PyNerva 0.0.7__py3-none-any.whl

pynerva-0.0.7.dist-info/METADATA

@@ -0,0 +1,310 @@
+Metadata-Version: 2.4
+Name: PyNerva
+Version: 0.0.7
+Summary: Framework for exploring advanced program synthesis and transformation techniques
+Project-URL: Homepage, https://github.com/kriskwiatkowski/NervaPy.git
+Author-email: Kris Kwiatkowski <kris@amongbytes.com>
+License-File: LICENSE.rst
+Keywords: arm,assembler,assembly,code transformation,codegen,elf,program synthesis,risc-v,x86-64
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: BSD License
+Classifier: Natural Language :: English
+Classifier: Operating System :: MacOS :: MacOS X
+Classifier: Operating System :: Microsoft :: Windows
+Classifier: Operating System :: OS Independent
+Classifier: Operating System :: POSIX :: BSD :: FreeBSD
+Classifier: Operating System :: POSIX :: Linux
+Classifier: Programming Language :: Assembly
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Software Development
+Classifier: Topic :: Software Development :: Assemblers
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: Software Development :: Libraries
+Requires-Python: >=3.10
+Requires-Dist: click>=8.1.8
+Requires-Dist: requests>=2.34.2
+Description-Content-Type: text/x-rst
+
+.. image:: https://github.com/kriskwiatkowski/NervaPy/blob/master/logo/nervapy.png
+  :alt: NervaPy logo
+  :align: center
+
+===========================================================================
+NervaPy
+===========================================================================
+
+NervaPy is a Python framework for writing high-performance assembly kernels.
+
+NervaPy aims to simplify writing optimized assembly kernels while preserving all optimization opportunities of traditional assembly. Some NervaPy features:
+
+- Universal assembly syntax for Windows, Unix, and Golang assembly.
+
+  * NervaPy can directly generate ELF, MS COFF and Mach-O object files and assembly listings for Golang toolchain
+
+- Automatic adaption of function to different calling conventions and ABIs.
+  
+  * Functions for different platforms can be generated from the same assembly source
+  * Supports Microsoft x64 ABI, System V x86-64 ABI (Linux, OS X, and FreeBSD), Linux x32 ABI, Native Client x86-64 SFI ABI, Golang AMD64 ABI, Golang AMD64p32 ABI
+      
+- Automatic register allocation.
+  
+  * NervaPy is flexible and lets mix auto-allocated and hardcoded registers in the same code.
+
+- Automation of routine tasks in assembly programming:
+
+  * Function prolog and epilog and generated by NervaPy
+  * De-duplication of data constants (e.g. `Constant.float32x4(1.0)`)
+  * Analysis of ISA extensions used in a function
+
+- Supports x86-64 instructions up to AVX-512 and SHA
+  
+  * Including 3dnow!+, XOP, FMA3, FMA4, TBM and BMI2.
+  * Excluding x87 FPU and most system instructions.
+
+- Auto-generation of metadata files
+
+  * Makefile with module dependencies (`-MMD` and `-MF` options)
+  * C header for the generated functions
+  * Function metadata in JSON format
+
+- Python-based metaprogramming and code-generation.
+- Multiplexing of multiple instruction streams (helpful for software pipelining).
+- Compatible with Python 2 and Python 3, CPython and PyPy.
+
+Installation
+------------
+
+NervaPy is actively developed, and thus there are presently no stable releases of 0.2 branch. We recommend that you use the `master` version:
+
+.. code-block:: bash
+
+  pip install --upgrade git+https://github.com/kriskwiatkowski/NervaPy
+
+Installation for development
+****************************
+
+If you plan to modify NervaPy, we recommend the following installation procedure:
+
+.. code-block:: bash
+
+  git clone https://github.com/kriskwiatkowski/NervaPy.git
+  cd NervaPy
+  python setup.py develop
+
+
+Using NervaPy as a command-line tool
+------------------------------------
+
+.. code-block:: python
+  
+  # These two lines are not needed for NervaPy, but will help you get autocompletion in good code editors
+  from nervapy import *
+  from nervapy.x86_64 import *
+
+  # Lets write a function float DotProduct(const float* x, const float* y)
+  
+  # If you want maximum cross-platform compatibility, arguments must have names
+  x = Argument(ptr(const_float_), name="x")
+  # If name is not specified, it is auto-detected
+  y = Argument(ptr(const_float_))
+
+  # Everything inside the `with` statement is function body
+  with Function("DotProduct", (x, y), float_,
+    # Enable instructions up to SSE4.2
+    # NervaPy will report error if you accidentally use a newer instruction
+    target=uarch.default + isa.sse4_2):
+  
+    # Request two 64-bit general-purpose registers. No need to specify exact names.
+    reg_x, reg_y = GeneralPurposeRegister64(), GeneralPurposeRegister64()
+
+    # This is a cross-platform way to load arguments. NervaPy will map it to something proper later.
+    LOAD.ARGUMENT(reg_x, x)
+    LOAD.ARGUMENT(reg_y, y)
+
+    # Also request a virtual 128-bit SIMD register...
+    xmm_x = XMMRegister()
+    # ...and fill it with data
+    MOVAPS(xmm_x, [reg_x])
+    # It is fine to mix virtual and physical (xmm0-xmm15) registers in the same code
+    MOVAPS(xmm2, [reg_y])
+
+    # Execute dot product instruction, put result into xmm_x
+    DPPS(xmm_x, xmm2, 0xF1)
+
+    # This is a cross-platform way to return results. NervaPy will take care of ABI specifics.
+    RETURN(xmm_x)
+
+Now you can compile this code into a binary object file that you can link into a program...
+
+.. code-block:: bash
+
+  # Use MS-COFF format with Microsoft ABI for Windows
+  python -m nervapy.x86_64 -mabi=ms -mimage-format=ms-coff -o example.obj example.py
+  # Use Mach-O format with SysV ABI for OS X
+  python -m nervapy.x86_64 -mabi=sysv -mimage-format=mach-o -o example.o example.py
+  # Use ELF format with SysV ABI for Linux x86-64
+  python -m nervapy.x86_64 -mabi=sysv -mimage-format=elf -o example.o example.py
+  # Use ELF format with x32 ABI for Linux x32 (x86-64 with 32-bit pointer)
+  python -m nervapy.x86_64 -mabi=x32 -mimage-format=elf -o example.o example.py
+  # Use ELF format with Native Client x86-64 ABI for Chromium x86-64
+  python -m nervapy.x86_64 -mabi=nacl -mimage-format=elf -o example.o example.py
+
+What else? You can convert the program to Plan 9 assembly for use with Go programming language:
+
+.. code-block:: bash
+
+  # Use Go ABI (asm version) with -S flag to generate assembly for Go x86-64 targets
+  python -m nervapy.x86_64 -mabi=goasm -S -o example_amd64.s example.py
+  # Use Go-p32 ABI (asm version) with -S flag to generate assembly for Go x86-64 targets with 32-bit pointers
+  python -m nervapy.x86_64 -mabi=goasm-p32 -S -o example_amd64p32.s example.py
+
+If Plan 9 assembly is too restrictive for your use-case, generate ``.syso`` objects `which can be linked into Go programs <https://github.com/golang/go/wiki/GcToolchainTricks#use-syso-file-to-embed-arbitrary-self-contained-c-code>`_:
+
+.. code-block:: bash
+
+  # Use Go ABI (syso version) to generate .syso objects for Go x86-64 targets
+  # Image format can be any (ELF/Mach-O/MS-COFF)
+  python -m nervapy.x86_64 -mabi=gosyso -mimage-format=elf -o example_amd64.syso example.py
+  # Use Go-p32 ABI (syso version) to generate .syso objects for Go x86-64 targets with 32-bit pointers
+  # Image format can be any (ELF/Mach-O/MS-COFF)
+  python -m nervapy.x86_64 -mabi=gosyso-p32 -mimage-format=elf -o example_amd64p32.syso example.py
+
+See `examples <https://github.com/kriskwiatkowski/NervaPy/tree/master/examples>`_ for real-world scenarios of using NervaPy with ``make``, ``nmake`` and ``go generate`` tools.
+
+Using NervaPy as a Python module
+--------------------------------
+
+When command-line tool does not provide sufficient flexibility, Python scripts can import NervaPy objects from ``nervapy`` and ``nervapy.x86_64`` modules and do arbitrary manipulations on output images, program structure, instructions, and bytecodes.
+
+NervaPy as Inline Assembler for Python
+**************************************
+
+NervaPy links assembly and Python: it represents assembly instructions and syntax as Python classes, functions, and objects.
+But it also works the other way around: NervaPy can represent your assembly functions as callable Python functions!
+
+.. code-block:: python
+
+  from nervapy import *
+  from nervapy.x86_64 import *
+
+  x = Argument(int32_t)
+  y = Argument(int32_t)
+
+  with Function("Add", (x, y), int32_t) as asm_function:
+      reg_x = GeneralPurposeRegister32()
+      reg_y = GeneralPurposeRegister32()
+
+      LOAD.ARGUMENT(reg_x, x)
+      LOAD.ARGUMENT(reg_y, y)
+
+      ADD(reg_x, reg_y)
+
+      RETURN(reg_x)
+
+  python_function = asm_function.finalize(abi.detect()).encode().load()
+
+  print(python_function(2, 2)) # -> prints "4"
+
+NervaPy as Instruction Encoder
+******************************
+
+NervaPy can be used to explore instruction length, opcodes, and alternative encodings:
+
+.. code-block:: python
+
+  from nervapy.x86_64 import *
+
+  ADD(eax, 5).encode() # -> bytearray(b'\x83\xc0\x05')
+
+  MOVAPS(xmm0, xmm1).encode_options() # -> [bytearray(b'\x0f(\xc1'), bytearray(b'\x0f)\xc8')]
+  
+  VPSLLVD(ymm0, ymm1, [rsi + 8]).encode_length_options() # -> {6: bytearray(b'\xc4\xe2uGF\x08'),
+                                                         #     7: bytearray(b'\xc4\xe2uGD&\x08'),
+                                                         #     9: bytearray(b'\xc4\xe2uG\x86\x08\x00\x00\x00')}
+
+Tutorials
+---------
+
+- `Writing Go assembly functions with NervaPy <https://blog.gopheracademy.com/advent-2016/nervapy/>`_ by `Damian Gryski <https://github.com/dgryski>`_
+
+- `Adventures in JIT compilation (Part 4) <http://eli.thegreenplace.net/2017/adventures-in-jit-compilation-part-4-in-python/>`_ by `Eli Bendersky <https://github.com/eliben>`_
+
+Users
+-----
+
+- `NNPACK <https://github.com/kriskwiatkowski/NNPACK>`_ -- an acceleration layer for convolutional networks on multi-core CPUs.
+
+- `ChaCha20 <https://git.schwanenlied.me/yawning/chacha20>`_ -- Go implementation of ChaCha20 cryptographic cipher.
+
+- `AEZ <https://git.schwanenlied.me/yawning/aez>`_ -- Go implementation of AEZ authenticated-encryption scheme.
+
+- `bp128 <https://github.com/robskie/bp128>`_ -- Go implementation of SIMD-BP128 integer encoding and decoding.
+
+- `go-marvin32 <https://github.com/dgryski/go-marvin32>`_ -- Go implementation of Microsoft's Marvin32 hash function.
+
+- `go-highway <https://github.com/dgryski/go-highway>`_ -- Go implementation of Google's Highway hash function.
+
+- `go-metro <https://github.com/dgryski/go-metro>`_ -- Go implementation of MetroHash function.
+
+- `go-stadtx <https://github.com/dgryski/go-stadtx>`_ -- Go implementation of Stadtx hash function.
+
+- `go-sip13 <https://github.com/dgryski/go-sip13>`_ -- Go implementation of SipHash 1-3 function.
+
+- `go-chaskey <https://github.com/dgryski/go-chaskey>`_ -- Go implementation of Chaskey MAC.
+
+- `go-speck <https://github.com/dgryski/go-speck>`_ -- Go implementation of SPECK cipher.
+
+- `go-bloomindex <https://github.com/dgryski/go-bloomindex>`_ - Go implementation of Bloom-filter based search index.
+
+- `go-groupvariant <https://github.com/dgryski/go-groupvarint>`_ - SSE-optimized group varint integer encoding in Go.
+
+- `Yeppp! <http://www.yeppp.info>`_ performance library. All optimized kernels in Yeppp! are implemented in NervaPy (uses old version of NervaPy with deprecated syntax).
+
+Peer-Reviewed Publications
+--------------------------
+
+- Marat Dukhan "NervaPy: A Python Framework for Developing High-Performance Assembly Kernels", Python for High-Performance Computing (PyHPC) 2013 (`slides <http://www.yeppp.info/resources/nervapy-slides.pdf>`_, `paper <http://www.yeppp.info/resources/nervapy-paper.pdf>`_, code uses deprecated syntax)
+
+- Marat Dukhan "NervaPy meets Opcodes: Direct Machine Code Generation from Python", Python for High-Performance Computing (PyHPC) 2015 (`slides <http://www.nervapy.io/slides/pyhpc2015>`_, `paper on ACM Digital Library <https://dl.acm.org/citation.cfm?id=2835860>`_).
+
+Other Presentations
+-------------------
+
+- Marat Dukhan "Developing Low-Level Assembly Kernels in NervaPy", presentation on `The First BLIS Retreat Workshop <https://www.cs.utexas.edu/users/flame/BLISRetreat/>`_, 2013 (`slides <https://www.cs.utexas.edu/users/flame/BLISRetreat/BLISRetreatTalks/NervaPy.pdf>`_, code uses deprecated syntax)
+
+- Marat Dukhan "Porting BLIS micro-kernels to NervaPy", presentation on `The Third BLIS Retreat Workshop <https://www.cs.utexas.edu/users/flame/BLISRetreat2015/>`_, 2015 (`slides <http://www.nervapy.io/slides/blis-retreat-2015/>`_)
+
+- Marat Dukhan "Accelerating Data Processing in Go with SIMD Instructions", presentation on `Atlanta Go Meetup <http://www.meetup.com/Go-Users-Group-Atlanta>`_, September 16, 2015 (`slides <https://docs.google.com/presentation/d/1MYg8PyhEf0oIvZ9YU2panNkVXsKt5UQBl_vGEaCeB1k/edit?usp=sharing>`_)
+
+Dependencies
+------------
+
+- Nearly all instruction classes in NervaPy are generated from `Opcodes Database <https://github.com/kriskwiatkowski/Opcodes>`_
+
+- Instruction encodings in NervaPy are validated against `binutils <https://www.gnu.org/software/binutils/>`_ using auto-generated tests
+
+- NervaPy uses `six <https://pythonhosted.org/six/>`_ and `enum34 <https://pypi.python.org/pypi/enum34>`_ packages as a compatibility layer between Python 2 and Python 3
+
+Acknowledgements
+----------------
+
+.. image:: https://github.com/kriskwiatkowski/NervaPy/blob/master/logo/hpcgarage.png
+  :alt: HPC Garage logo
+  :target: http://hpcgarage.org/
+
+.. image:: https://github.com/kriskwiatkowski/NervaPy/blob/master/logo/college-of-computing.gif
+  :alt: Georgia Tech College of Computing logo
+  :target: http://www.cse.gatech.edu/
+
+This work is a research project at the HPC Garage lab in the Georgia Institute of Technology, College of Computing, School of Computational Science and Engineering.
+
+The work was supported in part by grants to Prof. Richard Vuduc's research lab, `The HPC Garage <www.hpcgarage.org>`_, from the National Science Foundation (NSF) under NSF CAREER award number 0953100; and a grant from the Defense Advanced Research Projects Agency (DARPA) Computer Science Study Group program
+
+Any opinions, conclusions or recommendations expressed in this software and documentation are those of the authors and not necessarily reflect those of NSF or DARPA.

