packages feed

hsblst (empty) → 0.0.1

raw patch · 124 files changed

+93383/−0 lines, 124 filesdep +basedep +bytestringdep +deepseqsetup-changed

Dependencies added: base, bytestring, deepseq, hex-text, hsblst, memory, tasty, tasty-hunit, text

Files

+ CHANGELOG.md view
@@ -0,0 +1,8 @@+<!--+   - SPDX-FileCopyrightText: 2022 Serokell <https://serokell.io>+   - SPDX-License-Identifier: MPL-2.0+   -->++## v0.0.1++* Initial release
+ LICENSE view
@@ -0,0 +1,312 @@+Mozilla Public License Version 2.0++   1. Definitions++1.1. "Contributor" means each individual or legal entity that creates, contributes+to the creation of, or owns Covered Software.++1.2. "Contributor Version" means the combination of the Contributions of others+(if any) used by a Contributor and that particular Contributor's Contribution.++      1.3. "Contribution" means Covered Software of a particular Contributor.++1.4. "Covered Software" means Source Code Form to which the initial Contributor+has attached the notice in Exhibit A, the Executable Form of such Source Code+Form, and Modifications of such Source Code Form, in each case including portions+thereof.++      1.5. "Incompatible With Secondary Licenses" means++(a) that the initial Contributor has attached the notice described in Exhibit+B to the Covered Software; or++(b) that the Covered Software was made available under the terms of version+1.1 or earlier of the License, but not also under the terms of a Secondary+License.++1.6. "Executable Form" means any form of the work other than Source Code Form.++1.7. "Larger Work" means a work that combines Covered Software with other+material, in a separate file or files, that is not Covered Software.++      1.8. "License" means this document.++1.9. "Licensable" means having the right to grant, to the maximum extent possible,+whether at the time of the initial grant or subsequently, any and all of the+rights conveyed by this License.++      1.10. "Modifications" means any of the following:++(a) any file in Source Code Form that results from an addition to, deletion+from, or modification of the contents of Covered Software; or++(b) any new file in Source Code Form that contains any Covered Software.++1.11. "Patent Claims" of a Contributor means any patent claim(s), including+without limitation, method, process, and apparatus claims, in any patent Licensable+by such Contributor that would be infringed, but for the grant of the License,+by the making, using, selling, offering for sale, having made, import, or+transfer of either its Contributions or its Contributor Version.++1.12. "Secondary License" means either the GNU General Public License, Version+2.0, the GNU Lesser General Public License, Version 2.1, the GNU Affero General+Public License, Version 3.0, or any later versions of those licenses.++1.13. "Source Code Form" means the form of the work preferred for making modifications.++1.14. "You" (or "Your") means an individual or a legal entity exercising rights+under this License. For legal entities, "You" includes any entity that controls,+is controlled by, or is under common control with You. For purposes of this+definition, "control" means (a) the power, direct or indirect, to cause the+direction or management of such entity, whether by contract or otherwise,+or (b) ownership of more than fifty percent (50%) of the outstanding shares+or beneficial ownership of such entity.++   2. License Grants and Conditions++      2.1. Grants++Each Contributor hereby grants You a world-wide, royalty-free, non-exclusive+license:++(a) under intellectual property rights (other than patent or trademark) Licensable+by such Contributor to use, reproduce, make available, modify, display, perform,+distribute, and otherwise exploit its Contributions, either on an unmodified+basis, with Modifications, or as part of a Larger Work; and++(b) under Patent Claims of such Contributor to make, use, sell, offer for+sale, have made, import, and otherwise transfer either its Contributions or+its Contributor Version.++      2.2. Effective Date++The licenses granted in Section 2.1 with respect to any Contribution become+effective for each Contribution on the date the Contributor first distributes+such Contribution.++      2.3. Limitations on Grant Scope++The licenses granted in this Section 2 are the only rights granted under this+License. No additional rights or licenses will be implied from the distribution+or licensing of Covered Software under this License. Notwithstanding Section+2.1(b) above, no patent license is granted by a Contributor:++(a) for any code that a Contributor has removed from Covered Software; or++(b) for infringements caused by: (i) Your and any other third party's modifications+of Covered Software, or (ii) the combination of its Contributions with other+software (except as part of its Contributor Version); or++(c) under Patent Claims infringed by Covered Software in the absence of its+Contributions.++This License does not grant any rights in the trademarks, service marks, or+logos of any Contributor (except as may be necessary to comply with the notice+requirements in Section 3.4).++      2.4. Subsequent Licenses++No Contributor makes additional grants as a result of Your choice to distribute+the Covered Software under a subsequent version of this License (see Section+10.2) or under the terms of a Secondary License (if permitted under the terms+of Section 3.3).++      2.5. Representation++Each Contributor represents that the Contributor believes its Contributions+are its original creation(s) or it has sufficient rights to grant the rights+to its Contributions conveyed by this License.++      2.6. Fair Use++This License is not intended to limit any rights You have under applicable+copyright doctrines of fair use, fair dealing, or other equivalents.++      2.7. Conditions++Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in+Section 2.1.++   3. Responsibilities++      3.1. Distribution of Source Form++All distribution of Covered Software in Source Code Form, including any Modifications+that You create or to which You contribute, must be under the terms of this+License. You must inform recipients that the Source Code Form of the Covered+Software is governed by the terms of this License, and how they can obtain+a copy of this License. You may not attempt to alter or restrict the recipients'+rights in the Source Code Form.++      3.2. Distribution of Executable Form++      If You distribute Covered Software in Executable Form then:++(a) such Covered Software must also be made available in Source Code Form,+as described in Section 3.1, and You must inform recipients of the Executable+Form how they can obtain a copy of such Source Code Form by reasonable means+in a timely manner, at a charge no more than the cost of distribution to the+recipient; and++(b) You may distribute such Executable Form under the terms of this License,+or sublicense it under different terms, provided that the license for the+Executable Form does not attempt to limit or alter the recipients' rights+in the Source Code Form under this License.++      3.3. Distribution of a Larger Work++You may create and distribute a Larger Work under terms of Your choice, provided+that You also comply with the requirements of this License for the Covered+Software. If the Larger Work is a combination of Covered Software with a work+governed by one or more Secondary Licenses, and the Covered Software is not+Incompatible With Secondary Licenses, this License permits You to additionally+distribute such Covered Software under the terms of such Secondary License(s),+so that the recipient of the Larger Work may, at their option, further distribute+the Covered Software under the terms of either this License or such Secondary+License(s).++      3.4. Notices++You may not remove or alter the substance of any license notices (including+copyright notices, patent notices, disclaimers of warranty, or limitations+of liability) contained within the Source Code Form of the Covered Software,+except that You may alter any license notices to the extent required to remedy+known factual inaccuracies.++      3.5. Application of Additional Terms++You may choose to offer, and to charge a fee for, warranty, support, indemnity+or liability obligations to one or more recipients of Covered Software. However,+You may do so only on Your own behalf, and not on behalf of any Contributor.+You must make it absolutely clear that any such warranty, support, indemnity,+or liability obligation is offered by You alone, and You hereby agree to indemnify+every Contributor for any liability incurred by such Contributor as a result+of warranty, support, indemnity or liability terms You offer. You may include+additional disclaimers of warranty and limitations of liability specific to+any jurisdiction.++   4. Inability to Comply Due to Statute or Regulation++If it is impossible for You to comply with any of the terms of this License+with respect to some or all of the Covered Software due to statute, judicial+order, or regulation then You must: (a) comply with the terms of this License+to the maximum extent possible; and (b) describe the limitations and the code+they affect. Such description must be placed in a text file included with+all distributions of the Covered Software under this License. Except to the+extent prohibited by statute or regulation, such description must be sufficiently+detailed for a recipient of ordinary skill to be able to understand it.++   5. Termination++5.1. The rights granted under this License will terminate automatically if+You fail to comply with any of its terms. However, if You become compliant,+then the rights granted under this License from a particular Contributor are+reinstated (a) provisionally, unless and until such Contributor explicitly+and finally terminates Your grants, and (b) on an ongoing basis, if such Contributor+fails to notify You of the non-compliance by some reasonable means prior to+60 days after You have come back into compliance. Moreover, Your grants from+a particular Contributor are reinstated on an ongoing basis if such Contributor+notifies You of the non-compliance by some reasonable means, this is the first+time You have received notice of non-compliance with this License from such+Contributor, and You become compliant prior to 30 days after Your receipt+of the notice.++5.2. If You initiate litigation against any entity by asserting a patent infringement+claim (excluding declaratory judgment actions, counter-claims, and cross-claims)+alleging that a Contributor Version directly or indirectly infringes any patent,+then the rights granted to You by any and all Contributors for the Covered+Software under Section 2.1 of this License shall terminate.++5.3. In the event of termination under Sections 5.1 or 5.2 above, all end+user license agreements (excluding distributors and resellers) which have+been validly granted by You or Your distributors under this License prior+to termination shall survive termination.++   6. Disclaimer of Warranty++Covered Software is provided under this License on an "as is" basis, without+warranty of any kind, either expressed, implied, or statutory, including,+without limitation, warranties that the Covered Software is free of defects,+merchantable, fit for a particular purpose or non-infringing. The entire risk+as to the quality and performance of the Covered Software is with You. Should+any Covered Software prove defective in any respect, You (not any Contributor)+assume the cost of any necessary servicing, repair, or correction. This disclaimer+of warranty constitutes an essential part of this License. No use of any Covered+Software is authorized under this License except under this disclaimer.++   7. Limitation of Liability++Under no circumstances and under no legal theory, whether tort (including+negligence), contract, or otherwise, shall any Contributor, or anyone who+distributes Covered Software as permitted above, be liable to You for any+direct, indirect, special, incidental, or consequential damages of any character+including, without limitation, damages for lost profits, loss of goodwill,+work stoppage, computer failure or malfunction, or any and all other commercial+damages or losses, even if such party shall have been informed of the possibility+of such damages. This limitation of liability shall not apply to liability+for death or personal injury resulting from such party's negligence to the+extent applicable law prohibits such limitation. Some jurisdictions do not+allow the exclusion or limitation of incidental or consequential damages,+so this exclusion and limitation may not apply to You.++   8. Litigation++Any litigation relating to this License may be brought only in the courts+of a jurisdiction where the defendant maintains its principal place of business+and such litigation shall be governed by laws of that jurisdiction, without+reference to its conflict-of-law provisions. Nothing in this Section shall+prevent a party's ability to bring cross-claims or counter-claims.++   9. Miscellaneous++This License represents the complete agreement concerning the subject matter+hereof. If any provision of this License is held to be unenforceable, such+provision shall be reformed only to the extent necessary to make it enforceable.+Any law or regulation which provides that the language of a contract shall+be construed against the drafter shall not be used to construe this License+against a Contributor.++   10. Versions of the License++      10.1. New Versions++Mozilla Foundation is the license steward. Except as provided in Section 10.3,+no one other than the license steward has the right to modify or publish new+versions of this License. Each version will be given a distinguishing version+number.++      10.2. Effect of New Versions++You may distribute the Covered Software under the terms of the version of+the License under which You originally received the Covered Software, or under+the terms of any subsequent version published by the license steward.++      10.3. Modified Versions++If you create software not governed by this License, and you want to create+a new license for such software, you may create and use a modified version+of this License if you rename the license and remove any references to the+name of the license steward (except to note that such modified license differs+from this License).++10.4. Distributing Source Code Form that is Incompatible With Secondary Licenses++If You choose to distribute Source Code Form that is Incompatible With Secondary+Licenses under the terms of this version of the License, the notice described+in Exhibit B of this License must be attached. Exhibit A - Source Code Form+License Notice++This Source Code Form is subject to the terms of the Mozilla Public License,+v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain+one at http://mozilla.org/MPL/2.0/.++If it is not possible or desirable to put the notice in a particular file,+then You may include the notice in a location (such as a LICENSE file in a+relevant directory) where a recipient would be likely to look for such a notice.++You may add additional accurate notices of copyright ownership.++Exhibit B - "Incompatible With Secondary Licenses" Notice++This Source Code Form is "Incompatible With Secondary Licenses", as defined+by the Mozilla Public License, v. 2.0.
+ README.md view
@@ -0,0 +1,31 @@+<!--+   - SPDX-FileCopyrightText: 2022 Serokell <https://serokell.io>+   - SPDX-License-Identifier: MPL-2.0+   -->+# HsBLST++[![License: MPL 2.0](https://img.shields.io/badge/License-MPL%202.0-brightgreen.svg)](https://opensource.org/licenses/MPL-2.0)++HsBLST is low-level Haskell bindings and a high-level interface to [BLST](https://github.com/supranational/blst) -- a multilingual BLS12-381 signature library.++This package includes sources from v0.3.10 version of BLST, licensed under+[Apache License 2.0](https://github.com/supranational/blst/blob/master/LICENSE)++## Build Instructions [↑](#hsblst)++Run `make` to build everything.++## Usage [↑](#hsblst)++See Haddock documentation.++## For Contributors [↑](#hsblst)++Please see [CONTRIBUTING.md](CONTRIBUTING.md) for more information.++## About Serokell [↑](#hsblst)++HsBLST is maintained and funded with ❤️ by [Serokell](https://serokell.io/).+The names and logo for Serokell are trademark of Serokell OÜ.++We love open source software! See [our other projects](https://serokell.io/community?utm_source=github) or [hire us](https://serokell.io/hire-us?utm_source=github) to design, develop and grow your idea!
+ Setup.hs view
@@ -0,0 +1,5 @@+-- SPDX-FileCopyrightText: 2022 Serokell <https://serokell.io>+-- SPDX-License-Identifier: CC0-1.0++import Distribution.Simple+main = defaultMain
+ c-source/LICENSE view
@@ -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.
+ c-source/README.md view
@@ -0,0 +1,221 @@+[![Build Status](https://travis-ci.com/supranational/blst.svg?branch=master)](https://travis-ci.com/github/supranational/blst) [![Actions status](https://github.com/supranational/blst/workflows/build/badge.svg)](https://github.com/supranational/blst/actions) [![Total alerts](https://img.shields.io/lgtm/alerts/g/supranational/blst.svg?logo=lgtm&logoWidth=18)](https://lgtm.com/projects/g/supranational/blst/alerts/)+<div align="left">+  <img src=blst_logo_small.png>+</div>++# blst+blst (pronounced 'blast') is a BLS12-381 signature library focused on performance and security. It is written in C and assembly.++## Table of Contents++  * [Status](#status)+  * [General notes on implementation](#general-notes-on-implementation)+  * [Platform and Language Compatibility](#platform-and-language-compatibility)+  * [API](#api)+  * [Introductory Tutorial](#introductory-tutorial)+    + [Public Keys and Signatures](#public-keys-and-signatures)+    + [Signature Verification](#signature-verification)+    + [Signature Aggregation](#signature-aggregation)+    + [Serialization Format](#serialization-format)+  * [Build](#build)+    + [C static library](#c-static-library)+  * [Language-specific notes](#language-specific-notes)+    + [Go](#go)+    + [Rust](#rust)+  * [Repository Structure](#repository-structure)+  * [Performance](#performance)+  * [License](#license)++## Status+**This library is under active development**++An initial audit of this library was conducted by NCC Group in January 2021 and can be found [here](https://research.nccgroup.com/wp-content/uploads/2021/01/NCC_Group_EthereumFoundation_ETHF002_Report_2021-01-20_v1.0.pdf).++Formal verification of this library by Galois is on-going and can be found [here](https://github.com/GaloisInc/BLST-Verification).++This library is compliant with the following IETF draft specifications:+- [IETF BLS Signature V5](https://tools.ietf.org/html/draft-irtf-cfrg-bls-signature)+- [IETF Hash-to-Curve V16](https://tools.ietf.org/html/draft-irtf-cfrg-hash-to-curve)++The serialization formatting is implemented according to [the ZCash definition](#serialization-format).++## General notes on implementation+The goal of the blst library is to provide a foundational component for applications and other libraries that require high performance and formally verified BLS12-381 operations. With that in mind some decisions are made to maximize the public good beyond BLS12-381. For example, the field operations are optimized for general 384-bit usage, as opposed to tuned specifically for the 381-bit BLS12-381 curve parameters. With the formal verification of these foundational components, we believe they can provide a reliable building block for other curves that would like high performance and an extra element of security.++The library deliberately abstains from dealing with memory management and multi-threading, with the rationale that these ultimately belong in language-specific bindings. Another responsibility that is left to application is random number generation. All this in the name of run-time neutrality, which makes integration into more stringent environments like Intel SGX or ARM TrustZone trivial.++## Platform and Language Compatibility++This library primarily supports x86_64 and ARM64 hardware platforms, and Linux, Mac, and Windows operating systems. But it does have a portable replacement for the assembly modules, which can be compiled for a plethora of other platforms. Problem reports for these will be considered and are likely to be addressed.++This repository includes explicit bindings for:+- [Go](bindings/go)+- [Rust](bindings/rust)++Unless deemed appropriate to implement, bindings for other languages will be provided using [SWIG](http://swig.org). Proof-of-concept scripts are available for:+- [Python](bindings/python)+- [Java](bindings/java)+- [Node.js](bindings/node.js)++## API++The blst API is defined in the C header [bindings/blst.h](bindings/blst.h). The API can be categorized as follows, with some example operations:+- Field Operations (add, sub, mul, neg, inv, to/from Montgomery)+- Curve Operations (add, double, mul, to/from affine, group check)+- Intermediate (hash to curve, pairing, serdes)+- BLS12-381 signature (sign, verify, aggregate)++Note: there is also an auxiliary header file, [bindings/blst_aux.h](bindings/blst_aux.h), that is used as a staging area for experimental interfaces that may or may not get promoted to blst.h.++## Introductory Tutorial++Programming is understanding, and understanding implies mastering the lingo. So we have a pair of additive groups being mapped to multiplicative one... What does it mean? Well, this tutorial is not about explaining that, but rather about making the connection between what you're supposed to know about [pairing-based cryptography](https://en.wikipedia.org/wiki/Pairing-based_cryptography) and the interface provided by the library.++### Public Keys and Signatures++We have two elliptic curves, E1 and E2, points on which are contained in `blst_p1` and `blst_p2`, or `blst_p1_affine` and `blst_p2_affine` structures. Elements in the multiplicative group are held in a `blst_fp12` structure. One of the curves, or more specifically, a subset of points that form a cyclic group, is chosen for public keys, and another, for signatures. The choice is denoted by the subroutines' suffixes, `_pk_in_g1` or `_pk_in_g2`. The most common choice appears to be the former, that is, `blst_p1` for public keys, and `blst_p2` for signatures. But it all starts with a secret key...++The secret key is held in a 256-bit `blst_scalar` structure which can be instantiated with either [`blst_keygen`](https://tools.ietf.org/html/draft-irtf-cfrg-bls-signature#section-2.3), or deserialized with `blst_scalar_from_bendian` or `blst_scalar_from_lendian` from a previously serialized byte sequence. It shouldn't come as surprise that there are two uses for a secret key:++- generating the associated public key, either with `blst_sk_to_pk_in_g1` or `blst_sk_to_pk_in_g2`;+- performing a sign operation, either with `blst_sign_pk_in_g1` or `blst_sign_pk_in_g2`;++As for signing, unlike what your intuition might suggest, `blst_sign_*` doesn't sign a message, but rather a point on the corresponding elliptic curve. You can obtain this point from a message by calling `blst_hash_to_g2` or `blst_encode_to_g2` (see the [IETF hash-to-curve](https://tools.ietf.org/html/draft-irtf-cfrg-hash-to-curve#section-3) draft for distinction). Another counter-intuitive aspect is the apparent g1 vs. g2 naming mismatch, in the sense that `blst_sign_pk_in_g1` accepts output from `blst_hash_to_g2`, and `blst_sign_pk_in_g2` accepts output from `blst_hash_to_g1`. This is because, as you should recall, public keys and signatures come from complementary groups.++Now that you have a public key and signature, as points on corresponding elliptic curves, you can serialize them with `blst_p1_serialize`/`blst_p1_compress` and `blst_p2_serialize`/`blst_p2_compress` and send the resulting byte sequences over the network for deserialization/uncompression and verification.++### Signature Verification++Even though there are "single-shot" `blst_core_verify_pk_in_g1` and `blst_core_verify_pk_in_g2`, you should really familiarize yourself with the more generalized pairing interface. `blst_pairing` is an opaque structure, and the only thing you know about it is `blst_pairing_sizeof`, which is how much memory you're supposed to allocate for it. In order to verify an aggregated signature for a set of public keys and messages, or just one[!], you would:+```+blst_pairing_init(ctx, hash_or_encode, domain_separation_tag);+blst_pairing_aggregate_pk_in_g1(ctx, PK[0], aggregated_signature, message[0]);+blst_pairing_aggregate_pk_in_g1(ctx, PK[1], NULL, message[1]);+...+blst_pairing_commit(ctx);+result = blst_pairing_finalverify(ctx, NULL);+```+**The essential point to note** is that it's the caller's responsibility to ensure that public keys are group-checked with `blst_p1_affine_in_g1`. This is because it's a relatively expensive operation and it's naturally assumed that the application would cache the check's outcome. Signatures are group-checked internally. Not shown in the pseudo-code snippet above, but `aggregate` and `commit` calls return `BLST_ERROR` denoting success or failure in performing the operation. Call to `finalverify`, on the other hand, returns boolean.++Another, potentially more useful usage pattern is:+```+blst_p2_affine_in_g2(signature);+blst_aggregated_in_g2(gtsig, signature);+blst_pairing_init(ctx, hash_or_encode, domain_separation_tag);+blst_pairing_aggregate_pk_in_g1(ctx, PK[0], NULL, message[0]);+blst_pairing_aggregate_pk_in_g1(ctx, PK[1], NULL, message[1]);+...+blst_pairing_commit(ctx);+result = blst_pairing_finalverify(ctx, gtsig);+```+What is useful about it is that `aggregated_signature` can be handled in a separate thread. And while we are at it, aggregate calls can also be executed in different threads. This naturally implies that each thread will operate on its own `blst_pairing` context, which will have to be combined with `blst_pairing_merge` as threads join.++### Signature Aggregation++Aggregation is a trivial operation of performing point additions, with `blst_p2_add_or_double_affine` or `blst_p1_add_or_double_affine`. Note that the accumulator is a non-affine point.++---++That's about what you need to know to get started with nitty-gritty of actual function declarations.++### Serialization Format++From the ZCash BLS12-381 specification++* Fq elements are encoded in big-endian form. They occupy 48 bytes in this form.+* Fq2 elements are encoded in big-endian form, meaning that the Fq2 element c0 + c1 * u is represented by the Fq element c1 followed by the Fq element c0. This means Fq2 elements occupy 96 bytes in this form.+* The group G1 uses Fq elements for coordinates. The group G2 uses Fq2 elements for coordinates.+* G1 and G2 elements can be encoded in uncompressed form (the x-coordinate followed by the y-coordinate) or in compressed form (just the x-coordinate). G1 elements occupy 96 bytes in uncompressed form, and 48 bytes in compressed form. G2 elements occupy 192 bytes in uncompressed form, and 96 bytes in compressed form.++The most-significant three bits of a G1 or G2 encoding should be masked away before the coordinate(s) are interpreted. These bits are used to unambiguously represent the underlying element:++* The most significant bit, when set, indicates that the point is in compressed form. Otherwise, the point is in uncompressed form.+* The second-most significant bit indicates that the point is at infinity. If this bit is set, the remaining bits of the group element's encoding should be set to zero.+* The third-most significant bit is set if (and only if) this point is in compressed form _and_ it is not the point at infinity _and_ its y-coordinate is the lexicographically largest of the two associated with the encoded x-coordinate.++## Build+The build process is very simple and only requires a C complier. It's integrated into the Go and Rust ecosystems, so that respective users would go about as they would with any other external module. Otherwise, a binary library would have to be compiled.++### C static library+A static library called libblst.a can be built in the current working directory of the user's choice:++Linux, Mac, and Windows (in MinGW or Cygwin environments)+```+/some/where/build.sh+```++Windows (Visual C)+```+\some\where\build.bat+```++If final application crashes with an "illegal instruction" exception [after copying to another system], pass <nobr>`-D__BLST_PORTABLE__`</nobr> on `build.sh` command line. If you don't use build.sh, complement the `CFLAGS` environment variable with the said command line option. If you compile a Go application, you will need to modify the `CGO_CFLAGS` variable instead. And if you compile a Rust application, you can pass <nobr>`--features portable`</nobr> to `cargo build`. Alternatively, if you compile on an older Intel system, but will execute application on a newer one, consider instead passing <nobr>`--features force-adx`</nobr> for better performance.++## Language-specific notes++### [Go](bindings/go)+There are two primary modes of operation that can be chosen based on type definitions in the application.++For minimal-pubkey-size operations:+```+type PublicKey = blst.P1Affine+type Signature = blst.P2Affine+type AggregateSignature = blst.P2Aggregate+type AggregatePublicKey = blst.P1Aggregate+```++For minimal-signature-size operations:+```+type PublicKey = blst.P2Affine+type Signature = blst.P1Affine+type AggregateSignature = blst.P1Aggregate+type AggregatePublicKey = blst.P2Aggregate+```++For more details see the Go binding [readme](bindings/go/README.md).++### [Rust](bindings/rust)+[`blst`](https://crates.io/crates/blst) is the Rust binding crate.++To use min-pk version:+```+use blst::min_pk::*;+```++To use min-sig version:+```+use blst::min_sig::*;+```++For more details see the Rust binding [readme](bindings/rust/README.md).++## Repository Structure++**Root** - Contains various configuration files, documentation, licensing, and a build script+* **Bindings** - Contains the files that define the blst interface+    * blst.h - provides C API to blst library+    * blst_aux.h - contains experimental functions not yet committed for long-term maintenance+    * blst.hpp - provides foundational class-oriented C++ interface to blst library+    * blst.swg - provides SWIG definitions for creating blst bindings for other languages, such as Java and Python+    * **Go** - folder containing Go bindings for blst, including tests and benchmarks+    * **Java** - folder containing an example of how to use SWIG Java bindings for blst+    * **Node.js** - folder containing an example of how to use SWIG Javascript bindings for blst+    * **Python** - folder containing an example of how to use SWIG Python bindings for blst+    * **Rust** - folder containing Rust bindings for blst, including tests and benchmarks+    * **Vectors**+        * **Hash_to_curve**: folder containing test for hash_to_curve from IETF specification+* **Src** - folder containing C code for lower level blst functions such as field operations, extension field operations, hash-to-field, and more+    * **Asm** - folder containing Perl scripts that are used to generate assembly code for different hardware platforms including x86 with ADX instructions, x86 without ADX instructions, and ARMv8, and [ABI](https://en.wikipedia.org/wiki/Application_binary_interface)[1]+* **Build** - this folder containing a set of pre-generated assembly files for a variety of operating systems and maintenance scripts.+    * **Coff** - assembly code for use on Window systems with GNU toolchain+    * **Elf** - assembly code for use on Unix systems+    * **Mach-o** - assembly code for use on Apple operating systems+    * **Win64** - assembly code for use on Windows systems with Microsoft toolchain++[1]: See [refresh.sh](build/refresh.sh) for usage. This method allows for simple reuse of optimized assembly across various platforms with minimal effort.++## Performance+Currently both the [Go](bindings/go) and [Rust](bindings/rust) bindings provide benchmarks for a variety of signature related operations.++## License+The blst library is licensed under the [Apache License Version 2.0](LICENSE) software license.
+ c-source/bindings/blst.h view
@@ -0,0 +1,479 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */+#ifndef __BLST_H__+#define __BLST_H__++#ifdef __SIZE_TYPE__+typedef __SIZE_TYPE__ size_t;+#else+#include <stddef.h>+#endif++#if defined(__UINT8_TYPE__) && defined(__UINT32_TYPE__) \+                            && defined(__UINT64_TYPE__)+typedef __UINT8_TYPE__  uint8_t;+typedef __UINT32_TYPE__ uint32_t;+typedef __UINT64_TYPE__ uint64_t;+#else+#include <stdint.h>+#endif++#ifdef __cplusplus+extern "C" {+#elif defined(__BLST_CGO__)+typedef _Bool bool; /* it's assumed that cgo calls modern enough compiler */+#elif defined(__STDC_VERSION__) && __STDC_VERSION__>=199901+# define bool _Bool+#else+# define bool int+#endif++#ifdef SWIG+# define DEFNULL =NULL+#elif defined __cplusplus+# define DEFNULL =0+#else+# define DEFNULL+#endif++typedef enum {+    BLST_SUCCESS = 0,+    BLST_BAD_ENCODING,+    BLST_POINT_NOT_ON_CURVE,+    BLST_POINT_NOT_IN_GROUP,+    BLST_AGGR_TYPE_MISMATCH,+    BLST_VERIFY_FAIL,+    BLST_PK_IS_INFINITY,+    BLST_BAD_SCALAR,+} BLST_ERROR;++typedef uint8_t byte;+typedef uint64_t limb_t;++typedef struct { byte b[256/8]; } blst_scalar;+typedef struct { limb_t l[256/8/sizeof(limb_t)]; } blst_fr;+typedef struct { limb_t l[384/8/sizeof(limb_t)]; } blst_fp;+/* 0 is "real" part, 1 is "imaginary" */+typedef struct { blst_fp fp[2]; } blst_fp2;+typedef struct { blst_fp2 fp2[3]; } blst_fp6;+typedef struct { blst_fp6 fp6[2]; } blst_fp12;++void blst_scalar_from_uint32(blst_scalar *out, const uint32_t a[8]);+void blst_uint32_from_scalar(uint32_t out[8], const blst_scalar *a);+void blst_scalar_from_uint64(blst_scalar *out, const uint64_t a[4]);+void blst_uint64_from_scalar(uint64_t out[4], const blst_scalar *a);+void blst_scalar_from_bendian(blst_scalar *out, const byte a[32]);+void blst_bendian_from_scalar(byte out[32], const blst_scalar *a);+void blst_scalar_from_lendian(blst_scalar *out, const byte a[32]);+void blst_lendian_from_scalar(byte out[32], const blst_scalar *a);+bool blst_scalar_fr_check(const blst_scalar *a);+bool blst_sk_check(const blst_scalar *a);+bool blst_sk_add_n_check(blst_scalar *out, const blst_scalar *a,+                                           const blst_scalar *b);+bool blst_sk_sub_n_check(blst_scalar *out, const blst_scalar *a,+                                           const blst_scalar *b);+bool blst_sk_mul_n_check(blst_scalar *out, const blst_scalar *a,+                                           const blst_scalar *b);+void blst_sk_inverse(blst_scalar *out, const blst_scalar *a);+bool blst_scalar_from_le_bytes(blst_scalar *out, const byte *in, size_t len);+bool blst_scalar_from_be_bytes(blst_scalar *out, const byte *in, size_t len);++#ifndef SWIG+/*+ * BLS12-381-specifc Fr operations.+ */+void blst_fr_add(blst_fr *ret, const blst_fr *a, const blst_fr *b);+void blst_fr_sub(blst_fr *ret, const blst_fr *a, const blst_fr *b);+void blst_fr_mul_by_3(blst_fr *ret, const blst_fr *a);+void blst_fr_lshift(blst_fr *ret, const blst_fr *a, size_t count);+void blst_fr_rshift(blst_fr *ret, const blst_fr *a, size_t count);+void blst_fr_mul(blst_fr *ret, const blst_fr *a, const blst_fr *b);+void blst_fr_sqr(blst_fr *ret, const blst_fr *a);+void blst_fr_cneg(blst_fr *ret, const blst_fr *a, bool flag);+void blst_fr_eucl_inverse(blst_fr *ret, const blst_fr *a);+void blst_fr_inverse(blst_fr *ret, const blst_fr *a);++void blst_fr_from_uint64(blst_fr *ret, const uint64_t a[4]);+void blst_uint64_from_fr(uint64_t ret[4], const blst_fr *a);+void blst_fr_from_scalar(blst_fr *ret, const blst_scalar *a);+void blst_scalar_from_fr(blst_scalar *ret, const blst_fr *a);++/*+ * BLS12-381-specifc Fp operations.+ */+void blst_fp_add(blst_fp *ret, const blst_fp *a, const blst_fp *b);+void blst_fp_sub(blst_fp *ret, const blst_fp *a, const blst_fp *b);+void blst_fp_mul_by_3(blst_fp *ret, const blst_fp *a);+void blst_fp_mul_by_8(blst_fp *ret, const blst_fp *a);+void blst_fp_lshift(blst_fp *ret, const blst_fp *a, size_t count);+void blst_fp_mul(blst_fp *ret, const blst_fp *a, const blst_fp *b);+void blst_fp_sqr(blst_fp *ret, const blst_fp *a);+void blst_fp_cneg(blst_fp *ret, const blst_fp *a, bool flag);+void blst_fp_eucl_inverse(blst_fp *ret, const blst_fp *a);+void blst_fp_inverse(blst_fp *ret, const blst_fp *a);+bool blst_fp_sqrt(blst_fp *ret, const blst_fp *a);++void blst_fp_from_uint32(blst_fp *ret, const uint32_t a[12]);+void blst_uint32_from_fp(uint32_t ret[12], const blst_fp *a);+void blst_fp_from_uint64(blst_fp *ret, const uint64_t a[6]);+void blst_uint64_from_fp(uint64_t ret[6], const blst_fp *a);+void blst_fp_from_bendian(blst_fp *ret, const byte a[48]);+void blst_bendian_from_fp(byte ret[48], const blst_fp *a);+void blst_fp_from_lendian(blst_fp *ret, const byte a[48]);+void blst_lendian_from_fp(byte ret[48], const blst_fp *a);++/*+ * BLS12-381-specifc Fp2 operations.+ */+void blst_fp2_add(blst_fp2 *ret, const blst_fp2 *a, const blst_fp2 *b);+void blst_fp2_sub(blst_fp2 *ret, const blst_fp2 *a, const blst_fp2 *b);+void blst_fp2_mul_by_3(blst_fp2 *ret, const blst_fp2 *a);+void blst_fp2_mul_by_8(blst_fp2 *ret, const blst_fp2 *a);+void blst_fp2_lshift(blst_fp2 *ret, const blst_fp2 *a, size_t count);+void blst_fp2_mul(blst_fp2 *ret, const blst_fp2 *a, const blst_fp2 *b);+void blst_fp2_sqr(blst_fp2 *ret, const blst_fp2 *a);+void blst_fp2_cneg(blst_fp2 *ret, const blst_fp2 *a, bool flag);+void blst_fp2_eucl_inverse(blst_fp2 *ret, const blst_fp2 *a);+void blst_fp2_inverse(blst_fp2 *ret, const blst_fp2 *a);+bool blst_fp2_sqrt(blst_fp2 *ret, const blst_fp2 *a);++/*+ * BLS12-381-specifc Fp12 operations.+ */+void blst_fp12_sqr(blst_fp12 *ret, const blst_fp12 *a);+void blst_fp12_cyclotomic_sqr(blst_fp12 *ret, const blst_fp12 *a);+void blst_fp12_mul(blst_fp12 *ret, const blst_fp12 *a, const blst_fp12 *b);+void blst_fp12_mul_by_xy00z0(blst_fp12 *ret, const blst_fp12 *a,+                                             const blst_fp6 *xy00z0);+void blst_fp12_conjugate(blst_fp12 *a);+void blst_fp12_inverse(blst_fp12 *ret, const blst_fp12 *a);+/* caveat lector! |n| has to be non-zero and not more than 3! */+void blst_fp12_frobenius_map(blst_fp12 *ret, const blst_fp12 *a, size_t n);+bool blst_fp12_is_equal(const blst_fp12 *a, const blst_fp12 *b);+bool blst_fp12_is_one(const blst_fp12 *a);+bool blst_fp12_in_group(const blst_fp12 *a);+const blst_fp12 *blst_fp12_one();+#endif  // SWIG++/*+ * BLS12-381-specifc point operations.+ */+typedef struct { blst_fp x, y, z; } blst_p1;+typedef struct { blst_fp x, y; } blst_p1_affine;++void blst_p1_add(blst_p1 *out, const blst_p1 *a, const blst_p1 *b);+void blst_p1_add_or_double(blst_p1 *out, const blst_p1 *a, const blst_p1 *b);+void blst_p1_add_affine(blst_p1 *out, const blst_p1 *a,+                                      const blst_p1_affine *b);+void blst_p1_add_or_double_affine(blst_p1 *out, const blst_p1 *a,+                                                const blst_p1_affine *b);+void blst_p1_double(blst_p1 *out, const blst_p1 *a);+void blst_p1_mult(blst_p1 *out, const blst_p1 *p, const byte *scalar,+                                                  size_t nbits);+void blst_p1_cneg(blst_p1 *p, bool cbit);+void blst_p1_to_affine(blst_p1_affine *out, const blst_p1 *in);+void blst_p1_from_affine(blst_p1 *out, const blst_p1_affine *in);+bool blst_p1_on_curve(const blst_p1 *p);+bool blst_p1_in_g1(const blst_p1 *p);+bool blst_p1_is_equal(const blst_p1 *a, const blst_p1 *b);+bool blst_p1_is_inf(const blst_p1 *a);+const blst_p1 *blst_p1_generator();++bool blst_p1_affine_on_curve(const blst_p1_affine *p);+bool blst_p1_affine_in_g1(const blst_p1_affine *p);+bool blst_p1_affine_is_equal(const blst_p1_affine *a, const blst_p1_affine *b);+bool blst_p1_affine_is_inf(const blst_p1_affine *a);+const blst_p1_affine *blst_p1_affine_generator();++typedef struct { blst_fp2 x, y, z; } blst_p2;+typedef struct { blst_fp2 x, y; } blst_p2_affine;++void blst_p2_add(blst_p2 *out, const blst_p2 *a, const blst_p2 *b);+void blst_p2_add_or_double(blst_p2 *out, const blst_p2 *a, const blst_p2 *b);+void blst_p2_add_affine(blst_p2 *out, const blst_p2 *a,+                                      const blst_p2_affine *b);+void blst_p2_add_or_double_affine(blst_p2 *out, const blst_p2 *a,+                                                const blst_p2_affine *b);+void blst_p2_double(blst_p2 *out, const blst_p2 *a);+void blst_p2_mult(blst_p2 *out, const blst_p2 *p, const byte *scalar,+                                                  size_t nbits);+void blst_p2_cneg(blst_p2 *p, bool cbit);+void blst_p2_to_affine(blst_p2_affine *out, const blst_p2 *in);+void blst_p2_from_affine(blst_p2 *out, const blst_p2_affine *in);+bool blst_p2_on_curve(const blst_p2 *p);+bool blst_p2_in_g2(const blst_p2 *p);+bool blst_p2_is_equal(const blst_p2 *a, const blst_p2 *b);+bool blst_p2_is_inf(const blst_p2 *a);+const blst_p2 *blst_p2_generator();++bool blst_p2_affine_on_curve(const blst_p2_affine *p);+bool blst_p2_affine_in_g2(const blst_p2_affine *p);+bool blst_p2_affine_is_equal(const blst_p2_affine *a, const blst_p2_affine *b);+bool blst_p2_affine_is_inf(const blst_p2_affine *a);+const blst_p2_affine *blst_p2_affine_generator();++/*+ * Multi-scalar multiplications and other multi-point operations.+ */++void blst_p1s_to_affine(blst_p1_affine dst[], const blst_p1 *const points[],+                        size_t npoints);+void blst_p1s_add(blst_p1 *ret, const blst_p1_affine *const points[],+                                size_t npoints);++size_t blst_p1s_mult_wbits_precompute_sizeof(size_t wbits, size_t npoints);+void blst_p1s_mult_wbits_precompute(blst_p1_affine table[], size_t wbits,+                                    const blst_p1_affine *const points[],+                                    size_t npoints);+size_t blst_p1s_mult_wbits_scratch_sizeof(size_t npoints);+void blst_p1s_mult_wbits(blst_p1 *ret, const blst_p1_affine table[],+                         size_t wbits, size_t npoints,+                         const byte *const scalars[], size_t nbits,+                         limb_t *scratch);++size_t blst_p1s_mult_pippenger_scratch_sizeof(size_t npoints);+void blst_p1s_mult_pippenger(blst_p1 *ret, const blst_p1_affine *const points[],+                             size_t npoints, const byte *const scalars[],+                             size_t nbits, limb_t *scratch);+void blst_p1s_tile_pippenger(blst_p1 *ret, const blst_p1_affine *const points[],+                             size_t npoints, const byte *const scalars[],+                             size_t nbits, limb_t *scratch,+                             size_t bit0, size_t window);++void blst_p2s_to_affine(blst_p2_affine dst[], const blst_p2 *const points[],+                        size_t npoints);+void blst_p2s_add(blst_p2 *ret, const blst_p2_affine *const points[],+                                size_t npoints);++size_t blst_p2s_mult_wbits_precompute_sizeof(size_t wbits, size_t npoints);+void blst_p2s_mult_wbits_precompute(blst_p2_affine table[], size_t wbits,+                                    const blst_p2_affine *const points[],+                                    size_t npoints);+size_t blst_p2s_mult_wbits_scratch_sizeof(size_t npoints);+void blst_p2s_mult_wbits(blst_p2 *ret, const blst_p2_affine table[],+                         size_t wbits, size_t npoints,+                         const byte *const scalars[], size_t nbits,+                         limb_t *scratch);++size_t blst_p2s_mult_pippenger_scratch_sizeof(size_t npoints);+void blst_p2s_mult_pippenger(blst_p2 *ret, const blst_p2_affine *const points[],+                             size_t npoints, const byte *const scalars[],+                             size_t nbits, limb_t *scratch);+void blst_p2s_tile_pippenger(blst_p2 *ret, const blst_p2_affine *const points[],+                             size_t npoints, const byte *const scalars[],+                             size_t nbits, limb_t *scratch,+                             size_t bit0, size_t window);++/*+ * Hash-to-curve operations.+ */+#ifndef SWIG+void blst_map_to_g1(blst_p1 *out, const blst_fp *u, const blst_fp *v DEFNULL);+void blst_map_to_g2(blst_p2 *out, const blst_fp2 *u, const blst_fp2 *v DEFNULL);+#endif++void blst_encode_to_g1(blst_p1 *out,+                       const byte *msg, size_t msg_len,+                       const byte *DST DEFNULL, size_t DST_len DEFNULL,+                       const byte *aug DEFNULL, size_t aug_len DEFNULL);+void blst_hash_to_g1(blst_p1 *out,+                     const byte *msg, size_t msg_len,+                     const byte *DST DEFNULL, size_t DST_len DEFNULL,+                     const byte *aug DEFNULL, size_t aug_len DEFNULL);++void blst_encode_to_g2(blst_p2 *out,+                       const byte *msg, size_t msg_len,+                       const byte *DST DEFNULL, size_t DST_len DEFNULL,+                       const byte *aug DEFNULL, size_t aug_len DEFNULL);+void blst_hash_to_g2(blst_p2 *out,+                     const byte *msg, size_t msg_len,+                     const byte *DST DEFNULL, size_t DST_len DEFNULL,+                     const byte *aug DEFNULL, size_t aug_len DEFNULL);++/*+ * Zcash-compatible serialization/deserialization.+ */+void blst_p1_serialize(byte out[96], const blst_p1 *in);+void blst_p1_compress(byte out[48], const blst_p1 *in);+void blst_p1_affine_serialize(byte out[96], const blst_p1_affine *in);+void blst_p1_affine_compress(byte out[48], const blst_p1_affine *in);+BLST_ERROR blst_p1_uncompress(blst_p1_affine *out, const byte in[48]);+BLST_ERROR blst_p1_deserialize(blst_p1_affine *out, const byte in[96]);++void blst_p2_serialize(byte out[192], const blst_p2 *in);+void blst_p2_compress(byte out[96], const blst_p2 *in);+void blst_p2_affine_serialize(byte out[192], const blst_p2_affine *in);+void blst_p2_affine_compress(byte out[96], const blst_p2_affine *in);+BLST_ERROR blst_p2_uncompress(blst_p2_affine *out, const byte in[96]);+BLST_ERROR blst_p2_deserialize(blst_p2_affine *out, const byte in[192]);++/*+ * Specification defines two variants, 'minimal-signature-size' and+ * 'minimal-pubkey-size'. To unify appearance we choose to distinguish+ * them by suffix referring to the public key type, more specifically+ * _pk_in_g1 corresponds to 'minimal-pubkey-size' and _pk_in_g2 - to+ * 'minimal-signature-size'. It might appear a bit counterintuitive+ * in sign call, but no matter how you twist it, something is bound to+ * turn a little odd.+ */+/*+ * Secret-key operations.+ */+void blst_keygen(blst_scalar *out_SK, const byte *IKM, size_t IKM_len,+                 const byte *info DEFNULL, size_t info_len DEFNULL);+void blst_sk_to_pk_in_g1(blst_p1 *out_pk, const blst_scalar *SK);+void blst_sign_pk_in_g1(blst_p2 *out_sig, const blst_p2 *hash,+                                          const blst_scalar *SK);+void blst_sk_to_pk_in_g2(blst_p2 *out_pk, const blst_scalar *SK);+void blst_sign_pk_in_g2(blst_p1 *out_sig, const blst_p1 *hash,+                                          const blst_scalar *SK);++/*+ * Pairing interface.+ */+#ifndef SWIG+void blst_miller_loop(blst_fp12 *ret, const blst_p2_affine *Q,+                                      const blst_p1_affine *P);+void blst_final_exp(blst_fp12 *ret, const blst_fp12 *f);+void blst_precompute_lines(blst_fp6 Qlines[68], const blst_p2_affine *Q);+void blst_miller_loop_lines(blst_fp12 *ret, const blst_fp6 Qlines[68],+                                            const blst_p1_affine *P);+bool blst_fp12_finalverify(const blst_fp12 *gt1, const blst_fp12 *gt2);+#endif++#ifdef __BLST_CGO__+typedef limb_t blst_pairing;+#elif defined(__BLST_RUST_BINDGEN__)+typedef struct {} blst_pairing;+#else+typedef struct blst_opaque blst_pairing;+#endif++size_t blst_pairing_sizeof();+void blst_pairing_init(blst_pairing *new_ctx, bool hash_or_encode,+                       const byte *DST DEFNULL, size_t DST_len DEFNULL);+const byte *blst_pairing_get_dst(const blst_pairing *ctx);+void blst_pairing_commit(blst_pairing *ctx);+BLST_ERROR blst_pairing_aggregate_pk_in_g2(blst_pairing *ctx,+                                           const blst_p2_affine *PK,+                                           const blst_p1_affine *signature,+                                           const byte *msg, size_t msg_len,+                                           const byte *aug DEFNULL,+                                           size_t aug_len DEFNULL);+BLST_ERROR blst_pairing_chk_n_aggr_pk_in_g2(blst_pairing *ctx,+                                            const blst_p2_affine *PK,+                                            bool pk_grpchk,+                                            const blst_p1_affine *signature,+                                            bool sig_grpchk,+                                            const byte *msg, size_t msg_len,+                                            const byte *aug DEFNULL,+                                            size_t aug_len DEFNULL);+BLST_ERROR blst_pairing_mul_n_aggregate_pk_in_g2(blst_pairing *ctx,+                                                 const blst_p2_affine *PK,+                                                 const blst_p1_affine *sig,+                                                 const byte *scalar,+                                                 size_t nbits,+                                                 const byte *msg,+                                                 size_t msg_len,+                                                 const byte *aug DEFNULL,+                                                 size_t aug_len DEFNULL);+BLST_ERROR blst_pairing_chk_n_mul_n_aggr_pk_in_g2(blst_pairing *ctx,+                                                  const blst_p2_affine *PK,+                                                  bool pk_grpchk,+                                                  const blst_p1_affine *sig,+                                                  bool sig_grpchk,+                                                  const byte *scalar,+                                                  size_t nbits,+                                                  const byte *msg,+                                                  size_t msg_len,+                                                  const byte *aug DEFNULL,+                                                  size_t aug_len DEFNULL);+BLST_ERROR blst_pairing_aggregate_pk_in_g1(blst_pairing *ctx,+                                           const blst_p1_affine *PK,+                                           const blst_p2_affine *signature,+                                           const byte *msg, size_t msg_len,+                                           const byte *aug DEFNULL,+                                           size_t aug_len DEFNULL);+BLST_ERROR blst_pairing_chk_n_aggr_pk_in_g1(blst_pairing *ctx,+                                            const blst_p1_affine *PK,+                                            bool pk_grpchk,+                                            const blst_p2_affine *signature,+                                            bool sig_grpchk,+                                            const byte *msg, size_t msg_len,+                                            const byte *aug DEFNULL,+                                            size_t aug_len DEFNULL);+BLST_ERROR blst_pairing_mul_n_aggregate_pk_in_g1(blst_pairing *ctx,+                                                 const blst_p1_affine *PK,+                                                 const blst_p2_affine *sig,+                                                 const byte *scalar,+                                                 size_t nbits,+                                                 const byte *msg,+                                                 size_t msg_len,+                                                 const byte *aug DEFNULL,+                                                 size_t aug_len DEFNULL);+BLST_ERROR blst_pairing_chk_n_mul_n_aggr_pk_in_g1(blst_pairing *ctx,+                                                  const blst_p1_affine *PK,+                                                  bool pk_grpchk,+                                                  const blst_p2_affine *sig,+                                                  bool sig_grpchk,+                                                  const byte *scalar,+                                                  size_t nbits,+                                                  const byte *msg,+                                                  size_t msg_len,+                                                  const byte *aug DEFNULL,+                                                  size_t aug_len DEFNULL);+BLST_ERROR blst_pairing_merge(blst_pairing *ctx, const blst_pairing *ctx1);+bool blst_pairing_finalverify(const blst_pairing *ctx,+                              const blst_fp12 *gtsig DEFNULL);+++/*+ * Customarily applications aggregate signatures separately.+ * In which case application would have to pass NULLs for |signature|+ * to blst_pairing_aggregate calls and pass aggregated signature+ * collected with these calls to blst_pairing_finalverify. Inputs are+ * Zcash-compatible "straight-from-wire" byte vectors, compressed or+ * not.+ */+BLST_ERROR blst_aggregate_in_g1(blst_p1 *out, const blst_p1 *in,+                                              const byte *zwire);+BLST_ERROR blst_aggregate_in_g2(blst_p2 *out, const blst_p2 *in,+                                              const byte *zwire);++void blst_aggregated_in_g1(blst_fp12 *out, const blst_p1_affine *signature);+void blst_aggregated_in_g2(blst_fp12 *out, const blst_p2_affine *signature);++/*+ * "One-shot" CoreVerify entry points.+ */+BLST_ERROR blst_core_verify_pk_in_g1(const blst_p1_affine *pk,+                                     const blst_p2_affine *signature,+                                     bool hash_or_encode,+                                     const byte *msg, size_t msg_len,+                                     const byte *DST DEFNULL,+                                     size_t DST_len DEFNULL,+                                     const byte *aug DEFNULL,+                                     size_t aug_len DEFNULL);+BLST_ERROR blst_core_verify_pk_in_g2(const blst_p2_affine *pk,+                                     const blst_p1_affine *signature,+                                     bool hash_or_encode,+                                     const byte *msg, size_t msg_len,+                                     const byte *DST DEFNULL,+                                     size_t DST_len DEFNULL,+                                     const byte *aug DEFNULL,+                                     size_t aug_len DEFNULL);++extern const blst_p1_affine BLS12_381_G1;+extern const blst_p1_affine BLS12_381_NEG_G1;+extern const blst_p2_affine BLS12_381_G2;+extern const blst_p2_affine BLS12_381_NEG_G2;++#include "blst_aux.h"++#ifdef __cplusplus+}+#endif+#endif
+ c-source/bindings/blst_aux.h view
@@ -0,0 +1,102 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */+#ifndef __BLST_AUX_H__+#define __BLST_AUX_H__+/*+ * This file lists interfaces that might be promoted to blst.h or removed,+ * depending on their proven/unproven worthiness.+ */++void blst_fr_to(blst_fr *ret, const blst_fr *a);+void blst_fr_from(blst_fr *ret, const blst_fr *a);++void blst_fp_to(blst_fp *ret, const blst_fp *a);+void blst_fp_from(blst_fp *ret, const blst_fp *a);++bool blst_fp_is_square(const blst_fp *a);+bool blst_fp2_is_square(const blst_fp2 *a);++void blst_p1_from_jacobian(blst_p1 *out, const blst_p1 *in);+void blst_p2_from_jacobian(blst_p2 *out, const blst_p2 *in);++/*+ * Below functions produce both point and deserialized outcome of+ * SkToPk and Sign. However, deserialized outputs are pre-decorated+ * with sign and infinity bits. This means that you have to bring the+ * output into compliance prior returning to application. If you want+ * compressed point value, then do [equivalent of]+ *+ *  byte temp[96];+ *  blst_sk_to_pk2_in_g1(temp, out_pk, SK);+ *  temp[0] |= 0x80;+ *  memcpy(out, temp, 48);+ *+ * Otherwise do+ *+ *  blst_sk_to_pk2_in_g1(out, out_pk, SK);+ *  out[0] &= ~0x20;+ *+ * Either |out| or |out_<point>| can be NULL.+ */+void blst_sk_to_pk2_in_g1(byte out[96], blst_p1_affine *out_pk,+                          const blst_scalar *SK);+void blst_sign_pk2_in_g1(byte out[192], blst_p2_affine *out_sig,+                         const blst_p2 *hash, const blst_scalar *SK);+void blst_sk_to_pk2_in_g2(byte out[192], blst_p2_affine *out_pk,+                          const blst_scalar *SK);+void blst_sign_pk2_in_g2(byte out[96], blst_p1_affine *out_sig,+                         const blst_p1 *hash, const blst_scalar *SK);++typedef struct {} blst_uniq;++size_t blst_uniq_sizeof(size_t n_nodes);+void blst_uniq_init(blst_uniq *tree);+bool blst_uniq_test(blst_uniq *tree, const byte *msg, size_t len);++#ifdef expand_message_xmd+void expand_message_xmd(unsigned char *bytes, size_t len_in_bytes,+                        const unsigned char *aug, size_t aug_len,+                        const unsigned char *msg, size_t msg_len,+                        const unsigned char *DST, size_t DST_len);+#else+void blst_expand_message_xmd(byte *out, size_t out_len,+                             const byte *msg, size_t msg_len,+                             const byte *DST, size_t DST_len);+#endif++void blst_p1_unchecked_mult(blst_p1 *out, const blst_p1 *p, const byte *scalar,+                                                            size_t nbits);+void blst_p2_unchecked_mult(blst_p2 *out, const blst_p2 *p, const byte *scalar,+                                                            size_t nbits);++void blst_pairing_raw_aggregate(blst_pairing *ctx, const blst_p2_affine *q,+                                                   const blst_p1_affine *p);+blst_fp12 *blst_pairing_as_fp12(blst_pairing *ctx);+void blst_bendian_from_fp12(byte out[48*12], const blst_fp12 *a);++void blst_keygen_v3(blst_scalar *out_SK, const byte *IKM, size_t IKM_len,+                    const byte *info DEFNULL, size_t info_len DEFNULL);+void blst_keygen_v4_5(blst_scalar *out_SK, const byte *IKM, size_t IKM_len,+                      const byte *salt, size_t salt_len,+                      const byte *info DEFNULL, size_t info_len DEFNULL);+void blst_keygen_v5(blst_scalar *out_SK, const byte *IKM, size_t IKM_len,+                    const byte *salt, size_t salt_len,+                    const byte *info DEFNULL, size_t info_len DEFNULL);+void blst_derive_master_eip2333(blst_scalar *out_SK,+                                const byte *IKM, size_t IKM_len);+void blst_derive_child_eip2333(blst_scalar *out_SK, const blst_scalar *SK,+                               uint32_t child_index);++void blst_scalar_from_hexascii(blst_scalar *out, const byte *hex);+void blst_fr_from_hexascii(blst_fr *ret, const byte *hex);+void blst_fp_from_hexascii(blst_fp *ret, const byte *hex);++size_t blst_p1_sizeof();+size_t blst_p1_affine_sizeof();+size_t blst_p2_sizeof();+size_t blst_p2_affine_sizeof();+size_t blst_fp12_sizeof();+#endif
+ c-source/build/assembly.S view
@@ -0,0 +1,123 @@+#if defined(__x86_64) || defined(__x86_64__)+# if defined(__ELF__)+#  if defined(__BLST_PORTABLE__)+#   include "elf/sha256-portable-x86_64.s"+#  else+#   include "elf/sha256-x86_64.s"+#  endif+#  if defined(__ADX__) && !defined(__BLST_PORTABLE__)+#   include "elf/ctx_inverse_mod_384-x86_64.s"+#  else+#   include "elf/ctq_inverse_mod_384-x86_64.s"+#  endif+#  include "elf/add_mod_384-x86_64.s"+#  include "elf/add_mod_384x384-x86_64.s"+#  define __add_mod_384     __add_mont_384+#  define __sub_mod_384     __sub_mont_384+#  define __sub_mod_384x384 __sub_mont_384x384+#  if defined(__ADX__) && !defined(__BLST_PORTABLE__)+#   include "elf/mulx_mont_384-x86_64.s"+#   include "elf/mulx_mont_256-x86_64.s"+#  else+#   include "elf/mulq_mont_384-x86_64.s"+#   include "elf/mulq_mont_256-x86_64.s"+#  endif+#  include "elf/add_mod_256-x86_64.s"+#  include "elf/ct_inverse_mod_256-x86_64.s"+#  include "elf/div3w-x86_64.s"+#  include "elf/ct_is_square_mod_384-x86_64.s"+# elif defined(_WIN64) || defined(__CYGWIN__)+#  if defined(__BLST_PORTABLE__)+#   include "coff/sha256-portable-x86_64.s"+#  else+#   include "coff/sha256-x86_64.s"+#  endif+#  if defined(__ADX__) && !defined(__BLST_PORTABLE__)+#   include "coff/ctx_inverse_mod_384-x86_64.s"+#  else+#   include "coff/ctq_inverse_mod_384-x86_64.s"+#  endif+#  include "coff/add_mod_384-x86_64.s"+#  include "coff/add_mod_384x384-x86_64.s"+#  define __add_mod_384     __add_mont_384+#  define __sub_mod_384     __sub_mont_384+#  define __sub_mod_384x384 __sub_mont_384x384+#  if defined(__ADX__) && !defined(__BLST_PORTABLE__)+#   include "coff/mulx_mont_384-x86_64.s"+#   include "coff/mulx_mont_256-x86_64.s"+#  else+#   include "coff/mulq_mont_384-x86_64.s"+#   include "coff/mulq_mont_256-x86_64.s"+#  endif+#  include "coff/add_mod_256-x86_64.s"+#  include "coff/ct_inverse_mod_256-x86_64.s"+#  include "coff/div3w-x86_64.s"+#  include "coff/ct_is_square_mod_384-x86_64.s"+# elif defined(__APPLE__)+#  include "mach-o/sha256-x86_64.s"+#  if defined(__ADX__) && !defined(__BLST_PORTABLE__)+#   include "mach-o/ctx_inverse_mod_384-x86_64.s"+#  else+#   include "mach-o/ctq_inverse_mod_384-x86_64.s"+#  endif+#  include "mach-o/add_mod_384-x86_64.s"+#  include "mach-o/add_mod_384x384-x86_64.s"+#  define __add_mod_384     __add_mont_384+#  define __sub_mod_384     __sub_mont_384+#  define __sub_mod_384x384 __sub_mont_384x384+#  if defined(__ADX__) && !defined(__BLST_PORTABLE__)+#   include "mach-o/mulx_mont_384-x86_64.s"+#   include "mach-o/mulx_mont_256-x86_64.s"+#  else+#   include "mach-o/mulq_mont_384-x86_64.s"+#   include "mach-o/mulq_mont_256-x86_64.s"+#  endif+#  include "mach-o/add_mod_256-x86_64.s"+#  include "mach-o/ct_inverse_mod_256-x86_64.s"+#  include "mach-o/div3w-x86_64.s"+#  include "mach-o/ct_is_square_mod_384-x86_64.s"+# endif+#elif defined(__aarch64__)+# if defined(__ELF__)+#  include "elf/sha256-armv8.S"+#  include "elf/ct_inverse_mod_384-armv8.S"+#  include "elf/add_mod_384-armv8.S"+#  define __add_mod_384     __add_mont_384+#  define __sub_mod_384     __sub_mont_384+#  include "elf/mul_mont_384-armv8.S"+#  include "elf/mul_mont_256-armv8.S"+#  include "elf/add_mod_256-armv8.S"+#  include "elf/ct_inverse_mod_256-armv8.S"+#  include "elf/div3w-armv8.S"+#  include "elf/ct_is_square_mod_384-armv8.S"+# elif defined(_WIN64)+#  include "coff/sha256-armv8.S"+#  include "coff/ct_inverse_mod_384-armv8.S"+#  include "coff/add_mod_384-armv8.S"+#  define __add_mod_384     __add_mont_384+#  define __sub_mod_384     __sub_mont_384+#  include "coff/mul_mont_384-armv8.S"+#  include "coff/mul_mont_256-armv8.S"+#  include "coff/add_mod_256-armv8.S"+#  include "coff/ct_inverse_mod_256-armv8.S"+#  include "coff/div3w-armv8.S"+#  include "coff/ct_is_square_mod_384-armv8.S"+# elif defined(__APPLE__)+#  include "mach-o/sha256-armv8.S"+#  include "mach-o/ct_inverse_mod_384-armv8.S"+#  include "mach-o/add_mod_384-armv8.S"+#  define __add_mod_384     __add_mont_384+#  define __sub_mod_384     __sub_mont_384+#  include "mach-o/mul_mont_384-armv8.S"+#  include "mach-o/mul_mont_256-armv8.S"+#  include "mach-o/add_mod_256-armv8.S"+#  include "mach-o/ct_inverse_mod_256-armv8.S"+#  include "mach-o/div3w-armv8.S"+#  include "mach-o/ct_is_square_mod_384-armv8.S"+# endif+#elif defined(__BLST_NO_ASM__) || \+      (defined(__SIZEOF_POINTER__) && __SIZEOF_POINTER__==4)+/* inaccurate way to detect a 32-bit processor, but it's close enough */+#else+# error "unsupported platform"+#endif
+ c-source/build/coff/add_mod_256-armv8.S view
@@ -0,0 +1,397 @@+.text++.globl	add_mod_256++.def	add_mod_256;+.type	32;+.endef+.p2align	5+add_mod_256:+	ldp	x8,x9,[x1]+	ldp	x12,x13,[x2]++	ldp	x10,x11,[x1,#16]+	adds	x8,x8,x12+	ldp	x14,x15,[x2,#16]+	adcs	x9,x9,x13+	ldp	x4,x5,[x3]+	adcs	x10,x10,x14+	ldp	x6,x7,[x3,#16]+	adcs	x11,x11,x15+	adc	x3,xzr,xzr++	subs	x16,x8,x4+	sbcs	x17,x9,x5+	sbcs	x1,x10,x6+	sbcs	x2,x11,x7+	sbcs	xzr,x3,xzr++	csel	x8,x8,x16,lo+	csel	x9,x9,x17,lo+	csel	x10,x10,x1,lo+	stp	x8,x9,[x0]+	csel	x11,x11,x2,lo+	stp	x10,x11,[x0,#16]++	ret+++.globl	mul_by_3_mod_256++.def	mul_by_3_mod_256;+.type	32;+.endef+.p2align	5+mul_by_3_mod_256:+	ldp	x12,x13,[x1]+	ldp	x14,x15,[x1,#16]++	adds	x8,x12,x12+	ldp	x4,x5,[x2]+	adcs	x9,x13,x13+	ldp	x6,x7,[x2,#16]+	adcs	x10,x14,x14+	adcs	x11,x15,x15+	adc	x3,xzr,xzr++	subs	x16,x8,x4+	sbcs	x17,x9,x5+	sbcs	x1,x10,x6+	sbcs	x2,x11,x7+	sbcs	xzr,x3,xzr++	csel	x8,x8,x16,lo+	csel	x9,x9,x17,lo+	csel	x10,x10,x1,lo+	csel	x11,x11,x2,lo++	adds	x8,x8,x12+	adcs	x9,x9,x13+	adcs	x10,x10,x14+	adcs	x11,x11,x15+	adc	x3,xzr,xzr++	subs	x16,x8,x4+	sbcs	x17,x9,x5+	sbcs	x1,x10,x6+	sbcs	x2,x11,x7+	sbcs	xzr,x3,xzr++	csel	x8,x8,x16,lo+	csel	x9,x9,x17,lo+	csel	x10,x10,x1,lo+	stp	x8,x9,[x0]+	csel	x11,x11,x2,lo+	stp	x10,x11,[x0,#16]++	ret+++.globl	lshift_mod_256++.def	lshift_mod_256;+.type	32;+.endef+.p2align	5+lshift_mod_256:+	ldp	x8,x9,[x1]+	ldp	x10,x11,[x1,#16]++	ldp	x4,x5,[x3]+	ldp	x6,x7,[x3,#16]++.Loop_lshift_mod_256:+	adds	x8,x8,x8+	sub	x2,x2,#1+	adcs	x9,x9,x9+	adcs	x10,x10,x10+	adcs	x11,x11,x11+	adc	x3,xzr,xzr++	subs	x12,x8,x4+	sbcs	x13,x9,x5+	sbcs	x14,x10,x6+	sbcs	x15,x11,x7+	sbcs	xzr,x3,xzr++	csel	x8,x8,x12,lo+	csel	x9,x9,x13,lo+	csel	x10,x10,x14,lo+	csel	x11,x11,x15,lo++	cbnz	x2,.Loop_lshift_mod_256++	stp	x8,x9,[x0]+	stp	x10,x11,[x0,#16]++	ret+++.globl	rshift_mod_256++.def	rshift_mod_256;+.type	32;+.endef+.p2align	5+rshift_mod_256:+	ldp	x8,x9,[x1]+	ldp	x10,x11,[x1,#16]++	ldp	x4,x5,[x3]+	ldp	x6,x7,[x3,#16]++.Loop_rshift:+	adds	x12,x8,x4+	sub	x2,x2,#1+	adcs	x13,x9,x5+	adcs	x14,x10,x6+	adcs	x15,x11,x7+	adc	x3,xzr,xzr+	tst	x8,#1++	csel	x12,x12,x8,ne+	csel	x13,x13,x9,ne+	csel	x14,x14,x10,ne+	csel	x15,x15,x11,ne+	csel	x3,x3,xzr,ne++	extr	x8,x13,x12,#1+	extr	x9,x14,x13,#1+	extr	x10,x15,x14,#1+	extr	x11,x3,x15,#1++	cbnz	x2,.Loop_rshift++	stp	x8,x9,[x0]+	stp	x10,x11,[x0,#16]++	ret+++.globl	cneg_mod_256++.def	cneg_mod_256;+.type	32;+.endef+.p2align	5+cneg_mod_256:+	ldp	x8,x9,[x1]+	ldp	x4,x5,[x3]++	ldp	x10,x11,[x1,#16]+	subs	x12,x4,x8+	ldp	x6,x7,[x3,#16]+	orr	x4,x8,x9+	sbcs	x13,x5,x9+	orr	x5,x10,x11+	sbcs	x14,x6,x10+	orr	x3,x4,x5+	sbc	x15,x7,x11++	cmp	x3,#0+	csetm	x3,ne+	ands	x2,x2,x3++	csel	x8,x8,x12,eq+	csel	x9,x9,x13,eq+	csel	x10,x10,x14,eq+	stp	x8,x9,[x0]+	csel	x11,x11,x15,eq+	stp	x10,x11,[x0,#16]++	ret+++.globl	sub_mod_256++.def	sub_mod_256;+.type	32;+.endef+.p2align	5+sub_mod_256:+	ldp	x8,x9,[x1]+	ldp	x12,x13,[x2]++	ldp	x10,x11,[x1,#16]+	subs	x8,x8,x12+	ldp	x14,x15,[x2,#16]+	sbcs	x9,x9,x13+	ldp	x4,x5,[x3]+	sbcs	x10,x10,x14+	ldp	x6,x7,[x3,#16]+	sbcs	x11,x11,x15+	sbc	x3,xzr,xzr++	and	x4,x4,x3+	and	x5,x5,x3+	adds	x8,x8,x4+	and	x6,x6,x3+	adcs	x9,x9,x5+	and	x7,x7,x3+	adcs	x10,x10,x6+	stp	x8,x9,[x0]+	adc	x11,x11,x7+	stp	x10,x11,[x0,#16]++	ret+++.globl	check_mod_256++.def	check_mod_256;+.type	32;+.endef+.p2align	5+check_mod_256:+	ldp	x8,x9,[x0]+	ldp	x10,x11,[x0,#16]+	ldp	x4,x5,[x1]+	ldp	x6,x7,[x1,#16]++#ifdef	__AARCH64EB__+	rev	x8,x8+	rev	x9,x9+	rev	x10,x10+	rev	x11,x11+#endif++	subs	xzr,x8,x4+	sbcs	xzr,x9,x5+	orr	x8,x8,x9+	sbcs	xzr,x10,x6+	orr	x8,x8,x10+	sbcs	xzr,x11,x7+	orr	x8,x8,x11+	sbc	x1,xzr,xzr++	cmp	x8,#0+	mov	x0,#1+	csel	x0,x0,xzr,ne+	and	x0,x0,x1++	ret+++.globl	add_n_check_mod_256++.def	add_n_check_mod_256;+.type	32;+.endef+.p2align	5+add_n_check_mod_256:+	ldp	x8,x9,[x1]+	ldp	x12,x13,[x2]+	ldp	x10,x11,[x1,#16]+	ldp	x14,x15,[x2,#16]++#ifdef	__AARCH64EB__+	rev	x8,x8+	rev	x12,x12+	rev	x9,x9+	rev	x13,x13+	rev	x10,x10+	rev	x14,x14+	rev	x11,x11+	rev	x15,x15+#endif++	adds	x8,x8,x12+	ldp	x4,x5,[x3]+	adcs	x9,x9,x13+	ldp	x6,x7,[x3,#16]+	adcs	x10,x10,x14+	adcs	x11,x11,x15+	adc	x3,xzr,xzr++	subs	x16,x8,x4+	sbcs	x17,x9,x5+	sbcs	x1,x10,x6+	sbcs	x2,x11,x7+	sbcs	xzr,x3,xzr++	csel	x8,x8,x16,lo+	csel	x9,x9,x17,lo+	csel	x10,x10,x1,lo+	csel	x11,x11,x2,lo++	orr	x16, x8, x9+	orr	x17, x10, x11+	orr	x16, x16, x17++#ifdef	__AARCH64EB__+	rev	x8,x8+	rev	x9,x9+	rev	x10,x10+	rev	x11,x11+#endif++	stp	x8,x9,[x0]+	stp	x10,x11,[x0,#16]++	mov	x17, #1+	cmp	x16, #0+	csel	x0, x17, xzr, ne++	ret+++.globl	sub_n_check_mod_256++.def	sub_n_check_mod_256;+.type	32;+.endef+.p2align	5+sub_n_check_mod_256:+	ldp	x8,x9,[x1]+	ldp	x12,x13,[x2]+	ldp	x10,x11,[x1,#16]+	ldp	x14,x15,[x2,#16]++#ifdef	__AARCH64EB__+	rev	x8,x8+	rev	x12,x12+	rev	x9,x9+	rev	x13,x13+	rev	x10,x10+	rev	x14,x14+	rev	x11,x11+	rev	x15,x15+#endif++	subs	x8,x8,x12+	sbcs	x9,x9,x13+	ldp	x4,x5,[x3]+	sbcs	x10,x10,x14+	ldp	x6,x7,[x3,#16]+	sbcs	x11,x11,x15+	sbc	x3,xzr,xzr++	and	x4,x4,x3+	and	x5,x5,x3+	adds	x8,x8,x4+	and	x6,x6,x3+	adcs	x9,x9,x5+	and	x7,x7,x3+	adcs	x10,x10,x6+	adc	x11,x11,x7++	orr	x16, x8, x9+	orr	x17, x10, x11+	orr	x16, x16, x17++#ifdef	__AARCH64EB__+	rev	x8,x8+	rev	x9,x9+	rev	x10,x10+	rev	x11,x11+#endif++	stp	x8,x9,[x0]+	stp	x10,x11,[x0,#16]++	mov	x17, #1+	cmp	x16, #0+	csel	x0, x17, xzr, ne++	ret+
+ c-source/build/coff/add_mod_256-x86_64.s view
@@ -0,0 +1,911 @@+.text	++.globl	add_mod_256++.def	add_mod_256;	.scl 2;	.type 32;	.endef+.p2align	5+add_mod_256:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_add_mod_256:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	subq	$8,%rsp++.LSEH_body_add_mod_256:+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11++.Loaded_a_add_mod_256:+	addq	0(%rdx),%r8+	adcq	8(%rdx),%r9+	movq	%r8,%rax+	adcq	16(%rdx),%r10+	movq	%r9,%rsi+	adcq	24(%rdx),%r11+	sbbq	%rdx,%rdx++	movq	%r10,%rbx+	subq	0(%rcx),%r8+	sbbq	8(%rcx),%r9+	sbbq	16(%rcx),%r10+	movq	%r11,%rbp+	sbbq	24(%rcx),%r11+	sbbq	$0,%rdx++	cmovcq	%rax,%r8+	cmovcq	%rsi,%r9+	movq	%r8,0(%rdi)+	cmovcq	%rbx,%r10+	movq	%r9,8(%rdi)+	cmovcq	%rbp,%r11+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)++	movq	8(%rsp),%rbx++	movq	16(%rsp),%rbp++	leaq	24(%rsp),%rsp++.LSEH_epilogue_add_mod_256:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_add_mod_256:+++.globl	mul_by_3_mod_256++.def	mul_by_3_mod_256;	.scl 2;	.type 32;	.endef+.p2align	5+mul_by_3_mod_256:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_mul_by_3_mod_256:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++.LSEH_body_mul_by_3_mod_256:+++	movq	%rdx,%rcx+	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	%rsi,%rdx+	movq	24(%rsi),%r11++	call	__lshift_mod_256+	movq	0(%rsp),%r12++	jmp	.Loaded_a_add_mod_256++	movq	8(%rsp),%rbx++	movq	16(%rsp),%rbp++	leaq	24(%rsp),%rsp++.LSEH_epilogue_mul_by_3_mod_256:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_mul_by_3_mod_256:++.def	__lshift_mod_256;	.scl 3;	.type 32;	.endef+.p2align	5+__lshift_mod_256:+	.byte	0xf3,0x0f,0x1e,0xfa++	addq	%r8,%r8+	adcq	%r9,%r9+	movq	%r8,%rax+	adcq	%r10,%r10+	movq	%r9,%rsi+	adcq	%r11,%r11+	sbbq	%r12,%r12++	movq	%r10,%rbx+	subq	0(%rcx),%r8+	sbbq	8(%rcx),%r9+	sbbq	16(%rcx),%r10+	movq	%r11,%rbp+	sbbq	24(%rcx),%r11+	sbbq	$0,%r12++	cmovcq	%rax,%r8+	cmovcq	%rsi,%r9+	cmovcq	%rbx,%r10+	cmovcq	%rbp,%r11++	.byte	0xf3,0xc3++++.globl	lshift_mod_256++.def	lshift_mod_256;	.scl 2;	.type 32;	.endef+.p2align	5+lshift_mod_256:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_lshift_mod_256:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++.LSEH_body_lshift_mod_256:+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11++.Loop_lshift_mod_256:+	call	__lshift_mod_256+	decl	%edx+	jnz	.Loop_lshift_mod_256++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)++	movq	0(%rsp),%r12++	movq	8(%rsp),%rbx++	movq	16(%rsp),%rbp++	leaq	24(%rsp),%rsp++.LSEH_epilogue_lshift_mod_256:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_lshift_mod_256:+++.globl	rshift_mod_256++.def	rshift_mod_256;	.scl 2;	.type 32;	.endef+.p2align	5+rshift_mod_256:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_rshift_mod_256:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	subq	$8,%rsp++.LSEH_body_rshift_mod_256:+++	movq	0(%rsi),%rbp+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11++.Loop_rshift_mod_256:+	movq	%rbp,%r8+	andq	$1,%rbp+	movq	0(%rcx),%rax+	negq	%rbp+	movq	8(%rcx),%rsi+	movq	16(%rcx),%rbx++	andq	%rbp,%rax+	andq	%rbp,%rsi+	andq	%rbp,%rbx+	andq	24(%rcx),%rbp++	addq	%rax,%r8+	adcq	%rsi,%r9+	adcq	%rbx,%r10+	adcq	%rbp,%r11+	sbbq	%rax,%rax++	shrq	$1,%r8+	movq	%r9,%rbp+	shrq	$1,%r9+	movq	%r10,%rbx+	shrq	$1,%r10+	movq	%r11,%rsi+	shrq	$1,%r11++	shlq	$63,%rbp+	shlq	$63,%rbx+	orq	%r8,%rbp+	shlq	$63,%rsi+	orq	%rbx,%r9+	shlq	$63,%rax+	orq	%rsi,%r10+	orq	%rax,%r11++	decl	%edx+	jnz	.Loop_rshift_mod_256++	movq	%rbp,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)++	movq	8(%rsp),%rbx++	movq	16(%rsp),%rbp++	leaq	24(%rsp),%rsp++.LSEH_epilogue_rshift_mod_256:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_rshift_mod_256:+++.globl	cneg_mod_256++.def	cneg_mod_256;	.scl 2;	.type 32;	.endef+.p2align	5+cneg_mod_256:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_cneg_mod_256:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++.LSEH_body_cneg_mod_256:+++	movq	0(%rsi),%r12+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	%r12,%r8+	movq	24(%rsi),%r11+	orq	%r9,%r12+	orq	%r10,%r12+	orq	%r11,%r12+	movq	$-1,%rbp++	movq	0(%rcx),%rax+	cmovnzq	%rbp,%r12+	movq	8(%rcx),%rsi+	movq	16(%rcx),%rbx+	andq	%r12,%rax+	movq	24(%rcx),%rbp+	andq	%r12,%rsi+	andq	%r12,%rbx+	andq	%r12,%rbp++	subq	%r8,%rax+	sbbq	%r9,%rsi+	sbbq	%r10,%rbx+	sbbq	%r11,%rbp++	orq	%rdx,%rdx++	cmovzq	%r8,%rax+	cmovzq	%r9,%rsi+	movq	%rax,0(%rdi)+	cmovzq	%r10,%rbx+	movq	%rsi,8(%rdi)+	cmovzq	%r11,%rbp+	movq	%rbx,16(%rdi)+	movq	%rbp,24(%rdi)++	movq	0(%rsp),%r12++	movq	8(%rsp),%rbx++	movq	16(%rsp),%rbp++	leaq	24(%rsp),%rsp++.LSEH_epilogue_cneg_mod_256:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_cneg_mod_256:+++.globl	sub_mod_256++.def	sub_mod_256;	.scl 2;	.type 32;	.endef+.p2align	5+sub_mod_256:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sub_mod_256:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	subq	$8,%rsp++.LSEH_body_sub_mod_256:+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11++	subq	0(%rdx),%r8+	movq	0(%rcx),%rax+	sbbq	8(%rdx),%r9+	movq	8(%rcx),%rsi+	sbbq	16(%rdx),%r10+	movq	16(%rcx),%rbx+	sbbq	24(%rdx),%r11+	movq	24(%rcx),%rbp+	sbbq	%rdx,%rdx++	andq	%rdx,%rax+	andq	%rdx,%rsi+	andq	%rdx,%rbx+	andq	%rdx,%rbp++	addq	%rax,%r8+	adcq	%rsi,%r9+	movq	%r8,0(%rdi)+	adcq	%rbx,%r10+	movq	%r9,8(%rdi)+	adcq	%rbp,%r11+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)++	movq	8(%rsp),%rbx++	movq	16(%rsp),%rbp++	leaq	24(%rsp),%rsp++.LSEH_epilogue_sub_mod_256:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sub_mod_256:+++.globl	check_mod_256++.def	check_mod_256;	.scl 2;	.type 32;	.endef+.p2align	5+check_mod_256:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_check_mod_256:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+++	movq	0(%rdi),%rax+	movq	8(%rdi),%r9+	movq	16(%rdi),%r10+	movq	24(%rdi),%r11++	movq	%rax,%r8+	orq	%r9,%rax+	orq	%r10,%rax+	orq	%r11,%rax++	subq	0(%rsi),%r8+	sbbq	8(%rsi),%r9+	sbbq	16(%rsi),%r10+	sbbq	24(%rsi),%r11+	sbbq	%rsi,%rsi++	movq	$1,%rdx+	cmpq	$0,%rax+	cmovneq	%rdx,%rax+	andq	%rsi,%rax+.LSEH_epilogue_check_mod_256:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_check_mod_256:+++.globl	add_n_check_mod_256++.def	add_n_check_mod_256;	.scl 2;	.type 32;	.endef+.p2align	5+add_n_check_mod_256:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_add_n_check_mod_256:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	subq	$8,%rsp++.LSEH_body_add_n_check_mod_256:+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11++	addq	0(%rdx),%r8+	adcq	8(%rdx),%r9+	movq	%r8,%rax+	adcq	16(%rdx),%r10+	movq	%r9,%rsi+	adcq	24(%rdx),%r11+	sbbq	%rdx,%rdx++	movq	%r10,%rbx+	subq	0(%rcx),%r8+	sbbq	8(%rcx),%r9+	sbbq	16(%rcx),%r10+	movq	%r11,%rbp+	sbbq	24(%rcx),%r11+	sbbq	$0,%rdx++	cmovcq	%rax,%r8+	cmovcq	%rsi,%r9+	movq	%r8,0(%rdi)+	cmovcq	%rbx,%r10+	movq	%r9,8(%rdi)+	cmovcq	%rbp,%r11+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)++	orq	%r9,%r8+	orq	%r11,%r10+	orq	%r10,%r8+	movq	$1,%rax+	cmovzq	%r8,%rax++	movq	8(%rsp),%rbx++	movq	16(%rsp),%rbp++	leaq	24(%rsp),%rsp++.LSEH_epilogue_add_n_check_mod_256:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_add_n_check_mod_256:+++.globl	sub_n_check_mod_256++.def	sub_n_check_mod_256;	.scl 2;	.type 32;	.endef+.p2align	5+sub_n_check_mod_256:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sub_n_check_mod_256:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	subq	$8,%rsp++.LSEH_body_sub_n_check_mod_256:+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11++	subq	0(%rdx),%r8+	movq	0(%rcx),%rax+	sbbq	8(%rdx),%r9+	movq	8(%rcx),%rsi+	sbbq	16(%rdx),%r10+	movq	16(%rcx),%rbx+	sbbq	24(%rdx),%r11+	movq	24(%rcx),%rbp+	sbbq	%rdx,%rdx++	andq	%rdx,%rax+	andq	%rdx,%rsi+	andq	%rdx,%rbx+	andq	%rdx,%rbp++	addq	%rax,%r8+	adcq	%rsi,%r9+	movq	%r8,0(%rdi)+	adcq	%rbx,%r10+	movq	%r9,8(%rdi)+	adcq	%rbp,%r11+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)++	orq	%r9,%r8+	orq	%r11,%r10+	orq	%r10,%r8+	movq	$1,%rax+	cmovzq	%r8,%rax++	movq	8(%rsp),%rbx++	movq	16(%rsp),%rbp++	leaq	24(%rsp),%rsp++.LSEH_epilogue_sub_n_check_mod_256:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sub_n_check_mod_256:+.section	.pdata+.p2align	2+.rva	.LSEH_begin_add_mod_256+.rva	.LSEH_body_add_mod_256+.rva	.LSEH_info_add_mod_256_prologue++.rva	.LSEH_body_add_mod_256+.rva	.LSEH_epilogue_add_mod_256+.rva	.LSEH_info_add_mod_256_body++.rva	.LSEH_epilogue_add_mod_256+.rva	.LSEH_end_add_mod_256+.rva	.LSEH_info_add_mod_256_epilogue++.rva	.LSEH_begin_mul_by_3_mod_256+.rva	.LSEH_body_mul_by_3_mod_256+.rva	.LSEH_info_mul_by_3_mod_256_prologue++.rva	.LSEH_body_mul_by_3_mod_256+.rva	.LSEH_epilogue_mul_by_3_mod_256+.rva	.LSEH_info_mul_by_3_mod_256_body++.rva	.LSEH_epilogue_mul_by_3_mod_256+.rva	.LSEH_end_mul_by_3_mod_256+.rva	.LSEH_info_mul_by_3_mod_256_epilogue++.rva	.LSEH_begin_lshift_mod_256+.rva	.LSEH_body_lshift_mod_256+.rva	.LSEH_info_lshift_mod_256_prologue++.rva	.LSEH_body_lshift_mod_256+.rva	.LSEH_epilogue_lshift_mod_256+.rva	.LSEH_info_lshift_mod_256_body++.rva	.LSEH_epilogue_lshift_mod_256+.rva	.LSEH_end_lshift_mod_256+.rva	.LSEH_info_lshift_mod_256_epilogue++.rva	.LSEH_begin_rshift_mod_256+.rva	.LSEH_body_rshift_mod_256+.rva	.LSEH_info_rshift_mod_256_prologue++.rva	.LSEH_body_rshift_mod_256+.rva	.LSEH_epilogue_rshift_mod_256+.rva	.LSEH_info_rshift_mod_256_body++.rva	.LSEH_epilogue_rshift_mod_256+.rva	.LSEH_end_rshift_mod_256+.rva	.LSEH_info_rshift_mod_256_epilogue++.rva	.LSEH_begin_cneg_mod_256+.rva	.LSEH_body_cneg_mod_256+.rva	.LSEH_info_cneg_mod_256_prologue++.rva	.LSEH_body_cneg_mod_256+.rva	.LSEH_epilogue_cneg_mod_256+.rva	.LSEH_info_cneg_mod_256_body++.rva	.LSEH_epilogue_cneg_mod_256+.rva	.LSEH_end_cneg_mod_256+.rva	.LSEH_info_cneg_mod_256_epilogue++.rva	.LSEH_begin_sub_mod_256+.rva	.LSEH_body_sub_mod_256+.rva	.LSEH_info_sub_mod_256_prologue++.rva	.LSEH_body_sub_mod_256+.rva	.LSEH_epilogue_sub_mod_256+.rva	.LSEH_info_sub_mod_256_body++.rva	.LSEH_epilogue_sub_mod_256+.rva	.LSEH_end_sub_mod_256+.rva	.LSEH_info_sub_mod_256_epilogue++.rva	.LSEH_epilogue_check_mod_256+.rva	.LSEH_end_check_mod_256+.rva	.LSEH_info_check_mod_256_epilogue++.rva	.LSEH_begin_add_n_check_mod_256+.rva	.LSEH_body_add_n_check_mod_256+.rva	.LSEH_info_add_n_check_mod_256_prologue++.rva	.LSEH_body_add_n_check_mod_256+.rva	.LSEH_epilogue_add_n_check_mod_256+.rva	.LSEH_info_add_n_check_mod_256_body++.rva	.LSEH_epilogue_add_n_check_mod_256+.rva	.LSEH_end_add_n_check_mod_256+.rva	.LSEH_info_add_n_check_mod_256_epilogue++.rva	.LSEH_begin_sub_n_check_mod_256+.rva	.LSEH_body_sub_n_check_mod_256+.rva	.LSEH_info_sub_n_check_mod_256_prologue++.rva	.LSEH_body_sub_n_check_mod_256+.rva	.LSEH_epilogue_sub_n_check_mod_256+.rva	.LSEH_info_sub_n_check_mod_256_body++.rva	.LSEH_epilogue_sub_n_check_mod_256+.rva	.LSEH_end_sub_n_check_mod_256+.rva	.LSEH_info_sub_n_check_mod_256_epilogue++.section	.xdata+.p2align	3+.LSEH_info_add_mod_256_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_add_mod_256_body:+.byte	1,0,9,0+.byte	0x00,0x34,0x01,0x00+.byte	0x00,0x54,0x02,0x00+.byte	0x00,0x74,0x04,0x00+.byte	0x00,0x64,0x05,0x00+.byte	0x00,0x22+.byte	0x00,0x00+.LSEH_info_add_mod_256_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_mul_by_3_mod_256_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_mul_by_3_mod_256_body:+.byte	1,0,11,0+.byte	0x00,0xc4,0x00,0x00+.byte	0x00,0x34,0x01,0x00+.byte	0x00,0x54,0x02,0x00+.byte	0x00,0x74,0x04,0x00+.byte	0x00,0x64,0x05,0x00+.byte	0x00,0x22+.byte	0x00,0x00,0x00,0x00,0x00,0x00+.LSEH_info_mul_by_3_mod_256_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_lshift_mod_256_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_lshift_mod_256_body:+.byte	1,0,11,0+.byte	0x00,0xc4,0x00,0x00+.byte	0x00,0x34,0x01,0x00+.byte	0x00,0x54,0x02,0x00+.byte	0x00,0x74,0x04,0x00+.byte	0x00,0x64,0x05,0x00+.byte	0x00,0x22+.byte	0x00,0x00,0x00,0x00,0x00,0x00+.LSEH_info_lshift_mod_256_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_rshift_mod_256_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_rshift_mod_256_body:+.byte	1,0,9,0+.byte	0x00,0x34,0x01,0x00+.byte	0x00,0x54,0x02,0x00+.byte	0x00,0x74,0x04,0x00+.byte	0x00,0x64,0x05,0x00+.byte	0x00,0x22+.byte	0x00,0x00+.LSEH_info_rshift_mod_256_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_cneg_mod_256_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_cneg_mod_256_body:+.byte	1,0,11,0+.byte	0x00,0xc4,0x00,0x00+.byte	0x00,0x34,0x01,0x00+.byte	0x00,0x54,0x02,0x00+.byte	0x00,0x74,0x04,0x00+.byte	0x00,0x64,0x05,0x00+.byte	0x00,0x22+.byte	0x00,0x00,0x00,0x00,0x00,0x00+.LSEH_info_cneg_mod_256_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sub_mod_256_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sub_mod_256_body:+.byte	1,0,9,0+.byte	0x00,0x34,0x01,0x00+.byte	0x00,0x54,0x02,0x00+.byte	0x00,0x74,0x04,0x00+.byte	0x00,0x64,0x05,0x00+.byte	0x00,0x22+.byte	0x00,0x00+.LSEH_info_sub_mod_256_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_check_mod_256_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_add_n_check_mod_256_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_add_n_check_mod_256_body:+.byte	1,0,9,0+.byte	0x00,0x34,0x01,0x00+.byte	0x00,0x54,0x02,0x00+.byte	0x00,0x74,0x04,0x00+.byte	0x00,0x64,0x05,0x00+.byte	0x00,0x22+.byte	0x00,0x00+.LSEH_info_add_n_check_mod_256_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sub_n_check_mod_256_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sub_n_check_mod_256_body:+.byte	1,0,9,0+.byte	0x00,0x34,0x01,0x00+.byte	0x00,0x54,0x02,0x00+.byte	0x00,0x74,0x04,0x00+.byte	0x00,0x64,0x05,0x00+.byte	0x00,0x22+.byte	0x00,0x00+.LSEH_info_sub_n_check_mod_256_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00+
+ c-source/build/coff/add_mod_384-armv8.S view
@@ -0,0 +1,981 @@+.text++.globl	add_mod_384++.def	add_mod_384;+.type	32;+.endef+.p2align	5+add_mod_384:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x4,x5,[x3]+	ldp	x6,x7,[x3,#16]+	ldp	x8,x9,[x3,#32]++	bl	__add_mod_384+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]+	stp	x14,x15,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret+++.def	__add_mod_384;+.type	32;+.endef+.p2align	5+__add_mod_384:+	ldp	x10,x11,[x1]+	ldp	x16,x17,[x2]+	ldp	x12,x13,[x1,#16]+	ldp	x19,x20,[x2,#16]+	ldp	x14,x15,[x1,#32]+	ldp	x21,x22,[x2,#32]++__add_mod_384_ab_are_loaded:+	adds	x10,x10,x16+	adcs	x11,x11,x17+	adcs	x12,x12,x19+	adcs	x13,x13,x20+	adcs	x14,x14,x21+	adcs	x15,x15,x22+	adc	x3,xzr,xzr++	subs	x16,x10,x4+	sbcs	x17,x11,x5+	sbcs	x19,x12,x6+	sbcs	x20,x13,x7+	sbcs	x21,x14,x8+	sbcs	x22,x15,x9+	sbcs	xzr,x3,xzr++	csel	x10,x10,x16,lo+	csel	x11,x11,x17,lo+	csel	x12,x12,x19,lo+	csel	x13,x13,x20,lo+	csel	x14,x14,x21,lo+	csel	x15,x15,x22,lo++	ret+++.globl	add_mod_384x++.def	add_mod_384x;+.type	32;+.endef+.p2align	5+add_mod_384x:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x4,x5,[x3]+	ldp	x6,x7,[x3,#16]+	ldp	x8,x9,[x3,#32]++	bl	__add_mod_384++	stp	x10,x11,[x0]+	add	x1,x1,#48+	stp	x12,x13,[x0,#16]+	add	x2,x2,#48+	stp	x14,x15,[x0,#32]++	bl	__add_mod_384+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0,#48]+	stp	x12,x13,[x0,#64]+	stp	x14,x15,[x0,#80]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret+++.globl	rshift_mod_384++.def	rshift_mod_384;+.type	32;+.endef+.p2align	5+rshift_mod_384:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]+	ldp	x14,x15,[x1,#32]++	ldp	x4,x5,[x3]+	ldp	x6,x7,[x3,#16]+	ldp	x8,x9,[x3,#32]++.Loop_rshift_mod_384:+	sub	x2,x2,#1+	bl	__rshift_mod_384+	cbnz	x2,.Loop_rshift_mod_384++	ldr	x30,[sp,#8]+	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]+	stp	x14,x15,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret+++.def	__rshift_mod_384;+.type	32;+.endef+.p2align	5+__rshift_mod_384:+	sbfx	x22,x10,#0,#1+	and	x16,x22,x4+	and	x17,x22,x5+	adds	x10,x10,x16+	and	x19,x22,x6+	adcs	x11,x11,x17+	and	x20,x22,x7+	adcs	x12,x12,x19+	and	x21,x22,x8+	adcs	x13,x13,x20+	and	x22,x22,x9+	adcs	x14,x14,x21+	extr	x10,x11,x10,#1	// a[0:5] >>= 1+	adcs	x15,x15,x22+	extr	x11,x12,x11,#1+	adc	x22,xzr,xzr+	extr	x12,x13,x12,#1+	extr	x13,x14,x13,#1+	extr	x14,x15,x14,#1+	extr	x15,x22,x15,#1+	ret+++.globl	div_by_2_mod_384++.def	div_by_2_mod_384;+.type	32;+.endef+.p2align	5+div_by_2_mod_384:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]+	ldp	x14,x15,[x1,#32]++	ldp	x4,x5,[x2]+	ldp	x6,x7,[x2,#16]+	ldp	x8,x9,[x2,#32]++	bl	__rshift_mod_384++	ldr	x30,[sp,#8]+	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]+	stp	x14,x15,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret+++.globl	lshift_mod_384++.def	lshift_mod_384;+.type	32;+.endef+.p2align	5+lshift_mod_384:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]+	ldp	x14,x15,[x1,#32]++	ldp	x4,x5,[x3]+	ldp	x6,x7,[x3,#16]+	ldp	x8,x9,[x3,#32]++.Loop_lshift_mod_384:+	sub	x2,x2,#1+	bl	__lshift_mod_384+	cbnz	x2,.Loop_lshift_mod_384++	ldr	x30,[sp,#8]+	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]+	stp	x14,x15,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret+++.def	__lshift_mod_384;+.type	32;+.endef+.p2align	5+__lshift_mod_384:+	adds	x10,x10,x10+	adcs	x11,x11,x11+	adcs	x12,x12,x12+	adcs	x13,x13,x13+	adcs	x14,x14,x14+	adcs	x15,x15,x15+	adc	x3,xzr,xzr++	subs	x16,x10,x4+	sbcs	x17,x11,x5+	sbcs	x19,x12,x6+	sbcs	x20,x13,x7+	sbcs	x21,x14,x8+	sbcs	x22,x15,x9+	sbcs	xzr,x3,xzr++	csel	x10,x10,x16,lo+	csel	x11,x11,x17,lo+	csel	x12,x12,x19,lo+	csel	x13,x13,x20,lo+	csel	x14,x14,x21,lo+	csel	x15,x15,x22,lo++	ret+++.globl	mul_by_3_mod_384++.def	mul_by_3_mod_384;+.type	32;+.endef+.p2align	5+mul_by_3_mod_384:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]+	ldp	x14,x15,[x1,#32]++	ldp	x4,x5,[x2]+	ldp	x6,x7,[x2,#16]+	ldp	x8,x9,[x2,#32]++	bl	__lshift_mod_384++	ldp	x16,x17,[x1]+	ldp	x19,x20,[x1,#16]+	ldp	x21,x22,[x1,#32]++	bl	__add_mod_384_ab_are_loaded+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]+	stp	x14,x15,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret+++.globl	mul_by_8_mod_384++.def	mul_by_8_mod_384;+.type	32;+.endef+.p2align	5+mul_by_8_mod_384:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]+	ldp	x14,x15,[x1,#32]++	ldp	x4,x5,[x2]+	ldp	x6,x7,[x2,#16]+	ldp	x8,x9,[x2,#32]++	bl	__lshift_mod_384+	bl	__lshift_mod_384+	bl	__lshift_mod_384+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]+	stp	x14,x15,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret+++.globl	mul_by_3_mod_384x++.def	mul_by_3_mod_384x;+.type	32;+.endef+.p2align	5+mul_by_3_mod_384x:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]+	ldp	x14,x15,[x1,#32]++	ldp	x4,x5,[x2]+	ldp	x6,x7,[x2,#16]+	ldp	x8,x9,[x2,#32]++	bl	__lshift_mod_384++	ldp	x16,x17,[x1]+	ldp	x19,x20,[x1,#16]+	ldp	x21,x22,[x1,#32]++	bl	__add_mod_384_ab_are_loaded++	stp	x10,x11,[x0]+	ldp	x10,x11,[x1,#48]+	stp	x12,x13,[x0,#16]+	ldp	x12,x13,[x1,#64]+	stp	x14,x15,[x0,#32]+	ldp	x14,x15,[x1,#80]++	bl	__lshift_mod_384++	ldp	x16,x17,[x1,#48]+	ldp	x19,x20,[x1,#64]+	ldp	x21,x22,[x1,#80]++	bl	__add_mod_384_ab_are_loaded+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0,#48]+	stp	x12,x13,[x0,#64]+	stp	x14,x15,[x0,#80]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret+++.globl	mul_by_8_mod_384x++.def	mul_by_8_mod_384x;+.type	32;+.endef+.p2align	5+mul_by_8_mod_384x:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]+	ldp	x14,x15,[x1,#32]++	ldp	x4,x5,[x2]+	ldp	x6,x7,[x2,#16]+	ldp	x8,x9,[x2,#32]++	bl	__lshift_mod_384+	bl	__lshift_mod_384+	bl	__lshift_mod_384++	stp	x10,x11,[x0]+	ldp	x10,x11,[x1,#48]+	stp	x12,x13,[x0,#16]+	ldp	x12,x13,[x1,#64]+	stp	x14,x15,[x0,#32]+	ldp	x14,x15,[x1,#80]++	bl	__lshift_mod_384+	bl	__lshift_mod_384+	bl	__lshift_mod_384+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0,#48]+	stp	x12,x13,[x0,#64]+	stp	x14,x15,[x0,#80]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret+++.globl	cneg_mod_384++.def	cneg_mod_384;+.type	32;+.endef+.p2align	5+cneg_mod_384:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x10,x11,[x1]+	ldp	x4,x5,[x3]+	ldp	x12,x13,[x1,#16]+	ldp	x6,x7,[x3,#16]++	subs	x16,x4,x10+	ldp	x14,x15,[x1,#32]+	ldp	x8,x9,[x3,#32]+	orr	x3,x10,x11+	sbcs	x17,x5,x11+	orr	x3,x3,x12+	sbcs	x19,x6,x12+	orr	x3,x3,x13+	sbcs	x20,x7,x13+	orr	x3,x3,x14+	sbcs	x21,x8,x14+	orr	x3,x3,x15+	sbc	x22,x9,x15++	cmp	x3,#0+	csetm	x3,ne+	ands	x2,x2,x3++	csel	x10,x10,x16,eq+	csel	x11,x11,x17,eq+	csel	x12,x12,x19,eq+	csel	x13,x13,x20,eq+	stp	x10,x11,[x0]+	csel	x14,x14,x21,eq+	stp	x12,x13,[x0,#16]+	csel	x15,x15,x22,eq+	stp	x14,x15,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret+++.globl	sub_mod_384++.def	sub_mod_384;+.type	32;+.endef+.p2align	5+sub_mod_384:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x4,x5,[x3]+	ldp	x6,x7,[x3,#16]+	ldp	x8,x9,[x3,#32]++	bl	__sub_mod_384+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]+	stp	x14,x15,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret+++.def	__sub_mod_384;+.type	32;+.endef+.p2align	5+__sub_mod_384:+	ldp	x10,x11,[x1]+	ldp	x16,x17,[x2]+	ldp	x12,x13,[x1,#16]+	ldp	x19,x20,[x2,#16]+	ldp	x14,x15,[x1,#32]+	ldp	x21,x22,[x2,#32]++	subs	x10,x10,x16+	sbcs	x11,x11,x17+	sbcs	x12,x12,x19+	sbcs	x13,x13,x20+	sbcs	x14,x14,x21+	sbcs	x15,x15,x22+	sbc	x3,xzr,xzr++	and	x16,x4,x3+	and	x17,x5,x3+	adds	x10,x10,x16+	and	x19,x6,x3+	adcs	x11,x11,x17+	and	x20,x7,x3+	adcs	x12,x12,x19+	and	x21,x8,x3+	adcs	x13,x13,x20+	and	x22,x9,x3+	adcs	x14,x14,x21+	adc	x15,x15,x22++	ret+++.globl	sub_mod_384x++.def	sub_mod_384x;+.type	32;+.endef+.p2align	5+sub_mod_384x:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x4,x5,[x3]+	ldp	x6,x7,[x3,#16]+	ldp	x8,x9,[x3,#32]++	bl	__sub_mod_384++	stp	x10,x11,[x0]+	add	x1,x1,#48+	stp	x12,x13,[x0,#16]+	add	x2,x2,#48+	stp	x14,x15,[x0,#32]++	bl	__sub_mod_384+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0,#48]+	stp	x12,x13,[x0,#64]+	stp	x14,x15,[x0,#80]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret+++.globl	mul_by_1_plus_i_mod_384x++.def	mul_by_1_plus_i_mod_384x;+.type	32;+.endef+.p2align	5+mul_by_1_plus_i_mod_384x:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x4,x5,[x2]+	ldp	x6,x7,[x2,#16]+	ldp	x8,x9,[x2,#32]+	add	x2,x1,#48++	bl	__sub_mod_384			// a->re - a->im++	ldp	x16,x17,[x1]+	ldp	x19,x20,[x1,#16]+	ldp	x21,x22,[x1,#32]+	stp	x10,x11,[x0]+	ldp	x10,x11,[x1,#48]+	stp	x12,x13,[x0,#16]+	ldp	x12,x13,[x1,#64]+	stp	x14,x15,[x0,#32]+	ldp	x14,x15,[x1,#80]++	bl	__add_mod_384_ab_are_loaded	// a->re + a->im+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0,#48]+	stp	x12,x13,[x0,#64]+	stp	x14,x15,[x0,#80]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret+++.globl	sgn0_pty_mod_384++.def	sgn0_pty_mod_384;+.type	32;+.endef+.p2align	5+sgn0_pty_mod_384:+	ldp	x10,x11,[x0]+	ldp	x12,x13,[x0,#16]+	ldp	x14,x15,[x0,#32]++	ldp	x4,x5,[x1]+	ldp	x6,x7,[x1,#16]+	ldp	x8,x9,[x1,#32]++	and	x0,x10,#1+	adds	x10,x10,x10+	adcs	x11,x11,x11+	adcs	x12,x12,x12+	adcs	x13,x13,x13+	adcs	x14,x14,x14+	adcs	x15,x15,x15+	adc	x3,xzr,xzr++	subs	x10,x10,x4+	sbcs	x11,x11,x5+	sbcs	x12,x12,x6+	sbcs	x13,x13,x7+	sbcs	x14,x14,x8+	sbcs	x15,x15,x9+	sbc	x3,x3,xzr++	mvn	x3,x3+	and	x3,x3,#2+	orr	x0,x0,x3++	ret+++.globl	sgn0_pty_mod_384x++.def	sgn0_pty_mod_384x;+.type	32;+.endef+.p2align	5+sgn0_pty_mod_384x:+	ldp	x10,x11,[x0]+	ldp	x12,x13,[x0,#16]+	ldp	x14,x15,[x0,#32]++	ldp	x4,x5,[x1]+	ldp	x6,x7,[x1,#16]+	ldp	x8,x9,[x1,#32]++	and	x2,x10,#1+	orr	x3,x10,x11+	adds	x10,x10,x10+	orr	x3,x3,x12+	adcs	x11,x11,x11+	orr	x3,x3,x13+	adcs	x12,x12,x12+	orr	x3,x3,x14+	adcs	x13,x13,x13+	orr	x3,x3,x15+	adcs	x14,x14,x14+	adcs	x15,x15,x15+	adc	x16,xzr,xzr++	subs	x10,x10,x4+	sbcs	x11,x11,x5+	sbcs	x12,x12,x6+	sbcs	x13,x13,x7+	sbcs	x14,x14,x8+	sbcs	x15,x15,x9+	sbc	x16,x16,xzr++	ldp	x10,x11,[x0,#48]+	ldp	x12,x13,[x0,#64]+	ldp	x14,x15,[x0,#80]++	mvn	x16,x16+	and	x16,x16,#2+	orr	x2,x2,x16++	and	x0,x10,#1+	orr	x1,x10,x11+	adds	x10,x10,x10+	orr	x1,x1,x12+	adcs	x11,x11,x11+	orr	x1,x1,x13+	adcs	x12,x12,x12+	orr	x1,x1,x14+	adcs	x13,x13,x13+	orr	x1,x1,x15+	adcs	x14,x14,x14+	adcs	x15,x15,x15+	adc	x16,xzr,xzr++	subs	x10,x10,x4+	sbcs	x11,x11,x5+	sbcs	x12,x12,x6+	sbcs	x13,x13,x7+	sbcs	x14,x14,x8+	sbcs	x15,x15,x9+	sbc	x16,x16,xzr++	mvn	x16,x16+	and	x16,x16,#2+	orr	x0,x0,x16++	cmp	x3,#0+	csel	x3,x0,x2,eq	// a->re==0? prty(a->im) : prty(a->re)++	cmp	x1,#0+	csel	x1,x0,x2,ne	// a->im!=0? sgn0(a->im) : sgn0(a->re)++	and	x3,x3,#1+	and	x1,x1,#2+	orr	x0,x1,x3	// pack sign and parity++	ret++.globl	vec_select_48++.def	vec_select_48;+.type	32;+.endef+.p2align	5+vec_select_48:+	dup	v6.2d, x3+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	cmeq	v6.2d, v6.2d, #0+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v0.16b, v3.16b, v6.16b+	bit	v1.16b, v4.16b, v6.16b+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0]+	ret++.globl	vec_select_96++.def	vec_select_96;+.type	32;+.endef+.p2align	5+vec_select_96:+	dup	v6.2d, x3+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	cmeq	v6.2d, v6.2d, #0+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v0.16b, v3.16b, v6.16b+	ld1	{v16.2d, v17.2d, v18.2d}, [x1],#48+	bit	v1.16b, v4.16b, v6.16b+	ld1	{v19.2d, v20.2d, v21.2d}, [x2],#48+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0],#48+	bit	v16.16b, v19.16b, v6.16b+	bit	v17.16b, v20.16b, v6.16b+	bit	v18.16b, v21.16b, v6.16b+	st1	{v16.2d, v17.2d, v18.2d}, [x0]+	ret++.globl	vec_select_192++.def	vec_select_192;+.type	32;+.endef+.p2align	5+vec_select_192:+	dup	v6.2d, x3+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	cmeq	v6.2d, v6.2d, #0+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v0.16b, v3.16b, v6.16b+	ld1	{v16.2d, v17.2d, v18.2d}, [x1],#48+	bit	v1.16b, v4.16b, v6.16b+	ld1	{v19.2d, v20.2d, v21.2d}, [x2],#48+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0],#48+	bit	v16.16b, v19.16b, v6.16b+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	bit	v17.16b, v20.16b, v6.16b+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v18.16b, v21.16b, v6.16b+	st1	{v16.2d, v17.2d, v18.2d}, [x0],#48+	bit	v0.16b, v3.16b, v6.16b+	ld1	{v16.2d, v17.2d, v18.2d}, [x1],#48+	bit	v1.16b, v4.16b, v6.16b+	ld1	{v19.2d, v20.2d, v21.2d}, [x2],#48+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0],#48+	bit	v16.16b, v19.16b, v6.16b+	bit	v17.16b, v20.16b, v6.16b+	bit	v18.16b, v21.16b, v6.16b+	st1	{v16.2d, v17.2d, v18.2d}, [x0]+	ret++.globl	vec_select_144++.def	vec_select_144;+.type	32;+.endef+.p2align	5+vec_select_144:+	dup	v6.2d, x3+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	cmeq	v6.2d, v6.2d, #0+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v0.16b, v3.16b, v6.16b+	ld1	{v16.2d, v17.2d, v18.2d}, [x1],#48+	bit	v1.16b, v4.16b, v6.16b+	ld1	{v19.2d, v20.2d, v21.2d}, [x2],#48+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0],#48+	bit	v16.16b, v19.16b, v6.16b+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	bit	v17.16b, v20.16b, v6.16b+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v18.16b, v21.16b, v6.16b+	st1	{v16.2d, v17.2d, v18.2d}, [x0],#48+	bit	v0.16b, v3.16b, v6.16b+	bit	v1.16b, v4.16b, v6.16b+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0]+	ret++.globl	vec_select_288++.def	vec_select_288;+.type	32;+.endef+.p2align	5+vec_select_288:+	dup	v6.2d, x3+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	cmeq	v6.2d, v6.2d, #0+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v0.16b, v3.16b, v6.16b+	ld1	{v16.2d, v17.2d, v18.2d}, [x1],#48+	bit	v1.16b, v4.16b, v6.16b+	ld1	{v19.2d, v20.2d, v21.2d}, [x2],#48+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0],#48+	bit	v16.16b, v19.16b, v6.16b+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	bit	v17.16b, v20.16b, v6.16b+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v18.16b, v21.16b, v6.16b+	st1	{v16.2d, v17.2d, v18.2d}, [x0],#48+	bit	v0.16b, v3.16b, v6.16b+	ld1	{v16.2d, v17.2d, v18.2d}, [x1],#48+	bit	v1.16b, v4.16b, v6.16b+	ld1	{v19.2d, v20.2d, v21.2d}, [x2],#48+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0],#48+	bit	v16.16b, v19.16b, v6.16b+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	bit	v17.16b, v20.16b, v6.16b+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v18.16b, v21.16b, v6.16b+	st1	{v16.2d, v17.2d, v18.2d}, [x0],#48+	bit	v0.16b, v3.16b, v6.16b+	ld1	{v16.2d, v17.2d, v18.2d}, [x1],#48+	bit	v1.16b, v4.16b, v6.16b+	ld1	{v19.2d, v20.2d, v21.2d}, [x2],#48+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0],#48+	bit	v16.16b, v19.16b, v6.16b+	bit	v17.16b, v20.16b, v6.16b+	bit	v18.16b, v21.16b, v6.16b+	st1	{v16.2d, v17.2d, v18.2d}, [x0]+	ret++.globl	vec_prefetch++.def	vec_prefetch;+.type	32;+.endef+.p2align	5+vec_prefetch:+	add	x1, x1, x0+	sub	x1, x1, #1+	mov	x2, #64+	prfm	pldl1keep, [x0]+	add	x0, x0, x2+	cmp	x0, x1+	csel	x0, x1, x0, hi+	csel	x2, xzr, x2, hi+	prfm	pldl1keep, [x0]+	add	x0, x0, x2+	cmp	x0, x1+	csel	x0, x1, x0, hi+	csel	x2, xzr, x2, hi+	prfm	pldl1keep, [x0]+	add	x0, x0, x2+	cmp	x0, x1+	csel	x0, x1, x0, hi+	csel	x2, xzr, x2, hi+	prfm	pldl1keep, [x0]+	add	x0, x0, x2+	cmp	x0, x1+	csel	x0, x1, x0, hi+	csel	x2, xzr, x2, hi+	prfm	pldl1keep, [x0]+	add	x0, x0, x2+	cmp	x0, x1+	csel	x0, x1, x0, hi+	csel	x2, xzr, x2, hi+	prfm	pldl1keep, [x0]+	add	x0, x0, x2+	cmp	x0, x1+	csel	x0, x1, x0, hi+	prfm	pldl1keep, [x0]+	ret+
+ c-source/build/coff/add_mod_384-x86_64.s view
@@ -0,0 +1,2389 @@+.text	++.globl	add_mod_384++.def	add_mod_384;	.scl 2;	.type 32;	.endef+.p2align	5+add_mod_384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_add_mod_384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$8,%rsp++.LSEH_body_add_mod_384:+++	call	__add_mod_384++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_add_mod_384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_add_mod_384:++.def	__add_mod_384;	.scl 3;	.type 32;	.endef+.p2align	5+__add_mod_384:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++__add_mod_384_a_is_loaded:+	addq	0(%rdx),%r8+	adcq	8(%rdx),%r9+	adcq	16(%rdx),%r10+	movq	%r8,%r14+	adcq	24(%rdx),%r11+	movq	%r9,%r15+	adcq	32(%rdx),%r12+	movq	%r10,%rax+	adcq	40(%rdx),%r13+	movq	%r11,%rbx+	sbbq	%rdx,%rdx++	subq	0(%rcx),%r8+	sbbq	8(%rcx),%r9+	movq	%r12,%rbp+	sbbq	16(%rcx),%r10+	sbbq	24(%rcx),%r11+	sbbq	32(%rcx),%r12+	movq	%r13,%rsi+	sbbq	40(%rcx),%r13+	sbbq	$0,%rdx++	cmovcq	%r14,%r8+	cmovcq	%r15,%r9+	cmovcq	%rax,%r10+	movq	%r8,0(%rdi)+	cmovcq	%rbx,%r11+	movq	%r9,8(%rdi)+	cmovcq	%rbp,%r12+	movq	%r10,16(%rdi)+	cmovcq	%rsi,%r13+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3+++.globl	add_mod_384x++.def	add_mod_384x;	.scl 2;	.type 32;	.endef+.p2align	5+add_mod_384x:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_add_mod_384x:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$24,%rsp++.LSEH_body_add_mod_384x:+++	movq	%rsi,0(%rsp)+	movq	%rdx,8(%rsp)+	leaq	48(%rsi),%rsi+	leaq	48(%rdx),%rdx+	leaq	48(%rdi),%rdi+	call	__add_mod_384++	movq	0(%rsp),%rsi+	movq	8(%rsp),%rdx+	leaq	-48(%rdi),%rdi+	call	__add_mod_384++	movq	24+0(%rsp),%r15++	movq	24+8(%rsp),%r14++	movq	24+16(%rsp),%r13++	movq	24+24(%rsp),%r12++	movq	24+32(%rsp),%rbx++	movq	24+40(%rsp),%rbp++	leaq	24+48(%rsp),%rsp++.LSEH_epilogue_add_mod_384x:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_add_mod_384x:+++.globl	rshift_mod_384++.def	rshift_mod_384;	.scl 2;	.type 32;	.endef+.p2align	5+rshift_mod_384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_rshift_mod_384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	pushq	%rdi++.LSEH_body_rshift_mod_384:+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++.Loop_rshift_mod_384:+	call	__rshift_mod_384+	decl	%edx+	jnz	.Loop_rshift_mod_384++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_rshift_mod_384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_rshift_mod_384:++.def	__rshift_mod_384;	.scl 3;	.type 32;	.endef+.p2align	5+__rshift_mod_384:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	$1,%rsi+	movq	0(%rcx),%r14+	andq	%r8,%rsi+	movq	8(%rcx),%r15+	negq	%rsi+	movq	16(%rcx),%rax+	andq	%rsi,%r14+	movq	24(%rcx),%rbx+	andq	%rsi,%r15+	movq	32(%rcx),%rbp+	andq	%rsi,%rax+	andq	%rsi,%rbx+	andq	%rsi,%rbp+	andq	40(%rcx),%rsi++	addq	%r8,%r14+	adcq	%r9,%r15+	adcq	%r10,%rax+	adcq	%r11,%rbx+	adcq	%r12,%rbp+	adcq	%r13,%rsi+	sbbq	%r13,%r13++	shrq	$1,%r14+	movq	%r15,%r8+	shrq	$1,%r15+	movq	%rax,%r9+	shrq	$1,%rax+	movq	%rbx,%r10+	shrq	$1,%rbx+	movq	%rbp,%r11+	shrq	$1,%rbp+	movq	%rsi,%r12+	shrq	$1,%rsi+	shlq	$63,%r8+	shlq	$63,%r9+	orq	%r14,%r8+	shlq	$63,%r10+	orq	%r15,%r9+	shlq	$63,%r11+	orq	%rax,%r10+	shlq	$63,%r12+	orq	%rbx,%r11+	shlq	$63,%r13+	orq	%rbp,%r12+	orq	%rsi,%r13++	.byte	0xf3,0xc3+++.globl	div_by_2_mod_384++.def	div_by_2_mod_384;	.scl 2;	.type 32;	.endef+.p2align	5+div_by_2_mod_384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_div_by_2_mod_384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	pushq	%rdi++.LSEH_body_div_by_2_mod_384:+++	movq	0(%rsi),%r8+	movq	%rdx,%rcx+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	call	__rshift_mod_384++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_div_by_2_mod_384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_div_by_2_mod_384:+++.globl	lshift_mod_384++.def	lshift_mod_384;	.scl 2;	.type 32;	.endef+.p2align	5+lshift_mod_384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_lshift_mod_384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	pushq	%rdi++.LSEH_body_lshift_mod_384:+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++.Loop_lshift_mod_384:+	addq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	movq	%r8,%r14+	adcq	%r11,%r11+	movq	%r9,%r15+	adcq	%r12,%r12+	movq	%r10,%rax+	adcq	%r13,%r13+	movq	%r11,%rbx+	sbbq	%rdi,%rdi++	subq	0(%rcx),%r8+	sbbq	8(%rcx),%r9+	movq	%r12,%rbp+	sbbq	16(%rcx),%r10+	sbbq	24(%rcx),%r11+	sbbq	32(%rcx),%r12+	movq	%r13,%rsi+	sbbq	40(%rcx),%r13+	sbbq	$0,%rdi++	movq	(%rsp),%rdi+	cmovcq	%r14,%r8+	cmovcq	%r15,%r9+	cmovcq	%rax,%r10+	cmovcq	%rbx,%r11+	cmovcq	%rbp,%r12+	cmovcq	%rsi,%r13++	decl	%edx+	jnz	.Loop_lshift_mod_384++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_lshift_mod_384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_lshift_mod_384:++.def	__lshift_mod_384;	.scl 3;	.type 32;	.endef+.p2align	5+__lshift_mod_384:+	.byte	0xf3,0x0f,0x1e,0xfa++	addq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	movq	%r8,%r14+	adcq	%r11,%r11+	movq	%r9,%r15+	adcq	%r12,%r12+	movq	%r10,%rax+	adcq	%r13,%r13+	movq	%r11,%rbx+	sbbq	%rdx,%rdx++	subq	0(%rcx),%r8+	sbbq	8(%rcx),%r9+	movq	%r12,%rbp+	sbbq	16(%rcx),%r10+	sbbq	24(%rcx),%r11+	sbbq	32(%rcx),%r12+	movq	%r13,%rsi+	sbbq	40(%rcx),%r13+	sbbq	$0,%rdx++	cmovcq	%r14,%r8+	cmovcq	%r15,%r9+	cmovcq	%rax,%r10+	cmovcq	%rbx,%r11+	cmovcq	%rbp,%r12+	cmovcq	%rsi,%r13++	.byte	0xf3,0xc3++++.globl	mul_by_3_mod_384++.def	mul_by_3_mod_384;	.scl 2;	.type 32;	.endef+.p2align	5+mul_by_3_mod_384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_mul_by_3_mod_384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	pushq	%rsi++.LSEH_body_mul_by_3_mod_384:+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	%rdx,%rcx++	call	__lshift_mod_384++	movq	(%rsp),%rdx+	call	__add_mod_384_a_is_loaded++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_mul_by_3_mod_384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_mul_by_3_mod_384:++.globl	mul_by_8_mod_384++.def	mul_by_8_mod_384;	.scl 2;	.type 32;	.endef+.p2align	5+mul_by_8_mod_384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_mul_by_8_mod_384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$8,%rsp++.LSEH_body_mul_by_8_mod_384:+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	%rdx,%rcx++	call	__lshift_mod_384+	call	__lshift_mod_384+	call	__lshift_mod_384++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_mul_by_8_mod_384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_mul_by_8_mod_384:+++.globl	mul_by_3_mod_384x++.def	mul_by_3_mod_384x;	.scl 2;	.type 32;	.endef+.p2align	5+mul_by_3_mod_384x:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_mul_by_3_mod_384x:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	pushq	%rsi++.LSEH_body_mul_by_3_mod_384x:+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	%rdx,%rcx++	call	__lshift_mod_384++	movq	(%rsp),%rdx+	call	__add_mod_384_a_is_loaded++	movq	(%rsp),%rsi+	leaq	48(%rdi),%rdi++	movq	48(%rsi),%r8+	movq	56(%rsi),%r9+	movq	64(%rsi),%r10+	movq	72(%rsi),%r11+	movq	80(%rsi),%r12+	movq	88(%rsi),%r13++	call	__lshift_mod_384++	movq	$48,%rdx+	addq	(%rsp),%rdx+	call	__add_mod_384_a_is_loaded++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_mul_by_3_mod_384x:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_mul_by_3_mod_384x:++.globl	mul_by_8_mod_384x++.def	mul_by_8_mod_384x;	.scl 2;	.type 32;	.endef+.p2align	5+mul_by_8_mod_384x:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_mul_by_8_mod_384x:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	pushq	%rsi++.LSEH_body_mul_by_8_mod_384x:+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	%rdx,%rcx++	call	__lshift_mod_384+	call	__lshift_mod_384+	call	__lshift_mod_384++	movq	(%rsp),%rsi+	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	movq	48+0(%rsi),%r8+	movq	48+8(%rsi),%r9+	movq	48+16(%rsi),%r10+	movq	48+24(%rsi),%r11+	movq	48+32(%rsi),%r12+	movq	48+40(%rsi),%r13++	call	__lshift_mod_384+	call	__lshift_mod_384+	call	__lshift_mod_384++	movq	%r8,48+0(%rdi)+	movq	%r9,48+8(%rdi)+	movq	%r10,48+16(%rdi)+	movq	%r11,48+24(%rdi)+	movq	%r12,48+32(%rdi)+	movq	%r13,48+40(%rdi)++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_mul_by_8_mod_384x:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_mul_by_8_mod_384x:+++.globl	cneg_mod_384++.def	cneg_mod_384;	.scl 2;	.type 32;	.endef+.p2align	5+cneg_mod_384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_cneg_mod_384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	pushq	%rdx++.LSEH_body_cneg_mod_384:+++	movq	0(%rsi),%rdx+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	%rdx,%r8+	movq	24(%rsi),%r11+	orq	%r9,%rdx+	movq	32(%rsi),%r12+	orq	%r10,%rdx+	movq	40(%rsi),%r13+	orq	%r11,%rdx+	movq	$-1,%rsi+	orq	%r12,%rdx+	orq	%r13,%rdx++	movq	0(%rcx),%r14+	cmovnzq	%rsi,%rdx+	movq	8(%rcx),%r15+	movq	16(%rcx),%rax+	andq	%rdx,%r14+	movq	24(%rcx),%rbx+	andq	%rdx,%r15+	movq	32(%rcx),%rbp+	andq	%rdx,%rax+	movq	40(%rcx),%rsi+	andq	%rdx,%rbx+	movq	0(%rsp),%rcx+	andq	%rdx,%rbp+	andq	%rdx,%rsi++	subq	%r8,%r14+	sbbq	%r9,%r15+	sbbq	%r10,%rax+	sbbq	%r11,%rbx+	sbbq	%r12,%rbp+	sbbq	%r13,%rsi++	orq	%rcx,%rcx++	cmovzq	%r8,%r14+	cmovzq	%r9,%r15+	cmovzq	%r10,%rax+	movq	%r14,0(%rdi)+	cmovzq	%r11,%rbx+	movq	%r15,8(%rdi)+	cmovzq	%r12,%rbp+	movq	%rax,16(%rdi)+	cmovzq	%r13,%rsi+	movq	%rbx,24(%rdi)+	movq	%rbp,32(%rdi)+	movq	%rsi,40(%rdi)++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_cneg_mod_384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_cneg_mod_384:+++.globl	sub_mod_384++.def	sub_mod_384;	.scl 2;	.type 32;	.endef+.p2align	5+sub_mod_384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sub_mod_384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$8,%rsp++.LSEH_body_sub_mod_384:+++	call	__sub_mod_384++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_sub_mod_384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sub_mod_384:++.def	__sub_mod_384;	.scl 3;	.type 32;	.endef+.p2align	5+__sub_mod_384:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	subq	0(%rdx),%r8+	movq	0(%rcx),%r14+	sbbq	8(%rdx),%r9+	movq	8(%rcx),%r15+	sbbq	16(%rdx),%r10+	movq	16(%rcx),%rax+	sbbq	24(%rdx),%r11+	movq	24(%rcx),%rbx+	sbbq	32(%rdx),%r12+	movq	32(%rcx),%rbp+	sbbq	40(%rdx),%r13+	movq	40(%rcx),%rsi+	sbbq	%rdx,%rdx++	andq	%rdx,%r14+	andq	%rdx,%r15+	andq	%rdx,%rax+	andq	%rdx,%rbx+	andq	%rdx,%rbp+	andq	%rdx,%rsi++	addq	%r14,%r8+	adcq	%r15,%r9+	movq	%r8,0(%rdi)+	adcq	%rax,%r10+	movq	%r9,8(%rdi)+	adcq	%rbx,%r11+	movq	%r10,16(%rdi)+	adcq	%rbp,%r12+	movq	%r11,24(%rdi)+	adcq	%rsi,%r13+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3+++.globl	sub_mod_384x++.def	sub_mod_384x;	.scl 2;	.type 32;	.endef+.p2align	5+sub_mod_384x:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sub_mod_384x:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$24,%rsp++.LSEH_body_sub_mod_384x:+++	movq	%rsi,0(%rsp)+	movq	%rdx,8(%rsp)+	leaq	48(%rsi),%rsi+	leaq	48(%rdx),%rdx+	leaq	48(%rdi),%rdi+	call	__sub_mod_384++	movq	0(%rsp),%rsi+	movq	8(%rsp),%rdx+	leaq	-48(%rdi),%rdi+	call	__sub_mod_384++	movq	24+0(%rsp),%r15++	movq	24+8(%rsp),%r14++	movq	24+16(%rsp),%r13++	movq	24+24(%rsp),%r12++	movq	24+32(%rsp),%rbx++	movq	24+40(%rsp),%rbp++	leaq	24+48(%rsp),%rsp++.LSEH_epilogue_sub_mod_384x:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sub_mod_384x:+.globl	mul_by_1_plus_i_mod_384x++.def	mul_by_1_plus_i_mod_384x;	.scl 2;	.type 32;	.endef+.p2align	5+mul_by_1_plus_i_mod_384x:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_mul_by_1_plus_i_mod_384x:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$56,%rsp++.LSEH_body_mul_by_1_plus_i_mod_384x:+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%r8,%r14+	addq	48(%rsi),%r8+	movq	%r9,%r15+	adcq	56(%rsi),%r9+	movq	%r10,%rax+	adcq	64(%rsi),%r10+	movq	%r11,%rbx+	adcq	72(%rsi),%r11+	movq	%r12,%rcx+	adcq	80(%rsi),%r12+	movq	%r13,%rbp+	adcq	88(%rsi),%r13+	movq	%rdi,48(%rsp)+	sbbq	%rdi,%rdi++	subq	48(%rsi),%r14+	sbbq	56(%rsi),%r15+	sbbq	64(%rsi),%rax+	sbbq	72(%rsi),%rbx+	sbbq	80(%rsi),%rcx+	sbbq	88(%rsi),%rbp+	sbbq	%rsi,%rsi++	movq	%r8,0(%rsp)+	movq	0(%rdx),%r8+	movq	%r9,8(%rsp)+	movq	8(%rdx),%r9+	movq	%r10,16(%rsp)+	movq	16(%rdx),%r10+	movq	%r11,24(%rsp)+	movq	24(%rdx),%r11+	movq	%r12,32(%rsp)+	andq	%rsi,%r8+	movq	32(%rdx),%r12+	movq	%r13,40(%rsp)+	andq	%rsi,%r9+	movq	40(%rdx),%r13+	andq	%rsi,%r10+	andq	%rsi,%r11+	andq	%rsi,%r12+	andq	%rsi,%r13+	movq	48(%rsp),%rsi++	addq	%r8,%r14+	movq	0(%rsp),%r8+	adcq	%r9,%r15+	movq	8(%rsp),%r9+	adcq	%r10,%rax+	movq	16(%rsp),%r10+	adcq	%r11,%rbx+	movq	24(%rsp),%r11+	adcq	%r12,%rcx+	movq	32(%rsp),%r12+	adcq	%r13,%rbp+	movq	40(%rsp),%r13++	movq	%r14,0(%rsi)+	movq	%r8,%r14+	movq	%r15,8(%rsi)+	movq	%rax,16(%rsi)+	movq	%r9,%r15+	movq	%rbx,24(%rsi)+	movq	%rcx,32(%rsi)+	movq	%r10,%rax+	movq	%rbp,40(%rsi)++	subq	0(%rdx),%r8+	movq	%r11,%rbx+	sbbq	8(%rdx),%r9+	sbbq	16(%rdx),%r10+	movq	%r12,%rcx+	sbbq	24(%rdx),%r11+	sbbq	32(%rdx),%r12+	movq	%r13,%rbp+	sbbq	40(%rdx),%r13+	sbbq	$0,%rdi++	cmovcq	%r14,%r8+	cmovcq	%r15,%r9+	cmovcq	%rax,%r10+	movq	%r8,48(%rsi)+	cmovcq	%rbx,%r11+	movq	%r9,56(%rsi)+	cmovcq	%rcx,%r12+	movq	%r10,64(%rsi)+	cmovcq	%rbp,%r13+	movq	%r11,72(%rsi)+	movq	%r12,80(%rsi)+	movq	%r13,88(%rsi)++	movq	56+0(%rsp),%r15++	movq	56+8(%rsp),%r14++	movq	56+16(%rsp),%r13++	movq	56+24(%rsp),%r12++	movq	56+32(%rsp),%rbx++	movq	56+40(%rsp),%rbp++	leaq	56+48(%rsp),%rsp++.LSEH_epilogue_mul_by_1_plus_i_mod_384x:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_mul_by_1_plus_i_mod_384x:+.globl	sgn0_pty_mod_384++.def	sgn0_pty_mod_384;	.scl 2;	.type 32;	.endef+.p2align	5+sgn0_pty_mod_384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sgn0_pty_mod_384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+++.LSEH_body_sgn0_pty_mod_384:++	movq	0(%rdi),%r8+	movq	8(%rdi),%r9+	movq	16(%rdi),%r10+	movq	24(%rdi),%r11+	movq	32(%rdi),%rcx+	movq	40(%rdi),%rdx++	xorq	%rax,%rax+	movq	%r8,%rdi+	addq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	%rcx,%rcx+	adcq	%rdx,%rdx+	adcq	$0,%rax++	subq	0(%rsi),%r8+	sbbq	8(%rsi),%r9+	sbbq	16(%rsi),%r10+	sbbq	24(%rsi),%r11+	sbbq	32(%rsi),%rcx+	sbbq	40(%rsi),%rdx+	sbbq	$0,%rax++	notq	%rax+	andq	$1,%rdi+	andq	$2,%rax+	orq	%rdi,%rax++.LSEH_epilogue_sgn0_pty_mod_384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sgn0_pty_mod_384:++.globl	sgn0_pty_mod_384x++.def	sgn0_pty_mod_384x;	.scl 2;	.type 32;	.endef+.p2align	5+sgn0_pty_mod_384x:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sgn0_pty_mod_384x:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+++	pushq	%rbp++	pushq	%rbx++	subq	$8,%rsp++.LSEH_body_sgn0_pty_mod_384x:+++	movq	48(%rdi),%r8+	movq	56(%rdi),%r9+	movq	64(%rdi),%r10+	movq	72(%rdi),%r11+	movq	80(%rdi),%rcx+	movq	88(%rdi),%rdx++	movq	%r8,%rbx+	orq	%r9,%r8+	orq	%r10,%r8+	orq	%r11,%r8+	orq	%rcx,%r8+	orq	%rdx,%r8++	leaq	0(%rdi),%rax+	xorq	%rdi,%rdi+	movq	%rbx,%rbp+	addq	%rbx,%rbx+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	%rcx,%rcx+	adcq	%rdx,%rdx+	adcq	$0,%rdi++	subq	0(%rsi),%rbx+	sbbq	8(%rsi),%r9+	sbbq	16(%rsi),%r10+	sbbq	24(%rsi),%r11+	sbbq	32(%rsi),%rcx+	sbbq	40(%rsi),%rdx+	sbbq	$0,%rdi++	movq	%r8,0(%rsp)+	notq	%rdi+	andq	$1,%rbp+	andq	$2,%rdi+	orq	%rbp,%rdi++	movq	0(%rax),%r8+	movq	8(%rax),%r9+	movq	16(%rax),%r10+	movq	24(%rax),%r11+	movq	32(%rax),%rcx+	movq	40(%rax),%rdx++	movq	%r8,%rbx+	orq	%r9,%r8+	orq	%r10,%r8+	orq	%r11,%r8+	orq	%rcx,%r8+	orq	%rdx,%r8++	xorq	%rax,%rax+	movq	%rbx,%rbp+	addq	%rbx,%rbx+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	%rcx,%rcx+	adcq	%rdx,%rdx+	adcq	$0,%rax++	subq	0(%rsi),%rbx+	sbbq	8(%rsi),%r9+	sbbq	16(%rsi),%r10+	sbbq	24(%rsi),%r11+	sbbq	32(%rsi),%rcx+	sbbq	40(%rsi),%rdx+	sbbq	$0,%rax++	movq	0(%rsp),%rbx++	notq	%rax++	testq	%r8,%r8+	cmovzq	%rdi,%rbp++	testq	%rbx,%rbx+	cmovnzq	%rdi,%rax++	andq	$1,%rbp+	andq	$2,%rax+	orq	%rbp,%rax++	movq	8(%rsp),%rbx++	movq	16(%rsp),%rbp++	leaq	24(%rsp),%rsp++.LSEH_epilogue_sgn0_pty_mod_384x:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sgn0_pty_mod_384x:+.globl	vec_select_48++.def	vec_select_48;	.scl 2;	.type 32;	.endef+.p2align	5+vec_select_48:+	.byte	0xf3,0x0f,0x1e,0xfa++	movd	%r9d,%xmm5+	pxor	%xmm4,%xmm4+	pshufd	$0,%xmm5,%xmm5+	movdqu	(%rdx),%xmm0+	leaq	24(%rdx),%rdx+	pcmpeqd	%xmm4,%xmm5+	movdqu	(%r8),%xmm1+	leaq	24(%r8),%r8+	pcmpeqd	%xmm5,%xmm4+	leaq	24(%rcx),%rcx+	pand	%xmm4,%xmm0+	movdqu	0+16-24(%rdx),%xmm2+	pand	%xmm5,%xmm1+	movdqu	0+16-24(%r8),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,0-24(%rcx)+	pand	%xmm4,%xmm2+	movdqu	16+16-24(%rdx),%xmm0+	pand	%xmm5,%xmm3+	movdqu	16+16-24(%r8),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,16-24(%rcx)+	pand	%xmm4,%xmm0+	pand	%xmm5,%xmm1+	por	%xmm1,%xmm0+	movdqu	%xmm0,32-24(%rcx)+	.byte	0xf3,0xc3++.globl	vec_select_96++.def	vec_select_96;	.scl 2;	.type 32;	.endef+.p2align	5+vec_select_96:+	.byte	0xf3,0x0f,0x1e,0xfa++	movd	%r9d,%xmm5+	pxor	%xmm4,%xmm4+	pshufd	$0,%xmm5,%xmm5+	movdqu	(%rdx),%xmm0+	leaq	48(%rdx),%rdx+	pcmpeqd	%xmm4,%xmm5+	movdqu	(%r8),%xmm1+	leaq	48(%r8),%r8+	pcmpeqd	%xmm5,%xmm4+	leaq	48(%rcx),%rcx+	pand	%xmm4,%xmm0+	movdqu	0+16-48(%rdx),%xmm2+	pand	%xmm5,%xmm1+	movdqu	0+16-48(%r8),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,0-48(%rcx)+	pand	%xmm4,%xmm2+	movdqu	16+16-48(%rdx),%xmm0+	pand	%xmm5,%xmm3+	movdqu	16+16-48(%r8),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,16-48(%rcx)+	pand	%xmm4,%xmm0+	movdqu	32+16-48(%rdx),%xmm2+	pand	%xmm5,%xmm1+	movdqu	32+16-48(%r8),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,32-48(%rcx)+	pand	%xmm4,%xmm2+	movdqu	48+16-48(%rdx),%xmm0+	pand	%xmm5,%xmm3+	movdqu	48+16-48(%r8),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,48-48(%rcx)+	pand	%xmm4,%xmm0+	movdqu	64+16-48(%rdx),%xmm2+	pand	%xmm5,%xmm1+	movdqu	64+16-48(%r8),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,64-48(%rcx)+	pand	%xmm4,%xmm2+	pand	%xmm5,%xmm3+	por	%xmm3,%xmm2+	movdqu	%xmm2,80-48(%rcx)+	.byte	0xf3,0xc3++.globl	vec_select_192++.def	vec_select_192;	.scl 2;	.type 32;	.endef+.p2align	5+vec_select_192:+	.byte	0xf3,0x0f,0x1e,0xfa++	movd	%r9d,%xmm5+	pxor	%xmm4,%xmm4+	pshufd	$0,%xmm5,%xmm5+	movdqu	(%rdx),%xmm0+	leaq	96(%rdx),%rdx+	pcmpeqd	%xmm4,%xmm5+	movdqu	(%r8),%xmm1+	leaq	96(%r8),%r8+	pcmpeqd	%xmm5,%xmm4+	leaq	96(%rcx),%rcx+	pand	%xmm4,%xmm0+	movdqu	0+16-96(%rdx),%xmm2+	pand	%xmm5,%xmm1+	movdqu	0+16-96(%r8),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,0-96(%rcx)+	pand	%xmm4,%xmm2+	movdqu	16+16-96(%rdx),%xmm0+	pand	%xmm5,%xmm3+	movdqu	16+16-96(%r8),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,16-96(%rcx)+	pand	%xmm4,%xmm0+	movdqu	32+16-96(%rdx),%xmm2+	pand	%xmm5,%xmm1+	movdqu	32+16-96(%r8),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,32-96(%rcx)+	pand	%xmm4,%xmm2+	movdqu	48+16-96(%rdx),%xmm0+	pand	%xmm5,%xmm3+	movdqu	48+16-96(%r8),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,48-96(%rcx)+	pand	%xmm4,%xmm0+	movdqu	64+16-96(%rdx),%xmm2+	pand	%xmm5,%xmm1+	movdqu	64+16-96(%r8),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,64-96(%rcx)+	pand	%xmm4,%xmm2+	movdqu	80+16-96(%rdx),%xmm0+	pand	%xmm5,%xmm3+	movdqu	80+16-96(%r8),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,80-96(%rcx)+	pand	%xmm4,%xmm0+	movdqu	96+16-96(%rdx),%xmm2+	pand	%xmm5,%xmm1+	movdqu	96+16-96(%r8),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,96-96(%rcx)+	pand	%xmm4,%xmm2+	movdqu	112+16-96(%rdx),%xmm0+	pand	%xmm5,%xmm3+	movdqu	112+16-96(%r8),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,112-96(%rcx)+	pand	%xmm4,%xmm0+	movdqu	128+16-96(%rdx),%xmm2+	pand	%xmm5,%xmm1+	movdqu	128+16-96(%r8),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,128-96(%rcx)+	pand	%xmm4,%xmm2+	movdqu	144+16-96(%rdx),%xmm0+	pand	%xmm5,%xmm3+	movdqu	144+16-96(%r8),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,144-96(%rcx)+	pand	%xmm4,%xmm0+	movdqu	160+16-96(%rdx),%xmm2+	pand	%xmm5,%xmm1+	movdqu	160+16-96(%r8),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,160-96(%rcx)+	pand	%xmm4,%xmm2+	pand	%xmm5,%xmm3+	por	%xmm3,%xmm2+	movdqu	%xmm2,176-96(%rcx)+	.byte	0xf3,0xc3++.globl	vec_select_144++.def	vec_select_144;	.scl 2;	.type 32;	.endef+.p2align	5+vec_select_144:+	.byte	0xf3,0x0f,0x1e,0xfa++	movd	%r9d,%xmm5+	pxor	%xmm4,%xmm4+	pshufd	$0,%xmm5,%xmm5+	movdqu	(%rdx),%xmm0+	leaq	72(%rdx),%rdx+	pcmpeqd	%xmm4,%xmm5+	movdqu	(%r8),%xmm1+	leaq	72(%r8),%r8+	pcmpeqd	%xmm5,%xmm4+	leaq	72(%rcx),%rcx+	pand	%xmm4,%xmm0+	movdqu	0+16-72(%rdx),%xmm2+	pand	%xmm5,%xmm1+	movdqu	0+16-72(%r8),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,0-72(%rcx)+	pand	%xmm4,%xmm2+	movdqu	16+16-72(%rdx),%xmm0+	pand	%xmm5,%xmm3+	movdqu	16+16-72(%r8),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,16-72(%rcx)+	pand	%xmm4,%xmm0+	movdqu	32+16-72(%rdx),%xmm2+	pand	%xmm5,%xmm1+	movdqu	32+16-72(%r8),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,32-72(%rcx)+	pand	%xmm4,%xmm2+	movdqu	48+16-72(%rdx),%xmm0+	pand	%xmm5,%xmm3+	movdqu	48+16-72(%r8),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,48-72(%rcx)+	pand	%xmm4,%xmm0+	movdqu	64+16-72(%rdx),%xmm2+	pand	%xmm5,%xmm1+	movdqu	64+16-72(%r8),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,64-72(%rcx)+	pand	%xmm4,%xmm2+	movdqu	80+16-72(%rdx),%xmm0+	pand	%xmm5,%xmm3+	movdqu	80+16-72(%r8),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,80-72(%rcx)+	pand	%xmm4,%xmm0+	movdqu	96+16-72(%rdx),%xmm2+	pand	%xmm5,%xmm1+	movdqu	96+16-72(%r8),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,96-72(%rcx)+	pand	%xmm4,%xmm2+	movdqu	112+16-72(%rdx),%xmm0+	pand	%xmm5,%xmm3+	movdqu	112+16-72(%r8),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,112-72(%rcx)+	pand	%xmm4,%xmm0+	pand	%xmm5,%xmm1+	por	%xmm1,%xmm0+	movdqu	%xmm0,128-72(%rcx)+	.byte	0xf3,0xc3++.globl	vec_select_288++.def	vec_select_288;	.scl 2;	.type 32;	.endef+.p2align	5+vec_select_288:+	.byte	0xf3,0x0f,0x1e,0xfa++	movd	%r9d,%xmm5+	pxor	%xmm4,%xmm4+	pshufd	$0,%xmm5,%xmm5+	movdqu	(%rdx),%xmm0+	leaq	144(%rdx),%rdx+	pcmpeqd	%xmm4,%xmm5+	movdqu	(%r8),%xmm1+	leaq	144(%r8),%r8+	pcmpeqd	%xmm5,%xmm4+	leaq	144(%rcx),%rcx+	pand	%xmm4,%xmm0+	movdqu	0+16-144(%rdx),%xmm2+	pand	%xmm5,%xmm1+	movdqu	0+16-144(%r8),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,0-144(%rcx)+	pand	%xmm4,%xmm2+	movdqu	16+16-144(%rdx),%xmm0+	pand	%xmm5,%xmm3+	movdqu	16+16-144(%r8),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,16-144(%rcx)+	pand	%xmm4,%xmm0+	movdqu	32+16-144(%rdx),%xmm2+	pand	%xmm5,%xmm1+	movdqu	32+16-144(%r8),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,32-144(%rcx)+	pand	%xmm4,%xmm2+	movdqu	48+16-144(%rdx),%xmm0+	pand	%xmm5,%xmm3+	movdqu	48+16-144(%r8),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,48-144(%rcx)+	pand	%xmm4,%xmm0+	movdqu	64+16-144(%rdx),%xmm2+	pand	%xmm5,%xmm1+	movdqu	64+16-144(%r8),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,64-144(%rcx)+	pand	%xmm4,%xmm2+	movdqu	80+16-144(%rdx),%xmm0+	pand	%xmm5,%xmm3+	movdqu	80+16-144(%r8),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,80-144(%rcx)+	pand	%xmm4,%xmm0+	movdqu	96+16-144(%rdx),%xmm2+	pand	%xmm5,%xmm1+	movdqu	96+16-144(%r8),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,96-144(%rcx)+	pand	%xmm4,%xmm2+	movdqu	112+16-144(%rdx),%xmm0+	pand	%xmm5,%xmm3+	movdqu	112+16-144(%r8),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,112-144(%rcx)+	pand	%xmm4,%xmm0+	movdqu	128+16-144(%rdx),%xmm2+	pand	%xmm5,%xmm1+	movdqu	128+16-144(%r8),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,128-144(%rcx)+	pand	%xmm4,%xmm2+	movdqu	144+16-144(%rdx),%xmm0+	pand	%xmm5,%xmm3+	movdqu	144+16-144(%r8),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,144-144(%rcx)+	pand	%xmm4,%xmm0+	movdqu	160+16-144(%rdx),%xmm2+	pand	%xmm5,%xmm1+	movdqu	160+16-144(%r8),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,160-144(%rcx)+	pand	%xmm4,%xmm2+	movdqu	176+16-144(%rdx),%xmm0+	pand	%xmm5,%xmm3+	movdqu	176+16-144(%r8),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,176-144(%rcx)+	pand	%xmm4,%xmm0+	movdqu	192+16-144(%rdx),%xmm2+	pand	%xmm5,%xmm1+	movdqu	192+16-144(%r8),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,192-144(%rcx)+	pand	%xmm4,%xmm2+	movdqu	208+16-144(%rdx),%xmm0+	pand	%xmm5,%xmm3+	movdqu	208+16-144(%r8),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,208-144(%rcx)+	pand	%xmm4,%xmm0+	movdqu	224+16-144(%rdx),%xmm2+	pand	%xmm5,%xmm1+	movdqu	224+16-144(%r8),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,224-144(%rcx)+	pand	%xmm4,%xmm2+	movdqu	240+16-144(%rdx),%xmm0+	pand	%xmm5,%xmm3+	movdqu	240+16-144(%r8),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,240-144(%rcx)+	pand	%xmm4,%xmm0+	movdqu	256+16-144(%rdx),%xmm2+	pand	%xmm5,%xmm1+	movdqu	256+16-144(%r8),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,256-144(%rcx)+	pand	%xmm4,%xmm2+	pand	%xmm5,%xmm3+	por	%xmm3,%xmm2+	movdqu	%xmm2,272-144(%rcx)+	.byte	0xf3,0xc3++.globl	vec_prefetch++.def	vec_prefetch;	.scl 2;	.type 32;	.endef+.p2align	5+vec_prefetch:+	.byte	0xf3,0x0f,0x1e,0xfa++	leaq	-1(%rcx,%rdx,1),%rdx+	movq	$64,%rax+	xorq	%r8,%r8+	prefetchnta	(%rcx)+	leaq	(%rcx,%rax,1),%rcx+	cmpq	%rdx,%rcx+	cmovaq	%rdx,%rcx+	cmovaq	%r8,%rax+	prefetchnta	(%rcx)+	leaq	(%rcx,%rax,1),%rcx+	cmpq	%rdx,%rcx+	cmovaq	%rdx,%rcx+	cmovaq	%r8,%rax+	prefetchnta	(%rcx)+	leaq	(%rcx,%rax,1),%rcx+	cmpq	%rdx,%rcx+	cmovaq	%rdx,%rcx+	cmovaq	%r8,%rax+	prefetchnta	(%rcx)+	leaq	(%rcx,%rax,1),%rcx+	cmpq	%rdx,%rcx+	cmovaq	%rdx,%rcx+	cmovaq	%r8,%rax+	prefetchnta	(%rcx)+	leaq	(%rcx,%rax,1),%rcx+	cmpq	%rdx,%rcx+	cmovaq	%rdx,%rcx+	cmovaq	%r8,%rax+	prefetchnta	(%rcx)+	leaq	(%rcx,%rax,1),%rcx+	cmpq	%rdx,%rcx+	cmovaq	%rdx,%rcx+	prefetchnta	(%rcx)+	.byte	0xf3,0xc3++.section	.pdata+.p2align	2+.rva	.LSEH_begin_add_mod_384+.rva	.LSEH_body_add_mod_384+.rva	.LSEH_info_add_mod_384_prologue++.rva	.LSEH_body_add_mod_384+.rva	.LSEH_epilogue_add_mod_384+.rva	.LSEH_info_add_mod_384_body++.rva	.LSEH_epilogue_add_mod_384+.rva	.LSEH_end_add_mod_384+.rva	.LSEH_info_add_mod_384_epilogue++.rva	.LSEH_begin_add_mod_384x+.rva	.LSEH_body_add_mod_384x+.rva	.LSEH_info_add_mod_384x_prologue++.rva	.LSEH_body_add_mod_384x+.rva	.LSEH_epilogue_add_mod_384x+.rva	.LSEH_info_add_mod_384x_body++.rva	.LSEH_epilogue_add_mod_384x+.rva	.LSEH_end_add_mod_384x+.rva	.LSEH_info_add_mod_384x_epilogue++.rva	.LSEH_begin_rshift_mod_384+.rva	.LSEH_body_rshift_mod_384+.rva	.LSEH_info_rshift_mod_384_prologue++.rva	.LSEH_body_rshift_mod_384+.rva	.LSEH_epilogue_rshift_mod_384+.rva	.LSEH_info_rshift_mod_384_body++.rva	.LSEH_epilogue_rshift_mod_384+.rva	.LSEH_end_rshift_mod_384+.rva	.LSEH_info_rshift_mod_384_epilogue++.rva	.LSEH_begin_div_by_2_mod_384+.rva	.LSEH_body_div_by_2_mod_384+.rva	.LSEH_info_div_by_2_mod_384_prologue++.rva	.LSEH_body_div_by_2_mod_384+.rva	.LSEH_epilogue_div_by_2_mod_384+.rva	.LSEH_info_div_by_2_mod_384_body++.rva	.LSEH_epilogue_div_by_2_mod_384+.rva	.LSEH_end_div_by_2_mod_384+.rva	.LSEH_info_div_by_2_mod_384_epilogue++.rva	.LSEH_begin_lshift_mod_384+.rva	.LSEH_body_lshift_mod_384+.rva	.LSEH_info_lshift_mod_384_prologue++.rva	.LSEH_body_lshift_mod_384+.rva	.LSEH_epilogue_lshift_mod_384+.rva	.LSEH_info_lshift_mod_384_body++.rva	.LSEH_epilogue_lshift_mod_384+.rva	.LSEH_end_lshift_mod_384+.rva	.LSEH_info_lshift_mod_384_epilogue++.rva	.LSEH_begin_mul_by_3_mod_384+.rva	.LSEH_body_mul_by_3_mod_384+.rva	.LSEH_info_mul_by_3_mod_384_prologue++.rva	.LSEH_body_mul_by_3_mod_384+.rva	.LSEH_epilogue_mul_by_3_mod_384+.rva	.LSEH_info_mul_by_3_mod_384_body++.rva	.LSEH_epilogue_mul_by_3_mod_384+.rva	.LSEH_end_mul_by_3_mod_384+.rva	.LSEH_info_mul_by_3_mod_384_epilogue++.rva	.LSEH_begin_mul_by_8_mod_384+.rva	.LSEH_body_mul_by_8_mod_384+.rva	.LSEH_info_mul_by_8_mod_384_prologue++.rva	.LSEH_body_mul_by_8_mod_384+.rva	.LSEH_epilogue_mul_by_8_mod_384+.rva	.LSEH_info_mul_by_8_mod_384_body++.rva	.LSEH_epilogue_mul_by_8_mod_384+.rva	.LSEH_end_mul_by_8_mod_384+.rva	.LSEH_info_mul_by_8_mod_384_epilogue++.rva	.LSEH_begin_mul_by_3_mod_384x+.rva	.LSEH_body_mul_by_3_mod_384x+.rva	.LSEH_info_mul_by_3_mod_384x_prologue++.rva	.LSEH_body_mul_by_3_mod_384x+.rva	.LSEH_epilogue_mul_by_3_mod_384x+.rva	.LSEH_info_mul_by_3_mod_384x_body++.rva	.LSEH_epilogue_mul_by_3_mod_384x+.rva	.LSEH_end_mul_by_3_mod_384x+.rva	.LSEH_info_mul_by_3_mod_384x_epilogue++.rva	.LSEH_begin_mul_by_8_mod_384x+.rva	.LSEH_body_mul_by_8_mod_384x+.rva	.LSEH_info_mul_by_8_mod_384x_prologue++.rva	.LSEH_body_mul_by_8_mod_384x+.rva	.LSEH_epilogue_mul_by_8_mod_384x+.rva	.LSEH_info_mul_by_8_mod_384x_body++.rva	.LSEH_epilogue_mul_by_8_mod_384x+.rva	.LSEH_end_mul_by_8_mod_384x+.rva	.LSEH_info_mul_by_8_mod_384x_epilogue++.rva	.LSEH_begin_cneg_mod_384+.rva	.LSEH_body_cneg_mod_384+.rva	.LSEH_info_cneg_mod_384_prologue++.rva	.LSEH_body_cneg_mod_384+.rva	.LSEH_epilogue_cneg_mod_384+.rva	.LSEH_info_cneg_mod_384_body++.rva	.LSEH_epilogue_cneg_mod_384+.rva	.LSEH_end_cneg_mod_384+.rva	.LSEH_info_cneg_mod_384_epilogue++.rva	.LSEH_begin_sub_mod_384+.rva	.LSEH_body_sub_mod_384+.rva	.LSEH_info_sub_mod_384_prologue++.rva	.LSEH_body_sub_mod_384+.rva	.LSEH_epilogue_sub_mod_384+.rva	.LSEH_info_sub_mod_384_body++.rva	.LSEH_epilogue_sub_mod_384+.rva	.LSEH_end_sub_mod_384+.rva	.LSEH_info_sub_mod_384_epilogue++.rva	.LSEH_begin_sub_mod_384x+.rva	.LSEH_body_sub_mod_384x+.rva	.LSEH_info_sub_mod_384x_prologue++.rva	.LSEH_body_sub_mod_384x+.rva	.LSEH_epilogue_sub_mod_384x+.rva	.LSEH_info_sub_mod_384x_body++.rva	.LSEH_epilogue_sub_mod_384x+.rva	.LSEH_end_sub_mod_384x+.rva	.LSEH_info_sub_mod_384x_epilogue++.rva	.LSEH_begin_mul_by_1_plus_i_mod_384x+.rva	.LSEH_body_mul_by_1_plus_i_mod_384x+.rva	.LSEH_info_mul_by_1_plus_i_mod_384x_prologue++.rva	.LSEH_body_mul_by_1_plus_i_mod_384x+.rva	.LSEH_epilogue_mul_by_1_plus_i_mod_384x+.rva	.LSEH_info_mul_by_1_plus_i_mod_384x_body++.rva	.LSEH_epilogue_mul_by_1_plus_i_mod_384x+.rva	.LSEH_end_mul_by_1_plus_i_mod_384x+.rva	.LSEH_info_mul_by_1_plus_i_mod_384x_epilogue++.rva	.LSEH_begin_sgn0_pty_mod_384+.rva	.LSEH_body_sgn0_pty_mod_384+.rva	.LSEH_info_sgn0_pty_mod_384_prologue++.rva	.LSEH_body_sgn0_pty_mod_384+.rva	.LSEH_epilogue_sgn0_pty_mod_384+.rva	.LSEH_info_sgn0_pty_mod_384_body++.rva	.LSEH_epilogue_sgn0_pty_mod_384+.rva	.LSEH_end_sgn0_pty_mod_384+.rva	.LSEH_info_sgn0_pty_mod_384_epilogue++.rva	.LSEH_begin_sgn0_pty_mod_384x+.rva	.LSEH_body_sgn0_pty_mod_384x+.rva	.LSEH_info_sgn0_pty_mod_384x_prologue++.rva	.LSEH_body_sgn0_pty_mod_384x+.rva	.LSEH_epilogue_sgn0_pty_mod_384x+.rva	.LSEH_info_sgn0_pty_mod_384x_body++.rva	.LSEH_epilogue_sgn0_pty_mod_384x+.rva	.LSEH_end_sgn0_pty_mod_384x+.rva	.LSEH_info_sgn0_pty_mod_384x_epilogue++.section	.xdata+.p2align	3+.LSEH_info_add_mod_384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_add_mod_384_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_add_mod_384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_add_mod_384x_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_add_mod_384x_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x03,0x00+.byte	0x00,0xe4,0x04,0x00+.byte	0x00,0xd4,0x05,0x00+.byte	0x00,0xc4,0x06,0x00+.byte	0x00,0x34,0x07,0x00+.byte	0x00,0x54,0x08,0x00+.byte	0x00,0x74,0x0a,0x00+.byte	0x00,0x64,0x0b,0x00+.byte	0x00,0x82+.byte	0x00,0x00+.LSEH_info_add_mod_384x_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_rshift_mod_384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_rshift_mod_384_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_rshift_mod_384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_div_by_2_mod_384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_div_by_2_mod_384_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_div_by_2_mod_384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_lshift_mod_384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_lshift_mod_384_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_lshift_mod_384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_mul_by_3_mod_384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_mul_by_3_mod_384_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_mul_by_3_mod_384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_mul_by_8_mod_384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_mul_by_8_mod_384_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_mul_by_8_mod_384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_mul_by_3_mod_384x_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_mul_by_3_mod_384x_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_mul_by_3_mod_384x_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_mul_by_8_mod_384x_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_mul_by_8_mod_384x_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_mul_by_8_mod_384x_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_cneg_mod_384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_cneg_mod_384_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_cneg_mod_384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sub_mod_384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sub_mod_384_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_sub_mod_384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sub_mod_384x_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sub_mod_384x_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x03,0x00+.byte	0x00,0xe4,0x04,0x00+.byte	0x00,0xd4,0x05,0x00+.byte	0x00,0xc4,0x06,0x00+.byte	0x00,0x34,0x07,0x00+.byte	0x00,0x54,0x08,0x00+.byte	0x00,0x74,0x0a,0x00+.byte	0x00,0x64,0x0b,0x00+.byte	0x00,0x82+.byte	0x00,0x00+.LSEH_info_sub_mod_384x_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_mul_by_1_plus_i_mod_384x_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_mul_by_1_plus_i_mod_384x_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x07,0x00+.byte	0x00,0xe4,0x08,0x00+.byte	0x00,0xd4,0x09,0x00+.byte	0x00,0xc4,0x0a,0x00+.byte	0x00,0x34,0x0b,0x00+.byte	0x00,0x54,0x0c,0x00+.byte	0x00,0x74,0x0e,0x00+.byte	0x00,0x64,0x0f,0x00+.byte	0x00,0xc2+.byte	0x00,0x00+.LSEH_info_mul_by_1_plus_i_mod_384x_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sgn0_pty_mod_384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sgn0_pty_mod_384_body:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00+.LSEH_info_sgn0_pty_mod_384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sgn0_pty_mod_384x_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sgn0_pty_mod_384x_body:+.byte	1,0,9,0+.byte	0x00,0x34,0x01,0x00+.byte	0x00,0x54,0x02,0x00+.byte	0x00,0x74,0x04,0x00+.byte	0x00,0x64,0x05,0x00+.byte	0x00,0x22+.byte	0x00,0x00+.LSEH_info_sgn0_pty_mod_384x_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00+
+ c-source/build/coff/add_mod_384x384-x86_64.s view
@@ -0,0 +1,326 @@+.text	++.def	__add_mod_384x384;	.scl 3;	.type 32;	.endef+.p2align	5+__add_mod_384x384:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	48(%rsi),%r14++	addq	0(%rdx),%r8+	movq	56(%rsi),%r15+	adcq	8(%rdx),%r9+	movq	64(%rsi),%rax+	adcq	16(%rdx),%r10+	movq	72(%rsi),%rbx+	adcq	24(%rdx),%r11+	movq	80(%rsi),%rbp+	adcq	32(%rdx),%r12+	movq	88(%rsi),%rsi+	adcq	40(%rdx),%r13+	movq	%r8,0(%rdi)+	adcq	48(%rdx),%r14+	movq	%r9,8(%rdi)+	adcq	56(%rdx),%r15+	movq	%r10,16(%rdi)+	adcq	64(%rdx),%rax+	movq	%r12,32(%rdi)+	movq	%r14,%r8+	adcq	72(%rdx),%rbx+	movq	%r11,24(%rdi)+	movq	%r15,%r9+	adcq	80(%rdx),%rbp+	movq	%r13,40(%rdi)+	movq	%rax,%r10+	adcq	88(%rdx),%rsi+	movq	%rbx,%r11+	sbbq	%rdx,%rdx++	subq	0(%rcx),%r14+	sbbq	8(%rcx),%r15+	movq	%rbp,%r12+	sbbq	16(%rcx),%rax+	sbbq	24(%rcx),%rbx+	sbbq	32(%rcx),%rbp+	movq	%rsi,%r13+	sbbq	40(%rcx),%rsi+	sbbq	$0,%rdx++	cmovcq	%r8,%r14+	cmovcq	%r9,%r15+	cmovcq	%r10,%rax+	movq	%r14,48(%rdi)+	cmovcq	%r11,%rbx+	movq	%r15,56(%rdi)+	cmovcq	%r12,%rbp+	movq	%rax,64(%rdi)+	cmovcq	%r13,%rsi+	movq	%rbx,72(%rdi)+	movq	%rbp,80(%rdi)+	movq	%rsi,88(%rdi)++	.byte	0xf3,0xc3+++.def	__sub_mod_384x384;	.scl 3;	.type 32;	.endef+.p2align	5+__sub_mod_384x384:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	48(%rsi),%r14++	subq	0(%rdx),%r8+	movq	56(%rsi),%r15+	sbbq	8(%rdx),%r9+	movq	64(%rsi),%rax+	sbbq	16(%rdx),%r10+	movq	72(%rsi),%rbx+	sbbq	24(%rdx),%r11+	movq	80(%rsi),%rbp+	sbbq	32(%rdx),%r12+	movq	88(%rsi),%rsi+	sbbq	40(%rdx),%r13+	movq	%r8,0(%rdi)+	sbbq	48(%rdx),%r14+	movq	0(%rcx),%r8+	movq	%r9,8(%rdi)+	sbbq	56(%rdx),%r15+	movq	8(%rcx),%r9+	movq	%r10,16(%rdi)+	sbbq	64(%rdx),%rax+	movq	16(%rcx),%r10+	movq	%r11,24(%rdi)+	sbbq	72(%rdx),%rbx+	movq	24(%rcx),%r11+	movq	%r12,32(%rdi)+	sbbq	80(%rdx),%rbp+	movq	32(%rcx),%r12+	movq	%r13,40(%rdi)+	sbbq	88(%rdx),%rsi+	movq	40(%rcx),%r13+	sbbq	%rdx,%rdx++	andq	%rdx,%r8+	andq	%rdx,%r9+	andq	%rdx,%r10+	andq	%rdx,%r11+	andq	%rdx,%r12+	andq	%rdx,%r13++	addq	%r8,%r14+	adcq	%r9,%r15+	movq	%r14,48(%rdi)+	adcq	%r10,%rax+	movq	%r15,56(%rdi)+	adcq	%r11,%rbx+	movq	%rax,64(%rdi)+	adcq	%r12,%rbp+	movq	%rbx,72(%rdi)+	adcq	%r13,%rsi+	movq	%rbp,80(%rdi)+	movq	%rsi,88(%rdi)++	.byte	0xf3,0xc3+++.globl	add_mod_384x384++.def	add_mod_384x384;	.scl 2;	.type 32;	.endef+.p2align	5+add_mod_384x384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_add_mod_384x384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$8,%rsp++.LSEH_body_add_mod_384x384:+++	call	__add_mod_384x384++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_add_mod_384x384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_add_mod_384x384:++.globl	sub_mod_384x384++.def	sub_mod_384x384;	.scl 2;	.type 32;	.endef+.p2align	5+sub_mod_384x384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sub_mod_384x384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$8,%rsp++.LSEH_body_sub_mod_384x384:+++	call	__sub_mod_384x384++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_sub_mod_384x384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sub_mod_384x384:+.section	.pdata+.p2align	2+.rva	.LSEH_begin_add_mod_384x384+.rva	.LSEH_body_add_mod_384x384+.rva	.LSEH_info_add_mod_384x384_prologue++.rva	.LSEH_body_add_mod_384x384+.rva	.LSEH_epilogue_add_mod_384x384+.rva	.LSEH_info_add_mod_384x384_body++.rva	.LSEH_epilogue_add_mod_384x384+.rva	.LSEH_end_add_mod_384x384+.rva	.LSEH_info_add_mod_384x384_epilogue++.rva	.LSEH_begin_sub_mod_384x384+.rva	.LSEH_body_sub_mod_384x384+.rva	.LSEH_info_sub_mod_384x384_prologue++.rva	.LSEH_body_sub_mod_384x384+.rva	.LSEH_epilogue_sub_mod_384x384+.rva	.LSEH_info_sub_mod_384x384_body++.rva	.LSEH_epilogue_sub_mod_384x384+.rva	.LSEH_end_sub_mod_384x384+.rva	.LSEH_info_sub_mod_384x384_epilogue++.section	.xdata+.p2align	3+.LSEH_info_add_mod_384x384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_add_mod_384x384_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_add_mod_384x384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sub_mod_384x384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sub_mod_384x384_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_sub_mod_384x384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00+
+ c-source/build/coff/ct_inverse_mod_256-armv8.S view
@@ -0,0 +1,798 @@+.text++.globl	ct_inverse_mod_256+.def	ct_inverse_mod_256;+.type	32;+.endef+.p2align	5+ct_inverse_mod_256:+.long	3573752639+	stp	x29, x30, [sp,#-80]!+	add	x29, sp, #0+	stp	x19, x20, [sp,#16]+	stp	x21, x22, [sp,#32]+	stp	x23, x24, [sp,#48]+	stp	x25, x26, [sp,#64]+	sub	sp, sp, #1040++	ldp	x4, x5, [x1,#8*0]+	ldp	x6, x7, [x1,#8*2]++	add	x1, sp, #16+511	// find closest 512-byte-aligned spot+	and	x1, x1, #-512	// in the frame...+	str	x0, [sp]++	ldp	x8, x9, [x2,#8*0]+	ldp	x10, x11, [x2,#8*2]++	stp	x4, x5, [x1,#8*0]	// copy input to |a|+	stp	x6, x7, [x1,#8*2]+	stp	x8, x9, [x1,#8*4]	// copy modulus to |b|+	stp	x10, x11, [x1,#8*6]++	////////////////////////////////////////// first iteration+	bl	.Lab_approximation_31_256_loaded++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	str	x12,[x0,#8*8]		// initialize |u| with |f0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to dst |b|+	bl	__smul_256_n_shift_by_31+	str	x12, [x0,#8*9]		// initialize |v| with |f1|++	////////////////////////////////////////// second iteration+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	ldr	x8, [x1,#8*8]		// |u|+	ldr	x9, [x1,#8*13]	// |v|+	madd	x4, x16, x8, xzr	// |u|*|f0|+	madd	x4, x17, x9, x4	// |v|*|g0|+	str	x4, [x0,#8*4]+	asr	x5, x4, #63		// sign extenstion+	stp	x5, x5, [x0,#8*5]+	stp	x5, x5, [x0,#8*7]++	madd	x4, x12, x8, xzr	// |u|*|f1|+	madd	x4, x13, x9, x4	// |v|*|g1|+	str	x4, [x0,#8*9]+	asr	x5, x4, #63		// sign extenstion+	stp	x5, x5, [x0,#8*10]+	stp	x5, x5, [x0,#8*12]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	adc	x22, x22, x23+	stp	x22, x22, [x0,#8*4]+	stp	x22, x22, [x0,#8*6]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	adc	x22, x22, x23+	stp	x22, x22, [x0,#8*4]+	stp	x22, x22, [x0,#8*6]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	adc	x22, x22, x23+	stp	x22, x22, [x0,#8*4]+	stp	x22, x22, [x0,#8*6]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	adc	x22, x22, x23+	stp	x22, x22, [x0,#8*4]+	stp	x22, x22, [x0,#8*6]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	adc	x22, x22, x23+	stp	x22, x22, [x0,#8*4]+	stp	x22, x22, [x0,#8*6]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	adc	x22, x22, x23+	stp	x22, x22, [x0,#8*4]+	stp	x22, x22, [x0,#8*6]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	bl	__smul_512x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	bl	__smul_512x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	bl	__smul_512x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	bl	__smul_512x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	bl	__smul_512x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	bl	__smul_512x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	bl	__smul_512x63_tail+	////////////////////////////////////////// two[!] last iterations+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #47			// 31 + 512 % 31+	//bl	__ab_approximation_62_256	// |a| and |b| are exact,+	ldr	x7, [x1,#8*0]		// just load+	ldr	x11, [x1,#8*4]+	bl	__inner_loop_62_256++	mov	x16, x14+	mov	x17, x15+	ldr	x0, [sp]			// original out_ptr+	bl	__smul_256x63+	bl	__smul_512x63_tail+	ldr	x30, [x29,#8]++	smulh	x20, x7, x17		// figure out top-most limb+	ldp	x8, x9, [x3,#8*0]+	adc	x23, x23, x25+	ldp	x10, x11, [x3,#8*2]++	add	x20, x20, x23		// x20 is 1, 0 or -1+	asr	x19, x20, #63		// sign as mask++	and	x23,   x8, x19		// add mod<<256 conditionally+	and	x24,   x9, x19+	adds	x4, x4, x23+	and	x25,   x10, x19+	adcs	x5, x5, x24+	and	x26,   x11, x19+	adcs	x6, x6, x25+	adcs	x7, x22,   x26+	adc	x20, x20, xzr		// x20 is 1, 0 or -1++	neg	x19, x20+	orr	x20, x20, x19		// excess bit or sign as mask+	asr	x19, x19, #63		// excess bit as mask++	and	x8, x8, x20		// mask |mod|+	and	x9, x9, x20+	and	x10, x10, x20+	and	x11, x11, x20++	eor	x8, x8, x19		// conditionally negate |mod|+	eor	x9, x9, x19+	adds	x8, x8, x19, lsr#63+	eor	x10, x10, x19+	adcs	x9, x9, xzr+	eor	x11, x11, x19+	adcs	x10, x10, xzr+	adc	x11, x11, xzr++	adds	x4, x4, x8	// final adjustment for |mod|<<256+	adcs	x5, x5, x9+	adcs	x6, x6, x10+	stp	x4, x5, [x0,#8*4]+	adc	x7, x7, x11+	stp	x6, x7, [x0,#8*6]++	add	sp, sp, #1040+	ldp	x19, x20, [x29,#16]+	ldp	x21, x22, [x29,#32]+	ldp	x23, x24, [x29,#48]+	ldp	x25, x26, [x29,#64]+	ldr	x29, [sp],#80+.long	3573752767+	ret+++////////////////////////////////////////////////////////////////////////+.def	__smul_256x63;+.type	32;+.endef+.p2align	5+__smul_256x63:+	ldp	x4, x5, [x1,#8*0+64]	// load |u| (or |v|)+	asr	x14, x16, #63		// |f_|'s sign as mask (or |g_|'s)+	ldp	x6, x7, [x1,#8*2+64]+	eor	x16, x16, x14		// conditionally negate |f_| (or |g_|)+	ldr	x22, [x1,#8*4+64]++	eor	x4, x4, x14	// conditionally negate |u| (or |v|)+	sub	x16, x16, x14+	eor	x5, x5, x14+	adds	x4, x4, x14, lsr#63+	eor	x6, x6, x14+	adcs	x5, x5, xzr+	eor	x7, x7, x14+	adcs	x6, x6, xzr+	eor	x22, x22, x14+	umulh	x19, x4, x16+	adcs	x7, x7, xzr+	umulh	x20, x5, x16+	adcs	x22, x22, xzr+	umulh	x21, x6, x16+	mul	x4, x4, x16+	cmp	x16, #0+	mul	x5, x5, x16+	csel	x22, x22, xzr, ne+	mul	x6, x6, x16+	adds	x5, x5, x19+	mul	x24, x7, x16+	adcs	x6, x6, x20+	adcs	x24, x24, x21+	adc	x26, xzr, xzr+	ldp	x8, x9, [x1,#8*0+104]	// load |u| (or |v|)+	asr	x14, x17, #63		// |f_|'s sign as mask (or |g_|'s)+	ldp	x10, x11, [x1,#8*2+104]+	eor	x17, x17, x14		// conditionally negate |f_| (or |g_|)+	ldr	x23, [x1,#8*4+104]++	eor	x8, x8, x14	// conditionally negate |u| (or |v|)+	sub	x17, x17, x14+	eor	x9, x9, x14+	adds	x8, x8, x14, lsr#63+	eor	x10, x10, x14+	adcs	x9, x9, xzr+	eor	x11, x11, x14+	adcs	x10, x10, xzr+	eor	x23, x23, x14+	umulh	x19, x8, x17+	adcs	x11, x11, xzr+	umulh	x20, x9, x17+	adcs	x23, x23, xzr+	umulh	x21, x10, x17+	adc	x15, xzr, xzr		// used in __smul_512x63_tail+	mul	x8, x8, x17+	cmp	x17, #0+	mul	x9, x9, x17+	csel	x23, x23, xzr, ne+	mul	x10, x10, x17+	adds	x9, x9, x19+	mul	x25, x11, x17+	adcs	x10, x10, x20+	adcs	x25, x25, x21+	adc	x26, x26, xzr++	adds	x4, x4, x8+	adcs	x5, x5, x9+	adcs	x6, x6, x10+	stp	x4, x5, [x0,#8*0]+	adcs	x24,   x24,   x25+	stp	x6, x24, [x0,#8*2]++	ret+++.def	__smul_512x63_tail;+.type	32;+.endef+.p2align	5+__smul_512x63_tail:+	umulh	x24, x7, x16+	ldp	x5, x6, [x1,#8*18]	// load rest of |v|+	adc	x26, x26, xzr+	ldr	x7, [x1,#8*20]+	and	x22, x22, x16++	umulh	x11, x11, x17	// resume |v|*|g1| chain++	sub	x24, x24, x22	// tie up |u|*|f1| chain+	asr	x25, x24, #63++	eor	x5, x5, x14	// conditionally negate rest of |v|+	eor	x6, x6, x14+	adds	x5, x5, x15+	eor	x7, x7, x14+	adcs	x6, x6, xzr+	umulh	x19, x23,   x17+	adc	x7, x7, xzr+	umulh	x20, x5, x17+	add	x11, x11, x26+	umulh	x21, x6, x17++	mul	x4, x23,   x17+	mul	x5, x5, x17+	adds	x4, x4, x11+	mul	x6, x6, x17+	adcs	x5, x5, x19+	mul	x22,   x7, x17+	adcs	x6, x6, x20+	adcs	x22,   x22,   x21+	adc	x23, xzr, xzr		// used in the final step++	adds	x4, x4, x24+	adcs	x5, x5, x25+	adcs	x6, x6, x25+	stp	x4, x5, [x0,#8*4]+	adcs	x22,   x22,   x25	// carry is used in the final step+	stp	x6, x22,   [x0,#8*6]++	ret+++.def	__smul_256_n_shift_by_31;+.type	32;+.endef+.p2align	5+__smul_256_n_shift_by_31:+	ldp	x4, x5, [x1,#8*0+0]	// load |a| (or |b|)+	asr	x24, x12, #63		// |f0|'s sign as mask (or |g0|'s)+	ldp	x6, x7, [x1,#8*2+0]+	eor	x25, x12, x24	// conditionally negate |f0| (or |g0|)++	eor	x4, x4, x24	// conditionally negate |a| (or |b|)+	sub	x25, x25, x24+	eor	x5, x5, x24+	adds	x4, x4, x24, lsr#63+	eor	x6, x6, x24+	adcs	x5, x5, xzr+	eor	x7, x7, x24+	umulh	x19, x4, x25+	adcs	x6, x6, xzr+	umulh	x20, x5, x25+	adc	x7, x7, xzr+	umulh	x21, x6, x25+	and	x24, x24, x25+	umulh	x22, x7, x25+	neg	x24, x24++	mul	x4, x4, x25+	mul	x5, x5, x25+	mul	x6, x6, x25+	adds	x5, x5, x19+	mul	x7, x7, x25+	adcs	x6, x6, x20+	adcs	x7, x7, x21+	adc	x22, x22, x24+	ldp	x8, x9, [x1,#8*0+32]	// load |a| (or |b|)+	asr	x24, x13, #63		// |f0|'s sign as mask (or |g0|'s)+	ldp	x10, x11, [x1,#8*2+32]+	eor	x25, x13, x24	// conditionally negate |f0| (or |g0|)++	eor	x8, x8, x24	// conditionally negate |a| (or |b|)+	sub	x25, x25, x24+	eor	x9, x9, x24+	adds	x8, x8, x24, lsr#63+	eor	x10, x10, x24+	adcs	x9, x9, xzr+	eor	x11, x11, x24+	umulh	x19, x8, x25+	adcs	x10, x10, xzr+	umulh	x20, x9, x25+	adc	x11, x11, xzr+	umulh	x21, x10, x25+	and	x24, x24, x25+	umulh	x23, x11, x25+	neg	x24, x24++	mul	x8, x8, x25+	mul	x9, x9, x25+	mul	x10, x10, x25+	adds	x9, x9, x19+	mul	x11, x11, x25+	adcs	x10, x10, x20+	adcs	x11, x11, x21+	adc	x23, x23, x24+	adds	x4, x4, x8+	adcs	x5, x5, x9+	adcs	x6, x6, x10+	adcs	x7, x7, x11+	adc	x8, x22,   x23++	extr	x4, x5, x4, #31+	extr	x5, x6, x5, #31+	extr	x6, x7, x6, #31+	asr	x23, x8, #63	// result's sign as mask+	extr	x7, x8, x7, #31++	eor	x4, x4, x23	// ensure the result is positive+	eor	x5, x5, x23+	adds	x4, x4, x23, lsr#63+	eor	x6, x6, x23+	adcs	x5, x5, xzr+	eor	x7, x7, x23+	adcs	x6, x6, xzr+	stp	x4, x5, [x0,#8*0]+	adc	x7, x7, xzr+	stp	x6, x7, [x0,#8*2]++	eor	x12, x12, x23		// adjust |f/g| accordingly+	eor	x13, x13, x23+	sub	x12, x12, x23+	sub	x13, x13, x23++	ret++.def	__ab_approximation_31_256;+.type	32;+.endef+.p2align	4+__ab_approximation_31_256:+	ldp	x6, x7, [x1,#8*2]+	ldp	x10, x11, [x1,#8*6]+	ldp	x4, x5, [x1,#8*0]+	ldp	x8, x9, [x1,#8*4]++.Lab_approximation_31_256_loaded:+	orr	x19, x7, x11	// check top-most limbs, ...+	cmp	x19, #0+	csel	x7, x7, x6, ne+	csel	x11, x11, x10, ne+	csel	x6, x6, x5, ne+	orr	x19, x7, x11	// and ones before top-most, ...+	csel	x10, x10, x9, ne++	cmp	x19, #0+	csel	x7, x7, x6, ne+	csel	x11, x11, x10, ne+	csel	x6, x6, x4, ne+	orr	x19, x7, x11	// and one more, ...+	csel	x10, x10, x8, ne++	clz	x19, x19+	cmp	x19, #64+	csel	x19, x19, xzr, ne+	csel	x7, x7, x6, ne+	csel	x11, x11, x10, ne+	neg	x20, x19++	lslv	x7, x7, x19	// align high limbs to the left+	lslv	x11, x11, x19+	lsrv	x6, x6, x20+	lsrv	x10, x10, x20+	and	x6, x6, x20, asr#6+	and	x10, x10, x20, asr#6+	orr	x7, x7, x6+	orr	x11, x11, x10++	bfxil	x7, x4, #0, #31+	bfxil	x11, x8, #0, #31++	b	__inner_loop_31_256+	ret+++.def	__inner_loop_31_256;+.type	32;+.endef+.p2align	4+__inner_loop_31_256:+	mov	x2, #31+	mov	x13, #0x7FFFFFFF80000000	// |f0|=1, |g0|=0+	mov	x15, #0x800000007FFFFFFF	// |f1|=0, |g1|=1+	mov	x23,#0x7FFFFFFF7FFFFFFF++.Loop_31_256:+	sbfx	x22, x7, #0, #1	// if |a_| is odd, then we'll be subtracting+	sub	x2, x2, #1+	and	x19, x11, x22+	sub	x20, x11, x7	// |b_|-|a_|+	subs	x21, x7, x19	// |a_|-|b_| (or |a_|-0 if |a_| was even)+	mov	x19, x15+	csel	x11, x11, x7, hs	// |b_| = |a_|+	csel	x7, x21, x20, hs	// borrow means |a_|<|b_|, replace with |b_|-|a_|+	csel	x15, x15, x13,    hs	// exchange |fg0| and |fg1|+	csel	x13, x13, x19,   hs+	lsr	x7, x7, #1+	and	x19, x15, x22+	and	x20, x23, x22+	sub	x13, x13, x19	// |f0|-=|f1| (or |f0-=0| if |a_| was even)+	add	x15, x15, x15	// |f1|<<=1+	add	x13, x13, x20+	sub	x15, x15, x23+	cbnz	x2, .Loop_31_256++	mov	x23, #0x7FFFFFFF+	ubfx	x12, x13, #0, #32+	ubfx	x13, x13, #32, #32+	ubfx	x14, x15, #0, #32+	ubfx	x15, x15, #32, #32+	sub	x12, x12, x23		// remove bias+	sub	x13, x13, x23+	sub	x14, x14, x23+	sub	x15, x15, x23++	ret+++.def	__inner_loop_62_256;+.type	32;+.endef+.p2align	4+__inner_loop_62_256:+	mov	x12, #1		// |f0|=1+	mov	x13, #0		// |g0|=0+	mov	x14, #0		// |f1|=0+	mov	x15, #1		// |g1|=1++.Loop_62_256:+	sbfx	x22, x7, #0, #1	// if |a_| is odd, then we'll be subtracting+	sub	x2, x2, #1+	and	x19, x11, x22+	sub	x20, x11, x7	// |b_|-|a_|+	subs	x21, x7, x19	// |a_|-|b_| (or |a_|-0 if |a_| was even)+	mov	x19, x12+	csel	x11, x11, x7, hs	// |b_| = |a_|+	csel	x7, x21, x20, hs	// borrow means |a_|<|b_|, replace with |b_|-|a_|+	mov	x20, x13+	csel	x12, x12, x14,       hs	// exchange |f0| and |f1|+	csel	x14, x14, x19,     hs+	csel	x13, x13, x15,       hs	// exchange |g0| and |g1|+	csel	x15, x15, x20,     hs+	lsr	x7, x7, #1+	and	x19, x14, x22+	and	x20, x15, x22+	add	x14, x14, x14		// |f1|<<=1+	add	x15, x15, x15		// |g1|<<=1+	sub	x12, x12, x19		// |f0|-=|f1| (or |f0-=0| if |a_| was even)+	sub	x13, x13, x20		// |g0|-=|g1| (or |g0-=0| ...)+	cbnz	x2, .Loop_62_256++	ret+
+ c-source/build/coff/ct_inverse_mod_256-x86_64.s view
@@ -0,0 +1,1209 @@+.text	++.globl	ct_inverse_mod_256+.def	ct_inverse_mod_256;	.scl 2;	.type 32;	.endef+.p2align	5+ct_inverse_mod_256:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_ct_inverse_mod_256:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$1072,%rsp++.LSEH_body_ct_inverse_mod_256:+++	leaq	48+511(%rsp),%rax+	andq	$-512,%rax+	movq	%rdi,32(%rsp)+	movq	%rcx,40(%rsp)++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11++	movq	0(%rdx),%r12+	movq	8(%rdx),%r13+	movq	16(%rdx),%r14+	movq	24(%rdx),%r15++	movq	%r8,0(%rax)+	movq	%r9,8(%rax)+	movq	%r10,16(%rax)+	movq	%r11,24(%rax)++	movq	%r12,32(%rax)+	movq	%r13,40(%rax)+	movq	%r14,48(%rax)+	movq	%r15,56(%rax)+	movq	%rax,%rsi+++	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+++	movq	%rdx,64(%rdi)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+++	movq	%rdx,72(%rdi)+++	xorq	$256,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31++++	movq	64(%rsi),%r8+	movq	104(%rsi),%r12+	movq	%r8,%r9+	imulq	0(%rsp),%r8+	movq	%r12,%r13+	imulq	8(%rsp),%r12+	addq	%r12,%r8+	movq	%r8,32(%rdi)+	sarq	$63,%r8+	movq	%r8,40(%rdi)+	movq	%r8,48(%rdi)+	movq	%r8,56(%rdi)+	movq	%r8,64(%rdi)+	leaq	64(%rsi),%rsi++	imulq	%rdx,%r9+	imulq	%rcx,%r13+	addq	%r13,%r9+	movq	%r9,72(%rdi)+	sarq	$63,%r9+	movq	%r9,80(%rdi)+	movq	%r9,88(%rdi)+	movq	%r9,96(%rdi)+	movq	%r9,104(%rdi)+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_256x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_256x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_256x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_256x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_256x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_256x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_256x63+	sarq	$63,%rbp+	movq	%rbp,40(%rdi)+	movq	%rbp,48(%rdi)+	movq	%rbp,56(%rdi)+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_512x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_512x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_512x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_512x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_512x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_512x63++	xorq	$256+64,%rsi+	movl	$47,%edx++	movq	0(%rsi),%r8++	movq	32(%rsi),%r10++	call	__inner_loop_62_256++++++++	leaq	64(%rsi),%rsi++++++	movq	%r12,%rdx+	movq	%r13,%rcx+	movq	32(%rsp),%rdi+	call	__smulq_512x63+	adcq	%rbp,%rdx++	movq	40(%rsp),%rsi+	movq	%rdx,%rax+	sarq	$63,%rdx++	movq	%rdx,%r8+	movq	%rdx,%r9+	andq	0(%rsi),%r8+	movq	%rdx,%r10+	andq	8(%rsi),%r9+	andq	16(%rsi),%r10+	andq	24(%rsi),%rdx++	addq	%r8,%r12+	adcq	%r9,%r13+	adcq	%r10,%r14+	adcq	%rdx,%r15+	adcq	$0,%rax++	movq	%rax,%rdx+	negq	%rax+	orq	%rax,%rdx+	sarq	$63,%rax++	movq	%rdx,%r8+	movq	%rdx,%r9+	andq	0(%rsi),%r8+	movq	%rdx,%r10+	andq	8(%rsi),%r9+	andq	16(%rsi),%r10+	andq	24(%rsi),%rdx++	xorq	%rax,%r8+	xorq	%rcx,%rcx+	xorq	%rax,%r9+	subq	%rax,%rcx+	xorq	%rax,%r10+	xorq	%rax,%rdx+	addq	%rcx,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%rdx++	addq	%r8,%r12+	adcq	%r9,%r13+	adcq	%r10,%r14+	adcq	%rdx,%r15++	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)+	movq	%r14,48(%rdi)+	movq	%r15,56(%rdi)++	leaq	1072(%rsp),%r8+	movq	0(%r8),%r15++	movq	8(%r8),%r14++	movq	16(%r8),%r13++	movq	24(%r8),%r12++	movq	32(%r8),%rbx++	movq	40(%r8),%rbp++	leaq	48(%r8),%rsp++.LSEH_epilogue_ct_inverse_mod_256:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_ct_inverse_mod_256:+.def	__smulq_512x63;	.scl 3;	.type 32;	.endef+.p2align	5+__smulq_512x63:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%rbp++	movq	%rdx,%rbx+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbx+	addq	%rax,%rbx++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%rbp+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%rbp++	mulq	%rbx+	movq	%rax,0(%rdi)+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbx+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%r9,8(%rdi)+	movq	%rdx,%r10+	mulq	%rbx+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%r10,16(%rdi)+	movq	%rdx,%r11+	andq	%rbx,%rbp+	negq	%rbp+	mulq	%rbx+	addq	%rax,%r11+	adcq	%rdx,%rbp+	movq	%r11,24(%rdi)++	movq	40(%rsi),%r8+	movq	48(%rsi),%r9+	movq	56(%rsi),%r10+	movq	64(%rsi),%r11+	movq	72(%rsi),%r12+	movq	80(%rsi),%r13+	movq	88(%rsi),%r14+	movq	96(%rsi),%r15++	movq	%rcx,%rdx+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rcx+	addq	%rax,%rcx++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	xorq	%rdx,%r14+	xorq	%rdx,%r15+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13+	adcq	$0,%r14+	adcq	$0,%r15++	mulq	%rcx+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rcx+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rcx+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rcx+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	mulq	%rcx+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	mulq	%rcx+	addq	%rax,%r13+	movq	%r14,%rax+	adcq	$0,%rdx+	movq	%rdx,%r14+	mulq	%rcx+	addq	%rax,%r14+	movq	%r15,%rax+	adcq	$0,%rdx+	movq	%rdx,%r15+	imulq	%rcx+	addq	%rax,%r15+	adcq	$0,%rdx++	movq	%rbp,%rbx+	sarq	$63,%rbp++	addq	0(%rdi),%r8+	adcq	8(%rdi),%r9+	adcq	16(%rdi),%r10+	adcq	24(%rdi),%r11+	adcq	%rbx,%r12+	adcq	%rbp,%r13+	adcq	%rbp,%r14+	adcq	%rbp,%r15++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)+	movq	%r14,48(%rdi)+	movq	%r15,56(%rdi)++	.byte	0xf3,0xc3+++.def	__smulq_256x63;	.scl 3;	.type 32;	.endef+.p2align	5+__smulq_256x63:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0+0(%rsi),%r8+	movq	0+8(%rsi),%r9+	movq	0+16(%rsi),%r10+	movq	0+24(%rsi),%r11+	movq	0+32(%rsi),%rbp++	movq	%rdx,%rbx+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbx+	addq	%rax,%rbx++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%rbp+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%rbp++	mulq	%rbx+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbx+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rbx+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	andq	%rbx,%rbp+	negq	%rbp+	mulq	%rbx+	addq	%rax,%r11+	adcq	%rdx,%rbp+	movq	%rcx,%rdx+	movq	40+0(%rsi),%r12+	movq	40+8(%rsi),%r13+	movq	40+16(%rsi),%r14+	movq	40+24(%rsi),%r15+	movq	40+32(%rsi),%rcx++	movq	%rdx,%rbx+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbx+	addq	%rax,%rbx++	xorq	%rdx,%r12+	xorq	%rdx,%r13+	xorq	%rdx,%r14+	xorq	%rdx,%r15+	xorq	%rdx,%rcx+	addq	%r12,%rax+	adcq	$0,%r13+	adcq	$0,%r14+	adcq	$0,%r15+	adcq	$0,%rcx++	mulq	%rbx+	movq	%rax,%r12+	movq	%r13,%rax+	movq	%rdx,%r13+	mulq	%rbx+	addq	%rax,%r13+	movq	%r14,%rax+	adcq	$0,%rdx+	movq	%rdx,%r14+	mulq	%rbx+	addq	%rax,%r14+	movq	%r15,%rax+	adcq	$0,%rdx+	movq	%rdx,%r15+	andq	%rbx,%rcx+	negq	%rcx+	mulq	%rbx+	addq	%rax,%r15+	adcq	%rdx,%rcx+	addq	%r12,%r8+	adcq	%r13,%r9+	adcq	%r14,%r10+	adcq	%r15,%r11+	adcq	%rcx,%rbp++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%rbp,32(%rdi)++	.byte	0xf3,0xc3++.def	__smulq_256_n_shift_by_31;	.scl 3;	.type 32;	.endef+.p2align	5+__smulq_256_n_shift_by_31:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	%rdx,0(%rdi)+	movq	%rcx,8(%rdi)+	movq	%rdx,%rbp+	movq	0+0(%rsi),%r8+	movq	0+8(%rsi),%r9+	movq	0+16(%rsi),%r10+	movq	0+24(%rsi),%r11++	movq	%rbp,%rbx+	sarq	$63,%rbp+	xorq	%rax,%rax+	subq	%rbp,%rax++	xorq	%rbp,%rbx+	addq	%rax,%rbx++	xorq	%rbp,%r8+	xorq	%rbp,%r9+	xorq	%rbp,%r10+	xorq	%rbp,%r11+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11++	mulq	%rbx+	movq	%rax,%r8+	movq	%r9,%rax+	andq	%rbx,%rbp+	negq	%rbp+	movq	%rdx,%r9+	mulq	%rbx+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rbx+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rbx+	addq	%rax,%r11+	adcq	%rdx,%rbp+	movq	32+0(%rsi),%r12+	movq	32+8(%rsi),%r13+	movq	32+16(%rsi),%r14+	movq	32+24(%rsi),%r15++	movq	%rcx,%rbx+	sarq	$63,%rcx+	xorq	%rax,%rax+	subq	%rcx,%rax++	xorq	%rcx,%rbx+	addq	%rax,%rbx++	xorq	%rcx,%r12+	xorq	%rcx,%r13+	xorq	%rcx,%r14+	xorq	%rcx,%r15+	addq	%r12,%rax+	adcq	$0,%r13+	adcq	$0,%r14+	adcq	$0,%r15++	mulq	%rbx+	movq	%rax,%r12+	movq	%r13,%rax+	andq	%rbx,%rcx+	negq	%rcx+	movq	%rdx,%r13+	mulq	%rbx+	addq	%rax,%r13+	movq	%r14,%rax+	adcq	$0,%rdx+	movq	%rdx,%r14+	mulq	%rbx+	addq	%rax,%r14+	movq	%r15,%rax+	adcq	$0,%rdx+	movq	%rdx,%r15+	mulq	%rbx+	addq	%rax,%r15+	adcq	%rdx,%rcx+	addq	%r12,%r8+	adcq	%r13,%r9+	adcq	%r14,%r10+	adcq	%r15,%r11+	adcq	%rcx,%rbp++	movq	0(%rdi),%rdx+	movq	8(%rdi),%rcx++	shrdq	$31,%r9,%r8+	shrdq	$31,%r10,%r9+	shrdq	$31,%r11,%r10+	shrdq	$31,%rbp,%r11++	sarq	$63,%rbp+	xorq	%rax,%rax+	subq	%rbp,%rax++	xorq	%rbp,%r8+	xorq	%rbp,%r9+	xorq	%rbp,%r10+	xorq	%rbp,%r11+	addq	%rax,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)++	xorq	%rbp,%rdx+	xorq	%rbp,%rcx+	addq	%rax,%rdx+	addq	%rax,%rcx++	.byte	0xf3,0xc3++.def	__ab_approximation_31_256;	.scl 3;	.type 32;	.endef+.p2align	5+__ab_approximation_31_256:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	24(%rsi),%r9+	movq	56(%rsi),%r11+	movq	16(%rsi),%rbx+	movq	48(%rsi),%rbp+	movq	8(%rsi),%r8+	movq	40(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	movq	0(%rsi),%r8+	cmovzq	%r10,%rbp+	movq	32(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	cmovzq	%r10,%rbp++	movq	%r9,%rax+	orq	%r11,%rax+	bsrq	%rax,%rcx+	leaq	1(%rcx),%rcx+	cmovzq	%r8,%r9+	cmovzq	%r10,%r11+	cmovzq	%rax,%rcx+	negq	%rcx+++	shldq	%cl,%rbx,%r9+	shldq	%cl,%rbp,%r11++	movl	$0x7FFFFFFF,%eax+	andq	%rax,%r8+	andq	%rax,%r10+	notq	%rax+	andq	%rax,%r9+	andq	%rax,%r11+	orq	%r9,%r8+	orq	%r11,%r10++	jmp	__inner_loop_31_256++	.byte	0xf3,0xc3++.def	__inner_loop_31_256;	.scl 3;	.type 32;	.endef+.p2align	5+__inner_loop_31_256:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	$0x7FFFFFFF80000000,%rcx+	movq	$0x800000007FFFFFFF,%r13+	movq	$0x7FFFFFFF7FFFFFFF,%r15++.Loop_31_256:+	cmpq	%r10,%r8+	movq	%r8,%rax+	movq	%r10,%rbx+	movq	%rcx,%rbp+	movq	%r13,%r14+	cmovbq	%r10,%r8+	cmovbq	%rax,%r10+	cmovbq	%r13,%rcx+	cmovbq	%rbp,%r13++	subq	%r10,%r8+	subq	%r13,%rcx+	addq	%r15,%rcx++	testq	$1,%rax+	cmovzq	%rax,%r8+	cmovzq	%rbx,%r10+	cmovzq	%rbp,%rcx+	cmovzq	%r14,%r13++	shrq	$1,%r8+	addq	%r13,%r13+	subq	%r15,%r13+	subl	$1,%edx+	jnz	.Loop_31_256++	shrq	$32,%r15+	movl	%ecx,%edx+	movl	%r13d,%r12d+	shrq	$32,%rcx+	shrq	$32,%r13+	subq	%r15,%rdx+	subq	%r15,%rcx+	subq	%r15,%r12+	subq	%r15,%r13++	.byte	0xf3,0xc3+++.def	__inner_loop_62_256;	.scl 3;	.type 32;	.endef+.p2align	5+__inner_loop_62_256:+	.byte	0xf3,0x0f,0x1e,0xfa++	movl	%edx,%r15d+	movq	$1,%rdx+	xorq	%rcx,%rcx+	xorq	%r12,%r12+	movq	%rdx,%r13+	movq	%rdx,%r14++.Loop_62_256:+	xorq	%rax,%rax+	testq	%r14,%r8+	movq	%r10,%rbx+	cmovnzq	%r10,%rax+	subq	%r8,%rbx+	movq	%r8,%rbp+	subq	%rax,%r8+	cmovcq	%rbx,%r8+	cmovcq	%rbp,%r10+	movq	%rdx,%rax+	cmovcq	%r12,%rdx+	cmovcq	%rax,%r12+	movq	%rcx,%rbx+	cmovcq	%r13,%rcx+	cmovcq	%rbx,%r13+	xorq	%rax,%rax+	xorq	%rbx,%rbx+	shrq	$1,%r8+	testq	%r14,%rbp+	cmovnzq	%r12,%rax+	cmovnzq	%r13,%rbx+	addq	%r12,%r12+	addq	%r13,%r13+	subq	%rax,%rdx+	subq	%rbx,%rcx+	subl	$1,%r15d+	jnz	.Loop_62_256++	.byte	0xf3,0xc3++.section	.pdata+.p2align	2+.rva	.LSEH_begin_ct_inverse_mod_256+.rva	.LSEH_body_ct_inverse_mod_256+.rva	.LSEH_info_ct_inverse_mod_256_prologue++.rva	.LSEH_body_ct_inverse_mod_256+.rva	.LSEH_epilogue_ct_inverse_mod_256+.rva	.LSEH_info_ct_inverse_mod_256_body++.rva	.LSEH_epilogue_ct_inverse_mod_256+.rva	.LSEH_end_ct_inverse_mod_256+.rva	.LSEH_info_ct_inverse_mod_256_epilogue++.section	.xdata+.p2align	3+.LSEH_info_ct_inverse_mod_256_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_ct_inverse_mod_256_body:+.byte	1,0,18,0+.byte	0x00,0xf4,0x86,0x00+.byte	0x00,0xe4,0x87,0x00+.byte	0x00,0xd4,0x88,0x00+.byte	0x00,0xc4,0x89,0x00+.byte	0x00,0x34,0x8a,0x00+.byte	0x00,0x54,0x8b,0x00+.byte	0x00,0x74,0x8d,0x00+.byte	0x00,0x64,0x8e,0x00+.byte	0x00,0x01,0x8c,0x00+.LSEH_info_ct_inverse_mod_256_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00+
+ c-source/build/coff/ct_inverse_mod_384-armv8.S view
@@ -0,0 +1,729 @@+.text++.globl	ct_inverse_mod_383+.def	ct_inverse_mod_383;+.type	32;+.endef+.p2align	5+ct_inverse_mod_383:+.long	3573752639+	stp	x29, x30, [sp,#-128]!+	add	x29, sp, #0+	stp	x19, x20, [sp,#16]+	stp	x21, x22, [sp,#32]+	stp	x23, x24, [sp,#48]+	stp	x25, x26, [sp,#64]+	stp	x27, x28, [sp,#80]+	sub	sp, sp, #1040++	ldp	x22,   x4, [x1,#8*0]+	ldp	x5, x6, [x1,#8*2]+	ldp	x7, x8, [x1,#8*4]++	add	x1, sp, #16+511	// find closest 512-byte-aligned spot+	and	x1, x1, #-512	// in the frame...+	stp	x0, x3, [sp]++	ldp	x9, x10, [x2,#8*0]+	ldp	x11, x12, [x2,#8*2]+	ldp	x13, x14, [x2,#8*4]++	stp	x22,   x4, [x1,#8*0]	// copy input to |a|+	stp	x5, x6, [x1,#8*2]+	stp	x7, x8, [x1,#8*4]+	stp	x9, x10, [x1,#8*6]	// copy modulus to |b|+	stp	x11, x12, [x1,#8*8]+	stp	x13, x14, [x1,#8*10]++	////////////////////////////////////////// first iteration+	mov	x2, #62+	bl	.Lab_approximation_62_loaded++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	str	x15,[x0,#8*12]		// initialize |u| with |f0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to dst |b|+	bl	__smul_383_n_shift_by_62+	str	x15, [x0,#8*12]		// initialize |v| with |f1|++	////////////////////////////////////////// second iteration+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	ldr	x7, [x1,#8*12]	// |u|+	ldr	x8, [x1,#8*18]	// |v|+	mul	x3, x20, x7		// |u|*|f0|+	smulh	x4, x20, x7+	mul	x5, x21, x8		// |v|*|g0|+	smulh	x6, x21, x8+	adds	x3, x3, x5+	adc	x4, x4, x6+	stp	x3, x4, [x0,#8*6]+	asr	x5, x4, #63		// sign extenstion+	stp	x5, x5, [x0,#8*8]+	stp	x5, x5, [x0,#8*10]++	mul	x3, x15, x7		// |u|*|f1|+	smulh	x4, x15, x7+	mul	x5, x16, x8		// |v|*|g1|+	smulh	x6, x16, x8+	adds	x3, x3, x5+	adc	x4, x4, x6+	stp	x3, x4, [x0,#8*12]+	asr	x5, x4, #63		// sign extenstion+	stp	x5, x5, [x0,#8*14]+	stp	x5, x5, [x0,#8*16]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	asr	x27, x27, #63		// sign extension+	stp	x27, x27, [x0,#8*6]+	stp	x27, x27, [x0,#8*8]+	stp	x27, x27, [x0,#8*10]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	bl	__smul_767x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	bl	__smul_767x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	bl	__smul_767x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	bl	__smul_767x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	bl	__smul_767x63_tail+	////////////////////////////////////////// iteration before last+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	//bl	__ab_approximation_62		// |a| and |b| are exact,+	ldp	x3, x8, [x1,#8*0]	// just load+	ldp	x9, x14, [x1,#8*6]+	bl	__inner_loop_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	str	x3, [x0,#8*0]+	str	x9, [x0,#8*6]++	mov	x20, x15			// exact |f0|+	mov	x21, x16			// exact |g0|+	mov	x15, x17+	mov	x16, x19+	add	x0, x0, #8*12	// pointer to dst |u|+	bl	__smul_383x63++	mov	x20, x15			// exact |f1|+	mov	x21, x16			// exact |g1|+	add	x0, x0, #8*6	// pointer to dst |v|+	bl	__smul_383x63+	bl	__smul_767x63_tail++	////////////////////////////////////////// last iteration+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #22			// 766 % 62+	//bl	__ab_approximation_62		// |a| and |b| are exact,+	ldr	x3, [x1,#8*0]		// just load+	eor	x8, x8, x8+	ldr	x9, [x1,#8*6]+	eor	x14, x14, x14+	bl	__inner_loop_62++	mov	x20, x17+	mov	x21, x19+	ldp	x0, x15, [sp]		// original out_ptr and n_ptr+	bl	__smul_383x63+	bl	__smul_767x63_tail+	ldr	x30, [x29,#8]++	asr	x22, x8, #63		// sign as mask+	ldp	x9, x10, [x15,#8*0]+	ldp	x11, x12, [x15,#8*2]+	ldp	x13, x14, [x15,#8*4]++	and	x9, x9, x22		// add mod<<384 conditionally+	and	x10, x10, x22+	adds	x3, x3, x9+	and	x11, x11, x22+	adcs	x4, x4, x10+	and	x12, x12, x22+	adcs	x5, x5, x11+	and	x13, x13, x22+	adcs	x6, x6, x12+	and	x14, x14, x22+	stp	x3, x4, [x0,#8*6]+	adcs	x7, x7, x13+	stp	x5, x6, [x0,#8*8]+	adc	x8, x8, x14+	stp	x7, x8, [x0,#8*10]++	add	sp, sp, #1040+	ldp	x19, x20, [x29,#16]+	ldp	x21, x22, [x29,#32]+	ldp	x23, x24, [x29,#48]+	ldp	x25, x26, [x29,#64]+	ldp	x27, x28, [x29,#80]+	ldr	x29, [sp],#128+.long	3573752767+	ret+++////////////////////////////////////////////////////////////////////////+// see corresponding commentary in ctx_inverse_mod_384-x86_64...+.def	__smul_383x63;+.type	32;+.endef+.p2align	5+__smul_383x63:+	ldp	x3, x4, [x1,#8*0+96]	// load |u| (or |v|)+	asr	x17, x20, #63		// |f_|'s sign as mask (or |g_|'s)+	ldp	x5, x6, [x1,#8*2+96]+	eor	x20, x20, x17		// conditionally negate |f_| (or |g_|)+	ldp	x7, x8, [x1,#8*4+96]++	eor	x3, x3, x17	// conditionally negate |u| (or |v|)+	sub	x20, x20, x17+	eor	x4, x4, x17+	adds	x3, x3, x17, lsr#63+	eor	x5, x5, x17+	adcs	x4, x4, xzr+	eor	x6, x6, x17+	adcs	x5, x5, xzr+	eor	x7, x7, x17+	adcs	x6, x6, xzr+	umulh	x22, x3, x20+	eor	x8, x8, x17+	umulh	x23, x4, x20+	adcs	x7, x7, xzr+	umulh	x24, x5, x20+	adcs	x8, x8, xzr+	umulh	x25, x6, x20+	umulh	x26, x7, x20+	mul	x3, x3, x20+	mul	x4, x4, x20+	mul	x5, x5, x20+	adds	x4, x4, x22+	mul	x6, x6, x20+	adcs	x5, x5, x23+	mul	x7, x7, x20+	adcs	x6, x6, x24+	mul	x27,x8, x20+	adcs	x7, x7, x25+	adcs	x27,x27,x26+	adc	x2, xzr, xzr+	ldp	x9, x10, [x1,#8*0+144]	// load |u| (or |v|)+	asr	x17, x21, #63		// |f_|'s sign as mask (or |g_|'s)+	ldp	x11, x12, [x1,#8*2+144]+	eor	x21, x21, x17		// conditionally negate |f_| (or |g_|)+	ldp	x13, x14, [x1,#8*4+144]++	eor	x9, x9, x17	// conditionally negate |u| (or |v|)+	sub	x21, x21, x17+	eor	x10, x10, x17+	adds	x9, x9, x17, lsr#63+	eor	x11, x11, x17+	adcs	x10, x10, xzr+	eor	x12, x12, x17+	adcs	x11, x11, xzr+	eor	x13, x13, x17+	adcs	x12, x12, xzr+	umulh	x22, x9, x21+	eor	x14, x14, x17+	umulh	x23, x10, x21+	adcs	x13, x13, xzr+	umulh	x24, x11, x21+	adcs	x14, x14, xzr+	umulh	x25, x12, x21+	adc	x19, xzr, xzr		// used in __smul_767x63_tail+	umulh	x26, x13, x21+	mul	x9, x9, x21+	mul	x10, x10, x21+	mul	x11, x11, x21+	adds	x10, x10, x22+	mul	x12, x12, x21+	adcs	x11, x11, x23+	mul	x13, x13, x21+	adcs	x12, x12, x24+	mul	x28,x14, x21+	adcs	x13, x13, x25+	adcs	x28,x28,x26+	adc	x2, x2, xzr++	adds	x3, x3, x9+	adcs	x4, x4, x10+	adcs	x5, x5, x11+	adcs	x6, x6, x12+	stp	x3, x4, [x0,#8*0]+	adcs	x7, x7, x13+	stp	x5, x6, [x0,#8*2]+	adcs	x27,   x27,   x28+	stp	x7, x27,   [x0,#8*4]+	adc	x28,   x2,   xzr	// used in __smul_767x63_tail++	ret+++.def	__smul_767x63_tail;+.type	32;+.endef+.p2align	5+__smul_767x63_tail:+	smulh	x27,   x8, x20+	ldp	x3, x4, [x1,#8*24]	// load rest of |v|+	umulh	x14,x14, x21+	ldp	x5, x6, [x1,#8*26]+	ldp	x7, x8, [x1,#8*28]++	eor	x3, x3, x17	// conditionally negate rest of |v|+	eor	x4, x4, x17+	eor	x5, x5, x17+	adds	x3, x3, x19+	eor	x6, x6, x17+	adcs	x4, x4, xzr+	eor	x7, x7, x17+	adcs	x5, x5, xzr+	eor	x8, x8, x17+	adcs	x6, x6, xzr+	umulh	x22, x3, x21+	adcs	x7, x7, xzr+	umulh	x23, x4, x21+	adc	x8, x8, xzr++	umulh	x24, x5, x21+	add	x14, x14, x28+	umulh	x25, x6, x21+	asr	x28, x27, #63+	umulh	x26, x7, x21+	mul	x3, x3, x21+	mul	x4, x4, x21+	mul	x5, x5, x21+	adds	x3, x3, x14+	mul	x6, x6, x21+	adcs	x4, x4, x22+	mul	x7, x7, x21+	adcs	x5, x5, x23+	mul	x8, x8, x21+	adcs	x6, x6, x24+	adcs	x7, x7, x25+	adc	x8, x8, x26++	adds	x3, x3, x27+	adcs	x4, x4, x28+	adcs	x5, x5, x28+	adcs	x6, x6, x28+	stp	x3, x4, [x0,#8*6]+	adcs	x7, x7, x28+	stp	x5, x6, [x0,#8*8]+	adc	x8, x8, x28+	stp	x7, x8, [x0,#8*10]++	ret+++.def	__smul_383_n_shift_by_62;+.type	32;+.endef+.p2align	5+__smul_383_n_shift_by_62:+	ldp	x3, x4, [x1,#8*0+0]	// load |a| (or |b|)+	asr	x28, x15, #63		// |f0|'s sign as mask (or |g0|'s)+	ldp	x5, x6, [x1,#8*2+0]+	eor	x2, x15, x28	// conditionally negate |f0| (or |g0|)+	ldp	x7, x8, [x1,#8*4+0]++	eor	x3, x3, x28	// conditionally negate |a| (or |b|)+	sub	x2, x2, x28+	eor	x4, x4, x28+	adds	x3, x3, x28, lsr#63+	eor	x5, x5, x28+	adcs	x4, x4, xzr+	eor	x6, x6, x28+	adcs	x5, x5, xzr+	eor	x7, x7, x28+	umulh	x22, x3, x2+	adcs	x6, x6, xzr+	umulh	x23, x4, x2+	eor	x8, x8, x28+	umulh	x24, x5, x2+	adcs	x7, x7, xzr+	umulh	x25, x6, x2+	adc	x8, x8, xzr++	umulh	x26, x7, x2+	smulh	x27, x8, x2+	mul	x3, x3, x2+	mul	x4, x4, x2+	mul	x5, x5, x2+	adds	x4, x4, x22+	mul	x6, x6, x2+	adcs	x5, x5, x23+	mul	x7, x7, x2+	adcs	x6, x6, x24+	mul	x8, x8, x2+	adcs	x7, x7, x25+	adcs	x8, x8 ,x26+	adc	x27, x27, xzr+	ldp	x9, x10, [x1,#8*0+48]	// load |a| (or |b|)+	asr	x28, x16, #63		// |f0|'s sign as mask (or |g0|'s)+	ldp	x11, x12, [x1,#8*2+48]+	eor	x2, x16, x28	// conditionally negate |f0| (or |g0|)+	ldp	x13, x14, [x1,#8*4+48]++	eor	x9, x9, x28	// conditionally negate |a| (or |b|)+	sub	x2, x2, x28+	eor	x10, x10, x28+	adds	x9, x9, x28, lsr#63+	eor	x11, x11, x28+	adcs	x10, x10, xzr+	eor	x12, x12, x28+	adcs	x11, x11, xzr+	eor	x13, x13, x28+	umulh	x22, x9, x2+	adcs	x12, x12, xzr+	umulh	x23, x10, x2+	eor	x14, x14, x28+	umulh	x24, x11, x2+	adcs	x13, x13, xzr+	umulh	x25, x12, x2+	adc	x14, x14, xzr++	umulh	x26, x13, x2+	smulh	x28, x14, x2+	mul	x9, x9, x2+	mul	x10, x10, x2+	mul	x11, x11, x2+	adds	x10, x10, x22+	mul	x12, x12, x2+	adcs	x11, x11, x23+	mul	x13, x13, x2+	adcs	x12, x12, x24+	mul	x14, x14, x2+	adcs	x13, x13, x25+	adcs	x14, x14 ,x26+	adc	x28, x28, xzr+	adds	x3, x3, x9+	adcs	x4, x4, x10+	adcs	x5, x5, x11+	adcs	x6, x6, x12+	adcs	x7, x7, x13+	adcs	x8, x8, x14+	adc	x9, x27,   x28++	extr	x3, x4, x3, #62+	extr	x4, x5, x4, #62+	extr	x5, x6, x5, #62+	asr	x28, x9, #63+	extr	x6, x7, x6, #62+	extr	x7, x8, x7, #62+	extr	x8, x9, x8, #62++	eor	x3, x3, x28+	eor	x4, x4, x28+	adds	x3, x3, x28, lsr#63+	eor	x5, x5, x28+	adcs	x4, x4, xzr+	eor	x6, x6, x28+	adcs	x5, x5, xzr+	eor	x7, x7, x28+	adcs	x6, x6, xzr+	eor	x8, x8, x28+	stp	x3, x4, [x0,#8*0]+	adcs	x7, x7, xzr+	stp	x5, x6, [x0,#8*2]+	adc	x8, x8, xzr+	stp	x7, x8, [x0,#8*4]++	eor	x15, x15, x28+	eor	x16, x16, x28+	sub	x15, x15, x28+	sub	x16, x16, x28++	ret++.def	__ab_approximation_62;+.type	32;+.endef+.p2align	4+__ab_approximation_62:+	ldp	x7, x8, [x1,#8*4]+	ldp	x13, x14, [x1,#8*10]+	ldp	x5, x6, [x1,#8*2]+	ldp	x11, x12, [x1,#8*8]++.Lab_approximation_62_loaded:+	orr	x22, x8, x14	// check top-most limbs, ...+	cmp	x22, #0+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	csel	x7, x7, x6, ne+	orr	x22, x8, x14	// ... ones before top-most, ...+	csel	x13, x13, x12, ne++	ldp	x3, x4, [x1,#8*0]+	ldp	x9, x10, [x1,#8*6]++	cmp	x22, #0+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	csel	x7, x7, x5, ne+	orr	x22, x8, x14	// ... and ones before that ...+	csel	x13, x13, x11, ne++	cmp	x22, #0+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	csel	x7, x7, x4, ne+	orr	x22, x8, x14+	csel	x13, x13, x10, ne++	clz	x22, x22+	cmp	x22, #64+	csel	x22, x22, xzr, ne+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	neg	x23, x22++	lslv	x8, x8, x22	// align high limbs to the left+	lslv	x14, x14, x22+	lsrv	x7, x7, x23+	lsrv	x13, x13, x23+	and	x7, x7, x23, asr#6+	and	x13, x13, x23, asr#6+	orr	x8, x8, x7+	orr	x14, x14, x13++	b	__inner_loop_62+	ret++.def	__inner_loop_62;+.type	32;+.endef+.p2align	4+__inner_loop_62:+	mov	x15, #1		// |f0|=1+	mov	x16, #0		// |g0|=0+	mov	x17, #0		// |f1|=0+	mov	x19, #1		// |g1|=1++.Loop_62:+	sbfx	x28, x3, #0, #1	// if |a_| is odd, then we'll be subtracting+	sub	x2, x2, #1+	subs	x24, x9, x3	// |b_|-|a_|+	and	x22, x9, x28+	sbc	x25, x14, x8+	and	x23, x14, x28+	subs	x26, x3, x22	// |a_|-|b_| (or |a_|-0 if |a_| was even)+	mov	x22, x15+	sbcs	x27, x8, x23+	mov	x23, x16+	csel	x9, x9, x3, hs	// |b_| = |a_|+	csel	x14, x14, x8, hs+	csel	x3, x26, x24, hs	// borrow means |a_|<|b_|, replace with |b_|-|a_|+	csel	x8, x27, x25, hs+	csel	x15, x15, x17,       hs	// exchange |f0| and |f1|+	csel	x17, x17, x22,     hs+	csel	x16, x16, x19,       hs	// exchange |g0| and |g1|+	csel	x19, x19, x23,     hs+	extr	x3, x8, x3, #1+	lsr	x8, x8, #1+	and	x22, x17, x28+	and	x23, x19, x28+	add	x17, x17, x17		// |f1|<<=1+	add	x19, x19, x19		// |g1|<<=1+	sub	x15, x15, x22		// |f0|-=|f1| (or |f0-=0| if |a_| was even)+	sub	x16, x16, x23		// |g0|-=|g1| (or |g0-=0| ...)+	cbnz	x2, .Loop_62++	ret+
+ c-source/build/coff/ct_is_square_mod_384-armv8.S view
@@ -0,0 +1,334 @@+.text++.globl	ct_is_square_mod_384+.def	ct_is_square_mod_384;+.type	32;+.endef+.p2align	5+ct_is_square_mod_384:+.long	3573752639+	stp	x29, x30, [sp,#-128]!+	add	x29, sp, #0+	stp	x19, x20, [sp,#16]+	stp	x21, x22, [sp,#32]+	stp	x23, x24, [sp,#48]+	stp	x25, x26, [sp,#64]+	stp	x27, x28, [sp,#80]+	sub	sp, sp, #512++	ldp	x3, x4, [x0,#8*0]		// load input+	ldp	x5, x6, [x0,#8*2]+	ldp	x7, x8, [x0,#8*4]++	add	x0, sp, #255	// find closest 256-byte-aligned spot+	and	x0, x0, #-256	// in the frame...++	ldp	x9, x10, [x1,#8*0]		// load modulus+	ldp	x11, x12, [x1,#8*2]+	ldp	x13, x14, [x1,#8*4]++	stp	x3, x4, [x0,#8*6]	// copy input to |a|+	stp	x5, x6, [x0,#8*8]+	stp	x7, x8, [x0,#8*10]+	stp	x9, x10, [x0,#8*0]	// copy modulus to |b|+	stp	x11, x12, [x0,#8*2]+	stp	x13, x14, [x0,#8*4]++	eor	x2, x2, x2			// init the .Legendre symbol+	mov	x15, #24			// 24 is 768/30-1+	b	.Loop_is_square++.p2align	4+.Loop_is_square:+	bl	__ab_approximation_30+	sub	x15, x15, #1++	eor	x1, x0, #128		// pointer to dst |b|+	bl	__smul_384_n_shift_by_30++	mov	x19, x16			// |f0|+	mov	x20, x17			// |g0|+	add	x1, x1, #8*6	// pointer to dst |a|+	bl	__smul_384_n_shift_by_30++	ldp	x9, x10, [x1,#-8*6]+	eor	x0, x0, #128		// flip-flop src |a|b|+	and	x27, x27, x9		// if |a| was negative,+	add	x2, x2, x27, lsr#1		// adjust |L|++	cbnz	x15, .Loop_is_square++	////////////////////////////////////////// last iteration+	//bl	__ab_approximation_30		// |a| and |b| are exact,+	//ldr	x8, [x0,#8*6]		// and loaded+	//ldr	x14, [x0,#8*0]+	mov	x15, #48			// 48 is 768%30 + 30+	bl	__inner_loop_48+	ldr	x30, [x29,#8]++	and	x0, x2, #1+	eor	x0, x0, #1++	add	sp, sp, #512+	ldp	x19, x20, [x29,#16]+	ldp	x21, x22, [x29,#32]+	ldp	x23, x24, [x29,#48]+	ldp	x25, x26, [x29,#64]+	ldp	x27, x28, [x29,#80]+	ldr	x29, [sp],#128+.long	3573752767+	ret+++.def	__smul_384_n_shift_by_30;+.type	32;+.endef+.p2align	5+__smul_384_n_shift_by_30:+	ldp	x3, x4, [x0,#8*0+0]	// load |b| (or |a|)+	asr	x27, x20, #63		// |g1|'s sign as mask (or |f1|'s)+	ldp	x5, x6, [x0,#8*2+0]+	eor	x20, x20, x27		// conditionally negate |g1| (or |f1|)+	ldp	x7, x8, [x0,#8*4+0]++	eor	x3, x3, x27	// conditionally negate |b| (or |a|)+	sub	x20, x20, x27+	eor	x4, x4, x27+	adds	x3, x3, x27, lsr#63+	eor	x5, x5, x27+	adcs	x4, x4, xzr+	eor	x6, x6, x27+	adcs	x5, x5, xzr+	eor	x7, x7, x27+	umulh	x21, x3, x20+	adcs	x6, x6, xzr+	umulh	x22, x4, x20+	eor	x8, x8, x27+	umulh	x23, x5, x20+	adcs	x7, x7, xzr+	umulh	x24, x6, x20+	adc	x8, x8, xzr++	umulh	x25, x7, x20+	and	x28, x20, x27+	umulh	x26, x8, x20+	neg	x28, x28+	mul	x3, x3, x20+	mul	x4, x4, x20+	mul	x5, x5, x20+	adds	x4, x4, x21+	mul	x6, x6, x20+	adcs	x5, x5, x22+	mul	x7, x7, x20+	adcs	x6, x6, x23+	mul	x8, x8, x20+	adcs	x7, x7, x24+	adcs	x8, x8 ,x25+	adc	x26, x26, x28+	ldp	x9, x10, [x0,#8*0+48]	// load |b| (or |a|)+	asr	x27, x19, #63		// |g1|'s sign as mask (or |f1|'s)+	ldp	x11, x12, [x0,#8*2+48]+	eor	x19, x19, x27		// conditionally negate |g1| (or |f1|)+	ldp	x13, x14, [x0,#8*4+48]++	eor	x9, x9, x27	// conditionally negate |b| (or |a|)+	sub	x19, x19, x27+	eor	x10, x10, x27+	adds	x9, x9, x27, lsr#63+	eor	x11, x11, x27+	adcs	x10, x10, xzr+	eor	x12, x12, x27+	adcs	x11, x11, xzr+	eor	x13, x13, x27+	umulh	x21, x9, x19+	adcs	x12, x12, xzr+	umulh	x22, x10, x19+	eor	x14, x14, x27+	umulh	x23, x11, x19+	adcs	x13, x13, xzr+	umulh	x24, x12, x19+	adc	x14, x14, xzr++	umulh	x25, x13, x19+	and	x28, x19, x27+	umulh	x27, x14, x19+	neg	x28, x28+	mul	x9, x9, x19+	mul	x10, x10, x19+	mul	x11, x11, x19+	adds	x10, x10, x21+	mul	x12, x12, x19+	adcs	x11, x11, x22+	mul	x13, x13, x19+	adcs	x12, x12, x23+	mul	x14, x14, x19+	adcs	x13, x13, x24+	adcs	x14, x14 ,x25+	adc	x27, x27, x28+	adds	x3, x3, x9+	adcs	x4, x4, x10+	adcs	x5, x5, x11+	adcs	x6, x6, x12+	adcs	x7, x7, x13+	adcs	x8, x8, x14+	adc	x9, x26,   x27++	extr	x3, x4, x3, #30+	extr	x4, x5, x4, #30+	extr	x5, x6, x5, #30+	asr	x27, x9, #63+	extr	x6, x7, x6, #30+	extr	x7, x8, x7, #30+	extr	x8, x9, x8, #30++	eor	x3, x3, x27+	eor	x4, x4, x27+	adds	x3, x3, x27, lsr#63+	eor	x5, x5, x27+	adcs	x4, x4, xzr+	eor	x6, x6, x27+	adcs	x5, x5, xzr+	eor	x7, x7, x27+	adcs	x6, x6, xzr+	eor	x8, x8, x27+	stp	x3, x4, [x1,#8*0]+	adcs	x7, x7, xzr+	stp	x5, x6, [x1,#8*2]+	adc	x8, x8, xzr+	stp	x7, x8, [x1,#8*4]++	ret++.def	__ab_approximation_30;+.type	32;+.endef+.p2align	4+__ab_approximation_30:+	ldp	x13, x14, [x0,#8*4]	// |a| is still in registers+	ldp	x11, x12, [x0,#8*2]++	orr	x21, x8, x14	// check top-most limbs, ...+	cmp	x21, #0+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	csel	x7, x7, x6, ne+	orr	x21, x8, x14	// ... ones before top-most, ...+	csel	x13, x13, x12, ne++	cmp	x21, #0+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	csel	x7, x7, x5, ne+	orr	x21, x8, x14	// ... and ones before that ...+	csel	x13, x13, x11, ne++	cmp	x21, #0+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	csel	x7, x7, x4, ne+	orr	x21, x8, x14	// and one more, ...+	csel	x13, x13, x10, ne++	cmp	x21, #0+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	csel	x7, x7, x3, ne+	orr	x21, x8, x14+	csel	x13, x13, x9, ne++	clz	x21, x21+	cmp	x21, #64+	csel	x21, x21, xzr, ne+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	neg	x22, x21++	lslv	x8, x8, x21	// align high limbs to the left+	lslv	x14, x14, x21+	lsrv	x7, x7, x22+	lsrv	x13, x13, x22+	and	x7, x7, x22, asr#6+	and	x13, x13, x22, asr#6+	orr	x8, x8, x7+	orr	x14, x14, x13++	bfxil	x8, x3, #0, #32+	bfxil	x14, x9, #0, #32++	b	__inner_loop_30+	ret+++.def	__inner_loop_30;+.type	32;+.endef+.p2align	4+__inner_loop_30:+	mov	x28, #30+	mov	x17, #0x7FFFFFFF80000000	// |f0|=1, |g0|=0+	mov	x20, #0x800000007FFFFFFF	// |f1|=0, |g1|=1+	mov	x27,#0x7FFFFFFF7FFFFFFF++.Loop_30:+	sbfx	x24, x8, #0, #1	// if |a_| is odd, then we'll be subtracting+	and	x25, x8, x14+	sub	x28, x28, #1+	and	x21, x14, x24++	sub	x22, x14, x8		// |b_|-|a_|+	subs	x23, x8, x21	// |a_|-|b_| (or |a_|-0 if |a_| was even)+	add	x25, x2, x25, lsr#1	// L + (a_ & b_) >> 1+	mov	x21, x20+	csel	x14, x14, x8, hs	// |b_| = |a_|+	csel	x8, x23, x22, hs	// borrow means |a_|<|b_|, replace with |b_|-|a_|+	csel	x20, x20, x17,  hs	// exchange |fg0| and |fg1|+	csel	x17, x17, x21, hs+	csel	x2,   x2,   x25, hs+	lsr	x8, x8, #1+	and	x21, x20, x24+	and	x22, x27, x24+	add	x23, x14, #2+	sub	x17, x17, x21	// |f0|-=|f1| (or |f0-=0| if |a_| was even)+	add	x20, x20, x20	// |f1|<<=1+	add	x2, x2, x23, lsr#2	// "negate" |L| if |b|%8 is 3 or 5+	add	x17, x17, x22+	sub	x20, x20, x27++	cbnz	x28, .Loop_30++	mov	x27, #0x7FFFFFFF+	ubfx	x16, x17, #0, #32+	ubfx	x17, x17, #32, #32+	ubfx	x19, x20, #0, #32+	ubfx	x20, x20, #32, #32+	sub	x16, x16, x27		// remove the bias+	sub	x17, x17, x27+	sub	x19, x19, x27+	sub	x20, x20, x27++	ret++.def	__inner_loop_48;+.type	32;+.endef+.p2align	4+__inner_loop_48:+.Loop_48:+	sbfx	x24, x3, #0, #1	// if |a_| is odd, then we'll be subtracting+	and	x25, x3, x9+	sub	x15, x15, #1+	and	x21, x9, x24+	sub	x22, x9, x3		// |b_|-|a_|+	subs	x23, x3, x21	// |a_|-|b_| (or |a_|-0 if |a_| was even)+	add	x25, x2, x25, lsr#1+	csel	x9, x9, x3, hs	// |b_| = |a_|+	csel	x3, x23, x22, hs	// borrow means |a_|<|b_|, replace with |b_|-|a_|+	csel	x2,   x2,   x25, hs+	add	x23, x9, #2+	lsr	x3, x3, #1+	add	x2, x2, x23, lsr#2	// "negate" |L| if |b|%8 is 3 or 5++	cbnz	x15, .Loop_48++	ret+
+ c-source/build/coff/ct_is_square_mod_384-x86_64.s view
@@ -0,0 +1,505 @@+.text	++.globl	ct_is_square_mod_384+.def	ct_is_square_mod_384;	.scl 2;	.type 32;	.endef+.p2align	5+ct_is_square_mod_384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_ct_is_square_mod_384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$536,%rsp++.LSEH_body_ct_is_square_mod_384:+++	leaq	24+255(%rsp),%rax+	andq	$-256,%rax++	movq	0(%rdi),%r8+	movq	8(%rdi),%r9+	movq	16(%rdi),%r10+	movq	24(%rdi),%r11+	movq	32(%rdi),%r12+	movq	40(%rdi),%r13++	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%rbx+	movq	24(%rsi),%rcx+	movq	32(%rsi),%rdx+	movq	40(%rsi),%rdi+	movq	%rax,%rsi++	movq	%r8,0(%rax)+	movq	%r9,8(%rax)+	movq	%r10,16(%rax)+	movq	%r11,24(%rax)+	movq	%r12,32(%rax)+	movq	%r13,40(%rax)++	movq	%r14,48(%rax)+	movq	%r15,56(%rax)+	movq	%rbx,64(%rax)+	movq	%rcx,72(%rax)+	movq	%rdx,80(%rax)+	movq	%rdi,88(%rax)++	xorq	%rbp,%rbp+	movl	$24,%ecx+	jmp	.Loop_is_square++.p2align	5+.Loop_is_square:+	movl	%ecx,16(%rsp)++	call	__ab_approximation_30+	movq	%rax,0(%rsp)+	movq	%rbx,8(%rsp)++	movq	$128+48,%rdi+	xorq	%rsi,%rdi+	call	__smulq_384_n_shift_by_30++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	-48(%rdi),%rdi+	call	__smulq_384_n_shift_by_30++	movl	16(%rsp),%ecx+	xorq	$128,%rsi++	andq	48(%rdi),%r14+	shrq	$1,%r14+	addq	%r14,%rbp++	subl	$1,%ecx+	jnz	.Loop_is_square+++++	movq	48(%rsi),%r9+	call	__inner_loop_48++	movq	$1,%rax+	andq	%rbp,%rax+	xorq	$1,%rax++	leaq	536(%rsp),%r8+	movq	0(%r8),%r15++	movq	8(%r8),%r14++	movq	16(%r8),%r13++	movq	24(%r8),%r12++	movq	32(%r8),%rbx++	movq	40(%r8),%rbp++	leaq	48(%r8),%rsp++.LSEH_epilogue_ct_is_square_mod_384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_ct_is_square_mod_384:++.def	__smulq_384_n_shift_by_30;	.scl 3;	.type 32;	.endef+.p2align	5+__smulq_384_n_shift_by_30:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rdx,%rbx+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbx+	addq	%rax,%rbx++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	movq	%rdx,%r14+	andq	%rbx,%r14+	mulq	%rbx+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbx+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rbx+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rbx+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	mulq	%rbx+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	negq	%r14+	mulq	%rbx+	addq	%rax,%r13+	adcq	%rdx,%r14+	leaq	48(%rsi),%rsi+	movq	%rcx,%rdx++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)+	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rdx,%rbx+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbx+	addq	%rax,%rbx++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	movq	%rdx,%r15+	andq	%rbx,%r15+	mulq	%rbx+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbx+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rbx+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rbx+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	mulq	%rbx+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	negq	%r15+	mulq	%rbx+	addq	%rax,%r13+	adcq	%rdx,%r15+	leaq	-48(%rsi),%rsi++	addq	0(%rdi),%r8+	adcq	8(%rdi),%r9+	adcq	16(%rdi),%r10+	adcq	24(%rdi),%r11+	adcq	32(%rdi),%r12+	adcq	40(%rdi),%r13+	adcq	%r15,%r14++	shrdq	$30,%r9,%r8+	shrdq	$30,%r10,%r9+	shrdq	$30,%r11,%r10+	shrdq	$30,%r12,%r11+	shrdq	$30,%r13,%r12+	shrdq	$30,%r14,%r13++	sarq	$63,%r14+	xorq	%rbx,%rbx+	subq	%r14,%rbx++	xorq	%r14,%r8+	xorq	%r14,%r9+	xorq	%r14,%r10+	xorq	%r14,%r11+	xorq	%r14,%r12+	xorq	%r14,%r13+	addq	%rbx,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3++.def	__ab_approximation_30;	.scl 3;	.type 32;	.endef+.p2align	5+__ab_approximation_30:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	88(%rsi),%rbx+	movq	80(%rsi),%r15+	movq	72(%rsi),%r14++	movq	%r13,%rax+	orq	%rbx,%rax+	cmovzq	%r12,%r13+	cmovzq	%r15,%rbx+	cmovzq	%r11,%r12+	movq	64(%rsi),%r11+	cmovzq	%r14,%r15++	movq	%r13,%rax+	orq	%rbx,%rax+	cmovzq	%r12,%r13+	cmovzq	%r15,%rbx+	cmovzq	%r10,%r12+	movq	56(%rsi),%r10+	cmovzq	%r11,%r15++	movq	%r13,%rax+	orq	%rbx,%rax+	cmovzq	%r12,%r13+	cmovzq	%r15,%rbx+	cmovzq	%r9,%r12+	movq	48(%rsi),%r9+	cmovzq	%r10,%r15++	movq	%r13,%rax+	orq	%rbx,%rax+	cmovzq	%r12,%r13+	cmovzq	%r15,%rbx+	cmovzq	%r8,%r12+	cmovzq	%r9,%r15++	movq	%r13,%rax+	orq	%rbx,%rax+	bsrq	%rax,%rcx+	leaq	1(%rcx),%rcx+	cmovzq	%r8,%r13+	cmovzq	%r9,%rbx+	cmovzq	%rax,%rcx+	negq	%rcx+++	shldq	%cl,%r12,%r13+	shldq	%cl,%r15,%rbx++	movq	$0xFFFFFFFF00000000,%rax+	movl	%r8d,%r8d+	movl	%r9d,%r9d+	andq	%rax,%r13+	andq	%rax,%rbx+	orq	%r13,%r8+	orq	%rbx,%r9++	jmp	__inner_loop_30++	.byte	0xf3,0xc3++.def	__inner_loop_30;	.scl 3;	.type 32;	.endef+.p2align	5+__inner_loop_30:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	$0x7FFFFFFF80000000,%rbx+	movq	$0x800000007FFFFFFF,%rcx+	leaq	-1(%rbx),%r15+	movl	$30,%edi++.Loop_30:+	movq	%r8,%rax+	andq	%r9,%rax+	shrq	$1,%rax++	cmpq	%r9,%r8+	movq	%r8,%r10+	movq	%r9,%r11+	leaq	(%rax,%rbp,1),%rax+	movq	%rbx,%r12+	movq	%rcx,%r13+	movq	%rbp,%r14+	cmovbq	%r9,%r8+	cmovbq	%r10,%r9+	cmovbq	%rcx,%rbx+	cmovbq	%r12,%rcx+	cmovbq	%rax,%rbp++	subq	%r9,%r8+	subq	%rcx,%rbx+	addq	%r15,%rbx++	testq	$1,%r10+	cmovzq	%r10,%r8+	cmovzq	%r11,%r9+	cmovzq	%r12,%rbx+	cmovzq	%r13,%rcx+	cmovzq	%r14,%rbp++	leaq	2(%r9),%rax+	shrq	$1,%r8+	shrq	$2,%rax+	addq	%rcx,%rcx+	leaq	(%rax,%rbp,1),%rbp+	subq	%r15,%rcx++	subl	$1,%edi+	jnz	.Loop_30++	shrq	$32,%r15+	movl	%ebx,%eax+	shrq	$32,%rbx+	movl	%ecx,%edx+	shrq	$32,%rcx+	subq	%r15,%rax+	subq	%r15,%rbx+	subq	%r15,%rdx+	subq	%r15,%rcx++	.byte	0xf3,0xc3+++.def	__inner_loop_48;	.scl 3;	.type 32;	.endef+.p2align	5+__inner_loop_48:+	.byte	0xf3,0x0f,0x1e,0xfa++	movl	$48,%edi++.Loop_48:+	movq	%r8,%rax+	andq	%r9,%rax+	shrq	$1,%rax++	cmpq	%r9,%r8+	movq	%r8,%r10+	movq	%r9,%r11+	leaq	(%rax,%rbp,1),%rax+	movq	%rbp,%r12+	cmovbq	%r9,%r8+	cmovbq	%r10,%r9+	cmovbq	%rax,%rbp++	subq	%r9,%r8++	testq	$1,%r10+	cmovzq	%r10,%r8+	cmovzq	%r11,%r9+	cmovzq	%r12,%rbp++	leaq	2(%r9),%rax+	shrq	$1,%r8+	shrq	$2,%rax+	addq	%rax,%rbp++	subl	$1,%edi+	jnz	.Loop_48++	.byte	0xf3,0xc3++.section	.pdata+.p2align	2+.rva	.LSEH_begin_ct_is_square_mod_384+.rva	.LSEH_body_ct_is_square_mod_384+.rva	.LSEH_info_ct_is_square_mod_384_prologue++.rva	.LSEH_body_ct_is_square_mod_384+.rva	.LSEH_epilogue_ct_is_square_mod_384+.rva	.LSEH_info_ct_is_square_mod_384_body++.rva	.LSEH_epilogue_ct_is_square_mod_384+.rva	.LSEH_end_ct_is_square_mod_384+.rva	.LSEH_info_ct_is_square_mod_384_epilogue++.section	.xdata+.p2align	3+.LSEH_info_ct_is_square_mod_384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_ct_is_square_mod_384_body:+.byte	1,0,18,0+.byte	0x00,0xf4,0x43,0x00+.byte	0x00,0xe4,0x44,0x00+.byte	0x00,0xd4,0x45,0x00+.byte	0x00,0xc4,0x46,0x00+.byte	0x00,0x34,0x47,0x00+.byte	0x00,0x54,0x48,0x00+.byte	0x00,0x74,0x4a,0x00+.byte	0x00,0x64,0x4b,0x00+.byte	0x00,0x01,0x49,0x00+.LSEH_info_ct_is_square_mod_384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00+
+ c-source/build/coff/ctq_inverse_mod_384-x86_64.s view
@@ -0,0 +1,1221 @@+.text	++.globl	ct_inverse_mod_383+.def	ct_inverse_mod_383;	.scl 2;	.type 32;	.endef+.p2align	5+ct_inverse_mod_383:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_ct_inverse_mod_383:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$1112,%rsp++.LSEH_body_ct_inverse_mod_383:+++	leaq	88+511(%rsp),%rax+	andq	$-512,%rax+	movq	%rdi,32(%rsp)+	movq	%rcx,40(%rsp)++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	0(%rdx),%r14+	movq	8(%rdx),%r15+	movq	16(%rdx),%rbx+	movq	24(%rdx),%rbp+	movq	32(%rdx),%rsi+	movq	40(%rdx),%rdi++	movq	%r8,0(%rax)+	movq	%r9,8(%rax)+	movq	%r10,16(%rax)+	movq	%r11,24(%rax)+	movq	%r12,32(%rax)+	movq	%r13,40(%rax)++	movq	%r14,48(%rax)+	movq	%r15,56(%rax)+	movq	%rbx,64(%rax)+	movq	%rbp,72(%rax)+	movq	%rsi,80(%rax)+	movq	%rax,%rsi+	movq	%rdi,88(%rax)+++	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+++	movq	%rdx,96(%rdi)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+++	movq	%rdx,96(%rdi)+++	xorq	$256,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62++++	movq	96(%rsi),%rax+	movq	144(%rsi),%r11+	movq	%rdx,%rbx+	movq	%rax,%r10+	imulq	56(%rsp)+	movq	%rax,%r8+	movq	%r11,%rax+	movq	%rdx,%r9+	imulq	64(%rsp)+	addq	%rax,%r8+	adcq	%rdx,%r9+	movq	%r8,48(%rdi)+	movq	%r9,56(%rdi)+	sarq	$63,%r9+	movq	%r9,64(%rdi)+	movq	%r9,72(%rdi)+	movq	%r9,80(%rdi)+	movq	%r9,88(%rdi)+	leaq	96(%rsi),%rsi++	movq	%r10,%rax+	imulq	%rbx+	movq	%rax,%r8+	movq	%r11,%rax+	movq	%rdx,%r9+	imulq	%rcx+	addq	%rax,%r8+	adcq	%rdx,%r9+	movq	%r8,96(%rdi)+	movq	%r9,104(%rdi)+	sarq	$63,%r9+	movq	%r9,112(%rdi)+	movq	%r9,120(%rdi)+	movq	%r9,128(%rdi)+	movq	%r9,136(%rdi)+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383x63+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383x63+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383x63+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383x63+	sarq	$63,%r13+	movq	%r13,48(%rdi)+	movq	%r13,56(%rdi)+	movq	%r13,64(%rdi)+	movq	%r13,72(%rdi)+	movq	%r13,80(%rdi)+	movq	%r13,88(%rdi)+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_767x63+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_767x63+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_767x63+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_767x63+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_767x63++	xorq	$256+96,%rsi+	movl	$62,%edi++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	48(%rsi),%r10+	movq	56(%rsi),%r11+	call	__inner_loop_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	movq	%r8,0(%rdi)+	movq	%r10,48(%rdi)++++	leaq	96(%rsi),%rsi+	leaq	96(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_767x63+++	xorq	$256+96,%rsi+	movl	$22,%edi++	movq	0(%rsi),%r8+	xorq	%r9,%r9+	movq	48(%rsi),%r10+	xorq	%r11,%r11+	call	__inner_loop_62++++++++	leaq	96(%rsi),%rsi++++++	movq	%r12,%rdx+	movq	%r13,%rcx+	movq	32(%rsp),%rdi+	call	__smulq_767x63++	movq	40(%rsp),%rsi+	movq	%rax,%rdx+	sarq	$63,%rax++	movq	%rax,%r8+	movq	%rax,%r9+	movq	%rax,%r10+	andq	0(%rsi),%r8+	andq	8(%rsi),%r9+	movq	%rax,%r11+	andq	16(%rsi),%r10+	andq	24(%rsi),%r11+	movq	%rax,%r12+	andq	32(%rsi),%r12+	andq	40(%rsi),%rax++	addq	%r8,%r14+	adcq	%r9,%r15+	adcq	%r10,%rbx+	adcq	%r11,%rbp+	adcq	%r12,%rcx+	adcq	%rax,%rdx++	movq	%r14,48(%rdi)+	movq	%r15,56(%rdi)+	movq	%rbx,64(%rdi)+	movq	%rbp,72(%rdi)+	movq	%rcx,80(%rdi)+	movq	%rdx,88(%rdi)++	leaq	1112(%rsp),%r8+	movq	0(%r8),%r15++	movq	8(%r8),%r14++	movq	16(%r8),%r13++	movq	24(%r8),%r12++	movq	32(%r8),%rbx++	movq	40(%r8),%rbp++	leaq	48(%r8),%rsp++.LSEH_epilogue_ct_inverse_mod_383:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_ct_inverse_mod_383:+.def	__smulq_767x63;	.scl 3;	.type 32;	.endef+.p2align	5+__smulq_767x63:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rdx,%rbp+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	leaq	48(%rsi),%rsi++	xorq	%rdx,%rbp+	addq	%rax,%rbp++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	mulq	%rbp+	movq	%rax,0(%rdi)+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbp+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	movq	%r9,8(%rdi)+	mulq	%rbp+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	movq	%r10,16(%rdi)+	mulq	%rbp+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	movq	%r11,24(%rdi)+	mulq	%rbp+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	movq	%r12,32(%rdi)+	imulq	%rbp+	addq	%rax,%r13+	adcq	$0,%rdx++	movq	%r13,40(%rdi)+	movq	%rdx,48(%rdi)+	sarq	$63,%rdx+	movq	%rdx,56(%rdi)+	movq	%rcx,%rdx++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	48(%rsi),%r14+	movq	56(%rsi),%r15+	movq	64(%rsi),%rbx+	movq	72(%rsi),%rbp+	movq	80(%rsi),%rcx+	movq	88(%rsi),%rdi++	movq	%rdx,%rsi+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rsi+	addq	%rax,%rsi++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	xorq	%rdx,%r14+	xorq	%rdx,%r15+	xorq	%rdx,%rbx+	xorq	%rdx,%rbp+	xorq	%rdx,%rcx+	xorq	%rdx,%rdi+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13+	adcq	$0,%r14+	adcq	$0,%r15+	adcq	$0,%rbx+	adcq	$0,%rbp+	adcq	$0,%rcx+	adcq	$0,%rdi++	mulq	%rsi+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rsi+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rsi+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rsi+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	mulq	%rsi+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	mulq	%rsi+	addq	%rax,%r13+	movq	%r14,%rax+	adcq	$0,%rdx+	movq	%rdx,%r14+	mulq	%rsi+	addq	%rax,%r14+	movq	%r15,%rax+	adcq	$0,%rdx+	movq	%rdx,%r15+	mulq	%rsi+	addq	%rax,%r15+	movq	%rbx,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbx+	mulq	%rsi+	addq	%rax,%rbx+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp+	mulq	%rsi+	addq	%rax,%rbp+	movq	%rcx,%rax+	adcq	$0,%rdx+	movq	%rdx,%rcx+	mulq	%rsi+	addq	%rax,%rcx+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%rdi+	movq	8(%rsp),%rdx+	imulq	%rsi,%rax+	movq	16(%rsp),%rsi+	addq	%rdi,%rax++	addq	0(%rdx),%r8+	adcq	8(%rdx),%r9+	adcq	16(%rdx),%r10+	adcq	24(%rdx),%r11+	adcq	32(%rdx),%r12+	adcq	40(%rdx),%r13+	adcq	48(%rdx),%r14+	movq	56(%rdx),%rdi+	adcq	%rdi,%r15+	adcq	%rdi,%rbx+	adcq	%rdi,%rbp+	adcq	%rdi,%rcx+	adcq	%rdi,%rax++	movq	%rdx,%rdi++	movq	%r8,0(%rdx)+	movq	%r9,8(%rdx)+	movq	%r10,16(%rdx)+	movq	%r11,24(%rdx)+	movq	%r12,32(%rdx)+	movq	%r13,40(%rdx)+	movq	%r14,48(%rdx)+	movq	%r15,56(%rdx)+	movq	%rbx,64(%rdx)+	movq	%rbp,72(%rdx)+	movq	%rcx,80(%rdx)+	movq	%rax,88(%rdx)++	.byte	0xf3,0xc3++.def	__smulq_383x63;	.scl 3;	.type 32;	.endef+.p2align	5+__smulq_383x63:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rdx,%rbp+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbp+	addq	%rax,%rbp++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	mulq	%rbp+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbp+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rbp+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rbp+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	mulq	%rbp+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	imulq	%rbp,%rax+	addq	%rax,%r13++	leaq	48(%rsi),%rsi+	movq	%rcx,%rdx++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)+	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rdx,%rbp+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbp+	addq	%rax,%rbp++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	mulq	%rbp+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbp+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rbp+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rbp+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	mulq	%rbp+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	imulq	%rbp,%rax+	addq	%rax,%r13++	leaq	-48(%rsi),%rsi++	addq	0(%rdi),%r8+	adcq	8(%rdi),%r9+	adcq	16(%rdi),%r10+	adcq	24(%rdi),%r11+	adcq	32(%rdi),%r12+	adcq	40(%rdi),%r13++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3++.def	__smulq_383_n_shift_by_62;	.scl 3;	.type 32;	.endef+.p2align	5+__smulq_383_n_shift_by_62:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	%rdx,%rbx+	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rdx,%rbp+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbp+	addq	%rax,%rbp++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	mulq	%rbp+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbp+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rbp+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rbp+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	mulq	%rbp+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	imulq	%rbp+	addq	%rax,%r13+	adcq	$0,%rdx++	leaq	48(%rsi),%rsi+	movq	%rdx,%r14+	movq	%rcx,%rdx++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)+	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rdx,%rbp+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbp+	addq	%rax,%rbp++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	mulq	%rbp+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbp+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rbp+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rbp+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	mulq	%rbp+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	imulq	%rbp+	addq	%rax,%r13+	adcq	$0,%rdx++	leaq	-48(%rsi),%rsi++	addq	0(%rdi),%r8+	adcq	8(%rdi),%r9+	adcq	16(%rdi),%r10+	adcq	24(%rdi),%r11+	adcq	32(%rdi),%r12+	adcq	40(%rdi),%r13+	adcq	%rdx,%r14+	movq	%rbx,%rdx++	shrdq	$62,%r9,%r8+	shrdq	$62,%r10,%r9+	shrdq	$62,%r11,%r10+	shrdq	$62,%r12,%r11+	shrdq	$62,%r13,%r12+	shrdq	$62,%r14,%r13++	sarq	$63,%r14+	xorq	%rbp,%rbp+	subq	%r14,%rbp++	xorq	%r14,%r8+	xorq	%r14,%r9+	xorq	%r14,%r10+	xorq	%r14,%r11+	xorq	%r14,%r12+	xorq	%r14,%r13+	addq	%rbp,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	xorq	%r14,%rdx+	xorq	%r14,%rcx+	addq	%rbp,%rdx+	addq	%rbp,%rcx++	.byte	0xf3,0xc3++.def	__ab_approximation_62;	.scl 3;	.type 32;	.endef+.p2align	5+__ab_approximation_62:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	40(%rsi),%r9+	movq	88(%rsi),%r11+	movq	32(%rsi),%rbx+	movq	80(%rsi),%rbp+	movq	24(%rsi),%r8+	movq	72(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	cmovzq	%r10,%rbp+	movq	16(%rsi),%r8+	movq	64(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	cmovzq	%r10,%rbp+	movq	8(%rsi),%r8+	movq	56(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	cmovzq	%r10,%rbp+	movq	0(%rsi),%r8+	movq	48(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	bsrq	%rax,%rcx+	leaq	1(%rcx),%rcx+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%rax,%rcx+	negq	%rcx+++	shldq	%cl,%rbx,%r9+	shldq	%cl,%rbp,%r11++	jmp	__inner_loop_62++	.byte	0xf3,0xc3++.def	__inner_loop_62;	.scl 3;	.type 32;	.endef+.p2align	3+.long	0+__inner_loop_62:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	$1,%rdx+	xorq	%rcx,%rcx+	xorq	%r12,%r12+	movq	$1,%r13+	movq	%rsi,8(%rsp)++.Loop_62:+	xorq	%rax,%rax+	xorq	%rbx,%rbx+	testq	$1,%r8+	movq	%r10,%rbp+	movq	%r11,%r14+	cmovnzq	%r10,%rax+	cmovnzq	%r11,%rbx+	subq	%r8,%rbp+	sbbq	%r9,%r14+	movq	%r8,%r15+	movq	%r9,%rsi+	subq	%rax,%r8+	sbbq	%rbx,%r9+	cmovcq	%rbp,%r8+	cmovcq	%r14,%r9+	cmovcq	%r15,%r10+	cmovcq	%rsi,%r11+	movq	%rdx,%rax+	cmovcq	%r12,%rdx+	cmovcq	%rax,%r12+	movq	%rcx,%rbx+	cmovcq	%r13,%rcx+	cmovcq	%rbx,%r13+	xorq	%rax,%rax+	xorq	%rbx,%rbx+	shrdq	$1,%r9,%r8+	shrq	$1,%r9+	testq	$1,%r15+	cmovnzq	%r12,%rax+	cmovnzq	%r13,%rbx+	addq	%r12,%r12+	addq	%r13,%r13+	subq	%rax,%rdx+	subq	%rbx,%rcx+	subl	$1,%edi+	jnz	.Loop_62++	movq	8(%rsp),%rsi+	.byte	0xf3,0xc3++.section	.pdata+.p2align	2+.rva	.LSEH_begin_ct_inverse_mod_383+.rva	.LSEH_body_ct_inverse_mod_383+.rva	.LSEH_info_ct_inverse_mod_383_prologue++.rva	.LSEH_body_ct_inverse_mod_383+.rva	.LSEH_epilogue_ct_inverse_mod_383+.rva	.LSEH_info_ct_inverse_mod_383_body++.rva	.LSEH_epilogue_ct_inverse_mod_383+.rva	.LSEH_end_ct_inverse_mod_383+.rva	.LSEH_info_ct_inverse_mod_383_epilogue++.section	.xdata+.p2align	3+.LSEH_info_ct_inverse_mod_383_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_ct_inverse_mod_383_body:+.byte	1,0,18,0+.byte	0x00,0xf4,0x8b,0x00+.byte	0x00,0xe4,0x8c,0x00+.byte	0x00,0xd4,0x8d,0x00+.byte	0x00,0xc4,0x8e,0x00+.byte	0x00,0x34,0x8f,0x00+.byte	0x00,0x54,0x90,0x00+.byte	0x00,0x74,0x92,0x00+.byte	0x00,0x64,0x93,0x00+.byte	0x00,0x01,0x91,0x00+.LSEH_info_ct_inverse_mod_383_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00+
+ c-source/build/coff/ctx_inverse_mod_384-x86_64.s view
@@ -0,0 +1,1596 @@+.text	++.globl	ctx_inverse_mod_383+.def	ctx_inverse_mod_383;	.scl 2;	.type 32;	.endef+.p2align	5+ctx_inverse_mod_383:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_ctx_inverse_mod_383:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$1112,%rsp++.LSEH_body_ctx_inverse_mod_383:+++	leaq	88+511(%rsp),%rax+	andq	$-512,%rax+	movq	%rdi,32(%rsp)+	movq	%rcx,40(%rsp)++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	0(%rdx),%r14+	movq	8(%rdx),%r15+	movq	16(%rdx),%rbx+	movq	24(%rdx),%rbp+	movq	32(%rdx),%rsi+	movq	40(%rdx),%rdi++	movq	%r8,0(%rax)+	movq	%r9,8(%rax)+	movq	%r10,16(%rax)+	movq	%r11,24(%rax)+	movq	%r12,32(%rax)+	movq	%r13,40(%rax)++	movq	%r14,48(%rax)+	movq	%r15,56(%rax)+	movq	%rbx,64(%rax)+	movq	%rbp,72(%rax)+	movq	%rsi,80(%rax)+	movq	%rax,%rsi+	movq	%rdi,88(%rax)+++	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+++	movq	%rdx,96(%rdi)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+++	movq	%rdx,96(%rdi)+++	xorq	$256,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31++++	movq	96(%rsi),%rax+	movq	144(%rsi),%r11+	movq	%rdx,%rbx+	movq	%rax,%r10+	imulq	56(%rsp)+	movq	%rax,%r8+	movq	%r11,%rax+	movq	%rdx,%r9+	imulq	64(%rsp)+	addq	%rax,%r8+	adcq	%rdx,%r9+	movq	%r8,48(%rdi)+	movq	%r9,56(%rdi)+	sarq	$63,%r9+	movq	%r9,64(%rdi)+	movq	%r9,72(%rdi)+	movq	%r9,80(%rdi)+	movq	%r9,88(%rdi)+	leaq	96(%rsi),%rsi++	movq	%r10,%rax+	imulq	%rbx+	movq	%rax,%r8+	movq	%r11,%rax+	movq	%rdx,%r9+	imulq	%rcx+	addq	%rax,%r8+	adcq	%rdx,%r9+	movq	%r8,96(%rdi)+	movq	%r9,104(%rdi)+	sarq	$63,%r9+	movq	%r9,112(%rdi)+	movq	%r9,120(%rdi)+	movq	%r9,128(%rdi)+	movq	%r9,136(%rdi)+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	sarq	$63,%r13+	movq	%r13,48(%rdi)+	movq	%r13,56(%rdi)+	movq	%r13,64(%rdi)+	movq	%r13,72(%rdi)+	movq	%r13,80(%rdi)+	movq	%r13,88(%rdi)+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_191_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_191_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_191_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_191_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_191_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_191_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_191_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_191_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63++	xorq	$256+96,%rsi+	movl	$53,%edi++	movq	0(%rsi),%r8++	movq	48(%rsi),%r10++	call	__inner_loop_62++++++++	leaq	96(%rsi),%rsi++++++	movq	%r12,%rdx+	movq	%r13,%rcx+	movq	32(%rsp),%rdi+	call	__smulx_767x63++	movq	40(%rsp),%rsi+	movq	%rax,%rdx+	sarq	$63,%rax++	movq	%rax,%r8+	movq	%rax,%r9+	movq	%rax,%r10+	andq	0(%rsi),%r8+	andq	8(%rsi),%r9+	movq	%rax,%r11+	andq	16(%rsi),%r10+	andq	24(%rsi),%r11+	movq	%rax,%r12+	andq	32(%rsi),%r12+	andq	40(%rsi),%rax++	addq	%r8,%r14+	adcq	%r9,%r15+	adcq	%r10,%rbx+	adcq	%r11,%rbp+	adcq	%r12,%rcx+	adcq	%rax,%rdx++	movq	%r14,48(%rdi)+	movq	%r15,56(%rdi)+	movq	%rbx,64(%rdi)+	movq	%rbp,72(%rdi)+	movq	%rcx,80(%rdi)+	movq	%rdx,88(%rdi)++	leaq	1112(%rsp),%r8+	movq	0(%r8),%r15++	movq	8(%r8),%r14++	movq	16(%r8),%r13++	movq	24(%r8),%r12++	movq	32(%r8),%rbx++	movq	40(%r8),%rbp++	leaq	48(%r8),%rsp++.LSEH_epilogue_ctx_inverse_mod_383:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_ctx_inverse_mod_383:+.def	__smulx_767x63;	.scl 3;	.type 32;	.endef+.p2align	5+__smulx_767x63:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rdx,%rax+	sarq	$63,%rax+	xorq	%rbp,%rbp+	subq	%rax,%rbp++	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	leaq	48(%rsi),%rsi++	xorq	%rax,%rdx+	addq	%rbp,%rdx++	xorq	%rax,%r8+	xorq	%rax,%r9+	xorq	%rax,%r10+	xorq	%rax,%r11+	xorq	%rax,%r12+	xorq	%r13,%rax+	addq	%rbp,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%rax++	mulxq	%r8,%r8,%rbp+	mulxq	%r9,%r9,%r13+	addq	%rbp,%r9+	mulxq	%r10,%r10,%rbp+	adcq	%r13,%r10+	mulxq	%r11,%r11,%r13+	adcq	%rbp,%r11+	mulxq	%r12,%r12,%rbp+	adcq	%r13,%r12+	adcq	$0,%rbp+	imulq	%rdx+	addq	%rbp,%rax+	adcq	$0,%rdx++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%rax,40(%rdi)+	movq	%rdx,48(%rdi)+	sarq	$63,%rdx+	movq	%rdx,56(%rdi)+	movq	%rcx,%rdx+	movq	%rcx,%rax++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	48(%rsi),%r14+	movq	56(%rsi),%r15+	movq	64(%rsi),%rbx+	movq	72(%rsi),%rbp+	movq	80(%rsi),%rcx+	movq	88(%rsi),%rdi++	sarq	$63,%rax+	xorq	%rsi,%rsi+	subq	%rax,%rsi++	xorq	%rax,%rdx+	addq	%rsi,%rdx++	xorq	%rax,%r8+	xorq	%rax,%r9+	xorq	%rax,%r10+	xorq	%rax,%r11+	xorq	%rax,%r12+	xorq	%rax,%r13+	xorq	%rax,%r14+	xorq	%rax,%r15+	xorq	%rax,%rbx+	xorq	%rax,%rbp+	xorq	%rax,%rcx+	xorq	%rax,%rdi+	addq	%rsi,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13+	adcq	$0,%r14+	adcq	$0,%r15+	adcq	$0,%rbx+	adcq	$0,%rbp+	adcq	$0,%rcx+	adcq	$0,%rdi++	mulxq	%r8,%r8,%rax+	mulxq	%r9,%r9,%rsi+	addq	%rax,%r9+	mulxq	%r10,%r10,%rax+	adcq	%rsi,%r10+	mulxq	%r11,%r11,%rsi+	adcq	%rax,%r11+	mulxq	%r12,%r12,%rax+	adcq	%rsi,%r12+	mulxq	%r13,%r13,%rsi+	adcq	%rax,%r13+	mulxq	%r14,%r14,%rax+	adcq	%rsi,%r14+	mulxq	%r15,%r15,%rsi+	adcq	%rax,%r15+	mulxq	%rbx,%rbx,%rax+	adcq	%rsi,%rbx+	mulxq	%rbp,%rbp,%rsi+	adcq	%rax,%rbp+	mulxq	%rcx,%rcx,%rax+	adcq	%rsi,%rcx+	mulxq	%rdi,%rdi,%rsi+	movq	8(%rsp),%rdx+	movq	16(%rsp),%rsi+	adcq	%rdi,%rax++	addq	0(%rdx),%r8+	adcq	8(%rdx),%r9+	adcq	16(%rdx),%r10+	adcq	24(%rdx),%r11+	adcq	32(%rdx),%r12+	adcq	40(%rdx),%r13+	adcq	48(%rdx),%r14+	movq	56(%rdx),%rdi+	adcq	%rdi,%r15+	adcq	%rdi,%rbx+	adcq	%rdi,%rbp+	adcq	%rdi,%rcx+	adcq	%rdi,%rax++	movq	%rdx,%rdi++	movq	%r8,0(%rdx)+	movq	%r9,8(%rdx)+	movq	%r10,16(%rdx)+	movq	%r11,24(%rdx)+	movq	%r12,32(%rdx)+	movq	%r13,40(%rdx)+	movq	%r14,48(%rdx)+	movq	%r15,56(%rdx)+	movq	%rbx,64(%rdx)+	movq	%rbp,72(%rdx)+	movq	%rcx,80(%rdx)+	movq	%rax,88(%rdx)++	.byte	0xf3,0xc3++.def	__smulx_383x63;	.scl 3;	.type 32;	.endef+.p2align	5+__smulx_383x63:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0+0(%rsi),%r8+	movq	0+8(%rsi),%r9+	movq	0+16(%rsi),%r10+	movq	0+24(%rsi),%r11+	movq	0+32(%rsi),%r12+	movq	0+40(%rsi),%r13++	movq	%rdx,%rbp+	sarq	$63,%rbp+	xorq	%rax,%rax+	subq	%rbp,%rax++	xorq	%rbp,%rdx+	addq	%rax,%rdx++	xorq	%rbp,%r8+	xorq	%rbp,%r9+	xorq	%rbp,%r10+	xorq	%rbp,%r11+	xorq	%rbp,%r12+	xorq	%rbp,%r13+	addq	%rax,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	mulxq	%r8,%r8,%rbp+	mulxq	%r9,%r9,%rax+	addq	%rbp,%r9+	mulxq	%r10,%r10,%rbp+	adcq	%rax,%r10+	mulxq	%r11,%r11,%rax+	adcq	%rbp,%r11+	mulxq	%r12,%r12,%rbp+	adcq	%rax,%r12+	mulxq	%r13,%r13,%rax+	movq	%rcx,%rdx+	adcq	%rbp,%r13++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)+	movq	48+0(%rsi),%r8+	movq	48+8(%rsi),%r9+	movq	48+16(%rsi),%r10+	movq	48+24(%rsi),%r11+	movq	48+32(%rsi),%r12+	movq	48+40(%rsi),%r13++	movq	%rdx,%rbp+	sarq	$63,%rbp+	xorq	%rax,%rax+	subq	%rbp,%rax++	xorq	%rbp,%rdx+	addq	%rax,%rdx++	xorq	%rbp,%r8+	xorq	%rbp,%r9+	xorq	%rbp,%r10+	xorq	%rbp,%r11+	xorq	%rbp,%r12+	xorq	%rbp,%r13+	addq	%rax,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	mulxq	%r8,%r8,%rbp+	mulxq	%r9,%r9,%rax+	addq	%rbp,%r9+	mulxq	%r10,%r10,%rbp+	adcq	%rax,%r10+	mulxq	%r11,%r11,%rax+	adcq	%rbp,%r11+	mulxq	%r12,%r12,%rbp+	adcq	%rax,%r12+	mulxq	%r13,%r13,%rax+	adcq	%rbp,%r13++	addq	0(%rdi),%r8+	adcq	8(%rdi),%r9+	adcq	16(%rdi),%r10+	adcq	24(%rdi),%r11+	adcq	32(%rdi),%r12+	adcq	40(%rdi),%r13++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3++.def	__smulx_383_n_shift_by_31;	.scl 3;	.type 32;	.endef+.p2align	5+__smulx_383_n_shift_by_31:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	%rdx,%rbx+	xorq	%r14,%r14+	movq	0+0(%rsi),%r8+	movq	0+8(%rsi),%r9+	movq	0+16(%rsi),%r10+	movq	0+24(%rsi),%r11+	movq	0+32(%rsi),%r12+	movq	0+40(%rsi),%r13++	movq	%rdx,%rax+	sarq	$63,%rax+	xorq	%rbp,%rbp+	subq	%rax,%rbp++	xorq	%rax,%rdx+	addq	%rbp,%rdx++	xorq	%rax,%r8+	xorq	%rax,%r9+	xorq	%rax,%r10+	xorq	%rax,%r11+	xorq	%rax,%r12+	xorq	%r13,%rax+	addq	%rbp,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%rax++	mulxq	%r8,%r8,%rbp+	mulxq	%r9,%r9,%r13+	addq	%rbp,%r9+	mulxq	%r10,%r10,%rbp+	adcq	%r13,%r10+	mulxq	%r11,%r11,%r13+	adcq	%rbp,%r11+	mulxq	%r12,%r12,%rbp+	adcq	%r13,%r12+	adcq	$0,%rbp+	imulq	%rdx+	addq	%rbp,%rax+	adcq	%rdx,%r14++	movq	%rcx,%rdx++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%rax,40(%rdi)+	movq	48+0(%rsi),%r8+	movq	48+8(%rsi),%r9+	movq	48+16(%rsi),%r10+	movq	48+24(%rsi),%r11+	movq	48+32(%rsi),%r12+	movq	48+40(%rsi),%r13++	movq	%rdx,%rax+	sarq	$63,%rax+	xorq	%rbp,%rbp+	subq	%rax,%rbp++	xorq	%rax,%rdx+	addq	%rbp,%rdx++	xorq	%rax,%r8+	xorq	%rax,%r9+	xorq	%rax,%r10+	xorq	%rax,%r11+	xorq	%rax,%r12+	xorq	%r13,%rax+	addq	%rbp,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%rax++	mulxq	%r8,%r8,%rbp+	mulxq	%r9,%r9,%r13+	addq	%rbp,%r9+	mulxq	%r10,%r10,%rbp+	adcq	%r13,%r10+	mulxq	%r11,%r11,%r13+	adcq	%rbp,%r11+	mulxq	%r12,%r12,%rbp+	adcq	%r13,%r12+	adcq	$0,%rbp+	imulq	%rdx+	addq	%rbp,%rax+	adcq	$0,%rdx++	addq	0(%rdi),%r8+	adcq	8(%rdi),%r9+	adcq	16(%rdi),%r10+	adcq	24(%rdi),%r11+	adcq	32(%rdi),%r12+	adcq	40(%rdi),%rax+	adcq	%rdx,%r14+	movq	%rbx,%rdx++	shrdq	$31,%r9,%r8+	shrdq	$31,%r10,%r9+	shrdq	$31,%r11,%r10+	shrdq	$31,%r12,%r11+	shrdq	$31,%rax,%r12+	shrdq	$31,%r14,%rax++	sarq	$63,%r14+	xorq	%rbp,%rbp+	subq	%r14,%rbp++	xorq	%r14,%r8+	xorq	%r14,%r9+	xorq	%r14,%r10+	xorq	%r14,%r11+	xorq	%r14,%r12+	xorq	%r14,%rax+	addq	%rbp,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%rax++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%rax,40(%rdi)++	xorq	%r14,%rdx+	xorq	%r14,%rcx+	addq	%rbp,%rdx+	addq	%rbp,%rcx++	.byte	0xf3,0xc3++.def	__smulx_191_n_shift_by_31;	.scl 3;	.type 32;	.endef+.p2align	5+__smulx_191_n_shift_by_31:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	%rdx,%rbx+	movq	0+0(%rsi),%r8+	movq	0+8(%rsi),%r9+	movq	0+16(%rsi),%r10++	movq	%rdx,%rax+	sarq	$63,%rax+	xorq	%rbp,%rbp+	subq	%rax,%rbp++	xorq	%rax,%rdx+	addq	%rbp,%rdx++	xorq	%rax,%r8+	xorq	%rax,%r9+	xorq	%r10,%rax+	addq	%rbp,%r8+	adcq	$0,%r9+	adcq	$0,%rax++	mulxq	%r8,%r8,%rbp+	mulxq	%r9,%r9,%r10+	addq	%rbp,%r9+	adcq	$0,%r10+	imulq	%rdx+	addq	%rax,%r10+	adcq	$0,%rdx+	movq	%rdx,%r14+	movq	%rcx,%rdx+	movq	48+0(%rsi),%r11+	movq	48+8(%rsi),%r12+	movq	48+16(%rsi),%r13++	movq	%rdx,%rax+	sarq	$63,%rax+	xorq	%rbp,%rbp+	subq	%rax,%rbp++	xorq	%rax,%rdx+	addq	%rbp,%rdx++	xorq	%rax,%r11+	xorq	%rax,%r12+	xorq	%r13,%rax+	addq	%rbp,%r11+	adcq	$0,%r12+	adcq	$0,%rax++	mulxq	%r11,%r11,%rbp+	mulxq	%r12,%r12,%r13+	addq	%rbp,%r12+	adcq	$0,%r13+	imulq	%rdx+	addq	%rax,%r13+	adcq	$0,%rdx+	addq	%r8,%r11+	adcq	%r9,%r12+	adcq	%r10,%r13+	adcq	%rdx,%r14+	movq	%rbx,%rdx++	shrdq	$31,%r12,%r11+	shrdq	$31,%r13,%r12+	shrdq	$31,%r14,%r13++	sarq	$63,%r14+	xorq	%rbp,%rbp+	subq	%r14,%rbp++	xorq	%r14,%r11+	xorq	%r14,%r12+	xorq	%r14,%r13+	addq	%rbp,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	movq	%r11,0(%rdi)+	movq	%r12,8(%rdi)+	movq	%r13,16(%rdi)++	xorq	%r14,%rdx+	xorq	%r14,%rcx+	addq	%rbp,%rdx+	addq	%rbp,%rcx++	.byte	0xf3,0xc3++.def	__ab_approximation_31;	.scl 3;	.type 32;	.endef+.p2align	5+__ab_approximation_31:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	40(%rsi),%r9+	movq	88(%rsi),%r11+	movq	32(%rsi),%rbx+	movq	80(%rsi),%rbp+	movq	24(%rsi),%r8+	movq	72(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	movq	16(%rsi),%r8+	cmovzq	%r10,%rbp+	movq	64(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	movq	8(%rsi),%r8+	cmovzq	%r10,%rbp+	movq	56(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	movq	0(%rsi),%r8+	cmovzq	%r10,%rbp+	movq	48(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	cmovzq	%r10,%rbp++	movq	%r9,%rax+	orq	%r11,%rax+	bsrq	%rax,%rcx+	leaq	1(%rcx),%rcx+	cmovzq	%r8,%r9+	cmovzq	%r10,%r11+	cmovzq	%rax,%rcx+	negq	%rcx+++	shldq	%cl,%rbx,%r9+	shldq	%cl,%rbp,%r11++	movl	$0x7FFFFFFF,%eax+	andq	%rax,%r8+	andq	%rax,%r10+	andnq	%r9,%rax,%r9+	andnq	%r11,%rax,%r11+	orq	%r9,%r8+	orq	%r11,%r10++	jmp	__inner_loop_31++	.byte	0xf3,0xc3++.def	__inner_loop_31;	.scl 3;	.type 32;	.endef+.p2align	5+__inner_loop_31:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	$0x7FFFFFFF80000000,%rcx+	movq	$0x800000007FFFFFFF,%r13+	movq	$0x7FFFFFFF7FFFFFFF,%r15++.Loop_31:+	cmpq	%r10,%r8+	movq	%r8,%rax+	movq	%r10,%rbx+	movq	%rcx,%rbp+	movq	%r13,%r14+	cmovbq	%r10,%r8+	cmovbq	%rax,%r10+	cmovbq	%r13,%rcx+	cmovbq	%rbp,%r13++	subq	%r10,%r8+	subq	%r13,%rcx+	addq	%r15,%rcx++	testq	$1,%rax+	cmovzq	%rax,%r8+	cmovzq	%rbx,%r10+	cmovzq	%rbp,%rcx+	cmovzq	%r14,%r13++	shrq	$1,%r8+	addq	%r13,%r13+	subq	%r15,%r13+	subl	$1,%edi+	jnz	.Loop_31++	shrq	$32,%r15+	movl	%ecx,%edx+	movl	%r13d,%r12d+	shrq	$32,%rcx+	shrq	$32,%r13+	subq	%r15,%rdx+	subq	%r15,%rcx+	subq	%r15,%r12+	subq	%r15,%r13++	.byte	0xf3,0xc3+++.def	__inner_loop_62;	.scl 3;	.type 32;	.endef+.p2align	5+__inner_loop_62:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	$1,%rdx+	xorq	%rcx,%rcx+	xorq	%r12,%r12+	movq	$1,%r13++.Loop_62:+	xorq	%rax,%rax+	testq	$1,%r8+	movq	%r10,%rbx+	cmovnzq	%r10,%rax+	subq	%r8,%rbx+	movq	%r8,%rbp+	subq	%rax,%r8+	cmovcq	%rbx,%r8+	cmovcq	%rbp,%r10+	movq	%rdx,%rax+	cmovcq	%r12,%rdx+	cmovcq	%rax,%r12+	movq	%rcx,%rbx+	cmovcq	%r13,%rcx+	cmovcq	%rbx,%r13+	xorq	%rax,%rax+	xorq	%rbx,%rbx+	shrq	$1,%r8+	testq	$1,%rbp+	cmovnzq	%r12,%rax+	cmovnzq	%r13,%rbx+	addq	%r12,%r12+	addq	%r13,%r13+	subq	%rax,%rdx+	subq	%rbx,%rcx+	subl	$1,%edi+	jnz	.Loop_62++	.byte	0xf3,0xc3++.section	.pdata+.p2align	2+.rva	.LSEH_begin_ctx_inverse_mod_383+.rva	.LSEH_body_ctx_inverse_mod_383+.rva	.LSEH_info_ctx_inverse_mod_383_prologue++.rva	.LSEH_body_ctx_inverse_mod_383+.rva	.LSEH_epilogue_ctx_inverse_mod_383+.rva	.LSEH_info_ctx_inverse_mod_383_body++.rva	.LSEH_epilogue_ctx_inverse_mod_383+.rva	.LSEH_end_ctx_inverse_mod_383+.rva	.LSEH_info_ctx_inverse_mod_383_epilogue++.section	.xdata+.p2align	3+.LSEH_info_ctx_inverse_mod_383_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_ctx_inverse_mod_383_body:+.byte	1,0,18,0+.byte	0x00,0xf4,0x8b,0x00+.byte	0x00,0xe4,0x8c,0x00+.byte	0x00,0xd4,0x8d,0x00+.byte	0x00,0xc4,0x8e,0x00+.byte	0x00,0x34,0x8f,0x00+.byte	0x00,0x54,0x90,0x00+.byte	0x00,0x74,0x92,0x00+.byte	0x00,0x64,0x93,0x00+.byte	0x00,0x01,0x91,0x00+.LSEH_info_ctx_inverse_mod_383_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00+
+ c-source/build/coff/div3w-armv8.S view
@@ -0,0 +1,94 @@+.text++.globl	div_3_limbs+.def	div_3_limbs;+.type	32;+.endef+.p2align	5+div_3_limbs:+	ldp	x4,x5,[x0]	// load R+	eor	x0,x0,x0	// Q = 0+	mov	x3,#64		// loop counter+	nop++.Loop:+	subs	x6,x4,x1	// R - D+	add	x0,x0,x0	// Q <<= 1+	sbcs	x7,x5,x2+	add	x0,x0,#1	// Q + speculative bit+	csel	x4,x4,x6,lo	// select between R and R - D+	extr	x1,x2,x1,#1	// D >>= 1+	csel	x5,x5,x7,lo+	lsr	x2,x2,#1+	sbc	x0,x0,xzr	// subtract speculative bit+	sub	x3,x3,#1+	cbnz	x3,.Loop++	asr	x3,x0,#63	// top bit -> mask+	add	x0,x0,x0	// Q <<= 1+	subs	x6,x4,x1	// R - D+	add	x0,x0,#1	// Q + specilative bit+	sbcs	x7,x5,x2+	sbc	x0,x0,xzr	// subtract speculative bit++	orr	x0,x0,x3	// all ones if overflow++	ret++.globl	quot_rem_128+.def	quot_rem_128;+.type	32;+.endef+.p2align	5+quot_rem_128:+	ldp	x3,x4,[x1]++	mul	x5,x3,x2	// divisor[0:1} * quotient+	umulh	x6,x3,x2+	mul	x11,  x4,x2+	umulh	x7,x4,x2++	ldp	x8,x9,[x0]	// load 3 limbs of the dividend+	ldr	x10,[x0,#16]++	adds	x6,x6,x11+	adc	x7,x7,xzr++	subs	x8,x8,x5	// dividend - divisor * quotient+	sbcs	x9,x9,x6+	sbcs	x10,x10,x7+	sbc	x5,xzr,xzr		// borrow -> mask++	add	x2,x2,x5	// if borrowed, adjust the quotient ...+	and	x3,x3,x5+	and	x4,x4,x5+	adds	x8,x8,x3	// ... and add divisor+	adc	x9,x9,x4++	stp	x8,x9,[x0]	// save 2 limbs of the remainder+	str	x2,[x0,#16]	// and one limb of the quotient++	mov	x0,x2		// return adjusted quotient++	ret+++.globl	quot_rem_64+.def	quot_rem_64;+.type	32;+.endef+.p2align	5+quot_rem_64:+	ldr	x3,[x1]+	ldr	x8,[x0]	// load 1 limb of the dividend++	mul	x5,x3,x2	// divisor * quotient++	sub	x8,x8,x5	// dividend - divisor * quotient++	stp	x8,x2,[x0]	// save remainder and quotient++	mov	x0,x2		// return quotient++	ret+
+ c-source/build/coff/div3w-x86_64.s view
@@ -0,0 +1,140 @@+.text	++.globl	div_3_limbs++.def	div_3_limbs;	.scl 2;	.type 32;	.endef+.p2align	5+div_3_limbs:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%rax+.LSEH_begin_div_3_limbs:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx++	movq	(%rdi),%r8+	movq	8(%rdi),%r9+	xorq	%rax,%rax+	movl	$64,%ecx++.Loop:+	movq	%r8,%r10+	subq	%rsi,%r8+	movq	%r9,%r11+	sbbq	%rdx,%r9+	leaq	1(%rax,%rax,1),%rax+	movq	%rdx,%rdi+	cmovcq	%r10,%r8+	cmovcq	%r11,%r9+	sbbq	$0,%rax+	shlq	$63,%rdi+	shrq	$1,%rsi+	shrq	$1,%rdx+	orq	%rdi,%rsi+	subl	$1,%ecx+	jnz	.Loop++	leaq	1(%rax,%rax,1),%rcx+	sarq	$63,%rax++	subq	%rsi,%r8+	sbbq	%rdx,%r9+	sbbq	$0,%rcx++	orq	%rcx,%rax++	movq	8(%rsp),%rdi+	movq	16(%rsp),%rsi+	.byte	0xf3,0xc3+.LSEH_end_div_3_limbs:+.globl	quot_rem_128++.def	quot_rem_128;	.scl 2;	.type 32;	.endef+.p2align	5+quot_rem_128:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%rax+.LSEH_begin_quot_rem_128:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx++	movq	%rdx,%rax+	movq	%rdx,%rcx++	mulq	0(%rsi)+	movq	%rax,%r8+	movq	%rcx,%rax+	movq	%rdx,%r9++	mulq	8(%rsi)+	addq	%rax,%r9+	adcq	$0,%rdx++	movq	0(%rdi),%r10+	movq	8(%rdi),%r11+	movq	16(%rdi),%rax++	subq	%r8,%r10+	sbbq	%r9,%r11+	sbbq	%rdx,%rax+	sbbq	%r8,%r8++	addq	%r8,%rcx+	movq	%r8,%r9+	andq	0(%rsi),%r8+	andq	8(%rsi),%r9+	addq	%r8,%r10+	adcq	%r9,%r11++	movq	%r10,0(%rdi)+	movq	%r11,8(%rdi)+	movq	%rcx,16(%rdi)++	movq	%rcx,%rax++	movq	8(%rsp),%rdi+	movq	16(%rsp),%rsi+	.byte	0xf3,0xc3+.LSEH_end_quot_rem_128:++++++.globl	quot_rem_64++.def	quot_rem_64;	.scl 2;	.type 32;	.endef+.p2align	5+quot_rem_64:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%rax+.LSEH_begin_quot_rem_64:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx++	movq	%rdx,%rax+	imulq	0(%rsi),%rdx++	movq	0(%rdi),%r10++	subq	%rdx,%r10++	movq	%r10,0(%rdi)+	movq	%rax,8(%rdi)++	movq	8(%rsp),%rdi+	movq	16(%rsp),%rsi+	.byte	0xf3,0xc3+.LSEH_end_quot_rem_64:+.section	.pdata+.p2align	2+.section	.xdata+.p2align	3
+ c-source/build/coff/mul_mont_256-armv8.S view
@@ -0,0 +1,474 @@+.text++.globl	mul_mont_sparse_256++.def	mul_mont_sparse_256;+.type	32;+.endef+.p2align	5+mul_mont_sparse_256:+	stp	x29,x30,[sp,#-64]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]++	ldp	x10,x11,[x1]+	ldr	x9,        [x2]+	ldp	x12,x13,[x1,#16]++	mul	x19,x10,x9+	ldp	x5,x6,[x3]+	mul	x20,x11,x9+	ldp	x7,x8,[x3,#16]+	mul	x21,x12,x9+	mul	x22,x13,x9++	umulh	x14,x10,x9+	umulh	x15,x11,x9+	mul	x3,x4,x19+	umulh	x16,x12,x9+	umulh	x17,x13,x9+	adds	x20,x20,x14+	//mul	x14,x5,x3+	adcs	x21,x21,x15+	mul	x15,x6,x3+	adcs	x22,x22,x16+	mul	x16,x7,x3+	adc	x23,xzr,    x17+	mul	x17,x8,x3+	ldr	x9,[x2,8*1]+	subs	xzr,x19,#1		//adds	x19,x19,x14+	umulh	x14,x5,x3+	adcs	x20,x20,x15+	umulh	x15,x6,x3+	adcs	x21,x21,x16+	umulh	x16,x7,x3+	adcs	x22,x22,x17+	umulh	x17,x8,x3+	adc	x23,x23,xzr++	adds	x19,x20,x14+	mul	x14,x10,x9+	adcs	x20,x21,x15+	mul	x15,x11,x9+	adcs	x21,x22,x16+	mul	x16,x12,x9+	adcs	x22,x23,x17+	mul	x17,x13,x9+	adc	x23,xzr,xzr++	adds	x19,x19,x14+	umulh	x14,x10,x9+	adcs	x20,x20,x15+	umulh	x15,x11,x9+	adcs	x21,x21,x16+	mul	x3,x4,x19+	umulh	x16,x12,x9+	adcs	x22,x22,x17+	umulh	x17,x13,x9+	adc	x23,x23,xzr++	adds	x20,x20,x14+	//mul	x14,x5,x3+	adcs	x21,x21,x15+	mul	x15,x6,x3+	adcs	x22,x22,x16+	mul	x16,x7,x3+	adc	x23,x23,x17+	mul	x17,x8,x3+	ldr	x9,[x2,8*2]+	subs	xzr,x19,#1		//adds	x19,x19,x14+	umulh	x14,x5,x3+	adcs	x20,x20,x15+	umulh	x15,x6,x3+	adcs	x21,x21,x16+	umulh	x16,x7,x3+	adcs	x22,x22,x17+	umulh	x17,x8,x3+	adc	x23,x23,xzr++	adds	x19,x20,x14+	mul	x14,x10,x9+	adcs	x20,x21,x15+	mul	x15,x11,x9+	adcs	x21,x22,x16+	mul	x16,x12,x9+	adcs	x22,x23,x17+	mul	x17,x13,x9+	adc	x23,xzr,xzr++	adds	x19,x19,x14+	umulh	x14,x10,x9+	adcs	x20,x20,x15+	umulh	x15,x11,x9+	adcs	x21,x21,x16+	mul	x3,x4,x19+	umulh	x16,x12,x9+	adcs	x22,x22,x17+	umulh	x17,x13,x9+	adc	x23,x23,xzr++	adds	x20,x20,x14+	//mul	x14,x5,x3+	adcs	x21,x21,x15+	mul	x15,x6,x3+	adcs	x22,x22,x16+	mul	x16,x7,x3+	adc	x23,x23,x17+	mul	x17,x8,x3+	ldr	x9,[x2,8*3]+	subs	xzr,x19,#1		//adds	x19,x19,x14+	umulh	x14,x5,x3+	adcs	x20,x20,x15+	umulh	x15,x6,x3+	adcs	x21,x21,x16+	umulh	x16,x7,x3+	adcs	x22,x22,x17+	umulh	x17,x8,x3+	adc	x23,x23,xzr++	adds	x19,x20,x14+	mul	x14,x10,x9+	adcs	x20,x21,x15+	mul	x15,x11,x9+	adcs	x21,x22,x16+	mul	x16,x12,x9+	adcs	x22,x23,x17+	mul	x17,x13,x9+	adc	x23,xzr,xzr++	adds	x19,x19,x14+	umulh	x14,x10,x9+	adcs	x20,x20,x15+	umulh	x15,x11,x9+	adcs	x21,x21,x16+	mul	x3,x4,x19+	umulh	x16,x12,x9+	adcs	x22,x22,x17+	umulh	x17,x13,x9+	adc	x23,x23,xzr++	adds	x20,x20,x14+	//mul	x14,x5,x3+	adcs	x21,x21,x15+	mul	x15,x6,x3+	adcs	x22,x22,x16+	mul	x16,x7,x3+	adc	x23,x23,x17+	mul	x17,x8,x3+	subs	xzr,x19,#1		//adds	x19,x19,x14+	umulh	x14,x5,x3+	adcs	x20,x20,x15+	umulh	x15,x6,x3+	adcs	x21,x21,x16+	umulh	x16,x7,x3+	adcs	x22,x22,x17+	umulh	x17,x8,x3+	adc	x23,x23,xzr++	adds	x19,x20,x14+	adcs	x20,x21,x15+	adcs	x21,x22,x16+	adcs	x22,x23,x17+	adc	x23,xzr,xzr++	subs	x14,x19,x5+	sbcs	x15,x20,x6+	sbcs	x16,x21,x7+	sbcs	x17,x22,x8+	sbcs	xzr,    x23,xzr++	csel	x19,x19,x14,lo+	csel	x20,x20,x15,lo+	csel	x21,x21,x16,lo+	csel	x22,x22,x17,lo++	stp	x19,x20,[x0]+	stp	x21,x22,[x0,#16]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldr	x29,[sp],#64+	ret++.globl	sqr_mont_sparse_256++.def	sqr_mont_sparse_256;+.type	32;+.endef+.p2align	5+sqr_mont_sparse_256:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x5,x6,[x1]+	ldp	x7,x8,[x1,#16]+	mov	x4,x3++	////////////////////////////////////////////////////////////////+	//  |  |  |  |  |  |a1*a0|  |+	//  |  |  |  |  |a2*a0|  |  |+	//  |  |a3*a2|a3*a0|  |  |  |+	//  |  |  |  |a2*a1|  |  |  |+	//  |  |  |a3*a1|  |  |  |  |+	// *|  |  |  |  |  |  |  | 2|+	// +|a3*a3|a2*a2|a1*a1|a0*a0|+	//  |--+--+--+--+--+--+--+--|+	//  |A7|A6|A5|A4|A3|A2|A1|A0|, where Ax is x10+	//+	//  "can't overflow" below mark carrying into high part of+	//  multiplication result, which can't overflow, because it+	//  can never be all ones.++	mul	x11,x6,x5	// a[1]*a[0]+	umulh	x15,x6,x5+	mul	x12,x7,x5	// a[2]*a[0]+	umulh	x16,x7,x5+	mul	x13,x8,x5	// a[3]*a[0]+	umulh	x19,x8,x5++	adds	x12,x12,x15	// accumulate high parts of multiplication+	mul	x14,x7,x6	// a[2]*a[1]+	umulh	x15,x7,x6+	adcs	x13,x13,x16+	mul	x16,x8,x6	// a[3]*a[1]+	umulh	x17,x8,x6+	adc	x19,x19,xzr	// can't overflow++	mul	x20,x8,x7	// a[3]*a[2]+	umulh	x21,x8,x7++	adds	x15,x15,x16	// accumulate high parts of multiplication+	mul	x10,x5,x5	// a[0]*a[0]+	adc	x16,x17,xzr	// can't overflow++	adds	x13,x13,x14	// accumulate low parts of multiplication+	umulh	x5,x5,x5+	adcs	x19,x19,x15+	mul	x15,x6,x6	// a[1]*a[1]+	adcs	x20,x20,x16+	umulh	x6,x6,x6+	adc	x21,x21,xzr	// can't overflow++	adds	x11,x11,x11	// acc[1-6]*=2+	mul	x16,x7,x7	// a[2]*a[2]+	adcs	x12,x12,x12+	umulh	x7,x7,x7+	adcs	x13,x13,x13+	mul	x17,x8,x8	// a[3]*a[3]+	adcs	x19,x19,x19+	umulh	x8,x8,x8+	adcs	x20,x20,x20+	adcs	x21,x21,x21+	adc	x22,xzr,xzr++	adds	x11,x11,x5	// +a[i]*a[i]+	adcs	x12,x12,x15+	adcs	x13,x13,x6+	adcs	x19,x19,x16+	adcs	x20,x20,x7+	adcs	x21,x21,x17+	adc	x22,x22,x8++	bl	__mul_by_1_mont_256+	ldr	x30,[x29,#8]++	adds	x10,x10,x19	// accumulate upper half+	adcs	x11,x11,x20+	adcs	x12,x12,x21+	adcs	x13,x13,x22+	adc	x19,xzr,xzr++	subs	x14,x10,x5+	sbcs	x15,x11,x6+	sbcs	x16,x12,x7+	sbcs	x17,x13,x8+	sbcs	xzr,    x19,xzr++	csel	x10,x10,x14,lo+	csel	x11,x11,x15,lo+	csel	x12,x12,x16,lo+	csel	x13,x13,x17,lo++	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret++.globl	from_mont_256++.def	from_mont_256;+.type	32;+.endef+.p2align	5+from_mont_256:+.long	3573752639+	stp	x29,x30,[sp,#-16]!+	add	x29,sp,#0++	mov	x4,x3+	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]++	bl	__mul_by_1_mont_256+	ldr	x30,[x29,#8]++	subs	x14,x10,x5+	sbcs	x15,x11,x6+	sbcs	x16,x12,x7+	sbcs	x17,x13,x8++	csel	x10,x10,x14,lo+	csel	x11,x11,x15,lo+	csel	x12,x12,x16,lo+	csel	x13,x13,x17,lo++	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]++	ldr	x29,[sp],#16+.long	3573752767+	ret+++.globl	redc_mont_256++.def	redc_mont_256;+.type	32;+.endef+.p2align	5+redc_mont_256:+.long	3573752639+	stp	x29,x30,[sp,#-16]!+	add	x29,sp,#0++	mov	x4,x3+	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]++	bl	__mul_by_1_mont_256+	ldr	x30,[x29,#8]++	ldp	x14,x15,[x1,#32]+	ldp	x16,x17,[x1,#48]++	adds	x10,x10,x14+	adcs	x11,x11,x15+	adcs	x12,x12,x16+	adcs	x13,x13,x17+	adc	x9,xzr,xzr++	subs	x14,x10,x5+	sbcs	x15,x11,x6+	sbcs	x16,x12,x7+	sbcs	x17,x13,x8+	sbcs	xzr,    x9,xzr++	csel	x10,x10,x14,lo+	csel	x11,x11,x15,lo+	csel	x12,x12,x16,lo+	csel	x13,x13,x17,lo++	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]++	ldr	x29,[sp],#16+.long	3573752767+	ret+++.def	__mul_by_1_mont_256;+.type	32;+.endef+.p2align	5+__mul_by_1_mont_256:+	mul	x3,x4,x10+	ldp	x5,x6,[x2]+	ldp	x7,x8,[x2,#16]+	//mul	x14,x5,x3+	mul	x15,x6,x3+	mul	x16,x7,x3+	mul	x17,x8,x3+	subs	xzr,x10,#1		//adds	x10,x10,x14+	umulh	x14,x5,x3+	adcs	x11,x11,x15+	umulh	x15,x6,x3+	adcs	x12,x12,x16+	umulh	x16,x7,x3+	adcs	x13,x13,x17+	umulh	x17,x8,x3+	adc	x9,xzr,xzr++	adds	x10,x11,x14+	adcs	x11,x12,x15+	adcs	x12,x13,x16+	mul	x3,x4,x10+	adc	x13,x9,x17+	//mul	x14,x5,x3+	mul	x15,x6,x3+	mul	x16,x7,x3+	mul	x17,x8,x3+	subs	xzr,x10,#1		//adds	x10,x10,x14+	umulh	x14,x5,x3+	adcs	x11,x11,x15+	umulh	x15,x6,x3+	adcs	x12,x12,x16+	umulh	x16,x7,x3+	adcs	x13,x13,x17+	umulh	x17,x8,x3+	adc	x9,xzr,xzr++	adds	x10,x11,x14+	adcs	x11,x12,x15+	adcs	x12,x13,x16+	mul	x3,x4,x10+	adc	x13,x9,x17+	//mul	x14,x5,x3+	mul	x15,x6,x3+	mul	x16,x7,x3+	mul	x17,x8,x3+	subs	xzr,x10,#1		//adds	x10,x10,x14+	umulh	x14,x5,x3+	adcs	x11,x11,x15+	umulh	x15,x6,x3+	adcs	x12,x12,x16+	umulh	x16,x7,x3+	adcs	x13,x13,x17+	umulh	x17,x8,x3+	adc	x9,xzr,xzr++	adds	x10,x11,x14+	adcs	x11,x12,x15+	adcs	x12,x13,x16+	mul	x3,x4,x10+	adc	x13,x9,x17+	//mul	x14,x5,x3+	mul	x15,x6,x3+	mul	x16,x7,x3+	mul	x17,x8,x3+	subs	xzr,x10,#1		//adds	x10,x10,x14+	umulh	x14,x5,x3+	adcs	x11,x11,x15+	umulh	x15,x6,x3+	adcs	x12,x12,x16+	umulh	x16,x7,x3+	adcs	x13,x13,x17+	umulh	x17,x8,x3+	adc	x9,xzr,xzr++	adds	x10,x11,x14+	adcs	x11,x12,x15+	adcs	x12,x13,x16+	adc	x13,x9,x17++	ret+
+ c-source/build/coff/mul_mont_384-armv8.S view
@@ -0,0 +1,2424 @@+.text++.globl	add_mod_384x384+.def	add_mod_384x384;+.type	32;+.endef+.p2align	5+add_mod_384x384:+.long	3573752639+	stp	x29,x30,[sp,#-64]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]++	ldp	x5,x6,[x3]+	ldp	x7,x8,[x3,#16]+	ldp	x9,x10,[x3,#32]++	bl	__add_mod_384x384+	ldr	x30,[x29,#8]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldr	x29,[sp],#64+.long	3573752767+	ret+++.def	__add_mod_384x384;+.type	32;+.endef+.p2align	5+__add_mod_384x384:+	ldp	x11,  x12,  [x1]+	ldp	x19,x20,[x2]+	ldp	x13,  x14,  [x1,#16]+	adds	x11,x11,x19+	ldp	x21,x22,[x2,#16]+	adcs	x12,x12,x20+	ldp	x15,  x16,  [x1,#32]+	adcs	x13,x13,x21+	ldp	x23,x24,[x2,#32]+	adcs	x14,x14,x22+	stp	x11,  x12,  [x0]+	adcs	x15,x15,x23+	ldp	x11,  x12,  [x1,#48]+	adcs	x16,x16,x24++	ldp	x19,x20,[x2,#48]+	stp	x13,  x14,  [x0,#16]+	ldp	x13,  x14,  [x1,#64]+	ldp	x21,x22,[x2,#64]++	adcs	x11,x11,x19+	stp	x15,  x16,  [x0,#32]+	adcs	x12,x12,x20+	ldp	x15,  x16,  [x1,#80]+	adcs	x13,x13,x21+	ldp	x23,x24,[x2,#80]+	adcs	x14,x14,x22+	adcs	x15,x15,x23+	adcs	x16,x16,x24+	adc	x17,xzr,xzr++	subs	x19,x11,x5+	sbcs	x20,x12,x6+	sbcs	x21,x13,x7+	sbcs	x22,x14,x8+	sbcs	x23,x15,x9+	sbcs	x24,x16,x10+	sbcs	xzr,x17,xzr++	csel	x11,x11,x19,lo+	csel	x12,x12,x20,lo+	csel	x13,x13,x21,lo+	csel	x14,x14,x22,lo+	stp	x11,x12,[x0,#48]+	csel	x15,x15,x23,lo+	stp	x13,x14,[x0,#64]+	csel	x16,x16,x24,lo+	stp	x15,x16,[x0,#80]++	ret+++.globl	sub_mod_384x384+.def	sub_mod_384x384;+.type	32;+.endef+.p2align	5+sub_mod_384x384:+.long	3573752639+	stp	x29,x30,[sp,#-64]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]++	ldp	x5,x6,[x3]+	ldp	x7,x8,[x3,#16]+	ldp	x9,x10,[x3,#32]++	bl	__sub_mod_384x384+	ldr	x30,[x29,#8]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldr	x29,[sp],#64+.long	3573752767+	ret+++.def	__sub_mod_384x384;+.type	32;+.endef+.p2align	5+__sub_mod_384x384:+	ldp	x11,  x12,  [x1]+	ldp	x19,x20,[x2]+	ldp	x13,  x14,  [x1,#16]+	subs	x11,x11,x19+	ldp	x21,x22,[x2,#16]+	sbcs	x12,x12,x20+	ldp	x15,  x16,  [x1,#32]+	sbcs	x13,x13,x21+	ldp	x23,x24,[x2,#32]+	sbcs	x14,x14,x22+	stp	x11,  x12,  [x0]+	sbcs	x15,x15,x23+	ldp	x11,  x12,  [x1,#48]+	sbcs	x16,x16,x24++	ldp	x19,x20,[x2,#48]+	stp	x13,  x14,  [x0,#16]+	ldp	x13,  x14,  [x1,#64]+	ldp	x21,x22,[x2,#64]++	sbcs	x11,x11,x19+	stp	x15,  x16,  [x0,#32]+	sbcs	x12,x12,x20+	ldp	x15,  x16,  [x1,#80]+	sbcs	x13,x13,x21+	ldp	x23,x24,[x2,#80]+	sbcs	x14,x14,x22+	sbcs	x15,x15,x23+	sbcs	x16,x16,x24+	sbc	x17,xzr,xzr++	and	x19,x5,x17+	and	x20,x6,x17+	adds	x11,x11,x19+	and	x21,x7,x17+	adcs	x12,x12,x20+	and	x22,x8,x17+	adcs	x13,x13,x21+	and	x23,x9,x17+	adcs	x14,x14,x22+	and	x24,x10,x17+	adcs	x15,x15,x23+	stp	x11,x12,[x0,#48]+	adc	x16,x16,x24+	stp	x13,x14,[x0,#64]+	stp	x15,x16,[x0,#80]++	ret+++.def	__add_mod_384;+.type	32;+.endef+.p2align	5+__add_mod_384:+	ldp	x11,  x12,  [x1]+	ldp	x19,x20,[x2]+	ldp	x13,  x14,  [x1,#16]+	adds	x11,x11,x19+	ldp	x21,x22,[x2,#16]+	adcs	x12,x12,x20+	ldp	x15,  x16,  [x1,#32]+	adcs	x13,x13,x21+	ldp	x23,x24,[x2,#32]+	adcs	x14,x14,x22+	adcs	x15,x15,x23+	adcs	x16,x16,x24+	adc	x17,xzr,xzr++	subs	x19,x11,x5+	sbcs	x20,x12,x6+	sbcs	x21,x13,x7+	sbcs	x22,x14,x8+	sbcs	x23,x15,x9+	sbcs	x24,x16,x10+	sbcs	xzr,x17,xzr++	csel	x11,x11,x19,lo+	csel	x12,x12,x20,lo+	csel	x13,x13,x21,lo+	csel	x14,x14,x22,lo+	csel	x15,x15,x23,lo+	stp	x11,x12,[x0]+	csel	x16,x16,x24,lo+	stp	x13,x14,[x0,#16]+	stp	x15,x16,[x0,#32]++	ret+++.def	__sub_mod_384;+.type	32;+.endef+.p2align	5+__sub_mod_384:+	ldp	x11,  x12,  [x1]+	ldp	x19,x20,[x2]+	ldp	x13,  x14,  [x1,#16]+	subs	x11,x11,x19+	ldp	x21,x22,[x2,#16]+	sbcs	x12,x12,x20+	ldp	x15,  x16,  [x1,#32]+	sbcs	x13,x13,x21+	ldp	x23,x24,[x2,#32]+	sbcs	x14,x14,x22+	sbcs	x15,x15,x23+	sbcs	x16,x16,x24+	sbc	x17,xzr,xzr++	and	x19,x5,x17+	and	x20,x6,x17+	adds	x11,x11,x19+	and	x21,x7,x17+	adcs	x12,x12,x20+	and	x22,x8,x17+	adcs	x13,x13,x21+	and	x23,x9,x17+	adcs	x14,x14,x22+	and	x24,x10,x17+	adcs	x15,x15,x23+	stp	x11,x12,[x0]+	adc	x16,x16,x24+	stp	x13,x14,[x0,#16]+	stp	x15,x16,[x0,#32]++	ret+++.globl	mul_mont_384x++.def	mul_mont_384x;+.type	32;+.endef+.p2align	5+mul_mont_384x:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	sub	sp,sp,#288		// space for 3 768-bit vectors++	mov	x26,x0		// save r_ptr+	mov	x27,x1		// save b_ptr+	mov	x28,x2		// save b_ptr++	sub	x0,sp,#0		// mul_384(t0, a->re, b->re)+	bl	__mul_384++	add	x1,x1,#48	// mul_384(t1, a->im, b->im)+	add	x2,x2,#48+	add	x0,sp,#96+	bl	__mul_384++	ldp	x5,x6,[x3]+	ldp	x7,x8,[x3,#16]+	ldp	x9,x10,[x3,#32]++	sub	x2,x1,#48+	add	x0,sp,#240+	bl	__add_mod_384++	add	x1,x28,#0+	add	x2,x28,#48+	add	x0,sp,#192		// t2+	bl	__add_mod_384++	add	x1,x0,#0+	add	x2,x0,#48+	bl	__mul_384		// mul_384(t2, a->re+a->im, b->re+b->im)++	ldp	x5,x6,[x3]+	ldp	x7,x8,[x3,#16]+	ldp	x9,x10,[x3,#32]++	mov	x1,x0+	add	x2,sp,#0+	bl	__sub_mod_384x384++	add	x2,sp,#96+	bl	__sub_mod_384x384	// t2 = t2-t0-t1++	add	x1,sp,#0+	add	x2,sp,#96+	add	x0,sp,#0+	bl	__sub_mod_384x384	// t0 = t0-t1++	add	x1,sp,#0		// ret->re = redc(t0)+	add	x0,x26,#0+	bl	__mul_by_1_mont_384+	bl	__redc_tail_mont_384++	add	x1,sp,#192		// ret->im = redc(t2)+	add	x0,x0,#48+	bl	__mul_by_1_mont_384+	bl	__redc_tail_mont_384+	ldr	x30,[x29,#8]++	add	sp,sp,#288+	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret+++.globl	sqr_mont_384x++.def	sqr_mont_384x;+.type	32;+.endef+.p2align	5+sqr_mont_384x:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	stp	x3,x0,[sp,#96]	// __mul_mont_384 wants them there+	sub	sp,sp,#96		// space for 2 384-bit vectors+	mov	x4,x3		// adjust for missing b_ptr++	ldp	x5,x6,[x2]+	ldp	x7,x8,[x2,#16]+	ldp	x9,x10,[x2,#32]++	add	x2,x1,#48+	add	x0,sp,#0+	bl	__add_mod_384		// t0 = a->re + a->im++	add	x0,sp,#48+	bl	__sub_mod_384		// t1 = a->re - a->im++	ldp	x11,x12,[x1]+	ldr	x17,        [x2]+	ldp	x13,x14,[x1,#16]+	ldp	x15,x16,[x1,#32]++	bl	__mul_mont_384		// mul_mont_384(ret->im, a->re, a->im)++	adds	x11,x11,x11	// add with itself+	adcs	x12,x12,x12+	adcs	x13,x13,x13+	adcs	x14,x14,x14+	adcs	x15,x15,x15+	adcs	x16,x16,x16+	adc	x25,xzr,xzr++	subs	x19,x11,x5+	sbcs	x20,x12,x6+	sbcs	x21,x13,x7+	sbcs	x22,x14,x8+	sbcs	x23,x15,x9+	sbcs	x24,x16,x10+	sbcs	xzr,x25,xzr++	csel	x19,x11,x19,lo+	csel	x20,x12,x20,lo+	csel	x21,x13,x21,lo+	ldp	x11,x12,[sp]+	csel	x22,x14,x22,lo+	ldr	x17,        [sp,#48]+	csel	x23,x15,x23,lo+	ldp	x13,x14,[sp,#16]+	csel	x24,x16,x24,lo+	ldp	x15,x16,[sp,#32]++	stp	x19,x20,[x2,#48]+	stp	x21,x22,[x2,#64]+	stp	x23,x24,[x2,#80]++	add	x2,sp,#48+	bl	__mul_mont_384		// mul_mont_384(ret->re, t0, t1)+	ldr	x30,[x29,#8]++	stp	x11,x12,[x2]+	stp	x13,x14,[x2,#16]+	stp	x15,x16,[x2,#32]++	add	sp,sp,#96+	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret+++.globl	mul_mont_384++.def	mul_mont_384;+.type	32;+.endef+.p2align	5+mul_mont_384:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	stp	x4,x0,[sp,#96]	// __mul_mont_384 wants them there++	ldp	x11,x12,[x1]+	ldr	x17,        [x2]+	ldp	x13,x14,[x1,#16]+	ldp	x15,x16,[x1,#32]++	ldp	x5,x6,[x3]+	ldp	x7,x8,[x3,#16]+	ldp	x9,x10,[x3,#32]++	bl	__mul_mont_384+	ldr	x30,[x29,#8]++	stp	x11,x12,[x2]+	stp	x13,x14,[x2,#16]+	stp	x15,x16,[x2,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret+++.def	__mul_mont_384;+.type	32;+.endef+.p2align	5+__mul_mont_384:+	mul	x19,x11,x17+	mul	x20,x12,x17+	mul	x21,x13,x17+	mul	x22,x14,x17+	mul	x23,x15,x17+	mul	x24,x16,x17+	mul	x4,x4,x19++	umulh	x26,x11,x17+	umulh	x27,x12,x17+	umulh	x28,x13,x17+	umulh	x0,x14,x17+	umulh	x1,x15,x17+	umulh	x3,x16,x17++	adds	x20,x20,x26+	// mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adc	x25,xzr,    x3+	mul	x3,x10,x4+	mov	x17,xzr+	subs	xzr,x19,#1		// adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adcs	x25,x25,xzr+	adc	x4,x17,xzr+	ldr	x17,[x2,8*1]++	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,x4,xzr+	ldr	x4,[x29,#96]++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adcs	x25,x25,xzr+	adc	x17,xzr,xzr++	adds	x20,x20,x26+	// mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adcs	x25,x25,x3+	mul	x3,x10,x4+	adc	x17,x17,xzr+	subs	xzr,x19,#1		// adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adcs	x25,x25,xzr+	adc	x4,x17,xzr+	ldr	x17,[x2,8*2]++	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,x4,xzr+	ldr	x4,[x29,#96]++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adcs	x25,x25,xzr+	adc	x17,xzr,xzr++	adds	x20,x20,x26+	// mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adcs	x25,x25,x3+	mul	x3,x10,x4+	adc	x17,x17,xzr+	subs	xzr,x19,#1		// adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adcs	x25,x25,xzr+	adc	x4,x17,xzr+	ldr	x17,[x2,8*3]++	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,x4,xzr+	ldr	x4,[x29,#96]++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adcs	x25,x25,xzr+	adc	x17,xzr,xzr++	adds	x20,x20,x26+	// mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adcs	x25,x25,x3+	mul	x3,x10,x4+	adc	x17,x17,xzr+	subs	xzr,x19,#1		// adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adcs	x25,x25,xzr+	adc	x4,x17,xzr+	ldr	x17,[x2,8*4]++	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,x4,xzr+	ldr	x4,[x29,#96]++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adcs	x25,x25,xzr+	adc	x17,xzr,xzr++	adds	x20,x20,x26+	// mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adcs	x25,x25,x3+	mul	x3,x10,x4+	adc	x17,x17,xzr+	subs	xzr,x19,#1		// adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adcs	x25,x25,xzr+	adc	x4,x17,xzr+	ldr	x17,[x2,8*5]++	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,x4,xzr+	ldr	x4,[x29,#96]++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adcs	x25,x25,xzr+	adc	x17,xzr,xzr++	adds	x20,x20,x26+	// mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adcs	x25,x25,x3+	mul	x3,x10,x4+	adc	x17,x17,xzr+	subs	xzr,x19,#1		// adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adcs	x25,x25,xzr+	ldp	x4,x2,[x29,#96]	// pull r_ptr+	adc	x17,x17,xzr++	adds	x19,x20,x26+	adcs	x20,x21,x27+	adcs	x21,x22,x28+	adcs	x22,x23,x0+	adcs	x23,x24,x1+	adcs	x24,x25,x3+	adc	x25,x17,xzr++	subs	x26,x19,x5+	sbcs	x27,x20,x6+	sbcs	x28,x21,x7+	sbcs	x0,x22,x8+	sbcs	x1,x23,x9+	sbcs	x3,x24,x10+	sbcs	xzr,    x25,xzr++	csel	x11,x19,x26,lo+	csel	x12,x20,x27,lo+	csel	x13,x21,x28,lo+	csel	x14,x22,x0,lo+	csel	x15,x23,x1,lo+	csel	x16,x24,x3,lo+	ret+++.globl	sqr_mont_384++.def	sqr_mont_384;+.type	32;+.endef+.p2align	5+sqr_mont_384:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	sub	sp,sp,#96		// space for 768-bit vector+	mov	x4,x3		// adjust for missing b_ptr++	mov	x3,x0		// save r_ptr+	mov	x0,sp++	ldp	x11,x12,[x1]+	ldp	x13,x14,[x1,#16]+	ldp	x15,x16,[x1,#32]++	bl	__sqr_384++	ldp	x5,x6,[x2]+	ldp	x7,x8,[x2,#16]+	ldp	x9,x10,[x2,#32]++	mov	x1,sp+	mov	x0,x3		// restore r_ptr+	bl	__mul_by_1_mont_384+	bl	__redc_tail_mont_384+	ldr	x30,[x29,#8]++	add	sp,sp,#96+	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret+++.globl	sqr_n_mul_mont_383++.def	sqr_n_mul_mont_383;+.type	32;+.endef+.p2align	5+sqr_n_mul_mont_383:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	stp	x4,x0,[sp,#96]	// __mul_mont_384 wants them there+	sub	sp,sp,#96		// space for 768-bit vector+	mov	x17,x5			// save b_ptr++	ldp	x11,x12,[x1]+	ldp	x13,x14,[x1,#16]+	ldp	x15,x16,[x1,#32]+	mov	x0,sp+.Loop_sqr_383:+	bl	__sqr_384+	sub	x2,x2,#1	// counter++	ldp	x5,x6,[x3]+	ldp	x7,x8,[x3,#16]+	ldp	x9,x10,[x3,#32]++	mov	x1,sp+	bl	__mul_by_1_mont_384++	ldp	x19,x20,[x1,#48]+	ldp	x21,x22,[x1,#64]+	ldp	x23,x24,[x1,#80]++	adds	x11,x11,x19	// just accumulate upper half+	adcs	x12,x12,x20+	adcs	x13,x13,x21+	adcs	x14,x14,x22+	adcs	x15,x15,x23+	adc	x16,x16,x24++	cbnz	x2,.Loop_sqr_383++	mov	x2,x17+	ldr	x17,[x17]+	bl	__mul_mont_384+	ldr	x30,[x29,#8]++	stp	x11,x12,[x2]+	stp	x13,x14,[x2,#16]+	stp	x15,x16,[x2,#32]++	add	sp,sp,#96+	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret++.def	__sqr_384;+.type	32;+.endef+.p2align	5+__sqr_384:+	mul	x19,x12,x11+	mul	x20,x13,x11+	mul	x21,x14,x11+	mul	x22,x15,x11+	mul	x23,x16,x11++	umulh	x6,x12,x11+	umulh	x7,x13,x11+	umulh	x8,x14,x11+	umulh	x9,x15,x11+	adds	x20,x20,x6+	umulh	x10,x16,x11+	adcs	x21,x21,x7+	mul	x7,x13,x12+	adcs	x22,x22,x8+	mul	x8,x14,x12+	adcs	x23,x23,x9+	mul	x9,x15,x12+	adc	x24,xzr,    x10+	mul	x10,x16,x12++	adds	x21,x21,x7+	umulh	x7,x13,x12+	adcs	x22,x22,x8+	umulh	x8,x14,x12+	adcs	x23,x23,x9+	umulh	x9,x15,x12+	adcs	x24,x24,x10+	umulh	x10,x16,x12+	adc	x25,xzr,xzr++	mul	x5,x11,x11+	adds	x22,x22,x7+	umulh	x11,  x11,x11+	adcs	x23,x23,x8+	mul	x8,x14,x13+	adcs	x24,x24,x9+	mul	x9,x15,x13+	adc	x25,x25,x10+	mul	x10,x16,x13++	adds	x23,x23,x8+	umulh	x8,x14,x13+	adcs	x24,x24,x9+	umulh	x9,x15,x13+	adcs	x25,x25,x10+	umulh	x10,x16,x13+	adc	x26,xzr,xzr++	mul	x6,x12,x12+	adds	x24,x24,x8+	umulh	x12,  x12,x12+	adcs	x25,x25,x9+	mul	x9,x15,x14+	adc	x26,x26,x10+	mul	x10,x16,x14++	adds	x25,x25,x9+	umulh	x9,x15,x14+	adcs	x26,x26,x10+	umulh	x10,x16,x14+	adc	x27,xzr,xzr+	mul	x7,x13,x13+	adds	x26,x26,x9+	umulh	x13,  x13,x13+	adc	x27,x27,x10+	mul	x8,x14,x14++	mul	x10,x16,x15+	umulh	x14,  x14,x14+	adds	x27,x27,x10+	umulh	x10,x16,x15+	mul	x9,x15,x15+	adc	x28,x10,xzr++	adds	x19,x19,x19+	adcs	x20,x20,x20+	adcs	x21,x21,x21+	adcs	x22,x22,x22+	adcs	x23,x23,x23+	adcs	x24,x24,x24+	adcs	x25,x25,x25+	adcs	x26,x26,x26+	umulh	x15,  x15,x15+	adcs	x27,x27,x27+	mul	x10,x16,x16+	adcs	x28,x28,x28+	umulh	x16,  x16,x16+	adc	x1,xzr,xzr++	adds	x19,x19,x11+	adcs	x20,x20,x6+	adcs	x21,x21,x12+	adcs	x22,x22,x7+	adcs	x23,x23,x13+	adcs	x24,x24,x8+	adcs	x25,x25,x14+	stp	x5,x19,[x0]+	adcs	x26,x26,x9+	stp	x20,x21,[x0,#16]+	adcs	x27,x27,x15+	stp	x22,x23,[x0,#32]+	adcs	x28,x28,x10+	stp	x24,x25,[x0,#48]+	adc	x16,x16,x1+	stp	x26,x27,[x0,#64]+	stp	x28,x16,[x0,#80]++	ret++.globl	sqr_384++.def	sqr_384;+.type	32;+.endef+.p2align	5+sqr_384:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]++	ldp	x11,x12,[x1]+	ldp	x13,x14,[x1,#16]+	ldp	x15,x16,[x1,#32]++	bl	__sqr_384+	ldr	x30,[x29,#8]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret+++.globl	redc_mont_384++.def	redc_mont_384;+.type	32;+.endef+.p2align	5+redc_mont_384:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	mov	x4,x3		// adjust for missing b_ptr++	ldp	x5,x6,[x2]+	ldp	x7,x8,[x2,#16]+	ldp	x9,x10,[x2,#32]++	bl	__mul_by_1_mont_384+	bl	__redc_tail_mont_384+	ldr	x30,[x29,#8]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret+++.globl	from_mont_384++.def	from_mont_384;+.type	32;+.endef+.p2align	5+from_mont_384:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	mov	x4,x3		// adjust for missing b_ptr++	ldp	x5,x6,[x2]+	ldp	x7,x8,[x2,#16]+	ldp	x9,x10,[x2,#32]++	bl	__mul_by_1_mont_384+	ldr	x30,[x29,#8]++	subs	x19,x11,x5+	sbcs	x20,x12,x6+	sbcs	x21,x13,x7+	sbcs	x22,x14,x8+	sbcs	x23,x15,x9+	sbcs	x24,x16,x10++	csel	x11,x11,x19,lo+	csel	x12,x12,x20,lo+	csel	x13,x13,x21,lo+	csel	x14,x14,x22,lo+	csel	x15,x15,x23,lo+	csel	x16,x16,x24,lo++	stp	x11,x12,[x0]+	stp	x13,x14,[x0,#16]+	stp	x15,x16,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret+++.def	__mul_by_1_mont_384;+.type	32;+.endef+.p2align	5+__mul_by_1_mont_384:+	ldp	x11,x12,[x1]+	ldp	x13,x14,[x1,#16]+	mul	x26,x4,x11+	ldp	x15,x16,[x1,#32]++	// mul	x19,x5,x26+	mul	x20,x6,x26+	mul	x21,x7,x26+	mul	x22,x8,x26+	mul	x23,x9,x26+	mul	x24,x10,x26+	subs	xzr,x11,#1		// adds	x19,x19,x11+	umulh	x11,x5,x26+	adcs	x20,x20,x12+	umulh	x12,x6,x26+	adcs	x21,x21,x13+	umulh	x13,x7,x26+	adcs	x22,x22,x14+	umulh	x14,x8,x26+	adcs	x23,x23,x15+	umulh	x15,x9,x26+	adcs	x24,x24,x16+	umulh	x16,x10,x26+	adc	x25,xzr,xzr+	adds	x11,x11,x20+	adcs	x12,x12,x21+	adcs	x13,x13,x22+	mul	x26,x4,x11+	adcs	x14,x14,x23+	adcs	x15,x15,x24+	adc	x16,x16,x25++	// mul	x19,x5,x26+	mul	x20,x6,x26+	mul	x21,x7,x26+	mul	x22,x8,x26+	mul	x23,x9,x26+	mul	x24,x10,x26+	subs	xzr,x11,#1		// adds	x19,x19,x11+	umulh	x11,x5,x26+	adcs	x20,x20,x12+	umulh	x12,x6,x26+	adcs	x21,x21,x13+	umulh	x13,x7,x26+	adcs	x22,x22,x14+	umulh	x14,x8,x26+	adcs	x23,x23,x15+	umulh	x15,x9,x26+	adcs	x24,x24,x16+	umulh	x16,x10,x26+	adc	x25,xzr,xzr+	adds	x11,x11,x20+	adcs	x12,x12,x21+	adcs	x13,x13,x22+	mul	x26,x4,x11+	adcs	x14,x14,x23+	adcs	x15,x15,x24+	adc	x16,x16,x25++	// mul	x19,x5,x26+	mul	x20,x6,x26+	mul	x21,x7,x26+	mul	x22,x8,x26+	mul	x23,x9,x26+	mul	x24,x10,x26+	subs	xzr,x11,#1		// adds	x19,x19,x11+	umulh	x11,x5,x26+	adcs	x20,x20,x12+	umulh	x12,x6,x26+	adcs	x21,x21,x13+	umulh	x13,x7,x26+	adcs	x22,x22,x14+	umulh	x14,x8,x26+	adcs	x23,x23,x15+	umulh	x15,x9,x26+	adcs	x24,x24,x16+	umulh	x16,x10,x26+	adc	x25,xzr,xzr+	adds	x11,x11,x20+	adcs	x12,x12,x21+	adcs	x13,x13,x22+	mul	x26,x4,x11+	adcs	x14,x14,x23+	adcs	x15,x15,x24+	adc	x16,x16,x25++	// mul	x19,x5,x26+	mul	x20,x6,x26+	mul	x21,x7,x26+	mul	x22,x8,x26+	mul	x23,x9,x26+	mul	x24,x10,x26+	subs	xzr,x11,#1		// adds	x19,x19,x11+	umulh	x11,x5,x26+	adcs	x20,x20,x12+	umulh	x12,x6,x26+	adcs	x21,x21,x13+	umulh	x13,x7,x26+	adcs	x22,x22,x14+	umulh	x14,x8,x26+	adcs	x23,x23,x15+	umulh	x15,x9,x26+	adcs	x24,x24,x16+	umulh	x16,x10,x26+	adc	x25,xzr,xzr+	adds	x11,x11,x20+	adcs	x12,x12,x21+	adcs	x13,x13,x22+	mul	x26,x4,x11+	adcs	x14,x14,x23+	adcs	x15,x15,x24+	adc	x16,x16,x25++	// mul	x19,x5,x26+	mul	x20,x6,x26+	mul	x21,x7,x26+	mul	x22,x8,x26+	mul	x23,x9,x26+	mul	x24,x10,x26+	subs	xzr,x11,#1		// adds	x19,x19,x11+	umulh	x11,x5,x26+	adcs	x20,x20,x12+	umulh	x12,x6,x26+	adcs	x21,x21,x13+	umulh	x13,x7,x26+	adcs	x22,x22,x14+	umulh	x14,x8,x26+	adcs	x23,x23,x15+	umulh	x15,x9,x26+	adcs	x24,x24,x16+	umulh	x16,x10,x26+	adc	x25,xzr,xzr+	adds	x11,x11,x20+	adcs	x12,x12,x21+	adcs	x13,x13,x22+	mul	x26,x4,x11+	adcs	x14,x14,x23+	adcs	x15,x15,x24+	adc	x16,x16,x25++	// mul	x19,x5,x26+	mul	x20,x6,x26+	mul	x21,x7,x26+	mul	x22,x8,x26+	mul	x23,x9,x26+	mul	x24,x10,x26+	subs	xzr,x11,#1		// adds	x19,x19,x11+	umulh	x11,x5,x26+	adcs	x20,x20,x12+	umulh	x12,x6,x26+	adcs	x21,x21,x13+	umulh	x13,x7,x26+	adcs	x22,x22,x14+	umulh	x14,x8,x26+	adcs	x23,x23,x15+	umulh	x15,x9,x26+	adcs	x24,x24,x16+	umulh	x16,x10,x26+	adc	x25,xzr,xzr+	adds	x11,x11,x20+	adcs	x12,x12,x21+	adcs	x13,x13,x22+	adcs	x14,x14,x23+	adcs	x15,x15,x24+	adc	x16,x16,x25++	ret+++.def	__redc_tail_mont_384;+.type	32;+.endef+.p2align	5+__redc_tail_mont_384:+	ldp	x19,x20,[x1,#48]+	ldp	x21,x22,[x1,#64]+	ldp	x23,x24,[x1,#80]++	adds	x11,x11,x19	// accumulate upper half+	adcs	x12,x12,x20+	adcs	x13,x13,x21+	adcs	x14,x14,x22+	adcs	x15,x15,x23+	adcs	x16,x16,x24+	adc	x25,xzr,xzr++	subs	x19,x11,x5+	sbcs	x20,x12,x6+	sbcs	x21,x13,x7+	sbcs	x22,x14,x8+	sbcs	x23,x15,x9+	sbcs	x24,x16,x10+	sbcs	xzr,x25,xzr++	csel	x11,x11,x19,lo+	csel	x12,x12,x20,lo+	csel	x13,x13,x21,lo+	csel	x14,x14,x22,lo+	csel	x15,x15,x23,lo+	csel	x16,x16,x24,lo++	stp	x11,x12,[x0]+	stp	x13,x14,[x0,#16]+	stp	x15,x16,[x0,#32]++	ret+++.globl	mul_384++.def	mul_384;+.type	32;+.endef+.p2align	5+mul_384:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]++	bl	__mul_384+	ldr	x30,[x29,#8]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret+++.def	__mul_384;+.type	32;+.endef+.p2align	5+__mul_384:+	ldp	x11,x12,[x1]+	ldr	x17,        [x2]+	ldp	x13,x14,[x1,#16]+	ldp	x15,x16,[x1,#32]++	mul	x19,x11,x17+	mul	x20,x12,x17+	mul	x21,x13,x17+	mul	x22,x14,x17+	mul	x23,x15,x17+	mul	x24,x16,x17++	umulh	x5,x11,x17+	umulh	x6,x12,x17+	umulh	x7,x13,x17+	umulh	x8,x14,x17+	umulh	x9,x15,x17+	umulh	x10,x16,x17+	ldr	x17,[x2,8*1]++	str	x19,[x0]+	adds	x19,x20,x5+	mul	x5,x11,x17+	adcs	x20,x21,x6+	mul	x6,x12,x17+	adcs	x21,x22,x7+	mul	x7,x13,x17+	adcs	x22,x23,x8+	mul	x8,x14,x17+	adcs	x23,x24,x9+	mul	x9,x15,x17+	adc	x24,xzr,    x10+	mul	x10,x16,x17+	adds	x19,x19,x5+	umulh	x5,x11,x17+	adcs	x20,x20,x6+	umulh	x6,x12,x17+	adcs	x21,x21,x7+	umulh	x7,x13,x17+	adcs	x22,x22,x8+	umulh	x8,x14,x17+	adcs	x23,x23,x9+	umulh	x9,x15,x17+	adcs	x24,x24,x10+	umulh	x10,x16,x17+	ldr	x17,[x2,#8*(1+1)]+	adc	x25,xzr,xzr++	str	x19,[x0,8*1]+	adds	x19,x20,x5+	mul	x5,x11,x17+	adcs	x20,x21,x6+	mul	x6,x12,x17+	adcs	x21,x22,x7+	mul	x7,x13,x17+	adcs	x22,x23,x8+	mul	x8,x14,x17+	adcs	x23,x24,x9+	mul	x9,x15,x17+	adc	x24,x25,x10+	mul	x10,x16,x17+	adds	x19,x19,x5+	umulh	x5,x11,x17+	adcs	x20,x20,x6+	umulh	x6,x12,x17+	adcs	x21,x21,x7+	umulh	x7,x13,x17+	adcs	x22,x22,x8+	umulh	x8,x14,x17+	adcs	x23,x23,x9+	umulh	x9,x15,x17+	adcs	x24,x24,x10+	umulh	x10,x16,x17+	ldr	x17,[x2,#8*(2+1)]+	adc	x25,xzr,xzr++	str	x19,[x0,8*2]+	adds	x19,x20,x5+	mul	x5,x11,x17+	adcs	x20,x21,x6+	mul	x6,x12,x17+	adcs	x21,x22,x7+	mul	x7,x13,x17+	adcs	x22,x23,x8+	mul	x8,x14,x17+	adcs	x23,x24,x9+	mul	x9,x15,x17+	adc	x24,x25,x10+	mul	x10,x16,x17+	adds	x19,x19,x5+	umulh	x5,x11,x17+	adcs	x20,x20,x6+	umulh	x6,x12,x17+	adcs	x21,x21,x7+	umulh	x7,x13,x17+	adcs	x22,x22,x8+	umulh	x8,x14,x17+	adcs	x23,x23,x9+	umulh	x9,x15,x17+	adcs	x24,x24,x10+	umulh	x10,x16,x17+	ldr	x17,[x2,#8*(3+1)]+	adc	x25,xzr,xzr++	str	x19,[x0,8*3]+	adds	x19,x20,x5+	mul	x5,x11,x17+	adcs	x20,x21,x6+	mul	x6,x12,x17+	adcs	x21,x22,x7+	mul	x7,x13,x17+	adcs	x22,x23,x8+	mul	x8,x14,x17+	adcs	x23,x24,x9+	mul	x9,x15,x17+	adc	x24,x25,x10+	mul	x10,x16,x17+	adds	x19,x19,x5+	umulh	x5,x11,x17+	adcs	x20,x20,x6+	umulh	x6,x12,x17+	adcs	x21,x21,x7+	umulh	x7,x13,x17+	adcs	x22,x22,x8+	umulh	x8,x14,x17+	adcs	x23,x23,x9+	umulh	x9,x15,x17+	adcs	x24,x24,x10+	umulh	x10,x16,x17+	ldr	x17,[x2,#8*(4+1)]+	adc	x25,xzr,xzr++	str	x19,[x0,8*4]+	adds	x19,x20,x5+	mul	x5,x11,x17+	adcs	x20,x21,x6+	mul	x6,x12,x17+	adcs	x21,x22,x7+	mul	x7,x13,x17+	adcs	x22,x23,x8+	mul	x8,x14,x17+	adcs	x23,x24,x9+	mul	x9,x15,x17+	adc	x24,x25,x10+	mul	x10,x16,x17+	adds	x19,x19,x5+	umulh	x5,x11,x17+	adcs	x20,x20,x6+	umulh	x6,x12,x17+	adcs	x21,x21,x7+	umulh	x7,x13,x17+	adcs	x22,x22,x8+	umulh	x8,x14,x17+	adcs	x23,x23,x9+	umulh	x9,x15,x17+	adcs	x24,x24,x10+	umulh	x10,x16,x17+	adc	x25,xzr,xzr++	str	x19,[x0,8*5]+	adds	x19,x20,x5+	adcs	x20,x21,x6+	adcs	x21,x22,x7+	adcs	x22,x23,x8+	adcs	x23,x24,x9+	adc	x24,x25,x10++	stp	x19,x20,[x0,#48]+	stp	x21,x22,[x0,#64]+	stp	x23,x24,[x0,#80]++	ret+++.globl	mul_382x++.def	mul_382x;+.type	32;+.endef+.p2align	5+mul_382x:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	sub	sp,sp,#96		// space for two 384-bit vectors++	ldp	x11,x12,[x1]+	mov	x26,x0		// save r_ptr+	ldp	x19,x20,[x1,#48]+	mov	x27,x1		// save a_ptr+	ldp	x13,x14,[x1,#16]+	mov	x28,x2		// save b_ptr+	ldp	x21,x22,[x1,#64]+	ldp	x15,x16,[x1,#32]+	adds	x5,x11,x19	// t0 = a->re + a->im+	ldp	x23,x24,[x1,#80]+	adcs	x6,x12,x20+	ldp	x11,x12,[x2]+	adcs	x7,x13,x21+	ldp	x19,x20,[x2,#48]+	adcs	x8,x14,x22+	ldp	x13,x14,[x2,#16]+	adcs	x9,x15,x23+	ldp	x21,x22,[x2,#64]+	adc	x10,x16,x24+	ldp	x15,x16,[x2,#32]++	stp	x5,x6,[sp]+	adds	x5,x11,x19	// t1 = b->re + b->im+	ldp	x23,x24,[x2,#80]+	adcs	x6,x12,x20+	stp	x7,x8,[sp,#16]+	adcs	x7,x13,x21+	adcs	x8,x14,x22+	stp	x9,x10,[sp,#32]+	adcs	x9,x15,x23+	stp	x5,x6,[sp,#48]+	adc	x10,x16,x24+	stp	x7,x8,[sp,#64]+	stp	x9,x10,[sp,#80]++	bl	__mul_384		// mul_384(ret->re, a->re, b->re)++	add	x1,sp,#0		// mul_384(ret->im, t0, t1)+	add	x2,sp,#48+	add	x0,x26,#96+	bl	__mul_384++	add	x1,x27,#48	// mul_384(tx, a->im, b->im)+	add	x2,x28,#48+	add	x0,sp,#0+	bl	__mul_384++	ldp	x5,x6,[x3]+	ldp	x7,x8,[x3,#16]+	ldp	x9,x10,[x3,#32]++	add	x1,x26,#96	// ret->im -= tx+	add	x2,sp,#0+	add	x0,x26,#96+	bl	__sub_mod_384x384++	add	x2,x26,#0	// ret->im -= ret->re+	bl	__sub_mod_384x384++	add	x1,x26,#0	// ret->re -= tx+	add	x2,sp,#0+	add	x0,x26,#0+	bl	__sub_mod_384x384+	ldr	x30,[x29,#8]++	add	sp,sp,#96+	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret+++.globl	sqr_382x++.def	sqr_382x;+.type	32;+.endef+.p2align	5+sqr_382x:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]++	ldp	x11,x12,[x1]+	ldp	x19,x20,[x1,#48]+	ldp	x13,x14,[x1,#16]+	adds	x5,x11,x19	// t0 = a->re + a->im+	ldp	x21,x22,[x1,#64]+	adcs	x6,x12,x20+	ldp	x15,x16,[x1,#32]+	adcs	x7,x13,x21+	ldp	x23,x24,[x1,#80]+	adcs	x8,x14,x22+	stp	x5,x6,[x0]+	adcs	x9,x15,x23+	ldp	x5,x6,[x2]+	adc	x10,x16,x24+	stp	x7,x8,[x0,#16]++	subs	x11,x11,x19	// t1 = a->re - a->im+	ldp	x7,x8,[x2,#16]+	sbcs	x12,x12,x20+	stp	x9,x10,[x0,#32]+	sbcs	x13,x13,x21+	ldp	x9,x10,[x2,#32]+	sbcs	x14,x14,x22+	sbcs	x15,x15,x23+	sbcs	x16,x16,x24+	sbc	x25,xzr,xzr++	and	x19,x5,x25+	and	x20,x6,x25+	adds	x11,x11,x19+	and	x21,x7,x25+	adcs	x12,x12,x20+	and	x22,x8,x25+	adcs	x13,x13,x21+	and	x23,x9,x25+	adcs	x14,x14,x22+	and	x24,x10,x25+	adcs	x15,x15,x23+	stp	x11,x12,[x0,#48]+	adc	x16,x16,x24+	stp	x13,x14,[x0,#64]+	stp	x15,x16,[x0,#80]++	mov	x4,x1		// save a_ptr+	add	x1,x0,#0	// mul_384(ret->re, t0, t1)+	add	x2,x0,#48+	bl	__mul_384++	add	x1,x4,#0		// mul_384(ret->im, a->re, a->im)+	add	x2,x4,#48+	add	x0,x0,#96+	bl	__mul_384+	ldr	x30,[x29,#8]++	ldp	x11,x12,[x0]+	ldp	x13,x14,[x0,#16]+	adds	x11,x11,x11	// add with itself+	ldp	x15,x16,[x0,#32]+	adcs	x12,x12,x12+	adcs	x13,x13,x13+	adcs	x14,x14,x14+	adcs	x15,x15,x15+	adcs	x16,x16,x16+	adcs	x19,x19,x19+	adcs	x20,x20,x20+	stp	x11,x12,[x0]+	adcs	x21,x21,x21+	stp	x13,x14,[x0,#16]+	adcs	x22,x22,x22+	stp	x15,x16,[x0,#32]+	adcs	x23,x23,x23+	stp	x19,x20,[x0,#48]+	adc	x24,x24,x24+	stp	x21,x22,[x0,#64]+	stp	x23,x24,[x0,#80]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret+++.globl	sqr_mont_382x++.def	sqr_mont_382x;+.type	32;+.endef+.p2align	5+sqr_mont_382x:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	stp	x3,x0,[sp,#96]	// __mul_mont_384 wants them there+	sub	sp,sp,#112		// space for two 384-bit vectors + word+	mov	x4,x3		// adjust for missing b_ptr++	ldp	x11,x12,[x1]+	ldp	x13,x14,[x1,#16]+	ldp	x15,x16,[x1,#32]++	ldp	x17,x20,[x1,#48]+	ldp	x21,x22,[x1,#64]+	ldp	x23,x24,[x1,#80]++	adds	x5,x11,x17	// t0 = a->re + a->im+	adcs	x6,x12,x20+	adcs	x7,x13,x21+	adcs	x8,x14,x22+	adcs	x9,x15,x23+	adc	x10,x16,x24++	subs	x19,x11,x17	// t1 = a->re - a->im+	sbcs	x20,x12,x20+	sbcs	x21,x13,x21+	sbcs	x22,x14,x22+	sbcs	x23,x15,x23+	sbcs	x24,x16,x24+	sbc	x25,xzr,xzr		// borrow flag as mask++	stp	x5,x6,[sp]+	stp	x7,x8,[sp,#16]+	stp	x9,x10,[sp,#32]+	stp	x19,x20,[sp,#48]+	stp	x21,x22,[sp,#64]+	stp	x23,x24,[sp,#80]+	str	x25,[sp,#96]++	ldp	x5,x6,[x2]+	ldp	x7,x8,[x2,#16]+	ldp	x9,x10,[x2,#32]++	add	x2,x1,#48+	bl	__mul_mont_383_nonred	// mul_mont_384(ret->im, a->re, a->im)++	adds	x19,x11,x11	// add with itself+	adcs	x20,x12,x12+	adcs	x21,x13,x13+	adcs	x22,x14,x14+	adcs	x23,x15,x15+	adc	x24,x16,x16++	stp	x19,x20,[x2,#48]+	stp	x21,x22,[x2,#64]+	stp	x23,x24,[x2,#80]++	ldp	x11,x12,[sp]+	ldr	x17,[sp,#48]+	ldp	x13,x14,[sp,#16]+	ldp	x15,x16,[sp,#32]++	add	x2,sp,#48+	bl	__mul_mont_383_nonred	// mul_mont_384(ret->im, t0, t1)+	ldr	x30,[x29,#8]++	ldr	x25,[sp,#96]	// account for sign from a->re - a->im+	ldp	x19,x20,[sp]+	ldp	x21,x22,[sp,#16]+	ldp	x23,x24,[sp,#32]++	and	x19,x19,x25+	and	x20,x20,x25+	and	x21,x21,x25+	and	x22,x22,x25+	and	x23,x23,x25+	and	x24,x24,x25++	subs	x11,x11,x19+	sbcs	x12,x12,x20+	sbcs	x13,x13,x21+	sbcs	x14,x14,x22+	sbcs	x15,x15,x23+	sbcs	x16,x16,x24+	sbc	x25,xzr,xzr++	and	x19,x5,x25+	and	x20,x6,x25+	and	x21,x7,x25+	and	x22,x8,x25+	and	x23,x9,x25+	and	x24,x10,x25++	adds	x11,x11,x19+	adcs	x12,x12,x20+	adcs	x13,x13,x21+	adcs	x14,x14,x22+	adcs	x15,x15,x23+	adc	x16,x16,x24++	stp	x11,x12,[x2]+	stp	x13,x14,[x2,#16]+	stp	x15,x16,[x2,#32]++	add	sp,sp,#112+	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret+++.def	__mul_mont_383_nonred;+.type	32;+.endef+.p2align	5+__mul_mont_383_nonred:+	mul	x19,x11,x17+	mul	x20,x12,x17+	mul	x21,x13,x17+	mul	x22,x14,x17+	mul	x23,x15,x17+	mul	x24,x16,x17+	mul	x4,x4,x19++	umulh	x26,x11,x17+	umulh	x27,x12,x17+	umulh	x28,x13,x17+	umulh	x0,x14,x17+	umulh	x1,x15,x17+	umulh	x3,x16,x17++	adds	x20,x20,x26+	mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adc	x25,xzr,    x3+	mul	x3,x10,x4+	ldr	x17,[x2,8*1]+	adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adc	x25,x25,xzr++	ldr	x4,[x29,#96]+	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,xzr,xzr++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adc	x25,x25,xzr++	adds	x20,x20,x26+	mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adc	x25,x25,x3+	mul	x3,x10,x4+	ldr	x17,[x2,8*2]+	adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adc	x25,x25,xzr++	ldr	x4,[x29,#96]+	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,xzr,xzr++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adc	x25,x25,xzr++	adds	x20,x20,x26+	mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adc	x25,x25,x3+	mul	x3,x10,x4+	ldr	x17,[x2,8*3]+	adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adc	x25,x25,xzr++	ldr	x4,[x29,#96]+	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,xzr,xzr++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adc	x25,x25,xzr++	adds	x20,x20,x26+	mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adc	x25,x25,x3+	mul	x3,x10,x4+	ldr	x17,[x2,8*4]+	adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adc	x25,x25,xzr++	ldr	x4,[x29,#96]+	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,xzr,xzr++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adc	x25,x25,xzr++	adds	x20,x20,x26+	mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adc	x25,x25,x3+	mul	x3,x10,x4+	ldr	x17,[x2,8*5]+	adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adc	x25,x25,xzr++	ldr	x4,[x29,#96]+	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,xzr,xzr++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adc	x25,x25,xzr++	adds	x20,x20,x26+	mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adc	x25,x25,x3+	mul	x3,x10,x4+	adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adc	x25,x25,xzr+	ldp	x4,x2,[x29,#96]		// pull r_ptr++	adds	x11,x20,x26+	adcs	x12,x21,x27+	adcs	x13,x22,x28+	adcs	x14,x23,x0+	adcs	x15,x24,x1+	adcs	x16,x25,x3++	ret+++.globl	sgn0_pty_mont_384++.def	sgn0_pty_mont_384;+.type	32;+.endef+.p2align	5+sgn0_pty_mont_384:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]++	mov	x4,x2+	ldp	x5,x6,[x1]+	ldp	x7,x8,[x1,#16]+	ldp	x9,x10,[x1,#32]+	mov	x1,x0++	bl	__mul_by_1_mont_384+	ldr	x30,[x29,#8]++	and	x0,x11,#1+	adds	x11,x11,x11+	adcs	x12,x12,x12+	adcs	x13,x13,x13+	adcs	x14,x14,x14+	adcs	x15,x15,x15+	adcs	x16,x16,x16+	adc	x17,xzr,xzr++	subs	x11,x11,x5+	sbcs	x12,x12,x6+	sbcs	x13,x13,x7+	sbcs	x14,x14,x8+	sbcs	x15,x15,x9+	sbcs	x16,x16,x10+	sbc	x17,x17,xzr++	mvn	x17,x17+	and	x17,x17,#2+	orr	x0,x0,x17++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret+++.globl	sgn0_pty_mont_384x++.def	sgn0_pty_mont_384x;+.type	32;+.endef+.p2align	5+sgn0_pty_mont_384x:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]++	mov	x4,x2+	ldp	x5,x6,[x1]+	ldp	x7,x8,[x1,#16]+	ldp	x9,x10,[x1,#32]+	mov	x1,x0++	bl	__mul_by_1_mont_384+	add	x1,x1,#48++	and	x2,x11,#1+	orr	x3,x11,x12+	adds	x11,x11,x11+	orr	x3,x3,x13+	adcs	x12,x12,x12+	orr	x3,x3,x14+	adcs	x13,x13,x13+	orr	x3,x3,x15+	adcs	x14,x14,x14+	orr	x3,x3,x16+	adcs	x15,x15,x15+	adcs	x16,x16,x16+	adc	x17,xzr,xzr++	subs	x11,x11,x5+	sbcs	x12,x12,x6+	sbcs	x13,x13,x7+	sbcs	x14,x14,x8+	sbcs	x15,x15,x9+	sbcs	x16,x16,x10+	sbc	x17,x17,xzr++	mvn	x17,x17+	and	x17,x17,#2+	orr	x2,x2,x17++	bl	__mul_by_1_mont_384+	ldr	x30,[x29,#8]++	and	x0,x11,#1+	orr	x1,x11,x12+	adds	x11,x11,x11+	orr	x1,x1,x13+	adcs	x12,x12,x12+	orr	x1,x1,x14+	adcs	x13,x13,x13+	orr	x1,x1,x15+	adcs	x14,x14,x14+	orr	x1,x1,x16+	adcs	x15,x15,x15+	adcs	x16,x16,x16+	adc	x17,xzr,xzr++	subs	x11,x11,x5+	sbcs	x12,x12,x6+	sbcs	x13,x13,x7+	sbcs	x14,x14,x8+	sbcs	x15,x15,x9+	sbcs	x16,x16,x10+	sbc	x17,x17,xzr++	mvn	x17,x17+	and	x17,x17,#2+	orr	x0,x0,x17++	cmp	x3,#0+	csel	x3,x0,x2,eq	// a->re==0? prty(a->im) : prty(a->re)++	cmp	x1,#0+	csel	x1,x0,x2,ne	// a->im!=0? sgn0(a->im) : sgn0(a->re)++	and	x3,x3,#1+	and	x1,x1,#2+	orr	x0,x1,x3		// pack sign and parity++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret+
+ c-source/build/coff/mulq_mont_256-x86_64.s view
@@ -0,0 +1,872 @@+.text	++.globl	mul_mont_sparse_256++.def	mul_mont_sparse_256;	.scl 2;	.type 32;	.endef+.p2align	5+mul_mont_sparse_256:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_mul_mont_sparse_256:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+	movq	40(%rsp),%r8+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	pushq	%rdi++.LSEH_body_mul_mont_sparse_256:+++	movq	0(%rdx),%rax+	movq	0(%rsi),%r13+	movq	8(%rsi),%r14+	movq	16(%rsi),%r12+	movq	24(%rsi),%rbp+	movq	%rdx,%rbx++	movq	%rax,%r15+	mulq	%r13+	movq	%rax,%r9+	movq	%r15,%rax+	movq	%rdx,%r10+	call	__mulq_mont_sparse_256++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_mul_mont_sparse_256:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_mul_mont_sparse_256:++.globl	sqr_mont_sparse_256++.def	sqr_mont_sparse_256;	.scl 2;	.type 32;	.endef+.p2align	5+sqr_mont_sparse_256:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sqr_mont_sparse_256:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	pushq	%rdi++.LSEH_body_sqr_mont_sparse_256:+++	movq	0(%rsi),%rax+	movq	%rcx,%r8+	movq	8(%rsi),%r14+	movq	%rdx,%rcx+	movq	16(%rsi),%r12+	leaq	(%rsi),%rbx+	movq	24(%rsi),%rbp++	movq	%rax,%r15+	mulq	%rax+	movq	%rax,%r9+	movq	%r15,%rax+	movq	%rdx,%r10+	call	__mulq_mont_sparse_256++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_sqr_mont_sparse_256:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sqr_mont_sparse_256:+.def	__mulq_mont_sparse_256;	.scl 3;	.type 32;	.endef+.p2align	5+__mulq_mont_sparse_256:+	.byte	0xf3,0x0f,0x1e,0xfa++	mulq	%r14+	addq	%rax,%r10+	movq	%r15,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	%r12+	addq	%rax,%r11+	movq	%r15,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	%rbp+	addq	%rax,%r12+	movq	8(%rbx),%rax+	adcq	$0,%rdx+	xorq	%r14,%r14+	movq	%rdx,%r13++	movq	%r9,%rdi+	imulq	%r8,%r9+++	movq	%rax,%r15+	mulq	0(%rsi)+	addq	%rax,%r10+	movq	%r15,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	8(%rsi)+	addq	%rax,%r11+	movq	%r15,%rax+	adcq	$0,%rdx+	addq	%rbp,%r11+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rsi)+	addq	%rax,%r12+	movq	%r15,%rax+	adcq	$0,%rdx+	addq	%rbp,%r12+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rsi)+	addq	%rax,%r13+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	%rdx,%r14+	xorq	%r15,%r15+++	mulq	0(%rcx)+	addq	%rax,%rdi+	movq	%r9,%rax+	adcq	%rdx,%rdi++	mulq	8(%rcx)+	addq	%rax,%r10+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%rdi,%r10+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r11+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%rbp,%r11+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rax,%r12+	movq	16(%rbx),%rax+	adcq	$0,%rdx+	addq	%rbp,%r12+	adcq	$0,%rdx+	addq	%rdx,%r13+	adcq	$0,%r14+	adcq	$0,%r15+	movq	%r10,%rdi+	imulq	%r8,%r10+++	movq	%rax,%r9+	mulq	0(%rsi)+	addq	%rax,%r11+	movq	%r9,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	8(%rsi)+	addq	%rax,%r12+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%rbp,%r12+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rsi)+	addq	%rax,%r13+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rsi)+	addq	%rax,%r14+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%rbp,%r14+	adcq	%rdx,%r15+	xorq	%r9,%r9+++	mulq	0(%rcx)+	addq	%rax,%rdi+	movq	%r10,%rax+	adcq	%rdx,%rdi++	mulq	8(%rcx)+	addq	%rax,%r11+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%rdi,%r11+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r12+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%rbp,%r12+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rax,%r13+	movq	24(%rbx),%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	$0,%rdx+	addq	%rdx,%r14+	adcq	$0,%r15+	adcq	$0,%r9+	movq	%r11,%rdi+	imulq	%r8,%r11+++	movq	%rax,%r10+	mulq	0(%rsi)+	addq	%rax,%r12+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	8(%rsi)+	addq	%rax,%r13+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rsi)+	addq	%rax,%r14+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%rbp,%r14+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rsi)+	addq	%rax,%r15+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%rbp,%r15+	adcq	%rdx,%r9+	xorq	%r10,%r10+++	mulq	0(%rcx)+	addq	%rax,%rdi+	movq	%r11,%rax+	adcq	%rdx,%rdi++	mulq	8(%rcx)+	addq	%rax,%r12+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%rdi,%r12+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rax,%r14+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%rbp,%r14+	adcq	$0,%rdx+	addq	%rdx,%r15+	adcq	$0,%r9+	adcq	$0,%r10+	imulq	%r8,%rax+	movq	8(%rsp),%rsi+++	movq	%rax,%r11+	mulq	0(%rcx)+	addq	%rax,%r12+	movq	%r11,%rax+	adcq	%rdx,%r12++	mulq	8(%rcx)+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r12,%r13+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r14+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%rbp,%r14+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	movq	%r14,%rbx+	addq	%rbp,%r15+	adcq	$0,%rdx+	addq	%rax,%r15+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%rdx,%r9+	adcq	$0,%r10+++++	movq	%r15,%r12+	subq	0(%rcx),%r13+	sbbq	8(%rcx),%r14+	sbbq	16(%rcx),%r15+	movq	%r9,%rbp+	sbbq	24(%rcx),%r9+	sbbq	$0,%r10++	cmovcq	%rax,%r13+	cmovcq	%rbx,%r14+	cmovcq	%r12,%r15+	movq	%r13,0(%rsi)+	cmovcq	%rbp,%r9+	movq	%r14,8(%rsi)+	movq	%r15,16(%rsi)+	movq	%r9,24(%rsi)++	.byte	0xf3,0xc3+++.globl	from_mont_256++.def	from_mont_256;	.scl 2;	.type 32;	.endef+.p2align	5+from_mont_256:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_from_mont_256:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$8,%rsp++.LSEH_body_from_mont_256:+++	movq	%rdx,%rbx+	call	__mulq_by_1_mont_256++++++	movq	%r14,%r10+	movq	%r15,%r11+	movq	%r9,%r12++	subq	0(%rbx),%r13+	sbbq	8(%rbx),%r14+	sbbq	16(%rbx),%r15+	sbbq	24(%rbx),%r9++	cmovncq	%r13,%rax+	cmovncq	%r14,%r10+	cmovncq	%r15,%r11+	movq	%rax,0(%rdi)+	cmovncq	%r9,%r12+	movq	%r10,8(%rdi)+	movq	%r11,16(%rdi)+	movq	%r12,24(%rdi)++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_from_mont_256:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_from_mont_256:++.globl	redc_mont_256++.def	redc_mont_256;	.scl 2;	.type 32;	.endef+.p2align	5+redc_mont_256:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_redc_mont_256:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$8,%rsp++.LSEH_body_redc_mont_256:+++	movq	%rdx,%rbx+	call	__mulq_by_1_mont_256++	addq	32(%rsi),%r13+	adcq	40(%rsi),%r14+	movq	%r13,%rax+	adcq	48(%rsi),%r15+	movq	%r14,%r10+	adcq	56(%rsi),%r9+	sbbq	%rsi,%rsi+++++	movq	%r15,%r11+	subq	0(%rbx),%r13+	sbbq	8(%rbx),%r14+	sbbq	16(%rbx),%r15+	movq	%r9,%r12+	sbbq	24(%rbx),%r9+	sbbq	$0,%rsi++	cmovncq	%r13,%rax+	cmovncq	%r14,%r10+	cmovncq	%r15,%r11+	movq	%rax,0(%rdi)+	cmovncq	%r9,%r12+	movq	%r10,8(%rdi)+	movq	%r11,16(%rdi)+	movq	%r12,24(%rdi)++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_redc_mont_256:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_redc_mont_256:+.def	__mulq_by_1_mont_256;	.scl 3;	.type 32;	.endef+.p2align	5+__mulq_by_1_mont_256:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%rax+	movq	8(%rsi),%r10+	movq	16(%rsi),%r11+	movq	24(%rsi),%r12++	movq	%rax,%r13+	imulq	%rcx,%rax+	movq	%rax,%r9++	mulq	0(%rbx)+	addq	%rax,%r13+	movq	%r9,%rax+	adcq	%rdx,%r13++	mulq	8(%rbx)+	addq	%rax,%r10+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r13,%r10+	adcq	$0,%rdx+	movq	%rdx,%r13++	mulq	16(%rbx)+	movq	%r10,%r14+	imulq	%rcx,%r10+	addq	%rax,%r11+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r13,%r11+	adcq	$0,%rdx+	movq	%rdx,%r13++	mulq	24(%rbx)+	addq	%rax,%r12+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r13,%r12+	adcq	$0,%rdx+	movq	%rdx,%r13++	mulq	0(%rbx)+	addq	%rax,%r14+	movq	%r10,%rax+	adcq	%rdx,%r14++	mulq	8(%rbx)+	addq	%rax,%r11+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r14,%r11+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	16(%rbx)+	movq	%r11,%r15+	imulq	%rcx,%r11+	addq	%rax,%r12+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r14,%r12+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	24(%rbx)+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r14,%r13+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	0(%rbx)+	addq	%rax,%r15+	movq	%r11,%rax+	adcq	%rdx,%r15++	mulq	8(%rbx)+	addq	%rax,%r12+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r15,%r12+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	16(%rbx)+	movq	%r12,%r9+	imulq	%rcx,%r12+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r15,%r13+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	24(%rbx)+	addq	%rax,%r14+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r15,%r14+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	0(%rbx)+	addq	%rax,%r9+	movq	%r12,%rax+	adcq	%rdx,%r9++	mulq	8(%rbx)+	addq	%rax,%r13+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r9,%r13+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	16(%rbx)+	addq	%rax,%r14+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r9,%r14+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rbx)+	addq	%rax,%r15+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r9,%r15+	adcq	$0,%rdx+	movq	%rdx,%r9+	.byte	0xf3,0xc3++.section	.pdata+.p2align	2+.rva	.LSEH_begin_mul_mont_sparse_256+.rva	.LSEH_body_mul_mont_sparse_256+.rva	.LSEH_info_mul_mont_sparse_256_prologue++.rva	.LSEH_body_mul_mont_sparse_256+.rva	.LSEH_epilogue_mul_mont_sparse_256+.rva	.LSEH_info_mul_mont_sparse_256_body++.rva	.LSEH_epilogue_mul_mont_sparse_256+.rva	.LSEH_end_mul_mont_sparse_256+.rva	.LSEH_info_mul_mont_sparse_256_epilogue++.rva	.LSEH_begin_sqr_mont_sparse_256+.rva	.LSEH_body_sqr_mont_sparse_256+.rva	.LSEH_info_sqr_mont_sparse_256_prologue++.rva	.LSEH_body_sqr_mont_sparse_256+.rva	.LSEH_epilogue_sqr_mont_sparse_256+.rva	.LSEH_info_sqr_mont_sparse_256_body++.rva	.LSEH_epilogue_sqr_mont_sparse_256+.rva	.LSEH_end_sqr_mont_sparse_256+.rva	.LSEH_info_sqr_mont_sparse_256_epilogue++.rva	.LSEH_begin_from_mont_256+.rva	.LSEH_body_from_mont_256+.rva	.LSEH_info_from_mont_256_prologue++.rva	.LSEH_body_from_mont_256+.rva	.LSEH_epilogue_from_mont_256+.rva	.LSEH_info_from_mont_256_body++.rva	.LSEH_epilogue_from_mont_256+.rva	.LSEH_end_from_mont_256+.rva	.LSEH_info_from_mont_256_epilogue++.rva	.LSEH_begin_redc_mont_256+.rva	.LSEH_body_redc_mont_256+.rva	.LSEH_info_redc_mont_256_prologue++.rva	.LSEH_body_redc_mont_256+.rva	.LSEH_epilogue_redc_mont_256+.rva	.LSEH_info_redc_mont_256_body++.rva	.LSEH_epilogue_redc_mont_256+.rva	.LSEH_end_redc_mont_256+.rva	.LSEH_info_redc_mont_256_epilogue++.section	.xdata+.p2align	3+.LSEH_info_mul_mont_sparse_256_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_mul_mont_sparse_256_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_mul_mont_sparse_256_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sqr_mont_sparse_256_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sqr_mont_sparse_256_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_sqr_mont_sparse_256_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_from_mont_256_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_from_mont_256_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_from_mont_256_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_redc_mont_256_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_redc_mont_256_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_redc_mont_256_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00+
+ c-source/build/coff/mulq_mont_384-x86_64.s view
@@ -0,0 +1,4206 @@+.text	++++++++.def	__sub_mod_384x384;	.scl 3;	.type 32;	.endef+.p2align	5+__sub_mod_384x384:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	48(%rsi),%r14++	subq	0(%rdx),%r8+	movq	56(%rsi),%r15+	sbbq	8(%rdx),%r9+	movq	64(%rsi),%rax+	sbbq	16(%rdx),%r10+	movq	72(%rsi),%rbx+	sbbq	24(%rdx),%r11+	movq	80(%rsi),%rbp+	sbbq	32(%rdx),%r12+	movq	88(%rsi),%rsi+	sbbq	40(%rdx),%r13+	movq	%r8,0(%rdi)+	sbbq	48(%rdx),%r14+	movq	0(%rcx),%r8+	movq	%r9,8(%rdi)+	sbbq	56(%rdx),%r15+	movq	8(%rcx),%r9+	movq	%r10,16(%rdi)+	sbbq	64(%rdx),%rax+	movq	16(%rcx),%r10+	movq	%r11,24(%rdi)+	sbbq	72(%rdx),%rbx+	movq	24(%rcx),%r11+	movq	%r12,32(%rdi)+	sbbq	80(%rdx),%rbp+	movq	32(%rcx),%r12+	movq	%r13,40(%rdi)+	sbbq	88(%rdx),%rsi+	movq	40(%rcx),%r13+	sbbq	%rdx,%rdx++	andq	%rdx,%r8+	andq	%rdx,%r9+	andq	%rdx,%r10+	andq	%rdx,%r11+	andq	%rdx,%r12+	andq	%rdx,%r13++	addq	%r8,%r14+	adcq	%r9,%r15+	movq	%r14,48(%rdi)+	adcq	%r10,%rax+	movq	%r15,56(%rdi)+	adcq	%r11,%rbx+	movq	%rax,64(%rdi)+	adcq	%r12,%rbp+	movq	%rbx,72(%rdi)+	adcq	%r13,%rsi+	movq	%rbp,80(%rdi)+	movq	%rsi,88(%rdi)++	.byte	0xf3,0xc3+++.def	__add_mod_384;	.scl 3;	.type 32;	.endef+.p2align	5+__add_mod_384:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	addq	0(%rdx),%r8+	adcq	8(%rdx),%r9+	adcq	16(%rdx),%r10+	movq	%r8,%r14+	adcq	24(%rdx),%r11+	movq	%r9,%r15+	adcq	32(%rdx),%r12+	movq	%r10,%rax+	adcq	40(%rdx),%r13+	movq	%r11,%rbx+	sbbq	%rdx,%rdx++	subq	0(%rcx),%r8+	sbbq	8(%rcx),%r9+	movq	%r12,%rbp+	sbbq	16(%rcx),%r10+	sbbq	24(%rcx),%r11+	sbbq	32(%rcx),%r12+	movq	%r13,%rsi+	sbbq	40(%rcx),%r13+	sbbq	$0,%rdx++	cmovcq	%r14,%r8+	cmovcq	%r15,%r9+	cmovcq	%rax,%r10+	movq	%r8,0(%rdi)+	cmovcq	%rbx,%r11+	movq	%r9,8(%rdi)+	cmovcq	%rbp,%r12+	movq	%r10,16(%rdi)+	cmovcq	%rsi,%r13+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3+++.def	__sub_mod_384;	.scl 3;	.type 32;	.endef+.p2align	5+__sub_mod_384:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++__sub_mod_384_a_is_loaded:+	subq	0(%rdx),%r8+	movq	0(%rcx),%r14+	sbbq	8(%rdx),%r9+	movq	8(%rcx),%r15+	sbbq	16(%rdx),%r10+	movq	16(%rcx),%rax+	sbbq	24(%rdx),%r11+	movq	24(%rcx),%rbx+	sbbq	32(%rdx),%r12+	movq	32(%rcx),%rbp+	sbbq	40(%rdx),%r13+	movq	40(%rcx),%rsi+	sbbq	%rdx,%rdx++	andq	%rdx,%r14+	andq	%rdx,%r15+	andq	%rdx,%rax+	andq	%rdx,%rbx+	andq	%rdx,%rbp+	andq	%rdx,%rsi++	addq	%r14,%r8+	adcq	%r15,%r9+	movq	%r8,0(%rdi)+	adcq	%rax,%r10+	movq	%r9,8(%rdi)+	adcq	%rbx,%r11+	movq	%r10,16(%rdi)+	adcq	%rbp,%r12+	movq	%r11,24(%rdi)+	adcq	%rsi,%r13+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3++.globl	mul_mont_384x++.def	mul_mont_384x;	.scl 2;	.type 32;	.endef+.p2align	5+mul_mont_384x:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_mul_mont_384x:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+	movq	40(%rsp),%r8+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$328,%rsp++.LSEH_body_mul_mont_384x:+++	movq	%rdx,%rbx+	movq	%rdi,32(%rsp)+	movq	%rsi,24(%rsp)+	movq	%rdx,16(%rsp)+	movq	%rcx,8(%rsp)+	movq	%r8,0(%rsp)+++++	leaq	40(%rsp),%rdi+	call	__mulq_384+++	leaq	48(%rbx),%rbx+	leaq	48(%rsi),%rsi+	leaq	40+96(%rsp),%rdi+	call	__mulq_384+++	movq	8(%rsp),%rcx+	leaq	-48(%rsi),%rdx+	leaq	40+192+48(%rsp),%rdi+	call	__add_mod_384++	movq	16(%rsp),%rsi+	leaq	48(%rsi),%rdx+	leaq	-48(%rdi),%rdi+	call	__add_mod_384++	leaq	(%rdi),%rbx+	leaq	48(%rdi),%rsi+	call	__mulq_384+++	leaq	(%rdi),%rsi+	leaq	40(%rsp),%rdx+	movq	8(%rsp),%rcx+	call	__sub_mod_384x384++	leaq	(%rdi),%rsi+	leaq	-96(%rdi),%rdx+	call	__sub_mod_384x384+++	leaq	40(%rsp),%rsi+	leaq	40+96(%rsp),%rdx+	leaq	40(%rsp),%rdi+	call	__sub_mod_384x384++	movq	%rcx,%rbx+++	leaq	40(%rsp),%rsi+	movq	0(%rsp),%rcx+	movq	32(%rsp),%rdi+	call	__mulq_by_1_mont_384+	call	__redc_tail_mont_384+++	leaq	40+192(%rsp),%rsi+	movq	0(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__mulq_by_1_mont_384+	call	__redc_tail_mont_384++	leaq	328(%rsp),%r8+	movq	0(%r8),%r15++	movq	8(%r8),%r14++	movq	16(%r8),%r13++	movq	24(%r8),%r12++	movq	32(%r8),%rbx++	movq	40(%r8),%rbp++	leaq	48(%r8),%rsp++.LSEH_epilogue_mul_mont_384x:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_mul_mont_384x:+.globl	sqr_mont_384x++.def	sqr_mont_384x;	.scl 2;	.type 32;	.endef+.p2align	5+sqr_mont_384x:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sqr_mont_384x:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$136,%rsp++.LSEH_body_sqr_mont_384x:+++	movq	%rcx,0(%rsp)+	movq	%rdx,%rcx+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+++	leaq	48(%rsi),%rdx+	leaq	32(%rsp),%rdi+	call	__add_mod_384+++	movq	16(%rsp),%rsi+	leaq	48(%rsi),%rdx+	leaq	32+48(%rsp),%rdi+	call	__sub_mod_384+++	movq	16(%rsp),%rsi+	leaq	48(%rsi),%rbx++	movq	48(%rsi),%rax+	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%r12+	movq	24(%rsi),%r13++	call	__mulq_mont_384+	addq	%r14,%r14+	adcq	%r15,%r15+	adcq	%r8,%r8+	movq	%r14,%r12+	adcq	%r9,%r9+	movq	%r15,%r13+	adcq	%r10,%r10+	movq	%r8,%rax+	adcq	%r11,%r11+	movq	%r9,%rbx+	sbbq	%rdx,%rdx++	subq	0(%rcx),%r14+	sbbq	8(%rcx),%r15+	movq	%r10,%rbp+	sbbq	16(%rcx),%r8+	sbbq	24(%rcx),%r9+	sbbq	32(%rcx),%r10+	movq	%r11,%rsi+	sbbq	40(%rcx),%r11+	sbbq	$0,%rdx++	cmovcq	%r12,%r14+	cmovcq	%r13,%r15+	cmovcq	%rax,%r8+	movq	%r14,48(%rdi)+	cmovcq	%rbx,%r9+	movq	%r15,56(%rdi)+	cmovcq	%rbp,%r10+	movq	%r8,64(%rdi)+	cmovcq	%rsi,%r11+	movq	%r9,72(%rdi)+	movq	%r10,80(%rdi)+	movq	%r11,88(%rdi)++	leaq	32(%rsp),%rsi+	leaq	32+48(%rsp),%rbx++	movq	32+48(%rsp),%rax+	movq	32+0(%rsp),%r14+	movq	32+8(%rsp),%r15+	movq	32+16(%rsp),%r12+	movq	32+24(%rsp),%r13++	call	__mulq_mont_384++	leaq	136(%rsp),%r8+	movq	0(%r8),%r15++	movq	8(%r8),%r14++	movq	16(%r8),%r13++	movq	24(%r8),%r12++	movq	32(%r8),%rbx++	movq	40(%r8),%rbp++	leaq	48(%r8),%rsp++.LSEH_epilogue_sqr_mont_384x:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sqr_mont_384x:++.globl	mul_382x++.def	mul_382x;	.scl 2;	.type 32;	.endef+.p2align	5+mul_382x:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_mul_382x:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$136,%rsp++.LSEH_body_mul_382x:+++	leaq	96(%rdi),%rdi+	movq	%rsi,0(%rsp)+	movq	%rdx,8(%rsp)+	movq	%rdi,16(%rsp)+	movq	%rcx,24(%rsp)+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	addq	48(%rsi),%r8+	adcq	56(%rsi),%r9+	adcq	64(%rsi),%r10+	adcq	72(%rsi),%r11+	adcq	80(%rsi),%r12+	adcq	88(%rsi),%r13++	movq	%r8,32+0(%rsp)+	movq	%r9,32+8(%rsp)+	movq	%r10,32+16(%rsp)+	movq	%r11,32+24(%rsp)+	movq	%r12,32+32(%rsp)+	movq	%r13,32+40(%rsp)+++	movq	0(%rdx),%r8+	movq	8(%rdx),%r9+	movq	16(%rdx),%r10+	movq	24(%rdx),%r11+	movq	32(%rdx),%r12+	movq	40(%rdx),%r13++	addq	48(%rdx),%r8+	adcq	56(%rdx),%r9+	adcq	64(%rdx),%r10+	adcq	72(%rdx),%r11+	adcq	80(%rdx),%r12+	adcq	88(%rdx),%r13++	movq	%r8,32+48(%rsp)+	movq	%r9,32+56(%rsp)+	movq	%r10,32+64(%rsp)+	movq	%r11,32+72(%rsp)+	movq	%r12,32+80(%rsp)+	movq	%r13,32+88(%rsp)+++	leaq	32+0(%rsp),%rsi+	leaq	32+48(%rsp),%rbx+	call	__mulq_384+++	movq	0(%rsp),%rsi+	movq	8(%rsp),%rbx+	leaq	-96(%rdi),%rdi+	call	__mulq_384+++	leaq	48(%rsi),%rsi+	leaq	48(%rbx),%rbx+	leaq	32(%rsp),%rdi+	call	__mulq_384+++	movq	16(%rsp),%rsi+	leaq	32(%rsp),%rdx+	movq	24(%rsp),%rcx+	movq	%rsi,%rdi+	call	__sub_mod_384x384+++	leaq	0(%rdi),%rsi+	leaq	-96(%rdi),%rdx+	call	__sub_mod_384x384+++	leaq	-96(%rdi),%rsi+	leaq	32(%rsp),%rdx+	leaq	-96(%rdi),%rdi+	call	__sub_mod_384x384++	leaq	136(%rsp),%r8+	movq	0(%r8),%r15++	movq	8(%r8),%r14++	movq	16(%r8),%r13++	movq	24(%r8),%r12++	movq	32(%r8),%rbx++	movq	40(%r8),%rbp++	leaq	48(%r8),%rsp++.LSEH_epilogue_mul_382x:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_mul_382x:+.globl	sqr_382x++.def	sqr_382x;	.scl 2;	.type 32;	.endef+.p2align	5+sqr_382x:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sqr_382x:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	pushq	%rsi++.LSEH_body_sqr_382x:+++	movq	%rdx,%rcx+++	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%rax+	movq	24(%rsi),%rbx+	movq	32(%rsi),%rbp+	movq	40(%rsi),%rdx++	movq	%r14,%r8+	addq	48(%rsi),%r14+	movq	%r15,%r9+	adcq	56(%rsi),%r15+	movq	%rax,%r10+	adcq	64(%rsi),%rax+	movq	%rbx,%r11+	adcq	72(%rsi),%rbx+	movq	%rbp,%r12+	adcq	80(%rsi),%rbp+	movq	%rdx,%r13+	adcq	88(%rsi),%rdx++	movq	%r14,0(%rdi)+	movq	%r15,8(%rdi)+	movq	%rax,16(%rdi)+	movq	%rbx,24(%rdi)+	movq	%rbp,32(%rdi)+	movq	%rdx,40(%rdi)+++	leaq	48(%rsi),%rdx+	leaq	48(%rdi),%rdi+	call	__sub_mod_384_a_is_loaded+++	leaq	(%rdi),%rsi+	leaq	-48(%rdi),%rbx+	leaq	-48(%rdi),%rdi+	call	__mulq_384+++	movq	(%rsp),%rsi+	leaq	48(%rsi),%rbx+	leaq	96(%rdi),%rdi+	call	__mulq_384++	movq	0(%rdi),%r8+	movq	8(%rdi),%r9+	movq	16(%rdi),%r10+	movq	24(%rdi),%r11+	movq	32(%rdi),%r12+	movq	40(%rdi),%r13+	movq	48(%rdi),%r14+	movq	56(%rdi),%r15+	movq	64(%rdi),%rax+	movq	72(%rdi),%rbx+	movq	80(%rdi),%rbp+	addq	%r8,%r8+	movq	88(%rdi),%rdx+	adcq	%r9,%r9+	movq	%r8,0(%rdi)+	adcq	%r10,%r10+	movq	%r9,8(%rdi)+	adcq	%r11,%r11+	movq	%r10,16(%rdi)+	adcq	%r12,%r12+	movq	%r11,24(%rdi)+	adcq	%r13,%r13+	movq	%r12,32(%rdi)+	adcq	%r14,%r14+	movq	%r13,40(%rdi)+	adcq	%r15,%r15+	movq	%r14,48(%rdi)+	adcq	%rax,%rax+	movq	%r15,56(%rdi)+	adcq	%rbx,%rbx+	movq	%rax,64(%rdi)+	adcq	%rbp,%rbp+	movq	%rbx,72(%rdi)+	adcq	%rdx,%rdx+	movq	%rbp,80(%rdi)+	movq	%rdx,88(%rdi)++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_sqr_382x:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sqr_382x:+.globl	mul_384++.def	mul_384;	.scl 2;	.type 32;	.endef+.p2align	5+mul_384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_mul_384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++.LSEH_body_mul_384:+++	movq	%rdx,%rbx+	call	__mulq_384++	movq	0(%rsp),%r12++	movq	8(%rsp),%rbx++	movq	16(%rsp),%rbp++	leaq	24(%rsp),%rsp++.LSEH_epilogue_mul_384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_mul_384:++.def	__mulq_384;	.scl 3;	.type 32;	.endef+.p2align	5+__mulq_384:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rbx),%rax++	movq	%rax,%rbp+	mulq	0(%rsi)+	movq	%rax,0(%rdi)+	movq	%rbp,%rax+	movq	%rdx,%rcx++	mulq	8(%rsi)+	addq	%rax,%rcx+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rsi)+	addq	%rax,%r8+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rsi)+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rsi)+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rsi)+	addq	%rax,%r11+	movq	8(%rbx),%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%rcx+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rcx,8(%rdi)+	movq	%rdx,%rcx++	mulq	8(%rsi)+	addq	%rax,%r8+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%rcx+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rsi)+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r8+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rsi)+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r9+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rsi)+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r10+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rsi)+	addq	%rax,%r12+	movq	16(%rbx),%rax+	adcq	$0,%rdx+	addq	%r12,%r11+	adcq	$0,%rdx+	movq	%rdx,%r12+	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%rcx+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rcx,16(%rdi)+	movq	%rdx,%rcx++	mulq	8(%rsi)+	addq	%rax,%r8+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%rcx+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rsi)+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r8+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rsi)+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r9+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rsi)+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r10+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rsi)+	addq	%rax,%r12+	movq	24(%rbx),%rax+	adcq	$0,%rdx+	addq	%r12,%r11+	adcq	$0,%rdx+	movq	%rdx,%r12+	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%rcx+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rcx,24(%rdi)+	movq	%rdx,%rcx++	mulq	8(%rsi)+	addq	%rax,%r8+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%rcx+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rsi)+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r8+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rsi)+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r9+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rsi)+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r10+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rsi)+	addq	%rax,%r12+	movq	32(%rbx),%rax+	adcq	$0,%rdx+	addq	%r12,%r11+	adcq	$0,%rdx+	movq	%rdx,%r12+	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%rcx+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rcx,32(%rdi)+	movq	%rdx,%rcx++	mulq	8(%rsi)+	addq	%rax,%r8+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%rcx+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rsi)+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r8+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rsi)+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r9+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rsi)+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r10+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rsi)+	addq	%rax,%r12+	movq	40(%rbx),%rax+	adcq	$0,%rdx+	addq	%r12,%r11+	adcq	$0,%rdx+	movq	%rdx,%r12+	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%rcx+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rcx,40(%rdi)+	movq	%rdx,%rcx++	mulq	8(%rsi)+	addq	%rax,%r8+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%rcx+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rsi)+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r8+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rsi)+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r9+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rsi)+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r10+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rsi)+	addq	%rax,%r12+	movq	%rax,%rax+	adcq	$0,%rdx+	addq	%r12,%r11+	adcq	$0,%rdx+	movq	%rdx,%r12+	movq	%rcx,48(%rdi)+	movq	%r8,56(%rdi)+	movq	%r9,64(%rdi)+	movq	%r10,72(%rdi)+	movq	%r11,80(%rdi)+	movq	%r12,88(%rdi)++	.byte	0xf3,0xc3++.globl	sqr_384++.def	sqr_384;	.scl 2;	.type 32;	.endef+.p2align	5+sqr_384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sqr_384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$8,%rsp++.LSEH_body_sqr_384:+++	call	__sqrq_384++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_sqr_384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sqr_384:++.def	__sqrq_384;	.scl 3;	.type 32;	.endef+.p2align	5+__sqrq_384:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%rax+	movq	8(%rsi),%r15+	movq	16(%rsi),%rcx+	movq	24(%rsi),%rbx+++	movq	%rax,%r14+	mulq	%r15+	movq	%rax,%r9+	movq	%r14,%rax+	movq	32(%rsi),%rbp+	movq	%rdx,%r10++	mulq	%rcx+	addq	%rax,%r10+	movq	%r14,%rax+	adcq	$0,%rdx+	movq	40(%rsi),%rsi+	movq	%rdx,%r11++	mulq	%rbx+	addq	%rax,%r11+	movq	%r14,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	%rbp+	addq	%rax,%r12+	movq	%r14,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13++	mulq	%rsi+	addq	%rax,%r13+	movq	%r14,%rax+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	%rax+	xorq	%r8,%r8+	movq	%rax,0(%rdi)+	movq	%r15,%rax+	addq	%r9,%r9+	adcq	$0,%r8+	addq	%rdx,%r9+	adcq	$0,%r8+	movq	%r9,8(%rdi)++	mulq	%rcx+	addq	%rax,%r11+	movq	%r15,%rax+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	%rbx+	addq	%rax,%r12+	movq	%r15,%rax+	adcq	$0,%rdx+	addq	%r9,%r12+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	%rbp+	addq	%rax,%r13+	movq	%r15,%rax+	adcq	$0,%rdx+	addq	%r9,%r13+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	%rsi+	addq	%rax,%r14+	movq	%r15,%rax+	adcq	$0,%rdx+	addq	%r9,%r14+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	%rax+	xorq	%r9,%r9+	addq	%rax,%r8+	movq	%rcx,%rax+	addq	%r10,%r10+	adcq	%r11,%r11+	adcq	$0,%r9+	addq	%r8,%r10+	adcq	%rdx,%r11+	adcq	$0,%r9+	movq	%r10,16(%rdi)++	mulq	%rbx+	addq	%rax,%r13+	movq	%rcx,%rax+	adcq	$0,%rdx+	movq	%r11,24(%rdi)+	movq	%rdx,%r8++	mulq	%rbp+	addq	%rax,%r14+	movq	%rcx,%rax+	adcq	$0,%rdx+	addq	%r8,%r14+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	%rsi+	addq	%rax,%r15+	movq	%rcx,%rax+	adcq	$0,%rdx+	addq	%r8,%r15+	adcq	$0,%rdx+	movq	%rdx,%rcx++	mulq	%rax+	xorq	%r11,%r11+	addq	%rax,%r9+	movq	%rbx,%rax+	addq	%r12,%r12+	adcq	%r13,%r13+	adcq	$0,%r11+	addq	%r9,%r12+	adcq	%rdx,%r13+	adcq	$0,%r11+	movq	%r12,32(%rdi)+++	mulq	%rbp+	addq	%rax,%r15+	movq	%rbx,%rax+	adcq	$0,%rdx+	movq	%r13,40(%rdi)+	movq	%rdx,%r8++	mulq	%rsi+	addq	%rax,%rcx+	movq	%rbx,%rax+	adcq	$0,%rdx+	addq	%r8,%rcx+	adcq	$0,%rdx+	movq	%rdx,%rbx++	mulq	%rax+	xorq	%r12,%r12+	addq	%rax,%r11+	movq	%rbp,%rax+	addq	%r14,%r14+	adcq	%r15,%r15+	adcq	$0,%r12+	addq	%r11,%r14+	adcq	%rdx,%r15+	movq	%r14,48(%rdi)+	adcq	$0,%r12+	movq	%r15,56(%rdi)+++	mulq	%rsi+	addq	%rax,%rbx+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	%rax+	xorq	%r13,%r13+	addq	%rax,%r12+	movq	%rsi,%rax+	addq	%rcx,%rcx+	adcq	%rbx,%rbx+	adcq	$0,%r13+	addq	%r12,%rcx+	adcq	%rdx,%rbx+	movq	%rcx,64(%rdi)+	adcq	$0,%r13+	movq	%rbx,72(%rdi)+++	mulq	%rax+	addq	%r13,%rax+	addq	%rbp,%rbp+	adcq	$0,%rdx+	addq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rax,80(%rdi)+	movq	%rdx,88(%rdi)++	.byte	0xf3,0xc3+++.globl	sqr_mont_384++.def	sqr_mont_384;	.scl 2;	.type 32;	.endef+.p2align	5+sqr_mont_384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sqr_mont_384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$120,%rsp++.LSEH_body_sqr_mont_384:+++	movq	%rcx,96(%rsp)+	movq	%rdx,104(%rsp)+	movq	%rdi,112(%rsp)++	movq	%rsp,%rdi+	call	__sqrq_384++	leaq	0(%rsp),%rsi+	movq	96(%rsp),%rcx+	movq	104(%rsp),%rbx+	movq	112(%rsp),%rdi+	call	__mulq_by_1_mont_384+	call	__redc_tail_mont_384++	leaq	120(%rsp),%r8+	movq	120(%rsp),%r15++	movq	8(%r8),%r14++	movq	16(%r8),%r13++	movq	24(%r8),%r12++	movq	32(%r8),%rbx++	movq	40(%r8),%rbp++	leaq	48(%r8),%rsp++.LSEH_epilogue_sqr_mont_384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sqr_mont_384:++++.globl	redc_mont_384++.def	redc_mont_384;	.scl 2;	.type 32;	.endef+.p2align	5+redc_mont_384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_redc_mont_384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$8,%rsp++.LSEH_body_redc_mont_384:+++	movq	%rdx,%rbx+	call	__mulq_by_1_mont_384+	call	__redc_tail_mont_384++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_redc_mont_384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_redc_mont_384:+++++.globl	from_mont_384++.def	from_mont_384;	.scl 2;	.type 32;	.endef+.p2align	5+from_mont_384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_from_mont_384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$8,%rsp++.LSEH_body_from_mont_384:+++	movq	%rdx,%rbx+	call	__mulq_by_1_mont_384++++++	movq	%r15,%rcx+	movq	%r8,%rdx+	movq	%r9,%rbp++	subq	0(%rbx),%r14+	sbbq	8(%rbx),%r15+	movq	%r10,%r13+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	movq	%r11,%rsi+	sbbq	40(%rbx),%r11++	cmovcq	%rax,%r14+	cmovcq	%rcx,%r15+	cmovcq	%rdx,%r8+	movq	%r14,0(%rdi)+	cmovcq	%rbp,%r9+	movq	%r15,8(%rdi)+	cmovcq	%r13,%r10+	movq	%r8,16(%rdi)+	cmovcq	%rsi,%r11+	movq	%r9,24(%rdi)+	movq	%r10,32(%rdi)+	movq	%r11,40(%rdi)++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_from_mont_384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_from_mont_384:+.def	__mulq_by_1_mont_384;	.scl 3;	.type 32;	.endef+.p2align	5+__mulq_by_1_mont_384:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%rax+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rax,%r14+	imulq	%rcx,%rax+	movq	%rax,%r8++	mulq	0(%rbx)+	addq	%rax,%r14+	movq	%r8,%rax+	adcq	%rdx,%r14++	mulq	8(%rbx)+	addq	%rax,%r9+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%r14,%r9+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	16(%rbx)+	addq	%rax,%r10+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%r14,%r10+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	24(%rbx)+	addq	%rax,%r11+	movq	%r8,%rax+	adcq	$0,%rdx+	movq	%r9,%r15+	imulq	%rcx,%r9+	addq	%r14,%r11+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	32(%rbx)+	addq	%rax,%r12+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%r14,%r12+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	40(%rbx)+	addq	%rax,%r13+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r14,%r13+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	0(%rbx)+	addq	%rax,%r15+	movq	%r9,%rax+	adcq	%rdx,%r15++	mulq	8(%rbx)+	addq	%rax,%r10+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r15,%r10+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	16(%rbx)+	addq	%rax,%r11+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r15,%r11+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	24(%rbx)+	addq	%rax,%r12+	movq	%r9,%rax+	adcq	$0,%rdx+	movq	%r10,%r8+	imulq	%rcx,%r10+	addq	%r15,%r12+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	32(%rbx)+	addq	%rax,%r13+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r15,%r13+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	40(%rbx)+	addq	%rax,%r14+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r15,%r14+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	0(%rbx)+	addq	%rax,%r8+	movq	%r10,%rax+	adcq	%rdx,%r8++	mulq	8(%rbx)+	addq	%rax,%r11+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r8,%r11+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rbx)+	addq	%rax,%r12+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r8,%r12+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	24(%rbx)+	addq	%rax,%r13+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%r11,%r9+	imulq	%rcx,%r11+	addq	%r8,%r13+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	32(%rbx)+	addq	%rax,%r14+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r8,%r14+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	40(%rbx)+	addq	%rax,%r15+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r8,%r15+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	0(%rbx)+	addq	%rax,%r9+	movq	%r11,%rax+	adcq	%rdx,%r9++	mulq	8(%rbx)+	addq	%rax,%r12+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r9,%r12+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	16(%rbx)+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r9,%r13+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rbx)+	addq	%rax,%r14+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%r12,%r10+	imulq	%rcx,%r12+	addq	%r9,%r14+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	32(%rbx)+	addq	%rax,%r15+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r9,%r15+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	40(%rbx)+	addq	%rax,%r8+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r9,%r8+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	0(%rbx)+	addq	%rax,%r10+	movq	%r12,%rax+	adcq	%rdx,%r10++	mulq	8(%rbx)+	addq	%rax,%r13+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r10,%r13+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	16(%rbx)+	addq	%rax,%r14+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r10,%r14+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	24(%rbx)+	addq	%rax,%r15+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%r13,%r11+	imulq	%rcx,%r13+	addq	%r10,%r15+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rbx)+	addq	%rax,%r8+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r10,%r8+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	40(%rbx)+	addq	%rax,%r9+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r10,%r9+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	0(%rbx)+	addq	%rax,%r11+	movq	%r13,%rax+	adcq	%rdx,%r11++	mulq	8(%rbx)+	addq	%rax,%r14+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r11,%r14+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	16(%rbx)+	addq	%rax,%r15+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r11,%r15+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	24(%rbx)+	addq	%rax,%r8+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r11,%r8+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	32(%rbx)+	addq	%rax,%r9+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r11,%r9+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rbx)+	addq	%rax,%r10+	movq	%r14,%rax+	adcq	$0,%rdx+	addq	%r11,%r10+	adcq	$0,%rdx+	movq	%rdx,%r11+	.byte	0xf3,0xc3+++.def	__redc_tail_mont_384;	.scl 3;	.type 32;	.endef+.p2align	5+__redc_tail_mont_384:+	.byte	0xf3,0x0f,0x1e,0xfa++	addq	48(%rsi),%r14+	movq	%r14,%rax+	adcq	56(%rsi),%r15+	adcq	64(%rsi),%r8+	adcq	72(%rsi),%r9+	movq	%r15,%rcx+	adcq	80(%rsi),%r10+	adcq	88(%rsi),%r11+	sbbq	%r12,%r12+++++	movq	%r8,%rdx+	movq	%r9,%rbp++	subq	0(%rbx),%r14+	sbbq	8(%rbx),%r15+	movq	%r10,%r13+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	movq	%r11,%rsi+	sbbq	40(%rbx),%r11+	sbbq	$0,%r12++	cmovcq	%rax,%r14+	cmovcq	%rcx,%r15+	cmovcq	%rdx,%r8+	movq	%r14,0(%rdi)+	cmovcq	%rbp,%r9+	movq	%r15,8(%rdi)+	cmovcq	%r13,%r10+	movq	%r8,16(%rdi)+	cmovcq	%rsi,%r11+	movq	%r9,24(%rdi)+	movq	%r10,32(%rdi)+	movq	%r11,40(%rdi)++	.byte	0xf3,0xc3+++.globl	sgn0_pty_mont_384++.def	sgn0_pty_mont_384;	.scl 2;	.type 32;	.endef+.p2align	5+sgn0_pty_mont_384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sgn0_pty_mont_384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$8,%rsp++.LSEH_body_sgn0_pty_mont_384:+++	movq	%rsi,%rbx+	leaq	0(%rdi),%rsi+	movq	%rdx,%rcx+	call	__mulq_by_1_mont_384++	xorq	%rax,%rax+	movq	%r14,%r13+	addq	%r14,%r14+	adcq	%r15,%r15+	adcq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	$0,%rax++	subq	0(%rbx),%r14+	sbbq	8(%rbx),%r15+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	sbbq	40(%rbx),%r11+	sbbq	$0,%rax++	notq	%rax+	andq	$1,%r13+	andq	$2,%rax+	orq	%r13,%rax++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_sgn0_pty_mont_384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sgn0_pty_mont_384:++.globl	sgn0_pty_mont_384x++.def	sgn0_pty_mont_384x;	.scl 2;	.type 32;	.endef+.p2align	5+sgn0_pty_mont_384x:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sgn0_pty_mont_384x:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$8,%rsp++.LSEH_body_sgn0_pty_mont_384x:+++	movq	%rsi,%rbx+	leaq	48(%rdi),%rsi+	movq	%rdx,%rcx+	call	__mulq_by_1_mont_384++	movq	%r14,%r12+	orq	%r15,%r14+	orq	%r8,%r14+	orq	%r9,%r14+	orq	%r10,%r14+	orq	%r11,%r14++	leaq	0(%rdi),%rsi+	xorq	%rdi,%rdi+	movq	%r12,%r13+	addq	%r12,%r12+	adcq	%r15,%r15+	adcq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	$0,%rdi++	subq	0(%rbx),%r12+	sbbq	8(%rbx),%r15+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	sbbq	40(%rbx),%r11+	sbbq	$0,%rdi++	movq	%r14,0(%rsp)+	notq	%rdi+	andq	$1,%r13+	andq	$2,%rdi+	orq	%r13,%rdi++	call	__mulq_by_1_mont_384++	movq	%r14,%r12+	orq	%r15,%r14+	orq	%r8,%r14+	orq	%r9,%r14+	orq	%r10,%r14+	orq	%r11,%r14++	xorq	%rax,%rax+	movq	%r12,%r13+	addq	%r12,%r12+	adcq	%r15,%r15+	adcq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	$0,%rax++	subq	0(%rbx),%r12+	sbbq	8(%rbx),%r15+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	sbbq	40(%rbx),%r11+	sbbq	$0,%rax++	movq	0(%rsp),%r12++	notq	%rax++	testq	%r14,%r14+	cmovzq	%rdi,%r13++	testq	%r12,%r12+	cmovnzq	%rdi,%rax++	andq	$1,%r13+	andq	$2,%rax+	orq	%r13,%rax++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_sgn0_pty_mont_384x:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sgn0_pty_mont_384x:+.globl	mul_mont_384++.def	mul_mont_384;	.scl 2;	.type 32;	.endef+.p2align	5+mul_mont_384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_mul_mont_384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+	movq	40(%rsp),%r8+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$24,%rsp++.LSEH_body_mul_mont_384:+++	movq	0(%rdx),%rax+	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%r12+	movq	24(%rsi),%r13+	movq	%rdx,%rbx+	movq	%r8,0(%rsp)+	movq	%rdi,8(%rsp)++	call	__mulq_mont_384++	movq	24(%rsp),%r15++	movq	32(%rsp),%r14++	movq	40(%rsp),%r13++	movq	48(%rsp),%r12++	movq	56(%rsp),%rbx++	movq	64(%rsp),%rbp++	leaq	72(%rsp),%rsp++.LSEH_epilogue_mul_mont_384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_mul_mont_384:+.def	__mulq_mont_384;	.scl 3;	.type 32;	.endef+.p2align	5+__mulq_mont_384:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	%rax,%rdi+	mulq	%r14+	movq	%rax,%r8+	movq	%rdi,%rax+	movq	%rdx,%r9++	mulq	%r15+	addq	%rax,%r9+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	%r12+	addq	%rax,%r10+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11++	movq	%r8,%rbp+	imulq	8(%rsp),%r8++	mulq	%r13+	addq	%rax,%r11+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	32(%rsi)+	addq	%rax,%r12+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13++	mulq	40(%rsi)+	addq	%rax,%r13+	movq	%r8,%rax+	adcq	$0,%rdx+	xorq	%r15,%r15+	movq	%rdx,%r14++	mulq	0(%rcx)+	addq	%rax,%rbp+	movq	%r8,%rax+	adcq	%rdx,%rbp++	mulq	8(%rcx)+	addq	%rax,%r9+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%rbp,%r9+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r10+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%rbp,%r10+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rbp,%r11+	adcq	$0,%rdx+	addq	%rax,%r11+	movq	%r8,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	32(%rcx)+	addq	%rax,%r12+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%rbp,%r12+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	40(%rcx)+	addq	%rax,%r13+	movq	8(%rbx),%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	%rdx,%r14+	adcq	$0,%r15++	movq	%rax,%rdi+	mulq	0(%rsi)+	addq	%rax,%r9+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	8(%rsi)+	addq	%rax,%r10+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r8,%r10+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rsi)+	addq	%rax,%r11+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r8,%r11+	adcq	$0,%rdx+	movq	%rdx,%r8++	movq	%r9,%rbp+	imulq	8(%rsp),%r9++	mulq	24(%rsi)+	addq	%rax,%r12+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r8,%r12+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	32(%rsi)+	addq	%rax,%r13+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r8,%r13+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	40(%rsi)+	addq	%r8,%r14+	adcq	$0,%rdx+	xorq	%r8,%r8+	addq	%rax,%r14+	movq	%r9,%rax+	adcq	%rdx,%r15+	adcq	$0,%r8++	mulq	0(%rcx)+	addq	%rax,%rbp+	movq	%r9,%rax+	adcq	%rdx,%rbp++	mulq	8(%rcx)+	addq	%rax,%r10+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%rbp,%r10+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r11+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%rbp,%r11+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rbp,%r12+	adcq	$0,%rdx+	addq	%rax,%r12+	movq	%r9,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	32(%rcx)+	addq	%rax,%r13+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	40(%rcx)+	addq	%rax,%r14+	movq	16(%rbx),%rax+	adcq	$0,%rdx+	addq	%rbp,%r14+	adcq	%rdx,%r15+	adcq	$0,%r8++	movq	%rax,%rdi+	mulq	0(%rsi)+	addq	%rax,%r10+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	8(%rsi)+	addq	%rax,%r11+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r9,%r11+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	16(%rsi)+	addq	%rax,%r12+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r9,%r12+	adcq	$0,%rdx+	movq	%rdx,%r9++	movq	%r10,%rbp+	imulq	8(%rsp),%r10++	mulq	24(%rsi)+	addq	%rax,%r13+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r9,%r13+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	32(%rsi)+	addq	%rax,%r14+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r9,%r14+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	40(%rsi)+	addq	%r9,%r15+	adcq	$0,%rdx+	xorq	%r9,%r9+	addq	%rax,%r15+	movq	%r10,%rax+	adcq	%rdx,%r8+	adcq	$0,%r9++	mulq	0(%rcx)+	addq	%rax,%rbp+	movq	%r10,%rax+	adcq	%rdx,%rbp++	mulq	8(%rcx)+	addq	%rax,%r11+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%rbp,%r11+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r12+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%rbp,%r12+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rbp,%r13+	adcq	$0,%rdx+	addq	%rax,%r13+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	32(%rcx)+	addq	%rax,%r14+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%rbp,%r14+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	40(%rcx)+	addq	%rax,%r15+	movq	24(%rbx),%rax+	adcq	$0,%rdx+	addq	%rbp,%r15+	adcq	%rdx,%r8+	adcq	$0,%r9++	movq	%rax,%rdi+	mulq	0(%rsi)+	addq	%rax,%r11+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	8(%rsi)+	addq	%rax,%r12+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r10,%r12+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	16(%rsi)+	addq	%rax,%r13+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r10,%r13+	adcq	$0,%rdx+	movq	%rdx,%r10++	movq	%r11,%rbp+	imulq	8(%rsp),%r11++	mulq	24(%rsi)+	addq	%rax,%r14+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r10,%r14+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rsi)+	addq	%rax,%r15+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r10,%r15+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	40(%rsi)+	addq	%r10,%r8+	adcq	$0,%rdx+	xorq	%r10,%r10+	addq	%rax,%r8+	movq	%r11,%rax+	adcq	%rdx,%r9+	adcq	$0,%r10++	mulq	0(%rcx)+	addq	%rax,%rbp+	movq	%r11,%rax+	adcq	%rdx,%rbp++	mulq	8(%rcx)+	addq	%rax,%r12+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%rbp,%r12+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rbp,%r14+	adcq	$0,%rdx+	addq	%rax,%r14+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	32(%rcx)+	addq	%rax,%r15+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%rbp,%r15+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	40(%rcx)+	addq	%rax,%r8+	movq	32(%rbx),%rax+	adcq	$0,%rdx+	addq	%rbp,%r8+	adcq	%rdx,%r9+	adcq	$0,%r10++	movq	%rax,%rdi+	mulq	0(%rsi)+	addq	%rax,%r12+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	8(%rsi)+	addq	%rax,%r13+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r11,%r13+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	16(%rsi)+	addq	%rax,%r14+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r11,%r14+	adcq	$0,%rdx+	movq	%rdx,%r11++	movq	%r12,%rbp+	imulq	8(%rsp),%r12++	mulq	24(%rsi)+	addq	%rax,%r15+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r11,%r15+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	32(%rsi)+	addq	%rax,%r8+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r11,%r8+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rsi)+	addq	%r11,%r9+	adcq	$0,%rdx+	xorq	%r11,%r11+	addq	%rax,%r9+	movq	%r12,%rax+	adcq	%rdx,%r10+	adcq	$0,%r11++	mulq	0(%rcx)+	addq	%rax,%rbp+	movq	%r12,%rax+	adcq	%rdx,%rbp++	mulq	8(%rcx)+	addq	%rax,%r13+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r14+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%rbp,%r14+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rbp,%r15+	adcq	$0,%rdx+	addq	%rax,%r15+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	32(%rcx)+	addq	%rax,%r8+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%rbp,%r8+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	40(%rcx)+	addq	%rax,%r9+	movq	40(%rbx),%rax+	adcq	$0,%rdx+	addq	%rbp,%r9+	adcq	%rdx,%r10+	adcq	$0,%r11++	movq	%rax,%rdi+	mulq	0(%rsi)+	addq	%rax,%r13+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	8(%rsi)+	addq	%rax,%r14+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r12,%r14+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	16(%rsi)+	addq	%rax,%r15+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r12,%r15+	adcq	$0,%rdx+	movq	%rdx,%r12++	movq	%r13,%rbp+	imulq	8(%rsp),%r13++	mulq	24(%rsi)+	addq	%rax,%r8+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r12,%r8+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	32(%rsi)+	addq	%rax,%r9+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r12,%r9+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	40(%rsi)+	addq	%r12,%r10+	adcq	$0,%rdx+	xorq	%r12,%r12+	addq	%rax,%r10+	movq	%r13,%rax+	adcq	%rdx,%r11+	adcq	$0,%r12++	mulq	0(%rcx)+	addq	%rax,%rbp+	movq	%r13,%rax+	adcq	%rdx,%rbp++	mulq	8(%rcx)+	addq	%rax,%r14+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%rbp,%r14+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r15+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%rbp,%r15+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rbp,%r8+	adcq	$0,%rdx+	addq	%rax,%r8+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	32(%rcx)+	addq	%rax,%r9+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%rbp,%r9+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	40(%rcx)+	addq	%rax,%r10+	movq	%r14,%rax+	adcq	$0,%rdx+	addq	%rbp,%r10+	adcq	%rdx,%r11+	adcq	$0,%r12+++++	movq	16(%rsp),%rdi+	subq	0(%rcx),%r14+	movq	%r15,%rdx+	sbbq	8(%rcx),%r15+	movq	%r8,%rbx+	sbbq	16(%rcx),%r8+	movq	%r9,%rsi+	sbbq	24(%rcx),%r9+	movq	%r10,%rbp+	sbbq	32(%rcx),%r10+	movq	%r11,%r13+	sbbq	40(%rcx),%r11+	sbbq	$0,%r12++	cmovcq	%rax,%r14+	cmovcq	%rdx,%r15+	cmovcq	%rbx,%r8+	movq	%r14,0(%rdi)+	cmovcq	%rsi,%r9+	movq	%r15,8(%rdi)+	cmovcq	%rbp,%r10+	movq	%r8,16(%rdi)+	cmovcq	%r13,%r11+	movq	%r9,24(%rdi)+	movq	%r10,32(%rdi)+	movq	%r11,40(%rdi)++	.byte	0xf3,0xc3++.globl	sqr_n_mul_mont_384++.def	sqr_n_mul_mont_384;	.scl 2;	.type 32;	.endef+.p2align	5+sqr_n_mul_mont_384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sqr_n_mul_mont_384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+	movq	40(%rsp),%r8+	movq	48(%rsp),%r9+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$136,%rsp++.LSEH_body_sqr_n_mul_mont_384:+++	movq	%r8,0(%rsp)+	movq	%rdi,8(%rsp)+	movq	%rcx,16(%rsp)+	leaq	32(%rsp),%rdi+	movq	%r9,24(%rsp)+	movq	(%r9),%xmm2++.Loop_sqr_384:+	movd	%edx,%xmm1++	call	__sqrq_384++	leaq	0(%rdi),%rsi+	movq	0(%rsp),%rcx+	movq	16(%rsp),%rbx+	call	__mulq_by_1_mont_384+	call	__redc_tail_mont_384++	movd	%xmm1,%edx+	leaq	0(%rdi),%rsi+	decl	%edx+	jnz	.Loop_sqr_384++.byte	102,72,15,126,208+	movq	%rbx,%rcx+	movq	24(%rsp),%rbx+++++++	movq	%r8,%r12+	movq	%r9,%r13++	call	__mulq_mont_384++	leaq	136(%rsp),%r8+	movq	136(%rsp),%r15++	movq	8(%r8),%r14++	movq	16(%r8),%r13++	movq	24(%r8),%r12++	movq	32(%r8),%rbx++	movq	40(%r8),%rbp++	leaq	48(%r8),%rsp++.LSEH_epilogue_sqr_n_mul_mont_384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sqr_n_mul_mont_384:++.globl	sqr_n_mul_mont_383++.def	sqr_n_mul_mont_383;	.scl 2;	.type 32;	.endef+.p2align	5+sqr_n_mul_mont_383:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sqr_n_mul_mont_383:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+	movq	40(%rsp),%r8+	movq	48(%rsp),%r9+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$136,%rsp++.LSEH_body_sqr_n_mul_mont_383:+++	movq	%r8,0(%rsp)+	movq	%rdi,8(%rsp)+	movq	%rcx,16(%rsp)+	leaq	32(%rsp),%rdi+	movq	%r9,24(%rsp)+	movq	(%r9),%xmm2++.Loop_sqr_383:+	movd	%edx,%xmm1++	call	__sqrq_384++	leaq	0(%rdi),%rsi+	movq	0(%rsp),%rcx+	movq	16(%rsp),%rbx+	call	__mulq_by_1_mont_384++	movd	%xmm1,%edx+	addq	48(%rsi),%r14+	adcq	56(%rsi),%r15+	adcq	64(%rsi),%r8+	adcq	72(%rsi),%r9+	adcq	80(%rsi),%r10+	adcq	88(%rsi),%r11+	leaq	0(%rdi),%rsi++	movq	%r14,0(%rdi)+	movq	%r15,8(%rdi)+	movq	%r8,16(%rdi)+	movq	%r9,24(%rdi)+	movq	%r10,32(%rdi)+	movq	%r11,40(%rdi)++	decl	%edx+	jnz	.Loop_sqr_383++.byte	102,72,15,126,208+	movq	%rbx,%rcx+	movq	24(%rsp),%rbx+++++++	movq	%r8,%r12+	movq	%r9,%r13++	call	__mulq_mont_384++	leaq	136(%rsp),%r8+	movq	136(%rsp),%r15++	movq	8(%r8),%r14++	movq	16(%r8),%r13++	movq	24(%r8),%r12++	movq	32(%r8),%rbx++	movq	40(%r8),%rbp++	leaq	48(%r8),%rsp++.LSEH_epilogue_sqr_n_mul_mont_383:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sqr_n_mul_mont_383:+.def	__mulq_mont_383_nonred;	.scl 3;	.type 32;	.endef+.p2align	5+__mulq_mont_383_nonred:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	%rax,%rbp+	mulq	%r14+	movq	%rax,%r8+	movq	%rbp,%rax+	movq	%rdx,%r9++	mulq	%r15+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	%r12+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11++	movq	%r8,%r15+	imulq	8(%rsp),%r8++	mulq	%r13+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	32(%rsi)+	addq	%rax,%r12+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13++	mulq	40(%rsi)+	addq	%rax,%r13+	movq	%r8,%rax+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	0(%rcx)+	addq	%rax,%r15+	movq	%r8,%rax+	adcq	%rdx,%r15++	mulq	8(%rcx)+	addq	%rax,%r9+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%r15,%r9+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	16(%rcx)+	addq	%rax,%r10+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%r15,%r10+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	24(%rcx)+	addq	%r15,%r11+	adcq	$0,%rdx+	addq	%rax,%r11+	movq	%r8,%rax+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	32(%rcx)+	addq	%rax,%r12+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%r15,%r12+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	40(%rcx)+	addq	%rax,%r13+	movq	8(%rbx),%rax+	adcq	$0,%rdx+	addq	%r15,%r13+	adcq	%rdx,%r14++	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	8(%rsi)+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r15,%r10+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	16(%rsi)+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r15,%r11+	adcq	$0,%rdx+	movq	%rdx,%r15++	movq	%r9,%r8+	imulq	8(%rsp),%r9++	mulq	24(%rsi)+	addq	%rax,%r12+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r15,%r12+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	32(%rsi)+	addq	%rax,%r13+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r15,%r13+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	40(%rsi)+	addq	%r15,%r14+	adcq	$0,%rdx+	addq	%rax,%r14+	movq	%r9,%rax+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	0(%rcx)+	addq	%rax,%r8+	movq	%r9,%rax+	adcq	%rdx,%r8++	mulq	8(%rcx)+	addq	%rax,%r10+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r8,%r10+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rcx)+	addq	%rax,%r11+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r8,%r11+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	24(%rcx)+	addq	%r8,%r12+	adcq	$0,%rdx+	addq	%rax,%r12+	movq	%r9,%rax+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	32(%rcx)+	addq	%rax,%r13+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r8,%r13+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	40(%rcx)+	addq	%rax,%r14+	movq	16(%rbx),%rax+	adcq	$0,%rdx+	addq	%r8,%r14+	adcq	%rdx,%r15++	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	8(%rsi)+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%r11+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rsi)+	addq	%rax,%r12+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%r12+	adcq	$0,%rdx+	movq	%rdx,%r8++	movq	%r10,%r9+	imulq	8(%rsp),%r10++	mulq	24(%rsi)+	addq	%rax,%r13+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%r13+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	32(%rsi)+	addq	%rax,%r14+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%r14+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	40(%rsi)+	addq	%r8,%r15+	adcq	$0,%rdx+	addq	%rax,%r15+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	0(%rcx)+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	%rdx,%r9++	mulq	8(%rcx)+	addq	%rax,%r11+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r9,%r11+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	16(%rcx)+	addq	%rax,%r12+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r9,%r12+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rcx)+	addq	%r9,%r13+	adcq	$0,%rdx+	addq	%rax,%r13+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	32(%rcx)+	addq	%rax,%r14+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r9,%r14+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	40(%rcx)+	addq	%rax,%r15+	movq	24(%rbx),%rax+	adcq	$0,%rdx+	addq	%r9,%r15+	adcq	%rdx,%r8++	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	8(%rsi)+	addq	%rax,%r12+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r12+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	16(%rsi)+	addq	%rax,%r13+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r13+	adcq	$0,%rdx+	movq	%rdx,%r9++	movq	%r11,%r10+	imulq	8(%rsp),%r11++	mulq	24(%rsi)+	addq	%rax,%r14+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r14+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	32(%rsi)+	addq	%rax,%r15+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r15+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	40(%rsi)+	addq	%r9,%r8+	adcq	$0,%rdx+	addq	%rax,%r8+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	0(%rcx)+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	%rdx,%r10++	mulq	8(%rcx)+	addq	%rax,%r12+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r10,%r12+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	16(%rcx)+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r10,%r13+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	24(%rcx)+	addq	%r10,%r14+	adcq	$0,%rdx+	addq	%rax,%r14+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rcx)+	addq	%rax,%r15+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r10,%r15+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	40(%rcx)+	addq	%rax,%r8+	movq	32(%rbx),%rax+	adcq	$0,%rdx+	addq	%r10,%r8+	adcq	%rdx,%r9++	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%r12+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	8(%rsi)+	addq	%rax,%r13+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r13+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	16(%rsi)+	addq	%rax,%r14+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r14+	adcq	$0,%rdx+	movq	%rdx,%r10++	movq	%r12,%r11+	imulq	8(%rsp),%r12++	mulq	24(%rsi)+	addq	%rax,%r15+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r15+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rsi)+	addq	%rax,%r8+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r8+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	40(%rsi)+	addq	%r10,%r9+	adcq	$0,%rdx+	addq	%rax,%r9+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	0(%rcx)+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	%rdx,%r11++	mulq	8(%rcx)+	addq	%rax,%r13+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r11,%r13+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	16(%rcx)+	addq	%rax,%r14+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r11,%r14+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	24(%rcx)+	addq	%r11,%r15+	adcq	$0,%rdx+	addq	%rax,%r15+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	32(%rcx)+	addq	%rax,%r8+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r11,%r8+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rcx)+	addq	%rax,%r9+	movq	40(%rbx),%rax+	adcq	$0,%rdx+	addq	%r11,%r9+	adcq	%rdx,%r10++	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%r13+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	8(%rsi)+	addq	%rax,%r14+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r14+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	16(%rsi)+	addq	%rax,%r15+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r15+	adcq	$0,%rdx+	movq	%rdx,%r11++	movq	%r13,%r12+	imulq	8(%rsp),%r13++	mulq	24(%rsi)+	addq	%rax,%r8+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r8+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	32(%rsi)+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r9+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rsi)+	addq	%r11,%r10+	adcq	$0,%rdx+	addq	%rax,%r10+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	0(%rcx)+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	%rdx,%r12++	mulq	8(%rcx)+	addq	%rax,%r14+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r12,%r14+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	16(%rcx)+	addq	%rax,%r15+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r12,%r15+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	24(%rcx)+	addq	%r12,%r8+	adcq	$0,%rdx+	addq	%rax,%r8+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	32(%rcx)+	addq	%rax,%r9+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r12,%r9+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	40(%rcx)+	addq	%rax,%r10+	movq	%r14,%rax+	adcq	$0,%rdx+	addq	%r12,%r10+	adcq	%rdx,%r11+	.byte	0xf3,0xc3++.globl	sqr_mont_382x++.def	sqr_mont_382x;	.scl 2;	.type 32;	.endef+.p2align	5+sqr_mont_382x:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sqr_mont_382x:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$136,%rsp++.LSEH_body_sqr_mont_382x:+++	movq	%rcx,0(%rsp)+	movq	%rdx,%rcx+	movq	%rsi,16(%rsp)+	movq	%rdi,24(%rsp)+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%r8,%r14+	addq	48(%rsi),%r8+	movq	%r9,%r15+	adcq	56(%rsi),%r9+	movq	%r10,%rax+	adcq	64(%rsi),%r10+	movq	%r11,%rdx+	adcq	72(%rsi),%r11+	movq	%r12,%rbx+	adcq	80(%rsi),%r12+	movq	%r13,%rbp+	adcq	88(%rsi),%r13++	subq	48(%rsi),%r14+	sbbq	56(%rsi),%r15+	sbbq	64(%rsi),%rax+	sbbq	72(%rsi),%rdx+	sbbq	80(%rsi),%rbx+	sbbq	88(%rsi),%rbp+	sbbq	%rdi,%rdi++	movq	%r8,32+0(%rsp)+	movq	%r9,32+8(%rsp)+	movq	%r10,32+16(%rsp)+	movq	%r11,32+24(%rsp)+	movq	%r12,32+32(%rsp)+	movq	%r13,32+40(%rsp)++	movq	%r14,32+48(%rsp)+	movq	%r15,32+56(%rsp)+	movq	%rax,32+64(%rsp)+	movq	%rdx,32+72(%rsp)+	movq	%rbx,32+80(%rsp)+	movq	%rbp,32+88(%rsp)+	movq	%rdi,32+96(%rsp)++++	leaq	48(%rsi),%rbx++	movq	48(%rsi),%rax+	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%r12+	movq	24(%rsi),%r13++	movq	24(%rsp),%rdi+	call	__mulq_mont_383_nonred+	addq	%r14,%r14+	adcq	%r15,%r15+	adcq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11++	movq	%r14,48(%rdi)+	movq	%r15,56(%rdi)+	movq	%r8,64(%rdi)+	movq	%r9,72(%rdi)+	movq	%r10,80(%rdi)+	movq	%r11,88(%rdi)++	leaq	32(%rsp),%rsi+	leaq	32+48(%rsp),%rbx++	movq	32+48(%rsp),%rax+	movq	32+0(%rsp),%r14+	movq	32+8(%rsp),%r15+	movq	32+16(%rsp),%r12+	movq	32+24(%rsp),%r13++	call	__mulq_mont_383_nonred+	movq	32+96(%rsp),%rsi+	movq	32+0(%rsp),%r12+	movq	32+8(%rsp),%r13+	andq	%rsi,%r12+	movq	32+16(%rsp),%rax+	andq	%rsi,%r13+	movq	32+24(%rsp),%rbx+	andq	%rsi,%rax+	movq	32+32(%rsp),%rbp+	andq	%rsi,%rbx+	andq	%rsi,%rbp+	andq	32+40(%rsp),%rsi++	subq	%r12,%r14+	movq	0(%rcx),%r12+	sbbq	%r13,%r15+	movq	8(%rcx),%r13+	sbbq	%rax,%r8+	movq	16(%rcx),%rax+	sbbq	%rbx,%r9+	movq	24(%rcx),%rbx+	sbbq	%rbp,%r10+	movq	32(%rcx),%rbp+	sbbq	%rsi,%r11+	sbbq	%rsi,%rsi++	andq	%rsi,%r12+	andq	%rsi,%r13+	andq	%rsi,%rax+	andq	%rsi,%rbx+	andq	%rsi,%rbp+	andq	40(%rcx),%rsi++	addq	%r12,%r14+	adcq	%r13,%r15+	adcq	%rax,%r8+	adcq	%rbx,%r9+	adcq	%rbp,%r10+	adcq	%rsi,%r11++	movq	%r14,0(%rdi)+	movq	%r15,8(%rdi)+	movq	%r8,16(%rdi)+	movq	%r9,24(%rdi)+	movq	%r10,32(%rdi)+	movq	%r11,40(%rdi)+	leaq	136(%rsp),%r8+	movq	0(%r8),%r15++	movq	8(%r8),%r14++	movq	16(%r8),%r13++	movq	24(%r8),%r12++	movq	32(%r8),%rbx++	movq	40(%r8),%rbp++	leaq	48(%r8),%rsp++.LSEH_epilogue_sqr_mont_382x:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sqr_mont_382x:+.section	.pdata+.p2align	2+.rva	.LSEH_begin_mul_mont_384x+.rva	.LSEH_body_mul_mont_384x+.rva	.LSEH_info_mul_mont_384x_prologue++.rva	.LSEH_body_mul_mont_384x+.rva	.LSEH_epilogue_mul_mont_384x+.rva	.LSEH_info_mul_mont_384x_body++.rva	.LSEH_epilogue_mul_mont_384x+.rva	.LSEH_end_mul_mont_384x+.rva	.LSEH_info_mul_mont_384x_epilogue++.rva	.LSEH_begin_sqr_mont_384x+.rva	.LSEH_body_sqr_mont_384x+.rva	.LSEH_info_sqr_mont_384x_prologue++.rva	.LSEH_body_sqr_mont_384x+.rva	.LSEH_epilogue_sqr_mont_384x+.rva	.LSEH_info_sqr_mont_384x_body++.rva	.LSEH_epilogue_sqr_mont_384x+.rva	.LSEH_end_sqr_mont_384x+.rva	.LSEH_info_sqr_mont_384x_epilogue++.rva	.LSEH_begin_mul_382x+.rva	.LSEH_body_mul_382x+.rva	.LSEH_info_mul_382x_prologue++.rva	.LSEH_body_mul_382x+.rva	.LSEH_epilogue_mul_382x+.rva	.LSEH_info_mul_382x_body++.rva	.LSEH_epilogue_mul_382x+.rva	.LSEH_end_mul_382x+.rva	.LSEH_info_mul_382x_epilogue++.rva	.LSEH_begin_sqr_382x+.rva	.LSEH_body_sqr_382x+.rva	.LSEH_info_sqr_382x_prologue++.rva	.LSEH_body_sqr_382x+.rva	.LSEH_epilogue_sqr_382x+.rva	.LSEH_info_sqr_382x_body++.rva	.LSEH_epilogue_sqr_382x+.rva	.LSEH_end_sqr_382x+.rva	.LSEH_info_sqr_382x_epilogue++.rva	.LSEH_begin_mul_384+.rva	.LSEH_body_mul_384+.rva	.LSEH_info_mul_384_prologue++.rva	.LSEH_body_mul_384+.rva	.LSEH_epilogue_mul_384+.rva	.LSEH_info_mul_384_body++.rva	.LSEH_epilogue_mul_384+.rva	.LSEH_end_mul_384+.rva	.LSEH_info_mul_384_epilogue++.rva	.LSEH_begin_sqr_384+.rva	.LSEH_body_sqr_384+.rva	.LSEH_info_sqr_384_prologue++.rva	.LSEH_body_sqr_384+.rva	.LSEH_epilogue_sqr_384+.rva	.LSEH_info_sqr_384_body++.rva	.LSEH_epilogue_sqr_384+.rva	.LSEH_end_sqr_384+.rva	.LSEH_info_sqr_384_epilogue++.rva	.LSEH_begin_sqr_mont_384+.rva	.LSEH_body_sqr_mont_384+.rva	.LSEH_info_sqr_mont_384_prologue++.rva	.LSEH_body_sqr_mont_384+.rva	.LSEH_epilogue_sqr_mont_384+.rva	.LSEH_info_sqr_mont_384_body++.rva	.LSEH_epilogue_sqr_mont_384+.rva	.LSEH_end_sqr_mont_384+.rva	.LSEH_info_sqr_mont_384_epilogue++.rva	.LSEH_begin_redc_mont_384+.rva	.LSEH_body_redc_mont_384+.rva	.LSEH_info_redc_mont_384_prologue++.rva	.LSEH_body_redc_mont_384+.rva	.LSEH_epilogue_redc_mont_384+.rva	.LSEH_info_redc_mont_384_body++.rva	.LSEH_epilogue_redc_mont_384+.rva	.LSEH_end_redc_mont_384+.rva	.LSEH_info_redc_mont_384_epilogue++.rva	.LSEH_begin_from_mont_384+.rva	.LSEH_body_from_mont_384+.rva	.LSEH_info_from_mont_384_prologue++.rva	.LSEH_body_from_mont_384+.rva	.LSEH_epilogue_from_mont_384+.rva	.LSEH_info_from_mont_384_body++.rva	.LSEH_epilogue_from_mont_384+.rva	.LSEH_end_from_mont_384+.rva	.LSEH_info_from_mont_384_epilogue++.rva	.LSEH_begin_sgn0_pty_mont_384+.rva	.LSEH_body_sgn0_pty_mont_384+.rva	.LSEH_info_sgn0_pty_mont_384_prologue++.rva	.LSEH_body_sgn0_pty_mont_384+.rva	.LSEH_epilogue_sgn0_pty_mont_384+.rva	.LSEH_info_sgn0_pty_mont_384_body++.rva	.LSEH_epilogue_sgn0_pty_mont_384+.rva	.LSEH_end_sgn0_pty_mont_384+.rva	.LSEH_info_sgn0_pty_mont_384_epilogue++.rva	.LSEH_begin_sgn0_pty_mont_384x+.rva	.LSEH_body_sgn0_pty_mont_384x+.rva	.LSEH_info_sgn0_pty_mont_384x_prologue++.rva	.LSEH_body_sgn0_pty_mont_384x+.rva	.LSEH_epilogue_sgn0_pty_mont_384x+.rva	.LSEH_info_sgn0_pty_mont_384x_body++.rva	.LSEH_epilogue_sgn0_pty_mont_384x+.rva	.LSEH_end_sgn0_pty_mont_384x+.rva	.LSEH_info_sgn0_pty_mont_384x_epilogue++.rva	.LSEH_begin_mul_mont_384+.rva	.LSEH_body_mul_mont_384+.rva	.LSEH_info_mul_mont_384_prologue++.rva	.LSEH_body_mul_mont_384+.rva	.LSEH_epilogue_mul_mont_384+.rva	.LSEH_info_mul_mont_384_body++.rva	.LSEH_epilogue_mul_mont_384+.rva	.LSEH_end_mul_mont_384+.rva	.LSEH_info_mul_mont_384_epilogue++.rva	.LSEH_begin_sqr_n_mul_mont_384+.rva	.LSEH_body_sqr_n_mul_mont_384+.rva	.LSEH_info_sqr_n_mul_mont_384_prologue++.rva	.LSEH_body_sqr_n_mul_mont_384+.rva	.LSEH_epilogue_sqr_n_mul_mont_384+.rva	.LSEH_info_sqr_n_mul_mont_384_body++.rva	.LSEH_epilogue_sqr_n_mul_mont_384+.rva	.LSEH_end_sqr_n_mul_mont_384+.rva	.LSEH_info_sqr_n_mul_mont_384_epilogue++.rva	.LSEH_begin_sqr_n_mul_mont_383+.rva	.LSEH_body_sqr_n_mul_mont_383+.rva	.LSEH_info_sqr_n_mul_mont_383_prologue++.rva	.LSEH_body_sqr_n_mul_mont_383+.rva	.LSEH_epilogue_sqr_n_mul_mont_383+.rva	.LSEH_info_sqr_n_mul_mont_383_body++.rva	.LSEH_epilogue_sqr_n_mul_mont_383+.rva	.LSEH_end_sqr_n_mul_mont_383+.rva	.LSEH_info_sqr_n_mul_mont_383_epilogue++.rva	.LSEH_begin_sqr_mont_382x+.rva	.LSEH_body_sqr_mont_382x+.rva	.LSEH_info_sqr_mont_382x_prologue++.rva	.LSEH_body_sqr_mont_382x+.rva	.LSEH_epilogue_sqr_mont_382x+.rva	.LSEH_info_sqr_mont_382x_body++.rva	.LSEH_epilogue_sqr_mont_382x+.rva	.LSEH_end_sqr_mont_382x+.rva	.LSEH_info_sqr_mont_382x_epilogue++.section	.xdata+.p2align	3+.LSEH_info_mul_mont_384x_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_mul_mont_384x_body:+.byte	1,0,18,0+.byte	0x00,0xf4,0x29,0x00+.byte	0x00,0xe4,0x2a,0x00+.byte	0x00,0xd4,0x2b,0x00+.byte	0x00,0xc4,0x2c,0x00+.byte	0x00,0x34,0x2d,0x00+.byte	0x00,0x54,0x2e,0x00+.byte	0x00,0x74,0x30,0x00+.byte	0x00,0x64,0x31,0x00+.byte	0x00,0x01,0x2f,0x00+.LSEH_info_mul_mont_384x_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sqr_mont_384x_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sqr_mont_384x_body:+.byte	1,0,18,0+.byte	0x00,0xf4,0x11,0x00+.byte	0x00,0xe4,0x12,0x00+.byte	0x00,0xd4,0x13,0x00+.byte	0x00,0xc4,0x14,0x00+.byte	0x00,0x34,0x15,0x00+.byte	0x00,0x54,0x16,0x00+.byte	0x00,0x74,0x18,0x00+.byte	0x00,0x64,0x19,0x00+.byte	0x00,0x01,0x17,0x00+.LSEH_info_sqr_mont_384x_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_mul_382x_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_mul_382x_body:+.byte	1,0,18,0+.byte	0x00,0xf4,0x11,0x00+.byte	0x00,0xe4,0x12,0x00+.byte	0x00,0xd4,0x13,0x00+.byte	0x00,0xc4,0x14,0x00+.byte	0x00,0x34,0x15,0x00+.byte	0x00,0x54,0x16,0x00+.byte	0x00,0x74,0x18,0x00+.byte	0x00,0x64,0x19,0x00+.byte	0x00,0x01,0x17,0x00+.LSEH_info_mul_382x_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sqr_382x_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sqr_382x_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_sqr_382x_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_mul_384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_mul_384_body:+.byte	1,0,11,0+.byte	0x00,0xc4,0x00,0x00+.byte	0x00,0x34,0x01,0x00+.byte	0x00,0x54,0x02,0x00+.byte	0x00,0x74,0x04,0x00+.byte	0x00,0x64,0x05,0x00+.byte	0x00,0x22+.byte	0x00,0x00,0x00,0x00,0x00,0x00+.LSEH_info_mul_384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sqr_384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sqr_384_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_sqr_384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sqr_mont_384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sqr_mont_384_body:+.byte	1,0,18,0+.byte	0x00,0xf4,0x0f,0x00+.byte	0x00,0xe4,0x10,0x00+.byte	0x00,0xd4,0x11,0x00+.byte	0x00,0xc4,0x12,0x00+.byte	0x00,0x34,0x13,0x00+.byte	0x00,0x54,0x14,0x00+.byte	0x00,0x74,0x16,0x00+.byte	0x00,0x64,0x17,0x00+.byte	0x00,0x01,0x15,0x00+.LSEH_info_sqr_mont_384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_redc_mont_384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_redc_mont_384_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_redc_mont_384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_from_mont_384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_from_mont_384_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_from_mont_384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sgn0_pty_mont_384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sgn0_pty_mont_384_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_sgn0_pty_mont_384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sgn0_pty_mont_384x_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sgn0_pty_mont_384x_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_sgn0_pty_mont_384x_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_mul_mont_384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_mul_mont_384_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x03,0x00+.byte	0x00,0xe4,0x04,0x00+.byte	0x00,0xd4,0x05,0x00+.byte	0x00,0xc4,0x06,0x00+.byte	0x00,0x34,0x07,0x00+.byte	0x00,0x54,0x08,0x00+.byte	0x00,0x74,0x0a,0x00+.byte	0x00,0x64,0x0b,0x00+.byte	0x00,0x82+.byte	0x00,0x00+.LSEH_info_mul_mont_384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sqr_n_mul_mont_384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sqr_n_mul_mont_384_body:+.byte	1,0,18,0+.byte	0x00,0xf4,0x11,0x00+.byte	0x00,0xe4,0x12,0x00+.byte	0x00,0xd4,0x13,0x00+.byte	0x00,0xc4,0x14,0x00+.byte	0x00,0x34,0x15,0x00+.byte	0x00,0x54,0x16,0x00+.byte	0x00,0x74,0x18,0x00+.byte	0x00,0x64,0x19,0x00+.byte	0x00,0x01,0x17,0x00+.LSEH_info_sqr_n_mul_mont_384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sqr_n_mul_mont_383_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sqr_n_mul_mont_383_body:+.byte	1,0,18,0+.byte	0x00,0xf4,0x11,0x00+.byte	0x00,0xe4,0x12,0x00+.byte	0x00,0xd4,0x13,0x00+.byte	0x00,0xc4,0x14,0x00+.byte	0x00,0x34,0x15,0x00+.byte	0x00,0x54,0x16,0x00+.byte	0x00,0x74,0x18,0x00+.byte	0x00,0x64,0x19,0x00+.byte	0x00,0x01,0x17,0x00+.LSEH_info_sqr_n_mul_mont_383_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sqr_mont_382x_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sqr_mont_382x_body:+.byte	1,0,18,0+.byte	0x00,0xf4,0x11,0x00+.byte	0x00,0xe4,0x12,0x00+.byte	0x00,0xd4,0x13,0x00+.byte	0x00,0xc4,0x14,0x00+.byte	0x00,0x34,0x15,0x00+.byte	0x00,0x54,0x16,0x00+.byte	0x00,0x74,0x18,0x00+.byte	0x00,0x64,0x19,0x00+.byte	0x00,0x01,0x17,0x00+.LSEH_info_sqr_mont_382x_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00+
+ c-source/build/coff/mulx_mont_256-x86_64.s view
@@ -0,0 +1,784 @@+.text	++.globl	mulx_mont_sparse_256++.def	mulx_mont_sparse_256;	.scl 2;	.type 32;	.endef+.p2align	5+mulx_mont_sparse_256:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_mulx_mont_sparse_256:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+	movq	40(%rsp),%r8+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$8,%rsp++.LSEH_body_mulx_mont_sparse_256:+++	movq	%rdx,%rbx+	movq	0(%rdx),%rdx+	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%rbp+	movq	24(%rsi),%r9+	leaq	-128(%rsi),%rsi+	leaq	-128(%rcx),%rcx++	mulxq	%r14,%rax,%r11+	call	__mulx_mont_sparse_256++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_mulx_mont_sparse_256:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_mulx_mont_sparse_256:++.globl	sqrx_mont_sparse_256++.def	sqrx_mont_sparse_256;	.scl 2;	.type 32;	.endef+.p2align	5+sqrx_mont_sparse_256:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sqrx_mont_sparse_256:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$8,%rsp++.LSEH_body_sqrx_mont_sparse_256:+++	movq	%rsi,%rbx+	movq	%rcx,%r8+	movq	%rdx,%rcx+	movq	0(%rsi),%rdx+	movq	8(%rsi),%r15+	movq	16(%rsi),%rbp+	movq	24(%rsi),%r9+	leaq	-128(%rbx),%rsi+	leaq	-128(%rcx),%rcx++	mulxq	%rdx,%rax,%r11+	call	__mulx_mont_sparse_256++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_sqrx_mont_sparse_256:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sqrx_mont_sparse_256:+.def	__mulx_mont_sparse_256;	.scl 3;	.type 32;	.endef+.p2align	5+__mulx_mont_sparse_256:+	.byte	0xf3,0x0f,0x1e,0xfa++	mulxq	%r15,%r15,%r12+	mulxq	%rbp,%rbp,%r13+	addq	%r15,%r11+	mulxq	%r9,%r9,%r14+	movq	8(%rbx),%rdx+	adcq	%rbp,%r12+	adcq	%r9,%r13+	adcq	$0,%r14++	movq	%rax,%r10+	imulq	%r8,%rax+++	xorq	%r15,%r15+	mulxq	0+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r11+	adcxq	%r9,%r12++	mulxq	8+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r12+	adcxq	%r9,%r13++	mulxq	16+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r13+	adcxq	%r9,%r14++	mulxq	24+128(%rsi),%rbp,%r9+	movq	%rax,%rdx+	adoxq	%rbp,%r14+	adcxq	%r15,%r9+	adoxq	%r9,%r15+++	mulxq	0+128(%rcx),%rbp,%rax+	adcxq	%rbp,%r10+	adoxq	%r11,%rax++	mulxq	8+128(%rcx),%rbp,%r9+	adcxq	%rbp,%rax+	adoxq	%r9,%r12++	mulxq	16+128(%rcx),%rbp,%r9+	adcxq	%rbp,%r12+	adoxq	%r9,%r13++	mulxq	24+128(%rcx),%rbp,%r9+	movq	16(%rbx),%rdx+	adcxq	%rbp,%r13+	adoxq	%r9,%r14+	adcxq	%r10,%r14+	adoxq	%r10,%r15+	adcxq	%r10,%r15+	adoxq	%r10,%r10+	adcq	$0,%r10+	movq	%rax,%r11+	imulq	%r8,%rax+++	xorq	%rbp,%rbp+	mulxq	0+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r12+	adcxq	%r9,%r13++	mulxq	8+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r13+	adcxq	%r9,%r14++	mulxq	16+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r14+	adcxq	%r9,%r15++	mulxq	24+128(%rsi),%rbp,%r9+	movq	%rax,%rdx+	adoxq	%rbp,%r15+	adcxq	%r10,%r9+	adoxq	%r9,%r10+++	mulxq	0+128(%rcx),%rbp,%rax+	adcxq	%rbp,%r11+	adoxq	%r12,%rax++	mulxq	8+128(%rcx),%rbp,%r9+	adcxq	%rbp,%rax+	adoxq	%r9,%r13++	mulxq	16+128(%rcx),%rbp,%r9+	adcxq	%rbp,%r13+	adoxq	%r9,%r14++	mulxq	24+128(%rcx),%rbp,%r9+	movq	24(%rbx),%rdx+	adcxq	%rbp,%r14+	adoxq	%r9,%r15+	adcxq	%r11,%r15+	adoxq	%r11,%r10+	adcxq	%r11,%r10+	adoxq	%r11,%r11+	adcq	$0,%r11+	movq	%rax,%r12+	imulq	%r8,%rax+++	xorq	%rbp,%rbp+	mulxq	0+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r13+	adcxq	%r9,%r14++	mulxq	8+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r14+	adcxq	%r9,%r15++	mulxq	16+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r15+	adcxq	%r9,%r10++	mulxq	24+128(%rsi),%rbp,%r9+	movq	%rax,%rdx+	adoxq	%rbp,%r10+	adcxq	%r11,%r9+	adoxq	%r9,%r11+++	mulxq	0+128(%rcx),%rbp,%rax+	adcxq	%rbp,%r12+	adoxq	%r13,%rax++	mulxq	8+128(%rcx),%rbp,%r9+	adcxq	%rbp,%rax+	adoxq	%r9,%r14++	mulxq	16+128(%rcx),%rbp,%r9+	adcxq	%rbp,%r14+	adoxq	%r9,%r15++	mulxq	24+128(%rcx),%rbp,%r9+	movq	%rax,%rdx+	adcxq	%rbp,%r15+	adoxq	%r9,%r10+	adcxq	%r12,%r10+	adoxq	%r12,%r11+	adcxq	%r12,%r11+	adoxq	%r12,%r12+	adcq	$0,%r12+	imulq	%r8,%rdx+++	xorq	%rbp,%rbp+	mulxq	0+128(%rcx),%r13,%r9+	adcxq	%rax,%r13+	adoxq	%r9,%r14++	mulxq	8+128(%rcx),%rbp,%r9+	adcxq	%rbp,%r14+	adoxq	%r9,%r15++	mulxq	16+128(%rcx),%rbp,%r9+	adcxq	%rbp,%r15+	adoxq	%r9,%r10++	mulxq	24+128(%rcx),%rbp,%r9+	movq	%r14,%rdx+	leaq	128(%rcx),%rcx+	adcxq	%rbp,%r10+	adoxq	%r9,%r11+	movq	%r15,%rax+	adcxq	%r13,%r11+	adoxq	%r13,%r12+	adcq	$0,%r12+++++	movq	%r10,%rbp+	subq	0(%rcx),%r14+	sbbq	8(%rcx),%r15+	sbbq	16(%rcx),%r10+	movq	%r11,%r9+	sbbq	24(%rcx),%r11+	sbbq	$0,%r12++	cmovcq	%rdx,%r14+	cmovcq	%rax,%r15+	cmovcq	%rbp,%r10+	movq	%r14,0(%rdi)+	cmovcq	%r9,%r11+	movq	%r15,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)++	.byte	0xf3,0xc3++.globl	fromx_mont_256++.def	fromx_mont_256;	.scl 2;	.type 32;	.endef+.p2align	5+fromx_mont_256:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_fromx_mont_256:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$8,%rsp++.LSEH_body_fromx_mont_256:+++	movq	%rdx,%rbx+	call	__mulx_by_1_mont_256++++++	movq	%r15,%rdx+	movq	%r10,%r12+	movq	%r11,%r13++	subq	0(%rbx),%r14+	sbbq	8(%rbx),%r15+	sbbq	16(%rbx),%r10+	sbbq	24(%rbx),%r11++	cmovncq	%r14,%rax+	cmovncq	%r15,%rdx+	cmovncq	%r10,%r12+	movq	%rax,0(%rdi)+	cmovncq	%r11,%r13+	movq	%rdx,8(%rdi)+	movq	%r12,16(%rdi)+	movq	%r13,24(%rdi)++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_fromx_mont_256:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_fromx_mont_256:++.globl	redcx_mont_256++.def	redcx_mont_256;	.scl 2;	.type 32;	.endef+.p2align	5+redcx_mont_256:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_redcx_mont_256:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$8,%rsp++.LSEH_body_redcx_mont_256:+++	movq	%rdx,%rbx+	call	__mulx_by_1_mont_256++	addq	32(%rsi),%r14+	adcq	40(%rsi),%r15+	movq	%r14,%rax+	adcq	48(%rsi),%r10+	movq	%r15,%rdx+	adcq	56(%rsi),%r11+	sbbq	%rsi,%rsi+++++	movq	%r10,%r12+	subq	0(%rbx),%r14+	sbbq	8(%rbx),%r15+	sbbq	16(%rbx),%r10+	movq	%r11,%r13+	sbbq	24(%rbx),%r11+	sbbq	$0,%rsi++	cmovncq	%r14,%rax+	cmovncq	%r15,%rdx+	cmovncq	%r10,%r12+	movq	%rax,0(%rdi)+	cmovncq	%r11,%r13+	movq	%rdx,8(%rdi)+	movq	%r12,16(%rdi)+	movq	%r13,24(%rdi)++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_redcx_mont_256:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_redcx_mont_256:+.def	__mulx_by_1_mont_256;	.scl 3;	.type 32;	.endef+.p2align	5+__mulx_by_1_mont_256:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%rax+	movq	8(%rsi),%r11+	movq	16(%rsi),%r12+	movq	24(%rsi),%r13++	movq	%rax,%r14+	imulq	%rcx,%rax+	movq	%rax,%r10++	mulq	0(%rbx)+	addq	%rax,%r14+	movq	%r10,%rax+	adcq	%rdx,%r14++	mulq	8(%rbx)+	addq	%rax,%r11+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r14,%r11+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	16(%rbx)+	movq	%r11,%r15+	imulq	%rcx,%r11+	addq	%rax,%r12+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r14,%r12+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	24(%rbx)+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r14,%r13+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	0(%rbx)+	addq	%rax,%r15+	movq	%r11,%rax+	adcq	%rdx,%r15++	mulq	8(%rbx)+	addq	%rax,%r12+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r15,%r12+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	16(%rbx)+	movq	%r12,%r10+	imulq	%rcx,%r12+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r15,%r13+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	24(%rbx)+	addq	%rax,%r14+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r15,%r14+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	0(%rbx)+	addq	%rax,%r10+	movq	%r12,%rax+	adcq	%rdx,%r10++	mulq	8(%rbx)+	addq	%rax,%r13+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r10,%r13+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	16(%rbx)+	movq	%r13,%r11+	imulq	%rcx,%r13+	addq	%rax,%r14+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r10,%r14+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	24(%rbx)+	addq	%rax,%r15+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r10,%r15+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	0(%rbx)+	addq	%rax,%r11+	movq	%r13,%rax+	adcq	%rdx,%r11++	mulq	8(%rbx)+	addq	%rax,%r14+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r11,%r14+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	16(%rbx)+	addq	%rax,%r15+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r11,%r15+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	24(%rbx)+	addq	%rax,%r10+	movq	%r14,%rax+	adcq	$0,%rdx+	addq	%r11,%r10+	adcq	$0,%rdx+	movq	%rdx,%r11+	.byte	0xf3,0xc3++.section	.pdata+.p2align	2+.rva	.LSEH_begin_mulx_mont_sparse_256+.rva	.LSEH_body_mulx_mont_sparse_256+.rva	.LSEH_info_mulx_mont_sparse_256_prologue++.rva	.LSEH_body_mulx_mont_sparse_256+.rva	.LSEH_epilogue_mulx_mont_sparse_256+.rva	.LSEH_info_mulx_mont_sparse_256_body++.rva	.LSEH_epilogue_mulx_mont_sparse_256+.rva	.LSEH_end_mulx_mont_sparse_256+.rva	.LSEH_info_mulx_mont_sparse_256_epilogue++.rva	.LSEH_begin_sqrx_mont_sparse_256+.rva	.LSEH_body_sqrx_mont_sparse_256+.rva	.LSEH_info_sqrx_mont_sparse_256_prologue++.rva	.LSEH_body_sqrx_mont_sparse_256+.rva	.LSEH_epilogue_sqrx_mont_sparse_256+.rva	.LSEH_info_sqrx_mont_sparse_256_body++.rva	.LSEH_epilogue_sqrx_mont_sparse_256+.rva	.LSEH_end_sqrx_mont_sparse_256+.rva	.LSEH_info_sqrx_mont_sparse_256_epilogue++.rva	.LSEH_begin_fromx_mont_256+.rva	.LSEH_body_fromx_mont_256+.rva	.LSEH_info_fromx_mont_256_prologue++.rva	.LSEH_body_fromx_mont_256+.rva	.LSEH_epilogue_fromx_mont_256+.rva	.LSEH_info_fromx_mont_256_body++.rva	.LSEH_epilogue_fromx_mont_256+.rva	.LSEH_end_fromx_mont_256+.rva	.LSEH_info_fromx_mont_256_epilogue++.rva	.LSEH_begin_redcx_mont_256+.rva	.LSEH_body_redcx_mont_256+.rva	.LSEH_info_redcx_mont_256_prologue++.rva	.LSEH_body_redcx_mont_256+.rva	.LSEH_epilogue_redcx_mont_256+.rva	.LSEH_info_redcx_mont_256_body++.rva	.LSEH_epilogue_redcx_mont_256+.rva	.LSEH_end_redcx_mont_256+.rva	.LSEH_info_redcx_mont_256_epilogue++.section	.xdata+.p2align	3+.LSEH_info_mulx_mont_sparse_256_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_mulx_mont_sparse_256_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_mulx_mont_sparse_256_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sqrx_mont_sparse_256_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sqrx_mont_sparse_256_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_sqrx_mont_sparse_256_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_fromx_mont_256_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_fromx_mont_256_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_fromx_mont_256_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_redcx_mont_256_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_redcx_mont_256_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_redcx_mont_256_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00+
+ c-source/build/coff/mulx_mont_384-x86_64.s view
@@ -0,0 +1,3559 @@+.text	++++++++.def	__sub_mod_384x384;	.scl 3;	.type 32;	.endef+.p2align	5+__sub_mod_384x384:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	48(%rsi),%r14++	subq	0(%rdx),%r8+	movq	56(%rsi),%r15+	sbbq	8(%rdx),%r9+	movq	64(%rsi),%rax+	sbbq	16(%rdx),%r10+	movq	72(%rsi),%rbx+	sbbq	24(%rdx),%r11+	movq	80(%rsi),%rbp+	sbbq	32(%rdx),%r12+	movq	88(%rsi),%rsi+	sbbq	40(%rdx),%r13+	movq	%r8,0(%rdi)+	sbbq	48(%rdx),%r14+	movq	0(%rcx),%r8+	movq	%r9,8(%rdi)+	sbbq	56(%rdx),%r15+	movq	8(%rcx),%r9+	movq	%r10,16(%rdi)+	sbbq	64(%rdx),%rax+	movq	16(%rcx),%r10+	movq	%r11,24(%rdi)+	sbbq	72(%rdx),%rbx+	movq	24(%rcx),%r11+	movq	%r12,32(%rdi)+	sbbq	80(%rdx),%rbp+	movq	32(%rcx),%r12+	movq	%r13,40(%rdi)+	sbbq	88(%rdx),%rsi+	movq	40(%rcx),%r13+	sbbq	%rdx,%rdx++	andq	%rdx,%r8+	andq	%rdx,%r9+	andq	%rdx,%r10+	andq	%rdx,%r11+	andq	%rdx,%r12+	andq	%rdx,%r13++	addq	%r8,%r14+	adcq	%r9,%r15+	movq	%r14,48(%rdi)+	adcq	%r10,%rax+	movq	%r15,56(%rdi)+	adcq	%r11,%rbx+	movq	%rax,64(%rdi)+	adcq	%r12,%rbp+	movq	%rbx,72(%rdi)+	adcq	%r13,%rsi+	movq	%rbp,80(%rdi)+	movq	%rsi,88(%rdi)++	.byte	0xf3,0xc3+++.def	__add_mod_384;	.scl 3;	.type 32;	.endef+.p2align	5+__add_mod_384:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	addq	0(%rdx),%r8+	adcq	8(%rdx),%r9+	adcq	16(%rdx),%r10+	movq	%r8,%r14+	adcq	24(%rdx),%r11+	movq	%r9,%r15+	adcq	32(%rdx),%r12+	movq	%r10,%rax+	adcq	40(%rdx),%r13+	movq	%r11,%rbx+	sbbq	%rdx,%rdx++	subq	0(%rcx),%r8+	sbbq	8(%rcx),%r9+	movq	%r12,%rbp+	sbbq	16(%rcx),%r10+	sbbq	24(%rcx),%r11+	sbbq	32(%rcx),%r12+	movq	%r13,%rsi+	sbbq	40(%rcx),%r13+	sbbq	$0,%rdx++	cmovcq	%r14,%r8+	cmovcq	%r15,%r9+	cmovcq	%rax,%r10+	movq	%r8,0(%rdi)+	cmovcq	%rbx,%r11+	movq	%r9,8(%rdi)+	cmovcq	%rbp,%r12+	movq	%r10,16(%rdi)+	cmovcq	%rsi,%r13+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3+++.def	__sub_mod_384;	.scl 3;	.type 32;	.endef+.p2align	5+__sub_mod_384:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++__sub_mod_384_a_is_loaded:+	subq	0(%rdx),%r8+	movq	0(%rcx),%r14+	sbbq	8(%rdx),%r9+	movq	8(%rcx),%r15+	sbbq	16(%rdx),%r10+	movq	16(%rcx),%rax+	sbbq	24(%rdx),%r11+	movq	24(%rcx),%rbx+	sbbq	32(%rdx),%r12+	movq	32(%rcx),%rbp+	sbbq	40(%rdx),%r13+	movq	40(%rcx),%rsi+	sbbq	%rdx,%rdx++	andq	%rdx,%r14+	andq	%rdx,%r15+	andq	%rdx,%rax+	andq	%rdx,%rbx+	andq	%rdx,%rbp+	andq	%rdx,%rsi++	addq	%r14,%r8+	adcq	%r15,%r9+	movq	%r8,0(%rdi)+	adcq	%rax,%r10+	movq	%r9,8(%rdi)+	adcq	%rbx,%r11+	movq	%r10,16(%rdi)+	adcq	%rbp,%r12+	movq	%r11,24(%rdi)+	adcq	%rsi,%r13+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3++.globl	mulx_mont_384x++.def	mulx_mont_384x;	.scl 2;	.type 32;	.endef+.p2align	5+mulx_mont_384x:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_mulx_mont_384x:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+	movq	40(%rsp),%r8+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$328,%rsp++.LSEH_body_mulx_mont_384x:+++	movq	%rdx,%rbx+	movq	%rdi,32(%rsp)+	movq	%rsi,24(%rsp)+	movq	%rdx,16(%rsp)+	movq	%rcx,8(%rsp)+	movq	%r8,0(%rsp)+++++	leaq	40(%rsp),%rdi+	call	__mulx_384+++	leaq	48(%rbx),%rbx+	leaq	128+48(%rsi),%rsi+	leaq	96(%rdi),%rdi+	call	__mulx_384+++	movq	8(%rsp),%rcx+	leaq	(%rbx),%rsi+	leaq	-48(%rbx),%rdx+	leaq	40+192+48(%rsp),%rdi+	call	__add_mod_384++	movq	24(%rsp),%rsi+	leaq	48(%rsi),%rdx+	leaq	-48(%rdi),%rdi+	call	__add_mod_384++	leaq	(%rdi),%rbx+	leaq	48(%rdi),%rsi+	call	__mulx_384+++	leaq	(%rdi),%rsi+	leaq	40(%rsp),%rdx+	movq	8(%rsp),%rcx+	call	__sub_mod_384x384++	leaq	(%rdi),%rsi+	leaq	-96(%rdi),%rdx+	call	__sub_mod_384x384+++	leaq	40(%rsp),%rsi+	leaq	40+96(%rsp),%rdx+	leaq	40(%rsp),%rdi+	call	__sub_mod_384x384++	leaq	(%rcx),%rbx+++	leaq	40(%rsp),%rsi+	movq	0(%rsp),%rcx+	movq	32(%rsp),%rdi+	call	__mulx_by_1_mont_384+	call	__redc_tail_mont_384+++	leaq	40+192(%rsp),%rsi+	movq	0(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__mulx_by_1_mont_384+	call	__redc_tail_mont_384++	leaq	328(%rsp),%r8+	movq	0(%r8),%r15++	movq	8(%r8),%r14++	movq	16(%r8),%r13++	movq	24(%r8),%r12++	movq	32(%r8),%rbx++	movq	40(%r8),%rbp++	leaq	48(%r8),%rsp++.LSEH_epilogue_mulx_mont_384x:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_mulx_mont_384x:+.globl	sqrx_mont_384x++.def	sqrx_mont_384x;	.scl 2;	.type 32;	.endef+.p2align	5+sqrx_mont_384x:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sqrx_mont_384x:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$136,%rsp++.LSEH_body_sqrx_mont_384x:+++	movq	%rcx,0(%rsp)+	movq	%rdx,%rcx++	movq	%rdi,16(%rsp)+	movq	%rsi,24(%rsp)+++	leaq	48(%rsi),%rdx+	leaq	32(%rsp),%rdi+	call	__add_mod_384+++	movq	24(%rsp),%rsi+	leaq	48(%rsi),%rdx+	leaq	32+48(%rsp),%rdi+	call	__sub_mod_384+++	movq	24(%rsp),%rsi+	leaq	48(%rsi),%rbx++	movq	48(%rsi),%rdx+	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%rax+	movq	24(%rsi),%r12+	movq	32(%rsi),%rdi+	movq	40(%rsi),%rbp+	leaq	-128(%rsi),%rsi+	leaq	-128(%rcx),%rcx++	mulxq	%r14,%r8,%r9+	call	__mulx_mont_384+	addq	%rdx,%rdx+	adcq	%r15,%r15+	adcq	%rax,%rax+	movq	%rdx,%r8+	adcq	%r12,%r12+	movq	%r15,%r9+	adcq	%rdi,%rdi+	movq	%rax,%r10+	adcq	%rbp,%rbp+	movq	%r12,%r11+	sbbq	%rsi,%rsi++	subq	0(%rcx),%rdx+	sbbq	8(%rcx),%r15+	movq	%rdi,%r13+	sbbq	16(%rcx),%rax+	sbbq	24(%rcx),%r12+	sbbq	32(%rcx),%rdi+	movq	%rbp,%r14+	sbbq	40(%rcx),%rbp+	sbbq	$0,%rsi++	cmovcq	%r8,%rdx+	cmovcq	%r9,%r15+	cmovcq	%r10,%rax+	movq	%rdx,48(%rbx)+	cmovcq	%r11,%r12+	movq	%r15,56(%rbx)+	cmovcq	%r13,%rdi+	movq	%rax,64(%rbx)+	cmovcq	%r14,%rbp+	movq	%r12,72(%rbx)+	movq	%rdi,80(%rbx)+	movq	%rbp,88(%rbx)++	leaq	32(%rsp),%rsi+	leaq	32+48(%rsp),%rbx++	movq	32+48(%rsp),%rdx+	movq	32+0(%rsp),%r14+	movq	32+8(%rsp),%r15+	movq	32+16(%rsp),%rax+	movq	32+24(%rsp),%r12+	movq	32+32(%rsp),%rdi+	movq	32+40(%rsp),%rbp+	leaq	-128(%rsi),%rsi+	leaq	-128(%rcx),%rcx++	mulxq	%r14,%r8,%r9+	call	__mulx_mont_384++	leaq	136(%rsp),%r8+	movq	0(%r8),%r15++	movq	8(%r8),%r14++	movq	16(%r8),%r13++	movq	24(%r8),%r12++	movq	32(%r8),%rbx++	movq	40(%r8),%rbp++	leaq	48(%r8),%rsp++.LSEH_epilogue_sqrx_mont_384x:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sqrx_mont_384x:++.globl	mulx_382x++.def	mulx_382x;	.scl 2;	.type 32;	.endef+.p2align	5+mulx_382x:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_mulx_382x:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$136,%rsp++.LSEH_body_mulx_382x:+++	leaq	96(%rdi),%rdi+	movq	%rsi,0(%rsp)+	movq	%rdx,8(%rsp)+	movq	%rdi,16(%rsp)+	movq	%rcx,24(%rsp)+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	addq	48(%rsi),%r8+	adcq	56(%rsi),%r9+	adcq	64(%rsi),%r10+	adcq	72(%rsi),%r11+	adcq	80(%rsi),%r12+	adcq	88(%rsi),%r13++	movq	%r8,32+0(%rsp)+	movq	%r9,32+8(%rsp)+	movq	%r10,32+16(%rsp)+	movq	%r11,32+24(%rsp)+	movq	%r12,32+32(%rsp)+	movq	%r13,32+40(%rsp)+++	movq	0(%rdx),%r8+	movq	8(%rdx),%r9+	movq	16(%rdx),%r10+	movq	24(%rdx),%r11+	movq	32(%rdx),%r12+	movq	40(%rdx),%r13++	addq	48(%rdx),%r8+	adcq	56(%rdx),%r9+	adcq	64(%rdx),%r10+	adcq	72(%rdx),%r11+	adcq	80(%rdx),%r12+	adcq	88(%rdx),%r13++	movq	%r8,32+48(%rsp)+	movq	%r9,32+56(%rsp)+	movq	%r10,32+64(%rsp)+	movq	%r11,32+72(%rsp)+	movq	%r12,32+80(%rsp)+	movq	%r13,32+88(%rsp)+++	leaq	32+0(%rsp),%rsi+	leaq	32+48(%rsp),%rbx+	call	__mulx_384+++	movq	0(%rsp),%rsi+	movq	8(%rsp),%rbx+	leaq	-96(%rdi),%rdi+	call	__mulx_384+++	leaq	48+128(%rsi),%rsi+	leaq	48(%rbx),%rbx+	leaq	32(%rsp),%rdi+	call	__mulx_384+++	movq	16(%rsp),%rsi+	leaq	32(%rsp),%rdx+	movq	24(%rsp),%rcx+	movq	%rsi,%rdi+	call	__sub_mod_384x384+++	leaq	0(%rdi),%rsi+	leaq	-96(%rdi),%rdx+	call	__sub_mod_384x384+++	leaq	-96(%rdi),%rsi+	leaq	32(%rsp),%rdx+	leaq	-96(%rdi),%rdi+	call	__sub_mod_384x384++	leaq	136(%rsp),%r8+	movq	0(%r8),%r15++	movq	8(%r8),%r14++	movq	16(%r8),%r13++	movq	24(%r8),%r12++	movq	32(%r8),%rbx++	movq	40(%r8),%rbp++	leaq	48(%r8),%rsp++.LSEH_epilogue_mulx_382x:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_mulx_382x:+.globl	sqrx_382x++.def	sqrx_382x;	.scl 2;	.type 32;	.endef+.p2align	5+sqrx_382x:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sqrx_382x:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	pushq	%rsi++.LSEH_body_sqrx_382x:+++	movq	%rdx,%rcx+++	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%rax+	movq	24(%rsi),%rbx+	movq	32(%rsi),%rbp+	movq	40(%rsi),%rdx++	movq	%r14,%r8+	addq	48(%rsi),%r14+	movq	%r15,%r9+	adcq	56(%rsi),%r15+	movq	%rax,%r10+	adcq	64(%rsi),%rax+	movq	%rbx,%r11+	adcq	72(%rsi),%rbx+	movq	%rbp,%r12+	adcq	80(%rsi),%rbp+	movq	%rdx,%r13+	adcq	88(%rsi),%rdx++	movq	%r14,0(%rdi)+	movq	%r15,8(%rdi)+	movq	%rax,16(%rdi)+	movq	%rbx,24(%rdi)+	movq	%rbp,32(%rdi)+	movq	%rdx,40(%rdi)+++	leaq	48(%rsi),%rdx+	leaq	48(%rdi),%rdi+	call	__sub_mod_384_a_is_loaded+++	leaq	(%rdi),%rsi+	leaq	-48(%rdi),%rbx+	leaq	-48(%rdi),%rdi+	call	__mulx_384+++	movq	(%rsp),%rsi+	leaq	48(%rsi),%rbx+	leaq	96(%rdi),%rdi+	call	__mulx_384++	movq	0(%rdi),%r8+	movq	8(%rdi),%r9+	movq	16(%rdi),%r10+	movq	24(%rdi),%r11+	movq	32(%rdi),%r12+	movq	40(%rdi),%r13+	movq	48(%rdi),%r14+	movq	56(%rdi),%r15+	movq	64(%rdi),%rax+	movq	72(%rdi),%rbx+	movq	80(%rdi),%rbp+	addq	%r8,%r8+	movq	88(%rdi),%rdx+	adcq	%r9,%r9+	movq	%r8,0(%rdi)+	adcq	%r10,%r10+	movq	%r9,8(%rdi)+	adcq	%r11,%r11+	movq	%r10,16(%rdi)+	adcq	%r12,%r12+	movq	%r11,24(%rdi)+	adcq	%r13,%r13+	movq	%r12,32(%rdi)+	adcq	%r14,%r14+	movq	%r13,40(%rdi)+	adcq	%r15,%r15+	movq	%r14,48(%rdi)+	adcq	%rax,%rax+	movq	%r15,56(%rdi)+	adcq	%rbx,%rbx+	movq	%rax,64(%rdi)+	adcq	%rbp,%rbp+	movq	%rbx,72(%rdi)+	adcq	%rdx,%rdx+	movq	%rbp,80(%rdi)+	movq	%rdx,88(%rdi)++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_sqrx_382x:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sqrx_382x:+.globl	mulx_384++.def	mulx_384;	.scl 2;	.type 32;	.endef+.p2align	5+mulx_384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_mulx_384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++.LSEH_body_mulx_384:+++	movq	%rdx,%rbx+	call	__mulx_384++	movq	0(%rsp),%r15++	movq	8(%rsp),%r14++	movq	16(%rsp),%r13++	movq	24(%rsp),%r12++	movq	32(%rsp),%rbx++	movq	40(%rsp),%rbp++	leaq	48(%rsp),%rsp++.LSEH_epilogue_mulx_384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_mulx_384:++.def	__mulx_384;	.scl 3;	.type 32;	.endef+.p2align	5+__mulx_384:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rbx),%rdx+	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	leaq	-128(%rsi),%rsi++	mulxq	%r14,%r9,%rcx+	xorq	%rbp,%rbp++	mulxq	%r15,%r8,%rax+	adcxq	%rcx,%r8+	movq	%r9,0(%rdi)++	mulxq	%r10,%r9,%rcx+	adcxq	%rax,%r9++	mulxq	%r11,%r10,%rax+	adcxq	%rcx,%r10++	mulxq	%r12,%r11,%rcx+	adcxq	%rax,%r11++	mulxq	%r13,%r12,%r13+	movq	8(%rbx),%rdx+	adcxq	%rcx,%r12+	adcxq	%rbp,%r13+	mulxq	%r14,%rax,%rcx+	adcxq	%r8,%rax+	adoxq	%rcx,%r9+	movq	%rax,8(%rdi)++	mulxq	%r15,%r8,%rcx+	adcxq	%r9,%r8+	adoxq	%rcx,%r10++	mulxq	128+16(%rsi),%r9,%rax+	adcxq	%r10,%r9+	adoxq	%rax,%r11++	mulxq	128+24(%rsi),%r10,%rcx+	adcxq	%r11,%r10+	adoxq	%rcx,%r12++	mulxq	128+32(%rsi),%r11,%rax+	adcxq	%r12,%r11+	adoxq	%r13,%rax++	mulxq	128+40(%rsi),%r12,%r13+	movq	16(%rbx),%rdx+	adcxq	%rax,%r12+	adoxq	%rbp,%r13+	adcxq	%rbp,%r13+	mulxq	%r14,%rax,%rcx+	adcxq	%r8,%rax+	adoxq	%rcx,%r9+	movq	%rax,16(%rdi)++	mulxq	%r15,%r8,%rcx+	adcxq	%r9,%r8+	adoxq	%rcx,%r10++	mulxq	128+16(%rsi),%r9,%rax+	adcxq	%r10,%r9+	adoxq	%rax,%r11++	mulxq	128+24(%rsi),%r10,%rcx+	adcxq	%r11,%r10+	adoxq	%rcx,%r12++	mulxq	128+32(%rsi),%r11,%rax+	adcxq	%r12,%r11+	adoxq	%r13,%rax++	mulxq	128+40(%rsi),%r12,%r13+	movq	24(%rbx),%rdx+	adcxq	%rax,%r12+	adoxq	%rbp,%r13+	adcxq	%rbp,%r13+	mulxq	%r14,%rax,%rcx+	adcxq	%r8,%rax+	adoxq	%rcx,%r9+	movq	%rax,24(%rdi)++	mulxq	%r15,%r8,%rcx+	adcxq	%r9,%r8+	adoxq	%rcx,%r10++	mulxq	128+16(%rsi),%r9,%rax+	adcxq	%r10,%r9+	adoxq	%rax,%r11++	mulxq	128+24(%rsi),%r10,%rcx+	adcxq	%r11,%r10+	adoxq	%rcx,%r12++	mulxq	128+32(%rsi),%r11,%rax+	adcxq	%r12,%r11+	adoxq	%r13,%rax++	mulxq	128+40(%rsi),%r12,%r13+	movq	32(%rbx),%rdx+	adcxq	%rax,%r12+	adoxq	%rbp,%r13+	adcxq	%rbp,%r13+	mulxq	%r14,%rax,%rcx+	adcxq	%r8,%rax+	adoxq	%rcx,%r9+	movq	%rax,32(%rdi)++	mulxq	%r15,%r8,%rcx+	adcxq	%r9,%r8+	adoxq	%rcx,%r10++	mulxq	128+16(%rsi),%r9,%rax+	adcxq	%r10,%r9+	adoxq	%rax,%r11++	mulxq	128+24(%rsi),%r10,%rcx+	adcxq	%r11,%r10+	adoxq	%rcx,%r12++	mulxq	128+32(%rsi),%r11,%rax+	adcxq	%r12,%r11+	adoxq	%r13,%rax++	mulxq	128+40(%rsi),%r12,%r13+	movq	40(%rbx),%rdx+	adcxq	%rax,%r12+	adoxq	%rbp,%r13+	adcxq	%rbp,%r13+	mulxq	%r14,%rax,%rcx+	adcxq	%r8,%rax+	adoxq	%rcx,%r9+	movq	%rax,40(%rdi)++	mulxq	%r15,%r8,%rcx+	adcxq	%r9,%r8+	adoxq	%rcx,%r10++	mulxq	128+16(%rsi),%r9,%rax+	adcxq	%r10,%r9+	adoxq	%rax,%r11++	mulxq	128+24(%rsi),%r10,%rcx+	adcxq	%r11,%r10+	adoxq	%rcx,%r12++	mulxq	128+32(%rsi),%r11,%rax+	adcxq	%r12,%r11+	adoxq	%r13,%rax++	mulxq	128+40(%rsi),%r12,%r13+	movq	%rax,%rdx+	adcxq	%rax,%r12+	adoxq	%rbp,%r13+	adcxq	%rbp,%r13+	movq	%r8,48(%rdi)+	movq	%r9,56(%rdi)+	movq	%r10,64(%rdi)+	movq	%r11,72(%rdi)+	movq	%r12,80(%rdi)+	movq	%r13,88(%rdi)++	.byte	0xf3,0xc3++.globl	sqrx_384++.def	sqrx_384;	.scl 2;	.type 32;	.endef+.p2align	5+sqrx_384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sqrx_384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	pushq	%rdi++.LSEH_body_sqrx_384:+++	call	__sqrx_384++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_sqrx_384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sqrx_384:+.def	__sqrx_384;	.scl 3;	.type 32;	.endef+.p2align	5+__sqrx_384:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%rdx+	movq	8(%rsi),%r14+	movq	16(%rsi),%r15+	movq	24(%rsi),%rcx+	movq	32(%rsi),%rbx+++	mulxq	%r14,%r8,%rdi+	movq	40(%rsi),%rbp+	mulxq	%r15,%r9,%rax+	addq	%rdi,%r9+	mulxq	%rcx,%r10,%rdi+	adcq	%rax,%r10+	mulxq	%rbx,%r11,%rax+	adcq	%rdi,%r11+	mulxq	%rbp,%r12,%r13+	movq	%r14,%rdx+	adcq	%rax,%r12+	adcq	$0,%r13+++	xorq	%r14,%r14+	mulxq	%r15,%rdi,%rax+	adcxq	%rdi,%r10+	adoxq	%rax,%r11++	mulxq	%rcx,%rdi,%rax+	adcxq	%rdi,%r11+	adoxq	%rax,%r12++	mulxq	%rbx,%rdi,%rax+	adcxq	%rdi,%r12+	adoxq	%rax,%r13++	mulxq	%rbp,%rdi,%rax+	movq	%r15,%rdx+	adcxq	%rdi,%r13+	adoxq	%r14,%rax+	adcxq	%rax,%r14+++	xorq	%r15,%r15+	mulxq	%rcx,%rdi,%rax+	adcxq	%rdi,%r12+	adoxq	%rax,%r13++	mulxq	%rbx,%rdi,%rax+	adcxq	%rdi,%r13+	adoxq	%rax,%r14++	mulxq	%rbp,%rdi,%rax+	movq	%rcx,%rdx+	adcxq	%rdi,%r14+	adoxq	%r15,%rax+	adcxq	%rax,%r15+++	xorq	%rcx,%rcx+	mulxq	%rbx,%rdi,%rax+	adcxq	%rdi,%r14+	adoxq	%rax,%r15++	mulxq	%rbp,%rdi,%rax+	movq	%rbx,%rdx+	adcxq	%rdi,%r15+	adoxq	%rcx,%rax+	adcxq	%rax,%rcx+++	mulxq	%rbp,%rdi,%rbx+	movq	0(%rsi),%rdx+	addq	%rdi,%rcx+	movq	8(%rsp),%rdi+	adcq	$0,%rbx+++	xorq	%rbp,%rbp+	adcxq	%r8,%r8+	adcxq	%r9,%r9+	adcxq	%r10,%r10+	adcxq	%r11,%r11+	adcxq	%r12,%r12+++	mulxq	%rdx,%rdx,%rax+	movq	%rdx,0(%rdi)+	movq	8(%rsi),%rdx+	adoxq	%rax,%r8+	movq	%r8,8(%rdi)++	mulxq	%rdx,%r8,%rax+	movq	16(%rsi),%rdx+	adoxq	%r8,%r9+	adoxq	%rax,%r10+	movq	%r9,16(%rdi)+	movq	%r10,24(%rdi)++	mulxq	%rdx,%r8,%r9+	movq	24(%rsi),%rdx+	adoxq	%r8,%r11+	adoxq	%r9,%r12+	adcxq	%r13,%r13+	adcxq	%r14,%r14+	movq	%r11,32(%rdi)+	movq	%r12,40(%rdi)++	mulxq	%rdx,%r8,%r9+	movq	32(%rsi),%rdx+	adoxq	%r8,%r13+	adoxq	%r9,%r14+	adcxq	%r15,%r15+	adcxq	%rcx,%rcx+	movq	%r13,48(%rdi)+	movq	%r14,56(%rdi)++	mulxq	%rdx,%r8,%r9+	movq	40(%rsi),%rdx+	adoxq	%r8,%r15+	adoxq	%r9,%rcx+	adcxq	%rbx,%rbx+	adcxq	%rbp,%rbp+	movq	%r15,64(%rdi)+	movq	%rcx,72(%rdi)++	mulxq	%rdx,%r8,%r9+	adoxq	%r8,%rbx+	adoxq	%r9,%rbp++	movq	%rbx,80(%rdi)+	movq	%rbp,88(%rdi)++	.byte	0xf3,0xc3+++++.globl	redcx_mont_384++.def	redcx_mont_384;	.scl 2;	.type 32;	.endef+.p2align	5+redcx_mont_384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_redcx_mont_384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$8,%rsp++.LSEH_body_redcx_mont_384:+++	movq	%rdx,%rbx+	call	__mulx_by_1_mont_384+	call	__redc_tail_mont_384++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_redcx_mont_384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_redcx_mont_384:+++++.globl	fromx_mont_384++.def	fromx_mont_384;	.scl 2;	.type 32;	.endef+.p2align	5+fromx_mont_384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_fromx_mont_384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$8,%rsp++.LSEH_body_fromx_mont_384:+++	movq	%rdx,%rbx+	call	__mulx_by_1_mont_384+++++	movq	%r14,%rax+	movq	%r15,%rcx+	movq	%r8,%rdx+	movq	%r9,%rbp++	subq	0(%rbx),%r14+	sbbq	8(%rbx),%r15+	movq	%r10,%r13+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	movq	%r11,%rsi+	sbbq	40(%rbx),%r11++	cmovcq	%rax,%r14+	cmovcq	%rcx,%r15+	cmovcq	%rdx,%r8+	movq	%r14,0(%rdi)+	cmovcq	%rbp,%r9+	movq	%r15,8(%rdi)+	cmovcq	%r13,%r10+	movq	%r8,16(%rdi)+	cmovcq	%rsi,%r11+	movq	%r9,24(%rdi)+	movq	%r10,32(%rdi)+	movq	%r11,40(%rdi)++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_fromx_mont_384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_fromx_mont_384:+.def	__mulx_by_1_mont_384;	.scl 3;	.type 32;	.endef+.p2align	5+__mulx_by_1_mont_384:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	%rcx,%rdx+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	imulq	%r8,%rdx+++	xorq	%r14,%r14+	mulxq	0(%rbx),%rax,%rbp+	adcxq	%rax,%r8+	adoxq	%rbp,%r9++	mulxq	8(%rbx),%rax,%rbp+	adcxq	%rax,%r9+	adoxq	%rbp,%r10++	mulxq	16(%rbx),%rax,%rbp+	adcxq	%rax,%r10+	adoxq	%rbp,%r11++	mulxq	24(%rbx),%rax,%rbp+	adcxq	%rax,%r11+	adoxq	%rbp,%r12++	mulxq	32(%rbx),%rax,%rbp+	adcxq	%rax,%r12+	adoxq	%rbp,%r13++	mulxq	40(%rbx),%rax,%rbp+	movq	%rcx,%rdx+	adcxq	%rax,%r13+	adoxq	%r14,%rbp+	adcxq	%rbp,%r14+	imulq	%r9,%rdx+++	xorq	%r15,%r15+	mulxq	0(%rbx),%rax,%rbp+	adcxq	%rax,%r9+	adoxq	%rbp,%r10++	mulxq	8(%rbx),%rax,%rbp+	adcxq	%rax,%r10+	adoxq	%rbp,%r11++	mulxq	16(%rbx),%rax,%rbp+	adcxq	%rax,%r11+	adoxq	%rbp,%r12++	mulxq	24(%rbx),%rax,%rbp+	adcxq	%rax,%r12+	adoxq	%rbp,%r13++	mulxq	32(%rbx),%rax,%rbp+	adcxq	%rax,%r13+	adoxq	%rbp,%r14++	mulxq	40(%rbx),%rax,%rbp+	movq	%rcx,%rdx+	adcxq	%rax,%r14+	adoxq	%r15,%rbp+	adcxq	%rbp,%r15+	imulq	%r10,%rdx+++	xorq	%r8,%r8+	mulxq	0(%rbx),%rax,%rbp+	adcxq	%rax,%r10+	adoxq	%rbp,%r11++	mulxq	8(%rbx),%rax,%rbp+	adcxq	%rax,%r11+	adoxq	%rbp,%r12++	mulxq	16(%rbx),%rax,%rbp+	adcxq	%rax,%r12+	adoxq	%rbp,%r13++	mulxq	24(%rbx),%rax,%rbp+	adcxq	%rax,%r13+	adoxq	%rbp,%r14++	mulxq	32(%rbx),%rax,%rbp+	adcxq	%rax,%r14+	adoxq	%rbp,%r15++	mulxq	40(%rbx),%rax,%rbp+	movq	%rcx,%rdx+	adcxq	%rax,%r15+	adoxq	%r8,%rbp+	adcxq	%rbp,%r8+	imulq	%r11,%rdx+++	xorq	%r9,%r9+	mulxq	0(%rbx),%rax,%rbp+	adcxq	%rax,%r11+	adoxq	%rbp,%r12++	mulxq	8(%rbx),%rax,%rbp+	adcxq	%rax,%r12+	adoxq	%rbp,%r13++	mulxq	16(%rbx),%rax,%rbp+	adcxq	%rax,%r13+	adoxq	%rbp,%r14++	mulxq	24(%rbx),%rax,%rbp+	adcxq	%rax,%r14+	adoxq	%rbp,%r15++	mulxq	32(%rbx),%rax,%rbp+	adcxq	%rax,%r15+	adoxq	%rbp,%r8++	mulxq	40(%rbx),%rax,%rbp+	movq	%rcx,%rdx+	adcxq	%rax,%r8+	adoxq	%r9,%rbp+	adcxq	%rbp,%r9+	imulq	%r12,%rdx+++	xorq	%r10,%r10+	mulxq	0(%rbx),%rax,%rbp+	adcxq	%rax,%r12+	adoxq	%rbp,%r13++	mulxq	8(%rbx),%rax,%rbp+	adcxq	%rax,%r13+	adoxq	%rbp,%r14++	mulxq	16(%rbx),%rax,%rbp+	adcxq	%rax,%r14+	adoxq	%rbp,%r15++	mulxq	24(%rbx),%rax,%rbp+	adcxq	%rax,%r15+	adoxq	%rbp,%r8++	mulxq	32(%rbx),%rax,%rbp+	adcxq	%rax,%r8+	adoxq	%rbp,%r9++	mulxq	40(%rbx),%rax,%rbp+	movq	%rcx,%rdx+	adcxq	%rax,%r9+	adoxq	%r10,%rbp+	adcxq	%rbp,%r10+	imulq	%r13,%rdx+++	xorq	%r11,%r11+	mulxq	0(%rbx),%rax,%rbp+	adcxq	%rax,%r13+	adoxq	%rbp,%r14++	mulxq	8(%rbx),%rax,%rbp+	adcxq	%rax,%r14+	adoxq	%rbp,%r15++	mulxq	16(%rbx),%rax,%rbp+	adcxq	%rax,%r15+	adoxq	%rbp,%r8++	mulxq	24(%rbx),%rax,%rbp+	adcxq	%rax,%r8+	adoxq	%rbp,%r9++	mulxq	32(%rbx),%rax,%rbp+	adcxq	%rax,%r9+	adoxq	%rbp,%r10++	mulxq	40(%rbx),%rax,%rbp+	movq	%rcx,%rdx+	adcxq	%rax,%r10+	adoxq	%r11,%rbp+	adcxq	%rbp,%r11+	.byte	0xf3,0xc3+++.def	__redc_tail_mont_384;	.scl 3;	.type 32;	.endef+.p2align	5+__redc_tail_mont_384:+	.byte	0xf3,0x0f,0x1e,0xfa++	addq	48(%rsi),%r14+	movq	%r14,%rax+	adcq	56(%rsi),%r15+	adcq	64(%rsi),%r8+	adcq	72(%rsi),%r9+	movq	%r15,%rcx+	adcq	80(%rsi),%r10+	adcq	88(%rsi),%r11+	sbbq	%r12,%r12+++++	movq	%r8,%rdx+	movq	%r9,%rbp++	subq	0(%rbx),%r14+	sbbq	8(%rbx),%r15+	movq	%r10,%r13+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	movq	%r11,%rsi+	sbbq	40(%rbx),%r11+	sbbq	$0,%r12++	cmovcq	%rax,%r14+	cmovcq	%rcx,%r15+	cmovcq	%rdx,%r8+	movq	%r14,0(%rdi)+	cmovcq	%rbp,%r9+	movq	%r15,8(%rdi)+	cmovcq	%r13,%r10+	movq	%r8,16(%rdi)+	cmovcq	%rsi,%r11+	movq	%r9,24(%rdi)+	movq	%r10,32(%rdi)+	movq	%r11,40(%rdi)++	.byte	0xf3,0xc3+++.globl	sgn0x_pty_mont_384++.def	sgn0x_pty_mont_384;	.scl 2;	.type 32;	.endef+.p2align	5+sgn0x_pty_mont_384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sgn0x_pty_mont_384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$8,%rsp++.LSEH_body_sgn0x_pty_mont_384:+++	movq	%rsi,%rbx+	leaq	0(%rdi),%rsi+	movq	%rdx,%rcx+	call	__mulx_by_1_mont_384++	xorq	%rax,%rax+	movq	%r14,%r13+	addq	%r14,%r14+	adcq	%r15,%r15+	adcq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	$0,%rax++	subq	0(%rbx),%r14+	sbbq	8(%rbx),%r15+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	sbbq	40(%rbx),%r11+	sbbq	$0,%rax++	notq	%rax+	andq	$1,%r13+	andq	$2,%rax+	orq	%r13,%rax++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_sgn0x_pty_mont_384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sgn0x_pty_mont_384:++.globl	sgn0x_pty_mont_384x++.def	sgn0x_pty_mont_384x;	.scl 2;	.type 32;	.endef+.p2align	5+sgn0x_pty_mont_384x:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sgn0x_pty_mont_384x:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$8,%rsp++.LSEH_body_sgn0x_pty_mont_384x:+++	movq	%rsi,%rbx+	leaq	48(%rdi),%rsi+	movq	%rdx,%rcx+	call	__mulx_by_1_mont_384++	movq	%r14,%r12+	orq	%r15,%r14+	orq	%r8,%r14+	orq	%r9,%r14+	orq	%r10,%r14+	orq	%r11,%r14++	leaq	0(%rdi),%rsi+	xorq	%rdi,%rdi+	movq	%r12,%r13+	addq	%r12,%r12+	adcq	%r15,%r15+	adcq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	$0,%rdi++	subq	0(%rbx),%r12+	sbbq	8(%rbx),%r15+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	sbbq	40(%rbx),%r11+	sbbq	$0,%rdi++	movq	%r14,0(%rsp)+	notq	%rdi+	andq	$1,%r13+	andq	$2,%rdi+	orq	%r13,%rdi++	call	__mulx_by_1_mont_384++	movq	%r14,%r12+	orq	%r15,%r14+	orq	%r8,%r14+	orq	%r9,%r14+	orq	%r10,%r14+	orq	%r11,%r14++	xorq	%rax,%rax+	movq	%r12,%r13+	addq	%r12,%r12+	adcq	%r15,%r15+	adcq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	$0,%rax++	subq	0(%rbx),%r12+	sbbq	8(%rbx),%r15+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	sbbq	40(%rbx),%r11+	sbbq	$0,%rax++	movq	0(%rsp),%r12++	notq	%rax++	testq	%r14,%r14+	cmovzq	%rdi,%r13++	testq	%r12,%r12+	cmovnzq	%rdi,%rax++	andq	$1,%r13+	andq	$2,%rax+	orq	%r13,%rax++	movq	8(%rsp),%r15++	movq	16(%rsp),%r14++	movq	24(%rsp),%r13++	movq	32(%rsp),%r12++	movq	40(%rsp),%rbx++	movq	48(%rsp),%rbp++	leaq	56(%rsp),%rsp++.LSEH_epilogue_sgn0x_pty_mont_384x:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sgn0x_pty_mont_384x:+.globl	mulx_mont_384++.def	mulx_mont_384;	.scl 2;	.type 32;	.endef+.p2align	5+mulx_mont_384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_mulx_mont_384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+	movq	40(%rsp),%r8+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	leaq	-24(%rsp),%rsp++.LSEH_body_mulx_mont_384:+++	movq	%rdx,%rbx+	movq	0(%rdx),%rdx+	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%rax+	movq	24(%rsi),%r12+	movq	%rdi,16(%rsp)+	movq	32(%rsi),%rdi+	movq	40(%rsi),%rbp+	leaq	-128(%rsi),%rsi+	leaq	-128(%rcx),%rcx+	movq	%r8,(%rsp)++	mulxq	%r14,%r8,%r9+	call	__mulx_mont_384++	movq	24(%rsp),%r15++	movq	32(%rsp),%r14++	movq	40(%rsp),%r13++	movq	48(%rsp),%r12++	movq	56(%rsp),%rbx++	movq	64(%rsp),%rbp++	leaq	72(%rsp),%rsp++.LSEH_epilogue_mulx_mont_384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_mulx_mont_384:+.def	__mulx_mont_384;	.scl 3;	.type 32;	.endef+.p2align	5+__mulx_mont_384:+	.byte	0xf3,0x0f,0x1e,0xfa+++	mulxq	%r15,%r14,%r10+	mulxq	%rax,%r15,%r11+	addq	%r14,%r9+	mulxq	%r12,%rax,%r12+	adcq	%r15,%r10+	mulxq	%rdi,%rdi,%r13+	adcq	%rax,%r11+	mulxq	%rbp,%rbp,%r14+	movq	8(%rbx),%rdx+	adcq	%rdi,%r12+	adcq	%rbp,%r13+	adcq	$0,%r14+	xorq	%r15,%r15++	movq	%r8,16(%rsp)+	imulq	8(%rsp),%r8+++	xorq	%rax,%rax+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r9+	adcxq	%rbp,%r10++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r10+	adcxq	%rbp,%r11++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r11+	adcxq	%rbp,%r12++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r12+	adcxq	%rbp,%r13++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r8,%rdx+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15+	adoxq	%rax,%r15+	adoxq	%rax,%rax+++	xorq	%r8,%r8+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	16(%rsp),%rdi+	adoxq	%rbp,%r9++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r9+	adoxq	%rbp,%r10++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r10+	adoxq	%rbp,%r11++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r11+	adoxq	%rbp,%r12++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r12+	adoxq	%rbp,%r13++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	16(%rbx),%rdx+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14+	adcxq	%r8,%r14+	adoxq	%r8,%r15+	adcxq	%r8,%r15+	adoxq	%r8,%rax+	adcxq	%r8,%rax+	movq	%r9,16(%rsp)+	imulq	8(%rsp),%r9+++	xorq	%r8,%r8+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r10+	adcxq	%rbp,%r11++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r11+	adcxq	%rbp,%r12++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r12+	adcxq	%rbp,%r13++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r9,%rdx+	adoxq	%rdi,%r15+	adcxq	%rbp,%rax+	adoxq	%r8,%rax+	adoxq	%r8,%r8+++	xorq	%r9,%r9+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	16(%rsp),%rdi+	adoxq	%rbp,%r10++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r10+	adoxq	%rbp,%r11++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r11+	adoxq	%rbp,%r12++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r12+	adoxq	%rbp,%r13++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	24(%rbx),%rdx+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15+	adcxq	%r9,%r15+	adoxq	%r9,%rax+	adcxq	%r9,%rax+	adoxq	%r9,%r8+	adcxq	%r9,%r8+	movq	%r10,16(%rsp)+	imulq	8(%rsp),%r10+++	xorq	%r9,%r9+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r11+	adcxq	%rbp,%r12++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r12+	adcxq	%rbp,%r13++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r15+	adcxq	%rbp,%rax++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r10,%rdx+	adoxq	%rdi,%rax+	adcxq	%rbp,%r8+	adoxq	%r9,%r8+	adoxq	%r9,%r9+++	xorq	%r10,%r10+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	16(%rsp),%rdi+	adoxq	%rbp,%r11++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r11+	adoxq	%rbp,%r12++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r12+	adoxq	%rbp,%r13++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	32(%rbx),%rdx+	adcxq	%rdi,%r15+	adoxq	%rbp,%rax+	adcxq	%r10,%rax+	adoxq	%r10,%r8+	adcxq	%r10,%r8+	adoxq	%r10,%r9+	adcxq	%r10,%r9+	movq	%r11,16(%rsp)+	imulq	8(%rsp),%r11+++	xorq	%r10,%r10+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r12+	adcxq	%rbp,%r13++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r15+	adcxq	%rbp,%rax++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%rax+	adcxq	%rbp,%r8++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r11,%rdx+	adoxq	%rdi,%r8+	adcxq	%rbp,%r9+	adoxq	%r10,%r9+	adoxq	%r10,%r10+++	xorq	%r11,%r11+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	16(%rsp),%rdi+	adoxq	%rbp,%r12++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r12+	adoxq	%rbp,%r13++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r15+	adoxq	%rbp,%rax++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	40(%rbx),%rdx+	adcxq	%rdi,%rax+	adoxq	%rbp,%r8+	adcxq	%r11,%r8+	adoxq	%r11,%r9+	adcxq	%r11,%r9+	adoxq	%r11,%r10+	adcxq	%r11,%r10+	movq	%r12,16(%rsp)+	imulq	8(%rsp),%r12+++	xorq	%r11,%r11+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r15+	adcxq	%rbp,%rax++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%rax+	adcxq	%rbp,%r8++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r8+	adcxq	%rbp,%r9++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r12,%rdx+	adoxq	%rdi,%r9+	adcxq	%rbp,%r10+	adoxq	%r11,%r10+	adoxq	%r11,%r11+++	xorq	%r12,%r12+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	16(%rsp),%rdi+	adoxq	%rbp,%r13++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r15+	adoxq	%rbp,%rax++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%rax+	adoxq	%rbp,%r8++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	%r13,%rdx+	adcxq	%rdi,%r8+	adoxq	%rbp,%r9+	adcxq	%r12,%r9+	adoxq	%r12,%r10+	adcxq	%r12,%r10+	adoxq	%r12,%r11+	adcxq	%r12,%r11+	imulq	8(%rsp),%rdx+	movq	24(%rsp),%rbx+++	xorq	%r12,%r12+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r15+	adoxq	%rbp,%rax++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%rax+	adoxq	%rbp,%r8+	movq	%r15,%r13++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r8+	adoxq	%rbp,%r9+	movq	%rax,%rsi++	mulxq	40+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r9+	adoxq	%rbp,%r10+	movq	%r14,%rdx+	adcxq	%r12,%r10+	adoxq	%r12,%r11+	leaq	128(%rcx),%rcx+	movq	%r8,%r12+	adcq	$0,%r11+++++	subq	0(%rcx),%r14+	sbbq	8(%rcx),%r15+	movq	%r9,%rdi+	sbbq	16(%rcx),%rax+	sbbq	24(%rcx),%r8+	sbbq	32(%rcx),%r9+	movq	%r10,%rbp+	sbbq	40(%rcx),%r10+	sbbq	$0,%r11++	cmovncq	%r14,%rdx+	cmovcq	%r13,%r15+	cmovcq	%rsi,%rax+	cmovncq	%r8,%r12+	movq	%rdx,0(%rbx)+	cmovncq	%r9,%rdi+	movq	%r15,8(%rbx)+	cmovncq	%r10,%rbp+	movq	%rax,16(%rbx)+	movq	%r12,24(%rbx)+	movq	%rdi,32(%rbx)+	movq	%rbp,40(%rbx)++	.byte	0xf3,0xc3+++.globl	sqrx_mont_384++.def	sqrx_mont_384;	.scl 2;	.type 32;	.endef+.p2align	5+sqrx_mont_384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sqrx_mont_384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	leaq	-24(%rsp),%rsp++.LSEH_body_sqrx_mont_384:+++	movq	%rcx,%r8+	leaq	-128(%rdx),%rcx+	movq	0(%rsi),%rdx+	movq	8(%rsi),%r15+	movq	16(%rsi),%rax+	movq	24(%rsi),%r12+	movq	%rdi,16(%rsp)+	movq	32(%rsi),%rdi+	movq	40(%rsi),%rbp++	leaq	(%rsi),%rbx+	movq	%r8,(%rsp)+	leaq	-128(%rsi),%rsi++	mulxq	%rdx,%r8,%r9+	call	__mulx_mont_384++	movq	24(%rsp),%r15++	movq	32(%rsp),%r14++	movq	40(%rsp),%r13++	movq	48(%rsp),%r12++	movq	56(%rsp),%rbx++	movq	64(%rsp),%rbp++	leaq	72(%rsp),%rsp++.LSEH_epilogue_sqrx_mont_384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sqrx_mont_384:++.globl	sqrx_n_mul_mont_384++.def	sqrx_n_mul_mont_384;	.scl 2;	.type 32;	.endef+.p2align	5+sqrx_n_mul_mont_384:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sqrx_n_mul_mont_384:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+	movq	40(%rsp),%r8+	movq	48(%rsp),%r9+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	leaq	-40(%rsp),%rsp++.LSEH_body_sqrx_n_mul_mont_384:+++	movq	%rdx,%r10+	movq	0(%rsi),%rdx+	movq	8(%rsi),%r15+	movq	16(%rsi),%rax+	movq	%rsi,%rbx+	movq	24(%rsi),%r12+	movq	%rdi,16(%rsp)+	movq	32(%rsi),%rdi+	movq	40(%rsi),%rbp++	movq	%r8,(%rsp)+	movq	%r9,24(%rsp)+	movq	0(%r9),%xmm2++.Loop_sqrx_384:+	movd	%r10d,%xmm1+	leaq	-128(%rbx),%rsi+	leaq	-128(%rcx),%rcx++	mulxq	%rdx,%r8,%r9+	call	__mulx_mont_384++	movd	%xmm1,%r10d+	decl	%r10d+	jnz	.Loop_sqrx_384++	movq	%rdx,%r14+.byte	102,72,15,126,210+	leaq	-128(%rbx),%rsi+	movq	24(%rsp),%rbx+	leaq	-128(%rcx),%rcx++	mulxq	%r14,%r8,%r9+	call	__mulx_mont_384++	movq	40(%rsp),%r15++	movq	48(%rsp),%r14++	movq	56(%rsp),%r13++	movq	64(%rsp),%r12++	movq	72(%rsp),%rbx++	movq	80(%rsp),%rbp++	leaq	88(%rsp),%rsp++.LSEH_epilogue_sqrx_n_mul_mont_384:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sqrx_n_mul_mont_384:++.globl	sqrx_n_mul_mont_383++.def	sqrx_n_mul_mont_383;	.scl 2;	.type 32;	.endef+.p2align	5+sqrx_n_mul_mont_383:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sqrx_n_mul_mont_383:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+	movq	40(%rsp),%r8+	movq	48(%rsp),%r9+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	leaq	-40(%rsp),%rsp++.LSEH_body_sqrx_n_mul_mont_383:+++	movq	%rdx,%r10+	movq	0(%rsi),%rdx+	movq	8(%rsi),%r15+	movq	16(%rsi),%rax+	movq	%rsi,%rbx+	movq	24(%rsi),%r12+	movq	%rdi,16(%rsp)+	movq	32(%rsi),%rdi+	movq	40(%rsi),%rbp++	movq	%r8,(%rsp)+	movq	%r9,24(%rsp)+	movq	0(%r9),%xmm2+	leaq	-128(%rcx),%rcx++.Loop_sqrx_383:+	movd	%r10d,%xmm1+	leaq	-128(%rbx),%rsi++	mulxq	%rdx,%r8,%r9+	call	__mulx_mont_383_nonred++	movd	%xmm1,%r10d+	decl	%r10d+	jnz	.Loop_sqrx_383++	movq	%rdx,%r14+.byte	102,72,15,126,210+	leaq	-128(%rbx),%rsi+	movq	24(%rsp),%rbx++	mulxq	%r14,%r8,%r9+	call	__mulx_mont_384++	movq	40(%rsp),%r15++	movq	48(%rsp),%r14++	movq	56(%rsp),%r13++	movq	64(%rsp),%r12++	movq	72(%rsp),%rbx++	movq	80(%rsp),%rbp++	leaq	88(%rsp),%rsp++.LSEH_epilogue_sqrx_n_mul_mont_383:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sqrx_n_mul_mont_383:+.def	__mulx_mont_383_nonred;	.scl 3;	.type 32;	.endef+.p2align	5+__mulx_mont_383_nonred:+	.byte	0xf3,0x0f,0x1e,0xfa+++	mulxq	%r15,%r14,%r10+	mulxq	%rax,%r15,%r11+	addq	%r14,%r9+	mulxq	%r12,%rax,%r12+	adcq	%r15,%r10+	mulxq	%rdi,%rdi,%r13+	adcq	%rax,%r11+	mulxq	%rbp,%rbp,%r14+	movq	8(%rbx),%rdx+	adcq	%rdi,%r12+	adcq	%rbp,%r13+	adcq	$0,%r14+	movq	%r8,%rax+	imulq	8(%rsp),%r8+++	xorq	%r15,%r15+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r9+	adcxq	%rbp,%r10++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r10+	adcxq	%rbp,%r11++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r11+	adcxq	%rbp,%r12++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r12+	adcxq	%rbp,%r13++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r8,%rdx+	adoxq	%rdi,%r14+	adcxq	%r15,%rbp+	adoxq	%rbp,%r15+++	xorq	%r8,%r8+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%rax+	adoxq	%rbp,%r9++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r9+	adoxq	%rbp,%r10++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r10+	adoxq	%rbp,%r11++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r11+	adoxq	%rbp,%r12++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r12+	adoxq	%rbp,%r13++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	16(%rbx),%rdx+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14+	adcxq	%rax,%r14+	adoxq	%rax,%r15+	adcxq	%rax,%r15+	movq	%r9,%r8+	imulq	8(%rsp),%r9+++	xorq	%rax,%rax+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r10+	adcxq	%rbp,%r11++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r11+	adcxq	%rbp,%r12++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r12+	adcxq	%rbp,%r13++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r9,%rdx+	adoxq	%rdi,%r15+	adcxq	%rax,%rbp+	adoxq	%rbp,%rax+++	xorq	%r9,%r9+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r8+	adoxq	%rbp,%r10++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r10+	adoxq	%rbp,%r11++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r11+	adoxq	%rbp,%r12++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r12+	adoxq	%rbp,%r13++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	24(%rbx),%rdx+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15+	adcxq	%r8,%r15+	adoxq	%r8,%rax+	adcxq	%r8,%rax+	movq	%r10,%r9+	imulq	8(%rsp),%r10+++	xorq	%r8,%r8+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r11+	adcxq	%rbp,%r12++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r12+	adcxq	%rbp,%r13++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r15+	adcxq	%rbp,%rax++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r10,%rdx+	adoxq	%rdi,%rax+	adcxq	%r8,%rbp+	adoxq	%rbp,%r8+++	xorq	%r10,%r10+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r9+	adoxq	%rbp,%r11++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r11+	adoxq	%rbp,%r12++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r12+	adoxq	%rbp,%r13++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	32(%rbx),%rdx+	adcxq	%rdi,%r15+	adoxq	%rbp,%rax+	adcxq	%r9,%rax+	adoxq	%r9,%r8+	adcxq	%r9,%r8+	movq	%r11,%r10+	imulq	8(%rsp),%r11+++	xorq	%r9,%r9+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r12+	adcxq	%rbp,%r13++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r15+	adcxq	%rbp,%rax++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%rax+	adcxq	%rbp,%r8++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r11,%rdx+	adoxq	%rdi,%r8+	adcxq	%r9,%rbp+	adoxq	%rbp,%r9+++	xorq	%r11,%r11+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r10+	adoxq	%rbp,%r12++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r12+	adoxq	%rbp,%r13++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r15+	adoxq	%rbp,%rax++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	40(%rbx),%rdx+	adcxq	%rdi,%rax+	adoxq	%rbp,%r8+	adcxq	%r10,%r8+	adoxq	%r10,%r9+	adcxq	%r10,%r9+	movq	%r12,%r11+	imulq	8(%rsp),%r12+++	xorq	%r10,%r10+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r15+	adcxq	%rbp,%rax++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%rax+	adcxq	%rbp,%r8++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r8+	adcxq	%rbp,%r9++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r12,%rdx+	adoxq	%rdi,%r9+	adcxq	%r10,%rbp+	adoxq	%rbp,%r10+++	xorq	%r12,%r12+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r11+	adoxq	%rbp,%r13++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r15+	adoxq	%rbp,%rax++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%rax+	adoxq	%rbp,%r8++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	%r13,%rdx+	adcxq	%rdi,%r8+	adoxq	%rbp,%r9+	adcxq	%r11,%r9+	adoxq	%r11,%r10+	adcxq	%r11,%r10+	imulq	8(%rsp),%rdx+	movq	24(%rsp),%rbx+++	xorq	%r12,%r12+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r15+	adoxq	%rbp,%rax++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%rax+	adoxq	%rbp,%r8++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r8+	adoxq	%rbp,%r9++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	%r14,%rdx+	adcxq	%rdi,%r9+	adoxq	%rbp,%r10+	adcq	$0,%r10+	movq	%r8,%r12++	movq	%r14,0(%rbx)+	movq	%r15,8(%rbx)+	movq	%rax,16(%rbx)+	movq	%r9,%rdi+	movq	%r8,24(%rbx)+	movq	%r9,32(%rbx)+	movq	%r10,40(%rbx)+	movq	%r10,%rbp++	.byte	0xf3,0xc3+++.globl	sqrx_mont_382x++.def	sqrx_mont_382x;	.scl 2;	.type 32;	.endef+.p2align	5+sqrx_mont_382x:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_sqrx_mont_382x:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+	movq	%r9,%rcx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	subq	$136,%rsp++.LSEH_body_sqrx_mont_382x:+++	movq	%rcx,0(%rsp)+	movq	%rdx,%rcx+	movq	%rdi,16(%rsp)+	movq	%rsi,24(%rsp)+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%r8,%r14+	addq	48(%rsi),%r8+	movq	%r9,%r15+	adcq	56(%rsi),%r9+	movq	%r10,%rax+	adcq	64(%rsi),%r10+	movq	%r11,%rdx+	adcq	72(%rsi),%r11+	movq	%r12,%rbx+	adcq	80(%rsi),%r12+	movq	%r13,%rbp+	adcq	88(%rsi),%r13++	subq	48(%rsi),%r14+	sbbq	56(%rsi),%r15+	sbbq	64(%rsi),%rax+	sbbq	72(%rsi),%rdx+	sbbq	80(%rsi),%rbx+	sbbq	88(%rsi),%rbp+	sbbq	%rdi,%rdi++	movq	%r8,32+0(%rsp)+	movq	%r9,32+8(%rsp)+	movq	%r10,32+16(%rsp)+	movq	%r11,32+24(%rsp)+	movq	%r12,32+32(%rsp)+	movq	%r13,32+40(%rsp)++	movq	%r14,32+48(%rsp)+	movq	%r15,32+56(%rsp)+	movq	%rax,32+64(%rsp)+	movq	%rdx,32+72(%rsp)+	movq	%rbx,32+80(%rsp)+	movq	%rbp,32+88(%rsp)+	movq	%rdi,32+96(%rsp)++++	leaq	48(%rsi),%rbx++	movq	48(%rsi),%rdx+	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%rax+	movq	24(%rsi),%r12+	movq	32(%rsi),%rdi+	movq	40(%rsi),%rbp+	leaq	-128(%rsi),%rsi+	leaq	-128(%rcx),%rcx++	mulxq	%r14,%r8,%r9+	call	__mulx_mont_383_nonred+	addq	%rdx,%rdx+	adcq	%r15,%r15+	adcq	%rax,%rax+	adcq	%r12,%r12+	adcq	%rdi,%rdi+	adcq	%rbp,%rbp++	movq	%rdx,48(%rbx)+	movq	%r15,56(%rbx)+	movq	%rax,64(%rbx)+	movq	%r12,72(%rbx)+	movq	%rdi,80(%rbx)+	movq	%rbp,88(%rbx)++	leaq	32-128(%rsp),%rsi+	leaq	32+48(%rsp),%rbx++	movq	32+48(%rsp),%rdx+	movq	32+0(%rsp),%r14+	movq	32+8(%rsp),%r15+	movq	32+16(%rsp),%rax+	movq	32+24(%rsp),%r12+	movq	32+32(%rsp),%rdi+	movq	32+40(%rsp),%rbp++++	mulxq	%r14,%r8,%r9+	call	__mulx_mont_383_nonred+	movq	32+96(%rsp),%r14+	leaq	128(%rcx),%rcx+	movq	32+0(%rsp),%r8+	andq	%r14,%r8+	movq	32+8(%rsp),%r9+	andq	%r14,%r9+	movq	32+16(%rsp),%r10+	andq	%r14,%r10+	movq	32+24(%rsp),%r11+	andq	%r14,%r11+	movq	32+32(%rsp),%r13+	andq	%r14,%r13+	andq	32+40(%rsp),%r14++	subq	%r8,%rdx+	movq	0(%rcx),%r8+	sbbq	%r9,%r15+	movq	8(%rcx),%r9+	sbbq	%r10,%rax+	movq	16(%rcx),%r10+	sbbq	%r11,%r12+	movq	24(%rcx),%r11+	sbbq	%r13,%rdi+	movq	32(%rcx),%r13+	sbbq	%r14,%rbp+	sbbq	%r14,%r14++	andq	%r14,%r8+	andq	%r14,%r9+	andq	%r14,%r10+	andq	%r14,%r11+	andq	%r14,%r13+	andq	40(%rcx),%r14++	addq	%r8,%rdx+	adcq	%r9,%r15+	adcq	%r10,%rax+	adcq	%r11,%r12+	adcq	%r13,%rdi+	adcq	%r14,%rbp++	movq	%rdx,0(%rbx)+	movq	%r15,8(%rbx)+	movq	%rax,16(%rbx)+	movq	%r12,24(%rbx)+	movq	%rdi,32(%rbx)+	movq	%rbp,40(%rbx)+	leaq	136(%rsp),%r8+	movq	0(%r8),%r15++	movq	8(%r8),%r14++	movq	16(%r8),%r13++	movq	24(%r8),%r12++	movq	32(%r8),%rbx++	movq	40(%r8),%rbp++	leaq	48(%r8),%rsp++.LSEH_epilogue_sqrx_mont_382x:+	mov	8(%rsp),%rdi+	mov	16(%rsp),%rsi++	.byte	0xf3,0xc3++.LSEH_end_sqrx_mont_382x:+.section	.pdata+.p2align	2+.rva	.LSEH_begin_mulx_mont_384x+.rva	.LSEH_body_mulx_mont_384x+.rva	.LSEH_info_mulx_mont_384x_prologue++.rva	.LSEH_body_mulx_mont_384x+.rva	.LSEH_epilogue_mulx_mont_384x+.rva	.LSEH_info_mulx_mont_384x_body++.rva	.LSEH_epilogue_mulx_mont_384x+.rva	.LSEH_end_mulx_mont_384x+.rva	.LSEH_info_mulx_mont_384x_epilogue++.rva	.LSEH_begin_sqrx_mont_384x+.rva	.LSEH_body_sqrx_mont_384x+.rva	.LSEH_info_sqrx_mont_384x_prologue++.rva	.LSEH_body_sqrx_mont_384x+.rva	.LSEH_epilogue_sqrx_mont_384x+.rva	.LSEH_info_sqrx_mont_384x_body++.rva	.LSEH_epilogue_sqrx_mont_384x+.rva	.LSEH_end_sqrx_mont_384x+.rva	.LSEH_info_sqrx_mont_384x_epilogue++.rva	.LSEH_begin_mulx_382x+.rva	.LSEH_body_mulx_382x+.rva	.LSEH_info_mulx_382x_prologue++.rva	.LSEH_body_mulx_382x+.rva	.LSEH_epilogue_mulx_382x+.rva	.LSEH_info_mulx_382x_body++.rva	.LSEH_epilogue_mulx_382x+.rva	.LSEH_end_mulx_382x+.rva	.LSEH_info_mulx_382x_epilogue++.rva	.LSEH_begin_sqrx_382x+.rva	.LSEH_body_sqrx_382x+.rva	.LSEH_info_sqrx_382x_prologue++.rva	.LSEH_body_sqrx_382x+.rva	.LSEH_epilogue_sqrx_382x+.rva	.LSEH_info_sqrx_382x_body++.rva	.LSEH_epilogue_sqrx_382x+.rva	.LSEH_end_sqrx_382x+.rva	.LSEH_info_sqrx_382x_epilogue++.rva	.LSEH_begin_mulx_384+.rva	.LSEH_body_mulx_384+.rva	.LSEH_info_mulx_384_prologue++.rva	.LSEH_body_mulx_384+.rva	.LSEH_epilogue_mulx_384+.rva	.LSEH_info_mulx_384_body++.rva	.LSEH_epilogue_mulx_384+.rva	.LSEH_end_mulx_384+.rva	.LSEH_info_mulx_384_epilogue++.rva	.LSEH_begin_sqrx_384+.rva	.LSEH_body_sqrx_384+.rva	.LSEH_info_sqrx_384_prologue++.rva	.LSEH_body_sqrx_384+.rva	.LSEH_epilogue_sqrx_384+.rva	.LSEH_info_sqrx_384_body++.rva	.LSEH_epilogue_sqrx_384+.rva	.LSEH_end_sqrx_384+.rva	.LSEH_info_sqrx_384_epilogue++.rva	.LSEH_begin_redcx_mont_384+.rva	.LSEH_body_redcx_mont_384+.rva	.LSEH_info_redcx_mont_384_prologue++.rva	.LSEH_body_redcx_mont_384+.rva	.LSEH_epilogue_redcx_mont_384+.rva	.LSEH_info_redcx_mont_384_body++.rva	.LSEH_epilogue_redcx_mont_384+.rva	.LSEH_end_redcx_mont_384+.rva	.LSEH_info_redcx_mont_384_epilogue++.rva	.LSEH_begin_fromx_mont_384+.rva	.LSEH_body_fromx_mont_384+.rva	.LSEH_info_fromx_mont_384_prologue++.rva	.LSEH_body_fromx_mont_384+.rva	.LSEH_epilogue_fromx_mont_384+.rva	.LSEH_info_fromx_mont_384_body++.rva	.LSEH_epilogue_fromx_mont_384+.rva	.LSEH_end_fromx_mont_384+.rva	.LSEH_info_fromx_mont_384_epilogue++.rva	.LSEH_begin_sgn0x_pty_mont_384+.rva	.LSEH_body_sgn0x_pty_mont_384+.rva	.LSEH_info_sgn0x_pty_mont_384_prologue++.rva	.LSEH_body_sgn0x_pty_mont_384+.rva	.LSEH_epilogue_sgn0x_pty_mont_384+.rva	.LSEH_info_sgn0x_pty_mont_384_body++.rva	.LSEH_epilogue_sgn0x_pty_mont_384+.rva	.LSEH_end_sgn0x_pty_mont_384+.rva	.LSEH_info_sgn0x_pty_mont_384_epilogue++.rva	.LSEH_begin_sgn0x_pty_mont_384x+.rva	.LSEH_body_sgn0x_pty_mont_384x+.rva	.LSEH_info_sgn0x_pty_mont_384x_prologue++.rva	.LSEH_body_sgn0x_pty_mont_384x+.rva	.LSEH_epilogue_sgn0x_pty_mont_384x+.rva	.LSEH_info_sgn0x_pty_mont_384x_body++.rva	.LSEH_epilogue_sgn0x_pty_mont_384x+.rva	.LSEH_end_sgn0x_pty_mont_384x+.rva	.LSEH_info_sgn0x_pty_mont_384x_epilogue++.rva	.LSEH_begin_mulx_mont_384+.rva	.LSEH_body_mulx_mont_384+.rva	.LSEH_info_mulx_mont_384_prologue++.rva	.LSEH_body_mulx_mont_384+.rva	.LSEH_epilogue_mulx_mont_384+.rva	.LSEH_info_mulx_mont_384_body++.rva	.LSEH_epilogue_mulx_mont_384+.rva	.LSEH_end_mulx_mont_384+.rva	.LSEH_info_mulx_mont_384_epilogue++.rva	.LSEH_begin_sqrx_mont_384+.rva	.LSEH_body_sqrx_mont_384+.rva	.LSEH_info_sqrx_mont_384_prologue++.rva	.LSEH_body_sqrx_mont_384+.rva	.LSEH_epilogue_sqrx_mont_384+.rva	.LSEH_info_sqrx_mont_384_body++.rva	.LSEH_epilogue_sqrx_mont_384+.rva	.LSEH_end_sqrx_mont_384+.rva	.LSEH_info_sqrx_mont_384_epilogue++.rva	.LSEH_begin_sqrx_n_mul_mont_384+.rva	.LSEH_body_sqrx_n_mul_mont_384+.rva	.LSEH_info_sqrx_n_mul_mont_384_prologue++.rva	.LSEH_body_sqrx_n_mul_mont_384+.rva	.LSEH_epilogue_sqrx_n_mul_mont_384+.rva	.LSEH_info_sqrx_n_mul_mont_384_body++.rva	.LSEH_epilogue_sqrx_n_mul_mont_384+.rva	.LSEH_end_sqrx_n_mul_mont_384+.rva	.LSEH_info_sqrx_n_mul_mont_384_epilogue++.rva	.LSEH_begin_sqrx_n_mul_mont_383+.rva	.LSEH_body_sqrx_n_mul_mont_383+.rva	.LSEH_info_sqrx_n_mul_mont_383_prologue++.rva	.LSEH_body_sqrx_n_mul_mont_383+.rva	.LSEH_epilogue_sqrx_n_mul_mont_383+.rva	.LSEH_info_sqrx_n_mul_mont_383_body++.rva	.LSEH_epilogue_sqrx_n_mul_mont_383+.rva	.LSEH_end_sqrx_n_mul_mont_383+.rva	.LSEH_info_sqrx_n_mul_mont_383_epilogue++.rva	.LSEH_begin_sqrx_mont_382x+.rva	.LSEH_body_sqrx_mont_382x+.rva	.LSEH_info_sqrx_mont_382x_prologue++.rva	.LSEH_body_sqrx_mont_382x+.rva	.LSEH_epilogue_sqrx_mont_382x+.rva	.LSEH_info_sqrx_mont_382x_body++.rva	.LSEH_epilogue_sqrx_mont_382x+.rva	.LSEH_end_sqrx_mont_382x+.rva	.LSEH_info_sqrx_mont_382x_epilogue++.section	.xdata+.p2align	3+.LSEH_info_mulx_mont_384x_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_mulx_mont_384x_body:+.byte	1,0,18,0+.byte	0x00,0xf4,0x29,0x00+.byte	0x00,0xe4,0x2a,0x00+.byte	0x00,0xd4,0x2b,0x00+.byte	0x00,0xc4,0x2c,0x00+.byte	0x00,0x34,0x2d,0x00+.byte	0x00,0x54,0x2e,0x00+.byte	0x00,0x74,0x30,0x00+.byte	0x00,0x64,0x31,0x00+.byte	0x00,0x01,0x2f,0x00+.LSEH_info_mulx_mont_384x_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sqrx_mont_384x_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sqrx_mont_384x_body:+.byte	1,0,18,0+.byte	0x00,0xf4,0x11,0x00+.byte	0x00,0xe4,0x12,0x00+.byte	0x00,0xd4,0x13,0x00+.byte	0x00,0xc4,0x14,0x00+.byte	0x00,0x34,0x15,0x00+.byte	0x00,0x54,0x16,0x00+.byte	0x00,0x74,0x18,0x00+.byte	0x00,0x64,0x19,0x00+.byte	0x00,0x01,0x17,0x00+.LSEH_info_sqrx_mont_384x_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_mulx_382x_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_mulx_382x_body:+.byte	1,0,18,0+.byte	0x00,0xf4,0x11,0x00+.byte	0x00,0xe4,0x12,0x00+.byte	0x00,0xd4,0x13,0x00+.byte	0x00,0xc4,0x14,0x00+.byte	0x00,0x34,0x15,0x00+.byte	0x00,0x54,0x16,0x00+.byte	0x00,0x74,0x18,0x00+.byte	0x00,0x64,0x19,0x00+.byte	0x00,0x01,0x17,0x00+.LSEH_info_mulx_382x_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sqrx_382x_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sqrx_382x_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_sqrx_382x_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_mulx_384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_mulx_384_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x00,0x00+.byte	0x00,0xe4,0x01,0x00+.byte	0x00,0xd4,0x02,0x00+.byte	0x00,0xc4,0x03,0x00+.byte	0x00,0x34,0x04,0x00+.byte	0x00,0x54,0x05,0x00+.byte	0x00,0x74,0x07,0x00+.byte	0x00,0x64,0x08,0x00+.byte	0x00,0x52+.byte	0x00,0x00+.LSEH_info_mulx_384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sqrx_384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sqrx_384_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_sqrx_384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_redcx_mont_384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_redcx_mont_384_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_redcx_mont_384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_fromx_mont_384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_fromx_mont_384_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_fromx_mont_384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sgn0x_pty_mont_384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sgn0x_pty_mont_384_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_sgn0x_pty_mont_384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sgn0x_pty_mont_384x_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sgn0x_pty_mont_384x_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x01,0x00+.byte	0x00,0xe4,0x02,0x00+.byte	0x00,0xd4,0x03,0x00+.byte	0x00,0xc4,0x04,0x00+.byte	0x00,0x34,0x05,0x00+.byte	0x00,0x54,0x06,0x00+.byte	0x00,0x74,0x08,0x00+.byte	0x00,0x64,0x09,0x00+.byte	0x00,0x62+.byte	0x00,0x00+.LSEH_info_sgn0x_pty_mont_384x_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_mulx_mont_384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_mulx_mont_384_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x03,0x00+.byte	0x00,0xe4,0x04,0x00+.byte	0x00,0xd4,0x05,0x00+.byte	0x00,0xc4,0x06,0x00+.byte	0x00,0x34,0x07,0x00+.byte	0x00,0x54,0x08,0x00+.byte	0x00,0x74,0x0a,0x00+.byte	0x00,0x64,0x0b,0x00+.byte	0x00,0x82+.byte	0x00,0x00+.LSEH_info_mulx_mont_384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sqrx_mont_384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sqrx_mont_384_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x03,0x00+.byte	0x00,0xe4,0x04,0x00+.byte	0x00,0xd4,0x05,0x00+.byte	0x00,0xc4,0x06,0x00+.byte	0x00,0x34,0x07,0x00+.byte	0x00,0x54,0x08,0x00+.byte	0x00,0x74,0x0a,0x00+.byte	0x00,0x64,0x0b,0x00+.byte	0x00,0x82+.byte	0x00,0x00+.LSEH_info_sqrx_mont_384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sqrx_n_mul_mont_384_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sqrx_n_mul_mont_384_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x05,0x00+.byte	0x00,0xe4,0x06,0x00+.byte	0x00,0xd4,0x07,0x00+.byte	0x00,0xc4,0x08,0x00+.byte	0x00,0x34,0x09,0x00+.byte	0x00,0x54,0x0a,0x00+.byte	0x00,0x74,0x0c,0x00+.byte	0x00,0x64,0x0d,0x00+.byte	0x00,0xa2+.byte	0x00,0x00+.LSEH_info_sqrx_n_mul_mont_384_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sqrx_n_mul_mont_383_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sqrx_n_mul_mont_383_body:+.byte	1,0,17,0+.byte	0x00,0xf4,0x05,0x00+.byte	0x00,0xe4,0x06,0x00+.byte	0x00,0xd4,0x07,0x00+.byte	0x00,0xc4,0x08,0x00+.byte	0x00,0x34,0x09,0x00+.byte	0x00,0x54,0x0a,0x00+.byte	0x00,0x74,0x0c,0x00+.byte	0x00,0x64,0x0d,0x00+.byte	0x00,0xa2+.byte	0x00,0x00+.LSEH_info_sqrx_n_mul_mont_383_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00++.LSEH_info_sqrx_mont_382x_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_sqrx_mont_382x_body:+.byte	1,0,18,0+.byte	0x00,0xf4,0x11,0x00+.byte	0x00,0xe4,0x12,0x00+.byte	0x00,0xd4,0x13,0x00+.byte	0x00,0xc4,0x14,0x00+.byte	0x00,0x34,0x15,0x00+.byte	0x00,0x54,0x16,0x00+.byte	0x00,0x74,0x18,0x00+.byte	0x00,0x64,0x19,0x00+.byte	0x00,0x01,0x17,0x00+.LSEH_info_sqrx_mont_382x_epilogue:+.byte	1,0,4,0+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x00,0x00,0x00+
+ c-source/build/coff/sha256-armv8.S view
@@ -0,0 +1,1087 @@+//+// Copyright Supranational LLC+// Licensed under the Apache License, Version 2.0, see LICENSE for details.+// SPDX-License-Identifier: Apache-2.0+//+// ====================================================================+// Written by Andy Polyakov, @dot-asm, initially for the OpenSSL+// project.+// ====================================================================+//+// sha256_block procedure for ARMv8.+//+// This module is stripped of scalar code paths, with raionale that all+// known processors are NEON-capable.+//+// See original module at CRYPTOGAMS for further details.++.text++.p2align	6++.LK256:+.long	0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5+.long	0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5+.long	0xd807aa98,0x12835b01,0x243185be,0x550c7dc3+.long	0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174+.long	0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc+.long	0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da+.long	0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7+.long	0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967+.long	0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13+.long	0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85+.long	0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3+.long	0xd192e819,0xd6990624,0xf40e3585,0x106aa070+.long	0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5+.long	0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3+.long	0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208+.long	0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2+.long	0	//terminator++.byte	83,72,65,50,53,54,32,98,108,111,99,107,32,116,114,97,110,115,102,111,114,109,32,102,111,114,32,65,82,77,118,56,44,32,67,82,89,80,84,79,71,65,77,83,32,98,121,32,64,100,111,116,45,97,115,109,0+.align	2+.p2align	2+.globl	blst_sha256_block_armv8+.def	blst_sha256_block_armv8;+.type	32;+.endef+.p2align	6+blst_sha256_block_armv8:+.Lv8_entry:+	stp	x29,x30,[sp,#-16]!+	add	x29,sp,#0++	ld1	{v0.4s,v1.4s},[x0]+	adr	x3,.LK256++.Loop_hw:+	ld1	{v4.16b,v5.16b,v6.16b,v7.16b},[x1],#64+	sub	x2,x2,#1+	ld1	{v16.4s},[x3],#16+	rev32	v4.16b,v4.16b+	rev32	v5.16b,v5.16b+	rev32	v6.16b,v6.16b+	rev32	v7.16b,v7.16b+	orr	v18.16b,v0.16b,v0.16b		// offload+	orr	v19.16b,v1.16b,v1.16b+	ld1	{v17.4s},[x3],#16+	add	v16.4s,v16.4s,v4.4s+.long	0x5e2828a4	//sha256su0 v4.16b,v5.16b+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e104020	//sha256h v0.16b,v1.16b,v16.4s+.long	0x5e105041	//sha256h2 v1.16b,v2.16b,v16.4s+.long	0x5e0760c4	//sha256su1 v4.16b,v6.16b,v7.16b+	ld1	{v16.4s},[x3],#16+	add	v17.4s,v17.4s,v5.4s+.long	0x5e2828c5	//sha256su0 v5.16b,v6.16b+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e114020	//sha256h v0.16b,v1.16b,v17.4s+.long	0x5e115041	//sha256h2 v1.16b,v2.16b,v17.4s+.long	0x5e0460e5	//sha256su1 v5.16b,v7.16b,v4.16b+	ld1	{v17.4s},[x3],#16+	add	v16.4s,v16.4s,v6.4s+.long	0x5e2828e6	//sha256su0 v6.16b,v7.16b+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e104020	//sha256h v0.16b,v1.16b,v16.4s+.long	0x5e105041	//sha256h2 v1.16b,v2.16b,v16.4s+.long	0x5e056086	//sha256su1 v6.16b,v4.16b,v5.16b+	ld1	{v16.4s},[x3],#16+	add	v17.4s,v17.4s,v7.4s+.long	0x5e282887	//sha256su0 v7.16b,v4.16b+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e114020	//sha256h v0.16b,v1.16b,v17.4s+.long	0x5e115041	//sha256h2 v1.16b,v2.16b,v17.4s+.long	0x5e0660a7	//sha256su1 v7.16b,v5.16b,v6.16b+	ld1	{v17.4s},[x3],#16+	add	v16.4s,v16.4s,v4.4s+.long	0x5e2828a4	//sha256su0 v4.16b,v5.16b+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e104020	//sha256h v0.16b,v1.16b,v16.4s+.long	0x5e105041	//sha256h2 v1.16b,v2.16b,v16.4s+.long	0x5e0760c4	//sha256su1 v4.16b,v6.16b,v7.16b+	ld1	{v16.4s},[x3],#16+	add	v17.4s,v17.4s,v5.4s+.long	0x5e2828c5	//sha256su0 v5.16b,v6.16b+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e114020	//sha256h v0.16b,v1.16b,v17.4s+.long	0x5e115041	//sha256h2 v1.16b,v2.16b,v17.4s+.long	0x5e0460e5	//sha256su1 v5.16b,v7.16b,v4.16b+	ld1	{v17.4s},[x3],#16+	add	v16.4s,v16.4s,v6.4s+.long	0x5e2828e6	//sha256su0 v6.16b,v7.16b+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e104020	//sha256h v0.16b,v1.16b,v16.4s+.long	0x5e105041	//sha256h2 v1.16b,v2.16b,v16.4s+.long	0x5e056086	//sha256su1 v6.16b,v4.16b,v5.16b+	ld1	{v16.4s},[x3],#16+	add	v17.4s,v17.4s,v7.4s+.long	0x5e282887	//sha256su0 v7.16b,v4.16b+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e114020	//sha256h v0.16b,v1.16b,v17.4s+.long	0x5e115041	//sha256h2 v1.16b,v2.16b,v17.4s+.long	0x5e0660a7	//sha256su1 v7.16b,v5.16b,v6.16b+	ld1	{v17.4s},[x3],#16+	add	v16.4s,v16.4s,v4.4s+.long	0x5e2828a4	//sha256su0 v4.16b,v5.16b+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e104020	//sha256h v0.16b,v1.16b,v16.4s+.long	0x5e105041	//sha256h2 v1.16b,v2.16b,v16.4s+.long	0x5e0760c4	//sha256su1 v4.16b,v6.16b,v7.16b+	ld1	{v16.4s},[x3],#16+	add	v17.4s,v17.4s,v5.4s+.long	0x5e2828c5	//sha256su0 v5.16b,v6.16b+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e114020	//sha256h v0.16b,v1.16b,v17.4s+.long	0x5e115041	//sha256h2 v1.16b,v2.16b,v17.4s+.long	0x5e0460e5	//sha256su1 v5.16b,v7.16b,v4.16b+	ld1	{v17.4s},[x3],#16+	add	v16.4s,v16.4s,v6.4s+.long	0x5e2828e6	//sha256su0 v6.16b,v7.16b+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e104020	//sha256h v0.16b,v1.16b,v16.4s+.long	0x5e105041	//sha256h2 v1.16b,v2.16b,v16.4s+.long	0x5e056086	//sha256su1 v6.16b,v4.16b,v5.16b+	ld1	{v16.4s},[x3],#16+	add	v17.4s,v17.4s,v7.4s+.long	0x5e282887	//sha256su0 v7.16b,v4.16b+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e114020	//sha256h v0.16b,v1.16b,v17.4s+.long	0x5e115041	//sha256h2 v1.16b,v2.16b,v17.4s+.long	0x5e0660a7	//sha256su1 v7.16b,v5.16b,v6.16b+	ld1	{v17.4s},[x3],#16+	add	v16.4s,v16.4s,v4.4s+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e104020	//sha256h v0.16b,v1.16b,v16.4s+.long	0x5e105041	//sha256h2 v1.16b,v2.16b,v16.4s++	ld1	{v16.4s},[x3],#16+	add	v17.4s,v17.4s,v5.4s+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e114020	//sha256h v0.16b,v1.16b,v17.4s+.long	0x5e115041	//sha256h2 v1.16b,v2.16b,v17.4s++	ld1	{v17.4s},[x3]+	add	v16.4s,v16.4s,v6.4s+	sub	x3,x3,#64*4-16	// rewind+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e104020	//sha256h v0.16b,v1.16b,v16.4s+.long	0x5e105041	//sha256h2 v1.16b,v2.16b,v16.4s++	add	v17.4s,v17.4s,v7.4s+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e114020	//sha256h v0.16b,v1.16b,v17.4s+.long	0x5e115041	//sha256h2 v1.16b,v2.16b,v17.4s++	add	v0.4s,v0.4s,v18.4s+	add	v1.4s,v1.4s,v19.4s++	cbnz	x2,.Loop_hw++	st1	{v0.4s,v1.4s},[x0]++	ldr	x29,[sp],#16+	ret++.globl	blst_sha256_block_data_order+.def	blst_sha256_block_data_order;+.type	32;+.endef+.p2align	4+blst_sha256_block_data_order:+	stp	x29, x30, [sp, #-16]!+	mov	x29, sp+	sub	sp,sp,#16*4++	adr	x16,.LK256+	add	x2,x1,x2,lsl#6	// len to point at the end of inp++	ld1	{v0.16b},[x1], #16+	ld1	{v1.16b},[x1], #16+	ld1	{v2.16b},[x1], #16+	ld1	{v3.16b},[x1], #16+	ld1	{v4.4s},[x16], #16+	ld1	{v5.4s},[x16], #16+	ld1	{v6.4s},[x16], #16+	ld1	{v7.4s},[x16], #16+	rev32	v0.16b,v0.16b		// yes, even on+	rev32	v1.16b,v1.16b		// big-endian+	rev32	v2.16b,v2.16b+	rev32	v3.16b,v3.16b+	mov	x17,sp+	add	v4.4s,v4.4s,v0.4s+	add	v5.4s,v5.4s,v1.4s+	add	v6.4s,v6.4s,v2.4s+	st1	{v4.4s,v5.4s},[x17], #32+	add	v7.4s,v7.4s,v3.4s+	st1	{v6.4s,v7.4s},[x17]+	sub	x17,x17,#32++	ldp	w3,w4,[x0]+	ldp	w5,w6,[x0,#8]+	ldp	w7,w8,[x0,#16]+	ldp	w9,w10,[x0,#24]+	ldr	w12,[sp,#0]+	mov	w13,wzr+	eor	w14,w4,w5+	mov	w15,wzr+	b	.L_00_48++.p2align	4+.L_00_48:+	ext	v4.16b,v0.16b,v1.16b,#4+	add	w10,w10,w12+	add	w3,w3,w15+	and	w12,w8,w7+	bic	w15,w9,w7+	ext	v7.16b,v2.16b,v3.16b,#4+	eor	w11,w7,w7,ror#5+	add	w3,w3,w13+	mov	d19,v3.d[1]+	orr	w12,w12,w15+	eor	w11,w11,w7,ror#19+	ushr	v6.4s,v4.4s,#7+	eor	w15,w3,w3,ror#11+	ushr	v5.4s,v4.4s,#3+	add	w10,w10,w12+	add	v0.4s,v0.4s,v7.4s+	ror	w11,w11,#6+	sli	v6.4s,v4.4s,#25+	eor	w13,w3,w4+	eor	w15,w15,w3,ror#20+	ushr	v7.4s,v4.4s,#18+	add	w10,w10,w11+	ldr	w12,[sp,#4]+	and	w14,w14,w13+	eor	v5.16b,v5.16b,v6.16b+	ror	w15,w15,#2+	add	w6,w6,w10+	sli	v7.4s,v4.4s,#14+	eor	w14,w14,w4+	ushr	v16.4s,v19.4s,#17+	add	w9,w9,w12+	add	w10,w10,w15+	and	w12,w7,w6+	eor	v5.16b,v5.16b,v7.16b+	bic	w15,w8,w6+	eor	w11,w6,w6,ror#5+	sli	v16.4s,v19.4s,#15+	add	w10,w10,w14+	orr	w12,w12,w15+	ushr	v17.4s,v19.4s,#10+	eor	w11,w11,w6,ror#19+	eor	w15,w10,w10,ror#11+	ushr	v7.4s,v19.4s,#19+	add	w9,w9,w12+	ror	w11,w11,#6+	add	v0.4s,v0.4s,v5.4s+	eor	w14,w10,w3+	eor	w15,w15,w10,ror#20+	sli	v7.4s,v19.4s,#13+	add	w9,w9,w11+	ldr	w12,[sp,#8]+	and	w13,w13,w14+	eor	v17.16b,v17.16b,v16.16b+	ror	w15,w15,#2+	add	w5,w5,w9+	eor	w13,w13,w3+	eor	v17.16b,v17.16b,v7.16b+	add	w8,w8,w12+	add	w9,w9,w15+	and	w12,w6,w5+	add	v0.4s,v0.4s,v17.4s+	bic	w15,w7,w5+	eor	w11,w5,w5,ror#5+	add	w9,w9,w13+	ushr	v18.4s,v0.4s,#17+	orr	w12,w12,w15+	ushr	v19.4s,v0.4s,#10+	eor	w11,w11,w5,ror#19+	eor	w15,w9,w9,ror#11+	sli	v18.4s,v0.4s,#15+	add	w8,w8,w12+	ushr	v17.4s,v0.4s,#19+	ror	w11,w11,#6+	eor	w13,w9,w10+	eor	v19.16b,v19.16b,v18.16b+	eor	w15,w15,w9,ror#20+	add	w8,w8,w11+	sli	v17.4s,v0.4s,#13+	ldr	w12,[sp,#12]+	and	w14,w14,w13+	ror	w15,w15,#2+	ld1	{v4.4s},[x16], #16+	add	w4,w4,w8+	eor	v19.16b,v19.16b,v17.16b+	eor	w14,w14,w10+	eor	v17.16b,v17.16b,v17.16b+	add	w7,w7,w12+	add	w8,w8,w15+	and	w12,w5,w4+	mov	v17.d[1],v19.d[0]+	bic	w15,w6,w4+	eor	w11,w4,w4,ror#5+	add	w8,w8,w14+	add	v0.4s,v0.4s,v17.4s+	orr	w12,w12,w15+	eor	w11,w11,w4,ror#19+	eor	w15,w8,w8,ror#11+	add	v4.4s,v4.4s,v0.4s+	add	w7,w7,w12+	ror	w11,w11,#6+	eor	w14,w8,w9+	eor	w15,w15,w8,ror#20+	add	w7,w7,w11+	ldr	w12,[sp,#16]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w3,w3,w7+	eor	w13,w13,w9+	st1	{v4.4s},[x17], #16+	ext	v4.16b,v1.16b,v2.16b,#4+	add	w6,w6,w12+	add	w7,w7,w15+	and	w12,w4,w3+	bic	w15,w5,w3+	ext	v7.16b,v3.16b,v0.16b,#4+	eor	w11,w3,w3,ror#5+	add	w7,w7,w13+	mov	d19,v0.d[1]+	orr	w12,w12,w15+	eor	w11,w11,w3,ror#19+	ushr	v6.4s,v4.4s,#7+	eor	w15,w7,w7,ror#11+	ushr	v5.4s,v4.4s,#3+	add	w6,w6,w12+	add	v1.4s,v1.4s,v7.4s+	ror	w11,w11,#6+	sli	v6.4s,v4.4s,#25+	eor	w13,w7,w8+	eor	w15,w15,w7,ror#20+	ushr	v7.4s,v4.4s,#18+	add	w6,w6,w11+	ldr	w12,[sp,#20]+	and	w14,w14,w13+	eor	v5.16b,v5.16b,v6.16b+	ror	w15,w15,#2+	add	w10,w10,w6+	sli	v7.4s,v4.4s,#14+	eor	w14,w14,w8+	ushr	v16.4s,v19.4s,#17+	add	w5,w5,w12+	add	w6,w6,w15+	and	w12,w3,w10+	eor	v5.16b,v5.16b,v7.16b+	bic	w15,w4,w10+	eor	w11,w10,w10,ror#5+	sli	v16.4s,v19.4s,#15+	add	w6,w6,w14+	orr	w12,w12,w15+	ushr	v17.4s,v19.4s,#10+	eor	w11,w11,w10,ror#19+	eor	w15,w6,w6,ror#11+	ushr	v7.4s,v19.4s,#19+	add	w5,w5,w12+	ror	w11,w11,#6+	add	v1.4s,v1.4s,v5.4s+	eor	w14,w6,w7+	eor	w15,w15,w6,ror#20+	sli	v7.4s,v19.4s,#13+	add	w5,w5,w11+	ldr	w12,[sp,#24]+	and	w13,w13,w14+	eor	v17.16b,v17.16b,v16.16b+	ror	w15,w15,#2+	add	w9,w9,w5+	eor	w13,w13,w7+	eor	v17.16b,v17.16b,v7.16b+	add	w4,w4,w12+	add	w5,w5,w15+	and	w12,w10,w9+	add	v1.4s,v1.4s,v17.4s+	bic	w15,w3,w9+	eor	w11,w9,w9,ror#5+	add	w5,w5,w13+	ushr	v18.4s,v1.4s,#17+	orr	w12,w12,w15+	ushr	v19.4s,v1.4s,#10+	eor	w11,w11,w9,ror#19+	eor	w15,w5,w5,ror#11+	sli	v18.4s,v1.4s,#15+	add	w4,w4,w12+	ushr	v17.4s,v1.4s,#19+	ror	w11,w11,#6+	eor	w13,w5,w6+	eor	v19.16b,v19.16b,v18.16b+	eor	w15,w15,w5,ror#20+	add	w4,w4,w11+	sli	v17.4s,v1.4s,#13+	ldr	w12,[sp,#28]+	and	w14,w14,w13+	ror	w15,w15,#2+	ld1	{v4.4s},[x16], #16+	add	w8,w8,w4+	eor	v19.16b,v19.16b,v17.16b+	eor	w14,w14,w6+	eor	v17.16b,v17.16b,v17.16b+	add	w3,w3,w12+	add	w4,w4,w15+	and	w12,w9,w8+	mov	v17.d[1],v19.d[0]+	bic	w15,w10,w8+	eor	w11,w8,w8,ror#5+	add	w4,w4,w14+	add	v1.4s,v1.4s,v17.4s+	orr	w12,w12,w15+	eor	w11,w11,w8,ror#19+	eor	w15,w4,w4,ror#11+	add	v4.4s,v4.4s,v1.4s+	add	w3,w3,w12+	ror	w11,w11,#6+	eor	w14,w4,w5+	eor	w15,w15,w4,ror#20+	add	w3,w3,w11+	ldr	w12,[sp,#32]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w7,w7,w3+	eor	w13,w13,w5+	st1	{v4.4s},[x17], #16+	ext	v4.16b,v2.16b,v3.16b,#4+	add	w10,w10,w12+	add	w3,w3,w15+	and	w12,w8,w7+	bic	w15,w9,w7+	ext	v7.16b,v0.16b,v1.16b,#4+	eor	w11,w7,w7,ror#5+	add	w3,w3,w13+	mov	d19,v1.d[1]+	orr	w12,w12,w15+	eor	w11,w11,w7,ror#19+	ushr	v6.4s,v4.4s,#7+	eor	w15,w3,w3,ror#11+	ushr	v5.4s,v4.4s,#3+	add	w10,w10,w12+	add	v2.4s,v2.4s,v7.4s+	ror	w11,w11,#6+	sli	v6.4s,v4.4s,#25+	eor	w13,w3,w4+	eor	w15,w15,w3,ror#20+	ushr	v7.4s,v4.4s,#18+	add	w10,w10,w11+	ldr	w12,[sp,#36]+	and	w14,w14,w13+	eor	v5.16b,v5.16b,v6.16b+	ror	w15,w15,#2+	add	w6,w6,w10+	sli	v7.4s,v4.4s,#14+	eor	w14,w14,w4+	ushr	v16.4s,v19.4s,#17+	add	w9,w9,w12+	add	w10,w10,w15+	and	w12,w7,w6+	eor	v5.16b,v5.16b,v7.16b+	bic	w15,w8,w6+	eor	w11,w6,w6,ror#5+	sli	v16.4s,v19.4s,#15+	add	w10,w10,w14+	orr	w12,w12,w15+	ushr	v17.4s,v19.4s,#10+	eor	w11,w11,w6,ror#19+	eor	w15,w10,w10,ror#11+	ushr	v7.4s,v19.4s,#19+	add	w9,w9,w12+	ror	w11,w11,#6+	add	v2.4s,v2.4s,v5.4s+	eor	w14,w10,w3+	eor	w15,w15,w10,ror#20+	sli	v7.4s,v19.4s,#13+	add	w9,w9,w11+	ldr	w12,[sp,#40]+	and	w13,w13,w14+	eor	v17.16b,v17.16b,v16.16b+	ror	w15,w15,#2+	add	w5,w5,w9+	eor	w13,w13,w3+	eor	v17.16b,v17.16b,v7.16b+	add	w8,w8,w12+	add	w9,w9,w15+	and	w12,w6,w5+	add	v2.4s,v2.4s,v17.4s+	bic	w15,w7,w5+	eor	w11,w5,w5,ror#5+	add	w9,w9,w13+	ushr	v18.4s,v2.4s,#17+	orr	w12,w12,w15+	ushr	v19.4s,v2.4s,#10+	eor	w11,w11,w5,ror#19+	eor	w15,w9,w9,ror#11+	sli	v18.4s,v2.4s,#15+	add	w8,w8,w12+	ushr	v17.4s,v2.4s,#19+	ror	w11,w11,#6+	eor	w13,w9,w10+	eor	v19.16b,v19.16b,v18.16b+	eor	w15,w15,w9,ror#20+	add	w8,w8,w11+	sli	v17.4s,v2.4s,#13+	ldr	w12,[sp,#44]+	and	w14,w14,w13+	ror	w15,w15,#2+	ld1	{v4.4s},[x16], #16+	add	w4,w4,w8+	eor	v19.16b,v19.16b,v17.16b+	eor	w14,w14,w10+	eor	v17.16b,v17.16b,v17.16b+	add	w7,w7,w12+	add	w8,w8,w15+	and	w12,w5,w4+	mov	v17.d[1],v19.d[0]+	bic	w15,w6,w4+	eor	w11,w4,w4,ror#5+	add	w8,w8,w14+	add	v2.4s,v2.4s,v17.4s+	orr	w12,w12,w15+	eor	w11,w11,w4,ror#19+	eor	w15,w8,w8,ror#11+	add	v4.4s,v4.4s,v2.4s+	add	w7,w7,w12+	ror	w11,w11,#6+	eor	w14,w8,w9+	eor	w15,w15,w8,ror#20+	add	w7,w7,w11+	ldr	w12,[sp,#48]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w3,w3,w7+	eor	w13,w13,w9+	st1	{v4.4s},[x17], #16+	ext	v4.16b,v3.16b,v0.16b,#4+	add	w6,w6,w12+	add	w7,w7,w15+	and	w12,w4,w3+	bic	w15,w5,w3+	ext	v7.16b,v1.16b,v2.16b,#4+	eor	w11,w3,w3,ror#5+	add	w7,w7,w13+	mov	d19,v2.d[1]+	orr	w12,w12,w15+	eor	w11,w11,w3,ror#19+	ushr	v6.4s,v4.4s,#7+	eor	w15,w7,w7,ror#11+	ushr	v5.4s,v4.4s,#3+	add	w6,w6,w12+	add	v3.4s,v3.4s,v7.4s+	ror	w11,w11,#6+	sli	v6.4s,v4.4s,#25+	eor	w13,w7,w8+	eor	w15,w15,w7,ror#20+	ushr	v7.4s,v4.4s,#18+	add	w6,w6,w11+	ldr	w12,[sp,#52]+	and	w14,w14,w13+	eor	v5.16b,v5.16b,v6.16b+	ror	w15,w15,#2+	add	w10,w10,w6+	sli	v7.4s,v4.4s,#14+	eor	w14,w14,w8+	ushr	v16.4s,v19.4s,#17+	add	w5,w5,w12+	add	w6,w6,w15+	and	w12,w3,w10+	eor	v5.16b,v5.16b,v7.16b+	bic	w15,w4,w10+	eor	w11,w10,w10,ror#5+	sli	v16.4s,v19.4s,#15+	add	w6,w6,w14+	orr	w12,w12,w15+	ushr	v17.4s,v19.4s,#10+	eor	w11,w11,w10,ror#19+	eor	w15,w6,w6,ror#11+	ushr	v7.4s,v19.4s,#19+	add	w5,w5,w12+	ror	w11,w11,#6+	add	v3.4s,v3.4s,v5.4s+	eor	w14,w6,w7+	eor	w15,w15,w6,ror#20+	sli	v7.4s,v19.4s,#13+	add	w5,w5,w11+	ldr	w12,[sp,#56]+	and	w13,w13,w14+	eor	v17.16b,v17.16b,v16.16b+	ror	w15,w15,#2+	add	w9,w9,w5+	eor	w13,w13,w7+	eor	v17.16b,v17.16b,v7.16b+	add	w4,w4,w12+	add	w5,w5,w15+	and	w12,w10,w9+	add	v3.4s,v3.4s,v17.4s+	bic	w15,w3,w9+	eor	w11,w9,w9,ror#5+	add	w5,w5,w13+	ushr	v18.4s,v3.4s,#17+	orr	w12,w12,w15+	ushr	v19.4s,v3.4s,#10+	eor	w11,w11,w9,ror#19+	eor	w15,w5,w5,ror#11+	sli	v18.4s,v3.4s,#15+	add	w4,w4,w12+	ushr	v17.4s,v3.4s,#19+	ror	w11,w11,#6+	eor	w13,w5,w6+	eor	v19.16b,v19.16b,v18.16b+	eor	w15,w15,w5,ror#20+	add	w4,w4,w11+	sli	v17.4s,v3.4s,#13+	ldr	w12,[sp,#60]+	and	w14,w14,w13+	ror	w15,w15,#2+	ld1	{v4.4s},[x16], #16+	add	w8,w8,w4+	eor	v19.16b,v19.16b,v17.16b+	eor	w14,w14,w6+	eor	v17.16b,v17.16b,v17.16b+	add	w3,w3,w12+	add	w4,w4,w15+	and	w12,w9,w8+	mov	v17.d[1],v19.d[0]+	bic	w15,w10,w8+	eor	w11,w8,w8,ror#5+	add	w4,w4,w14+	add	v3.4s,v3.4s,v17.4s+	orr	w12,w12,w15+	eor	w11,w11,w8,ror#19+	eor	w15,w4,w4,ror#11+	add	v4.4s,v4.4s,v3.4s+	add	w3,w3,w12+	ror	w11,w11,#6+	eor	w14,w4,w5+	eor	w15,w15,w4,ror#20+	add	w3,w3,w11+	ldr	w12,[x16]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w7,w7,w3+	eor	w13,w13,w5+	st1	{v4.4s},[x17], #16+	cmp	w12,#0				// check for K256 terminator+	ldr	w12,[sp,#0]+	sub	x17,x17,#64+	bne	.L_00_48++	sub	x16,x16,#256		// rewind x16+	cmp	x1,x2+	mov	x17, #64+	csel	x17, x17, xzr, eq+	sub	x1,x1,x17			// avoid SEGV+	mov	x17,sp+	add	w10,w10,w12+	add	w3,w3,w15+	and	w12,w8,w7+	ld1	{v0.16b},[x1],#16+	bic	w15,w9,w7+	eor	w11,w7,w7,ror#5+	ld1	{v4.4s},[x16],#16+	add	w3,w3,w13+	orr	w12,w12,w15+	eor	w11,w11,w7,ror#19+	eor	w15,w3,w3,ror#11+	rev32	v0.16b,v0.16b+	add	w10,w10,w12+	ror	w11,w11,#6+	eor	w13,w3,w4+	eor	w15,w15,w3,ror#20+	add	v4.4s,v4.4s,v0.4s+	add	w10,w10,w11+	ldr	w12,[sp,#4]+	and	w14,w14,w13+	ror	w15,w15,#2+	add	w6,w6,w10+	eor	w14,w14,w4+	add	w9,w9,w12+	add	w10,w10,w15+	and	w12,w7,w6+	bic	w15,w8,w6+	eor	w11,w6,w6,ror#5+	add	w10,w10,w14+	orr	w12,w12,w15+	eor	w11,w11,w6,ror#19+	eor	w15,w10,w10,ror#11+	add	w9,w9,w12+	ror	w11,w11,#6+	eor	w14,w10,w3+	eor	w15,w15,w10,ror#20+	add	w9,w9,w11+	ldr	w12,[sp,#8]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w5,w5,w9+	eor	w13,w13,w3+	add	w8,w8,w12+	add	w9,w9,w15+	and	w12,w6,w5+	bic	w15,w7,w5+	eor	w11,w5,w5,ror#5+	add	w9,w9,w13+	orr	w12,w12,w15+	eor	w11,w11,w5,ror#19+	eor	w15,w9,w9,ror#11+	add	w8,w8,w12+	ror	w11,w11,#6+	eor	w13,w9,w10+	eor	w15,w15,w9,ror#20+	add	w8,w8,w11+	ldr	w12,[sp,#12]+	and	w14,w14,w13+	ror	w15,w15,#2+	add	w4,w4,w8+	eor	w14,w14,w10+	add	w7,w7,w12+	add	w8,w8,w15+	and	w12,w5,w4+	bic	w15,w6,w4+	eor	w11,w4,w4,ror#5+	add	w8,w8,w14+	orr	w12,w12,w15+	eor	w11,w11,w4,ror#19+	eor	w15,w8,w8,ror#11+	add	w7,w7,w12+	ror	w11,w11,#6+	eor	w14,w8,w9+	eor	w15,w15,w8,ror#20+	add	w7,w7,w11+	ldr	w12,[sp,#16]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w3,w3,w7+	eor	w13,w13,w9+	st1	{v4.4s},[x17], #16+	add	w6,w6,w12+	add	w7,w7,w15+	and	w12,w4,w3+	ld1	{v1.16b},[x1],#16+	bic	w15,w5,w3+	eor	w11,w3,w3,ror#5+	ld1	{v4.4s},[x16],#16+	add	w7,w7,w13+	orr	w12,w12,w15+	eor	w11,w11,w3,ror#19+	eor	w15,w7,w7,ror#11+	rev32	v1.16b,v1.16b+	add	w6,w6,w12+	ror	w11,w11,#6+	eor	w13,w7,w8+	eor	w15,w15,w7,ror#20+	add	v4.4s,v4.4s,v1.4s+	add	w6,w6,w11+	ldr	w12,[sp,#20]+	and	w14,w14,w13+	ror	w15,w15,#2+	add	w10,w10,w6+	eor	w14,w14,w8+	add	w5,w5,w12+	add	w6,w6,w15+	and	w12,w3,w10+	bic	w15,w4,w10+	eor	w11,w10,w10,ror#5+	add	w6,w6,w14+	orr	w12,w12,w15+	eor	w11,w11,w10,ror#19+	eor	w15,w6,w6,ror#11+	add	w5,w5,w12+	ror	w11,w11,#6+	eor	w14,w6,w7+	eor	w15,w15,w6,ror#20+	add	w5,w5,w11+	ldr	w12,[sp,#24]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w9,w9,w5+	eor	w13,w13,w7+	add	w4,w4,w12+	add	w5,w5,w15+	and	w12,w10,w9+	bic	w15,w3,w9+	eor	w11,w9,w9,ror#5+	add	w5,w5,w13+	orr	w12,w12,w15+	eor	w11,w11,w9,ror#19+	eor	w15,w5,w5,ror#11+	add	w4,w4,w12+	ror	w11,w11,#6+	eor	w13,w5,w6+	eor	w15,w15,w5,ror#20+	add	w4,w4,w11+	ldr	w12,[sp,#28]+	and	w14,w14,w13+	ror	w15,w15,#2+	add	w8,w8,w4+	eor	w14,w14,w6+	add	w3,w3,w12+	add	w4,w4,w15+	and	w12,w9,w8+	bic	w15,w10,w8+	eor	w11,w8,w8,ror#5+	add	w4,w4,w14+	orr	w12,w12,w15+	eor	w11,w11,w8,ror#19+	eor	w15,w4,w4,ror#11+	add	w3,w3,w12+	ror	w11,w11,#6+	eor	w14,w4,w5+	eor	w15,w15,w4,ror#20+	add	w3,w3,w11+	ldr	w12,[sp,#32]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w7,w7,w3+	eor	w13,w13,w5+	st1	{v4.4s},[x17], #16+	add	w10,w10,w12+	add	w3,w3,w15+	and	w12,w8,w7+	ld1	{v2.16b},[x1],#16+	bic	w15,w9,w7+	eor	w11,w7,w7,ror#5+	ld1	{v4.4s},[x16],#16+	add	w3,w3,w13+	orr	w12,w12,w15+	eor	w11,w11,w7,ror#19+	eor	w15,w3,w3,ror#11+	rev32	v2.16b,v2.16b+	add	w10,w10,w12+	ror	w11,w11,#6+	eor	w13,w3,w4+	eor	w15,w15,w3,ror#20+	add	v4.4s,v4.4s,v2.4s+	add	w10,w10,w11+	ldr	w12,[sp,#36]+	and	w14,w14,w13+	ror	w15,w15,#2+	add	w6,w6,w10+	eor	w14,w14,w4+	add	w9,w9,w12+	add	w10,w10,w15+	and	w12,w7,w6+	bic	w15,w8,w6+	eor	w11,w6,w6,ror#5+	add	w10,w10,w14+	orr	w12,w12,w15+	eor	w11,w11,w6,ror#19+	eor	w15,w10,w10,ror#11+	add	w9,w9,w12+	ror	w11,w11,#6+	eor	w14,w10,w3+	eor	w15,w15,w10,ror#20+	add	w9,w9,w11+	ldr	w12,[sp,#40]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w5,w5,w9+	eor	w13,w13,w3+	add	w8,w8,w12+	add	w9,w9,w15+	and	w12,w6,w5+	bic	w15,w7,w5+	eor	w11,w5,w5,ror#5+	add	w9,w9,w13+	orr	w12,w12,w15+	eor	w11,w11,w5,ror#19+	eor	w15,w9,w9,ror#11+	add	w8,w8,w12+	ror	w11,w11,#6+	eor	w13,w9,w10+	eor	w15,w15,w9,ror#20+	add	w8,w8,w11+	ldr	w12,[sp,#44]+	and	w14,w14,w13+	ror	w15,w15,#2+	add	w4,w4,w8+	eor	w14,w14,w10+	add	w7,w7,w12+	add	w8,w8,w15+	and	w12,w5,w4+	bic	w15,w6,w4+	eor	w11,w4,w4,ror#5+	add	w8,w8,w14+	orr	w12,w12,w15+	eor	w11,w11,w4,ror#19+	eor	w15,w8,w8,ror#11+	add	w7,w7,w12+	ror	w11,w11,#6+	eor	w14,w8,w9+	eor	w15,w15,w8,ror#20+	add	w7,w7,w11+	ldr	w12,[sp,#48]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w3,w3,w7+	eor	w13,w13,w9+	st1	{v4.4s},[x17], #16+	add	w6,w6,w12+	add	w7,w7,w15+	and	w12,w4,w3+	ld1	{v3.16b},[x1],#16+	bic	w15,w5,w3+	eor	w11,w3,w3,ror#5+	ld1	{v4.4s},[x16],#16+	add	w7,w7,w13+	orr	w12,w12,w15+	eor	w11,w11,w3,ror#19+	eor	w15,w7,w7,ror#11+	rev32	v3.16b,v3.16b+	add	w6,w6,w12+	ror	w11,w11,#6+	eor	w13,w7,w8+	eor	w15,w15,w7,ror#20+	add	v4.4s,v4.4s,v3.4s+	add	w6,w6,w11+	ldr	w12,[sp,#52]+	and	w14,w14,w13+	ror	w15,w15,#2+	add	w10,w10,w6+	eor	w14,w14,w8+	add	w5,w5,w12+	add	w6,w6,w15+	and	w12,w3,w10+	bic	w15,w4,w10+	eor	w11,w10,w10,ror#5+	add	w6,w6,w14+	orr	w12,w12,w15+	eor	w11,w11,w10,ror#19+	eor	w15,w6,w6,ror#11+	add	w5,w5,w12+	ror	w11,w11,#6+	eor	w14,w6,w7+	eor	w15,w15,w6,ror#20+	add	w5,w5,w11+	ldr	w12,[sp,#56]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w9,w9,w5+	eor	w13,w13,w7+	add	w4,w4,w12+	add	w5,w5,w15+	and	w12,w10,w9+	bic	w15,w3,w9+	eor	w11,w9,w9,ror#5+	add	w5,w5,w13+	orr	w12,w12,w15+	eor	w11,w11,w9,ror#19+	eor	w15,w5,w5,ror#11+	add	w4,w4,w12+	ror	w11,w11,#6+	eor	w13,w5,w6+	eor	w15,w15,w5,ror#20+	add	w4,w4,w11+	ldr	w12,[sp,#60]+	and	w14,w14,w13+	ror	w15,w15,#2+	add	w8,w8,w4+	eor	w14,w14,w6+	add	w3,w3,w12+	add	w4,w4,w15+	and	w12,w9,w8+	bic	w15,w10,w8+	eor	w11,w8,w8,ror#5+	add	w4,w4,w14+	orr	w12,w12,w15+	eor	w11,w11,w8,ror#19+	eor	w15,w4,w4,ror#11+	add	w3,w3,w12+	ror	w11,w11,#6+	eor	w14,w4,w5+	eor	w15,w15,w4,ror#20+	add	w3,w3,w11+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w7,w7,w3+	eor	w13,w13,w5+	st1	{v4.4s},[x17], #16+	add	w3,w3,w15			// h+=Sigma0(a) from the past+	ldp	w11,w12,[x0,#0]+	add	w3,w3,w13			// h+=Maj(a,b,c) from the past+	ldp	w13,w14,[x0,#8]+	add	w3,w3,w11			// accumulate+	add	w4,w4,w12+	ldp	w11,w12,[x0,#16]+	add	w5,w5,w13+	add	w6,w6,w14+	ldp	w13,w14,[x0,#24]+	add	w7,w7,w11+	add	w8,w8,w12+	ldr	w12,[sp,#0]+	stp	w3,w4,[x0,#0]+	add	w9,w9,w13+	mov	w13,wzr+	stp	w5,w6,[x0,#8]+	add	w10,w10,w14+	stp	w7,w8,[x0,#16]+	eor	w14,w4,w5+	stp	w9,w10,[x0,#24]+	mov	w15,wzr+	mov	x17,sp+	b.ne	.L_00_48++	ldr	x29,[x29]+	add	sp,sp,#16*4+16+	ret++.globl	blst_sha256_emit++.def	blst_sha256_emit;+.type	32;+.endef+.p2align	4+blst_sha256_emit:+	ldp	x4,x5,[x1]+	ldp	x6,x7,[x1,#16]+#ifndef	__AARCH64EB__+	rev	x4,x4+	rev	x5,x5+	rev	x6,x6+	rev	x7,x7+#endif+	str	w4,[x0,#4]+	lsr	x4,x4,#32+	str	w5,[x0,#12]+	lsr	x5,x5,#32+	str	w6,[x0,#20]+	lsr	x6,x6,#32+	str	w7,[x0,#28]+	lsr	x7,x7,#32+	str	w4,[x0,#0]+	str	w5,[x0,#8]+	str	w6,[x0,#16]+	str	w7,[x0,#24]+	ret+++.globl	blst_sha256_bcopy++.def	blst_sha256_bcopy;+.type	32;+.endef+.p2align	4+blst_sha256_bcopy:+.Loop_bcopy:+	ldrb	w3,[x1],#1+	sub	x2,x2,#1+	strb	w3,[x0],#1+	cbnz	x2,.Loop_bcopy+	ret+++.globl	blst_sha256_hcopy++.def	blst_sha256_hcopy;+.type	32;+.endef+.p2align	4+blst_sha256_hcopy:+	ldp	x4,x5,[x1]+	ldp	x6,x7,[x1,#16]+	stp	x4,x5,[x0]+	stp	x6,x7,[x0,#16]+	ret+
+ c-source/build/coff/sha256-portable-x86_64.s view
@@ -0,0 +1,1784 @@+.text	++.globl	blst_sha256_block_data_order+.def	blst_sha256_block_data_order;	.scl 2;	.type 32;	.endef+.p2align	4+blst_sha256_block_data_order:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_blst_sha256_block_data_order:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+++	pushq	%rbx++	pushq	%rbp++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	shlq	$4,%rdx+	subq	$64+24,%rsp++	leaq	(%rsi,%rdx,4),%rdx+	movq	%rdi,64+0(%rsp)+	movq	%rsi,64+8(%rsp)+	movq	%rdx,64+16(%rsp)+.LSEH_body_blst_sha256_block_data_order:+++	movl	0(%rdi),%eax+	movl	4(%rdi),%ebx+	movl	8(%rdi),%ecx+	movl	12(%rdi),%edx+	movl	16(%rdi),%r8d+	movl	20(%rdi),%r9d+	movl	24(%rdi),%r10d+	movl	28(%rdi),%r11d+	jmp	.Lloop++.p2align	4+.Lloop:+	movl	%ebx,%edi+	leaq	K256(%rip),%rbp+	xorl	%ecx,%edi+	movl	0(%rsi),%r12d+	movl	%r8d,%r13d+	movl	%eax,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%r9d,%r15d++	xorl	%r8d,%r13d+	rorl	$9,%r14d+	xorl	%r10d,%r15d++	movl	%r12d,0(%rsp)+	xorl	%eax,%r14d+	andl	%r8d,%r15d++	rorl	$5,%r13d+	addl	%r11d,%r12d+	xorl	%r10d,%r15d++	rorl	$11,%r14d+	xorl	%r8d,%r13d+	addl	%r15d,%r12d++	movl	%eax,%r15d+	addl	0(%rbp),%r12d+	xorl	%eax,%r14d++	xorl	%ebx,%r15d+	rorl	$6,%r13d+	movl	%ebx,%r11d++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%r11d+	addl	%r12d,%edx+	addl	%r12d,%r11d+	addl	%r14d,%r11d+	movl	4(%rsi),%r12d+	movl	%edx,%r13d+	movl	%r11d,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%r8d,%edi++	xorl	%edx,%r13d+	rorl	$9,%r14d+	xorl	%r9d,%edi++	movl	%r12d,4(%rsp)+	xorl	%r11d,%r14d+	andl	%edx,%edi++	rorl	$5,%r13d+	addl	%r10d,%r12d+	xorl	%r9d,%edi++	rorl	$11,%r14d+	xorl	%edx,%r13d+	addl	%edi,%r12d++	movl	%r11d,%edi+	addl	4(%rbp),%r12d+	xorl	%r11d,%r14d++	xorl	%eax,%edi+	rorl	$6,%r13d+	movl	%eax,%r10d++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%r10d+	addl	%r12d,%ecx+	addl	%r12d,%r10d+	addl	%r14d,%r10d+	movl	8(%rsi),%r12d+	movl	%ecx,%r13d+	movl	%r10d,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%edx,%r15d++	xorl	%ecx,%r13d+	rorl	$9,%r14d+	xorl	%r8d,%r15d++	movl	%r12d,8(%rsp)+	xorl	%r10d,%r14d+	andl	%ecx,%r15d++	rorl	$5,%r13d+	addl	%r9d,%r12d+	xorl	%r8d,%r15d++	rorl	$11,%r14d+	xorl	%ecx,%r13d+	addl	%r15d,%r12d++	movl	%r10d,%r15d+	addl	8(%rbp),%r12d+	xorl	%r10d,%r14d++	xorl	%r11d,%r15d+	rorl	$6,%r13d+	movl	%r11d,%r9d++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%r9d+	addl	%r12d,%ebx+	addl	%r12d,%r9d+	addl	%r14d,%r9d+	movl	12(%rsi),%r12d+	movl	%ebx,%r13d+	movl	%r9d,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%ecx,%edi++	xorl	%ebx,%r13d+	rorl	$9,%r14d+	xorl	%edx,%edi++	movl	%r12d,12(%rsp)+	xorl	%r9d,%r14d+	andl	%ebx,%edi++	rorl	$5,%r13d+	addl	%r8d,%r12d+	xorl	%edx,%edi++	rorl	$11,%r14d+	xorl	%ebx,%r13d+	addl	%edi,%r12d++	movl	%r9d,%edi+	addl	12(%rbp),%r12d+	xorl	%r9d,%r14d++	xorl	%r10d,%edi+	rorl	$6,%r13d+	movl	%r10d,%r8d++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%r8d+	addl	%r12d,%eax+	addl	%r12d,%r8d+	addl	%r14d,%r8d+	movl	16(%rsi),%r12d+	movl	%eax,%r13d+	movl	%r8d,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%ebx,%r15d++	xorl	%eax,%r13d+	rorl	$9,%r14d+	xorl	%ecx,%r15d++	movl	%r12d,16(%rsp)+	xorl	%r8d,%r14d+	andl	%eax,%r15d++	rorl	$5,%r13d+	addl	%edx,%r12d+	xorl	%ecx,%r15d++	rorl	$11,%r14d+	xorl	%eax,%r13d+	addl	%r15d,%r12d++	movl	%r8d,%r15d+	addl	16(%rbp),%r12d+	xorl	%r8d,%r14d++	xorl	%r9d,%r15d+	rorl	$6,%r13d+	movl	%r9d,%edx++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%edx+	addl	%r12d,%r11d+	addl	%r12d,%edx+	addl	%r14d,%edx+	movl	20(%rsi),%r12d+	movl	%r11d,%r13d+	movl	%edx,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%eax,%edi++	xorl	%r11d,%r13d+	rorl	$9,%r14d+	xorl	%ebx,%edi++	movl	%r12d,20(%rsp)+	xorl	%edx,%r14d+	andl	%r11d,%edi++	rorl	$5,%r13d+	addl	%ecx,%r12d+	xorl	%ebx,%edi++	rorl	$11,%r14d+	xorl	%r11d,%r13d+	addl	%edi,%r12d++	movl	%edx,%edi+	addl	20(%rbp),%r12d+	xorl	%edx,%r14d++	xorl	%r8d,%edi+	rorl	$6,%r13d+	movl	%r8d,%ecx++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%ecx+	addl	%r12d,%r10d+	addl	%r12d,%ecx+	addl	%r14d,%ecx+	movl	24(%rsi),%r12d+	movl	%r10d,%r13d+	movl	%ecx,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%r11d,%r15d++	xorl	%r10d,%r13d+	rorl	$9,%r14d+	xorl	%eax,%r15d++	movl	%r12d,24(%rsp)+	xorl	%ecx,%r14d+	andl	%r10d,%r15d++	rorl	$5,%r13d+	addl	%ebx,%r12d+	xorl	%eax,%r15d++	rorl	$11,%r14d+	xorl	%r10d,%r13d+	addl	%r15d,%r12d++	movl	%ecx,%r15d+	addl	24(%rbp),%r12d+	xorl	%ecx,%r14d++	xorl	%edx,%r15d+	rorl	$6,%r13d+	movl	%edx,%ebx++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%ebx+	addl	%r12d,%r9d+	addl	%r12d,%ebx+	addl	%r14d,%ebx+	movl	28(%rsi),%r12d+	movl	%r9d,%r13d+	movl	%ebx,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%r10d,%edi++	xorl	%r9d,%r13d+	rorl	$9,%r14d+	xorl	%r11d,%edi++	movl	%r12d,28(%rsp)+	xorl	%ebx,%r14d+	andl	%r9d,%edi++	rorl	$5,%r13d+	addl	%eax,%r12d+	xorl	%r11d,%edi++	rorl	$11,%r14d+	xorl	%r9d,%r13d+	addl	%edi,%r12d++	movl	%ebx,%edi+	addl	28(%rbp),%r12d+	xorl	%ebx,%r14d++	xorl	%ecx,%edi+	rorl	$6,%r13d+	movl	%ecx,%eax++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%eax+	addl	%r12d,%r8d+	addl	%r12d,%eax+	addl	%r14d,%eax+	movl	32(%rsi),%r12d+	movl	%r8d,%r13d+	movl	%eax,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%r9d,%r15d++	xorl	%r8d,%r13d+	rorl	$9,%r14d+	xorl	%r10d,%r15d++	movl	%r12d,32(%rsp)+	xorl	%eax,%r14d+	andl	%r8d,%r15d++	rorl	$5,%r13d+	addl	%r11d,%r12d+	xorl	%r10d,%r15d++	rorl	$11,%r14d+	xorl	%r8d,%r13d+	addl	%r15d,%r12d++	movl	%eax,%r15d+	addl	32(%rbp),%r12d+	xorl	%eax,%r14d++	xorl	%ebx,%r15d+	rorl	$6,%r13d+	movl	%ebx,%r11d++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%r11d+	addl	%r12d,%edx+	addl	%r12d,%r11d+	addl	%r14d,%r11d+	movl	36(%rsi),%r12d+	movl	%edx,%r13d+	movl	%r11d,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%r8d,%edi++	xorl	%edx,%r13d+	rorl	$9,%r14d+	xorl	%r9d,%edi++	movl	%r12d,36(%rsp)+	xorl	%r11d,%r14d+	andl	%edx,%edi++	rorl	$5,%r13d+	addl	%r10d,%r12d+	xorl	%r9d,%edi++	rorl	$11,%r14d+	xorl	%edx,%r13d+	addl	%edi,%r12d++	movl	%r11d,%edi+	addl	36(%rbp),%r12d+	xorl	%r11d,%r14d++	xorl	%eax,%edi+	rorl	$6,%r13d+	movl	%eax,%r10d++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%r10d+	addl	%r12d,%ecx+	addl	%r12d,%r10d+	addl	%r14d,%r10d+	movl	40(%rsi),%r12d+	movl	%ecx,%r13d+	movl	%r10d,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%edx,%r15d++	xorl	%ecx,%r13d+	rorl	$9,%r14d+	xorl	%r8d,%r15d++	movl	%r12d,40(%rsp)+	xorl	%r10d,%r14d+	andl	%ecx,%r15d++	rorl	$5,%r13d+	addl	%r9d,%r12d+	xorl	%r8d,%r15d++	rorl	$11,%r14d+	xorl	%ecx,%r13d+	addl	%r15d,%r12d++	movl	%r10d,%r15d+	addl	40(%rbp),%r12d+	xorl	%r10d,%r14d++	xorl	%r11d,%r15d+	rorl	$6,%r13d+	movl	%r11d,%r9d++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%r9d+	addl	%r12d,%ebx+	addl	%r12d,%r9d+	addl	%r14d,%r9d+	movl	44(%rsi),%r12d+	movl	%ebx,%r13d+	movl	%r9d,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%ecx,%edi++	xorl	%ebx,%r13d+	rorl	$9,%r14d+	xorl	%edx,%edi++	movl	%r12d,44(%rsp)+	xorl	%r9d,%r14d+	andl	%ebx,%edi++	rorl	$5,%r13d+	addl	%r8d,%r12d+	xorl	%edx,%edi++	rorl	$11,%r14d+	xorl	%ebx,%r13d+	addl	%edi,%r12d++	movl	%r9d,%edi+	addl	44(%rbp),%r12d+	xorl	%r9d,%r14d++	xorl	%r10d,%edi+	rorl	$6,%r13d+	movl	%r10d,%r8d++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%r8d+	addl	%r12d,%eax+	addl	%r12d,%r8d+	addl	%r14d,%r8d+	movl	48(%rsi),%r12d+	movl	%eax,%r13d+	movl	%r8d,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%ebx,%r15d++	xorl	%eax,%r13d+	rorl	$9,%r14d+	xorl	%ecx,%r15d++	movl	%r12d,48(%rsp)+	xorl	%r8d,%r14d+	andl	%eax,%r15d++	rorl	$5,%r13d+	addl	%edx,%r12d+	xorl	%ecx,%r15d++	rorl	$11,%r14d+	xorl	%eax,%r13d+	addl	%r15d,%r12d++	movl	%r8d,%r15d+	addl	48(%rbp),%r12d+	xorl	%r8d,%r14d++	xorl	%r9d,%r15d+	rorl	$6,%r13d+	movl	%r9d,%edx++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%edx+	addl	%r12d,%r11d+	addl	%r12d,%edx+	addl	%r14d,%edx+	movl	52(%rsi),%r12d+	movl	%r11d,%r13d+	movl	%edx,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%eax,%edi++	xorl	%r11d,%r13d+	rorl	$9,%r14d+	xorl	%ebx,%edi++	movl	%r12d,52(%rsp)+	xorl	%edx,%r14d+	andl	%r11d,%edi++	rorl	$5,%r13d+	addl	%ecx,%r12d+	xorl	%ebx,%edi++	rorl	$11,%r14d+	xorl	%r11d,%r13d+	addl	%edi,%r12d++	movl	%edx,%edi+	addl	52(%rbp),%r12d+	xorl	%edx,%r14d++	xorl	%r8d,%edi+	rorl	$6,%r13d+	movl	%r8d,%ecx++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%ecx+	addl	%r12d,%r10d+	addl	%r12d,%ecx+	addl	%r14d,%ecx+	movl	56(%rsi),%r12d+	movl	%r10d,%r13d+	movl	%ecx,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%r11d,%r15d++	xorl	%r10d,%r13d+	rorl	$9,%r14d+	xorl	%eax,%r15d++	movl	%r12d,56(%rsp)+	xorl	%ecx,%r14d+	andl	%r10d,%r15d++	rorl	$5,%r13d+	addl	%ebx,%r12d+	xorl	%eax,%r15d++	rorl	$11,%r14d+	xorl	%r10d,%r13d+	addl	%r15d,%r12d++	movl	%ecx,%r15d+	addl	56(%rbp),%r12d+	xorl	%ecx,%r14d++	xorl	%edx,%r15d+	rorl	$6,%r13d+	movl	%edx,%ebx++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%ebx+	addl	%r12d,%r9d+	addl	%r12d,%ebx+	addl	%r14d,%ebx+	movl	60(%rsi),%r12d+	movl	%r9d,%r13d+	movl	%ebx,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%r10d,%edi++	xorl	%r9d,%r13d+	rorl	$9,%r14d+	xorl	%r11d,%edi++	movl	%r12d,60(%rsp)+	xorl	%ebx,%r14d+	andl	%r9d,%edi++	rorl	$5,%r13d+	addl	%eax,%r12d+	xorl	%r11d,%edi++	rorl	$11,%r14d+	xorl	%r9d,%r13d+	addl	%edi,%r12d++	movl	%ebx,%edi+	addl	60(%rbp),%r12d+	xorl	%ebx,%r14d++	xorl	%ecx,%edi+	rorl	$6,%r13d+	movl	%ecx,%eax++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%eax+	addl	%r12d,%r8d+	addl	%r12d,%eax+	jmp	.Lrounds_16_xx+.p2align	4+.Lrounds_16_xx:+	movl	4(%rsp),%r13d+	movl	56(%rsp),%r15d++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%eax+	movl	%r15d,%r14d+	rorl	$2,%r15d++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%r15d+	shrl	$10,%r14d++	rorl	$17,%r15d+	xorl	%r13d,%r12d+	xorl	%r14d,%r15d+	addl	36(%rsp),%r12d++	addl	0(%rsp),%r12d+	movl	%r8d,%r13d+	addl	%r15d,%r12d+	movl	%eax,%r14d+	rorl	$14,%r13d+	movl	%r9d,%r15d++	xorl	%r8d,%r13d+	rorl	$9,%r14d+	xorl	%r10d,%r15d++	movl	%r12d,0(%rsp)+	xorl	%eax,%r14d+	andl	%r8d,%r15d++	rorl	$5,%r13d+	addl	%r11d,%r12d+	xorl	%r10d,%r15d++	rorl	$11,%r14d+	xorl	%r8d,%r13d+	addl	%r15d,%r12d++	movl	%eax,%r15d+	addl	64(%rbp),%r12d+	xorl	%eax,%r14d++	xorl	%ebx,%r15d+	rorl	$6,%r13d+	movl	%ebx,%r11d++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%r11d+	addl	%r12d,%edx+	addl	%r12d,%r11d+	movl	8(%rsp),%r13d+	movl	60(%rsp),%edi++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%r11d+	movl	%edi,%r14d+	rorl	$2,%edi++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%edi+	shrl	$10,%r14d++	rorl	$17,%edi+	xorl	%r13d,%r12d+	xorl	%r14d,%edi+	addl	40(%rsp),%r12d++	addl	4(%rsp),%r12d+	movl	%edx,%r13d+	addl	%edi,%r12d+	movl	%r11d,%r14d+	rorl	$14,%r13d+	movl	%r8d,%edi++	xorl	%edx,%r13d+	rorl	$9,%r14d+	xorl	%r9d,%edi++	movl	%r12d,4(%rsp)+	xorl	%r11d,%r14d+	andl	%edx,%edi++	rorl	$5,%r13d+	addl	%r10d,%r12d+	xorl	%r9d,%edi++	rorl	$11,%r14d+	xorl	%edx,%r13d+	addl	%edi,%r12d++	movl	%r11d,%edi+	addl	68(%rbp),%r12d+	xorl	%r11d,%r14d++	xorl	%eax,%edi+	rorl	$6,%r13d+	movl	%eax,%r10d++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%r10d+	addl	%r12d,%ecx+	addl	%r12d,%r10d+	movl	12(%rsp),%r13d+	movl	0(%rsp),%r15d++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%r10d+	movl	%r15d,%r14d+	rorl	$2,%r15d++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%r15d+	shrl	$10,%r14d++	rorl	$17,%r15d+	xorl	%r13d,%r12d+	xorl	%r14d,%r15d+	addl	44(%rsp),%r12d++	addl	8(%rsp),%r12d+	movl	%ecx,%r13d+	addl	%r15d,%r12d+	movl	%r10d,%r14d+	rorl	$14,%r13d+	movl	%edx,%r15d++	xorl	%ecx,%r13d+	rorl	$9,%r14d+	xorl	%r8d,%r15d++	movl	%r12d,8(%rsp)+	xorl	%r10d,%r14d+	andl	%ecx,%r15d++	rorl	$5,%r13d+	addl	%r9d,%r12d+	xorl	%r8d,%r15d++	rorl	$11,%r14d+	xorl	%ecx,%r13d+	addl	%r15d,%r12d++	movl	%r10d,%r15d+	addl	72(%rbp),%r12d+	xorl	%r10d,%r14d++	xorl	%r11d,%r15d+	rorl	$6,%r13d+	movl	%r11d,%r9d++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%r9d+	addl	%r12d,%ebx+	addl	%r12d,%r9d+	movl	16(%rsp),%r13d+	movl	4(%rsp),%edi++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%r9d+	movl	%edi,%r14d+	rorl	$2,%edi++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%edi+	shrl	$10,%r14d++	rorl	$17,%edi+	xorl	%r13d,%r12d+	xorl	%r14d,%edi+	addl	48(%rsp),%r12d++	addl	12(%rsp),%r12d+	movl	%ebx,%r13d+	addl	%edi,%r12d+	movl	%r9d,%r14d+	rorl	$14,%r13d+	movl	%ecx,%edi++	xorl	%ebx,%r13d+	rorl	$9,%r14d+	xorl	%edx,%edi++	movl	%r12d,12(%rsp)+	xorl	%r9d,%r14d+	andl	%ebx,%edi++	rorl	$5,%r13d+	addl	%r8d,%r12d+	xorl	%edx,%edi++	rorl	$11,%r14d+	xorl	%ebx,%r13d+	addl	%edi,%r12d++	movl	%r9d,%edi+	addl	76(%rbp),%r12d+	xorl	%r9d,%r14d++	xorl	%r10d,%edi+	rorl	$6,%r13d+	movl	%r10d,%r8d++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%r8d+	addl	%r12d,%eax+	addl	%r12d,%r8d+	movl	20(%rsp),%r13d+	movl	8(%rsp),%r15d++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%r8d+	movl	%r15d,%r14d+	rorl	$2,%r15d++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%r15d+	shrl	$10,%r14d++	rorl	$17,%r15d+	xorl	%r13d,%r12d+	xorl	%r14d,%r15d+	addl	52(%rsp),%r12d++	addl	16(%rsp),%r12d+	movl	%eax,%r13d+	addl	%r15d,%r12d+	movl	%r8d,%r14d+	rorl	$14,%r13d+	movl	%ebx,%r15d++	xorl	%eax,%r13d+	rorl	$9,%r14d+	xorl	%ecx,%r15d++	movl	%r12d,16(%rsp)+	xorl	%r8d,%r14d+	andl	%eax,%r15d++	rorl	$5,%r13d+	addl	%edx,%r12d+	xorl	%ecx,%r15d++	rorl	$11,%r14d+	xorl	%eax,%r13d+	addl	%r15d,%r12d++	movl	%r8d,%r15d+	addl	80(%rbp),%r12d+	xorl	%r8d,%r14d++	xorl	%r9d,%r15d+	rorl	$6,%r13d+	movl	%r9d,%edx++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%edx+	addl	%r12d,%r11d+	addl	%r12d,%edx+	movl	24(%rsp),%r13d+	movl	12(%rsp),%edi++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%edx+	movl	%edi,%r14d+	rorl	$2,%edi++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%edi+	shrl	$10,%r14d++	rorl	$17,%edi+	xorl	%r13d,%r12d+	xorl	%r14d,%edi+	addl	56(%rsp),%r12d++	addl	20(%rsp),%r12d+	movl	%r11d,%r13d+	addl	%edi,%r12d+	movl	%edx,%r14d+	rorl	$14,%r13d+	movl	%eax,%edi++	xorl	%r11d,%r13d+	rorl	$9,%r14d+	xorl	%ebx,%edi++	movl	%r12d,20(%rsp)+	xorl	%edx,%r14d+	andl	%r11d,%edi++	rorl	$5,%r13d+	addl	%ecx,%r12d+	xorl	%ebx,%edi++	rorl	$11,%r14d+	xorl	%r11d,%r13d+	addl	%edi,%r12d++	movl	%edx,%edi+	addl	84(%rbp),%r12d+	xorl	%edx,%r14d++	xorl	%r8d,%edi+	rorl	$6,%r13d+	movl	%r8d,%ecx++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%ecx+	addl	%r12d,%r10d+	addl	%r12d,%ecx+	movl	28(%rsp),%r13d+	movl	16(%rsp),%r15d++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%ecx+	movl	%r15d,%r14d+	rorl	$2,%r15d++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%r15d+	shrl	$10,%r14d++	rorl	$17,%r15d+	xorl	%r13d,%r12d+	xorl	%r14d,%r15d+	addl	60(%rsp),%r12d++	addl	24(%rsp),%r12d+	movl	%r10d,%r13d+	addl	%r15d,%r12d+	movl	%ecx,%r14d+	rorl	$14,%r13d+	movl	%r11d,%r15d++	xorl	%r10d,%r13d+	rorl	$9,%r14d+	xorl	%eax,%r15d++	movl	%r12d,24(%rsp)+	xorl	%ecx,%r14d+	andl	%r10d,%r15d++	rorl	$5,%r13d+	addl	%ebx,%r12d+	xorl	%eax,%r15d++	rorl	$11,%r14d+	xorl	%r10d,%r13d+	addl	%r15d,%r12d++	movl	%ecx,%r15d+	addl	88(%rbp),%r12d+	xorl	%ecx,%r14d++	xorl	%edx,%r15d+	rorl	$6,%r13d+	movl	%edx,%ebx++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%ebx+	addl	%r12d,%r9d+	addl	%r12d,%ebx+	movl	32(%rsp),%r13d+	movl	20(%rsp),%edi++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%ebx+	movl	%edi,%r14d+	rorl	$2,%edi++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%edi+	shrl	$10,%r14d++	rorl	$17,%edi+	xorl	%r13d,%r12d+	xorl	%r14d,%edi+	addl	0(%rsp),%r12d++	addl	28(%rsp),%r12d+	movl	%r9d,%r13d+	addl	%edi,%r12d+	movl	%ebx,%r14d+	rorl	$14,%r13d+	movl	%r10d,%edi++	xorl	%r9d,%r13d+	rorl	$9,%r14d+	xorl	%r11d,%edi++	movl	%r12d,28(%rsp)+	xorl	%ebx,%r14d+	andl	%r9d,%edi++	rorl	$5,%r13d+	addl	%eax,%r12d+	xorl	%r11d,%edi++	rorl	$11,%r14d+	xorl	%r9d,%r13d+	addl	%edi,%r12d++	movl	%ebx,%edi+	addl	92(%rbp),%r12d+	xorl	%ebx,%r14d++	xorl	%ecx,%edi+	rorl	$6,%r13d+	movl	%ecx,%eax++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%eax+	addl	%r12d,%r8d+	addl	%r12d,%eax+	movl	36(%rsp),%r13d+	movl	24(%rsp),%r15d++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%eax+	movl	%r15d,%r14d+	rorl	$2,%r15d++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%r15d+	shrl	$10,%r14d++	rorl	$17,%r15d+	xorl	%r13d,%r12d+	xorl	%r14d,%r15d+	addl	4(%rsp),%r12d++	addl	32(%rsp),%r12d+	movl	%r8d,%r13d+	addl	%r15d,%r12d+	movl	%eax,%r14d+	rorl	$14,%r13d+	movl	%r9d,%r15d++	xorl	%r8d,%r13d+	rorl	$9,%r14d+	xorl	%r10d,%r15d++	movl	%r12d,32(%rsp)+	xorl	%eax,%r14d+	andl	%r8d,%r15d++	rorl	$5,%r13d+	addl	%r11d,%r12d+	xorl	%r10d,%r15d++	rorl	$11,%r14d+	xorl	%r8d,%r13d+	addl	%r15d,%r12d++	movl	%eax,%r15d+	addl	96(%rbp),%r12d+	xorl	%eax,%r14d++	xorl	%ebx,%r15d+	rorl	$6,%r13d+	movl	%ebx,%r11d++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%r11d+	addl	%r12d,%edx+	addl	%r12d,%r11d+	movl	40(%rsp),%r13d+	movl	28(%rsp),%edi++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%r11d+	movl	%edi,%r14d+	rorl	$2,%edi++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%edi+	shrl	$10,%r14d++	rorl	$17,%edi+	xorl	%r13d,%r12d+	xorl	%r14d,%edi+	addl	8(%rsp),%r12d++	addl	36(%rsp),%r12d+	movl	%edx,%r13d+	addl	%edi,%r12d+	movl	%r11d,%r14d+	rorl	$14,%r13d+	movl	%r8d,%edi++	xorl	%edx,%r13d+	rorl	$9,%r14d+	xorl	%r9d,%edi++	movl	%r12d,36(%rsp)+	xorl	%r11d,%r14d+	andl	%edx,%edi++	rorl	$5,%r13d+	addl	%r10d,%r12d+	xorl	%r9d,%edi++	rorl	$11,%r14d+	xorl	%edx,%r13d+	addl	%edi,%r12d++	movl	%r11d,%edi+	addl	100(%rbp),%r12d+	xorl	%r11d,%r14d++	xorl	%eax,%edi+	rorl	$6,%r13d+	movl	%eax,%r10d++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%r10d+	addl	%r12d,%ecx+	addl	%r12d,%r10d+	movl	44(%rsp),%r13d+	movl	32(%rsp),%r15d++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%r10d+	movl	%r15d,%r14d+	rorl	$2,%r15d++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%r15d+	shrl	$10,%r14d++	rorl	$17,%r15d+	xorl	%r13d,%r12d+	xorl	%r14d,%r15d+	addl	12(%rsp),%r12d++	addl	40(%rsp),%r12d+	movl	%ecx,%r13d+	addl	%r15d,%r12d+	movl	%r10d,%r14d+	rorl	$14,%r13d+	movl	%edx,%r15d++	xorl	%ecx,%r13d+	rorl	$9,%r14d+	xorl	%r8d,%r15d++	movl	%r12d,40(%rsp)+	xorl	%r10d,%r14d+	andl	%ecx,%r15d++	rorl	$5,%r13d+	addl	%r9d,%r12d+	xorl	%r8d,%r15d++	rorl	$11,%r14d+	xorl	%ecx,%r13d+	addl	%r15d,%r12d++	movl	%r10d,%r15d+	addl	104(%rbp),%r12d+	xorl	%r10d,%r14d++	xorl	%r11d,%r15d+	rorl	$6,%r13d+	movl	%r11d,%r9d++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%r9d+	addl	%r12d,%ebx+	addl	%r12d,%r9d+	movl	48(%rsp),%r13d+	movl	36(%rsp),%edi++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%r9d+	movl	%edi,%r14d+	rorl	$2,%edi++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%edi+	shrl	$10,%r14d++	rorl	$17,%edi+	xorl	%r13d,%r12d+	xorl	%r14d,%edi+	addl	16(%rsp),%r12d++	addl	44(%rsp),%r12d+	movl	%ebx,%r13d+	addl	%edi,%r12d+	movl	%r9d,%r14d+	rorl	$14,%r13d+	movl	%ecx,%edi++	xorl	%ebx,%r13d+	rorl	$9,%r14d+	xorl	%edx,%edi++	movl	%r12d,44(%rsp)+	xorl	%r9d,%r14d+	andl	%ebx,%edi++	rorl	$5,%r13d+	addl	%r8d,%r12d+	xorl	%edx,%edi++	rorl	$11,%r14d+	xorl	%ebx,%r13d+	addl	%edi,%r12d++	movl	%r9d,%edi+	addl	108(%rbp),%r12d+	xorl	%r9d,%r14d++	xorl	%r10d,%edi+	rorl	$6,%r13d+	movl	%r10d,%r8d++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%r8d+	addl	%r12d,%eax+	addl	%r12d,%r8d+	movl	52(%rsp),%r13d+	movl	40(%rsp),%r15d++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%r8d+	movl	%r15d,%r14d+	rorl	$2,%r15d++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%r15d+	shrl	$10,%r14d++	rorl	$17,%r15d+	xorl	%r13d,%r12d+	xorl	%r14d,%r15d+	addl	20(%rsp),%r12d++	addl	48(%rsp),%r12d+	movl	%eax,%r13d+	addl	%r15d,%r12d+	movl	%r8d,%r14d+	rorl	$14,%r13d+	movl	%ebx,%r15d++	xorl	%eax,%r13d+	rorl	$9,%r14d+	xorl	%ecx,%r15d++	movl	%r12d,48(%rsp)+	xorl	%r8d,%r14d+	andl	%eax,%r15d++	rorl	$5,%r13d+	addl	%edx,%r12d+	xorl	%ecx,%r15d++	rorl	$11,%r14d+	xorl	%eax,%r13d+	addl	%r15d,%r12d++	movl	%r8d,%r15d+	addl	112(%rbp),%r12d+	xorl	%r8d,%r14d++	xorl	%r9d,%r15d+	rorl	$6,%r13d+	movl	%r9d,%edx++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%edx+	addl	%r12d,%r11d+	addl	%r12d,%edx+	movl	56(%rsp),%r13d+	movl	44(%rsp),%edi++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%edx+	movl	%edi,%r14d+	rorl	$2,%edi++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%edi+	shrl	$10,%r14d++	rorl	$17,%edi+	xorl	%r13d,%r12d+	xorl	%r14d,%edi+	addl	24(%rsp),%r12d++	addl	52(%rsp),%r12d+	movl	%r11d,%r13d+	addl	%edi,%r12d+	movl	%edx,%r14d+	rorl	$14,%r13d+	movl	%eax,%edi++	xorl	%r11d,%r13d+	rorl	$9,%r14d+	xorl	%ebx,%edi++	movl	%r12d,52(%rsp)+	xorl	%edx,%r14d+	andl	%r11d,%edi++	rorl	$5,%r13d+	addl	%ecx,%r12d+	xorl	%ebx,%edi++	rorl	$11,%r14d+	xorl	%r11d,%r13d+	addl	%edi,%r12d++	movl	%edx,%edi+	addl	116(%rbp),%r12d+	xorl	%edx,%r14d++	xorl	%r8d,%edi+	rorl	$6,%r13d+	movl	%r8d,%ecx++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%ecx+	addl	%r12d,%r10d+	addl	%r12d,%ecx+	movl	60(%rsp),%r13d+	movl	48(%rsp),%r15d++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%ecx+	movl	%r15d,%r14d+	rorl	$2,%r15d++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%r15d+	shrl	$10,%r14d++	rorl	$17,%r15d+	xorl	%r13d,%r12d+	xorl	%r14d,%r15d+	addl	28(%rsp),%r12d++	addl	56(%rsp),%r12d+	movl	%r10d,%r13d+	addl	%r15d,%r12d+	movl	%ecx,%r14d+	rorl	$14,%r13d+	movl	%r11d,%r15d++	xorl	%r10d,%r13d+	rorl	$9,%r14d+	xorl	%eax,%r15d++	movl	%r12d,56(%rsp)+	xorl	%ecx,%r14d+	andl	%r10d,%r15d++	rorl	$5,%r13d+	addl	%ebx,%r12d+	xorl	%eax,%r15d++	rorl	$11,%r14d+	xorl	%r10d,%r13d+	addl	%r15d,%r12d++	movl	%ecx,%r15d+	addl	120(%rbp),%r12d+	xorl	%ecx,%r14d++	xorl	%edx,%r15d+	rorl	$6,%r13d+	movl	%edx,%ebx++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%ebx+	addl	%r12d,%r9d+	addl	%r12d,%ebx+	movl	0(%rsp),%r13d+	movl	52(%rsp),%edi++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%ebx+	movl	%edi,%r14d+	rorl	$2,%edi++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%edi+	shrl	$10,%r14d++	rorl	$17,%edi+	xorl	%r13d,%r12d+	xorl	%r14d,%edi+	addl	32(%rsp),%r12d++	addl	60(%rsp),%r12d+	movl	%r9d,%r13d+	addl	%edi,%r12d+	movl	%ebx,%r14d+	rorl	$14,%r13d+	movl	%r10d,%edi++	xorl	%r9d,%r13d+	rorl	$9,%r14d+	xorl	%r11d,%edi++	movl	%r12d,60(%rsp)+	xorl	%ebx,%r14d+	andl	%r9d,%edi++	rorl	$5,%r13d+	addl	%eax,%r12d+	xorl	%r11d,%edi++	rorl	$11,%r14d+	xorl	%r9d,%r13d+	addl	%edi,%r12d++	movl	%ebx,%edi+	addl	124(%rbp),%r12d+	xorl	%ebx,%r14d++	xorl	%ecx,%edi+	rorl	$6,%r13d+	movl	%ecx,%eax++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%eax+	addl	%r12d,%r8d+	addl	%r12d,%eax+	leaq	64(%rbp),%rbp+	cmpb	$0x19,3(%rbp)+	jnz	.Lrounds_16_xx++	movq	64+0(%rsp),%rdi+	addl	%r14d,%eax+	leaq	64(%rsi),%rsi++	addl	0(%rdi),%eax+	addl	4(%rdi),%ebx+	addl	8(%rdi),%ecx+	addl	12(%rdi),%edx+	addl	16(%rdi),%r8d+	addl	20(%rdi),%r9d+	addl	24(%rdi),%r10d+	addl	28(%rdi),%r11d++	cmpq	64+16(%rsp),%rsi++	movl	%eax,0(%rdi)+	movl	%ebx,4(%rdi)+	movl	%ecx,8(%rdi)+	movl	%edx,12(%rdi)+	movl	%r8d,16(%rdi)+	movl	%r9d,20(%rdi)+	movl	%r10d,24(%rdi)+	movl	%r11d,28(%rdi)+	jb	.Lloop++	leaq	64+24+48(%rsp),%r11++	movq	64+24(%rsp),%r15++	movq	-40(%r11),%r14++	movq	-32(%r11),%r13++	movq	-24(%r11),%r12++	movq	-16(%r11),%rbp++	movq	-8(%r11),%rbx++.LSEH_epilogue_blst_sha256_block_data_order:+	mov	8(%r11),%rdi+	mov	16(%r11),%rsi++	leaq	(%r11),%rsp+	.byte	0xf3,0xc3++.LSEH_end_blst_sha256_block_data_order:++.p2align	6++K256:+.long	0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5+.long	0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5+.long	0xd807aa98,0x12835b01,0x243185be,0x550c7dc3+.long	0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174+.long	0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc+.long	0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da+.long	0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7+.long	0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967+.long	0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13+.long	0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85+.long	0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3+.long	0xd192e819,0xd6990624,0xf40e3585,0x106aa070+.long	0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5+.long	0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3+.long	0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208+.long	0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2++.byte	83,72,65,50,53,54,32,98,108,111,99,107,32,116,114,97,110,115,102,111,114,109,32,102,111,114,32,120,56,54,95,54,52,44,32,67,82,89,80,84,79,71,65,77,83,32,98,121,32,64,100,111,116,45,97,115,109,0+.globl	blst_sha256_emit++.def	blst_sha256_emit;	.scl 2;	.type 32;	.endef+.p2align	4+blst_sha256_emit:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rdx),%r8+	movq	8(%rdx),%r9+	movq	16(%rdx),%r10+	bswapq	%r8+	movq	24(%rdx),%r11+	bswapq	%r9+	movl	%r8d,4(%rcx)+	bswapq	%r10+	movl	%r9d,12(%rcx)+	bswapq	%r11+	movl	%r10d,20(%rcx)+	shrq	$32,%r8+	movl	%r11d,28(%rcx)+	shrq	$32,%r9+	movl	%r8d,0(%rcx)+	shrq	$32,%r10+	movl	%r9d,8(%rcx)+	shrq	$32,%r11+	movl	%r10d,16(%rcx)+	movl	%r11d,24(%rcx)+	.byte	0xf3,0xc3+++.globl	blst_sha256_bcopy++.def	blst_sha256_bcopy;	.scl 2;	.type 32;	.endef+.p2align	4+blst_sha256_bcopy:+	.byte	0xf3,0x0f,0x1e,0xfa++	subq	%rdx,%rcx+.Loop_bcopy:+	movzbl	(%rdx),%eax+	leaq	1(%rdx),%rdx+	movb	%al,-1(%rcx,%rdx,1)+	decq	%r8+	jnz	.Loop_bcopy+	.byte	0xf3,0xc3+++.globl	blst_sha256_hcopy++.def	blst_sha256_hcopy;	.scl 2;	.type 32;	.endef+.p2align	4+blst_sha256_hcopy:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rdx),%r8+	movq	8(%rdx),%r9+	movq	16(%rdx),%r10+	movq	24(%rdx),%r11+	movq	%r8,0(%rcx)+	movq	%r9,8(%rcx)+	movq	%r10,16(%rcx)+	movq	%r11,24(%rcx)+	.byte	0xf3,0xc3++.section	.pdata+.p2align	2+.rva	.LSEH_begin_blst_sha256_block_data_order+.rva	.LSEH_body_blst_sha256_block_data_order+.rva	.LSEH_info_blst_sha256_block_data_order_prologue++.rva	.LSEH_body_blst_sha256_block_data_order+.rva	.LSEH_epilogue_blst_sha256_block_data_order+.rva	.LSEH_info_blst_sha256_block_data_order_body++.rva	.LSEH_epilogue_blst_sha256_block_data_order+.rva	.LSEH_end_blst_sha256_block_data_order+.rva	.LSEH_info_blst_sha256_block_data_order_epilogue++.section	.xdata+.p2align	3+.LSEH_info_blst_sha256_block_data_order_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_blst_sha256_block_data_order_body:+.byte	1,0,18,0+.byte	0x00,0xf4,0x0b,0x00+.byte	0x00,0xe4,0x0c,0x00+.byte	0x00,0xd4,0x0d,0x00+.byte	0x00,0xc4,0x0e,0x00+.byte	0x00,0x54,0x0f,0x00+.byte	0x00,0x34,0x10,0x00+.byte	0x00,0x74,0x12,0x00+.byte	0x00,0x64,0x13,0x00+.byte	0x00,0x01,0x11,0x00+.LSEH_info_blst_sha256_block_data_order_epilogue:+.byte	1,0,5,11+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x03+.byte	0x00,0x00+
+ c-source/build/coff/sha256-x86_64.s view
@@ -0,0 +1,1560 @@+.text	++.p2align	6++K256:+.long	0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5+.long	0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5+.long	0xd807aa98,0x12835b01,0x243185be,0x550c7dc3+.long	0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174+.long	0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc+.long	0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da+.long	0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7+.long	0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967+.long	0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13+.long	0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85+.long	0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3+.long	0xd192e819,0xd6990624,0xf40e3585,0x106aa070+.long	0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5+.long	0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3+.long	0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208+.long	0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2++.long	0x00010203,0x04050607,0x08090a0b,0x0c0d0e0f+.long	0x03020100,0x0b0a0908,0xffffffff,0xffffffff+.long	0xffffffff,0xffffffff,0x03020100,0x0b0a0908+.byte	83,72,65,50,53,54,32,98,108,111,99,107,32,116,114,97,110,115,102,111,114,109,32,102,111,114,32,120,56,54,95,54,52,44,32,67,82,89,80,84,79,71,65,77,83,32,98,121,32,64,100,111,116,45,97,115,109,0+.globl	blst_sha256_block_data_order_shaext++.def	blst_sha256_block_data_order_shaext;	.scl 2;	.type 32;	.endef+.p2align	6+blst_sha256_block_data_order_shaext:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_blst_sha256_block_data_order_shaext:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+++	subq	$0x58,%rsp++	movaps	%xmm6,-88(%r11)++	movaps	%xmm7,-72(%r11)++	movaps	%xmm8,-56(%r11)++	movaps	%xmm9,-40(%r11)++	movaps	%xmm10,-24(%r11)++.LSEH_body_blst_sha256_block_data_order_shaext:++	leaq	K256+128(%rip),%rcx+	movdqu	(%rdi),%xmm1+	movdqu	16(%rdi),%xmm2+	movdqa	256-128(%rcx),%xmm7++	pshufd	$0x1b,%xmm1,%xmm0+	pshufd	$0xb1,%xmm1,%xmm1+	pshufd	$0x1b,%xmm2,%xmm2+	movdqa	%xmm7,%xmm8+.byte	102,15,58,15,202,8+	punpcklqdq	%xmm0,%xmm2+	jmp	.Loop_shaext++.p2align	4+.Loop_shaext:+	movdqu	(%rsi),%xmm3+	movdqu	16(%rsi),%xmm4+	movdqu	32(%rsi),%xmm5+.byte	102,15,56,0,223+	movdqu	48(%rsi),%xmm6++	movdqa	0-128(%rcx),%xmm0+	paddd	%xmm3,%xmm0+.byte	102,15,56,0,231+	movdqa	%xmm2,%xmm10+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	nop+	movdqa	%xmm1,%xmm9+.byte	15,56,203,202++	movdqa	16-128(%rcx),%xmm0+	paddd	%xmm4,%xmm0+.byte	102,15,56,0,239+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	leaq	64(%rsi),%rsi+.byte	15,56,204,220+.byte	15,56,203,202++	movdqa	32-128(%rcx),%xmm0+	paddd	%xmm5,%xmm0+.byte	102,15,56,0,247+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm6,%xmm7+.byte	102,15,58,15,253,4+	nop+	paddd	%xmm7,%xmm3+.byte	15,56,204,229+.byte	15,56,203,202++	movdqa	48-128(%rcx),%xmm0+	paddd	%xmm6,%xmm0+.byte	15,56,205,222+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm3,%xmm7+.byte	102,15,58,15,254,4+	nop+	paddd	%xmm7,%xmm4+.byte	15,56,204,238+.byte	15,56,203,202+	movdqa	64-128(%rcx),%xmm0+	paddd	%xmm3,%xmm0+.byte	15,56,205,227+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm4,%xmm7+.byte	102,15,58,15,251,4+	nop+	paddd	%xmm7,%xmm5+.byte	15,56,204,243+.byte	15,56,203,202+	movdqa	80-128(%rcx),%xmm0+	paddd	%xmm4,%xmm0+.byte	15,56,205,236+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm5,%xmm7+.byte	102,15,58,15,252,4+	nop+	paddd	%xmm7,%xmm6+.byte	15,56,204,220+.byte	15,56,203,202+	movdqa	96-128(%rcx),%xmm0+	paddd	%xmm5,%xmm0+.byte	15,56,205,245+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm6,%xmm7+.byte	102,15,58,15,253,4+	nop+	paddd	%xmm7,%xmm3+.byte	15,56,204,229+.byte	15,56,203,202+	movdqa	112-128(%rcx),%xmm0+	paddd	%xmm6,%xmm0+.byte	15,56,205,222+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm3,%xmm7+.byte	102,15,58,15,254,4+	nop+	paddd	%xmm7,%xmm4+.byte	15,56,204,238+.byte	15,56,203,202+	movdqa	128-128(%rcx),%xmm0+	paddd	%xmm3,%xmm0+.byte	15,56,205,227+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm4,%xmm7+.byte	102,15,58,15,251,4+	nop+	paddd	%xmm7,%xmm5+.byte	15,56,204,243+.byte	15,56,203,202+	movdqa	144-128(%rcx),%xmm0+	paddd	%xmm4,%xmm0+.byte	15,56,205,236+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm5,%xmm7+.byte	102,15,58,15,252,4+	nop+	paddd	%xmm7,%xmm6+.byte	15,56,204,220+.byte	15,56,203,202+	movdqa	160-128(%rcx),%xmm0+	paddd	%xmm5,%xmm0+.byte	15,56,205,245+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm6,%xmm7+.byte	102,15,58,15,253,4+	nop+	paddd	%xmm7,%xmm3+.byte	15,56,204,229+.byte	15,56,203,202+	movdqa	176-128(%rcx),%xmm0+	paddd	%xmm6,%xmm0+.byte	15,56,205,222+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm3,%xmm7+.byte	102,15,58,15,254,4+	nop+	paddd	%xmm7,%xmm4+.byte	15,56,204,238+.byte	15,56,203,202+	movdqa	192-128(%rcx),%xmm0+	paddd	%xmm3,%xmm0+.byte	15,56,205,227+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm4,%xmm7+.byte	102,15,58,15,251,4+	nop+	paddd	%xmm7,%xmm5+.byte	15,56,204,243+.byte	15,56,203,202+	movdqa	208-128(%rcx),%xmm0+	paddd	%xmm4,%xmm0+.byte	15,56,205,236+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm5,%xmm7+.byte	102,15,58,15,252,4+.byte	15,56,203,202+	paddd	%xmm7,%xmm6++	movdqa	224-128(%rcx),%xmm0+	paddd	%xmm5,%xmm0+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+.byte	15,56,205,245+	movdqa	%xmm8,%xmm7+.byte	15,56,203,202++	movdqa	240-128(%rcx),%xmm0+	paddd	%xmm6,%xmm0+	nop+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	decq	%rdx+	nop+.byte	15,56,203,202++	paddd	%xmm10,%xmm2+	paddd	%xmm9,%xmm1+	jnz	.Loop_shaext++	pshufd	$0xb1,%xmm2,%xmm2+	pshufd	$0x1b,%xmm1,%xmm7+	pshufd	$0xb1,%xmm1,%xmm1+	punpckhqdq	%xmm2,%xmm1+.byte	102,15,58,15,215,8++	movdqu	%xmm1,(%rdi)+	movdqu	%xmm2,16(%rdi)+	movaps	-88(%r11),%xmm6+	movaps	-72(%r11),%xmm7+	movaps	-56(%r11),%xmm8+	movaps	-40(%r11),%xmm9+	movaps	-24(%r11),%xmm10+	movq	%r11,%rsp++.LSEH_epilogue_blst_sha256_block_data_order_shaext:+	mov	8(%r11),%rdi+	mov	16(%r11),%rsi++	.byte	0xf3,0xc3++.LSEH_end_blst_sha256_block_data_order_shaext:+.globl	blst_sha256_block_data_order++.def	blst_sha256_block_data_order;	.scl 2;	.type 32;	.endef+.p2align	6+blst_sha256_block_data_order:+	.byte	0xf3,0x0f,0x1e,0xfa+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	movq	%rsp,%r11+.LSEH_begin_blst_sha256_block_data_order:+	movq	%rcx,%rdi+	movq	%rdx,%rsi+	movq	%r8,%rdx+++	pushq	%rbp++	pushq	%rbx++	pushq	%r12++	pushq	%r13++	pushq	%r14++	pushq	%r15++	shlq	$4,%rdx+	subq	$104,%rsp++	leaq	(%rsi,%rdx,4),%rdx+	movq	%rdi,0(%rsp)++	movq	%rdx,16(%rsp)+	movaps	%xmm6,32(%rsp)++	movaps	%xmm7,48(%rsp)++	movaps	%xmm8,64(%rsp)++	movaps	%xmm9,80(%rsp)++	movq	%rsp,%rbp++.LSEH_body_blst_sha256_block_data_order:+++	leaq	-64(%rsp),%rsp+	movl	0(%rdi),%eax+	andq	$-64,%rsp+	movl	4(%rdi),%ebx+	movl	8(%rdi),%ecx+	movl	12(%rdi),%edx+	movl	16(%rdi),%r8d+	movl	20(%rdi),%r9d+	movl	24(%rdi),%r10d+	movl	28(%rdi),%r11d+++	jmp	.Lloop_ssse3+.p2align	4+.Lloop_ssse3:+	movdqa	K256+256(%rip),%xmm7+	movq	%rsi,8(%rbp)+	movdqu	0(%rsi),%xmm0+	movdqu	16(%rsi),%xmm1+	movdqu	32(%rsi),%xmm2+.byte	102,15,56,0,199+	movdqu	48(%rsi),%xmm3+	leaq	K256(%rip),%rsi+.byte	102,15,56,0,207+	movdqa	0(%rsi),%xmm4+	movdqa	16(%rsi),%xmm5+.byte	102,15,56,0,215+	paddd	%xmm0,%xmm4+	movdqa	32(%rsi),%xmm6+.byte	102,15,56,0,223+	movdqa	48(%rsi),%xmm7+	paddd	%xmm1,%xmm5+	paddd	%xmm2,%xmm6+	paddd	%xmm3,%xmm7+	movdqa	%xmm4,0(%rsp)+	movl	%eax,%r14d+	movdqa	%xmm5,16(%rsp)+	movl	%ebx,%edi+	movdqa	%xmm6,32(%rsp)+	xorl	%ecx,%edi+	movdqa	%xmm7,48(%rsp)+	movl	%r8d,%r13d+	jmp	.Lssse3_00_47++.p2align	4+.Lssse3_00_47:+	subq	$-64,%rsi+	rorl	$14,%r13d+	movdqa	%xmm1,%xmm4+	movl	%r14d,%eax+	movl	%r9d,%r12d+	movdqa	%xmm3,%xmm7+	rorl	$9,%r14d+	xorl	%r8d,%r13d+	xorl	%r10d,%r12d+	rorl	$5,%r13d+	xorl	%eax,%r14d+.byte	102,15,58,15,224,4+	andl	%r8d,%r12d+	xorl	%r8d,%r13d+.byte	102,15,58,15,250,4+	addl	0(%rsp),%r11d+	movl	%eax,%r15d+	xorl	%r10d,%r12d+	rorl	$11,%r14d+	movdqa	%xmm4,%xmm5+	xorl	%ebx,%r15d+	addl	%r12d,%r11d+	movdqa	%xmm4,%xmm6+	rorl	$6,%r13d+	andl	%r15d,%edi+	psrld	$3,%xmm4+	xorl	%eax,%r14d+	addl	%r13d,%r11d+	xorl	%ebx,%edi+	paddd	%xmm7,%xmm0+	rorl	$2,%r14d+	addl	%r11d,%edx+	psrld	$7,%xmm6+	addl	%edi,%r11d+	movl	%edx,%r13d+	pshufd	$250,%xmm3,%xmm7+	addl	%r11d,%r14d+	rorl	$14,%r13d+	pslld	$14,%xmm5+	movl	%r14d,%r11d+	movl	%r8d,%r12d+	pxor	%xmm6,%xmm4+	rorl	$9,%r14d+	xorl	%edx,%r13d+	xorl	%r9d,%r12d+	rorl	$5,%r13d+	psrld	$11,%xmm6+	xorl	%r11d,%r14d+	pxor	%xmm5,%xmm4+	andl	%edx,%r12d+	xorl	%edx,%r13d+	pslld	$11,%xmm5+	addl	4(%rsp),%r10d+	movl	%r11d,%edi+	pxor	%xmm6,%xmm4+	xorl	%r9d,%r12d+	rorl	$11,%r14d+	movdqa	%xmm7,%xmm6+	xorl	%eax,%edi+	addl	%r12d,%r10d+	pxor	%xmm5,%xmm4+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%r11d,%r14d+	psrld	$10,%xmm7+	addl	%r13d,%r10d+	xorl	%eax,%r15d+	paddd	%xmm4,%xmm0+	rorl	$2,%r14d+	addl	%r10d,%ecx+	psrlq	$17,%xmm6+	addl	%r15d,%r10d+	movl	%ecx,%r13d+	addl	%r10d,%r14d+	pxor	%xmm6,%xmm7+	rorl	$14,%r13d+	movl	%r14d,%r10d+	movl	%edx,%r12d+	rorl	$9,%r14d+	psrlq	$2,%xmm6+	xorl	%ecx,%r13d+	xorl	%r8d,%r12d+	pxor	%xmm6,%xmm7+	rorl	$5,%r13d+	xorl	%r10d,%r14d+	andl	%ecx,%r12d+	pshufd	$128,%xmm7,%xmm7+	xorl	%ecx,%r13d+	addl	8(%rsp),%r9d+	movl	%r10d,%r15d+	psrldq	$8,%xmm7+	xorl	%r8d,%r12d+	rorl	$11,%r14d+	xorl	%r11d,%r15d+	addl	%r12d,%r9d+	rorl	$6,%r13d+	paddd	%xmm7,%xmm0+	andl	%r15d,%edi+	xorl	%r10d,%r14d+	addl	%r13d,%r9d+	pshufd	$80,%xmm0,%xmm7+	xorl	%r11d,%edi+	rorl	$2,%r14d+	addl	%r9d,%ebx+	movdqa	%xmm7,%xmm6+	addl	%edi,%r9d+	movl	%ebx,%r13d+	psrld	$10,%xmm7+	addl	%r9d,%r14d+	rorl	$14,%r13d+	psrlq	$17,%xmm6+	movl	%r14d,%r9d+	movl	%ecx,%r12d+	pxor	%xmm6,%xmm7+	rorl	$9,%r14d+	xorl	%ebx,%r13d+	xorl	%edx,%r12d+	rorl	$5,%r13d+	xorl	%r9d,%r14d+	psrlq	$2,%xmm6+	andl	%ebx,%r12d+	xorl	%ebx,%r13d+	addl	12(%rsp),%r8d+	pxor	%xmm6,%xmm7+	movl	%r9d,%edi+	xorl	%edx,%r12d+	rorl	$11,%r14d+	pshufd	$8,%xmm7,%xmm7+	xorl	%r10d,%edi+	addl	%r12d,%r8d+	movdqa	0(%rsi),%xmm6+	rorl	$6,%r13d+	andl	%edi,%r15d+	pslldq	$8,%xmm7+	xorl	%r9d,%r14d+	addl	%r13d,%r8d+	xorl	%r10d,%r15d+	paddd	%xmm7,%xmm0+	rorl	$2,%r14d+	addl	%r8d,%eax+	addl	%r15d,%r8d+	paddd	%xmm0,%xmm6+	movl	%eax,%r13d+	addl	%r8d,%r14d+	movdqa	%xmm6,0(%rsp)+	rorl	$14,%r13d+	movdqa	%xmm2,%xmm4+	movl	%r14d,%r8d+	movl	%ebx,%r12d+	movdqa	%xmm0,%xmm7+	rorl	$9,%r14d+	xorl	%eax,%r13d+	xorl	%ecx,%r12d+	rorl	$5,%r13d+	xorl	%r8d,%r14d+.byte	102,15,58,15,225,4+	andl	%eax,%r12d+	xorl	%eax,%r13d+.byte	102,15,58,15,251,4+	addl	16(%rsp),%edx+	movl	%r8d,%r15d+	xorl	%ecx,%r12d+	rorl	$11,%r14d+	movdqa	%xmm4,%xmm5+	xorl	%r9d,%r15d+	addl	%r12d,%edx+	movdqa	%xmm4,%xmm6+	rorl	$6,%r13d+	andl	%r15d,%edi+	psrld	$3,%xmm4+	xorl	%r8d,%r14d+	addl	%r13d,%edx+	xorl	%r9d,%edi+	paddd	%xmm7,%xmm1+	rorl	$2,%r14d+	addl	%edx,%r11d+	psrld	$7,%xmm6+	addl	%edi,%edx+	movl	%r11d,%r13d+	pshufd	$250,%xmm0,%xmm7+	addl	%edx,%r14d+	rorl	$14,%r13d+	pslld	$14,%xmm5+	movl	%r14d,%edx+	movl	%eax,%r12d+	pxor	%xmm6,%xmm4+	rorl	$9,%r14d+	xorl	%r11d,%r13d+	xorl	%ebx,%r12d+	rorl	$5,%r13d+	psrld	$11,%xmm6+	xorl	%edx,%r14d+	pxor	%xmm5,%xmm4+	andl	%r11d,%r12d+	xorl	%r11d,%r13d+	pslld	$11,%xmm5+	addl	20(%rsp),%ecx+	movl	%edx,%edi+	pxor	%xmm6,%xmm4+	xorl	%ebx,%r12d+	rorl	$11,%r14d+	movdqa	%xmm7,%xmm6+	xorl	%r8d,%edi+	addl	%r12d,%ecx+	pxor	%xmm5,%xmm4+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%edx,%r14d+	psrld	$10,%xmm7+	addl	%r13d,%ecx+	xorl	%r8d,%r15d+	paddd	%xmm4,%xmm1+	rorl	$2,%r14d+	addl	%ecx,%r10d+	psrlq	$17,%xmm6+	addl	%r15d,%ecx+	movl	%r10d,%r13d+	addl	%ecx,%r14d+	pxor	%xmm6,%xmm7+	rorl	$14,%r13d+	movl	%r14d,%ecx+	movl	%r11d,%r12d+	rorl	$9,%r14d+	psrlq	$2,%xmm6+	xorl	%r10d,%r13d+	xorl	%eax,%r12d+	pxor	%xmm6,%xmm7+	rorl	$5,%r13d+	xorl	%ecx,%r14d+	andl	%r10d,%r12d+	pshufd	$128,%xmm7,%xmm7+	xorl	%r10d,%r13d+	addl	24(%rsp),%ebx+	movl	%ecx,%r15d+	psrldq	$8,%xmm7+	xorl	%eax,%r12d+	rorl	$11,%r14d+	xorl	%edx,%r15d+	addl	%r12d,%ebx+	rorl	$6,%r13d+	paddd	%xmm7,%xmm1+	andl	%r15d,%edi+	xorl	%ecx,%r14d+	addl	%r13d,%ebx+	pshufd	$80,%xmm1,%xmm7+	xorl	%edx,%edi+	rorl	$2,%r14d+	addl	%ebx,%r9d+	movdqa	%xmm7,%xmm6+	addl	%edi,%ebx+	movl	%r9d,%r13d+	psrld	$10,%xmm7+	addl	%ebx,%r14d+	rorl	$14,%r13d+	psrlq	$17,%xmm6+	movl	%r14d,%ebx+	movl	%r10d,%r12d+	pxor	%xmm6,%xmm7+	rorl	$9,%r14d+	xorl	%r9d,%r13d+	xorl	%r11d,%r12d+	rorl	$5,%r13d+	xorl	%ebx,%r14d+	psrlq	$2,%xmm6+	andl	%r9d,%r12d+	xorl	%r9d,%r13d+	addl	28(%rsp),%eax+	pxor	%xmm6,%xmm7+	movl	%ebx,%edi+	xorl	%r11d,%r12d+	rorl	$11,%r14d+	pshufd	$8,%xmm7,%xmm7+	xorl	%ecx,%edi+	addl	%r12d,%eax+	movdqa	16(%rsi),%xmm6+	rorl	$6,%r13d+	andl	%edi,%r15d+	pslldq	$8,%xmm7+	xorl	%ebx,%r14d+	addl	%r13d,%eax+	xorl	%ecx,%r15d+	paddd	%xmm7,%xmm1+	rorl	$2,%r14d+	addl	%eax,%r8d+	addl	%r15d,%eax+	paddd	%xmm1,%xmm6+	movl	%r8d,%r13d+	addl	%eax,%r14d+	movdqa	%xmm6,16(%rsp)+	rorl	$14,%r13d+	movdqa	%xmm3,%xmm4+	movl	%r14d,%eax+	movl	%r9d,%r12d+	movdqa	%xmm1,%xmm7+	rorl	$9,%r14d+	xorl	%r8d,%r13d+	xorl	%r10d,%r12d+	rorl	$5,%r13d+	xorl	%eax,%r14d+.byte	102,15,58,15,226,4+	andl	%r8d,%r12d+	xorl	%r8d,%r13d+.byte	102,15,58,15,248,4+	addl	32(%rsp),%r11d+	movl	%eax,%r15d+	xorl	%r10d,%r12d+	rorl	$11,%r14d+	movdqa	%xmm4,%xmm5+	xorl	%ebx,%r15d+	addl	%r12d,%r11d+	movdqa	%xmm4,%xmm6+	rorl	$6,%r13d+	andl	%r15d,%edi+	psrld	$3,%xmm4+	xorl	%eax,%r14d+	addl	%r13d,%r11d+	xorl	%ebx,%edi+	paddd	%xmm7,%xmm2+	rorl	$2,%r14d+	addl	%r11d,%edx+	psrld	$7,%xmm6+	addl	%edi,%r11d+	movl	%edx,%r13d+	pshufd	$250,%xmm1,%xmm7+	addl	%r11d,%r14d+	rorl	$14,%r13d+	pslld	$14,%xmm5+	movl	%r14d,%r11d+	movl	%r8d,%r12d+	pxor	%xmm6,%xmm4+	rorl	$9,%r14d+	xorl	%edx,%r13d+	xorl	%r9d,%r12d+	rorl	$5,%r13d+	psrld	$11,%xmm6+	xorl	%r11d,%r14d+	pxor	%xmm5,%xmm4+	andl	%edx,%r12d+	xorl	%edx,%r13d+	pslld	$11,%xmm5+	addl	36(%rsp),%r10d+	movl	%r11d,%edi+	pxor	%xmm6,%xmm4+	xorl	%r9d,%r12d+	rorl	$11,%r14d+	movdqa	%xmm7,%xmm6+	xorl	%eax,%edi+	addl	%r12d,%r10d+	pxor	%xmm5,%xmm4+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%r11d,%r14d+	psrld	$10,%xmm7+	addl	%r13d,%r10d+	xorl	%eax,%r15d+	paddd	%xmm4,%xmm2+	rorl	$2,%r14d+	addl	%r10d,%ecx+	psrlq	$17,%xmm6+	addl	%r15d,%r10d+	movl	%ecx,%r13d+	addl	%r10d,%r14d+	pxor	%xmm6,%xmm7+	rorl	$14,%r13d+	movl	%r14d,%r10d+	movl	%edx,%r12d+	rorl	$9,%r14d+	psrlq	$2,%xmm6+	xorl	%ecx,%r13d+	xorl	%r8d,%r12d+	pxor	%xmm6,%xmm7+	rorl	$5,%r13d+	xorl	%r10d,%r14d+	andl	%ecx,%r12d+	pshufd	$128,%xmm7,%xmm7+	xorl	%ecx,%r13d+	addl	40(%rsp),%r9d+	movl	%r10d,%r15d+	psrldq	$8,%xmm7+	xorl	%r8d,%r12d+	rorl	$11,%r14d+	xorl	%r11d,%r15d+	addl	%r12d,%r9d+	rorl	$6,%r13d+	paddd	%xmm7,%xmm2+	andl	%r15d,%edi+	xorl	%r10d,%r14d+	addl	%r13d,%r9d+	pshufd	$80,%xmm2,%xmm7+	xorl	%r11d,%edi+	rorl	$2,%r14d+	addl	%r9d,%ebx+	movdqa	%xmm7,%xmm6+	addl	%edi,%r9d+	movl	%ebx,%r13d+	psrld	$10,%xmm7+	addl	%r9d,%r14d+	rorl	$14,%r13d+	psrlq	$17,%xmm6+	movl	%r14d,%r9d+	movl	%ecx,%r12d+	pxor	%xmm6,%xmm7+	rorl	$9,%r14d+	xorl	%ebx,%r13d+	xorl	%edx,%r12d+	rorl	$5,%r13d+	xorl	%r9d,%r14d+	psrlq	$2,%xmm6+	andl	%ebx,%r12d+	xorl	%ebx,%r13d+	addl	44(%rsp),%r8d+	pxor	%xmm6,%xmm7+	movl	%r9d,%edi+	xorl	%edx,%r12d+	rorl	$11,%r14d+	pshufd	$8,%xmm7,%xmm7+	xorl	%r10d,%edi+	addl	%r12d,%r8d+	movdqa	32(%rsi),%xmm6+	rorl	$6,%r13d+	andl	%edi,%r15d+	pslldq	$8,%xmm7+	xorl	%r9d,%r14d+	addl	%r13d,%r8d+	xorl	%r10d,%r15d+	paddd	%xmm7,%xmm2+	rorl	$2,%r14d+	addl	%r8d,%eax+	addl	%r15d,%r8d+	paddd	%xmm2,%xmm6+	movl	%eax,%r13d+	addl	%r8d,%r14d+	movdqa	%xmm6,32(%rsp)+	rorl	$14,%r13d+	movdqa	%xmm0,%xmm4+	movl	%r14d,%r8d+	movl	%ebx,%r12d+	movdqa	%xmm2,%xmm7+	rorl	$9,%r14d+	xorl	%eax,%r13d+	xorl	%ecx,%r12d+	rorl	$5,%r13d+	xorl	%r8d,%r14d+.byte	102,15,58,15,227,4+	andl	%eax,%r12d+	xorl	%eax,%r13d+.byte	102,15,58,15,249,4+	addl	48(%rsp),%edx+	movl	%r8d,%r15d+	xorl	%ecx,%r12d+	rorl	$11,%r14d+	movdqa	%xmm4,%xmm5+	xorl	%r9d,%r15d+	addl	%r12d,%edx+	movdqa	%xmm4,%xmm6+	rorl	$6,%r13d+	andl	%r15d,%edi+	psrld	$3,%xmm4+	xorl	%r8d,%r14d+	addl	%r13d,%edx+	xorl	%r9d,%edi+	paddd	%xmm7,%xmm3+	rorl	$2,%r14d+	addl	%edx,%r11d+	psrld	$7,%xmm6+	addl	%edi,%edx+	movl	%r11d,%r13d+	pshufd	$250,%xmm2,%xmm7+	addl	%edx,%r14d+	rorl	$14,%r13d+	pslld	$14,%xmm5+	movl	%r14d,%edx+	movl	%eax,%r12d+	pxor	%xmm6,%xmm4+	rorl	$9,%r14d+	xorl	%r11d,%r13d+	xorl	%ebx,%r12d+	rorl	$5,%r13d+	psrld	$11,%xmm6+	xorl	%edx,%r14d+	pxor	%xmm5,%xmm4+	andl	%r11d,%r12d+	xorl	%r11d,%r13d+	pslld	$11,%xmm5+	addl	52(%rsp),%ecx+	movl	%edx,%edi+	pxor	%xmm6,%xmm4+	xorl	%ebx,%r12d+	rorl	$11,%r14d+	movdqa	%xmm7,%xmm6+	xorl	%r8d,%edi+	addl	%r12d,%ecx+	pxor	%xmm5,%xmm4+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%edx,%r14d+	psrld	$10,%xmm7+	addl	%r13d,%ecx+	xorl	%r8d,%r15d+	paddd	%xmm4,%xmm3+	rorl	$2,%r14d+	addl	%ecx,%r10d+	psrlq	$17,%xmm6+	addl	%r15d,%ecx+	movl	%r10d,%r13d+	addl	%ecx,%r14d+	pxor	%xmm6,%xmm7+	rorl	$14,%r13d+	movl	%r14d,%ecx+	movl	%r11d,%r12d+	rorl	$9,%r14d+	psrlq	$2,%xmm6+	xorl	%r10d,%r13d+	xorl	%eax,%r12d+	pxor	%xmm6,%xmm7+	rorl	$5,%r13d+	xorl	%ecx,%r14d+	andl	%r10d,%r12d+	pshufd	$128,%xmm7,%xmm7+	xorl	%r10d,%r13d+	addl	56(%rsp),%ebx+	movl	%ecx,%r15d+	psrldq	$8,%xmm7+	xorl	%eax,%r12d+	rorl	$11,%r14d+	xorl	%edx,%r15d+	addl	%r12d,%ebx+	rorl	$6,%r13d+	paddd	%xmm7,%xmm3+	andl	%r15d,%edi+	xorl	%ecx,%r14d+	addl	%r13d,%ebx+	pshufd	$80,%xmm3,%xmm7+	xorl	%edx,%edi+	rorl	$2,%r14d+	addl	%ebx,%r9d+	movdqa	%xmm7,%xmm6+	addl	%edi,%ebx+	movl	%r9d,%r13d+	psrld	$10,%xmm7+	addl	%ebx,%r14d+	rorl	$14,%r13d+	psrlq	$17,%xmm6+	movl	%r14d,%ebx+	movl	%r10d,%r12d+	pxor	%xmm6,%xmm7+	rorl	$9,%r14d+	xorl	%r9d,%r13d+	xorl	%r11d,%r12d+	rorl	$5,%r13d+	xorl	%ebx,%r14d+	psrlq	$2,%xmm6+	andl	%r9d,%r12d+	xorl	%r9d,%r13d+	addl	60(%rsp),%eax+	pxor	%xmm6,%xmm7+	movl	%ebx,%edi+	xorl	%r11d,%r12d+	rorl	$11,%r14d+	pshufd	$8,%xmm7,%xmm7+	xorl	%ecx,%edi+	addl	%r12d,%eax+	movdqa	48(%rsi),%xmm6+	rorl	$6,%r13d+	andl	%edi,%r15d+	pslldq	$8,%xmm7+	xorl	%ebx,%r14d+	addl	%r13d,%eax+	xorl	%ecx,%r15d+	paddd	%xmm7,%xmm3+	rorl	$2,%r14d+	addl	%eax,%r8d+	addl	%r15d,%eax+	paddd	%xmm3,%xmm6+	movl	%r8d,%r13d+	addl	%eax,%r14d+	movdqa	%xmm6,48(%rsp)+	cmpb	$0,67(%rsi)+	jne	.Lssse3_00_47+	rorl	$14,%r13d+	movl	%r14d,%eax+	movl	%r9d,%r12d+	rorl	$9,%r14d+	xorl	%r8d,%r13d+	xorl	%r10d,%r12d+	rorl	$5,%r13d+	xorl	%eax,%r14d+	andl	%r8d,%r12d+	xorl	%r8d,%r13d+	addl	0(%rsp),%r11d+	movl	%eax,%r15d+	xorl	%r10d,%r12d+	rorl	$11,%r14d+	xorl	%ebx,%r15d+	addl	%r12d,%r11d+	rorl	$6,%r13d+	andl	%r15d,%edi+	xorl	%eax,%r14d+	addl	%r13d,%r11d+	xorl	%ebx,%edi+	rorl	$2,%r14d+	addl	%r11d,%edx+	addl	%edi,%r11d+	movl	%edx,%r13d+	addl	%r11d,%r14d+	rorl	$14,%r13d+	movl	%r14d,%r11d+	movl	%r8d,%r12d+	rorl	$9,%r14d+	xorl	%edx,%r13d+	xorl	%r9d,%r12d+	rorl	$5,%r13d+	xorl	%r11d,%r14d+	andl	%edx,%r12d+	xorl	%edx,%r13d+	addl	4(%rsp),%r10d+	movl	%r11d,%edi+	xorl	%r9d,%r12d+	rorl	$11,%r14d+	xorl	%eax,%edi+	addl	%r12d,%r10d+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%r11d,%r14d+	addl	%r13d,%r10d+	xorl	%eax,%r15d+	rorl	$2,%r14d+	addl	%r10d,%ecx+	addl	%r15d,%r10d+	movl	%ecx,%r13d+	addl	%r10d,%r14d+	rorl	$14,%r13d+	movl	%r14d,%r10d+	movl	%edx,%r12d+	rorl	$9,%r14d+	xorl	%ecx,%r13d+	xorl	%r8d,%r12d+	rorl	$5,%r13d+	xorl	%r10d,%r14d+	andl	%ecx,%r12d+	xorl	%ecx,%r13d+	addl	8(%rsp),%r9d+	movl	%r10d,%r15d+	xorl	%r8d,%r12d+	rorl	$11,%r14d+	xorl	%r11d,%r15d+	addl	%r12d,%r9d+	rorl	$6,%r13d+	andl	%r15d,%edi+	xorl	%r10d,%r14d+	addl	%r13d,%r9d+	xorl	%r11d,%edi+	rorl	$2,%r14d+	addl	%r9d,%ebx+	addl	%edi,%r9d+	movl	%ebx,%r13d+	addl	%r9d,%r14d+	rorl	$14,%r13d+	movl	%r14d,%r9d+	movl	%ecx,%r12d+	rorl	$9,%r14d+	xorl	%ebx,%r13d+	xorl	%edx,%r12d+	rorl	$5,%r13d+	xorl	%r9d,%r14d+	andl	%ebx,%r12d+	xorl	%ebx,%r13d+	addl	12(%rsp),%r8d+	movl	%r9d,%edi+	xorl	%edx,%r12d+	rorl	$11,%r14d+	xorl	%r10d,%edi+	addl	%r12d,%r8d+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%r9d,%r14d+	addl	%r13d,%r8d+	xorl	%r10d,%r15d+	rorl	$2,%r14d+	addl	%r8d,%eax+	addl	%r15d,%r8d+	movl	%eax,%r13d+	addl	%r8d,%r14d+	rorl	$14,%r13d+	movl	%r14d,%r8d+	movl	%ebx,%r12d+	rorl	$9,%r14d+	xorl	%eax,%r13d+	xorl	%ecx,%r12d+	rorl	$5,%r13d+	xorl	%r8d,%r14d+	andl	%eax,%r12d+	xorl	%eax,%r13d+	addl	16(%rsp),%edx+	movl	%r8d,%r15d+	xorl	%ecx,%r12d+	rorl	$11,%r14d+	xorl	%r9d,%r15d+	addl	%r12d,%edx+	rorl	$6,%r13d+	andl	%r15d,%edi+	xorl	%r8d,%r14d+	addl	%r13d,%edx+	xorl	%r9d,%edi+	rorl	$2,%r14d+	addl	%edx,%r11d+	addl	%edi,%edx+	movl	%r11d,%r13d+	addl	%edx,%r14d+	rorl	$14,%r13d+	movl	%r14d,%edx+	movl	%eax,%r12d+	rorl	$9,%r14d+	xorl	%r11d,%r13d+	xorl	%ebx,%r12d+	rorl	$5,%r13d+	xorl	%edx,%r14d+	andl	%r11d,%r12d+	xorl	%r11d,%r13d+	addl	20(%rsp),%ecx+	movl	%edx,%edi+	xorl	%ebx,%r12d+	rorl	$11,%r14d+	xorl	%r8d,%edi+	addl	%r12d,%ecx+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%edx,%r14d+	addl	%r13d,%ecx+	xorl	%r8d,%r15d+	rorl	$2,%r14d+	addl	%ecx,%r10d+	addl	%r15d,%ecx+	movl	%r10d,%r13d+	addl	%ecx,%r14d+	rorl	$14,%r13d+	movl	%r14d,%ecx+	movl	%r11d,%r12d+	rorl	$9,%r14d+	xorl	%r10d,%r13d+	xorl	%eax,%r12d+	rorl	$5,%r13d+	xorl	%ecx,%r14d+	andl	%r10d,%r12d+	xorl	%r10d,%r13d+	addl	24(%rsp),%ebx+	movl	%ecx,%r15d+	xorl	%eax,%r12d+	rorl	$11,%r14d+	xorl	%edx,%r15d+	addl	%r12d,%ebx+	rorl	$6,%r13d+	andl	%r15d,%edi+	xorl	%ecx,%r14d+	addl	%r13d,%ebx+	xorl	%edx,%edi+	rorl	$2,%r14d+	addl	%ebx,%r9d+	addl	%edi,%ebx+	movl	%r9d,%r13d+	addl	%ebx,%r14d+	rorl	$14,%r13d+	movl	%r14d,%ebx+	movl	%r10d,%r12d+	rorl	$9,%r14d+	xorl	%r9d,%r13d+	xorl	%r11d,%r12d+	rorl	$5,%r13d+	xorl	%ebx,%r14d+	andl	%r9d,%r12d+	xorl	%r9d,%r13d+	addl	28(%rsp),%eax+	movl	%ebx,%edi+	xorl	%r11d,%r12d+	rorl	$11,%r14d+	xorl	%ecx,%edi+	addl	%r12d,%eax+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%ebx,%r14d+	addl	%r13d,%eax+	xorl	%ecx,%r15d+	rorl	$2,%r14d+	addl	%eax,%r8d+	addl	%r15d,%eax+	movl	%r8d,%r13d+	addl	%eax,%r14d+	rorl	$14,%r13d+	movl	%r14d,%eax+	movl	%r9d,%r12d+	rorl	$9,%r14d+	xorl	%r8d,%r13d+	xorl	%r10d,%r12d+	rorl	$5,%r13d+	xorl	%eax,%r14d+	andl	%r8d,%r12d+	xorl	%r8d,%r13d+	addl	32(%rsp),%r11d+	movl	%eax,%r15d+	xorl	%r10d,%r12d+	rorl	$11,%r14d+	xorl	%ebx,%r15d+	addl	%r12d,%r11d+	rorl	$6,%r13d+	andl	%r15d,%edi+	xorl	%eax,%r14d+	addl	%r13d,%r11d+	xorl	%ebx,%edi+	rorl	$2,%r14d+	addl	%r11d,%edx+	addl	%edi,%r11d+	movl	%edx,%r13d+	addl	%r11d,%r14d+	rorl	$14,%r13d+	movl	%r14d,%r11d+	movl	%r8d,%r12d+	rorl	$9,%r14d+	xorl	%edx,%r13d+	xorl	%r9d,%r12d+	rorl	$5,%r13d+	xorl	%r11d,%r14d+	andl	%edx,%r12d+	xorl	%edx,%r13d+	addl	36(%rsp),%r10d+	movl	%r11d,%edi+	xorl	%r9d,%r12d+	rorl	$11,%r14d+	xorl	%eax,%edi+	addl	%r12d,%r10d+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%r11d,%r14d+	addl	%r13d,%r10d+	xorl	%eax,%r15d+	rorl	$2,%r14d+	addl	%r10d,%ecx+	addl	%r15d,%r10d+	movl	%ecx,%r13d+	addl	%r10d,%r14d+	rorl	$14,%r13d+	movl	%r14d,%r10d+	movl	%edx,%r12d+	rorl	$9,%r14d+	xorl	%ecx,%r13d+	xorl	%r8d,%r12d+	rorl	$5,%r13d+	xorl	%r10d,%r14d+	andl	%ecx,%r12d+	xorl	%ecx,%r13d+	addl	40(%rsp),%r9d+	movl	%r10d,%r15d+	xorl	%r8d,%r12d+	rorl	$11,%r14d+	xorl	%r11d,%r15d+	addl	%r12d,%r9d+	rorl	$6,%r13d+	andl	%r15d,%edi+	xorl	%r10d,%r14d+	addl	%r13d,%r9d+	xorl	%r11d,%edi+	rorl	$2,%r14d+	addl	%r9d,%ebx+	addl	%edi,%r9d+	movl	%ebx,%r13d+	addl	%r9d,%r14d+	rorl	$14,%r13d+	movl	%r14d,%r9d+	movl	%ecx,%r12d+	rorl	$9,%r14d+	xorl	%ebx,%r13d+	xorl	%edx,%r12d+	rorl	$5,%r13d+	xorl	%r9d,%r14d+	andl	%ebx,%r12d+	xorl	%ebx,%r13d+	addl	44(%rsp),%r8d+	movl	%r9d,%edi+	xorl	%edx,%r12d+	rorl	$11,%r14d+	xorl	%r10d,%edi+	addl	%r12d,%r8d+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%r9d,%r14d+	addl	%r13d,%r8d+	xorl	%r10d,%r15d+	rorl	$2,%r14d+	addl	%r8d,%eax+	addl	%r15d,%r8d+	movl	%eax,%r13d+	addl	%r8d,%r14d+	rorl	$14,%r13d+	movl	%r14d,%r8d+	movl	%ebx,%r12d+	rorl	$9,%r14d+	xorl	%eax,%r13d+	xorl	%ecx,%r12d+	rorl	$5,%r13d+	xorl	%r8d,%r14d+	andl	%eax,%r12d+	xorl	%eax,%r13d+	addl	48(%rsp),%edx+	movl	%r8d,%r15d+	xorl	%ecx,%r12d+	rorl	$11,%r14d+	xorl	%r9d,%r15d+	addl	%r12d,%edx+	rorl	$6,%r13d+	andl	%r15d,%edi+	xorl	%r8d,%r14d+	addl	%r13d,%edx+	xorl	%r9d,%edi+	rorl	$2,%r14d+	addl	%edx,%r11d+	addl	%edi,%edx+	movl	%r11d,%r13d+	addl	%edx,%r14d+	rorl	$14,%r13d+	movl	%r14d,%edx+	movl	%eax,%r12d+	rorl	$9,%r14d+	xorl	%r11d,%r13d+	xorl	%ebx,%r12d+	rorl	$5,%r13d+	xorl	%edx,%r14d+	andl	%r11d,%r12d+	xorl	%r11d,%r13d+	addl	52(%rsp),%ecx+	movl	%edx,%edi+	xorl	%ebx,%r12d+	rorl	$11,%r14d+	xorl	%r8d,%edi+	addl	%r12d,%ecx+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%edx,%r14d+	addl	%r13d,%ecx+	xorl	%r8d,%r15d+	rorl	$2,%r14d+	addl	%ecx,%r10d+	addl	%r15d,%ecx+	movl	%r10d,%r13d+	addl	%ecx,%r14d+	rorl	$14,%r13d+	movl	%r14d,%ecx+	movl	%r11d,%r12d+	rorl	$9,%r14d+	xorl	%r10d,%r13d+	xorl	%eax,%r12d+	rorl	$5,%r13d+	xorl	%ecx,%r14d+	andl	%r10d,%r12d+	xorl	%r10d,%r13d+	addl	56(%rsp),%ebx+	movl	%ecx,%r15d+	xorl	%eax,%r12d+	rorl	$11,%r14d+	xorl	%edx,%r15d+	addl	%r12d,%ebx+	rorl	$6,%r13d+	andl	%r15d,%edi+	xorl	%ecx,%r14d+	addl	%r13d,%ebx+	xorl	%edx,%edi+	rorl	$2,%r14d+	addl	%ebx,%r9d+	addl	%edi,%ebx+	movl	%r9d,%r13d+	addl	%ebx,%r14d+	rorl	$14,%r13d+	movl	%r14d,%ebx+	movl	%r10d,%r12d+	rorl	$9,%r14d+	xorl	%r9d,%r13d+	xorl	%r11d,%r12d+	rorl	$5,%r13d+	xorl	%ebx,%r14d+	andl	%r9d,%r12d+	xorl	%r9d,%r13d+	addl	60(%rsp),%eax+	movl	%ebx,%edi+	xorl	%r11d,%r12d+	rorl	$11,%r14d+	xorl	%ecx,%edi+	addl	%r12d,%eax+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%ebx,%r14d+	addl	%r13d,%eax+	xorl	%ecx,%r15d+	rorl	$2,%r14d+	addl	%eax,%r8d+	addl	%r15d,%eax+	movl	%r8d,%r13d+	addl	%eax,%r14d+	movq	0(%rbp),%rdi+	movl	%r14d,%eax+	movq	8(%rbp),%rsi++	addl	0(%rdi),%eax+	addl	4(%rdi),%ebx+	addl	8(%rdi),%ecx+	addl	12(%rdi),%edx+	addl	16(%rdi),%r8d+	addl	20(%rdi),%r9d+	addl	24(%rdi),%r10d+	addl	28(%rdi),%r11d++	leaq	64(%rsi),%rsi+	cmpq	16(%rbp),%rsi++	movl	%eax,0(%rdi)+	movl	%ebx,4(%rdi)+	movl	%ecx,8(%rdi)+	movl	%edx,12(%rdi)+	movl	%r8d,16(%rdi)+	movl	%r9d,20(%rdi)+	movl	%r10d,24(%rdi)+	movl	%r11d,28(%rdi)+	jb	.Lloop_ssse3++	xorps	%xmm0,%xmm0+	leaq	104+48(%rbp),%r11++	movaps	%xmm0,0(%rsp)+	movaps	%xmm0,16(%rsp)+	movaps	%xmm0,32(%rsp)+	movaps	%xmm0,48(%rsp)+	movaps	32(%rbp),%xmm6+	movaps	48(%rbp),%xmm7+	movaps	64(%rbp),%xmm8+	movaps	80(%rbp),%xmm9+	movq	104(%rbp),%r15++	movq	-40(%r11),%r14++	movq	-32(%r11),%r13++	movq	-24(%r11),%r12++	movq	-16(%r11),%rbx++	movq	-8(%r11),%rbp++.LSEH_epilogue_blst_sha256_block_data_order:+	mov	8(%r11),%rdi+	mov	16(%r11),%rsi++	leaq	(%r11),%rsp+	.byte	0xf3,0xc3++.LSEH_end_blst_sha256_block_data_order:+.globl	blst_sha256_emit++.def	blst_sha256_emit;	.scl 2;	.type 32;	.endef+.p2align	4+blst_sha256_emit:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rdx),%r8+	movq	8(%rdx),%r9+	movq	16(%rdx),%r10+	bswapq	%r8+	movq	24(%rdx),%r11+	bswapq	%r9+	movl	%r8d,4(%rcx)+	bswapq	%r10+	movl	%r9d,12(%rcx)+	bswapq	%r11+	movl	%r10d,20(%rcx)+	shrq	$32,%r8+	movl	%r11d,28(%rcx)+	shrq	$32,%r9+	movl	%r8d,0(%rcx)+	shrq	$32,%r10+	movl	%r9d,8(%rcx)+	shrq	$32,%r11+	movl	%r10d,16(%rcx)+	movl	%r11d,24(%rcx)+	.byte	0xf3,0xc3+++.globl	blst_sha256_bcopy++.def	blst_sha256_bcopy;	.scl 2;	.type 32;	.endef+.p2align	4+blst_sha256_bcopy:+	.byte	0xf3,0x0f,0x1e,0xfa++	subq	%rdx,%rcx+.Loop_bcopy:+	movzbl	(%rdx),%eax+	leaq	1(%rdx),%rdx+	movb	%al,-1(%rcx,%rdx,1)+	decq	%r8+	jnz	.Loop_bcopy+	.byte	0xf3,0xc3+++.globl	blst_sha256_hcopy++.def	blst_sha256_hcopy;	.scl 2;	.type 32;	.endef+.p2align	4+blst_sha256_hcopy:+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rdx),%r8+	movq	8(%rdx),%r9+	movq	16(%rdx),%r10+	movq	24(%rdx),%r11+	movq	%r8,0(%rcx)+	movq	%r9,8(%rcx)+	movq	%r10,16(%rcx)+	movq	%r11,24(%rcx)+	.byte	0xf3,0xc3++.section	.pdata+.p2align	2+.rva	.LSEH_begin_blst_sha256_block_data_order_shaext+.rva	.LSEH_body_blst_sha256_block_data_order_shaext+.rva	.LSEH_info_blst_sha256_block_data_order_shaext_prologue++.rva	.LSEH_body_blst_sha256_block_data_order_shaext+.rva	.LSEH_epilogue_blst_sha256_block_data_order_shaext+.rva	.LSEH_info_blst_sha256_block_data_order_shaext_body++.rva	.LSEH_epilogue_blst_sha256_block_data_order_shaext+.rva	.LSEH_end_blst_sha256_block_data_order_shaext+.rva	.LSEH_info_blst_sha256_block_data_order_shaext_epilogue++.rva	.LSEH_begin_blst_sha256_block_data_order+.rva	.LSEH_body_blst_sha256_block_data_order+.rva	.LSEH_info_blst_sha256_block_data_order_prologue++.rva	.LSEH_body_blst_sha256_block_data_order+.rva	.LSEH_epilogue_blst_sha256_block_data_order+.rva	.LSEH_info_blst_sha256_block_data_order_body++.rva	.LSEH_epilogue_blst_sha256_block_data_order+.rva	.LSEH_end_blst_sha256_block_data_order+.rva	.LSEH_info_blst_sha256_block_data_order_epilogue++.section	.xdata+.p2align	3+.LSEH_info_blst_sha256_block_data_order_shaext_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_blst_sha256_block_data_order_shaext_body:+.byte	1,0,15,0+.byte	0x00,0x68,0x00,0x00+.byte	0x00,0x78,0x01,0x00+.byte	0x00,0x88,0x02,0x00+.byte	0x00,0x98,0x03,0x00+.byte	0x00,0xa8,0x04,0x00+.byte	0x00,0x74,0x0c,0x00+.byte	0x00,0x64,0x0d,0x00+.byte	0x00,0xa2+.byte	0x00,0x00,0x00,0x00,0x00,0x00+.LSEH_info_blst_sha256_block_data_order_shaext_epilogue:+.byte	1,0,5,11+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x03+.byte	0x00,0x00++.LSEH_info_blst_sha256_block_data_order_prologue:+.byte	1,0,5,0x0b+.byte	0,0x74,1,0+.byte	0,0x64,2,0+.byte	0,0x03+.byte	0,0+.LSEH_info_blst_sha256_block_data_order_body:+.byte	1,0,26,5+.byte	0x00,0x68,0x02,0x00+.byte	0x00,0x78,0x03,0x00+.byte	0x00,0x88,0x04,0x00+.byte	0x00,0x98,0x05,0x00+.byte	0x00,0xf4,0x0d,0x00+.byte	0x00,0xe4,0x0e,0x00+.byte	0x00,0xd4,0x0f,0x00+.byte	0x00,0xc4,0x10,0x00+.byte	0x00,0x34,0x11,0x00+.byte	0x00,0x74,0x14,0x00+.byte	0x00,0x64,0x15,0x00+.byte	0x00,0x03+.byte	0x00,0x01,0x12,0x00+.byte	0x00,0x50+.LSEH_info_blst_sha256_block_data_order_epilogue:+.byte	1,0,5,11+.byte	0x00,0x74,0x01,0x00+.byte	0x00,0x64,0x02,0x00+.byte	0x00,0x03+.byte	0x00,0x00+
+ c-source/build/elf/add_mod_256-armv8.S view
@@ -0,0 +1,379 @@+.text++.globl	add_mod_256+.hidden	add_mod_256+.type	add_mod_256,%function+.align	5+add_mod_256:+	ldp	x8,x9,[x1]+	ldp	x12,x13,[x2]++	ldp	x10,x11,[x1,#16]+	adds	x8,x8,x12+	ldp	x14,x15,[x2,#16]+	adcs	x9,x9,x13+	ldp	x4,x5,[x3]+	adcs	x10,x10,x14+	ldp	x6,x7,[x3,#16]+	adcs	x11,x11,x15+	adc	x3,xzr,xzr++	subs	x16,x8,x4+	sbcs	x17,x9,x5+	sbcs	x1,x10,x6+	sbcs	x2,x11,x7+	sbcs	xzr,x3,xzr++	csel	x8,x8,x16,lo+	csel	x9,x9,x17,lo+	csel	x10,x10,x1,lo+	stp	x8,x9,[x0]+	csel	x11,x11,x2,lo+	stp	x10,x11,[x0,#16]++	ret+.size	add_mod_256,.-add_mod_256++.globl	mul_by_3_mod_256+.hidden	mul_by_3_mod_256+.type	mul_by_3_mod_256,%function+.align	5+mul_by_3_mod_256:+	ldp	x12,x13,[x1]+	ldp	x14,x15,[x1,#16]++	adds	x8,x12,x12+	ldp	x4,x5,[x2]+	adcs	x9,x13,x13+	ldp	x6,x7,[x2,#16]+	adcs	x10,x14,x14+	adcs	x11,x15,x15+	adc	x3,xzr,xzr++	subs	x16,x8,x4+	sbcs	x17,x9,x5+	sbcs	x1,x10,x6+	sbcs	x2,x11,x7+	sbcs	xzr,x3,xzr++	csel	x8,x8,x16,lo+	csel	x9,x9,x17,lo+	csel	x10,x10,x1,lo+	csel	x11,x11,x2,lo++	adds	x8,x8,x12+	adcs	x9,x9,x13+	adcs	x10,x10,x14+	adcs	x11,x11,x15+	adc	x3,xzr,xzr++	subs	x16,x8,x4+	sbcs	x17,x9,x5+	sbcs	x1,x10,x6+	sbcs	x2,x11,x7+	sbcs	xzr,x3,xzr++	csel	x8,x8,x16,lo+	csel	x9,x9,x17,lo+	csel	x10,x10,x1,lo+	stp	x8,x9,[x0]+	csel	x11,x11,x2,lo+	stp	x10,x11,[x0,#16]++	ret+.size	mul_by_3_mod_256,.-mul_by_3_mod_256++.globl	lshift_mod_256+.hidden	lshift_mod_256+.type	lshift_mod_256,%function+.align	5+lshift_mod_256:+	ldp	x8,x9,[x1]+	ldp	x10,x11,[x1,#16]++	ldp	x4,x5,[x3]+	ldp	x6,x7,[x3,#16]++.Loop_lshift_mod_256:+	adds	x8,x8,x8+	sub	x2,x2,#1+	adcs	x9,x9,x9+	adcs	x10,x10,x10+	adcs	x11,x11,x11+	adc	x3,xzr,xzr++	subs	x12,x8,x4+	sbcs	x13,x9,x5+	sbcs	x14,x10,x6+	sbcs	x15,x11,x7+	sbcs	xzr,x3,xzr++	csel	x8,x8,x12,lo+	csel	x9,x9,x13,lo+	csel	x10,x10,x14,lo+	csel	x11,x11,x15,lo++	cbnz	x2,.Loop_lshift_mod_256++	stp	x8,x9,[x0]+	stp	x10,x11,[x0,#16]++	ret+.size	lshift_mod_256,.-lshift_mod_256++.globl	rshift_mod_256+.hidden	rshift_mod_256+.type	rshift_mod_256,%function+.align	5+rshift_mod_256:+	ldp	x8,x9,[x1]+	ldp	x10,x11,[x1,#16]++	ldp	x4,x5,[x3]+	ldp	x6,x7,[x3,#16]++.Loop_rshift:+	adds	x12,x8,x4+	sub	x2,x2,#1+	adcs	x13,x9,x5+	adcs	x14,x10,x6+	adcs	x15,x11,x7+	adc	x3,xzr,xzr+	tst	x8,#1++	csel	x12,x12,x8,ne+	csel	x13,x13,x9,ne+	csel	x14,x14,x10,ne+	csel	x15,x15,x11,ne+	csel	x3,x3,xzr,ne++	extr	x8,x13,x12,#1+	extr	x9,x14,x13,#1+	extr	x10,x15,x14,#1+	extr	x11,x3,x15,#1++	cbnz	x2,.Loop_rshift++	stp	x8,x9,[x0]+	stp	x10,x11,[x0,#16]++	ret+.size	rshift_mod_256,.-rshift_mod_256++.globl	cneg_mod_256+.hidden	cneg_mod_256+.type	cneg_mod_256,%function+.align	5+cneg_mod_256:+	ldp	x8,x9,[x1]+	ldp	x4,x5,[x3]++	ldp	x10,x11,[x1,#16]+	subs	x12,x4,x8+	ldp	x6,x7,[x3,#16]+	orr	x4,x8,x9+	sbcs	x13,x5,x9+	orr	x5,x10,x11+	sbcs	x14,x6,x10+	orr	x3,x4,x5+	sbc	x15,x7,x11++	cmp	x3,#0+	csetm	x3,ne+	ands	x2,x2,x3++	csel	x8,x8,x12,eq+	csel	x9,x9,x13,eq+	csel	x10,x10,x14,eq+	stp	x8,x9,[x0]+	csel	x11,x11,x15,eq+	stp	x10,x11,[x0,#16]++	ret+.size	cneg_mod_256,.-cneg_mod_256++.globl	sub_mod_256+.hidden	sub_mod_256+.type	sub_mod_256,%function+.align	5+sub_mod_256:+	ldp	x8,x9,[x1]+	ldp	x12,x13,[x2]++	ldp	x10,x11,[x1,#16]+	subs	x8,x8,x12+	ldp	x14,x15,[x2,#16]+	sbcs	x9,x9,x13+	ldp	x4,x5,[x3]+	sbcs	x10,x10,x14+	ldp	x6,x7,[x3,#16]+	sbcs	x11,x11,x15+	sbc	x3,xzr,xzr++	and	x4,x4,x3+	and	x5,x5,x3+	adds	x8,x8,x4+	and	x6,x6,x3+	adcs	x9,x9,x5+	and	x7,x7,x3+	adcs	x10,x10,x6+	stp	x8,x9,[x0]+	adc	x11,x11,x7+	stp	x10,x11,[x0,#16]++	ret+.size	sub_mod_256,.-sub_mod_256++.globl	check_mod_256+.hidden	check_mod_256+.type	check_mod_256,%function+.align	5+check_mod_256:+	ldp	x8,x9,[x0]+	ldp	x10,x11,[x0,#16]+	ldp	x4,x5,[x1]+	ldp	x6,x7,[x1,#16]++#ifdef	__AARCH64EB__+	rev	x8,x8+	rev	x9,x9+	rev	x10,x10+	rev	x11,x11+#endif++	subs	xzr,x8,x4+	sbcs	xzr,x9,x5+	orr	x8,x8,x9+	sbcs	xzr,x10,x6+	orr	x8,x8,x10+	sbcs	xzr,x11,x7+	orr	x8,x8,x11+	sbc	x1,xzr,xzr++	cmp	x8,#0+	mov	x0,#1+	csel	x0,x0,xzr,ne+	and	x0,x0,x1++	ret+.size	check_mod_256,.-check_mod_256++.globl	add_n_check_mod_256+.hidden	add_n_check_mod_256+.type	add_n_check_mod_256,%function+.align	5+add_n_check_mod_256:+	ldp	x8,x9,[x1]+	ldp	x12,x13,[x2]+	ldp	x10,x11,[x1,#16]+	ldp	x14,x15,[x2,#16]++#ifdef	__AARCH64EB__+	rev	x8,x8+	rev	x12,x12+	rev	x9,x9+	rev	x13,x13+	rev	x10,x10+	rev	x14,x14+	rev	x11,x11+	rev	x15,x15+#endif++	adds	x8,x8,x12+	ldp	x4,x5,[x3]+	adcs	x9,x9,x13+	ldp	x6,x7,[x3,#16]+	adcs	x10,x10,x14+	adcs	x11,x11,x15+	adc	x3,xzr,xzr++	subs	x16,x8,x4+	sbcs	x17,x9,x5+	sbcs	x1,x10,x6+	sbcs	x2,x11,x7+	sbcs	xzr,x3,xzr++	csel	x8,x8,x16,lo+	csel	x9,x9,x17,lo+	csel	x10,x10,x1,lo+	csel	x11,x11,x2,lo++	orr	x16, x8, x9+	orr	x17, x10, x11+	orr	x16, x16, x17++#ifdef	__AARCH64EB__+	rev	x8,x8+	rev	x9,x9+	rev	x10,x10+	rev	x11,x11+#endif++	stp	x8,x9,[x0]+	stp	x10,x11,[x0,#16]++	mov	x17, #1+	cmp	x16, #0+	csel	x0, x17, xzr, ne++	ret+.size	add_n_check_mod_256,.-add_n_check_mod_256++.globl	sub_n_check_mod_256+.hidden	sub_n_check_mod_256+.type	sub_n_check_mod_256,%function+.align	5+sub_n_check_mod_256:+	ldp	x8,x9,[x1]+	ldp	x12,x13,[x2]+	ldp	x10,x11,[x1,#16]+	ldp	x14,x15,[x2,#16]++#ifdef	__AARCH64EB__+	rev	x8,x8+	rev	x12,x12+	rev	x9,x9+	rev	x13,x13+	rev	x10,x10+	rev	x14,x14+	rev	x11,x11+	rev	x15,x15+#endif++	subs	x8,x8,x12+	sbcs	x9,x9,x13+	ldp	x4,x5,[x3]+	sbcs	x10,x10,x14+	ldp	x6,x7,[x3,#16]+	sbcs	x11,x11,x15+	sbc	x3,xzr,xzr++	and	x4,x4,x3+	and	x5,x5,x3+	adds	x8,x8,x4+	and	x6,x6,x3+	adcs	x9,x9,x5+	and	x7,x7,x3+	adcs	x10,x10,x6+	adc	x11,x11,x7++	orr	x16, x8, x9+	orr	x17, x10, x11+	orr	x16, x16, x17++#ifdef	__AARCH64EB__+	rev	x8,x8+	rev	x9,x9+	rev	x10,x10+	rev	x11,x11+#endif++	stp	x8,x9,[x0]+	stp	x10,x11,[x0,#16]++	mov	x17, #1+	cmp	x16, #0+	csel	x0, x17, xzr, ne++	ret+.size	sub_n_check_mod_256,.-sub_n_check_mod_256
+ c-source/build/elf/add_mod_256-x86_64.s view
@@ -0,0 +1,572 @@+.text	++.globl	add_mod_256+.hidden	add_mod_256+.type	add_mod_256,@function+.align	32+add_mod_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11++.Loaded_a_add_mod_256:+	addq	0(%rdx),%r8+	adcq	8(%rdx),%r9+	movq	%r8,%rax+	adcq	16(%rdx),%r10+	movq	%r9,%rsi+	adcq	24(%rdx),%r11+	sbbq	%rdx,%rdx++	movq	%r10,%rbx+	subq	0(%rcx),%r8+	sbbq	8(%rcx),%r9+	sbbq	16(%rcx),%r10+	movq	%r11,%rbp+	sbbq	24(%rcx),%r11+	sbbq	$0,%rdx++	cmovcq	%rax,%r8+	cmovcq	%rsi,%r9+	movq	%r8,0(%rdi)+	cmovcq	%rbx,%r10+	movq	%r9,8(%rdi)+	cmovcq	%rbp,%r11+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)++	movq	8(%rsp),%rbx+.cfi_restore	%rbx+	movq	16(%rsp),%rbp+.cfi_restore	%rbp+	leaq	24(%rsp),%rsp+.cfi_adjust_cfa_offset	-24++	.byte	0xf3,0xc3+.cfi_endproc	+.size	add_mod_256,.-add_mod_256+++.globl	mul_by_3_mod_256+.hidden	mul_by_3_mod_256+.type	mul_by_3_mod_256,@function+.align	32+mul_by_3_mod_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+++	movq	%rdx,%rcx+	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	%rsi,%rdx+	movq	24(%rsi),%r11++	call	__lshift_mod_256+	movq	0(%rsp),%r12+.cfi_restore	%r12+	jmp	.Loaded_a_add_mod_256++	movq	8(%rsp),%rbx+.cfi_restore	%rbx+	movq	16(%rsp),%rbp+.cfi_restore	%rbp+	leaq	24(%rsp),%rsp+.cfi_adjust_cfa_offset	-24++	.byte	0xf3,0xc3+.cfi_endproc	+.size	mul_by_3_mod_256,.-mul_by_3_mod_256++.type	__lshift_mod_256,@function+.align	32+__lshift_mod_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	addq	%r8,%r8+	adcq	%r9,%r9+	movq	%r8,%rax+	adcq	%r10,%r10+	movq	%r9,%rsi+	adcq	%r11,%r11+	sbbq	%r12,%r12++	movq	%r10,%rbx+	subq	0(%rcx),%r8+	sbbq	8(%rcx),%r9+	sbbq	16(%rcx),%r10+	movq	%r11,%rbp+	sbbq	24(%rcx),%r11+	sbbq	$0,%r12++	cmovcq	%rax,%r8+	cmovcq	%rsi,%r9+	cmovcq	%rbx,%r10+	cmovcq	%rbp,%r11++	.byte	0xf3,0xc3+.cfi_endproc+.size	__lshift_mod_256,.-__lshift_mod_256+++.globl	lshift_mod_256+.hidden	lshift_mod_256+.type	lshift_mod_256,@function+.align	32+lshift_mod_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11++.Loop_lshift_mod_256:+	call	__lshift_mod_256+	decl	%edx+	jnz	.Loop_lshift_mod_256++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)++	movq	0(%rsp),%r12+.cfi_restore	%r12+	movq	8(%rsp),%rbx+.cfi_restore	%rbx+	movq	16(%rsp),%rbp+.cfi_restore	%rbp+	leaq	24(%rsp),%rsp+.cfi_adjust_cfa_offset	-24++	.byte	0xf3,0xc3+.cfi_endproc	+.size	lshift_mod_256,.-lshift_mod_256+++.globl	rshift_mod_256+.hidden	rshift_mod_256+.type	rshift_mod_256,@function+.align	32+rshift_mod_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%rbp+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11++.Loop_rshift_mod_256:+	movq	%rbp,%r8+	andq	$1,%rbp+	movq	0(%rcx),%rax+	negq	%rbp+	movq	8(%rcx),%rsi+	movq	16(%rcx),%rbx++	andq	%rbp,%rax+	andq	%rbp,%rsi+	andq	%rbp,%rbx+	andq	24(%rcx),%rbp++	addq	%rax,%r8+	adcq	%rsi,%r9+	adcq	%rbx,%r10+	adcq	%rbp,%r11+	sbbq	%rax,%rax++	shrq	$1,%r8+	movq	%r9,%rbp+	shrq	$1,%r9+	movq	%r10,%rbx+	shrq	$1,%r10+	movq	%r11,%rsi+	shrq	$1,%r11++	shlq	$63,%rbp+	shlq	$63,%rbx+	orq	%r8,%rbp+	shlq	$63,%rsi+	orq	%rbx,%r9+	shlq	$63,%rax+	orq	%rsi,%r10+	orq	%rax,%r11++	decl	%edx+	jnz	.Loop_rshift_mod_256++	movq	%rbp,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)++	movq	8(%rsp),%rbx+.cfi_restore	%rbx+	movq	16(%rsp),%rbp+.cfi_restore	%rbp+	leaq	24(%rsp),%rsp+.cfi_adjust_cfa_offset	-24++	.byte	0xf3,0xc3+.cfi_endproc	+.size	rshift_mod_256,.-rshift_mod_256+++.globl	cneg_mod_256+.hidden	cneg_mod_256+.type	cneg_mod_256,@function+.align	32+cneg_mod_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+++	movq	0(%rsi),%r12+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	%r12,%r8+	movq	24(%rsi),%r11+	orq	%r9,%r12+	orq	%r10,%r12+	orq	%r11,%r12+	movq	$-1,%rbp++	movq	0(%rcx),%rax+	cmovnzq	%rbp,%r12+	movq	8(%rcx),%rsi+	movq	16(%rcx),%rbx+	andq	%r12,%rax+	movq	24(%rcx),%rbp+	andq	%r12,%rsi+	andq	%r12,%rbx+	andq	%r12,%rbp++	subq	%r8,%rax+	sbbq	%r9,%rsi+	sbbq	%r10,%rbx+	sbbq	%r11,%rbp++	orq	%rdx,%rdx++	cmovzq	%r8,%rax+	cmovzq	%r9,%rsi+	movq	%rax,0(%rdi)+	cmovzq	%r10,%rbx+	movq	%rsi,8(%rdi)+	cmovzq	%r11,%rbp+	movq	%rbx,16(%rdi)+	movq	%rbp,24(%rdi)++	movq	0(%rsp),%r12+.cfi_restore	%r12+	movq	8(%rsp),%rbx+.cfi_restore	%rbx+	movq	16(%rsp),%rbp+.cfi_restore	%rbp+	leaq	24(%rsp),%rsp+.cfi_adjust_cfa_offset	-24++	.byte	0xf3,0xc3+.cfi_endproc	+.size	cneg_mod_256,.-cneg_mod_256+++.globl	sub_mod_256+.hidden	sub_mod_256+.type	sub_mod_256,@function+.align	32+sub_mod_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11++	subq	0(%rdx),%r8+	movq	0(%rcx),%rax+	sbbq	8(%rdx),%r9+	movq	8(%rcx),%rsi+	sbbq	16(%rdx),%r10+	movq	16(%rcx),%rbx+	sbbq	24(%rdx),%r11+	movq	24(%rcx),%rbp+	sbbq	%rdx,%rdx++	andq	%rdx,%rax+	andq	%rdx,%rsi+	andq	%rdx,%rbx+	andq	%rdx,%rbp++	addq	%rax,%r8+	adcq	%rsi,%r9+	movq	%r8,0(%rdi)+	adcq	%rbx,%r10+	movq	%r9,8(%rdi)+	adcq	%rbp,%r11+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)++	movq	8(%rsp),%rbx+.cfi_restore	%rbx+	movq	16(%rsp),%rbp+.cfi_restore	%rbp+	leaq	24(%rsp),%rsp+.cfi_adjust_cfa_offset	-24++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sub_mod_256,.-sub_mod_256+++.globl	check_mod_256+.hidden	check_mod_256+.type	check_mod_256,@function+.align	32+check_mod_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	movq	0(%rdi),%rax+	movq	8(%rdi),%r9+	movq	16(%rdi),%r10+	movq	24(%rdi),%r11++	movq	%rax,%r8+	orq	%r9,%rax+	orq	%r10,%rax+	orq	%r11,%rax++	subq	0(%rsi),%r8+	sbbq	8(%rsi),%r9+	sbbq	16(%rsi),%r10+	sbbq	24(%rsi),%r11+	sbbq	%rsi,%rsi++	movq	$1,%rdx+	cmpq	$0,%rax+	cmovneq	%rdx,%rax+	andq	%rsi,%rax++	.byte	0xf3,0xc3+.cfi_endproc	+.size	check_mod_256,.-check_mod_256+++.globl	add_n_check_mod_256+.hidden	add_n_check_mod_256+.type	add_n_check_mod_256,@function+.align	32+add_n_check_mod_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11++	addq	0(%rdx),%r8+	adcq	8(%rdx),%r9+	movq	%r8,%rax+	adcq	16(%rdx),%r10+	movq	%r9,%rsi+	adcq	24(%rdx),%r11+	sbbq	%rdx,%rdx++	movq	%r10,%rbx+	subq	0(%rcx),%r8+	sbbq	8(%rcx),%r9+	sbbq	16(%rcx),%r10+	movq	%r11,%rbp+	sbbq	24(%rcx),%r11+	sbbq	$0,%rdx++	cmovcq	%rax,%r8+	cmovcq	%rsi,%r9+	movq	%r8,0(%rdi)+	cmovcq	%rbx,%r10+	movq	%r9,8(%rdi)+	cmovcq	%rbp,%r11+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)++	orq	%r9,%r8+	orq	%r11,%r10+	orq	%r10,%r8+	movq	$1,%rax+	cmovzq	%r8,%rax++	movq	8(%rsp),%rbx+.cfi_restore	%rbx+	movq	16(%rsp),%rbp+.cfi_restore	%rbp+	leaq	24(%rsp),%rsp+.cfi_adjust_cfa_offset	-24++	.byte	0xf3,0xc3+.cfi_endproc	+.size	add_n_check_mod_256,.-add_n_check_mod_256+++.globl	sub_n_check_mod_256+.hidden	sub_n_check_mod_256+.type	sub_n_check_mod_256,@function+.align	32+sub_n_check_mod_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11++	subq	0(%rdx),%r8+	movq	0(%rcx),%rax+	sbbq	8(%rdx),%r9+	movq	8(%rcx),%rsi+	sbbq	16(%rdx),%r10+	movq	16(%rcx),%rbx+	sbbq	24(%rdx),%r11+	movq	24(%rcx),%rbp+	sbbq	%rdx,%rdx++	andq	%rdx,%rax+	andq	%rdx,%rsi+	andq	%rdx,%rbx+	andq	%rdx,%rbp++	addq	%rax,%r8+	adcq	%rsi,%r9+	movq	%r8,0(%rdi)+	adcq	%rbx,%r10+	movq	%r9,8(%rdi)+	adcq	%rbp,%r11+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)++	orq	%r9,%r8+	orq	%r11,%r10+	orq	%r10,%r8+	movq	$1,%rax+	cmovzq	%r8,%rax++	movq	8(%rsp),%rbx+.cfi_restore	%rbx+	movq	16(%rsp),%rbp+.cfi_restore	%rbp+	leaq	24(%rsp),%rsp+.cfi_adjust_cfa_offset	-24++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sub_n_check_mod_256,.-sub_n_check_mod_256++.section	.note.GNU-stack,"",@progbits+.section	.note.gnu.property,"a",@note+	.long	4,2f-1f,5+	.byte	0x47,0x4E,0x55,0+1:	.long	0xc0000002,4,3+.align	8+2:
+ c-source/build/elf/add_mod_384-armv8.S view
@@ -0,0 +1,931 @@+.text++.globl	add_mod_384+.hidden	add_mod_384+.type	add_mod_384,%function+.align	5+add_mod_384:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x4,x5,[x3]+	ldp	x6,x7,[x3,#16]+	ldp	x8,x9,[x3,#32]++	bl	__add_mod_384+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]+	stp	x14,x15,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+	.inst	0xd50323bf+	ret+.size	add_mod_384,.-add_mod_384++.type	__add_mod_384,%function+.align	5+__add_mod_384:+	ldp	x10,x11,[x1]+	ldp	x16,x17,[x2]+	ldp	x12,x13,[x1,#16]+	ldp	x19,x20,[x2,#16]+	ldp	x14,x15,[x1,#32]+	ldp	x21,x22,[x2,#32]++__add_mod_384_ab_are_loaded:+	adds	x10,x10,x16+	adcs	x11,x11,x17+	adcs	x12,x12,x19+	adcs	x13,x13,x20+	adcs	x14,x14,x21+	adcs	x15,x15,x22+	adc	x3,xzr,xzr++	subs	x16,x10,x4+	sbcs	x17,x11,x5+	sbcs	x19,x12,x6+	sbcs	x20,x13,x7+	sbcs	x21,x14,x8+	sbcs	x22,x15,x9+	sbcs	xzr,x3,xzr++	csel	x10,x10,x16,lo+	csel	x11,x11,x17,lo+	csel	x12,x12,x19,lo+	csel	x13,x13,x20,lo+	csel	x14,x14,x21,lo+	csel	x15,x15,x22,lo++	ret+.size	__add_mod_384,.-__add_mod_384++.globl	add_mod_384x+.hidden	add_mod_384x+.type	add_mod_384x,%function+.align	5+add_mod_384x:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x4,x5,[x3]+	ldp	x6,x7,[x3,#16]+	ldp	x8,x9,[x3,#32]++	bl	__add_mod_384++	stp	x10,x11,[x0]+	add	x1,x1,#48+	stp	x12,x13,[x0,#16]+	add	x2,x2,#48+	stp	x14,x15,[x0,#32]++	bl	__add_mod_384+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0,#48]+	stp	x12,x13,[x0,#64]+	stp	x14,x15,[x0,#80]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+	.inst	0xd50323bf+	ret+.size	add_mod_384x,.-add_mod_384x++.globl	rshift_mod_384+.hidden	rshift_mod_384+.type	rshift_mod_384,%function+.align	5+rshift_mod_384:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]+	ldp	x14,x15,[x1,#32]++	ldp	x4,x5,[x3]+	ldp	x6,x7,[x3,#16]+	ldp	x8,x9,[x3,#32]++.Loop_rshift_mod_384:+	sub	x2,x2,#1+	bl	__rshift_mod_384+	cbnz	x2,.Loop_rshift_mod_384++	ldr	x30,[sp,#8]+	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]+	stp	x14,x15,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+	.inst	0xd50323bf+	ret+.size	rshift_mod_384,.-rshift_mod_384++.type	__rshift_mod_384,%function+.align	5+__rshift_mod_384:+	sbfx	x22,x10,#0,#1+	and	x16,x22,x4+	and	x17,x22,x5+	adds	x10,x10,x16+	and	x19,x22,x6+	adcs	x11,x11,x17+	and	x20,x22,x7+	adcs	x12,x12,x19+	and	x21,x22,x8+	adcs	x13,x13,x20+	and	x22,x22,x9+	adcs	x14,x14,x21+	extr	x10,x11,x10,#1	// a[0:5] >>= 1+	adcs	x15,x15,x22+	extr	x11,x12,x11,#1+	adc	x22,xzr,xzr+	extr	x12,x13,x12,#1+	extr	x13,x14,x13,#1+	extr	x14,x15,x14,#1+	extr	x15,x22,x15,#1+	ret+.size	__rshift_mod_384,.-__rshift_mod_384++.globl	div_by_2_mod_384+.hidden	div_by_2_mod_384+.type	div_by_2_mod_384,%function+.align	5+div_by_2_mod_384:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]+	ldp	x14,x15,[x1,#32]++	ldp	x4,x5,[x2]+	ldp	x6,x7,[x2,#16]+	ldp	x8,x9,[x2,#32]++	bl	__rshift_mod_384++	ldr	x30,[sp,#8]+	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]+	stp	x14,x15,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+	.inst	0xd50323bf+	ret+.size	div_by_2_mod_384,.-div_by_2_mod_384++.globl	lshift_mod_384+.hidden	lshift_mod_384+.type	lshift_mod_384,%function+.align	5+lshift_mod_384:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]+	ldp	x14,x15,[x1,#32]++	ldp	x4,x5,[x3]+	ldp	x6,x7,[x3,#16]+	ldp	x8,x9,[x3,#32]++.Loop_lshift_mod_384:+	sub	x2,x2,#1+	bl	__lshift_mod_384+	cbnz	x2,.Loop_lshift_mod_384++	ldr	x30,[sp,#8]+	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]+	stp	x14,x15,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+	.inst	0xd50323bf+	ret+.size	lshift_mod_384,.-lshift_mod_384++.type	__lshift_mod_384,%function+.align	5+__lshift_mod_384:+	adds	x10,x10,x10+	adcs	x11,x11,x11+	adcs	x12,x12,x12+	adcs	x13,x13,x13+	adcs	x14,x14,x14+	adcs	x15,x15,x15+	adc	x3,xzr,xzr++	subs	x16,x10,x4+	sbcs	x17,x11,x5+	sbcs	x19,x12,x6+	sbcs	x20,x13,x7+	sbcs	x21,x14,x8+	sbcs	x22,x15,x9+	sbcs	xzr,x3,xzr++	csel	x10,x10,x16,lo+	csel	x11,x11,x17,lo+	csel	x12,x12,x19,lo+	csel	x13,x13,x20,lo+	csel	x14,x14,x21,lo+	csel	x15,x15,x22,lo++	ret+.size	__lshift_mod_384,.-__lshift_mod_384++.globl	mul_by_3_mod_384+.hidden	mul_by_3_mod_384+.type	mul_by_3_mod_384,%function+.align	5+mul_by_3_mod_384:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]+	ldp	x14,x15,[x1,#32]++	ldp	x4,x5,[x2]+	ldp	x6,x7,[x2,#16]+	ldp	x8,x9,[x2,#32]++	bl	__lshift_mod_384++	ldp	x16,x17,[x1]+	ldp	x19,x20,[x1,#16]+	ldp	x21,x22,[x1,#32]++	bl	__add_mod_384_ab_are_loaded+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]+	stp	x14,x15,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+	.inst	0xd50323bf+	ret+.size	mul_by_3_mod_384,.-mul_by_3_mod_384++.globl	mul_by_8_mod_384+.hidden	mul_by_8_mod_384+.type	mul_by_8_mod_384,%function+.align	5+mul_by_8_mod_384:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]+	ldp	x14,x15,[x1,#32]++	ldp	x4,x5,[x2]+	ldp	x6,x7,[x2,#16]+	ldp	x8,x9,[x2,#32]++	bl	__lshift_mod_384+	bl	__lshift_mod_384+	bl	__lshift_mod_384+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]+	stp	x14,x15,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+	.inst	0xd50323bf+	ret+.size	mul_by_8_mod_384,.-mul_by_8_mod_384++.globl	mul_by_3_mod_384x+.hidden	mul_by_3_mod_384x+.type	mul_by_3_mod_384x,%function+.align	5+mul_by_3_mod_384x:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]+	ldp	x14,x15,[x1,#32]++	ldp	x4,x5,[x2]+	ldp	x6,x7,[x2,#16]+	ldp	x8,x9,[x2,#32]++	bl	__lshift_mod_384++	ldp	x16,x17,[x1]+	ldp	x19,x20,[x1,#16]+	ldp	x21,x22,[x1,#32]++	bl	__add_mod_384_ab_are_loaded++	stp	x10,x11,[x0]+	ldp	x10,x11,[x1,#48]+	stp	x12,x13,[x0,#16]+	ldp	x12,x13,[x1,#64]+	stp	x14,x15,[x0,#32]+	ldp	x14,x15,[x1,#80]++	bl	__lshift_mod_384++	ldp	x16,x17,[x1,#48]+	ldp	x19,x20,[x1,#64]+	ldp	x21,x22,[x1,#80]++	bl	__add_mod_384_ab_are_loaded+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0,#48]+	stp	x12,x13,[x0,#64]+	stp	x14,x15,[x0,#80]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+	.inst	0xd50323bf+	ret+.size	mul_by_3_mod_384x,.-mul_by_3_mod_384x++.globl	mul_by_8_mod_384x+.hidden	mul_by_8_mod_384x+.type	mul_by_8_mod_384x,%function+.align	5+mul_by_8_mod_384x:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]+	ldp	x14,x15,[x1,#32]++	ldp	x4,x5,[x2]+	ldp	x6,x7,[x2,#16]+	ldp	x8,x9,[x2,#32]++	bl	__lshift_mod_384+	bl	__lshift_mod_384+	bl	__lshift_mod_384++	stp	x10,x11,[x0]+	ldp	x10,x11,[x1,#48]+	stp	x12,x13,[x0,#16]+	ldp	x12,x13,[x1,#64]+	stp	x14,x15,[x0,#32]+	ldp	x14,x15,[x1,#80]++	bl	__lshift_mod_384+	bl	__lshift_mod_384+	bl	__lshift_mod_384+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0,#48]+	stp	x12,x13,[x0,#64]+	stp	x14,x15,[x0,#80]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+	.inst	0xd50323bf+	ret+.size	mul_by_8_mod_384x,.-mul_by_8_mod_384x++.globl	cneg_mod_384+.hidden	cneg_mod_384+.type	cneg_mod_384,%function+.align	5+cneg_mod_384:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x10,x11,[x1]+	ldp	x4,x5,[x3]+	ldp	x12,x13,[x1,#16]+	ldp	x6,x7,[x3,#16]++	subs	x16,x4,x10+	ldp	x14,x15,[x1,#32]+	ldp	x8,x9,[x3,#32]+	orr	x3,x10,x11+	sbcs	x17,x5,x11+	orr	x3,x3,x12+	sbcs	x19,x6,x12+	orr	x3,x3,x13+	sbcs	x20,x7,x13+	orr	x3,x3,x14+	sbcs	x21,x8,x14+	orr	x3,x3,x15+	sbc	x22,x9,x15++	cmp	x3,#0+	csetm	x3,ne+	ands	x2,x2,x3++	csel	x10,x10,x16,eq+	csel	x11,x11,x17,eq+	csel	x12,x12,x19,eq+	csel	x13,x13,x20,eq+	stp	x10,x11,[x0]+	csel	x14,x14,x21,eq+	stp	x12,x13,[x0,#16]+	csel	x15,x15,x22,eq+	stp	x14,x15,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+	.inst	0xd50323bf+	ret+.size	cneg_mod_384,.-cneg_mod_384++.globl	sub_mod_384+.hidden	sub_mod_384+.type	sub_mod_384,%function+.align	5+sub_mod_384:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x4,x5,[x3]+	ldp	x6,x7,[x3,#16]+	ldp	x8,x9,[x3,#32]++	bl	__sub_mod_384+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]+	stp	x14,x15,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+	.inst	0xd50323bf+	ret+.size	sub_mod_384,.-sub_mod_384++.type	__sub_mod_384,%function+.align	5+__sub_mod_384:+	ldp	x10,x11,[x1]+	ldp	x16,x17,[x2]+	ldp	x12,x13,[x1,#16]+	ldp	x19,x20,[x2,#16]+	ldp	x14,x15,[x1,#32]+	ldp	x21,x22,[x2,#32]++	subs	x10,x10,x16+	sbcs	x11,x11,x17+	sbcs	x12,x12,x19+	sbcs	x13,x13,x20+	sbcs	x14,x14,x21+	sbcs	x15,x15,x22+	sbc	x3,xzr,xzr++	and	x16,x4,x3+	and	x17,x5,x3+	adds	x10,x10,x16+	and	x19,x6,x3+	adcs	x11,x11,x17+	and	x20,x7,x3+	adcs	x12,x12,x19+	and	x21,x8,x3+	adcs	x13,x13,x20+	and	x22,x9,x3+	adcs	x14,x14,x21+	adc	x15,x15,x22++	ret+.size	__sub_mod_384,.-__sub_mod_384++.globl	sub_mod_384x+.hidden	sub_mod_384x+.type	sub_mod_384x,%function+.align	5+sub_mod_384x:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x4,x5,[x3]+	ldp	x6,x7,[x3,#16]+	ldp	x8,x9,[x3,#32]++	bl	__sub_mod_384++	stp	x10,x11,[x0]+	add	x1,x1,#48+	stp	x12,x13,[x0,#16]+	add	x2,x2,#48+	stp	x14,x15,[x0,#32]++	bl	__sub_mod_384+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0,#48]+	stp	x12,x13,[x0,#64]+	stp	x14,x15,[x0,#80]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+	.inst	0xd50323bf+	ret+.size	sub_mod_384x,.-sub_mod_384x++.globl	mul_by_1_plus_i_mod_384x+.hidden	mul_by_1_plus_i_mod_384x+.type	mul_by_1_plus_i_mod_384x,%function+.align	5+mul_by_1_plus_i_mod_384x:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x4,x5,[x2]+	ldp	x6,x7,[x2,#16]+	ldp	x8,x9,[x2,#32]+	add	x2,x1,#48++	bl	__sub_mod_384			// a->re - a->im++	ldp	x16,x17,[x1]+	ldp	x19,x20,[x1,#16]+	ldp	x21,x22,[x1,#32]+	stp	x10,x11,[x0]+	ldp	x10,x11,[x1,#48]+	stp	x12,x13,[x0,#16]+	ldp	x12,x13,[x1,#64]+	stp	x14,x15,[x0,#32]+	ldp	x14,x15,[x1,#80]++	bl	__add_mod_384_ab_are_loaded	// a->re + a->im+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0,#48]+	stp	x12,x13,[x0,#64]+	stp	x14,x15,[x0,#80]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+	.inst	0xd50323bf+	ret+.size	mul_by_1_plus_i_mod_384x,.-mul_by_1_plus_i_mod_384x++.globl	sgn0_pty_mod_384+.hidden	sgn0_pty_mod_384+.type	sgn0_pty_mod_384,%function+.align	5+sgn0_pty_mod_384:+	ldp	x10,x11,[x0]+	ldp	x12,x13,[x0,#16]+	ldp	x14,x15,[x0,#32]++	ldp	x4,x5,[x1]+	ldp	x6,x7,[x1,#16]+	ldp	x8,x9,[x1,#32]++	and	x0,x10,#1+	adds	x10,x10,x10+	adcs	x11,x11,x11+	adcs	x12,x12,x12+	adcs	x13,x13,x13+	adcs	x14,x14,x14+	adcs	x15,x15,x15+	adc	x3,xzr,xzr++	subs	x10,x10,x4+	sbcs	x11,x11,x5+	sbcs	x12,x12,x6+	sbcs	x13,x13,x7+	sbcs	x14,x14,x8+	sbcs	x15,x15,x9+	sbc	x3,x3,xzr++	mvn	x3,x3+	and	x3,x3,#2+	orr	x0,x0,x3++	ret+.size	sgn0_pty_mod_384,.-sgn0_pty_mod_384++.globl	sgn0_pty_mod_384x+.hidden	sgn0_pty_mod_384x+.type	sgn0_pty_mod_384x,%function+.align	5+sgn0_pty_mod_384x:+	ldp	x10,x11,[x0]+	ldp	x12,x13,[x0,#16]+	ldp	x14,x15,[x0,#32]++	ldp	x4,x5,[x1]+	ldp	x6,x7,[x1,#16]+	ldp	x8,x9,[x1,#32]++	and	x2,x10,#1+	orr	x3,x10,x11+	adds	x10,x10,x10+	orr	x3,x3,x12+	adcs	x11,x11,x11+	orr	x3,x3,x13+	adcs	x12,x12,x12+	orr	x3,x3,x14+	adcs	x13,x13,x13+	orr	x3,x3,x15+	adcs	x14,x14,x14+	adcs	x15,x15,x15+	adc	x16,xzr,xzr++	subs	x10,x10,x4+	sbcs	x11,x11,x5+	sbcs	x12,x12,x6+	sbcs	x13,x13,x7+	sbcs	x14,x14,x8+	sbcs	x15,x15,x9+	sbc	x16,x16,xzr++	ldp	x10,x11,[x0,#48]+	ldp	x12,x13,[x0,#64]+	ldp	x14,x15,[x0,#80]++	mvn	x16,x16+	and	x16,x16,#2+	orr	x2,x2,x16++	and	x0,x10,#1+	orr	x1,x10,x11+	adds	x10,x10,x10+	orr	x1,x1,x12+	adcs	x11,x11,x11+	orr	x1,x1,x13+	adcs	x12,x12,x12+	orr	x1,x1,x14+	adcs	x13,x13,x13+	orr	x1,x1,x15+	adcs	x14,x14,x14+	adcs	x15,x15,x15+	adc	x16,xzr,xzr++	subs	x10,x10,x4+	sbcs	x11,x11,x5+	sbcs	x12,x12,x6+	sbcs	x13,x13,x7+	sbcs	x14,x14,x8+	sbcs	x15,x15,x9+	sbc	x16,x16,xzr++	mvn	x16,x16+	and	x16,x16,#2+	orr	x0,x0,x16++	cmp	x3,#0+	csel	x3,x0,x2,eq	// a->re==0? prty(a->im) : prty(a->re)++	cmp	x1,#0+	csel	x1,x0,x2,ne	// a->im!=0? sgn0(a->im) : sgn0(a->re)++	and	x3,x3,#1+	and	x1,x1,#2+	orr	x0,x1,x3	// pack sign and parity++	ret+.size	sgn0_pty_mod_384x,.-sgn0_pty_mod_384x+.globl	vec_select_48+.hidden	vec_select_48+.type	vec_select_48,%function+.align	5+vec_select_48:+	dup	v6.2d, x3+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	cmeq	v6.2d, v6.2d, #0+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v0.16b, v3.16b, v6.16b+	bit	v1.16b, v4.16b, v6.16b+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0]+	ret+.size	vec_select_48,.-vec_select_48+.globl	vec_select_96+.hidden	vec_select_96+.type	vec_select_96,%function+.align	5+vec_select_96:+	dup	v6.2d, x3+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	cmeq	v6.2d, v6.2d, #0+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v0.16b, v3.16b, v6.16b+	ld1	{v16.2d, v17.2d, v18.2d}, [x1],#48+	bit	v1.16b, v4.16b, v6.16b+	ld1	{v19.2d, v20.2d, v21.2d}, [x2],#48+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0],#48+	bit	v16.16b, v19.16b, v6.16b+	bit	v17.16b, v20.16b, v6.16b+	bit	v18.16b, v21.16b, v6.16b+	st1	{v16.2d, v17.2d, v18.2d}, [x0]+	ret+.size	vec_select_96,.-vec_select_96+.globl	vec_select_192+.hidden	vec_select_192+.type	vec_select_192,%function+.align	5+vec_select_192:+	dup	v6.2d, x3+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	cmeq	v6.2d, v6.2d, #0+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v0.16b, v3.16b, v6.16b+	ld1	{v16.2d, v17.2d, v18.2d}, [x1],#48+	bit	v1.16b, v4.16b, v6.16b+	ld1	{v19.2d, v20.2d, v21.2d}, [x2],#48+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0],#48+	bit	v16.16b, v19.16b, v6.16b+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	bit	v17.16b, v20.16b, v6.16b+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v18.16b, v21.16b, v6.16b+	st1	{v16.2d, v17.2d, v18.2d}, [x0],#48+	bit	v0.16b, v3.16b, v6.16b+	ld1	{v16.2d, v17.2d, v18.2d}, [x1],#48+	bit	v1.16b, v4.16b, v6.16b+	ld1	{v19.2d, v20.2d, v21.2d}, [x2],#48+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0],#48+	bit	v16.16b, v19.16b, v6.16b+	bit	v17.16b, v20.16b, v6.16b+	bit	v18.16b, v21.16b, v6.16b+	st1	{v16.2d, v17.2d, v18.2d}, [x0]+	ret+.size	vec_select_192,.-vec_select_192+.globl	vec_select_144+.hidden	vec_select_144+.type	vec_select_144,%function+.align	5+vec_select_144:+	dup	v6.2d, x3+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	cmeq	v6.2d, v6.2d, #0+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v0.16b, v3.16b, v6.16b+	ld1	{v16.2d, v17.2d, v18.2d}, [x1],#48+	bit	v1.16b, v4.16b, v6.16b+	ld1	{v19.2d, v20.2d, v21.2d}, [x2],#48+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0],#48+	bit	v16.16b, v19.16b, v6.16b+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	bit	v17.16b, v20.16b, v6.16b+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v18.16b, v21.16b, v6.16b+	st1	{v16.2d, v17.2d, v18.2d}, [x0],#48+	bit	v0.16b, v3.16b, v6.16b+	bit	v1.16b, v4.16b, v6.16b+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0]+	ret+.size	vec_select_144,.-vec_select_144+.globl	vec_select_288+.hidden	vec_select_288+.type	vec_select_288,%function+.align	5+vec_select_288:+	dup	v6.2d, x3+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	cmeq	v6.2d, v6.2d, #0+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v0.16b, v3.16b, v6.16b+	ld1	{v16.2d, v17.2d, v18.2d}, [x1],#48+	bit	v1.16b, v4.16b, v6.16b+	ld1	{v19.2d, v20.2d, v21.2d}, [x2],#48+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0],#48+	bit	v16.16b, v19.16b, v6.16b+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	bit	v17.16b, v20.16b, v6.16b+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v18.16b, v21.16b, v6.16b+	st1	{v16.2d, v17.2d, v18.2d}, [x0],#48+	bit	v0.16b, v3.16b, v6.16b+	ld1	{v16.2d, v17.2d, v18.2d}, [x1],#48+	bit	v1.16b, v4.16b, v6.16b+	ld1	{v19.2d, v20.2d, v21.2d}, [x2],#48+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0],#48+	bit	v16.16b, v19.16b, v6.16b+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	bit	v17.16b, v20.16b, v6.16b+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v18.16b, v21.16b, v6.16b+	st1	{v16.2d, v17.2d, v18.2d}, [x0],#48+	bit	v0.16b, v3.16b, v6.16b+	ld1	{v16.2d, v17.2d, v18.2d}, [x1],#48+	bit	v1.16b, v4.16b, v6.16b+	ld1	{v19.2d, v20.2d, v21.2d}, [x2],#48+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0],#48+	bit	v16.16b, v19.16b, v6.16b+	bit	v17.16b, v20.16b, v6.16b+	bit	v18.16b, v21.16b, v6.16b+	st1	{v16.2d, v17.2d, v18.2d}, [x0]+	ret+.size	vec_select_288,.-vec_select_288+.globl	vec_prefetch+.hidden	vec_prefetch+.type	vec_prefetch,%function+.align	5+vec_prefetch:+	add	x1, x1, x0+	sub	x1, x1, #1+	mov	x2, #64+	prfm	pldl1keep, [x0]+	add	x0, x0, x2+	cmp	x0, x1+	csel	x0, x1, x0, hi+	csel	x2, xzr, x2, hi+	prfm	pldl1keep, [x0]+	add	x0, x0, x2+	cmp	x0, x1+	csel	x0, x1, x0, hi+	csel	x2, xzr, x2, hi+	prfm	pldl1keep, [x0]+	add	x0, x0, x2+	cmp	x0, x1+	csel	x0, x1, x0, hi+	csel	x2, xzr, x2, hi+	prfm	pldl1keep, [x0]+	add	x0, x0, x2+	cmp	x0, x1+	csel	x0, x1, x0, hi+	csel	x2, xzr, x2, hi+	prfm	pldl1keep, [x0]+	add	x0, x0, x2+	cmp	x0, x1+	csel	x0, x1, x0, hi+	csel	x2, xzr, x2, hi+	prfm	pldl1keep, [x0]+	add	x0, x0, x2+	cmp	x0, x1+	csel	x0, x1, x0, hi+	prfm	pldl1keep, [x0]+	ret+.size	vec_prefetch,.-vec_prefetch
+ c-source/build/elf/add_mod_384-x86_64.s view
@@ -0,0 +1,1809 @@+.text	++.globl	add_mod_384+.hidden	add_mod_384+.type	add_mod_384,@function+.align	32+add_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	call	__add_mod_384++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	add_mod_384,.-add_mod_384++.type	__add_mod_384,@function+.align	32+__add_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++__add_mod_384_a_is_loaded:+	addq	0(%rdx),%r8+	adcq	8(%rdx),%r9+	adcq	16(%rdx),%r10+	movq	%r8,%r14+	adcq	24(%rdx),%r11+	movq	%r9,%r15+	adcq	32(%rdx),%r12+	movq	%r10,%rax+	adcq	40(%rdx),%r13+	movq	%r11,%rbx+	sbbq	%rdx,%rdx++	subq	0(%rcx),%r8+	sbbq	8(%rcx),%r9+	movq	%r12,%rbp+	sbbq	16(%rcx),%r10+	sbbq	24(%rcx),%r11+	sbbq	32(%rcx),%r12+	movq	%r13,%rsi+	sbbq	40(%rcx),%r13+	sbbq	$0,%rdx++	cmovcq	%r14,%r8+	cmovcq	%r15,%r9+	cmovcq	%rax,%r10+	movq	%r8,0(%rdi)+	cmovcq	%rbx,%r11+	movq	%r9,8(%rdi)+	cmovcq	%rbp,%r12+	movq	%r10,16(%rdi)+	cmovcq	%rsi,%r13+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+.size	__add_mod_384,.-__add_mod_384++.globl	add_mod_384x+.hidden	add_mod_384x+.type	add_mod_384x,@function+.align	32+add_mod_384x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$24,%rsp+.cfi_adjust_cfa_offset	24+++	movq	%rsi,0(%rsp)+	movq	%rdx,8(%rsp)+	leaq	48(%rsi),%rsi+	leaq	48(%rdx),%rdx+	leaq	48(%rdi),%rdi+	call	__add_mod_384++	movq	0(%rsp),%rsi+	movq	8(%rsp),%rdx+	leaq	-48(%rdi),%rdi+	call	__add_mod_384++	movq	24+0(%rsp),%r15+.cfi_restore	%r15+	movq	24+8(%rsp),%r14+.cfi_restore	%r14+	movq	24+16(%rsp),%r13+.cfi_restore	%r13+	movq	24+24(%rsp),%r12+.cfi_restore	%r12+	movq	24+32(%rsp),%rbx+.cfi_restore	%rbx+	movq	24+40(%rsp),%rbp+.cfi_restore	%rbp+	leaq	24+48(%rsp),%rsp+.cfi_adjust_cfa_offset	-24-8*6++	.byte	0xf3,0xc3+.cfi_endproc	+.size	add_mod_384x,.-add_mod_384x+++.globl	rshift_mod_384+.hidden	rshift_mod_384+.type	rshift_mod_384,@function+.align	32+rshift_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	pushq	%rdi+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++.Loop_rshift_mod_384:+	call	__rshift_mod_384+	decl	%edx+	jnz	.Loop_rshift_mod_384++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	rshift_mod_384,.-rshift_mod_384++.type	__rshift_mod_384,@function+.align	32+__rshift_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	$1,%rsi+	movq	0(%rcx),%r14+	andq	%r8,%rsi+	movq	8(%rcx),%r15+	negq	%rsi+	movq	16(%rcx),%rax+	andq	%rsi,%r14+	movq	24(%rcx),%rbx+	andq	%rsi,%r15+	movq	32(%rcx),%rbp+	andq	%rsi,%rax+	andq	%rsi,%rbx+	andq	%rsi,%rbp+	andq	40(%rcx),%rsi++	addq	%r8,%r14+	adcq	%r9,%r15+	adcq	%r10,%rax+	adcq	%r11,%rbx+	adcq	%r12,%rbp+	adcq	%r13,%rsi+	sbbq	%r13,%r13++	shrq	$1,%r14+	movq	%r15,%r8+	shrq	$1,%r15+	movq	%rax,%r9+	shrq	$1,%rax+	movq	%rbx,%r10+	shrq	$1,%rbx+	movq	%rbp,%r11+	shrq	$1,%rbp+	movq	%rsi,%r12+	shrq	$1,%rsi+	shlq	$63,%r8+	shlq	$63,%r9+	orq	%r14,%r8+	shlq	$63,%r10+	orq	%r15,%r9+	shlq	$63,%r11+	orq	%rax,%r10+	shlq	$63,%r12+	orq	%rbx,%r11+	shlq	$63,%r13+	orq	%rbp,%r12+	orq	%rsi,%r13++	.byte	0xf3,0xc3+.cfi_endproc+.size	__rshift_mod_384,.-__rshift_mod_384++.globl	div_by_2_mod_384+.hidden	div_by_2_mod_384+.type	div_by_2_mod_384,@function+.align	32+div_by_2_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	pushq	%rdi+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%r8+	movq	%rdx,%rcx+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	call	__rshift_mod_384++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	div_by_2_mod_384,.-div_by_2_mod_384+++.globl	lshift_mod_384+.hidden	lshift_mod_384+.type	lshift_mod_384,@function+.align	32+lshift_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	pushq	%rdi+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++.Loop_lshift_mod_384:+	addq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	movq	%r8,%r14+	adcq	%r11,%r11+	movq	%r9,%r15+	adcq	%r12,%r12+	movq	%r10,%rax+	adcq	%r13,%r13+	movq	%r11,%rbx+	sbbq	%rdi,%rdi++	subq	0(%rcx),%r8+	sbbq	8(%rcx),%r9+	movq	%r12,%rbp+	sbbq	16(%rcx),%r10+	sbbq	24(%rcx),%r11+	sbbq	32(%rcx),%r12+	movq	%r13,%rsi+	sbbq	40(%rcx),%r13+	sbbq	$0,%rdi++	movq	(%rsp),%rdi+	cmovcq	%r14,%r8+	cmovcq	%r15,%r9+	cmovcq	%rax,%r10+	cmovcq	%rbx,%r11+	cmovcq	%rbp,%r12+	cmovcq	%rsi,%r13++	decl	%edx+	jnz	.Loop_lshift_mod_384++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	lshift_mod_384,.-lshift_mod_384++.type	__lshift_mod_384,@function+.align	32+__lshift_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	addq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	movq	%r8,%r14+	adcq	%r11,%r11+	movq	%r9,%r15+	adcq	%r12,%r12+	movq	%r10,%rax+	adcq	%r13,%r13+	movq	%r11,%rbx+	sbbq	%rdx,%rdx++	subq	0(%rcx),%r8+	sbbq	8(%rcx),%r9+	movq	%r12,%rbp+	sbbq	16(%rcx),%r10+	sbbq	24(%rcx),%r11+	sbbq	32(%rcx),%r12+	movq	%r13,%rsi+	sbbq	40(%rcx),%r13+	sbbq	$0,%rdx++	cmovcq	%r14,%r8+	cmovcq	%r15,%r9+	cmovcq	%rax,%r10+	cmovcq	%rbx,%r11+	cmovcq	%rbp,%r12+	cmovcq	%rsi,%r13++	.byte	0xf3,0xc3+.cfi_endproc+.size	__lshift_mod_384,.-__lshift_mod_384+++.globl	mul_by_3_mod_384+.hidden	mul_by_3_mod_384+.type	mul_by_3_mod_384,@function+.align	32+mul_by_3_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	pushq	%rsi+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	%rdx,%rcx++	call	__lshift_mod_384++	movq	(%rsp),%rdx+	call	__add_mod_384_a_is_loaded++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	mul_by_3_mod_384,.-mul_by_3_mod_384++.globl	mul_by_8_mod_384+.hidden	mul_by_8_mod_384+.type	mul_by_8_mod_384,@function+.align	32+mul_by_8_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	%rdx,%rcx++	call	__lshift_mod_384+	call	__lshift_mod_384+	call	__lshift_mod_384++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	mul_by_8_mod_384,.-mul_by_8_mod_384+++.globl	mul_by_3_mod_384x+.hidden	mul_by_3_mod_384x+.type	mul_by_3_mod_384x,@function+.align	32+mul_by_3_mod_384x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	pushq	%rsi+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	%rdx,%rcx++	call	__lshift_mod_384++	movq	(%rsp),%rdx+	call	__add_mod_384_a_is_loaded++	movq	(%rsp),%rsi+	leaq	48(%rdi),%rdi++	movq	48(%rsi),%r8+	movq	56(%rsi),%r9+	movq	64(%rsi),%r10+	movq	72(%rsi),%r11+	movq	80(%rsi),%r12+	movq	88(%rsi),%r13++	call	__lshift_mod_384++	movq	$48,%rdx+	addq	(%rsp),%rdx+	call	__add_mod_384_a_is_loaded++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	mul_by_3_mod_384x,.-mul_by_3_mod_384x++.globl	mul_by_8_mod_384x+.hidden	mul_by_8_mod_384x+.type	mul_by_8_mod_384x,@function+.align	32+mul_by_8_mod_384x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	pushq	%rsi+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	%rdx,%rcx++	call	__lshift_mod_384+	call	__lshift_mod_384+	call	__lshift_mod_384++	movq	(%rsp),%rsi+	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	movq	48+0(%rsi),%r8+	movq	48+8(%rsi),%r9+	movq	48+16(%rsi),%r10+	movq	48+24(%rsi),%r11+	movq	48+32(%rsi),%r12+	movq	48+40(%rsi),%r13++	call	__lshift_mod_384+	call	__lshift_mod_384+	call	__lshift_mod_384++	movq	%r8,48+0(%rdi)+	movq	%r9,48+8(%rdi)+	movq	%r10,48+16(%rdi)+	movq	%r11,48+24(%rdi)+	movq	%r12,48+32(%rdi)+	movq	%r13,48+40(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	mul_by_8_mod_384x,.-mul_by_8_mod_384x+++.globl	cneg_mod_384+.hidden	cneg_mod_384+.type	cneg_mod_384,@function+.align	32+cneg_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	pushq	%rdx+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%rdx+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	%rdx,%r8+	movq	24(%rsi),%r11+	orq	%r9,%rdx+	movq	32(%rsi),%r12+	orq	%r10,%rdx+	movq	40(%rsi),%r13+	orq	%r11,%rdx+	movq	$-1,%rsi+	orq	%r12,%rdx+	orq	%r13,%rdx++	movq	0(%rcx),%r14+	cmovnzq	%rsi,%rdx+	movq	8(%rcx),%r15+	movq	16(%rcx),%rax+	andq	%rdx,%r14+	movq	24(%rcx),%rbx+	andq	%rdx,%r15+	movq	32(%rcx),%rbp+	andq	%rdx,%rax+	movq	40(%rcx),%rsi+	andq	%rdx,%rbx+	movq	0(%rsp),%rcx+	andq	%rdx,%rbp+	andq	%rdx,%rsi++	subq	%r8,%r14+	sbbq	%r9,%r15+	sbbq	%r10,%rax+	sbbq	%r11,%rbx+	sbbq	%r12,%rbp+	sbbq	%r13,%rsi++	orq	%rcx,%rcx++	cmovzq	%r8,%r14+	cmovzq	%r9,%r15+	cmovzq	%r10,%rax+	movq	%r14,0(%rdi)+	cmovzq	%r11,%rbx+	movq	%r15,8(%rdi)+	cmovzq	%r12,%rbp+	movq	%rax,16(%rdi)+	cmovzq	%r13,%rsi+	movq	%rbx,24(%rdi)+	movq	%rbp,32(%rdi)+	movq	%rsi,40(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	cneg_mod_384,.-cneg_mod_384+++.globl	sub_mod_384+.hidden	sub_mod_384+.type	sub_mod_384,@function+.align	32+sub_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	call	__sub_mod_384++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sub_mod_384,.-sub_mod_384++.type	__sub_mod_384,@function+.align	32+__sub_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	subq	0(%rdx),%r8+	movq	0(%rcx),%r14+	sbbq	8(%rdx),%r9+	movq	8(%rcx),%r15+	sbbq	16(%rdx),%r10+	movq	16(%rcx),%rax+	sbbq	24(%rdx),%r11+	movq	24(%rcx),%rbx+	sbbq	32(%rdx),%r12+	movq	32(%rcx),%rbp+	sbbq	40(%rdx),%r13+	movq	40(%rcx),%rsi+	sbbq	%rdx,%rdx++	andq	%rdx,%r14+	andq	%rdx,%r15+	andq	%rdx,%rax+	andq	%rdx,%rbx+	andq	%rdx,%rbp+	andq	%rdx,%rsi++	addq	%r14,%r8+	adcq	%r15,%r9+	movq	%r8,0(%rdi)+	adcq	%rax,%r10+	movq	%r9,8(%rdi)+	adcq	%rbx,%r11+	movq	%r10,16(%rdi)+	adcq	%rbp,%r12+	movq	%r11,24(%rdi)+	adcq	%rsi,%r13+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+.size	__sub_mod_384,.-__sub_mod_384++.globl	sub_mod_384x+.hidden	sub_mod_384x+.type	sub_mod_384x,@function+.align	32+sub_mod_384x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$24,%rsp+.cfi_adjust_cfa_offset	24+++	movq	%rsi,0(%rsp)+	movq	%rdx,8(%rsp)+	leaq	48(%rsi),%rsi+	leaq	48(%rdx),%rdx+	leaq	48(%rdi),%rdi+	call	__sub_mod_384++	movq	0(%rsp),%rsi+	movq	8(%rsp),%rdx+	leaq	-48(%rdi),%rdi+	call	__sub_mod_384++	movq	24+0(%rsp),%r15+.cfi_restore	%r15+	movq	24+8(%rsp),%r14+.cfi_restore	%r14+	movq	24+16(%rsp),%r13+.cfi_restore	%r13+	movq	24+24(%rsp),%r12+.cfi_restore	%r12+	movq	24+32(%rsp),%rbx+.cfi_restore	%rbx+	movq	24+40(%rsp),%rbp+.cfi_restore	%rbp+	leaq	24+48(%rsp),%rsp+.cfi_adjust_cfa_offset	-24-8*6++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sub_mod_384x,.-sub_mod_384x+.globl	mul_by_1_plus_i_mod_384x+.hidden	mul_by_1_plus_i_mod_384x+.type	mul_by_1_plus_i_mod_384x,@function+.align	32+mul_by_1_plus_i_mod_384x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$56,%rsp+.cfi_adjust_cfa_offset	56+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%r8,%r14+	addq	48(%rsi),%r8+	movq	%r9,%r15+	adcq	56(%rsi),%r9+	movq	%r10,%rax+	adcq	64(%rsi),%r10+	movq	%r11,%rbx+	adcq	72(%rsi),%r11+	movq	%r12,%rcx+	adcq	80(%rsi),%r12+	movq	%r13,%rbp+	adcq	88(%rsi),%r13+	movq	%rdi,48(%rsp)+	sbbq	%rdi,%rdi++	subq	48(%rsi),%r14+	sbbq	56(%rsi),%r15+	sbbq	64(%rsi),%rax+	sbbq	72(%rsi),%rbx+	sbbq	80(%rsi),%rcx+	sbbq	88(%rsi),%rbp+	sbbq	%rsi,%rsi++	movq	%r8,0(%rsp)+	movq	0(%rdx),%r8+	movq	%r9,8(%rsp)+	movq	8(%rdx),%r9+	movq	%r10,16(%rsp)+	movq	16(%rdx),%r10+	movq	%r11,24(%rsp)+	movq	24(%rdx),%r11+	movq	%r12,32(%rsp)+	andq	%rsi,%r8+	movq	32(%rdx),%r12+	movq	%r13,40(%rsp)+	andq	%rsi,%r9+	movq	40(%rdx),%r13+	andq	%rsi,%r10+	andq	%rsi,%r11+	andq	%rsi,%r12+	andq	%rsi,%r13+	movq	48(%rsp),%rsi++	addq	%r8,%r14+	movq	0(%rsp),%r8+	adcq	%r9,%r15+	movq	8(%rsp),%r9+	adcq	%r10,%rax+	movq	16(%rsp),%r10+	adcq	%r11,%rbx+	movq	24(%rsp),%r11+	adcq	%r12,%rcx+	movq	32(%rsp),%r12+	adcq	%r13,%rbp+	movq	40(%rsp),%r13++	movq	%r14,0(%rsi)+	movq	%r8,%r14+	movq	%r15,8(%rsi)+	movq	%rax,16(%rsi)+	movq	%r9,%r15+	movq	%rbx,24(%rsi)+	movq	%rcx,32(%rsi)+	movq	%r10,%rax+	movq	%rbp,40(%rsi)++	subq	0(%rdx),%r8+	movq	%r11,%rbx+	sbbq	8(%rdx),%r9+	sbbq	16(%rdx),%r10+	movq	%r12,%rcx+	sbbq	24(%rdx),%r11+	sbbq	32(%rdx),%r12+	movq	%r13,%rbp+	sbbq	40(%rdx),%r13+	sbbq	$0,%rdi++	cmovcq	%r14,%r8+	cmovcq	%r15,%r9+	cmovcq	%rax,%r10+	movq	%r8,48(%rsi)+	cmovcq	%rbx,%r11+	movq	%r9,56(%rsi)+	cmovcq	%rcx,%r12+	movq	%r10,64(%rsi)+	cmovcq	%rbp,%r13+	movq	%r11,72(%rsi)+	movq	%r12,80(%rsi)+	movq	%r13,88(%rsi)++	movq	56+0(%rsp),%r15+.cfi_restore	%r15+	movq	56+8(%rsp),%r14+.cfi_restore	%r14+	movq	56+16(%rsp),%r13+.cfi_restore	%r13+	movq	56+24(%rsp),%r12+.cfi_restore	%r12+	movq	56+32(%rsp),%rbx+.cfi_restore	%rbx+	movq	56+40(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56+48(%rsp),%rsp+.cfi_adjust_cfa_offset	-56-8*6++	.byte	0xf3,0xc3+.cfi_endproc	+.size	mul_by_1_plus_i_mod_384x,.-mul_by_1_plus_i_mod_384x+.globl	sgn0_pty_mod_384+.hidden	sgn0_pty_mod_384+.type	sgn0_pty_mod_384,@function+.align	32+sgn0_pty_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++++	movq	0(%rdi),%r8+	movq	8(%rdi),%r9+	movq	16(%rdi),%r10+	movq	24(%rdi),%r11+	movq	32(%rdi),%rcx+	movq	40(%rdi),%rdx++	xorq	%rax,%rax+	movq	%r8,%rdi+	addq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	%rcx,%rcx+	adcq	%rdx,%rdx+	adcq	$0,%rax++	subq	0(%rsi),%r8+	sbbq	8(%rsi),%r9+	sbbq	16(%rsi),%r10+	sbbq	24(%rsi),%r11+	sbbq	32(%rsi),%rcx+	sbbq	40(%rsi),%rdx+	sbbq	$0,%rax++	notq	%rax+	andq	$1,%rdi+	andq	$2,%rax+	orq	%rdi,%rax+++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sgn0_pty_mod_384,.-sgn0_pty_mod_384++.globl	sgn0_pty_mod_384x+.hidden	sgn0_pty_mod_384x+.type	sgn0_pty_mod_384x,@function+.align	32+sgn0_pty_mod_384x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	48(%rdi),%r8+	movq	56(%rdi),%r9+	movq	64(%rdi),%r10+	movq	72(%rdi),%r11+	movq	80(%rdi),%rcx+	movq	88(%rdi),%rdx++	movq	%r8,%rbx+	orq	%r9,%r8+	orq	%r10,%r8+	orq	%r11,%r8+	orq	%rcx,%r8+	orq	%rdx,%r8++	leaq	0(%rdi),%rax+	xorq	%rdi,%rdi+	movq	%rbx,%rbp+	addq	%rbx,%rbx+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	%rcx,%rcx+	adcq	%rdx,%rdx+	adcq	$0,%rdi++	subq	0(%rsi),%rbx+	sbbq	8(%rsi),%r9+	sbbq	16(%rsi),%r10+	sbbq	24(%rsi),%r11+	sbbq	32(%rsi),%rcx+	sbbq	40(%rsi),%rdx+	sbbq	$0,%rdi++	movq	%r8,0(%rsp)+	notq	%rdi+	andq	$1,%rbp+	andq	$2,%rdi+	orq	%rbp,%rdi++	movq	0(%rax),%r8+	movq	8(%rax),%r9+	movq	16(%rax),%r10+	movq	24(%rax),%r11+	movq	32(%rax),%rcx+	movq	40(%rax),%rdx++	movq	%r8,%rbx+	orq	%r9,%r8+	orq	%r10,%r8+	orq	%r11,%r8+	orq	%rcx,%r8+	orq	%rdx,%r8++	xorq	%rax,%rax+	movq	%rbx,%rbp+	addq	%rbx,%rbx+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	%rcx,%rcx+	adcq	%rdx,%rdx+	adcq	$0,%rax++	subq	0(%rsi),%rbx+	sbbq	8(%rsi),%r9+	sbbq	16(%rsi),%r10+	sbbq	24(%rsi),%r11+	sbbq	32(%rsi),%rcx+	sbbq	40(%rsi),%rdx+	sbbq	$0,%rax++	movq	0(%rsp),%rbx++	notq	%rax++	testq	%r8,%r8+	cmovzq	%rdi,%rbp++	testq	%rbx,%rbx+	cmovnzq	%rdi,%rax++	andq	$1,%rbp+	andq	$2,%rax+	orq	%rbp,%rax++	movq	8(%rsp),%rbx+.cfi_restore	%rbx+	movq	16(%rsp),%rbp+.cfi_restore	%rbp+	leaq	24(%rsp),%rsp+.cfi_adjust_cfa_offset	-24++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sgn0_pty_mod_384x,.-sgn0_pty_mod_384x+.globl	vec_select_48+.hidden	vec_select_48+.type	vec_select_48,@function+.align	32+vec_select_48:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movd	%ecx,%xmm5+	pxor	%xmm4,%xmm4+	pshufd	$0,%xmm5,%xmm5+	movdqu	(%rsi),%xmm0+	leaq	24(%rsi),%rsi+	pcmpeqd	%xmm4,%xmm5+	movdqu	(%rdx),%xmm1+	leaq	24(%rdx),%rdx+	pcmpeqd	%xmm5,%xmm4+	leaq	24(%rdi),%rdi+	pand	%xmm4,%xmm0+	movdqu	0+16-24(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	0+16-24(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,0-24(%rdi)+	pand	%xmm4,%xmm2+	movdqu	16+16-24(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	16+16-24(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,16-24(%rdi)+	pand	%xmm4,%xmm0+	pand	%xmm5,%xmm1+	por	%xmm1,%xmm0+	movdqu	%xmm0,32-24(%rdi)+	.byte	0xf3,0xc3+.cfi_endproc+.size	vec_select_48,.-vec_select_48+.globl	vec_select_96+.hidden	vec_select_96+.type	vec_select_96,@function+.align	32+vec_select_96:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movd	%ecx,%xmm5+	pxor	%xmm4,%xmm4+	pshufd	$0,%xmm5,%xmm5+	movdqu	(%rsi),%xmm0+	leaq	48(%rsi),%rsi+	pcmpeqd	%xmm4,%xmm5+	movdqu	(%rdx),%xmm1+	leaq	48(%rdx),%rdx+	pcmpeqd	%xmm5,%xmm4+	leaq	48(%rdi),%rdi+	pand	%xmm4,%xmm0+	movdqu	0+16-48(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	0+16-48(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,0-48(%rdi)+	pand	%xmm4,%xmm2+	movdqu	16+16-48(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	16+16-48(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,16-48(%rdi)+	pand	%xmm4,%xmm0+	movdqu	32+16-48(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	32+16-48(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,32-48(%rdi)+	pand	%xmm4,%xmm2+	movdqu	48+16-48(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	48+16-48(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,48-48(%rdi)+	pand	%xmm4,%xmm0+	movdqu	64+16-48(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	64+16-48(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,64-48(%rdi)+	pand	%xmm4,%xmm2+	pand	%xmm5,%xmm3+	por	%xmm3,%xmm2+	movdqu	%xmm2,80-48(%rdi)+	.byte	0xf3,0xc3+.cfi_endproc+.size	vec_select_96,.-vec_select_96+.globl	vec_select_192+.hidden	vec_select_192+.type	vec_select_192,@function+.align	32+vec_select_192:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movd	%ecx,%xmm5+	pxor	%xmm4,%xmm4+	pshufd	$0,%xmm5,%xmm5+	movdqu	(%rsi),%xmm0+	leaq	96(%rsi),%rsi+	pcmpeqd	%xmm4,%xmm5+	movdqu	(%rdx),%xmm1+	leaq	96(%rdx),%rdx+	pcmpeqd	%xmm5,%xmm4+	leaq	96(%rdi),%rdi+	pand	%xmm4,%xmm0+	movdqu	0+16-96(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	0+16-96(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,0-96(%rdi)+	pand	%xmm4,%xmm2+	movdqu	16+16-96(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	16+16-96(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,16-96(%rdi)+	pand	%xmm4,%xmm0+	movdqu	32+16-96(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	32+16-96(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,32-96(%rdi)+	pand	%xmm4,%xmm2+	movdqu	48+16-96(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	48+16-96(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,48-96(%rdi)+	pand	%xmm4,%xmm0+	movdqu	64+16-96(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	64+16-96(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,64-96(%rdi)+	pand	%xmm4,%xmm2+	movdqu	80+16-96(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	80+16-96(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,80-96(%rdi)+	pand	%xmm4,%xmm0+	movdqu	96+16-96(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	96+16-96(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,96-96(%rdi)+	pand	%xmm4,%xmm2+	movdqu	112+16-96(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	112+16-96(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,112-96(%rdi)+	pand	%xmm4,%xmm0+	movdqu	128+16-96(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	128+16-96(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,128-96(%rdi)+	pand	%xmm4,%xmm2+	movdqu	144+16-96(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	144+16-96(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,144-96(%rdi)+	pand	%xmm4,%xmm0+	movdqu	160+16-96(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	160+16-96(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,160-96(%rdi)+	pand	%xmm4,%xmm2+	pand	%xmm5,%xmm3+	por	%xmm3,%xmm2+	movdqu	%xmm2,176-96(%rdi)+	.byte	0xf3,0xc3+.cfi_endproc+.size	vec_select_192,.-vec_select_192+.globl	vec_select_144+.hidden	vec_select_144+.type	vec_select_144,@function+.align	32+vec_select_144:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movd	%ecx,%xmm5+	pxor	%xmm4,%xmm4+	pshufd	$0,%xmm5,%xmm5+	movdqu	(%rsi),%xmm0+	leaq	72(%rsi),%rsi+	pcmpeqd	%xmm4,%xmm5+	movdqu	(%rdx),%xmm1+	leaq	72(%rdx),%rdx+	pcmpeqd	%xmm5,%xmm4+	leaq	72(%rdi),%rdi+	pand	%xmm4,%xmm0+	movdqu	0+16-72(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	0+16-72(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,0-72(%rdi)+	pand	%xmm4,%xmm2+	movdqu	16+16-72(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	16+16-72(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,16-72(%rdi)+	pand	%xmm4,%xmm0+	movdqu	32+16-72(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	32+16-72(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,32-72(%rdi)+	pand	%xmm4,%xmm2+	movdqu	48+16-72(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	48+16-72(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,48-72(%rdi)+	pand	%xmm4,%xmm0+	movdqu	64+16-72(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	64+16-72(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,64-72(%rdi)+	pand	%xmm4,%xmm2+	movdqu	80+16-72(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	80+16-72(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,80-72(%rdi)+	pand	%xmm4,%xmm0+	movdqu	96+16-72(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	96+16-72(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,96-72(%rdi)+	pand	%xmm4,%xmm2+	movdqu	112+16-72(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	112+16-72(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,112-72(%rdi)+	pand	%xmm4,%xmm0+	pand	%xmm5,%xmm1+	por	%xmm1,%xmm0+	movdqu	%xmm0,128-72(%rdi)+	.byte	0xf3,0xc3+.cfi_endproc+.size	vec_select_144,.-vec_select_144+.globl	vec_select_288+.hidden	vec_select_288+.type	vec_select_288,@function+.align	32+vec_select_288:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movd	%ecx,%xmm5+	pxor	%xmm4,%xmm4+	pshufd	$0,%xmm5,%xmm5+	movdqu	(%rsi),%xmm0+	leaq	144(%rsi),%rsi+	pcmpeqd	%xmm4,%xmm5+	movdqu	(%rdx),%xmm1+	leaq	144(%rdx),%rdx+	pcmpeqd	%xmm5,%xmm4+	leaq	144(%rdi),%rdi+	pand	%xmm4,%xmm0+	movdqu	0+16-144(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	0+16-144(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,0-144(%rdi)+	pand	%xmm4,%xmm2+	movdqu	16+16-144(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	16+16-144(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,16-144(%rdi)+	pand	%xmm4,%xmm0+	movdqu	32+16-144(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	32+16-144(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,32-144(%rdi)+	pand	%xmm4,%xmm2+	movdqu	48+16-144(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	48+16-144(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,48-144(%rdi)+	pand	%xmm4,%xmm0+	movdqu	64+16-144(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	64+16-144(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,64-144(%rdi)+	pand	%xmm4,%xmm2+	movdqu	80+16-144(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	80+16-144(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,80-144(%rdi)+	pand	%xmm4,%xmm0+	movdqu	96+16-144(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	96+16-144(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,96-144(%rdi)+	pand	%xmm4,%xmm2+	movdqu	112+16-144(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	112+16-144(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,112-144(%rdi)+	pand	%xmm4,%xmm0+	movdqu	128+16-144(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	128+16-144(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,128-144(%rdi)+	pand	%xmm4,%xmm2+	movdqu	144+16-144(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	144+16-144(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,144-144(%rdi)+	pand	%xmm4,%xmm0+	movdqu	160+16-144(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	160+16-144(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,160-144(%rdi)+	pand	%xmm4,%xmm2+	movdqu	176+16-144(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	176+16-144(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,176-144(%rdi)+	pand	%xmm4,%xmm0+	movdqu	192+16-144(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	192+16-144(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,192-144(%rdi)+	pand	%xmm4,%xmm2+	movdqu	208+16-144(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	208+16-144(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,208-144(%rdi)+	pand	%xmm4,%xmm0+	movdqu	224+16-144(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	224+16-144(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,224-144(%rdi)+	pand	%xmm4,%xmm2+	movdqu	240+16-144(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	240+16-144(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,240-144(%rdi)+	pand	%xmm4,%xmm0+	movdqu	256+16-144(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	256+16-144(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,256-144(%rdi)+	pand	%xmm4,%xmm2+	pand	%xmm5,%xmm3+	por	%xmm3,%xmm2+	movdqu	%xmm2,272-144(%rdi)+	.byte	0xf3,0xc3+.cfi_endproc+.size	vec_select_288,.-vec_select_288+.globl	vec_prefetch+.hidden	vec_prefetch+.type	vec_prefetch,@function+.align	32+vec_prefetch:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	leaq	-1(%rdi,%rsi,1),%rsi+	movq	$64,%rax+	xorq	%r8,%r8+	prefetchnta	(%rdi)+	leaq	(%rdi,%rax,1),%rdi+	cmpq	%rsi,%rdi+	cmovaq	%rsi,%rdi+	cmovaq	%r8,%rax+	prefetchnta	(%rdi)+	leaq	(%rdi,%rax,1),%rdi+	cmpq	%rsi,%rdi+	cmovaq	%rsi,%rdi+	cmovaq	%r8,%rax+	prefetchnta	(%rdi)+	leaq	(%rdi,%rax,1),%rdi+	cmpq	%rsi,%rdi+	cmovaq	%rsi,%rdi+	cmovaq	%r8,%rax+	prefetchnta	(%rdi)+	leaq	(%rdi,%rax,1),%rdi+	cmpq	%rsi,%rdi+	cmovaq	%rsi,%rdi+	cmovaq	%r8,%rax+	prefetchnta	(%rdi)+	leaq	(%rdi,%rax,1),%rdi+	cmpq	%rsi,%rdi+	cmovaq	%rsi,%rdi+	cmovaq	%r8,%rax+	prefetchnta	(%rdi)+	leaq	(%rdi,%rax,1),%rdi+	cmpq	%rsi,%rdi+	cmovaq	%rsi,%rdi+	prefetchnta	(%rdi)+	.byte	0xf3,0xc3+.cfi_endproc+.size	vec_prefetch,.-vec_prefetch++.section	.note.GNU-stack,"",@progbits+.section	.note.gnu.property,"a",@note+	.long	4,2f-1f,5+	.byte	0x47,0x4E,0x55,0+1:	.long	0xc0000002,4,3+.align	8+2:
+ c-source/build/elf/add_mod_384x384-x86_64.s view
@@ -0,0 +1,252 @@+.text	++.type	__add_mod_384x384,@function+.align	32+__add_mod_384x384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	48(%rsi),%r14++	addq	0(%rdx),%r8+	movq	56(%rsi),%r15+	adcq	8(%rdx),%r9+	movq	64(%rsi),%rax+	adcq	16(%rdx),%r10+	movq	72(%rsi),%rbx+	adcq	24(%rdx),%r11+	movq	80(%rsi),%rbp+	adcq	32(%rdx),%r12+	movq	88(%rsi),%rsi+	adcq	40(%rdx),%r13+	movq	%r8,0(%rdi)+	adcq	48(%rdx),%r14+	movq	%r9,8(%rdi)+	adcq	56(%rdx),%r15+	movq	%r10,16(%rdi)+	adcq	64(%rdx),%rax+	movq	%r12,32(%rdi)+	movq	%r14,%r8+	adcq	72(%rdx),%rbx+	movq	%r11,24(%rdi)+	movq	%r15,%r9+	adcq	80(%rdx),%rbp+	movq	%r13,40(%rdi)+	movq	%rax,%r10+	adcq	88(%rdx),%rsi+	movq	%rbx,%r11+	sbbq	%rdx,%rdx++	subq	0(%rcx),%r14+	sbbq	8(%rcx),%r15+	movq	%rbp,%r12+	sbbq	16(%rcx),%rax+	sbbq	24(%rcx),%rbx+	sbbq	32(%rcx),%rbp+	movq	%rsi,%r13+	sbbq	40(%rcx),%rsi+	sbbq	$0,%rdx++	cmovcq	%r8,%r14+	cmovcq	%r9,%r15+	cmovcq	%r10,%rax+	movq	%r14,48(%rdi)+	cmovcq	%r11,%rbx+	movq	%r15,56(%rdi)+	cmovcq	%r12,%rbp+	movq	%rax,64(%rdi)+	cmovcq	%r13,%rsi+	movq	%rbx,72(%rdi)+	movq	%rbp,80(%rdi)+	movq	%rsi,88(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+.size	__add_mod_384x384,.-__add_mod_384x384++.type	__sub_mod_384x384,@function+.align	32+__sub_mod_384x384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	48(%rsi),%r14++	subq	0(%rdx),%r8+	movq	56(%rsi),%r15+	sbbq	8(%rdx),%r9+	movq	64(%rsi),%rax+	sbbq	16(%rdx),%r10+	movq	72(%rsi),%rbx+	sbbq	24(%rdx),%r11+	movq	80(%rsi),%rbp+	sbbq	32(%rdx),%r12+	movq	88(%rsi),%rsi+	sbbq	40(%rdx),%r13+	movq	%r8,0(%rdi)+	sbbq	48(%rdx),%r14+	movq	0(%rcx),%r8+	movq	%r9,8(%rdi)+	sbbq	56(%rdx),%r15+	movq	8(%rcx),%r9+	movq	%r10,16(%rdi)+	sbbq	64(%rdx),%rax+	movq	16(%rcx),%r10+	movq	%r11,24(%rdi)+	sbbq	72(%rdx),%rbx+	movq	24(%rcx),%r11+	movq	%r12,32(%rdi)+	sbbq	80(%rdx),%rbp+	movq	32(%rcx),%r12+	movq	%r13,40(%rdi)+	sbbq	88(%rdx),%rsi+	movq	40(%rcx),%r13+	sbbq	%rdx,%rdx++	andq	%rdx,%r8+	andq	%rdx,%r9+	andq	%rdx,%r10+	andq	%rdx,%r11+	andq	%rdx,%r12+	andq	%rdx,%r13++	addq	%r8,%r14+	adcq	%r9,%r15+	movq	%r14,48(%rdi)+	adcq	%r10,%rax+	movq	%r15,56(%rdi)+	adcq	%r11,%rbx+	movq	%rax,64(%rdi)+	adcq	%r12,%rbp+	movq	%rbx,72(%rdi)+	adcq	%r13,%rsi+	movq	%rbp,80(%rdi)+	movq	%rsi,88(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+.size	__sub_mod_384x384,.-__sub_mod_384x384++.globl	add_mod_384x384+.hidden	add_mod_384x384+.type	add_mod_384x384,@function+.align	32+add_mod_384x384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	call	__add_mod_384x384++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	add_mod_384x384,.-add_mod_384x384++.globl	sub_mod_384x384+.hidden	sub_mod_384x384+.type	sub_mod_384x384,@function+.align	32+sub_mod_384x384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	call	__sub_mod_384x384++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sub_mod_384x384,.-sub_mod_384x384++.section	.note.GNU-stack,"",@progbits+.section	.note.gnu.property,"a",@note+	.long	4,2f-1f,5+	.byte	0x47,0x4E,0x55,0+1:	.long	0xc0000002,4,3+.align	8+2:
+ c-source/build/elf/ct_inverse_mod_256-armv8.S view
@@ -0,0 +1,784 @@+.text++.globl	ct_inverse_mod_256+.type	ct_inverse_mod_256, %function+.align	5+ct_inverse_mod_256:+	.inst	0xd503233f+	stp	x29, x30, [sp,#-80]!+	add	x29, sp, #0+	stp	x19, x20, [sp,#16]+	stp	x21, x22, [sp,#32]+	stp	x23, x24, [sp,#48]+	stp	x25, x26, [sp,#64]+	sub	sp, sp, #1040++	ldp	x4, x5, [x1,#8*0]+	ldp	x6, x7, [x1,#8*2]++	add	x1, sp, #16+511	// find closest 512-byte-aligned spot+	and	x1, x1, #-512	// in the frame...+	str	x0, [sp]++	ldp	x8, x9, [x2,#8*0]+	ldp	x10, x11, [x2,#8*2]++	stp	x4, x5, [x1,#8*0]	// copy input to |a|+	stp	x6, x7, [x1,#8*2]+	stp	x8, x9, [x1,#8*4]	// copy modulus to |b|+	stp	x10, x11, [x1,#8*6]++	////////////////////////////////////////// first iteration+	bl	.Lab_approximation_31_256_loaded++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	str	x12,[x0,#8*8]		// initialize |u| with |f0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to dst |b|+	bl	__smul_256_n_shift_by_31+	str	x12, [x0,#8*9]		// initialize |v| with |f1|++	////////////////////////////////////////// second iteration+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	ldr	x8, [x1,#8*8]		// |u|+	ldr	x9, [x1,#8*13]	// |v|+	madd	x4, x16, x8, xzr	// |u|*|f0|+	madd	x4, x17, x9, x4	// |v|*|g0|+	str	x4, [x0,#8*4]+	asr	x5, x4, #63		// sign extenstion+	stp	x5, x5, [x0,#8*5]+	stp	x5, x5, [x0,#8*7]++	madd	x4, x12, x8, xzr	// |u|*|f1|+	madd	x4, x13, x9, x4	// |v|*|g1|+	str	x4, [x0,#8*9]+	asr	x5, x4, #63		// sign extenstion+	stp	x5, x5, [x0,#8*10]+	stp	x5, x5, [x0,#8*12]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	adc	x22, x22, x23+	stp	x22, x22, [x0,#8*4]+	stp	x22, x22, [x0,#8*6]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	adc	x22, x22, x23+	stp	x22, x22, [x0,#8*4]+	stp	x22, x22, [x0,#8*6]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	adc	x22, x22, x23+	stp	x22, x22, [x0,#8*4]+	stp	x22, x22, [x0,#8*6]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	adc	x22, x22, x23+	stp	x22, x22, [x0,#8*4]+	stp	x22, x22, [x0,#8*6]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	adc	x22, x22, x23+	stp	x22, x22, [x0,#8*4]+	stp	x22, x22, [x0,#8*6]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	adc	x22, x22, x23+	stp	x22, x22, [x0,#8*4]+	stp	x22, x22, [x0,#8*6]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	bl	__smul_512x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	bl	__smul_512x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	bl	__smul_512x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	bl	__smul_512x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	bl	__smul_512x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	bl	__smul_512x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	bl	__smul_512x63_tail+	////////////////////////////////////////// two[!] last iterations+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #47			// 31 + 512 % 31+	//bl	__ab_approximation_62_256	// |a| and |b| are exact,+	ldr	x7, [x1,#8*0]		// just load+	ldr	x11, [x1,#8*4]+	bl	__inner_loop_62_256++	mov	x16, x14+	mov	x17, x15+	ldr	x0, [sp]			// original out_ptr+	bl	__smul_256x63+	bl	__smul_512x63_tail+	ldr	x30, [x29,#8]++	smulh	x20, x7, x17		// figure out top-most limb+	ldp	x8, x9, [x3,#8*0]+	adc	x23, x23, x25+	ldp	x10, x11, [x3,#8*2]++	add	x20, x20, x23		// x20 is 1, 0 or -1+	asr	x19, x20, #63		// sign as mask++	and	x23,   x8, x19		// add mod<<256 conditionally+	and	x24,   x9, x19+	adds	x4, x4, x23+	and	x25,   x10, x19+	adcs	x5, x5, x24+	and	x26,   x11, x19+	adcs	x6, x6, x25+	adcs	x7, x22,   x26+	adc	x20, x20, xzr		// x20 is 1, 0 or -1++	neg	x19, x20+	orr	x20, x20, x19		// excess bit or sign as mask+	asr	x19, x19, #63		// excess bit as mask++	and	x8, x8, x20		// mask |mod|+	and	x9, x9, x20+	and	x10, x10, x20+	and	x11, x11, x20++	eor	x8, x8, x19		// conditionally negate |mod|+	eor	x9, x9, x19+	adds	x8, x8, x19, lsr#63+	eor	x10, x10, x19+	adcs	x9, x9, xzr+	eor	x11, x11, x19+	adcs	x10, x10, xzr+	adc	x11, x11, xzr++	adds	x4, x4, x8	// final adjustment for |mod|<<256+	adcs	x5, x5, x9+	adcs	x6, x6, x10+	stp	x4, x5, [x0,#8*4]+	adc	x7, x7, x11+	stp	x6, x7, [x0,#8*6]++	add	sp, sp, #1040+	ldp	x19, x20, [x29,#16]+	ldp	x21, x22, [x29,#32]+	ldp	x23, x24, [x29,#48]+	ldp	x25, x26, [x29,#64]+	ldr	x29, [sp],#80+	.inst	0xd50323bf+	ret+.size	ct_inverse_mod_256,.-ct_inverse_mod_256++////////////////////////////////////////////////////////////////////////+.type	__smul_256x63, %function+.align	5+__smul_256x63:+	ldp	x4, x5, [x1,#8*0+64]	// load |u| (or |v|)+	asr	x14, x16, #63		// |f_|'s sign as mask (or |g_|'s)+	ldp	x6, x7, [x1,#8*2+64]+	eor	x16, x16, x14		// conditionally negate |f_| (or |g_|)+	ldr	x22, [x1,#8*4+64]++	eor	x4, x4, x14	// conditionally negate |u| (or |v|)+	sub	x16, x16, x14+	eor	x5, x5, x14+	adds	x4, x4, x14, lsr#63+	eor	x6, x6, x14+	adcs	x5, x5, xzr+	eor	x7, x7, x14+	adcs	x6, x6, xzr+	eor	x22, x22, x14+	umulh	x19, x4, x16+	adcs	x7, x7, xzr+	umulh	x20, x5, x16+	adcs	x22, x22, xzr+	umulh	x21, x6, x16+	mul	x4, x4, x16+	cmp	x16, #0+	mul	x5, x5, x16+	csel	x22, x22, xzr, ne+	mul	x6, x6, x16+	adds	x5, x5, x19+	mul	x24, x7, x16+	adcs	x6, x6, x20+	adcs	x24, x24, x21+	adc	x26, xzr, xzr+	ldp	x8, x9, [x1,#8*0+104]	// load |u| (or |v|)+	asr	x14, x17, #63		// |f_|'s sign as mask (or |g_|'s)+	ldp	x10, x11, [x1,#8*2+104]+	eor	x17, x17, x14		// conditionally negate |f_| (or |g_|)+	ldr	x23, [x1,#8*4+104]++	eor	x8, x8, x14	// conditionally negate |u| (or |v|)+	sub	x17, x17, x14+	eor	x9, x9, x14+	adds	x8, x8, x14, lsr#63+	eor	x10, x10, x14+	adcs	x9, x9, xzr+	eor	x11, x11, x14+	adcs	x10, x10, xzr+	eor	x23, x23, x14+	umulh	x19, x8, x17+	adcs	x11, x11, xzr+	umulh	x20, x9, x17+	adcs	x23, x23, xzr+	umulh	x21, x10, x17+	adc	x15, xzr, xzr		// used in __smul_512x63_tail+	mul	x8, x8, x17+	cmp	x17, #0+	mul	x9, x9, x17+	csel	x23, x23, xzr, ne+	mul	x10, x10, x17+	adds	x9, x9, x19+	mul	x25, x11, x17+	adcs	x10, x10, x20+	adcs	x25, x25, x21+	adc	x26, x26, xzr++	adds	x4, x4, x8+	adcs	x5, x5, x9+	adcs	x6, x6, x10+	stp	x4, x5, [x0,#8*0]+	adcs	x24,   x24,   x25+	stp	x6, x24, [x0,#8*2]++	ret+.size	__smul_256x63,.-__smul_256x63++.type	__smul_512x63_tail, %function+.align	5+__smul_512x63_tail:+	umulh	x24, x7, x16+	ldp	x5, x6, [x1,#8*18]	// load rest of |v|+	adc	x26, x26, xzr+	ldr	x7, [x1,#8*20]+	and	x22, x22, x16++	umulh	x11, x11, x17	// resume |v|*|g1| chain++	sub	x24, x24, x22	// tie up |u|*|f1| chain+	asr	x25, x24, #63++	eor	x5, x5, x14	// conditionally negate rest of |v|+	eor	x6, x6, x14+	adds	x5, x5, x15+	eor	x7, x7, x14+	adcs	x6, x6, xzr+	umulh	x19, x23,   x17+	adc	x7, x7, xzr+	umulh	x20, x5, x17+	add	x11, x11, x26+	umulh	x21, x6, x17++	mul	x4, x23,   x17+	mul	x5, x5, x17+	adds	x4, x4, x11+	mul	x6, x6, x17+	adcs	x5, x5, x19+	mul	x22,   x7, x17+	adcs	x6, x6, x20+	adcs	x22,   x22,   x21+	adc	x23, xzr, xzr		// used in the final step++	adds	x4, x4, x24+	adcs	x5, x5, x25+	adcs	x6, x6, x25+	stp	x4, x5, [x0,#8*4]+	adcs	x22,   x22,   x25	// carry is used in the final step+	stp	x6, x22,   [x0,#8*6]++	ret+.size	__smul_512x63_tail,.-__smul_512x63_tail++.type	__smul_256_n_shift_by_31, %function+.align	5+__smul_256_n_shift_by_31:+	ldp	x4, x5, [x1,#8*0+0]	// load |a| (or |b|)+	asr	x24, x12, #63		// |f0|'s sign as mask (or |g0|'s)+	ldp	x6, x7, [x1,#8*2+0]+	eor	x25, x12, x24	// conditionally negate |f0| (or |g0|)++	eor	x4, x4, x24	// conditionally negate |a| (or |b|)+	sub	x25, x25, x24+	eor	x5, x5, x24+	adds	x4, x4, x24, lsr#63+	eor	x6, x6, x24+	adcs	x5, x5, xzr+	eor	x7, x7, x24+	umulh	x19, x4, x25+	adcs	x6, x6, xzr+	umulh	x20, x5, x25+	adc	x7, x7, xzr+	umulh	x21, x6, x25+	and	x24, x24, x25+	umulh	x22, x7, x25+	neg	x24, x24++	mul	x4, x4, x25+	mul	x5, x5, x25+	mul	x6, x6, x25+	adds	x5, x5, x19+	mul	x7, x7, x25+	adcs	x6, x6, x20+	adcs	x7, x7, x21+	adc	x22, x22, x24+	ldp	x8, x9, [x1,#8*0+32]	// load |a| (or |b|)+	asr	x24, x13, #63		// |f0|'s sign as mask (or |g0|'s)+	ldp	x10, x11, [x1,#8*2+32]+	eor	x25, x13, x24	// conditionally negate |f0| (or |g0|)++	eor	x8, x8, x24	// conditionally negate |a| (or |b|)+	sub	x25, x25, x24+	eor	x9, x9, x24+	adds	x8, x8, x24, lsr#63+	eor	x10, x10, x24+	adcs	x9, x9, xzr+	eor	x11, x11, x24+	umulh	x19, x8, x25+	adcs	x10, x10, xzr+	umulh	x20, x9, x25+	adc	x11, x11, xzr+	umulh	x21, x10, x25+	and	x24, x24, x25+	umulh	x23, x11, x25+	neg	x24, x24++	mul	x8, x8, x25+	mul	x9, x9, x25+	mul	x10, x10, x25+	adds	x9, x9, x19+	mul	x11, x11, x25+	adcs	x10, x10, x20+	adcs	x11, x11, x21+	adc	x23, x23, x24+	adds	x4, x4, x8+	adcs	x5, x5, x9+	adcs	x6, x6, x10+	adcs	x7, x7, x11+	adc	x8, x22,   x23++	extr	x4, x5, x4, #31+	extr	x5, x6, x5, #31+	extr	x6, x7, x6, #31+	asr	x23, x8, #63	// result's sign as mask+	extr	x7, x8, x7, #31++	eor	x4, x4, x23	// ensure the result is positive+	eor	x5, x5, x23+	adds	x4, x4, x23, lsr#63+	eor	x6, x6, x23+	adcs	x5, x5, xzr+	eor	x7, x7, x23+	adcs	x6, x6, xzr+	stp	x4, x5, [x0,#8*0]+	adc	x7, x7, xzr+	stp	x6, x7, [x0,#8*2]++	eor	x12, x12, x23		// adjust |f/g| accordingly+	eor	x13, x13, x23+	sub	x12, x12, x23+	sub	x13, x13, x23++	ret+.size	__smul_256_n_shift_by_31,.-__smul_256_n_shift_by_31+.type	__ab_approximation_31_256, %function+.align	4+__ab_approximation_31_256:+	ldp	x6, x7, [x1,#8*2]+	ldp	x10, x11, [x1,#8*6]+	ldp	x4, x5, [x1,#8*0]+	ldp	x8, x9, [x1,#8*4]++.Lab_approximation_31_256_loaded:+	orr	x19, x7, x11	// check top-most limbs, ...+	cmp	x19, #0+	csel	x7, x7, x6, ne+	csel	x11, x11, x10, ne+	csel	x6, x6, x5, ne+	orr	x19, x7, x11	// and ones before top-most, ...+	csel	x10, x10, x9, ne++	cmp	x19, #0+	csel	x7, x7, x6, ne+	csel	x11, x11, x10, ne+	csel	x6, x6, x4, ne+	orr	x19, x7, x11	// and one more, ...+	csel	x10, x10, x8, ne++	clz	x19, x19+	cmp	x19, #64+	csel	x19, x19, xzr, ne+	csel	x7, x7, x6, ne+	csel	x11, x11, x10, ne+	neg	x20, x19++	lslv	x7, x7, x19	// align high limbs to the left+	lslv	x11, x11, x19+	lsrv	x6, x6, x20+	lsrv	x10, x10, x20+	and	x6, x6, x20, asr#6+	and	x10, x10, x20, asr#6+	orr	x7, x7, x6+	orr	x11, x11, x10++	bfxil	x7, x4, #0, #31+	bfxil	x11, x8, #0, #31++	b	__inner_loop_31_256+	ret+.size	__ab_approximation_31_256,.-__ab_approximation_31_256++.type	__inner_loop_31_256, %function+.align	4+__inner_loop_31_256:+	mov	x2, #31+	mov	x13, #0x7FFFFFFF80000000	// |f0|=1, |g0|=0+	mov	x15, #0x800000007FFFFFFF	// |f1|=0, |g1|=1+	mov	x23,#0x7FFFFFFF7FFFFFFF++.Loop_31_256:+	sbfx	x22, x7, #0, #1	// if |a_| is odd, then we'll be subtracting+	sub	x2, x2, #1+	and	x19, x11, x22+	sub	x20, x11, x7	// |b_|-|a_|+	subs	x21, x7, x19	// |a_|-|b_| (or |a_|-0 if |a_| was even)+	mov	x19, x15+	csel	x11, x11, x7, hs	// |b_| = |a_|+	csel	x7, x21, x20, hs	// borrow means |a_|<|b_|, replace with |b_|-|a_|+	csel	x15, x15, x13,    hs	// exchange |fg0| and |fg1|+	csel	x13, x13, x19,   hs+	lsr	x7, x7, #1+	and	x19, x15, x22+	and	x20, x23, x22+	sub	x13, x13, x19	// |f0|-=|f1| (or |f0-=0| if |a_| was even)+	add	x15, x15, x15	// |f1|<<=1+	add	x13, x13, x20+	sub	x15, x15, x23+	cbnz	x2, .Loop_31_256++	mov	x23, #0x7FFFFFFF+	ubfx	x12, x13, #0, #32+	ubfx	x13, x13, #32, #32+	ubfx	x14, x15, #0, #32+	ubfx	x15, x15, #32, #32+	sub	x12, x12, x23		// remove bias+	sub	x13, x13, x23+	sub	x14, x14, x23+	sub	x15, x15, x23++	ret+.size	__inner_loop_31_256,.-__inner_loop_31_256++.type	__inner_loop_62_256, %function+.align	4+__inner_loop_62_256:+	mov	x12, #1		// |f0|=1+	mov	x13, #0		// |g0|=0+	mov	x14, #0		// |f1|=0+	mov	x15, #1		// |g1|=1++.Loop_62_256:+	sbfx	x22, x7, #0, #1	// if |a_| is odd, then we'll be subtracting+	sub	x2, x2, #1+	and	x19, x11, x22+	sub	x20, x11, x7	// |b_|-|a_|+	subs	x21, x7, x19	// |a_|-|b_| (or |a_|-0 if |a_| was even)+	mov	x19, x12+	csel	x11, x11, x7, hs	// |b_| = |a_|+	csel	x7, x21, x20, hs	// borrow means |a_|<|b_|, replace with |b_|-|a_|+	mov	x20, x13+	csel	x12, x12, x14,       hs	// exchange |f0| and |f1|+	csel	x14, x14, x19,     hs+	csel	x13, x13, x15,       hs	// exchange |g0| and |g1|+	csel	x15, x15, x20,     hs+	lsr	x7, x7, #1+	and	x19, x14, x22+	and	x20, x15, x22+	add	x14, x14, x14		// |f1|<<=1+	add	x15, x15, x15		// |g1|<<=1+	sub	x12, x12, x19		// |f0|-=|f1| (or |f0-=0| if |a_| was even)+	sub	x13, x13, x20		// |g0|-=|g1| (or |g0-=0| ...)+	cbnz	x2, .Loop_62_256++	ret+.size	__inner_loop_62_256,.-__inner_loop_62_256
+ c-source/build/elf/ct_inverse_mod_256-x86_64.s view
@@ -0,0 +1,1185 @@+.text	++.globl	ct_inverse_mod_256+.type	ct_inverse_mod_256,@function+.align	32+ct_inverse_mod_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$1072,%rsp+.cfi_adjust_cfa_offset	1072+++	leaq	48+511(%rsp),%rax+	andq	$-512,%rax+	movq	%rdi,32(%rsp)+	movq	%rcx,40(%rsp)++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11++	movq	0(%rdx),%r12+	movq	8(%rdx),%r13+	movq	16(%rdx),%r14+	movq	24(%rdx),%r15++	movq	%r8,0(%rax)+	movq	%r9,8(%rax)+	movq	%r10,16(%rax)+	movq	%r11,24(%rax)++	movq	%r12,32(%rax)+	movq	%r13,40(%rax)+	movq	%r14,48(%rax)+	movq	%r15,56(%rax)+	movq	%rax,%rsi+++	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+++	movq	%rdx,64(%rdi)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+++	movq	%rdx,72(%rdi)+++	xorq	$256,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31++++	movq	64(%rsi),%r8+	movq	104(%rsi),%r12+	movq	%r8,%r9+	imulq	0(%rsp),%r8+	movq	%r12,%r13+	imulq	8(%rsp),%r12+	addq	%r12,%r8+	movq	%r8,32(%rdi)+	sarq	$63,%r8+	movq	%r8,40(%rdi)+	movq	%r8,48(%rdi)+	movq	%r8,56(%rdi)+	movq	%r8,64(%rdi)+	leaq	64(%rsi),%rsi++	imulq	%rdx,%r9+	imulq	%rcx,%r13+	addq	%r13,%r9+	movq	%r9,72(%rdi)+	sarq	$63,%r9+	movq	%r9,80(%rdi)+	movq	%r9,88(%rdi)+	movq	%r9,96(%rdi)+	movq	%r9,104(%rdi)+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_256x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_256x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_256x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_256x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_256x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_256x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_256x63+	sarq	$63,%rbp+	movq	%rbp,40(%rdi)+	movq	%rbp,48(%rdi)+	movq	%rbp,56(%rdi)+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_512x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_512x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_512x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_512x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_512x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_512x63++	xorq	$256+64,%rsi+	movl	$47,%edx++	movq	0(%rsi),%r8++	movq	32(%rsi),%r10++	call	__inner_loop_62_256++++++++	leaq	64(%rsi),%rsi++++++	movq	%r12,%rdx+	movq	%r13,%rcx+	movq	32(%rsp),%rdi+	call	__smulq_512x63+	adcq	%rbp,%rdx++	movq	40(%rsp),%rsi+	movq	%rdx,%rax+	sarq	$63,%rdx++	movq	%rdx,%r8+	movq	%rdx,%r9+	andq	0(%rsi),%r8+	movq	%rdx,%r10+	andq	8(%rsi),%r9+	andq	16(%rsi),%r10+	andq	24(%rsi),%rdx++	addq	%r8,%r12+	adcq	%r9,%r13+	adcq	%r10,%r14+	adcq	%rdx,%r15+	adcq	$0,%rax++	movq	%rax,%rdx+	negq	%rax+	orq	%rax,%rdx+	sarq	$63,%rax++	movq	%rdx,%r8+	movq	%rdx,%r9+	andq	0(%rsi),%r8+	movq	%rdx,%r10+	andq	8(%rsi),%r9+	andq	16(%rsi),%r10+	andq	24(%rsi),%rdx++	xorq	%rax,%r8+	xorq	%rcx,%rcx+	xorq	%rax,%r9+	subq	%rax,%rcx+	xorq	%rax,%r10+	xorq	%rax,%rdx+	addq	%rcx,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%rdx++	addq	%r8,%r12+	adcq	%r9,%r13+	adcq	%r10,%r14+	adcq	%rdx,%r15++	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)+	movq	%r14,48(%rdi)+	movq	%r15,56(%rdi)++	leaq	1072(%rsp),%r8+	movq	0(%r8),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-1072-8*6++	.byte	0xf3,0xc3+.cfi_endproc	+.size	ct_inverse_mod_256,.-ct_inverse_mod_256+.type	__smulq_512x63,@function+.align	32+__smulq_512x63:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%rbp++	movq	%rdx,%rbx+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbx+	addq	%rax,%rbx++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%rbp+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%rbp++	mulq	%rbx+	movq	%rax,0(%rdi)+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbx+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%r9,8(%rdi)+	movq	%rdx,%r10+	mulq	%rbx+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%r10,16(%rdi)+	movq	%rdx,%r11+	andq	%rbx,%rbp+	negq	%rbp+	mulq	%rbx+	addq	%rax,%r11+	adcq	%rdx,%rbp+	movq	%r11,24(%rdi)++	movq	40(%rsi),%r8+	movq	48(%rsi),%r9+	movq	56(%rsi),%r10+	movq	64(%rsi),%r11+	movq	72(%rsi),%r12+	movq	80(%rsi),%r13+	movq	88(%rsi),%r14+	movq	96(%rsi),%r15++	movq	%rcx,%rdx+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rcx+	addq	%rax,%rcx++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	xorq	%rdx,%r14+	xorq	%rdx,%r15+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13+	adcq	$0,%r14+	adcq	$0,%r15++	mulq	%rcx+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rcx+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rcx+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rcx+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	mulq	%rcx+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	mulq	%rcx+	addq	%rax,%r13+	movq	%r14,%rax+	adcq	$0,%rdx+	movq	%rdx,%r14+	mulq	%rcx+	addq	%rax,%r14+	movq	%r15,%rax+	adcq	$0,%rdx+	movq	%rdx,%r15+	imulq	%rcx+	addq	%rax,%r15+	adcq	$0,%rdx++	movq	%rbp,%rbx+	sarq	$63,%rbp++	addq	0(%rdi),%r8+	adcq	8(%rdi),%r9+	adcq	16(%rdi),%r10+	adcq	24(%rdi),%r11+	adcq	%rbx,%r12+	adcq	%rbp,%r13+	adcq	%rbp,%r14+	adcq	%rbp,%r15++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)+	movq	%r14,48(%rdi)+	movq	%r15,56(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+.size	__smulq_512x63,.-__smulq_512x63++.type	__smulq_256x63,@function+.align	32+__smulq_256x63:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0+0(%rsi),%r8+	movq	0+8(%rsi),%r9+	movq	0+16(%rsi),%r10+	movq	0+24(%rsi),%r11+	movq	0+32(%rsi),%rbp++	movq	%rdx,%rbx+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbx+	addq	%rax,%rbx++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%rbp+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%rbp++	mulq	%rbx+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbx+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rbx+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	andq	%rbx,%rbp+	negq	%rbp+	mulq	%rbx+	addq	%rax,%r11+	adcq	%rdx,%rbp+	movq	%rcx,%rdx+	movq	40+0(%rsi),%r12+	movq	40+8(%rsi),%r13+	movq	40+16(%rsi),%r14+	movq	40+24(%rsi),%r15+	movq	40+32(%rsi),%rcx++	movq	%rdx,%rbx+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbx+	addq	%rax,%rbx++	xorq	%rdx,%r12+	xorq	%rdx,%r13+	xorq	%rdx,%r14+	xorq	%rdx,%r15+	xorq	%rdx,%rcx+	addq	%r12,%rax+	adcq	$0,%r13+	adcq	$0,%r14+	adcq	$0,%r15+	adcq	$0,%rcx++	mulq	%rbx+	movq	%rax,%r12+	movq	%r13,%rax+	movq	%rdx,%r13+	mulq	%rbx+	addq	%rax,%r13+	movq	%r14,%rax+	adcq	$0,%rdx+	movq	%rdx,%r14+	mulq	%rbx+	addq	%rax,%r14+	movq	%r15,%rax+	adcq	$0,%rdx+	movq	%rdx,%r15+	andq	%rbx,%rcx+	negq	%rcx+	mulq	%rbx+	addq	%rax,%r15+	adcq	%rdx,%rcx+	addq	%r12,%r8+	adcq	%r13,%r9+	adcq	%r14,%r10+	adcq	%r15,%r11+	adcq	%rcx,%rbp++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%rbp,32(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+.size	__smulq_256x63,.-__smulq_256x63+.type	__smulq_256_n_shift_by_31,@function+.align	32+__smulq_256_n_shift_by_31:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	%rdx,0(%rdi)+	movq	%rcx,8(%rdi)+	movq	%rdx,%rbp+	movq	0+0(%rsi),%r8+	movq	0+8(%rsi),%r9+	movq	0+16(%rsi),%r10+	movq	0+24(%rsi),%r11++	movq	%rbp,%rbx+	sarq	$63,%rbp+	xorq	%rax,%rax+	subq	%rbp,%rax++	xorq	%rbp,%rbx+	addq	%rax,%rbx++	xorq	%rbp,%r8+	xorq	%rbp,%r9+	xorq	%rbp,%r10+	xorq	%rbp,%r11+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11++	mulq	%rbx+	movq	%rax,%r8+	movq	%r9,%rax+	andq	%rbx,%rbp+	negq	%rbp+	movq	%rdx,%r9+	mulq	%rbx+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rbx+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rbx+	addq	%rax,%r11+	adcq	%rdx,%rbp+	movq	32+0(%rsi),%r12+	movq	32+8(%rsi),%r13+	movq	32+16(%rsi),%r14+	movq	32+24(%rsi),%r15++	movq	%rcx,%rbx+	sarq	$63,%rcx+	xorq	%rax,%rax+	subq	%rcx,%rax++	xorq	%rcx,%rbx+	addq	%rax,%rbx++	xorq	%rcx,%r12+	xorq	%rcx,%r13+	xorq	%rcx,%r14+	xorq	%rcx,%r15+	addq	%r12,%rax+	adcq	$0,%r13+	adcq	$0,%r14+	adcq	$0,%r15++	mulq	%rbx+	movq	%rax,%r12+	movq	%r13,%rax+	andq	%rbx,%rcx+	negq	%rcx+	movq	%rdx,%r13+	mulq	%rbx+	addq	%rax,%r13+	movq	%r14,%rax+	adcq	$0,%rdx+	movq	%rdx,%r14+	mulq	%rbx+	addq	%rax,%r14+	movq	%r15,%rax+	adcq	$0,%rdx+	movq	%rdx,%r15+	mulq	%rbx+	addq	%rax,%r15+	adcq	%rdx,%rcx+	addq	%r12,%r8+	adcq	%r13,%r9+	adcq	%r14,%r10+	adcq	%r15,%r11+	adcq	%rcx,%rbp++	movq	0(%rdi),%rdx+	movq	8(%rdi),%rcx++	shrdq	$31,%r9,%r8+	shrdq	$31,%r10,%r9+	shrdq	$31,%r11,%r10+	shrdq	$31,%rbp,%r11++	sarq	$63,%rbp+	xorq	%rax,%rax+	subq	%rbp,%rax++	xorq	%rbp,%r8+	xorq	%rbp,%r9+	xorq	%rbp,%r10+	xorq	%rbp,%r11+	addq	%rax,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)++	xorq	%rbp,%rdx+	xorq	%rbp,%rcx+	addq	%rax,%rdx+	addq	%rax,%rcx++	.byte	0xf3,0xc3+.cfi_endproc+.size	__smulq_256_n_shift_by_31,.-__smulq_256_n_shift_by_31+.type	__ab_approximation_31_256,@function+.align	32+__ab_approximation_31_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	24(%rsi),%r9+	movq	56(%rsi),%r11+	movq	16(%rsi),%rbx+	movq	48(%rsi),%rbp+	movq	8(%rsi),%r8+	movq	40(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	movq	0(%rsi),%r8+	cmovzq	%r10,%rbp+	movq	32(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	cmovzq	%r10,%rbp++	movq	%r9,%rax+	orq	%r11,%rax+	bsrq	%rax,%rcx+	leaq	1(%rcx),%rcx+	cmovzq	%r8,%r9+	cmovzq	%r10,%r11+	cmovzq	%rax,%rcx+	negq	%rcx+++	shldq	%cl,%rbx,%r9+	shldq	%cl,%rbp,%r11++	movl	$0x7FFFFFFF,%eax+	andq	%rax,%r8+	andq	%rax,%r10+	notq	%rax+	andq	%rax,%r9+	andq	%rax,%r11+	orq	%r9,%r8+	orq	%r11,%r10++	jmp	__inner_loop_31_256++	.byte	0xf3,0xc3+.cfi_endproc+.size	__ab_approximation_31_256,.-__ab_approximation_31_256+.type	__inner_loop_31_256,@function+.align	32+__inner_loop_31_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	$0x7FFFFFFF80000000,%rcx+	movq	$0x800000007FFFFFFF,%r13+	movq	$0x7FFFFFFF7FFFFFFF,%r15++.Loop_31_256:+	cmpq	%r10,%r8+	movq	%r8,%rax+	movq	%r10,%rbx+	movq	%rcx,%rbp+	movq	%r13,%r14+	cmovbq	%r10,%r8+	cmovbq	%rax,%r10+	cmovbq	%r13,%rcx+	cmovbq	%rbp,%r13++	subq	%r10,%r8+	subq	%r13,%rcx+	addq	%r15,%rcx++	testq	$1,%rax+	cmovzq	%rax,%r8+	cmovzq	%rbx,%r10+	cmovzq	%rbp,%rcx+	cmovzq	%r14,%r13++	shrq	$1,%r8+	addq	%r13,%r13+	subq	%r15,%r13+	subl	$1,%edx+	jnz	.Loop_31_256++	shrq	$32,%r15+	movl	%ecx,%edx+	movl	%r13d,%r12d+	shrq	$32,%rcx+	shrq	$32,%r13+	subq	%r15,%rdx+	subq	%r15,%rcx+	subq	%r15,%r12+	subq	%r15,%r13++	.byte	0xf3,0xc3+.cfi_endproc+.size	__inner_loop_31_256,.-__inner_loop_31_256++.type	__inner_loop_62_256,@function+.align	32+__inner_loop_62_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movl	%edx,%r15d+	movq	$1,%rdx+	xorq	%rcx,%rcx+	xorq	%r12,%r12+	movq	%rdx,%r13+	movq	%rdx,%r14++.Loop_62_256:+	xorq	%rax,%rax+	testq	%r14,%r8+	movq	%r10,%rbx+	cmovnzq	%r10,%rax+	subq	%r8,%rbx+	movq	%r8,%rbp+	subq	%rax,%r8+	cmovcq	%rbx,%r8+	cmovcq	%rbp,%r10+	movq	%rdx,%rax+	cmovcq	%r12,%rdx+	cmovcq	%rax,%r12+	movq	%rcx,%rbx+	cmovcq	%r13,%rcx+	cmovcq	%rbx,%r13+	xorq	%rax,%rax+	xorq	%rbx,%rbx+	shrq	$1,%r8+	testq	%r14,%rbp+	cmovnzq	%r12,%rax+	cmovnzq	%r13,%rbx+	addq	%r12,%r12+	addq	%r13,%r13+	subq	%rax,%rdx+	subq	%rbx,%rcx+	subl	$1,%r15d+	jnz	.Loop_62_256++	.byte	0xf3,0xc3+.cfi_endproc+.size	__inner_loop_62_256,.-__inner_loop_62_256++.section	.note.GNU-stack,"",@progbits+.section	.note.gnu.property,"a",@note+	.long	4,2f-1f,5+	.byte	0x47,0x4E,0x55,0+1:	.long	0xc0000002,4,3+.align	8+2:
+ c-source/build/elf/ct_inverse_mod_384-armv8.S view
@@ -0,0 +1,717 @@+.text++.globl	ct_inverse_mod_383+.type	ct_inverse_mod_383, %function+.align	5+ct_inverse_mod_383:+	.inst	0xd503233f+	stp	x29, x30, [sp,#-128]!+	add	x29, sp, #0+	stp	x19, x20, [sp,#16]+	stp	x21, x22, [sp,#32]+	stp	x23, x24, [sp,#48]+	stp	x25, x26, [sp,#64]+	stp	x27, x28, [sp,#80]+	sub	sp, sp, #1040++	ldp	x22,   x4, [x1,#8*0]+	ldp	x5, x6, [x1,#8*2]+	ldp	x7, x8, [x1,#8*4]++	add	x1, sp, #16+511	// find closest 512-byte-aligned spot+	and	x1, x1, #-512	// in the frame...+	stp	x0, x3, [sp]++	ldp	x9, x10, [x2,#8*0]+	ldp	x11, x12, [x2,#8*2]+	ldp	x13, x14, [x2,#8*4]++	stp	x22,   x4, [x1,#8*0]	// copy input to |a|+	stp	x5, x6, [x1,#8*2]+	stp	x7, x8, [x1,#8*4]+	stp	x9, x10, [x1,#8*6]	// copy modulus to |b|+	stp	x11, x12, [x1,#8*8]+	stp	x13, x14, [x1,#8*10]++	////////////////////////////////////////// first iteration+	mov	x2, #62+	bl	.Lab_approximation_62_loaded++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	str	x15,[x0,#8*12]		// initialize |u| with |f0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to dst |b|+	bl	__smul_383_n_shift_by_62+	str	x15, [x0,#8*12]		// initialize |v| with |f1|++	////////////////////////////////////////// second iteration+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	ldr	x7, [x1,#8*12]	// |u|+	ldr	x8, [x1,#8*18]	// |v|+	mul	x3, x20, x7		// |u|*|f0|+	smulh	x4, x20, x7+	mul	x5, x21, x8		// |v|*|g0|+	smulh	x6, x21, x8+	adds	x3, x3, x5+	adc	x4, x4, x6+	stp	x3, x4, [x0,#8*6]+	asr	x5, x4, #63		// sign extenstion+	stp	x5, x5, [x0,#8*8]+	stp	x5, x5, [x0,#8*10]++	mul	x3, x15, x7		// |u|*|f1|+	smulh	x4, x15, x7+	mul	x5, x16, x8		// |v|*|g1|+	smulh	x6, x16, x8+	adds	x3, x3, x5+	adc	x4, x4, x6+	stp	x3, x4, [x0,#8*12]+	asr	x5, x4, #63		// sign extenstion+	stp	x5, x5, [x0,#8*14]+	stp	x5, x5, [x0,#8*16]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	asr	x27, x27, #63		// sign extension+	stp	x27, x27, [x0,#8*6]+	stp	x27, x27, [x0,#8*8]+	stp	x27, x27, [x0,#8*10]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	bl	__smul_767x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	bl	__smul_767x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	bl	__smul_767x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	bl	__smul_767x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	bl	__smul_767x63_tail+	////////////////////////////////////////// iteration before last+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	//bl	__ab_approximation_62		// |a| and |b| are exact,+	ldp	x3, x8, [x1,#8*0]	// just load+	ldp	x9, x14, [x1,#8*6]+	bl	__inner_loop_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	str	x3, [x0,#8*0]+	str	x9, [x0,#8*6]++	mov	x20, x15			// exact |f0|+	mov	x21, x16			// exact |g0|+	mov	x15, x17+	mov	x16, x19+	add	x0, x0, #8*12	// pointer to dst |u|+	bl	__smul_383x63++	mov	x20, x15			// exact |f1|+	mov	x21, x16			// exact |g1|+	add	x0, x0, #8*6	// pointer to dst |v|+	bl	__smul_383x63+	bl	__smul_767x63_tail++	////////////////////////////////////////// last iteration+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #22			// 766 % 62+	//bl	__ab_approximation_62		// |a| and |b| are exact,+	ldr	x3, [x1,#8*0]		// just load+	eor	x8, x8, x8+	ldr	x9, [x1,#8*6]+	eor	x14, x14, x14+	bl	__inner_loop_62++	mov	x20, x17+	mov	x21, x19+	ldp	x0, x15, [sp]		// original out_ptr and n_ptr+	bl	__smul_383x63+	bl	__smul_767x63_tail+	ldr	x30, [x29,#8]++	asr	x22, x8, #63		// sign as mask+	ldp	x9, x10, [x15,#8*0]+	ldp	x11, x12, [x15,#8*2]+	ldp	x13, x14, [x15,#8*4]++	and	x9, x9, x22		// add mod<<384 conditionally+	and	x10, x10, x22+	adds	x3, x3, x9+	and	x11, x11, x22+	adcs	x4, x4, x10+	and	x12, x12, x22+	adcs	x5, x5, x11+	and	x13, x13, x22+	adcs	x6, x6, x12+	and	x14, x14, x22+	stp	x3, x4, [x0,#8*6]+	adcs	x7, x7, x13+	stp	x5, x6, [x0,#8*8]+	adc	x8, x8, x14+	stp	x7, x8, [x0,#8*10]++	add	sp, sp, #1040+	ldp	x19, x20, [x29,#16]+	ldp	x21, x22, [x29,#32]+	ldp	x23, x24, [x29,#48]+	ldp	x25, x26, [x29,#64]+	ldp	x27, x28, [x29,#80]+	ldr	x29, [sp],#128+	.inst	0xd50323bf+	ret+.size	ct_inverse_mod_383,.-ct_inverse_mod_383++////////////////////////////////////////////////////////////////////////+// see corresponding commentary in ctx_inverse_mod_384-x86_64...+.type	__smul_383x63, %function+.align	5+__smul_383x63:+	ldp	x3, x4, [x1,#8*0+96]	// load |u| (or |v|)+	asr	x17, x20, #63		// |f_|'s sign as mask (or |g_|'s)+	ldp	x5, x6, [x1,#8*2+96]+	eor	x20, x20, x17		// conditionally negate |f_| (or |g_|)+	ldp	x7, x8, [x1,#8*4+96]++	eor	x3, x3, x17	// conditionally negate |u| (or |v|)+	sub	x20, x20, x17+	eor	x4, x4, x17+	adds	x3, x3, x17, lsr#63+	eor	x5, x5, x17+	adcs	x4, x4, xzr+	eor	x6, x6, x17+	adcs	x5, x5, xzr+	eor	x7, x7, x17+	adcs	x6, x6, xzr+	umulh	x22, x3, x20+	eor	x8, x8, x17+	umulh	x23, x4, x20+	adcs	x7, x7, xzr+	umulh	x24, x5, x20+	adcs	x8, x8, xzr+	umulh	x25, x6, x20+	umulh	x26, x7, x20+	mul	x3, x3, x20+	mul	x4, x4, x20+	mul	x5, x5, x20+	adds	x4, x4, x22+	mul	x6, x6, x20+	adcs	x5, x5, x23+	mul	x7, x7, x20+	adcs	x6, x6, x24+	mul	x27,x8, x20+	adcs	x7, x7, x25+	adcs	x27,x27,x26+	adc	x2, xzr, xzr+	ldp	x9, x10, [x1,#8*0+144]	// load |u| (or |v|)+	asr	x17, x21, #63		// |f_|'s sign as mask (or |g_|'s)+	ldp	x11, x12, [x1,#8*2+144]+	eor	x21, x21, x17		// conditionally negate |f_| (or |g_|)+	ldp	x13, x14, [x1,#8*4+144]++	eor	x9, x9, x17	// conditionally negate |u| (or |v|)+	sub	x21, x21, x17+	eor	x10, x10, x17+	adds	x9, x9, x17, lsr#63+	eor	x11, x11, x17+	adcs	x10, x10, xzr+	eor	x12, x12, x17+	adcs	x11, x11, xzr+	eor	x13, x13, x17+	adcs	x12, x12, xzr+	umulh	x22, x9, x21+	eor	x14, x14, x17+	umulh	x23, x10, x21+	adcs	x13, x13, xzr+	umulh	x24, x11, x21+	adcs	x14, x14, xzr+	umulh	x25, x12, x21+	adc	x19, xzr, xzr		// used in __smul_767x63_tail+	umulh	x26, x13, x21+	mul	x9, x9, x21+	mul	x10, x10, x21+	mul	x11, x11, x21+	adds	x10, x10, x22+	mul	x12, x12, x21+	adcs	x11, x11, x23+	mul	x13, x13, x21+	adcs	x12, x12, x24+	mul	x28,x14, x21+	adcs	x13, x13, x25+	adcs	x28,x28,x26+	adc	x2, x2, xzr++	adds	x3, x3, x9+	adcs	x4, x4, x10+	adcs	x5, x5, x11+	adcs	x6, x6, x12+	stp	x3, x4, [x0,#8*0]+	adcs	x7, x7, x13+	stp	x5, x6, [x0,#8*2]+	adcs	x27,   x27,   x28+	stp	x7, x27,   [x0,#8*4]+	adc	x28,   x2,   xzr	// used in __smul_767x63_tail++	ret+.size	__smul_383x63,.-__smul_383x63++.type	__smul_767x63_tail, %function+.align	5+__smul_767x63_tail:+	smulh	x27,   x8, x20+	ldp	x3, x4, [x1,#8*24]	// load rest of |v|+	umulh	x14,x14, x21+	ldp	x5, x6, [x1,#8*26]+	ldp	x7, x8, [x1,#8*28]++	eor	x3, x3, x17	// conditionally negate rest of |v|+	eor	x4, x4, x17+	eor	x5, x5, x17+	adds	x3, x3, x19+	eor	x6, x6, x17+	adcs	x4, x4, xzr+	eor	x7, x7, x17+	adcs	x5, x5, xzr+	eor	x8, x8, x17+	adcs	x6, x6, xzr+	umulh	x22, x3, x21+	adcs	x7, x7, xzr+	umulh	x23, x4, x21+	adc	x8, x8, xzr++	umulh	x24, x5, x21+	add	x14, x14, x28+	umulh	x25, x6, x21+	asr	x28, x27, #63+	umulh	x26, x7, x21+	mul	x3, x3, x21+	mul	x4, x4, x21+	mul	x5, x5, x21+	adds	x3, x3, x14+	mul	x6, x6, x21+	adcs	x4, x4, x22+	mul	x7, x7, x21+	adcs	x5, x5, x23+	mul	x8, x8, x21+	adcs	x6, x6, x24+	adcs	x7, x7, x25+	adc	x8, x8, x26++	adds	x3, x3, x27+	adcs	x4, x4, x28+	adcs	x5, x5, x28+	adcs	x6, x6, x28+	stp	x3, x4, [x0,#8*6]+	adcs	x7, x7, x28+	stp	x5, x6, [x0,#8*8]+	adc	x8, x8, x28+	stp	x7, x8, [x0,#8*10]++	ret+.size	__smul_767x63_tail,.-__smul_767x63_tail++.type	__smul_383_n_shift_by_62, %function+.align	5+__smul_383_n_shift_by_62:+	ldp	x3, x4, [x1,#8*0+0]	// load |a| (or |b|)+	asr	x28, x15, #63		// |f0|'s sign as mask (or |g0|'s)+	ldp	x5, x6, [x1,#8*2+0]+	eor	x2, x15, x28	// conditionally negate |f0| (or |g0|)+	ldp	x7, x8, [x1,#8*4+0]++	eor	x3, x3, x28	// conditionally negate |a| (or |b|)+	sub	x2, x2, x28+	eor	x4, x4, x28+	adds	x3, x3, x28, lsr#63+	eor	x5, x5, x28+	adcs	x4, x4, xzr+	eor	x6, x6, x28+	adcs	x5, x5, xzr+	eor	x7, x7, x28+	umulh	x22, x3, x2+	adcs	x6, x6, xzr+	umulh	x23, x4, x2+	eor	x8, x8, x28+	umulh	x24, x5, x2+	adcs	x7, x7, xzr+	umulh	x25, x6, x2+	adc	x8, x8, xzr++	umulh	x26, x7, x2+	smulh	x27, x8, x2+	mul	x3, x3, x2+	mul	x4, x4, x2+	mul	x5, x5, x2+	adds	x4, x4, x22+	mul	x6, x6, x2+	adcs	x5, x5, x23+	mul	x7, x7, x2+	adcs	x6, x6, x24+	mul	x8, x8, x2+	adcs	x7, x7, x25+	adcs	x8, x8 ,x26+	adc	x27, x27, xzr+	ldp	x9, x10, [x1,#8*0+48]	// load |a| (or |b|)+	asr	x28, x16, #63		// |f0|'s sign as mask (or |g0|'s)+	ldp	x11, x12, [x1,#8*2+48]+	eor	x2, x16, x28	// conditionally negate |f0| (or |g0|)+	ldp	x13, x14, [x1,#8*4+48]++	eor	x9, x9, x28	// conditionally negate |a| (or |b|)+	sub	x2, x2, x28+	eor	x10, x10, x28+	adds	x9, x9, x28, lsr#63+	eor	x11, x11, x28+	adcs	x10, x10, xzr+	eor	x12, x12, x28+	adcs	x11, x11, xzr+	eor	x13, x13, x28+	umulh	x22, x9, x2+	adcs	x12, x12, xzr+	umulh	x23, x10, x2+	eor	x14, x14, x28+	umulh	x24, x11, x2+	adcs	x13, x13, xzr+	umulh	x25, x12, x2+	adc	x14, x14, xzr++	umulh	x26, x13, x2+	smulh	x28, x14, x2+	mul	x9, x9, x2+	mul	x10, x10, x2+	mul	x11, x11, x2+	adds	x10, x10, x22+	mul	x12, x12, x2+	adcs	x11, x11, x23+	mul	x13, x13, x2+	adcs	x12, x12, x24+	mul	x14, x14, x2+	adcs	x13, x13, x25+	adcs	x14, x14 ,x26+	adc	x28, x28, xzr+	adds	x3, x3, x9+	adcs	x4, x4, x10+	adcs	x5, x5, x11+	adcs	x6, x6, x12+	adcs	x7, x7, x13+	adcs	x8, x8, x14+	adc	x9, x27,   x28++	extr	x3, x4, x3, #62+	extr	x4, x5, x4, #62+	extr	x5, x6, x5, #62+	asr	x28, x9, #63+	extr	x6, x7, x6, #62+	extr	x7, x8, x7, #62+	extr	x8, x9, x8, #62++	eor	x3, x3, x28+	eor	x4, x4, x28+	adds	x3, x3, x28, lsr#63+	eor	x5, x5, x28+	adcs	x4, x4, xzr+	eor	x6, x6, x28+	adcs	x5, x5, xzr+	eor	x7, x7, x28+	adcs	x6, x6, xzr+	eor	x8, x8, x28+	stp	x3, x4, [x0,#8*0]+	adcs	x7, x7, xzr+	stp	x5, x6, [x0,#8*2]+	adc	x8, x8, xzr+	stp	x7, x8, [x0,#8*4]++	eor	x15, x15, x28+	eor	x16, x16, x28+	sub	x15, x15, x28+	sub	x16, x16, x28++	ret+.size	__smul_383_n_shift_by_62,.-__smul_383_n_shift_by_62+.type	__ab_approximation_62, %function+.align	4+__ab_approximation_62:+	ldp	x7, x8, [x1,#8*4]+	ldp	x13, x14, [x1,#8*10]+	ldp	x5, x6, [x1,#8*2]+	ldp	x11, x12, [x1,#8*8]++.Lab_approximation_62_loaded:+	orr	x22, x8, x14	// check top-most limbs, ...+	cmp	x22, #0+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	csel	x7, x7, x6, ne+	orr	x22, x8, x14	// ... ones before top-most, ...+	csel	x13, x13, x12, ne++	ldp	x3, x4, [x1,#8*0]+	ldp	x9, x10, [x1,#8*6]++	cmp	x22, #0+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	csel	x7, x7, x5, ne+	orr	x22, x8, x14	// ... and ones before that ...+	csel	x13, x13, x11, ne++	cmp	x22, #0+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	csel	x7, x7, x4, ne+	orr	x22, x8, x14+	csel	x13, x13, x10, ne++	clz	x22, x22+	cmp	x22, #64+	csel	x22, x22, xzr, ne+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	neg	x23, x22++	lslv	x8, x8, x22	// align high limbs to the left+	lslv	x14, x14, x22+	lsrv	x7, x7, x23+	lsrv	x13, x13, x23+	and	x7, x7, x23, asr#6+	and	x13, x13, x23, asr#6+	orr	x8, x8, x7+	orr	x14, x14, x13++	b	__inner_loop_62+	ret+.size	__ab_approximation_62,.-__ab_approximation_62+.type	__inner_loop_62, %function+.align	4+__inner_loop_62:+	mov	x15, #1		// |f0|=1+	mov	x16, #0		// |g0|=0+	mov	x17, #0		// |f1|=0+	mov	x19, #1		// |g1|=1++.Loop_62:+	sbfx	x28, x3, #0, #1	// if |a_| is odd, then we'll be subtracting+	sub	x2, x2, #1+	subs	x24, x9, x3	// |b_|-|a_|+	and	x22, x9, x28+	sbc	x25, x14, x8+	and	x23, x14, x28+	subs	x26, x3, x22	// |a_|-|b_| (or |a_|-0 if |a_| was even)+	mov	x22, x15+	sbcs	x27, x8, x23+	mov	x23, x16+	csel	x9, x9, x3, hs	// |b_| = |a_|+	csel	x14, x14, x8, hs+	csel	x3, x26, x24, hs	// borrow means |a_|<|b_|, replace with |b_|-|a_|+	csel	x8, x27, x25, hs+	csel	x15, x15, x17,       hs	// exchange |f0| and |f1|+	csel	x17, x17, x22,     hs+	csel	x16, x16, x19,       hs	// exchange |g0| and |g1|+	csel	x19, x19, x23,     hs+	extr	x3, x8, x3, #1+	lsr	x8, x8, #1+	and	x22, x17, x28+	and	x23, x19, x28+	add	x17, x17, x17		// |f1|<<=1+	add	x19, x19, x19		// |g1|<<=1+	sub	x15, x15, x22		// |f0|-=|f1| (or |f0-=0| if |a_| was even)+	sub	x16, x16, x23		// |g0|-=|g1| (or |g0-=0| ...)+	cbnz	x2, .Loop_62++	ret+.size	__inner_loop_62,.-__inner_loop_62
+ c-source/build/elf/ct_is_square_mod_384-armv8.S view
@@ -0,0 +1,324 @@+.text++.globl	ct_is_square_mod_384+.type	ct_is_square_mod_384, %function+.align	5+ct_is_square_mod_384:+	.inst	0xd503233f+	stp	x29, x30, [sp,#-128]!+	add	x29, sp, #0+	stp	x19, x20, [sp,#16]+	stp	x21, x22, [sp,#32]+	stp	x23, x24, [sp,#48]+	stp	x25, x26, [sp,#64]+	stp	x27, x28, [sp,#80]+	sub	sp, sp, #512++	ldp	x3, x4, [x0,#8*0]		// load input+	ldp	x5, x6, [x0,#8*2]+	ldp	x7, x8, [x0,#8*4]++	add	x0, sp, #255	// find closest 256-byte-aligned spot+	and	x0, x0, #-256	// in the frame...++	ldp	x9, x10, [x1,#8*0]		// load modulus+	ldp	x11, x12, [x1,#8*2]+	ldp	x13, x14, [x1,#8*4]++	stp	x3, x4, [x0,#8*6]	// copy input to |a|+	stp	x5, x6, [x0,#8*8]+	stp	x7, x8, [x0,#8*10]+	stp	x9, x10, [x0,#8*0]	// copy modulus to |b|+	stp	x11, x12, [x0,#8*2]+	stp	x13, x14, [x0,#8*4]++	eor	x2, x2, x2			// init the .Legendre symbol+	mov	x15, #24			// 24 is 768/30-1+	b	.Loop_is_square++.align	4+.Loop_is_square:+	bl	__ab_approximation_30+	sub	x15, x15, #1++	eor	x1, x0, #128		// pointer to dst |b|+	bl	__smul_384_n_shift_by_30++	mov	x19, x16			// |f0|+	mov	x20, x17			// |g0|+	add	x1, x1, #8*6	// pointer to dst |a|+	bl	__smul_384_n_shift_by_30++	ldp	x9, x10, [x1,#-8*6]+	eor	x0, x0, #128		// flip-flop src |a|b|+	and	x27, x27, x9		// if |a| was negative,+	add	x2, x2, x27, lsr#1		// adjust |L|++	cbnz	x15, .Loop_is_square++	////////////////////////////////////////// last iteration+	//bl	__ab_approximation_30		// |a| and |b| are exact,+	//ldr	x8, [x0,#8*6]		// and loaded+	//ldr	x14, [x0,#8*0]+	mov	x15, #48			// 48 is 768%30 + 30+	bl	__inner_loop_48+	ldr	x30, [x29,#8]++	and	x0, x2, #1+	eor	x0, x0, #1++	add	sp, sp, #512+	ldp	x19, x20, [x29,#16]+	ldp	x21, x22, [x29,#32]+	ldp	x23, x24, [x29,#48]+	ldp	x25, x26, [x29,#64]+	ldp	x27, x28, [x29,#80]+	ldr	x29, [sp],#128+	.inst	0xd50323bf+	ret+.size	ct_is_square_mod_384,.-ct_is_square_mod_384++.type	__smul_384_n_shift_by_30, %function+.align	5+__smul_384_n_shift_by_30:+	ldp	x3, x4, [x0,#8*0+0]	// load |b| (or |a|)+	asr	x27, x20, #63		// |g1|'s sign as mask (or |f1|'s)+	ldp	x5, x6, [x0,#8*2+0]+	eor	x20, x20, x27		// conditionally negate |g1| (or |f1|)+	ldp	x7, x8, [x0,#8*4+0]++	eor	x3, x3, x27	// conditionally negate |b| (or |a|)+	sub	x20, x20, x27+	eor	x4, x4, x27+	adds	x3, x3, x27, lsr#63+	eor	x5, x5, x27+	adcs	x4, x4, xzr+	eor	x6, x6, x27+	adcs	x5, x5, xzr+	eor	x7, x7, x27+	umulh	x21, x3, x20+	adcs	x6, x6, xzr+	umulh	x22, x4, x20+	eor	x8, x8, x27+	umulh	x23, x5, x20+	adcs	x7, x7, xzr+	umulh	x24, x6, x20+	adc	x8, x8, xzr++	umulh	x25, x7, x20+	and	x28, x20, x27+	umulh	x26, x8, x20+	neg	x28, x28+	mul	x3, x3, x20+	mul	x4, x4, x20+	mul	x5, x5, x20+	adds	x4, x4, x21+	mul	x6, x6, x20+	adcs	x5, x5, x22+	mul	x7, x7, x20+	adcs	x6, x6, x23+	mul	x8, x8, x20+	adcs	x7, x7, x24+	adcs	x8, x8 ,x25+	adc	x26, x26, x28+	ldp	x9, x10, [x0,#8*0+48]	// load |b| (or |a|)+	asr	x27, x19, #63		// |g1|'s sign as mask (or |f1|'s)+	ldp	x11, x12, [x0,#8*2+48]+	eor	x19, x19, x27		// conditionally negate |g1| (or |f1|)+	ldp	x13, x14, [x0,#8*4+48]++	eor	x9, x9, x27	// conditionally negate |b| (or |a|)+	sub	x19, x19, x27+	eor	x10, x10, x27+	adds	x9, x9, x27, lsr#63+	eor	x11, x11, x27+	adcs	x10, x10, xzr+	eor	x12, x12, x27+	adcs	x11, x11, xzr+	eor	x13, x13, x27+	umulh	x21, x9, x19+	adcs	x12, x12, xzr+	umulh	x22, x10, x19+	eor	x14, x14, x27+	umulh	x23, x11, x19+	adcs	x13, x13, xzr+	umulh	x24, x12, x19+	adc	x14, x14, xzr++	umulh	x25, x13, x19+	and	x28, x19, x27+	umulh	x27, x14, x19+	neg	x28, x28+	mul	x9, x9, x19+	mul	x10, x10, x19+	mul	x11, x11, x19+	adds	x10, x10, x21+	mul	x12, x12, x19+	adcs	x11, x11, x22+	mul	x13, x13, x19+	adcs	x12, x12, x23+	mul	x14, x14, x19+	adcs	x13, x13, x24+	adcs	x14, x14 ,x25+	adc	x27, x27, x28+	adds	x3, x3, x9+	adcs	x4, x4, x10+	adcs	x5, x5, x11+	adcs	x6, x6, x12+	adcs	x7, x7, x13+	adcs	x8, x8, x14+	adc	x9, x26,   x27++	extr	x3, x4, x3, #30+	extr	x4, x5, x4, #30+	extr	x5, x6, x5, #30+	asr	x27, x9, #63+	extr	x6, x7, x6, #30+	extr	x7, x8, x7, #30+	extr	x8, x9, x8, #30++	eor	x3, x3, x27+	eor	x4, x4, x27+	adds	x3, x3, x27, lsr#63+	eor	x5, x5, x27+	adcs	x4, x4, xzr+	eor	x6, x6, x27+	adcs	x5, x5, xzr+	eor	x7, x7, x27+	adcs	x6, x6, xzr+	eor	x8, x8, x27+	stp	x3, x4, [x1,#8*0]+	adcs	x7, x7, xzr+	stp	x5, x6, [x1,#8*2]+	adc	x8, x8, xzr+	stp	x7, x8, [x1,#8*4]++	ret+.size	__smul_384_n_shift_by_30,.-__smul_384_n_shift_by_30+.type	__ab_approximation_30, %function+.align	4+__ab_approximation_30:+	ldp	x13, x14, [x0,#8*4]	// |a| is still in registers+	ldp	x11, x12, [x0,#8*2]++	orr	x21, x8, x14	// check top-most limbs, ...+	cmp	x21, #0+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	csel	x7, x7, x6, ne+	orr	x21, x8, x14	// ... ones before top-most, ...+	csel	x13, x13, x12, ne++	cmp	x21, #0+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	csel	x7, x7, x5, ne+	orr	x21, x8, x14	// ... and ones before that ...+	csel	x13, x13, x11, ne++	cmp	x21, #0+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	csel	x7, x7, x4, ne+	orr	x21, x8, x14	// and one more, ...+	csel	x13, x13, x10, ne++	cmp	x21, #0+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	csel	x7, x7, x3, ne+	orr	x21, x8, x14+	csel	x13, x13, x9, ne++	clz	x21, x21+	cmp	x21, #64+	csel	x21, x21, xzr, ne+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	neg	x22, x21++	lslv	x8, x8, x21	// align high limbs to the left+	lslv	x14, x14, x21+	lsrv	x7, x7, x22+	lsrv	x13, x13, x22+	and	x7, x7, x22, asr#6+	and	x13, x13, x22, asr#6+	orr	x8, x8, x7+	orr	x14, x14, x13++	bfxil	x8, x3, #0, #32+	bfxil	x14, x9, #0, #32++	b	__inner_loop_30+	ret+.size	__ab_approximation_30,.-__ab_approximation_30++.type	__inner_loop_30, %function+.align	4+__inner_loop_30:+	mov	x28, #30+	mov	x17, #0x7FFFFFFF80000000	// |f0|=1, |g0|=0+	mov	x20, #0x800000007FFFFFFF	// |f1|=0, |g1|=1+	mov	x27,#0x7FFFFFFF7FFFFFFF++.Loop_30:+	sbfx	x24, x8, #0, #1	// if |a_| is odd, then we'll be subtracting+	and	x25, x8, x14+	sub	x28, x28, #1+	and	x21, x14, x24++	sub	x22, x14, x8		// |b_|-|a_|+	subs	x23, x8, x21	// |a_|-|b_| (or |a_|-0 if |a_| was even)+	add	x25, x2, x25, lsr#1	// L + (a_ & b_) >> 1+	mov	x21, x20+	csel	x14, x14, x8, hs	// |b_| = |a_|+	csel	x8, x23, x22, hs	// borrow means |a_|<|b_|, replace with |b_|-|a_|+	csel	x20, x20, x17,  hs	// exchange |fg0| and |fg1|+	csel	x17, x17, x21, hs+	csel	x2,   x2,   x25, hs+	lsr	x8, x8, #1+	and	x21, x20, x24+	and	x22, x27, x24+	add	x23, x14, #2+	sub	x17, x17, x21	// |f0|-=|f1| (or |f0-=0| if |a_| was even)+	add	x20, x20, x20	// |f1|<<=1+	add	x2, x2, x23, lsr#2	// "negate" |L| if |b|%8 is 3 or 5+	add	x17, x17, x22+	sub	x20, x20, x27++	cbnz	x28, .Loop_30++	mov	x27, #0x7FFFFFFF+	ubfx	x16, x17, #0, #32+	ubfx	x17, x17, #32, #32+	ubfx	x19, x20, #0, #32+	ubfx	x20, x20, #32, #32+	sub	x16, x16, x27		// remove the bias+	sub	x17, x17, x27+	sub	x19, x19, x27+	sub	x20, x20, x27++	ret+.size	__inner_loop_30,.-__inner_loop_30+.type	__inner_loop_48, %function+.align	4+__inner_loop_48:+.Loop_48:+	sbfx	x24, x3, #0, #1	// if |a_| is odd, then we'll be subtracting+	and	x25, x3, x9+	sub	x15, x15, #1+	and	x21, x9, x24+	sub	x22, x9, x3		// |b_|-|a_|+	subs	x23, x3, x21	// |a_|-|b_| (or |a_|-0 if |a_| was even)+	add	x25, x2, x25, lsr#1+	csel	x9, x9, x3, hs	// |b_| = |a_|+	csel	x3, x23, x22, hs	// borrow means |a_|<|b_|, replace with |b_|-|a_|+	csel	x2,   x2,   x25, hs+	add	x23, x9, #2+	lsr	x3, x3, #1+	add	x2, x2, x23, lsr#2	// "negate" |L| if |b|%8 is 3 or 5++	cbnz	x15, .Loop_48++	ret+.size	__inner_loop_48,.-__inner_loop_48
+ c-source/build/elf/ct_is_square_mod_384-x86_64.s view
@@ -0,0 +1,479 @@+.text	++.globl	ct_is_square_mod_384+.type	ct_is_square_mod_384,@function+.align	32+ct_is_square_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$536,%rsp+.cfi_adjust_cfa_offset	536+++	leaq	24+255(%rsp),%rax+	andq	$-256,%rax++	movq	0(%rdi),%r8+	movq	8(%rdi),%r9+	movq	16(%rdi),%r10+	movq	24(%rdi),%r11+	movq	32(%rdi),%r12+	movq	40(%rdi),%r13++	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%rbx+	movq	24(%rsi),%rcx+	movq	32(%rsi),%rdx+	movq	40(%rsi),%rdi+	movq	%rax,%rsi++	movq	%r8,0(%rax)+	movq	%r9,8(%rax)+	movq	%r10,16(%rax)+	movq	%r11,24(%rax)+	movq	%r12,32(%rax)+	movq	%r13,40(%rax)++	movq	%r14,48(%rax)+	movq	%r15,56(%rax)+	movq	%rbx,64(%rax)+	movq	%rcx,72(%rax)+	movq	%rdx,80(%rax)+	movq	%rdi,88(%rax)++	xorq	%rbp,%rbp+	movl	$24,%ecx+	jmp	.Loop_is_square++.align	32+.Loop_is_square:+	movl	%ecx,16(%rsp)++	call	__ab_approximation_30+	movq	%rax,0(%rsp)+	movq	%rbx,8(%rsp)++	movq	$128+48,%rdi+	xorq	%rsi,%rdi+	call	__smulq_384_n_shift_by_30++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	-48(%rdi),%rdi+	call	__smulq_384_n_shift_by_30++	movl	16(%rsp),%ecx+	xorq	$128,%rsi++	andq	48(%rdi),%r14+	shrq	$1,%r14+	addq	%r14,%rbp++	subl	$1,%ecx+	jnz	.Loop_is_square+++++	movq	48(%rsi),%r9+	call	__inner_loop_48++	movq	$1,%rax+	andq	%rbp,%rax+	xorq	$1,%rax++	leaq	536(%rsp),%r8+	movq	0(%r8),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-536-8*6++	.byte	0xf3,0xc3+.cfi_endproc	+.size	ct_is_square_mod_384,.-ct_is_square_mod_384++.type	__smulq_384_n_shift_by_30,@function+.align	32+__smulq_384_n_shift_by_30:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rdx,%rbx+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbx+	addq	%rax,%rbx++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	movq	%rdx,%r14+	andq	%rbx,%r14+	mulq	%rbx+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbx+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rbx+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rbx+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	mulq	%rbx+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	negq	%r14+	mulq	%rbx+	addq	%rax,%r13+	adcq	%rdx,%r14+	leaq	48(%rsi),%rsi+	movq	%rcx,%rdx++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)+	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rdx,%rbx+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbx+	addq	%rax,%rbx++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	movq	%rdx,%r15+	andq	%rbx,%r15+	mulq	%rbx+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbx+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rbx+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rbx+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	mulq	%rbx+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	negq	%r15+	mulq	%rbx+	addq	%rax,%r13+	adcq	%rdx,%r15+	leaq	-48(%rsi),%rsi++	addq	0(%rdi),%r8+	adcq	8(%rdi),%r9+	adcq	16(%rdi),%r10+	adcq	24(%rdi),%r11+	adcq	32(%rdi),%r12+	adcq	40(%rdi),%r13+	adcq	%r15,%r14++	shrdq	$30,%r9,%r8+	shrdq	$30,%r10,%r9+	shrdq	$30,%r11,%r10+	shrdq	$30,%r12,%r11+	shrdq	$30,%r13,%r12+	shrdq	$30,%r14,%r13++	sarq	$63,%r14+	xorq	%rbx,%rbx+	subq	%r14,%rbx++	xorq	%r14,%r8+	xorq	%r14,%r9+	xorq	%r14,%r10+	xorq	%r14,%r11+	xorq	%r14,%r12+	xorq	%r14,%r13+	addq	%rbx,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+.size	__smulq_384_n_shift_by_30,.-__smulq_384_n_shift_by_30+.type	__ab_approximation_30,@function+.align	32+__ab_approximation_30:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	88(%rsi),%rbx+	movq	80(%rsi),%r15+	movq	72(%rsi),%r14++	movq	%r13,%rax+	orq	%rbx,%rax+	cmovzq	%r12,%r13+	cmovzq	%r15,%rbx+	cmovzq	%r11,%r12+	movq	64(%rsi),%r11+	cmovzq	%r14,%r15++	movq	%r13,%rax+	orq	%rbx,%rax+	cmovzq	%r12,%r13+	cmovzq	%r15,%rbx+	cmovzq	%r10,%r12+	movq	56(%rsi),%r10+	cmovzq	%r11,%r15++	movq	%r13,%rax+	orq	%rbx,%rax+	cmovzq	%r12,%r13+	cmovzq	%r15,%rbx+	cmovzq	%r9,%r12+	movq	48(%rsi),%r9+	cmovzq	%r10,%r15++	movq	%r13,%rax+	orq	%rbx,%rax+	cmovzq	%r12,%r13+	cmovzq	%r15,%rbx+	cmovzq	%r8,%r12+	cmovzq	%r9,%r15++	movq	%r13,%rax+	orq	%rbx,%rax+	bsrq	%rax,%rcx+	leaq	1(%rcx),%rcx+	cmovzq	%r8,%r13+	cmovzq	%r9,%rbx+	cmovzq	%rax,%rcx+	negq	%rcx+++	shldq	%cl,%r12,%r13+	shldq	%cl,%r15,%rbx++	movq	$0xFFFFFFFF00000000,%rax+	movl	%r8d,%r8d+	movl	%r9d,%r9d+	andq	%rax,%r13+	andq	%rax,%rbx+	orq	%r13,%r8+	orq	%rbx,%r9++	jmp	__inner_loop_30++	.byte	0xf3,0xc3+.cfi_endproc+.size	__ab_approximation_30,.-__ab_approximation_30+.type	__inner_loop_30,@function+.align	32+__inner_loop_30:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	$0x7FFFFFFF80000000,%rbx+	movq	$0x800000007FFFFFFF,%rcx+	leaq	-1(%rbx),%r15+	movl	$30,%edi++.Loop_30:+	movq	%r8,%rax+	andq	%r9,%rax+	shrq	$1,%rax++	cmpq	%r9,%r8+	movq	%r8,%r10+	movq	%r9,%r11+	leaq	(%rax,%rbp,1),%rax+	movq	%rbx,%r12+	movq	%rcx,%r13+	movq	%rbp,%r14+	cmovbq	%r9,%r8+	cmovbq	%r10,%r9+	cmovbq	%rcx,%rbx+	cmovbq	%r12,%rcx+	cmovbq	%rax,%rbp++	subq	%r9,%r8+	subq	%rcx,%rbx+	addq	%r15,%rbx++	testq	$1,%r10+	cmovzq	%r10,%r8+	cmovzq	%r11,%r9+	cmovzq	%r12,%rbx+	cmovzq	%r13,%rcx+	cmovzq	%r14,%rbp++	leaq	2(%r9),%rax+	shrq	$1,%r8+	shrq	$2,%rax+	addq	%rcx,%rcx+	leaq	(%rax,%rbp,1),%rbp+	subq	%r15,%rcx++	subl	$1,%edi+	jnz	.Loop_30++	shrq	$32,%r15+	movl	%ebx,%eax+	shrq	$32,%rbx+	movl	%ecx,%edx+	shrq	$32,%rcx+	subq	%r15,%rax+	subq	%r15,%rbx+	subq	%r15,%rdx+	subq	%r15,%rcx++	.byte	0xf3,0xc3+.cfi_endproc+.size	__inner_loop_30,.-__inner_loop_30++.type	__inner_loop_48,@function+.align	32+__inner_loop_48:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movl	$48,%edi++.Loop_48:+	movq	%r8,%rax+	andq	%r9,%rax+	shrq	$1,%rax++	cmpq	%r9,%r8+	movq	%r8,%r10+	movq	%r9,%r11+	leaq	(%rax,%rbp,1),%rax+	movq	%rbp,%r12+	cmovbq	%r9,%r8+	cmovbq	%r10,%r9+	cmovbq	%rax,%rbp++	subq	%r9,%r8++	testq	$1,%r10+	cmovzq	%r10,%r8+	cmovzq	%r11,%r9+	cmovzq	%r12,%rbp++	leaq	2(%r9),%rax+	shrq	$1,%r8+	shrq	$2,%rax+	addq	%rax,%rbp++	subl	$1,%edi+	jnz	.Loop_48++	.byte	0xf3,0xc3+.cfi_endproc+.size	__inner_loop_48,.-__inner_loop_48++.section	.note.GNU-stack,"",@progbits+.section	.note.gnu.property,"a",@note+	.long	4,2f-1f,5+	.byte	0x47,0x4E,0x55,0+1:	.long	0xc0000002,4,3+.align	8+2:
+ c-source/build/elf/ctq_inverse_mod_384-x86_64.s view
@@ -0,0 +1,1195 @@+.text	++.globl	ct_inverse_mod_383+.type	ct_inverse_mod_383,@function+.align	32+ct_inverse_mod_383:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$1112,%rsp+.cfi_adjust_cfa_offset	1112+++	leaq	88+511(%rsp),%rax+	andq	$-512,%rax+	movq	%rdi,32(%rsp)+	movq	%rcx,40(%rsp)++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	0(%rdx),%r14+	movq	8(%rdx),%r15+	movq	16(%rdx),%rbx+	movq	24(%rdx),%rbp+	movq	32(%rdx),%rsi+	movq	40(%rdx),%rdi++	movq	%r8,0(%rax)+	movq	%r9,8(%rax)+	movq	%r10,16(%rax)+	movq	%r11,24(%rax)+	movq	%r12,32(%rax)+	movq	%r13,40(%rax)++	movq	%r14,48(%rax)+	movq	%r15,56(%rax)+	movq	%rbx,64(%rax)+	movq	%rbp,72(%rax)+	movq	%rsi,80(%rax)+	movq	%rax,%rsi+	movq	%rdi,88(%rax)+++	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+++	movq	%rdx,96(%rdi)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+++	movq	%rdx,96(%rdi)+++	xorq	$256,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62++++	movq	96(%rsi),%rax+	movq	144(%rsi),%r11+	movq	%rdx,%rbx+	movq	%rax,%r10+	imulq	56(%rsp)+	movq	%rax,%r8+	movq	%r11,%rax+	movq	%rdx,%r9+	imulq	64(%rsp)+	addq	%rax,%r8+	adcq	%rdx,%r9+	movq	%r8,48(%rdi)+	movq	%r9,56(%rdi)+	sarq	$63,%r9+	movq	%r9,64(%rdi)+	movq	%r9,72(%rdi)+	movq	%r9,80(%rdi)+	movq	%r9,88(%rdi)+	leaq	96(%rsi),%rsi++	movq	%r10,%rax+	imulq	%rbx+	movq	%rax,%r8+	movq	%r11,%rax+	movq	%rdx,%r9+	imulq	%rcx+	addq	%rax,%r8+	adcq	%rdx,%r9+	movq	%r8,96(%rdi)+	movq	%r9,104(%rdi)+	sarq	$63,%r9+	movq	%r9,112(%rdi)+	movq	%r9,120(%rdi)+	movq	%r9,128(%rdi)+	movq	%r9,136(%rdi)+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383x63+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383x63+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383x63+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383x63+	sarq	$63,%r13+	movq	%r13,48(%rdi)+	movq	%r13,56(%rdi)+	movq	%r13,64(%rdi)+	movq	%r13,72(%rdi)+	movq	%r13,80(%rdi)+	movq	%r13,88(%rdi)+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_767x63+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_767x63+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_767x63+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_767x63+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_767x63++	xorq	$256+96,%rsi+	movl	$62,%edi++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	48(%rsi),%r10+	movq	56(%rsi),%r11+	call	__inner_loop_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	movq	%r8,0(%rdi)+	movq	%r10,48(%rdi)++++	leaq	96(%rsi),%rsi+	leaq	96(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_767x63+++	xorq	$256+96,%rsi+	movl	$22,%edi++	movq	0(%rsi),%r8+	xorq	%r9,%r9+	movq	48(%rsi),%r10+	xorq	%r11,%r11+	call	__inner_loop_62++++++++	leaq	96(%rsi),%rsi++++++	movq	%r12,%rdx+	movq	%r13,%rcx+	movq	32(%rsp),%rdi+	call	__smulq_767x63++	movq	40(%rsp),%rsi+	movq	%rax,%rdx+	sarq	$63,%rax++	movq	%rax,%r8+	movq	%rax,%r9+	movq	%rax,%r10+	andq	0(%rsi),%r8+	andq	8(%rsi),%r9+	movq	%rax,%r11+	andq	16(%rsi),%r10+	andq	24(%rsi),%r11+	movq	%rax,%r12+	andq	32(%rsi),%r12+	andq	40(%rsi),%rax++	addq	%r8,%r14+	adcq	%r9,%r15+	adcq	%r10,%rbx+	adcq	%r11,%rbp+	adcq	%r12,%rcx+	adcq	%rax,%rdx++	movq	%r14,48(%rdi)+	movq	%r15,56(%rdi)+	movq	%rbx,64(%rdi)+	movq	%rbp,72(%rdi)+	movq	%rcx,80(%rdi)+	movq	%rdx,88(%rdi)++	leaq	1112(%rsp),%r8+	movq	0(%r8),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-1112-8*6++	.byte	0xf3,0xc3+.cfi_endproc	+.size	ct_inverse_mod_383,.-ct_inverse_mod_383+.type	__smulq_767x63,@function+.align	32+__smulq_767x63:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rdx,%rbp+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	leaq	48(%rsi),%rsi++	xorq	%rdx,%rbp+	addq	%rax,%rbp++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	mulq	%rbp+	movq	%rax,0(%rdi)+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbp+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	movq	%r9,8(%rdi)+	mulq	%rbp+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	movq	%r10,16(%rdi)+	mulq	%rbp+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	movq	%r11,24(%rdi)+	mulq	%rbp+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	movq	%r12,32(%rdi)+	imulq	%rbp+	addq	%rax,%r13+	adcq	$0,%rdx++	movq	%r13,40(%rdi)+	movq	%rdx,48(%rdi)+	sarq	$63,%rdx+	movq	%rdx,56(%rdi)+	movq	%rcx,%rdx++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	48(%rsi),%r14+	movq	56(%rsi),%r15+	movq	64(%rsi),%rbx+	movq	72(%rsi),%rbp+	movq	80(%rsi),%rcx+	movq	88(%rsi),%rdi++	movq	%rdx,%rsi+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rsi+	addq	%rax,%rsi++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	xorq	%rdx,%r14+	xorq	%rdx,%r15+	xorq	%rdx,%rbx+	xorq	%rdx,%rbp+	xorq	%rdx,%rcx+	xorq	%rdx,%rdi+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13+	adcq	$0,%r14+	adcq	$0,%r15+	adcq	$0,%rbx+	adcq	$0,%rbp+	adcq	$0,%rcx+	adcq	$0,%rdi++	mulq	%rsi+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rsi+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rsi+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rsi+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	mulq	%rsi+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	mulq	%rsi+	addq	%rax,%r13+	movq	%r14,%rax+	adcq	$0,%rdx+	movq	%rdx,%r14+	mulq	%rsi+	addq	%rax,%r14+	movq	%r15,%rax+	adcq	$0,%rdx+	movq	%rdx,%r15+	mulq	%rsi+	addq	%rax,%r15+	movq	%rbx,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbx+	mulq	%rsi+	addq	%rax,%rbx+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp+	mulq	%rsi+	addq	%rax,%rbp+	movq	%rcx,%rax+	adcq	$0,%rdx+	movq	%rdx,%rcx+	mulq	%rsi+	addq	%rax,%rcx+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%rdi+	movq	8(%rsp),%rdx+	imulq	%rsi,%rax+	movq	16(%rsp),%rsi+	addq	%rdi,%rax++	addq	0(%rdx),%r8+	adcq	8(%rdx),%r9+	adcq	16(%rdx),%r10+	adcq	24(%rdx),%r11+	adcq	32(%rdx),%r12+	adcq	40(%rdx),%r13+	adcq	48(%rdx),%r14+	movq	56(%rdx),%rdi+	adcq	%rdi,%r15+	adcq	%rdi,%rbx+	adcq	%rdi,%rbp+	adcq	%rdi,%rcx+	adcq	%rdi,%rax++	movq	%rdx,%rdi++	movq	%r8,0(%rdx)+	movq	%r9,8(%rdx)+	movq	%r10,16(%rdx)+	movq	%r11,24(%rdx)+	movq	%r12,32(%rdx)+	movq	%r13,40(%rdx)+	movq	%r14,48(%rdx)+	movq	%r15,56(%rdx)+	movq	%rbx,64(%rdx)+	movq	%rbp,72(%rdx)+	movq	%rcx,80(%rdx)+	movq	%rax,88(%rdx)++	.byte	0xf3,0xc3+.cfi_endproc+.size	__smulq_767x63,.-__smulq_767x63+.type	__smulq_383x63,@function+.align	32+__smulq_383x63:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rdx,%rbp+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbp+	addq	%rax,%rbp++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	mulq	%rbp+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbp+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rbp+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rbp+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	mulq	%rbp+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	imulq	%rbp,%rax+	addq	%rax,%r13++	leaq	48(%rsi),%rsi+	movq	%rcx,%rdx++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)+	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rdx,%rbp+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbp+	addq	%rax,%rbp++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	mulq	%rbp+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbp+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rbp+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rbp+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	mulq	%rbp+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	imulq	%rbp,%rax+	addq	%rax,%r13++	leaq	-48(%rsi),%rsi++	addq	0(%rdi),%r8+	adcq	8(%rdi),%r9+	adcq	16(%rdi),%r10+	adcq	24(%rdi),%r11+	adcq	32(%rdi),%r12+	adcq	40(%rdi),%r13++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+.size	__smulq_383x63,.-__smulq_383x63+.type	__smulq_383_n_shift_by_62,@function+.align	32+__smulq_383_n_shift_by_62:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	%rdx,%rbx+	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rdx,%rbp+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbp+	addq	%rax,%rbp++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	mulq	%rbp+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbp+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rbp+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rbp+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	mulq	%rbp+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	imulq	%rbp+	addq	%rax,%r13+	adcq	$0,%rdx++	leaq	48(%rsi),%rsi+	movq	%rdx,%r14+	movq	%rcx,%rdx++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)+	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rdx,%rbp+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbp+	addq	%rax,%rbp++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	mulq	%rbp+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbp+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rbp+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rbp+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	mulq	%rbp+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	imulq	%rbp+	addq	%rax,%r13+	adcq	$0,%rdx++	leaq	-48(%rsi),%rsi++	addq	0(%rdi),%r8+	adcq	8(%rdi),%r9+	adcq	16(%rdi),%r10+	adcq	24(%rdi),%r11+	adcq	32(%rdi),%r12+	adcq	40(%rdi),%r13+	adcq	%rdx,%r14+	movq	%rbx,%rdx++	shrdq	$62,%r9,%r8+	shrdq	$62,%r10,%r9+	shrdq	$62,%r11,%r10+	shrdq	$62,%r12,%r11+	shrdq	$62,%r13,%r12+	shrdq	$62,%r14,%r13++	sarq	$63,%r14+	xorq	%rbp,%rbp+	subq	%r14,%rbp++	xorq	%r14,%r8+	xorq	%r14,%r9+	xorq	%r14,%r10+	xorq	%r14,%r11+	xorq	%r14,%r12+	xorq	%r14,%r13+	addq	%rbp,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	xorq	%r14,%rdx+	xorq	%r14,%rcx+	addq	%rbp,%rdx+	addq	%rbp,%rcx++	.byte	0xf3,0xc3+.cfi_endproc+.size	__smulq_383_n_shift_by_62,.-__smulq_383_n_shift_by_62+.type	__ab_approximation_62,@function+.align	32+__ab_approximation_62:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	40(%rsi),%r9+	movq	88(%rsi),%r11+	movq	32(%rsi),%rbx+	movq	80(%rsi),%rbp+	movq	24(%rsi),%r8+	movq	72(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	cmovzq	%r10,%rbp+	movq	16(%rsi),%r8+	movq	64(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	cmovzq	%r10,%rbp+	movq	8(%rsi),%r8+	movq	56(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	cmovzq	%r10,%rbp+	movq	0(%rsi),%r8+	movq	48(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	bsrq	%rax,%rcx+	leaq	1(%rcx),%rcx+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%rax,%rcx+	negq	%rcx+++	shldq	%cl,%rbx,%r9+	shldq	%cl,%rbp,%r11++	jmp	__inner_loop_62++	.byte	0xf3,0xc3+.cfi_endproc+.size	__ab_approximation_62,.-__ab_approximation_62+.type	__inner_loop_62,@function+.align	8+.long	0+__inner_loop_62:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	$1,%rdx+	xorq	%rcx,%rcx+	xorq	%r12,%r12+	movq	$1,%r13+	movq	%rsi,8(%rsp)++.Loop_62:+	xorq	%rax,%rax+	xorq	%rbx,%rbx+	testq	$1,%r8+	movq	%r10,%rbp+	movq	%r11,%r14+	cmovnzq	%r10,%rax+	cmovnzq	%r11,%rbx+	subq	%r8,%rbp+	sbbq	%r9,%r14+	movq	%r8,%r15+	movq	%r9,%rsi+	subq	%rax,%r8+	sbbq	%rbx,%r9+	cmovcq	%rbp,%r8+	cmovcq	%r14,%r9+	cmovcq	%r15,%r10+	cmovcq	%rsi,%r11+	movq	%rdx,%rax+	cmovcq	%r12,%rdx+	cmovcq	%rax,%r12+	movq	%rcx,%rbx+	cmovcq	%r13,%rcx+	cmovcq	%rbx,%r13+	xorq	%rax,%rax+	xorq	%rbx,%rbx+	shrdq	$1,%r9,%r8+	shrq	$1,%r9+	testq	$1,%r15+	cmovnzq	%r12,%rax+	cmovnzq	%r13,%rbx+	addq	%r12,%r12+	addq	%r13,%r13+	subq	%rax,%rdx+	subq	%rbx,%rcx+	subl	$1,%edi+	jnz	.Loop_62++	movq	8(%rsp),%rsi+	.byte	0xf3,0xc3+.cfi_endproc+.size	__inner_loop_62,.-__inner_loop_62++.section	.note.GNU-stack,"",@progbits+.section	.note.gnu.property,"a",@note+	.long	4,2f-1f,5+	.byte	0x47,0x4E,0x55,0+1:	.long	0xc0000002,4,3+.align	8+2:
+ c-source/build/elf/ctx_inverse_mod_384-x86_64.s view
@@ -0,0 +1,1574 @@+.text	++.globl	ctx_inverse_mod_383+.type	ctx_inverse_mod_383,@function+.align	32+ctx_inverse_mod_383:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$1112,%rsp+.cfi_adjust_cfa_offset	1112+++	leaq	88+511(%rsp),%rax+	andq	$-512,%rax+	movq	%rdi,32(%rsp)+	movq	%rcx,40(%rsp)++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	0(%rdx),%r14+	movq	8(%rdx),%r15+	movq	16(%rdx),%rbx+	movq	24(%rdx),%rbp+	movq	32(%rdx),%rsi+	movq	40(%rdx),%rdi++	movq	%r8,0(%rax)+	movq	%r9,8(%rax)+	movq	%r10,16(%rax)+	movq	%r11,24(%rax)+	movq	%r12,32(%rax)+	movq	%r13,40(%rax)++	movq	%r14,48(%rax)+	movq	%r15,56(%rax)+	movq	%rbx,64(%rax)+	movq	%rbp,72(%rax)+	movq	%rsi,80(%rax)+	movq	%rax,%rsi+	movq	%rdi,88(%rax)+++	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+++	movq	%rdx,96(%rdi)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+++	movq	%rdx,96(%rdi)+++	xorq	$256,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31++++	movq	96(%rsi),%rax+	movq	144(%rsi),%r11+	movq	%rdx,%rbx+	movq	%rax,%r10+	imulq	56(%rsp)+	movq	%rax,%r8+	movq	%r11,%rax+	movq	%rdx,%r9+	imulq	64(%rsp)+	addq	%rax,%r8+	adcq	%rdx,%r9+	movq	%r8,48(%rdi)+	movq	%r9,56(%rdi)+	sarq	$63,%r9+	movq	%r9,64(%rdi)+	movq	%r9,72(%rdi)+	movq	%r9,80(%rdi)+	movq	%r9,88(%rdi)+	leaq	96(%rsi),%rsi++	movq	%r10,%rax+	imulq	%rbx+	movq	%rax,%r8+	movq	%r11,%rax+	movq	%rdx,%r9+	imulq	%rcx+	addq	%rax,%r8+	adcq	%rdx,%r9+	movq	%r8,96(%rdi)+	movq	%r9,104(%rdi)+	sarq	$63,%r9+	movq	%r9,112(%rdi)+	movq	%r9,120(%rdi)+	movq	%r9,128(%rdi)+	movq	%r9,136(%rdi)+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	sarq	$63,%r13+	movq	%r13,48(%rdi)+	movq	%r13,56(%rdi)+	movq	%r13,64(%rdi)+	movq	%r13,72(%rdi)+	movq	%r13,80(%rdi)+	movq	%r13,88(%rdi)+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_191_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_191_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_191_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_191_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_191_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_191_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_191_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_191_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63++	xorq	$256+96,%rsi+	movl	$53,%edi++	movq	0(%rsi),%r8++	movq	48(%rsi),%r10++	call	__inner_loop_62++++++++	leaq	96(%rsi),%rsi++++++	movq	%r12,%rdx+	movq	%r13,%rcx+	movq	32(%rsp),%rdi+	call	__smulx_767x63++	movq	40(%rsp),%rsi+	movq	%rax,%rdx+	sarq	$63,%rax++	movq	%rax,%r8+	movq	%rax,%r9+	movq	%rax,%r10+	andq	0(%rsi),%r8+	andq	8(%rsi),%r9+	movq	%rax,%r11+	andq	16(%rsi),%r10+	andq	24(%rsi),%r11+	movq	%rax,%r12+	andq	32(%rsi),%r12+	andq	40(%rsi),%rax++	addq	%r8,%r14+	adcq	%r9,%r15+	adcq	%r10,%rbx+	adcq	%r11,%rbp+	adcq	%r12,%rcx+	adcq	%rax,%rdx++	movq	%r14,48(%rdi)+	movq	%r15,56(%rdi)+	movq	%rbx,64(%rdi)+	movq	%rbp,72(%rdi)+	movq	%rcx,80(%rdi)+	movq	%rdx,88(%rdi)++	leaq	1112(%rsp),%r8+	movq	0(%r8),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-1112-8*6++	.byte	0xf3,0xc3+.cfi_endproc	+.size	ctx_inverse_mod_383,.-ctx_inverse_mod_383+.type	__smulx_767x63,@function+.align	32+__smulx_767x63:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rdx,%rax+	sarq	$63,%rax+	xorq	%rbp,%rbp+	subq	%rax,%rbp++	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	leaq	48(%rsi),%rsi++	xorq	%rax,%rdx+	addq	%rbp,%rdx++	xorq	%rax,%r8+	xorq	%rax,%r9+	xorq	%rax,%r10+	xorq	%rax,%r11+	xorq	%rax,%r12+	xorq	%r13,%rax+	addq	%rbp,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%rax++	mulxq	%r8,%r8,%rbp+	mulxq	%r9,%r9,%r13+	addq	%rbp,%r9+	mulxq	%r10,%r10,%rbp+	adcq	%r13,%r10+	mulxq	%r11,%r11,%r13+	adcq	%rbp,%r11+	mulxq	%r12,%r12,%rbp+	adcq	%r13,%r12+	adcq	$0,%rbp+	imulq	%rdx+	addq	%rbp,%rax+	adcq	$0,%rdx++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%rax,40(%rdi)+	movq	%rdx,48(%rdi)+	sarq	$63,%rdx+	movq	%rdx,56(%rdi)+	movq	%rcx,%rdx+	movq	%rcx,%rax++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	48(%rsi),%r14+	movq	56(%rsi),%r15+	movq	64(%rsi),%rbx+	movq	72(%rsi),%rbp+	movq	80(%rsi),%rcx+	movq	88(%rsi),%rdi++	sarq	$63,%rax+	xorq	%rsi,%rsi+	subq	%rax,%rsi++	xorq	%rax,%rdx+	addq	%rsi,%rdx++	xorq	%rax,%r8+	xorq	%rax,%r9+	xorq	%rax,%r10+	xorq	%rax,%r11+	xorq	%rax,%r12+	xorq	%rax,%r13+	xorq	%rax,%r14+	xorq	%rax,%r15+	xorq	%rax,%rbx+	xorq	%rax,%rbp+	xorq	%rax,%rcx+	xorq	%rax,%rdi+	addq	%rsi,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13+	adcq	$0,%r14+	adcq	$0,%r15+	adcq	$0,%rbx+	adcq	$0,%rbp+	adcq	$0,%rcx+	adcq	$0,%rdi++	mulxq	%r8,%r8,%rax+	mulxq	%r9,%r9,%rsi+	addq	%rax,%r9+	mulxq	%r10,%r10,%rax+	adcq	%rsi,%r10+	mulxq	%r11,%r11,%rsi+	adcq	%rax,%r11+	mulxq	%r12,%r12,%rax+	adcq	%rsi,%r12+	mulxq	%r13,%r13,%rsi+	adcq	%rax,%r13+	mulxq	%r14,%r14,%rax+	adcq	%rsi,%r14+	mulxq	%r15,%r15,%rsi+	adcq	%rax,%r15+	mulxq	%rbx,%rbx,%rax+	adcq	%rsi,%rbx+	mulxq	%rbp,%rbp,%rsi+	adcq	%rax,%rbp+	mulxq	%rcx,%rcx,%rax+	adcq	%rsi,%rcx+	mulxq	%rdi,%rdi,%rsi+	movq	8(%rsp),%rdx+	movq	16(%rsp),%rsi+	adcq	%rdi,%rax++	addq	0(%rdx),%r8+	adcq	8(%rdx),%r9+	adcq	16(%rdx),%r10+	adcq	24(%rdx),%r11+	adcq	32(%rdx),%r12+	adcq	40(%rdx),%r13+	adcq	48(%rdx),%r14+	movq	56(%rdx),%rdi+	adcq	%rdi,%r15+	adcq	%rdi,%rbx+	adcq	%rdi,%rbp+	adcq	%rdi,%rcx+	adcq	%rdi,%rax++	movq	%rdx,%rdi++	movq	%r8,0(%rdx)+	movq	%r9,8(%rdx)+	movq	%r10,16(%rdx)+	movq	%r11,24(%rdx)+	movq	%r12,32(%rdx)+	movq	%r13,40(%rdx)+	movq	%r14,48(%rdx)+	movq	%r15,56(%rdx)+	movq	%rbx,64(%rdx)+	movq	%rbp,72(%rdx)+	movq	%rcx,80(%rdx)+	movq	%rax,88(%rdx)++	.byte	0xf3,0xc3+.cfi_endproc+.size	__smulx_767x63,.-__smulx_767x63+.type	__smulx_383x63,@function+.align	32+__smulx_383x63:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0+0(%rsi),%r8+	movq	0+8(%rsi),%r9+	movq	0+16(%rsi),%r10+	movq	0+24(%rsi),%r11+	movq	0+32(%rsi),%r12+	movq	0+40(%rsi),%r13++	movq	%rdx,%rbp+	sarq	$63,%rbp+	xorq	%rax,%rax+	subq	%rbp,%rax++	xorq	%rbp,%rdx+	addq	%rax,%rdx++	xorq	%rbp,%r8+	xorq	%rbp,%r9+	xorq	%rbp,%r10+	xorq	%rbp,%r11+	xorq	%rbp,%r12+	xorq	%rbp,%r13+	addq	%rax,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	mulxq	%r8,%r8,%rbp+	mulxq	%r9,%r9,%rax+	addq	%rbp,%r9+	mulxq	%r10,%r10,%rbp+	adcq	%rax,%r10+	mulxq	%r11,%r11,%rax+	adcq	%rbp,%r11+	mulxq	%r12,%r12,%rbp+	adcq	%rax,%r12+	mulxq	%r13,%r13,%rax+	movq	%rcx,%rdx+	adcq	%rbp,%r13++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)+	movq	48+0(%rsi),%r8+	movq	48+8(%rsi),%r9+	movq	48+16(%rsi),%r10+	movq	48+24(%rsi),%r11+	movq	48+32(%rsi),%r12+	movq	48+40(%rsi),%r13++	movq	%rdx,%rbp+	sarq	$63,%rbp+	xorq	%rax,%rax+	subq	%rbp,%rax++	xorq	%rbp,%rdx+	addq	%rax,%rdx++	xorq	%rbp,%r8+	xorq	%rbp,%r9+	xorq	%rbp,%r10+	xorq	%rbp,%r11+	xorq	%rbp,%r12+	xorq	%rbp,%r13+	addq	%rax,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	mulxq	%r8,%r8,%rbp+	mulxq	%r9,%r9,%rax+	addq	%rbp,%r9+	mulxq	%r10,%r10,%rbp+	adcq	%rax,%r10+	mulxq	%r11,%r11,%rax+	adcq	%rbp,%r11+	mulxq	%r12,%r12,%rbp+	adcq	%rax,%r12+	mulxq	%r13,%r13,%rax+	adcq	%rbp,%r13++	addq	0(%rdi),%r8+	adcq	8(%rdi),%r9+	adcq	16(%rdi),%r10+	adcq	24(%rdi),%r11+	adcq	32(%rdi),%r12+	adcq	40(%rdi),%r13++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+.size	__smulx_383x63,.-__smulx_383x63+.type	__smulx_383_n_shift_by_31,@function+.align	32+__smulx_383_n_shift_by_31:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	%rdx,%rbx+	xorq	%r14,%r14+	movq	0+0(%rsi),%r8+	movq	0+8(%rsi),%r9+	movq	0+16(%rsi),%r10+	movq	0+24(%rsi),%r11+	movq	0+32(%rsi),%r12+	movq	0+40(%rsi),%r13++	movq	%rdx,%rax+	sarq	$63,%rax+	xorq	%rbp,%rbp+	subq	%rax,%rbp++	xorq	%rax,%rdx+	addq	%rbp,%rdx++	xorq	%rax,%r8+	xorq	%rax,%r9+	xorq	%rax,%r10+	xorq	%rax,%r11+	xorq	%rax,%r12+	xorq	%r13,%rax+	addq	%rbp,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%rax++	mulxq	%r8,%r8,%rbp+	mulxq	%r9,%r9,%r13+	addq	%rbp,%r9+	mulxq	%r10,%r10,%rbp+	adcq	%r13,%r10+	mulxq	%r11,%r11,%r13+	adcq	%rbp,%r11+	mulxq	%r12,%r12,%rbp+	adcq	%r13,%r12+	adcq	$0,%rbp+	imulq	%rdx+	addq	%rbp,%rax+	adcq	%rdx,%r14++	movq	%rcx,%rdx++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%rax,40(%rdi)+	movq	48+0(%rsi),%r8+	movq	48+8(%rsi),%r9+	movq	48+16(%rsi),%r10+	movq	48+24(%rsi),%r11+	movq	48+32(%rsi),%r12+	movq	48+40(%rsi),%r13++	movq	%rdx,%rax+	sarq	$63,%rax+	xorq	%rbp,%rbp+	subq	%rax,%rbp++	xorq	%rax,%rdx+	addq	%rbp,%rdx++	xorq	%rax,%r8+	xorq	%rax,%r9+	xorq	%rax,%r10+	xorq	%rax,%r11+	xorq	%rax,%r12+	xorq	%r13,%rax+	addq	%rbp,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%rax++	mulxq	%r8,%r8,%rbp+	mulxq	%r9,%r9,%r13+	addq	%rbp,%r9+	mulxq	%r10,%r10,%rbp+	adcq	%r13,%r10+	mulxq	%r11,%r11,%r13+	adcq	%rbp,%r11+	mulxq	%r12,%r12,%rbp+	adcq	%r13,%r12+	adcq	$0,%rbp+	imulq	%rdx+	addq	%rbp,%rax+	adcq	$0,%rdx++	addq	0(%rdi),%r8+	adcq	8(%rdi),%r9+	adcq	16(%rdi),%r10+	adcq	24(%rdi),%r11+	adcq	32(%rdi),%r12+	adcq	40(%rdi),%rax+	adcq	%rdx,%r14+	movq	%rbx,%rdx++	shrdq	$31,%r9,%r8+	shrdq	$31,%r10,%r9+	shrdq	$31,%r11,%r10+	shrdq	$31,%r12,%r11+	shrdq	$31,%rax,%r12+	shrdq	$31,%r14,%rax++	sarq	$63,%r14+	xorq	%rbp,%rbp+	subq	%r14,%rbp++	xorq	%r14,%r8+	xorq	%r14,%r9+	xorq	%r14,%r10+	xorq	%r14,%r11+	xorq	%r14,%r12+	xorq	%r14,%rax+	addq	%rbp,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%rax++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%rax,40(%rdi)++	xorq	%r14,%rdx+	xorq	%r14,%rcx+	addq	%rbp,%rdx+	addq	%rbp,%rcx++	.byte	0xf3,0xc3+.cfi_endproc+.size	__smulx_383_n_shift_by_31,.-__smulx_383_n_shift_by_31+.type	__smulx_191_n_shift_by_31,@function+.align	32+__smulx_191_n_shift_by_31:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	%rdx,%rbx+	movq	0+0(%rsi),%r8+	movq	0+8(%rsi),%r9+	movq	0+16(%rsi),%r10++	movq	%rdx,%rax+	sarq	$63,%rax+	xorq	%rbp,%rbp+	subq	%rax,%rbp++	xorq	%rax,%rdx+	addq	%rbp,%rdx++	xorq	%rax,%r8+	xorq	%rax,%r9+	xorq	%r10,%rax+	addq	%rbp,%r8+	adcq	$0,%r9+	adcq	$0,%rax++	mulxq	%r8,%r8,%rbp+	mulxq	%r9,%r9,%r10+	addq	%rbp,%r9+	adcq	$0,%r10+	imulq	%rdx+	addq	%rax,%r10+	adcq	$0,%rdx+	movq	%rdx,%r14+	movq	%rcx,%rdx+	movq	48+0(%rsi),%r11+	movq	48+8(%rsi),%r12+	movq	48+16(%rsi),%r13++	movq	%rdx,%rax+	sarq	$63,%rax+	xorq	%rbp,%rbp+	subq	%rax,%rbp++	xorq	%rax,%rdx+	addq	%rbp,%rdx++	xorq	%rax,%r11+	xorq	%rax,%r12+	xorq	%r13,%rax+	addq	%rbp,%r11+	adcq	$0,%r12+	adcq	$0,%rax++	mulxq	%r11,%r11,%rbp+	mulxq	%r12,%r12,%r13+	addq	%rbp,%r12+	adcq	$0,%r13+	imulq	%rdx+	addq	%rax,%r13+	adcq	$0,%rdx+	addq	%r8,%r11+	adcq	%r9,%r12+	adcq	%r10,%r13+	adcq	%rdx,%r14+	movq	%rbx,%rdx++	shrdq	$31,%r12,%r11+	shrdq	$31,%r13,%r12+	shrdq	$31,%r14,%r13++	sarq	$63,%r14+	xorq	%rbp,%rbp+	subq	%r14,%rbp++	xorq	%r14,%r11+	xorq	%r14,%r12+	xorq	%r14,%r13+	addq	%rbp,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	movq	%r11,0(%rdi)+	movq	%r12,8(%rdi)+	movq	%r13,16(%rdi)++	xorq	%r14,%rdx+	xorq	%r14,%rcx+	addq	%rbp,%rdx+	addq	%rbp,%rcx++	.byte	0xf3,0xc3+.cfi_endproc+.size	__smulx_191_n_shift_by_31,.-__smulx_191_n_shift_by_31+.type	__ab_approximation_31,@function+.align	32+__ab_approximation_31:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	40(%rsi),%r9+	movq	88(%rsi),%r11+	movq	32(%rsi),%rbx+	movq	80(%rsi),%rbp+	movq	24(%rsi),%r8+	movq	72(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	movq	16(%rsi),%r8+	cmovzq	%r10,%rbp+	movq	64(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	movq	8(%rsi),%r8+	cmovzq	%r10,%rbp+	movq	56(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	movq	0(%rsi),%r8+	cmovzq	%r10,%rbp+	movq	48(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	cmovzq	%r10,%rbp++	movq	%r9,%rax+	orq	%r11,%rax+	bsrq	%rax,%rcx+	leaq	1(%rcx),%rcx+	cmovzq	%r8,%r9+	cmovzq	%r10,%r11+	cmovzq	%rax,%rcx+	negq	%rcx+++	shldq	%cl,%rbx,%r9+	shldq	%cl,%rbp,%r11++	movl	$0x7FFFFFFF,%eax+	andq	%rax,%r8+	andq	%rax,%r10+	andnq	%r9,%rax,%r9+	andnq	%r11,%rax,%r11+	orq	%r9,%r8+	orq	%r11,%r10++	jmp	__inner_loop_31++	.byte	0xf3,0xc3+.cfi_endproc+.size	__ab_approximation_31,.-__ab_approximation_31+.type	__inner_loop_31,@function+.align	32+__inner_loop_31:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	$0x7FFFFFFF80000000,%rcx+	movq	$0x800000007FFFFFFF,%r13+	movq	$0x7FFFFFFF7FFFFFFF,%r15++.Loop_31:+	cmpq	%r10,%r8+	movq	%r8,%rax+	movq	%r10,%rbx+	movq	%rcx,%rbp+	movq	%r13,%r14+	cmovbq	%r10,%r8+	cmovbq	%rax,%r10+	cmovbq	%r13,%rcx+	cmovbq	%rbp,%r13++	subq	%r10,%r8+	subq	%r13,%rcx+	addq	%r15,%rcx++	testq	$1,%rax+	cmovzq	%rax,%r8+	cmovzq	%rbx,%r10+	cmovzq	%rbp,%rcx+	cmovzq	%r14,%r13++	shrq	$1,%r8+	addq	%r13,%r13+	subq	%r15,%r13+	subl	$1,%edi+	jnz	.Loop_31++	shrq	$32,%r15+	movl	%ecx,%edx+	movl	%r13d,%r12d+	shrq	$32,%rcx+	shrq	$32,%r13+	subq	%r15,%rdx+	subq	%r15,%rcx+	subq	%r15,%r12+	subq	%r15,%r13++	.byte	0xf3,0xc3+.cfi_endproc+.size	__inner_loop_31,.-__inner_loop_31++.type	__inner_loop_62,@function+.align	32+__inner_loop_62:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	$1,%rdx+	xorq	%rcx,%rcx+	xorq	%r12,%r12+	movq	$1,%r13++.Loop_62:+	xorq	%rax,%rax+	testq	$1,%r8+	movq	%r10,%rbx+	cmovnzq	%r10,%rax+	subq	%r8,%rbx+	movq	%r8,%rbp+	subq	%rax,%r8+	cmovcq	%rbx,%r8+	cmovcq	%rbp,%r10+	movq	%rdx,%rax+	cmovcq	%r12,%rdx+	cmovcq	%rax,%r12+	movq	%rcx,%rbx+	cmovcq	%r13,%rcx+	cmovcq	%rbx,%r13+	xorq	%rax,%rax+	xorq	%rbx,%rbx+	shrq	$1,%r8+	testq	$1,%rbp+	cmovnzq	%r12,%rax+	cmovnzq	%r13,%rbx+	addq	%r12,%r12+	addq	%r13,%r13+	subq	%rax,%rdx+	subq	%rbx,%rcx+	subl	$1,%edi+	jnz	.Loop_62++	.byte	0xf3,0xc3+.cfi_endproc+.size	__inner_loop_62,.-__inner_loop_62++.section	.note.GNU-stack,"",@progbits+.section	.note.gnu.property,"a",@note+	.long	4,2f-1f,5+	.byte	0x47,0x4E,0x55,0+1:	.long	0xc0000002,4,3+.align	8+2:
+ c-source/build/elf/div3w-armv8.S view
@@ -0,0 +1,88 @@+.text++.globl	div_3_limbs+.type	div_3_limbs,%function+.align	5+div_3_limbs:+	ldp	x4,x5,[x0]	// load R+	eor	x0,x0,x0	// Q = 0+	mov	x3,#64		// loop counter+	nop++.Loop:+	subs	x6,x4,x1	// R - D+	add	x0,x0,x0	// Q <<= 1+	sbcs	x7,x5,x2+	add	x0,x0,#1	// Q + speculative bit+	csel	x4,x4,x6,lo	// select between R and R - D+	extr	x1,x2,x1,#1	// D >>= 1+	csel	x5,x5,x7,lo+	lsr	x2,x2,#1+	sbc	x0,x0,xzr	// subtract speculative bit+	sub	x3,x3,#1+	cbnz	x3,.Loop++	asr	x3,x0,#63	// top bit -> mask+	add	x0,x0,x0	// Q <<= 1+	subs	x6,x4,x1	// R - D+	add	x0,x0,#1	// Q + specilative bit+	sbcs	x7,x5,x2+	sbc	x0,x0,xzr	// subtract speculative bit++	orr	x0,x0,x3	// all ones if overflow++	ret+.size	div_3_limbs,.-div_3_limbs+.globl	quot_rem_128+.type	quot_rem_128,%function+.align	5+quot_rem_128:+	ldp	x3,x4,[x1]++	mul	x5,x3,x2	// divisor[0:1} * quotient+	umulh	x6,x3,x2+	mul	x11,  x4,x2+	umulh	x7,x4,x2++	ldp	x8,x9,[x0]	// load 3 limbs of the dividend+	ldr	x10,[x0,#16]++	adds	x6,x6,x11+	adc	x7,x7,xzr++	subs	x8,x8,x5	// dividend - divisor * quotient+	sbcs	x9,x9,x6+	sbcs	x10,x10,x7+	sbc	x5,xzr,xzr		// borrow -> mask++	add	x2,x2,x5	// if borrowed, adjust the quotient ...+	and	x3,x3,x5+	and	x4,x4,x5+	adds	x8,x8,x3	// ... and add divisor+	adc	x9,x9,x4++	stp	x8,x9,[x0]	// save 2 limbs of the remainder+	str	x2,[x0,#16]	// and one limb of the quotient++	mov	x0,x2		// return adjusted quotient++	ret+.size	quot_rem_128,.-quot_rem_128++.globl	quot_rem_64+.type	quot_rem_64,%function+.align	5+quot_rem_64:+	ldr	x3,[x1]+	ldr	x8,[x0]	// load 1 limb of the dividend++	mul	x5,x3,x2	// divisor * quotient++	sub	x8,x8,x5	// dividend - divisor * quotient++	stp	x8,x2,[x0]	// save remainder and quotient++	mov	x0,x2		// return quotient++	ret+.size	quot_rem_64,.-quot_rem_64
+ c-source/build/elf/div3w-x86_64.s view
@@ -0,0 +1,123 @@+.text	++.globl	div_3_limbs+.hidden	div_3_limbs+.type	div_3_limbs,@function+.align	32+div_3_limbs:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	(%rdi),%r8+	movq	8(%rdi),%r9+	xorq	%rax,%rax+	movl	$64,%ecx++.Loop:+	movq	%r8,%r10+	subq	%rsi,%r8+	movq	%r9,%r11+	sbbq	%rdx,%r9+	leaq	1(%rax,%rax,1),%rax+	movq	%rdx,%rdi+	cmovcq	%r10,%r8+	cmovcq	%r11,%r9+	sbbq	$0,%rax+	shlq	$63,%rdi+	shrq	$1,%rsi+	shrq	$1,%rdx+	orq	%rdi,%rsi+	subl	$1,%ecx+	jnz	.Loop++	leaq	1(%rax,%rax,1),%rcx+	sarq	$63,%rax++	subq	%rsi,%r8+	sbbq	%rdx,%r9+	sbbq	$0,%rcx++	orq	%rcx,%rax++	.byte	0xf3,0xc3+.cfi_endproc+.size	div_3_limbs,.-div_3_limbs+.globl	quot_rem_128+.hidden	quot_rem_128+.type	quot_rem_128,@function+.align	32+quot_rem_128:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	%rdx,%rax+	movq	%rdx,%rcx++	mulq	0(%rsi)+	movq	%rax,%r8+	movq	%rcx,%rax+	movq	%rdx,%r9++	mulq	8(%rsi)+	addq	%rax,%r9+	adcq	$0,%rdx++	movq	0(%rdi),%r10+	movq	8(%rdi),%r11+	movq	16(%rdi),%rax++	subq	%r8,%r10+	sbbq	%r9,%r11+	sbbq	%rdx,%rax+	sbbq	%r8,%r8++	addq	%r8,%rcx+	movq	%r8,%r9+	andq	0(%rsi),%r8+	andq	8(%rsi),%r9+	addq	%r8,%r10+	adcq	%r9,%r11++	movq	%r10,0(%rdi)+	movq	%r11,8(%rdi)+	movq	%rcx,16(%rdi)++	movq	%rcx,%rax++	.byte	0xf3,0xc3+.cfi_endproc+.size	quot_rem_128,.-quot_rem_128++++++.globl	quot_rem_64+.hidden	quot_rem_64+.type	quot_rem_64,@function+.align	32+quot_rem_64:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	%rdx,%rax+	imulq	0(%rsi),%rdx++	movq	0(%rdi),%r10++	subq	%rdx,%r10++	movq	%r10,0(%rdi)+	movq	%rax,8(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+.size	quot_rem_64,.-quot_rem_64++.section	.note.GNU-stack,"",@progbits+.section	.note.gnu.property,"a",@note+	.long	4,2f-1f,5+	.byte	0x47,0x4E,0x55,0+1:	.long	0xc0000002,4,3+.align	8+2:
+ c-source/build/elf/mul_mont_256-armv8.S view
@@ -0,0 +1,464 @@+.text++.globl	mul_mont_sparse_256+.hidden	mul_mont_sparse_256+.type	mul_mont_sparse_256,%function+.align	5+mul_mont_sparse_256:+	stp	x29,x30,[sp,#-64]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]++	ldp	x10,x11,[x1]+	ldr	x9,        [x2]+	ldp	x12,x13,[x1,#16]++	mul	x19,x10,x9+	ldp	x5,x6,[x3]+	mul	x20,x11,x9+	ldp	x7,x8,[x3,#16]+	mul	x21,x12,x9+	mul	x22,x13,x9++	umulh	x14,x10,x9+	umulh	x15,x11,x9+	mul	x3,x4,x19+	umulh	x16,x12,x9+	umulh	x17,x13,x9+	adds	x20,x20,x14+	//mul	x14,x5,x3+	adcs	x21,x21,x15+	mul	x15,x6,x3+	adcs	x22,x22,x16+	mul	x16,x7,x3+	adc	x23,xzr,    x17+	mul	x17,x8,x3+	ldr	x9,[x2,8*1]+	subs	xzr,x19,#1		//adds	x19,x19,x14+	umulh	x14,x5,x3+	adcs	x20,x20,x15+	umulh	x15,x6,x3+	adcs	x21,x21,x16+	umulh	x16,x7,x3+	adcs	x22,x22,x17+	umulh	x17,x8,x3+	adc	x23,x23,xzr++	adds	x19,x20,x14+	mul	x14,x10,x9+	adcs	x20,x21,x15+	mul	x15,x11,x9+	adcs	x21,x22,x16+	mul	x16,x12,x9+	adcs	x22,x23,x17+	mul	x17,x13,x9+	adc	x23,xzr,xzr++	adds	x19,x19,x14+	umulh	x14,x10,x9+	adcs	x20,x20,x15+	umulh	x15,x11,x9+	adcs	x21,x21,x16+	mul	x3,x4,x19+	umulh	x16,x12,x9+	adcs	x22,x22,x17+	umulh	x17,x13,x9+	adc	x23,x23,xzr++	adds	x20,x20,x14+	//mul	x14,x5,x3+	adcs	x21,x21,x15+	mul	x15,x6,x3+	adcs	x22,x22,x16+	mul	x16,x7,x3+	adc	x23,x23,x17+	mul	x17,x8,x3+	ldr	x9,[x2,8*2]+	subs	xzr,x19,#1		//adds	x19,x19,x14+	umulh	x14,x5,x3+	adcs	x20,x20,x15+	umulh	x15,x6,x3+	adcs	x21,x21,x16+	umulh	x16,x7,x3+	adcs	x22,x22,x17+	umulh	x17,x8,x3+	adc	x23,x23,xzr++	adds	x19,x20,x14+	mul	x14,x10,x9+	adcs	x20,x21,x15+	mul	x15,x11,x9+	adcs	x21,x22,x16+	mul	x16,x12,x9+	adcs	x22,x23,x17+	mul	x17,x13,x9+	adc	x23,xzr,xzr++	adds	x19,x19,x14+	umulh	x14,x10,x9+	adcs	x20,x20,x15+	umulh	x15,x11,x9+	adcs	x21,x21,x16+	mul	x3,x4,x19+	umulh	x16,x12,x9+	adcs	x22,x22,x17+	umulh	x17,x13,x9+	adc	x23,x23,xzr++	adds	x20,x20,x14+	//mul	x14,x5,x3+	adcs	x21,x21,x15+	mul	x15,x6,x3+	adcs	x22,x22,x16+	mul	x16,x7,x3+	adc	x23,x23,x17+	mul	x17,x8,x3+	ldr	x9,[x2,8*3]+	subs	xzr,x19,#1		//adds	x19,x19,x14+	umulh	x14,x5,x3+	adcs	x20,x20,x15+	umulh	x15,x6,x3+	adcs	x21,x21,x16+	umulh	x16,x7,x3+	adcs	x22,x22,x17+	umulh	x17,x8,x3+	adc	x23,x23,xzr++	adds	x19,x20,x14+	mul	x14,x10,x9+	adcs	x20,x21,x15+	mul	x15,x11,x9+	adcs	x21,x22,x16+	mul	x16,x12,x9+	adcs	x22,x23,x17+	mul	x17,x13,x9+	adc	x23,xzr,xzr++	adds	x19,x19,x14+	umulh	x14,x10,x9+	adcs	x20,x20,x15+	umulh	x15,x11,x9+	adcs	x21,x21,x16+	mul	x3,x4,x19+	umulh	x16,x12,x9+	adcs	x22,x22,x17+	umulh	x17,x13,x9+	adc	x23,x23,xzr++	adds	x20,x20,x14+	//mul	x14,x5,x3+	adcs	x21,x21,x15+	mul	x15,x6,x3+	adcs	x22,x22,x16+	mul	x16,x7,x3+	adc	x23,x23,x17+	mul	x17,x8,x3+	subs	xzr,x19,#1		//adds	x19,x19,x14+	umulh	x14,x5,x3+	adcs	x20,x20,x15+	umulh	x15,x6,x3+	adcs	x21,x21,x16+	umulh	x16,x7,x3+	adcs	x22,x22,x17+	umulh	x17,x8,x3+	adc	x23,x23,xzr++	adds	x19,x20,x14+	adcs	x20,x21,x15+	adcs	x21,x22,x16+	adcs	x22,x23,x17+	adc	x23,xzr,xzr++	subs	x14,x19,x5+	sbcs	x15,x20,x6+	sbcs	x16,x21,x7+	sbcs	x17,x22,x8+	sbcs	xzr,    x23,xzr++	csel	x19,x19,x14,lo+	csel	x20,x20,x15,lo+	csel	x21,x21,x16,lo+	csel	x22,x22,x17,lo++	stp	x19,x20,[x0]+	stp	x21,x22,[x0,#16]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldr	x29,[sp],#64+	ret+.size	mul_mont_sparse_256,.-mul_mont_sparse_256+.globl	sqr_mont_sparse_256+.hidden	sqr_mont_sparse_256+.type	sqr_mont_sparse_256,%function+.align	5+sqr_mont_sparse_256:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x5,x6,[x1]+	ldp	x7,x8,[x1,#16]+	mov	x4,x3++	////////////////////////////////////////////////////////////////+	//  |  |  |  |  |  |a1*a0|  |+	//  |  |  |  |  |a2*a0|  |  |+	//  |  |a3*a2|a3*a0|  |  |  |+	//  |  |  |  |a2*a1|  |  |  |+	//  |  |  |a3*a1|  |  |  |  |+	// *|  |  |  |  |  |  |  | 2|+	// +|a3*a3|a2*a2|a1*a1|a0*a0|+	//  |--+--+--+--+--+--+--+--|+	//  |A7|A6|A5|A4|A3|A2|A1|A0|, where Ax is x10+	//+	//  "can't overflow" below mark carrying into high part of+	//  multiplication result, which can't overflow, because it+	//  can never be all ones.++	mul	x11,x6,x5	// a[1]*a[0]+	umulh	x15,x6,x5+	mul	x12,x7,x5	// a[2]*a[0]+	umulh	x16,x7,x5+	mul	x13,x8,x5	// a[3]*a[0]+	umulh	x19,x8,x5++	adds	x12,x12,x15	// accumulate high parts of multiplication+	mul	x14,x7,x6	// a[2]*a[1]+	umulh	x15,x7,x6+	adcs	x13,x13,x16+	mul	x16,x8,x6	// a[3]*a[1]+	umulh	x17,x8,x6+	adc	x19,x19,xzr	// can't overflow++	mul	x20,x8,x7	// a[3]*a[2]+	umulh	x21,x8,x7++	adds	x15,x15,x16	// accumulate high parts of multiplication+	mul	x10,x5,x5	// a[0]*a[0]+	adc	x16,x17,xzr	// can't overflow++	adds	x13,x13,x14	// accumulate low parts of multiplication+	umulh	x5,x5,x5+	adcs	x19,x19,x15+	mul	x15,x6,x6	// a[1]*a[1]+	adcs	x20,x20,x16+	umulh	x6,x6,x6+	adc	x21,x21,xzr	// can't overflow++	adds	x11,x11,x11	// acc[1-6]*=2+	mul	x16,x7,x7	// a[2]*a[2]+	adcs	x12,x12,x12+	umulh	x7,x7,x7+	adcs	x13,x13,x13+	mul	x17,x8,x8	// a[3]*a[3]+	adcs	x19,x19,x19+	umulh	x8,x8,x8+	adcs	x20,x20,x20+	adcs	x21,x21,x21+	adc	x22,xzr,xzr++	adds	x11,x11,x5	// +a[i]*a[i]+	adcs	x12,x12,x15+	adcs	x13,x13,x6+	adcs	x19,x19,x16+	adcs	x20,x20,x7+	adcs	x21,x21,x17+	adc	x22,x22,x8++	bl	__mul_by_1_mont_256+	ldr	x30,[x29,#8]++	adds	x10,x10,x19	// accumulate upper half+	adcs	x11,x11,x20+	adcs	x12,x12,x21+	adcs	x13,x13,x22+	adc	x19,xzr,xzr++	subs	x14,x10,x5+	sbcs	x15,x11,x6+	sbcs	x16,x12,x7+	sbcs	x17,x13,x8+	sbcs	xzr,    x19,xzr++	csel	x10,x10,x14,lo+	csel	x11,x11,x15,lo+	csel	x12,x12,x16,lo+	csel	x13,x13,x17,lo++	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+	.inst	0xd50323bf+	ret+.size	sqr_mont_sparse_256,.-sqr_mont_sparse_256+.globl	from_mont_256+.hidden	from_mont_256+.type	from_mont_256,%function+.align	5+from_mont_256:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-16]!+	add	x29,sp,#0++	mov	x4,x3+	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]++	bl	__mul_by_1_mont_256+	ldr	x30,[x29,#8]++	subs	x14,x10,x5+	sbcs	x15,x11,x6+	sbcs	x16,x12,x7+	sbcs	x17,x13,x8++	csel	x10,x10,x14,lo+	csel	x11,x11,x15,lo+	csel	x12,x12,x16,lo+	csel	x13,x13,x17,lo++	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]++	ldr	x29,[sp],#16+	.inst	0xd50323bf+	ret+.size	from_mont_256,.-from_mont_256++.globl	redc_mont_256+.hidden	redc_mont_256+.type	redc_mont_256,%function+.align	5+redc_mont_256:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-16]!+	add	x29,sp,#0++	mov	x4,x3+	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]++	bl	__mul_by_1_mont_256+	ldr	x30,[x29,#8]++	ldp	x14,x15,[x1,#32]+	ldp	x16,x17,[x1,#48]++	adds	x10,x10,x14+	adcs	x11,x11,x15+	adcs	x12,x12,x16+	adcs	x13,x13,x17+	adc	x9,xzr,xzr++	subs	x14,x10,x5+	sbcs	x15,x11,x6+	sbcs	x16,x12,x7+	sbcs	x17,x13,x8+	sbcs	xzr,    x9,xzr++	csel	x10,x10,x14,lo+	csel	x11,x11,x15,lo+	csel	x12,x12,x16,lo+	csel	x13,x13,x17,lo++	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]++	ldr	x29,[sp],#16+	.inst	0xd50323bf+	ret+.size	redc_mont_256,.-redc_mont_256++.type	__mul_by_1_mont_256,%function+.align	5+__mul_by_1_mont_256:+	mul	x3,x4,x10+	ldp	x5,x6,[x2]+	ldp	x7,x8,[x2,#16]+	//mul	x14,x5,x3+	mul	x15,x6,x3+	mul	x16,x7,x3+	mul	x17,x8,x3+	subs	xzr,x10,#1		//adds	x10,x10,x14+	umulh	x14,x5,x3+	adcs	x11,x11,x15+	umulh	x15,x6,x3+	adcs	x12,x12,x16+	umulh	x16,x7,x3+	adcs	x13,x13,x17+	umulh	x17,x8,x3+	adc	x9,xzr,xzr++	adds	x10,x11,x14+	adcs	x11,x12,x15+	adcs	x12,x13,x16+	mul	x3,x4,x10+	adc	x13,x9,x17+	//mul	x14,x5,x3+	mul	x15,x6,x3+	mul	x16,x7,x3+	mul	x17,x8,x3+	subs	xzr,x10,#1		//adds	x10,x10,x14+	umulh	x14,x5,x3+	adcs	x11,x11,x15+	umulh	x15,x6,x3+	adcs	x12,x12,x16+	umulh	x16,x7,x3+	adcs	x13,x13,x17+	umulh	x17,x8,x3+	adc	x9,xzr,xzr++	adds	x10,x11,x14+	adcs	x11,x12,x15+	adcs	x12,x13,x16+	mul	x3,x4,x10+	adc	x13,x9,x17+	//mul	x14,x5,x3+	mul	x15,x6,x3+	mul	x16,x7,x3+	mul	x17,x8,x3+	subs	xzr,x10,#1		//adds	x10,x10,x14+	umulh	x14,x5,x3+	adcs	x11,x11,x15+	umulh	x15,x6,x3+	adcs	x12,x12,x16+	umulh	x16,x7,x3+	adcs	x13,x13,x17+	umulh	x17,x8,x3+	adc	x9,xzr,xzr++	adds	x10,x11,x14+	adcs	x11,x12,x15+	adcs	x12,x13,x16+	mul	x3,x4,x10+	adc	x13,x9,x17+	//mul	x14,x5,x3+	mul	x15,x6,x3+	mul	x16,x7,x3+	mul	x17,x8,x3+	subs	xzr,x10,#1		//adds	x10,x10,x14+	umulh	x14,x5,x3+	adcs	x11,x11,x15+	umulh	x15,x6,x3+	adcs	x12,x12,x16+	umulh	x16,x7,x3+	adcs	x13,x13,x17+	umulh	x17,x8,x3+	adc	x9,xzr,xzr++	adds	x10,x11,x14+	adcs	x11,x12,x15+	adcs	x12,x13,x16+	adc	x13,x9,x17++	ret+.size	__mul_by_1_mont_256,.-__mul_by_1_mont_256
+ c-source/build/elf/mul_mont_384-armv8.S view
@@ -0,0 +1,2372 @@+.text++.globl	add_mod_384x384+.type	add_mod_384x384,%function+.align	5+add_mod_384x384:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-64]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]++	ldp	x5,x6,[x3]+	ldp	x7,x8,[x3,#16]+	ldp	x9,x10,[x3,#32]++	bl	__add_mod_384x384+	ldr	x30,[x29,#8]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldr	x29,[sp],#64+	.inst	0xd50323bf+	ret+.size	add_mod_384x384,.-add_mod_384x384++.type	__add_mod_384x384,%function+.align	5+__add_mod_384x384:+	ldp	x11,  x12,  [x1]+	ldp	x19,x20,[x2]+	ldp	x13,  x14,  [x1,#16]+	adds	x11,x11,x19+	ldp	x21,x22,[x2,#16]+	adcs	x12,x12,x20+	ldp	x15,  x16,  [x1,#32]+	adcs	x13,x13,x21+	ldp	x23,x24,[x2,#32]+	adcs	x14,x14,x22+	stp	x11,  x12,  [x0]+	adcs	x15,x15,x23+	ldp	x11,  x12,  [x1,#48]+	adcs	x16,x16,x24++	ldp	x19,x20,[x2,#48]+	stp	x13,  x14,  [x0,#16]+	ldp	x13,  x14,  [x1,#64]+	ldp	x21,x22,[x2,#64]++	adcs	x11,x11,x19+	stp	x15,  x16,  [x0,#32]+	adcs	x12,x12,x20+	ldp	x15,  x16,  [x1,#80]+	adcs	x13,x13,x21+	ldp	x23,x24,[x2,#80]+	adcs	x14,x14,x22+	adcs	x15,x15,x23+	adcs	x16,x16,x24+	adc	x17,xzr,xzr++	subs	x19,x11,x5+	sbcs	x20,x12,x6+	sbcs	x21,x13,x7+	sbcs	x22,x14,x8+	sbcs	x23,x15,x9+	sbcs	x24,x16,x10+	sbcs	xzr,x17,xzr++	csel	x11,x11,x19,lo+	csel	x12,x12,x20,lo+	csel	x13,x13,x21,lo+	csel	x14,x14,x22,lo+	stp	x11,x12,[x0,#48]+	csel	x15,x15,x23,lo+	stp	x13,x14,[x0,#64]+	csel	x16,x16,x24,lo+	stp	x15,x16,[x0,#80]++	ret+.size	__add_mod_384x384,.-__add_mod_384x384++.globl	sub_mod_384x384+.type	sub_mod_384x384,%function+.align	5+sub_mod_384x384:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-64]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]++	ldp	x5,x6,[x3]+	ldp	x7,x8,[x3,#16]+	ldp	x9,x10,[x3,#32]++	bl	__sub_mod_384x384+	ldr	x30,[x29,#8]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldr	x29,[sp],#64+	.inst	0xd50323bf+	ret+.size	sub_mod_384x384,.-sub_mod_384x384++.type	__sub_mod_384x384,%function+.align	5+__sub_mod_384x384:+	ldp	x11,  x12,  [x1]+	ldp	x19,x20,[x2]+	ldp	x13,  x14,  [x1,#16]+	subs	x11,x11,x19+	ldp	x21,x22,[x2,#16]+	sbcs	x12,x12,x20+	ldp	x15,  x16,  [x1,#32]+	sbcs	x13,x13,x21+	ldp	x23,x24,[x2,#32]+	sbcs	x14,x14,x22+	stp	x11,  x12,  [x0]+	sbcs	x15,x15,x23+	ldp	x11,  x12,  [x1,#48]+	sbcs	x16,x16,x24++	ldp	x19,x20,[x2,#48]+	stp	x13,  x14,  [x0,#16]+	ldp	x13,  x14,  [x1,#64]+	ldp	x21,x22,[x2,#64]++	sbcs	x11,x11,x19+	stp	x15,  x16,  [x0,#32]+	sbcs	x12,x12,x20+	ldp	x15,  x16,  [x1,#80]+	sbcs	x13,x13,x21+	ldp	x23,x24,[x2,#80]+	sbcs	x14,x14,x22+	sbcs	x15,x15,x23+	sbcs	x16,x16,x24+	sbc	x17,xzr,xzr++	and	x19,x5,x17+	and	x20,x6,x17+	adds	x11,x11,x19+	and	x21,x7,x17+	adcs	x12,x12,x20+	and	x22,x8,x17+	adcs	x13,x13,x21+	and	x23,x9,x17+	adcs	x14,x14,x22+	and	x24,x10,x17+	adcs	x15,x15,x23+	stp	x11,x12,[x0,#48]+	adc	x16,x16,x24+	stp	x13,x14,[x0,#64]+	stp	x15,x16,[x0,#80]++	ret+.size	__sub_mod_384x384,.-__sub_mod_384x384++.type	__add_mod_384,%function+.align	5+__add_mod_384:+	ldp	x11,  x12,  [x1]+	ldp	x19,x20,[x2]+	ldp	x13,  x14,  [x1,#16]+	adds	x11,x11,x19+	ldp	x21,x22,[x2,#16]+	adcs	x12,x12,x20+	ldp	x15,  x16,  [x1,#32]+	adcs	x13,x13,x21+	ldp	x23,x24,[x2,#32]+	adcs	x14,x14,x22+	adcs	x15,x15,x23+	adcs	x16,x16,x24+	adc	x17,xzr,xzr++	subs	x19,x11,x5+	sbcs	x20,x12,x6+	sbcs	x21,x13,x7+	sbcs	x22,x14,x8+	sbcs	x23,x15,x9+	sbcs	x24,x16,x10+	sbcs	xzr,x17,xzr++	csel	x11,x11,x19,lo+	csel	x12,x12,x20,lo+	csel	x13,x13,x21,lo+	csel	x14,x14,x22,lo+	csel	x15,x15,x23,lo+	stp	x11,x12,[x0]+	csel	x16,x16,x24,lo+	stp	x13,x14,[x0,#16]+	stp	x15,x16,[x0,#32]++	ret+.size	__add_mod_384,.-__add_mod_384++.type	__sub_mod_384,%function+.align	5+__sub_mod_384:+	ldp	x11,  x12,  [x1]+	ldp	x19,x20,[x2]+	ldp	x13,  x14,  [x1,#16]+	subs	x11,x11,x19+	ldp	x21,x22,[x2,#16]+	sbcs	x12,x12,x20+	ldp	x15,  x16,  [x1,#32]+	sbcs	x13,x13,x21+	ldp	x23,x24,[x2,#32]+	sbcs	x14,x14,x22+	sbcs	x15,x15,x23+	sbcs	x16,x16,x24+	sbc	x17,xzr,xzr++	and	x19,x5,x17+	and	x20,x6,x17+	adds	x11,x11,x19+	and	x21,x7,x17+	adcs	x12,x12,x20+	and	x22,x8,x17+	adcs	x13,x13,x21+	and	x23,x9,x17+	adcs	x14,x14,x22+	and	x24,x10,x17+	adcs	x15,x15,x23+	stp	x11,x12,[x0]+	adc	x16,x16,x24+	stp	x13,x14,[x0,#16]+	stp	x15,x16,[x0,#32]++	ret+.size	__sub_mod_384,.-__sub_mod_384++.globl	mul_mont_384x+.hidden	mul_mont_384x+.type	mul_mont_384x,%function+.align	5+mul_mont_384x:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	sub	sp,sp,#288		// space for 3 768-bit vectors++	mov	x26,x0		// save r_ptr+	mov	x27,x1		// save b_ptr+	mov	x28,x2		// save b_ptr++	sub	x0,sp,#0		// mul_384(t0, a->re, b->re)+	bl	__mul_384++	add	x1,x1,#48	// mul_384(t1, a->im, b->im)+	add	x2,x2,#48+	add	x0,sp,#96+	bl	__mul_384++	ldp	x5,x6,[x3]+	ldp	x7,x8,[x3,#16]+	ldp	x9,x10,[x3,#32]++	sub	x2,x1,#48+	add	x0,sp,#240+	bl	__add_mod_384++	add	x1,x28,#0+	add	x2,x28,#48+	add	x0,sp,#192		// t2+	bl	__add_mod_384++	add	x1,x0,#0+	add	x2,x0,#48+	bl	__mul_384		// mul_384(t2, a->re+a->im, b->re+b->im)++	ldp	x5,x6,[x3]+	ldp	x7,x8,[x3,#16]+	ldp	x9,x10,[x3,#32]++	mov	x1,x0+	add	x2,sp,#0+	bl	__sub_mod_384x384++	add	x2,sp,#96+	bl	__sub_mod_384x384	// t2 = t2-t0-t1++	add	x1,sp,#0+	add	x2,sp,#96+	add	x0,sp,#0+	bl	__sub_mod_384x384	// t0 = t0-t1++	add	x1,sp,#0		// ret->re = redc(t0)+	add	x0,x26,#0+	bl	__mul_by_1_mont_384+	bl	__redc_tail_mont_384++	add	x1,sp,#192		// ret->im = redc(t2)+	add	x0,x0,#48+	bl	__mul_by_1_mont_384+	bl	__redc_tail_mont_384+	ldr	x30,[x29,#8]++	add	sp,sp,#288+	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+	.inst	0xd50323bf+	ret+.size	mul_mont_384x,.-mul_mont_384x++.globl	sqr_mont_384x+.hidden	sqr_mont_384x+.type	sqr_mont_384x,%function+.align	5+sqr_mont_384x:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	stp	x3,x0,[sp,#96]	// __mul_mont_384 wants them there+	sub	sp,sp,#96		// space for 2 384-bit vectors+	mov	x4,x3		// adjust for missing b_ptr++	ldp	x5,x6,[x2]+	ldp	x7,x8,[x2,#16]+	ldp	x9,x10,[x2,#32]++	add	x2,x1,#48+	add	x0,sp,#0+	bl	__add_mod_384		// t0 = a->re + a->im++	add	x0,sp,#48+	bl	__sub_mod_384		// t1 = a->re - a->im++	ldp	x11,x12,[x1]+	ldr	x17,        [x2]+	ldp	x13,x14,[x1,#16]+	ldp	x15,x16,[x1,#32]++	bl	__mul_mont_384		// mul_mont_384(ret->im, a->re, a->im)++	adds	x11,x11,x11	// add with itself+	adcs	x12,x12,x12+	adcs	x13,x13,x13+	adcs	x14,x14,x14+	adcs	x15,x15,x15+	adcs	x16,x16,x16+	adc	x25,xzr,xzr++	subs	x19,x11,x5+	sbcs	x20,x12,x6+	sbcs	x21,x13,x7+	sbcs	x22,x14,x8+	sbcs	x23,x15,x9+	sbcs	x24,x16,x10+	sbcs	xzr,x25,xzr++	csel	x19,x11,x19,lo+	csel	x20,x12,x20,lo+	csel	x21,x13,x21,lo+	ldp	x11,x12,[sp]+	csel	x22,x14,x22,lo+	ldr	x17,        [sp,#48]+	csel	x23,x15,x23,lo+	ldp	x13,x14,[sp,#16]+	csel	x24,x16,x24,lo+	ldp	x15,x16,[sp,#32]++	stp	x19,x20,[x2,#48]+	stp	x21,x22,[x2,#64]+	stp	x23,x24,[x2,#80]++	add	x2,sp,#48+	bl	__mul_mont_384		// mul_mont_384(ret->re, t0, t1)+	ldr	x30,[x29,#8]++	stp	x11,x12,[x2]+	stp	x13,x14,[x2,#16]+	stp	x15,x16,[x2,#32]++	add	sp,sp,#96+	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+	.inst	0xd50323bf+	ret+.size	sqr_mont_384x,.-sqr_mont_384x++.globl	mul_mont_384+.hidden	mul_mont_384+.type	mul_mont_384,%function+.align	5+mul_mont_384:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	stp	x4,x0,[sp,#96]	// __mul_mont_384 wants them there++	ldp	x11,x12,[x1]+	ldr	x17,        [x2]+	ldp	x13,x14,[x1,#16]+	ldp	x15,x16,[x1,#32]++	ldp	x5,x6,[x3]+	ldp	x7,x8,[x3,#16]+	ldp	x9,x10,[x3,#32]++	bl	__mul_mont_384+	ldr	x30,[x29,#8]++	stp	x11,x12,[x2]+	stp	x13,x14,[x2,#16]+	stp	x15,x16,[x2,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+	.inst	0xd50323bf+	ret+.size	mul_mont_384,.-mul_mont_384++.type	__mul_mont_384,%function+.align	5+__mul_mont_384:+	mul	x19,x11,x17+	mul	x20,x12,x17+	mul	x21,x13,x17+	mul	x22,x14,x17+	mul	x23,x15,x17+	mul	x24,x16,x17+	mul	x4,x4,x19++	umulh	x26,x11,x17+	umulh	x27,x12,x17+	umulh	x28,x13,x17+	umulh	x0,x14,x17+	umulh	x1,x15,x17+	umulh	x3,x16,x17++	adds	x20,x20,x26+	// mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adc	x25,xzr,    x3+	mul	x3,x10,x4+	mov	x17,xzr+	subs	xzr,x19,#1		// adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adcs	x25,x25,xzr+	adc	x4,x17,xzr+	ldr	x17,[x2,8*1]++	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,x4,xzr+	ldr	x4,[x29,#96]++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adcs	x25,x25,xzr+	adc	x17,xzr,xzr++	adds	x20,x20,x26+	// mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adcs	x25,x25,x3+	mul	x3,x10,x4+	adc	x17,x17,xzr+	subs	xzr,x19,#1		// adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adcs	x25,x25,xzr+	adc	x4,x17,xzr+	ldr	x17,[x2,8*2]++	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,x4,xzr+	ldr	x4,[x29,#96]++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adcs	x25,x25,xzr+	adc	x17,xzr,xzr++	adds	x20,x20,x26+	// mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adcs	x25,x25,x3+	mul	x3,x10,x4+	adc	x17,x17,xzr+	subs	xzr,x19,#1		// adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adcs	x25,x25,xzr+	adc	x4,x17,xzr+	ldr	x17,[x2,8*3]++	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,x4,xzr+	ldr	x4,[x29,#96]++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adcs	x25,x25,xzr+	adc	x17,xzr,xzr++	adds	x20,x20,x26+	// mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adcs	x25,x25,x3+	mul	x3,x10,x4+	adc	x17,x17,xzr+	subs	xzr,x19,#1		// adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adcs	x25,x25,xzr+	adc	x4,x17,xzr+	ldr	x17,[x2,8*4]++	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,x4,xzr+	ldr	x4,[x29,#96]++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adcs	x25,x25,xzr+	adc	x17,xzr,xzr++	adds	x20,x20,x26+	// mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adcs	x25,x25,x3+	mul	x3,x10,x4+	adc	x17,x17,xzr+	subs	xzr,x19,#1		// adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adcs	x25,x25,xzr+	adc	x4,x17,xzr+	ldr	x17,[x2,8*5]++	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,x4,xzr+	ldr	x4,[x29,#96]++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adcs	x25,x25,xzr+	adc	x17,xzr,xzr++	adds	x20,x20,x26+	// mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adcs	x25,x25,x3+	mul	x3,x10,x4+	adc	x17,x17,xzr+	subs	xzr,x19,#1		// adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adcs	x25,x25,xzr+	ldp	x4,x2,[x29,#96]	// pull r_ptr+	adc	x17,x17,xzr++	adds	x19,x20,x26+	adcs	x20,x21,x27+	adcs	x21,x22,x28+	adcs	x22,x23,x0+	adcs	x23,x24,x1+	adcs	x24,x25,x3+	adc	x25,x17,xzr++	subs	x26,x19,x5+	sbcs	x27,x20,x6+	sbcs	x28,x21,x7+	sbcs	x0,x22,x8+	sbcs	x1,x23,x9+	sbcs	x3,x24,x10+	sbcs	xzr,    x25,xzr++	csel	x11,x19,x26,lo+	csel	x12,x20,x27,lo+	csel	x13,x21,x28,lo+	csel	x14,x22,x0,lo+	csel	x15,x23,x1,lo+	csel	x16,x24,x3,lo+	ret+.size	__mul_mont_384,.-__mul_mont_384++.globl	sqr_mont_384+.hidden	sqr_mont_384+.type	sqr_mont_384,%function+.align	5+sqr_mont_384:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	sub	sp,sp,#96		// space for 768-bit vector+	mov	x4,x3		// adjust for missing b_ptr++	mov	x3,x0		// save r_ptr+	mov	x0,sp++	ldp	x11,x12,[x1]+	ldp	x13,x14,[x1,#16]+	ldp	x15,x16,[x1,#32]++	bl	__sqr_384++	ldp	x5,x6,[x2]+	ldp	x7,x8,[x2,#16]+	ldp	x9,x10,[x2,#32]++	mov	x1,sp+	mov	x0,x3		// restore r_ptr+	bl	__mul_by_1_mont_384+	bl	__redc_tail_mont_384+	ldr	x30,[x29,#8]++	add	sp,sp,#96+	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+	.inst	0xd50323bf+	ret+.size	sqr_mont_384,.-sqr_mont_384++.globl	sqr_n_mul_mont_383+.hidden	sqr_n_mul_mont_383+.type	sqr_n_mul_mont_383,%function+.align	5+sqr_n_mul_mont_383:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	stp	x4,x0,[sp,#96]	// __mul_mont_384 wants them there+	sub	sp,sp,#96		// space for 768-bit vector+	mov	x17,x5			// save b_ptr++	ldp	x11,x12,[x1]+	ldp	x13,x14,[x1,#16]+	ldp	x15,x16,[x1,#32]+	mov	x0,sp+.Loop_sqr_383:+	bl	__sqr_384+	sub	x2,x2,#1	// counter++	ldp	x5,x6,[x3]+	ldp	x7,x8,[x3,#16]+	ldp	x9,x10,[x3,#32]++	mov	x1,sp+	bl	__mul_by_1_mont_384++	ldp	x19,x20,[x1,#48]+	ldp	x21,x22,[x1,#64]+	ldp	x23,x24,[x1,#80]++	adds	x11,x11,x19	// just accumulate upper half+	adcs	x12,x12,x20+	adcs	x13,x13,x21+	adcs	x14,x14,x22+	adcs	x15,x15,x23+	adc	x16,x16,x24++	cbnz	x2,.Loop_sqr_383++	mov	x2,x17+	ldr	x17,[x17]+	bl	__mul_mont_384+	ldr	x30,[x29,#8]++	stp	x11,x12,[x2]+	stp	x13,x14,[x2,#16]+	stp	x15,x16,[x2,#32]++	add	sp,sp,#96+	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+	.inst	0xd50323bf+	ret+.size	sqr_n_mul_mont_383,.-sqr_n_mul_mont_383+.type	__sqr_384,%function+.align	5+__sqr_384:+	mul	x19,x12,x11+	mul	x20,x13,x11+	mul	x21,x14,x11+	mul	x22,x15,x11+	mul	x23,x16,x11++	umulh	x6,x12,x11+	umulh	x7,x13,x11+	umulh	x8,x14,x11+	umulh	x9,x15,x11+	adds	x20,x20,x6+	umulh	x10,x16,x11+	adcs	x21,x21,x7+	mul	x7,x13,x12+	adcs	x22,x22,x8+	mul	x8,x14,x12+	adcs	x23,x23,x9+	mul	x9,x15,x12+	adc	x24,xzr,    x10+	mul	x10,x16,x12++	adds	x21,x21,x7+	umulh	x7,x13,x12+	adcs	x22,x22,x8+	umulh	x8,x14,x12+	adcs	x23,x23,x9+	umulh	x9,x15,x12+	adcs	x24,x24,x10+	umulh	x10,x16,x12+	adc	x25,xzr,xzr++	mul	x5,x11,x11+	adds	x22,x22,x7+	umulh	x11,  x11,x11+	adcs	x23,x23,x8+	mul	x8,x14,x13+	adcs	x24,x24,x9+	mul	x9,x15,x13+	adc	x25,x25,x10+	mul	x10,x16,x13++	adds	x23,x23,x8+	umulh	x8,x14,x13+	adcs	x24,x24,x9+	umulh	x9,x15,x13+	adcs	x25,x25,x10+	umulh	x10,x16,x13+	adc	x26,xzr,xzr++	mul	x6,x12,x12+	adds	x24,x24,x8+	umulh	x12,  x12,x12+	adcs	x25,x25,x9+	mul	x9,x15,x14+	adc	x26,x26,x10+	mul	x10,x16,x14++	adds	x25,x25,x9+	umulh	x9,x15,x14+	adcs	x26,x26,x10+	umulh	x10,x16,x14+	adc	x27,xzr,xzr+	mul	x7,x13,x13+	adds	x26,x26,x9+	umulh	x13,  x13,x13+	adc	x27,x27,x10+	mul	x8,x14,x14++	mul	x10,x16,x15+	umulh	x14,  x14,x14+	adds	x27,x27,x10+	umulh	x10,x16,x15+	mul	x9,x15,x15+	adc	x28,x10,xzr++	adds	x19,x19,x19+	adcs	x20,x20,x20+	adcs	x21,x21,x21+	adcs	x22,x22,x22+	adcs	x23,x23,x23+	adcs	x24,x24,x24+	adcs	x25,x25,x25+	adcs	x26,x26,x26+	umulh	x15,  x15,x15+	adcs	x27,x27,x27+	mul	x10,x16,x16+	adcs	x28,x28,x28+	umulh	x16,  x16,x16+	adc	x1,xzr,xzr++	adds	x19,x19,x11+	adcs	x20,x20,x6+	adcs	x21,x21,x12+	adcs	x22,x22,x7+	adcs	x23,x23,x13+	adcs	x24,x24,x8+	adcs	x25,x25,x14+	stp	x5,x19,[x0]+	adcs	x26,x26,x9+	stp	x20,x21,[x0,#16]+	adcs	x27,x27,x15+	stp	x22,x23,[x0,#32]+	adcs	x28,x28,x10+	stp	x24,x25,[x0,#48]+	adc	x16,x16,x1+	stp	x26,x27,[x0,#64]+	stp	x28,x16,[x0,#80]++	ret+.size	__sqr_384,.-__sqr_384+.globl	sqr_384+.hidden	sqr_384+.type	sqr_384,%function+.align	5+sqr_384:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]++	ldp	x11,x12,[x1]+	ldp	x13,x14,[x1,#16]+	ldp	x15,x16,[x1,#32]++	bl	__sqr_384+	ldr	x30,[x29,#8]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+	.inst	0xd50323bf+	ret+.size	sqr_384,.-sqr_384++.globl	redc_mont_384+.hidden	redc_mont_384+.type	redc_mont_384,%function+.align	5+redc_mont_384:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	mov	x4,x3		// adjust for missing b_ptr++	ldp	x5,x6,[x2]+	ldp	x7,x8,[x2,#16]+	ldp	x9,x10,[x2,#32]++	bl	__mul_by_1_mont_384+	bl	__redc_tail_mont_384+	ldr	x30,[x29,#8]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+	.inst	0xd50323bf+	ret+.size	redc_mont_384,.-redc_mont_384++.globl	from_mont_384+.hidden	from_mont_384+.type	from_mont_384,%function+.align	5+from_mont_384:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	mov	x4,x3		// adjust for missing b_ptr++	ldp	x5,x6,[x2]+	ldp	x7,x8,[x2,#16]+	ldp	x9,x10,[x2,#32]++	bl	__mul_by_1_mont_384+	ldr	x30,[x29,#8]++	subs	x19,x11,x5+	sbcs	x20,x12,x6+	sbcs	x21,x13,x7+	sbcs	x22,x14,x8+	sbcs	x23,x15,x9+	sbcs	x24,x16,x10++	csel	x11,x11,x19,lo+	csel	x12,x12,x20,lo+	csel	x13,x13,x21,lo+	csel	x14,x14,x22,lo+	csel	x15,x15,x23,lo+	csel	x16,x16,x24,lo++	stp	x11,x12,[x0]+	stp	x13,x14,[x0,#16]+	stp	x15,x16,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+	.inst	0xd50323bf+	ret+.size	from_mont_384,.-from_mont_384++.type	__mul_by_1_mont_384,%function+.align	5+__mul_by_1_mont_384:+	ldp	x11,x12,[x1]+	ldp	x13,x14,[x1,#16]+	mul	x26,x4,x11+	ldp	x15,x16,[x1,#32]++	// mul	x19,x5,x26+	mul	x20,x6,x26+	mul	x21,x7,x26+	mul	x22,x8,x26+	mul	x23,x9,x26+	mul	x24,x10,x26+	subs	xzr,x11,#1		// adds	x19,x19,x11+	umulh	x11,x5,x26+	adcs	x20,x20,x12+	umulh	x12,x6,x26+	adcs	x21,x21,x13+	umulh	x13,x7,x26+	adcs	x22,x22,x14+	umulh	x14,x8,x26+	adcs	x23,x23,x15+	umulh	x15,x9,x26+	adcs	x24,x24,x16+	umulh	x16,x10,x26+	adc	x25,xzr,xzr+	adds	x11,x11,x20+	adcs	x12,x12,x21+	adcs	x13,x13,x22+	mul	x26,x4,x11+	adcs	x14,x14,x23+	adcs	x15,x15,x24+	adc	x16,x16,x25++	// mul	x19,x5,x26+	mul	x20,x6,x26+	mul	x21,x7,x26+	mul	x22,x8,x26+	mul	x23,x9,x26+	mul	x24,x10,x26+	subs	xzr,x11,#1		// adds	x19,x19,x11+	umulh	x11,x5,x26+	adcs	x20,x20,x12+	umulh	x12,x6,x26+	adcs	x21,x21,x13+	umulh	x13,x7,x26+	adcs	x22,x22,x14+	umulh	x14,x8,x26+	adcs	x23,x23,x15+	umulh	x15,x9,x26+	adcs	x24,x24,x16+	umulh	x16,x10,x26+	adc	x25,xzr,xzr+	adds	x11,x11,x20+	adcs	x12,x12,x21+	adcs	x13,x13,x22+	mul	x26,x4,x11+	adcs	x14,x14,x23+	adcs	x15,x15,x24+	adc	x16,x16,x25++	// mul	x19,x5,x26+	mul	x20,x6,x26+	mul	x21,x7,x26+	mul	x22,x8,x26+	mul	x23,x9,x26+	mul	x24,x10,x26+	subs	xzr,x11,#1		// adds	x19,x19,x11+	umulh	x11,x5,x26+	adcs	x20,x20,x12+	umulh	x12,x6,x26+	adcs	x21,x21,x13+	umulh	x13,x7,x26+	adcs	x22,x22,x14+	umulh	x14,x8,x26+	adcs	x23,x23,x15+	umulh	x15,x9,x26+	adcs	x24,x24,x16+	umulh	x16,x10,x26+	adc	x25,xzr,xzr+	adds	x11,x11,x20+	adcs	x12,x12,x21+	adcs	x13,x13,x22+	mul	x26,x4,x11+	adcs	x14,x14,x23+	adcs	x15,x15,x24+	adc	x16,x16,x25++	// mul	x19,x5,x26+	mul	x20,x6,x26+	mul	x21,x7,x26+	mul	x22,x8,x26+	mul	x23,x9,x26+	mul	x24,x10,x26+	subs	xzr,x11,#1		// adds	x19,x19,x11+	umulh	x11,x5,x26+	adcs	x20,x20,x12+	umulh	x12,x6,x26+	adcs	x21,x21,x13+	umulh	x13,x7,x26+	adcs	x22,x22,x14+	umulh	x14,x8,x26+	adcs	x23,x23,x15+	umulh	x15,x9,x26+	adcs	x24,x24,x16+	umulh	x16,x10,x26+	adc	x25,xzr,xzr+	adds	x11,x11,x20+	adcs	x12,x12,x21+	adcs	x13,x13,x22+	mul	x26,x4,x11+	adcs	x14,x14,x23+	adcs	x15,x15,x24+	adc	x16,x16,x25++	// mul	x19,x5,x26+	mul	x20,x6,x26+	mul	x21,x7,x26+	mul	x22,x8,x26+	mul	x23,x9,x26+	mul	x24,x10,x26+	subs	xzr,x11,#1		// adds	x19,x19,x11+	umulh	x11,x5,x26+	adcs	x20,x20,x12+	umulh	x12,x6,x26+	adcs	x21,x21,x13+	umulh	x13,x7,x26+	adcs	x22,x22,x14+	umulh	x14,x8,x26+	adcs	x23,x23,x15+	umulh	x15,x9,x26+	adcs	x24,x24,x16+	umulh	x16,x10,x26+	adc	x25,xzr,xzr+	adds	x11,x11,x20+	adcs	x12,x12,x21+	adcs	x13,x13,x22+	mul	x26,x4,x11+	adcs	x14,x14,x23+	adcs	x15,x15,x24+	adc	x16,x16,x25++	// mul	x19,x5,x26+	mul	x20,x6,x26+	mul	x21,x7,x26+	mul	x22,x8,x26+	mul	x23,x9,x26+	mul	x24,x10,x26+	subs	xzr,x11,#1		// adds	x19,x19,x11+	umulh	x11,x5,x26+	adcs	x20,x20,x12+	umulh	x12,x6,x26+	adcs	x21,x21,x13+	umulh	x13,x7,x26+	adcs	x22,x22,x14+	umulh	x14,x8,x26+	adcs	x23,x23,x15+	umulh	x15,x9,x26+	adcs	x24,x24,x16+	umulh	x16,x10,x26+	adc	x25,xzr,xzr+	adds	x11,x11,x20+	adcs	x12,x12,x21+	adcs	x13,x13,x22+	adcs	x14,x14,x23+	adcs	x15,x15,x24+	adc	x16,x16,x25++	ret+.size	__mul_by_1_mont_384,.-__mul_by_1_mont_384++.type	__redc_tail_mont_384,%function+.align	5+__redc_tail_mont_384:+	ldp	x19,x20,[x1,#48]+	ldp	x21,x22,[x1,#64]+	ldp	x23,x24,[x1,#80]++	adds	x11,x11,x19	// accumulate upper half+	adcs	x12,x12,x20+	adcs	x13,x13,x21+	adcs	x14,x14,x22+	adcs	x15,x15,x23+	adcs	x16,x16,x24+	adc	x25,xzr,xzr++	subs	x19,x11,x5+	sbcs	x20,x12,x6+	sbcs	x21,x13,x7+	sbcs	x22,x14,x8+	sbcs	x23,x15,x9+	sbcs	x24,x16,x10+	sbcs	xzr,x25,xzr++	csel	x11,x11,x19,lo+	csel	x12,x12,x20,lo+	csel	x13,x13,x21,lo+	csel	x14,x14,x22,lo+	csel	x15,x15,x23,lo+	csel	x16,x16,x24,lo++	stp	x11,x12,[x0]+	stp	x13,x14,[x0,#16]+	stp	x15,x16,[x0,#32]++	ret+.size	__redc_tail_mont_384,.-__redc_tail_mont_384++.globl	mul_384+.hidden	mul_384+.type	mul_384,%function+.align	5+mul_384:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]++	bl	__mul_384+	ldr	x30,[x29,#8]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+	.inst	0xd50323bf+	ret+.size	mul_384,.-mul_384++.type	__mul_384,%function+.align	5+__mul_384:+	ldp	x11,x12,[x1]+	ldr	x17,        [x2]+	ldp	x13,x14,[x1,#16]+	ldp	x15,x16,[x1,#32]++	mul	x19,x11,x17+	mul	x20,x12,x17+	mul	x21,x13,x17+	mul	x22,x14,x17+	mul	x23,x15,x17+	mul	x24,x16,x17++	umulh	x5,x11,x17+	umulh	x6,x12,x17+	umulh	x7,x13,x17+	umulh	x8,x14,x17+	umulh	x9,x15,x17+	umulh	x10,x16,x17+	ldr	x17,[x2,8*1]++	str	x19,[x0]+	adds	x19,x20,x5+	mul	x5,x11,x17+	adcs	x20,x21,x6+	mul	x6,x12,x17+	adcs	x21,x22,x7+	mul	x7,x13,x17+	adcs	x22,x23,x8+	mul	x8,x14,x17+	adcs	x23,x24,x9+	mul	x9,x15,x17+	adc	x24,xzr,    x10+	mul	x10,x16,x17+	adds	x19,x19,x5+	umulh	x5,x11,x17+	adcs	x20,x20,x6+	umulh	x6,x12,x17+	adcs	x21,x21,x7+	umulh	x7,x13,x17+	adcs	x22,x22,x8+	umulh	x8,x14,x17+	adcs	x23,x23,x9+	umulh	x9,x15,x17+	adcs	x24,x24,x10+	umulh	x10,x16,x17+	ldr	x17,[x2,#8*(1+1)]+	adc	x25,xzr,xzr++	str	x19,[x0,8*1]+	adds	x19,x20,x5+	mul	x5,x11,x17+	adcs	x20,x21,x6+	mul	x6,x12,x17+	adcs	x21,x22,x7+	mul	x7,x13,x17+	adcs	x22,x23,x8+	mul	x8,x14,x17+	adcs	x23,x24,x9+	mul	x9,x15,x17+	adc	x24,x25,x10+	mul	x10,x16,x17+	adds	x19,x19,x5+	umulh	x5,x11,x17+	adcs	x20,x20,x6+	umulh	x6,x12,x17+	adcs	x21,x21,x7+	umulh	x7,x13,x17+	adcs	x22,x22,x8+	umulh	x8,x14,x17+	adcs	x23,x23,x9+	umulh	x9,x15,x17+	adcs	x24,x24,x10+	umulh	x10,x16,x17+	ldr	x17,[x2,#8*(2+1)]+	adc	x25,xzr,xzr++	str	x19,[x0,8*2]+	adds	x19,x20,x5+	mul	x5,x11,x17+	adcs	x20,x21,x6+	mul	x6,x12,x17+	adcs	x21,x22,x7+	mul	x7,x13,x17+	adcs	x22,x23,x8+	mul	x8,x14,x17+	adcs	x23,x24,x9+	mul	x9,x15,x17+	adc	x24,x25,x10+	mul	x10,x16,x17+	adds	x19,x19,x5+	umulh	x5,x11,x17+	adcs	x20,x20,x6+	umulh	x6,x12,x17+	adcs	x21,x21,x7+	umulh	x7,x13,x17+	adcs	x22,x22,x8+	umulh	x8,x14,x17+	adcs	x23,x23,x9+	umulh	x9,x15,x17+	adcs	x24,x24,x10+	umulh	x10,x16,x17+	ldr	x17,[x2,#8*(3+1)]+	adc	x25,xzr,xzr++	str	x19,[x0,8*3]+	adds	x19,x20,x5+	mul	x5,x11,x17+	adcs	x20,x21,x6+	mul	x6,x12,x17+	adcs	x21,x22,x7+	mul	x7,x13,x17+	adcs	x22,x23,x8+	mul	x8,x14,x17+	adcs	x23,x24,x9+	mul	x9,x15,x17+	adc	x24,x25,x10+	mul	x10,x16,x17+	adds	x19,x19,x5+	umulh	x5,x11,x17+	adcs	x20,x20,x6+	umulh	x6,x12,x17+	adcs	x21,x21,x7+	umulh	x7,x13,x17+	adcs	x22,x22,x8+	umulh	x8,x14,x17+	adcs	x23,x23,x9+	umulh	x9,x15,x17+	adcs	x24,x24,x10+	umulh	x10,x16,x17+	ldr	x17,[x2,#8*(4+1)]+	adc	x25,xzr,xzr++	str	x19,[x0,8*4]+	adds	x19,x20,x5+	mul	x5,x11,x17+	adcs	x20,x21,x6+	mul	x6,x12,x17+	adcs	x21,x22,x7+	mul	x7,x13,x17+	adcs	x22,x23,x8+	mul	x8,x14,x17+	adcs	x23,x24,x9+	mul	x9,x15,x17+	adc	x24,x25,x10+	mul	x10,x16,x17+	adds	x19,x19,x5+	umulh	x5,x11,x17+	adcs	x20,x20,x6+	umulh	x6,x12,x17+	adcs	x21,x21,x7+	umulh	x7,x13,x17+	adcs	x22,x22,x8+	umulh	x8,x14,x17+	adcs	x23,x23,x9+	umulh	x9,x15,x17+	adcs	x24,x24,x10+	umulh	x10,x16,x17+	adc	x25,xzr,xzr++	str	x19,[x0,8*5]+	adds	x19,x20,x5+	adcs	x20,x21,x6+	adcs	x21,x22,x7+	adcs	x22,x23,x8+	adcs	x23,x24,x9+	adc	x24,x25,x10++	stp	x19,x20,[x0,#48]+	stp	x21,x22,[x0,#64]+	stp	x23,x24,[x0,#80]++	ret+.size	__mul_384,.-__mul_384++.globl	mul_382x+.hidden	mul_382x+.type	mul_382x,%function+.align	5+mul_382x:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	sub	sp,sp,#96		// space for two 384-bit vectors++	ldp	x11,x12,[x1]+	mov	x26,x0		// save r_ptr+	ldp	x19,x20,[x1,#48]+	mov	x27,x1		// save a_ptr+	ldp	x13,x14,[x1,#16]+	mov	x28,x2		// save b_ptr+	ldp	x21,x22,[x1,#64]+	ldp	x15,x16,[x1,#32]+	adds	x5,x11,x19	// t0 = a->re + a->im+	ldp	x23,x24,[x1,#80]+	adcs	x6,x12,x20+	ldp	x11,x12,[x2]+	adcs	x7,x13,x21+	ldp	x19,x20,[x2,#48]+	adcs	x8,x14,x22+	ldp	x13,x14,[x2,#16]+	adcs	x9,x15,x23+	ldp	x21,x22,[x2,#64]+	adc	x10,x16,x24+	ldp	x15,x16,[x2,#32]++	stp	x5,x6,[sp]+	adds	x5,x11,x19	// t1 = b->re + b->im+	ldp	x23,x24,[x2,#80]+	adcs	x6,x12,x20+	stp	x7,x8,[sp,#16]+	adcs	x7,x13,x21+	adcs	x8,x14,x22+	stp	x9,x10,[sp,#32]+	adcs	x9,x15,x23+	stp	x5,x6,[sp,#48]+	adc	x10,x16,x24+	stp	x7,x8,[sp,#64]+	stp	x9,x10,[sp,#80]++	bl	__mul_384		// mul_384(ret->re, a->re, b->re)++	add	x1,sp,#0		// mul_384(ret->im, t0, t1)+	add	x2,sp,#48+	add	x0,x26,#96+	bl	__mul_384++	add	x1,x27,#48	// mul_384(tx, a->im, b->im)+	add	x2,x28,#48+	add	x0,sp,#0+	bl	__mul_384++	ldp	x5,x6,[x3]+	ldp	x7,x8,[x3,#16]+	ldp	x9,x10,[x3,#32]++	add	x1,x26,#96	// ret->im -= tx+	add	x2,sp,#0+	add	x0,x26,#96+	bl	__sub_mod_384x384++	add	x2,x26,#0	// ret->im -= ret->re+	bl	__sub_mod_384x384++	add	x1,x26,#0	// ret->re -= tx+	add	x2,sp,#0+	add	x0,x26,#0+	bl	__sub_mod_384x384+	ldr	x30,[x29,#8]++	add	sp,sp,#96+	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+	.inst	0xd50323bf+	ret+.size	mul_382x,.-mul_382x++.globl	sqr_382x+.hidden	sqr_382x+.type	sqr_382x,%function+.align	5+sqr_382x:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]++	ldp	x11,x12,[x1]+	ldp	x19,x20,[x1,#48]+	ldp	x13,x14,[x1,#16]+	adds	x5,x11,x19	// t0 = a->re + a->im+	ldp	x21,x22,[x1,#64]+	adcs	x6,x12,x20+	ldp	x15,x16,[x1,#32]+	adcs	x7,x13,x21+	ldp	x23,x24,[x1,#80]+	adcs	x8,x14,x22+	stp	x5,x6,[x0]+	adcs	x9,x15,x23+	ldp	x5,x6,[x2]+	adc	x10,x16,x24+	stp	x7,x8,[x0,#16]++	subs	x11,x11,x19	// t1 = a->re - a->im+	ldp	x7,x8,[x2,#16]+	sbcs	x12,x12,x20+	stp	x9,x10,[x0,#32]+	sbcs	x13,x13,x21+	ldp	x9,x10,[x2,#32]+	sbcs	x14,x14,x22+	sbcs	x15,x15,x23+	sbcs	x16,x16,x24+	sbc	x25,xzr,xzr++	and	x19,x5,x25+	and	x20,x6,x25+	adds	x11,x11,x19+	and	x21,x7,x25+	adcs	x12,x12,x20+	and	x22,x8,x25+	adcs	x13,x13,x21+	and	x23,x9,x25+	adcs	x14,x14,x22+	and	x24,x10,x25+	adcs	x15,x15,x23+	stp	x11,x12,[x0,#48]+	adc	x16,x16,x24+	stp	x13,x14,[x0,#64]+	stp	x15,x16,[x0,#80]++	mov	x4,x1		// save a_ptr+	add	x1,x0,#0	// mul_384(ret->re, t0, t1)+	add	x2,x0,#48+	bl	__mul_384++	add	x1,x4,#0		// mul_384(ret->im, a->re, a->im)+	add	x2,x4,#48+	add	x0,x0,#96+	bl	__mul_384+	ldr	x30,[x29,#8]++	ldp	x11,x12,[x0]+	ldp	x13,x14,[x0,#16]+	adds	x11,x11,x11	// add with itself+	ldp	x15,x16,[x0,#32]+	adcs	x12,x12,x12+	adcs	x13,x13,x13+	adcs	x14,x14,x14+	adcs	x15,x15,x15+	adcs	x16,x16,x16+	adcs	x19,x19,x19+	adcs	x20,x20,x20+	stp	x11,x12,[x0]+	adcs	x21,x21,x21+	stp	x13,x14,[x0,#16]+	adcs	x22,x22,x22+	stp	x15,x16,[x0,#32]+	adcs	x23,x23,x23+	stp	x19,x20,[x0,#48]+	adc	x24,x24,x24+	stp	x21,x22,[x0,#64]+	stp	x23,x24,[x0,#80]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+	.inst	0xd50323bf+	ret+.size	sqr_382x,.-sqr_382x++.globl	sqr_mont_382x+.hidden	sqr_mont_382x+.type	sqr_mont_382x,%function+.align	5+sqr_mont_382x:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	stp	x3,x0,[sp,#96]	// __mul_mont_384 wants them there+	sub	sp,sp,#112		// space for two 384-bit vectors + word+	mov	x4,x3		// adjust for missing b_ptr++	ldp	x11,x12,[x1]+	ldp	x13,x14,[x1,#16]+	ldp	x15,x16,[x1,#32]++	ldp	x17,x20,[x1,#48]+	ldp	x21,x22,[x1,#64]+	ldp	x23,x24,[x1,#80]++	adds	x5,x11,x17	// t0 = a->re + a->im+	adcs	x6,x12,x20+	adcs	x7,x13,x21+	adcs	x8,x14,x22+	adcs	x9,x15,x23+	adc	x10,x16,x24++	subs	x19,x11,x17	// t1 = a->re - a->im+	sbcs	x20,x12,x20+	sbcs	x21,x13,x21+	sbcs	x22,x14,x22+	sbcs	x23,x15,x23+	sbcs	x24,x16,x24+	sbc	x25,xzr,xzr		// borrow flag as mask++	stp	x5,x6,[sp]+	stp	x7,x8,[sp,#16]+	stp	x9,x10,[sp,#32]+	stp	x19,x20,[sp,#48]+	stp	x21,x22,[sp,#64]+	stp	x23,x24,[sp,#80]+	str	x25,[sp,#96]++	ldp	x5,x6,[x2]+	ldp	x7,x8,[x2,#16]+	ldp	x9,x10,[x2,#32]++	add	x2,x1,#48+	bl	__mul_mont_383_nonred	// mul_mont_384(ret->im, a->re, a->im)++	adds	x19,x11,x11	// add with itself+	adcs	x20,x12,x12+	adcs	x21,x13,x13+	adcs	x22,x14,x14+	adcs	x23,x15,x15+	adc	x24,x16,x16++	stp	x19,x20,[x2,#48]+	stp	x21,x22,[x2,#64]+	stp	x23,x24,[x2,#80]++	ldp	x11,x12,[sp]+	ldr	x17,[sp,#48]+	ldp	x13,x14,[sp,#16]+	ldp	x15,x16,[sp,#32]++	add	x2,sp,#48+	bl	__mul_mont_383_nonred	// mul_mont_384(ret->im, t0, t1)+	ldr	x30,[x29,#8]++	ldr	x25,[sp,#96]	// account for sign from a->re - a->im+	ldp	x19,x20,[sp]+	ldp	x21,x22,[sp,#16]+	ldp	x23,x24,[sp,#32]++	and	x19,x19,x25+	and	x20,x20,x25+	and	x21,x21,x25+	and	x22,x22,x25+	and	x23,x23,x25+	and	x24,x24,x25++	subs	x11,x11,x19+	sbcs	x12,x12,x20+	sbcs	x13,x13,x21+	sbcs	x14,x14,x22+	sbcs	x15,x15,x23+	sbcs	x16,x16,x24+	sbc	x25,xzr,xzr++	and	x19,x5,x25+	and	x20,x6,x25+	and	x21,x7,x25+	and	x22,x8,x25+	and	x23,x9,x25+	and	x24,x10,x25++	adds	x11,x11,x19+	adcs	x12,x12,x20+	adcs	x13,x13,x21+	adcs	x14,x14,x22+	adcs	x15,x15,x23+	adc	x16,x16,x24++	stp	x11,x12,[x2]+	stp	x13,x14,[x2,#16]+	stp	x15,x16,[x2,#32]++	add	sp,sp,#112+	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+	.inst	0xd50323bf+	ret+.size	sqr_mont_382x,.-sqr_mont_382x++.type	__mul_mont_383_nonred,%function+.align	5+__mul_mont_383_nonred:+	mul	x19,x11,x17+	mul	x20,x12,x17+	mul	x21,x13,x17+	mul	x22,x14,x17+	mul	x23,x15,x17+	mul	x24,x16,x17+	mul	x4,x4,x19++	umulh	x26,x11,x17+	umulh	x27,x12,x17+	umulh	x28,x13,x17+	umulh	x0,x14,x17+	umulh	x1,x15,x17+	umulh	x3,x16,x17++	adds	x20,x20,x26+	mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adc	x25,xzr,    x3+	mul	x3,x10,x4+	ldr	x17,[x2,8*1]+	adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adc	x25,x25,xzr++	ldr	x4,[x29,#96]+	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,xzr,xzr++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adc	x25,x25,xzr++	adds	x20,x20,x26+	mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adc	x25,x25,x3+	mul	x3,x10,x4+	ldr	x17,[x2,8*2]+	adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adc	x25,x25,xzr++	ldr	x4,[x29,#96]+	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,xzr,xzr++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adc	x25,x25,xzr++	adds	x20,x20,x26+	mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adc	x25,x25,x3+	mul	x3,x10,x4+	ldr	x17,[x2,8*3]+	adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adc	x25,x25,xzr++	ldr	x4,[x29,#96]+	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,xzr,xzr++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adc	x25,x25,xzr++	adds	x20,x20,x26+	mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adc	x25,x25,x3+	mul	x3,x10,x4+	ldr	x17,[x2,8*4]+	adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adc	x25,x25,xzr++	ldr	x4,[x29,#96]+	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,xzr,xzr++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adc	x25,x25,xzr++	adds	x20,x20,x26+	mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adc	x25,x25,x3+	mul	x3,x10,x4+	ldr	x17,[x2,8*5]+	adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adc	x25,x25,xzr++	ldr	x4,[x29,#96]+	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,xzr,xzr++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adc	x25,x25,xzr++	adds	x20,x20,x26+	mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adc	x25,x25,x3+	mul	x3,x10,x4+	adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adc	x25,x25,xzr+	ldp	x4,x2,[x29,#96]		// pull r_ptr++	adds	x11,x20,x26+	adcs	x12,x21,x27+	adcs	x13,x22,x28+	adcs	x14,x23,x0+	adcs	x15,x24,x1+	adcs	x16,x25,x3++	ret+.size	__mul_mont_383_nonred,.-__mul_mont_383_nonred++.globl	sgn0_pty_mont_384+.hidden	sgn0_pty_mont_384+.type	sgn0_pty_mont_384,%function+.align	5+sgn0_pty_mont_384:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]++	mov	x4,x2+	ldp	x5,x6,[x1]+	ldp	x7,x8,[x1,#16]+	ldp	x9,x10,[x1,#32]+	mov	x1,x0++	bl	__mul_by_1_mont_384+	ldr	x30,[x29,#8]++	and	x0,x11,#1+	adds	x11,x11,x11+	adcs	x12,x12,x12+	adcs	x13,x13,x13+	adcs	x14,x14,x14+	adcs	x15,x15,x15+	adcs	x16,x16,x16+	adc	x17,xzr,xzr++	subs	x11,x11,x5+	sbcs	x12,x12,x6+	sbcs	x13,x13,x7+	sbcs	x14,x14,x8+	sbcs	x15,x15,x9+	sbcs	x16,x16,x10+	sbc	x17,x17,xzr++	mvn	x17,x17+	and	x17,x17,#2+	orr	x0,x0,x17++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+	.inst	0xd50323bf+	ret+.size	sgn0_pty_mont_384,.-sgn0_pty_mont_384++.globl	sgn0_pty_mont_384x+.hidden	sgn0_pty_mont_384x+.type	sgn0_pty_mont_384x,%function+.align	5+sgn0_pty_mont_384x:+	.inst	0xd503233f+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]++	mov	x4,x2+	ldp	x5,x6,[x1]+	ldp	x7,x8,[x1,#16]+	ldp	x9,x10,[x1,#32]+	mov	x1,x0++	bl	__mul_by_1_mont_384+	add	x1,x1,#48++	and	x2,x11,#1+	orr	x3,x11,x12+	adds	x11,x11,x11+	orr	x3,x3,x13+	adcs	x12,x12,x12+	orr	x3,x3,x14+	adcs	x13,x13,x13+	orr	x3,x3,x15+	adcs	x14,x14,x14+	orr	x3,x3,x16+	adcs	x15,x15,x15+	adcs	x16,x16,x16+	adc	x17,xzr,xzr++	subs	x11,x11,x5+	sbcs	x12,x12,x6+	sbcs	x13,x13,x7+	sbcs	x14,x14,x8+	sbcs	x15,x15,x9+	sbcs	x16,x16,x10+	sbc	x17,x17,xzr++	mvn	x17,x17+	and	x17,x17,#2+	orr	x2,x2,x17++	bl	__mul_by_1_mont_384+	ldr	x30,[x29,#8]++	and	x0,x11,#1+	orr	x1,x11,x12+	adds	x11,x11,x11+	orr	x1,x1,x13+	adcs	x12,x12,x12+	orr	x1,x1,x14+	adcs	x13,x13,x13+	orr	x1,x1,x15+	adcs	x14,x14,x14+	orr	x1,x1,x16+	adcs	x15,x15,x15+	adcs	x16,x16,x16+	adc	x17,xzr,xzr++	subs	x11,x11,x5+	sbcs	x12,x12,x6+	sbcs	x13,x13,x7+	sbcs	x14,x14,x8+	sbcs	x15,x15,x9+	sbcs	x16,x16,x10+	sbc	x17,x17,xzr++	mvn	x17,x17+	and	x17,x17,#2+	orr	x0,x0,x17++	cmp	x3,#0+	csel	x3,x0,x2,eq	// a->re==0? prty(a->im) : prty(a->re)++	cmp	x1,#0+	csel	x1,x0,x2,ne	// a->im!=0? sgn0(a->im) : sgn0(a->re)++	and	x3,x3,#1+	and	x1,x1,#2+	orr	x0,x1,x3		// pack sign and parity++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+	.inst	0xd50323bf+	ret+.size	sgn0_pty_mont_384x,.-sgn0_pty_mont_384x
+ c-source/build/elf/mulq_mont_256-x86_64.s view
@@ -0,0 +1,714 @@+.text	++.globl	mul_mont_sparse_256+.hidden	mul_mont_sparse_256+.type	mul_mont_sparse_256,@function+.align	32+mul_mont_sparse_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	pushq	%rdi+.cfi_adjust_cfa_offset	8+++	movq	0(%rdx),%rax+	movq	0(%rsi),%r13+	movq	8(%rsi),%r14+	movq	16(%rsi),%r12+	movq	24(%rsi),%rbp+	movq	%rdx,%rbx++	movq	%rax,%r15+	mulq	%r13+	movq	%rax,%r9+	movq	%r15,%rax+	movq	%rdx,%r10+	call	__mulq_mont_sparse_256++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	mul_mont_sparse_256,.-mul_mont_sparse_256++.globl	sqr_mont_sparse_256+.hidden	sqr_mont_sparse_256+.type	sqr_mont_sparse_256,@function+.align	32+sqr_mont_sparse_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	pushq	%rdi+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%rax+	movq	%rcx,%r8+	movq	8(%rsi),%r14+	movq	%rdx,%rcx+	movq	16(%rsi),%r12+	leaq	(%rsi),%rbx+	movq	24(%rsi),%rbp++	movq	%rax,%r15+	mulq	%rax+	movq	%rax,%r9+	movq	%r15,%rax+	movq	%rdx,%r10+	call	__mulq_mont_sparse_256++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sqr_mont_sparse_256,.-sqr_mont_sparse_256+.type	__mulq_mont_sparse_256,@function+.align	32+__mulq_mont_sparse_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	mulq	%r14+	addq	%rax,%r10+	movq	%r15,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	%r12+	addq	%rax,%r11+	movq	%r15,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	%rbp+	addq	%rax,%r12+	movq	8(%rbx),%rax+	adcq	$0,%rdx+	xorq	%r14,%r14+	movq	%rdx,%r13++	movq	%r9,%rdi+	imulq	%r8,%r9+++	movq	%rax,%r15+	mulq	0(%rsi)+	addq	%rax,%r10+	movq	%r15,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	8(%rsi)+	addq	%rax,%r11+	movq	%r15,%rax+	adcq	$0,%rdx+	addq	%rbp,%r11+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rsi)+	addq	%rax,%r12+	movq	%r15,%rax+	adcq	$0,%rdx+	addq	%rbp,%r12+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rsi)+	addq	%rax,%r13+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	%rdx,%r14+	xorq	%r15,%r15+++	mulq	0(%rcx)+	addq	%rax,%rdi+	movq	%r9,%rax+	adcq	%rdx,%rdi++	mulq	8(%rcx)+	addq	%rax,%r10+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%rdi,%r10+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r11+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%rbp,%r11+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rax,%r12+	movq	16(%rbx),%rax+	adcq	$0,%rdx+	addq	%rbp,%r12+	adcq	$0,%rdx+	addq	%rdx,%r13+	adcq	$0,%r14+	adcq	$0,%r15+	movq	%r10,%rdi+	imulq	%r8,%r10+++	movq	%rax,%r9+	mulq	0(%rsi)+	addq	%rax,%r11+	movq	%r9,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	8(%rsi)+	addq	%rax,%r12+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%rbp,%r12+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rsi)+	addq	%rax,%r13+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rsi)+	addq	%rax,%r14+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%rbp,%r14+	adcq	%rdx,%r15+	xorq	%r9,%r9+++	mulq	0(%rcx)+	addq	%rax,%rdi+	movq	%r10,%rax+	adcq	%rdx,%rdi++	mulq	8(%rcx)+	addq	%rax,%r11+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%rdi,%r11+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r12+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%rbp,%r12+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rax,%r13+	movq	24(%rbx),%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	$0,%rdx+	addq	%rdx,%r14+	adcq	$0,%r15+	adcq	$0,%r9+	movq	%r11,%rdi+	imulq	%r8,%r11+++	movq	%rax,%r10+	mulq	0(%rsi)+	addq	%rax,%r12+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	8(%rsi)+	addq	%rax,%r13+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rsi)+	addq	%rax,%r14+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%rbp,%r14+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rsi)+	addq	%rax,%r15+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%rbp,%r15+	adcq	%rdx,%r9+	xorq	%r10,%r10+++	mulq	0(%rcx)+	addq	%rax,%rdi+	movq	%r11,%rax+	adcq	%rdx,%rdi++	mulq	8(%rcx)+	addq	%rax,%r12+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%rdi,%r12+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rax,%r14+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%rbp,%r14+	adcq	$0,%rdx+	addq	%rdx,%r15+	adcq	$0,%r9+	adcq	$0,%r10+	imulq	%r8,%rax+	movq	8(%rsp),%rsi+++	movq	%rax,%r11+	mulq	0(%rcx)+	addq	%rax,%r12+	movq	%r11,%rax+	adcq	%rdx,%r12++	mulq	8(%rcx)+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r12,%r13+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r14+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%rbp,%r14+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	movq	%r14,%rbx+	addq	%rbp,%r15+	adcq	$0,%rdx+	addq	%rax,%r15+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%rdx,%r9+	adcq	$0,%r10+++++	movq	%r15,%r12+	subq	0(%rcx),%r13+	sbbq	8(%rcx),%r14+	sbbq	16(%rcx),%r15+	movq	%r9,%rbp+	sbbq	24(%rcx),%r9+	sbbq	$0,%r10++	cmovcq	%rax,%r13+	cmovcq	%rbx,%r14+	cmovcq	%r12,%r15+	movq	%r13,0(%rsi)+	cmovcq	%rbp,%r9+	movq	%r14,8(%rsi)+	movq	%r15,16(%rsi)+	movq	%r9,24(%rsi)++	.byte	0xf3,0xc3+.cfi_endproc	+.size	__mulq_mont_sparse_256,.-__mulq_mont_sparse_256+.globl	from_mont_256+.hidden	from_mont_256+.type	from_mont_256,@function+.align	32+from_mont_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rdx,%rbx+	call	__mulq_by_1_mont_256++++++	movq	%r14,%r10+	movq	%r15,%r11+	movq	%r9,%r12++	subq	0(%rbx),%r13+	sbbq	8(%rbx),%r14+	sbbq	16(%rbx),%r15+	sbbq	24(%rbx),%r9++	cmovncq	%r13,%rax+	cmovncq	%r14,%r10+	cmovncq	%r15,%r11+	movq	%rax,0(%rdi)+	cmovncq	%r9,%r12+	movq	%r10,8(%rdi)+	movq	%r11,16(%rdi)+	movq	%r12,24(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	from_mont_256,.-from_mont_256++.globl	redc_mont_256+.hidden	redc_mont_256+.type	redc_mont_256,@function+.align	32+redc_mont_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rdx,%rbx+	call	__mulq_by_1_mont_256++	addq	32(%rsi),%r13+	adcq	40(%rsi),%r14+	movq	%r13,%rax+	adcq	48(%rsi),%r15+	movq	%r14,%r10+	adcq	56(%rsi),%r9+	sbbq	%rsi,%rsi+++++	movq	%r15,%r11+	subq	0(%rbx),%r13+	sbbq	8(%rbx),%r14+	sbbq	16(%rbx),%r15+	movq	%r9,%r12+	sbbq	24(%rbx),%r9+	sbbq	$0,%rsi++	cmovncq	%r13,%rax+	cmovncq	%r14,%r10+	cmovncq	%r15,%r11+	movq	%rax,0(%rdi)+	cmovncq	%r9,%r12+	movq	%r10,8(%rdi)+	movq	%r11,16(%rdi)+	movq	%r12,24(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	redc_mont_256,.-redc_mont_256+.type	__mulq_by_1_mont_256,@function+.align	32+__mulq_by_1_mont_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%rax+	movq	8(%rsi),%r10+	movq	16(%rsi),%r11+	movq	24(%rsi),%r12++	movq	%rax,%r13+	imulq	%rcx,%rax+	movq	%rax,%r9++	mulq	0(%rbx)+	addq	%rax,%r13+	movq	%r9,%rax+	adcq	%rdx,%r13++	mulq	8(%rbx)+	addq	%rax,%r10+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r13,%r10+	adcq	$0,%rdx+	movq	%rdx,%r13++	mulq	16(%rbx)+	movq	%r10,%r14+	imulq	%rcx,%r10+	addq	%rax,%r11+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r13,%r11+	adcq	$0,%rdx+	movq	%rdx,%r13++	mulq	24(%rbx)+	addq	%rax,%r12+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r13,%r12+	adcq	$0,%rdx+	movq	%rdx,%r13++	mulq	0(%rbx)+	addq	%rax,%r14+	movq	%r10,%rax+	adcq	%rdx,%r14++	mulq	8(%rbx)+	addq	%rax,%r11+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r14,%r11+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	16(%rbx)+	movq	%r11,%r15+	imulq	%rcx,%r11+	addq	%rax,%r12+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r14,%r12+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	24(%rbx)+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r14,%r13+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	0(%rbx)+	addq	%rax,%r15+	movq	%r11,%rax+	adcq	%rdx,%r15++	mulq	8(%rbx)+	addq	%rax,%r12+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r15,%r12+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	16(%rbx)+	movq	%r12,%r9+	imulq	%rcx,%r12+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r15,%r13+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	24(%rbx)+	addq	%rax,%r14+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r15,%r14+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	0(%rbx)+	addq	%rax,%r9+	movq	%r12,%rax+	adcq	%rdx,%r9++	mulq	8(%rbx)+	addq	%rax,%r13+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r9,%r13+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	16(%rbx)+	addq	%rax,%r14+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r9,%r14+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rbx)+	addq	%rax,%r15+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r9,%r15+	adcq	$0,%rdx+	movq	%rdx,%r9+	.byte	0xf3,0xc3+.cfi_endproc+.size	__mulq_by_1_mont_256,.-__mulq_by_1_mont_256++.section	.note.GNU-stack,"",@progbits+.section	.note.gnu.property,"a",@note+	.long	4,2f-1f,5+	.byte	0x47,0x4E,0x55,0+1:	.long	0xc0000002,4,3+.align	8+2:
+ c-source/build/elf/mulq_mont_384-x86_64.s view
@@ -0,0 +1,3620 @@+.text	++++++++.type	__sub_mod_384x384,@function+.align	32+__sub_mod_384x384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	48(%rsi),%r14++	subq	0(%rdx),%r8+	movq	56(%rsi),%r15+	sbbq	8(%rdx),%r9+	movq	64(%rsi),%rax+	sbbq	16(%rdx),%r10+	movq	72(%rsi),%rbx+	sbbq	24(%rdx),%r11+	movq	80(%rsi),%rbp+	sbbq	32(%rdx),%r12+	movq	88(%rsi),%rsi+	sbbq	40(%rdx),%r13+	movq	%r8,0(%rdi)+	sbbq	48(%rdx),%r14+	movq	0(%rcx),%r8+	movq	%r9,8(%rdi)+	sbbq	56(%rdx),%r15+	movq	8(%rcx),%r9+	movq	%r10,16(%rdi)+	sbbq	64(%rdx),%rax+	movq	16(%rcx),%r10+	movq	%r11,24(%rdi)+	sbbq	72(%rdx),%rbx+	movq	24(%rcx),%r11+	movq	%r12,32(%rdi)+	sbbq	80(%rdx),%rbp+	movq	32(%rcx),%r12+	movq	%r13,40(%rdi)+	sbbq	88(%rdx),%rsi+	movq	40(%rcx),%r13+	sbbq	%rdx,%rdx++	andq	%rdx,%r8+	andq	%rdx,%r9+	andq	%rdx,%r10+	andq	%rdx,%r11+	andq	%rdx,%r12+	andq	%rdx,%r13++	addq	%r8,%r14+	adcq	%r9,%r15+	movq	%r14,48(%rdi)+	adcq	%r10,%rax+	movq	%r15,56(%rdi)+	adcq	%r11,%rbx+	movq	%rax,64(%rdi)+	adcq	%r12,%rbp+	movq	%rbx,72(%rdi)+	adcq	%r13,%rsi+	movq	%rbp,80(%rdi)+	movq	%rsi,88(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+.size	__sub_mod_384x384,.-__sub_mod_384x384++.type	__add_mod_384,@function+.align	32+__add_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	addq	0(%rdx),%r8+	adcq	8(%rdx),%r9+	adcq	16(%rdx),%r10+	movq	%r8,%r14+	adcq	24(%rdx),%r11+	movq	%r9,%r15+	adcq	32(%rdx),%r12+	movq	%r10,%rax+	adcq	40(%rdx),%r13+	movq	%r11,%rbx+	sbbq	%rdx,%rdx++	subq	0(%rcx),%r8+	sbbq	8(%rcx),%r9+	movq	%r12,%rbp+	sbbq	16(%rcx),%r10+	sbbq	24(%rcx),%r11+	sbbq	32(%rcx),%r12+	movq	%r13,%rsi+	sbbq	40(%rcx),%r13+	sbbq	$0,%rdx++	cmovcq	%r14,%r8+	cmovcq	%r15,%r9+	cmovcq	%rax,%r10+	movq	%r8,0(%rdi)+	cmovcq	%rbx,%r11+	movq	%r9,8(%rdi)+	cmovcq	%rbp,%r12+	movq	%r10,16(%rdi)+	cmovcq	%rsi,%r13+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+.size	__add_mod_384,.-__add_mod_384++.type	__sub_mod_384,@function+.align	32+__sub_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++__sub_mod_384_a_is_loaded:+	subq	0(%rdx),%r8+	movq	0(%rcx),%r14+	sbbq	8(%rdx),%r9+	movq	8(%rcx),%r15+	sbbq	16(%rdx),%r10+	movq	16(%rcx),%rax+	sbbq	24(%rdx),%r11+	movq	24(%rcx),%rbx+	sbbq	32(%rdx),%r12+	movq	32(%rcx),%rbp+	sbbq	40(%rdx),%r13+	movq	40(%rcx),%rsi+	sbbq	%rdx,%rdx++	andq	%rdx,%r14+	andq	%rdx,%r15+	andq	%rdx,%rax+	andq	%rdx,%rbx+	andq	%rdx,%rbp+	andq	%rdx,%rsi++	addq	%r14,%r8+	adcq	%r15,%r9+	movq	%r8,0(%rdi)+	adcq	%rax,%r10+	movq	%r9,8(%rdi)+	adcq	%rbx,%r11+	movq	%r10,16(%rdi)+	adcq	%rbp,%r12+	movq	%r11,24(%rdi)+	adcq	%rsi,%r13+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+.size	__sub_mod_384,.-__sub_mod_384+.globl	mul_mont_384x+.hidden	mul_mont_384x+.type	mul_mont_384x,@function+.align	32+mul_mont_384x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$328,%rsp+.cfi_adjust_cfa_offset	328+++	movq	%rdx,%rbx+	movq	%rdi,32(%rsp)+	movq	%rsi,24(%rsp)+	movq	%rdx,16(%rsp)+	movq	%rcx,8(%rsp)+	movq	%r8,0(%rsp)+++++	leaq	40(%rsp),%rdi+	call	__mulq_384+++	leaq	48(%rbx),%rbx+	leaq	48(%rsi),%rsi+	leaq	40+96(%rsp),%rdi+	call	__mulq_384+++	movq	8(%rsp),%rcx+	leaq	-48(%rsi),%rdx+	leaq	40+192+48(%rsp),%rdi+	call	__add_mod_384++	movq	16(%rsp),%rsi+	leaq	48(%rsi),%rdx+	leaq	-48(%rdi),%rdi+	call	__add_mod_384++	leaq	(%rdi),%rbx+	leaq	48(%rdi),%rsi+	call	__mulq_384+++	leaq	(%rdi),%rsi+	leaq	40(%rsp),%rdx+	movq	8(%rsp),%rcx+	call	__sub_mod_384x384++	leaq	(%rdi),%rsi+	leaq	-96(%rdi),%rdx+	call	__sub_mod_384x384+++	leaq	40(%rsp),%rsi+	leaq	40+96(%rsp),%rdx+	leaq	40(%rsp),%rdi+	call	__sub_mod_384x384++	movq	%rcx,%rbx+++	leaq	40(%rsp),%rsi+	movq	0(%rsp),%rcx+	movq	32(%rsp),%rdi+	call	__mulq_by_1_mont_384+	call	__redc_tail_mont_384+++	leaq	40+192(%rsp),%rsi+	movq	0(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__mulq_by_1_mont_384+	call	__redc_tail_mont_384++	leaq	328(%rsp),%r8+	movq	0(%r8),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-328-8*6++	.byte	0xf3,0xc3+.cfi_endproc	+.size	mul_mont_384x,.-mul_mont_384x+.globl	sqr_mont_384x+.hidden	sqr_mont_384x+.type	sqr_mont_384x,@function+.align	32+sqr_mont_384x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$136,%rsp+.cfi_adjust_cfa_offset	136+++	movq	%rcx,0(%rsp)+	movq	%rdx,%rcx+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+++	leaq	48(%rsi),%rdx+	leaq	32(%rsp),%rdi+	call	__add_mod_384+++	movq	16(%rsp),%rsi+	leaq	48(%rsi),%rdx+	leaq	32+48(%rsp),%rdi+	call	__sub_mod_384+++	movq	16(%rsp),%rsi+	leaq	48(%rsi),%rbx++	movq	48(%rsi),%rax+	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%r12+	movq	24(%rsi),%r13++	call	__mulq_mont_384+	addq	%r14,%r14+	adcq	%r15,%r15+	adcq	%r8,%r8+	movq	%r14,%r12+	adcq	%r9,%r9+	movq	%r15,%r13+	adcq	%r10,%r10+	movq	%r8,%rax+	adcq	%r11,%r11+	movq	%r9,%rbx+	sbbq	%rdx,%rdx++	subq	0(%rcx),%r14+	sbbq	8(%rcx),%r15+	movq	%r10,%rbp+	sbbq	16(%rcx),%r8+	sbbq	24(%rcx),%r9+	sbbq	32(%rcx),%r10+	movq	%r11,%rsi+	sbbq	40(%rcx),%r11+	sbbq	$0,%rdx++	cmovcq	%r12,%r14+	cmovcq	%r13,%r15+	cmovcq	%rax,%r8+	movq	%r14,48(%rdi)+	cmovcq	%rbx,%r9+	movq	%r15,56(%rdi)+	cmovcq	%rbp,%r10+	movq	%r8,64(%rdi)+	cmovcq	%rsi,%r11+	movq	%r9,72(%rdi)+	movq	%r10,80(%rdi)+	movq	%r11,88(%rdi)++	leaq	32(%rsp),%rsi+	leaq	32+48(%rsp),%rbx++	movq	32+48(%rsp),%rax+	movq	32+0(%rsp),%r14+	movq	32+8(%rsp),%r15+	movq	32+16(%rsp),%r12+	movq	32+24(%rsp),%r13++	call	__mulq_mont_384++	leaq	136(%rsp),%r8+	movq	0(%r8),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-136-8*6++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sqr_mont_384x,.-sqr_mont_384x++.globl	mul_382x+.hidden	mul_382x+.type	mul_382x,@function+.align	32+mul_382x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$136,%rsp+.cfi_adjust_cfa_offset	136+++	leaq	96(%rdi),%rdi+	movq	%rsi,0(%rsp)+	movq	%rdx,8(%rsp)+	movq	%rdi,16(%rsp)+	movq	%rcx,24(%rsp)+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	addq	48(%rsi),%r8+	adcq	56(%rsi),%r9+	adcq	64(%rsi),%r10+	adcq	72(%rsi),%r11+	adcq	80(%rsi),%r12+	adcq	88(%rsi),%r13++	movq	%r8,32+0(%rsp)+	movq	%r9,32+8(%rsp)+	movq	%r10,32+16(%rsp)+	movq	%r11,32+24(%rsp)+	movq	%r12,32+32(%rsp)+	movq	%r13,32+40(%rsp)+++	movq	0(%rdx),%r8+	movq	8(%rdx),%r9+	movq	16(%rdx),%r10+	movq	24(%rdx),%r11+	movq	32(%rdx),%r12+	movq	40(%rdx),%r13++	addq	48(%rdx),%r8+	adcq	56(%rdx),%r9+	adcq	64(%rdx),%r10+	adcq	72(%rdx),%r11+	adcq	80(%rdx),%r12+	adcq	88(%rdx),%r13++	movq	%r8,32+48(%rsp)+	movq	%r9,32+56(%rsp)+	movq	%r10,32+64(%rsp)+	movq	%r11,32+72(%rsp)+	movq	%r12,32+80(%rsp)+	movq	%r13,32+88(%rsp)+++	leaq	32+0(%rsp),%rsi+	leaq	32+48(%rsp),%rbx+	call	__mulq_384+++	movq	0(%rsp),%rsi+	movq	8(%rsp),%rbx+	leaq	-96(%rdi),%rdi+	call	__mulq_384+++	leaq	48(%rsi),%rsi+	leaq	48(%rbx),%rbx+	leaq	32(%rsp),%rdi+	call	__mulq_384+++	movq	16(%rsp),%rsi+	leaq	32(%rsp),%rdx+	movq	24(%rsp),%rcx+	movq	%rsi,%rdi+	call	__sub_mod_384x384+++	leaq	0(%rdi),%rsi+	leaq	-96(%rdi),%rdx+	call	__sub_mod_384x384+++	leaq	-96(%rdi),%rsi+	leaq	32(%rsp),%rdx+	leaq	-96(%rdi),%rdi+	call	__sub_mod_384x384++	leaq	136(%rsp),%r8+	movq	0(%r8),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-136-8*6++	.byte	0xf3,0xc3+.cfi_endproc	+.size	mul_382x,.-mul_382x+.globl	sqr_382x+.hidden	sqr_382x+.type	sqr_382x,@function+.align	32+sqr_382x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	pushq	%rsi+.cfi_adjust_cfa_offset	8+++	movq	%rdx,%rcx+++	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%rax+	movq	24(%rsi),%rbx+	movq	32(%rsi),%rbp+	movq	40(%rsi),%rdx++	movq	%r14,%r8+	addq	48(%rsi),%r14+	movq	%r15,%r9+	adcq	56(%rsi),%r15+	movq	%rax,%r10+	adcq	64(%rsi),%rax+	movq	%rbx,%r11+	adcq	72(%rsi),%rbx+	movq	%rbp,%r12+	adcq	80(%rsi),%rbp+	movq	%rdx,%r13+	adcq	88(%rsi),%rdx++	movq	%r14,0(%rdi)+	movq	%r15,8(%rdi)+	movq	%rax,16(%rdi)+	movq	%rbx,24(%rdi)+	movq	%rbp,32(%rdi)+	movq	%rdx,40(%rdi)+++	leaq	48(%rsi),%rdx+	leaq	48(%rdi),%rdi+	call	__sub_mod_384_a_is_loaded+++	leaq	(%rdi),%rsi+	leaq	-48(%rdi),%rbx+	leaq	-48(%rdi),%rdi+	call	__mulq_384+++	movq	(%rsp),%rsi+	leaq	48(%rsi),%rbx+	leaq	96(%rdi),%rdi+	call	__mulq_384++	movq	0(%rdi),%r8+	movq	8(%rdi),%r9+	movq	16(%rdi),%r10+	movq	24(%rdi),%r11+	movq	32(%rdi),%r12+	movq	40(%rdi),%r13+	movq	48(%rdi),%r14+	movq	56(%rdi),%r15+	movq	64(%rdi),%rax+	movq	72(%rdi),%rbx+	movq	80(%rdi),%rbp+	addq	%r8,%r8+	movq	88(%rdi),%rdx+	adcq	%r9,%r9+	movq	%r8,0(%rdi)+	adcq	%r10,%r10+	movq	%r9,8(%rdi)+	adcq	%r11,%r11+	movq	%r10,16(%rdi)+	adcq	%r12,%r12+	movq	%r11,24(%rdi)+	adcq	%r13,%r13+	movq	%r12,32(%rdi)+	adcq	%r14,%r14+	movq	%r13,40(%rdi)+	adcq	%r15,%r15+	movq	%r14,48(%rdi)+	adcq	%rax,%rax+	movq	%r15,56(%rdi)+	adcq	%rbx,%rbx+	movq	%rax,64(%rdi)+	adcq	%rbp,%rbp+	movq	%rbx,72(%rdi)+	adcq	%rdx,%rdx+	movq	%rbp,80(%rdi)+	movq	%rdx,88(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-8*7++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sqr_382x,.-sqr_382x+.globl	mul_384+.hidden	mul_384+.type	mul_384,@function+.align	32+mul_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+++	movq	%rdx,%rbx+	call	__mulq_384++	movq	0(%rsp),%r12+.cfi_restore	%r12+	movq	8(%rsp),%rbx+.cfi_restore	%rbx+	movq	16(%rsp),%rbp+.cfi_restore	%rbp+	leaq	24(%rsp),%rsp+.cfi_adjust_cfa_offset	-24++	.byte	0xf3,0xc3+.cfi_endproc	+.size	mul_384,.-mul_384++.type	__mulq_384,@function+.align	32+__mulq_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rbx),%rax++	movq	%rax,%rbp+	mulq	0(%rsi)+	movq	%rax,0(%rdi)+	movq	%rbp,%rax+	movq	%rdx,%rcx++	mulq	8(%rsi)+	addq	%rax,%rcx+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rsi)+	addq	%rax,%r8+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rsi)+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rsi)+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rsi)+	addq	%rax,%r11+	movq	8(%rbx),%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%rcx+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rcx,8(%rdi)+	movq	%rdx,%rcx++	mulq	8(%rsi)+	addq	%rax,%r8+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%rcx+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rsi)+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r8+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rsi)+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r9+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rsi)+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r10+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rsi)+	addq	%rax,%r12+	movq	16(%rbx),%rax+	adcq	$0,%rdx+	addq	%r12,%r11+	adcq	$0,%rdx+	movq	%rdx,%r12+	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%rcx+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rcx,16(%rdi)+	movq	%rdx,%rcx++	mulq	8(%rsi)+	addq	%rax,%r8+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%rcx+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rsi)+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r8+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rsi)+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r9+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rsi)+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r10+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rsi)+	addq	%rax,%r12+	movq	24(%rbx),%rax+	adcq	$0,%rdx+	addq	%r12,%r11+	adcq	$0,%rdx+	movq	%rdx,%r12+	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%rcx+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rcx,24(%rdi)+	movq	%rdx,%rcx++	mulq	8(%rsi)+	addq	%rax,%r8+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%rcx+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rsi)+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r8+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rsi)+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r9+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rsi)+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r10+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rsi)+	addq	%rax,%r12+	movq	32(%rbx),%rax+	adcq	$0,%rdx+	addq	%r12,%r11+	adcq	$0,%rdx+	movq	%rdx,%r12+	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%rcx+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rcx,32(%rdi)+	movq	%rdx,%rcx++	mulq	8(%rsi)+	addq	%rax,%r8+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%rcx+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rsi)+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r8+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rsi)+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r9+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rsi)+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r10+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rsi)+	addq	%rax,%r12+	movq	40(%rbx),%rax+	adcq	$0,%rdx+	addq	%r12,%r11+	adcq	$0,%rdx+	movq	%rdx,%r12+	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%rcx+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rcx,40(%rdi)+	movq	%rdx,%rcx++	mulq	8(%rsi)+	addq	%rax,%r8+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%rcx+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rsi)+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r8+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rsi)+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r9+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rsi)+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r10+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rsi)+	addq	%rax,%r12+	movq	%rax,%rax+	adcq	$0,%rdx+	addq	%r12,%r11+	adcq	$0,%rdx+	movq	%rdx,%r12+	movq	%rcx,48(%rdi)+	movq	%r8,56(%rdi)+	movq	%r9,64(%rdi)+	movq	%r10,72(%rdi)+	movq	%r11,80(%rdi)+	movq	%r12,88(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+.size	__mulq_384,.-__mulq_384+.globl	sqr_384+.hidden	sqr_384+.type	sqr_384,@function+.align	32+sqr_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	call	__sqrq_384++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sqr_384,.-sqr_384++.type	__sqrq_384,@function+.align	32+__sqrq_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%rax+	movq	8(%rsi),%r15+	movq	16(%rsi),%rcx+	movq	24(%rsi),%rbx+++	movq	%rax,%r14+	mulq	%r15+	movq	%rax,%r9+	movq	%r14,%rax+	movq	32(%rsi),%rbp+	movq	%rdx,%r10++	mulq	%rcx+	addq	%rax,%r10+	movq	%r14,%rax+	adcq	$0,%rdx+	movq	40(%rsi),%rsi+	movq	%rdx,%r11++	mulq	%rbx+	addq	%rax,%r11+	movq	%r14,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	%rbp+	addq	%rax,%r12+	movq	%r14,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13++	mulq	%rsi+	addq	%rax,%r13+	movq	%r14,%rax+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	%rax+	xorq	%r8,%r8+	movq	%rax,0(%rdi)+	movq	%r15,%rax+	addq	%r9,%r9+	adcq	$0,%r8+	addq	%rdx,%r9+	adcq	$0,%r8+	movq	%r9,8(%rdi)++	mulq	%rcx+	addq	%rax,%r11+	movq	%r15,%rax+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	%rbx+	addq	%rax,%r12+	movq	%r15,%rax+	adcq	$0,%rdx+	addq	%r9,%r12+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	%rbp+	addq	%rax,%r13+	movq	%r15,%rax+	adcq	$0,%rdx+	addq	%r9,%r13+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	%rsi+	addq	%rax,%r14+	movq	%r15,%rax+	adcq	$0,%rdx+	addq	%r9,%r14+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	%rax+	xorq	%r9,%r9+	addq	%rax,%r8+	movq	%rcx,%rax+	addq	%r10,%r10+	adcq	%r11,%r11+	adcq	$0,%r9+	addq	%r8,%r10+	adcq	%rdx,%r11+	adcq	$0,%r9+	movq	%r10,16(%rdi)++	mulq	%rbx+	addq	%rax,%r13+	movq	%rcx,%rax+	adcq	$0,%rdx+	movq	%r11,24(%rdi)+	movq	%rdx,%r8++	mulq	%rbp+	addq	%rax,%r14+	movq	%rcx,%rax+	adcq	$0,%rdx+	addq	%r8,%r14+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	%rsi+	addq	%rax,%r15+	movq	%rcx,%rax+	adcq	$0,%rdx+	addq	%r8,%r15+	adcq	$0,%rdx+	movq	%rdx,%rcx++	mulq	%rax+	xorq	%r11,%r11+	addq	%rax,%r9+	movq	%rbx,%rax+	addq	%r12,%r12+	adcq	%r13,%r13+	adcq	$0,%r11+	addq	%r9,%r12+	adcq	%rdx,%r13+	adcq	$0,%r11+	movq	%r12,32(%rdi)+++	mulq	%rbp+	addq	%rax,%r15+	movq	%rbx,%rax+	adcq	$0,%rdx+	movq	%r13,40(%rdi)+	movq	%rdx,%r8++	mulq	%rsi+	addq	%rax,%rcx+	movq	%rbx,%rax+	adcq	$0,%rdx+	addq	%r8,%rcx+	adcq	$0,%rdx+	movq	%rdx,%rbx++	mulq	%rax+	xorq	%r12,%r12+	addq	%rax,%r11+	movq	%rbp,%rax+	addq	%r14,%r14+	adcq	%r15,%r15+	adcq	$0,%r12+	addq	%r11,%r14+	adcq	%rdx,%r15+	movq	%r14,48(%rdi)+	adcq	$0,%r12+	movq	%r15,56(%rdi)+++	mulq	%rsi+	addq	%rax,%rbx+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	%rax+	xorq	%r13,%r13+	addq	%rax,%r12+	movq	%rsi,%rax+	addq	%rcx,%rcx+	adcq	%rbx,%rbx+	adcq	$0,%r13+	addq	%r12,%rcx+	adcq	%rdx,%rbx+	movq	%rcx,64(%rdi)+	adcq	$0,%r13+	movq	%rbx,72(%rdi)+++	mulq	%rax+	addq	%r13,%rax+	addq	%rbp,%rbp+	adcq	$0,%rdx+	addq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rax,80(%rdi)+	movq	%rdx,88(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+.size	__sqrq_384,.-__sqrq_384++.globl	sqr_mont_384+.hidden	sqr_mont_384+.type	sqr_mont_384,@function+.align	32+sqr_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$120,%rsp+.cfi_adjust_cfa_offset	8*15+++	movq	%rcx,96(%rsp)+	movq	%rdx,104(%rsp)+	movq	%rdi,112(%rsp)++	movq	%rsp,%rdi+	call	__sqrq_384++	leaq	0(%rsp),%rsi+	movq	96(%rsp),%rcx+	movq	104(%rsp),%rbx+	movq	112(%rsp),%rdi+	call	__mulq_by_1_mont_384+	call	__redc_tail_mont_384++	leaq	120(%rsp),%r8+	movq	120(%rsp),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-8*21++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sqr_mont_384,.-sqr_mont_384++++.globl	redc_mont_384+.hidden	redc_mont_384+.type	redc_mont_384,@function+.align	32+redc_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rdx,%rbx+	call	__mulq_by_1_mont_384+	call	__redc_tail_mont_384++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	redc_mont_384,.-redc_mont_384+++++.globl	from_mont_384+.hidden	from_mont_384+.type	from_mont_384,@function+.align	32+from_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rdx,%rbx+	call	__mulq_by_1_mont_384++++++	movq	%r15,%rcx+	movq	%r8,%rdx+	movq	%r9,%rbp++	subq	0(%rbx),%r14+	sbbq	8(%rbx),%r15+	movq	%r10,%r13+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	movq	%r11,%rsi+	sbbq	40(%rbx),%r11++	cmovcq	%rax,%r14+	cmovcq	%rcx,%r15+	cmovcq	%rdx,%r8+	movq	%r14,0(%rdi)+	cmovcq	%rbp,%r9+	movq	%r15,8(%rdi)+	cmovcq	%r13,%r10+	movq	%r8,16(%rdi)+	cmovcq	%rsi,%r11+	movq	%r9,24(%rdi)+	movq	%r10,32(%rdi)+	movq	%r11,40(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	from_mont_384,.-from_mont_384+.type	__mulq_by_1_mont_384,@function+.align	32+__mulq_by_1_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%rax+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rax,%r14+	imulq	%rcx,%rax+	movq	%rax,%r8++	mulq	0(%rbx)+	addq	%rax,%r14+	movq	%r8,%rax+	adcq	%rdx,%r14++	mulq	8(%rbx)+	addq	%rax,%r9+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%r14,%r9+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	16(%rbx)+	addq	%rax,%r10+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%r14,%r10+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	24(%rbx)+	addq	%rax,%r11+	movq	%r8,%rax+	adcq	$0,%rdx+	movq	%r9,%r15+	imulq	%rcx,%r9+	addq	%r14,%r11+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	32(%rbx)+	addq	%rax,%r12+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%r14,%r12+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	40(%rbx)+	addq	%rax,%r13+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r14,%r13+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	0(%rbx)+	addq	%rax,%r15+	movq	%r9,%rax+	adcq	%rdx,%r15++	mulq	8(%rbx)+	addq	%rax,%r10+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r15,%r10+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	16(%rbx)+	addq	%rax,%r11+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r15,%r11+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	24(%rbx)+	addq	%rax,%r12+	movq	%r9,%rax+	adcq	$0,%rdx+	movq	%r10,%r8+	imulq	%rcx,%r10+	addq	%r15,%r12+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	32(%rbx)+	addq	%rax,%r13+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r15,%r13+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	40(%rbx)+	addq	%rax,%r14+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r15,%r14+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	0(%rbx)+	addq	%rax,%r8+	movq	%r10,%rax+	adcq	%rdx,%r8++	mulq	8(%rbx)+	addq	%rax,%r11+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r8,%r11+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rbx)+	addq	%rax,%r12+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r8,%r12+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	24(%rbx)+	addq	%rax,%r13+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%r11,%r9+	imulq	%rcx,%r11+	addq	%r8,%r13+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	32(%rbx)+	addq	%rax,%r14+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r8,%r14+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	40(%rbx)+	addq	%rax,%r15+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r8,%r15+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	0(%rbx)+	addq	%rax,%r9+	movq	%r11,%rax+	adcq	%rdx,%r9++	mulq	8(%rbx)+	addq	%rax,%r12+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r9,%r12+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	16(%rbx)+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r9,%r13+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rbx)+	addq	%rax,%r14+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%r12,%r10+	imulq	%rcx,%r12+	addq	%r9,%r14+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	32(%rbx)+	addq	%rax,%r15+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r9,%r15+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	40(%rbx)+	addq	%rax,%r8+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r9,%r8+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	0(%rbx)+	addq	%rax,%r10+	movq	%r12,%rax+	adcq	%rdx,%r10++	mulq	8(%rbx)+	addq	%rax,%r13+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r10,%r13+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	16(%rbx)+	addq	%rax,%r14+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r10,%r14+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	24(%rbx)+	addq	%rax,%r15+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%r13,%r11+	imulq	%rcx,%r13+	addq	%r10,%r15+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rbx)+	addq	%rax,%r8+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r10,%r8+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	40(%rbx)+	addq	%rax,%r9+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r10,%r9+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	0(%rbx)+	addq	%rax,%r11+	movq	%r13,%rax+	adcq	%rdx,%r11++	mulq	8(%rbx)+	addq	%rax,%r14+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r11,%r14+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	16(%rbx)+	addq	%rax,%r15+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r11,%r15+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	24(%rbx)+	addq	%rax,%r8+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r11,%r8+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	32(%rbx)+	addq	%rax,%r9+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r11,%r9+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rbx)+	addq	%rax,%r10+	movq	%r14,%rax+	adcq	$0,%rdx+	addq	%r11,%r10+	adcq	$0,%rdx+	movq	%rdx,%r11+	.byte	0xf3,0xc3+.cfi_endproc+.size	__mulq_by_1_mont_384,.-__mulq_by_1_mont_384++.type	__redc_tail_mont_384,@function+.align	32+__redc_tail_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	addq	48(%rsi),%r14+	movq	%r14,%rax+	adcq	56(%rsi),%r15+	adcq	64(%rsi),%r8+	adcq	72(%rsi),%r9+	movq	%r15,%rcx+	adcq	80(%rsi),%r10+	adcq	88(%rsi),%r11+	sbbq	%r12,%r12+++++	movq	%r8,%rdx+	movq	%r9,%rbp++	subq	0(%rbx),%r14+	sbbq	8(%rbx),%r15+	movq	%r10,%r13+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	movq	%r11,%rsi+	sbbq	40(%rbx),%r11+	sbbq	$0,%r12++	cmovcq	%rax,%r14+	cmovcq	%rcx,%r15+	cmovcq	%rdx,%r8+	movq	%r14,0(%rdi)+	cmovcq	%rbp,%r9+	movq	%r15,8(%rdi)+	cmovcq	%r13,%r10+	movq	%r8,16(%rdi)+	cmovcq	%rsi,%r11+	movq	%r9,24(%rdi)+	movq	%r10,32(%rdi)+	movq	%r11,40(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+.size	__redc_tail_mont_384,.-__redc_tail_mont_384++.globl	sgn0_pty_mont_384+.hidden	sgn0_pty_mont_384+.type	sgn0_pty_mont_384,@function+.align	32+sgn0_pty_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rsi,%rbx+	leaq	0(%rdi),%rsi+	movq	%rdx,%rcx+	call	__mulq_by_1_mont_384++	xorq	%rax,%rax+	movq	%r14,%r13+	addq	%r14,%r14+	adcq	%r15,%r15+	adcq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	$0,%rax++	subq	0(%rbx),%r14+	sbbq	8(%rbx),%r15+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	sbbq	40(%rbx),%r11+	sbbq	$0,%rax++	notq	%rax+	andq	$1,%r13+	andq	$2,%rax+	orq	%r13,%rax++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sgn0_pty_mont_384,.-sgn0_pty_mont_384++.globl	sgn0_pty_mont_384x+.hidden	sgn0_pty_mont_384x+.type	sgn0_pty_mont_384x,@function+.align	32+sgn0_pty_mont_384x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rsi,%rbx+	leaq	48(%rdi),%rsi+	movq	%rdx,%rcx+	call	__mulq_by_1_mont_384++	movq	%r14,%r12+	orq	%r15,%r14+	orq	%r8,%r14+	orq	%r9,%r14+	orq	%r10,%r14+	orq	%r11,%r14++	leaq	0(%rdi),%rsi+	xorq	%rdi,%rdi+	movq	%r12,%r13+	addq	%r12,%r12+	adcq	%r15,%r15+	adcq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	$0,%rdi++	subq	0(%rbx),%r12+	sbbq	8(%rbx),%r15+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	sbbq	40(%rbx),%r11+	sbbq	$0,%rdi++	movq	%r14,0(%rsp)+	notq	%rdi+	andq	$1,%r13+	andq	$2,%rdi+	orq	%r13,%rdi++	call	__mulq_by_1_mont_384++	movq	%r14,%r12+	orq	%r15,%r14+	orq	%r8,%r14+	orq	%r9,%r14+	orq	%r10,%r14+	orq	%r11,%r14++	xorq	%rax,%rax+	movq	%r12,%r13+	addq	%r12,%r12+	adcq	%r15,%r15+	adcq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	$0,%rax++	subq	0(%rbx),%r12+	sbbq	8(%rbx),%r15+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	sbbq	40(%rbx),%r11+	sbbq	$0,%rax++	movq	0(%rsp),%r12++	notq	%rax++	testq	%r14,%r14+	cmovzq	%rdi,%r13++	testq	%r12,%r12+	cmovnzq	%rdi,%rax++	andq	$1,%r13+	andq	$2,%rax+	orq	%r13,%rax++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sgn0_pty_mont_384x,.-sgn0_pty_mont_384x+.globl	mul_mont_384+.hidden	mul_mont_384+.type	mul_mont_384,@function+.align	32+mul_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$24,%rsp+.cfi_adjust_cfa_offset	8*3+++	movq	0(%rdx),%rax+	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%r12+	movq	24(%rsi),%r13+	movq	%rdx,%rbx+	movq	%r8,0(%rsp)+	movq	%rdi,8(%rsp)++	call	__mulq_mont_384++	movq	24(%rsp),%r15+.cfi_restore	%r15+	movq	32(%rsp),%r14+.cfi_restore	%r14+	movq	40(%rsp),%r13+.cfi_restore	%r13+	movq	48(%rsp),%r12+.cfi_restore	%r12+	movq	56(%rsp),%rbx+.cfi_restore	%rbx+	movq	64(%rsp),%rbp+.cfi_restore	%rbp+	leaq	72(%rsp),%rsp+.cfi_adjust_cfa_offset	-72++	.byte	0xf3,0xc3+.cfi_endproc	+.size	mul_mont_384,.-mul_mont_384+.type	__mulq_mont_384,@function+.align	32+__mulq_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	%rax,%rdi+	mulq	%r14+	movq	%rax,%r8+	movq	%rdi,%rax+	movq	%rdx,%r9++	mulq	%r15+	addq	%rax,%r9+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	%r12+	addq	%rax,%r10+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11++	movq	%r8,%rbp+	imulq	8(%rsp),%r8++	mulq	%r13+	addq	%rax,%r11+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	32(%rsi)+	addq	%rax,%r12+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13++	mulq	40(%rsi)+	addq	%rax,%r13+	movq	%r8,%rax+	adcq	$0,%rdx+	xorq	%r15,%r15+	movq	%rdx,%r14++	mulq	0(%rcx)+	addq	%rax,%rbp+	movq	%r8,%rax+	adcq	%rdx,%rbp++	mulq	8(%rcx)+	addq	%rax,%r9+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%rbp,%r9+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r10+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%rbp,%r10+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rbp,%r11+	adcq	$0,%rdx+	addq	%rax,%r11+	movq	%r8,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	32(%rcx)+	addq	%rax,%r12+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%rbp,%r12+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	40(%rcx)+	addq	%rax,%r13+	movq	8(%rbx),%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	%rdx,%r14+	adcq	$0,%r15++	movq	%rax,%rdi+	mulq	0(%rsi)+	addq	%rax,%r9+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	8(%rsi)+	addq	%rax,%r10+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r8,%r10+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rsi)+	addq	%rax,%r11+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r8,%r11+	adcq	$0,%rdx+	movq	%rdx,%r8++	movq	%r9,%rbp+	imulq	8(%rsp),%r9++	mulq	24(%rsi)+	addq	%rax,%r12+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r8,%r12+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	32(%rsi)+	addq	%rax,%r13+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r8,%r13+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	40(%rsi)+	addq	%r8,%r14+	adcq	$0,%rdx+	xorq	%r8,%r8+	addq	%rax,%r14+	movq	%r9,%rax+	adcq	%rdx,%r15+	adcq	$0,%r8++	mulq	0(%rcx)+	addq	%rax,%rbp+	movq	%r9,%rax+	adcq	%rdx,%rbp++	mulq	8(%rcx)+	addq	%rax,%r10+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%rbp,%r10+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r11+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%rbp,%r11+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rbp,%r12+	adcq	$0,%rdx+	addq	%rax,%r12+	movq	%r9,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	32(%rcx)+	addq	%rax,%r13+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	40(%rcx)+	addq	%rax,%r14+	movq	16(%rbx),%rax+	adcq	$0,%rdx+	addq	%rbp,%r14+	adcq	%rdx,%r15+	adcq	$0,%r8++	movq	%rax,%rdi+	mulq	0(%rsi)+	addq	%rax,%r10+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	8(%rsi)+	addq	%rax,%r11+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r9,%r11+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	16(%rsi)+	addq	%rax,%r12+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r9,%r12+	adcq	$0,%rdx+	movq	%rdx,%r9++	movq	%r10,%rbp+	imulq	8(%rsp),%r10++	mulq	24(%rsi)+	addq	%rax,%r13+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r9,%r13+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	32(%rsi)+	addq	%rax,%r14+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r9,%r14+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	40(%rsi)+	addq	%r9,%r15+	adcq	$0,%rdx+	xorq	%r9,%r9+	addq	%rax,%r15+	movq	%r10,%rax+	adcq	%rdx,%r8+	adcq	$0,%r9++	mulq	0(%rcx)+	addq	%rax,%rbp+	movq	%r10,%rax+	adcq	%rdx,%rbp++	mulq	8(%rcx)+	addq	%rax,%r11+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%rbp,%r11+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r12+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%rbp,%r12+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rbp,%r13+	adcq	$0,%rdx+	addq	%rax,%r13+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	32(%rcx)+	addq	%rax,%r14+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%rbp,%r14+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	40(%rcx)+	addq	%rax,%r15+	movq	24(%rbx),%rax+	adcq	$0,%rdx+	addq	%rbp,%r15+	adcq	%rdx,%r8+	adcq	$0,%r9++	movq	%rax,%rdi+	mulq	0(%rsi)+	addq	%rax,%r11+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	8(%rsi)+	addq	%rax,%r12+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r10,%r12+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	16(%rsi)+	addq	%rax,%r13+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r10,%r13+	adcq	$0,%rdx+	movq	%rdx,%r10++	movq	%r11,%rbp+	imulq	8(%rsp),%r11++	mulq	24(%rsi)+	addq	%rax,%r14+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r10,%r14+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rsi)+	addq	%rax,%r15+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r10,%r15+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	40(%rsi)+	addq	%r10,%r8+	adcq	$0,%rdx+	xorq	%r10,%r10+	addq	%rax,%r8+	movq	%r11,%rax+	adcq	%rdx,%r9+	adcq	$0,%r10++	mulq	0(%rcx)+	addq	%rax,%rbp+	movq	%r11,%rax+	adcq	%rdx,%rbp++	mulq	8(%rcx)+	addq	%rax,%r12+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%rbp,%r12+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rbp,%r14+	adcq	$0,%rdx+	addq	%rax,%r14+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	32(%rcx)+	addq	%rax,%r15+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%rbp,%r15+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	40(%rcx)+	addq	%rax,%r8+	movq	32(%rbx),%rax+	adcq	$0,%rdx+	addq	%rbp,%r8+	adcq	%rdx,%r9+	adcq	$0,%r10++	movq	%rax,%rdi+	mulq	0(%rsi)+	addq	%rax,%r12+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	8(%rsi)+	addq	%rax,%r13+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r11,%r13+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	16(%rsi)+	addq	%rax,%r14+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r11,%r14+	adcq	$0,%rdx+	movq	%rdx,%r11++	movq	%r12,%rbp+	imulq	8(%rsp),%r12++	mulq	24(%rsi)+	addq	%rax,%r15+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r11,%r15+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	32(%rsi)+	addq	%rax,%r8+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r11,%r8+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rsi)+	addq	%r11,%r9+	adcq	$0,%rdx+	xorq	%r11,%r11+	addq	%rax,%r9+	movq	%r12,%rax+	adcq	%rdx,%r10+	adcq	$0,%r11++	mulq	0(%rcx)+	addq	%rax,%rbp+	movq	%r12,%rax+	adcq	%rdx,%rbp++	mulq	8(%rcx)+	addq	%rax,%r13+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r14+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%rbp,%r14+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rbp,%r15+	adcq	$0,%rdx+	addq	%rax,%r15+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	32(%rcx)+	addq	%rax,%r8+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%rbp,%r8+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	40(%rcx)+	addq	%rax,%r9+	movq	40(%rbx),%rax+	adcq	$0,%rdx+	addq	%rbp,%r9+	adcq	%rdx,%r10+	adcq	$0,%r11++	movq	%rax,%rdi+	mulq	0(%rsi)+	addq	%rax,%r13+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	8(%rsi)+	addq	%rax,%r14+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r12,%r14+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	16(%rsi)+	addq	%rax,%r15+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r12,%r15+	adcq	$0,%rdx+	movq	%rdx,%r12++	movq	%r13,%rbp+	imulq	8(%rsp),%r13++	mulq	24(%rsi)+	addq	%rax,%r8+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r12,%r8+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	32(%rsi)+	addq	%rax,%r9+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r12,%r9+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	40(%rsi)+	addq	%r12,%r10+	adcq	$0,%rdx+	xorq	%r12,%r12+	addq	%rax,%r10+	movq	%r13,%rax+	adcq	%rdx,%r11+	adcq	$0,%r12++	mulq	0(%rcx)+	addq	%rax,%rbp+	movq	%r13,%rax+	adcq	%rdx,%rbp++	mulq	8(%rcx)+	addq	%rax,%r14+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%rbp,%r14+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r15+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%rbp,%r15+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rbp,%r8+	adcq	$0,%rdx+	addq	%rax,%r8+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	32(%rcx)+	addq	%rax,%r9+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%rbp,%r9+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	40(%rcx)+	addq	%rax,%r10+	movq	%r14,%rax+	adcq	$0,%rdx+	addq	%rbp,%r10+	adcq	%rdx,%r11+	adcq	$0,%r12+++++	movq	16(%rsp),%rdi+	subq	0(%rcx),%r14+	movq	%r15,%rdx+	sbbq	8(%rcx),%r15+	movq	%r8,%rbx+	sbbq	16(%rcx),%r8+	movq	%r9,%rsi+	sbbq	24(%rcx),%r9+	movq	%r10,%rbp+	sbbq	32(%rcx),%r10+	movq	%r11,%r13+	sbbq	40(%rcx),%r11+	sbbq	$0,%r12++	cmovcq	%rax,%r14+	cmovcq	%rdx,%r15+	cmovcq	%rbx,%r8+	movq	%r14,0(%rdi)+	cmovcq	%rsi,%r9+	movq	%r15,8(%rdi)+	cmovcq	%rbp,%r10+	movq	%r8,16(%rdi)+	cmovcq	%r13,%r11+	movq	%r9,24(%rdi)+	movq	%r10,32(%rdi)+	movq	%r11,40(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+.size	__mulq_mont_384,.-__mulq_mont_384+.globl	sqr_n_mul_mont_384+.hidden	sqr_n_mul_mont_384+.type	sqr_n_mul_mont_384,@function+.align	32+sqr_n_mul_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$136,%rsp+.cfi_adjust_cfa_offset	8*17+++	movq	%r8,0(%rsp)+	movq	%rdi,8(%rsp)+	movq	%rcx,16(%rsp)+	leaq	32(%rsp),%rdi+	movq	%r9,24(%rsp)+	movq	(%r9),%xmm2++.Loop_sqr_384:+	movd	%edx,%xmm1++	call	__sqrq_384++	leaq	0(%rdi),%rsi+	movq	0(%rsp),%rcx+	movq	16(%rsp),%rbx+	call	__mulq_by_1_mont_384+	call	__redc_tail_mont_384++	movd	%xmm1,%edx+	leaq	0(%rdi),%rsi+	decl	%edx+	jnz	.Loop_sqr_384++.byte	102,72,15,126,208+	movq	%rbx,%rcx+	movq	24(%rsp),%rbx+++++++	movq	%r8,%r12+	movq	%r9,%r13++	call	__mulq_mont_384++	leaq	136(%rsp),%r8+	movq	136(%rsp),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-8*23++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sqr_n_mul_mont_384,.-sqr_n_mul_mont_384++.globl	sqr_n_mul_mont_383+.hidden	sqr_n_mul_mont_383+.type	sqr_n_mul_mont_383,@function+.align	32+sqr_n_mul_mont_383:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$136,%rsp+.cfi_adjust_cfa_offset	8*17+++	movq	%r8,0(%rsp)+	movq	%rdi,8(%rsp)+	movq	%rcx,16(%rsp)+	leaq	32(%rsp),%rdi+	movq	%r9,24(%rsp)+	movq	(%r9),%xmm2++.Loop_sqr_383:+	movd	%edx,%xmm1++	call	__sqrq_384++	leaq	0(%rdi),%rsi+	movq	0(%rsp),%rcx+	movq	16(%rsp),%rbx+	call	__mulq_by_1_mont_384++	movd	%xmm1,%edx+	addq	48(%rsi),%r14+	adcq	56(%rsi),%r15+	adcq	64(%rsi),%r8+	adcq	72(%rsi),%r9+	adcq	80(%rsi),%r10+	adcq	88(%rsi),%r11+	leaq	0(%rdi),%rsi++	movq	%r14,0(%rdi)+	movq	%r15,8(%rdi)+	movq	%r8,16(%rdi)+	movq	%r9,24(%rdi)+	movq	%r10,32(%rdi)+	movq	%r11,40(%rdi)++	decl	%edx+	jnz	.Loop_sqr_383++.byte	102,72,15,126,208+	movq	%rbx,%rcx+	movq	24(%rsp),%rbx+++++++	movq	%r8,%r12+	movq	%r9,%r13++	call	__mulq_mont_384++	leaq	136(%rsp),%r8+	movq	136(%rsp),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-8*23++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sqr_n_mul_mont_383,.-sqr_n_mul_mont_383+.type	__mulq_mont_383_nonred,@function+.align	32+__mulq_mont_383_nonred:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	%rax,%rbp+	mulq	%r14+	movq	%rax,%r8+	movq	%rbp,%rax+	movq	%rdx,%r9++	mulq	%r15+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	%r12+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11++	movq	%r8,%r15+	imulq	8(%rsp),%r8++	mulq	%r13+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	32(%rsi)+	addq	%rax,%r12+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13++	mulq	40(%rsi)+	addq	%rax,%r13+	movq	%r8,%rax+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	0(%rcx)+	addq	%rax,%r15+	movq	%r8,%rax+	adcq	%rdx,%r15++	mulq	8(%rcx)+	addq	%rax,%r9+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%r15,%r9+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	16(%rcx)+	addq	%rax,%r10+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%r15,%r10+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	24(%rcx)+	addq	%r15,%r11+	adcq	$0,%rdx+	addq	%rax,%r11+	movq	%r8,%rax+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	32(%rcx)+	addq	%rax,%r12+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%r15,%r12+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	40(%rcx)+	addq	%rax,%r13+	movq	8(%rbx),%rax+	adcq	$0,%rdx+	addq	%r15,%r13+	adcq	%rdx,%r14++	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	8(%rsi)+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r15,%r10+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	16(%rsi)+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r15,%r11+	adcq	$0,%rdx+	movq	%rdx,%r15++	movq	%r9,%r8+	imulq	8(%rsp),%r9++	mulq	24(%rsi)+	addq	%rax,%r12+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r15,%r12+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	32(%rsi)+	addq	%rax,%r13+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r15,%r13+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	40(%rsi)+	addq	%r15,%r14+	adcq	$0,%rdx+	addq	%rax,%r14+	movq	%r9,%rax+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	0(%rcx)+	addq	%rax,%r8+	movq	%r9,%rax+	adcq	%rdx,%r8++	mulq	8(%rcx)+	addq	%rax,%r10+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r8,%r10+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rcx)+	addq	%rax,%r11+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r8,%r11+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	24(%rcx)+	addq	%r8,%r12+	adcq	$0,%rdx+	addq	%rax,%r12+	movq	%r9,%rax+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	32(%rcx)+	addq	%rax,%r13+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r8,%r13+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	40(%rcx)+	addq	%rax,%r14+	movq	16(%rbx),%rax+	adcq	$0,%rdx+	addq	%r8,%r14+	adcq	%rdx,%r15++	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	8(%rsi)+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%r11+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rsi)+	addq	%rax,%r12+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%r12+	adcq	$0,%rdx+	movq	%rdx,%r8++	movq	%r10,%r9+	imulq	8(%rsp),%r10++	mulq	24(%rsi)+	addq	%rax,%r13+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%r13+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	32(%rsi)+	addq	%rax,%r14+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%r14+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	40(%rsi)+	addq	%r8,%r15+	adcq	$0,%rdx+	addq	%rax,%r15+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	0(%rcx)+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	%rdx,%r9++	mulq	8(%rcx)+	addq	%rax,%r11+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r9,%r11+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	16(%rcx)+	addq	%rax,%r12+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r9,%r12+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rcx)+	addq	%r9,%r13+	adcq	$0,%rdx+	addq	%rax,%r13+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	32(%rcx)+	addq	%rax,%r14+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r9,%r14+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	40(%rcx)+	addq	%rax,%r15+	movq	24(%rbx),%rax+	adcq	$0,%rdx+	addq	%r9,%r15+	adcq	%rdx,%r8++	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	8(%rsi)+	addq	%rax,%r12+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r12+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	16(%rsi)+	addq	%rax,%r13+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r13+	adcq	$0,%rdx+	movq	%rdx,%r9++	movq	%r11,%r10+	imulq	8(%rsp),%r11++	mulq	24(%rsi)+	addq	%rax,%r14+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r14+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	32(%rsi)+	addq	%rax,%r15+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r15+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	40(%rsi)+	addq	%r9,%r8+	adcq	$0,%rdx+	addq	%rax,%r8+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	0(%rcx)+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	%rdx,%r10++	mulq	8(%rcx)+	addq	%rax,%r12+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r10,%r12+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	16(%rcx)+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r10,%r13+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	24(%rcx)+	addq	%r10,%r14+	adcq	$0,%rdx+	addq	%rax,%r14+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rcx)+	addq	%rax,%r15+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r10,%r15+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	40(%rcx)+	addq	%rax,%r8+	movq	32(%rbx),%rax+	adcq	$0,%rdx+	addq	%r10,%r8+	adcq	%rdx,%r9++	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%r12+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	8(%rsi)+	addq	%rax,%r13+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r13+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	16(%rsi)+	addq	%rax,%r14+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r14+	adcq	$0,%rdx+	movq	%rdx,%r10++	movq	%r12,%r11+	imulq	8(%rsp),%r12++	mulq	24(%rsi)+	addq	%rax,%r15+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r15+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rsi)+	addq	%rax,%r8+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r8+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	40(%rsi)+	addq	%r10,%r9+	adcq	$0,%rdx+	addq	%rax,%r9+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	0(%rcx)+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	%rdx,%r11++	mulq	8(%rcx)+	addq	%rax,%r13+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r11,%r13+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	16(%rcx)+	addq	%rax,%r14+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r11,%r14+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	24(%rcx)+	addq	%r11,%r15+	adcq	$0,%rdx+	addq	%rax,%r15+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	32(%rcx)+	addq	%rax,%r8+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r11,%r8+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rcx)+	addq	%rax,%r9+	movq	40(%rbx),%rax+	adcq	$0,%rdx+	addq	%r11,%r9+	adcq	%rdx,%r10++	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%r13+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	8(%rsi)+	addq	%rax,%r14+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r14+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	16(%rsi)+	addq	%rax,%r15+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r15+	adcq	$0,%rdx+	movq	%rdx,%r11++	movq	%r13,%r12+	imulq	8(%rsp),%r13++	mulq	24(%rsi)+	addq	%rax,%r8+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r8+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	32(%rsi)+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r9+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rsi)+	addq	%r11,%r10+	adcq	$0,%rdx+	addq	%rax,%r10+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	0(%rcx)+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	%rdx,%r12++	mulq	8(%rcx)+	addq	%rax,%r14+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r12,%r14+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	16(%rcx)+	addq	%rax,%r15+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r12,%r15+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	24(%rcx)+	addq	%r12,%r8+	adcq	$0,%rdx+	addq	%rax,%r8+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	32(%rcx)+	addq	%rax,%r9+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r12,%r9+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	40(%rcx)+	addq	%rax,%r10+	movq	%r14,%rax+	adcq	$0,%rdx+	addq	%r12,%r10+	adcq	%rdx,%r11+	.byte	0xf3,0xc3+.cfi_endproc+.size	__mulq_mont_383_nonred,.-__mulq_mont_383_nonred+.globl	sqr_mont_382x+.hidden	sqr_mont_382x+.type	sqr_mont_382x,@function+.align	32+sqr_mont_382x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$136,%rsp+.cfi_adjust_cfa_offset	136+++	movq	%rcx,0(%rsp)+	movq	%rdx,%rcx+	movq	%rsi,16(%rsp)+	movq	%rdi,24(%rsp)+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%r8,%r14+	addq	48(%rsi),%r8+	movq	%r9,%r15+	adcq	56(%rsi),%r9+	movq	%r10,%rax+	adcq	64(%rsi),%r10+	movq	%r11,%rdx+	adcq	72(%rsi),%r11+	movq	%r12,%rbx+	adcq	80(%rsi),%r12+	movq	%r13,%rbp+	adcq	88(%rsi),%r13++	subq	48(%rsi),%r14+	sbbq	56(%rsi),%r15+	sbbq	64(%rsi),%rax+	sbbq	72(%rsi),%rdx+	sbbq	80(%rsi),%rbx+	sbbq	88(%rsi),%rbp+	sbbq	%rdi,%rdi++	movq	%r8,32+0(%rsp)+	movq	%r9,32+8(%rsp)+	movq	%r10,32+16(%rsp)+	movq	%r11,32+24(%rsp)+	movq	%r12,32+32(%rsp)+	movq	%r13,32+40(%rsp)++	movq	%r14,32+48(%rsp)+	movq	%r15,32+56(%rsp)+	movq	%rax,32+64(%rsp)+	movq	%rdx,32+72(%rsp)+	movq	%rbx,32+80(%rsp)+	movq	%rbp,32+88(%rsp)+	movq	%rdi,32+96(%rsp)++++	leaq	48(%rsi),%rbx++	movq	48(%rsi),%rax+	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%r12+	movq	24(%rsi),%r13++	movq	24(%rsp),%rdi+	call	__mulq_mont_383_nonred+	addq	%r14,%r14+	adcq	%r15,%r15+	adcq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11++	movq	%r14,48(%rdi)+	movq	%r15,56(%rdi)+	movq	%r8,64(%rdi)+	movq	%r9,72(%rdi)+	movq	%r10,80(%rdi)+	movq	%r11,88(%rdi)++	leaq	32(%rsp),%rsi+	leaq	32+48(%rsp),%rbx++	movq	32+48(%rsp),%rax+	movq	32+0(%rsp),%r14+	movq	32+8(%rsp),%r15+	movq	32+16(%rsp),%r12+	movq	32+24(%rsp),%r13++	call	__mulq_mont_383_nonred+	movq	32+96(%rsp),%rsi+	movq	32+0(%rsp),%r12+	movq	32+8(%rsp),%r13+	andq	%rsi,%r12+	movq	32+16(%rsp),%rax+	andq	%rsi,%r13+	movq	32+24(%rsp),%rbx+	andq	%rsi,%rax+	movq	32+32(%rsp),%rbp+	andq	%rsi,%rbx+	andq	%rsi,%rbp+	andq	32+40(%rsp),%rsi++	subq	%r12,%r14+	movq	0(%rcx),%r12+	sbbq	%r13,%r15+	movq	8(%rcx),%r13+	sbbq	%rax,%r8+	movq	16(%rcx),%rax+	sbbq	%rbx,%r9+	movq	24(%rcx),%rbx+	sbbq	%rbp,%r10+	movq	32(%rcx),%rbp+	sbbq	%rsi,%r11+	sbbq	%rsi,%rsi++	andq	%rsi,%r12+	andq	%rsi,%r13+	andq	%rsi,%rax+	andq	%rsi,%rbx+	andq	%rsi,%rbp+	andq	40(%rcx),%rsi++	addq	%r12,%r14+	adcq	%r13,%r15+	adcq	%rax,%r8+	adcq	%rbx,%r9+	adcq	%rbp,%r10+	adcq	%rsi,%r11++	movq	%r14,0(%rdi)+	movq	%r15,8(%rdi)+	movq	%r8,16(%rdi)+	movq	%r9,24(%rdi)+	movq	%r10,32(%rdi)+	movq	%r11,40(%rdi)+	leaq	136(%rsp),%r8+	movq	0(%r8),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-136-8*6++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sqr_mont_382x,.-sqr_mont_382x++.section	.note.GNU-stack,"",@progbits+.section	.note.gnu.property,"a",@note+	.long	4,2f-1f,5+	.byte	0x47,0x4E,0x55,0+1:	.long	0xc0000002,4,3+.align	8+2:
+ c-source/build/elf/mulx_mont_256-x86_64.s view
@@ -0,0 +1,627 @@+.text	++.globl	mulx_mont_sparse_256+.hidden	mulx_mont_sparse_256+.type	mulx_mont_sparse_256,@function+.align	32+mulx_mont_sparse_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rdx,%rbx+	movq	0(%rdx),%rdx+	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%rbp+	movq	24(%rsi),%r9+	leaq	-128(%rsi),%rsi+	leaq	-128(%rcx),%rcx++	mulxq	%r14,%rax,%r11+	call	__mulx_mont_sparse_256++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	mulx_mont_sparse_256,.-mulx_mont_sparse_256++.globl	sqrx_mont_sparse_256+.hidden	sqrx_mont_sparse_256+.type	sqrx_mont_sparse_256,@function+.align	32+sqrx_mont_sparse_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rsi,%rbx+	movq	%rcx,%r8+	movq	%rdx,%rcx+	movq	0(%rsi),%rdx+	movq	8(%rsi),%r15+	movq	16(%rsi),%rbp+	movq	24(%rsi),%r9+	leaq	-128(%rbx),%rsi+	leaq	-128(%rcx),%rcx++	mulxq	%rdx,%rax,%r11+	call	__mulx_mont_sparse_256++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sqrx_mont_sparse_256,.-sqrx_mont_sparse_256+.type	__mulx_mont_sparse_256,@function+.align	32+__mulx_mont_sparse_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	mulxq	%r15,%r15,%r12+	mulxq	%rbp,%rbp,%r13+	addq	%r15,%r11+	mulxq	%r9,%r9,%r14+	movq	8(%rbx),%rdx+	adcq	%rbp,%r12+	adcq	%r9,%r13+	adcq	$0,%r14++	movq	%rax,%r10+	imulq	%r8,%rax+++	xorq	%r15,%r15+	mulxq	0+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r11+	adcxq	%r9,%r12++	mulxq	8+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r12+	adcxq	%r9,%r13++	mulxq	16+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r13+	adcxq	%r9,%r14++	mulxq	24+128(%rsi),%rbp,%r9+	movq	%rax,%rdx+	adoxq	%rbp,%r14+	adcxq	%r15,%r9+	adoxq	%r9,%r15+++	mulxq	0+128(%rcx),%rbp,%rax+	adcxq	%rbp,%r10+	adoxq	%r11,%rax++	mulxq	8+128(%rcx),%rbp,%r9+	adcxq	%rbp,%rax+	adoxq	%r9,%r12++	mulxq	16+128(%rcx),%rbp,%r9+	adcxq	%rbp,%r12+	adoxq	%r9,%r13++	mulxq	24+128(%rcx),%rbp,%r9+	movq	16(%rbx),%rdx+	adcxq	%rbp,%r13+	adoxq	%r9,%r14+	adcxq	%r10,%r14+	adoxq	%r10,%r15+	adcxq	%r10,%r15+	adoxq	%r10,%r10+	adcq	$0,%r10+	movq	%rax,%r11+	imulq	%r8,%rax+++	xorq	%rbp,%rbp+	mulxq	0+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r12+	adcxq	%r9,%r13++	mulxq	8+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r13+	adcxq	%r9,%r14++	mulxq	16+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r14+	adcxq	%r9,%r15++	mulxq	24+128(%rsi),%rbp,%r9+	movq	%rax,%rdx+	adoxq	%rbp,%r15+	adcxq	%r10,%r9+	adoxq	%r9,%r10+++	mulxq	0+128(%rcx),%rbp,%rax+	adcxq	%rbp,%r11+	adoxq	%r12,%rax++	mulxq	8+128(%rcx),%rbp,%r9+	adcxq	%rbp,%rax+	adoxq	%r9,%r13++	mulxq	16+128(%rcx),%rbp,%r9+	adcxq	%rbp,%r13+	adoxq	%r9,%r14++	mulxq	24+128(%rcx),%rbp,%r9+	movq	24(%rbx),%rdx+	adcxq	%rbp,%r14+	adoxq	%r9,%r15+	adcxq	%r11,%r15+	adoxq	%r11,%r10+	adcxq	%r11,%r10+	adoxq	%r11,%r11+	adcq	$0,%r11+	movq	%rax,%r12+	imulq	%r8,%rax+++	xorq	%rbp,%rbp+	mulxq	0+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r13+	adcxq	%r9,%r14++	mulxq	8+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r14+	adcxq	%r9,%r15++	mulxq	16+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r15+	adcxq	%r9,%r10++	mulxq	24+128(%rsi),%rbp,%r9+	movq	%rax,%rdx+	adoxq	%rbp,%r10+	adcxq	%r11,%r9+	adoxq	%r9,%r11+++	mulxq	0+128(%rcx),%rbp,%rax+	adcxq	%rbp,%r12+	adoxq	%r13,%rax++	mulxq	8+128(%rcx),%rbp,%r9+	adcxq	%rbp,%rax+	adoxq	%r9,%r14++	mulxq	16+128(%rcx),%rbp,%r9+	adcxq	%rbp,%r14+	adoxq	%r9,%r15++	mulxq	24+128(%rcx),%rbp,%r9+	movq	%rax,%rdx+	adcxq	%rbp,%r15+	adoxq	%r9,%r10+	adcxq	%r12,%r10+	adoxq	%r12,%r11+	adcxq	%r12,%r11+	adoxq	%r12,%r12+	adcq	$0,%r12+	imulq	%r8,%rdx+++	xorq	%rbp,%rbp+	mulxq	0+128(%rcx),%r13,%r9+	adcxq	%rax,%r13+	adoxq	%r9,%r14++	mulxq	8+128(%rcx),%rbp,%r9+	adcxq	%rbp,%r14+	adoxq	%r9,%r15++	mulxq	16+128(%rcx),%rbp,%r9+	adcxq	%rbp,%r15+	adoxq	%r9,%r10++	mulxq	24+128(%rcx),%rbp,%r9+	movq	%r14,%rdx+	leaq	128(%rcx),%rcx+	adcxq	%rbp,%r10+	adoxq	%r9,%r11+	movq	%r15,%rax+	adcxq	%r13,%r11+	adoxq	%r13,%r12+	adcq	$0,%r12+++++	movq	%r10,%rbp+	subq	0(%rcx),%r14+	sbbq	8(%rcx),%r15+	sbbq	16(%rcx),%r10+	movq	%r11,%r9+	sbbq	24(%rcx),%r11+	sbbq	$0,%r12++	cmovcq	%rdx,%r14+	cmovcq	%rax,%r15+	cmovcq	%rbp,%r10+	movq	%r14,0(%rdi)+	cmovcq	%r9,%r11+	movq	%r15,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+.size	__mulx_mont_sparse_256,.-__mulx_mont_sparse_256+.globl	fromx_mont_256+.hidden	fromx_mont_256+.type	fromx_mont_256,@function+.align	32+fromx_mont_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rdx,%rbx+	call	__mulx_by_1_mont_256++++++	movq	%r15,%rdx+	movq	%r10,%r12+	movq	%r11,%r13++	subq	0(%rbx),%r14+	sbbq	8(%rbx),%r15+	sbbq	16(%rbx),%r10+	sbbq	24(%rbx),%r11++	cmovncq	%r14,%rax+	cmovncq	%r15,%rdx+	cmovncq	%r10,%r12+	movq	%rax,0(%rdi)+	cmovncq	%r11,%r13+	movq	%rdx,8(%rdi)+	movq	%r12,16(%rdi)+	movq	%r13,24(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	fromx_mont_256,.-fromx_mont_256++.globl	redcx_mont_256+.hidden	redcx_mont_256+.type	redcx_mont_256,@function+.align	32+redcx_mont_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rdx,%rbx+	call	__mulx_by_1_mont_256++	addq	32(%rsi),%r14+	adcq	40(%rsi),%r15+	movq	%r14,%rax+	adcq	48(%rsi),%r10+	movq	%r15,%rdx+	adcq	56(%rsi),%r11+	sbbq	%rsi,%rsi+++++	movq	%r10,%r12+	subq	0(%rbx),%r14+	sbbq	8(%rbx),%r15+	sbbq	16(%rbx),%r10+	movq	%r11,%r13+	sbbq	24(%rbx),%r11+	sbbq	$0,%rsi++	cmovncq	%r14,%rax+	cmovncq	%r15,%rdx+	cmovncq	%r10,%r12+	movq	%rax,0(%rdi)+	cmovncq	%r11,%r13+	movq	%rdx,8(%rdi)+	movq	%r12,16(%rdi)+	movq	%r13,24(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	redcx_mont_256,.-redcx_mont_256+.type	__mulx_by_1_mont_256,@function+.align	32+__mulx_by_1_mont_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%rax+	movq	8(%rsi),%r11+	movq	16(%rsi),%r12+	movq	24(%rsi),%r13++	movq	%rax,%r14+	imulq	%rcx,%rax+	movq	%rax,%r10++	mulq	0(%rbx)+	addq	%rax,%r14+	movq	%r10,%rax+	adcq	%rdx,%r14++	mulq	8(%rbx)+	addq	%rax,%r11+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r14,%r11+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	16(%rbx)+	movq	%r11,%r15+	imulq	%rcx,%r11+	addq	%rax,%r12+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r14,%r12+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	24(%rbx)+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r14,%r13+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	0(%rbx)+	addq	%rax,%r15+	movq	%r11,%rax+	adcq	%rdx,%r15++	mulq	8(%rbx)+	addq	%rax,%r12+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r15,%r12+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	16(%rbx)+	movq	%r12,%r10+	imulq	%rcx,%r12+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r15,%r13+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	24(%rbx)+	addq	%rax,%r14+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r15,%r14+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	0(%rbx)+	addq	%rax,%r10+	movq	%r12,%rax+	adcq	%rdx,%r10++	mulq	8(%rbx)+	addq	%rax,%r13+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r10,%r13+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	16(%rbx)+	movq	%r13,%r11+	imulq	%rcx,%r13+	addq	%rax,%r14+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r10,%r14+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	24(%rbx)+	addq	%rax,%r15+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r10,%r15+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	0(%rbx)+	addq	%rax,%r11+	movq	%r13,%rax+	adcq	%rdx,%r11++	mulq	8(%rbx)+	addq	%rax,%r14+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r11,%r14+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	16(%rbx)+	addq	%rax,%r15+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r11,%r15+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	24(%rbx)+	addq	%rax,%r10+	movq	%r14,%rax+	adcq	$0,%rdx+	addq	%r11,%r10+	adcq	$0,%rdx+	movq	%rdx,%r11+	.byte	0xf3,0xc3+.cfi_endproc+.size	__mulx_by_1_mont_256,.-__mulx_by_1_mont_256++.section	.note.GNU-stack,"",@progbits+.section	.note.gnu.property,"a",@note+	.long	4,2f-1f,5+	.byte	0x47,0x4E,0x55,0+1:	.long	0xc0000002,4,3+.align	8+2:
+ c-source/build/elf/mulx_mont_384-x86_64.s view
@@ -0,0 +1,2968 @@+.text	++++++++.type	__sub_mod_384x384,@function+.align	32+__sub_mod_384x384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	48(%rsi),%r14++	subq	0(%rdx),%r8+	movq	56(%rsi),%r15+	sbbq	8(%rdx),%r9+	movq	64(%rsi),%rax+	sbbq	16(%rdx),%r10+	movq	72(%rsi),%rbx+	sbbq	24(%rdx),%r11+	movq	80(%rsi),%rbp+	sbbq	32(%rdx),%r12+	movq	88(%rsi),%rsi+	sbbq	40(%rdx),%r13+	movq	%r8,0(%rdi)+	sbbq	48(%rdx),%r14+	movq	0(%rcx),%r8+	movq	%r9,8(%rdi)+	sbbq	56(%rdx),%r15+	movq	8(%rcx),%r9+	movq	%r10,16(%rdi)+	sbbq	64(%rdx),%rax+	movq	16(%rcx),%r10+	movq	%r11,24(%rdi)+	sbbq	72(%rdx),%rbx+	movq	24(%rcx),%r11+	movq	%r12,32(%rdi)+	sbbq	80(%rdx),%rbp+	movq	32(%rcx),%r12+	movq	%r13,40(%rdi)+	sbbq	88(%rdx),%rsi+	movq	40(%rcx),%r13+	sbbq	%rdx,%rdx++	andq	%rdx,%r8+	andq	%rdx,%r9+	andq	%rdx,%r10+	andq	%rdx,%r11+	andq	%rdx,%r12+	andq	%rdx,%r13++	addq	%r8,%r14+	adcq	%r9,%r15+	movq	%r14,48(%rdi)+	adcq	%r10,%rax+	movq	%r15,56(%rdi)+	adcq	%r11,%rbx+	movq	%rax,64(%rdi)+	adcq	%r12,%rbp+	movq	%rbx,72(%rdi)+	adcq	%r13,%rsi+	movq	%rbp,80(%rdi)+	movq	%rsi,88(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+.size	__sub_mod_384x384,.-__sub_mod_384x384++.type	__add_mod_384,@function+.align	32+__add_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	addq	0(%rdx),%r8+	adcq	8(%rdx),%r9+	adcq	16(%rdx),%r10+	movq	%r8,%r14+	adcq	24(%rdx),%r11+	movq	%r9,%r15+	adcq	32(%rdx),%r12+	movq	%r10,%rax+	adcq	40(%rdx),%r13+	movq	%r11,%rbx+	sbbq	%rdx,%rdx++	subq	0(%rcx),%r8+	sbbq	8(%rcx),%r9+	movq	%r12,%rbp+	sbbq	16(%rcx),%r10+	sbbq	24(%rcx),%r11+	sbbq	32(%rcx),%r12+	movq	%r13,%rsi+	sbbq	40(%rcx),%r13+	sbbq	$0,%rdx++	cmovcq	%r14,%r8+	cmovcq	%r15,%r9+	cmovcq	%rax,%r10+	movq	%r8,0(%rdi)+	cmovcq	%rbx,%r11+	movq	%r9,8(%rdi)+	cmovcq	%rbp,%r12+	movq	%r10,16(%rdi)+	cmovcq	%rsi,%r13+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+.size	__add_mod_384,.-__add_mod_384++.type	__sub_mod_384,@function+.align	32+__sub_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++__sub_mod_384_a_is_loaded:+	subq	0(%rdx),%r8+	movq	0(%rcx),%r14+	sbbq	8(%rdx),%r9+	movq	8(%rcx),%r15+	sbbq	16(%rdx),%r10+	movq	16(%rcx),%rax+	sbbq	24(%rdx),%r11+	movq	24(%rcx),%rbx+	sbbq	32(%rdx),%r12+	movq	32(%rcx),%rbp+	sbbq	40(%rdx),%r13+	movq	40(%rcx),%rsi+	sbbq	%rdx,%rdx++	andq	%rdx,%r14+	andq	%rdx,%r15+	andq	%rdx,%rax+	andq	%rdx,%rbx+	andq	%rdx,%rbp+	andq	%rdx,%rsi++	addq	%r14,%r8+	adcq	%r15,%r9+	movq	%r8,0(%rdi)+	adcq	%rax,%r10+	movq	%r9,8(%rdi)+	adcq	%rbx,%r11+	movq	%r10,16(%rdi)+	adcq	%rbp,%r12+	movq	%r11,24(%rdi)+	adcq	%rsi,%r13+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+.size	__sub_mod_384,.-__sub_mod_384+.globl	mulx_mont_384x+.hidden	mulx_mont_384x+.type	mulx_mont_384x,@function+.align	32+mulx_mont_384x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$328,%rsp+.cfi_adjust_cfa_offset	328+++	movq	%rdx,%rbx+	movq	%rdi,32(%rsp)+	movq	%rsi,24(%rsp)+	movq	%rdx,16(%rsp)+	movq	%rcx,8(%rsp)+	movq	%r8,0(%rsp)+++++	leaq	40(%rsp),%rdi+	call	__mulx_384+++	leaq	48(%rbx),%rbx+	leaq	128+48(%rsi),%rsi+	leaq	96(%rdi),%rdi+	call	__mulx_384+++	movq	8(%rsp),%rcx+	leaq	(%rbx),%rsi+	leaq	-48(%rbx),%rdx+	leaq	40+192+48(%rsp),%rdi+	call	__add_mod_384++	movq	24(%rsp),%rsi+	leaq	48(%rsi),%rdx+	leaq	-48(%rdi),%rdi+	call	__add_mod_384++	leaq	(%rdi),%rbx+	leaq	48(%rdi),%rsi+	call	__mulx_384+++	leaq	(%rdi),%rsi+	leaq	40(%rsp),%rdx+	movq	8(%rsp),%rcx+	call	__sub_mod_384x384++	leaq	(%rdi),%rsi+	leaq	-96(%rdi),%rdx+	call	__sub_mod_384x384+++	leaq	40(%rsp),%rsi+	leaq	40+96(%rsp),%rdx+	leaq	40(%rsp),%rdi+	call	__sub_mod_384x384++	leaq	(%rcx),%rbx+++	leaq	40(%rsp),%rsi+	movq	0(%rsp),%rcx+	movq	32(%rsp),%rdi+	call	__mulx_by_1_mont_384+	call	__redc_tail_mont_384+++	leaq	40+192(%rsp),%rsi+	movq	0(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__mulx_by_1_mont_384+	call	__redc_tail_mont_384++	leaq	328(%rsp),%r8+	movq	0(%r8),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-328-8*6++	.byte	0xf3,0xc3+.cfi_endproc	+.size	mulx_mont_384x,.-mulx_mont_384x+.globl	sqrx_mont_384x+.hidden	sqrx_mont_384x+.type	sqrx_mont_384x,@function+.align	32+sqrx_mont_384x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$136,%rsp+.cfi_adjust_cfa_offset	136+++	movq	%rcx,0(%rsp)+	movq	%rdx,%rcx++	movq	%rdi,16(%rsp)+	movq	%rsi,24(%rsp)+++	leaq	48(%rsi),%rdx+	leaq	32(%rsp),%rdi+	call	__add_mod_384+++	movq	24(%rsp),%rsi+	leaq	48(%rsi),%rdx+	leaq	32+48(%rsp),%rdi+	call	__sub_mod_384+++	movq	24(%rsp),%rsi+	leaq	48(%rsi),%rbx++	movq	48(%rsi),%rdx+	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%rax+	movq	24(%rsi),%r12+	movq	32(%rsi),%rdi+	movq	40(%rsi),%rbp+	leaq	-128(%rsi),%rsi+	leaq	-128(%rcx),%rcx++	mulxq	%r14,%r8,%r9+	call	__mulx_mont_384+	addq	%rdx,%rdx+	adcq	%r15,%r15+	adcq	%rax,%rax+	movq	%rdx,%r8+	adcq	%r12,%r12+	movq	%r15,%r9+	adcq	%rdi,%rdi+	movq	%rax,%r10+	adcq	%rbp,%rbp+	movq	%r12,%r11+	sbbq	%rsi,%rsi++	subq	0(%rcx),%rdx+	sbbq	8(%rcx),%r15+	movq	%rdi,%r13+	sbbq	16(%rcx),%rax+	sbbq	24(%rcx),%r12+	sbbq	32(%rcx),%rdi+	movq	%rbp,%r14+	sbbq	40(%rcx),%rbp+	sbbq	$0,%rsi++	cmovcq	%r8,%rdx+	cmovcq	%r9,%r15+	cmovcq	%r10,%rax+	movq	%rdx,48(%rbx)+	cmovcq	%r11,%r12+	movq	%r15,56(%rbx)+	cmovcq	%r13,%rdi+	movq	%rax,64(%rbx)+	cmovcq	%r14,%rbp+	movq	%r12,72(%rbx)+	movq	%rdi,80(%rbx)+	movq	%rbp,88(%rbx)++	leaq	32(%rsp),%rsi+	leaq	32+48(%rsp),%rbx++	movq	32+48(%rsp),%rdx+	movq	32+0(%rsp),%r14+	movq	32+8(%rsp),%r15+	movq	32+16(%rsp),%rax+	movq	32+24(%rsp),%r12+	movq	32+32(%rsp),%rdi+	movq	32+40(%rsp),%rbp+	leaq	-128(%rsi),%rsi+	leaq	-128(%rcx),%rcx++	mulxq	%r14,%r8,%r9+	call	__mulx_mont_384++	leaq	136(%rsp),%r8+	movq	0(%r8),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-136-8*6++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sqrx_mont_384x,.-sqrx_mont_384x++.globl	mulx_382x+.hidden	mulx_382x+.type	mulx_382x,@function+.align	32+mulx_382x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$136,%rsp+.cfi_adjust_cfa_offset	136+++	leaq	96(%rdi),%rdi+	movq	%rsi,0(%rsp)+	movq	%rdx,8(%rsp)+	movq	%rdi,16(%rsp)+	movq	%rcx,24(%rsp)+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	addq	48(%rsi),%r8+	adcq	56(%rsi),%r9+	adcq	64(%rsi),%r10+	adcq	72(%rsi),%r11+	adcq	80(%rsi),%r12+	adcq	88(%rsi),%r13++	movq	%r8,32+0(%rsp)+	movq	%r9,32+8(%rsp)+	movq	%r10,32+16(%rsp)+	movq	%r11,32+24(%rsp)+	movq	%r12,32+32(%rsp)+	movq	%r13,32+40(%rsp)+++	movq	0(%rdx),%r8+	movq	8(%rdx),%r9+	movq	16(%rdx),%r10+	movq	24(%rdx),%r11+	movq	32(%rdx),%r12+	movq	40(%rdx),%r13++	addq	48(%rdx),%r8+	adcq	56(%rdx),%r9+	adcq	64(%rdx),%r10+	adcq	72(%rdx),%r11+	adcq	80(%rdx),%r12+	adcq	88(%rdx),%r13++	movq	%r8,32+48(%rsp)+	movq	%r9,32+56(%rsp)+	movq	%r10,32+64(%rsp)+	movq	%r11,32+72(%rsp)+	movq	%r12,32+80(%rsp)+	movq	%r13,32+88(%rsp)+++	leaq	32+0(%rsp),%rsi+	leaq	32+48(%rsp),%rbx+	call	__mulx_384+++	movq	0(%rsp),%rsi+	movq	8(%rsp),%rbx+	leaq	-96(%rdi),%rdi+	call	__mulx_384+++	leaq	48+128(%rsi),%rsi+	leaq	48(%rbx),%rbx+	leaq	32(%rsp),%rdi+	call	__mulx_384+++	movq	16(%rsp),%rsi+	leaq	32(%rsp),%rdx+	movq	24(%rsp),%rcx+	movq	%rsi,%rdi+	call	__sub_mod_384x384+++	leaq	0(%rdi),%rsi+	leaq	-96(%rdi),%rdx+	call	__sub_mod_384x384+++	leaq	-96(%rdi),%rsi+	leaq	32(%rsp),%rdx+	leaq	-96(%rdi),%rdi+	call	__sub_mod_384x384++	leaq	136(%rsp),%r8+	movq	0(%r8),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-136-8*6++	.byte	0xf3,0xc3+.cfi_endproc	+.size	mulx_382x,.-mulx_382x+.globl	sqrx_382x+.hidden	sqrx_382x+.type	sqrx_382x,@function+.align	32+sqrx_382x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	pushq	%rsi+.cfi_adjust_cfa_offset	8+++	movq	%rdx,%rcx+++	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%rax+	movq	24(%rsi),%rbx+	movq	32(%rsi),%rbp+	movq	40(%rsi),%rdx++	movq	%r14,%r8+	addq	48(%rsi),%r14+	movq	%r15,%r9+	adcq	56(%rsi),%r15+	movq	%rax,%r10+	adcq	64(%rsi),%rax+	movq	%rbx,%r11+	adcq	72(%rsi),%rbx+	movq	%rbp,%r12+	adcq	80(%rsi),%rbp+	movq	%rdx,%r13+	adcq	88(%rsi),%rdx++	movq	%r14,0(%rdi)+	movq	%r15,8(%rdi)+	movq	%rax,16(%rdi)+	movq	%rbx,24(%rdi)+	movq	%rbp,32(%rdi)+	movq	%rdx,40(%rdi)+++	leaq	48(%rsi),%rdx+	leaq	48(%rdi),%rdi+	call	__sub_mod_384_a_is_loaded+++	leaq	(%rdi),%rsi+	leaq	-48(%rdi),%rbx+	leaq	-48(%rdi),%rdi+	call	__mulx_384+++	movq	(%rsp),%rsi+	leaq	48(%rsi),%rbx+	leaq	96(%rdi),%rdi+	call	__mulx_384++	movq	0(%rdi),%r8+	movq	8(%rdi),%r9+	movq	16(%rdi),%r10+	movq	24(%rdi),%r11+	movq	32(%rdi),%r12+	movq	40(%rdi),%r13+	movq	48(%rdi),%r14+	movq	56(%rdi),%r15+	movq	64(%rdi),%rax+	movq	72(%rdi),%rbx+	movq	80(%rdi),%rbp+	addq	%r8,%r8+	movq	88(%rdi),%rdx+	adcq	%r9,%r9+	movq	%r8,0(%rdi)+	adcq	%r10,%r10+	movq	%r9,8(%rdi)+	adcq	%r11,%r11+	movq	%r10,16(%rdi)+	adcq	%r12,%r12+	movq	%r11,24(%rdi)+	adcq	%r13,%r13+	movq	%r12,32(%rdi)+	adcq	%r14,%r14+	movq	%r13,40(%rdi)+	adcq	%r15,%r15+	movq	%r14,48(%rdi)+	adcq	%rax,%rax+	movq	%r15,56(%rdi)+	adcq	%rbx,%rbx+	movq	%rax,64(%rdi)+	adcq	%rbp,%rbp+	movq	%rbx,72(%rdi)+	adcq	%rdx,%rdx+	movq	%rbp,80(%rdi)+	movq	%rdx,88(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-8*7++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sqrx_382x,.-sqrx_382x+.globl	mulx_384+.hidden	mulx_384+.type	mulx_384,@function+.align	32+mulx_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+++	movq	%rdx,%rbx+	call	__mulx_384++	movq	0(%rsp),%r15+.cfi_restore	%r15+	movq	8(%rsp),%r14+.cfi_restore	%r14+	movq	16(%rsp),%r13+.cfi_restore	%r13+	movq	24(%rsp),%r12+.cfi_restore	%r12+	movq	32(%rsp),%rbx+.cfi_restore	%rbx+	movq	40(%rsp),%rbp+.cfi_restore	%rbp+	leaq	48(%rsp),%rsp+.cfi_adjust_cfa_offset	-48++	.byte	0xf3,0xc3+.cfi_endproc	+.size	mulx_384,.-mulx_384++.type	__mulx_384,@function+.align	32+__mulx_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rbx),%rdx+	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	leaq	-128(%rsi),%rsi++	mulxq	%r14,%r9,%rcx+	xorq	%rbp,%rbp++	mulxq	%r15,%r8,%rax+	adcxq	%rcx,%r8+	movq	%r9,0(%rdi)++	mulxq	%r10,%r9,%rcx+	adcxq	%rax,%r9++	mulxq	%r11,%r10,%rax+	adcxq	%rcx,%r10++	mulxq	%r12,%r11,%rcx+	adcxq	%rax,%r11++	mulxq	%r13,%r12,%r13+	movq	8(%rbx),%rdx+	adcxq	%rcx,%r12+	adcxq	%rbp,%r13+	mulxq	%r14,%rax,%rcx+	adcxq	%r8,%rax+	adoxq	%rcx,%r9+	movq	%rax,8(%rdi)++	mulxq	%r15,%r8,%rcx+	adcxq	%r9,%r8+	adoxq	%rcx,%r10++	mulxq	128+16(%rsi),%r9,%rax+	adcxq	%r10,%r9+	adoxq	%rax,%r11++	mulxq	128+24(%rsi),%r10,%rcx+	adcxq	%r11,%r10+	adoxq	%rcx,%r12++	mulxq	128+32(%rsi),%r11,%rax+	adcxq	%r12,%r11+	adoxq	%r13,%rax++	mulxq	128+40(%rsi),%r12,%r13+	movq	16(%rbx),%rdx+	adcxq	%rax,%r12+	adoxq	%rbp,%r13+	adcxq	%rbp,%r13+	mulxq	%r14,%rax,%rcx+	adcxq	%r8,%rax+	adoxq	%rcx,%r9+	movq	%rax,16(%rdi)++	mulxq	%r15,%r8,%rcx+	adcxq	%r9,%r8+	adoxq	%rcx,%r10++	mulxq	128+16(%rsi),%r9,%rax+	adcxq	%r10,%r9+	adoxq	%rax,%r11++	mulxq	128+24(%rsi),%r10,%rcx+	adcxq	%r11,%r10+	adoxq	%rcx,%r12++	mulxq	128+32(%rsi),%r11,%rax+	adcxq	%r12,%r11+	adoxq	%r13,%rax++	mulxq	128+40(%rsi),%r12,%r13+	movq	24(%rbx),%rdx+	adcxq	%rax,%r12+	adoxq	%rbp,%r13+	adcxq	%rbp,%r13+	mulxq	%r14,%rax,%rcx+	adcxq	%r8,%rax+	adoxq	%rcx,%r9+	movq	%rax,24(%rdi)++	mulxq	%r15,%r8,%rcx+	adcxq	%r9,%r8+	adoxq	%rcx,%r10++	mulxq	128+16(%rsi),%r9,%rax+	adcxq	%r10,%r9+	adoxq	%rax,%r11++	mulxq	128+24(%rsi),%r10,%rcx+	adcxq	%r11,%r10+	adoxq	%rcx,%r12++	mulxq	128+32(%rsi),%r11,%rax+	adcxq	%r12,%r11+	adoxq	%r13,%rax++	mulxq	128+40(%rsi),%r12,%r13+	movq	32(%rbx),%rdx+	adcxq	%rax,%r12+	adoxq	%rbp,%r13+	adcxq	%rbp,%r13+	mulxq	%r14,%rax,%rcx+	adcxq	%r8,%rax+	adoxq	%rcx,%r9+	movq	%rax,32(%rdi)++	mulxq	%r15,%r8,%rcx+	adcxq	%r9,%r8+	adoxq	%rcx,%r10++	mulxq	128+16(%rsi),%r9,%rax+	adcxq	%r10,%r9+	adoxq	%rax,%r11++	mulxq	128+24(%rsi),%r10,%rcx+	adcxq	%r11,%r10+	adoxq	%rcx,%r12++	mulxq	128+32(%rsi),%r11,%rax+	adcxq	%r12,%r11+	adoxq	%r13,%rax++	mulxq	128+40(%rsi),%r12,%r13+	movq	40(%rbx),%rdx+	adcxq	%rax,%r12+	adoxq	%rbp,%r13+	adcxq	%rbp,%r13+	mulxq	%r14,%rax,%rcx+	adcxq	%r8,%rax+	adoxq	%rcx,%r9+	movq	%rax,40(%rdi)++	mulxq	%r15,%r8,%rcx+	adcxq	%r9,%r8+	adoxq	%rcx,%r10++	mulxq	128+16(%rsi),%r9,%rax+	adcxq	%r10,%r9+	adoxq	%rax,%r11++	mulxq	128+24(%rsi),%r10,%rcx+	adcxq	%r11,%r10+	adoxq	%rcx,%r12++	mulxq	128+32(%rsi),%r11,%rax+	adcxq	%r12,%r11+	adoxq	%r13,%rax++	mulxq	128+40(%rsi),%r12,%r13+	movq	%rax,%rdx+	adcxq	%rax,%r12+	adoxq	%rbp,%r13+	adcxq	%rbp,%r13+	movq	%r8,48(%rdi)+	movq	%r9,56(%rdi)+	movq	%r10,64(%rdi)+	movq	%r11,72(%rdi)+	movq	%r12,80(%rdi)+	movq	%r13,88(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+.size	__mulx_384,.-__mulx_384+.globl	sqrx_384+.hidden	sqrx_384+.type	sqrx_384,@function+.align	32+sqrx_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	pushq	%rdi+.cfi_adjust_cfa_offset	8+++	call	__sqrx_384++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sqrx_384,.-sqrx_384+.type	__sqrx_384,@function+.align	32+__sqrx_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%rdx+	movq	8(%rsi),%r14+	movq	16(%rsi),%r15+	movq	24(%rsi),%rcx+	movq	32(%rsi),%rbx+++	mulxq	%r14,%r8,%rdi+	movq	40(%rsi),%rbp+	mulxq	%r15,%r9,%rax+	addq	%rdi,%r9+	mulxq	%rcx,%r10,%rdi+	adcq	%rax,%r10+	mulxq	%rbx,%r11,%rax+	adcq	%rdi,%r11+	mulxq	%rbp,%r12,%r13+	movq	%r14,%rdx+	adcq	%rax,%r12+	adcq	$0,%r13+++	xorq	%r14,%r14+	mulxq	%r15,%rdi,%rax+	adcxq	%rdi,%r10+	adoxq	%rax,%r11++	mulxq	%rcx,%rdi,%rax+	adcxq	%rdi,%r11+	adoxq	%rax,%r12++	mulxq	%rbx,%rdi,%rax+	adcxq	%rdi,%r12+	adoxq	%rax,%r13++	mulxq	%rbp,%rdi,%rax+	movq	%r15,%rdx+	adcxq	%rdi,%r13+	adoxq	%r14,%rax+	adcxq	%rax,%r14+++	xorq	%r15,%r15+	mulxq	%rcx,%rdi,%rax+	adcxq	%rdi,%r12+	adoxq	%rax,%r13++	mulxq	%rbx,%rdi,%rax+	adcxq	%rdi,%r13+	adoxq	%rax,%r14++	mulxq	%rbp,%rdi,%rax+	movq	%rcx,%rdx+	adcxq	%rdi,%r14+	adoxq	%r15,%rax+	adcxq	%rax,%r15+++	xorq	%rcx,%rcx+	mulxq	%rbx,%rdi,%rax+	adcxq	%rdi,%r14+	adoxq	%rax,%r15++	mulxq	%rbp,%rdi,%rax+	movq	%rbx,%rdx+	adcxq	%rdi,%r15+	adoxq	%rcx,%rax+	adcxq	%rax,%rcx+++	mulxq	%rbp,%rdi,%rbx+	movq	0(%rsi),%rdx+	addq	%rdi,%rcx+	movq	8(%rsp),%rdi+	adcq	$0,%rbx+++	xorq	%rbp,%rbp+	adcxq	%r8,%r8+	adcxq	%r9,%r9+	adcxq	%r10,%r10+	adcxq	%r11,%r11+	adcxq	%r12,%r12+++	mulxq	%rdx,%rdx,%rax+	movq	%rdx,0(%rdi)+	movq	8(%rsi),%rdx+	adoxq	%rax,%r8+	movq	%r8,8(%rdi)++	mulxq	%rdx,%r8,%rax+	movq	16(%rsi),%rdx+	adoxq	%r8,%r9+	adoxq	%rax,%r10+	movq	%r9,16(%rdi)+	movq	%r10,24(%rdi)++	mulxq	%rdx,%r8,%r9+	movq	24(%rsi),%rdx+	adoxq	%r8,%r11+	adoxq	%r9,%r12+	adcxq	%r13,%r13+	adcxq	%r14,%r14+	movq	%r11,32(%rdi)+	movq	%r12,40(%rdi)++	mulxq	%rdx,%r8,%r9+	movq	32(%rsi),%rdx+	adoxq	%r8,%r13+	adoxq	%r9,%r14+	adcxq	%r15,%r15+	adcxq	%rcx,%rcx+	movq	%r13,48(%rdi)+	movq	%r14,56(%rdi)++	mulxq	%rdx,%r8,%r9+	movq	40(%rsi),%rdx+	adoxq	%r8,%r15+	adoxq	%r9,%rcx+	adcxq	%rbx,%rbx+	adcxq	%rbp,%rbp+	movq	%r15,64(%rdi)+	movq	%rcx,72(%rdi)++	mulxq	%rdx,%r8,%r9+	adoxq	%r8,%rbx+	adoxq	%r9,%rbp++	movq	%rbx,80(%rdi)+	movq	%rbp,88(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+.size	__sqrx_384,.-__sqrx_384++++.globl	redcx_mont_384+.hidden	redcx_mont_384+.type	redcx_mont_384,@function+.align	32+redcx_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rdx,%rbx+	call	__mulx_by_1_mont_384+	call	__redc_tail_mont_384++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	redcx_mont_384,.-redcx_mont_384+++++.globl	fromx_mont_384+.hidden	fromx_mont_384+.type	fromx_mont_384,@function+.align	32+fromx_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rdx,%rbx+	call	__mulx_by_1_mont_384+++++	movq	%r14,%rax+	movq	%r15,%rcx+	movq	%r8,%rdx+	movq	%r9,%rbp++	subq	0(%rbx),%r14+	sbbq	8(%rbx),%r15+	movq	%r10,%r13+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	movq	%r11,%rsi+	sbbq	40(%rbx),%r11++	cmovcq	%rax,%r14+	cmovcq	%rcx,%r15+	cmovcq	%rdx,%r8+	movq	%r14,0(%rdi)+	cmovcq	%rbp,%r9+	movq	%r15,8(%rdi)+	cmovcq	%r13,%r10+	movq	%r8,16(%rdi)+	cmovcq	%rsi,%r11+	movq	%r9,24(%rdi)+	movq	%r10,32(%rdi)+	movq	%r11,40(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	fromx_mont_384,.-fromx_mont_384+.type	__mulx_by_1_mont_384,@function+.align	32+__mulx_by_1_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	%rcx,%rdx+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	imulq	%r8,%rdx+++	xorq	%r14,%r14+	mulxq	0(%rbx),%rax,%rbp+	adcxq	%rax,%r8+	adoxq	%rbp,%r9++	mulxq	8(%rbx),%rax,%rbp+	adcxq	%rax,%r9+	adoxq	%rbp,%r10++	mulxq	16(%rbx),%rax,%rbp+	adcxq	%rax,%r10+	adoxq	%rbp,%r11++	mulxq	24(%rbx),%rax,%rbp+	adcxq	%rax,%r11+	adoxq	%rbp,%r12++	mulxq	32(%rbx),%rax,%rbp+	adcxq	%rax,%r12+	adoxq	%rbp,%r13++	mulxq	40(%rbx),%rax,%rbp+	movq	%rcx,%rdx+	adcxq	%rax,%r13+	adoxq	%r14,%rbp+	adcxq	%rbp,%r14+	imulq	%r9,%rdx+++	xorq	%r15,%r15+	mulxq	0(%rbx),%rax,%rbp+	adcxq	%rax,%r9+	adoxq	%rbp,%r10++	mulxq	8(%rbx),%rax,%rbp+	adcxq	%rax,%r10+	adoxq	%rbp,%r11++	mulxq	16(%rbx),%rax,%rbp+	adcxq	%rax,%r11+	adoxq	%rbp,%r12++	mulxq	24(%rbx),%rax,%rbp+	adcxq	%rax,%r12+	adoxq	%rbp,%r13++	mulxq	32(%rbx),%rax,%rbp+	adcxq	%rax,%r13+	adoxq	%rbp,%r14++	mulxq	40(%rbx),%rax,%rbp+	movq	%rcx,%rdx+	adcxq	%rax,%r14+	adoxq	%r15,%rbp+	adcxq	%rbp,%r15+	imulq	%r10,%rdx+++	xorq	%r8,%r8+	mulxq	0(%rbx),%rax,%rbp+	adcxq	%rax,%r10+	adoxq	%rbp,%r11++	mulxq	8(%rbx),%rax,%rbp+	adcxq	%rax,%r11+	adoxq	%rbp,%r12++	mulxq	16(%rbx),%rax,%rbp+	adcxq	%rax,%r12+	adoxq	%rbp,%r13++	mulxq	24(%rbx),%rax,%rbp+	adcxq	%rax,%r13+	adoxq	%rbp,%r14++	mulxq	32(%rbx),%rax,%rbp+	adcxq	%rax,%r14+	adoxq	%rbp,%r15++	mulxq	40(%rbx),%rax,%rbp+	movq	%rcx,%rdx+	adcxq	%rax,%r15+	adoxq	%r8,%rbp+	adcxq	%rbp,%r8+	imulq	%r11,%rdx+++	xorq	%r9,%r9+	mulxq	0(%rbx),%rax,%rbp+	adcxq	%rax,%r11+	adoxq	%rbp,%r12++	mulxq	8(%rbx),%rax,%rbp+	adcxq	%rax,%r12+	adoxq	%rbp,%r13++	mulxq	16(%rbx),%rax,%rbp+	adcxq	%rax,%r13+	adoxq	%rbp,%r14++	mulxq	24(%rbx),%rax,%rbp+	adcxq	%rax,%r14+	adoxq	%rbp,%r15++	mulxq	32(%rbx),%rax,%rbp+	adcxq	%rax,%r15+	adoxq	%rbp,%r8++	mulxq	40(%rbx),%rax,%rbp+	movq	%rcx,%rdx+	adcxq	%rax,%r8+	adoxq	%r9,%rbp+	adcxq	%rbp,%r9+	imulq	%r12,%rdx+++	xorq	%r10,%r10+	mulxq	0(%rbx),%rax,%rbp+	adcxq	%rax,%r12+	adoxq	%rbp,%r13++	mulxq	8(%rbx),%rax,%rbp+	adcxq	%rax,%r13+	adoxq	%rbp,%r14++	mulxq	16(%rbx),%rax,%rbp+	adcxq	%rax,%r14+	adoxq	%rbp,%r15++	mulxq	24(%rbx),%rax,%rbp+	adcxq	%rax,%r15+	adoxq	%rbp,%r8++	mulxq	32(%rbx),%rax,%rbp+	adcxq	%rax,%r8+	adoxq	%rbp,%r9++	mulxq	40(%rbx),%rax,%rbp+	movq	%rcx,%rdx+	adcxq	%rax,%r9+	adoxq	%r10,%rbp+	adcxq	%rbp,%r10+	imulq	%r13,%rdx+++	xorq	%r11,%r11+	mulxq	0(%rbx),%rax,%rbp+	adcxq	%rax,%r13+	adoxq	%rbp,%r14++	mulxq	8(%rbx),%rax,%rbp+	adcxq	%rax,%r14+	adoxq	%rbp,%r15++	mulxq	16(%rbx),%rax,%rbp+	adcxq	%rax,%r15+	adoxq	%rbp,%r8++	mulxq	24(%rbx),%rax,%rbp+	adcxq	%rax,%r8+	adoxq	%rbp,%r9++	mulxq	32(%rbx),%rax,%rbp+	adcxq	%rax,%r9+	adoxq	%rbp,%r10++	mulxq	40(%rbx),%rax,%rbp+	movq	%rcx,%rdx+	adcxq	%rax,%r10+	adoxq	%r11,%rbp+	adcxq	%rbp,%r11+	.byte	0xf3,0xc3+.cfi_endproc+.size	__mulx_by_1_mont_384,.-__mulx_by_1_mont_384++.type	__redc_tail_mont_384,@function+.align	32+__redc_tail_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	addq	48(%rsi),%r14+	movq	%r14,%rax+	adcq	56(%rsi),%r15+	adcq	64(%rsi),%r8+	adcq	72(%rsi),%r9+	movq	%r15,%rcx+	adcq	80(%rsi),%r10+	adcq	88(%rsi),%r11+	sbbq	%r12,%r12+++++	movq	%r8,%rdx+	movq	%r9,%rbp++	subq	0(%rbx),%r14+	sbbq	8(%rbx),%r15+	movq	%r10,%r13+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	movq	%r11,%rsi+	sbbq	40(%rbx),%r11+	sbbq	$0,%r12++	cmovcq	%rax,%r14+	cmovcq	%rcx,%r15+	cmovcq	%rdx,%r8+	movq	%r14,0(%rdi)+	cmovcq	%rbp,%r9+	movq	%r15,8(%rdi)+	cmovcq	%r13,%r10+	movq	%r8,16(%rdi)+	cmovcq	%rsi,%r11+	movq	%r9,24(%rdi)+	movq	%r10,32(%rdi)+	movq	%r11,40(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+.size	__redc_tail_mont_384,.-__redc_tail_mont_384++.globl	sgn0x_pty_mont_384+.hidden	sgn0x_pty_mont_384+.type	sgn0x_pty_mont_384,@function+.align	32+sgn0x_pty_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rsi,%rbx+	leaq	0(%rdi),%rsi+	movq	%rdx,%rcx+	call	__mulx_by_1_mont_384++	xorq	%rax,%rax+	movq	%r14,%r13+	addq	%r14,%r14+	adcq	%r15,%r15+	adcq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	$0,%rax++	subq	0(%rbx),%r14+	sbbq	8(%rbx),%r15+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	sbbq	40(%rbx),%r11+	sbbq	$0,%rax++	notq	%rax+	andq	$1,%r13+	andq	$2,%rax+	orq	%r13,%rax++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sgn0x_pty_mont_384,.-sgn0x_pty_mont_384++.globl	sgn0x_pty_mont_384x+.hidden	sgn0x_pty_mont_384x+.type	sgn0x_pty_mont_384x,@function+.align	32+sgn0x_pty_mont_384x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rsi,%rbx+	leaq	48(%rdi),%rsi+	movq	%rdx,%rcx+	call	__mulx_by_1_mont_384++	movq	%r14,%r12+	orq	%r15,%r14+	orq	%r8,%r14+	orq	%r9,%r14+	orq	%r10,%r14+	orq	%r11,%r14++	leaq	0(%rdi),%rsi+	xorq	%rdi,%rdi+	movq	%r12,%r13+	addq	%r12,%r12+	adcq	%r15,%r15+	adcq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	$0,%rdi++	subq	0(%rbx),%r12+	sbbq	8(%rbx),%r15+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	sbbq	40(%rbx),%r11+	sbbq	$0,%rdi++	movq	%r14,0(%rsp)+	notq	%rdi+	andq	$1,%r13+	andq	$2,%rdi+	orq	%r13,%rdi++	call	__mulx_by_1_mont_384++	movq	%r14,%r12+	orq	%r15,%r14+	orq	%r8,%r14+	orq	%r9,%r14+	orq	%r10,%r14+	orq	%r11,%r14++	xorq	%rax,%rax+	movq	%r12,%r13+	addq	%r12,%r12+	adcq	%r15,%r15+	adcq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	$0,%rax++	subq	0(%rbx),%r12+	sbbq	8(%rbx),%r15+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	sbbq	40(%rbx),%r11+	sbbq	$0,%rax++	movq	0(%rsp),%r12++	notq	%rax++	testq	%r14,%r14+	cmovzq	%rdi,%r13++	testq	%r12,%r12+	cmovnzq	%rdi,%rax++	andq	$1,%r13+	andq	$2,%rax+	orq	%r13,%rax++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sgn0x_pty_mont_384x,.-sgn0x_pty_mont_384x+.globl	mulx_mont_384+.hidden	mulx_mont_384+.type	mulx_mont_384,@function+.align	32+mulx_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	leaq	-24(%rsp),%rsp+.cfi_adjust_cfa_offset	8*3+++	movq	%rdx,%rbx+	movq	0(%rdx),%rdx+	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%rax+	movq	24(%rsi),%r12+	movq	%rdi,16(%rsp)+	movq	32(%rsi),%rdi+	movq	40(%rsi),%rbp+	leaq	-128(%rsi),%rsi+	leaq	-128(%rcx),%rcx+	movq	%r8,(%rsp)++	mulxq	%r14,%r8,%r9+	call	__mulx_mont_384++	movq	24(%rsp),%r15+.cfi_restore	%r15+	movq	32(%rsp),%r14+.cfi_restore	%r14+	movq	40(%rsp),%r13+.cfi_restore	%r13+	movq	48(%rsp),%r12+.cfi_restore	%r12+	movq	56(%rsp),%rbx+.cfi_restore	%rbx+	movq	64(%rsp),%rbp+.cfi_restore	%rbp+	leaq	72(%rsp),%rsp+.cfi_adjust_cfa_offset	-8*9++	.byte	0xf3,0xc3+.cfi_endproc	+.size	mulx_mont_384,.-mulx_mont_384+.type	__mulx_mont_384,@function+.align	32+__mulx_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	mulxq	%r15,%r14,%r10+	mulxq	%rax,%r15,%r11+	addq	%r14,%r9+	mulxq	%r12,%rax,%r12+	adcq	%r15,%r10+	mulxq	%rdi,%rdi,%r13+	adcq	%rax,%r11+	mulxq	%rbp,%rbp,%r14+	movq	8(%rbx),%rdx+	adcq	%rdi,%r12+	adcq	%rbp,%r13+	adcq	$0,%r14+	xorq	%r15,%r15++	movq	%r8,16(%rsp)+	imulq	8(%rsp),%r8+++	xorq	%rax,%rax+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r9+	adcxq	%rbp,%r10++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r10+	adcxq	%rbp,%r11++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r11+	adcxq	%rbp,%r12++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r12+	adcxq	%rbp,%r13++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r8,%rdx+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15+	adoxq	%rax,%r15+	adoxq	%rax,%rax+++	xorq	%r8,%r8+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	16(%rsp),%rdi+	adoxq	%rbp,%r9++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r9+	adoxq	%rbp,%r10++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r10+	adoxq	%rbp,%r11++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r11+	adoxq	%rbp,%r12++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r12+	adoxq	%rbp,%r13++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	16(%rbx),%rdx+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14+	adcxq	%r8,%r14+	adoxq	%r8,%r15+	adcxq	%r8,%r15+	adoxq	%r8,%rax+	adcxq	%r8,%rax+	movq	%r9,16(%rsp)+	imulq	8(%rsp),%r9+++	xorq	%r8,%r8+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r10+	adcxq	%rbp,%r11++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r11+	adcxq	%rbp,%r12++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r12+	adcxq	%rbp,%r13++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r9,%rdx+	adoxq	%rdi,%r15+	adcxq	%rbp,%rax+	adoxq	%r8,%rax+	adoxq	%r8,%r8+++	xorq	%r9,%r9+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	16(%rsp),%rdi+	adoxq	%rbp,%r10++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r10+	adoxq	%rbp,%r11++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r11+	adoxq	%rbp,%r12++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r12+	adoxq	%rbp,%r13++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	24(%rbx),%rdx+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15+	adcxq	%r9,%r15+	adoxq	%r9,%rax+	adcxq	%r9,%rax+	adoxq	%r9,%r8+	adcxq	%r9,%r8+	movq	%r10,16(%rsp)+	imulq	8(%rsp),%r10+++	xorq	%r9,%r9+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r11+	adcxq	%rbp,%r12++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r12+	adcxq	%rbp,%r13++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r15+	adcxq	%rbp,%rax++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r10,%rdx+	adoxq	%rdi,%rax+	adcxq	%rbp,%r8+	adoxq	%r9,%r8+	adoxq	%r9,%r9+++	xorq	%r10,%r10+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	16(%rsp),%rdi+	adoxq	%rbp,%r11++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r11+	adoxq	%rbp,%r12++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r12+	adoxq	%rbp,%r13++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	32(%rbx),%rdx+	adcxq	%rdi,%r15+	adoxq	%rbp,%rax+	adcxq	%r10,%rax+	adoxq	%r10,%r8+	adcxq	%r10,%r8+	adoxq	%r10,%r9+	adcxq	%r10,%r9+	movq	%r11,16(%rsp)+	imulq	8(%rsp),%r11+++	xorq	%r10,%r10+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r12+	adcxq	%rbp,%r13++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r15+	adcxq	%rbp,%rax++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%rax+	adcxq	%rbp,%r8++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r11,%rdx+	adoxq	%rdi,%r8+	adcxq	%rbp,%r9+	adoxq	%r10,%r9+	adoxq	%r10,%r10+++	xorq	%r11,%r11+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	16(%rsp),%rdi+	adoxq	%rbp,%r12++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r12+	adoxq	%rbp,%r13++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r15+	adoxq	%rbp,%rax++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	40(%rbx),%rdx+	adcxq	%rdi,%rax+	adoxq	%rbp,%r8+	adcxq	%r11,%r8+	adoxq	%r11,%r9+	adcxq	%r11,%r9+	adoxq	%r11,%r10+	adcxq	%r11,%r10+	movq	%r12,16(%rsp)+	imulq	8(%rsp),%r12+++	xorq	%r11,%r11+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r15+	adcxq	%rbp,%rax++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%rax+	adcxq	%rbp,%r8++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r8+	adcxq	%rbp,%r9++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r12,%rdx+	adoxq	%rdi,%r9+	adcxq	%rbp,%r10+	adoxq	%r11,%r10+	adoxq	%r11,%r11+++	xorq	%r12,%r12+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	16(%rsp),%rdi+	adoxq	%rbp,%r13++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r15+	adoxq	%rbp,%rax++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%rax+	adoxq	%rbp,%r8++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	%r13,%rdx+	adcxq	%rdi,%r8+	adoxq	%rbp,%r9+	adcxq	%r12,%r9+	adoxq	%r12,%r10+	adcxq	%r12,%r10+	adoxq	%r12,%r11+	adcxq	%r12,%r11+	imulq	8(%rsp),%rdx+	movq	24(%rsp),%rbx+++	xorq	%r12,%r12+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r15+	adoxq	%rbp,%rax++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%rax+	adoxq	%rbp,%r8+	movq	%r15,%r13++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r8+	adoxq	%rbp,%r9+	movq	%rax,%rsi++	mulxq	40+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r9+	adoxq	%rbp,%r10+	movq	%r14,%rdx+	adcxq	%r12,%r10+	adoxq	%r12,%r11+	leaq	128(%rcx),%rcx+	movq	%r8,%r12+	adcq	$0,%r11+++++	subq	0(%rcx),%r14+	sbbq	8(%rcx),%r15+	movq	%r9,%rdi+	sbbq	16(%rcx),%rax+	sbbq	24(%rcx),%r8+	sbbq	32(%rcx),%r9+	movq	%r10,%rbp+	sbbq	40(%rcx),%r10+	sbbq	$0,%r11++	cmovncq	%r14,%rdx+	cmovcq	%r13,%r15+	cmovcq	%rsi,%rax+	cmovncq	%r8,%r12+	movq	%rdx,0(%rbx)+	cmovncq	%r9,%rdi+	movq	%r15,8(%rbx)+	cmovncq	%r10,%rbp+	movq	%rax,16(%rbx)+	movq	%r12,24(%rbx)+	movq	%rdi,32(%rbx)+	movq	%rbp,40(%rbx)++	.byte	0xf3,0xc3+.cfi_endproc	+.size	__mulx_mont_384,.-__mulx_mont_384+.globl	sqrx_mont_384+.hidden	sqrx_mont_384+.type	sqrx_mont_384,@function+.align	32+sqrx_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	leaq	-24(%rsp),%rsp+.cfi_adjust_cfa_offset	8*3+++	movq	%rcx,%r8+	leaq	-128(%rdx),%rcx+	movq	0(%rsi),%rdx+	movq	8(%rsi),%r15+	movq	16(%rsi),%rax+	movq	24(%rsi),%r12+	movq	%rdi,16(%rsp)+	movq	32(%rsi),%rdi+	movq	40(%rsi),%rbp++	leaq	(%rsi),%rbx+	movq	%r8,(%rsp)+	leaq	-128(%rsi),%rsi++	mulxq	%rdx,%r8,%r9+	call	__mulx_mont_384++	movq	24(%rsp),%r15+.cfi_restore	%r15+	movq	32(%rsp),%r14+.cfi_restore	%r14+	movq	40(%rsp),%r13+.cfi_restore	%r13+	movq	48(%rsp),%r12+.cfi_restore	%r12+	movq	56(%rsp),%rbx+.cfi_restore	%rbx+	movq	64(%rsp),%rbp+.cfi_restore	%rbp+	leaq	72(%rsp),%rsp+.cfi_adjust_cfa_offset	-8*9++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sqrx_mont_384,.-sqrx_mont_384++.globl	sqrx_n_mul_mont_384+.hidden	sqrx_n_mul_mont_384+.type	sqrx_n_mul_mont_384,@function+.align	32+sqrx_n_mul_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	leaq	-40(%rsp),%rsp+.cfi_adjust_cfa_offset	8*5+++	movq	%rdx,%r10+	movq	0(%rsi),%rdx+	movq	8(%rsi),%r15+	movq	16(%rsi),%rax+	movq	%rsi,%rbx+	movq	24(%rsi),%r12+	movq	%rdi,16(%rsp)+	movq	32(%rsi),%rdi+	movq	40(%rsi),%rbp++	movq	%r8,(%rsp)+	movq	%r9,24(%rsp)+	movq	0(%r9),%xmm2++.Loop_sqrx_384:+	movd	%r10d,%xmm1+	leaq	-128(%rbx),%rsi+	leaq	-128(%rcx),%rcx++	mulxq	%rdx,%r8,%r9+	call	__mulx_mont_384++	movd	%xmm1,%r10d+	decl	%r10d+	jnz	.Loop_sqrx_384++	movq	%rdx,%r14+.byte	102,72,15,126,210+	leaq	-128(%rbx),%rsi+	movq	24(%rsp),%rbx+	leaq	-128(%rcx),%rcx++	mulxq	%r14,%r8,%r9+	call	__mulx_mont_384++	movq	40(%rsp),%r15+.cfi_restore	%r15+	movq	48(%rsp),%r14+.cfi_restore	%r14+	movq	56(%rsp),%r13+.cfi_restore	%r13+	movq	64(%rsp),%r12+.cfi_restore	%r12+	movq	72(%rsp),%rbx+.cfi_restore	%rbx+	movq	80(%rsp),%rbp+.cfi_restore	%rbp+	leaq	88(%rsp),%rsp+.cfi_adjust_cfa_offset	-8*11++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sqrx_n_mul_mont_384,.-sqrx_n_mul_mont_384++.globl	sqrx_n_mul_mont_383+.hidden	sqrx_n_mul_mont_383+.type	sqrx_n_mul_mont_383,@function+.align	32+sqrx_n_mul_mont_383:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	leaq	-40(%rsp),%rsp+.cfi_adjust_cfa_offset	8*5+++	movq	%rdx,%r10+	movq	0(%rsi),%rdx+	movq	8(%rsi),%r15+	movq	16(%rsi),%rax+	movq	%rsi,%rbx+	movq	24(%rsi),%r12+	movq	%rdi,16(%rsp)+	movq	32(%rsi),%rdi+	movq	40(%rsi),%rbp++	movq	%r8,(%rsp)+	movq	%r9,24(%rsp)+	movq	0(%r9),%xmm2+	leaq	-128(%rcx),%rcx++.Loop_sqrx_383:+	movd	%r10d,%xmm1+	leaq	-128(%rbx),%rsi++	mulxq	%rdx,%r8,%r9+	call	__mulx_mont_383_nonred++	movd	%xmm1,%r10d+	decl	%r10d+	jnz	.Loop_sqrx_383++	movq	%rdx,%r14+.byte	102,72,15,126,210+	leaq	-128(%rbx),%rsi+	movq	24(%rsp),%rbx++	mulxq	%r14,%r8,%r9+	call	__mulx_mont_384++	movq	40(%rsp),%r15+.cfi_restore	%r15+	movq	48(%rsp),%r14+.cfi_restore	%r14+	movq	56(%rsp),%r13+.cfi_restore	%r13+	movq	64(%rsp),%r12+.cfi_restore	%r12+	movq	72(%rsp),%rbx+.cfi_restore	%rbx+	movq	80(%rsp),%rbp+.cfi_restore	%rbp+	leaq	88(%rsp),%rsp+.cfi_adjust_cfa_offset	-8*11++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sqrx_n_mul_mont_383,.-sqrx_n_mul_mont_383+.type	__mulx_mont_383_nonred,@function+.align	32+__mulx_mont_383_nonred:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	mulxq	%r15,%r14,%r10+	mulxq	%rax,%r15,%r11+	addq	%r14,%r9+	mulxq	%r12,%rax,%r12+	adcq	%r15,%r10+	mulxq	%rdi,%rdi,%r13+	adcq	%rax,%r11+	mulxq	%rbp,%rbp,%r14+	movq	8(%rbx),%rdx+	adcq	%rdi,%r12+	adcq	%rbp,%r13+	adcq	$0,%r14+	movq	%r8,%rax+	imulq	8(%rsp),%r8+++	xorq	%r15,%r15+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r9+	adcxq	%rbp,%r10++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r10+	adcxq	%rbp,%r11++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r11+	adcxq	%rbp,%r12++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r12+	adcxq	%rbp,%r13++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r8,%rdx+	adoxq	%rdi,%r14+	adcxq	%r15,%rbp+	adoxq	%rbp,%r15+++	xorq	%r8,%r8+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%rax+	adoxq	%rbp,%r9++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r9+	adoxq	%rbp,%r10++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r10+	adoxq	%rbp,%r11++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r11+	adoxq	%rbp,%r12++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r12+	adoxq	%rbp,%r13++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	16(%rbx),%rdx+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14+	adcxq	%rax,%r14+	adoxq	%rax,%r15+	adcxq	%rax,%r15+	movq	%r9,%r8+	imulq	8(%rsp),%r9+++	xorq	%rax,%rax+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r10+	adcxq	%rbp,%r11++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r11+	adcxq	%rbp,%r12++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r12+	adcxq	%rbp,%r13++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r9,%rdx+	adoxq	%rdi,%r15+	adcxq	%rax,%rbp+	adoxq	%rbp,%rax+++	xorq	%r9,%r9+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r8+	adoxq	%rbp,%r10++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r10+	adoxq	%rbp,%r11++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r11+	adoxq	%rbp,%r12++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r12+	adoxq	%rbp,%r13++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	24(%rbx),%rdx+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15+	adcxq	%r8,%r15+	adoxq	%r8,%rax+	adcxq	%r8,%rax+	movq	%r10,%r9+	imulq	8(%rsp),%r10+++	xorq	%r8,%r8+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r11+	adcxq	%rbp,%r12++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r12+	adcxq	%rbp,%r13++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r15+	adcxq	%rbp,%rax++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r10,%rdx+	adoxq	%rdi,%rax+	adcxq	%r8,%rbp+	adoxq	%rbp,%r8+++	xorq	%r10,%r10+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r9+	adoxq	%rbp,%r11++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r11+	adoxq	%rbp,%r12++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r12+	adoxq	%rbp,%r13++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	32(%rbx),%rdx+	adcxq	%rdi,%r15+	adoxq	%rbp,%rax+	adcxq	%r9,%rax+	adoxq	%r9,%r8+	adcxq	%r9,%r8+	movq	%r11,%r10+	imulq	8(%rsp),%r11+++	xorq	%r9,%r9+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r12+	adcxq	%rbp,%r13++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r15+	adcxq	%rbp,%rax++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%rax+	adcxq	%rbp,%r8++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r11,%rdx+	adoxq	%rdi,%r8+	adcxq	%r9,%rbp+	adoxq	%rbp,%r9+++	xorq	%r11,%r11+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r10+	adoxq	%rbp,%r12++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r12+	adoxq	%rbp,%r13++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r15+	adoxq	%rbp,%rax++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	40(%rbx),%rdx+	adcxq	%rdi,%rax+	adoxq	%rbp,%r8+	adcxq	%r10,%r8+	adoxq	%r10,%r9+	adcxq	%r10,%r9+	movq	%r12,%r11+	imulq	8(%rsp),%r12+++	xorq	%r10,%r10+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r15+	adcxq	%rbp,%rax++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%rax+	adcxq	%rbp,%r8++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r8+	adcxq	%rbp,%r9++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r12,%rdx+	adoxq	%rdi,%r9+	adcxq	%r10,%rbp+	adoxq	%rbp,%r10+++	xorq	%r12,%r12+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r11+	adoxq	%rbp,%r13++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r15+	adoxq	%rbp,%rax++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%rax+	adoxq	%rbp,%r8++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	%r13,%rdx+	adcxq	%rdi,%r8+	adoxq	%rbp,%r9+	adcxq	%r11,%r9+	adoxq	%r11,%r10+	adcxq	%r11,%r10+	imulq	8(%rsp),%rdx+	movq	24(%rsp),%rbx+++	xorq	%r12,%r12+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r15+	adoxq	%rbp,%rax++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%rax+	adoxq	%rbp,%r8++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r8+	adoxq	%rbp,%r9++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	%r14,%rdx+	adcxq	%rdi,%r9+	adoxq	%rbp,%r10+	adcq	$0,%r10+	movq	%r8,%r12++	movq	%r14,0(%rbx)+	movq	%r15,8(%rbx)+	movq	%rax,16(%rbx)+	movq	%r9,%rdi+	movq	%r8,24(%rbx)+	movq	%r9,32(%rbx)+	movq	%r10,40(%rbx)+	movq	%r10,%rbp++	.byte	0xf3,0xc3+.cfi_endproc	+.size	__mulx_mont_383_nonred,.-__mulx_mont_383_nonred+.globl	sqrx_mont_382x+.hidden	sqrx_mont_382x+.type	sqrx_mont_382x,@function+.align	32+sqrx_mont_382x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$136,%rsp+.cfi_adjust_cfa_offset	136+++	movq	%rcx,0(%rsp)+	movq	%rdx,%rcx+	movq	%rdi,16(%rsp)+	movq	%rsi,24(%rsp)+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%r8,%r14+	addq	48(%rsi),%r8+	movq	%r9,%r15+	adcq	56(%rsi),%r9+	movq	%r10,%rax+	adcq	64(%rsi),%r10+	movq	%r11,%rdx+	adcq	72(%rsi),%r11+	movq	%r12,%rbx+	adcq	80(%rsi),%r12+	movq	%r13,%rbp+	adcq	88(%rsi),%r13++	subq	48(%rsi),%r14+	sbbq	56(%rsi),%r15+	sbbq	64(%rsi),%rax+	sbbq	72(%rsi),%rdx+	sbbq	80(%rsi),%rbx+	sbbq	88(%rsi),%rbp+	sbbq	%rdi,%rdi++	movq	%r8,32+0(%rsp)+	movq	%r9,32+8(%rsp)+	movq	%r10,32+16(%rsp)+	movq	%r11,32+24(%rsp)+	movq	%r12,32+32(%rsp)+	movq	%r13,32+40(%rsp)++	movq	%r14,32+48(%rsp)+	movq	%r15,32+56(%rsp)+	movq	%rax,32+64(%rsp)+	movq	%rdx,32+72(%rsp)+	movq	%rbx,32+80(%rsp)+	movq	%rbp,32+88(%rsp)+	movq	%rdi,32+96(%rsp)++++	leaq	48(%rsi),%rbx++	movq	48(%rsi),%rdx+	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%rax+	movq	24(%rsi),%r12+	movq	32(%rsi),%rdi+	movq	40(%rsi),%rbp+	leaq	-128(%rsi),%rsi+	leaq	-128(%rcx),%rcx++	mulxq	%r14,%r8,%r9+	call	__mulx_mont_383_nonred+	addq	%rdx,%rdx+	adcq	%r15,%r15+	adcq	%rax,%rax+	adcq	%r12,%r12+	adcq	%rdi,%rdi+	adcq	%rbp,%rbp++	movq	%rdx,48(%rbx)+	movq	%r15,56(%rbx)+	movq	%rax,64(%rbx)+	movq	%r12,72(%rbx)+	movq	%rdi,80(%rbx)+	movq	%rbp,88(%rbx)++	leaq	32-128(%rsp),%rsi+	leaq	32+48(%rsp),%rbx++	movq	32+48(%rsp),%rdx+	movq	32+0(%rsp),%r14+	movq	32+8(%rsp),%r15+	movq	32+16(%rsp),%rax+	movq	32+24(%rsp),%r12+	movq	32+32(%rsp),%rdi+	movq	32+40(%rsp),%rbp++++	mulxq	%r14,%r8,%r9+	call	__mulx_mont_383_nonred+	movq	32+96(%rsp),%r14+	leaq	128(%rcx),%rcx+	movq	32+0(%rsp),%r8+	andq	%r14,%r8+	movq	32+8(%rsp),%r9+	andq	%r14,%r9+	movq	32+16(%rsp),%r10+	andq	%r14,%r10+	movq	32+24(%rsp),%r11+	andq	%r14,%r11+	movq	32+32(%rsp),%r13+	andq	%r14,%r13+	andq	32+40(%rsp),%r14++	subq	%r8,%rdx+	movq	0(%rcx),%r8+	sbbq	%r9,%r15+	movq	8(%rcx),%r9+	sbbq	%r10,%rax+	movq	16(%rcx),%r10+	sbbq	%r11,%r12+	movq	24(%rcx),%r11+	sbbq	%r13,%rdi+	movq	32(%rcx),%r13+	sbbq	%r14,%rbp+	sbbq	%r14,%r14++	andq	%r14,%r8+	andq	%r14,%r9+	andq	%r14,%r10+	andq	%r14,%r11+	andq	%r14,%r13+	andq	40(%rcx),%r14++	addq	%r8,%rdx+	adcq	%r9,%r15+	adcq	%r10,%rax+	adcq	%r11,%r12+	adcq	%r13,%rdi+	adcq	%r14,%rbp++	movq	%rdx,0(%rbx)+	movq	%r15,8(%rbx)+	movq	%rax,16(%rbx)+	movq	%r12,24(%rbx)+	movq	%rdi,32(%rbx)+	movq	%rbp,40(%rbx)+	leaq	136(%rsp),%r8+	movq	0(%r8),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-136-8*6++	.byte	0xf3,0xc3+.cfi_endproc	+.size	sqrx_mont_382x,.-sqrx_mont_382x++.section	.note.GNU-stack,"",@progbits+.section	.note.gnu.property,"a",@note+	.long	4,2f-1f,5+	.byte	0x47,0x4E,0x55,0+1:	.long	0xc0000002,4,3+.align	8+2:
+ c-source/build/elf/sha256-armv8.S view
@@ -0,0 +1,1077 @@+//+// Copyright Supranational LLC+// Licensed under the Apache License, Version 2.0, see LICENSE for details.+// SPDX-License-Identifier: Apache-2.0+//+// ====================================================================+// Written by Andy Polyakov, @dot-asm, initially for the OpenSSL+// project.+// ====================================================================+//+// sha256_block procedure for ARMv8.+//+// This module is stripped of scalar code paths, with raionale that all+// known processors are NEON-capable.+//+// See original module at CRYPTOGAMS for further details.++.text++.align	6+.type	.LK256,%object+.LK256:+.long	0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5+.long	0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5+.long	0xd807aa98,0x12835b01,0x243185be,0x550c7dc3+.long	0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174+.long	0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc+.long	0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da+.long	0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7+.long	0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967+.long	0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13+.long	0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85+.long	0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3+.long	0xd192e819,0xd6990624,0xf40e3585,0x106aa070+.long	0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5+.long	0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3+.long	0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208+.long	0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2+.long	0	//terminator+.size	.LK256,.-.LK256+.byte	83,72,65,50,53,54,32,98,108,111,99,107,32,116,114,97,110,115,102,111,114,109,32,102,111,114,32,65,82,77,118,56,44,32,67,82,89,80,84,79,71,65,77,83,32,98,121,32,64,100,111,116,45,97,115,109,0+.align	2+.align	2+.globl	blst_sha256_block_armv8+.type	blst_sha256_block_armv8,%function+.align	6+blst_sha256_block_armv8:+.Lv8_entry:+	stp	x29,x30,[sp,#-16]!+	add	x29,sp,#0++	ld1	{v0.4s,v1.4s},[x0]+	adr	x3,.LK256++.Loop_hw:+	ld1	{v4.16b,v5.16b,v6.16b,v7.16b},[x1],#64+	sub	x2,x2,#1+	ld1	{v16.4s},[x3],#16+	rev32	v4.16b,v4.16b+	rev32	v5.16b,v5.16b+	rev32	v6.16b,v6.16b+	rev32	v7.16b,v7.16b+	orr	v18.16b,v0.16b,v0.16b		// offload+	orr	v19.16b,v1.16b,v1.16b+	ld1	{v17.4s},[x3],#16+	add	v16.4s,v16.4s,v4.4s+.inst	0x5e2828a4	//sha256su0 v4.16b,v5.16b+	orr	v2.16b,v0.16b,v0.16b+.inst	0x5e104020	//sha256h v0.16b,v1.16b,v16.4s+.inst	0x5e105041	//sha256h2 v1.16b,v2.16b,v16.4s+.inst	0x5e0760c4	//sha256su1 v4.16b,v6.16b,v7.16b+	ld1	{v16.4s},[x3],#16+	add	v17.4s,v17.4s,v5.4s+.inst	0x5e2828c5	//sha256su0 v5.16b,v6.16b+	orr	v2.16b,v0.16b,v0.16b+.inst	0x5e114020	//sha256h v0.16b,v1.16b,v17.4s+.inst	0x5e115041	//sha256h2 v1.16b,v2.16b,v17.4s+.inst	0x5e0460e5	//sha256su1 v5.16b,v7.16b,v4.16b+	ld1	{v17.4s},[x3],#16+	add	v16.4s,v16.4s,v6.4s+.inst	0x5e2828e6	//sha256su0 v6.16b,v7.16b+	orr	v2.16b,v0.16b,v0.16b+.inst	0x5e104020	//sha256h v0.16b,v1.16b,v16.4s+.inst	0x5e105041	//sha256h2 v1.16b,v2.16b,v16.4s+.inst	0x5e056086	//sha256su1 v6.16b,v4.16b,v5.16b+	ld1	{v16.4s},[x3],#16+	add	v17.4s,v17.4s,v7.4s+.inst	0x5e282887	//sha256su0 v7.16b,v4.16b+	orr	v2.16b,v0.16b,v0.16b+.inst	0x5e114020	//sha256h v0.16b,v1.16b,v17.4s+.inst	0x5e115041	//sha256h2 v1.16b,v2.16b,v17.4s+.inst	0x5e0660a7	//sha256su1 v7.16b,v5.16b,v6.16b+	ld1	{v17.4s},[x3],#16+	add	v16.4s,v16.4s,v4.4s+.inst	0x5e2828a4	//sha256su0 v4.16b,v5.16b+	orr	v2.16b,v0.16b,v0.16b+.inst	0x5e104020	//sha256h v0.16b,v1.16b,v16.4s+.inst	0x5e105041	//sha256h2 v1.16b,v2.16b,v16.4s+.inst	0x5e0760c4	//sha256su1 v4.16b,v6.16b,v7.16b+	ld1	{v16.4s},[x3],#16+	add	v17.4s,v17.4s,v5.4s+.inst	0x5e2828c5	//sha256su0 v5.16b,v6.16b+	orr	v2.16b,v0.16b,v0.16b+.inst	0x5e114020	//sha256h v0.16b,v1.16b,v17.4s+.inst	0x5e115041	//sha256h2 v1.16b,v2.16b,v17.4s+.inst	0x5e0460e5	//sha256su1 v5.16b,v7.16b,v4.16b+	ld1	{v17.4s},[x3],#16+	add	v16.4s,v16.4s,v6.4s+.inst	0x5e2828e6	//sha256su0 v6.16b,v7.16b+	orr	v2.16b,v0.16b,v0.16b+.inst	0x5e104020	//sha256h v0.16b,v1.16b,v16.4s+.inst	0x5e105041	//sha256h2 v1.16b,v2.16b,v16.4s+.inst	0x5e056086	//sha256su1 v6.16b,v4.16b,v5.16b+	ld1	{v16.4s},[x3],#16+	add	v17.4s,v17.4s,v7.4s+.inst	0x5e282887	//sha256su0 v7.16b,v4.16b+	orr	v2.16b,v0.16b,v0.16b+.inst	0x5e114020	//sha256h v0.16b,v1.16b,v17.4s+.inst	0x5e115041	//sha256h2 v1.16b,v2.16b,v17.4s+.inst	0x5e0660a7	//sha256su1 v7.16b,v5.16b,v6.16b+	ld1	{v17.4s},[x3],#16+	add	v16.4s,v16.4s,v4.4s+.inst	0x5e2828a4	//sha256su0 v4.16b,v5.16b+	orr	v2.16b,v0.16b,v0.16b+.inst	0x5e104020	//sha256h v0.16b,v1.16b,v16.4s+.inst	0x5e105041	//sha256h2 v1.16b,v2.16b,v16.4s+.inst	0x5e0760c4	//sha256su1 v4.16b,v6.16b,v7.16b+	ld1	{v16.4s},[x3],#16+	add	v17.4s,v17.4s,v5.4s+.inst	0x5e2828c5	//sha256su0 v5.16b,v6.16b+	orr	v2.16b,v0.16b,v0.16b+.inst	0x5e114020	//sha256h v0.16b,v1.16b,v17.4s+.inst	0x5e115041	//sha256h2 v1.16b,v2.16b,v17.4s+.inst	0x5e0460e5	//sha256su1 v5.16b,v7.16b,v4.16b+	ld1	{v17.4s},[x3],#16+	add	v16.4s,v16.4s,v6.4s+.inst	0x5e2828e6	//sha256su0 v6.16b,v7.16b+	orr	v2.16b,v0.16b,v0.16b+.inst	0x5e104020	//sha256h v0.16b,v1.16b,v16.4s+.inst	0x5e105041	//sha256h2 v1.16b,v2.16b,v16.4s+.inst	0x5e056086	//sha256su1 v6.16b,v4.16b,v5.16b+	ld1	{v16.4s},[x3],#16+	add	v17.4s,v17.4s,v7.4s+.inst	0x5e282887	//sha256su0 v7.16b,v4.16b+	orr	v2.16b,v0.16b,v0.16b+.inst	0x5e114020	//sha256h v0.16b,v1.16b,v17.4s+.inst	0x5e115041	//sha256h2 v1.16b,v2.16b,v17.4s+.inst	0x5e0660a7	//sha256su1 v7.16b,v5.16b,v6.16b+	ld1	{v17.4s},[x3],#16+	add	v16.4s,v16.4s,v4.4s+	orr	v2.16b,v0.16b,v0.16b+.inst	0x5e104020	//sha256h v0.16b,v1.16b,v16.4s+.inst	0x5e105041	//sha256h2 v1.16b,v2.16b,v16.4s++	ld1	{v16.4s},[x3],#16+	add	v17.4s,v17.4s,v5.4s+	orr	v2.16b,v0.16b,v0.16b+.inst	0x5e114020	//sha256h v0.16b,v1.16b,v17.4s+.inst	0x5e115041	//sha256h2 v1.16b,v2.16b,v17.4s++	ld1	{v17.4s},[x3]+	add	v16.4s,v16.4s,v6.4s+	sub	x3,x3,#64*4-16	// rewind+	orr	v2.16b,v0.16b,v0.16b+.inst	0x5e104020	//sha256h v0.16b,v1.16b,v16.4s+.inst	0x5e105041	//sha256h2 v1.16b,v2.16b,v16.4s++	add	v17.4s,v17.4s,v7.4s+	orr	v2.16b,v0.16b,v0.16b+.inst	0x5e114020	//sha256h v0.16b,v1.16b,v17.4s+.inst	0x5e115041	//sha256h2 v1.16b,v2.16b,v17.4s++	add	v0.4s,v0.4s,v18.4s+	add	v1.4s,v1.4s,v19.4s++	cbnz	x2,.Loop_hw++	st1	{v0.4s,v1.4s},[x0]++	ldr	x29,[sp],#16+	ret+.size	blst_sha256_block_armv8,.-blst_sha256_block_armv8+.globl	blst_sha256_block_data_order+.type	blst_sha256_block_data_order,%function+.align	4+blst_sha256_block_data_order:+	stp	x29, x30, [sp, #-16]!+	mov	x29, sp+	sub	sp,sp,#16*4++	adr	x16,.LK256+	add	x2,x1,x2,lsl#6	// len to point at the end of inp++	ld1	{v0.16b},[x1], #16+	ld1	{v1.16b},[x1], #16+	ld1	{v2.16b},[x1], #16+	ld1	{v3.16b},[x1], #16+	ld1	{v4.4s},[x16], #16+	ld1	{v5.4s},[x16], #16+	ld1	{v6.4s},[x16], #16+	ld1	{v7.4s},[x16], #16+	rev32	v0.16b,v0.16b		// yes, even on+	rev32	v1.16b,v1.16b		// big-endian+	rev32	v2.16b,v2.16b+	rev32	v3.16b,v3.16b+	mov	x17,sp+	add	v4.4s,v4.4s,v0.4s+	add	v5.4s,v5.4s,v1.4s+	add	v6.4s,v6.4s,v2.4s+	st1	{v4.4s,v5.4s},[x17], #32+	add	v7.4s,v7.4s,v3.4s+	st1	{v6.4s,v7.4s},[x17]+	sub	x17,x17,#32++	ldp	w3,w4,[x0]+	ldp	w5,w6,[x0,#8]+	ldp	w7,w8,[x0,#16]+	ldp	w9,w10,[x0,#24]+	ldr	w12,[sp,#0]+	mov	w13,wzr+	eor	w14,w4,w5+	mov	w15,wzr+	b	.L_00_48++.align	4+.L_00_48:+	ext	v4.16b,v0.16b,v1.16b,#4+	add	w10,w10,w12+	add	w3,w3,w15+	and	w12,w8,w7+	bic	w15,w9,w7+	ext	v7.16b,v2.16b,v3.16b,#4+	eor	w11,w7,w7,ror#5+	add	w3,w3,w13+	mov	d19,v3.d[1]+	orr	w12,w12,w15+	eor	w11,w11,w7,ror#19+	ushr	v6.4s,v4.4s,#7+	eor	w15,w3,w3,ror#11+	ushr	v5.4s,v4.4s,#3+	add	w10,w10,w12+	add	v0.4s,v0.4s,v7.4s+	ror	w11,w11,#6+	sli	v6.4s,v4.4s,#25+	eor	w13,w3,w4+	eor	w15,w15,w3,ror#20+	ushr	v7.4s,v4.4s,#18+	add	w10,w10,w11+	ldr	w12,[sp,#4]+	and	w14,w14,w13+	eor	v5.16b,v5.16b,v6.16b+	ror	w15,w15,#2+	add	w6,w6,w10+	sli	v7.4s,v4.4s,#14+	eor	w14,w14,w4+	ushr	v16.4s,v19.4s,#17+	add	w9,w9,w12+	add	w10,w10,w15+	and	w12,w7,w6+	eor	v5.16b,v5.16b,v7.16b+	bic	w15,w8,w6+	eor	w11,w6,w6,ror#5+	sli	v16.4s,v19.4s,#15+	add	w10,w10,w14+	orr	w12,w12,w15+	ushr	v17.4s,v19.4s,#10+	eor	w11,w11,w6,ror#19+	eor	w15,w10,w10,ror#11+	ushr	v7.4s,v19.4s,#19+	add	w9,w9,w12+	ror	w11,w11,#6+	add	v0.4s,v0.4s,v5.4s+	eor	w14,w10,w3+	eor	w15,w15,w10,ror#20+	sli	v7.4s,v19.4s,#13+	add	w9,w9,w11+	ldr	w12,[sp,#8]+	and	w13,w13,w14+	eor	v17.16b,v17.16b,v16.16b+	ror	w15,w15,#2+	add	w5,w5,w9+	eor	w13,w13,w3+	eor	v17.16b,v17.16b,v7.16b+	add	w8,w8,w12+	add	w9,w9,w15+	and	w12,w6,w5+	add	v0.4s,v0.4s,v17.4s+	bic	w15,w7,w5+	eor	w11,w5,w5,ror#5+	add	w9,w9,w13+	ushr	v18.4s,v0.4s,#17+	orr	w12,w12,w15+	ushr	v19.4s,v0.4s,#10+	eor	w11,w11,w5,ror#19+	eor	w15,w9,w9,ror#11+	sli	v18.4s,v0.4s,#15+	add	w8,w8,w12+	ushr	v17.4s,v0.4s,#19+	ror	w11,w11,#6+	eor	w13,w9,w10+	eor	v19.16b,v19.16b,v18.16b+	eor	w15,w15,w9,ror#20+	add	w8,w8,w11+	sli	v17.4s,v0.4s,#13+	ldr	w12,[sp,#12]+	and	w14,w14,w13+	ror	w15,w15,#2+	ld1	{v4.4s},[x16], #16+	add	w4,w4,w8+	eor	v19.16b,v19.16b,v17.16b+	eor	w14,w14,w10+	eor	v17.16b,v17.16b,v17.16b+	add	w7,w7,w12+	add	w8,w8,w15+	and	w12,w5,w4+	mov	v17.d[1],v19.d[0]+	bic	w15,w6,w4+	eor	w11,w4,w4,ror#5+	add	w8,w8,w14+	add	v0.4s,v0.4s,v17.4s+	orr	w12,w12,w15+	eor	w11,w11,w4,ror#19+	eor	w15,w8,w8,ror#11+	add	v4.4s,v4.4s,v0.4s+	add	w7,w7,w12+	ror	w11,w11,#6+	eor	w14,w8,w9+	eor	w15,w15,w8,ror#20+	add	w7,w7,w11+	ldr	w12,[sp,#16]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w3,w3,w7+	eor	w13,w13,w9+	st1	{v4.4s},[x17], #16+	ext	v4.16b,v1.16b,v2.16b,#4+	add	w6,w6,w12+	add	w7,w7,w15+	and	w12,w4,w3+	bic	w15,w5,w3+	ext	v7.16b,v3.16b,v0.16b,#4+	eor	w11,w3,w3,ror#5+	add	w7,w7,w13+	mov	d19,v0.d[1]+	orr	w12,w12,w15+	eor	w11,w11,w3,ror#19+	ushr	v6.4s,v4.4s,#7+	eor	w15,w7,w7,ror#11+	ushr	v5.4s,v4.4s,#3+	add	w6,w6,w12+	add	v1.4s,v1.4s,v7.4s+	ror	w11,w11,#6+	sli	v6.4s,v4.4s,#25+	eor	w13,w7,w8+	eor	w15,w15,w7,ror#20+	ushr	v7.4s,v4.4s,#18+	add	w6,w6,w11+	ldr	w12,[sp,#20]+	and	w14,w14,w13+	eor	v5.16b,v5.16b,v6.16b+	ror	w15,w15,#2+	add	w10,w10,w6+	sli	v7.4s,v4.4s,#14+	eor	w14,w14,w8+	ushr	v16.4s,v19.4s,#17+	add	w5,w5,w12+	add	w6,w6,w15+	and	w12,w3,w10+	eor	v5.16b,v5.16b,v7.16b+	bic	w15,w4,w10+	eor	w11,w10,w10,ror#5+	sli	v16.4s,v19.4s,#15+	add	w6,w6,w14+	orr	w12,w12,w15+	ushr	v17.4s,v19.4s,#10+	eor	w11,w11,w10,ror#19+	eor	w15,w6,w6,ror#11+	ushr	v7.4s,v19.4s,#19+	add	w5,w5,w12+	ror	w11,w11,#6+	add	v1.4s,v1.4s,v5.4s+	eor	w14,w6,w7+	eor	w15,w15,w6,ror#20+	sli	v7.4s,v19.4s,#13+	add	w5,w5,w11+	ldr	w12,[sp,#24]+	and	w13,w13,w14+	eor	v17.16b,v17.16b,v16.16b+	ror	w15,w15,#2+	add	w9,w9,w5+	eor	w13,w13,w7+	eor	v17.16b,v17.16b,v7.16b+	add	w4,w4,w12+	add	w5,w5,w15+	and	w12,w10,w9+	add	v1.4s,v1.4s,v17.4s+	bic	w15,w3,w9+	eor	w11,w9,w9,ror#5+	add	w5,w5,w13+	ushr	v18.4s,v1.4s,#17+	orr	w12,w12,w15+	ushr	v19.4s,v1.4s,#10+	eor	w11,w11,w9,ror#19+	eor	w15,w5,w5,ror#11+	sli	v18.4s,v1.4s,#15+	add	w4,w4,w12+	ushr	v17.4s,v1.4s,#19+	ror	w11,w11,#6+	eor	w13,w5,w6+	eor	v19.16b,v19.16b,v18.16b+	eor	w15,w15,w5,ror#20+	add	w4,w4,w11+	sli	v17.4s,v1.4s,#13+	ldr	w12,[sp,#28]+	and	w14,w14,w13+	ror	w15,w15,#2+	ld1	{v4.4s},[x16], #16+	add	w8,w8,w4+	eor	v19.16b,v19.16b,v17.16b+	eor	w14,w14,w6+	eor	v17.16b,v17.16b,v17.16b+	add	w3,w3,w12+	add	w4,w4,w15+	and	w12,w9,w8+	mov	v17.d[1],v19.d[0]+	bic	w15,w10,w8+	eor	w11,w8,w8,ror#5+	add	w4,w4,w14+	add	v1.4s,v1.4s,v17.4s+	orr	w12,w12,w15+	eor	w11,w11,w8,ror#19+	eor	w15,w4,w4,ror#11+	add	v4.4s,v4.4s,v1.4s+	add	w3,w3,w12+	ror	w11,w11,#6+	eor	w14,w4,w5+	eor	w15,w15,w4,ror#20+	add	w3,w3,w11+	ldr	w12,[sp,#32]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w7,w7,w3+	eor	w13,w13,w5+	st1	{v4.4s},[x17], #16+	ext	v4.16b,v2.16b,v3.16b,#4+	add	w10,w10,w12+	add	w3,w3,w15+	and	w12,w8,w7+	bic	w15,w9,w7+	ext	v7.16b,v0.16b,v1.16b,#4+	eor	w11,w7,w7,ror#5+	add	w3,w3,w13+	mov	d19,v1.d[1]+	orr	w12,w12,w15+	eor	w11,w11,w7,ror#19+	ushr	v6.4s,v4.4s,#7+	eor	w15,w3,w3,ror#11+	ushr	v5.4s,v4.4s,#3+	add	w10,w10,w12+	add	v2.4s,v2.4s,v7.4s+	ror	w11,w11,#6+	sli	v6.4s,v4.4s,#25+	eor	w13,w3,w4+	eor	w15,w15,w3,ror#20+	ushr	v7.4s,v4.4s,#18+	add	w10,w10,w11+	ldr	w12,[sp,#36]+	and	w14,w14,w13+	eor	v5.16b,v5.16b,v6.16b+	ror	w15,w15,#2+	add	w6,w6,w10+	sli	v7.4s,v4.4s,#14+	eor	w14,w14,w4+	ushr	v16.4s,v19.4s,#17+	add	w9,w9,w12+	add	w10,w10,w15+	and	w12,w7,w6+	eor	v5.16b,v5.16b,v7.16b+	bic	w15,w8,w6+	eor	w11,w6,w6,ror#5+	sli	v16.4s,v19.4s,#15+	add	w10,w10,w14+	orr	w12,w12,w15+	ushr	v17.4s,v19.4s,#10+	eor	w11,w11,w6,ror#19+	eor	w15,w10,w10,ror#11+	ushr	v7.4s,v19.4s,#19+	add	w9,w9,w12+	ror	w11,w11,#6+	add	v2.4s,v2.4s,v5.4s+	eor	w14,w10,w3+	eor	w15,w15,w10,ror#20+	sli	v7.4s,v19.4s,#13+	add	w9,w9,w11+	ldr	w12,[sp,#40]+	and	w13,w13,w14+	eor	v17.16b,v17.16b,v16.16b+	ror	w15,w15,#2+	add	w5,w5,w9+	eor	w13,w13,w3+	eor	v17.16b,v17.16b,v7.16b+	add	w8,w8,w12+	add	w9,w9,w15+	and	w12,w6,w5+	add	v2.4s,v2.4s,v17.4s+	bic	w15,w7,w5+	eor	w11,w5,w5,ror#5+	add	w9,w9,w13+	ushr	v18.4s,v2.4s,#17+	orr	w12,w12,w15+	ushr	v19.4s,v2.4s,#10+	eor	w11,w11,w5,ror#19+	eor	w15,w9,w9,ror#11+	sli	v18.4s,v2.4s,#15+	add	w8,w8,w12+	ushr	v17.4s,v2.4s,#19+	ror	w11,w11,#6+	eor	w13,w9,w10+	eor	v19.16b,v19.16b,v18.16b+	eor	w15,w15,w9,ror#20+	add	w8,w8,w11+	sli	v17.4s,v2.4s,#13+	ldr	w12,[sp,#44]+	and	w14,w14,w13+	ror	w15,w15,#2+	ld1	{v4.4s},[x16], #16+	add	w4,w4,w8+	eor	v19.16b,v19.16b,v17.16b+	eor	w14,w14,w10+	eor	v17.16b,v17.16b,v17.16b+	add	w7,w7,w12+	add	w8,w8,w15+	and	w12,w5,w4+	mov	v17.d[1],v19.d[0]+	bic	w15,w6,w4+	eor	w11,w4,w4,ror#5+	add	w8,w8,w14+	add	v2.4s,v2.4s,v17.4s+	orr	w12,w12,w15+	eor	w11,w11,w4,ror#19+	eor	w15,w8,w8,ror#11+	add	v4.4s,v4.4s,v2.4s+	add	w7,w7,w12+	ror	w11,w11,#6+	eor	w14,w8,w9+	eor	w15,w15,w8,ror#20+	add	w7,w7,w11+	ldr	w12,[sp,#48]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w3,w3,w7+	eor	w13,w13,w9+	st1	{v4.4s},[x17], #16+	ext	v4.16b,v3.16b,v0.16b,#4+	add	w6,w6,w12+	add	w7,w7,w15+	and	w12,w4,w3+	bic	w15,w5,w3+	ext	v7.16b,v1.16b,v2.16b,#4+	eor	w11,w3,w3,ror#5+	add	w7,w7,w13+	mov	d19,v2.d[1]+	orr	w12,w12,w15+	eor	w11,w11,w3,ror#19+	ushr	v6.4s,v4.4s,#7+	eor	w15,w7,w7,ror#11+	ushr	v5.4s,v4.4s,#3+	add	w6,w6,w12+	add	v3.4s,v3.4s,v7.4s+	ror	w11,w11,#6+	sli	v6.4s,v4.4s,#25+	eor	w13,w7,w8+	eor	w15,w15,w7,ror#20+	ushr	v7.4s,v4.4s,#18+	add	w6,w6,w11+	ldr	w12,[sp,#52]+	and	w14,w14,w13+	eor	v5.16b,v5.16b,v6.16b+	ror	w15,w15,#2+	add	w10,w10,w6+	sli	v7.4s,v4.4s,#14+	eor	w14,w14,w8+	ushr	v16.4s,v19.4s,#17+	add	w5,w5,w12+	add	w6,w6,w15+	and	w12,w3,w10+	eor	v5.16b,v5.16b,v7.16b+	bic	w15,w4,w10+	eor	w11,w10,w10,ror#5+	sli	v16.4s,v19.4s,#15+	add	w6,w6,w14+	orr	w12,w12,w15+	ushr	v17.4s,v19.4s,#10+	eor	w11,w11,w10,ror#19+	eor	w15,w6,w6,ror#11+	ushr	v7.4s,v19.4s,#19+	add	w5,w5,w12+	ror	w11,w11,#6+	add	v3.4s,v3.4s,v5.4s+	eor	w14,w6,w7+	eor	w15,w15,w6,ror#20+	sli	v7.4s,v19.4s,#13+	add	w5,w5,w11+	ldr	w12,[sp,#56]+	and	w13,w13,w14+	eor	v17.16b,v17.16b,v16.16b+	ror	w15,w15,#2+	add	w9,w9,w5+	eor	w13,w13,w7+	eor	v17.16b,v17.16b,v7.16b+	add	w4,w4,w12+	add	w5,w5,w15+	and	w12,w10,w9+	add	v3.4s,v3.4s,v17.4s+	bic	w15,w3,w9+	eor	w11,w9,w9,ror#5+	add	w5,w5,w13+	ushr	v18.4s,v3.4s,#17+	orr	w12,w12,w15+	ushr	v19.4s,v3.4s,#10+	eor	w11,w11,w9,ror#19+	eor	w15,w5,w5,ror#11+	sli	v18.4s,v3.4s,#15+	add	w4,w4,w12+	ushr	v17.4s,v3.4s,#19+	ror	w11,w11,#6+	eor	w13,w5,w6+	eor	v19.16b,v19.16b,v18.16b+	eor	w15,w15,w5,ror#20+	add	w4,w4,w11+	sli	v17.4s,v3.4s,#13+	ldr	w12,[sp,#60]+	and	w14,w14,w13+	ror	w15,w15,#2+	ld1	{v4.4s},[x16], #16+	add	w8,w8,w4+	eor	v19.16b,v19.16b,v17.16b+	eor	w14,w14,w6+	eor	v17.16b,v17.16b,v17.16b+	add	w3,w3,w12+	add	w4,w4,w15+	and	w12,w9,w8+	mov	v17.d[1],v19.d[0]+	bic	w15,w10,w8+	eor	w11,w8,w8,ror#5+	add	w4,w4,w14+	add	v3.4s,v3.4s,v17.4s+	orr	w12,w12,w15+	eor	w11,w11,w8,ror#19+	eor	w15,w4,w4,ror#11+	add	v4.4s,v4.4s,v3.4s+	add	w3,w3,w12+	ror	w11,w11,#6+	eor	w14,w4,w5+	eor	w15,w15,w4,ror#20+	add	w3,w3,w11+	ldr	w12,[x16]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w7,w7,w3+	eor	w13,w13,w5+	st1	{v4.4s},[x17], #16+	cmp	w12,#0				// check for K256 terminator+	ldr	w12,[sp,#0]+	sub	x17,x17,#64+	bne	.L_00_48++	sub	x16,x16,#256		// rewind x16+	cmp	x1,x2+	mov	x17, #64+	csel	x17, x17, xzr, eq+	sub	x1,x1,x17			// avoid SEGV+	mov	x17,sp+	add	w10,w10,w12+	add	w3,w3,w15+	and	w12,w8,w7+	ld1	{v0.16b},[x1],#16+	bic	w15,w9,w7+	eor	w11,w7,w7,ror#5+	ld1	{v4.4s},[x16],#16+	add	w3,w3,w13+	orr	w12,w12,w15+	eor	w11,w11,w7,ror#19+	eor	w15,w3,w3,ror#11+	rev32	v0.16b,v0.16b+	add	w10,w10,w12+	ror	w11,w11,#6+	eor	w13,w3,w4+	eor	w15,w15,w3,ror#20+	add	v4.4s,v4.4s,v0.4s+	add	w10,w10,w11+	ldr	w12,[sp,#4]+	and	w14,w14,w13+	ror	w15,w15,#2+	add	w6,w6,w10+	eor	w14,w14,w4+	add	w9,w9,w12+	add	w10,w10,w15+	and	w12,w7,w6+	bic	w15,w8,w6+	eor	w11,w6,w6,ror#5+	add	w10,w10,w14+	orr	w12,w12,w15+	eor	w11,w11,w6,ror#19+	eor	w15,w10,w10,ror#11+	add	w9,w9,w12+	ror	w11,w11,#6+	eor	w14,w10,w3+	eor	w15,w15,w10,ror#20+	add	w9,w9,w11+	ldr	w12,[sp,#8]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w5,w5,w9+	eor	w13,w13,w3+	add	w8,w8,w12+	add	w9,w9,w15+	and	w12,w6,w5+	bic	w15,w7,w5+	eor	w11,w5,w5,ror#5+	add	w9,w9,w13+	orr	w12,w12,w15+	eor	w11,w11,w5,ror#19+	eor	w15,w9,w9,ror#11+	add	w8,w8,w12+	ror	w11,w11,#6+	eor	w13,w9,w10+	eor	w15,w15,w9,ror#20+	add	w8,w8,w11+	ldr	w12,[sp,#12]+	and	w14,w14,w13+	ror	w15,w15,#2+	add	w4,w4,w8+	eor	w14,w14,w10+	add	w7,w7,w12+	add	w8,w8,w15+	and	w12,w5,w4+	bic	w15,w6,w4+	eor	w11,w4,w4,ror#5+	add	w8,w8,w14+	orr	w12,w12,w15+	eor	w11,w11,w4,ror#19+	eor	w15,w8,w8,ror#11+	add	w7,w7,w12+	ror	w11,w11,#6+	eor	w14,w8,w9+	eor	w15,w15,w8,ror#20+	add	w7,w7,w11+	ldr	w12,[sp,#16]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w3,w3,w7+	eor	w13,w13,w9+	st1	{v4.4s},[x17], #16+	add	w6,w6,w12+	add	w7,w7,w15+	and	w12,w4,w3+	ld1	{v1.16b},[x1],#16+	bic	w15,w5,w3+	eor	w11,w3,w3,ror#5+	ld1	{v4.4s},[x16],#16+	add	w7,w7,w13+	orr	w12,w12,w15+	eor	w11,w11,w3,ror#19+	eor	w15,w7,w7,ror#11+	rev32	v1.16b,v1.16b+	add	w6,w6,w12+	ror	w11,w11,#6+	eor	w13,w7,w8+	eor	w15,w15,w7,ror#20+	add	v4.4s,v4.4s,v1.4s+	add	w6,w6,w11+	ldr	w12,[sp,#20]+	and	w14,w14,w13+	ror	w15,w15,#2+	add	w10,w10,w6+	eor	w14,w14,w8+	add	w5,w5,w12+	add	w6,w6,w15+	and	w12,w3,w10+	bic	w15,w4,w10+	eor	w11,w10,w10,ror#5+	add	w6,w6,w14+	orr	w12,w12,w15+	eor	w11,w11,w10,ror#19+	eor	w15,w6,w6,ror#11+	add	w5,w5,w12+	ror	w11,w11,#6+	eor	w14,w6,w7+	eor	w15,w15,w6,ror#20+	add	w5,w5,w11+	ldr	w12,[sp,#24]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w9,w9,w5+	eor	w13,w13,w7+	add	w4,w4,w12+	add	w5,w5,w15+	and	w12,w10,w9+	bic	w15,w3,w9+	eor	w11,w9,w9,ror#5+	add	w5,w5,w13+	orr	w12,w12,w15+	eor	w11,w11,w9,ror#19+	eor	w15,w5,w5,ror#11+	add	w4,w4,w12+	ror	w11,w11,#6+	eor	w13,w5,w6+	eor	w15,w15,w5,ror#20+	add	w4,w4,w11+	ldr	w12,[sp,#28]+	and	w14,w14,w13+	ror	w15,w15,#2+	add	w8,w8,w4+	eor	w14,w14,w6+	add	w3,w3,w12+	add	w4,w4,w15+	and	w12,w9,w8+	bic	w15,w10,w8+	eor	w11,w8,w8,ror#5+	add	w4,w4,w14+	orr	w12,w12,w15+	eor	w11,w11,w8,ror#19+	eor	w15,w4,w4,ror#11+	add	w3,w3,w12+	ror	w11,w11,#6+	eor	w14,w4,w5+	eor	w15,w15,w4,ror#20+	add	w3,w3,w11+	ldr	w12,[sp,#32]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w7,w7,w3+	eor	w13,w13,w5+	st1	{v4.4s},[x17], #16+	add	w10,w10,w12+	add	w3,w3,w15+	and	w12,w8,w7+	ld1	{v2.16b},[x1],#16+	bic	w15,w9,w7+	eor	w11,w7,w7,ror#5+	ld1	{v4.4s},[x16],#16+	add	w3,w3,w13+	orr	w12,w12,w15+	eor	w11,w11,w7,ror#19+	eor	w15,w3,w3,ror#11+	rev32	v2.16b,v2.16b+	add	w10,w10,w12+	ror	w11,w11,#6+	eor	w13,w3,w4+	eor	w15,w15,w3,ror#20+	add	v4.4s,v4.4s,v2.4s+	add	w10,w10,w11+	ldr	w12,[sp,#36]+	and	w14,w14,w13+	ror	w15,w15,#2+	add	w6,w6,w10+	eor	w14,w14,w4+	add	w9,w9,w12+	add	w10,w10,w15+	and	w12,w7,w6+	bic	w15,w8,w6+	eor	w11,w6,w6,ror#5+	add	w10,w10,w14+	orr	w12,w12,w15+	eor	w11,w11,w6,ror#19+	eor	w15,w10,w10,ror#11+	add	w9,w9,w12+	ror	w11,w11,#6+	eor	w14,w10,w3+	eor	w15,w15,w10,ror#20+	add	w9,w9,w11+	ldr	w12,[sp,#40]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w5,w5,w9+	eor	w13,w13,w3+	add	w8,w8,w12+	add	w9,w9,w15+	and	w12,w6,w5+	bic	w15,w7,w5+	eor	w11,w5,w5,ror#5+	add	w9,w9,w13+	orr	w12,w12,w15+	eor	w11,w11,w5,ror#19+	eor	w15,w9,w9,ror#11+	add	w8,w8,w12+	ror	w11,w11,#6+	eor	w13,w9,w10+	eor	w15,w15,w9,ror#20+	add	w8,w8,w11+	ldr	w12,[sp,#44]+	and	w14,w14,w13+	ror	w15,w15,#2+	add	w4,w4,w8+	eor	w14,w14,w10+	add	w7,w7,w12+	add	w8,w8,w15+	and	w12,w5,w4+	bic	w15,w6,w4+	eor	w11,w4,w4,ror#5+	add	w8,w8,w14+	orr	w12,w12,w15+	eor	w11,w11,w4,ror#19+	eor	w15,w8,w8,ror#11+	add	w7,w7,w12+	ror	w11,w11,#6+	eor	w14,w8,w9+	eor	w15,w15,w8,ror#20+	add	w7,w7,w11+	ldr	w12,[sp,#48]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w3,w3,w7+	eor	w13,w13,w9+	st1	{v4.4s},[x17], #16+	add	w6,w6,w12+	add	w7,w7,w15+	and	w12,w4,w3+	ld1	{v3.16b},[x1],#16+	bic	w15,w5,w3+	eor	w11,w3,w3,ror#5+	ld1	{v4.4s},[x16],#16+	add	w7,w7,w13+	orr	w12,w12,w15+	eor	w11,w11,w3,ror#19+	eor	w15,w7,w7,ror#11+	rev32	v3.16b,v3.16b+	add	w6,w6,w12+	ror	w11,w11,#6+	eor	w13,w7,w8+	eor	w15,w15,w7,ror#20+	add	v4.4s,v4.4s,v3.4s+	add	w6,w6,w11+	ldr	w12,[sp,#52]+	and	w14,w14,w13+	ror	w15,w15,#2+	add	w10,w10,w6+	eor	w14,w14,w8+	add	w5,w5,w12+	add	w6,w6,w15+	and	w12,w3,w10+	bic	w15,w4,w10+	eor	w11,w10,w10,ror#5+	add	w6,w6,w14+	orr	w12,w12,w15+	eor	w11,w11,w10,ror#19+	eor	w15,w6,w6,ror#11+	add	w5,w5,w12+	ror	w11,w11,#6+	eor	w14,w6,w7+	eor	w15,w15,w6,ror#20+	add	w5,w5,w11+	ldr	w12,[sp,#56]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w9,w9,w5+	eor	w13,w13,w7+	add	w4,w4,w12+	add	w5,w5,w15+	and	w12,w10,w9+	bic	w15,w3,w9+	eor	w11,w9,w9,ror#5+	add	w5,w5,w13+	orr	w12,w12,w15+	eor	w11,w11,w9,ror#19+	eor	w15,w5,w5,ror#11+	add	w4,w4,w12+	ror	w11,w11,#6+	eor	w13,w5,w6+	eor	w15,w15,w5,ror#20+	add	w4,w4,w11+	ldr	w12,[sp,#60]+	and	w14,w14,w13+	ror	w15,w15,#2+	add	w8,w8,w4+	eor	w14,w14,w6+	add	w3,w3,w12+	add	w4,w4,w15+	and	w12,w9,w8+	bic	w15,w10,w8+	eor	w11,w8,w8,ror#5+	add	w4,w4,w14+	orr	w12,w12,w15+	eor	w11,w11,w8,ror#19+	eor	w15,w4,w4,ror#11+	add	w3,w3,w12+	ror	w11,w11,#6+	eor	w14,w4,w5+	eor	w15,w15,w4,ror#20+	add	w3,w3,w11+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w7,w7,w3+	eor	w13,w13,w5+	st1	{v4.4s},[x17], #16+	add	w3,w3,w15			// h+=Sigma0(a) from the past+	ldp	w11,w12,[x0,#0]+	add	w3,w3,w13			// h+=Maj(a,b,c) from the past+	ldp	w13,w14,[x0,#8]+	add	w3,w3,w11			// accumulate+	add	w4,w4,w12+	ldp	w11,w12,[x0,#16]+	add	w5,w5,w13+	add	w6,w6,w14+	ldp	w13,w14,[x0,#24]+	add	w7,w7,w11+	add	w8,w8,w12+	ldr	w12,[sp,#0]+	stp	w3,w4,[x0,#0]+	add	w9,w9,w13+	mov	w13,wzr+	stp	w5,w6,[x0,#8]+	add	w10,w10,w14+	stp	w7,w8,[x0,#16]+	eor	w14,w4,w5+	stp	w9,w10,[x0,#24]+	mov	w15,wzr+	mov	x17,sp+	b.ne	.L_00_48++	ldr	x29,[x29]+	add	sp,sp,#16*4+16+	ret+.size	blst_sha256_block_data_order,.-blst_sha256_block_data_order+.globl	blst_sha256_emit+.hidden	blst_sha256_emit+.type	blst_sha256_emit,%function+.align	4+blst_sha256_emit:+	ldp	x4,x5,[x1]+	ldp	x6,x7,[x1,#16]+#ifndef	__AARCH64EB__+	rev	x4,x4+	rev	x5,x5+	rev	x6,x6+	rev	x7,x7+#endif+	str	w4,[x0,#4]+	lsr	x4,x4,#32+	str	w5,[x0,#12]+	lsr	x5,x5,#32+	str	w6,[x0,#20]+	lsr	x6,x6,#32+	str	w7,[x0,#28]+	lsr	x7,x7,#32+	str	w4,[x0,#0]+	str	w5,[x0,#8]+	str	w6,[x0,#16]+	str	w7,[x0,#24]+	ret+.size	blst_sha256_emit,.-blst_sha256_emit++.globl	blst_sha256_bcopy+.hidden	blst_sha256_bcopy+.type	blst_sha256_bcopy,%function+.align	4+blst_sha256_bcopy:+.Loop_bcopy:+	ldrb	w3,[x1],#1+	sub	x2,x2,#1+	strb	w3,[x0],#1+	cbnz	x2,.Loop_bcopy+	ret+.size	blst_sha256_bcopy,.-blst_sha256_bcopy++.globl	blst_sha256_hcopy+.hidden	blst_sha256_hcopy+.type	blst_sha256_hcopy,%function+.align	4+blst_sha256_hcopy:+	ldp	x4,x5,[x1]+	ldp	x6,x7,[x1,#16]+	stp	x4,x5,[x0]+	stp	x6,x7,[x0,#16]+	ret+.size	blst_sha256_hcopy,.-blst_sha256_hcopy
+ c-source/build/elf/sha256-portable-x86_64.s view
@@ -0,0 +1,1754 @@+.text	++.globl	blst_sha256_block_data_order+.type	blst_sha256_block_data_order,@function+.align	16+blst_sha256_block_data_order:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-16+	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	shlq	$4,%rdx+	subq	$64+24,%rsp+.cfi_adjust_cfa_offset	16*4+3*8+	leaq	(%rsi,%rdx,4),%rdx+	movq	%rdi,64+0(%rsp)+	movq	%rsi,64+8(%rsp)+	movq	%rdx,64+16(%rsp)+++	movl	0(%rdi),%eax+	movl	4(%rdi),%ebx+	movl	8(%rdi),%ecx+	movl	12(%rdi),%edx+	movl	16(%rdi),%r8d+	movl	20(%rdi),%r9d+	movl	24(%rdi),%r10d+	movl	28(%rdi),%r11d+	jmp	.Lloop++.align	16+.Lloop:+	movl	%ebx,%edi+	leaq	K256(%rip),%rbp+	xorl	%ecx,%edi+	movl	0(%rsi),%r12d+	movl	%r8d,%r13d+	movl	%eax,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%r9d,%r15d++	xorl	%r8d,%r13d+	rorl	$9,%r14d+	xorl	%r10d,%r15d++	movl	%r12d,0(%rsp)+	xorl	%eax,%r14d+	andl	%r8d,%r15d++	rorl	$5,%r13d+	addl	%r11d,%r12d+	xorl	%r10d,%r15d++	rorl	$11,%r14d+	xorl	%r8d,%r13d+	addl	%r15d,%r12d++	movl	%eax,%r15d+	addl	0(%rbp),%r12d+	xorl	%eax,%r14d++	xorl	%ebx,%r15d+	rorl	$6,%r13d+	movl	%ebx,%r11d++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%r11d+	addl	%r12d,%edx+	addl	%r12d,%r11d+	addl	%r14d,%r11d+	movl	4(%rsi),%r12d+	movl	%edx,%r13d+	movl	%r11d,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%r8d,%edi++	xorl	%edx,%r13d+	rorl	$9,%r14d+	xorl	%r9d,%edi++	movl	%r12d,4(%rsp)+	xorl	%r11d,%r14d+	andl	%edx,%edi++	rorl	$5,%r13d+	addl	%r10d,%r12d+	xorl	%r9d,%edi++	rorl	$11,%r14d+	xorl	%edx,%r13d+	addl	%edi,%r12d++	movl	%r11d,%edi+	addl	4(%rbp),%r12d+	xorl	%r11d,%r14d++	xorl	%eax,%edi+	rorl	$6,%r13d+	movl	%eax,%r10d++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%r10d+	addl	%r12d,%ecx+	addl	%r12d,%r10d+	addl	%r14d,%r10d+	movl	8(%rsi),%r12d+	movl	%ecx,%r13d+	movl	%r10d,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%edx,%r15d++	xorl	%ecx,%r13d+	rorl	$9,%r14d+	xorl	%r8d,%r15d++	movl	%r12d,8(%rsp)+	xorl	%r10d,%r14d+	andl	%ecx,%r15d++	rorl	$5,%r13d+	addl	%r9d,%r12d+	xorl	%r8d,%r15d++	rorl	$11,%r14d+	xorl	%ecx,%r13d+	addl	%r15d,%r12d++	movl	%r10d,%r15d+	addl	8(%rbp),%r12d+	xorl	%r10d,%r14d++	xorl	%r11d,%r15d+	rorl	$6,%r13d+	movl	%r11d,%r9d++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%r9d+	addl	%r12d,%ebx+	addl	%r12d,%r9d+	addl	%r14d,%r9d+	movl	12(%rsi),%r12d+	movl	%ebx,%r13d+	movl	%r9d,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%ecx,%edi++	xorl	%ebx,%r13d+	rorl	$9,%r14d+	xorl	%edx,%edi++	movl	%r12d,12(%rsp)+	xorl	%r9d,%r14d+	andl	%ebx,%edi++	rorl	$5,%r13d+	addl	%r8d,%r12d+	xorl	%edx,%edi++	rorl	$11,%r14d+	xorl	%ebx,%r13d+	addl	%edi,%r12d++	movl	%r9d,%edi+	addl	12(%rbp),%r12d+	xorl	%r9d,%r14d++	xorl	%r10d,%edi+	rorl	$6,%r13d+	movl	%r10d,%r8d++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%r8d+	addl	%r12d,%eax+	addl	%r12d,%r8d+	addl	%r14d,%r8d+	movl	16(%rsi),%r12d+	movl	%eax,%r13d+	movl	%r8d,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%ebx,%r15d++	xorl	%eax,%r13d+	rorl	$9,%r14d+	xorl	%ecx,%r15d++	movl	%r12d,16(%rsp)+	xorl	%r8d,%r14d+	andl	%eax,%r15d++	rorl	$5,%r13d+	addl	%edx,%r12d+	xorl	%ecx,%r15d++	rorl	$11,%r14d+	xorl	%eax,%r13d+	addl	%r15d,%r12d++	movl	%r8d,%r15d+	addl	16(%rbp),%r12d+	xorl	%r8d,%r14d++	xorl	%r9d,%r15d+	rorl	$6,%r13d+	movl	%r9d,%edx++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%edx+	addl	%r12d,%r11d+	addl	%r12d,%edx+	addl	%r14d,%edx+	movl	20(%rsi),%r12d+	movl	%r11d,%r13d+	movl	%edx,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%eax,%edi++	xorl	%r11d,%r13d+	rorl	$9,%r14d+	xorl	%ebx,%edi++	movl	%r12d,20(%rsp)+	xorl	%edx,%r14d+	andl	%r11d,%edi++	rorl	$5,%r13d+	addl	%ecx,%r12d+	xorl	%ebx,%edi++	rorl	$11,%r14d+	xorl	%r11d,%r13d+	addl	%edi,%r12d++	movl	%edx,%edi+	addl	20(%rbp),%r12d+	xorl	%edx,%r14d++	xorl	%r8d,%edi+	rorl	$6,%r13d+	movl	%r8d,%ecx++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%ecx+	addl	%r12d,%r10d+	addl	%r12d,%ecx+	addl	%r14d,%ecx+	movl	24(%rsi),%r12d+	movl	%r10d,%r13d+	movl	%ecx,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%r11d,%r15d++	xorl	%r10d,%r13d+	rorl	$9,%r14d+	xorl	%eax,%r15d++	movl	%r12d,24(%rsp)+	xorl	%ecx,%r14d+	andl	%r10d,%r15d++	rorl	$5,%r13d+	addl	%ebx,%r12d+	xorl	%eax,%r15d++	rorl	$11,%r14d+	xorl	%r10d,%r13d+	addl	%r15d,%r12d++	movl	%ecx,%r15d+	addl	24(%rbp),%r12d+	xorl	%ecx,%r14d++	xorl	%edx,%r15d+	rorl	$6,%r13d+	movl	%edx,%ebx++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%ebx+	addl	%r12d,%r9d+	addl	%r12d,%ebx+	addl	%r14d,%ebx+	movl	28(%rsi),%r12d+	movl	%r9d,%r13d+	movl	%ebx,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%r10d,%edi++	xorl	%r9d,%r13d+	rorl	$9,%r14d+	xorl	%r11d,%edi++	movl	%r12d,28(%rsp)+	xorl	%ebx,%r14d+	andl	%r9d,%edi++	rorl	$5,%r13d+	addl	%eax,%r12d+	xorl	%r11d,%edi++	rorl	$11,%r14d+	xorl	%r9d,%r13d+	addl	%edi,%r12d++	movl	%ebx,%edi+	addl	28(%rbp),%r12d+	xorl	%ebx,%r14d++	xorl	%ecx,%edi+	rorl	$6,%r13d+	movl	%ecx,%eax++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%eax+	addl	%r12d,%r8d+	addl	%r12d,%eax+	addl	%r14d,%eax+	movl	32(%rsi),%r12d+	movl	%r8d,%r13d+	movl	%eax,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%r9d,%r15d++	xorl	%r8d,%r13d+	rorl	$9,%r14d+	xorl	%r10d,%r15d++	movl	%r12d,32(%rsp)+	xorl	%eax,%r14d+	andl	%r8d,%r15d++	rorl	$5,%r13d+	addl	%r11d,%r12d+	xorl	%r10d,%r15d++	rorl	$11,%r14d+	xorl	%r8d,%r13d+	addl	%r15d,%r12d++	movl	%eax,%r15d+	addl	32(%rbp),%r12d+	xorl	%eax,%r14d++	xorl	%ebx,%r15d+	rorl	$6,%r13d+	movl	%ebx,%r11d++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%r11d+	addl	%r12d,%edx+	addl	%r12d,%r11d+	addl	%r14d,%r11d+	movl	36(%rsi),%r12d+	movl	%edx,%r13d+	movl	%r11d,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%r8d,%edi++	xorl	%edx,%r13d+	rorl	$9,%r14d+	xorl	%r9d,%edi++	movl	%r12d,36(%rsp)+	xorl	%r11d,%r14d+	andl	%edx,%edi++	rorl	$5,%r13d+	addl	%r10d,%r12d+	xorl	%r9d,%edi++	rorl	$11,%r14d+	xorl	%edx,%r13d+	addl	%edi,%r12d++	movl	%r11d,%edi+	addl	36(%rbp),%r12d+	xorl	%r11d,%r14d++	xorl	%eax,%edi+	rorl	$6,%r13d+	movl	%eax,%r10d++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%r10d+	addl	%r12d,%ecx+	addl	%r12d,%r10d+	addl	%r14d,%r10d+	movl	40(%rsi),%r12d+	movl	%ecx,%r13d+	movl	%r10d,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%edx,%r15d++	xorl	%ecx,%r13d+	rorl	$9,%r14d+	xorl	%r8d,%r15d++	movl	%r12d,40(%rsp)+	xorl	%r10d,%r14d+	andl	%ecx,%r15d++	rorl	$5,%r13d+	addl	%r9d,%r12d+	xorl	%r8d,%r15d++	rorl	$11,%r14d+	xorl	%ecx,%r13d+	addl	%r15d,%r12d++	movl	%r10d,%r15d+	addl	40(%rbp),%r12d+	xorl	%r10d,%r14d++	xorl	%r11d,%r15d+	rorl	$6,%r13d+	movl	%r11d,%r9d++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%r9d+	addl	%r12d,%ebx+	addl	%r12d,%r9d+	addl	%r14d,%r9d+	movl	44(%rsi),%r12d+	movl	%ebx,%r13d+	movl	%r9d,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%ecx,%edi++	xorl	%ebx,%r13d+	rorl	$9,%r14d+	xorl	%edx,%edi++	movl	%r12d,44(%rsp)+	xorl	%r9d,%r14d+	andl	%ebx,%edi++	rorl	$5,%r13d+	addl	%r8d,%r12d+	xorl	%edx,%edi++	rorl	$11,%r14d+	xorl	%ebx,%r13d+	addl	%edi,%r12d++	movl	%r9d,%edi+	addl	44(%rbp),%r12d+	xorl	%r9d,%r14d++	xorl	%r10d,%edi+	rorl	$6,%r13d+	movl	%r10d,%r8d++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%r8d+	addl	%r12d,%eax+	addl	%r12d,%r8d+	addl	%r14d,%r8d+	movl	48(%rsi),%r12d+	movl	%eax,%r13d+	movl	%r8d,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%ebx,%r15d++	xorl	%eax,%r13d+	rorl	$9,%r14d+	xorl	%ecx,%r15d++	movl	%r12d,48(%rsp)+	xorl	%r8d,%r14d+	andl	%eax,%r15d++	rorl	$5,%r13d+	addl	%edx,%r12d+	xorl	%ecx,%r15d++	rorl	$11,%r14d+	xorl	%eax,%r13d+	addl	%r15d,%r12d++	movl	%r8d,%r15d+	addl	48(%rbp),%r12d+	xorl	%r8d,%r14d++	xorl	%r9d,%r15d+	rorl	$6,%r13d+	movl	%r9d,%edx++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%edx+	addl	%r12d,%r11d+	addl	%r12d,%edx+	addl	%r14d,%edx+	movl	52(%rsi),%r12d+	movl	%r11d,%r13d+	movl	%edx,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%eax,%edi++	xorl	%r11d,%r13d+	rorl	$9,%r14d+	xorl	%ebx,%edi++	movl	%r12d,52(%rsp)+	xorl	%edx,%r14d+	andl	%r11d,%edi++	rorl	$5,%r13d+	addl	%ecx,%r12d+	xorl	%ebx,%edi++	rorl	$11,%r14d+	xorl	%r11d,%r13d+	addl	%edi,%r12d++	movl	%edx,%edi+	addl	52(%rbp),%r12d+	xorl	%edx,%r14d++	xorl	%r8d,%edi+	rorl	$6,%r13d+	movl	%r8d,%ecx++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%ecx+	addl	%r12d,%r10d+	addl	%r12d,%ecx+	addl	%r14d,%ecx+	movl	56(%rsi),%r12d+	movl	%r10d,%r13d+	movl	%ecx,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%r11d,%r15d++	xorl	%r10d,%r13d+	rorl	$9,%r14d+	xorl	%eax,%r15d++	movl	%r12d,56(%rsp)+	xorl	%ecx,%r14d+	andl	%r10d,%r15d++	rorl	$5,%r13d+	addl	%ebx,%r12d+	xorl	%eax,%r15d++	rorl	$11,%r14d+	xorl	%r10d,%r13d+	addl	%r15d,%r12d++	movl	%ecx,%r15d+	addl	56(%rbp),%r12d+	xorl	%ecx,%r14d++	xorl	%edx,%r15d+	rorl	$6,%r13d+	movl	%edx,%ebx++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%ebx+	addl	%r12d,%r9d+	addl	%r12d,%ebx+	addl	%r14d,%ebx+	movl	60(%rsi),%r12d+	movl	%r9d,%r13d+	movl	%ebx,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%r10d,%edi++	xorl	%r9d,%r13d+	rorl	$9,%r14d+	xorl	%r11d,%edi++	movl	%r12d,60(%rsp)+	xorl	%ebx,%r14d+	andl	%r9d,%edi++	rorl	$5,%r13d+	addl	%eax,%r12d+	xorl	%r11d,%edi++	rorl	$11,%r14d+	xorl	%r9d,%r13d+	addl	%edi,%r12d++	movl	%ebx,%edi+	addl	60(%rbp),%r12d+	xorl	%ebx,%r14d++	xorl	%ecx,%edi+	rorl	$6,%r13d+	movl	%ecx,%eax++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%eax+	addl	%r12d,%r8d+	addl	%r12d,%eax+	jmp	.Lrounds_16_xx+.align	16+.Lrounds_16_xx:+	movl	4(%rsp),%r13d+	movl	56(%rsp),%r15d++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%eax+	movl	%r15d,%r14d+	rorl	$2,%r15d++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%r15d+	shrl	$10,%r14d++	rorl	$17,%r15d+	xorl	%r13d,%r12d+	xorl	%r14d,%r15d+	addl	36(%rsp),%r12d++	addl	0(%rsp),%r12d+	movl	%r8d,%r13d+	addl	%r15d,%r12d+	movl	%eax,%r14d+	rorl	$14,%r13d+	movl	%r9d,%r15d++	xorl	%r8d,%r13d+	rorl	$9,%r14d+	xorl	%r10d,%r15d++	movl	%r12d,0(%rsp)+	xorl	%eax,%r14d+	andl	%r8d,%r15d++	rorl	$5,%r13d+	addl	%r11d,%r12d+	xorl	%r10d,%r15d++	rorl	$11,%r14d+	xorl	%r8d,%r13d+	addl	%r15d,%r12d++	movl	%eax,%r15d+	addl	64(%rbp),%r12d+	xorl	%eax,%r14d++	xorl	%ebx,%r15d+	rorl	$6,%r13d+	movl	%ebx,%r11d++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%r11d+	addl	%r12d,%edx+	addl	%r12d,%r11d+	movl	8(%rsp),%r13d+	movl	60(%rsp),%edi++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%r11d+	movl	%edi,%r14d+	rorl	$2,%edi++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%edi+	shrl	$10,%r14d++	rorl	$17,%edi+	xorl	%r13d,%r12d+	xorl	%r14d,%edi+	addl	40(%rsp),%r12d++	addl	4(%rsp),%r12d+	movl	%edx,%r13d+	addl	%edi,%r12d+	movl	%r11d,%r14d+	rorl	$14,%r13d+	movl	%r8d,%edi++	xorl	%edx,%r13d+	rorl	$9,%r14d+	xorl	%r9d,%edi++	movl	%r12d,4(%rsp)+	xorl	%r11d,%r14d+	andl	%edx,%edi++	rorl	$5,%r13d+	addl	%r10d,%r12d+	xorl	%r9d,%edi++	rorl	$11,%r14d+	xorl	%edx,%r13d+	addl	%edi,%r12d++	movl	%r11d,%edi+	addl	68(%rbp),%r12d+	xorl	%r11d,%r14d++	xorl	%eax,%edi+	rorl	$6,%r13d+	movl	%eax,%r10d++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%r10d+	addl	%r12d,%ecx+	addl	%r12d,%r10d+	movl	12(%rsp),%r13d+	movl	0(%rsp),%r15d++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%r10d+	movl	%r15d,%r14d+	rorl	$2,%r15d++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%r15d+	shrl	$10,%r14d++	rorl	$17,%r15d+	xorl	%r13d,%r12d+	xorl	%r14d,%r15d+	addl	44(%rsp),%r12d++	addl	8(%rsp),%r12d+	movl	%ecx,%r13d+	addl	%r15d,%r12d+	movl	%r10d,%r14d+	rorl	$14,%r13d+	movl	%edx,%r15d++	xorl	%ecx,%r13d+	rorl	$9,%r14d+	xorl	%r8d,%r15d++	movl	%r12d,8(%rsp)+	xorl	%r10d,%r14d+	andl	%ecx,%r15d++	rorl	$5,%r13d+	addl	%r9d,%r12d+	xorl	%r8d,%r15d++	rorl	$11,%r14d+	xorl	%ecx,%r13d+	addl	%r15d,%r12d++	movl	%r10d,%r15d+	addl	72(%rbp),%r12d+	xorl	%r10d,%r14d++	xorl	%r11d,%r15d+	rorl	$6,%r13d+	movl	%r11d,%r9d++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%r9d+	addl	%r12d,%ebx+	addl	%r12d,%r9d+	movl	16(%rsp),%r13d+	movl	4(%rsp),%edi++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%r9d+	movl	%edi,%r14d+	rorl	$2,%edi++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%edi+	shrl	$10,%r14d++	rorl	$17,%edi+	xorl	%r13d,%r12d+	xorl	%r14d,%edi+	addl	48(%rsp),%r12d++	addl	12(%rsp),%r12d+	movl	%ebx,%r13d+	addl	%edi,%r12d+	movl	%r9d,%r14d+	rorl	$14,%r13d+	movl	%ecx,%edi++	xorl	%ebx,%r13d+	rorl	$9,%r14d+	xorl	%edx,%edi++	movl	%r12d,12(%rsp)+	xorl	%r9d,%r14d+	andl	%ebx,%edi++	rorl	$5,%r13d+	addl	%r8d,%r12d+	xorl	%edx,%edi++	rorl	$11,%r14d+	xorl	%ebx,%r13d+	addl	%edi,%r12d++	movl	%r9d,%edi+	addl	76(%rbp),%r12d+	xorl	%r9d,%r14d++	xorl	%r10d,%edi+	rorl	$6,%r13d+	movl	%r10d,%r8d++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%r8d+	addl	%r12d,%eax+	addl	%r12d,%r8d+	movl	20(%rsp),%r13d+	movl	8(%rsp),%r15d++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%r8d+	movl	%r15d,%r14d+	rorl	$2,%r15d++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%r15d+	shrl	$10,%r14d++	rorl	$17,%r15d+	xorl	%r13d,%r12d+	xorl	%r14d,%r15d+	addl	52(%rsp),%r12d++	addl	16(%rsp),%r12d+	movl	%eax,%r13d+	addl	%r15d,%r12d+	movl	%r8d,%r14d+	rorl	$14,%r13d+	movl	%ebx,%r15d++	xorl	%eax,%r13d+	rorl	$9,%r14d+	xorl	%ecx,%r15d++	movl	%r12d,16(%rsp)+	xorl	%r8d,%r14d+	andl	%eax,%r15d++	rorl	$5,%r13d+	addl	%edx,%r12d+	xorl	%ecx,%r15d++	rorl	$11,%r14d+	xorl	%eax,%r13d+	addl	%r15d,%r12d++	movl	%r8d,%r15d+	addl	80(%rbp),%r12d+	xorl	%r8d,%r14d++	xorl	%r9d,%r15d+	rorl	$6,%r13d+	movl	%r9d,%edx++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%edx+	addl	%r12d,%r11d+	addl	%r12d,%edx+	movl	24(%rsp),%r13d+	movl	12(%rsp),%edi++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%edx+	movl	%edi,%r14d+	rorl	$2,%edi++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%edi+	shrl	$10,%r14d++	rorl	$17,%edi+	xorl	%r13d,%r12d+	xorl	%r14d,%edi+	addl	56(%rsp),%r12d++	addl	20(%rsp),%r12d+	movl	%r11d,%r13d+	addl	%edi,%r12d+	movl	%edx,%r14d+	rorl	$14,%r13d+	movl	%eax,%edi++	xorl	%r11d,%r13d+	rorl	$9,%r14d+	xorl	%ebx,%edi++	movl	%r12d,20(%rsp)+	xorl	%edx,%r14d+	andl	%r11d,%edi++	rorl	$5,%r13d+	addl	%ecx,%r12d+	xorl	%ebx,%edi++	rorl	$11,%r14d+	xorl	%r11d,%r13d+	addl	%edi,%r12d++	movl	%edx,%edi+	addl	84(%rbp),%r12d+	xorl	%edx,%r14d++	xorl	%r8d,%edi+	rorl	$6,%r13d+	movl	%r8d,%ecx++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%ecx+	addl	%r12d,%r10d+	addl	%r12d,%ecx+	movl	28(%rsp),%r13d+	movl	16(%rsp),%r15d++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%ecx+	movl	%r15d,%r14d+	rorl	$2,%r15d++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%r15d+	shrl	$10,%r14d++	rorl	$17,%r15d+	xorl	%r13d,%r12d+	xorl	%r14d,%r15d+	addl	60(%rsp),%r12d++	addl	24(%rsp),%r12d+	movl	%r10d,%r13d+	addl	%r15d,%r12d+	movl	%ecx,%r14d+	rorl	$14,%r13d+	movl	%r11d,%r15d++	xorl	%r10d,%r13d+	rorl	$9,%r14d+	xorl	%eax,%r15d++	movl	%r12d,24(%rsp)+	xorl	%ecx,%r14d+	andl	%r10d,%r15d++	rorl	$5,%r13d+	addl	%ebx,%r12d+	xorl	%eax,%r15d++	rorl	$11,%r14d+	xorl	%r10d,%r13d+	addl	%r15d,%r12d++	movl	%ecx,%r15d+	addl	88(%rbp),%r12d+	xorl	%ecx,%r14d++	xorl	%edx,%r15d+	rorl	$6,%r13d+	movl	%edx,%ebx++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%ebx+	addl	%r12d,%r9d+	addl	%r12d,%ebx+	movl	32(%rsp),%r13d+	movl	20(%rsp),%edi++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%ebx+	movl	%edi,%r14d+	rorl	$2,%edi++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%edi+	shrl	$10,%r14d++	rorl	$17,%edi+	xorl	%r13d,%r12d+	xorl	%r14d,%edi+	addl	0(%rsp),%r12d++	addl	28(%rsp),%r12d+	movl	%r9d,%r13d+	addl	%edi,%r12d+	movl	%ebx,%r14d+	rorl	$14,%r13d+	movl	%r10d,%edi++	xorl	%r9d,%r13d+	rorl	$9,%r14d+	xorl	%r11d,%edi++	movl	%r12d,28(%rsp)+	xorl	%ebx,%r14d+	andl	%r9d,%edi++	rorl	$5,%r13d+	addl	%eax,%r12d+	xorl	%r11d,%edi++	rorl	$11,%r14d+	xorl	%r9d,%r13d+	addl	%edi,%r12d++	movl	%ebx,%edi+	addl	92(%rbp),%r12d+	xorl	%ebx,%r14d++	xorl	%ecx,%edi+	rorl	$6,%r13d+	movl	%ecx,%eax++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%eax+	addl	%r12d,%r8d+	addl	%r12d,%eax+	movl	36(%rsp),%r13d+	movl	24(%rsp),%r15d++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%eax+	movl	%r15d,%r14d+	rorl	$2,%r15d++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%r15d+	shrl	$10,%r14d++	rorl	$17,%r15d+	xorl	%r13d,%r12d+	xorl	%r14d,%r15d+	addl	4(%rsp),%r12d++	addl	32(%rsp),%r12d+	movl	%r8d,%r13d+	addl	%r15d,%r12d+	movl	%eax,%r14d+	rorl	$14,%r13d+	movl	%r9d,%r15d++	xorl	%r8d,%r13d+	rorl	$9,%r14d+	xorl	%r10d,%r15d++	movl	%r12d,32(%rsp)+	xorl	%eax,%r14d+	andl	%r8d,%r15d++	rorl	$5,%r13d+	addl	%r11d,%r12d+	xorl	%r10d,%r15d++	rorl	$11,%r14d+	xorl	%r8d,%r13d+	addl	%r15d,%r12d++	movl	%eax,%r15d+	addl	96(%rbp),%r12d+	xorl	%eax,%r14d++	xorl	%ebx,%r15d+	rorl	$6,%r13d+	movl	%ebx,%r11d++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%r11d+	addl	%r12d,%edx+	addl	%r12d,%r11d+	movl	40(%rsp),%r13d+	movl	28(%rsp),%edi++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%r11d+	movl	%edi,%r14d+	rorl	$2,%edi++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%edi+	shrl	$10,%r14d++	rorl	$17,%edi+	xorl	%r13d,%r12d+	xorl	%r14d,%edi+	addl	8(%rsp),%r12d++	addl	36(%rsp),%r12d+	movl	%edx,%r13d+	addl	%edi,%r12d+	movl	%r11d,%r14d+	rorl	$14,%r13d+	movl	%r8d,%edi++	xorl	%edx,%r13d+	rorl	$9,%r14d+	xorl	%r9d,%edi++	movl	%r12d,36(%rsp)+	xorl	%r11d,%r14d+	andl	%edx,%edi++	rorl	$5,%r13d+	addl	%r10d,%r12d+	xorl	%r9d,%edi++	rorl	$11,%r14d+	xorl	%edx,%r13d+	addl	%edi,%r12d++	movl	%r11d,%edi+	addl	100(%rbp),%r12d+	xorl	%r11d,%r14d++	xorl	%eax,%edi+	rorl	$6,%r13d+	movl	%eax,%r10d++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%r10d+	addl	%r12d,%ecx+	addl	%r12d,%r10d+	movl	44(%rsp),%r13d+	movl	32(%rsp),%r15d++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%r10d+	movl	%r15d,%r14d+	rorl	$2,%r15d++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%r15d+	shrl	$10,%r14d++	rorl	$17,%r15d+	xorl	%r13d,%r12d+	xorl	%r14d,%r15d+	addl	12(%rsp),%r12d++	addl	40(%rsp),%r12d+	movl	%ecx,%r13d+	addl	%r15d,%r12d+	movl	%r10d,%r14d+	rorl	$14,%r13d+	movl	%edx,%r15d++	xorl	%ecx,%r13d+	rorl	$9,%r14d+	xorl	%r8d,%r15d++	movl	%r12d,40(%rsp)+	xorl	%r10d,%r14d+	andl	%ecx,%r15d++	rorl	$5,%r13d+	addl	%r9d,%r12d+	xorl	%r8d,%r15d++	rorl	$11,%r14d+	xorl	%ecx,%r13d+	addl	%r15d,%r12d++	movl	%r10d,%r15d+	addl	104(%rbp),%r12d+	xorl	%r10d,%r14d++	xorl	%r11d,%r15d+	rorl	$6,%r13d+	movl	%r11d,%r9d++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%r9d+	addl	%r12d,%ebx+	addl	%r12d,%r9d+	movl	48(%rsp),%r13d+	movl	36(%rsp),%edi++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%r9d+	movl	%edi,%r14d+	rorl	$2,%edi++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%edi+	shrl	$10,%r14d++	rorl	$17,%edi+	xorl	%r13d,%r12d+	xorl	%r14d,%edi+	addl	16(%rsp),%r12d++	addl	44(%rsp),%r12d+	movl	%ebx,%r13d+	addl	%edi,%r12d+	movl	%r9d,%r14d+	rorl	$14,%r13d+	movl	%ecx,%edi++	xorl	%ebx,%r13d+	rorl	$9,%r14d+	xorl	%edx,%edi++	movl	%r12d,44(%rsp)+	xorl	%r9d,%r14d+	andl	%ebx,%edi++	rorl	$5,%r13d+	addl	%r8d,%r12d+	xorl	%edx,%edi++	rorl	$11,%r14d+	xorl	%ebx,%r13d+	addl	%edi,%r12d++	movl	%r9d,%edi+	addl	108(%rbp),%r12d+	xorl	%r9d,%r14d++	xorl	%r10d,%edi+	rorl	$6,%r13d+	movl	%r10d,%r8d++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%r8d+	addl	%r12d,%eax+	addl	%r12d,%r8d+	movl	52(%rsp),%r13d+	movl	40(%rsp),%r15d++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%r8d+	movl	%r15d,%r14d+	rorl	$2,%r15d++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%r15d+	shrl	$10,%r14d++	rorl	$17,%r15d+	xorl	%r13d,%r12d+	xorl	%r14d,%r15d+	addl	20(%rsp),%r12d++	addl	48(%rsp),%r12d+	movl	%eax,%r13d+	addl	%r15d,%r12d+	movl	%r8d,%r14d+	rorl	$14,%r13d+	movl	%ebx,%r15d++	xorl	%eax,%r13d+	rorl	$9,%r14d+	xorl	%ecx,%r15d++	movl	%r12d,48(%rsp)+	xorl	%r8d,%r14d+	andl	%eax,%r15d++	rorl	$5,%r13d+	addl	%edx,%r12d+	xorl	%ecx,%r15d++	rorl	$11,%r14d+	xorl	%eax,%r13d+	addl	%r15d,%r12d++	movl	%r8d,%r15d+	addl	112(%rbp),%r12d+	xorl	%r8d,%r14d++	xorl	%r9d,%r15d+	rorl	$6,%r13d+	movl	%r9d,%edx++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%edx+	addl	%r12d,%r11d+	addl	%r12d,%edx+	movl	56(%rsp),%r13d+	movl	44(%rsp),%edi++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%edx+	movl	%edi,%r14d+	rorl	$2,%edi++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%edi+	shrl	$10,%r14d++	rorl	$17,%edi+	xorl	%r13d,%r12d+	xorl	%r14d,%edi+	addl	24(%rsp),%r12d++	addl	52(%rsp),%r12d+	movl	%r11d,%r13d+	addl	%edi,%r12d+	movl	%edx,%r14d+	rorl	$14,%r13d+	movl	%eax,%edi++	xorl	%r11d,%r13d+	rorl	$9,%r14d+	xorl	%ebx,%edi++	movl	%r12d,52(%rsp)+	xorl	%edx,%r14d+	andl	%r11d,%edi++	rorl	$5,%r13d+	addl	%ecx,%r12d+	xorl	%ebx,%edi++	rorl	$11,%r14d+	xorl	%r11d,%r13d+	addl	%edi,%r12d++	movl	%edx,%edi+	addl	116(%rbp),%r12d+	xorl	%edx,%r14d++	xorl	%r8d,%edi+	rorl	$6,%r13d+	movl	%r8d,%ecx++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%ecx+	addl	%r12d,%r10d+	addl	%r12d,%ecx+	movl	60(%rsp),%r13d+	movl	48(%rsp),%r15d++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%ecx+	movl	%r15d,%r14d+	rorl	$2,%r15d++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%r15d+	shrl	$10,%r14d++	rorl	$17,%r15d+	xorl	%r13d,%r12d+	xorl	%r14d,%r15d+	addl	28(%rsp),%r12d++	addl	56(%rsp),%r12d+	movl	%r10d,%r13d+	addl	%r15d,%r12d+	movl	%ecx,%r14d+	rorl	$14,%r13d+	movl	%r11d,%r15d++	xorl	%r10d,%r13d+	rorl	$9,%r14d+	xorl	%eax,%r15d++	movl	%r12d,56(%rsp)+	xorl	%ecx,%r14d+	andl	%r10d,%r15d++	rorl	$5,%r13d+	addl	%ebx,%r12d+	xorl	%eax,%r15d++	rorl	$11,%r14d+	xorl	%r10d,%r13d+	addl	%r15d,%r12d++	movl	%ecx,%r15d+	addl	120(%rbp),%r12d+	xorl	%ecx,%r14d++	xorl	%edx,%r15d+	rorl	$6,%r13d+	movl	%edx,%ebx++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%ebx+	addl	%r12d,%r9d+	addl	%r12d,%ebx+	movl	0(%rsp),%r13d+	movl	52(%rsp),%edi++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%ebx+	movl	%edi,%r14d+	rorl	$2,%edi++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%edi+	shrl	$10,%r14d++	rorl	$17,%edi+	xorl	%r13d,%r12d+	xorl	%r14d,%edi+	addl	32(%rsp),%r12d++	addl	60(%rsp),%r12d+	movl	%r9d,%r13d+	addl	%edi,%r12d+	movl	%ebx,%r14d+	rorl	$14,%r13d+	movl	%r10d,%edi++	xorl	%r9d,%r13d+	rorl	$9,%r14d+	xorl	%r11d,%edi++	movl	%r12d,60(%rsp)+	xorl	%ebx,%r14d+	andl	%r9d,%edi++	rorl	$5,%r13d+	addl	%eax,%r12d+	xorl	%r11d,%edi++	rorl	$11,%r14d+	xorl	%r9d,%r13d+	addl	%edi,%r12d++	movl	%ebx,%edi+	addl	124(%rbp),%r12d+	xorl	%ebx,%r14d++	xorl	%ecx,%edi+	rorl	$6,%r13d+	movl	%ecx,%eax++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%eax+	addl	%r12d,%r8d+	addl	%r12d,%eax+	leaq	64(%rbp),%rbp+	cmpb	$0x19,3(%rbp)+	jnz	.Lrounds_16_xx++	movq	64+0(%rsp),%rdi+	addl	%r14d,%eax+	leaq	64(%rsi),%rsi++	addl	0(%rdi),%eax+	addl	4(%rdi),%ebx+	addl	8(%rdi),%ecx+	addl	12(%rdi),%edx+	addl	16(%rdi),%r8d+	addl	20(%rdi),%r9d+	addl	24(%rdi),%r10d+	addl	28(%rdi),%r11d++	cmpq	64+16(%rsp),%rsi++	movl	%eax,0(%rdi)+	movl	%ebx,4(%rdi)+	movl	%ecx,8(%rdi)+	movl	%edx,12(%rdi)+	movl	%r8d,16(%rdi)+	movl	%r9d,20(%rdi)+	movl	%r10d,24(%rdi)+	movl	%r11d,28(%rdi)+	jb	.Lloop++	leaq	64+24+48(%rsp),%r11+.cfi_def_cfa	%r11,8+	movq	64+24(%rsp),%r15+.cfi_restore	%r15+	movq	-40(%r11),%r14+.cfi_restore	%r14+	movq	-32(%r11),%r13+.cfi_restore	%r13+	movq	-24(%r11),%r12+.cfi_restore	%r12+	movq	-16(%r11),%rbp+.cfi_restore	%rbp+	movq	-8(%r11),%rbx+.cfi_restore	%rbx++	leaq	(%r11),%rsp+	.byte	0xf3,0xc3+.cfi_endproc	+.size	blst_sha256_block_data_order,.-blst_sha256_block_data_order++.align	64+.type	K256,@object+K256:+.long	0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5+.long	0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5+.long	0xd807aa98,0x12835b01,0x243185be,0x550c7dc3+.long	0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174+.long	0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc+.long	0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da+.long	0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7+.long	0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967+.long	0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13+.long	0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85+.long	0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3+.long	0xd192e819,0xd6990624,0xf40e3585,0x106aa070+.long	0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5+.long	0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3+.long	0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208+.long	0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2++.byte	83,72,65,50,53,54,32,98,108,111,99,107,32,116,114,97,110,115,102,111,114,109,32,102,111,114,32,120,56,54,95,54,52,44,32,67,82,89,80,84,79,71,65,77,83,32,98,121,32,64,100,111,116,45,97,115,109,0+.globl	blst_sha256_emit+.hidden	blst_sha256_emit+.type	blst_sha256_emit,@function+.align	16+blst_sha256_emit:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	bswapq	%r8+	movq	24(%rsi),%r11+	bswapq	%r9+	movl	%r8d,4(%rdi)+	bswapq	%r10+	movl	%r9d,12(%rdi)+	bswapq	%r11+	movl	%r10d,20(%rdi)+	shrq	$32,%r8+	movl	%r11d,28(%rdi)+	shrq	$32,%r9+	movl	%r8d,0(%rdi)+	shrq	$32,%r10+	movl	%r9d,8(%rdi)+	shrq	$32,%r11+	movl	%r10d,16(%rdi)+	movl	%r11d,24(%rdi)+	.byte	0xf3,0xc3+.cfi_endproc+.size	blst_sha256_emit,.-blst_sha256_emit++.globl	blst_sha256_bcopy+.hidden	blst_sha256_bcopy+.type	blst_sha256_bcopy,@function+.align	16+blst_sha256_bcopy:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	subq	%rsi,%rdi+.Loop_bcopy:+	movzbl	(%rsi),%eax+	leaq	1(%rsi),%rsi+	movb	%al,-1(%rdi,%rsi,1)+	decq	%rdx+	jnz	.Loop_bcopy+	.byte	0xf3,0xc3+.cfi_endproc+.size	blst_sha256_bcopy,.-blst_sha256_bcopy++.globl	blst_sha256_hcopy+.hidden	blst_sha256_hcopy+.type	blst_sha256_hcopy,@function+.align	16+blst_sha256_hcopy:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	.byte	0xf3,0xc3+.cfi_endproc+.size	blst_sha256_hcopy,.-blst_sha256_hcopy++.section	.note.GNU-stack,"",@progbits+.section	.note.gnu.property,"a",@note+	.long	4,2f-1f,5+	.byte	0x47,0x4E,0x55,0+1:	.long	0xc0000002,4,3+.align	8+2:
+ c-source/build/elf/sha256-x86_64.s view
@@ -0,0 +1,1446 @@+.text	++.align	64+.type	K256,@object+K256:+.long	0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5+.long	0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5+.long	0xd807aa98,0x12835b01,0x243185be,0x550c7dc3+.long	0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174+.long	0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc+.long	0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da+.long	0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7+.long	0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967+.long	0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13+.long	0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85+.long	0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3+.long	0xd192e819,0xd6990624,0xf40e3585,0x106aa070+.long	0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5+.long	0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3+.long	0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208+.long	0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2++.long	0x00010203,0x04050607,0x08090a0b,0x0c0d0e0f+.long	0x03020100,0x0b0a0908,0xffffffff,0xffffffff+.long	0xffffffff,0xffffffff,0x03020100,0x0b0a0908+.byte	83,72,65,50,53,54,32,98,108,111,99,107,32,116,114,97,110,115,102,111,114,109,32,102,111,114,32,120,56,54,95,54,52,44,32,67,82,89,80,84,79,71,65,77,83,32,98,121,32,64,100,111,116,45,97,115,109,0+.globl	blst_sha256_block_data_order_shaext+.hidden	blst_sha256_block_data_order_shaext+.type	blst_sha256_block_data_order_shaext,@function+.align	64+blst_sha256_block_data_order_shaext:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	leaq	K256+128(%rip),%rcx+	movdqu	(%rdi),%xmm1+	movdqu	16(%rdi),%xmm2+	movdqa	256-128(%rcx),%xmm7++	pshufd	$0x1b,%xmm1,%xmm0+	pshufd	$0xb1,%xmm1,%xmm1+	pshufd	$0x1b,%xmm2,%xmm2+	movdqa	%xmm7,%xmm8+.byte	102,15,58,15,202,8+	punpcklqdq	%xmm0,%xmm2+	jmp	.Loop_shaext++.align	16+.Loop_shaext:+	movdqu	(%rsi),%xmm3+	movdqu	16(%rsi),%xmm4+	movdqu	32(%rsi),%xmm5+.byte	102,15,56,0,223+	movdqu	48(%rsi),%xmm6++	movdqa	0-128(%rcx),%xmm0+	paddd	%xmm3,%xmm0+.byte	102,15,56,0,231+	movdqa	%xmm2,%xmm10+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	nop+	movdqa	%xmm1,%xmm9+.byte	15,56,203,202++	movdqa	16-128(%rcx),%xmm0+	paddd	%xmm4,%xmm0+.byte	102,15,56,0,239+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	leaq	64(%rsi),%rsi+.byte	15,56,204,220+.byte	15,56,203,202++	movdqa	32-128(%rcx),%xmm0+	paddd	%xmm5,%xmm0+.byte	102,15,56,0,247+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm6,%xmm7+.byte	102,15,58,15,253,4+	nop+	paddd	%xmm7,%xmm3+.byte	15,56,204,229+.byte	15,56,203,202++	movdqa	48-128(%rcx),%xmm0+	paddd	%xmm6,%xmm0+.byte	15,56,205,222+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm3,%xmm7+.byte	102,15,58,15,254,4+	nop+	paddd	%xmm7,%xmm4+.byte	15,56,204,238+.byte	15,56,203,202+	movdqa	64-128(%rcx),%xmm0+	paddd	%xmm3,%xmm0+.byte	15,56,205,227+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm4,%xmm7+.byte	102,15,58,15,251,4+	nop+	paddd	%xmm7,%xmm5+.byte	15,56,204,243+.byte	15,56,203,202+	movdqa	80-128(%rcx),%xmm0+	paddd	%xmm4,%xmm0+.byte	15,56,205,236+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm5,%xmm7+.byte	102,15,58,15,252,4+	nop+	paddd	%xmm7,%xmm6+.byte	15,56,204,220+.byte	15,56,203,202+	movdqa	96-128(%rcx),%xmm0+	paddd	%xmm5,%xmm0+.byte	15,56,205,245+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm6,%xmm7+.byte	102,15,58,15,253,4+	nop+	paddd	%xmm7,%xmm3+.byte	15,56,204,229+.byte	15,56,203,202+	movdqa	112-128(%rcx),%xmm0+	paddd	%xmm6,%xmm0+.byte	15,56,205,222+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm3,%xmm7+.byte	102,15,58,15,254,4+	nop+	paddd	%xmm7,%xmm4+.byte	15,56,204,238+.byte	15,56,203,202+	movdqa	128-128(%rcx),%xmm0+	paddd	%xmm3,%xmm0+.byte	15,56,205,227+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm4,%xmm7+.byte	102,15,58,15,251,4+	nop+	paddd	%xmm7,%xmm5+.byte	15,56,204,243+.byte	15,56,203,202+	movdqa	144-128(%rcx),%xmm0+	paddd	%xmm4,%xmm0+.byte	15,56,205,236+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm5,%xmm7+.byte	102,15,58,15,252,4+	nop+	paddd	%xmm7,%xmm6+.byte	15,56,204,220+.byte	15,56,203,202+	movdqa	160-128(%rcx),%xmm0+	paddd	%xmm5,%xmm0+.byte	15,56,205,245+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm6,%xmm7+.byte	102,15,58,15,253,4+	nop+	paddd	%xmm7,%xmm3+.byte	15,56,204,229+.byte	15,56,203,202+	movdqa	176-128(%rcx),%xmm0+	paddd	%xmm6,%xmm0+.byte	15,56,205,222+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm3,%xmm7+.byte	102,15,58,15,254,4+	nop+	paddd	%xmm7,%xmm4+.byte	15,56,204,238+.byte	15,56,203,202+	movdqa	192-128(%rcx),%xmm0+	paddd	%xmm3,%xmm0+.byte	15,56,205,227+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm4,%xmm7+.byte	102,15,58,15,251,4+	nop+	paddd	%xmm7,%xmm5+.byte	15,56,204,243+.byte	15,56,203,202+	movdqa	208-128(%rcx),%xmm0+	paddd	%xmm4,%xmm0+.byte	15,56,205,236+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm5,%xmm7+.byte	102,15,58,15,252,4+.byte	15,56,203,202+	paddd	%xmm7,%xmm6++	movdqa	224-128(%rcx),%xmm0+	paddd	%xmm5,%xmm0+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+.byte	15,56,205,245+	movdqa	%xmm8,%xmm7+.byte	15,56,203,202++	movdqa	240-128(%rcx),%xmm0+	paddd	%xmm6,%xmm0+	nop+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	decq	%rdx+	nop+.byte	15,56,203,202++	paddd	%xmm10,%xmm2+	paddd	%xmm9,%xmm1+	jnz	.Loop_shaext++	pshufd	$0xb1,%xmm2,%xmm2+	pshufd	$0x1b,%xmm1,%xmm7+	pshufd	$0xb1,%xmm1,%xmm1+	punpckhqdq	%xmm2,%xmm1+.byte	102,15,58,15,215,8++	movdqu	%xmm1,(%rdi)+	movdqu	%xmm2,16(%rdi)+	.byte	0xf3,0xc3+.cfi_endproc	+.size	blst_sha256_block_data_order_shaext,.-blst_sha256_block_data_order_shaext+.globl	blst_sha256_block_data_order+.hidden	blst_sha256_block_data_order+.type	blst_sha256_block_data_order,@function+.align	64+blst_sha256_block_data_order:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	shlq	$4,%rdx+	subq	$40,%rsp+.cfi_adjust_cfa_offset	40+	leaq	(%rsi,%rdx,4),%rdx+	movq	%rdi,0(%rsp)++	movq	%rdx,16(%rsp)+	movq	%rsp,%rbp+.cfi_def_cfa_register	%rbp+++	leaq	-64(%rsp),%rsp+	movl	0(%rdi),%eax+	andq	$-64,%rsp+	movl	4(%rdi),%ebx+	movl	8(%rdi),%ecx+	movl	12(%rdi),%edx+	movl	16(%rdi),%r8d+	movl	20(%rdi),%r9d+	movl	24(%rdi),%r10d+	movl	28(%rdi),%r11d+++	jmp	.Lloop_ssse3+.align	16+.Lloop_ssse3:+	movdqa	K256+256(%rip),%xmm7+	movq	%rsi,8(%rbp)+	movdqu	0(%rsi),%xmm0+	movdqu	16(%rsi),%xmm1+	movdqu	32(%rsi),%xmm2+.byte	102,15,56,0,199+	movdqu	48(%rsi),%xmm3+	leaq	K256(%rip),%rsi+.byte	102,15,56,0,207+	movdqa	0(%rsi),%xmm4+	movdqa	16(%rsi),%xmm5+.byte	102,15,56,0,215+	paddd	%xmm0,%xmm4+	movdqa	32(%rsi),%xmm6+.byte	102,15,56,0,223+	movdqa	48(%rsi),%xmm7+	paddd	%xmm1,%xmm5+	paddd	%xmm2,%xmm6+	paddd	%xmm3,%xmm7+	movdqa	%xmm4,0(%rsp)+	movl	%eax,%r14d+	movdqa	%xmm5,16(%rsp)+	movl	%ebx,%edi+	movdqa	%xmm6,32(%rsp)+	xorl	%ecx,%edi+	movdqa	%xmm7,48(%rsp)+	movl	%r8d,%r13d+	jmp	.Lssse3_00_47++.align	16+.Lssse3_00_47:+	subq	$-64,%rsi+	rorl	$14,%r13d+	movdqa	%xmm1,%xmm4+	movl	%r14d,%eax+	movl	%r9d,%r12d+	movdqa	%xmm3,%xmm7+	rorl	$9,%r14d+	xorl	%r8d,%r13d+	xorl	%r10d,%r12d+	rorl	$5,%r13d+	xorl	%eax,%r14d+.byte	102,15,58,15,224,4+	andl	%r8d,%r12d+	xorl	%r8d,%r13d+.byte	102,15,58,15,250,4+	addl	0(%rsp),%r11d+	movl	%eax,%r15d+	xorl	%r10d,%r12d+	rorl	$11,%r14d+	movdqa	%xmm4,%xmm5+	xorl	%ebx,%r15d+	addl	%r12d,%r11d+	movdqa	%xmm4,%xmm6+	rorl	$6,%r13d+	andl	%r15d,%edi+	psrld	$3,%xmm4+	xorl	%eax,%r14d+	addl	%r13d,%r11d+	xorl	%ebx,%edi+	paddd	%xmm7,%xmm0+	rorl	$2,%r14d+	addl	%r11d,%edx+	psrld	$7,%xmm6+	addl	%edi,%r11d+	movl	%edx,%r13d+	pshufd	$250,%xmm3,%xmm7+	addl	%r11d,%r14d+	rorl	$14,%r13d+	pslld	$14,%xmm5+	movl	%r14d,%r11d+	movl	%r8d,%r12d+	pxor	%xmm6,%xmm4+	rorl	$9,%r14d+	xorl	%edx,%r13d+	xorl	%r9d,%r12d+	rorl	$5,%r13d+	psrld	$11,%xmm6+	xorl	%r11d,%r14d+	pxor	%xmm5,%xmm4+	andl	%edx,%r12d+	xorl	%edx,%r13d+	pslld	$11,%xmm5+	addl	4(%rsp),%r10d+	movl	%r11d,%edi+	pxor	%xmm6,%xmm4+	xorl	%r9d,%r12d+	rorl	$11,%r14d+	movdqa	%xmm7,%xmm6+	xorl	%eax,%edi+	addl	%r12d,%r10d+	pxor	%xmm5,%xmm4+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%r11d,%r14d+	psrld	$10,%xmm7+	addl	%r13d,%r10d+	xorl	%eax,%r15d+	paddd	%xmm4,%xmm0+	rorl	$2,%r14d+	addl	%r10d,%ecx+	psrlq	$17,%xmm6+	addl	%r15d,%r10d+	movl	%ecx,%r13d+	addl	%r10d,%r14d+	pxor	%xmm6,%xmm7+	rorl	$14,%r13d+	movl	%r14d,%r10d+	movl	%edx,%r12d+	rorl	$9,%r14d+	psrlq	$2,%xmm6+	xorl	%ecx,%r13d+	xorl	%r8d,%r12d+	pxor	%xmm6,%xmm7+	rorl	$5,%r13d+	xorl	%r10d,%r14d+	andl	%ecx,%r12d+	pshufd	$128,%xmm7,%xmm7+	xorl	%ecx,%r13d+	addl	8(%rsp),%r9d+	movl	%r10d,%r15d+	psrldq	$8,%xmm7+	xorl	%r8d,%r12d+	rorl	$11,%r14d+	xorl	%r11d,%r15d+	addl	%r12d,%r9d+	rorl	$6,%r13d+	paddd	%xmm7,%xmm0+	andl	%r15d,%edi+	xorl	%r10d,%r14d+	addl	%r13d,%r9d+	pshufd	$80,%xmm0,%xmm7+	xorl	%r11d,%edi+	rorl	$2,%r14d+	addl	%r9d,%ebx+	movdqa	%xmm7,%xmm6+	addl	%edi,%r9d+	movl	%ebx,%r13d+	psrld	$10,%xmm7+	addl	%r9d,%r14d+	rorl	$14,%r13d+	psrlq	$17,%xmm6+	movl	%r14d,%r9d+	movl	%ecx,%r12d+	pxor	%xmm6,%xmm7+	rorl	$9,%r14d+	xorl	%ebx,%r13d+	xorl	%edx,%r12d+	rorl	$5,%r13d+	xorl	%r9d,%r14d+	psrlq	$2,%xmm6+	andl	%ebx,%r12d+	xorl	%ebx,%r13d+	addl	12(%rsp),%r8d+	pxor	%xmm6,%xmm7+	movl	%r9d,%edi+	xorl	%edx,%r12d+	rorl	$11,%r14d+	pshufd	$8,%xmm7,%xmm7+	xorl	%r10d,%edi+	addl	%r12d,%r8d+	movdqa	0(%rsi),%xmm6+	rorl	$6,%r13d+	andl	%edi,%r15d+	pslldq	$8,%xmm7+	xorl	%r9d,%r14d+	addl	%r13d,%r8d+	xorl	%r10d,%r15d+	paddd	%xmm7,%xmm0+	rorl	$2,%r14d+	addl	%r8d,%eax+	addl	%r15d,%r8d+	paddd	%xmm0,%xmm6+	movl	%eax,%r13d+	addl	%r8d,%r14d+	movdqa	%xmm6,0(%rsp)+	rorl	$14,%r13d+	movdqa	%xmm2,%xmm4+	movl	%r14d,%r8d+	movl	%ebx,%r12d+	movdqa	%xmm0,%xmm7+	rorl	$9,%r14d+	xorl	%eax,%r13d+	xorl	%ecx,%r12d+	rorl	$5,%r13d+	xorl	%r8d,%r14d+.byte	102,15,58,15,225,4+	andl	%eax,%r12d+	xorl	%eax,%r13d+.byte	102,15,58,15,251,4+	addl	16(%rsp),%edx+	movl	%r8d,%r15d+	xorl	%ecx,%r12d+	rorl	$11,%r14d+	movdqa	%xmm4,%xmm5+	xorl	%r9d,%r15d+	addl	%r12d,%edx+	movdqa	%xmm4,%xmm6+	rorl	$6,%r13d+	andl	%r15d,%edi+	psrld	$3,%xmm4+	xorl	%r8d,%r14d+	addl	%r13d,%edx+	xorl	%r9d,%edi+	paddd	%xmm7,%xmm1+	rorl	$2,%r14d+	addl	%edx,%r11d+	psrld	$7,%xmm6+	addl	%edi,%edx+	movl	%r11d,%r13d+	pshufd	$250,%xmm0,%xmm7+	addl	%edx,%r14d+	rorl	$14,%r13d+	pslld	$14,%xmm5+	movl	%r14d,%edx+	movl	%eax,%r12d+	pxor	%xmm6,%xmm4+	rorl	$9,%r14d+	xorl	%r11d,%r13d+	xorl	%ebx,%r12d+	rorl	$5,%r13d+	psrld	$11,%xmm6+	xorl	%edx,%r14d+	pxor	%xmm5,%xmm4+	andl	%r11d,%r12d+	xorl	%r11d,%r13d+	pslld	$11,%xmm5+	addl	20(%rsp),%ecx+	movl	%edx,%edi+	pxor	%xmm6,%xmm4+	xorl	%ebx,%r12d+	rorl	$11,%r14d+	movdqa	%xmm7,%xmm6+	xorl	%r8d,%edi+	addl	%r12d,%ecx+	pxor	%xmm5,%xmm4+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%edx,%r14d+	psrld	$10,%xmm7+	addl	%r13d,%ecx+	xorl	%r8d,%r15d+	paddd	%xmm4,%xmm1+	rorl	$2,%r14d+	addl	%ecx,%r10d+	psrlq	$17,%xmm6+	addl	%r15d,%ecx+	movl	%r10d,%r13d+	addl	%ecx,%r14d+	pxor	%xmm6,%xmm7+	rorl	$14,%r13d+	movl	%r14d,%ecx+	movl	%r11d,%r12d+	rorl	$9,%r14d+	psrlq	$2,%xmm6+	xorl	%r10d,%r13d+	xorl	%eax,%r12d+	pxor	%xmm6,%xmm7+	rorl	$5,%r13d+	xorl	%ecx,%r14d+	andl	%r10d,%r12d+	pshufd	$128,%xmm7,%xmm7+	xorl	%r10d,%r13d+	addl	24(%rsp),%ebx+	movl	%ecx,%r15d+	psrldq	$8,%xmm7+	xorl	%eax,%r12d+	rorl	$11,%r14d+	xorl	%edx,%r15d+	addl	%r12d,%ebx+	rorl	$6,%r13d+	paddd	%xmm7,%xmm1+	andl	%r15d,%edi+	xorl	%ecx,%r14d+	addl	%r13d,%ebx+	pshufd	$80,%xmm1,%xmm7+	xorl	%edx,%edi+	rorl	$2,%r14d+	addl	%ebx,%r9d+	movdqa	%xmm7,%xmm6+	addl	%edi,%ebx+	movl	%r9d,%r13d+	psrld	$10,%xmm7+	addl	%ebx,%r14d+	rorl	$14,%r13d+	psrlq	$17,%xmm6+	movl	%r14d,%ebx+	movl	%r10d,%r12d+	pxor	%xmm6,%xmm7+	rorl	$9,%r14d+	xorl	%r9d,%r13d+	xorl	%r11d,%r12d+	rorl	$5,%r13d+	xorl	%ebx,%r14d+	psrlq	$2,%xmm6+	andl	%r9d,%r12d+	xorl	%r9d,%r13d+	addl	28(%rsp),%eax+	pxor	%xmm6,%xmm7+	movl	%ebx,%edi+	xorl	%r11d,%r12d+	rorl	$11,%r14d+	pshufd	$8,%xmm7,%xmm7+	xorl	%ecx,%edi+	addl	%r12d,%eax+	movdqa	16(%rsi),%xmm6+	rorl	$6,%r13d+	andl	%edi,%r15d+	pslldq	$8,%xmm7+	xorl	%ebx,%r14d+	addl	%r13d,%eax+	xorl	%ecx,%r15d+	paddd	%xmm7,%xmm1+	rorl	$2,%r14d+	addl	%eax,%r8d+	addl	%r15d,%eax+	paddd	%xmm1,%xmm6+	movl	%r8d,%r13d+	addl	%eax,%r14d+	movdqa	%xmm6,16(%rsp)+	rorl	$14,%r13d+	movdqa	%xmm3,%xmm4+	movl	%r14d,%eax+	movl	%r9d,%r12d+	movdqa	%xmm1,%xmm7+	rorl	$9,%r14d+	xorl	%r8d,%r13d+	xorl	%r10d,%r12d+	rorl	$5,%r13d+	xorl	%eax,%r14d+.byte	102,15,58,15,226,4+	andl	%r8d,%r12d+	xorl	%r8d,%r13d+.byte	102,15,58,15,248,4+	addl	32(%rsp),%r11d+	movl	%eax,%r15d+	xorl	%r10d,%r12d+	rorl	$11,%r14d+	movdqa	%xmm4,%xmm5+	xorl	%ebx,%r15d+	addl	%r12d,%r11d+	movdqa	%xmm4,%xmm6+	rorl	$6,%r13d+	andl	%r15d,%edi+	psrld	$3,%xmm4+	xorl	%eax,%r14d+	addl	%r13d,%r11d+	xorl	%ebx,%edi+	paddd	%xmm7,%xmm2+	rorl	$2,%r14d+	addl	%r11d,%edx+	psrld	$7,%xmm6+	addl	%edi,%r11d+	movl	%edx,%r13d+	pshufd	$250,%xmm1,%xmm7+	addl	%r11d,%r14d+	rorl	$14,%r13d+	pslld	$14,%xmm5+	movl	%r14d,%r11d+	movl	%r8d,%r12d+	pxor	%xmm6,%xmm4+	rorl	$9,%r14d+	xorl	%edx,%r13d+	xorl	%r9d,%r12d+	rorl	$5,%r13d+	psrld	$11,%xmm6+	xorl	%r11d,%r14d+	pxor	%xmm5,%xmm4+	andl	%edx,%r12d+	xorl	%edx,%r13d+	pslld	$11,%xmm5+	addl	36(%rsp),%r10d+	movl	%r11d,%edi+	pxor	%xmm6,%xmm4+	xorl	%r9d,%r12d+	rorl	$11,%r14d+	movdqa	%xmm7,%xmm6+	xorl	%eax,%edi+	addl	%r12d,%r10d+	pxor	%xmm5,%xmm4+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%r11d,%r14d+	psrld	$10,%xmm7+	addl	%r13d,%r10d+	xorl	%eax,%r15d+	paddd	%xmm4,%xmm2+	rorl	$2,%r14d+	addl	%r10d,%ecx+	psrlq	$17,%xmm6+	addl	%r15d,%r10d+	movl	%ecx,%r13d+	addl	%r10d,%r14d+	pxor	%xmm6,%xmm7+	rorl	$14,%r13d+	movl	%r14d,%r10d+	movl	%edx,%r12d+	rorl	$9,%r14d+	psrlq	$2,%xmm6+	xorl	%ecx,%r13d+	xorl	%r8d,%r12d+	pxor	%xmm6,%xmm7+	rorl	$5,%r13d+	xorl	%r10d,%r14d+	andl	%ecx,%r12d+	pshufd	$128,%xmm7,%xmm7+	xorl	%ecx,%r13d+	addl	40(%rsp),%r9d+	movl	%r10d,%r15d+	psrldq	$8,%xmm7+	xorl	%r8d,%r12d+	rorl	$11,%r14d+	xorl	%r11d,%r15d+	addl	%r12d,%r9d+	rorl	$6,%r13d+	paddd	%xmm7,%xmm2+	andl	%r15d,%edi+	xorl	%r10d,%r14d+	addl	%r13d,%r9d+	pshufd	$80,%xmm2,%xmm7+	xorl	%r11d,%edi+	rorl	$2,%r14d+	addl	%r9d,%ebx+	movdqa	%xmm7,%xmm6+	addl	%edi,%r9d+	movl	%ebx,%r13d+	psrld	$10,%xmm7+	addl	%r9d,%r14d+	rorl	$14,%r13d+	psrlq	$17,%xmm6+	movl	%r14d,%r9d+	movl	%ecx,%r12d+	pxor	%xmm6,%xmm7+	rorl	$9,%r14d+	xorl	%ebx,%r13d+	xorl	%edx,%r12d+	rorl	$5,%r13d+	xorl	%r9d,%r14d+	psrlq	$2,%xmm6+	andl	%ebx,%r12d+	xorl	%ebx,%r13d+	addl	44(%rsp),%r8d+	pxor	%xmm6,%xmm7+	movl	%r9d,%edi+	xorl	%edx,%r12d+	rorl	$11,%r14d+	pshufd	$8,%xmm7,%xmm7+	xorl	%r10d,%edi+	addl	%r12d,%r8d+	movdqa	32(%rsi),%xmm6+	rorl	$6,%r13d+	andl	%edi,%r15d+	pslldq	$8,%xmm7+	xorl	%r9d,%r14d+	addl	%r13d,%r8d+	xorl	%r10d,%r15d+	paddd	%xmm7,%xmm2+	rorl	$2,%r14d+	addl	%r8d,%eax+	addl	%r15d,%r8d+	paddd	%xmm2,%xmm6+	movl	%eax,%r13d+	addl	%r8d,%r14d+	movdqa	%xmm6,32(%rsp)+	rorl	$14,%r13d+	movdqa	%xmm0,%xmm4+	movl	%r14d,%r8d+	movl	%ebx,%r12d+	movdqa	%xmm2,%xmm7+	rorl	$9,%r14d+	xorl	%eax,%r13d+	xorl	%ecx,%r12d+	rorl	$5,%r13d+	xorl	%r8d,%r14d+.byte	102,15,58,15,227,4+	andl	%eax,%r12d+	xorl	%eax,%r13d+.byte	102,15,58,15,249,4+	addl	48(%rsp),%edx+	movl	%r8d,%r15d+	xorl	%ecx,%r12d+	rorl	$11,%r14d+	movdqa	%xmm4,%xmm5+	xorl	%r9d,%r15d+	addl	%r12d,%edx+	movdqa	%xmm4,%xmm6+	rorl	$6,%r13d+	andl	%r15d,%edi+	psrld	$3,%xmm4+	xorl	%r8d,%r14d+	addl	%r13d,%edx+	xorl	%r9d,%edi+	paddd	%xmm7,%xmm3+	rorl	$2,%r14d+	addl	%edx,%r11d+	psrld	$7,%xmm6+	addl	%edi,%edx+	movl	%r11d,%r13d+	pshufd	$250,%xmm2,%xmm7+	addl	%edx,%r14d+	rorl	$14,%r13d+	pslld	$14,%xmm5+	movl	%r14d,%edx+	movl	%eax,%r12d+	pxor	%xmm6,%xmm4+	rorl	$9,%r14d+	xorl	%r11d,%r13d+	xorl	%ebx,%r12d+	rorl	$5,%r13d+	psrld	$11,%xmm6+	xorl	%edx,%r14d+	pxor	%xmm5,%xmm4+	andl	%r11d,%r12d+	xorl	%r11d,%r13d+	pslld	$11,%xmm5+	addl	52(%rsp),%ecx+	movl	%edx,%edi+	pxor	%xmm6,%xmm4+	xorl	%ebx,%r12d+	rorl	$11,%r14d+	movdqa	%xmm7,%xmm6+	xorl	%r8d,%edi+	addl	%r12d,%ecx+	pxor	%xmm5,%xmm4+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%edx,%r14d+	psrld	$10,%xmm7+	addl	%r13d,%ecx+	xorl	%r8d,%r15d+	paddd	%xmm4,%xmm3+	rorl	$2,%r14d+	addl	%ecx,%r10d+	psrlq	$17,%xmm6+	addl	%r15d,%ecx+	movl	%r10d,%r13d+	addl	%ecx,%r14d+	pxor	%xmm6,%xmm7+	rorl	$14,%r13d+	movl	%r14d,%ecx+	movl	%r11d,%r12d+	rorl	$9,%r14d+	psrlq	$2,%xmm6+	xorl	%r10d,%r13d+	xorl	%eax,%r12d+	pxor	%xmm6,%xmm7+	rorl	$5,%r13d+	xorl	%ecx,%r14d+	andl	%r10d,%r12d+	pshufd	$128,%xmm7,%xmm7+	xorl	%r10d,%r13d+	addl	56(%rsp),%ebx+	movl	%ecx,%r15d+	psrldq	$8,%xmm7+	xorl	%eax,%r12d+	rorl	$11,%r14d+	xorl	%edx,%r15d+	addl	%r12d,%ebx+	rorl	$6,%r13d+	paddd	%xmm7,%xmm3+	andl	%r15d,%edi+	xorl	%ecx,%r14d+	addl	%r13d,%ebx+	pshufd	$80,%xmm3,%xmm7+	xorl	%edx,%edi+	rorl	$2,%r14d+	addl	%ebx,%r9d+	movdqa	%xmm7,%xmm6+	addl	%edi,%ebx+	movl	%r9d,%r13d+	psrld	$10,%xmm7+	addl	%ebx,%r14d+	rorl	$14,%r13d+	psrlq	$17,%xmm6+	movl	%r14d,%ebx+	movl	%r10d,%r12d+	pxor	%xmm6,%xmm7+	rorl	$9,%r14d+	xorl	%r9d,%r13d+	xorl	%r11d,%r12d+	rorl	$5,%r13d+	xorl	%ebx,%r14d+	psrlq	$2,%xmm6+	andl	%r9d,%r12d+	xorl	%r9d,%r13d+	addl	60(%rsp),%eax+	pxor	%xmm6,%xmm7+	movl	%ebx,%edi+	xorl	%r11d,%r12d+	rorl	$11,%r14d+	pshufd	$8,%xmm7,%xmm7+	xorl	%ecx,%edi+	addl	%r12d,%eax+	movdqa	48(%rsi),%xmm6+	rorl	$6,%r13d+	andl	%edi,%r15d+	pslldq	$8,%xmm7+	xorl	%ebx,%r14d+	addl	%r13d,%eax+	xorl	%ecx,%r15d+	paddd	%xmm7,%xmm3+	rorl	$2,%r14d+	addl	%eax,%r8d+	addl	%r15d,%eax+	paddd	%xmm3,%xmm6+	movl	%r8d,%r13d+	addl	%eax,%r14d+	movdqa	%xmm6,48(%rsp)+	cmpb	$0,67(%rsi)+	jne	.Lssse3_00_47+	rorl	$14,%r13d+	movl	%r14d,%eax+	movl	%r9d,%r12d+	rorl	$9,%r14d+	xorl	%r8d,%r13d+	xorl	%r10d,%r12d+	rorl	$5,%r13d+	xorl	%eax,%r14d+	andl	%r8d,%r12d+	xorl	%r8d,%r13d+	addl	0(%rsp),%r11d+	movl	%eax,%r15d+	xorl	%r10d,%r12d+	rorl	$11,%r14d+	xorl	%ebx,%r15d+	addl	%r12d,%r11d+	rorl	$6,%r13d+	andl	%r15d,%edi+	xorl	%eax,%r14d+	addl	%r13d,%r11d+	xorl	%ebx,%edi+	rorl	$2,%r14d+	addl	%r11d,%edx+	addl	%edi,%r11d+	movl	%edx,%r13d+	addl	%r11d,%r14d+	rorl	$14,%r13d+	movl	%r14d,%r11d+	movl	%r8d,%r12d+	rorl	$9,%r14d+	xorl	%edx,%r13d+	xorl	%r9d,%r12d+	rorl	$5,%r13d+	xorl	%r11d,%r14d+	andl	%edx,%r12d+	xorl	%edx,%r13d+	addl	4(%rsp),%r10d+	movl	%r11d,%edi+	xorl	%r9d,%r12d+	rorl	$11,%r14d+	xorl	%eax,%edi+	addl	%r12d,%r10d+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%r11d,%r14d+	addl	%r13d,%r10d+	xorl	%eax,%r15d+	rorl	$2,%r14d+	addl	%r10d,%ecx+	addl	%r15d,%r10d+	movl	%ecx,%r13d+	addl	%r10d,%r14d+	rorl	$14,%r13d+	movl	%r14d,%r10d+	movl	%edx,%r12d+	rorl	$9,%r14d+	xorl	%ecx,%r13d+	xorl	%r8d,%r12d+	rorl	$5,%r13d+	xorl	%r10d,%r14d+	andl	%ecx,%r12d+	xorl	%ecx,%r13d+	addl	8(%rsp),%r9d+	movl	%r10d,%r15d+	xorl	%r8d,%r12d+	rorl	$11,%r14d+	xorl	%r11d,%r15d+	addl	%r12d,%r9d+	rorl	$6,%r13d+	andl	%r15d,%edi+	xorl	%r10d,%r14d+	addl	%r13d,%r9d+	xorl	%r11d,%edi+	rorl	$2,%r14d+	addl	%r9d,%ebx+	addl	%edi,%r9d+	movl	%ebx,%r13d+	addl	%r9d,%r14d+	rorl	$14,%r13d+	movl	%r14d,%r9d+	movl	%ecx,%r12d+	rorl	$9,%r14d+	xorl	%ebx,%r13d+	xorl	%edx,%r12d+	rorl	$5,%r13d+	xorl	%r9d,%r14d+	andl	%ebx,%r12d+	xorl	%ebx,%r13d+	addl	12(%rsp),%r8d+	movl	%r9d,%edi+	xorl	%edx,%r12d+	rorl	$11,%r14d+	xorl	%r10d,%edi+	addl	%r12d,%r8d+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%r9d,%r14d+	addl	%r13d,%r8d+	xorl	%r10d,%r15d+	rorl	$2,%r14d+	addl	%r8d,%eax+	addl	%r15d,%r8d+	movl	%eax,%r13d+	addl	%r8d,%r14d+	rorl	$14,%r13d+	movl	%r14d,%r8d+	movl	%ebx,%r12d+	rorl	$9,%r14d+	xorl	%eax,%r13d+	xorl	%ecx,%r12d+	rorl	$5,%r13d+	xorl	%r8d,%r14d+	andl	%eax,%r12d+	xorl	%eax,%r13d+	addl	16(%rsp),%edx+	movl	%r8d,%r15d+	xorl	%ecx,%r12d+	rorl	$11,%r14d+	xorl	%r9d,%r15d+	addl	%r12d,%edx+	rorl	$6,%r13d+	andl	%r15d,%edi+	xorl	%r8d,%r14d+	addl	%r13d,%edx+	xorl	%r9d,%edi+	rorl	$2,%r14d+	addl	%edx,%r11d+	addl	%edi,%edx+	movl	%r11d,%r13d+	addl	%edx,%r14d+	rorl	$14,%r13d+	movl	%r14d,%edx+	movl	%eax,%r12d+	rorl	$9,%r14d+	xorl	%r11d,%r13d+	xorl	%ebx,%r12d+	rorl	$5,%r13d+	xorl	%edx,%r14d+	andl	%r11d,%r12d+	xorl	%r11d,%r13d+	addl	20(%rsp),%ecx+	movl	%edx,%edi+	xorl	%ebx,%r12d+	rorl	$11,%r14d+	xorl	%r8d,%edi+	addl	%r12d,%ecx+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%edx,%r14d+	addl	%r13d,%ecx+	xorl	%r8d,%r15d+	rorl	$2,%r14d+	addl	%ecx,%r10d+	addl	%r15d,%ecx+	movl	%r10d,%r13d+	addl	%ecx,%r14d+	rorl	$14,%r13d+	movl	%r14d,%ecx+	movl	%r11d,%r12d+	rorl	$9,%r14d+	xorl	%r10d,%r13d+	xorl	%eax,%r12d+	rorl	$5,%r13d+	xorl	%ecx,%r14d+	andl	%r10d,%r12d+	xorl	%r10d,%r13d+	addl	24(%rsp),%ebx+	movl	%ecx,%r15d+	xorl	%eax,%r12d+	rorl	$11,%r14d+	xorl	%edx,%r15d+	addl	%r12d,%ebx+	rorl	$6,%r13d+	andl	%r15d,%edi+	xorl	%ecx,%r14d+	addl	%r13d,%ebx+	xorl	%edx,%edi+	rorl	$2,%r14d+	addl	%ebx,%r9d+	addl	%edi,%ebx+	movl	%r9d,%r13d+	addl	%ebx,%r14d+	rorl	$14,%r13d+	movl	%r14d,%ebx+	movl	%r10d,%r12d+	rorl	$9,%r14d+	xorl	%r9d,%r13d+	xorl	%r11d,%r12d+	rorl	$5,%r13d+	xorl	%ebx,%r14d+	andl	%r9d,%r12d+	xorl	%r9d,%r13d+	addl	28(%rsp),%eax+	movl	%ebx,%edi+	xorl	%r11d,%r12d+	rorl	$11,%r14d+	xorl	%ecx,%edi+	addl	%r12d,%eax+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%ebx,%r14d+	addl	%r13d,%eax+	xorl	%ecx,%r15d+	rorl	$2,%r14d+	addl	%eax,%r8d+	addl	%r15d,%eax+	movl	%r8d,%r13d+	addl	%eax,%r14d+	rorl	$14,%r13d+	movl	%r14d,%eax+	movl	%r9d,%r12d+	rorl	$9,%r14d+	xorl	%r8d,%r13d+	xorl	%r10d,%r12d+	rorl	$5,%r13d+	xorl	%eax,%r14d+	andl	%r8d,%r12d+	xorl	%r8d,%r13d+	addl	32(%rsp),%r11d+	movl	%eax,%r15d+	xorl	%r10d,%r12d+	rorl	$11,%r14d+	xorl	%ebx,%r15d+	addl	%r12d,%r11d+	rorl	$6,%r13d+	andl	%r15d,%edi+	xorl	%eax,%r14d+	addl	%r13d,%r11d+	xorl	%ebx,%edi+	rorl	$2,%r14d+	addl	%r11d,%edx+	addl	%edi,%r11d+	movl	%edx,%r13d+	addl	%r11d,%r14d+	rorl	$14,%r13d+	movl	%r14d,%r11d+	movl	%r8d,%r12d+	rorl	$9,%r14d+	xorl	%edx,%r13d+	xorl	%r9d,%r12d+	rorl	$5,%r13d+	xorl	%r11d,%r14d+	andl	%edx,%r12d+	xorl	%edx,%r13d+	addl	36(%rsp),%r10d+	movl	%r11d,%edi+	xorl	%r9d,%r12d+	rorl	$11,%r14d+	xorl	%eax,%edi+	addl	%r12d,%r10d+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%r11d,%r14d+	addl	%r13d,%r10d+	xorl	%eax,%r15d+	rorl	$2,%r14d+	addl	%r10d,%ecx+	addl	%r15d,%r10d+	movl	%ecx,%r13d+	addl	%r10d,%r14d+	rorl	$14,%r13d+	movl	%r14d,%r10d+	movl	%edx,%r12d+	rorl	$9,%r14d+	xorl	%ecx,%r13d+	xorl	%r8d,%r12d+	rorl	$5,%r13d+	xorl	%r10d,%r14d+	andl	%ecx,%r12d+	xorl	%ecx,%r13d+	addl	40(%rsp),%r9d+	movl	%r10d,%r15d+	xorl	%r8d,%r12d+	rorl	$11,%r14d+	xorl	%r11d,%r15d+	addl	%r12d,%r9d+	rorl	$6,%r13d+	andl	%r15d,%edi+	xorl	%r10d,%r14d+	addl	%r13d,%r9d+	xorl	%r11d,%edi+	rorl	$2,%r14d+	addl	%r9d,%ebx+	addl	%edi,%r9d+	movl	%ebx,%r13d+	addl	%r9d,%r14d+	rorl	$14,%r13d+	movl	%r14d,%r9d+	movl	%ecx,%r12d+	rorl	$9,%r14d+	xorl	%ebx,%r13d+	xorl	%edx,%r12d+	rorl	$5,%r13d+	xorl	%r9d,%r14d+	andl	%ebx,%r12d+	xorl	%ebx,%r13d+	addl	44(%rsp),%r8d+	movl	%r9d,%edi+	xorl	%edx,%r12d+	rorl	$11,%r14d+	xorl	%r10d,%edi+	addl	%r12d,%r8d+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%r9d,%r14d+	addl	%r13d,%r8d+	xorl	%r10d,%r15d+	rorl	$2,%r14d+	addl	%r8d,%eax+	addl	%r15d,%r8d+	movl	%eax,%r13d+	addl	%r8d,%r14d+	rorl	$14,%r13d+	movl	%r14d,%r8d+	movl	%ebx,%r12d+	rorl	$9,%r14d+	xorl	%eax,%r13d+	xorl	%ecx,%r12d+	rorl	$5,%r13d+	xorl	%r8d,%r14d+	andl	%eax,%r12d+	xorl	%eax,%r13d+	addl	48(%rsp),%edx+	movl	%r8d,%r15d+	xorl	%ecx,%r12d+	rorl	$11,%r14d+	xorl	%r9d,%r15d+	addl	%r12d,%edx+	rorl	$6,%r13d+	andl	%r15d,%edi+	xorl	%r8d,%r14d+	addl	%r13d,%edx+	xorl	%r9d,%edi+	rorl	$2,%r14d+	addl	%edx,%r11d+	addl	%edi,%edx+	movl	%r11d,%r13d+	addl	%edx,%r14d+	rorl	$14,%r13d+	movl	%r14d,%edx+	movl	%eax,%r12d+	rorl	$9,%r14d+	xorl	%r11d,%r13d+	xorl	%ebx,%r12d+	rorl	$5,%r13d+	xorl	%edx,%r14d+	andl	%r11d,%r12d+	xorl	%r11d,%r13d+	addl	52(%rsp),%ecx+	movl	%edx,%edi+	xorl	%ebx,%r12d+	rorl	$11,%r14d+	xorl	%r8d,%edi+	addl	%r12d,%ecx+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%edx,%r14d+	addl	%r13d,%ecx+	xorl	%r8d,%r15d+	rorl	$2,%r14d+	addl	%ecx,%r10d+	addl	%r15d,%ecx+	movl	%r10d,%r13d+	addl	%ecx,%r14d+	rorl	$14,%r13d+	movl	%r14d,%ecx+	movl	%r11d,%r12d+	rorl	$9,%r14d+	xorl	%r10d,%r13d+	xorl	%eax,%r12d+	rorl	$5,%r13d+	xorl	%ecx,%r14d+	andl	%r10d,%r12d+	xorl	%r10d,%r13d+	addl	56(%rsp),%ebx+	movl	%ecx,%r15d+	xorl	%eax,%r12d+	rorl	$11,%r14d+	xorl	%edx,%r15d+	addl	%r12d,%ebx+	rorl	$6,%r13d+	andl	%r15d,%edi+	xorl	%ecx,%r14d+	addl	%r13d,%ebx+	xorl	%edx,%edi+	rorl	$2,%r14d+	addl	%ebx,%r9d+	addl	%edi,%ebx+	movl	%r9d,%r13d+	addl	%ebx,%r14d+	rorl	$14,%r13d+	movl	%r14d,%ebx+	movl	%r10d,%r12d+	rorl	$9,%r14d+	xorl	%r9d,%r13d+	xorl	%r11d,%r12d+	rorl	$5,%r13d+	xorl	%ebx,%r14d+	andl	%r9d,%r12d+	xorl	%r9d,%r13d+	addl	60(%rsp),%eax+	movl	%ebx,%edi+	xorl	%r11d,%r12d+	rorl	$11,%r14d+	xorl	%ecx,%edi+	addl	%r12d,%eax+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%ebx,%r14d+	addl	%r13d,%eax+	xorl	%ecx,%r15d+	rorl	$2,%r14d+	addl	%eax,%r8d+	addl	%r15d,%eax+	movl	%r8d,%r13d+	addl	%eax,%r14d+	movq	0(%rbp),%rdi+	movl	%r14d,%eax+	movq	8(%rbp),%rsi++	addl	0(%rdi),%eax+	addl	4(%rdi),%ebx+	addl	8(%rdi),%ecx+	addl	12(%rdi),%edx+	addl	16(%rdi),%r8d+	addl	20(%rdi),%r9d+	addl	24(%rdi),%r10d+	addl	28(%rdi),%r11d++	leaq	64(%rsi),%rsi+	cmpq	16(%rbp),%rsi++	movl	%eax,0(%rdi)+	movl	%ebx,4(%rdi)+	movl	%ecx,8(%rdi)+	movl	%edx,12(%rdi)+	movl	%r8d,16(%rdi)+	movl	%r9d,20(%rdi)+	movl	%r10d,24(%rdi)+	movl	%r11d,28(%rdi)+	jb	.Lloop_ssse3++	xorps	%xmm0,%xmm0+	leaq	40+48(%rbp),%r11+.cfi_def_cfa	%r11,8+	movaps	%xmm0,0(%rsp)+	movaps	%xmm0,16(%rsp)+	movaps	%xmm0,32(%rsp)+	movaps	%xmm0,48(%rsp)+	movq	40(%rbp),%r15+.cfi_restore	%r15+	movq	-40(%r11),%r14+.cfi_restore	%r14+	movq	-32(%r11),%r13+.cfi_restore	%r13+	movq	-24(%r11),%r12+.cfi_restore	%r12+	movq	-16(%r11),%rbx+.cfi_restore	%rbx+	movq	-8(%r11),%rbp+.cfi_restore	%rbp++	leaq	(%r11),%rsp+	.byte	0xf3,0xc3+.cfi_endproc	+.size	blst_sha256_block_data_order,.-blst_sha256_block_data_order+.globl	blst_sha256_emit+.hidden	blst_sha256_emit+.type	blst_sha256_emit,@function+.align	16+blst_sha256_emit:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	bswapq	%r8+	movq	24(%rsi),%r11+	bswapq	%r9+	movl	%r8d,4(%rdi)+	bswapq	%r10+	movl	%r9d,12(%rdi)+	bswapq	%r11+	movl	%r10d,20(%rdi)+	shrq	$32,%r8+	movl	%r11d,28(%rdi)+	shrq	$32,%r9+	movl	%r8d,0(%rdi)+	shrq	$32,%r10+	movl	%r9d,8(%rdi)+	shrq	$32,%r11+	movl	%r10d,16(%rdi)+	movl	%r11d,24(%rdi)+	.byte	0xf3,0xc3+.cfi_endproc+.size	blst_sha256_emit,.-blst_sha256_emit++.globl	blst_sha256_bcopy+.hidden	blst_sha256_bcopy+.type	blst_sha256_bcopy,@function+.align	16+blst_sha256_bcopy:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	subq	%rsi,%rdi+.Loop_bcopy:+	movzbl	(%rsi),%eax+	leaq	1(%rsi),%rsi+	movb	%al,-1(%rdi,%rsi,1)+	decq	%rdx+	jnz	.Loop_bcopy+	.byte	0xf3,0xc3+.cfi_endproc+.size	blst_sha256_bcopy,.-blst_sha256_bcopy++.globl	blst_sha256_hcopy+.hidden	blst_sha256_hcopy+.type	blst_sha256_hcopy,@function+.align	16+blst_sha256_hcopy:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	.byte	0xf3,0xc3+.cfi_endproc+.size	blst_sha256_hcopy,.-blst_sha256_hcopy++.section	.note.GNU-stack,"",@progbits+.section	.note.gnu.property,"a",@note+	.long	4,2f-1f,5+	.byte	0x47,0x4E,0x55,0+1:	.long	0xc0000002,4,3+.align	8+2:
+ c-source/build/mach-o/add_mod_256-armv8.S view
@@ -0,0 +1,379 @@+.text++.globl	_add_mod_256+.private_extern	_add_mod_256++.align	5+_add_mod_256:+	ldp	x8,x9,[x1]+	ldp	x12,x13,[x2]++	ldp	x10,x11,[x1,#16]+	adds	x8,x8,x12+	ldp	x14,x15,[x2,#16]+	adcs	x9,x9,x13+	ldp	x4,x5,[x3]+	adcs	x10,x10,x14+	ldp	x6,x7,[x3,#16]+	adcs	x11,x11,x15+	adc	x3,xzr,xzr++	subs	x16,x8,x4+	sbcs	x17,x9,x5+	sbcs	x1,x10,x6+	sbcs	x2,x11,x7+	sbcs	xzr,x3,xzr++	csel	x8,x8,x16,lo+	csel	x9,x9,x17,lo+	csel	x10,x10,x1,lo+	stp	x8,x9,[x0]+	csel	x11,x11,x2,lo+	stp	x10,x11,[x0,#16]++	ret+++.globl	_mul_by_3_mod_256+.private_extern	_mul_by_3_mod_256++.align	5+_mul_by_3_mod_256:+	ldp	x12,x13,[x1]+	ldp	x14,x15,[x1,#16]++	adds	x8,x12,x12+	ldp	x4,x5,[x2]+	adcs	x9,x13,x13+	ldp	x6,x7,[x2,#16]+	adcs	x10,x14,x14+	adcs	x11,x15,x15+	adc	x3,xzr,xzr++	subs	x16,x8,x4+	sbcs	x17,x9,x5+	sbcs	x1,x10,x6+	sbcs	x2,x11,x7+	sbcs	xzr,x3,xzr++	csel	x8,x8,x16,lo+	csel	x9,x9,x17,lo+	csel	x10,x10,x1,lo+	csel	x11,x11,x2,lo++	adds	x8,x8,x12+	adcs	x9,x9,x13+	adcs	x10,x10,x14+	adcs	x11,x11,x15+	adc	x3,xzr,xzr++	subs	x16,x8,x4+	sbcs	x17,x9,x5+	sbcs	x1,x10,x6+	sbcs	x2,x11,x7+	sbcs	xzr,x3,xzr++	csel	x8,x8,x16,lo+	csel	x9,x9,x17,lo+	csel	x10,x10,x1,lo+	stp	x8,x9,[x0]+	csel	x11,x11,x2,lo+	stp	x10,x11,[x0,#16]++	ret+++.globl	_lshift_mod_256+.private_extern	_lshift_mod_256++.align	5+_lshift_mod_256:+	ldp	x8,x9,[x1]+	ldp	x10,x11,[x1,#16]++	ldp	x4,x5,[x3]+	ldp	x6,x7,[x3,#16]++Loop_lshift_mod_256:+	adds	x8,x8,x8+	sub	x2,x2,#1+	adcs	x9,x9,x9+	adcs	x10,x10,x10+	adcs	x11,x11,x11+	adc	x3,xzr,xzr++	subs	x12,x8,x4+	sbcs	x13,x9,x5+	sbcs	x14,x10,x6+	sbcs	x15,x11,x7+	sbcs	xzr,x3,xzr++	csel	x8,x8,x12,lo+	csel	x9,x9,x13,lo+	csel	x10,x10,x14,lo+	csel	x11,x11,x15,lo++	cbnz	x2,Loop_lshift_mod_256++	stp	x8,x9,[x0]+	stp	x10,x11,[x0,#16]++	ret+++.globl	_rshift_mod_256+.private_extern	_rshift_mod_256++.align	5+_rshift_mod_256:+	ldp	x8,x9,[x1]+	ldp	x10,x11,[x1,#16]++	ldp	x4,x5,[x3]+	ldp	x6,x7,[x3,#16]++Loop_rshift:+	adds	x12,x8,x4+	sub	x2,x2,#1+	adcs	x13,x9,x5+	adcs	x14,x10,x6+	adcs	x15,x11,x7+	adc	x3,xzr,xzr+	tst	x8,#1++	csel	x12,x12,x8,ne+	csel	x13,x13,x9,ne+	csel	x14,x14,x10,ne+	csel	x15,x15,x11,ne+	csel	x3,x3,xzr,ne++	extr	x8,x13,x12,#1+	extr	x9,x14,x13,#1+	extr	x10,x15,x14,#1+	extr	x11,x3,x15,#1++	cbnz	x2,Loop_rshift++	stp	x8,x9,[x0]+	stp	x10,x11,[x0,#16]++	ret+++.globl	_cneg_mod_256+.private_extern	_cneg_mod_256++.align	5+_cneg_mod_256:+	ldp	x8,x9,[x1]+	ldp	x4,x5,[x3]++	ldp	x10,x11,[x1,#16]+	subs	x12,x4,x8+	ldp	x6,x7,[x3,#16]+	orr	x4,x8,x9+	sbcs	x13,x5,x9+	orr	x5,x10,x11+	sbcs	x14,x6,x10+	orr	x3,x4,x5+	sbc	x15,x7,x11++	cmp	x3,#0+	csetm	x3,ne+	ands	x2,x2,x3++	csel	x8,x8,x12,eq+	csel	x9,x9,x13,eq+	csel	x10,x10,x14,eq+	stp	x8,x9,[x0]+	csel	x11,x11,x15,eq+	stp	x10,x11,[x0,#16]++	ret+++.globl	_sub_mod_256+.private_extern	_sub_mod_256++.align	5+_sub_mod_256:+	ldp	x8,x9,[x1]+	ldp	x12,x13,[x2]++	ldp	x10,x11,[x1,#16]+	subs	x8,x8,x12+	ldp	x14,x15,[x2,#16]+	sbcs	x9,x9,x13+	ldp	x4,x5,[x3]+	sbcs	x10,x10,x14+	ldp	x6,x7,[x3,#16]+	sbcs	x11,x11,x15+	sbc	x3,xzr,xzr++	and	x4,x4,x3+	and	x5,x5,x3+	adds	x8,x8,x4+	and	x6,x6,x3+	adcs	x9,x9,x5+	and	x7,x7,x3+	adcs	x10,x10,x6+	stp	x8,x9,[x0]+	adc	x11,x11,x7+	stp	x10,x11,[x0,#16]++	ret+++.globl	_check_mod_256+.private_extern	_check_mod_256++.align	5+_check_mod_256:+	ldp	x8,x9,[x0]+	ldp	x10,x11,[x0,#16]+	ldp	x4,x5,[x1]+	ldp	x6,x7,[x1,#16]++#ifdef	__AARCH64EB__+	rev	x8,x8+	rev	x9,x9+	rev	x10,x10+	rev	x11,x11+#endif++	subs	xzr,x8,x4+	sbcs	xzr,x9,x5+	orr	x8,x8,x9+	sbcs	xzr,x10,x6+	orr	x8,x8,x10+	sbcs	xzr,x11,x7+	orr	x8,x8,x11+	sbc	x1,xzr,xzr++	cmp	x8,#0+	mov	x0,#1+	csel	x0,x0,xzr,ne+	and	x0,x0,x1++	ret+++.globl	_add_n_check_mod_256+.private_extern	_add_n_check_mod_256++.align	5+_add_n_check_mod_256:+	ldp	x8,x9,[x1]+	ldp	x12,x13,[x2]+	ldp	x10,x11,[x1,#16]+	ldp	x14,x15,[x2,#16]++#ifdef	__AARCH64EB__+	rev	x8,x8+	rev	x12,x12+	rev	x9,x9+	rev	x13,x13+	rev	x10,x10+	rev	x14,x14+	rev	x11,x11+	rev	x15,x15+#endif++	adds	x8,x8,x12+	ldp	x4,x5,[x3]+	adcs	x9,x9,x13+	ldp	x6,x7,[x3,#16]+	adcs	x10,x10,x14+	adcs	x11,x11,x15+	adc	x3,xzr,xzr++	subs	x16,x8,x4+	sbcs	x17,x9,x5+	sbcs	x1,x10,x6+	sbcs	x2,x11,x7+	sbcs	xzr,x3,xzr++	csel	x8,x8,x16,lo+	csel	x9,x9,x17,lo+	csel	x10,x10,x1,lo+	csel	x11,x11,x2,lo++	orr	x16, x8, x9+	orr	x17, x10, x11+	orr	x16, x16, x17++#ifdef	__AARCH64EB__+	rev	x8,x8+	rev	x9,x9+	rev	x10,x10+	rev	x11,x11+#endif++	stp	x8,x9,[x0]+	stp	x10,x11,[x0,#16]++	mov	x17, #1+	cmp	x16, #0+	csel	x0, x17, xzr, ne++	ret+++.globl	_sub_n_check_mod_256+.private_extern	_sub_n_check_mod_256++.align	5+_sub_n_check_mod_256:+	ldp	x8,x9,[x1]+	ldp	x12,x13,[x2]+	ldp	x10,x11,[x1,#16]+	ldp	x14,x15,[x2,#16]++#ifdef	__AARCH64EB__+	rev	x8,x8+	rev	x12,x12+	rev	x9,x9+	rev	x13,x13+	rev	x10,x10+	rev	x14,x14+	rev	x11,x11+	rev	x15,x15+#endif++	subs	x8,x8,x12+	sbcs	x9,x9,x13+	ldp	x4,x5,[x3]+	sbcs	x10,x10,x14+	ldp	x6,x7,[x3,#16]+	sbcs	x11,x11,x15+	sbc	x3,xzr,xzr++	and	x4,x4,x3+	and	x5,x5,x3+	adds	x8,x8,x4+	and	x6,x6,x3+	adcs	x9,x9,x5+	and	x7,x7,x3+	adcs	x10,x10,x6+	adc	x11,x11,x7++	orr	x16, x8, x9+	orr	x17, x10, x11+	orr	x16, x16, x17++#ifdef	__AARCH64EB__+	rev	x8,x8+	rev	x9,x9+	rev	x10,x10+	rev	x11,x11+#endif++	stp	x8,x9,[x0]+	stp	x10,x11,[x0,#16]++	mov	x17, #1+	cmp	x16, #0+	csel	x0, x17, xzr, ne++	ret+
+ c-source/build/mach-o/add_mod_256-x86_64.s view
@@ -0,0 +1,564 @@+.text	++.globl	_add_mod_256+.private_extern	_add_mod_256++.p2align	5+_add_mod_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11++L$oaded_a_add_mod_256:+	addq	0(%rdx),%r8+	adcq	8(%rdx),%r9+	movq	%r8,%rax+	adcq	16(%rdx),%r10+	movq	%r9,%rsi+	adcq	24(%rdx),%r11+	sbbq	%rdx,%rdx++	movq	%r10,%rbx+	subq	0(%rcx),%r8+	sbbq	8(%rcx),%r9+	sbbq	16(%rcx),%r10+	movq	%r11,%rbp+	sbbq	24(%rcx),%r11+	sbbq	$0,%rdx++	cmovcq	%rax,%r8+	cmovcq	%rsi,%r9+	movq	%r8,0(%rdi)+	cmovcq	%rbx,%r10+	movq	%r9,8(%rdi)+	cmovcq	%rbp,%r11+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)++	movq	8(%rsp),%rbx+.cfi_restore	%rbx+	movq	16(%rsp),%rbp+.cfi_restore	%rbp+	leaq	24(%rsp),%rsp+.cfi_adjust_cfa_offset	-24++	.byte	0xf3,0xc3+.cfi_endproc	++++.globl	_mul_by_3_mod_256+.private_extern	_mul_by_3_mod_256++.p2align	5+_mul_by_3_mod_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+++	movq	%rdx,%rcx+	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	%rsi,%rdx+	movq	24(%rsi),%r11++	call	__lshift_mod_256+	movq	0(%rsp),%r12+.cfi_restore	%r12+	jmp	L$oaded_a_add_mod_256++	movq	8(%rsp),%rbx+.cfi_restore	%rbx+	movq	16(%rsp),%rbp+.cfi_restore	%rbp+	leaq	24(%rsp),%rsp+.cfi_adjust_cfa_offset	-24++	.byte	0xf3,0xc3+.cfi_endproc	++++.p2align	5+__lshift_mod_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	addq	%r8,%r8+	adcq	%r9,%r9+	movq	%r8,%rax+	adcq	%r10,%r10+	movq	%r9,%rsi+	adcq	%r11,%r11+	sbbq	%r12,%r12++	movq	%r10,%rbx+	subq	0(%rcx),%r8+	sbbq	8(%rcx),%r9+	sbbq	16(%rcx),%r10+	movq	%r11,%rbp+	sbbq	24(%rcx),%r11+	sbbq	$0,%r12++	cmovcq	%rax,%r8+	cmovcq	%rsi,%r9+	cmovcq	%rbx,%r10+	cmovcq	%rbp,%r11++	.byte	0xf3,0xc3+.cfi_endproc++++.globl	_lshift_mod_256+.private_extern	_lshift_mod_256++.p2align	5+_lshift_mod_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11++L$oop_lshift_mod_256:+	call	__lshift_mod_256+	decl	%edx+	jnz	L$oop_lshift_mod_256++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)++	movq	0(%rsp),%r12+.cfi_restore	%r12+	movq	8(%rsp),%rbx+.cfi_restore	%rbx+	movq	16(%rsp),%rbp+.cfi_restore	%rbp+	leaq	24(%rsp),%rsp+.cfi_adjust_cfa_offset	-24++	.byte	0xf3,0xc3+.cfi_endproc	++++.globl	_rshift_mod_256+.private_extern	_rshift_mod_256++.p2align	5+_rshift_mod_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%rbp+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11++L$oop_rshift_mod_256:+	movq	%rbp,%r8+	andq	$1,%rbp+	movq	0(%rcx),%rax+	negq	%rbp+	movq	8(%rcx),%rsi+	movq	16(%rcx),%rbx++	andq	%rbp,%rax+	andq	%rbp,%rsi+	andq	%rbp,%rbx+	andq	24(%rcx),%rbp++	addq	%rax,%r8+	adcq	%rsi,%r9+	adcq	%rbx,%r10+	adcq	%rbp,%r11+	sbbq	%rax,%rax++	shrq	$1,%r8+	movq	%r9,%rbp+	shrq	$1,%r9+	movq	%r10,%rbx+	shrq	$1,%r10+	movq	%r11,%rsi+	shrq	$1,%r11++	shlq	$63,%rbp+	shlq	$63,%rbx+	orq	%r8,%rbp+	shlq	$63,%rsi+	orq	%rbx,%r9+	shlq	$63,%rax+	orq	%rsi,%r10+	orq	%rax,%r11++	decl	%edx+	jnz	L$oop_rshift_mod_256++	movq	%rbp,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)++	movq	8(%rsp),%rbx+.cfi_restore	%rbx+	movq	16(%rsp),%rbp+.cfi_restore	%rbp+	leaq	24(%rsp),%rsp+.cfi_adjust_cfa_offset	-24++	.byte	0xf3,0xc3+.cfi_endproc	++++.globl	_cneg_mod_256+.private_extern	_cneg_mod_256++.p2align	5+_cneg_mod_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+++	movq	0(%rsi),%r12+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	%r12,%r8+	movq	24(%rsi),%r11+	orq	%r9,%r12+	orq	%r10,%r12+	orq	%r11,%r12+	movq	$-1,%rbp++	movq	0(%rcx),%rax+	cmovnzq	%rbp,%r12+	movq	8(%rcx),%rsi+	movq	16(%rcx),%rbx+	andq	%r12,%rax+	movq	24(%rcx),%rbp+	andq	%r12,%rsi+	andq	%r12,%rbx+	andq	%r12,%rbp++	subq	%r8,%rax+	sbbq	%r9,%rsi+	sbbq	%r10,%rbx+	sbbq	%r11,%rbp++	orq	%rdx,%rdx++	cmovzq	%r8,%rax+	cmovzq	%r9,%rsi+	movq	%rax,0(%rdi)+	cmovzq	%r10,%rbx+	movq	%rsi,8(%rdi)+	cmovzq	%r11,%rbp+	movq	%rbx,16(%rdi)+	movq	%rbp,24(%rdi)++	movq	0(%rsp),%r12+.cfi_restore	%r12+	movq	8(%rsp),%rbx+.cfi_restore	%rbx+	movq	16(%rsp),%rbp+.cfi_restore	%rbp+	leaq	24(%rsp),%rsp+.cfi_adjust_cfa_offset	-24++	.byte	0xf3,0xc3+.cfi_endproc	++++.globl	_sub_mod_256+.private_extern	_sub_mod_256++.p2align	5+_sub_mod_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11++	subq	0(%rdx),%r8+	movq	0(%rcx),%rax+	sbbq	8(%rdx),%r9+	movq	8(%rcx),%rsi+	sbbq	16(%rdx),%r10+	movq	16(%rcx),%rbx+	sbbq	24(%rdx),%r11+	movq	24(%rcx),%rbp+	sbbq	%rdx,%rdx++	andq	%rdx,%rax+	andq	%rdx,%rsi+	andq	%rdx,%rbx+	andq	%rdx,%rbp++	addq	%rax,%r8+	adcq	%rsi,%r9+	movq	%r8,0(%rdi)+	adcq	%rbx,%r10+	movq	%r9,8(%rdi)+	adcq	%rbp,%r11+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)++	movq	8(%rsp),%rbx+.cfi_restore	%rbx+	movq	16(%rsp),%rbp+.cfi_restore	%rbp+	leaq	24(%rsp),%rsp+.cfi_adjust_cfa_offset	-24++	.byte	0xf3,0xc3+.cfi_endproc	++++.globl	_check_mod_256+.private_extern	_check_mod_256++.p2align	5+_check_mod_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	movq	0(%rdi),%rax+	movq	8(%rdi),%r9+	movq	16(%rdi),%r10+	movq	24(%rdi),%r11++	movq	%rax,%r8+	orq	%r9,%rax+	orq	%r10,%rax+	orq	%r11,%rax++	subq	0(%rsi),%r8+	sbbq	8(%rsi),%r9+	sbbq	16(%rsi),%r10+	sbbq	24(%rsi),%r11+	sbbq	%rsi,%rsi++	movq	$1,%rdx+	cmpq	$0,%rax+	cmovneq	%rdx,%rax+	andq	%rsi,%rax++	.byte	0xf3,0xc3+.cfi_endproc	++++.globl	_add_n_check_mod_256+.private_extern	_add_n_check_mod_256++.p2align	5+_add_n_check_mod_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11++	addq	0(%rdx),%r8+	adcq	8(%rdx),%r9+	movq	%r8,%rax+	adcq	16(%rdx),%r10+	movq	%r9,%rsi+	adcq	24(%rdx),%r11+	sbbq	%rdx,%rdx++	movq	%r10,%rbx+	subq	0(%rcx),%r8+	sbbq	8(%rcx),%r9+	sbbq	16(%rcx),%r10+	movq	%r11,%rbp+	sbbq	24(%rcx),%r11+	sbbq	$0,%rdx++	cmovcq	%rax,%r8+	cmovcq	%rsi,%r9+	movq	%r8,0(%rdi)+	cmovcq	%rbx,%r10+	movq	%r9,8(%rdi)+	cmovcq	%rbp,%r11+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)++	orq	%r9,%r8+	orq	%r11,%r10+	orq	%r10,%r8+	movq	$1,%rax+	cmovzq	%r8,%rax++	movq	8(%rsp),%rbx+.cfi_restore	%rbx+	movq	16(%rsp),%rbp+.cfi_restore	%rbp+	leaq	24(%rsp),%rsp+.cfi_adjust_cfa_offset	-24++	.byte	0xf3,0xc3+.cfi_endproc	++++.globl	_sub_n_check_mod_256+.private_extern	_sub_n_check_mod_256++.p2align	5+_sub_n_check_mod_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11++	subq	0(%rdx),%r8+	movq	0(%rcx),%rax+	sbbq	8(%rdx),%r9+	movq	8(%rcx),%rsi+	sbbq	16(%rdx),%r10+	movq	16(%rcx),%rbx+	sbbq	24(%rdx),%r11+	movq	24(%rcx),%rbp+	sbbq	%rdx,%rdx++	andq	%rdx,%rax+	andq	%rdx,%rsi+	andq	%rdx,%rbx+	andq	%rdx,%rbp++	addq	%rax,%r8+	adcq	%rsi,%r9+	movq	%r8,0(%rdi)+	adcq	%rbx,%r10+	movq	%r9,8(%rdi)+	adcq	%rbp,%r11+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)++	orq	%r9,%r8+	orq	%r11,%r10+	orq	%r10,%r8+	movq	$1,%rax+	cmovzq	%r8,%rax++	movq	8(%rsp),%rbx+.cfi_restore	%rbx+	movq	16(%rsp),%rbp+.cfi_restore	%rbp+	leaq	24(%rsp),%rsp+.cfi_adjust_cfa_offset	-24++	.byte	0xf3,0xc3+.cfi_endproc	+
+ c-source/build/mach-o/add_mod_384-armv8.S view
@@ -0,0 +1,931 @@+.text++.globl	_add_mod_384+.private_extern	_add_mod_384++.align	5+_add_mod_384:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x4,x5,[x3]+	ldp	x6,x7,[x3,#16]+	ldp	x8,x9,[x3,#32]++	bl	__add_mod_384+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]+	stp	x14,x15,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret++++.align	5+__add_mod_384:+	ldp	x10,x11,[x1]+	ldp	x16,x17,[x2]+	ldp	x12,x13,[x1,#16]+	ldp	x19,x20,[x2,#16]+	ldp	x14,x15,[x1,#32]+	ldp	x21,x22,[x2,#32]++__add_mod_384_ab_are_loaded:+	adds	x10,x10,x16+	adcs	x11,x11,x17+	adcs	x12,x12,x19+	adcs	x13,x13,x20+	adcs	x14,x14,x21+	adcs	x15,x15,x22+	adc	x3,xzr,xzr++	subs	x16,x10,x4+	sbcs	x17,x11,x5+	sbcs	x19,x12,x6+	sbcs	x20,x13,x7+	sbcs	x21,x14,x8+	sbcs	x22,x15,x9+	sbcs	xzr,x3,xzr++	csel	x10,x10,x16,lo+	csel	x11,x11,x17,lo+	csel	x12,x12,x19,lo+	csel	x13,x13,x20,lo+	csel	x14,x14,x21,lo+	csel	x15,x15,x22,lo++	ret+++.globl	_add_mod_384x+.private_extern	_add_mod_384x++.align	5+_add_mod_384x:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x4,x5,[x3]+	ldp	x6,x7,[x3,#16]+	ldp	x8,x9,[x3,#32]++	bl	__add_mod_384++	stp	x10,x11,[x0]+	add	x1,x1,#48+	stp	x12,x13,[x0,#16]+	add	x2,x2,#48+	stp	x14,x15,[x0,#32]++	bl	__add_mod_384+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0,#48]+	stp	x12,x13,[x0,#64]+	stp	x14,x15,[x0,#80]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret+++.globl	_rshift_mod_384+.private_extern	_rshift_mod_384++.align	5+_rshift_mod_384:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]+	ldp	x14,x15,[x1,#32]++	ldp	x4,x5,[x3]+	ldp	x6,x7,[x3,#16]+	ldp	x8,x9,[x3,#32]++Loop_rshift_mod_384:+	sub	x2,x2,#1+	bl	__rshift_mod_384+	cbnz	x2,Loop_rshift_mod_384++	ldr	x30,[sp,#8]+	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]+	stp	x14,x15,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret++++.align	5+__rshift_mod_384:+	sbfx	x22,x10,#0,#1+	and	x16,x22,x4+	and	x17,x22,x5+	adds	x10,x10,x16+	and	x19,x22,x6+	adcs	x11,x11,x17+	and	x20,x22,x7+	adcs	x12,x12,x19+	and	x21,x22,x8+	adcs	x13,x13,x20+	and	x22,x22,x9+	adcs	x14,x14,x21+	extr	x10,x11,x10,#1	// a[0:5] >>= 1+	adcs	x15,x15,x22+	extr	x11,x12,x11,#1+	adc	x22,xzr,xzr+	extr	x12,x13,x12,#1+	extr	x13,x14,x13,#1+	extr	x14,x15,x14,#1+	extr	x15,x22,x15,#1+	ret+++.globl	_div_by_2_mod_384+.private_extern	_div_by_2_mod_384++.align	5+_div_by_2_mod_384:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]+	ldp	x14,x15,[x1,#32]++	ldp	x4,x5,[x2]+	ldp	x6,x7,[x2,#16]+	ldp	x8,x9,[x2,#32]++	bl	__rshift_mod_384++	ldr	x30,[sp,#8]+	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]+	stp	x14,x15,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret+++.globl	_lshift_mod_384+.private_extern	_lshift_mod_384++.align	5+_lshift_mod_384:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]+	ldp	x14,x15,[x1,#32]++	ldp	x4,x5,[x3]+	ldp	x6,x7,[x3,#16]+	ldp	x8,x9,[x3,#32]++Loop_lshift_mod_384:+	sub	x2,x2,#1+	bl	__lshift_mod_384+	cbnz	x2,Loop_lshift_mod_384++	ldr	x30,[sp,#8]+	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]+	stp	x14,x15,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret++++.align	5+__lshift_mod_384:+	adds	x10,x10,x10+	adcs	x11,x11,x11+	adcs	x12,x12,x12+	adcs	x13,x13,x13+	adcs	x14,x14,x14+	adcs	x15,x15,x15+	adc	x3,xzr,xzr++	subs	x16,x10,x4+	sbcs	x17,x11,x5+	sbcs	x19,x12,x6+	sbcs	x20,x13,x7+	sbcs	x21,x14,x8+	sbcs	x22,x15,x9+	sbcs	xzr,x3,xzr++	csel	x10,x10,x16,lo+	csel	x11,x11,x17,lo+	csel	x12,x12,x19,lo+	csel	x13,x13,x20,lo+	csel	x14,x14,x21,lo+	csel	x15,x15,x22,lo++	ret+++.globl	_mul_by_3_mod_384+.private_extern	_mul_by_3_mod_384++.align	5+_mul_by_3_mod_384:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]+	ldp	x14,x15,[x1,#32]++	ldp	x4,x5,[x2]+	ldp	x6,x7,[x2,#16]+	ldp	x8,x9,[x2,#32]++	bl	__lshift_mod_384++	ldp	x16,x17,[x1]+	ldp	x19,x20,[x1,#16]+	ldp	x21,x22,[x1,#32]++	bl	__add_mod_384_ab_are_loaded+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]+	stp	x14,x15,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret+++.globl	_mul_by_8_mod_384+.private_extern	_mul_by_8_mod_384++.align	5+_mul_by_8_mod_384:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]+	ldp	x14,x15,[x1,#32]++	ldp	x4,x5,[x2]+	ldp	x6,x7,[x2,#16]+	ldp	x8,x9,[x2,#32]++	bl	__lshift_mod_384+	bl	__lshift_mod_384+	bl	__lshift_mod_384+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]+	stp	x14,x15,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret+++.globl	_mul_by_3_mod_384x+.private_extern	_mul_by_3_mod_384x++.align	5+_mul_by_3_mod_384x:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]+	ldp	x14,x15,[x1,#32]++	ldp	x4,x5,[x2]+	ldp	x6,x7,[x2,#16]+	ldp	x8,x9,[x2,#32]++	bl	__lshift_mod_384++	ldp	x16,x17,[x1]+	ldp	x19,x20,[x1,#16]+	ldp	x21,x22,[x1,#32]++	bl	__add_mod_384_ab_are_loaded++	stp	x10,x11,[x0]+	ldp	x10,x11,[x1,#48]+	stp	x12,x13,[x0,#16]+	ldp	x12,x13,[x1,#64]+	stp	x14,x15,[x0,#32]+	ldp	x14,x15,[x1,#80]++	bl	__lshift_mod_384++	ldp	x16,x17,[x1,#48]+	ldp	x19,x20,[x1,#64]+	ldp	x21,x22,[x1,#80]++	bl	__add_mod_384_ab_are_loaded+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0,#48]+	stp	x12,x13,[x0,#64]+	stp	x14,x15,[x0,#80]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret+++.globl	_mul_by_8_mod_384x+.private_extern	_mul_by_8_mod_384x++.align	5+_mul_by_8_mod_384x:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]+	ldp	x14,x15,[x1,#32]++	ldp	x4,x5,[x2]+	ldp	x6,x7,[x2,#16]+	ldp	x8,x9,[x2,#32]++	bl	__lshift_mod_384+	bl	__lshift_mod_384+	bl	__lshift_mod_384++	stp	x10,x11,[x0]+	ldp	x10,x11,[x1,#48]+	stp	x12,x13,[x0,#16]+	ldp	x12,x13,[x1,#64]+	stp	x14,x15,[x0,#32]+	ldp	x14,x15,[x1,#80]++	bl	__lshift_mod_384+	bl	__lshift_mod_384+	bl	__lshift_mod_384+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0,#48]+	stp	x12,x13,[x0,#64]+	stp	x14,x15,[x0,#80]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret+++.globl	_cneg_mod_384+.private_extern	_cneg_mod_384++.align	5+_cneg_mod_384:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x10,x11,[x1]+	ldp	x4,x5,[x3]+	ldp	x12,x13,[x1,#16]+	ldp	x6,x7,[x3,#16]++	subs	x16,x4,x10+	ldp	x14,x15,[x1,#32]+	ldp	x8,x9,[x3,#32]+	orr	x3,x10,x11+	sbcs	x17,x5,x11+	orr	x3,x3,x12+	sbcs	x19,x6,x12+	orr	x3,x3,x13+	sbcs	x20,x7,x13+	orr	x3,x3,x14+	sbcs	x21,x8,x14+	orr	x3,x3,x15+	sbc	x22,x9,x15++	cmp	x3,#0+	csetm	x3,ne+	ands	x2,x2,x3++	csel	x10,x10,x16,eq+	csel	x11,x11,x17,eq+	csel	x12,x12,x19,eq+	csel	x13,x13,x20,eq+	stp	x10,x11,[x0]+	csel	x14,x14,x21,eq+	stp	x12,x13,[x0,#16]+	csel	x15,x15,x22,eq+	stp	x14,x15,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret+++.globl	_sub_mod_384+.private_extern	_sub_mod_384++.align	5+_sub_mod_384:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x4,x5,[x3]+	ldp	x6,x7,[x3,#16]+	ldp	x8,x9,[x3,#32]++	bl	__sub_mod_384+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]+	stp	x14,x15,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret++++.align	5+__sub_mod_384:+	ldp	x10,x11,[x1]+	ldp	x16,x17,[x2]+	ldp	x12,x13,[x1,#16]+	ldp	x19,x20,[x2,#16]+	ldp	x14,x15,[x1,#32]+	ldp	x21,x22,[x2,#32]++	subs	x10,x10,x16+	sbcs	x11,x11,x17+	sbcs	x12,x12,x19+	sbcs	x13,x13,x20+	sbcs	x14,x14,x21+	sbcs	x15,x15,x22+	sbc	x3,xzr,xzr++	and	x16,x4,x3+	and	x17,x5,x3+	adds	x10,x10,x16+	and	x19,x6,x3+	adcs	x11,x11,x17+	and	x20,x7,x3+	adcs	x12,x12,x19+	and	x21,x8,x3+	adcs	x13,x13,x20+	and	x22,x9,x3+	adcs	x14,x14,x21+	adc	x15,x15,x22++	ret+++.globl	_sub_mod_384x+.private_extern	_sub_mod_384x++.align	5+_sub_mod_384x:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x4,x5,[x3]+	ldp	x6,x7,[x3,#16]+	ldp	x8,x9,[x3,#32]++	bl	__sub_mod_384++	stp	x10,x11,[x0]+	add	x1,x1,#48+	stp	x12,x13,[x0,#16]+	add	x2,x2,#48+	stp	x14,x15,[x0,#32]++	bl	__sub_mod_384+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0,#48]+	stp	x12,x13,[x0,#64]+	stp	x14,x15,[x0,#80]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret+++.globl	_mul_by_1_plus_i_mod_384x+.private_extern	_mul_by_1_plus_i_mod_384x++.align	5+_mul_by_1_plus_i_mod_384x:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x4,x5,[x2]+	ldp	x6,x7,[x2,#16]+	ldp	x8,x9,[x2,#32]+	add	x2,x1,#48++	bl	__sub_mod_384			// a->re - a->im++	ldp	x16,x17,[x1]+	ldp	x19,x20,[x1,#16]+	ldp	x21,x22,[x1,#32]+	stp	x10,x11,[x0]+	ldp	x10,x11,[x1,#48]+	stp	x12,x13,[x0,#16]+	ldp	x12,x13,[x1,#64]+	stp	x14,x15,[x0,#32]+	ldp	x14,x15,[x1,#80]++	bl	__add_mod_384_ab_are_loaded	// a->re + a->im+	ldr	x30,[sp,#8]++	stp	x10,x11,[x0,#48]+	stp	x12,x13,[x0,#64]+	stp	x14,x15,[x0,#80]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret+++.globl	_sgn0_pty_mod_384+.private_extern	_sgn0_pty_mod_384++.align	5+_sgn0_pty_mod_384:+	ldp	x10,x11,[x0]+	ldp	x12,x13,[x0,#16]+	ldp	x14,x15,[x0,#32]++	ldp	x4,x5,[x1]+	ldp	x6,x7,[x1,#16]+	ldp	x8,x9,[x1,#32]++	and	x0,x10,#1+	adds	x10,x10,x10+	adcs	x11,x11,x11+	adcs	x12,x12,x12+	adcs	x13,x13,x13+	adcs	x14,x14,x14+	adcs	x15,x15,x15+	adc	x3,xzr,xzr++	subs	x10,x10,x4+	sbcs	x11,x11,x5+	sbcs	x12,x12,x6+	sbcs	x13,x13,x7+	sbcs	x14,x14,x8+	sbcs	x15,x15,x9+	sbc	x3,x3,xzr++	mvn	x3,x3+	and	x3,x3,#2+	orr	x0,x0,x3++	ret+++.globl	_sgn0_pty_mod_384x+.private_extern	_sgn0_pty_mod_384x++.align	5+_sgn0_pty_mod_384x:+	ldp	x10,x11,[x0]+	ldp	x12,x13,[x0,#16]+	ldp	x14,x15,[x0,#32]++	ldp	x4,x5,[x1]+	ldp	x6,x7,[x1,#16]+	ldp	x8,x9,[x1,#32]++	and	x2,x10,#1+	orr	x3,x10,x11+	adds	x10,x10,x10+	orr	x3,x3,x12+	adcs	x11,x11,x11+	orr	x3,x3,x13+	adcs	x12,x12,x12+	orr	x3,x3,x14+	adcs	x13,x13,x13+	orr	x3,x3,x15+	adcs	x14,x14,x14+	adcs	x15,x15,x15+	adc	x16,xzr,xzr++	subs	x10,x10,x4+	sbcs	x11,x11,x5+	sbcs	x12,x12,x6+	sbcs	x13,x13,x7+	sbcs	x14,x14,x8+	sbcs	x15,x15,x9+	sbc	x16,x16,xzr++	ldp	x10,x11,[x0,#48]+	ldp	x12,x13,[x0,#64]+	ldp	x14,x15,[x0,#80]++	mvn	x16,x16+	and	x16,x16,#2+	orr	x2,x2,x16++	and	x0,x10,#1+	orr	x1,x10,x11+	adds	x10,x10,x10+	orr	x1,x1,x12+	adcs	x11,x11,x11+	orr	x1,x1,x13+	adcs	x12,x12,x12+	orr	x1,x1,x14+	adcs	x13,x13,x13+	orr	x1,x1,x15+	adcs	x14,x14,x14+	adcs	x15,x15,x15+	adc	x16,xzr,xzr++	subs	x10,x10,x4+	sbcs	x11,x11,x5+	sbcs	x12,x12,x6+	sbcs	x13,x13,x7+	sbcs	x14,x14,x8+	sbcs	x15,x15,x9+	sbc	x16,x16,xzr++	mvn	x16,x16+	and	x16,x16,#2+	orr	x0,x0,x16++	cmp	x3,#0+	csel	x3,x0,x2,eq	// a->re==0? prty(a->im) : prty(a->re)++	cmp	x1,#0+	csel	x1,x0,x2,ne	// a->im!=0? sgn0(a->im) : sgn0(a->re)++	and	x3,x3,#1+	and	x1,x1,#2+	orr	x0,x1,x3	// pack sign and parity++	ret++.globl	_vec_select_48+.private_extern	_vec_select_48++.align	5+_vec_select_48:+	dup	v6.2d, x3+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	cmeq	v6.2d, v6.2d, #0+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v0.16b, v3.16b, v6.16b+	bit	v1.16b, v4.16b, v6.16b+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0]+	ret++.globl	_vec_select_96+.private_extern	_vec_select_96++.align	5+_vec_select_96:+	dup	v6.2d, x3+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	cmeq	v6.2d, v6.2d, #0+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v0.16b, v3.16b, v6.16b+	ld1	{v16.2d, v17.2d, v18.2d}, [x1],#48+	bit	v1.16b, v4.16b, v6.16b+	ld1	{v19.2d, v20.2d, v21.2d}, [x2],#48+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0],#48+	bit	v16.16b, v19.16b, v6.16b+	bit	v17.16b, v20.16b, v6.16b+	bit	v18.16b, v21.16b, v6.16b+	st1	{v16.2d, v17.2d, v18.2d}, [x0]+	ret++.globl	_vec_select_192+.private_extern	_vec_select_192++.align	5+_vec_select_192:+	dup	v6.2d, x3+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	cmeq	v6.2d, v6.2d, #0+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v0.16b, v3.16b, v6.16b+	ld1	{v16.2d, v17.2d, v18.2d}, [x1],#48+	bit	v1.16b, v4.16b, v6.16b+	ld1	{v19.2d, v20.2d, v21.2d}, [x2],#48+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0],#48+	bit	v16.16b, v19.16b, v6.16b+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	bit	v17.16b, v20.16b, v6.16b+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v18.16b, v21.16b, v6.16b+	st1	{v16.2d, v17.2d, v18.2d}, [x0],#48+	bit	v0.16b, v3.16b, v6.16b+	ld1	{v16.2d, v17.2d, v18.2d}, [x1],#48+	bit	v1.16b, v4.16b, v6.16b+	ld1	{v19.2d, v20.2d, v21.2d}, [x2],#48+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0],#48+	bit	v16.16b, v19.16b, v6.16b+	bit	v17.16b, v20.16b, v6.16b+	bit	v18.16b, v21.16b, v6.16b+	st1	{v16.2d, v17.2d, v18.2d}, [x0]+	ret++.globl	_vec_select_144+.private_extern	_vec_select_144++.align	5+_vec_select_144:+	dup	v6.2d, x3+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	cmeq	v6.2d, v6.2d, #0+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v0.16b, v3.16b, v6.16b+	ld1	{v16.2d, v17.2d, v18.2d}, [x1],#48+	bit	v1.16b, v4.16b, v6.16b+	ld1	{v19.2d, v20.2d, v21.2d}, [x2],#48+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0],#48+	bit	v16.16b, v19.16b, v6.16b+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	bit	v17.16b, v20.16b, v6.16b+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v18.16b, v21.16b, v6.16b+	st1	{v16.2d, v17.2d, v18.2d}, [x0],#48+	bit	v0.16b, v3.16b, v6.16b+	bit	v1.16b, v4.16b, v6.16b+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0]+	ret++.globl	_vec_select_288+.private_extern	_vec_select_288++.align	5+_vec_select_288:+	dup	v6.2d, x3+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	cmeq	v6.2d, v6.2d, #0+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v0.16b, v3.16b, v6.16b+	ld1	{v16.2d, v17.2d, v18.2d}, [x1],#48+	bit	v1.16b, v4.16b, v6.16b+	ld1	{v19.2d, v20.2d, v21.2d}, [x2],#48+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0],#48+	bit	v16.16b, v19.16b, v6.16b+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	bit	v17.16b, v20.16b, v6.16b+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v18.16b, v21.16b, v6.16b+	st1	{v16.2d, v17.2d, v18.2d}, [x0],#48+	bit	v0.16b, v3.16b, v6.16b+	ld1	{v16.2d, v17.2d, v18.2d}, [x1],#48+	bit	v1.16b, v4.16b, v6.16b+	ld1	{v19.2d, v20.2d, v21.2d}, [x2],#48+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0],#48+	bit	v16.16b, v19.16b, v6.16b+	ld1	{v0.2d, v1.2d, v2.2d}, [x1],#48+	bit	v17.16b, v20.16b, v6.16b+	ld1	{v3.2d, v4.2d, v5.2d}, [x2],#48+	bit	v18.16b, v21.16b, v6.16b+	st1	{v16.2d, v17.2d, v18.2d}, [x0],#48+	bit	v0.16b, v3.16b, v6.16b+	ld1	{v16.2d, v17.2d, v18.2d}, [x1],#48+	bit	v1.16b, v4.16b, v6.16b+	ld1	{v19.2d, v20.2d, v21.2d}, [x2],#48+	bit	v2.16b, v5.16b, v6.16b+	st1	{v0.2d, v1.2d, v2.2d}, [x0],#48+	bit	v16.16b, v19.16b, v6.16b+	bit	v17.16b, v20.16b, v6.16b+	bit	v18.16b, v21.16b, v6.16b+	st1	{v16.2d, v17.2d, v18.2d}, [x0]+	ret++.globl	_vec_prefetch+.private_extern	_vec_prefetch++.align	5+_vec_prefetch:+	add	x1, x1, x0+	sub	x1, x1, #1+	mov	x2, #64+	prfm	pldl1keep, [x0]+	add	x0, x0, x2+	cmp	x0, x1+	csel	x0, x1, x0, hi+	csel	x2, xzr, x2, hi+	prfm	pldl1keep, [x0]+	add	x0, x0, x2+	cmp	x0, x1+	csel	x0, x1, x0, hi+	csel	x2, xzr, x2, hi+	prfm	pldl1keep, [x0]+	add	x0, x0, x2+	cmp	x0, x1+	csel	x0, x1, x0, hi+	csel	x2, xzr, x2, hi+	prfm	pldl1keep, [x0]+	add	x0, x0, x2+	cmp	x0, x1+	csel	x0, x1, x0, hi+	csel	x2, xzr, x2, hi+	prfm	pldl1keep, [x0]+	add	x0, x0, x2+	cmp	x0, x1+	csel	x0, x1, x0, hi+	csel	x2, xzr, x2, hi+	prfm	pldl1keep, [x0]+	add	x0, x0, x2+	cmp	x0, x1+	csel	x0, x1, x0, hi+	prfm	pldl1keep, [x0]+	ret+
+ c-source/build/mach-o/add_mod_384-x86_64.s view
@@ -0,0 +1,1801 @@+.text	++.globl	_add_mod_384+.private_extern	_add_mod_384++.p2align	5+_add_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	call	__add_mod_384++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	++++.p2align	5+__add_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++__add_mod_384_a_is_loaded:+	addq	0(%rdx),%r8+	adcq	8(%rdx),%r9+	adcq	16(%rdx),%r10+	movq	%r8,%r14+	adcq	24(%rdx),%r11+	movq	%r9,%r15+	adcq	32(%rdx),%r12+	movq	%r10,%rax+	adcq	40(%rdx),%r13+	movq	%r11,%rbx+	sbbq	%rdx,%rdx++	subq	0(%rcx),%r8+	sbbq	8(%rcx),%r9+	movq	%r12,%rbp+	sbbq	16(%rcx),%r10+	sbbq	24(%rcx),%r11+	sbbq	32(%rcx),%r12+	movq	%r13,%rsi+	sbbq	40(%rcx),%r13+	sbbq	$0,%rdx++	cmovcq	%r14,%r8+	cmovcq	%r15,%r9+	cmovcq	%rax,%r10+	movq	%r8,0(%rdi)+	cmovcq	%rbx,%r11+	movq	%r9,8(%rdi)+	cmovcq	%rbp,%r12+	movq	%r10,16(%rdi)+	cmovcq	%rsi,%r13+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+++.globl	_add_mod_384x+.private_extern	_add_mod_384x++.p2align	5+_add_mod_384x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$24,%rsp+.cfi_adjust_cfa_offset	24+++	movq	%rsi,0(%rsp)+	movq	%rdx,8(%rsp)+	leaq	48(%rsi),%rsi+	leaq	48(%rdx),%rdx+	leaq	48(%rdi),%rdi+	call	__add_mod_384++	movq	0(%rsp),%rsi+	movq	8(%rsp),%rdx+	leaq	-48(%rdi),%rdi+	call	__add_mod_384++	movq	24+0(%rsp),%r15+.cfi_restore	%r15+	movq	24+8(%rsp),%r14+.cfi_restore	%r14+	movq	24+16(%rsp),%r13+.cfi_restore	%r13+	movq	24+24(%rsp),%r12+.cfi_restore	%r12+	movq	24+32(%rsp),%rbx+.cfi_restore	%rbx+	movq	24+40(%rsp),%rbp+.cfi_restore	%rbp+	leaq	24+48(%rsp),%rsp+.cfi_adjust_cfa_offset	-24-8*6++	.byte	0xf3,0xc3+.cfi_endproc	++++.globl	_rshift_mod_384+.private_extern	_rshift_mod_384++.p2align	5+_rshift_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	pushq	%rdi+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++L$oop_rshift_mod_384:+	call	__rshift_mod_384+	decl	%edx+	jnz	L$oop_rshift_mod_384++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	++++.p2align	5+__rshift_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	$1,%rsi+	movq	0(%rcx),%r14+	andq	%r8,%rsi+	movq	8(%rcx),%r15+	negq	%rsi+	movq	16(%rcx),%rax+	andq	%rsi,%r14+	movq	24(%rcx),%rbx+	andq	%rsi,%r15+	movq	32(%rcx),%rbp+	andq	%rsi,%rax+	andq	%rsi,%rbx+	andq	%rsi,%rbp+	andq	40(%rcx),%rsi++	addq	%r8,%r14+	adcq	%r9,%r15+	adcq	%r10,%rax+	adcq	%r11,%rbx+	adcq	%r12,%rbp+	adcq	%r13,%rsi+	sbbq	%r13,%r13++	shrq	$1,%r14+	movq	%r15,%r8+	shrq	$1,%r15+	movq	%rax,%r9+	shrq	$1,%rax+	movq	%rbx,%r10+	shrq	$1,%rbx+	movq	%rbp,%r11+	shrq	$1,%rbp+	movq	%rsi,%r12+	shrq	$1,%rsi+	shlq	$63,%r8+	shlq	$63,%r9+	orq	%r14,%r8+	shlq	$63,%r10+	orq	%r15,%r9+	shlq	$63,%r11+	orq	%rax,%r10+	shlq	$63,%r12+	orq	%rbx,%r11+	shlq	$63,%r13+	orq	%rbp,%r12+	orq	%rsi,%r13++	.byte	0xf3,0xc3+.cfi_endproc+++.globl	_div_by_2_mod_384+.private_extern	_div_by_2_mod_384++.p2align	5+_div_by_2_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	pushq	%rdi+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%r8+	movq	%rdx,%rcx+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	call	__rshift_mod_384++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	++++.globl	_lshift_mod_384+.private_extern	_lshift_mod_384++.p2align	5+_lshift_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	pushq	%rdi+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++L$oop_lshift_mod_384:+	addq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	movq	%r8,%r14+	adcq	%r11,%r11+	movq	%r9,%r15+	adcq	%r12,%r12+	movq	%r10,%rax+	adcq	%r13,%r13+	movq	%r11,%rbx+	sbbq	%rdi,%rdi++	subq	0(%rcx),%r8+	sbbq	8(%rcx),%r9+	movq	%r12,%rbp+	sbbq	16(%rcx),%r10+	sbbq	24(%rcx),%r11+	sbbq	32(%rcx),%r12+	movq	%r13,%rsi+	sbbq	40(%rcx),%r13+	sbbq	$0,%rdi++	movq	(%rsp),%rdi+	cmovcq	%r14,%r8+	cmovcq	%r15,%r9+	cmovcq	%rax,%r10+	cmovcq	%rbx,%r11+	cmovcq	%rbp,%r12+	cmovcq	%rsi,%r13++	decl	%edx+	jnz	L$oop_lshift_mod_384++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	++++.p2align	5+__lshift_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	addq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	movq	%r8,%r14+	adcq	%r11,%r11+	movq	%r9,%r15+	adcq	%r12,%r12+	movq	%r10,%rax+	adcq	%r13,%r13+	movq	%r11,%rbx+	sbbq	%rdx,%rdx++	subq	0(%rcx),%r8+	sbbq	8(%rcx),%r9+	movq	%r12,%rbp+	sbbq	16(%rcx),%r10+	sbbq	24(%rcx),%r11+	sbbq	32(%rcx),%r12+	movq	%r13,%rsi+	sbbq	40(%rcx),%r13+	sbbq	$0,%rdx++	cmovcq	%r14,%r8+	cmovcq	%r15,%r9+	cmovcq	%rax,%r10+	cmovcq	%rbx,%r11+	cmovcq	%rbp,%r12+	cmovcq	%rsi,%r13++	.byte	0xf3,0xc3+.cfi_endproc++++.globl	_mul_by_3_mod_384+.private_extern	_mul_by_3_mod_384++.p2align	5+_mul_by_3_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	pushq	%rsi+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	%rdx,%rcx++	call	__lshift_mod_384++	movq	(%rsp),%rdx+	call	__add_mod_384_a_is_loaded++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+++.globl	_mul_by_8_mod_384+.private_extern	_mul_by_8_mod_384++.p2align	5+_mul_by_8_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	%rdx,%rcx++	call	__lshift_mod_384+	call	__lshift_mod_384+	call	__lshift_mod_384++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	++++.globl	_mul_by_3_mod_384x+.private_extern	_mul_by_3_mod_384x++.p2align	5+_mul_by_3_mod_384x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	pushq	%rsi+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	%rdx,%rcx++	call	__lshift_mod_384++	movq	(%rsp),%rdx+	call	__add_mod_384_a_is_loaded++	movq	(%rsp),%rsi+	leaq	48(%rdi),%rdi++	movq	48(%rsi),%r8+	movq	56(%rsi),%r9+	movq	64(%rsi),%r10+	movq	72(%rsi),%r11+	movq	80(%rsi),%r12+	movq	88(%rsi),%r13++	call	__lshift_mod_384++	movq	$48,%rdx+	addq	(%rsp),%rdx+	call	__add_mod_384_a_is_loaded++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+++.globl	_mul_by_8_mod_384x+.private_extern	_mul_by_8_mod_384x++.p2align	5+_mul_by_8_mod_384x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	pushq	%rsi+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	%rdx,%rcx++	call	__lshift_mod_384+	call	__lshift_mod_384+	call	__lshift_mod_384++	movq	(%rsp),%rsi+	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	movq	48+0(%rsi),%r8+	movq	48+8(%rsi),%r9+	movq	48+16(%rsi),%r10+	movq	48+24(%rsi),%r11+	movq	48+32(%rsi),%r12+	movq	48+40(%rsi),%r13++	call	__lshift_mod_384+	call	__lshift_mod_384+	call	__lshift_mod_384++	movq	%r8,48+0(%rdi)+	movq	%r9,48+8(%rdi)+	movq	%r10,48+16(%rdi)+	movq	%r11,48+24(%rdi)+	movq	%r12,48+32(%rdi)+	movq	%r13,48+40(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	++++.globl	_cneg_mod_384+.private_extern	_cneg_mod_384++.p2align	5+_cneg_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	pushq	%rdx+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%rdx+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	%rdx,%r8+	movq	24(%rsi),%r11+	orq	%r9,%rdx+	movq	32(%rsi),%r12+	orq	%r10,%rdx+	movq	40(%rsi),%r13+	orq	%r11,%rdx+	movq	$-1,%rsi+	orq	%r12,%rdx+	orq	%r13,%rdx++	movq	0(%rcx),%r14+	cmovnzq	%rsi,%rdx+	movq	8(%rcx),%r15+	movq	16(%rcx),%rax+	andq	%rdx,%r14+	movq	24(%rcx),%rbx+	andq	%rdx,%r15+	movq	32(%rcx),%rbp+	andq	%rdx,%rax+	movq	40(%rcx),%rsi+	andq	%rdx,%rbx+	movq	0(%rsp),%rcx+	andq	%rdx,%rbp+	andq	%rdx,%rsi++	subq	%r8,%r14+	sbbq	%r9,%r15+	sbbq	%r10,%rax+	sbbq	%r11,%rbx+	sbbq	%r12,%rbp+	sbbq	%r13,%rsi++	orq	%rcx,%rcx++	cmovzq	%r8,%r14+	cmovzq	%r9,%r15+	cmovzq	%r10,%rax+	movq	%r14,0(%rdi)+	cmovzq	%r11,%rbx+	movq	%r15,8(%rdi)+	cmovzq	%r12,%rbp+	movq	%rax,16(%rdi)+	cmovzq	%r13,%rsi+	movq	%rbx,24(%rdi)+	movq	%rbp,32(%rdi)+	movq	%rsi,40(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	++++.globl	_sub_mod_384+.private_extern	_sub_mod_384++.p2align	5+_sub_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	call	__sub_mod_384++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	++++.p2align	5+__sub_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	subq	0(%rdx),%r8+	movq	0(%rcx),%r14+	sbbq	8(%rdx),%r9+	movq	8(%rcx),%r15+	sbbq	16(%rdx),%r10+	movq	16(%rcx),%rax+	sbbq	24(%rdx),%r11+	movq	24(%rcx),%rbx+	sbbq	32(%rdx),%r12+	movq	32(%rcx),%rbp+	sbbq	40(%rdx),%r13+	movq	40(%rcx),%rsi+	sbbq	%rdx,%rdx++	andq	%rdx,%r14+	andq	%rdx,%r15+	andq	%rdx,%rax+	andq	%rdx,%rbx+	andq	%rdx,%rbp+	andq	%rdx,%rsi++	addq	%r14,%r8+	adcq	%r15,%r9+	movq	%r8,0(%rdi)+	adcq	%rax,%r10+	movq	%r9,8(%rdi)+	adcq	%rbx,%r11+	movq	%r10,16(%rdi)+	adcq	%rbp,%r12+	movq	%r11,24(%rdi)+	adcq	%rsi,%r13+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+++.globl	_sub_mod_384x+.private_extern	_sub_mod_384x++.p2align	5+_sub_mod_384x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$24,%rsp+.cfi_adjust_cfa_offset	24+++	movq	%rsi,0(%rsp)+	movq	%rdx,8(%rsp)+	leaq	48(%rsi),%rsi+	leaq	48(%rdx),%rdx+	leaq	48(%rdi),%rdi+	call	__sub_mod_384++	movq	0(%rsp),%rsi+	movq	8(%rsp),%rdx+	leaq	-48(%rdi),%rdi+	call	__sub_mod_384++	movq	24+0(%rsp),%r15+.cfi_restore	%r15+	movq	24+8(%rsp),%r14+.cfi_restore	%r14+	movq	24+16(%rsp),%r13+.cfi_restore	%r13+	movq	24+24(%rsp),%r12+.cfi_restore	%r12+	movq	24+32(%rsp),%rbx+.cfi_restore	%rbx+	movq	24+40(%rsp),%rbp+.cfi_restore	%rbp+	leaq	24+48(%rsp),%rsp+.cfi_adjust_cfa_offset	-24-8*6++	.byte	0xf3,0xc3+.cfi_endproc	++.globl	_mul_by_1_plus_i_mod_384x+.private_extern	_mul_by_1_plus_i_mod_384x++.p2align	5+_mul_by_1_plus_i_mod_384x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$56,%rsp+.cfi_adjust_cfa_offset	56+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%r8,%r14+	addq	48(%rsi),%r8+	movq	%r9,%r15+	adcq	56(%rsi),%r9+	movq	%r10,%rax+	adcq	64(%rsi),%r10+	movq	%r11,%rbx+	adcq	72(%rsi),%r11+	movq	%r12,%rcx+	adcq	80(%rsi),%r12+	movq	%r13,%rbp+	adcq	88(%rsi),%r13+	movq	%rdi,48(%rsp)+	sbbq	%rdi,%rdi++	subq	48(%rsi),%r14+	sbbq	56(%rsi),%r15+	sbbq	64(%rsi),%rax+	sbbq	72(%rsi),%rbx+	sbbq	80(%rsi),%rcx+	sbbq	88(%rsi),%rbp+	sbbq	%rsi,%rsi++	movq	%r8,0(%rsp)+	movq	0(%rdx),%r8+	movq	%r9,8(%rsp)+	movq	8(%rdx),%r9+	movq	%r10,16(%rsp)+	movq	16(%rdx),%r10+	movq	%r11,24(%rsp)+	movq	24(%rdx),%r11+	movq	%r12,32(%rsp)+	andq	%rsi,%r8+	movq	32(%rdx),%r12+	movq	%r13,40(%rsp)+	andq	%rsi,%r9+	movq	40(%rdx),%r13+	andq	%rsi,%r10+	andq	%rsi,%r11+	andq	%rsi,%r12+	andq	%rsi,%r13+	movq	48(%rsp),%rsi++	addq	%r8,%r14+	movq	0(%rsp),%r8+	adcq	%r9,%r15+	movq	8(%rsp),%r9+	adcq	%r10,%rax+	movq	16(%rsp),%r10+	adcq	%r11,%rbx+	movq	24(%rsp),%r11+	adcq	%r12,%rcx+	movq	32(%rsp),%r12+	adcq	%r13,%rbp+	movq	40(%rsp),%r13++	movq	%r14,0(%rsi)+	movq	%r8,%r14+	movq	%r15,8(%rsi)+	movq	%rax,16(%rsi)+	movq	%r9,%r15+	movq	%rbx,24(%rsi)+	movq	%rcx,32(%rsi)+	movq	%r10,%rax+	movq	%rbp,40(%rsi)++	subq	0(%rdx),%r8+	movq	%r11,%rbx+	sbbq	8(%rdx),%r9+	sbbq	16(%rdx),%r10+	movq	%r12,%rcx+	sbbq	24(%rdx),%r11+	sbbq	32(%rdx),%r12+	movq	%r13,%rbp+	sbbq	40(%rdx),%r13+	sbbq	$0,%rdi++	cmovcq	%r14,%r8+	cmovcq	%r15,%r9+	cmovcq	%rax,%r10+	movq	%r8,48(%rsi)+	cmovcq	%rbx,%r11+	movq	%r9,56(%rsi)+	cmovcq	%rcx,%r12+	movq	%r10,64(%rsi)+	cmovcq	%rbp,%r13+	movq	%r11,72(%rsi)+	movq	%r12,80(%rsi)+	movq	%r13,88(%rsi)++	movq	56+0(%rsp),%r15+.cfi_restore	%r15+	movq	56+8(%rsp),%r14+.cfi_restore	%r14+	movq	56+16(%rsp),%r13+.cfi_restore	%r13+	movq	56+24(%rsp),%r12+.cfi_restore	%r12+	movq	56+32(%rsp),%rbx+.cfi_restore	%rbx+	movq	56+40(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56+48(%rsp),%rsp+.cfi_adjust_cfa_offset	-56-8*6++	.byte	0xf3,0xc3+.cfi_endproc	++.globl	_sgn0_pty_mod_384+.private_extern	_sgn0_pty_mod_384++.p2align	5+_sgn0_pty_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++++	movq	0(%rdi),%r8+	movq	8(%rdi),%r9+	movq	16(%rdi),%r10+	movq	24(%rdi),%r11+	movq	32(%rdi),%rcx+	movq	40(%rdi),%rdx++	xorq	%rax,%rax+	movq	%r8,%rdi+	addq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	%rcx,%rcx+	adcq	%rdx,%rdx+	adcq	$0,%rax++	subq	0(%rsi),%r8+	sbbq	8(%rsi),%r9+	sbbq	16(%rsi),%r10+	sbbq	24(%rsi),%r11+	sbbq	32(%rsi),%rcx+	sbbq	40(%rsi),%rdx+	sbbq	$0,%rax++	notq	%rax+	andq	$1,%rdi+	andq	$2,%rax+	orq	%rdi,%rax+++	.byte	0xf3,0xc3+.cfi_endproc	+++.globl	_sgn0_pty_mod_384x+.private_extern	_sgn0_pty_mod_384x++.p2align	5+_sgn0_pty_mod_384x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	48(%rdi),%r8+	movq	56(%rdi),%r9+	movq	64(%rdi),%r10+	movq	72(%rdi),%r11+	movq	80(%rdi),%rcx+	movq	88(%rdi),%rdx++	movq	%r8,%rbx+	orq	%r9,%r8+	orq	%r10,%r8+	orq	%r11,%r8+	orq	%rcx,%r8+	orq	%rdx,%r8++	leaq	0(%rdi),%rax+	xorq	%rdi,%rdi+	movq	%rbx,%rbp+	addq	%rbx,%rbx+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	%rcx,%rcx+	adcq	%rdx,%rdx+	adcq	$0,%rdi++	subq	0(%rsi),%rbx+	sbbq	8(%rsi),%r9+	sbbq	16(%rsi),%r10+	sbbq	24(%rsi),%r11+	sbbq	32(%rsi),%rcx+	sbbq	40(%rsi),%rdx+	sbbq	$0,%rdi++	movq	%r8,0(%rsp)+	notq	%rdi+	andq	$1,%rbp+	andq	$2,%rdi+	orq	%rbp,%rdi++	movq	0(%rax),%r8+	movq	8(%rax),%r9+	movq	16(%rax),%r10+	movq	24(%rax),%r11+	movq	32(%rax),%rcx+	movq	40(%rax),%rdx++	movq	%r8,%rbx+	orq	%r9,%r8+	orq	%r10,%r8+	orq	%r11,%r8+	orq	%rcx,%r8+	orq	%rdx,%r8++	xorq	%rax,%rax+	movq	%rbx,%rbp+	addq	%rbx,%rbx+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	%rcx,%rcx+	adcq	%rdx,%rdx+	adcq	$0,%rax++	subq	0(%rsi),%rbx+	sbbq	8(%rsi),%r9+	sbbq	16(%rsi),%r10+	sbbq	24(%rsi),%r11+	sbbq	32(%rsi),%rcx+	sbbq	40(%rsi),%rdx+	sbbq	$0,%rax++	movq	0(%rsp),%rbx++	notq	%rax++	testq	%r8,%r8+	cmovzq	%rdi,%rbp++	testq	%rbx,%rbx+	cmovnzq	%rdi,%rax++	andq	$1,%rbp+	andq	$2,%rax+	orq	%rbp,%rax++	movq	8(%rsp),%rbx+.cfi_restore	%rbx+	movq	16(%rsp),%rbp+.cfi_restore	%rbp+	leaq	24(%rsp),%rsp+.cfi_adjust_cfa_offset	-24++	.byte	0xf3,0xc3+.cfi_endproc	++.globl	_vec_select_48+.private_extern	_vec_select_48++.p2align	5+_vec_select_48:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movd	%ecx,%xmm5+	pxor	%xmm4,%xmm4+	pshufd	$0,%xmm5,%xmm5+	movdqu	(%rsi),%xmm0+	leaq	24(%rsi),%rsi+	pcmpeqd	%xmm4,%xmm5+	movdqu	(%rdx),%xmm1+	leaq	24(%rdx),%rdx+	pcmpeqd	%xmm5,%xmm4+	leaq	24(%rdi),%rdi+	pand	%xmm4,%xmm0+	movdqu	0+16-24(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	0+16-24(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,0-24(%rdi)+	pand	%xmm4,%xmm2+	movdqu	16+16-24(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	16+16-24(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,16-24(%rdi)+	pand	%xmm4,%xmm0+	pand	%xmm5,%xmm1+	por	%xmm1,%xmm0+	movdqu	%xmm0,32-24(%rdi)+	.byte	0xf3,0xc3+.cfi_endproc++.globl	_vec_select_96+.private_extern	_vec_select_96++.p2align	5+_vec_select_96:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movd	%ecx,%xmm5+	pxor	%xmm4,%xmm4+	pshufd	$0,%xmm5,%xmm5+	movdqu	(%rsi),%xmm0+	leaq	48(%rsi),%rsi+	pcmpeqd	%xmm4,%xmm5+	movdqu	(%rdx),%xmm1+	leaq	48(%rdx),%rdx+	pcmpeqd	%xmm5,%xmm4+	leaq	48(%rdi),%rdi+	pand	%xmm4,%xmm0+	movdqu	0+16-48(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	0+16-48(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,0-48(%rdi)+	pand	%xmm4,%xmm2+	movdqu	16+16-48(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	16+16-48(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,16-48(%rdi)+	pand	%xmm4,%xmm0+	movdqu	32+16-48(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	32+16-48(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,32-48(%rdi)+	pand	%xmm4,%xmm2+	movdqu	48+16-48(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	48+16-48(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,48-48(%rdi)+	pand	%xmm4,%xmm0+	movdqu	64+16-48(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	64+16-48(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,64-48(%rdi)+	pand	%xmm4,%xmm2+	pand	%xmm5,%xmm3+	por	%xmm3,%xmm2+	movdqu	%xmm2,80-48(%rdi)+	.byte	0xf3,0xc3+.cfi_endproc++.globl	_vec_select_192+.private_extern	_vec_select_192++.p2align	5+_vec_select_192:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movd	%ecx,%xmm5+	pxor	%xmm4,%xmm4+	pshufd	$0,%xmm5,%xmm5+	movdqu	(%rsi),%xmm0+	leaq	96(%rsi),%rsi+	pcmpeqd	%xmm4,%xmm5+	movdqu	(%rdx),%xmm1+	leaq	96(%rdx),%rdx+	pcmpeqd	%xmm5,%xmm4+	leaq	96(%rdi),%rdi+	pand	%xmm4,%xmm0+	movdqu	0+16-96(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	0+16-96(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,0-96(%rdi)+	pand	%xmm4,%xmm2+	movdqu	16+16-96(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	16+16-96(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,16-96(%rdi)+	pand	%xmm4,%xmm0+	movdqu	32+16-96(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	32+16-96(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,32-96(%rdi)+	pand	%xmm4,%xmm2+	movdqu	48+16-96(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	48+16-96(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,48-96(%rdi)+	pand	%xmm4,%xmm0+	movdqu	64+16-96(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	64+16-96(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,64-96(%rdi)+	pand	%xmm4,%xmm2+	movdqu	80+16-96(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	80+16-96(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,80-96(%rdi)+	pand	%xmm4,%xmm0+	movdqu	96+16-96(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	96+16-96(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,96-96(%rdi)+	pand	%xmm4,%xmm2+	movdqu	112+16-96(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	112+16-96(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,112-96(%rdi)+	pand	%xmm4,%xmm0+	movdqu	128+16-96(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	128+16-96(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,128-96(%rdi)+	pand	%xmm4,%xmm2+	movdqu	144+16-96(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	144+16-96(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,144-96(%rdi)+	pand	%xmm4,%xmm0+	movdqu	160+16-96(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	160+16-96(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,160-96(%rdi)+	pand	%xmm4,%xmm2+	pand	%xmm5,%xmm3+	por	%xmm3,%xmm2+	movdqu	%xmm2,176-96(%rdi)+	.byte	0xf3,0xc3+.cfi_endproc++.globl	_vec_select_144+.private_extern	_vec_select_144++.p2align	5+_vec_select_144:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movd	%ecx,%xmm5+	pxor	%xmm4,%xmm4+	pshufd	$0,%xmm5,%xmm5+	movdqu	(%rsi),%xmm0+	leaq	72(%rsi),%rsi+	pcmpeqd	%xmm4,%xmm5+	movdqu	(%rdx),%xmm1+	leaq	72(%rdx),%rdx+	pcmpeqd	%xmm5,%xmm4+	leaq	72(%rdi),%rdi+	pand	%xmm4,%xmm0+	movdqu	0+16-72(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	0+16-72(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,0-72(%rdi)+	pand	%xmm4,%xmm2+	movdqu	16+16-72(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	16+16-72(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,16-72(%rdi)+	pand	%xmm4,%xmm0+	movdqu	32+16-72(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	32+16-72(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,32-72(%rdi)+	pand	%xmm4,%xmm2+	movdqu	48+16-72(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	48+16-72(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,48-72(%rdi)+	pand	%xmm4,%xmm0+	movdqu	64+16-72(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	64+16-72(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,64-72(%rdi)+	pand	%xmm4,%xmm2+	movdqu	80+16-72(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	80+16-72(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,80-72(%rdi)+	pand	%xmm4,%xmm0+	movdqu	96+16-72(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	96+16-72(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,96-72(%rdi)+	pand	%xmm4,%xmm2+	movdqu	112+16-72(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	112+16-72(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,112-72(%rdi)+	pand	%xmm4,%xmm0+	pand	%xmm5,%xmm1+	por	%xmm1,%xmm0+	movdqu	%xmm0,128-72(%rdi)+	.byte	0xf3,0xc3+.cfi_endproc++.globl	_vec_select_288+.private_extern	_vec_select_288++.p2align	5+_vec_select_288:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movd	%ecx,%xmm5+	pxor	%xmm4,%xmm4+	pshufd	$0,%xmm5,%xmm5+	movdqu	(%rsi),%xmm0+	leaq	144(%rsi),%rsi+	pcmpeqd	%xmm4,%xmm5+	movdqu	(%rdx),%xmm1+	leaq	144(%rdx),%rdx+	pcmpeqd	%xmm5,%xmm4+	leaq	144(%rdi),%rdi+	pand	%xmm4,%xmm0+	movdqu	0+16-144(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	0+16-144(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,0-144(%rdi)+	pand	%xmm4,%xmm2+	movdqu	16+16-144(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	16+16-144(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,16-144(%rdi)+	pand	%xmm4,%xmm0+	movdqu	32+16-144(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	32+16-144(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,32-144(%rdi)+	pand	%xmm4,%xmm2+	movdqu	48+16-144(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	48+16-144(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,48-144(%rdi)+	pand	%xmm4,%xmm0+	movdqu	64+16-144(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	64+16-144(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,64-144(%rdi)+	pand	%xmm4,%xmm2+	movdqu	80+16-144(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	80+16-144(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,80-144(%rdi)+	pand	%xmm4,%xmm0+	movdqu	96+16-144(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	96+16-144(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,96-144(%rdi)+	pand	%xmm4,%xmm2+	movdqu	112+16-144(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	112+16-144(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,112-144(%rdi)+	pand	%xmm4,%xmm0+	movdqu	128+16-144(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	128+16-144(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,128-144(%rdi)+	pand	%xmm4,%xmm2+	movdqu	144+16-144(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	144+16-144(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,144-144(%rdi)+	pand	%xmm4,%xmm0+	movdqu	160+16-144(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	160+16-144(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,160-144(%rdi)+	pand	%xmm4,%xmm2+	movdqu	176+16-144(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	176+16-144(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,176-144(%rdi)+	pand	%xmm4,%xmm0+	movdqu	192+16-144(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	192+16-144(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,192-144(%rdi)+	pand	%xmm4,%xmm2+	movdqu	208+16-144(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	208+16-144(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,208-144(%rdi)+	pand	%xmm4,%xmm0+	movdqu	224+16-144(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	224+16-144(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,224-144(%rdi)+	pand	%xmm4,%xmm2+	movdqu	240+16-144(%rsi),%xmm0+	pand	%xmm5,%xmm3+	movdqu	240+16-144(%rdx),%xmm1+	por	%xmm3,%xmm2+	movdqu	%xmm2,240-144(%rdi)+	pand	%xmm4,%xmm0+	movdqu	256+16-144(%rsi),%xmm2+	pand	%xmm5,%xmm1+	movdqu	256+16-144(%rdx),%xmm3+	por	%xmm1,%xmm0+	movdqu	%xmm0,256-144(%rdi)+	pand	%xmm4,%xmm2+	pand	%xmm5,%xmm3+	por	%xmm3,%xmm2+	movdqu	%xmm2,272-144(%rdi)+	.byte	0xf3,0xc3+.cfi_endproc++.globl	_vec_prefetch+.private_extern	_vec_prefetch++.p2align	5+_vec_prefetch:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	leaq	-1(%rdi,%rsi,1),%rsi+	movq	$64,%rax+	xorq	%r8,%r8+	prefetchnta	(%rdi)+	leaq	(%rdi,%rax,1),%rdi+	cmpq	%rsi,%rdi+	cmovaq	%rsi,%rdi+	cmovaq	%r8,%rax+	prefetchnta	(%rdi)+	leaq	(%rdi,%rax,1),%rdi+	cmpq	%rsi,%rdi+	cmovaq	%rsi,%rdi+	cmovaq	%r8,%rax+	prefetchnta	(%rdi)+	leaq	(%rdi,%rax,1),%rdi+	cmpq	%rsi,%rdi+	cmovaq	%rsi,%rdi+	cmovaq	%r8,%rax+	prefetchnta	(%rdi)+	leaq	(%rdi,%rax,1),%rdi+	cmpq	%rsi,%rdi+	cmovaq	%rsi,%rdi+	cmovaq	%r8,%rax+	prefetchnta	(%rdi)+	leaq	(%rdi,%rax,1),%rdi+	cmpq	%rsi,%rdi+	cmovaq	%rsi,%rdi+	cmovaq	%r8,%rax+	prefetchnta	(%rdi)+	leaq	(%rdi,%rax,1),%rdi+	cmpq	%rsi,%rdi+	cmovaq	%rsi,%rdi+	prefetchnta	(%rdi)+	.byte	0xf3,0xc3+.cfi_endproc+
+ c-source/build/mach-o/add_mod_384x384-x86_64.s view
@@ -0,0 +1,244 @@+.text	+++.p2align	5+__add_mod_384x384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	48(%rsi),%r14++	addq	0(%rdx),%r8+	movq	56(%rsi),%r15+	adcq	8(%rdx),%r9+	movq	64(%rsi),%rax+	adcq	16(%rdx),%r10+	movq	72(%rsi),%rbx+	adcq	24(%rdx),%r11+	movq	80(%rsi),%rbp+	adcq	32(%rdx),%r12+	movq	88(%rsi),%rsi+	adcq	40(%rdx),%r13+	movq	%r8,0(%rdi)+	adcq	48(%rdx),%r14+	movq	%r9,8(%rdi)+	adcq	56(%rdx),%r15+	movq	%r10,16(%rdi)+	adcq	64(%rdx),%rax+	movq	%r12,32(%rdi)+	movq	%r14,%r8+	adcq	72(%rdx),%rbx+	movq	%r11,24(%rdi)+	movq	%r15,%r9+	adcq	80(%rdx),%rbp+	movq	%r13,40(%rdi)+	movq	%rax,%r10+	adcq	88(%rdx),%rsi+	movq	%rbx,%r11+	sbbq	%rdx,%rdx++	subq	0(%rcx),%r14+	sbbq	8(%rcx),%r15+	movq	%rbp,%r12+	sbbq	16(%rcx),%rax+	sbbq	24(%rcx),%rbx+	sbbq	32(%rcx),%rbp+	movq	%rsi,%r13+	sbbq	40(%rcx),%rsi+	sbbq	$0,%rdx++	cmovcq	%r8,%r14+	cmovcq	%r9,%r15+	cmovcq	%r10,%rax+	movq	%r14,48(%rdi)+	cmovcq	%r11,%rbx+	movq	%r15,56(%rdi)+	cmovcq	%r12,%rbp+	movq	%rax,64(%rdi)+	cmovcq	%r13,%rsi+	movq	%rbx,72(%rdi)+	movq	%rbp,80(%rdi)+	movq	%rsi,88(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc++++.p2align	5+__sub_mod_384x384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	48(%rsi),%r14++	subq	0(%rdx),%r8+	movq	56(%rsi),%r15+	sbbq	8(%rdx),%r9+	movq	64(%rsi),%rax+	sbbq	16(%rdx),%r10+	movq	72(%rsi),%rbx+	sbbq	24(%rdx),%r11+	movq	80(%rsi),%rbp+	sbbq	32(%rdx),%r12+	movq	88(%rsi),%rsi+	sbbq	40(%rdx),%r13+	movq	%r8,0(%rdi)+	sbbq	48(%rdx),%r14+	movq	0(%rcx),%r8+	movq	%r9,8(%rdi)+	sbbq	56(%rdx),%r15+	movq	8(%rcx),%r9+	movq	%r10,16(%rdi)+	sbbq	64(%rdx),%rax+	movq	16(%rcx),%r10+	movq	%r11,24(%rdi)+	sbbq	72(%rdx),%rbx+	movq	24(%rcx),%r11+	movq	%r12,32(%rdi)+	sbbq	80(%rdx),%rbp+	movq	32(%rcx),%r12+	movq	%r13,40(%rdi)+	sbbq	88(%rdx),%rsi+	movq	40(%rcx),%r13+	sbbq	%rdx,%rdx++	andq	%rdx,%r8+	andq	%rdx,%r9+	andq	%rdx,%r10+	andq	%rdx,%r11+	andq	%rdx,%r12+	andq	%rdx,%r13++	addq	%r8,%r14+	adcq	%r9,%r15+	movq	%r14,48(%rdi)+	adcq	%r10,%rax+	movq	%r15,56(%rdi)+	adcq	%r11,%rbx+	movq	%rax,64(%rdi)+	adcq	%r12,%rbp+	movq	%rbx,72(%rdi)+	adcq	%r13,%rsi+	movq	%rbp,80(%rdi)+	movq	%rsi,88(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+++.globl	_add_mod_384x384+.private_extern	_add_mod_384x384++.p2align	5+_add_mod_384x384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	call	__add_mod_384x384++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+++.globl	_sub_mod_384x384+.private_extern	_sub_mod_384x384++.p2align	5+_sub_mod_384x384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	call	__sub_mod_384x384++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+
+ c-source/build/mach-o/ct_inverse_mod_256-armv8.S view
@@ -0,0 +1,784 @@+.text++.globl	_ct_inverse_mod_256++.align	5+_ct_inverse_mod_256:+.long	3573752639+	stp	x29, x30, [sp,#-80]!+	add	x29, sp, #0+	stp	x19, x20, [sp,#16]+	stp	x21, x22, [sp,#32]+	stp	x23, x24, [sp,#48]+	stp	x25, x26, [sp,#64]+	sub	sp, sp, #1040++	ldp	x4, x5, [x1,#8*0]+	ldp	x6, x7, [x1,#8*2]++	add	x1, sp, #16+511	// find closest 512-byte-aligned spot+	and	x1, x1, #-512	// in the frame...+	str	x0, [sp]++	ldp	x8, x9, [x2,#8*0]+	ldp	x10, x11, [x2,#8*2]++	stp	x4, x5, [x1,#8*0]	// copy input to |a|+	stp	x6, x7, [x1,#8*2]+	stp	x8, x9, [x1,#8*4]	// copy modulus to |b|+	stp	x10, x11, [x1,#8*6]++	////////////////////////////////////////// first iteration+	bl	Lab_approximation_31_256_loaded++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	str	x12,[x0,#8*8]		// initialize |u| with |f0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to dst |b|+	bl	__smul_256_n_shift_by_31+	str	x12, [x0,#8*9]		// initialize |v| with |f1|++	////////////////////////////////////////// second iteration+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	ldr	x8, [x1,#8*8]		// |u|+	ldr	x9, [x1,#8*13]	// |v|+	madd	x4, x16, x8, xzr	// |u|*|f0|+	madd	x4, x17, x9, x4	// |v|*|g0|+	str	x4, [x0,#8*4]+	asr	x5, x4, #63		// sign extenstion+	stp	x5, x5, [x0,#8*5]+	stp	x5, x5, [x0,#8*7]++	madd	x4, x12, x8, xzr	// |u|*|f1|+	madd	x4, x13, x9, x4	// |v|*|g1|+	str	x4, [x0,#8*9]+	asr	x5, x4, #63		// sign extenstion+	stp	x5, x5, [x0,#8*10]+	stp	x5, x5, [x0,#8*12]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	adc	x22, x22, x23+	stp	x22, x22, [x0,#8*4]+	stp	x22, x22, [x0,#8*6]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	adc	x22, x22, x23+	stp	x22, x22, [x0,#8*4]+	stp	x22, x22, [x0,#8*6]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	adc	x22, x22, x23+	stp	x22, x22, [x0,#8*4]+	stp	x22, x22, [x0,#8*6]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	adc	x22, x22, x23+	stp	x22, x22, [x0,#8*4]+	stp	x22, x22, [x0,#8*6]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	adc	x22, x22, x23+	stp	x22, x22, [x0,#8*4]+	stp	x22, x22, [x0,#8*6]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	adc	x22, x22, x23+	stp	x22, x22, [x0,#8*4]+	stp	x22, x22, [x0,#8*6]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	bl	__smul_512x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	bl	__smul_512x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	bl	__smul_512x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	bl	__smul_512x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	bl	__smul_512x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	bl	__smul_512x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	bl	__ab_approximation_31_256++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_256_n_shift_by_31+	mov	x16, x12			// corrected |f0|+	mov	x17, x13			// corrected |g0|++	mov	x12, x14			// |f1|+	mov	x13, x15			// |g1|+	add	x0, x0, #8*4	// pointer to destination |b|+	bl	__smul_256_n_shift_by_31++	add	x0, x0, #8*4	// pointer to destination |u|+	bl	__smul_256x63+	adc	x22, x22, x23+	str	x22, [x0,#8*4]++	mov	x16, x12			// corrected |f1|+	mov	x17, x13			// corrected |g1|+	add	x0, x0, #8*5	// pointer to destination |v|+	bl	__smul_256x63+	bl	__smul_512x63_tail+	////////////////////////////////////////// two[!] last iterations+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #47			// 31 + 512 % 31+	//bl	__ab_approximation_62_256	// |a| and |b| are exact,+	ldr	x7, [x1,#8*0]		// just load+	ldr	x11, [x1,#8*4]+	bl	__inner_loop_62_256++	mov	x16, x14+	mov	x17, x15+	ldr	x0, [sp]			// original out_ptr+	bl	__smul_256x63+	bl	__smul_512x63_tail+	ldr	x30, [x29,#8]++	smulh	x20, x7, x17		// figure out top-most limb+	ldp	x8, x9, [x3,#8*0]+	adc	x23, x23, x25+	ldp	x10, x11, [x3,#8*2]++	add	x20, x20, x23		// x20 is 1, 0 or -1+	asr	x19, x20, #63		// sign as mask++	and	x23,   x8, x19		// add mod<<256 conditionally+	and	x24,   x9, x19+	adds	x4, x4, x23+	and	x25,   x10, x19+	adcs	x5, x5, x24+	and	x26,   x11, x19+	adcs	x6, x6, x25+	adcs	x7, x22,   x26+	adc	x20, x20, xzr		// x20 is 1, 0 or -1++	neg	x19, x20+	orr	x20, x20, x19		// excess bit or sign as mask+	asr	x19, x19, #63		// excess bit as mask++	and	x8, x8, x20		// mask |mod|+	and	x9, x9, x20+	and	x10, x10, x20+	and	x11, x11, x20++	eor	x8, x8, x19		// conditionally negate |mod|+	eor	x9, x9, x19+	adds	x8, x8, x19, lsr#63+	eor	x10, x10, x19+	adcs	x9, x9, xzr+	eor	x11, x11, x19+	adcs	x10, x10, xzr+	adc	x11, x11, xzr++	adds	x4, x4, x8	// final adjustment for |mod|<<256+	adcs	x5, x5, x9+	adcs	x6, x6, x10+	stp	x4, x5, [x0,#8*4]+	adc	x7, x7, x11+	stp	x6, x7, [x0,#8*6]++	add	sp, sp, #1040+	ldp	x19, x20, [x29,#16]+	ldp	x21, x22, [x29,#32]+	ldp	x23, x24, [x29,#48]+	ldp	x25, x26, [x29,#64]+	ldr	x29, [sp],#80+.long	3573752767+	ret+++////////////////////////////////////////////////////////////////////////++.align	5+__smul_256x63:+	ldp	x4, x5, [x1,#8*0+64]	// load |u| (or |v|)+	asr	x14, x16, #63		// |f_|'s sign as mask (or |g_|'s)+	ldp	x6, x7, [x1,#8*2+64]+	eor	x16, x16, x14		// conditionally negate |f_| (or |g_|)+	ldr	x22, [x1,#8*4+64]++	eor	x4, x4, x14	// conditionally negate |u| (or |v|)+	sub	x16, x16, x14+	eor	x5, x5, x14+	adds	x4, x4, x14, lsr#63+	eor	x6, x6, x14+	adcs	x5, x5, xzr+	eor	x7, x7, x14+	adcs	x6, x6, xzr+	eor	x22, x22, x14+	umulh	x19, x4, x16+	adcs	x7, x7, xzr+	umulh	x20, x5, x16+	adcs	x22, x22, xzr+	umulh	x21, x6, x16+	mul	x4, x4, x16+	cmp	x16, #0+	mul	x5, x5, x16+	csel	x22, x22, xzr, ne+	mul	x6, x6, x16+	adds	x5, x5, x19+	mul	x24, x7, x16+	adcs	x6, x6, x20+	adcs	x24, x24, x21+	adc	x26, xzr, xzr+	ldp	x8, x9, [x1,#8*0+104]	// load |u| (or |v|)+	asr	x14, x17, #63		// |f_|'s sign as mask (or |g_|'s)+	ldp	x10, x11, [x1,#8*2+104]+	eor	x17, x17, x14		// conditionally negate |f_| (or |g_|)+	ldr	x23, [x1,#8*4+104]++	eor	x8, x8, x14	// conditionally negate |u| (or |v|)+	sub	x17, x17, x14+	eor	x9, x9, x14+	adds	x8, x8, x14, lsr#63+	eor	x10, x10, x14+	adcs	x9, x9, xzr+	eor	x11, x11, x14+	adcs	x10, x10, xzr+	eor	x23, x23, x14+	umulh	x19, x8, x17+	adcs	x11, x11, xzr+	umulh	x20, x9, x17+	adcs	x23, x23, xzr+	umulh	x21, x10, x17+	adc	x15, xzr, xzr		// used in __smul_512x63_tail+	mul	x8, x8, x17+	cmp	x17, #0+	mul	x9, x9, x17+	csel	x23, x23, xzr, ne+	mul	x10, x10, x17+	adds	x9, x9, x19+	mul	x25, x11, x17+	adcs	x10, x10, x20+	adcs	x25, x25, x21+	adc	x26, x26, xzr++	adds	x4, x4, x8+	adcs	x5, x5, x9+	adcs	x6, x6, x10+	stp	x4, x5, [x0,#8*0]+	adcs	x24,   x24,   x25+	stp	x6, x24, [x0,#8*2]++	ret++++.align	5+__smul_512x63_tail:+	umulh	x24, x7, x16+	ldp	x5, x6, [x1,#8*18]	// load rest of |v|+	adc	x26, x26, xzr+	ldr	x7, [x1,#8*20]+	and	x22, x22, x16++	umulh	x11, x11, x17	// resume |v|*|g1| chain++	sub	x24, x24, x22	// tie up |u|*|f1| chain+	asr	x25, x24, #63++	eor	x5, x5, x14	// conditionally negate rest of |v|+	eor	x6, x6, x14+	adds	x5, x5, x15+	eor	x7, x7, x14+	adcs	x6, x6, xzr+	umulh	x19, x23,   x17+	adc	x7, x7, xzr+	umulh	x20, x5, x17+	add	x11, x11, x26+	umulh	x21, x6, x17++	mul	x4, x23,   x17+	mul	x5, x5, x17+	adds	x4, x4, x11+	mul	x6, x6, x17+	adcs	x5, x5, x19+	mul	x22,   x7, x17+	adcs	x6, x6, x20+	adcs	x22,   x22,   x21+	adc	x23, xzr, xzr		// used in the final step++	adds	x4, x4, x24+	adcs	x5, x5, x25+	adcs	x6, x6, x25+	stp	x4, x5, [x0,#8*4]+	adcs	x22,   x22,   x25	// carry is used in the final step+	stp	x6, x22,   [x0,#8*6]++	ret++++.align	5+__smul_256_n_shift_by_31:+	ldp	x4, x5, [x1,#8*0+0]	// load |a| (or |b|)+	asr	x24, x12, #63		// |f0|'s sign as mask (or |g0|'s)+	ldp	x6, x7, [x1,#8*2+0]+	eor	x25, x12, x24	// conditionally negate |f0| (or |g0|)++	eor	x4, x4, x24	// conditionally negate |a| (or |b|)+	sub	x25, x25, x24+	eor	x5, x5, x24+	adds	x4, x4, x24, lsr#63+	eor	x6, x6, x24+	adcs	x5, x5, xzr+	eor	x7, x7, x24+	umulh	x19, x4, x25+	adcs	x6, x6, xzr+	umulh	x20, x5, x25+	adc	x7, x7, xzr+	umulh	x21, x6, x25+	and	x24, x24, x25+	umulh	x22, x7, x25+	neg	x24, x24++	mul	x4, x4, x25+	mul	x5, x5, x25+	mul	x6, x6, x25+	adds	x5, x5, x19+	mul	x7, x7, x25+	adcs	x6, x6, x20+	adcs	x7, x7, x21+	adc	x22, x22, x24+	ldp	x8, x9, [x1,#8*0+32]	// load |a| (or |b|)+	asr	x24, x13, #63		// |f0|'s sign as mask (or |g0|'s)+	ldp	x10, x11, [x1,#8*2+32]+	eor	x25, x13, x24	// conditionally negate |f0| (or |g0|)++	eor	x8, x8, x24	// conditionally negate |a| (or |b|)+	sub	x25, x25, x24+	eor	x9, x9, x24+	adds	x8, x8, x24, lsr#63+	eor	x10, x10, x24+	adcs	x9, x9, xzr+	eor	x11, x11, x24+	umulh	x19, x8, x25+	adcs	x10, x10, xzr+	umulh	x20, x9, x25+	adc	x11, x11, xzr+	umulh	x21, x10, x25+	and	x24, x24, x25+	umulh	x23, x11, x25+	neg	x24, x24++	mul	x8, x8, x25+	mul	x9, x9, x25+	mul	x10, x10, x25+	adds	x9, x9, x19+	mul	x11, x11, x25+	adcs	x10, x10, x20+	adcs	x11, x11, x21+	adc	x23, x23, x24+	adds	x4, x4, x8+	adcs	x5, x5, x9+	adcs	x6, x6, x10+	adcs	x7, x7, x11+	adc	x8, x22,   x23++	extr	x4, x5, x4, #31+	extr	x5, x6, x5, #31+	extr	x6, x7, x6, #31+	asr	x23, x8, #63	// result's sign as mask+	extr	x7, x8, x7, #31++	eor	x4, x4, x23	// ensure the result is positive+	eor	x5, x5, x23+	adds	x4, x4, x23, lsr#63+	eor	x6, x6, x23+	adcs	x5, x5, xzr+	eor	x7, x7, x23+	adcs	x6, x6, xzr+	stp	x4, x5, [x0,#8*0]+	adc	x7, x7, xzr+	stp	x6, x7, [x0,#8*2]++	eor	x12, x12, x23		// adjust |f/g| accordingly+	eor	x13, x13, x23+	sub	x12, x12, x23+	sub	x13, x13, x23++	ret+++.align	4+__ab_approximation_31_256:+	ldp	x6, x7, [x1,#8*2]+	ldp	x10, x11, [x1,#8*6]+	ldp	x4, x5, [x1,#8*0]+	ldp	x8, x9, [x1,#8*4]++Lab_approximation_31_256_loaded:+	orr	x19, x7, x11	// check top-most limbs, ...+	cmp	x19, #0+	csel	x7, x7, x6, ne+	csel	x11, x11, x10, ne+	csel	x6, x6, x5, ne+	orr	x19, x7, x11	// and ones before top-most, ...+	csel	x10, x10, x9, ne++	cmp	x19, #0+	csel	x7, x7, x6, ne+	csel	x11, x11, x10, ne+	csel	x6, x6, x4, ne+	orr	x19, x7, x11	// and one more, ...+	csel	x10, x10, x8, ne++	clz	x19, x19+	cmp	x19, #64+	csel	x19, x19, xzr, ne+	csel	x7, x7, x6, ne+	csel	x11, x11, x10, ne+	neg	x20, x19++	lslv	x7, x7, x19	// align high limbs to the left+	lslv	x11, x11, x19+	lsrv	x6, x6, x20+	lsrv	x10, x10, x20+	and	x6, x6, x20, asr#6+	and	x10, x10, x20, asr#6+	orr	x7, x7, x6+	orr	x11, x11, x10++	bfxil	x7, x4, #0, #31+	bfxil	x11, x8, #0, #31++	b	__inner_loop_31_256+	ret++++.align	4+__inner_loop_31_256:+	mov	x2, #31+	mov	x13, #0x7FFFFFFF80000000	// |f0|=1, |g0|=0+	mov	x15, #0x800000007FFFFFFF	// |f1|=0, |g1|=1+	mov	x23,#0x7FFFFFFF7FFFFFFF++Loop_31_256:+	sbfx	x22, x7, #0, #1	// if |a_| is odd, then we'll be subtracting+	sub	x2, x2, #1+	and	x19, x11, x22+	sub	x20, x11, x7	// |b_|-|a_|+	subs	x21, x7, x19	// |a_|-|b_| (or |a_|-0 if |a_| was even)+	mov	x19, x15+	csel	x11, x11, x7, hs	// |b_| = |a_|+	csel	x7, x21, x20, hs	// borrow means |a_|<|b_|, replace with |b_|-|a_|+	csel	x15, x15, x13,    hs	// exchange |fg0| and |fg1|+	csel	x13, x13, x19,   hs+	lsr	x7, x7, #1+	and	x19, x15, x22+	and	x20, x23, x22+	sub	x13, x13, x19	// |f0|-=|f1| (or |f0-=0| if |a_| was even)+	add	x15, x15, x15	// |f1|<<=1+	add	x13, x13, x20+	sub	x15, x15, x23+	cbnz	x2, Loop_31_256++	mov	x23, #0x7FFFFFFF+	ubfx	x12, x13, #0, #32+	ubfx	x13, x13, #32, #32+	ubfx	x14, x15, #0, #32+	ubfx	x15, x15, #32, #32+	sub	x12, x12, x23		// remove bias+	sub	x13, x13, x23+	sub	x14, x14, x23+	sub	x15, x15, x23++	ret++++.align	4+__inner_loop_62_256:+	mov	x12, #1		// |f0|=1+	mov	x13, #0		// |g0|=0+	mov	x14, #0		// |f1|=0+	mov	x15, #1		// |g1|=1++Loop_62_256:+	sbfx	x22, x7, #0, #1	// if |a_| is odd, then we'll be subtracting+	sub	x2, x2, #1+	and	x19, x11, x22+	sub	x20, x11, x7	// |b_|-|a_|+	subs	x21, x7, x19	// |a_|-|b_| (or |a_|-0 if |a_| was even)+	mov	x19, x12+	csel	x11, x11, x7, hs	// |b_| = |a_|+	csel	x7, x21, x20, hs	// borrow means |a_|<|b_|, replace with |b_|-|a_|+	mov	x20, x13+	csel	x12, x12, x14,       hs	// exchange |f0| and |f1|+	csel	x14, x14, x19,     hs+	csel	x13, x13, x15,       hs	// exchange |g0| and |g1|+	csel	x15, x15, x20,     hs+	lsr	x7, x7, #1+	and	x19, x14, x22+	and	x20, x15, x22+	add	x14, x14, x14		// |f1|<<=1+	add	x15, x15, x15		// |g1|<<=1+	sub	x12, x12, x19		// |f0|-=|f1| (or |f0-=0| if |a_| was even)+	sub	x13, x13, x20		// |g0|-=|g1| (or |g0-=0| ...)+	cbnz	x2, Loop_62_256++	ret+
+ c-source/build/mach-o/ct_inverse_mod_256-x86_64.s view
@@ -0,0 +1,1177 @@+.text	++.globl	_ct_inverse_mod_256++.p2align	5+_ct_inverse_mod_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$1072,%rsp+.cfi_adjust_cfa_offset	1072+++	leaq	48+511(%rsp),%rax+	andq	$-512,%rax+	movq	%rdi,32(%rsp)+	movq	%rcx,40(%rsp)++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11++	movq	0(%rdx),%r12+	movq	8(%rdx),%r13+	movq	16(%rdx),%r14+	movq	24(%rdx),%r15++	movq	%r8,0(%rax)+	movq	%r9,8(%rax)+	movq	%r10,16(%rax)+	movq	%r11,24(%rax)++	movq	%r12,32(%rax)+	movq	%r13,40(%rax)+	movq	%r14,48(%rax)+	movq	%r15,56(%rax)+	movq	%rax,%rsi+++	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+++	movq	%rdx,64(%rdi)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+++	movq	%rdx,72(%rdi)+++	xorq	$256,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31++++	movq	64(%rsi),%r8+	movq	104(%rsi),%r12+	movq	%r8,%r9+	imulq	0(%rsp),%r8+	movq	%r12,%r13+	imulq	8(%rsp),%r12+	addq	%r12,%r8+	movq	%r8,32(%rdi)+	sarq	$63,%r8+	movq	%r8,40(%rdi)+	movq	%r8,48(%rdi)+	movq	%r8,56(%rdi)+	movq	%r8,64(%rdi)+	leaq	64(%rsi),%rsi++	imulq	%rdx,%r9+	imulq	%rcx,%r13+	addq	%r13,%r9+	movq	%r9,72(%rdi)+	sarq	$63,%r9+	movq	%r9,80(%rdi)+	movq	%r9,88(%rdi)+	movq	%r9,96(%rdi)+	movq	%r9,104(%rdi)+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_256x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_256x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_256x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_256x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_256x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_256x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_256x63+	sarq	$63,%rbp+	movq	%rbp,40(%rdi)+	movq	%rbp,48(%rdi)+	movq	%rbp,56(%rdi)+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_512x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_512x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_512x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_512x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_512x63+	xorq	$256+64,%rsi+	movl	$31,%edx+	call	__ab_approximation_31_256+++	movq	%r12,16(%rsp)+	movq	%r13,24(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,0(%rsp)+	movq	%rcx,8(%rsp)++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	32(%rdi),%rdi+	call	__smulq_256_n_shift_by_31+	movq	%rdx,16(%rsp)+	movq	%rcx,24(%rsp)++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	64(%rsi),%rsi+	leaq	32(%rdi),%rdi+	call	__smulq_256x63++	movq	16(%rsp),%rdx+	movq	24(%rsp),%rcx+	leaq	40(%rdi),%rdi+	call	__smulq_512x63++	xorq	$256+64,%rsi+	movl	$47,%edx++	movq	0(%rsi),%r8++	movq	32(%rsi),%r10++	call	__inner_loop_62_256++++++++	leaq	64(%rsi),%rsi++++++	movq	%r12,%rdx+	movq	%r13,%rcx+	movq	32(%rsp),%rdi+	call	__smulq_512x63+	adcq	%rbp,%rdx++	movq	40(%rsp),%rsi+	movq	%rdx,%rax+	sarq	$63,%rdx++	movq	%rdx,%r8+	movq	%rdx,%r9+	andq	0(%rsi),%r8+	movq	%rdx,%r10+	andq	8(%rsi),%r9+	andq	16(%rsi),%r10+	andq	24(%rsi),%rdx++	addq	%r8,%r12+	adcq	%r9,%r13+	adcq	%r10,%r14+	adcq	%rdx,%r15+	adcq	$0,%rax++	movq	%rax,%rdx+	negq	%rax+	orq	%rax,%rdx+	sarq	$63,%rax++	movq	%rdx,%r8+	movq	%rdx,%r9+	andq	0(%rsi),%r8+	movq	%rdx,%r10+	andq	8(%rsi),%r9+	andq	16(%rsi),%r10+	andq	24(%rsi),%rdx++	xorq	%rax,%r8+	xorq	%rcx,%rcx+	xorq	%rax,%r9+	subq	%rax,%rcx+	xorq	%rax,%r10+	xorq	%rax,%rdx+	addq	%rcx,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%rdx++	addq	%r8,%r12+	adcq	%r9,%r13+	adcq	%r10,%r14+	adcq	%rdx,%r15++	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)+	movq	%r14,48(%rdi)+	movq	%r15,56(%rdi)++	leaq	1072(%rsp),%r8+	movq	0(%r8),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-1072-8*6++	.byte	0xf3,0xc3+.cfi_endproc	+++.p2align	5+__smulq_512x63:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%rbp++	movq	%rdx,%rbx+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbx+	addq	%rax,%rbx++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%rbp+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%rbp++	mulq	%rbx+	movq	%rax,0(%rdi)+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbx+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%r9,8(%rdi)+	movq	%rdx,%r10+	mulq	%rbx+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%r10,16(%rdi)+	movq	%rdx,%r11+	andq	%rbx,%rbp+	negq	%rbp+	mulq	%rbx+	addq	%rax,%r11+	adcq	%rdx,%rbp+	movq	%r11,24(%rdi)++	movq	40(%rsi),%r8+	movq	48(%rsi),%r9+	movq	56(%rsi),%r10+	movq	64(%rsi),%r11+	movq	72(%rsi),%r12+	movq	80(%rsi),%r13+	movq	88(%rsi),%r14+	movq	96(%rsi),%r15++	movq	%rcx,%rdx+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rcx+	addq	%rax,%rcx++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	xorq	%rdx,%r14+	xorq	%rdx,%r15+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13+	adcq	$0,%r14+	adcq	$0,%r15++	mulq	%rcx+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rcx+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rcx+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rcx+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	mulq	%rcx+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	mulq	%rcx+	addq	%rax,%r13+	movq	%r14,%rax+	adcq	$0,%rdx+	movq	%rdx,%r14+	mulq	%rcx+	addq	%rax,%r14+	movq	%r15,%rax+	adcq	$0,%rdx+	movq	%rdx,%r15+	imulq	%rcx+	addq	%rax,%r15+	adcq	$0,%rdx++	movq	%rbp,%rbx+	sarq	$63,%rbp++	addq	0(%rdi),%r8+	adcq	8(%rdi),%r9+	adcq	16(%rdi),%r10+	adcq	24(%rdi),%r11+	adcq	%rbx,%r12+	adcq	%rbp,%r13+	adcq	%rbp,%r14+	adcq	%rbp,%r15++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)+	movq	%r14,48(%rdi)+	movq	%r15,56(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc++++.p2align	5+__smulq_256x63:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0+0(%rsi),%r8+	movq	0+8(%rsi),%r9+	movq	0+16(%rsi),%r10+	movq	0+24(%rsi),%r11+	movq	0+32(%rsi),%rbp++	movq	%rdx,%rbx+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbx+	addq	%rax,%rbx++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%rbp+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%rbp++	mulq	%rbx+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbx+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rbx+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	andq	%rbx,%rbp+	negq	%rbp+	mulq	%rbx+	addq	%rax,%r11+	adcq	%rdx,%rbp+	movq	%rcx,%rdx+	movq	40+0(%rsi),%r12+	movq	40+8(%rsi),%r13+	movq	40+16(%rsi),%r14+	movq	40+24(%rsi),%r15+	movq	40+32(%rsi),%rcx++	movq	%rdx,%rbx+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbx+	addq	%rax,%rbx++	xorq	%rdx,%r12+	xorq	%rdx,%r13+	xorq	%rdx,%r14+	xorq	%rdx,%r15+	xorq	%rdx,%rcx+	addq	%r12,%rax+	adcq	$0,%r13+	adcq	$0,%r14+	adcq	$0,%r15+	adcq	$0,%rcx++	mulq	%rbx+	movq	%rax,%r12+	movq	%r13,%rax+	movq	%rdx,%r13+	mulq	%rbx+	addq	%rax,%r13+	movq	%r14,%rax+	adcq	$0,%rdx+	movq	%rdx,%r14+	mulq	%rbx+	addq	%rax,%r14+	movq	%r15,%rax+	adcq	$0,%rdx+	movq	%rdx,%r15+	andq	%rbx,%rcx+	negq	%rcx+	mulq	%rbx+	addq	%rax,%r15+	adcq	%rdx,%rcx+	addq	%r12,%r8+	adcq	%r13,%r9+	adcq	%r14,%r10+	adcq	%r15,%r11+	adcq	%rcx,%rbp++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%rbp,32(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+++.p2align	5+__smulq_256_n_shift_by_31:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	%rdx,0(%rdi)+	movq	%rcx,8(%rdi)+	movq	%rdx,%rbp+	movq	0+0(%rsi),%r8+	movq	0+8(%rsi),%r9+	movq	0+16(%rsi),%r10+	movq	0+24(%rsi),%r11++	movq	%rbp,%rbx+	sarq	$63,%rbp+	xorq	%rax,%rax+	subq	%rbp,%rax++	xorq	%rbp,%rbx+	addq	%rax,%rbx++	xorq	%rbp,%r8+	xorq	%rbp,%r9+	xorq	%rbp,%r10+	xorq	%rbp,%r11+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11++	mulq	%rbx+	movq	%rax,%r8+	movq	%r9,%rax+	andq	%rbx,%rbp+	negq	%rbp+	movq	%rdx,%r9+	mulq	%rbx+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rbx+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rbx+	addq	%rax,%r11+	adcq	%rdx,%rbp+	movq	32+0(%rsi),%r12+	movq	32+8(%rsi),%r13+	movq	32+16(%rsi),%r14+	movq	32+24(%rsi),%r15++	movq	%rcx,%rbx+	sarq	$63,%rcx+	xorq	%rax,%rax+	subq	%rcx,%rax++	xorq	%rcx,%rbx+	addq	%rax,%rbx++	xorq	%rcx,%r12+	xorq	%rcx,%r13+	xorq	%rcx,%r14+	xorq	%rcx,%r15+	addq	%r12,%rax+	adcq	$0,%r13+	adcq	$0,%r14+	adcq	$0,%r15++	mulq	%rbx+	movq	%rax,%r12+	movq	%r13,%rax+	andq	%rbx,%rcx+	negq	%rcx+	movq	%rdx,%r13+	mulq	%rbx+	addq	%rax,%r13+	movq	%r14,%rax+	adcq	$0,%rdx+	movq	%rdx,%r14+	mulq	%rbx+	addq	%rax,%r14+	movq	%r15,%rax+	adcq	$0,%rdx+	movq	%rdx,%r15+	mulq	%rbx+	addq	%rax,%r15+	adcq	%rdx,%rcx+	addq	%r12,%r8+	adcq	%r13,%r9+	adcq	%r14,%r10+	adcq	%r15,%r11+	adcq	%rcx,%rbp++	movq	0(%rdi),%rdx+	movq	8(%rdi),%rcx++	shrdq	$31,%r9,%r8+	shrdq	$31,%r10,%r9+	shrdq	$31,%r11,%r10+	shrdq	$31,%rbp,%r11++	sarq	$63,%rbp+	xorq	%rax,%rax+	subq	%rbp,%rax++	xorq	%rbp,%r8+	xorq	%rbp,%r9+	xorq	%rbp,%r10+	xorq	%rbp,%r11+	addq	%rax,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)++	xorq	%rbp,%rdx+	xorq	%rbp,%rcx+	addq	%rax,%rdx+	addq	%rax,%rcx++	.byte	0xf3,0xc3+.cfi_endproc+++.p2align	5+__ab_approximation_31_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	24(%rsi),%r9+	movq	56(%rsi),%r11+	movq	16(%rsi),%rbx+	movq	48(%rsi),%rbp+	movq	8(%rsi),%r8+	movq	40(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	movq	0(%rsi),%r8+	cmovzq	%r10,%rbp+	movq	32(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	cmovzq	%r10,%rbp++	movq	%r9,%rax+	orq	%r11,%rax+	bsrq	%rax,%rcx+	leaq	1(%rcx),%rcx+	cmovzq	%r8,%r9+	cmovzq	%r10,%r11+	cmovzq	%rax,%rcx+	negq	%rcx+++	shldq	%cl,%rbx,%r9+	shldq	%cl,%rbp,%r11++	movl	$0x7FFFFFFF,%eax+	andq	%rax,%r8+	andq	%rax,%r10+	notq	%rax+	andq	%rax,%r9+	andq	%rax,%r11+	orq	%r9,%r8+	orq	%r11,%r10++	jmp	__inner_loop_31_256++	.byte	0xf3,0xc3+.cfi_endproc+++.p2align	5+__inner_loop_31_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	$0x7FFFFFFF80000000,%rcx+	movq	$0x800000007FFFFFFF,%r13+	movq	$0x7FFFFFFF7FFFFFFF,%r15++L$oop_31_256:+	cmpq	%r10,%r8+	movq	%r8,%rax+	movq	%r10,%rbx+	movq	%rcx,%rbp+	movq	%r13,%r14+	cmovbq	%r10,%r8+	cmovbq	%rax,%r10+	cmovbq	%r13,%rcx+	cmovbq	%rbp,%r13++	subq	%r10,%r8+	subq	%r13,%rcx+	addq	%r15,%rcx++	testq	$1,%rax+	cmovzq	%rax,%r8+	cmovzq	%rbx,%r10+	cmovzq	%rbp,%rcx+	cmovzq	%r14,%r13++	shrq	$1,%r8+	addq	%r13,%r13+	subq	%r15,%r13+	subl	$1,%edx+	jnz	L$oop_31_256++	shrq	$32,%r15+	movl	%ecx,%edx+	movl	%r13d,%r12d+	shrq	$32,%rcx+	shrq	$32,%r13+	subq	%r15,%rdx+	subq	%r15,%rcx+	subq	%r15,%r12+	subq	%r15,%r13++	.byte	0xf3,0xc3+.cfi_endproc++++.p2align	5+__inner_loop_62_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movl	%edx,%r15d+	movq	$1,%rdx+	xorq	%rcx,%rcx+	xorq	%r12,%r12+	movq	%rdx,%r13+	movq	%rdx,%r14++L$oop_62_256:+	xorq	%rax,%rax+	testq	%r14,%r8+	movq	%r10,%rbx+	cmovnzq	%r10,%rax+	subq	%r8,%rbx+	movq	%r8,%rbp+	subq	%rax,%r8+	cmovcq	%rbx,%r8+	cmovcq	%rbp,%r10+	movq	%rdx,%rax+	cmovcq	%r12,%rdx+	cmovcq	%rax,%r12+	movq	%rcx,%rbx+	cmovcq	%r13,%rcx+	cmovcq	%rbx,%r13+	xorq	%rax,%rax+	xorq	%rbx,%rbx+	shrq	$1,%r8+	testq	%r14,%rbp+	cmovnzq	%r12,%rax+	cmovnzq	%r13,%rbx+	addq	%r12,%r12+	addq	%r13,%r13+	subq	%rax,%rdx+	subq	%rbx,%rcx+	subl	$1,%r15d+	jnz	L$oop_62_256++	.byte	0xf3,0xc3+.cfi_endproc+
+ c-source/build/mach-o/ct_inverse_mod_384-armv8.S view
@@ -0,0 +1,717 @@+.text++.globl	_ct_inverse_mod_383++.align	5+_ct_inverse_mod_383:+.long	3573752639+	stp	x29, x30, [sp,#-128]!+	add	x29, sp, #0+	stp	x19, x20, [sp,#16]+	stp	x21, x22, [sp,#32]+	stp	x23, x24, [sp,#48]+	stp	x25, x26, [sp,#64]+	stp	x27, x28, [sp,#80]+	sub	sp, sp, #1040++	ldp	x22,   x4, [x1,#8*0]+	ldp	x5, x6, [x1,#8*2]+	ldp	x7, x8, [x1,#8*4]++	add	x1, sp, #16+511	// find closest 512-byte-aligned spot+	and	x1, x1, #-512	// in the frame...+	stp	x0, x3, [sp]++	ldp	x9, x10, [x2,#8*0]+	ldp	x11, x12, [x2,#8*2]+	ldp	x13, x14, [x2,#8*4]++	stp	x22,   x4, [x1,#8*0]	// copy input to |a|+	stp	x5, x6, [x1,#8*2]+	stp	x7, x8, [x1,#8*4]+	stp	x9, x10, [x1,#8*6]	// copy modulus to |b|+	stp	x11, x12, [x1,#8*8]+	stp	x13, x14, [x1,#8*10]++	////////////////////////////////////////// first iteration+	mov	x2, #62+	bl	Lab_approximation_62_loaded++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	str	x15,[x0,#8*12]		// initialize |u| with |f0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to dst |b|+	bl	__smul_383_n_shift_by_62+	str	x15, [x0,#8*12]		// initialize |v| with |f1|++	////////////////////////////////////////// second iteration+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	ldr	x7, [x1,#8*12]	// |u|+	ldr	x8, [x1,#8*18]	// |v|+	mul	x3, x20, x7		// |u|*|f0|+	smulh	x4, x20, x7+	mul	x5, x21, x8		// |v|*|g0|+	smulh	x6, x21, x8+	adds	x3, x3, x5+	adc	x4, x4, x6+	stp	x3, x4, [x0,#8*6]+	asr	x5, x4, #63		// sign extenstion+	stp	x5, x5, [x0,#8*8]+	stp	x5, x5, [x0,#8*10]++	mul	x3, x15, x7		// |u|*|f1|+	smulh	x4, x15, x7+	mul	x5, x16, x8		// |v|*|g1|+	smulh	x6, x16, x8+	adds	x3, x3, x5+	adc	x4, x4, x6+	stp	x3, x4, [x0,#8*12]+	asr	x5, x4, #63		// sign extenstion+	stp	x5, x5, [x0,#8*14]+	stp	x5, x5, [x0,#8*16]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	asr	x27, x27, #63		// sign extension+	stp	x27, x27, [x0,#8*6]+	stp	x27, x27, [x0,#8*8]+	stp	x27, x27, [x0,#8*10]+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	bl	__smul_767x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	bl	__smul_767x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	bl	__smul_767x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	bl	__smul_767x63_tail+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	bl	__ab_approximation_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	bl	__smul_383_n_shift_by_62+	mov	x20, x15			// corrected |f0|+	mov	x21, x16			// corrected |g0|++	mov	x15, x17			// |f1|+	mov	x16, x19			// |g1|+	add	x0, x0, #8*6	// pointer to destination |b|+	bl	__smul_383_n_shift_by_62++	add	x0, x0, #8*6	// pointer to destination |u|+	bl	__smul_383x63++	mov	x20, x15			// corrected |f1|+	mov	x21, x16			// corrected |g1|+	add	x0, x0, #8*6	// pointer to destination |v|+	bl	__smul_383x63+	bl	__smul_767x63_tail+	////////////////////////////////////////// iteration before last+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #62+	//bl	__ab_approximation_62		// |a| and |b| are exact,+	ldp	x3, x8, [x1,#8*0]	// just load+	ldp	x9, x14, [x1,#8*6]+	bl	__inner_loop_62++	eor	x0, x1, #256		// pointer to dst |a|b|u|v|+	str	x3, [x0,#8*0]+	str	x9, [x0,#8*6]++	mov	x20, x15			// exact |f0|+	mov	x21, x16			// exact |g0|+	mov	x15, x17+	mov	x16, x19+	add	x0, x0, #8*12	// pointer to dst |u|+	bl	__smul_383x63++	mov	x20, x15			// exact |f1|+	mov	x21, x16			// exact |g1|+	add	x0, x0, #8*6	// pointer to dst |v|+	bl	__smul_383x63+	bl	__smul_767x63_tail++	////////////////////////////////////////// last iteration+	eor	x1, x1, #256		// flip-flop src |a|b|u|v|+	mov	x2, #22			// 766 % 62+	//bl	__ab_approximation_62		// |a| and |b| are exact,+	ldr	x3, [x1,#8*0]		// just load+	eor	x8, x8, x8+	ldr	x9, [x1,#8*6]+	eor	x14, x14, x14+	bl	__inner_loop_62++	mov	x20, x17+	mov	x21, x19+	ldp	x0, x15, [sp]		// original out_ptr and n_ptr+	bl	__smul_383x63+	bl	__smul_767x63_tail+	ldr	x30, [x29,#8]++	asr	x22, x8, #63		// sign as mask+	ldp	x9, x10, [x15,#8*0]+	ldp	x11, x12, [x15,#8*2]+	ldp	x13, x14, [x15,#8*4]++	and	x9, x9, x22		// add mod<<384 conditionally+	and	x10, x10, x22+	adds	x3, x3, x9+	and	x11, x11, x22+	adcs	x4, x4, x10+	and	x12, x12, x22+	adcs	x5, x5, x11+	and	x13, x13, x22+	adcs	x6, x6, x12+	and	x14, x14, x22+	stp	x3, x4, [x0,#8*6]+	adcs	x7, x7, x13+	stp	x5, x6, [x0,#8*8]+	adc	x8, x8, x14+	stp	x7, x8, [x0,#8*10]++	add	sp, sp, #1040+	ldp	x19, x20, [x29,#16]+	ldp	x21, x22, [x29,#32]+	ldp	x23, x24, [x29,#48]+	ldp	x25, x26, [x29,#64]+	ldp	x27, x28, [x29,#80]+	ldr	x29, [sp],#128+.long	3573752767+	ret+++////////////////////////////////////////////////////////////////////////+// see corresponding commentary in ctx_inverse_mod_384-x86_64...++.align	5+__smul_383x63:+	ldp	x3, x4, [x1,#8*0+96]	// load |u| (or |v|)+	asr	x17, x20, #63		// |f_|'s sign as mask (or |g_|'s)+	ldp	x5, x6, [x1,#8*2+96]+	eor	x20, x20, x17		// conditionally negate |f_| (or |g_|)+	ldp	x7, x8, [x1,#8*4+96]++	eor	x3, x3, x17	// conditionally negate |u| (or |v|)+	sub	x20, x20, x17+	eor	x4, x4, x17+	adds	x3, x3, x17, lsr#63+	eor	x5, x5, x17+	adcs	x4, x4, xzr+	eor	x6, x6, x17+	adcs	x5, x5, xzr+	eor	x7, x7, x17+	adcs	x6, x6, xzr+	umulh	x22, x3, x20+	eor	x8, x8, x17+	umulh	x23, x4, x20+	adcs	x7, x7, xzr+	umulh	x24, x5, x20+	adcs	x8, x8, xzr+	umulh	x25, x6, x20+	umulh	x26, x7, x20+	mul	x3, x3, x20+	mul	x4, x4, x20+	mul	x5, x5, x20+	adds	x4, x4, x22+	mul	x6, x6, x20+	adcs	x5, x5, x23+	mul	x7, x7, x20+	adcs	x6, x6, x24+	mul	x27,x8, x20+	adcs	x7, x7, x25+	adcs	x27,x27,x26+	adc	x2, xzr, xzr+	ldp	x9, x10, [x1,#8*0+144]	// load |u| (or |v|)+	asr	x17, x21, #63		// |f_|'s sign as mask (or |g_|'s)+	ldp	x11, x12, [x1,#8*2+144]+	eor	x21, x21, x17		// conditionally negate |f_| (or |g_|)+	ldp	x13, x14, [x1,#8*4+144]++	eor	x9, x9, x17	// conditionally negate |u| (or |v|)+	sub	x21, x21, x17+	eor	x10, x10, x17+	adds	x9, x9, x17, lsr#63+	eor	x11, x11, x17+	adcs	x10, x10, xzr+	eor	x12, x12, x17+	adcs	x11, x11, xzr+	eor	x13, x13, x17+	adcs	x12, x12, xzr+	umulh	x22, x9, x21+	eor	x14, x14, x17+	umulh	x23, x10, x21+	adcs	x13, x13, xzr+	umulh	x24, x11, x21+	adcs	x14, x14, xzr+	umulh	x25, x12, x21+	adc	x19, xzr, xzr		// used in __smul_767x63_tail+	umulh	x26, x13, x21+	mul	x9, x9, x21+	mul	x10, x10, x21+	mul	x11, x11, x21+	adds	x10, x10, x22+	mul	x12, x12, x21+	adcs	x11, x11, x23+	mul	x13, x13, x21+	adcs	x12, x12, x24+	mul	x28,x14, x21+	adcs	x13, x13, x25+	adcs	x28,x28,x26+	adc	x2, x2, xzr++	adds	x3, x3, x9+	adcs	x4, x4, x10+	adcs	x5, x5, x11+	adcs	x6, x6, x12+	stp	x3, x4, [x0,#8*0]+	adcs	x7, x7, x13+	stp	x5, x6, [x0,#8*2]+	adcs	x27,   x27,   x28+	stp	x7, x27,   [x0,#8*4]+	adc	x28,   x2,   xzr	// used in __smul_767x63_tail++	ret++++.align	5+__smul_767x63_tail:+	smulh	x27,   x8, x20+	ldp	x3, x4, [x1,#8*24]	// load rest of |v|+	umulh	x14,x14, x21+	ldp	x5, x6, [x1,#8*26]+	ldp	x7, x8, [x1,#8*28]++	eor	x3, x3, x17	// conditionally negate rest of |v|+	eor	x4, x4, x17+	eor	x5, x5, x17+	adds	x3, x3, x19+	eor	x6, x6, x17+	adcs	x4, x4, xzr+	eor	x7, x7, x17+	adcs	x5, x5, xzr+	eor	x8, x8, x17+	adcs	x6, x6, xzr+	umulh	x22, x3, x21+	adcs	x7, x7, xzr+	umulh	x23, x4, x21+	adc	x8, x8, xzr++	umulh	x24, x5, x21+	add	x14, x14, x28+	umulh	x25, x6, x21+	asr	x28, x27, #63+	umulh	x26, x7, x21+	mul	x3, x3, x21+	mul	x4, x4, x21+	mul	x5, x5, x21+	adds	x3, x3, x14+	mul	x6, x6, x21+	adcs	x4, x4, x22+	mul	x7, x7, x21+	adcs	x5, x5, x23+	mul	x8, x8, x21+	adcs	x6, x6, x24+	adcs	x7, x7, x25+	adc	x8, x8, x26++	adds	x3, x3, x27+	adcs	x4, x4, x28+	adcs	x5, x5, x28+	adcs	x6, x6, x28+	stp	x3, x4, [x0,#8*6]+	adcs	x7, x7, x28+	stp	x5, x6, [x0,#8*8]+	adc	x8, x8, x28+	stp	x7, x8, [x0,#8*10]++	ret++++.align	5+__smul_383_n_shift_by_62:+	ldp	x3, x4, [x1,#8*0+0]	// load |a| (or |b|)+	asr	x28, x15, #63		// |f0|'s sign as mask (or |g0|'s)+	ldp	x5, x6, [x1,#8*2+0]+	eor	x2, x15, x28	// conditionally negate |f0| (or |g0|)+	ldp	x7, x8, [x1,#8*4+0]++	eor	x3, x3, x28	// conditionally negate |a| (or |b|)+	sub	x2, x2, x28+	eor	x4, x4, x28+	adds	x3, x3, x28, lsr#63+	eor	x5, x5, x28+	adcs	x4, x4, xzr+	eor	x6, x6, x28+	adcs	x5, x5, xzr+	eor	x7, x7, x28+	umulh	x22, x3, x2+	adcs	x6, x6, xzr+	umulh	x23, x4, x2+	eor	x8, x8, x28+	umulh	x24, x5, x2+	adcs	x7, x7, xzr+	umulh	x25, x6, x2+	adc	x8, x8, xzr++	umulh	x26, x7, x2+	smulh	x27, x8, x2+	mul	x3, x3, x2+	mul	x4, x4, x2+	mul	x5, x5, x2+	adds	x4, x4, x22+	mul	x6, x6, x2+	adcs	x5, x5, x23+	mul	x7, x7, x2+	adcs	x6, x6, x24+	mul	x8, x8, x2+	adcs	x7, x7, x25+	adcs	x8, x8 ,x26+	adc	x27, x27, xzr+	ldp	x9, x10, [x1,#8*0+48]	// load |a| (or |b|)+	asr	x28, x16, #63		// |f0|'s sign as mask (or |g0|'s)+	ldp	x11, x12, [x1,#8*2+48]+	eor	x2, x16, x28	// conditionally negate |f0| (or |g0|)+	ldp	x13, x14, [x1,#8*4+48]++	eor	x9, x9, x28	// conditionally negate |a| (or |b|)+	sub	x2, x2, x28+	eor	x10, x10, x28+	adds	x9, x9, x28, lsr#63+	eor	x11, x11, x28+	adcs	x10, x10, xzr+	eor	x12, x12, x28+	adcs	x11, x11, xzr+	eor	x13, x13, x28+	umulh	x22, x9, x2+	adcs	x12, x12, xzr+	umulh	x23, x10, x2+	eor	x14, x14, x28+	umulh	x24, x11, x2+	adcs	x13, x13, xzr+	umulh	x25, x12, x2+	adc	x14, x14, xzr++	umulh	x26, x13, x2+	smulh	x28, x14, x2+	mul	x9, x9, x2+	mul	x10, x10, x2+	mul	x11, x11, x2+	adds	x10, x10, x22+	mul	x12, x12, x2+	adcs	x11, x11, x23+	mul	x13, x13, x2+	adcs	x12, x12, x24+	mul	x14, x14, x2+	adcs	x13, x13, x25+	adcs	x14, x14 ,x26+	adc	x28, x28, xzr+	adds	x3, x3, x9+	adcs	x4, x4, x10+	adcs	x5, x5, x11+	adcs	x6, x6, x12+	adcs	x7, x7, x13+	adcs	x8, x8, x14+	adc	x9, x27,   x28++	extr	x3, x4, x3, #62+	extr	x4, x5, x4, #62+	extr	x5, x6, x5, #62+	asr	x28, x9, #63+	extr	x6, x7, x6, #62+	extr	x7, x8, x7, #62+	extr	x8, x9, x8, #62++	eor	x3, x3, x28+	eor	x4, x4, x28+	adds	x3, x3, x28, lsr#63+	eor	x5, x5, x28+	adcs	x4, x4, xzr+	eor	x6, x6, x28+	adcs	x5, x5, xzr+	eor	x7, x7, x28+	adcs	x6, x6, xzr+	eor	x8, x8, x28+	stp	x3, x4, [x0,#8*0]+	adcs	x7, x7, xzr+	stp	x5, x6, [x0,#8*2]+	adc	x8, x8, xzr+	stp	x7, x8, [x0,#8*4]++	eor	x15, x15, x28+	eor	x16, x16, x28+	sub	x15, x15, x28+	sub	x16, x16, x28++	ret+++.align	4+__ab_approximation_62:+	ldp	x7, x8, [x1,#8*4]+	ldp	x13, x14, [x1,#8*10]+	ldp	x5, x6, [x1,#8*2]+	ldp	x11, x12, [x1,#8*8]++Lab_approximation_62_loaded:+	orr	x22, x8, x14	// check top-most limbs, ...+	cmp	x22, #0+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	csel	x7, x7, x6, ne+	orr	x22, x8, x14	// ... ones before top-most, ...+	csel	x13, x13, x12, ne++	ldp	x3, x4, [x1,#8*0]+	ldp	x9, x10, [x1,#8*6]++	cmp	x22, #0+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	csel	x7, x7, x5, ne+	orr	x22, x8, x14	// ... and ones before that ...+	csel	x13, x13, x11, ne++	cmp	x22, #0+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	csel	x7, x7, x4, ne+	orr	x22, x8, x14+	csel	x13, x13, x10, ne++	clz	x22, x22+	cmp	x22, #64+	csel	x22, x22, xzr, ne+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	neg	x23, x22++	lslv	x8, x8, x22	// align high limbs to the left+	lslv	x14, x14, x22+	lsrv	x7, x7, x23+	lsrv	x13, x13, x23+	and	x7, x7, x23, asr#6+	and	x13, x13, x23, asr#6+	orr	x8, x8, x7+	orr	x14, x14, x13++	b	__inner_loop_62+	ret+++.align	4+__inner_loop_62:+	mov	x15, #1		// |f0|=1+	mov	x16, #0		// |g0|=0+	mov	x17, #0		// |f1|=0+	mov	x19, #1		// |g1|=1++Loop_62:+	sbfx	x28, x3, #0, #1	// if |a_| is odd, then we'll be subtracting+	sub	x2, x2, #1+	subs	x24, x9, x3	// |b_|-|a_|+	and	x22, x9, x28+	sbc	x25, x14, x8+	and	x23, x14, x28+	subs	x26, x3, x22	// |a_|-|b_| (or |a_|-0 if |a_| was even)+	mov	x22, x15+	sbcs	x27, x8, x23+	mov	x23, x16+	csel	x9, x9, x3, hs	// |b_| = |a_|+	csel	x14, x14, x8, hs+	csel	x3, x26, x24, hs	// borrow means |a_|<|b_|, replace with |b_|-|a_|+	csel	x8, x27, x25, hs+	csel	x15, x15, x17,       hs	// exchange |f0| and |f1|+	csel	x17, x17, x22,     hs+	csel	x16, x16, x19,       hs	// exchange |g0| and |g1|+	csel	x19, x19, x23,     hs+	extr	x3, x8, x3, #1+	lsr	x8, x8, #1+	and	x22, x17, x28+	and	x23, x19, x28+	add	x17, x17, x17		// |f1|<<=1+	add	x19, x19, x19		// |g1|<<=1+	sub	x15, x15, x22		// |f0|-=|f1| (or |f0-=0| if |a_| was even)+	sub	x16, x16, x23		// |g0|-=|g1| (or |g0-=0| ...)+	cbnz	x2, Loop_62++	ret+
+ c-source/build/mach-o/ct_is_square_mod_384-armv8.S view
@@ -0,0 +1,324 @@+.text++.globl	_ct_is_square_mod_384++.align	5+_ct_is_square_mod_384:+.long	3573752639+	stp	x29, x30, [sp,#-128]!+	add	x29, sp, #0+	stp	x19, x20, [sp,#16]+	stp	x21, x22, [sp,#32]+	stp	x23, x24, [sp,#48]+	stp	x25, x26, [sp,#64]+	stp	x27, x28, [sp,#80]+	sub	sp, sp, #512++	ldp	x3, x4, [x0,#8*0]		// load input+	ldp	x5, x6, [x0,#8*2]+	ldp	x7, x8, [x0,#8*4]++	add	x0, sp, #255	// find closest 256-byte-aligned spot+	and	x0, x0, #-256	// in the frame...++	ldp	x9, x10, [x1,#8*0]		// load modulus+	ldp	x11, x12, [x1,#8*2]+	ldp	x13, x14, [x1,#8*4]++	stp	x3, x4, [x0,#8*6]	// copy input to |a|+	stp	x5, x6, [x0,#8*8]+	stp	x7, x8, [x0,#8*10]+	stp	x9, x10, [x0,#8*0]	// copy modulus to |b|+	stp	x11, x12, [x0,#8*2]+	stp	x13, x14, [x0,#8*4]++	eor	x2, x2, x2			// init the Legendre symbol+	mov	x15, #24			// 24 is 768/30-1+	b	Loop_is_square++.align	4+Loop_is_square:+	bl	__ab_approximation_30+	sub	x15, x15, #1++	eor	x1, x0, #128		// pointer to dst |b|+	bl	__smul_384_n_shift_by_30++	mov	x19, x16			// |f0|+	mov	x20, x17			// |g0|+	add	x1, x1, #8*6	// pointer to dst |a|+	bl	__smul_384_n_shift_by_30++	ldp	x9, x10, [x1,#-8*6]+	eor	x0, x0, #128		// flip-flop src |a|b|+	and	x27, x27, x9		// if |a| was negative,+	add	x2, x2, x27, lsr#1		// adjust |L|++	cbnz	x15, Loop_is_square++	////////////////////////////////////////// last iteration+	//bl	__ab_approximation_30		// |a| and |b| are exact,+	//ldr	x8, [x0,#8*6]		// and loaded+	//ldr	x14, [x0,#8*0]+	mov	x15, #48			// 48 is 768%30 + 30+	bl	__inner_loop_48+	ldr	x30, [x29,#8]++	and	x0, x2, #1+	eor	x0, x0, #1++	add	sp, sp, #512+	ldp	x19, x20, [x29,#16]+	ldp	x21, x22, [x29,#32]+	ldp	x23, x24, [x29,#48]+	ldp	x25, x26, [x29,#64]+	ldp	x27, x28, [x29,#80]+	ldr	x29, [sp],#128+.long	3573752767+	ret++++.align	5+__smul_384_n_shift_by_30:+	ldp	x3, x4, [x0,#8*0+0]	// load |b| (or |a|)+	asr	x27, x20, #63		// |g1|'s sign as mask (or |f1|'s)+	ldp	x5, x6, [x0,#8*2+0]+	eor	x20, x20, x27		// conditionally negate |g1| (or |f1|)+	ldp	x7, x8, [x0,#8*4+0]++	eor	x3, x3, x27	// conditionally negate |b| (or |a|)+	sub	x20, x20, x27+	eor	x4, x4, x27+	adds	x3, x3, x27, lsr#63+	eor	x5, x5, x27+	adcs	x4, x4, xzr+	eor	x6, x6, x27+	adcs	x5, x5, xzr+	eor	x7, x7, x27+	umulh	x21, x3, x20+	adcs	x6, x6, xzr+	umulh	x22, x4, x20+	eor	x8, x8, x27+	umulh	x23, x5, x20+	adcs	x7, x7, xzr+	umulh	x24, x6, x20+	adc	x8, x8, xzr++	umulh	x25, x7, x20+	and	x28, x20, x27+	umulh	x26, x8, x20+	neg	x28, x28+	mul	x3, x3, x20+	mul	x4, x4, x20+	mul	x5, x5, x20+	adds	x4, x4, x21+	mul	x6, x6, x20+	adcs	x5, x5, x22+	mul	x7, x7, x20+	adcs	x6, x6, x23+	mul	x8, x8, x20+	adcs	x7, x7, x24+	adcs	x8, x8 ,x25+	adc	x26, x26, x28+	ldp	x9, x10, [x0,#8*0+48]	// load |b| (or |a|)+	asr	x27, x19, #63		// |g1|'s sign as mask (or |f1|'s)+	ldp	x11, x12, [x0,#8*2+48]+	eor	x19, x19, x27		// conditionally negate |g1| (or |f1|)+	ldp	x13, x14, [x0,#8*4+48]++	eor	x9, x9, x27	// conditionally negate |b| (or |a|)+	sub	x19, x19, x27+	eor	x10, x10, x27+	adds	x9, x9, x27, lsr#63+	eor	x11, x11, x27+	adcs	x10, x10, xzr+	eor	x12, x12, x27+	adcs	x11, x11, xzr+	eor	x13, x13, x27+	umulh	x21, x9, x19+	adcs	x12, x12, xzr+	umulh	x22, x10, x19+	eor	x14, x14, x27+	umulh	x23, x11, x19+	adcs	x13, x13, xzr+	umulh	x24, x12, x19+	adc	x14, x14, xzr++	umulh	x25, x13, x19+	and	x28, x19, x27+	umulh	x27, x14, x19+	neg	x28, x28+	mul	x9, x9, x19+	mul	x10, x10, x19+	mul	x11, x11, x19+	adds	x10, x10, x21+	mul	x12, x12, x19+	adcs	x11, x11, x22+	mul	x13, x13, x19+	adcs	x12, x12, x23+	mul	x14, x14, x19+	adcs	x13, x13, x24+	adcs	x14, x14 ,x25+	adc	x27, x27, x28+	adds	x3, x3, x9+	adcs	x4, x4, x10+	adcs	x5, x5, x11+	adcs	x6, x6, x12+	adcs	x7, x7, x13+	adcs	x8, x8, x14+	adc	x9, x26,   x27++	extr	x3, x4, x3, #30+	extr	x4, x5, x4, #30+	extr	x5, x6, x5, #30+	asr	x27, x9, #63+	extr	x6, x7, x6, #30+	extr	x7, x8, x7, #30+	extr	x8, x9, x8, #30++	eor	x3, x3, x27+	eor	x4, x4, x27+	adds	x3, x3, x27, lsr#63+	eor	x5, x5, x27+	adcs	x4, x4, xzr+	eor	x6, x6, x27+	adcs	x5, x5, xzr+	eor	x7, x7, x27+	adcs	x6, x6, xzr+	eor	x8, x8, x27+	stp	x3, x4, [x1,#8*0]+	adcs	x7, x7, xzr+	stp	x5, x6, [x1,#8*2]+	adc	x8, x8, xzr+	stp	x7, x8, [x1,#8*4]++	ret+++.align	4+__ab_approximation_30:+	ldp	x13, x14, [x0,#8*4]	// |a| is still in registers+	ldp	x11, x12, [x0,#8*2]++	orr	x21, x8, x14	// check top-most limbs, ...+	cmp	x21, #0+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	csel	x7, x7, x6, ne+	orr	x21, x8, x14	// ... ones before top-most, ...+	csel	x13, x13, x12, ne++	cmp	x21, #0+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	csel	x7, x7, x5, ne+	orr	x21, x8, x14	// ... and ones before that ...+	csel	x13, x13, x11, ne++	cmp	x21, #0+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	csel	x7, x7, x4, ne+	orr	x21, x8, x14	// and one more, ...+	csel	x13, x13, x10, ne++	cmp	x21, #0+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	csel	x7, x7, x3, ne+	orr	x21, x8, x14+	csel	x13, x13, x9, ne++	clz	x21, x21+	cmp	x21, #64+	csel	x21, x21, xzr, ne+	csel	x8, x8, x7, ne+	csel	x14, x14, x13, ne+	neg	x22, x21++	lslv	x8, x8, x21	// align high limbs to the left+	lslv	x14, x14, x21+	lsrv	x7, x7, x22+	lsrv	x13, x13, x22+	and	x7, x7, x22, asr#6+	and	x13, x13, x22, asr#6+	orr	x8, x8, x7+	orr	x14, x14, x13++	bfxil	x8, x3, #0, #32+	bfxil	x14, x9, #0, #32++	b	__inner_loop_30+	ret++++.align	4+__inner_loop_30:+	mov	x28, #30+	mov	x17, #0x7FFFFFFF80000000	// |f0|=1, |g0|=0+	mov	x20, #0x800000007FFFFFFF	// |f1|=0, |g1|=1+	mov	x27,#0x7FFFFFFF7FFFFFFF++Loop_30:+	sbfx	x24, x8, #0, #1	// if |a_| is odd, then we'll be subtracting+	and	x25, x8, x14+	sub	x28, x28, #1+	and	x21, x14, x24++	sub	x22, x14, x8		// |b_|-|a_|+	subs	x23, x8, x21	// |a_|-|b_| (or |a_|-0 if |a_| was even)+	add	x25, x2, x25, lsr#1	// L + (a_ & b_) >> 1+	mov	x21, x20+	csel	x14, x14, x8, hs	// |b_| = |a_|+	csel	x8, x23, x22, hs	// borrow means |a_|<|b_|, replace with |b_|-|a_|+	csel	x20, x20, x17,  hs	// exchange |fg0| and |fg1|+	csel	x17, x17, x21, hs+	csel	x2,   x2,   x25, hs+	lsr	x8, x8, #1+	and	x21, x20, x24+	and	x22, x27, x24+	add	x23, x14, #2+	sub	x17, x17, x21	// |f0|-=|f1| (or |f0-=0| if |a_| was even)+	add	x20, x20, x20	// |f1|<<=1+	add	x2, x2, x23, lsr#2	// "negate" |L| if |b|%8 is 3 or 5+	add	x17, x17, x22+	sub	x20, x20, x27++	cbnz	x28, Loop_30++	mov	x27, #0x7FFFFFFF+	ubfx	x16, x17, #0, #32+	ubfx	x17, x17, #32, #32+	ubfx	x19, x20, #0, #32+	ubfx	x20, x20, #32, #32+	sub	x16, x16, x27		// remove the bias+	sub	x17, x17, x27+	sub	x19, x19, x27+	sub	x20, x20, x27++	ret+++.align	4+__inner_loop_48:+Loop_48:+	sbfx	x24, x3, #0, #1	// if |a_| is odd, then we'll be subtracting+	and	x25, x3, x9+	sub	x15, x15, #1+	and	x21, x9, x24+	sub	x22, x9, x3		// |b_|-|a_|+	subs	x23, x3, x21	// |a_|-|b_| (or |a_|-0 if |a_| was even)+	add	x25, x2, x25, lsr#1+	csel	x9, x9, x3, hs	// |b_| = |a_|+	csel	x3, x23, x22, hs	// borrow means |a_|<|b_|, replace with |b_|-|a_|+	csel	x2,   x2,   x25, hs+	add	x23, x9, #2+	lsr	x3, x3, #1+	add	x2, x2, x23, lsr#2	// "negate" |L| if |b|%8 is 3 or 5++	cbnz	x15, Loop_48++	ret+
+ c-source/build/mach-o/ct_is_square_mod_384-x86_64.s view
@@ -0,0 +1,471 @@+.text	++.globl	_ct_is_square_mod_384++.p2align	5+_ct_is_square_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$536,%rsp+.cfi_adjust_cfa_offset	536+++	leaq	24+255(%rsp),%rax+	andq	$-256,%rax++	movq	0(%rdi),%r8+	movq	8(%rdi),%r9+	movq	16(%rdi),%r10+	movq	24(%rdi),%r11+	movq	32(%rdi),%r12+	movq	40(%rdi),%r13++	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%rbx+	movq	24(%rsi),%rcx+	movq	32(%rsi),%rdx+	movq	40(%rsi),%rdi+	movq	%rax,%rsi++	movq	%r8,0(%rax)+	movq	%r9,8(%rax)+	movq	%r10,16(%rax)+	movq	%r11,24(%rax)+	movq	%r12,32(%rax)+	movq	%r13,40(%rax)++	movq	%r14,48(%rax)+	movq	%r15,56(%rax)+	movq	%rbx,64(%rax)+	movq	%rcx,72(%rax)+	movq	%rdx,80(%rax)+	movq	%rdi,88(%rax)++	xorq	%rbp,%rbp+	movl	$24,%ecx+	jmp	L$oop_is_square++.p2align	5+L$oop_is_square:+	movl	%ecx,16(%rsp)++	call	__ab_approximation_30+	movq	%rax,0(%rsp)+	movq	%rbx,8(%rsp)++	movq	$128+48,%rdi+	xorq	%rsi,%rdi+	call	__smulq_384_n_shift_by_30++	movq	0(%rsp),%rdx+	movq	8(%rsp),%rcx+	leaq	-48(%rdi),%rdi+	call	__smulq_384_n_shift_by_30++	movl	16(%rsp),%ecx+	xorq	$128,%rsi++	andq	48(%rdi),%r14+	shrq	$1,%r14+	addq	%r14,%rbp++	subl	$1,%ecx+	jnz	L$oop_is_square+++++	movq	48(%rsi),%r9+	call	__inner_loop_48++	movq	$1,%rax+	andq	%rbp,%rax+	xorq	$1,%rax++	leaq	536(%rsp),%r8+	movq	0(%r8),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-536-8*6++	.byte	0xf3,0xc3+.cfi_endproc	++++.p2align	5+__smulq_384_n_shift_by_30:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rdx,%rbx+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbx+	addq	%rax,%rbx++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	movq	%rdx,%r14+	andq	%rbx,%r14+	mulq	%rbx+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbx+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rbx+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rbx+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	mulq	%rbx+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	negq	%r14+	mulq	%rbx+	addq	%rax,%r13+	adcq	%rdx,%r14+	leaq	48(%rsi),%rsi+	movq	%rcx,%rdx++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)+	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rdx,%rbx+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbx+	addq	%rax,%rbx++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	movq	%rdx,%r15+	andq	%rbx,%r15+	mulq	%rbx+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbx+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rbx+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rbx+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	mulq	%rbx+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	negq	%r15+	mulq	%rbx+	addq	%rax,%r13+	adcq	%rdx,%r15+	leaq	-48(%rsi),%rsi++	addq	0(%rdi),%r8+	adcq	8(%rdi),%r9+	adcq	16(%rdi),%r10+	adcq	24(%rdi),%r11+	adcq	32(%rdi),%r12+	adcq	40(%rdi),%r13+	adcq	%r15,%r14++	shrdq	$30,%r9,%r8+	shrdq	$30,%r10,%r9+	shrdq	$30,%r11,%r10+	shrdq	$30,%r12,%r11+	shrdq	$30,%r13,%r12+	shrdq	$30,%r14,%r13++	sarq	$63,%r14+	xorq	%rbx,%rbx+	subq	%r14,%rbx++	xorq	%r14,%r8+	xorq	%r14,%r9+	xorq	%r14,%r10+	xorq	%r14,%r11+	xorq	%r14,%r12+	xorq	%r14,%r13+	addq	%rbx,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+++.p2align	5+__ab_approximation_30:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	88(%rsi),%rbx+	movq	80(%rsi),%r15+	movq	72(%rsi),%r14++	movq	%r13,%rax+	orq	%rbx,%rax+	cmovzq	%r12,%r13+	cmovzq	%r15,%rbx+	cmovzq	%r11,%r12+	movq	64(%rsi),%r11+	cmovzq	%r14,%r15++	movq	%r13,%rax+	orq	%rbx,%rax+	cmovzq	%r12,%r13+	cmovzq	%r15,%rbx+	cmovzq	%r10,%r12+	movq	56(%rsi),%r10+	cmovzq	%r11,%r15++	movq	%r13,%rax+	orq	%rbx,%rax+	cmovzq	%r12,%r13+	cmovzq	%r15,%rbx+	cmovzq	%r9,%r12+	movq	48(%rsi),%r9+	cmovzq	%r10,%r15++	movq	%r13,%rax+	orq	%rbx,%rax+	cmovzq	%r12,%r13+	cmovzq	%r15,%rbx+	cmovzq	%r8,%r12+	cmovzq	%r9,%r15++	movq	%r13,%rax+	orq	%rbx,%rax+	bsrq	%rax,%rcx+	leaq	1(%rcx),%rcx+	cmovzq	%r8,%r13+	cmovzq	%r9,%rbx+	cmovzq	%rax,%rcx+	negq	%rcx+++	shldq	%cl,%r12,%r13+	shldq	%cl,%r15,%rbx++	movq	$0xFFFFFFFF00000000,%rax+	movl	%r8d,%r8d+	movl	%r9d,%r9d+	andq	%rax,%r13+	andq	%rax,%rbx+	orq	%r13,%r8+	orq	%rbx,%r9++	jmp	__inner_loop_30++	.byte	0xf3,0xc3+.cfi_endproc+++.p2align	5+__inner_loop_30:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	$0x7FFFFFFF80000000,%rbx+	movq	$0x800000007FFFFFFF,%rcx+	leaq	-1(%rbx),%r15+	movl	$30,%edi++L$oop_30:+	movq	%r8,%rax+	andq	%r9,%rax+	shrq	$1,%rax++	cmpq	%r9,%r8+	movq	%r8,%r10+	movq	%r9,%r11+	leaq	(%rax,%rbp,1),%rax+	movq	%rbx,%r12+	movq	%rcx,%r13+	movq	%rbp,%r14+	cmovbq	%r9,%r8+	cmovbq	%r10,%r9+	cmovbq	%rcx,%rbx+	cmovbq	%r12,%rcx+	cmovbq	%rax,%rbp++	subq	%r9,%r8+	subq	%rcx,%rbx+	addq	%r15,%rbx++	testq	$1,%r10+	cmovzq	%r10,%r8+	cmovzq	%r11,%r9+	cmovzq	%r12,%rbx+	cmovzq	%r13,%rcx+	cmovzq	%r14,%rbp++	leaq	2(%r9),%rax+	shrq	$1,%r8+	shrq	$2,%rax+	addq	%rcx,%rcx+	leaq	(%rax,%rbp,1),%rbp+	subq	%r15,%rcx++	subl	$1,%edi+	jnz	L$oop_30++	shrq	$32,%r15+	movl	%ebx,%eax+	shrq	$32,%rbx+	movl	%ecx,%edx+	shrq	$32,%rcx+	subq	%r15,%rax+	subq	%r15,%rbx+	subq	%r15,%rdx+	subq	%r15,%rcx++	.byte	0xf3,0xc3+.cfi_endproc++++.p2align	5+__inner_loop_48:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movl	$48,%edi++L$oop_48:+	movq	%r8,%rax+	andq	%r9,%rax+	shrq	$1,%rax++	cmpq	%r9,%r8+	movq	%r8,%r10+	movq	%r9,%r11+	leaq	(%rax,%rbp,1),%rax+	movq	%rbp,%r12+	cmovbq	%r9,%r8+	cmovbq	%r10,%r9+	cmovbq	%rax,%rbp++	subq	%r9,%r8++	testq	$1,%r10+	cmovzq	%r10,%r8+	cmovzq	%r11,%r9+	cmovzq	%r12,%rbp++	leaq	2(%r9),%rax+	shrq	$1,%r8+	shrq	$2,%rax+	addq	%rax,%rbp++	subl	$1,%edi+	jnz	L$oop_48++	.byte	0xf3,0xc3+.cfi_endproc+
+ c-source/build/mach-o/ctq_inverse_mod_384-x86_64.s view
@@ -0,0 +1,1187 @@+.text	++.globl	_ct_inverse_mod_383++.p2align	5+_ct_inverse_mod_383:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$1112,%rsp+.cfi_adjust_cfa_offset	1112+++	leaq	88+511(%rsp),%rax+	andq	$-512,%rax+	movq	%rdi,32(%rsp)+	movq	%rcx,40(%rsp)++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	0(%rdx),%r14+	movq	8(%rdx),%r15+	movq	16(%rdx),%rbx+	movq	24(%rdx),%rbp+	movq	32(%rdx),%rsi+	movq	40(%rdx),%rdi++	movq	%r8,0(%rax)+	movq	%r9,8(%rax)+	movq	%r10,16(%rax)+	movq	%r11,24(%rax)+	movq	%r12,32(%rax)+	movq	%r13,40(%rax)++	movq	%r14,48(%rax)+	movq	%r15,56(%rax)+	movq	%rbx,64(%rax)+	movq	%rbp,72(%rax)+	movq	%rsi,80(%rax)+	movq	%rax,%rsi+	movq	%rdi,88(%rax)+++	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+++	movq	%rdx,96(%rdi)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+++	movq	%rdx,96(%rdi)+++	xorq	$256,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62++++	movq	96(%rsi),%rax+	movq	144(%rsi),%r11+	movq	%rdx,%rbx+	movq	%rax,%r10+	imulq	56(%rsp)+	movq	%rax,%r8+	movq	%r11,%rax+	movq	%rdx,%r9+	imulq	64(%rsp)+	addq	%rax,%r8+	adcq	%rdx,%r9+	movq	%r8,48(%rdi)+	movq	%r9,56(%rdi)+	sarq	$63,%r9+	movq	%r9,64(%rdi)+	movq	%r9,72(%rdi)+	movq	%r9,80(%rdi)+	movq	%r9,88(%rdi)+	leaq	96(%rsi),%rsi++	movq	%r10,%rax+	imulq	%rbx+	movq	%rax,%r8+	movq	%r11,%rax+	movq	%rdx,%r9+	imulq	%rcx+	addq	%rax,%r8+	adcq	%rdx,%r9+	movq	%r8,96(%rdi)+	movq	%r9,104(%rdi)+	sarq	$63,%r9+	movq	%r9,112(%rdi)+	movq	%r9,120(%rdi)+	movq	%r9,128(%rdi)+	movq	%r9,136(%rdi)+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383x63+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383x63+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383x63+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383x63+	sarq	$63,%r13+	movq	%r13,48(%rdi)+	movq	%r13,56(%rdi)+	movq	%r13,64(%rdi)+	movq	%r13,72(%rdi)+	movq	%r13,80(%rdi)+	movq	%r13,88(%rdi)+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_767x63+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_767x63+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_767x63+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_767x63+	xorq	$256+96,%rsi+	movl	$62,%edi+	call	__ab_approximation_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_383_n_shift_by_62+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_767x63++	xorq	$256+96,%rsi+	movl	$62,%edi++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	48(%rsi),%r10+	movq	56(%rsi),%r11+	call	__inner_loop_62+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	movq	%r8,0(%rdi)+	movq	%r10,48(%rdi)++++	leaq	96(%rsi),%rsi+	leaq	96(%rdi),%rdi+	call	__smulq_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulq_767x63+++	xorq	$256+96,%rsi+	movl	$22,%edi++	movq	0(%rsi),%r8+	xorq	%r9,%r9+	movq	48(%rsi),%r10+	xorq	%r11,%r11+	call	__inner_loop_62++++++++	leaq	96(%rsi),%rsi++++++	movq	%r12,%rdx+	movq	%r13,%rcx+	movq	32(%rsp),%rdi+	call	__smulq_767x63++	movq	40(%rsp),%rsi+	movq	%rax,%rdx+	sarq	$63,%rax++	movq	%rax,%r8+	movq	%rax,%r9+	movq	%rax,%r10+	andq	0(%rsi),%r8+	andq	8(%rsi),%r9+	movq	%rax,%r11+	andq	16(%rsi),%r10+	andq	24(%rsi),%r11+	movq	%rax,%r12+	andq	32(%rsi),%r12+	andq	40(%rsi),%rax++	addq	%r8,%r14+	adcq	%r9,%r15+	adcq	%r10,%rbx+	adcq	%r11,%rbp+	adcq	%r12,%rcx+	adcq	%rax,%rdx++	movq	%r14,48(%rdi)+	movq	%r15,56(%rdi)+	movq	%rbx,64(%rdi)+	movq	%rbp,72(%rdi)+	movq	%rcx,80(%rdi)+	movq	%rdx,88(%rdi)++	leaq	1112(%rsp),%r8+	movq	0(%r8),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-1112-8*6++	.byte	0xf3,0xc3+.cfi_endproc	+++.p2align	5+__smulq_767x63:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rdx,%rbp+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	leaq	48(%rsi),%rsi++	xorq	%rdx,%rbp+	addq	%rax,%rbp++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	mulq	%rbp+	movq	%rax,0(%rdi)+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbp+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	movq	%r9,8(%rdi)+	mulq	%rbp+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	movq	%r10,16(%rdi)+	mulq	%rbp+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	movq	%r11,24(%rdi)+	mulq	%rbp+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	movq	%r12,32(%rdi)+	imulq	%rbp+	addq	%rax,%r13+	adcq	$0,%rdx++	movq	%r13,40(%rdi)+	movq	%rdx,48(%rdi)+	sarq	$63,%rdx+	movq	%rdx,56(%rdi)+	movq	%rcx,%rdx++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	48(%rsi),%r14+	movq	56(%rsi),%r15+	movq	64(%rsi),%rbx+	movq	72(%rsi),%rbp+	movq	80(%rsi),%rcx+	movq	88(%rsi),%rdi++	movq	%rdx,%rsi+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rsi+	addq	%rax,%rsi++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	xorq	%rdx,%r14+	xorq	%rdx,%r15+	xorq	%rdx,%rbx+	xorq	%rdx,%rbp+	xorq	%rdx,%rcx+	xorq	%rdx,%rdi+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13+	adcq	$0,%r14+	adcq	$0,%r15+	adcq	$0,%rbx+	adcq	$0,%rbp+	adcq	$0,%rcx+	adcq	$0,%rdi++	mulq	%rsi+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rsi+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rsi+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rsi+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	mulq	%rsi+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	mulq	%rsi+	addq	%rax,%r13+	movq	%r14,%rax+	adcq	$0,%rdx+	movq	%rdx,%r14+	mulq	%rsi+	addq	%rax,%r14+	movq	%r15,%rax+	adcq	$0,%rdx+	movq	%rdx,%r15+	mulq	%rsi+	addq	%rax,%r15+	movq	%rbx,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbx+	mulq	%rsi+	addq	%rax,%rbx+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp+	mulq	%rsi+	addq	%rax,%rbp+	movq	%rcx,%rax+	adcq	$0,%rdx+	movq	%rdx,%rcx+	mulq	%rsi+	addq	%rax,%rcx+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%rdi+	movq	8(%rsp),%rdx+	imulq	%rsi,%rax+	movq	16(%rsp),%rsi+	addq	%rdi,%rax++	addq	0(%rdx),%r8+	adcq	8(%rdx),%r9+	adcq	16(%rdx),%r10+	adcq	24(%rdx),%r11+	adcq	32(%rdx),%r12+	adcq	40(%rdx),%r13+	adcq	48(%rdx),%r14+	movq	56(%rdx),%rdi+	adcq	%rdi,%r15+	adcq	%rdi,%rbx+	adcq	%rdi,%rbp+	adcq	%rdi,%rcx+	adcq	%rdi,%rax++	movq	%rdx,%rdi++	movq	%r8,0(%rdx)+	movq	%r9,8(%rdx)+	movq	%r10,16(%rdx)+	movq	%r11,24(%rdx)+	movq	%r12,32(%rdx)+	movq	%r13,40(%rdx)+	movq	%r14,48(%rdx)+	movq	%r15,56(%rdx)+	movq	%rbx,64(%rdx)+	movq	%rbp,72(%rdx)+	movq	%rcx,80(%rdx)+	movq	%rax,88(%rdx)++	.byte	0xf3,0xc3+.cfi_endproc+++.p2align	5+__smulq_383x63:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rdx,%rbp+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbp+	addq	%rax,%rbp++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	mulq	%rbp+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbp+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rbp+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rbp+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	mulq	%rbp+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	imulq	%rbp,%rax+	addq	%rax,%r13++	leaq	48(%rsi),%rsi+	movq	%rcx,%rdx++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)+	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rdx,%rbp+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbp+	addq	%rax,%rbp++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	mulq	%rbp+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbp+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rbp+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rbp+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	mulq	%rbp+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	imulq	%rbp,%rax+	addq	%rax,%r13++	leaq	-48(%rsi),%rsi++	addq	0(%rdi),%r8+	adcq	8(%rdi),%r9+	adcq	16(%rdi),%r10+	adcq	24(%rdi),%r11+	adcq	32(%rdi),%r12+	adcq	40(%rdi),%r13++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+++.p2align	5+__smulq_383_n_shift_by_62:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	%rdx,%rbx+	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rdx,%rbp+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbp+	addq	%rax,%rbp++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	mulq	%rbp+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbp+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rbp+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rbp+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	mulq	%rbp+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	imulq	%rbp+	addq	%rax,%r13+	adcq	$0,%rdx++	leaq	48(%rsi),%rsi+	movq	%rdx,%r14+	movq	%rcx,%rdx++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)+	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rdx,%rbp+	sarq	$63,%rdx+	xorq	%rax,%rax+	subq	%rdx,%rax++	xorq	%rdx,%rbp+	addq	%rax,%rbp++	xorq	%rdx,%r8+	xorq	%rdx,%r9+	xorq	%rdx,%r10+	xorq	%rdx,%r11+	xorq	%rdx,%r12+	xorq	%rdx,%r13+	addq	%r8,%rax+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	mulq	%rbp+	movq	%rax,%r8+	movq	%r9,%rax+	movq	%rdx,%r9+	mulq	%rbp+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10+	mulq	%rbp+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11+	mulq	%rbp+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	mulq	%rbp+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13+	imulq	%rbp+	addq	%rax,%r13+	adcq	$0,%rdx++	leaq	-48(%rsi),%rsi++	addq	0(%rdi),%r8+	adcq	8(%rdi),%r9+	adcq	16(%rdi),%r10+	adcq	24(%rdi),%r11+	adcq	32(%rdi),%r12+	adcq	40(%rdi),%r13+	adcq	%rdx,%r14+	movq	%rbx,%rdx++	shrdq	$62,%r9,%r8+	shrdq	$62,%r10,%r9+	shrdq	$62,%r11,%r10+	shrdq	$62,%r12,%r11+	shrdq	$62,%r13,%r12+	shrdq	$62,%r14,%r13++	sarq	$63,%r14+	xorq	%rbp,%rbp+	subq	%r14,%rbp++	xorq	%r14,%r8+	xorq	%r14,%r9+	xorq	%r14,%r10+	xorq	%r14,%r11+	xorq	%r14,%r12+	xorq	%r14,%r13+	addq	%rbp,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	xorq	%r14,%rdx+	xorq	%r14,%rcx+	addq	%rbp,%rdx+	addq	%rbp,%rcx++	.byte	0xf3,0xc3+.cfi_endproc+++.p2align	5+__ab_approximation_62:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	40(%rsi),%r9+	movq	88(%rsi),%r11+	movq	32(%rsi),%rbx+	movq	80(%rsi),%rbp+	movq	24(%rsi),%r8+	movq	72(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	cmovzq	%r10,%rbp+	movq	16(%rsi),%r8+	movq	64(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	cmovzq	%r10,%rbp+	movq	8(%rsi),%r8+	movq	56(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	cmovzq	%r10,%rbp+	movq	0(%rsi),%r8+	movq	48(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	bsrq	%rax,%rcx+	leaq	1(%rcx),%rcx+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%rax,%rcx+	negq	%rcx+++	shldq	%cl,%rbx,%r9+	shldq	%cl,%rbp,%r11++	jmp	__inner_loop_62++	.byte	0xf3,0xc3+.cfi_endproc+++.p2align	3+.long	0+__inner_loop_62:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	$1,%rdx+	xorq	%rcx,%rcx+	xorq	%r12,%r12+	movq	$1,%r13+	movq	%rsi,8(%rsp)++L$oop_62:+	xorq	%rax,%rax+	xorq	%rbx,%rbx+	testq	$1,%r8+	movq	%r10,%rbp+	movq	%r11,%r14+	cmovnzq	%r10,%rax+	cmovnzq	%r11,%rbx+	subq	%r8,%rbp+	sbbq	%r9,%r14+	movq	%r8,%r15+	movq	%r9,%rsi+	subq	%rax,%r8+	sbbq	%rbx,%r9+	cmovcq	%rbp,%r8+	cmovcq	%r14,%r9+	cmovcq	%r15,%r10+	cmovcq	%rsi,%r11+	movq	%rdx,%rax+	cmovcq	%r12,%rdx+	cmovcq	%rax,%r12+	movq	%rcx,%rbx+	cmovcq	%r13,%rcx+	cmovcq	%rbx,%r13+	xorq	%rax,%rax+	xorq	%rbx,%rbx+	shrdq	$1,%r9,%r8+	shrq	$1,%r9+	testq	$1,%r15+	cmovnzq	%r12,%rax+	cmovnzq	%r13,%rbx+	addq	%r12,%r12+	addq	%r13,%r13+	subq	%rax,%rdx+	subq	%rbx,%rcx+	subl	$1,%edi+	jnz	L$oop_62++	movq	8(%rsp),%rsi+	.byte	0xf3,0xc3+.cfi_endproc+
+ c-source/build/mach-o/ctx_inverse_mod_384-x86_64.s view
@@ -0,0 +1,1566 @@+.text	++.globl	_ctx_inverse_mod_383++.p2align	5+_ctx_inverse_mod_383:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$1112,%rsp+.cfi_adjust_cfa_offset	1112+++	leaq	88+511(%rsp),%rax+	andq	$-512,%rax+	movq	%rdi,32(%rsp)+	movq	%rcx,40(%rsp)++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	0(%rdx),%r14+	movq	8(%rdx),%r15+	movq	16(%rdx),%rbx+	movq	24(%rdx),%rbp+	movq	32(%rdx),%rsi+	movq	40(%rdx),%rdi++	movq	%r8,0(%rax)+	movq	%r9,8(%rax)+	movq	%r10,16(%rax)+	movq	%r11,24(%rax)+	movq	%r12,32(%rax)+	movq	%r13,40(%rax)++	movq	%r14,48(%rax)+	movq	%r15,56(%rax)+	movq	%rbx,64(%rax)+	movq	%rbp,72(%rax)+	movq	%rsi,80(%rax)+	movq	%rax,%rsi+	movq	%rdi,88(%rax)+++	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+++	movq	%rdx,96(%rdi)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+++	movq	%rdx,96(%rdi)+++	xorq	$256,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31++++	movq	96(%rsi),%rax+	movq	144(%rsi),%r11+	movq	%rdx,%rbx+	movq	%rax,%r10+	imulq	56(%rsp)+	movq	%rax,%r8+	movq	%r11,%rax+	movq	%rdx,%r9+	imulq	64(%rsp)+	addq	%rax,%r8+	adcq	%rdx,%r9+	movq	%r8,48(%rdi)+	movq	%r9,56(%rdi)+	sarq	$63,%r9+	movq	%r9,64(%rdi)+	movq	%r9,72(%rdi)+	movq	%r9,80(%rdi)+	movq	%r9,88(%rdi)+	leaq	96(%rsi),%rsi++	movq	%r10,%rax+	imulq	%rbx+	movq	%rax,%r8+	movq	%r11,%rax+	movq	%rdx,%r9+	imulq	%rcx+	addq	%rax,%r8+	adcq	%rdx,%r9+	movq	%r8,96(%rdi)+	movq	%r9,104(%rdi)+	sarq	$63,%r9+	movq	%r9,112(%rdi)+	movq	%r9,120(%rdi)+	movq	%r9,128(%rdi)+	movq	%r9,136(%rdi)+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383x63+	sarq	$63,%r13+	movq	%r13,48(%rdi)+	movq	%r13,56(%rdi)+	movq	%r13,64(%rdi)+	movq	%r13,72(%rdi)+	movq	%r13,80(%rdi)+	movq	%r13,88(%rdi)+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_383_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_191_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_191_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_191_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_191_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_191_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_191_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63+	xorq	$256+96,%rsi+	movl	$31,%edi+	call	__ab_approximation_31+++	movq	%r12,72(%rsp)+	movq	%r13,80(%rsp)++	movq	$256,%rdi+	xorq	%rsi,%rdi+	call	__smulx_191_n_shift_by_31+	movq	%rdx,56(%rsp)+	movq	%rcx,64(%rsp)++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_191_n_shift_by_31+	movq	%rdx,72(%rsp)+	movq	%rcx,80(%rsp)++	movq	56(%rsp),%rdx+	movq	64(%rsp),%rcx+	leaq	96(%rsi),%rsi+	leaq	48(%rdi),%rdi+	call	__smulx_383x63++	movq	72(%rsp),%rdx+	movq	80(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__smulx_767x63++	xorq	$256+96,%rsi+	movl	$53,%edi++	movq	0(%rsi),%r8++	movq	48(%rsi),%r10++	call	__inner_loop_62++++++++	leaq	96(%rsi),%rsi++++++	movq	%r12,%rdx+	movq	%r13,%rcx+	movq	32(%rsp),%rdi+	call	__smulx_767x63++	movq	40(%rsp),%rsi+	movq	%rax,%rdx+	sarq	$63,%rax++	movq	%rax,%r8+	movq	%rax,%r9+	movq	%rax,%r10+	andq	0(%rsi),%r8+	andq	8(%rsi),%r9+	movq	%rax,%r11+	andq	16(%rsi),%r10+	andq	24(%rsi),%r11+	movq	%rax,%r12+	andq	32(%rsi),%r12+	andq	40(%rsi),%rax++	addq	%r8,%r14+	adcq	%r9,%r15+	adcq	%r10,%rbx+	adcq	%r11,%rbp+	adcq	%r12,%rcx+	adcq	%rax,%rdx++	movq	%r14,48(%rdi)+	movq	%r15,56(%rdi)+	movq	%rbx,64(%rdi)+	movq	%rbp,72(%rdi)+	movq	%rcx,80(%rdi)+	movq	%rdx,88(%rdi)++	leaq	1112(%rsp),%r8+	movq	0(%r8),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-1112-8*6++	.byte	0xf3,0xc3+.cfi_endproc	+++.p2align	5+__smulx_767x63:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rdx,%rax+	sarq	$63,%rax+	xorq	%rbp,%rbp+	subq	%rax,%rbp++	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+	leaq	48(%rsi),%rsi++	xorq	%rax,%rdx+	addq	%rbp,%rdx++	xorq	%rax,%r8+	xorq	%rax,%r9+	xorq	%rax,%r10+	xorq	%rax,%r11+	xorq	%rax,%r12+	xorq	%r13,%rax+	addq	%rbp,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%rax++	mulxq	%r8,%r8,%rbp+	mulxq	%r9,%r9,%r13+	addq	%rbp,%r9+	mulxq	%r10,%r10,%rbp+	adcq	%r13,%r10+	mulxq	%r11,%r11,%r13+	adcq	%rbp,%r11+	mulxq	%r12,%r12,%rbp+	adcq	%r13,%r12+	adcq	$0,%rbp+	imulq	%rdx+	addq	%rbp,%rax+	adcq	$0,%rdx++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%rax,40(%rdi)+	movq	%rdx,48(%rdi)+	sarq	$63,%rdx+	movq	%rdx,56(%rdi)+	movq	%rcx,%rdx+	movq	%rcx,%rax++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	48(%rsi),%r14+	movq	56(%rsi),%r15+	movq	64(%rsi),%rbx+	movq	72(%rsi),%rbp+	movq	80(%rsi),%rcx+	movq	88(%rsi),%rdi++	sarq	$63,%rax+	xorq	%rsi,%rsi+	subq	%rax,%rsi++	xorq	%rax,%rdx+	addq	%rsi,%rdx++	xorq	%rax,%r8+	xorq	%rax,%r9+	xorq	%rax,%r10+	xorq	%rax,%r11+	xorq	%rax,%r12+	xorq	%rax,%r13+	xorq	%rax,%r14+	xorq	%rax,%r15+	xorq	%rax,%rbx+	xorq	%rax,%rbp+	xorq	%rax,%rcx+	xorq	%rax,%rdi+	addq	%rsi,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13+	adcq	$0,%r14+	adcq	$0,%r15+	adcq	$0,%rbx+	adcq	$0,%rbp+	adcq	$0,%rcx+	adcq	$0,%rdi++	mulxq	%r8,%r8,%rax+	mulxq	%r9,%r9,%rsi+	addq	%rax,%r9+	mulxq	%r10,%r10,%rax+	adcq	%rsi,%r10+	mulxq	%r11,%r11,%rsi+	adcq	%rax,%r11+	mulxq	%r12,%r12,%rax+	adcq	%rsi,%r12+	mulxq	%r13,%r13,%rsi+	adcq	%rax,%r13+	mulxq	%r14,%r14,%rax+	adcq	%rsi,%r14+	mulxq	%r15,%r15,%rsi+	adcq	%rax,%r15+	mulxq	%rbx,%rbx,%rax+	adcq	%rsi,%rbx+	mulxq	%rbp,%rbp,%rsi+	adcq	%rax,%rbp+	mulxq	%rcx,%rcx,%rax+	adcq	%rsi,%rcx+	mulxq	%rdi,%rdi,%rsi+	movq	8(%rsp),%rdx+	movq	16(%rsp),%rsi+	adcq	%rdi,%rax++	addq	0(%rdx),%r8+	adcq	8(%rdx),%r9+	adcq	16(%rdx),%r10+	adcq	24(%rdx),%r11+	adcq	32(%rdx),%r12+	adcq	40(%rdx),%r13+	adcq	48(%rdx),%r14+	movq	56(%rdx),%rdi+	adcq	%rdi,%r15+	adcq	%rdi,%rbx+	adcq	%rdi,%rbp+	adcq	%rdi,%rcx+	adcq	%rdi,%rax++	movq	%rdx,%rdi++	movq	%r8,0(%rdx)+	movq	%r9,8(%rdx)+	movq	%r10,16(%rdx)+	movq	%r11,24(%rdx)+	movq	%r12,32(%rdx)+	movq	%r13,40(%rdx)+	movq	%r14,48(%rdx)+	movq	%r15,56(%rdx)+	movq	%rbx,64(%rdx)+	movq	%rbp,72(%rdx)+	movq	%rcx,80(%rdx)+	movq	%rax,88(%rdx)++	.byte	0xf3,0xc3+.cfi_endproc+++.p2align	5+__smulx_383x63:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0+0(%rsi),%r8+	movq	0+8(%rsi),%r9+	movq	0+16(%rsi),%r10+	movq	0+24(%rsi),%r11+	movq	0+32(%rsi),%r12+	movq	0+40(%rsi),%r13++	movq	%rdx,%rbp+	sarq	$63,%rbp+	xorq	%rax,%rax+	subq	%rbp,%rax++	xorq	%rbp,%rdx+	addq	%rax,%rdx++	xorq	%rbp,%r8+	xorq	%rbp,%r9+	xorq	%rbp,%r10+	xorq	%rbp,%r11+	xorq	%rbp,%r12+	xorq	%rbp,%r13+	addq	%rax,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	mulxq	%r8,%r8,%rbp+	mulxq	%r9,%r9,%rax+	addq	%rbp,%r9+	mulxq	%r10,%r10,%rbp+	adcq	%rax,%r10+	mulxq	%r11,%r11,%rax+	adcq	%rbp,%r11+	mulxq	%r12,%r12,%rbp+	adcq	%rax,%r12+	mulxq	%r13,%r13,%rax+	movq	%rcx,%rdx+	adcq	%rbp,%r13++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)+	movq	48+0(%rsi),%r8+	movq	48+8(%rsi),%r9+	movq	48+16(%rsi),%r10+	movq	48+24(%rsi),%r11+	movq	48+32(%rsi),%r12+	movq	48+40(%rsi),%r13++	movq	%rdx,%rbp+	sarq	$63,%rbp+	xorq	%rax,%rax+	subq	%rbp,%rax++	xorq	%rbp,%rdx+	addq	%rax,%rdx++	xorq	%rbp,%r8+	xorq	%rbp,%r9+	xorq	%rbp,%r10+	xorq	%rbp,%r11+	xorq	%rbp,%r12+	xorq	%rbp,%r13+	addq	%rax,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	mulxq	%r8,%r8,%rbp+	mulxq	%r9,%r9,%rax+	addq	%rbp,%r9+	mulxq	%r10,%r10,%rbp+	adcq	%rax,%r10+	mulxq	%r11,%r11,%rax+	adcq	%rbp,%r11+	mulxq	%r12,%r12,%rbp+	adcq	%rax,%r12+	mulxq	%r13,%r13,%rax+	adcq	%rbp,%r13++	addq	0(%rdi),%r8+	adcq	8(%rdi),%r9+	adcq	16(%rdi),%r10+	adcq	24(%rdi),%r11+	adcq	32(%rdi),%r12+	adcq	40(%rdi),%r13++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+++.p2align	5+__smulx_383_n_shift_by_31:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	%rdx,%rbx+	xorq	%r14,%r14+	movq	0+0(%rsi),%r8+	movq	0+8(%rsi),%r9+	movq	0+16(%rsi),%r10+	movq	0+24(%rsi),%r11+	movq	0+32(%rsi),%r12+	movq	0+40(%rsi),%r13++	movq	%rdx,%rax+	sarq	$63,%rax+	xorq	%rbp,%rbp+	subq	%rax,%rbp++	xorq	%rax,%rdx+	addq	%rbp,%rdx++	xorq	%rax,%r8+	xorq	%rax,%r9+	xorq	%rax,%r10+	xorq	%rax,%r11+	xorq	%rax,%r12+	xorq	%r13,%rax+	addq	%rbp,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%rax++	mulxq	%r8,%r8,%rbp+	mulxq	%r9,%r9,%r13+	addq	%rbp,%r9+	mulxq	%r10,%r10,%rbp+	adcq	%r13,%r10+	mulxq	%r11,%r11,%r13+	adcq	%rbp,%r11+	mulxq	%r12,%r12,%rbp+	adcq	%r13,%r12+	adcq	$0,%rbp+	imulq	%rdx+	addq	%rbp,%rax+	adcq	%rdx,%r14++	movq	%rcx,%rdx++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%rax,40(%rdi)+	movq	48+0(%rsi),%r8+	movq	48+8(%rsi),%r9+	movq	48+16(%rsi),%r10+	movq	48+24(%rsi),%r11+	movq	48+32(%rsi),%r12+	movq	48+40(%rsi),%r13++	movq	%rdx,%rax+	sarq	$63,%rax+	xorq	%rbp,%rbp+	subq	%rax,%rbp++	xorq	%rax,%rdx+	addq	%rbp,%rdx++	xorq	%rax,%r8+	xorq	%rax,%r9+	xorq	%rax,%r10+	xorq	%rax,%r11+	xorq	%rax,%r12+	xorq	%r13,%rax+	addq	%rbp,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%rax++	mulxq	%r8,%r8,%rbp+	mulxq	%r9,%r9,%r13+	addq	%rbp,%r9+	mulxq	%r10,%r10,%rbp+	adcq	%r13,%r10+	mulxq	%r11,%r11,%r13+	adcq	%rbp,%r11+	mulxq	%r12,%r12,%rbp+	adcq	%r13,%r12+	adcq	$0,%rbp+	imulq	%rdx+	addq	%rbp,%rax+	adcq	$0,%rdx++	addq	0(%rdi),%r8+	adcq	8(%rdi),%r9+	adcq	16(%rdi),%r10+	adcq	24(%rdi),%r11+	adcq	32(%rdi),%r12+	adcq	40(%rdi),%rax+	adcq	%rdx,%r14+	movq	%rbx,%rdx++	shrdq	$31,%r9,%r8+	shrdq	$31,%r10,%r9+	shrdq	$31,%r11,%r10+	shrdq	$31,%r12,%r11+	shrdq	$31,%rax,%r12+	shrdq	$31,%r14,%rax++	sarq	$63,%r14+	xorq	%rbp,%rbp+	subq	%r14,%rbp++	xorq	%r14,%r8+	xorq	%r14,%r9+	xorq	%r14,%r10+	xorq	%r14,%r11+	xorq	%r14,%r12+	xorq	%r14,%rax+	addq	%rbp,%r8+	adcq	$0,%r9+	adcq	$0,%r10+	adcq	$0,%r11+	adcq	$0,%r12+	adcq	$0,%rax++	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%rax,40(%rdi)++	xorq	%r14,%rdx+	xorq	%r14,%rcx+	addq	%rbp,%rdx+	addq	%rbp,%rcx++	.byte	0xf3,0xc3+.cfi_endproc+++.p2align	5+__smulx_191_n_shift_by_31:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	%rdx,%rbx+	movq	0+0(%rsi),%r8+	movq	0+8(%rsi),%r9+	movq	0+16(%rsi),%r10++	movq	%rdx,%rax+	sarq	$63,%rax+	xorq	%rbp,%rbp+	subq	%rax,%rbp++	xorq	%rax,%rdx+	addq	%rbp,%rdx++	xorq	%rax,%r8+	xorq	%rax,%r9+	xorq	%r10,%rax+	addq	%rbp,%r8+	adcq	$0,%r9+	adcq	$0,%rax++	mulxq	%r8,%r8,%rbp+	mulxq	%r9,%r9,%r10+	addq	%rbp,%r9+	adcq	$0,%r10+	imulq	%rdx+	addq	%rax,%r10+	adcq	$0,%rdx+	movq	%rdx,%r14+	movq	%rcx,%rdx+	movq	48+0(%rsi),%r11+	movq	48+8(%rsi),%r12+	movq	48+16(%rsi),%r13++	movq	%rdx,%rax+	sarq	$63,%rax+	xorq	%rbp,%rbp+	subq	%rax,%rbp++	xorq	%rax,%rdx+	addq	%rbp,%rdx++	xorq	%rax,%r11+	xorq	%rax,%r12+	xorq	%r13,%rax+	addq	%rbp,%r11+	adcq	$0,%r12+	adcq	$0,%rax++	mulxq	%r11,%r11,%rbp+	mulxq	%r12,%r12,%r13+	addq	%rbp,%r12+	adcq	$0,%r13+	imulq	%rdx+	addq	%rax,%r13+	adcq	$0,%rdx+	addq	%r8,%r11+	adcq	%r9,%r12+	adcq	%r10,%r13+	adcq	%rdx,%r14+	movq	%rbx,%rdx++	shrdq	$31,%r12,%r11+	shrdq	$31,%r13,%r12+	shrdq	$31,%r14,%r13++	sarq	$63,%r14+	xorq	%rbp,%rbp+	subq	%r14,%rbp++	xorq	%r14,%r11+	xorq	%r14,%r12+	xorq	%r14,%r13+	addq	%rbp,%r11+	adcq	$0,%r12+	adcq	$0,%r13++	movq	%r11,0(%rdi)+	movq	%r12,8(%rdi)+	movq	%r13,16(%rdi)++	xorq	%r14,%rdx+	xorq	%r14,%rcx+	addq	%rbp,%rdx+	addq	%rbp,%rcx++	.byte	0xf3,0xc3+.cfi_endproc+++.p2align	5+__ab_approximation_31:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	40(%rsi),%r9+	movq	88(%rsi),%r11+	movq	32(%rsi),%rbx+	movq	80(%rsi),%rbp+	movq	24(%rsi),%r8+	movq	72(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	movq	16(%rsi),%r8+	cmovzq	%r10,%rbp+	movq	64(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	movq	8(%rsi),%r8+	cmovzq	%r10,%rbp+	movq	56(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	movq	0(%rsi),%r8+	cmovzq	%r10,%rbp+	movq	48(%rsi),%r10++	movq	%r9,%rax+	orq	%r11,%rax+	cmovzq	%rbx,%r9+	cmovzq	%rbp,%r11+	cmovzq	%r8,%rbx+	cmovzq	%r10,%rbp++	movq	%r9,%rax+	orq	%r11,%rax+	bsrq	%rax,%rcx+	leaq	1(%rcx),%rcx+	cmovzq	%r8,%r9+	cmovzq	%r10,%r11+	cmovzq	%rax,%rcx+	negq	%rcx+++	shldq	%cl,%rbx,%r9+	shldq	%cl,%rbp,%r11++	movl	$0x7FFFFFFF,%eax+	andq	%rax,%r8+	andq	%rax,%r10+	andnq	%r9,%rax,%r9+	andnq	%r11,%rax,%r11+	orq	%r9,%r8+	orq	%r11,%r10++	jmp	__inner_loop_31++	.byte	0xf3,0xc3+.cfi_endproc+++.p2align	5+__inner_loop_31:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	$0x7FFFFFFF80000000,%rcx+	movq	$0x800000007FFFFFFF,%r13+	movq	$0x7FFFFFFF7FFFFFFF,%r15++L$oop_31:+	cmpq	%r10,%r8+	movq	%r8,%rax+	movq	%r10,%rbx+	movq	%rcx,%rbp+	movq	%r13,%r14+	cmovbq	%r10,%r8+	cmovbq	%rax,%r10+	cmovbq	%r13,%rcx+	cmovbq	%rbp,%r13++	subq	%r10,%r8+	subq	%r13,%rcx+	addq	%r15,%rcx++	testq	$1,%rax+	cmovzq	%rax,%r8+	cmovzq	%rbx,%r10+	cmovzq	%rbp,%rcx+	cmovzq	%r14,%r13++	shrq	$1,%r8+	addq	%r13,%r13+	subq	%r15,%r13+	subl	$1,%edi+	jnz	L$oop_31++	shrq	$32,%r15+	movl	%ecx,%edx+	movl	%r13d,%r12d+	shrq	$32,%rcx+	shrq	$32,%r13+	subq	%r15,%rdx+	subq	%r15,%rcx+	subq	%r15,%r12+	subq	%r15,%r13++	.byte	0xf3,0xc3+.cfi_endproc++++.p2align	5+__inner_loop_62:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	$1,%rdx+	xorq	%rcx,%rcx+	xorq	%r12,%r12+	movq	$1,%r13++L$oop_62:+	xorq	%rax,%rax+	testq	$1,%r8+	movq	%r10,%rbx+	cmovnzq	%r10,%rax+	subq	%r8,%rbx+	movq	%r8,%rbp+	subq	%rax,%r8+	cmovcq	%rbx,%r8+	cmovcq	%rbp,%r10+	movq	%rdx,%rax+	cmovcq	%r12,%rdx+	cmovcq	%rax,%r12+	movq	%rcx,%rbx+	cmovcq	%r13,%rcx+	cmovcq	%rbx,%r13+	xorq	%rax,%rax+	xorq	%rbx,%rbx+	shrq	$1,%r8+	testq	$1,%rbp+	cmovnzq	%r12,%rax+	cmovnzq	%r13,%rbx+	addq	%r12,%r12+	addq	%r13,%r13+	subq	%rax,%rdx+	subq	%rbx,%rcx+	subl	$1,%edi+	jnz	L$oop_62++	.byte	0xf3,0xc3+.cfi_endproc+
+ c-source/build/mach-o/div3w-armv8.S view
@@ -0,0 +1,88 @@+.text++.globl	_div_3_limbs++.align	5+_div_3_limbs:+	ldp	x4,x5,[x0]	// load R+	eor	x0,x0,x0	// Q = 0+	mov	x3,#64		// loop counter+	nop++Loop:+	subs	x6,x4,x1	// R - D+	add	x0,x0,x0	// Q <<= 1+	sbcs	x7,x5,x2+	add	x0,x0,#1	// Q + speculative bit+	csel	x4,x4,x6,lo	// select between R and R - D+	extr	x1,x2,x1,#1	// D >>= 1+	csel	x5,x5,x7,lo+	lsr	x2,x2,#1+	sbc	x0,x0,xzr	// subtract speculative bit+	sub	x3,x3,#1+	cbnz	x3,Loop++	asr	x3,x0,#63	// top bit -> mask+	add	x0,x0,x0	// Q <<= 1+	subs	x6,x4,x1	// R - D+	add	x0,x0,#1	// Q + specilative bit+	sbcs	x7,x5,x2+	sbc	x0,x0,xzr	// subtract speculative bit++	orr	x0,x0,x3	// all ones if overflow++	ret++.globl	_quot_rem_128++.align	5+_quot_rem_128:+	ldp	x3,x4,[x1]++	mul	x5,x3,x2	// divisor[0:1} * quotient+	umulh	x6,x3,x2+	mul	x11,  x4,x2+	umulh	x7,x4,x2++	ldp	x8,x9,[x0]	// load 3 limbs of the dividend+	ldr	x10,[x0,#16]++	adds	x6,x6,x11+	adc	x7,x7,xzr++	subs	x8,x8,x5	// dividend - divisor * quotient+	sbcs	x9,x9,x6+	sbcs	x10,x10,x7+	sbc	x5,xzr,xzr		// borrow -> mask++	add	x2,x2,x5	// if borrowed, adjust the quotient ...+	and	x3,x3,x5+	and	x4,x4,x5+	adds	x8,x8,x3	// ... and add divisor+	adc	x9,x9,x4++	stp	x8,x9,[x0]	// save 2 limbs of the remainder+	str	x2,[x0,#16]	// and one limb of the quotient++	mov	x0,x2		// return adjusted quotient++	ret+++.globl	_quot_rem_64++.align	5+_quot_rem_64:+	ldr	x3,[x1]+	ldr	x8,[x0]	// load 1 limb of the dividend++	mul	x5,x3,x2	// divisor * quotient++	sub	x8,x8,x5	// dividend - divisor * quotient++	stp	x8,x2,[x0]	// save remainder and quotient++	mov	x0,x2		// return quotient++	ret+
+ c-source/build/mach-o/div3w-x86_64.s view
@@ -0,0 +1,115 @@+.text	++.globl	_div_3_limbs+.private_extern	_div_3_limbs++.p2align	5+_div_3_limbs:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	(%rdi),%r8+	movq	8(%rdi),%r9+	xorq	%rax,%rax+	movl	$64,%ecx++L$oop:+	movq	%r8,%r10+	subq	%rsi,%r8+	movq	%r9,%r11+	sbbq	%rdx,%r9+	leaq	1(%rax,%rax,1),%rax+	movq	%rdx,%rdi+	cmovcq	%r10,%r8+	cmovcq	%r11,%r9+	sbbq	$0,%rax+	shlq	$63,%rdi+	shrq	$1,%rsi+	shrq	$1,%rdx+	orq	%rdi,%rsi+	subl	$1,%ecx+	jnz	L$oop++	leaq	1(%rax,%rax,1),%rcx+	sarq	$63,%rax++	subq	%rsi,%r8+	sbbq	%rdx,%r9+	sbbq	$0,%rcx++	orq	%rcx,%rax++	.byte	0xf3,0xc3+.cfi_endproc++.globl	_quot_rem_128+.private_extern	_quot_rem_128++.p2align	5+_quot_rem_128:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	%rdx,%rax+	movq	%rdx,%rcx++	mulq	0(%rsi)+	movq	%rax,%r8+	movq	%rcx,%rax+	movq	%rdx,%r9++	mulq	8(%rsi)+	addq	%rax,%r9+	adcq	$0,%rdx++	movq	0(%rdi),%r10+	movq	8(%rdi),%r11+	movq	16(%rdi),%rax++	subq	%r8,%r10+	sbbq	%r9,%r11+	sbbq	%rdx,%rax+	sbbq	%r8,%r8++	addq	%r8,%rcx+	movq	%r8,%r9+	andq	0(%rsi),%r8+	andq	8(%rsi),%r9+	addq	%r8,%r10+	adcq	%r9,%r11++	movq	%r10,0(%rdi)+	movq	%r11,8(%rdi)+	movq	%rcx,16(%rdi)++	movq	%rcx,%rax++	.byte	0xf3,0xc3+.cfi_endproc+++++++.globl	_quot_rem_64+.private_extern	_quot_rem_64++.p2align	5+_quot_rem_64:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	%rdx,%rax+	imulq	0(%rsi),%rdx++	movq	0(%rdi),%r10++	subq	%rdx,%r10++	movq	%r10,0(%rdi)+	movq	%rax,8(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+
+ c-source/build/mach-o/mul_mont_256-armv8.S view
@@ -0,0 +1,464 @@+.text++.globl	_mul_mont_sparse_256+.private_extern	_mul_mont_sparse_256++.align	5+_mul_mont_sparse_256:+	stp	x29,x30,[sp,#-64]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]++	ldp	x10,x11,[x1]+	ldr	x9,        [x2]+	ldp	x12,x13,[x1,#16]++	mul	x19,x10,x9+	ldp	x5,x6,[x3]+	mul	x20,x11,x9+	ldp	x7,x8,[x3,#16]+	mul	x21,x12,x9+	mul	x22,x13,x9++	umulh	x14,x10,x9+	umulh	x15,x11,x9+	mul	x3,x4,x19+	umulh	x16,x12,x9+	umulh	x17,x13,x9+	adds	x20,x20,x14+	//mul	x14,x5,x3+	adcs	x21,x21,x15+	mul	x15,x6,x3+	adcs	x22,x22,x16+	mul	x16,x7,x3+	adc	x23,xzr,    x17+	mul	x17,x8,x3+	ldr	x9,[x2,8*1]+	subs	xzr,x19,#1		//adds	x19,x19,x14+	umulh	x14,x5,x3+	adcs	x20,x20,x15+	umulh	x15,x6,x3+	adcs	x21,x21,x16+	umulh	x16,x7,x3+	adcs	x22,x22,x17+	umulh	x17,x8,x3+	adc	x23,x23,xzr++	adds	x19,x20,x14+	mul	x14,x10,x9+	adcs	x20,x21,x15+	mul	x15,x11,x9+	adcs	x21,x22,x16+	mul	x16,x12,x9+	adcs	x22,x23,x17+	mul	x17,x13,x9+	adc	x23,xzr,xzr++	adds	x19,x19,x14+	umulh	x14,x10,x9+	adcs	x20,x20,x15+	umulh	x15,x11,x9+	adcs	x21,x21,x16+	mul	x3,x4,x19+	umulh	x16,x12,x9+	adcs	x22,x22,x17+	umulh	x17,x13,x9+	adc	x23,x23,xzr++	adds	x20,x20,x14+	//mul	x14,x5,x3+	adcs	x21,x21,x15+	mul	x15,x6,x3+	adcs	x22,x22,x16+	mul	x16,x7,x3+	adc	x23,x23,x17+	mul	x17,x8,x3+	ldr	x9,[x2,8*2]+	subs	xzr,x19,#1		//adds	x19,x19,x14+	umulh	x14,x5,x3+	adcs	x20,x20,x15+	umulh	x15,x6,x3+	adcs	x21,x21,x16+	umulh	x16,x7,x3+	adcs	x22,x22,x17+	umulh	x17,x8,x3+	adc	x23,x23,xzr++	adds	x19,x20,x14+	mul	x14,x10,x9+	adcs	x20,x21,x15+	mul	x15,x11,x9+	adcs	x21,x22,x16+	mul	x16,x12,x9+	adcs	x22,x23,x17+	mul	x17,x13,x9+	adc	x23,xzr,xzr++	adds	x19,x19,x14+	umulh	x14,x10,x9+	adcs	x20,x20,x15+	umulh	x15,x11,x9+	adcs	x21,x21,x16+	mul	x3,x4,x19+	umulh	x16,x12,x9+	adcs	x22,x22,x17+	umulh	x17,x13,x9+	adc	x23,x23,xzr++	adds	x20,x20,x14+	//mul	x14,x5,x3+	adcs	x21,x21,x15+	mul	x15,x6,x3+	adcs	x22,x22,x16+	mul	x16,x7,x3+	adc	x23,x23,x17+	mul	x17,x8,x3+	ldr	x9,[x2,8*3]+	subs	xzr,x19,#1		//adds	x19,x19,x14+	umulh	x14,x5,x3+	adcs	x20,x20,x15+	umulh	x15,x6,x3+	adcs	x21,x21,x16+	umulh	x16,x7,x3+	adcs	x22,x22,x17+	umulh	x17,x8,x3+	adc	x23,x23,xzr++	adds	x19,x20,x14+	mul	x14,x10,x9+	adcs	x20,x21,x15+	mul	x15,x11,x9+	adcs	x21,x22,x16+	mul	x16,x12,x9+	adcs	x22,x23,x17+	mul	x17,x13,x9+	adc	x23,xzr,xzr++	adds	x19,x19,x14+	umulh	x14,x10,x9+	adcs	x20,x20,x15+	umulh	x15,x11,x9+	adcs	x21,x21,x16+	mul	x3,x4,x19+	umulh	x16,x12,x9+	adcs	x22,x22,x17+	umulh	x17,x13,x9+	adc	x23,x23,xzr++	adds	x20,x20,x14+	//mul	x14,x5,x3+	adcs	x21,x21,x15+	mul	x15,x6,x3+	adcs	x22,x22,x16+	mul	x16,x7,x3+	adc	x23,x23,x17+	mul	x17,x8,x3+	subs	xzr,x19,#1		//adds	x19,x19,x14+	umulh	x14,x5,x3+	adcs	x20,x20,x15+	umulh	x15,x6,x3+	adcs	x21,x21,x16+	umulh	x16,x7,x3+	adcs	x22,x22,x17+	umulh	x17,x8,x3+	adc	x23,x23,xzr++	adds	x19,x20,x14+	adcs	x20,x21,x15+	adcs	x21,x22,x16+	adcs	x22,x23,x17+	adc	x23,xzr,xzr++	subs	x14,x19,x5+	sbcs	x15,x20,x6+	sbcs	x16,x21,x7+	sbcs	x17,x22,x8+	sbcs	xzr,    x23,xzr++	csel	x19,x19,x14,lo+	csel	x20,x20,x15,lo+	csel	x21,x21,x16,lo+	csel	x22,x22,x17,lo++	stp	x19,x20,[x0]+	stp	x21,x22,[x0,#16]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldr	x29,[sp],#64+	ret++.globl	_sqr_mont_sparse_256+.private_extern	_sqr_mont_sparse_256++.align	5+_sqr_mont_sparse_256:+.long	3573752639+	stp	x29,x30,[sp,#-48]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]++	ldp	x5,x6,[x1]+	ldp	x7,x8,[x1,#16]+	mov	x4,x3++	////////////////////////////////////////////////////////////////+	//  |  |  |  |  |  |a1*a0|  |+	//  |  |  |  |  |a2*a0|  |  |+	//  |  |a3*a2|a3*a0|  |  |  |+	//  |  |  |  |a2*a1|  |  |  |+	//  |  |  |a3*a1|  |  |  |  |+	// *|  |  |  |  |  |  |  | 2|+	// +|a3*a3|a2*a2|a1*a1|a0*a0|+	//  |--+--+--+--+--+--+--+--|+	//  |A7|A6|A5|A4|A3|A2|A1|A0|, where Ax is x10+	//+	//  "can't overflow" below mark carrying into high part of+	//  multiplication result, which can't overflow, because it+	//  can never be all ones.++	mul	x11,x6,x5	// a[1]*a[0]+	umulh	x15,x6,x5+	mul	x12,x7,x5	// a[2]*a[0]+	umulh	x16,x7,x5+	mul	x13,x8,x5	// a[3]*a[0]+	umulh	x19,x8,x5++	adds	x12,x12,x15	// accumulate high parts of multiplication+	mul	x14,x7,x6	// a[2]*a[1]+	umulh	x15,x7,x6+	adcs	x13,x13,x16+	mul	x16,x8,x6	// a[3]*a[1]+	umulh	x17,x8,x6+	adc	x19,x19,xzr	// can't overflow++	mul	x20,x8,x7	// a[3]*a[2]+	umulh	x21,x8,x7++	adds	x15,x15,x16	// accumulate high parts of multiplication+	mul	x10,x5,x5	// a[0]*a[0]+	adc	x16,x17,xzr	// can't overflow++	adds	x13,x13,x14	// accumulate low parts of multiplication+	umulh	x5,x5,x5+	adcs	x19,x19,x15+	mul	x15,x6,x6	// a[1]*a[1]+	adcs	x20,x20,x16+	umulh	x6,x6,x6+	adc	x21,x21,xzr	// can't overflow++	adds	x11,x11,x11	// acc[1-6]*=2+	mul	x16,x7,x7	// a[2]*a[2]+	adcs	x12,x12,x12+	umulh	x7,x7,x7+	adcs	x13,x13,x13+	mul	x17,x8,x8	// a[3]*a[3]+	adcs	x19,x19,x19+	umulh	x8,x8,x8+	adcs	x20,x20,x20+	adcs	x21,x21,x21+	adc	x22,xzr,xzr++	adds	x11,x11,x5	// +a[i]*a[i]+	adcs	x12,x12,x15+	adcs	x13,x13,x6+	adcs	x19,x19,x16+	adcs	x20,x20,x7+	adcs	x21,x21,x17+	adc	x22,x22,x8++	bl	__mul_by_1_mont_256+	ldr	x30,[x29,#8]++	adds	x10,x10,x19	// accumulate upper half+	adcs	x11,x11,x20+	adcs	x12,x12,x21+	adcs	x13,x13,x22+	adc	x19,xzr,xzr++	subs	x14,x10,x5+	sbcs	x15,x11,x6+	sbcs	x16,x12,x7+	sbcs	x17,x13,x8+	sbcs	xzr,    x19,xzr++	csel	x10,x10,x14,lo+	csel	x11,x11,x15,lo+	csel	x12,x12,x16,lo+	csel	x13,x13,x17,lo++	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldr	x29,[sp],#48+.long	3573752767+	ret++.globl	_from_mont_256+.private_extern	_from_mont_256++.align	5+_from_mont_256:+.long	3573752639+	stp	x29,x30,[sp,#-16]!+	add	x29,sp,#0++	mov	x4,x3+	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]++	bl	__mul_by_1_mont_256+	ldr	x30,[x29,#8]++	subs	x14,x10,x5+	sbcs	x15,x11,x6+	sbcs	x16,x12,x7+	sbcs	x17,x13,x8++	csel	x10,x10,x14,lo+	csel	x11,x11,x15,lo+	csel	x12,x12,x16,lo+	csel	x13,x13,x17,lo++	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]++	ldr	x29,[sp],#16+.long	3573752767+	ret+++.globl	_redc_mont_256+.private_extern	_redc_mont_256++.align	5+_redc_mont_256:+.long	3573752639+	stp	x29,x30,[sp,#-16]!+	add	x29,sp,#0++	mov	x4,x3+	ldp	x10,x11,[x1]+	ldp	x12,x13,[x1,#16]++	bl	__mul_by_1_mont_256+	ldr	x30,[x29,#8]++	ldp	x14,x15,[x1,#32]+	ldp	x16,x17,[x1,#48]++	adds	x10,x10,x14+	adcs	x11,x11,x15+	adcs	x12,x12,x16+	adcs	x13,x13,x17+	adc	x9,xzr,xzr++	subs	x14,x10,x5+	sbcs	x15,x11,x6+	sbcs	x16,x12,x7+	sbcs	x17,x13,x8+	sbcs	xzr,    x9,xzr++	csel	x10,x10,x14,lo+	csel	x11,x11,x15,lo+	csel	x12,x12,x16,lo+	csel	x13,x13,x17,lo++	stp	x10,x11,[x0]+	stp	x12,x13,[x0,#16]++	ldr	x29,[sp],#16+.long	3573752767+	ret++++.align	5+__mul_by_1_mont_256:+	mul	x3,x4,x10+	ldp	x5,x6,[x2]+	ldp	x7,x8,[x2,#16]+	//mul	x14,x5,x3+	mul	x15,x6,x3+	mul	x16,x7,x3+	mul	x17,x8,x3+	subs	xzr,x10,#1		//adds	x10,x10,x14+	umulh	x14,x5,x3+	adcs	x11,x11,x15+	umulh	x15,x6,x3+	adcs	x12,x12,x16+	umulh	x16,x7,x3+	adcs	x13,x13,x17+	umulh	x17,x8,x3+	adc	x9,xzr,xzr++	adds	x10,x11,x14+	adcs	x11,x12,x15+	adcs	x12,x13,x16+	mul	x3,x4,x10+	adc	x13,x9,x17+	//mul	x14,x5,x3+	mul	x15,x6,x3+	mul	x16,x7,x3+	mul	x17,x8,x3+	subs	xzr,x10,#1		//adds	x10,x10,x14+	umulh	x14,x5,x3+	adcs	x11,x11,x15+	umulh	x15,x6,x3+	adcs	x12,x12,x16+	umulh	x16,x7,x3+	adcs	x13,x13,x17+	umulh	x17,x8,x3+	adc	x9,xzr,xzr++	adds	x10,x11,x14+	adcs	x11,x12,x15+	adcs	x12,x13,x16+	mul	x3,x4,x10+	adc	x13,x9,x17+	//mul	x14,x5,x3+	mul	x15,x6,x3+	mul	x16,x7,x3+	mul	x17,x8,x3+	subs	xzr,x10,#1		//adds	x10,x10,x14+	umulh	x14,x5,x3+	adcs	x11,x11,x15+	umulh	x15,x6,x3+	adcs	x12,x12,x16+	umulh	x16,x7,x3+	adcs	x13,x13,x17+	umulh	x17,x8,x3+	adc	x9,xzr,xzr++	adds	x10,x11,x14+	adcs	x11,x12,x15+	adcs	x12,x13,x16+	mul	x3,x4,x10+	adc	x13,x9,x17+	//mul	x14,x5,x3+	mul	x15,x6,x3+	mul	x16,x7,x3+	mul	x17,x8,x3+	subs	xzr,x10,#1		//adds	x10,x10,x14+	umulh	x14,x5,x3+	adcs	x11,x11,x15+	umulh	x15,x6,x3+	adcs	x12,x12,x16+	umulh	x16,x7,x3+	adcs	x13,x13,x17+	umulh	x17,x8,x3+	adc	x9,xzr,xzr++	adds	x10,x11,x14+	adcs	x11,x12,x15+	adcs	x12,x13,x16+	adc	x13,x9,x17++	ret+
+ c-source/build/mach-o/mul_mont_384-armv8.S view
@@ -0,0 +1,2372 @@+.text++.globl	_add_mod_384x384++.align	5+_add_mod_384x384:+.long	3573752639+	stp	x29,x30,[sp,#-64]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]++	ldp	x5,x6,[x3]+	ldp	x7,x8,[x3,#16]+	ldp	x9,x10,[x3,#32]++	bl	__add_mod_384x384+	ldr	x30,[x29,#8]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldr	x29,[sp],#64+.long	3573752767+	ret++++.align	5+__add_mod_384x384:+	ldp	x11,  x12,  [x1]+	ldp	x19,x20,[x2]+	ldp	x13,  x14,  [x1,#16]+	adds	x11,x11,x19+	ldp	x21,x22,[x2,#16]+	adcs	x12,x12,x20+	ldp	x15,  x16,  [x1,#32]+	adcs	x13,x13,x21+	ldp	x23,x24,[x2,#32]+	adcs	x14,x14,x22+	stp	x11,  x12,  [x0]+	adcs	x15,x15,x23+	ldp	x11,  x12,  [x1,#48]+	adcs	x16,x16,x24++	ldp	x19,x20,[x2,#48]+	stp	x13,  x14,  [x0,#16]+	ldp	x13,  x14,  [x1,#64]+	ldp	x21,x22,[x2,#64]++	adcs	x11,x11,x19+	stp	x15,  x16,  [x0,#32]+	adcs	x12,x12,x20+	ldp	x15,  x16,  [x1,#80]+	adcs	x13,x13,x21+	ldp	x23,x24,[x2,#80]+	adcs	x14,x14,x22+	adcs	x15,x15,x23+	adcs	x16,x16,x24+	adc	x17,xzr,xzr++	subs	x19,x11,x5+	sbcs	x20,x12,x6+	sbcs	x21,x13,x7+	sbcs	x22,x14,x8+	sbcs	x23,x15,x9+	sbcs	x24,x16,x10+	sbcs	xzr,x17,xzr++	csel	x11,x11,x19,lo+	csel	x12,x12,x20,lo+	csel	x13,x13,x21,lo+	csel	x14,x14,x22,lo+	stp	x11,x12,[x0,#48]+	csel	x15,x15,x23,lo+	stp	x13,x14,[x0,#64]+	csel	x16,x16,x24,lo+	stp	x15,x16,[x0,#80]++	ret+++.globl	_sub_mod_384x384++.align	5+_sub_mod_384x384:+.long	3573752639+	stp	x29,x30,[sp,#-64]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]++	ldp	x5,x6,[x3]+	ldp	x7,x8,[x3,#16]+	ldp	x9,x10,[x3,#32]++	bl	__sub_mod_384x384+	ldr	x30,[x29,#8]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldr	x29,[sp],#64+.long	3573752767+	ret++++.align	5+__sub_mod_384x384:+	ldp	x11,  x12,  [x1]+	ldp	x19,x20,[x2]+	ldp	x13,  x14,  [x1,#16]+	subs	x11,x11,x19+	ldp	x21,x22,[x2,#16]+	sbcs	x12,x12,x20+	ldp	x15,  x16,  [x1,#32]+	sbcs	x13,x13,x21+	ldp	x23,x24,[x2,#32]+	sbcs	x14,x14,x22+	stp	x11,  x12,  [x0]+	sbcs	x15,x15,x23+	ldp	x11,  x12,  [x1,#48]+	sbcs	x16,x16,x24++	ldp	x19,x20,[x2,#48]+	stp	x13,  x14,  [x0,#16]+	ldp	x13,  x14,  [x1,#64]+	ldp	x21,x22,[x2,#64]++	sbcs	x11,x11,x19+	stp	x15,  x16,  [x0,#32]+	sbcs	x12,x12,x20+	ldp	x15,  x16,  [x1,#80]+	sbcs	x13,x13,x21+	ldp	x23,x24,[x2,#80]+	sbcs	x14,x14,x22+	sbcs	x15,x15,x23+	sbcs	x16,x16,x24+	sbc	x17,xzr,xzr++	and	x19,x5,x17+	and	x20,x6,x17+	adds	x11,x11,x19+	and	x21,x7,x17+	adcs	x12,x12,x20+	and	x22,x8,x17+	adcs	x13,x13,x21+	and	x23,x9,x17+	adcs	x14,x14,x22+	and	x24,x10,x17+	adcs	x15,x15,x23+	stp	x11,x12,[x0,#48]+	adc	x16,x16,x24+	stp	x13,x14,[x0,#64]+	stp	x15,x16,[x0,#80]++	ret++++.align	5+__add_mod_384:+	ldp	x11,  x12,  [x1]+	ldp	x19,x20,[x2]+	ldp	x13,  x14,  [x1,#16]+	adds	x11,x11,x19+	ldp	x21,x22,[x2,#16]+	adcs	x12,x12,x20+	ldp	x15,  x16,  [x1,#32]+	adcs	x13,x13,x21+	ldp	x23,x24,[x2,#32]+	adcs	x14,x14,x22+	adcs	x15,x15,x23+	adcs	x16,x16,x24+	adc	x17,xzr,xzr++	subs	x19,x11,x5+	sbcs	x20,x12,x6+	sbcs	x21,x13,x7+	sbcs	x22,x14,x8+	sbcs	x23,x15,x9+	sbcs	x24,x16,x10+	sbcs	xzr,x17,xzr++	csel	x11,x11,x19,lo+	csel	x12,x12,x20,lo+	csel	x13,x13,x21,lo+	csel	x14,x14,x22,lo+	csel	x15,x15,x23,lo+	stp	x11,x12,[x0]+	csel	x16,x16,x24,lo+	stp	x13,x14,[x0,#16]+	stp	x15,x16,[x0,#32]++	ret++++.align	5+__sub_mod_384:+	ldp	x11,  x12,  [x1]+	ldp	x19,x20,[x2]+	ldp	x13,  x14,  [x1,#16]+	subs	x11,x11,x19+	ldp	x21,x22,[x2,#16]+	sbcs	x12,x12,x20+	ldp	x15,  x16,  [x1,#32]+	sbcs	x13,x13,x21+	ldp	x23,x24,[x2,#32]+	sbcs	x14,x14,x22+	sbcs	x15,x15,x23+	sbcs	x16,x16,x24+	sbc	x17,xzr,xzr++	and	x19,x5,x17+	and	x20,x6,x17+	adds	x11,x11,x19+	and	x21,x7,x17+	adcs	x12,x12,x20+	and	x22,x8,x17+	adcs	x13,x13,x21+	and	x23,x9,x17+	adcs	x14,x14,x22+	and	x24,x10,x17+	adcs	x15,x15,x23+	stp	x11,x12,[x0]+	adc	x16,x16,x24+	stp	x13,x14,[x0,#16]+	stp	x15,x16,[x0,#32]++	ret+++.globl	_mul_mont_384x+.private_extern	_mul_mont_384x++.align	5+_mul_mont_384x:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	sub	sp,sp,#288		// space for 3 768-bit vectors++	mov	x26,x0		// save r_ptr+	mov	x27,x1		// save b_ptr+	mov	x28,x2		// save b_ptr++	sub	x0,sp,#0		// mul_384(t0, a->re, b->re)+	bl	__mul_384++	add	x1,x1,#48	// mul_384(t1, a->im, b->im)+	add	x2,x2,#48+	add	x0,sp,#96+	bl	__mul_384++	ldp	x5,x6,[x3]+	ldp	x7,x8,[x3,#16]+	ldp	x9,x10,[x3,#32]++	sub	x2,x1,#48+	add	x0,sp,#240+	bl	__add_mod_384++	add	x1,x28,#0+	add	x2,x28,#48+	add	x0,sp,#192		// t2+	bl	__add_mod_384++	add	x1,x0,#0+	add	x2,x0,#48+	bl	__mul_384		// mul_384(t2, a->re+a->im, b->re+b->im)++	ldp	x5,x6,[x3]+	ldp	x7,x8,[x3,#16]+	ldp	x9,x10,[x3,#32]++	mov	x1,x0+	add	x2,sp,#0+	bl	__sub_mod_384x384++	add	x2,sp,#96+	bl	__sub_mod_384x384	// t2 = t2-t0-t1++	add	x1,sp,#0+	add	x2,sp,#96+	add	x0,sp,#0+	bl	__sub_mod_384x384	// t0 = t0-t1++	add	x1,sp,#0		// ret->re = redc(t0)+	add	x0,x26,#0+	bl	__mul_by_1_mont_384+	bl	__redc_tail_mont_384++	add	x1,sp,#192		// ret->im = redc(t2)+	add	x0,x0,#48+	bl	__mul_by_1_mont_384+	bl	__redc_tail_mont_384+	ldr	x30,[x29,#8]++	add	sp,sp,#288+	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret+++.globl	_sqr_mont_384x+.private_extern	_sqr_mont_384x++.align	5+_sqr_mont_384x:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	stp	x3,x0,[sp,#96]	// __mul_mont_384 wants them there+	sub	sp,sp,#96		// space for 2 384-bit vectors+	mov	x4,x3		// adjust for missing b_ptr++	ldp	x5,x6,[x2]+	ldp	x7,x8,[x2,#16]+	ldp	x9,x10,[x2,#32]++	add	x2,x1,#48+	add	x0,sp,#0+	bl	__add_mod_384		// t0 = a->re + a->im++	add	x0,sp,#48+	bl	__sub_mod_384		// t1 = a->re - a->im++	ldp	x11,x12,[x1]+	ldr	x17,        [x2]+	ldp	x13,x14,[x1,#16]+	ldp	x15,x16,[x1,#32]++	bl	__mul_mont_384		// mul_mont_384(ret->im, a->re, a->im)++	adds	x11,x11,x11	// add with itself+	adcs	x12,x12,x12+	adcs	x13,x13,x13+	adcs	x14,x14,x14+	adcs	x15,x15,x15+	adcs	x16,x16,x16+	adc	x25,xzr,xzr++	subs	x19,x11,x5+	sbcs	x20,x12,x6+	sbcs	x21,x13,x7+	sbcs	x22,x14,x8+	sbcs	x23,x15,x9+	sbcs	x24,x16,x10+	sbcs	xzr,x25,xzr++	csel	x19,x11,x19,lo+	csel	x20,x12,x20,lo+	csel	x21,x13,x21,lo+	ldp	x11,x12,[sp]+	csel	x22,x14,x22,lo+	ldr	x17,        [sp,#48]+	csel	x23,x15,x23,lo+	ldp	x13,x14,[sp,#16]+	csel	x24,x16,x24,lo+	ldp	x15,x16,[sp,#32]++	stp	x19,x20,[x2,#48]+	stp	x21,x22,[x2,#64]+	stp	x23,x24,[x2,#80]++	add	x2,sp,#48+	bl	__mul_mont_384		// mul_mont_384(ret->re, t0, t1)+	ldr	x30,[x29,#8]++	stp	x11,x12,[x2]+	stp	x13,x14,[x2,#16]+	stp	x15,x16,[x2,#32]++	add	sp,sp,#96+	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret+++.globl	_mul_mont_384+.private_extern	_mul_mont_384++.align	5+_mul_mont_384:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	stp	x4,x0,[sp,#96]	// __mul_mont_384 wants them there++	ldp	x11,x12,[x1]+	ldr	x17,        [x2]+	ldp	x13,x14,[x1,#16]+	ldp	x15,x16,[x1,#32]++	ldp	x5,x6,[x3]+	ldp	x7,x8,[x3,#16]+	ldp	x9,x10,[x3,#32]++	bl	__mul_mont_384+	ldr	x30,[x29,#8]++	stp	x11,x12,[x2]+	stp	x13,x14,[x2,#16]+	stp	x15,x16,[x2,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret++++.align	5+__mul_mont_384:+	mul	x19,x11,x17+	mul	x20,x12,x17+	mul	x21,x13,x17+	mul	x22,x14,x17+	mul	x23,x15,x17+	mul	x24,x16,x17+	mul	x4,x4,x19++	umulh	x26,x11,x17+	umulh	x27,x12,x17+	umulh	x28,x13,x17+	umulh	x0,x14,x17+	umulh	x1,x15,x17+	umulh	x3,x16,x17++	adds	x20,x20,x26+	// mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adc	x25,xzr,    x3+	mul	x3,x10,x4+	mov	x17,xzr+	subs	xzr,x19,#1		// adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adcs	x25,x25,xzr+	adc	x4,x17,xzr+	ldr	x17,[x2,8*1]++	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,x4,xzr+	ldr	x4,[x29,#96]++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adcs	x25,x25,xzr+	adc	x17,xzr,xzr++	adds	x20,x20,x26+	// mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adcs	x25,x25,x3+	mul	x3,x10,x4+	adc	x17,x17,xzr+	subs	xzr,x19,#1		// adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adcs	x25,x25,xzr+	adc	x4,x17,xzr+	ldr	x17,[x2,8*2]++	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,x4,xzr+	ldr	x4,[x29,#96]++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adcs	x25,x25,xzr+	adc	x17,xzr,xzr++	adds	x20,x20,x26+	// mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adcs	x25,x25,x3+	mul	x3,x10,x4+	adc	x17,x17,xzr+	subs	xzr,x19,#1		// adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adcs	x25,x25,xzr+	adc	x4,x17,xzr+	ldr	x17,[x2,8*3]++	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,x4,xzr+	ldr	x4,[x29,#96]++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adcs	x25,x25,xzr+	adc	x17,xzr,xzr++	adds	x20,x20,x26+	// mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adcs	x25,x25,x3+	mul	x3,x10,x4+	adc	x17,x17,xzr+	subs	xzr,x19,#1		// adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adcs	x25,x25,xzr+	adc	x4,x17,xzr+	ldr	x17,[x2,8*4]++	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,x4,xzr+	ldr	x4,[x29,#96]++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adcs	x25,x25,xzr+	adc	x17,xzr,xzr++	adds	x20,x20,x26+	// mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adcs	x25,x25,x3+	mul	x3,x10,x4+	adc	x17,x17,xzr+	subs	xzr,x19,#1		// adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adcs	x25,x25,xzr+	adc	x4,x17,xzr+	ldr	x17,[x2,8*5]++	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,x4,xzr+	ldr	x4,[x29,#96]++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adcs	x25,x25,xzr+	adc	x17,xzr,xzr++	adds	x20,x20,x26+	// mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adcs	x25,x25,x3+	mul	x3,x10,x4+	adc	x17,x17,xzr+	subs	xzr,x19,#1		// adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adcs	x25,x25,xzr+	ldp	x4,x2,[x29,#96]	// pull r_ptr+	adc	x17,x17,xzr++	adds	x19,x20,x26+	adcs	x20,x21,x27+	adcs	x21,x22,x28+	adcs	x22,x23,x0+	adcs	x23,x24,x1+	adcs	x24,x25,x3+	adc	x25,x17,xzr++	subs	x26,x19,x5+	sbcs	x27,x20,x6+	sbcs	x28,x21,x7+	sbcs	x0,x22,x8+	sbcs	x1,x23,x9+	sbcs	x3,x24,x10+	sbcs	xzr,    x25,xzr++	csel	x11,x19,x26,lo+	csel	x12,x20,x27,lo+	csel	x13,x21,x28,lo+	csel	x14,x22,x0,lo+	csel	x15,x23,x1,lo+	csel	x16,x24,x3,lo+	ret+++.globl	_sqr_mont_384+.private_extern	_sqr_mont_384++.align	5+_sqr_mont_384:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	sub	sp,sp,#96		// space for 768-bit vector+	mov	x4,x3		// adjust for missing b_ptr++	mov	x3,x0		// save r_ptr+	mov	x0,sp++	ldp	x11,x12,[x1]+	ldp	x13,x14,[x1,#16]+	ldp	x15,x16,[x1,#32]++	bl	__sqr_384++	ldp	x5,x6,[x2]+	ldp	x7,x8,[x2,#16]+	ldp	x9,x10,[x2,#32]++	mov	x1,sp+	mov	x0,x3		// restore r_ptr+	bl	__mul_by_1_mont_384+	bl	__redc_tail_mont_384+	ldr	x30,[x29,#8]++	add	sp,sp,#96+	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret+++.globl	_sqr_n_mul_mont_383+.private_extern	_sqr_n_mul_mont_383++.align	5+_sqr_n_mul_mont_383:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	stp	x4,x0,[sp,#96]	// __mul_mont_384 wants them there+	sub	sp,sp,#96		// space for 768-bit vector+	mov	x17,x5			// save b_ptr++	ldp	x11,x12,[x1]+	ldp	x13,x14,[x1,#16]+	ldp	x15,x16,[x1,#32]+	mov	x0,sp+Loop_sqr_383:+	bl	__sqr_384+	sub	x2,x2,#1	// counter++	ldp	x5,x6,[x3]+	ldp	x7,x8,[x3,#16]+	ldp	x9,x10,[x3,#32]++	mov	x1,sp+	bl	__mul_by_1_mont_384++	ldp	x19,x20,[x1,#48]+	ldp	x21,x22,[x1,#64]+	ldp	x23,x24,[x1,#80]++	adds	x11,x11,x19	// just accumulate upper half+	adcs	x12,x12,x20+	adcs	x13,x13,x21+	adcs	x14,x14,x22+	adcs	x15,x15,x23+	adc	x16,x16,x24++	cbnz	x2,Loop_sqr_383++	mov	x2,x17+	ldr	x17,[x17]+	bl	__mul_mont_384+	ldr	x30,[x29,#8]++	stp	x11,x12,[x2]+	stp	x13,x14,[x2,#16]+	stp	x15,x16,[x2,#32]++	add	sp,sp,#96+	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret+++.align	5+__sqr_384:+	mul	x19,x12,x11+	mul	x20,x13,x11+	mul	x21,x14,x11+	mul	x22,x15,x11+	mul	x23,x16,x11++	umulh	x6,x12,x11+	umulh	x7,x13,x11+	umulh	x8,x14,x11+	umulh	x9,x15,x11+	adds	x20,x20,x6+	umulh	x10,x16,x11+	adcs	x21,x21,x7+	mul	x7,x13,x12+	adcs	x22,x22,x8+	mul	x8,x14,x12+	adcs	x23,x23,x9+	mul	x9,x15,x12+	adc	x24,xzr,    x10+	mul	x10,x16,x12++	adds	x21,x21,x7+	umulh	x7,x13,x12+	adcs	x22,x22,x8+	umulh	x8,x14,x12+	adcs	x23,x23,x9+	umulh	x9,x15,x12+	adcs	x24,x24,x10+	umulh	x10,x16,x12+	adc	x25,xzr,xzr++	mul	x5,x11,x11+	adds	x22,x22,x7+	umulh	x11,  x11,x11+	adcs	x23,x23,x8+	mul	x8,x14,x13+	adcs	x24,x24,x9+	mul	x9,x15,x13+	adc	x25,x25,x10+	mul	x10,x16,x13++	adds	x23,x23,x8+	umulh	x8,x14,x13+	adcs	x24,x24,x9+	umulh	x9,x15,x13+	adcs	x25,x25,x10+	umulh	x10,x16,x13+	adc	x26,xzr,xzr++	mul	x6,x12,x12+	adds	x24,x24,x8+	umulh	x12,  x12,x12+	adcs	x25,x25,x9+	mul	x9,x15,x14+	adc	x26,x26,x10+	mul	x10,x16,x14++	adds	x25,x25,x9+	umulh	x9,x15,x14+	adcs	x26,x26,x10+	umulh	x10,x16,x14+	adc	x27,xzr,xzr+	mul	x7,x13,x13+	adds	x26,x26,x9+	umulh	x13,  x13,x13+	adc	x27,x27,x10+	mul	x8,x14,x14++	mul	x10,x16,x15+	umulh	x14,  x14,x14+	adds	x27,x27,x10+	umulh	x10,x16,x15+	mul	x9,x15,x15+	adc	x28,x10,xzr++	adds	x19,x19,x19+	adcs	x20,x20,x20+	adcs	x21,x21,x21+	adcs	x22,x22,x22+	adcs	x23,x23,x23+	adcs	x24,x24,x24+	adcs	x25,x25,x25+	adcs	x26,x26,x26+	umulh	x15,  x15,x15+	adcs	x27,x27,x27+	mul	x10,x16,x16+	adcs	x28,x28,x28+	umulh	x16,  x16,x16+	adc	x1,xzr,xzr++	adds	x19,x19,x11+	adcs	x20,x20,x6+	adcs	x21,x21,x12+	adcs	x22,x22,x7+	adcs	x23,x23,x13+	adcs	x24,x24,x8+	adcs	x25,x25,x14+	stp	x5,x19,[x0]+	adcs	x26,x26,x9+	stp	x20,x21,[x0,#16]+	adcs	x27,x27,x15+	stp	x22,x23,[x0,#32]+	adcs	x28,x28,x10+	stp	x24,x25,[x0,#48]+	adc	x16,x16,x1+	stp	x26,x27,[x0,#64]+	stp	x28,x16,[x0,#80]++	ret++.globl	_sqr_384+.private_extern	_sqr_384++.align	5+_sqr_384:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]++	ldp	x11,x12,[x1]+	ldp	x13,x14,[x1,#16]+	ldp	x15,x16,[x1,#32]++	bl	__sqr_384+	ldr	x30,[x29,#8]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret+++.globl	_redc_mont_384+.private_extern	_redc_mont_384++.align	5+_redc_mont_384:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	mov	x4,x3		// adjust for missing b_ptr++	ldp	x5,x6,[x2]+	ldp	x7,x8,[x2,#16]+	ldp	x9,x10,[x2,#32]++	bl	__mul_by_1_mont_384+	bl	__redc_tail_mont_384+	ldr	x30,[x29,#8]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret+++.globl	_from_mont_384+.private_extern	_from_mont_384++.align	5+_from_mont_384:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	mov	x4,x3		// adjust for missing b_ptr++	ldp	x5,x6,[x2]+	ldp	x7,x8,[x2,#16]+	ldp	x9,x10,[x2,#32]++	bl	__mul_by_1_mont_384+	ldr	x30,[x29,#8]++	subs	x19,x11,x5+	sbcs	x20,x12,x6+	sbcs	x21,x13,x7+	sbcs	x22,x14,x8+	sbcs	x23,x15,x9+	sbcs	x24,x16,x10++	csel	x11,x11,x19,lo+	csel	x12,x12,x20,lo+	csel	x13,x13,x21,lo+	csel	x14,x14,x22,lo+	csel	x15,x15,x23,lo+	csel	x16,x16,x24,lo++	stp	x11,x12,[x0]+	stp	x13,x14,[x0,#16]+	stp	x15,x16,[x0,#32]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret++++.align	5+__mul_by_1_mont_384:+	ldp	x11,x12,[x1]+	ldp	x13,x14,[x1,#16]+	mul	x26,x4,x11+	ldp	x15,x16,[x1,#32]++	// mul	x19,x5,x26+	mul	x20,x6,x26+	mul	x21,x7,x26+	mul	x22,x8,x26+	mul	x23,x9,x26+	mul	x24,x10,x26+	subs	xzr,x11,#1		// adds	x19,x19,x11+	umulh	x11,x5,x26+	adcs	x20,x20,x12+	umulh	x12,x6,x26+	adcs	x21,x21,x13+	umulh	x13,x7,x26+	adcs	x22,x22,x14+	umulh	x14,x8,x26+	adcs	x23,x23,x15+	umulh	x15,x9,x26+	adcs	x24,x24,x16+	umulh	x16,x10,x26+	adc	x25,xzr,xzr+	adds	x11,x11,x20+	adcs	x12,x12,x21+	adcs	x13,x13,x22+	mul	x26,x4,x11+	adcs	x14,x14,x23+	adcs	x15,x15,x24+	adc	x16,x16,x25++	// mul	x19,x5,x26+	mul	x20,x6,x26+	mul	x21,x7,x26+	mul	x22,x8,x26+	mul	x23,x9,x26+	mul	x24,x10,x26+	subs	xzr,x11,#1		// adds	x19,x19,x11+	umulh	x11,x5,x26+	adcs	x20,x20,x12+	umulh	x12,x6,x26+	adcs	x21,x21,x13+	umulh	x13,x7,x26+	adcs	x22,x22,x14+	umulh	x14,x8,x26+	adcs	x23,x23,x15+	umulh	x15,x9,x26+	adcs	x24,x24,x16+	umulh	x16,x10,x26+	adc	x25,xzr,xzr+	adds	x11,x11,x20+	adcs	x12,x12,x21+	adcs	x13,x13,x22+	mul	x26,x4,x11+	adcs	x14,x14,x23+	adcs	x15,x15,x24+	adc	x16,x16,x25++	// mul	x19,x5,x26+	mul	x20,x6,x26+	mul	x21,x7,x26+	mul	x22,x8,x26+	mul	x23,x9,x26+	mul	x24,x10,x26+	subs	xzr,x11,#1		// adds	x19,x19,x11+	umulh	x11,x5,x26+	adcs	x20,x20,x12+	umulh	x12,x6,x26+	adcs	x21,x21,x13+	umulh	x13,x7,x26+	adcs	x22,x22,x14+	umulh	x14,x8,x26+	adcs	x23,x23,x15+	umulh	x15,x9,x26+	adcs	x24,x24,x16+	umulh	x16,x10,x26+	adc	x25,xzr,xzr+	adds	x11,x11,x20+	adcs	x12,x12,x21+	adcs	x13,x13,x22+	mul	x26,x4,x11+	adcs	x14,x14,x23+	adcs	x15,x15,x24+	adc	x16,x16,x25++	// mul	x19,x5,x26+	mul	x20,x6,x26+	mul	x21,x7,x26+	mul	x22,x8,x26+	mul	x23,x9,x26+	mul	x24,x10,x26+	subs	xzr,x11,#1		// adds	x19,x19,x11+	umulh	x11,x5,x26+	adcs	x20,x20,x12+	umulh	x12,x6,x26+	adcs	x21,x21,x13+	umulh	x13,x7,x26+	adcs	x22,x22,x14+	umulh	x14,x8,x26+	adcs	x23,x23,x15+	umulh	x15,x9,x26+	adcs	x24,x24,x16+	umulh	x16,x10,x26+	adc	x25,xzr,xzr+	adds	x11,x11,x20+	adcs	x12,x12,x21+	adcs	x13,x13,x22+	mul	x26,x4,x11+	adcs	x14,x14,x23+	adcs	x15,x15,x24+	adc	x16,x16,x25++	// mul	x19,x5,x26+	mul	x20,x6,x26+	mul	x21,x7,x26+	mul	x22,x8,x26+	mul	x23,x9,x26+	mul	x24,x10,x26+	subs	xzr,x11,#1		// adds	x19,x19,x11+	umulh	x11,x5,x26+	adcs	x20,x20,x12+	umulh	x12,x6,x26+	adcs	x21,x21,x13+	umulh	x13,x7,x26+	adcs	x22,x22,x14+	umulh	x14,x8,x26+	adcs	x23,x23,x15+	umulh	x15,x9,x26+	adcs	x24,x24,x16+	umulh	x16,x10,x26+	adc	x25,xzr,xzr+	adds	x11,x11,x20+	adcs	x12,x12,x21+	adcs	x13,x13,x22+	mul	x26,x4,x11+	adcs	x14,x14,x23+	adcs	x15,x15,x24+	adc	x16,x16,x25++	// mul	x19,x5,x26+	mul	x20,x6,x26+	mul	x21,x7,x26+	mul	x22,x8,x26+	mul	x23,x9,x26+	mul	x24,x10,x26+	subs	xzr,x11,#1		// adds	x19,x19,x11+	umulh	x11,x5,x26+	adcs	x20,x20,x12+	umulh	x12,x6,x26+	adcs	x21,x21,x13+	umulh	x13,x7,x26+	adcs	x22,x22,x14+	umulh	x14,x8,x26+	adcs	x23,x23,x15+	umulh	x15,x9,x26+	adcs	x24,x24,x16+	umulh	x16,x10,x26+	adc	x25,xzr,xzr+	adds	x11,x11,x20+	adcs	x12,x12,x21+	adcs	x13,x13,x22+	adcs	x14,x14,x23+	adcs	x15,x15,x24+	adc	x16,x16,x25++	ret++++.align	5+__redc_tail_mont_384:+	ldp	x19,x20,[x1,#48]+	ldp	x21,x22,[x1,#64]+	ldp	x23,x24,[x1,#80]++	adds	x11,x11,x19	// accumulate upper half+	adcs	x12,x12,x20+	adcs	x13,x13,x21+	adcs	x14,x14,x22+	adcs	x15,x15,x23+	adcs	x16,x16,x24+	adc	x25,xzr,xzr++	subs	x19,x11,x5+	sbcs	x20,x12,x6+	sbcs	x21,x13,x7+	sbcs	x22,x14,x8+	sbcs	x23,x15,x9+	sbcs	x24,x16,x10+	sbcs	xzr,x25,xzr++	csel	x11,x11,x19,lo+	csel	x12,x12,x20,lo+	csel	x13,x13,x21,lo+	csel	x14,x14,x22,lo+	csel	x15,x15,x23,lo+	csel	x16,x16,x24,lo++	stp	x11,x12,[x0]+	stp	x13,x14,[x0,#16]+	stp	x15,x16,[x0,#32]++	ret+++.globl	_mul_384+.private_extern	_mul_384++.align	5+_mul_384:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]++	bl	__mul_384+	ldr	x30,[x29,#8]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret++++.align	5+__mul_384:+	ldp	x11,x12,[x1]+	ldr	x17,        [x2]+	ldp	x13,x14,[x1,#16]+	ldp	x15,x16,[x1,#32]++	mul	x19,x11,x17+	mul	x20,x12,x17+	mul	x21,x13,x17+	mul	x22,x14,x17+	mul	x23,x15,x17+	mul	x24,x16,x17++	umulh	x5,x11,x17+	umulh	x6,x12,x17+	umulh	x7,x13,x17+	umulh	x8,x14,x17+	umulh	x9,x15,x17+	umulh	x10,x16,x17+	ldr	x17,[x2,8*1]++	str	x19,[x0]+	adds	x19,x20,x5+	mul	x5,x11,x17+	adcs	x20,x21,x6+	mul	x6,x12,x17+	adcs	x21,x22,x7+	mul	x7,x13,x17+	adcs	x22,x23,x8+	mul	x8,x14,x17+	adcs	x23,x24,x9+	mul	x9,x15,x17+	adc	x24,xzr,    x10+	mul	x10,x16,x17+	adds	x19,x19,x5+	umulh	x5,x11,x17+	adcs	x20,x20,x6+	umulh	x6,x12,x17+	adcs	x21,x21,x7+	umulh	x7,x13,x17+	adcs	x22,x22,x8+	umulh	x8,x14,x17+	adcs	x23,x23,x9+	umulh	x9,x15,x17+	adcs	x24,x24,x10+	umulh	x10,x16,x17+	ldr	x17,[x2,#8*(1+1)]+	adc	x25,xzr,xzr++	str	x19,[x0,8*1]+	adds	x19,x20,x5+	mul	x5,x11,x17+	adcs	x20,x21,x6+	mul	x6,x12,x17+	adcs	x21,x22,x7+	mul	x7,x13,x17+	adcs	x22,x23,x8+	mul	x8,x14,x17+	adcs	x23,x24,x9+	mul	x9,x15,x17+	adc	x24,x25,x10+	mul	x10,x16,x17+	adds	x19,x19,x5+	umulh	x5,x11,x17+	adcs	x20,x20,x6+	umulh	x6,x12,x17+	adcs	x21,x21,x7+	umulh	x7,x13,x17+	adcs	x22,x22,x8+	umulh	x8,x14,x17+	adcs	x23,x23,x9+	umulh	x9,x15,x17+	adcs	x24,x24,x10+	umulh	x10,x16,x17+	ldr	x17,[x2,#8*(2+1)]+	adc	x25,xzr,xzr++	str	x19,[x0,8*2]+	adds	x19,x20,x5+	mul	x5,x11,x17+	adcs	x20,x21,x6+	mul	x6,x12,x17+	adcs	x21,x22,x7+	mul	x7,x13,x17+	adcs	x22,x23,x8+	mul	x8,x14,x17+	adcs	x23,x24,x9+	mul	x9,x15,x17+	adc	x24,x25,x10+	mul	x10,x16,x17+	adds	x19,x19,x5+	umulh	x5,x11,x17+	adcs	x20,x20,x6+	umulh	x6,x12,x17+	adcs	x21,x21,x7+	umulh	x7,x13,x17+	adcs	x22,x22,x8+	umulh	x8,x14,x17+	adcs	x23,x23,x9+	umulh	x9,x15,x17+	adcs	x24,x24,x10+	umulh	x10,x16,x17+	ldr	x17,[x2,#8*(3+1)]+	adc	x25,xzr,xzr++	str	x19,[x0,8*3]+	adds	x19,x20,x5+	mul	x5,x11,x17+	adcs	x20,x21,x6+	mul	x6,x12,x17+	adcs	x21,x22,x7+	mul	x7,x13,x17+	adcs	x22,x23,x8+	mul	x8,x14,x17+	adcs	x23,x24,x9+	mul	x9,x15,x17+	adc	x24,x25,x10+	mul	x10,x16,x17+	adds	x19,x19,x5+	umulh	x5,x11,x17+	adcs	x20,x20,x6+	umulh	x6,x12,x17+	adcs	x21,x21,x7+	umulh	x7,x13,x17+	adcs	x22,x22,x8+	umulh	x8,x14,x17+	adcs	x23,x23,x9+	umulh	x9,x15,x17+	adcs	x24,x24,x10+	umulh	x10,x16,x17+	ldr	x17,[x2,#8*(4+1)]+	adc	x25,xzr,xzr++	str	x19,[x0,8*4]+	adds	x19,x20,x5+	mul	x5,x11,x17+	adcs	x20,x21,x6+	mul	x6,x12,x17+	adcs	x21,x22,x7+	mul	x7,x13,x17+	adcs	x22,x23,x8+	mul	x8,x14,x17+	adcs	x23,x24,x9+	mul	x9,x15,x17+	adc	x24,x25,x10+	mul	x10,x16,x17+	adds	x19,x19,x5+	umulh	x5,x11,x17+	adcs	x20,x20,x6+	umulh	x6,x12,x17+	adcs	x21,x21,x7+	umulh	x7,x13,x17+	adcs	x22,x22,x8+	umulh	x8,x14,x17+	adcs	x23,x23,x9+	umulh	x9,x15,x17+	adcs	x24,x24,x10+	umulh	x10,x16,x17+	adc	x25,xzr,xzr++	str	x19,[x0,8*5]+	adds	x19,x20,x5+	adcs	x20,x21,x6+	adcs	x21,x22,x7+	adcs	x22,x23,x8+	adcs	x23,x24,x9+	adc	x24,x25,x10++	stp	x19,x20,[x0,#48]+	stp	x21,x22,[x0,#64]+	stp	x23,x24,[x0,#80]++	ret+++.globl	_mul_382x+.private_extern	_mul_382x++.align	5+_mul_382x:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	sub	sp,sp,#96		// space for two 384-bit vectors++	ldp	x11,x12,[x1]+	mov	x26,x0		// save r_ptr+	ldp	x19,x20,[x1,#48]+	mov	x27,x1		// save a_ptr+	ldp	x13,x14,[x1,#16]+	mov	x28,x2		// save b_ptr+	ldp	x21,x22,[x1,#64]+	ldp	x15,x16,[x1,#32]+	adds	x5,x11,x19	// t0 = a->re + a->im+	ldp	x23,x24,[x1,#80]+	adcs	x6,x12,x20+	ldp	x11,x12,[x2]+	adcs	x7,x13,x21+	ldp	x19,x20,[x2,#48]+	adcs	x8,x14,x22+	ldp	x13,x14,[x2,#16]+	adcs	x9,x15,x23+	ldp	x21,x22,[x2,#64]+	adc	x10,x16,x24+	ldp	x15,x16,[x2,#32]++	stp	x5,x6,[sp]+	adds	x5,x11,x19	// t1 = b->re + b->im+	ldp	x23,x24,[x2,#80]+	adcs	x6,x12,x20+	stp	x7,x8,[sp,#16]+	adcs	x7,x13,x21+	adcs	x8,x14,x22+	stp	x9,x10,[sp,#32]+	adcs	x9,x15,x23+	stp	x5,x6,[sp,#48]+	adc	x10,x16,x24+	stp	x7,x8,[sp,#64]+	stp	x9,x10,[sp,#80]++	bl	__mul_384		// _mul_384(ret->re, a->re, b->re)++	add	x1,sp,#0		// _mul_384(ret->im, t0, t1)+	add	x2,sp,#48+	add	x0,x26,#96+	bl	__mul_384++	add	x1,x27,#48	// _mul_384(tx, a->im, b->im)+	add	x2,x28,#48+	add	x0,sp,#0+	bl	__mul_384++	ldp	x5,x6,[x3]+	ldp	x7,x8,[x3,#16]+	ldp	x9,x10,[x3,#32]++	add	x1,x26,#96	// ret->im -= tx+	add	x2,sp,#0+	add	x0,x26,#96+	bl	__sub_mod_384x384++	add	x2,x26,#0	// ret->im -= ret->re+	bl	__sub_mod_384x384++	add	x1,x26,#0	// ret->re -= tx+	add	x2,sp,#0+	add	x0,x26,#0+	bl	__sub_mod_384x384+	ldr	x30,[x29,#8]++	add	sp,sp,#96+	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret+++.globl	_sqr_382x+.private_extern	_sqr_382x++.align	5+_sqr_382x:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]++	ldp	x11,x12,[x1]+	ldp	x19,x20,[x1,#48]+	ldp	x13,x14,[x1,#16]+	adds	x5,x11,x19	// t0 = a->re + a->im+	ldp	x21,x22,[x1,#64]+	adcs	x6,x12,x20+	ldp	x15,x16,[x1,#32]+	adcs	x7,x13,x21+	ldp	x23,x24,[x1,#80]+	adcs	x8,x14,x22+	stp	x5,x6,[x0]+	adcs	x9,x15,x23+	ldp	x5,x6,[x2]+	adc	x10,x16,x24+	stp	x7,x8,[x0,#16]++	subs	x11,x11,x19	// t1 = a->re - a->im+	ldp	x7,x8,[x2,#16]+	sbcs	x12,x12,x20+	stp	x9,x10,[x0,#32]+	sbcs	x13,x13,x21+	ldp	x9,x10,[x2,#32]+	sbcs	x14,x14,x22+	sbcs	x15,x15,x23+	sbcs	x16,x16,x24+	sbc	x25,xzr,xzr++	and	x19,x5,x25+	and	x20,x6,x25+	adds	x11,x11,x19+	and	x21,x7,x25+	adcs	x12,x12,x20+	and	x22,x8,x25+	adcs	x13,x13,x21+	and	x23,x9,x25+	adcs	x14,x14,x22+	and	x24,x10,x25+	adcs	x15,x15,x23+	stp	x11,x12,[x0,#48]+	adc	x16,x16,x24+	stp	x13,x14,[x0,#64]+	stp	x15,x16,[x0,#80]++	mov	x4,x1		// save a_ptr+	add	x1,x0,#0	// _mul_384(ret->re, t0, t1)+	add	x2,x0,#48+	bl	__mul_384++	add	x1,x4,#0		// _mul_384(ret->im, a->re, a->im)+	add	x2,x4,#48+	add	x0,x0,#96+	bl	__mul_384+	ldr	x30,[x29,#8]++	ldp	x11,x12,[x0]+	ldp	x13,x14,[x0,#16]+	adds	x11,x11,x11	// add with itself+	ldp	x15,x16,[x0,#32]+	adcs	x12,x12,x12+	adcs	x13,x13,x13+	adcs	x14,x14,x14+	adcs	x15,x15,x15+	adcs	x16,x16,x16+	adcs	x19,x19,x19+	adcs	x20,x20,x20+	stp	x11,x12,[x0]+	adcs	x21,x21,x21+	stp	x13,x14,[x0,#16]+	adcs	x22,x22,x22+	stp	x15,x16,[x0,#32]+	adcs	x23,x23,x23+	stp	x19,x20,[x0,#48]+	adc	x24,x24,x24+	stp	x21,x22,[x0,#64]+	stp	x23,x24,[x0,#80]++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret+++.globl	_sqr_mont_382x+.private_extern	_sqr_mont_382x++.align	5+_sqr_mont_382x:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]+	stp	x3,x0,[sp,#96]	// __mul_mont_384 wants them there+	sub	sp,sp,#112		// space for two 384-bit vectors + word+	mov	x4,x3		// adjust for missing b_ptr++	ldp	x11,x12,[x1]+	ldp	x13,x14,[x1,#16]+	ldp	x15,x16,[x1,#32]++	ldp	x17,x20,[x1,#48]+	ldp	x21,x22,[x1,#64]+	ldp	x23,x24,[x1,#80]++	adds	x5,x11,x17	// t0 = a->re + a->im+	adcs	x6,x12,x20+	adcs	x7,x13,x21+	adcs	x8,x14,x22+	adcs	x9,x15,x23+	adc	x10,x16,x24++	subs	x19,x11,x17	// t1 = a->re - a->im+	sbcs	x20,x12,x20+	sbcs	x21,x13,x21+	sbcs	x22,x14,x22+	sbcs	x23,x15,x23+	sbcs	x24,x16,x24+	sbc	x25,xzr,xzr		// borrow flag as mask++	stp	x5,x6,[sp]+	stp	x7,x8,[sp,#16]+	stp	x9,x10,[sp,#32]+	stp	x19,x20,[sp,#48]+	stp	x21,x22,[sp,#64]+	stp	x23,x24,[sp,#80]+	str	x25,[sp,#96]++	ldp	x5,x6,[x2]+	ldp	x7,x8,[x2,#16]+	ldp	x9,x10,[x2,#32]++	add	x2,x1,#48+	bl	__mul_mont_383_nonred	// _mul_mont_384(ret->im, a->re, a->im)++	adds	x19,x11,x11	// add with itself+	adcs	x20,x12,x12+	adcs	x21,x13,x13+	adcs	x22,x14,x14+	adcs	x23,x15,x15+	adc	x24,x16,x16++	stp	x19,x20,[x2,#48]+	stp	x21,x22,[x2,#64]+	stp	x23,x24,[x2,#80]++	ldp	x11,x12,[sp]+	ldr	x17,[sp,#48]+	ldp	x13,x14,[sp,#16]+	ldp	x15,x16,[sp,#32]++	add	x2,sp,#48+	bl	__mul_mont_383_nonred	// _mul_mont_384(ret->im, t0, t1)+	ldr	x30,[x29,#8]++	ldr	x25,[sp,#96]	// account for sign from a->re - a->im+	ldp	x19,x20,[sp]+	ldp	x21,x22,[sp,#16]+	ldp	x23,x24,[sp,#32]++	and	x19,x19,x25+	and	x20,x20,x25+	and	x21,x21,x25+	and	x22,x22,x25+	and	x23,x23,x25+	and	x24,x24,x25++	subs	x11,x11,x19+	sbcs	x12,x12,x20+	sbcs	x13,x13,x21+	sbcs	x14,x14,x22+	sbcs	x15,x15,x23+	sbcs	x16,x16,x24+	sbc	x25,xzr,xzr++	and	x19,x5,x25+	and	x20,x6,x25+	and	x21,x7,x25+	and	x22,x8,x25+	and	x23,x9,x25+	and	x24,x10,x25++	adds	x11,x11,x19+	adcs	x12,x12,x20+	adcs	x13,x13,x21+	adcs	x14,x14,x22+	adcs	x15,x15,x23+	adc	x16,x16,x24++	stp	x11,x12,[x2]+	stp	x13,x14,[x2,#16]+	stp	x15,x16,[x2,#32]++	add	sp,sp,#112+	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret++++.align	5+__mul_mont_383_nonred:+	mul	x19,x11,x17+	mul	x20,x12,x17+	mul	x21,x13,x17+	mul	x22,x14,x17+	mul	x23,x15,x17+	mul	x24,x16,x17+	mul	x4,x4,x19++	umulh	x26,x11,x17+	umulh	x27,x12,x17+	umulh	x28,x13,x17+	umulh	x0,x14,x17+	umulh	x1,x15,x17+	umulh	x3,x16,x17++	adds	x20,x20,x26+	mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adc	x25,xzr,    x3+	mul	x3,x10,x4+	ldr	x17,[x2,8*1]+	adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adc	x25,x25,xzr++	ldr	x4,[x29,#96]+	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,xzr,xzr++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adc	x25,x25,xzr++	adds	x20,x20,x26+	mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adc	x25,x25,x3+	mul	x3,x10,x4+	ldr	x17,[x2,8*2]+	adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adc	x25,x25,xzr++	ldr	x4,[x29,#96]+	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,xzr,xzr++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adc	x25,x25,xzr++	adds	x20,x20,x26+	mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adc	x25,x25,x3+	mul	x3,x10,x4+	ldr	x17,[x2,8*3]+	adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adc	x25,x25,xzr++	ldr	x4,[x29,#96]+	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,xzr,xzr++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adc	x25,x25,xzr++	adds	x20,x20,x26+	mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adc	x25,x25,x3+	mul	x3,x10,x4+	ldr	x17,[x2,8*4]+	adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adc	x25,x25,xzr++	ldr	x4,[x29,#96]+	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,xzr,xzr++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adc	x25,x25,xzr++	adds	x20,x20,x26+	mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adc	x25,x25,x3+	mul	x3,x10,x4+	ldr	x17,[x2,8*5]+	adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adc	x25,x25,xzr++	ldr	x4,[x29,#96]+	adds	x19,x20,x26+	mul	x26,x11,x17+	adcs	x20,x21,x27+	mul	x27,x12,x17+	adcs	x21,x22,x28+	mul	x28,x13,x17+	adcs	x22,x23,x0+	mul	x0,x14,x17+	adcs	x23,x24,x1+	mul	x1,x15,x17+	adcs	x24,x25,x3+	mul	x3,x16,x17+	adc	x25,xzr,xzr++	adds	x19,x19,x26+	umulh	x26,x11,x17+	adcs	x20,x20,x27+	umulh	x27,x12,x17+	adcs	x21,x21,x28+	mul	x4,x4,x19+	umulh	x28,x13,x17+	adcs	x22,x22,x0+	umulh	x0,x14,x17+	adcs	x23,x23,x1+	umulh	x1,x15,x17+	adcs	x24,x24,x3+	umulh	x3,x16,x17+	adc	x25,x25,xzr++	adds	x20,x20,x26+	mul	x26,x5,x4+	adcs	x21,x21,x27+	mul	x27,x6,x4+	adcs	x22,x22,x28+	mul	x28,x7,x4+	adcs	x23,x23,x0+	mul	x0,x8,x4+	adcs	x24,x24,x1+	mul	x1,x9,x4+	adc	x25,x25,x3+	mul	x3,x10,x4+	adds	x19,x19,x26+	umulh	x26,x5,x4+	adcs	x20,x20,x27+	umulh	x27,x6,x4+	adcs	x21,x21,x28+	umulh	x28,x7,x4+	adcs	x22,x22,x0+	umulh	x0,x8,x4+	adcs	x23,x23,x1+	umulh	x1,x9,x4+	adcs	x24,x24,x3+	umulh	x3,x10,x4+	adc	x25,x25,xzr+	ldp	x4,x2,[x29,#96]		// pull r_ptr++	adds	x11,x20,x26+	adcs	x12,x21,x27+	adcs	x13,x22,x28+	adcs	x14,x23,x0+	adcs	x15,x24,x1+	adcs	x16,x25,x3++	ret+++.globl	_sgn0_pty_mont_384+.private_extern	_sgn0_pty_mont_384++.align	5+_sgn0_pty_mont_384:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]++	mov	x4,x2+	ldp	x5,x6,[x1]+	ldp	x7,x8,[x1,#16]+	ldp	x9,x10,[x1,#32]+	mov	x1,x0++	bl	__mul_by_1_mont_384+	ldr	x30,[x29,#8]++	and	x0,x11,#1+	adds	x11,x11,x11+	adcs	x12,x12,x12+	adcs	x13,x13,x13+	adcs	x14,x14,x14+	adcs	x15,x15,x15+	adcs	x16,x16,x16+	adc	x17,xzr,xzr++	subs	x11,x11,x5+	sbcs	x12,x12,x6+	sbcs	x13,x13,x7+	sbcs	x14,x14,x8+	sbcs	x15,x15,x9+	sbcs	x16,x16,x10+	sbc	x17,x17,xzr++	mvn	x17,x17+	and	x17,x17,#2+	orr	x0,x0,x17++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret+++.globl	_sgn0_pty_mont_384x+.private_extern	_sgn0_pty_mont_384x++.align	5+_sgn0_pty_mont_384x:+.long	3573752639+	stp	x29,x30,[sp,#-128]!+	add	x29,sp,#0+	stp	x19,x20,[sp,#16]+	stp	x21,x22,[sp,#32]+	stp	x23,x24,[sp,#48]+	stp	x25,x26,[sp,#64]+	stp	x27,x28,[sp,#80]++	mov	x4,x2+	ldp	x5,x6,[x1]+	ldp	x7,x8,[x1,#16]+	ldp	x9,x10,[x1,#32]+	mov	x1,x0++	bl	__mul_by_1_mont_384+	add	x1,x1,#48++	and	x2,x11,#1+	orr	x3,x11,x12+	adds	x11,x11,x11+	orr	x3,x3,x13+	adcs	x12,x12,x12+	orr	x3,x3,x14+	adcs	x13,x13,x13+	orr	x3,x3,x15+	adcs	x14,x14,x14+	orr	x3,x3,x16+	adcs	x15,x15,x15+	adcs	x16,x16,x16+	adc	x17,xzr,xzr++	subs	x11,x11,x5+	sbcs	x12,x12,x6+	sbcs	x13,x13,x7+	sbcs	x14,x14,x8+	sbcs	x15,x15,x9+	sbcs	x16,x16,x10+	sbc	x17,x17,xzr++	mvn	x17,x17+	and	x17,x17,#2+	orr	x2,x2,x17++	bl	__mul_by_1_mont_384+	ldr	x30,[x29,#8]++	and	x0,x11,#1+	orr	x1,x11,x12+	adds	x11,x11,x11+	orr	x1,x1,x13+	adcs	x12,x12,x12+	orr	x1,x1,x14+	adcs	x13,x13,x13+	orr	x1,x1,x15+	adcs	x14,x14,x14+	orr	x1,x1,x16+	adcs	x15,x15,x15+	adcs	x16,x16,x16+	adc	x17,xzr,xzr++	subs	x11,x11,x5+	sbcs	x12,x12,x6+	sbcs	x13,x13,x7+	sbcs	x14,x14,x8+	sbcs	x15,x15,x9+	sbcs	x16,x16,x10+	sbc	x17,x17,xzr++	mvn	x17,x17+	and	x17,x17,#2+	orr	x0,x0,x17++	cmp	x3,#0+	csel	x3,x0,x2,eq	// a->re==0? prty(a->im) : prty(a->re)++	cmp	x1,#0+	csel	x1,x0,x2,ne	// a->im!=0? sgn0(a->im) : sgn0(a->re)++	and	x3,x3,#1+	and	x1,x1,#2+	orr	x0,x1,x3		// pack sign and parity++	ldp	x19,x20,[x29,#16]+	ldp	x21,x22,[x29,#32]+	ldp	x23,x24,[x29,#48]+	ldp	x25,x26,[x29,#64]+	ldp	x27,x28,[x29,#80]+	ldr	x29,[sp],#128+.long	3573752767+	ret+
+ c-source/build/mach-o/mulq_mont_256-x86_64.s view
@@ -0,0 +1,706 @@+.text	++.globl	_mul_mont_sparse_256+.private_extern	_mul_mont_sparse_256++.p2align	5+_mul_mont_sparse_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	pushq	%rdi+.cfi_adjust_cfa_offset	8+++	movq	0(%rdx),%rax+	movq	0(%rsi),%r13+	movq	8(%rsi),%r14+	movq	16(%rsi),%r12+	movq	24(%rsi),%rbp+	movq	%rdx,%rbx++	movq	%rax,%r15+	mulq	%r13+	movq	%rax,%r9+	movq	%r15,%rax+	movq	%rdx,%r10+	call	__mulq_mont_sparse_256++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+++.globl	_sqr_mont_sparse_256+.private_extern	_sqr_mont_sparse_256++.p2align	5+_sqr_mont_sparse_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	pushq	%rdi+.cfi_adjust_cfa_offset	8+++	movq	0(%rsi),%rax+	movq	%rcx,%r8+	movq	8(%rsi),%r14+	movq	%rdx,%rcx+	movq	16(%rsi),%r12+	leaq	(%rsi),%rbx+	movq	24(%rsi),%rbp++	movq	%rax,%r15+	mulq	%rax+	movq	%rax,%r9+	movq	%r15,%rax+	movq	%rdx,%r10+	call	__mulq_mont_sparse_256++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+++.p2align	5+__mulq_mont_sparse_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	mulq	%r14+	addq	%rax,%r10+	movq	%r15,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	%r12+	addq	%rax,%r11+	movq	%r15,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	%rbp+	addq	%rax,%r12+	movq	8(%rbx),%rax+	adcq	$0,%rdx+	xorq	%r14,%r14+	movq	%rdx,%r13++	movq	%r9,%rdi+	imulq	%r8,%r9+++	movq	%rax,%r15+	mulq	0(%rsi)+	addq	%rax,%r10+	movq	%r15,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	8(%rsi)+	addq	%rax,%r11+	movq	%r15,%rax+	adcq	$0,%rdx+	addq	%rbp,%r11+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rsi)+	addq	%rax,%r12+	movq	%r15,%rax+	adcq	$0,%rdx+	addq	%rbp,%r12+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rsi)+	addq	%rax,%r13+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	%rdx,%r14+	xorq	%r15,%r15+++	mulq	0(%rcx)+	addq	%rax,%rdi+	movq	%r9,%rax+	adcq	%rdx,%rdi++	mulq	8(%rcx)+	addq	%rax,%r10+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%rdi,%r10+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r11+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%rbp,%r11+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rax,%r12+	movq	16(%rbx),%rax+	adcq	$0,%rdx+	addq	%rbp,%r12+	adcq	$0,%rdx+	addq	%rdx,%r13+	adcq	$0,%r14+	adcq	$0,%r15+	movq	%r10,%rdi+	imulq	%r8,%r10+++	movq	%rax,%r9+	mulq	0(%rsi)+	addq	%rax,%r11+	movq	%r9,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	8(%rsi)+	addq	%rax,%r12+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%rbp,%r12+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rsi)+	addq	%rax,%r13+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rsi)+	addq	%rax,%r14+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%rbp,%r14+	adcq	%rdx,%r15+	xorq	%r9,%r9+++	mulq	0(%rcx)+	addq	%rax,%rdi+	movq	%r10,%rax+	adcq	%rdx,%rdi++	mulq	8(%rcx)+	addq	%rax,%r11+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%rdi,%r11+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r12+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%rbp,%r12+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rax,%r13+	movq	24(%rbx),%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	$0,%rdx+	addq	%rdx,%r14+	adcq	$0,%r15+	adcq	$0,%r9+	movq	%r11,%rdi+	imulq	%r8,%r11+++	movq	%rax,%r10+	mulq	0(%rsi)+	addq	%rax,%r12+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	8(%rsi)+	addq	%rax,%r13+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rsi)+	addq	%rax,%r14+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%rbp,%r14+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rsi)+	addq	%rax,%r15+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%rbp,%r15+	adcq	%rdx,%r9+	xorq	%r10,%r10+++	mulq	0(%rcx)+	addq	%rax,%rdi+	movq	%r11,%rax+	adcq	%rdx,%rdi++	mulq	8(%rcx)+	addq	%rax,%r12+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%rdi,%r12+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rax,%r14+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%rbp,%r14+	adcq	$0,%rdx+	addq	%rdx,%r15+	adcq	$0,%r9+	adcq	$0,%r10+	imulq	%r8,%rax+	movq	8(%rsp),%rsi+++	movq	%rax,%r11+	mulq	0(%rcx)+	addq	%rax,%r12+	movq	%r11,%rax+	adcq	%rdx,%r12++	mulq	8(%rcx)+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r12,%r13+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r14+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%rbp,%r14+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	movq	%r14,%rbx+	addq	%rbp,%r15+	adcq	$0,%rdx+	addq	%rax,%r15+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%rdx,%r9+	adcq	$0,%r10+++++	movq	%r15,%r12+	subq	0(%rcx),%r13+	sbbq	8(%rcx),%r14+	sbbq	16(%rcx),%r15+	movq	%r9,%rbp+	sbbq	24(%rcx),%r9+	sbbq	$0,%r10++	cmovcq	%rax,%r13+	cmovcq	%rbx,%r14+	cmovcq	%r12,%r15+	movq	%r13,0(%rsi)+	cmovcq	%rbp,%r9+	movq	%r14,8(%rsi)+	movq	%r15,16(%rsi)+	movq	%r9,24(%rsi)++	.byte	0xf3,0xc3+.cfi_endproc	++.globl	_from_mont_256+.private_extern	_from_mont_256++.p2align	5+_from_mont_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rdx,%rbx+	call	__mulq_by_1_mont_256++++++	movq	%r14,%r10+	movq	%r15,%r11+	movq	%r9,%r12++	subq	0(%rbx),%r13+	sbbq	8(%rbx),%r14+	sbbq	16(%rbx),%r15+	sbbq	24(%rbx),%r9++	cmovncq	%r13,%rax+	cmovncq	%r14,%r10+	cmovncq	%r15,%r11+	movq	%rax,0(%rdi)+	cmovncq	%r9,%r12+	movq	%r10,8(%rdi)+	movq	%r11,16(%rdi)+	movq	%r12,24(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+++.globl	_redc_mont_256+.private_extern	_redc_mont_256++.p2align	5+_redc_mont_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rdx,%rbx+	call	__mulq_by_1_mont_256++	addq	32(%rsi),%r13+	adcq	40(%rsi),%r14+	movq	%r13,%rax+	adcq	48(%rsi),%r15+	movq	%r14,%r10+	adcq	56(%rsi),%r9+	sbbq	%rsi,%rsi+++++	movq	%r15,%r11+	subq	0(%rbx),%r13+	sbbq	8(%rbx),%r14+	sbbq	16(%rbx),%r15+	movq	%r9,%r12+	sbbq	24(%rbx),%r9+	sbbq	$0,%rsi++	cmovncq	%r13,%rax+	cmovncq	%r14,%r10+	cmovncq	%r15,%r11+	movq	%rax,0(%rdi)+	cmovncq	%r9,%r12+	movq	%r10,8(%rdi)+	movq	%r11,16(%rdi)+	movq	%r12,24(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+++.p2align	5+__mulq_by_1_mont_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%rax+	movq	8(%rsi),%r10+	movq	16(%rsi),%r11+	movq	24(%rsi),%r12++	movq	%rax,%r13+	imulq	%rcx,%rax+	movq	%rax,%r9++	mulq	0(%rbx)+	addq	%rax,%r13+	movq	%r9,%rax+	adcq	%rdx,%r13++	mulq	8(%rbx)+	addq	%rax,%r10+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r13,%r10+	adcq	$0,%rdx+	movq	%rdx,%r13++	mulq	16(%rbx)+	movq	%r10,%r14+	imulq	%rcx,%r10+	addq	%rax,%r11+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r13,%r11+	adcq	$0,%rdx+	movq	%rdx,%r13++	mulq	24(%rbx)+	addq	%rax,%r12+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r13,%r12+	adcq	$0,%rdx+	movq	%rdx,%r13++	mulq	0(%rbx)+	addq	%rax,%r14+	movq	%r10,%rax+	adcq	%rdx,%r14++	mulq	8(%rbx)+	addq	%rax,%r11+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r14,%r11+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	16(%rbx)+	movq	%r11,%r15+	imulq	%rcx,%r11+	addq	%rax,%r12+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r14,%r12+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	24(%rbx)+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r14,%r13+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	0(%rbx)+	addq	%rax,%r15+	movq	%r11,%rax+	adcq	%rdx,%r15++	mulq	8(%rbx)+	addq	%rax,%r12+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r15,%r12+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	16(%rbx)+	movq	%r12,%r9+	imulq	%rcx,%r12+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r15,%r13+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	24(%rbx)+	addq	%rax,%r14+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r15,%r14+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	0(%rbx)+	addq	%rax,%r9+	movq	%r12,%rax+	adcq	%rdx,%r9++	mulq	8(%rbx)+	addq	%rax,%r13+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r9,%r13+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	16(%rbx)+	addq	%rax,%r14+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r9,%r14+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rbx)+	addq	%rax,%r15+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r9,%r15+	adcq	$0,%rdx+	movq	%rdx,%r9+	.byte	0xf3,0xc3+.cfi_endproc+
+ c-source/build/mach-o/mulq_mont_384-x86_64.s view
@@ -0,0 +1,3612 @@+.text	+++++++++.p2align	5+__sub_mod_384x384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	48(%rsi),%r14++	subq	0(%rdx),%r8+	movq	56(%rsi),%r15+	sbbq	8(%rdx),%r9+	movq	64(%rsi),%rax+	sbbq	16(%rdx),%r10+	movq	72(%rsi),%rbx+	sbbq	24(%rdx),%r11+	movq	80(%rsi),%rbp+	sbbq	32(%rdx),%r12+	movq	88(%rsi),%rsi+	sbbq	40(%rdx),%r13+	movq	%r8,0(%rdi)+	sbbq	48(%rdx),%r14+	movq	0(%rcx),%r8+	movq	%r9,8(%rdi)+	sbbq	56(%rdx),%r15+	movq	8(%rcx),%r9+	movq	%r10,16(%rdi)+	sbbq	64(%rdx),%rax+	movq	16(%rcx),%r10+	movq	%r11,24(%rdi)+	sbbq	72(%rdx),%rbx+	movq	24(%rcx),%r11+	movq	%r12,32(%rdi)+	sbbq	80(%rdx),%rbp+	movq	32(%rcx),%r12+	movq	%r13,40(%rdi)+	sbbq	88(%rdx),%rsi+	movq	40(%rcx),%r13+	sbbq	%rdx,%rdx++	andq	%rdx,%r8+	andq	%rdx,%r9+	andq	%rdx,%r10+	andq	%rdx,%r11+	andq	%rdx,%r12+	andq	%rdx,%r13++	addq	%r8,%r14+	adcq	%r9,%r15+	movq	%r14,48(%rdi)+	adcq	%r10,%rax+	movq	%r15,56(%rdi)+	adcq	%r11,%rbx+	movq	%rax,64(%rdi)+	adcq	%r12,%rbp+	movq	%rbx,72(%rdi)+	adcq	%r13,%rsi+	movq	%rbp,80(%rdi)+	movq	%rsi,88(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc++++.p2align	5+__add_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	addq	0(%rdx),%r8+	adcq	8(%rdx),%r9+	adcq	16(%rdx),%r10+	movq	%r8,%r14+	adcq	24(%rdx),%r11+	movq	%r9,%r15+	adcq	32(%rdx),%r12+	movq	%r10,%rax+	adcq	40(%rdx),%r13+	movq	%r11,%rbx+	sbbq	%rdx,%rdx++	subq	0(%rcx),%r8+	sbbq	8(%rcx),%r9+	movq	%r12,%rbp+	sbbq	16(%rcx),%r10+	sbbq	24(%rcx),%r11+	sbbq	32(%rcx),%r12+	movq	%r13,%rsi+	sbbq	40(%rcx),%r13+	sbbq	$0,%rdx++	cmovcq	%r14,%r8+	cmovcq	%r15,%r9+	cmovcq	%rax,%r10+	movq	%r8,0(%rdi)+	cmovcq	%rbx,%r11+	movq	%r9,8(%rdi)+	cmovcq	%rbp,%r12+	movq	%r10,16(%rdi)+	cmovcq	%rsi,%r13+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc++++.p2align	5+__sub_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++__sub_mod_384_a_is_loaded:+	subq	0(%rdx),%r8+	movq	0(%rcx),%r14+	sbbq	8(%rdx),%r9+	movq	8(%rcx),%r15+	sbbq	16(%rdx),%r10+	movq	16(%rcx),%rax+	sbbq	24(%rdx),%r11+	movq	24(%rcx),%rbx+	sbbq	32(%rdx),%r12+	movq	32(%rcx),%rbp+	sbbq	40(%rdx),%r13+	movq	40(%rcx),%rsi+	sbbq	%rdx,%rdx++	andq	%rdx,%r14+	andq	%rdx,%r15+	andq	%rdx,%rax+	andq	%rdx,%rbx+	andq	%rdx,%rbp+	andq	%rdx,%rsi++	addq	%r14,%r8+	adcq	%r15,%r9+	movq	%r8,0(%rdi)+	adcq	%rax,%r10+	movq	%r9,8(%rdi)+	adcq	%rbx,%r11+	movq	%r10,16(%rdi)+	adcq	%rbp,%r12+	movq	%r11,24(%rdi)+	adcq	%rsi,%r13+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc++.globl	_mul_mont_384x+.private_extern	_mul_mont_384x++.p2align	5+_mul_mont_384x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$328,%rsp+.cfi_adjust_cfa_offset	328+++	movq	%rdx,%rbx+	movq	%rdi,32(%rsp)+	movq	%rsi,24(%rsp)+	movq	%rdx,16(%rsp)+	movq	%rcx,8(%rsp)+	movq	%r8,0(%rsp)+++++	leaq	40(%rsp),%rdi+	call	__mulq_384+++	leaq	48(%rbx),%rbx+	leaq	48(%rsi),%rsi+	leaq	40+96(%rsp),%rdi+	call	__mulq_384+++	movq	8(%rsp),%rcx+	leaq	-48(%rsi),%rdx+	leaq	40+192+48(%rsp),%rdi+	call	__add_mod_384++	movq	16(%rsp),%rsi+	leaq	48(%rsi),%rdx+	leaq	-48(%rdi),%rdi+	call	__add_mod_384++	leaq	(%rdi),%rbx+	leaq	48(%rdi),%rsi+	call	__mulq_384+++	leaq	(%rdi),%rsi+	leaq	40(%rsp),%rdx+	movq	8(%rsp),%rcx+	call	__sub_mod_384x384++	leaq	(%rdi),%rsi+	leaq	-96(%rdi),%rdx+	call	__sub_mod_384x384+++	leaq	40(%rsp),%rsi+	leaq	40+96(%rsp),%rdx+	leaq	40(%rsp),%rdi+	call	__sub_mod_384x384++	movq	%rcx,%rbx+++	leaq	40(%rsp),%rsi+	movq	0(%rsp),%rcx+	movq	32(%rsp),%rdi+	call	__mulq_by_1_mont_384+	call	__redc_tail_mont_384+++	leaq	40+192(%rsp),%rsi+	movq	0(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__mulq_by_1_mont_384+	call	__redc_tail_mont_384++	leaq	328(%rsp),%r8+	movq	0(%r8),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-328-8*6++	.byte	0xf3,0xc3+.cfi_endproc	++.globl	_sqr_mont_384x+.private_extern	_sqr_mont_384x++.p2align	5+_sqr_mont_384x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$136,%rsp+.cfi_adjust_cfa_offset	136+++	movq	%rcx,0(%rsp)+	movq	%rdx,%rcx+	movq	%rdi,8(%rsp)+	movq	%rsi,16(%rsp)+++	leaq	48(%rsi),%rdx+	leaq	32(%rsp),%rdi+	call	__add_mod_384+++	movq	16(%rsp),%rsi+	leaq	48(%rsi),%rdx+	leaq	32+48(%rsp),%rdi+	call	__sub_mod_384+++	movq	16(%rsp),%rsi+	leaq	48(%rsi),%rbx++	movq	48(%rsi),%rax+	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%r12+	movq	24(%rsi),%r13++	call	__mulq_mont_384+	addq	%r14,%r14+	adcq	%r15,%r15+	adcq	%r8,%r8+	movq	%r14,%r12+	adcq	%r9,%r9+	movq	%r15,%r13+	adcq	%r10,%r10+	movq	%r8,%rax+	adcq	%r11,%r11+	movq	%r9,%rbx+	sbbq	%rdx,%rdx++	subq	0(%rcx),%r14+	sbbq	8(%rcx),%r15+	movq	%r10,%rbp+	sbbq	16(%rcx),%r8+	sbbq	24(%rcx),%r9+	sbbq	32(%rcx),%r10+	movq	%r11,%rsi+	sbbq	40(%rcx),%r11+	sbbq	$0,%rdx++	cmovcq	%r12,%r14+	cmovcq	%r13,%r15+	cmovcq	%rax,%r8+	movq	%r14,48(%rdi)+	cmovcq	%rbx,%r9+	movq	%r15,56(%rdi)+	cmovcq	%rbp,%r10+	movq	%r8,64(%rdi)+	cmovcq	%rsi,%r11+	movq	%r9,72(%rdi)+	movq	%r10,80(%rdi)+	movq	%r11,88(%rdi)++	leaq	32(%rsp),%rsi+	leaq	32+48(%rsp),%rbx++	movq	32+48(%rsp),%rax+	movq	32+0(%rsp),%r14+	movq	32+8(%rsp),%r15+	movq	32+16(%rsp),%r12+	movq	32+24(%rsp),%r13++	call	__mulq_mont_384++	leaq	136(%rsp),%r8+	movq	0(%r8),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-136-8*6++	.byte	0xf3,0xc3+.cfi_endproc	+++.globl	_mul_382x+.private_extern	_mul_382x++.p2align	5+_mul_382x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$136,%rsp+.cfi_adjust_cfa_offset	136+++	leaq	96(%rdi),%rdi+	movq	%rsi,0(%rsp)+	movq	%rdx,8(%rsp)+	movq	%rdi,16(%rsp)+	movq	%rcx,24(%rsp)+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	addq	48(%rsi),%r8+	adcq	56(%rsi),%r9+	adcq	64(%rsi),%r10+	adcq	72(%rsi),%r11+	adcq	80(%rsi),%r12+	adcq	88(%rsi),%r13++	movq	%r8,32+0(%rsp)+	movq	%r9,32+8(%rsp)+	movq	%r10,32+16(%rsp)+	movq	%r11,32+24(%rsp)+	movq	%r12,32+32(%rsp)+	movq	%r13,32+40(%rsp)+++	movq	0(%rdx),%r8+	movq	8(%rdx),%r9+	movq	16(%rdx),%r10+	movq	24(%rdx),%r11+	movq	32(%rdx),%r12+	movq	40(%rdx),%r13++	addq	48(%rdx),%r8+	adcq	56(%rdx),%r9+	adcq	64(%rdx),%r10+	adcq	72(%rdx),%r11+	adcq	80(%rdx),%r12+	adcq	88(%rdx),%r13++	movq	%r8,32+48(%rsp)+	movq	%r9,32+56(%rsp)+	movq	%r10,32+64(%rsp)+	movq	%r11,32+72(%rsp)+	movq	%r12,32+80(%rsp)+	movq	%r13,32+88(%rsp)+++	leaq	32+0(%rsp),%rsi+	leaq	32+48(%rsp),%rbx+	call	__mulq_384+++	movq	0(%rsp),%rsi+	movq	8(%rsp),%rbx+	leaq	-96(%rdi),%rdi+	call	__mulq_384+++	leaq	48(%rsi),%rsi+	leaq	48(%rbx),%rbx+	leaq	32(%rsp),%rdi+	call	__mulq_384+++	movq	16(%rsp),%rsi+	leaq	32(%rsp),%rdx+	movq	24(%rsp),%rcx+	movq	%rsi,%rdi+	call	__sub_mod_384x384+++	leaq	0(%rdi),%rsi+	leaq	-96(%rdi),%rdx+	call	__sub_mod_384x384+++	leaq	-96(%rdi),%rsi+	leaq	32(%rsp),%rdx+	leaq	-96(%rdi),%rdi+	call	__sub_mod_384x384++	leaq	136(%rsp),%r8+	movq	0(%r8),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-136-8*6++	.byte	0xf3,0xc3+.cfi_endproc	++.globl	_sqr_382x+.private_extern	_sqr_382x++.p2align	5+_sqr_382x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	pushq	%rsi+.cfi_adjust_cfa_offset	8+++	movq	%rdx,%rcx+++	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%rax+	movq	24(%rsi),%rbx+	movq	32(%rsi),%rbp+	movq	40(%rsi),%rdx++	movq	%r14,%r8+	addq	48(%rsi),%r14+	movq	%r15,%r9+	adcq	56(%rsi),%r15+	movq	%rax,%r10+	adcq	64(%rsi),%rax+	movq	%rbx,%r11+	adcq	72(%rsi),%rbx+	movq	%rbp,%r12+	adcq	80(%rsi),%rbp+	movq	%rdx,%r13+	adcq	88(%rsi),%rdx++	movq	%r14,0(%rdi)+	movq	%r15,8(%rdi)+	movq	%rax,16(%rdi)+	movq	%rbx,24(%rdi)+	movq	%rbp,32(%rdi)+	movq	%rdx,40(%rdi)+++	leaq	48(%rsi),%rdx+	leaq	48(%rdi),%rdi+	call	__sub_mod_384_a_is_loaded+++	leaq	(%rdi),%rsi+	leaq	-48(%rdi),%rbx+	leaq	-48(%rdi),%rdi+	call	__mulq_384+++	movq	(%rsp),%rsi+	leaq	48(%rsi),%rbx+	leaq	96(%rdi),%rdi+	call	__mulq_384++	movq	0(%rdi),%r8+	movq	8(%rdi),%r9+	movq	16(%rdi),%r10+	movq	24(%rdi),%r11+	movq	32(%rdi),%r12+	movq	40(%rdi),%r13+	movq	48(%rdi),%r14+	movq	56(%rdi),%r15+	movq	64(%rdi),%rax+	movq	72(%rdi),%rbx+	movq	80(%rdi),%rbp+	addq	%r8,%r8+	movq	88(%rdi),%rdx+	adcq	%r9,%r9+	movq	%r8,0(%rdi)+	adcq	%r10,%r10+	movq	%r9,8(%rdi)+	adcq	%r11,%r11+	movq	%r10,16(%rdi)+	adcq	%r12,%r12+	movq	%r11,24(%rdi)+	adcq	%r13,%r13+	movq	%r12,32(%rdi)+	adcq	%r14,%r14+	movq	%r13,40(%rdi)+	adcq	%r15,%r15+	movq	%r14,48(%rdi)+	adcq	%rax,%rax+	movq	%r15,56(%rdi)+	adcq	%rbx,%rbx+	movq	%rax,64(%rdi)+	adcq	%rbp,%rbp+	movq	%rbx,72(%rdi)+	adcq	%rdx,%rdx+	movq	%rbp,80(%rdi)+	movq	%rdx,88(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-8*7++	.byte	0xf3,0xc3+.cfi_endproc	++.globl	_mul_384+.private_extern	_mul_384++.p2align	5+_mul_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+++	movq	%rdx,%rbx+	call	__mulq_384++	movq	0(%rsp),%r12+.cfi_restore	%r12+	movq	8(%rsp),%rbx+.cfi_restore	%rbx+	movq	16(%rsp),%rbp+.cfi_restore	%rbp+	leaq	24(%rsp),%rsp+.cfi_adjust_cfa_offset	-24++	.byte	0xf3,0xc3+.cfi_endproc	++++.p2align	5+__mulq_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rbx),%rax++	movq	%rax,%rbp+	mulq	0(%rsi)+	movq	%rax,0(%rdi)+	movq	%rbp,%rax+	movq	%rdx,%rcx++	mulq	8(%rsi)+	addq	%rax,%rcx+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rsi)+	addq	%rax,%r8+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rsi)+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rsi)+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rsi)+	addq	%rax,%r11+	movq	8(%rbx),%rax+	adcq	$0,%rdx+	movq	%rdx,%r12+	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%rcx+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rcx,8(%rdi)+	movq	%rdx,%rcx++	mulq	8(%rsi)+	addq	%rax,%r8+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%rcx+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rsi)+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r8+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rsi)+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r9+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rsi)+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r10+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rsi)+	addq	%rax,%r12+	movq	16(%rbx),%rax+	adcq	$0,%rdx+	addq	%r12,%r11+	adcq	$0,%rdx+	movq	%rdx,%r12+	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%rcx+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rcx,16(%rdi)+	movq	%rdx,%rcx++	mulq	8(%rsi)+	addq	%rax,%r8+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%rcx+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rsi)+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r8+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rsi)+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r9+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rsi)+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r10+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rsi)+	addq	%rax,%r12+	movq	24(%rbx),%rax+	adcq	$0,%rdx+	addq	%r12,%r11+	adcq	$0,%rdx+	movq	%rdx,%r12+	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%rcx+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rcx,24(%rdi)+	movq	%rdx,%rcx++	mulq	8(%rsi)+	addq	%rax,%r8+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%rcx+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rsi)+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r8+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rsi)+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r9+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rsi)+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r10+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rsi)+	addq	%rax,%r12+	movq	32(%rbx),%rax+	adcq	$0,%rdx+	addq	%r12,%r11+	adcq	$0,%rdx+	movq	%rdx,%r12+	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%rcx+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rcx,32(%rdi)+	movq	%rdx,%rcx++	mulq	8(%rsi)+	addq	%rax,%r8+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%rcx+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rsi)+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r8+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rsi)+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r9+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rsi)+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r10+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rsi)+	addq	%rax,%r12+	movq	40(%rbx),%rax+	adcq	$0,%rdx+	addq	%r12,%r11+	adcq	$0,%rdx+	movq	%rdx,%r12+	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%rcx+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rcx,40(%rdi)+	movq	%rdx,%rcx++	mulq	8(%rsi)+	addq	%rax,%r8+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%rcx+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rsi)+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r8+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rsi)+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r9+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rsi)+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r10+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rsi)+	addq	%rax,%r12+	movq	%rax,%rax+	adcq	$0,%rdx+	addq	%r12,%r11+	adcq	$0,%rdx+	movq	%rdx,%r12+	movq	%rcx,48(%rdi)+	movq	%r8,56(%rdi)+	movq	%r9,64(%rdi)+	movq	%r10,72(%rdi)+	movq	%r11,80(%rdi)+	movq	%r12,88(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc++.globl	_sqr_384+.private_extern	_sqr_384++.p2align	5+_sqr_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	call	__sqrq_384++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	++++.p2align	5+__sqrq_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%rax+	movq	8(%rsi),%r15+	movq	16(%rsi),%rcx+	movq	24(%rsi),%rbx+++	movq	%rax,%r14+	mulq	%r15+	movq	%rax,%r9+	movq	%r14,%rax+	movq	32(%rsi),%rbp+	movq	%rdx,%r10++	mulq	%rcx+	addq	%rax,%r10+	movq	%r14,%rax+	adcq	$0,%rdx+	movq	40(%rsi),%rsi+	movq	%rdx,%r11++	mulq	%rbx+	addq	%rax,%r11+	movq	%r14,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	%rbp+	addq	%rax,%r12+	movq	%r14,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13++	mulq	%rsi+	addq	%rax,%r13+	movq	%r14,%rax+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	%rax+	xorq	%r8,%r8+	movq	%rax,0(%rdi)+	movq	%r15,%rax+	addq	%r9,%r9+	adcq	$0,%r8+	addq	%rdx,%r9+	adcq	$0,%r8+	movq	%r9,8(%rdi)++	mulq	%rcx+	addq	%rax,%r11+	movq	%r15,%rax+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	%rbx+	addq	%rax,%r12+	movq	%r15,%rax+	adcq	$0,%rdx+	addq	%r9,%r12+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	%rbp+	addq	%rax,%r13+	movq	%r15,%rax+	adcq	$0,%rdx+	addq	%r9,%r13+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	%rsi+	addq	%rax,%r14+	movq	%r15,%rax+	adcq	$0,%rdx+	addq	%r9,%r14+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	%rax+	xorq	%r9,%r9+	addq	%rax,%r8+	movq	%rcx,%rax+	addq	%r10,%r10+	adcq	%r11,%r11+	adcq	$0,%r9+	addq	%r8,%r10+	adcq	%rdx,%r11+	adcq	$0,%r9+	movq	%r10,16(%rdi)++	mulq	%rbx+	addq	%rax,%r13+	movq	%rcx,%rax+	adcq	$0,%rdx+	movq	%r11,24(%rdi)+	movq	%rdx,%r8++	mulq	%rbp+	addq	%rax,%r14+	movq	%rcx,%rax+	adcq	$0,%rdx+	addq	%r8,%r14+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	%rsi+	addq	%rax,%r15+	movq	%rcx,%rax+	adcq	$0,%rdx+	addq	%r8,%r15+	adcq	$0,%rdx+	movq	%rdx,%rcx++	mulq	%rax+	xorq	%r11,%r11+	addq	%rax,%r9+	movq	%rbx,%rax+	addq	%r12,%r12+	adcq	%r13,%r13+	adcq	$0,%r11+	addq	%r9,%r12+	adcq	%rdx,%r13+	adcq	$0,%r11+	movq	%r12,32(%rdi)+++	mulq	%rbp+	addq	%rax,%r15+	movq	%rbx,%rax+	adcq	$0,%rdx+	movq	%r13,40(%rdi)+	movq	%rdx,%r8++	mulq	%rsi+	addq	%rax,%rcx+	movq	%rbx,%rax+	adcq	$0,%rdx+	addq	%r8,%rcx+	adcq	$0,%rdx+	movq	%rdx,%rbx++	mulq	%rax+	xorq	%r12,%r12+	addq	%rax,%r11+	movq	%rbp,%rax+	addq	%r14,%r14+	adcq	%r15,%r15+	adcq	$0,%r12+	addq	%r11,%r14+	adcq	%rdx,%r15+	movq	%r14,48(%rdi)+	adcq	$0,%r12+	movq	%r15,56(%rdi)+++	mulq	%rsi+	addq	%rax,%rbx+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	%rax+	xorq	%r13,%r13+	addq	%rax,%r12+	movq	%rsi,%rax+	addq	%rcx,%rcx+	adcq	%rbx,%rbx+	adcq	$0,%r13+	addq	%r12,%rcx+	adcq	%rdx,%rbx+	movq	%rcx,64(%rdi)+	adcq	$0,%r13+	movq	%rbx,72(%rdi)+++	mulq	%rax+	addq	%r13,%rax+	addq	%rbp,%rbp+	adcq	$0,%rdx+	addq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rax,80(%rdi)+	movq	%rdx,88(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+++.globl	_sqr_mont_384+.private_extern	_sqr_mont_384++.p2align	5+_sqr_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$120,%rsp+.cfi_adjust_cfa_offset	8*15+++	movq	%rcx,96(%rsp)+	movq	%rdx,104(%rsp)+	movq	%rdi,112(%rsp)++	movq	%rsp,%rdi+	call	__sqrq_384++	leaq	0(%rsp),%rsi+	movq	96(%rsp),%rcx+	movq	104(%rsp),%rbx+	movq	112(%rsp),%rdi+	call	__mulq_by_1_mont_384+	call	__redc_tail_mont_384++	leaq	120(%rsp),%r8+	movq	120(%rsp),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-8*21++	.byte	0xf3,0xc3+.cfi_endproc	+++++.globl	_redc_mont_384+.private_extern	_redc_mont_384++.p2align	5+_redc_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rdx,%rbx+	call	__mulq_by_1_mont_384+	call	__redc_tail_mont_384++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	++++++.globl	_from_mont_384+.private_extern	_from_mont_384++.p2align	5+_from_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rdx,%rbx+	call	__mulq_by_1_mont_384++++++	movq	%r15,%rcx+	movq	%r8,%rdx+	movq	%r9,%rbp++	subq	0(%rbx),%r14+	sbbq	8(%rbx),%r15+	movq	%r10,%r13+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	movq	%r11,%rsi+	sbbq	40(%rbx),%r11++	cmovcq	%rax,%r14+	cmovcq	%rcx,%r15+	cmovcq	%rdx,%r8+	movq	%r14,0(%rdi)+	cmovcq	%rbp,%r9+	movq	%r15,8(%rdi)+	cmovcq	%r13,%r10+	movq	%r8,16(%rdi)+	cmovcq	%rsi,%r11+	movq	%r9,24(%rdi)+	movq	%r10,32(%rdi)+	movq	%r11,40(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+++.p2align	5+__mulq_by_1_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%rax+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%rax,%r14+	imulq	%rcx,%rax+	movq	%rax,%r8++	mulq	0(%rbx)+	addq	%rax,%r14+	movq	%r8,%rax+	adcq	%rdx,%r14++	mulq	8(%rbx)+	addq	%rax,%r9+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%r14,%r9+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	16(%rbx)+	addq	%rax,%r10+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%r14,%r10+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	24(%rbx)+	addq	%rax,%r11+	movq	%r8,%rax+	adcq	$0,%rdx+	movq	%r9,%r15+	imulq	%rcx,%r9+	addq	%r14,%r11+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	32(%rbx)+	addq	%rax,%r12+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%r14,%r12+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	40(%rbx)+	addq	%rax,%r13+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r14,%r13+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	0(%rbx)+	addq	%rax,%r15+	movq	%r9,%rax+	adcq	%rdx,%r15++	mulq	8(%rbx)+	addq	%rax,%r10+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r15,%r10+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	16(%rbx)+	addq	%rax,%r11+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r15,%r11+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	24(%rbx)+	addq	%rax,%r12+	movq	%r9,%rax+	adcq	$0,%rdx+	movq	%r10,%r8+	imulq	%rcx,%r10+	addq	%r15,%r12+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	32(%rbx)+	addq	%rax,%r13+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r15,%r13+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	40(%rbx)+	addq	%rax,%r14+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r15,%r14+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	0(%rbx)+	addq	%rax,%r8+	movq	%r10,%rax+	adcq	%rdx,%r8++	mulq	8(%rbx)+	addq	%rax,%r11+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r8,%r11+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rbx)+	addq	%rax,%r12+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r8,%r12+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	24(%rbx)+	addq	%rax,%r13+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%r11,%r9+	imulq	%rcx,%r11+	addq	%r8,%r13+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	32(%rbx)+	addq	%rax,%r14+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r8,%r14+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	40(%rbx)+	addq	%rax,%r15+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r8,%r15+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	0(%rbx)+	addq	%rax,%r9+	movq	%r11,%rax+	adcq	%rdx,%r9++	mulq	8(%rbx)+	addq	%rax,%r12+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r9,%r12+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	16(%rbx)+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r9,%r13+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rbx)+	addq	%rax,%r14+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%r12,%r10+	imulq	%rcx,%r12+	addq	%r9,%r14+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	32(%rbx)+	addq	%rax,%r15+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r9,%r15+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	40(%rbx)+	addq	%rax,%r8+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r9,%r8+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	0(%rbx)+	addq	%rax,%r10+	movq	%r12,%rax+	adcq	%rdx,%r10++	mulq	8(%rbx)+	addq	%rax,%r13+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r10,%r13+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	16(%rbx)+	addq	%rax,%r14+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r10,%r14+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	24(%rbx)+	addq	%rax,%r15+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%r13,%r11+	imulq	%rcx,%r13+	addq	%r10,%r15+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rbx)+	addq	%rax,%r8+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r10,%r8+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	40(%rbx)+	addq	%rax,%r9+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r10,%r9+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	0(%rbx)+	addq	%rax,%r11+	movq	%r13,%rax+	adcq	%rdx,%r11++	mulq	8(%rbx)+	addq	%rax,%r14+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r11,%r14+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	16(%rbx)+	addq	%rax,%r15+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r11,%r15+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	24(%rbx)+	addq	%rax,%r8+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r11,%r8+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	32(%rbx)+	addq	%rax,%r9+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r11,%r9+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rbx)+	addq	%rax,%r10+	movq	%r14,%rax+	adcq	$0,%rdx+	addq	%r11,%r10+	adcq	$0,%rdx+	movq	%rdx,%r11+	.byte	0xf3,0xc3+.cfi_endproc++++.p2align	5+__redc_tail_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	addq	48(%rsi),%r14+	movq	%r14,%rax+	adcq	56(%rsi),%r15+	adcq	64(%rsi),%r8+	adcq	72(%rsi),%r9+	movq	%r15,%rcx+	adcq	80(%rsi),%r10+	adcq	88(%rsi),%r11+	sbbq	%r12,%r12+++++	movq	%r8,%rdx+	movq	%r9,%rbp++	subq	0(%rbx),%r14+	sbbq	8(%rbx),%r15+	movq	%r10,%r13+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	movq	%r11,%rsi+	sbbq	40(%rbx),%r11+	sbbq	$0,%r12++	cmovcq	%rax,%r14+	cmovcq	%rcx,%r15+	cmovcq	%rdx,%r8+	movq	%r14,0(%rdi)+	cmovcq	%rbp,%r9+	movq	%r15,8(%rdi)+	cmovcq	%r13,%r10+	movq	%r8,16(%rdi)+	cmovcq	%rsi,%r11+	movq	%r9,24(%rdi)+	movq	%r10,32(%rdi)+	movq	%r11,40(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+++.globl	_sgn0_pty_mont_384+.private_extern	_sgn0_pty_mont_384++.p2align	5+_sgn0_pty_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rsi,%rbx+	leaq	0(%rdi),%rsi+	movq	%rdx,%rcx+	call	__mulq_by_1_mont_384++	xorq	%rax,%rax+	movq	%r14,%r13+	addq	%r14,%r14+	adcq	%r15,%r15+	adcq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	$0,%rax++	subq	0(%rbx),%r14+	sbbq	8(%rbx),%r15+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	sbbq	40(%rbx),%r11+	sbbq	$0,%rax++	notq	%rax+	andq	$1,%r13+	andq	$2,%rax+	orq	%r13,%rax++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+++.globl	_sgn0_pty_mont_384x+.private_extern	_sgn0_pty_mont_384x++.p2align	5+_sgn0_pty_mont_384x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rsi,%rbx+	leaq	48(%rdi),%rsi+	movq	%rdx,%rcx+	call	__mulq_by_1_mont_384++	movq	%r14,%r12+	orq	%r15,%r14+	orq	%r8,%r14+	orq	%r9,%r14+	orq	%r10,%r14+	orq	%r11,%r14++	leaq	0(%rdi),%rsi+	xorq	%rdi,%rdi+	movq	%r12,%r13+	addq	%r12,%r12+	adcq	%r15,%r15+	adcq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	$0,%rdi++	subq	0(%rbx),%r12+	sbbq	8(%rbx),%r15+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	sbbq	40(%rbx),%r11+	sbbq	$0,%rdi++	movq	%r14,0(%rsp)+	notq	%rdi+	andq	$1,%r13+	andq	$2,%rdi+	orq	%r13,%rdi++	call	__mulq_by_1_mont_384++	movq	%r14,%r12+	orq	%r15,%r14+	orq	%r8,%r14+	orq	%r9,%r14+	orq	%r10,%r14+	orq	%r11,%r14++	xorq	%rax,%rax+	movq	%r12,%r13+	addq	%r12,%r12+	adcq	%r15,%r15+	adcq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	$0,%rax++	subq	0(%rbx),%r12+	sbbq	8(%rbx),%r15+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	sbbq	40(%rbx),%r11+	sbbq	$0,%rax++	movq	0(%rsp),%r12++	notq	%rax++	testq	%r14,%r14+	cmovzq	%rdi,%r13++	testq	%r12,%r12+	cmovnzq	%rdi,%rax++	andq	$1,%r13+	andq	$2,%rax+	orq	%r13,%rax++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	++.globl	_mul_mont_384+.private_extern	_mul_mont_384++.p2align	5+_mul_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$24,%rsp+.cfi_adjust_cfa_offset	8*3+++	movq	0(%rdx),%rax+	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%r12+	movq	24(%rsi),%r13+	movq	%rdx,%rbx+	movq	%r8,0(%rsp)+	movq	%rdi,8(%rsp)++	call	__mulq_mont_384++	movq	24(%rsp),%r15+.cfi_restore	%r15+	movq	32(%rsp),%r14+.cfi_restore	%r14+	movq	40(%rsp),%r13+.cfi_restore	%r13+	movq	48(%rsp),%r12+.cfi_restore	%r12+	movq	56(%rsp),%rbx+.cfi_restore	%rbx+	movq	64(%rsp),%rbp+.cfi_restore	%rbp+	leaq	72(%rsp),%rsp+.cfi_adjust_cfa_offset	-72++	.byte	0xf3,0xc3+.cfi_endproc	+++.p2align	5+__mulq_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	%rax,%rdi+	mulq	%r14+	movq	%rax,%r8+	movq	%rdi,%rax+	movq	%rdx,%r9++	mulq	%r15+	addq	%rax,%r9+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	%r12+	addq	%rax,%r10+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11++	movq	%r8,%rbp+	imulq	8(%rsp),%r8++	mulq	%r13+	addq	%rax,%r11+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	32(%rsi)+	addq	%rax,%r12+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13++	mulq	40(%rsi)+	addq	%rax,%r13+	movq	%r8,%rax+	adcq	$0,%rdx+	xorq	%r15,%r15+	movq	%rdx,%r14++	mulq	0(%rcx)+	addq	%rax,%rbp+	movq	%r8,%rax+	adcq	%rdx,%rbp++	mulq	8(%rcx)+	addq	%rax,%r9+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%rbp,%r9+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r10+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%rbp,%r10+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rbp,%r11+	adcq	$0,%rdx+	addq	%rax,%r11+	movq	%r8,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	32(%rcx)+	addq	%rax,%r12+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%rbp,%r12+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	40(%rcx)+	addq	%rax,%r13+	movq	8(%rbx),%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	%rdx,%r14+	adcq	$0,%r15++	movq	%rax,%rdi+	mulq	0(%rsi)+	addq	%rax,%r9+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	8(%rsi)+	addq	%rax,%r10+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r8,%r10+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rsi)+	addq	%rax,%r11+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r8,%r11+	adcq	$0,%rdx+	movq	%rdx,%r8++	movq	%r9,%rbp+	imulq	8(%rsp),%r9++	mulq	24(%rsi)+	addq	%rax,%r12+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r8,%r12+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	32(%rsi)+	addq	%rax,%r13+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r8,%r13+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	40(%rsi)+	addq	%r8,%r14+	adcq	$0,%rdx+	xorq	%r8,%r8+	addq	%rax,%r14+	movq	%r9,%rax+	adcq	%rdx,%r15+	adcq	$0,%r8++	mulq	0(%rcx)+	addq	%rax,%rbp+	movq	%r9,%rax+	adcq	%rdx,%rbp++	mulq	8(%rcx)+	addq	%rax,%r10+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%rbp,%r10+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r11+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%rbp,%r11+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rbp,%r12+	adcq	$0,%rdx+	addq	%rax,%r12+	movq	%r9,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	32(%rcx)+	addq	%rax,%r13+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	40(%rcx)+	addq	%rax,%r14+	movq	16(%rbx),%rax+	adcq	$0,%rdx+	addq	%rbp,%r14+	adcq	%rdx,%r15+	adcq	$0,%r8++	movq	%rax,%rdi+	mulq	0(%rsi)+	addq	%rax,%r10+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	8(%rsi)+	addq	%rax,%r11+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r9,%r11+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	16(%rsi)+	addq	%rax,%r12+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r9,%r12+	adcq	$0,%rdx+	movq	%rdx,%r9++	movq	%r10,%rbp+	imulq	8(%rsp),%r10++	mulq	24(%rsi)+	addq	%rax,%r13+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r9,%r13+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	32(%rsi)+	addq	%rax,%r14+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r9,%r14+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	40(%rsi)+	addq	%r9,%r15+	adcq	$0,%rdx+	xorq	%r9,%r9+	addq	%rax,%r15+	movq	%r10,%rax+	adcq	%rdx,%r8+	adcq	$0,%r9++	mulq	0(%rcx)+	addq	%rax,%rbp+	movq	%r10,%rax+	adcq	%rdx,%rbp++	mulq	8(%rcx)+	addq	%rax,%r11+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%rbp,%r11+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r12+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%rbp,%r12+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rbp,%r13+	adcq	$0,%rdx+	addq	%rax,%r13+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	32(%rcx)+	addq	%rax,%r14+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%rbp,%r14+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	40(%rcx)+	addq	%rax,%r15+	movq	24(%rbx),%rax+	adcq	$0,%rdx+	addq	%rbp,%r15+	adcq	%rdx,%r8+	adcq	$0,%r9++	movq	%rax,%rdi+	mulq	0(%rsi)+	addq	%rax,%r11+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	8(%rsi)+	addq	%rax,%r12+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r10,%r12+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	16(%rsi)+	addq	%rax,%r13+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r10,%r13+	adcq	$0,%rdx+	movq	%rdx,%r10++	movq	%r11,%rbp+	imulq	8(%rsp),%r11++	mulq	24(%rsi)+	addq	%rax,%r14+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r10,%r14+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rsi)+	addq	%rax,%r15+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r10,%r15+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	40(%rsi)+	addq	%r10,%r8+	adcq	$0,%rdx+	xorq	%r10,%r10+	addq	%rax,%r8+	movq	%r11,%rax+	adcq	%rdx,%r9+	adcq	$0,%r10++	mulq	0(%rcx)+	addq	%rax,%rbp+	movq	%r11,%rax+	adcq	%rdx,%rbp++	mulq	8(%rcx)+	addq	%rax,%r12+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%rbp,%r12+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rbp,%r14+	adcq	$0,%rdx+	addq	%rax,%r14+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	32(%rcx)+	addq	%rax,%r15+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%rbp,%r15+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	40(%rcx)+	addq	%rax,%r8+	movq	32(%rbx),%rax+	adcq	$0,%rdx+	addq	%rbp,%r8+	adcq	%rdx,%r9+	adcq	$0,%r10++	movq	%rax,%rdi+	mulq	0(%rsi)+	addq	%rax,%r12+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	8(%rsi)+	addq	%rax,%r13+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r11,%r13+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	16(%rsi)+	addq	%rax,%r14+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r11,%r14+	adcq	$0,%rdx+	movq	%rdx,%r11++	movq	%r12,%rbp+	imulq	8(%rsp),%r12++	mulq	24(%rsi)+	addq	%rax,%r15+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r11,%r15+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	32(%rsi)+	addq	%rax,%r8+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r11,%r8+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rsi)+	addq	%r11,%r9+	adcq	$0,%rdx+	xorq	%r11,%r11+	addq	%rax,%r9+	movq	%r12,%rax+	adcq	%rdx,%r10+	adcq	$0,%r11++	mulq	0(%rcx)+	addq	%rax,%rbp+	movq	%r12,%rax+	adcq	%rdx,%rbp++	mulq	8(%rcx)+	addq	%rax,%r13+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%rbp,%r13+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r14+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%rbp,%r14+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rbp,%r15+	adcq	$0,%rdx+	addq	%rax,%r15+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	32(%rcx)+	addq	%rax,%r8+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%rbp,%r8+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	40(%rcx)+	addq	%rax,%r9+	movq	40(%rbx),%rax+	adcq	$0,%rdx+	addq	%rbp,%r9+	adcq	%rdx,%r10+	adcq	$0,%r11++	movq	%rax,%rdi+	mulq	0(%rsi)+	addq	%rax,%r13+	movq	%rdi,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	8(%rsi)+	addq	%rax,%r14+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r12,%r14+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	16(%rsi)+	addq	%rax,%r15+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r12,%r15+	adcq	$0,%rdx+	movq	%rdx,%r12++	movq	%r13,%rbp+	imulq	8(%rsp),%r13++	mulq	24(%rsi)+	addq	%rax,%r8+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r12,%r8+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	32(%rsi)+	addq	%rax,%r9+	movq	%rdi,%rax+	adcq	$0,%rdx+	addq	%r12,%r9+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	40(%rsi)+	addq	%r12,%r10+	adcq	$0,%rdx+	xorq	%r12,%r12+	addq	%rax,%r10+	movq	%r13,%rax+	adcq	%rdx,%r11+	adcq	$0,%r12++	mulq	0(%rcx)+	addq	%rax,%rbp+	movq	%r13,%rax+	adcq	%rdx,%rbp++	mulq	8(%rcx)+	addq	%rax,%r14+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%rbp,%r14+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	16(%rcx)+	addq	%rax,%r15+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%rbp,%r15+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	24(%rcx)+	addq	%rbp,%r8+	adcq	$0,%rdx+	addq	%rax,%r8+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	32(%rcx)+	addq	%rax,%r9+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%rbp,%r9+	adcq	$0,%rdx+	movq	%rdx,%rbp++	mulq	40(%rcx)+	addq	%rax,%r10+	movq	%r14,%rax+	adcq	$0,%rdx+	addq	%rbp,%r10+	adcq	%rdx,%r11+	adcq	$0,%r12+++++	movq	16(%rsp),%rdi+	subq	0(%rcx),%r14+	movq	%r15,%rdx+	sbbq	8(%rcx),%r15+	movq	%r8,%rbx+	sbbq	16(%rcx),%r8+	movq	%r9,%rsi+	sbbq	24(%rcx),%r9+	movq	%r10,%rbp+	sbbq	32(%rcx),%r10+	movq	%r11,%r13+	sbbq	40(%rcx),%r11+	sbbq	$0,%r12++	cmovcq	%rax,%r14+	cmovcq	%rdx,%r15+	cmovcq	%rbx,%r8+	movq	%r14,0(%rdi)+	cmovcq	%rsi,%r9+	movq	%r15,8(%rdi)+	cmovcq	%rbp,%r10+	movq	%r8,16(%rdi)+	cmovcq	%r13,%r11+	movq	%r9,24(%rdi)+	movq	%r10,32(%rdi)+	movq	%r11,40(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc++.globl	_sqr_n_mul_mont_384+.private_extern	_sqr_n_mul_mont_384++.p2align	5+_sqr_n_mul_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$136,%rsp+.cfi_adjust_cfa_offset	8*17+++	movq	%r8,0(%rsp)+	movq	%rdi,8(%rsp)+	movq	%rcx,16(%rsp)+	leaq	32(%rsp),%rdi+	movq	%r9,24(%rsp)+	movq	(%r9),%xmm2++L$oop_sqr_384:+	movd	%edx,%xmm1++	call	__sqrq_384++	leaq	0(%rdi),%rsi+	movq	0(%rsp),%rcx+	movq	16(%rsp),%rbx+	call	__mulq_by_1_mont_384+	call	__redc_tail_mont_384++	movd	%xmm1,%edx+	leaq	0(%rdi),%rsi+	decl	%edx+	jnz	L$oop_sqr_384++.byte	102,72,15,126,208+	movq	%rbx,%rcx+	movq	24(%rsp),%rbx+++++++	movq	%r8,%r12+	movq	%r9,%r13++	call	__mulq_mont_384++	leaq	136(%rsp),%r8+	movq	136(%rsp),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-8*23++	.byte	0xf3,0xc3+.cfi_endproc	+++.globl	_sqr_n_mul_mont_383+.private_extern	_sqr_n_mul_mont_383++.p2align	5+_sqr_n_mul_mont_383:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$136,%rsp+.cfi_adjust_cfa_offset	8*17+++	movq	%r8,0(%rsp)+	movq	%rdi,8(%rsp)+	movq	%rcx,16(%rsp)+	leaq	32(%rsp),%rdi+	movq	%r9,24(%rsp)+	movq	(%r9),%xmm2++L$oop_sqr_383:+	movd	%edx,%xmm1++	call	__sqrq_384++	leaq	0(%rdi),%rsi+	movq	0(%rsp),%rcx+	movq	16(%rsp),%rbx+	call	__mulq_by_1_mont_384++	movd	%xmm1,%edx+	addq	48(%rsi),%r14+	adcq	56(%rsi),%r15+	adcq	64(%rsi),%r8+	adcq	72(%rsi),%r9+	adcq	80(%rsi),%r10+	adcq	88(%rsi),%r11+	leaq	0(%rdi),%rsi++	movq	%r14,0(%rdi)+	movq	%r15,8(%rdi)+	movq	%r8,16(%rdi)+	movq	%r9,24(%rdi)+	movq	%r10,32(%rdi)+	movq	%r11,40(%rdi)++	decl	%edx+	jnz	L$oop_sqr_383++.byte	102,72,15,126,208+	movq	%rbx,%rcx+	movq	24(%rsp),%rbx+++++++	movq	%r8,%r12+	movq	%r9,%r13++	call	__mulq_mont_384++	leaq	136(%rsp),%r8+	movq	136(%rsp),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-8*23++	.byte	0xf3,0xc3+.cfi_endproc	+++.p2align	5+__mulq_mont_383_nonred:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	%rax,%rbp+	mulq	%r14+	movq	%rax,%r8+	movq	%rbp,%rax+	movq	%rdx,%r9++	mulq	%r15+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	%r12+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11++	movq	%r8,%r15+	imulq	8(%rsp),%r8++	mulq	%r13+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	32(%rsi)+	addq	%rax,%r12+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r13++	mulq	40(%rsi)+	addq	%rax,%r13+	movq	%r8,%rax+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	0(%rcx)+	addq	%rax,%r15+	movq	%r8,%rax+	adcq	%rdx,%r15++	mulq	8(%rcx)+	addq	%rax,%r9+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%r15,%r9+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	16(%rcx)+	addq	%rax,%r10+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%r15,%r10+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	24(%rcx)+	addq	%r15,%r11+	adcq	$0,%rdx+	addq	%rax,%r11+	movq	%r8,%rax+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	32(%rcx)+	addq	%rax,%r12+	movq	%r8,%rax+	adcq	$0,%rdx+	addq	%r15,%r12+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	40(%rcx)+	addq	%rax,%r13+	movq	8(%rbx),%rax+	adcq	$0,%rdx+	addq	%r15,%r13+	adcq	%rdx,%r14++	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	8(%rsi)+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r15,%r10+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	16(%rsi)+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r15,%r11+	adcq	$0,%rdx+	movq	%rdx,%r15++	movq	%r9,%r8+	imulq	8(%rsp),%r9++	mulq	24(%rsi)+	addq	%rax,%r12+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r15,%r12+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	32(%rsi)+	addq	%rax,%r13+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r15,%r13+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	40(%rsi)+	addq	%r15,%r14+	adcq	$0,%rdx+	addq	%rax,%r14+	movq	%r9,%rax+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	0(%rcx)+	addq	%rax,%r8+	movq	%r9,%rax+	adcq	%rdx,%r8++	mulq	8(%rcx)+	addq	%rax,%r10+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r8,%r10+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rcx)+	addq	%rax,%r11+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r8,%r11+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	24(%rcx)+	addq	%r8,%r12+	adcq	$0,%rdx+	addq	%rax,%r12+	movq	%r9,%rax+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	32(%rcx)+	addq	%rax,%r13+	movq	%r9,%rax+	adcq	$0,%rdx+	addq	%r8,%r13+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	40(%rcx)+	addq	%rax,%r14+	movq	16(%rbx),%rax+	adcq	$0,%rdx+	addq	%r8,%r14+	adcq	%rdx,%r15++	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%r10+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	8(%rsi)+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%r11+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	16(%rsi)+	addq	%rax,%r12+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%r12+	adcq	$0,%rdx+	movq	%rdx,%r8++	movq	%r10,%r9+	imulq	8(%rsp),%r10++	mulq	24(%rsi)+	addq	%rax,%r13+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%r13+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	32(%rsi)+	addq	%rax,%r14+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r8,%r14+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	40(%rsi)+	addq	%r8,%r15+	adcq	$0,%rdx+	addq	%rax,%r15+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r8++	mulq	0(%rcx)+	addq	%rax,%r9+	movq	%r10,%rax+	adcq	%rdx,%r9++	mulq	8(%rcx)+	addq	%rax,%r11+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r9,%r11+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	16(%rcx)+	addq	%rax,%r12+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r9,%r12+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	24(%rcx)+	addq	%r9,%r13+	adcq	$0,%rdx+	addq	%rax,%r13+	movq	%r10,%rax+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	32(%rcx)+	addq	%rax,%r14+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r9,%r14+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	40(%rcx)+	addq	%rax,%r15+	movq	24(%rbx),%rax+	adcq	$0,%rdx+	addq	%r9,%r15+	adcq	%rdx,%r8++	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%r11+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	8(%rsi)+	addq	%rax,%r12+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r12+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	16(%rsi)+	addq	%rax,%r13+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r13+	adcq	$0,%rdx+	movq	%rdx,%r9++	movq	%r11,%r10+	imulq	8(%rsp),%r11++	mulq	24(%rsi)+	addq	%rax,%r14+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r14+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	32(%rsi)+	addq	%rax,%r15+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r9,%r15+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	40(%rsi)+	addq	%r9,%r8+	adcq	$0,%rdx+	addq	%rax,%r8+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r9++	mulq	0(%rcx)+	addq	%rax,%r10+	movq	%r11,%rax+	adcq	%rdx,%r10++	mulq	8(%rcx)+	addq	%rax,%r12+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r10,%r12+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	16(%rcx)+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r10,%r13+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	24(%rcx)+	addq	%r10,%r14+	adcq	$0,%rdx+	addq	%rax,%r14+	movq	%r11,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rcx)+	addq	%rax,%r15+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r10,%r15+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	40(%rcx)+	addq	%rax,%r8+	movq	32(%rbx),%rax+	adcq	$0,%rdx+	addq	%r10,%r8+	adcq	%rdx,%r9++	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%r12+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	8(%rsi)+	addq	%rax,%r13+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r13+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	16(%rsi)+	addq	%rax,%r14+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r14+	adcq	$0,%rdx+	movq	%rdx,%r10++	movq	%r12,%r11+	imulq	8(%rsp),%r12++	mulq	24(%rsi)+	addq	%rax,%r15+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r15+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	32(%rsi)+	addq	%rax,%r8+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r10,%r8+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	40(%rsi)+	addq	%r10,%r9+	adcq	$0,%rdx+	addq	%rax,%r9+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	0(%rcx)+	addq	%rax,%r11+	movq	%r12,%rax+	adcq	%rdx,%r11++	mulq	8(%rcx)+	addq	%rax,%r13+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r11,%r13+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	16(%rcx)+	addq	%rax,%r14+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r11,%r14+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	24(%rcx)+	addq	%r11,%r15+	adcq	$0,%rdx+	addq	%rax,%r15+	movq	%r12,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	32(%rcx)+	addq	%rax,%r8+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r11,%r8+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rcx)+	addq	%rax,%r9+	movq	40(%rbx),%rax+	adcq	$0,%rdx+	addq	%r11,%r9+	adcq	%rdx,%r10++	movq	%rax,%rbp+	mulq	0(%rsi)+	addq	%rax,%r13+	movq	%rbp,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	8(%rsi)+	addq	%rax,%r14+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r14+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	16(%rsi)+	addq	%rax,%r15+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r15+	adcq	$0,%rdx+	movq	%rdx,%r11++	movq	%r13,%r12+	imulq	8(%rsp),%r13++	mulq	24(%rsi)+	addq	%rax,%r8+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r8+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	32(%rsi)+	addq	%rax,%r9+	movq	%rbp,%rax+	adcq	$0,%rdx+	addq	%r11,%r9+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	40(%rsi)+	addq	%r11,%r10+	adcq	$0,%rdx+	addq	%rax,%r10+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	0(%rcx)+	addq	%rax,%r12+	movq	%r13,%rax+	adcq	%rdx,%r12++	mulq	8(%rcx)+	addq	%rax,%r14+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r12,%r14+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	16(%rcx)+	addq	%rax,%r15+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r12,%r15+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	24(%rcx)+	addq	%r12,%r8+	adcq	$0,%rdx+	addq	%rax,%r8+	movq	%r13,%rax+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	32(%rcx)+	addq	%rax,%r9+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r12,%r9+	adcq	$0,%rdx+	movq	%rdx,%r12++	mulq	40(%rcx)+	addq	%rax,%r10+	movq	%r14,%rax+	adcq	$0,%rdx+	addq	%r12,%r10+	adcq	%rdx,%r11+	.byte	0xf3,0xc3+.cfi_endproc++.globl	_sqr_mont_382x+.private_extern	_sqr_mont_382x++.p2align	5+_sqr_mont_382x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$136,%rsp+.cfi_adjust_cfa_offset	136+++	movq	%rcx,0(%rsp)+	movq	%rdx,%rcx+	movq	%rsi,16(%rsp)+	movq	%rdi,24(%rsp)+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%r8,%r14+	addq	48(%rsi),%r8+	movq	%r9,%r15+	adcq	56(%rsi),%r9+	movq	%r10,%rax+	adcq	64(%rsi),%r10+	movq	%r11,%rdx+	adcq	72(%rsi),%r11+	movq	%r12,%rbx+	adcq	80(%rsi),%r12+	movq	%r13,%rbp+	adcq	88(%rsi),%r13++	subq	48(%rsi),%r14+	sbbq	56(%rsi),%r15+	sbbq	64(%rsi),%rax+	sbbq	72(%rsi),%rdx+	sbbq	80(%rsi),%rbx+	sbbq	88(%rsi),%rbp+	sbbq	%rdi,%rdi++	movq	%r8,32+0(%rsp)+	movq	%r9,32+8(%rsp)+	movq	%r10,32+16(%rsp)+	movq	%r11,32+24(%rsp)+	movq	%r12,32+32(%rsp)+	movq	%r13,32+40(%rsp)++	movq	%r14,32+48(%rsp)+	movq	%r15,32+56(%rsp)+	movq	%rax,32+64(%rsp)+	movq	%rdx,32+72(%rsp)+	movq	%rbx,32+80(%rsp)+	movq	%rbp,32+88(%rsp)+	movq	%rdi,32+96(%rsp)++++	leaq	48(%rsi),%rbx++	movq	48(%rsi),%rax+	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%r12+	movq	24(%rsi),%r13++	movq	24(%rsp),%rdi+	call	__mulq_mont_383_nonred+	addq	%r14,%r14+	adcq	%r15,%r15+	adcq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11++	movq	%r14,48(%rdi)+	movq	%r15,56(%rdi)+	movq	%r8,64(%rdi)+	movq	%r9,72(%rdi)+	movq	%r10,80(%rdi)+	movq	%r11,88(%rdi)++	leaq	32(%rsp),%rsi+	leaq	32+48(%rsp),%rbx++	movq	32+48(%rsp),%rax+	movq	32+0(%rsp),%r14+	movq	32+8(%rsp),%r15+	movq	32+16(%rsp),%r12+	movq	32+24(%rsp),%r13++	call	__mulq_mont_383_nonred+	movq	32+96(%rsp),%rsi+	movq	32+0(%rsp),%r12+	movq	32+8(%rsp),%r13+	andq	%rsi,%r12+	movq	32+16(%rsp),%rax+	andq	%rsi,%r13+	movq	32+24(%rsp),%rbx+	andq	%rsi,%rax+	movq	32+32(%rsp),%rbp+	andq	%rsi,%rbx+	andq	%rsi,%rbp+	andq	32+40(%rsp),%rsi++	subq	%r12,%r14+	movq	0(%rcx),%r12+	sbbq	%r13,%r15+	movq	8(%rcx),%r13+	sbbq	%rax,%r8+	movq	16(%rcx),%rax+	sbbq	%rbx,%r9+	movq	24(%rcx),%rbx+	sbbq	%rbp,%r10+	movq	32(%rcx),%rbp+	sbbq	%rsi,%r11+	sbbq	%rsi,%rsi++	andq	%rsi,%r12+	andq	%rsi,%r13+	andq	%rsi,%rax+	andq	%rsi,%rbx+	andq	%rsi,%rbp+	andq	40(%rcx),%rsi++	addq	%r12,%r14+	adcq	%r13,%r15+	adcq	%rax,%r8+	adcq	%rbx,%r9+	adcq	%rbp,%r10+	adcq	%rsi,%r11++	movq	%r14,0(%rdi)+	movq	%r15,8(%rdi)+	movq	%r8,16(%rdi)+	movq	%r9,24(%rdi)+	movq	%r10,32(%rdi)+	movq	%r11,40(%rdi)+	leaq	136(%rsp),%r8+	movq	0(%r8),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-136-8*6++	.byte	0xf3,0xc3+.cfi_endproc	+
+ c-source/build/mach-o/mulx_mont_256-x86_64.s view
@@ -0,0 +1,619 @@+.text	++.globl	_mulx_mont_sparse_256+.private_extern	_mulx_mont_sparse_256++.p2align	5+_mulx_mont_sparse_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rdx,%rbx+	movq	0(%rdx),%rdx+	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%rbp+	movq	24(%rsi),%r9+	leaq	-128(%rsi),%rsi+	leaq	-128(%rcx),%rcx++	mulxq	%r14,%rax,%r11+	call	__mulx_mont_sparse_256++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+++.globl	_sqrx_mont_sparse_256+.private_extern	_sqrx_mont_sparse_256++.p2align	5+_sqrx_mont_sparse_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rsi,%rbx+	movq	%rcx,%r8+	movq	%rdx,%rcx+	movq	0(%rsi),%rdx+	movq	8(%rsi),%r15+	movq	16(%rsi),%rbp+	movq	24(%rsi),%r9+	leaq	-128(%rbx),%rsi+	leaq	-128(%rcx),%rcx++	mulxq	%rdx,%rax,%r11+	call	__mulx_mont_sparse_256++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+++.p2align	5+__mulx_mont_sparse_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	mulxq	%r15,%r15,%r12+	mulxq	%rbp,%rbp,%r13+	addq	%r15,%r11+	mulxq	%r9,%r9,%r14+	movq	8(%rbx),%rdx+	adcq	%rbp,%r12+	adcq	%r9,%r13+	adcq	$0,%r14++	movq	%rax,%r10+	imulq	%r8,%rax+++	xorq	%r15,%r15+	mulxq	0+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r11+	adcxq	%r9,%r12++	mulxq	8+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r12+	adcxq	%r9,%r13++	mulxq	16+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r13+	adcxq	%r9,%r14++	mulxq	24+128(%rsi),%rbp,%r9+	movq	%rax,%rdx+	adoxq	%rbp,%r14+	adcxq	%r15,%r9+	adoxq	%r9,%r15+++	mulxq	0+128(%rcx),%rbp,%rax+	adcxq	%rbp,%r10+	adoxq	%r11,%rax++	mulxq	8+128(%rcx),%rbp,%r9+	adcxq	%rbp,%rax+	adoxq	%r9,%r12++	mulxq	16+128(%rcx),%rbp,%r9+	adcxq	%rbp,%r12+	adoxq	%r9,%r13++	mulxq	24+128(%rcx),%rbp,%r9+	movq	16(%rbx),%rdx+	adcxq	%rbp,%r13+	adoxq	%r9,%r14+	adcxq	%r10,%r14+	adoxq	%r10,%r15+	adcxq	%r10,%r15+	adoxq	%r10,%r10+	adcq	$0,%r10+	movq	%rax,%r11+	imulq	%r8,%rax+++	xorq	%rbp,%rbp+	mulxq	0+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r12+	adcxq	%r9,%r13++	mulxq	8+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r13+	adcxq	%r9,%r14++	mulxq	16+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r14+	adcxq	%r9,%r15++	mulxq	24+128(%rsi),%rbp,%r9+	movq	%rax,%rdx+	adoxq	%rbp,%r15+	adcxq	%r10,%r9+	adoxq	%r9,%r10+++	mulxq	0+128(%rcx),%rbp,%rax+	adcxq	%rbp,%r11+	adoxq	%r12,%rax++	mulxq	8+128(%rcx),%rbp,%r9+	adcxq	%rbp,%rax+	adoxq	%r9,%r13++	mulxq	16+128(%rcx),%rbp,%r9+	adcxq	%rbp,%r13+	adoxq	%r9,%r14++	mulxq	24+128(%rcx),%rbp,%r9+	movq	24(%rbx),%rdx+	adcxq	%rbp,%r14+	adoxq	%r9,%r15+	adcxq	%r11,%r15+	adoxq	%r11,%r10+	adcxq	%r11,%r10+	adoxq	%r11,%r11+	adcq	$0,%r11+	movq	%rax,%r12+	imulq	%r8,%rax+++	xorq	%rbp,%rbp+	mulxq	0+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r13+	adcxq	%r9,%r14++	mulxq	8+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r14+	adcxq	%r9,%r15++	mulxq	16+128(%rsi),%rbp,%r9+	adoxq	%rbp,%r15+	adcxq	%r9,%r10++	mulxq	24+128(%rsi),%rbp,%r9+	movq	%rax,%rdx+	adoxq	%rbp,%r10+	adcxq	%r11,%r9+	adoxq	%r9,%r11+++	mulxq	0+128(%rcx),%rbp,%rax+	adcxq	%rbp,%r12+	adoxq	%r13,%rax++	mulxq	8+128(%rcx),%rbp,%r9+	adcxq	%rbp,%rax+	adoxq	%r9,%r14++	mulxq	16+128(%rcx),%rbp,%r9+	adcxq	%rbp,%r14+	adoxq	%r9,%r15++	mulxq	24+128(%rcx),%rbp,%r9+	movq	%rax,%rdx+	adcxq	%rbp,%r15+	adoxq	%r9,%r10+	adcxq	%r12,%r10+	adoxq	%r12,%r11+	adcxq	%r12,%r11+	adoxq	%r12,%r12+	adcq	$0,%r12+	imulq	%r8,%rdx+++	xorq	%rbp,%rbp+	mulxq	0+128(%rcx),%r13,%r9+	adcxq	%rax,%r13+	adoxq	%r9,%r14++	mulxq	8+128(%rcx),%rbp,%r9+	adcxq	%rbp,%r14+	adoxq	%r9,%r15++	mulxq	16+128(%rcx),%rbp,%r9+	adcxq	%rbp,%r15+	adoxq	%r9,%r10++	mulxq	24+128(%rcx),%rbp,%r9+	movq	%r14,%rdx+	leaq	128(%rcx),%rcx+	adcxq	%rbp,%r10+	adoxq	%r9,%r11+	movq	%r15,%rax+	adcxq	%r13,%r11+	adoxq	%r13,%r12+	adcq	$0,%r12+++++	movq	%r10,%rbp+	subq	0(%rcx),%r14+	sbbq	8(%rcx),%r15+	sbbq	16(%rcx),%r10+	movq	%r11,%r9+	sbbq	24(%rcx),%r11+	sbbq	$0,%r12++	cmovcq	%rdx,%r14+	cmovcq	%rax,%r15+	cmovcq	%rbp,%r10+	movq	%r14,0(%rdi)+	cmovcq	%r9,%r11+	movq	%r15,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc++.globl	_fromx_mont_256+.private_extern	_fromx_mont_256++.p2align	5+_fromx_mont_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rdx,%rbx+	call	__mulx_by_1_mont_256++++++	movq	%r15,%rdx+	movq	%r10,%r12+	movq	%r11,%r13++	subq	0(%rbx),%r14+	sbbq	8(%rbx),%r15+	sbbq	16(%rbx),%r10+	sbbq	24(%rbx),%r11++	cmovncq	%r14,%rax+	cmovncq	%r15,%rdx+	cmovncq	%r10,%r12+	movq	%rax,0(%rdi)+	cmovncq	%r11,%r13+	movq	%rdx,8(%rdi)+	movq	%r12,16(%rdi)+	movq	%r13,24(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+++.globl	_redcx_mont_256+.private_extern	_redcx_mont_256++.p2align	5+_redcx_mont_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rdx,%rbx+	call	__mulx_by_1_mont_256++	addq	32(%rsi),%r14+	adcq	40(%rsi),%r15+	movq	%r14,%rax+	adcq	48(%rsi),%r10+	movq	%r15,%rdx+	adcq	56(%rsi),%r11+	sbbq	%rsi,%rsi+++++	movq	%r10,%r12+	subq	0(%rbx),%r14+	sbbq	8(%rbx),%r15+	sbbq	16(%rbx),%r10+	movq	%r11,%r13+	sbbq	24(%rbx),%r11+	sbbq	$0,%rsi++	cmovncq	%r14,%rax+	cmovncq	%r15,%rdx+	cmovncq	%r10,%r12+	movq	%rax,0(%rdi)+	cmovncq	%r11,%r13+	movq	%rdx,8(%rdi)+	movq	%r12,16(%rdi)+	movq	%r13,24(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+++.p2align	5+__mulx_by_1_mont_256:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%rax+	movq	8(%rsi),%r11+	movq	16(%rsi),%r12+	movq	24(%rsi),%r13++	movq	%rax,%r14+	imulq	%rcx,%rax+	movq	%rax,%r10++	mulq	0(%rbx)+	addq	%rax,%r14+	movq	%r10,%rax+	adcq	%rdx,%r14++	mulq	8(%rbx)+	addq	%rax,%r11+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r14,%r11+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	16(%rbx)+	movq	%r11,%r15+	imulq	%rcx,%r11+	addq	%rax,%r12+	movq	%r10,%rax+	adcq	$0,%rdx+	addq	%r14,%r12+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	24(%rbx)+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r14,%r13+	adcq	$0,%rdx+	movq	%rdx,%r14++	mulq	0(%rbx)+	addq	%rax,%r15+	movq	%r11,%rax+	adcq	%rdx,%r15++	mulq	8(%rbx)+	addq	%rax,%r12+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r15,%r12+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	16(%rbx)+	movq	%r12,%r10+	imulq	%rcx,%r12+	addq	%rax,%r13+	movq	%r11,%rax+	adcq	$0,%rdx+	addq	%r15,%r13+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	24(%rbx)+	addq	%rax,%r14+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r15,%r14+	adcq	$0,%rdx+	movq	%rdx,%r15++	mulq	0(%rbx)+	addq	%rax,%r10+	movq	%r12,%rax+	adcq	%rdx,%r10++	mulq	8(%rbx)+	addq	%rax,%r13+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r10,%r13+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	16(%rbx)+	movq	%r13,%r11+	imulq	%rcx,%r13+	addq	%rax,%r14+	movq	%r12,%rax+	adcq	$0,%rdx+	addq	%r10,%r14+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	24(%rbx)+	addq	%rax,%r15+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r10,%r15+	adcq	$0,%rdx+	movq	%rdx,%r10++	mulq	0(%rbx)+	addq	%rax,%r11+	movq	%r13,%rax+	adcq	%rdx,%r11++	mulq	8(%rbx)+	addq	%rax,%r14+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r11,%r14+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	16(%rbx)+	addq	%rax,%r15+	movq	%r13,%rax+	adcq	$0,%rdx+	addq	%r11,%r15+	adcq	$0,%rdx+	movq	%rdx,%r11++	mulq	24(%rbx)+	addq	%rax,%r10+	movq	%r14,%rax+	adcq	$0,%rdx+	addq	%r11,%r10+	adcq	$0,%rdx+	movq	%rdx,%r11+	.byte	0xf3,0xc3+.cfi_endproc+
+ c-source/build/mach-o/mulx_mont_384-x86_64.s view
@@ -0,0 +1,2960 @@+.text	+++++++++.p2align	5+__sub_mod_384x384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	movq	48(%rsi),%r14++	subq	0(%rdx),%r8+	movq	56(%rsi),%r15+	sbbq	8(%rdx),%r9+	movq	64(%rsi),%rax+	sbbq	16(%rdx),%r10+	movq	72(%rsi),%rbx+	sbbq	24(%rdx),%r11+	movq	80(%rsi),%rbp+	sbbq	32(%rdx),%r12+	movq	88(%rsi),%rsi+	sbbq	40(%rdx),%r13+	movq	%r8,0(%rdi)+	sbbq	48(%rdx),%r14+	movq	0(%rcx),%r8+	movq	%r9,8(%rdi)+	sbbq	56(%rdx),%r15+	movq	8(%rcx),%r9+	movq	%r10,16(%rdi)+	sbbq	64(%rdx),%rax+	movq	16(%rcx),%r10+	movq	%r11,24(%rdi)+	sbbq	72(%rdx),%rbx+	movq	24(%rcx),%r11+	movq	%r12,32(%rdi)+	sbbq	80(%rdx),%rbp+	movq	32(%rcx),%r12+	movq	%r13,40(%rdi)+	sbbq	88(%rdx),%rsi+	movq	40(%rcx),%r13+	sbbq	%rdx,%rdx++	andq	%rdx,%r8+	andq	%rdx,%r9+	andq	%rdx,%r10+	andq	%rdx,%r11+	andq	%rdx,%r12+	andq	%rdx,%r13++	addq	%r8,%r14+	adcq	%r9,%r15+	movq	%r14,48(%rdi)+	adcq	%r10,%rax+	movq	%r15,56(%rdi)+	adcq	%r11,%rbx+	movq	%rax,64(%rdi)+	adcq	%r12,%rbp+	movq	%rbx,72(%rdi)+	adcq	%r13,%rsi+	movq	%rbp,80(%rdi)+	movq	%rsi,88(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc++++.p2align	5+__add_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	addq	0(%rdx),%r8+	adcq	8(%rdx),%r9+	adcq	16(%rdx),%r10+	movq	%r8,%r14+	adcq	24(%rdx),%r11+	movq	%r9,%r15+	adcq	32(%rdx),%r12+	movq	%r10,%rax+	adcq	40(%rdx),%r13+	movq	%r11,%rbx+	sbbq	%rdx,%rdx++	subq	0(%rcx),%r8+	sbbq	8(%rcx),%r9+	movq	%r12,%rbp+	sbbq	16(%rcx),%r10+	sbbq	24(%rcx),%r11+	sbbq	32(%rcx),%r12+	movq	%r13,%rsi+	sbbq	40(%rcx),%r13+	sbbq	$0,%rdx++	cmovcq	%r14,%r8+	cmovcq	%r15,%r9+	cmovcq	%rax,%r10+	movq	%r8,0(%rdi)+	cmovcq	%rbx,%r11+	movq	%r9,8(%rdi)+	cmovcq	%rbp,%r12+	movq	%r10,16(%rdi)+	cmovcq	%rsi,%r13+	movq	%r11,24(%rdi)+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc++++.p2align	5+__sub_mod_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++__sub_mod_384_a_is_loaded:+	subq	0(%rdx),%r8+	movq	0(%rcx),%r14+	sbbq	8(%rdx),%r9+	movq	8(%rcx),%r15+	sbbq	16(%rdx),%r10+	movq	16(%rcx),%rax+	sbbq	24(%rdx),%r11+	movq	24(%rcx),%rbx+	sbbq	32(%rdx),%r12+	movq	32(%rcx),%rbp+	sbbq	40(%rdx),%r13+	movq	40(%rcx),%rsi+	sbbq	%rdx,%rdx++	andq	%rdx,%r14+	andq	%rdx,%r15+	andq	%rdx,%rax+	andq	%rdx,%rbx+	andq	%rdx,%rbp+	andq	%rdx,%rsi++	addq	%r14,%r8+	adcq	%r15,%r9+	movq	%r8,0(%rdi)+	adcq	%rax,%r10+	movq	%r9,8(%rdi)+	adcq	%rbx,%r11+	movq	%r10,16(%rdi)+	adcq	%rbp,%r12+	movq	%r11,24(%rdi)+	adcq	%rsi,%r13+	movq	%r12,32(%rdi)+	movq	%r13,40(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc++.globl	_mulx_mont_384x+.private_extern	_mulx_mont_384x++.p2align	5+_mulx_mont_384x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$328,%rsp+.cfi_adjust_cfa_offset	328+++	movq	%rdx,%rbx+	movq	%rdi,32(%rsp)+	movq	%rsi,24(%rsp)+	movq	%rdx,16(%rsp)+	movq	%rcx,8(%rsp)+	movq	%r8,0(%rsp)+++++	leaq	40(%rsp),%rdi+	call	__mulx_384+++	leaq	48(%rbx),%rbx+	leaq	128+48(%rsi),%rsi+	leaq	96(%rdi),%rdi+	call	__mulx_384+++	movq	8(%rsp),%rcx+	leaq	(%rbx),%rsi+	leaq	-48(%rbx),%rdx+	leaq	40+192+48(%rsp),%rdi+	call	__add_mod_384++	movq	24(%rsp),%rsi+	leaq	48(%rsi),%rdx+	leaq	-48(%rdi),%rdi+	call	__add_mod_384++	leaq	(%rdi),%rbx+	leaq	48(%rdi),%rsi+	call	__mulx_384+++	leaq	(%rdi),%rsi+	leaq	40(%rsp),%rdx+	movq	8(%rsp),%rcx+	call	__sub_mod_384x384++	leaq	(%rdi),%rsi+	leaq	-96(%rdi),%rdx+	call	__sub_mod_384x384+++	leaq	40(%rsp),%rsi+	leaq	40+96(%rsp),%rdx+	leaq	40(%rsp),%rdi+	call	__sub_mod_384x384++	leaq	(%rcx),%rbx+++	leaq	40(%rsp),%rsi+	movq	0(%rsp),%rcx+	movq	32(%rsp),%rdi+	call	__mulx_by_1_mont_384+	call	__redc_tail_mont_384+++	leaq	40+192(%rsp),%rsi+	movq	0(%rsp),%rcx+	leaq	48(%rdi),%rdi+	call	__mulx_by_1_mont_384+	call	__redc_tail_mont_384++	leaq	328(%rsp),%r8+	movq	0(%r8),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-328-8*6++	.byte	0xf3,0xc3+.cfi_endproc	++.globl	_sqrx_mont_384x+.private_extern	_sqrx_mont_384x++.p2align	5+_sqrx_mont_384x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$136,%rsp+.cfi_adjust_cfa_offset	136+++	movq	%rcx,0(%rsp)+	movq	%rdx,%rcx++	movq	%rdi,16(%rsp)+	movq	%rsi,24(%rsp)+++	leaq	48(%rsi),%rdx+	leaq	32(%rsp),%rdi+	call	__add_mod_384+++	movq	24(%rsp),%rsi+	leaq	48(%rsi),%rdx+	leaq	32+48(%rsp),%rdi+	call	__sub_mod_384+++	movq	24(%rsp),%rsi+	leaq	48(%rsi),%rbx++	movq	48(%rsi),%rdx+	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%rax+	movq	24(%rsi),%r12+	movq	32(%rsi),%rdi+	movq	40(%rsi),%rbp+	leaq	-128(%rsi),%rsi+	leaq	-128(%rcx),%rcx++	mulxq	%r14,%r8,%r9+	call	__mulx_mont_384+	addq	%rdx,%rdx+	adcq	%r15,%r15+	adcq	%rax,%rax+	movq	%rdx,%r8+	adcq	%r12,%r12+	movq	%r15,%r9+	adcq	%rdi,%rdi+	movq	%rax,%r10+	adcq	%rbp,%rbp+	movq	%r12,%r11+	sbbq	%rsi,%rsi++	subq	0(%rcx),%rdx+	sbbq	8(%rcx),%r15+	movq	%rdi,%r13+	sbbq	16(%rcx),%rax+	sbbq	24(%rcx),%r12+	sbbq	32(%rcx),%rdi+	movq	%rbp,%r14+	sbbq	40(%rcx),%rbp+	sbbq	$0,%rsi++	cmovcq	%r8,%rdx+	cmovcq	%r9,%r15+	cmovcq	%r10,%rax+	movq	%rdx,48(%rbx)+	cmovcq	%r11,%r12+	movq	%r15,56(%rbx)+	cmovcq	%r13,%rdi+	movq	%rax,64(%rbx)+	cmovcq	%r14,%rbp+	movq	%r12,72(%rbx)+	movq	%rdi,80(%rbx)+	movq	%rbp,88(%rbx)++	leaq	32(%rsp),%rsi+	leaq	32+48(%rsp),%rbx++	movq	32+48(%rsp),%rdx+	movq	32+0(%rsp),%r14+	movq	32+8(%rsp),%r15+	movq	32+16(%rsp),%rax+	movq	32+24(%rsp),%r12+	movq	32+32(%rsp),%rdi+	movq	32+40(%rsp),%rbp+	leaq	-128(%rsi),%rsi+	leaq	-128(%rcx),%rcx++	mulxq	%r14,%r8,%r9+	call	__mulx_mont_384++	leaq	136(%rsp),%r8+	movq	0(%r8),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-136-8*6++	.byte	0xf3,0xc3+.cfi_endproc	+++.globl	_mulx_382x+.private_extern	_mulx_382x++.p2align	5+_mulx_382x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$136,%rsp+.cfi_adjust_cfa_offset	136+++	leaq	96(%rdi),%rdi+	movq	%rsi,0(%rsp)+	movq	%rdx,8(%rsp)+	movq	%rdi,16(%rsp)+	movq	%rcx,24(%rsp)+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	addq	48(%rsi),%r8+	adcq	56(%rsi),%r9+	adcq	64(%rsi),%r10+	adcq	72(%rsi),%r11+	adcq	80(%rsi),%r12+	adcq	88(%rsi),%r13++	movq	%r8,32+0(%rsp)+	movq	%r9,32+8(%rsp)+	movq	%r10,32+16(%rsp)+	movq	%r11,32+24(%rsp)+	movq	%r12,32+32(%rsp)+	movq	%r13,32+40(%rsp)+++	movq	0(%rdx),%r8+	movq	8(%rdx),%r9+	movq	16(%rdx),%r10+	movq	24(%rdx),%r11+	movq	32(%rdx),%r12+	movq	40(%rdx),%r13++	addq	48(%rdx),%r8+	adcq	56(%rdx),%r9+	adcq	64(%rdx),%r10+	adcq	72(%rdx),%r11+	adcq	80(%rdx),%r12+	adcq	88(%rdx),%r13++	movq	%r8,32+48(%rsp)+	movq	%r9,32+56(%rsp)+	movq	%r10,32+64(%rsp)+	movq	%r11,32+72(%rsp)+	movq	%r12,32+80(%rsp)+	movq	%r13,32+88(%rsp)+++	leaq	32+0(%rsp),%rsi+	leaq	32+48(%rsp),%rbx+	call	__mulx_384+++	movq	0(%rsp),%rsi+	movq	8(%rsp),%rbx+	leaq	-96(%rdi),%rdi+	call	__mulx_384+++	leaq	48+128(%rsi),%rsi+	leaq	48(%rbx),%rbx+	leaq	32(%rsp),%rdi+	call	__mulx_384+++	movq	16(%rsp),%rsi+	leaq	32(%rsp),%rdx+	movq	24(%rsp),%rcx+	movq	%rsi,%rdi+	call	__sub_mod_384x384+++	leaq	0(%rdi),%rsi+	leaq	-96(%rdi),%rdx+	call	__sub_mod_384x384+++	leaq	-96(%rdi),%rsi+	leaq	32(%rsp),%rdx+	leaq	-96(%rdi),%rdi+	call	__sub_mod_384x384++	leaq	136(%rsp),%r8+	movq	0(%r8),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-136-8*6++	.byte	0xf3,0xc3+.cfi_endproc	++.globl	_sqrx_382x+.private_extern	_sqrx_382x++.p2align	5+_sqrx_382x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	pushq	%rsi+.cfi_adjust_cfa_offset	8+++	movq	%rdx,%rcx+++	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%rax+	movq	24(%rsi),%rbx+	movq	32(%rsi),%rbp+	movq	40(%rsi),%rdx++	movq	%r14,%r8+	addq	48(%rsi),%r14+	movq	%r15,%r9+	adcq	56(%rsi),%r15+	movq	%rax,%r10+	adcq	64(%rsi),%rax+	movq	%rbx,%r11+	adcq	72(%rsi),%rbx+	movq	%rbp,%r12+	adcq	80(%rsi),%rbp+	movq	%rdx,%r13+	adcq	88(%rsi),%rdx++	movq	%r14,0(%rdi)+	movq	%r15,8(%rdi)+	movq	%rax,16(%rdi)+	movq	%rbx,24(%rdi)+	movq	%rbp,32(%rdi)+	movq	%rdx,40(%rdi)+++	leaq	48(%rsi),%rdx+	leaq	48(%rdi),%rdi+	call	__sub_mod_384_a_is_loaded+++	leaq	(%rdi),%rsi+	leaq	-48(%rdi),%rbx+	leaq	-48(%rdi),%rdi+	call	__mulx_384+++	movq	(%rsp),%rsi+	leaq	48(%rsi),%rbx+	leaq	96(%rdi),%rdi+	call	__mulx_384++	movq	0(%rdi),%r8+	movq	8(%rdi),%r9+	movq	16(%rdi),%r10+	movq	24(%rdi),%r11+	movq	32(%rdi),%r12+	movq	40(%rdi),%r13+	movq	48(%rdi),%r14+	movq	56(%rdi),%r15+	movq	64(%rdi),%rax+	movq	72(%rdi),%rbx+	movq	80(%rdi),%rbp+	addq	%r8,%r8+	movq	88(%rdi),%rdx+	adcq	%r9,%r9+	movq	%r8,0(%rdi)+	adcq	%r10,%r10+	movq	%r9,8(%rdi)+	adcq	%r11,%r11+	movq	%r10,16(%rdi)+	adcq	%r12,%r12+	movq	%r11,24(%rdi)+	adcq	%r13,%r13+	movq	%r12,32(%rdi)+	adcq	%r14,%r14+	movq	%r13,40(%rdi)+	adcq	%r15,%r15+	movq	%r14,48(%rdi)+	adcq	%rax,%rax+	movq	%r15,56(%rdi)+	adcq	%rbx,%rbx+	movq	%rax,64(%rdi)+	adcq	%rbp,%rbp+	movq	%rbx,72(%rdi)+	adcq	%rdx,%rdx+	movq	%rbp,80(%rdi)+	movq	%rdx,88(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-8*7++	.byte	0xf3,0xc3+.cfi_endproc	++.globl	_mulx_384+.private_extern	_mulx_384++.p2align	5+_mulx_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+++	movq	%rdx,%rbx+	call	__mulx_384++	movq	0(%rsp),%r15+.cfi_restore	%r15+	movq	8(%rsp),%r14+.cfi_restore	%r14+	movq	16(%rsp),%r13+.cfi_restore	%r13+	movq	24(%rsp),%r12+.cfi_restore	%r12+	movq	32(%rsp),%rbx+.cfi_restore	%rbx+	movq	40(%rsp),%rbp+.cfi_restore	%rbp+	leaq	48(%rsp),%rsp+.cfi_adjust_cfa_offset	-48++	.byte	0xf3,0xc3+.cfi_endproc	++++.p2align	5+__mulx_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rbx),%rdx+	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	leaq	-128(%rsi),%rsi++	mulxq	%r14,%r9,%rcx+	xorq	%rbp,%rbp++	mulxq	%r15,%r8,%rax+	adcxq	%rcx,%r8+	movq	%r9,0(%rdi)++	mulxq	%r10,%r9,%rcx+	adcxq	%rax,%r9++	mulxq	%r11,%r10,%rax+	adcxq	%rcx,%r10++	mulxq	%r12,%r11,%rcx+	adcxq	%rax,%r11++	mulxq	%r13,%r12,%r13+	movq	8(%rbx),%rdx+	adcxq	%rcx,%r12+	adcxq	%rbp,%r13+	mulxq	%r14,%rax,%rcx+	adcxq	%r8,%rax+	adoxq	%rcx,%r9+	movq	%rax,8(%rdi)++	mulxq	%r15,%r8,%rcx+	adcxq	%r9,%r8+	adoxq	%rcx,%r10++	mulxq	128+16(%rsi),%r9,%rax+	adcxq	%r10,%r9+	adoxq	%rax,%r11++	mulxq	128+24(%rsi),%r10,%rcx+	adcxq	%r11,%r10+	adoxq	%rcx,%r12++	mulxq	128+32(%rsi),%r11,%rax+	adcxq	%r12,%r11+	adoxq	%r13,%rax++	mulxq	128+40(%rsi),%r12,%r13+	movq	16(%rbx),%rdx+	adcxq	%rax,%r12+	adoxq	%rbp,%r13+	adcxq	%rbp,%r13+	mulxq	%r14,%rax,%rcx+	adcxq	%r8,%rax+	adoxq	%rcx,%r9+	movq	%rax,16(%rdi)++	mulxq	%r15,%r8,%rcx+	adcxq	%r9,%r8+	adoxq	%rcx,%r10++	mulxq	128+16(%rsi),%r9,%rax+	adcxq	%r10,%r9+	adoxq	%rax,%r11++	mulxq	128+24(%rsi),%r10,%rcx+	adcxq	%r11,%r10+	adoxq	%rcx,%r12++	mulxq	128+32(%rsi),%r11,%rax+	adcxq	%r12,%r11+	adoxq	%r13,%rax++	mulxq	128+40(%rsi),%r12,%r13+	movq	24(%rbx),%rdx+	adcxq	%rax,%r12+	adoxq	%rbp,%r13+	adcxq	%rbp,%r13+	mulxq	%r14,%rax,%rcx+	adcxq	%r8,%rax+	adoxq	%rcx,%r9+	movq	%rax,24(%rdi)++	mulxq	%r15,%r8,%rcx+	adcxq	%r9,%r8+	adoxq	%rcx,%r10++	mulxq	128+16(%rsi),%r9,%rax+	adcxq	%r10,%r9+	adoxq	%rax,%r11++	mulxq	128+24(%rsi),%r10,%rcx+	adcxq	%r11,%r10+	adoxq	%rcx,%r12++	mulxq	128+32(%rsi),%r11,%rax+	adcxq	%r12,%r11+	adoxq	%r13,%rax++	mulxq	128+40(%rsi),%r12,%r13+	movq	32(%rbx),%rdx+	adcxq	%rax,%r12+	adoxq	%rbp,%r13+	adcxq	%rbp,%r13+	mulxq	%r14,%rax,%rcx+	adcxq	%r8,%rax+	adoxq	%rcx,%r9+	movq	%rax,32(%rdi)++	mulxq	%r15,%r8,%rcx+	adcxq	%r9,%r8+	adoxq	%rcx,%r10++	mulxq	128+16(%rsi),%r9,%rax+	adcxq	%r10,%r9+	adoxq	%rax,%r11++	mulxq	128+24(%rsi),%r10,%rcx+	adcxq	%r11,%r10+	adoxq	%rcx,%r12++	mulxq	128+32(%rsi),%r11,%rax+	adcxq	%r12,%r11+	adoxq	%r13,%rax++	mulxq	128+40(%rsi),%r12,%r13+	movq	40(%rbx),%rdx+	adcxq	%rax,%r12+	adoxq	%rbp,%r13+	adcxq	%rbp,%r13+	mulxq	%r14,%rax,%rcx+	adcxq	%r8,%rax+	adoxq	%rcx,%r9+	movq	%rax,40(%rdi)++	mulxq	%r15,%r8,%rcx+	adcxq	%r9,%r8+	adoxq	%rcx,%r10++	mulxq	128+16(%rsi),%r9,%rax+	adcxq	%r10,%r9+	adoxq	%rax,%r11++	mulxq	128+24(%rsi),%r10,%rcx+	adcxq	%r11,%r10+	adoxq	%rcx,%r12++	mulxq	128+32(%rsi),%r11,%rax+	adcxq	%r12,%r11+	adoxq	%r13,%rax++	mulxq	128+40(%rsi),%r12,%r13+	movq	%rax,%rdx+	adcxq	%rax,%r12+	adoxq	%rbp,%r13+	adcxq	%rbp,%r13+	movq	%r8,48(%rdi)+	movq	%r9,56(%rdi)+	movq	%r10,64(%rdi)+	movq	%r11,72(%rdi)+	movq	%r12,80(%rdi)+	movq	%r13,88(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc++.globl	_sqrx_384+.private_extern	_sqrx_384++.p2align	5+_sqrx_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	pushq	%rdi+.cfi_adjust_cfa_offset	8+++	call	__sqrx_384++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+++.p2align	5+__sqrx_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%rdx+	movq	8(%rsi),%r14+	movq	16(%rsi),%r15+	movq	24(%rsi),%rcx+	movq	32(%rsi),%rbx+++	mulxq	%r14,%r8,%rdi+	movq	40(%rsi),%rbp+	mulxq	%r15,%r9,%rax+	addq	%rdi,%r9+	mulxq	%rcx,%r10,%rdi+	adcq	%rax,%r10+	mulxq	%rbx,%r11,%rax+	adcq	%rdi,%r11+	mulxq	%rbp,%r12,%r13+	movq	%r14,%rdx+	adcq	%rax,%r12+	adcq	$0,%r13+++	xorq	%r14,%r14+	mulxq	%r15,%rdi,%rax+	adcxq	%rdi,%r10+	adoxq	%rax,%r11++	mulxq	%rcx,%rdi,%rax+	adcxq	%rdi,%r11+	adoxq	%rax,%r12++	mulxq	%rbx,%rdi,%rax+	adcxq	%rdi,%r12+	adoxq	%rax,%r13++	mulxq	%rbp,%rdi,%rax+	movq	%r15,%rdx+	adcxq	%rdi,%r13+	adoxq	%r14,%rax+	adcxq	%rax,%r14+++	xorq	%r15,%r15+	mulxq	%rcx,%rdi,%rax+	adcxq	%rdi,%r12+	adoxq	%rax,%r13++	mulxq	%rbx,%rdi,%rax+	adcxq	%rdi,%r13+	adoxq	%rax,%r14++	mulxq	%rbp,%rdi,%rax+	movq	%rcx,%rdx+	adcxq	%rdi,%r14+	adoxq	%r15,%rax+	adcxq	%rax,%r15+++	xorq	%rcx,%rcx+	mulxq	%rbx,%rdi,%rax+	adcxq	%rdi,%r14+	adoxq	%rax,%r15++	mulxq	%rbp,%rdi,%rax+	movq	%rbx,%rdx+	adcxq	%rdi,%r15+	adoxq	%rcx,%rax+	adcxq	%rax,%rcx+++	mulxq	%rbp,%rdi,%rbx+	movq	0(%rsi),%rdx+	addq	%rdi,%rcx+	movq	8(%rsp),%rdi+	adcq	$0,%rbx+++	xorq	%rbp,%rbp+	adcxq	%r8,%r8+	adcxq	%r9,%r9+	adcxq	%r10,%r10+	adcxq	%r11,%r11+	adcxq	%r12,%r12+++	mulxq	%rdx,%rdx,%rax+	movq	%rdx,0(%rdi)+	movq	8(%rsi),%rdx+	adoxq	%rax,%r8+	movq	%r8,8(%rdi)++	mulxq	%rdx,%r8,%rax+	movq	16(%rsi),%rdx+	adoxq	%r8,%r9+	adoxq	%rax,%r10+	movq	%r9,16(%rdi)+	movq	%r10,24(%rdi)++	mulxq	%rdx,%r8,%r9+	movq	24(%rsi),%rdx+	adoxq	%r8,%r11+	adoxq	%r9,%r12+	adcxq	%r13,%r13+	adcxq	%r14,%r14+	movq	%r11,32(%rdi)+	movq	%r12,40(%rdi)++	mulxq	%rdx,%r8,%r9+	movq	32(%rsi),%rdx+	adoxq	%r8,%r13+	adoxq	%r9,%r14+	adcxq	%r15,%r15+	adcxq	%rcx,%rcx+	movq	%r13,48(%rdi)+	movq	%r14,56(%rdi)++	mulxq	%rdx,%r8,%r9+	movq	40(%rsi),%rdx+	adoxq	%r8,%r15+	adoxq	%r9,%rcx+	adcxq	%rbx,%rbx+	adcxq	%rbp,%rbp+	movq	%r15,64(%rdi)+	movq	%rcx,72(%rdi)++	mulxq	%rdx,%r8,%r9+	adoxq	%r8,%rbx+	adoxq	%r9,%rbp++	movq	%rbx,80(%rdi)+	movq	%rbp,88(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+++++.globl	_redcx_mont_384+.private_extern	_redcx_mont_384++.p2align	5+_redcx_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rdx,%rbx+	call	__mulx_by_1_mont_384+	call	__redc_tail_mont_384++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	++++++.globl	_fromx_mont_384+.private_extern	_fromx_mont_384++.p2align	5+_fromx_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rdx,%rbx+	call	__mulx_by_1_mont_384+++++	movq	%r14,%rax+	movq	%r15,%rcx+	movq	%r8,%rdx+	movq	%r9,%rbp++	subq	0(%rbx),%r14+	sbbq	8(%rbx),%r15+	movq	%r10,%r13+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	movq	%r11,%rsi+	sbbq	40(%rbx),%r11++	cmovcq	%rax,%r14+	cmovcq	%rcx,%r15+	cmovcq	%rdx,%r8+	movq	%r14,0(%rdi)+	cmovcq	%rbp,%r9+	movq	%r15,8(%rdi)+	cmovcq	%r13,%r10+	movq	%r8,16(%rdi)+	cmovcq	%rsi,%r11+	movq	%r9,24(%rdi)+	movq	%r10,32(%rdi)+	movq	%r11,40(%rdi)++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+++.p2align	5+__mulx_by_1_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	%rcx,%rdx+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13+	imulq	%r8,%rdx+++	xorq	%r14,%r14+	mulxq	0(%rbx),%rax,%rbp+	adcxq	%rax,%r8+	adoxq	%rbp,%r9++	mulxq	8(%rbx),%rax,%rbp+	adcxq	%rax,%r9+	adoxq	%rbp,%r10++	mulxq	16(%rbx),%rax,%rbp+	adcxq	%rax,%r10+	adoxq	%rbp,%r11++	mulxq	24(%rbx),%rax,%rbp+	adcxq	%rax,%r11+	adoxq	%rbp,%r12++	mulxq	32(%rbx),%rax,%rbp+	adcxq	%rax,%r12+	adoxq	%rbp,%r13++	mulxq	40(%rbx),%rax,%rbp+	movq	%rcx,%rdx+	adcxq	%rax,%r13+	adoxq	%r14,%rbp+	adcxq	%rbp,%r14+	imulq	%r9,%rdx+++	xorq	%r15,%r15+	mulxq	0(%rbx),%rax,%rbp+	adcxq	%rax,%r9+	adoxq	%rbp,%r10++	mulxq	8(%rbx),%rax,%rbp+	adcxq	%rax,%r10+	adoxq	%rbp,%r11++	mulxq	16(%rbx),%rax,%rbp+	adcxq	%rax,%r11+	adoxq	%rbp,%r12++	mulxq	24(%rbx),%rax,%rbp+	adcxq	%rax,%r12+	adoxq	%rbp,%r13++	mulxq	32(%rbx),%rax,%rbp+	adcxq	%rax,%r13+	adoxq	%rbp,%r14++	mulxq	40(%rbx),%rax,%rbp+	movq	%rcx,%rdx+	adcxq	%rax,%r14+	adoxq	%r15,%rbp+	adcxq	%rbp,%r15+	imulq	%r10,%rdx+++	xorq	%r8,%r8+	mulxq	0(%rbx),%rax,%rbp+	adcxq	%rax,%r10+	adoxq	%rbp,%r11++	mulxq	8(%rbx),%rax,%rbp+	adcxq	%rax,%r11+	adoxq	%rbp,%r12++	mulxq	16(%rbx),%rax,%rbp+	adcxq	%rax,%r12+	adoxq	%rbp,%r13++	mulxq	24(%rbx),%rax,%rbp+	adcxq	%rax,%r13+	adoxq	%rbp,%r14++	mulxq	32(%rbx),%rax,%rbp+	adcxq	%rax,%r14+	adoxq	%rbp,%r15++	mulxq	40(%rbx),%rax,%rbp+	movq	%rcx,%rdx+	adcxq	%rax,%r15+	adoxq	%r8,%rbp+	adcxq	%rbp,%r8+	imulq	%r11,%rdx+++	xorq	%r9,%r9+	mulxq	0(%rbx),%rax,%rbp+	adcxq	%rax,%r11+	adoxq	%rbp,%r12++	mulxq	8(%rbx),%rax,%rbp+	adcxq	%rax,%r12+	adoxq	%rbp,%r13++	mulxq	16(%rbx),%rax,%rbp+	adcxq	%rax,%r13+	adoxq	%rbp,%r14++	mulxq	24(%rbx),%rax,%rbp+	adcxq	%rax,%r14+	adoxq	%rbp,%r15++	mulxq	32(%rbx),%rax,%rbp+	adcxq	%rax,%r15+	adoxq	%rbp,%r8++	mulxq	40(%rbx),%rax,%rbp+	movq	%rcx,%rdx+	adcxq	%rax,%r8+	adoxq	%r9,%rbp+	adcxq	%rbp,%r9+	imulq	%r12,%rdx+++	xorq	%r10,%r10+	mulxq	0(%rbx),%rax,%rbp+	adcxq	%rax,%r12+	adoxq	%rbp,%r13++	mulxq	8(%rbx),%rax,%rbp+	adcxq	%rax,%r13+	adoxq	%rbp,%r14++	mulxq	16(%rbx),%rax,%rbp+	adcxq	%rax,%r14+	adoxq	%rbp,%r15++	mulxq	24(%rbx),%rax,%rbp+	adcxq	%rax,%r15+	adoxq	%rbp,%r8++	mulxq	32(%rbx),%rax,%rbp+	adcxq	%rax,%r8+	adoxq	%rbp,%r9++	mulxq	40(%rbx),%rax,%rbp+	movq	%rcx,%rdx+	adcxq	%rax,%r9+	adoxq	%r10,%rbp+	adcxq	%rbp,%r10+	imulq	%r13,%rdx+++	xorq	%r11,%r11+	mulxq	0(%rbx),%rax,%rbp+	adcxq	%rax,%r13+	adoxq	%rbp,%r14++	mulxq	8(%rbx),%rax,%rbp+	adcxq	%rax,%r14+	adoxq	%rbp,%r15++	mulxq	16(%rbx),%rax,%rbp+	adcxq	%rax,%r15+	adoxq	%rbp,%r8++	mulxq	24(%rbx),%rax,%rbp+	adcxq	%rax,%r8+	adoxq	%rbp,%r9++	mulxq	32(%rbx),%rax,%rbp+	adcxq	%rax,%r9+	adoxq	%rbp,%r10++	mulxq	40(%rbx),%rax,%rbp+	movq	%rcx,%rdx+	adcxq	%rax,%r10+	adoxq	%r11,%rbp+	adcxq	%rbp,%r11+	.byte	0xf3,0xc3+.cfi_endproc++++.p2align	5+__redc_tail_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	addq	48(%rsi),%r14+	movq	%r14,%rax+	adcq	56(%rsi),%r15+	adcq	64(%rsi),%r8+	adcq	72(%rsi),%r9+	movq	%r15,%rcx+	adcq	80(%rsi),%r10+	adcq	88(%rsi),%r11+	sbbq	%r12,%r12+++++	movq	%r8,%rdx+	movq	%r9,%rbp++	subq	0(%rbx),%r14+	sbbq	8(%rbx),%r15+	movq	%r10,%r13+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	movq	%r11,%rsi+	sbbq	40(%rbx),%r11+	sbbq	$0,%r12++	cmovcq	%rax,%r14+	cmovcq	%rcx,%r15+	cmovcq	%rdx,%r8+	movq	%r14,0(%rdi)+	cmovcq	%rbp,%r9+	movq	%r15,8(%rdi)+	cmovcq	%r13,%r10+	movq	%r8,16(%rdi)+	cmovcq	%rsi,%r11+	movq	%r9,24(%rdi)+	movq	%r10,32(%rdi)+	movq	%r11,40(%rdi)++	.byte	0xf3,0xc3+.cfi_endproc+++.globl	_sgn0x_pty_mont_384+.private_extern	_sgn0x_pty_mont_384++.p2align	5+_sgn0x_pty_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rsi,%rbx+	leaq	0(%rdi),%rsi+	movq	%rdx,%rcx+	call	__mulx_by_1_mont_384++	xorq	%rax,%rax+	movq	%r14,%r13+	addq	%r14,%r14+	adcq	%r15,%r15+	adcq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	$0,%rax++	subq	0(%rbx),%r14+	sbbq	8(%rbx),%r15+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	sbbq	40(%rbx),%r11+	sbbq	$0,%rax++	notq	%rax+	andq	$1,%r13+	andq	$2,%rax+	orq	%r13,%rax++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	+++.globl	_sgn0x_pty_mont_384x+.private_extern	_sgn0x_pty_mont_384x++.p2align	5+_sgn0x_pty_mont_384x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$8,%rsp+.cfi_adjust_cfa_offset	8+++	movq	%rsi,%rbx+	leaq	48(%rdi),%rsi+	movq	%rdx,%rcx+	call	__mulx_by_1_mont_384++	movq	%r14,%r12+	orq	%r15,%r14+	orq	%r8,%r14+	orq	%r9,%r14+	orq	%r10,%r14+	orq	%r11,%r14++	leaq	0(%rdi),%rsi+	xorq	%rdi,%rdi+	movq	%r12,%r13+	addq	%r12,%r12+	adcq	%r15,%r15+	adcq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	$0,%rdi++	subq	0(%rbx),%r12+	sbbq	8(%rbx),%r15+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	sbbq	40(%rbx),%r11+	sbbq	$0,%rdi++	movq	%r14,0(%rsp)+	notq	%rdi+	andq	$1,%r13+	andq	$2,%rdi+	orq	%r13,%rdi++	call	__mulx_by_1_mont_384++	movq	%r14,%r12+	orq	%r15,%r14+	orq	%r8,%r14+	orq	%r9,%r14+	orq	%r10,%r14+	orq	%r11,%r14++	xorq	%rax,%rax+	movq	%r12,%r13+	addq	%r12,%r12+	adcq	%r15,%r15+	adcq	%r8,%r8+	adcq	%r9,%r9+	adcq	%r10,%r10+	adcq	%r11,%r11+	adcq	$0,%rax++	subq	0(%rbx),%r12+	sbbq	8(%rbx),%r15+	sbbq	16(%rbx),%r8+	sbbq	24(%rbx),%r9+	sbbq	32(%rbx),%r10+	sbbq	40(%rbx),%r11+	sbbq	$0,%rax++	movq	0(%rsp),%r12++	notq	%rax++	testq	%r14,%r14+	cmovzq	%rdi,%r13++	testq	%r12,%r12+	cmovnzq	%rdi,%rax++	andq	$1,%r13+	andq	$2,%rax+	orq	%r13,%rax++	movq	8(%rsp),%r15+.cfi_restore	%r15+	movq	16(%rsp),%r14+.cfi_restore	%r14+	movq	24(%rsp),%r13+.cfi_restore	%r13+	movq	32(%rsp),%r12+.cfi_restore	%r12+	movq	40(%rsp),%rbx+.cfi_restore	%rbx+	movq	48(%rsp),%rbp+.cfi_restore	%rbp+	leaq	56(%rsp),%rsp+.cfi_adjust_cfa_offset	-56++	.byte	0xf3,0xc3+.cfi_endproc	++.globl	_mulx_mont_384+.private_extern	_mulx_mont_384++.p2align	5+_mulx_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	leaq	-24(%rsp),%rsp+.cfi_adjust_cfa_offset	8*3+++	movq	%rdx,%rbx+	movq	0(%rdx),%rdx+	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%rax+	movq	24(%rsi),%r12+	movq	%rdi,16(%rsp)+	movq	32(%rsi),%rdi+	movq	40(%rsi),%rbp+	leaq	-128(%rsi),%rsi+	leaq	-128(%rcx),%rcx+	movq	%r8,(%rsp)++	mulxq	%r14,%r8,%r9+	call	__mulx_mont_384++	movq	24(%rsp),%r15+.cfi_restore	%r15+	movq	32(%rsp),%r14+.cfi_restore	%r14+	movq	40(%rsp),%r13+.cfi_restore	%r13+	movq	48(%rsp),%r12+.cfi_restore	%r12+	movq	56(%rsp),%rbx+.cfi_restore	%rbx+	movq	64(%rsp),%rbp+.cfi_restore	%rbp+	leaq	72(%rsp),%rsp+.cfi_adjust_cfa_offset	-8*9++	.byte	0xf3,0xc3+.cfi_endproc	+++.p2align	5+__mulx_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	mulxq	%r15,%r14,%r10+	mulxq	%rax,%r15,%r11+	addq	%r14,%r9+	mulxq	%r12,%rax,%r12+	adcq	%r15,%r10+	mulxq	%rdi,%rdi,%r13+	adcq	%rax,%r11+	mulxq	%rbp,%rbp,%r14+	movq	8(%rbx),%rdx+	adcq	%rdi,%r12+	adcq	%rbp,%r13+	adcq	$0,%r14+	xorq	%r15,%r15++	movq	%r8,16(%rsp)+	imulq	8(%rsp),%r8+++	xorq	%rax,%rax+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r9+	adcxq	%rbp,%r10++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r10+	adcxq	%rbp,%r11++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r11+	adcxq	%rbp,%r12++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r12+	adcxq	%rbp,%r13++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r8,%rdx+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15+	adoxq	%rax,%r15+	adoxq	%rax,%rax+++	xorq	%r8,%r8+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	16(%rsp),%rdi+	adoxq	%rbp,%r9++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r9+	adoxq	%rbp,%r10++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r10+	adoxq	%rbp,%r11++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r11+	adoxq	%rbp,%r12++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r12+	adoxq	%rbp,%r13++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	16(%rbx),%rdx+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14+	adcxq	%r8,%r14+	adoxq	%r8,%r15+	adcxq	%r8,%r15+	adoxq	%r8,%rax+	adcxq	%r8,%rax+	movq	%r9,16(%rsp)+	imulq	8(%rsp),%r9+++	xorq	%r8,%r8+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r10+	adcxq	%rbp,%r11++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r11+	adcxq	%rbp,%r12++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r12+	adcxq	%rbp,%r13++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r9,%rdx+	adoxq	%rdi,%r15+	adcxq	%rbp,%rax+	adoxq	%r8,%rax+	adoxq	%r8,%r8+++	xorq	%r9,%r9+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	16(%rsp),%rdi+	adoxq	%rbp,%r10++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r10+	adoxq	%rbp,%r11++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r11+	adoxq	%rbp,%r12++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r12+	adoxq	%rbp,%r13++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	24(%rbx),%rdx+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15+	adcxq	%r9,%r15+	adoxq	%r9,%rax+	adcxq	%r9,%rax+	adoxq	%r9,%r8+	adcxq	%r9,%r8+	movq	%r10,16(%rsp)+	imulq	8(%rsp),%r10+++	xorq	%r9,%r9+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r11+	adcxq	%rbp,%r12++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r12+	adcxq	%rbp,%r13++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r15+	adcxq	%rbp,%rax++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r10,%rdx+	adoxq	%rdi,%rax+	adcxq	%rbp,%r8+	adoxq	%r9,%r8+	adoxq	%r9,%r9+++	xorq	%r10,%r10+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	16(%rsp),%rdi+	adoxq	%rbp,%r11++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r11+	adoxq	%rbp,%r12++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r12+	adoxq	%rbp,%r13++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	32(%rbx),%rdx+	adcxq	%rdi,%r15+	adoxq	%rbp,%rax+	adcxq	%r10,%rax+	adoxq	%r10,%r8+	adcxq	%r10,%r8+	adoxq	%r10,%r9+	adcxq	%r10,%r9+	movq	%r11,16(%rsp)+	imulq	8(%rsp),%r11+++	xorq	%r10,%r10+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r12+	adcxq	%rbp,%r13++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r15+	adcxq	%rbp,%rax++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%rax+	adcxq	%rbp,%r8++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r11,%rdx+	adoxq	%rdi,%r8+	adcxq	%rbp,%r9+	adoxq	%r10,%r9+	adoxq	%r10,%r10+++	xorq	%r11,%r11+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	16(%rsp),%rdi+	adoxq	%rbp,%r12++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r12+	adoxq	%rbp,%r13++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r15+	adoxq	%rbp,%rax++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	40(%rbx),%rdx+	adcxq	%rdi,%rax+	adoxq	%rbp,%r8+	adcxq	%r11,%r8+	adoxq	%r11,%r9+	adcxq	%r11,%r9+	adoxq	%r11,%r10+	adcxq	%r11,%r10+	movq	%r12,16(%rsp)+	imulq	8(%rsp),%r12+++	xorq	%r11,%r11+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r15+	adcxq	%rbp,%rax++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%rax+	adcxq	%rbp,%r8++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r8+	adcxq	%rbp,%r9++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r12,%rdx+	adoxq	%rdi,%r9+	adcxq	%rbp,%r10+	adoxq	%r11,%r10+	adoxq	%r11,%r11+++	xorq	%r12,%r12+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	16(%rsp),%rdi+	adoxq	%rbp,%r13++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r15+	adoxq	%rbp,%rax++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%rax+	adoxq	%rbp,%r8++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	%r13,%rdx+	adcxq	%rdi,%r8+	adoxq	%rbp,%r9+	adcxq	%r12,%r9+	adoxq	%r12,%r10+	adcxq	%r12,%r10+	adoxq	%r12,%r11+	adcxq	%r12,%r11+	imulq	8(%rsp),%rdx+	movq	24(%rsp),%rbx+++	xorq	%r12,%r12+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r15+	adoxq	%rbp,%rax++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%rax+	adoxq	%rbp,%r8+	movq	%r15,%r13++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r8+	adoxq	%rbp,%r9+	movq	%rax,%rsi++	mulxq	40+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r9+	adoxq	%rbp,%r10+	movq	%r14,%rdx+	adcxq	%r12,%r10+	adoxq	%r12,%r11+	leaq	128(%rcx),%rcx+	movq	%r8,%r12+	adcq	$0,%r11+++++	subq	0(%rcx),%r14+	sbbq	8(%rcx),%r15+	movq	%r9,%rdi+	sbbq	16(%rcx),%rax+	sbbq	24(%rcx),%r8+	sbbq	32(%rcx),%r9+	movq	%r10,%rbp+	sbbq	40(%rcx),%r10+	sbbq	$0,%r11++	cmovncq	%r14,%rdx+	cmovcq	%r13,%r15+	cmovcq	%rsi,%rax+	cmovncq	%r8,%r12+	movq	%rdx,0(%rbx)+	cmovncq	%r9,%rdi+	movq	%r15,8(%rbx)+	cmovncq	%r10,%rbp+	movq	%rax,16(%rbx)+	movq	%r12,24(%rbx)+	movq	%rdi,32(%rbx)+	movq	%rbp,40(%rbx)++	.byte	0xf3,0xc3+.cfi_endproc	++.globl	_sqrx_mont_384+.private_extern	_sqrx_mont_384++.p2align	5+_sqrx_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	leaq	-24(%rsp),%rsp+.cfi_adjust_cfa_offset	8*3+++	movq	%rcx,%r8+	leaq	-128(%rdx),%rcx+	movq	0(%rsi),%rdx+	movq	8(%rsi),%r15+	movq	16(%rsi),%rax+	movq	24(%rsi),%r12+	movq	%rdi,16(%rsp)+	movq	32(%rsi),%rdi+	movq	40(%rsi),%rbp++	leaq	(%rsi),%rbx+	movq	%r8,(%rsp)+	leaq	-128(%rsi),%rsi++	mulxq	%rdx,%r8,%r9+	call	__mulx_mont_384++	movq	24(%rsp),%r15+.cfi_restore	%r15+	movq	32(%rsp),%r14+.cfi_restore	%r14+	movq	40(%rsp),%r13+.cfi_restore	%r13+	movq	48(%rsp),%r12+.cfi_restore	%r12+	movq	56(%rsp),%rbx+.cfi_restore	%rbx+	movq	64(%rsp),%rbp+.cfi_restore	%rbp+	leaq	72(%rsp),%rsp+.cfi_adjust_cfa_offset	-8*9++	.byte	0xf3,0xc3+.cfi_endproc	+++.globl	_sqrx_n_mul_mont_384+.private_extern	_sqrx_n_mul_mont_384++.p2align	5+_sqrx_n_mul_mont_384:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	leaq	-40(%rsp),%rsp+.cfi_adjust_cfa_offset	8*5+++	movq	%rdx,%r10+	movq	0(%rsi),%rdx+	movq	8(%rsi),%r15+	movq	16(%rsi),%rax+	movq	%rsi,%rbx+	movq	24(%rsi),%r12+	movq	%rdi,16(%rsp)+	movq	32(%rsi),%rdi+	movq	40(%rsi),%rbp++	movq	%r8,(%rsp)+	movq	%r9,24(%rsp)+	movq	0(%r9),%xmm2++L$oop_sqrx_384:+	movd	%r10d,%xmm1+	leaq	-128(%rbx),%rsi+	leaq	-128(%rcx),%rcx++	mulxq	%rdx,%r8,%r9+	call	__mulx_mont_384++	movd	%xmm1,%r10d+	decl	%r10d+	jnz	L$oop_sqrx_384++	movq	%rdx,%r14+.byte	102,72,15,126,210+	leaq	-128(%rbx),%rsi+	movq	24(%rsp),%rbx+	leaq	-128(%rcx),%rcx++	mulxq	%r14,%r8,%r9+	call	__mulx_mont_384++	movq	40(%rsp),%r15+.cfi_restore	%r15+	movq	48(%rsp),%r14+.cfi_restore	%r14+	movq	56(%rsp),%r13+.cfi_restore	%r13+	movq	64(%rsp),%r12+.cfi_restore	%r12+	movq	72(%rsp),%rbx+.cfi_restore	%rbx+	movq	80(%rsp),%rbp+.cfi_restore	%rbp+	leaq	88(%rsp),%rsp+.cfi_adjust_cfa_offset	-8*11++	.byte	0xf3,0xc3+.cfi_endproc	+++.globl	_sqrx_n_mul_mont_383+.private_extern	_sqrx_n_mul_mont_383++.p2align	5+_sqrx_n_mul_mont_383:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	leaq	-40(%rsp),%rsp+.cfi_adjust_cfa_offset	8*5+++	movq	%rdx,%r10+	movq	0(%rsi),%rdx+	movq	8(%rsi),%r15+	movq	16(%rsi),%rax+	movq	%rsi,%rbx+	movq	24(%rsi),%r12+	movq	%rdi,16(%rsp)+	movq	32(%rsi),%rdi+	movq	40(%rsi),%rbp++	movq	%r8,(%rsp)+	movq	%r9,24(%rsp)+	movq	0(%r9),%xmm2+	leaq	-128(%rcx),%rcx++L$oop_sqrx_383:+	movd	%r10d,%xmm1+	leaq	-128(%rbx),%rsi++	mulxq	%rdx,%r8,%r9+	call	__mulx_mont_383_nonred++	movd	%xmm1,%r10d+	decl	%r10d+	jnz	L$oop_sqrx_383++	movq	%rdx,%r14+.byte	102,72,15,126,210+	leaq	-128(%rbx),%rsi+	movq	24(%rsp),%rbx++	mulxq	%r14,%r8,%r9+	call	__mulx_mont_384++	movq	40(%rsp),%r15+.cfi_restore	%r15+	movq	48(%rsp),%r14+.cfi_restore	%r14+	movq	56(%rsp),%r13+.cfi_restore	%r13+	movq	64(%rsp),%r12+.cfi_restore	%r12+	movq	72(%rsp),%rbx+.cfi_restore	%rbx+	movq	80(%rsp),%rbp+.cfi_restore	%rbp+	leaq	88(%rsp),%rsp+.cfi_adjust_cfa_offset	-8*11++	.byte	0xf3,0xc3+.cfi_endproc	+++.p2align	5+__mulx_mont_383_nonred:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	mulxq	%r15,%r14,%r10+	mulxq	%rax,%r15,%r11+	addq	%r14,%r9+	mulxq	%r12,%rax,%r12+	adcq	%r15,%r10+	mulxq	%rdi,%rdi,%r13+	adcq	%rax,%r11+	mulxq	%rbp,%rbp,%r14+	movq	8(%rbx),%rdx+	adcq	%rdi,%r12+	adcq	%rbp,%r13+	adcq	$0,%r14+	movq	%r8,%rax+	imulq	8(%rsp),%r8+++	xorq	%r15,%r15+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r9+	adcxq	%rbp,%r10++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r10+	adcxq	%rbp,%r11++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r11+	adcxq	%rbp,%r12++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r12+	adcxq	%rbp,%r13++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r8,%rdx+	adoxq	%rdi,%r14+	adcxq	%r15,%rbp+	adoxq	%rbp,%r15+++	xorq	%r8,%r8+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%rax+	adoxq	%rbp,%r9++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r9+	adoxq	%rbp,%r10++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r10+	adoxq	%rbp,%r11++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r11+	adoxq	%rbp,%r12++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r12+	adoxq	%rbp,%r13++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	16(%rbx),%rdx+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14+	adcxq	%rax,%r14+	adoxq	%rax,%r15+	adcxq	%rax,%r15+	movq	%r9,%r8+	imulq	8(%rsp),%r9+++	xorq	%rax,%rax+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r10+	adcxq	%rbp,%r11++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r11+	adcxq	%rbp,%r12++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r12+	adcxq	%rbp,%r13++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r9,%rdx+	adoxq	%rdi,%r15+	adcxq	%rax,%rbp+	adoxq	%rbp,%rax+++	xorq	%r9,%r9+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r8+	adoxq	%rbp,%r10++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r10+	adoxq	%rbp,%r11++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r11+	adoxq	%rbp,%r12++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r12+	adoxq	%rbp,%r13++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	24(%rbx),%rdx+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15+	adcxq	%r8,%r15+	adoxq	%r8,%rax+	adcxq	%r8,%rax+	movq	%r10,%r9+	imulq	8(%rsp),%r10+++	xorq	%r8,%r8+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r11+	adcxq	%rbp,%r12++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r12+	adcxq	%rbp,%r13++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r15+	adcxq	%rbp,%rax++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r10,%rdx+	adoxq	%rdi,%rax+	adcxq	%r8,%rbp+	adoxq	%rbp,%r8+++	xorq	%r10,%r10+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r9+	adoxq	%rbp,%r11++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r11+	adoxq	%rbp,%r12++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r12+	adoxq	%rbp,%r13++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	32(%rbx),%rdx+	adcxq	%rdi,%r15+	adoxq	%rbp,%rax+	adcxq	%r9,%rax+	adoxq	%r9,%r8+	adcxq	%r9,%r8+	movq	%r11,%r10+	imulq	8(%rsp),%r11+++	xorq	%r9,%r9+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r12+	adcxq	%rbp,%r13++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r15+	adcxq	%rbp,%rax++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%rax+	adcxq	%rbp,%r8++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r11,%rdx+	adoxq	%rdi,%r8+	adcxq	%r9,%rbp+	adoxq	%rbp,%r9+++	xorq	%r11,%r11+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r10+	adoxq	%rbp,%r12++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r12+	adoxq	%rbp,%r13++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r15+	adoxq	%rbp,%rax++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	40(%rbx),%rdx+	adcxq	%rdi,%rax+	adoxq	%rbp,%r8+	adcxq	%r10,%r8+	adoxq	%r10,%r9+	adcxq	%r10,%r9+	movq	%r12,%r11+	imulq	8(%rsp),%r12+++	xorq	%r10,%r10+	mulxq	0+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r13+	adcxq	%rbp,%r14++	mulxq	8+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r14+	adcxq	%rbp,%r15++	mulxq	16+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r15+	adcxq	%rbp,%rax++	mulxq	24+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%rax+	adcxq	%rbp,%r8++	mulxq	32+128(%rsi),%rdi,%rbp+	adoxq	%rdi,%r8+	adcxq	%rbp,%r9++	mulxq	40+128(%rsi),%rdi,%rbp+	movq	%r12,%rdx+	adoxq	%rdi,%r9+	adcxq	%r10,%rbp+	adoxq	%rbp,%r10+++	xorq	%r12,%r12+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r11+	adoxq	%rbp,%r13++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r15+	adoxq	%rbp,%rax++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%rax+	adoxq	%rbp,%r8++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	%r13,%rdx+	adcxq	%rdi,%r8+	adoxq	%rbp,%r9+	adcxq	%r11,%r9+	adoxq	%r11,%r10+	adcxq	%r11,%r10+	imulq	8(%rsp),%rdx+	movq	24(%rsp),%rbx+++	xorq	%r12,%r12+	mulxq	0+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r13+	adoxq	%rbp,%r14++	mulxq	8+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r14+	adoxq	%rbp,%r15++	mulxq	16+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r15+	adoxq	%rbp,%rax++	mulxq	24+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%rax+	adoxq	%rbp,%r8++	mulxq	32+128(%rcx),%rdi,%rbp+	adcxq	%rdi,%r8+	adoxq	%rbp,%r9++	mulxq	40+128(%rcx),%rdi,%rbp+	movq	%r14,%rdx+	adcxq	%rdi,%r9+	adoxq	%rbp,%r10+	adcq	$0,%r10+	movq	%r8,%r12++	movq	%r14,0(%rbx)+	movq	%r15,8(%rbx)+	movq	%rax,16(%rbx)+	movq	%r9,%rdi+	movq	%r8,24(%rbx)+	movq	%r9,32(%rbx)+	movq	%r10,40(%rbx)+	movq	%r10,%rbp++	.byte	0xf3,0xc3+.cfi_endproc	++.globl	_sqrx_mont_382x+.private_extern	_sqrx_mont_382x++.p2align	5+_sqrx_mont_382x:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	subq	$136,%rsp+.cfi_adjust_cfa_offset	136+++	movq	%rcx,0(%rsp)+	movq	%rdx,%rcx+	movq	%rdi,16(%rsp)+	movq	%rsi,24(%rsp)+++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	32(%rsi),%r12+	movq	40(%rsi),%r13++	movq	%r8,%r14+	addq	48(%rsi),%r8+	movq	%r9,%r15+	adcq	56(%rsi),%r9+	movq	%r10,%rax+	adcq	64(%rsi),%r10+	movq	%r11,%rdx+	adcq	72(%rsi),%r11+	movq	%r12,%rbx+	adcq	80(%rsi),%r12+	movq	%r13,%rbp+	adcq	88(%rsi),%r13++	subq	48(%rsi),%r14+	sbbq	56(%rsi),%r15+	sbbq	64(%rsi),%rax+	sbbq	72(%rsi),%rdx+	sbbq	80(%rsi),%rbx+	sbbq	88(%rsi),%rbp+	sbbq	%rdi,%rdi++	movq	%r8,32+0(%rsp)+	movq	%r9,32+8(%rsp)+	movq	%r10,32+16(%rsp)+	movq	%r11,32+24(%rsp)+	movq	%r12,32+32(%rsp)+	movq	%r13,32+40(%rsp)++	movq	%r14,32+48(%rsp)+	movq	%r15,32+56(%rsp)+	movq	%rax,32+64(%rsp)+	movq	%rdx,32+72(%rsp)+	movq	%rbx,32+80(%rsp)+	movq	%rbp,32+88(%rsp)+	movq	%rdi,32+96(%rsp)++++	leaq	48(%rsi),%rbx++	movq	48(%rsi),%rdx+	movq	0(%rsi),%r14+	movq	8(%rsi),%r15+	movq	16(%rsi),%rax+	movq	24(%rsi),%r12+	movq	32(%rsi),%rdi+	movq	40(%rsi),%rbp+	leaq	-128(%rsi),%rsi+	leaq	-128(%rcx),%rcx++	mulxq	%r14,%r8,%r9+	call	__mulx_mont_383_nonred+	addq	%rdx,%rdx+	adcq	%r15,%r15+	adcq	%rax,%rax+	adcq	%r12,%r12+	adcq	%rdi,%rdi+	adcq	%rbp,%rbp++	movq	%rdx,48(%rbx)+	movq	%r15,56(%rbx)+	movq	%rax,64(%rbx)+	movq	%r12,72(%rbx)+	movq	%rdi,80(%rbx)+	movq	%rbp,88(%rbx)++	leaq	32-128(%rsp),%rsi+	leaq	32+48(%rsp),%rbx++	movq	32+48(%rsp),%rdx+	movq	32+0(%rsp),%r14+	movq	32+8(%rsp),%r15+	movq	32+16(%rsp),%rax+	movq	32+24(%rsp),%r12+	movq	32+32(%rsp),%rdi+	movq	32+40(%rsp),%rbp++++	mulxq	%r14,%r8,%r9+	call	__mulx_mont_383_nonred+	movq	32+96(%rsp),%r14+	leaq	128(%rcx),%rcx+	movq	32+0(%rsp),%r8+	andq	%r14,%r8+	movq	32+8(%rsp),%r9+	andq	%r14,%r9+	movq	32+16(%rsp),%r10+	andq	%r14,%r10+	movq	32+24(%rsp),%r11+	andq	%r14,%r11+	movq	32+32(%rsp),%r13+	andq	%r14,%r13+	andq	32+40(%rsp),%r14++	subq	%r8,%rdx+	movq	0(%rcx),%r8+	sbbq	%r9,%r15+	movq	8(%rcx),%r9+	sbbq	%r10,%rax+	movq	16(%rcx),%r10+	sbbq	%r11,%r12+	movq	24(%rcx),%r11+	sbbq	%r13,%rdi+	movq	32(%rcx),%r13+	sbbq	%r14,%rbp+	sbbq	%r14,%r14++	andq	%r14,%r8+	andq	%r14,%r9+	andq	%r14,%r10+	andq	%r14,%r11+	andq	%r14,%r13+	andq	40(%rcx),%r14++	addq	%r8,%rdx+	adcq	%r9,%r15+	adcq	%r10,%rax+	adcq	%r11,%r12+	adcq	%r13,%rdi+	adcq	%r14,%rbp++	movq	%rdx,0(%rbx)+	movq	%r15,8(%rbx)+	movq	%rax,16(%rbx)+	movq	%r12,24(%rbx)+	movq	%rdi,32(%rbx)+	movq	%rbp,40(%rbx)+	leaq	136(%rsp),%r8+	movq	0(%r8),%r15+.cfi_restore	%r15+	movq	8(%r8),%r14+.cfi_restore	%r14+	movq	16(%r8),%r13+.cfi_restore	%r13+	movq	24(%r8),%r12+.cfi_restore	%r12+	movq	32(%r8),%rbx+.cfi_restore	%rbx+	movq	40(%r8),%rbp+.cfi_restore	%rbp+	leaq	48(%r8),%rsp+.cfi_adjust_cfa_offset	-136-8*6++	.byte	0xf3,0xc3+.cfi_endproc	+
+ c-source/build/mach-o/sha256-armv8.S view
@@ -0,0 +1,1077 @@+//+// Copyright Supranational LLC+// Licensed under the Apache License, Version 2.0, see LICENSE for details.+// SPDX-License-Identifier: Apache-2.0+//+// ====================================================================+// Written by Andy Polyakov, @dot-asm, initially for the OpenSSL+// project.+// ====================================================================+//+// sha256_block procedure for ARMv8.+//+// This module is stripped of scalar code paths, with raionale that all+// known processors are NEON-capable.+//+// See original module at CRYPTOGAMS for further details.++.text++.align	6++LK256:+.long	0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5+.long	0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5+.long	0xd807aa98,0x12835b01,0x243185be,0x550c7dc3+.long	0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174+.long	0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc+.long	0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da+.long	0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7+.long	0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967+.long	0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13+.long	0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85+.long	0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3+.long	0xd192e819,0xd6990624,0xf40e3585,0x106aa070+.long	0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5+.long	0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3+.long	0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208+.long	0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2+.long	0	//terminator++.byte	83,72,65,50,53,54,32,98,108,111,99,107,32,116,114,97,110,115,102,111,114,109,32,102,111,114,32,65,82,77,118,56,44,32,67,82,89,80,84,79,71,65,77,83,32,98,121,32,64,100,111,116,45,97,115,109,0+.align	2+.align	2+.globl	_blst_sha256_block_armv8++.align	6+_blst_sha256_block_armv8:+Lv8_entry:+	stp	x29,x30,[sp,#-16]!+	add	x29,sp,#0++	ld1	{v0.4s,v1.4s},[x0]+	adr	x3,LK256++Loop_hw:+	ld1	{v4.16b,v5.16b,v6.16b,v7.16b},[x1],#64+	sub	x2,x2,#1+	ld1	{v16.4s},[x3],#16+	rev32	v4.16b,v4.16b+	rev32	v5.16b,v5.16b+	rev32	v6.16b,v6.16b+	rev32	v7.16b,v7.16b+	orr	v18.16b,v0.16b,v0.16b		// offload+	orr	v19.16b,v1.16b,v1.16b+	ld1	{v17.4s},[x3],#16+	add	v16.4s,v16.4s,v4.4s+.long	0x5e2828a4	//sha256su0 v4.16b,v5.16b+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e104020	//sha256h v0.16b,v1.16b,v16.4s+.long	0x5e105041	//sha256h2 v1.16b,v2.16b,v16.4s+.long	0x5e0760c4	//sha256su1 v4.16b,v6.16b,v7.16b+	ld1	{v16.4s},[x3],#16+	add	v17.4s,v17.4s,v5.4s+.long	0x5e2828c5	//sha256su0 v5.16b,v6.16b+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e114020	//sha256h v0.16b,v1.16b,v17.4s+.long	0x5e115041	//sha256h2 v1.16b,v2.16b,v17.4s+.long	0x5e0460e5	//sha256su1 v5.16b,v7.16b,v4.16b+	ld1	{v17.4s},[x3],#16+	add	v16.4s,v16.4s,v6.4s+.long	0x5e2828e6	//sha256su0 v6.16b,v7.16b+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e104020	//sha256h v0.16b,v1.16b,v16.4s+.long	0x5e105041	//sha256h2 v1.16b,v2.16b,v16.4s+.long	0x5e056086	//sha256su1 v6.16b,v4.16b,v5.16b+	ld1	{v16.4s},[x3],#16+	add	v17.4s,v17.4s,v7.4s+.long	0x5e282887	//sha256su0 v7.16b,v4.16b+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e114020	//sha256h v0.16b,v1.16b,v17.4s+.long	0x5e115041	//sha256h2 v1.16b,v2.16b,v17.4s+.long	0x5e0660a7	//sha256su1 v7.16b,v5.16b,v6.16b+	ld1	{v17.4s},[x3],#16+	add	v16.4s,v16.4s,v4.4s+.long	0x5e2828a4	//sha256su0 v4.16b,v5.16b+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e104020	//sha256h v0.16b,v1.16b,v16.4s+.long	0x5e105041	//sha256h2 v1.16b,v2.16b,v16.4s+.long	0x5e0760c4	//sha256su1 v4.16b,v6.16b,v7.16b+	ld1	{v16.4s},[x3],#16+	add	v17.4s,v17.4s,v5.4s+.long	0x5e2828c5	//sha256su0 v5.16b,v6.16b+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e114020	//sha256h v0.16b,v1.16b,v17.4s+.long	0x5e115041	//sha256h2 v1.16b,v2.16b,v17.4s+.long	0x5e0460e5	//sha256su1 v5.16b,v7.16b,v4.16b+	ld1	{v17.4s},[x3],#16+	add	v16.4s,v16.4s,v6.4s+.long	0x5e2828e6	//sha256su0 v6.16b,v7.16b+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e104020	//sha256h v0.16b,v1.16b,v16.4s+.long	0x5e105041	//sha256h2 v1.16b,v2.16b,v16.4s+.long	0x5e056086	//sha256su1 v6.16b,v4.16b,v5.16b+	ld1	{v16.4s},[x3],#16+	add	v17.4s,v17.4s,v7.4s+.long	0x5e282887	//sha256su0 v7.16b,v4.16b+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e114020	//sha256h v0.16b,v1.16b,v17.4s+.long	0x5e115041	//sha256h2 v1.16b,v2.16b,v17.4s+.long	0x5e0660a7	//sha256su1 v7.16b,v5.16b,v6.16b+	ld1	{v17.4s},[x3],#16+	add	v16.4s,v16.4s,v4.4s+.long	0x5e2828a4	//sha256su0 v4.16b,v5.16b+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e104020	//sha256h v0.16b,v1.16b,v16.4s+.long	0x5e105041	//sha256h2 v1.16b,v2.16b,v16.4s+.long	0x5e0760c4	//sha256su1 v4.16b,v6.16b,v7.16b+	ld1	{v16.4s},[x3],#16+	add	v17.4s,v17.4s,v5.4s+.long	0x5e2828c5	//sha256su0 v5.16b,v6.16b+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e114020	//sha256h v0.16b,v1.16b,v17.4s+.long	0x5e115041	//sha256h2 v1.16b,v2.16b,v17.4s+.long	0x5e0460e5	//sha256su1 v5.16b,v7.16b,v4.16b+	ld1	{v17.4s},[x3],#16+	add	v16.4s,v16.4s,v6.4s+.long	0x5e2828e6	//sha256su0 v6.16b,v7.16b+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e104020	//sha256h v0.16b,v1.16b,v16.4s+.long	0x5e105041	//sha256h2 v1.16b,v2.16b,v16.4s+.long	0x5e056086	//sha256su1 v6.16b,v4.16b,v5.16b+	ld1	{v16.4s},[x3],#16+	add	v17.4s,v17.4s,v7.4s+.long	0x5e282887	//sha256su0 v7.16b,v4.16b+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e114020	//sha256h v0.16b,v1.16b,v17.4s+.long	0x5e115041	//sha256h2 v1.16b,v2.16b,v17.4s+.long	0x5e0660a7	//sha256su1 v7.16b,v5.16b,v6.16b+	ld1	{v17.4s},[x3],#16+	add	v16.4s,v16.4s,v4.4s+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e104020	//sha256h v0.16b,v1.16b,v16.4s+.long	0x5e105041	//sha256h2 v1.16b,v2.16b,v16.4s++	ld1	{v16.4s},[x3],#16+	add	v17.4s,v17.4s,v5.4s+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e114020	//sha256h v0.16b,v1.16b,v17.4s+.long	0x5e115041	//sha256h2 v1.16b,v2.16b,v17.4s++	ld1	{v17.4s},[x3]+	add	v16.4s,v16.4s,v6.4s+	sub	x3,x3,#64*4-16	// rewind+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e104020	//sha256h v0.16b,v1.16b,v16.4s+.long	0x5e105041	//sha256h2 v1.16b,v2.16b,v16.4s++	add	v17.4s,v17.4s,v7.4s+	orr	v2.16b,v0.16b,v0.16b+.long	0x5e114020	//sha256h v0.16b,v1.16b,v17.4s+.long	0x5e115041	//sha256h2 v1.16b,v2.16b,v17.4s++	add	v0.4s,v0.4s,v18.4s+	add	v1.4s,v1.4s,v19.4s++	cbnz	x2,Loop_hw++	st1	{v0.4s,v1.4s},[x0]++	ldr	x29,[sp],#16+	ret++.globl	_blst_sha256_block_data_order++.align	4+_blst_sha256_block_data_order:+	stp	x29, x30, [sp, #-16]!+	mov	x29, sp+	sub	sp,sp,#16*4++	adr	x16,LK256+	add	x2,x1,x2,lsl#6	// len to point at the end of inp++	ld1	{v0.16b},[x1], #16+	ld1	{v1.16b},[x1], #16+	ld1	{v2.16b},[x1], #16+	ld1	{v3.16b},[x1], #16+	ld1	{v4.4s},[x16], #16+	ld1	{v5.4s},[x16], #16+	ld1	{v6.4s},[x16], #16+	ld1	{v7.4s},[x16], #16+	rev32	v0.16b,v0.16b		// yes, even on+	rev32	v1.16b,v1.16b		// big-endian+	rev32	v2.16b,v2.16b+	rev32	v3.16b,v3.16b+	mov	x17,sp+	add	v4.4s,v4.4s,v0.4s+	add	v5.4s,v5.4s,v1.4s+	add	v6.4s,v6.4s,v2.4s+	st1	{v4.4s,v5.4s},[x17], #32+	add	v7.4s,v7.4s,v3.4s+	st1	{v6.4s,v7.4s},[x17]+	sub	x17,x17,#32++	ldp	w3,w4,[x0]+	ldp	w5,w6,[x0,#8]+	ldp	w7,w8,[x0,#16]+	ldp	w9,w10,[x0,#24]+	ldr	w12,[sp,#0]+	mov	w13,wzr+	eor	w14,w4,w5+	mov	w15,wzr+	b	L_00_48++.align	4+L_00_48:+	ext	v4.16b,v0.16b,v1.16b,#4+	add	w10,w10,w12+	add	w3,w3,w15+	and	w12,w8,w7+	bic	w15,w9,w7+	ext	v7.16b,v2.16b,v3.16b,#4+	eor	w11,w7,w7,ror#5+	add	w3,w3,w13+	mov	d19,v3.d[1]+	orr	w12,w12,w15+	eor	w11,w11,w7,ror#19+	ushr	v6.4s,v4.4s,#7+	eor	w15,w3,w3,ror#11+	ushr	v5.4s,v4.4s,#3+	add	w10,w10,w12+	add	v0.4s,v0.4s,v7.4s+	ror	w11,w11,#6+	sli	v6.4s,v4.4s,#25+	eor	w13,w3,w4+	eor	w15,w15,w3,ror#20+	ushr	v7.4s,v4.4s,#18+	add	w10,w10,w11+	ldr	w12,[sp,#4]+	and	w14,w14,w13+	eor	v5.16b,v5.16b,v6.16b+	ror	w15,w15,#2+	add	w6,w6,w10+	sli	v7.4s,v4.4s,#14+	eor	w14,w14,w4+	ushr	v16.4s,v19.4s,#17+	add	w9,w9,w12+	add	w10,w10,w15+	and	w12,w7,w6+	eor	v5.16b,v5.16b,v7.16b+	bic	w15,w8,w6+	eor	w11,w6,w6,ror#5+	sli	v16.4s,v19.4s,#15+	add	w10,w10,w14+	orr	w12,w12,w15+	ushr	v17.4s,v19.4s,#10+	eor	w11,w11,w6,ror#19+	eor	w15,w10,w10,ror#11+	ushr	v7.4s,v19.4s,#19+	add	w9,w9,w12+	ror	w11,w11,#6+	add	v0.4s,v0.4s,v5.4s+	eor	w14,w10,w3+	eor	w15,w15,w10,ror#20+	sli	v7.4s,v19.4s,#13+	add	w9,w9,w11+	ldr	w12,[sp,#8]+	and	w13,w13,w14+	eor	v17.16b,v17.16b,v16.16b+	ror	w15,w15,#2+	add	w5,w5,w9+	eor	w13,w13,w3+	eor	v17.16b,v17.16b,v7.16b+	add	w8,w8,w12+	add	w9,w9,w15+	and	w12,w6,w5+	add	v0.4s,v0.4s,v17.4s+	bic	w15,w7,w5+	eor	w11,w5,w5,ror#5+	add	w9,w9,w13+	ushr	v18.4s,v0.4s,#17+	orr	w12,w12,w15+	ushr	v19.4s,v0.4s,#10+	eor	w11,w11,w5,ror#19+	eor	w15,w9,w9,ror#11+	sli	v18.4s,v0.4s,#15+	add	w8,w8,w12+	ushr	v17.4s,v0.4s,#19+	ror	w11,w11,#6+	eor	w13,w9,w10+	eor	v19.16b,v19.16b,v18.16b+	eor	w15,w15,w9,ror#20+	add	w8,w8,w11+	sli	v17.4s,v0.4s,#13+	ldr	w12,[sp,#12]+	and	w14,w14,w13+	ror	w15,w15,#2+	ld1	{v4.4s},[x16], #16+	add	w4,w4,w8+	eor	v19.16b,v19.16b,v17.16b+	eor	w14,w14,w10+	eor	v17.16b,v17.16b,v17.16b+	add	w7,w7,w12+	add	w8,w8,w15+	and	w12,w5,w4+	mov	v17.d[1],v19.d[0]+	bic	w15,w6,w4+	eor	w11,w4,w4,ror#5+	add	w8,w8,w14+	add	v0.4s,v0.4s,v17.4s+	orr	w12,w12,w15+	eor	w11,w11,w4,ror#19+	eor	w15,w8,w8,ror#11+	add	v4.4s,v4.4s,v0.4s+	add	w7,w7,w12+	ror	w11,w11,#6+	eor	w14,w8,w9+	eor	w15,w15,w8,ror#20+	add	w7,w7,w11+	ldr	w12,[sp,#16]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w3,w3,w7+	eor	w13,w13,w9+	st1	{v4.4s},[x17], #16+	ext	v4.16b,v1.16b,v2.16b,#4+	add	w6,w6,w12+	add	w7,w7,w15+	and	w12,w4,w3+	bic	w15,w5,w3+	ext	v7.16b,v3.16b,v0.16b,#4+	eor	w11,w3,w3,ror#5+	add	w7,w7,w13+	mov	d19,v0.d[1]+	orr	w12,w12,w15+	eor	w11,w11,w3,ror#19+	ushr	v6.4s,v4.4s,#7+	eor	w15,w7,w7,ror#11+	ushr	v5.4s,v4.4s,#3+	add	w6,w6,w12+	add	v1.4s,v1.4s,v7.4s+	ror	w11,w11,#6+	sli	v6.4s,v4.4s,#25+	eor	w13,w7,w8+	eor	w15,w15,w7,ror#20+	ushr	v7.4s,v4.4s,#18+	add	w6,w6,w11+	ldr	w12,[sp,#20]+	and	w14,w14,w13+	eor	v5.16b,v5.16b,v6.16b+	ror	w15,w15,#2+	add	w10,w10,w6+	sli	v7.4s,v4.4s,#14+	eor	w14,w14,w8+	ushr	v16.4s,v19.4s,#17+	add	w5,w5,w12+	add	w6,w6,w15+	and	w12,w3,w10+	eor	v5.16b,v5.16b,v7.16b+	bic	w15,w4,w10+	eor	w11,w10,w10,ror#5+	sli	v16.4s,v19.4s,#15+	add	w6,w6,w14+	orr	w12,w12,w15+	ushr	v17.4s,v19.4s,#10+	eor	w11,w11,w10,ror#19+	eor	w15,w6,w6,ror#11+	ushr	v7.4s,v19.4s,#19+	add	w5,w5,w12+	ror	w11,w11,#6+	add	v1.4s,v1.4s,v5.4s+	eor	w14,w6,w7+	eor	w15,w15,w6,ror#20+	sli	v7.4s,v19.4s,#13+	add	w5,w5,w11+	ldr	w12,[sp,#24]+	and	w13,w13,w14+	eor	v17.16b,v17.16b,v16.16b+	ror	w15,w15,#2+	add	w9,w9,w5+	eor	w13,w13,w7+	eor	v17.16b,v17.16b,v7.16b+	add	w4,w4,w12+	add	w5,w5,w15+	and	w12,w10,w9+	add	v1.4s,v1.4s,v17.4s+	bic	w15,w3,w9+	eor	w11,w9,w9,ror#5+	add	w5,w5,w13+	ushr	v18.4s,v1.4s,#17+	orr	w12,w12,w15+	ushr	v19.4s,v1.4s,#10+	eor	w11,w11,w9,ror#19+	eor	w15,w5,w5,ror#11+	sli	v18.4s,v1.4s,#15+	add	w4,w4,w12+	ushr	v17.4s,v1.4s,#19+	ror	w11,w11,#6+	eor	w13,w5,w6+	eor	v19.16b,v19.16b,v18.16b+	eor	w15,w15,w5,ror#20+	add	w4,w4,w11+	sli	v17.4s,v1.4s,#13+	ldr	w12,[sp,#28]+	and	w14,w14,w13+	ror	w15,w15,#2+	ld1	{v4.4s},[x16], #16+	add	w8,w8,w4+	eor	v19.16b,v19.16b,v17.16b+	eor	w14,w14,w6+	eor	v17.16b,v17.16b,v17.16b+	add	w3,w3,w12+	add	w4,w4,w15+	and	w12,w9,w8+	mov	v17.d[1],v19.d[0]+	bic	w15,w10,w8+	eor	w11,w8,w8,ror#5+	add	w4,w4,w14+	add	v1.4s,v1.4s,v17.4s+	orr	w12,w12,w15+	eor	w11,w11,w8,ror#19+	eor	w15,w4,w4,ror#11+	add	v4.4s,v4.4s,v1.4s+	add	w3,w3,w12+	ror	w11,w11,#6+	eor	w14,w4,w5+	eor	w15,w15,w4,ror#20+	add	w3,w3,w11+	ldr	w12,[sp,#32]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w7,w7,w3+	eor	w13,w13,w5+	st1	{v4.4s},[x17], #16+	ext	v4.16b,v2.16b,v3.16b,#4+	add	w10,w10,w12+	add	w3,w3,w15+	and	w12,w8,w7+	bic	w15,w9,w7+	ext	v7.16b,v0.16b,v1.16b,#4+	eor	w11,w7,w7,ror#5+	add	w3,w3,w13+	mov	d19,v1.d[1]+	orr	w12,w12,w15+	eor	w11,w11,w7,ror#19+	ushr	v6.4s,v4.4s,#7+	eor	w15,w3,w3,ror#11+	ushr	v5.4s,v4.4s,#3+	add	w10,w10,w12+	add	v2.4s,v2.4s,v7.4s+	ror	w11,w11,#6+	sli	v6.4s,v4.4s,#25+	eor	w13,w3,w4+	eor	w15,w15,w3,ror#20+	ushr	v7.4s,v4.4s,#18+	add	w10,w10,w11+	ldr	w12,[sp,#36]+	and	w14,w14,w13+	eor	v5.16b,v5.16b,v6.16b+	ror	w15,w15,#2+	add	w6,w6,w10+	sli	v7.4s,v4.4s,#14+	eor	w14,w14,w4+	ushr	v16.4s,v19.4s,#17+	add	w9,w9,w12+	add	w10,w10,w15+	and	w12,w7,w6+	eor	v5.16b,v5.16b,v7.16b+	bic	w15,w8,w6+	eor	w11,w6,w6,ror#5+	sli	v16.4s,v19.4s,#15+	add	w10,w10,w14+	orr	w12,w12,w15+	ushr	v17.4s,v19.4s,#10+	eor	w11,w11,w6,ror#19+	eor	w15,w10,w10,ror#11+	ushr	v7.4s,v19.4s,#19+	add	w9,w9,w12+	ror	w11,w11,#6+	add	v2.4s,v2.4s,v5.4s+	eor	w14,w10,w3+	eor	w15,w15,w10,ror#20+	sli	v7.4s,v19.4s,#13+	add	w9,w9,w11+	ldr	w12,[sp,#40]+	and	w13,w13,w14+	eor	v17.16b,v17.16b,v16.16b+	ror	w15,w15,#2+	add	w5,w5,w9+	eor	w13,w13,w3+	eor	v17.16b,v17.16b,v7.16b+	add	w8,w8,w12+	add	w9,w9,w15+	and	w12,w6,w5+	add	v2.4s,v2.4s,v17.4s+	bic	w15,w7,w5+	eor	w11,w5,w5,ror#5+	add	w9,w9,w13+	ushr	v18.4s,v2.4s,#17+	orr	w12,w12,w15+	ushr	v19.4s,v2.4s,#10+	eor	w11,w11,w5,ror#19+	eor	w15,w9,w9,ror#11+	sli	v18.4s,v2.4s,#15+	add	w8,w8,w12+	ushr	v17.4s,v2.4s,#19+	ror	w11,w11,#6+	eor	w13,w9,w10+	eor	v19.16b,v19.16b,v18.16b+	eor	w15,w15,w9,ror#20+	add	w8,w8,w11+	sli	v17.4s,v2.4s,#13+	ldr	w12,[sp,#44]+	and	w14,w14,w13+	ror	w15,w15,#2+	ld1	{v4.4s},[x16], #16+	add	w4,w4,w8+	eor	v19.16b,v19.16b,v17.16b+	eor	w14,w14,w10+	eor	v17.16b,v17.16b,v17.16b+	add	w7,w7,w12+	add	w8,w8,w15+	and	w12,w5,w4+	mov	v17.d[1],v19.d[0]+	bic	w15,w6,w4+	eor	w11,w4,w4,ror#5+	add	w8,w8,w14+	add	v2.4s,v2.4s,v17.4s+	orr	w12,w12,w15+	eor	w11,w11,w4,ror#19+	eor	w15,w8,w8,ror#11+	add	v4.4s,v4.4s,v2.4s+	add	w7,w7,w12+	ror	w11,w11,#6+	eor	w14,w8,w9+	eor	w15,w15,w8,ror#20+	add	w7,w7,w11+	ldr	w12,[sp,#48]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w3,w3,w7+	eor	w13,w13,w9+	st1	{v4.4s},[x17], #16+	ext	v4.16b,v3.16b,v0.16b,#4+	add	w6,w6,w12+	add	w7,w7,w15+	and	w12,w4,w3+	bic	w15,w5,w3+	ext	v7.16b,v1.16b,v2.16b,#4+	eor	w11,w3,w3,ror#5+	add	w7,w7,w13+	mov	d19,v2.d[1]+	orr	w12,w12,w15+	eor	w11,w11,w3,ror#19+	ushr	v6.4s,v4.4s,#7+	eor	w15,w7,w7,ror#11+	ushr	v5.4s,v4.4s,#3+	add	w6,w6,w12+	add	v3.4s,v3.4s,v7.4s+	ror	w11,w11,#6+	sli	v6.4s,v4.4s,#25+	eor	w13,w7,w8+	eor	w15,w15,w7,ror#20+	ushr	v7.4s,v4.4s,#18+	add	w6,w6,w11+	ldr	w12,[sp,#52]+	and	w14,w14,w13+	eor	v5.16b,v5.16b,v6.16b+	ror	w15,w15,#2+	add	w10,w10,w6+	sli	v7.4s,v4.4s,#14+	eor	w14,w14,w8+	ushr	v16.4s,v19.4s,#17+	add	w5,w5,w12+	add	w6,w6,w15+	and	w12,w3,w10+	eor	v5.16b,v5.16b,v7.16b+	bic	w15,w4,w10+	eor	w11,w10,w10,ror#5+	sli	v16.4s,v19.4s,#15+	add	w6,w6,w14+	orr	w12,w12,w15+	ushr	v17.4s,v19.4s,#10+	eor	w11,w11,w10,ror#19+	eor	w15,w6,w6,ror#11+	ushr	v7.4s,v19.4s,#19+	add	w5,w5,w12+	ror	w11,w11,#6+	add	v3.4s,v3.4s,v5.4s+	eor	w14,w6,w7+	eor	w15,w15,w6,ror#20+	sli	v7.4s,v19.4s,#13+	add	w5,w5,w11+	ldr	w12,[sp,#56]+	and	w13,w13,w14+	eor	v17.16b,v17.16b,v16.16b+	ror	w15,w15,#2+	add	w9,w9,w5+	eor	w13,w13,w7+	eor	v17.16b,v17.16b,v7.16b+	add	w4,w4,w12+	add	w5,w5,w15+	and	w12,w10,w9+	add	v3.4s,v3.4s,v17.4s+	bic	w15,w3,w9+	eor	w11,w9,w9,ror#5+	add	w5,w5,w13+	ushr	v18.4s,v3.4s,#17+	orr	w12,w12,w15+	ushr	v19.4s,v3.4s,#10+	eor	w11,w11,w9,ror#19+	eor	w15,w5,w5,ror#11+	sli	v18.4s,v3.4s,#15+	add	w4,w4,w12+	ushr	v17.4s,v3.4s,#19+	ror	w11,w11,#6+	eor	w13,w5,w6+	eor	v19.16b,v19.16b,v18.16b+	eor	w15,w15,w5,ror#20+	add	w4,w4,w11+	sli	v17.4s,v3.4s,#13+	ldr	w12,[sp,#60]+	and	w14,w14,w13+	ror	w15,w15,#2+	ld1	{v4.4s},[x16], #16+	add	w8,w8,w4+	eor	v19.16b,v19.16b,v17.16b+	eor	w14,w14,w6+	eor	v17.16b,v17.16b,v17.16b+	add	w3,w3,w12+	add	w4,w4,w15+	and	w12,w9,w8+	mov	v17.d[1],v19.d[0]+	bic	w15,w10,w8+	eor	w11,w8,w8,ror#5+	add	w4,w4,w14+	add	v3.4s,v3.4s,v17.4s+	orr	w12,w12,w15+	eor	w11,w11,w8,ror#19+	eor	w15,w4,w4,ror#11+	add	v4.4s,v4.4s,v3.4s+	add	w3,w3,w12+	ror	w11,w11,#6+	eor	w14,w4,w5+	eor	w15,w15,w4,ror#20+	add	w3,w3,w11+	ldr	w12,[x16]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w7,w7,w3+	eor	w13,w13,w5+	st1	{v4.4s},[x17], #16+	cmp	w12,#0				// check for K256 terminator+	ldr	w12,[sp,#0]+	sub	x17,x17,#64+	bne	L_00_48++	sub	x16,x16,#256		// rewind x16+	cmp	x1,x2+	mov	x17, #64+	csel	x17, x17, xzr, eq+	sub	x1,x1,x17			// avoid SEGV+	mov	x17,sp+	add	w10,w10,w12+	add	w3,w3,w15+	and	w12,w8,w7+	ld1	{v0.16b},[x1],#16+	bic	w15,w9,w7+	eor	w11,w7,w7,ror#5+	ld1	{v4.4s},[x16],#16+	add	w3,w3,w13+	orr	w12,w12,w15+	eor	w11,w11,w7,ror#19+	eor	w15,w3,w3,ror#11+	rev32	v0.16b,v0.16b+	add	w10,w10,w12+	ror	w11,w11,#6+	eor	w13,w3,w4+	eor	w15,w15,w3,ror#20+	add	v4.4s,v4.4s,v0.4s+	add	w10,w10,w11+	ldr	w12,[sp,#4]+	and	w14,w14,w13+	ror	w15,w15,#2+	add	w6,w6,w10+	eor	w14,w14,w4+	add	w9,w9,w12+	add	w10,w10,w15+	and	w12,w7,w6+	bic	w15,w8,w6+	eor	w11,w6,w6,ror#5+	add	w10,w10,w14+	orr	w12,w12,w15+	eor	w11,w11,w6,ror#19+	eor	w15,w10,w10,ror#11+	add	w9,w9,w12+	ror	w11,w11,#6+	eor	w14,w10,w3+	eor	w15,w15,w10,ror#20+	add	w9,w9,w11+	ldr	w12,[sp,#8]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w5,w5,w9+	eor	w13,w13,w3+	add	w8,w8,w12+	add	w9,w9,w15+	and	w12,w6,w5+	bic	w15,w7,w5+	eor	w11,w5,w5,ror#5+	add	w9,w9,w13+	orr	w12,w12,w15+	eor	w11,w11,w5,ror#19+	eor	w15,w9,w9,ror#11+	add	w8,w8,w12+	ror	w11,w11,#6+	eor	w13,w9,w10+	eor	w15,w15,w9,ror#20+	add	w8,w8,w11+	ldr	w12,[sp,#12]+	and	w14,w14,w13+	ror	w15,w15,#2+	add	w4,w4,w8+	eor	w14,w14,w10+	add	w7,w7,w12+	add	w8,w8,w15+	and	w12,w5,w4+	bic	w15,w6,w4+	eor	w11,w4,w4,ror#5+	add	w8,w8,w14+	orr	w12,w12,w15+	eor	w11,w11,w4,ror#19+	eor	w15,w8,w8,ror#11+	add	w7,w7,w12+	ror	w11,w11,#6+	eor	w14,w8,w9+	eor	w15,w15,w8,ror#20+	add	w7,w7,w11+	ldr	w12,[sp,#16]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w3,w3,w7+	eor	w13,w13,w9+	st1	{v4.4s},[x17], #16+	add	w6,w6,w12+	add	w7,w7,w15+	and	w12,w4,w3+	ld1	{v1.16b},[x1],#16+	bic	w15,w5,w3+	eor	w11,w3,w3,ror#5+	ld1	{v4.4s},[x16],#16+	add	w7,w7,w13+	orr	w12,w12,w15+	eor	w11,w11,w3,ror#19+	eor	w15,w7,w7,ror#11+	rev32	v1.16b,v1.16b+	add	w6,w6,w12+	ror	w11,w11,#6+	eor	w13,w7,w8+	eor	w15,w15,w7,ror#20+	add	v4.4s,v4.4s,v1.4s+	add	w6,w6,w11+	ldr	w12,[sp,#20]+	and	w14,w14,w13+	ror	w15,w15,#2+	add	w10,w10,w6+	eor	w14,w14,w8+	add	w5,w5,w12+	add	w6,w6,w15+	and	w12,w3,w10+	bic	w15,w4,w10+	eor	w11,w10,w10,ror#5+	add	w6,w6,w14+	orr	w12,w12,w15+	eor	w11,w11,w10,ror#19+	eor	w15,w6,w6,ror#11+	add	w5,w5,w12+	ror	w11,w11,#6+	eor	w14,w6,w7+	eor	w15,w15,w6,ror#20+	add	w5,w5,w11+	ldr	w12,[sp,#24]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w9,w9,w5+	eor	w13,w13,w7+	add	w4,w4,w12+	add	w5,w5,w15+	and	w12,w10,w9+	bic	w15,w3,w9+	eor	w11,w9,w9,ror#5+	add	w5,w5,w13+	orr	w12,w12,w15+	eor	w11,w11,w9,ror#19+	eor	w15,w5,w5,ror#11+	add	w4,w4,w12+	ror	w11,w11,#6+	eor	w13,w5,w6+	eor	w15,w15,w5,ror#20+	add	w4,w4,w11+	ldr	w12,[sp,#28]+	and	w14,w14,w13+	ror	w15,w15,#2+	add	w8,w8,w4+	eor	w14,w14,w6+	add	w3,w3,w12+	add	w4,w4,w15+	and	w12,w9,w8+	bic	w15,w10,w8+	eor	w11,w8,w8,ror#5+	add	w4,w4,w14+	orr	w12,w12,w15+	eor	w11,w11,w8,ror#19+	eor	w15,w4,w4,ror#11+	add	w3,w3,w12+	ror	w11,w11,#6+	eor	w14,w4,w5+	eor	w15,w15,w4,ror#20+	add	w3,w3,w11+	ldr	w12,[sp,#32]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w7,w7,w3+	eor	w13,w13,w5+	st1	{v4.4s},[x17], #16+	add	w10,w10,w12+	add	w3,w3,w15+	and	w12,w8,w7+	ld1	{v2.16b},[x1],#16+	bic	w15,w9,w7+	eor	w11,w7,w7,ror#5+	ld1	{v4.4s},[x16],#16+	add	w3,w3,w13+	orr	w12,w12,w15+	eor	w11,w11,w7,ror#19+	eor	w15,w3,w3,ror#11+	rev32	v2.16b,v2.16b+	add	w10,w10,w12+	ror	w11,w11,#6+	eor	w13,w3,w4+	eor	w15,w15,w3,ror#20+	add	v4.4s,v4.4s,v2.4s+	add	w10,w10,w11+	ldr	w12,[sp,#36]+	and	w14,w14,w13+	ror	w15,w15,#2+	add	w6,w6,w10+	eor	w14,w14,w4+	add	w9,w9,w12+	add	w10,w10,w15+	and	w12,w7,w6+	bic	w15,w8,w6+	eor	w11,w6,w6,ror#5+	add	w10,w10,w14+	orr	w12,w12,w15+	eor	w11,w11,w6,ror#19+	eor	w15,w10,w10,ror#11+	add	w9,w9,w12+	ror	w11,w11,#6+	eor	w14,w10,w3+	eor	w15,w15,w10,ror#20+	add	w9,w9,w11+	ldr	w12,[sp,#40]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w5,w5,w9+	eor	w13,w13,w3+	add	w8,w8,w12+	add	w9,w9,w15+	and	w12,w6,w5+	bic	w15,w7,w5+	eor	w11,w5,w5,ror#5+	add	w9,w9,w13+	orr	w12,w12,w15+	eor	w11,w11,w5,ror#19+	eor	w15,w9,w9,ror#11+	add	w8,w8,w12+	ror	w11,w11,#6+	eor	w13,w9,w10+	eor	w15,w15,w9,ror#20+	add	w8,w8,w11+	ldr	w12,[sp,#44]+	and	w14,w14,w13+	ror	w15,w15,#2+	add	w4,w4,w8+	eor	w14,w14,w10+	add	w7,w7,w12+	add	w8,w8,w15+	and	w12,w5,w4+	bic	w15,w6,w4+	eor	w11,w4,w4,ror#5+	add	w8,w8,w14+	orr	w12,w12,w15+	eor	w11,w11,w4,ror#19+	eor	w15,w8,w8,ror#11+	add	w7,w7,w12+	ror	w11,w11,#6+	eor	w14,w8,w9+	eor	w15,w15,w8,ror#20+	add	w7,w7,w11+	ldr	w12,[sp,#48]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w3,w3,w7+	eor	w13,w13,w9+	st1	{v4.4s},[x17], #16+	add	w6,w6,w12+	add	w7,w7,w15+	and	w12,w4,w3+	ld1	{v3.16b},[x1],#16+	bic	w15,w5,w3+	eor	w11,w3,w3,ror#5+	ld1	{v4.4s},[x16],#16+	add	w7,w7,w13+	orr	w12,w12,w15+	eor	w11,w11,w3,ror#19+	eor	w15,w7,w7,ror#11+	rev32	v3.16b,v3.16b+	add	w6,w6,w12+	ror	w11,w11,#6+	eor	w13,w7,w8+	eor	w15,w15,w7,ror#20+	add	v4.4s,v4.4s,v3.4s+	add	w6,w6,w11+	ldr	w12,[sp,#52]+	and	w14,w14,w13+	ror	w15,w15,#2+	add	w10,w10,w6+	eor	w14,w14,w8+	add	w5,w5,w12+	add	w6,w6,w15+	and	w12,w3,w10+	bic	w15,w4,w10+	eor	w11,w10,w10,ror#5+	add	w6,w6,w14+	orr	w12,w12,w15+	eor	w11,w11,w10,ror#19+	eor	w15,w6,w6,ror#11+	add	w5,w5,w12+	ror	w11,w11,#6+	eor	w14,w6,w7+	eor	w15,w15,w6,ror#20+	add	w5,w5,w11+	ldr	w12,[sp,#56]+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w9,w9,w5+	eor	w13,w13,w7+	add	w4,w4,w12+	add	w5,w5,w15+	and	w12,w10,w9+	bic	w15,w3,w9+	eor	w11,w9,w9,ror#5+	add	w5,w5,w13+	orr	w12,w12,w15+	eor	w11,w11,w9,ror#19+	eor	w15,w5,w5,ror#11+	add	w4,w4,w12+	ror	w11,w11,#6+	eor	w13,w5,w6+	eor	w15,w15,w5,ror#20+	add	w4,w4,w11+	ldr	w12,[sp,#60]+	and	w14,w14,w13+	ror	w15,w15,#2+	add	w8,w8,w4+	eor	w14,w14,w6+	add	w3,w3,w12+	add	w4,w4,w15+	and	w12,w9,w8+	bic	w15,w10,w8+	eor	w11,w8,w8,ror#5+	add	w4,w4,w14+	orr	w12,w12,w15+	eor	w11,w11,w8,ror#19+	eor	w15,w4,w4,ror#11+	add	w3,w3,w12+	ror	w11,w11,#6+	eor	w14,w4,w5+	eor	w15,w15,w4,ror#20+	add	w3,w3,w11+	and	w13,w13,w14+	ror	w15,w15,#2+	add	w7,w7,w3+	eor	w13,w13,w5+	st1	{v4.4s},[x17], #16+	add	w3,w3,w15			// h+=Sigma0(a) from the past+	ldp	w11,w12,[x0,#0]+	add	w3,w3,w13			// h+=Maj(a,b,c) from the past+	ldp	w13,w14,[x0,#8]+	add	w3,w3,w11			// accumulate+	add	w4,w4,w12+	ldp	w11,w12,[x0,#16]+	add	w5,w5,w13+	add	w6,w6,w14+	ldp	w13,w14,[x0,#24]+	add	w7,w7,w11+	add	w8,w8,w12+	ldr	w12,[sp,#0]+	stp	w3,w4,[x0,#0]+	add	w9,w9,w13+	mov	w13,wzr+	stp	w5,w6,[x0,#8]+	add	w10,w10,w14+	stp	w7,w8,[x0,#16]+	eor	w14,w4,w5+	stp	w9,w10,[x0,#24]+	mov	w15,wzr+	mov	x17,sp+	b.ne	L_00_48++	ldr	x29,[x29]+	add	sp,sp,#16*4+16+	ret++.globl	_blst_sha256_emit+.private_extern	_blst_sha256_emit++.align	4+_blst_sha256_emit:+	ldp	x4,x5,[x1]+	ldp	x6,x7,[x1,#16]+#ifndef	__AARCH64EB__+	rev	x4,x4+	rev	x5,x5+	rev	x6,x6+	rev	x7,x7+#endif+	str	w4,[x0,#4]+	lsr	x4,x4,#32+	str	w5,[x0,#12]+	lsr	x5,x5,#32+	str	w6,[x0,#20]+	lsr	x6,x6,#32+	str	w7,[x0,#28]+	lsr	x7,x7,#32+	str	w4,[x0,#0]+	str	w5,[x0,#8]+	str	w6,[x0,#16]+	str	w7,[x0,#24]+	ret+++.globl	_blst_sha256_bcopy+.private_extern	_blst_sha256_bcopy++.align	4+_blst_sha256_bcopy:+Loop_bcopy:+	ldrb	w3,[x1],#1+	sub	x2,x2,#1+	strb	w3,[x0],#1+	cbnz	x2,Loop_bcopy+	ret+++.globl	_blst_sha256_hcopy+.private_extern	_blst_sha256_hcopy++.align	4+_blst_sha256_hcopy:+	ldp	x4,x5,[x1]+	ldp	x6,x7,[x1,#16]+	stp	x4,x5,[x0]+	stp	x6,x7,[x0,#16]+	ret+
+ c-source/build/mach-o/sha256-portable-x86_64.s view
@@ -0,0 +1,1746 @@+.text	++.globl	_blst_sha256_block_data_order++.p2align	4+_blst_sha256_block_data_order:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-16+	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	shlq	$4,%rdx+	subq	$64+24,%rsp+.cfi_adjust_cfa_offset	16*4+3*8+	leaq	(%rsi,%rdx,4),%rdx+	movq	%rdi,64+0(%rsp)+	movq	%rsi,64+8(%rsp)+	movq	%rdx,64+16(%rsp)+++	movl	0(%rdi),%eax+	movl	4(%rdi),%ebx+	movl	8(%rdi),%ecx+	movl	12(%rdi),%edx+	movl	16(%rdi),%r8d+	movl	20(%rdi),%r9d+	movl	24(%rdi),%r10d+	movl	28(%rdi),%r11d+	jmp	L$loop++.p2align	4+L$loop:+	movl	%ebx,%edi+	leaq	K256(%rip),%rbp+	xorl	%ecx,%edi+	movl	0(%rsi),%r12d+	movl	%r8d,%r13d+	movl	%eax,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%r9d,%r15d++	xorl	%r8d,%r13d+	rorl	$9,%r14d+	xorl	%r10d,%r15d++	movl	%r12d,0(%rsp)+	xorl	%eax,%r14d+	andl	%r8d,%r15d++	rorl	$5,%r13d+	addl	%r11d,%r12d+	xorl	%r10d,%r15d++	rorl	$11,%r14d+	xorl	%r8d,%r13d+	addl	%r15d,%r12d++	movl	%eax,%r15d+	addl	0(%rbp),%r12d+	xorl	%eax,%r14d++	xorl	%ebx,%r15d+	rorl	$6,%r13d+	movl	%ebx,%r11d++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%r11d+	addl	%r12d,%edx+	addl	%r12d,%r11d+	addl	%r14d,%r11d+	movl	4(%rsi),%r12d+	movl	%edx,%r13d+	movl	%r11d,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%r8d,%edi++	xorl	%edx,%r13d+	rorl	$9,%r14d+	xorl	%r9d,%edi++	movl	%r12d,4(%rsp)+	xorl	%r11d,%r14d+	andl	%edx,%edi++	rorl	$5,%r13d+	addl	%r10d,%r12d+	xorl	%r9d,%edi++	rorl	$11,%r14d+	xorl	%edx,%r13d+	addl	%edi,%r12d++	movl	%r11d,%edi+	addl	4(%rbp),%r12d+	xorl	%r11d,%r14d++	xorl	%eax,%edi+	rorl	$6,%r13d+	movl	%eax,%r10d++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%r10d+	addl	%r12d,%ecx+	addl	%r12d,%r10d+	addl	%r14d,%r10d+	movl	8(%rsi),%r12d+	movl	%ecx,%r13d+	movl	%r10d,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%edx,%r15d++	xorl	%ecx,%r13d+	rorl	$9,%r14d+	xorl	%r8d,%r15d++	movl	%r12d,8(%rsp)+	xorl	%r10d,%r14d+	andl	%ecx,%r15d++	rorl	$5,%r13d+	addl	%r9d,%r12d+	xorl	%r8d,%r15d++	rorl	$11,%r14d+	xorl	%ecx,%r13d+	addl	%r15d,%r12d++	movl	%r10d,%r15d+	addl	8(%rbp),%r12d+	xorl	%r10d,%r14d++	xorl	%r11d,%r15d+	rorl	$6,%r13d+	movl	%r11d,%r9d++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%r9d+	addl	%r12d,%ebx+	addl	%r12d,%r9d+	addl	%r14d,%r9d+	movl	12(%rsi),%r12d+	movl	%ebx,%r13d+	movl	%r9d,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%ecx,%edi++	xorl	%ebx,%r13d+	rorl	$9,%r14d+	xorl	%edx,%edi++	movl	%r12d,12(%rsp)+	xorl	%r9d,%r14d+	andl	%ebx,%edi++	rorl	$5,%r13d+	addl	%r8d,%r12d+	xorl	%edx,%edi++	rorl	$11,%r14d+	xorl	%ebx,%r13d+	addl	%edi,%r12d++	movl	%r9d,%edi+	addl	12(%rbp),%r12d+	xorl	%r9d,%r14d++	xorl	%r10d,%edi+	rorl	$6,%r13d+	movl	%r10d,%r8d++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%r8d+	addl	%r12d,%eax+	addl	%r12d,%r8d+	addl	%r14d,%r8d+	movl	16(%rsi),%r12d+	movl	%eax,%r13d+	movl	%r8d,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%ebx,%r15d++	xorl	%eax,%r13d+	rorl	$9,%r14d+	xorl	%ecx,%r15d++	movl	%r12d,16(%rsp)+	xorl	%r8d,%r14d+	andl	%eax,%r15d++	rorl	$5,%r13d+	addl	%edx,%r12d+	xorl	%ecx,%r15d++	rorl	$11,%r14d+	xorl	%eax,%r13d+	addl	%r15d,%r12d++	movl	%r8d,%r15d+	addl	16(%rbp),%r12d+	xorl	%r8d,%r14d++	xorl	%r9d,%r15d+	rorl	$6,%r13d+	movl	%r9d,%edx++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%edx+	addl	%r12d,%r11d+	addl	%r12d,%edx+	addl	%r14d,%edx+	movl	20(%rsi),%r12d+	movl	%r11d,%r13d+	movl	%edx,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%eax,%edi++	xorl	%r11d,%r13d+	rorl	$9,%r14d+	xorl	%ebx,%edi++	movl	%r12d,20(%rsp)+	xorl	%edx,%r14d+	andl	%r11d,%edi++	rorl	$5,%r13d+	addl	%ecx,%r12d+	xorl	%ebx,%edi++	rorl	$11,%r14d+	xorl	%r11d,%r13d+	addl	%edi,%r12d++	movl	%edx,%edi+	addl	20(%rbp),%r12d+	xorl	%edx,%r14d++	xorl	%r8d,%edi+	rorl	$6,%r13d+	movl	%r8d,%ecx++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%ecx+	addl	%r12d,%r10d+	addl	%r12d,%ecx+	addl	%r14d,%ecx+	movl	24(%rsi),%r12d+	movl	%r10d,%r13d+	movl	%ecx,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%r11d,%r15d++	xorl	%r10d,%r13d+	rorl	$9,%r14d+	xorl	%eax,%r15d++	movl	%r12d,24(%rsp)+	xorl	%ecx,%r14d+	andl	%r10d,%r15d++	rorl	$5,%r13d+	addl	%ebx,%r12d+	xorl	%eax,%r15d++	rorl	$11,%r14d+	xorl	%r10d,%r13d+	addl	%r15d,%r12d++	movl	%ecx,%r15d+	addl	24(%rbp),%r12d+	xorl	%ecx,%r14d++	xorl	%edx,%r15d+	rorl	$6,%r13d+	movl	%edx,%ebx++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%ebx+	addl	%r12d,%r9d+	addl	%r12d,%ebx+	addl	%r14d,%ebx+	movl	28(%rsi),%r12d+	movl	%r9d,%r13d+	movl	%ebx,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%r10d,%edi++	xorl	%r9d,%r13d+	rorl	$9,%r14d+	xorl	%r11d,%edi++	movl	%r12d,28(%rsp)+	xorl	%ebx,%r14d+	andl	%r9d,%edi++	rorl	$5,%r13d+	addl	%eax,%r12d+	xorl	%r11d,%edi++	rorl	$11,%r14d+	xorl	%r9d,%r13d+	addl	%edi,%r12d++	movl	%ebx,%edi+	addl	28(%rbp),%r12d+	xorl	%ebx,%r14d++	xorl	%ecx,%edi+	rorl	$6,%r13d+	movl	%ecx,%eax++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%eax+	addl	%r12d,%r8d+	addl	%r12d,%eax+	addl	%r14d,%eax+	movl	32(%rsi),%r12d+	movl	%r8d,%r13d+	movl	%eax,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%r9d,%r15d++	xorl	%r8d,%r13d+	rorl	$9,%r14d+	xorl	%r10d,%r15d++	movl	%r12d,32(%rsp)+	xorl	%eax,%r14d+	andl	%r8d,%r15d++	rorl	$5,%r13d+	addl	%r11d,%r12d+	xorl	%r10d,%r15d++	rorl	$11,%r14d+	xorl	%r8d,%r13d+	addl	%r15d,%r12d++	movl	%eax,%r15d+	addl	32(%rbp),%r12d+	xorl	%eax,%r14d++	xorl	%ebx,%r15d+	rorl	$6,%r13d+	movl	%ebx,%r11d++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%r11d+	addl	%r12d,%edx+	addl	%r12d,%r11d+	addl	%r14d,%r11d+	movl	36(%rsi),%r12d+	movl	%edx,%r13d+	movl	%r11d,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%r8d,%edi++	xorl	%edx,%r13d+	rorl	$9,%r14d+	xorl	%r9d,%edi++	movl	%r12d,36(%rsp)+	xorl	%r11d,%r14d+	andl	%edx,%edi++	rorl	$5,%r13d+	addl	%r10d,%r12d+	xorl	%r9d,%edi++	rorl	$11,%r14d+	xorl	%edx,%r13d+	addl	%edi,%r12d++	movl	%r11d,%edi+	addl	36(%rbp),%r12d+	xorl	%r11d,%r14d++	xorl	%eax,%edi+	rorl	$6,%r13d+	movl	%eax,%r10d++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%r10d+	addl	%r12d,%ecx+	addl	%r12d,%r10d+	addl	%r14d,%r10d+	movl	40(%rsi),%r12d+	movl	%ecx,%r13d+	movl	%r10d,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%edx,%r15d++	xorl	%ecx,%r13d+	rorl	$9,%r14d+	xorl	%r8d,%r15d++	movl	%r12d,40(%rsp)+	xorl	%r10d,%r14d+	andl	%ecx,%r15d++	rorl	$5,%r13d+	addl	%r9d,%r12d+	xorl	%r8d,%r15d++	rorl	$11,%r14d+	xorl	%ecx,%r13d+	addl	%r15d,%r12d++	movl	%r10d,%r15d+	addl	40(%rbp),%r12d+	xorl	%r10d,%r14d++	xorl	%r11d,%r15d+	rorl	$6,%r13d+	movl	%r11d,%r9d++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%r9d+	addl	%r12d,%ebx+	addl	%r12d,%r9d+	addl	%r14d,%r9d+	movl	44(%rsi),%r12d+	movl	%ebx,%r13d+	movl	%r9d,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%ecx,%edi++	xorl	%ebx,%r13d+	rorl	$9,%r14d+	xorl	%edx,%edi++	movl	%r12d,44(%rsp)+	xorl	%r9d,%r14d+	andl	%ebx,%edi++	rorl	$5,%r13d+	addl	%r8d,%r12d+	xorl	%edx,%edi++	rorl	$11,%r14d+	xorl	%ebx,%r13d+	addl	%edi,%r12d++	movl	%r9d,%edi+	addl	44(%rbp),%r12d+	xorl	%r9d,%r14d++	xorl	%r10d,%edi+	rorl	$6,%r13d+	movl	%r10d,%r8d++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%r8d+	addl	%r12d,%eax+	addl	%r12d,%r8d+	addl	%r14d,%r8d+	movl	48(%rsi),%r12d+	movl	%eax,%r13d+	movl	%r8d,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%ebx,%r15d++	xorl	%eax,%r13d+	rorl	$9,%r14d+	xorl	%ecx,%r15d++	movl	%r12d,48(%rsp)+	xorl	%r8d,%r14d+	andl	%eax,%r15d++	rorl	$5,%r13d+	addl	%edx,%r12d+	xorl	%ecx,%r15d++	rorl	$11,%r14d+	xorl	%eax,%r13d+	addl	%r15d,%r12d++	movl	%r8d,%r15d+	addl	48(%rbp),%r12d+	xorl	%r8d,%r14d++	xorl	%r9d,%r15d+	rorl	$6,%r13d+	movl	%r9d,%edx++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%edx+	addl	%r12d,%r11d+	addl	%r12d,%edx+	addl	%r14d,%edx+	movl	52(%rsi),%r12d+	movl	%r11d,%r13d+	movl	%edx,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%eax,%edi++	xorl	%r11d,%r13d+	rorl	$9,%r14d+	xorl	%ebx,%edi++	movl	%r12d,52(%rsp)+	xorl	%edx,%r14d+	andl	%r11d,%edi++	rorl	$5,%r13d+	addl	%ecx,%r12d+	xorl	%ebx,%edi++	rorl	$11,%r14d+	xorl	%r11d,%r13d+	addl	%edi,%r12d++	movl	%edx,%edi+	addl	52(%rbp),%r12d+	xorl	%edx,%r14d++	xorl	%r8d,%edi+	rorl	$6,%r13d+	movl	%r8d,%ecx++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%ecx+	addl	%r12d,%r10d+	addl	%r12d,%ecx+	addl	%r14d,%ecx+	movl	56(%rsi),%r12d+	movl	%r10d,%r13d+	movl	%ecx,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%r11d,%r15d++	xorl	%r10d,%r13d+	rorl	$9,%r14d+	xorl	%eax,%r15d++	movl	%r12d,56(%rsp)+	xorl	%ecx,%r14d+	andl	%r10d,%r15d++	rorl	$5,%r13d+	addl	%ebx,%r12d+	xorl	%eax,%r15d++	rorl	$11,%r14d+	xorl	%r10d,%r13d+	addl	%r15d,%r12d++	movl	%ecx,%r15d+	addl	56(%rbp),%r12d+	xorl	%ecx,%r14d++	xorl	%edx,%r15d+	rorl	$6,%r13d+	movl	%edx,%ebx++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%ebx+	addl	%r12d,%r9d+	addl	%r12d,%ebx+	addl	%r14d,%ebx+	movl	60(%rsi),%r12d+	movl	%r9d,%r13d+	movl	%ebx,%r14d+	bswapl	%r12d+	rorl	$14,%r13d+	movl	%r10d,%edi++	xorl	%r9d,%r13d+	rorl	$9,%r14d+	xorl	%r11d,%edi++	movl	%r12d,60(%rsp)+	xorl	%ebx,%r14d+	andl	%r9d,%edi++	rorl	$5,%r13d+	addl	%eax,%r12d+	xorl	%r11d,%edi++	rorl	$11,%r14d+	xorl	%r9d,%r13d+	addl	%edi,%r12d++	movl	%ebx,%edi+	addl	60(%rbp),%r12d+	xorl	%ebx,%r14d++	xorl	%ecx,%edi+	rorl	$6,%r13d+	movl	%ecx,%eax++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%eax+	addl	%r12d,%r8d+	addl	%r12d,%eax+	jmp	L$rounds_16_xx+.p2align	4+L$rounds_16_xx:+	movl	4(%rsp),%r13d+	movl	56(%rsp),%r15d++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%eax+	movl	%r15d,%r14d+	rorl	$2,%r15d++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%r15d+	shrl	$10,%r14d++	rorl	$17,%r15d+	xorl	%r13d,%r12d+	xorl	%r14d,%r15d+	addl	36(%rsp),%r12d++	addl	0(%rsp),%r12d+	movl	%r8d,%r13d+	addl	%r15d,%r12d+	movl	%eax,%r14d+	rorl	$14,%r13d+	movl	%r9d,%r15d++	xorl	%r8d,%r13d+	rorl	$9,%r14d+	xorl	%r10d,%r15d++	movl	%r12d,0(%rsp)+	xorl	%eax,%r14d+	andl	%r8d,%r15d++	rorl	$5,%r13d+	addl	%r11d,%r12d+	xorl	%r10d,%r15d++	rorl	$11,%r14d+	xorl	%r8d,%r13d+	addl	%r15d,%r12d++	movl	%eax,%r15d+	addl	64(%rbp),%r12d+	xorl	%eax,%r14d++	xorl	%ebx,%r15d+	rorl	$6,%r13d+	movl	%ebx,%r11d++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%r11d+	addl	%r12d,%edx+	addl	%r12d,%r11d+	movl	8(%rsp),%r13d+	movl	60(%rsp),%edi++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%r11d+	movl	%edi,%r14d+	rorl	$2,%edi++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%edi+	shrl	$10,%r14d++	rorl	$17,%edi+	xorl	%r13d,%r12d+	xorl	%r14d,%edi+	addl	40(%rsp),%r12d++	addl	4(%rsp),%r12d+	movl	%edx,%r13d+	addl	%edi,%r12d+	movl	%r11d,%r14d+	rorl	$14,%r13d+	movl	%r8d,%edi++	xorl	%edx,%r13d+	rorl	$9,%r14d+	xorl	%r9d,%edi++	movl	%r12d,4(%rsp)+	xorl	%r11d,%r14d+	andl	%edx,%edi++	rorl	$5,%r13d+	addl	%r10d,%r12d+	xorl	%r9d,%edi++	rorl	$11,%r14d+	xorl	%edx,%r13d+	addl	%edi,%r12d++	movl	%r11d,%edi+	addl	68(%rbp),%r12d+	xorl	%r11d,%r14d++	xorl	%eax,%edi+	rorl	$6,%r13d+	movl	%eax,%r10d++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%r10d+	addl	%r12d,%ecx+	addl	%r12d,%r10d+	movl	12(%rsp),%r13d+	movl	0(%rsp),%r15d++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%r10d+	movl	%r15d,%r14d+	rorl	$2,%r15d++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%r15d+	shrl	$10,%r14d++	rorl	$17,%r15d+	xorl	%r13d,%r12d+	xorl	%r14d,%r15d+	addl	44(%rsp),%r12d++	addl	8(%rsp),%r12d+	movl	%ecx,%r13d+	addl	%r15d,%r12d+	movl	%r10d,%r14d+	rorl	$14,%r13d+	movl	%edx,%r15d++	xorl	%ecx,%r13d+	rorl	$9,%r14d+	xorl	%r8d,%r15d++	movl	%r12d,8(%rsp)+	xorl	%r10d,%r14d+	andl	%ecx,%r15d++	rorl	$5,%r13d+	addl	%r9d,%r12d+	xorl	%r8d,%r15d++	rorl	$11,%r14d+	xorl	%ecx,%r13d+	addl	%r15d,%r12d++	movl	%r10d,%r15d+	addl	72(%rbp),%r12d+	xorl	%r10d,%r14d++	xorl	%r11d,%r15d+	rorl	$6,%r13d+	movl	%r11d,%r9d++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%r9d+	addl	%r12d,%ebx+	addl	%r12d,%r9d+	movl	16(%rsp),%r13d+	movl	4(%rsp),%edi++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%r9d+	movl	%edi,%r14d+	rorl	$2,%edi++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%edi+	shrl	$10,%r14d++	rorl	$17,%edi+	xorl	%r13d,%r12d+	xorl	%r14d,%edi+	addl	48(%rsp),%r12d++	addl	12(%rsp),%r12d+	movl	%ebx,%r13d+	addl	%edi,%r12d+	movl	%r9d,%r14d+	rorl	$14,%r13d+	movl	%ecx,%edi++	xorl	%ebx,%r13d+	rorl	$9,%r14d+	xorl	%edx,%edi++	movl	%r12d,12(%rsp)+	xorl	%r9d,%r14d+	andl	%ebx,%edi++	rorl	$5,%r13d+	addl	%r8d,%r12d+	xorl	%edx,%edi++	rorl	$11,%r14d+	xorl	%ebx,%r13d+	addl	%edi,%r12d++	movl	%r9d,%edi+	addl	76(%rbp),%r12d+	xorl	%r9d,%r14d++	xorl	%r10d,%edi+	rorl	$6,%r13d+	movl	%r10d,%r8d++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%r8d+	addl	%r12d,%eax+	addl	%r12d,%r8d+	movl	20(%rsp),%r13d+	movl	8(%rsp),%r15d++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%r8d+	movl	%r15d,%r14d+	rorl	$2,%r15d++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%r15d+	shrl	$10,%r14d++	rorl	$17,%r15d+	xorl	%r13d,%r12d+	xorl	%r14d,%r15d+	addl	52(%rsp),%r12d++	addl	16(%rsp),%r12d+	movl	%eax,%r13d+	addl	%r15d,%r12d+	movl	%r8d,%r14d+	rorl	$14,%r13d+	movl	%ebx,%r15d++	xorl	%eax,%r13d+	rorl	$9,%r14d+	xorl	%ecx,%r15d++	movl	%r12d,16(%rsp)+	xorl	%r8d,%r14d+	andl	%eax,%r15d++	rorl	$5,%r13d+	addl	%edx,%r12d+	xorl	%ecx,%r15d++	rorl	$11,%r14d+	xorl	%eax,%r13d+	addl	%r15d,%r12d++	movl	%r8d,%r15d+	addl	80(%rbp),%r12d+	xorl	%r8d,%r14d++	xorl	%r9d,%r15d+	rorl	$6,%r13d+	movl	%r9d,%edx++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%edx+	addl	%r12d,%r11d+	addl	%r12d,%edx+	movl	24(%rsp),%r13d+	movl	12(%rsp),%edi++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%edx+	movl	%edi,%r14d+	rorl	$2,%edi++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%edi+	shrl	$10,%r14d++	rorl	$17,%edi+	xorl	%r13d,%r12d+	xorl	%r14d,%edi+	addl	56(%rsp),%r12d++	addl	20(%rsp),%r12d+	movl	%r11d,%r13d+	addl	%edi,%r12d+	movl	%edx,%r14d+	rorl	$14,%r13d+	movl	%eax,%edi++	xorl	%r11d,%r13d+	rorl	$9,%r14d+	xorl	%ebx,%edi++	movl	%r12d,20(%rsp)+	xorl	%edx,%r14d+	andl	%r11d,%edi++	rorl	$5,%r13d+	addl	%ecx,%r12d+	xorl	%ebx,%edi++	rorl	$11,%r14d+	xorl	%r11d,%r13d+	addl	%edi,%r12d++	movl	%edx,%edi+	addl	84(%rbp),%r12d+	xorl	%edx,%r14d++	xorl	%r8d,%edi+	rorl	$6,%r13d+	movl	%r8d,%ecx++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%ecx+	addl	%r12d,%r10d+	addl	%r12d,%ecx+	movl	28(%rsp),%r13d+	movl	16(%rsp),%r15d++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%ecx+	movl	%r15d,%r14d+	rorl	$2,%r15d++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%r15d+	shrl	$10,%r14d++	rorl	$17,%r15d+	xorl	%r13d,%r12d+	xorl	%r14d,%r15d+	addl	60(%rsp),%r12d++	addl	24(%rsp),%r12d+	movl	%r10d,%r13d+	addl	%r15d,%r12d+	movl	%ecx,%r14d+	rorl	$14,%r13d+	movl	%r11d,%r15d++	xorl	%r10d,%r13d+	rorl	$9,%r14d+	xorl	%eax,%r15d++	movl	%r12d,24(%rsp)+	xorl	%ecx,%r14d+	andl	%r10d,%r15d++	rorl	$5,%r13d+	addl	%ebx,%r12d+	xorl	%eax,%r15d++	rorl	$11,%r14d+	xorl	%r10d,%r13d+	addl	%r15d,%r12d++	movl	%ecx,%r15d+	addl	88(%rbp),%r12d+	xorl	%ecx,%r14d++	xorl	%edx,%r15d+	rorl	$6,%r13d+	movl	%edx,%ebx++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%ebx+	addl	%r12d,%r9d+	addl	%r12d,%ebx+	movl	32(%rsp),%r13d+	movl	20(%rsp),%edi++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%ebx+	movl	%edi,%r14d+	rorl	$2,%edi++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%edi+	shrl	$10,%r14d++	rorl	$17,%edi+	xorl	%r13d,%r12d+	xorl	%r14d,%edi+	addl	0(%rsp),%r12d++	addl	28(%rsp),%r12d+	movl	%r9d,%r13d+	addl	%edi,%r12d+	movl	%ebx,%r14d+	rorl	$14,%r13d+	movl	%r10d,%edi++	xorl	%r9d,%r13d+	rorl	$9,%r14d+	xorl	%r11d,%edi++	movl	%r12d,28(%rsp)+	xorl	%ebx,%r14d+	andl	%r9d,%edi++	rorl	$5,%r13d+	addl	%eax,%r12d+	xorl	%r11d,%edi++	rorl	$11,%r14d+	xorl	%r9d,%r13d+	addl	%edi,%r12d++	movl	%ebx,%edi+	addl	92(%rbp),%r12d+	xorl	%ebx,%r14d++	xorl	%ecx,%edi+	rorl	$6,%r13d+	movl	%ecx,%eax++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%eax+	addl	%r12d,%r8d+	addl	%r12d,%eax+	movl	36(%rsp),%r13d+	movl	24(%rsp),%r15d++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%eax+	movl	%r15d,%r14d+	rorl	$2,%r15d++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%r15d+	shrl	$10,%r14d++	rorl	$17,%r15d+	xorl	%r13d,%r12d+	xorl	%r14d,%r15d+	addl	4(%rsp),%r12d++	addl	32(%rsp),%r12d+	movl	%r8d,%r13d+	addl	%r15d,%r12d+	movl	%eax,%r14d+	rorl	$14,%r13d+	movl	%r9d,%r15d++	xorl	%r8d,%r13d+	rorl	$9,%r14d+	xorl	%r10d,%r15d++	movl	%r12d,32(%rsp)+	xorl	%eax,%r14d+	andl	%r8d,%r15d++	rorl	$5,%r13d+	addl	%r11d,%r12d+	xorl	%r10d,%r15d++	rorl	$11,%r14d+	xorl	%r8d,%r13d+	addl	%r15d,%r12d++	movl	%eax,%r15d+	addl	96(%rbp),%r12d+	xorl	%eax,%r14d++	xorl	%ebx,%r15d+	rorl	$6,%r13d+	movl	%ebx,%r11d++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%r11d+	addl	%r12d,%edx+	addl	%r12d,%r11d+	movl	40(%rsp),%r13d+	movl	28(%rsp),%edi++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%r11d+	movl	%edi,%r14d+	rorl	$2,%edi++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%edi+	shrl	$10,%r14d++	rorl	$17,%edi+	xorl	%r13d,%r12d+	xorl	%r14d,%edi+	addl	8(%rsp),%r12d++	addl	36(%rsp),%r12d+	movl	%edx,%r13d+	addl	%edi,%r12d+	movl	%r11d,%r14d+	rorl	$14,%r13d+	movl	%r8d,%edi++	xorl	%edx,%r13d+	rorl	$9,%r14d+	xorl	%r9d,%edi++	movl	%r12d,36(%rsp)+	xorl	%r11d,%r14d+	andl	%edx,%edi++	rorl	$5,%r13d+	addl	%r10d,%r12d+	xorl	%r9d,%edi++	rorl	$11,%r14d+	xorl	%edx,%r13d+	addl	%edi,%r12d++	movl	%r11d,%edi+	addl	100(%rbp),%r12d+	xorl	%r11d,%r14d++	xorl	%eax,%edi+	rorl	$6,%r13d+	movl	%eax,%r10d++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%r10d+	addl	%r12d,%ecx+	addl	%r12d,%r10d+	movl	44(%rsp),%r13d+	movl	32(%rsp),%r15d++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%r10d+	movl	%r15d,%r14d+	rorl	$2,%r15d++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%r15d+	shrl	$10,%r14d++	rorl	$17,%r15d+	xorl	%r13d,%r12d+	xorl	%r14d,%r15d+	addl	12(%rsp),%r12d++	addl	40(%rsp),%r12d+	movl	%ecx,%r13d+	addl	%r15d,%r12d+	movl	%r10d,%r14d+	rorl	$14,%r13d+	movl	%edx,%r15d++	xorl	%ecx,%r13d+	rorl	$9,%r14d+	xorl	%r8d,%r15d++	movl	%r12d,40(%rsp)+	xorl	%r10d,%r14d+	andl	%ecx,%r15d++	rorl	$5,%r13d+	addl	%r9d,%r12d+	xorl	%r8d,%r15d++	rorl	$11,%r14d+	xorl	%ecx,%r13d+	addl	%r15d,%r12d++	movl	%r10d,%r15d+	addl	104(%rbp),%r12d+	xorl	%r10d,%r14d++	xorl	%r11d,%r15d+	rorl	$6,%r13d+	movl	%r11d,%r9d++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%r9d+	addl	%r12d,%ebx+	addl	%r12d,%r9d+	movl	48(%rsp),%r13d+	movl	36(%rsp),%edi++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%r9d+	movl	%edi,%r14d+	rorl	$2,%edi++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%edi+	shrl	$10,%r14d++	rorl	$17,%edi+	xorl	%r13d,%r12d+	xorl	%r14d,%edi+	addl	16(%rsp),%r12d++	addl	44(%rsp),%r12d+	movl	%ebx,%r13d+	addl	%edi,%r12d+	movl	%r9d,%r14d+	rorl	$14,%r13d+	movl	%ecx,%edi++	xorl	%ebx,%r13d+	rorl	$9,%r14d+	xorl	%edx,%edi++	movl	%r12d,44(%rsp)+	xorl	%r9d,%r14d+	andl	%ebx,%edi++	rorl	$5,%r13d+	addl	%r8d,%r12d+	xorl	%edx,%edi++	rorl	$11,%r14d+	xorl	%ebx,%r13d+	addl	%edi,%r12d++	movl	%r9d,%edi+	addl	108(%rbp),%r12d+	xorl	%r9d,%r14d++	xorl	%r10d,%edi+	rorl	$6,%r13d+	movl	%r10d,%r8d++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%r8d+	addl	%r12d,%eax+	addl	%r12d,%r8d+	movl	52(%rsp),%r13d+	movl	40(%rsp),%r15d++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%r8d+	movl	%r15d,%r14d+	rorl	$2,%r15d++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%r15d+	shrl	$10,%r14d++	rorl	$17,%r15d+	xorl	%r13d,%r12d+	xorl	%r14d,%r15d+	addl	20(%rsp),%r12d++	addl	48(%rsp),%r12d+	movl	%eax,%r13d+	addl	%r15d,%r12d+	movl	%r8d,%r14d+	rorl	$14,%r13d+	movl	%ebx,%r15d++	xorl	%eax,%r13d+	rorl	$9,%r14d+	xorl	%ecx,%r15d++	movl	%r12d,48(%rsp)+	xorl	%r8d,%r14d+	andl	%eax,%r15d++	rorl	$5,%r13d+	addl	%edx,%r12d+	xorl	%ecx,%r15d++	rorl	$11,%r14d+	xorl	%eax,%r13d+	addl	%r15d,%r12d++	movl	%r8d,%r15d+	addl	112(%rbp),%r12d+	xorl	%r8d,%r14d++	xorl	%r9d,%r15d+	rorl	$6,%r13d+	movl	%r9d,%edx++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%edx+	addl	%r12d,%r11d+	addl	%r12d,%edx+	movl	56(%rsp),%r13d+	movl	44(%rsp),%edi++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%edx+	movl	%edi,%r14d+	rorl	$2,%edi++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%edi+	shrl	$10,%r14d++	rorl	$17,%edi+	xorl	%r13d,%r12d+	xorl	%r14d,%edi+	addl	24(%rsp),%r12d++	addl	52(%rsp),%r12d+	movl	%r11d,%r13d+	addl	%edi,%r12d+	movl	%edx,%r14d+	rorl	$14,%r13d+	movl	%eax,%edi++	xorl	%r11d,%r13d+	rorl	$9,%r14d+	xorl	%ebx,%edi++	movl	%r12d,52(%rsp)+	xorl	%edx,%r14d+	andl	%r11d,%edi++	rorl	$5,%r13d+	addl	%ecx,%r12d+	xorl	%ebx,%edi++	rorl	$11,%r14d+	xorl	%r11d,%r13d+	addl	%edi,%r12d++	movl	%edx,%edi+	addl	116(%rbp),%r12d+	xorl	%edx,%r14d++	xorl	%r8d,%edi+	rorl	$6,%r13d+	movl	%r8d,%ecx++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%ecx+	addl	%r12d,%r10d+	addl	%r12d,%ecx+	movl	60(%rsp),%r13d+	movl	48(%rsp),%r15d++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%ecx+	movl	%r15d,%r14d+	rorl	$2,%r15d++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%r15d+	shrl	$10,%r14d++	rorl	$17,%r15d+	xorl	%r13d,%r12d+	xorl	%r14d,%r15d+	addl	28(%rsp),%r12d++	addl	56(%rsp),%r12d+	movl	%r10d,%r13d+	addl	%r15d,%r12d+	movl	%ecx,%r14d+	rorl	$14,%r13d+	movl	%r11d,%r15d++	xorl	%r10d,%r13d+	rorl	$9,%r14d+	xorl	%eax,%r15d++	movl	%r12d,56(%rsp)+	xorl	%ecx,%r14d+	andl	%r10d,%r15d++	rorl	$5,%r13d+	addl	%ebx,%r12d+	xorl	%eax,%r15d++	rorl	$11,%r14d+	xorl	%r10d,%r13d+	addl	%r15d,%r12d++	movl	%ecx,%r15d+	addl	120(%rbp),%r12d+	xorl	%ecx,%r14d++	xorl	%edx,%r15d+	rorl	$6,%r13d+	movl	%edx,%ebx++	andl	%r15d,%edi+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%edi,%ebx+	addl	%r12d,%r9d+	addl	%r12d,%ebx+	movl	0(%rsp),%r13d+	movl	52(%rsp),%edi++	movl	%r13d,%r12d+	rorl	$11,%r13d+	addl	%r14d,%ebx+	movl	%edi,%r14d+	rorl	$2,%edi++	xorl	%r12d,%r13d+	shrl	$3,%r12d+	rorl	$7,%r13d+	xorl	%r14d,%edi+	shrl	$10,%r14d++	rorl	$17,%edi+	xorl	%r13d,%r12d+	xorl	%r14d,%edi+	addl	32(%rsp),%r12d++	addl	60(%rsp),%r12d+	movl	%r9d,%r13d+	addl	%edi,%r12d+	movl	%ebx,%r14d+	rorl	$14,%r13d+	movl	%r10d,%edi++	xorl	%r9d,%r13d+	rorl	$9,%r14d+	xorl	%r11d,%edi++	movl	%r12d,60(%rsp)+	xorl	%ebx,%r14d+	andl	%r9d,%edi++	rorl	$5,%r13d+	addl	%eax,%r12d+	xorl	%r11d,%edi++	rorl	$11,%r14d+	xorl	%r9d,%r13d+	addl	%edi,%r12d++	movl	%ebx,%edi+	addl	124(%rbp),%r12d+	xorl	%ebx,%r14d++	xorl	%ecx,%edi+	rorl	$6,%r13d+	movl	%ecx,%eax++	andl	%edi,%r15d+	rorl	$2,%r14d+	addl	%r13d,%r12d++	xorl	%r15d,%eax+	addl	%r12d,%r8d+	addl	%r12d,%eax+	leaq	64(%rbp),%rbp+	cmpb	$0x19,3(%rbp)+	jnz	L$rounds_16_xx++	movq	64+0(%rsp),%rdi+	addl	%r14d,%eax+	leaq	64(%rsi),%rsi++	addl	0(%rdi),%eax+	addl	4(%rdi),%ebx+	addl	8(%rdi),%ecx+	addl	12(%rdi),%edx+	addl	16(%rdi),%r8d+	addl	20(%rdi),%r9d+	addl	24(%rdi),%r10d+	addl	28(%rdi),%r11d++	cmpq	64+16(%rsp),%rsi++	movl	%eax,0(%rdi)+	movl	%ebx,4(%rdi)+	movl	%ecx,8(%rdi)+	movl	%edx,12(%rdi)+	movl	%r8d,16(%rdi)+	movl	%r9d,20(%rdi)+	movl	%r10d,24(%rdi)+	movl	%r11d,28(%rdi)+	jb	L$loop++	leaq	64+24+48(%rsp),%r11+.cfi_def_cfa	%r11,8+	movq	64+24(%rsp),%r15+.cfi_restore	%r15+	movq	-40(%r11),%r14+.cfi_restore	%r14+	movq	-32(%r11),%r13+.cfi_restore	%r13+	movq	-24(%r11),%r12+.cfi_restore	%r12+	movq	-16(%r11),%rbp+.cfi_restore	%rbp+	movq	-8(%r11),%rbx+.cfi_restore	%rbx++	leaq	(%r11),%rsp+	.byte	0xf3,0xc3+.cfi_endproc	+++.p2align	6++K256:+.long	0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5+.long	0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5+.long	0xd807aa98,0x12835b01,0x243185be,0x550c7dc3+.long	0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174+.long	0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc+.long	0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da+.long	0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7+.long	0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967+.long	0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13+.long	0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85+.long	0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3+.long	0xd192e819,0xd6990624,0xf40e3585,0x106aa070+.long	0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5+.long	0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3+.long	0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208+.long	0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2++.byte	83,72,65,50,53,54,32,98,108,111,99,107,32,116,114,97,110,115,102,111,114,109,32,102,111,114,32,120,56,54,95,54,52,44,32,67,82,89,80,84,79,71,65,77,83,32,98,121,32,64,100,111,116,45,97,115,109,0+.globl	_blst_sha256_emit+.private_extern	_blst_sha256_emit++.p2align	4+_blst_sha256_emit:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	bswapq	%r8+	movq	24(%rsi),%r11+	bswapq	%r9+	movl	%r8d,4(%rdi)+	bswapq	%r10+	movl	%r9d,12(%rdi)+	bswapq	%r11+	movl	%r10d,20(%rdi)+	shrq	$32,%r8+	movl	%r11d,28(%rdi)+	shrq	$32,%r9+	movl	%r8d,0(%rdi)+	shrq	$32,%r10+	movl	%r9d,8(%rdi)+	shrq	$32,%r11+	movl	%r10d,16(%rdi)+	movl	%r11d,24(%rdi)+	.byte	0xf3,0xc3+.cfi_endproc+++.globl	_blst_sha256_bcopy+.private_extern	_blst_sha256_bcopy++.p2align	4+_blst_sha256_bcopy:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	subq	%rsi,%rdi+L$oop_bcopy:+	movzbl	(%rsi),%eax+	leaq	1(%rsi),%rsi+	movb	%al,-1(%rdi,%rsi,1)+	decq	%rdx+	jnz	L$oop_bcopy+	.byte	0xf3,0xc3+.cfi_endproc+++.globl	_blst_sha256_hcopy+.private_extern	_blst_sha256_hcopy++.p2align	4+_blst_sha256_hcopy:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	.byte	0xf3,0xc3+.cfi_endproc+
+ c-source/build/mach-o/sha256-x86_64.s view
@@ -0,0 +1,1438 @@+.text	++.p2align	6++K256:+.long	0x428a2f98,0x71374491,0xb5c0fbcf,0xe9b5dba5+.long	0x3956c25b,0x59f111f1,0x923f82a4,0xab1c5ed5+.long	0xd807aa98,0x12835b01,0x243185be,0x550c7dc3+.long	0x72be5d74,0x80deb1fe,0x9bdc06a7,0xc19bf174+.long	0xe49b69c1,0xefbe4786,0x0fc19dc6,0x240ca1cc+.long	0x2de92c6f,0x4a7484aa,0x5cb0a9dc,0x76f988da+.long	0x983e5152,0xa831c66d,0xb00327c8,0xbf597fc7+.long	0xc6e00bf3,0xd5a79147,0x06ca6351,0x14292967+.long	0x27b70a85,0x2e1b2138,0x4d2c6dfc,0x53380d13+.long	0x650a7354,0x766a0abb,0x81c2c92e,0x92722c85+.long	0xa2bfe8a1,0xa81a664b,0xc24b8b70,0xc76c51a3+.long	0xd192e819,0xd6990624,0xf40e3585,0x106aa070+.long	0x19a4c116,0x1e376c08,0x2748774c,0x34b0bcb5+.long	0x391c0cb3,0x4ed8aa4a,0x5b9cca4f,0x682e6ff3+.long	0x748f82ee,0x78a5636f,0x84c87814,0x8cc70208+.long	0x90befffa,0xa4506ceb,0xbef9a3f7,0xc67178f2++.long	0x00010203,0x04050607,0x08090a0b,0x0c0d0e0f+.long	0x03020100,0x0b0a0908,0xffffffff,0xffffffff+.long	0xffffffff,0xffffffff,0x03020100,0x0b0a0908+.byte	83,72,65,50,53,54,32,98,108,111,99,107,32,116,114,97,110,115,102,111,114,109,32,102,111,114,32,120,56,54,95,54,52,44,32,67,82,89,80,84,79,71,65,77,83,32,98,121,32,64,100,111,116,45,97,115,109,0+.globl	_blst_sha256_block_data_order_shaext+.private_extern	_blst_sha256_block_data_order_shaext++.p2align	6+_blst_sha256_block_data_order_shaext:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	leaq	K256+128(%rip),%rcx+	movdqu	(%rdi),%xmm1+	movdqu	16(%rdi),%xmm2+	movdqa	256-128(%rcx),%xmm7++	pshufd	$0x1b,%xmm1,%xmm0+	pshufd	$0xb1,%xmm1,%xmm1+	pshufd	$0x1b,%xmm2,%xmm2+	movdqa	%xmm7,%xmm8+.byte	102,15,58,15,202,8+	punpcklqdq	%xmm0,%xmm2+	jmp	L$oop_shaext++.p2align	4+L$oop_shaext:+	movdqu	(%rsi),%xmm3+	movdqu	16(%rsi),%xmm4+	movdqu	32(%rsi),%xmm5+.byte	102,15,56,0,223+	movdqu	48(%rsi),%xmm6++	movdqa	0-128(%rcx),%xmm0+	paddd	%xmm3,%xmm0+.byte	102,15,56,0,231+	movdqa	%xmm2,%xmm10+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	nop+	movdqa	%xmm1,%xmm9+.byte	15,56,203,202++	movdqa	16-128(%rcx),%xmm0+	paddd	%xmm4,%xmm0+.byte	102,15,56,0,239+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	leaq	64(%rsi),%rsi+.byte	15,56,204,220+.byte	15,56,203,202++	movdqa	32-128(%rcx),%xmm0+	paddd	%xmm5,%xmm0+.byte	102,15,56,0,247+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm6,%xmm7+.byte	102,15,58,15,253,4+	nop+	paddd	%xmm7,%xmm3+.byte	15,56,204,229+.byte	15,56,203,202++	movdqa	48-128(%rcx),%xmm0+	paddd	%xmm6,%xmm0+.byte	15,56,205,222+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm3,%xmm7+.byte	102,15,58,15,254,4+	nop+	paddd	%xmm7,%xmm4+.byte	15,56,204,238+.byte	15,56,203,202+	movdqa	64-128(%rcx),%xmm0+	paddd	%xmm3,%xmm0+.byte	15,56,205,227+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm4,%xmm7+.byte	102,15,58,15,251,4+	nop+	paddd	%xmm7,%xmm5+.byte	15,56,204,243+.byte	15,56,203,202+	movdqa	80-128(%rcx),%xmm0+	paddd	%xmm4,%xmm0+.byte	15,56,205,236+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm5,%xmm7+.byte	102,15,58,15,252,4+	nop+	paddd	%xmm7,%xmm6+.byte	15,56,204,220+.byte	15,56,203,202+	movdqa	96-128(%rcx),%xmm0+	paddd	%xmm5,%xmm0+.byte	15,56,205,245+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm6,%xmm7+.byte	102,15,58,15,253,4+	nop+	paddd	%xmm7,%xmm3+.byte	15,56,204,229+.byte	15,56,203,202+	movdqa	112-128(%rcx),%xmm0+	paddd	%xmm6,%xmm0+.byte	15,56,205,222+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm3,%xmm7+.byte	102,15,58,15,254,4+	nop+	paddd	%xmm7,%xmm4+.byte	15,56,204,238+.byte	15,56,203,202+	movdqa	128-128(%rcx),%xmm0+	paddd	%xmm3,%xmm0+.byte	15,56,205,227+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm4,%xmm7+.byte	102,15,58,15,251,4+	nop+	paddd	%xmm7,%xmm5+.byte	15,56,204,243+.byte	15,56,203,202+	movdqa	144-128(%rcx),%xmm0+	paddd	%xmm4,%xmm0+.byte	15,56,205,236+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm5,%xmm7+.byte	102,15,58,15,252,4+	nop+	paddd	%xmm7,%xmm6+.byte	15,56,204,220+.byte	15,56,203,202+	movdqa	160-128(%rcx),%xmm0+	paddd	%xmm5,%xmm0+.byte	15,56,205,245+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm6,%xmm7+.byte	102,15,58,15,253,4+	nop+	paddd	%xmm7,%xmm3+.byte	15,56,204,229+.byte	15,56,203,202+	movdqa	176-128(%rcx),%xmm0+	paddd	%xmm6,%xmm0+.byte	15,56,205,222+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm3,%xmm7+.byte	102,15,58,15,254,4+	nop+	paddd	%xmm7,%xmm4+.byte	15,56,204,238+.byte	15,56,203,202+	movdqa	192-128(%rcx),%xmm0+	paddd	%xmm3,%xmm0+.byte	15,56,205,227+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm4,%xmm7+.byte	102,15,58,15,251,4+	nop+	paddd	%xmm7,%xmm5+.byte	15,56,204,243+.byte	15,56,203,202+	movdqa	208-128(%rcx),%xmm0+	paddd	%xmm4,%xmm0+.byte	15,56,205,236+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	movdqa	%xmm5,%xmm7+.byte	102,15,58,15,252,4+.byte	15,56,203,202+	paddd	%xmm7,%xmm6++	movdqa	224-128(%rcx),%xmm0+	paddd	%xmm5,%xmm0+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+.byte	15,56,205,245+	movdqa	%xmm8,%xmm7+.byte	15,56,203,202++	movdqa	240-128(%rcx),%xmm0+	paddd	%xmm6,%xmm0+	nop+.byte	15,56,203,209+	pshufd	$0x0e,%xmm0,%xmm0+	decq	%rdx+	nop+.byte	15,56,203,202++	paddd	%xmm10,%xmm2+	paddd	%xmm9,%xmm1+	jnz	L$oop_shaext++	pshufd	$0xb1,%xmm2,%xmm2+	pshufd	$0x1b,%xmm1,%xmm7+	pshufd	$0xb1,%xmm1,%xmm1+	punpckhqdq	%xmm2,%xmm1+.byte	102,15,58,15,215,8++	movdqu	%xmm1,(%rdi)+	movdqu	%xmm2,16(%rdi)+	.byte	0xf3,0xc3+.cfi_endproc	++.globl	_blst_sha256_block_data_order+.private_extern	_blst_sha256_block_data_order++.p2align	6+_blst_sha256_block_data_order:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa+++	pushq	%rbp+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbp,-16+	pushq	%rbx+.cfi_adjust_cfa_offset	8+.cfi_offset	%rbx,-24+	pushq	%r12+.cfi_adjust_cfa_offset	8+.cfi_offset	%r12,-32+	pushq	%r13+.cfi_adjust_cfa_offset	8+.cfi_offset	%r13,-40+	pushq	%r14+.cfi_adjust_cfa_offset	8+.cfi_offset	%r14,-48+	pushq	%r15+.cfi_adjust_cfa_offset	8+.cfi_offset	%r15,-56+	shlq	$4,%rdx+	subq	$40,%rsp+.cfi_adjust_cfa_offset	40+	leaq	(%rsi,%rdx,4),%rdx+	movq	%rdi,0(%rsp)++	movq	%rdx,16(%rsp)+	movq	%rsp,%rbp+.cfi_def_cfa_register	%rbp+++	leaq	-64(%rsp),%rsp+	movl	0(%rdi),%eax+	andq	$-64,%rsp+	movl	4(%rdi),%ebx+	movl	8(%rdi),%ecx+	movl	12(%rdi),%edx+	movl	16(%rdi),%r8d+	movl	20(%rdi),%r9d+	movl	24(%rdi),%r10d+	movl	28(%rdi),%r11d+++	jmp	L$loop_ssse3+.p2align	4+L$loop_ssse3:+	movdqa	K256+256(%rip),%xmm7+	movq	%rsi,8(%rbp)+	movdqu	0(%rsi),%xmm0+	movdqu	16(%rsi),%xmm1+	movdqu	32(%rsi),%xmm2+.byte	102,15,56,0,199+	movdqu	48(%rsi),%xmm3+	leaq	K256(%rip),%rsi+.byte	102,15,56,0,207+	movdqa	0(%rsi),%xmm4+	movdqa	16(%rsi),%xmm5+.byte	102,15,56,0,215+	paddd	%xmm0,%xmm4+	movdqa	32(%rsi),%xmm6+.byte	102,15,56,0,223+	movdqa	48(%rsi),%xmm7+	paddd	%xmm1,%xmm5+	paddd	%xmm2,%xmm6+	paddd	%xmm3,%xmm7+	movdqa	%xmm4,0(%rsp)+	movl	%eax,%r14d+	movdqa	%xmm5,16(%rsp)+	movl	%ebx,%edi+	movdqa	%xmm6,32(%rsp)+	xorl	%ecx,%edi+	movdqa	%xmm7,48(%rsp)+	movl	%r8d,%r13d+	jmp	L$ssse3_00_47++.p2align	4+L$ssse3_00_47:+	subq	$-64,%rsi+	rorl	$14,%r13d+	movdqa	%xmm1,%xmm4+	movl	%r14d,%eax+	movl	%r9d,%r12d+	movdqa	%xmm3,%xmm7+	rorl	$9,%r14d+	xorl	%r8d,%r13d+	xorl	%r10d,%r12d+	rorl	$5,%r13d+	xorl	%eax,%r14d+.byte	102,15,58,15,224,4+	andl	%r8d,%r12d+	xorl	%r8d,%r13d+.byte	102,15,58,15,250,4+	addl	0(%rsp),%r11d+	movl	%eax,%r15d+	xorl	%r10d,%r12d+	rorl	$11,%r14d+	movdqa	%xmm4,%xmm5+	xorl	%ebx,%r15d+	addl	%r12d,%r11d+	movdqa	%xmm4,%xmm6+	rorl	$6,%r13d+	andl	%r15d,%edi+	psrld	$3,%xmm4+	xorl	%eax,%r14d+	addl	%r13d,%r11d+	xorl	%ebx,%edi+	paddd	%xmm7,%xmm0+	rorl	$2,%r14d+	addl	%r11d,%edx+	psrld	$7,%xmm6+	addl	%edi,%r11d+	movl	%edx,%r13d+	pshufd	$250,%xmm3,%xmm7+	addl	%r11d,%r14d+	rorl	$14,%r13d+	pslld	$14,%xmm5+	movl	%r14d,%r11d+	movl	%r8d,%r12d+	pxor	%xmm6,%xmm4+	rorl	$9,%r14d+	xorl	%edx,%r13d+	xorl	%r9d,%r12d+	rorl	$5,%r13d+	psrld	$11,%xmm6+	xorl	%r11d,%r14d+	pxor	%xmm5,%xmm4+	andl	%edx,%r12d+	xorl	%edx,%r13d+	pslld	$11,%xmm5+	addl	4(%rsp),%r10d+	movl	%r11d,%edi+	pxor	%xmm6,%xmm4+	xorl	%r9d,%r12d+	rorl	$11,%r14d+	movdqa	%xmm7,%xmm6+	xorl	%eax,%edi+	addl	%r12d,%r10d+	pxor	%xmm5,%xmm4+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%r11d,%r14d+	psrld	$10,%xmm7+	addl	%r13d,%r10d+	xorl	%eax,%r15d+	paddd	%xmm4,%xmm0+	rorl	$2,%r14d+	addl	%r10d,%ecx+	psrlq	$17,%xmm6+	addl	%r15d,%r10d+	movl	%ecx,%r13d+	addl	%r10d,%r14d+	pxor	%xmm6,%xmm7+	rorl	$14,%r13d+	movl	%r14d,%r10d+	movl	%edx,%r12d+	rorl	$9,%r14d+	psrlq	$2,%xmm6+	xorl	%ecx,%r13d+	xorl	%r8d,%r12d+	pxor	%xmm6,%xmm7+	rorl	$5,%r13d+	xorl	%r10d,%r14d+	andl	%ecx,%r12d+	pshufd	$128,%xmm7,%xmm7+	xorl	%ecx,%r13d+	addl	8(%rsp),%r9d+	movl	%r10d,%r15d+	psrldq	$8,%xmm7+	xorl	%r8d,%r12d+	rorl	$11,%r14d+	xorl	%r11d,%r15d+	addl	%r12d,%r9d+	rorl	$6,%r13d+	paddd	%xmm7,%xmm0+	andl	%r15d,%edi+	xorl	%r10d,%r14d+	addl	%r13d,%r9d+	pshufd	$80,%xmm0,%xmm7+	xorl	%r11d,%edi+	rorl	$2,%r14d+	addl	%r9d,%ebx+	movdqa	%xmm7,%xmm6+	addl	%edi,%r9d+	movl	%ebx,%r13d+	psrld	$10,%xmm7+	addl	%r9d,%r14d+	rorl	$14,%r13d+	psrlq	$17,%xmm6+	movl	%r14d,%r9d+	movl	%ecx,%r12d+	pxor	%xmm6,%xmm7+	rorl	$9,%r14d+	xorl	%ebx,%r13d+	xorl	%edx,%r12d+	rorl	$5,%r13d+	xorl	%r9d,%r14d+	psrlq	$2,%xmm6+	andl	%ebx,%r12d+	xorl	%ebx,%r13d+	addl	12(%rsp),%r8d+	pxor	%xmm6,%xmm7+	movl	%r9d,%edi+	xorl	%edx,%r12d+	rorl	$11,%r14d+	pshufd	$8,%xmm7,%xmm7+	xorl	%r10d,%edi+	addl	%r12d,%r8d+	movdqa	0(%rsi),%xmm6+	rorl	$6,%r13d+	andl	%edi,%r15d+	pslldq	$8,%xmm7+	xorl	%r9d,%r14d+	addl	%r13d,%r8d+	xorl	%r10d,%r15d+	paddd	%xmm7,%xmm0+	rorl	$2,%r14d+	addl	%r8d,%eax+	addl	%r15d,%r8d+	paddd	%xmm0,%xmm6+	movl	%eax,%r13d+	addl	%r8d,%r14d+	movdqa	%xmm6,0(%rsp)+	rorl	$14,%r13d+	movdqa	%xmm2,%xmm4+	movl	%r14d,%r8d+	movl	%ebx,%r12d+	movdqa	%xmm0,%xmm7+	rorl	$9,%r14d+	xorl	%eax,%r13d+	xorl	%ecx,%r12d+	rorl	$5,%r13d+	xorl	%r8d,%r14d+.byte	102,15,58,15,225,4+	andl	%eax,%r12d+	xorl	%eax,%r13d+.byte	102,15,58,15,251,4+	addl	16(%rsp),%edx+	movl	%r8d,%r15d+	xorl	%ecx,%r12d+	rorl	$11,%r14d+	movdqa	%xmm4,%xmm5+	xorl	%r9d,%r15d+	addl	%r12d,%edx+	movdqa	%xmm4,%xmm6+	rorl	$6,%r13d+	andl	%r15d,%edi+	psrld	$3,%xmm4+	xorl	%r8d,%r14d+	addl	%r13d,%edx+	xorl	%r9d,%edi+	paddd	%xmm7,%xmm1+	rorl	$2,%r14d+	addl	%edx,%r11d+	psrld	$7,%xmm6+	addl	%edi,%edx+	movl	%r11d,%r13d+	pshufd	$250,%xmm0,%xmm7+	addl	%edx,%r14d+	rorl	$14,%r13d+	pslld	$14,%xmm5+	movl	%r14d,%edx+	movl	%eax,%r12d+	pxor	%xmm6,%xmm4+	rorl	$9,%r14d+	xorl	%r11d,%r13d+	xorl	%ebx,%r12d+	rorl	$5,%r13d+	psrld	$11,%xmm6+	xorl	%edx,%r14d+	pxor	%xmm5,%xmm4+	andl	%r11d,%r12d+	xorl	%r11d,%r13d+	pslld	$11,%xmm5+	addl	20(%rsp),%ecx+	movl	%edx,%edi+	pxor	%xmm6,%xmm4+	xorl	%ebx,%r12d+	rorl	$11,%r14d+	movdqa	%xmm7,%xmm6+	xorl	%r8d,%edi+	addl	%r12d,%ecx+	pxor	%xmm5,%xmm4+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%edx,%r14d+	psrld	$10,%xmm7+	addl	%r13d,%ecx+	xorl	%r8d,%r15d+	paddd	%xmm4,%xmm1+	rorl	$2,%r14d+	addl	%ecx,%r10d+	psrlq	$17,%xmm6+	addl	%r15d,%ecx+	movl	%r10d,%r13d+	addl	%ecx,%r14d+	pxor	%xmm6,%xmm7+	rorl	$14,%r13d+	movl	%r14d,%ecx+	movl	%r11d,%r12d+	rorl	$9,%r14d+	psrlq	$2,%xmm6+	xorl	%r10d,%r13d+	xorl	%eax,%r12d+	pxor	%xmm6,%xmm7+	rorl	$5,%r13d+	xorl	%ecx,%r14d+	andl	%r10d,%r12d+	pshufd	$128,%xmm7,%xmm7+	xorl	%r10d,%r13d+	addl	24(%rsp),%ebx+	movl	%ecx,%r15d+	psrldq	$8,%xmm7+	xorl	%eax,%r12d+	rorl	$11,%r14d+	xorl	%edx,%r15d+	addl	%r12d,%ebx+	rorl	$6,%r13d+	paddd	%xmm7,%xmm1+	andl	%r15d,%edi+	xorl	%ecx,%r14d+	addl	%r13d,%ebx+	pshufd	$80,%xmm1,%xmm7+	xorl	%edx,%edi+	rorl	$2,%r14d+	addl	%ebx,%r9d+	movdqa	%xmm7,%xmm6+	addl	%edi,%ebx+	movl	%r9d,%r13d+	psrld	$10,%xmm7+	addl	%ebx,%r14d+	rorl	$14,%r13d+	psrlq	$17,%xmm6+	movl	%r14d,%ebx+	movl	%r10d,%r12d+	pxor	%xmm6,%xmm7+	rorl	$9,%r14d+	xorl	%r9d,%r13d+	xorl	%r11d,%r12d+	rorl	$5,%r13d+	xorl	%ebx,%r14d+	psrlq	$2,%xmm6+	andl	%r9d,%r12d+	xorl	%r9d,%r13d+	addl	28(%rsp),%eax+	pxor	%xmm6,%xmm7+	movl	%ebx,%edi+	xorl	%r11d,%r12d+	rorl	$11,%r14d+	pshufd	$8,%xmm7,%xmm7+	xorl	%ecx,%edi+	addl	%r12d,%eax+	movdqa	16(%rsi),%xmm6+	rorl	$6,%r13d+	andl	%edi,%r15d+	pslldq	$8,%xmm7+	xorl	%ebx,%r14d+	addl	%r13d,%eax+	xorl	%ecx,%r15d+	paddd	%xmm7,%xmm1+	rorl	$2,%r14d+	addl	%eax,%r8d+	addl	%r15d,%eax+	paddd	%xmm1,%xmm6+	movl	%r8d,%r13d+	addl	%eax,%r14d+	movdqa	%xmm6,16(%rsp)+	rorl	$14,%r13d+	movdqa	%xmm3,%xmm4+	movl	%r14d,%eax+	movl	%r9d,%r12d+	movdqa	%xmm1,%xmm7+	rorl	$9,%r14d+	xorl	%r8d,%r13d+	xorl	%r10d,%r12d+	rorl	$5,%r13d+	xorl	%eax,%r14d+.byte	102,15,58,15,226,4+	andl	%r8d,%r12d+	xorl	%r8d,%r13d+.byte	102,15,58,15,248,4+	addl	32(%rsp),%r11d+	movl	%eax,%r15d+	xorl	%r10d,%r12d+	rorl	$11,%r14d+	movdqa	%xmm4,%xmm5+	xorl	%ebx,%r15d+	addl	%r12d,%r11d+	movdqa	%xmm4,%xmm6+	rorl	$6,%r13d+	andl	%r15d,%edi+	psrld	$3,%xmm4+	xorl	%eax,%r14d+	addl	%r13d,%r11d+	xorl	%ebx,%edi+	paddd	%xmm7,%xmm2+	rorl	$2,%r14d+	addl	%r11d,%edx+	psrld	$7,%xmm6+	addl	%edi,%r11d+	movl	%edx,%r13d+	pshufd	$250,%xmm1,%xmm7+	addl	%r11d,%r14d+	rorl	$14,%r13d+	pslld	$14,%xmm5+	movl	%r14d,%r11d+	movl	%r8d,%r12d+	pxor	%xmm6,%xmm4+	rorl	$9,%r14d+	xorl	%edx,%r13d+	xorl	%r9d,%r12d+	rorl	$5,%r13d+	psrld	$11,%xmm6+	xorl	%r11d,%r14d+	pxor	%xmm5,%xmm4+	andl	%edx,%r12d+	xorl	%edx,%r13d+	pslld	$11,%xmm5+	addl	36(%rsp),%r10d+	movl	%r11d,%edi+	pxor	%xmm6,%xmm4+	xorl	%r9d,%r12d+	rorl	$11,%r14d+	movdqa	%xmm7,%xmm6+	xorl	%eax,%edi+	addl	%r12d,%r10d+	pxor	%xmm5,%xmm4+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%r11d,%r14d+	psrld	$10,%xmm7+	addl	%r13d,%r10d+	xorl	%eax,%r15d+	paddd	%xmm4,%xmm2+	rorl	$2,%r14d+	addl	%r10d,%ecx+	psrlq	$17,%xmm6+	addl	%r15d,%r10d+	movl	%ecx,%r13d+	addl	%r10d,%r14d+	pxor	%xmm6,%xmm7+	rorl	$14,%r13d+	movl	%r14d,%r10d+	movl	%edx,%r12d+	rorl	$9,%r14d+	psrlq	$2,%xmm6+	xorl	%ecx,%r13d+	xorl	%r8d,%r12d+	pxor	%xmm6,%xmm7+	rorl	$5,%r13d+	xorl	%r10d,%r14d+	andl	%ecx,%r12d+	pshufd	$128,%xmm7,%xmm7+	xorl	%ecx,%r13d+	addl	40(%rsp),%r9d+	movl	%r10d,%r15d+	psrldq	$8,%xmm7+	xorl	%r8d,%r12d+	rorl	$11,%r14d+	xorl	%r11d,%r15d+	addl	%r12d,%r9d+	rorl	$6,%r13d+	paddd	%xmm7,%xmm2+	andl	%r15d,%edi+	xorl	%r10d,%r14d+	addl	%r13d,%r9d+	pshufd	$80,%xmm2,%xmm7+	xorl	%r11d,%edi+	rorl	$2,%r14d+	addl	%r9d,%ebx+	movdqa	%xmm7,%xmm6+	addl	%edi,%r9d+	movl	%ebx,%r13d+	psrld	$10,%xmm7+	addl	%r9d,%r14d+	rorl	$14,%r13d+	psrlq	$17,%xmm6+	movl	%r14d,%r9d+	movl	%ecx,%r12d+	pxor	%xmm6,%xmm7+	rorl	$9,%r14d+	xorl	%ebx,%r13d+	xorl	%edx,%r12d+	rorl	$5,%r13d+	xorl	%r9d,%r14d+	psrlq	$2,%xmm6+	andl	%ebx,%r12d+	xorl	%ebx,%r13d+	addl	44(%rsp),%r8d+	pxor	%xmm6,%xmm7+	movl	%r9d,%edi+	xorl	%edx,%r12d+	rorl	$11,%r14d+	pshufd	$8,%xmm7,%xmm7+	xorl	%r10d,%edi+	addl	%r12d,%r8d+	movdqa	32(%rsi),%xmm6+	rorl	$6,%r13d+	andl	%edi,%r15d+	pslldq	$8,%xmm7+	xorl	%r9d,%r14d+	addl	%r13d,%r8d+	xorl	%r10d,%r15d+	paddd	%xmm7,%xmm2+	rorl	$2,%r14d+	addl	%r8d,%eax+	addl	%r15d,%r8d+	paddd	%xmm2,%xmm6+	movl	%eax,%r13d+	addl	%r8d,%r14d+	movdqa	%xmm6,32(%rsp)+	rorl	$14,%r13d+	movdqa	%xmm0,%xmm4+	movl	%r14d,%r8d+	movl	%ebx,%r12d+	movdqa	%xmm2,%xmm7+	rorl	$9,%r14d+	xorl	%eax,%r13d+	xorl	%ecx,%r12d+	rorl	$5,%r13d+	xorl	%r8d,%r14d+.byte	102,15,58,15,227,4+	andl	%eax,%r12d+	xorl	%eax,%r13d+.byte	102,15,58,15,249,4+	addl	48(%rsp),%edx+	movl	%r8d,%r15d+	xorl	%ecx,%r12d+	rorl	$11,%r14d+	movdqa	%xmm4,%xmm5+	xorl	%r9d,%r15d+	addl	%r12d,%edx+	movdqa	%xmm4,%xmm6+	rorl	$6,%r13d+	andl	%r15d,%edi+	psrld	$3,%xmm4+	xorl	%r8d,%r14d+	addl	%r13d,%edx+	xorl	%r9d,%edi+	paddd	%xmm7,%xmm3+	rorl	$2,%r14d+	addl	%edx,%r11d+	psrld	$7,%xmm6+	addl	%edi,%edx+	movl	%r11d,%r13d+	pshufd	$250,%xmm2,%xmm7+	addl	%edx,%r14d+	rorl	$14,%r13d+	pslld	$14,%xmm5+	movl	%r14d,%edx+	movl	%eax,%r12d+	pxor	%xmm6,%xmm4+	rorl	$9,%r14d+	xorl	%r11d,%r13d+	xorl	%ebx,%r12d+	rorl	$5,%r13d+	psrld	$11,%xmm6+	xorl	%edx,%r14d+	pxor	%xmm5,%xmm4+	andl	%r11d,%r12d+	xorl	%r11d,%r13d+	pslld	$11,%xmm5+	addl	52(%rsp),%ecx+	movl	%edx,%edi+	pxor	%xmm6,%xmm4+	xorl	%ebx,%r12d+	rorl	$11,%r14d+	movdqa	%xmm7,%xmm6+	xorl	%r8d,%edi+	addl	%r12d,%ecx+	pxor	%xmm5,%xmm4+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%edx,%r14d+	psrld	$10,%xmm7+	addl	%r13d,%ecx+	xorl	%r8d,%r15d+	paddd	%xmm4,%xmm3+	rorl	$2,%r14d+	addl	%ecx,%r10d+	psrlq	$17,%xmm6+	addl	%r15d,%ecx+	movl	%r10d,%r13d+	addl	%ecx,%r14d+	pxor	%xmm6,%xmm7+	rorl	$14,%r13d+	movl	%r14d,%ecx+	movl	%r11d,%r12d+	rorl	$9,%r14d+	psrlq	$2,%xmm6+	xorl	%r10d,%r13d+	xorl	%eax,%r12d+	pxor	%xmm6,%xmm7+	rorl	$5,%r13d+	xorl	%ecx,%r14d+	andl	%r10d,%r12d+	pshufd	$128,%xmm7,%xmm7+	xorl	%r10d,%r13d+	addl	56(%rsp),%ebx+	movl	%ecx,%r15d+	psrldq	$8,%xmm7+	xorl	%eax,%r12d+	rorl	$11,%r14d+	xorl	%edx,%r15d+	addl	%r12d,%ebx+	rorl	$6,%r13d+	paddd	%xmm7,%xmm3+	andl	%r15d,%edi+	xorl	%ecx,%r14d+	addl	%r13d,%ebx+	pshufd	$80,%xmm3,%xmm7+	xorl	%edx,%edi+	rorl	$2,%r14d+	addl	%ebx,%r9d+	movdqa	%xmm7,%xmm6+	addl	%edi,%ebx+	movl	%r9d,%r13d+	psrld	$10,%xmm7+	addl	%ebx,%r14d+	rorl	$14,%r13d+	psrlq	$17,%xmm6+	movl	%r14d,%ebx+	movl	%r10d,%r12d+	pxor	%xmm6,%xmm7+	rorl	$9,%r14d+	xorl	%r9d,%r13d+	xorl	%r11d,%r12d+	rorl	$5,%r13d+	xorl	%ebx,%r14d+	psrlq	$2,%xmm6+	andl	%r9d,%r12d+	xorl	%r9d,%r13d+	addl	60(%rsp),%eax+	pxor	%xmm6,%xmm7+	movl	%ebx,%edi+	xorl	%r11d,%r12d+	rorl	$11,%r14d+	pshufd	$8,%xmm7,%xmm7+	xorl	%ecx,%edi+	addl	%r12d,%eax+	movdqa	48(%rsi),%xmm6+	rorl	$6,%r13d+	andl	%edi,%r15d+	pslldq	$8,%xmm7+	xorl	%ebx,%r14d+	addl	%r13d,%eax+	xorl	%ecx,%r15d+	paddd	%xmm7,%xmm3+	rorl	$2,%r14d+	addl	%eax,%r8d+	addl	%r15d,%eax+	paddd	%xmm3,%xmm6+	movl	%r8d,%r13d+	addl	%eax,%r14d+	movdqa	%xmm6,48(%rsp)+	cmpb	$0,67(%rsi)+	jne	L$ssse3_00_47+	rorl	$14,%r13d+	movl	%r14d,%eax+	movl	%r9d,%r12d+	rorl	$9,%r14d+	xorl	%r8d,%r13d+	xorl	%r10d,%r12d+	rorl	$5,%r13d+	xorl	%eax,%r14d+	andl	%r8d,%r12d+	xorl	%r8d,%r13d+	addl	0(%rsp),%r11d+	movl	%eax,%r15d+	xorl	%r10d,%r12d+	rorl	$11,%r14d+	xorl	%ebx,%r15d+	addl	%r12d,%r11d+	rorl	$6,%r13d+	andl	%r15d,%edi+	xorl	%eax,%r14d+	addl	%r13d,%r11d+	xorl	%ebx,%edi+	rorl	$2,%r14d+	addl	%r11d,%edx+	addl	%edi,%r11d+	movl	%edx,%r13d+	addl	%r11d,%r14d+	rorl	$14,%r13d+	movl	%r14d,%r11d+	movl	%r8d,%r12d+	rorl	$9,%r14d+	xorl	%edx,%r13d+	xorl	%r9d,%r12d+	rorl	$5,%r13d+	xorl	%r11d,%r14d+	andl	%edx,%r12d+	xorl	%edx,%r13d+	addl	4(%rsp),%r10d+	movl	%r11d,%edi+	xorl	%r9d,%r12d+	rorl	$11,%r14d+	xorl	%eax,%edi+	addl	%r12d,%r10d+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%r11d,%r14d+	addl	%r13d,%r10d+	xorl	%eax,%r15d+	rorl	$2,%r14d+	addl	%r10d,%ecx+	addl	%r15d,%r10d+	movl	%ecx,%r13d+	addl	%r10d,%r14d+	rorl	$14,%r13d+	movl	%r14d,%r10d+	movl	%edx,%r12d+	rorl	$9,%r14d+	xorl	%ecx,%r13d+	xorl	%r8d,%r12d+	rorl	$5,%r13d+	xorl	%r10d,%r14d+	andl	%ecx,%r12d+	xorl	%ecx,%r13d+	addl	8(%rsp),%r9d+	movl	%r10d,%r15d+	xorl	%r8d,%r12d+	rorl	$11,%r14d+	xorl	%r11d,%r15d+	addl	%r12d,%r9d+	rorl	$6,%r13d+	andl	%r15d,%edi+	xorl	%r10d,%r14d+	addl	%r13d,%r9d+	xorl	%r11d,%edi+	rorl	$2,%r14d+	addl	%r9d,%ebx+	addl	%edi,%r9d+	movl	%ebx,%r13d+	addl	%r9d,%r14d+	rorl	$14,%r13d+	movl	%r14d,%r9d+	movl	%ecx,%r12d+	rorl	$9,%r14d+	xorl	%ebx,%r13d+	xorl	%edx,%r12d+	rorl	$5,%r13d+	xorl	%r9d,%r14d+	andl	%ebx,%r12d+	xorl	%ebx,%r13d+	addl	12(%rsp),%r8d+	movl	%r9d,%edi+	xorl	%edx,%r12d+	rorl	$11,%r14d+	xorl	%r10d,%edi+	addl	%r12d,%r8d+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%r9d,%r14d+	addl	%r13d,%r8d+	xorl	%r10d,%r15d+	rorl	$2,%r14d+	addl	%r8d,%eax+	addl	%r15d,%r8d+	movl	%eax,%r13d+	addl	%r8d,%r14d+	rorl	$14,%r13d+	movl	%r14d,%r8d+	movl	%ebx,%r12d+	rorl	$9,%r14d+	xorl	%eax,%r13d+	xorl	%ecx,%r12d+	rorl	$5,%r13d+	xorl	%r8d,%r14d+	andl	%eax,%r12d+	xorl	%eax,%r13d+	addl	16(%rsp),%edx+	movl	%r8d,%r15d+	xorl	%ecx,%r12d+	rorl	$11,%r14d+	xorl	%r9d,%r15d+	addl	%r12d,%edx+	rorl	$6,%r13d+	andl	%r15d,%edi+	xorl	%r8d,%r14d+	addl	%r13d,%edx+	xorl	%r9d,%edi+	rorl	$2,%r14d+	addl	%edx,%r11d+	addl	%edi,%edx+	movl	%r11d,%r13d+	addl	%edx,%r14d+	rorl	$14,%r13d+	movl	%r14d,%edx+	movl	%eax,%r12d+	rorl	$9,%r14d+	xorl	%r11d,%r13d+	xorl	%ebx,%r12d+	rorl	$5,%r13d+	xorl	%edx,%r14d+	andl	%r11d,%r12d+	xorl	%r11d,%r13d+	addl	20(%rsp),%ecx+	movl	%edx,%edi+	xorl	%ebx,%r12d+	rorl	$11,%r14d+	xorl	%r8d,%edi+	addl	%r12d,%ecx+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%edx,%r14d+	addl	%r13d,%ecx+	xorl	%r8d,%r15d+	rorl	$2,%r14d+	addl	%ecx,%r10d+	addl	%r15d,%ecx+	movl	%r10d,%r13d+	addl	%ecx,%r14d+	rorl	$14,%r13d+	movl	%r14d,%ecx+	movl	%r11d,%r12d+	rorl	$9,%r14d+	xorl	%r10d,%r13d+	xorl	%eax,%r12d+	rorl	$5,%r13d+	xorl	%ecx,%r14d+	andl	%r10d,%r12d+	xorl	%r10d,%r13d+	addl	24(%rsp),%ebx+	movl	%ecx,%r15d+	xorl	%eax,%r12d+	rorl	$11,%r14d+	xorl	%edx,%r15d+	addl	%r12d,%ebx+	rorl	$6,%r13d+	andl	%r15d,%edi+	xorl	%ecx,%r14d+	addl	%r13d,%ebx+	xorl	%edx,%edi+	rorl	$2,%r14d+	addl	%ebx,%r9d+	addl	%edi,%ebx+	movl	%r9d,%r13d+	addl	%ebx,%r14d+	rorl	$14,%r13d+	movl	%r14d,%ebx+	movl	%r10d,%r12d+	rorl	$9,%r14d+	xorl	%r9d,%r13d+	xorl	%r11d,%r12d+	rorl	$5,%r13d+	xorl	%ebx,%r14d+	andl	%r9d,%r12d+	xorl	%r9d,%r13d+	addl	28(%rsp),%eax+	movl	%ebx,%edi+	xorl	%r11d,%r12d+	rorl	$11,%r14d+	xorl	%ecx,%edi+	addl	%r12d,%eax+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%ebx,%r14d+	addl	%r13d,%eax+	xorl	%ecx,%r15d+	rorl	$2,%r14d+	addl	%eax,%r8d+	addl	%r15d,%eax+	movl	%r8d,%r13d+	addl	%eax,%r14d+	rorl	$14,%r13d+	movl	%r14d,%eax+	movl	%r9d,%r12d+	rorl	$9,%r14d+	xorl	%r8d,%r13d+	xorl	%r10d,%r12d+	rorl	$5,%r13d+	xorl	%eax,%r14d+	andl	%r8d,%r12d+	xorl	%r8d,%r13d+	addl	32(%rsp),%r11d+	movl	%eax,%r15d+	xorl	%r10d,%r12d+	rorl	$11,%r14d+	xorl	%ebx,%r15d+	addl	%r12d,%r11d+	rorl	$6,%r13d+	andl	%r15d,%edi+	xorl	%eax,%r14d+	addl	%r13d,%r11d+	xorl	%ebx,%edi+	rorl	$2,%r14d+	addl	%r11d,%edx+	addl	%edi,%r11d+	movl	%edx,%r13d+	addl	%r11d,%r14d+	rorl	$14,%r13d+	movl	%r14d,%r11d+	movl	%r8d,%r12d+	rorl	$9,%r14d+	xorl	%edx,%r13d+	xorl	%r9d,%r12d+	rorl	$5,%r13d+	xorl	%r11d,%r14d+	andl	%edx,%r12d+	xorl	%edx,%r13d+	addl	36(%rsp),%r10d+	movl	%r11d,%edi+	xorl	%r9d,%r12d+	rorl	$11,%r14d+	xorl	%eax,%edi+	addl	%r12d,%r10d+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%r11d,%r14d+	addl	%r13d,%r10d+	xorl	%eax,%r15d+	rorl	$2,%r14d+	addl	%r10d,%ecx+	addl	%r15d,%r10d+	movl	%ecx,%r13d+	addl	%r10d,%r14d+	rorl	$14,%r13d+	movl	%r14d,%r10d+	movl	%edx,%r12d+	rorl	$9,%r14d+	xorl	%ecx,%r13d+	xorl	%r8d,%r12d+	rorl	$5,%r13d+	xorl	%r10d,%r14d+	andl	%ecx,%r12d+	xorl	%ecx,%r13d+	addl	40(%rsp),%r9d+	movl	%r10d,%r15d+	xorl	%r8d,%r12d+	rorl	$11,%r14d+	xorl	%r11d,%r15d+	addl	%r12d,%r9d+	rorl	$6,%r13d+	andl	%r15d,%edi+	xorl	%r10d,%r14d+	addl	%r13d,%r9d+	xorl	%r11d,%edi+	rorl	$2,%r14d+	addl	%r9d,%ebx+	addl	%edi,%r9d+	movl	%ebx,%r13d+	addl	%r9d,%r14d+	rorl	$14,%r13d+	movl	%r14d,%r9d+	movl	%ecx,%r12d+	rorl	$9,%r14d+	xorl	%ebx,%r13d+	xorl	%edx,%r12d+	rorl	$5,%r13d+	xorl	%r9d,%r14d+	andl	%ebx,%r12d+	xorl	%ebx,%r13d+	addl	44(%rsp),%r8d+	movl	%r9d,%edi+	xorl	%edx,%r12d+	rorl	$11,%r14d+	xorl	%r10d,%edi+	addl	%r12d,%r8d+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%r9d,%r14d+	addl	%r13d,%r8d+	xorl	%r10d,%r15d+	rorl	$2,%r14d+	addl	%r8d,%eax+	addl	%r15d,%r8d+	movl	%eax,%r13d+	addl	%r8d,%r14d+	rorl	$14,%r13d+	movl	%r14d,%r8d+	movl	%ebx,%r12d+	rorl	$9,%r14d+	xorl	%eax,%r13d+	xorl	%ecx,%r12d+	rorl	$5,%r13d+	xorl	%r8d,%r14d+	andl	%eax,%r12d+	xorl	%eax,%r13d+	addl	48(%rsp),%edx+	movl	%r8d,%r15d+	xorl	%ecx,%r12d+	rorl	$11,%r14d+	xorl	%r9d,%r15d+	addl	%r12d,%edx+	rorl	$6,%r13d+	andl	%r15d,%edi+	xorl	%r8d,%r14d+	addl	%r13d,%edx+	xorl	%r9d,%edi+	rorl	$2,%r14d+	addl	%edx,%r11d+	addl	%edi,%edx+	movl	%r11d,%r13d+	addl	%edx,%r14d+	rorl	$14,%r13d+	movl	%r14d,%edx+	movl	%eax,%r12d+	rorl	$9,%r14d+	xorl	%r11d,%r13d+	xorl	%ebx,%r12d+	rorl	$5,%r13d+	xorl	%edx,%r14d+	andl	%r11d,%r12d+	xorl	%r11d,%r13d+	addl	52(%rsp),%ecx+	movl	%edx,%edi+	xorl	%ebx,%r12d+	rorl	$11,%r14d+	xorl	%r8d,%edi+	addl	%r12d,%ecx+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%edx,%r14d+	addl	%r13d,%ecx+	xorl	%r8d,%r15d+	rorl	$2,%r14d+	addl	%ecx,%r10d+	addl	%r15d,%ecx+	movl	%r10d,%r13d+	addl	%ecx,%r14d+	rorl	$14,%r13d+	movl	%r14d,%ecx+	movl	%r11d,%r12d+	rorl	$9,%r14d+	xorl	%r10d,%r13d+	xorl	%eax,%r12d+	rorl	$5,%r13d+	xorl	%ecx,%r14d+	andl	%r10d,%r12d+	xorl	%r10d,%r13d+	addl	56(%rsp),%ebx+	movl	%ecx,%r15d+	xorl	%eax,%r12d+	rorl	$11,%r14d+	xorl	%edx,%r15d+	addl	%r12d,%ebx+	rorl	$6,%r13d+	andl	%r15d,%edi+	xorl	%ecx,%r14d+	addl	%r13d,%ebx+	xorl	%edx,%edi+	rorl	$2,%r14d+	addl	%ebx,%r9d+	addl	%edi,%ebx+	movl	%r9d,%r13d+	addl	%ebx,%r14d+	rorl	$14,%r13d+	movl	%r14d,%ebx+	movl	%r10d,%r12d+	rorl	$9,%r14d+	xorl	%r9d,%r13d+	xorl	%r11d,%r12d+	rorl	$5,%r13d+	xorl	%ebx,%r14d+	andl	%r9d,%r12d+	xorl	%r9d,%r13d+	addl	60(%rsp),%eax+	movl	%ebx,%edi+	xorl	%r11d,%r12d+	rorl	$11,%r14d+	xorl	%ecx,%edi+	addl	%r12d,%eax+	rorl	$6,%r13d+	andl	%edi,%r15d+	xorl	%ebx,%r14d+	addl	%r13d,%eax+	xorl	%ecx,%r15d+	rorl	$2,%r14d+	addl	%eax,%r8d+	addl	%r15d,%eax+	movl	%r8d,%r13d+	addl	%eax,%r14d+	movq	0(%rbp),%rdi+	movl	%r14d,%eax+	movq	8(%rbp),%rsi++	addl	0(%rdi),%eax+	addl	4(%rdi),%ebx+	addl	8(%rdi),%ecx+	addl	12(%rdi),%edx+	addl	16(%rdi),%r8d+	addl	20(%rdi),%r9d+	addl	24(%rdi),%r10d+	addl	28(%rdi),%r11d++	leaq	64(%rsi),%rsi+	cmpq	16(%rbp),%rsi++	movl	%eax,0(%rdi)+	movl	%ebx,4(%rdi)+	movl	%ecx,8(%rdi)+	movl	%edx,12(%rdi)+	movl	%r8d,16(%rdi)+	movl	%r9d,20(%rdi)+	movl	%r10d,24(%rdi)+	movl	%r11d,28(%rdi)+	jb	L$loop_ssse3++	xorps	%xmm0,%xmm0+	leaq	40+48(%rbp),%r11+.cfi_def_cfa	%r11,8+	movaps	%xmm0,0(%rsp)+	movaps	%xmm0,16(%rsp)+	movaps	%xmm0,32(%rsp)+	movaps	%xmm0,48(%rsp)+	movq	40(%rbp),%r15+.cfi_restore	%r15+	movq	-40(%r11),%r14+.cfi_restore	%r14+	movq	-32(%r11),%r13+.cfi_restore	%r13+	movq	-24(%r11),%r12+.cfi_restore	%r12+	movq	-16(%r11),%rbx+.cfi_restore	%rbx+	movq	-8(%r11),%rbp+.cfi_restore	%rbp++	leaq	(%r11),%rsp+	.byte	0xf3,0xc3+.cfi_endproc	++.globl	_blst_sha256_emit+.private_extern	_blst_sha256_emit++.p2align	4+_blst_sha256_emit:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	bswapq	%r8+	movq	24(%rsi),%r11+	bswapq	%r9+	movl	%r8d,4(%rdi)+	bswapq	%r10+	movl	%r9d,12(%rdi)+	bswapq	%r11+	movl	%r10d,20(%rdi)+	shrq	$32,%r8+	movl	%r11d,28(%rdi)+	shrq	$32,%r9+	movl	%r8d,0(%rdi)+	shrq	$32,%r10+	movl	%r9d,8(%rdi)+	shrq	$32,%r11+	movl	%r10d,16(%rdi)+	movl	%r11d,24(%rdi)+	.byte	0xf3,0xc3+.cfi_endproc+++.globl	_blst_sha256_bcopy+.private_extern	_blst_sha256_bcopy++.p2align	4+_blst_sha256_bcopy:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	subq	%rsi,%rdi+L$oop_bcopy:+	movzbl	(%rsi),%eax+	leaq	1(%rsi),%rsi+	movb	%al,-1(%rdi,%rsi,1)+	decq	%rdx+	jnz	L$oop_bcopy+	.byte	0xf3,0xc3+.cfi_endproc+++.globl	_blst_sha256_hcopy+.private_extern	_blst_sha256_hcopy++.p2align	4+_blst_sha256_hcopy:+.cfi_startproc+	.byte	0xf3,0x0f,0x1e,0xfa++	movq	0(%rsi),%r8+	movq	8(%rsi),%r9+	movq	16(%rsi),%r10+	movq	24(%rsi),%r11+	movq	%r8,0(%rdi)+	movq	%r9,8(%rdi)+	movq	%r10,16(%rdi)+	movq	%r11,24(%rdi)+	.byte	0xf3,0xc3+.cfi_endproc+
+ c-source/src/aggregate.c view
@@ -0,0 +1,673 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */++/*+ * Usage pattern on single-processor system is+ *+ * blst_pairing_init(ctx, hash_or_encode, DST);+ * blst_pairing_aggregate_pk_in_g1(ctx, PK[0], aggregated_signature, msg[0]);+ * blst_pairing_aggregate_pk_in_g1(ctx, PK[1], NULL, msg[1]);+ * ...+ * blst_pairing_commit(ctx);+ * blst_pairing_finalverify(ctx, NULL);+ *+ ***********************************************************************+ * Usage pattern on multi-processor system is+ *+ *   blst_pairing_init(pk[0], hash_or_encode, DST);+ *   blst_pairing_init(pk[1], hash_or_encode, DST);+ *   ...+ * start threads each processing an N/nthreads slice of PKs and messages:+ *     blst_pairing_aggregate_pk_in_g1(pk[i], PK[i*n+0], NULL, msg[i*n+0]);+ *     blst_pairing_aggregate_pk_in_g1(pk[i], PK[i*n+1], NULL, msg[i*n+1]);+ *     ...+ *     blst_pairing_commit(pkx);+ *   ...+ * meanwhile in main thread+ *   blst_fp12 gtsig;+ *   blst_aggregated_in_g2(&gtsig, aggregated_signature);+ * join threads and merge their contexts:+ *   blst_pairing_merge(pk[0], pk[1]);+ *   blst_pairing_merge(pk[0], pk[2]);+ *   ...+ *   blst_pairing_finalverify(pk[0], gtsig);+ */++#ifndef N_MAX+# define N_MAX 8+#endif++typedef union { POINTonE1 e1; POINTonE2 e2; } AggregatedSignature;+typedef struct {+    unsigned int ctrl;+    unsigned int nelems;+    const void *DST;+    size_t DST_len;+    vec384fp12 GT;+    AggregatedSignature AggrSign;+    POINTonE2_affine Q[N_MAX];+    POINTonE1_affine P[N_MAX];+} PAIRING;++enum { AGGR_UNDEFINED      = 0,+       AGGR_MIN_SIG        = 1,+       AGGR_MIN_PK         = 2,+       AGGR_SIGN_SET       = 0x10,+       AGGR_GT_SET         = 0x20,+       AGGR_HASH_OR_ENCODE = 0x40 };+#define MIN_SIG_OR_PK (AGGR_MIN_SIG | AGGR_MIN_PK)++static const size_t sizeof_pairing = (sizeof(PAIRING) + 7) & ~(size_t)7;++size_t blst_pairing_sizeof(void)+{   return sizeof_pairing;   }++void blst_pairing_init(PAIRING *ctx, int hash_or_encode,+                       const void *DST, size_t DST_len)+{+    ctx->ctrl = AGGR_UNDEFINED | (hash_or_encode ? AGGR_HASH_OR_ENCODE : 0);+    ctx->nelems = 0;+    ctx->DST = (uptr_t)DST==(uptr_t)((byte *)ctx+sizeof_pairing) ? (void *)42+                                                                 : DST;+    ctx->DST_len = DST_len;+}++static const void *pairing_get_dst(const PAIRING *ctx)+{   return (uptr_t)ctx->DST==(uptr_t)42 ? (const byte *)ctx+sizeof_pairing+                                        : ctx->DST;+}++const void *blst_pairing_get_dst(const PAIRING *ctx)+{   return pairing_get_dst(ctx);   }++#define FROM_AFFINE(out,in) do { \+    vec_copy((out)->X, in->X, 2*sizeof(in->X)), \+    vec_select((out)->Z, in->X, BLS12_381_Rx.p, sizeof(in->X), \+                         vec_is_zero(in->X, 2*sizeof(in->X))); } while(0)++/*+ * Optional |nbits|-wide |scalar| is used to facilitate multiple aggregated+ * signature vetification as discussed at+ * https://ethresear.ch/t/fast-verification-of-multiple-bls-signatures/5407.+ * Usage pattern is not finalized yet, because (sig != NULL) is better and+ * will be handled separately...+ */+static BLST_ERROR PAIRING_Aggregate_PK_in_G2(PAIRING *ctx,+                                             const POINTonE2_affine *PK,+                                             size_t pk_groupcheck,+                                             const POINTonE1_affine *sig,+                                             size_t sig_groupcheck,+                                             const byte *scalar, size_t nbits,+                                             const void *msg, size_t msg_len,+                                             const void *aug, size_t aug_len)+{+    if (ctx->ctrl & AGGR_MIN_PK)+        return BLST_AGGR_TYPE_MISMATCH;++    ctx->ctrl |= AGGR_MIN_SIG;++    /*+     * Since we don't know if the signature is individual or aggregated,+     * the only sensible thing to do is to skip over infinite one and+     * count on the corresponding infinite public key to be rejected,+     * in case the signature is non-aggregated that is.+     */+    if (sig != NULL && !vec_is_zero(sig, sizeof(*sig))) {+        POINTonE1 *S = &ctx->AggrSign.e1;+        POINTonE1 P[1];++        FROM_AFFINE(P, sig);++        if (sig_groupcheck && !POINTonE1_in_G1(P))+            return BLST_POINT_NOT_IN_GROUP;++        if (ctx->ctrl & AGGR_SIGN_SET) {+            if (nbits != 0 && scalar != NULL) {+                POINTonE1_mult_w5(P, P, scalar, nbits);+                POINTonE1_dadd(S, S, P, NULL);+            } else {+                POINTonE1_dadd_affine(S, S, sig);+            }+        } else {+            ctx->ctrl |= AGGR_SIGN_SET;+            if (nbits != 0 && scalar != NULL)+                POINTonE1_mult_w5(S, P, scalar, nbits);+            else+                vec_copy(S, P, sizeof(P));+        }+    }++    if (PK != NULL) {+        unsigned int n;+        POINTonE1 H[1];+        const void *DST = pairing_get_dst(ctx);++        /*+         * Reject infinite public keys.+         */+        if (vec_is_zero(PK, sizeof(*PK)))+            return BLST_PK_IS_INFINITY;++        if (pk_groupcheck) {+            POINTonE2 P[1];++            FROM_AFFINE(P, PK);+            if (!POINTonE2_in_G2(P))+                return BLST_POINT_NOT_IN_GROUP;+        }++        if (ctx->ctrl & AGGR_HASH_OR_ENCODE)+            Hash_to_G1(H, msg, msg_len, DST, ctx->DST_len, aug, aug_len);+        else+            Encode_to_G1(H, msg, msg_len, DST, ctx->DST_len, aug, aug_len);++        if (nbits != 0 && scalar != NULL)+            POINTonE1_mult_w5(H, H, scalar, nbits);++        POINTonE1_from_Jacobian(H, H);++        n = ctx->nelems;+        vec_copy(ctx->Q + n, PK, sizeof(POINTonE2_affine));+        vec_copy(ctx->P + n, H, sizeof(POINTonE1_affine));+        if (++n == N_MAX) {+            if (ctx->ctrl & AGGR_GT_SET) {+                vec384fp12 GT;+                miller_loop_n(GT, ctx->Q, ctx->P, n);+                mul_fp12(ctx->GT, ctx->GT, GT);+            } else {+                miller_loop_n(ctx->GT, ctx->Q, ctx->P, n);+                ctx->ctrl |= AGGR_GT_SET;+            }+            n = 0;+        }+        ctx->nelems = n;+    }++    return BLST_SUCCESS;+}++BLST_ERROR blst_pairing_aggregate_pk_in_g2(PAIRING *ctx,+                                           const POINTonE2_affine *PK,+                                           const POINTonE1_affine *signature,+                                           const void *msg, size_t msg_len,+                                           const void *aug, size_t aug_len)+{   return PAIRING_Aggregate_PK_in_G2(ctx, PK, 0, signature, 1, NULL, 0,+                                      msg, msg_len, aug, aug_len);+}++BLST_ERROR blst_pairing_mul_n_aggregate_pk_in_g2(PAIRING *ctx,+                                                 const POINTonE2_affine *PK,+                                                 const POINTonE1_affine *sig,+                                                 const byte *scalar,+                                                 size_t nbits,+                                                 const void *msg,+                                                 size_t msg_len,+                                                 const void *aug,+                                                 size_t aug_len)+{   return PAIRING_Aggregate_PK_in_G2(ctx, PK, 0, sig, 1, scalar, nbits,+                                      msg, msg_len, aug, aug_len);+}++BLST_ERROR blst_pairing_chk_n_aggr_pk_in_g2(PAIRING *ctx,+                                            const POINTonE2_affine *PK,+                                            size_t pk_grpchk,+                                            const POINTonE1_affine *signature,+                                            size_t sig_grpchk,+                                            const void *msg, size_t msg_len,+                                            const void *aug, size_t aug_len)+{   return PAIRING_Aggregate_PK_in_G2(ctx, PK, pk_grpchk, signature, sig_grpchk,+                                      NULL, 0, msg, msg_len, aug, aug_len);+}++BLST_ERROR blst_pairing_chk_n_mul_n_aggr_pk_in_g2(PAIRING *ctx,+                                                  const POINTonE2_affine *PK,+                                                  size_t pk_grpchk,+                                                  const POINTonE1_affine *sig,+                                                  size_t sig_grpchk,+                                                  const byte *scalar,+                                                  size_t nbits,+                                                  const void *msg,+                                                  size_t msg_len,+                                                  const void *aug,+                                                  size_t aug_len)+{   return PAIRING_Aggregate_PK_in_G2(ctx, PK, pk_grpchk, sig, sig_grpchk,+                                      scalar, nbits,+                                      msg, msg_len, aug, aug_len);+}++static BLST_ERROR PAIRING_Aggregate_PK_in_G1(PAIRING *ctx,+                                             const POINTonE1_affine *PK,+                                             size_t pk_groupcheck,+                                             const POINTonE2_affine *sig,+                                             size_t sig_groupcheck,+                                             const byte *scalar, size_t nbits,+                                             const void *msg, size_t msg_len,+                                             const void *aug, size_t aug_len)+{+    if (ctx->ctrl & AGGR_MIN_SIG)+        return BLST_AGGR_TYPE_MISMATCH;++    ctx->ctrl |= AGGR_MIN_PK;++    /*+     * Since we don't know if the signature is individual or aggregated,+     * the only sensible thing to do is to skip over infinite one and+     * count on the corresponding infinite public key to be rejected,+     * in case the signature is non-aggregated that is.+     */+    if (sig != NULL && !vec_is_zero(sig, sizeof(*sig))) {+        POINTonE2 *S = &ctx->AggrSign.e2;+        POINTonE2 P[1];++        FROM_AFFINE(P, sig);++        if (sig_groupcheck && !POINTonE2_in_G2(P))+            return BLST_POINT_NOT_IN_GROUP;++        if (ctx->ctrl & AGGR_SIGN_SET) {+            if (nbits != 0 && scalar != NULL) {++                POINTonE2_mult_w5(P, P, scalar, nbits);+                POINTonE2_dadd(S, S, P, NULL);+            } else {+                POINTonE2_dadd_affine(S, S, sig);+            }+        } else {+            ctx->ctrl |= AGGR_SIGN_SET;+            if (nbits != 0 && scalar != NULL)+                POINTonE2_mult_w5(S, P, scalar, nbits);+            else+                vec_copy(S, P, sizeof(P));+        }+    }++    if (PK != NULL) {+        unsigned int n;+        POINTonE2 H[1];+        POINTonE1 pk[1];+        const void *DST = pairing_get_dst(ctx);++        /*+         * Reject infinite public keys.+         */+        if (vec_is_zero(PK, sizeof(*PK)))+            return BLST_PK_IS_INFINITY;++        if (pk_groupcheck) {+            POINTonE1 P[1];++            FROM_AFFINE(P, PK);+            if (!POINTonE1_in_G1(P))+                return BLST_POINT_NOT_IN_GROUP;+        }++        if (ctx->ctrl & AGGR_HASH_OR_ENCODE)+            Hash_to_G2(H, msg, msg_len, DST, ctx->DST_len, aug, aug_len);+        else+            Encode_to_G2(H, msg, msg_len, DST, ctx->DST_len, aug, aug_len);++        POINTonE2_from_Jacobian(H, H);++        if (nbits != 0 && scalar != NULL) {+            FROM_AFFINE(pk, PK);+            POINTonE1_mult_w5(pk, pk, scalar, nbits);+            POINTonE1_from_Jacobian(pk, pk);+            PK = (const POINTonE1_affine *)pk;+        }++        n = ctx->nelems;+        vec_copy(ctx->Q + n, H, sizeof(POINTonE2_affine));+        vec_copy(ctx->P + n, PK, sizeof(POINTonE1_affine));+        if (++n == N_MAX) {+            if (ctx->ctrl & AGGR_GT_SET) {+                vec384fp12 GT;+                miller_loop_n(GT, ctx->Q, ctx->P, n);+                mul_fp12(ctx->GT, ctx->GT, GT);+            } else {+                miller_loop_n(ctx->GT, ctx->Q, ctx->P, n);+                ctx->ctrl |= AGGR_GT_SET;+            }+            n = 0;+        }+        ctx->nelems = n;+    }++    return BLST_SUCCESS;+}++BLST_ERROR blst_pairing_aggregate_pk_in_g1(PAIRING *ctx,+                                           const POINTonE1_affine *PK,+                                           const POINTonE2_affine *signature,+                                           const void *msg, size_t msg_len,+                                           const void *aug, size_t aug_len)+{   return PAIRING_Aggregate_PK_in_G1(ctx, PK, 0, signature, 1, NULL, 0,+                                      msg, msg_len, aug, aug_len);+}++BLST_ERROR blst_pairing_mul_n_aggregate_pk_in_g1(PAIRING *ctx,+                                                 const POINTonE1_affine *PK,+                                                 const POINTonE2_affine *sig,+                                                 const byte *scalar,+                                                 size_t nbits,+                                                 const void *msg,+                                                 size_t msg_len,+                                                 const void *aug,+                                                 size_t aug_len)+{   return PAIRING_Aggregate_PK_in_G1(ctx, PK, 0, sig, 1, scalar, nbits,+                                      msg, msg_len, aug, aug_len);+}++BLST_ERROR blst_pairing_chk_n_aggr_pk_in_g1(PAIRING *ctx,+                                            const POINTonE1_affine *PK,+                                            size_t pk_grpchk,+                                            const POINTonE2_affine *signature,+                                            size_t sig_grpchk,+                                            const void *msg, size_t msg_len,+                                            const void *aug, size_t aug_len)+{   return PAIRING_Aggregate_PK_in_G1(ctx, PK, pk_grpchk, signature, sig_grpchk,+                                      NULL, 0, msg, msg_len, aug, aug_len);+}++BLST_ERROR blst_pairing_chk_n_mul_n_aggr_pk_in_g1(PAIRING *ctx,+                                                  const POINTonE1_affine *PK,+                                                  size_t pk_grpchk,+                                                  const POINTonE2_affine *sig,+                                                  size_t sig_grpchk,+                                                  const byte *scalar,+                                                  size_t nbits,+                                                  const void *msg,+                                                  size_t msg_len,+                                                  const void *aug,+                                                  size_t aug_len)+{   return PAIRING_Aggregate_PK_in_G1(ctx, PK, pk_grpchk, sig, sig_grpchk,+                                      scalar, nbits,+                                      msg, msg_len, aug, aug_len);+}++static void PAIRING_Commit(PAIRING *ctx)+{+    unsigned int n;++    if ((n = ctx->nelems) != 0) {+        if (ctx->ctrl & AGGR_GT_SET) {+            vec384fp12 GT;+            miller_loop_n(GT, ctx->Q, ctx->P, n);+            mul_fp12(ctx->GT, ctx->GT, GT);+        } else {+            miller_loop_n(ctx->GT, ctx->Q, ctx->P, n);+            ctx->ctrl |= AGGR_GT_SET;+        }+        ctx->nelems = 0;+    }+}++void blst_pairing_commit(PAIRING *ctx)+{   PAIRING_Commit(ctx);   }++BLST_ERROR blst_pairing_merge(PAIRING *ctx, const PAIRING *ctx1)+{+    if ((ctx->ctrl & MIN_SIG_OR_PK) != AGGR_UNDEFINED+        && (ctx1->ctrl & MIN_SIG_OR_PK) != AGGR_UNDEFINED+        && (ctx->ctrl & ctx1->ctrl & MIN_SIG_OR_PK) == 0)+        return BLST_AGGR_TYPE_MISMATCH;++    /* context producers are expected to have called blst_pairing_commit */+    if (ctx->nelems || ctx1->nelems)+        return BLST_AGGR_TYPE_MISMATCH;++    ctx->ctrl |= ctx1->ctrl & MIN_SIG_OR_PK;++    switch (ctx->ctrl & MIN_SIG_OR_PK) {+        case AGGR_MIN_SIG:+            if (ctx->ctrl & ctx1->ctrl & AGGR_SIGN_SET) {+                POINTonE1_dadd(&ctx->AggrSign.e1, &ctx->AggrSign.e1,+                                                  &ctx1->AggrSign.e1, NULL);+            } else if (ctx1->ctrl & AGGR_SIGN_SET) {+                ctx->ctrl |= AGGR_SIGN_SET;+                vec_copy(&ctx->AggrSign.e1, &ctx1->AggrSign.e1,+                         sizeof(ctx->AggrSign.e1));+            }+            break;+        case AGGR_MIN_PK:+            if (ctx->ctrl & ctx1->ctrl & AGGR_SIGN_SET) {+                POINTonE2_dadd(&ctx->AggrSign.e2, &ctx->AggrSign.e2,+                                                  &ctx1->AggrSign.e2, NULL);+            } else if (ctx1->ctrl & AGGR_SIGN_SET) {+                ctx->ctrl |= AGGR_SIGN_SET;+                vec_copy(&ctx->AggrSign.e2, &ctx1->AggrSign.e2,+                         sizeof(ctx->AggrSign.e2));+            }+            break;+        case AGGR_UNDEFINED:+            break;+        default:+            return BLST_AGGR_TYPE_MISMATCH;+    }++    if (ctx->ctrl & ctx1->ctrl & AGGR_GT_SET) {+        mul_fp12(ctx->GT, ctx->GT, ctx1->GT);+    } else if (ctx1->ctrl & AGGR_GT_SET) {+        ctx->ctrl |= AGGR_GT_SET;+        vec_copy(ctx->GT, ctx1->GT, sizeof(ctx->GT));+    }++    return BLST_SUCCESS;+}++static bool_t PAIRING_FinalVerify(const PAIRING *ctx, const vec384fp12 GTsig)+{+    vec384fp12 GT;++    if (!(ctx->ctrl & AGGR_GT_SET))+        return 0;++    if (GTsig != NULL) {+        vec_copy(GT, GTsig, sizeof(GT));+    } else if (ctx->ctrl & AGGR_SIGN_SET) {+        AggregatedSignature AggrSign;++        switch (ctx->ctrl & MIN_SIG_OR_PK) {+            case AGGR_MIN_SIG:+                POINTonE1_from_Jacobian(&AggrSign.e1, &ctx->AggrSign.e1);+                miller_loop_n(GT, (const POINTonE2_affine *)&BLS12_381_G2,+                                  (const POINTonE1_affine *)&AggrSign.e1, 1);+                break;+            case AGGR_MIN_PK:+                POINTonE2_from_Jacobian(&AggrSign.e2, &ctx->AggrSign.e2);+                miller_loop_n(GT, (const POINTonE2_affine *)&AggrSign.e2,+                                  (const POINTonE1_affine *)&BLS12_381_G1, 1);+                break;+            default:+                return 0;+        }+    } else {+        /*+         * The aggregated signature was infinite, relation between the+         * hashes and the public keys has to be VERY special...+         */+        vec_copy(GT, BLS12_381_Rx.p12, sizeof(GT));+    }++    conjugate_fp12(GT);+    mul_fp12(GT, GT, ctx->GT);+    final_exp(GT, GT);++    /* return GT==1 */+    return vec_is_equal(GT[0][0], BLS12_381_Rx.p2, sizeof(GT[0][0])) &+           vec_is_zero(GT[0][1], sizeof(GT) - sizeof(GT[0][0]));+}++int blst_pairing_finalverify(const PAIRING *ctx, const vec384fp12 GTsig)+{   return (int)PAIRING_FinalVerify(ctx, GTsig);   }++int blst_fp12_finalverify(const vec384fp12 GT1, const vec384fp12 GT2)+{+    vec384fp12 GT;++    vec_copy(GT, GT1, sizeof(GT));+    conjugate_fp12(GT);+    mul_fp12(GT, GT, GT2);+    final_exp(GT, GT);++    /* return GT==1 */+    return (int)(vec_is_equal(GT[0][0], BLS12_381_Rx.p2, sizeof(GT[0][0])) &+                 vec_is_zero(GT[0][1], sizeof(GT) - sizeof(GT[0][0])));+}++void blst_pairing_raw_aggregate(PAIRING *ctx, const POINTonE2_affine *q,+                                              const POINTonE1_affine *p)+{+    unsigned int n;++    if (vec_is_zero(q, sizeof(*q)) & vec_is_zero(p, sizeof(*p)))+        return;++    n = ctx->nelems;+    vec_copy(ctx->Q + n, q, sizeof(*q));+    vec_copy(ctx->P + n, p, sizeof(*p));+    if (++n == N_MAX) {+        if (ctx->ctrl & AGGR_GT_SET) {+            vec384fp12 GT;+            miller_loop_n(GT, ctx->Q, ctx->P, n);+            mul_fp12(ctx->GT, ctx->GT, GT);+        } else {+            miller_loop_n(ctx->GT, ctx->Q, ctx->P, n);+            ctx->ctrl |= AGGR_GT_SET;+        }+        n = 0;+    }+    ctx->nelems = n;+}++vec384fp12 *blst_pairing_as_fp12(PAIRING *ctx)+{+    PAIRING_Commit(ctx);+    return (vec384fp12 *)ctx->GT;+}++/*+ * PAIRING context-free entry points.+ *+ * To perform FastAggregateVerify, aggregate all public keys and+ * signatures with corresponding blst_aggregate_in_g{12}, convert+ * result to affine and call suitable blst_core_verify_pk_in_g{12}+ * or blst_aggregated_in_g{12}...+ */+BLST_ERROR blst_aggregate_in_g1(POINTonE1 *out, const POINTonE1 *in,+                                                const unsigned char *zwire)+{+    POINTonE1 P[1];+    BLST_ERROR ret;++    ret = POINTonE1_Deserialize_Z((POINTonE1_affine *)P, zwire);++    if (ret != BLST_SUCCESS)+        return ret;++    if (vec_is_zero(P, sizeof(POINTonE1_affine))) {+        if (in == NULL)+            vec_zero(out, sizeof(*out));+        return BLST_SUCCESS;+    }++    vec_copy(P->Z, BLS12_381_Rx.p, sizeof(P->Z));++    if (!POINTonE1_in_G1(P))+        return BLST_POINT_NOT_IN_GROUP;++    if (in == NULL)+        vec_copy(out, P, sizeof(P));+    else+        POINTonE1_dadd_affine(out, in, (POINTonE1_affine *)P);++    return BLST_SUCCESS;+}++BLST_ERROR blst_aggregate_in_g2(POINTonE2 *out, const POINTonE2 *in,+                                                const unsigned char *zwire)+{+    POINTonE2 P[1];+    BLST_ERROR ret;++    ret = POINTonE2_Deserialize_Z((POINTonE2_affine *)P, zwire);++    if (ret != BLST_SUCCESS)+        return ret;++    if (vec_is_zero(P, sizeof(POINTonE2_affine))) {+        if (in == NULL)+            vec_zero(out, sizeof(*out));+        return BLST_SUCCESS;+    }++    vec_copy(P->Z, BLS12_381_Rx.p, sizeof(P->Z));++    if (!POINTonE2_in_G2(P))+        return BLST_POINT_NOT_IN_GROUP;++    if (in == NULL) {+        vec_copy(out, P, sizeof(P));+    } else {+        POINTonE2_dadd_affine(out, in, (POINTonE2_affine *)P);+    }+    return BLST_SUCCESS;+}++void blst_aggregated_in_g1(vec384fp12 ret, const POINTonE1_affine *sig)+{   miller_loop_n(ret, (const POINTonE2_affine *)&BLS12_381_G2, sig, 1);   }++void blst_aggregated_in_g2(vec384fp12 ret, const POINTonE2_affine *sig)+{   miller_loop_n(ret, sig, (const POINTonE1_affine *)&BLS12_381_G1, 1);   }++BLST_ERROR blst_core_verify_pk_in_g1(const POINTonE1_affine *pk,+                                     const POINTonE2_affine *signature,+                                     int hash_or_encode,+                                     const void *msg, size_t msg_len,+                                     const void *DST, size_t DST_len,+                                     const void *aug, size_t aug_len)+{+    PAIRING ctx;+    BLST_ERROR ret;++    ctx.ctrl = AGGR_UNDEFINED | (hash_or_encode ? AGGR_HASH_OR_ENCODE : 0);+    ctx.nelems = 0;+    ctx.DST = DST;+    ctx.DST_len = DST_len;++    ret = PAIRING_Aggregate_PK_in_G1(&ctx, pk, 1, signature, 1, NULL, 0,+                                     msg, msg_len, aug, aug_len);+    if (ret != BLST_SUCCESS)+        return ret;++    PAIRING_Commit(&ctx);++    return PAIRING_FinalVerify(&ctx, NULL) ? BLST_SUCCESS : BLST_VERIFY_FAIL;+}++BLST_ERROR blst_core_verify_pk_in_g2(const POINTonE2_affine *pk,+                                     const POINTonE1_affine *signature,+                                     int hash_or_encode,+                                     const void *msg, size_t msg_len,+                                     const void *DST, size_t DST_len,+                                     const void *aug, size_t aug_len)+{+    PAIRING ctx;+    BLST_ERROR ret;++    ctx.ctrl = AGGR_UNDEFINED | (hash_or_encode ? AGGR_HASH_OR_ENCODE : 0);+    ctx.nelems = 0;+    ctx.DST = DST;+    ctx.DST_len = DST_len;++    ret = PAIRING_Aggregate_PK_in_G2(&ctx, pk, 1, signature, 1, NULL, 0,+                                     msg, msg_len, aug, aug_len);+    if (ret != BLST_SUCCESS)+        return ret;++    PAIRING_Commit(&ctx);++    return PAIRING_FinalVerify(&ctx, NULL) ? BLST_SUCCESS : BLST_VERIFY_FAIL;+}
+ c-source/src/bulk_addition.c view
@@ -0,0 +1,168 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */++#include "fields.h"+#include "point.h"++/*+ * This implementation uses explicit addition formula:+ *+ * λ = (Y₂-Y₁)/(X₂-X₁)+ * X₃ = λ²-(X₁+X₂)+ * Y₃ = λ⋅(X₁-X₃)-Y₁+ *+ * But since we don't know if we'll have to add point to itself, we need+ * to eventually resort to corresponding doubling formula:+ *+ * λ = 3X₁²/2Y₁+ * X₃ = λ²-2X₁+ * Y₃ = λ⋅(X₁-X₃)-Y₁+ *+ * The formulae use prohibitively expensive inversion, but whenever we+ * have a lot of affine points to accumulate, we can amortize the cost+ * by applying Montgomery's batch inversion approach. As a result,+ * asymptotic[!] per-point cost for addition is as small as 5M+1S. For+ * comparison, ptype##_dadd_affine takes 8M+5S. In practice, all things+ * considered, the improvement coefficient varies from 60% to 85%+ * depending on platform and curve.+ *+ * THIS IMPLEMENTATION IS *NOT* CONSTANT-TIME. [But if there is an+ * application that requires constant time-ness, speak up!]+ */++/*+ * Calculate λ's numerator and denominator.+ *+ * input:	A	x1	y1	-+ *		B	x2	y2	-+ * output:+ * if A!=B:	A	x1	y1	(x2-x1)*mul_acc+ *		B	x2+x1	y2-y1	(x2-x1)+ *+ * if A==B:	A	x	y	2y*mul_acc+ *		B	2x	3*x^2	2y+ *+ * if A==-B:	A	0	0	1*mul_acc+ *		B	0	3*x^2	0+ */+#define HEAD(ptype, bits, field, one) \+static void ptype##_head(ptype AB[2], const vec##bits mul_acc) \+{ \+    ptype *A = AB, *B = AB+1; \+    limb_t inf = vec_is_zero(A, sizeof(ptype##_affine)) | \+                 vec_is_zero(B, sizeof(ptype##_affine));  \+    static const vec##bits zero = { 0 }; \+\+    sub_##field(B->Z, B->X, A->X);		/* X2-X1  */ \+    add_##field(B->X, B->X, A->X);		/* X2+X1  */ \+    add_##field(A->Z, B->Y, A->Y);		/* Y2+Y1  */ \+    sub_##field(B->Y, B->Y, A->Y);		/* Y2-Y1  */ \+    if (vec_is_zero(B->Z, sizeof(B->Z))) {	/* X2==X1 */ \+        inf = vec_is_zero(A->Z, sizeof(A->Z));	\+        vec_select(B->X, A->Z, B->X, sizeof(B->X), inf); \+        sqr_##field(B->Y, A->X);		\+        mul_by_3_##field(B->Y, B->Y);		/* 3*X1^2 */ \+        vec_copy(B->Z, A->Z, sizeof(B->Z));	/* 2*Y1   */ \+    }						/* B->Y is numenator    */ \+						/* B->Z is denominator  */ \+    vec_select(A->X, B->X, A->X, sizeof(A->X), inf); \+    vec_select(A->Y, A->Z, A->Y, sizeof(A->Y), inf); \+    vec_select(A->Z, one,  B->Z, sizeof(A->Z), inf); \+    vec_select(B->Z, zero, B->Z, sizeof(B->Z), inf); \+    if (mul_acc != NULL) \+        mul_##field(A->Z, A->Z, mul_acc);	/* chain multiplication */\+}++/*+ * Calculate λ and resulting coordinates.+ *+ * input:	A		x1			y1		-+ *		B		x2+x1			nominator	-+ * 		lambda		1/denominator+ * output:	D		x3=(nom/den)^2-(x2+x1)	y3=(nom/den)(x1-x3)-y1+ */+#define TAIL(ptype, bits, field, one) \+static void ptype##_tail(ptype *D, ptype AB[2], vec##bits lambda) \+{ \+    ptype *A = AB, *B = AB+1; \+    vec##bits llambda; \+    limb_t inf = vec_is_zero(B->Z, sizeof(B->Z)); \+\+    mul_##field(lambda, lambda, B->Y);		/* λ = (Y2-Y1)/(X2-X1)  */ \+						/* alt. 3*X1^2/2*Y1     */ \+    sqr_##field(llambda, lambda); \+    sub_##field(D->X, llambda, B->X);		/* X3 = λ^2-X1-X2       */ \+\+    sub_##field(D->Y, A->X, D->X);   \+    mul_##field(D->Y, D->Y, lambda); \+    sub_##field(D->Y, D->Y, A->Y);		/* Y3 = λ*(X1-X3)-Y1    */ \+\+    vec_select(D->X, A->X, D->X, 2*sizeof(D->X), inf); \+    vec_select(B->Z, one, B->Z, sizeof(B->Z), inf); \+}++/*+ * |points[]| is volatile buffer with |X|s and |Y|s initially holding+ * input affine coordinates, and with |Z|s being used as additional+ * temporary storage [unrelated to Jacobian coordinates]. |sum| is+ * in-/output, initialize to infinity accordingly.+ */+#define ADDITION_BTREE(prefix, ptype, bits, field, one) \+HEAD(ptype, bits, field, one) \+TAIL(ptype, bits, field, one) \+static void ptype##s_accumulate(ptype *sum, ptype points[], size_t n) \+{ \+    ptype *dst; \+    void *mul_acc; \+    size_t i; \+\+    while (n >= 16) { \+        if (n & 1) \+            ptype##_dadd_affine(sum, sum, (const ptype##_affine *)points++); \+        n /= 2; \+        for (mul_acc = NULL, i = n; i--; mul_acc = points->Z, points += 2) \+            ptype##_head(points, mul_acc); \+\+        reciprocal_##field(points[-2].Z, points[-2].Z); /* 1/∏ Zi */ \+\+        for (dst = points, i = n; --i;) { \+            dst--; points -= 2; \+            mul_##field(points[-2].Z, points[0].Z, points[-2].Z); \+            ptype##_tail(dst, points, points[-2].Z); \+            mul_##field(points[-2].Z, points[0].Z, points[1].Z); \+        } \+        dst--; points -= 2; \+        ptype##_tail(dst, points, points[0].Z); \+        points = dst; \+    } \+    while (n--) \+        ptype##_dadd_affine(sum, sum, (const ptype##_affine *)points++); \+} \+\+void prefix##s_add(ptype *sum, const ptype##_affine *const points[], \+                               size_t npoints) \+{ \+    /* Performance with 288K scratch is within 1-2-3% from optimal */ \+    const size_t stride = sizeof(ptype)==sizeof(POINTonE1) ? 2048 : 1024; \+    ptype *scratch = alloca((npoints > stride ? stride : npoints) * \+                            sizeof(ptype)); \+    const ptype##_affine *point = NULL; \+\+    vec_zero(sum, sizeof(*sum)); \+    while (npoints) { \+        size_t i, j = npoints > stride ? stride : npoints; \+        for (i=0; i<j; i++) { \+            point = *points ? *points++ : point+1; \+            vec_copy(&scratch[i], point, sizeof(*point)); \+        } \+        ptype##s_accumulate(sum, scratch, j); \+        npoints -= j; \+    } \+}++ADDITION_BTREE(blst_p1, POINTonE1, 384, fp, BLS12_381_Rx.p2)++ADDITION_BTREE(blst_p2, POINTonE2, 384x, fp2, BLS12_381_Rx.p2)
+ c-source/src/bytes.h view
@@ -0,0 +1,152 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */+#ifndef __BLS12_381_ASM_BYTES_H__+#define __BLS12_381_ASM_BYTES_H__++static inline void bytes_zero(unsigned char *a, size_t num)+{+    size_t i;++    for (i = 0; i < num; i++)+        a[i] = 0;+}++static inline void limbs_from_be_bytes(limb_t *restrict ret,+                                       const unsigned char *in, size_t n)+{+    limb_t limb = 0;++    while(n--) {+        limb <<= 8;+        limb |= *in++;+        /*+         * 'if (n % sizeof(limb_t) == 0)' is omitted because it's cheaper+         * to perform redundant stores than to pay penalty for+         * mispredicted branch. Besides, some compilers unroll the+         * loop and remove redundant stores to 'restict'-ed storage...+         */+        ret[n / sizeof(limb_t)] = limb;+    }+}++static inline void be_bytes_from_limbs(unsigned char *out, const limb_t *in,+                                       size_t n)+{+    limb_t limb;++    while(n--) {+        limb = in[n / sizeof(limb_t)];+        *out++ = (unsigned char)(limb >> (8 * (n % sizeof(limb_t))));+    }+}++static inline void limbs_from_le_bytes(limb_t *restrict ret,+                                       const unsigned char *in, size_t n)+{+    limb_t limb = 0;++    while(n--) {+        limb <<= 8;+        limb |= in[n];+        /*+         * 'if (n % sizeof(limb_t) == 0)' is omitted because it's cheaper+         * to perform redundant stores than to pay penalty for+         * mispredicted branch. Besides, some compilers unroll the+         * loop and remove redundant stores to 'restict'-ed storage...+         */+        ret[n / sizeof(limb_t)] = limb;+    }+}++static inline void le_bytes_from_limbs(unsigned char *out, const limb_t *in,+                                       size_t n)+{+    const union {+        long one;+        char little;+    } is_endian = { 1 };+    limb_t limb;+    size_t i, j, r;++    if ((uptr_t)out == (uptr_t)in && is_endian.little)+        return;++    r = n % sizeof(limb_t);+    n /= sizeof(limb_t);++    for(i = 0; i < n; i++) {+        for (limb = in[i], j = 0; j < sizeof(limb_t); j++, limb >>= 8)+            *out++ = (unsigned char)limb;+    }+    if (r) {+        for (limb = in[i], j = 0; j < r; j++, limb >>= 8)+            *out++ = (unsigned char)limb;+    }+}++static inline char hex_from_nibble(unsigned char nibble)+{+    int mask = (9 - (nibble &= 0xf)) >> 31;+    return (char)(nibble + ((('a'-10) & mask) | ('0' & ~mask)));+}++static unsigned char nibble_from_hex(char c)+{+    int mask, ret;++    mask = (('a'-c-1) & (c-1-'f')) >> 31;+    ret  = (10 + c - 'a') & mask;+    mask = (('A'-c-1) & (c-1-'F')) >> 31;+    ret |= (10 + c - 'A') & mask;+    mask = (('0'-c-1) & (c-1-'9')) >> 31;+    ret |= (c - '0') & mask;+    mask = ((ret-1) & ~mask) >> 31;+    ret |= 16 & mask;++    return (unsigned char)ret;+}++static void bytes_from_hexascii(unsigned char *ret, size_t sz, const char *hex)+{+    size_t len;+    unsigned char b = 0;++    if (hex[0]=='0' && (hex[1]=='x' || hex[1]=='X'))+        hex += 2;++    for (len = 0; len<2*sz && nibble_from_hex(hex[len])<16; len++) ;++    bytes_zero(ret, sz);++    while(len--) {+        b <<= 4;+        b |= nibble_from_hex(*hex++);+        if (len % 2 == 0)+            ret[len / 2] = b;+    }+}++static void limbs_from_hexascii(limb_t *ret, size_t sz, const char *hex)+{+    size_t len;+    limb_t limb = 0;++    if (hex[0]=='0' && (hex[1]=='x' || hex[1]=='X'))+        hex += 2;++    for (len = 0; len<2*sz && nibble_from_hex(hex[len])<16; len++) ;++    vec_zero(ret, sz);++    while(len--) {+        limb <<= 4;+        limb |= nibble_from_hex(*hex++);+        if (len % (2*sizeof(limb_t)) == 0)+            ret[len / (2*sizeof(limb_t))] = limb;+    }+}++#endif
+ c-source/src/client_min_pk.c view
@@ -0,0 +1,17 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */++#include "keygen.c"+#include "e2.c"+#include "hash_to_field.c"+#include "map_to_g2.c"+#include "e1.c"+#include "exp.c"+#include "sqrt.c"+#include "recip.c"+#include "consts.c"+#include "vect.c"+#include "exports.c"
+ c-source/src/client_min_sig.c view
@@ -0,0 +1,17 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */++#include "keygen.c"+#include "e1.c"+#include "hash_to_field.c"+#include "map_to_g1.c"+#include "e2.c"+#include "exp.c"+#include "sqrt.c"+#include "recip.c"+#include "consts.c"+#include "vect.c"+#include "exports.c"
+ c-source/src/consts.c view
@@ -0,0 +1,36 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */++#include "consts.h"++/* z = -0xd201000000010000 */+const vec384 BLS12_381_P = {    /* (z-1)^2 * (z^4 - z^2 + 1)/3 + z */+    TO_LIMB_T(0xb9feffffffffaaab), TO_LIMB_T(0x1eabfffeb153ffff),+    TO_LIMB_T(0x6730d2a0f6b0f624), TO_LIMB_T(0x64774b84f38512bf),+    TO_LIMB_T(0x4b1ba7b6434bacd7), TO_LIMB_T(0x1a0111ea397fe69a)+};+const limb_t BLS12_381_p0 = (limb_t)0x89f3fffcfffcfffd;  /* -1/P */++const radix384 BLS12_381_Rx = { /* (1<<384)%P, "radix", one-in-Montgomery */+  { { ONE_MONT_P },+    { 0 } }+};++const vec384 BLS12_381_RR = {   /* (1<<768)%P, "radix"^2, to-Montgomery */+    TO_LIMB_T(0xf4df1f341c341746), TO_LIMB_T(0x0a76e6a609d104f1),+    TO_LIMB_T(0x8de5476c4c95b6d5), TO_LIMB_T(0x67eb88a9939d83c0),+    TO_LIMB_T(0x9a793e85b519952d), TO_LIMB_T(0x11988fe592cae3aa)+};++const vec256 BLS12_381_r = {    /* z^4 - z^2 + 1, group order */+    TO_LIMB_T(0xffffffff00000001), TO_LIMB_T(0x53bda402fffe5bfe),+    TO_LIMB_T(0x3339d80809a1d805), TO_LIMB_T(0x73eda753299d7d48)+};++const vec256 BLS12_381_rRR = {  /* (1<<512)%r, "radix"^2, to-Montgomery */+    TO_LIMB_T(0xc999e990f3f29c6d), TO_LIMB_T(0x2b6cedcb87925c23),+    TO_LIMB_T(0x05d314967254398f), TO_LIMB_T(0x0748d9d99f59ff11)+};
+ c-source/src/consts.h view
@@ -0,0 +1,30 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */+#ifndef __BLS12_381_ASM_CONST_H__+#define __BLS12_381_ASM_CONST_H__+#include "vect.h"++extern const vec384 BLS12_381_P;+extern const limb_t BLS12_381_p0;+static const limb_t p0 = (limb_t)0x89f3fffcfffcfffd;  /* -1/P */+typedef union { vec384 p12[12]; vec384x p2; vec384 p; } radix384;+extern const radix384 BLS12_381_Rx; /* (1<<384)%P, "radix", one-in-Montgomery */+extern const vec384 BLS12_381_RR;   /* (1<<768)%P, "radix"^2, to-Montgomery   */++#define ONE_MONT_P TO_LIMB_T(0x760900000002fffd), \+                   TO_LIMB_T(0xebf4000bc40c0002), \+                   TO_LIMB_T(0x5f48985753c758ba), \+                   TO_LIMB_T(0x77ce585370525745), \+                   TO_LIMB_T(0x5c071a97a256ec6d), \+                   TO_LIMB_T(0x15f65ec3fa80e493)++#define ZERO_384 (BLS12_381_Rx.p2[1])++extern const vec256 BLS12_381_r;    /* order */+static const limb_t r0 = (limb_t)0xfffffffeffffffff;  /* -1/r */+extern const vec256 BLS12_381_rRR;  /* (1<<512)%r, "radix"^2, to-Montgomery   */++#endif
+ c-source/src/e1.c view
@@ -0,0 +1,564 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */++#include "point.h"+#include "fields.h"+#include "errors.h"++/*+ * y^2 = x^3 + B+ */+static const vec384 B_E1 = {        /* (4 << 384) % P */+    TO_LIMB_T(0xaa270000000cfff3), TO_LIMB_T(0x53cc0032fc34000a),+    TO_LIMB_T(0x478fe97a6b0a807f), TO_LIMB_T(0xb1d37ebee6ba24d7),+    TO_LIMB_T(0x8ec9733bbf78ab2f), TO_LIMB_T(0x09d645513d83de7e)+};++const POINTonE1 BLS12_381_G1 = {    /* generator point [in Montgomery] */+  /* (0x17f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905+   *    a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb << 384) % P */+  { TO_LIMB_T(0x5cb38790fd530c16), TO_LIMB_T(0x7817fc679976fff5),+    TO_LIMB_T(0x154f95c7143ba1c1), TO_LIMB_T(0xf0ae6acdf3d0e747),+    TO_LIMB_T(0xedce6ecc21dbf440), TO_LIMB_T(0x120177419e0bfb75) },+  /* (0x08b3f481e3aaa0f1a09e30ed741d8ae4fcf5e095d5d00af6+   *    00db18cb2c04b3edd03cc744a2888ae40caa232946c5e7e1 << 384) % P */+  { TO_LIMB_T(0xbaac93d50ce72271), TO_LIMB_T(0x8c22631a7918fd8e),+    TO_LIMB_T(0xdd595f13570725ce), TO_LIMB_T(0x51ac582950405194),+    TO_LIMB_T(0x0e1c8c3fad0059c0), TO_LIMB_T(0x0bbc3efc5008a26a) },+  { ONE_MONT_P }+};++const POINTonE1 BLS12_381_NEG_G1 = { /* negative generator [in Montgomery] */+  /* (0x17f1d3a73197d7942695638c4fa9ac0fc3688c4f9774b905+   *    a14e3a3f171bac586c55e83ff97a1aeffb3af00adb22c6bb << 384) % P */+  { TO_LIMB_T(0x5cb38790fd530c16), TO_LIMB_T(0x7817fc679976fff5),+    TO_LIMB_T(0x154f95c7143ba1c1), TO_LIMB_T(0xf0ae6acdf3d0e747),+    TO_LIMB_T(0xedce6ecc21dbf440), TO_LIMB_T(0x120177419e0bfb75) },+  /* (0x114d1d6855d545a8aa7d76c8cf2e21f267816aef1db507c9+   *    6655b9d5caac42364e6f38ba0ecb751bad54dcd6b939c2ca << 384) % P */+  { TO_LIMB_T(0xff526c2af318883a), TO_LIMB_T(0x92899ce4383b0270),+    TO_LIMB_T(0x89d7738d9fa9d055), TO_LIMB_T(0x12caf35ba344c12a),+    TO_LIMB_T(0x3cff1b76964b5317), TO_LIMB_T(0x0e44d2ede9774430) },+  { ONE_MONT_P }+};++static inline void mul_by_b_onE1(vec384 out, const vec384 in)+{   lshift_fp(out, in, 2);   }++static inline void mul_by_4b_onE1(vec384 out, const vec384 in)+{   lshift_fp(out, in, 4);   }++static void POINTonE1_cneg(POINTonE1 *p, bool_t cbit)+{   cneg_fp(p->Y, p->Y, cbit);   }++void blst_p1_cneg(POINTonE1 *a, int cbit)+{   POINTonE1_cneg(a, is_zero(cbit) ^ 1);   }++static void POINTonE1_from_Jacobian(POINTonE1 *out, const POINTonE1 *in)+{+    vec384 Z, ZZ;+    limb_t inf = vec_is_zero(in->Z, sizeof(in->Z));++    reciprocal_fp(Z, in->Z);                            /* 1/Z   */++    sqr_fp(ZZ, Z);+    mul_fp(out->X, in->X, ZZ);                          /* X = X/Z^2 */++    mul_fp(ZZ, ZZ, Z);+    mul_fp(out->Y, in->Y, ZZ);                          /* Y = Y/Z^3 */++    vec_select(out->Z, in->Z, BLS12_381_G1.Z,+                       sizeof(BLS12_381_G1.Z), inf);    /* Z = inf ? 0 : 1 */+}++void blst_p1_from_jacobian(POINTonE1 *out, const POINTonE1 *a)+{   POINTonE1_from_Jacobian(out, a);   }++static void POINTonE1_to_affine(POINTonE1_affine *out, const POINTonE1 *in)+{+    POINTonE1 p;++    if (!vec_is_equal(in->Z, BLS12_381_Rx.p, sizeof(in->Z))) {+        POINTonE1_from_Jacobian(&p, in);+        in = &p;+    }+    vec_copy(out, in, sizeof(*out));+}++void blst_p1_to_affine(POINTonE1_affine *out, const POINTonE1 *a)+{   POINTonE1_to_affine(out, a);   }++void blst_p1_from_affine(POINTonE1 *out, const POINTonE1_affine *a)+{+    vec_copy(out, a, sizeof(*a));+    vec_select(out->Z, a->X, BLS12_381_Rx.p, sizeof(out->Z),+                       vec_is_zero(a, sizeof(*a)));+}++static bool_t POINTonE1_affine_on_curve(const POINTonE1_affine *p)+{+    vec384 XXX, YY;++    sqr_fp(XXX, p->X);+    mul_fp(XXX, XXX, p->X);                             /* X^3 */+    add_fp(XXX, XXX, B_E1);                             /* X^3 + B */++    sqr_fp(YY, p->Y);                                   /* Y^2 */++    return vec_is_equal(XXX, YY, sizeof(XXX));+}++int blst_p1_affine_on_curve(const POINTonE1_affine *p)+{   return (int)(POINTonE1_affine_on_curve(p) | vec_is_zero(p, sizeof(*p)));   }++static bool_t POINTonE1_on_curve(const POINTonE1 *p)+{+    vec384 XXX, YY, BZ6;+    limb_t inf = vec_is_zero(p->Z, sizeof(p->Z));++    sqr_fp(BZ6, p->Z);+    mul_fp(BZ6, BZ6, p->Z);+    sqr_fp(BZ6, BZ6);                                   /* Z^6 */+    mul_by_b_onE1(BZ6, BZ6);                            /* B*Z^6 */++    sqr_fp(XXX, p->X);+    mul_fp(XXX, XXX, p->X);                             /* X^3 */+    add_fp(XXX, XXX, BZ6);                              /* X^3 + B*Z^6 */++    sqr_fp(YY, p->Y);                                   /* Y^2 */++    return vec_is_equal(XXX, YY, sizeof(XXX)) | inf;+}++int blst_p1_on_curve(const POINTonE1 *p)+{   return (int)POINTonE1_on_curve(p);   }++static limb_t POINTonE1_affine_Serialize_BE(unsigned char out[96],+                                            const POINTonE1_affine *in)+{+    vec384 temp;++    from_fp(temp, in->X);+    be_bytes_from_limbs(out, temp, sizeof(temp));++    from_fp(temp, in->Y);+    be_bytes_from_limbs(out + 48, temp, sizeof(temp));++    return sgn0_pty_mod_384(temp, BLS12_381_P);+}++void blst_p1_affine_serialize(unsigned char out[96],+                              const POINTonE1_affine *in)+{+    if (vec_is_zero(in->X, 2*sizeof(in->X))) {+        bytes_zero(out, 96);+        out[0] = 0x40;    /* infinitiy bit */+    } else {+        (void)POINTonE1_affine_Serialize_BE(out, in);+    }+}++static limb_t POINTonE1_Serialize_BE(unsigned char out[96],+                                     const POINTonE1 *in)+{+    POINTonE1 p;++    if (!vec_is_equal(in->Z, BLS12_381_Rx.p, sizeof(in->Z))) {+        POINTonE1_from_Jacobian(&p, in);+        in = &p;+    }++    return POINTonE1_affine_Serialize_BE(out, (const POINTonE1_affine *)in);+}++static void POINTonE1_Serialize(unsigned char out[96], const POINTonE1 *in)+{+    if (vec_is_zero(in->Z, sizeof(in->Z))) {+        bytes_zero(out, 96);+        out[0] = 0x40;    /* infinitiy bit */+    } else {+        (void)POINTonE1_Serialize_BE(out, in);+    }+}++void blst_p1_serialize(unsigned char out[96], const POINTonE1 *in)+{   POINTonE1_Serialize(out, in);   }++static limb_t POINTonE1_affine_Compress_BE(unsigned char out[48],+                                           const POINTonE1_affine *in)+{+    vec384 temp;++    from_fp(temp, in->X);+    be_bytes_from_limbs(out, temp, sizeof(temp));++    return sgn0_pty_mont_384(in->Y, BLS12_381_P, p0);+}++void blst_p1_affine_compress(unsigned char out[48], const POINTonE1_affine *in)+{+    if (vec_is_zero(in->X, 2*sizeof(in->X))) {+        bytes_zero(out, 48);+        out[0] = 0xc0;    /* compressed and infinitiy bits */+    } else {+        limb_t sign = POINTonE1_affine_Compress_BE(out, in);+        out[0] |= (unsigned char)(0x80 | ((sign & 2) << 4));+    }+}++static limb_t POINTonE1_Compress_BE(unsigned char out[48],+                                    const POINTonE1 *in)+{+    POINTonE1 p;++    if (!vec_is_equal(in->Z, BLS12_381_Rx.p, sizeof(in->Z))) {+        POINTonE1_from_Jacobian(&p, in);+        in = &p;+    }++    return POINTonE1_affine_Compress_BE(out, (const POINTonE1_affine *)in);+}++void blst_p1_compress(unsigned char out[48], const POINTonE1 *in)+{+    if (vec_is_zero(in->Z, sizeof(in->Z))) {+        bytes_zero(out, 48);+        out[0] = 0xc0;    /* compressed and infinitiy bits */+    } else {+        limb_t sign = POINTonE1_Compress_BE(out, in);+        out[0] |= (unsigned char)(0x80 | ((sign & 2) << 4));+    }+}++static limb_t POINTonE1_Uncompress_BE(POINTonE1_affine *out,+                                      const unsigned char in[48])+{+    POINTonE1_affine ret;+    vec384 temp;++    limbs_from_be_bytes(ret.X, in, sizeof(ret.X));+    /* clear top 3 bits in case caller was conveying some information there */+    ret.X[sizeof(ret.X)/sizeof(limb_t)-1] &= ((limb_t)0-1) >> 3;+    add_fp(temp, ret.X, ZERO_384);  /* less than modulus? */+    if (!vec_is_equal(temp, ret.X, sizeof(temp)))+        return (limb_t)0 - BLST_BAD_ENCODING;+    mul_fp(ret.X, ret.X, BLS12_381_RR);++    sqr_fp(ret.Y, ret.X);+    mul_fp(ret.Y, ret.Y, ret.X);+    add_fp(ret.Y, ret.Y, B_E1);                         /* X^3 + B */+    if (!sqrt_fp(ret.Y, ret.Y))+        return (limb_t)0 - BLST_POINT_NOT_ON_CURVE;++    vec_copy(out, &ret, sizeof(ret));++    return sgn0_pty_mont_384(out->Y, BLS12_381_P, p0);+}++static BLST_ERROR POINTonE1_Uncompress_Z(POINTonE1_affine *out,+                                         const unsigned char in[48])+{+    unsigned char in0 = in[0];+    limb_t sgn0_pty;++    if ((in0 & 0x80) == 0)      /* compressed bit */+        return BLST_BAD_ENCODING;++    if (in0 & 0x40) {           /* infinity bit */+        if (byte_is_zero(in0 & 0x3f) & bytes_are_zero(in+1, 47)) {+            vec_zero(out, sizeof(*out));+            return BLST_SUCCESS;+        } else {+            return BLST_BAD_ENCODING;+        }+    }++    sgn0_pty = POINTonE1_Uncompress_BE(out, in);++    if (sgn0_pty > 3)+        return (BLST_ERROR)(0 - sgn0_pty); /* POINT_NOT_ON_CURVE */++    sgn0_pty >>= 1; /* skip over parity bit */+    sgn0_pty ^= (in0 & 0x20) >> 5;+    cneg_fp(out->Y, out->Y, sgn0_pty);++    /* (0,±2) is not in group, but application might want to ignore? */+    return vec_is_zero(out->X, sizeof(out->X)) ? BLST_POINT_NOT_IN_GROUP+                                               : BLST_SUCCESS;+}++BLST_ERROR blst_p1_uncompress(POINTonE1_affine *out, const unsigned char in[48])+{   return POINTonE1_Uncompress_Z(out, in);   }++static BLST_ERROR POINTonE1_Deserialize_BE(POINTonE1_affine *out,+                                           const unsigned char in[96])+{+    POINTonE1_affine ret;+    vec384 temp;++    limbs_from_be_bytes(ret.X, in, sizeof(ret.X));+    limbs_from_be_bytes(ret.Y, in + 48, sizeof(ret.Y));++    /* clear top 3 bits in case caller was conveying some information there */+    ret.X[sizeof(ret.X)/sizeof(limb_t)-1] &= ((limb_t)0-1) >> 3;+    add_fp(temp, ret.X, ZERO_384);  /* less than modulus? */+    if (!vec_is_equal(temp, ret.X, sizeof(temp)))+        return BLST_BAD_ENCODING;++    add_fp(temp, ret.Y, ZERO_384);  /* less than modulus? */+    if (!vec_is_equal(temp, ret.Y, sizeof(temp)))+        return BLST_BAD_ENCODING;++    mul_fp(ret.X, ret.X, BLS12_381_RR);+    mul_fp(ret.Y, ret.Y, BLS12_381_RR);++    if (!POINTonE1_affine_on_curve(&ret))+        return BLST_POINT_NOT_ON_CURVE;++    vec_copy(out, &ret, sizeof(ret));++    /* (0,±2) is not in group, but application might want to ignore? */+    return vec_is_zero(out->X, sizeof(out->X)) ? BLST_POINT_NOT_IN_GROUP+                                               : BLST_SUCCESS;+}++static BLST_ERROR POINTonE1_Deserialize_Z(POINTonE1_affine *out,+                                          const unsigned char in[96])+{+    unsigned char in0 = in[0];++    if ((in0 & 0xe0) == 0)+        return POINTonE1_Deserialize_BE(out, in);++    if (in0 & 0x80)             /* compressed bit */+        return POINTonE1_Uncompress_Z(out, in);++    if (in0 & 0x40) {           /* infinity bit */+        if (byte_is_zero(in0 & 0x3f) & bytes_are_zero(in+1, 95)) {+            vec_zero(out, sizeof(*out));+            return BLST_SUCCESS;+        }+    }++    return BLST_BAD_ENCODING;+}++BLST_ERROR blst_p1_deserialize(POINTonE1_affine *out,+                               const unsigned char in[96])+{   return POINTonE1_Deserialize_Z(out, in);   }++#include "ec_ops.h"+POINT_DADD_IMPL(POINTonE1, 384, fp)+POINT_DADD_AFFINE_IMPL_A0(POINTonE1, 384, fp, BLS12_381_Rx.p)+POINT_ADD_IMPL(POINTonE1, 384, fp)+POINT_ADD_AFFINE_IMPL(POINTonE1, 384, fp, BLS12_381_Rx.p)+POINT_DOUBLE_IMPL_A0(POINTonE1, 384, fp)+POINT_IS_EQUAL_IMPL(POINTonE1, 384, fp)++void blst_p1_add(POINTonE1 *out, const POINTonE1 *a, const POINTonE1 *b)+{   POINTonE1_add(out, a, b);   }++void blst_p1_add_or_double(POINTonE1 *out, const POINTonE1 *a,+                                           const POINTonE1 *b)+{   POINTonE1_dadd(out, a, b, NULL);   }++void blst_p1_add_affine(POINTonE1 *out, const POINTonE1 *a,+                                        const POINTonE1_affine *b)+{   POINTonE1_add_affine(out, a, b);   }++void blst_p1_add_or_double_affine(POINTonE1 *out, const POINTonE1 *a,+                                                  const POINTonE1_affine *b)+{   POINTonE1_dadd_affine(out, a, b);   }++void blst_p1_double(POINTonE1 *out, const POINTonE1 *a)+{   POINTonE1_double(out, a);   }++int blst_p1_is_equal(const POINTonE1 *a, const POINTonE1 *b)+{   return (int)POINTonE1_is_equal(a, b);   }++#include "ec_mult.h"+POINT_MULT_SCALAR_WX_IMPL(POINTonE1, 4)+POINT_MULT_SCALAR_WX_IMPL(POINTonE1, 5)++#ifdef __BLST_PRIVATE_TESTMODE__+POINT_AFFINE_MULT_SCALAR_IMPL(POINTonE1)++DECLARE_PRIVATE_POINTXZ(POINTonE1, 384)+POINT_LADDER_PRE_IMPL(POINTonE1, 384, fp)+POINT_LADDER_STEP_IMPL_A0(POINTonE1, 384, fp, onE1)+POINT_LADDER_POST_IMPL_A0(POINTonE1, 384, fp, onE1)+POINT_MULT_SCALAR_LADDER_IMPL(POINTonE1)+#endif++static const vec384 beta = {            /* such that beta^3 - 1 = 0  */+    /* -1/2 * (1 + sqrt(-3)) = ((P-2)^(P-2)) * (1 + (P-3)^((P+1)/4)) */+    /* (0x1a0111ea397fe699ec02408663d4de85aa0d857d89759ad4+          897d29650fb85f9b409427eb4f49fffd8bfd00000000aaac << 384) % P */+    TO_LIMB_T(0xcd03c9e48671f071), TO_LIMB_T(0x5dab22461fcda5d2),+    TO_LIMB_T(0x587042afd3851b95), TO_LIMB_T(0x8eb60ebe01bacb9e),+    TO_LIMB_T(0x03f97d6e83d050d2), TO_LIMB_T(0x18f0206554638741)+};++static void sigma(POINTonE1 *out, const POINTonE1 *in)+{+    vec_copy(out->X, in->X, 2*sizeof(out->X));+    mul_fp(out->Z, in->Z, beta);+}++/* Gallant-Lambert-Vanstone, ~45% faster than POINTonE1_mult_w5 */+static void POINTonE1_mult_glv(POINTonE1 *out, const POINTonE1 *in,+                               const pow256 SK)+{+    union { vec256 l; pow256 s; } val;++    /* SK/z^2 [in constant time] */++    limbs_from_le_bytes(val.l, SK, 32);+    div_by_zz(val.l);+    le_bytes_from_limbs(val.s, val.l, 32);++    {+        const byte *scalars[2] = { val.s+16, val.s };+        POINTonE1 table[2][1<<(5-1)];   /* 4.5KB */+        size_t i;++        POINTonE1_precompute_w5(table[0], in);+        for (i = 0; i < 1<<(5-1); i++) {+            mul_fp(table[1][i].X, table[0][i].X, beta);+            cneg_fp(table[1][i].Y, table[0][i].Y, 1);+            vec_copy(table[1][i].Z, table[0][i].Z, sizeof(table[1][i].Z));+        }++        POINTonE1s_mult_w5(out, NULL, 2, scalars, 128, table);+        POINTonE1_cneg(out, 1);+        mul_fp(out->Z, out->Z, beta);+        mul_fp(out->Z, out->Z, beta);+    }++    vec_zero(val.l, sizeof(val));   /* scrub the copy of SK */+}++static void POINTonE1_sign(POINTonE1 *out, const POINTonE1 *in, const pow256 SK)+{+    vec384 Z, ZZ;+    limb_t inf;++    POINTonE1_mult_glv(out, in, SK);++    /* convert to affine to remove possible bias in out->Z */+    inf = vec_is_zero(out->Z, sizeof(out->Z));+#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION+    flt_reciprocal_fp(Z, out->Z);                       /* 1/Z   */+#else+    reciprocal_fp(Z, out->Z);                           /* 1/Z   */+#endif++    sqr_fp(ZZ, Z);+    mul_fp(out->X, out->X, ZZ);                         /* X = X/Z^2 */++    mul_fp(ZZ, ZZ, Z);+    mul_fp(out->Y, out->Y, ZZ);                         /* Y = Y/Z^3 */++    vec_select(out->Z, out->Z, BLS12_381_G1.Z, sizeof(BLS12_381_G1.Z),+                       inf);                            /* Z = inf ? 0 : 1 */+}++void blst_sk_to_pk_in_g1(POINTonE1 *out, const pow256 SK)+{   POINTonE1_sign(out, &BLS12_381_G1, SK);   }++void blst_sign_pk_in_g2(POINTonE1 *out, const POINTonE1 *msg, const pow256 SK)+{   POINTonE1_sign(out, msg, SK);   }++void blst_sk_to_pk2_in_g1(unsigned char out[96], POINTonE1_affine *PK,+                          const pow256 SK)+{+    POINTonE1 P[1];++    POINTonE1_sign(P, &BLS12_381_G1, SK);+    if (PK != NULL)+        vec_copy(PK, P, sizeof(*PK));+    if (out != NULL) {+        limb_t sgn0_pty = POINTonE1_Serialize_BE(out, P);+        out[0] |= (sgn0_pty & 2) << 4;      /* pre-decorate */+        out[0] |= vec_is_zero(P->Z, sizeof(P->Z)) << 6;+    }+}++void blst_sign_pk2_in_g2(unsigned char out[96], POINTonE1_affine *sig,+                         const POINTonE1 *hash, const pow256 SK)+{+    POINTonE1 P[1];++    POINTonE1_sign(P, hash, SK);+    if (sig != NULL)+        vec_copy(sig, P, sizeof(*sig));+    if (out != NULL) {+        limb_t sgn0_pty = POINTonE1_Serialize_BE(out, P);+        out[0] |= (sgn0_pty & 2) << 4;      /* pre-decorate */+        out[0] |= vec_is_zero(P->Z, sizeof(P->Z)) << 6;+    }+}++void blst_p1_mult(POINTonE1 *out, const POINTonE1 *a,+                                  const byte *scalar, size_t nbits)+{+    if (nbits < 176) {+        if (nbits)+            POINTonE1_mult_w4(out, a, scalar, nbits);+        else+            vec_zero(out, sizeof(*out));+    } else if (nbits <= 256) {+        union { vec256 l; pow256 s; } val;+        size_t i, j, top, mask = (size_t)0 - 1;++        /* this is not about constant-time-ness, but branch optimization */+        for (top = (nbits + 7)/8, i=0, j=0; i<sizeof(val.s);) {+            val.s[i++] = scalar[j] & mask;+            mask = 0 - ((i - top) >> (8*sizeof(top)-1));+            j += 1 & mask;+        }++        if (check_mod_256(val.s, BLS12_381_r))  /* z^4 is the formal limit */+            POINTonE1_mult_glv(out, a, val.s);+        else    /* should never be the case, added for formal completeness */+            POINTonE1_mult_w5(out, a, scalar, nbits);++        vec_zero(val.l, sizeof(val));+    } else {    /* should never be the case, added for formal completeness */+        POINTonE1_mult_w5(out, a, scalar, nbits);+    }+}++void blst_p1_unchecked_mult(POINTonE1 *out, const POINTonE1 *a,+                                            const byte *scalar, size_t nbits)+{+    if (nbits)+        POINTonE1_mult_w4(out, a, scalar, nbits);+    else+        vec_zero(out, sizeof(*out));+}++int blst_p1_affine_is_equal(const POINTonE1_affine *a,+                            const POINTonE1_affine *b)+{   return (int)vec_is_equal(a, b, sizeof(*a));   }++int blst_p1_is_inf(const POINTonE1 *p)+{   return (int)vec_is_zero(p->Z, sizeof(p->Z));   }++const POINTonE1 *blst_p1_generator(void)+{   return &BLS12_381_G1;   }++int blst_p1_affine_is_inf(const POINTonE1_affine *p)+{   return (int)vec_is_zero(p, sizeof(*p));   }++const POINTonE1_affine *blst_p1_affine_generator(void)+{   return (const POINTonE1_affine *)&BLS12_381_G1;   }++size_t blst_p1_sizeof(void)+{   return sizeof(POINTonE1);   }++size_t blst_p1_affine_sizeof(void)+{   return sizeof(POINTonE1_affine);   }
+ c-source/src/e2.c view
@@ -0,0 +1,638 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */++#include "point.h"+#include "fields.h"+#include "errors.h"++/*+ * y^2 = x^3 + B+ */+static const vec384x B_E2 = {       /* 4 + 4*i */+  { TO_LIMB_T(0xaa270000000cfff3), TO_LIMB_T(0x53cc0032fc34000a),+    TO_LIMB_T(0x478fe97a6b0a807f), TO_LIMB_T(0xb1d37ebee6ba24d7),+    TO_LIMB_T(0x8ec9733bbf78ab2f), TO_LIMB_T(0x09d645513d83de7e) },+  { TO_LIMB_T(0xaa270000000cfff3), TO_LIMB_T(0x53cc0032fc34000a),+    TO_LIMB_T(0x478fe97a6b0a807f), TO_LIMB_T(0xb1d37ebee6ba24d7),+    TO_LIMB_T(0x8ec9733bbf78ab2f), TO_LIMB_T(0x09d645513d83de7e) }+};++const POINTonE2 BLS12_381_G2 = {    /* generator point [in Montgomery] */+{ /* (0x024aa2b2f08f0a91260805272dc51051c6e47ad4fa403b02+        b4510b647ae3d1770bac0326a805bbefd48056c8c121bdb8 << 384) % P */+  { TO_LIMB_T(0xf5f28fa202940a10), TO_LIMB_T(0xb3f5fb2687b4961a),+    TO_LIMB_T(0xa1a893b53e2ae580), TO_LIMB_T(0x9894999d1a3caee9),+    TO_LIMB_T(0x6f67b7631863366b), TO_LIMB_T(0x058191924350bcd7) },+  /* (0x13e02b6052719f607dacd3a088274f65596bd0d09920b61a+        b5da61bbdc7f5049334cf11213945d57e5ac7d055d042b7e << 384) % P */+  { TO_LIMB_T(0xa5a9c0759e23f606), TO_LIMB_T(0xaaa0c59dbccd60c3),+    TO_LIMB_T(0x3bb17e18e2867806), TO_LIMB_T(0x1b1ab6cc8541b367),+    TO_LIMB_T(0xc2b6ed0ef2158547), TO_LIMB_T(0x11922a097360edf3) }+},+{ /* (0x0ce5d527727d6e118cc9cdc6da2e351aadfd9baa8cbdd3a7+        6d429a695160d12c923ac9cc3baca289e193548608b82801 << 384) % P */+  { TO_LIMB_T(0x4c730af860494c4a), TO_LIMB_T(0x597cfa1f5e369c5a),+    TO_LIMB_T(0xe7e6856caa0a635a), TO_LIMB_T(0xbbefb5e96e0d495f),+    TO_LIMB_T(0x07d3a975f0ef25a2), TO_LIMB_T(0x0083fd8e7e80dae5) },+  /* (0x0606c4a02ea734cc32acd2b02bc28b99cb3e287e85a763af+        267492ab572e99ab3f370d275cec1da1aaa9075ff05f79be << 384) % P */+  { TO_LIMB_T(0xadc0fc92df64b05d), TO_LIMB_T(0x18aa270a2b1461dc),+    TO_LIMB_T(0x86adac6a3be4eba0), TO_LIMB_T(0x79495c4ec93da33a),+    TO_LIMB_T(0xe7175850a43ccaed), TO_LIMB_T(0x0b2bc2a163de1bf2) },+},+{ { ONE_MONT_P }, { 0 } }+};++const POINTonE2 BLS12_381_NEG_G2 = { /* negative generator [in Montgomery] */+{ /* (0x024aa2b2f08f0a91260805272dc51051c6e47ad4fa403b02+        b4510b647ae3d1770bac0326a805bbefd48056c8c121bdb8 << 384) % P */+  { TO_LIMB_T(0xf5f28fa202940a10), TO_LIMB_T(0xb3f5fb2687b4961a),+    TO_LIMB_T(0xa1a893b53e2ae580), TO_LIMB_T(0x9894999d1a3caee9),+    TO_LIMB_T(0x6f67b7631863366b), TO_LIMB_T(0x058191924350bcd7) },+  /* (0x13e02b6052719f607dacd3a088274f65596bd0d09920b61a+        b5da61bbdc7f5049334cf11213945d57e5ac7d055d042b7e << 384) % P */+  { TO_LIMB_T(0xa5a9c0759e23f606), TO_LIMB_T(0xaaa0c59dbccd60c3),+    TO_LIMB_T(0x3bb17e18e2867806), TO_LIMB_T(0x1b1ab6cc8541b367),+    TO_LIMB_T(0xc2b6ed0ef2158547), TO_LIMB_T(0x11922a097360edf3) }+},+{ /* (0x0d1b3cc2c7027888be51d9ef691d77bcb679afda66c73f17+        f9ee3837a55024f78c71363275a75d75d86bab79f74782aa << 384) % P */+  { TO_LIMB_T(0x6d8bf5079fb65e61), TO_LIMB_T(0xc52f05df531d63a5),+    TO_LIMB_T(0x7f4a4d344ca692c9), TO_LIMB_T(0xa887959b8577c95f),+    TO_LIMB_T(0x4347fe40525c8734), TO_LIMB_T(0x197d145bbaff0bb5) },+  /* (0x13fa4d4a0ad8b1ce186ed5061789213d993923066dddaf10+        40bc3ff59f825c78df74f2d75467e25e0f55f8a00fa030ed << 384) % P */+  { TO_LIMB_T(0x0c3e036d209afa4e), TO_LIMB_T(0x0601d8f4863f9e23),+    TO_LIMB_T(0xe0832636bacc0a84), TO_LIMB_T(0xeb2def362a476f84),+    TO_LIMB_T(0x64044f659f0ee1e9), TO_LIMB_T(0x0ed54f48d5a1caa7) }+},+{ { ONE_MONT_P }, { 0 } }+};++static void mul_by_b_onE2(vec384x out, const vec384x in)+{+    sub_fp(out[0], in[0], in[1]);+    add_fp(out[1], in[0], in[1]);+    lshift_fp(out[0], out[0], 2);+    lshift_fp(out[1], out[1], 2);+}++static void mul_by_4b_onE2(vec384x out, const vec384x in)+{+    sub_fp(out[0], in[0], in[1]);+    add_fp(out[1], in[0], in[1]);+    lshift_fp(out[0], out[0], 4);+    lshift_fp(out[1], out[1], 4);+}++static void POINTonE2_cneg(POINTonE2 *p, bool_t cbit)+{   cneg_fp2(p->Y, p->Y, cbit);   }++void blst_p2_cneg(POINTonE2 *a, int cbit)+{   POINTonE2_cneg(a, is_zero(cbit) ^ 1);   }++static void POINTonE2_from_Jacobian(POINTonE2 *out, const POINTonE2 *in)+{+    vec384x Z, ZZ;+    limb_t inf = vec_is_zero(in->Z, sizeof(in->Z));++    reciprocal_fp2(Z, in->Z);                           /* 1/Z */++    sqr_fp2(ZZ, Z);+    mul_fp2(out->X, in->X, ZZ);                         /* X = X/Z^2 */++    mul_fp2(ZZ, ZZ, Z);+    mul_fp2(out->Y, in->Y, ZZ);                         /* Y = Y/Z^3 */++    vec_select(out->Z, in->Z, BLS12_381_G2.Z,+                       sizeof(BLS12_381_G2.Z), inf);    /* Z = inf ? 0 : 1 */+}++void blst_p2_from_jacobian(POINTonE2 *out, const POINTonE2 *a)+{   POINTonE2_from_Jacobian(out, a);   }++static void POINTonE2_to_affine(POINTonE2_affine *out, const POINTonE2 *in)+{+    POINTonE2 p;++    if (!vec_is_equal(in->Z, BLS12_381_Rx.p2, sizeof(in->Z))) {+        POINTonE2_from_Jacobian(&p, in);+        in = &p;+    }+    vec_copy(out, in, sizeof(*out));+}++void blst_p2_to_affine(POINTonE2_affine *out, const POINTonE2 *a)+{   POINTonE2_to_affine(out, a);   }++void blst_p2_from_affine(POINTonE2 *out, const POINTonE2_affine *a)+{+    vec_copy(out, a, sizeof(*a));+    vec_select(out->Z, a->X, BLS12_381_Rx.p2, sizeof(out->Z),+                       vec_is_zero(a, sizeof(*a)));+}++static bool_t POINTonE2_affine_on_curve(const POINTonE2_affine *p)+{+    vec384x XXX, YY;++    sqr_fp2(XXX, p->X);+    mul_fp2(XXX, XXX, p->X);                            /* X^3 */+    add_fp2(XXX, XXX, B_E2);                            /* X^3 + B */++    sqr_fp2(YY, p->Y);                                  /* Y^2 */++    return vec_is_equal(XXX, YY, sizeof(XXX));+}++int blst_p2_affine_on_curve(const POINTonE2_affine *p)+{   return (int)(POINTonE2_affine_on_curve(p) | vec_is_zero(p, sizeof(*p)));   }++static bool_t POINTonE2_on_curve(const POINTonE2 *p)+{+    vec384x XXX, YY, BZ6;+    limb_t inf = vec_is_zero(p->Z, sizeof(p->Z));++    sqr_fp2(BZ6, p->Z);+    mul_fp2(BZ6, BZ6, p->Z);+    sqr_fp2(XXX, BZ6);                                  /* Z^6 */+    mul_by_b_onE2(BZ6, XXX);                            /* B*Z^6 */++    sqr_fp2(XXX, p->X);+    mul_fp2(XXX, XXX, p->X);                            /* X^3 */+    add_fp2(XXX, XXX, BZ6);                             /* X^3 + B*Z^6 */++    sqr_fp2(YY, p->Y);                                  /* Y^2 */++    return vec_is_equal(XXX, YY, sizeof(XXX)) | inf;+}++int blst_p2_on_curve(const POINTonE2 *p)+{   return (int)POINTonE2_on_curve(p);   }++static limb_t POINTonE2_affine_Serialize_BE(unsigned char out[192],+                                            const POINTonE2_affine *in)+{+    vec384x temp;++    from_fp(temp[1], in->X[1]);+    be_bytes_from_limbs(out, temp[1], sizeof(temp[1]));+    from_fp(temp[0], in->X[0]);+    be_bytes_from_limbs(out + 48, temp[0], sizeof(temp[0]));++    from_fp(temp[1], in->Y[1]);+    be_bytes_from_limbs(out + 96, temp[1], sizeof(temp[1]));+    from_fp(temp[0], in->Y[0]);+    be_bytes_from_limbs(out + 144, temp[0], sizeof(temp[0]));++    return sgn0_pty_mod_384x(temp, BLS12_381_P);+}++void blst_p2_affine_serialize(unsigned char out[192],+                              const POINTonE2_affine *in)+{+    if (vec_is_zero(in->X, 2*sizeof(in->X))) {+        bytes_zero(out, 192);+        out[0] = 0x40;    /* infinitiy bit */+    } else {+        (void)POINTonE2_affine_Serialize_BE(out, in);+    }+}++static limb_t POINTonE2_Serialize_BE(unsigned char out[192],+                                     const POINTonE2 *in)+{+    POINTonE2 p;++    if (!vec_is_equal(in->Z, BLS12_381_Rx.p2, sizeof(in->Z))) {+        POINTonE2_from_Jacobian(&p, in);+        in = &p;+    }++    return POINTonE2_affine_Serialize_BE(out, (const POINTonE2_affine *)in);+}++static void POINTonE2_Serialize(unsigned char out[192], const POINTonE2 *in)+{+    if (vec_is_zero(in->Z, sizeof(in->Z))) {+        bytes_zero(out, 192);+        out[0] = 0x40;    /* infinitiy bit */+    } else {+        (void)POINTonE2_Serialize_BE(out, in);+    }+}++void blst_p2_serialize(unsigned char out[192], const POINTonE2 *in)+{   POINTonE2_Serialize(out, in);   }++static limb_t POINTonE2_affine_Compress_BE(unsigned char out[96],+                                           const POINTonE2_affine *in)+{+    vec384 temp;++    from_fp(temp, in->X[1]);+    be_bytes_from_limbs(out, temp, sizeof(temp));+    from_fp(temp, in->X[0]);+    be_bytes_from_limbs(out + 48, temp, sizeof(temp));++    return sgn0_pty_mont_384x(in->Y, BLS12_381_P, p0);+}++void blst_p2_affine_compress(unsigned char out[96], const POINTonE2_affine *in)+{+    if (vec_is_zero(in->X, 2*sizeof(in->X))) {+        bytes_zero(out, 96);+        out[0] = 0xc0;    /* compressed and infinitiy bits */+    } else {+        limb_t sign = POINTonE2_affine_Compress_BE(out, in);+        out[0] |= (unsigned char)(0x80 | ((sign & 2) << 4));+    }+}++static limb_t POINTonE2_Compress_BE(unsigned char out[96],+                                    const POINTonE2 *in)+{+    POINTonE2 p;++    if (!vec_is_equal(in->Z, BLS12_381_Rx.p, sizeof(in->Z))) {+        POINTonE2_from_Jacobian(&p, in);+        in = &p;+    }++    return POINTonE2_affine_Compress_BE(out, (const POINTonE2_affine *)in);+}++void blst_p2_compress(unsigned char out[96], const POINTonE2 *in)+{+    if (vec_is_zero(in->Z, sizeof(in->Z))) {+        bytes_zero(out, 96);+        out[0] = 0xc0;    /* compressed and infinitiy bits */+    } else {+        limb_t sign = POINTonE2_Compress_BE(out, in);+        out[0] |= (unsigned char)(0x80 | ((sign & 2) << 4));+    }+}++static limb_t POINTonE2_Uncompress_BE(POINTonE2_affine *out,+                                      const unsigned char in[96])+{+    POINTonE2_affine ret;+    vec384 temp;++    limbs_from_be_bytes(ret.X[1], in, sizeof(ret.X[1]));+    limbs_from_be_bytes(ret.X[0], in + 48, sizeof(ret.X[0]));++    /* clear top 3 bits in case caller was conveying some information there */+    ret.X[1][sizeof(ret.X[1])/sizeof(limb_t)-1] &= ((limb_t)0-1) >> 3;+    add_fp(temp, ret.X[1], ZERO_384);  /* less than modulus? */+    if (!vec_is_equal(temp, ret.X[1], sizeof(temp)))+        return (limb_t)0 - BLST_BAD_ENCODING;++    add_fp(temp, ret.X[0], ZERO_384);  /* less than modulus? */+    if (!vec_is_equal(temp, ret.X[0], sizeof(temp)))+        return (limb_t)0 - BLST_BAD_ENCODING;++    mul_fp(ret.X[0], ret.X[0], BLS12_381_RR);+    mul_fp(ret.X[1], ret.X[1], BLS12_381_RR);++    sqr_fp2(ret.Y, ret.X);+    mul_fp2(ret.Y, ret.Y, ret.X);+    add_fp2(ret.Y, ret.Y, B_E2);                        /* X^3 + B */+    if (!sqrt_fp2(ret.Y, ret.Y))+        return (limb_t)0 - BLST_POINT_NOT_ON_CURVE;++    vec_copy(out, &ret, sizeof(ret));++    return sgn0_pty_mont_384x(out->Y, BLS12_381_P, p0);+}++static BLST_ERROR POINTonE2_Uncompress_Z(POINTonE2_affine *out,+                                         const unsigned char in[96])+{+    unsigned char in0 = in[0];+    limb_t sgn0_pty;++    if ((in0 & 0x80) == 0)      /* compressed bit */+        return BLST_BAD_ENCODING;++    if (in0 & 0x40) {           /* infinity bit */+        if (byte_is_zero(in0 & 0x3f) & bytes_are_zero(in+1, 95)) {+            vec_zero(out, sizeof(*out));+            return BLST_SUCCESS;+        } else {+            return BLST_BAD_ENCODING;+        }+    }++    sgn0_pty = POINTonE2_Uncompress_BE(out, in);++    if (sgn0_pty > 3)+        return (BLST_ERROR)(0 - sgn0_pty); /* POINT_NOT_ON_CURVE */++    sgn0_pty >>= 1; /* skip over parity bit */+    sgn0_pty ^= (in0 & 0x20) >> 5;+    cneg_fp2(out->Y, out->Y, sgn0_pty);++    return BLST_SUCCESS;+}++BLST_ERROR blst_p2_uncompress(POINTonE2_affine *out, const unsigned char in[96])+{   return POINTonE2_Uncompress_Z(out, in);   }++static BLST_ERROR POINTonE2_Deserialize_BE(POINTonE2_affine *out,+                                           const unsigned char in[192])+{+    POINTonE2_affine ret;+    vec384 temp;++    limbs_from_be_bytes(ret.X[1], in, sizeof(ret.X[1]));+    limbs_from_be_bytes(ret.X[0], in + 48, sizeof(ret.X[0]));+    limbs_from_be_bytes(ret.Y[1], in + 96, sizeof(ret.Y[1]));+    limbs_from_be_bytes(ret.Y[0], in + 144, sizeof(ret.Y[0]));++    /* clear top 3 bits in case caller was conveying some information there */+    ret.X[1][sizeof(ret.X[1])/sizeof(limb_t)-1] &= ((limb_t)0-1) >> 3;+    add_fp(temp, ret.X[1], ZERO_384);  /* less than modulus? */+    if (!vec_is_equal(temp, ret.X[1], sizeof(temp)))+        return BLST_BAD_ENCODING;++    add_fp(temp, ret.X[0], ZERO_384);  /* less than modulus? */+    if (!vec_is_equal(temp, ret.X[0], sizeof(temp)))+        return BLST_BAD_ENCODING;++    add_fp(temp, ret.Y[1], ZERO_384);  /* less than modulus? */+    if (!vec_is_equal(temp, ret.Y[1], sizeof(temp)))+        return BLST_BAD_ENCODING;++    add_fp(temp, ret.Y[0], ZERO_384);  /* less than modulus? */+    if (!vec_is_equal(temp, ret.Y[0], sizeof(temp)))+        return BLST_BAD_ENCODING;++    mul_fp(ret.X[0], ret.X[0], BLS12_381_RR);+    mul_fp(ret.X[1], ret.X[1], BLS12_381_RR);+    mul_fp(ret.Y[0], ret.Y[0], BLS12_381_RR);+    mul_fp(ret.Y[1], ret.Y[1], BLS12_381_RR);++    if (!POINTonE2_affine_on_curve(&ret))+        return BLST_POINT_NOT_ON_CURVE;++    vec_copy(out, &ret, sizeof(ret));++    return BLST_SUCCESS;+}++static BLST_ERROR POINTonE2_Deserialize_Z(POINTonE2_affine *out,+                                          const unsigned char in[192])+{+    unsigned char in0 = in[0];++    if ((in0 & 0xe0) == 0)+        return POINTonE2_Deserialize_BE(out, in);++    if (in0 & 0x80)             /* compressed bit */+        return POINTonE2_Uncompress_Z(out, in);++    if (in0 & 0x40) {           /* infinity bit */+        if (byte_is_zero(in0 & 0x3f) & bytes_are_zero(in+1, 191)) {+            vec_zero(out, sizeof(*out));+            return BLST_SUCCESS;+        }+    }++    return BLST_BAD_ENCODING;+}++BLST_ERROR blst_p2_deserialize(POINTonE2_affine *out,+                               const unsigned char in[192])+{   return POINTonE2_Deserialize_Z(out, in);   }++#include "ec_ops.h"+POINT_DADD_IMPL(POINTonE2, 384x, fp2)+POINT_DADD_AFFINE_IMPL_A0(POINTonE2, 384x, fp2, BLS12_381_Rx.p2)+POINT_ADD_IMPL(POINTonE2, 384x, fp2)+POINT_ADD_AFFINE_IMPL(POINTonE2, 384x, fp2, BLS12_381_Rx.p2)+POINT_DOUBLE_IMPL_A0(POINTonE2, 384x, fp2)+POINT_IS_EQUAL_IMPL(POINTonE2, 384x, fp2)++void blst_p2_add(POINTonE2 *out, const POINTonE2 *a, const POINTonE2 *b)+{   POINTonE2_add(out, a, b);   }++void blst_p2_add_or_double(POINTonE2 *out, const POINTonE2 *a,+                                           const POINTonE2 *b)+{   POINTonE2_dadd(out, a, b, NULL);   }++void blst_p2_add_affine(POINTonE2 *out, const POINTonE2 *a,+                                        const POINTonE2_affine *b)+{   POINTonE2_add_affine(out, a, b);   }++void blst_p2_add_or_double_affine(POINTonE2 *out, const POINTonE2 *a,+                                                  const POINTonE2_affine *b)+{   POINTonE2_dadd_affine(out, a, b);   }++void blst_p2_double(POINTonE2 *out, const POINTonE2 *a)+{   POINTonE2_double(out, a);   }++int blst_p2_is_equal(const POINTonE2 *a, const POINTonE2 *b)+{   return (int)POINTonE2_is_equal(a, b);   }++#include "ec_mult.h"+POINT_MULT_SCALAR_WX_IMPL(POINTonE2, 4)+POINT_MULT_SCALAR_WX_IMPL(POINTonE2, 5)++#ifdef __BLST_PRIVATE_TESTMODE__+POINT_AFFINE_MULT_SCALAR_IMPL(POINTonE2)++DECLARE_PRIVATE_POINTXZ(POINTonE2, 384x)+POINT_LADDER_PRE_IMPL(POINTonE2, 384x, fp2)+POINT_LADDER_STEP_IMPL_A0(POINTonE2, 384x, fp2, onE2)+POINT_LADDER_POST_IMPL_A0(POINTonE2, 384x, fp2, onE2)+POINT_MULT_SCALAR_LADDER_IMPL(POINTonE2)+#endif++static void psi(POINTonE2 *out, const POINTonE2 *in)+{+    static const vec384x frobenius_x = { /* 1/(1 + i)^((P-1)/3) */+      { 0 },+      { /* (0x1a0111ea397fe699ec02408663d4de85aa0d857d89759ad4+              897d29650fb85f9b409427eb4f49fffd8bfd00000000aaad << 384) % P */+        TO_LIMB_T(0x890dc9e4867545c3), TO_LIMB_T(0x2af322533285a5d5),+        TO_LIMB_T(0x50880866309b7e2c), TO_LIMB_T(0xa20d1b8c7e881024),+        TO_LIMB_T(0x14e4f04fe2db9068), TO_LIMB_T(0x14e56d3f1564853a) }+    };+    static const vec384x frobenius_y = { /* 1/(1 + i)^((P-1)/2) */+      { /* (0x135203e60180a68ee2e9c448d77a2cd91c3dedd930b1cf60+              ef396489f61eb45e304466cf3e67fa0af1ee7b04121bdea2 << 384) % P */+        TO_LIMB_T(0x3e2f585da55c9ad1), TO_LIMB_T(0x4294213d86c18183),+        TO_LIMB_T(0x382844c88b623732), TO_LIMB_T(0x92ad2afd19103e18),+        TO_LIMB_T(0x1d794e4fac7cf0b9), TO_LIMB_T(0x0bd592fc7d825ec8) },+      { /* (0x06af0e0437ff400b6831e36d6bd17ffe48395dabc2d3435e+              77f76e17009241c5ee67992f72ec05f4c81084fbede3cc09 << 384) % P */+        TO_LIMB_T(0x7bcfa7a25aa30fda), TO_LIMB_T(0xdc17dec12a927e7c),+        TO_LIMB_T(0x2f088dd86b4ebef1), TO_LIMB_T(0xd1ca2087da74d4a7),+        TO_LIMB_T(0x2da2596696cebc1d), TO_LIMB_T(0x0e2b7eedbbfd87d2) },+    };++    vec_copy(out, in, sizeof(*out));+    cneg_fp(out->X[1], out->X[1], 1);   mul_fp2(out->X, out->X, frobenius_x);+    cneg_fp(out->Y[1], out->Y[1], 1);   mul_fp2(out->Y, out->Y, frobenius_y);+    cneg_fp(out->Z[1], out->Z[1], 1);+}++/* Galbraith-Lin-Scott, ~67% faster than POINTonE2_mul_w5 */+static void POINTonE2_mult_gls(POINTonE2 *out, const POINTonE2 *in,+                               const pow256 SK)+{+    union { vec256 l; pow256 s; } val;++    /* break down SK to "digits" with |z| as radix [in constant time] */++    limbs_from_le_bytes(val.l, SK, 32);+    div_by_zz(val.l);+    div_by_z(val.l);+    div_by_z(val.l + NLIMBS(256)/2);+    le_bytes_from_limbs(val.s, val.l, 32);++    {+        const byte *scalars[2] = { val.s, NULL };+        POINTonE2 table[4][1<<(5-1)];   /* 18KB */+        size_t i;++        POINTonE2_precompute_w5(table[0], in);+        for (i = 0; i < 1<<(5-1); i++) {+            psi(&table[1][i], &table[0][i]);+            psi(&table[2][i], &table[1][i]);+            psi(&table[3][i], &table[2][i]);+            POINTonE2_cneg(&table[1][i], 1); /* account for z being negative */+            POINTonE2_cneg(&table[3][i], 1);+        }++        POINTonE2s_mult_w5(out, NULL, 4, scalars, 64, table);+    }++    vec_zero(val.l, sizeof(val));   /* scrub the copy of SK */+}++static void POINTonE2_sign(POINTonE2 *out, const POINTonE2 *in, const pow256 SK)+{+    vec384x Z, ZZ;+    limb_t inf;++    POINTonE2_mult_gls(out, in, SK);++    /* convert to affine to remove possible bias in out->Z */+    inf = vec_is_zero(out->Z, sizeof(out->Z));+#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION+    flt_reciprocal_fp2(Z, out->Z);                      /* 1/Z   */+#else+    reciprocal_fp2(Z, out->Z);                          /* 1/Z   */+#endif++    sqr_fp2(ZZ, Z);+    mul_fp2(out->X, out->X, ZZ);                        /* X = X/Z^2 */++    mul_fp2(ZZ, ZZ, Z);+    mul_fp2(out->Y, out->Y, ZZ);                        /* Y = Y/Z^3 */++    vec_select(out->Z, out->Z, BLS12_381_G2.Z, sizeof(BLS12_381_G2.Z),+                       inf);                            /* Z = inf ? 0 : 1 */+}++void blst_sk_to_pk_in_g2(POINTonE2 *out, const pow256 SK)+{   POINTonE2_sign(out, &BLS12_381_G2, SK);   }++void blst_sign_pk_in_g1(POINTonE2 *out, const POINTonE2 *msg, const pow256 SK)+{   POINTonE2_sign(out, msg, SK);   }++void blst_sk_to_pk2_in_g2(unsigned char out[192], POINTonE2_affine *PK,+                          const pow256 SK)+{+    POINTonE2 P[1];++    POINTonE2_sign(P, &BLS12_381_G2, SK);+    if (PK != NULL)+        vec_copy(PK, P, sizeof(*PK));+    if (out != NULL) {+        limb_t sgn0_pty = POINTonE2_Serialize_BE(out, P);+        out[0] |= (sgn0_pty & 2) << 4;      /* pre-decorate */+        out[0] |= vec_is_zero(P->Z, sizeof(P->Z)) << 6;+    }+}++void blst_sign_pk2_in_g1(unsigned char out[192], POINTonE2_affine *sig,+                         const POINTonE2 *hash, const pow256 SK)+{+    POINTonE2 P[1];++    POINTonE2_sign(P, hash, SK);+    if (sig != NULL)+        vec_copy(sig, P, sizeof(*sig));+    if (out != NULL) {+        limb_t sgn0_pty = POINTonE2_Serialize_BE(out, P);+        out[0] |= (sgn0_pty & 2) << 4;      /* pre-decorate */+        out[0] |= vec_is_zero(P->Z, sizeof(P->Z)) << 6;+    }+}++void blst_p2_mult(POINTonE2 *out, const POINTonE2 *a,+                                  const byte *scalar, size_t nbits)+{+    if (nbits < 144) {+        if (nbits)+            POINTonE2_mult_w4(out, a, scalar, nbits);+        else+            vec_zero(out, sizeof(*out));+    } else if (nbits <= 256) {+        union { vec256 l; pow256 s; } val;+        size_t i, j, top, mask = (size_t)0 - 1;++        /* this is not about constant-time-ness, but branch optimization */+        for (top = (nbits + 7)/8, i=0, j=0; i<sizeof(val.s);) {+            val.s[i++] = scalar[j] & mask;+            mask = 0 - ((i - top) >> (8*sizeof(top)-1));+            j += 1 & mask;+        }++        if (check_mod_256(val.s, BLS12_381_r))  /* z^4 is the formal limit */+            POINTonE2_mult_gls(out, a, val.s);+        else    /* should never be the case, added for formal completeness */+            POINTonE2_mult_w5(out, a, scalar, nbits);++        vec_zero(val.l, sizeof(val));+    } else {    /* should never be the case, added for formal completeness */+        POINTonE2_mult_w5(out, a, scalar, nbits);+    }+}++void blst_p2_unchecked_mult(POINTonE2 *out, const POINTonE2 *a,+                                            const byte *scalar, size_t nbits)+{+    if (nbits)+        POINTonE2_mult_w4(out, a, scalar, nbits);+    else+        vec_zero(out, sizeof(*out));+}++int blst_p2_affine_is_equal(const POINTonE2_affine *a,+                            const POINTonE2_affine *b)+{   return (int)vec_is_equal(a, b, sizeof(*a));   }++int blst_p2_is_inf(const POINTonE2 *p)+{   return (int)vec_is_zero(p->Z, sizeof(p->Z));   }++const POINTonE2 *blst_p2_generator(void)+{   return &BLS12_381_G2;   }++int blst_p2_affine_is_inf(const POINTonE2_affine *p)+{   return (int)vec_is_zero(p, sizeof(*p));   }++const POINTonE2_affine *blst_p2_affine_generator(void)+{   return (const POINTonE2_affine *)&BLS12_381_G2;   }++size_t blst_p2_sizeof(void)+{   return sizeof(POINTonE2);   }++size_t blst_p2_affine_sizeof(void)+{   return sizeof(POINTonE2_affine);   }
+ c-source/src/ec_mult.h view
@@ -0,0 +1,289 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */+#ifndef __BLS12_381_ASM_EC_MULT_H__+#define __BLS12_381_ASM_EC_MULT_H__++#include "point.h"++/* Works up to 9 bits */+static limb_t get_wval(const byte *d, size_t off, size_t bits)+{+    size_t top = off + bits - 1;+    limb_t ret;++    ret = ((limb_t)d[top / 8] << 8) | d[off / 8];++    return ret >> (off%8);+}++/* Works up to 25 bits. */+static limb_t get_wval_limb(const byte *d, size_t off, size_t bits)+{+    size_t i, top = (off + bits - 1)/8;+    limb_t ret, mask = (limb_t)0 - 1;++    d   += off/8;+    top -= off/8-1;++    /* this is not about constant-time-ness, but branch optimization */+    for (ret=0, i=0; i<4;) {+        ret |= (*d & mask) << (8*i);+        mask = (limb_t)0 - ((++i - top) >> (8*sizeof(top)-1));+        d += 1 & mask;+    }++    return ret >> (off%8);+}++/*+ * Window value encoding that utilizes the fact that -P is trivially+ * calculated, which allows to halve the size of pre-computed table,+ * is attributed to A. D. Booth, hence the name of the subroutines...+ */+static limb_t booth_encode(limb_t wval, size_t sz)+{+    limb_t mask = 0 - (wval >> sz);     /* "sign" bit -> mask */++    wval = (wval + 1) >> 1;+    wval = (wval & ~mask) | ((0-wval) & mask);++    /* &0x1f, but <=0x10, is index in table, rest is extended "sign" bit */+    return wval;+}++/*+ * Key feature of these constant-time subroutines is that they tolerate+ * zeros in most significant bit positions of the scalar[s], or in other+ * words, zero-padded scalar values. This means that one can and should+ * pass order's bit-length, which is customarily publicly known, instead+ * of the factual scalars' bit-lengths. This is facilitated by point+ * addition subroutines implemented to handle points at infinity, which+ * are encoded as Z==0. [Doubling agorithms handle such points at+ * infinity "naturally," since resulting Z is product of original Z.]+ */+#define POINT_MULT_SCALAR_WX_IMPL(ptype, SZ) \+static void ptype##_gather_booth_w##SZ(ptype *restrict p, \+                                       const ptype table[1<<(SZ-1)], \+                                       limb_t booth_idx) \+{ \+    size_t i; \+    bool_t booth_sign = (booth_idx >> SZ) & 1; \+\+    booth_idx &= (1<<SZ) - 1; \+    vec_zero(p, sizeof(ptype)); /* implicit infinity at table[-1] */\+    /* ~6% with -Os, ~2% with -O3 ... */\+    for (i = 1; i <= 1<<(SZ-1); i++) \+        ptype##_ccopy(p, table + i - 1, byte_is_zero((byte)(i ^ booth_idx))); \+\+    ptype##_cneg(p, booth_sign); \+} \+\+static void ptype##_precompute_w##SZ(ptype row[], const ptype *point) \+{ \+    size_t i, j; \+                                      /* row[-1] is implicit infinity */\+    vec_copy(&row[0], point, sizeof(ptype));        /* row[0]=p*1     */\+    ptype##_double(&row[1],  point);                /* row[1]=p*(1+1) */\+    for (i = 2, j = 1; i < 1<<(SZ-1); i += 2, j++) \+        ptype##_add(&row[i], &row[j], &row[j-1]),   /* row[2]=p*(2+1) */\+        ptype##_double(&row[i+1], &row[j]);         /* row[3]=p*(2+2) */\+}                                                   /* row[4] ...     */\+\+static void ptype##s_mult_w##SZ(ptype *ret, \+                                const ptype *points[], size_t npoints, \+                                const byte *scalars[], size_t bits, \+                                ptype table[][1<<(SZ-1)]) \+{ \+    limb_t wmask, wval; \+    size_t i, j, window, nbytes; \+    const byte *scalar, **scalar_s = scalars; \+    ptype temp[1]; \+\+    if (table == NULL) \+        table = (ptype (*)[1<<(SZ-1)])alloca((1<<(SZ-1)) * sizeof(ptype) * \+                                             npoints); \+\+    if (points != NULL) { \+        const ptype *point = NULL; \+        for (i = 0; i < npoints; i++) \+            point = *points ? *points++ : point+1, \+            ptype##_precompute_w##SZ(table[i], point); \+    } \+\+    nbytes = (bits + 7)/8; /* convert |bits| to bytes */ \+    scalar = *scalar_s++; \+\+    /* top excess bits modulo target window size */ \+    window = bits % SZ; /* yes, it may be zero */ \+    wmask = ((limb_t)1 << (window + 1)) - 1; \+\+    bits -= window; \+    if (bits > 0) \+        wval = get_wval(scalar, bits - 1, window + 1) & wmask; \+    else \+        wval = (scalar[0] << 1) & wmask; \+\+    wval = booth_encode(wval, SZ); \+    ptype##_gather_booth_w##SZ(ret, table[0], wval); \+\+    i = 1; \+    while (bits > 0) { \+        for (; i < npoints; i++) { \+            scalar = *scalar_s ? *scalar_s++ : scalar+nbytes; \+            wval = get_wval(scalar, bits - 1, window + 1) & wmask; \+            wval = booth_encode(wval, SZ); \+            ptype##_gather_booth_w##SZ(temp, table[i], wval); \+            ptype##_dadd(ret, ret, temp, NULL); \+        } \+\+        for (j = 0; j < SZ; j++) \+            ptype##_double(ret, ret); \+\+        window = SZ; \+        wmask = ((limb_t)1 << (window + 1)) - 1; \+        bits -= window; \+        i = 0; scalar_s = scalars; \+    } \+\+    for (; i < npoints; i++) { \+        scalar = *scalar_s ? *scalar_s++ : scalar+nbytes; \+        wval = (scalar[0] << 1) & wmask; \+        wval = booth_encode(wval, SZ); \+        ptype##_gather_booth_w##SZ(temp, table[i], wval); \+        ptype##_dadd(ret, ret, temp, NULL); \+    } \+} \+\+static void ptype##_mult_w##SZ(ptype *ret, const ptype *point, \+                               const byte *scalar, size_t bits) \+{ \+    limb_t wmask, wval; \+    size_t j, window; \+    ptype temp[1]; \+    ptype table[1<<(SZ-1)]; \+\+    ptype##_precompute_w##SZ(table, point); \+\+    /* top excess bits modulo target window size */ \+    window = bits % SZ;  /* yes, it may be zero */ \+    wmask = ((limb_t)1 << (window + 1)) - 1; \+\+    bits -= window; \+    wval = bits ? get_wval(scalar, bits - 1, window + 1) \+                : (limb_t)scalar[0] << 1; \+    wval &= wmask; \+    wval = booth_encode(wval, SZ); \+    ptype##_gather_booth_w##SZ(ret, table, wval); \+\+    while (bits > 0) { \+        for (j = 0; j < SZ; j++) \+            ptype##_double(ret, ret); \+\+        window = SZ; \+        wmask = ((limb_t)1 << (window + 1)) - 1; \+        bits -= window; \+\+        wval = bits ? get_wval(scalar, bits - 1, window + 1) \+                    : (limb_t)scalar[0] << 1; \+        wval &= wmask; \+        wval = booth_encode(wval, SZ); \+        ptype##_gather_booth_w##SZ(temp, table, wval); \+        if (bits > 0) ptype##_add(ret, ret, temp); \+        else          ptype##_dadd(ret, ret, temp, NULL); \+    } \+}++#if 0+/* ~50%, or ~2x[!] slower than w5... */+#define POINT_MULT_SCALAR_LADDER_IMPL(ptype) \+static void ptype##_mult_ladder(ptype *ret, const ptype *p, \+                                const byte *scalar, size_t bits) \+{ \+    ptype sum[1]; \+    bool_t bit, pbit = 0; \+\+    vec_copy(sum, p, sizeof(ptype)); \+    vec_zero(ret, sizeof(ptype));   /* infinity */ \+\+    while (bits--) { \+        bit = is_bit_set(scalar, bits); \+        bit ^= pbit; \+        ptype##_cswap(ret, sum, bit); \+        ptype##_add(sum, sum, ret); \+        ptype##_double(ret, ret); \+        pbit ^= bit; \+    } \+    ptype##_cswap(ret, sum, pbit); \+}+#else+/* >40% better performance than above, [and ~30% slower than w5]... */+#define POINT_MULT_SCALAR_LADDER_IMPL(ptype) \+static void ptype##_mult_ladder(ptype *out, const ptype *p, \+                                const byte *scalar, size_t bits) \+{ \+    ptype##xz sum[1]; \+    ptype##xz pxz[1]; \+    ptype##xz ret[1]; \+    bool_t bit, pbit = 0; \+\+    ptype##xz_ladder_pre(pxz, p); \+    vec_copy(sum, pxz, sizeof(ptype##xz)); \+    vec_zero(ret, sizeof(ptype##xz));   /* infinity */ \+\+    while (bits--) { \+        bit = is_bit_set(scalar, bits); \+        bit ^= pbit; \+        ptype##xz_cswap(ret, sum, bit); \+        ptype##xz_ladder_step(ret, sum, pxz); \+        pbit ^= bit; \+    } \+    ptype##xz_cswap(ret, sum, pbit); \+    ptype##xz_ladder_post(out, ret, sum, pxz, p->Y); \+}+#endif++/*+ * Sole reason for existence of this implementation is that addition+ * with affine point renders a share of multiplications redundant by+ * virtue of Z==1. And since pre-defined generator point can be and+ * customarily is instantiated affine, it would be hardly appropriate+ * to pass on this opportunity. Though while it's faster than the+ * generic ladder implementation, by ~25%, it's not faster than XZ one+ * above, <15% slower. Just in case, it's faster than generic ladder+ * even if one accounts for prior conversion to affine coordinates,+ * so that choice [for resource-constrained case] is actually between+ * this plus said conversion and XZ ladder...+ *+ * To summarize, if ptype##_mult_w5 executed in one unit of time, then+ * - naive ptype##_mult_ladder would execute in ~2;+ * - XZ version above - in ~1.4;+ * - ptype##_affine_mult_ladder below - in ~1.65;+ * - [small-footprint ptype##_to_affine would run in ~0.18].+ *+ * Caveat lector, |p_affine|*(order+2) produces wrong result, because+ * addition doesn't handle doubling. Indeed, P*(order+1) is P and it+ * fails to add with itself producing infinity in last addition. But+ * as long as |scalar| is reduced modulo order, as it should be, it's+ * not a problem...+ */+#define POINT_AFFINE_MULT_SCALAR_IMPL(ptype) \+static void ptype##_affine_mult_ladder(ptype *ret, \+                                       const ptype##_affine *p_affine, \+                                       const byte *scalar, size_t bits) \+{ \+    ptype sum[1]; \+    bool_t bit; \+\+    vec_zero(ret, sizeof(ptype));   /* infinity */ \+\+    while (bits--) { \+        ptype##_double(ret, ret); \+        ptype##_add_affine(sum, ret, p_affine); \+        bit = (scalar[bits / LIMB_T_BITS] >> (bits % LIMB_T_BITS)) & 1; \+        ptype##_ccopy(ret, sum, bit); \+    } \+}+#endif
+ c-source/src/ec_ops.h view
@@ -0,0 +1,787 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */+#ifndef __BLS12_384_ASM_EC_OPS_H__+#define __BLS12_384_ASM_EC_OPS_H__+/*+ * Addition that can handle doubling [as well as points at infinity,+ * which are encoded as Z==0] in constant time. It naturally comes at+ * cost, but this subroutine should be called only when independent+ * points are processed, which is considered reasonable compromise.+ * For example, ptype##s_mult_w5 calls it, but since *major* gain is+ * result of pure doublings being effectively divided by amount of+ * points, slightly slower addition can be tolerated. But what is the+ * additional cost more specifically? Best addition result is 11M+5S,+ * while this routine takes 13M+5S (+1M+1S if a4!=0), as per+ *+ * -------------+-------------+ * addition     | doubling+ * -------------+-------------+ * U1 = X1*Z2^2 | U1 = X1+ * U2 = X2*Z1^2 |+ * S1 = Y1*Z2^3 | S1 = Y1+ * S2 = Y2*Z1^3 |+ * zz = Z1*Z2   | zz = Z1+ * H = U2-U1    | H' = 2*Y1+ * R = S2-S1    | R' = 3*X1^2[+a*Z1^4]+ * sx = U1+U2   | sx = X1+X1+ * -------------+-------------+ * H!=0 || R!=0 | H==0 && R==0+ *+ *      X3 = R^2-H^2*sx+ *      Y3 = R*(H^2*U1-X3)-H^3*S1+ *      Z3 = H*zz+ *+ * As for R!=0 condition in context of H==0, a.k.a. P-P. The result is+ * infinity by virtue of Z3 = (U2-U1)*zz = H*zz = 0*zz == 0.+ */+#define POINT_DADD_IMPL(ptype, bits, field) \+static void ptype##_dadd(ptype *out, const ptype *p1, const ptype *p2, \+                         const vec##bits a4) \+{ \+    ptype p3; /* starts as (U1, S1, zz) from addition side */\+    struct { vec##bits H, R, sx; } add, dbl; \+    bool_t p1inf, p2inf, is_dbl; \+\+    add_##field(dbl.sx, p1->X, p1->X);  /* sx = X1+X1 */\+    sqr_##field(dbl.R, p1->X);          /* X1^2 */\+    mul_by_3_##field(dbl.R, dbl.R);     /* R = 3*X1^2 */\+    add_##field(dbl.H, p1->Y, p1->Y);   /* H = 2*Y1 */\+\+    p2inf = vec_is_zero(p2->Z, sizeof(p2->Z)); \+    sqr_##field(p3.X, p2->Z);           /* Z2^2 */\+    mul_##field(p3.Z, p1->Z, p2->Z);    /* Z1*Z2 */\+    p1inf = vec_is_zero(p1->Z, sizeof(p1->Z)); \+    sqr_##field(add.H, p1->Z);          /* Z1^2 */\+\+    if (a4 != NULL) { \+        sqr_##field(p3.Y, add.H);       /* Z1^4, [borrow p3.Y] */\+        mul_##field(p3.Y, p3.Y, a4);    \+        add_##field(dbl.R, dbl.R, p3.Y);/* R = 3*X1^2+a*Z1^4 */\+    } \+\+    mul_##field(p3.Y, p1->Y, p2->Z);    \+    mul_##field(p3.Y, p3.Y, p3.X);      /* S1 = Y1*Z2^3 */\+    mul_##field(add.R, p2->Y, p1->Z);   \+    mul_##field(add.R, add.R, add.H);   /* S2 = Y2*Z1^3 */\+    sub_##field(add.R, add.R, p3.Y);    /* R = S2-S1 */\+\+    mul_##field(p3.X, p3.X, p1->X);     /* U1 = X1*Z2^2 */\+    mul_##field(add.H, add.H, p2->X);   /* U2 = X2*Z1^2 */\+\+    add_##field(add.sx, add.H, p3.X);   /* sx = U1+U2 */\+    sub_##field(add.H, add.H, p3.X);    /* H = U2-U1 */\+\+    /* make the choice between addition and doubling */\+    is_dbl = vec_is_zero(add.H, 2*sizeof(add.H));      \+    vec_select(&p3, p1, &p3, sizeof(p3), is_dbl);      \+    vec_select(&add, &dbl, &add, sizeof(add), is_dbl); \+    /* |p3| and |add| hold all inputs now, |p3| will hold output */\+\+    mul_##field(p3.Z, p3.Z, add.H);     /* Z3 = H*Z1*Z2 */\+\+    sqr_##field(dbl.H, add.H);          /* H^2 */\+    mul_##field(dbl.R, dbl.H, add.H);   /* H^3 */\+    mul_##field(dbl.R, dbl.R, p3.Y);    /* H^3*S1 */\+    mul_##field(p3.Y, dbl.H, p3.X);     /* H^2*U1 */\+\+    mul_##field(dbl.H, dbl.H, add.sx);  /* H^2*sx */\+    sqr_##field(p3.X, add.R);           /* R^2 */\+    sub_##field(p3.X, p3.X, dbl.H);     /* X3 = R^2-H^2*sx */\+\+    sub_##field(p3.Y, p3.Y, p3.X);      /* H^2*U1-X3 */\+    mul_##field(p3.Y, p3.Y, add.R);     /* R*(H^2*U1-X3) */\+    sub_##field(p3.Y, p3.Y, dbl.R);     /* Y3 = R*(H^2*U1-X3)-H^3*S1 */\+\+    vec_select(&p3, p1, &p3, sizeof(ptype), p2inf); \+    vec_select(out, p2, &p3, sizeof(ptype), p1inf); \+}++/*+ * Addition with affine point that can handle doubling [as well as+ * points at infinity, with |p1| being encoded as Z==0 and |p2| as+ * X,Y==0] in constant time. But at what additional cost? Best+ * addition result is 7M+4S, while this routine takes 8M+5S, as per+ *+ * -------------+-------------+ * addition     | doubling+ * -------------+-------------+ * U1 = X1      | U1 = X2+ * U2 = X2*Z1^2 |+ * S1 = Y1      | S1 = Y2+ * S2 = Y2*Z1^3 |+ * H = U2-X1    | H' = 2*Y2+ * R = S2-Y1    | R' = 3*X2^2[+a]+ * sx = X1+U2   | sx = X2+X2+ * zz = H*Z1    | zz = H'+ * -------------+-------------+ * H!=0 || R!=0 | H==0 && R==0+ *+ *      X3 = R^2-H^2*sx+ *      Y3 = R*(H^2*U1-X3)-H^3*S1+ *      Z3 = zz+ *+ * As for R!=0 condition in context of H==0, a.k.a. P-P. The result is+ * infinity by virtue of Z3 = (U2-U1)*zz = H*zz = 0*zz == 0.+ */+#define POINT_DADD_AFFINE_IMPL_A0(ptype, bits, field, one) \+static void ptype##_dadd_affine(ptype *out, const ptype *p1, \+                                            const ptype##_affine *p2) \+{ \+    ptype p3; /* starts as (,, H*Z1) from addition side */\+    struct { vec##bits H, R, sx; } add, dbl; \+    bool_t p1inf, p2inf, is_dbl; \+\+    p2inf = vec_is_zero(p2->X, 2*sizeof(p2->X)); \+    add_##field(dbl.sx, p2->X, p2->X);  /* sx = X2+X2 */\+    sqr_##field(dbl.R, p2->X);          /* X2^2 */\+    mul_by_3_##field(dbl.R, dbl.R);     /* R = 3*X2^2 */\+    add_##field(dbl.H, p2->Y, p2->Y);   /* H = 2*Y2 */\+\+    p1inf = vec_is_zero(p1->Z, sizeof(p1->Z)); \+    sqr_##field(add.H, p1->Z);          /* Z1^2 */\+    mul_##field(add.R, add.H, p1->Z);   /* Z1^3 */\+    mul_##field(add.R, add.R, p2->Y);   /* S2 = Y2*Z1^3 */\+    sub_##field(add.R, add.R, p1->Y);   /* R = S2-Y1 */\+\+    mul_##field(add.H, add.H, p2->X);   /* U2 = X2*Z1^2 */\+\+    add_##field(add.sx, add.H, p1->X);  /* sx = X1+U2 */\+    sub_##field(add.H, add.H, p1->X);   /* H = U2-X1 */\+\+    mul_##field(p3.Z, add.H, p1->Z);    /* Z3 = H*Z1 */\+\+    /* make the choice between addition and doubling */ \+    is_dbl = vec_is_zero(add.H, 2*sizeof(add.H));       \+    vec_select(p3.X, p2, p1, 2*sizeof(p3.X), is_dbl);   \+    vec_select(p3.Z, dbl.H, p3.Z, sizeof(p3.Z), is_dbl);\+    vec_select(&add, &dbl, &add, sizeof(add), is_dbl);  \+    /* |p3| and |add| hold all inputs now, |p3| will hold output */\+\+    sqr_##field(dbl.H, add.H);          /* H^2 */\+    mul_##field(dbl.R, dbl.H, add.H);   /* H^3 */\+    mul_##field(dbl.R, dbl.R, p3.Y);    /* H^3*S1 */\+    mul_##field(p3.Y, dbl.H, p3.X);     /* H^2*U1 */\+\+    mul_##field(dbl.H, dbl.H, add.sx);  /* H^2*sx */\+    sqr_##field(p3.X, add.R);           /* R^2 */\+    sub_##field(p3.X, p3.X, dbl.H);     /* X3 = R^2-H^2*sx */\+\+    sub_##field(p3.Y, p3.Y, p3.X);      /* H^2*U1-X3 */\+    mul_##field(p3.Y, p3.Y, add.R);     /* R*(H^2*U1-X3) */\+    sub_##field(p3.Y, p3.Y, dbl.R);     /* Y3 = R*(H^2*U1-X3)-H^3*S1 */\+\+    vec_select(p3.X, p2,  p3.X, 2*sizeof(p3.X), p1inf); \+    vec_select(p3.Z, one, p3.Z, sizeof(p3.Z), p1inf); \+    vec_select(out, p1, &p3, sizeof(ptype), p2inf); \+}++/*+ * https://www.hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#addition-add-2007-bl+ * with twist to handle either input at infinity, which are encoded as Z==0.+ */+#define POINT_ADD_IMPL(ptype, bits, field) \+static void ptype##_add(ptype *out, const ptype *p1, const ptype *p2) \+{ \+    ptype p3; \+    vec##bits Z1Z1, Z2Z2, U1, S1, H, I, J; \+    bool_t p1inf, p2inf; \+\+    p1inf = vec_is_zero(p1->Z, sizeof(p1->Z)); \+    sqr_##field(Z1Z1, p1->Z);           /* Z1Z1 = Z1^2 */\+\+    mul_##field(p3.Z, Z1Z1, p1->Z);     /* Z1*Z1Z1 */\+    mul_##field(p3.Z, p3.Z, p2->Y);     /* S2 = Y2*Z1*Z1Z1 */\+\+    p2inf = vec_is_zero(p2->Z, sizeof(p2->Z)); \+    sqr_##field(Z2Z2, p2->Z);           /* Z2Z2 = Z2^2 */\+\+    mul_##field(S1, Z2Z2, p2->Z);       /* Z2*Z2Z2 */\+    mul_##field(S1, S1, p1->Y);         /* S1 = Y1*Z2*Z2Z2 */\+\+    sub_##field(p3.Z, p3.Z, S1);        /* S2-S1 */\+    add_##field(p3.Z, p3.Z, p3.Z);      /* r = 2*(S2-S1) */\+\+    mul_##field(U1, p1->X, Z2Z2);       /* U1 = X1*Z2Z2 */\+    mul_##field(H,  p2->X, Z1Z1);       /* U2 = X2*Z1Z1 */\+\+    sub_##field(H, H, U1);              /* H = U2-U1 */\+\+    add_##field(I, H, H);               /* 2*H */\+    sqr_##field(I, I);                  /* I = (2*H)^2 */\+\+    mul_##field(J, H, I);               /* J = H*I */\+    mul_##field(S1, S1, J);             /* S1*J */\+\+    mul_##field(p3.Y, U1, I);           /* V = U1*I */\+\+    sqr_##field(p3.X, p3.Z);            /* r^2 */\+    sub_##field(p3.X, p3.X, J);         /* r^2-J */\+    sub_##field(p3.X, p3.X, p3.Y);      \+    sub_##field(p3.X, p3.X, p3.Y);      /* X3 = r^2-J-2*V */\+\+    sub_##field(p3.Y, p3.Y, p3.X);      /* V-X3 */\+    mul_##field(p3.Y, p3.Y, p3.Z);      /* r*(V-X3) */\+    sub_##field(p3.Y, p3.Y, S1);        \+    sub_##field(p3.Y, p3.Y, S1);        /* Y3 = r*(V-X3)-2*S1*J */\+\+    add_##field(p3.Z, p1->Z, p2->Z);    /* Z1+Z2 */\+    sqr_##field(p3.Z, p3.Z);            /* (Z1+Z2)^2 */\+    sub_##field(p3.Z, p3.Z, Z1Z1);      /* (Z1+Z2)^2-Z1Z1 */\+    sub_##field(p3.Z, p3.Z, Z2Z2);      /* (Z1+Z2)^2-Z1Z1-Z2Z2 */\+    mul_##field(p3.Z, p3.Z, H);         /* Z3 = ((Z1+Z2)^2-Z1Z1-Z2Z2)*H */\+\+    vec_select(&p3, p1, &p3, sizeof(ptype), p2inf); \+    vec_select(out, p2, &p3, sizeof(ptype), p1inf); \+}++/*+ * https://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#addition-madd-2007-bl+ * with twist to handle either input at infinity, with |p1| encoded as Z==0,+ * and |p2| as X==Y==0.+ */+#define POINT_ADD_AFFINE_IMPL(ptype, bits, field, one) \+static void ptype##_add_affine(ptype *out, const ptype *p1, \+                                           const ptype##_affine *p2) \+{ \+    ptype p3; \+    vec##bits Z1Z1, H, HH, I, J; \+    bool_t p1inf, p2inf; \+\+    p1inf = vec_is_zero(p1->Z, sizeof(p1->Z)); \+\+    sqr_##field(Z1Z1, p1->Z);           /* Z1Z1 = Z1^2 */\+\+    mul_##field(p3.Z, Z1Z1, p1->Z);     /* Z1*Z1Z1 */\+    mul_##field(p3.Z, p3.Z, p2->Y);     /* S2 = Y2*Z1*Z1Z1 */\+\+    p2inf = vec_is_zero(p2->X, 2*sizeof(p2->X)); \+\+    mul_##field(H, p2->X, Z1Z1);        /* U2 = X2*Z1Z1 */\+    sub_##field(H, H, p1->X);           /* H = U2-X1 */\+\+    sqr_##field(HH, H);                 /* HH = H^2 */\+    add_##field(I, HH, HH);             \+    add_##field(I, I, I);               /* I = 4*HH */\+\+    mul_##field(p3.Y, p1->X, I);        /* V = X1*I */\+    mul_##field(J, H, I);               /* J = H*I */\+    mul_##field(I, J, p1->Y);           /* Y1*J */\+\+    sub_##field(p3.Z, p3.Z, p1->Y);     /* S2-Y1 */\+    add_##field(p3.Z, p3.Z, p3.Z);      /* r = 2*(S2-Y1) */\+\+    sqr_##field(p3.X, p3.Z);            /* r^2 */\+    sub_##field(p3.X, p3.X, J);         /* r^2-J */\+    sub_##field(p3.X, p3.X, p3.Y);      \+    sub_##field(p3.X, p3.X, p3.Y);      /* X3 = r^2-J-2*V */\+\+    sub_##field(p3.Y, p3.Y, p3.X);      /* V-X3 */\+    mul_##field(p3.Y, p3.Y, p3.Z);      /* r*(V-X3) */\+    sub_##field(p3.Y, p3.Y, I);         \+    sub_##field(p3.Y, p3.Y, I);         /* Y3 = r*(V-X3)-2*Y1*J */\+\+    add_##field(p3.Z, p1->Z, H);        /* Z1+H */\+    sqr_##field(p3.Z, p3.Z);            /* (Z1+H)^2 */\+    sub_##field(p3.Z, p3.Z, Z1Z1);      /* (Z1+H)^2-Z1Z1 */\+    sub_##field(p3.Z, p3.Z, HH);        /* Z3 = (Z1+H)^2-Z1Z1-HH */\+\+    vec_select(p3.Z, one, p3.Z, sizeof(p3.Z), p1inf); \+    vec_select(p3.X, p2,  p3.X, 2*sizeof(p3.X), p1inf); \+    vec_select(out, p1, &p3, sizeof(ptype), p2inf); \+}++/*+ * https://www.hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#doubling-dbl-2009-l+ */+#define POINT_DOUBLE_IMPL_A0(ptype, bits, field) \+static void ptype##_double(ptype *p3, const ptype *p1) \+{ \+    vec##bits A, B, C; \+\+    sqr_##field(A, p1->X);              /* A = X1^2 */\+    sqr_##field(B, p1->Y);              /* B = Y1^2 */\+    sqr_##field(C, B);                  /* C = B^2 */\+\+    add_##field(B, B, p1->X);           /* X1+B */\+    sqr_##field(B, B);                  /* (X1+B)^2 */\+    sub_##field(B, B, A);               /* (X1+B)^2-A */\+    sub_##field(B, B, C);               /* (X1+B)^2-A-C */\+    add_##field(B, B, B);               /* D = 2*((X1+B)^2-A-C) */\+\+    mul_by_3_##field(A, A);             /* E = 3*A */\+\+    sqr_##field(p3->X, A);              /* F = E^2 */\+    sub_##field(p3->X, p3->X, B);       \+    sub_##field(p3->X, p3->X, B);       /* X3 = F-2*D */\+\+    add_##field(p3->Z, p1->Z, p1->Z);   /* 2*Z1 */\+    mul_##field(p3->Z, p3->Z, p1->Y);   /* Z3 = 2*Z1*Y1 */\+\+    mul_by_8_##field(C, C);             /* 8*C */\+    sub_##field(p3->Y, B, p3->X);       /* D-X3 */\+    mul_##field(p3->Y, p3->Y, A);       /* E*(D-X3) */\+    sub_##field(p3->Y, p3->Y, C);       /* Y3 = E*(D-X3)-8*C */\+}++#define POINT_LADDER_PRE_IMPL(ptype, bits, field) \+static void ptype##xz_ladder_pre(ptype##xz *pxz, const ptype *p) \+{ \+    mul_##field(pxz->X, p->X, p->Z);    /* X2 = X1*Z1 */\+    sqr_##field(pxz->Z, p->Z);          \+    mul_##field(pxz->Z, pxz->Z, p->Z);  /* Z2 = Z1^3 */\+}++/*+ * https://hyperelliptic.org/EFD/g1p/auto-shortw-xz.html#ladder-ladd-2002-it-3+ * with twist to handle either input at infinity, which are encoded as Z==0.+ * Just in case, order of doubling and addition is reverse in comparison to+ * hyperelliptic.org entry. This was done to minimize temporary storage.+ *+ * XZ1 is |p|, XZ2&XZ4 are in&out |r|, XZ3&XZ5 are in&out |s|.+ */+#define POINT_LADDER_STEP_IMPL_A0(ptype, bits, field, suffix4b) \+static void ptype##xz_ladder_step(ptype##xz *r, ptype##xz *s, \+                                  const ptype##xz *p) \+{ \+    ptype##xz p5; \+    vec##bits A, B, C, D, XX, ZZ; \+    bool_t r_inf, s_inf; \+                                        /* s += r */\+    mul_##field(A, r->X, s->X);         /* A = X2*X3 */\+    mul_##field(B, r->Z, s->Z);         /* B = Z2*Z3 */\+    mul_##field(C, r->X, s->Z);         /* C = X2*Z3 */\+    mul_##field(D, r->Z, s->X);         /* D = X3*Z2 */\+\+    sqr_##field(A, A);                  /* (A[-a*B])^2 */\+    add_##field(p5.X, C, D);            /* C+D */\+    mul_##field(p5.X, p5.X, B);         /* B*(C+D) */\+    mul_by_4b_##suffix4b(B, p5.X);      /* b4*B*(C+D) */\+    sub_##field(p5.X, A, B);            /* (A[-a*B])^2-b4*B*(C+D) */\+    mul_##field(p5.X, p5.X, p->Z);      /* X5 = Z1*((A[-a*B])^2-b4*B*(C+D)) */\+\+    sub_##field(p5.Z, C, D);            /* C-D */\+    sqr_##field(p5.Z, p5.Z);            /* (C-D)^2 */\+    mul_##field(p5.Z, p5.Z, p->X);      /* Z5 = X1*(C-D)^2 */\+\+    r_inf = vec_is_zero(r->Z, sizeof(r->Z)); \+    s_inf = vec_is_zero(s->Z, sizeof(s->Z)); \+\+    vec_select(&p5, r, &p5, sizeof(ptype##xz), s_inf); \+    vec_select(s,   s, &p5, sizeof(ptype##xz), r_inf); \+                                        /* r *= 2 */\+    sqr_##field(XX, r->X);              /* XX = X2^2 */\+    sqr_##field(ZZ, r->Z);              /* ZZ = Z2^2 */\+\+    add_##field(r->Z, r->X, r->Z);      /* X2+Z2 */\+    sqr_##field(r->Z, r->Z);            /* (X2+Z2)^2 */\+    sub_##field(r->Z, r->Z, XX);        /* (X2+Z2)^2-XX */\+    sub_##field(r->Z, r->Z, ZZ);        /* E = (X2+Z2)^2-XX-ZZ */\+\+    sqr_##field(A, XX);                 /* (XX[-a*ZZ])^2 */\+    mul_##field(B, r->Z, ZZ);           /* E*ZZ */\+    mul_by_4b_##suffix4b(C, B);         /* b4*E*ZZ */\+    sub_##field(r->X, A, C);            /* X4 = (XX[-a*ZZ])^2-b4*E*ZZ */\+\+    sqr_##field(ZZ, ZZ);                /* ZZ^2 */\+    mul_by_4b_##suffix4b(B, ZZ);        /* b4*ZZ^2 */\+    mul_##field(r->Z, r->Z, XX);        /* E*(XX[+a*ZZ]) */\+    add_##field(r->Z, r->Z, r->Z);      /* 2*E*(XX[+a*ZZ]) */\+    add_##field(r->Z, r->Z, B);         /* Z4 = 2*E*(XX[+a*ZZ])+b4*ZZ^2 */\+}++/*+ * Recover the |r|'s y-coordinate using Eq. (8) from Brier-Joye,+ * "Weierstraß Elliptic Curves and Side-Channel Attacks", with XZ twist+ * and conversion to Jacobian coordinates from <openssl>/.../ecp_smpl.c,+ * and with twist to recover from |s| at infinity [which occurs when+ * multiplying by (order-1)].+ *+ * X4 = 2*Y1*X2*Z3*Z1*Z2+ * Y4 = 2*b*Z3*(Z1*Z2)^2 + Z3*(a*Z1*Z2+X1*X2)*(X1*Z2+X2*Z1) - X3*(X1*Z2-X2*Z1)^2+ * Z4 = 2*Y1*Z3*Z2^2*Z1+ *+ * Z3x2 = 2*Z3+ * Y1Z3x2 = Y1*Z3x2+ * Z1Z2 = Z1*Z2+ * X1Z2 = X1*Z2+ * X2Z1 = X2*Z1+ * X4 = Y1Z3x2*X2*Z1Z2+ * A = b*Z3x2*(Z1Z2)^2+ * B = Z3*(a*Z1Z2+X1*X2)*(X1Z2+X2Z1)+ * C = X3*(X1Z2-X2Z1)^2+ * Y4 = A+B-C+ * Z4 = Y1Z3x2*Z1Z2*Z2+ *+ * XZ1 is |p|, XZ2 is |r|, XZ3 is |s|, 'a' is 0.+ */+#define POINT_LADDER_POST_IMPL_A0(ptype, bits, field, suffixb) \+static void ptype##xz_ladder_post(ptype *p4, \+                                  const ptype##xz *r, const ptype##xz *s, \+                                  const ptype##xz *p, const vec##bits Y1) \+{ \+    vec##bits Z3x2, Y1Z3x2, Z1Z2, X1Z2, X2Z1, A, B, C; \+    bool_t s_inf; \+\+    add_##field(Z3x2, s->Z, s->Z);      /* Z3x2 = 2*Z3 */\+    mul_##field(Y1Z3x2, Y1, Z3x2);      /* Y1Z3x2 = Y1*Z3x2 */\+    mul_##field(Z1Z2, p->Z, r->Z);      /* Z1Z2 = Z1*Z2 */\+    mul_##field(X1Z2, p->X, r->Z);      /* X1Z2 = X1*Z2 */\+    mul_##field(X2Z1, r->X, p->Z);      /* X2Z1 = X2*Z1 */\+\+    mul_##field(p4->X, Y1Z3x2, r->X);   /* Y1Z3x2*X2 */\+    mul_##field(p4->X, p4->X, Z1Z2);    /* X4 = Y1Z3x2*X2*Z1Z2 */\+\+    sqr_##field(A, Z1Z2);               /* (Z1Z2)^2 */\+    mul_##field(B, A, Z3x2);            /* Z3x2*(Z1Z2)^2 */\+    mul_by_b_##suffixb(A, B);           /* A = b*Z3x2*(Z1Z2)^2 */\+\+    mul_##field(B, p->X, r->X);         /* [a*Z1Z2+]X1*X2 */\+    mul_##field(B, B, s->Z);            /* Z3*([a*Z1Z2+]X1*X2) */\+    add_##field(C, X1Z2, X2Z1);         /* X1Z2+X2Z1 */\+    mul_##field(B, B, C);               /* B = Z3*([a*Z2Z1+]X1*X2)*(X1Z2+X2Z1) */\+\+    sub_##field(C, X1Z2, X2Z1);         /* X1Z2-X2Z1 */\+    sqr_##field(C, C);                  /* (X1Z2-X2Z1)^2 */\+    mul_##field(C, C, s->X);            /* C = X3*(X1Z2-X2Z1)^2 */\+\+    add_##field(A, A, B);               /* A+B */\+    sub_##field(A, A, C);               /* Y4 = A+B-C */\+\+    mul_##field(p4->Z, Z1Z2, r->Z);     /* Z1Z2*Z2 */\+    mul_##field(p4->Z, p4->Z, Y1Z3x2);  /* Y1Z3x2*Z1Z2*Z2 */\+\+    s_inf = vec_is_zero(s->Z, sizeof(s->Z)); \+    vec_select(p4->X, p->X, p4->X, sizeof(p4->X), s_inf); \+    vec_select(p4->Y, Y1,   A,     sizeof(p4->Y), s_inf); \+    vec_select(p4->Z, p->Z, p4->Z, sizeof(p4->Z), s_inf); \+    ptype##_cneg(p4, s_inf); \+                                        /* to Jacobian */\+    mul_##field(p4->X, p4->X, p4->Z);   /* X4 = X4*Z4 */\+    sqr_##field(B, p4->Z);              \+    mul_##field(p4->Y, p4->Y, B);       /* Y4 = Y4*Z4^2 */\+}++#define POINT_IS_EQUAL_IMPL(ptype, bits, field) \+static limb_t ptype##_is_equal(const ptype *p1, const ptype *p2) \+{ \+    vec##bits Z1Z1, Z2Z2; \+    ptype##_affine a1, a2; \+    bool_t is_inf1 = vec_is_zero(p1->Z, sizeof(p1->Z)); \+    bool_t is_inf2 = vec_is_zero(p2->Z, sizeof(p2->Z)); \+\+    sqr_##field(Z1Z1, p1->Z);           /* Z1Z1 = Z1^2 */\+    sqr_##field(Z2Z2, p2->Z);           /* Z2Z2 = Z2^2 */\+\+    mul_##field(a1.X, p1->X, Z2Z2);     /* U1 = X1*Z2Z2 */\+    mul_##field(a2.X, p2->X, Z1Z1);     /* U2 = X2*Z1Z1 */\+\+    mul_##field(a1.Y, p1->Y, p2->Z);    /* Y1*Z2 */\+    mul_##field(a2.Y, p2->Y, p1->Z);    /* Y2*Z1 */\+\+    mul_##field(a1.Y, a1.Y, Z2Z2);      /* S1 = Y1*Z2*Z2Z2 */\+    mul_##field(a2.Y, a2.Y, Z1Z1);      /* S2 = Y2*Z1*Z1Z1 */\+\+    return vec_is_equal(&a1, &a2, sizeof(a1)) & (is_inf1 ^ is_inf2 ^ 1); \+}++/*+ * https://eprint.iacr.org/2015/1060, algorithm 7 with a twist to handle+ * |p3| pointing at either |p1| or |p2|. This is resolved by adding |t5|+ * and replacing few first references to |X3| in the formula, up to step+ * 21, with it. 12M[+27A], doubling and infinity are handled by the+ * formula itself. Infinity is to be encoded as [0, !0, 0].+ */+#define POINT_PROJ_DADD_IMPL_A0(ptype, bits, field, suffixb) \+static void ptype##proj_dadd(ptype##proj *p3, const ptype##proj *p1, \+                                              const ptype##proj *p2) \+{ \+    vec##bits t0, t1, t2, t3, t4, t5; \+\+    mul_##field(t0, p1->X, p2->X);      /* 1.     t0 = X1*X2 */\+    mul_##field(t1, p1->Y, p2->Y);      /* 2.     t1 = Y1*Y2 */\+    mul_##field(t2, p1->Z, p2->Z);      /* 3.     t2 = Z1*Z2 */\+    add_##field(t3, p1->X, p1->Y);      /* 4.     t3 = X1+Y1 */\+    add_##field(t4, p2->X, p2->Y);      /* 5.     t4 = X2+Y2 */\+    mul_##field(t3, t3, t4);            /* 6.     t3 = t3*t4 */\+    add_##field(t4, t0, t1);            /* 7.     t4 = t0+t1 */\+    sub_##field(t3, t3, t4);            /* 8.     t3 = t3-t4 */\+    add_##field(t4, p1->Y, p1->Z);      /* 9.     t4 = Y1+Z1 */\+    add_##field(t5, p2->Y, p2->Z);      /* 10.    t5 = Y2+Z2 */\+    mul_##field(t4, t4, t5);            /* 11.    t4 = t4*t5 */\+    add_##field(t5, t1, t2);            /* 12.    t5 = t1+t2 */\+    sub_##field(t4, t4, t5);            /* 13.    t4 = t4-t5 */\+    add_##field(t5, p1->X, p1->Z);      /* 14.    t5 = X1+Z1 */\+    add_##field(p3->Y, p2->X, p2->Z);   /* 15.    Y3 = X2+Z2 */\+    mul_##field(t5, t5, p3->Y);         /* 16.    t5 = t5*Y3 */\+    add_##field(p3->Y, t0, t2);         /* 17.    Y3 = t0+t2 */\+    sub_##field(p3->Y, t5, p3->Y);      /* 18.    Y3 = t5-Y3 */\+    mul_by_3_##field(t0, t0);           /* 19-20. t0 = 3*t0  */\+    mul_by_3_##field(t5, t2);           /* 21.    t5 = 3*t2  */\+    mul_by_b_##suffixb(t2, t5);         /* 21.    t2 = b*t5  */\+    add_##field(p3->Z, t1, t2);         /* 22.    Z3 = t1+t2 */\+    sub_##field(t1, t1, t2);            /* 23.    t1 = t1-t2 */\+    mul_by_3_##field(t5, p3->Y);        /* 24.    t5 = 3*Y3  */\+    mul_by_b_##suffixb(p3->Y, t5);      /* 24.    Y3 = b*t5  */\+    mul_##field(p3->X, t4, p3->Y);      /* 25.    X3 = t4*Y3 */\+    mul_##field(t2, t3, t1);            /* 26.    t2 = t3*t1 */\+    sub_##field(p3->X, t2, p3->X);      /* 27.    X3 = t2-X3 */\+    mul_##field(p3->Y, p3->Y, t0);      /* 28.    Y3 = Y3*t0 */\+    mul_##field(t1, t1, p3->Z);         /* 29.    t1 = t1*Z3 */\+    add_##field(p3->Y, t1, p3->Y);      /* 30.    Y3 = t1+Y3 */\+    mul_##field(t0, t0, t3);            /* 31.    t0 = t0*t3 */\+    mul_##field(p3->Z, p3->Z, t4);      /* 32.    Z3 = Z3*t4 */\+    add_##field(p3->Z, p3->Z, t0);      /* 33.    Z3 = Z3+t0 */\+}++/*+ * https://eprint.iacr.org/2015/1060, algorithm 8 with a twist to handle+ * |p2| being infinity encoded as [0, 0]. 11M[+21A].+ */+#define POINT_PROJ_DADD_AFFINE_IMPL_A0(ptype, bits, field, suffixb) \+static void ptype##proj_dadd_affine(ptype##proj *out, const ptype##proj *p1, \+                                                      const ptype##_affine *p2) \+{ \+    ptype##proj p3[1]; \+    vec##bits t0, t1, t2, t3, t4; \+    limb_t p2inf = vec_is_zero(p2, sizeof(*p2)); \+\+    mul_##field(t0, p1->X, p2->X);      /* 1.     t0 = X1*X2 */\+    mul_##field(t1, p1->Y, p2->Y);      /* 2.     t1 = Y1*Y2 */\+    add_##field(t3, p1->X, p1->Y);      /* 3.     t3 = X1+Y1 */\+    add_##field(t4, p2->X, p2->Y);      /* 4.     t4 = X2+Y2 */\+    mul_##field(t3, t3, t4);            /* 5.     t3 = t3*t4 */\+    add_##field(t4, t0, t1);            /* 6.     t4 = t0+t1 */\+    sub_##field(t3, t3, t4);            /* 7.     t3 = t3-t4 */\+    mul_##field(t4, p2->Y, p1->Z);      /* 8.     t4 = Y2*Z1 */\+    add_##field(t4, t4, p1->Y);         /* 9.     t4 = t4+Y1 */\+    mul_##field(p3->Y, p2->X, p1->Z);   /* 10.    Y3 = X2*Z1 */\+    add_##field(p3->Y, p3->Y, p1->X);   /* 11.    Y3 = Y3+X1 */\+    mul_by_3_##field(t0, t0);           /* 12-13. t0 = 3*t0  */\+    mul_by_b_##suffixb(t2, p1->Z);      /* 14.    t2 = b*Z1  */\+    mul_by_3_##field(t2, t2);           /* 14.    t2 = 3*t2  */\+    add_##field(p3->Z, t1, t2);         /* 15.    Z3 = t1+t2 */\+    sub_##field(t1, t1, t2);            /* 16.    t1 = t1-t2 */\+    mul_by_b_##suffixb(t2, p3->Y);      /* 17.    t2 = b*Y3  */\+    mul_by_3_##field(p3->Y, t2);        /* 17.    Y3 = 3*t2  */\+    mul_##field(p3->X, t4, p3->Y);      /* 18.    X3 = t4*Y3 */\+    mul_##field(t2, t3, t1);            /* 19.    t2 = t3*t1 */\+    sub_##field(p3->X, t2, p3->X);      /* 20.    X3 = t2-X3 */\+    mul_##field(p3->Y, p3->Y, t0);      /* 21.    Y3 = Y3*t0 */\+    mul_##field(t1, t1, p3->Z);         /* 22.    t1 = t1*Z3 */\+    add_##field(p3->Y, t1, p3->Y);      /* 23.    Y3 = t1+Y3 */\+    mul_##field(t0, t0, t3);            /* 24.    t0 = t0*t3 */\+    mul_##field(p3->Z, p3->Z, t4);      /* 25.    Z3 = Z3*t4 */\+    add_##field(p3->Z, p3->Z, t0);      /* 26.    Z3 = Z3+t0 */\+\+    vec_select(out, p1, p3, sizeof(*out), p2inf); \+}++/*+ * https://eprint.iacr.org/2015/1060, algorithm 9 with a twist to handle+ * |p3| pointing at |p1|. This is resolved by adding |t3| to hold X*Y+ * and reordering operations to bring references to |p1| forward.+ * 6M+2S[+13A].+ */+#define POINT_PROJ_DOUBLE_IMPL_A0(ptype, bits, field, suffixb) \+static void ptype##proj_double(ptype##proj *p3, const ptype##proj *p1) \+{ \+    vec##bits t0, t1, t2, t3; \+\+    sqr_##field(t0, p1->Y);             /* 1.     t0 = Y*Y   */\+    mul_##field(t1, p1->Y, p1->Z);      /* 5.     t1 = Y*Z   */\+    sqr_##field(t2, p1->Z);             /* 6.     t2 = Z*Z   */\+    mul_##field(t3, p1->X, p1->Y);      /* 16.    t3 = X*Y   */\+    lshift_##field(p3->Z, t0, 3);       /* 2-4.   Z3 = 8*t0  */\+    mul_by_b_##suffixb(p3->X, t2);      /* 7.     t2 = b*t2  */\+    mul_by_3_##field(t2, p3->X);        /* 7.     t2 = 3*t2  */\+    mul_##field(p3->X, t2, p3->Z);      /* 8.     X3 = t2*Z3 */\+    add_##field(p3->Y, t0, t2);         /* 9.     Y3 = t0+t2 */\+    mul_##field(p3->Z, t1, p3->Z);      /* 10.    Z3 = t1*Z3 */\+    mul_by_3_##field(t2, t2);           /* 11-12. t2 = 3*t2  */\+    sub_##field(t0, t0, t2);            /* 13.    t0 = t0-t2 */\+    mul_##field(p3->Y, t0, p3->Y);      /* 14.    Y3 = t0*Y3 */\+    add_##field(p3->Y, p3->X, p3->Y);   /* 15.    Y3 = X3+Y3 */\+    mul_##field(p3->X, t0, t3);         /* 17.    X3 = t0*t3 */\+    add_##field(p3->X, p3->X, p3->X);   /* 18.    X3 = X3+X3 */\+}++#define POINT_PROJ_TO_JACOBIAN_IMPL(ptype, bits, field) \+static void ptype##proj_to_Jacobian(ptype *out, const ptype##proj *in) \+{ \+    vec##bits ZZ; \+\+    sqr_##field(ZZ, in->Z); \+    mul_##field(out->X, in->X, in->Z); \+    mul_##field(out->Y, in->Y, ZZ); \+    vec_copy(out->Z, in->Z, sizeof(out->Z)); \+}++#define POINT_TO_PROJECTIVE_IMPL(ptype, bits, field, one) \+static void ptype##_to_projective(ptype##proj *out, const ptype *in) \+{ \+    vec##bits ZZ; \+    limb_t is_inf = vec_is_zero(in->Z, sizeof(in->Z)); \+\+    sqr_##field(ZZ, in->Z); \+    mul_##field(out->X, in->X, in->Z); \+    vec_select(out->Y, one, in->Y, sizeof(out->Y), is_inf); \+    mul_##field(out->Z, ZZ, in->Z); \+}++/******************* !!!!! NOT CONSTANT TIME !!!!! *******************/++/*+ * http://hyperelliptic.org/EFD/g1p/auto-shortw-xyzz.html#addition-add-2008-s+ * http://hyperelliptic.org/EFD/g1p/auto-shortw-xyzz.html#doubling-dbl-2008-s-1+ * with twist to handle either input at infinity. Addition costs 12M+2S,+ * while conditional doubling - 4M+6M+3S.+ */+#define POINTXYZZ_DADD_IMPL(ptype, bits, field) \+static void ptype##xyzz_dadd(ptype##xyzz *p3, const ptype##xyzz *p1, \+                                              const ptype##xyzz *p2) \+{ \+    vec##bits U, S, P, R; \+\+    if (vec_is_zero(p2->ZZZ, 2*sizeof(p2->ZZZ))) { \+        vec_copy(p3, p1, sizeof(*p3));  \+        return; \+    } else if (vec_is_zero(p1->ZZZ, 2*sizeof(p1->ZZZ))) { \+        vec_copy(p3, p2, sizeof(*p3));  \+        return; \+    } \+\+    mul_##field(U, p1->X, p2->ZZ);              /* U1 = X1*ZZ2 */\+    mul_##field(S, p1->Y, p2->ZZZ);             /* S1 = Y1*ZZZ2 */\+    mul_##field(P, p2->X, p1->ZZ);              /* U2 = X2*ZZ1 */\+    mul_##field(R, p2->Y, p1->ZZZ);             /* S2 = Y2*ZZZ1 */\+    sub_##field(P, P, U);                       /* P = U2-U1 */\+    sub_##field(R, R, S);                       /* R = S2-S1 */\+\+    if (!vec_is_zero(P, sizeof(P))) {           /* X1!=X2 */\+        vec##bits PP, PPP, Q;                   /* add |p1| and |p2| */\+\+        sqr_##field(PP, P);                     /* PP = P^2 */\+        mul_##field(PPP, PP, P);                /* PPP = P*PP */\+        mul_##field(Q, U, PP);                  /* Q = U1*PP */\+        sqr_##field(p3->X, R);                  /* R^2 */\+        add_##field(P, Q, Q); \+        sub_##field(p3->X, p3->X, PPP);         /* R^2-PPP */\+        sub_##field(p3->X, p3->X, P);           /* X3 = R^2-PPP-2*Q */\+        sub_##field(Q, Q, p3->X); \+        mul_##field(Q, Q, R);                   /* R*(Q-X3) */\+        mul_##field(p3->Y, S, PPP);             /* S1*PPP */\+        sub_##field(p3->Y, Q, p3->Y);           /* Y3 = R*(Q-X3)-S1*PPP */\+        mul_##field(p3->ZZ, p1->ZZ, p2->ZZ);    /* ZZ1*ZZ2 */\+        mul_##field(p3->ZZZ, p1->ZZZ, p2->ZZZ); /* ZZZ1*ZZZ2 */\+        mul_##field(p3->ZZ, p3->ZZ, PP);        /* ZZ3 = ZZ1*ZZ2*PP */\+        mul_##field(p3->ZZZ, p3->ZZZ, PPP);     /* ZZZ3 = ZZZ1*ZZZ2*PPP */\+    } else if (vec_is_zero(R, sizeof(R))) {     /* X1==X2 && Y1==Y2 */\+        vec##bits V, W, M;                      /* double |p1| */\+\+        add_##field(U, p1->Y, p1->Y);           /* U = 2*Y1 */\+        sqr_##field(V, U);                      /* V = U^2 */\+        mul_##field(W, V, U);                   /* W = U*V */\+        mul_##field(S, p1->X, V);               /* S = X1*V */\+        sqr_##field(M, p1->X); \+        mul_by_3_##field(M, M);                 /* M = 3*X1^2[+a*ZZ1^2] */\+        sqr_##field(p3->X, M); \+        add_##field(U, S, S);                   /* 2*S */\+        sub_##field(p3->X, p3->X, U);           /* X3 = M^2-2*S */\+        mul_##field(p3->Y, W, p1->Y);           /* W*Y1 */\+        sub_##field(S, S, p3->X); \+        mul_##field(S, S, M);                   /* M*(S-X3) */\+        sub_##field(p3->Y, S, p3->Y);           /* Y3 = M*(S-X3)-W*Y1 */\+        mul_##field(p3->ZZ, p1->ZZ, V);         /* ZZ3 = V*ZZ1 */\+        mul_##field(p3->ZZZ, p1->ZZZ, W);       /* ZZ3 = W*ZZZ1 */\+    } else {                                    /* X1==X2 && Y1==-Y2 */\+        vec_zero(p3->ZZZ, 2*sizeof(p3->ZZZ));   /* set |p3| to infinity */\+    } \+}++/*+ * http://hyperelliptic.org/EFD/g1p/auto-shortw-xyzz.html#addition-madd-2008-s+ * http://hyperelliptic.org/EFD/g1p/auto-shortw-xyzz.html#doubling-mdbl-2008-s-1+ * with twists to handle even subtractions and either input at infinity.+ * Addition costs 8M+2S, while conditional doubling - 2M+4M+3S.+ */+#define POINTXYZZ_DADD_AFFINE_IMPL(ptype, bits, field, one) \+static void ptype##xyzz_dadd_affine(ptype##xyzz *p3, const ptype##xyzz *p1, \+                                                     const ptype##_affine *p2, \+                                                     bool_t subtract) \+{ \+    vec##bits P, R; \+\+    if (vec_is_zero(p2, sizeof(*p2))) { \+        vec_copy(p3, p1, sizeof(*p3));  \+        return; \+    } else if (vec_is_zero(p1->ZZZ, 2*sizeof(p1->ZZZ))) { \+        vec_copy(p3->X, p2->X, 2*sizeof(p3->X));\+        cneg_##field(p3->ZZZ, one, subtract);   \+        vec_copy(p3->ZZ, one, sizeof(p3->ZZ));  \+        return; \+    } \+\+    mul_##field(P, p2->X, p1->ZZ);              /* U2 = X2*ZZ1 */\+    mul_##field(R, p2->Y, p1->ZZZ);             /* S2 = Y2*ZZZ1 */\+    cneg_##field(R, R, subtract); \+    sub_##field(P, P, p1->X);                   /* P = U2-X1 */\+    sub_##field(R, R, p1->Y);                   /* R = S2-Y1 */\+\+    if (!vec_is_zero(P, sizeof(P))) {           /* X1!=X2 */\+        vec##bits PP, PPP, Q;                   /* add |p2| to |p1| */\+\+        sqr_##field(PP, P);                     /* PP = P^2 */\+        mul_##field(PPP, PP, P);                /* PPP = P*PP */\+        mul_##field(Q, p1->X, PP);              /* Q = X1*PP */\+        sqr_##field(p3->X, R);                  /* R^2 */\+        add_##field(P, Q, Q); \+        sub_##field(p3->X, p3->X, PPP);         /* R^2-PPP */\+        sub_##field(p3->X, p3->X, P);           /* X3 = R^2-PPP-2*Q */\+        sub_##field(Q, Q, p3->X); \+        mul_##field(Q, Q, R);                   /* R*(Q-X3) */\+        mul_##field(p3->Y, p1->Y, PPP);         /* Y1*PPP */\+        sub_##field(p3->Y, Q, p3->Y);           /* Y3 = R*(Q-X3)-Y1*PPP */\+        mul_##field(p3->ZZ, p1->ZZ, PP);        /* ZZ3 = ZZ1*PP */\+        mul_##field(p3->ZZZ, p1->ZZZ, PPP);     /* ZZZ3 = ZZZ1*PPP */\+    } else if (vec_is_zero(R, sizeof(R))) {     /* X1==X2 && Y1==Y2 */\+        vec##bits U, S, M;                      /* double |p2| */\+\+        add_##field(U, p2->Y, p2->Y);           /* U = 2*Y1 */\+        sqr_##field(p3->ZZ, U);                 /* [ZZ3 =] V = U^2 */\+        mul_##field(p3->ZZZ, p3->ZZ, U);        /* [ZZZ3 =] W = U*V */\+        mul_##field(S, p2->X, p3->ZZ);          /* S = X1*V */\+        sqr_##field(M, p2->X); \+        mul_by_3_##field(M, M);                 /* M = 3*X1^2[+a] */\+        sqr_##field(p3->X, M); \+        add_##field(U, S, S);                   /* 2*S */\+        sub_##field(p3->X, p3->X, U);           /* X3 = M^2-2*S */\+        mul_##field(p3->Y, p3->ZZZ, p2->Y);     /* W*Y1 */\+        sub_##field(S, S, p3->X); \+        mul_##field(S, S, M);                   /* M*(S-X3) */\+        sub_##field(p3->Y, S, p3->Y);           /* Y3 = M*(S-X3)-W*Y1 */\+        cneg_##field(p3->ZZZ, p3->ZZZ, subtract); \+    } else {                                    /* X1==X2 && Y1==-Y2 */\+        vec_zero(p3->ZZZ, 2*sizeof(p3->ZZZ));   /* set |p3| to infinity */\+    } \+}++#define POINTXYZZ_TO_JACOBIAN_IMPL(ptype, bits, field) \+static void ptype##xyzz_to_Jacobian(ptype *out, const ptype##xyzz *in) \+{ \+    mul_##field(out->X, in->X, in->ZZ); \+    mul_##field(out->Y, in->Y, in->ZZZ); \+    vec_copy(out->Z, in->ZZ, sizeof(out->Z)); \+}++#define POINT_TO_XYZZ_IMPL(ptype, bits, field) \+static void ptype##_to_xyzz(ptype##xyzz *out, const ptype *in) \+{ \+    vec_copy(out->X, in->X, 2*sizeof(out->X)); \+    sqr_##field(out->ZZ, in->Z); \+    mul_##field(out->ZZZ, out->ZZ, in->Z); \+}++#endif
+ c-source/src/errors.h view
@@ -0,0 +1,19 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */+#ifndef __BLS12_381_ASM_ERRORS_H__+#define __BLS12_381_ASM_ERRORS_H__++typedef enum {+    BLST_SUCCESS = 0,+    BLST_BAD_ENCODING,+    BLST_POINT_NOT_ON_CURVE,+    BLST_POINT_NOT_IN_GROUP,+    BLST_AGGR_TYPE_MISMATCH,+    BLST_VERIFY_FAIL,+    BLST_PK_IS_INFINITY,+} BLST_ERROR;++#endif
+ c-source/src/exp.c view
@@ -0,0 +1,55 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */++#include "vect.h"++/*+ * |out| = |inp|^|pow|, small footprint, public exponent+ */+static void exp_mont_384(vec384 out, const vec384 inp, const byte *pow,+                         size_t pow_bits, const vec384 p, limb_t n0)+{+#if 1+    vec384 ret;++    vec_copy(ret, inp, sizeof(ret));  /* ret = inp^1 */+    --pow_bits; /* most significant bit is set, skip over */+    while (pow_bits--) {+        sqr_mont_384(ret, ret, p, n0);+        if (is_bit_set(pow, pow_bits))+            mul_mont_384(ret, ret, inp, p, n0);+    }+    vec_copy(out, ret, sizeof(ret));  /* out = ret */+#else+    unsigned int i;+    vec384 sqr;++    vec_copy(sqr, inp, sizeof(sqr));+    for (i = 0; !is_bit_set(pow, i++);)+        sqr_mont_384(sqr, sqr, sqr, p, n0);+    vec_copy(out, sqr, sizeof(sqr));+    for (; i < pow_bits; i++) {+        sqr_mont_384(sqr, sqr, sqr, p, n0);+        if (is_bit_set(pow, i))+            mul_mont_384(out, out, sqr, p, n0);+    }+#endif+}++static void exp_mont_384x(vec384x out, const vec384x inp, const byte *pow,+                          size_t pow_bits, const vec384 p, limb_t n0)+{+    vec384x ret;++    vec_copy(ret, inp, sizeof(ret));  /* |ret| = |inp|^1 */+    --pow_bits; /* most significant bit is accounted for, skip over */+    while (pow_bits--) {+        sqr_mont_384x(ret, ret, p, n0);+        if (is_bit_set(pow, pow_bits))+            mul_mont_384x(ret, ret, inp, p, n0);+    }+    vec_copy(out, ret, sizeof(ret));  /* |out| = |ret| */+}
+ c-source/src/exports.c view
@@ -0,0 +1,559 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */+/*+ * Why this file? Overall goal is to ensure that all internal calls+ * remain internal after linking application. This is to both+ *+ * a) minimize possibility of external name conflicts (since all+ *    non-blst-prefixed and [assembly subroutines] remain static);+ * b) preclude possibility of unintentional internal reference+ *    overload in shared library context (one can achieve same+ *    effect with -Bsymbolic, but we don't want to rely on end-user+ *    to remember to use it);+ */++#include "fields.h"+#include "bytes.h"++/*+ * BLS12-381-specifc Fr shortcuts to assembly.+ */+void blst_fr_add(vec256 ret, const vec256 a, const vec256 b)+{   add_mod_256(ret, a, b, BLS12_381_r);   }++void blst_fr_sub(vec256 ret, const vec256 a, const vec256 b)+{   sub_mod_256(ret, a, b, BLS12_381_r);   }++void blst_fr_mul_by_3(vec256 ret, const vec256 a)+{   mul_by_3_mod_256(ret, a, BLS12_381_r);   }++void blst_fr_lshift(vec256 ret, const vec256 a, size_t count)+{   lshift_mod_256(ret, a, count, BLS12_381_r);   }++void blst_fr_rshift(vec256 ret, const vec256 a, size_t count)+{   rshift_mod_256(ret, a, count, BLS12_381_r);   }++void blst_fr_mul(vec256 ret, const vec256 a, const vec256 b)+{   mul_mont_sparse_256(ret, a, b, BLS12_381_r, r0);   }++void blst_fr_sqr(vec256 ret, const vec256 a)+{   sqr_mont_sparse_256(ret, a, BLS12_381_r, r0);   }++void blst_fr_cneg(vec256 ret, const vec256 a, int flag)+{   cneg_mod_256(ret, a, is_zero(flag) ^ 1, BLS12_381_r);   }++void blst_fr_to(vec256 ret, const vec256 a)+{   mul_mont_sparse_256(ret, a, BLS12_381_rRR, BLS12_381_r, r0);   }++void blst_fr_from(vec256 ret, const vec256 a)+{   from_mont_256(ret, a, BLS12_381_r, r0);   }++void blst_fr_from_scalar(vec256 ret, const pow256 a)+{+    const union {+        long one;+        char little;+    } is_endian = { 1 };++    if ((uptr_t)ret == (uptr_t)a && is_endian.little) {+        mul_mont_sparse_256(ret, (const limb_t *)a, BLS12_381_rRR,+                                                    BLS12_381_r, r0);+    } else {+        vec256 out;+        limbs_from_le_bytes(out, a, 32);+        mul_mont_sparse_256(ret, out, BLS12_381_rRR, BLS12_381_r, r0);+        vec_zero(out, sizeof(out));+    }+}++void blst_scalar_from_fr(pow256 ret, const vec256 a)+{+    const union {+        long one;+        char little;+    } is_endian = { 1 };++    if ((uptr_t)ret == (uptr_t)a && is_endian.little) {+        from_mont_256((limb_t *)ret, a, BLS12_381_r, r0);+    } else {+        vec256 out;+        from_mont_256(out, a, BLS12_381_r, r0);+        le_bytes_from_limbs(ret, out, 32);+        vec_zero(out, sizeof(out));+    }+}++int blst_scalar_fr_check(const pow256 a)+{   return (int)(check_mod_256(a, BLS12_381_r) |+                 bytes_are_zero(a, sizeof(pow256)));+}++int blst_sk_check(const pow256 a)+{   return (int)check_mod_256(a, BLS12_381_r);   }++int blst_sk_add_n_check(pow256 ret, const pow256 a, const pow256 b)+{   return (int)add_n_check_mod_256(ret, a, b, BLS12_381_r);   }++int blst_sk_sub_n_check(pow256 ret, const pow256 a, const pow256 b)+{   return (int)sub_n_check_mod_256(ret, a, b, BLS12_381_r);   }++int blst_sk_mul_n_check(pow256 ret, const pow256 a, const pow256 b)+{+    vec256 a_fr, b_fr;+    const union {+        long one;+        char little;+    } is_endian = { 1 };++    if (((size_t)a|(size_t)b)%sizeof(limb_t) != 0 || !is_endian.little) {+        limbs_from_le_bytes(a_fr, a, sizeof(a_fr));+        limbs_from_le_bytes(b_fr, b, sizeof(a_fr));+        a = (const byte *)a_fr;+        b = (const byte *)b_fr;+    }+    mul_mont_sparse_256(a_fr, (const limb_t *)a, BLS12_381_rRR,+                                                 BLS12_381_r, r0);+    mul_mont_sparse_256(b_fr, (const limb_t *)b, BLS12_381_rRR,+                                                 BLS12_381_r, r0);+    mul_mont_sparse_256(a_fr, a_fr, b_fr, BLS12_381_r, r0);+    from_mont_256(a_fr, a_fr, BLS12_381_r, r0);+    le_bytes_from_limbs(ret, a_fr, sizeof(a_fr));++    return (int)(vec_is_zero(a_fr, sizeof(a_fr)) ^ 1);+}++void blst_sk_inverse(pow256 ret, const pow256 a)+{+    const union {+        long one;+        char little;+    } is_endian = { 1 };++    if (((size_t)a|(size_t)ret)%sizeof(limb_t) == 0 && is_endian.little) {+        limb_t *out = (limb_t *)ret;+        mul_mont_sparse_256(out, (const limb_t *)a, BLS12_381_rRR,+                                                    BLS12_381_r, r0);+        reciprocal_fr(out, out);+        from_mont_256(out, out, BLS12_381_r, r0);+    } else {+        vec256 out;+        limbs_from_le_bytes(out, a, 32);+        mul_mont_sparse_256(out, out, BLS12_381_rRR, BLS12_381_r, r0);+        reciprocal_fr(out, out);+        from_mont_256(out, out, BLS12_381_r, r0);+        le_bytes_from_limbs(ret, out, 32);+        vec_zero(out, sizeof(out));+    }+}++/*+ * BLS12-381-specifc Fp shortcuts to assembly.+ */+void blst_fp_add(vec384 ret, const vec384 a, const vec384 b)+{   add_fp(ret, a, b);   }++void blst_fp_sub(vec384 ret, const vec384 a, const vec384 b)+{   sub_fp(ret, a, b);   }++void blst_fp_mul_by_3(vec384 ret, const vec384 a)+{   mul_by_3_fp(ret, a);   }++void blst_fp_mul_by_8(vec384 ret, const vec384 a)+{   mul_by_8_fp(ret, a);   }++void blst_fp_lshift(vec384 ret, const vec384 a, size_t count)+{   lshift_fp(ret, a, count);   }++void blst_fp_mul(vec384 ret, const vec384 a, const vec384 b)+{   mul_fp(ret, a, b);   }++void blst_fp_sqr(vec384 ret, const vec384 a)+{   sqr_fp(ret, a);   }++void blst_fp_cneg(vec384 ret, const vec384 a, int flag)+{   cneg_fp(ret, a, is_zero(flag) ^ 1);   }++void blst_fp_to(vec384 ret, const vec384 a)+{   mul_fp(ret, a, BLS12_381_RR);   }++void blst_fp_from(vec384 ret, const vec384 a)+{   from_fp(ret, a);   }++/*+ * Fp serialization/deserialization.+ */+void blst_fp_from_uint32(vec384 ret, const unsigned int a[12])+{+    if (sizeof(limb_t) == 8) {+        int i;+        for (i = 0; i < 6; i++)+            ret[i] = a[2*i] | ((limb_t)a[2*i+1] << (32 & (8*sizeof(limb_t)-1)));+        a = (const unsigned int *)ret;+    }+    mul_fp(ret, (const limb_t *)a, BLS12_381_RR);+}++void blst_uint32_from_fp(unsigned int ret[12], const vec384 a)+{+    if (sizeof(limb_t) == 4) {+        from_fp((limb_t *)ret, a);+    } else {+        vec384 out;+        int i;++        from_fp(out, a);+        for (i = 0; i < 6; i++) {+            limb_t limb = out[i];+            ret[2*i]   = (unsigned int)limb;+            ret[2*i+1] = (unsigned int)(limb >> (32 & (8*sizeof(limb_t)-1)));+        }+    }+}++void blst_fp_from_uint64(vec384 ret, const unsigned long long a[6])+{+    const union {+        long one;+        char little;+    } is_endian = { 1 };++    if (sizeof(limb_t) == 4 && !is_endian.little) {+        int i;+        for (i = 0; i < 6; i++) {+            unsigned long long limb = a[i];+            ret[2*i]   = (limb_t)limb;+            ret[2*i+1] = (limb_t)(limb >> 32);+        }+        a = (const unsigned long long *)ret;+    }+    mul_fp(ret, (const limb_t *)a, BLS12_381_RR);+}++void blst_uint64_from_fp(unsigned long long ret[6], const vec384 a)+{+    const union {+        long one;+        char little;+    } is_endian = { 1 };++    if (sizeof(limb_t) == 8 || is_endian.little) {+        from_fp((limb_t *)ret, a);+    } else {+        vec384 out;+        int i;++        from_fp(out, a);+        for (i = 0; i < 6; i++)+            ret[i] = out[2*i] | ((unsigned long long)out[2*i+1] << 32);+    }+}++void blst_fp_from_bendian(vec384 ret, const unsigned char a[48])+{+    vec384 out;++    limbs_from_be_bytes(out, a, sizeof(vec384));+    mul_fp(ret, out, BLS12_381_RR);+}++void blst_bendian_from_fp(unsigned char ret[48], const vec384 a)+{+    vec384 out;++    from_fp(out, a);+    be_bytes_from_limbs(ret, out, sizeof(vec384));+}++void blst_fp_from_lendian(vec384 ret, const unsigned char a[48])+{+    vec384 out;++    limbs_from_le_bytes(out, a, sizeof(vec384));+    mul_fp(ret, out, BLS12_381_RR);+}++void blst_lendian_from_fp(unsigned char ret[48], const vec384 a)+{+    vec384 out;++    from_fp(out, a);+    le_bytes_from_limbs(ret, out, sizeof(vec384));+}++/*+ * BLS12-381-specifc Fp2 shortcuts to assembly.+ */+void blst_fp2_add(vec384x ret, const vec384x a, const vec384x b)+{   add_fp2(ret, a, b);   }++void blst_fp2_sub(vec384x ret, const vec384x a, const vec384x b)+{   sub_fp2(ret, a, b);   }++void blst_fp2_mul_by_3(vec384x ret, const vec384x a)+{   mul_by_3_fp2(ret, a);   }++void blst_fp2_mul_by_8(vec384x ret, const vec384x a)+{   mul_by_8_fp2(ret, a);   }++void blst_fp2_lshift(vec384x ret, const vec384x a, size_t count)+{   lshift_fp2(ret, a, count);    }++void blst_fp2_mul(vec384x ret, const vec384x a, const vec384x b)+{   mul_fp2(ret, a, b);   }++void blst_fp2_sqr(vec384x ret, const vec384x a)+{   sqr_fp2(ret, a);   }++void blst_fp2_cneg(vec384x ret, const vec384x a, int flag)+{   cneg_fp2(ret, a, is_zero(flag) ^ 1);   }++/*+ * Scalar serialization/deseriazation+ */+void blst_scalar_from_uint32(pow256 ret, const unsigned int a[8])+{+    const union {+        long one;+        char little;+    } is_endian = { 1 };+    size_t i;++    if ((uptr_t)ret==(uptr_t)a && is_endian.little)+        return;++    for(i = 0; i < 8; i++) {+        unsigned int w = a[i];+        *ret++ = (byte)w;+        *ret++ = (byte)(w >> 8);+        *ret++ = (byte)(w >> 16);+        *ret++ = (byte)(w >> 24);+    }+}++void blst_uint32_from_scalar(unsigned int ret[8], const pow256 a)+{+    const union {+        long one;+        char little;+    } is_endian = { 1 };+    size_t i;++    if ((uptr_t)ret==(uptr_t)a && is_endian.little)+        return;++    for(i = 0; i < 8; i++) {+        unsigned int w = (unsigned int)(*a++);+        w |= (unsigned int)(*a++) << 8;+        w |= (unsigned int)(*a++) << 16;+        w |= (unsigned int)(*a++) << 24;+        ret[i] = w;+    }+}++void blst_scalar_from_uint64(pow256 ret, const unsigned long long a[4])+{+    const union {+        long one;+        char little;+    } is_endian = { 1 };+    size_t i;++    if ((uptr_t)ret==(uptr_t)a && is_endian.little)+        return;++    for(i = 0; i < 4; i++) {+        unsigned long long w = a[i];+        *ret++ = (byte)w;+        *ret++ = (byte)(w >> 8);+        *ret++ = (byte)(w >> 16);+        *ret++ = (byte)(w >> 24);+        *ret++ = (byte)(w >> 32);+        *ret++ = (byte)(w >> 40);+        *ret++ = (byte)(w >> 48);+        *ret++ = (byte)(w >> 56);+    }+}++void blst_uint64_from_scalar(unsigned long long ret[4], const pow256 a)+{+    const union {+        long one;+        char little;+    } is_endian = { 1 };+    size_t i;++    if ((uptr_t)ret==(uptr_t)a && is_endian.little)+        return;++    for(i = 0; i < 4; i++) {+        unsigned long long w = (unsigned long long)(*a++);+        w |= (unsigned long long)(*a++) << 8;+        w |= (unsigned long long)(*a++) << 16;+        w |= (unsigned long long)(*a++) << 24;+        w |= (unsigned long long)(*a++) << 32;+        w |= (unsigned long long)(*a++) << 40;+        w |= (unsigned long long)(*a++) << 48;+        w |= (unsigned long long)(*a++) << 56;+        ret[i] = w;+    }+}++void blst_scalar_from_bendian(pow256 ret, const unsigned char a[32])+{+    vec256 out;+    limbs_from_be_bytes(out, a, sizeof(out));+    le_bytes_from_limbs(ret, out, sizeof(out));+    vec_zero(out, sizeof(out));+}++void blst_bendian_from_scalar(unsigned char ret[32], const pow256 a)+{+    vec256 out;+    limbs_from_le_bytes(out, a, sizeof(out));+    be_bytes_from_limbs(ret, out, sizeof(out));+    vec_zero(out, sizeof(out));+}++void blst_scalar_from_lendian(pow256 ret, const unsigned char a[32])+{+    size_t i;++    if ((uptr_t)ret==(uptr_t)a)+        return;++    for (i = 0; i < 32; i++)+        ret[i] = a[i];+}++void blst_lendian_from_scalar(unsigned char ret[32], const pow256 a)+{+    size_t i;++    if ((uptr_t)ret==(uptr_t)a)+        return;++    for (i = 0; i < 32; i++)+        ret[i] = a[i];+}++void blst_fr_from_uint64(vec256 ret, const unsigned long long a[4])+{+    const union {+        long one;+        char little;+    } is_endian = { 1 };++    if (sizeof(limb_t) == 4 && !is_endian.little) {+        int i;+        for (i = 0; i < 4; i++) {+            unsigned long long limb = a[i];+            ret[2*i]   = (limb_t)limb;+            ret[2*i+1] = (limb_t)(limb >> 32);+        }+        a = (const unsigned long long *)ret;+    }+    mul_mont_sparse_256(ret, (const limb_t *)a, BLS12_381_rRR, BLS12_381_r, r0);+}++void blst_uint64_from_fr(unsigned long long ret[4], const vec256 a)+{+    const union {+        long one;+        char little;+    } is_endian = { 1 };++    if (sizeof(limb_t) == 8 || is_endian.little) {+        from_mont_256((limb_t *)ret, a, BLS12_381_r, r0);+    } else {+        vec256 out;+        int i;++        from_mont_256(out, a, BLS12_381_r, r0);+        for (i = 0; i < 4; i++)+            ret[i] = out[2*i] | ((unsigned long long)out[2*i+1] << 32);+        vec_zero(out, sizeof(out));+    }+}++int blst_scalar_from_le_bytes(pow256 out, const unsigned char *bytes, size_t n)+{+    struct { vec256 out, digit, radix; } t;+    limb_t ret;++    vec_zero(t.out, sizeof(t.out));+    vec_copy(t.radix, BLS12_381_rRR, sizeof(t.radix));++    while (n > 32) {+        limbs_from_le_bytes(t.digit, bytes, 32);+        from_mont_256(t.digit, t.digit, BLS12_381_r, r0);+        mul_mont_sparse_256(t.digit, t.digit, t.radix, BLS12_381_r, r0);+        add_mod_256(t.out, t.out, t.digit, BLS12_381_r);+        mul_mont_sparse_256(t.radix, t.radix, BLS12_381_rRR, BLS12_381_r, r0);+        bytes += 32;+        n -= 32;+    }++    vec_zero(t.digit, sizeof(t.digit));+    limbs_from_le_bytes(t.digit, bytes, n);+    from_mont_256(t.digit, t.digit, BLS12_381_r, r0);+    mul_mont_sparse_256(t.digit, t.digit, t.radix, BLS12_381_r, r0);+    add_mod_256(t.out, t.out, t.digit, BLS12_381_r);++    ret = vec_is_zero(t.out, sizeof(t.out));+    le_bytes_from_limbs(out, t.out, 32);+    vec_zero(t.out, 2*sizeof(t.out));++    return (int)(ret^1);+}++int blst_scalar_from_be_bytes(pow256 out, const unsigned char *bytes, size_t n)+{+    struct { vec256 out, digit, radix; } t;+    limb_t ret;++    vec_zero(t.out, sizeof(t.out));+    vec_copy(t.radix, BLS12_381_rRR, sizeof(t.radix));++    bytes += n;+    while (n > 32) {+        limbs_from_be_bytes(t.digit, bytes -= 32, 32);+        from_mont_256(t.digit, t.digit, BLS12_381_r, r0);+        mul_mont_sparse_256(t.digit, t.digit, t.radix, BLS12_381_r, r0);+        add_mod_256(t.out, t.out, t.digit, BLS12_381_r);+        mul_mont_sparse_256(t.radix, t.radix, BLS12_381_rRR, BLS12_381_r, r0);+        n -= 32;+    }++    vec_zero(t.digit, sizeof(t.digit));+    limbs_from_be_bytes(t.digit, bytes -= n, n);+    from_mont_256(t.digit, t.digit, BLS12_381_r, r0);+    mul_mont_sparse_256(t.digit, t.digit, t.radix, BLS12_381_r, r0);+    add_mod_256(t.out, t.out, t.digit, BLS12_381_r);++    ret = vec_is_zero(t.out, sizeof(t.out));+    le_bytes_from_limbs(out, t.out, 32);+    vec_zero(t.out, 2*sizeof(t.out));++    return (int)(ret^1);+}++/*+ * Test facilitator+ */+void blst_scalar_from_hexascii(pow256 ret, const char *hex)+{   bytes_from_hexascii(ret, sizeof(pow256), hex);   }++void blst_fr_from_hexascii(vec256 ret, const char *hex)+{+    limbs_from_hexascii(ret, sizeof(vec256), hex);+    mul_mont_sparse_256(ret, ret, BLS12_381_rRR, BLS12_381_r, r0);+}++void blst_fp_from_hexascii(vec384 ret, const char *hex)+{+    limbs_from_hexascii(ret, sizeof(vec384), hex);+    mul_fp(ret, ret, BLS12_381_RR);+}
+ c-source/src/fields.h view
@@ -0,0 +1,116 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */+#ifndef __BLS12_381_ASM_FIELDS_H__+#define __BLS12_381_ASM_FIELDS_H__++#include "vect.h"+#include "consts.h"++/*+ * BLS12-381-specifc Fp shortcuts to assembly.+ */+static inline void add_fp(vec384 ret, const vec384 a, const vec384 b)+{   add_mod_384(ret, a, b, BLS12_381_P);   }++static inline void sub_fp(vec384 ret, const vec384 a, const vec384 b)+{   sub_mod_384(ret, a, b, BLS12_381_P);   }++static inline void mul_by_3_fp(vec384 ret, const vec384 a)+{   mul_by_3_mod_384(ret, a, BLS12_381_P);   }++static inline void mul_by_8_fp(vec384 ret, const vec384 a)+{   mul_by_8_mod_384(ret, a, BLS12_381_P);   }++static inline void lshift_fp(vec384 ret, const vec384 a, size_t count)+{   lshift_mod_384(ret, a, count, BLS12_381_P);   }++static inline void rshift_fp(vec384 ret, const vec384 a, size_t count)+{   rshift_mod_384(ret, a, count, BLS12_381_P);   }++static inline void div_by_2_fp(vec384 ret, const vec384 a)+{   div_by_2_mod_384(ret, a, BLS12_381_P);   }++static inline void mul_fp(vec384 ret, const vec384 a, const vec384 b)+{   mul_mont_384(ret, a, b, BLS12_381_P, p0);   }++static inline void sqr_fp(vec384 ret, const vec384 a)+{   sqr_mont_384(ret, a, BLS12_381_P, p0);   }++static inline void cneg_fp(vec384 ret, const vec384 a, bool_t flag)+{   cneg_mod_384(ret, a, flag, BLS12_381_P);   }++static inline void from_fp(vec384 ret, const vec384 a)+{   from_mont_384(ret, a, BLS12_381_P, p0);   }++static inline void redc_fp(vec384 ret, const vec768 a)+{   redc_mont_384(ret, a, BLS12_381_P, p0);   }++/*+ * BLS12-381-specifc Fp2 shortcuts to assembly.+ */+static inline void add_fp2(vec384x ret, const vec384x a, const vec384x b)+{   add_mod_384x(ret, a, b, BLS12_381_P);   }++static inline void sub_fp2(vec384x ret, const vec384x a, const vec384x b)+{   sub_mod_384x(ret, a, b, BLS12_381_P);   }++static inline void mul_by_3_fp2(vec384x ret, const vec384x a)+{   mul_by_3_mod_384x(ret, a, BLS12_381_P);   }++static inline void mul_by_8_fp2(vec384x ret, const vec384x a)+{   mul_by_8_mod_384x(ret, a, BLS12_381_P);   }++static inline void lshift_fp2(vec384x ret, const vec384x a, size_t count)+{+    lshift_mod_384(ret[0], a[0], count, BLS12_381_P);+    lshift_mod_384(ret[1], a[1], count, BLS12_381_P);+}++static inline void mul_fp2(vec384x ret, const vec384x a, const vec384x b)+{   mul_mont_384x(ret, a, b, BLS12_381_P, p0);   }++static inline void sqr_fp2(vec384x ret, const vec384x a)+{   sqr_mont_384x(ret, a, BLS12_381_P, p0);   }++static inline void cneg_fp2(vec384x ret, const vec384x a, bool_t flag)+{+    cneg_mod_384(ret[0], a[0], flag, BLS12_381_P);+    cneg_mod_384(ret[1], a[1], flag, BLS12_381_P);+}++#define vec_load_global vec_copy++static void reciprocal_fp(vec384 out, const vec384 inp);+static void flt_reciprocal_fp(vec384 out, const vec384 inp);+static bool_t recip_sqrt_fp(vec384 out, const vec384 inp);+static bool_t sqrt_fp(vec384 out, const vec384 inp);++static void reciprocal_fp2(vec384x out, const vec384x inp);+static void flt_reciprocal_fp2(vec384x out, const vec384x inp);+static bool_t recip_sqrt_fp2(vec384x out, const vec384x inp,+                             const vec384x recip_ZZZ, const vec384x magic_ZZZ);+static bool_t sqrt_fp2(vec384x out, const vec384x inp);+static bool_t sqrt_align_fp2(vec384x out, const vec384x ret,+                             const vec384x sqrt, const vec384x inp);++typedef vec384x   vec384fp2;+typedef vec384fp2 vec384fp6[3];+typedef vec384fp6 vec384fp12[2];++static void sqr_fp12(vec384fp12 ret, const vec384fp12 a);+static void cyclotomic_sqr_fp12(vec384fp12 ret, const vec384fp12 a);+static void mul_fp12(vec384fp12 ret, const vec384fp12 a, const vec384fp12 b);+static void mul_by_xy00z0_fp12(vec384fp12 ret, const vec384fp12 a,+                                               const vec384fp6 xy00z0);+static void conjugate_fp12(vec384fp12 a);+static void inverse_fp12(vec384fp12 ret, const vec384fp12 a);+/* caveat lector! |n| has to be non-zero and not more than 3! */+static void frobenius_map_fp12(vec384fp12 ret, const vec384fp12 a, size_t n);++#define neg_fp(r,a) cneg_fp((r),(a),1)+#define neg_fp2(r,a) cneg_fp2((r),(a),1)++#endif /* __BLS12_381_ASM_FIELDS_H__ */
+ c-source/src/fp12_tower.c view
@@ -0,0 +1,789 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */++#include "fields.h"++/*+ * Fp2  = Fp[u]  / (u^2 + 1)+ * Fp6  = Fp2[v] / (v^3 - u - 1)+ * Fp12 = Fp6[w] / (w^2 - v)+ */++static inline void mul_by_u_plus_1_fp2(vec384x ret, const vec384x a)+{   mul_by_1_plus_i_mod_384x(ret, a, BLS12_381_P);   }++#if 1 && !defined(__BLST_NO_ASM__)+#define __FP2x2__+/*+ * Fp2x2 is a "widened" version of Fp2, which allows to consolidate+ * reductions from several multiplications. In other words instead of+ * "mul_redc-mul_redc-add" we get "mul-mul-add-redc," where latter+ * addition is double-width... To be more specific this gives ~7-10%+ * faster pairing depending on platform...+ */+typedef vec768 vec768x[2];++static inline void add_fp2x2(vec768x ret, const vec768x a, const vec768x b)+{+    add_mod_384x384(ret[0], a[0], b[0], BLS12_381_P);+    add_mod_384x384(ret[1], a[1], b[1], BLS12_381_P);+}++static inline void sub_fp2x2(vec768x ret, const vec768x a, const vec768x b)+{+    sub_mod_384x384(ret[0], a[0], b[0], BLS12_381_P);+    sub_mod_384x384(ret[1], a[1], b[1], BLS12_381_P);+}++static inline void mul_by_u_plus_1_fp2x2(vec768x ret, const vec768x a)+{+    /* caveat lector! |ret| may not be same as |a| */+    sub_mod_384x384(ret[0], a[0], a[1], BLS12_381_P);+    add_mod_384x384(ret[1], a[0], a[1], BLS12_381_P);+}++static inline void redc_fp2x2(vec384x ret, const vec768x a)+{+    redc_mont_384(ret[0], a[0], BLS12_381_P, p0);+    redc_mont_384(ret[1], a[1], BLS12_381_P, p0);+}++static void mul_fp2x2(vec768x ret, const vec384x a, const vec384x b)+{+#if 1+    mul_382x(ret, a, b, BLS12_381_P);   /* +~6% in Miller loop */+#else+    union { vec384 x[2]; vec768 x2; } t;++    add_mod_384(t.x[0], a[0], a[1], BLS12_381_P);+    add_mod_384(t.x[1], b[0], b[1], BLS12_381_P);+    mul_384(ret[1], t.x[0], t.x[1]);++    mul_384(ret[0], a[0], b[0]);+    mul_384(t.x2,   a[1], b[1]);++    sub_mod_384x384(ret[1], ret[1], ret[0], BLS12_381_P);+    sub_mod_384x384(ret[1], ret[1], t.x2, BLS12_381_P);++    sub_mod_384x384(ret[0], ret[0], t.x2, BLS12_381_P);+#endif+}++static void sqr_fp2x2(vec768x ret, const vec384x a)+{+#if 1+    sqr_382x(ret, a, BLS12_381_P);      /* +~5% in final exponentiation */+#else+    vec384 t0, t1;++    add_mod_384(t0, a[0], a[1], BLS12_381_P);+    sub_mod_384(t1, a[0], a[1], BLS12_381_P);++    mul_384(ret[1], a[0], a[1]);+    add_mod_384x384(ret[1], ret[1], ret[1], BLS12_381_P);++    mul_384(ret[0], t0, t1);+#endif+}+#endif  /* __FP2x2__ */++/*+ * Fp6 extension+ */+#if defined(__FP2x2__)  /* ~10-13% improvement for mul_fp12 and sqr_fp12 */+typedef vec768x vec768fp6[3];++static inline void sub_fp6x2(vec768fp6 ret, const vec768fp6 a,+                                            const vec768fp6 b)+{+    sub_fp2x2(ret[0], a[0], b[0]);+    sub_fp2x2(ret[1], a[1], b[1]);+    sub_fp2x2(ret[2], a[2], b[2]);+}++static void mul_fp6x2(vec768fp6 ret, const vec384fp6 a, const vec384fp6 b)+{+    vec768x t0, t1, t2;+    vec384x aa, bb;++    mul_fp2x2(t0, a[0], b[0]);+    mul_fp2x2(t1, a[1], b[1]);+    mul_fp2x2(t2, a[2], b[2]);++    /* ret[0] = ((a1 + a2)*(b1 + b2) - a1*b1 - a2*b2)*(u+1) + a0*b0+              = (a1*b2 + a2*b1)*(u+1) + a0*b0 */+    add_fp2(aa, a[1], a[2]);+    add_fp2(bb, b[1], b[2]);+    mul_fp2x2(ret[0], aa, bb);+    sub_fp2x2(ret[0], ret[0], t1);+    sub_fp2x2(ret[0], ret[0], t2);+    mul_by_u_plus_1_fp2x2(ret[1], ret[0]);  /* borrow ret[1] for a moment */+    add_fp2x2(ret[0], ret[1], t0);++    /* ret[1] = (a0 + a1)*(b0 + b1) - a0*b0 - a1*b1 + a2*b2*(u+1)+              = a0*b1 + a1*b0 + a2*b2*(u+1) */+    add_fp2(aa, a[0], a[1]);+    add_fp2(bb, b[0], b[1]);+    mul_fp2x2(ret[1], aa, bb);+    sub_fp2x2(ret[1], ret[1], t0);+    sub_fp2x2(ret[1], ret[1], t1);+    mul_by_u_plus_1_fp2x2(ret[2], t2);      /* borrow ret[2] for a moment */+    add_fp2x2(ret[1], ret[1], ret[2]);++    /* ret[2] = (a0 + a2)*(b0 + b2) - a0*b0 - a2*b2 + a1*b1+              = a0*b2 + a2*b0 + a1*b1 */+    add_fp2(aa, a[0], a[2]);+    add_fp2(bb, b[0], b[2]);+    mul_fp2x2(ret[2], aa, bb);+    sub_fp2x2(ret[2], ret[2], t0);+    sub_fp2x2(ret[2], ret[2], t2);+    add_fp2x2(ret[2], ret[2], t1);+}++static inline void redc_fp6x2(vec384fp6 ret, const vec768fp6 a)+{+    redc_fp2x2(ret[0], a[0]);+    redc_fp2x2(ret[1], a[1]);+    redc_fp2x2(ret[2], a[2]);+}++static void mul_fp6(vec384fp6 ret, const vec384fp6 a, const vec384fp6 b)+{+    vec768fp6 r;++    mul_fp6x2(r, a, b);+    redc_fp6x2(ret, r); /* narrow to normal width */+}++static void sqr_fp6(vec384fp6 ret, const vec384fp6 a)+{+    vec768x s0, m01, m12, s2, rx;++    sqr_fp2x2(s0, a[0]);++    mul_fp2x2(m01, a[0], a[1]);+    add_fp2x2(m01, m01, m01);++    mul_fp2x2(m12, a[1], a[2]);+    add_fp2x2(m12, m12, m12);++    sqr_fp2x2(s2, a[2]);++    /* ret[2] = (a0 + a1 + a2)^2 - a0^2 - a2^2 - 2*(a0*a1) - 2*(a1*a2)+              = a1^2 + 2*(a0*a2) */+    add_fp2(ret[2], a[2], a[1]);+    add_fp2(ret[2], ret[2], a[0]);+    sqr_fp2x2(rx, ret[2]);+    sub_fp2x2(rx, rx, s0);+    sub_fp2x2(rx, rx, s2);+    sub_fp2x2(rx, rx, m01);+    sub_fp2x2(rx, rx, m12);+    redc_fp2x2(ret[2], rx);++    /* ret[0] = a0^2 + 2*(a1*a2)*(u+1) */+    mul_by_u_plus_1_fp2x2(rx, m12);+    add_fp2x2(rx, rx, s0);+    redc_fp2x2(ret[0], rx);++    /* ret[1] = a2^2*(u+1) + 2*(a0*a1) */+    mul_by_u_plus_1_fp2x2(rx, s2);+    add_fp2x2(rx, rx, m01);+    redc_fp2x2(ret[1], rx);+}+#else+static void mul_fp6(vec384fp6 ret, const vec384fp6 a, const vec384fp6 b)+{+    vec384x t0, t1, t2, t3, t4, t5;++    mul_fp2(t0, a[0], b[0]);+    mul_fp2(t1, a[1], b[1]);+    mul_fp2(t2, a[2], b[2]);++    /* ret[0] = ((a1 + a2)*(b1 + b2) - a1*b1 - a2*b2)*(u+1) + a0*b0+              = (a1*b2 + a2*b1)*(u+1) + a0*b0 */+    add_fp2(t4, a[1], a[2]);+    add_fp2(t5, b[1], b[2]);+    mul_fp2(t3, t4, t5);+    sub_fp2(t3, t3, t1);+    sub_fp2(t3, t3, t2);+    mul_by_u_plus_1_fp2(t3, t3);+    /* add_fp2(ret[0], t3, t0); considering possible aliasing... */++    /* ret[1] = (a0 + a1)*(b0 + b1) - a0*b0 - a1*b1 + a2*b2*(u+1)+              = a0*b1 + a1*b0 + a2*b2*(u+1) */+    add_fp2(t4, a[0], a[1]);+    add_fp2(t5, b[0], b[1]);+    mul_fp2(ret[1], t4, t5);+    sub_fp2(ret[1], ret[1], t0);+    sub_fp2(ret[1], ret[1], t1);+    mul_by_u_plus_1_fp2(t4, t2);+    add_fp2(ret[1], ret[1], t4);++    /* ret[2] = (a0 + a2)*(b0 + b2) - a0*b0 - a2*b2 + a1*b1+              = a0*b2 + a2*b0 + a1*b1 */+    add_fp2(t4, a[0], a[2]);+    add_fp2(t5, b[0], b[2]);+    mul_fp2(ret[2], t4, t5);+    sub_fp2(ret[2], ret[2], t0);+    sub_fp2(ret[2], ret[2], t2);+    add_fp2(ret[2], ret[2], t1);++    add_fp2(ret[0], t3, t0);    /* ... moved from above */+}++static void sqr_fp6(vec384fp6 ret, const vec384fp6 a)+{+    vec384x s0, m01, m12, s2;++    sqr_fp2(s0, a[0]);++    mul_fp2(m01, a[0], a[1]);+    add_fp2(m01, m01, m01);++    mul_fp2(m12, a[1], a[2]);+    add_fp2(m12, m12, m12);++    sqr_fp2(s2, a[2]);++    /* ret[2] = (a0 + a1 + a2)^2 - a0^2 - a2^2 - 2*(a0*a1) - 2*(a1*a2)+              = a1^2 + 2*(a0*a2) */+    add_fp2(ret[2], a[2], a[1]);+    add_fp2(ret[2], ret[2], a[0]);+    sqr_fp2(ret[2], ret[2]);+    sub_fp2(ret[2], ret[2], s0);+    sub_fp2(ret[2], ret[2], s2);+    sub_fp2(ret[2], ret[2], m01);+    sub_fp2(ret[2], ret[2], m12);++    /* ret[0] = a0^2 + 2*(a1*a2)*(u+1) */+    mul_by_u_plus_1_fp2(ret[0], m12);+    add_fp2(ret[0], ret[0], s0);++    /* ret[1] = a2^2*(u+1) + 2*(a0*a1) */+    mul_by_u_plus_1_fp2(ret[1], s2);+    add_fp2(ret[1], ret[1], m01);+}+#endif++static void add_fp6(vec384fp6 ret, const vec384fp6 a, const vec384fp6 b)+{+    add_fp2(ret[0], a[0], b[0]);+    add_fp2(ret[1], a[1], b[1]);+    add_fp2(ret[2], a[2], b[2]);+}++static void sub_fp6(vec384fp6 ret, const vec384fp6 a, const vec384fp6 b)+{+    sub_fp2(ret[0], a[0], b[0]);+    sub_fp2(ret[1], a[1], b[1]);+    sub_fp2(ret[2], a[2], b[2]);+}++static void neg_fp6(vec384fp6 ret, const vec384fp6 a)+{+    neg_fp2(ret[0], a[0]);+    neg_fp2(ret[1], a[1]);+    neg_fp2(ret[2], a[2]);+}++#if 0+#define mul_by_v_fp6 mul_by_v_fp6+static void mul_by_v_fp6(vec384fp6 ret, const vec384fp6 a)+{+    vec384x t;++    mul_by_u_plus_1_fp2(t, a[2]);+    vec_copy(ret[2], a[1], sizeof(a[1]));+    vec_copy(ret[1], a[0], sizeof(a[0]));+    vec_copy(ret[0], t, sizeof(t));+}+#endif++/*+ * Fp12 extension+ */+#if defined(__FP2x2__)+static void mul_fp12(vec384fp12 ret, const vec384fp12 a, const vec384fp12 b)+{+    vec768fp6 t0, t1, rx;+    vec384fp6 t2;++    mul_fp6x2(t0, a[0], b[0]);+    mul_fp6x2(t1, a[1], b[1]);++    /* ret[1] = (a0 + a1)*(b0 + b1) - a0*b0 - a1*b1+              = a0*b1 + a1*b0 */+    add_fp6(t2, a[0], a[1]);+    add_fp6(ret[1], b[0], b[1]);+    mul_fp6x2(rx, ret[1], t2);+    sub_fp6x2(rx, rx, t0);+    sub_fp6x2(rx, rx, t1);+    redc_fp6x2(ret[1], rx);++    /* ret[0] = a0*b0 + a1*b1*v */+    mul_by_u_plus_1_fp2x2(rx[0], t1[2]);+    add_fp2x2(rx[0], t0[0], rx[0]);+    add_fp2x2(rx[1], t0[1], t1[0]);+    add_fp2x2(rx[2], t0[2], t1[1]);+    redc_fp6x2(ret[0], rx);+}++static inline void mul_by_0y0_fp6x2(vec768fp6 ret, const vec384fp6 a,+                                                   const vec384fp2 b)+{+    mul_fp2x2(ret[1], a[2], b);     /* borrow ret[1] for a moment */+    mul_by_u_plus_1_fp2x2(ret[0], ret[1]);+    mul_fp2x2(ret[1], a[0], b);+    mul_fp2x2(ret[2], a[1], b);+}++static void mul_by_xy0_fp6x2(vec768fp6 ret, const vec384fp6 a,+                                            const vec384fp6 b)+{+    vec768x t0, t1;+    vec384x aa, bb;++    mul_fp2x2(t0, a[0], b[0]);+    mul_fp2x2(t1, a[1], b[1]);++    /* ret[0] = ((a1 + a2)*(b1 + 0) - a1*b1 - a2*0)*(u+1) + a0*b0+              = (a1*0 + a2*b1)*(u+1) + a0*b0 */+    mul_fp2x2(ret[1], a[2], b[1]);  /* borrow ret[1] for a moment */+    mul_by_u_plus_1_fp2x2(ret[0], ret[1]);+    add_fp2x2(ret[0], ret[0], t0);++    /* ret[1] = (a0 + a1)*(b0 + b1) - a0*b0 - a1*b1 + a2*0*(u+1)+              = a0*b1 + a1*b0 + a2*0*(u+1) */+    add_fp2(aa, a[0], a[1]);+    add_fp2(bb, b[0], b[1]);+    mul_fp2x2(ret[1], aa, bb);+    sub_fp2x2(ret[1], ret[1], t0);+    sub_fp2x2(ret[1], ret[1], t1);++    /* ret[2] = (a0 + a2)*(b0 + 0) - a0*b0 - a2*0 + a1*b1+              = a0*0 + a2*b0 + a1*b1 */+    mul_fp2x2(ret[2], a[2], b[0]);+    add_fp2x2(ret[2], ret[2], t1);+}++static void mul_by_xy00z0_fp12(vec384fp12 ret, const vec384fp12 a,+                                               const vec384fp6 xy00z0)+{+    vec768fp6 t0, t1, rr;+    vec384fp6 t2;++    mul_by_xy0_fp6x2(t0, a[0], xy00z0);+    mul_by_0y0_fp6x2(t1, a[1], xy00z0[2]);++    /* ret[1] = (a0 + a1)*(b0 + b1) - a0*b0 - a1*b1+              = a0*b1 + a1*b0 */+    vec_copy(t2[0], xy00z0[0], sizeof(t2[0]));+    add_fp2(t2[1], xy00z0[1], xy00z0[2]);+    add_fp6(ret[1], a[0], a[1]);+    mul_by_xy0_fp6x2(rr, ret[1], t2);+    sub_fp6x2(rr, rr, t0);+    sub_fp6x2(rr, rr, t1);+    redc_fp6x2(ret[1], rr);++    /* ret[0] = a0*b0 + a1*b1*v */+    mul_by_u_plus_1_fp2x2(rr[0], t1[2]);+    add_fp2x2(rr[0], t0[0], rr[0]);+    add_fp2x2(rr[1], t0[1], t1[0]);+    add_fp2x2(rr[2], t0[2], t1[1]);+    redc_fp6x2(ret[0], rr);+}+#else+static void mul_fp12(vec384fp12 ret, const vec384fp12 a, const vec384fp12 b)+{+    vec384fp6 t0, t1, t2;++    mul_fp6(t0, a[0], b[0]);+    mul_fp6(t1, a[1], b[1]);++    /* ret[1] = (a0 + a1)*(b0 + b1) - a0*b0 - a1*b1+              = a0*b1 + a1*b0 */+    add_fp6(t2, a[0], a[1]);+    add_fp6(ret[1], b[0], b[1]);+    mul_fp6(ret[1], ret[1], t2);+    sub_fp6(ret[1], ret[1], t0);+    sub_fp6(ret[1], ret[1], t1);++    /* ret[0] = a0*b0 + a1*b1*v */+#ifdef mul_by_v_fp6+    mul_by_v_fp6(t1, t1);+    add_fp6(ret[0], t0, t1);+#else+    mul_by_u_plus_1_fp2(t1[2], t1[2]);+    add_fp2(ret[0][0], t0[0], t1[2]);+    add_fp2(ret[0][1], t0[1], t1[0]);+    add_fp2(ret[0][2], t0[2], t1[1]);+#endif+}++static inline void mul_by_0y0_fp6(vec384fp6 ret, const vec384fp6 a,+                                                 const vec384fp2 b)+{+    vec384x t;++    mul_fp2(t,      a[2], b);+    mul_fp2(ret[2], a[1], b);+    mul_fp2(ret[1], a[0], b);+    mul_by_u_plus_1_fp2(ret[0], t);+}++static void mul_by_xy0_fp6(vec384fp6 ret, const vec384fp6 a, const vec384fp6 b)+{+    vec384x t0, t1, /*t2,*/ t3, t4, t5;++    mul_fp2(t0, a[0], b[0]);+    mul_fp2(t1, a[1], b[1]);++    /* ret[0] = ((a1 + a2)*(b1 + 0) - a1*b1 - a2*0)*(u+1) + a0*b0+              = (a1*0 + a2*b1)*(u+1) + a0*b0 */+    mul_fp2(t3, a[2], b[1]);+    mul_by_u_plus_1_fp2(t3, t3);+    /* add_fp2(ret[0], t3, t0); considering possible aliasing... */++    /* ret[1] = (a0 + a1)*(b0 + b1) - a0*b0 - a1*b1 + a2*0*(u+1)+              = a0*b1 + a1*b0 + a2*0*(u+1) */+    add_fp2(t4, a[0], a[1]);+    add_fp2(t5, b[0], b[1]);+    mul_fp2(ret[1], t4, t5);+    sub_fp2(ret[1], ret[1], t0);+    sub_fp2(ret[1], ret[1], t1);++    /* ret[2] = (a0 + a2)*(b0 + 0) - a0*b0 - a2*0 + a1*b1+              = a0*0 + a2*b0 + a1*b1 */+    mul_fp2(ret[2], a[2], b[0]);+    add_fp2(ret[2], ret[2], t1);++    add_fp2(ret[0], t3, t0);    /* ... moved from above */+}++static void mul_by_xy00z0_fp12(vec384fp12 ret, const vec384fp12 a,+                                               const vec384fp6 xy00z0)+{+    vec384fp6 t0, t1, t2;++    mul_by_xy0_fp6(t0, a[0], xy00z0);+    mul_by_0y0_fp6(t1, a[1], xy00z0[2]);++    /* ret[1] = (a0 + a1)*(b0 + b1) - a0*b0 - a1*b1+              = a0*b1 + a1*b0 */+    vec_copy(t2[0], xy00z0[0], sizeof(t2[0]));+    add_fp2(t2[1], xy00z0[1], xy00z0[2]);+    add_fp6(ret[1], a[0], a[1]);+    mul_by_xy0_fp6(ret[1], ret[1], t2);+    sub_fp6(ret[1], ret[1], t0);+    sub_fp6(ret[1], ret[1], t1);++    /* ret[0] = a0*b0 + a1*b1*v */+#ifdef mul_by_v_fp6+    mul_by_v_fp6(t1, t1);+    add_fp6(ret[0], t0, t1);+#else+    mul_by_u_plus_1_fp2(t1[2], t1[2]);+    add_fp2(ret[0][0], t0[0], t1[2]);+    add_fp2(ret[0][1], t0[1], t1[0]);+    add_fp2(ret[0][2], t0[2], t1[1]);+#endif+}+#endif++static void sqr_fp12(vec384fp12 ret, const vec384fp12 a)+{+    vec384fp6 t0, t1;++    add_fp6(t0, a[0], a[1]);+#ifdef mul_by_v_fp6+    mul_by_v_fp6(t1, a[1]);+    add_fp6(t1, a[0], t1);+#else+    mul_by_u_plus_1_fp2(t1[2], a[1][2]);+    add_fp2(t1[0], a[0][0], t1[2]);+    add_fp2(t1[1], a[0][1], a[1][0]);+    add_fp2(t1[2], a[0][2], a[1][1]);+#endif+    mul_fp6(t0, t0, t1);+    mul_fp6(t1, a[0], a[1]);++    /* ret[1] = 2*(a0*a1) */+    add_fp6(ret[1], t1, t1);++    /* ret[0] = (a0 + a1)*(a0 + a1*v) - a0*a1 - a0*a1*v+              = a0^2 + a1^2*v */+    sub_fp6(ret[0], t0, t1);+#ifdef mul_by_v_fp6+    mul_by_v_fp6(t1, t1);+    sub_fp6(ret[0], ret[0], t1);+#else+    mul_by_u_plus_1_fp2(t1[2], t1[2]);+    sub_fp2(ret[0][0], ret[0][0], t1[2]);+    sub_fp2(ret[0][1], ret[0][1], t1[0]);+    sub_fp2(ret[0][2], ret[0][2], t1[1]);+#endif+}++static void conjugate_fp12(vec384fp12 a)+{   neg_fp6(a[1], a[1]);   }++static void inverse_fp6(vec384fp6 ret, const vec384fp6 a)+{+    vec384x c0, c1, c2, t0, t1;++    /* c0 = a0^2 - (a1*a2)*(u+1) */+    sqr_fp2(c0, a[0]);+    mul_fp2(t0, a[1], a[2]);+    mul_by_u_plus_1_fp2(t0, t0);+    sub_fp2(c0, c0, t0);++    /* c1 = a2^2*(u+1) - (a0*a1) */+    sqr_fp2(c1, a[2]);+    mul_by_u_plus_1_fp2(c1, c1);+    mul_fp2(t0, a[0], a[1]);+    sub_fp2(c1, c1, t0);+ +    /* c2 = a1^2 - a0*a2 */+    sqr_fp2(c2, a[1]);+    mul_fp2(t0, a[0], a[2]);+    sub_fp2(c2, c2, t0);++    /* (a2*c1 + a1*c2)*(u+1) + a0*c0 */+    mul_fp2(t0, c1, a[2]);+    mul_fp2(t1, c2, a[1]);+    add_fp2(t0, t0, t1);+    mul_by_u_plus_1_fp2(t0, t0);+    mul_fp2(t1, c0, a[0]);+    add_fp2(t0, t0, t1);++    reciprocal_fp2(t1, t0);++    mul_fp2(ret[0], c0, t1);+    mul_fp2(ret[1], c1, t1);+    mul_fp2(ret[2], c2, t1);+}++static void inverse_fp12(vec384fp12 ret, const vec384fp12 a)+{+    vec384fp6 t0, t1;++    sqr_fp6(t0, a[0]);+    sqr_fp6(t1, a[1]);+#ifdef mul_by_v_fp6+    mul_by_v_fp6(t1, t1);+    sub_fp6(t0, t0, t1);+#else+    mul_by_u_plus_1_fp2(t1[2], t1[2]);+    sub_fp2(t0[0], t0[0], t1[2]);+    sub_fp2(t0[1], t0[1], t1[0]);+    sub_fp2(t0[2], t0[2], t1[1]);+#endif++    inverse_fp6(t1, t0);++    mul_fp6(ret[0], a[0], t1);+    mul_fp6(ret[1], a[1], t1);+    neg_fp6(ret[1], ret[1]);+}++typedef vec384x vec384fp4[2];++#if defined(__FP2x2__)+static void sqr_fp4(vec384fp4 ret, const vec384x a0, const vec384x a1)+{+    vec768x t0, t1, t2;++    sqr_fp2x2(t0, a0);+    sqr_fp2x2(t1, a1);+    add_fp2(ret[1], a0, a1);++    mul_by_u_plus_1_fp2x2(t2, t1);+    add_fp2x2(t2, t2, t0);+    redc_fp2x2(ret[0], t2);++    sqr_fp2x2(t2, ret[1]);+    sub_fp2x2(t2, t2, t0);+    sub_fp2x2(t2, t2, t1);+    redc_fp2x2(ret[1], t2);+}+#else+static void sqr_fp4(vec384fp4 ret, const vec384x a0, const vec384x a1)+{+    vec384x t0, t1;++    sqr_fp2(t0, a0);+    sqr_fp2(t1, a1);+    add_fp2(ret[1], a0, a1);++    mul_by_u_plus_1_fp2(ret[0], t1);+    add_fp2(ret[0], ret[0], t0);++    sqr_fp2(ret[1], ret[1]);+    sub_fp2(ret[1], ret[1], t0);+    sub_fp2(ret[1], ret[1], t1);+}+#endif++static void cyclotomic_sqr_fp12(vec384fp12 ret, const vec384fp12 a)+{+    vec384fp4 t0, t1, t2;++    sqr_fp4(t0, a[0][0], a[1][1]);+    sqr_fp4(t1, a[1][0], a[0][2]);+    sqr_fp4(t2, a[0][1], a[1][2]);++    sub_fp2(ret[0][0], t0[0],     a[0][0]);+    add_fp2(ret[0][0], ret[0][0], ret[0][0]);+    add_fp2(ret[0][0], ret[0][0], t0[0]);++    sub_fp2(ret[0][1], t1[0],     a[0][1]);+    add_fp2(ret[0][1], ret[0][1], ret[0][1]);+    add_fp2(ret[0][1], ret[0][1], t1[0]);++    sub_fp2(ret[0][2], t2[0],     a[0][2]);+    add_fp2(ret[0][2], ret[0][2], ret[0][2]);+    add_fp2(ret[0][2], ret[0][2], t2[0]);++    mul_by_u_plus_1_fp2(t2[1], t2[1]);+    add_fp2(ret[1][0], t2[1],     a[1][0]);+    add_fp2(ret[1][0], ret[1][0], ret[1][0]);+    add_fp2(ret[1][0], ret[1][0], t2[1]);++    add_fp2(ret[1][1], t0[1],     a[1][1]);+    add_fp2(ret[1][1], ret[1][1], ret[1][1]);+    add_fp2(ret[1][1], ret[1][1], t0[1]);++    add_fp2(ret[1][2], t1[1],     a[1][2]);+    add_fp2(ret[1][2], ret[1][2], ret[1][2]);+    add_fp2(ret[1][2], ret[1][2], t1[1]);+}++/*+ * caveat lector! |n| has to be non-zero and not more than 3!+ */+static inline void frobenius_map_fp2(vec384x ret, const vec384x a, size_t n)+{+    vec_copy(ret[0], a[0], sizeof(ret[0]));+    cneg_fp(ret[1], a[1], n & 1);+}++static void frobenius_map_fp6(vec384fp6 ret, const vec384fp6 a, size_t n)+{+    static const vec384x coeffs1[] = {  /* (u + 1)^((P^n - 1) / 3) */+      { { 0 },+        { TO_LIMB_T(0xcd03c9e48671f071), TO_LIMB_T(0x5dab22461fcda5d2),+          TO_LIMB_T(0x587042afd3851b95), TO_LIMB_T(0x8eb60ebe01bacb9e),+          TO_LIMB_T(0x03f97d6e83d050d2), TO_LIMB_T(0x18f0206554638741) } },+      { { TO_LIMB_T(0x30f1361b798a64e8), TO_LIMB_T(0xf3b8ddab7ece5a2a),+          TO_LIMB_T(0x16a8ca3ac61577f7), TO_LIMB_T(0xc26a2ff874fd029b),+          TO_LIMB_T(0x3636b76660701c6e), TO_LIMB_T(0x051ba4ab241b6160) } },+      { { 0 }, { ONE_MONT_P } }+    };+    static const vec384 coeffs2[] = {  /* (u + 1)^((2P^n - 2) / 3) */+      {   TO_LIMB_T(0x890dc9e4867545c3), TO_LIMB_T(0x2af322533285a5d5),+          TO_LIMB_T(0x50880866309b7e2c), TO_LIMB_T(0xa20d1b8c7e881024),+          TO_LIMB_T(0x14e4f04fe2db9068), TO_LIMB_T(0x14e56d3f1564853a)   },+      {   TO_LIMB_T(0xcd03c9e48671f071), TO_LIMB_T(0x5dab22461fcda5d2),+          TO_LIMB_T(0x587042afd3851b95), TO_LIMB_T(0x8eb60ebe01bacb9e),+          TO_LIMB_T(0x03f97d6e83d050d2), TO_LIMB_T(0x18f0206554638741)   },+      {   TO_LIMB_T(0x43f5fffffffcaaae), TO_LIMB_T(0x32b7fff2ed47fffd),+          TO_LIMB_T(0x07e83a49a2e99d69), TO_LIMB_T(0xeca8f3318332bb7a),+          TO_LIMB_T(0xef148d1ea0f4c069), TO_LIMB_T(0x040ab3263eff0206)   }+    };++    frobenius_map_fp2(ret[0], a[0], n);+    frobenius_map_fp2(ret[1], a[1], n);+    frobenius_map_fp2(ret[2], a[2], n);+    --n;    /* implied ONE_MONT_P at index 0 */+    mul_fp2(ret[1], ret[1], coeffs1[n]);+    mul_fp(ret[2][0], ret[2][0], coeffs2[n]);+    mul_fp(ret[2][1], ret[2][1], coeffs2[n]);+}++static void frobenius_map_fp12(vec384fp12 ret, const vec384fp12 a, size_t n)+{+    static const vec384x coeffs[] = {  /* (u + 1)^((P^n - 1) / 6) */+      { { TO_LIMB_T(0x07089552b319d465), TO_LIMB_T(0xc6695f92b50a8313),+          TO_LIMB_T(0x97e83cccd117228f), TO_LIMB_T(0xa35baecab2dc29ee),+          TO_LIMB_T(0x1ce393ea5daace4d), TO_LIMB_T(0x08f2220fb0fb66eb) },+	{ TO_LIMB_T(0xb2f66aad4ce5d646), TO_LIMB_T(0x5842a06bfc497cec),+          TO_LIMB_T(0xcf4895d42599d394), TO_LIMB_T(0xc11b9cba40a8e8d0),+          TO_LIMB_T(0x2e3813cbe5a0de89), TO_LIMB_T(0x110eefda88847faf) } },+      { { TO_LIMB_T(0xecfb361b798dba3a), TO_LIMB_T(0xc100ddb891865a2c),+          TO_LIMB_T(0x0ec08ff1232bda8e), TO_LIMB_T(0xd5c13cc6f1ca4721),+          TO_LIMB_T(0x47222a47bf7b5c04), TO_LIMB_T(0x0110f184e51c5f59) } },+      { { TO_LIMB_T(0x3e2f585da55c9ad1), TO_LIMB_T(0x4294213d86c18183),+          TO_LIMB_T(0x382844c88b623732), TO_LIMB_T(0x92ad2afd19103e18),+          TO_LIMB_T(0x1d794e4fac7cf0b9), TO_LIMB_T(0x0bd592fc7d825ec8) },+	{ TO_LIMB_T(0x7bcfa7a25aa30fda), TO_LIMB_T(0xdc17dec12a927e7c),+          TO_LIMB_T(0x2f088dd86b4ebef1), TO_LIMB_T(0xd1ca2087da74d4a7),+          TO_LIMB_T(0x2da2596696cebc1d), TO_LIMB_T(0x0e2b7eedbbfd87d2) } },+    };++    frobenius_map_fp6(ret[0], a[0], n);+    frobenius_map_fp6(ret[1], a[1], n);+    --n;    /* implied ONE_MONT_P at index 0 */+    mul_fp2(ret[1][0], ret[1][0], coeffs[n]);+    mul_fp2(ret[1][1], ret[1][1], coeffs[n]);+    mul_fp2(ret[1][2], ret[1][2], coeffs[n]);+}+++/*+ * BLS12-381-specifc Fp12 shortcuts.+ */+void blst_fp12_sqr(vec384fp12 ret, const vec384fp12 a)+{   sqr_fp12(ret, a);   }++void blst_fp12_cyclotomic_sqr(vec384fp12 ret, const vec384fp12 a)+{   cyclotomic_sqr_fp12(ret, a);   }++void blst_fp12_mul(vec384fp12 ret, const vec384fp12 a, const vec384fp12 b)+{   mul_fp12(ret, a, b);   }++void blst_fp12_mul_by_xy00z0(vec384fp12 ret, const vec384fp12 a,+                                             const vec384fp6 xy00z0)+{   mul_by_xy00z0_fp12(ret, a, xy00z0);   }++void blst_fp12_conjugate(vec384fp12 a)+{   conjugate_fp12(a);   }++void blst_fp12_inverse(vec384fp12 ret, const vec384fp12 a)+{   inverse_fp12(ret, a);   }++/* caveat lector! |n| has to be non-zero and not more than 3! */+void blst_fp12_frobenius_map(vec384fp12 ret, const vec384fp12 a, size_t n)+{   frobenius_map_fp12(ret, a, n);   }++int blst_fp12_is_equal(const vec384fp12 a, const vec384fp12 b)+{   return (int)vec_is_equal(a, b, sizeof(vec384fp12));   }++int blst_fp12_is_one(const vec384fp12 a)+{+    return (int)(vec_is_equal(a[0][0], BLS12_381_Rx.p2, sizeof(a[0][0])) &+                 vec_is_zero(a[0][1], sizeof(vec384fp12) - sizeof(a[0][0])));+}++const vec384fp12 *blst_fp12_one(void)+{   return (const vec384fp12 *)BLS12_381_Rx.p12;   }++void blst_bendian_from_fp12(unsigned char ret[48*12], const vec384fp12 a)+{+    size_t i, j;+    vec384 out;++    for (i = 0; i < 3; i++) {+        for (j = 0; j < 2; j++) {+            from_fp(out, a[j][i][0]);+            be_bytes_from_limbs(ret, out, sizeof(vec384));  ret += 48;+            from_fp(out, a[j][i][1]);+            be_bytes_from_limbs(ret, out, sizeof(vec384));  ret += 48;+        }+    }+}++size_t blst_fp12_sizeof(void)+{   return sizeof(vec384fp12);   }
+ c-source/src/hash_to_field.c view
@@ -0,0 +1,177 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */++#include "consts.h"+#include "sha256.h"++static const vec384 BLS12_381_RRRR = {  /* RR^2 */+    TO_LIMB_T(0xed48ac6bd94ca1e0), TO_LIMB_T(0x315f831e03a7adf8),+    TO_LIMB_T(0x9a53352a615e29dd), TO_LIMB_T(0x34c04e5e921e1761),+    TO_LIMB_T(0x2512d43565724728), TO_LIMB_T(0x0aa6346091755d4d)+};++#ifdef expand_message_xmd+void expand_message_xmd(unsigned char *bytes, size_t len_in_bytes,+                        const unsigned char *aug, size_t aug_len,+                        const unsigned char *msg, size_t msg_len,+                        const unsigned char *DST, size_t DST_len);+#else+static void sha256_init_Zpad(SHA256_CTX *ctx)+{+    ctx->h[0] = 0xda5698beU;+    ctx->h[1] = 0x17b9b469U;+    ctx->h[2] = 0x62335799U;+    ctx->h[3] = 0x779fbecaU;+    ctx->h[4] = 0x8ce5d491U;+    ctx->h[5] = 0xc0d26243U;+    ctx->h[6] = 0xbafef9eaU;+    ctx->h[7] = 0x1837a9d8U;+    ctx->N = 64;+    vec_zero(ctx->buf, sizeof(ctx->buf));+    ctx->off = 0;+}++static void vec_xor(void *restrict ret, const void *restrict a,+                                        const void *restrict b, size_t num)+{+    limb_t *rp = (limb_t *)ret;+    const limb_t *ap = (const limb_t *)a;+    const limb_t *bp = (const limb_t *)b;+    size_t i;++    num /= sizeof(limb_t);++    for (i = 0; i < num; i++)+        rp[i] = ap[i] ^ bp[i];+}++static void expand_message_xmd(unsigned char *bytes, size_t len_in_bytes,+                               const unsigned char *aug, size_t aug_len,+                               const unsigned char *msg, size_t msg_len,+                               const unsigned char *DST, size_t DST_len)+{+    union { limb_t align; unsigned char c[32]; } b_0;+    union { limb_t align; unsigned char c[33+256+31]; } b_i;+    unsigned char *p;+    size_t i, b_i_bits, b_i_blocks;+    SHA256_CTX ctx;++    /*+     * compose template for 'strxor(b_0, b_(i-1)) || I2OSP(i, 1) || DST_prime'+     */+    if (DST_len > 255) {+        sha256_init(&ctx);+        sha256_update(&ctx, "H2C-OVERSIZE-DST-", 17);+        sha256_update(&ctx, DST, DST_len);+        sha256_final(b_0.c, &ctx);+        DST = b_0.c, DST_len = 32;+    }+    b_i_blocks = ((33 + DST_len + 1 + 9) + 63) & -64;+    vec_zero(b_i.c + b_i_blocks - 64, 64);++    p = b_i.c + 33;+    for (i = 0; i < DST_len; i++)+        p[i] = DST[i];+    p[i++] = (unsigned char)DST_len;+    p[i++] = 0x80;+    p[i+6] = p[i+5] = p[i+4] = p[i+3] = p[i+2] = p[i+1] = p[i+0] = 0;+    b_i_bits = (33 + DST_len + 1) * 8;+    p = b_i.c + b_i_blocks;+    p[-2] = (unsigned char)(b_i_bits >> 8);+    p[-1] = (unsigned char)(b_i_bits);++    sha256_init_Zpad(&ctx);                         /* Z_pad | */+    sha256_update(&ctx, aug, aug_len);              /* | aug | */+    sha256_update(&ctx, msg, msg_len);              /* | msg | */+    /* | I2OSP(len_in_bytes, 2) || I2OSP(0, 1) || DST_prime    */+    b_i.c[30] = (unsigned char)(len_in_bytes >> 8);+    b_i.c[31] = (unsigned char)(len_in_bytes);+    b_i.c[32] = 0;+    sha256_update(&ctx, b_i.c + 30, 3 + DST_len + 1);+    sha256_final(b_0.c, &ctx);++    sha256_init_h(ctx.h);+    vec_copy(b_i.c, b_0.c, 32);+    ++b_i.c[32];+    sha256_block_data_order(ctx.h, b_i.c, b_i_blocks / 64);+    sha256_emit(bytes, ctx.h);++    len_in_bytes += 31; /* ell = ceil(len_in_bytes / b_in_bytes), with */+    len_in_bytes /= 32; /* caller being responsible for accordingly large+                         * buffer. hash_to_field passes one with length+                         * divisible by 64, remember? which works... */+    while (--len_in_bytes) {+        sha256_init_h(ctx.h);+        vec_xor(b_i.c, b_0.c, bytes, 32);+        bytes += 32;+        ++b_i.c[32];+        sha256_block_data_order(ctx.h, b_i.c, b_i_blocks / 64);+        sha256_emit(bytes, ctx.h);+    }+}+#endif++/*+ * |nelems| is 'count * m' from spec+ */+static void hash_to_field(vec384 elems[], size_t nelems,+                          const unsigned char *aug, size_t aug_len,+                          const unsigned char *msg, size_t msg_len,+                          const unsigned char *DST, size_t DST_len)+{+    size_t L = sizeof(vec384) + 128/8;  /* ceil((ceil(log2(p)) + k) / 8) */+    size_t len_in_bytes = L * nelems;   /* divisible by 64, hurray!      */+#if !defined(__STDC_VERSION__) || __STDC_VERSION__<199901 \+                               || defined(__STDC_NO_VLA__)+    limb_t *pseudo_random = alloca(len_in_bytes);+#else+    limb_t pseudo_random[len_in_bytes/sizeof(limb_t)];+#endif+    unsigned char *bytes;+    vec768 elem;++    aug_len = aug!=NULL ? aug_len : 0;+    DST_len = DST!=NULL ? DST_len : 0;++    expand_message_xmd((unsigned char *)pseudo_random, len_in_bytes,+                       aug, aug_len, msg, msg_len, DST, DST_len);++    vec_zero(elem, sizeof(elem));+    bytes = (unsigned char *)pseudo_random;+    while (nelems--) {+        limbs_from_be_bytes(elem, bytes, L);+        bytes += L;+        /*+         * L-bytes block % P, output is in Montgomery domain...+         */+        redc_mont_384(elems[0], elem, BLS12_381_P, p0);+        mul_mont_384(elems[0], elems[0], BLS12_381_RRRR, BLS12_381_P, p0);+        elems++;+    }+}++void blst_expand_message_xmd(unsigned char *bytes, size_t len_in_bytes,+                             const unsigned char *msg, size_t msg_len,+                             const unsigned char *DST, size_t DST_len)+{+    size_t buf_len = (len_in_bytes+31) & ((size_t)0-32);+    unsigned char *buf_ptr = bytes;++    if (buf_len > 255*32)+        return;++    if (buf_len != len_in_bytes)+        buf_ptr = alloca(buf_len);++    expand_message_xmd(buf_ptr, len_in_bytes, NULL, 0, msg, msg_len,+                                              DST, DST_len);+    if (buf_ptr != bytes) {+        unsigned char *ptr = buf_ptr;+        while (len_in_bytes--)+            *bytes++ = *ptr++;+        vec_zero(buf_ptr, buf_len);+    }+}
+ c-source/src/keygen.c view
@@ -0,0 +1,319 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */++#include "consts.h"+#include "bytes.h"+#include "sha256.h"++typedef struct {+    SHA256_CTX ctx;+    unsigned int h_ipad[8];+    unsigned int h_opad[8];+    union { limb_t l[64/sizeof(limb_t)]; unsigned char c[64]; } tail;+} HMAC_SHA256_CTX;++static void HMAC_init(HMAC_SHA256_CTX *ctx, const void *K, size_t K_len)+{+    size_t i;++    if (K == NULL) {            /* reuse h_ipad and h_opad */+        sha256_hcopy(ctx->ctx.h, ctx->h_ipad);+        ctx->ctx.N = 64;+        vec_zero(ctx->ctx.buf, sizeof(ctx->ctx.buf));+        ctx->ctx.off = 0;++        return;+    }++    vec_zero(ctx->tail.c, sizeof(ctx->tail));+    if (K_len > 64) {+        sha256_init(&ctx->ctx);+        sha256_update(&ctx->ctx, K, K_len);+        sha256_final(ctx->tail.c, &ctx->ctx);+    } else {+        sha256_bcopy(ctx->tail.c, K, K_len);+    }++    for (i = 0; i < 64/sizeof(limb_t); i++)+        ctx->tail.l[i] ^= (limb_t)0x3636363636363636;++    sha256_init(&ctx->ctx);+    sha256_update(&ctx->ctx, ctx->tail.c, 64);+    sha256_hcopy(ctx->h_ipad, ctx->ctx.h);++    for (i = 0; i < 64/sizeof(limb_t); i++)+        ctx->tail.l[i] ^= (limb_t)(0x3636363636363636 ^ 0x5c5c5c5c5c5c5c5c);++    sha256_init_h(ctx->h_opad);+    sha256_block_data_order(ctx->h_opad, ctx->tail.c, 1);++    vec_zero(ctx->tail.c, sizeof(ctx->tail));+    ctx->tail.c[32] = 0x80;+    ctx->tail.c[62] = 3;        /* (64+32)*8 in big endian */+    ctx->tail.c[63] = 0;+}++static void HMAC_update(HMAC_SHA256_CTX *ctx, const unsigned char *inp,+                                              size_t len)+{   sha256_update(&ctx->ctx, inp, len);   }++static void HMAC_final(unsigned char md[32], HMAC_SHA256_CTX *ctx)+{+    sha256_final(ctx->tail.c, &ctx->ctx);+    sha256_hcopy(ctx->ctx.h, ctx->h_opad);+    sha256_block_data_order(ctx->ctx.h, ctx->tail.c, 1);+    sha256_emit(md, ctx->ctx.h);+}++static void HKDF_Extract(unsigned char PRK[32],+                         const void *salt, size_t salt_len,+                         const void *IKM,  size_t IKM_len,+#ifndef __BLST_HKDF_TESTMODE__+                         int IKM_fixup,+#endif+                         HMAC_SHA256_CTX *ctx)+{+    unsigned char zero[1] = { 0 };++    HMAC_init(ctx, salt != NULL ? salt : zero, salt_len);+    HMAC_update(ctx, IKM, IKM_len);+#ifndef __BLST_HKDF_TESTMODE__+    if (IKM_fixup) {+        /* Section 2.3 KeyGen in BLS-signature draft */+        HMAC_update(ctx, zero, 1);+    }+#endif+    HMAC_final(PRK, ctx);+}++static void HKDF_Expand(unsigned char *OKM, size_t L,+                        const unsigned char PRK[32],+                        const void *info, size_t info_len,+#ifndef __BLST_HKDF_TESTMODE__+                        int info_fixup,+#endif+                        HMAC_SHA256_CTX *ctx)+{+#if !defined(__STDC_VERSION__) || __STDC_VERSION__<199901 \+                               || defined(__STDC_NO_VLA__)+    unsigned char *info_prime = alloca(info_len + 2 + 1);+#else+    unsigned char info_prime[info_len + 2 + 1];+#endif++    HMAC_init(ctx, PRK, 32);++    if (info_len != 0)+        sha256_bcopy(info_prime, info, info_len);+#ifndef __BLST_HKDF_TESTMODE__+    if (info_fixup) {+        /* Section 2.3 KeyGen in BLS-signature draft */+        info_prime[info_len + 0] = (unsigned char)(L >> 8);+        info_prime[info_len + 1] = (unsigned char)(L);+        info_len += 2;+    }+#endif+    info_prime[info_len] = 1;   /* counter */+    HMAC_update(ctx, info_prime, info_len + 1);+    HMAC_final(ctx->tail.c, ctx);+    while (L > 32) {+        sha256_hcopy((unsigned int *)OKM, (const unsigned int *)ctx->tail.c);+        OKM += 32; L -= 32;+        ++info_prime[info_len]; /* counter */+        HMAC_init(ctx, NULL, 0);+        HMAC_update(ctx, ctx->tail.c, 32);+        HMAC_update(ctx, info_prime, info_len + 1);+        HMAC_final(ctx->tail.c, ctx);+    }+    sha256_bcopy(OKM, ctx->tail.c, L);+}++#ifndef __BLST_HKDF_TESTMODE__+static void keygen(pow256 SK, const void *IKM, size_t IKM_len,+                              const void *salt, size_t salt_len,+                              const void *info, size_t info_len,+                              int version)+{+    struct {+        HMAC_SHA256_CTX ctx;+        unsigned char PRK[32], OKM[48];+        vec512 key;+    } scratch;+    unsigned char salt_prime[32] = "BLS-SIG-KEYGEN-SALT-";++    if (IKM_len < 32 || (version > 4 && salt == NULL)) {+        vec_zero(SK, sizeof(pow256));+        return;+    }++    /*+     * Vet |info| since some callers were caught to be sloppy, e.g.+     * SWIG-4.0-generated Python wrapper...+     */+    info_len = info==NULL ? 0 : info_len;++    if (salt == NULL) {+        salt = salt_prime;+        salt_len = 20;+    }++    if (version == 4) {+        /* salt = H(salt) */+        sha256_init(&scratch.ctx.ctx);+        sha256_update(&scratch.ctx.ctx, salt, salt_len);+        sha256_final(salt_prime, &scratch.ctx.ctx);+        salt = salt_prime;+        salt_len = sizeof(salt_prime);+    }++    while (1) {+        /* PRK = HKDF-Extract(salt, IKM || I2OSP(0, 1)) */+        HKDF_Extract(scratch.PRK, salt, salt_len,+                                  IKM, IKM_len, 1, &scratch.ctx);++        /* OKM = HKDF-Expand(PRK, key_info || I2OSP(L, 2), L) */+        HKDF_Expand(scratch.OKM, sizeof(scratch.OKM), scratch.PRK,+                    info, info_len, 1, &scratch.ctx);++        /* SK = OS2IP(OKM) mod r */+        vec_zero(scratch.key, sizeof(scratch.key));+        limbs_from_be_bytes(scratch.key, scratch.OKM, sizeof(scratch.OKM));+        redc_mont_256(scratch.key, scratch.key, BLS12_381_r, r0);+        /*+         * Given that mul_mont_sparse_256 has special boundary conditions+         * it's appropriate to mention that redc_mont_256 output is fully+         * reduced at this point. Because we started with 384-bit input,+         * one with most significant half smaller than the modulus.+         */+        mul_mont_sparse_256(scratch.key, scratch.key, BLS12_381_rRR,+                            BLS12_381_r, r0);++        if (version < 4 || !vec_is_zero(scratch.key, sizeof(vec256)))+            break;++        /* salt = H(salt) */+        sha256_init(&scratch.ctx.ctx);+        sha256_update(&scratch.ctx.ctx, salt, salt_len);+        sha256_final(salt_prime, &scratch.ctx.ctx);+        salt = salt_prime;+        salt_len = sizeof(salt_prime);+    }++    le_bytes_from_limbs(SK, scratch.key, sizeof(pow256));++    /*+     * scrub the stack just in case next callee inadvertently flashes+     * a fragment across application boundary...+     */+    vec_zero(&scratch, sizeof(scratch));+}++void blst_keygen(pow256 SK, const void *IKM, size_t IKM_len,+                            const void *info, size_t info_len)+{   keygen(SK, IKM, IKM_len, NULL, 0, info, info_len, 4);   }++void blst_keygen_v3(pow256 SK, const void *IKM, size_t IKM_len,+                               const void *info, size_t info_len)+{   keygen(SK, IKM, IKM_len, NULL, 0, info, info_len, 3);   }++void blst_keygen_v4_5(pow256 SK, const void *IKM, size_t IKM_len,+                                 const void *salt, size_t salt_len,+                                 const void *info, size_t info_len)+{   keygen(SK, IKM, IKM_len, salt, salt_len, info, info_len, 4);   }++void blst_keygen_v5(pow256 SK, const void *IKM, size_t IKM_len,+                               const void *salt, size_t salt_len,+                               const void *info, size_t info_len)+{   keygen(SK, IKM, IKM_len, salt, salt_len, info, info_len, 5);   }++/*+ * https://eips.ethereum.org/EIPS/eip-2333+ */+void blst_derive_master_eip2333(pow256 SK, const void *seed, size_t seed_len)+{   keygen(SK, seed, seed_len, NULL, 0, NULL, 0, 4);   }++static void parent_SK_to_lamport_PK(pow256 PK, const pow256 parent_SK,+                                    unsigned int index)+{+    size_t i;+    struct {+        HMAC_SHA256_CTX ctx;+        SHA256_CTX ret;+        unsigned char PRK[32], IKM[32];+        unsigned char lamport[255][32];+    } scratch;++    /* salt = I2OSP(index, 4) */+    unsigned char salt[4] = { (unsigned char)(index>>24),+                              (unsigned char)(index>>16),+                              (unsigned char)(index>>8),+                              (unsigned char)(index) };++    /* IKM = I2OSP(parent_SK, 32) */+    for (i = 0; i < 32; i++)+        scratch.IKM[i] = parent_SK[31-i];++    /* lamport_0 = IKM_to_lamport_SK(IKM, salt) */+    HKDF_Extract(scratch.PRK, salt, sizeof(salt), scratch.IKM, 32, 0,+                 &scratch.ctx);+    HKDF_Expand(scratch.lamport[0], sizeof(scratch.lamport),+                scratch.PRK, NULL, 0, 0, &scratch.ctx);++    vec_zero(scratch.ctx.ctx.buf, sizeof(scratch.ctx.ctx.buf));+    scratch.ctx.ctx.buf[32] = 0x80;+    scratch.ctx.ctx.buf[62] = 1;    /* 32*8 in big endian */+    scratch.ctx.ctx.buf[63] = 0;+    for (i = 0; i < 255; i++) {+        /* lamport_PK = lamport_PK | SHA256(lamport_0[i]) */+        sha256_init_h(scratch.ctx.ctx.h);+        sha256_bcopy(scratch.ctx.ctx.buf, scratch.lamport[i], 32);+        sha256_block_data_order(scratch.ctx.ctx.h, scratch.ctx.ctx.buf, 1);+        sha256_emit(scratch.lamport[i], scratch.ctx.ctx.h);+    }++    /* compressed_lamport_PK = SHA256(lamport_PK) */+    sha256_init(&scratch.ret);+    sha256_update(&scratch.ret, scratch.lamport, sizeof(scratch.lamport));++    /* not_IKM = flip_bits(IKM) */+    for (i = 0; i< 32; i++)+        scratch.IKM[i] = ~scratch.IKM[i];++    /* lamport_1 = IKM_to_lamport_SK(not_IKM, salt) */+    HKDF_Extract(scratch.PRK, salt, sizeof(salt), scratch.IKM, 32, 0,+                 &scratch.ctx);+    HKDF_Expand(scratch.lamport[0], sizeof(scratch.lamport),+                scratch.PRK, NULL, 0, 0, &scratch.ctx);++    vec_zero(scratch.ctx.ctx.buf, sizeof(scratch.ctx.ctx.buf));+    scratch.ctx.ctx.buf[32] = 0x80;+    scratch.ctx.ctx.buf[62] = 1;+    for (i = 0; i < 255; i++) {+        /* lamport_PK = lamport_PK | SHA256(lamport_1[i]) */+        sha256_init_h(scratch.ctx.ctx.h);+        sha256_bcopy(scratch.ctx.ctx.buf, scratch.lamport[i], 32);+        sha256_block_data_order(scratch.ctx.ctx.h, scratch.ctx.ctx.buf, 1);+        sha256_emit(scratch.lamport[i], scratch.ctx.ctx.h);+    }++    /* compressed_lamport_PK = SHA256(lamport_PK) */+    sha256_update(&scratch.ret, scratch.lamport, sizeof(scratch.lamport));+    sha256_final(PK, &scratch.ret);++    /*+     * scrub the stack just in case next callee inadvertently flashes+     * a fragment across application boundary...+     */+    vec_zero(&scratch, sizeof(scratch));+}++void blst_derive_child_eip2333(pow256 SK, const pow256 parent_SK,+                               unsigned int child_index)+{+    parent_SK_to_lamport_PK(SK, parent_SK, child_index);+    keygen(SK, SK, sizeof(pow256), NULL, 0, NULL, 0, 4);+}+#endif
+ c-source/src/map_to_g1.c view
@@ -0,0 +1,559 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */++#include "point.h"+#include "fields.h"++/*+ * y^2 = x^3 + A'*x + B', isogenous one+ */+static const vec384 Aprime_E1 = {+    /* (0x00144698a3b8e9433d693a02c96d4982b0ea985383ee66a8+          d8e8981aefd881ac98936f8da0e0f97f5cf428082d584c1d << 384) % P */+    TO_LIMB_T(0x2f65aa0e9af5aa51), TO_LIMB_T(0x86464c2d1e8416c3),+    TO_LIMB_T(0xb85ce591b7bd31e2), TO_LIMB_T(0x27e11c91b5f24e7c),+    TO_LIMB_T(0x28376eda6bfc1835), TO_LIMB_T(0x155455c3e5071d85)+};+static const vec384 Bprime_E1 = {+    /* (0x12e2908d11688030018b12e8753eee3b2016c1f0f24f4070+          a0b9c14fcef35ef55a23215a316ceaa5d1cc48e98e172be0 << 384) % P */+    TO_LIMB_T(0xfb996971fe22a1e0), TO_LIMB_T(0x9aa93eb35b742d6f),+    TO_LIMB_T(0x8c476013de99c5c4), TO_LIMB_T(0x873e27c3a221e571),+    TO_LIMB_T(0xca72b5e45a52d888), TO_LIMB_T(0x06824061418a386b)+};++static void map_fp_times_Zz(vec384 map[], const vec384 isogeny_map[],+                            const vec384 Zz_powers[], size_t n)+{+    while (n--)+        mul_fp(map[n], isogeny_map[n], Zz_powers[n]);+}++static void map_fp(vec384 acc, const vec384 x, const vec384 map[], size_t n)+{+    while (n--) {+        mul_fp(acc, acc, x);+        add_fp(acc, acc, map[n]);+    }+}++static void isogeny_map_to_E1(POINTonE1 *out, const POINTonE1 *p)+{+    /*+     * x = x_num / x_den, where+     * x_num = k_(1,11) * x'^11 + k_(1,10) * x'^10 + k_(1,9) * x'^9 ++     *         ... + k_(1,0)+     * ...+     */+    static const vec384 isogeny_map_x_num[] = { /*  (k_(1,*)<<384) % P  */+      { TO_LIMB_T(0x4d18b6f3af00131c), TO_LIMB_T(0x19fa219793fee28c),+        TO_LIMB_T(0x3f2885f1467f19ae), TO_LIMB_T(0x23dcea34f2ffb304),+        TO_LIMB_T(0xd15b58d2ffc00054), TO_LIMB_T(0x0913be200a20bef4)  },+      { TO_LIMB_T(0x898985385cdbbd8b), TO_LIMB_T(0x3c79e43cc7d966aa),+        TO_LIMB_T(0x1597e193f4cd233a), TO_LIMB_T(0x8637ef1e4d6623ad),+        TO_LIMB_T(0x11b22deed20d827b), TO_LIMB_T(0x07097bc5998784ad)  },+      { TO_LIMB_T(0xa542583a480b664b), TO_LIMB_T(0xfc7169c026e568c6),+        TO_LIMB_T(0x5ba2ef314ed8b5a6), TO_LIMB_T(0x5b5491c05102f0e7),+        TO_LIMB_T(0xdf6e99707d2a0079), TO_LIMB_T(0x0784151ed7605524)  },+      { TO_LIMB_T(0x494e212870f72741), TO_LIMB_T(0xab9be52fbda43021),+        TO_LIMB_T(0x26f5577994e34c3d), TO_LIMB_T(0x049dfee82aefbd60),+        TO_LIMB_T(0x65dadd7828505289), TO_LIMB_T(0x0e93d431ea011aeb)  },+      { TO_LIMB_T(0x90ee774bd6a74d45), TO_LIMB_T(0x7ada1c8a41bfb185),+        TO_LIMB_T(0x0f1a8953b325f464), TO_LIMB_T(0x104c24211be4805c),+        TO_LIMB_T(0x169139d319ea7a8f), TO_LIMB_T(0x09f20ead8e532bf6)  },+      { TO_LIMB_T(0x6ddd93e2f43626b7), TO_LIMB_T(0xa5482c9aa1ccd7bd),+        TO_LIMB_T(0x143245631883f4bd), TO_LIMB_T(0x2e0a94ccf77ec0db),+        TO_LIMB_T(0xb0282d480e56489f), TO_LIMB_T(0x18f4bfcbb4368929)  },+      { TO_LIMB_T(0x23c5f0c953402dfd), TO_LIMB_T(0x7a43ff6958ce4fe9),+        TO_LIMB_T(0x2c390d3d2da5df63), TO_LIMB_T(0xd0df5c98e1f9d70f),+        TO_LIMB_T(0xffd89869a572b297), TO_LIMB_T(0x1277ffc72f25e8fe)  },+      { TO_LIMB_T(0x79f4f0490f06a8a6), TO_LIMB_T(0x85f894a88030fd81),+        TO_LIMB_T(0x12da3054b18b6410), TO_LIMB_T(0xe2a57f6505880d65),+        TO_LIMB_T(0xbba074f260e400f1), TO_LIMB_T(0x08b76279f621d028)  },+      { TO_LIMB_T(0xe67245ba78d5b00b), TO_LIMB_T(0x8456ba9a1f186475),+        TO_LIMB_T(0x7888bff6e6b33bb4), TO_LIMB_T(0xe21585b9a30f86cb),+        TO_LIMB_T(0x05a69cdcef55feee), TO_LIMB_T(0x09e699dd9adfa5ac)  },+      { TO_LIMB_T(0x0de5c357bff57107), TO_LIMB_T(0x0a0db4ae6b1a10b2),+        TO_LIMB_T(0xe256bb67b3b3cd8d), TO_LIMB_T(0x8ad456574e9db24f),+        TO_LIMB_T(0x0443915f50fd4179), TO_LIMB_T(0x098c4bf7de8b6375)  },+      { TO_LIMB_T(0xe6b0617e7dd929c7), TO_LIMB_T(0xfe6e37d442537375),+        TO_LIMB_T(0x1dafdeda137a489e), TO_LIMB_T(0xe4efd1ad3f767ceb),+        TO_LIMB_T(0x4a51d8667f0fe1cf), TO_LIMB_T(0x054fdf4bbf1d821c)  },+      { TO_LIMB_T(0x72db2a50658d767b), TO_LIMB_T(0x8abf91faa257b3d5),+        TO_LIMB_T(0xe969d6833764ab47), TO_LIMB_T(0x464170142a1009eb),+        TO_LIMB_T(0xb14f01aadb30be2f), TO_LIMB_T(0x18ae6a856f40715d)  }+    };+    /* ...+     * x_den = x'^10 + k_(2,9) * x'^9 + k_(2,8) * x'^8 + ... + k_(2,0)+     */+    static const vec384 isogeny_map_x_den[] = { /*  (k_(2,*)<<384) % P  */+      { TO_LIMB_T(0xb962a077fdb0f945), TO_LIMB_T(0xa6a9740fefda13a0),+        TO_LIMB_T(0xc14d568c3ed6c544), TO_LIMB_T(0xb43fc37b908b133e),+        TO_LIMB_T(0x9c0b3ac929599016), TO_LIMB_T(0x0165aa6c93ad115f)  },+      { TO_LIMB_T(0x23279a3ba506c1d9), TO_LIMB_T(0x92cfca0a9465176a),+        TO_LIMB_T(0x3b294ab13755f0ff), TO_LIMB_T(0x116dda1c5070ae93),+        TO_LIMB_T(0xed4530924cec2045), TO_LIMB_T(0x083383d6ed81f1ce)  },+      { TO_LIMB_T(0x9885c2a6449fecfc), TO_LIMB_T(0x4a2b54ccd37733f0),+        TO_LIMB_T(0x17da9ffd8738c142), TO_LIMB_T(0xa0fba72732b3fafd),+        TO_LIMB_T(0xff364f36e54b6812), TO_LIMB_T(0x0f29c13c660523e2)  },+      { TO_LIMB_T(0xe349cc118278f041), TO_LIMB_T(0xd487228f2f3204fb),+        TO_LIMB_T(0xc9d325849ade5150), TO_LIMB_T(0x43a92bd69c15c2df),+        TO_LIMB_T(0x1c2c7844bc417be4), TO_LIMB_T(0x12025184f407440c)  },+      { TO_LIMB_T(0x587f65ae6acb057b), TO_LIMB_T(0x1444ef325140201f),+        TO_LIMB_T(0xfbf995e71270da49), TO_LIMB_T(0xccda066072436a42),+        TO_LIMB_T(0x7408904f0f186bb2), TO_LIMB_T(0x13b93c63edf6c015)  },+      { TO_LIMB_T(0xfb918622cd141920), TO_LIMB_T(0x4a4c64423ecaddb4),+        TO_LIMB_T(0x0beb232927f7fb26), TO_LIMB_T(0x30f94df6f83a3dc2),+        TO_LIMB_T(0xaeedd424d780f388), TO_LIMB_T(0x06cc402dd594bbeb)  },+      { TO_LIMB_T(0xd41f761151b23f8f), TO_LIMB_T(0x32a92465435719b3),+        TO_LIMB_T(0x64f436e888c62cb9), TO_LIMB_T(0xdf70a9a1f757c6e4),+        TO_LIMB_T(0x6933a38d5b594c81), TO_LIMB_T(0x0c6f7f7237b46606)  },+      { TO_LIMB_T(0x693c08747876c8f7), TO_LIMB_T(0x22c9850bf9cf80f0),+        TO_LIMB_T(0x8e9071dab950c124), TO_LIMB_T(0x89bc62d61c7baf23),+        TO_LIMB_T(0xbc6be2d8dad57c23), TO_LIMB_T(0x17916987aa14a122)  },+      { TO_LIMB_T(0x1be3ff439c1316fd), TO_LIMB_T(0x9965243a7571dfa7),+        TO_LIMB_T(0xc7f7f62962f5cd81), TO_LIMB_T(0x32c6aa9af394361c),+        TO_LIMB_T(0xbbc2ee18e1c227f4), TO_LIMB_T(0x0c102cbac531bb34)  },+      { TO_LIMB_T(0x997614c97bacbf07), TO_LIMB_T(0x61f86372b99192c0),+        TO_LIMB_T(0x5b8c95fc14353fc3), TO_LIMB_T(0xca2b066c2a87492f),+        TO_LIMB_T(0x16178f5bbf698711), TO_LIMB_T(0x12a6dcd7f0f4e0e8)  }+    };+    /*+     * y = y' * y_num / y_den, where+     * y_num = k_(3,15) * x'^15 + k_(3,14) * x'^14 + k_(3,13) * x'^13 ++     *         ... + k_(3,0)+     * ...+     */+    static const vec384 isogeny_map_y_num[] = { /*  (k_(3,*)<<384) % P  */+      { TO_LIMB_T(0x2b567ff3e2837267), TO_LIMB_T(0x1d4d9e57b958a767),+        TO_LIMB_T(0xce028fea04bd7373), TO_LIMB_T(0xcc31a30a0b6cd3df),+        TO_LIMB_T(0x7d7b18a682692693), TO_LIMB_T(0x0d300744d42a0310)  },+      { TO_LIMB_T(0x99c2555fa542493f), TO_LIMB_T(0xfe7f53cc4874f878),+        TO_LIMB_T(0x5df0608b8f97608a), TO_LIMB_T(0x14e03832052b49c8),+        TO_LIMB_T(0x706326a6957dd5a4), TO_LIMB_T(0x0a8dadd9c2414555)  },+      { TO_LIMB_T(0x13d942922a5cf63a), TO_LIMB_T(0x357e33e36e261e7d),+        TO_LIMB_T(0xcf05a27c8456088d), TO_LIMB_T(0x0000bd1de7ba50f0),+        TO_LIMB_T(0x83d0c7532f8c1fde), TO_LIMB_T(0x13f70bf38bbf2905)  },+      { TO_LIMB_T(0x5c57fd95bfafbdbb), TO_LIMB_T(0x28a359a65e541707),+        TO_LIMB_T(0x3983ceb4f6360b6d), TO_LIMB_T(0xafe19ff6f97e6d53),+        TO_LIMB_T(0xb3468f4550192bf7), TO_LIMB_T(0x0bb6cde49d8ba257)  },+      { TO_LIMB_T(0x590b62c7ff8a513f), TO_LIMB_T(0x314b4ce372cacefd),+        TO_LIMB_T(0x6bef32ce94b8a800), TO_LIMB_T(0x6ddf84a095713d5f),+        TO_LIMB_T(0x64eace4cb0982191), TO_LIMB_T(0x0386213c651b888d)  },+      { TO_LIMB_T(0xa5310a31111bbcdd), TO_LIMB_T(0xa14ac0f5da148982),+        TO_LIMB_T(0xf9ad9cc95423d2e9), TO_LIMB_T(0xaa6ec095283ee4a7),+        TO_LIMB_T(0xcf5b1f022e1c9107), TO_LIMB_T(0x01fddf5aed881793)  },+      { TO_LIMB_T(0x65a572b0d7a7d950), TO_LIMB_T(0xe25c2d8183473a19),+        TO_LIMB_T(0xc2fcebe7cb877dbd), TO_LIMB_T(0x05b2d36c769a89b0),+        TO_LIMB_T(0xba12961be86e9efb), TO_LIMB_T(0x07eb1b29c1dfde1f)  },+      { TO_LIMB_T(0x93e09572f7c4cd24), TO_LIMB_T(0x364e929076795091),+        TO_LIMB_T(0x8569467e68af51b5), TO_LIMB_T(0xa47da89439f5340f),+        TO_LIMB_T(0xf4fa918082e44d64), TO_LIMB_T(0x0ad52ba3e6695a79)  },+      { TO_LIMB_T(0x911429844e0d5f54), TO_LIMB_T(0xd03f51a3516bb233),+        TO_LIMB_T(0x3d587e5640536e66), TO_LIMB_T(0xfa86d2a3a9a73482),+        TO_LIMB_T(0xa90ed5adf1ed5537), TO_LIMB_T(0x149c9c326a5e7393)  },+      { TO_LIMB_T(0x462bbeb03c12921a), TO_LIMB_T(0xdc9af5fa0a274a17),+        TO_LIMB_T(0x9a558ebde836ebed), TO_LIMB_T(0x649ef8f11a4fae46),+        TO_LIMB_T(0x8100e1652b3cdc62), TO_LIMB_T(0x1862bd62c291dacb)  },+      { TO_LIMB_T(0x05c9b8ca89f12c26), TO_LIMB_T(0x0194160fa9b9ac4f),+        TO_LIMB_T(0x6a643d5a6879fa2c), TO_LIMB_T(0x14665bdd8846e19d),+        TO_LIMB_T(0xbb1d0d53af3ff6bf), TO_LIMB_T(0x12c7e1c3b28962e5)  },+      { TO_LIMB_T(0xb55ebf900b8a3e17), TO_LIMB_T(0xfedc77ec1a9201c4),+        TO_LIMB_T(0x1f07db10ea1a4df4), TO_LIMB_T(0x0dfbd15dc41a594d),+        TO_LIMB_T(0x389547f2334a5391), TO_LIMB_T(0x02419f98165871a4)  },+      { TO_LIMB_T(0xb416af000745fc20), TO_LIMB_T(0x8e563e9d1ea6d0f5),+        TO_LIMB_T(0x7c763e17763a0652), TO_LIMB_T(0x01458ef0159ebbef),+        TO_LIMB_T(0x8346fe421f96bb13), TO_LIMB_T(0x0d2d7b829ce324d2)  },+      { TO_LIMB_T(0x93096bb538d64615), TO_LIMB_T(0x6f2a2619951d823a),+        TO_LIMB_T(0x8f66b3ea59514fa4), TO_LIMB_T(0xf563e63704f7092f),+        TO_LIMB_T(0x724b136c4cf2d9fa), TO_LIMB_T(0x046959cfcfd0bf49)  },+      { TO_LIMB_T(0xea748d4b6e405346), TO_LIMB_T(0x91e9079c2c02d58f),+        TO_LIMB_T(0x41064965946d9b59), TO_LIMB_T(0xa06731f1d2bbe1ee),+        TO_LIMB_T(0x07f897e267a33f1b), TO_LIMB_T(0x1017290919210e5f)  },+      { TO_LIMB_T(0x872aa6c17d985097), TO_LIMB_T(0xeecc53161264562a),+        TO_LIMB_T(0x07afe37afff55002), TO_LIMB_T(0x54759078e5be6838),+        TO_LIMB_T(0xc4b92d15db8acca8), TO_LIMB_T(0x106d87d1b51d13b9)  }+    };+    /* ...+     * y_den = x'^15 + k_(4,14) * x'^14 + k_(4,13) * x'^13 + ... + k_(4,0)+     */+    static const vec384 isogeny_map_y_den[] = { /*  (k_(4,*)<<384) % P  */+      { TO_LIMB_T(0xeb6c359d47e52b1c), TO_LIMB_T(0x18ef5f8a10634d60),+        TO_LIMB_T(0xddfa71a0889d5b7e), TO_LIMB_T(0x723e71dcc5fc1323),+        TO_LIMB_T(0x52f45700b70d5c69), TO_LIMB_T(0x0a8b981ee47691f1)  },+      { TO_LIMB_T(0x616a3c4f5535b9fb), TO_LIMB_T(0x6f5f037395dbd911),+        TO_LIMB_T(0xf25f4cc5e35c65da), TO_LIMB_T(0x3e50dffea3c62658),+        TO_LIMB_T(0x6a33dca523560776), TO_LIMB_T(0x0fadeff77b6bfe3e)  },+      { TO_LIMB_T(0x2be9b66df470059c), TO_LIMB_T(0x24a2c159a3d36742),+        TO_LIMB_T(0x115dbe7ad10c2a37), TO_LIMB_T(0xb6634a652ee5884d),+        TO_LIMB_T(0x04fe8bb2b8d81af4), TO_LIMB_T(0x01c2a7a256fe9c41)  },+      { TO_LIMB_T(0xf27bf8ef3b75a386), TO_LIMB_T(0x898b367476c9073f),+        TO_LIMB_T(0x24482e6b8c2f4e5f), TO_LIMB_T(0xc8e0bbd6fe110806),+        TO_LIMB_T(0x59b0c17f7631448a), TO_LIMB_T(0x11037cd58b3dbfbd)  },+      { TO_LIMB_T(0x31c7912ea267eec6), TO_LIMB_T(0x1dbf6f1c5fcdb700),+        TO_LIMB_T(0xd30d4fe3ba86fdb1), TO_LIMB_T(0x3cae528fbee9a2a4),+        TO_LIMB_T(0xb1cce69b6aa9ad9a), TO_LIMB_T(0x044393bb632d94fb)  },+      { TO_LIMB_T(0xc66ef6efeeb5c7e8), TO_LIMB_T(0x9824c289dd72bb55),+        TO_LIMB_T(0x71b1a4d2f119981d), TO_LIMB_T(0x104fc1aafb0919cc),+        TO_LIMB_T(0x0e49df01d942a628), TO_LIMB_T(0x096c3a09773272d4)  },+      { TO_LIMB_T(0x9abc11eb5fadeff4), TO_LIMB_T(0x32dca50a885728f0),+        TO_LIMB_T(0xfb1fa3721569734c), TO_LIMB_T(0xc4b76271ea6506b3),+        TO_LIMB_T(0xd466a75599ce728e), TO_LIMB_T(0x0c81d4645f4cb6ed)  },+      { TO_LIMB_T(0x4199f10e5b8be45b), TO_LIMB_T(0xda64e495b1e87930),+        TO_LIMB_T(0xcb353efe9b33e4ff), TO_LIMB_T(0x9e9efb24aa6424c6),+        TO_LIMB_T(0xf08d33680a237465), TO_LIMB_T(0x0d3378023e4c7406)  },+      { TO_LIMB_T(0x7eb4ae92ec74d3a5), TO_LIMB_T(0xc341b4aa9fac3497),+        TO_LIMB_T(0x5be603899e907687), TO_LIMB_T(0x03bfd9cca75cbdeb),+        TO_LIMB_T(0x564c2935a96bfa93), TO_LIMB_T(0x0ef3c33371e2fdb5)  },+      { TO_LIMB_T(0x7ee91fd449f6ac2e), TO_LIMB_T(0xe5d5bd5cb9357a30),+        TO_LIMB_T(0x773a8ca5196b1380), TO_LIMB_T(0xd0fda172174ed023),+        TO_LIMB_T(0x6cb95e0fa776aead), TO_LIMB_T(0x0d22d5a40cec7cff)  },+      { TO_LIMB_T(0xf727e09285fd8519), TO_LIMB_T(0xdc9d55a83017897b),+        TO_LIMB_T(0x7549d8bd057894ae), TO_LIMB_T(0x178419613d90d8f8),+        TO_LIMB_T(0xfce95ebdeb5b490a), TO_LIMB_T(0x0467ffaef23fc49e)  },+      { TO_LIMB_T(0xc1769e6a7c385f1b), TO_LIMB_T(0x79bc930deac01c03),+        TO_LIMB_T(0x5461c75a23ede3b5), TO_LIMB_T(0x6e20829e5c230c45),+        TO_LIMB_T(0x828e0f1e772a53cd), TO_LIMB_T(0x116aefa749127bff)  },+      { TO_LIMB_T(0x101c10bf2744c10a), TO_LIMB_T(0xbbf18d053a6a3154),+        TO_LIMB_T(0xa0ecf39ef026f602), TO_LIMB_T(0xfc009d4996dc5153),+        TO_LIMB_T(0xb9000209d5bd08d3), TO_LIMB_T(0x189e5fe4470cd73c)  },+      { TO_LIMB_T(0x7ebd546ca1575ed2), TO_LIMB_T(0xe47d5a981d081b55),+        TO_LIMB_T(0x57b2b625b6d4ca21), TO_LIMB_T(0xb0a1ba04228520cc),+        TO_LIMB_T(0x98738983c2107ff3), TO_LIMB_T(0x13dddbc4799d81d6)  },+      { TO_LIMB_T(0x09319f2e39834935), TO_LIMB_T(0x039e952cbdb05c21),+        TO_LIMB_T(0x55ba77a9a2f76493), TO_LIMB_T(0xfd04e3dfc6086467),+        TO_LIMB_T(0xfb95832e7d78742e), TO_LIMB_T(0x0ef9c24eccaf5e0e)  }+    };+    vec384 Zz_powers[15], map[15], xn, xd, yn, yd;++    /* lay down Z^2 powers in descending order                          */+    sqr_fp(Zz_powers[14], p->Z);                        /* ZZ^1         */+#ifdef __OPTIMIZE_SIZE__+    for (size_t i = 14; i > 0; i--)+        mul_fp(Zz_powers[i-1], Zz_powers[i], Zz_powers[14]);+#else+    sqr_fp(Zz_powers[13], Zz_powers[14]);               /* ZZ^2  1+1    */+    mul_fp(Zz_powers[12], Zz_powers[14], Zz_powers[13]);/* ZZ^3  2+1    */+    sqr_fp(Zz_powers[11], Zz_powers[13]);               /* ZZ^4  2+2    */+    mul_fp(Zz_powers[10], Zz_powers[13], Zz_powers[12]);/* ZZ^5  2+3    */+    sqr_fp(Zz_powers[9],  Zz_powers[12]);               /* ZZ^6  3+3    */+    mul_fp(Zz_powers[8],  Zz_powers[12], Zz_powers[11]);/* ZZ^7  3+4    */+    sqr_fp(Zz_powers[7],  Zz_powers[11]);               /* ZZ^8  4+4    */+    mul_fp(Zz_powers[6],  Zz_powers[11], Zz_powers[10]);/* ZZ^9  4+5    */+    sqr_fp(Zz_powers[5],  Zz_powers[10]);               /* ZZ^10 5+5    */+    mul_fp(Zz_powers[4],  Zz_powers[10], Zz_powers[9]); /* ZZ^11 5+6    */+    sqr_fp(Zz_powers[3],  Zz_powers[9]);                /* ZZ^12 6+6    */+    mul_fp(Zz_powers[2],  Zz_powers[9],  Zz_powers[8]); /* ZZ^13 6+7    */+    sqr_fp(Zz_powers[1],  Zz_powers[8]);                /* ZZ^14 7+7    */+    mul_fp(Zz_powers[0],  Zz_powers[8],  Zz_powers[7]); /* ZZ^15 7+8    */+#endif++    map_fp_times_Zz(map, isogeny_map_x_num, Zz_powers + 4, 11);+    mul_fp(xn, p->X, isogeny_map_x_num[11]);+    add_fp(xn, xn, map[10]);+    map_fp(xn, p->X, map, 10);++    map_fp_times_Zz(map, isogeny_map_x_den, Zz_powers + 5, 10);+    add_fp(xd, p->X, map[9]);+    map_fp(xd, p->X, map, 9);+    mul_fp(xd, xd, Zz_powers[14]);      /* xd *= Z^2                    */++    map_fp_times_Zz(map, isogeny_map_y_num, Zz_powers, 15);+    mul_fp(yn, p->X, isogeny_map_y_num[15]);+    add_fp(yn, yn, map[14]);+    map_fp(yn, p->X, map, 14);+    mul_fp(yn, yn, p->Y);               /* yn *= Y                      */++    map_fp_times_Zz(map, isogeny_map_y_den, Zz_powers, 15);+    add_fp(yd, p->X, map[14]);+    map_fp(yd, p->X, map, 14);+    mul_fp(Zz_powers[14], Zz_powers[14], p->Z);+    mul_fp(yd, yd, Zz_powers[14]);      /* yd *= Z^3                    */++    /* convert (xn, xd, yn, yd) to Jacobian coordinates                 */+    mul_fp(out->Z, xd, yd);             /* Z = xd * yd                  */+    mul_fp(out->X, xn, yd);+    mul_fp(out->X, out->X, out->Z);     /* X = xn * xd * yd^2           */+    sqr_fp(out->Y, out->Z);+    mul_fp(out->Y, out->Y, xd);+    mul_fp(out->Y, out->Y, yn);         /* Y = yn * xd^3 * yd^2         */+}++static void map_to_isogenous_E1(POINTonE1 *p, const vec384 u)+{+    static const vec384 minus_A = { /* P - A */+        TO_LIMB_T(0x8a9955f1650a005a), TO_LIMB_T(0x9865b3d192cfe93c),+        TO_LIMB_T(0xaed3ed0f3ef3c441), TO_LIMB_T(0x3c962ef33d92c442),+        TO_LIMB_T(0x22e438dbd74f94a2), TO_LIMB_T(0x04acbc265478c915)+    };+    static const vec384 Z = {       /* (11<<384) % P */+        TO_LIMB_T(0x886c00000023ffdc), TO_LIMB_T(0x0f70008d3090001d),+        TO_LIMB_T(0x77672417ed5828c3), TO_LIMB_T(0x9dac23e943dc1740),+        TO_LIMB_T(0x50553f1b9c131521), TO_LIMB_T(0x078c712fbe0ab6e8)+    };+    static const vec384 sqrt_minus_ZZZ = {+        TO_LIMB_T(0x43b571cad3215f1f), TO_LIMB_T(0xccb460ef1c702dc2),+        TO_LIMB_T(0x742d884f4f97100b), TO_LIMB_T(0xdb2c3e3238a3382b),+        TO_LIMB_T(0xe40f3fa13fce8f88), TO_LIMB_T(0x0073a2af9892a2ff)+    };+    static const vec384 ZxA = {+        TO_LIMB_T(0x7f674ea0a8915178), TO_LIMB_T(0xb0f945fc13b8fa65),+        TO_LIMB_T(0x4b46759a38e87d76), TO_LIMB_T(0x2e7a929641bbb6a1),+        TO_LIMB_T(0x1668ddfa462bf6b6), TO_LIMB_T(0x00960e2ed1cf294c)+    };+    vec384 uu, tv2, x2n, gx1, gxd, y2;+#if 0+    vec384 xn, x1n, xd, y, y1, Zuu, tv4;+#else+# define xn     p->X+# define y      p->Y+# define xd     p->Z+# define x1n    xn+# define y1     y+# define Zuu    x2n+# define tv4    y1+#endif+#define sgn0_fp(a) (sgn0_pty_mont_384((a), BLS12_381_P, p0) & 1)+    bool_t e1, e2;++    /*+     * as per map_to_curve() from poc/sswu_opt.sage at+     * https://github.com/cfrg/draft-irtf-cfrg-hash-to-curve+     */+    /* x numerator variants                                             */+    sqr_fp(uu, u);                      /* uu = u^2                     */+    mul_fp(Zuu, Z, uu);                 /* Zuu = Z * uu                 */+    sqr_fp(tv2, Zuu);                   /* tv2 = Zuu^2                  */+    add_fp(tv2, tv2, Zuu);              /* tv2 = tv2 + Zuu              */+    add_fp(x1n, tv2, BLS12_381_Rx.p);   /* x1n = tv2 + 1                */+    mul_fp(x1n, x1n, Bprime_E1);        /* x1n = x1n * B                */+    mul_fp(x2n, Zuu, x1n);              /* x2n = Zuu * x1n              */++    /* x denumenator                                                    */+    mul_fp(xd, minus_A, tv2);           /* xd = -A * tv2                */+    e1 = vec_is_zero(xd, sizeof(xd));   /* e1 = xd == 0                 */+    vec_select(xd, ZxA, xd, sizeof(xd), e1);    /*              # If xd == 0, set xd = Z*A */++    /* y numerators variants                                            */+    sqr_fp(tv2, xd);                    /* tv2 = xd^2                   */+    mul_fp(gxd, xd, tv2);               /* gxd = xd^3                   */+    mul_fp(tv2, Aprime_E1, tv2);        /* tv2 = A * tv2                */+    sqr_fp(gx1, x1n);                   /* gx1 = x1n^2                  */+    add_fp(gx1, gx1, tv2);              /* gx1 = gx1 + tv2      # x1n^2 + A*xd^2 */+    mul_fp(gx1, gx1, x1n);              /* gx1 = gx1 * x1n      # x1n^3 + A*x1n*xd^2 */+    mul_fp(tv2, Bprime_E1, gxd);        /* tv2 = B * gxd                */+    add_fp(gx1, gx1, tv2);              /* gx1 = gx1 + tv2      # x1^3 + A*x1*xd^2 + B*xd^3 */+    sqr_fp(tv4, gxd);                   /* tv4 = gxd^2                  */+    mul_fp(tv2, gx1, gxd);              /* tv2 = gx1 * gxd              */+    mul_fp(tv4, tv4, tv2);              /* tv4 = tv4 * tv2      # gx1*gxd^3 */+    e2 = recip_sqrt_fp(y1, tv4);        /* y1 = tv4^c1          # (gx1*gxd^3)^((p-3)/4) */+    mul_fp(y1, y1, tv2);                /* y1 = y1 * tv2        # gx1*gxd*y1 */+    mul_fp(y2, y1, sqrt_minus_ZZZ);     /* y2 = y1 * c2         # y2 = y1*sqrt(-Z^3) */+    mul_fp(y2, y2, uu);                 /* y2 = y2 * uu                 */+    mul_fp(y2, y2, u);                  /* y2 = y2 * u                  */++    /* choose numerators                                                */+    vec_select(xn, x1n, x2n, sizeof(xn), e2);   /* xn = e2 ? x1n : x2n  */+    vec_select(y, y1, y2, sizeof(y), e2);       /* y  = e2 ? y1 : y2    */++    e1 = sgn0_fp(u);+    e2 = sgn0_fp(y);+    cneg_fp(y, y, e1^e2);               /* fix sign of y                */+                                        /* return (xn, xd, y, 1)        */++    /* convert (xn, xd, y, 1) to Jacobian projective coordinates        */+    mul_fp(p->X, xn, xd);               /* X = xn * xd                  */+    mul_fp(p->Y, y, gxd);               /* Y = y * xd^3                 */+#ifndef xd+    vec_copy(p->Z, xd, sizeof(xd));     /* Z = xd                       */+#else+# undef xn+# undef y+# undef xd+# undef x1n+# undef y1+# undef Zuu+# undef tv4+#endif+#undef sgn0_fp+}++static void POINTonE1_add_n_dbl(POINTonE1 *out, const POINTonE1 *p, size_t n)+{+    POINTonE1_dadd(out, out, p, NULL);+    while(n--)+        POINTonE1_double(out, out);+}++static void POINTonE1_times_minus_z(POINTonE1 *out, const POINTonE1 *in)+{+    POINTonE1_double(out, in);          /*      1: 0x2                  */+    POINTonE1_add_n_dbl(out, in, 2);    /*   2..4: 0x3..0xc             */+    POINTonE1_add_n_dbl(out, in, 3);    /*   5..8: 0xd..0x68            */+    POINTonE1_add_n_dbl(out, in, 9);    /*  9..18: 0x69..0xd200         */+    POINTonE1_add_n_dbl(out, in, 32);   /* 19..51: ..0xd20100000000     */+    POINTonE1_add_n_dbl(out, in, 16);   /* 52..68: ..0xd201000000010000 */+}++/*+ * |u|, |v| are expected to be in Montgomery representation+ */+static void map_to_g1(POINTonE1 *out, const vec384 u, const vec384 v)+{+    POINTonE1 p;++    map_to_isogenous_E1(&p, u);++    if (v != NULL) {+        map_to_isogenous_E1(out, v);    /* borrow |out|                 */+        POINTonE1_dadd(&p, &p, out, Aprime_E1);+    }++    isogeny_map_to_E1(&p, &p);          /* sprinkle isogenous powder    */++    /* clear the cofactor by multiplying |p| by 1-z, 0xd201000000010001 */+    POINTonE1_times_minus_z(out, &p);+    POINTonE1_dadd(out, out, &p, NULL);+}++void blst_map_to_g1(POINTonE1 *out, const vec384 u, const vec384 v)+{   map_to_g1(out, u, v);   }++static void Encode_to_G1(POINTonE1 *p, const unsigned char *msg, size_t msg_len,+                                       const unsigned char *DST, size_t DST_len,+                                       const unsigned char *aug, size_t aug_len)+{+    vec384 u[1];++    hash_to_field(u, 1, aug, aug_len, msg, msg_len, DST, DST_len);+    map_to_g1(p, u[0], NULL);+}++void blst_encode_to_g1(POINTonE1 *p, const unsigned char *msg, size_t msg_len,+                                     const unsigned char *DST, size_t DST_len,+                                     const unsigned char *aug, size_t aug_len)+{   Encode_to_G1(p, msg, msg_len, DST, DST_len, aug, aug_len);   }++static void Hash_to_G1(POINTonE1 *p, const unsigned char *msg, size_t msg_len,+                                     const unsigned char *DST, size_t DST_len,+                                     const unsigned char *aug, size_t aug_len)+{+    vec384 u[2];++    hash_to_field(u, 2, aug, aug_len, msg, msg_len, DST, DST_len);+    map_to_g1(p, u[0], u[1]);+}++void blst_hash_to_g1(POINTonE1 *p, const unsigned char *msg, size_t msg_len,+                                   const unsigned char *DST, size_t DST_len,+                                   const unsigned char *aug, size_t aug_len)+{   Hash_to_G1(p, msg, msg_len, DST, DST_len, aug, aug_len);   }++static void sigma(POINTonE1 *out, const POINTonE1 *in);++#if 0+#ifdef __OPTIMIZE_SIZE__+static void POINTonE1_times_zz_minus_1_div_by_3(POINTonE1 *out,+                                                const POINTonE1 *in)+{+    static const byte zz_minus_1_div_by_3[] = {+        TO_BYTES(0x0000000055555555ULL), TO_BYTES(0x396c8c005555e156)+    };+    size_t n = 126-1;+    const POINTonE1 *dblin = in;++    while(n--) {+        POINTonE1_double(out, dblin);   dblin = out;+        if (is_bit_set(zz_minus_1_div_by_3, n))+            POINTonE1_dadd(out, out, in, NULL);+    }+}+#else+static void POINTonE1_dbl_n_add(POINTonE1 *out, size_t n, const POINTonE1 *p)+{+    while(n--)+        POINTonE1_double(out, out);+    POINTonE1_dadd(out, out, p, NULL);+}++static void POINTonE1_times_zz_minus_1_div_by_3(POINTonE1 *out,+                                                const POINTonE1 *in)+{+    POINTonE1 t3, t5, t7, t11, t85;++    POINTonE1_double(&t7, in);              /* 2P */+    POINTonE1_dadd(&t3, &t7, in, NULL);     /* 3P */+    POINTonE1_dadd(&t5, &t3, &t7, NULL);    /* 5P */+    POINTonE1_dadd(&t7, &t5, &t7, NULL);    /* 7P */+    POINTonE1_double(&t85, &t5);            /* 10P */+    POINTonE1_dadd(&t11, &t85, in, NULL);   /* 11P */+    POINTonE1_dbl_n_add(&t85, 3, &t5);      /* 0x55P */+                                            /* (-0xd201000000010000^2 - 1) / 3 */+    POINTonE1_double(out, &t7);             /* 0xe */+    POINTonE1_dbl_n_add(out, 5,  &t11);     /* 0x1cb */+    POINTonE1_dbl_n_add(out, 3,  &t3);      /* 0xe5b */+    POINTonE1_dbl_n_add(out, 3,  in);       /* 0x72d9 */+    POINTonE1_dbl_n_add(out, 5,  &t3);      /* 0xe5b23 */+    POINTonE1_dbl_n_add(out, 18, &t85);     /* 0x396c8c0055 */+    POINTonE1_dbl_n_add(out, 8,  &t85);     /* 0x396c8c005555 */+    POINTonE1_dbl_n_add(out, 3,  &t7);      /* 0x1cb646002aaaf */+    POINTonE1_dbl_n_add(out, 7,  &t5);      /* 0xe5b23001555785 */+    POINTonE1_dbl_n_add(out, 5,  &t11);     /* 0x1cb646002aaaf0ab */+    POINTonE1_dbl_n_add(out, 41, &t85);     /* 0x396c8c005555e1560000000055 */+    POINTonE1_dbl_n_add(out, 8,  &t85);     /* 0x396c8c005555e156000000005555 */+    POINTonE1_dbl_n_add(out, 8,  &t85);     /* 0x396c8c005555e15600000000555555 */+    POINTonE1_dbl_n_add(out, 8,  &t85);     /* 0x396c8c005555e1560000000055555555 */+}+#endif++static bool_t POINTonE1_in_G1(const POINTonE1 *P)+{+    POINTonE1 t0, t1, t2;++    /* Bowe, S., "Faster subgroup checks for BLS12-381"                   */+    sigma(&t0, P);                        /* σ(P)                         */+    sigma(&t1, &t0);                      /* σ²(P)                        */++    POINTonE1_double(&t0, &t0);           /* 2σ(P)                        */+    POINTonE1_dadd(&t2, &t1, P, NULL);    /* P +  σ²(P)                   */+    POINTonE1_cneg(&t2, 1);               /* - P - σ²(P)                  */+    POINTonE1_dadd(&t2, &t2, &t0, NULL);  /* 2σ(P) - P - σ²(P)            */+    POINTonE1_times_zz_minus_1_div_by_3(  &t0, &t2);+    POINTonE1_cneg(&t1, 1);+    POINTonE1_dadd(&t0, &t0, &t1, NULL);  /* [(z²-1)/3](2σ(P) - P - σ²(P)) */+                                          /* - σ²(P) */+    return vec_is_zero(t0.Z, sizeof(t0.Z));+}+#else+static bool_t POINTonE1_in_G1(const POINTonE1 *P)+{+    POINTonE1 t0, t1;++    /* Scott, M., https://eprint.iacr.org/2021/1130 */+    POINTonE1_times_minus_z(&t0, P);+    POINTonE1_times_minus_z(&t1, &t0);+    POINTonE1_cneg(&t1, 1);             /* [-z²]P   */++    sigma(&t0, P);                      /* σ(P)     */+    sigma(&t0, &t0);                    /* σ²(P)    */++    return POINTonE1_is_equal(&t0, &t1);+}+#endif++int blst_p1_in_g1(const POINTonE1 *p)+{   return (int)POINTonE1_in_G1(p);   }++int blst_p1_affine_in_g1(const POINTonE1_affine *p)+{+    POINTonE1 P;++    vec_copy(P.X, p->X, 2*sizeof(P.X));+    vec_select(P.Z, p->X, BLS12_381_Rx.p, sizeof(P.Z),+                     vec_is_zero(p, sizeof(*p)));++    return (int)POINTonE1_in_G1(&P);+}
+ c-source/src/map_to_g2.c view
@@ -0,0 +1,444 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */++#include "point.h"+#include "fields.h"++/*+ * y^2 = x^3 + A'*x + B', isogenous one+ */+static const vec384x Aprime_E2 = {      /* 240*i */+  { 0 },+  { TO_LIMB_T(0xe53a000003135242), TO_LIMB_T(0x01080c0fdef80285),+    TO_LIMB_T(0xe7889edbe340f6bd), TO_LIMB_T(0x0b51375126310601),+    TO_LIMB_T(0x02d6985717c744ab), TO_LIMB_T(0x1220b4e979ea5467) }+};+static const vec384x Bprime_E2 = {      /* 1012 + 1012*i */+  { TO_LIMB_T(0x22ea00000cf89db2), TO_LIMB_T(0x6ec832df71380aa4),+    TO_LIMB_T(0x6e1b94403db5a66e), TO_LIMB_T(0x75bf3c53a79473ba),+    TO_LIMB_T(0x3dd3a569412c0a34), TO_LIMB_T(0x125cdb5e74dc4fd1) },+  { TO_LIMB_T(0x22ea00000cf89db2), TO_LIMB_T(0x6ec832df71380aa4),+    TO_LIMB_T(0x6e1b94403db5a66e), TO_LIMB_T(0x75bf3c53a79473ba),+    TO_LIMB_T(0x3dd3a569412c0a34), TO_LIMB_T(0x125cdb5e74dc4fd1) }+};++static void map_fp2_times_Zz(vec384x map[], const vec384x isogeny_map[],+                             const vec384x Zz_powers[], size_t n)+{+    while (n--)+        mul_fp2(map[n], isogeny_map[n], Zz_powers[n]);+}++static void map_fp2(vec384x acc, const vec384x x, const vec384x map[], size_t n)+{+    while (n--) {+        mul_fp2(acc, acc, x);+        add_fp2(acc, acc, map[n]);+    }+}++static void isogeny_map_to_E2(POINTonE2 *out, const POINTonE2 *p)+{+    /*+     * x = x_num / x_den, where+     * x_num = k_(1,3) * x'^3 + k_(1,2) * x'^2 + k_(1,1) * x' + k_(1,0)+     * ...+     */+    static const vec384x isogeny_map_x_num[] = {    /* (k_(1,*)<<384) % P   */+     {{ TO_LIMB_T(0x47f671c71ce05e62), TO_LIMB_T(0x06dd57071206393e),+        TO_LIMB_T(0x7c80cd2af3fd71a2), TO_LIMB_T(0x048103ea9e6cd062),+        TO_LIMB_T(0xc54516acc8d037f6), TO_LIMB_T(0x13808f550920ea41) },+      { TO_LIMB_T(0x47f671c71ce05e62), TO_LIMB_T(0x06dd57071206393e),+        TO_LIMB_T(0x7c80cd2af3fd71a2), TO_LIMB_T(0x048103ea9e6cd062),+        TO_LIMB_T(0xc54516acc8d037f6), TO_LIMB_T(0x13808f550920ea41) }},+     {{ 0 },+      { TO_LIMB_T(0x5fe55555554c71d0), TO_LIMB_T(0x873fffdd236aaaa3),+        TO_LIMB_T(0x6a6b4619b26ef918), TO_LIMB_T(0x21c2888408874945),+        TO_LIMB_T(0x2836cda7028cabc5), TO_LIMB_T(0x0ac73310a7fd5abd) }},+     {{ TO_LIMB_T(0x0a0c5555555971c3), TO_LIMB_T(0xdb0c00101f9eaaae),+        TO_LIMB_T(0xb1fb2f941d797997), TO_LIMB_T(0xd3960742ef416e1c),+        TO_LIMB_T(0xb70040e2c20556f4), TO_LIMB_T(0x149d7861e581393b) },+      { TO_LIMB_T(0xaff2aaaaaaa638e8), TO_LIMB_T(0x439fffee91b55551),+        TO_LIMB_T(0xb535a30cd9377c8c), TO_LIMB_T(0x90e144420443a4a2),+        TO_LIMB_T(0x941b66d3814655e2), TO_LIMB_T(0x0563998853fead5e) }},+     {{ TO_LIMB_T(0x40aac71c71c725ed), TO_LIMB_T(0x190955557a84e38e),+        TO_LIMB_T(0xd817050a8f41abc3), TO_LIMB_T(0xd86485d4c87f6fb1),+        TO_LIMB_T(0x696eb479f885d059), TO_LIMB_T(0x198e1a74328002d2) },+      { 0 }}+    };+    /* ...+     * x_den = x'^2 + k_(2,1) * x' + k_(2,0)+     */+    static const vec384x isogeny_map_x_den[] = {    /* (k_(2,*)<<384) % P   */+     {{ 0 },+      { TO_LIMB_T(0x1f3affffff13ab97), TO_LIMB_T(0xf25bfc611da3ff3e),+        TO_LIMB_T(0xca3757cb3819b208), TO_LIMB_T(0x3e6427366f8cec18),+        TO_LIMB_T(0x03977bc86095b089), TO_LIMB_T(0x04f69db13f39a952) }},+     {{ TO_LIMB_T(0x447600000027552e), TO_LIMB_T(0xdcb8009a43480020),+        TO_LIMB_T(0x6f7ee9ce4a6e8b59), TO_LIMB_T(0xb10330b7c0a95bc6),+        TO_LIMB_T(0x6140b1fcfb1e54b7), TO_LIMB_T(0x0381be097f0bb4e1) },+      { TO_LIMB_T(0x7588ffffffd8557d), TO_LIMB_T(0x41f3ff646e0bffdf),+        TO_LIMB_T(0xf7b1e8d2ac426aca), TO_LIMB_T(0xb3741acd32dbb6f8),+        TO_LIMB_T(0xe9daf5b9482d581f), TO_LIMB_T(0x167f53e0ba7431b8) }}+    };+    /*+     * y = y' * y_num / y_den, where+     * y_num = k_(3,3) * x'^3 + k_(3,2) * x'^2 + k_(3,1) * x' + k_(3,0)+     * ...+     */+    static const vec384x isogeny_map_y_num[] = {    /* (k_(3,*)<<384) % P   */+     {{ TO_LIMB_T(0x96d8f684bdfc77be), TO_LIMB_T(0xb530e4f43b66d0e2),+        TO_LIMB_T(0x184a88ff379652fd), TO_LIMB_T(0x57cb23ecfae804e1),+        TO_LIMB_T(0x0fd2e39eada3eba9), TO_LIMB_T(0x08c8055e31c5d5c3) },+      { TO_LIMB_T(0x96d8f684bdfc77be), TO_LIMB_T(0xb530e4f43b66d0e2),+        TO_LIMB_T(0x184a88ff379652fd), TO_LIMB_T(0x57cb23ecfae804e1),+        TO_LIMB_T(0x0fd2e39eada3eba9), TO_LIMB_T(0x08c8055e31c5d5c3) }},+     {{ 0 },+      { TO_LIMB_T(0xbf0a71c71c91b406), TO_LIMB_T(0x4d6d55d28b7638fd),+        TO_LIMB_T(0x9d82f98e5f205aee), TO_LIMB_T(0xa27aa27b1d1a18d5),+        TO_LIMB_T(0x02c3b2b2d2938e86), TO_LIMB_T(0x0c7d13420b09807f) }},+     {{ TO_LIMB_T(0xd7f9555555531c74), TO_LIMB_T(0x21cffff748daaaa8),+        TO_LIMB_T(0x5a9ad1866c9bbe46), TO_LIMB_T(0x4870a2210221d251),+        TO_LIMB_T(0x4a0db369c0a32af1), TO_LIMB_T(0x02b1ccc429ff56af) },+      { TO_LIMB_T(0xe205aaaaaaac8e37), TO_LIMB_T(0xfcdc000768795556),+        TO_LIMB_T(0x0c96011a8a1537dd), TO_LIMB_T(0x1c06a963f163406e),+        TO_LIMB_T(0x010df44c82a881e6), TO_LIMB_T(0x174f45260f808feb) }},+     {{ TO_LIMB_T(0xa470bda12f67f35c), TO_LIMB_T(0xc0fe38e23327b425),+        TO_LIMB_T(0xc9d3d0f2c6f0678d), TO_LIMB_T(0x1c55c9935b5a982e),+        TO_LIMB_T(0x27f6c0e2f0746764), TO_LIMB_T(0x117c5e6e28aa9054) },+      { 0 }}+    };+    /* ...+     * y_den = x'^3 + k_(4,2) * x'^2 + k_(4,1) * x' + k_(4,0)+     */+    static const vec384x isogeny_map_y_den[] = {    /* (k_(4,*)<<384) % P   */+     {{ TO_LIMB_T(0x0162fffffa765adf), TO_LIMB_T(0x8f7bea480083fb75),+        TO_LIMB_T(0x561b3c2259e93611), TO_LIMB_T(0x11e19fc1a9c875d5),+        TO_LIMB_T(0xca713efc00367660), TO_LIMB_T(0x03c6a03d41da1151) },+      { TO_LIMB_T(0x0162fffffa765adf), TO_LIMB_T(0x8f7bea480083fb75),+        TO_LIMB_T(0x561b3c2259e93611), TO_LIMB_T(0x11e19fc1a9c875d5),+        TO_LIMB_T(0xca713efc00367660), TO_LIMB_T(0x03c6a03d41da1151) }},+     {{ 0 },+      { TO_LIMB_T(0x5db0fffffd3b02c5), TO_LIMB_T(0xd713f52358ebfdba),+        TO_LIMB_T(0x5ea60761a84d161a), TO_LIMB_T(0xbb2c75a34ea6c44a),+        TO_LIMB_T(0x0ac6735921c1119b), TO_LIMB_T(0x0ee3d913bdacfbf6) }},+     {{ TO_LIMB_T(0x66b10000003affc5), TO_LIMB_T(0xcb1400e764ec0030),+        TO_LIMB_T(0xa73e5eb56fa5d106), TO_LIMB_T(0x8984c913a0fe09a9),+        TO_LIMB_T(0x11e10afb78ad7f13), TO_LIMB_T(0x05429d0e3e918f52) },+      { TO_LIMB_T(0x534dffffffc4aae6), TO_LIMB_T(0x5397ff174c67ffcf),+        TO_LIMB_T(0xbff273eb870b251d), TO_LIMB_T(0xdaf2827152870915),+        TO_LIMB_T(0x393a9cbaca9e2dc3), TO_LIMB_T(0x14be74dbfaee5748) }}+    };+    vec384x Zz_powers[3], map[3], xn, xd, yn, yd;++    /* lay down Z^2 powers in descending order                          */+    sqr_fp2(Zz_powers[2], p->Z);                       /* ZZ^1          */+    sqr_fp2(Zz_powers[1], Zz_powers[2]);               /* ZZ^2  1+1     */+    mul_fp2(Zz_powers[0], Zz_powers[2], Zz_powers[1]); /* ZZ^3  2+1     */++    map_fp2_times_Zz(map, isogeny_map_x_num, Zz_powers, 3);+    mul_fp2(xn, p->X, isogeny_map_x_num[3]);+    add_fp2(xn, xn, map[2]);+    map_fp2(xn, p->X, map, 2);++    map_fp2_times_Zz(map, isogeny_map_x_den, Zz_powers + 1, 2);+    add_fp2(xd, p->X, map[1]);+    map_fp2(xd, p->X, map, 1);+    mul_fp2(xd, xd, Zz_powers[2]);      /* xd *= Z^2                    */++    map_fp2_times_Zz(map, isogeny_map_y_num, Zz_powers, 3);+    mul_fp2(yn, p->X, isogeny_map_y_num[3]);+    add_fp2(yn, yn, map[2]);+    map_fp2(yn, p->X, map, 2);+    mul_fp2(yn, yn, p->Y);              /* yn *= Y                      */++    map_fp2_times_Zz(map, isogeny_map_y_den, Zz_powers, 3);+    add_fp2(yd, p->X, map[2]);+    map_fp2(yd, p->X, map, 2);+    mul_fp2(Zz_powers[2], Zz_powers[2], p->Z);+    mul_fp2(yd, yd, Zz_powers[2]);      /* yd *= Z^3                    */++    /* convert (xn, xd, yn, yd) to Jacobian coordinates                 */+    mul_fp2(out->Z, xd, yd);            /* Z = xd * yd                  */+    mul_fp2(out->X, xn, yd);+    mul_fp2(out->X, out->X, out->Z);    /* X = xn * xd * yd^2           */+    sqr_fp2(out->Y, out->Z);+    mul_fp2(out->Y, out->Y, xd);+    mul_fp2(out->Y, out->Y, yn);        /* Y = yn * xd^3 * yd^2         */+}++static void map_to_isogenous_E2(POINTonE2 *p, const vec384x u)+{+    static const vec384x minus_A = {+      { 0 },+      { TO_LIMB_T(0xd4c4fffffcec5869), TO_LIMB_T(0x1da3f3eed25bfd79),+        TO_LIMB_T(0x7fa833c5136fff67), TO_LIMB_T(0x59261433cd540cbd),+        TO_LIMB_T(0x48450f5f2b84682c), TO_LIMB_T(0x07e05d00bf959233) }+    };+    static const vec384x Z = {              /* -2 - i */+      { TO_LIMB_T(0x87ebfffffff9555c), TO_LIMB_T(0x656fffe5da8ffffa),+        TO_LIMB_T(0x0fd0749345d33ad2), TO_LIMB_T(0xd951e663066576f4),+        TO_LIMB_T(0xde291a3d41e980d3), TO_LIMB_T(0x0815664c7dfe040d) },+      { TO_LIMB_T(0x43f5fffffffcaaae), TO_LIMB_T(0x32b7fff2ed47fffd),+        TO_LIMB_T(0x07e83a49a2e99d69), TO_LIMB_T(0xeca8f3318332bb7a),+        TO_LIMB_T(0xef148d1ea0f4c069), TO_LIMB_T(0x040ab3263eff0206) }+    };+    static const vec384x recip_ZZZ = {      /* 1/(Z^3) */+      { TO_LIMB_T(0x65018f5c28f598eb), TO_LIMB_T(0xe6020417f022d916),+        TO_LIMB_T(0xd6327313288369c7), TO_LIMB_T(0x622ded8eb447156f),+        TO_LIMB_T(0xe52a2aee72c2a01f), TO_LIMB_T(0x089812fb8481ffe4) },+      { TO_LIMB_T(0x2574eb851eb8619f), TO_LIMB_T(0xdba2e97912925604),+        TO_LIMB_T(0x67e495a909e7a18e), TO_LIMB_T(0xdf2da23b8145b8f7),+        TO_LIMB_T(0xcf5d3728310ebf6d), TO_LIMB_T(0x11be446236f4c116) }+    };+    static const vec384x magic_ZZZ = {      /* 1/Z^3 = a + b*i */+                                            /* a^2 + b^2 */+      { TO_LIMB_T(0xaa7eb851eb8508e0), TO_LIMB_T(0x1c54fdf360989374),+        TO_LIMB_T(0xc87f2fc6e716c62e), TO_LIMB_T(0x0124aefb1f9efea7),+        TO_LIMB_T(0xb2f8be63e844865c), TO_LIMB_T(0x08b47f775a7ef35a) },+                                            /* (a^2 + b^2)^((P-3)/4) */+      { TO_LIMB_T(0xe4132bbd838cf70a), TO_LIMB_T(0x01d769ac83772c19),+        TO_LIMB_T(0xa83dd6e974c22e45), TO_LIMB_T(0xbc8ec3e777b08dff),+        TO_LIMB_T(0xc035c2042ecf5da3), TO_LIMB_T(0x073929e97f0850bf) }+    };+    static const vec384x ZxA = {            /* 240 - 480*i */+      { TO_LIMB_T(0xe53a000003135242), TO_LIMB_T(0x01080c0fdef80285),+        TO_LIMB_T(0xe7889edbe340f6bd), TO_LIMB_T(0x0b51375126310601),+        TO_LIMB_T(0x02d6985717c744ab), TO_LIMB_T(0x1220b4e979ea5467) },+      { TO_LIMB_T(0xa989fffff9d8b0d2), TO_LIMB_T(0x3b47e7dda4b7faf3),+        TO_LIMB_T(0xff50678a26dffece), TO_LIMB_T(0xb24c28679aa8197a),+        TO_LIMB_T(0x908a1ebe5708d058), TO_LIMB_T(0x0fc0ba017f2b2466) }+    };+    vec384x uu, tv2, tv4, x2n, gx1, gxd, y2;+#if 0+    vec384x xn, x1n, xd, y, y1, Zuu;+#else+# define xn     p->X+# define y      p->Y+# define xd     p->Z+# define x1n    xn+# define y1     y+# define Zuu    x2n+#endif+#define sgn0_fp2(a) (sgn0_pty_mont_384x((a), BLS12_381_P, p0) & 1)+    bool_t e1, e2;++    /*+     * as per map_to_curve() from poc/sswu_opt.sage at+     * https://github.com/cfrg/draft-irtf-cfrg-hash-to-curve+     * with 9mod16 twists...+     */+    /* x numerator variants                                             */+    sqr_fp2(uu, u);                     /* uu = u^2                     */+    mul_fp2(Zuu, Z, uu);                /* Zuu = Z * uu                 */+    sqr_fp2(tv2, Zuu);                  /* tv2 = Zuu^2                  */+    add_fp2(tv2, tv2, Zuu);             /* tv2 = tv2 + Zuu              */+    add_fp2(x1n, tv2, BLS12_381_Rx.p2); /* x1n = tv2 + 1                */+    mul_fp2(x1n, x1n, Bprime_E2);       /* x1n = x1n * B                */+    mul_fp2(x2n, Zuu, x1n);             /* x2n = Zuu * x1n              */++    /* x denumenator                                                    */+    mul_fp2(xd, minus_A, tv2);          /* xd = -A * tv2                */+    e1 = vec_is_zero(xd, sizeof(xd));   /* e1 = xd == 0                 */+    vec_select(xd, ZxA, xd, sizeof(xd), e1);    /*              # If xd == 0, set xd = Z*A */++    /* y numerators variants                                            */+    sqr_fp2(tv2, xd);                   /* tv2 = xd^2                   */+    mul_fp2(gxd, xd, tv2);              /* gxd = xd^3                   */+    mul_fp2(tv2, Aprime_E2, tv2);       /* tv2 = A * tv2                */+    sqr_fp2(gx1, x1n);                  /* gx1 = x1n^2                  */+    add_fp2(gx1, gx1, tv2);             /* gx1 = gx1 + tv2      # x1n^2 + A*xd^2 */+    mul_fp2(gx1, gx1, x1n);             /* gx1 = gx1 * x1n      # x1n^3 + A*x1n*xd^2 */+    mul_fp2(tv2, Bprime_E2, gxd);       /* tv2 = B * gxd                */+    add_fp2(gx1, gx1, tv2);             /* gx1 = gx1 + tv2      # x1^3 + A*x1*xd^2 + B*xd^3 */+    sqr_fp2(tv4, gxd);                  /* tv4 = gxd^2                  */+    mul_fp2(tv2, gx1, gxd);             /* tv2 = gx1 * gxd              */+    mul_fp2(tv4, tv4, tv2);             /* tv4 = tv4 * tv2      # gx1*gxd^3 */+    e2 = recip_sqrt_fp2(y1, tv4,        /* y1 = tv4^c1          # (gx1*gxd^3)^((p^2-9)/16) */+                        recip_ZZZ, magic_ZZZ);+    mul_fp2(y1, y1, tv2);               /* y1 = y1 * tv2        # gx1*gxd*y1 */+    mul_fp2(y2, y1, uu);                /* y2 = y1 * uu                 */+    mul_fp2(y2, y2, u);                 /* y2 = y2 * u                  */++    /* choose numerators                                                */+    vec_select(xn, x1n, x2n, sizeof(xn), e2);   /* xn = e2 ? x1n : x2n  */+    vec_select(y, y1, y2, sizeof(y), e2);       /* y  = e2 ? y1 : y2    */++    e1 = sgn0_fp2(u);+    e2 = sgn0_fp2(y);+    cneg_fp2(y, y, e1^e2);              /* fix sign of y                */+                                        /* return (xn, xd, y, 1)        */++    /* convert (xn, xd, y, 1) to Jacobian projective coordinates        */+    mul_fp2(p->X, xn, xd);              /* X = xn * xd                  */+    mul_fp2(p->Y, y, gxd);              /* Y = y * xd^3                 */+#ifndef xd+    vec_copy(p->Z, xd, sizeof(xd));     /* Z = xd                       */+#else+# undef xn+# undef y+# undef xd+# undef x1n+# undef y1+# undef Zuu+# undef tv4+#endif+#undef sgn0_fp2+}++#if 0+static const byte h_eff[] = {+    TO_BYTES(0xe8020005aaa95551), TO_BYTES(0x59894c0adebbf6b4),+    TO_BYTES(0xe954cbc06689f6a3), TO_BYTES(0x2ec0ec69d7477c1a),+    TO_BYTES(0x6d82bf015d1212b0), TO_BYTES(0x329c2f178731db95),+    TO_BYTES(0x9986ff031508ffe1), TO_BYTES(0x88e2a8e9145ad768),+    TO_BYTES(0x584c6a0ea91b3528), TO_BYTES(0x0bc69f08f2ee75b3)+};++static void clear_cofactor(POINTonE2 *out, const POINTonE2 *p)+{    POINTonE2_mult_w5(out, p, h_eff, 636);   }+#else+/*+ * As per suggestions in "7. Clearing the cofactor" at+ * https://tools.ietf.org/html/draft-irtf-cfrg-hash-to-curve-06+ */+static void POINTonE2_add_n_dbl(POINTonE2 *out, const POINTonE2 *p, size_t n)+{+    POINTonE2_dadd(out, out, p, NULL);+    while(n--)+        POINTonE2_double(out, out);+}++static void POINTonE2_times_minus_z(POINTonE2 *out, const POINTonE2 *in)+{+    POINTonE2_double(out, in);          /*      1: 0x2                  */+    POINTonE2_add_n_dbl(out, in, 2);    /*   2..4: 0x3..0xc             */+    POINTonE2_add_n_dbl(out, in, 3);    /*   5..8: 0xd..0x68            */+    POINTonE2_add_n_dbl(out, in, 9);    /*  9..18: 0x69..0xd200         */+    POINTonE2_add_n_dbl(out, in, 32);   /* 19..51: ..0xd20100000000     */+    POINTonE2_add_n_dbl(out, in, 16);   /* 52..68: ..0xd201000000010000 */+}++static void psi(POINTonE2 *out, const POINTonE2 *in);++static void clear_cofactor(POINTonE2 *out, const POINTonE2 *p)+{+    POINTonE2 t0, t1;++    /* A.Budroni, F.Pintore, "Efficient hash maps to G2 on BLS curves"  */+    POINTonE2_double(out, p);           /* out = 2P                     */+    psi(out, out);                      /* out = Ψ(2P)                  */+    psi(out, out);                      /* out = Ψ²(2P)                 */++    vec_copy(&t0, p, sizeof(t0));+    POINTonE2_cneg(&t0, 1);             /* t0 = -P                      */+    psi(&t1, &t0);                      /* t1 = -Ψ(P)                   */+    POINTonE2_dadd(out, out, &t0, NULL);/* out = Ψ²(2P) - P             */+    POINTonE2_dadd(out, out, &t1, NULL);/* out = Ψ²(2P) - P - Ψ(P)      */++    POINTonE2_times_minus_z(&t0, p);    /* t0 = [-z]P                   */+    POINTonE2_dadd(&t0, &t0, p, NULL);  /* t0 = [-z + 1]P               */+    POINTonE2_dadd(&t0, &t0, &t1, NULL);/* t0 = [-z + 1]P - Ψ(P)        */+    POINTonE2_times_minus_z(&t1, &t0);  /* t1 = [z² - z]P + [z]Ψ(P)     */+    POINTonE2_dadd(out, out, &t1, NULL);/* out = [z² - z - 1]P          */+                                        /*     + [z - 1]Ψ(P)            */+                                        /*     + Ψ²(2P)                 */+}+#endif++/*+ * |u|, |v| are expected to be in Montgomery representation+ */+static void map_to_g2(POINTonE2 *out, const vec384x u, const vec384x v)+{+    POINTonE2 p;++    map_to_isogenous_E2(&p, u);++    if (v != NULL) {+        map_to_isogenous_E2(out, v);    /* borrow |out|                 */+        POINTonE2_dadd(&p, &p, out, Aprime_E2);+    }++    isogeny_map_to_E2(&p, &p);          /* sprinkle isogenous powder    */+    clear_cofactor(out, &p);+}++void blst_map_to_g2(POINTonE2 *out, const vec384x u, const vec384x v)+{   map_to_g2(out, u, v);   }++static void Encode_to_G2(POINTonE2 *p, const unsigned char *msg, size_t msg_len,+                                       const unsigned char *DST, size_t DST_len,+                                       const unsigned char *aug, size_t aug_len)+{+    vec384x u[1];++    hash_to_field(u[0], 2, aug, aug_len, msg, msg_len, DST, DST_len);+    map_to_g2(p, u[0], NULL);+}++void blst_encode_to_g2(POINTonE2 *p, const unsigned char *msg, size_t msg_len,+                                     const unsigned char *DST, size_t DST_len,+                                     const unsigned char *aug, size_t aug_len)+{   Encode_to_G2(p, msg, msg_len, DST, DST_len, aug, aug_len);   }++static void Hash_to_G2(POINTonE2 *p, const unsigned char *msg, size_t msg_len,+                                     const unsigned char *DST, size_t DST_len,+                                     const unsigned char *aug, size_t aug_len)+{+    vec384x u[2];++    hash_to_field(u[0], 4, aug, aug_len, msg, msg_len, DST, DST_len);+    map_to_g2(p, u[0], u[1]);+}++void blst_hash_to_g2(POINTonE2 *p, const unsigned char *msg, size_t msg_len,+                                   const unsigned char *DST, size_t DST_len,+                                   const unsigned char *aug, size_t aug_len)+{   Hash_to_G2(p, msg, msg_len, DST, DST_len, aug, aug_len);   }++static bool_t POINTonE2_in_G2(const POINTonE2 *P)+{+#if 0+    POINTonE2 t0, t1, t2;++    /* Bowe, S., "Faster subgroup checks for BLS12-381"                 */+    psi(&t0, P);                        /* Ψ(P)                         */+    psi(&t0, &t0);                      /* Ψ²(P)                        */+    psi(&t1, &t0);                      /* Ψ³(P)                        */++    POINTonE2_times_minus_z(&t2, &t1);+    POINTonE2_dadd(&t0, &t0, &t2, NULL);+    POINTonE2_cneg(&t0, 1);+    POINTonE2_dadd(&t0, &t0, P, NULL);  /* [z]Ψ³(P) - Ψ²(P) + P         */++    return vec_is_zero(t0.Z, sizeof(t0.Z));+#else+    POINTonE2 t0, t1;++    /* Scott, M., https://eprint.iacr.org/2021/1130 */+    psi(&t0, P);                            /* Ψ(P) */++    POINTonE2_times_minus_z(&t1, P);+    POINTonE2_cneg(&t1, 1);                 /* [z]P */++    return POINTonE2_is_equal(&t0, &t1);+#endif+}++int blst_p2_in_g2(const POINTonE2 *p)+{   return (int)POINTonE2_in_G2(p);   }++int blst_p2_affine_in_g2(const POINTonE2_affine *p)+{+    POINTonE2 P;++    vec_copy(P.X, p->X, 2*sizeof(P.X));+    vec_select(P.Z, p->X, BLS12_381_Rx.p, sizeof(P.Z),+                     vec_is_zero(p, sizeof(*p)));++    return (int)POINTonE2_in_G2(&P);+}
+ c-source/src/multi_scalar.c view
@@ -0,0 +1,414 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */++#include "fields.h"+#include "point.h"++/*+ * Infinite point among inputs would be devastating. Shall we change it?+ */+#define POINTS_TO_AFFINE_IMPL(prefix, ptype, bits, field) \+static void ptype##s_to_affine(ptype##_affine dst[], \+                               const ptype *const points[], size_t npoints) \+{ \+    size_t i; \+    vec##bits *acc, ZZ, ZZZ; \+    const ptype *point = NULL; \+    const size_t stride = sizeof(ptype)==sizeof(POINTonE1) ? 1536 : 768; \+\+    while (npoints) { \+        const ptype *p, *const *walkback; \+        size_t delta = stride<npoints ? stride : npoints; \+\+        point = *points ? *points++ : point+1; \+        acc = (vec##bits *)dst; \+        vec_copy(acc++, point->Z, sizeof(vec##bits)); \+        for (i = 1; i < delta; i++, acc++) \+            point = *points ? *points++ : point+1, \+            mul_##field(acc[0], acc[-1], point->Z); \+\+        --acc; reciprocal_##field(acc[0], acc[0]); \+\+        walkback = points-1, p = point, --delta, dst += delta; \+        for (i = 0; i < delta; i++, acc--, dst--) { \+            mul_##field(acc[-1], acc[-1], acc[0]);  /* 1/Z        */\+            sqr_##field(ZZ, acc[-1]);               /* 1/Z^2      */\+            mul_##field(ZZZ, ZZ, acc[-1]);          /* 1/Z^3      */\+            mul_##field(acc[-1], p->Z, acc[0]);     \+            mul_##field(dst->X,  p->X, ZZ);         /* X = X'/Z^2 */\+            mul_##field(dst->Y,  p->Y, ZZZ);        /* Y = Y'/Z^3 */\+            p = (p == *walkback) ? *--walkback : p-1; \+        } \+        sqr_##field(ZZ, acc[0]);                    /* 1/Z^2      */\+        mul_##field(ZZZ, ZZ, acc[0]);               /* 1/Z^3      */\+        mul_##field(dst->X, p->X, ZZ);              /* X = X'/Z^2 */\+        mul_##field(dst->Y, p->Y, ZZZ);             /* Y = Y'/Z^3 */\+        ++delta, dst += delta, npoints -= delta; \+    } \+} \+\+void prefix##s_to_affine(ptype##_affine dst[], const ptype *const points[], \+                         size_t npoints) \+{   ptype##s_to_affine(dst, points, npoints);   }++POINTS_TO_AFFINE_IMPL(blst_p1, POINTonE1, 384, fp)+POINTS_TO_AFFINE_IMPL(blst_p2, POINTonE2, 384x, fp2)++/*+ * This is two-step multi-scalar multiplication procedure. First, given+ * a set of points you pre-compute a table for chosen windowing factor+ * [expressed in bits with value between 2 and 14], and then you pass+ * this table to the actual multiplication procedure along with scalars.+ * Idea is that the pre-computed table will be reused multiple times. In+ * which case multiplication runs faster than below Pippenger algorithm+ * implementation for up to ~16K points for wbits=8, naturally at the+ * expense of multi-megabyte table. One can trade even more memory for+ * performance, but each wbits increment doubles the memory requirement,+ * so at some point it gets prohibively large... For reference, without+ * reusing the table it's faster than Pippenger algorithm for up ~32+ * points [with wbits=5]...+ */++#define SCRATCH_SZ(ptype) (sizeof(ptype)==sizeof(POINTonE1) ? 8192 : 4096)++#define PRECOMPUTE_WBITS_IMPL(prefix, ptype, bits, field, one) \+static void ptype##_precompute_row_wbits(ptype row[], size_t wbits, \+                                         const ptype##_affine *point) \+{ \+    size_t i, j, n = (size_t)1 << (wbits-1); \+                                          /* row[-1] is implicit infinity */\+    vec_copy(&row[0], point, sizeof(*point));           /* row[0]=p*1     */\+    vec_copy(&row[0].Z, one, sizeof(row[0].Z));                             \+    ptype##_double(&row[1],  &row[0]);                  /* row[1]=p*(1+1) */\+    for (i = 2, j = 1; i < n; i += 2, j++) \+        ptype##_add_affine(&row[i], &row[i-1], point),  /* row[2]=p*(2+1) */\+        ptype##_double(&row[i+1], &row[j]);             /* row[3]=p*(2+2) */\+}                                                       /* row[4] ...     */\+\+static void ptype##s_to_affine_row_wbits(ptype##_affine dst[], ptype src[], \+                                         size_t wbits, size_t npoints) \+{ \+    size_t total = npoints << (wbits-1); \+    size_t nwin = (size_t)1 << (wbits-1); \+    size_t i, j; \+    vec##bits *acc, ZZ, ZZZ; \+\+    src += total; \+    acc = (vec##bits *)src; \+    vec_copy(acc++, one, sizeof(vec##bits)); \+    for (i = 0; i < npoints; i++) \+        for (j = nwin; --src, --j; acc++)    \+            mul_##field(acc[0], acc[-1], src->Z); \+\+    --acc; reciprocal_##field(acc[0], acc[0]); \+\+    for (i = 0; i < npoints; i++) { \+        vec_copy(dst++, src++, sizeof(ptype##_affine)); \+        for (j = 1; j < nwin; j++, acc--, src++, dst++) { \+            mul_##field(acc[-1], acc[-1], acc[0]);  /* 1/Z        */\+            sqr_##field(ZZ, acc[-1]);               /* 1/Z^2      */\+            mul_##field(ZZZ, ZZ, acc[-1]);          /* 1/Z^3      */\+            mul_##field(acc[-1], src->Z, acc[0]);                   \+            mul_##field(dst->X, src->X, ZZ);        /* X = X'/Z^2 */\+            mul_##field(dst->Y, src->Y, ZZZ);       /* Y = Y'/Z^3 */\+        } \+    } \+} \+\+/* flat |points[n]| can be placed at the end of |table[n<<(wbits-1)]| */\+static void ptype##s_precompute_wbits(ptype##_affine table[], size_t wbits, \+                                      const ptype##_affine *const points[], \+                                      size_t npoints) \+{ \+    size_t total = npoints << (wbits-1); \+    size_t nwin = (size_t)1 << (wbits-1); \+    size_t nmin = wbits>9 ? (size_t)1: (size_t)1 << (9-wbits); \+    size_t i, top = 0; \+    ptype *rows, *row; \+    const ptype##_affine *point = NULL; \+    size_t stride = ((512*1024)/sizeof(ptype##_affine)) >> wbits; \+    if (stride == 0) stride = 1; \+\+    while (npoints >= nmin) { \+        size_t limit = total - npoints; \+\+        if (top + (stride << wbits) > limit) { \+            stride = (limit - top) >> wbits;   \+            if (stride == 0) break;            \+        } \+        rows = row = (ptype *)(&table[top]); \+        for (i = 0; i < stride; i++, row += nwin) \+            point = *points ? *points++ : point+1, \+            ptype##_precompute_row_wbits(row, wbits, point); \+        ptype##s_to_affine_row_wbits(&table[top], rows, wbits, stride); \+        top += stride << (wbits-1); \+        npoints -= stride; \+    } \+    rows = row = alloca(2*sizeof(ptype##_affine) * npoints * nwin); \+    for (i = 0; i < npoints; i++, row += nwin) \+        point = *points ? *points++ : point+1, \+        ptype##_precompute_row_wbits(row, wbits, point); \+    ptype##s_to_affine_row_wbits(&table[top], rows, wbits, npoints); \+} \+\+size_t prefix##s_mult_wbits_precompute_sizeof(size_t wbits, size_t npoints) \+{ return (sizeof(ptype##_affine)*npoints) << (wbits-1); } \+void prefix##s_mult_wbits_precompute(ptype##_affine table[], size_t wbits, \+                                     const ptype##_affine *const points[], \+                                     size_t npoints) \+{ ptype##s_precompute_wbits(table, wbits, points, npoints); }++#define POINTS_MULT_WBITS_IMPL(prefix, ptype, bits, field, one) \+static void ptype##_gather_booth_wbits(ptype *p, const ptype##_affine row[], \+                                       size_t wbits, limb_t booth_idx) \+{ \+    bool_t booth_sign = (booth_idx >> wbits) & 1; \+    bool_t idx_is_zero; \+    static const ptype##_affine infinity = { 0 }; \+\+    booth_idx &= ((limb_t)1 << wbits) - 1; \+    idx_is_zero = is_zero(booth_idx); \+    booth_idx -= 1 ^ idx_is_zero; \+    vec_select(p, &infinity, &row[booth_idx], sizeof(row[0]), idx_is_zero); \+    ptype##_cneg(p, booth_sign); \+} \+\+static void ptype##s_mult_wbits(ptype *ret, const ptype##_affine table[], \+                                size_t wbits, size_t npoints, \+                                const byte *const scalars[], size_t nbits, \+                                ptype scratch[]) \+{ \+    limb_t wmask, wval; \+    size_t i, j, z, nbytes, window, nwin = (size_t)1 << (wbits-1); \+    const byte *scalar, *const *scalar_s = scalars; \+    const ptype##_affine *row = table; \+\+    size_t scratch_sz = SCRATCH_SZ(ptype); \+    if (scratch == NULL) { \+        scratch_sz /= 4; /* limit to 288K */ \+        scratch_sz = scratch_sz < npoints ? scratch_sz : npoints; \+        scratch = alloca(sizeof(ptype) * scratch_sz); \+    } \+\+    nbytes = (nbits + 7)/8; /* convert |nbits| to bytes */ \+    scalar = *scalar_s++; \+\+    /* top excess bits modulo target window size */ \+    window = nbits % wbits; /* yes, it may be zero */ \+    wmask = ((limb_t)1 << (window + 1)) - 1; \+\+    nbits -= window; \+    z = is_zero(nbits); \+    wval = (get_wval_limb(scalar, nbits - (z^1), wbits + (z^1)) << z) & wmask; \+    wval = booth_encode(wval, wbits); \+    ptype##_gather_booth_wbits(&scratch[0], row, wbits, wval); \+    row += nwin; \+\+    i = 1; vec_zero(ret, sizeof(*ret)); \+    while (nbits > 0) { \+        for (j = i; i < npoints; i++, j++, row += nwin) { \+            if (j == scratch_sz) \+                ptype##s_accumulate(ret, scratch, j), j = 0; \+            scalar = *scalar_s ? *scalar_s++ : scalar+nbytes; \+            wval = get_wval_limb(scalar, nbits - 1, window + 1) & wmask; \+            wval = booth_encode(wval, wbits); \+            ptype##_gather_booth_wbits(&scratch[j], row, wbits, wval); \+        } \+        ptype##s_accumulate(ret, scratch, j); \+\+        for (j = 0; j < wbits; j++) \+            ptype##_double(ret, ret); \+\+        window = wbits; \+        wmask = ((limb_t)1 << (window + 1)) - 1; \+        nbits -= window; \+        i = 0; row = table; scalar_s = scalars; \+    } \+\+    for (j = i; i < npoints; i++, j++, row += nwin) { \+        if (j == scratch_sz) \+            ptype##s_accumulate(ret, scratch, j), j = 0; \+        scalar = *scalar_s ? *scalar_s++ : scalar+nbytes; \+        wval = (get_wval_limb(scalar, 0, wbits) << 1) & wmask; \+        wval = booth_encode(wval, wbits); \+        ptype##_gather_booth_wbits(&scratch[j], row, wbits, wval); \+    } \+    ptype##s_accumulate(ret, scratch, j); \+} \+\+size_t prefix##s_mult_wbits_scratch_sizeof(size_t npoints) \+{ \+    const size_t scratch_sz = SCRATCH_SZ(ptype); \+    return sizeof(ptype) * (npoints < scratch_sz ? npoints : scratch_sz); \+} \+void prefix##s_mult_wbits(ptype *ret, const ptype##_affine table[], \+                          size_t wbits, size_t npoints, \+                          const byte *const scalars[], size_t nbits, \+                          ptype scratch[]) \+{ ptype##s_mult_wbits(ret, table, wbits, npoints, scalars, nbits, scratch); }++PRECOMPUTE_WBITS_IMPL(blst_p1, POINTonE1, 384, fp, BLS12_381_Rx.p)+POINTS_MULT_WBITS_IMPL(blst_p1, POINTonE1, 384, fp, BLS12_381_Rx.p)++PRECOMPUTE_WBITS_IMPL(blst_p2, POINTonE2, 384x, fp2, BLS12_381_Rx.p2)+POINTS_MULT_WBITS_IMPL(blst_p2, POINTonE2, 384x, fp2, BLS12_381_Rx.p2)++/*+ * Pippenger algorithm implementation, fastest option for larger amount+ * of points...+ */++static size_t pippenger_window_size(size_t npoints)+{+    size_t wbits;++    for (wbits=0; npoints>>=1; wbits++) ;++    return wbits>12 ? wbits-3 : (wbits>4 ? wbits-2 : (wbits ? 2 : 1));+}++#define DECLARE_PRIVATE_POINTXYZZ(ptype, bits) \+typedef struct { vec##bits X,Y,ZZZ,ZZ; } ptype##xyzz;++#define POINTS_MULT_PIPPENGER_IMPL(prefix, ptype) \+static void ptype##_integrate_buckets(ptype *out, ptype##xyzz buckets[], \+                                                  size_t wbits) \+{ \+    ptype##xyzz ret[1], acc[1]; \+    size_t n = (size_t)1 << wbits; \+\+    /* Calculate sum of x[i-1]*i for i=1 through 1<<|wbits|. */\+    vec_copy(acc, &buckets[--n], sizeof(acc)); \+    vec_copy(ret, &buckets[n], sizeof(ret)); \+    vec_zero(&buckets[n], sizeof(buckets[n])); \+    while (n--) { \+        ptype##xyzz_dadd(acc, acc, &buckets[n]); \+        ptype##xyzz_dadd(ret, ret, acc); \+        vec_zero(&buckets[n], sizeof(buckets[n])); \+    } \+    ptype##xyzz_to_Jacobian(out, ret); \+} \+\+static void ptype##_bucket(ptype##xyzz buckets[], limb_t booth_idx, \+                           size_t wbits, const ptype##_affine *p) \+{ \+    bool_t booth_sign = (booth_idx >> wbits) & 1; \+\+    booth_idx &= (1<<wbits) - 1; \+    if (booth_idx--) \+        ptype##xyzz_dadd_affine(&buckets[booth_idx], &buckets[booth_idx], \+                                                     p, booth_sign); \+} \+\+static void ptype##_prefetch(const ptype##xyzz buckets[], limb_t booth_idx, \+                             size_t wbits) \+{ \+    booth_idx &= (1<<wbits) - 1; \+    if (booth_idx--) \+        vec_prefetch(&buckets[booth_idx], sizeof(buckets[booth_idx])); \+} \+\+static void ptype##s_tile_pippenger(ptype *ret, \+                                    const ptype##_affine *const points[], \+                                    size_t npoints, \+                                    const byte *const scalars[], size_t nbits, \+                                    ptype##xyzz buckets[], \+                                    size_t bit0, size_t wbits, size_t cbits) \+{ \+    limb_t wmask, wval, wnxt; \+    size_t i, z, nbytes; \+    const byte *scalar = *scalars++; \+    const ptype##_affine *point = *points++; \+\+    nbytes = (nbits + 7)/8; /* convert |nbits| to bytes */ \+    wmask = ((limb_t)1 << (wbits+1)) - 1; \+    z = is_zero(bit0); \+    bit0 -= z^1; wbits += z^1; \+    wval = (get_wval_limb(scalar, bit0, wbits) << z) & wmask; \+    wval = booth_encode(wval, cbits); \+    scalar = *scalars ? *scalars++ : scalar+nbytes; \+    wnxt = (get_wval_limb(scalar, bit0, wbits) << z) & wmask; \+    wnxt = booth_encode(wnxt, cbits); \+    npoints--;  /* account for prefetch */ \+\+    ptype##_bucket(buckets, wval, cbits, point); \+    for (i = 1; i < npoints; i++) { \+        wval = wnxt; \+        scalar = *scalars ? *scalars++ : scalar+nbytes; \+        wnxt = (get_wval_limb(scalar, bit0, wbits) << z) & wmask; \+        wnxt = booth_encode(wnxt, cbits); \+        ptype##_prefetch(buckets, wnxt, cbits); \+        point = *points ? *points++ : point+1; \+        ptype##_bucket(buckets, wval, cbits, point); \+    } \+    point = *points ? *points++ : point+1; \+    ptype##_bucket(buckets, wnxt, cbits, point); \+    ptype##_integrate_buckets(ret, buckets, cbits - 1); \+} \+\+static void ptype##s_mult_pippenger(ptype *ret, \+                                    const ptype##_affine *const points[], \+                                    size_t npoints, \+                                    const byte *const scalars[], size_t nbits, \+                                    ptype##xyzz buckets[], size_t window) \+{ \+    size_t i, wbits, cbits, bit0 = nbits; \+    ptype tile[1]; \+\+    window = window ? window : pippenger_window_size(npoints); \+    vec_zero(buckets, sizeof(buckets[0]) << (window-1)); \+    vec_zero(ret, sizeof(*ret)); \+\+    /* top excess bits modulo target window size */ \+    wbits = nbits % window; /* yes, it may be zero */ \+    cbits = wbits + 1; \+    while (bit0 -= wbits) { \+        ptype##s_tile_pippenger(tile, points, npoints, scalars, nbits, \+                                      buckets, bit0, wbits, cbits); \+        ptype##_dadd(ret, ret, tile, NULL); \+        for (i = 0; i < window; i++) \+            ptype##_double(ret, ret); \+        cbits = wbits = window; \+    } \+    ptype##s_tile_pippenger(tile, points, npoints, scalars, nbits, \+                                  buckets, 0, wbits, cbits); \+    ptype##_dadd(ret, ret, tile, NULL); \+} \+\+size_t prefix##s_mult_pippenger_scratch_sizeof(size_t npoints) \+{   return sizeof(ptype##xyzz) << (pippenger_window_size(npoints)-1);   } \+void prefix##s_tile_pippenger(ptype *ret, \+                              const ptype##_affine *const points[], \+                              size_t npoints, \+                              const byte *const scalars[], size_t nbits, \+                              ptype##xyzz scratch[], \+                              size_t bit0, size_t window) \+{ \+    size_t wbits, cbits; \+\+    if (bit0 + window > nbits)  wbits = nbits - bit0, cbits = wbits + 1; \+    else                        wbits = cbits = window; \+    ptype##s_tile_pippenger(ret, points, npoints, scalars, nbits, scratch, \+                                 bit0, wbits, cbits); \+} \+void prefix##s_mult_pippenger(ptype *ret, \+                              const ptype##_affine *const points[], \+                              size_t npoints, \+                              const byte *const scalars[], size_t nbits, \+                              ptype##xyzz scratch[]) \+{ ptype##s_mult_pippenger(ret, points, npoints, scalars, nbits, scratch, 0); }++DECLARE_PRIVATE_POINTXYZZ(POINTonE1, 384)+POINTXYZZ_TO_JACOBIAN_IMPL(POINTonE1, 384, fp)+POINTXYZZ_DADD_IMPL(POINTonE1, 384, fp)+POINTXYZZ_DADD_AFFINE_IMPL(POINTonE1, 384, fp, BLS12_381_Rx.p)+POINTS_MULT_PIPPENGER_IMPL(blst_p1, POINTonE1)++DECLARE_PRIVATE_POINTXYZZ(POINTonE2, 384x)+POINTXYZZ_TO_JACOBIAN_IMPL(POINTonE2, 384x, fp2)+POINTXYZZ_DADD_IMPL(POINTonE2, 384x, fp2)+POINTXYZZ_DADD_AFFINE_IMPL(POINTonE2, 384x, fp2, BLS12_381_Rx.p2)+POINTS_MULT_PIPPENGER_IMPL(blst_p2, POINTonE2)
+ c-source/src/no_asm.h view
@@ -0,0 +1,1291 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */++#if LIMB_T_BITS==32+typedef unsigned long long llimb_t;+#endif++#if !defined(__STDC_VERSION__) || __STDC_VERSION__<199901 || defined(__STDC_NO_VLA__)+# error "unsupported compiler"+#endif++#if defined(__clang__)+# pragma GCC diagnostic ignored "-Wstatic-in-inline"+#endif++static void mul_mont_n(limb_t ret[], const limb_t a[], const limb_t b[],+                       const limb_t p[], limb_t n0, size_t n)+{+    llimb_t limbx;+    limb_t mask, borrow, mx, hi, tmp[n+1], carry;+    size_t i, j;++    for (mx=b[0], hi=0, i=0; i<n; i++) {+        limbx = (mx * (llimb_t)a[i]) + hi;+        tmp[i] = (limb_t)limbx;+        hi = (limb_t)(limbx >> LIMB_T_BITS);+    }+    mx = n0*tmp[0];+    tmp[i] = hi;++    for (carry=0, j=0; ; ) {+        limbx = (mx * (llimb_t)p[0]) + tmp[0];+        hi = (limb_t)(limbx >> LIMB_T_BITS);+        for (i=1; i<n; i++) {+            limbx = (mx * (llimb_t)p[i] + hi) + tmp[i];+            tmp[i-1] = (limb_t)limbx;+            hi = (limb_t)(limbx >> LIMB_T_BITS);+        }+        limbx = tmp[i] + (hi + (llimb_t)carry);+        tmp[i-1] = (limb_t)limbx;+        carry = (limb_t)(limbx >> LIMB_T_BITS);++        if (++j==n)+            break;++        for (mx=b[j], hi=0, i=0; i<n; i++) {+            limbx = (mx * (llimb_t)a[i] + hi) + tmp[i];+            tmp[i] = (limb_t)limbx;+            hi = (limb_t)(limbx >> LIMB_T_BITS);+        }+        mx = n0*tmp[0];+        limbx = hi + (llimb_t)carry;+        tmp[i] = (limb_t)limbx;+        carry = (limb_t)(limbx >> LIMB_T_BITS);+    }++    for (borrow=0, i=0; i<n; i++) {+        limbx = tmp[i] - (p[i] + (llimb_t)borrow);+        ret[i] = (limb_t)limbx;+        borrow = (limb_t)(limbx >> LIMB_T_BITS) & 1;+    }++    mask = carry - borrow;++    for(i=0; i<n; i++)+        ret[i] = (ret[i] & ~mask) | (tmp[i] & mask);+}++#define MUL_MONT_IMPL(bits) \+inline void mul_mont_##bits(vec##bits ret, const vec##bits a, \+                            const vec##bits b, const vec##bits p, limb_t n0) \+{   mul_mont_n(ret, a, b, p, n0, NLIMBS(bits));   } \+\+inline void sqr_mont_##bits(vec##bits ret, const vec##bits a, \+                            const vec##bits p, limb_t n0) \+{   mul_mont_n(ret, a, a, p, n0, NLIMBS(bits));   }++/*+ * 256-bit subroutines can handle arbitrary modulus, even non-"sparse",+ * but we have to harmonize the naming with assembly.+ */+#define mul_mont_256 mul_mont_sparse_256+#define sqr_mont_256 sqr_mont_sparse_256+MUL_MONT_IMPL(256)+#undef mul_mont_256+#undef sqr_mont_256+MUL_MONT_IMPL(384)++static void add_mod_n(limb_t ret[], const limb_t a[], const limb_t b[],+                      const limb_t p[], size_t n)+{+    llimb_t limbx;+    limb_t mask, carry, borrow, tmp[n];+    size_t i;++    for (carry=0, i=0; i<n; i++) {+        limbx = a[i] + (b[i] + (llimb_t)carry);+        tmp[i] = (limb_t)limbx;+        carry = (limb_t)(limbx >> LIMB_T_BITS);+    }++    for (borrow=0, i=0; i<n; i++) {+        limbx = tmp[i] - (p[i] + (llimb_t)borrow);+        ret[i] = (limb_t)limbx;+        borrow = (limb_t)(limbx >> LIMB_T_BITS) & 1;+    }++    mask = carry - borrow;++    for(i=0; i<n; i++)+        ret[i] = (ret[i] & ~mask) | (tmp[i] & mask);+}++#define ADD_MOD_IMPL(bits) \+inline void add_mod_##bits(vec##bits ret, const vec##bits a, \+                           const vec##bits b, const vec##bits p) \+{   add_mod_n(ret, a, b, p, NLIMBS(bits));   }++ADD_MOD_IMPL(256)+ADD_MOD_IMPL(384)++static void sub_mod_n(limb_t ret[], const limb_t a[], const limb_t b[],+                      const limb_t p[], size_t n)+{+    llimb_t limbx;+    limb_t mask, carry, borrow;+    size_t i;++    for (borrow=0, i=0; i<n; i++) {+        limbx = a[i] - (b[i] + (llimb_t)borrow);+        ret[i] = (limb_t)limbx;+        borrow = (limb_t)(limbx >> LIMB_T_BITS) & 1;+    }++    mask = 0 - borrow;++    for (carry=0, i=0; i<n; i++) {+        limbx = ret[i] + ((p[i] & mask) + (llimb_t)carry);+        ret[i] = (limb_t)limbx;+        carry = (limb_t)(limbx >> LIMB_T_BITS);+    }+}++#define SUB_MOD_IMPL(bits) \+inline void sub_mod_##bits(vec##bits ret, const vec##bits a, \+                           const vec##bits b, const vec##bits p) \+{   sub_mod_n(ret, a, b, p, NLIMBS(bits));   }++SUB_MOD_IMPL(256)+SUB_MOD_IMPL(384)++static void mul_by_3_mod_n(limb_t ret[], const limb_t a[], const limb_t p[],+                           size_t n)+{+    llimb_t limbx;+    limb_t mask, carry, borrow, tmp[n], two_a[n];+    size_t i;++    for (carry=0, i=0; i<n; i++) {+        limb_t a_i = a[i];+        tmp[i] = a_i<<1 | carry;+        carry = a_i>>(LIMB_T_BITS-1);+    }++    for (borrow=0, i=0; i<n; i++) {+        limbx = tmp[i] - (p[i] + (llimb_t)borrow);+        two_a[i] = (limb_t)limbx;+        borrow = (limb_t)(limbx >> LIMB_T_BITS) & 1;+    }++    mask = carry - borrow;++    for(i=0; i<n; i++)+        two_a[i] = (two_a[i] & ~mask) | (tmp[i] & mask);++    for (carry=0, i=0; i<n; i++) {+        limbx = a[i] + (two_a[i] + (llimb_t)carry);+        tmp[i] = (limb_t)limbx;+        carry = (limb_t)(limbx >> LIMB_T_BITS);+    }++    for (borrow=0, i=0; i<n; i++) {+        limbx = tmp[i] - (p[i] + (llimb_t)borrow);+        ret[i] = (limb_t)limbx;+        borrow = (limb_t)(limbx >> LIMB_T_BITS) & 1;+    }++    mask = carry - borrow;++    for(i=0; i<n; i++)+        ret[i] = (ret[i] & ~mask) | (tmp[i] & mask);+}++#define MUL_BY_3_MOD_IMPL(bits) \+inline void mul_by_3_mod_##bits(vec##bits ret, const vec##bits a, \+                                const vec##bits p) \+{   mul_by_3_mod_n(ret, a, p, NLIMBS(bits));   }++MUL_BY_3_MOD_IMPL(256)+MUL_BY_3_MOD_IMPL(384)++static void lshift_mod_n(limb_t ret[], const limb_t a[], size_t count,+                         const limb_t p[], size_t n)+{+    llimb_t limbx;+    limb_t mask, carry, borrow, tmp[n];+    size_t i;++    while (count--) {+        for (carry=0, i=0; i<n; i++) {+            limb_t a_i = a[i];+            tmp[i] = a_i<<1 | carry;+            carry = a_i>>(LIMB_T_BITS-1);+        }++        for (borrow=0, i=0; i<n; i++) {+            limbx = tmp[i] - (p[i] + (llimb_t)borrow);+            ret[i] = (limb_t)limbx;+            borrow = (limb_t)(limbx >> LIMB_T_BITS) & 1;+        }++        mask = carry - borrow;++        for(i=0; i<n; i++)+            ret[i] = (ret[i] & ~mask) | (tmp[i] & mask);++        a = ret;+    }+}++#define LSHIFT_MOD_IMPL(bits) \+inline void lshift_mod_##bits(vec##bits ret, const vec##bits a, size_t count, \+                              const vec##bits p) \+{   lshift_mod_n(ret, a, count, p, NLIMBS(bits));   }++LSHIFT_MOD_IMPL(256)+LSHIFT_MOD_IMPL(384)++static void cneg_mod_n(limb_t ret[], const limb_t a[], bool_t flag,+                       const limb_t p[], size_t n)+{+    llimb_t limbx;+    limb_t borrow, mask, tmp[n];+    size_t i;++    for (borrow=0, i=0; i<n; i++) {+        limbx = p[i] - (a[i] + (llimb_t)borrow);+        tmp[i] = (limb_t)limbx;+        borrow = (limb_t)(limbx >> LIMB_T_BITS) & 1;+    }++    flag &= vec_is_zero(a, sizeof(tmp)) ^ 1;+    mask = (limb_t)0 - flag;++    for(i=0; i<n; i++)+        ret[i] = (a[i] & ~mask) | (tmp[i] & mask);+}++#define CNEG_MOD_IMPL(bits) \+inline void cneg_mod_##bits(vec##bits ret, const vec##bits a, bool_t flag, \+                            const vec##bits p) \+{   cneg_mod_n(ret, a, flag, p, NLIMBS(bits));   }++CNEG_MOD_IMPL(256)+CNEG_MOD_IMPL(384)++static limb_t check_mod_n(const byte a[], const limb_t p[], size_t n)+{+    llimb_t limbx;+    limb_t borrow, ai, acc;+    size_t i, j;++    for (acc=borrow=0, i=0; i<n; i++) {+        for (ai=0, j=0; j<8*sizeof(limb_t); j+=8)+            ai |= (limb_t)(*a++) << j;+        acc |= ai;+        limbx = ai - (p[i] + (llimb_t)borrow);+        borrow = (limb_t)(limbx >> LIMB_T_BITS) & 1;+    }++    return borrow & (is_zero(acc) ^ 1);+}++#define CHECK_MOD_IMPL(bits) \+inline limb_t check_mod_##bits(const pow##bits a, const vec##bits p) \+{   return check_mod_n(a, p, NLIMBS(bits));   }++CHECK_MOD_IMPL(256)++static limb_t add_n_check_mod_n(byte ret[], const byte a[], const byte b[],+                                            const limb_t p[], size_t n)+{+    limb_t ret_[n], a_[n], b_[n], zero;++    limbs_from_le_bytes(a_, a, sizeof(a_));+    limbs_from_le_bytes(b_, b, sizeof(b_));++    add_mod_n(ret_, a_, b_, p, n);+    zero = vec_is_zero(ret_, sizeof(ret_));++    le_bytes_from_limbs(ret, ret_, sizeof(ret_));++    return zero^1;+}++#define ADD_N_CHECK_MOD_IMPL(bits) \+inline limb_t add_n_check_mod_##bits(pow##bits ret, const pow##bits a, \+                                     const pow##bits b, const vec##bits p) \+{   return add_n_check_mod_n(ret, a, b, p, NLIMBS(bits));   }++ADD_N_CHECK_MOD_IMPL(256)++static limb_t sub_n_check_mod_n(byte ret[], const byte a[], const byte b[],+                                            const limb_t p[], size_t n)+{+    limb_t ret_[n], a_[n], b_[n], zero;++    limbs_from_le_bytes(a_, a, sizeof(a_));+    limbs_from_le_bytes(b_, b, sizeof(b_));++    sub_mod_n(ret_, a_, b_, p, n);+    zero = vec_is_zero(ret_, sizeof(ret_));++    le_bytes_from_limbs(ret, ret_, sizeof(ret_));++    return zero^1;+}++#define SUB_N_CHECK_MOD_IMPL(bits) \+inline limb_t sub_n_check_mod_##bits(pow##bits ret, const pow##bits a, \+                                     const pow##bits b, const vec##bits p) \+{   return sub_n_check_mod_n(ret, a, b, p, NLIMBS(bits));   }++SUB_N_CHECK_MOD_IMPL(256)++static void from_mont_n(limb_t ret[], const limb_t a[],+                        const limb_t p[], limb_t n0, size_t n)+{+    llimb_t limbx;+    limb_t mask, borrow, mx, hi, tmp[n];+    size_t i, j;++    for (j=0; j<n; j++) {+        mx = n0*a[0];+        limbx = (mx * (llimb_t)p[0]) + a[0];+        hi = (limb_t)(limbx >> LIMB_T_BITS);+        for (i=1; i<n; i++) {+            limbx = (mx * (llimb_t)p[i] + hi) + a[i];+            tmp[i-1] = (limb_t)limbx;+            hi = (limb_t)(limbx >> LIMB_T_BITS);+        }+        tmp[i-1] = hi;+        a = tmp;+    }++    /* this is needed only if input can be non-fully-reduced */+    for (borrow=0, i=0; i<n; i++) {+        limbx = tmp[i] - (p[i] + (llimb_t)borrow);+        ret[i] = (limb_t)limbx;+        borrow = (limb_t)(limbx >> LIMB_T_BITS) & 1;+    }++    mask = 0 - borrow;++    for(i=0; i<n; i++)+        ret[i] = (ret[i] & ~mask) | (tmp[i] & mask);+}++#define FROM_MONT_IMPL(bits) \+inline void from_mont_##bits(vec##bits ret, const vec##bits a, \+                             const vec##bits p, limb_t n0) \+{   from_mont_n(ret, a, p, n0, NLIMBS(bits));   }++FROM_MONT_IMPL(256)+FROM_MONT_IMPL(384)++static void redc_mont_n(limb_t ret[], const limb_t a[],+                        const limb_t p[], limb_t n0, size_t n)+{+    llimb_t limbx;+    limb_t mask, carry, borrow, mx, hi, tmp[n];+    const limb_t *b = a;+    size_t i, j;++    for (j=0; j<n; j++) {+        mx = n0*b[0];+        limbx = (mx * (llimb_t)p[0]) + b[0];+        hi = (limb_t)(limbx >> LIMB_T_BITS);+        for (i=1; i<n; i++) {+            limbx = (mx * (llimb_t)p[i] + hi) + b[i];+            tmp[i-1] = (limb_t)limbx;+            hi = (limb_t)(limbx >> LIMB_T_BITS);+        }+        tmp[i-1] = hi;+        b = tmp;+    }++    for (carry=0, i=0; i<n; i++) {+        limbx = a[n+i] + (tmp[i] + (llimb_t)carry);+        tmp[i] = (limb_t)limbx;+        carry = (limb_t)(limbx >> LIMB_T_BITS);+    }++    for (borrow=0, i=0; i<n; i++) {+        limbx = tmp[i] - (p[i] + (llimb_t)borrow);+        ret[i] = (limb_t)limbx;+        borrow = (limb_t)(limbx >> LIMB_T_BITS) & 1;+    }++    mask = carry - borrow;++    for(i=0; i<n; i++)+        ret[i] = (ret[i] & ~mask) | (tmp[i] & mask);+}++#define REDC_MONT_IMPL(bits, bits2) \+inline void redc_mont_##bits(vec##bits ret, const vec##bits2 a, \+                             const vec##bits p, limb_t n0) \+{   redc_mont_n(ret, a, p, n0, NLIMBS(bits));   }++REDC_MONT_IMPL(256, 512)+REDC_MONT_IMPL(384, 768)++static void rshift_mod_n(limb_t ret[], const limb_t a[], size_t count,+                         const limb_t p[], size_t n)+{+    llimb_t limbx;+    limb_t mask, carry, limb, next;+    size_t i;++    while (count--) {+        mask = 0 - (a[0] & 1);+        for (carry=0, i=0; i<n; i++) {+            limbx = a[i] + ((p[i]&mask) + (llimb_t)carry);+            ret[i] = (limb_t)limbx;+            carry = (limb_t)(limbx >> LIMB_T_BITS);+        }++        for (next=ret[0], i=0; i<n-1; i++) {+            limb = next >> 1;+            next = ret[i+1];+            ret[i] = limb | next << (LIMB_T_BITS-1);+        }+        ret[i] = next >> 1 | carry << (LIMB_T_BITS-1);++        a = ret;+    }+}++#define RSHIFT_MOD_IMPL(bits) \+inline void rshift_mod_##bits(vec##bits ret, const vec##bits a, size_t count, \+                              const vec##bits p) \+{   rshift_mod_n(ret, a, count, p, NLIMBS(bits));   }++RSHIFT_MOD_IMPL(256)+RSHIFT_MOD_IMPL(384)++#define DIV_BY_2_MOD_IMPL(bits) \+inline void div_by_2_mod_##bits(vec##bits ret, const vec##bits a, \+                                const vec##bits p) \+{   rshift_mod_n(ret, a, 1, p, NLIMBS(bits));   }++DIV_BY_2_MOD_IMPL(384)++static limb_t sgn0_pty_mod_n(const limb_t a[], const limb_t p[], size_t n)+{+    llimb_t limbx;+    limb_t carry, borrow, ret, tmp[n];+    size_t i;++    ret = a[0] & 1; /* parity */++    for (carry=0, i=0; i<n; i++) {+        limb_t a_i = a[i];+        tmp[i] = a_i<<1 | carry;+        carry = a_i>>(LIMB_T_BITS-1);+    }++    for (borrow=0, i=0; i<n; i++) {+        limbx = tmp[i] - (p[i] + (llimb_t)borrow);+        borrow = (limb_t)(limbx >> LIMB_T_BITS) & 1;+    }++    ret |= ((carry - borrow) & 2) ^ 2;++    return ret;+}++inline limb_t sgn0_pty_mod_384(const vec384 a, const vec384 p)+{   return sgn0_pty_mod_n(a, p, NLIMBS(384));   }++inline limb_t sgn0_pty_mont_384(const vec384 a, const vec384 p, limb_t n0)+{+    vec384 tmp;++    from_mont_n(tmp, a, p, n0, NLIMBS(384));++    return sgn0_pty_mod_n(tmp, p, NLIMBS(384));+}++inline limb_t sgn0_pty_mod_384x(const vec384x a, const vec384 p)+{+    limb_t re, im, sign, prty;++    re = sgn0_pty_mod_n(a[0], p, NLIMBS(384));+    im = sgn0_pty_mod_n(a[1], p, NLIMBS(384));++    /* a->im!=0 ? sgn0(a->im) : sgn0(a->re) */+    sign = (limb_t)0 - vec_is_zero(a[1], sizeof(vec384));+    sign = (re & sign) | (im & ~sign);++    /* a->re==0 ? prty(a->im) : prty(a->re) */+    prty = (limb_t)0 - vec_is_zero(a[0], sizeof(vec384));+    prty = (im & prty) | (re & ~prty);++    return (sign & 2) | (prty & 1);+}++inline limb_t sgn0_pty_mont_384x(const vec384x a, const vec384 p, limb_t n0)+{+    vec384x tmp;++    from_mont_n(tmp[0], a[0], p, n0, NLIMBS(384));+    from_mont_n(tmp[1], a[1], p, n0, NLIMBS(384));++    return sgn0_pty_mod_384x(tmp, p);+}++void mul_mont_384x(vec384x ret, const vec384x a, const vec384x b,+                          const vec384 p, limb_t n0)+{+    vec384 aa, bb, cc;++    add_mod_n(aa, a[0], a[1], p, NLIMBS(384));+    add_mod_n(bb, b[0], b[1], p, NLIMBS(384));+    mul_mont_n(bb, bb, aa, p, n0, NLIMBS(384));+    mul_mont_n(aa, a[0], b[0], p, n0, NLIMBS(384));+    mul_mont_n(cc, a[1], b[1], p, n0, NLIMBS(384));+    sub_mod_n(ret[0], aa, cc, p, NLIMBS(384));+    sub_mod_n(ret[1], bb, aa, p, NLIMBS(384));+    sub_mod_n(ret[1], ret[1], cc, p, NLIMBS(384));+}++/*+ * mul_mont_n without final conditional subtraction, which implies+ * that modulus is one bit short, which in turn means that there are+ * no carries to handle between iterations...+ */+static void mul_mont_nonred_n(limb_t ret[], const limb_t a[], const limb_t b[],+                              const limb_t p[], limb_t n0, size_t n)+{+    llimb_t limbx;+    limb_t mx, hi, tmp[n+1];+    size_t i, j;++    for (mx=b[0], hi=0, i=0; i<n; i++) {+        limbx = (mx * (llimb_t)a[i]) + hi;+        tmp[i] = (limb_t)limbx;+        hi = (limb_t)(limbx >> LIMB_T_BITS);+    }+    mx = n0*tmp[0];+    tmp[i] = hi;++    for (j=0; ; ) {+        limbx = (mx * (llimb_t)p[0]) + tmp[0];+        hi = (limb_t)(limbx >> LIMB_T_BITS);+        for (i=1; i<n; i++) {+            limbx = (mx * (llimb_t)p[i] + hi) + tmp[i];+            tmp[i-1] = (limb_t)limbx;+            hi = (limb_t)(limbx >> LIMB_T_BITS);+        }+        tmp[i-1] = tmp[i] + hi;++        if (++j==n)+            break;++        for (mx=b[j], hi=0, i=0; i<n; i++) {+            limbx = (mx * (llimb_t)a[i] + hi) + tmp[i];+            tmp[i] = (limb_t)limbx;+            hi = (limb_t)(limbx >> LIMB_T_BITS);+        }+        mx = n0*tmp[0];+        tmp[i] = hi;+    }++    vec_copy(ret, tmp, sizeof(tmp)-sizeof(limb_t));+}++void sqr_n_mul_mont_383(vec384 ret, const vec384 a, size_t count,+                        const vec384 p, limb_t n0, const vec384 b)+{+    while(count--) {+        mul_mont_nonred_n(ret, a, a, p, n0, NLIMBS(384));+        a = ret;+    }+    mul_mont_n(ret, ret, b, p, n0, NLIMBS(384));+}++void sqr_mont_382x(vec384x ret, const vec384x a,+                          const vec384 p, limb_t n0)+{+    llimb_t limbx;+    limb_t mask, carry, borrow;+    size_t i;+    vec384 t0, t1;++    /* "add_mod_n(t0, a[0], a[1], p, NLIMBS(384));" */+    for (carry=0, i=0; i<NLIMBS(384); i++) {+        limbx = a[0][i] + (a[1][i] + (llimb_t)carry);+        t0[i] = (limb_t)limbx;+        carry = (limb_t)(limbx >> LIMB_T_BITS);+    }++    /* "sub_mod_n(t1, a[0], a[1], p, NLIMBS(384));" */+    for (borrow=0, i=0; i<NLIMBS(384); i++) {+        limbx = a[0][i] - (a[1][i] + (llimb_t)borrow);+        t1[i] = (limb_t)limbx;+        borrow = (limb_t)(limbx >> LIMB_T_BITS) & 1;+    }+    mask = 0 - borrow;++    /* "mul_mont_n(ret[1], a[0], a[1], p, n0, NLIMBS(384));" */+    mul_mont_nonred_n(ret[1], a[0], a[1], p, n0, NLIMBS(384));++    /* "add_mod_n(ret[1], ret[1], ret[1], p, NLIMBS(384));" */+    for (carry=0, i=0; i<NLIMBS(384); i++) {+        limb_t a_i = ret[1][i];+        ret[1][i] = a_i<<1 | carry;+        carry = a_i>>(LIMB_T_BITS-1);+    }++    /* "mul_mont_n(ret[0], t0, t1, p, n0, NLIMBS(384));" */+    mul_mont_nonred_n(ret[0], t0, t1, p, n0, NLIMBS(384));++    /* account for t1's sign... */+    for (borrow=0, i=0; i<NLIMBS(384); i++) {+        limbx = ret[0][i] - ((t0[i] & mask) + (llimb_t)borrow);+        ret[0][i] = (limb_t)limbx;+        borrow = (limb_t)(limbx >> LIMB_T_BITS) & 1;+    }+    mask = 0 - borrow;+    for (carry=0, i=0; i<NLIMBS(384); i++) {+        limbx = ret[0][i] + ((p[i] & mask) + (llimb_t)carry);+        ret[0][i] = (limb_t)limbx;+        carry = (limb_t)(limbx >> LIMB_T_BITS);+    }+}++#define MSB(x) ((x) >> (LIMB_T_BITS-1))++static size_t num_bits(limb_t l)+{+    limb_t x, mask;+    size_t bits = is_zero(l) ^ 1;++    if (sizeof(limb_t) == 8) {+        x = l >> (32 & (8*sizeof(limb_t)-1));+        mask = 0 - MSB(0 - x);+        bits += 32 & mask;+        l ^= (x ^ l) & mask;+    }++    x = l >> 16;+    mask = 0 - MSB(0 - x);+    bits += 16 & mask;+    l ^= (x ^ l) & mask;++    x = l >> 8;+    mask = 0 - MSB(0 - x);+    bits += 8 & mask;+    l ^= (x ^ l) & mask;++    x = l >> 4;+    mask = 0 - MSB(0 - x);+    bits += 4 & mask;+    l ^= (x ^ l) & mask;++    x = l >> 2;+    mask = 0 - MSB(0 - x);+    bits += 2 & mask;+    l ^= (x ^ l) & mask;++    bits += l >> 1;++    return bits;+}++#if defined(__clang_major__) && __clang_major__>7+__attribute__((optnone))+#endif+static limb_t lshift_2(limb_t hi, limb_t lo, size_t l)+{+    size_t r = LIMB_T_BITS - l;+    limb_t mask = 0 - (is_zero(l)^1);+    return (hi << (l&(LIMB_T_BITS-1))) | ((lo & mask) >> (r&(LIMB_T_BITS-1)));+}++/*+ * https://eprint.iacr.org/2020/972 with 'k' being LIMB_T_BITS-1.+ */+static void ab_approximation_n(limb_t a_[2], const limb_t a[],+                               limb_t b_[2], const limb_t b[], size_t n)+{+    limb_t a_hi, a_lo, b_hi, b_lo, mask;+    size_t i;++    i = n-1;+    a_hi = a[i],    a_lo = a[i-1];+    b_hi = b[i],    b_lo = b[i-1];+    for (i--; --i;) {+        mask = 0 - is_zero(a_hi | b_hi);+        a_hi = ((a_lo ^ a_hi) & mask) ^ a_hi;+        b_hi = ((b_lo ^ b_hi) & mask) ^ b_hi;+        a_lo = ((a[i] ^ a_lo) & mask) ^ a_lo;+        b_lo = ((b[i] ^ b_lo) & mask) ^ b_lo;+    }+    i = LIMB_T_BITS - num_bits(a_hi | b_hi);+    /* |i| can be LIMB_T_BITS if all a[2..]|b[2..] were zeros */++    a_[0] = a[0], a_[1] = lshift_2(a_hi, a_lo, i);+    b_[0] = b[0], b_[1] = lshift_2(b_hi, b_lo, i);+}++typedef struct { limb_t f0, g0, f1, g1; } factors;++static void inner_loop_n(factors *fg, const limb_t a_[2], const limb_t b_[2],+                         size_t n)+{+    llimb_t limbx;+    limb_t f0 = 1, g0 = 0, f1 = 0, g1 = 1;+    limb_t a_lo, a_hi, b_lo, b_hi, t_lo, t_hi, odd, borrow, xorm;++    a_lo = a_[0], a_hi = a_[1];+    b_lo = b_[0], b_hi = b_[1];++    while(n--) {+        odd = 0 - (a_lo&1);++        /* a_ -= b_ if a_ is odd */+        t_lo = a_lo, t_hi = a_hi;+        limbx = a_lo - (llimb_t)(b_lo & odd);+        a_lo = (limb_t)limbx;+        borrow = (limb_t)(limbx >> LIMB_T_BITS) & 1;+        limbx = a_hi - ((llimb_t)(b_hi & odd) + borrow);+        a_hi = (limb_t)limbx;+        borrow = (limb_t)(limbx >> LIMB_T_BITS);++        /* negate a_-b_ if it borrowed */+        a_lo ^= borrow;+        a_hi ^= borrow;+        limbx = a_lo + (llimb_t)(borrow & 1);+        a_lo = (limb_t)limbx;+        a_hi += (limb_t)(limbx >> LIMB_T_BITS) & 1;++        /* b_=a_ if a_-b_ borrowed */+        b_lo = ((t_lo ^ b_lo) & borrow) ^ b_lo;+        b_hi = ((t_hi ^ b_hi) & borrow) ^ b_hi;++        /* exchange f0 and f1 if a_-b_ borrowed */+        xorm = (f0 ^ f1) & borrow;+        f0 ^= xorm;+        f1 ^= xorm;++        /* exchange g0 and g1 if a_-b_ borrowed */+        xorm = (g0 ^ g1) & borrow;+        g0 ^= xorm;+        g1 ^= xorm;++        /* subtract if a_ was odd */+        f0 -= f1 & odd;+        g0 -= g1 & odd;++        f1 <<= 1;+        g1 <<= 1;+        a_lo >>= 1; a_lo |= a_hi << (LIMB_T_BITS-1);+        a_hi >>= 1;+    }++    fg->f0 = f0, fg->g0 = g0, fg->f1 = f1, fg->g1= g1;+}++static limb_t cneg_n(limb_t ret[], const limb_t a[], limb_t neg, size_t n)+{+    llimb_t limbx = 0;+    limb_t carry;+    size_t i;++    for (carry=neg&1, i=0; i<n; i++) {+        limbx = (llimb_t)(a[i] ^ neg) + carry;+        ret[i] = (limb_t)limbx;+        carry = (limb_t)(limbx >> LIMB_T_BITS);+    }++    return 0 - MSB((limb_t)limbx);+}++static limb_t add_n(limb_t ret[], const limb_t a[], limb_t b[], size_t n)+{+    llimb_t limbx;+    limb_t carry;+    size_t i;++    for (carry=0, i=0; i<n; i++) {+        limbx = a[i] + (b[i] + (llimb_t)carry);+        ret[i] = (limb_t)limbx;+        carry = (limb_t)(limbx >> LIMB_T_BITS);+    }++    return carry;+}++static limb_t umul_n(limb_t ret[], const limb_t a[], limb_t b, size_t n)+{+    llimb_t limbx;+    limb_t hi;+    size_t i;++    for (hi=0, i=0; i<n; i++) {+        limbx = (b * (llimb_t)a[i]) + hi;+        ret[i] = (limb_t)limbx;+        hi = (limb_t)(limbx >> LIMB_T_BITS);+    }++    return hi;+}++static limb_t smul_n_shift_n(limb_t ret[], const limb_t a[], limb_t *f_,+                                           const limb_t b[], limb_t *g_,+                                           size_t n)+{+    limb_t a_[n+1], b_[n+1], f, g, neg, carry, hi;+    size_t i;++    /* |a|*|f_| */+    f = *f_;+    neg = 0 - MSB(f);+    f = (f ^ neg) - neg;            /* ensure |f| is positive */+    (void)cneg_n(a_, a, neg, n);+    hi = umul_n(a_, a_, f, n);+    a_[n] = hi - (f & neg);++    /* |b|*|g_| */+    g = *g_;+    neg = 0 - MSB(g);+    g = (g ^ neg) - neg;            /* ensure |g| is positive */+    (void)cneg_n(b_, b, neg, n);+    hi = umul_n(b_, b_, g, n);+    b_[n] = hi - (g & neg);++    /* |a|*|f_| + |b|*|g_| */+    (void)add_n(a_, a_, b_, n+1);++    /* (|a|*|f_| + |b|*|g_|) >> k */+    for (carry=a_[0], i=0; i<n; i++) {+        hi = carry >> (LIMB_T_BITS-2);+        carry = a_[i+1];+        ret[i] = hi | (carry << 2);+    }++    /* ensure result is non-negative, fix up |f_| and |g_| accordingly */+    neg = 0 - MSB(carry);+    *f_ = (*f_ ^ neg) - neg;+    *g_ = (*g_ ^ neg) - neg;+    (void)cneg_n(ret, ret, neg, n);++    return neg;+}++static limb_t smul_2n(limb_t ret[], const limb_t u[], limb_t f,+                                    const limb_t v[], limb_t g, size_t n)+{+    limb_t u_[n], v_[n], neg, hi;++    /* |u|*|f_| */+    neg = 0 - MSB(f);+    f = (f ^ neg) - neg;            /* ensure |f| is positive */+    neg = cneg_n(u_, u, neg, n);+    hi = umul_n(u_, u_, f, n) - (f&neg);++    /* |v|*|g_| */+    neg = 0 - MSB(g);+    g = (g ^ neg) - neg;            /* ensure |g| is positive */+    neg = cneg_n(v_, v, neg, n);+    hi += umul_n(v_, v_, g, n) - (g&neg);++    /* |u|*|f_| + |v|*|g_| */+    hi += add_n(ret, u_, v_, n);++    return hi;+}++static void ct_inverse_mod_n(limb_t ret[], const limb_t inp[],+                             const limb_t mod[], const limb_t modx[], size_t n)+{+    llimb_t limbx;+    limb_t a[n], b[n], u[2*n], v[2*n], t[2*n];+    limb_t a_[2], b_[2], sign, carry, top;+    factors fg;+    size_t i;++    vec_copy(a, inp, sizeof(a));+    vec_copy(b, mod, sizeof(b));+    vec_zero(u, sizeof(u)); u[0] = 1;+    vec_zero(v, sizeof(v));++    for (i=0; i<(2*n*LIMB_T_BITS)/(LIMB_T_BITS-2); i++) {+        ab_approximation_n(a_, a, b_, b, n);+        inner_loop_n(&fg, a_, b_, LIMB_T_BITS-2);+        (void)smul_n_shift_n(t, a, &fg.f0, b, &fg.g0, n);+        (void)smul_n_shift_n(b, a, &fg.f1, b, &fg.g1, n);+        vec_copy(a, t, sizeof(a));+        smul_2n(t, u, fg.f0, v, fg.g0, 2*n);+        smul_2n(v, u, fg.f1, v, fg.g1, 2*n);+        vec_copy(u, t, sizeof(u));+    }++    inner_loop_n(&fg, a, b, (2*n*LIMB_T_BITS)%(LIMB_T_BITS-2));+    top = smul_2n(ret, u, fg.f1, v, fg.g1, 2*n);++    sign = 0 - MSB(top);    /* top is 1, 0 or -1 */+    for (carry=0, i=0; i<n; i++) {+        limbx = ret[n+i] + ((modx[i] & sign) + (llimb_t)carry);+        ret[n+i] = (limb_t)limbx;+        carry = (limb_t)(limbx >> LIMB_T_BITS);+    }+    top += carry;+    sign = 0 - top;         /* top is 1, 0 or -1 */+    top |= sign;+    for (i=0; i<n; i++)+        a[i] = modx[i] & top;+    (void)cneg_n(a, a, 0 - MSB(sign), n);+    add_n(ret+n, ret+n, a, n);+}++#define CT_INVERSE_MOD_IMPL(bits) \+inline void ct_inverse_mod_##bits(vec##bits ret, const vec##bits inp, \+                                  const vec##bits mod, const vec##bits modx) \+{   ct_inverse_mod_n(ret, inp, mod, modx, NLIMBS(bits));   }++CT_INVERSE_MOD_IMPL(256)+CT_INVERSE_MOD_IMPL(384)++/*+ * Copy of inner_loop_n above, but with |L| updates.+ */+static limb_t legendre_loop_n(limb_t L, factors *fg, const limb_t a_[2],+                              const limb_t b_[2], size_t n)+{+    llimb_t limbx;+    limb_t f0 = 1, g0 = 0, f1 = 0, g1 = 1;+    limb_t a_lo, a_hi, b_lo, b_hi, t_lo, t_hi, odd, borrow, xorm;++    a_lo = a_[0], a_hi = a_[1];+    b_lo = b_[0], b_hi = b_[1];++    while(n--) {+        odd = 0 - (a_lo&1);++        /* a_ -= b_ if a_ is odd */+        t_lo = a_lo, t_hi = a_hi;+        limbx = a_lo - (llimb_t)(b_lo & odd);+        a_lo = (limb_t)limbx;+        borrow = (limb_t)(limbx >> LIMB_T_BITS) & 1;+        limbx = a_hi - ((llimb_t)(b_hi & odd) + borrow);+        a_hi = (limb_t)limbx;+        borrow = (limb_t)(limbx >> LIMB_T_BITS);++        L += ((t_lo & b_lo) >> 1) & borrow;++        /* negate a_-b_ if it borrowed */+        a_lo ^= borrow;+        a_hi ^= borrow;+        limbx = a_lo + (llimb_t)(borrow & 1);+        a_lo = (limb_t)limbx;+        a_hi += (limb_t)(limbx >> LIMB_T_BITS) & 1;++        /* b_=a_ if a_-b_ borrowed */+        b_lo = ((t_lo ^ b_lo) & borrow) ^ b_lo;+        b_hi = ((t_hi ^ b_hi) & borrow) ^ b_hi;++        /* exchange f0 and f1 if a_-b_ borrowed */+        xorm = (f0 ^ f1) & borrow;+        f0 ^= xorm;+        f1 ^= xorm;++        /* exchange g0 and g1 if a_-b_ borrowed */+        xorm = (g0 ^ g1) & borrow;+        g0 ^= xorm;+        g1 ^= xorm;++        /* subtract if a_ was odd */+        f0 -= f1 & odd;+        g0 -= g1 & odd;++        f1 <<= 1;+        g1 <<= 1;+        a_lo >>= 1; a_lo |= a_hi << (LIMB_T_BITS-1);+        a_hi >>= 1;++        L += (b_lo + 2) >> 2;+    }++    fg->f0 = f0, fg->g0 = g0, fg->f1 = f1, fg->g1 = g1;++    return L;+}++static bool_t ct_is_sqr_mod_n(const limb_t inp[], const limb_t mod[], size_t n)+{+    limb_t a[n], b[n], t[n];+    limb_t a_[2], b_[2], neg, L = 0;+    factors fg;+    size_t i;++    vec_copy(a, inp, sizeof(a));+    vec_copy(b, mod, sizeof(b));++    for (i=0; i<(2*n*LIMB_T_BITS)/(LIMB_T_BITS-2); i++) {+        ab_approximation_n(a_, a, b_, b, n);+        L = legendre_loop_n(L, &fg, a_, b_, LIMB_T_BITS-2);+        neg = smul_n_shift_n(t, a, &fg.f0, b, &fg.g0, n);+        (void)smul_n_shift_n(b, a, &fg.f1, b, &fg.g1, n);+        vec_copy(a, t, sizeof(a));+        L += (b[0] >> 1) & neg;+    }++    L = legendre_loop_n(L, &fg, a, b, (2*n*LIMB_T_BITS)%(LIMB_T_BITS-2));++    return (L & 1) ^ 1;+}++#define CT_IS_SQR_MOD_IMPL(bits) \+inline bool_t ct_is_square_mod_##bits(const vec##bits inp, \+                                      const vec##bits mod) \+{   return ct_is_sqr_mod_n(inp, mod, NLIMBS(bits));   }++CT_IS_SQR_MOD_IMPL(384)++/*+ * |div_top| points at two most significant limbs of the dividend, |d_hi|+ * and |d_lo| are two most significant limbs of the divisor. If divisor+ * is only one limb, it is to be passed in |d_hi| with zero in |d_lo|.+ * The divisor is required to be "bitwise left-aligned," and dividend's+ * top limbs to be not larger than the divisor's. The latter limitation+ * can be problematic in the first iteration of multi-precision division,+ * where in most general case the condition would have to be "smaller."+ * The subroutine considers four limbs, two of which are "overlapping,"+ * hence the name... Another way to look at it is to think of the pair+ * of the dividend's limbs being suffixed with a zero:+ *   +-------+-------+-------++ * R |       |       |   0   |+ *   +-------+-------+-------++ *           +-------+-------++ * D         |       |       |+ *           +-------+-------++ */+limb_t div_3_limbs(const limb_t div_top[2], limb_t d_lo, limb_t d_hi)+{+    llimb_t Rx;+    limb_t r_lo = div_top[0], r_hi = div_top[1];+    limb_t Q = 0, mask, borrow, rx;+    size_t i;++    for (i = 0; i < LIMB_T_BITS; i++) {+        /* "borrow, Rx = R - D" */+        Rx = (llimb_t)r_lo - d_lo;+        rx = (limb_t)Rx;+        borrow = (limb_t)(Rx >> LIMB_T_BITS) & 1;+        Rx = r_hi - (d_hi + (llimb_t)borrow);+        borrow = (limb_t)(Rx >> LIMB_T_BITS);++        /* "if (R >= D) R -= D" */+        r_lo = ((r_lo ^ rx) & borrow) ^ rx;+        rx = (limb_t)Rx;+        r_hi = ((r_hi ^ rx) & borrow) ^ rx;++        Q <<= 1;+        Q |= ~borrow & 1;++        /* "D >>= 1" */+        d_lo >>= 1; d_lo |= d_hi << (LIMB_T_BITS - 1);+        d_hi >>= 1;+    }++    mask = 0 - MSB(Q);  /* does it overflow? */++    /* "borrow, Rx = R - D" */+    Rx = (llimb_t)r_lo - d_lo;+    rx = (limb_t)Rx;+    borrow = (limb_t)(Rx >> LIMB_T_BITS) & 1;+    Rx = r_hi - (d_hi + (llimb_t)borrow);+    borrow = (limb_t)(Rx >> LIMB_T_BITS) & 1;++    Q <<= 1;+    Q |= borrow ^ 1;++    return (Q | mask);+}++static limb_t quot_rem_n(limb_t *div_rem, const limb_t *divisor,+                                          limb_t quotient, size_t n)+{+    llimb_t limbx;+    limb_t tmp[n+1], carry, mask, borrow;+    size_t i;++    /* divisor*quotient */+    for (carry=0, i=0; i<n; i++) {+        limbx = (quotient * (llimb_t)divisor[i]) + carry;+        tmp[i] = (limb_t)limbx;+        carry = (limb_t)(limbx >> LIMB_T_BITS);+    }+    tmp[i] = carry;++    /* remainder = dividend - divisor*quotient */+    for (borrow=0, i=0; i<=n; i++) {+        limbx = div_rem[i] - (tmp[i] + (llimb_t)borrow);+        tmp[i] = (limb_t)limbx;+        borrow = (limb_t)(limbx >> LIMB_T_BITS) & 1;+    }++    mask = 0 - borrow;++    /* if quotient was off by one, add divisor to the remainder */+    for (carry=0, i=0; i<n; i++) {+        limbx = tmp[i] + ((divisor[i] & mask) + (llimb_t)carry);+        div_rem[i] = (limb_t)limbx;+        carry = (limb_t)(limbx >> LIMB_T_BITS) & 1;+    }++    return (div_rem[i] = quotient + mask);+}++inline limb_t quot_rem_128(limb_t *div_rem, const limb_t *divisor,+                                            limb_t quotient)+{   return quot_rem_n(div_rem, divisor, quotient, NLIMBS(128));   }++inline limb_t quot_rem_64(limb_t *div_rem, const limb_t *divisor,+                                           limb_t quotient)+{   return quot_rem_n(div_rem, divisor, quotient, NLIMBS(64));   }++/*+ * Unlock reference implementations in vect.c+ */+#define mul_by_8_mod_384 mul_by_8_mod_384+#define mul_by_8_mod_384x mul_by_8_mod_384x+#define mul_by_3_mod_384x mul_by_3_mod_384x+#define mul_by_1_plus_i_mod_384x mul_by_1_plus_i_mod_384x+#define add_mod_384x add_mod_384x+#define sub_mod_384x sub_mod_384x+#define lshift_mod_384x lshift_mod_384x+#define sqr_mont_384x sqr_mont_384x++inline void vec_prefetch(const void *ptr, size_t len)+{   (void)ptr; (void)len;   }++/*+ * SHA-256+ */+#define ROTR(x,n)	((x)>>n | (x)<<(32-n))+#define Sigma0(x)	(ROTR((x),2) ^ ROTR((x),13) ^ ROTR((x),22))+#define Sigma1(x)	(ROTR((x),6) ^ ROTR((x),11) ^ ROTR((x),25))+#define sigma0(x)	(ROTR((x),7) ^ ROTR((x),18) ^ ((x)>>3))+#define sigma1(x)	(ROTR((x),17) ^ ROTR((x),19) ^ ((x)>>10))+#define Ch(x,y,z)	(((x) & (y)) ^ ((~(x)) & (z)))+#define Maj(x,y,z)	(((x) & (y)) ^ ((x) & (z)) ^ ((y) & (z)))++void blst_sha256_block_data_order(unsigned int *v, const void *inp,+                                                   size_t blocks)+{+    static const unsigned int K256[64] = {+        0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5,+        0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5,+        0xd807aa98, 0x12835b01, 0x243185be, 0x550c7dc3,+        0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174,+        0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc,+        0x2de92c6f, 0x4a7484aa, 0x5cb0a9dc, 0x76f988da,+        0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7,+        0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967,+        0x27b70a85, 0x2e1b2138, 0x4d2c6dfc, 0x53380d13,+        0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85,+        0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,+        0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070,+        0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5,+        0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f, 0x682e6ff3,+        0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208,+        0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2+    };+    unsigned int X[16], l, a, b, c, d, e, f, g, h, s0, s1, T1, T2;+    const unsigned char *data = inp;+    size_t round;++    a = v[0];+    b = v[1];+    c = v[2];+    d = v[3];+    e = v[4];+    f = v[5];+    g = v[6];+    h = v[7];++    while (blocks--) {+        for (round = 0; round < 16; round++) {+            l  = (unsigned int)data[0] << 24;+            l |= (unsigned int)data[1] << 16;+            l |= (unsigned int)data[2] << 8;+            l |= (unsigned int)data[3];+            data += 4;+            T1 = X[round] = l;+            T1 += h + Sigma1(e) + Ch(e, f, g) + K256[round];+            T2 = Sigma0(a) + Maj(a, b, c);+            h = g;+            g = f;+            f = e;+            e = d + T1;+            d = c;+            c = b;+            b = a;+            a = T1 + T2;+        }++        for (; round < 64; round++) {+            s0 = X[(round + 1) & 0x0f];+            s0 = sigma0(s0);+            s1 = X[(round + 14) & 0x0f];+            s1 = sigma1(s1);++            T1 = X[round & 0xf] += s0 + s1 + X[(round + 9) & 0xf];+            T1 += h + Sigma1(e) + Ch(e, f, g) + K256[round];+            T2 = Sigma0(a) + Maj(a, b, c);+            h = g;+            g = f;+            f = e;+            e = d + T1;+            d = c;+            c = b;+            b = a;+            a = T1 + T2;+        }++        a += v[0]; v[0] = a;+        b += v[1]; v[1] = b;+        c += v[2]; v[2] = c;+        d += v[3]; v[3] = d;+        e += v[4]; v[4] = e;+        f += v[5]; v[5] = f;+        g += v[6]; v[6] = g;+        h += v[7]; v[7] = h;+    }+}+#undef ROTR+#undef Sigma0+#undef Sigma1+#undef sigma0+#undef sigma1+#undef Ch+#undef Maj++void blst_sha256_hcopy(unsigned int dst[8], const unsigned int src[8])+{+    size_t i;++    for (i=0; i<8; i++)+        dst[i] = src[i];+}++void blst_sha256_emit(unsigned char md[32], const unsigned int h[8])+{+    size_t i;++    for (i=0; i<8; i++, md+=4) {+        unsigned int h_i = h[i];+        md[0] = (unsigned char)(h_i >> 24);+        md[1] = (unsigned char)(h_i >> 16);+        md[2] = (unsigned char)(h_i >> 8);+        md[3] = (unsigned char)h_i;+    }+}++void blst_sha256_bcopy(void *dst_, const void *src_, size_t len)+{+    unsigned char *dst = dst_;+    const unsigned char *src = src_;+    size_t i;++    for (i=0; i<len; i++)+        dst[i] = src[i];+}
+ c-source/src/pairing.c view
@@ -0,0 +1,444 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */++#include "point.h"+#include "fields.h"++/*+ * Line evaluations from  https://eprint.iacr.org/2010/354.pdf+ * with a twist moving common expression to line_by_Px2.+ */+static void line_add(vec384fp6 line, POINTonE2 *T, const POINTonE2 *R,+                                                   const POINTonE2_affine *Q)+{+    vec384x Z1Z1, U2, S2, H, HH, I, J, V;+#if 1+# define r line[1]+#else+    vec384x r;+#endif++    /*+     * https://hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#addition-madd-2007-bl+     * with XYZ3 being |T|, XYZ1 - |R|, XY2 - |Q|, i.e. Q is affine+     */+    sqr_fp2(Z1Z1, R->Z);                /* Z1Z1 = Z1^2 */+    mul_fp2(U2, Q->X, Z1Z1);            /* U2 = X2*Z1Z1 */++    mul_fp2(S2, Q->Y, R->Z);+    mul_fp2(S2, S2, Z1Z1);              /* S2 = Y2*Z1*Z1Z1 */++    sub_fp2(H, U2, R->X);               /* H = U2-X1 */++    sqr_fp2(HH, H);                     /* HH = H^2 */+    add_fp2(I, HH, HH);+    add_fp2(I, I, I);                   /* I = 4*HH */++    mul_fp2(J, H, I);                   /* J = H*I */++    sub_fp2(r, S2, R->Y);+    add_fp2(r, r, r);                   /* r = 2*(S2-Y1) */++    mul_fp2(V, R->X, I);                /* V = X1*I */++    sqr_fp2(T->X, r);+    sub_fp2(T->X, T->X, J);+    sub_fp2(T->X, T->X, V);+    sub_fp2(T->X, T->X, V);             /* X3 = r^2-J-2*V */++    mul_fp2(J, J, R->Y);+    sub_fp2(T->Y, V, T->X);+    mul_fp2(T->Y, T->Y, r);+    sub_fp2(T->Y, T->Y, J);+    sub_fp2(T->Y, T->Y, J);             /* Y3 = r*(V-X3)-2*Y1*J */++    add_fp2(T->Z, R->Z, H);+    sqr_fp2(T->Z, T->Z);+    sub_fp2(T->Z, T->Z, Z1Z1);+    sub_fp2(T->Z, T->Z, HH);            /* Z3 = (Z1+H)^2-Z1Z1-HH */++    /*+     * line evaluation+     */+    mul_fp2(I, r, Q->X);+    mul_fp2(J, Q->Y, T->Z);+    sub_fp2(I, I, J);+    add_fp2(line[0], I, I);          /* 2*(r*X2 - Y2*Z3) */+#ifdef r+# undef r+#else+    vec_copy(line[1], r, sizeof(r));+#endif+    vec_copy(line[2], T->Z, sizeof(T->Z));+}++static void line_dbl(vec384fp6 line, POINTonE2 *T, const POINTonE2 *Q)+{+    vec384x ZZ, A, B, C, D, E, F;++    /*+     * https://www.hyperelliptic.org/EFD/g1p/auto-shortw-jacobian-0.html#doubling-dbl-2009-alnr+     */+    sqr_fp2(A, Q->X);                   /* A = X1^2 */+    sqr_fp2(B, Q->Y);                   /* B = Y1^2 */+    sqr_fp2(ZZ, Q->Z);                  /* ZZ = Z1^2 */+    sqr_fp2(C, B);                      /* C = B^2 */++    add_fp2(D, Q->X, B);                /* X1+B */+    sqr_fp2(D, D);                      /* (X1+B)^2 */+    sub_fp2(D, D, A);                   /* (X1+B)^2-A */+    sub_fp2(D, D, C);                   /* (X1+B)^2-A-C */+    add_fp2(D, D, D);                   /* D = 2*((X1+B)^2-A-C) */++    mul_by_3_fp2(E, A);                 /* E = 3*A */+    sqr_fp2(F, E);                      /* F = E^2 */++    add_fp2(line[0], E, Q->X);          /* 3*A+X1 for line evaluation */++    sub_fp2(T->X, F, D);+    sub_fp2(T->X, T->X, D);             /* X3 = F-2*D */++    add_fp2(T->Z, Q->Y, Q->Z);+    sqr_fp2(T->Z, T->Z);+    sub_fp2(T->Z, T->Z, B);+    sub_fp2(T->Z, T->Z, ZZ);            /* Z3 = (Y1+Z1)^2-B-ZZ */++    mul_by_8_fp2(C, C);                 /* 8*C */+    sub_fp2(T->Y, D, T->X);             /* D-X3 */+    mul_fp2(T->Y, T->Y, E);             /* E*(D-X3) */+    sub_fp2(T->Y, T->Y, C);             /* Y3 = E*(D-X3)-8*C */++    /*+     * line evaluation+     */+    sqr_fp2(line[0], line[0]);+    sub_fp2(line[0], line[0], A);+    sub_fp2(line[0], line[0], F);       /* (3*A+X1)^2 - X1^2 - 9*A^2 */+    lshift_fp2(B, B, 2);+    sub_fp2(line[0], line[0], B);       /* 6*X1^3 - 4*Y1^2 */++    mul_fp2(line[1], E, ZZ);            /* 3*X1^2 * Z1^2 */++    mul_fp2(line[2], T->Z, ZZ);         /* Z3 * Z1^2 */+}++static void line_by_Px2(vec384fp6 line, const POINTonE1_affine *Px2)+{+    mul_fp(line[1][0], line[1][0], Px2->X);   /* "b01" *= -2*P->X */+    mul_fp(line[1][1], line[1][1], Px2->X);++    mul_fp(line[2][0], line[2][0], Px2->Y);   /* "b11" *= 2*P->Y */+    mul_fp(line[2][1], line[2][1], Px2->Y);+}++#if 0+static void add_n_dbl(vec384fp12 ret, POINTonE2 *T, const POINTonE2_affine *Q,+                      const POINTonE1_affine *Px2, vec384fp6 line, size_t n)+{+    line_add(line, T, T, Q);    line_by_Px2(line, Px2);+    mul_by_xy00z0_fp12(ret, ret, line);+    while (n--) {+        sqr_fp12(ret, ret);+        line_dbl(line, T, T);   line_by_Px2(line, Px2);+        mul_by_xy00z0_fp12(ret, ret, line);+    }+}++static void miller_loop(vec384fp12 ret, const POINTonE2 *Q, const POINTonE1 *P)+{+#define Q ((const POINTonE2_affine *)Q)+    POINTonE2 T[1];+    POINTonE1_affine Px2[1];+    vec384fp6 line; /* it's not actual fp6, but 3 packed fp2, "xy00z0"  */++    /* Move common expression from line evaluation to line_by_Px2. */+    add_fp(Px2->X, P->X, P->X);+    neg_fp(Px2->X, Px2->X);+    add_fp(Px2->Y, P->Y, P->Y);++    vec_copy(T->X, Q->X, 2*sizeof(T->X));+    vec_copy(T->Z, BLS12_381_Rx.p2, sizeof(T->Z));++    /* first step is ret = 1^2*line, which is replaced with ret = line  */+    line_dbl(line, T, T);                       /* 0x2                  */+    line_by_Px2(line, Px2);+    vec_zero(ret, sizeof(vec384fp12));+    vec_copy(ret[0][0], line[0], 2*sizeof(vec384fp2));+    vec_copy(ret[1][1], line[2], sizeof(vec384fp2));+    add_n_dbl(ret, T, Q, Px2, line, 2);         /* ..0xc                */+    add_n_dbl(ret, T, Q, Px2, line, 3);         /* ..0x68               */+    add_n_dbl(ret, T, Q, Px2, line, 9);         /* ..0xd200             */+    add_n_dbl(ret, T, Q, Px2, line, 32);        /* ..0xd20100000000     */+    add_n_dbl(ret, T, Q, Px2, line, 16);        /* ..0xd201000000010000 */+    conjugate_fp12(ret);                /* account for z being negative */+#undef Q+}+#endif++static void start_dbl_n(vec384fp12 ret, POINTonE2 T[],+                                        const POINTonE1_affine Px2[], size_t n)+{+    size_t i;+    vec384fp6 line; /* it's not actual fp6, but 3 packed fp2, "xy00z0"  */++    /* first step is ret = 1^2*line, which is replaced with ret = line  */+    line_dbl(line, T+0, T+0);           line_by_Px2(line, Px2+0);+    vec_zero(ret, sizeof(vec384fp12));+    vec_copy(ret[0][0], line[0], 2*sizeof(vec384fp2));+    vec_copy(ret[1][1], line[2], sizeof(vec384fp2));++    for (i = 1; i < n; i++) {+        line_dbl(line, T+i, T+i);       line_by_Px2(line, Px2+i);+        mul_by_xy00z0_fp12(ret, ret, line);+    }+}++static void add_n_dbl_n(vec384fp12 ret, POINTonE2 T[],+                                        const POINTonE2_affine Q[],+                                        const POINTonE1_affine Px2[],+                                        size_t n, size_t k)+{+    size_t i;+    vec384fp6 line; /* it's not actual fp6, but 3 packed fp2, "xy00z0"  */++    for (i = 0; i < n; i++) {+        line_add(line, T+i, T+i, Q+i);  line_by_Px2(line, Px2+i);+        mul_by_xy00z0_fp12(ret, ret, line);+    }+    while (k--) {+        sqr_fp12(ret, ret);+        for (i = 0; i < n; i++) {+            line_dbl(line, T+i, T+i);   line_by_Px2(line, Px2+i);+            mul_by_xy00z0_fp12(ret, ret, line);+        }+    }+}++static void miller_loop_n(vec384fp12 ret, const POINTonE2_affine Q[],+                                          const POINTonE1_affine P[], size_t n)+{+#if !defined(__STDC_VERSION__) || __STDC_VERSION__<199901 \+                               || defined(__STDC_NO_VLA__)+    POINTonE2 *T = alloca(n*sizeof(POINTonE2));+    POINTonE1_affine *Px2 = alloca(n*sizeof(POINTonE1_affine));+#else+    POINTonE2 T[n];+    POINTonE1_affine Px2[n];+#endif+    size_t i;++    if ((n == 1) && (vec_is_zero(&Q[0], sizeof(Q[0])) |+                     vec_is_zero(&P[0], sizeof(P[0]))) ) {+        /*+         * Special case of infinite aggregated signature, pair the additive+         * group's identity with the multiplicative group's identity.+         */+        vec_copy(ret, BLS12_381_Rx.p12, sizeof(vec384fp12));+        return;+    }++    for (i = 0; i < n; i++) {+        /* Move common expression from line evaluation to line_by_Px2.  */+        add_fp(Px2[i].X, P[i].X, P[i].X);+        neg_fp(Px2[i].X, Px2[i].X);+        add_fp(Px2[i].Y, P[i].Y, P[i].Y);++        vec_copy(T[i].X, Q[i].X, 2*sizeof(T[i].X));+        vec_copy(T[i].Z, BLS12_381_Rx.p2, sizeof(T[i].Z));+    }++    /* first step is ret = 1^2*line, which is replaced with ret = line  */+    start_dbl_n(ret, T, Px2, n);                /* 0x2                  */+    add_n_dbl_n(ret, T, Q, Px2, n, 2);          /* ..0xc                */+    add_n_dbl_n(ret, T, Q, Px2, n, 3);          /* ..0x68               */+    add_n_dbl_n(ret, T, Q, Px2, n, 9);          /* ..0xd200             */+    add_n_dbl_n(ret, T, Q, Px2, n, 32);         /* ..0xd20100000000     */+    add_n_dbl_n(ret, T, Q, Px2, n, 16);         /* ..0xd201000000010000 */+    conjugate_fp12(ret);                /* account for z being negative */+}++static void pre_add_n_dbl(vec384fp6 lines[], POINTonE2 *T,+                                             const POINTonE2_affine *Q,+                                             size_t n)+{+    line_add(lines++[0], T, T, Q);+    while (n--)+        line_dbl(lines++[0], T, T);+}++static void precompute_lines(vec384fp6 Qlines[68], const POINTonE2_affine *Q)+{+    POINTonE2 T[1];++    vec_copy(T->X, Q->X, 2*sizeof(T->X));+    vec_copy(T->Z, BLS12_381_Rx.p2, sizeof(T->Z));++    line_dbl(Qlines[0], T, T);                  /* 0x2                  */+    pre_add_n_dbl(&Qlines[1],  T, Q, 2);        /* ..0xc                */+    pre_add_n_dbl(&Qlines[4],  T, Q, 3);        /* ..0x68               */+    pre_add_n_dbl(&Qlines[8],  T, Q, 9);        /* ..0xd200             */+    pre_add_n_dbl(&Qlines[18], T, Q, 32);       /* ..0xd20100000000     */+    pre_add_n_dbl(&Qlines[51], T, Q, 16);       /* ..0xd201000000010000 */+}++static void post_line_by_Px2(vec384fp6 out, const vec384fp6 in,+                                            const POINTonE1_affine *Px2)+{+    vec_copy(out[0], in[0], sizeof(out[0]));++    mul_fp(out[1][0], in[1][0], Px2->X);        /* "b01" *= -2*P->X */+    mul_fp(out[1][1], in[1][1], Px2->X);++    mul_fp(out[2][0], in[2][0], Px2->Y);        /* "b11" *= 2*P->Y */+    mul_fp(out[2][1], in[2][1], Px2->Y);+}++static void post_add_n_dbl(vec384fp12 ret, const vec384fp6 lines[],+                           const POINTonE1_affine *Px2, size_t n)+{+    vec384fp6 line;++    post_line_by_Px2(line, lines++[0], Px2);+    mul_by_xy00z0_fp12(ret, ret, line);+    while (n--) {+        sqr_fp12(ret, ret);+        post_line_by_Px2(line, lines++[0], Px2);+        mul_by_xy00z0_fp12(ret, ret, line);+    }+}++static void miller_loop_lines(vec384fp12 ret, const vec384fp6 Qlines[68],+                                              const POINTonE1_affine *P)+{+    POINTonE1_affine Px2[1];+    vec384fp6 line; /* it's not actual fp6, but 3 packed fp2, "xy00z0"  */++    /* Move common expression from line evaluation to line_by_Px2. */+    add_fp(Px2->X, P->X, P->X);+    neg_fp(Px2->X, Px2->X);+    add_fp(Px2->Y, P->Y, P->Y);++    /* first step is ret = 1^2*line, which is replaced with ret = line  */+    post_line_by_Px2(line, Qlines[0], Px2);     /* 0x2                  */+    vec_zero(ret, sizeof(vec384fp12));+    vec_copy(ret[0][0], line[0], 2*sizeof(vec384fp2));+    vec_copy(ret[1][1], line[2], sizeof(vec384fp2));+    post_add_n_dbl(ret, &Qlines[1],  Px2, 2);   /* ..0xc                */+    post_add_n_dbl(ret, &Qlines[4],  Px2, 3);   /* ..0x68               */+    post_add_n_dbl(ret, &Qlines[8],  Px2, 9);   /* ..0xd200             */+    post_add_n_dbl(ret, &Qlines[18], Px2, 32);  /* ..0xd20100000000     */+    post_add_n_dbl(ret, &Qlines[51], Px2, 16);  /* ..0xd201000000010000 */+    conjugate_fp12(ret);                /* account for z being negative */+}++#ifdef INTERNAL_TESTMODE+static void miller_loop_alt(vec384fp12 ret, const POINTonE2_affine *Q,+                                            const POINTonE1_affine *P)+{+    vec384fp6 lines[68];++    precompute_lines(lines, Q);+    miller_loop_lines(ret, lines, P);+}+#endif++static void mul_n_sqr(vec384fp12 ret, const vec384fp12 a, size_t n)+{+    mul_fp12(ret, ret, a);+    while (n--)+        cyclotomic_sqr_fp12(ret, ret);+}++static void raise_to_z_div_by_2(vec384fp12 ret, const vec384fp12 a)+{+    cyclotomic_sqr_fp12(ret, a);                /* 0x2                  */+    mul_n_sqr(ret, a, 2);                       /* ..0xc                */+    mul_n_sqr(ret, a, 3);                       /* ..0x68               */+    mul_n_sqr(ret, a, 9);                       /* ..0xd200             */+    mul_n_sqr(ret, a, 32);                      /* ..0xd20100000000     */+    mul_n_sqr(ret, a, 16-1);                    /* ..0x6900800000008000 */+    conjugate_fp12(ret);                /* account for z being negative */+}++#define raise_to_z(a, b) (raise_to_z_div_by_2(a, b), cyclotomic_sqr_fp12(a, a))++/*+ * Adaptation from <zkcrypto>/pairing/src/bls12_381/mod.rs+ */+static void final_exp(vec384fp12 ret, const vec384fp12 f)+{+    vec384fp12 y0, y1, y2, y3;++    vec_copy(y1, f, sizeof(y1));+    conjugate_fp12(y1);+    inverse_fp12(y2, f);+    mul_fp12(ret, y1, y2);+    frobenius_map_fp12(y2, ret, 2);+    mul_fp12(ret, ret, y2);++    cyclotomic_sqr_fp12(y0, ret);+    raise_to_z(y1, y0);+    raise_to_z_div_by_2(y2, y1);+    vec_copy(y3, ret, sizeof(y3));+    conjugate_fp12(y3);+    mul_fp12(y1, y1, y3);+    conjugate_fp12(y1);+    mul_fp12(y1, y1, y2);+    raise_to_z(y2, y1);+    raise_to_z(y3, y2);+    conjugate_fp12(y1);+    mul_fp12(y3, y3, y1);+    conjugate_fp12(y1);+    frobenius_map_fp12(y1, y1, 3);+    frobenius_map_fp12(y2, y2, 2);+    mul_fp12(y1, y1, y2);+    raise_to_z(y2, y3);+    mul_fp12(y2, y2, y0);+    mul_fp12(y2, y2, ret);+    mul_fp12(y1, y1, y2);+    frobenius_map_fp12(y2, y3, 1);+    mul_fp12(ret, y1, y2);+}++void blst_miller_loop(vec384fp12 ret, const POINTonE2_affine *Q,+                                      const POINTonE1_affine *P)+{   miller_loop_n(ret, Q ? Q : (const POINTonE2_affine *)&BLS12_381_G2,+                       P ? P : (const POINTonE1_affine *)&BLS12_381_G1, 1);+}++void blst_final_exp(vec384fp12 ret, const vec384fp12 f)+{   final_exp(ret, f);   }++void blst_precompute_lines(vec384fp6 Qlines[68], const POINTonE2_affine *Q)+{   precompute_lines(Qlines, Q);   }++void blst_miller_loop_lines(vec384fp12 ret, const vec384fp6 Qlines[68],+                                            const POINTonE1_affine *P)+{   miller_loop_lines(ret, Qlines, P);   }++static bool_t is_cyclotomic(const vec384fp12 f)+{+    vec384fp12 a, b;++    frobenius_map_fp12(a, f, 2);+    frobenius_map_fp12(b, a, 2);+    mul_fp12(b, b, f);++    return vec_is_equal(a, b, sizeof(a));+}++int blst_fp12_in_group(const vec384fp12 f)+{+    vec384fp12 a, b;++    if (vec_is_zero(f, sizeof(vec384fp12)) || !is_cyclotomic(f))+        return 0;++    frobenius_map_fp12(a, f, 1);+    raise_to_z(b, f);++    return (int)vec_is_equal(a, b, sizeof(a));+}
+ c-source/src/point.h view
@@ -0,0 +1,62 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */+#ifndef __BLS12_381_ASM_POINT_H__+#define __BLS12_381_ASM_POINT_H__++#include "vect.h"+#include "bytes.h"++#define DECLARE_POINT(ptype, bits) \+typedef struct { vec##bits X,Y,Z; } ptype; \+typedef struct { vec##bits X,Y; } ptype##_affine; \+\+static void ptype##_dadd(ptype *out, const ptype *p1, const ptype *p2,	\+                         const vec##bits a4);				\+static void ptype##_dadd_affine(ptype *out, const ptype *p1,		\+                                            const ptype##_affine *p2);	\+static void ptype##_add(ptype *out, const ptype *p1, const ptype *p2);	\+static void ptype##_add_affine(ptype *out, const ptype *p1,		\+                                           const ptype##_affine *p2);	\+static void ptype##_double(ptype *out, const ptype *p1);		\+static void ptype##_mult_w5(ptype *out, const ptype *point,		\+                            const byte *scalar, size_t nbits);		\+static void ptype##_cneg(ptype *p, limb_t cbit);			\+static void ptype##_to_affine(ptype##_affine *out, const ptype *in);	\+static void ptype##_from_Jacobian(ptype *out, const ptype *in);		\+\+static inline void ptype##_cswap(ptype *restrict a,			\+                                 ptype *restrict b, bool_t cbit) {	\+    vec_cswap(a, b, sizeof(ptype), cbit);				\+} \+static inline void ptype##_ccopy(ptype *restrict a,			\+                                 const ptype *restrict b, bool_t cbit) {\+    vec_select(a, b, a, sizeof(ptype), cbit);				\+}++#define DECLARE_PRIVATE_POINTXZ(ptype, bits) \+typedef struct { vec##bits X,Z; } ptype##xz; \+\+static void ptype##xz_ladder_pre(ptype##xz *out, const ptype *in);	\+static void ptype##xz_ladder_step(ptype##xz *r, ptype##xz *s,		\+                                  const ptype##xz *p);			\+static void ptype##xz_ladder_post(ptype *ret,				\+                                  const ptype##xz *r, const ptype##xz *s, \+                                  const ptype##xz *p, const vec##bits Y1);\+\+static inline void ptype##xz_cswap(ptype##xz *restrict a,		\+                                   ptype##xz *restrict b, bool_t cbit) {\+    vec_cswap(a, b, sizeof(ptype##xz), cbit);				\+}++DECLARE_POINT(POINTonE1, 384)++DECLARE_POINT(POINTonE2, 384x)++#ifdef __GNUC__+# pragma GCC diagnostic ignored "-Wunused-function"+#endif++#endif
+ c-source/src/rb_tree.c view
@@ -0,0 +1,145 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */++#include <stddef.h>++/*+ * Red-black tree tailored for uniqueness test. Amount of messages to be+ * checked is known prior context initialization, implementation is+ * insert-only, failure is returned if message is already in the tree.+ */++struct node {+    struct node *leafs[2];+    const void *data;+    size_t len_n_colour;    /* len<<1 | colour */+};++struct rb_tree {+    struct node *root;+    size_t n_nodes;+    struct node nodes[1];+};++static long bytes_compare(const unsigned char *ptr0, size_t len0,+                          const unsigned char *ptr1, size_t len1)+{+    size_t i, len = len0<len1 ? len0 : len1;+    long a, b;++    for (i=0; i<len; i++) {+        if ((a = ptr0[i]) != (b = ptr1[i]))+            return a - b;+    }++    return (long)len0 - (long)len1;+}++#define PAINT_BLACK(p)  ((p)->len_n_colour &= ~(size_t)1)+#define PAINT_RED(p)    ((p)->len_n_colour |= 1)+#define IS_RED(p)       ((p)->len_n_colour & 1)++static int rb_tree_insert(struct rb_tree *tree, const void *data, size_t len)+{+    struct node *nodes[8*sizeof(void *)];   /* visited nodes    */+    unsigned char dirs[8*sizeof(void *)];   /* taken directions */+    size_t k = 0;                           /* walked distance  */+    struct node *p, *y, *z;++    for (p = tree->root; p != NULL; k++) {+        long cmp = bytes_compare(data, len, p->data, p->len_n_colour>>1);++        if (cmp == 0)+            return 0;   /* already in tree, no insertion */++        /* record the step */+        nodes[k] = p;+        p = p->leafs[(dirs[k] = cmp>0)];+    }++    /* allocate new node */+    z = &tree->nodes[tree->n_nodes++];+    z->leafs[0] = z->leafs[1] = NULL;+    z->data = data;+    z->len_n_colour = len<<1;+    PAINT_RED(z);++    /* graft |z| */+    if (k > 0)+        nodes[k-1]->leafs[dirs[k-1]] = z;+    else+        tree->root = z;++    /* re-balance |tree| */+    while (k >= 2 && IS_RED(y = nodes[k-1])) {+        size_t ydir = dirs[k-2];+        struct node *x = nodes[k-2],        /* |z|'s grandparent    */+                    *s = x->leafs[ydir^1];  /* |z|'s uncle          */++        if (s != NULL && IS_RED(s)) {+            PAINT_RED(x);+            PAINT_BLACK(y);+            PAINT_BLACK(s);+            k -= 2;+        } else {+            if (dirs[k-1] != ydir) {+                /*    |        |+                 *    x        x+                 *   / \        \+                 *  y   s -> z   s+                 *   \      /+                 *    z    y+                 *   /      \+                 *  ?        ?+                 */+                struct node *t = y;+                y = y->leafs[ydir^1];+                t->leafs[ydir^1] = y->leafs[ydir];+                y->leafs[ydir] = t;+            }++            /*      |        |+             *      x        y+             *       \      / \+             *    y   s -> z   x+             *   / \          / \+             *  z   ?        ?   s+             */+            x->leafs[ydir] = y->leafs[ydir^1];+            y->leafs[ydir^1] = x;++            PAINT_RED(x);+            PAINT_BLACK(y);++            if (k > 2)+                nodes[k-3]->leafs[dirs[k-3]] = y;+            else+                tree->root = y;++            break;+        }+    }++    PAINT_BLACK(tree->root);++    return 1;+}++#undef IS_RED+#undef PAINT_RED+#undef PAINT_BLACK++size_t blst_uniq_sizeof(size_t n_nodes)+{   return sizeof(struct rb_tree) + sizeof(struct node)*(n_nodes-1);   }++void blst_uniq_init(struct rb_tree *tree)+{+    tree->root = NULL;+    tree->n_nodes = 0;+}++int blst_uniq_test(struct rb_tree *tree, const void *data, size_t len)+{   return (int)rb_tree_insert(tree, data, len);   }
+ c-source/src/recip-addchain.h view
@@ -0,0 +1,489 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */+/*+ * The "magic" number is BLS12_381_P-2. Exponentiation to which yields+ * reciprocal to input base.+ *+ * Generated with 'addchain 4002409555221667393417789825735904156556882819939007885332058136124031650490837864442687629129015664037894272559785'+ * https://github.com/kwantam/addchain+ *+ * # Bos-Coster (win=4)           :  461 (16) <<<+ * # Bos-Coster (win=3)           :  464 ( 9)+ * # Bos-Coster (win=8)           :  469 (35)+ * # Bos-Coster (win=5)           :  463 (28)+ * # Bos-Coster (win=9)           :  467 (32)+ * # Bos-Coster (win=7)           :  462 (27)+ * # Yacobi                       :  481 (31)+ * # Bos-Coster (win=10)          :  475 (30)+ * # Bos-Coster (win=6)           :  463 (32)+ * # Bos-Coster (win=2)           :  489 ( 5)+ * # Bergeron-Berstel-Brlek-Duboc :  498 ( 5)+ */++#define RECIPROCAL_MOD_BLS12_381_P(out, inp, ptype) do { \+ptype t[16]; \+vec_copy(t[1], inp, sizeof(ptype)); /*    0: 1 */\+sqr(t[0], t[1]);                    /*    1: 2 */\+mul(t[9], t[0], t[1]);              /*    2: 3 */\+sqr(t[5], t[0]);                    /*    3: 4 */\+mul(t[2], t[9], t[0]);              /*    4: 5 */\+mul(t[7], t[5], t[9]);              /*    5: 7 */\+mul(t[10], t[2], t[5]);             /*    6: 9 */\+mul(t[13], t[7], t[5]);             /*    7: b */\+mul(t[4], t[10], t[5]);             /*    8: d */\+mul(t[8], t[13], t[5]);             /*    9: f */\+mul(t[15], t[4], t[5]);             /*   10: 11 */\+mul(t[11], t[8], t[5]);             /*   11: 13 */\+mul(t[3], t[15], t[5]);             /*   12: 15 */\+mul(t[12], t[11], t[5]);            /*   13: 17 */\+sqr(t[0], t[4]);                    /*   14: 1a */\+mul(t[14], t[12], t[5]);            /*   15: 1b */\+mul(t[6], t[0], t[9]);              /*   16: 1d */\+mul(t[5], t[0], t[2]);              /*   17: 1f */\+/* sqr(t[0], t[0]); */              /*   18: 34 */\+/* sqr(t[0], t[0]); */              /*   19: 68 */\+/* sqr(t[0], t[0]); */              /*   20: d0 */\+/* sqr(t[0], t[0]); */              /*   21: 1a0 */\+/* sqr(t[0], t[0]); */              /*   22: 340 */\+/* sqr(t[0], t[0]); */              /*   23: 680 */\+/* sqr(t[0], t[0]); */              /*   24: d00 */\+/* sqr(t[0], t[0]); */              /*   25: 1a00 */\+/* sqr(t[0], t[0]); */              /*   26: 3400 */\+/* sqr(t[0], t[0]); */              /*   27: 6800 */\+/* sqr(t[0], t[0]); */              /*   28: d000 */\+/* sqr(t[0], t[0]); */              /*   29: 1a000 */\+sqr_n_mul(t[0], t[0], 12, t[15]);   /*   30: 1a011 */\+/* sqr(t[0], t[0]); */              /*   31: 34022 */\+/* sqr(t[0], t[0]); */              /*   32: 68044 */\+/* sqr(t[0], t[0]); */              /*   33: d0088 */\+/* sqr(t[0], t[0]); */              /*   34: 1a0110 */\+/* sqr(t[0], t[0]); */              /*   35: 340220 */\+/* sqr(t[0], t[0]); */              /*   36: 680440 */\+/* sqr(t[0], t[0]); */              /*   37: d00880 */\+sqr_n_mul(t[0], t[0], 7, t[8]);     /*   38: d0088f */\+/* sqr(t[0], t[0]); */              /*   39: 1a0111e */\+/* sqr(t[0], t[0]); */              /*   40: 340223c */\+/* sqr(t[0], t[0]); */              /*   41: 6804478 */\+/* sqr(t[0], t[0]); */              /*   42: d0088f0 */\+sqr_n_mul(t[0], t[0], 4, t[2]);     /*   43: d0088f5 */\+/* sqr(t[0], t[0]); */              /*   44: 1a0111ea */\+/* sqr(t[0], t[0]); */              /*   45: 340223d4 */\+/* sqr(t[0], t[0]); */              /*   46: 680447a8 */\+/* sqr(t[0], t[0]); */              /*   47: d0088f50 */\+/* sqr(t[0], t[0]); */              /*   48: 1a0111ea0 */\+/* sqr(t[0], t[0]); */              /*   49: 340223d40 */\+sqr_n_mul(t[0], t[0], 6, t[7]);     /*   50: 340223d47 */\+/* sqr(t[0], t[0]); */              /*   51: 680447a8e */\+/* sqr(t[0], t[0]); */              /*   52: d0088f51c */\+/* sqr(t[0], t[0]); */              /*   53: 1a0111ea38 */\+/* sqr(t[0], t[0]); */              /*   54: 340223d470 */\+/* sqr(t[0], t[0]); */              /*   55: 680447a8e0 */\+/* sqr(t[0], t[0]); */              /*   56: d0088f51c0 */\+/* sqr(t[0], t[0]); */              /*   57: 1a0111ea380 */\+sqr_n_mul(t[0], t[0], 7, t[12]);    /*   58: 1a0111ea397 */\+/* sqr(t[0], t[0]); */              /*   59: 340223d472e */\+/* sqr(t[0], t[0]); */              /*   60: 680447a8e5c */\+/* sqr(t[0], t[0]); */              /*   61: d0088f51cb8 */\+/* sqr(t[0], t[0]); */              /*   62: 1a0111ea3970 */\+/* sqr(t[0], t[0]); */              /*   63: 340223d472e0 */\+sqr_n_mul(t[0], t[0], 5, t[5]);     /*   64: 340223d472ff */\+/* sqr(t[0], t[0]); */              /*   65: 680447a8e5fe */\+/* sqr(t[0], t[0]); */              /*   66: d0088f51cbfc */\+sqr_n_mul(t[0], t[0], 2, t[9]);     /*   67: d0088f51cbff */\+/* sqr(t[0], t[0]); */              /*   68: 1a0111ea397fe */\+/* sqr(t[0], t[0]); */              /*   69: 340223d472ffc */\+/* sqr(t[0], t[0]); */              /*   70: 680447a8e5ff8 */\+/* sqr(t[0], t[0]); */              /*   71: d0088f51cbff0 */\+/* sqr(t[0], t[0]); */              /*   72: 1a0111ea397fe0 */\+/* sqr(t[0], t[0]); */              /*   73: 340223d472ffc0 */\+sqr_n_mul(t[0], t[0], 6, t[4]);     /*   74: 340223d472ffcd */\+/* sqr(t[0], t[0]); */              /*   75: 680447a8e5ff9a */\+/* sqr(t[0], t[0]); */              /*   76: d0088f51cbff34 */\+/* sqr(t[0], t[0]); */              /*   77: 1a0111ea397fe68 */\+/* sqr(t[0], t[0]); */              /*   78: 340223d472ffcd0 */\+/* sqr(t[0], t[0]); */              /*   79: 680447a8e5ff9a0 */\+/* sqr(t[0], t[0]); */              /*   80: d0088f51cbff340 */\+sqr_n_mul(t[0], t[0], 6, t[4]);     /*   81: d0088f51cbff34d */\+/* sqr(t[0], t[0]); */              /*   82: 1a0111ea397fe69a */\+/* sqr(t[0], t[0]); */              /*   83: 340223d472ffcd34 */\+/* sqr(t[0], t[0]); */              /*   84: 680447a8e5ff9a68 */\+/* sqr(t[0], t[0]); */              /*   85: d0088f51cbff34d0 */\+/* sqr(t[0], t[0]); */              /*   86: 1a0111ea397fe69a0 */\+/* sqr(t[0], t[0]); */              /*   87: 340223d472ffcd340 */\+sqr_n_mul(t[0], t[0], 6, t[10]);    /*   88: 340223d472ffcd349 */\+/* sqr(t[0], t[0]); */              /*   89: 680447a8e5ff9a692 */\+/* sqr(t[0], t[0]); */              /*   90: d0088f51cbff34d24 */\+/* sqr(t[0], t[0]); */              /*   91: 1a0111ea397fe69a48 */\+sqr_n_mul(t[0], t[0], 3, t[9]);     /*   92: 1a0111ea397fe69a4b */\+/* sqr(t[0], t[0]); */              /*   93: 340223d472ffcd3496 */\+/* sqr(t[0], t[0]); */              /*   94: 680447a8e5ff9a692c */\+/* sqr(t[0], t[0]); */              /*   95: d0088f51cbff34d258 */\+/* sqr(t[0], t[0]); */              /*   96: 1a0111ea397fe69a4b0 */\+/* sqr(t[0], t[0]); */              /*   97: 340223d472ffcd34960 */\+/* sqr(t[0], t[0]); */              /*   98: 680447a8e5ff9a692c0 */\+/* sqr(t[0], t[0]); */              /*   99: d0088f51cbff34d2580 */\+sqr_n_mul(t[0], t[0], 7, t[4]);     /*  100: d0088f51cbff34d258d */\+/* sqr(t[0], t[0]); */              /*  101: 1a0111ea397fe69a4b1a */\+/* sqr(t[0], t[0]); */              /*  102: 340223d472ffcd349634 */\+/* sqr(t[0], t[0]); */              /*  103: 680447a8e5ff9a692c68 */\+/* sqr(t[0], t[0]); */              /*  104: d0088f51cbff34d258d0 */\+sqr_n_mul(t[0], t[0], 4, t[4]);     /*  105: d0088f51cbff34d258dd */\+/* sqr(t[0], t[0]); */              /*  106: 1a0111ea397fe69a4b1ba */\+/* sqr(t[0], t[0]); */              /*  107: 340223d472ffcd3496374 */\+/* sqr(t[0], t[0]); */              /*  108: 680447a8e5ff9a692c6e8 */\+/* sqr(t[0], t[0]); */              /*  109: d0088f51cbff34d258dd0 */\+/* sqr(t[0], t[0]); */              /*  110: 1a0111ea397fe69a4b1ba0 */\+/* sqr(t[0], t[0]); */              /*  111: 340223d472ffcd34963740 */\+sqr_n_mul(t[0], t[0], 6, t[8]);     /*  112: 340223d472ffcd3496374f */\+/* sqr(t[0], t[0]); */              /*  113: 680447a8e5ff9a692c6e9e */\+/* sqr(t[0], t[0]); */              /*  114: d0088f51cbff34d258dd3c */\+/* sqr(t[0], t[0]); */              /*  115: 1a0111ea397fe69a4b1ba78 */\+/* sqr(t[0], t[0]); */              /*  116: 340223d472ffcd3496374f0 */\+/* sqr(t[0], t[0]); */              /*  117: 680447a8e5ff9a692c6e9e0 */\+/* sqr(t[0], t[0]); */              /*  118: d0088f51cbff34d258dd3c0 */\+sqr_n_mul(t[0], t[0], 6, t[14]);    /*  119: d0088f51cbff34d258dd3db */\+/* sqr(t[0], t[0]); */              /*  120: 1a0111ea397fe69a4b1ba7b6 */\+/* sqr(t[0], t[0]); */              /*  121: 340223d472ffcd3496374f6c */\+/* sqr(t[0], t[0]); */              /*  122: 680447a8e5ff9a692c6e9ed8 */\+sqr_n_mul(t[0], t[0], 3, t[1]);     /*  123: 680447a8e5ff9a692c6e9ed9 */\+/* sqr(t[0], t[0]); */              /*  124: d0088f51cbff34d258dd3db2 */\+/* sqr(t[0], t[0]); */              /*  125: 1a0111ea397fe69a4b1ba7b64 */\+/* sqr(t[0], t[0]); */              /*  126: 340223d472ffcd3496374f6c8 */\+/* sqr(t[0], t[0]); */              /*  127: 680447a8e5ff9a692c6e9ed90 */\+/* sqr(t[0], t[0]); */              /*  128: d0088f51cbff34d258dd3db20 */\+/* sqr(t[0], t[0]); */              /*  129: 1a0111ea397fe69a4b1ba7b640 */\+/* sqr(t[0], t[0]); */              /*  130: 340223d472ffcd3496374f6c80 */\+/* sqr(t[0], t[0]); */              /*  131: 680447a8e5ff9a692c6e9ed900 */\+sqr_n_mul(t[0], t[0], 8, t[4]);     /*  132: 680447a8e5ff9a692c6e9ed90d */\+/* sqr(t[0], t[0]); */              /*  133: d0088f51cbff34d258dd3db21a */\+/* sqr(t[0], t[0]); */              /*  134: 1a0111ea397fe69a4b1ba7b6434 */\+/* sqr(t[0], t[0]); */              /*  135: 340223d472ffcd3496374f6c868 */\+/* sqr(t[0], t[0]); */              /*  136: 680447a8e5ff9a692c6e9ed90d0 */\+/* sqr(t[0], t[0]); */              /*  137: d0088f51cbff34d258dd3db21a0 */\+/* sqr(t[0], t[0]); */              /*  138: 1a0111ea397fe69a4b1ba7b64340 */\+/* sqr(t[0], t[0]); */              /*  139: 340223d472ffcd3496374f6c8680 */\+sqr_n_mul(t[0], t[0], 7, t[12]);    /*  140: 340223d472ffcd3496374f6c8697 */\+/* sqr(t[0], t[0]); */              /*  141: 680447a8e5ff9a692c6e9ed90d2e */\+/* sqr(t[0], t[0]); */              /*  142: d0088f51cbff34d258dd3db21a5c */\+/* sqr(t[0], t[0]); */              /*  143: 1a0111ea397fe69a4b1ba7b6434b8 */\+/* sqr(t[0], t[0]); */              /*  144: 340223d472ffcd3496374f6c86970 */\+/* sqr(t[0], t[0]); */              /*  145: 680447a8e5ff9a692c6e9ed90d2e0 */\+sqr_n_mul(t[0], t[0], 5, t[13]);    /*  146: 680447a8e5ff9a692c6e9ed90d2eb */\+/* sqr(t[0], t[0]); */              /*  147: d0088f51cbff34d258dd3db21a5d6 */\+/* sqr(t[0], t[0]); */              /*  148: 1a0111ea397fe69a4b1ba7b6434bac */\+/* sqr(t[0], t[0]); */              /*  149: 340223d472ffcd3496374f6c869758 */\+/* sqr(t[0], t[0]); */              /*  150: 680447a8e5ff9a692c6e9ed90d2eb0 */\+/* sqr(t[0], t[0]); */              /*  151: d0088f51cbff34d258dd3db21a5d60 */\+/* sqr(t[0], t[0]); */              /*  152: 1a0111ea397fe69a4b1ba7b6434bac0 */\+sqr_n_mul(t[0], t[0], 6, t[4]);     /*  153: 1a0111ea397fe69a4b1ba7b6434bacd */\+/* sqr(t[0], t[0]); */              /*  154: 340223d472ffcd3496374f6c869759a */\+/* sqr(t[0], t[0]); */              /*  155: 680447a8e5ff9a692c6e9ed90d2eb34 */\+/* sqr(t[0], t[0]); */              /*  156: d0088f51cbff34d258dd3db21a5d668 */\+/* sqr(t[0], t[0]); */              /*  157: 1a0111ea397fe69a4b1ba7b6434bacd0 */\+/* sqr(t[0], t[0]); */              /*  158: 340223d472ffcd3496374f6c869759a0 */\+/* sqr(t[0], t[0]); */              /*  159: 680447a8e5ff9a692c6e9ed90d2eb340 */\+sqr_n_mul(t[0], t[0], 6, t[6]);     /*  160: 680447a8e5ff9a692c6e9ed90d2eb35d */\+/* sqr(t[0], t[0]); */              /*  161: d0088f51cbff34d258dd3db21a5d66ba */\+/* sqr(t[0], t[0]); */              /*  162: 1a0111ea397fe69a4b1ba7b6434bacd74 */\+/* sqr(t[0], t[0]); */              /*  163: 340223d472ffcd3496374f6c869759ae8 */\+/* sqr(t[0], t[0]); */              /*  164: 680447a8e5ff9a692c6e9ed90d2eb35d0 */\+sqr_n_mul(t[0], t[0], 4, t[10]);    /*  165: 680447a8e5ff9a692c6e9ed90d2eb35d9 */\+/* sqr(t[0], t[0]); */              /*  166: d0088f51cbff34d258dd3db21a5d66bb2 */\+/* sqr(t[0], t[0]); */              /*  167: 1a0111ea397fe69a4b1ba7b6434bacd764 */\+/* sqr(t[0], t[0]); */              /*  168: 340223d472ffcd3496374f6c869759aec8 */\+/* sqr(t[0], t[0]); */              /*  169: 680447a8e5ff9a692c6e9ed90d2eb35d90 */\+/* sqr(t[0], t[0]); */              /*  170: d0088f51cbff34d258dd3db21a5d66bb20 */\+/* sqr(t[0], t[0]); */              /*  171: 1a0111ea397fe69a4b1ba7b6434bacd7640 */\+/* sqr(t[0], t[0]); */              /*  172: 340223d472ffcd3496374f6c869759aec80 */\+/* sqr(t[0], t[0]); */              /*  173: 680447a8e5ff9a692c6e9ed90d2eb35d900 */\+sqr_n_mul(t[0], t[0], 8, t[6]);     /*  174: 680447a8e5ff9a692c6e9ed90d2eb35d91d */\+/* sqr(t[0], t[0]); */              /*  175: d0088f51cbff34d258dd3db21a5d66bb23a */\+/* sqr(t[0], t[0]); */              /*  176: 1a0111ea397fe69a4b1ba7b6434bacd76474 */\+/* sqr(t[0], t[0]); */              /*  177: 340223d472ffcd3496374f6c869759aec8e8 */\+/* sqr(t[0], t[0]); */              /*  178: 680447a8e5ff9a692c6e9ed90d2eb35d91d0 */\+sqr_n_mul(t[0], t[0], 4, t[4]);     /*  179: 680447a8e5ff9a692c6e9ed90d2eb35d91dd */\+/* sqr(t[0], t[0]); */              /*  180: d0088f51cbff34d258dd3db21a5d66bb23ba */\+/* sqr(t[0], t[0]); */              /*  181: 1a0111ea397fe69a4b1ba7b6434bacd764774 */\+/* sqr(t[0], t[0]); */              /*  182: 340223d472ffcd3496374f6c869759aec8ee8 */\+/* sqr(t[0], t[0]); */              /*  183: 680447a8e5ff9a692c6e9ed90d2eb35d91dd0 */\+/* sqr(t[0], t[0]); */              /*  184: d0088f51cbff34d258dd3db21a5d66bb23ba0 */\+/* sqr(t[0], t[0]); */              /*  185: 1a0111ea397fe69a4b1ba7b6434bacd7647740 */\+/* sqr(t[0], t[0]); */              /*  186: 340223d472ffcd3496374f6c869759aec8ee80 */\+sqr_n_mul(t[0], t[0], 7, t[12]);    /*  187: 340223d472ffcd3496374f6c869759aec8ee97 */\+/* sqr(t[0], t[0]); */              /*  188: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e */\+/* sqr(t[0], t[0]); */              /*  189: d0088f51cbff34d258dd3db21a5d66bb23ba5c */\+/* sqr(t[0], t[0]); */              /*  190: 1a0111ea397fe69a4b1ba7b6434bacd764774b8 */\+/* sqr(t[0], t[0]); */              /*  191: 340223d472ffcd3496374f6c869759aec8ee970 */\+/* sqr(t[0], t[0]); */              /*  192: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e0 */\+/* sqr(t[0], t[0]); */              /*  193: d0088f51cbff34d258dd3db21a5d66bb23ba5c0 */\+/* sqr(t[0], t[0]); */              /*  194: 1a0111ea397fe69a4b1ba7b6434bacd764774b80 */\+/* sqr(t[0], t[0]); */              /*  195: 340223d472ffcd3496374f6c869759aec8ee9700 */\+/* sqr(t[0], t[0]); */              /*  196: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e00 */\+sqr_n_mul(t[0], t[0], 9, t[11]);    /*  197: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13 */\+/* sqr(t[0], t[0]); */              /*  198: d0088f51cbff34d258dd3db21a5d66bb23ba5c26 */\+/* sqr(t[0], t[0]); */              /*  199: 1a0111ea397fe69a4b1ba7b6434bacd764774b84c */\+sqr_n_mul(t[0], t[0], 2, t[9]);     /*  200: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f */\+/* sqr(t[0], t[0]); */              /*  201: 340223d472ffcd3496374f6c869759aec8ee9709e */\+/* sqr(t[0], t[0]); */              /*  202: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13c */\+/* sqr(t[0], t[0]); */              /*  203: d0088f51cbff34d258dd3db21a5d66bb23ba5c278 */\+/* sqr(t[0], t[0]); */              /*  204: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f0 */\+/* sqr(t[0], t[0]); */              /*  205: 340223d472ffcd3496374f6c869759aec8ee9709e0 */\+sqr_n_mul(t[0], t[0], 5, t[7]);     /*  206: 340223d472ffcd3496374f6c869759aec8ee9709e7 */\+/* sqr(t[0], t[0]); */              /*  207: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce */\+/* sqr(t[0], t[0]); */              /*  208: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c */\+/* sqr(t[0], t[0]); */              /*  209: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38 */\+/* sqr(t[0], t[0]); */              /*  210: 340223d472ffcd3496374f6c869759aec8ee9709e70 */\+/* sqr(t[0], t[0]); */              /*  211: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce0 */\+/* sqr(t[0], t[0]); */              /*  212: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c0 */\+/* sqr(t[0], t[0]); */              /*  213: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f380 */\+sqr_n_mul(t[0], t[0], 7, t[2]);     /*  214: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f385 */\+/* sqr(t[0], t[0]); */              /*  215: 340223d472ffcd3496374f6c869759aec8ee9709e70a */\+/* sqr(t[0], t[0]); */              /*  216: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce14 */\+/* sqr(t[0], t[0]); */              /*  217: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c28 */\+/* sqr(t[0], t[0]); */              /*  218: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f3850 */\+/* sqr(t[0], t[0]); */              /*  219: 340223d472ffcd3496374f6c869759aec8ee9709e70a0 */\+/* sqr(t[0], t[0]); */              /*  220: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce140 */\+/* sqr(t[0], t[0]); */              /*  221: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c280 */\+sqr_n_mul(t[0], t[0], 7, t[10]);    /*  222: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c289 */\+/* sqr(t[0], t[0]); */              /*  223: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512 */\+/* sqr(t[0], t[0]); */              /*  224: 340223d472ffcd3496374f6c869759aec8ee9709e70a24 */\+/* sqr(t[0], t[0]); */              /*  225: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce1448 */\+/* sqr(t[0], t[0]); */              /*  226: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2890 */\+/* sqr(t[0], t[0]); */              /*  227: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f385120 */\+/* sqr(t[0], t[0]); */              /*  228: 340223d472ffcd3496374f6c869759aec8ee9709e70a240 */\+sqr_n_mul(t[0], t[0], 6, t[12]);    /*  229: 340223d472ffcd3496374f6c869759aec8ee9709e70a257 */\+/* sqr(t[0], t[0]); */              /*  230: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144ae */\+/* sqr(t[0], t[0]); */              /*  231: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895c */\+/* sqr(t[0], t[0]); */              /*  232: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512b8 */\+/* sqr(t[0], t[0]); */              /*  233: 340223d472ffcd3496374f6c869759aec8ee9709e70a2570 */\+/* sqr(t[0], t[0]); */              /*  234: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144ae0 */\+sqr_n_mul(t[0], t[0], 5, t[6]);     /*  235: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd */\+/* sqr(t[0], t[0]); */              /*  236: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fa */\+/* sqr(t[0], t[0]); */              /*  237: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf4 */\+/* sqr(t[0], t[0]); */              /*  238: 340223d472ffcd3496374f6c869759aec8ee9709e70a257e8 */\+/* sqr(t[0], t[0]); */              /*  239: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd0 */\+/* sqr(t[0], t[0]); */              /*  240: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fa0 */\+sqr_n_mul(t[0], t[0], 5, t[11]);    /*  241: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb3 */\+/* sqr(t[0], t[0]); */              /*  242: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf66 */\+/* sqr(t[0], t[0]); */              /*  243: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ecc */\+/* sqr(t[0], t[0]); */              /*  244: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd98 */\+/* sqr(t[0], t[0]); */              /*  245: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb30 */\+/* sqr(t[0], t[0]); */              /*  246: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf660 */\+sqr_n_mul(t[0], t[0], 5, t[11]);    /*  247: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf673 */\+/* sqr(t[0], t[0]); */              /*  248: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece6 */\+/* sqr(t[0], t[0]); */              /*  249: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc */\+/* sqr(t[0], t[0]); */              /*  250: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb398 */\+/* sqr(t[0], t[0]); */              /*  251: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730 */\+/* sqr(t[0], t[0]); */              /*  252: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece60 */\+/* sqr(t[0], t[0]); */              /*  253: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc0 */\+/* sqr(t[0], t[0]); */              /*  254: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb3980 */\+/* sqr(t[0], t[0]); */              /*  255: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf67300 */\+sqr_n_mul(t[0], t[0], 8, t[4]);     /*  256: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d */\+/* sqr(t[0], t[0]); */              /*  257: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a */\+/* sqr(t[0], t[0]); */              /*  258: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34 */\+/* sqr(t[0], t[0]); */              /*  259: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39868 */\+/* sqr(t[0], t[0]); */              /*  260: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d0 */\+/* sqr(t[0], t[0]); */              /*  261: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a0 */\+/* sqr(t[0], t[0]); */              /*  262: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc340 */\+/* sqr(t[0], t[0]); */              /*  263: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb398680 */\+sqr_n_mul(t[0], t[0], 7, t[3]);     /*  264: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb398695 */\+/* sqr(t[0], t[0]); */              /*  265: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a */\+/* sqr(t[0], t[0]); */              /*  266: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a54 */\+/* sqr(t[0], t[0]); */              /*  267: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a8 */\+/* sqr(t[0], t[0]); */              /*  268: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb3986950 */\+/* sqr(t[0], t[0]); */              /*  269: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0 */\+/* sqr(t[0], t[0]); */              /*  270: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a540 */\+/* sqr(t[0], t[0]); */              /*  271: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a80 */\+/* sqr(t[0], t[0]); */              /*  272: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869500 */\+/* sqr(t[0], t[0]); */              /*  273: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a00 */\+sqr_n_mul(t[0], t[0], 9, t[8]);     /*  274: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f */\+/* sqr(t[0], t[0]); */              /*  275: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541e */\+/* sqr(t[0], t[0]); */              /*  276: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83c */\+/* sqr(t[0], t[0]); */              /*  277: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb398695078 */\+/* sqr(t[0], t[0]); */              /*  278: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f0 */\+/* sqr(t[0], t[0]); */              /*  279: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541e0 */\+sqr_n_mul(t[0], t[0], 5, t[4]);     /*  280: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed */\+/* sqr(t[0], t[0]); */              /*  281: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83da */\+/* sqr(t[0], t[0]); */              /*  282: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b4 */\+/* sqr(t[0], t[0]); */              /*  283: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f68 */\+sqr_n_mul(t[0], t[0], 3, t[9]);     /*  284: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b */\+/* sqr(t[0], t[0]); */              /*  285: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed6 */\+/* sqr(t[0], t[0]); */              /*  286: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac */\+/* sqr(t[0], t[0]); */              /*  287: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b58 */\+/* sqr(t[0], t[0]); */              /*  288: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0 */\+/* sqr(t[0], t[0]); */              /*  289: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed60 */\+/* sqr(t[0], t[0]); */              /*  290: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac0 */\+/* sqr(t[0], t[0]); */              /*  291: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b580 */\+/* sqr(t[0], t[0]); */              /*  292: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b00 */\+sqr_n_mul(t[0], t[0], 8, t[8]);     /*  293: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f */\+/* sqr(t[0], t[0]); */              /*  294: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61e */\+/* sqr(t[0], t[0]); */              /*  295: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3c */\+/* sqr(t[0], t[0]); */              /*  296: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b5878 */\+sqr_n_mul(t[0], t[0], 3, t[9]);     /*  297: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b */\+/* sqr(t[0], t[0]); */              /*  298: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6 */\+/* sqr(t[0], t[0]); */              /*  299: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec */\+/* sqr(t[0], t[0]); */              /*  300: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8 */\+/* sqr(t[0], t[0]); */              /*  301: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b0 */\+/* sqr(t[0], t[0]); */              /*  302: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f60 */\+/* sqr(t[0], t[0]); */              /*  303: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec0 */\+/* sqr(t[0], t[0]); */              /*  304: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d80 */\+sqr_n_mul(t[0], t[0], 7, t[10]);    /*  305: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d89 */\+/* sqr(t[0], t[0]); */              /*  306: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b12 */\+/* sqr(t[0], t[0]); */              /*  307: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f624 */\+/* sqr(t[0], t[0]); */              /*  308: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec48 */\+/* sqr(t[0], t[0]); */              /*  309: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d890 */\+/* sqr(t[0], t[0]); */              /*  310: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120 */\+/* sqr(t[0], t[0]); */              /*  311: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6240 */\+/* sqr(t[0], t[0]); */              /*  312: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec480 */\+/* sqr(t[0], t[0]); */              /*  313: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8900 */\+/* sqr(t[0], t[0]); */              /*  314: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b1200 */\+sqr_n_mul(t[0], t[0], 9, t[8]);     /*  315: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f */\+/* sqr(t[0], t[0]); */              /*  316: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241e */\+/* sqr(t[0], t[0]); */              /*  317: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483c */\+/* sqr(t[0], t[0]); */              /*  318: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d89078 */\+/* sqr(t[0], t[0]); */              /*  319: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f0 */\+/* sqr(t[0], t[0]); */              /*  320: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241e0 */\+/* sqr(t[0], t[0]); */              /*  321: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483c0 */\+sqr_n_mul(t[0], t[0], 6, t[3]);     /*  322: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d5 */\+/* sqr(t[0], t[0]); */              /*  323: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aa */\+/* sqr(t[0], t[0]); */              /*  324: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f54 */\+/* sqr(t[0], t[0]); */              /*  325: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241ea8 */\+/* sqr(t[0], t[0]); */              /*  326: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d50 */\+/* sqr(t[0], t[0]); */              /*  327: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aa0 */\+/* sqr(t[0], t[0]); */              /*  328: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f540 */\+sqr_n_mul(t[0], t[0], 6, t[5]);     /*  329: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55f */\+/* sqr(t[0], t[0]); */              /*  330: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabe */\+/* sqr(t[0], t[0]); */              /*  331: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57c */\+/* sqr(t[0], t[0]); */              /*  332: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaf8 */\+/* sqr(t[0], t[0]); */              /*  333: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55f0 */\+/* sqr(t[0], t[0]); */              /*  334: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabe0 */\+sqr_n_mul(t[0], t[0], 5, t[5]);     /*  335: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabff */\+/* sqr(t[0], t[0]); */              /*  336: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fe */\+/* sqr(t[0], t[0]); */              /*  337: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffc */\+/* sqr(t[0], t[0]); */              /*  338: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ff8 */\+/* sqr(t[0], t[0]); */              /*  339: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabff0 */\+/* sqr(t[0], t[0]); */              /*  340: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fe0 */\+sqr_n_mul(t[0], t[0], 5, t[5]);     /*  341: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fff */\+/* sqr(t[0], t[0]); */              /*  342: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aafffe */\+/* sqr(t[0], t[0]); */              /*  343: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55fffc */\+/* sqr(t[0], t[0]); */              /*  344: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfff8 */\+/* sqr(t[0], t[0]); */              /*  345: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fff0 */\+sqr_n_mul(t[0], t[0], 4, t[4]);     /*  346: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd */\+/* sqr(t[0], t[0]); */              /*  347: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffa */\+/* sqr(t[0], t[0]); */              /*  348: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff4 */\+/* sqr(t[0], t[0]); */              /*  349: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffe8 */\+sqr_n_mul(t[0], t[0], 3, t[9]);     /*  350: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb */\+/* sqr(t[0], t[0]); */              /*  351: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd6 */\+/* sqr(t[0], t[0]); */              /*  352: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac */\+/* sqr(t[0], t[0]); */              /*  353: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58 */\+/* sqr(t[0], t[0]); */              /*  354: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb0 */\+/* sqr(t[0], t[0]); */              /*  355: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd60 */\+/* sqr(t[0], t[0]); */              /*  356: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac0 */\+/* sqr(t[0], t[0]); */              /*  357: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff580 */\+/* sqr(t[0], t[0]); */              /*  358: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb00 */\+sqr_n_mul(t[0], t[0], 8, t[3]);     /*  359: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb15 */\+/* sqr(t[0], t[0]); */              /*  360: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a */\+/* sqr(t[0], t[0]); */              /*  361: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54 */\+/* sqr(t[0], t[0]); */              /*  362: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a8 */\+/* sqr(t[0], t[0]); */              /*  363: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb150 */\+/* sqr(t[0], t[0]); */              /*  364: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a0 */\+/* sqr(t[0], t[0]); */              /*  365: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac540 */\+/* sqr(t[0], t[0]); */              /*  366: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a80 */\+sqr_n_mul(t[0], t[0], 7, t[5]);     /*  367: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9f */\+/* sqr(t[0], t[0]); */              /*  368: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153e */\+/* sqr(t[0], t[0]); */              /*  369: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7c */\+/* sqr(t[0], t[0]); */              /*  370: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54f8 */\+/* sqr(t[0], t[0]); */              /*  371: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9f0 */\+/* sqr(t[0], t[0]); */              /*  372: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153e0 */\+sqr_n_mul(t[0], t[0], 5, t[5]);     /*  373: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ff */\+/* sqr(t[0], t[0]); */              /*  374: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7fe */\+/* sqr(t[0], t[0]); */              /*  375: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffc */\+/* sqr(t[0], t[0]); */              /*  376: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ff8 */\+/* sqr(t[0], t[0]); */              /*  377: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ff0 */\+/* sqr(t[0], t[0]); */              /*  378: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7fe0 */\+sqr_n_mul(t[0], t[0], 5, t[5]);     /*  379: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7fff */\+/* sqr(t[0], t[0]); */              /*  380: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54fffe */\+/* sqr(t[0], t[0]); */              /*  381: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9fffc */\+/* sqr(t[0], t[0]); */              /*  382: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153fff8 */\+/* sqr(t[0], t[0]); */              /*  383: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7fff0 */\+sqr_n_mul(t[0], t[0], 4, t[8]);     /*  384: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff */\+/* sqr(t[0], t[0]); */              /*  385: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffe */\+/* sqr(t[0], t[0]); */              /*  386: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffc */\+/* sqr(t[0], t[0]); */              /*  387: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffff8 */\+/* sqr(t[0], t[0]); */              /*  388: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff0 */\+sqr_n_mul(t[0], t[0], 4, t[7]);     /*  389: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff7 */\+/* sqr(t[0], t[0]); */              /*  390: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee */\+/* sqr(t[0], t[0]); */              /*  391: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdc */\+/* sqr(t[0], t[0]); */              /*  392: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb8 */\+/* sqr(t[0], t[0]); */              /*  393: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff70 */\+/* sqr(t[0], t[0]); */              /*  394: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee0 */\+/* sqr(t[0], t[0]); */              /*  395: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdc0 */\+/* sqr(t[0], t[0]); */              /*  396: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb80 */\+sqr_n_mul(t[0], t[0], 7, t[5]);     /*  397: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9f */\+/* sqr(t[0], t[0]); */              /*  398: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73e */\+/* sqr(t[0], t[0]); */              /*  399: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7c */\+/* sqr(t[0], t[0]); */              /*  400: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcf8 */\+/* sqr(t[0], t[0]); */              /*  401: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9f0 */\+/* sqr(t[0], t[0]); */              /*  402: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73e0 */\+sqr_n_mul(t[0], t[0], 5, t[6]);     /*  403: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fd */\+/* sqr(t[0], t[0]); */              /*  404: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fa */\+/* sqr(t[0], t[0]); */              /*  405: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff4 */\+/* sqr(t[0], t[0]); */              /*  406: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9fe8 */\+/* sqr(t[0], t[0]); */              /*  407: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fd0 */\+/* sqr(t[0], t[0]); */              /*  408: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fa0 */\+sqr_n_mul(t[0], t[0], 5, t[5]);     /*  409: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fbf */\+/* sqr(t[0], t[0]); */              /*  410: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7e */\+/* sqr(t[0], t[0]); */              /*  411: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9fefc */\+/* sqr(t[0], t[0]); */              /*  412: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fdf8 */\+/* sqr(t[0], t[0]); */              /*  413: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fbf0 */\+/* sqr(t[0], t[0]); */              /*  414: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7e0 */\+sqr_n_mul(t[0], t[0], 5, t[5]);     /*  415: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7ff */\+/* sqr(t[0], t[0]); */              /*  416: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffe */\+/* sqr(t[0], t[0]); */              /*  417: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fdffc */\+/* sqr(t[0], t[0]); */              /*  418: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fbff8 */\+/* sqr(t[0], t[0]); */              /*  419: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7ff0 */\+/* sqr(t[0], t[0]); */              /*  420: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffe0 */\+sqr_n_mul(t[0], t[0], 5, t[5]);     /*  421: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffff */\+/* sqr(t[0], t[0]); */              /*  422: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fdfffe */\+/* sqr(t[0], t[0]); */              /*  423: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fbfffc */\+/* sqr(t[0], t[0]); */              /*  424: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7fff8 */\+/* sqr(t[0], t[0]); */              /*  425: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffff0 */\+/* sqr(t[0], t[0]); */              /*  426: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fdfffe0 */\+sqr_n_mul(t[0], t[0], 5, t[5]);     /*  427: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fdfffff */\+/* sqr(t[0], t[0]); */              /*  428: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fbffffe */\+/* sqr(t[0], t[0]); */              /*  429: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7ffffc */\+/* sqr(t[0], t[0]); */              /*  430: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9fefffff8 */\+/* sqr(t[0], t[0]); */              /*  431: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fdfffff0 */\+/* sqr(t[0], t[0]); */              /*  432: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fbffffe0 */\+sqr_n_mul(t[0], t[0], 5, t[5]);     /*  433: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fbffffff */\+/* sqr(t[0], t[0]); */              /*  434: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7fffffe */\+/* sqr(t[0], t[0]); */              /*  435: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffc */\+/* sqr(t[0], t[0]); */              /*  436: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fdffffff8 */\+/* sqr(t[0], t[0]); */              /*  437: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fbffffff0 */\+/* sqr(t[0], t[0]); */              /*  438: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7fffffe0 */\+sqr_n_mul(t[0], t[0], 5, t[5]);     /*  439: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7fffffff */\+/* sqr(t[0], t[0]); */              /*  440: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9fefffffffe */\+/* sqr(t[0], t[0]); */              /*  441: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fdfffffffc */\+/* sqr(t[0], t[0]); */              /*  442: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fbfffffff8 */\+/* sqr(t[0], t[0]); */              /*  443: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7fffffff0 */\+sqr_n_mul(t[0], t[0], 4, t[4]);     /*  444: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7fffffffd */\+/* sqr(t[0], t[0]); */              /*  445: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffa */\+/* sqr(t[0], t[0]); */              /*  446: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fdffffffff4 */\+/* sqr(t[0], t[0]); */              /*  447: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fbfffffffe8 */\+/* sqr(t[0], t[0]); */              /*  448: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7fffffffd0 */\+/* sqr(t[0], t[0]); */              /*  449: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffa0 */\+/* sqr(t[0], t[0]); */              /*  450: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fdffffffff40 */\+sqr_n_mul(t[0], t[0], 6, t[3]);     /*  451: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fdffffffff55 */\+/* sqr(t[0], t[0]); */              /*  452: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fbfffffffeaa */\+/* sqr(t[0], t[0]); */              /*  453: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7fffffffd54 */\+/* sqr(t[0], t[0]); */              /*  454: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaa8 */\+/* sqr(t[0], t[0]); */              /*  455: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fdffffffff550 */\+sqr_n_mul(t[0], t[0], 4, t[2]);     /*  456: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fdffffffff555 */\+/* sqr(t[0], t[0]); */              /*  457: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fbfffffffeaaa */\+/* sqr(t[0], t[0]); */              /*  458: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7fffffffd554 */\+/* sqr(t[0], t[0]); */              /*  459: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaa8 */\+sqr_n_mul(out, t[0], 3, t[1]);      /*  460: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaaa9 */\+} while(0)
+ c-source/src/recip.c view
@@ -0,0 +1,139 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */++#include "fields.h"++#ifdef __OPTIMIZE_SIZE__+/*+ * 608 multiplications for scalar inversion modulo BLS12-381 prime, 32%+ * more than corresponding optimal addition-chain, plus mispredicted+ * branch penalties on top of that... The addition chain below was+ * measured to be >50% faster.+ */+static void flt_reciprocal_fp(vec384 out, const vec384 inp)+{+    static const byte BLS12_381_P_minus_2[] = {+        TO_BYTES(0xb9feffffffffaaa9), TO_BYTES(0x1eabfffeb153ffff),+        TO_BYTES(0x6730d2a0f6b0f624), TO_BYTES(0x64774b84f38512bf),+        TO_BYTES(0x4b1ba7b6434bacd7), TO_BYTES(0x1a0111ea397fe69a)+    };++    exp_mont_384(out, inp, BLS12_381_P_minus_2, 381, BLS12_381_P, p0);+}+#else+# define sqr(ret,a)		sqr_fp(ret,a)+# define mul(ret,a,b)		mul_fp(ret,a,b)+# define sqr_n_mul(ret,a,n,b)	sqr_n_mul_fp(ret,a,n,b)++# include "recip-addchain.h"+static void flt_reciprocal_fp(vec384 out, const vec384 inp)+{+    RECIPROCAL_MOD_BLS12_381_P(out, inp, vec384);+}+# undef RECIPROCAL_MOD_BLS12_381_P+# undef sqr_n_mul+# undef mul+# undef sqr+#endif++static void flt_reciprocal_fp2(vec384x out, const vec384x inp)+{+    vec384 t0, t1;++    /*+     * |out| = 1/(a + b*i) = a/(a^2+b^2) - b/(a^2+b^2)*i+     */+    sqr_fp(t0, inp[0]);+    sqr_fp(t1, inp[1]);+    add_fp(t0, t0, t1);+    flt_reciprocal_fp(t1, t0);+    mul_fp(out[0], inp[0], t1);+    mul_fp(out[1], inp[1], t1);+    neg_fp(out[1], out[1]);+}++static void reciprocal_fp(vec384 out, const vec384 inp)+{+    static const vec384 Px8 = {    /* left-aligned value of the modulus */+        TO_LIMB_T(0xcff7fffffffd5558), TO_LIMB_T(0xf55ffff58a9ffffd),+        TO_LIMB_T(0x39869507b587b120), TO_LIMB_T(0x23ba5c279c2895fb),+        TO_LIMB_T(0x58dd3db21a5d66bb), TO_LIMB_T(0xd0088f51cbff34d2)+    };+#ifdef __BLST_NO_ASM__+# define RRx4 BLS12_381_RR+#else+    static const vec384 RRx4 = {   /* (4<<768)%P */+        TO_LIMB_T(0x5f7e7cd070d107c2), TO_LIMB_T(0xec839a9ac49c13c8),+        TO_LIMB_T(0x6933786f44f4ef0b), TO_LIMB_T(0xd6bf8b9c676be983),+        TO_LIMB_T(0xd3adaaaa4dcefb06), TO_LIMB_T(0x12601bc1d82bc175)+    };+#endif+    union { vec768 x; vec384 r[2]; } temp;++    ct_inverse_mod_383(temp.x, inp, BLS12_381_P, Px8);+    redc_mont_384(temp.r[0], temp.x, BLS12_381_P, p0);+    mul_mont_384(temp.r[0], temp.r[0], RRx4, BLS12_381_P, p0);++#ifndef FUZZING_BUILD_MODE_UNSAFE_FOR_PRODUCTION+    /* sign goes straight to flt_reciprocal */+    mul_mont_384(temp.r[1], temp.r[0], inp, BLS12_381_P, p0);+    if (vec_is_equal(temp.r[1],  BLS12_381_Rx.p, sizeof(vec384)) |+        vec_is_zero(temp.r[1], sizeof(vec384)))+        vec_copy(out, temp.r[0], sizeof(vec384));+    else+        flt_reciprocal_fp(out, inp);+#else+    vec_copy(out, temp.r[0], sizeof(vec384));+#endif+#undef RRx4+}++void blst_fp_inverse(vec384 out, const vec384 inp)+{   reciprocal_fp(out, inp);   }++void blst_fp_eucl_inverse(vec384 ret, const vec384 a)+{   reciprocal_fp(ret, a);   }++static void reciprocal_fp2(vec384x out, const vec384x inp)+{+    vec384 t0, t1;++    /*+     * |out| = 1/(a + b*i) = a/(a^2+b^2) - b/(a^2+b^2)*i+     */+    sqr_fp(t0, inp[0]);+    sqr_fp(t1, inp[1]);+    add_fp(t0, t0, t1);+    reciprocal_fp(t1, t0);+    mul_fp(out[0], inp[0], t1);+    mul_fp(out[1], inp[1], t1);+    neg_fp(out[1], out[1]);+}++void blst_fp2_inverse(vec384x out, const vec384x inp)+{   reciprocal_fp2(out, inp);   }++void blst_fp2_eucl_inverse(vec384x out, const vec384x inp)+{   reciprocal_fp2(out, inp);   }++static void reciprocal_fr(vec256 out, const vec256 inp)+{+    static const vec256 rx2 = { /* left-aligned value of the modulus */+        TO_LIMB_T(0xfffffffe00000002), TO_LIMB_T(0xa77b4805fffcb7fd),+        TO_LIMB_T(0x6673b0101343b00a), TO_LIMB_T(0xe7db4ea6533afa90),+    };+    vec512 temp;++    ct_inverse_mod_256(temp, inp, BLS12_381_r, rx2);+    redc_mont_256(out, temp, BLS12_381_r, r0);+    mul_mont_sparse_256(out, out, BLS12_381_rRR, BLS12_381_r, r0);+}++void blst_fr_inverse(vec256 out, const vec256 inp)+{   reciprocal_fr(out, inp);   }++void blst_fr_eucl_inverse(vec256 out, const vec256 inp)+{   reciprocal_fr(out, inp);   }
+ c-source/src/server.c view
@@ -0,0 +1,24 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */++#include "keygen.c"+#include "hash_to_field.c"+#include "e1.c"+#include "map_to_g1.c"+#include "e2.c"+#include "map_to_g2.c"+#include "fp12_tower.c"+#include "pairing.c"+#include "aggregate.c"+#include "exp.c"+#include "sqrt.c"+#include "recip.c"+#include "bulk_addition.c"+#include "multi_scalar.c"+#include "consts.c"+#include "vect.c"+#include "exports.c"+#include "rb_tree.c"
+ c-source/src/sha256.h view
@@ -0,0 +1,140 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */+#ifndef __BLS12_381_ASM_SHA256_H__+#define __BLS12_381_ASM_SHA256_H__++#include "vect.h"++#if (defined(__x86_64__) || defined(__x86_64) || defined(_M_X64)) && \+     defined(__SHA__) /* -msha */ && !defined(__BLST_PORTABLE__)+# define sha256_block_data_order blst_sha256_block_data_order_shaext+#elif defined(__aarch64__) && \+      defined(__ARM_FEATURE_CRYPTO) && !defined(__BLST_PORTABLE__)+# define sha256_block_data_order blst_sha256_block_armv8+#else+# define sha256_block_data_order blst_sha256_block_data_order+#endif+#define sha256_hcopy blst_sha256_hcopy+#define sha256_bcopy blst_sha256_bcopy+#define sha256_emit  blst_sha256_emit++void sha256_block_data_order(unsigned int *h, const void *inp, size_t blocks);+void sha256_hcopy(unsigned int dst[8], const unsigned int src[8]);+void sha256_bcopy(void *dst, const void *src, size_t len);++/*+ * If SHA256_CTX conflicts with something, just redefine it to alternative+ * custom name prior including this header.+ */+typedef struct {+    unsigned int h[8];+    unsigned long long N;+    unsigned char buf[64];+    size_t off;+} SHA256_CTX;+++static void sha256_init_h(unsigned int h[8])+{+    h[0] = 0x6a09e667U;+    h[1] = 0xbb67ae85U;+    h[2] = 0x3c6ef372U;+    h[3] = 0xa54ff53aU;+    h[4] = 0x510e527fU;+    h[5] = 0x9b05688cU;+    h[6] = 0x1f83d9abU;+    h[7] = 0x5be0cd19U;+}++static void sha256_init(SHA256_CTX *ctx)+{+    sha256_init_h(ctx->h);+    ctx->N = 0;+    vec_zero(ctx->buf, sizeof(ctx->buf));+    ctx->off = 0;+}++static void sha256_update(SHA256_CTX *ctx, const void *_inp, size_t len)+{+    size_t n;+    const unsigned char *inp = _inp;++    ctx->N += len;++    if ((len != 0) & ((n = ctx->off) != 0)) {+        size_t rem = sizeof(ctx->buf) - n;++        if (rem > len) {+            sha256_bcopy(ctx->buf + n, inp, len);+            ctx->off += len;+            return;+        } else {+            sha256_bcopy(ctx->buf + n, inp, rem);+            inp += rem;+            len -= rem;+            sha256_block_data_order(ctx->h, ctx->buf, 1);+            vec_zero(ctx->buf, sizeof(ctx->buf));+            ctx->off = 0;+        }+    }++    n = len / sizeof(ctx->buf);+    if (n > 0) {+        sha256_block_data_order(ctx->h, inp, n);+        n *= sizeof(ctx->buf);+        inp += n;+        len -= n;+    }++    if (len)+        sha256_bcopy(ctx->buf, inp, ctx->off = len);+}++#define __TOBE32(ptr, val) ((ptr)[0] = (unsigned char)((val)>>24), \+                            (ptr)[1] = (unsigned char)((val)>>16), \+                            (ptr)[2] = (unsigned char)((val)>>8),  \+                            (ptr)[3] = (unsigned char)(val))++#if 1+void sha256_emit(unsigned char md[32], const unsigned int h[8]);+#else+static void sha256_emit(unsigned char md[32], const unsigned int h[8])+{+    unsigned int h_i;++    h_i = h[0]; __TOBE32(md + 0, h_i);+    h_i = h[1]; __TOBE32(md + 4, h_i);+    h_i = h[2]; __TOBE32(md + 8, h_i);+    h_i = h[3]; __TOBE32(md + 12, h_i);+    h_i = h[4]; __TOBE32(md + 16, h_i);+    h_i = h[5]; __TOBE32(md + 20, h_i);+    h_i = h[6]; __TOBE32(md + 24, h_i);+    h_i = h[7]; __TOBE32(md + 28, h_i);+}+#endif++static void sha256_final(unsigned char md[32], SHA256_CTX *ctx)+{+    unsigned long long bits = ctx->N * 8;+    size_t n = ctx->off;+    unsigned char *tail;++    ctx->buf[n++] = 0x80;++    if (n > (sizeof(ctx->buf) - 8)) {+        sha256_block_data_order(ctx->h, ctx->buf, 1);+        vec_zero(ctx->buf, sizeof(ctx->buf));+    }++    tail = ctx->buf + sizeof(ctx->buf) - 8;+    __TOBE32(tail, (unsigned int)(bits >> 32));+    __TOBE32(tail + 4, (unsigned int)bits);+    sha256_block_data_order(ctx->h, ctx->buf, 1);+    sha256_emit(md, ctx->h);+}++#undef __TOBE32+#endif
+ c-source/src/sqrt-addchain.h view
@@ -0,0 +1,489 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */+/*+ * The "magic" number is (BLS12_381_P-3)/4. Exponentiation to which+ * yields reciprocal of sqrt(x), which is used in simplified Shallue-+ * van de Woestijne-Ulas map-to-curve method, but it's trivial to adapt+ * it for more "traditional" sqrt(x) as 'x*ret' (or for is_square(x)+ * as 'x*ret^2==1').+ *+ * Generated with 'addchain 1000602388805416848354447456433976039139220704984751971333014534031007912622709466110671907282253916009473568139946'+ * https://github.com/kwantam/addchain+ *+ * # Bos-Coster (win=4)           :  458 (16) <<<+ * # Bos-Coster (win=5)           :  460 (28)+ * # Bos-Coster (win=6)           :  461 (33)+ * # Bos-Coster (win=7)           :  460 (28)+ * # Bos-Coster (win=3)           :  462 ( 9)+ * # Bos-Coster (win=8)           :  466 (34)+ * # Bos-Coster (win=9)           :  464 (31)+ * # Yacobi                       :  478 (31)+ * # Bos-Coster (win=10)          :  473 (30)+ * # Bos-Coster (win=2)           :  486 ( 5)+ * # Bergeron-Berstel-Brlek-Duboc :  489 ( 5)+ */++#define RECIP_SQRT_MOD_BLS12_381_P(out, inp, ptype) do { \+ptype t[16]; \+vec_copy(t[13], inp, sizeof(ptype));/*    0: 1 */\+sqr(t[0], t[13]);                   /*    1: 2 */\+mul(t[8], t[0], t[13]);             /*    2: 3 */\+sqr(t[4], t[0]);                    /*    3: 4 */\+mul(t[1], t[8], t[0]);              /*    4: 5 */\+mul(t[6], t[4], t[8]);              /*    5: 7 */\+mul(t[9], t[1], t[4]);              /*    6: 9 */\+mul(t[12], t[6], t[4]);             /*    7: b */\+mul(t[3], t[9], t[4]);              /*    8: d */\+mul(t[7], t[12], t[4]);             /*    9: f */\+mul(t[15], t[3], t[4]);             /*   10: 11 */\+mul(t[10], t[7], t[4]);             /*   11: 13 */\+mul(t[2], t[15], t[4]);             /*   12: 15 */\+mul(t[11], t[10], t[4]);            /*   13: 17 */\+sqr(t[0], t[3]);                    /*   14: 1a */\+mul(t[14], t[11], t[4]);            /*   15: 1b */\+mul(t[5], t[0], t[8]);              /*   16: 1d */\+mul(t[4], t[0], t[1]);              /*   17: 1f */\+/* sqr(t[0], t[0]); */              /*   18: 34 */\+/* sqr(t[0], t[0]); */              /*   19: 68 */\+/* sqr(t[0], t[0]); */              /*   20: d0 */\+/* sqr(t[0], t[0]); */              /*   21: 1a0 */\+/* sqr(t[0], t[0]); */              /*   22: 340 */\+/* sqr(t[0], t[0]); */              /*   23: 680 */\+/* sqr(t[0], t[0]); */              /*   24: d00 */\+/* sqr(t[0], t[0]); */              /*   25: 1a00 */\+/* sqr(t[0], t[0]); */              /*   26: 3400 */\+/* sqr(t[0], t[0]); */              /*   27: 6800 */\+/* sqr(t[0], t[0]); */              /*   28: d000 */\+/* sqr(t[0], t[0]); */              /*   29: 1a000 */\+sqr_n_mul(t[0], t[0], 12, t[15]);   /*   30: 1a011 */\+/* sqr(t[0], t[0]); */              /*   31: 34022 */\+/* sqr(t[0], t[0]); */              /*   32: 68044 */\+/* sqr(t[0], t[0]); */              /*   33: d0088 */\+/* sqr(t[0], t[0]); */              /*   34: 1a0110 */\+/* sqr(t[0], t[0]); */              /*   35: 340220 */\+/* sqr(t[0], t[0]); */              /*   36: 680440 */\+/* sqr(t[0], t[0]); */              /*   37: d00880 */\+sqr_n_mul(t[0], t[0], 7, t[7]);     /*   38: d0088f */\+/* sqr(t[0], t[0]); */              /*   39: 1a0111e */\+/* sqr(t[0], t[0]); */              /*   40: 340223c */\+/* sqr(t[0], t[0]); */              /*   41: 6804478 */\+/* sqr(t[0], t[0]); */              /*   42: d0088f0 */\+sqr_n_mul(t[0], t[0], 4, t[1]);     /*   43: d0088f5 */\+/* sqr(t[0], t[0]); */              /*   44: 1a0111ea */\+/* sqr(t[0], t[0]); */              /*   45: 340223d4 */\+/* sqr(t[0], t[0]); */              /*   46: 680447a8 */\+/* sqr(t[0], t[0]); */              /*   47: d0088f50 */\+/* sqr(t[0], t[0]); */              /*   48: 1a0111ea0 */\+/* sqr(t[0], t[0]); */              /*   49: 340223d40 */\+sqr_n_mul(t[0], t[0], 6, t[6]);     /*   50: 340223d47 */\+/* sqr(t[0], t[0]); */              /*   51: 680447a8e */\+/* sqr(t[0], t[0]); */              /*   52: d0088f51c */\+/* sqr(t[0], t[0]); */              /*   53: 1a0111ea38 */\+/* sqr(t[0], t[0]); */              /*   54: 340223d470 */\+/* sqr(t[0], t[0]); */              /*   55: 680447a8e0 */\+/* sqr(t[0], t[0]); */              /*   56: d0088f51c0 */\+/* sqr(t[0], t[0]); */              /*   57: 1a0111ea380 */\+sqr_n_mul(t[0], t[0], 7, t[11]);    /*   58: 1a0111ea397 */\+/* sqr(t[0], t[0]); */              /*   59: 340223d472e */\+/* sqr(t[0], t[0]); */              /*   60: 680447a8e5c */\+/* sqr(t[0], t[0]); */              /*   61: d0088f51cb8 */\+/* sqr(t[0], t[0]); */              /*   62: 1a0111ea3970 */\+/* sqr(t[0], t[0]); */              /*   63: 340223d472e0 */\+sqr_n_mul(t[0], t[0], 5, t[4]);     /*   64: 340223d472ff */\+/* sqr(t[0], t[0]); */              /*   65: 680447a8e5fe */\+/* sqr(t[0], t[0]); */              /*   66: d0088f51cbfc */\+sqr_n_mul(t[0], t[0], 2, t[8]);     /*   67: d0088f51cbff */\+/* sqr(t[0], t[0]); */              /*   68: 1a0111ea397fe */\+/* sqr(t[0], t[0]); */              /*   69: 340223d472ffc */\+/* sqr(t[0], t[0]); */              /*   70: 680447a8e5ff8 */\+/* sqr(t[0], t[0]); */              /*   71: d0088f51cbff0 */\+/* sqr(t[0], t[0]); */              /*   72: 1a0111ea397fe0 */\+/* sqr(t[0], t[0]); */              /*   73: 340223d472ffc0 */\+sqr_n_mul(t[0], t[0], 6, t[3]);     /*   74: 340223d472ffcd */\+/* sqr(t[0], t[0]); */              /*   75: 680447a8e5ff9a */\+/* sqr(t[0], t[0]); */              /*   76: d0088f51cbff34 */\+/* sqr(t[0], t[0]); */              /*   77: 1a0111ea397fe68 */\+/* sqr(t[0], t[0]); */              /*   78: 340223d472ffcd0 */\+/* sqr(t[0], t[0]); */              /*   79: 680447a8e5ff9a0 */\+/* sqr(t[0], t[0]); */              /*   80: d0088f51cbff340 */\+sqr_n_mul(t[0], t[0], 6, t[3]);     /*   81: d0088f51cbff34d */\+/* sqr(t[0], t[0]); */              /*   82: 1a0111ea397fe69a */\+/* sqr(t[0], t[0]); */              /*   83: 340223d472ffcd34 */\+/* sqr(t[0], t[0]); */              /*   84: 680447a8e5ff9a68 */\+/* sqr(t[0], t[0]); */              /*   85: d0088f51cbff34d0 */\+/* sqr(t[0], t[0]); */              /*   86: 1a0111ea397fe69a0 */\+/* sqr(t[0], t[0]); */              /*   87: 340223d472ffcd340 */\+sqr_n_mul(t[0], t[0], 6, t[9]);     /*   88: 340223d472ffcd349 */\+/* sqr(t[0], t[0]); */              /*   89: 680447a8e5ff9a692 */\+/* sqr(t[0], t[0]); */              /*   90: d0088f51cbff34d24 */\+/* sqr(t[0], t[0]); */              /*   91: 1a0111ea397fe69a48 */\+sqr_n_mul(t[0], t[0], 3, t[8]);     /*   92: 1a0111ea397fe69a4b */\+/* sqr(t[0], t[0]); */              /*   93: 340223d472ffcd3496 */\+/* sqr(t[0], t[0]); */              /*   94: 680447a8e5ff9a692c */\+/* sqr(t[0], t[0]); */              /*   95: d0088f51cbff34d258 */\+/* sqr(t[0], t[0]); */              /*   96: 1a0111ea397fe69a4b0 */\+/* sqr(t[0], t[0]); */              /*   97: 340223d472ffcd34960 */\+/* sqr(t[0], t[0]); */              /*   98: 680447a8e5ff9a692c0 */\+/* sqr(t[0], t[0]); */              /*   99: d0088f51cbff34d2580 */\+sqr_n_mul(t[0], t[0], 7, t[3]);     /*  100: d0088f51cbff34d258d */\+/* sqr(t[0], t[0]); */              /*  101: 1a0111ea397fe69a4b1a */\+/* sqr(t[0], t[0]); */              /*  102: 340223d472ffcd349634 */\+/* sqr(t[0], t[0]); */              /*  103: 680447a8e5ff9a692c68 */\+/* sqr(t[0], t[0]); */              /*  104: d0088f51cbff34d258d0 */\+sqr_n_mul(t[0], t[0], 4, t[3]);     /*  105: d0088f51cbff34d258dd */\+/* sqr(t[0], t[0]); */              /*  106: 1a0111ea397fe69a4b1ba */\+/* sqr(t[0], t[0]); */              /*  107: 340223d472ffcd3496374 */\+/* sqr(t[0], t[0]); */              /*  108: 680447a8e5ff9a692c6e8 */\+/* sqr(t[0], t[0]); */              /*  109: d0088f51cbff34d258dd0 */\+/* sqr(t[0], t[0]); */              /*  110: 1a0111ea397fe69a4b1ba0 */\+/* sqr(t[0], t[0]); */              /*  111: 340223d472ffcd34963740 */\+sqr_n_mul(t[0], t[0], 6, t[7]);     /*  112: 340223d472ffcd3496374f */\+/* sqr(t[0], t[0]); */              /*  113: 680447a8e5ff9a692c6e9e */\+/* sqr(t[0], t[0]); */              /*  114: d0088f51cbff34d258dd3c */\+/* sqr(t[0], t[0]); */              /*  115: 1a0111ea397fe69a4b1ba78 */\+/* sqr(t[0], t[0]); */              /*  116: 340223d472ffcd3496374f0 */\+/* sqr(t[0], t[0]); */              /*  117: 680447a8e5ff9a692c6e9e0 */\+/* sqr(t[0], t[0]); */              /*  118: d0088f51cbff34d258dd3c0 */\+sqr_n_mul(t[0], t[0], 6, t[14]);    /*  119: d0088f51cbff34d258dd3db */\+/* sqr(t[0], t[0]); */              /*  120: 1a0111ea397fe69a4b1ba7b6 */\+/* sqr(t[0], t[0]); */              /*  121: 340223d472ffcd3496374f6c */\+/* sqr(t[0], t[0]); */              /*  122: 680447a8e5ff9a692c6e9ed8 */\+sqr_n_mul(t[0], t[0], 3, t[13]);    /*  123: 680447a8e5ff9a692c6e9ed9 */\+/* sqr(t[0], t[0]); */              /*  124: d0088f51cbff34d258dd3db2 */\+/* sqr(t[0], t[0]); */              /*  125: 1a0111ea397fe69a4b1ba7b64 */\+/* sqr(t[0], t[0]); */              /*  126: 340223d472ffcd3496374f6c8 */\+/* sqr(t[0], t[0]); */              /*  127: 680447a8e5ff9a692c6e9ed90 */\+/* sqr(t[0], t[0]); */              /*  128: d0088f51cbff34d258dd3db20 */\+/* sqr(t[0], t[0]); */              /*  129: 1a0111ea397fe69a4b1ba7b640 */\+/* sqr(t[0], t[0]); */              /*  130: 340223d472ffcd3496374f6c80 */\+/* sqr(t[0], t[0]); */              /*  131: 680447a8e5ff9a692c6e9ed900 */\+sqr_n_mul(t[0], t[0], 8, t[3]);     /*  132: 680447a8e5ff9a692c6e9ed90d */\+/* sqr(t[0], t[0]); */              /*  133: d0088f51cbff34d258dd3db21a */\+/* sqr(t[0], t[0]); */              /*  134: 1a0111ea397fe69a4b1ba7b6434 */\+/* sqr(t[0], t[0]); */              /*  135: 340223d472ffcd3496374f6c868 */\+/* sqr(t[0], t[0]); */              /*  136: 680447a8e5ff9a692c6e9ed90d0 */\+/* sqr(t[0], t[0]); */              /*  137: d0088f51cbff34d258dd3db21a0 */\+/* sqr(t[0], t[0]); */              /*  138: 1a0111ea397fe69a4b1ba7b64340 */\+/* sqr(t[0], t[0]); */              /*  139: 340223d472ffcd3496374f6c8680 */\+sqr_n_mul(t[0], t[0], 7, t[11]);    /*  140: 340223d472ffcd3496374f6c8697 */\+/* sqr(t[0], t[0]); */              /*  141: 680447a8e5ff9a692c6e9ed90d2e */\+/* sqr(t[0], t[0]); */              /*  142: d0088f51cbff34d258dd3db21a5c */\+/* sqr(t[0], t[0]); */              /*  143: 1a0111ea397fe69a4b1ba7b6434b8 */\+/* sqr(t[0], t[0]); */              /*  144: 340223d472ffcd3496374f6c86970 */\+/* sqr(t[0], t[0]); */              /*  145: 680447a8e5ff9a692c6e9ed90d2e0 */\+sqr_n_mul(t[0], t[0], 5, t[12]);    /*  146: 680447a8e5ff9a692c6e9ed90d2eb */\+/* sqr(t[0], t[0]); */              /*  147: d0088f51cbff34d258dd3db21a5d6 */\+/* sqr(t[0], t[0]); */              /*  148: 1a0111ea397fe69a4b1ba7b6434bac */\+/* sqr(t[0], t[0]); */              /*  149: 340223d472ffcd3496374f6c869758 */\+/* sqr(t[0], t[0]); */              /*  150: 680447a8e5ff9a692c6e9ed90d2eb0 */\+/* sqr(t[0], t[0]); */              /*  151: d0088f51cbff34d258dd3db21a5d60 */\+/* sqr(t[0], t[0]); */              /*  152: 1a0111ea397fe69a4b1ba7b6434bac0 */\+sqr_n_mul(t[0], t[0], 6, t[3]);     /*  153: 1a0111ea397fe69a4b1ba7b6434bacd */\+/* sqr(t[0], t[0]); */              /*  154: 340223d472ffcd3496374f6c869759a */\+/* sqr(t[0], t[0]); */              /*  155: 680447a8e5ff9a692c6e9ed90d2eb34 */\+/* sqr(t[0], t[0]); */              /*  156: d0088f51cbff34d258dd3db21a5d668 */\+/* sqr(t[0], t[0]); */              /*  157: 1a0111ea397fe69a4b1ba7b6434bacd0 */\+/* sqr(t[0], t[0]); */              /*  158: 340223d472ffcd3496374f6c869759a0 */\+/* sqr(t[0], t[0]); */              /*  159: 680447a8e5ff9a692c6e9ed90d2eb340 */\+sqr_n_mul(t[0], t[0], 6, t[5]);     /*  160: 680447a8e5ff9a692c6e9ed90d2eb35d */\+/* sqr(t[0], t[0]); */              /*  161: d0088f51cbff34d258dd3db21a5d66ba */\+/* sqr(t[0], t[0]); */              /*  162: 1a0111ea397fe69a4b1ba7b6434bacd74 */\+/* sqr(t[0], t[0]); */              /*  163: 340223d472ffcd3496374f6c869759ae8 */\+/* sqr(t[0], t[0]); */              /*  164: 680447a8e5ff9a692c6e9ed90d2eb35d0 */\+sqr_n_mul(t[0], t[0], 4, t[9]);     /*  165: 680447a8e5ff9a692c6e9ed90d2eb35d9 */\+/* sqr(t[0], t[0]); */              /*  166: d0088f51cbff34d258dd3db21a5d66bb2 */\+/* sqr(t[0], t[0]); */              /*  167: 1a0111ea397fe69a4b1ba7b6434bacd764 */\+/* sqr(t[0], t[0]); */              /*  168: 340223d472ffcd3496374f6c869759aec8 */\+/* sqr(t[0], t[0]); */              /*  169: 680447a8e5ff9a692c6e9ed90d2eb35d90 */\+/* sqr(t[0], t[0]); */              /*  170: d0088f51cbff34d258dd3db21a5d66bb20 */\+/* sqr(t[0], t[0]); */              /*  171: 1a0111ea397fe69a4b1ba7b6434bacd7640 */\+/* sqr(t[0], t[0]); */              /*  172: 340223d472ffcd3496374f6c869759aec80 */\+/* sqr(t[0], t[0]); */              /*  173: 680447a8e5ff9a692c6e9ed90d2eb35d900 */\+sqr_n_mul(t[0], t[0], 8, t[5]);     /*  174: 680447a8e5ff9a692c6e9ed90d2eb35d91d */\+/* sqr(t[0], t[0]); */              /*  175: d0088f51cbff34d258dd3db21a5d66bb23a */\+/* sqr(t[0], t[0]); */              /*  176: 1a0111ea397fe69a4b1ba7b6434bacd76474 */\+/* sqr(t[0], t[0]); */              /*  177: 340223d472ffcd3496374f6c869759aec8e8 */\+/* sqr(t[0], t[0]); */              /*  178: 680447a8e5ff9a692c6e9ed90d2eb35d91d0 */\+sqr_n_mul(t[0], t[0], 4, t[3]);     /*  179: 680447a8e5ff9a692c6e9ed90d2eb35d91dd */\+/* sqr(t[0], t[0]); */              /*  180: d0088f51cbff34d258dd3db21a5d66bb23ba */\+/* sqr(t[0], t[0]); */              /*  181: 1a0111ea397fe69a4b1ba7b6434bacd764774 */\+/* sqr(t[0], t[0]); */              /*  182: 340223d472ffcd3496374f6c869759aec8ee8 */\+/* sqr(t[0], t[0]); */              /*  183: 680447a8e5ff9a692c6e9ed90d2eb35d91dd0 */\+/* sqr(t[0], t[0]); */              /*  184: d0088f51cbff34d258dd3db21a5d66bb23ba0 */\+/* sqr(t[0], t[0]); */              /*  185: 1a0111ea397fe69a4b1ba7b6434bacd7647740 */\+/* sqr(t[0], t[0]); */              /*  186: 340223d472ffcd3496374f6c869759aec8ee80 */\+sqr_n_mul(t[0], t[0], 7, t[11]);    /*  187: 340223d472ffcd3496374f6c869759aec8ee97 */\+/* sqr(t[0], t[0]); */              /*  188: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e */\+/* sqr(t[0], t[0]); */              /*  189: d0088f51cbff34d258dd3db21a5d66bb23ba5c */\+/* sqr(t[0], t[0]); */              /*  190: 1a0111ea397fe69a4b1ba7b6434bacd764774b8 */\+/* sqr(t[0], t[0]); */              /*  191: 340223d472ffcd3496374f6c869759aec8ee970 */\+/* sqr(t[0], t[0]); */              /*  192: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e0 */\+/* sqr(t[0], t[0]); */              /*  193: d0088f51cbff34d258dd3db21a5d66bb23ba5c0 */\+/* sqr(t[0], t[0]); */              /*  194: 1a0111ea397fe69a4b1ba7b6434bacd764774b80 */\+/* sqr(t[0], t[0]); */              /*  195: 340223d472ffcd3496374f6c869759aec8ee9700 */\+/* sqr(t[0], t[0]); */              /*  196: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e00 */\+sqr_n_mul(t[0], t[0], 9, t[10]);    /*  197: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13 */\+/* sqr(t[0], t[0]); */              /*  198: d0088f51cbff34d258dd3db21a5d66bb23ba5c26 */\+/* sqr(t[0], t[0]); */              /*  199: 1a0111ea397fe69a4b1ba7b6434bacd764774b84c */\+sqr_n_mul(t[0], t[0], 2, t[8]);     /*  200: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f */\+/* sqr(t[0], t[0]); */              /*  201: 340223d472ffcd3496374f6c869759aec8ee9709e */\+/* sqr(t[0], t[0]); */              /*  202: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13c */\+/* sqr(t[0], t[0]); */              /*  203: d0088f51cbff34d258dd3db21a5d66bb23ba5c278 */\+/* sqr(t[0], t[0]); */              /*  204: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f0 */\+/* sqr(t[0], t[0]); */              /*  205: 340223d472ffcd3496374f6c869759aec8ee9709e0 */\+sqr_n_mul(t[0], t[0], 5, t[6]);     /*  206: 340223d472ffcd3496374f6c869759aec8ee9709e7 */\+/* sqr(t[0], t[0]); */              /*  207: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce */\+/* sqr(t[0], t[0]); */              /*  208: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c */\+/* sqr(t[0], t[0]); */              /*  209: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38 */\+/* sqr(t[0], t[0]); */              /*  210: 340223d472ffcd3496374f6c869759aec8ee9709e70 */\+/* sqr(t[0], t[0]); */              /*  211: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce0 */\+/* sqr(t[0], t[0]); */              /*  212: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c0 */\+/* sqr(t[0], t[0]); */              /*  213: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f380 */\+sqr_n_mul(t[0], t[0], 7, t[1]);     /*  214: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f385 */\+/* sqr(t[0], t[0]); */              /*  215: 340223d472ffcd3496374f6c869759aec8ee9709e70a */\+/* sqr(t[0], t[0]); */              /*  216: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce14 */\+/* sqr(t[0], t[0]); */              /*  217: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c28 */\+/* sqr(t[0], t[0]); */              /*  218: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f3850 */\+/* sqr(t[0], t[0]); */              /*  219: 340223d472ffcd3496374f6c869759aec8ee9709e70a0 */\+/* sqr(t[0], t[0]); */              /*  220: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce140 */\+/* sqr(t[0], t[0]); */              /*  221: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c280 */\+sqr_n_mul(t[0], t[0], 7, t[9]);     /*  222: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c289 */\+/* sqr(t[0], t[0]); */              /*  223: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512 */\+/* sqr(t[0], t[0]); */              /*  224: 340223d472ffcd3496374f6c869759aec8ee9709e70a24 */\+/* sqr(t[0], t[0]); */              /*  225: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce1448 */\+/* sqr(t[0], t[0]); */              /*  226: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2890 */\+/* sqr(t[0], t[0]); */              /*  227: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f385120 */\+/* sqr(t[0], t[0]); */              /*  228: 340223d472ffcd3496374f6c869759aec8ee9709e70a240 */\+sqr_n_mul(t[0], t[0], 6, t[11]);    /*  229: 340223d472ffcd3496374f6c869759aec8ee9709e70a257 */\+/* sqr(t[0], t[0]); */              /*  230: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144ae */\+/* sqr(t[0], t[0]); */              /*  231: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895c */\+/* sqr(t[0], t[0]); */              /*  232: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512b8 */\+/* sqr(t[0], t[0]); */              /*  233: 340223d472ffcd3496374f6c869759aec8ee9709e70a2570 */\+/* sqr(t[0], t[0]); */              /*  234: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144ae0 */\+sqr_n_mul(t[0], t[0], 5, t[5]);     /*  235: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd */\+/* sqr(t[0], t[0]); */              /*  236: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fa */\+/* sqr(t[0], t[0]); */              /*  237: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf4 */\+/* sqr(t[0], t[0]); */              /*  238: 340223d472ffcd3496374f6c869759aec8ee9709e70a257e8 */\+/* sqr(t[0], t[0]); */              /*  239: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd0 */\+/* sqr(t[0], t[0]); */              /*  240: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fa0 */\+sqr_n_mul(t[0], t[0], 5, t[10]);    /*  241: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb3 */\+/* sqr(t[0], t[0]); */              /*  242: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf66 */\+/* sqr(t[0], t[0]); */              /*  243: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ecc */\+/* sqr(t[0], t[0]); */              /*  244: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd98 */\+/* sqr(t[0], t[0]); */              /*  245: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb30 */\+/* sqr(t[0], t[0]); */              /*  246: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf660 */\+sqr_n_mul(t[0], t[0], 5, t[10]);    /*  247: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf673 */\+/* sqr(t[0], t[0]); */              /*  248: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece6 */\+/* sqr(t[0], t[0]); */              /*  249: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc */\+/* sqr(t[0], t[0]); */              /*  250: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb398 */\+/* sqr(t[0], t[0]); */              /*  251: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730 */\+/* sqr(t[0], t[0]); */              /*  252: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece60 */\+/* sqr(t[0], t[0]); */              /*  253: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc0 */\+/* sqr(t[0], t[0]); */              /*  254: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb3980 */\+/* sqr(t[0], t[0]); */              /*  255: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf67300 */\+sqr_n_mul(t[0], t[0], 8, t[3]);     /*  256: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d */\+/* sqr(t[0], t[0]); */              /*  257: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a */\+/* sqr(t[0], t[0]); */              /*  258: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34 */\+/* sqr(t[0], t[0]); */              /*  259: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39868 */\+/* sqr(t[0], t[0]); */              /*  260: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d0 */\+/* sqr(t[0], t[0]); */              /*  261: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a0 */\+/* sqr(t[0], t[0]); */              /*  262: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc340 */\+/* sqr(t[0], t[0]); */              /*  263: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb398680 */\+sqr_n_mul(t[0], t[0], 7, t[2]);     /*  264: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb398695 */\+/* sqr(t[0], t[0]); */              /*  265: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a */\+/* sqr(t[0], t[0]); */              /*  266: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a54 */\+/* sqr(t[0], t[0]); */              /*  267: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a8 */\+/* sqr(t[0], t[0]); */              /*  268: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb3986950 */\+/* sqr(t[0], t[0]); */              /*  269: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0 */\+/* sqr(t[0], t[0]); */              /*  270: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a540 */\+/* sqr(t[0], t[0]); */              /*  271: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a80 */\+/* sqr(t[0], t[0]); */              /*  272: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869500 */\+/* sqr(t[0], t[0]); */              /*  273: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a00 */\+sqr_n_mul(t[0], t[0], 9, t[7]);     /*  274: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f */\+/* sqr(t[0], t[0]); */              /*  275: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541e */\+/* sqr(t[0], t[0]); */              /*  276: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83c */\+/* sqr(t[0], t[0]); */              /*  277: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb398695078 */\+/* sqr(t[0], t[0]); */              /*  278: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f0 */\+/* sqr(t[0], t[0]); */              /*  279: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541e0 */\+sqr_n_mul(t[0], t[0], 5, t[3]);     /*  280: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed */\+/* sqr(t[0], t[0]); */              /*  281: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83da */\+/* sqr(t[0], t[0]); */              /*  282: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b4 */\+/* sqr(t[0], t[0]); */              /*  283: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f68 */\+sqr_n_mul(t[0], t[0], 3, t[8]);     /*  284: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b */\+/* sqr(t[0], t[0]); */              /*  285: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed6 */\+/* sqr(t[0], t[0]); */              /*  286: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac */\+/* sqr(t[0], t[0]); */              /*  287: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b58 */\+/* sqr(t[0], t[0]); */              /*  288: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0 */\+/* sqr(t[0], t[0]); */              /*  289: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed60 */\+/* sqr(t[0], t[0]); */              /*  290: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac0 */\+/* sqr(t[0], t[0]); */              /*  291: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b580 */\+/* sqr(t[0], t[0]); */              /*  292: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b00 */\+sqr_n_mul(t[0], t[0], 8, t[7]);     /*  293: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f */\+/* sqr(t[0], t[0]); */              /*  294: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61e */\+/* sqr(t[0], t[0]); */              /*  295: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3c */\+/* sqr(t[0], t[0]); */              /*  296: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b5878 */\+sqr_n_mul(t[0], t[0], 3, t[8]);     /*  297: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b */\+/* sqr(t[0], t[0]); */              /*  298: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6 */\+/* sqr(t[0], t[0]); */              /*  299: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec */\+/* sqr(t[0], t[0]); */              /*  300: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8 */\+/* sqr(t[0], t[0]); */              /*  301: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b0 */\+/* sqr(t[0], t[0]); */              /*  302: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f60 */\+/* sqr(t[0], t[0]); */              /*  303: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec0 */\+/* sqr(t[0], t[0]); */              /*  304: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d80 */\+sqr_n_mul(t[0], t[0], 7, t[9]);     /*  305: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d89 */\+/* sqr(t[0], t[0]); */              /*  306: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b12 */\+/* sqr(t[0], t[0]); */              /*  307: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f624 */\+/* sqr(t[0], t[0]); */              /*  308: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec48 */\+/* sqr(t[0], t[0]); */              /*  309: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d890 */\+/* sqr(t[0], t[0]); */              /*  310: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120 */\+/* sqr(t[0], t[0]); */              /*  311: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6240 */\+/* sqr(t[0], t[0]); */              /*  312: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec480 */\+/* sqr(t[0], t[0]); */              /*  313: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8900 */\+/* sqr(t[0], t[0]); */              /*  314: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b1200 */\+sqr_n_mul(t[0], t[0], 9, t[7]);     /*  315: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f */\+/* sqr(t[0], t[0]); */              /*  316: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241e */\+/* sqr(t[0], t[0]); */              /*  317: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483c */\+/* sqr(t[0], t[0]); */              /*  318: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d89078 */\+/* sqr(t[0], t[0]); */              /*  319: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f0 */\+/* sqr(t[0], t[0]); */              /*  320: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241e0 */\+/* sqr(t[0], t[0]); */              /*  321: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483c0 */\+sqr_n_mul(t[0], t[0], 6, t[2]);     /*  322: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d5 */\+/* sqr(t[0], t[0]); */              /*  323: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aa */\+/* sqr(t[0], t[0]); */              /*  324: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f54 */\+/* sqr(t[0], t[0]); */              /*  325: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241ea8 */\+/* sqr(t[0], t[0]); */              /*  326: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d50 */\+/* sqr(t[0], t[0]); */              /*  327: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aa0 */\+/* sqr(t[0], t[0]); */              /*  328: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f540 */\+sqr_n_mul(t[0], t[0], 6, t[4]);     /*  329: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55f */\+/* sqr(t[0], t[0]); */              /*  330: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabe */\+/* sqr(t[0], t[0]); */              /*  331: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57c */\+/* sqr(t[0], t[0]); */              /*  332: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaf8 */\+/* sqr(t[0], t[0]); */              /*  333: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55f0 */\+/* sqr(t[0], t[0]); */              /*  334: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabe0 */\+sqr_n_mul(t[0], t[0], 5, t[4]);     /*  335: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabff */\+/* sqr(t[0], t[0]); */              /*  336: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fe */\+/* sqr(t[0], t[0]); */              /*  337: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffc */\+/* sqr(t[0], t[0]); */              /*  338: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ff8 */\+/* sqr(t[0], t[0]); */              /*  339: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabff0 */\+/* sqr(t[0], t[0]); */              /*  340: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fe0 */\+sqr_n_mul(t[0], t[0], 5, t[4]);     /*  341: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fff */\+/* sqr(t[0], t[0]); */              /*  342: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aafffe */\+/* sqr(t[0], t[0]); */              /*  343: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55fffc */\+/* sqr(t[0], t[0]); */              /*  344: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfff8 */\+/* sqr(t[0], t[0]); */              /*  345: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fff0 */\+sqr_n_mul(t[0], t[0], 4, t[3]);     /*  346: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd */\+/* sqr(t[0], t[0]); */              /*  347: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffa */\+/* sqr(t[0], t[0]); */              /*  348: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff4 */\+/* sqr(t[0], t[0]); */              /*  349: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffe8 */\+sqr_n_mul(t[0], t[0], 3, t[8]);     /*  350: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb */\+/* sqr(t[0], t[0]); */              /*  351: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd6 */\+/* sqr(t[0], t[0]); */              /*  352: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac */\+/* sqr(t[0], t[0]); */              /*  353: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58 */\+/* sqr(t[0], t[0]); */              /*  354: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb0 */\+/* sqr(t[0], t[0]); */              /*  355: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd60 */\+/* sqr(t[0], t[0]); */              /*  356: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac0 */\+/* sqr(t[0], t[0]); */              /*  357: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff580 */\+/* sqr(t[0], t[0]); */              /*  358: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb00 */\+sqr_n_mul(t[0], t[0], 8, t[2]);     /*  359: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb15 */\+/* sqr(t[0], t[0]); */              /*  360: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a */\+/* sqr(t[0], t[0]); */              /*  361: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54 */\+/* sqr(t[0], t[0]); */              /*  362: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a8 */\+/* sqr(t[0], t[0]); */              /*  363: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb150 */\+/* sqr(t[0], t[0]); */              /*  364: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a0 */\+/* sqr(t[0], t[0]); */              /*  365: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac540 */\+/* sqr(t[0], t[0]); */              /*  366: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a80 */\+sqr_n_mul(t[0], t[0], 7, t[4]);     /*  367: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9f */\+/* sqr(t[0], t[0]); */              /*  368: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153e */\+/* sqr(t[0], t[0]); */              /*  369: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7c */\+/* sqr(t[0], t[0]); */              /*  370: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54f8 */\+/* sqr(t[0], t[0]); */              /*  371: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9f0 */\+/* sqr(t[0], t[0]); */              /*  372: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153e0 */\+sqr_n_mul(t[0], t[0], 5, t[4]);     /*  373: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ff */\+/* sqr(t[0], t[0]); */              /*  374: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7fe */\+/* sqr(t[0], t[0]); */              /*  375: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffc */\+/* sqr(t[0], t[0]); */              /*  376: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ff8 */\+/* sqr(t[0], t[0]); */              /*  377: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ff0 */\+/* sqr(t[0], t[0]); */              /*  378: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7fe0 */\+sqr_n_mul(t[0], t[0], 5, t[4]);     /*  379: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7fff */\+/* sqr(t[0], t[0]); */              /*  380: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54fffe */\+/* sqr(t[0], t[0]); */              /*  381: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9fffc */\+/* sqr(t[0], t[0]); */              /*  382: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153fff8 */\+/* sqr(t[0], t[0]); */              /*  383: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7fff0 */\+sqr_n_mul(t[0], t[0], 4, t[7]);     /*  384: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff */\+/* sqr(t[0], t[0]); */              /*  385: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffe */\+/* sqr(t[0], t[0]); */              /*  386: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffc */\+/* sqr(t[0], t[0]); */              /*  387: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffff8 */\+/* sqr(t[0], t[0]); */              /*  388: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff0 */\+sqr_n_mul(t[0], t[0], 4, t[6]);     /*  389: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff7 */\+/* sqr(t[0], t[0]); */              /*  390: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee */\+/* sqr(t[0], t[0]); */              /*  391: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdc */\+/* sqr(t[0], t[0]); */              /*  392: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb8 */\+/* sqr(t[0], t[0]); */              /*  393: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff70 */\+/* sqr(t[0], t[0]); */              /*  394: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee0 */\+/* sqr(t[0], t[0]); */              /*  395: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdc0 */\+/* sqr(t[0], t[0]); */              /*  396: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb80 */\+sqr_n_mul(t[0], t[0], 7, t[4]);     /*  397: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9f */\+/* sqr(t[0], t[0]); */              /*  398: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73e */\+/* sqr(t[0], t[0]); */              /*  399: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7c */\+/* sqr(t[0], t[0]); */              /*  400: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcf8 */\+/* sqr(t[0], t[0]); */              /*  401: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9f0 */\+/* sqr(t[0], t[0]); */              /*  402: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73e0 */\+sqr_n_mul(t[0], t[0], 5, t[5]);     /*  403: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fd */\+/* sqr(t[0], t[0]); */              /*  404: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fa */\+/* sqr(t[0], t[0]); */              /*  405: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff4 */\+/* sqr(t[0], t[0]); */              /*  406: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9fe8 */\+/* sqr(t[0], t[0]); */              /*  407: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fd0 */\+/* sqr(t[0], t[0]); */              /*  408: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fa0 */\+sqr_n_mul(t[0], t[0], 5, t[4]);     /*  409: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fbf */\+/* sqr(t[0], t[0]); */              /*  410: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7e */\+/* sqr(t[0], t[0]); */              /*  411: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9fefc */\+/* sqr(t[0], t[0]); */              /*  412: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fdf8 */\+/* sqr(t[0], t[0]); */              /*  413: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fbf0 */\+/* sqr(t[0], t[0]); */              /*  414: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7e0 */\+sqr_n_mul(t[0], t[0], 5, t[4]);     /*  415: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7ff */\+/* sqr(t[0], t[0]); */              /*  416: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffe */\+/* sqr(t[0], t[0]); */              /*  417: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fdffc */\+/* sqr(t[0], t[0]); */              /*  418: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fbff8 */\+/* sqr(t[0], t[0]); */              /*  419: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7ff0 */\+/* sqr(t[0], t[0]); */              /*  420: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffe0 */\+sqr_n_mul(t[0], t[0], 5, t[4]);     /*  421: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffff */\+/* sqr(t[0], t[0]); */              /*  422: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fdfffe */\+/* sqr(t[0], t[0]); */              /*  423: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fbfffc */\+/* sqr(t[0], t[0]); */              /*  424: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7fff8 */\+/* sqr(t[0], t[0]); */              /*  425: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffff0 */\+/* sqr(t[0], t[0]); */              /*  426: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fdfffe0 */\+sqr_n_mul(t[0], t[0], 5, t[4]);     /*  427: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fdfffff */\+/* sqr(t[0], t[0]); */              /*  428: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fbffffe */\+/* sqr(t[0], t[0]); */              /*  429: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7ffffc */\+/* sqr(t[0], t[0]); */              /*  430: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9fefffff8 */\+/* sqr(t[0], t[0]); */              /*  431: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fdfffff0 */\+/* sqr(t[0], t[0]); */              /*  432: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fbffffe0 */\+sqr_n_mul(t[0], t[0], 5, t[4]);     /*  433: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fbffffff */\+/* sqr(t[0], t[0]); */              /*  434: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7fffffe */\+/* sqr(t[0], t[0]); */              /*  435: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffc */\+/* sqr(t[0], t[0]); */              /*  436: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fdffffff8 */\+/* sqr(t[0], t[0]); */              /*  437: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fbffffff0 */\+/* sqr(t[0], t[0]); */              /*  438: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7fffffe0 */\+sqr_n_mul(t[0], t[0], 5, t[4]);     /*  439: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7fffffff */\+/* sqr(t[0], t[0]); */              /*  440: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9fefffffffe */\+/* sqr(t[0], t[0]); */              /*  441: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fdfffffffc */\+/* sqr(t[0], t[0]); */              /*  442: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fbfffffff8 */\+/* sqr(t[0], t[0]); */              /*  443: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7fffffff0 */\+sqr_n_mul(t[0], t[0], 4, t[3]);     /*  444: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7fffffffd */\+/* sqr(t[0], t[0]); */              /*  445: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffa */\+/* sqr(t[0], t[0]); */              /*  446: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fdffffffff4 */\+/* sqr(t[0], t[0]); */              /*  447: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fbfffffffe8 */\+/* sqr(t[0], t[0]); */              /*  448: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7fffffffd0 */\+/* sqr(t[0], t[0]); */              /*  449: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffa0 */\+/* sqr(t[0], t[0]); */              /*  450: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fdffffffff40 */\+sqr_n_mul(t[0], t[0], 6, t[2]);     /*  451: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fdffffffff55 */\+/* sqr(t[0], t[0]); */              /*  452: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fbfffffffeaa */\+/* sqr(t[0], t[0]); */              /*  453: d0088f51cbff34d258dd3db21a5d66bb23ba5c279c2895fb39869507b587b120f55ffff58a9ffffdcff7fffffffd54 */\+/* sqr(t[0], t[0]); */              /*  454: 1a0111ea397fe69a4b1ba7b6434bacd764774b84f38512bf6730d2a0f6b0f6241eabfffeb153ffffb9feffffffffaa8 */\+/* sqr(t[0], t[0]); */              /*  455: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fdffffffff550 */\+sqr_n_mul(t[0], t[0], 4, t[1]);     /*  456: 340223d472ffcd3496374f6c869759aec8ee9709e70a257ece61a541ed61ec483d57fffd62a7ffff73fdffffffff555 */\+sqr(out, t[0]);                     /*  457: 680447a8e5ff9a692c6e9ed90d2eb35d91dd2e13ce144afd9cc34a83dac3d8907aaffffac54ffffee7fbfffffffeaaa */\+} while(0)
+ c-source/src/sqrt.c view
@@ -0,0 +1,261 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */++#include "fields.h"++#ifdef __OPTIMIZE_SIZE__+static void recip_sqrt_fp_3mod4(vec384 out, const vec384 inp)+{+    static const byte BLS_12_381_P_minus_3_div_4[] = {+        TO_BYTES(0xee7fbfffffffeaaa), TO_BYTES(0x07aaffffac54ffff),+        TO_BYTES(0xd9cc34a83dac3d89), TO_BYTES(0xd91dd2e13ce144af),+        TO_BYTES(0x92c6e9ed90d2eb35), TO_BYTES(0x0680447a8e5ff9a6)+    };++    exp_mont_384(out, inp, BLS_12_381_P_minus_3_div_4, 379, BLS12_381_P, p0);+}+#else+# if 1+/*+ * "383"-bit variant omits full reductions at the ends of squarings,+ * which results in up to ~15% improvement. [One can improve further+ * by omitting full reductions even after multiplications and+ * performing final reduction at the very end of the chain.]+ */+static inline void sqr_n_mul_fp(vec384 out, const vec384 a, size_t count,+                                const vec384 b)+{   sqr_n_mul_mont_383(out, a, count, BLS12_381_P, p0, b);   }+# else+static void sqr_n_mul_fp(vec384 out, const vec384 a, size_t count,+                         const vec384 b)+{+    while(count--) {+        sqr_fp(out, a);+        a = out;+    }+    mul_fp(out, out, b);+}+# endif++# define sqr(ret,a)		sqr_fp(ret,a)+# define mul(ret,a,b)		mul_fp(ret,a,b)+# define sqr_n_mul(ret,a,n,b)	sqr_n_mul_fp(ret,a,n,b)++# include "sqrt-addchain.h"+static void recip_sqrt_fp_3mod4(vec384 out, const vec384 inp)+{+    RECIP_SQRT_MOD_BLS12_381_P(out, inp, vec384);+}+# undef RECIP_SQRT_MOD_BLS12_381_P++# undef sqr_n_mul+# undef sqr+# undef mul+#endif++static bool_t recip_sqrt_fp(vec384 out, const vec384 inp)+{+    vec384 t0, t1;+    bool_t ret;++    recip_sqrt_fp_3mod4(t0, inp);++    mul_fp(t1, t0, inp);+    sqr_fp(t1, t1);+    ret = vec_is_equal(t1, inp, sizeof(t1));+    vec_copy(out, t0, sizeof(t0));++    return ret;+}++static bool_t sqrt_fp(vec384 out, const vec384 inp)+{+    vec384 t0, t1;+    bool_t ret;++    recip_sqrt_fp_3mod4(t0, inp);++    mul_fp(t0, t0, inp);+    sqr_fp(t1, t0);+    ret = vec_is_equal(t1, inp, sizeof(t1));+    vec_copy(out, t0, sizeof(t0));++    return ret;+}++int blst_fp_sqrt(vec384 out, const vec384 inp)+{   return (int)sqrt_fp(out, inp);   }++int blst_fp_is_square(const vec384 inp)+{+    return (int)ct_is_square_mod_384(inp, BLS12_381_P);+}++static bool_t sqrt_align_fp2(vec384x out, const vec384x ret,+                             const vec384x sqrt, const vec384x inp)+{+    static const vec384x sqrt_minus_1 = { { 0 }, { ONE_MONT_P } };+    static const vec384x sqrt_sqrt_minus_1 = {+      /*+       * "magic" number is ±2^((p-3)/4)%p, which is "1/sqrt(2)",+       * in quotes because 2*"1/sqrt(2)"^2 == -1 mod p, not 1,+       * but it pivots into "complex" plane nevertheless...+       */+      { TO_LIMB_T(0x3e2f585da55c9ad1), TO_LIMB_T(0x4294213d86c18183),+        TO_LIMB_T(0x382844c88b623732), TO_LIMB_T(0x92ad2afd19103e18),+        TO_LIMB_T(0x1d794e4fac7cf0b9), TO_LIMB_T(0x0bd592fc7d825ec8) },+      { TO_LIMB_T(0x7bcfa7a25aa30fda), TO_LIMB_T(0xdc17dec12a927e7c),+        TO_LIMB_T(0x2f088dd86b4ebef1), TO_LIMB_T(0xd1ca2087da74d4a7),+        TO_LIMB_T(0x2da2596696cebc1d), TO_LIMB_T(0x0e2b7eedbbfd87d2) }+    };+    static const vec384x sqrt_minus_sqrt_minus_1 = {+      { TO_LIMB_T(0x7bcfa7a25aa30fda), TO_LIMB_T(0xdc17dec12a927e7c),+        TO_LIMB_T(0x2f088dd86b4ebef1), TO_LIMB_T(0xd1ca2087da74d4a7),+        TO_LIMB_T(0x2da2596696cebc1d), TO_LIMB_T(0x0e2b7eedbbfd87d2) },+      { TO_LIMB_T(0x7bcfa7a25aa30fda), TO_LIMB_T(0xdc17dec12a927e7c),+        TO_LIMB_T(0x2f088dd86b4ebef1), TO_LIMB_T(0xd1ca2087da74d4a7),+        TO_LIMB_T(0x2da2596696cebc1d), TO_LIMB_T(0x0e2b7eedbbfd87d2) }+    };+    vec384x coeff, t0, t1;+    bool_t is_sqrt, flag;++    /*+     * Instead of multiple trial squarings we can perform just one+     * and see if the result is "rotated by multiple of 90°" in+     * relation to |inp|, and "rotate" |ret| accordingly.+     */+    sqr_fp2(t0, sqrt);+    /* "sqrt(|inp|)"^2 = (a + b*i)^2 = (a^2-b^2) + 2ab*i */++    /* (a^2-b^2) + 2ab*i == |inp| ? |ret| is spot on */+    sub_fp2(t1, t0, inp);+    is_sqrt = vec_is_zero(t1, sizeof(t1));+    vec_copy(coeff, BLS12_381_Rx.p2, sizeof(coeff));++    /* -(a^2-b^2) - 2ab*i == |inp| ? "rotate |ret| by 90°" */+    add_fp2(t1, t0, inp);+    vec_select(coeff, sqrt_minus_1, coeff, sizeof(coeff),+               flag = vec_is_zero(t1, sizeof(t1)));+    is_sqrt |= flag;++    /* 2ab - (a^2-b^2)*i == |inp| ? "rotate |ret| by 135°" */+    sub_fp(t1[0], t0[0], inp[1]);+    add_fp(t1[1], t0[1], inp[0]);+    vec_select(coeff, sqrt_sqrt_minus_1, coeff, sizeof(coeff),+               flag = vec_is_zero(t1, sizeof(t1)));+    is_sqrt |= flag;++    /* -2ab + (a^2-b^2)*i == |inp| ? "rotate |ret| by 45°" */+    add_fp(t1[0], t0[0], inp[1]);+    sub_fp(t1[1], t0[1], inp[0]);+    vec_select(coeff, sqrt_minus_sqrt_minus_1, coeff, sizeof(coeff),+               flag = vec_is_zero(t1, sizeof(t1)));+    is_sqrt |= flag;++    /* actual "rotation" */+    mul_fp2(out, ret, coeff);++    return is_sqrt;+}++/*+ * |inp| = a + b*i+ */+static bool_t recip_sqrt_fp2(vec384x out, const vec384x inp,+                                          const vec384x recip_ZZZ,+                                          const vec384x magic_ZZZ)+{+    vec384 aa, bb, cc;+    vec384x inp_;+    bool_t is_sqrt;++    sqr_fp(aa, inp[0]);+    sqr_fp(bb, inp[1]);+    add_fp(aa, aa, bb);++    is_sqrt = recip_sqrt_fp(cc, aa);  /* 1/sqrt(a²+b²)                    */++    /* if |inp| doesn't have quadratic residue, multiply by "1/Z³" ...    */+    mul_fp2(inp_, inp, recip_ZZZ);+    /* ... and adjust |aa| and |cc| accordingly                           */+    {+        vec384 za, zc;++        mul_fp(za, aa, magic_ZZZ[0]); /* aa*(za² + zb²)                   */+        mul_fp(zc, cc, magic_ZZZ[1]); /* cc*(za² + zb²)^((p-3)/4)         */+        vec_select(aa, aa, za, sizeof(aa), is_sqrt);+        vec_select(cc, cc, zc, sizeof(cc), is_sqrt);+    }+    vec_select(inp_, inp, inp_, sizeof(inp_), is_sqrt);++    mul_fp(aa, aa, cc);               /* sqrt(a²+b²)                      */++    sub_fp(bb, inp_[0], aa);+    add_fp(aa, inp_[0], aa);+    vec_select(aa, bb, aa, sizeof(aa), vec_is_zero(aa, sizeof(aa)));+    div_by_2_fp(aa, aa);              /* (a ± sqrt(a²+b²))/2              */++    /* if it says "no sqrt," final "align" will find right one...         */+    (void)recip_sqrt_fp(out[0], aa);  /* 1/sqrt((a ± sqrt(a²+b²))/2)      */++    div_by_2_fp(out[1], inp_[1]);+    mul_fp(out[1], out[1], out[0]);   /* b/(2*sqrt((a ± sqrt(a²+b²))/2))  */+    mul_fp(out[0], out[0], aa);       /* sqrt((a ± sqrt(a²+b²))/2)        */++    /* bound to succeed                                                   */+    (void)sqrt_align_fp2(out, out, out, inp_);++    mul_fp(out[0], out[0], cc);       /* inverse the result               */+    mul_fp(out[1], out[1], cc);+    neg_fp(out[1], out[1]);++    return is_sqrt;+}++static bool_t sqrt_fp2(vec384x out, const vec384x inp)+{+    vec384x ret;+    vec384 aa, bb;++    sqr_fp(aa, inp[0]);+    sqr_fp(bb, inp[1]);+    add_fp(aa, aa, bb);++    /* don't pay attention to return value, final "align" will tell...    */+    (void)sqrt_fp(aa, aa);            /* sqrt(a²+b²)                      */++    sub_fp(bb, inp[0], aa);+    add_fp(aa, inp[0], aa);+    vec_select(aa, bb, aa, sizeof(aa), vec_is_zero(aa, sizeof(aa)));+    div_by_2_fp(aa, aa);              /* (a ± sqrt(a²+b²))/2              */++    /* if it says "no sqrt," final "align" will find right one...         */+    (void)recip_sqrt_fp(ret[0], aa);  /* 1/sqrt((a ± sqrt(a²+b²))/2)      */++    div_by_2_fp(ret[1], inp[1]);+    mul_fp(ret[1], ret[1], ret[0]);   /* b/(2*sqrt((a ± sqrt(a²+b²))/2))  */+    mul_fp(ret[0], ret[0], aa);       /* sqrt((a ± sqrt(a²+b²))/2)        */++    /*+     * Now see if |ret| is or can be made sqrt(|inp|)...+     */++    return sqrt_align_fp2(out, ret, ret, inp);+}++int blst_fp2_sqrt(vec384x out, const vec384x inp)+{   return (int)sqrt_fp2(out, inp);   }++int blst_fp2_is_square(const vec384x inp)+{+    vec384 aa, bb;++    sqr_fp(aa, inp[0]);+    sqr_fp(bb, inp[1]);+    add_fp(aa, aa, bb);++    return (int)ct_is_square_mod_384(aa, BLS12_381_P);+}
+ c-source/src/vect.c view
@@ -0,0 +1,176 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */++#include "vect.h"++#ifdef __BLST_NO_ASM__+# include "no_asm.h"+#endif++/*+ * Following are some reference C implementations to assist new+ * assembly modules development, as starting-point stand-ins and for+ * cross-checking. In order to "polyfil" specific subroutine redefine+ * it on compiler command line, e.g. -Dmul_mont_384x=_mul_mont_384x.+ */++#ifdef lshift_mod_384+inline void lshift_mod_384(vec384 ret, const vec384 a, size_t n,+                           const vec384 mod)+{+    while(n--)+        add_mod_384(ret, a, a, mod), a = ret;+}+#endif++#ifdef mul_by_8_mod_384+inline void mul_by_8_mod_384(vec384 ret, const vec384 a, const vec384 mod)+{   lshift_mod_384(ret, a, 3, mod);   }+#endif++#ifdef mul_by_3_mod_384+inline void mul_by_3_mod_384(vec384 ret, const vec384 a, const vec384 mod)+{+    vec384 t;++    add_mod_384(t, a, a, mod);+    add_mod_384(ret, t, a, mod);+}+#endif++#ifdef mul_by_3_mod_384x+inline void mul_by_3_mod_384x(vec384x ret, const vec384x a, const vec384 mod)+{+    mul_by_3_mod_384(ret[0], a[0], mod);+    mul_by_3_mod_384(ret[1], a[1], mod);+}+#endif++#ifdef mul_by_8_mod_384x+inline void mul_by_8_mod_384x(vec384x ret, const vec384x a, const vec384 mod)+{+    mul_by_8_mod_384(ret[0], a[0], mod);+    mul_by_8_mod_384(ret[1], a[1], mod);+}+#endif++#ifdef mul_by_1_plus_i_mod_384x+inline void mul_by_1_plus_i_mod_384x(vec384x ret, const vec384x a,+                                     const vec384 mod)+{+    vec384 t;++    add_mod_384(t, a[0], a[1], mod);+    sub_mod_384(ret[0], a[0], a[1], mod);+    vec_copy(ret[1], t, sizeof(t));+}+#endif++#ifdef add_mod_384x+inline void add_mod_384x(vec384x ret, const vec384x a, const vec384x b,+                         const vec384 mod)+{+    add_mod_384(ret[0], a[0], b[0], mod);+    add_mod_384(ret[1], a[1], b[1], mod);+}+#endif++#ifdef sub_mod_384x+inline void sub_mod_384x(vec384x ret, const vec384x a, const vec384x b,+                         const vec384 mod)+{+    sub_mod_384(ret[0], a[0], b[0], mod);+    sub_mod_384(ret[1], a[1], b[1], mod);+}+#endif++#ifdef lshift_mod_384x+inline void lshift_mod_384x(vec384x ret, const vec384x a, size_t n,+                            const vec384 mod)+{+    lshift_mod_384(ret[0], a[0], n, mod);+    lshift_mod_384(ret[1], a[1], n, mod);+}+#endif++#if defined(mul_mont_384x) && !(defined(__ADX__) && !defined(__BLST_PORTABLE__))+void mul_mont_384x(vec384x ret, const vec384x a, const vec384x b,+                   const vec384 mod, limb_t n0)+{+    vec768 t0, t1, t2;+    vec384 aa, bb;++    mul_384(t0, a[0], b[0]);+    mul_384(t1, a[1], b[1]);++    add_mod_384(aa, a[0], a[1], mod);+    add_mod_384(bb, b[0], b[1], mod);+    mul_384(t2, aa, bb);+    sub_mod_384x384(t2, t2, t0, mod);+    sub_mod_384x384(t2, t2, t1, mod);++    sub_mod_384x384(t0, t0, t1, mod);++    redc_mont_384(ret[0], t0, mod, n0);+    redc_mont_384(ret[1], t2, mod, n0);+}+#endif++#if defined(sqr_mont_384x) && !(defined(__ADX__) && !defined(__BLST_PORTABLE__))+void sqr_mont_384x(vec384x ret, const vec384x a, const vec384 mod, limb_t n0)+{+    vec384 t0, t1;++    add_mod_384(t0, a[0], a[1], mod);+    sub_mod_384(t1, a[0], a[1], mod);++    mul_mont_384(ret[1], a[0], a[1], mod, n0);+    add_mod_384(ret[1], ret[1], ret[1], mod);++    mul_mont_384(ret[0], t0, t1, mod, n0);+}+#endif++limb_t div_3_limbs(const limb_t dividend_top[2], limb_t d_lo, limb_t d_hi);+limb_t quot_rem_128(limb_t *quot_rem, const limb_t *divisor, limb_t quotient);+limb_t quot_rem_64(limb_t *quot_rem, const limb_t *divisor, limb_t quotient);++/*+ * Divide 255-bit |val| by z^2 yielding 128-bit quotient and remainder in place.+ */+static void div_by_zz(limb_t val[])+{+    static const limb_t zz[] = { TO_LIMB_T(0x0000000100000000),+                                 TO_LIMB_T(0xac45a4010001a402) };+    size_t loop, zz_len = sizeof(zz)/sizeof(zz[0]);+    limb_t d_lo, d_hi;++    d_lo = zz[zz_len - 2];+    d_hi = zz[zz_len - 1];+    for (loop = zz_len, zz_len--; loop--;) {+        limb_t q = div_3_limbs(val + loop + zz_len, d_lo, d_hi);+        (void)quot_rem_128(val + loop, zz, q);+    }+    /* remainder is in low half of val[], quotient is in high */+}++/*+ * Divide 128-bit |val| by z yielding 64-bit quotient and remainder in place.+ */+static void div_by_z(limb_t val[])+{+    static const limb_t z[] = { TO_LIMB_T(0xd201000000010000) };+    size_t loop, z_len = sizeof(z)/sizeof(z[0]);+    limb_t d_lo, d_hi;++    d_lo = (sizeof(z) == sizeof(limb_t)) ? 0 : z[z_len - 2];+    d_hi = z[z_len - 1];+    for (loop = z_len, z_len--; loop--;) {+        limb_t q = div_3_limbs(val + loop + z_len, d_lo, d_hi);+        (void)quot_rem_64(val + loop, z, q);+    }+    /* remainder is in low half of val[], quotient is in high */+}
+ c-source/src/vect.h view
@@ -0,0 +1,384 @@+/*+ * Copyright Supranational LLC+ * Licensed under the Apache License, Version 2.0, see LICENSE for details.+ * SPDX-License-Identifier: Apache-2.0+ */+#ifndef __BLS12_381_ASM_VECT_H__+#define __BLS12_381_ASM_VECT_H__++#include <stddef.h>++#if defined(__x86_64__) || defined(__aarch64__)+/* These are available even in ILP32 flavours, but even then they are+ * capable of performing 64-bit operations as efficiently as in *P64. */+typedef unsigned long long limb_t;+# define LIMB_T_BITS    64++#elif defined(_WIN64)   /* Win64 is P64 */+typedef unsigned __int64 limb_t;+# define LIMB_T_BITS    64++#elif defined(__BLST_NO_ASM__) || defined(__wasm64__)+typedef unsigned int limb_t;+# define LIMB_T_BITS    32+# ifndef __BLST_NO_ASM__+#  define __BLST_NO_ASM__+# endif++#else                   /* 32 bits on 32-bit platforms, 64 - on 64-bit */+typedef unsigned long limb_t;+#  ifdef _LP64+#   define LIMB_T_BITS   64+#  else+#   define LIMB_T_BITS   32+#   define __BLST_NO_ASM__+#  endif+#endif++/*+ * Why isn't LIMB_T_BITS defined as 8*sizeof(limb_t)? Because pre-processor+ * knows nothing about sizeof(anything)...+ */+#if LIMB_T_BITS == 64+# define TO_LIMB_T(limb64)     limb64+#else+# define TO_LIMB_T(limb64)     (limb_t)limb64,(limb_t)(limb64>>32)+#endif++#define NLIMBS(bits)   (bits/LIMB_T_BITS)++typedef limb_t vec256[NLIMBS(256)];+typedef limb_t vec512[NLIMBS(512)];+typedef limb_t vec384[NLIMBS(384)];+typedef limb_t vec768[NLIMBS(768)];+typedef vec384 vec384x[2];      /* 0 is "real" part, 1 is "imaginary" */++typedef unsigned char byte;+#define TO_BYTES(limb64)    (byte)limb64,(byte)(limb64>>8),\+                            (byte)(limb64>>16),(byte)(limb64>>24),\+                            (byte)(limb64>>32),(byte)(limb64>>40),\+                            (byte)(limb64>>48),(byte)(limb64>>56)+typedef byte pow256[256/8];++/*+ * Internal Boolean type, Bolean by value, hence safe to cast to or+ * reinterpret as 'bool'.+ */+typedef limb_t bool_t;++/*+ * Assembly subroutines...+ */+#if defined(__ADX__) /* e.g. -march=broadwell */ && !defined(__BLST_PORTABLE__)\+                                                 && !defined(__BLST_NO_ASM__)+# define mul_mont_sparse_256 mulx_mont_sparse_256+# define sqr_mont_sparse_256 sqrx_mont_sparse_256+# define from_mont_256 fromx_mont_256+# define redc_mont_256 redcx_mont_256+# define mul_mont_384 mulx_mont_384+# define sqr_mont_384 sqrx_mont_384+# define sqr_n_mul_mont_384 sqrx_n_mul_mont_384+# define sqr_n_mul_mont_383 sqrx_n_mul_mont_383+# define mul_384 mulx_384+# define sqr_384 sqrx_384+# define redc_mont_384 redcx_mont_384+# define from_mont_384 fromx_mont_384+# define sgn0_pty_mont_384 sgn0x_pty_mont_384+# define sgn0_pty_mont_384x sgn0x_pty_mont_384x+# define ct_inverse_mod_383 ctx_inverse_mod_383+#elif defined(__BLST_NO_ASM__)+# define ct_inverse_mod_383 ct_inverse_mod_384+#endif++void mul_mont_sparse_256(vec256 ret, const vec256 a, const vec256 b,+                         const vec256 p, limb_t n0);+void sqr_mont_sparse_256(vec256 ret, const vec256 a, const vec256 p, limb_t n0);+void redc_mont_256(vec256 ret, const vec512 a, const vec256 p, limb_t n0);+void from_mont_256(vec256 ret, const vec256 a, const vec256 p, limb_t n0);++void add_mod_256(vec256 ret, const vec256 a, const vec256 b, const vec256 p);+void sub_mod_256(vec256 ret, const vec256 a, const vec256 b, const vec256 p);+void mul_by_3_mod_256(vec256 ret, const vec256 a, const vec256 p);+void cneg_mod_256(vec256 ret, const vec256 a, bool_t flag, const vec256 p);+void lshift_mod_256(vec256 ret, const vec256 a, size_t count, const vec256 p);+void rshift_mod_256(vec256 ret, const vec256 a, size_t count, const vec256 p);+bool_t eucl_inverse_mod_256(vec256 ret, const vec256 a, const vec256 p,+                            const vec256 one);+limb_t check_mod_256(const pow256 a, const vec256 p);+limb_t add_n_check_mod_256(pow256 ret, const pow256 a, const pow256 b,+                                       const vec256 p);+limb_t sub_n_check_mod_256(pow256 ret, const pow256 a, const pow256 b,+                                       const vec256 p);++void vec_prefetch(const void *ptr, size_t len);++void mul_mont_384(vec384 ret, const vec384 a, const vec384 b,+                  const vec384 p, limb_t n0);+void sqr_mont_384(vec384 ret, const vec384 a, const vec384 p, limb_t n0);+void sqr_n_mul_mont_384(vec384 ret, const vec384 a, size_t count,+                        const vec384 p, limb_t n0, const vec384 b);+void sqr_n_mul_mont_383(vec384 ret, const vec384 a, size_t count,+                        const vec384 p, limb_t n0, const vec384 b);++void mul_384(vec768 ret, const vec384 a, const vec384 b);+void sqr_384(vec768 ret, const vec384 a);+void redc_mont_384(vec384 ret, const vec768 a, const vec384 p, limb_t n0);+void from_mont_384(vec384 ret, const vec384 a, const vec384 p, limb_t n0);+limb_t sgn0_pty_mont_384(const vec384 a, const vec384 p, limb_t n0);+limb_t sgn0_pty_mont_384x(const vec384x a, const vec384 p, limb_t n0);+limb_t sgn0_pty_mod_384(const vec384 a, const vec384 p);+limb_t sgn0_pty_mod_384x(const vec384x a, const vec384 p);++void add_mod_384(vec384 ret, const vec384 a, const vec384 b, const vec384 p);+void sub_mod_384(vec384 ret, const vec384 a, const vec384 b, const vec384 p);+void mul_by_8_mod_384(vec384 ret, const vec384 a, const vec384 p);+void mul_by_3_mod_384(vec384 ret, const vec384 a, const vec384 p);+void cneg_mod_384(vec384 ret, const vec384 a, bool_t flag, const vec384 p);+void lshift_mod_384(vec384 ret, const vec384 a, size_t count, const vec384 p);+void rshift_mod_384(vec384 ret, const vec384 a, size_t count, const vec384 p);+void div_by_2_mod_384(vec384 ret, const vec384 a, const vec384 p);+void ct_inverse_mod_383(vec768 ret, const vec384 inp, const vec384 mod,+                                                      const vec384 modx);+void ct_inverse_mod_256(vec512 ret, const vec256 inp, const vec256 mod,+                                                      const vec256 modx);+bool_t ct_is_square_mod_384(const vec384 inp, const vec384 mod);++#if defined(__ADX__) /* e.g. -march=broadwell */ && !defined(__BLST_PORTABLE__)+# define mul_mont_384x mulx_mont_384x+# define sqr_mont_384x sqrx_mont_384x+# define sqr_mont_382x sqrx_mont_382x+# define sqr_n_mul_mont_384x sqrx_n_mul_mont_384x+# define mul_382x mulx_382x+# define sqr_382x sqrx_382x+#endif++void mul_mont_384x(vec384x ret, const vec384x a, const vec384x b,+                   const vec384 p, limb_t n0);+void sqr_mont_384x(vec384x ret, const vec384x a, const vec384 p, limb_t n0);+void sqr_mont_382x(vec384x ret, const vec384x a, const vec384 p, limb_t n0);+void sqr_n_mul_mont_384x(vec384x ret, const vec384x a, size_t count,+                         const vec384 p, limb_t n0, const vec384x b);+void mul_382x(vec768 ret[2], const vec384x a, const vec384x b, const vec384 p);+void sqr_382x(vec768 ret[2], const vec384x a, const vec384 p);++void add_mod_384x(vec384x ret, const vec384x a, const vec384x b,+                  const vec384 p);+void sub_mod_384x(vec384x ret, const vec384x a, const vec384x b,+                  const vec384 p);+void mul_by_8_mod_384x(vec384x ret, const vec384x a, const vec384 p);+void mul_by_3_mod_384x(vec384x ret, const vec384x a, const vec384 p);+void mul_by_1_plus_i_mod_384x(vec384x ret, const vec384x a, const vec384 p);+void add_mod_384x384(vec768 ret, const vec768 a, const vec768 b,+                     const vec384 p);+void sub_mod_384x384(vec768 ret, const vec768 a, const vec768 b,+                     const vec384 p);++/*+ * C subroutines+ */+static void exp_mont_384(vec384 out, const vec384 inp, const byte *pow,+                         size_t pow_bits, const vec384 p, limb_t n0);+static void exp_mont_384x(vec384x out, const vec384x inp, const byte *pow,+                          size_t pow_bits, const vec384 p, limb_t n0);+static void div_by_zz(limb_t val[]);+static void div_by_z(limb_t val[]);++#ifdef __UINTPTR_TYPE__+typedef __UINTPTR_TYPE__ uptr_t;+#else+typedef const void *uptr_t;+#endif++#if !defined(restrict)+# if !defined(__STDC_VERSION__) || __STDC_VERSION__<199901+#  if defined(__GNUC__) && __GNUC__>=2+#   define restrict __restrict__+#  elif defined(_MSC_VER)+#   define restrict __restrict+#  else+#   define restrict+#  endif+# endif+#endif++#if !defined(inline) && !defined(__cplusplus)+# if !defined(__STDC_VERSION__) || __STDC_VERSION__<199901+#  if defined(__GNUC__) && __GNUC__>=2+#   define inline __inline__+#  elif defined(_MSC_VER)+#   define inline __inline+#  else+#   define inline+#  endif+# endif+#endif++static inline bool_t is_bit_set(const byte *v, size_t i)+{   return (v[i/8] >> (i%8)) & 1;   }++static inline bool_t byte_is_zero(unsigned char c)+{   return ((limb_t)(c) - 1) >> (LIMB_T_BITS - 1);   }++static inline bool_t bytes_are_zero(const unsigned char *a, size_t num)+{+    unsigned char acc;+    size_t i;++    for (acc = 0, i = 0; i < num; i++)+        acc |= a[i];++    return byte_is_zero(acc);+}++static inline void vec_cswap(void *restrict a, void *restrict b, size_t num,+                             bool_t cbit)+{+    limb_t ai, *ap = (limb_t *)a;+    limb_t bi, *bp = (limb_t *)b;+    limb_t xorm, mask = (limb_t)0 - cbit;+    size_t i;++    num /= sizeof(limb_t);++    for (i = 0; i < num; i++) {+        xorm = ((ai = ap[i]) ^ (bi = bp[i])) & mask;+        ap[i] = ai ^ xorm;+        bp[i] = bi ^ xorm;+    }+}++/* ret = bit ? a : b */+void vec_select_48(void *ret, const void *a, const void *b, bool_t sel_a);+void vec_select_96(void *ret, const void *a, const void *b, bool_t sel_a);+void vec_select_144(void *ret, const void *a, const void *b, bool_t sel_a);+void vec_select_192(void *ret, const void *a, const void *b, bool_t sel_a);+void vec_select_288(void *ret, const void *a, const void *b, bool_t sel_a);+static inline void vec_select(void *ret, const void *a, const void *b,+                              size_t num, bool_t sel_a)+{+#ifndef __BLST_NO_ASM__+    if (num == 48)          vec_select_48(ret, a, b, sel_a);+    else if (num == 96)     vec_select_96(ret, a, b, sel_a);+    else if (num == 144)    vec_select_144(ret, a, b, sel_a);+    else if (num == 192)    vec_select_192(ret, a, b, sel_a);+    else if (num == 288)    vec_select_288(ret, a, b, sel_a);+#else+    if (0) ;+#endif+    else {+        limb_t bi, *rp = (limb_t *)ret;+        const limb_t *ap = (const limb_t *)a;+        const limb_t *bp = (const limb_t *)b;+        limb_t xorm, mask = (limb_t)0 - sel_a;+        size_t i;++        num /= sizeof(limb_t);++        for (i = 0; i < num; i++) {+            xorm = (ap[i] ^ (bi = bp[i])) & mask;+            rp[i] = bi ^ xorm;+        }+    }+}++static inline bool_t is_zero(limb_t l)+{   return (~l & (l - 1)) >> (LIMB_T_BITS - 1);   }++static inline bool_t vec_is_zero(const void *a, size_t num)+{+    const limb_t *ap = (const limb_t *)a;+    limb_t acc;+    size_t i;++    num /= sizeof(limb_t);++    for (acc = 0, i = 0; i < num; i++)+        acc |= ap[i];++    return is_zero(acc);+}++static inline bool_t vec_is_equal(const void *a, const void *b, size_t num)+{+    const limb_t *ap = (const limb_t *)a;+    const limb_t *bp = (const limb_t *)b;+    limb_t acc;+    size_t i;++    num /= sizeof(limb_t);++    for (acc = 0, i = 0; i < num; i++)+        acc |= ap[i] ^ bp[i];++    return is_zero(acc);+}++static inline void cneg_mod_384x(vec384x ret, const vec384x a, bool_t flag,+                                 const vec384 p)+{+    cneg_mod_384(ret[0], a[0], flag, p);+    cneg_mod_384(ret[1], a[1], flag, p);+}++static inline void vec_copy(void *restrict ret, const void *a, size_t num)+{+    limb_t *rp = (limb_t *)ret;+    const limb_t *ap = (const limb_t *)a;+    size_t i;++    num /= sizeof(limb_t);++    for (i = 0; i < num; i++)+        rp[i] = ap[i];+}++static inline void vec_zero(void *ret, size_t num)+{+    volatile limb_t *rp = (volatile limb_t *)ret;+    size_t i;++    num /= sizeof(limb_t);++    for (i = 0; i < num; i++)+        rp[i] = 0;++#if defined(__GNUC__) && !defined(__NVCC__)+    asm volatile("" : : "r"(ret) : "memory");+#endif+}++/*+ * Some compilers get arguably overzealous(*) when passing pointer to+ * multi-dimensional array [such as vec384x] as 'const' argument.+ * General direction seems to be to legitimize such constification,+ * so it's argued that suppressing the warning is appropriate.+ *+ * (*)  http://www.open-std.org/jtc1/sc22/wg14/www/docs/n1923.htm+ */+#if defined(__INTEL_COMPILER)+# pragma warning(disable:167)+# pragma warning(disable:556)+#elif defined(__GNUC__) && !defined(__clang__)+# pragma GCC diagnostic ignored "-Wpedantic"+#elif defined(_MSC_VER)+# pragma warning(disable: 4127 4189)+#endif++#if !defined(__wasm__)+# include <stdlib.h>+#endif++#if defined(__GNUC__)+# ifndef alloca+#  define alloca(s) __builtin_alloca(s)+# endif+#elif defined(__sun)+# include <alloca.h>+#elif defined(_WIN32)+# include <malloc.h>+# ifndef alloca+#  define alloca(s) _alloca(s)+# endif+#endif++#endif /* __BLS12_381_ASM_VECT_H__ */
+ hsblst.cabal view
@@ -0,0 +1,291 @@+cabal-version: 1.12++-- This file has been generated from package.yaml by hpack version 0.34.4.+--+-- see: https://github.com/sol/hpack++name:           hsblst+version:        0.0.1+synopsis:       Haskell bindings to BLST+description:    HsBLST is low-level Haskell bindings and a high-level interface to [BLST](https://github.com/supranational/blst) -- a multilingual BLS12-381 signature library.+category:       Cryptography+homepage:       https://github.com/serokell/hsblst#readme+bug-reports:    https://github.com/serokell/hsblst/issues+author:         Serokell <hi@serokell.io>+maintainer:     Serokell <hi@serokell.io>+copyright:      2022 Serokell <https://serokell.io>+license:        MPL-2.0+license-file:   LICENSE+build-type:     Simple+tested-with:+    GHC == 9.0.2+  , GHC == 9.2.7+  , GHC == 9.4.4+extra-source-files:+    README.md+    CHANGELOG.md+    c-source/build/coff/add_mod_256-x86_64.s+    c-source/build/coff/add_mod_384-x86_64.s+    c-source/build/coff/add_mod_384x384-x86_64.s+    c-source/build/coff/ct_inverse_mod_256-x86_64.s+    c-source/build/coff/ct_is_square_mod_384-x86_64.s+    c-source/build/coff/ctq_inverse_mod_384-x86_64.s+    c-source/build/coff/ctx_inverse_mod_384-x86_64.s+    c-source/build/coff/div3w-x86_64.s+    c-source/build/coff/mulq_mont_256-x86_64.s+    c-source/build/coff/mulq_mont_384-x86_64.s+    c-source/build/coff/mulx_mont_256-x86_64.s+    c-source/build/coff/mulx_mont_384-x86_64.s+    c-source/build/coff/sha256-portable-x86_64.s+    c-source/build/coff/sha256-x86_64.s+    c-source/build/elf/add_mod_256-x86_64.s+    c-source/build/elf/add_mod_384-x86_64.s+    c-source/build/elf/add_mod_384x384-x86_64.s+    c-source/build/elf/ct_inverse_mod_256-x86_64.s+    c-source/build/elf/ct_is_square_mod_384-x86_64.s+    c-source/build/elf/ctq_inverse_mod_384-x86_64.s+    c-source/build/elf/ctx_inverse_mod_384-x86_64.s+    c-source/build/elf/div3w-x86_64.s+    c-source/build/elf/mulq_mont_256-x86_64.s+    c-source/build/elf/mulq_mont_384-x86_64.s+    c-source/build/elf/mulx_mont_256-x86_64.s+    c-source/build/elf/mulx_mont_384-x86_64.s+    c-source/build/elf/sha256-portable-x86_64.s+    c-source/build/elf/sha256-x86_64.s+    c-source/build/mach-o/add_mod_256-x86_64.s+    c-source/build/mach-o/add_mod_384-x86_64.s+    c-source/build/mach-o/add_mod_384x384-x86_64.s+    c-source/build/mach-o/ct_inverse_mod_256-x86_64.s+    c-source/build/mach-o/ct_is_square_mod_384-x86_64.s+    c-source/build/mach-o/ctq_inverse_mod_384-x86_64.s+    c-source/build/mach-o/ctx_inverse_mod_384-x86_64.s+    c-source/build/mach-o/div3w-x86_64.s+    c-source/build/mach-o/mulq_mont_256-x86_64.s+    c-source/build/mach-o/mulq_mont_384-x86_64.s+    c-source/build/mach-o/mulx_mont_256-x86_64.s+    c-source/build/mach-o/mulx_mont_384-x86_64.s+    c-source/build/mach-o/sha256-portable-x86_64.s+    c-source/build/mach-o/sha256-x86_64.s+    c-source/build/assembly.S+    c-source/build/coff/add_mod_256-armv8.S+    c-source/build/coff/add_mod_384-armv8.S+    c-source/build/coff/ct_inverse_mod_256-armv8.S+    c-source/build/coff/ct_inverse_mod_384-armv8.S+    c-source/build/coff/ct_is_square_mod_384-armv8.S+    c-source/build/coff/div3w-armv8.S+    c-source/build/coff/mul_mont_256-armv8.S+    c-source/build/coff/mul_mont_384-armv8.S+    c-source/build/coff/sha256-armv8.S+    c-source/build/elf/add_mod_256-armv8.S+    c-source/build/elf/add_mod_384-armv8.S+    c-source/build/elf/ct_inverse_mod_256-armv8.S+    c-source/build/elf/ct_inverse_mod_384-armv8.S+    c-source/build/elf/ct_is_square_mod_384-armv8.S+    c-source/build/elf/div3w-armv8.S+    c-source/build/elf/mul_mont_256-armv8.S+    c-source/build/elf/mul_mont_384-armv8.S+    c-source/build/elf/sha256-armv8.S+    c-source/build/mach-o/add_mod_256-armv8.S+    c-source/build/mach-o/add_mod_384-armv8.S+    c-source/build/mach-o/ct_inverse_mod_256-armv8.S+    c-source/build/mach-o/ct_inverse_mod_384-armv8.S+    c-source/build/mach-o/ct_is_square_mod_384-armv8.S+    c-source/build/mach-o/div3w-armv8.S+    c-source/build/mach-o/mul_mont_256-armv8.S+    c-source/build/mach-o/mul_mont_384-armv8.S+    c-source/build/mach-o/sha256-armv8.S+    c-source/src/aggregate.c+    c-source/src/bulk_addition.c+    c-source/src/client_min_pk.c+    c-source/src/client_min_sig.c+    c-source/src/consts.c+    c-source/src/e1.c+    c-source/src/e2.c+    c-source/src/exp.c+    c-source/src/exports.c+    c-source/src/fp12_tower.c+    c-source/src/hash_to_field.c+    c-source/src/keygen.c+    c-source/src/map_to_g1.c+    c-source/src/map_to_g2.c+    c-source/src/multi_scalar.c+    c-source/src/pairing.c+    c-source/src/rb_tree.c+    c-source/src/recip.c+    c-source/src/server.c+    c-source/src/sqrt.c+    c-source/src/vect.c+    c-source/src/bytes.h+    c-source/src/consts.h+    c-source/src/ec_mult.h+    c-source/src/ec_ops.h+    c-source/src/errors.h+    c-source/src/fields.h+    c-source/src/no_asm.h+    c-source/src/point.h+    c-source/src/recip-addchain.h+    c-source/src/sha256.h+    c-source/src/sqrt-addchain.h+    c-source/src/vect.h+    c-source/bindings/blst.h+    c-source/bindings/blst_aux.h+    c-source/LICENSE+    c-source/README.md++source-repository head+  type: git+  location: https://github.com/serokell/hsblst++library+  exposed-modules:+      Crypto.BLST+      Crypto.BLST.Internal.Bindings+      Crypto.BLST.Internal.Bindings.Types+      Crypto.BLST.Internal.Classy+      Crypto.BLST.Internal.Demote+      Crypto.BLST.Internal.Types+  other-modules:+      Paths_hsblst+  hs-source-dirs:+      src+  default-extensions:+      AllowAmbiguousTypes+      BangPatterns+      BlockArguments+      ConstraintKinds+      DataKinds+      DefaultSignatures+      DeriveAnyClass+      DeriveDataTypeable+      DeriveFoldable+      DeriveFunctor+      DeriveGeneric+      DeriveTraversable+      DerivingStrategies+      DerivingVia+      EmptyCase+      FlexibleContexts+      FlexibleInstances+      GADTs+      GeneralizedNewtypeDeriving+      ImportQualifiedPost+      LambdaCase+      MultiParamTypeClasses+      MultiWayIf+      NamedFieldPuns+      NegativeLiterals+      NoStarIsType+      NumDecimals+      OverloadedLabels+      OverloadedStrings+      PatternSynonyms+      PolyKinds+      QuasiQuotes+      RankNTypes+      RecordWildCards+      RecursiveDo+      ScopedTypeVariables+      StandaloneDeriving+      StandaloneKindSignatures+      StrictData+      TemplateHaskell+      TupleSections+      TypeApplications+      TypeFamilies+      TypeOperators+      UndecidableInstances+      UndecidableSuperClasses+      ViewPatterns+  ghc-options: -Weverything -Wno-missing-exported-signatures -Wno-missing-import-lists -Wno-missed-specialisations -Wno-all-missed-specialisations -Wno-unsafe -Wno-safe -Wno-missing-local-signatures -Wno-monomorphism-restriction -Wno-implicit-prelude -Wno-prepositive-qualified-module -Wno-inferred-safe-imports -Wno-missing-safe-haskell-mode+  include-dirs:+      c-source/bindings+  c-sources:+      c-source/src/server.c+      c-source/build/assembly.S+  build-tools:+      c2hs+  build-depends:+      base >=4.15.1.0 && <4.18+    , deepseq >=1.4.5.0 && <1.5+    , memory >=0.16.0 && <0.19+  if impl(ghc >= 9.2)+    ghc-options: -Wno-missing-kind-signatures+  default-language: Haskell2010++test-suite hsblst-test+  type: exitcode-stdio-1.0+  main-is: Main.hs+  other-modules:+      Test.BLST+      Test.BLST.Bindings+      Test.BLST.Fixtures+      Test.BLST.Tezos+      Test.BLST.Util+      Paths_hsblst+  hs-source-dirs:+      test+  default-extensions:+      AllowAmbiguousTypes+      BangPatterns+      BlockArguments+      ConstraintKinds+      DataKinds+      DefaultSignatures+      DeriveAnyClass+      DeriveDataTypeable+      DeriveFoldable+      DeriveFunctor+      DeriveGeneric+      DeriveTraversable+      DerivingStrategies+      DerivingVia+      EmptyCase+      FlexibleContexts+      FlexibleInstances+      GADTs+      GeneralizedNewtypeDeriving+      ImportQualifiedPost+      LambdaCase+      MultiParamTypeClasses+      MultiWayIf+      NamedFieldPuns+      NegativeLiterals+      NoStarIsType+      NumDecimals+      OverloadedLabels+      OverloadedStrings+      PatternSynonyms+      PolyKinds+      QuasiQuotes+      RankNTypes+      RecordWildCards+      RecursiveDo+      ScopedTypeVariables+      StandaloneDeriving+      StandaloneKindSignatures+      StrictData+      TemplateHaskell+      TupleSections+      TypeApplications+      TypeFamilies+      TypeOperators+      UndecidableInstances+      UndecidableSuperClasses+      ViewPatterns+  ghc-options: -Weverything -Wno-missing-exported-signatures -Wno-missing-import-lists -Wno-missed-specialisations -Wno-all-missed-specialisations -Wno-unsafe -Wno-safe -Wno-missing-local-signatures -Wno-monomorphism-restriction -Wno-implicit-prelude -Wno-prepositive-qualified-module -Wno-inferred-safe-imports -Wno-missing-safe-haskell-mode -Wno-incomplete-patterns -threaded "-with-rtsopts=-N -A64m -AL256m"+  build-tool-depends:+      tasty-discover:tasty-discover+  build-depends:+      base >=4.15.1.0 && <4.18+    , bytestring >=0.10.12.1 && <0.12+    , hex-text >=0.1.0.6 && <0.2+    , hsblst+    , memory >=0.16.0 && <0.19+    , tasty >=1.4.2.1 && <1.5+    , tasty-hunit >=0.10.0.3 && <0.11+    , text >=1.2.5.0 && <1.3 || >=2.0.1 && <2.1+  if impl(ghc >= 9.2)+    ghc-options: -Wno-missing-kind-signatures+  if impl(ghc < 9.4)+    ghc-options: -eventlog+  default-language: Haskell2010
+ src/Crypto/BLST.hs view
@@ -0,0 +1,193 @@+-- SPDX-FileCopyrightText: 2022 Serokell <https://serokell.io>+-- SPDX-License-Identifier: MPL-2.0++-- for inequality on keygen+{-# OPTIONS_GHC -Wno-redundant-constraints #-}++module Crypto.BLST+  ( -- * Main functions+    keygen+  , skToPk+  , sign+  , verify+  , serializeSk+  , deserializeSk+  , serializePk+  , deserializePk+  , compressPk+  , decompressPk+  , serializeSignature+  , deserializeSignature+  , compressSignature+  , decompressSignature++    -- * Aggregate signatures+  , aggregateSignatures+  , aggregateVerify++    -- * Representation datatypes+  , SecretKey+  , PublicKey+  , Signature+  , B.BlstError(..)++    -- * Utility typeclasses+  , IsCurve+  , IsPoint+  , ToCurve+  , Demote++    -- * Data kinds+  , Curve(..)+  , B.EncodeMethod(..)++    -- * Typelevel byte sizes+  , ByteSize+  , SerializeOrCompress(..)++    -- * Misc helpers+  , noDST+  , byteSize+  ) where++import Control.Exception (catch, throwIO)+import Control.Monad (forM_)+import Data.ByteArray (ByteArrayAccess, Bytes, ScrubbedBytes)+import Data.ByteArray.Sized (SizedByteArray, unSizedByteArray)+import Data.Foldable (foldlM)+import Data.List.NonEmpty (NonEmpty(..))+import GHC.TypeNats (KnownNat, type (<=))+import System.IO.Unsafe (unsafePerformIO)++import Crypto.BLST.Internal.Bindings qualified as B+import Crypto.BLST.Internal.Classy+import Crypto.BLST.Internal.Demote+import Crypto.BLST.Internal.Types++-- | Generate a secret key from bytes.+keygen :: (ByteArrayAccess ba, 32 <= n, KnownNat n) => SizedByteArray n ba -> SecretKey+keygen = SecretKey . unsafePerformIO . B.keygen . unSizedByteArray++-- | Convert a secret key to the corresponding public key on a given curve.+skToPk :: forall c. IsCurve c => SecretKey -> PublicKey c+skToPk (SecretKey sk) = PublicKey $ unsafePerformIO $ skToPkPoint sk >>= toAffine++-- | Serialize public key.+serializePk+  :: forall c. IsCurve c+  => PublicKey c+  -> SizedByteArray (SerializedSize (CurveToPkPoint c)) Bytes+serializePk (PublicKey pk) = unsafePerformIO $ affSerialize pk++-- | Deserialize public key.+deserializePk+  :: forall c ba. (IsCurve c, ByteArrayAccess ba)+  => SizedByteArray (SerializedSize (CurveToPkPoint c)) ba+  -> Either B.BlstError (PublicKey c)+deserializePk bs = unsafePerformIO $ fmap PublicKey <$> deserialize bs++-- | Compress public key.+compressPk+  :: forall c. IsCurve c+  => PublicKey c+  -> SizedByteArray (CompressedSize (CurveToPkPoint c)) Bytes+compressPk (PublicKey pk) = unsafePerformIO $ affCompress pk++-- | Decompress public key.+decompressPk+  :: forall c ba. (IsCurve c, ByteArrayAccess ba)+  => SizedByteArray (CompressedSize (CurveToPkPoint c)) ba+  -> Either B.BlstError (PublicKey c)+decompressPk bs = unsafePerformIO $ fmap PublicKey <$> uncompress bs++-- | Sign a single message.+sign+  :: forall c m ba ba2. (ToCurve m c, ByteArrayAccess ba, ByteArrayAccess ba2)+  => SecretKey -- ^ Secret key+  -> ba -- ^ Message to sign+  -> Maybe ba2 -- ^ Optional domain separation tag+  -> Signature c m+sign (SecretKey sk) bytes dst = Signature $ unsafePerformIO $ do+  encMsg <- toCurve @m bytes dst+  signPk encMsg sk >>= toAffine++-- | Serialize message signature.+serializeSignature+  :: forall c m. IsCurve c+  => Signature c m+  -> SizedByteArray (SerializedSize (CurveToMsgPoint c)) Bytes+serializeSignature (Signature sig) = unsafePerformIO $ affSerialize sig++-- | Deserialize message signature.+deserializeSignature+  :: forall c m ba. (IsCurve c, ByteArrayAccess ba)+  => SizedByteArray (SerializedSize (CurveToMsgPoint c)) ba+  -> Either B.BlstError (Signature c m)+deserializeSignature bs = unsafePerformIO $ fmap Signature <$> deserialize bs++-- | Serialize and compress message signature.+compressSignature+  :: forall c m. IsCurve c+  => Signature c m+  -> SizedByteArray (CompressedSize (CurveToMsgPoint c)) Bytes+compressSignature (Signature sig) = unsafePerformIO $ affCompress sig++-- | Decompress and deserialize message signature.+decompressSignature+  :: forall c m ba. (IsCurve c, ByteArrayAccess ba)+  => SizedByteArray (CompressedSize (CurveToMsgPoint c)) ba+  -> Either B.BlstError (Signature c m)+decompressSignature bs = unsafePerformIO $ fmap Signature <$> uncompress bs++-- | Verify message signature.+verify+  :: forall c m ba ba2. (IsCurve c, Demote m, ByteArrayAccess ba, ByteArrayAccess ba2)+  => Signature c m -- ^ Signature+  -> PublicKey c -- ^ Public key of the signer+  -> ba -- ^ Message+  -> Maybe ba2 -- ^ Optional domain separation tag (must be the same as used for signing!)+  -> B.BlstError+verify (Signature sig) (PublicKey pk) bytes dst =+  unsafePerformIO $ coreVerifyPk pk sig meth bytes dst+  where+    meth = demote @m++-- | Convenience synonym for 'Nothing'. Do not use domain separation tag.+noDST :: Maybe Bytes+noDST = Nothing++-- | Serialize secret key.+serializeSk :: SecretKey -> SizedByteArray B.SkSerializeSize ScrubbedBytes+serializeSk (SecretKey sk) = unsafePerformIO $ B.lendianFromScalar sk++-- | Deserialize secret key.+deserializeSk :: ByteArrayAccess ba => SizedByteArray B.SkSerializeSize ba -> SecretKey+deserializeSk bs = SecretKey $ unsafePerformIO $ B.scalarFromLendian bs++-- | Aggregate multiple signatures.+aggregateSignatures :: forall c m. IsCurve c => NonEmpty (Signature c m) -> Signature c m+aggregateSignatures (Signature x :| xs) = Signature . unsafePerformIO $ do+  start <- fromAffine x+  foldlM add start xs >>= toAffine+  where+    add x' (Signature y) = addOrDoubleAffine x' y++-- | Aggregate signature verification.+aggregateVerify+  :: forall c m ba ba2. (IsCurve c, Demote m, ByteArrayAccess ba, ByteArrayAccess ba2)+  => NonEmpty (PublicKey c, ba) -- ^ Public keys with corresponding messages+  -> Signature c m -- ^ Aggregate signature+  -> Maybe ba2 -- ^ Optional domain separation tag (must be the same as used for signing!)+  -> Either B.BlstError Bool+aggregateVerify ((PublicKey pk1, msg1) :| xs) (Signature sig) dst = unsafePerformIO $ do+  ctx <- B.pairingInit (demote @m) dst+  checkThrow =<< pairingChkNAggrPk ctx pk1 True (Just sig) True msg1+  forM_ xs $ \(PublicKey pki, msgi) ->+    checkThrow =<< pairingChkNAggrPk ctx pki True Nothing True msgi+  B.pairingCommit ctx+  Right <$> B.pairingFinalVerify ctx+  `catch` \(err :: B.BlstError) -> pure $ Left err+  where+    checkThrow = \case+      B.BlstSuccess -> pure ()+      x -> throwIO x
+ src/Crypto/BLST/Internal/Bindings.chs view
@@ -0,0 +1,451 @@+-- SPDX-FileCopyrightText: 2022 Serokell <https://serokell.io>+-- SPDX-License-Identifier: MPL-2.0++#include <blst.h>++{-# OPTIONS_HADDOCK not-home #-}++-- | Lower-level bindings. Functions starting with @blst_@ are raw c2hs+-- bindings. Others are slightly higher level wrappers around those bindings.+--+-- See+-- <https://github.com/supranational/blst/tree/f791f7a465cda8ecda74df0a60778331dde40809#introductory-tutorial>+-- for a more comprehensive explanation of the functions declared here.+module Crypto.BLST.Internal.Bindings+  ( module Crypto.BLST.Internal.Bindings+  , module Crypto.BLST.Internal.Bindings.Types+  ) where++import Prelude hiding (length)++import Control.Exception (Exception, catch, throwIO)+import Data.ByteArray (ByteArrayAccess(..), Bytes, ScrubbedBytes)+import Data.ByteArray qualified as BA+import Data.ByteArray.Sized (SizedByteArray)+import Data.ByteArray.Sized qualified as AS+import Foreign.Marshal.Utils (fromBool, toBool)+import Foreign.Ptr (nullPtr)++import Crypto.BLST.Internal.Bindings.Types++type instance SizeOf (Point 'P1) = {# sizeof blst_p1 #}+type instance SizeOf (Point 'P2) = {# sizeof blst_p2 #}++type instance SizeOf (Affine 'P1) = {# sizeof blst_p1_affine #}+type instance SizeOf (Affine 'P2) = {# sizeof blst_p2_affine #}++type instance SizeOf Scalar = {# sizeof blst_scalar #}++-- | Possible C return values.+{# enum BLST_ERROR as BlstError {underscoreToCase} #}++deriving stock instance Eq BlstError+deriving stock instance Bounded BlstError+deriving stock instance Show BlstError++instance Exception BlstError++-- | Generate secret key from bytes. Input must be at least 32 bytes long.+keygen :: ByteArrayAccess ba => ba -> IO Scalar+keygen bytes = fmap Scalar $+  AS.create $ \ptr ->+  withByteArray bytes $ \bytes' ->+    -- void blst_keygen(blst_scalar *out_SK, const byte *IKM, size_t IKM_len,+    --                  const byte *info DEFNULL, size_t info_len DEFNULL);+    {# call blst_keygen #} ptr bytes' (fromIntegral $ length bytes) nullPtr 0++-- | Convert scalar to a point in G1.+skToPkInG1 :: Scalar -> IO (Point 'P1)+skToPkInG1 (Scalar sk) = fmap Point $+  AS.create $ \ptr ->+  withByteArray sk $ \sk' ->+    -- void blst_sk_to_pk_in_g1(blst_p1 *out_pk, const blst_scalar *SK);+    {# call blst_sk_to_pk_in_g1 #} ptr sk'++-- | Convert scalar to a P2 point in G2.+skToPkInG2 :: Scalar -> IO (Point 'P2)+skToPkInG2 (Scalar sk) = fmap Point $+  AS.create $ \ptr ->+  withByteArray sk $ \sk' ->+    -- void blst_sk_to_pk_in_g2(blst_p2 *out_pk, const blst_scalar *SK);+    {# call blst_sk_to_pk_in_g2 #} ptr sk'++-- | Sign a message point in G1.+signPkInG1 :: Point 'P2 -> Scalar -> IO (Point 'P2)+signPkInG1 (Point p2) (Scalar sc) = fmap Point $+  AS.create $ \ptr ->+  withByteArray sc $ \sc' ->+  withByteArray p2 $ \p2' ->+    -- void blst_sign_pk_in_g1(blst_p2 *out_sig, const blst_p2 *hash,+    --                                           const blst_scalar *SK);+    {# call blst_sign_pk_in_g1 #} ptr p2' sc'++-- | Sign a message point in G2.+signPkInG2 :: Point 'P1 -> Scalar -> IO (Point 'P1)+signPkInG2 (Point p1) (Scalar sc) = fmap Point $+  AS.create $ \ptr ->+  withByteArray sc $ \sc' ->+  withByteArray p1 $ \p1' ->+    -- void blst_sign_pk_in_g2(blst_p1 *out_sig, const blst_p1 *hash,+    --                                           const blst_scalar *SK);+    {# call blst_sign_pk_in_g2 #} ptr p1' sc'++-- | Encode bytes to a point in G1.+encodeToG1 :: (ByteArrayAccess ba, ByteArrayAccess ba2) => ba -> Maybe ba2 -> IO (Point 'P1)+encodeToG1 msg dst = fmap Point $+  AS.create $ \ptr ->+  withByteArray msg $ \msg' ->+  maybe ($ nullPtr) withByteArray dst $ \dst' ->+    -- void blst_encode_to_g1(blst_p1 *out,+    --                        const byte *msg, size_t msg_len,+    --                        const byte *DST DEFNULL, size_t DST_len DEFNULL,+    --                        const byte *aug DEFNULL, size_t aug_len DEFNULL);+    {# call blst_encode_to_g1 #} ptr msg' (fromIntegral $ length msg)+      dst' (maybe 0 (fromIntegral . length) dst) nullPtr 0++-- | Hash bytes to a point in G1.+hashToG1 :: (ByteArrayAccess ba, ByteArrayAccess ba2) => ba -> Maybe ba2 -> IO (Point 'P1)+hashToG1 msg dst = fmap Point $+  AS.create $ \ptr ->+  withByteArray msg $ \msg' ->+  maybe ($ nullPtr) withByteArray dst $ \dst' ->+    -- void blst_hash_to_g1(blst_p1 *out,+    --                      const byte *msg, size_t msg_len,+    --                      const byte *DST DEFNULL, size_t DST_len DEFNULL,+    --                      const byte *aug DEFNULL, size_t aug_len DEFNULL);+    {# call blst_hash_to_g1 #} ptr msg' (fromIntegral $ length msg)+      dst' (maybe 0 (fromIntegral . length) dst) nullPtr 0++-- | Encode bytes to a point in G2.+encodeToG2 :: (ByteArrayAccess ba, ByteArrayAccess ba2) => ba -> Maybe ba2 -> IO (Point 'P2)+encodeToG2 msg dst = fmap Point $+  AS.create $ \ptr ->+  withByteArray msg $ \msg' ->+  maybe ($ nullPtr) withByteArray dst $ \dst' ->+    -- void blst_encode_to_g2(blst_p2 *out,+    --                        const byte *msg, size_t msg_len,+    --                        const byte *DST DEFNULL, size_t DST_len DEFNULL,+    --                        const byte *aug DEFNULL, size_t aug_len DEFNULL);+    {# call blst_encode_to_g2 #} ptr msg' (fromIntegral $ length msg)+      dst' (maybe 0 (fromIntegral . length) dst) nullPtr 0++-- | Hash bytes to a point in G2.+hashToG2 :: (ByteArrayAccess ba, ByteArrayAccess ba2) => ba -> Maybe ba2 -> IO (Point 'P2)+hashToG2 msg dst = fmap Point $+  AS.create $ \ptr ->+  withByteArray msg $ \msg' ->+  maybe ($ nullPtr) withByteArray dst $ \dst' ->+    -- void blst_hash_to_g2(blst_p2 *out,+    --                      const byte *msg, size_t msg_len,+    --                      const byte *DST DEFNULL, size_t DST_len DEFNULL,+    --                      const byte *aug DEFNULL, size_t aug_len DEFNULL);+    {# call blst_hash_to_g2 #} ptr msg' (fromIntegral $ length msg)+      dst' (maybe 0 (fromIntegral . length) dst) nullPtr 0++-- | Core signature verification function in G1.+coreVerifyPkInG1+  :: (ByteArrayAccess ba, ByteArrayAccess ba2)+  => Affine 'P1 -- ^ Public key+  -> Affine 'P2 -- ^ Signature+  -> EncodeMethod -- ^ Was message encoded or hashed to the curve+  -> ba -- ^ Message+  -> Maybe ba2 -- ^ Optional domain separation tag+  -> IO BlstError+coreVerifyPkInG1 (Affine pk) (Affine sig) hoe msg dst = fmap (toEnum . fromIntegral) $+  withByteArray pk $ \pk' ->+  withByteArray sig $ \sig' ->+  withByteArray msg $ \msg' ->+  maybe ($ nullPtr) withByteArray dst $ \dst' ->+    -- BLST_ERROR blst_core_verify_pk_in_g1(const blst_p1_affine *pk,+    --                                      const blst_p2_affine *signature,+    --                                      bool hash_or_encode,+    --                                      const byte *msg, size_t msg_len,+    --                                      const byte *DST DEFNULL,+    --                                      size_t DST_len DEFNULL,+    --                                      const byte *aug DEFNULL,+    --                                      size_t aug_len DEFNULL);+    {# call blst_core_verify_pk_in_g1 #} pk' sig' (fromIntegral $ fromEnum hoe)+      msg' (fromIntegral $ length msg)+      dst' (maybe 0 (fromIntegral . length) dst)+      nullPtr 0++-- | Core signature verification function in G2.+coreVerifyPkInG2+  :: (ByteArrayAccess ba, ByteArrayAccess ba2)+  => Affine 'P2 -- ^ Public key+  -> Affine 'P1 -- ^ Signature+  -> EncodeMethod -- ^ Was message encoded or hashed to the curve+  -> ba -- ^ Message+  -> Maybe ba2 -- ^ Optional domain separation tag+  -> IO BlstError+coreVerifyPkInG2 (Affine pk) (Affine sig) hoe msg dst = fmap (toEnum . fromIntegral) $+  withByteArray pk $ \pk' ->+  withByteArray sig $ \sig' ->+  withByteArray msg $ \msg' ->+  maybe ($ nullPtr) withByteArray dst $ \dst' ->+    -- BLST_ERROR blst_core_verify_pk_in_g2(const blst_p2_affine *pk,+    --                                      const blst_p1_affine *signature,+    --                                      bool hash_or_encode,+    --                                      const byte *msg, size_t msg_len,+    --                                      const byte *DST DEFNULL,+    --                                      size_t DST_len DEFNULL,+    --                                      const byte *aug DEFNULL,+    --                                      size_t aug_len DEFNULL);+    {# call blst_core_verify_pk_in_g2 #} pk' sig' (fromIntegral $ fromEnum hoe)+      msg' (fromIntegral $ length msg)+      dst' (maybe 0 (fromIntegral . length) dst)+      nullPtr 0++-- | Convert point to affine point in G1.+p1ToAffine :: Point 'P1 -> IO (Affine 'P1)+p1ToAffine (Point p1) = fmap Affine $+  AS.create $ \ptr ->+  withByteArray p1 $ \p1' ->+    -- void blst_p1_to_affine(blst_p1_affine *out, const blst_p1 *in);+    {# call blst_p1_to_affine #} ptr p1'++-- | Convert point to affine point in G2.+p2ToAffine :: Point 'P2 -> IO (Affine 'P2)+p2ToAffine (Point p2) = fmap Affine $+  AS.create $ \ptr ->+  withByteArray p2 $ \p2' ->+    -- void blst_p2_to_affine(blst_p2_affine *out, const blst_p2 *in);+    {# call blst_p2_to_affine #} ptr p2'++-- | Serialize affine G1 point.+p1AffSerialize :: Affine 'P1 -> IO (SizedByteArray P1SerializeSize Bytes)+p1AffSerialize (Affine p1) =+  AS.create $ \ptr ->+  withByteArray p1 $ \p1' ->+    -- void blst_p1_affine_serialize(byte out[96], const blst_p1_affine *in);+    {# call blst_p1_affine_serialize #} ptr p1'++-- | Serialize and compress affine G1 point.+p1AffCompress :: Affine 'P1 -> IO (SizedByteArray P1CompressSize Bytes)+p1AffCompress (Affine p1) =+  AS.create $ \ptr ->+  withByteArray p1 $ \p1' ->+    -- void blst_p1_affine_compress(byte out[48], const blst_p1_affine *in);+    {# call blst_p1_affine_compress #} ptr p1'++-- | Deserialize affine G1 point.+p1Deserialize+  :: ByteArrayAccess ba+  => SizedByteArray P1SerializeSize ba+  -> IO (Either BlstError (Affine 'P1))+p1Deserialize bs = do+  fmap (Right . Affine) $+    AS.create $ \ptr ->+    withByteArray bs $ \bs' -> do+      -- BLST_ERROR blst_p1_deserialize(blst_p1_affine *out, const byte in[96]);+      res <- {# call blst_p1_deserialize #} ptr bs'+      let res' = toEnum $ fromIntegral res+      case res' of+        BlstSuccess -> pure ()+        x -> throwIO x+  `catch` \(x :: BlstError) -> pure $ Left x++-- | Deserialize and decompress affine G1 point.+p1Uncompress+  :: ByteArrayAccess ba+  => SizedByteArray P1CompressSize ba+  -> IO (Either BlstError (Affine 'P1))+p1Uncompress bs = do+  fmap (Right . Affine) $+    AS.create $ \ptr ->+    withByteArray bs $ \bs' -> do+      -- BLST_ERROR blst_p1_uncompress(blst_p1_affine *out, const byte in[48]);+      res <- {# call blst_p1_uncompress #} ptr bs'+      let res' = toEnum $ fromIntegral res+      case res' of+        BlstSuccess -> pure ()+        x -> throwIO x+  `catch` \(x :: BlstError) -> pure $ Left x++-- | Serialize affine G2 point.+p2AffSerialize :: Affine 'P2 -> IO (SizedByteArray P2SerializeSize Bytes)+p2AffSerialize (Affine p2) =+  AS.create $ \ptr ->+  withByteArray p2 $ \p2' ->+    -- void blst_p2_affine_serialize(byte out[192], const blst_p2_affine *in);+    {# call blst_p2_affine_serialize #} ptr p2'++-- | Serialize and compress affine G2 point.+p2AffCompress :: Affine 'P2 -> IO (SizedByteArray P2CompressSize Bytes)+p2AffCompress (Affine p2) =+  AS.create $ \ptr ->+  withByteArray p2 $ \p2' ->+    -- void blst_p2_affine_compress(byte out[96], const blst_p2_affine *in);+    {# call blst_p2_affine_compress #} ptr p2'++-- | Deserialize affine G2 point.+p2Deserialize+  :: ByteArrayAccess ba+  => SizedByteArray P2SerializeSize ba+  -> IO (Either BlstError (Affine 'P2))+p2Deserialize bs = do+  fmap (Right . Affine) $+    AS.create $ \ptr ->+    withByteArray bs $ \bs' -> do+      -- BLST_ERROR blst_p2_deserialize(blst_p2_affine *out, const byte in[192]);+      res <- {# call blst_p2_deserialize #} ptr bs'+      let res' = toEnum $ fromIntegral res+      case res' of+        BlstSuccess -> pure ()+        x -> throwIO x+  `catch` \(x :: BlstError) -> pure $ Left x++-- | Deserialize and decompress affine G2 point.+p2Uncompress+  :: ByteArrayAccess ba+  => SizedByteArray P2CompressSize ba+  -> IO (Either BlstError (Affine 'P2))+p2Uncompress bs = do+  fmap (Right . Affine) $+    AS.create $ \ptr ->+    withByteArray bs $ \bs' -> do+      -- BLST_ERROR blst_p2_uncompress(blst_p2_affine *out, const byte in[96]);+      res <- {# call blst_p2_uncompress #} ptr bs'+      let res' = toEnum $ fromIntegral res+      case res' of+        BlstSuccess -> pure ()+        x -> throwIO x+  `catch` \(x :: BlstError) -> pure $ Left x++-- | Get scalar bytes in little endian order.+lendianFromScalar :: Scalar -> IO (SizedByteArray SkSerializeSize ScrubbedBytes)+lendianFromScalar (Scalar sc) =+  AS.create $ \out ->+  withByteArray sc $ \sc' ->+  -- void blst_lendian_from_scalar(byte out[32], const blst_scalar *a);+  {# call blst_lendian_from_scalar #} out sc'++-- | Build scalar from bytes in little endian order.+scalarFromLendian :: ByteArrayAccess ba => SizedByteArray SkSerializeSize ba -> IO Scalar+scalarFromLendian bs = fmap Scalar $+  AS.create $ \out ->+  withByteArray bs $ \bs' ->+  -- void blst_scalar_from_lendian(blst_scalar *out, const byte a[32]);+  {# call blst_scalar_from_lendian #} out bs'++-- | Add affine point to point in G1.+p1AddOrDoubleAffine :: Point 'P1 -> Affine 'P1 -> IO (Point 'P1)+p1AddOrDoubleAffine (Point a) (Affine b) = fmap Point $+  AS.create $ \out ->+  withByteArray a $ \a' ->+  withByteArray b $ \b' ->+  -- void blst_p1_add_or_double_affine(blst_p1 *out, const blst_p1 *a,+  --                                                 const blst_p1_affine *b);+  {# call blst_p1_add_or_double_affine #} out a' b'++-- | Add affine point to point in G2.+p2AddOrDoubleAffine :: Point 'P2 -> Affine 'P2 -> IO (Point 'P2)+p2AddOrDoubleAffine (Point a) (Affine b) = fmap Point $+  AS.create $ \out ->+  withByteArray a $ \a' ->+  withByteArray b $ \b' ->+  -- void blst_p2_add_or_double_affine(blst_p2 *out, const blst_p2 *a,+  --                                                 const blst_p2_affine *b);+  {# call blst_p2_add_or_double_affine #} out a' b'++-- | Convert affine point to point in G1.+p1FromAffine :: Affine 'P1 -> IO (Point 'P1)+p1FromAffine (Affine aff) = fmap Point $+  AS.create $ \out ->+  withByteArray aff $ \aff' ->+  -- void blst_p1_from_affine(blst_p1 *out, const blst_p1_affine *in);+  {# call blst_p1_from_affine #} out aff'++-- | Convert affine point to point in G2.+p2FromAffine :: Affine 'P2 -> IO (Point 'P2)+p2FromAffine (Affine aff) = fmap Point $+  AS.create $ \out ->+  withByteArray aff $ \aff' ->+  -- void blst_p2_from_affine(blst_p2 *out, const blst_p2_affine *in);+  {# call blst_p2_from_affine #} out aff'++-- | Check aggregate signature in G1.+pairingChkNAggrPkInG1+  :: ByteArrayAccess ba+  => PairingCtx -- ^ Pairing context. Use 'pairingInit' to create.+  -> Affine 'P1 -- ^ Public key+  -> Bool -- ^ Check public key group?+  -> Maybe (Affine 'P2)+  -- ^ Signature. Only the first call per pairing context specifies the+  -- signature, all consequent calls for the same context should use 'Nothing'+  -- here.+  -> Bool -- ^ Check signature group?+  -> ba -- ^ Message+  -> IO BlstError+pairingChkNAggrPkInG1 (PairingCtx ctx) (Affine pk) pk_gpck sig sig_gpck msg =+  fmap (toEnum . fromIntegral) $+  withByteArray ctx $ \ctx' ->+  withByteArray pk $ \pk' ->+  maybe ($ nullPtr) (withByteArray . unAffine) sig $ \sig' ->+  withByteArray msg $ \msg' ->+  -- BLST_ERROR blst_pairing_chk_n_aggr_pk_in_g1(blst_pairing *ctx,+  --                                             const blst_p1_affine *PK,+  --                                             bool pk_grpchk,+  --                                             const blst_p2_affine *signature,+  --                                             bool sig_grpchk,+  --                                             const byte *msg, size_t msg_len,+  --                                             const byte *aug DEFNULL,+  --                                             size_t aug_len DEFNULL);+  {# call blst_pairing_chk_n_aggr_pk_in_g1 #} ctx' pk' (fromBool pk_gpck) sig'+    (fromBool sig_gpck) msg' (fromIntegral $ length msg) nullPtr 0++-- | Check aggregate signature in G2.+pairingChkNAggrPkInG2+  :: ByteArrayAccess ba+  => PairingCtx -- ^ Pairing context. Use 'pairingInit' to create.+  -> Affine 'P2 -- ^ Public key+  -> Bool -- ^ Check public key group?+  -> Maybe (Affine 'P1)+  -- ^ Signature. Only the first call per pairing context specifies the+  -- signature, all consequent calls for the same context should use 'Nothing'+  -- here.+  -> Bool -- ^ Check signature group?+  -> ba -- ^ Message+  -> IO BlstError+pairingChkNAggrPkInG2 (PairingCtx ctx) (Affine pk) pk_gpck sig sig_gpck msg =+  fmap (toEnum . fromIntegral) $+  withByteArray ctx $ \ctx' ->+  withByteArray pk $ \pk' ->+  maybe ($ nullPtr) (withByteArray . unAffine) sig $ \sig' ->+  withByteArray msg $ \msg' ->+  -- BLST_ERROR blst_pairing_chk_n_aggr_pk_in_g2(blst_pairing *ctx,+  --                                             const blst_p2_affine *PK,+  --                                             bool pk_grpchk,+  --                                             const blst_p1_affine *signature,+  --                                             bool sig_grpchk,+  --                                             const byte *msg, size_t msg_len,+  --                                             const byte *aug DEFNULL,+  --                                             size_t aug_len DEFNULL);+  {# call blst_pairing_chk_n_aggr_pk_in_g2 #} ctx' pk' (fromBool pk_gpck) sig'+    (fromBool sig_gpck) msg' (fromIntegral $ length msg) nullPtr 0++-- | Make new pairing context.+pairingInit :: ByteArrayAccess ba => EncodeMethod -> Maybe ba -> IO PairingCtx+pairingInit hoe dst = do+  sz <- {# call blst_pairing_sizeof #}+  fmap PairingCtx $ BA.create (fromIntegral sz) $ \out ->+    maybe ($ nullPtr) withByteArray dst $ \dst' ->+      -- void blst_pairing_init(blst_pairing *new_ctx, bool hash_or_encode,+      --                        const byte *DST DEFNULL, size_t DST_len DEFNULL);+      {# call blst_pairing_init #} out (fromIntegral $ fromEnum hoe)+        dst' (maybe 0 (fromIntegral . length) dst)++-- | Commit pairing context.+pairingCommit :: PairingCtx -> IO ()+pairingCommit (PairingCtx ctx) =+  withByteArray ctx $ \ctx' ->+    -- void blst_pairing_commit(blst_pairing *ctx);+    {# call blst_pairing_commit #} ctx'++-- | Verify pairing context.+pairingFinalVerify :: PairingCtx -> IO Bool+pairingFinalVerify (PairingCtx ctx) = fmap toBool $+  withByteArray ctx $ \ctx' ->+    -- bool blst_pairing_finalverify(const blst_pairing *ctx,+    --                               const blst_fp12 *gtsig DEFNULL);+    {# call blst_pairing_finalverify #} ctx' nullPtr
+ src/Crypto/BLST/Internal/Bindings/Types.hs view
@@ -0,0 +1,77 @@+-- SPDX-FileCopyrightText: 2022 Serokell <https://serokell.io>+-- SPDX-License-Identifier: MPL-2.0++{-# OPTIONS_HADDOCK not-home #-}++-- | Types for lower-level bindings+module Crypto.BLST.Internal.Bindings.Types+  ( module Crypto.BLST.Internal.Bindings.Types+  ) where++import Prelude hiding (length)++import Control.DeepSeq (NFData(..))+import Data.ByteArray (Bytes, ScrubbedBytes)+import Data.ByteArray.Sized (SizedByteArray(..))+import Data.Coerce (coerce)+import Data.Kind (Type)+import GHC.TypeNats (Nat)++import Crypto.BLST.Internal.Demote++-- | Kind of point.+data PointKind = P1 | P2++instance Demote 'P1 where demote = P1+instance Demote 'P2 where demote = P2++-- | Size of type's representation in bytes.+type SizeOf :: Type -> Nat+type family SizeOf t++-- | Point representation.+newtype Point (a :: PointKind) = Point ( SizedByteArray (SizeOf (Point a)) Bytes )+  deriving stock (Show, Eq)++instance NFData (Point a) where+  rnf = rnf @Bytes . unSizedByteArray . coerce++-- | Affine point representation.+newtype Affine (a :: PointKind) = Affine { unAffine :: SizedByteArray (SizeOf (Affine a)) Bytes }+  deriving stock (Show, Eq)++instance NFData (Affine a) where+  rnf = rnf @Bytes . unSizedByteArray . coerce++-- | Scalar value representation.+newtype Scalar = Scalar ( SizedByteArray (SizeOf Scalar) ScrubbedBytes )+  deriving stock (Show, Eq)++instance NFData Scalar where+  rnf = rnf @ScrubbedBytes . unSizedByteArray . coerce++-- | Pairing context.+newtype PairingCtx = PairingCtx Bytes+  deriving newtype NFData++-- | Flag to choose whether values are hashed or encoded to the curve.+data EncodeMethod = Encode | Hash+  deriving stock (Eq, Enum, Bounded, Show)++instance Demote 'Hash where demote = Hash+instance Demote 'Encode where demote = Encode++-- | Serialized size of 'P1'.+type P1SerializeSize = 96++-- | Compressed serialized size of 'P1'.+type P1CompressSize = 48++-- | Serialized size of 'P2'.+type P2SerializeSize = 192++-- | Compressed serialized size of 'P2'.+type P2CompressSize = 96++-- | Scalar serialized size.+type SkSerializeSize = 32
+ src/Crypto/BLST/Internal/Classy.hs view
@@ -0,0 +1,131 @@+-- SPDX-FileCopyrightText: 2022 Serokell <https://serokell.io>+-- SPDX-License-Identifier: MPL-2.0++{-# LANGUAGE TypeFamilyDependencies #-}+{-# OPTIONS_HADDOCK not-home #-}++-- | Bindings with class.+module Crypto.BLST.Internal.Classy+  ( module Crypto.BLST.Internal.Classy+  ) where++import Data.ByteArray (ByteArrayAccess(..), Bytes)+import Data.ByteArray.Sized (SizedByteArray)+import Data.Kind (Constraint)+import GHC.TypeNats (KnownNat, Nat)++import Crypto.BLST.Internal.Bindings+import Crypto.BLST.Internal.Demote++-- | Curve data kind.+data Curve = G1 | G2++instance Demote 'G1 where demote = G1+instance Demote 'G2 where demote = G2++-- | Public key point type depending on the curve.+type CurveToPkPoint :: Curve -> PointKind+type family CurveToPkPoint c = r | r -> c where+  CurveToPkPoint 'G1 = 'P1+  CurveToPkPoint 'G2 = 'P2++-- | Message/signature point depending on the curve.+type CurveToMsgPoint :: Curve -> PointKind+type family CurveToMsgPoint c = r | r -> c where+  CurveToMsgPoint 'G1 = 'P2+  CurveToMsgPoint 'G2 = 'P1++-- | Size of serialized point.+type SerializedSize :: PointKind -> Nat+type family SerializedSize p = r | r -> p where+  SerializedSize 'P1 = P1SerializeSize+  SerializedSize 'P2 = P2SerializeSize++-- | Size of compressed serialized point.+type CompressedSize :: PointKind -> Nat+type family CompressedSize p = r | r -> p where+  CompressedSize 'P1 = P1CompressSize+  CompressedSize 'P2 = P2CompressSize++-- | Class for operations on curves.+type IsCurve :: Curve -> Constraint+class (IsPoint (CurveToMsgPoint c), IsPoint (CurveToPkPoint c)) => IsCurve c where+  skToPkPoint :: Scalar -> IO (Point (CurveToPkPoint c))+  signPk :: Point (CurveToMsgPoint c) -> Scalar -> IO (Point (CurveToMsgPoint c))+  coreVerifyPk+    :: (ByteArrayAccess ba, ByteArrayAccess ba2)+    => Affine (CurveToPkPoint c)+    -> Affine (CurveToMsgPoint c)+    -> EncodeMethod+    -> ba+    -> Maybe ba2+    -> IO BlstError+  pairingChkNAggrPk+    :: ByteArrayAccess ba+    => PairingCtx+    -> Affine (CurveToPkPoint c)+    -> Bool+    -> Maybe (Affine (CurveToMsgPoint c))+    -> Bool+    -> ba+    -> IO BlstError++instance IsCurve 'G1 where+  skToPkPoint = skToPkInG1+  signPk = signPkInG1+  coreVerifyPk = coreVerifyPkInG1+  pairingChkNAggrPk = pairingChkNAggrPkInG1++instance IsCurve 'G2 where+  skToPkPoint = skToPkInG2+  signPk = signPkInG2+  coreVerifyPk = coreVerifyPkInG2+  pairingChkNAggrPk = pairingChkNAggrPkInG2++-- | Class for operations on points.+type IsPoint :: PointKind -> Constraint+class (KnownNat (SerializedSize p), KnownNat (CompressedSize p)) => IsPoint p where+  toAffine :: Point p -> IO (Affine p)+  fromAffine :: Affine p -> IO (Point p)+  affSerialize :: Affine p -> IO (SizedByteArray (SerializedSize p) Bytes)+  affCompress :: Affine p -> IO (SizedByteArray (CompressedSize p) Bytes)+  uncompress+    :: ByteArrayAccess ba+    => SizedByteArray (CompressedSize p) ba+    -> IO (Either BlstError (Affine p))+  addOrDoubleAffine :: Point p -> Affine p -> IO (Point p)+  deserialize+    :: ByteArrayAccess ba+    => SizedByteArray (SerializedSize p) ba+    -> IO (Either BlstError (Affine p))++instance IsPoint 'P1 where+  toAffine = p1ToAffine+  fromAffine = p1FromAffine+  affSerialize = p1AffSerialize+  affCompress = p1AffCompress+  uncompress = p1Uncompress+  addOrDoubleAffine = p1AddOrDoubleAffine+  deserialize = p1Deserialize++instance IsPoint 'P2 where+  toAffine = p2ToAffine+  fromAffine = p2FromAffine+  affSerialize = p2AffSerialize+  affCompress = p2AffCompress+  uncompress = p2Uncompress+  addOrDoubleAffine = p2AddOrDoubleAffine+  deserialize = p2Deserialize++-- | Class for encoding/hashing to curve.+type ToCurve :: EncodeMethod -> Curve -> Constraint+class (IsCurve c, Demote meth) => ToCurve meth c where+  toCurve+    :: (ByteArrayAccess ba, ByteArrayAccess ba2)+    => ba -> Maybe ba2 -> IO (Point (CurveToMsgPoint c))++-- Note: it might seem this is backwards, but it's not.+instance ToCurve 'Encode 'G1 where toCurve = encodeToG2+instance ToCurve 'Encode 'G2 where toCurve = encodeToG1+instance ToCurve 'Hash 'G1 where toCurve = hashToG2+instance ToCurve 'Hash 'G2 where toCurve = hashToG1
+ src/Crypto/BLST/Internal/Demote.hs view
@@ -0,0 +1,17 @@+-- SPDX-FileCopyrightText: 2022 Serokell <https://serokell.io>+-- SPDX-License-Identifier: MPL-2.0++{-# OPTIONS_HADDOCK not-home #-}++-- | Utility class to demote promoted datatypes.+module Crypto.BLST.Internal.Demote+  ( module Crypto.BLST.Internal.Demote+  ) where++import Data.Kind (Constraint)++-- | Demotes a promoted data kind.+type Demote :: forall {k}. k -> Constraint+class Demote (x :: k) where+  -- | Returns a value corresponding to a promoted type.+  demote :: k
+ src/Crypto/BLST/Internal/Types.hs view
@@ -0,0 +1,54 @@+-- SPDX-FileCopyrightText: 2022 Serokell <https://serokell.io>+-- SPDX-License-Identifier: MPL-2.0++{-# OPTIONS_HADDOCK not-home #-}++-- | Types used for the high-level interface.+module Crypto.BLST.Internal.Types+  ( module Crypto.BLST.Internal.Types+  ) where++import Control.DeepSeq (NFData)+import Data.Kind (Type)+import Data.Proxy (Proxy(..))+import GHC.TypeLits (KnownNat, Nat, natVal)++import Crypto.BLST.Internal.Bindings.Types+import Crypto.BLST.Internal.Classy+  (CompressedSize, Curve, CurveToMsgPoint, CurveToPkPoint, SerializedSize)++-- | Data kind flag for 'ByteSize'.+data SerializeOrCompress = Serialize | Compress++type ByteSize :: SerializeOrCompress -> Type -> Nat+-- | Size in bytes of serialized/compressed representations of basic types.+type family ByteSize soc a++-- | Convenience function to get byte size as an 'Int' value.+byteSize :: forall soc a. KnownNat (ByteSize soc a) => Int+byteSize = fromIntegral $ natVal @(ByteSize soc a) Proxy++-- | Representation for the secret key.+newtype SecretKey = SecretKey Scalar+  deriving stock (Eq, Show)+  deriving newtype NFData++type instance ByteSize 'Serialize SecretKey = SkSerializeSize++-- | Public key representation.+type PublicKey :: Curve -> Type+newtype PublicKey c = PublicKey (Affine (CurveToPkPoint c))+  deriving stock (Eq, Show)+  deriving newtype NFData++type instance ByteSize 'Serialize (PublicKey c) = SerializedSize (CurveToPkPoint c)+type instance ByteSize 'Compress (PublicKey c) = CompressedSize (CurveToPkPoint c)++-- | Signature representation.+type Signature :: Curve -> EncodeMethod -> Type+newtype Signature c m = Signature (Affine (CurveToMsgPoint c))+  deriving stock (Eq, Show)+  deriving newtype NFData++type instance ByteSize 'Serialize (Signature c _) = SerializedSize (CurveToMsgPoint c)+type instance ByteSize 'Compress (Signature c _) = CompressedSize (CurveToMsgPoint c)
+ test/Main.hs view
@@ -0,0 +1,4 @@+-- SPDX-FileCopyrightText: 2022 Serokell <https://serokell.io>+-- SPDX-License-Identifier: MPL-2.0++{-# OPTIONS_GHC -F -pgmF tasty-discover #-}
+ test/Test/BLST.hs view
@@ -0,0 +1,118 @@+-- SPDX-FileCopyrightText: 2022 Serokell <https://serokell.io>+-- SPDX-License-Identifier: MPL-2.0++module Test.BLST+  ( test_highlevel+  ) where++import Data.ByteArray (Bytes, convert)+import Data.ByteArray.Sized qualified as AS+import Data.ByteString (ByteString)+import Data.List.NonEmpty (NonEmpty(..))+import Data.Proxy (Proxy(..))+import Test.Tasty (TestTree, testGroup)+import Test.Tasty.HUnit (assertBool, testCase, (@?=))++import Crypto.BLST++import Test.BLST.Fixtures+import Test.BLST.Util++test_highlevel :: TestTree+test_highlevel = testGroup "High-level interface"+  [ withAllOptions "sign and verify" $ \(_ :: Proxy '(c, m)) ->+      verify @c @m sig pk msg noDST @?= BlstSuccess+  , withAllOptions "sign and verify with DST" $ \(_ :: Proxy '(c, m)) ->+      verify @c @m sigDST pk msg myDST @?= BlstSuccess+  , testGroup "PK"+    [ testGroup "Serialize"+        [ testCase "G1" $ serializePk @'G1 pk @?= expectedSer1+        , testCase "G2" $ serializePk @'G2 pk @?= expectedSer2+        ]+    , testGroup "Deserialize"+        [ testCase "G1" $ deserializePk @'G1 expectedSer1 @?= Right pk+        , testCase "G2" $ deserializePk @'G2 expectedSer2 @?= Right pk+        ]+    , testGroup "Compress"+        [ testCase "G1" $ compressPk @'G1 pk @?= fromHex expectedComp1+        , testCase "G2" $ compressPk @'G2 pk @?= fromHex expectedComp2+        ]+    , testGroup "Decompress"+        [ testCase "G1" $ decompressPk @'G1 (fromHex expectedComp1) @?= Right pk+        , testCase "G2" $ decompressPk @'G2 (fromHex expectedComp2) @?= Right pk+        ]+    ]+  , testGroup "SK"+      [ testCase "Serialize" $+          serializeSk key @?= AS.convert (fromHex expectedSerKey)+      , testCase "Deserialize" $+          deserializeSk (fromHex expectedSerKey) @?= key+      ]+  , withAllOptions "Serialize-deserialize signature roundtrip" $ \(_ :: Proxy '(c, m)) ->+      sigRoundtrip @c @m sig @?= Right sig+  , withAllOptions "Compress-decompress signature roundtrip" $ \(_ :: Proxy '(c, m)) ->+      sigCompRoundtrip @c @m sig @?= Right sig+  , withAllOptions "DST affects signature" $ \(_ :: Proxy '(c, m)) ->+      assertBool "signatures match when DSTs differ" $+        sig @m @c /= sigDST+  , withAllOptions "Aggregate" $ testAgg noDST+  , withAllOptions "Aggregate with DST" $ testAgg myDST+  ]++testAgg :: forall c m. (ToCurve m c) => Maybe Bytes -> Proxy '(c, m) -> IO ()+testAgg dst _ = do+  let sk1 = keygen $+        AS.unsafeSizedByteArray @32 @ByteString "qqqqqqqqqqqqqqqqqqqqqqqqqqqqqqqq"+      sk2 = keygen $+        AS.unsafeSizedByteArray @32 @ByteString "wwwwwwwwwwwwwwwwwwwwwwwwwwwwwwww"+      (pk1, pk2) = (skToPk @c sk1, skToPk @c sk2)+      msg1 = "hello" :: ByteString+      msg2 = "world" :: ByteString+      sig1 = sign @c @m sk1 msg1 dst+      sig2 = sign @c @m sk2 msg2 dst+      sig3 = sign @c @m sk2 msg2 (Just ("xxx" :: ByteString))+      agg = aggregateSignatures (sig1 :| [sig2])+      agg' = aggregateSignatures (sig1 :| [sig2, sig3])+  aggregateVerify ((pk1, msg1) :| [(pk2, msg2)]) agg dst @?= Right True+  aggregateVerify ((pk1, msg1 <> "asd") :| [(pk2, msg2)]) agg dst @?= Right False+  aggregateVerify ((pk2, msg1) :| [(pk1, msg2)]) agg dst @?= Right False+  aggregateVerify ((pk1, msg1) :| [(pk2, msg2), (pk2, msg2)]) agg' dst @?= Right False++withAllOptions+  :: String+  -> (forall (c :: Curve) (m :: EncodeMethod). (ToCurve m c)+      => Proxy '(c, m) -> IO ())+  -> TestTree+withAllOptions name f = testGroup name+  [ testCase "G1 Hash"   $ f @'G1 @'Hash Proxy+  , testCase "G2 Hash"   $ f @'G2 @'Hash Proxy+  , testCase "G1 Encode" $ f @'G1 @'Encode Proxy+  , testCase "G2 Encode" $ f @'G2 @'Encode Proxy+  ]++sigRoundtrip+  :: IsCurve c+  => Signature c m+  -> Either BlstError (Signature c m)+sigRoundtrip = deserializeSignature . serializeSignature++sigCompRoundtrip+  :: IsCurve c+  => Signature c m+  -> Either BlstError (Signature c m)+sigCompRoundtrip = decompressSignature . compressSignature++key :: SecretKey+key = keygen $ AS.unsafeSizedByteArray @32 seed++pk :: IsCurve c => PublicKey c+pk = skToPk key++myDST :: Maybe Bytes+myDST = Just $ convert ("MY-DST" :: ByteString)++sig :: (ToCurve m c) => Signature c m+sig = sign key msg noDST++sigDST :: (ToCurve m c) => Signature c m+sigDST = sign key msg myDST
+ test/Test/BLST/Bindings.hs view
@@ -0,0 +1,181 @@+-- SPDX-FileCopyrightText: 2022 Serokell <https://serokell.io>+-- SPDX-License-Identifier: MPL-2.0++module Test.BLST.Bindings+  ( test_keygen+  , test_skToPkInG1+  , test_skToPkInG2+  , test_signPkInG1+  , test_signPkInG2+  , test_encodeToG1+  , test_hashToG1+  , test_encodeToG2+  , test_hashToG2+  , test_coreVerifyPkInG1+  , test_coreVerifyPkInG2+  , test_p1ToAffine+  , test_p2ToAffine+  , test_p1AffSerialize+  , test_p1Deserialize+  , test_p2AffSerialize+  , test_p2Deserialize+  , test_p1AffCompress+  , test_p1Uncompress+  , test_p2AffCompress+  , test_p2Uncompress+  , test_lendianFromScalar+  , test_scalarFromLendian+  ) where++import Data.ByteArray (Bytes)+import Test.Tasty (TestTree)+import Test.Tasty.HUnit (testCase, (@?=))++import Crypto.BLST.Internal.Bindings qualified as B++import Test.BLST.Fixtures+import Test.BLST.Util++noDST :: Maybe Bytes+noDST = Nothing++test_keygen :: TestTree+test_keygen = testCase "keygen" $ do+  key <- B.keygen seed+  key @?= expectedKey++test_skToPkInG1 :: TestTree+test_skToPkInG1 = testCase "skToPkInG1" $ do+  pk1 <- B.skToPkInG1 expectedKey+  pk1 @?= expectedPk1++test_skToPkInG2 :: TestTree+test_skToPkInG2 = testCase "skToPkInG2" $ do+  pk2 <- B.skToPkInG2 expectedKey+  pk2 @?= expectedPk2++test_signPkInG1 :: TestTree+test_signPkInG1 = testCase "signPkInG1" $ do+  x <- B.signPkInG1 expectedHash2 expectedKey+  x @?= expectedSignHash1+  y <- B.signPkInG1 expectedEnc2 expectedKey+  y @?= expectedSignEnc1++test_signPkInG2 :: TestTree+test_signPkInG2 = testCase "signPkInG2" $ do+  x <- B.signPkInG2 expectedHash1 expectedKey+  x @?= expectedSignHash2+  y <- B.signPkInG2 expectedEnc1 expectedKey+  y @?= expectedSignEnc2++test_encodeToG1 :: TestTree+test_encodeToG1 = testCase "encodeToG1" $ do+  x <- B.encodeToG1 msg noDST+  x @?= expectedEnc1++test_hashToG1 :: TestTree+test_hashToG1 = testCase "hashToG1" $ do+  x <- B.hashToG1 msg noDST+  x @?= expectedHash1++test_encodeToG2 :: TestTree+test_encodeToG2 = testCase "encodeToG2" $ do+  x <- B.encodeToG2 msg noDST+  x @?= expectedEnc2++test_hashToG2 :: TestTree+test_hashToG2 = testCase "hashToG2" $ do+  x <- B.hashToG2 msg noDST+  x @?= expectedHash2++test_coreVerifyPkInG1 :: TestTree+test_coreVerifyPkInG1 = testCase "coreVerifyPkInG1" $ do+  r1 <- B.coreVerifyPkInG1 expectedAffPk1 expectedAffSignHash1 B.Hash msg noDST+  r1 @?= B.BlstSuccess+  r2 <- B.coreVerifyPkInG1 expectedAffPk1 expectedAffSignEnc1 B.Encode msg noDST+  r2 @?= B.BlstSuccess+  -- failing cases+  r3 <- B.coreVerifyPkInG1 expectedAffPk1 expectedAffSignHash1 B.Encode msg noDST+  r3 @?= B.BlstVerifyFail+  r4 <- B.coreVerifyPkInG1 expectedAffPk1 expectedAffSignEnc1 B.Hash msg noDST+  r4 @?= B.BlstVerifyFail++test_coreVerifyPkInG2 :: TestTree+test_coreVerifyPkInG2 = testCase "coreVerifyPkInG2" $ do+  r1 <- B.coreVerifyPkInG2 expectedAffPk2 expectedAffSignHash2 B.Hash msg noDST+  r1 @?= B.BlstSuccess+  r2 <- B.coreVerifyPkInG2 expectedAffPk2 expectedAffSignEnc2 B.Encode msg noDST+  r2 @?= B.BlstSuccess+  -- failing cases+  r3 <- B.coreVerifyPkInG2 expectedAffPk2 expectedAffSignHash2 B.Encode msg noDST+  r3 @?= B.BlstVerifyFail+  r4 <- B.coreVerifyPkInG2 expectedAffPk2 expectedAffSignEnc2 B.Hash msg noDST+  r4 @?= B.BlstVerifyFail++test_p1ToAffine :: TestTree+test_p1ToAffine = testCase "p1ToAffine" $ do+  x <- B.p1ToAffine expectedPk1+  x @?= expectedAffPk1+  y <- B.p1ToAffine expectedSignEnc2+  y @?= expectedAffSignEnc2+  z <- B.p1ToAffine expectedSignHash2+  z @?= expectedAffSignHash2++test_p2ToAffine :: TestTree+test_p2ToAffine = testCase "p2ToAffine" $ do+  x <- B.p2ToAffine expectedPk2+  x @?= expectedAffPk2+  y <- B.p2ToAffine expectedSignEnc1+  y @?= expectedAffSignEnc1+  z <- B.p2ToAffine expectedSignHash1+  z @?= expectedAffSignHash1++test_p1AffSerialize :: TestTree+test_p1AffSerialize = testCase "p1AffSerialize" $ do+  x <- B.p1AffSerialize expectedAffPk1+  x @?= expectedSer1++test_p1Deserialize :: TestTree+test_p1Deserialize = testCase "p1Deserialize" $ do+  x <- B.p1Deserialize expectedSer1+  x @?= Right expectedAffPk1++test_p2AffSerialize :: TestTree+test_p2AffSerialize = testCase "p2AffSerialize" $ do+  x <- B.p2AffSerialize expectedAffPk2+  x @?= expectedSer2++test_p2Deserialize :: TestTree+test_p2Deserialize = testCase "p2Deserialize" $ do+  x <- B.p2Deserialize expectedSer2+  x @?= Right expectedAffPk2++test_p1AffCompress :: TestTree+test_p1AffCompress = testCase "p1AffCompress" $ do+  x <- B.p1AffCompress expectedAffPk1+  toHex x @?= expectedComp1++test_p1Uncompress :: TestTree+test_p1Uncompress = testCase "p1Uncompress" $ do+  x <- B.p1Uncompress $ fromHex expectedComp1+  x @?= Right expectedAffPk1++test_p2AffCompress :: TestTree+test_p2AffCompress = testCase "p2AffCompress" $ do+  x <- B.p2AffCompress expectedAffPk2+  toHex x @?= expectedComp2++test_p2Uncompress :: TestTree+test_p2Uncompress = testCase "p2Uncompress" $ do+  x <- B.p2Uncompress $ fromHex expectedComp2+  x @?= Right expectedAffPk2++test_lendianFromScalar :: TestTree+test_lendianFromScalar = testCase "lendianFromScalar" $ do+  x <- B.lendianFromScalar expectedKey+  toHex x @?= expectedSerKey++test_scalarFromLendian :: TestTree+test_scalarFromLendian = testCase "scalarFromLendian" $ do+  x <- B.scalarFromLendian $ fromHex expectedSerKey+  x @?= expectedKey
+ test/Test/BLST/Fixtures.hs view
@@ -0,0 +1,244 @@+-- SPDX-FileCopyrightText: 2022 Serokell <https://serokell.io>+-- SPDX-License-Identifier: MPL-2.0++{-# OPTIONS_GHC -Wwarn #-}++module Test.BLST.Fixtures+  ( seed+  , msg+  , expectedKey+  , expectedPk1+  , expectedPk2+  , expectedHash1+  , expectedHash2+  , expectedSignHash1+  , expectedSignHash2+  , expectedEnc1+  , expectedEnc2+  , expectedSignEnc1+  , expectedSignEnc2+  , expectedAffPk1+  , expectedAffPk2+  , expectedSer1+  , expectedSer2+  , expectedComp1+  , expectedComp2+  , expectedSerKey+  , expectedAffSignHash1+  , expectedAffSignHash2+  , expectedAffSignEnc1+  , expectedAffSignEnc2+  ) where++import Data.ByteArray (Bytes)+import Data.ByteArray.Sized (SizedByteArray)+import Data.ByteArray.Sized qualified as AS+import Data.ByteString (ByteString)+import Data.Text (Text)+import System.IO.Unsafe (unsafePerformIO)++import Crypto.BLST.Internal.Bindings qualified as B++import Test.BLST.Util++{-# ANN module ("HLint: ignore Missing NOINLINE pragma" :: Text) #-}++seed :: ByteString+seed = "asdfasdfasdfasdfasdfasdfasdfasdf"++msg :: ByteString+msg = "hello, world!"++expectedKey :: B.Scalar+expectedKey = unsafePerformIO $ B.scalarFromLendian $ fromHex expectedSerKey++expectedSerKey :: Text+expectedSerKey =+  "5ddb064f9378a723a172f364eaf8c069\+  \ef2ca9870c0928228c94c7a3adbdc20b"++expectedPk1 :: B.Point 'B.P1+expectedPk1 = deserializePoint+  "09afdbc09a9349f49da53fcf7ffc\+  \554394937510e14cbd6d330a02e8\+  \8d53b796c150abce2b953c3a7738\+  \86dae77dd867111a79f98c5102f2\+  \7993cc74875541c65bd9a220bc92\+  \b58bafb531e01deca18fcb5c8246\+  \1d8be54b6219d13e0aa96936"++expectedPk2 :: B.Point 'B.P2+expectedPk2 = deserializePoint' expectedSer2++-- NB: can't use serialized hash/enc because those roundtrip through affine+-- points loses information here.+expectedHash1 :: B.Point 'B.P1+expectedHash1 = B.Point $ AS.unsafeSizedByteArray $ fromHex'+  "3a69a985bb3c2c88c7c92141aaaba405\+  \ed352c7284c0108405b7977275595aba\+  \0d75772f5f4569a3a7aee43c1860770b\+  \8c2db24da8fe135325c0a3b77aec6e33\+  \dff54757f350c04af9057e4cb19424bf\+  \c1e6294cfa943925f6fe9607406ba705\+  \c5cdd8b0c4c9014695f13b4e2c6cc4ca\+  \e77b0f070a11a10840e373e97b17c79e\+  \68e0a9696907b5da815e6fc636065506"++expectedHash2 :: B.Point 'B.P2+expectedHash2 = B.Point $ AS.unsafeSizedByteArray $ fromHex'+  "818099f86b3d73fd53cd0768f379bb65\+  \0a4b4f2cee4dee97edd6b36834912877\+  \5bb1860418e0e8b10a82cb057142510f\+  \4240932247234c8e8c528ff1d2288471\+  \662f3b064b3cdb5b726bdc5c2fe3c10e\+  \b8d003ea272d2716c0f199b13fc4bb09\+  \29e7bbe9eec2ea0a7a3a678397c8e9af\+  \e9062296796065a9b673923e2a6b68fa\+  \97f1b29eaf17f3eb5728bb5fd24b6710\+  \66d10e7ff58b9355261d3bdf9c96ff63\+  \bc3c3d39b598e18ffe8d56cdf29cb61b\+  \f17f727f83f99a334f92bd2f03327114\+  \ef05a9368db5636a893a5878bfc30b08\+  \458b38c2cb6f2cda48c3ccb604c9740a\+  \4f9c644b437258bff2a45b323f4ba60d\+  \31e43c915daf976c5b24704b3f8d6dfc\+  \e336511e9a97ae32350ae5b9a32b2d1d\+  \8a594b22b1a31fd7795e510ef3fac908"++expectedEnc1 :: B.Point 'B.P1+expectedEnc1 = B.Point $ AS.unsafeSizedByteArray $ fromHex'+  "43bf72ddc6fb0b7b5cbafce921b11397\+  \3f3200ca0f81da5f8e2a7a3c8ac5b6d4\+  \f3b1a3ec20783c983b661b477e971512\+  \ed68359bef5ecc65a04c40ddb79da238\+  \d46753b3ceadab35f94c8cf38fe25f80\+  \e47fccbbe98ca3ccb6602df94c59d215\+  \c8b945158e6d7794fb628e7d8e307392\+  \bcc9f4f389c6011fb45b5ae4db11d4d5\+  \1b433e459a221ca6c4ff9a656a264a0b"++expectedEnc2 :: B.Point 'B.P2+expectedEnc2 = B.Point $ AS.unsafeSizedByteArray $ fromHex'+  "910646bb133d99d045bf023093b8b252\+  \1c5fa92d370cdeb4cbd7b5c0be024ae6\+  \263281bf060785e31ea85f6b86171818\+  \5728cd66f20930208d31008fbb45cbfb\+  \a74868b1703049031d8dcd474bc3a5de\+  \cf5825476d0fdd6c07b6ab530ce42903\+  \c147192266424eb261e78a4c16a15cfa\+  \0b17e0f13bf64b1a85fe804029a00ec2\+  \bbd34b335de66c5baa5cb077100fff04\+  \35ddc76afbae5cdc69421e5f98f1a6d8\+  \aa3a0e06ae3a8ae16dd3bee861605405\+  \244ac9c7da268c8d63cb1c0228390f15\+  \2f48f1cd1094323a44b6a246d30800a7\+  \cc5f480804b0e1ebf5169c6128e5d8b5\+  \4f429f7c4a354183cece49445564fc15\+  \b5c80f0a30fe9f5e8dacc392cca605c8\+  \63eaa48f433a68395e65e90c1da88d7f\+  \8f41f3c5e72795b65447f9735f6f0113"++expectedSignHash1 :: B.Point 'B.P2+expectedSignHash1 = deserializePoint+  "14369210233222d76103a4aa744a300f\+  \87dea5f5b8f1538415d85f477e4b004c\+  \c82569e620af5ce7d1532e465b9b1396\+  \06601565e7564a7c7013b71ce2cbdabc\+  \ea9db6c3244c6b33e6256f6c46f7257d\+  \561c88325a3c9cf725131f30d1c31b22\+  \124575a776f9704c20f2f35d695e51ec\+  \62afac092148a62bb5e0f058c0420b26\+  \1287c7edf2d3de8c492ce74c2e31bad7\+  \059dd86ac9796a69ddd1c9617cf61ba3\+  \b30e8bac3471bf3ae83b8085081f0ad5\+  \11157a6e89dcb890de3ce8a8c1348e09"++expectedAffSignHash1 :: B.Affine 'B.P2+expectedAffSignHash1 = unsafePerformIO $ B.p2ToAffine expectedSignHash1++expectedSignHash2 :: B.Point 'B.P1+expectedSignHash2 = deserializePoint+  "12c440df3381393ae09dd06a45c1b721\+  \816109f066b9669607b3f1c4febfd477\+  \01ea040e19e97ca9a70361ce25be3347\+  \126e269e38e6b485082c909b84ff191e\+  \861a2061441534429789e04b58303407\+  \5c68bc178f8ea96b2556ca1fb9611f93"++expectedAffSignHash2 :: B.Affine 'B.P1+expectedAffSignHash2 = unsafePerformIO $ B.p1ToAffine expectedSignHash2++expectedSignEnc1 :: B.Point 'B.P2+expectedSignEnc1 = deserializePoint+  "14093f93072f22ddf7957964786bf6ef\+  \0f27c8b0733f374f8ca29f7ca08eeb9e\+  \1aa893264553d970a7487688aad4aa67\+  \0d5e0d87267a63c9ce44340f625df5d6\+  \54d9a10eba66fd8e5d925fcc4bd37d81\+  \63b9e55142932bab720d23af46270c5f\+  \05880b4da102e19f7a4f8daf2e28d158\+  \ce36fb065bcf8bf5d76aef43a0a2163a\+  \e737192dbdced1e9afdadc5c933be231\+  \0507cf96ae04aa838384d612a9edbeb9\+  \ea336b737f20efdf4c7754ab9482064d\+  \b49d3e01d4953948cb4d8978defd0bcf"++expectedAffSignEnc1 :: B.Affine 'B.P2+expectedAffSignEnc1 = unsafePerformIO $ B.p2ToAffine expectedSignEnc1++expectedSignEnc2 :: B.Point 'B.P1+expectedSignEnc2 = deserializePoint+  "0ac71a17ad14546bbaa8f6689e5f4960\+  \7c377fa978cf92a37699dbdd680dcf77\+  \f85d8ba7f65639f74e1b2bba6d4af073\+  \115327fd424560691b171978fd436c55\+  \9597cced904e5b65e5e1a5e4b5497b90\+  \08dacc92a1e6d22ade43fdbddd487519"++expectedAffSignEnc2 :: B.Affine 'B.P1+expectedAffSignEnc2 = unsafePerformIO $ B.p1ToAffine expectedSignEnc2++expectedAffPk1 :: B.Affine 'B.P1+expectedAffPk1 = deserializeAffine' expectedSer1++expectedAffPk2 :: B.Affine 'B.P2+expectedAffPk2 = deserializeAffine' expectedSer2++expectedSer1 :: SizedByteArray B.P1SerializeSize Bytes+expectedSer1 = fromHex+  "09afdbc09a9349f49da53fcf7ffc5543\+  \94937510e14cbd6d330a02e88d53b796\+  \c150abce2b953c3a773886dae77dd867\+  \111a79f98c5102f27993cc74875541c6\+  \5bd9a220bc92b58bafb531e01deca18f\+  \cb5c82461d8be54b6219d13e0aa96936"++expectedSer2 :: SizedByteArray B.P2SerializeSize Bytes+expectedSer2 = fromHex+  "0fe7542b55fdf24f0a4fe2027f8f9c60\+  \74264eae84f83db8971d7ef8eb896406\+  \250e38be84b4443ab96a47c799261077\+  \080a849ce688e74b5c4cbd50b4f1cd66\+  \f4e41026813c7744f0e44a31876c2eca\+  \ef4550c78f829ededb3b14d870ac12e5\+  \0e8ab71a728201234283b5f1a01ebdfd\+  \54e2ceb7f3663a11c45f56badf624ad5\+  \01692a2bae776563eaa090aa45e00dfc\+  \0514c252a98b86e2f5054d597be4ef8c\+  \3697342dc336a5ffaba36da3e141972f\+  \8463cc9126d55bb7f18048569c9e6366"++expectedComp1 :: Text+expectedComp1 =+  "a9afdbc09a9349f49da53fcf7ffc5543\+  \94937510e14cbd6d330a02e88d53b796\+  \c150abce2b953c3a773886dae77dd867"++expectedComp2 :: Text+expectedComp2 =+  "afe7542b55fdf24f0a4fe2027f8f9c60\+  \74264eae84f83db8971d7ef8eb896406\+  \250e38be84b4443ab96a47c799261077\+  \080a849ce688e74b5c4cbd50b4f1cd66\+  \f4e41026813c7744f0e44a31876c2eca\+  \ef4550c78f829ededb3b14d870ac12e5"
+ test/Test/BLST/Tezos.hs view
@@ -0,0 +1,47 @@+-- SPDX-FileCopyrightText: 2022 Serokell <https://serokell.io>+-- SPDX-License-Identifier: MPL-2.0++-- | Test for interoperability with Tezos.+module Test.BLST.Tezos+  ( test_tezos+  ) where++import Data.ByteArray (convert)+import Data.ByteString (ByteString)+import Test.Tasty (TestTree)+import Test.Tasty.HUnit (testCase, (@?=))++import Crypto.BLST qualified as BLST++import Test.BLST.Util++test_tezos :: TestTree+test_tezos = testCase "Congruity with tezos" $ do+  let sk_ser =+        "79cc407e6917b5673a1f6966c23c9e15\+        \d257e5ab46cfe7b9b2f64200f2b2843e"+      pk_exp_ser =+        "b6cf94b6a59d102044d1ff16ebe3eccc\+        \5cd554965bb66ac80fb2728c18715817\+        \e185fb5ac9437908c9e609a742610177"+      signature =+        "8b7cd0689ad2eb42de97258d34db9eb3\+        \8585ec1b1f5be3c4ff580fb3147e33f6\+        \7246cf192b16ded6e9194720a11bf59d\+        \179cea087ef8c03c227ce10ce78bb1c7\+        \4c592e148d9ad0e1cf361b47e1235628\+        \fcf54ccbf6e8bda31f177107377dccda"+      sk = BLST.deserializeSk $ fromHex sk_ser+      pk = BLST.skToPk sk :: BLST.PublicKey 'BLST.G1+      pk_exp = BLST.decompressPk $ fromHex pk_exp_ser+      bytes = "\x12\x34\x56" :: ByteString+      sig = BLST.sign sk msg dst+      sig_ser :: BLST.Signature 'BLST.G1 'BLST.Hash =+        either (error "failed to decompress") id $ BLST.decompressSignature $ fromHex signature+      dst = Just ("BLS_SIG_BLS12381G2_XMD:SHA-256_SSWU_RO_AUG_" :: ByteString)+      msg = convert (BLST.compressPk pk) <> bytes+  Right pk @?= pk_exp+  toHex (BLST.compressPk pk) @?= pk_exp_ser+  toHex (BLST.serializeSk sk) @?= sk_ser+  BLST.verify sig_ser pk msg dst @?= BLST.BlstSuccess+  sig @?= sig_ser
+ test/Test/BLST/Util.hs view
@@ -0,0 +1,51 @@+-- SPDX-FileCopyrightText: 2022 Serokell <https://serokell.io>+-- SPDX-License-Identifier: MPL-2.0++{-# OPTIONS_GHC -Wwarn #-}++module Test.BLST.Util+  ( fromHex+  , toHex+  , deserializePoint+  , deserializePoint'+  , fromHex'+  , deserializeAffine'+  ) where++import Data.ByteArray (Bytes)+import Data.ByteArray qualified as BA+import Data.ByteArray.Sized (SizedByteArray)+import Data.ByteArray.Sized qualified as AS+import Data.Maybe (fromJust, fromMaybe)+import Data.Proxy (Proxy(..))+import Data.Text (Text, unpack)+import GHC.TypeNats (KnownNat, natVal)+import System.IO.Unsafe (unsafePerformIO)+import Text.Hex (decodeHex, encodeHex)++import Crypto.BLST.Internal.Bindings qualified as B+import Crypto.BLST.Internal.Classy qualified as C++fromHex :: forall n. (KnownNat n) => Text -> SizedByteArray n Bytes+fromHex arg = AS.convert+  . fromMaybe (error $ "Expected " <> show (natVal @n Proxy) <> " bytes got " <> unpack arg)+  . AS.sizedByteArray . fromJust . decodeHex+  $ arg++fromHex' :: BA.ByteArray a => Text -> a+fromHex' = BA.convert . fromJust . decodeHex++toHex :: BA.ByteArray a => SizedByteArray n a -> Text+toHex = encodeHex . BA.convert . AS.unSizedByteArray++deserializePoint :: C.IsPoint p => Text -> B.Point p+deserializePoint = unsafePerformIO . C.fromAffine . deserializeAffine++deserializePoint' :: C.IsPoint p => SizedByteArray (C.SerializedSize p) Bytes -> B.Point p+deserializePoint' = unsafePerformIO . C.fromAffine . deserializeAffine'++deserializeAffine :: C.IsPoint p => Text -> B.Affine p+deserializeAffine = deserializeAffine' . fromHex++deserializeAffine' :: C.IsPoint p => SizedByteArray (C.SerializedSize p) Bytes -> B.Affine p+deserializeAffine' = unsafePerformIO . fmap (either (error . show) id) . C.deserialize