pynerva-0.0.7.dist-info/RECORD

@@ -0,0 +1,74 @@
+nervapy/__init__.py,sha256=tde830ThHBm4Dh262lEp5BzpcNBUN0lf6sxSqB4ElkU,2495
+nervapy/abi.py,sha256=lrVAZzaYj_MD_PImgajXwxicruRcBltXo-WqpNO3Lg8,2598
+nervapy/arm.py,sha256=tuwlnsdw1c67PN_8_QiVC26Upt2GqcAijizAxZRT8tg,342
+nervapy/codegen.py,sha256=tr7bjhZrPk6Lq1per-FvhaKhSXgyAF0NI-7xktmZvMk,3230
+nervapy/constant_data.py,sha256=Rd1z07zMxZffDitRBa-_3N3UnKkO9iewzejN1IzuiMQ,10288
+nervapy/encoder.py,sha256=bUF4gViaOBaB3n5t1ULdAD4XSIyDn0V2bDn6CyqHIGE,8784
+nervapy/function.py,sha256=fobi1_gVHzTQjy8N9pUJRnePmqAurA1GtBdpxffTSA8,4249
+nervapy/literal.py,sha256=36rA0FsA3lRTLiKOEkcNbmNKob6OX86_hubKUI160R4,21587
+nervapy/loader.py,sha256=5VU7fzPNHyCbrQOPYi_HX-u0LTffGCG8fDrydEC-Etw,6927
+nervapy/name.py,sha256=kQKMS-UHpySJv-TkGcbZixxIhZrZsGe-dg9LLnZqPS0,6144
+nervapy/parse.py,sha256=M60cyXn1vnmUqYtK-K_bz3wWlTSWpMmbma1cNAcLu-8,2505
+nervapy/stream.py,sha256=eO7iAdiEAgxShhm1AQjMCUPCxci6xj0eH6IMVcbZK9U,1568
+nervapy/util.py,sha256=cNQo35reLk-LQM5KUj2LbT_N2isBHhlpMo4cNvbDiTc,2532
+nervapy/writer.py,sha256=6YSqBKKb7PnY-Bb-5j7gDquJQj3G3nk2Xh2k1fCBkWs,19309
+nervapy/arm/__init__.py,sha256=7PhXycCG-FlCDi7Sbp_YBEgVM1w4UCdZrPS3nZYpB7w,8986
+nervapy/arm/__main__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+nervapy/arm/abi.py,sha256=Z_w-mNHc6bzwnYev20Xr2T8bmOb0nTSef1Z-rsEPhXA,2672
+nervapy/arm/formats.py,sha256=sGRXLw1_j5rZk-X_xFp3oZK1sSPFpTZP7ZMeq3mLBK4,1594
+nervapy/arm/function.py,sha256=gN-pwOs_Bl0MwEwdp6FaGyycxt4QAb1z2lFJuKcMlA4,115820
+nervapy/arm/generic.py,sha256=WRKwy5NPgKSA_HwSEi8CbEw4u9LTSR3aFhpETq9EkQo,354086
+nervapy/arm/instructions.py,sha256=wP9cb_jN5bN46ST6YBpzctBm6Z1Y8umMjUnlQqZKl7A,19280
+nervapy/arm/isa.py,sha256=T2zJ7uU0nL8rZgrtfxqXrTs9AE2PZ3ZG3nAoCKuzBfA,12005
+nervapy/arm/literal_pool.py,sha256=mraQJCuD-dqyzPw54UG97laMXA8MwAPw7jVLGLGayRg,11250
+nervapy/arm/microarchitecture.py,sha256=lYXLvQImSzT3SdvyMP4t6oSavG0feHuIiA-s__x11do,6126
+nervapy/arm/pseudo.py,sha256=5HkaJD2xD0ZJVkcpH2NOcTZjRESqsmIPWxL2fqF2wFs,24483
+nervapy/arm/registers.py,sha256=DR4FsoFxiaooS7t-wtFmhVfwxb7v3rD6gaUtAqCaK0s,41860
+nervapy/arm/vfpneon.py,sha256=5CSmJ1bap19oezByzkHtQLOc-Q9SRWmNT49n5nlRHqg,135660
+nervapy/c/__init__.py,sha256=YlL7lK71J-1xWKZH46hjVEUOh-oqHNxPhrjDTk29jYs,21
+nervapy/c/types.py,sha256=SgimoeML9B_rbkCOhmscHi2tbTofZnC-ogjhJtEsl6o,15919
+nervapy/common/__init__.py,sha256=nVWt0v5ae2CsguOHnkFvGmkSOyOSVWRjIaMQxboxwgs,199
+nervapy/common/function.py,sha256=tJJZFdPcSc-0Gg9t74wEMLfbK0YPEcmCeTPxAB5Is1o,169
+nervapy/common/regalloc.py,sha256=hJHaXO_rJmhQUVy1Yf4y96pzLszHyajOso3Hk2GtqSg,5079
+nervapy/formats/__init__.py,sha256=zx99Xv4dN4bpv160kqn9ATdAlIWhqYnEgXthTjqKIWE,144
+nervapy/formats/elf/__init__.py,sha256=u1qGwYM9ZnQHBm0-MBGY6w4curJqsxzyyXjt-2JcM10,210
+nervapy/formats/elf/file.py,sha256=6imXblDIPag5Lfht5kxjq3RrZnNFTiaVK1LcNzoVqZQ,5337
+nervapy/formats/elf/image.py,sha256=Ig-PH65BvAiwRr3RecQLY0_0UkLM8tqveDLHjqYZRw4,4146
+nervapy/formats/elf/section.py,sha256=GxupTeTat7W1iqNfLANuliSfMIy7451grpMZKipVkDw,13695
+nervapy/formats/elf/symbol.py,sha256=uCQj3wVnppEiPcRMZU0xQdttCyhSwm8uXKChbnhjtN0,7252
+nervapy/formats/macho/__init__.py,sha256=zx99Xv4dN4bpv160kqn9ATdAlIWhqYnEgXthTjqKIWE,144
+nervapy/formats/macho/file.py,sha256=T-01LCknoK6OdKmDhWxzJ-ZOUHhs2EIo7LA_mWOz6NU,3012
+nervapy/formats/macho/image.py,sha256=MuWoc72J30VyoFr9ZWoQcjDPDXY6CqQuZJF_X0UZdgc,5121
+nervapy/formats/macho/section.py,sha256=Ya9rPyHtXY30w41HNf-97FSZPZbGfrhn0Ns_bZH-vh8,10120
+nervapy/formats/macho/symbol.py,sha256=RL6VNX4WVvMA25HvQct0Ui1TT4pcguGO8Hy4m8rq0GY,4696
+nervapy/formats/mscoff/__init__.py,sha256=-yTAgrci_L2ABjnHePAMb9KAQLbCPH1apLhixNVV8go,484
+nervapy/formats/mscoff/image.py,sha256=6dxUYYmHeGwDdkMAHa0P0Xv9zFzDsnMluYdTq_qVK2E,4091
+nervapy/formats/mscoff/section.py,sha256=Mjf2TxkuJ_UY9dYs0v-Kmt273p5Qsr_G2Rc0eLvtVF0,5674
+nervapy/formats/mscoff/symbol.py,sha256=mfzmOuxM6Zogl-YsJG7ocCGmvG3B0uRzfqEhWev0ozo,4844
+nervapy/x86_64/__init__.py,sha256=gzgS2YqHP3Ai3Sm8W3_R8xQ4nqwxo3pO_OjklEVTnoU,23997
+nervapy/x86_64/__main__.py,sha256=TQnPqtKpNIum8cm03B_TN9teyw_C3wIfG0k1YJGx2AY,13166
+nervapy/x86_64/abi.py,sha256=4qw7T8JDUcup_ptLZxdu7GcUtuK4P-ZJHP8u-lu-xwE,10286
+nervapy/x86_64/amd.py,sha256=kE-d5SInOm56PikR4fXB38LswA6fr80-uXj2LWP04aw,239567
+nervapy/x86_64/avx.py,sha256=eVl0OWxVtqNMFNSixKVkviYXI7lWTzB0LCYqOQXMNX0,3928949
+nervapy/x86_64/crypto.py,sha256=rP_qVj4EG5SIbNi9fdyD_CEcQm9BKIlgrWUPJeubnjs,56630
+nervapy/x86_64/encoding.py,sha256=ojLQgVNmzjspBV0SzREWWi5naTKrqz_EKcwsVj5F_mM,15830
+nervapy/x86_64/fma.py,sha256=pYTIX7rUDclUlk-BqVmzol_oEeLNNSV2ag0Zkgfa844,766882
+nervapy/x86_64/function.py,sha256=ZwmA6L-E_5xAAtp0sJdmw0nGGnTqYM2-98Pq0bkQyOs,119998
+nervapy/x86_64/generic.py,sha256=lvgb_5oPRJoRdjNHZ0J3D7OskGJPoQuDc3k_B_1fFCA,885368
+nervapy/x86_64/instructions.py,sha256=GT4dXroRLRHqztW0xblH87vco7uzVP9eYAkjllOXCMg,21009
+nervapy/x86_64/isa.py,sha256=lSUGcEcBvpgVPhcqZzqyzRte-esRUrQkncWLH1ycHfA,13866
+nervapy/x86_64/lower.py,sha256=5PzYzAVowFUYbByVpQW5DOMldtdhkNTYCokYNJmbrR8,6138
+nervapy/x86_64/mask.py,sha256=qEI-syVkJjo71aMzUj4zahkFCexiCz9d46fv9kJhOXE,95295
+nervapy/x86_64/meta.py,sha256=jYCHJhEgX_DmXQfMvAZUtc-tKmGWxq47dIj1F4T7Al4,4710
+nervapy/x86_64/mmxsse.py,sha256=AQppVEP7N6SZNyldG4QtoxP8fPC9Qn0I7JFaEvDSbFw,671134
+nervapy/x86_64/nacl.py,sha256=5SLYdpU2mnPJ8uwJKi1jw3X4fNlP34S1-Q0CPhtJwfk,10423
+nervapy/x86_64/operand.py,sha256=Cjv0Q_XxkKkPTP9RZyPoY1jxh9tfO9PPodYEh1nz31g,36154
+nervapy/x86_64/options.py,sha256=fJpjkhrNa85CqIxYQHEYe4zt0cVgpBzgB_2ozVbxHik,491
+nervapy/x86_64/pseudo.py,sha256=rVWrAQ7AXjKEA7-AR5amOVNcIUHuaXk89Uz56F3PmdA,28436
+nervapy/x86_64/registers.py,sha256=k5Rgnf0ywjizP9zUaWzWWVrnZs0gPGYXfzY0pTFbevE,36174
+nervapy/x86_64/types.py,sha256=AB3tFsIfzlToonoXftKTpIxV8tOGLVVIQaqNU8pvwNY,1011
+nervapy/x86_64/uarch.py,sha256=S5tzeXtMRpVrWNgVrnnc64_AmbPg-brUShrbW2EdpqU,11591
+pynerva-0.0.7.dist-info/METADATA,sha256=7AiMcKYna5PK95iM5boIZYmLimnYrPsIyW9MM5qpiO0,14548
+pynerva-0.0.7.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+pynerva-0.0.7.dist-info/licenses/LICENSE.rst,sha256=5tb9v8CcnMG_xVlGypaQ3ZJ23urtK3Ksf8XHm96A_zI,1443
+pynerva-0.0.7.dist-info/RECORD,,

pynerva-0.0.7.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

pynerva-0.0.7.dist-info/licenses/LICENSE.rst

@@ -0,0 +1,15 @@
+==============================
+PeachPy license (2-clause BSD)
+==============================
+
+Copyright (c) 2017, Facebook Inc.
+Copyright (c) 2013-2017, Georgia Institute of Technology
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice, this list of conditions and the following disclaimer in the documentation and/or other materials provided with the distribution.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.