Add files using upload-large-folder tool

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython-3.0.11.dist-info/COPYING.txt

@@ -0,0 +1,19 @@
+The original Pyrex code as of 2006-04 is licensed under the following
+license: "Copyright stuff: Pyrex is free of restrictions. You may use,
+redistribute, modify and distribute modified versions."
+
+------------------
+
+Cython, which derives from Pyrex, is licensed under the Apache 2.0
+Software License.  More precisely, all modifications and new code
+made to go from Pyrex to Cython are so licensed.
+
+See LICENSE.txt for more details.
+
+------------------
+
+The output of a Cython compilation is NOT considered a derivative
+work of Cython.  Specifically, though the compilation process may
+embed snippets of varying lengths into the final output, these
+snippets, as embedded in the output, do not encumber the resulting
+output with any license restrictions.

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython-3.0.11.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython-3.0.11.dist-info/LICENSE.txt

@@ -0,0 +1,176 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        https://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

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython-3.0.11.dist-info/METADATA

@@ -0,0 +1,63 @@
+Metadata-Version: 2.1
+Name: Cython
+Version: 3.0.11
+Summary: The Cython compiler for writing C extensions in the Python language.
+Home-page: https://cython.org/
+Author: Robert Bradshaw, Stefan Behnel, Dag Seljebotn, Greg Ewing, et al.
+Author-email: cython-devel@python.org
+License: Apache-2.0
+Project-URL: Documentation, https://cython.readthedocs.io/
+Project-URL: Donate, https://cython.readthedocs.io/en/latest/src/donating.html
+Project-URL: Source Code, https://github.com/cython/cython
+Project-URL: Bug Tracker, https://github.com/cython/cython/issues
+Project-URL: User Group, https://groups.google.com/g/cython-users
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Apache Software License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 2
+Classifier: Programming Language :: Python :: 2.7
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.4
+Classifier: Programming Language :: Python :: 3.5
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: Implementation :: CPython
+Classifier: Programming Language :: Python :: Implementation :: PyPy
+Classifier: Programming Language :: C
+Classifier: Programming Language :: Cython
+Classifier: Topic :: Software Development :: Code Generators
+Classifier: Topic :: Software Development :: Compilers
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Requires-Python: >=2.7, !=3.0.*, !=3.1.*, !=3.2.*, !=3.3.*
+License-File: LICENSE.txt
+License-File: COPYING.txt
+
+The Cython language makes writing C extensions for the Python language as
+easy as Python itself.  Cython is a source code translator based on Pyrex_,
+but supports more cutting edge functionality and optimizations.
+
+The Cython language is a superset of the Python language (almost all Python
+code is also valid Cython code), but Cython additionally supports optional
+static typing to natively call C functions, operate with C++ classes and
+declare fast C types on variables and class attributes.  This allows the
+compiler to generate very efficient C code from Cython code.
+
+This makes Cython the ideal language for writing glue code for external
+C/C++ libraries, and for fast C modules that speed up the execution of
+Python code.
+
+Note that for one-time builds, e.g. for CI/testing, on platforms that are not
+covered by one of the wheel packages provided on PyPI *and* the pure Python wheel
+that we provide is not used, it is substantially faster than a full source build
+to install an uncompiled (slower) version of Cython with::
+
+    pip install Cython --install-option="--no-cython-compile"
+
+.. _Pyrex: https://www.cosc.canterbury.ac.nz/greg.ewing/python/Pyrex/

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython-3.0.11.dist-info/RECORD

@@ -0,0 +1,448 @@
+../../../bin/cygdb,sha256=g-Go7XeWUFVdXEPEVDQHGpqa23ppoRMJpqF-QoAlzk4,269
+../../../bin/cython,sha256=XT1SfQF1nJkmzeNpBoKzlWDn9N67r3T8Y5RQb0QXPoE,290
+../../../bin/cythonize,sha256=TjNjnx44QGxed0b6m9mQFpomjDUebKiFMjap51LAfU4,270
+Cython-3.0.11.dist-info/COPYING.txt,sha256=4escSahQjoFz2sMBV-SmQ5pErYhGGUdGxCT7w_wrldc,756
+Cython-3.0.11.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+Cython-3.0.11.dist-info/LICENSE.txt,sha256=lWiisVXmasPguh_YC1K4J7lGDmz28jMSXny8qOIG3cM,10174
+Cython-3.0.11.dist-info/METADATA,sha256=Olx-spBXM1wCz95fdBSflhN68RCfBJpc64eq2YTsU4M,3161
+Cython-3.0.11.dist-info/RECORD,,
+Cython-3.0.11.dist-info/REQUESTED,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+Cython-3.0.11.dist-info/WHEEL,sha256=5Y454O0emXuKMOybDQevJmMdyxBqrxVayhyCIJ_fxN0,151
+Cython-3.0.11.dist-info/entry_points.txt,sha256=VU8NX8gnQyFbyqiWMzfh9BHvYMuoQRS3Nbm3kKcKQeY,139
+Cython-3.0.11.dist-info/top_level.txt,sha256=jLV8tZV98iCbIfiJR4DVzTX5Ru1Y_pYMZ59wkMCe6SY,24
+Cython/Build/BuildExecutable.py,sha256=jl36W_HYIHVuVUtN6iBnDBKA4oZsT1Z3bYx1AR9G8Ys,4789
+Cython/Build/Cythonize.py,sha256=HYib-gx-ARKQc5p-GNOwVzYF0TzUEbzvl0sS-nOGyoI,9830
+Cython/Build/Dependencies.py,sha256=B4aRLzFxuc7kUtRUcmAxVQh4s9LRGZpVUyOGEYdnPq4,52930
+Cython/Build/Distutils.py,sha256=iO5tPX84Kc-ZWMocfuQbl_PqyC9HGGIRS-NiKI60-ZE,49
+Cython/Build/Inline.py,sha256=E4IRWhPzRuoaYF0hbAxBLLP5j2aUXWhHZo5JL8uKC2k,13387
+Cython/Build/IpythonMagic.py,sha256=D8BRzCzPt5Dji7PqTdZEU9NVxmAo65COaCLE5wLwn8c,21966
+Cython/Build/Tests/TestCyCache.py,sha256=4p0k5OfCdWCUVzp_-iVyYTYB9ey6mlKF92WxEehj0ZM,4467
+Cython/Build/Tests/TestCythonizeArgsParser.py,sha256=_ijPP5tDvaeiUtuxUawlOZ8P4dcnkOOUJoze2OAbW4A,20346
+Cython/Build/Tests/TestDependencies.py,sha256=Bt7ERe6WQoZaVjYDZGPuNzYZyv5dEIbtj59-9AK_AlY,5835
+Cython/Build/Tests/TestInline.py,sha256=Ct_KmRN-hhdrx91xB_RILcjaPA4_bxZiCD-8F8NXiUo,3487
+Cython/Build/Tests/TestIpythonMagic.py,sha256=uQECO6yjMmcqLbx5fQ17TP0QJdOvc2hgAuLqFWWeKTw,9411
+Cython/Build/Tests/TestRecythonize.py,sha256=6un9tt8-I1YiFJo9xXRWqe0aUndMfHwrwA0h81Emhwc,6276
+Cython/Build/Tests/TestStripLiterals.py,sha256=D6F9NRbQXO7bHdqugpUnJF8iSjqs8xW_99ViP9ouhzc,1549
+Cython/Build/Tests/__init__.py,sha256=jOqtmPLCvMCq0xVMwGekuLpBmVgq0xtPFmUePySdOjs,13
+Cython/Build/Tests/__pycache__/TestCyCache.cpython-311.pyc,,
+Cython/Build/Tests/__pycache__/TestCythonizeArgsParser.cpython-311.pyc,,
+Cython/Build/Tests/__pycache__/TestDependencies.cpython-311.pyc,,
+Cython/Build/Tests/__pycache__/TestInline.cpython-311.pyc,,
+Cython/Build/Tests/__pycache__/TestIpythonMagic.cpython-311.pyc,,
+Cython/Build/Tests/__pycache__/TestRecythonize.cpython-311.pyc,,
+Cython/Build/Tests/__pycache__/TestStripLiterals.cpython-311.pyc,,
+Cython/Build/Tests/__pycache__/__init__.cpython-311.pyc,,
+Cython/Build/__init__.py,sha256=cxv1BKTFfuE10D5-MObSiFogR4dUpaQYFz-CLaHj9KU,401
+Cython/Build/__pycache__/BuildExecutable.cpython-311.pyc,,
+Cython/Build/__pycache__/Cythonize.cpython-311.pyc,,
+Cython/Build/__pycache__/Dependencies.cpython-311.pyc,,
+Cython/Build/__pycache__/Distutils.cpython-311.pyc,,
+Cython/Build/__pycache__/Inline.cpython-311.pyc,,
+Cython/Build/__pycache__/IpythonMagic.cpython-311.pyc,,
+Cython/Build/__pycache__/__init__.cpython-311.pyc,,
+Cython/CodeWriter.py,sha256=Yy4_ZSzZgnZ9_FmawxqBKd4frnshp1b7GupWuU6iKl0,24546
+Cython/Compiler/AnalysedTreeTransforms.py,sha256=LuwGJWnk-scpz_9TnKw1Lq0j4yNf5vCGO_NQ-GGupas,3834
+Cython/Compiler/Annotate.py,sha256=pYe_z56bqtzhSx3hvLS1K8ML36jMjWlFeaek_drOdLs,14153
+Cython/Compiler/AutoDocTransforms.py,sha256=sOPbdvRyU9c2k382ZtgQSFtjG7Jm21n5UAXpLAGLDYE,11738
+Cython/Compiler/Buffer.py,sha256=FalM1FoOOh9t9hXBofnSP5NKM5iYDLpnpZVweis_qrM,29304
+Cython/Compiler/Builtin.py,sha256=pIh5cqcFCb2-eW5oN3rifcG0h-eV-d5oPmLm_3FB7O0,32067
+Cython/Compiler/CmdLine.py,sha256=_m_rMfIT48gl1CrqpY2h7QfRaWjyTHV3YBRBThd7bUk,12526
+Cython/Compiler/Code.cpython-311-x86_64-linux-gnu.so,sha256=TZRhA8tbib2yQ3uv6brSMl1ipEOTXzZ00xyjx_EVKjk,1342888
+Cython/Compiler/Code.pxd,sha256=sx9jxBWoCmvfm_aR9IsfnqE69iNFn_fFe5y-WMfRqEQ,3548
+Cython/Compiler/Code.py,sha256=QOtZC7V2v98BrLPZSA9gA3NcvL2vEm7mwMooUczvADI,104762
+Cython/Compiler/CodeGeneration.py,sha256=jkcx2uX07nck0UZSgysIThRuJiPbdkSeXR4Z2uzbQU8,1108
+Cython/Compiler/CythonScope.py,sha256=4GqELgqDRlQ7bl1FKb47XrcWyYFDYgVstCXHr7yQKUQ,6863
+Cython/Compiler/Dataclass.py,sha256=Awfvdai0Yn2GA6IZSYvYP4WXRgoMfT9I_HD4gHudjGk,36032
+Cython/Compiler/DebugFlags.py,sha256=5Zg9ETp0qPFEma6QMtrGUwu9Fn6NTYMBMWPI_GxFW0A,623
+Cython/Compiler/Errors.py,sha256=_RsCSRTURcZaTtZeGp1TAJiSaXQDLkVBdWv6qa49AW0,9312
+Cython/Compiler/ExprNodes.py,sha256=rvxKVAu2gxiWd6YcaTxrOB0KVN_TivcFTmV8yZ7i-0E,602024
+Cython/Compiler/FlowControl.cpython-311-x86_64-linux-gnu.so,sha256=sse5GrBzH1Zy2XbUQI81JYkbjE4dTtTUA_VtHBQcf5Q,688080
+Cython/Compiler/FlowControl.pxd,sha256=C6se5i0mW-m-wUCa7HOzcuGW4R8All8HOBsIB66p_0A,2979
+Cython/Compiler/FlowControl.py,sha256=3UrRUUR9SliUR7zf_3qATAHd-Xs5ak-bq_QvFtqR60Y,48862
+Cython/Compiler/FusedNode.cpython-311-x86_64-linux-gnu.so,sha256=AkmMt-MwoafMrisUKTjDw8AdgHUdBvmt5jusOfKraBo,517064
+Cython/Compiler/FusedNode.py,sha256=NhZwm2QjIVyHY8Nghz0BIWQn6mXtKpr8VY8PG_0E8OA,43360
+Cython/Compiler/Future.py,sha256=NFtSWCJYqPlEqWZ5Ob_bv_pDfW6iS7pPYWeGH1OGA5g,629
+Cython/Compiler/Interpreter.py,sha256=6wJEJMtz22OoVi49qUZn9ILYevb50vqjqKAteu7lh04,2114
+Cython/Compiler/Lexicon.py,sha256=LmKi6ZqoC-NZDIL86U8L4EGkWVLgHojZQNgUKECkBco,21772
+Cython/Compiler/Main.py,sha256=vv59zMvZnHI5oIkJeTxZSRLYx555TkXu_CcTVzXufkY,32205
+Cython/Compiler/MemoryView.py,sha256=yTDgrvFvjcjIURylob910mMQNTPPmXg7Gh_drqALAfg,30382
+Cython/Compiler/ModuleNode.py,sha256=uhiBxur0D9s-54PCIZRhyVoR7ASHCM4FjH2qVdtVHb0,184020
+Cython/Compiler/Naming.py,sha256=YTKzc5XKvkx8vAqDZmgl45ExnR0QSbZiiNhIev5K1jQ,8160
+Cython/Compiler/Nodes.py,sha256=fuNGOVJP6amUxJCgV7bsfulV_OTbmadmxTRRL4xPm8o,442392
+Cython/Compiler/Optimize.py,sha256=s_sPuYACU4oVACRcoAKoFecyVZ5eU9FfITHhCQahYrw,226603
+Cython/Compiler/Options.py,sha256=ci8mtRDVvl-Mtmcn2UUT40PwAZNjWQ54J4T4zrAQs10,30646
+Cython/Compiler/ParseTreeTransforms.pxd,sha256=1YVH1stZcLYswszLUBMJd4W8wPTik4MCpG4yfNeSh7Y,2583
+Cython/Compiler/ParseTreeTransforms.py,sha256=oDECNyLNwVF3wEuM03DdrLg9fnqH-nEA8Ka1O0TPVqo,171534
+Cython/Compiler/Parsing.cpython-311-x86_64-linux-gnu.so,sha256=cQpeVpAAqGl5Dkdxp3dYk1-stpw7aZroi75lufK_mKI,1170440
+Cython/Compiler/Parsing.pxd,sha256=LomEHtmDKOIroiWpJbrHEcz9-wQP3Jl7jj8PjuLVG10,9166
+Cython/Compiler/Parsing.py,sha256=kRT-rhRpEEwTk3fNABKm0uRh6is5yXH-YCc1U4YENIU,139740
+Cython/Compiler/Pipeline.py,sha256=jNfU_et2wc_HfSSY3LA633OK5FmScceK1zOZKsvlAtM,15631
+Cython/Compiler/PyrexTypes.py,sha256=V_bCmCHwOUkpidMt8APwd02ScK4wbRRHF-U5cbLuIPA,208736
+Cython/Compiler/Pythran.py,sha256=NHIml0yx0jPLyTLRAHXZr0LHTyEyfYqspgYuV4vdNKI,7267
+Cython/Compiler/Scanning.cpython-311-x86_64-linux-gnu.so,sha256=NbvXcI5h1rLUcExxOQGNPq5nvKMD2foDIotQhF9v_-Y,340320
+Cython/Compiler/Scanning.pxd,sha256=ivsDKJzsh6FggfiybEVq3NJ_b6_qIHvi8rPkDLSVTtE,2071
+Cython/Compiler/Scanning.py,sha256=w-aGbQMGXqNBckE87bFDTl1w_lHN4H4-SCwMSh-gZvI,20114
+Cython/Compiler/StringEncoding.py,sha256=wepb0J7NZ9HhahxC0DqL41fWsVl-2I6l95UL1jdYn68,11728
+Cython/Compiler/Symtab.py,sha256=o0q6PYxCE5XFsjaahIjofZfQ-dttPcK7i5vYS5kMqPU,129778
+Cython/Compiler/Tests/TestBuffer.py,sha256=SDAkH2fjCsiaAisWQcBdNX3JxG1KcEEIQJbsnNeIWuk,4156
+Cython/Compiler/Tests/TestCmdLine.py,sha256=ONYLPSMwq4kEYMje-TmQuWzEgNkWkD-RKTmvWDvxtsk,21844
+Cython/Compiler/Tests/TestFlowControl.py,sha256=ge3iqBor6xe5MLaLbOtw7ETntJnAh8EequF1aetVzMw,1848
+Cython/Compiler/Tests/TestGrammar.py,sha256=SbHXzaLnYEcN_D2q6mOIcb0Rd-6cof49LCCYjIPFY4g,5128
+Cython/Compiler/Tests/TestMemView.py,sha256=kytAp-r-DMTuviujoFcA7DhsiofOjnArA0WpJ2j3E1o,2517
+Cython/Compiler/Tests/TestParseTreeTransforms.py,sha256=XbGkHi_fqoZENjQZYp7cMReeF-zg-mpujNaw5LjvdgY,8926
+Cython/Compiler/Tests/TestScanning.py,sha256=SpVM6-4MstnJQUuvFEhXZBEy8n2oPkPguvsb9Y3kI4o,4771
+Cython/Compiler/Tests/TestSignatureMatching.py,sha256=tDlQks1mgo2MIPBW_uC5YkoZt0RjPGYAdluk1j82IvM,3342
+Cython/Compiler/Tests/TestStringEncoding.py,sha256=RL1YDXrOUe1sPLEbWmTJQ5VF-uEZ_KLz0jaeQoMx85k,2315
+Cython/Compiler/Tests/TestTreeFragment.py,sha256=0VywSuhoyluLITx0w-BQ8HYES3TQ5UW0NcGQhjX4qxk,2166
+Cython/Compiler/Tests/TestTreePath.py,sha256=VHOJU30i8GuDWQo3gUL8he0C7wKHENI5wy9t6KU-qII,4192
+Cython/Compiler/Tests/TestTypes.py,sha256=Uo1wWZPgaRbv-leWXmuoqXx_HkY9oPgBAIRI5XulF-Y,3334
+Cython/Compiler/Tests/TestUtilityLoad.py,sha256=5zuAYD_RuRW_KDl2cfA9aXCJ_G-LlDA9pIF4zbqeZlg,3923
+Cython/Compiler/Tests/TestVisitor.py,sha256=QAnBpUhnirSFKqXWiawo-OhXhxIRTQidWxEzGjJDz6M,2228
+Cython/Compiler/Tests/Utils.py,sha256=ChgJ0EeGJRc_ZkNVjZFvFzk1tOj6dxjkW6X1BBot1Hc,1065
+Cython/Compiler/Tests/__init__.py,sha256=jOqtmPLCvMCq0xVMwGekuLpBmVgq0xtPFmUePySdOjs,13
+Cython/Compiler/Tests/__pycache__/TestBuffer.cpython-311.pyc,,
+Cython/Compiler/Tests/__pycache__/TestCmdLine.cpython-311.pyc,,
+Cython/Compiler/Tests/__pycache__/TestFlowControl.cpython-311.pyc,,
+Cython/Compiler/Tests/__pycache__/TestGrammar.cpython-311.pyc,,
+Cython/Compiler/Tests/__pycache__/TestMemView.cpython-311.pyc,,
+Cython/Compiler/Tests/__pycache__/TestParseTreeTransforms.cpython-311.pyc,,
+Cython/Compiler/Tests/__pycache__/TestScanning.cpython-311.pyc,,
+Cython/Compiler/Tests/__pycache__/TestSignatureMatching.cpython-311.pyc,,
+Cython/Compiler/Tests/__pycache__/TestStringEncoding.cpython-311.pyc,,
+Cython/Compiler/Tests/__pycache__/TestTreeFragment.cpython-311.pyc,,
+Cython/Compiler/Tests/__pycache__/TestTreePath.cpython-311.pyc,,
+Cython/Compiler/Tests/__pycache__/TestTypes.cpython-311.pyc,,
+Cython/Compiler/Tests/__pycache__/TestUtilityLoad.cpython-311.pyc,,
+Cython/Compiler/Tests/__pycache__/TestVisitor.cpython-311.pyc,,
+Cython/Compiler/Tests/__pycache__/Utils.cpython-311.pyc,,
+Cython/Compiler/Tests/__pycache__/__init__.cpython-311.pyc,,
+Cython/Compiler/TreeFragment.py,sha256=GuKBbSDCwWD77FacP9iHVvBHghBBfYrAvIgB4mxW5cE,9709
+Cython/Compiler/TreePath.py,sha256=3_lScMAd2Sly2ekZ8HO8dyZstGSruINl2MXXq9OYd2Q,7641
+Cython/Compiler/TypeInference.py,sha256=PQHeR9d8EFloyWVuVv6CNPri4G9nTNPyCQzcsfgNeBs,22725
+Cython/Compiler/TypeSlots.py,sha256=s0fmpCT07y85yDnrNZsa_DZvdfc07SiVVX-f_9hxf_g,50443
+Cython/Compiler/UFuncs.py,sha256=KNCawVbwvmUanYTqxG73AJhlIRFIJA6BjYLcKWiidiQ,9166
+Cython/Compiler/UtilNodes.py,sha256=QYfoLIIYKlbmG-IoO2-hTJDShl9pM12SAHb_G5QPwgY,12463
+Cython/Compiler/UtilityCode.py,sha256=yRSZAzXEQq4AuGR278ZFiZCXSoArylcf_cCgVsXDRnA,10952
+Cython/Compiler/Version.py,sha256=f2mS6aYYdu0DMRK3B4IuzMlCo-k-ffmehCao_vKlTdk,181
+Cython/Compiler/Visitor.cpython-311-x86_64-linux-gnu.so,sha256=hZfxmFgE9sDFW4TSmodE8OK8ZgCqppVAJJn7u8uh3sw,374848
+Cython/Compiler/Visitor.pxd,sha256=AsYd6v_MyVWzs2AVj0siG_92JGnKhxEYk89oAbhHa64,1814
+Cython/Compiler/Visitor.py,sha256=c5Xu4v2LTwhxBp_Ign24WXMThddN0OZ_7gZ53aCHOAo,31627
+Cython/Compiler/__init__.py,sha256=jOqtmPLCvMCq0xVMwGekuLpBmVgq0xtPFmUePySdOjs,13
+Cython/Compiler/__pycache__/AnalysedTreeTransforms.cpython-311.pyc,,
+Cython/Compiler/__pycache__/Annotate.cpython-311.pyc,,
+Cython/Compiler/__pycache__/AutoDocTransforms.cpython-311.pyc,,
+Cython/Compiler/__pycache__/Buffer.cpython-311.pyc,,
+Cython/Compiler/__pycache__/Builtin.cpython-311.pyc,,
+Cython/Compiler/__pycache__/CmdLine.cpython-311.pyc,,
+Cython/Compiler/__pycache__/Code.cpython-311.pyc,,
+Cython/Compiler/__pycache__/CodeGeneration.cpython-311.pyc,,
+Cython/Compiler/__pycache__/CythonScope.cpython-311.pyc,,
+Cython/Compiler/__pycache__/Dataclass.cpython-311.pyc,,
+Cython/Compiler/__pycache__/DebugFlags.cpython-311.pyc,,
+Cython/Compiler/__pycache__/Errors.cpython-311.pyc,,
+Cython/Compiler/__pycache__/ExprNodes.cpython-311.pyc,,
+Cython/Compiler/__pycache__/FlowControl.cpython-311.pyc,,
+Cython/Compiler/__pycache__/FusedNode.cpython-311.pyc,,
+Cython/Compiler/__pycache__/Future.cpython-311.pyc,,
+Cython/Compiler/__pycache__/Interpreter.cpython-311.pyc,,
+Cython/Compiler/__pycache__/Lexicon.cpython-311.pyc,,
+Cython/Compiler/__pycache__/Main.cpython-311.pyc,,
+Cython/Compiler/__pycache__/MemoryView.cpython-311.pyc,,
+Cython/Compiler/__pycache__/ModuleNode.cpython-311.pyc,,
+Cython/Compiler/__pycache__/Naming.cpython-311.pyc,,
+Cython/Compiler/__pycache__/Nodes.cpython-311.pyc,,
+Cython/Compiler/__pycache__/Optimize.cpython-311.pyc,,
+Cython/Compiler/__pycache__/Options.cpython-311.pyc,,
+Cython/Compiler/__pycache__/ParseTreeTransforms.cpython-311.pyc,,
+Cython/Compiler/__pycache__/Parsing.cpython-311.pyc,,
+Cython/Compiler/__pycache__/Pipeline.cpython-311.pyc,,
+Cython/Compiler/__pycache__/PyrexTypes.cpython-311.pyc,,
+Cython/Compiler/__pycache__/Pythran.cpython-311.pyc,,
+Cython/Compiler/__pycache__/Scanning.cpython-311.pyc,,
+Cython/Compiler/__pycache__/StringEncoding.cpython-311.pyc,,
+Cython/Compiler/__pycache__/Symtab.cpython-311.pyc,,
+Cython/Compiler/__pycache__/TreeFragment.cpython-311.pyc,,
+Cython/Compiler/__pycache__/TreePath.cpython-311.pyc,,
+Cython/Compiler/__pycache__/TypeInference.cpython-311.pyc,,
+Cython/Compiler/__pycache__/TypeSlots.cpython-311.pyc,,
+Cython/Compiler/__pycache__/UFuncs.cpython-311.pyc,,
+Cython/Compiler/__pycache__/UtilNodes.cpython-311.pyc,,
+Cython/Compiler/__pycache__/UtilityCode.cpython-311.pyc,,
+Cython/Compiler/__pycache__/Version.cpython-311.pyc,,
+Cython/Compiler/__pycache__/Visitor.cpython-311.pyc,,
+Cython/Compiler/__pycache__/__init__.cpython-311.pyc,,
+Cython/Coverage.py,sha256=prYNxj3ML6UaI_UVOhROd54GBwRgrt_Fa71vVlrEPbk,18461
+Cython/Debugger/Cygdb.py,sha256=8k5Wz09MSQdiUtCVtb0dMukKqZV7E8fvB9Yvv3rfJCI,6911
+Cython/Debugger/DebugWriter.py,sha256=OoywNqkq5IyRRAvlcaaZ05zDrJMgNgg7O6wMVdltr5k,2486
+Cython/Debugger/Tests/TestLibCython.py,sha256=T6qGlhSlrXwI5cn2OpWa82tZ51UjVm9qmmk9Mfho1p4,8455
+Cython/Debugger/Tests/__init__.py,sha256=jOqtmPLCvMCq0xVMwGekuLpBmVgq0xtPFmUePySdOjs,13
+Cython/Debugger/Tests/__pycache__/TestLibCython.cpython-311.pyc,,
+Cython/Debugger/Tests/__pycache__/__init__.cpython-311.pyc,,
+Cython/Debugger/Tests/__pycache__/test_libcython_in_gdb.cpython-311.pyc,,
+Cython/Debugger/Tests/__pycache__/test_libpython_in_gdb.cpython-311.pyc,,
+Cython/Debugger/Tests/cfuncs.c,sha256=4SZurmnz5J1SiIs9N26Eu4zc2wvF_qMEKaN0eTcbDPo,71
+Cython/Debugger/Tests/codefile,sha256=axsI884lThsoLMg2vlQJ6BPG8t9vil0mTDs_Pi7vuwI,642
+Cython/Debugger/Tests/test_libcython_in_gdb.py,sha256=8JDbj3CbmQrB7cFP7yThiHlgIS4QrdvQYMLGEoHuE7A,18048
+Cython/Debugger/Tests/test_libpython_in_gdb.py,sha256=fjXO3VgT0sYcAaV2vpx2oJDJ7MsQmXTG3IOge7QnnU0,4049
+Cython/Debugger/__init__.py,sha256=jOqtmPLCvMCq0xVMwGekuLpBmVgq0xtPFmUePySdOjs,13
+Cython/Debugger/__pycache__/Cygdb.cpython-311.pyc,,
+Cython/Debugger/__pycache__/DebugWriter.cpython-311.pyc,,
+Cython/Debugger/__pycache__/__init__.cpython-311.pyc,,
+Cython/Debugger/__pycache__/libcython.cpython-311.pyc,,
+Cython/Debugger/__pycache__/libpython.cpython-311.pyc,,
+Cython/Debugger/libcython.py,sha256=70z-fpmKeAj7Blk9FImlDXfFyNsU848IPzaWZYDITvE,46538
+Cython/Debugger/libpython.py,sha256=crnRuil2PPaXZz0wp6AZ-dabnFXzji0PcLQyMJB9e5Y,94004
+Cython/Debugging.py,sha256=vFtJhn7QstMf5gnYru2qHIz5ZjPg1KSlZVGHr-pBCwM,552
+Cython/Distutils/__init__.py,sha256=uyWaN2NJ_mKYLzVsDPi0qZCdIYoW5M_7YYEmAOIL3Ek,98
+Cython/Distutils/__pycache__/__init__.cpython-311.pyc,,
+Cython/Distutils/__pycache__/build_ext.cpython-311.pyc,,
+Cython/Distutils/__pycache__/extension.cpython-311.pyc,,
+Cython/Distutils/__pycache__/old_build_ext.cpython-311.pyc,,
+Cython/Distutils/build_ext.py,sha256=QCoEpEMz3NQ2s6kQtUB743zeuIFVdIz5VkADtqYbkeE,5708
+Cython/Distutils/extension.py,sha256=tnMDR7SMrWDh2tQjC7fHtptlKhYXvf0HiveMLGQjIJ0,4640
+Cython/Distutils/old_build_ext.py,sha256=jb7aERJvis6xrIJCPnRQjF2O-xjj4jYltMvDRodQAtg,13825
+Cython/Includes/cpython/__init__.pxd,sha256=imlSN5iR-xZ9Ep9tw_6WqTLaVn6vO5tXYHhVxv1u82o,8306
+Cython/Includes/cpython/array.pxd,sha256=0laAK0ujw6gtzgfqzWWmckRQe0-SQ5smhAqXKNpJCWg,6367
+Cython/Includes/cpython/bool.pxd,sha256=5RU6XY57iZ-xtngjXswJoBOxn1ClZdkcXWHQiZ2k6fg,1358
+Cython/Includes/cpython/buffer.pxd,sha256=wm7aHygGUof_H3-JyICOek_xiU6Oks178ark1Nfk-a0,4870
+Cython/Includes/cpython/bytearray.pxd,sha256=m0VdoHgouF1T0VtRjFLXZ5fi22vaMdVwFWpF3IxB6m4,1443
+Cython/Includes/cpython/bytes.pxd,sha256=OH9krgA2CLdcNJWOM0PpgMskbh5vnq6fjjj1lzYOhOU,10066
+Cython/Includes/cpython/cellobject.pxd,sha256=DXdTjSN1RP1m4CsaGuggyIA1nGiIO4Kr7-c0ZWfrpRo,1390
+Cython/Includes/cpython/ceval.pxd,sha256=h6fBetZCUvWTcCn3bkXZg2kqnIuyC5ZSChyhOocxVus,236
+Cython/Includes/cpython/cobject.pxd,sha256=ZeMdbpZLqpcTywdv2VoppMTWD4X_yghL6Qox7LVfOyg,1524
+Cython/Includes/cpython/codecs.pxd,sha256=3fyudEljkNGQ7e3dJPst6udXGcAeNKvlMK9U8EB1gXc,5084
+Cython/Includes/cpython/complex.pxd,sha256=B_ondPAPNM7nSJtgMPKZgWxFHldPxBqG63spwK4t9_Y,1842
+Cython/Includes/cpython/contextvars.pxd,sha256=HoNxGtIIZOLEuSclvOizjkSAwhLtOZWzg8j8YZa_RT8,5731
+Cython/Includes/cpython/conversion.pxd,sha256=dbbFuZJF0SscmcaNCUf0tlBQDRdKYf5tH8yzhTU_XYI,1696
+Cython/Includes/cpython/datetime.pxd,sha256=uoyukvbgigbAVXMVUFd6pwvUViAUHfZvuNPiA0nqETU,15793
+Cython/Includes/cpython/descr.pxd,sha256=RPSPJUxyejKsWruYS3IWU1rg0L1pKFAYidYcXW9YAj0,728
+Cython/Includes/cpython/dict.pxd,sha256=U1FHJRnYf2GZcVReNEATzeOa8s5PlAD539MQigbOASc,7939
+Cython/Includes/cpython/exc.pxd,sha256=0pI7VcDnMLqf-S_BClRgoiH2xGyDbhlmFGWOKcn3sGM,13830
+Cython/Includes/cpython/fileobject.pxd,sha256=yQG3M9wfS2jwpgSTo-8oXx8K9xnpGIkL-etQt9YDwTU,2889
+Cython/Includes/cpython/float.pxd,sha256=Gmf5SzLRCZOMd-deD35PgOlRGsrcwhQw__E4igmqKdc,1650
+Cython/Includes/cpython/function.pxd,sha256=IoJUprbz8F10DEKh-vSSpY6nWkCHw7SqG9p2f-4gHek,2671
+Cython/Includes/cpython/genobject.pxd,sha256=emC1JPgkuvBbGC0rgeZapKDaXYEj48uWiDC-xF0Mx2I,1052
+Cython/Includes/cpython/getargs.pxd,sha256=268twKzdiAkQMXMsetNiNlNqaqzlKtiBENKbhOHd8x4,775
+Cython/Includes/cpython/instance.pxd,sha256=qCbxPeHKOJbuszDu3UEaI-KLX9lTopuaNCcpoHJ9ngU,985
+Cython/Includes/cpython/int.pxd,sha256=d9a0zUw_M3pRycCESWIjtfXWRvdvFOWxjdOjkcbX2gs,4131
+Cython/Includes/cpython/iterator.pxd,sha256=o52mLHbdm14Kqant2hR2zAdYzqK4fkSWZtBcRmpoP-I,1319
+Cython/Includes/cpython/iterobject.pxd,sha256=5UEZZwG5zyzxoCpknoQuh91zPUV11Uxr6F1taJdTv8k,1036
+Cython/Includes/cpython/list.pxd,sha256=HhnwchBGhPIAoObzIXyg33KqvSxBRveWoq34iZM508s,4096
+Cython/Includes/cpython/long.pxd,sha256=1gN-O5AcV4B_r974qxW9YDr7NedDyDrTRjOelClvoyA,7047
+Cython/Includes/cpython/longintrepr.pxd,sha256=czvKr3fQdYIwIRu3gojXssT9LFXH-nstM7f_lPt7lE4,480
+Cython/Includes/cpython/mapping.pxd,sha256=DI5_kOp78IaYx77qIWpetu13iMEgGXZew84mTsCPYtM,2692
+Cython/Includes/cpython/marshal.pxd,sha256=-Tl2w_7VfgzrCSq1gpBIEZRADw1g1zZNMdPXz4YJClE,2897
+Cython/Includes/cpython/mem.pxd,sha256=O8I4rWJj7VvrlYjPpR-Dhls5izYddgO5rNyAOAzWUQQ,5912
+Cython/Includes/cpython/memoryview.pxd,sha256=l97J5-hbH3hp9aMbdXp3n73hJFNNsng6uyh40pc8P7I,2504
+Cython/Includes/cpython/method.pxd,sha256=UWXflhIlP4y7B5XDbH9rQ15iADciGW-iqV1-dlw2Wwg,2196
+Cython/Includes/cpython/module.pxd,sha256=ahRxpmkz_KMZhnSk-ZrXn_kkSoUhNBxWXf9uPquXyis,10128
+Cython/Includes/cpython/number.pxd,sha256=tYJ0nn0k_llUx3ilniW9iXd2rKVejA-J5UUiIJ36Kww,11922
+Cython/Includes/cpython/object.pxd,sha256=1mMnUhoxDfCg7iCjQHvf4lsagJLZw9H0EhsLy4NggyM,20003
+Cython/Includes/cpython/oldbuffer.pxd,sha256=v0-YZ_Iwwj3ZQdM8VE5NPTQcbBlJdWwJGtNO9DonGgw,2916
+Cython/Includes/cpython/pycapsule.pxd,sha256=Z3-xhfFRIldr-SqznNaE5J0N0jlUvoa-I5sGTHzWTGg,5700
+Cython/Includes/cpython/pylifecycle.pxd,sha256=LziJZHclGdtsr3yT28fULHNZ_n67bs1DmI9s8YzrBGg,2000
+Cython/Includes/cpython/pyport.pxd,sha256=MfWCwvbMjd_qBvpmj5DuNUqGnTnLLEIx9pb8B1-dz_Y,222
+Cython/Includes/cpython/pystate.pxd,sha256=TQb-_El6K7h6ktpFkgfehi1VBe4KcUNscH7TG7Nv8W4,3779
+Cython/Includes/cpython/pythread.pxd,sha256=0375TaYmtNCDDkWBh9WY4oJ_jhoTxhu_RR5QiOsXmYg,1946
+Cython/Includes/cpython/ref.pxd,sha256=awtAD2o36UaGQbnDHVdOyH8J2Iiclo7D4Bj7XFJbaA0,2556
+Cython/Includes/cpython/sequence.pxd,sha256=UajXW6S_ssyCmYDDsXFiHGR9IUDMP3f6AuV4bBzh2Do,6006
+Cython/Includes/cpython/set.pxd,sha256=ewHRPVMbHUGDInZ3NziisCq68LvtmEJ-SXFbzmuJxLc,5383
+Cython/Includes/cpython/slice.pxd,sha256=Rzgn8diAsN7lS2xGTq4VZucV3ziFNra4oz4tKGEAkMo,3111
+Cython/Includes/cpython/string.pxd,sha256=6jHMVltzGLTLgmo_ndti22mTuQmNVyk9J9S48eyPbEo,9942
+Cython/Includes/cpython/time.pxd,sha256=rdv6S1n2jDiymQDTnf5dxjdgab5ia0SiO0R2cKjkaTk,2411
+Cython/Includes/cpython/tuple.pxd,sha256=DUUhJp4v23g0JOJ6OK3sGvHNgEz97Z9be8XBgZrqH0Y,3219
+Cython/Includes/cpython/type.pxd,sha256=qt8Hqz3DKGJuMgWJgP2JuCpUHiySYp8KCJTerJ4gnpI,2067
+Cython/Includes/cpython/unicode.pxd,sha256=68cguuI3cMJbspbqwRPuzmpjJfOsZe_IV10JvhMd-FQ,30635
+Cython/Includes/cpython/version.pxd,sha256=l5KXt04isEv3qbGRJZ8fNlCYGO24HsA2l4EM3RxTEhE,847
+Cython/Includes/cpython/weakref.pxd,sha256=UU9H_ovHG07FFgP_kY2xhGv3yJDr_8iujCZnxH2jnlo,1984
+Cython/Includes/libc/__init__.pxd,sha256=jOqtmPLCvMCq0xVMwGekuLpBmVgq0xtPFmUePySdOjs,13
+Cython/Includes/libc/complex.pxd,sha256=m2ntA8NFZQG02UuY5YDGu-MrW-Avp0kSY82mhkR1Q8M,1224
+Cython/Includes/libc/errno.pxd,sha256=tt0CJaCDWZN4HGtzC5nP7D-hT-jjoYD9m0FOPizmRvc,2049
+Cython/Includes/libc/float.pxd,sha256=IhvZJljpTG0fZtcIp7EBO2Sqddozxoxwj4RFNVcKLpY,966
+Cython/Includes/libc/limits.pxd,sha256=xHlIyuDIKpjqclvRRYzZIcfd5G1re5QtbmoDMqZR_Ec,621
+Cython/Includes/libc/locale.pxd,sha256=sixG8EJ6wiVb0HIR1LWJ3lXTjTv463GJ9C_40HRovN4,1140
+Cython/Includes/libc/math.pxd,sha256=Hy0ewq4Xw2sWPvrokbrbpHw6r6azx8C1nRsNWtuMhUs,6581
+Cython/Includes/libc/setjmp.pxd,sha256=XRh-gSuhvFLl0nRvz5OhSWYe9eqX2attAck3JI7mwa4,297
+Cython/Includes/libc/signal.pxd,sha256=RmJeCLtWUfYFTtwiocZSV-gJtJrxFijkTYOZnvOk9Pw,1179
+Cython/Includes/libc/stddef.pxd,sha256=0rCyoocCfDL-1OQo3pxHQ-6fW20SAYktOLPoa4d97w8,164
+Cython/Includes/libc/stdint.pxd,sha256=qHJXzpWCrbvJWSaHYZL27VJPupQreTZl9VGj0jgLdRU,3449
+Cython/Includes/libc/stdio.pxd,sha256=qUaxEwNrQl1-4yHLorzzJZ-a-y5_-Rm_m7Z5meaRqH0,2476
+Cython/Includes/libc/stdlib.pxd,sha256=p62xq2XfB24WfNCjRXgD6cOYoRuV47AnYijkjWv4ugE,2444
+Cython/Includes/libc/string.pxd,sha256=tzYGbRrnccedFLes-KGgJqM0FEtwHF_q4f2fqltNvyE,2038
+Cython/Includes/libc/time.pxd,sha256=zeE7saukFU9k77SXjUlIJ2GWka-LdXCFVwinfL4sQx0,1354
+Cython/Includes/libcpp/__init__.pxd,sha256=PCx8ZRfOeoyMRu41PPlPY9uo2kZmt_7d0KR4Epzfe7c,94
+Cython/Includes/libcpp/algorithm.pxd,sha256=HaatOKA2pIHc-RNHCIWayPXLT2Hd56Q0gKC5kLlCYYc,23704
+Cython/Includes/libcpp/any.pxd,sha256=0HE8j4XF0bkCrxaYWE3DM1kV_2LhljH8WKh2ariwIWc,425
+Cython/Includes/libcpp/atomic.pxd,sha256=BDFpDe8SmSdiDkEUfzbh55hjkY8yCUVDyeeUcMOwiy8,1705
+Cython/Includes/libcpp/bit.pxd,sha256=Wd_4EoENOPZeqqhd0s--6TCOzeqPpUFfGNQibsqV9Ig,749
+Cython/Includes/libcpp/cast.pxd,sha256=En4LBubdinfpm9Rel077tK_LGwg_3k4FAu9mlIbKjuw,501
+Cython/Includes/libcpp/cmath.pxd,sha256=-_jnjIWY47jybkNnGrMk8ewZeGaWU0ezMWAZm9UCRk0,19935
+Cython/Includes/libcpp/complex.pxd,sha256=JtuQuknvS6GQ0FfyJGQ914DXvzNEaF1-z9D0jST6gXM,2995
+Cython/Includes/libcpp/deque.pxd,sha256=SwgYrnqq6OMQMSOEFTZpnpRsii7pIAT-06bLxMS5w7M,6718
+Cython/Includes/libcpp/execution.pxd,sha256=I2KizUy9DGm_0edrd2BFdHPwyeip2ZcDxqdwb0t7taI,515
+Cython/Includes/libcpp/forward_list.pxd,sha256=o2ThwKyJWZrNT4ZMB1aYmf-2wqYiqSCDdfVswpo8S8I,2429
+Cython/Includes/libcpp/functional.pxd,sha256=kMul7WB1J0X2-611AMtXq6sP9jYYk3YO8zZoDKFaeDU,722
+Cython/Includes/libcpp/iterator.pxd,sha256=UjkDqqKq6pHLiwgdUY730PbzAiTKKlhak6gkVd3jtsk,1512
+Cython/Includes/libcpp/limits.pxd,sha256=BWJzVBB8MZt3l9PUre1o5eScE2fGJa3_Sv6e_KH30Uw,1821
+Cython/Includes/libcpp/list.pxd,sha256=iOovgIk_Slkf7yaDEv6-ZUss_AU98OGWkvgNQDF0K0A,4438
+Cython/Includes/libcpp/map.pxd,sha256=C8EaEsvLEc2tmEkyybOzgkx3CoFWYFBpZelHhcKHI1s,10481
+Cython/Includes/libcpp/memory.pxd,sha256=OqNDPX_1ps9bxWCEQDiefbQv-NeZJ7SNUQtdYB86MZs,3593
+Cython/Includes/libcpp/numbers.pxd,sha256=SkBhbClhRTtzbSMj_QvR2pz-CjdB08ZXPJbXSwATzvw,395
+Cython/Includes/libcpp/numeric.pxd,sha256=dTdOmLBD5X5VGeTdYQqA_AXgJOr5f51_-rR7umo-w0Y,6571
+Cython/Includes/libcpp/optional.pxd,sha256=Mf5gnZIvB9IR-L7bi3ntog2EOXB-pp1Xo45CWqyRCiU,990
+Cython/Includes/libcpp/pair.pxd,sha256=UBJXw43uHkDlNsr0Pu1aP5tZ-ILXhUAyOLam2qdWmZA,27
+Cython/Includes/libcpp/queue.pxd,sha256=FbL4Q7C3lgtZ2YzictU1XBXzQ7G-6y9i_7l2eqzA3Xc,649
+Cython/Includes/libcpp/random.pxd,sha256=jgjjSbPvJturdi1NhYclH6NQRnDF3CiCbuPKgtrQ2lc,6203
+Cython/Includes/libcpp/set.pxd,sha256=IAEHB3ElvGIm9AX8fWoO9db1jpz6eVXLDgMgOcoHhcY,9176
+Cython/Includes/libcpp/stack.pxd,sha256=hCU6nVpHHkKhlzREnw4cSi64atGu9pWeuorFSZtEoh4,301
+Cython/Includes/libcpp/string.pxd,sha256=gT_1KTVrAt-0rnWT5S97GJhPChKpk-syeqa_Mj5L9wU,13840
+Cython/Includes/libcpp/typeindex.pxd,sha256=mIHr5Mq6Lol0SlzqeK6w_giVERh3uAjZm78yPDLXzc4,524
+Cython/Includes/libcpp/typeinfo.pxd,sha256=tITsqurrdaZjsEGFksem9xZtVhSxQRxHZxcoC-4Y-DY,304
+Cython/Includes/libcpp/unordered_map.pxd,sha256=dHnTuJ1S3ja7OYGRW-hZ1Zh_xDpv3iW6JUxs9Um_K4U,7945
+Cython/Includes/libcpp/unordered_set.pxd,sha256=yfmib2EnFDGn_RvlxCFkVy-eVapwQw2FvTHu-I5psTU,5810
+Cython/Includes/libcpp/utility.pxd,sha256=hTbvp7c12pnU2yvzzMvflZB-MAc_--3xh3PXtD_VIwg,1040
+Cython/Includes/libcpp/vector.pxd,sha256=lLjXSgOThX23KA6Suuyf0FrAY7kDiTs8xFJi5xKzetk,6839
+Cython/Includes/numpy/__init__.pxd,sha256=JbZ4wJihimLMlU6P4bT2iYy4E_hKrNenab-GC8h91QI,36457
+Cython/Includes/numpy/math.pxd,sha256=qZEdamaPgCFW4J7Itc6BWgOrQSKZdxDT6kbU_gqx2g4,5807
+Cython/Includes/openmp.pxd,sha256=3GTRd5JH31CvfTzXErglXnyf_jye1Gvk9O4giTa6pc0,1712
+Cython/Includes/posix/__init__.pxd,sha256=jOqtmPLCvMCq0xVMwGekuLpBmVgq0xtPFmUePySdOjs,13
+Cython/Includes/posix/dlfcn.pxd,sha256=U-jAieh45NSlrlogsd6SJeCunYDxCG-AlQ7hpEXQgL4,356
+Cython/Includes/posix/fcntl.pxd,sha256=s0Qj0-T7Luzk0dJH4Jn_U54Suzf1LrfKDlFp7qg_nfM,1697
+Cython/Includes/posix/ioctl.pxd,sha256=2RC5zejPOCTkarDZM_6Vd2wc4oBuN7iaiL_C5MPBs90,99
+Cython/Includes/posix/mman.pxd,sha256=jeRRW5YRK4o2cLx5M98Ce--CP7GGZWVyy3ylW2mP6nU,3475
+Cython/Includes/posix/resource.pxd,sha256=_oeWwy1HOQ-PUAxfnM1Ha7jnSIi2uUosAaNaQmqUmsk,1338
+Cython/Includes/posix/select.pxd,sha256=cF6U60K7hYUzQuY8udA8VF50vTC7xxau1eynXrADzAU,619
+Cython/Includes/posix/signal.pxd,sha256=wFJI5UthdtU9mZWjEBeZ9IIfeX252JVwDk2tsbW_q3U,1876
+Cython/Includes/posix/stat.pxd,sha256=5sHZ4Ira3nVeNDynsM-7aEcJu7DfC07d_aTwlcUhC0Q,2695
+Cython/Includes/posix/stdio.pxd,sha256=nDxLG4Qdq2v9zLb-bfxphv9oCvCD5QenT2POqSX7Sww,1055
+Cython/Includes/posix/stdlib.pxd,sha256=G5Miv-QwID6Te9BQsz2vlRyKTpmvtuuYdwOUX4RxRoM,935
+Cython/Includes/posix/strings.pxd,sha256=GNEteqND2wgXXSvkv6U9eKSC9oIom3C7o2zQ6W_J_S4,374
+Cython/Includes/posix/time.pxd,sha256=lX06ykHd1qZsrw9ziKLpsGNdoN03PURRfrEngOMRBcs,1981
+Cython/Includes/posix/types.pxd,sha256=tWEWxST4EGHIgYS-Ce2SGjZ-KgmM2SVe1eggdcgv3JQ,1162
+Cython/Includes/posix/uio.pxd,sha256=lsHOhduB-LgUwWz8uMYlenGa29gtfc2B_K8Jjw7_8OY,822
+Cython/Includes/posix/unistd.pxd,sha256=w9B4d9NaXBsQ62XOr2xe9UFPGewmEk5BG6sqiRWdoM8,8061
+Cython/Includes/posix/wait.pxd,sha256=8bQAm7_cADrhT9ZY8-HZUn6dbIeIvEkuy-ZYmaSYQMg,1246
+Cython/Plex/Actions.cpython-311-x86_64-linux-gnu.so,sha256=yqfhf3eac_YWxsZ0aVb15SxJbOIZC1KtRMbbLP4lSKQ,80704
+Cython/Plex/Actions.pxd,sha256=AQbTp0D_OPz2nVkcaPiumYEFfaQacOVJCGorHctKHcM,581
+Cython/Plex/Actions.py,sha256=eGPLzGxlQ4ncVaaUaQk-Re2N6SEDYk7DFq3KFVZXVjo,2919
+Cython/Plex/DFA.cpython-311-x86_64-linux-gnu.so,sha256=hCvqfOxNG6864pvvrLILQP6JhdfeuvyAN2rJFjWVASs,128360
+Cython/Plex/DFA.pxd,sha256=ZU4_46Flh_0QN9eQFgIdVXuGo-iuFTQHFil97o_Ege0,776
+Cython/Plex/DFA.py,sha256=HRTKO0V2gWmQ-8ch9u38NXXI9gVJ3HRwg5W2owWWkwE,5427
+Cython/Plex/Errors.py,sha256=UsCwtNpxD2_BfStOsYfb1gMeU0xe5a_8yUDd7WKf7cc,976
+Cython/Plex/Lexicons.py,sha256=D8QeBOxAM06Zox9gn_Dxnk7JNPFI1_F4Wb2kb8nFKKI,5946
+Cython/Plex/Machines.cpython-311-x86_64-linux-gnu.so,sha256=W9tKGFkvybV2cuVHoLvgEXdrQeo81ei_gXLp5yQj8gY,176680
+Cython/Plex/Machines.pxd,sha256=PmaVCp9oQorpzUgpTQAPMwPlXTVjHfln73arpOthKLY,732
+Cython/Plex/Machines.py,sha256=MlbIyguDBOrZ9qaTXHUcEB8T664y4KKLG0V1iLNINv8,7684
+Cython/Plex/Regexps.py,sha256=Gei0aVp0eM-KJWNLqvgOj9thOTw6Swy-aRlx-gzVbmA,14957
+Cython/Plex/Scanners.cpython-311-x86_64-linux-gnu.so,sha256=L-956RiR4JNYm1zYktPXy3gJ3zf3CSvKbCe5sjU8G4o,123048
+Cython/Plex/Scanners.pxd,sha256=oiTi45TeGNyaGN09oX8y21HtEfgcnlH_iHMahlqAcPs,1552
+Cython/Plex/Scanners.py,sha256=GsW6Ow3mOW43aZGNImZ8h_j5sBFCMSX4cI6YokCYOBo,12939
+Cython/Plex/Transitions.cpython-311-x86_64-linux-gnu.so,sha256=GSRS8Trc2W4r55CyH9MLWTpBqblpdUSZ47Gf9flNR4Y,138408
+Cython/Plex/Transitions.pxd,sha256=Ewpk1zxElJtYDEDQPFkGRDh-KAFfwbbUi0sd2gLsTuU,590
+Cython/Plex/Transitions.py,sha256=qrlew4MHJytnuG0OCxOBmUiVPCm-8egSlRJg1vsN20w,6761
+Cython/Plex/__init__.py,sha256=HUAqdIcdoDbQWsTwPl0-cM5rclQCecGv2Ysz_3dcBRo,1155
+Cython/Plex/__pycache__/Actions.cpython-311.pyc,,
+Cython/Plex/__pycache__/DFA.cpython-311.pyc,,
+Cython/Plex/__pycache__/Errors.cpython-311.pyc,,
+Cython/Plex/__pycache__/Lexicons.cpython-311.pyc,,
+Cython/Plex/__pycache__/Machines.cpython-311.pyc,,
+Cython/Plex/__pycache__/Regexps.cpython-311.pyc,,
+Cython/Plex/__pycache__/Scanners.cpython-311.pyc,,
+Cython/Plex/__pycache__/Transitions.cpython-311.pyc,,
+Cython/Plex/__pycache__/__init__.cpython-311.pyc,,
+Cython/Runtime/__init__.py,sha256=jOqtmPLCvMCq0xVMwGekuLpBmVgq0xtPFmUePySdOjs,13
+Cython/Runtime/__pycache__/__init__.cpython-311.pyc,,
+Cython/Runtime/refnanny.cpython-311-x86_64-linux-gnu.so,sha256=kNrjPiYL_v9YUJ40an7SwA-Znv2xnw2myvowLSZ-QNQ,93912
+Cython/Runtime/refnanny.pyx,sha256=K09EBbEVRgelbCnYDwlxwm3Fmuxsk8c4NW8xXz6s5hk,6611
+Cython/Shadow.py,sha256=jNFqWxRBGPdXraiqlzeF4-sH4tNvfXy7MD58LBHP3b0,17278
+Cython/Shadow.pyi,sha256=X7Y2fTL2wuz9Xb6I6pBQc3GQ1bQ6pa9gM4--hbz3qmo,2697
+Cython/StringIOTree.cpython-311-x86_64-linux-gnu.so,sha256=sFK6scoeZtYfYPZHt_8kLeg3tOnFyKeOvTvvv-mZOTo,89896
+Cython/StringIOTree.py,sha256=AB7jPmSEZXutd7v_JbDaTgg93vQEasP52X-QBtRPZ_4,5737
+Cython/Tempita/__init__.py,sha256=YHujYHiLoYUwFNNswJCgzSrDuie3sV08JsWT9Nbmp78,152
+Cython/Tempita/__pycache__/__init__.cpython-311.pyc,,
+Cython/Tempita/__pycache__/_looper.cpython-311.pyc,,
+Cython/Tempita/__pycache__/_tempita.cpython-311.pyc,,
+Cython/Tempita/__pycache__/compat3.cpython-311.pyc,,
+Cython/Tempita/_looper.py,sha256=jlStYhz9Pgp6NatX86k-netBNBmvwaeWxCRS_S8vcIM,4168
+Cython/Tempita/_tempita.cpython-311-x86_64-linux-gnu.so,sha256=BHfyCw36GfedxISkqSwLpK4gTQdK0XFFLh196LvU1s8,595904
+Cython/Tempita/_tempita.py,sha256=TyzL8e2Dpj3HTo7NsxSYN2LdvRShV6o9oEujNe6x8tU,37650
+Cython/Tempita/compat3.py,sha256=cjW1y266vRF5Xvh8kAu7_qHGT8AGGu2kGSJRK6DI-0E,903
+Cython/TestUtils.py,sha256=F_EvSitHy43ZNvZwZUy2JYJlHA5nMWGDlsEvjLahpeo,14703
+Cython/Tests/TestCodeWriter.py,sha256=ZbhNJEzEyxnl5w4dPw_8na6bpzSaeuZtYjEUecj4Ueo,3799
+Cython/Tests/TestCythonUtils.py,sha256=5wwdRgB3NgMvPoqMetIwRcddH0WgPrPI4bJq2pwEKQk,6825
+Cython/Tests/TestJediTyper.py,sha256=ppWoB_kWprErFZoTQctja1yBMia8jWdBbRaN5zhkYRM,7021
+Cython/Tests/TestShadow.py,sha256=MzvslvgEhJQDExPZBLSAClvJk4gDgfF3vafVx2VukkM,3384
+Cython/Tests/TestStringIOTree.py,sha256=vTuu3z32WTcmJaf0fBq62NMghYtaPL2rRnfdl2WM--4,1946
+Cython/Tests/TestTestUtils.py,sha256=6GJdzk66ewwC-ds132IzcmAhLWr8Oc9Ae18gFccwdxY,2966
+Cython/Tests/__init__.py,sha256=jOqtmPLCvMCq0xVMwGekuLpBmVgq0xtPFmUePySdOjs,13
+Cython/Tests/__pycache__/TestCodeWriter.cpython-311.pyc,,
+Cython/Tests/__pycache__/TestCythonUtils.cpython-311.pyc,,
+Cython/Tests/__pycache__/TestJediTyper.cpython-311.pyc,,
+Cython/Tests/__pycache__/TestShadow.cpython-311.pyc,,
+Cython/Tests/__pycache__/TestStringIOTree.cpython-311.pyc,,
+Cython/Tests/__pycache__/TestTestUtils.cpython-311.pyc,,
+Cython/Tests/__pycache__/__init__.cpython-311.pyc,,
+Cython/Tests/__pycache__/xmlrunner.cpython-311.pyc,,
+Cython/Tests/xmlrunner.py,sha256=9RrsdLNoOwd5nbqwxE_dWugLJ4RYdbP2t-0prJVpODM,14777
+Cython/Utility/AsyncGen.c,sha256=L8bb7P7lBEjfxURalqug0o4Soljs58FSlDbpRPMh1bQ,48376
+Cython/Utility/Buffer.c,sha256=JzuEsbFEMziYhHd2z-teXGwztKq2Lxioy1YKbbcSgrs,29910
+Cython/Utility/Builtins.c,sha256=ER4FCul2WdtlTRhFSqrdjI9gOzpf1S2CN0YIeZFq_w0,19205
+Cython/Utility/CConvert.pyx,sha256=EIC2CoisktkTpi_68-SF5eyftd6356t8W1c6dGQfx28,4419
+Cython/Utility/CMath.c,sha256=GIc7gd2WzaZryDJM3tefqXifLJpUJs6_T_c_mFrr-s8,2566
+Cython/Utility/CommonStructures.c,sha256=02ZcCAT2bXhZm2HJ1AIdx4fK0-TALfcI6GavxMVnDk4,4690
+Cython/Utility/Complex.c,sha256=91iLlSVz9zZ7fPiSPdRoKddG_yEQJXOt3eBd6dAbjXo,13609
+Cython/Utility/Coroutine.c,sha256=ofL1T1lkWx259qNTpPz5B_1AAmQOiejpfurJV-W11ko,99284
+Cython/Utility/CpdefEnums.pyx,sha256=R96TnoDtZucC9qvWmbQn3kuhxggugUQP5Pp5Vgmhwp4,6040
+Cython/Utility/CppConvert.pyx,sha256=tolYphcqNtj1KfxJLz1q76Js-JN-EMeuCBuN1N0N-ZU,7054
+Cython/Utility/CppSupport.cpp,sha256=B-nq6TcgMFFWfnZL2K7UhE_b0lZyjsuI6c-yQ9tzsv8,4934
+Cython/Utility/CythonFunction.c,sha256=mQdzqyxYMxKV-wPIUFPsyPDVIkyqkbKDC6riUShoay4,64260
+Cython/Utility/Dataclasses.c,sha256=Yky76ur34ZYi8mijd1ceC0Jc06B9aPEYBUu-LS5VSs0,7271
+Cython/Utility/Dataclasses.py,sha256=3lSw4xyskxbh6fyHKkYD_98nVWjZRpMQ5jnJQDtE0A0,4077
+Cython/Utility/Embed.c,sha256=JbXpWihTK9bq9rBhWMyaImZu8eTUvrrU6cWY-LZ8wA8,7436
+Cython/Utility/Exceptions.c,sha256=oidvxTU8mYMz9JMl7-ZZgrikCyIKLc8Gl5ovJu024rw,38955
+Cython/Utility/ExtensionTypes.c,sha256=t7ikHM9WDO8h8_WcCv8f_glW3mywGEylM96JFVSCtKM,25417
+Cython/Utility/FunctionArguments.c,sha256=nw4Cb-n8Mk4XrJhEj__iIjxT3EtA_XSnPHmlGAP6ukY,20740
+Cython/Utility/ImportExport.c,sha256=YeFwS6w-by14oI2KG17u04qz0yQLiNUUFmeRmsWnSYI,29972
+Cython/Utility/MemoryView.pyx,sha256=bMO2DFBecbQiO07engC4n2iUTI3RvAhR7c0lTa73b94,49594
+Cython/Utility/MemoryView_C.c,sha256=kEZ87RvCQcqTxcaWcPUVn4WgDJsDbCla1HqEbf8NFDE,31647
+Cython/Utility/ModuleSetupCode.c,sha256=fjXvPH6bwfyyRHeZzeCFxFeYryeFscW2h9BSVlCfzk8,86132
+Cython/Utility/NumpyImportArray.c,sha256=Gwo493DF8JxUxhTTjJYIdyHHJ9TEwFKqDmKsdk_uPyw,2033
+Cython/Utility/ObjectHandling.c,sha256=UTQYetFVANoYfOLAGc3IyicfkSMy3Vm6KtjJd-ajLds,116556
+Cython/Utility/Optimize.c,sha256=TpJPminM-vsQdslaVSu65LhaCnOyCMIcyj9hSTpTu8A,61029
+Cython/Utility/Overflow.c,sha256=1kwFjE2a3mdCG9gAlamP16tBjuNWFhs8s7UyHAQ2JkY,15874
+Cython/Utility/Printing.c,sha256=o8XnfjNIT8Ub5KY4FAp_FNw-OE3xqjy0MgmYWgDcWao,5103
+Cython/Utility/Profile.c,sha256=ZAO6vlT0FiQ5eXWl_JlmvQcFvrFiUov-RGLP3Gl-d78,18194
+Cython/Utility/StringTools.c,sha256=YaxeLKr6Dtu-HGJHk2tUSTolQfboMomsG0lb5rqG79A,45790
+Cython/Utility/TestCyUtilityLoader.pyx,sha256=91lWWJub7l_6xNn3ncrvQZZ94RpkQzEx2NtAaFpvrxY,152
+Cython/Utility/TestCythonScope.pyx,sha256=oE9x2UaH2KoyheZxKlRCCphtW8R4esePuJo4LoGh1Nc,1795
+Cython/Utility/TestUtilityLoader.c,sha256=dGy6ZWL2kBqtmUY7kF75UEox5kadQZ__BmZKscwg2aY,279
+Cython/Utility/TypeConversion.c,sha256=8OlHSjFUIAAeWQTP2FBhc5KBYXUCy9uXnpYblFxPAoA,47910
+Cython/Utility/UFuncs.pyx,sha256=dF32cppwl4Lelmpa7COgmRh1Vv4GD4uLhHG15g4E6gQ,2179
+Cython/Utility/UFuncs_C.c,sha256=BqiTcx1h5iINFAd3IubUHNEi8u_A1O_E-BOAf2J27d0,1519
+Cython/Utility/__init__.py,sha256=t2bpY-TYSX8lJdbKuBFJ1kBfpWVzgGw4xoZlCKfyj_s,1159
+Cython/Utility/__pycache__/Dataclasses.cpython-311.pyc,,
+Cython/Utility/__pycache__/__init__.cpython-311.pyc,,
+Cython/Utility/arrayarray.h,sha256=3Ll8Gd_S4rv8HaTfg5i6-aaoB9taI1vzwTp7NeA7Wy0,4089
+Cython/Utils.cpython-311-x86_64-linux-gnu.so,sha256=86qw6F2IwaGLvptyDxJsEVwioWuR7oAG29HW-l3gmes,396760
+Cython/Utils.py,sha256=_YpSLV29bS00oQLGqmTkgRxNXfFKAH1kyUtiQ7bO92I,22079
+Cython/__init__.py,sha256=GMnkoIas6hfN_meqZAJF9BEs1NuY4-4B2L0Uls7hXaA,358
+Cython/__pycache__/CodeWriter.cpython-311.pyc,,
+Cython/__pycache__/Coverage.cpython-311.pyc,,
+Cython/__pycache__/Debugging.cpython-311.pyc,,
+Cython/__pycache__/Shadow.cpython-311.pyc,,
+Cython/__pycache__/StringIOTree.cpython-311.pyc,,
+Cython/__pycache__/TestUtils.cpython-311.pyc,,
+Cython/__pycache__/Utils.cpython-311.pyc,,
+Cython/__pycache__/__init__.cpython-311.pyc,,
+__pycache__/cython.cpython-311.pyc,,
+cython.py,sha256=z2AtgHBGh0x0h0ZcGje7IhYlR6nGH_MmOh1fFMjqYn0,520
+pyximport/__init__.py,sha256=9hOyKolFtOerPiVEyktKrT1VtzbGexq9UmORzo52iHI,79
+pyximport/__pycache__/__init__.cpython-311.pyc,,
+pyximport/__pycache__/_pyximport2.cpython-311.pyc,,
+pyximport/__pycache__/_pyximport3.cpython-311.pyc,,
+pyximport/__pycache__/pyxbuild.cpython-311.pyc,,
+pyximport/__pycache__/pyximport.cpython-311.pyc,,
+pyximport/_pyximport2.py,sha256=mklesc9aVvPvUqWHXZhxlHF4rVrrirz1FFqJ30_x5IU,24364
+pyximport/_pyximport3.py,sha256=dGzBogaWn9eIWWyTZ9Un1jELxh8BdmSe3Fbxc3teX4M,18380
+pyximport/pyxbuild.py,sha256=AsL1tyLxG61Mj7Ah-DxtDBuaXF94W2Tb6KTos7r0w8I,5702
+pyximport/pyximport.py,sha256=23hjqx86b50J1MLmDBWBu_ESWLi1V7CoBzUYOKJi5oI,321

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython-3.0.11.dist-info/WHEEL

@@ -0,0 +1,6 @@
+Wheel-Version: 1.0
+Generator: setuptools (72.1.0)
+Root-Is-Purelib: false
+Tag: cp311-cp311-manylinux_2_17_x86_64
+Tag: cp311-cp311-manylinux2014_x86_64
+

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython-3.0.11.dist-info/entry_points.txt

@@ -0,0 +1,4 @@
+[console_scripts]
+cygdb = Cython.Debugger.Cygdb:main
+cython = Cython.Compiler.Main:setuptools_main
+cythonize = Cython.Build.Cythonize:main

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython-3.0.11.dist-info/top_level.txt

@@ -0,0 +1,3 @@
+Cython
+cython
+pyximport

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Runtime/__init__.py

@@ -0,0 +1 @@
+# empty file

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Runtime/refnanny.pyx

@@ -0,0 +1,192 @@
+# cython: language_level=3, auto_pickle=False
+
+from cpython.ref cimport PyObject, Py_INCREF, Py_CLEAR, Py_XDECREF, Py_XINCREF
+from cpython.exc cimport PyErr_Fetch, PyErr_Restore
+from cpython.pystate cimport PyThreadState_Get
+
+cimport cython
+
+loglevel = 0
+reflog = []
+
+cdef log(level, action, obj, lineno):
+    if reflog is None:
+        # can happen during finalisation
+        return
+    if loglevel >= level:
+        reflog.append((lineno, action, id(obj)))
+
+LOG_NONE, LOG_ALL = range(2)
+
+@cython.final
+cdef class Context(object):
+    cdef readonly object name, filename
+    cdef readonly dict refs
+    cdef readonly list errors
+    cdef readonly Py_ssize_t start
+
+    def __cinit__(self, name, line=0, filename=None):
+        self.name = name
+        self.start = line
+        self.filename = filename
+        self.refs = {} # id -> (count, [lineno])
+        self.errors = []
+
+    cdef regref(self, obj, Py_ssize_t lineno, bint is_null):
+        log(LOG_ALL, u'regref', u"<NULL>" if is_null else obj, lineno)
+        if is_null:
+            self.errors.append(f"NULL argument on line {lineno}")
+            return
+        id_ = id(obj)
+        count, linenumbers = self.refs.get(id_, (0, []))
+        self.refs[id_] = (count + 1, linenumbers)
+        linenumbers.append(lineno)
+
+    cdef bint delref(self, obj, Py_ssize_t lineno, bint is_null) except -1:
+        # returns whether it is ok to do the decref operation
+        log(LOG_ALL, u'delref', u"<NULL>" if is_null else obj, lineno)
+        if is_null:
+            self.errors.append(f"NULL argument on line {lineno}")
+            return False
+        id_ = id(obj)
+        count, linenumbers = self.refs.get(id_, (0, []))
+        if count == 0:
+            self.errors.append(f"Too many decrefs on line {lineno}, reference acquired on lines {linenumbers!r}")
+            return False
+        if count == 1:
+            del self.refs[id_]
+        else:
+            self.refs[id_] = (count - 1, linenumbers)
+        return True
+
+    cdef end(self):
+        if self.refs:
+            msg = u"References leaked:"
+            for count, linenos in self.refs.itervalues():
+                msg += f"\n  ({count}) acquired on lines: {u', '.join([f'{x}' for x in linenos])}"
+            self.errors.append(msg)
+        return u"\n".join([f'REFNANNY: {error}' for error in self.errors]) if self.errors else None
+
+
+cdef void report_unraisable(filename, Py_ssize_t lineno, object e=None):
+    try:
+        if e is None:
+            import sys
+            e = sys.exc_info()[1]
+        print(f"refnanny raised an exception from {filename}:{lineno}: {e}")
+    finally:
+        return  # We absolutely cannot exit with an exception
+
+
+# All Python operations must happen after any existing
+# exception has been fetched, in case we are called from
+# exception-handling code.
+
+cdef PyObject* SetupContext(char* funcname, Py_ssize_t lineno, char* filename) except NULL:
+    if Context is None:
+        # Context may be None during finalize phase.
+        # In that case, we don't want to be doing anything fancy
+        # like caching and resetting exceptions.
+        return NULL
+    cdef (PyObject*) type = NULL, value = NULL, tb = NULL, result = NULL
+    PyThreadState_Get()  # Check that we hold the GIL
+    PyErr_Fetch(&type, &value, &tb)
+    try:
+        ctx = Context(funcname, lineno, filename)
+        Py_INCREF(ctx)
+        result = <PyObject*>ctx
+    except Exception, e:
+        report_unraisable(filename, lineno, e)
+    PyErr_Restore(type, value, tb)
+    return result
+
+cdef void GOTREF(PyObject* ctx, PyObject* p_obj, Py_ssize_t lineno):
+    if ctx == NULL: return
+    cdef (PyObject*) type = NULL, value = NULL, tb = NULL
+    PyErr_Fetch(&type, &value, &tb)
+    try:
+        (<Context>ctx).regref(
+            <object>p_obj if p_obj is not NULL else None,
+            lineno,
+            is_null=p_obj is NULL,
+        )
+    except:
+        report_unraisable((<Context>ctx).filename, lineno=(<Context>ctx).start)
+    finally:
+        PyErr_Restore(type, value, tb)
+        return  # swallow any exceptions
+
+cdef bint GIVEREF_and_report(PyObject* ctx, PyObject* p_obj, Py_ssize_t lineno):
+    if ctx == NULL: return 1
+    cdef (PyObject*) type = NULL, value = NULL, tb = NULL
+    cdef bint decref_ok = False
+    PyErr_Fetch(&type, &value, &tb)
+    try:
+        decref_ok = (<Context>ctx).delref(
+            <object>p_obj if p_obj is not NULL else None,
+            lineno,
+            is_null=p_obj is NULL,
+        )
+    except:
+        report_unraisable((<Context>ctx).filename, lineno=(<Context>ctx).start)
+    finally:
+        PyErr_Restore(type, value, tb)
+        return decref_ok  # swallow any exceptions
+
+cdef void GIVEREF(PyObject* ctx, PyObject* p_obj, Py_ssize_t lineno):
+    GIVEREF_and_report(ctx, p_obj, lineno)
+
+cdef void INCREF(PyObject* ctx, PyObject* obj, Py_ssize_t lineno):
+    Py_XINCREF(obj)
+    PyThreadState_Get()  # Check that we hold the GIL
+    GOTREF(ctx, obj, lineno)
+
+cdef void DECREF(PyObject* ctx, PyObject* obj, Py_ssize_t lineno):
+    if GIVEREF_and_report(ctx, obj, lineno):
+        Py_XDECREF(obj)
+    PyThreadState_Get()  # Check that we hold the GIL
+
+cdef void FinishContext(PyObject** ctx):
+    if ctx == NULL or ctx[0] == NULL: return
+    cdef (PyObject*) type = NULL, value = NULL, tb = NULL
+    cdef object errors = None
+    cdef Context context
+    PyThreadState_Get()  # Check that we hold the GIL
+    PyErr_Fetch(&type, &value, &tb)
+    try:
+        context = <Context>ctx[0]
+        errors = context.end()
+        if errors:
+            print(f"{context.filename.decode('latin1')}: {context.name.decode('latin1')}()")
+            print(errors)
+        context = None
+    except:
+        report_unraisable(
+            context.filename if context is not None else None,
+            lineno=context.start if context is not None else 0,
+        )
+    finally:
+        Py_CLEAR(ctx[0])
+        PyErr_Restore(type, value, tb)
+        return  # swallow any exceptions
+
+ctypedef struct RefNannyAPIStruct:
+    void (*INCREF)(PyObject*, PyObject*, Py_ssize_t)
+    void (*DECREF)(PyObject*, PyObject*, Py_ssize_t)
+    void (*GOTREF)(PyObject*, PyObject*, Py_ssize_t)
+    void (*GIVEREF)(PyObject*, PyObject*, Py_ssize_t)
+    PyObject* (*SetupContext)(char*, Py_ssize_t, char*) except NULL
+    void (*FinishContext)(PyObject**)
+
+cdef RefNannyAPIStruct api
+api.INCREF = INCREF
+api.DECREF =  DECREF
+api.GOTREF =  GOTREF
+api.GIVEREF = GIVEREF
+api.SetupContext = SetupContext
+api.FinishContext = FinishContext
+
+cdef extern from "Python.h":
+    object PyLong_FromVoidPtr(void*)
+
+RefNannyAPI = PyLong_FromVoidPtr(<void*>&api)

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Utility/AsyncGen.c

@@ -0,0 +1,1317 @@
+// This is copied from genobject.c in CPython 3.6.
+// Try to keep it in sync by doing this from time to time:
+//    sed -e 's|__pyx_||ig'  Cython/Utility/AsyncGen.c | diff -udw - cpython/Objects/genobject.c | less
+
+//////////////////// AsyncGenerator.proto ////////////////////
+//@requires: Coroutine.c::Coroutine
+
+#define __Pyx_AsyncGen_USED
+typedef struct {
+    __pyx_CoroutineObject coro;
+    PyObject *ag_finalizer;
+    int ag_hooks_inited;
+    int ag_closed;
+    int ag_running_async;
+} __pyx_PyAsyncGenObject;
+
+static PyTypeObject *__pyx__PyAsyncGenWrappedValueType = 0;
+static PyTypeObject *__pyx__PyAsyncGenASendType = 0;
+static PyTypeObject *__pyx__PyAsyncGenAThrowType = 0;
+static PyTypeObject *__pyx_AsyncGenType = 0;
+
+#define __Pyx_AsyncGen_CheckExact(obj) __Pyx_IS_TYPE(obj, __pyx_AsyncGenType)
+#define __pyx_PyAsyncGenASend_CheckExact(o) \
+                    __Pyx_IS_TYPE(o, __pyx__PyAsyncGenASendType)
+#define __pyx_PyAsyncGenAThrow_CheckExact(o) \
+                    __Pyx_IS_TYPE(o, __pyx__PyAsyncGenAThrowType)
+
+static PyObject *__Pyx_async_gen_anext(PyObject *o);
+static CYTHON_INLINE PyObject *__Pyx_async_gen_asend_iternext(PyObject *o);
+static PyObject *__Pyx_async_gen_asend_send(PyObject *o, PyObject *arg);
+static PyObject *__Pyx_async_gen_asend_close(PyObject *o, PyObject *args);
+static PyObject *__Pyx_async_gen_athrow_close(PyObject *o, PyObject *args);
+
+static PyObject *__Pyx__PyAsyncGenValueWrapperNew(PyObject *val);
+
+
+static __pyx_CoroutineObject *__Pyx_AsyncGen_New(
+            __pyx_coroutine_body_t body, PyObject *code, PyObject *closure,
+            PyObject *name, PyObject *qualname, PyObject *module_name) {
+    __pyx_PyAsyncGenObject *gen = PyObject_GC_New(__pyx_PyAsyncGenObject, __pyx_AsyncGenType);
+    if (unlikely(!gen))
+        return NULL;
+    gen->ag_finalizer = NULL;
+    gen->ag_closed = 0;
+    gen->ag_hooks_inited = 0;
+    gen->ag_running_async = 0;
+    return __Pyx__Coroutine_NewInit((__pyx_CoroutineObject*)gen, body, code, closure, name, qualname, module_name);
+}
+
+static int __pyx_AsyncGen_init(PyObject *module);
+static void __Pyx_PyAsyncGen_Fini(void);
+
+//////////////////// AsyncGenerator.cleanup ////////////////////
+
+__Pyx_PyAsyncGen_Fini();
+
+//////////////////// AsyncGeneratorInitFinalizer ////////////////////
+
+// this is separated out because it needs more adaptation
+
+#if PY_VERSION_HEX < 0x030600B0
+static int __Pyx_async_gen_init_hooks(__pyx_PyAsyncGenObject *o) {
+#if 0
+    // TODO: implement finalizer support in older Python versions
+    PyThreadState *tstate;
+    PyObject *finalizer;
+    PyObject *firstiter;
+#endif
+
+    if (likely(o->ag_hooks_inited)) {
+        return 0;
+    }
+
+    o->ag_hooks_inited = 1;
+
+#if 0
+    tstate = __Pyx_PyThreadState_Current;
+
+    finalizer = tstate->async_gen_finalizer;
+    if (finalizer) {
+        Py_INCREF(finalizer);
+        o->ag_finalizer = finalizer;
+    }
+
+    firstiter = tstate->async_gen_firstiter;
+    if (firstiter) {
+        PyObject *res;
+
+        Py_INCREF(firstiter);
+        res = __Pyx_PyObject_CallOneArg(firstiter, (PyObject*)o);
+        Py_DECREF(firstiter);
+        if (res == NULL) {
+            return 1;
+        }
+        Py_DECREF(res);
+    }
+#endif
+
+    return 0;
+}
+#endif
+
+
+//////////////////// AsyncGenerator ////////////////////
+//@requires: AsyncGeneratorInitFinalizer
+//@requires: Coroutine.c::Coroutine
+//@requires: Coroutine.c::ReturnWithStopIteration
+//@requires: ObjectHandling.c::PyObjectCall2Args
+//@requires: ObjectHandling.c::PyObject_GenericGetAttrNoDict
+
+PyDoc_STRVAR(__Pyx_async_gen_send_doc,
+"send(arg) -> send 'arg' into generator,\n\
+return next yielded value or raise StopIteration.");
+
+PyDoc_STRVAR(__Pyx_async_gen_close_doc,
+"close() -> raise GeneratorExit inside generator.");
+
+PyDoc_STRVAR(__Pyx_async_gen_throw_doc,
+"throw(typ[,val[,tb]]) -> raise exception in generator,\n\
+return next yielded value or raise StopIteration.");
+
+PyDoc_STRVAR(__Pyx_async_gen_await_doc,
+"__await__() -> return a representation that can be passed into the 'await' expression.");
+
+// COPY STARTS HERE:
+
+static PyObject *__Pyx_async_gen_asend_new(__pyx_PyAsyncGenObject *, PyObject *);
+static PyObject *__Pyx_async_gen_athrow_new(__pyx_PyAsyncGenObject *, PyObject *);
+
+static const char *__Pyx_NON_INIT_CORO_MSG = "can't send non-None value to a just-started coroutine";
+static const char *__Pyx_ASYNC_GEN_IGNORED_EXIT_MSG = "async generator ignored GeneratorExit";
+static const char *__Pyx_ASYNC_GEN_CANNOT_REUSE_SEND_MSG = "cannot reuse already awaited __anext__()/asend()";
+static const char *__Pyx_ASYNC_GEN_CANNOT_REUSE_CLOSE_MSG = "cannot reuse already awaited aclose()/athrow()";
+
+typedef enum {
+    __PYX_AWAITABLE_STATE_INIT,   /* new awaitable, has not yet been iterated */
+    __PYX_AWAITABLE_STATE_ITER,   /* being iterated */
+    __PYX_AWAITABLE_STATE_CLOSED, /* closed */
+} __pyx_AwaitableState;
+
+typedef struct {
+    PyObject_HEAD
+    __pyx_PyAsyncGenObject *ags_gen;
+
+    /* Can be NULL, when in the __anext__() mode (equivalent of "asend(None)") */
+    PyObject *ags_sendval;
+
+    __pyx_AwaitableState ags_state;
+} __pyx_PyAsyncGenASend;
+
+
+typedef struct {
+    PyObject_HEAD
+    __pyx_PyAsyncGenObject *agt_gen;
+
+    /* Can be NULL, when in the "aclose()" mode (equivalent of "athrow(GeneratorExit)") */
+    PyObject *agt_args;
+
+    __pyx_AwaitableState agt_state;
+} __pyx_PyAsyncGenAThrow;
+
+
+typedef struct {
+    PyObject_HEAD
+    PyObject *agw_val;
+} __pyx__PyAsyncGenWrappedValue;
+
+
+#ifndef _PyAsyncGen_MAXFREELIST
+#define _PyAsyncGen_MAXFREELIST 80
+#endif
+
+// Freelists boost performance 6-10%; they also reduce memory
+// fragmentation, as _PyAsyncGenWrappedValue and PyAsyncGenASend
+// are short-living objects that are instantiated for every
+// __anext__ call.
+
+static __pyx__PyAsyncGenWrappedValue *__Pyx_ag_value_freelist[_PyAsyncGen_MAXFREELIST];
+static int __Pyx_ag_value_freelist_free = 0;
+
+static __pyx_PyAsyncGenASend *__Pyx_ag_asend_freelist[_PyAsyncGen_MAXFREELIST];
+static int __Pyx_ag_asend_freelist_free = 0;
+
+#define __pyx__PyAsyncGenWrappedValue_CheckExact(o) \
+                    __Pyx_IS_TYPE(o, __pyx__PyAsyncGenWrappedValueType)
+
+
+static int
+__Pyx_async_gen_traverse(__pyx_PyAsyncGenObject *gen, visitproc visit, void *arg)
+{
+    Py_VISIT(gen->ag_finalizer);
+    return __Pyx_Coroutine_traverse((__pyx_CoroutineObject*)gen, visit, arg);
+}
+
+
+static PyObject *
+__Pyx_async_gen_repr(__pyx_CoroutineObject *o)
+{
+    // avoid NULL pointer dereference for qualname during garbage collection
+    return PyUnicode_FromFormat("<async_generator object %S at %p>",
+                                o->gi_qualname ? o->gi_qualname : Py_None, o);
+}
+
+
+#if PY_VERSION_HEX >= 0x030600B0
+static int
+__Pyx_async_gen_init_hooks(__pyx_PyAsyncGenObject *o)
+{
+#if !CYTHON_COMPILING_IN_PYPY
+    PyThreadState *tstate;
+#endif
+    PyObject *finalizer;
+    PyObject *firstiter;
+
+    if (o->ag_hooks_inited) {
+        return 0;
+    }
+
+    o->ag_hooks_inited = 1;
+
+#if CYTHON_COMPILING_IN_PYPY
+    finalizer = _PyEval_GetAsyncGenFinalizer();
+#else
+    tstate = __Pyx_PyThreadState_Current;
+    finalizer = tstate->async_gen_finalizer;
+#endif
+    if (finalizer) {
+        Py_INCREF(finalizer);
+        o->ag_finalizer = finalizer;
+    }
+
+#if CYTHON_COMPILING_IN_PYPY
+    firstiter = _PyEval_GetAsyncGenFirstiter();
+#else
+    firstiter = tstate->async_gen_firstiter;
+#endif
+    if (firstiter) {
+        PyObject *res;
+#if CYTHON_UNPACK_METHODS
+        PyObject *self;
+#endif
+
+        Py_INCREF(firstiter);
+        // at least asyncio stores methods here => optimise the call
+#if CYTHON_UNPACK_METHODS
+        if (likely(PyMethod_Check(firstiter)) && likely((self = PyMethod_GET_SELF(firstiter)) != NULL)) {
+            PyObject *function = PyMethod_GET_FUNCTION(firstiter);
+            res = __Pyx_PyObject_Call2Args(function, self, (PyObject*)o);
+        } else
+#endif
+        res = __Pyx_PyObject_CallOneArg(firstiter, (PyObject*)o);
+
+        Py_DECREF(firstiter);
+        if (unlikely(res == NULL)) {
+            return 1;
+        }
+        Py_DECREF(res);
+    }
+
+    return 0;
+}
+#endif
+
+
+static PyObject *
+__Pyx_async_gen_anext(PyObject *g)
+{
+    __pyx_PyAsyncGenObject *o = (__pyx_PyAsyncGenObject*) g;
+    if (unlikely(__Pyx_async_gen_init_hooks(o))) {
+        return NULL;
+    }
+    return __Pyx_async_gen_asend_new(o, NULL);
+}
+
+static PyObject *
+__Pyx_async_gen_anext_method(PyObject *g, PyObject *arg) {
+    CYTHON_UNUSED_VAR(arg);
+    return __Pyx_async_gen_anext(g);
+}
+
+
+static PyObject *
+__Pyx_async_gen_asend(__pyx_PyAsyncGenObject *o, PyObject *arg)
+{
+    if (unlikely(__Pyx_async_gen_init_hooks(o))) {
+        return NULL;
+    }
+    return __Pyx_async_gen_asend_new(o, arg);
+}
+
+
+static PyObject *
+__Pyx_async_gen_aclose(__pyx_PyAsyncGenObject *o, PyObject *arg)
+{
+    CYTHON_UNUSED_VAR(arg);
+    if (unlikely(__Pyx_async_gen_init_hooks(o))) {
+        return NULL;
+    }
+    return __Pyx_async_gen_athrow_new(o, NULL);
+}
+
+
+static PyObject *
+__Pyx_async_gen_athrow(__pyx_PyAsyncGenObject *o, PyObject *args)
+{
+    if (unlikely(__Pyx_async_gen_init_hooks(o))) {
+        return NULL;
+    }
+    return __Pyx_async_gen_athrow_new(o, args);
+}
+
+
+static PyObject *
+__Pyx_async_gen_self_method(PyObject *g, PyObject *arg) {
+    CYTHON_UNUSED_VAR(arg);
+    return __Pyx_NewRef(g);
+}
+
+
+static PyGetSetDef __Pyx_async_gen_getsetlist[] = {
+    {(char*) "__name__", (getter)__Pyx_Coroutine_get_name, (setter)__Pyx_Coroutine_set_name,
+     (char*) PyDoc_STR("name of the async generator"), 0},
+    {(char*) "__qualname__", (getter)__Pyx_Coroutine_get_qualname, (setter)__Pyx_Coroutine_set_qualname,
+     (char*) PyDoc_STR("qualified name of the async generator"), 0},
+    //REMOVED: {(char*) "ag_await", (getter)coro_get_cr_await, NULL,
+    //REMOVED:  (char*) PyDoc_STR("object being awaited on, or None")},
+    {0, 0, 0, 0, 0} /* Sentinel */
+};
+
+static PyMemberDef __Pyx_async_gen_memberlist[] = {
+    //REMOVED: {(char*) "ag_frame",   T_OBJECT, offsetof(__pyx_PyAsyncGenObject, ag_frame),   READONLY},
+    {(char*) "ag_running", T_BOOL,   offsetof(__pyx_PyAsyncGenObject, ag_running_async), READONLY, NULL},
+    //REMOVED: {(char*) "ag_code",    T_OBJECT, offsetof(__pyx_PyAsyncGenObject, ag_code),    READONLY},
+    //ADDED: "ag_await"
+    {(char*) "ag_await", T_OBJECT, offsetof(__pyx_CoroutineObject, yieldfrom), READONLY,
+     (char*) PyDoc_STR("object being awaited on, or None")},
+    {(char *) "__module__", T_OBJECT, offsetof(__pyx_CoroutineObject, gi_modulename), 0, 0},
+#if CYTHON_USE_TYPE_SPECS
+    {(char *) "__weaklistoffset__", T_PYSSIZET, offsetof(__pyx_CoroutineObject, gi_weakreflist), READONLY, 0},
+#endif
+    {0, 0, 0, 0, 0}      /* Sentinel */
+};
+
+PyDoc_STRVAR(__Pyx_async_aclose_doc,
+"aclose() -> raise GeneratorExit inside generator.");
+
+PyDoc_STRVAR(__Pyx_async_asend_doc,
+"asend(v) -> send 'v' in generator.");
+
+PyDoc_STRVAR(__Pyx_async_athrow_doc,
+"athrow(typ[,val[,tb]]) -> raise exception in generator.");
+
+PyDoc_STRVAR(__Pyx_async_aiter_doc,
+"__aiter__(v) -> return an asynchronous iterator.");
+
+PyDoc_STRVAR(__Pyx_async_anext_doc,
+"__anext__(v) -> continue asynchronous iteration and return the next element.");
+
+static PyMethodDef __Pyx_async_gen_methods[] = {
+    {"asend", (PyCFunction)__Pyx_async_gen_asend, METH_O, __Pyx_async_asend_doc},
+    {"athrow",(PyCFunction)__Pyx_async_gen_athrow, METH_VARARGS, __Pyx_async_athrow_doc},
+    {"aclose", (PyCFunction)__Pyx_async_gen_aclose, METH_NOARGS, __Pyx_async_aclose_doc},
+    {"__aiter__", (PyCFunction)__Pyx_async_gen_self_method, METH_NOARGS, __Pyx_async_aiter_doc},
+    {"__anext__", (PyCFunction)__Pyx_async_gen_anext_method, METH_NOARGS, __Pyx_async_anext_doc},
+    {0, 0, 0, 0}        /* Sentinel */
+};
+
+
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx_AsyncGenType_slots[] = {
+    {Py_tp_dealloc, (void *)__Pyx_Coroutine_dealloc},
+    {Py_am_aiter, (void *)PyObject_SelfIter},
+    {Py_am_anext, (void *)__Pyx_async_gen_anext},
+    {Py_tp_repr, (void *)__Pyx_async_gen_repr},
+    {Py_tp_traverse, (void *)__Pyx_async_gen_traverse},
+    {Py_tp_methods, (void *)__Pyx_async_gen_methods},
+    {Py_tp_members, (void *)__Pyx_async_gen_memberlist},
+    {Py_tp_getset, (void *)__Pyx_async_gen_getsetlist},
+#if CYTHON_USE_TP_FINALIZE
+    {Py_tp_finalize, (void *)__Pyx_Coroutine_del},
+#endif
+    {0, 0},
+};
+
+static PyType_Spec __pyx_AsyncGenType_spec = {
+    __PYX_TYPE_MODULE_PREFIX "async_generator",
+    sizeof(__pyx_PyAsyncGenObject),
+    0,
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_HAVE_FINALIZE, /*tp_flags*/
+    __pyx_AsyncGenType_slots
+};
+#else /* CYTHON_USE_TYPE_SPECS */
+
+#if CYTHON_USE_ASYNC_SLOTS
+static __Pyx_PyAsyncMethodsStruct __Pyx_async_gen_as_async = {
+    0,                                          /* am_await */
+    PyObject_SelfIter,                          /* am_aiter */
+    (unaryfunc)__Pyx_async_gen_anext,           /* am_anext */
+#if PY_VERSION_HEX >= 0x030A00A3
+    0, /*am_send*/
+#endif
+};
+#endif
+
+static PyTypeObject __pyx_AsyncGenType_type = {
+    PyVarObject_HEAD_INIT(0, 0)
+    "async_generator",                          /* tp_name */
+    sizeof(__pyx_PyAsyncGenObject),             /* tp_basicsize */
+    0,                                          /* tp_itemsize */
+    (destructor)__Pyx_Coroutine_dealloc,        /* tp_dealloc */
+    0,                                          /* tp_vectorcall_offset */
+    0,                                          /* tp_getattr */
+    0,                                          /* tp_setattr */
+#if CYTHON_USE_ASYNC_SLOTS
+    &__Pyx_async_gen_as_async,                        /* tp_as_async */
+#else
+    0,                                          /*tp_reserved*/
+#endif
+    (reprfunc)__Pyx_async_gen_repr,                   /* tp_repr */
+    0,                                          /* tp_as_number */
+    0,                                          /* tp_as_sequence */
+    0,                                          /* tp_as_mapping */
+    0,                                          /* tp_hash */
+    0,                                          /* tp_call */
+    0,                                          /* tp_str */
+    0,                                          /* tp_getattro */
+    0,                                          /* tp_setattro */
+    0,                                          /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC |
+        Py_TPFLAGS_HAVE_FINALIZE,               /* tp_flags */
+    0,                                          /* tp_doc */
+    (traverseproc)__Pyx_async_gen_traverse,           /* tp_traverse */
+    0,                                          /* tp_clear */
+#if CYTHON_USE_ASYNC_SLOTS && CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 && PY_VERSION_HEX < 0x030500B1
+    // in order to (mis-)use tp_reserved above, we must also implement tp_richcompare
+    __Pyx_Coroutine_compare,            /*tp_richcompare*/
+#else
+    0,                                  /*tp_richcompare*/
+#endif
+    offsetof(__pyx_CoroutineObject, gi_weakreflist), /* tp_weaklistoffset */
+    0,                                          /* tp_iter */
+    0,                                          /* tp_iternext */
+    __Pyx_async_gen_methods,                          /* tp_methods */
+    __Pyx_async_gen_memberlist,                       /* tp_members */
+    __Pyx_async_gen_getsetlist,                       /* tp_getset */
+    0,                                          /* tp_base */
+    0,                                          /* tp_dict */
+    0,                                          /* tp_descr_get */
+    0,                                          /* tp_descr_set */
+    0,                                          /* tp_dictoffset */
+    0,                                          /* tp_init */
+    0,                                          /* tp_alloc */
+    0,                                          /* tp_new */
+    0,                                          /* tp_free */
+    0,                                          /* tp_is_gc */
+    0,                                          /* tp_bases */
+    0,                                          /* tp_mro */
+    0,                                          /* tp_cache */
+    0,                                          /* tp_subclasses */
+    0,                                          /* tp_weaklist */
+#if CYTHON_USE_TP_FINALIZE
+    0,                                  /*tp_del*/
+#else
+    __Pyx_Coroutine_del,                /*tp_del*/
+#endif
+    0,                                          /* tp_version_tag */
+#if CYTHON_USE_TP_FINALIZE
+    __Pyx_Coroutine_del,                        /* tp_finalize */
+#elif PY_VERSION_HEX >= 0x030400a1
+    0,                                          /* tp_finalize */
+#endif
+#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
+    0,                                          /*tp_vectorcall*/
+#endif
+#if __PYX_NEED_TP_PRINT_SLOT
+    0,                                          /*tp_print*/
+#endif
+#if PY_VERSION_HEX >= 0x030C0000
+    0,                                          /*tp_watched*/
+#endif
+#if PY_VERSION_HEX >= 0x030d00A4
+    0,                                          /*tp_versions_used*/
+#endif
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
+    0,                                          /*tp_pypy_flags*/
+#endif
+};
+#endif  /* CYTHON_USE_TYPE_SPECS */
+
+
+static int
+__Pyx_PyAsyncGen_ClearFreeLists(void)
+{
+    int ret = __Pyx_ag_value_freelist_free + __Pyx_ag_asend_freelist_free;
+
+    while (__Pyx_ag_value_freelist_free) {
+        __pyx__PyAsyncGenWrappedValue *o;
+        o = __Pyx_ag_value_freelist[--__Pyx_ag_value_freelist_free];
+        assert(__pyx__PyAsyncGenWrappedValue_CheckExact(o));
+        __Pyx_PyHeapTypeObject_GC_Del(o);
+    }
+
+    while (__Pyx_ag_asend_freelist_free) {
+        __pyx_PyAsyncGenASend *o;
+        o = __Pyx_ag_asend_freelist[--__Pyx_ag_asend_freelist_free];
+        assert(__Pyx_IS_TYPE(o, __pyx__PyAsyncGenASendType));
+        __Pyx_PyHeapTypeObject_GC_Del(o);
+    }
+
+    return ret;
+}
+
+static void
+__Pyx_PyAsyncGen_Fini(void)
+{
+    __Pyx_PyAsyncGen_ClearFreeLists();
+}
+
+
+static PyObject *
+__Pyx_async_gen_unwrap_value(__pyx_PyAsyncGenObject *gen, PyObject *result)
+{
+    if (result == NULL) {
+        PyObject *exc_type = PyErr_Occurred();
+        if (!exc_type) {
+            PyErr_SetNone(__Pyx_PyExc_StopAsyncIteration);
+            gen->ag_closed = 1;
+        } else if (__Pyx_PyErr_GivenExceptionMatches2(exc_type, __Pyx_PyExc_StopAsyncIteration, PyExc_GeneratorExit)) {
+            gen->ag_closed = 1;
+        }
+
+        gen->ag_running_async = 0;
+        return NULL;
+    }
+
+    if (__pyx__PyAsyncGenWrappedValue_CheckExact(result)) {
+        /* async yield */
+        __Pyx_ReturnWithStopIteration(((__pyx__PyAsyncGenWrappedValue*)result)->agw_val);
+        Py_DECREF(result);
+        gen->ag_running_async = 0;
+        return NULL;
+    }
+
+    return result;
+}
+
+
+/* ---------- Async Generator ASend Awaitable ------------ */
+
+
+static void
+__Pyx_async_gen_asend_dealloc(__pyx_PyAsyncGenASend *o)
+{
+    PyObject_GC_UnTrack((PyObject *)o);
+    Py_CLEAR(o->ags_gen);
+    Py_CLEAR(o->ags_sendval);
+    if (likely(__Pyx_ag_asend_freelist_free < _PyAsyncGen_MAXFREELIST)) {
+        assert(__pyx_PyAsyncGenASend_CheckExact(o));
+        __Pyx_ag_asend_freelist[__Pyx_ag_asend_freelist_free++] = o;
+    } else {
+        __Pyx_PyHeapTypeObject_GC_Del(o);
+    }
+}
+
+static int
+__Pyx_async_gen_asend_traverse(__pyx_PyAsyncGenASend *o, visitproc visit, void *arg)
+{
+    Py_VISIT(o->ags_gen);
+    Py_VISIT(o->ags_sendval);
+    return 0;
+}
+
+
+static PyObject *
+__Pyx_async_gen_asend_send(PyObject *g, PyObject *arg)
+{
+    __pyx_PyAsyncGenASend *o = (__pyx_PyAsyncGenASend*) g;
+    PyObject *result;
+
+    if (unlikely(o->ags_state == __PYX_AWAITABLE_STATE_CLOSED)) {
+        PyErr_SetString(PyExc_RuntimeError, __Pyx_ASYNC_GEN_CANNOT_REUSE_SEND_MSG);
+        return NULL;
+    }
+
+    if (o->ags_state == __PYX_AWAITABLE_STATE_INIT) {
+        if (unlikely(o->ags_gen->ag_running_async)) {
+            PyErr_SetString(
+                PyExc_RuntimeError,
+                "anext(): asynchronous generator is already running");
+            return NULL;
+        }
+
+        if (arg == NULL || arg == Py_None) {
+            arg = o->ags_sendval ? o->ags_sendval : Py_None;
+        }
+        o->ags_state = __PYX_AWAITABLE_STATE_ITER;
+    }
+
+    o->ags_gen->ag_running_async = 1;
+    result = __Pyx_Coroutine_Send((PyObject*)o->ags_gen, arg);
+    result = __Pyx_async_gen_unwrap_value(o->ags_gen, result);
+
+    if (result == NULL) {
+        o->ags_state = __PYX_AWAITABLE_STATE_CLOSED;
+    }
+
+    return result;
+}
+
+
+static CYTHON_INLINE PyObject *
+__Pyx_async_gen_asend_iternext(PyObject *o)
+{
+    return __Pyx_async_gen_asend_send(o, Py_None);
+}
+
+
+static PyObject *
+__Pyx_async_gen_asend_throw(__pyx_PyAsyncGenASend *o, PyObject *args)
+{
+    PyObject *result;
+
+    if (unlikely(o->ags_state == __PYX_AWAITABLE_STATE_CLOSED)) {
+        PyErr_SetString(PyExc_RuntimeError, __Pyx_ASYNC_GEN_CANNOT_REUSE_SEND_MSG);
+        return NULL;
+    }
+
+    result = __Pyx_Coroutine_Throw((PyObject*)o->ags_gen, args);
+    result = __Pyx_async_gen_unwrap_value(o->ags_gen, result);
+
+    if (result == NULL) {
+        o->ags_state = __PYX_AWAITABLE_STATE_CLOSED;
+    }
+
+    return result;
+}
+
+
+static PyObject *
+__Pyx_async_gen_asend_close(PyObject *g, PyObject *args)
+{
+    __pyx_PyAsyncGenASend *o = (__pyx_PyAsyncGenASend*) g;
+    CYTHON_UNUSED_VAR(args);
+    o->ags_state = __PYX_AWAITABLE_STATE_CLOSED;
+    Py_RETURN_NONE;
+}
+
+
+static PyMethodDef __Pyx_async_gen_asend_methods[] = {
+    {"send", (PyCFunction)__Pyx_async_gen_asend_send, METH_O, __Pyx_async_gen_send_doc},
+    {"throw", (PyCFunction)__Pyx_async_gen_asend_throw, METH_VARARGS, __Pyx_async_gen_throw_doc},
+    {"close", (PyCFunction)__Pyx_async_gen_asend_close, METH_NOARGS, __Pyx_async_gen_close_doc},
+    {"__await__", (PyCFunction)__Pyx_async_gen_self_method, METH_NOARGS, __Pyx_async_gen_await_doc},
+    {0, 0, 0, 0}        /* Sentinel */
+};
+
+
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx__PyAsyncGenASendType_slots[] = {
+    {Py_tp_dealloc, (void *)__Pyx_async_gen_asend_dealloc},
+    {Py_am_await, (void *)PyObject_SelfIter},
+    {Py_tp_traverse, (void *)__Pyx_async_gen_asend_traverse},
+    {Py_tp_methods, (void *)__Pyx_async_gen_asend_methods},
+    {Py_tp_iter, (void *)PyObject_SelfIter},
+    {Py_tp_iternext, (void *)__Pyx_async_gen_asend_iternext},
+    {0, 0},
+};
+
+static PyType_Spec __pyx__PyAsyncGenASendType_spec = {
+    __PYX_TYPE_MODULE_PREFIX "async_generator_asend",
+    sizeof(__pyx_PyAsyncGenASend),
+    0,
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
+    __pyx__PyAsyncGenASendType_slots
+};
+#else /* CYTHON_USE_TYPE_SPECS */
+
+#if CYTHON_USE_ASYNC_SLOTS
+static __Pyx_PyAsyncMethodsStruct __Pyx_async_gen_asend_as_async = {
+    PyObject_SelfIter,                          /* am_await */
+    0,                                          /* am_aiter */
+    0,                                          /* am_anext */
+#if PY_VERSION_HEX >= 0x030A00A3
+    0, /*am_send*/
+#endif
+};
+#endif
+
+static PyTypeObject __pyx__PyAsyncGenASendType_type = {
+    PyVarObject_HEAD_INIT(0, 0)
+    "async_generator_asend",                    /* tp_name */
+    sizeof(__pyx_PyAsyncGenASend),                    /* tp_basicsize */
+    0,                                          /* tp_itemsize */
+    /* methods */
+    (destructor)__Pyx_async_gen_asend_dealloc,        /* tp_dealloc */
+    0,                                          /* tp_vectorcall_offset */
+    0,                                          /* tp_getattr */
+    0,                                          /* tp_setattr */
+#if CYTHON_USE_ASYNC_SLOTS
+    &__Pyx_async_gen_asend_as_async,                  /* tp_as_async */
+#else
+    0,                                          /*tp_reserved*/
+#endif
+    0,                                          /* tp_repr */
+    0,                                          /* tp_as_number */
+    0,                                          /* tp_as_sequence */
+    0,                                          /* tp_as_mapping */
+    0,                                          /* tp_hash */
+    0,                                          /* tp_call */
+    0,                                          /* tp_str */
+    0,                                          /* tp_getattro */
+    0,                                          /* tp_setattro */
+    0,                                          /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,    /* tp_flags */
+    0,                                          /* tp_doc */
+    (traverseproc)__Pyx_async_gen_asend_traverse,  /* tp_traverse */
+    0,                                          /* tp_clear */
+#if CYTHON_USE_ASYNC_SLOTS && CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 && PY_VERSION_HEX < 0x030500B1
+    // in order to (mis-)use tp_reserved above, we must also implement tp_richcompare
+    __Pyx_Coroutine_compare,            /*tp_richcompare*/
+#else
+    0,                                  /*tp_richcompare*/
+#endif
+    0,                                          /* tp_weaklistoffset */
+    PyObject_SelfIter,                          /* tp_iter */
+    (iternextfunc)__Pyx_async_gen_asend_iternext,     /* tp_iternext */
+    __Pyx_async_gen_asend_methods,                    /* tp_methods */
+    0,                                          /* tp_members */
+    0,                                          /* tp_getset */
+    0,                                          /* tp_base */
+    0,                                          /* tp_dict */
+    0,                                          /* tp_descr_get */
+    0,                                          /* tp_descr_set */
+    0,                                          /* tp_dictoffset */
+    0,                                          /* tp_init */
+    0,                                          /* tp_alloc */
+    0,                                          /* tp_new */
+    0,                                          /* tp_free */
+    0,                                          /* tp_is_gc */
+    0,                                          /* tp_bases */
+    0,                                          /* tp_mro */
+    0,                                          /* tp_cache */
+    0,                                          /* tp_subclasses */
+    0,                                          /* tp_weaklist */
+    0,                                          /* tp_del */
+    0,                                          /* tp_version_tag */
+#if PY_VERSION_HEX >= 0x030400a1
+    0,                                          /* tp_finalize */
+#endif
+#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
+    0,                                          /*tp_vectorcall*/
+#endif
+#if __PYX_NEED_TP_PRINT_SLOT
+    0,                                          /*tp_print*/
+#endif
+#if PY_VERSION_HEX >= 0x030C0000
+    0,                                          /*tp_watched*/
+#endif
+#if PY_VERSION_HEX >= 0x030d00A4
+    0,                                          /*tp_versions_used*/
+#endif
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
+    0,                                          /*tp_pypy_flags*/
+#endif
+};
+#endif /* CYTHON_USE_TYPE_SPECS */
+
+
+static PyObject *
+__Pyx_async_gen_asend_new(__pyx_PyAsyncGenObject *gen, PyObject *sendval)
+{
+    __pyx_PyAsyncGenASend *o;
+    if (likely(__Pyx_ag_asend_freelist_free)) {
+        __Pyx_ag_asend_freelist_free--;
+        o = __Pyx_ag_asend_freelist[__Pyx_ag_asend_freelist_free];
+        _Py_NewReference((PyObject *)o);
+    } else {
+        o = PyObject_GC_New(__pyx_PyAsyncGenASend, __pyx__PyAsyncGenASendType);
+        if (unlikely(o == NULL)) {
+            return NULL;
+        }
+    }
+
+    Py_INCREF(gen);
+    o->ags_gen = gen;
+
+    Py_XINCREF(sendval);
+    o->ags_sendval = sendval;
+
+    o->ags_state = __PYX_AWAITABLE_STATE_INIT;
+
+    PyObject_GC_Track((PyObject*)o);
+    return (PyObject*)o;
+}
+
+
+/* ---------- Async Generator Value Wrapper ------------ */
+
+
+static void
+__Pyx_async_gen_wrapped_val_dealloc(__pyx__PyAsyncGenWrappedValue *o)
+{
+    PyObject_GC_UnTrack((PyObject *)o);
+    Py_CLEAR(o->agw_val);
+    if (likely(__Pyx_ag_value_freelist_free < _PyAsyncGen_MAXFREELIST)) {
+        assert(__pyx__PyAsyncGenWrappedValue_CheckExact(o));
+        __Pyx_ag_value_freelist[__Pyx_ag_value_freelist_free++] = o;
+    } else {
+        __Pyx_PyHeapTypeObject_GC_Del(o);
+    }
+}
+
+
+static int
+__Pyx_async_gen_wrapped_val_traverse(__pyx__PyAsyncGenWrappedValue *o,
+                                     visitproc visit, void *arg)
+{
+    Py_VISIT(o->agw_val);
+    return 0;
+}
+
+
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx__PyAsyncGenWrappedValueType_slots[] = {
+    {Py_tp_dealloc, (void *)__Pyx_async_gen_wrapped_val_dealloc},
+    {Py_tp_traverse, (void *)__Pyx_async_gen_wrapped_val_traverse},
+    {0, 0},
+};
+
+static PyType_Spec __pyx__PyAsyncGenWrappedValueType_spec = {
+    __PYX_TYPE_MODULE_PREFIX "async_generator_wrapped_value",
+    sizeof(__pyx__PyAsyncGenWrappedValue),
+    0,
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
+    __pyx__PyAsyncGenWrappedValueType_slots
+};
+#else /* CYTHON_USE_TYPE_SPECS */
+
+static PyTypeObject __pyx__PyAsyncGenWrappedValueType_type = {
+    PyVarObject_HEAD_INIT(0, 0)
+    "async_generator_wrapped_value",            /* tp_name */
+    sizeof(__pyx__PyAsyncGenWrappedValue),            /* tp_basicsize */
+    0,                                          /* tp_itemsize */
+    /* methods */
+    (destructor)__Pyx_async_gen_wrapped_val_dealloc,  /* tp_dealloc */
+    0,                                          /* tp_vectorcall_offset */
+    0,                                          /* tp_getattr */
+    0,                                          /* tp_setattr */
+    0,                                          /* tp_as_async */
+    0,                                          /* tp_repr */
+    0,                                          /* tp_as_number */
+    0,                                          /* tp_as_sequence */
+    0,                                          /* tp_as_mapping */
+    0,                                          /* tp_hash */
+    0,                                          /* tp_call */
+    0,                                          /* tp_str */
+    0,                                          /* tp_getattro */
+    0,                                          /* tp_setattro */
+    0,                                          /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,    /* tp_flags */
+    0,                                          /* tp_doc */
+    (traverseproc)__Pyx_async_gen_wrapped_val_traverse,    /* tp_traverse */
+    0,                                          /* tp_clear */
+    0,                                          /* tp_richcompare */
+    0,                                          /* tp_weaklistoffset */
+    0,                                          /* tp_iter */
+    0,                                          /* tp_iternext */
+    0,                                          /* tp_methods */
+    0,                                          /* tp_members */
+    0,                                          /* tp_getset */
+    0,                                          /* tp_base */
+    0,                                          /* tp_dict */
+    0,                                          /* tp_descr_get */
+    0,                                          /* tp_descr_set */
+    0,                                          /* tp_dictoffset */
+    0,                                          /* tp_init */
+    0,                                          /* tp_alloc */
+    0,                                          /* tp_new */
+    0,                                          /* tp_free */
+    0,                                          /* tp_is_gc */
+    0,                                          /* tp_bases */
+    0,                                          /* tp_mro */
+    0,                                          /* tp_cache */
+    0,                                          /* tp_subclasses */
+    0,                                          /* tp_weaklist */
+    0,                                          /* tp_del */
+    0,                                          /* tp_version_tag */
+#if PY_VERSION_HEX >= 0x030400a1
+    0,                                          /* tp_finalize */
+#endif
+#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
+    0,                                          /*tp_vectorcall*/
+#endif
+#if __PYX_NEED_TP_PRINT_SLOT
+    0,                                          /*tp_print*/
+#endif
+#if PY_VERSION_HEX >= 0x030C0000
+    0,                                          /*tp_watched*/
+#endif
+#if PY_VERSION_HEX >= 0x030d00A4
+    0,                                          /*tp_versions_used*/
+#endif
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
+    0,                                          /*tp_pypy_flags*/
+#endif
+};
+#endif /* CYTHON_USE_TYPE_SPECS */
+
+
+static PyObject *
+__Pyx__PyAsyncGenValueWrapperNew(PyObject *val)
+{
+    // NOTE: steals a reference to val !
+    __pyx__PyAsyncGenWrappedValue *o;
+    assert(val);
+
+    if (likely(__Pyx_ag_value_freelist_free)) {
+        __Pyx_ag_value_freelist_free--;
+        o = __Pyx_ag_value_freelist[__Pyx_ag_value_freelist_free];
+        assert(__pyx__PyAsyncGenWrappedValue_CheckExact(o));
+        _Py_NewReference((PyObject*)o);
+    } else {
+        o = PyObject_GC_New(__pyx__PyAsyncGenWrappedValue, __pyx__PyAsyncGenWrappedValueType);
+        if (unlikely(!o)) {
+            Py_DECREF(val);
+            return NULL;
+        }
+    }
+    o->agw_val = val;
+    // no Py_INCREF(val) - steals reference!
+    PyObject_GC_Track((PyObject*)o);
+    return (PyObject*)o;
+}
+
+
+/* ---------- Async Generator AThrow awaitable ------------ */
+
+
+static void
+__Pyx_async_gen_athrow_dealloc(__pyx_PyAsyncGenAThrow *o)
+{
+    PyObject_GC_UnTrack((PyObject *)o);
+    Py_CLEAR(o->agt_gen);
+    Py_CLEAR(o->agt_args);
+    __Pyx_PyHeapTypeObject_GC_Del(o);
+}
+
+
+static int
+__Pyx_async_gen_athrow_traverse(__pyx_PyAsyncGenAThrow *o, visitproc visit, void *arg)
+{
+    Py_VISIT(o->agt_gen);
+    Py_VISIT(o->agt_args);
+    return 0;
+}
+
+
+static PyObject *
+__Pyx_async_gen_athrow_send(__pyx_PyAsyncGenAThrow *o, PyObject *arg)
+{
+    __pyx_CoroutineObject *gen = (__pyx_CoroutineObject*)o->agt_gen;
+    PyObject *retval, *exc_type;
+
+    if (unlikely(o->agt_state == __PYX_AWAITABLE_STATE_CLOSED)) {
+        PyErr_SetString(PyExc_RuntimeError, __Pyx_ASYNC_GEN_CANNOT_REUSE_CLOSE_MSG);
+        return NULL;
+    }
+
+    if (unlikely(gen->resume_label == -1)) {
+        // already run past the end
+        o->agt_state = __PYX_AWAITABLE_STATE_CLOSED;
+        PyErr_SetNone(PyExc_StopIteration);
+        return NULL;
+    }
+
+    if (o->agt_state == __PYX_AWAITABLE_STATE_INIT) {
+        if (unlikely(o->agt_gen->ag_running_async)) {
+            o->agt_state = __PYX_AWAITABLE_STATE_CLOSED;
+            if (o->agt_args == NULL) {
+                PyErr_SetString(
+                    PyExc_RuntimeError,
+                    "aclose(): asynchronous generator is already running");
+            } else {
+                PyErr_SetString(
+                    PyExc_RuntimeError,
+                    "athrow(): asynchronous generator is already running");
+            }
+            return NULL;
+        }
+
+        if (unlikely(o->agt_gen->ag_closed)) {
+            o->agt_state = __PYX_AWAITABLE_STATE_CLOSED;
+            PyErr_SetNone(__Pyx_PyExc_StopAsyncIteration);
+            return NULL;
+        }
+
+        if (unlikely(arg != Py_None)) {
+            PyErr_SetString(PyExc_RuntimeError, __Pyx_NON_INIT_CORO_MSG);
+            return NULL;
+        }
+
+        o->agt_state = __PYX_AWAITABLE_STATE_ITER;
+        o->agt_gen->ag_running_async = 1;
+
+        if (o->agt_args == NULL) {
+            /* aclose() mode */
+            o->agt_gen->ag_closed = 1;
+
+            retval = __Pyx__Coroutine_Throw((PyObject*)gen,
+                /* Do not close generator when PyExc_GeneratorExit is passed */
+                PyExc_GeneratorExit, NULL, NULL, NULL, 0);
+
+            if (retval && __pyx__PyAsyncGenWrappedValue_CheckExact(retval)) {
+                Py_DECREF(retval);
+                goto yield_close;
+            }
+        } else {
+            PyObject *typ;
+            PyObject *tb = NULL;
+            PyObject *val = NULL;
+
+            if (unlikely(!PyArg_UnpackTuple(o->agt_args, "athrow", 1, 3, &typ, &val, &tb))) {
+                return NULL;
+            }
+
+            retval = __Pyx__Coroutine_Throw((PyObject*)gen,
+                /* Do not close generator when PyExc_GeneratorExit is passed */
+                typ, val, tb, o->agt_args, 0);
+            retval = __Pyx_async_gen_unwrap_value(o->agt_gen, retval);
+        }
+        if (retval == NULL) {
+            goto check_error;
+        }
+        return retval;
+    }
+
+    assert (o->agt_state == __PYX_AWAITABLE_STATE_ITER);
+
+    retval = __Pyx_Coroutine_Send((PyObject *)gen, arg);
+    if (o->agt_args) {
+        return __Pyx_async_gen_unwrap_value(o->agt_gen, retval);
+    } else {
+        /* aclose() mode */
+        if (retval) {
+            if (unlikely(__pyx__PyAsyncGenWrappedValue_CheckExact(retval))) {
+                Py_DECREF(retval);
+                goto yield_close;
+            }
+            else {
+                return retval;
+            }
+        }
+        else {
+            goto check_error;
+        }
+    }
+
+yield_close:
+    o->agt_gen->ag_running_async = 0;
+    o->agt_state = __PYX_AWAITABLE_STATE_CLOSED;
+    PyErr_SetString(
+        PyExc_RuntimeError, __Pyx_ASYNC_GEN_IGNORED_EXIT_MSG);
+    return NULL;
+
+check_error:
+    o->agt_gen->ag_running_async = 0;
+    o->agt_state = __PYX_AWAITABLE_STATE_CLOSED;
+    exc_type = PyErr_Occurred();
+    if (__Pyx_PyErr_GivenExceptionMatches2(exc_type, __Pyx_PyExc_StopAsyncIteration, PyExc_GeneratorExit)) {
+        if (o->agt_args == NULL) {
+            // when aclose() is called we don't want to propagate
+            // StopAsyncIteration or GeneratorExit; just raise
+            // StopIteration, signalling that this 'aclose()' await
+            // is done.
+            PyErr_Clear();
+            PyErr_SetNone(PyExc_StopIteration);
+        }
+    }
+    return NULL;
+}
+
+
+static PyObject *
+__Pyx_async_gen_athrow_throw(__pyx_PyAsyncGenAThrow *o, PyObject *args)
+{
+    PyObject *retval;
+
+    if (unlikely(o->agt_state == __PYX_AWAITABLE_STATE_CLOSED)) {
+        PyErr_SetString(PyExc_RuntimeError, __Pyx_ASYNC_GEN_CANNOT_REUSE_CLOSE_MSG);
+        return NULL;
+    }
+
+    retval = __Pyx_Coroutine_Throw((PyObject*)o->agt_gen, args);
+    if (o->agt_args) {
+        return __Pyx_async_gen_unwrap_value(o->agt_gen, retval);
+    } else {
+        // aclose() mode
+        PyObject *exc_type;
+        if (unlikely(retval && __pyx__PyAsyncGenWrappedValue_CheckExact(retval))) {
+            o->agt_gen->ag_running_async = 0;
+            o->agt_state = __PYX_AWAITABLE_STATE_CLOSED;
+            Py_DECREF(retval);
+            PyErr_SetString(PyExc_RuntimeError, __Pyx_ASYNC_GEN_IGNORED_EXIT_MSG);
+            return NULL;
+        }
+        exc_type = PyErr_Occurred();
+        if (__Pyx_PyErr_GivenExceptionMatches2(exc_type, __Pyx_PyExc_StopAsyncIteration, PyExc_GeneratorExit)) {
+            // when aclose() is called we don't want to propagate
+            // StopAsyncIteration or GeneratorExit; just raise
+            // StopIteration, signalling that this 'aclose()' await
+            // is done.
+            PyErr_Clear();
+            PyErr_SetNone(PyExc_StopIteration);
+        }
+        return retval;
+    }
+}
+
+
+static PyObject *
+__Pyx_async_gen_athrow_iternext(__pyx_PyAsyncGenAThrow *o)
+{
+    return __Pyx_async_gen_athrow_send(o, Py_None);
+}
+
+
+static PyObject *
+__Pyx_async_gen_athrow_close(PyObject *g, PyObject *args)
+{
+    __pyx_PyAsyncGenAThrow *o = (__pyx_PyAsyncGenAThrow*) g;
+    CYTHON_UNUSED_VAR(args);
+    o->agt_state = __PYX_AWAITABLE_STATE_CLOSED;
+    Py_RETURN_NONE;
+}
+
+
+static PyMethodDef __Pyx_async_gen_athrow_methods[] = {
+    {"send", (PyCFunction)__Pyx_async_gen_athrow_send, METH_O, __Pyx_async_gen_send_doc},
+    {"throw", (PyCFunction)__Pyx_async_gen_athrow_throw, METH_VARARGS, __Pyx_async_gen_throw_doc},
+    {"close", (PyCFunction)__Pyx_async_gen_athrow_close, METH_NOARGS, __Pyx_async_gen_close_doc},
+    {"__await__", (PyCFunction)__Pyx_async_gen_self_method, METH_NOARGS, __Pyx_async_gen_await_doc},
+    {0, 0, 0, 0}        /* Sentinel */
+};
+
+
+#if CYTHON_USE_TYPE_SPECS
+static PyType_Slot __pyx__PyAsyncGenAThrowType_slots[] = {
+    {Py_tp_dealloc, (void *)__Pyx_async_gen_athrow_dealloc},
+    {Py_am_await, (void *)PyObject_SelfIter},
+    {Py_tp_traverse, (void *)__Pyx_async_gen_athrow_traverse},
+    {Py_tp_iter, (void *)PyObject_SelfIter},
+    {Py_tp_iternext, (void *)__Pyx_async_gen_athrow_iternext},
+    {Py_tp_methods, (void *)__Pyx_async_gen_athrow_methods},
+    {Py_tp_getattro, (void *)__Pyx_PyObject_GenericGetAttrNoDict},
+    {0, 0},
+};
+
+static PyType_Spec __pyx__PyAsyncGenAThrowType_spec = {
+    __PYX_TYPE_MODULE_PREFIX "async_generator_athrow",
+    sizeof(__pyx_PyAsyncGenAThrow),
+    0,
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC, /*tp_flags*/
+    __pyx__PyAsyncGenAThrowType_slots
+};
+#else /* CYTHON_USE_TYPE_SPECS */
+
+#if CYTHON_USE_ASYNC_SLOTS
+static __Pyx_PyAsyncMethodsStruct __Pyx_async_gen_athrow_as_async = {
+    PyObject_SelfIter,                          /* am_await */
+    0,                                          /* am_aiter */
+    0,                                          /* am_anext */
+#if PY_VERSION_HEX >= 0x030A00A3
+    0, /*am_send*/
+#endif
+};
+#endif
+
+static PyTypeObject __pyx__PyAsyncGenAThrowType_type = {
+    PyVarObject_HEAD_INIT(0, 0)
+    "async_generator_athrow",                   /* tp_name */
+    sizeof(__pyx_PyAsyncGenAThrow),                   /* tp_basicsize */
+    0,                                          /* tp_itemsize */
+    (destructor)__Pyx_async_gen_athrow_dealloc,       /* tp_dealloc */
+    0,                                          /* tp_vectorcall_offset */
+    0,                                          /* tp_getattr */
+    0,                                          /* tp_setattr */
+#if CYTHON_USE_ASYNC_SLOTS
+    &__Pyx_async_gen_athrow_as_async,                 /* tp_as_async */
+#else
+    0,                                          /*tp_reserved*/
+#endif
+    0,                                          /* tp_repr */
+    0,                                          /* tp_as_number */
+    0,                                          /* tp_as_sequence */
+    0,                                          /* tp_as_mapping */
+    0,                                          /* tp_hash */
+    0,                                          /* tp_call */
+    0,                                          /* tp_str */
+    0,                                          /* tp_getattro */
+    0,                                          /* tp_setattro */
+    0,                                          /* tp_as_buffer */
+    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,    /* tp_flags */
+    0,                                          /* tp_doc */
+    (traverseproc)__Pyx_async_gen_athrow_traverse,    /* tp_traverse */
+    0,                                          /* tp_clear */
+#if CYTHON_USE_ASYNC_SLOTS && CYTHON_COMPILING_IN_CPYTHON && PY_MAJOR_VERSION >= 3 && PY_VERSION_HEX < 0x030500B1
+    // in order to (mis-)use tp_reserved above, we must also implement tp_richcompare
+    __Pyx_Coroutine_compare,            /*tp_richcompare*/
+#else
+    0,                                  /*tp_richcompare*/
+#endif
+    0,                                          /* tp_weaklistoffset */
+    PyObject_SelfIter,                          /* tp_iter */
+    (iternextfunc)__Pyx_async_gen_athrow_iternext,    /* tp_iternext */
+    __Pyx_async_gen_athrow_methods,                   /* tp_methods */
+    0,                                          /* tp_members */
+    0,                                          /* tp_getset */
+    0,                                          /* tp_base */
+    0,                                          /* tp_dict */
+    0,                                          /* tp_descr_get */
+    0,                                          /* tp_descr_set */
+    0,                                          /* tp_dictoffset */
+    0,                                          /* tp_init */
+    0,                                          /* tp_alloc */
+    0,                                          /* tp_new */
+    0,                                          /* tp_free */
+    0,                                          /* tp_is_gc */
+    0,                                          /* tp_bases */
+    0,                                          /* tp_mro */
+    0,                                          /* tp_cache */
+    0,                                          /* tp_subclasses */
+    0,                                          /* tp_weaklist */
+    0,                                          /* tp_del */
+    0,                                          /* tp_version_tag */
+#if PY_VERSION_HEX >= 0x030400a1
+    0,                                          /* tp_finalize */
+#endif
+#if PY_VERSION_HEX >= 0x030800b1 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07030800)
+    0,                                          /*tp_vectorcall*/
+#endif
+#if __PYX_NEED_TP_PRINT_SLOT
+    0,                                          /*tp_print*/
+#endif
+#if PY_VERSION_HEX >= 0x030C0000
+    0,                                          /*tp_watched*/
+#endif
+#if PY_VERSION_HEX >= 0x030d00A4
+    0,                                          /*tp_versions_used*/
+#endif
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX >= 0x03090000 && PY_VERSION_HEX < 0x030a0000
+    0,                                          /*tp_pypy_flags*/
+#endif
+};
+#endif /* CYTHON_USE_TYPE_SPECS */
+
+
+static PyObject *
+__Pyx_async_gen_athrow_new(__pyx_PyAsyncGenObject *gen, PyObject *args)
+{
+    __pyx_PyAsyncGenAThrow *o;
+    o = PyObject_GC_New(__pyx_PyAsyncGenAThrow, __pyx__PyAsyncGenAThrowType);
+    if (unlikely(o == NULL)) {
+        return NULL;
+    }
+    o->agt_gen = gen;
+    o->agt_args = args;
+    o->agt_state = __PYX_AWAITABLE_STATE_INIT;
+    Py_INCREF(gen);
+    Py_XINCREF(args);
+    PyObject_GC_Track((PyObject*)o);
+    return (PyObject*)o;
+}
+
+
+/* ---------- global type sharing ------------ */
+
+static int __pyx_AsyncGen_init(PyObject *module) {
+#if CYTHON_USE_TYPE_SPECS
+    __pyx_AsyncGenType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx_AsyncGenType_spec, NULL);
+#else
+    CYTHON_MAYBE_UNUSED_VAR(module);
+    // on Windows, C-API functions can't be used in slots statically
+    __pyx_AsyncGenType_type.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+    __pyx_AsyncGenType = __Pyx_FetchCommonType(&__pyx_AsyncGenType_type);
+#endif
+    if (unlikely(!__pyx_AsyncGenType))
+        return -1;
+
+#if CYTHON_USE_TYPE_SPECS
+    __pyx__PyAsyncGenAThrowType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx__PyAsyncGenAThrowType_spec, NULL);
+#else
+    __pyx__PyAsyncGenAThrowType_type.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+    __pyx__PyAsyncGenAThrowType = __Pyx_FetchCommonType(&__pyx__PyAsyncGenAThrowType_type);
+#endif
+    if (unlikely(!__pyx__PyAsyncGenAThrowType))
+        return -1;
+
+#if CYTHON_USE_TYPE_SPECS
+    __pyx__PyAsyncGenWrappedValueType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx__PyAsyncGenWrappedValueType_spec, NULL);
+#else
+    __pyx__PyAsyncGenWrappedValueType_type.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+    __pyx__PyAsyncGenWrappedValueType = __Pyx_FetchCommonType(&__pyx__PyAsyncGenWrappedValueType_type);
+#endif
+    if (unlikely(!__pyx__PyAsyncGenWrappedValueType))
+        return -1;
+
+#if CYTHON_USE_TYPE_SPECS
+    __pyx__PyAsyncGenASendType = __Pyx_FetchCommonTypeFromSpec(module, &__pyx__PyAsyncGenASendType_spec, NULL);
+#else
+    __pyx__PyAsyncGenASendType_type.tp_getattro = __Pyx_PyObject_GenericGetAttrNoDict;
+    __pyx__PyAsyncGenASendType = __Pyx_FetchCommonType(&__pyx__PyAsyncGenASendType_type);
+#endif
+    if (unlikely(!__pyx__PyAsyncGenASendType))
+        return -1;
+
+    return 0;
+}

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Utility/Buffer.c

@@ -0,0 +1,933 @@
+/////////////// BufferStructDeclare.proto ///////////////
+
+/* structs for buffer access */
+
+typedef struct {
+  Py_ssize_t shape, strides, suboffsets;
+} __Pyx_Buf_DimInfo;
+
+typedef struct {
+  size_t refcount;
+  Py_buffer pybuffer;
+} __Pyx_Buffer;
+
+typedef struct {
+  __Pyx_Buffer *rcbuffer;
+  char *data;
+  __Pyx_Buf_DimInfo diminfo[{{max_dims}}];
+} __Pyx_LocalBuf_ND;
+
+/////////////// BufferIndexError.proto ///////////////
+static void __Pyx_RaiseBufferIndexError(int axis); /*proto*/
+
+/////////////// BufferIndexError ///////////////
+static void __Pyx_RaiseBufferIndexError(int axis) {
+  PyErr_Format(PyExc_IndexError,
+     "Out of bounds on buffer access (axis %d)", axis);
+}
+
+/////////////// BufferIndexErrorNogil.proto ///////////////
+//@requires: BufferIndexError
+
+static void __Pyx_RaiseBufferIndexErrorNogil(int axis); /*proto*/
+
+/////////////// BufferIndexErrorNogil ///////////////
+static void __Pyx_RaiseBufferIndexErrorNogil(int axis) {
+    #ifdef WITH_THREAD
+    PyGILState_STATE gilstate = PyGILState_Ensure();
+    #endif
+    __Pyx_RaiseBufferIndexError(axis);
+    #ifdef WITH_THREAD
+    PyGILState_Release(gilstate);
+    #endif
+}
+
+/////////////// BufferFallbackError.proto ///////////////
+static void __Pyx_RaiseBufferFallbackError(void); /*proto*/
+
+/////////////// BufferFallbackError ///////////////
+static void __Pyx_RaiseBufferFallbackError(void) {
+  PyErr_SetString(PyExc_ValueError,
+     "Buffer acquisition failed on assignment; and then reacquiring the old buffer failed too!");
+}
+
+/////////////// BufferFormatStructs.proto ///////////////
+//@proto_block: utility_code_proto_before_types
+
+/* Run-time type information about structs used with buffers */
+struct __Pyx_StructField_;
+
+#define __PYX_BUF_FLAGS_PACKED_STRUCT (1 << 0)
+
+typedef struct {
+  const char* name; /* for error messages only */
+  struct __Pyx_StructField_* fields;
+  size_t size;     /* sizeof(type) */
+  size_t arraysize[8]; /* length of array in each dimension */
+  int ndim;
+  char typegroup; /* _R_eal, _C_omplex, Signed _I_nt, _U_nsigned int, _S_truct, _P_ointer, _O_bject, c_H_ar */
+  char is_unsigned;
+  int flags;
+} __Pyx_TypeInfo;
+
+typedef struct __Pyx_StructField_ {
+  __Pyx_TypeInfo* type;
+  const char* name;
+  size_t offset;
+} __Pyx_StructField;
+
+typedef struct {
+  __Pyx_StructField* field;
+  size_t parent_offset;
+} __Pyx_BufFmt_StackElem;
+
+typedef struct {
+  __Pyx_StructField root;
+  __Pyx_BufFmt_StackElem* head;
+  size_t fmt_offset;
+  size_t new_count, enc_count;
+  size_t struct_alignment;
+  int is_complex;
+  char enc_type;
+  char new_packmode;
+  char enc_packmode;
+  char is_valid_array;
+} __Pyx_BufFmt_Context;
+
+
+/////////////// GetAndReleaseBuffer.proto ///////////////
+
+#if PY_MAJOR_VERSION < 3
+    static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags);
+    static void __Pyx_ReleaseBuffer(Py_buffer *view);
+#else
+    #define __Pyx_GetBuffer PyObject_GetBuffer
+    #define __Pyx_ReleaseBuffer PyBuffer_Release
+#endif
+
+/////////////// GetAndReleaseBuffer ///////////////
+
+#if PY_MAJOR_VERSION < 3
+static int __Pyx_GetBuffer(PyObject *obj, Py_buffer *view, int flags) {
+    __Pyx_TypeName obj_type_name;
+    if (PyObject_CheckBuffer(obj)) return PyObject_GetBuffer(obj, view, flags);
+
+    {{for type_ptr, getbuffer, releasebuffer in types}}
+      {{if getbuffer}}
+        if (__Pyx_TypeCheck(obj, {{type_ptr}})) return {{getbuffer}}(obj, view, flags);
+      {{endif}}
+    {{endfor}}
+
+    obj_type_name = __Pyx_PyType_GetName(Py_TYPE(obj));
+    PyErr_Format(PyExc_TypeError,
+                 "'" __Pyx_FMT_TYPENAME "' does not have the buffer interface",
+                 obj_type_name);
+    __Pyx_DECREF_TypeName(obj_type_name);
+    return -1;
+}
+
+static void __Pyx_ReleaseBuffer(Py_buffer *view) {
+    PyObject *obj = view->obj;
+    if (!obj) return;
+
+    if (PyObject_CheckBuffer(obj)) {
+        PyBuffer_Release(view);
+        return;
+    }
+
+    if ((0)) {}
+    {{for type_ptr, getbuffer, releasebuffer in types}}
+      {{if releasebuffer}}
+        else if (__Pyx_TypeCheck(obj, {{type_ptr}})) {{releasebuffer}}(obj, view);
+      {{endif}}
+    {{endfor}}
+
+    view->obj = NULL;
+    Py_DECREF(obj);
+}
+
+#endif /*  PY_MAJOR_VERSION < 3 */
+
+
+/////////////// BufferGetAndValidate.proto ///////////////
+
+#define __Pyx_GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack) \
+    ((obj == Py_None || obj == NULL) ? \
+    (__Pyx_ZeroBuffer(buf), 0) : \
+    __Pyx__GetBufferAndValidate(buf, obj, dtype, flags, nd, cast, stack))
+
+static int  __Pyx__GetBufferAndValidate(Py_buffer* buf, PyObject* obj,
+    __Pyx_TypeInfo* dtype, int flags, int nd, int cast, __Pyx_BufFmt_StackElem* stack);
+static void __Pyx_ZeroBuffer(Py_buffer* buf);
+static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info);/*proto*/
+
+static Py_ssize_t __Pyx_minusones[] = { {{ ", ".join(["-1"] * max_dims) }} };
+static Py_ssize_t __Pyx_zeros[] = { {{ ", ".join(["0"] * max_dims) }} };
+
+
+/////////////// BufferGetAndValidate ///////////////
+//@requires: BufferFormatCheck
+
+static CYTHON_INLINE void __Pyx_SafeReleaseBuffer(Py_buffer* info) {
+  if (unlikely(info->buf == NULL)) return;
+  if (info->suboffsets == __Pyx_minusones) info->suboffsets = NULL;
+  __Pyx_ReleaseBuffer(info);
+}
+
+static void __Pyx_ZeroBuffer(Py_buffer* buf) {
+  buf->buf = NULL;
+  buf->obj = NULL;
+  buf->strides = __Pyx_zeros;
+  buf->shape = __Pyx_zeros;
+  buf->suboffsets = __Pyx_minusones;
+}
+
+static int __Pyx__GetBufferAndValidate(
+        Py_buffer* buf, PyObject* obj,  __Pyx_TypeInfo* dtype, int flags,
+        int nd, int cast, __Pyx_BufFmt_StackElem* stack)
+{
+  buf->buf = NULL;
+  if (unlikely(__Pyx_GetBuffer(obj, buf, flags) == -1)) {
+    __Pyx_ZeroBuffer(buf);
+    return -1;
+  }
+  // From this point on, we have acquired the buffer and must release it on errors.
+  if (unlikely(buf->ndim != nd)) {
+    PyErr_Format(PyExc_ValueError,
+                 "Buffer has wrong number of dimensions (expected %d, got %d)",
+                 nd, buf->ndim);
+    goto fail;
+  }
+  if (!cast) {
+    __Pyx_BufFmt_Context ctx;
+    __Pyx_BufFmt_Init(&ctx, stack, dtype);
+    if (!__Pyx_BufFmt_CheckString(&ctx, buf->format)) goto fail;
+  }
+  if (unlikely((size_t)buf->itemsize != dtype->size)) {
+    PyErr_Format(PyExc_ValueError,
+      "Item size of buffer (%" CYTHON_FORMAT_SSIZE_T "d byte%s) does not match size of '%s' (%" CYTHON_FORMAT_SSIZE_T "d byte%s)",
+      buf->itemsize, (buf->itemsize > 1) ? "s" : "",
+      dtype->name, (Py_ssize_t)dtype->size, (dtype->size > 1) ? "s" : "");
+    goto fail;
+  }
+  if (buf->suboffsets == NULL) buf->suboffsets = __Pyx_minusones;
+  return 0;
+fail:;
+  __Pyx_SafeReleaseBuffer(buf);
+  return -1;
+}
+
+
+/////////////// BufferFormatCheck.proto ///////////////
+
+//  Buffer format string checking
+//
+//  Buffer type checking. Utility code for checking that acquired
+//  buffers match our assumptions. We only need to check ndim and
+//  the format string; the access mode/flags is checked by the
+//  exporter. See:
+//
+//  https://docs.python.org/3/library/struct.html
+//  https://www.python.org/dev/peps/pep-3118/#additions-to-the-struct-string-syntax
+//
+//  The alignment code is copied from _struct.c in Python.
+
+static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts);
+static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx,
+                              __Pyx_BufFmt_StackElem* stack,
+                              __Pyx_TypeInfo* type); /*proto*/
+
+/////////////// BufferFormatCheck ///////////////
+//@requires: ModuleSetupCode.c::IsLittleEndian
+//@requires: BufferFormatStructs
+
+static void __Pyx_BufFmt_Init(__Pyx_BufFmt_Context* ctx,
+                              __Pyx_BufFmt_StackElem* stack,
+                              __Pyx_TypeInfo* type) {
+  stack[0].field = &ctx->root;
+  stack[0].parent_offset = 0;
+  ctx->root.type = type;
+  ctx->root.name = "buffer dtype";
+  ctx->root.offset = 0;
+  ctx->head = stack;
+  ctx->head->field = &ctx->root;
+  ctx->fmt_offset = 0;
+  ctx->head->parent_offset = 0;
+  ctx->new_packmode = '@';
+  ctx->enc_packmode = '@';
+  ctx->new_count = 1;
+  ctx->enc_count = 0;
+  ctx->enc_type = 0;
+  ctx->is_complex = 0;
+  ctx->is_valid_array = 0;
+  ctx->struct_alignment = 0;
+  while (type->typegroup == 'S') {
+    ++ctx->head;
+    ctx->head->field = type->fields;
+    ctx->head->parent_offset = 0;
+    type = type->fields->type;
+  }
+}
+
+static int __Pyx_BufFmt_ParseNumber(const char** ts) {
+    int count;
+    const char* t = *ts;
+    if (*t < '0' || *t > '9') {
+      return -1;
+    } else {
+        count = *t++ - '0';
+        while (*t >= '0' && *t <= '9') {
+            count *= 10;
+            count += *t++ - '0';
+        }
+    }
+    *ts = t;
+    return count;
+}
+
+static int __Pyx_BufFmt_ExpectNumber(const char **ts) {
+    int number = __Pyx_BufFmt_ParseNumber(ts);
+    if (number == -1) /* First char was not a digit */
+        PyErr_Format(PyExc_ValueError,\
+                     "Does not understand character buffer dtype format string ('%c')", **ts);
+    return number;
+}
+
+
+static void __Pyx_BufFmt_RaiseUnexpectedChar(char ch) {
+  PyErr_Format(PyExc_ValueError,
+               "Unexpected format string character: '%c'", ch);
+}
+
+static const char* __Pyx_BufFmt_DescribeTypeChar(char ch, int is_complex) {
+  switch (ch) {
+    case '?': return "'bool'";
+    case 'c': return "'char'";
+    case 'b': return "'signed char'";
+    case 'B': return "'unsigned char'";
+    case 'h': return "'short'";
+    case 'H': return "'unsigned short'";
+    case 'i': return "'int'";
+    case 'I': return "'unsigned int'";
+    case 'l': return "'long'";
+    case 'L': return "'unsigned long'";
+    case 'q': return "'long long'";
+    case 'Q': return "'unsigned long long'";
+    case 'f': return (is_complex ? "'complex float'" : "'float'");
+    case 'd': return (is_complex ? "'complex double'" : "'double'");
+    case 'g': return (is_complex ? "'complex long double'" : "'long double'");
+    case 'T': return "a struct";
+    case 'O': return "Python object";
+    case 'P': return "a pointer";
+    case 's': case 'p': return "a string";
+    case 0: return "end";
+    default: return "unparsable format string";
+  }
+}
+
+static size_t __Pyx_BufFmt_TypeCharToStandardSize(char ch, int is_complex) {
+  switch (ch) {
+    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
+    case 'h': case 'H': return 2;
+    case 'i': case 'I': case 'l': case 'L': return 4;
+    case 'q': case 'Q': return 8;
+    case 'f': return (is_complex ? 8 : 4);
+    case 'd': return (is_complex ? 16 : 8);
+    case 'g': {
+      PyErr_SetString(PyExc_ValueError, "Python does not define a standard format string size for long double ('g')..");
+      return 0;
+    }
+    case 'O': case 'P': return sizeof(void*);
+    default:
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+}
+
+static size_t __Pyx_BufFmt_TypeCharToNativeSize(char ch, int is_complex) {
+  switch (ch) {
+    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
+    case 'h': case 'H': return sizeof(short);
+    case 'i': case 'I': return sizeof(int);
+    case 'l': case 'L': return sizeof(long);
+    #ifdef HAVE_LONG_LONG
+    case 'q': case 'Q': return sizeof(PY_LONG_LONG);
+    #endif
+    case 'f': return sizeof(float) * (is_complex ? 2 : 1);
+    case 'd': return sizeof(double) * (is_complex ? 2 : 1);
+    case 'g': return sizeof(long double) * (is_complex ? 2 : 1);
+    case 'O': case 'P': return sizeof(void*);
+    default: {
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+  }
+}
+
+typedef struct { char c; short x; } __Pyx_st_short;
+typedef struct { char c; int x; } __Pyx_st_int;
+typedef struct { char c; long x; } __Pyx_st_long;
+typedef struct { char c; float x; } __Pyx_st_float;
+typedef struct { char c; double x; } __Pyx_st_double;
+typedef struct { char c; long double x; } __Pyx_st_longdouble;
+typedef struct { char c; void *x; } __Pyx_st_void_p;
+#ifdef HAVE_LONG_LONG
+typedef struct { char c; PY_LONG_LONG x; } __Pyx_st_longlong;
+#endif
+
+static size_t __Pyx_BufFmt_TypeCharToAlignment(char ch, int is_complex) {
+  CYTHON_UNUSED_VAR(is_complex);
+  switch (ch) {
+    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
+    case 'h': case 'H': return sizeof(__Pyx_st_short) - sizeof(short);
+    case 'i': case 'I': return sizeof(__Pyx_st_int) - sizeof(int);
+    case 'l': case 'L': return sizeof(__Pyx_st_long) - sizeof(long);
+#ifdef HAVE_LONG_LONG
+    case 'q': case 'Q': return sizeof(__Pyx_st_longlong) - sizeof(PY_LONG_LONG);
+#endif
+    case 'f': return sizeof(__Pyx_st_float) - sizeof(float);
+    case 'd': return sizeof(__Pyx_st_double) - sizeof(double);
+    case 'g': return sizeof(__Pyx_st_longdouble) - sizeof(long double);
+    case 'P': case 'O': return sizeof(__Pyx_st_void_p) - sizeof(void*);
+    default:
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+}
+
+/* These are for computing the padding at the end of the struct to align
+   on the first member of the struct. This will probably the same as above,
+   but we don't have any guarantees.
+ */
+typedef struct { short x; char c; } __Pyx_pad_short;
+typedef struct { int x; char c; } __Pyx_pad_int;
+typedef struct { long x; char c; } __Pyx_pad_long;
+typedef struct { float x; char c; } __Pyx_pad_float;
+typedef struct { double x; char c; } __Pyx_pad_double;
+typedef struct { long double x; char c; } __Pyx_pad_longdouble;
+typedef struct { void *x; char c; } __Pyx_pad_void_p;
+#ifdef HAVE_LONG_LONG
+typedef struct { PY_LONG_LONG x; char c; } __Pyx_pad_longlong;
+#endif
+
+static size_t __Pyx_BufFmt_TypeCharToPadding(char ch, int is_complex) {
+  CYTHON_UNUSED_VAR(is_complex);
+  switch (ch) {
+    case '?': case 'c': case 'b': case 'B': case 's': case 'p': return 1;
+    case 'h': case 'H': return sizeof(__Pyx_pad_short) - sizeof(short);
+    case 'i': case 'I': return sizeof(__Pyx_pad_int) - sizeof(int);
+    case 'l': case 'L': return sizeof(__Pyx_pad_long) - sizeof(long);
+#ifdef HAVE_LONG_LONG
+    case 'q': case 'Q': return sizeof(__Pyx_pad_longlong) - sizeof(PY_LONG_LONG);
+#endif
+    case 'f': return sizeof(__Pyx_pad_float) - sizeof(float);
+    case 'd': return sizeof(__Pyx_pad_double) - sizeof(double);
+    case 'g': return sizeof(__Pyx_pad_longdouble) - sizeof(long double);
+    case 'P': case 'O': return sizeof(__Pyx_pad_void_p) - sizeof(void*);
+    default:
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+}
+
+static char __Pyx_BufFmt_TypeCharToGroup(char ch, int is_complex) {
+  switch (ch) {
+    case 'c':
+        return 'H';
+    case 'b': case 'h': case 'i':
+    case 'l': case 'q': case 's': case 'p':
+        return 'I';
+    case '?': case 'B': case 'H': case 'I': case 'L': case 'Q':
+        return 'U';
+    case 'f': case 'd': case 'g':
+        return (is_complex ? 'C' : 'R');
+    case 'O':
+        return 'O';
+    case 'P':
+        return 'P';
+    default: {
+      __Pyx_BufFmt_RaiseUnexpectedChar(ch);
+      return 0;
+    }
+  }
+}
+
+
+static void __Pyx_BufFmt_RaiseExpected(__Pyx_BufFmt_Context* ctx) {
+  if (ctx->head == NULL || ctx->head->field == &ctx->root) {
+    const char* expected;
+    const char* quote;
+    if (ctx->head == NULL) {
+      expected = "end";
+      quote = "";
+    } else {
+      expected = ctx->head->field->type->name;
+      quote = "'";
+    }
+    PyErr_Format(PyExc_ValueError,
+                 "Buffer dtype mismatch, expected %s%s%s but got %s",
+                 quote, expected, quote,
+                 __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex));
+  } else {
+    __Pyx_StructField* field = ctx->head->field;
+    __Pyx_StructField* parent = (ctx->head - 1)->field;
+    PyErr_Format(PyExc_ValueError,
+                 "Buffer dtype mismatch, expected '%s' but got %s in '%s.%s'",
+                 field->type->name, __Pyx_BufFmt_DescribeTypeChar(ctx->enc_type, ctx->is_complex),
+                 parent->type->name, field->name);
+  }
+}
+
+static int __Pyx_BufFmt_ProcessTypeChunk(__Pyx_BufFmt_Context* ctx) {
+  char group;
+  size_t size, offset, arraysize = 1;
+
+  /* printf("processing... %s\n", ctx->head->field->type->name); */
+
+  if (ctx->enc_type == 0) return 0;
+
+  /* Validate array size */
+  if (ctx->head->field->type->arraysize[0]) {
+    int i, ndim = 0;
+
+    /* handle strings ('s' and 'p') */
+    if (ctx->enc_type == 's' || ctx->enc_type == 'p') {
+        ctx->is_valid_array = ctx->head->field->type->ndim == 1;
+        ndim = 1;
+        if (ctx->enc_count != ctx->head->field->type->arraysize[0]) {
+            PyErr_Format(PyExc_ValueError,
+                         "Expected a dimension of size %zu, got %zu",
+                         ctx->head->field->type->arraysize[0], ctx->enc_count);
+            return -1;
+        }
+    }
+
+    if (!ctx->is_valid_array) {
+      PyErr_Format(PyExc_ValueError, "Expected %d dimensions, got %d",
+                   ctx->head->field->type->ndim, ndim);
+      return -1;
+    }
+    for (i = 0; i < ctx->head->field->type->ndim; i++) {
+      arraysize *= ctx->head->field->type->arraysize[i];
+    }
+    ctx->is_valid_array = 0;
+    ctx->enc_count = 1;
+  }
+
+  group = __Pyx_BufFmt_TypeCharToGroup(ctx->enc_type, ctx->is_complex);
+  do {
+    __Pyx_StructField* field = ctx->head->field;
+    __Pyx_TypeInfo* type = field->type;
+
+    if (ctx->enc_packmode == '@' || ctx->enc_packmode == '^') {
+      size = __Pyx_BufFmt_TypeCharToNativeSize(ctx->enc_type, ctx->is_complex);
+    } else {
+      size = __Pyx_BufFmt_TypeCharToStandardSize(ctx->enc_type, ctx->is_complex);
+    }
+
+    if (ctx->enc_packmode == '@') {
+      size_t align_at = __Pyx_BufFmt_TypeCharToAlignment(ctx->enc_type, ctx->is_complex);
+      size_t align_mod_offset;
+      if (align_at == 0) return -1;
+      align_mod_offset = ctx->fmt_offset % align_at;
+      if (align_mod_offset > 0) ctx->fmt_offset += align_at - align_mod_offset;
+
+      if (ctx->struct_alignment == 0)
+          ctx->struct_alignment = __Pyx_BufFmt_TypeCharToPadding(ctx->enc_type,
+                                                                 ctx->is_complex);
+    }
+
+    if (type->size != size || type->typegroup != group) {
+      if (type->typegroup == 'C' && type->fields != NULL) {
+        /* special case -- treat as struct rather than complex number */
+        size_t parent_offset = ctx->head->parent_offset + field->offset;
+        ++ctx->head;
+        ctx->head->field = type->fields;
+        ctx->head->parent_offset = parent_offset;
+        continue;
+      }
+
+      if ((type->typegroup == 'H' || group == 'H') && type->size == size) {
+          /* special case -- chars don't care about sign */
+      } else {
+          __Pyx_BufFmt_RaiseExpected(ctx);
+          return -1;
+      }
+    }
+
+    offset = ctx->head->parent_offset + field->offset;
+    if (ctx->fmt_offset != offset) {
+      PyErr_Format(PyExc_ValueError,
+                   "Buffer dtype mismatch; next field is at offset %" CYTHON_FORMAT_SSIZE_T "d but %" CYTHON_FORMAT_SSIZE_T "d expected",
+                   (Py_ssize_t)ctx->fmt_offset, (Py_ssize_t)offset);
+      return -1;
+    }
+
+    ctx->fmt_offset += size;
+    if (arraysize)
+      ctx->fmt_offset += (arraysize - 1) * size;
+
+    --ctx->enc_count; /* Consume from buffer string */
+
+    /* Done checking, move to next field, pushing or popping struct stack if needed */
+    while (1) {
+      if (field == &ctx->root) {
+        ctx->head = NULL;
+        if (ctx->enc_count != 0) {
+          __Pyx_BufFmt_RaiseExpected(ctx);
+          return -1;
+        }
+        break; /* breaks both loops as ctx->enc_count == 0 */
+      }
+      ctx->head->field = ++field;
+      if (field->type == NULL) {
+        --ctx->head;
+        field = ctx->head->field;
+        continue;
+      } else if (field->type->typegroup == 'S') {
+        size_t parent_offset = ctx->head->parent_offset + field->offset;
+        if (field->type->fields->type == NULL) continue; /* empty struct */
+        field = field->type->fields;
+        ++ctx->head;
+        ctx->head->field = field;
+        ctx->head->parent_offset = parent_offset;
+        break;
+      } else {
+        break;
+      }
+    }
+  } while (ctx->enc_count);
+  ctx->enc_type = 0;
+  ctx->is_complex = 0;
+  return 0;
+}
+
+// Parse an array in the format string (e.g. (1,2,3))
+// Return 0 on success, -1 on error
+static int
+__pyx_buffmt_parse_array(__Pyx_BufFmt_Context* ctx, const char** tsp)
+{
+    const char *ts = *tsp;
+    int i = 0, number, ndim;
+
+    ++ts;
+    if (ctx->new_count != 1) {
+        PyErr_SetString(PyExc_ValueError,
+                        "Cannot handle repeated arrays in format string");
+        return -1;
+    }
+
+    /* Process the previous element */
+    if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return -1;
+
+    // store ndim now, as field advanced by __Pyx_BufFmt_ProcessTypeChunk call
+    ndim = ctx->head->field->type->ndim;
+
+    /* Parse all numbers in the format string */
+    while (*ts && *ts != ')') {
+        // ignore space characters (not using isspace() due to C/C++ problem on MacOS-X)
+        switch (*ts) {
+            case ' ': case '\f': case '\r': case '\n': case '\t': case '\v':  continue;
+            default:  break;  /* not a 'break' in the loop */
+        }
+
+        number = __Pyx_BufFmt_ExpectNumber(&ts);
+        if (number == -1) return -1;
+
+        if (i < ndim && (size_t) number != ctx->head->field->type->arraysize[i]) {
+            PyErr_Format(PyExc_ValueError,
+                        "Expected a dimension of size %zu, got %d",
+                        ctx->head->field->type->arraysize[i], number);
+            return -1;
+        }
+
+        if (*ts != ',' && *ts != ')') {
+            PyErr_Format(PyExc_ValueError,
+                                "Expected a comma in format string, got '%c'", *ts);
+            return -1;
+        }
+
+        if (*ts == ',') ts++;
+        i++;
+    }
+
+    if (i != ndim) {
+        PyErr_Format(PyExc_ValueError, "Expected %d dimension(s), got %d",
+                            ctx->head->field->type->ndim, i);
+        return -1;
+    }
+
+    if (!*ts) {
+        PyErr_SetString(PyExc_ValueError,
+                        "Unexpected end of format string, expected ')'");
+        return -1;
+    }
+
+    ctx->is_valid_array = 1;
+    ctx->new_count = 1;
+    *tsp = ++ts;
+    return 0;
+}
+
+static const char* __Pyx_BufFmt_CheckString(__Pyx_BufFmt_Context* ctx, const char* ts) {
+  int got_Z = 0;
+
+  while (1) {
+    /* puts(ts); */
+    switch(*ts) {
+      case 0:
+        if (ctx->enc_type != 0 && ctx->head == NULL) {
+          __Pyx_BufFmt_RaiseExpected(ctx);
+          return NULL;
+        }
+        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+        if (ctx->head != NULL) {
+          __Pyx_BufFmt_RaiseExpected(ctx);
+          return NULL;
+        }
+        return ts;
+      case ' ':
+      case '\r':
+      case '\n':
+        ++ts;
+        break;
+      case '<':
+        if (!__Pyx_Is_Little_Endian()) {
+          PyErr_SetString(PyExc_ValueError, "Little-endian buffer not supported on big-endian compiler");
+          return NULL;
+        }
+        ctx->new_packmode = '=';
+        ++ts;
+        break;
+      case '>':
+      case '!':
+        if (__Pyx_Is_Little_Endian()) {
+          PyErr_SetString(PyExc_ValueError, "Big-endian buffer not supported on little-endian compiler");
+          return NULL;
+        }
+        ctx->new_packmode = '=';
+        ++ts;
+        break;
+      case '=':
+      case '@':
+      case '^':
+        ctx->new_packmode = *ts++;
+        break;
+      case 'T': /* substruct */
+        {
+          const char* ts_after_sub;
+          size_t i, struct_count = ctx->new_count;
+          size_t struct_alignment = ctx->struct_alignment;
+          ctx->new_count = 1;
+          ++ts;
+          if (*ts != '{') {
+            PyErr_SetString(PyExc_ValueError, "Buffer acquisition: Expected '{' after 'T'");
+            return NULL;
+          }
+          if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+          ctx->enc_type = 0; /* Erase processed last struct element */
+          ctx->enc_count = 0;
+          ctx->struct_alignment = 0;
+          ++ts;
+          ts_after_sub = ts;
+          for (i = 0; i != struct_count; ++i) {
+            ts_after_sub = __Pyx_BufFmt_CheckString(ctx, ts);
+            if (!ts_after_sub) return NULL;
+          }
+          ts = ts_after_sub;
+          if (struct_alignment) ctx->struct_alignment = struct_alignment;
+        }
+        break;
+      case '}': /* end of substruct; either repeat or move on */
+        {
+          size_t alignment = ctx->struct_alignment;
+          ++ts;
+          if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+          ctx->enc_type = 0; /* Erase processed last struct element */
+          if (alignment && ctx->fmt_offset % alignment) {
+            /* Pad struct on size of the first member */
+            ctx->fmt_offset += alignment - (ctx->fmt_offset % alignment);
+          }
+        }
+        return ts;
+      case 'x':
+        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+        ctx->fmt_offset += ctx->new_count;
+        ctx->new_count = 1;
+        ctx->enc_count = 0;
+        ctx->enc_type = 0;
+        ctx->enc_packmode = ctx->new_packmode;
+        ++ts;
+        break;
+      case 'Z':
+        got_Z = 1;
+        ++ts;
+        if (*ts != 'f' && *ts != 'd' && *ts != 'g') {
+          __Pyx_BufFmt_RaiseUnexpectedChar('Z');
+          return NULL;
+        }
+        CYTHON_FALLTHROUGH;
+      case '?': case 'c': case 'b': case 'B': case 'h': case 'H': case 'i': case 'I':
+      case 'l': case 'L': case 'q': case 'Q':
+      case 'f': case 'd': case 'g':
+      case 'O': case 'p':
+        if ((ctx->enc_type == *ts) && (got_Z == ctx->is_complex) &&
+            (ctx->enc_packmode == ctx->new_packmode) && (!ctx->is_valid_array)) {
+          /* Continue pooling same type */
+          ctx->enc_count += ctx->new_count;
+          ctx->new_count = 1;
+          got_Z = 0;
+          ++ts;
+          break;
+        }
+        CYTHON_FALLTHROUGH;
+      case 's':
+        /* 's' or new type (cannot be added to current pool) */
+        if (__Pyx_BufFmt_ProcessTypeChunk(ctx) == -1) return NULL;
+        ctx->enc_count = ctx->new_count;
+        ctx->enc_packmode = ctx->new_packmode;
+        ctx->enc_type = *ts;
+        ctx->is_complex = got_Z;
+        ++ts;
+        ctx->new_count = 1;
+        got_Z = 0;
+        break;
+      case ':':
+        ++ts;
+        while(*ts != ':') ++ts;
+        ++ts;
+        break;
+      case '(':
+        if (__pyx_buffmt_parse_array(ctx, &ts) < 0) return NULL;
+        break;
+      default:
+        {
+          int number = __Pyx_BufFmt_ExpectNumber(&ts);
+          if (number == -1) return NULL;
+          ctx->new_count = (size_t)number;
+        }
+    }
+  }
+}
+
+/////////////// TypeInfoCompare.proto ///////////////
+static int __pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b);
+
+/////////////// TypeInfoCompare ///////////////
+//@requires: BufferFormatStructs
+
+// See if two dtypes are equal
+static int
+__pyx_typeinfo_cmp(__Pyx_TypeInfo *a, __Pyx_TypeInfo *b)
+{
+    int i;
+
+    if (!a || !b)
+        return 0;
+
+    if (a == b)
+        return 1;
+
+    if (a->size != b->size || a->typegroup != b->typegroup ||
+            a->is_unsigned != b->is_unsigned || a->ndim != b->ndim) {
+        if (a->typegroup == 'H' || b->typegroup == 'H') {
+            /* Special case for chars */
+            return a->size == b->size;
+        } else {
+            return 0;
+        }
+    }
+
+    if (a->ndim) {
+        /* Verify multidimensional C arrays */
+        for (i = 0; i < a->ndim; i++)
+            if (a->arraysize[i] != b->arraysize[i])
+                return 0;
+    }
+
+    if (a->typegroup == 'S') {
+        /* Check for packed struct */
+        if (a->flags != b->flags)
+            return 0;
+
+        /* compare all struct fields */
+        if (a->fields || b->fields) {
+            /* Check if both have fields */
+            if (!(a->fields && b->fields))
+                return 0;
+
+            /* compare */
+            for (i = 0; a->fields[i].type && b->fields[i].type; i++) {
+                __Pyx_StructField *field_a = a->fields + i;
+                __Pyx_StructField *field_b = b->fields + i;
+
+                if (field_a->offset != field_b->offset ||
+                    !__pyx_typeinfo_cmp(field_a->type, field_b->type))
+                    return 0;
+            }
+
+            /* If all fields are processed, we have a match */
+            return !a->fields[i].type && !b->fields[i].type;
+        }
+    }
+
+    return 1;
+}
+
+
+/////////////// TypeInfoToFormat.proto ///////////////
+struct __pyx_typeinfo_string {
+    char string[3];
+};
+static struct __pyx_typeinfo_string __Pyx_TypeInfoToFormat(__Pyx_TypeInfo *type);
+
+/////////////// TypeInfoToFormat ///////////////
+//@requires: BufferFormatStructs
+
+// See also MemoryView.pyx:BufferFormatFromTypeInfo
+
+static struct __pyx_typeinfo_string __Pyx_TypeInfoToFormat(__Pyx_TypeInfo *type) {
+    struct __pyx_typeinfo_string result = { {0} };
+    char *buf = (char *) result.string;
+    size_t size = type->size;
+
+    switch (type->typegroup) {
+        case 'H':
+            *buf = 'c';
+            break;
+        case 'I':
+        case 'U':
+            if (size == 1)
+                *buf = (type->is_unsigned) ? 'B' : 'b';
+            else if (size == 2)
+                *buf = (type->is_unsigned) ? 'H' : 'h';
+            else if (size == 4)
+                *buf = (type->is_unsigned) ? 'I' : 'i';
+            else if (size == 8)
+                *buf = (type->is_unsigned) ? 'Q' : 'q';
+            break;
+        case 'P':
+            *buf = 'P';
+            break;
+        case 'C':
+         {
+            __Pyx_TypeInfo complex_type = *type;
+            complex_type.typegroup = 'R';
+            complex_type.size /= 2;
+
+            *buf++ = 'Z';
+            *buf = __Pyx_TypeInfoToFormat(&complex_type).string[0];
+            break;
+         }
+        case 'R':
+            if (size == 4)
+                *buf = 'f';
+            else if (size == 8)
+                *buf = 'd';
+            else
+                *buf = 'g';
+            break;
+    }
+
+    return result;
+}

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Utility/CppSupport.cpp

@@ -0,0 +1,133 @@
+/////////////// CppExceptionConversion.proto ///////////////
+
+#ifndef __Pyx_CppExn2PyErr
+#include <new>
+#include <typeinfo>
+#include <stdexcept>
+#include <ios>
+
+static void __Pyx_CppExn2PyErr() {
+  // Catch a handful of different errors here and turn them into the
+  // equivalent Python errors.
+  try {
+    if (PyErr_Occurred())
+      ; // let the latest Python exn pass through and ignore the current one
+    else
+      throw;
+  } catch (const std::bad_alloc& exn) {
+    PyErr_SetString(PyExc_MemoryError, exn.what());
+  } catch (const std::bad_cast& exn) {
+    PyErr_SetString(PyExc_TypeError, exn.what());
+  } catch (const std::bad_typeid& exn) {
+    PyErr_SetString(PyExc_TypeError, exn.what());
+  } catch (const std::domain_error& exn) {
+    PyErr_SetString(PyExc_ValueError, exn.what());
+  } catch (const std::invalid_argument& exn) {
+    PyErr_SetString(PyExc_ValueError, exn.what());
+  } catch (const std::ios_base::failure& exn) {
+    // Unfortunately, in standard C++ we have no way of distinguishing EOF
+    // from other errors here; be careful with the exception mask
+    PyErr_SetString(PyExc_IOError, exn.what());
+  } catch (const std::out_of_range& exn) {
+    // Change out_of_range to IndexError
+    PyErr_SetString(PyExc_IndexError, exn.what());
+  } catch (const std::overflow_error& exn) {
+    PyErr_SetString(PyExc_OverflowError, exn.what());
+  } catch (const std::range_error& exn) {
+    PyErr_SetString(PyExc_ArithmeticError, exn.what());
+  } catch (const std::underflow_error& exn) {
+    PyErr_SetString(PyExc_ArithmeticError, exn.what());
+  } catch (const std::exception& exn) {
+    PyErr_SetString(PyExc_RuntimeError, exn.what());
+  }
+  catch (...)
+  {
+    PyErr_SetString(PyExc_RuntimeError, "Unknown exception");
+  }
+}
+#endif
+
+/////////////// PythranConversion.proto ///////////////
+
+template <class T>
+auto __Pyx_pythran_to_python(T &&value) -> decltype(to_python(
+      typename pythonic::returnable<typename std::remove_cv<typename std::remove_reference<T>::type>::type>::type{std::forward<T>(value)}))
+{
+  using returnable_type = typename pythonic::returnable<typename std::remove_cv<typename std::remove_reference<T>::type>::type>::type;
+  return to_python(returnable_type{std::forward<T>(value)});
+}
+
+#define __Pyx_PythranShapeAccessor(x) (pythonic::builtins::getattr(pythonic::types::attr::SHAPE{}, x))
+
+////////////// MoveIfSupported.proto //////////////////
+
+#if CYTHON_USE_CPP_STD_MOVE
+  #include <utility>
+  #define __PYX_STD_MOVE_IF_SUPPORTED(x) std::move(x)
+#else
+  #define __PYX_STD_MOVE_IF_SUPPORTED(x) x
+#endif
+
+////////////// EnumClassDecl.proto //////////////////
+//@proto_block: utility_code_proto_before_types
+
+#if defined (_MSC_VER)
+  #if _MSC_VER >= 1910
+    #define __PYX_ENUM_CLASS_DECL enum
+  #else
+    #define __PYX_ENUM_CLASS_DECL
+  #endif
+#else
+  #define __PYX_ENUM_CLASS_DECL enum
+#endif
+
+////////////// OptionalLocals.proto ////////////////
+//@proto_block: utility_code_proto_before_types
+
+#include <utility>
+#if defined(CYTHON_USE_BOOST_OPTIONAL)
+    // fallback mode - std::optional is preferred but this gives
+    // people with a less up-to-date compiler a chance
+    #include <boost/optional.hpp>
+    #define __Pyx_Optional_BaseType boost::optional
+#else
+    #include <optional>
+    // since std::optional is a C++17 features, a templated using declaration should be safe
+    // (although it could be replaced with a define)
+    template <typename T>
+    using __Pyx_Optional_BaseType = std::optional<T>;
+#endif
+
+// This class reuses as much of the implementation of std::optional as possible.
+// The only place it differs significantly is the assignment operators, which use
+// "emplace" (thus requiring move/copy constructors, but not move/copy
+// assignment operators). This is preferred because it lets us work with assignable
+// types (for example those with const members)
+template <typename T>
+class __Pyx_Optional_Type : private __Pyx_Optional_BaseType<T> {
+public:
+    using __Pyx_Optional_BaseType<T>::__Pyx_Optional_BaseType;
+    using __Pyx_Optional_BaseType<T>::has_value;
+    using __Pyx_Optional_BaseType<T>::operator*;
+    using __Pyx_Optional_BaseType<T>::operator->;
+#if __cplusplus >= 201103L || (defined(_MSC_VER) && _MSC_VER >= 1600)
+    __Pyx_Optional_Type& operator=(const __Pyx_Optional_Type& rhs) {
+        this->emplace(*rhs);
+        return *this;
+    }
+    __Pyx_Optional_Type& operator=(__Pyx_Optional_Type&& rhs) {
+        this->emplace(std::move(*rhs));
+        return *this;
+    }
+    template <typename U=T>
+    __Pyx_Optional_Type& operator=(U&& rhs) {
+        this->emplace(std::forward<U>(rhs));
+        return *this;
+    }
+#else
+    // Note - the "cpp_locals" feature is designed to require C++14.
+    // This pre-c++11 fallback is largely untested, and definitely won't work
+    // in all the cases that the more modern version does
+    using __Pyx_Optional_BaseType<T>::operator=; // the chances are emplace can't work...
+#endif
+};

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Utility/Dataclasses.py

@@ -0,0 +1,112 @@
+################### Dataclasses_fallback ###############################
+
+# This is the fallback dataclass code if the stdlib module isn't available.
+# It defines enough of the support types to be used with cdef classes
+# and to fail if used on regular types.
+
+# (Intended to be included as py code - not compiled)
+
+from collections import namedtuple
+try:
+    from types import MappingProxyType
+except ImportError:
+    # mutable fallback if unavailable
+    MappingProxyType = lambda x: x
+
+class _MISSING_TYPE(object):
+    pass
+MISSING = _MISSING_TYPE()
+
+_DataclassParams = namedtuple('_DataclassParams',
+    ["init", "repr", "eq", "order", "unsafe_hash", "frozen",
+     "match_args", "kw_only", "slots", "weakref_slot"])
+class Field(object):
+    __slots__ = ('name',
+                 'type',
+                 'default',
+                 'default_factory',
+                 'repr',
+                 'hash',
+                 'init',
+                 'compare',
+                 'metadata',
+                 'kw_only',
+                 '_field_type',  # Private: not to be used by user code.
+                 )
+
+    def __init__(self, default, default_factory, init, repr, hash, compare,
+                 metadata, kw_only):
+        self.name = None
+        self.type = None
+        self.default = default
+        self.default_factory = default_factory
+        self.init = init
+        self.repr = repr
+        self.hash = hash
+        self.compare = compare
+        # Be aware that if MappingProxyType is unavailable (i.e. py2?) then we
+        # don't enforce non-mutability that the real module does
+        self.metadata = (MappingProxyType({})
+                         if metadata is None else
+                         MappingProxyType(metadata))
+        self.kw_only = kw_only
+        self._field_type = None
+
+    def __repr__(self):
+        return ('Field('
+                'name={0!r},'
+                'type={1!r},'
+                'default={2!r},'
+                'default_factory={3!r},'
+                'init={4!r},'
+                'repr={5!r},'
+                'hash={6!r},'
+                'compare={7!r},'
+                'metadata={8!r},'
+                'kwonly={9!r},'
+                ')'.format(self.name, self.type, self.default,
+                           self.default_factory, self.init,
+                           self.repr, self.hash, self.compare,
+                           self.metadata, self.kw_only))
+
+# A sentinel object for default values to signal that a default
+# factory will be used.  This is given a nice repr() which will appear
+# in the function signature of dataclasses' constructors.
+class _HAS_DEFAULT_FACTORY_CLASS:
+    def __repr__(self):
+        return '<factory>'
+_HAS_DEFAULT_FACTORY = _HAS_DEFAULT_FACTORY_CLASS()
+
+def dataclass(*args, **kwds):
+    raise NotImplementedError("Standard library 'dataclasses' module"
+        "is unavailable, likely due to the version of Python you're using.")
+
+# Markers for the various kinds of fields and pseudo-fields.
+class _FIELD_BASE:
+    def __init__(self, name):
+        self.name = name
+    def __repr__(self):
+        return self.name
+_FIELD = _FIELD_BASE('_FIELD')
+_FIELD_CLASSVAR = _FIELD_BASE('_FIELD_CLASSVAR')
+_FIELD_INITVAR = _FIELD_BASE('_FIELD_INITVAR')
+
+def field(*ignore, **kwds):
+    default = kwds.pop("default", MISSING)
+    default_factory = kwds.pop("default_factory", MISSING)
+    init = kwds.pop("init", True)
+    repr = kwds.pop("repr", True)
+    hash = kwds.pop("hash", None)
+    compare = kwds.pop("compare", True)
+    metadata = kwds.pop("metadata", None)
+    kw_only = kwds.pop("kw_only", None)
+
+    if kwds:
+        raise ValueError("field received unexpected keyword arguments: %s"
+                         % list(kwds.keys()))
+    if default is not MISSING and default_factory is not MISSING:
+        raise ValueError('cannot specify both default and default_factory')
+    if ignore:
+        raise ValueError("'field' does not take any positional arguments")
+    return Field(default, default_factory, init,
+                 repr, hash, compare, metadata, kw_only)

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Utility/Exceptions.c

@@ -0,0 +1,1137 @@
+// Exception raising code
+//
+// Exceptions are raised by __Pyx_Raise() and stored as plain
+// type/value/tb in PyThreadState->curexc_*.  When being caught by an
+// 'except' statement, curexc_* is moved over to exc_* by
+// __Pyx_GetException()
+
+
+/////////////// AssertionsEnabled.init ///////////////
+
+if (likely(__Pyx_init_assertions_enabled() == 0)); else
+// error propagation code is appended automatically
+
+/////////////// AssertionsEnabled.proto ///////////////
+
+#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
+  #define __Pyx_init_assertions_enabled()  (0)
+  #define __pyx_assertions_enabled()  (1)
+#elif CYTHON_COMPILING_IN_LIMITED_API  ||  (CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030C0000)
+  // Py_OptimizeFlag is deprecated in Py3.12+ and not available in the Limited API.
+  static int __pyx_assertions_enabled_flag;
+  #define __pyx_assertions_enabled() (__pyx_assertions_enabled_flag)
+
+  static int __Pyx_init_assertions_enabled(void) {
+    PyObject *builtins, *debug, *debug_str;
+    int flag;
+    builtins = PyEval_GetBuiltins();
+    if (!builtins) goto bad;
+    debug_str = PyUnicode_FromStringAndSize("__debug__", 9);
+    if (!debug_str) goto bad;
+    debug = PyObject_GetItem(builtins, debug_str);
+    Py_DECREF(debug_str);
+    if (!debug) goto bad;
+    flag = PyObject_IsTrue(debug);
+    Py_DECREF(debug);
+    if (flag == -1) goto bad;
+    __pyx_assertions_enabled_flag = flag;
+    return 0;
+  bad:
+    __pyx_assertions_enabled_flag = 1;
+    // We (rarely) may not have an exception set, but the calling code will call PyErr_Occurred() either way.
+    return -1;
+  }
+#else
+  #define __Pyx_init_assertions_enabled()  (0)
+  #define __pyx_assertions_enabled()  (!Py_OptimizeFlag)
+#endif
+
+
+/////////////// ErrOccurredWithGIL.proto ///////////////
+static CYTHON_INLINE int __Pyx_ErrOccurredWithGIL(void); /* proto */
+
+/////////////// ErrOccurredWithGIL ///////////////
+static CYTHON_INLINE int __Pyx_ErrOccurredWithGIL(void) {
+  int err;
+  #ifdef WITH_THREAD
+  PyGILState_STATE _save = PyGILState_Ensure();
+  #endif
+  err = !!PyErr_Occurred();
+  #ifdef WITH_THREAD
+  PyGILState_Release(_save);
+  #endif
+  return err;
+}
+
+
+/////////////// PyThreadStateGet.proto ///////////////
+//@substitute: naming
+
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyThreadState_declare  PyThreadState *$local_tstate_cname;
+#define __Pyx_PyThreadState_assign  $local_tstate_cname = __Pyx_PyThreadState_Current;
+#if PY_VERSION_HEX >= 0x030C00A6
+#define __Pyx_PyErr_Occurred()  ($local_tstate_cname->current_exception != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  ($local_tstate_cname->current_exception ? (PyObject*) Py_TYPE($local_tstate_cname->current_exception) : (PyObject*) NULL)
+#else
+#define __Pyx_PyErr_Occurred()  ($local_tstate_cname->curexc_type != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  ($local_tstate_cname->curexc_type)
+#endif
+#else
+// !CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyThreadState_declare
+#define __Pyx_PyThreadState_assign
+#define __Pyx_PyErr_Occurred()  (PyErr_Occurred() != NULL)
+#define __Pyx_PyErr_CurrentExceptionType()  PyErr_Occurred()
+#endif
+
+
+/////////////// PyErrExceptionMatches.proto ///////////////
+//@substitute: naming
+
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_ExceptionMatches(err) __Pyx_PyErr_ExceptionMatchesInState($local_tstate_cname, err)
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err);
+#else
+#define __Pyx_PyErr_ExceptionMatches(err)  PyErr_ExceptionMatches(err)
+#endif
+
+/////////////// PyErrExceptionMatches ///////////////
+
+#if CYTHON_FAST_THREAD_STATE
+static int __Pyx_PyErr_ExceptionMatchesTuple(PyObject *exc_type, PyObject *tuple) {
+    Py_ssize_t i, n;
+    n = PyTuple_GET_SIZE(tuple);
+#if PY_MAJOR_VERSION >= 3
+    // the tighter subtype checking in Py3 allows faster out-of-order comparison
+    for (i=0; i<n; i++) {
+        if (exc_type == PyTuple_GET_ITEM(tuple, i)) return 1;
+    }
+#endif
+    for (i=0; i<n; i++) {
+        if (__Pyx_PyErr_GivenExceptionMatches(exc_type, PyTuple_GET_ITEM(tuple, i))) return 1;
+    }
+    return 0;
+}
+
+static CYTHON_INLINE int __Pyx_PyErr_ExceptionMatchesInState(PyThreadState* tstate, PyObject* err) {
+    int result;
+    PyObject *exc_type;
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *current_exception = tstate->current_exception;
+    if (unlikely(!current_exception)) return 0;
+    exc_type = (PyObject*) Py_TYPE(current_exception);
+    if (exc_type == err) return 1;
+#else
+    exc_type = tstate->curexc_type;
+    if (exc_type == err) return 1;
+    if (unlikely(!exc_type)) return 0;
+#endif
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_INCREF(exc_type);
+    #endif
+    if (unlikely(PyTuple_Check(err))) {
+        result = __Pyx_PyErr_ExceptionMatchesTuple(exc_type, err);
+    } else {
+        result = __Pyx_PyErr_GivenExceptionMatches(exc_type, err);
+    }
+    #if CYTHON_AVOID_BORROWED_REFS
+    Py_DECREF(exc_type);
+    #endif
+    return result;
+}
+#endif
+
+/////////////// PyErrFetchRestore.proto ///////////////
+//@substitute: naming
+//@requires: PyThreadStateGet
+
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_PyErr_Clear() __Pyx_ErrRestore(NULL, NULL, NULL)
+#define __Pyx_ErrRestoreWithState(type, value, tb)  __Pyx_ErrRestoreInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)    __Pyx_ErrFetchInState(PyThreadState_GET(), type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb)  __Pyx_ErrRestoreInState($local_tstate_cname, type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState($local_tstate_cname, type, value, tb)
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); /*proto*/
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); /*proto*/
+
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A6
+#define __Pyx_PyErr_SetNone(exc) (Py_INCREF(exc), __Pyx_ErrRestore((exc), NULL, NULL))
+#else
+#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+#endif
+
+#else
+#define __Pyx_PyErr_Clear() PyErr_Clear()
+#define __Pyx_PyErr_SetNone(exc) PyErr_SetNone(exc)
+#define __Pyx_ErrRestoreWithState(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchWithState(type, value, tb)  PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestoreInState(tstate, type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetchInState(tstate, type, value, tb)  PyErr_Fetch(type, value, tb)
+#define __Pyx_ErrRestore(type, value, tb)  PyErr_Restore(type, value, tb)
+#define __Pyx_ErrFetch(type, value, tb)  PyErr_Fetch(type, value, tb)
+#endif
+
+/////////////// PyErrFetchRestore ///////////////
+
+#if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject *tmp_value;
+    assert(type == NULL || (value != NULL && type == (PyObject*) Py_TYPE(value)));
+    if (value) {
+        #if CYTHON_COMPILING_IN_CPYTHON
+        if (unlikely(((PyBaseExceptionObject*) value)->traceback != tb))
+        #endif
+            // If this fails, we may lose the traceback but still set the expected exception below.
+            PyException_SetTraceback(value, tb);
+    }
+    tmp_value = tstate->current_exception;
+    tstate->current_exception = value;
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+#else
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    tmp_type = tstate->curexc_type;
+    tmp_value = tstate->curexc_value;
+    tmp_tb = tstate->curexc_traceback;
+    tstate->curexc_type = type;
+    tstate->curexc_value = value;
+    tstate->curexc_traceback = tb;
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#endif
+}
+
+static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+#if PY_VERSION_HEX >= 0x030C00A6
+    PyObject* exc_value;
+    exc_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    *value = exc_value;
+    *type = NULL;
+    *tb = NULL;
+    if (exc_value) {
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        *tb = ((PyBaseExceptionObject*) exc_value)->traceback;
+        Py_XINCREF(*tb);
+        #else
+        *tb = PyException_GetTraceback(exc_value);
+        #endif
+    }
+#else
+    *type = tstate->curexc_type;
+    *value = tstate->curexc_value;
+    *tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+#endif
+}
+#endif
+
+/////////////// RaiseException.proto ///////////////
+
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause); /*proto*/
+
+/////////////// RaiseException ///////////////
+//@requires: PyErrFetchRestore
+//@requires: PyThreadStateGet
+
+// The following function is based on do_raise() from ceval.c. There
+// are separate versions for Python2 and Python3 as exception handling
+// has changed quite a lot between the two versions.
+
+#if PY_MAJOR_VERSION < 3
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
+    __Pyx_PyThreadState_declare
+    CYTHON_UNUSED_VAR(cause);
+    /* 'cause' is only used in Py3 */
+    Py_XINCREF(type);
+    if (!value || value == Py_None)
+        value = NULL;
+    else
+        Py_INCREF(value);
+
+    if (!tb || tb == Py_None)
+        tb = NULL;
+    else {
+        Py_INCREF(tb);
+        if (!PyTraceBack_Check(tb)) {
+            PyErr_SetString(PyExc_TypeError,
+                "raise: arg 3 must be a traceback or None");
+            goto raise_error;
+        }
+    }
+
+    if (PyType_Check(type)) {
+        /* instantiate the type now (we don't know when and how it will be caught) */
+#if CYTHON_COMPILING_IN_PYPY
+        /* PyPy can't handle value == NULL */
+        if (!value) {
+            Py_INCREF(Py_None);
+            value = Py_None;
+        }
+#endif
+        PyErr_NormalizeException(&type, &value, &tb);
+
+    } else {
+        /* Raising an instance.  The value should be a dummy. */
+        if (value) {
+            PyErr_SetString(PyExc_TypeError,
+                "instance exception may not have a separate value");
+            goto raise_error;
+        }
+        /* Normalize to raise <class>, <instance> */
+        value = type;
+        type = (PyObject*) Py_TYPE(type);
+        Py_INCREF(type);
+        if (!PyType_IsSubtype((PyTypeObject *)type, (PyTypeObject *)PyExc_BaseException)) {
+            PyErr_SetString(PyExc_TypeError,
+                "raise: exception class must be a subclass of BaseException");
+            goto raise_error;
+        }
+    }
+
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrRestore(type, value, tb);
+    return;
+raise_error:
+    Py_XDECREF(value);
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+    return;
+}
+
+#else /* Python 3+ */
+
+static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause) {
+    PyObject* owned_instance = NULL;
+    if (tb == Py_None) {
+        tb = 0;
+    } else if (tb && !PyTraceBack_Check(tb)) {
+        PyErr_SetString(PyExc_TypeError,
+            "raise: arg 3 must be a traceback or None");
+        goto bad;
+    }
+    if (value == Py_None)
+        value = 0;
+
+    if (PyExceptionInstance_Check(type)) {
+        if (value) {
+            PyErr_SetString(PyExc_TypeError,
+                "instance exception may not have a separate value");
+            goto bad;
+        }
+        value = type;
+        type = (PyObject*) Py_TYPE(value);
+    } else if (PyExceptionClass_Check(type)) {
+        // make sure value is an exception instance of type
+        PyObject *instance_class = NULL;
+        if (value && PyExceptionInstance_Check(value)) {
+            instance_class = (PyObject*) Py_TYPE(value);
+            if (instance_class != type) {
+                int is_subclass = PyObject_IsSubclass(instance_class, type);
+                if (!is_subclass) {
+                    instance_class = NULL;
+                } else if (unlikely(is_subclass == -1)) {
+                    // error on subclass test
+                    goto bad;
+                } else {
+                    // believe the instance
+                    type = instance_class;
+                }
+            }
+        }
+        if (!instance_class) {
+            // instantiate the type now (we don't know when and how it will be caught)
+            // assuming that 'value' is an argument to the type's constructor
+            // not using PyErr_NormalizeException() to avoid ref-counting problems
+            PyObject *args;
+            if (!value)
+                args = PyTuple_New(0);
+            else if (PyTuple_Check(value)) {
+                Py_INCREF(value);
+                args = value;
+            } else
+                args = PyTuple_Pack(1, value);
+            if (!args)
+                goto bad;
+            owned_instance = PyObject_Call(type, args, NULL);
+            Py_DECREF(args);
+            if (!owned_instance)
+                goto bad;
+            value = owned_instance;
+            if (!PyExceptionInstance_Check(value)) {
+                PyErr_Format(PyExc_TypeError,
+                             "calling %R should have returned an instance of "
+                             "BaseException, not %R",
+                             type, Py_TYPE(value));
+                goto bad;
+            }
+        }
+    } else {
+        PyErr_SetString(PyExc_TypeError,
+            "raise: exception class must be a subclass of BaseException");
+        goto bad;
+    }
+
+    if (cause) {
+        PyObject *fixed_cause;
+        if (cause == Py_None) {
+            // raise ... from None
+            fixed_cause = NULL;
+        } else if (PyExceptionClass_Check(cause)) {
+            fixed_cause = PyObject_CallObject(cause, NULL);
+            if (fixed_cause == NULL)
+                goto bad;
+        } else if (PyExceptionInstance_Check(cause)) {
+            fixed_cause = cause;
+            Py_INCREF(fixed_cause);
+        } else {
+            PyErr_SetString(PyExc_TypeError,
+                            "exception causes must derive from "
+                            "BaseException");
+            goto bad;
+        }
+        PyException_SetCause(value, fixed_cause);
+    }
+
+    PyErr_SetObject(type, value);
+
+    if (tb) {
+      #if PY_VERSION_HEX >= 0x030C00A6
+        // If this fails, we just get a different exception, so ignore the return value.
+        PyException_SetTraceback(value, tb);
+      #elif CYTHON_FAST_THREAD_STATE
+        PyThreadState *tstate = __Pyx_PyThreadState_Current;
+        PyObject* tmp_tb = tstate->curexc_traceback;
+        if (tb != tmp_tb) {
+            Py_INCREF(tb);
+            tstate->curexc_traceback = tb;
+            Py_XDECREF(tmp_tb);
+        }
+#else
+        PyObject *tmp_type, *tmp_value, *tmp_tb;
+        PyErr_Fetch(&tmp_type, &tmp_value, &tmp_tb);
+        Py_INCREF(tb);
+        PyErr_Restore(tmp_type, tmp_value, tb);
+        Py_XDECREF(tmp_tb);
+#endif
+    }
+
+bad:
+    Py_XDECREF(owned_instance);
+    return;
+}
+#endif
+
+
+/////////////// GetTopmostException.proto ///////////////
+
+#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE
+static _PyErr_StackItem * __Pyx_PyErr_GetTopmostException(PyThreadState *tstate);
+#endif
+
+/////////////// GetTopmostException ///////////////
+
+#if CYTHON_USE_EXC_INFO_STACK && CYTHON_FAST_THREAD_STATE
+// Copied from errors.c in CPython.
+static _PyErr_StackItem *
+__Pyx_PyErr_GetTopmostException(PyThreadState *tstate)
+{
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    while ((exc_info->exc_value == NULL || exc_info->exc_value == Py_None) &&
+           exc_info->previous_item != NULL)
+    {
+        exc_info = exc_info->previous_item;
+    }
+    return exc_info;
+}
+#endif
+
+
+/////////////// GetException.proto ///////////////
+//@substitute: naming
+//@requires: PyThreadStateGet
+
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_GetException(type, value, tb)  __Pyx__GetException($local_tstate_cname, type, value, tb)
+static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); /*proto*/
+#else
+static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb); /*proto*/
+#endif
+
+/////////////// GetException ///////////////
+
+#if CYTHON_FAST_THREAD_STATE
+static int __Pyx__GetException(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb)
+#else
+static int __Pyx_GetException(PyObject **type, PyObject **value, PyObject **tb)
+#endif
+{
+    PyObject *local_type = NULL, *local_value, *local_tb = NULL;
+#if CYTHON_FAST_THREAD_STATE
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+  #if PY_VERSION_HEX >= 0x030C00A6
+    local_value = tstate->current_exception;
+    tstate->current_exception = 0;
+    if (likely(local_value)) {
+        local_type = (PyObject*) Py_TYPE(local_value);
+        Py_INCREF(local_type);
+        local_tb = PyException_GetTraceback(local_value);
+    }
+  #else
+    local_type = tstate->curexc_type;
+    local_value = tstate->curexc_value;
+    local_tb = tstate->curexc_traceback;
+    tstate->curexc_type = 0;
+    tstate->curexc_value = 0;
+    tstate->curexc_traceback = 0;
+  #endif
+#else
+    PyErr_Fetch(&local_type, &local_value, &local_tb);
+#endif
+
+    PyErr_NormalizeException(&local_type, &local_value, &local_tb);
+#if CYTHON_FAST_THREAD_STATE && PY_VERSION_HEX >= 0x030C00A6
+    if (unlikely(tstate->current_exception))
+#elif CYTHON_FAST_THREAD_STATE
+    if (unlikely(tstate->curexc_type))
+#else
+    if (unlikely(PyErr_Occurred()))
+#endif
+        goto bad;
+
+    #if PY_MAJOR_VERSION >= 3
+    if (local_tb) {
+        if (unlikely(PyException_SetTraceback(local_value, local_tb) < 0))
+            goto bad;
+    }
+    #endif
+
+    // traceback may be NULL for freshly raised exceptions
+    Py_XINCREF(local_tb);
+    // exception state may be temporarily empty in parallel loops (race condition)
+    Py_XINCREF(local_type);
+    Py_XINCREF(local_value);
+    *type = local_type;
+    *value = local_value;
+    *tb = local_tb;
+
+#if CYTHON_FAST_THREAD_STATE
+    #if CYTHON_USE_EXC_INFO_STACK
+    {
+        _PyErr_StackItem *exc_info = tstate->exc_info;
+      #if PY_VERSION_HEX >= 0x030B00a4
+        tmp_value = exc_info->exc_value;
+        exc_info->exc_value = local_value;
+        tmp_type = NULL;
+        tmp_tb = NULL;
+        Py_XDECREF(local_type);
+        Py_XDECREF(local_tb);
+      #else
+        tmp_type = exc_info->exc_type;
+        tmp_value = exc_info->exc_value;
+        tmp_tb = exc_info->exc_traceback;
+        exc_info->exc_type = local_type;
+        exc_info->exc_value = local_value;
+        exc_info->exc_traceback = local_tb;
+      #endif
+    }
+    #else
+    tmp_type = tstate->exc_type;
+    tmp_value = tstate->exc_value;
+    tmp_tb = tstate->exc_traceback;
+    tstate->exc_type = local_type;
+    tstate->exc_value = local_value;
+    tstate->exc_traceback = local_tb;
+    #endif
+    // Make sure tstate is in a consistent state when we XDECREF
+    // these objects (DECREF may run arbitrary code).
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+#else
+    PyErr_SetExcInfo(local_type, local_value, local_tb);
+#endif
+
+    return 0;
+
+bad:
+    *type = 0;
+    *value = 0;
+    *tb = 0;
+    Py_XDECREF(local_type);
+    Py_XDECREF(local_value);
+    Py_XDECREF(local_tb);
+    return -1;
+}
+
+/////////////// ReRaiseException.proto ///////////////
+
+static CYTHON_INLINE void __Pyx_ReraiseException(void); /*proto*/
+
+/////////////// ReRaiseException ///////////////
+//@requires: GetTopmostException
+
+static CYTHON_INLINE void __Pyx_ReraiseException(void) {
+    PyObject *type = NULL, *value = NULL, *tb = NULL;
+#if CYTHON_FAST_THREAD_STATE
+    PyThreadState *tstate = PyThreadState_GET();
+  #if CYTHON_USE_EXC_INFO_STACK
+    _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
+    value = exc_info->exc_value;
+    #if PY_VERSION_HEX >= 0x030B00a4
+    if (unlikely(value == Py_None)) {
+        value = NULL;
+    } else if (value) {
+        Py_INCREF(value);
+        type = (PyObject*) Py_TYPE(value);
+        Py_INCREF(type);
+        tb = PyException_GetTraceback(value);
+    }
+    #else
+    type = exc_info->exc_type;
+    tb = exc_info->exc_traceback;
+    Py_XINCREF(type);
+    Py_XINCREF(value);
+    Py_XINCREF(tb);
+    #endif
+  #else
+    type = tstate->exc_type;
+    value = tstate->exc_value;
+    tb = tstate->exc_traceback;
+    Py_XINCREF(type);
+    Py_XINCREF(value);
+    Py_XINCREF(tb);
+  #endif
+#else
+    PyErr_GetExcInfo(&type, &value, &tb);
+#endif
+    if (unlikely(!type || type == Py_None)) {
+        Py_XDECREF(type);
+        Py_XDECREF(value);
+        Py_XDECREF(tb);
+        // message copied from Py3
+        PyErr_SetString(PyExc_RuntimeError,
+            "No active exception to reraise");
+    } else {
+        PyErr_Restore(type, value, tb);
+    }
+}
+
+/////////////// SaveResetException.proto ///////////////
+//@substitute: naming
+//@requires: PyThreadStateGet
+
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_ExceptionSave(type, value, tb)  __Pyx__ExceptionSave($local_tstate_cname, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); /*proto*/
+#define __Pyx_ExceptionReset(type, value, tb)  __Pyx__ExceptionReset($local_tstate_cname, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb); /*proto*/
+
+#else
+
+#define __Pyx_ExceptionSave(type, value, tb)   PyErr_GetExcInfo(type, value, tb)
+#define __Pyx_ExceptionReset(type, value, tb)  PyErr_SetExcInfo(type, value, tb)
+#endif
+
+/////////////// SaveResetException ///////////////
+//@requires: GetTopmostException
+
+#if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx__ExceptionSave(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
+    PyObject *exc_value = exc_info->exc_value;
+    if (exc_value == NULL || exc_value == Py_None) {
+        *value = NULL;
+        *type = NULL;
+        *tb = NULL;
+    } else {
+        *value = exc_value;
+        Py_INCREF(*value);
+        *type = (PyObject*) Py_TYPE(exc_value);
+        Py_INCREF(*type);
+        *tb = PyException_GetTraceback(exc_value);
+    }
+  #elif CYTHON_USE_EXC_INFO_STACK
+    _PyErr_StackItem *exc_info = __Pyx_PyErr_GetTopmostException(tstate);
+    *type = exc_info->exc_type;
+    *value = exc_info->exc_value;
+    *tb = exc_info->exc_traceback;
+    Py_XINCREF(*type);
+    Py_XINCREF(*value);
+    Py_XINCREF(*tb);
+  #else
+    *type = tstate->exc_type;
+    *value = tstate->exc_value;
+    *tb = tstate->exc_traceback;
+    Py_XINCREF(*type);
+    Py_XINCREF(*value);
+    Py_XINCREF(*tb);
+  #endif
+}
+
+static CYTHON_INLINE void __Pyx__ExceptionReset(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    PyObject *tmp_value = exc_info->exc_value;
+    exc_info->exc_value = value;
+    Py_XDECREF(tmp_value);
+    // TODO: avoid passing these at all
+    Py_XDECREF(type);
+    Py_XDECREF(tb);
+  #else
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    #if CYTHON_USE_EXC_INFO_STACK
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    tmp_type = exc_info->exc_type;
+    tmp_value = exc_info->exc_value;
+    tmp_tb = exc_info->exc_traceback;
+    exc_info->exc_type = type;
+    exc_info->exc_value = value;
+    exc_info->exc_traceback = tb;
+    #else
+    tmp_type = tstate->exc_type;
+    tmp_value = tstate->exc_value;
+    tmp_tb = tstate->exc_traceback;
+    tstate->exc_type = type;
+    tstate->exc_value = value;
+    tstate->exc_traceback = tb;
+    #endif
+    Py_XDECREF(tmp_type);
+    Py_XDECREF(tmp_value);
+    Py_XDECREF(tmp_tb);
+  #endif
+}
+#endif
+
+/////////////// SwapException.proto ///////////////
+//@substitute: naming
+//@requires: PyThreadStateGet
+
+#if CYTHON_FAST_THREAD_STATE
+#define __Pyx_ExceptionSwap(type, value, tb)  __Pyx__ExceptionSwap($local_tstate_cname, type, value, tb)
+static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb); /*proto*/
+#else
+static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb); /*proto*/
+#endif
+
+/////////////// SwapException ///////////////
+
+#if CYTHON_FAST_THREAD_STATE
+static CYTHON_INLINE void __Pyx__ExceptionSwap(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+  #if CYTHON_USE_EXC_INFO_STACK && PY_VERSION_HEX >= 0x030B00a4
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    tmp_value = exc_info->exc_value;
+    exc_info->exc_value = *value;
+    if (tmp_value == NULL || tmp_value == Py_None) {
+        Py_XDECREF(tmp_value);
+        tmp_value = NULL;
+        tmp_type = NULL;
+        tmp_tb = NULL;
+    } else {
+        // TODO: avoid swapping these at all
+        tmp_type = (PyObject*) Py_TYPE(tmp_value);
+        Py_INCREF(tmp_type);
+        #if CYTHON_COMPILING_IN_CPYTHON
+        tmp_tb = ((PyBaseExceptionObject*) tmp_value)->traceback;
+        Py_XINCREF(tmp_tb);
+        #else
+        tmp_tb = PyException_GetTraceback(tmp_value);
+        #endif
+    }
+  #elif CYTHON_USE_EXC_INFO_STACK
+    _PyErr_StackItem *exc_info = tstate->exc_info;
+    tmp_type = exc_info->exc_type;
+    tmp_value = exc_info->exc_value;
+    tmp_tb = exc_info->exc_traceback;
+
+    exc_info->exc_type = *type;
+    exc_info->exc_value = *value;
+    exc_info->exc_traceback = *tb;
+  #else
+    tmp_type = tstate->exc_type;
+    tmp_value = tstate->exc_value;
+    tmp_tb = tstate->exc_traceback;
+
+    tstate->exc_type = *type;
+    tstate->exc_value = *value;
+    tstate->exc_traceback = *tb;
+  #endif
+
+    *type = tmp_type;
+    *value = tmp_value;
+    *tb = tmp_tb;
+}
+
+#else
+
+static CYTHON_INLINE void __Pyx_ExceptionSwap(PyObject **type, PyObject **value, PyObject **tb) {
+    PyObject *tmp_type, *tmp_value, *tmp_tb;
+    PyErr_GetExcInfo(&tmp_type, &tmp_value, &tmp_tb);
+    PyErr_SetExcInfo(*type, *value, *tb);
+    *type = tmp_type;
+    *value = tmp_value;
+    *tb = tmp_tb;
+}
+#endif
+
+/////////////// WriteUnraisableException.proto ///////////////
+
+static void __Pyx_WriteUnraisable(const char *name, int clineno,
+                                  int lineno, const char *filename,
+                                  int full_traceback, int nogil); /*proto*/
+
+/////////////// WriteUnraisableException ///////////////
+//@requires: PyErrFetchRestore
+//@requires: PyThreadStateGet
+
+static void __Pyx_WriteUnraisable(const char *name, int clineno,
+                                  int lineno, const char *filename,
+                                  int full_traceback, int nogil) {
+    PyObject *old_exc, *old_val, *old_tb;
+    PyObject *ctx;
+    __Pyx_PyThreadState_declare
+#ifdef WITH_THREAD
+    PyGILState_STATE state;
+    if (nogil)
+        state = PyGILState_Ensure();
+    /* arbitrary, to suppress warning */
+    else state = (PyGILState_STATE)0;
+#endif
+    CYTHON_UNUSED_VAR(clineno);
+    CYTHON_UNUSED_VAR(lineno);
+    CYTHON_UNUSED_VAR(filename);
+    CYTHON_MAYBE_UNUSED_VAR(nogil);
+
+    __Pyx_PyThreadState_assign
+    __Pyx_ErrFetch(&old_exc, &old_val, &old_tb);
+    if (full_traceback) {
+        Py_XINCREF(old_exc);
+        Py_XINCREF(old_val);
+        Py_XINCREF(old_tb);
+        __Pyx_ErrRestore(old_exc, old_val, old_tb);
+        PyErr_PrintEx(0);
+    }
+    #if PY_MAJOR_VERSION < 3
+    ctx = PyString_FromString(name);
+    #else
+    ctx = PyUnicode_FromString(name);
+    #endif
+    __Pyx_ErrRestore(old_exc, old_val, old_tb);
+    if (!ctx) {
+        PyErr_WriteUnraisable(Py_None);
+    } else {
+        PyErr_WriteUnraisable(ctx);
+        Py_DECREF(ctx);
+    }
+#ifdef WITH_THREAD
+    if (nogil)
+        PyGILState_Release(state);
+#endif
+}
+
+/////////////// CLineInTraceback.proto ///////////////
+
+#ifdef CYTHON_CLINE_IN_TRACEBACK  /* 0 or 1 to disable/enable C line display in tracebacks at C compile time */
+#define __Pyx_CLineForTraceback(tstate, c_line)  (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0)
+#else
+static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);/*proto*/
+#endif
+
+/////////////// CLineInTraceback ///////////////
+//@requires: ObjectHandling.c::PyObjectGetAttrStrNoError
+//@requires: ObjectHandling.c::PyDictVersioning
+//@requires: PyErrFetchRestore
+//@substitute: naming
+
+#ifndef CYTHON_CLINE_IN_TRACEBACK
+static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line) {
+    PyObject *use_cline;
+    PyObject *ptype, *pvalue, *ptraceback;
+#if CYTHON_COMPILING_IN_CPYTHON
+    PyObject **cython_runtime_dict;
+#endif
+
+    CYTHON_MAYBE_UNUSED_VAR(tstate);
+
+    if (unlikely(!${cython_runtime_cname})) {
+        // Very early error where the runtime module is not set up yet.
+        return c_line;
+    }
+
+    __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback);
+
+#if CYTHON_COMPILING_IN_CPYTHON
+    cython_runtime_dict = _PyObject_GetDictPtr(${cython_runtime_cname});
+    if (likely(cython_runtime_dict)) {
+        __PYX_PY_DICT_LOOKUP_IF_MODIFIED(
+            use_cline, *cython_runtime_dict,
+            __Pyx_PyDict_GetItemStr(*cython_runtime_dict, PYIDENT("cline_in_traceback")))
+    } else
+#endif
+    {
+      PyObject *use_cline_obj = __Pyx_PyObject_GetAttrStrNoError(${cython_runtime_cname}, PYIDENT("cline_in_traceback"));
+      if (use_cline_obj) {
+        use_cline = PyObject_Not(use_cline_obj) ? Py_False : Py_True;
+        Py_DECREF(use_cline_obj);
+      } else {
+        PyErr_Clear();
+        use_cline = NULL;
+      }
+    }
+    if (!use_cline) {
+        c_line = 0;
+        // No need to handle errors here when we reset the exception state just afterwards.
+        (void) PyObject_SetAttr(${cython_runtime_cname}, PYIDENT("cline_in_traceback"), Py_False);
+    }
+    else if (use_cline == Py_False || (use_cline != Py_True && PyObject_Not(use_cline) != 0)) {
+        c_line = 0;
+    }
+    __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback);
+    return c_line;
+}
+#endif
+
+/////////////// AddTraceback.proto ///////////////
+
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename); /*proto*/
+
+/////////////// AddTraceback ///////////////
+//@requires: ModuleSetupCode.c::CodeObjectCache
+//@requires: CLineInTraceback
+//@substitute: naming
+
+#include "compile.h"
+#include "frameobject.h"
+#include "traceback.h"
+#if PY_VERSION_HEX >= 0x030b00a6 && !CYTHON_COMPILING_IN_LIMITED_API
+  #ifndef Py_BUILD_CORE
+    #define Py_BUILD_CORE 1
+  #endif
+  #include "internal/pycore_frame.h"
+#endif
+
+#if CYTHON_COMPILING_IN_LIMITED_API
+static PyObject *__Pyx_PyCode_Replace_For_AddTraceback(PyObject *code, PyObject *scratch_dict,
+                                                       PyObject *firstlineno, PyObject *name) {
+    PyObject *replace = NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_firstlineno", firstlineno))) return NULL;
+    if (unlikely(PyDict_SetItemString(scratch_dict, "co_name", name))) return NULL;
+
+    replace = PyObject_GetAttrString(code, "replace");
+    if (likely(replace)) {
+        PyObject *result;
+        result = PyObject_Call(replace, $empty_tuple, scratch_dict);
+        Py_DECREF(replace);
+        return result;
+    }
+    PyErr_Clear();
+
+    #if __PYX_LIMITED_VERSION_HEX < 0x030780000
+    // If we're here, we're probably on Python <=3.7 which doesn't have code.replace.
+    // In this we take a lazy interpreted route (without regard to performance
+    // since it's fairly old and this is mostly just to get something working)
+    {
+        PyObject *compiled = NULL, *result = NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "code", code))) return NULL;
+        if (unlikely(PyDict_SetItemString(scratch_dict, "type", (PyObject*)(&PyType_Type)))) return NULL;
+        compiled = Py_CompileString(
+            "out = type(code)(\n"
+            "  code.co_argcount, code.co_kwonlyargcount, code.co_nlocals, code.co_stacksize,\n"
+            "  code.co_flags, code.co_code, code.co_consts, code.co_names,\n"
+            "  code.co_varnames, code.co_filename, co_name, co_firstlineno,\n"
+            "  code.co_lnotab)\n", "<dummy>", Py_file_input);
+        if (!compiled) return NULL;
+        result = PyEval_EvalCode(compiled, scratch_dict, scratch_dict);
+        Py_DECREF(compiled);
+        if (!result) PyErr_Print();
+        Py_DECREF(result);
+        result = PyDict_GetItemString(scratch_dict, "out");
+        if (result) Py_INCREF(result);
+        return result;
+    }
+    #else
+    return NULL;
+    #endif
+}
+
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyObject *code_object = NULL, *py_py_line = NULL, *py_funcname = NULL, *dict = NULL;
+    PyObject *replace = NULL, *getframe = NULL, *frame = NULL;
+    PyObject *exc_type, *exc_value, *exc_traceback;
+    int success = 0;
+    if (c_line) {
+        // Avoid "unused" warning as long as we don't use this.
+        (void) $cfilenm_cname;
+        (void) __Pyx_CLineForTraceback(__Pyx_PyThreadState_Current, c_line);
+    }
+
+    // DW - this is a horrendous hack, but I'm quite proud of it. Essentially
+    // we need to generate a frame with the right line number/filename/funcname.
+    // We do this by compiling a small bit of code that uses sys._getframe to get a
+    // frame, and then customizing the details of the code to match.
+    // We then run the code object and use the generated frame to set the traceback.
+
+    PyErr_Fetch(&exc_type, &exc_value, &exc_traceback);
+
+    code_object = Py_CompileString("_getframe()", filename, Py_eval_input);
+    if (unlikely(!code_object)) goto bad;
+    py_py_line = PyLong_FromLong(py_line);
+    if (unlikely(!py_py_line)) goto bad;
+    py_funcname = PyUnicode_FromString(funcname);
+    if (unlikely(!py_funcname)) goto bad;
+    dict = PyDict_New();
+    if (unlikely(!dict)) goto bad;
+    {
+        PyObject *old_code_object = code_object;
+        code_object = __Pyx_PyCode_Replace_For_AddTraceback(code_object, dict, py_py_line, py_funcname);
+        Py_DECREF(old_code_object);
+    }
+    if (unlikely(!code_object)) goto bad;
+
+    // Note that getframe is borrowed
+    getframe = PySys_GetObject("_getframe");
+    if (unlikely(!getframe)) goto bad;
+    // reuse dict as globals (nothing conflicts, and it saves an allocation)
+    if (unlikely(PyDict_SetItemString(dict, "_getframe", getframe))) goto bad;
+
+    frame = PyEval_EvalCode(code_object, dict, dict);
+    if (unlikely(!frame) || frame == Py_None) goto bad;
+    success = 1;
+
+  bad:
+    PyErr_Restore(exc_type, exc_value, exc_traceback);
+    Py_XDECREF(code_object);
+    Py_XDECREF(py_py_line);
+    Py_XDECREF(py_funcname);
+    Py_XDECREF(dict);
+    Py_XDECREF(replace);
+
+    if (success) {
+        // Unfortunately an easy way to check the type of frame isn't in the
+        // limited API. The check against None should cover the most
+        // likely wrong answer though.
+        PyTraceBack_Here(
+            // Python < 0x03090000 didn't expose PyFrameObject
+            // but they all expose struct _frame as an opaque type
+            (struct _frame*)frame);
+    }
+
+    Py_XDECREF(frame);
+}
+#else
+static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
+            const char *funcname, int c_line,
+            int py_line, const char *filename) {
+    PyCodeObject *py_code = NULL;
+    PyObject *py_funcname = NULL;
+    #if PY_MAJOR_VERSION < 3
+    PyObject *py_srcfile = NULL;
+
+    py_srcfile = PyString_FromString(filename);
+    if (!py_srcfile) goto bad;
+    #endif
+
+    if (c_line) {
+        #if PY_MAJOR_VERSION < 3
+        py_funcname = PyString_FromFormat( "%s (%s:%d)", funcname, $cfilenm_cname, c_line);
+        if (!py_funcname) goto bad;
+        #else
+        py_funcname = PyUnicode_FromFormat( "%s (%s:%d)", funcname, $cfilenm_cname, c_line);
+        if (!py_funcname) goto bad;
+        funcname = PyUnicode_AsUTF8(py_funcname);
+        if (!funcname) goto bad;
+        #endif
+    }
+    else {
+        #if PY_MAJOR_VERSION < 3
+        py_funcname = PyString_FromString(funcname);
+        if (!py_funcname) goto bad;
+        #endif
+    }
+    #if PY_MAJOR_VERSION < 3
+    py_code = __Pyx_PyCode_New(
+        0,            /*int argcount,*/
+        0,            /*int posonlyargcount,*/
+        0,            /*int kwonlyargcount,*/
+        0,            /*int nlocals,*/
+        0,            /*int stacksize,*/
+        0,            /*int flags,*/
+        $empty_bytes, /*PyObject *code,*/
+        $empty_tuple, /*PyObject *consts,*/
+        $empty_tuple, /*PyObject *names,*/
+        $empty_tuple, /*PyObject *varnames,*/
+        $empty_tuple, /*PyObject *freevars,*/
+        $empty_tuple, /*PyObject *cellvars,*/
+        py_srcfile,   /*PyObject *filename,*/
+        py_funcname,  /*PyObject *name,*/
+        py_line,      /*int firstlineno,*/
+        $empty_bytes  /*PyObject *lnotab*/
+    );
+    Py_DECREF(py_srcfile);
+    #else
+    py_code = PyCode_NewEmpty(filename, funcname, py_line);
+    #endif
+    Py_XDECREF(py_funcname);  /* XDECREF since it's only set on Py3 if cline */
+    return py_code;
+bad:
+    Py_XDECREF(py_funcname);
+    #if PY_MAJOR_VERSION < 3
+    Py_XDECREF(py_srcfile);
+    #endif
+    return NULL;
+}
+
+static void __Pyx_AddTraceback(const char *funcname, int c_line,
+                               int py_line, const char *filename) {
+    PyCodeObject *py_code = 0;
+    PyFrameObject *py_frame = 0;
+    PyThreadState *tstate = __Pyx_PyThreadState_Current;
+    PyObject *ptype, *pvalue, *ptraceback;
+
+    if (c_line) {
+        c_line = __Pyx_CLineForTraceback(tstate, c_line);
+    }
+
+    // Negate to avoid collisions between py and c lines.
+    py_code = $global_code_object_cache_find(c_line ? -c_line : py_line);
+    if (!py_code) {
+        __Pyx_ErrFetchInState(tstate, &ptype, &pvalue, &ptraceback);
+        py_code = __Pyx_CreateCodeObjectForTraceback(
+            funcname, c_line, py_line, filename);
+        if (!py_code) {
+            /* If the code object creation fails, then we should clear the
+               fetched exception references and propagate the new exception */
+            Py_XDECREF(ptype);
+            Py_XDECREF(pvalue);
+            Py_XDECREF(ptraceback);
+            goto bad;
+        }
+        __Pyx_ErrRestoreInState(tstate, ptype, pvalue, ptraceback);
+        $global_code_object_cache_insert(c_line ? -c_line : py_line, py_code);
+    }
+    py_frame = PyFrame_New(
+        tstate,            /*PyThreadState *tstate,*/
+        py_code,           /*PyCodeObject *code,*/
+        $moddict_cname,    /*PyObject *globals,*/
+        0                  /*PyObject *locals*/
+    );
+    if (!py_frame) goto bad;
+    __Pyx_PyFrame_SetLineNumber(py_frame, py_line);
+    PyTraceBack_Here(py_frame);
+bad:
+    Py_XDECREF(py_code);
+    Py_XDECREF(py_frame);
+}
+#endif

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Utility/NumpyImportArray.c

@@ -0,0 +1,46 @@
+///////////////////////// NumpyImportArray.init ////////////////////
+
+// comment below is deliberately kept in the generated C file to
+// help users debug where this came from:
+/*
+ * Cython has automatically inserted a call to _import_array since
+ * you didn't include one when you cimported numpy. To disable this
+ * add the line
+ *   <void>numpy._import_array
+ */
+#ifdef NPY_FEATURE_VERSION /* This is a public define that makes us reasonably confident it's "real" Numpy */
+// NO_IMPORT_ARRAY is Numpy's mechanism for indicating that import_array is handled elsewhere
+#ifndef NO_IMPORT_ARRAY /* https://numpy.org/doc/stable/reference/c-api/array.html#c.NO_IMPORT_ARRAY  */
+if (unlikely(_import_array() == -1)) {
+    PyErr_SetString(PyExc_ImportError, "numpy.core.multiarray failed to import "
+    "(auto-generated because you didn't call 'numpy.import_array()' after cimporting numpy; "
+    "use '<void>numpy._import_array' to disable if you are certain you don't need it).");
+}
+#endif
+#endif
+
+///////////////////////// NumpyImportUFunc.init ////////////////////
+
+// Unlike import_array, this is generated by the @cython.ufunc decorator
+// so we're confident the right headers are present and don't need to override them
+
+{
+    // NO_IMPORT_UFUNC is Numpy's mechanism for indicating that import_umath is handled elsewhere
+#ifndef NO_IMPORT_UFUNC /* https://numpy.org/doc/stable/reference/c-api/ufunc.html#c.NO_IMPORT_UFUNC */
+    if (unlikely(_import_umath() == -1)) {
+        PyErr_SetString(PyExc_ImportError, "numpy.core.umath failed to import "
+        "(auto-generated by @cython.ufunc).");
+    }
+#else
+    if ((0)) {}
+#endif
+    // NO_IMPORT_ARRAY is Numpy's mechanism for indicating that import_array is handled elsewhere
+#ifndef NO_IMPORT_ARRAY /* https://numpy.org/doc/stable/reference/c-api/array.html#c.NO_IMPORT_ARRAY  */
+    else if (unlikely(_import_array() == -1)) {
+        PyErr_SetString(PyExc_ImportError, "numpy.core.multiarray failed to import "
+        "(auto-generated by @cython.ufunc).");
+    }
+#endif
+}
+
+

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Utility/Optimize.c

@@ -0,0 +1,1616 @@
+/*
+ * Optional optimisations of built-in functions and methods.
+ *
+ * Required replacements of builtins are in Builtins.c.
+ *
+ * General object operations and protocols are in ObjectHandling.c.
+ */
+
+/////////////// append.proto ///////////////
+
+static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x); /*proto*/
+
+/////////////// append ///////////////
+//@requires: ListAppend
+//@requires: ObjectHandling.c::PyObjectCallMethod1
+
+static CYTHON_INLINE int __Pyx_PyObject_Append(PyObject* L, PyObject* x) {
+    if (likely(PyList_CheckExact(L))) {
+        if (unlikely(__Pyx_PyList_Append(L, x) < 0)) return -1;
+    } else {
+        PyObject* retval = __Pyx_PyObject_CallMethod1(L, PYIDENT("append"), x);
+        if (unlikely(!retval))
+            return -1;
+        Py_DECREF(retval);
+    }
+    return 0;
+}
+
+/////////////// ListAppend.proto ///////////////
+
+#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
+static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
+    PyListObject* L = (PyListObject*) list;
+    Py_ssize_t len = Py_SIZE(list);
+    if (likely(L->allocated > len) & likely(len > (L->allocated >> 1))) {
+        Py_INCREF(x);
+        #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+        // In Py3.13a1, PyList_SET_ITEM() checks that the end index is lower than the current size.
+        // However, extending the size *before* setting the value would not be correct,
+        // so we cannot call PyList_SET_ITEM().
+        L->ob_item[len] = x;
+        #else
+        PyList_SET_ITEM(list, len, x);
+        #endif
+        __Pyx_SET_SIZE(list, len + 1);
+        return 0;
+    }
+    return PyList_Append(list, x);
+}
+#else
+#define __Pyx_PyList_Append(L,x) PyList_Append(L,x)
+#endif
+
+/////////////// ListCompAppend.proto ///////////////
+
+#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
+static CYTHON_INLINE int __Pyx_ListComp_Append(PyObject* list, PyObject* x) {
+    PyListObject* L = (PyListObject*) list;
+    Py_ssize_t len = Py_SIZE(list);
+    if (likely(L->allocated > len)) {
+        Py_INCREF(x);
+        #if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030d0000
+        // In Py3.13a1, PyList_SET_ITEM() checks that the end index is lower than the current size.
+        // However, extending the size *before* setting the value would not be correct,
+        // so we cannot call PyList_SET_ITEM().
+        L->ob_item[len] = x;
+        #else
+        PyList_SET_ITEM(list, len, x);
+        #endif
+        __Pyx_SET_SIZE(list, len + 1);
+        return 0;
+    }
+    return PyList_Append(list, x);
+}
+#else
+#define __Pyx_ListComp_Append(L,x) PyList_Append(L,x)
+#endif
+
+//////////////////// ListExtend.proto ////////////////////
+
+static CYTHON_INLINE int __Pyx_PyList_Extend(PyObject* L, PyObject* v) {
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000
+    PyObject* none = _PyList_Extend((PyListObject*)L, v);
+    if (unlikely(!none))
+        return -1;
+    Py_DECREF(none);
+    return 0;
+#else
+    return PyList_SetSlice(L, PY_SSIZE_T_MAX, PY_SSIZE_T_MAX, v);
+#endif
+}
+
+/////////////// pop.proto ///////////////
+
+static CYTHON_INLINE PyObject* __Pyx__PyObject_Pop(PyObject* L); /*proto*/
+
+#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
+static CYTHON_INLINE PyObject* __Pyx_PyList_Pop(PyObject* L); /*proto*/
+#define __Pyx_PyObject_Pop(L) (likely(PyList_CheckExact(L)) ? \
+    __Pyx_PyList_Pop(L) : __Pyx__PyObject_Pop(L))
+
+#else
+#define __Pyx_PyList_Pop(L)  __Pyx__PyObject_Pop(L)
+#define __Pyx_PyObject_Pop(L)  __Pyx__PyObject_Pop(L)
+#endif
+
+/////////////// pop ///////////////
+//@requires: ObjectHandling.c::PyObjectCallMethod0
+
+static CYTHON_INLINE PyObject* __Pyx__PyObject_Pop(PyObject* L) {
+    if (__Pyx_IS_TYPE(L, &PySet_Type)) {
+        return PySet_Pop(L);
+    }
+    return __Pyx_PyObject_CallMethod0(L, PYIDENT("pop"));
+}
+
+#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
+static CYTHON_INLINE PyObject* __Pyx_PyList_Pop(PyObject* L) {
+    /* Check that both the size is positive and no reallocation shrinking needs to be done. */
+    if (likely(PyList_GET_SIZE(L) > (((PyListObject*)L)->allocated >> 1))) {
+        __Pyx_SET_SIZE(L, Py_SIZE(L) - 1);
+        return PyList_GET_ITEM(L, PyList_GET_SIZE(L));
+    }
+    return CALL_UNBOUND_METHOD(PyList_Type, "pop", L);
+}
+#endif
+
+
+/////////////// pop_index.proto ///////////////
+
+static PyObject* __Pyx__PyObject_PopNewIndex(PyObject* L, PyObject* py_ix); /*proto*/
+static PyObject* __Pyx__PyObject_PopIndex(PyObject* L, PyObject* py_ix); /*proto*/
+
+#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
+static PyObject* __Pyx__PyList_PopIndex(PyObject* L, PyObject* py_ix, Py_ssize_t ix); /*proto*/
+
+#define __Pyx_PyObject_PopIndex(L, py_ix, ix, is_signed, type, to_py_func) ( \
+    (likely(PyList_CheckExact(L) && __Pyx_fits_Py_ssize_t(ix, type, is_signed))) ? \
+        __Pyx__PyList_PopIndex(L, py_ix, ix) : ( \
+        (unlikely((py_ix) == Py_None)) ? __Pyx__PyObject_PopNewIndex(L, to_py_func(ix)) : \
+            __Pyx__PyObject_PopIndex(L, py_ix)))
+
+#define __Pyx_PyList_PopIndex(L, py_ix, ix, is_signed, type, to_py_func) ( \
+    __Pyx_fits_Py_ssize_t(ix, type, is_signed) ? \
+        __Pyx__PyList_PopIndex(L, py_ix, ix) : ( \
+        (unlikely((py_ix) == Py_None)) ? __Pyx__PyObject_PopNewIndex(L, to_py_func(ix)) : \
+            __Pyx__PyObject_PopIndex(L, py_ix)))
+
+#else
+
+#define __Pyx_PyList_PopIndex(L, py_ix, ix, is_signed, type, to_py_func) \
+    __Pyx_PyObject_PopIndex(L, py_ix, ix, is_signed, type, to_py_func)
+
+#define __Pyx_PyObject_PopIndex(L, py_ix, ix, is_signed, type, to_py_func) ( \
+    (unlikely((py_ix) == Py_None)) ? __Pyx__PyObject_PopNewIndex(L, to_py_func(ix)) : \
+        __Pyx__PyObject_PopIndex(L, py_ix))
+#endif
+
+/////////////// pop_index ///////////////
+//@requires: ObjectHandling.c::PyObjectCallMethod1
+
+static PyObject* __Pyx__PyObject_PopNewIndex(PyObject* L, PyObject* py_ix) {
+    PyObject *r;
+    if (unlikely(!py_ix)) return NULL;
+    r = __Pyx__PyObject_PopIndex(L, py_ix);
+    Py_DECREF(py_ix);
+    return r;
+}
+
+static PyObject* __Pyx__PyObject_PopIndex(PyObject* L, PyObject* py_ix) {
+    return __Pyx_PyObject_CallMethod1(L, PYIDENT("pop"), py_ix);
+}
+
+#if CYTHON_USE_PYLIST_INTERNALS && CYTHON_ASSUME_SAFE_MACROS
+static PyObject* __Pyx__PyList_PopIndex(PyObject* L, PyObject* py_ix, Py_ssize_t ix) {
+    Py_ssize_t size = PyList_GET_SIZE(L);
+    if (likely(size > (((PyListObject*)L)->allocated >> 1))) {
+        Py_ssize_t cix = ix;
+        if (cix < 0) {
+            cix += size;
+        }
+        if (likely(__Pyx_is_valid_index(cix, size))) {
+            PyObject* v = PyList_GET_ITEM(L, cix);
+            __Pyx_SET_SIZE(L, Py_SIZE(L) - 1);
+            size -= 1;
+            memmove(&PyList_GET_ITEM(L, cix), &PyList_GET_ITEM(L, cix+1), (size_t)(size-cix)*sizeof(PyObject*));
+            return v;
+        }
+    }
+    if (py_ix == Py_None) {
+        return __Pyx__PyObject_PopNewIndex(L, PyInt_FromSsize_t(ix));
+    } else {
+        return __Pyx__PyObject_PopIndex(L, py_ix);
+    }
+}
+#endif
+
+
+/////////////// dict_getitem_default.proto ///////////////
+
+static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value); /*proto*/
+
+/////////////// dict_getitem_default ///////////////
+
+static PyObject* __Pyx_PyDict_GetItemDefault(PyObject* d, PyObject* key, PyObject* default_value) {
+    PyObject* value;
+#if PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000)
+    value = PyDict_GetItemWithError(d, key);
+    if (unlikely(!value)) {
+        if (unlikely(PyErr_Occurred()))
+            return NULL;
+        value = default_value;
+    }
+    Py_INCREF(value);
+    // avoid C compiler warning about unused utility functions
+    if ((1));
+#else
+    if (PyString_CheckExact(key) || PyUnicode_CheckExact(key) || PyInt_CheckExact(key)) {
+        /* these presumably have safe hash functions */
+        value = PyDict_GetItem(d, key);
+        if (unlikely(!value)) {
+            value = default_value;
+        }
+        Py_INCREF(value);
+    }
+#endif
+    else {
+        if (default_value == Py_None)
+            value = CALL_UNBOUND_METHOD(PyDict_Type, "get", d, key);
+        else
+            value = CALL_UNBOUND_METHOD(PyDict_Type, "get", d, key, default_value);
+    }
+    return value;
+}
+
+
+/////////////// dict_setdefault.proto ///////////////
+
+static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value, int is_safe_type); /*proto*/
+
+/////////////// dict_setdefault ///////////////
+
+static CYTHON_INLINE PyObject *__Pyx_PyDict_SetDefault(PyObject *d, PyObject *key, PyObject *default_value,
+                                                       int is_safe_type) {
+    PyObject* value;
+    CYTHON_MAYBE_UNUSED_VAR(is_safe_type);
+#if PY_VERSION_HEX >= 0x030400A0
+    // we keep the method call at the end to avoid "unused" C compiler warnings
+    if ((1)) {
+        value = PyDict_SetDefault(d, key, default_value);
+        if (unlikely(!value)) return NULL;
+        Py_INCREF(value);
+#else
+    if (is_safe_type == 1 || (is_safe_type == -1 &&
+        /* the following builtins presumably have repeatably safe and fast hash functions */
+#if PY_MAJOR_VERSION >= 3 && (!CYTHON_COMPILING_IN_PYPY || PYPY_VERSION_NUM >= 0x07020000)
+            (PyUnicode_CheckExact(key) || PyString_CheckExact(key) || PyLong_CheckExact(key)))) {
+        value = PyDict_GetItemWithError(d, key);
+        if (unlikely(!value)) {
+            if (unlikely(PyErr_Occurred()))
+                return NULL;
+            if (unlikely(PyDict_SetItem(d, key, default_value) == -1))
+                return NULL;
+            value = default_value;
+        }
+        Py_INCREF(value);
+#else
+            (PyString_CheckExact(key) || PyUnicode_CheckExact(key) || PyInt_CheckExact(key) || PyLong_CheckExact(key)))) {
+        value = PyDict_GetItem(d, key);
+        if (unlikely(!value)) {
+            if (unlikely(PyDict_SetItem(d, key, default_value) == -1))
+                return NULL;
+            value = default_value;
+        }
+        Py_INCREF(value);
+#endif
+#endif
+    } else {
+        value = CALL_UNBOUND_METHOD(PyDict_Type, "setdefault", d, key, default_value);
+    }
+    return value;
+}
+
+
+/////////////// py_dict_clear.proto ///////////////
+
+#define __Pyx_PyDict_Clear(d) (PyDict_Clear(d), 0)
+
+
+/////////////// py_dict_pop.proto ///////////////
+
+static CYTHON_INLINE PyObject *__Pyx_PyDict_Pop(PyObject *d, PyObject *key, PyObject *default_value); /*proto*/
+
+/////////////// py_dict_pop ///////////////
+
+static CYTHON_INLINE PyObject *__Pyx_PyDict_Pop(PyObject *d, PyObject *key, PyObject *default_value) {
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX > 0x030600B3 & PY_VERSION_HEX < 0x030d0000
+    if ((1)) {
+        return _PyDict_Pop(d, key, default_value);
+    } else
+    // avoid "function unused" warnings
+#endif
+    if (default_value) {
+        return CALL_UNBOUND_METHOD(PyDict_Type, "pop", d, key, default_value);
+    } else {
+        return CALL_UNBOUND_METHOD(PyDict_Type, "pop", d, key);
+    }
+}
+
+
+/////////////// dict_iter.proto ///////////////
+
+static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* dict, int is_dict, PyObject* method_name,
+                                                   Py_ssize_t* p_orig_length, int* p_is_dict);
+static CYTHON_INLINE int __Pyx_dict_iter_next(PyObject* dict_or_iter, Py_ssize_t orig_length, Py_ssize_t* ppos,
+                                              PyObject** pkey, PyObject** pvalue, PyObject** pitem, int is_dict);
+
+/////////////// dict_iter ///////////////
+//@requires: ObjectHandling.c::UnpackTuple2
+//@requires: ObjectHandling.c::IterFinish
+//@requires: ObjectHandling.c::PyObjectCallMethod0
+
+#if CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
+#include <string.h>
+#endif
+
+static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, int is_dict, PyObject* method_name,
+                                                   Py_ssize_t* p_orig_length, int* p_source_is_dict) {
+    is_dict = is_dict || likely(PyDict_CheckExact(iterable));
+    *p_source_is_dict = is_dict;
+    if (is_dict) {
+#if !CYTHON_COMPILING_IN_PYPY
+        *p_orig_length = PyDict_Size(iterable);
+        Py_INCREF(iterable);
+        return iterable;
+#elif PY_MAJOR_VERSION >= 3
+        // On PyPy3, we need to translate manually a few method names.
+        // This logic is not needed on CPython thanks to the fast case above.
+        static PyObject *py_items = NULL, *py_keys = NULL, *py_values = NULL;
+        PyObject **pp = NULL;
+        if (method_name) {
+            const char *name = PyUnicode_AsUTF8(method_name);
+            if (strcmp(name, "iteritems") == 0) pp = &py_items;
+            else if (strcmp(name, "iterkeys") == 0) pp = &py_keys;
+            else if (strcmp(name, "itervalues") == 0) pp = &py_values;
+            if (pp) {
+                if (!*pp) {
+                    *pp = PyUnicode_FromString(name + 4);
+                    if (!*pp)
+                        return NULL;
+                }
+                method_name = *pp;
+            }
+        }
+#endif
+    }
+    *p_orig_length = 0;
+    if (method_name) {
+        PyObject* iter;
+        iterable = __Pyx_PyObject_CallMethod0(iterable, method_name);
+        if (!iterable)
+            return NULL;
+#if !CYTHON_COMPILING_IN_PYPY
+        if (PyTuple_CheckExact(iterable) || PyList_CheckExact(iterable))
+            return iterable;
+#endif
+        iter = PyObject_GetIter(iterable);
+        Py_DECREF(iterable);
+        return iter;
+    }
+    return PyObject_GetIter(iterable);
+}
+
+static CYTHON_INLINE int __Pyx_dict_iter_next(
+        PyObject* iter_obj, CYTHON_NCP_UNUSED Py_ssize_t orig_length, CYTHON_NCP_UNUSED Py_ssize_t* ppos,
+        PyObject** pkey, PyObject** pvalue, PyObject** pitem, int source_is_dict) {
+    PyObject* next_item;
+#if !CYTHON_COMPILING_IN_PYPY
+    if (source_is_dict) {
+        PyObject *key, *value;
+        if (unlikely(orig_length != PyDict_Size(iter_obj))) {
+            PyErr_SetString(PyExc_RuntimeError, "dictionary changed size during iteration");
+            return -1;
+        }
+        if (unlikely(!PyDict_Next(iter_obj, ppos, &key, &value))) {
+            return 0;
+        }
+        if (pitem) {
+            PyObject* tuple = PyTuple_New(2);
+            if (unlikely(!tuple)) {
+                return -1;
+            }
+            Py_INCREF(key);
+            Py_INCREF(value);
+            PyTuple_SET_ITEM(tuple, 0, key);
+            PyTuple_SET_ITEM(tuple, 1, value);
+            *pitem = tuple;
+        } else {
+            if (pkey) {
+                Py_INCREF(key);
+                *pkey = key;
+            }
+            if (pvalue) {
+                Py_INCREF(value);
+                *pvalue = value;
+            }
+        }
+        return 1;
+    } else if (PyTuple_CheckExact(iter_obj)) {
+        Py_ssize_t pos = *ppos;
+        if (unlikely(pos >= PyTuple_GET_SIZE(iter_obj))) return 0;
+        *ppos = pos + 1;
+        next_item = PyTuple_GET_ITEM(iter_obj, pos);
+        Py_INCREF(next_item);
+    } else if (PyList_CheckExact(iter_obj)) {
+        Py_ssize_t pos = *ppos;
+        if (unlikely(pos >= PyList_GET_SIZE(iter_obj))) return 0;
+        *ppos = pos + 1;
+        next_item = PyList_GET_ITEM(iter_obj, pos);
+        Py_INCREF(next_item);
+    } else
+#endif
+    {
+        next_item = PyIter_Next(iter_obj);
+        if (unlikely(!next_item)) {
+            return __Pyx_IterFinish();
+        }
+    }
+    if (pitem) {
+        *pitem = next_item;
+    } else if (pkey && pvalue) {
+        if (__Pyx_unpack_tuple2(next_item, pkey, pvalue, source_is_dict, source_is_dict, 1))
+            return -1;
+    } else if (pkey) {
+        *pkey = next_item;
+    } else {
+        *pvalue = next_item;
+    }
+    return 1;
+}
+
+
+/////////////// set_iter.proto ///////////////
+
+static CYTHON_INLINE PyObject* __Pyx_set_iterator(PyObject* iterable, int is_set,
+                                                  Py_ssize_t* p_orig_length, int* p_source_is_set); /*proto*/
+static CYTHON_INLINE int __Pyx_set_iter_next(
+        PyObject* iter_obj, Py_ssize_t orig_length,
+        Py_ssize_t* ppos, PyObject **value,
+        int source_is_set); /*proto*/
+
+/////////////// set_iter ///////////////
+//@requires: ObjectHandling.c::IterFinish
+
+static CYTHON_INLINE PyObject* __Pyx_set_iterator(PyObject* iterable, int is_set,
+                                                  Py_ssize_t* p_orig_length, int* p_source_is_set) {
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000
+    is_set = is_set || likely(PySet_CheckExact(iterable) || PyFrozenSet_CheckExact(iterable));
+    *p_source_is_set = is_set;
+    if (likely(is_set)) {
+        *p_orig_length = PySet_Size(iterable);
+        Py_INCREF(iterable);
+        return iterable;
+    }
+#else
+    CYTHON_UNUSED_VAR(is_set);
+    *p_source_is_set = 0;
+#endif
+    *p_orig_length = 0;
+    return PyObject_GetIter(iterable);
+}
+
+static CYTHON_INLINE int __Pyx_set_iter_next(
+        PyObject* iter_obj, Py_ssize_t orig_length,
+        Py_ssize_t* ppos, PyObject **value,
+        int source_is_set) {
+    if (!CYTHON_COMPILING_IN_CPYTHON || PY_VERSION_HEX >= 0x030d0000 || unlikely(!source_is_set)) {
+        *value = PyIter_Next(iter_obj);
+        if (unlikely(!*value)) {
+            return __Pyx_IterFinish();
+        }
+        CYTHON_UNUSED_VAR(orig_length);
+        CYTHON_UNUSED_VAR(ppos);
+        return 1;
+    }
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030d0000
+    if (unlikely(PySet_GET_SIZE(iter_obj) != orig_length)) {
+        PyErr_SetString(
+            PyExc_RuntimeError,
+            "set changed size during iteration");
+        return -1;
+    }
+    {
+        Py_hash_t hash;
+        int ret = _PySet_NextEntry(iter_obj, ppos, value, &hash);
+        // CPython does not raise errors here, only if !isinstance(iter_obj, set/frozenset)
+        assert (ret != -1);
+        if (likely(ret)) {
+            Py_INCREF(*value);
+            return 1;
+        }
+    }
+#endif
+    return 0;
+}
+
+/////////////// py_set_discard_unhashable ///////////////
+//@requires: Builtins.c::pyfrozenset_new
+
+static int __Pyx_PySet_DiscardUnhashable(PyObject *set, PyObject *key) {
+    PyObject *tmpkey;
+    int rv;
+
+    if (likely(!PySet_Check(key) || !PyErr_ExceptionMatches(PyExc_TypeError)))
+        return -1;
+    PyErr_Clear();
+    tmpkey = __Pyx_PyFrozenSet_New(key);
+    if (tmpkey == NULL)
+        return -1;
+    rv = PySet_Discard(set, tmpkey);
+    Py_DECREF(tmpkey);
+    return rv;
+}
+
+
+/////////////// py_set_discard.proto ///////////////
+
+static CYTHON_INLINE int __Pyx_PySet_Discard(PyObject *set, PyObject *key); /*proto*/
+
+/////////////// py_set_discard ///////////////
+//@requires: py_set_discard_unhashable
+
+static CYTHON_INLINE int __Pyx_PySet_Discard(PyObject *set, PyObject *key) {
+    int found = PySet_Discard(set, key);
+    // Convert *key* to frozenset if necessary
+    if (unlikely(found < 0)) {
+        found = __Pyx_PySet_DiscardUnhashable(set, key);
+    }
+    // note: returns -1 on error, 0 (not found) or 1 (found) otherwise => error check for -1 or < 0 works
+    return found;
+}
+
+
+/////////////// py_set_remove.proto ///////////////
+
+static CYTHON_INLINE int __Pyx_PySet_Remove(PyObject *set, PyObject *key); /*proto*/
+
+/////////////// py_set_remove ///////////////
+//@requires: py_set_discard_unhashable
+
+static int __Pyx_PySet_RemoveNotFound(PyObject *set, PyObject *key, int found) {
+    // Convert *key* to frozenset if necessary
+    if (unlikely(found < 0)) {
+        found = __Pyx_PySet_DiscardUnhashable(set, key);
+    }
+    if (likely(found == 0)) {
+        // Not found
+        PyObject *tup;
+        tup = PyTuple_Pack(1, key);
+        if (!tup)
+            return -1;
+        PyErr_SetObject(PyExc_KeyError, tup);
+        Py_DECREF(tup);
+        return -1;
+    }
+    // note: returns -1 on error, 0 (not found) or 1 (found) otherwise => error check for -1 or < 0 works
+    return found;
+}
+
+static CYTHON_INLINE int __Pyx_PySet_Remove(PyObject *set, PyObject *key) {
+    int found = PySet_Discard(set, key);
+    if (unlikely(found != 1)) {
+        // note: returns -1 on error, 0 (not found) or 1 (found) otherwise => error check for -1 or < 0 works
+        return __Pyx_PySet_RemoveNotFound(set, key, found);
+    }
+    return 0;
+}
+
+
+/////////////// unicode_iter.proto ///////////////
+
+static CYTHON_INLINE int __Pyx_init_unicode_iteration(
+    PyObject* ustring, Py_ssize_t *length, void** data, int *kind); /* proto */
+
+/////////////// unicode_iter ///////////////
+
+static CYTHON_INLINE int __Pyx_init_unicode_iteration(
+    PyObject* ustring, Py_ssize_t *length, void** data, int *kind) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+    // In the limited API we just point data to the unicode object
+    *kind   = 0;
+    *length = PyUnicode_GetLength(ustring);
+    *data   = (void*)ustring;
+#elif CYTHON_PEP393_ENABLED
+    if (unlikely(__Pyx_PyUnicode_READY(ustring) < 0)) return -1;
+    *kind   = PyUnicode_KIND(ustring);
+    *length = PyUnicode_GET_LENGTH(ustring);
+    *data   = PyUnicode_DATA(ustring);
+#else
+    *kind   = 0;
+    *length = PyUnicode_GET_SIZE(ustring);
+    *data   = (void*)PyUnicode_AS_UNICODE(ustring);
+#endif
+    return 0;
+}
+
+/////////////// pyobject_as_double.proto ///////////////
+
+static double __Pyx__PyObject_AsDouble(PyObject* obj); /* proto */
+
+#if CYTHON_COMPILING_IN_PYPY
+#define __Pyx_PyObject_AsDouble(obj) \
+(likely(PyFloat_CheckExact(obj)) ? PyFloat_AS_DOUBLE(obj) : \
+ likely(PyInt_CheckExact(obj)) ? \
+ PyFloat_AsDouble(obj) : __Pyx__PyObject_AsDouble(obj))
+#else
+#define __Pyx_PyObject_AsDouble(obj) \
+((likely(PyFloat_CheckExact(obj))) ?  PyFloat_AS_DOUBLE(obj) : \
+ likely(PyLong_CheckExact(obj)) ? \
+ PyLong_AsDouble(obj) : __Pyx__PyObject_AsDouble(obj))
+#endif
+
+/////////////// pyobject_as_double ///////////////
+//@requires: pybytes_as_double
+//@requires: pyunicode_as_double
+//@requires: ObjectHandling.c::PyObjectCallOneArg
+
+static double __Pyx__PyObject_AsDouble(PyObject* obj) {
+    if (PyUnicode_CheckExact(obj)) {
+        return __Pyx_PyUnicode_AsDouble(obj);
+    } else if (PyBytes_CheckExact(obj)) {
+        return __Pyx_PyBytes_AsDouble(obj);
+    } else if (PyByteArray_CheckExact(obj)) {
+        return __Pyx_PyByteArray_AsDouble(obj);
+    } else {
+        PyObject* float_value;
+#if !CYTHON_USE_TYPE_SLOTS
+        float_value = PyNumber_Float(obj);  if ((0)) goto bad;
+        // avoid "unused" warnings
+        (void)__Pyx_PyObject_CallOneArg;
+#else
+        PyNumberMethods *nb = Py_TYPE(obj)->tp_as_number;
+        if (likely(nb) && likely(nb->nb_float)) {
+            float_value = nb->nb_float(obj);
+            if (likely(float_value) && unlikely(!PyFloat_Check(float_value))) {
+                __Pyx_TypeName float_value_type_name = __Pyx_PyType_GetName(Py_TYPE(float_value));
+                PyErr_Format(PyExc_TypeError,
+                    "__float__ returned non-float (type " __Pyx_FMT_TYPENAME ")",
+                    float_value_type_name);
+                __Pyx_DECREF_TypeName(float_value_type_name);
+                Py_DECREF(float_value);
+                goto bad;
+            }
+        } else {
+            float_value = __Pyx_PyObject_CallOneArg((PyObject*)&PyFloat_Type, obj);
+        }
+#endif
+        if (likely(float_value)) {
+            double value = PyFloat_AS_DOUBLE(float_value);
+            Py_DECREF(float_value);
+            return value;
+        }
+    }
+bad:
+    return (double)-1;
+}
+
+
+/////////////// pystring_as_double.proto ///////////////
+//@requires: pyunicode_as_double
+//@requires: pybytes_as_double
+
+static CYTHON_INLINE double __Pyx_PyString_AsDouble(PyObject *obj) {
+    #if PY_MAJOR_VERSION >= 3
+    (void)__Pyx_PyBytes_AsDouble;
+    return __Pyx_PyUnicode_AsDouble(obj);
+    #else
+    (void)__Pyx_PyUnicode_AsDouble;
+    return __Pyx_PyBytes_AsDouble(obj);
+    #endif
+}
+
+
+/////////////// pyunicode_as_double.proto ///////////////
+
+static CYTHON_INLINE double __Pyx_PyUnicode_AsDouble(PyObject *obj);/*proto*/
+
+/////////////// pyunicode_as_double.proto ///////////////
+//@requires: pybytes_as_double
+
+#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY && CYTHON_ASSUME_SAFE_MACROS
+static const char* __Pyx__PyUnicode_AsDouble_Copy(const void* data, const int kind, char* buffer, Py_ssize_t start, Py_ssize_t end) {
+    int last_was_punctuation;
+    Py_ssize_t i;
+    // number must not start with punctuation
+    last_was_punctuation = 1;
+    for (i=start; i <= end; i++) {
+        Py_UCS4 chr = PyUnicode_READ(kind, data, i);
+        int is_punctuation = (chr == '_') | (chr == '.');
+        *buffer = (char)chr;
+        // reject sequences of '_' and '.'
+        buffer += (chr != '_');
+        if (unlikely(chr > 127)) goto parse_failure;
+        if (unlikely(last_was_punctuation & is_punctuation)) goto parse_failure;
+        last_was_punctuation = is_punctuation;
+    }
+    if (unlikely(last_was_punctuation)) goto parse_failure;
+    *buffer = '\0';
+    return buffer;
+
+parse_failure:
+    return NULL;
+}
+
+static double __Pyx__PyUnicode_AsDouble_inf_nan(const void* data, int kind, Py_ssize_t start, Py_ssize_t length) {
+    int matches = 1;
+    Py_UCS4 chr;
+    Py_UCS4 sign = PyUnicode_READ(kind, data, start);
+    int is_signed = (sign == '-') | (sign == '+');
+    start += is_signed;
+    length -= is_signed;
+
+    switch (PyUnicode_READ(kind, data, start)) {
+        #ifdef Py_NAN
+        case 'n':
+        case 'N':
+            if (unlikely(length != 3)) goto parse_failure;
+            chr = PyUnicode_READ(kind, data, start+1);
+            matches &= (chr == 'a') | (chr == 'A');
+            chr = PyUnicode_READ(kind, data, start+2);
+            matches &= (chr == 'n') | (chr == 'N');
+            if (unlikely(!matches)) goto parse_failure;
+            return (sign == '-') ? -Py_NAN : Py_NAN;
+        #endif
+        case 'i':
+        case 'I':
+            if (unlikely(length < 3)) goto parse_failure;
+            chr = PyUnicode_READ(kind, data, start+1);
+            matches &= (chr == 'n') | (chr == 'N');
+            chr = PyUnicode_READ(kind, data, start+2);
+            matches &= (chr == 'f') | (chr == 'F');
+            if (likely(length == 3 && matches))
+                return (sign == '-') ? -Py_HUGE_VAL : Py_HUGE_VAL;
+            if (unlikely(length != 8)) goto parse_failure;
+            chr = PyUnicode_READ(kind, data, start+3);
+            matches &= (chr == 'i') | (chr == 'I');
+            chr = PyUnicode_READ(kind, data, start+4);
+            matches &= (chr == 'n') | (chr == 'N');
+            chr = PyUnicode_READ(kind, data, start+5);
+            matches &= (chr == 'i') | (chr == 'I');
+            chr = PyUnicode_READ(kind, data, start+6);
+            matches &= (chr == 't') | (chr == 'T');
+            chr = PyUnicode_READ(kind, data, start+7);
+            matches &= (chr == 'y') | (chr == 'Y');
+            if (unlikely(!matches)) goto parse_failure;
+            return (sign == '-') ? -Py_HUGE_VAL : Py_HUGE_VAL;
+        case '.': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
+            break;
+        default:
+            goto parse_failure;
+    }
+    return 0.0;
+parse_failure:
+    return -1.0;
+}
+
+static double __Pyx_PyUnicode_AsDouble_WithSpaces(PyObject *obj) {
+    double value;
+    const char *last;
+    char *end;
+    Py_ssize_t start, length = PyUnicode_GET_LENGTH(obj);
+    const int kind = PyUnicode_KIND(obj);
+    const void* data = PyUnicode_DATA(obj);
+
+    // strip spaces at start and end
+    start = 0;
+    while (Py_UNICODE_ISSPACE(PyUnicode_READ(kind, data, start)))
+        start++;
+    while (start < length - 1 && Py_UNICODE_ISSPACE(PyUnicode_READ(kind, data, length - 1)))
+        length--;
+    length -= start;
+    if (unlikely(length <= 0)) goto fallback;
+
+    // parse NaN / inf
+    value = __Pyx__PyUnicode_AsDouble_inf_nan(data, kind, start, length);
+    if (unlikely(value == -1.0)) goto fallback;
+    if (value != 0.0) return value;
+
+    if (length < 40) {
+        char number[40];
+        last = __Pyx__PyUnicode_AsDouble_Copy(data, kind, number, start, start + length);
+        if (unlikely(!last)) goto fallback;
+        value = PyOS_string_to_double(number, &end, NULL);
+    } else {
+        char *number = (char*) PyMem_Malloc((length + 1) * sizeof(char));
+        if (unlikely(!number)) goto fallback;
+        last = __Pyx__PyUnicode_AsDouble_Copy(data, kind, number, start, start + length);
+        if (unlikely(!last)) {
+            PyMem_Free(number);
+            goto fallback;
+        }
+        value = PyOS_string_to_double(number, &end, NULL);
+        PyMem_Free(number);
+    }
+    if (likely(end == last) || (value == (double)-1 && PyErr_Occurred())) {
+        return value;
+    }
+fallback:
+    return __Pyx_SlowPyString_AsDouble(obj);
+}
+#endif
+
+static CYTHON_INLINE double __Pyx_PyUnicode_AsDouble(PyObject *obj) {
+    // Currently not optimised for Py2.7.
+#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY && CYTHON_ASSUME_SAFE_MACROS
+    if (unlikely(__Pyx_PyUnicode_READY(obj) == -1))
+        return (double)-1;
+    if (likely(PyUnicode_IS_ASCII(obj))) {
+        const char *s;
+        Py_ssize_t length;
+        s = PyUnicode_AsUTF8AndSize(obj, &length);
+        return __Pyx__PyBytes_AsDouble(obj, s, length);
+    }
+    return __Pyx_PyUnicode_AsDouble_WithSpaces(obj);
+#else
+    return __Pyx_SlowPyString_AsDouble(obj);
+#endif
+}
+
+
+/////////////// pybytes_as_double.proto ///////////////
+
+static double __Pyx_SlowPyString_AsDouble(PyObject *obj);/*proto*/
+static double __Pyx__PyBytes_AsDouble(PyObject *obj, const char* start, Py_ssize_t length);/*proto*/
+
+static CYTHON_INLINE double __Pyx_PyBytes_AsDouble(PyObject *obj) {
+    char* as_c_string;
+    Py_ssize_t size;
+#if CYTHON_ASSUME_SAFE_MACROS
+    as_c_string = PyBytes_AS_STRING(obj);
+    size = PyBytes_GET_SIZE(obj);
+#else
+    if (PyBytes_AsStringAndSize(obj, &as_c_string, &size) < 0) {
+        return (double)-1;
+    }
+#endif
+    return __Pyx__PyBytes_AsDouble(obj, as_c_string, size);
+}
+static CYTHON_INLINE double __Pyx_PyByteArray_AsDouble(PyObject *obj) {
+    char* as_c_string;
+    Py_ssize_t size;
+#if CYTHON_ASSUME_SAFE_MACROS
+    as_c_string = PyByteArray_AS_STRING(obj);
+    size = PyByteArray_GET_SIZE(obj);
+#else
+    as_c_string = PyByteArray_AsString(obj);
+    if (as_c_string == NULL) {
+        return (double)-1;
+    }
+    size = PyByteArray_Size(obj);
+#endif
+    return __Pyx__PyBytes_AsDouble(obj, as_c_string, size);
+}
+
+
+/////////////// pybytes_as_double ///////////////
+
+static double __Pyx_SlowPyString_AsDouble(PyObject *obj) {
+    PyObject *float_value;
+#if PY_MAJOR_VERSION >= 3
+    float_value = PyFloat_FromString(obj);
+#else
+    float_value = PyFloat_FromString(obj, 0);
+#endif
+    if (likely(float_value)) {
+#if CYTHON_ASSUME_SAFE_MACROS
+        double value = PyFloat_AS_DOUBLE(float_value);
+#else
+        double value = PyFloat_AsDouble(float_value);
+#endif
+        Py_DECREF(float_value);
+        return value;
+    }
+    return (double)-1;
+}
+
+static const char* __Pyx__PyBytes_AsDouble_Copy(const char* start, char* buffer, Py_ssize_t length) {
+    // number must not start with punctuation
+    int last_was_punctuation = 1;
+    Py_ssize_t i;
+    for (i=0; i < length; i++) {
+        char chr = start[i];
+        int is_punctuation = (chr == '_') | (chr == '.') | (chr == 'e') | (chr == 'E');
+        *buffer = chr;
+        buffer += (chr != '_');
+        // reject sequences of '_' and '.'
+        if (unlikely(last_was_punctuation & is_punctuation)) goto parse_failure;
+        last_was_punctuation = is_punctuation;
+    }
+    if (unlikely(last_was_punctuation)) goto parse_failure;
+    *buffer = '\0';
+    return buffer;
+
+parse_failure:
+    return NULL;
+}
+
+static double __Pyx__PyBytes_AsDouble_inf_nan(const char* start, Py_ssize_t length) {
+    int matches = 1;
+    char sign = start[0];
+    int is_signed = (sign == '+') | (sign == '-');
+    start += is_signed;
+    length -= is_signed;
+
+    switch (start[0]) {
+        #ifdef Py_NAN
+        case 'n':
+        case 'N':
+            if (unlikely(length != 3)) goto parse_failure;
+            matches &= (start[1] == 'a' || start[1] == 'A');
+            matches &= (start[2] == 'n' || start[2] == 'N');
+            if (unlikely(!matches)) goto parse_failure;
+            return (sign == '-') ? -Py_NAN : Py_NAN;
+        #endif
+        case 'i':
+        case 'I':
+            if (unlikely(length < 3)) goto parse_failure;
+            matches &= (start[1] == 'n' || start[1] == 'N');
+            matches &= (start[2] == 'f' || start[2] == 'F');
+            if (likely(length == 3 && matches))
+                return (sign == '-') ? -Py_HUGE_VAL : Py_HUGE_VAL;
+            if (unlikely(length != 8)) goto parse_failure;
+            matches &= (start[3] == 'i' || start[3] == 'I');
+            matches &= (start[4] == 'n' || start[4] == 'N');
+            matches &= (start[5] == 'i' || start[5] == 'I');
+            matches &= (start[6] == 't' || start[6] == 'T');
+            matches &= (start[7] == 'y' || start[7] == 'Y');
+            if (unlikely(!matches)) goto parse_failure;
+            return (sign == '-') ? -Py_HUGE_VAL : Py_HUGE_VAL;
+        case '.': case '0': case '1': case '2': case '3': case '4': case '5': case '6': case '7': case '8': case '9':
+            break;
+        default:
+            goto parse_failure;
+    }
+    return 0.0;
+parse_failure:
+    return -1.0;
+}
+
+static CYTHON_INLINE int __Pyx__PyBytes_AsDouble_IsSpace(char ch) {
+    // see Py_ISSPACE() in CPython
+    // https://github.com/python/cpython/blob/master/Python/pyctype.c
+    return (ch == 0x20) | !((ch < 0x9) | (ch > 0xd));
+}
+
+CYTHON_UNUSED static double __Pyx__PyBytes_AsDouble(PyObject *obj, const char* start, Py_ssize_t length) {
+    double value;
+    Py_ssize_t i, digits;
+    const char *last = start + length;
+    char *end;
+
+    // strip spaces at start and end
+    while (__Pyx__PyBytes_AsDouble_IsSpace(*start))
+        start++;
+    while (start < last - 1 && __Pyx__PyBytes_AsDouble_IsSpace(last[-1]))
+        last--;
+    length = last - start;
+    if (unlikely(length <= 0)) goto fallback;
+
+    // parse NaN / inf
+    value = __Pyx__PyBytes_AsDouble_inf_nan(start, length);
+    if (unlikely(value == -1.0)) goto fallback;
+    if (value != 0.0) return value;
+
+    // look for underscores
+    digits = 0;
+    for (i=0; i < length; digits += start[i++] != '_');
+
+    if (likely(digits == length)) {
+        value = PyOS_string_to_double(start, &end, NULL);
+    } else if (digits < 40) {
+        char number[40];
+        last = __Pyx__PyBytes_AsDouble_Copy(start, number, length);
+        if (unlikely(!last)) goto fallback;
+        value = PyOS_string_to_double(number, &end, NULL);
+    } else {
+        char *number = (char*) PyMem_Malloc((digits + 1) * sizeof(char));
+        if (unlikely(!number)) goto fallback;
+        last = __Pyx__PyBytes_AsDouble_Copy(start, number, length);
+        if (unlikely(!last)) {
+            PyMem_Free(number);
+            goto fallback;
+        }
+        value = PyOS_string_to_double(number, &end, NULL);
+        PyMem_Free(number);
+    }
+    if (likely(end == last) || (value == (double)-1 && PyErr_Occurred())) {
+        return value;
+    }
+fallback:
+    return __Pyx_SlowPyString_AsDouble(obj);
+}
+
+
+/////////////// PyNumberPow2.proto ///////////////
+
+#define __Pyx_PyNumber_InPlacePowerOf2(a, b, c) __Pyx__PyNumber_PowerOf2(a, b, c, 1)
+#define __Pyx_PyNumber_PowerOf2(a, b, c) __Pyx__PyNumber_PowerOf2(a, b, c, 0)
+
+static PyObject* __Pyx__PyNumber_PowerOf2(PyObject *two, PyObject *exp, PyObject *none, int inplace); /*proto*/
+
+/////////////// PyNumberPow2 ///////////////
+
+static PyObject* __Pyx__PyNumber_PowerOf2(PyObject *two, PyObject *exp, PyObject *none, int inplace) {
+// in CPython, 1<<N is substantially faster than 2**N
+// see https://bugs.python.org/issue21420
+#if !CYTHON_COMPILING_IN_PYPY
+    Py_ssize_t shiftby;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_CheckExact(exp))) {
+        shiftby = PyInt_AS_LONG(exp);
+    } else
+#endif
+    if (likely(PyLong_CheckExact(exp))) {
+        #if CYTHON_USE_PYLONG_INTERNALS
+        if (__Pyx_PyLong_IsZero(exp)) {
+            return PyInt_FromLong(1L);
+        } else if (__Pyx_PyLong_IsNeg(exp)) {
+            goto fallback;
+        } else if (__Pyx_PyLong_IsCompact(exp)) {
+            shiftby = __Pyx_PyLong_CompactValueUnsigned(exp);
+        } else {
+            shiftby = PyLong_AsSsize_t(exp);
+        }
+        #else
+        shiftby = PyLong_AsSsize_t(exp);
+        #endif
+    } else {
+        goto fallback;
+    }
+    if (likely(shiftby >= 0)) {
+        if ((size_t)shiftby <= sizeof(long) * 8 - 2) {
+            long value = 1L << shiftby;
+            return PyInt_FromLong(value);
+#ifdef HAVE_LONG_LONG
+        } else if ((size_t)shiftby <= sizeof(unsigned PY_LONG_LONG) * 8 - 1) {
+            unsigned PY_LONG_LONG value = ((unsigned PY_LONG_LONG)1) << shiftby;
+            return PyLong_FromUnsignedLongLong(value);
+#endif
+        } else {
+            PyObject *result, *one = PyInt_FromLong(1L);
+            if (unlikely(!one)) return NULL;
+            result = PyNumber_Lshift(one, exp);
+            Py_DECREF(one);
+            return result;
+        }
+    } else if (shiftby == -1 && PyErr_Occurred()) {
+        PyErr_Clear();
+    }
+fallback:
+#endif
+    return (inplace ? PyNumber_InPlacePower : PyNumber_Power)(two, exp, none);
+}
+
+
+/////////////// PyIntCompare.proto ///////////////
+
+{{py: c_ret_type = 'PyObject*' if ret_type.is_pyobject else 'int'}}
+static CYTHON_INLINE {{c_ret_type}} __Pyx_PyInt_{{'' if ret_type.is_pyobject else 'Bool'}}{{op}}{{order}}(PyObject *op1, PyObject *op2, long intval, long inplace); /*proto*/
+
+/////////////// PyIntCompare ///////////////
+
+{{py: pyval, ival = ('op2', 'b') if order == 'CObj' else ('op1', 'a') }}
+{{py: c_ret_type = 'PyObject*' if ret_type.is_pyobject else 'int'}}
+{{py: return_true = 'Py_RETURN_TRUE' if ret_type.is_pyobject else 'return 1'}}
+{{py: return_false = 'Py_RETURN_FALSE' if ret_type.is_pyobject else 'return 0'}}
+{{py: slot_name = op.lower() }}
+{{py: c_op = {'Eq': '==', 'Ne': '!='}[op] }}
+{{py:
+return_compare = (
+    (lambda a,b,c_op, return_true=return_true, return_false=return_false: "if ({a} {c_op} {b}) {return_true}; else {return_false};".format(
+        a=a, b=b, c_op=c_op, return_true=return_true, return_false=return_false))
+    if ret_type.is_pyobject else
+    (lambda a,b,c_op: "return ({a} {c_op} {b});".format(a=a, b=b, c_op=c_op))
+    )
+}}
+
+static CYTHON_INLINE {{c_ret_type}} __Pyx_PyInt_{{'' if ret_type.is_pyobject else 'Bool'}}{{op}}{{order}}(PyObject *op1, PyObject *op2, long intval, long inplace) {
+    CYTHON_MAYBE_UNUSED_VAR(intval);
+    CYTHON_UNUSED_VAR(inplace);
+    if (op1 == op2) {
+        {{return_true if op == 'Eq' else return_false}};
+    }
+
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_CheckExact({{pyval}}))) {
+        const long {{'a' if order == 'CObj' else 'b'}} = intval;
+        long {{ival}} = PyInt_AS_LONG({{pyval}});
+        {{return_compare('a', 'b', c_op)}}
+    }
+    #endif
+
+    #if CYTHON_USE_PYLONG_INTERNALS
+    if (likely(PyLong_CheckExact({{pyval}}))) {
+        int unequal;
+        unsigned long uintval;
+        Py_ssize_t size = __Pyx_PyLong_DigitCount({{pyval}});
+        const digit* digits = __Pyx_PyLong_Digits({{pyval}});
+        if (intval == 0) {
+            {{return_compare('__Pyx_PyLong_IsZero(%s)' % pyval, '1', c_op)}}
+        } else if (intval < 0) {
+            if (__Pyx_PyLong_IsNonNeg({{pyval}}))
+                {{return_false if op == 'Eq' else return_true}};
+            // both are negative => can use absolute values now.
+            intval = -intval;
+        } else {
+            // > 0  =>  Py_SIZE(pyval) > 0
+            if (__Pyx_PyLong_IsNeg({{pyval}}))
+                {{return_false if op == 'Eq' else return_true}};
+        }
+        // After checking that the sign is the same (and excluding 0), now compare the absolute values.
+        // When inlining, the C compiler should select exactly one line from this unrolled loop.
+        uintval = (unsigned long) intval;
+        {{for _size in range(4, 0, -1)}}
+#if PyLong_SHIFT * {{_size}} < SIZEOF_LONG*8
+        if (uintval >> (PyLong_SHIFT * {{_size}})) {
+            // The C integer value is between (PyLong_BASE ** _size) and MIN(PyLong_BASE ** _size, LONG_MAX).
+            unequal = (size != {{_size+1}}) || (digits[0] != (uintval & (unsigned long) PyLong_MASK))
+                {{for _i in range(1, _size+1)}} | (digits[{{_i}}] != ((uintval >> ({{_i}} * PyLong_SHIFT)) & (unsigned long) PyLong_MASK)){{endfor}};
+        } else
+#endif
+        {{endfor}}
+            unequal = (size != 1) || (((unsigned long) digits[0]) != (uintval & (unsigned long) PyLong_MASK));
+
+        {{return_compare('unequal', '0', c_op)}}
+    }
+    #endif
+
+    if (PyFloat_CheckExact({{pyval}})) {
+        const long {{'a' if order == 'CObj' else 'b'}} = intval;
+#if CYTHON_COMPILING_IN_LIMITED_API
+        double {{ival}} = __pyx_PyFloat_AsDouble({{pyval}});
+#else
+        double {{ival}} = PyFloat_AS_DOUBLE({{pyval}});
+#endif
+        {{return_compare('(double)a', '(double)b', c_op)}}
+    }
+
+    return {{'' if ret_type.is_pyobject else '__Pyx_PyObject_IsTrueAndDecref'}}(
+        PyObject_RichCompare(op1, op2, Py_{{op.upper()}}));
+}
+
+
+/////////////// PyIntBinop.proto ///////////////
+
+{{py: c_ret_type = 'PyObject*' if ret_type.is_pyobject else 'int'}}
+#if !CYTHON_COMPILING_IN_PYPY
+static {{c_ret_type}} __Pyx_PyInt_{{'' if ret_type.is_pyobject else 'Bool'}}{{op}}{{order}}(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check); /*proto*/
+#else
+#define __Pyx_PyInt_{{'' if ret_type.is_pyobject else 'Bool'}}{{op}}{{order}}(op1, op2, intval, inplace, zerodivision_check) \
+    {{if op in ('Eq', 'Ne')}}{{'' if ret_type.is_pyobject else '__Pyx_PyObject_IsTrueAndDecref'}}(PyObject_RichCompare(op1, op2, Py_{{op.upper()}}))
+    {{else}}(inplace ? PyNumber_InPlace{{op}}(op1, op2) : PyNumber_{{op}}(op1, op2))
+    {{endif}}
+#endif
+
+/////////////// PyIntBinop ///////////////
+
+#if !CYTHON_COMPILING_IN_PYPY
+{{py: from Cython.Utility import pylong_join }}
+{{py: pyval, ival = ('op2', 'b') if order == 'CObj' else ('op1', 'a') }}
+{{py: c_ret_type = 'PyObject*' if ret_type.is_pyobject else 'int'}}
+{{py: return_true = 'Py_RETURN_TRUE' if ret_type.is_pyobject else 'return 1'}}
+{{py: return_false = 'Py_RETURN_FALSE' if ret_type.is_pyobject else 'return 0'}}
+{{py: slot_name = {'TrueDivide': 'true_divide', 'FloorDivide': 'floor_divide'}.get(op, op.lower()) }}
+{{py: cfunc_name = '__Pyx_PyInt_%s%s%s' % ('' if ret_type.is_pyobject else 'Bool', op, order)}}
+{{py:
+c_op = {
+    'Add': '+', 'Subtract': '-', 'Multiply': '*', 'Remainder': '%', 'TrueDivide': '/', 'FloorDivide': '/',
+    'Or': '|', 'Xor': '^', 'And': '&', 'Rshift': '>>', 'Lshift': '<<',
+    'Eq': '==', 'Ne': '!=',
+    }[op]
+}}
+{{py:
+def zerodiv_check(operand, optype='integer', _is_mod=op == 'Remainder', _needs_check=(order == 'CObj' and c_op in '%/')):
+    return (((
+    'if (unlikely(zerodivision_check && ((%s) == 0))) {'
+    ' PyErr_SetString(PyExc_ZeroDivisionError, "%s division%s by zero");'
+    ' return NULL;'
+    '}') % (operand, optype, ' or modulo' if _is_mod else '')
+    ) if _needs_check else '')
+}}
+
+static {{c_ret_type}} {{cfunc_name}}(PyObject *op1, PyObject *op2, long intval, int inplace, int zerodivision_check) {
+    CYTHON_MAYBE_UNUSED_VAR(intval);
+    CYTHON_MAYBE_UNUSED_VAR(inplace);
+    CYTHON_UNUSED_VAR(zerodivision_check);
+
+    {{if op in ('Eq', 'Ne')}}
+    if (op1 == op2) {
+        {{return_true if op == 'Eq' else return_false}};
+    }
+    {{endif}}
+
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_CheckExact({{pyval}}))) {
+        const long {{'a' if order == 'CObj' else 'b'}} = intval;
+        {{if c_op in '+-%' or op == 'FloorDivide'}}
+        long x;
+        {{endif}}
+        long {{ival}} = PyInt_AS_LONG({{pyval}});
+        {{zerodiv_check('b')}}
+
+        {{if op in ('Eq', 'Ne')}}
+        if (a {{c_op}} b) {
+            {{return_true}};
+        } else {
+            {{return_false}};
+        }
+        {{elif c_op in '+-'}}
+            // adapted from intobject.c in Py2.7:
+            // casts in the line below avoid undefined behaviour on overflow
+            x = (long)((unsigned long)a {{c_op}} (unsigned long)b);
+            if (likely((x^a) >= 0 || (x^{{ '~' if op == 'Subtract' else '' }}b) >= 0))
+                return PyInt_FromLong(x);
+            return PyLong_Type.tp_as_number->nb_{{slot_name}}(op1, op2);
+        {{elif c_op == '%'}}
+            // see CMath.c :: ModInt utility code
+            x = a % b;
+            x += ((x != 0) & ((x ^ b) < 0)) * b;
+            return PyInt_FromLong(x);
+        {{elif op == 'TrueDivide'}}
+            if (8 * sizeof(long) <= 53 || likely(labs({{ival}}) <= ((PY_LONG_LONG)1 << 53))) {
+                return PyFloat_FromDouble((double)a / (double)b);
+            }
+            // let Python do the rounding
+            return PyInt_Type.tp_as_number->nb_{{slot_name}}(op1, op2);
+        {{elif op == 'FloorDivide'}}
+            // INT_MIN / -1  is the only case that overflows
+            if (unlikely(b == -1 && ((unsigned long)a) == 0-(unsigned long)a))
+                return PyInt_Type.tp_as_number->nb_{{slot_name}}(op1, op2);
+            else {
+                long q, r;
+                // see CMath.c :: DivInt utility code
+                q = a / b;
+                r = a - q*b;
+                q -= ((r != 0) & ((r ^ b) < 0));
+                x = q;
+            }
+            return PyInt_FromLong(x);
+        {{elif op == 'Lshift'}}
+            if (likely(b < (long) (sizeof(long)*8) && a == (a << b) >> b) || !a) {
+                return PyInt_FromLong(a {{c_op}} b);
+            }
+        {{elif c_op == '*'}}
+#ifdef HAVE_LONG_LONG
+            if (sizeof(PY_LONG_LONG) > sizeof(long)) {
+                PY_LONG_LONG result = (PY_LONG_LONG)a {{c_op}} (PY_LONG_LONG)b;
+                return (result >= LONG_MIN && result <= LONG_MAX) ?
+                    PyInt_FromLong((long)result) : PyLong_FromLongLong(result);
+            }
+#endif
+#if CYTHON_USE_TYPE_SLOTS
+            return PyInt_Type.tp_as_number->nb_{{slot_name}}(op1, op2);
+#else
+            return PyNumber_{{op}}(op1, op2);
+#endif
+        {{else}}
+            // other operations are safe, no overflow
+            return PyInt_FromLong(a {{c_op}} b);
+        {{endif}}
+    }
+    #endif
+
+    #if CYTHON_USE_PYLONG_INTERNALS
+    if (likely(PyLong_CheckExact({{pyval}}))) {
+        const long {{'a' if order == 'CObj' else 'b'}} = intval;
+        long {{ival}}{{if op not in ('Eq', 'Ne')}}, x{{endif}};
+        {{if op not in ('Eq', 'Ne', 'TrueDivide')}}
+#ifdef HAVE_LONG_LONG
+        const PY_LONG_LONG ll{{'a' if order == 'CObj' else 'b'}} = intval;
+        PY_LONG_LONG ll{{ival}}, llx;
+#endif
+        {{endif}}
+        {{if c_op == '&'}}
+        // special case for &-ing arbitrarily large numbers with known single digit operands
+        if ((intval & PyLong_MASK) == intval) {
+            // Calling PyLong_CompactValue() requires the PyLong value to be compact, we only need the last digit.
+            long last_digit = (long) __Pyx_PyLong_Digits({{pyval}})[0];
+            long result = intval & (likely(__Pyx_PyLong_IsPos({{pyval}})) ? last_digit : (PyLong_MASK - last_digit + 1));
+            return PyLong_FromLong(result);
+        }
+        {{endif}}
+        // special cases for 0: + - * % / // | ^ & >> <<
+        if (unlikely(__Pyx_PyLong_IsZero({{pyval}}))) {
+            {{if order == 'CObj' and c_op in '%/'}}
+            // division by zero!
+            {{zerodiv_check('0')}}
+            {{elif order == 'CObj' and c_op in '+-|^>><<'}}
+            // x == x+0 == x-0 == x|0 == x^0 == x>>0 == x<<0
+            return __Pyx_NewRef(op1);
+            {{elif order == 'CObj' and c_op in '*&'}}
+            // 0 == x*0 == x&0
+            return __Pyx_NewRef(op2);
+            {{elif order == 'ObjC' and c_op in '+|^'}}
+            // x == 0+x == 0|x == 0^x
+            return __Pyx_NewRef(op2);
+            {{elif order == 'ObjC' and c_op == '-'}}
+            // -x == 0-x
+            return PyLong_FromLong(-intval);
+            {{elif order == 'ObjC' and (c_op in '*%&>><<' or op == 'FloorDivide')}}
+            // 0 == 0*x == 0%x == 0&x == 0>>x == 0<<x == 0//x
+            return __Pyx_NewRef(op1);
+            {{endif}}
+        }
+        // handle most common case first to avoid indirect branch and optimise branch prediction
+        if (likely(__Pyx_PyLong_IsCompact({{pyval}}))) {
+            {{ival}} = __Pyx_PyLong_CompactValue({{pyval}});
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits({{pyval}});
+            const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount({{pyval}});
+            switch (size) {
+                {{for _size in range(2, 5)}}
+                {{for _case in (-_size, _size)}}
+                case {{_case}}:
+                    if (8 * sizeof(long) - 1 > {{_size}} * PyLong_SHIFT{{if c_op == '*'}}+30{{endif}}{{if op == 'TrueDivide'}} && {{_size-1}} * PyLong_SHIFT < 53{{endif}}) {
+                        {{ival}} = {{'-' if _case < 0 else ''}}(long) {{pylong_join(_size, 'digits')}};
+                        break;
+                    {{if op not in ('Eq', 'Ne', 'TrueDivide')}}
+                    #ifdef HAVE_LONG_LONG
+                    } else if (8 * sizeof(PY_LONG_LONG) - 1 > {{_size}} * PyLong_SHIFT{{if c_op == '*'}}+30{{endif}}) {
+                        ll{{ival}} = {{'-' if _case < 0 else ''}}(PY_LONG_LONG) {{pylong_join(_size, 'digits', 'unsigned PY_LONG_LONG')}};
+                        goto long_long;
+                    #endif
+                    {{endif}}
+                    }
+                    // if size doesn't fit into a long or PY_LONG_LONG anymore, fall through to default
+                    CYTHON_FALLTHROUGH;
+                {{endfor}}
+                {{endfor}}
+
+                {{if op in ('Eq', 'Ne')}}
+                #if PyLong_SHIFT < 30 && PyLong_SHIFT != 15
+                // unusual setup - your fault
+                default: return {{'' if ret_type.is_pyobject else '__Pyx_PyObject_IsTrueAndDecref'}}(
+                    PyLong_Type.tp_richcompare({{'op1, op2' if order == 'ObjC' else 'op2, op1'}}, Py_{{op.upper()}}));
+                #else
+                // too large for the long values we allow => definitely not equal
+                default: {{return_false if op == 'Eq' else return_true}};
+                #endif
+                {{else}}
+                default: return PyLong_Type.tp_as_number->nb_{{slot_name}}(op1, op2);
+                {{endif}}
+            }
+        }
+        {{if op in ('Eq', 'Ne')}}
+            if (a {{c_op}} b) {
+                {{return_true}};
+            } else {
+                {{return_false}};
+            }
+        {{else}}
+            {{if c_op == '*'}}
+                CYTHON_UNUSED_VAR(a);
+                CYTHON_UNUSED_VAR(b);
+                #ifdef HAVE_LONG_LONG
+                ll{{ival}} = {{ival}};
+                goto long_long;
+                #else
+                return PyLong_Type.tp_as_number->nb_{{slot_name}}(op1, op2);
+                #endif
+            {{elif c_op == '%'}}
+                // see CMath.c :: ModInt utility code
+                x = a % b;
+                x += ((x != 0) & ((x ^ b) < 0)) * b;
+            {{elif op == 'TrueDivide'}}
+                if ((8 * sizeof(long) <= 53 || likely(labs({{ival}}) <= ((PY_LONG_LONG)1 << 53)))
+                        || __Pyx_PyLong_DigitCount({{pyval}}) <= 52 / PyLong_SHIFT) {
+                    return PyFloat_FromDouble((double)a / (double)b);
+                }
+                return PyLong_Type.tp_as_number->nb_{{slot_name}}(op1, op2);
+            {{elif op == 'FloorDivide'}}
+                {
+                    long q, r;
+                    // see CMath.c :: DivInt utility code
+                    q = a / b;
+                    r = a - q*b;
+                    q -= ((r != 0) & ((r ^ b) < 0));
+                    x = q;
+                }
+            {{else}}
+                x = a {{c_op}} b;
+                {{if op == 'Lshift'}}
+#ifdef HAVE_LONG_LONG
+                if (unlikely(!(b < (long) (sizeof(long)*8) && a == x >> b)) && a) {
+                    ll{{ival}} = {{ival}};
+                    goto long_long;
+                }
+#else
+                if (likely(b < (long) (sizeof(long)*8) && a == x >> b) || !a) /* execute return statement below */
+#endif
+                {{endif}}
+            {{endif}}
+            return PyLong_FromLong(x);
+
+        {{if op != 'TrueDivide'}}
+#ifdef HAVE_LONG_LONG
+        long_long:
+            {{if c_op == '%'}}
+                // see CMath.c :: ModInt utility code
+                llx = lla % llb;
+                llx += ((llx != 0) & ((llx ^ llb) < 0)) * llb;
+            {{elif op == 'FloorDivide'}}
+                {
+                    PY_LONG_LONG q, r;
+                    // see CMath.c :: DivInt utility code
+                    q = lla / llb;
+                    r = lla - q*llb;
+                    q -= ((r != 0) & ((r ^ llb) < 0));
+                    llx = q;
+                }
+            {{else}}
+                llx = lla {{c_op}} llb;
+                {{if op == 'Lshift'}}
+                if (likely(lla == llx >> llb)) /* then execute 'return' below */
+                {{endif}}
+            {{endif}}
+            return PyLong_FromLongLong(llx);
+#endif
+        {{endif}}{{# if op != 'TrueDivide' #}}
+        {{endif}}{{# if op in ('Eq', 'Ne') #}}
+    }
+    #endif
+
+    {{if c_op in '+-*' or op in ('TrueDivide', 'Eq', 'Ne')}}
+    if (PyFloat_CheckExact({{pyval}})) {
+        const long {{'a' if order == 'CObj' else 'b'}} = intval;
+#if CYTHON_COMPILING_IN_LIMITED_API
+        double {{ival}} = __pyx_PyFloat_AsDouble({{pyval}});
+#else
+        double {{ival}} = PyFloat_AS_DOUBLE({{pyval}});
+#endif
+        {{if op in ('Eq', 'Ne')}}
+            if ((double)a {{c_op}} (double)b) {
+                {{return_true}};
+            } else {
+                {{return_false}};
+            }
+        {{else}}
+            double result;
+            {{zerodiv_check('b', 'float')}}
+            // copied from floatobject.c in Py3.5:
+            PyFPE_START_PROTECT("{{op.lower() if not op.endswith('Divide') else 'divide'}}", return NULL)
+            result = ((double)a) {{c_op}} (double)b;
+            PyFPE_END_PROTECT(result)
+            return PyFloat_FromDouble(result);
+        {{endif}}
+    }
+    {{endif}}
+
+    {{if op in ('Eq', 'Ne')}}
+    return {{'' if ret_type.is_pyobject else '__Pyx_PyObject_IsTrueAndDecref'}}(
+        PyObject_RichCompare(op1, op2, Py_{{op.upper()}}));
+    {{else}}
+    return (inplace ? PyNumber_InPlace{{op}} : PyNumber_{{op}})(op1, op2);
+    {{endif}}
+}
+#endif
+
+/////////////// PyFloatBinop.proto ///////////////
+
+{{py: c_ret_type = 'PyObject*' if ret_type.is_pyobject else 'int'}}
+#if !CYTHON_COMPILING_IN_PYPY
+static {{c_ret_type}} __Pyx_PyFloat_{{'' if ret_type.is_pyobject else 'Bool'}}{{op}}{{order}}(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check); /*proto*/
+#else
+#define __Pyx_PyFloat_{{'' if ret_type.is_pyobject else 'Bool'}}{{op}}{{order}}(op1, op2, floatval, inplace, zerodivision_check) \
+    {{if op in ('Eq', 'Ne')}}{{'' if ret_type.is_pyobject else '__Pyx_PyObject_IsTrueAndDecref'}}(PyObject_RichCompare(op1, op2, Py_{{op.upper()}}))
+    {{elif op == 'Divide'}}((inplace ? __Pyx_PyNumber_InPlaceDivide(op1, op2) : __Pyx_PyNumber_Divide(op1, op2)))
+    {{else}}(inplace ? PyNumber_InPlace{{op}}(op1, op2) : PyNumber_{{op}}(op1, op2))
+    {{endif}}
+#endif
+
+/////////////// PyFloatBinop ///////////////
+
+#if !CYTHON_COMPILING_IN_PYPY
+{{py: from Cython.Utility import pylong_join }}
+{{py: c_ret_type = 'PyObject*' if ret_type.is_pyobject else 'int'}}
+{{py: return_true = 'Py_RETURN_TRUE' if ret_type.is_pyobject else 'return 1'}}
+{{py: return_false = 'Py_RETURN_FALSE' if ret_type.is_pyobject else 'return 0'}}
+{{py: pyval, fval = ('op2', 'b') if order == 'CObj' else ('op1', 'a') }}
+{{py: cfunc_name = '__Pyx_PyFloat_%s%s%s' % ('' if ret_type.is_pyobject else 'Bool', op, order) }}
+{{py:
+c_op = {
+    'Add': '+', 'Subtract': '-', 'TrueDivide': '/', 'Divide': '/', 'Remainder': '%',
+    'Eq': '==', 'Ne': '!=',
+    }[op]
+}}
+{{py:
+def zerodiv_check(operand, _is_mod=op == 'Remainder', _needs_check=(order == 'CObj' and c_op in '%/')):
+    return (((
+        'if (unlikely(zerodivision_check && ((%s) == 0.0))) {'
+        ' PyErr_SetString(PyExc_ZeroDivisionError, "float division%s by zero");'
+        ' return NULL;'
+        '}') % (operand, ' or modulo' if _is_mod else '')
+    ) if _needs_check else '')
+}}
+
+static {{c_ret_type}} {{cfunc_name}}(PyObject *op1, PyObject *op2, double floatval, int inplace, int zerodivision_check) {
+    const double {{'a' if order == 'CObj' else 'b'}} = floatval;
+    double {{fval}}{{if op not in ('Eq', 'Ne')}}, result{{endif}};
+    CYTHON_UNUSED_VAR(inplace);
+    CYTHON_UNUSED_VAR(zerodivision_check);
+
+    {{if op in ('Eq', 'Ne')}}
+    if (op1 == op2) {
+        {{return_true if op == 'Eq' else return_false}};
+    }
+    {{endif}}
+
+    if (likely(PyFloat_CheckExact({{pyval}}))) {
+#if CYTHON_COMPILING_IN_LIMITED_API
+        {{fval}} = __pyx_PyFloat_AsDouble({{pyval}});
+#else
+        {{fval}} = PyFloat_AS_DOUBLE({{pyval}});
+#endif
+        {{zerodiv_check(fval)}}
+    } else
+
+    #if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_CheckExact({{pyval}}))) {
+        {{fval}} = (double) PyInt_AS_LONG({{pyval}});
+        {{zerodiv_check(fval)}}
+    } else
+    #endif
+
+    if (likely(PyLong_CheckExact({{pyval}}))) {
+        #if CYTHON_USE_PYLONG_INTERNALS
+        if (__Pyx_PyLong_IsZero({{pyval}})) {
+            {{fval}} = 0.0;
+            {{zerodiv_check(fval)}}
+        } else if (__Pyx_PyLong_IsCompact({{pyval}})) {
+            {{fval}} = (double) __Pyx_PyLong_CompactValue({{pyval}});
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits({{pyval}});
+            const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount({{pyval}});
+            switch (size) {
+                {{for _size in (2, 3, 4)}}
+                case -{{_size}}:
+                case {{_size}}:
+                    if (8 * sizeof(unsigned long) > {{_size}} * PyLong_SHIFT && ((8 * sizeof(unsigned long) < 53) || ({{_size-1}} * PyLong_SHIFT < 53))) {
+                        {{fval}} = (double) {{pylong_join(_size, 'digits')}};
+                        // let CPython do its own float rounding from 2**53 on (max. consecutive integer in double float)
+                        if ((8 * sizeof(unsigned long) < 53) || ({{_size}} * PyLong_SHIFT < 53) || ({{fval}} < (double) ((PY_LONG_LONG)1 << 53))) {
+                            if (size == {{-_size}})
+                                {{fval}} = -{{fval}};
+                            break;
+                        }
+                    }
+                    // Fall through if size doesn't fit safely into a double anymore.
+                    // It may not be obvious that this is a safe fall-through given the "fval < 2**53"
+                    // check above.  However, the number of digits that CPython uses for a given PyLong
+                    // value is minimal, and together with the "(size-1) * SHIFT < 53" check above,
+                    // this should make it safe.
+                    CYTHON_FALLTHROUGH;
+                {{endfor}}
+                default:
+        #endif
+        {{if op in ('Eq', 'Ne')}}
+                    return {{'' if ret_type.is_pyobject else '__Pyx_PyObject_IsTrueAndDecref'}}(
+                        PyFloat_Type.tp_richcompare({{'op1, op2' if order == 'CObj' else 'op2, op1'}}, Py_{{op.upper()}}));
+        {{else}}
+                    {{fval}} = PyLong_AsDouble({{pyval}});
+                    if (unlikely({{fval}} == -1.0 && PyErr_Occurred())) return NULL;
+                    {{if zerodiv_check(fval)}}
+                    #if !CYTHON_USE_PYLONG_INTERNALS
+                    {{zerodiv_check(fval)}}
+                    #endif
+                    {{endif}}
+        {{endif}}
+        #if CYTHON_USE_PYLONG_INTERNALS
+            }
+        }
+        #endif
+    } else {
+        {{if op in ('Eq', 'Ne')}}
+        return {{'' if ret_type.is_pyobject else '__Pyx_PyObject_IsTrueAndDecref'}}(
+            PyObject_RichCompare(op1, op2, Py_{{op.upper()}}));
+        {{elif op == 'Divide'}}
+        return (inplace ? __Pyx_PyNumber_InPlaceDivide(op1, op2) : __Pyx_PyNumber_Divide(op1, op2));
+        {{else}}
+        return (inplace ? PyNumber_InPlace{{op}} : PyNumber_{{op}})(op1, op2);
+        {{endif}}
+    }
+
+    {{if op in ('Eq', 'Ne')}}
+        if (a {{c_op}} b) {
+            {{return_true}};
+        } else {
+            {{return_false}};
+        }
+    {{else}}
+        // copied from floatobject.c in Py3.5:
+        PyFPE_START_PROTECT("{{op.lower() if not op.endswith('Divide') else 'divide'}}", return NULL)
+        {{if c_op == '%'}}
+        result = fmod(a, b);
+        if (result)
+            result += ((result < 0) ^ (b < 0)) * b;
+        else
+            result = copysign(0.0, b);
+        {{else}}
+        result = a {{c_op}} b;
+        {{endif}}
+        PyFPE_END_PROTECT(result)
+        return PyFloat_FromDouble(result);
+    {{endif}}
+}
+#endif

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Utility/Overflow.c

@@ -0,0 +1,404 @@
+/*
+These functions provide integer arithmetic with integer checking.  They do not
+actually raise an exception when an overflow is detected, but rather set a bit
+in the overflow parameter.  (This parameter may be re-used across several
+arithmetic operations, so should be or-ed rather than assigned to.)
+
+The implementation is divided into two parts, the signed and unsigned basecases,
+which is where the magic happens, and a generic template matching a specific
+type to an implementation based on its (c-compile-time) size and signedness.
+
+When possible, branching is avoided, and preference is given to speed over
+accuracy (a low rate of falsely "detected" overflows are acceptable,
+undetected overflows are not).
+
+
+TODO: Hook up checking.
+TODO: Conditionally support 128-bit with intmax_t?
+*/
+
+/////////////// Common.proto ///////////////
+
+static int __Pyx_check_twos_complement(void) {
+    if ((-1) != (~0)) {
+        PyErr_SetString(PyExc_RuntimeError, "Two's complement required for overflow checks.");
+        return 1;
+    } else if ((sizeof(short) == sizeof(int))) {
+        PyErr_SetString(PyExc_RuntimeError, "sizeof(short) < sizeof(int) required for overflow checks.");
+        return 1;
+    } else {
+        return 0;
+    }
+}
+
+#define __PYX_SIGN_BIT(type)    ((((unsigned type) 1) << (sizeof(type) * 8 - 1)))
+#define __PYX_HALF_MAX(type)    ((((type) 1) << (sizeof(type) * 8 - 2)))
+#define __PYX_MIN(type)         ((__PYX_IS_UNSIGNED(type) ? (type) 0 : 0 - __PYX_HALF_MAX(type) - __PYX_HALF_MAX(type)))
+#define __PYX_MAX(type)         ((~__PYX_MIN(type)))
+
+#define __Pyx_add_no_overflow(a, b, overflow) ((a) + (b))
+#define __Pyx_add_const_no_overflow(a, b, overflow) ((a) + (b))
+#define __Pyx_sub_no_overflow(a, b, overflow) ((a) - (b))
+#define __Pyx_sub_const_no_overflow(a, b, overflow) ((a) - (b))
+#define __Pyx_mul_no_overflow(a, b, overflow) ((a) * (b))
+#define __Pyx_mul_const_no_overflow(a, b, overflow) ((a) * (b))
+#define __Pyx_div_no_overflow(a, b, overflow) ((a) / (b))
+#define __Pyx_div_const_no_overflow(a, b, overflow) ((a) / (b))
+
+#if defined(__has_builtin)
+#  if __has_builtin(__builtin_add_overflow) && !defined(__ibmxl__)
+#    define __PYX_HAVE_BUILTIN_OVERFLOW
+#  endif
+#elif defined(__GNUC__) && (__GNUC__ >= 5) && (!defined(__INTEL_COMPILER) || (__INTEL_COMPILER >= 1800))
+#  define __PYX_HAVE_BUILTIN_OVERFLOW
+#endif
+
+#if defined(__GNUC__)
+#  define __Pyx_is_constant(x) (__builtin_constant_p(x))
+#elif defined(__has_builtin)
+#  if __has_builtin(__builtin_constant_p)
+#    define __Pyx_is_constant(x) (__builtin_constant_p(x))
+#  endif
+#else
+#  define __Pyx_is_constant(x) (0)
+#endif
+
+/////////////// Common.init ///////////////
+
+if (likely(__Pyx_check_twos_complement() == 0)); else
+// error propagation code is appended automatically
+
+/////////////// BaseCaseUnsigned.proto ///////////////
+
+{{if UINT == "long long"}}#ifdef HAVE_LONG_LONG{{endif}}
+
+static CYTHON_INLINE {{UINT}} __Pyx_add_{{NAME}}_checking_overflow({{UINT}} a, {{UINT}} b, int *overflow);
+static CYTHON_INLINE {{UINT}} __Pyx_sub_{{NAME}}_checking_overflow({{UINT}} a, {{UINT}} b, int *overflow);
+static CYTHON_INLINE {{UINT}} __Pyx_mul_{{NAME}}_checking_overflow({{UINT}} a, {{UINT}} b, int *overflow);
+static CYTHON_INLINE {{UINT}} __Pyx_div_{{NAME}}_checking_overflow({{UINT}} a, {{UINT}} b, int *overflow);
+
+// Use these when b is known at compile time.
+#define __Pyx_add_const_{{NAME}}_checking_overflow __Pyx_add_{{NAME}}_checking_overflow
+#define __Pyx_sub_const_{{NAME}}_checking_overflow __Pyx_sub_{{NAME}}_checking_overflow
+#if defined(__PYX_HAVE_BUILTIN_OVERFLOW)
+#define __Pyx_mul_const_{{NAME}}_checking_overflow __Pyx_mul_{{NAME}}_checking_overflow
+#else
+static CYTHON_INLINE {{UINT}} __Pyx_mul_const_{{NAME}}_checking_overflow({{UINT}} a, {{UINT}} constant, int *overflow);
+#endif
+#define __Pyx_div_const_{{NAME}}_checking_overflow __Pyx_div_{{NAME}}_checking_overflow
+
+{{if UINT == "long long"}}#endif{{endif}}
+
+/////////////// BaseCaseUnsigned ///////////////
+
+{{if UINT == "long long"}}#ifdef HAVE_LONG_LONG{{endif}}
+
+#if defined(__PYX_HAVE_BUILTIN_OVERFLOW)
+
+static CYTHON_INLINE {{UINT}} __Pyx_add_{{NAME}}_checking_overflow({{UINT}} a, {{UINT}} b, int *overflow) {
+    {{UINT}} result;
+    *overflow |= __builtin_add_overflow(a, b, &result);
+    return result;
+}
+
+static CYTHON_INLINE {{UINT}} __Pyx_sub_{{NAME}}_checking_overflow({{UINT}} a, {{UINT}} b, int *overflow) {
+    {{UINT}} result;
+    *overflow |= __builtin_sub_overflow(a, b, &result);
+    return result;
+}
+
+static CYTHON_INLINE {{UINT}} __Pyx_mul_{{NAME}}_checking_overflow({{UINT}} a, {{UINT}} b, int *overflow) {
+    {{UINT}} result;
+    *overflow |= __builtin_mul_overflow(a, b, &result);
+    return result;
+}
+
+#else
+
+static CYTHON_INLINE {{UINT}} __Pyx_add_{{NAME}}_checking_overflow({{UINT}} a, {{UINT}} b, int *overflow) {
+    {{UINT}} r = a + b;
+    *overflow |= r < a;
+    return r;
+}
+
+static CYTHON_INLINE {{UINT}} __Pyx_sub_{{NAME}}_checking_overflow({{UINT}} a, {{UINT}} b, int *overflow) {
+    {{UINT}} r = a - b;
+    *overflow |= r > a;
+    return r;
+}
+
+static CYTHON_INLINE {{UINT}} __Pyx_mul_{{NAME}}_checking_overflow({{UINT}} a, {{UINT}} b, int *overflow) {
+    // if we have a constant, use the constant version
+    if (__Pyx_is_constant(b)) {
+        return __Pyx_mul_const_{{NAME}}_checking_overflow(a, b, overflow);
+    } else if (__Pyx_is_constant(a)) {
+        return __Pyx_mul_const_{{NAME}}_checking_overflow(b, a, overflow);
+    } else if ((sizeof({{UINT}}) < sizeof(unsigned long))) {
+        unsigned long big_r = ((unsigned long) a) * ((unsigned long) b);
+        {{UINT}} r = ({{UINT}}) big_r;
+        *overflow |= big_r != r;
+        return r;
+#ifdef HAVE_LONG_LONG
+    } else if ((sizeof({{UINT}}) < sizeof(unsigned PY_LONG_LONG))) {
+        unsigned PY_LONG_LONG big_r = ((unsigned PY_LONG_LONG) a) * ((unsigned PY_LONG_LONG) b);
+        {{UINT}} r = ({{UINT}}) big_r;
+        *overflow |= big_r != r;
+        return r;
+#endif
+    } else {
+        return __Pyx_mul_const_{{NAME}}_checking_overflow(a, b, overflow);
+    }
+}
+
+static CYTHON_INLINE {{UINT}} __Pyx_mul_const_{{NAME}}_checking_overflow({{UINT}} a, {{UINT}} b, int *overflow) {
+    // note that deliberately the overflow check is written such that it divides by b; this
+    // function is used when b is a constant thus the compiler should be able to eliminate the
+    // (very slow on most CPUs!) division operation
+    {{UINT}} prod;
+    if (__Pyx_is_constant(a) && !__Pyx_is_constant(b)) {
+        // if a is a compile-time constant and b isn't, swap them
+        {{UINT}} temp = b;
+        b = a;
+        a = temp;
+    }
+    prod = a * b;
+    if (b != 0)
+        *overflow |= a > (__PYX_MAX({{UINT}}) / b);
+    return prod;
+}
+#endif // __PYX_HAVE_BUILTIN_OVERFLOW
+
+
+static CYTHON_INLINE {{UINT}} __Pyx_div_{{NAME}}_checking_overflow({{UINT}} a, {{UINT}} b, int *overflow) {
+    if (b == 0) {
+        *overflow |= 1;
+        return 0;
+    }
+    return a / b;
+}
+
+{{if UINT == "long long"}}#endif{{endif}}
+
+
+/////////////// BaseCaseSigned.proto ///////////////
+
+{{if INT == "long long"}}#ifdef HAVE_LONG_LONG{{endif}}
+
+static CYTHON_INLINE {{INT}} __Pyx_add_{{NAME}}_checking_overflow({{INT}} a, {{INT}} b, int *overflow);
+static CYTHON_INLINE {{INT}} __Pyx_sub_{{NAME}}_checking_overflow({{INT}} a, {{INT}} b, int *overflow);
+static CYTHON_INLINE {{INT}} __Pyx_mul_{{NAME}}_checking_overflow({{INT}} a, {{INT}} b, int *overflow);
+static CYTHON_INLINE {{INT}} __Pyx_div_{{NAME}}_checking_overflow({{INT}} a, {{INT}} b, int *overflow);
+
+
+// Use when b is known at compile time.
+#define __Pyx_add_const_{{NAME}}_checking_overflow __Pyx_add_{{NAME}}_checking_overflow
+#define __Pyx_sub_const_{{NAME}}_checking_overflow __Pyx_sub_{{NAME}}_checking_overflow
+#if defined(__PYX_HAVE_BUILTIN_OVERFLOW)
+#define __Pyx_mul_const_{{NAME}}_checking_overflow __Pyx_mul_{{NAME}}_checking_overflow
+#else
+static CYTHON_INLINE {{INT}} __Pyx_mul_const_{{NAME}}_checking_overflow({{INT}} a, {{INT}} constant, int *overflow);
+#endif
+#define __Pyx_div_const_{{NAME}}_checking_overflow __Pyx_div_{{NAME}}_checking_overflow
+
+{{if INT == "long long"}}#endif{{endif}}
+
+/////////////// BaseCaseSigned ///////////////
+
+{{if INT == "long long"}}#ifdef HAVE_LONG_LONG{{endif}}
+
+#if defined(__PYX_HAVE_BUILTIN_OVERFLOW)
+
+static CYTHON_INLINE {{INT}} __Pyx_add_{{NAME}}_checking_overflow({{INT}} a, {{INT}} b, int *overflow) {
+    {{INT}} result;
+    *overflow |= __builtin_add_overflow(a, b, &result);
+    return result;
+}
+
+static CYTHON_INLINE {{INT}} __Pyx_sub_{{NAME}}_checking_overflow({{INT}} a, {{INT}} b, int *overflow) {
+    {{INT}} result;
+    *overflow |= __builtin_sub_overflow(a, b, &result);
+    return result;
+}
+
+static CYTHON_INLINE {{INT}} __Pyx_mul_{{NAME}}_checking_overflow({{INT}} a, {{INT}} b, int *overflow) {
+    {{INT}} result;
+    *overflow |= __builtin_mul_overflow(a, b, &result);
+    return result;
+}
+
+#else
+
+static CYTHON_INLINE {{INT}} __Pyx_add_{{NAME}}_checking_overflow({{INT}} a, {{INT}} b, int *overflow) {
+    if ((sizeof({{INT}}) < sizeof(long))) {
+        long big_r = ((long) a) + ((long) b);
+        {{INT}} r = ({{INT}}) big_r;
+        *overflow |= big_r != r;
+        return r;
+#ifdef HAVE_LONG_LONG
+    } else if ((sizeof({{INT}}) < sizeof(PY_LONG_LONG))) {
+        PY_LONG_LONG big_r = ((PY_LONG_LONG) a) + ((PY_LONG_LONG) b);
+        {{INT}} r = ({{INT}}) big_r;
+        *overflow |= big_r != r;
+        return r;
+#endif
+    } else {
+        // Signed overflow undefined, but unsigned overflow is well defined. Casting is
+        // implementation-defined, but we assume two's complement (see __Pyx_check_twos_complement
+        // above), and arithmetic in two's-complement is the same as unsigned arithmetic.
+        unsigned {{INT}} r = (unsigned {{INT}}) a + (unsigned {{INT}}) b;
+        // Overflow happened if the operands have the same sign, but the result
+        // has opposite sign.
+        *overflow |= (((unsigned {{INT}})a ^ r) & ((unsigned {{INT}})b ^ r)) >> (8 * sizeof({{INT}}) - 1);
+        return ({{INT}}) r;
+    }
+}
+
+static CYTHON_INLINE {{INT}} __Pyx_sub_{{NAME}}_checking_overflow({{INT}} a, {{INT}} b, int *overflow) {
+    // Compilers don't handle widening as well in the subtraction case, so don't bother
+    unsigned {{INT}} r = (unsigned {{INT}}) a - (unsigned {{INT}}) b;
+    // Overflow happened if the operands differing signs, and the result
+    // has opposite sign to a.
+    *overflow |= (((unsigned {{INT}})a ^ (unsigned {{INT}})b) & ((unsigned {{INT}})a ^ r)) >> (8 * sizeof({{INT}}) - 1);
+    return ({{INT}}) r;
+}
+
+static CYTHON_INLINE {{INT}} __Pyx_mul_{{NAME}}_checking_overflow({{INT}} a, {{INT}} b, int *overflow) {
+    // if we have a constant, use the constant version
+    if (__Pyx_is_constant(b)) {
+        return __Pyx_mul_const_{{NAME}}_checking_overflow(a, b, overflow);
+    } else if (__Pyx_is_constant(a)) {
+        return __Pyx_mul_const_{{NAME}}_checking_overflow(b, a, overflow);
+    } else if ((sizeof({{INT}}) < sizeof(long))) {
+        long big_r = ((long) a) * ((long) b);
+        {{INT}} r = ({{INT}}) big_r;
+        *overflow |= big_r != r;
+        return ({{INT}}) r;
+#ifdef HAVE_LONG_LONG
+    } else if ((sizeof({{INT}}) < sizeof(PY_LONG_LONG))) {
+        PY_LONG_LONG big_r = ((PY_LONG_LONG) a) * ((PY_LONG_LONG) b);
+        {{INT}} r = ({{INT}}) big_r;
+        *overflow |= big_r != r;
+        return ({{INT}}) r;
+#endif
+    } else {
+        return __Pyx_mul_const_{{NAME}}_checking_overflow(a, b, overflow);
+    }
+}
+
+static CYTHON_INLINE {{INT}} __Pyx_mul_const_{{NAME}}_checking_overflow({{INT}} a, {{INT}} b, int *overflow) {
+    // note that deliberately all these comparisons are written such that they divide by b; this
+    // function is used when b is a constant thus the compiler should be able to eliminate the
+    // (very slow on most CPUs!) division operations
+    if (__Pyx_is_constant(a) && !__Pyx_is_constant(b)) {
+        // if a is a compile-time constant and b isn't, swap them
+        {{INT}} temp = b;
+        b = a;
+        a = temp;
+    }
+    if (b > 1) {
+        *overflow |= a > __PYX_MAX({{INT}}) / b;
+        *overflow |= a < __PYX_MIN({{INT}}) / b;
+    } else if (b == -1) {
+        *overflow |= a == __PYX_MIN({{INT}});
+    } else if (b < -1) {
+        *overflow |= a > __PYX_MIN({{INT}}) / b;
+        *overflow |= a < __PYX_MAX({{INT}}) / b;
+    }
+    return ({{INT}}) (((unsigned {{INT}})a) * ((unsigned {{INT}}) b));
+}
+#endif  // defined(__PYX_HAVE_BUILTIN_OVERFLOW)
+
+static CYTHON_INLINE {{INT}} __Pyx_div_{{NAME}}_checking_overflow({{INT}} a, {{INT}} b, int *overflow) {
+    if (b == 0) {
+        *overflow |= 1;
+        return 0;
+    }
+    *overflow |= a == __PYX_MIN({{INT}}) && b == -1;
+    return ({{INT}}) ((unsigned {{INT}}) a / (unsigned {{INT}}) b);
+}
+
+{{if INT == "long long"}}#endif{{endif}}
+
+
+/////////////// SizeCheck.init ///////////////
+
+if (likely(__Pyx_check_sane_{{NAME}}() == 0)); else
+// error propagation code is appended automatically
+
+/////////////// SizeCheck.proto ///////////////
+
+static int __Pyx_check_sane_{{NAME}}(void) {
+    if (((sizeof({{TYPE}}) <= sizeof(int)) ||
+#ifdef HAVE_LONG_LONG
+            (sizeof({{TYPE}}) == sizeof(PY_LONG_LONG)) ||
+#endif
+            (sizeof({{TYPE}}) == sizeof(long)))) {
+        return 0;
+    } else {
+        PyErr_Format(PyExc_RuntimeError, \
+            "Bad size for int type %.{{max(60, len(TYPE))}}s: %d", "{{TYPE}}", (int) sizeof({{TYPE}}));
+        return 1;
+    }
+}
+
+
+/////////////// Binop.proto ///////////////
+
+static CYTHON_INLINE {{TYPE}} __Pyx_{{BINOP}}_{{NAME}}_checking_overflow({{TYPE}} a, {{TYPE}} b, int *overflow);
+
+/////////////// Binop ///////////////
+
+static CYTHON_INLINE {{TYPE}} __Pyx_{{BINOP}}_{{NAME}}_checking_overflow({{TYPE}} a, {{TYPE}} b, int *overflow) {
+    if ((sizeof({{TYPE}}) < sizeof(int))) {
+        return __Pyx_{{BINOP}}_no_overflow(a, b, overflow);
+    } else if (__PYX_IS_UNSIGNED({{TYPE}})) {
+        if ((sizeof({{TYPE}}) == sizeof(unsigned int))) {
+            return ({{TYPE}}) __Pyx_{{BINOP}}_unsigned_int_checking_overflow(a, b, overflow);
+        } else if ((sizeof({{TYPE}}) == sizeof(unsigned long))) {
+            return ({{TYPE}}) __Pyx_{{BINOP}}_unsigned_long_checking_overflow(a, b, overflow);
+#ifdef HAVE_LONG_LONG
+        } else if ((sizeof({{TYPE}}) == sizeof(unsigned PY_LONG_LONG))) {
+            return ({{TYPE}}) __Pyx_{{BINOP}}_unsigned_long_long_checking_overflow(a, b, overflow);
+#endif
+        } else {
+            abort(); return 0; /* handled elsewhere */
+        }
+    } else {
+        if ((sizeof({{TYPE}}) == sizeof(int))) {
+            return ({{TYPE}}) __Pyx_{{BINOP}}_int_checking_overflow(a, b, overflow);
+        } else if ((sizeof({{TYPE}}) == sizeof(long))) {
+            return ({{TYPE}}) __Pyx_{{BINOP}}_long_checking_overflow(a, b, overflow);
+#ifdef HAVE_LONG_LONG
+        } else if ((sizeof({{TYPE}}) == sizeof(PY_LONG_LONG))) {
+            return ({{TYPE}}) __Pyx_{{BINOP}}_long_long_checking_overflow(a, b, overflow);
+#endif
+        } else {
+            abort(); return 0; /* handled elsewhere */
+        }
+    }
+}
+
+/////////////// LeftShift.proto ///////////////
+
+static CYTHON_INLINE {{TYPE}} __Pyx_lshift_{{NAME}}_checking_overflow({{TYPE}} a, {{TYPE}} b, int *overflow) {
+    int overflow_check =
+#if {{SIGNED}}
+        (a < 0) || (b < 0) ||
+#endif
+        // the following must be a _logical_ OR as the RHS is undefined if the LHS is true
+        (b >= ({{TYPE}}) (8 * sizeof({{TYPE}}))) || (a > (__PYX_MAX({{TYPE}}) >> b));
+    if (overflow_check) {
+        *overflow |= 1;
+        return 0;
+    } else {
+        return a << b;
+    }
+}
+#define __Pyx_lshift_const_{{NAME}}_checking_overflow __Pyx_lshift_{{NAME}}_checking_overflow
+
+
+/////////////// UnaryNegOverflows.proto ///////////////
+
+// from intobject.c
+#define __Pyx_UNARY_NEG_WOULD_OVERFLOW(x)    \
+        (((x) < 0) & ((unsigned long)(x) == 0-(unsigned long)(x)))

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Utility/TypeConversion.c

@@ -0,0 +1,1310 @@
+/////////////// TypeConversions.proto ///////////////
+//@requires: StringTools.c::IncludeStringH
+
+/* Type Conversion Predeclarations */
+
+#define __Pyx_uchar_cast(c) ((unsigned char)c)
+#define __Pyx_long_cast(x) ((long)x)
+
+#define __Pyx_fits_Py_ssize_t(v, type, is_signed)  (    \
+    (sizeof(type) < sizeof(Py_ssize_t))  ||             \
+    (sizeof(type) > sizeof(Py_ssize_t) &&               \
+          likely(v < (type)PY_SSIZE_T_MAX ||            \
+                 v == (type)PY_SSIZE_T_MAX)  &&         \
+          (!is_signed || likely(v > (type)PY_SSIZE_T_MIN ||       \
+                                v == (type)PY_SSIZE_T_MIN)))  ||  \
+    (sizeof(type) == sizeof(Py_ssize_t) &&              \
+          (is_signed || likely(v < (type)PY_SSIZE_T_MAX ||        \
+                               v == (type)PY_SSIZE_T_MAX)))  )
+
+static CYTHON_INLINE int __Pyx_is_valid_index(Py_ssize_t i, Py_ssize_t limit) {
+    // Optimisation from Section 14.2 "Bounds Checking" in
+    //   https://www.agner.org/optimize/optimizing_cpp.pdf
+    // See https://bugs.python.org/issue28397
+    // The cast to unsigned effectively tests for "0 <= i < limit".
+    return (size_t) i < (size_t) limit;
+}
+
+// fast and unsafe abs(Py_ssize_t) that ignores the overflow for (-PY_SSIZE_T_MAX-1)
+#if defined (__cplusplus) && __cplusplus >= 201103L
+    #include <cstdlib>
+    #define __Pyx_sst_abs(value) std::abs(value)
+#elif SIZEOF_INT >= SIZEOF_SIZE_T
+    #define __Pyx_sst_abs(value) abs(value)
+#elif SIZEOF_LONG >= SIZEOF_SIZE_T
+    #define __Pyx_sst_abs(value) labs(value)
+#elif defined (_MSC_VER)
+    // abs() is defined for long, but 64-bits type on MSVC is long long.
+    // Use MS-specific _abs64 instead.
+    #define __Pyx_sst_abs(value) ((Py_ssize_t)_abs64(value))
+#elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
+    #define __Pyx_sst_abs(value) llabs(value)
+#elif defined (__GNUC__)
+    // gcc or clang on 64 bit windows.
+    #define __Pyx_sst_abs(value) __builtin_llabs(value)
+#else
+    #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
+#endif
+
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s);
+static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
+static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
+
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char*);
+#define __Pyx_PyByteArray_FromStringAndSize(s, l) PyByteArray_FromStringAndSize((const char*)s, l)
+#define __Pyx_PyBytes_FromString        PyBytes_FromString
+#define __Pyx_PyBytes_FromStringAndSize PyBytes_FromStringAndSize
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char*);
+
+#if PY_MAJOR_VERSION < 3
+    #define __Pyx_PyStr_FromString        __Pyx_PyBytes_FromString
+    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
+#else
+    #define __Pyx_PyStr_FromString        __Pyx_PyUnicode_FromString
+    #define __Pyx_PyStr_FromStringAndSize __Pyx_PyUnicode_FromStringAndSize
+#endif
+
+#define __Pyx_PyBytes_AsWritableString(s)     ((char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyBytes_AsWritableSString(s)    ((signed char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyBytes_AsWritableUString(s)    ((unsigned char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyBytes_AsString(s)     ((const char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyBytes_AsSString(s)    ((const signed char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyBytes_AsUString(s)    ((const unsigned char*) PyBytes_AS_STRING(s))
+#define __Pyx_PyObject_AsWritableString(s)    ((char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*)(__pyx_uintptr_t) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsSString(s)    ((const signed char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_AsUString(s)    ((const unsigned char*) __Pyx_PyObject_AsString(s))
+#define __Pyx_PyObject_FromCString(s)  __Pyx_PyObject_FromString((const char*)s)
+#define __Pyx_PyBytes_FromCString(s)   __Pyx_PyBytes_FromString((const char*)s)
+#define __Pyx_PyByteArray_FromCString(s)   __Pyx_PyByteArray_FromString((const char*)s)
+#define __Pyx_PyStr_FromCString(s)     __Pyx_PyStr_FromString((const char*)s)
+#define __Pyx_PyUnicode_FromCString(s) __Pyx_PyUnicode_FromString((const char*)s)
+#define __Pyx_PyUnicode_FromOrdinal(o)       PyUnicode_FromOrdinal((int)o)
+#define __Pyx_PyUnicode_AsUnicode            PyUnicode_AsUnicode
+
+#define __Pyx_NewRef(obj) (Py_INCREF(obj), obj)
+#define __Pyx_Owned_Py_None(b) __Pyx_NewRef(Py_None)
+static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b);
+static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject*);
+static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject*);
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x);
+
+#define __Pyx_PySequence_Tuple(obj) \
+    (likely(PyTuple_CheckExact(obj)) ? __Pyx_NewRef(obj) : PySequence_Tuple(obj))
+
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject*);
+static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t);
+static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject*);
+
+#if CYTHON_ASSUME_SAFE_MACROS
+#define __pyx_PyFloat_AsDouble(x) (PyFloat_CheckExact(x) ? PyFloat_AS_DOUBLE(x) : PyFloat_AsDouble(x))
+#else
+#define __pyx_PyFloat_AsDouble(x) PyFloat_AsDouble(x)
+#endif
+#define __pyx_PyFloat_AsFloat(x) ((float) __pyx_PyFloat_AsDouble(x))
+
+#if PY_MAJOR_VERSION >= 3
+#define __Pyx_PyNumber_Int(x) (PyLong_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Long(x))
+#else
+#define __Pyx_PyNumber_Int(x) (PyInt_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Int(x))
+#endif
+// __Pyx_PyNumber_Float is now in its own section since it has dependencies (needed to make
+// string conversion work the same in all circumstances).
+
+#if CYTHON_USE_PYLONG_INTERNALS
+  #if PY_VERSION_HEX >= 0x030C00A7
+  #ifndef _PyLong_SIGN_MASK
+    #define _PyLong_SIGN_MASK 3
+  #endif
+  #ifndef _PyLong_NON_SIZE_BITS
+    #define _PyLong_NON_SIZE_BITS 3
+  #endif
+  #define __Pyx_PyLong_Sign(x)  (((PyLongObject*)x)->long_value.lv_tag & _PyLong_SIGN_MASK)
+  #define __Pyx_PyLong_IsNeg(x)  ((__Pyx_PyLong_Sign(x) & 2) != 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (!__Pyx_PyLong_IsNeg(x))
+  #define __Pyx_PyLong_IsZero(x)  (__Pyx_PyLong_Sign(x) & 1)
+  #define __Pyx_PyLong_IsPos(x)  (__Pyx_PyLong_Sign(x) == 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  (__Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  ((Py_ssize_t) (((PyLongObject*)x)->long_value.lv_tag >> _PyLong_NON_SIZE_BITS))
+  #define __Pyx_PyLong_SignedDigitCount(x)  \
+        ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * __Pyx_PyLong_DigitCount(x))
+
+  #if defined(PyUnstable_Long_IsCompact) && defined(PyUnstable_Long_CompactValue)
+    #define __Pyx_PyLong_IsCompact(x)     PyUnstable_Long_IsCompact((PyLongObject*) x)
+    #define __Pyx_PyLong_CompactValue(x)  PyUnstable_Long_CompactValue((PyLongObject*) x)
+  #else
+    #define __Pyx_PyLong_IsCompact(x)     (((PyLongObject*)x)->long_value.lv_tag < (2 << _PyLong_NON_SIZE_BITS))
+    #define __Pyx_PyLong_CompactValue(x)  ((1 - (Py_ssize_t) __Pyx_PyLong_Sign(x)) * (Py_ssize_t) __Pyx_PyLong_Digits(x)[0])
+  #endif
+
+  // CPython 3.12 requires C99, which defines 'size_t' (but not 'ssize_t')
+  typedef Py_ssize_t  __Pyx_compact_pylong;
+  typedef size_t  __Pyx_compact_upylong;
+
+  #else  /* Py < 3.12 */
+  #define __Pyx_PyLong_IsNeg(x)  (Py_SIZE(x) < 0)
+  #define __Pyx_PyLong_IsNonNeg(x)  (Py_SIZE(x) >= 0)
+  #define __Pyx_PyLong_IsZero(x)  (Py_SIZE(x) == 0)
+  #define __Pyx_PyLong_IsPos(x)  (Py_SIZE(x) > 0)
+  #define __Pyx_PyLong_CompactValueUnsigned(x)  ((Py_SIZE(x) == 0) ? 0 : __Pyx_PyLong_Digits(x)[0])
+  #define __Pyx_PyLong_DigitCount(x)  __Pyx_sst_abs(Py_SIZE(x))
+  #define __Pyx_PyLong_SignedDigitCount(x)  Py_SIZE(x)
+
+  #define __Pyx_PyLong_IsCompact(x)  (Py_SIZE(x) == 0 || Py_SIZE(x) == 1 || Py_SIZE(x) == -1)
+  #define __Pyx_PyLong_CompactValue(x)  \
+        ((Py_SIZE(x) == 0) ? (sdigit) 0 : ((Py_SIZE(x) < 0) ? -(sdigit)__Pyx_PyLong_Digits(x)[0] : (sdigit)__Pyx_PyLong_Digits(x)[0]))
+
+  typedef sdigit  __Pyx_compact_pylong;
+  typedef digit  __Pyx_compact_upylong;
+  #endif
+
+  #if PY_VERSION_HEX >= 0x030C00A5
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->long_value.ob_digit)
+  #else
+  #define __Pyx_PyLong_Digits(x)  (((PyLongObject*)x)->ob_digit)
+  #endif
+#endif
+
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+#include <string.h>
+
+static int __Pyx_sys_getdefaultencoding_not_ascii;
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+    PyObject* sys;
+    PyObject* default_encoding = NULL;
+    PyObject* ascii_chars_u = NULL;
+    PyObject* ascii_chars_b = NULL;
+    const char* default_encoding_c;
+    sys = PyImport_ImportModule("sys");
+    if (!sys) goto bad;
+    default_encoding = PyObject_CallMethod(sys, (char*) "getdefaultencoding", NULL);
+    Py_DECREF(sys);
+    if (!default_encoding) goto bad;
+    default_encoding_c = PyBytes_AsString(default_encoding);
+    if (!default_encoding_c) goto bad;
+    if (strcmp(default_encoding_c, "ascii") == 0) {
+        __Pyx_sys_getdefaultencoding_not_ascii = 0;
+    } else {
+        char ascii_chars[128];
+        int c;
+        for (c = 0; c < 128; c++) {
+            ascii_chars[c] = (char) c;
+        }
+        __Pyx_sys_getdefaultencoding_not_ascii = 1;
+        ascii_chars_u = PyUnicode_DecodeASCII(ascii_chars, 128, NULL);
+        if (!ascii_chars_u) goto bad;
+        ascii_chars_b = PyUnicode_AsEncodedString(ascii_chars_u, default_encoding_c, NULL);
+        if (!ascii_chars_b || !PyBytes_Check(ascii_chars_b) || memcmp(ascii_chars, PyBytes_AS_STRING(ascii_chars_b), 128) != 0) {
+            PyErr_Format(
+                PyExc_ValueError,
+                "This module compiled with c_string_encoding=ascii, but default encoding '%.200s' is not a superset of ascii.",
+                default_encoding_c);
+            goto bad;
+        }
+        Py_DECREF(ascii_chars_u);
+        Py_DECREF(ascii_chars_b);
+    }
+    Py_DECREF(default_encoding);
+    return 0;
+bad:
+    Py_XDECREF(default_encoding);
+    Py_XDECREF(ascii_chars_u);
+    Py_XDECREF(ascii_chars_b);
+    return -1;
+}
+#endif
+
+#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT && PY_MAJOR_VERSION >= 3
+#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_DecodeUTF8(c_str, size, NULL)
+#else
+#define __Pyx_PyUnicode_FromStringAndSize(c_str, size) PyUnicode_Decode(c_str, size, __PYX_DEFAULT_STRING_ENCODING, NULL)
+
+// __PYX_DEFAULT_STRING_ENCODING is either a user provided string constant
+// or we need to look it up here
+#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+#include <string.h>
+
+static char* __PYX_DEFAULT_STRING_ENCODING;
+
+static int __Pyx_init_sys_getdefaultencoding_params(void) {
+    PyObject* sys;
+    PyObject* default_encoding = NULL;
+    char* default_encoding_c;
+
+    sys = PyImport_ImportModule("sys");
+    if (!sys) goto bad;
+    default_encoding = PyObject_CallMethod(sys, (char*) (const char*) "getdefaultencoding", NULL);
+    Py_DECREF(sys);
+    if (!default_encoding) goto bad;
+    default_encoding_c = PyBytes_AsString(default_encoding);
+    if (!default_encoding_c) goto bad;
+    __PYX_DEFAULT_STRING_ENCODING = (char*) malloc(strlen(default_encoding_c) + 1);
+    if (!__PYX_DEFAULT_STRING_ENCODING) goto bad;
+    strcpy(__PYX_DEFAULT_STRING_ENCODING, default_encoding_c);
+    Py_DECREF(default_encoding);
+    return 0;
+bad:
+    Py_XDECREF(default_encoding);
+    return -1;
+}
+#endif
+#endif
+
+/////////////// TypeConversions ///////////////
+
+/* Type Conversion Functions */
+
+#include <string.h>
+
+static CYTHON_INLINE Py_ssize_t __Pyx_ssize_strlen(const char *s) {
+    size_t len = strlen(s);
+    if (unlikely(len > (size_t) PY_SSIZE_T_MAX)) {
+        PyErr_SetString(PyExc_OverflowError, "byte string is too long");
+        return -1;
+    }
+    return (Py_ssize_t) len;
+}
+
+static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_str) {
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return __Pyx_PyUnicode_FromStringAndSize(c_str, len);
+}
+
+static CYTHON_INLINE PyObject* __Pyx_PyByteArray_FromString(const char* c_str) {
+    Py_ssize_t len = __Pyx_ssize_strlen(c_str);
+    if (unlikely(len < 0)) return NULL;
+    return PyByteArray_FromStringAndSize(c_str, len);
+}
+
+// Py3.7 returns a "const char*" for unicode strings
+static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
+    Py_ssize_t ignore;
+    return __Pyx_PyObject_AsStringAndSize(o, &ignore);
+}
+
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+#if !CYTHON_PEP393_ENABLED
+static const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
+    char* defenc_c;
+    // borrowed reference, cached internally in 'o' by CPython
+    PyObject* defenc = _PyUnicode_AsDefaultEncodedString(o, NULL);
+    if (!defenc) return NULL;
+    defenc_c = PyBytes_AS_STRING(defenc);
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+    {
+        char* end = defenc_c + PyBytes_GET_SIZE(defenc);
+        char* c;
+        for (c = defenc_c; c < end; c++) {
+            if ((unsigned char) (*c) >= 128) {
+                // raise the error
+                PyUnicode_AsASCIIString(o);
+                return NULL;
+            }
+        }
+    }
+#endif /*__PYX_DEFAULT_STRING_ENCODING_IS_ASCII*/
+    *length = PyBytes_GET_SIZE(defenc);
+    return defenc_c;
+}
+
+#else /* CYTHON_PEP393_ENABLED: */
+
+static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
+    if (unlikely(__Pyx_PyUnicode_READY(o) == -1)) return NULL;
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+    if (likely(PyUnicode_IS_ASCII(o))) {
+        // cached for the lifetime of the object
+        *length = PyUnicode_GET_LENGTH(o);
+        return PyUnicode_AsUTF8(o);
+    } else {
+        // raise the error
+        PyUnicode_AsASCIIString(o);
+        return NULL;
+    }
+#else /* __PYX_DEFAULT_STRING_ENCODING_IS_ASCII */
+    return PyUnicode_AsUTF8AndSize(o, length);
+#endif /* __PYX_DEFAULT_STRING_ENCODING_IS_ASCII */
+}
+#endif /* CYTHON_PEP393_ENABLED */
+#endif
+
+// Py3.7 returns a "const char*" for unicode strings
+static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject* o, Py_ssize_t *length) {
+#if __PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
+    if (
+#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
+            __Pyx_sys_getdefaultencoding_not_ascii &&
+#endif
+            PyUnicode_Check(o)) {
+        return __Pyx_PyUnicode_AsStringAndSize(o, length);
+    } else
+#endif /* __PYX_DEFAULT_STRING_ENCODING_IS_ASCII  || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT */
+
+#if (!CYTHON_COMPILING_IN_PYPY && !CYTHON_COMPILING_IN_LIMITED_API) || (defined(PyByteArray_AS_STRING) && defined(PyByteArray_GET_SIZE))
+    if (PyByteArray_Check(o)) {
+        *length = PyByteArray_GET_SIZE(o);
+        return PyByteArray_AS_STRING(o);
+    } else
+#endif
+    {
+        char* result;
+        int r = PyBytes_AsStringAndSize(o, &result, length);
+        if (unlikely(r < 0)) {
+            return NULL;
+        } else {
+            return result;
+        }
+    }
+}
+
+/* Note: __Pyx_PyObject_IsTrue is written to minimize branching. */
+static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {
+   int is_true = x == Py_True;
+   if (is_true | (x == Py_False) | (x == Py_None)) return is_true;
+   else return PyObject_IsTrue(x);
+}
+
+static CYTHON_INLINE int __Pyx_PyObject_IsTrueAndDecref(PyObject* x) {
+    int retval;
+    if (unlikely(!x)) return -1;
+    retval = __Pyx_PyObject_IsTrue(x);
+    Py_DECREF(x);
+    return retval;
+}
+
+static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* result, const char* type_name) {
+    __Pyx_TypeName result_type_name = __Pyx_PyType_GetName(Py_TYPE(result));
+#if PY_MAJOR_VERSION >= 3
+    if (PyLong_Check(result)) {
+        // CPython issue #17576: warn if 'result' not of exact type int.
+        if (PyErr_WarnFormat(PyExc_DeprecationWarning, 1,
+                "__int__ returned non-int (type " __Pyx_FMT_TYPENAME ").  "
+                "The ability to return an instance of a strict subclass of int is deprecated, "
+                "and may be removed in a future version of Python.",
+                result_type_name)) {
+            __Pyx_DECREF_TypeName(result_type_name);
+            Py_DECREF(result);
+            return NULL;
+        }
+        __Pyx_DECREF_TypeName(result_type_name);
+        return result;
+    }
+#endif
+    PyErr_Format(PyExc_TypeError,
+                 "__%.4s__ returned non-%.4s (type " __Pyx_FMT_TYPENAME ")",
+                 type_name, type_name, result_type_name);
+    __Pyx_DECREF_TypeName(result_type_name);
+    Py_DECREF(result);
+    return NULL;
+}
+
+static CYTHON_INLINE PyObject* __Pyx_PyNumber_IntOrLong(PyObject* x) {
+#if CYTHON_USE_TYPE_SLOTS
+  PyNumberMethods *m;
+#endif
+  const char *name = NULL;
+  PyObject *res = NULL;
+#if PY_MAJOR_VERSION < 3
+  if (likely(PyInt_Check(x) || PyLong_Check(x)))
+#else
+  if (likely(PyLong_Check(x)))
+#endif
+    return __Pyx_NewRef(x);
+#if CYTHON_USE_TYPE_SLOTS
+  m = Py_TYPE(x)->tp_as_number;
+  #if PY_MAJOR_VERSION < 3
+  if (m && m->nb_int) {
+    name = "int";
+    res = m->nb_int(x);
+  }
+  else if (m && m->nb_long) {
+    name = "long";
+    res = m->nb_long(x);
+  }
+  #else
+  if (likely(m && m->nb_int)) {
+    name = "int";
+    res = m->nb_int(x);
+  }
+  #endif
+#else
+  if (!PyBytes_CheckExact(x) && !PyUnicode_CheckExact(x)) {
+    res = PyNumber_Int(x);
+  }
+#endif
+  if (likely(res)) {
+#if PY_MAJOR_VERSION < 3
+    if (unlikely(!PyInt_Check(res) && !PyLong_Check(res))) {
+#else
+    if (unlikely(!PyLong_CheckExact(res))) {
+#endif
+        return __Pyx_PyNumber_IntOrLongWrongResultType(res, name);
+    }
+  }
+  else if (!PyErr_Occurred()) {
+    PyErr_SetString(PyExc_TypeError,
+                    "an integer is required");
+  }
+  return res;
+}
+
+{{py: from Cython.Utility import pylong_join }}
+
+static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
+  Py_ssize_t ival;
+  PyObject *x;
+#if PY_MAJOR_VERSION < 3
+  if (likely(PyInt_CheckExact(b))) {
+    if (sizeof(Py_ssize_t) >= sizeof(long))
+        return PyInt_AS_LONG(b);
+    else
+        return PyInt_AsSsize_t(b);
+  }
+#endif
+  if (likely(PyLong_CheckExact(b))) {
+    #if CYTHON_USE_PYLONG_INTERNALS
+    // handle most common case first to avoid indirect branch and optimise branch prediction
+    if (likely(__Pyx_PyLong_IsCompact(b))) {
+        return __Pyx_PyLong_CompactValue(b);
+    } else {
+      const digit* digits = __Pyx_PyLong_Digits(b);
+      const Py_ssize_t size = __Pyx_PyLong_SignedDigitCount(b);
+      switch (size) {
+         {{for _size in (2, 3, 4)}}
+         {{for _case in (_size, -_size)}}
+         case {{_case}}:
+           if (8 * sizeof(Py_ssize_t) > {{_size}} * PyLong_SHIFT) {
+             return {{'-' if _case < 0 else ''}}(Py_ssize_t) {{pylong_join(_size, 'digits', 'size_t')}};
+           }
+           break;
+         {{endfor}}
+         {{endfor}}
+      }
+    }
+    #endif
+    return PyLong_AsSsize_t(b);
+  }
+  x = PyNumber_Index(b);
+  if (!x) return -1;
+  ival = PyInt_AsSsize_t(x);
+  Py_DECREF(x);
+  return ival;
+}
+
+
+static CYTHON_INLINE Py_hash_t __Pyx_PyIndex_AsHash_t(PyObject* o) {
+  if (sizeof(Py_hash_t) == sizeof(Py_ssize_t)) {
+    return (Py_hash_t) __Pyx_PyIndex_AsSsize_t(o);
+#if PY_MAJOR_VERSION < 3
+  } else if (likely(PyInt_CheckExact(o))) {
+    return PyInt_AS_LONG(o);
+#endif
+  } else {
+    Py_ssize_t ival;
+    PyObject *x;
+    x = PyNumber_Index(o);
+    if (!x) return -1;
+    ival = PyInt_AsLong(x);
+    Py_DECREF(x);
+    return ival;
+  }
+}
+
+
+static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) {
+  return b ? __Pyx_NewRef(Py_True) : __Pyx_NewRef(Py_False);
+}
+
+
+static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {
+    return PyInt_FromSize_t(ival);
+}
+
+/////////////// pynumber_float.proto ///////////////
+
+static CYTHON_INLINE PyObject* __Pyx__PyNumber_Float(PyObject* obj); /* proto */
+#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : __Pyx__PyNumber_Float(x))
+
+/////////////// pynumber_float ///////////////
+//@requires: Optimize.c::pybytes_as_double
+//@requires: Optimize.c::pyunicode_as_double
+
+static CYTHON_INLINE PyObject* __Pyx__PyNumber_Float(PyObject* obj) {
+    // 'obj is PyFloat' is handled in the calling macro
+    double val;
+    if (PyLong_CheckExact(obj)) {
+#if CYTHON_USE_PYLONG_INTERNALS
+        if (likely(__Pyx_PyLong_IsCompact(obj))) {
+            val = (double) __Pyx_PyLong_CompactValue(obj);
+            goto no_error;
+        }
+#endif
+        val = PyLong_AsDouble(obj);
+    } else if (PyUnicode_CheckExact(obj)) {
+        val = __Pyx_PyUnicode_AsDouble(obj);
+    } else if (PyBytes_CheckExact(obj)) {
+        val = __Pyx_PyBytes_AsDouble(obj);
+    } else if (PyByteArray_CheckExact(obj)) {
+        val = __Pyx_PyByteArray_AsDouble(obj);
+    } else {
+        return PyNumber_Float(obj);
+    }
+
+    if (unlikely(val == -1 && PyErr_Occurred())) {
+        return NULL;
+    }
+#if CYTHON_USE_PYLONG_INTERNALS
+no_error:
+#endif
+    return PyFloat_FromDouble(val);
+}
+
+/////////////// GCCDiagnostics.proto ///////////////
+
+// GCC diagnostic pragmas were introduced in GCC 4.6
+// Used to silence conversion warnings that are ok but cannot be avoided.
+#if !defined(__INTEL_COMPILER) && defined(__GNUC__) && (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6))
+#define __Pyx_HAS_GCC_DIAGNOSTIC
+#endif
+
+
+/////////////// ToPyCTupleUtility.proto ///////////////
+static PyObject* {{funcname}}({{struct_type_decl}});
+
+/////////////// ToPyCTupleUtility ///////////////
+static PyObject* {{funcname}}({{struct_type_decl}} value) {
+    PyObject* item = NULL;
+    PyObject* result = PyTuple_New({{size}});
+    if (!result) goto bad;
+
+    {{for ix, component in enumerate(components):}}
+        {{py:attr = "value.f%s" % ix}}
+        item = {{component.to_py_function}}({{attr}});
+        if (!item) goto bad;
+        PyTuple_SET_ITEM(result, {{ix}}, item);
+    {{endfor}}
+
+    return result;
+bad:
+    Py_XDECREF(item);
+    Py_XDECREF(result);
+    return NULL;
+}
+
+
+/////////////// FromPyCTupleUtility.proto ///////////////
+static CYTHON_INLINE {{struct_type_decl}} {{funcname}}(PyObject *);
+
+/////////////// FromPyCTupleUtility ///////////////
+
+#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+static void __Pyx_tuple_{{funcname}}(PyObject * o, {{struct_type_decl}} *result) {
+    {{for ix, component in enumerate(components):}}
+        {{py:attr = "result->f%s" % ix}}
+        {{attr}} = {{component.from_py_function}}(PyTuple_GET_ITEM(o, {{ix}}));
+        if ({{component.error_condition(attr)}}) goto bad;
+    {{endfor}}
+    return;
+bad:
+    return;
+}
+
+static void __Pyx_list_{{funcname}}(PyObject * o, {{struct_type_decl}} *result) {
+    {{for ix, component in enumerate(components):}}
+        {{py:attr = "result->f%s" % ix}}
+        {{attr}} = {{component.from_py_function}}(PyList_GET_ITEM(o, {{ix}}));
+        if ({{component.error_condition(attr)}}) goto bad;
+    {{endfor}}
+    return;
+bad:
+    return;
+}
+#endif
+
+static void __Pyx_seq_{{funcname}}(PyObject * o, {{struct_type_decl}} *result) {
+    if (unlikely(!PySequence_Check(o))) {
+        __Pyx_TypeName o_type_name = __Pyx_PyType_GetName(Py_TYPE(o));
+        PyErr_Format(PyExc_TypeError,
+                     "Expected a sequence of size %zd, got " __Pyx_FMT_TYPENAME, (Py_ssize_t) {{size}}, o_type_name);
+        __Pyx_DECREF_TypeName(o_type_name);
+        goto bad;
+    } else if (unlikely(PySequence_Length(o) != {{size}})) {
+        PyErr_Format(PyExc_TypeError,
+                     "Expected a sequence of size %zd, got size %zd", (Py_ssize_t) {{size}}, PySequence_Length(o));
+        goto bad;
+    }
+
+    {
+        PyObject *item;
+    {{for ix, component in enumerate(components):}}
+        {{py:attr = "result->f%s" % ix}}
+        item = PySequence_ITEM(o, {{ix}});  if (unlikely(!item)) goto bad;
+        {{attr}} = {{component.from_py_function}}(item);
+        Py_DECREF(item);
+        if ({{component.error_condition(attr)}}) goto bad;
+    {{endfor}}
+    }
+    return;
+bad:
+    return;
+}
+
+static CYTHON_INLINE {{struct_type_decl}} {{funcname}}(PyObject * o) {
+    {{struct_type_decl}} result;
+
+    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
+    if (likely(PyTuple_Check(o) && PyTuple_GET_SIZE(o) == {{size}})) {
+        __Pyx_tuple_{{funcname}}(o, &result);
+    } else if (likely(PyList_Check(o) && PyList_GET_SIZE(o) == {{size}})) {
+        __Pyx_list_{{funcname}}(o, &result);
+    } else
+    #endif
+    {
+        __Pyx_seq_{{funcname}}(o, &result);
+    }
+
+    return result;
+}
+
+
+/////////////// UnicodeAsUCS4.proto ///////////////
+
+static CYTHON_INLINE Py_UCS4 __Pyx_PyUnicode_AsPy_UCS4(PyObject*);
+
+/////////////// UnicodeAsUCS4 ///////////////
+
+static CYTHON_INLINE Py_UCS4 __Pyx_PyUnicode_AsPy_UCS4(PyObject* x) {
+   Py_ssize_t length;
+   #if CYTHON_PEP393_ENABLED
+   length = PyUnicode_GET_LENGTH(x);
+   if (likely(length == 1)) {
+       return PyUnicode_READ_CHAR(x, 0);
+   }
+   #else
+   length = PyUnicode_GET_SIZE(x);
+   if (likely(length == 1)) {
+       return PyUnicode_AS_UNICODE(x)[0];
+   }
+   #if Py_UNICODE_SIZE == 2
+   else if (PyUnicode_GET_SIZE(x) == 2) {
+       Py_UCS4 high_val = PyUnicode_AS_UNICODE(x)[0];
+       if (high_val >= 0xD800 && high_val <= 0xDBFF) {
+           Py_UCS4 low_val = PyUnicode_AS_UNICODE(x)[1];
+           if (low_val >= 0xDC00 && low_val <= 0xDFFF) {
+               return 0x10000 + (((high_val & ((1<<10)-1)) << 10) | (low_val & ((1<<10)-1)));
+           }
+       }
+   }
+   #endif
+   #endif
+   PyErr_Format(PyExc_ValueError,
+                "only single character unicode strings can be converted to Py_UCS4, "
+                "got length %" CYTHON_FORMAT_SSIZE_T "d", length);
+   return (Py_UCS4)-1;
+}
+
+
+/////////////// ObjectAsUCS4.proto ///////////////
+//@requires: UnicodeAsUCS4
+
+#define __Pyx_PyObject_AsPy_UCS4(x) \
+    (likely(PyUnicode_Check(x)) ? __Pyx_PyUnicode_AsPy_UCS4(x) : __Pyx__PyObject_AsPy_UCS4(x))
+static Py_UCS4 __Pyx__PyObject_AsPy_UCS4(PyObject*);
+
+/////////////// ObjectAsUCS4 ///////////////
+
+static Py_UCS4 __Pyx__PyObject_AsPy_UCS4_raise_error(long ival) {
+   if (ival < 0) {
+       if (!PyErr_Occurred())
+           PyErr_SetString(PyExc_OverflowError,
+                           "cannot convert negative value to Py_UCS4");
+   } else {
+       PyErr_SetString(PyExc_OverflowError,
+                       "value too large to convert to Py_UCS4");
+   }
+   return (Py_UCS4)-1;
+}
+
+static Py_UCS4 __Pyx__PyObject_AsPy_UCS4(PyObject* x) {
+   long ival;
+   ival = __Pyx_PyInt_As_long(x);
+   if (unlikely(!__Pyx_is_valid_index(ival, 1114111 + 1))) {
+       return __Pyx__PyObject_AsPy_UCS4_raise_error(ival);
+   }
+   return (Py_UCS4)ival;
+}
+
+
+/////////////// ObjectAsPyUnicode.proto ///////////////
+
+static CYTHON_INLINE Py_UNICODE __Pyx_PyObject_AsPy_UNICODE(PyObject*);
+
+/////////////// ObjectAsPyUnicode ///////////////
+
+static CYTHON_INLINE Py_UNICODE __Pyx_PyObject_AsPy_UNICODE(PyObject* x) {
+    long ival;
+    #if CYTHON_PEP393_ENABLED
+    #if Py_UNICODE_SIZE > 2
+    const long maxval = 1114111;
+    #else
+    const long maxval = 65535;
+    #endif
+    #else
+    static long maxval = 0;
+    #endif
+    if (PyUnicode_Check(x)) {
+        if (unlikely(__Pyx_PyUnicode_GET_LENGTH(x) != 1)) {
+            PyErr_Format(PyExc_ValueError,
+                         "only single character unicode strings can be converted to Py_UNICODE, "
+                         "got length %" CYTHON_FORMAT_SSIZE_T "d", __Pyx_PyUnicode_GET_LENGTH(x));
+            return (Py_UNICODE)-1;
+        }
+        #if CYTHON_PEP393_ENABLED
+        ival = PyUnicode_READ_CHAR(x, 0);
+        #else
+        return PyUnicode_AS_UNICODE(x)[0];
+        #endif
+    } else {
+        #if !CYTHON_PEP393_ENABLED
+        if (unlikely(!maxval))
+            maxval = (long)PyUnicode_GetMax();
+        #endif
+        ival = __Pyx_PyInt_As_long(x);
+    }
+    if (unlikely(!__Pyx_is_valid_index(ival, maxval + 1))) {
+        if (ival < 0) {
+            if (!PyErr_Occurred())
+                PyErr_SetString(PyExc_OverflowError,
+                                "cannot convert negative value to Py_UNICODE");
+            return (Py_UNICODE)-1;
+        } else {
+            PyErr_SetString(PyExc_OverflowError,
+                            "value too large to convert to Py_UNICODE");
+        }
+        return (Py_UNICODE)-1;
+    }
+    return (Py_UNICODE)ival;
+}
+
+
+/////////////// CIntToPy.proto ///////////////
+
+static CYTHON_INLINE PyObject* {{TO_PY_FUNCTION}}({{TYPE}} value);
+
+/////////////// CIntToPy ///////////////
+//@requires: GCCDiagnostics
+
+static CYTHON_INLINE PyObject* {{TO_PY_FUNCTION}}({{TYPE}} value) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const {{TYPE}} neg_one = ({{TYPE}}) -1, const_zero = ({{TYPE}}) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+    if (is_unsigned) {
+        if (sizeof({{TYPE}}) < sizeof(long)) {
+            return PyInt_FromLong((long) value);
+        } else if (sizeof({{TYPE}}) <= sizeof(unsigned long)) {
+            return PyLong_FromUnsignedLong((unsigned long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof({{TYPE}}) <= sizeof(unsigned PY_LONG_LONG)) {
+            return PyLong_FromUnsignedLongLong((unsigned PY_LONG_LONG) value);
+#endif
+        }
+    } else {
+        if (sizeof({{TYPE}}) <= sizeof(long)) {
+            return PyInt_FromLong((long) value);
+#ifdef HAVE_LONG_LONG
+        } else if (sizeof({{TYPE}}) <= sizeof(PY_LONG_LONG)) {
+            return PyLong_FromLongLong((PY_LONG_LONG) value);
+#endif
+        }
+    }
+    {
+        unsigned char *bytes = (unsigned char *)&value;
+#if !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX >= 0x030d00A4
+        if (is_unsigned) {
+            return PyLong_FromUnsignedNativeBytes(bytes, sizeof(value), -1);
+        } else {
+            return PyLong_FromNativeBytes(bytes, sizeof(value), -1);
+        }
+#elif !CYTHON_COMPILING_IN_LIMITED_API && PY_VERSION_HEX < 0x030d0000
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        return _PyLong_FromByteArray(bytes, sizeof({{TYPE}}),
+                                     little, !is_unsigned);
+#else
+        // call int.from_bytes()
+        int one = 1; int little = (int)*(unsigned char *)&one;
+        PyObject *from_bytes, *result = NULL;
+        PyObject *py_bytes = NULL, *arg_tuple = NULL, *kwds = NULL, *order_str = NULL;
+        from_bytes = PyObject_GetAttrString((PyObject*)&PyLong_Type, "from_bytes");
+        if (!from_bytes) return NULL;
+        py_bytes = PyBytes_FromStringAndSize((char*)bytes, sizeof({{TYPE}}));
+        if (!py_bytes) goto limited_bad;
+        // I'm deliberately not using PYIDENT here because this code path is very unlikely
+        // to ever run so it seems a pessimization mostly.
+        order_str = PyUnicode_FromString(little ? "little" : "big");
+        if (!order_str) goto limited_bad;
+        arg_tuple = PyTuple_Pack(2, py_bytes, order_str);
+        if (!arg_tuple) goto limited_bad;
+        if (!is_unsigned) {
+            // default is signed=False
+            kwds = PyDict_New();
+            if (!kwds) goto limited_bad;
+            if (PyDict_SetItemString(kwds, "signed", __Pyx_NewRef(Py_True))) goto limited_bad;
+        }
+        result = PyObject_Call(from_bytes, arg_tuple, kwds);
+
+        limited_bad:
+        Py_XDECREF(kwds);
+        Py_XDECREF(arg_tuple);
+        Py_XDECREF(order_str);
+        Py_XDECREF(py_bytes);
+        Py_XDECREF(from_bytes);
+        return result;
+#endif
+    }
+}
+
+
+/////////////// CIntToDigits ///////////////
+
+static const char DIGIT_PAIRS_10[2*10*10+1] = {
+    "00010203040506070809"
+    "10111213141516171819"
+    "20212223242526272829"
+    "30313233343536373839"
+    "40414243444546474849"
+    "50515253545556575859"
+    "60616263646566676869"
+    "70717273747576777879"
+    "80818283848586878889"
+    "90919293949596979899"
+};
+
+static const char DIGIT_PAIRS_8[2*8*8+1] = {
+    "0001020304050607"
+    "1011121314151617"
+    "2021222324252627"
+    "3031323334353637"
+    "4041424344454647"
+    "5051525354555657"
+    "6061626364656667"
+    "7071727374757677"
+};
+
+static const char DIGITS_HEX[2*16+1] = {
+    "0123456789abcdef"
+    "0123456789ABCDEF"
+};
+
+
+/////////////// CIntToPyUnicode.proto ///////////////
+
+static CYTHON_INLINE PyObject* {{TO_PY_FUNCTION}}({{TYPE}} value, Py_ssize_t width, char padding_char, char format_char);
+
+/////////////// CIntToPyUnicode ///////////////
+//@requires: StringTools.c::IncludeStringH
+//@requires: StringTools.c::BuildPyUnicode
+//@requires: CIntToDigits
+//@requires: GCCDiagnostics
+
+// NOTE: inlining because most arguments are constant, which collapses lots of code below
+
+static CYTHON_INLINE PyObject* {{TO_PY_FUNCTION}}({{TYPE}} value, Py_ssize_t width, char padding_char, char format_char) {
+    // simple and conservative C string allocation on the stack: each byte gives at most 3 digits, plus sign
+    char digits[sizeof({{TYPE}})*3+2];
+    // 'dpos' points to end of digits array + 1 initially to allow for pre-decrement looping
+    char *dpos, *end = digits + sizeof({{TYPE}})*3+2;
+    const char *hex_digits = DIGITS_HEX;
+    Py_ssize_t length, ulength;
+    int prepend_sign, last_one_off;
+    {{TYPE}} remaining;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const {{TYPE}} neg_one = ({{TYPE}}) -1, const_zero = ({{TYPE}}) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+
+    if (format_char == 'X') {
+        hex_digits += 16;
+        format_char = 'x';
+    }
+
+    // surprise: even trivial sprintf() calls don't get optimised in gcc (4.8)
+    remaining = value; /* not using abs(value) to avoid overflow problems */
+    last_one_off = 0;
+    dpos = end;
+    do {
+        int digit_pos;
+        switch (format_char) {
+        case 'o':
+            digit_pos = abs((int)(remaining % (8*8)));
+            remaining = ({{TYPE}}) (remaining / (8*8));
+            dpos -= 2;
+            memcpy(dpos, DIGIT_PAIRS_8 + digit_pos * 2, 2); /* copy 2 digits at a time, unaligned */
+            last_one_off = (digit_pos < 8);
+            break;
+        case 'd':
+            digit_pos = abs((int)(remaining % (10*10)));
+            remaining = ({{TYPE}}) (remaining / (10*10));
+            dpos -= 2;
+            memcpy(dpos, DIGIT_PAIRS_10 + digit_pos * 2, 2); /* copy 2 digits at a time, unaligned */
+            last_one_off = (digit_pos < 10);
+            break;
+        case 'x':
+            *(--dpos) = hex_digits[abs((int)(remaining % 16))];
+            remaining = ({{TYPE}}) (remaining / 16);
+            break;
+        default:
+            assert(0);
+            break;
+        }
+    } while (unlikely(remaining != 0));
+
+    // Correct dpos by 1 if we read an excess digit.
+    assert(!last_one_off || *dpos == '0');
+    dpos += last_one_off;
+
+    length = end - dpos;
+    ulength = length;
+    prepend_sign = 0;
+    if (!is_unsigned && value <= neg_one) {
+        if (padding_char == ' ' || width <= length + 1) {
+            *(--dpos) = '-';
+            ++length;
+        } else {
+            prepend_sign = 1;
+        }
+        ++ulength;
+    }
+    if (width > ulength) {
+        ulength = width;
+    }
+    // single character unicode strings are cached in CPython => use PyUnicode_FromOrdinal() for them
+    if (ulength == 1) {
+        return PyUnicode_FromOrdinal(*dpos);
+    }
+    return __Pyx_PyUnicode_BuildFromAscii(ulength, dpos, (int) length, prepend_sign, padding_char);
+}
+
+
+/////////////// CBIntToPyUnicode.proto ///////////////
+
+#define {{TO_PY_FUNCTION}}(value)  \
+    ((value) ? __Pyx_NewRef({{TRUE_CONST}}) : __Pyx_NewRef({{FALSE_CONST}}))
+
+
+/////////////// PyIntFromDouble.proto ///////////////
+
+#if PY_MAJOR_VERSION < 3
+static CYTHON_INLINE PyObject* __Pyx_PyInt_FromDouble(double value);
+#else
+#define __Pyx_PyInt_FromDouble(value) PyLong_FromDouble(value)
+#endif
+
+/////////////// PyIntFromDouble ///////////////
+
+#if PY_MAJOR_VERSION < 3
+static CYTHON_INLINE PyObject* __Pyx_PyInt_FromDouble(double value) {
+    if (value >= (double)LONG_MIN && value <= (double)LONG_MAX) {
+        return PyInt_FromLong((long)value);
+    }
+    return PyLong_FromDouble(value);
+}
+#endif
+
+
+/////////////// CIntFromPyVerify ///////////////
+
+// see CIntFromPy
+#define __PYX_VERIFY_RETURN_INT(target_type, func_type, func_value)       \
+    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 0)
+
+#define __PYX_VERIFY_RETURN_INT_EXC(target_type, func_type, func_value)   \
+    __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, 1)
+
+#define __PYX__VERIFY_RETURN_INT(target_type, func_type, func_value, exc) \
+    {                                                                     \
+        func_type value = func_value;                                     \
+        if (sizeof(target_type) < sizeof(func_type)) {                    \
+            if (unlikely(value != (func_type) (target_type) value)) {     \
+                func_type zero = 0;                                       \
+                if (exc && unlikely(value == (func_type)-1 && PyErr_Occurred()))  \
+                    return (target_type) -1;                              \
+                if (is_unsigned && unlikely(value < zero))                \
+                    goto raise_neg_overflow;                              \
+                else                                                      \
+                    goto raise_overflow;                                  \
+            }                                                             \
+        }                                                                 \
+        return (target_type) value;                                       \
+    }
+
+
+/////////////// CIntFromPy.proto ///////////////
+
+static CYTHON_INLINE {{TYPE}} {{FROM_PY_FUNCTION}}(PyObject *);
+
+/////////////// CIntFromPy ///////////////
+//@requires: CIntFromPyVerify
+//@requires: GCCDiagnostics
+
+{{py: from Cython.Utility import pylong_join }}
+
+static CYTHON_INLINE {{TYPE}} {{FROM_PY_FUNCTION}}(PyObject *x) {
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wconversion"
+#endif
+    const {{TYPE}} neg_one = ({{TYPE}}) -1, const_zero = ({{TYPE}}) 0;
+#ifdef __Pyx_HAS_GCC_DIAGNOSTIC
+#pragma GCC diagnostic pop
+#endif
+    const int is_unsigned = neg_one > const_zero;
+#if PY_MAJOR_VERSION < 3
+    if (likely(PyInt_Check(x))) {
+        if ((sizeof({{TYPE}}) < sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT({{TYPE}}, long, PyInt_AS_LONG(x))
+        } else {
+            long val = PyInt_AS_LONG(x);
+            if (is_unsigned && unlikely(val < 0)) {
+                goto raise_neg_overflow;
+            }
+            return ({{TYPE}}) val;
+        }
+    }
+#endif
+
+    if (unlikely(!PyLong_Check(x))) {
+        {{TYPE}} val;
+        PyObject *tmp = __Pyx_PyNumber_IntOrLong(x);
+        if (!tmp) return ({{TYPE}}) -1;
+        val = {{FROM_PY_FUNCTION}}(tmp);
+        Py_DECREF(tmp);
+        return val;
+    }
+
+    if (is_unsigned) {
+#if CYTHON_USE_PYLONG_INTERNALS
+        if (unlikely(__Pyx_PyLong_IsNeg(x))) {
+            goto raise_neg_overflow;
+        //} else if (__Pyx_PyLong_IsZero(x)) {
+        //    return ({{TYPE}}) 0;
+        } else if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT({{TYPE}}, __Pyx_compact_upylong, __Pyx_PyLong_CompactValueUnsigned(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_DigitCount(x)) {
+                {{for _size in (2, 3, 4)}}
+                case {{_size}}:
+                    if ((8 * sizeof({{TYPE}}) > {{_size-1}} * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > {{_size}} * PyLong_SHIFT)) {
+                            __PYX_VERIFY_RETURN_INT({{TYPE}}, unsigned long, {{pylong_join(_size, 'digits')}})
+                        } else if ((8 * sizeof({{TYPE}}) >= {{_size}} * PyLong_SHIFT)) {
+                            return ({{TYPE}}) {{pylong_join(_size, 'digits', TYPE)}};
+                        }
+                    }
+                    break;
+                {{endfor}}
+            }
+        }
+#endif
+#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX < 0x030C00A7
+        if (unlikely(Py_SIZE(x) < 0)) {
+            goto raise_neg_overflow;
+        }
+#else
+        {
+            // misuse Py_False as a quick way to compare to a '0' int object in PyPy
+            int result = PyObject_RichCompareBool(x, Py_False, Py_LT);
+            if (unlikely(result < 0))
+                return ({{TYPE}}) -1;
+            if (unlikely(result == 1))
+                goto raise_neg_overflow;
+        }
+#endif
+        if ((sizeof({{TYPE}}) <= sizeof(unsigned long))) {
+            __PYX_VERIFY_RETURN_INT_EXC({{TYPE}}, unsigned long, PyLong_AsUnsignedLong(x))
+#ifdef HAVE_LONG_LONG
+        } else if ((sizeof({{TYPE}}) <= sizeof(unsigned PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC({{TYPE}}, unsigned PY_LONG_LONG, PyLong_AsUnsignedLongLong(x))
+#endif
+        }
+
+    } else {
+        // signed
+#if CYTHON_USE_PYLONG_INTERNALS
+        if (__Pyx_PyLong_IsCompact(x)) {
+            __PYX_VERIFY_RETURN_INT({{TYPE}}, __Pyx_compact_pylong, __Pyx_PyLong_CompactValue(x))
+        } else {
+            const digit* digits = __Pyx_PyLong_Digits(x);
+            assert(__Pyx_PyLong_DigitCount(x) > 1);
+            switch (__Pyx_PyLong_SignedDigitCount(x)) {
+                {{for _size in (2, 3, 4)}}
+                {{for _case in (-_size, _size)}}
+                case {{_case}}:
+                    if ((8 * sizeof({{TYPE}}){{' - 1' if _case < 0 else ''}} > {{_size-1}} * PyLong_SHIFT)) {
+                        if ((8 * sizeof(unsigned long) > {{_size}} * PyLong_SHIFT)) {
+                            __PYX_VERIFY_RETURN_INT({{TYPE}}, {{'long' if _case < 0 else 'unsigned long'}}, {{'-(long) ' if _case < 0 else ''}}{{pylong_join(_size, 'digits')}})
+                        } else if ((8 * sizeof({{TYPE}}) - 1 > {{_size}} * PyLong_SHIFT)) {
+                            return ({{TYPE}}) ({{'((%s)-1)*' % TYPE if _case < 0 else ''}}{{pylong_join(_size, 'digits', TYPE)}});
+                        }
+                    }
+                    break;
+                {{endfor}}
+                {{endfor}}
+            }
+        }
+#endif
+        if ((sizeof({{TYPE}}) <= sizeof(long))) {
+            __PYX_VERIFY_RETURN_INT_EXC({{TYPE}}, long, PyLong_AsLong(x))
+#ifdef HAVE_LONG_LONG
+        } else if ((sizeof({{TYPE}}) <= sizeof(PY_LONG_LONG))) {
+            __PYX_VERIFY_RETURN_INT_EXC({{TYPE}}, PY_LONG_LONG, PyLong_AsLongLong(x))
+#endif
+        }
+    }
+
+    // large integer type and no access to PyLong internals => allow for a more expensive conversion
+    {
+        {{TYPE}} val;
+        int ret = -1;
+#if PY_VERSION_HEX >= 0x030d00A6 && !CYTHON_COMPILING_IN_LIMITED_API
+        Py_ssize_t bytes_copied = PyLong_AsNativeBytes(
+            x, &val, sizeof(val), Py_ASNATIVEBYTES_NATIVE_ENDIAN | (is_unsigned ? Py_ASNATIVEBYTES_UNSIGNED_BUFFER | Py_ASNATIVEBYTES_REJECT_NEGATIVE : 0));
+        if (unlikely(bytes_copied == -1)) {
+            // failed
+        } else if (unlikely(bytes_copied > (Py_ssize_t) sizeof(val))) {
+            goto raise_overflow;
+        } else {
+            ret = 0;
+        }
+#elif PY_VERSION_HEX < 0x030d0000 && !(CYTHON_COMPILING_IN_PYPY || CYTHON_COMPILING_IN_LIMITED_API) || defined(_PyLong_AsByteArray)
+        int one = 1; int is_little = (int)*(unsigned char *)&one;
+        unsigned char *bytes = (unsigned char *)&val;
+        ret = _PyLong_AsByteArray((PyLongObject *)x,
+                                    bytes, sizeof(val),
+                                    is_little, !is_unsigned);
+#else
+{{if IS_ENUM}}
+        // The fallback implementation uses math operations like shifting, which do not work well with enums.
+        PyErr_SetString(PyExc_RuntimeError,
+                        "_PyLong_AsByteArray() or PyLong_AsNativeBytes() not available, cannot convert large enums");
+        val = ({{TYPE}}) -1;
+{{else}}
+// Inefficient copy of bit chunks through the C-API.  Probably still better than a "cannot do this" exception.
+// This is substantially faster in CPython (>30%) than calling "int.to_bytes()" through the C-API.
+        PyObject *v;
+        PyObject *stepval = NULL, *mask = NULL, *shift = NULL;
+        int bits, remaining_bits, is_negative = 0;
+        int chunk_size = (sizeof(long) < 8) ? 30 : 62;
+
+        // Use exact PyLong to prevent user defined &&/<</etc. implementations (and make Py_SIZE() work below).
+        if (likely(PyLong_CheckExact(x))) {
+            v = __Pyx_NewRef(x);
+        } else {
+            v = PyNumber_Long(x);
+            if (unlikely(!v)) return ({{TYPE}}) -1;
+            assert(PyLong_CheckExact(v));
+        }
+
+        // Misuse Py_False as a quick way to compare to a '0' int object.
+        {
+            int result = PyObject_RichCompareBool(v, Py_False, Py_LT);
+            if (unlikely(result < 0)) {
+                Py_DECREF(v);
+                return ({{TYPE}}) -1;
+            }
+            is_negative = result == 1;
+        }
+
+        if (is_unsigned && unlikely(is_negative)) {
+            Py_DECREF(v);
+            goto raise_neg_overflow;
+        } else if (is_negative) {
+            // bit-invert to make sure we can safely convert it
+            stepval = PyNumber_Invert(v);
+            Py_DECREF(v);
+            if (unlikely(!stepval))
+                return ({{TYPE}}) -1;
+        } else {
+            stepval = v;
+        }
+        v = NULL;
+
+        // Unpack full chunks of bits.
+        val = ({{TYPE}}) 0;
+        mask = PyLong_FromLong((1L << chunk_size) - 1); if (unlikely(!mask)) goto done;
+        shift = PyLong_FromLong(chunk_size); if (unlikely(!shift)) goto done;
+        for (bits = 0; bits < (int) sizeof({{TYPE}}) * 8 - chunk_size; bits += chunk_size) {
+            PyObject *tmp, *digit;
+            long idigit;
+
+            digit = PyNumber_And(stepval, mask);
+            if (unlikely(!digit)) goto done;
+
+            idigit = PyLong_AsLong(digit);
+            Py_DECREF(digit);
+            if (unlikely(idigit < 0)) goto done;
+            val |= (({{TYPE}}) idigit) << bits;
+
+            tmp = PyNumber_Rshift(stepval, shift);
+            if (unlikely(!tmp)) goto done;
+            Py_DECREF(stepval); stepval = tmp;
+        }
+
+        Py_DECREF(shift); shift = NULL;
+        Py_DECREF(mask); mask = NULL;
+
+        // Add the last bits and detect overflow.
+        {
+            long idigit = PyLong_AsLong(stepval);
+            if (unlikely(idigit < 0)) goto done;
+            remaining_bits = ((int) sizeof({{TYPE}}) * 8) - bits - (is_unsigned ? 0 : 1);
+            if (unlikely(idigit >= (1L << remaining_bits)))
+                goto raise_overflow;
+            val |= (({{TYPE}}) idigit) << bits;
+        }
+
+        // Handle sign and overflow into sign bit.
+        if (!is_unsigned) {
+            // gcc warns about unsigned (val < 0) => test sign bit instead
+            if (unlikely(val & ((({{TYPE}}) 1) << (sizeof({{TYPE}}) * 8 - 1))))
+                goto raise_overflow;
+            // undo the PyNumber_Invert() above
+            if (is_negative)
+                val = ~val;
+        }
+        ret = 0;
+    done:
+        Py_XDECREF(shift);
+        Py_XDECREF(mask);
+        Py_XDECREF(stepval);
+{{endif}}
+#endif
+        if (unlikely(ret))
+            return ({{TYPE}}) -1;
+        return val;
+    }
+
+raise_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "value too large to convert to {{TYPE}}");
+    return ({{TYPE}}) -1;
+
+raise_neg_overflow:
+    PyErr_SetString(PyExc_OverflowError,
+        "can't convert negative value to {{TYPE}}");
+    return ({{TYPE}}) -1;
+}

tuning-competition-baseline/.venv/lib/python3.11/site-packages/Cython/Utility/arrayarray.h

@@ -0,0 +1,149 @@
+/////////////// ArrayAPI.proto ///////////////
+
+// arrayarray.h
+//
+//    Artificial C-API for Python's <array.array> type,
+//    used by array.pxd
+//
+//    last changes: 2009-05-15 rk
+//                  2012-05-02 andreasvc
+//                  (see revision control)
+//
+
+#ifndef _ARRAYARRAY_H
+#define _ARRAYARRAY_H
+
+// These two forward declarations are explicitly handled in the type
+// declaration code, as including them here is too late for cython-defined
+// types to use them.
+// struct arrayobject;
+// typedef struct arrayobject arrayobject;
+
+// All possible arraydescr values are defined in the vector "descriptors"
+// below.  That's defined later because the appropriate get and set
+// functions aren't visible yet.
+typedef struct arraydescr {
+    int typecode;
+    int itemsize;
+    PyObject * (*getitem)(struct arrayobject *, Py_ssize_t);
+    int (*setitem)(struct arrayobject *, Py_ssize_t, PyObject *);
+#if PY_MAJOR_VERSION >= 3
+    char *formats;
+#endif
+} arraydescr;
+
+
+struct arrayobject {
+    PyObject_HEAD
+    Py_ssize_t ob_size;
+    union {
+        char *ob_item;
+        float *as_floats;
+        double *as_doubles;
+        int *as_ints;
+        unsigned int *as_uints;
+        unsigned char *as_uchars;
+        signed char *as_schars;
+        char *as_chars;
+        unsigned long *as_ulongs;
+        long *as_longs;
+#if PY_MAJOR_VERSION >= 3
+        unsigned long long *as_ulonglongs;
+        long long *as_longlongs;
+#endif
+        short *as_shorts;
+        unsigned short *as_ushorts;
+        Py_UNICODE *as_pyunicodes;
+        void *as_voidptr;
+    } data;
+    Py_ssize_t allocated;
+    struct arraydescr *ob_descr;
+    PyObject *weakreflist; /* List of weak references */
+#if PY_MAJOR_VERSION >= 3
+        int ob_exports;  /* Number of exported buffers */
+#endif
+};
+
+#ifndef NO_NEWARRAY_INLINE
+//  fast creation of a new array
+static CYTHON_INLINE PyObject * newarrayobject(PyTypeObject *type, Py_ssize_t size,
+    struct arraydescr *descr) {
+    arrayobject *op;
+    size_t nbytes;
+
+    if (size < 0) {
+        PyErr_BadInternalCall();
+        return NULL;
+    }
+
+    nbytes = size * descr->itemsize;
+    // Check for overflow
+    if (nbytes / descr->itemsize != (size_t)size) {
+        return PyErr_NoMemory();
+    }
+    op = (arrayobject *) type->tp_alloc(type, 0);
+    if (op == NULL) {
+        return NULL;
+    }
+    op->ob_descr = descr;
+    op->allocated = size;
+    op->weakreflist = NULL;
+    __Pyx_SET_SIZE(op, size);
+    if (size <= 0) {
+        op->data.ob_item = NULL;
+    }
+    else {
+        op->data.ob_item = PyMem_NEW(char, nbytes);
+        if (op->data.ob_item == NULL) {
+            Py_DECREF(op);
+            return PyErr_NoMemory();
+        }
+    }
+    return (PyObject *) op;
+}
+#else
+PyObject* newarrayobject(PyTypeObject *type, Py_ssize_t size,
+    struct arraydescr *descr);
+#endif /* ifndef NO_NEWARRAY_INLINE */
+
+// fast resize (reallocation to the point)
+// not designed for filing small increments (but for fast opaque array apps)
+static CYTHON_INLINE int resize(arrayobject *self, Py_ssize_t n) {
+    void *items = (void*) self->data.ob_item;
+    PyMem_Resize(items, char, (size_t)(n * self->ob_descr->itemsize));
+    if (items == NULL) {
+        PyErr_NoMemory();
+        return -1;
+    }
+    self->data.ob_item = (char*) items;
+    __Pyx_SET_SIZE(self, n);
+    self->allocated = n;
+    return 0;
+}
+
+// suitable for small increments; over allocation 50% ;
+static CYTHON_INLINE int resize_smart(arrayobject *self, Py_ssize_t n) {
+    void *items = (void*) self->data.ob_item;
+    Py_ssize_t newsize;
+    if (n < self->allocated && n*4 > self->allocated) {
+        __Pyx_SET_SIZE(self, n);
+        return 0;
+    }
+    newsize = n + (n / 2) + 1;
+    if (newsize <= n) {   /* overflow */
+        PyErr_NoMemory();
+        return -1;
+    }
+    PyMem_Resize(items, char, (size_t)(newsize * self->ob_descr->itemsize));
+    if (items == NULL) {
+        PyErr_NoMemory();
+        return -1;
+    }
+    self->data.ob_item = (char*) items;
+    __Pyx_SET_SIZE(self, n);
+    self->allocated = newsize;
+    return 0;
+}
+
+#endif
+/* _ARRAYARRAY_H */

tuning-competition-baseline/.venv/lib/python3.11/site-packages/networkx-3.2.1.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

tuning-competition-baseline/.venv/lib/python3.11/site-packages/networkx-3.2.1.dist-info/RECORD

@@ -0,0 +1,1137 @@
+networkx-3.2.1.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+networkx-3.2.1.dist-info/LICENSE.txt,sha256=ULWifLQ_eiDO3nqnuasgM1UuBBLJof3lHTiIXBQX6V8,1763
+networkx-3.2.1.dist-info/METADATA,sha256=tEByL1NhNlpdXiGfQDexQA_h5H6sFB1UMtQUJwDr3xQ,5232
+networkx-3.2.1.dist-info/RECORD,,
+networkx-3.2.1.dist-info/WHEEL,sha256=yQN5g4mg4AybRjkgi-9yy4iQEFibGQmlz78Pik5Or-A,92
+networkx-3.2.1.dist-info/entry_points.txt,sha256=b0FW-zm-m9itB-Zkm7w_8c9yX9WGGTg-r_N_A32PAGs,87
+networkx-3.2.1.dist-info/top_level.txt,sha256=s3Mk-7KOlu-kD39w8Xg_KXoP5Z_MVvgB-upkyuOE4Hk,9
+networkx/__init__.py,sha256=WwK4KM7w30c5F2xUgs4N0ylwaixla1rJ-4qThcPnjho,1091
+networkx/__pycache__/__init__.cpython-311.pyc,,
+networkx/__pycache__/conftest.cpython-311.pyc,,
+networkx/__pycache__/convert.cpython-311.pyc,,
+networkx/__pycache__/convert_matrix.cpython-311.pyc,,
+networkx/__pycache__/exception.cpython-311.pyc,,
+networkx/__pycache__/lazy_imports.cpython-311.pyc,,
+networkx/__pycache__/relabel.cpython-311.pyc,,
+networkx/algorithms/__init__.py,sha256=Rz_AEhB6u0naGx7ejzbvXrMXixWM47ydmjnGOuofzqo,6512
+networkx/algorithms/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/__pycache__/asteroidal.cpython-311.pyc,,
+networkx/algorithms/__pycache__/boundary.cpython-311.pyc,,
+networkx/algorithms/__pycache__/bridges.cpython-311.pyc,,
+networkx/algorithms/__pycache__/chains.cpython-311.pyc,,
+networkx/algorithms/__pycache__/chordal.cpython-311.pyc,,
+networkx/algorithms/__pycache__/clique.cpython-311.pyc,,
+networkx/algorithms/__pycache__/cluster.cpython-311.pyc,,
+networkx/algorithms/__pycache__/communicability_alg.cpython-311.pyc,,
+networkx/algorithms/__pycache__/core.cpython-311.pyc,,
+networkx/algorithms/__pycache__/covering.cpython-311.pyc,,
+networkx/algorithms/__pycache__/cuts.cpython-311.pyc,,
+networkx/algorithms/__pycache__/cycles.cpython-311.pyc,,
+networkx/algorithms/__pycache__/d_separation.cpython-311.pyc,,
+networkx/algorithms/__pycache__/dag.cpython-311.pyc,,
+networkx/algorithms/__pycache__/distance_measures.cpython-311.pyc,,
+networkx/algorithms/__pycache__/distance_regular.cpython-311.pyc,,
+networkx/algorithms/__pycache__/dominance.cpython-311.pyc,,
+networkx/algorithms/__pycache__/dominating.cpython-311.pyc,,
+networkx/algorithms/__pycache__/efficiency_measures.cpython-311.pyc,,
+networkx/algorithms/__pycache__/euler.cpython-311.pyc,,
+networkx/algorithms/__pycache__/graph_hashing.cpython-311.pyc,,
+networkx/algorithms/__pycache__/graphical.cpython-311.pyc,,
+networkx/algorithms/__pycache__/hierarchy.cpython-311.pyc,,
+networkx/algorithms/__pycache__/hybrid.cpython-311.pyc,,
+networkx/algorithms/__pycache__/isolate.cpython-311.pyc,,
+networkx/algorithms/__pycache__/link_prediction.cpython-311.pyc,,
+networkx/algorithms/__pycache__/lowest_common_ancestors.cpython-311.pyc,,
+networkx/algorithms/__pycache__/matching.cpython-311.pyc,,
+networkx/algorithms/__pycache__/mis.cpython-311.pyc,,
+networkx/algorithms/__pycache__/moral.cpython-311.pyc,,
+networkx/algorithms/__pycache__/node_classification.cpython-311.pyc,,
+networkx/algorithms/__pycache__/non_randomness.cpython-311.pyc,,
+networkx/algorithms/__pycache__/planar_drawing.cpython-311.pyc,,
+networkx/algorithms/__pycache__/planarity.cpython-311.pyc,,
+networkx/algorithms/__pycache__/polynomials.cpython-311.pyc,,
+networkx/algorithms/__pycache__/reciprocity.cpython-311.pyc,,
+networkx/algorithms/__pycache__/regular.cpython-311.pyc,,
+networkx/algorithms/__pycache__/richclub.cpython-311.pyc,,
+networkx/algorithms/__pycache__/similarity.cpython-311.pyc,,
+networkx/algorithms/__pycache__/simple_paths.cpython-311.pyc,,
+networkx/algorithms/__pycache__/smallworld.cpython-311.pyc,,
+networkx/algorithms/__pycache__/smetric.cpython-311.pyc,,
+networkx/algorithms/__pycache__/sparsifiers.cpython-311.pyc,,
+networkx/algorithms/__pycache__/structuralholes.cpython-311.pyc,,
+networkx/algorithms/__pycache__/summarization.cpython-311.pyc,,
+networkx/algorithms/__pycache__/swap.cpython-311.pyc,,
+networkx/algorithms/__pycache__/threshold.cpython-311.pyc,,
+networkx/algorithms/__pycache__/time_dependent.cpython-311.pyc,,
+networkx/algorithms/__pycache__/tournament.cpython-311.pyc,,
+networkx/algorithms/__pycache__/triads.cpython-311.pyc,,
+networkx/algorithms/__pycache__/vitality.cpython-311.pyc,,
+networkx/algorithms/__pycache__/voronoi.cpython-311.pyc,,
+networkx/algorithms/__pycache__/walks.cpython-311.pyc,,
+networkx/algorithms/__pycache__/wiener.cpython-311.pyc,,
+networkx/algorithms/approximation/__init__.py,sha256=zf9NM64g-aZwEGqI5C0DpU5FML2GrkaaQsO6SW85atE,1177
+networkx/algorithms/approximation/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/approximation/__pycache__/clique.cpython-311.pyc,,
+networkx/algorithms/approximation/__pycache__/clustering_coefficient.cpython-311.pyc,,
+networkx/algorithms/approximation/__pycache__/connectivity.cpython-311.pyc,,
+networkx/algorithms/approximation/__pycache__/distance_measures.cpython-311.pyc,,
+networkx/algorithms/approximation/__pycache__/dominating_set.cpython-311.pyc,,
+networkx/algorithms/approximation/__pycache__/kcomponents.cpython-311.pyc,,
+networkx/algorithms/approximation/__pycache__/matching.cpython-311.pyc,,
+networkx/algorithms/approximation/__pycache__/maxcut.cpython-311.pyc,,
+networkx/algorithms/approximation/__pycache__/ramsey.cpython-311.pyc,,
+networkx/algorithms/approximation/__pycache__/steinertree.cpython-311.pyc,,
+networkx/algorithms/approximation/__pycache__/traveling_salesman.cpython-311.pyc,,
+networkx/algorithms/approximation/__pycache__/treewidth.cpython-311.pyc,,
+networkx/algorithms/approximation/__pycache__/vertex_cover.cpython-311.pyc,,
+networkx/algorithms/approximation/clique.py,sha256=y4AeIvmGpMmM0kKRaFQKEORyUVmwakM_Vqz0Mdgnd94,7674
+networkx/algorithms/approximation/clustering_coefficient.py,sha256=jbWKI0fd79_vH4lHkzPXU1cyD8mb9MDej3v9OKQnv5s,2084
+networkx/algorithms/approximation/connectivity.py,sha256=PbGbwOk3dE4phai74vxz7pj1lK3q_gbYrNtMltu2MDw,13107
+networkx/algorithms/approximation/distance_measures.py,sha256=9MUKk23jP7klSgN718h7ttVM_xKPE4dMkxop7BvjkcU,5593
+networkx/algorithms/approximation/dominating_set.py,sha256=oGr5hRltwqd3JltGX-LIC7Sq7LGjltfdUGmBXWdAR7s,4214
+networkx/algorithms/approximation/kcomponents.py,sha256=AN9co8R7Lmgx5N_CbSrSmkQhfFbfbsJtwrUxSDBd284,13282
+networkx/algorithms/approximation/matching.py,sha256=1xfEMDlvcV8J78kgUhbC9FkaTnwC6mjYtNesGTYgmVg,1170
+networkx/algorithms/approximation/maxcut.py,sha256=rWHElMJvy5g4Yy_Tk11tlFFwQ16AV07K6rW1bIwWHTU,3664
+networkx/algorithms/approximation/ramsey.py,sha256=xOZDmJqCm-ya7utQhQOmVM_5LO-O_1e5UDw-YIWr9rY,1353
+networkx/algorithms/approximation/steinertree.py,sha256=tE-4_f1fPpR_hvCudJlzNzkYq_5kyT4OxxJBbfErWJ8,7487
+networkx/algorithms/approximation/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/approximation/tests/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_approx_clust_coeff.cpython-311.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_clique.cpython-311.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_connectivity.cpython-311.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_distance_measures.cpython-311.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_dominating_set.cpython-311.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_kcomponents.cpython-311.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_matching.cpython-311.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_maxcut.cpython-311.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_ramsey.cpython-311.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_steinertree.cpython-311.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_traveling_salesman.cpython-311.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_treewidth.cpython-311.pyc,,
+networkx/algorithms/approximation/tests/__pycache__/test_vertex_cover.cpython-311.pyc,,
+networkx/algorithms/approximation/tests/test_approx_clust_coeff.py,sha256=PGOVEKf2BcJu1vvjZrgTlBBpwM8V6t7yCANjyS9nWF0,1171
+networkx/algorithms/approximation/tests/test_clique.py,sha256=JZ_ja03aVU7vnZ42Joy1ze0vjdcm_CnDhD96Z4W_Dcc,3022
+networkx/algorithms/approximation/tests/test_connectivity.py,sha256=gDG6tsgP3ux7Dgu0x7r0nso7_yknIxicV42Gq0It5pc,5952
+networkx/algorithms/approximation/tests/test_distance_measures.py,sha256=GSyupA_jqSc_pLPSMnZFNcBgZc8-KFWgt6Q7uFegTqg,2024
+networkx/algorithms/approximation/tests/test_dominating_set.py,sha256=l4pBDY7pK7Fxw-S4tOlNcxf-j2j5GpHPJ9f4TrMs1sI,2686
+networkx/algorithms/approximation/tests/test_kcomponents.py,sha256=tTljP1FHzXrUwi-oBz5AQcibRw1NgR4N5UE0a2OrOUA,9346
+networkx/algorithms/approximation/tests/test_matching.py,sha256=nitZncaM0605kaIu1NO6_5TFV2--nohUCO46XTD_lnM,186
+networkx/algorithms/approximation/tests/test_maxcut.py,sha256=HDFNx896WYi7do42P6C5tGTZsBpiqx7sUWm_2riE3nk,2426
+networkx/algorithms/approximation/tests/test_ramsey.py,sha256=h36Ol39csHbIoTDBxbxMgn4371iVUGZ3a2N6l7d56lI,1143
+networkx/algorithms/approximation/tests/test_steinertree.py,sha256=H6IKKl1kFeH96bJaI8CgSkXBJz34ceCft8DA7HNG-Mk,6901
+networkx/algorithms/approximation/tests/test_traveling_salesman.py,sha256=El7VoCuHfmb_DQxlQgo5k9L6lL6U4DBu70BgJ0REJyg,30697
+networkx/algorithms/approximation/tests/test_treewidth.py,sha256=MWFFcmjO0QxM8FS8iXSCtfGnk6eqG2kFyv1u2qnSeUo,9096
+networkx/algorithms/approximation/tests/test_vertex_cover.py,sha256=FobHNhG9CAMeB_AOEprUs-7XQdPoc1YvfmXhozDZ8pM,1942
+networkx/algorithms/approximation/traveling_salesman.py,sha256=FbysLItH41SzBjKIoByYqcvuqIboO8HwNYCO2DJjQ4g,54465
+networkx/algorithms/approximation/treewidth.py,sha256=MRGfLtAanCzDk1G6I6jTbC6MKn6lYreIe9XQdfRXGHE,8148
+networkx/algorithms/approximation/vertex_cover.py,sha256=s7s5v4TGqIlvgTAg2FVxRRUSA2BEp7szZg7FS_UpWAA,2798
+networkx/algorithms/assortativity/__init__.py,sha256=ov3HRRbeYB_6Qezvxp1OTl77GBpw-EWkWGUzgfT8G9c,294
+networkx/algorithms/assortativity/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/assortativity/__pycache__/connectivity.cpython-311.pyc,,
+networkx/algorithms/assortativity/__pycache__/correlation.cpython-311.pyc,,
+networkx/algorithms/assortativity/__pycache__/mixing.cpython-311.pyc,,
+networkx/algorithms/assortativity/__pycache__/neighbor_degree.cpython-311.pyc,,
+networkx/algorithms/assortativity/__pycache__/pairs.cpython-311.pyc,,
+networkx/algorithms/assortativity/connectivity.py,sha256=O1b3Iky0hlpdM6_QBmBNFfF4XeUsKDMj8fCid_bBRQE,4216
+networkx/algorithms/assortativity/correlation.py,sha256=6XUlbqlBgLyb8GDKsSvIrSgsL47Ti1jbLQoIdRVAj_k,8654
+networkx/algorithms/assortativity/mixing.py,sha256=adB-iqzA_lhjhnoOOZG9qK4ghRTZCjONYN9FePYqcj8,7551
+networkx/algorithms/assortativity/neighbor_degree.py,sha256=H1XQ9BenXxxHK_e6ZWtdIb3xYwYCrbtqEQ69Gasm7cA,5278
+networkx/algorithms/assortativity/pairs.py,sha256=qHALwEx_Q8N1B2ZszX8vs2BK2_0kc4lmbth4kMU6Nog,3393
+networkx/algorithms/assortativity/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/assortativity/tests/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/assortativity/tests/__pycache__/base_test.cpython-311.pyc,,
+networkx/algorithms/assortativity/tests/__pycache__/test_connectivity.cpython-311.pyc,,
+networkx/algorithms/assortativity/tests/__pycache__/test_correlation.cpython-311.pyc,,
+networkx/algorithms/assortativity/tests/__pycache__/test_mixing.cpython-311.pyc,,
+networkx/algorithms/assortativity/tests/__pycache__/test_neighbor_degree.cpython-311.pyc,,
+networkx/algorithms/assortativity/tests/__pycache__/test_pairs.cpython-311.pyc,,
+networkx/algorithms/assortativity/tests/base_test.py,sha256=MNeQMLA3oBUCM8TSyNbBQ_uW0nDc1GEZYdNdUwePAm4,2651
+networkx/algorithms/assortativity/tests/test_connectivity.py,sha256=Js841GQLYTLWvc6xZhnyqj-JtyrnS0ska1TFYntxyXA,4978
+networkx/algorithms/assortativity/tests/test_correlation.py,sha256=1_D9GjLDnlT8Uy28lUn2fS1AHp2XBwiMpIl2OhRNDXk,5069
+networkx/algorithms/assortativity/tests/test_mixing.py,sha256=u-LIccNn-TeIAM766UtzUJQlY7NAbxF4EsUoKINzmlo,6820
+networkx/algorithms/assortativity/tests/test_neighbor_degree.py,sha256=ODP2M8jCaFr_l3ODwpwaz20-KqU2IFaEfJRBK53mpE8,3968
+networkx/algorithms/assortativity/tests/test_pairs.py,sha256=t05qP_-gfkbiR6aTLtE1owYl9otBSsuJcRkuZsa63UQ,3008
+networkx/algorithms/asteroidal.py,sha256=ARFht3oQvn95xCaaBEhy42djMIx4BuqsNf8VVlwBCEI,5852
+networkx/algorithms/bipartite/__init__.py,sha256=NQtAEpZ0IkjGVwfUbOzD7eoPLwulb_iZfh7-aDnyPWo,3826
+networkx/algorithms/bipartite/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/bipartite/__pycache__/basic.cpython-311.pyc,,
+networkx/algorithms/bipartite/__pycache__/centrality.cpython-311.pyc,,
+networkx/algorithms/bipartite/__pycache__/cluster.cpython-311.pyc,,
+networkx/algorithms/bipartite/__pycache__/covering.cpython-311.pyc,,
+networkx/algorithms/bipartite/__pycache__/edgelist.cpython-311.pyc,,
+networkx/algorithms/bipartite/__pycache__/extendability.cpython-311.pyc,,
+networkx/algorithms/bipartite/__pycache__/generators.cpython-311.pyc,,
+networkx/algorithms/bipartite/__pycache__/matching.cpython-311.pyc,,
+networkx/algorithms/bipartite/__pycache__/matrix.cpython-311.pyc,,
+networkx/algorithms/bipartite/__pycache__/projection.cpython-311.pyc,,
+networkx/algorithms/bipartite/__pycache__/redundancy.cpython-311.pyc,,
+networkx/algorithms/bipartite/__pycache__/spectral.cpython-311.pyc,,
+networkx/algorithms/bipartite/basic.py,sha256=iqgNX-FUDwK2owu1APFTu6ldlw6QE2PaOuNiWEgHafQ,8350
+networkx/algorithms/bipartite/centrality.py,sha256=vkjnOLv5CQtfTOFpa2YhFZWRnMBFUCetGn1w7akAvq8,9144
+networkx/algorithms/bipartite/cluster.py,sha256=S9h8lu-usXFcXEJf6qUxZinf0LneqvKnEiUi9YKp7bo,6925
+networkx/algorithms/bipartite/covering.py,sha256=8pQEStjAGygcu83Cz88RfNAifUV7x8pC84LE2wWapsY,2160
+networkx/algorithms/bipartite/edgelist.py,sha256=aa5sHvwCLe0Lk7BK58tR5vMNjpnlfSaNSs6UY6G5vbc,11317
+networkx/algorithms/bipartite/extendability.py,sha256=CvF0zI__9899cMkq40vu_FfEcU-OeyCB4C2bHtMxxgE,3973
+networkx/algorithms/bipartite/generators.py,sha256=Hj-kPfih-bd74gHrZFpyeWtrMQbKS1uQyYiBqv5RxKQ,20231
+networkx/algorithms/bipartite/matching.py,sha256=kXgpv14FuL6k4KrKN68Z85dkKNgfBmxahTMn4N8aVoI,21620
+networkx/algorithms/bipartite/matrix.py,sha256=w9P7y4oS7vUFdv2dRQHAosuFDrH34YgMgUffQCSFRDE,6127
+networkx/algorithms/bipartite/projection.py,sha256=L9mkbufsE885rGhJ9t-7p-TqowBtUmrL8Zm95LeBygQ,17165
+networkx/algorithms/bipartite/redundancy.py,sha256=T2kDtj1xpSudwelE_ZnWFHnIXneZAMaXvv1m7pVF3Io,3397
+networkx/algorithms/bipartite/spectral.py,sha256=xxkLlaSByMJUP4Kz-XfuRhzTse_DqqsOtGzfiKIgdXc,1880
+networkx/algorithms/bipartite/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/bipartite/tests/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/bipartite/tests/__pycache__/test_basic.cpython-311.pyc,,
+networkx/algorithms/bipartite/tests/__pycache__/test_centrality.cpython-311.pyc,,
+networkx/algorithms/bipartite/tests/__pycache__/test_cluster.cpython-311.pyc,,
+networkx/algorithms/bipartite/tests/__pycache__/test_covering.cpython-311.pyc,,
+networkx/algorithms/bipartite/tests/__pycache__/test_edgelist.cpython-311.pyc,,
+networkx/algorithms/bipartite/tests/__pycache__/test_extendability.cpython-311.pyc,,
+networkx/algorithms/bipartite/tests/__pycache__/test_generators.cpython-311.pyc,,
+networkx/algorithms/bipartite/tests/__pycache__/test_matching.cpython-311.pyc,,
+networkx/algorithms/bipartite/tests/__pycache__/test_matrix.cpython-311.pyc,,
+networkx/algorithms/bipartite/tests/__pycache__/test_project.cpython-311.pyc,,
+networkx/algorithms/bipartite/tests/__pycache__/test_redundancy.cpython-311.pyc,,
+networkx/algorithms/bipartite/tests/__pycache__/test_spectral_bipartivity.cpython-311.pyc,,
+networkx/algorithms/bipartite/tests/test_basic.py,sha256=gzbtsQqPi85BznX5REdGBBJVyr9aH4nO06c3eEI4634,4291
+networkx/algorithms/bipartite/tests/test_centrality.py,sha256=PABPbrIyoAziEEQKXsZLl2jT36N8DZpNRzEO-jeu89Y,6362
+networkx/algorithms/bipartite/tests/test_cluster.py,sha256=O0VsPVt8vcY_E1FjjLJX2xaUbhVViI5MP6_gLTbEpos,2801
+networkx/algorithms/bipartite/tests/test_covering.py,sha256=EGVxYQsyLXE5yY5N5u6D4wZq2NcZe9OwlYpEuY6DF3o,1221
+networkx/algorithms/bipartite/tests/test_edgelist.py,sha256=UE7vm3iZshnlzIrcupso48en0kncxGUPU7XTQskgowg,7996
+networkx/algorithms/bipartite/tests/test_extendability.py,sha256=MsiRLfldka3Cz_h21BwPxnEOuKChntuI6mVCnIFnSs0,6780
+networkx/algorithms/bipartite/tests/test_generators.py,sha256=GLMThTKIfZ96NwTxIL0P0o0OAESZFfnySRkRjtKhao8,12794
+networkx/algorithms/bipartite/tests/test_matching.py,sha256=wFw095skCjW5YvQAnIie8mLacECVt0yUoeJFSj8ONAk,11972
+networkx/algorithms/bipartite/tests/test_matrix.py,sha256=EoqQKTMcPPPPUZYTzc-AAtl5F77qT0X3FI3E1tYppxM,2900
+networkx/algorithms/bipartite/tests/test_project.py,sha256=FBjkys3JYYzEG4aq_CsQrtm41edZibWI_uDAQ0b4wqM,15134
+networkx/algorithms/bipartite/tests/test_redundancy.py,sha256=ddjUzOQ0gkiWBLtVwVFYTJydaIdW3qAc4BCVscxj7-Q,919
+networkx/algorithms/bipartite/tests/test_spectral_bipartivity.py,sha256=1jGDgrIx3-TWOCNMSC4zxmZa7LHyMU69DXh3h12Bjag,2358
+networkx/algorithms/boundary.py,sha256=GNuNDL280F7RXMzgkhUqFx-Zcg1LtP_Q0bNCYbMWIYU,5330
+networkx/algorithms/bridges.py,sha256=MuH_zEBqeSuyou8wszhnEzjJrUZSN-PpNtaScqUmR6E,6075
+networkx/algorithms/centrality/__init__.py,sha256=Er3YoYoj76UfY4P6I0L-0fCQkO7mMU0b3NLsTT2RGWI,558
+networkx/algorithms/centrality/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/centrality/__pycache__/betweenness.cpython-311.pyc,,
+networkx/algorithms/centrality/__pycache__/betweenness_subset.cpython-311.pyc,,
+networkx/algorithms/centrality/__pycache__/closeness.cpython-311.pyc,,
+networkx/algorithms/centrality/__pycache__/current_flow_betweenness.cpython-311.pyc,,
+networkx/algorithms/centrality/__pycache__/current_flow_betweenness_subset.cpython-311.pyc,,
+networkx/algorithms/centrality/__pycache__/current_flow_closeness.cpython-311.pyc,,
+networkx/algorithms/centrality/__pycache__/degree_alg.cpython-311.pyc,,
+networkx/algorithms/centrality/__pycache__/dispersion.cpython-311.pyc,,
+networkx/algorithms/centrality/__pycache__/eigenvector.cpython-311.pyc,,
+networkx/algorithms/centrality/__pycache__/flow_matrix.cpython-311.pyc,,
+networkx/algorithms/centrality/__pycache__/group.cpython-311.pyc,,
+networkx/algorithms/centrality/__pycache__/harmonic.cpython-311.pyc,,
+networkx/algorithms/centrality/__pycache__/katz.cpython-311.pyc,,
+networkx/algorithms/centrality/__pycache__/laplacian.cpython-311.pyc,,
+networkx/algorithms/centrality/__pycache__/load.cpython-311.pyc,,
+networkx/algorithms/centrality/__pycache__/percolation.cpython-311.pyc,,
+networkx/algorithms/centrality/__pycache__/reaching.cpython-311.pyc,,
+networkx/algorithms/centrality/__pycache__/second_order.cpython-311.pyc,,
+networkx/algorithms/centrality/__pycache__/subgraph_alg.cpython-311.pyc,,
+networkx/algorithms/centrality/__pycache__/trophic.cpython-311.pyc,,
+networkx/algorithms/centrality/__pycache__/voterank_alg.cpython-311.pyc,,
+networkx/algorithms/centrality/betweenness.py,sha256=Uy9LCiUxzx1Jvgi7SgV-4AEG1BfvDy2ypWg6Xzfd0_8,14374
+networkx/algorithms/centrality/betweenness_subset.py,sha256=SW7uh0SyGhD_99gwAIGOHrJ9rlO3jXw7xHi-tOHmspE,9327
+networkx/algorithms/centrality/closeness.py,sha256=97qc3gCkitgyLh66sYcdpSRnl7cdUrDgRBP49jDlNNw,10252
+networkx/algorithms/centrality/current_flow_betweenness.py,sha256=eDoDGCVR1PIL5hIY07xRJ6Ze74S4v1HUGJGZ9DbfQW8,11871
+networkx/algorithms/centrality/current_flow_betweenness_subset.py,sha256=QAxgfH20BkeoGgjKPVHVRDrJ6kkGQ1MNmZIVV5baWaM,8046
+networkx/algorithms/centrality/current_flow_closeness.py,sha256=jId4MzTctT0NIJOrzTPsd_gomLSMAg_1SXuXGDZja18,3351
+networkx/algorithms/centrality/degree_alg.py,sha256=xwK263egt-sy-BBxVqL9CE7uF22UhJQls8NlVu3QfZU,3881
+networkx/algorithms/centrality/dispersion.py,sha256=Eld3WK97coVbsHjAJ3ewYI1vsJ0c4Nm3Yrznbec5G8c,3627
+networkx/algorithms/centrality/eigenvector.py,sha256=o0qmWOiMf18Hofdw0ACaAO3TASeJC89R1meCr3ILJi0,12738
+networkx/algorithms/centrality/flow_matrix.py,sha256=G7o6qTnkOlhUZ-DowDu5Xb0vQAiulXcP_veiuYpaPdU,3829
+networkx/algorithms/centrality/group.py,sha256=XBfaGSIgVc-an4Ecqvokd1smETuQ_lUTAtOduKA8YDg,27866
+networkx/algorithms/centrality/harmonic.py,sha256=0eFa5Kv-7Ff_TFuygH753cnQjDqeImkPgrKohtXhGFE,2626
+networkx/algorithms/centrality/katz.py,sha256=K3KVHs3RMGjywLa5tvwEk4xqoBedgytEXINcSjHzy4s,10941
+networkx/algorithms/centrality/laplacian.py,sha256=BHdSIiFBjqZGijThqYQHS3J2-KHnd8DdzQDwAXJwyt0,5403
+networkx/algorithms/centrality/load.py,sha256=6lFI7KqDsVit1QF1UXqrx5G_frELnG8UKOmqtETC5bs,6850
+networkx/algorithms/centrality/percolation.py,sha256=PcWtbDaXvTLeqr1PCbnIHjoD8XcfQTp1meff7FHU1As,4415
+networkx/algorithms/centrality/reaching.py,sha256=nMKAOEbpHajkGKIYxGYEhO70fI2KXeReVsJgaRplN0E,7017
+networkx/algorithms/centrality/second_order.py,sha256=hFk_RFwYpIRlh_iGPO-ZSNzp6Anb73jod_fLYTMvfYk,4966
+networkx/algorithms/centrality/subgraph_alg.py,sha256=BIxHyH7E3I1Ri2dDnnFPy9IOc65ouwk8Y_jc5JMEGRM,9472
+networkx/algorithms/centrality/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/centrality/tests/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_betweenness_centrality.cpython-311.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_betweenness_centrality_subset.cpython-311.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_closeness_centrality.cpython-311.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_current_flow_betweenness_centrality.cpython-311.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_current_flow_betweenness_centrality_subset.cpython-311.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_current_flow_closeness.cpython-311.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_degree_centrality.cpython-311.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_dispersion.cpython-311.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_eigenvector_centrality.cpython-311.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_group.cpython-311.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_harmonic_centrality.cpython-311.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_katz_centrality.cpython-311.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_laplacian_centrality.cpython-311.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_load_centrality.cpython-311.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_percolation_centrality.cpython-311.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_reaching.cpython-311.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_second_order_centrality.cpython-311.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_subgraph.cpython-311.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_trophic.cpython-311.pyc,,
+networkx/algorithms/centrality/tests/__pycache__/test_voterank.cpython-311.pyc,,
+networkx/algorithms/centrality/tests/test_betweenness_centrality.py,sha256=pKoPAP1hnQSgrOxYeW5-LdUiFDANiwTn_NdOdgccbo8,26795
+networkx/algorithms/centrality/tests/test_betweenness_centrality_subset.py,sha256=HrHMcgOL69Z6y679SbqZIjkQOnqrYSz24gt17AJ9q-o,12554
+networkx/algorithms/centrality/tests/test_closeness_centrality.py,sha256=XWZivyLjxYlF41U4ktUmvULC2PMvxKs2U6BHDXRZVdE,10209
+networkx/algorithms/centrality/tests/test_current_flow_betweenness_centrality.py,sha256=VOxx1A7iSGtdEbzJYea_sW_Hv0S71-oo1CVX7Rqd5RY,7870
+networkx/algorithms/centrality/tests/test_current_flow_betweenness_centrality_subset.py,sha256=JfRGgPuiF-vJu5fc2_pcJYREEboxcK_dmy-np39c4Aw,5839
+networkx/algorithms/centrality/tests/test_current_flow_closeness.py,sha256=vflQeoNKngrGUiRb3XNlm2X9wR4vKgMSW_sCyMUCQi8,1379
+networkx/algorithms/centrality/tests/test_degree_centrality.py,sha256=TxD7UBtezF4RCdbCAuTsSB5lcFOQZrGnLOuCMa0XWY0,4105
+networkx/algorithms/centrality/tests/test_dispersion.py,sha256=ROgl_5bGhcNXonNW3ylsvUcA0NCwynsQu_scic371Gw,1959
+networkx/algorithms/centrality/tests/test_eigenvector_centrality.py,sha256=MsHKkQX7oip4v0kF28K1RjtKqxSNVykiSjg8wT20YyE,4897
+networkx/algorithms/centrality/tests/test_group.py,sha256=YmWifoTgw2gSS5BnA9G2T_Voauk_WG6v90JrZEt-Kjk,8686
+networkx/algorithms/centrality/tests/test_harmonic_centrality.py,sha256=wYP0msmB5hh5OMIxPl9t0G4QSpG3Brxw98Kh9BrRoag,3658
+networkx/algorithms/centrality/tests/test_katz_centrality.py,sha256=JL0bZZsJe2MQFL6urXgY82wCAwucUvhjaShYZPxpL6U,11240
+networkx/algorithms/centrality/tests/test_laplacian_centrality.py,sha256=vY-NULtr_U_GxUMwfAZB-iccxIRTiqqUN4Q8HRNpzSo,5916
+networkx/algorithms/centrality/tests/test_load_centrality.py,sha256=Vv3zSW89iELN-8KNbUclmkhOe1LzKdF7U_w34nYovIo,11343
+networkx/algorithms/centrality/tests/test_percolation_centrality.py,sha256=ycQ1fvEZZcWAfqL11urT7yHiEP77usJDSG25OQiDM2s,2591
+networkx/algorithms/centrality/tests/test_reaching.py,sha256=sqQUPspoiWxs9tD77UwngBkMVFYjRzhayVxPqX9_XbY,4143
+networkx/algorithms/centrality/tests/test_second_order_centrality.py,sha256=ce0wQ4T33lu23wskzGUnBS7X4BSODlvAX1S5KxlLzOA,1999
+networkx/algorithms/centrality/tests/test_subgraph.py,sha256=vhE9Uh-_Hlk49k-ny6ORHCgqk7LWH8OHIYOEYM96uz0,3729
+networkx/algorithms/centrality/tests/test_trophic.py,sha256=AzV6rwcTa4b4tcenoKh95o6VF-z7w75l81ZOdhhi6yE,8705
+networkx/algorithms/centrality/tests/test_voterank.py,sha256=7Z9aQYKqEw_txBbWTz1FZWJzUmhjlMfDFSRIKHBdkOk,1692
+networkx/algorithms/centrality/trophic.py,sha256=ay_R2GtxxfP5muSoxSETt6wdqYka14J1f1Z9zafY790,4654
+networkx/algorithms/centrality/voterank_alg.py,sha256=UG71jAEm4b0vqj6ZQ-so8yqQtdxDoK8XI5CWTdjAyhg,3227
+networkx/algorithms/chains.py,sha256=wUNxO0v_nH9m5efeV0IXzog_5EbBl0PkVzgDJoCAJts,6964
+networkx/algorithms/chordal.py,sha256=H5fdhTaX5UzKWVj4mQQd7cjj_oj84R91rUGRiuug_Gk,13285
+networkx/algorithms/clique.py,sha256=gM-ksRAEX1eDr_Irk85uuUGVKRpFIYijeOo385mVsxs,25802
+networkx/algorithms/cluster.py,sha256=qkwVMieIgXyK2u01cYD9xrZtgpDAODmH3aggvUxxPVc,20281
+networkx/algorithms/coloring/__init__.py,sha256=P1cmqrAjcaCdObkNZ1e6Hp__ZpxBAhQx0iIipOVW8jg,182
+networkx/algorithms/coloring/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/coloring/__pycache__/equitable_coloring.cpython-311.pyc,,
+networkx/algorithms/coloring/__pycache__/greedy_coloring.cpython-311.pyc,,
+networkx/algorithms/coloring/equitable_coloring.py,sha256=JnL_TM3sTewENSKkbHIOOfNoaqXYkoEjzmfgf3xD9C8,16279
+networkx/algorithms/coloring/greedy_coloring.py,sha256=Tuo215orZ6k7znMd9wkyv3irZNAl1dyEryi72mC_im4,20170
+networkx/algorithms/coloring/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/coloring/tests/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/coloring/tests/__pycache__/test_coloring.cpython-311.pyc,,
+networkx/algorithms/coloring/tests/test_coloring.py,sha256=A2cAG--i7pTVolIK96mxNuCTtLvhbLVRqJ4MAfWUBEQ,23712
+networkx/algorithms/communicability_alg.py,sha256=8omQmig1RyfVYfB_bfX40AX3Vg4PD4D-cmjelQzzKFc,4536
+networkx/algorithms/community/__init__.py,sha256=gKUySRds_lxaCw0kEpPJ1vluQwN4cV3ayt4U_8fok_M,1125
+networkx/algorithms/community/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/community/__pycache__/asyn_fluid.cpython-311.pyc,,
+networkx/algorithms/community/__pycache__/centrality.cpython-311.pyc,,
+networkx/algorithms/community/__pycache__/community_utils.cpython-311.pyc,,
+networkx/algorithms/community/__pycache__/kclique.cpython-311.pyc,,
+networkx/algorithms/community/__pycache__/kernighan_lin.cpython-311.pyc,,
+networkx/algorithms/community/__pycache__/label_propagation.cpython-311.pyc,,
+networkx/algorithms/community/__pycache__/louvain.cpython-311.pyc,,
+networkx/algorithms/community/__pycache__/lukes.cpython-311.pyc,,
+networkx/algorithms/community/__pycache__/modularity_max.cpython-311.pyc,,
+networkx/algorithms/community/__pycache__/quality.cpython-311.pyc,,
+networkx/algorithms/community/asyn_fluid.py,sha256=Qn8tNzdrXA1DVVHuZi-YjvBsUSbj3J6WwekrSVXBs74,5912
+networkx/algorithms/community/centrality.py,sha256=AEuGeTP_vWSyWr4vC3r-63cTfQ7mV2vDTqv_vZUkoxQ,6631
+networkx/algorithms/community/community_utils.py,sha256=u4q9DSo_QyROG7Qci2-Cvphu4n_VM8AeYXYKkXQXxws,903
+networkx/algorithms/community/kclique.py,sha256=tG0GOot8kY-wnaGA0XdNo0VKKoa1hJprMqXszcA00Pc,2456
+networkx/algorithms/community/kernighan_lin.py,sha256=-pQEXeOBE6JnHqMo-5M6igzGcBNbeOWK8AQ51joeN-E,4345
+networkx/algorithms/community/label_propagation.py,sha256=pcGwq8qhZQPK7LSrmsL54lf0ljC4PzBQaE2s_vvsWmU,11846
+networkx/algorithms/community/louvain.py,sha256=smccDNEHuRC3aqBJJ7ijKTQQ8vy1c-zcSuPaeqoQqDw,14764
+networkx/algorithms/community/lukes.py,sha256=OxwTxVKYNEd4evk4htBNDw_IeNujUIvPuydAfT-ewZk,8086
+networkx/algorithms/community/modularity_max.py,sha256=mcQxD2iQduY8H2-Ep3Agg7BSb-UTUqzOEcHm-424sC8,18020
+networkx/algorithms/community/quality.py,sha256=G7ogU-CYh-78EWGUyPKKR55K0iFrZclHawzy9gvBW-4,11919
+networkx/algorithms/community/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/community/tests/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/community/tests/__pycache__/test_asyn_fluid.cpython-311.pyc,,
+networkx/algorithms/community/tests/__pycache__/test_centrality.cpython-311.pyc,,
+networkx/algorithms/community/tests/__pycache__/test_kclique.cpython-311.pyc,,
+networkx/algorithms/community/tests/__pycache__/test_kernighan_lin.cpython-311.pyc,,
+networkx/algorithms/community/tests/__pycache__/test_label_propagation.cpython-311.pyc,,
+networkx/algorithms/community/tests/__pycache__/test_louvain.cpython-311.pyc,,
+networkx/algorithms/community/tests/__pycache__/test_lukes.cpython-311.pyc,,
+networkx/algorithms/community/tests/__pycache__/test_modularity_max.cpython-311.pyc,,
+networkx/algorithms/community/tests/__pycache__/test_quality.cpython-311.pyc,,
+networkx/algorithms/community/tests/__pycache__/test_utils.cpython-311.pyc,,
+networkx/algorithms/community/tests/test_asyn_fluid.py,sha256=5DDArgCUSRVXrlG21R5Yu6Gg96xsivqvEib17VGOZLM,3057
+networkx/algorithms/community/tests/test_centrality.py,sha256=ADU1mFn7yl9kTtQjOkfPtjpmkBR_i_6hwbVkWh5qZmw,2931
+networkx/algorithms/community/tests/test_kclique.py,sha256=iA0SBqwbDfaD2u7KM6ccs6LfgAQY_xxrnW05UIT_tFA,2413
+networkx/algorithms/community/tests/test_kernighan_lin.py,sha256=s8bK53Y1a87zvlZ1AJE-QJ2vItnbscSOlHQSrMpetGI,2709
+networkx/algorithms/community/tests/test_label_propagation.py,sha256=uOyx9-rLQCNidVwJ5EcjAlAOubjkK6HooZff5CCYki4,7870
+networkx/algorithms/community/tests/test_louvain.py,sha256=m8TQDH3fX2ygvWVn-mtP3EEmi1F7JF-J_WYuSAxvGXs,7257
+networkx/algorithms/community/tests/test_lukes.py,sha256=f_JU-EzY6PwXEkPN8kk5_3NVg6phlX0nrj1f57M49lk,3961
+networkx/algorithms/community/tests/test_modularity_max.py,sha256=mqtalSff4cmpAPyOExOolfICOE7YuOtHA3BqT84eZlg,10365
+networkx/algorithms/community/tests/test_quality.py,sha256=_kbOlYD1mpPduNQU1wJx58we6Z8CbmQ8wsDwOqTE4hg,5274
+networkx/algorithms/community/tests/test_utils.py,sha256=r_YEdGUaGZo8B16FxzocmkgpRrWgqyN7ehvx_qFiYu4,706
+networkx/algorithms/components/__init__.py,sha256=Dt74KZWp_cJ_j0lL5hd_S50_hia5DKcC2SjuRnubr6M,173
+networkx/algorithms/components/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/components/__pycache__/attracting.cpython-311.pyc,,
+networkx/algorithms/components/__pycache__/biconnected.cpython-311.pyc,,
+networkx/algorithms/components/__pycache__/connected.cpython-311.pyc,,
+networkx/algorithms/components/__pycache__/semiconnected.cpython-311.pyc,,
+networkx/algorithms/components/__pycache__/strongly_connected.cpython-311.pyc,,
+networkx/algorithms/components/__pycache__/weakly_connected.cpython-311.pyc,,
+networkx/algorithms/components/attracting.py,sha256=DYv4WYi7o65w2gszDcNVPlxPYDESDA_r0Z4gDzfpEDA,2699
+networkx/algorithms/components/biconnected.py,sha256=6GRTNyPgwvboDpUdjA9GODDa9vtxTNELEirHkcDHuXs,12765
+networkx/algorithms/components/connected.py,sha256=CiwwhpZo_ppuSCm63cMkm64IJybY_OAOxewWCaGUU7s,4312
+networkx/algorithms/components/semiconnected.py,sha256=M_bCya75ayQONDqv4HCfV8fAXPITAQbP7pdOl7mt8BQ,2025
+networkx/algorithms/components/strongly_connected.py,sha256=EoxDU6BDAp11v57vQvsiQGmZ_1C9iszd4ZDutN4KWAc,11712
+networkx/algorithms/components/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/components/tests/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/components/tests/__pycache__/test_attracting.cpython-311.pyc,,
+networkx/algorithms/components/tests/__pycache__/test_biconnected.cpython-311.pyc,,
+networkx/algorithms/components/tests/__pycache__/test_connected.cpython-311.pyc,,
+networkx/algorithms/components/tests/__pycache__/test_semiconnected.cpython-311.pyc,,
+networkx/algorithms/components/tests/__pycache__/test_strongly_connected.cpython-311.pyc,,
+networkx/algorithms/components/tests/__pycache__/test_weakly_connected.cpython-311.pyc,,
+networkx/algorithms/components/tests/test_attracting.py,sha256=b3N3ZR9E5gLSQWGgaqhcRfRs4KBW6GnnkVYeAjdxC_o,2243
+networkx/algorithms/components/tests/test_biconnected.py,sha256=N-J-dgBgI77ytYUUrXjduLxtDydH7jS-af98fyPBkYc,6036
+networkx/algorithms/components/tests/test_connected.py,sha256=BTbxVcorGH8wKVXOO7D3bn0WR8lXK-Kijm-XDmQhiMY,3983
+networkx/algorithms/components/tests/test_semiconnected.py,sha256=q860lIxZF5M2JmDwwdzy-SGSXnrillOefMx23GcJpw0,1792
+networkx/algorithms/components/tests/test_strongly_connected.py,sha256=66c4bPIdcl1hKEZAY5Wjpglk_mrcVCoDxaKBOaZz754,6639
+networkx/algorithms/components/tests/test_weakly_connected.py,sha256=yi23wxW2Vw6JOMqaWMEuqNRxnleriuAQrZ5JGWE48Jk,2887
+networkx/algorithms/components/weakly_connected.py,sha256=mDxdyU7oGqWTYWY0Rh_VRbR5hcMFhy6yXFb_W20LkxU,4366
+networkx/algorithms/connectivity/__init__.py,sha256=VuUXTkagxX-tHjgmeYJ3K4Eq_luK6kSpv1nZwiwGFd8,281
+networkx/algorithms/connectivity/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/connectivity/__pycache__/connectivity.cpython-311.pyc,,
+networkx/algorithms/connectivity/__pycache__/cuts.cpython-311.pyc,,
+networkx/algorithms/connectivity/__pycache__/disjoint_paths.cpython-311.pyc,,
+networkx/algorithms/connectivity/__pycache__/edge_augmentation.cpython-311.pyc,,
+networkx/algorithms/connectivity/__pycache__/edge_kcomponents.cpython-311.pyc,,
+networkx/algorithms/connectivity/__pycache__/kcomponents.cpython-311.pyc,,
+networkx/algorithms/connectivity/__pycache__/kcutsets.cpython-311.pyc,,
+networkx/algorithms/connectivity/__pycache__/stoerwagner.cpython-311.pyc,,
+networkx/algorithms/connectivity/__pycache__/utils.cpython-311.pyc,,
+networkx/algorithms/connectivity/connectivity.py,sha256=X5tB-FevO5B-514-zb3LoaSOHlcBX0ockB5fBdh2E58,29912
+networkx/algorithms/connectivity/cuts.py,sha256=vCr5z2lvAa4cYIAhmnL-cYr7jVRL5a0TbbrV3Qb_xtQ,23183
+networkx/algorithms/connectivity/disjoint_paths.py,sha256=rQ1qZepPW4j0RnzMefaFtFbd4hsnjZ6tpiUSQwEpDxE,14852
+networkx/algorithms/connectivity/edge_augmentation.py,sha256=IJmZg75CiEmpIE0tQyFzbd6ZKFKGH--hBs7yuYMLzAA,43988
+networkx/algorithms/connectivity/edge_kcomponents.py,sha256=8jQ-ba3qxdCRK8dFDTAAcqG55-vOfJ_smRXeQAIw6FU,20709
+networkx/algorithms/connectivity/kcomponents.py,sha256=Ax0v4yudKFbkuzmek2TUEh3UPFIPoy6gJ7N4ZtUiO-A,8166
+networkx/algorithms/connectivity/kcutsets.py,sha256=rtSXzS7uIaNewh7RT_-lukXvr48_Cdl56VKalb8bQ50,9423
+networkx/algorithms/connectivity/stoerwagner.py,sha256=RW_Zx4wsdikYH8UB34zLDVLBBfpPQ4UBSOh_oYwhkMI,5375
+networkx/algorithms/connectivity/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/connectivity/tests/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/connectivity/tests/__pycache__/test_connectivity.cpython-311.pyc,,
+networkx/algorithms/connectivity/tests/__pycache__/test_cuts.cpython-311.pyc,,
+networkx/algorithms/connectivity/tests/__pycache__/test_disjoint_paths.cpython-311.pyc,,
+networkx/algorithms/connectivity/tests/__pycache__/test_edge_augmentation.cpython-311.pyc,,
+networkx/algorithms/connectivity/tests/__pycache__/test_edge_kcomponents.cpython-311.pyc,,
+networkx/algorithms/connectivity/tests/__pycache__/test_kcomponents.cpython-311.pyc,,
+networkx/algorithms/connectivity/tests/__pycache__/test_kcutsets.cpython-311.pyc,,
+networkx/algorithms/connectivity/tests/__pycache__/test_stoer_wagner.cpython-311.pyc,,
+networkx/algorithms/connectivity/tests/test_connectivity.py,sha256=eSmsi8uQk6MI591JgtSu2elIusb08bmSZS0h9gxb76I,15027
+networkx/algorithms/connectivity/tests/test_cuts.py,sha256=4F8seWb-sPDDjjVMkh14gst5UQa5f-zDkCsZIdJjVzo,10353
+networkx/algorithms/connectivity/tests/test_disjoint_paths.py,sha256=NLHReLoXSKoA6KPBNRbjF84ktg5PEaaktIj2AII3SDY,8392
+networkx/algorithms/connectivity/tests/test_edge_augmentation.py,sha256=d3ymFHyY2G4cpy1Y6wu4ze339qfF2LRp2HmGAIVjnMM,15731
+networkx/algorithms/connectivity/tests/test_edge_kcomponents.py,sha256=CZ26Dy91WOUqhw1X73mqLGX-WHWzBBIeBCgrp6KK4Zo,16453
+networkx/algorithms/connectivity/tests/test_kcomponents.py,sha256=ohoSX8GACeszRZdzTiNuWXSFitfU9DzP0hqllS2gvMU,8554
+networkx/algorithms/connectivity/tests/test_kcutsets.py,sha256=TU6vl9cVtl7GstL2OrPGwVX2PY1R_AGQ6lJ9QQX5UBQ,8458
+networkx/algorithms/connectivity/tests/test_stoer_wagner.py,sha256=A291C30_t2CI1erPCqN1W0DoAj3zqNA8fThPIj4Rku0,3011
+networkx/algorithms/connectivity/utils.py,sha256=8h29TgBEeaZbF_4OFNgtY2XLqURD_va_wezmz709Qfs,3168
+networkx/algorithms/core.py,sha256=mNKH8fwCgbCbaQAcIdZq8Dx9p_bsHiyQn4fAXOdR5K4,15990
+networkx/algorithms/covering.py,sha256=4SiBc9eJi4vQ0N5juRfw6atcyjH1xB_iSWwT6WOZhYk,5290
+networkx/algorithms/cuts.py,sha256=VSEhUHwqRFhfS70L-PzsUGEzN09uhC69B-5hwSixj7A,9960
+networkx/algorithms/cycles.py,sha256=eHduXG1NbfMOIT-RNDWHMyDeRiWC-3IAOokh0kyIDhs,43080
+networkx/algorithms/d_separation.py,sha256=2l6sRqNEldQQltIlVo7lK6ew115PYLT0OJcCjeQBnJY,15440
+networkx/algorithms/dag.py,sha256=1LkfG8kYN-dAjXk21Tmo7eCr9FaYpp4kMX37JCktlY4,39144
+networkx/algorithms/distance_measures.py,sha256=pMMLUutcc93wdbTfKkltEic7dcj5st95eEPpuxtHiNc,29136
+networkx/algorithms/distance_regular.py,sha256=KksQ9jiqigD5DzD63DXmxoeV8RAj1TF7hjyi9FLjbws,6914
+networkx/algorithms/dominance.py,sha256=wO5FnplVOSkPBdFSBcPQMgt-0bykxaEtXmdqRjGg3d8,3422
+networkx/algorithms/dominating.py,sha256=lA9lP6SXtjZsUPyKM58Uflgp58aSqfveTeoe9aQuy7Y,2675
+networkx/algorithms/efficiency_measures.py,sha256=OGkRnD5lrXUqr4TAPW9f_y2g89k9V_-L1EkvWy9Yibo,4786
+networkx/algorithms/euler.py,sha256=hf2HPmE6GkRm6DhG0-DD4wIJmvnAXy__ddXx2BGqsBU,14160
+networkx/algorithms/flow/__init__.py,sha256=rVtMUy6dViPLewjDRntmn15QF0bQwiDdQbZZx9j7Drc,341
+networkx/algorithms/flow/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/flow/__pycache__/boykovkolmogorov.cpython-311.pyc,,
+networkx/algorithms/flow/__pycache__/capacityscaling.cpython-311.pyc,,
+networkx/algorithms/flow/__pycache__/dinitz_alg.cpython-311.pyc,,
+networkx/algorithms/flow/__pycache__/edmondskarp.cpython-311.pyc,,
+networkx/algorithms/flow/__pycache__/gomory_hu.cpython-311.pyc,,
+networkx/algorithms/flow/__pycache__/maxflow.cpython-311.pyc,,
+networkx/algorithms/flow/__pycache__/mincost.cpython-311.pyc,,
+networkx/algorithms/flow/__pycache__/networksimplex.cpython-311.pyc,,
+networkx/algorithms/flow/__pycache__/preflowpush.cpython-311.pyc,,
+networkx/algorithms/flow/__pycache__/shortestaugmentingpath.cpython-311.pyc,,
+networkx/algorithms/flow/__pycache__/utils.cpython-311.pyc,,
+networkx/algorithms/flow/boykovkolmogorov.py,sha256=gJFnK5qZMg8xMWs2-aGx5-LLM25C48x2IPy-_50V6_c,13435
+networkx/algorithms/flow/capacityscaling.py,sha256=G4wdqfhQ4Gf7Fx3Eoh5_DUnpzD_qOT-8yWfaZ1dbbWA,14459
+networkx/algorithms/flow/dinitz_alg.py,sha256=mtSov40Oay_kz2v381MkOp5OSpDhKiH2OSINkrImsE0,7310
+networkx/algorithms/flow/edmondskarp.py,sha256=iafmZIMPO8euDc7uJQ1dg84s4a9OzK4tKMthF2jQoeo,8292
+networkx/algorithms/flow/gomory_hu.py,sha256=5fEaPaTi9_ox7CarltPwqSEGnF3OyxJJfWf04g-Aa50,6320
+networkx/algorithms/flow/maxflow.py,sha256=xyVgIMRtxRSUHZb-4txwc78ZEIFixzCQffG5NxioR98,22809
+networkx/algorithms/flow/mincost.py,sha256=JA6lLUmQ-UyxrdWdzbS3x8oK3t4MaPPBf_44Pgor9yA,12248
+networkx/algorithms/flow/networksimplex.py,sha256=eimOUJ4n2-jRBN8LgPoeuFrU38O2JRCB1O0uEkG7wkg,25175
+networkx/algorithms/flow/preflowpush.py,sha256=wIl2b0MpnhunZb4HpShxMVy1NgPggsAGF7chP0crKKw,15823
+networkx/algorithms/flow/shortestaugmentingpath.py,sha256=7vfa73BxJ6cHfzTy6ibXoD8DuOjK2lgp-EshUeimvZA,10474
+networkx/algorithms/flow/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/flow/tests/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/flow/tests/__pycache__/test_gomory_hu.cpython-311.pyc,,
+networkx/algorithms/flow/tests/__pycache__/test_maxflow.cpython-311.pyc,,
+networkx/algorithms/flow/tests/__pycache__/test_maxflow_large_graph.cpython-311.pyc,,
+networkx/algorithms/flow/tests/__pycache__/test_mincost.cpython-311.pyc,,
+networkx/algorithms/flow/tests/__pycache__/test_networksimplex.cpython-311.pyc,,
+networkx/algorithms/flow/tests/gl1.gpickle.bz2,sha256=z4-BzrXqruFiGqYLiS2D5ZamFz9vZRc1m2ef89qhsPg,44623
+networkx/algorithms/flow/tests/gw1.gpickle.bz2,sha256=b3nw6Q-kxR7HkWXxWWPh7YlHdXbga8qmeuYiwmBBGTE,42248
+networkx/algorithms/flow/tests/netgen-2.gpickle.bz2,sha256=OxfmbN7ajtuNHexyYmx38fZd1GdeP3bcL8T9hKoDjjA,18972
+networkx/algorithms/flow/tests/test_gomory_hu.py,sha256=aWtbI3AHofIK6LDJnmj9UH1QOfulXsi5NyB7bNyV2Vw,4471
+networkx/algorithms/flow/tests/test_maxflow.py,sha256=YRgkrdRj6NMHOXio2Zgr7-ErEzCbq7Z0w90azNffCC4,18727
+networkx/algorithms/flow/tests/test_maxflow_large_graph.py,sha256=fMweTQ3MzsZWYI-ul2dGR8OfGQeo8df2fLeCleHqxZw,4623
+networkx/algorithms/flow/tests/test_mincost.py,sha256=n4fFLDwDLy7Tau-_ey1CoxZwKhFjk28GLGJjCyxhClk,17816
+networkx/algorithms/flow/tests/test_networksimplex.py,sha256=bsVxlvHAD0K7aDevCcVaa9uRNNsWAevw6yUKlj2T8No,12103
+networkx/algorithms/flow/tests/wlm3.gpickle.bz2,sha256=zKy6Hg-_swvsNh8OSOyIyZnTR0_Npd35O9RErOF8-g4,88132
+networkx/algorithms/flow/utils.py,sha256=TyckjUeH5qcBUSARpkuZDXaVirYGuo9xvJK8cno0T38,6001
+networkx/algorithms/graph_hashing.py,sha256=cOAW2XlFvuYokbmhEeKiX4KQgIHL6PjraBqsZizcj_A,11887
+networkx/algorithms/graphical.py,sha256=BYh1nXb2Kg1AYLJBz926QIKcHkAtXqInpsb7QSzykAQ,15807
+networkx/algorithms/hierarchy.py,sha256=jDj8Ld7InknG7OVLVSnT82cqzNvBQ4FT5Qso107kQVQ,1541
+networkx/algorithms/hybrid.py,sha256=fFfA7Ki4zKxm9r8VEvreUqyCvGeCygsBbJZPsvXUQ7A,6180
+networkx/algorithms/isolate.py,sha256=toiuRPi4qb06D_hREZWbAcDJ4c8yx8aKftWez22Efj0,2325
+networkx/algorithms/isomorphism/__init__.py,sha256=gPRQ-_X6xN2lJZPQNw86IVj4NemGmbQYTejf5yJ32N4,406
+networkx/algorithms/isomorphism/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/isomorphism/__pycache__/ismags.cpython-311.pyc,,
+networkx/algorithms/isomorphism/__pycache__/isomorph.cpython-311.pyc,,
+networkx/algorithms/isomorphism/__pycache__/isomorphvf2.cpython-311.pyc,,
+networkx/algorithms/isomorphism/__pycache__/matchhelpers.cpython-311.pyc,,
+networkx/algorithms/isomorphism/__pycache__/temporalisomorphvf2.cpython-311.pyc,,
+networkx/algorithms/isomorphism/__pycache__/tree_isomorphism.cpython-311.pyc,,
+networkx/algorithms/isomorphism/__pycache__/vf2pp.cpython-311.pyc,,
+networkx/algorithms/isomorphism/__pycache__/vf2userfunc.cpython-311.pyc,,
+networkx/algorithms/isomorphism/ismags.py,sha256=5KRimh6jxs7BIDqAo48d01i8_1WkkckV0xVWkQ64czs,43529
+networkx/algorithms/isomorphism/isomorph.py,sha256=PQONDdw4Mc6neaPhW7yVQxoxOrbOqYorgBse4OjYtBA,7097
+networkx/algorithms/isomorphism/isomorphvf2.py,sha256=1LWpe54aulfYukTS87DoS4l1reCpOqZEr-74MOQLrRc,40528
+networkx/algorithms/isomorphism/matchhelpers.py,sha256=b7A7SwbqXj8CKAw-vrISgBNhDcEXobPjljkOhyWn4aM,10891
+networkx/algorithms/isomorphism/temporalisomorphvf2.py,sha256=-1NW81l8kM9orQ2ni9tcNizQzEhOUE9BaBJXjUWqhiI,10948
+networkx/algorithms/isomorphism/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/isomorphism/tests/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/isomorphism/tests/__pycache__/test_ismags.cpython-311.pyc,,
+networkx/algorithms/isomorphism/tests/__pycache__/test_isomorphism.cpython-311.pyc,,
+networkx/algorithms/isomorphism/tests/__pycache__/test_isomorphvf2.cpython-311.pyc,,
+networkx/algorithms/isomorphism/tests/__pycache__/test_match_helpers.cpython-311.pyc,,
+networkx/algorithms/isomorphism/tests/__pycache__/test_temporalisomorphvf2.cpython-311.pyc,,
+networkx/algorithms/isomorphism/tests/__pycache__/test_tree_isomorphism.cpython-311.pyc,,
+networkx/algorithms/isomorphism/tests/__pycache__/test_vf2pp.cpython-311.pyc,,
+networkx/algorithms/isomorphism/tests/__pycache__/test_vf2pp_helpers.cpython-311.pyc,,
+networkx/algorithms/isomorphism/tests/__pycache__/test_vf2userfunc.cpython-311.pyc,,
+networkx/algorithms/isomorphism/tests/iso_r01_s80.A99,sha256=hKzMtYLUR8Oqp9pmJR6RwG7qo31aNPZcnXy4KHDGhqU,1442
+networkx/algorithms/isomorphism/tests/iso_r01_s80.B99,sha256=AHx_W2xG4JEcz1xKoN5TwCHVE6-UO2PiMByynkd4TPE,1442
+networkx/algorithms/isomorphism/tests/si2_b06_m200.A99,sha256=NVnPFA52amNl3qM55G1V9eL9ZlP9NwugBlPf-zekTFU,310
+networkx/algorithms/isomorphism/tests/si2_b06_m200.B99,sha256=-clIDp05LFNRHA2BghhGTeyuXDqBBqA9XpEzpB7Ku7M,1602
+networkx/algorithms/isomorphism/tests/test_ismags.py,sha256=2sOkbB7Aejnq4zDx9BhJyfavf5DLiKJaUPusb3fhGRk,10585
+networkx/algorithms/isomorphism/tests/test_isomorphism.py,sha256=1GZmmqNWk605Qq9h55V_5SfEKPM50Ceq6DSICdh6ufs,1663
+networkx/algorithms/isomorphism/tests/test_isomorphvf2.py,sha256=s4yO4cHJk5qIpRemnSzD1MJEeSJPNpZcOU6LeWVhGXI,11751
+networkx/algorithms/isomorphism/tests/test_match_helpers.py,sha256=uuTcvjgf2LPqSQzzECPIh0dezw8-a1IN0u42u8TxwAw,2483
+networkx/algorithms/isomorphism/tests/test_temporalisomorphvf2.py,sha256=DZy2zAt74jiTAM-jGK5H9aGRn1ZsMgQl9K5UNsu178Y,7346
+networkx/algorithms/isomorphism/tests/test_tree_isomorphism.py,sha256=yj3C8ZBhi57I6kxetfneGpTse9hrYBvJQfGb0qks_G0,7066
+networkx/algorithms/isomorphism/tests/test_vf2pp.py,sha256=65RkN1mPWLoxirE7SlIvfaKMJk80b_ZwWG6HTJtlkPg,49924
+networkx/algorithms/isomorphism/tests/test_vf2pp_helpers.py,sha256=s4zz4IYYm2q8nHmkG0eRI2yJjcTx6zjRL7HTVIl1a-s,90080
+networkx/algorithms/isomorphism/tests/test_vf2userfunc.py,sha256=yby-vt4sYxc1uzlnD-iETREbojgNkpQGbLkrPER_Sss,6629
+networkx/algorithms/isomorphism/tree_isomorphism.py,sha256=HKPUDU1oCYCfEgyNYN0e31K9PqE3hsqHZMX8Iuq7i1Q,9397
+networkx/algorithms/isomorphism/vf2pp.py,sha256=oKBYHbwS0j3UihEI7LgaUZ7sMhv3nLLFrnCk3jETxnw,36383
+networkx/algorithms/isomorphism/vf2userfunc.py,sha256=VVTNWEzHnRaZrjtinBnkStRNsvC9FVvivXWs-pqG6LM,7475
+networkx/algorithms/link_analysis/__init__.py,sha256=UkcgTDdzsIu-jsJ4jBwP8sF2CsRPC1YcZZT-q5Wlj3I,118
+networkx/algorithms/link_analysis/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/link_analysis/__pycache__/hits_alg.cpython-311.pyc,,
+networkx/algorithms/link_analysis/__pycache__/pagerank_alg.cpython-311.pyc,,
+networkx/algorithms/link_analysis/hits_alg.py,sha256=5ntPDFZNGYbrw0Bq4WNvmoIWBxSa6PtIoBVHhHmv-8M,10244
+networkx/algorithms/link_analysis/pagerank_alg.py,sha256=0l7xABhW3Vkhx07y87NynTdYqcTql0UAVfCghURhZFk,17183
+networkx/algorithms/link_analysis/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/link_analysis/tests/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/link_analysis/tests/__pycache__/test_hits.cpython-311.pyc,,
+networkx/algorithms/link_analysis/tests/__pycache__/test_pagerank.cpython-311.pyc,,
+networkx/algorithms/link_analysis/tests/test_hits.py,sha256=BXMNyKv4OfRKXH9W8u8qCV3zaghDlEItRhYLN0TB-CM,2525
+networkx/algorithms/link_analysis/tests/test_pagerank.py,sha256=g0HyPn5HBXZeu-TQSWqqTzOfnzaejRfBuIIpKYSGecE,7530
+networkx/algorithms/link_prediction.py,sha256=z4abyN_TIEZiq6TN9YP7TYvrdiDhzgg-Irn9UW1IkYQ,19968
+networkx/algorithms/lowest_common_ancestors.py,sha256=popl_tFPaN5r4P1UQ47-qzEQ9EM0EQCeA7F_9th71Ek,9186
+networkx/algorithms/matching.py,sha256=ePjtahy-HIMke90HjmcgO1mJOUcG7WYJFfFKuAqQ8Jk,44530
+networkx/algorithms/minors/__init__.py,sha256=ceeKdsZ6U1H40ED-KmtVGkbADxeWMTVG07Ja8P7N_Pg,587
+networkx/algorithms/minors/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/minors/__pycache__/contraction.cpython-311.pyc,,
+networkx/algorithms/minors/contraction.py,sha256=dS3lUcojiGydTV2IOrpyD3UxChG5ZYqHy74c-Euulns,22735
+networkx/algorithms/minors/tests/__pycache__/test_contraction.cpython-311.pyc,,
+networkx/algorithms/minors/tests/test_contraction.py,sha256=rob7wHlt3xoXYxpcXQOwm7zP0TLyRqWV1JxsZlE8kfo,14212
+networkx/algorithms/mis.py,sha256=9ZdCuXXAlKOVHgWJMtillI1vLOXQGlRpSoz-rbnMU3I,2339
+networkx/algorithms/moral.py,sha256=k9uZGz0S6YK3U5hoiRLzR--PRQNktNdaI9-lrzsrgBg,1511
+networkx/algorithms/node_classification.py,sha256=ACq6C3i2p-f5E4UGHK8XQ6ng6ZVf6DxHdx4xR0x1zrA,6461
+networkx/algorithms/non_randomness.py,sha256=wEXsl0fat8w0SAROXT_mB0B4fidVD8N5Ue5rLDMcu7Q,2893
+networkx/algorithms/operators/__init__.py,sha256=dJ3xOXvHxSzzM3-YcfvjGTJ_ndxULF1TybkIRzUS87Y,201
+networkx/algorithms/operators/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/operators/__pycache__/all.cpython-311.pyc,,
+networkx/algorithms/operators/__pycache__/binary.cpython-311.pyc,,
+networkx/algorithms/operators/__pycache__/product.cpython-311.pyc,,
+networkx/algorithms/operators/__pycache__/unary.cpython-311.pyc,,
+networkx/algorithms/operators/all.py,sha256=_1em4J-Y6GQK0_UlkTIKZ7DNdTSzdXkZ748gAq9dxkg,9544
+networkx/algorithms/operators/binary.py,sha256=Un3NpZQxmGB3EhQY-_-qb-Kzr6lJy9RRVJZR0FOSrVI,12689
+networkx/algorithms/operators/product.py,sha256=3hm3Q1K3BaH6RYUTP369jGgFSVsyAF3crDS74PKlVDM,16115
+networkx/algorithms/operators/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/operators/tests/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/operators/tests/__pycache__/test_all.cpython-311.pyc,,
+networkx/algorithms/operators/tests/__pycache__/test_binary.cpython-311.pyc,,
+networkx/algorithms/operators/tests/__pycache__/test_product.cpython-311.pyc,,
+networkx/algorithms/operators/tests/__pycache__/test_unary.cpython-311.pyc,,
+networkx/algorithms/operators/tests/test_all.py,sha256=Pqjv9QiA0875Yl9D5o6c5Ml0t4KHpH2a5jbpAoZQXFc,8250
+networkx/algorithms/operators/tests/test_binary.py,sha256=N_HEuvjUPneQK44rYo8AMhR7OdfQk76U9EqIXCt65X4,12795
+networkx/algorithms/operators/tests/test_product.py,sha256=hbnfR6gKXhl2BiEHKrgi4hMYIie95noooNmVBws1iLo,13402
+networkx/algorithms/operators/tests/test_unary.py,sha256=UZdzbt5GI9hnflEizUWXihGqBWmSFJDkzjwVv6wziQE,1415
+networkx/algorithms/operators/unary.py,sha256=9cLxWpgt7aleGAgL608nW99s1gaw5kVGa-LybPt--qY,1745
+networkx/algorithms/planar_drawing.py,sha256=q9QJYn3PhDHzfNO1t5xAStN1XDzTPybFxtorb60KF5k,16289
+networkx/algorithms/planarity.py,sha256=j1SbhjE620Jda4PHALJh6PIwu_GHJKwACHnB6_q02aA,39476
+networkx/algorithms/polynomials.py,sha256=WNcCyqedQTPhhiwp9TJRqZXuo4KGTPjb85GF86XvDcU,11270
+networkx/algorithms/reciprocity.py,sha256=vKwcggMOSOz29-_j0R3do52qosaYFbfJJBXOkW-5jH8,2846
+networkx/algorithms/regular.py,sha256=0zEftUGLYqxeUEAV2cerg6bda98fQuqrDyKkNdkvvpo,6680
+networkx/algorithms/richclub.py,sha256=EP7v7VT6GhNAqFQ15I-WeDdksFISBArkS-guAPpdJoo,4166
+networkx/algorithms/shortest_paths/__init__.py,sha256=Rmxtsje-mPdQyeYhE8TP2NId-iZEOu4eAsWhVRm2Xqk,285
+networkx/algorithms/shortest_paths/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/shortest_paths/__pycache__/astar.cpython-311.pyc,,
+networkx/algorithms/shortest_paths/__pycache__/dense.cpython-311.pyc,,
+networkx/algorithms/shortest_paths/__pycache__/generic.cpython-311.pyc,,
+networkx/algorithms/shortest_paths/__pycache__/unweighted.cpython-311.pyc,,
+networkx/algorithms/shortest_paths/__pycache__/weighted.cpython-311.pyc,,
+networkx/algorithms/shortest_paths/astar.py,sha256=mb9Z0nmHJhTCuF_tAvS3oiNrpplCNQReunAwrLJcYME,7674
+networkx/algorithms/shortest_paths/dense.py,sha256=xBzv4NHJ-J2ehGnDEgjHJ6a3LidSKYBy2p36qBTdgfI,8151
+networkx/algorithms/shortest_paths/generic.py,sha256=uN1-eUXz6n9R0WWwCgpiynJTfyYyp5RYgCUeroeizWo,25321
+networkx/algorithms/shortest_paths/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/shortest_paths/tests/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/shortest_paths/tests/__pycache__/test_astar.cpython-311.pyc,,
+networkx/algorithms/shortest_paths/tests/__pycache__/test_dense.cpython-311.pyc,,
+networkx/algorithms/shortest_paths/tests/__pycache__/test_dense_numpy.cpython-311.pyc,,
+networkx/algorithms/shortest_paths/tests/__pycache__/test_generic.cpython-311.pyc,,
+networkx/algorithms/shortest_paths/tests/__pycache__/test_unweighted.cpython-311.pyc,,
+networkx/algorithms/shortest_paths/tests/__pycache__/test_weighted.cpython-311.pyc,,
+networkx/algorithms/shortest_paths/tests/test_astar.py,sha256=X9tLO2OVDrHjSy1-nNaNFIRngnOo-ITT5HAj6PAXafk,7176
+networkx/algorithms/shortest_paths/tests/test_dense.py,sha256=ievl4gu3Exl_31hp4OKcsAGPb3g3_xFUM4t3NnvrG_A,6747
+networkx/algorithms/shortest_paths/tests/test_dense_numpy.py,sha256=BNwXCe2wgNPE8o35-shPsFj8l19c_QG6Ye8tkIGphf8,2300
+networkx/algorithms/shortest_paths/tests/test_generic.py,sha256=aR3pUbMS-s3vBZJg7kauoY6rmZbjlx-DweCC1wyZQI4,18156
+networkx/algorithms/shortest_paths/tests/test_unweighted.py,sha256=fjpDkp38DmW8R2qpLRwRjcbYZp4an0f0yIq40XsFKJ8,5899
+networkx/algorithms/shortest_paths/tests/test_weighted.py,sha256=dmzFBYN3QEDZoun7RAtSe_spsGSbvkDiJSgUf9e-1K8,35038
+networkx/algorithms/shortest_paths/unweighted.py,sha256=EuiZiHEQEOrFZpmUMm52ThANjyfWeWhKYFIrnvu9G_s,15494
+networkx/algorithms/shortest_paths/weighted.py,sha256=esTy6BYmWqBcCGN15Ld3jJCfjTNZtw4pyphEK4g2NqQ,82339
+networkx/algorithms/similarity.py,sha256=Y5GRl1NW-IFVqwogOdHJs-SAHmpv1SgfN7MIF7y8odQ,59062
+networkx/algorithms/simple_paths.py,sha256=cliV45VPZSKngEAEI6jQX5o8JD9G7Yhe_kFnCCvZP1k,30535
+networkx/algorithms/smallworld.py,sha256=sD1yv28XfqfwSi0Y88GOKXPzVwMJlWpNf8S14ZLOw_k,13494
+networkx/algorithms/smetric.py,sha256=jHdRFK7HyeFkhQWkKApa1MpAyi512pY4Ksulkh8joo8,1933
+networkx/algorithms/sparsifiers.py,sha256=InQAPhcRTI5O_l9ckBc2LAheONfBVx1Wn6yYY0NVOiA,10073
+networkx/algorithms/structuralholes.py,sha256=58c8f6hBwxhp5-GL1JPWnR5dRLZU3gNziddeFVIeXSE,9319
+networkx/algorithms/summarization.py,sha256=ymt635-uEH_uocXwF0_tU8EbGlW_1wf3ZM-v0CG7dH4,23251
+networkx/algorithms/swap.py,sha256=uYRzbxhEONmGQlWWDsDw_SJQgIWJfXzvSKYQAd50HfE,14579
+networkx/algorithms/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/tests/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_asteroidal.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_boundary.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_bridges.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_chains.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_chordal.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_clique.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_cluster.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_communicability.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_core.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_covering.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_cuts.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_cycles.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_d_separation.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_dag.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_distance_measures.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_distance_regular.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_dominance.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_dominating.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_efficiency.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_euler.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_graph_hashing.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_graphical.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_hierarchy.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_hybrid.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_isolate.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_link_prediction.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_lowest_common_ancestors.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_matching.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_max_weight_clique.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_mis.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_moral.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_node_classification.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_non_randomness.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_planar_drawing.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_planarity.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_polynomials.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_reciprocity.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_regular.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_richclub.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_similarity.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_simple_paths.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_smallworld.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_smetric.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_sparsifiers.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_structuralholes.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_summarization.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_swap.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_threshold.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_time_dependent.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_tournament.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_triads.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_vitality.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_voronoi.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_walks.cpython-311.pyc,,
+networkx/algorithms/tests/__pycache__/test_wiener.cpython-311.pyc,,
+networkx/algorithms/tests/test_asteroidal.py,sha256=DnWI5_jnaaZMxtG44XD0K690HZs8ez7HU_9dSR-p6eA,502
+networkx/algorithms/tests/test_boundary.py,sha256=1OSJh32FYFhAVYB5zqxhZGEXZLS0HPp9kvfHZvWmD3o,6227
+networkx/algorithms/tests/test_bridges.py,sha256=FS34gA5cia8di_a2X4meeB7qI0JrsVtpQlL4fe_i1CA,4027
+networkx/algorithms/tests/test_chains.py,sha256=SofaAxDEJDf1gt5sIGVC_O8vT9YcTc8Jq1vfnwVPhkM,4363
+networkx/algorithms/tests/test_chordal.py,sha256=DPdNPY7KtqCsCwYVb4xQfnIm-z35dUJIWxNHtAiQLAQ,4438
+networkx/algorithms/tests/test_clique.py,sha256=FPIF2f8NLODsz-k_qrHt7DolClV_VdNWSh68oe8-ygI,9413
+networkx/algorithms/tests/test_cluster.py,sha256=AltwLWAblpSLa-24KvNuxYxM2IeVl5p2d-kozA9QJ-0,15595
+networkx/algorithms/tests/test_communicability.py,sha256=4KK9wU9gAUqHAAAyHwAKpq2dV9g415s_X0qd7Tt83gU,2938
+networkx/algorithms/tests/test_core.py,sha256=ZmLePvuK-Tv8aQ6tGCJd9965BHKUviNNVV7o3PzwfEE,7016
+networkx/algorithms/tests/test_covering.py,sha256=EeBjQ5mxcVctgavqXZ255T8ryFocuxjxdVpIxVUNFvw,2718
+networkx/algorithms/tests/test_cuts.py,sha256=2Ir5xyIG4cTC4Dgg1cceLXaEFiOCJ60ZTDDn33vz0Ns,5377
+networkx/algorithms/tests/test_cycles.py,sha256=mrID4F3wdoZV1oBPETd8Ebx9UXasC2dWsccx8bq_5C8,34243
+networkx/algorithms/tests/test_d_separation.py,sha256=md90cCjC409qAolNGTFwGTu5N577GdgK2RYW83lxopk,6600
+networkx/algorithms/tests/test_dag.py,sha256=MMSD9Flgl_h2fCDIr7gPr9MACj-cU6Xnn5qK1-LeCSc,27722
+networkx/algorithms/tests/test_distance_measures.py,sha256=LdVbsbebvMZghK2gOgecNGxs7v_WjO8z2okG9uF8rAY,22327
+networkx/algorithms/tests/test_distance_regular.py,sha256=pPZ2CPKo4QLjhxlcJhBQZif6-_2qwfh1kpbrN_mu5tg,2312
+networkx/algorithms/tests/test_dominance.py,sha256=nPqRGSF1GEvUR16ryo-dOql6fLdTvzBmYk8Y3ML-ONc,9373
+networkx/algorithms/tests/test_dominating.py,sha256=hyta7ln6BbHaGlpEUla6jVzh2PRuSjvujLSGXrmwZbc,1228
+networkx/algorithms/tests/test_efficiency.py,sha256=QKWMvyjCG1Byt-oNp7Rz_qxnVeT77Zk27lrzI1qH0mA,1894
+networkx/algorithms/tests/test_euler.py,sha256=4ajCsO3PwKBaz8jTB_b_nHh_yOz9qSPTOhNBloIRAF8,10987
+networkx/algorithms/tests/test_graph_hashing.py,sha256=duR9DQLUpRuy9bv0ZKQPt9gy9WxiX_K0-BVMlnF-WHY,23517
+networkx/algorithms/tests/test_graphical.py,sha256=uhFjvs04odxABToY4IRig_CaUTpAC3SfZRu1p1T7FwY,5366
+networkx/algorithms/tests/test_hierarchy.py,sha256=g3-0pNfzRo-RDW1BsiLXxyi2LwWIJukXx2i4JCpN2fg,941
+networkx/algorithms/tests/test_hybrid.py,sha256=kQLzaMoqZcKFaJ3D7PKbY2O-FX59XDZ1pN5un8My-tk,720
+networkx/algorithms/tests/test_isolate.py,sha256=LyR0YYHJDH5vppQzGzGiJK-aaIV17_Jmla8dMf93olg,555
+networkx/algorithms/tests/test_link_prediction.py,sha256=7c322xESYdH5WEA0TsMw4Jcc_-lqfIsj-SjXP6Y0TVc,19442
+networkx/algorithms/tests/test_lowest_common_ancestors.py,sha256=GvhYCQMnVYD9LHPCNFgWMAUmOV8V5gko0fe05zi1JwU,13153
+networkx/algorithms/tests/test_matching.py,sha256=jhehNkApE5RuMPtbjWNeHn0tPqhVz65mL7QakfRA3Vw,20174
+networkx/algorithms/tests/test_max_weight_clique.py,sha256=JWGZpbQfUaCklCGI170Gfpp3b5ICYwY7RH_DQ1mYQbc,6741
+networkx/algorithms/tests/test_mis.py,sha256=jusLniyKcNWs0994srLJxY3SVeAQqkkXf-h-qtlrfGw,1875
+networkx/algorithms/tests/test_moral.py,sha256=15PZgkx7O9aXQB1npQ2JNqBBkEqPPP2RfeZzKqY-GNU,452
+networkx/algorithms/tests/test_node_classification.py,sha256=NgJJKUHH1GoD1GE3F4QRYBLM3fUo_En3RNtZvhqCjlg,4663
+networkx/algorithms/tests/test_non_randomness.py,sha256=-8s-fJLYRxVNp7QpaMe5Dxrxi0kvewY78d4ja-nXNBk,782
+networkx/algorithms/tests/test_planar_drawing.py,sha256=CBJv6U9tT0BzYVrmEBlARBZSMxBwTsX3krACAnAPfHg,8771
+networkx/algorithms/tests/test_planarity.py,sha256=h9kUOsn0skbvYBcIYzKy5XDGmyP3sTwtvoXYKr_X230,13148
+networkx/algorithms/tests/test_polynomials.py,sha256=baI0Kua1pRngRC6Scm5gRRwi1bl0iET5_Xxo3AZTP3A,1983
+networkx/algorithms/tests/test_reciprocity.py,sha256=X_PXWFOTzuEcyMWpRdwEJfm8lJOfNE_1rb9AAybf4is,1296
+networkx/algorithms/tests/test_regular.py,sha256=zGf7Mmh7XPtwunOoeTfgiICnfsVeCEbMop3NrDgIfqY,2457
+networkx/algorithms/tests/test_richclub.py,sha256=hhRGQGNQ2EINvmTF-XkJxGZXROvQJZuWwubCYq8Mx9U,2585
+networkx/algorithms/tests/test_similarity.py,sha256=JJYVUV-WtjswW-kDbY5tUuyjLI_3mVKOLUbaRz8wCM8,32216
+networkx/algorithms/tests/test_simple_paths.py,sha256=mmuKfi8t9iXLO8tSIuQGbupFe9c6X6cSiGKEWYiWiqM,24075
+networkx/algorithms/tests/test_smallworld.py,sha256=rfgNCRU6YF55f8sCuA5WmX6MmhDci89Tb4jaz4ALjcQ,2405
+networkx/algorithms/tests/test_smetric.py,sha256=wihpgjZS4PaajOuE72RiDEbBWpQcoKPSAfjoAezuRxg,980
+networkx/algorithms/tests/test_sparsifiers.py,sha256=A12V4ljWxvXaSFJ73mHSFK2YNO-k8ax6Me4yEWTsI4s,4043
+networkx/algorithms/tests/test_structuralholes.py,sha256=-48vhIVXcUlmLAi603FdBP6afbVu447JZ1piSCIpRTE,5536
+networkx/algorithms/tests/test_summarization.py,sha256=cGAep6r-v141uAdsPF9r8YTuT-nO7L7puOqPPv339wo,21313
+networkx/algorithms/tests/test_swap.py,sha256=YRpN79MNL1i5Hm2FVb-mNl9SRfHDWAuDnn2Wx95_UYY,5307
+networkx/algorithms/tests/test_threshold.py,sha256=RF_SM5tdMGJfEHETO19mFicnt69UIlvVeuCwI7rxb0M,9751
+networkx/algorithms/tests/test_time_dependent.py,sha256=NmuV2kDo4nh2MeN0hwcJf0QSDtqMD0dfSeeKSsYBtQ8,13342
+networkx/algorithms/tests/test_tournament.py,sha256=xxmLb9Lrmjkh9tKmyv2yYJrhB2PHWh-Bq71M-d1NjQo,4158
+networkx/algorithms/tests/test_triads.py,sha256=tPMzSQDVHZQOmDOKa9Hyem76UO1zh7wcdaM9X_BhxG4,9088
+networkx/algorithms/tests/test_vitality.py,sha256=p5lPWCtVMtbvxDw6TJUaf8vpb0zKPoz5pND722xiypQ,1380
+networkx/algorithms/tests/test_voronoi.py,sha256=M4B6JtkJUw56ULEWRs1kyVEUsroNrnb5FBq9OioAyHM,3477
+networkx/algorithms/tests/test_walks.py,sha256=X8cb-YvGHiiqbMEXuKMSdTAb9WtVtbHjIESNSqpJTmU,1499
+networkx/algorithms/tests/test_wiener.py,sha256=NJJbXZ9L5ZeFGQpCpvYVWFNqyX3amkbuDQEBL7wCixw,2080
+networkx/algorithms/threshold.py,sha256=1GUMnQQvN_6mR5oowUbgoykaWPyV4zO1mO1Dyb9NdAE,31088
+networkx/algorithms/time_dependent.py,sha256=73WgWETl4IP4qsOrSDkIEIU7MJM3qc_j-LKRZUJlC4c,5757
+networkx/algorithms/tournament.py,sha256=nTgdIzkkFhIyie_5jDh97USz2jQx9TgY34vHOPVXkN0,11676
+networkx/algorithms/traversal/__init__.py,sha256=YtFrfNjciqTOI6jGePQaJ01tRSEQXTHqTGGNhDEDb_8,142
+networkx/algorithms/traversal/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/traversal/__pycache__/beamsearch.cpython-311.pyc,,
+networkx/algorithms/traversal/__pycache__/breadth_first_search.cpython-311.pyc,,
+networkx/algorithms/traversal/__pycache__/depth_first_search.cpython-311.pyc,,
+networkx/algorithms/traversal/__pycache__/edgebfs.cpython-311.pyc,,
+networkx/algorithms/traversal/__pycache__/edgedfs.cpython-311.pyc,,
+networkx/algorithms/traversal/beamsearch.py,sha256=ABR8pOl4G3CbUyaHpR9F93jh3J0XjVKZe7DK5LetVWc,3424
+networkx/algorithms/traversal/breadth_first_search.py,sha256=2sIfMwqc2qjGW2W3UcGwGBSCcc-_FWWa_ZRYQjhfro8,18107
+networkx/algorithms/traversal/depth_first_search.py,sha256=aJ-3wtaLVLslz5dJD7nW3biDdXsjJi_rAJB8QQTg_8w,13730
+networkx/algorithms/traversal/edgebfs.py,sha256=2eUhaoP2__-QSkDu1ie6wPd1WjuK3u8pU8rf87iAtKc,6239
+networkx/algorithms/traversal/edgedfs.py,sha256=NaZfoYV5jl8mmo5UhgdQqM2YJ_PjZ--VKYF5T9qa6Ms,5952
+networkx/algorithms/traversal/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/traversal/tests/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/traversal/tests/__pycache__/test_beamsearch.cpython-311.pyc,,
+networkx/algorithms/traversal/tests/__pycache__/test_bfs.cpython-311.pyc,,
+networkx/algorithms/traversal/tests/__pycache__/test_dfs.cpython-311.pyc,,
+networkx/algorithms/traversal/tests/__pycache__/test_edgebfs.cpython-311.pyc,,
+networkx/algorithms/traversal/tests/__pycache__/test_edgedfs.cpython-311.pyc,,
+networkx/algorithms/traversal/tests/test_beamsearch.py,sha256=b1fXCI0_BuWbnA536PZrXMMUfG1ejnHX1fpQGY-5hqI,1076
+networkx/algorithms/traversal/tests/test_bfs.py,sha256=fC6HUKzd5Jd9LerxgODpfvCRE15BU5PbMzEaMLoXPZs,6796
+networkx/algorithms/traversal/tests/test_dfs.py,sha256=4Gc1ACJQJ63rfOlPz0X0Tv6xW6k83ewMRVojBEnKMmk,8616
+networkx/algorithms/traversal/tests/test_edgebfs.py,sha256=8oplCu0fct3QipT0JB0-292EA2aOm8zWlMkPedfe6iY,4702
+networkx/algorithms/traversal/tests/test_edgedfs.py,sha256=HGmC3GUYSn9XLMHQpdefdE6g-Uh3KqbmgEEXBcckdYc,4775
+networkx/algorithms/tree/__init__.py,sha256=wm_FjX3G7hqJfyNmeEaJsRjZI-8Kkv0Nb5jAmQNXzSc,149
+networkx/algorithms/tree/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/tree/__pycache__/branchings.cpython-311.pyc,,
+networkx/algorithms/tree/__pycache__/coding.cpython-311.pyc,,
+networkx/algorithms/tree/__pycache__/decomposition.cpython-311.pyc,,
+networkx/algorithms/tree/__pycache__/mst.cpython-311.pyc,,
+networkx/algorithms/tree/__pycache__/operations.cpython-311.pyc,,
+networkx/algorithms/tree/__pycache__/recognition.cpython-311.pyc,,
+networkx/algorithms/tree/branchings.py,sha256=ZJmoLcn_rtQ9VKBwsFqdx1Rkh8edqjNGgYWBUezNpvE,56003
+networkx/algorithms/tree/coding.py,sha256=zB5ISLd1Jn-6wWfqrQaxYa2hbwchp59qzGKmCiuLVd8,13407
+networkx/algorithms/tree/decomposition.py,sha256=MFV3zHYOt8y7n3jNBxQCQvO60IFJ9rl5XIgvBqjT5RQ,3047
+networkx/algorithms/tree/mst.py,sha256=STCiAXhYmbt3x0yaqRQehwlp_GMJFoeU9vwdmzjFHNk,40276
+networkx/algorithms/tree/operations.py,sha256=46nnbX2qF_iyzeuzsIJXrlXiJOEQfo2KguFB4rP5Ttg,4702
+networkx/algorithms/tree/recognition.py,sha256=ZOdFP-cdG2Lv7jiX3M2nPi7g-e327wPN36_xbn4KiDs,7553
+networkx/algorithms/tree/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/algorithms/tree/tests/__pycache__/__init__.cpython-311.pyc,,
+networkx/algorithms/tree/tests/__pycache__/test_branchings.cpython-311.pyc,,
+networkx/algorithms/tree/tests/__pycache__/test_coding.cpython-311.pyc,,
+networkx/algorithms/tree/tests/__pycache__/test_decomposition.cpython-311.pyc,,
+networkx/algorithms/tree/tests/__pycache__/test_mst.cpython-311.pyc,,
+networkx/algorithms/tree/tests/__pycache__/test_operations.cpython-311.pyc,,
+networkx/algorithms/tree/tests/__pycache__/test_recognition.cpython-311.pyc,,
+networkx/algorithms/tree/tests/test_branchings.py,sha256=chEEI0evEkVVJSphcP_kIqhMEdv0nhBONYGP8ffW40s,18008
+networkx/algorithms/tree/tests/test_coding.py,sha256=f3A5dvfkWImC6Jp2qkuw2Sz3whOsabnaOfu6Eh9r65I,3954
+networkx/algorithms/tree/tests/test_decomposition.py,sha256=vnl_xoQzi1LnlZL25vXOZWwvaWmon3-x222OKt4eDqE,1871
+networkx/algorithms/tree/tests/test_mst.py,sha256=NgvEi2kwn18HN8ywvj1V20pZS98JIuo9vJOv31DqW2w,24749
+networkx/algorithms/tree/tests/test_operations.py,sha256=ybU96kROTVJRTyjLG7JSJjYlPxaWmYjUVJqbXV5VGGI,1961
+networkx/algorithms/tree/tests/test_recognition.py,sha256=hbS6q1lbshRClWH7o8Zj7Osd-TZuk_YOomUdTczHs3s,4171
+networkx/algorithms/triads.py,sha256=4EF74EolTV1PJheA-J371tP_pTJA7-aGLnq4D8pac2E,15517
+networkx/algorithms/vitality.py,sha256=yBXiKzewpz40SK0UzFpeZZDvOXXDSt_vh4jGLrNgnHg,2331
+networkx/algorithms/voronoi.py,sha256=zCiFFQiklBS5afAEfln44GfiPsoAI9c7E6m0gbQ2Big,3178
+networkx/algorithms/walks.py,sha256=3ulDmITV-YN8yBTr2qmVEDsSe-Gi8yzrnGyLP5dXQbQ,2419
+networkx/algorithms/wiener.py,sha256=o8tYpFn-W9sneu3QMhpMZlCkqptgRo2ZdUFKfVCOL1s,2328
+networkx/classes/__init__.py,sha256=Q9oONJrnTFs874SGpwcbV_kyJTDcrLI69GFt99MiE6I,364
+networkx/classes/__pycache__/__init__.cpython-311.pyc,,
+networkx/classes/__pycache__/coreviews.cpython-311.pyc,,
+networkx/classes/__pycache__/digraph.cpython-311.pyc,,
+networkx/classes/__pycache__/filters.cpython-311.pyc,,
+networkx/classes/__pycache__/function.cpython-311.pyc,,
+networkx/classes/__pycache__/graph.cpython-311.pyc,,
+networkx/classes/__pycache__/graphviews.cpython-311.pyc,,
+networkx/classes/__pycache__/multidigraph.cpython-311.pyc,,
+networkx/classes/__pycache__/multigraph.cpython-311.pyc,,
+networkx/classes/__pycache__/reportviews.cpython-311.pyc,,
+networkx/classes/coreviews.py,sha256=jkbsDaqebCcFH952hAAAuXw3qZpi7xUdCHyKbUrFsc8,11010
+networkx/classes/digraph.py,sha256=CnnSfxWTjOkabNkSNhBfE2bgwgSG32ylDD3scWxaPP0,47159
+networkx/classes/filters.py,sha256=47OFApfkvvohVMoZ2v9sniM6sgv9rka869BDwmbdww4,1715
+networkx/classes/function.py,sha256=55dS0xS5p7oiyeJQ03mGcSo7NwJLbfZ54_kIhVOx-q0,36323
+networkx/classes/graph.py,sha256=DigVc4mmBx9v1ctgqhDYu8GZwT2wa4iyci85otpYZ6Q,70379
+networkx/classes/graphviews.py,sha256=7rSoE4Pkh8SjjsP2G6t0U0SRAwnkUp5QLSgnJPZgPUQ,8558
+networkx/classes/multidigraph.py,sha256=_5yJvVz99QMkp92iS2qONcahEBhsmS3C7bfaKrNNKoA,36283
+networkx/classes/multigraph.py,sha256=5X1_tB0LJgfif8f1HckiL1MTm9tPDJ4YTRe_H22WFbA,47127
+networkx/classes/reportviews.py,sha256=WQU6LBq2tXIohU6bDJALKeefFaeGMW46Ln8sUJoJ-yM,45606
+networkx/classes/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/classes/tests/__pycache__/__init__.cpython-311.pyc,,
+networkx/classes/tests/__pycache__/dispatch_interface.cpython-311.pyc,,
+networkx/classes/tests/__pycache__/historical_tests.cpython-311.pyc,,
+networkx/classes/tests/__pycache__/test_backends.cpython-311.pyc,,
+networkx/classes/tests/__pycache__/test_coreviews.cpython-311.pyc,,
+networkx/classes/tests/__pycache__/test_digraph.cpython-311.pyc,,
+networkx/classes/tests/__pycache__/test_digraph_historical.cpython-311.pyc,,
+networkx/classes/tests/__pycache__/test_filters.cpython-311.pyc,,
+networkx/classes/tests/__pycache__/test_function.cpython-311.pyc,,
+networkx/classes/tests/__pycache__/test_graph.cpython-311.pyc,,
+networkx/classes/tests/__pycache__/test_graph_historical.cpython-311.pyc,,
+networkx/classes/tests/__pycache__/test_graphviews.cpython-311.pyc,,
+networkx/classes/tests/__pycache__/test_multidigraph.cpython-311.pyc,,
+networkx/classes/tests/__pycache__/test_multigraph.cpython-311.pyc,,
+networkx/classes/tests/__pycache__/test_reportviews.cpython-311.pyc,,
+networkx/classes/tests/__pycache__/test_special.cpython-311.pyc,,
+networkx/classes/tests/__pycache__/test_subgraphviews.cpython-311.pyc,,
+networkx/classes/tests/dispatch_interface.py,sha256=bOQdru35uGmAMKHNZEok-UBAeiuA0rF20JZEeo4ePT4,6683
+networkx/classes/tests/historical_tests.py,sha256=3lbZKaRvv8uodIEzSbBJDguTPpO2MhqBqh-Pk1soZBM,16173
+networkx/classes/tests/test_backends.py,sha256=IR8qFYv4cJX0y1q48lRV0zJEouj1sfSOmcwcm4FBxEg,2579
+networkx/classes/tests/test_coreviews.py,sha256=qzdozzWK8vLag-CAUqrXAM2CZZwMFN5vMu6Tdrwdf-E,12128
+networkx/classes/tests/test_digraph.py,sha256=uw0FuEu3y_YI-PSGuQCRytFpXLF7Eye2fqLJaKbXkBc,12283
+networkx/classes/tests/test_digraph_historical.py,sha256=s9FpuIP81zIbGCiMfiDqB3OxqWU2p3GwWdhpGIOjD5Y,3683
+networkx/classes/tests/test_filters.py,sha256=fBLig8z548gsBBlQw6VJdGZb4IcqJj7_0mi2Fd2ncEM,5851
+networkx/classes/tests/test_function.py,sha256=e5vg_SjtC8nHrMDemCcEVTHcudcSiWToMsZF655eQi4,25770
+networkx/classes/tests/test_graph.py,sha256=77t7pk1Pmz-txewyD2Dv19Vva6vWpWCtJSPtFx-EY_Y,30913
+networkx/classes/tests/test_graph_historical.py,sha256=-jf961vQCuQLyly0ju50q9dbzWG5m2OAs9H6IVS670c,273
+networkx/classes/tests/test_graphviews.py,sha256=i4x3ii8--PPg_pK4YA8aMR1axUQCdXZYpzmB05iEAOg,11466
+networkx/classes/tests/test_multidigraph.py,sha256=ryTKegCoYixXbAqOn3mIt9vSMb5666Dv-pfMkXEjoUE,16342
+networkx/classes/tests/test_multigraph.py,sha256=0vFQO3RCJaBpzXvnQzdWa_qYLHNo_I9DICYhPZJNUMk,18777
+networkx/classes/tests/test_reportviews.py,sha256=-4Vd42cOvTdZfsPiWuQuAAvVDafosjB47RosYglmXUw,41470
+networkx/classes/tests/test_special.py,sha256=IJsmqCS9LrTDoZ11KPmo-UOI7xEskL7NyduEJNPMNqs,4103
+networkx/classes/tests/test_subgraphviews.py,sha256=1dcJHq3F00LyoFSu6CTFPqS7DFIkWK1PyQu4QvJh5ko,13223
+networkx/conftest.py,sha256=v1f_RONRmJwf__rPjF4l-uFl2cyyF08mtst8WTnHXr4,7944
+networkx/convert.py,sha256=0EbsMbOgm8pdKpW4A6p5Ea4T_KGEcq-P1a0gCnM-jzY,15977
+networkx/convert_matrix.py,sha256=cnI56RdwsBke_XOz6dAbfgj_qVIwU2JeirRqMN9tM2w,41069
+networkx/drawing/__init__.py,sha256=rnTFNzLc4fis1hTAEpnWTC80neAR88-llVQ-LObN-i4,160
+networkx/drawing/__pycache__/__init__.cpython-311.pyc,,
+networkx/drawing/__pycache__/layout.cpython-311.pyc,,
+networkx/drawing/__pycache__/nx_agraph.cpython-311.pyc,,
+networkx/drawing/__pycache__/nx_latex.cpython-311.pyc,,
+networkx/drawing/__pycache__/nx_pydot.cpython-311.pyc,,
+networkx/drawing/__pycache__/nx_pylab.cpython-311.pyc,,
+networkx/drawing/layout.py,sha256=fvfHjubEdZZoRexknTKF2j0zO_Xj2N1nhzfuNTKY5BQ,38829
+networkx/drawing/nx_agraph.py,sha256=9Q6bz0oT7u-iU2hDIjhjvQ3jmxWsyAHA5fMIr4BmhEE,14009
+networkx/drawing/nx_latex.py,sha256=EZWQ1GJ9SWS7ufyAz8ey30gG1EtnCUVMgbLJ4-tIjgY,24805
+networkx/drawing/nx_pydot.py,sha256=vS_lJC9ASmBPyXpecinbNs_OuhjgUNIj82CLks3SjPk,14135
+networkx/drawing/nx_pylab.py,sha256=LOTf6wOfOkB_t-ml5EY-6SEOfMYAxdDzE-4uGJAxBuo,51138
+networkx/drawing/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/drawing/tests/__pycache__/__init__.cpython-311.pyc,,
+networkx/drawing/tests/__pycache__/test_agraph.cpython-311.pyc,,
+networkx/drawing/tests/__pycache__/test_latex.cpython-311.pyc,,
+networkx/drawing/tests/__pycache__/test_layout.cpython-311.pyc,,
+networkx/drawing/tests/__pycache__/test_pydot.cpython-311.pyc,,
+networkx/drawing/tests/__pycache__/test_pylab.cpython-311.pyc,,
+networkx/drawing/tests/baseline/test_house_with_colors.png,sha256=FQi9pIRFwjq4gvgB8cDdBHL5euQUJFw6sQlABf2kRVo,21918
+networkx/drawing/tests/test_agraph.py,sha256=7qDwr3AruwHxoSUGNRACyL5OTK7_2qDM5bkCANSMql4,9045
+networkx/drawing/tests/test_latex.py,sha256=_Wng73kMltC-_sUoxdo2uBL2bkEc7HMqkKhwo9ZDJGA,8710
+networkx/drawing/tests/test_layout.py,sha256=JUHMitAFs28rgYcEvk3-8-8Ri0Qui9ir3DjY24L6MfU,17841
+networkx/drawing/tests/test_pydot.py,sha256=-eRn39-HTFAZ1oVMR6ULSZxCS2531-HrlNjQaUa3i-8,6242
+networkx/drawing/tests/test_pylab.py,sha256=hlStKEitfl74u2wnEYlajmWHVd0IwHdyFfxDcgooUfc,27576
+networkx/exception.py,sha256=5v8tPTpYcuu3OFgSitgC8-wMUGNwfgxZog2gsBNeRPk,3537
+networkx/generators/__init__.py,sha256=tEbG2IO2NkxVzAFjeApCpATxhjRYopOXes6iffqC6DI,1318
+networkx/generators/__pycache__/__init__.cpython-311.pyc,,
+networkx/generators/__pycache__/atlas.cpython-311.pyc,,
+networkx/generators/__pycache__/classic.cpython-311.pyc,,
+networkx/generators/__pycache__/cographs.cpython-311.pyc,,
+networkx/generators/__pycache__/community.cpython-311.pyc,,
+networkx/generators/__pycache__/degree_seq.cpython-311.pyc,,
+networkx/generators/__pycache__/directed.cpython-311.pyc,,
+networkx/generators/__pycache__/duplication.cpython-311.pyc,,
+networkx/generators/__pycache__/ego.cpython-311.pyc,,
+networkx/generators/__pycache__/expanders.cpython-311.pyc,,
+networkx/generators/__pycache__/geometric.cpython-311.pyc,,
+networkx/generators/__pycache__/harary_graph.cpython-311.pyc,,
+networkx/generators/__pycache__/internet_as_graphs.cpython-311.pyc,,
+networkx/generators/__pycache__/intersection.cpython-311.pyc,,
+networkx/generators/__pycache__/interval_graph.cpython-311.pyc,,
+networkx/generators/__pycache__/joint_degree_seq.cpython-311.pyc,,
+networkx/generators/__pycache__/lattice.cpython-311.pyc,,
+networkx/generators/__pycache__/line.cpython-311.pyc,,
+networkx/generators/__pycache__/mycielski.cpython-311.pyc,,
+networkx/generators/__pycache__/nonisomorphic_trees.cpython-311.pyc,,
+networkx/generators/__pycache__/random_clustered.cpython-311.pyc,,
+networkx/generators/__pycache__/random_graphs.cpython-311.pyc,,
+networkx/generators/__pycache__/small.cpython-311.pyc,,
+networkx/generators/__pycache__/social.cpython-311.pyc,,
+networkx/generators/__pycache__/spectral_graph_forge.cpython-311.pyc,,
+networkx/generators/__pycache__/stochastic.cpython-311.pyc,,
+networkx/generators/__pycache__/sudoku.cpython-311.pyc,,
+networkx/generators/__pycache__/time_series.cpython-311.pyc,,
+networkx/generators/__pycache__/trees.cpython-311.pyc,,
+networkx/generators/__pycache__/triads.cpython-311.pyc,,
+networkx/generators/atlas.dat.gz,sha256=c_xBbfAWSSNgd1HLdZ9K6B3rX2VQvyW-Wcht47dH5B0,8887
+networkx/generators/atlas.py,sha256=NG5jMwud76LrkzBCl9tNGrv0j3weSi4-A_wtPChdglY,5557
+networkx/generators/classic.py,sha256=hmHiIsSsld_DVY8lpULBF8bGRLYDnhCWDD-Y_8u4o-k,28395
+networkx/generators/cographs.py,sha256=oDJVZRiviNZOrHSGXxQNcXFbRvtB3DW0aFFEJ8bfQ_Y,1866
+networkx/generators/community.py,sha256=bgbD7UfKYXf9lSUe9WJeo20pioNJJMyh1ZpenYOex6E,34690
+networkx/generators/degree_seq.py,sha256=0Zpv4q5rYgrUepprOGaQFTw3PVg6EEWobo9i3Ira9ZI,30006
+networkx/generators/directed.py,sha256=qlm-ArjKbqnGWJi2Ax9HuqaUQm_IUFPuwwDYvAUW4o8,15554
+networkx/generators/duplication.py,sha256=1Ys4nb9suq49ooAVXSnkuKQjvW3H_llprd-xdp70wSs,5013
+networkx/generators/ego.py,sha256=V373eWi-qyJXxgsa49NdLyVqFVCpqC-CMY9ATwQYws8,1873
+networkx/generators/expanders.py,sha256=xDfzdnl2XYrVItnCiU_09szMKQB6S9xOaxWx6rFTHCE,6447
+networkx/generators/geometric.py,sha256=8slijaPVv36oTzU5EsKx0bqtLmgICpbV5zl0vh7MfM8,30858
+networkx/generators/harary_graph.py,sha256=-9SU_IDZklbmiz4bwyCOPbQ4DEnXHwKStim2fHbPz6A,6111
+networkx/generators/internet_as_graphs.py,sha256=tMXL8U9YCAerfYYOV0wpEjPL16HIAJpEOzL8GdZAjxw,14148
+networkx/generators/intersection.py,sha256=WW3yE7TbjDtjggrLU8UysmiY_ip6tLy_hggUYWXVRy8,4028
+networkx/generators/interval_graph.py,sha256=LuXcLfLiRToVhmwz6nz1yWKivzqujFOB1MNZ0WRgnmg,2213
+networkx/generators/joint_degree_seq.py,sha256=p49dvZCcda6NAEsz4zvbiogIw4deqT51HpgIb8rU2zY,24717
+networkx/generators/lattice.py,sha256=8yw3GgxEH2erK2xBCW3oMT2hT2R5eCJC9OcBKz-R-vs,13380
+networkx/generators/line.py,sha256=R5Nz58zz_Fq8LbbLPEDRrYbCGLlbaRj2htmRZJbEv3M,17500
+networkx/generators/mycielski.py,sha256=0f_XLLjdpKsV_VS31PESe6LGg4yJI7nyX4DUWtyMU0U,3266
+networkx/generators/nonisomorphic_trees.py,sha256=I6T3QaH-Asw1B5g0_jnQJO9tOydc4qEbSmNIFUvq6ik,5232
+networkx/generators/random_clustered.py,sha256=4msP74PFIQvmWCxIs7F9WqYWvOTqDXXSf1wSuExEXF8,4159
+networkx/generators/random_graphs.py,sha256=SSYM8SZWgRglwMI6vxBWukDnQDJEk_9lCFKWMm_NkjA,44729
+networkx/generators/small.py,sha256=ADc-LfX8aEg_UYkPVfZk9YN4Na2KxpZxHsSvnVhj5D8,27217
+networkx/generators/social.py,sha256=caDTR23cNv1nlA5j3OZvs3d4HuwExxNbjfO9Ijqv7qY,22867
+networkx/generators/spectral_graph_forge.py,sha256=PPU6w9Z0_6iKQODsXSCE4ftVMYNrECBeH1Q_Y5Ea95U,4217
+networkx/generators/stochastic.py,sha256=K_4B3xmc6EDTQkc53eaOK1wHzF6qijAogWmEMDIjwjc,1897
+networkx/generators/sudoku.py,sha256=l-j2mo0KLarWRvMmjncZZfxJzoYn9ZGuz_3rlGZ5CRM,4264
+networkx/generators/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/generators/tests/__pycache__/__init__.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_atlas.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_classic.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_cographs.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_community.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_degree_seq.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_directed.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_duplication.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_ego.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_expanders.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_geometric.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_harary_graph.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_internet_as_graphs.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_intersection.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_interval_graph.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_joint_degree_seq.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_lattice.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_line.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_mycielski.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_nonisomorphic_trees.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_random_clustered.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_random_graphs.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_small.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_spectral_graph_forge.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_stochastic.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_sudoku.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_time_series.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_trees.cpython-311.pyc,,
+networkx/generators/tests/__pycache__/test_triads.cpython-311.pyc,,
+networkx/generators/tests/test_atlas.py,sha256=nwXJL4O5jUqhTwqhkPxHY8s3KXHQTDEdsfbg4MsSzVQ,2530
+networkx/generators/tests/test_classic.py,sha256=RAELDkMqAVYaIo1nhBbjDbmAfzSrn6RBqSSd--mWqvs,22495
+networkx/generators/tests/test_cographs.py,sha256=DkiQzP69sjw3QtjWVX2XV0EXoOuEvR42dixPWwuawSE,460
+networkx/generators/tests/test_community.py,sha256=FGcDo3Ajb-yYc5kUkFbVfOJVMG-YppbAtjgBPcVzjLc,11311
+networkx/generators/tests/test_degree_seq.py,sha256=in6lg1pwcAg1N08MA3lQdr3lnm2-aoUy3BRm6Yj_OBQ,7093
+networkx/generators/tests/test_directed.py,sha256=00widU8dJGkdnU_b6-ZxL8KGtx-gSh4sRG7cwbMHvjQ,5258
+networkx/generators/tests/test_duplication.py,sha256=IIzcHEfHp0NHsH7GTXSb4E4kgXAlt83q4IMibfx2FBw,1915
+networkx/generators/tests/test_ego.py,sha256=8v1Qjmkli9wIhhUuqzgqCzysr0C1Z2C3oJMCUoNvgY4,1327
+networkx/generators/tests/test_expanders.py,sha256=O6O68S5VFWycg-Ml-gvZXjX_vjwO0MBfaBcNYIBP9Io,2896
+networkx/generators/tests/test_geometric.py,sha256=1wzo-eTOP937aOEk8lQGrsW7u2BDfRhyYQ1HpHQqslQ,12512
+networkx/generators/tests/test_harary_graph.py,sha256=U5GfsoekBwVwTGMvk33e2eFOzHEL4czRIWv57j3nt_g,4937
+networkx/generators/tests/test_internet_as_graphs.py,sha256=QmzkOnWg9bcSrv31UcaD6Cko55AV-GPLLY5Aqb_Dmvs,6795
+networkx/generators/tests/test_intersection.py,sha256=hcIit5fKfOn3VjMhz9KqovZK9tzxZfmC6ezvA7gZAvM,819
+networkx/generators/tests/test_interval_graph.py,sha256=-1yXDZDW-ygmNva9Bu-TsS_SYGLcW1KJplwZHFFYyWM,4278
+networkx/generators/tests/test_joint_degree_seq.py,sha256=8TXTZI3Um2gBXtP-4yhGKf9vCi78-NVmWZw9r9WG3F8,4270
+networkx/generators/tests/test_lattice.py,sha256=q4Ri-dH9mKhfq0PNX9xMeYRUiP0JlPBr7piSruZlFlg,9290
+networkx/generators/tests/test_line.py,sha256=vXncJuny2j5ulCJyT01Rt1tTwPib4XelS3dJDdJXjx0,10378
+networkx/generators/tests/test_mycielski.py,sha256=cAg2J6o_RrbwEdAc0vCuSF6zeS6w1KT4leTM0vkIeoA,822
+networkx/generators/tests/test_nonisomorphic_trees.py,sha256=Y_qWyj_qZU9O_DC4BHEVD9xnIEALCmfdmZAYJjTxUYE,2384
+networkx/generators/tests/test_random_clustered.py,sha256=LTfigb1swnYWS59OJoBmNcjFcUjsodnHVOwFxBXl7xg,979
+networkx/generators/tests/test_random_graphs.py,sha256=DKEPbvKiFzZQsuofuj_MphGX2KJ8Bvz6ofIttDGMANk,13121
+networkx/generators/tests/test_small.py,sha256=u_CTdGXfwnqvIYWjYv8VX_r_KB5Y1aCxXxQkxhx-WHs,6906
+networkx/generators/tests/test_spectral_graph_forge.py,sha256=x4jyTiQiydaUPWYaGsNFsIB47PAzSSwQYCNXGa2B4SU,1594
+networkx/generators/tests/test_stochastic.py,sha256=xdytPcz4ETnuqGtjMr0CI3zR4xWJqi91Zxbkly8Ijf8,2178
+networkx/generators/tests/test_sudoku.py,sha256=dgOmk-B7MxCVkbHdZzsLZppQ61FAArVy4McSVL8Afzo,1968
+networkx/generators/tests/test_time_series.py,sha256=74kHpcBfbed7zmd1Ofh2XoLIhIaEEFpEf51j1e2muMo,2229
+networkx/generators/tests/test_trees.py,sha256=hv8oNYZOcYcaARXvaMQZptCVBvk-huk-nKI5mH9sB-8,7634
+networkx/generators/tests/test_triads.py,sha256=mgpHFf0Z34CqtnXgkdf7gK1dC77ppYAqwviXsaU1HVs,332
+networkx/generators/time_series.py,sha256=Jz33n3mprkLrVbwLRLznQg_lDQvmIL2jWNoY4LCla80,2414
+networkx/generators/trees.py,sha256=xR9H01HkI1WR24KdSEv8inTz6rgbzjwt1vL0GfOImts,39067
+networkx/generators/triads.py,sha256=bXfoxFUH9CJaO7PMxjwiB9SvhPp4ZL3HxlUsL-67Yv4,2233
+networkx/lazy_imports.py,sha256=MDfQ4C99G30uYBmLJBGtGEcrOzHMUcxvOyZpN674DYw,5784
+networkx/linalg/__init__.py,sha256=7iyNZ_YYBnlsW8zSfhUgvEkywOrUWfpIuyS86ZOKlG8,568
+networkx/linalg/__pycache__/__init__.cpython-311.pyc,,
+networkx/linalg/__pycache__/algebraicconnectivity.cpython-311.pyc,,
+networkx/linalg/__pycache__/attrmatrix.cpython-311.pyc,,
+networkx/linalg/__pycache__/bethehessianmatrix.cpython-311.pyc,,
+networkx/linalg/__pycache__/graphmatrix.cpython-311.pyc,,
+networkx/linalg/__pycache__/laplacianmatrix.cpython-311.pyc,,
+networkx/linalg/__pycache__/modularitymatrix.cpython-311.pyc,,
+networkx/linalg/__pycache__/spectrum.cpython-311.pyc,,
+networkx/linalg/algebraicconnectivity.py,sha256=CScaTuN7V1BfEBPA8LSSe1FLV7uE-Am8Iaf9Q9Crgtw,21106
+networkx/linalg/attrmatrix.py,sha256=93xWJq-tIvayQTEUp7UaHLmAQQpSPYMHKF4KqPEfSUE,15504
+networkx/linalg/bethehessianmatrix.py,sha256=sNCKJoRe9jidTrqdX5I8mwl1t08GKzaL14R4ujk42Vk,2692
+networkx/linalg/graphmatrix.py,sha256=TRbhk2cHeJtKW15Gl-lGD7Ih1M3eHkSOC7yoerb7WBU,5513
+networkx/linalg/laplacianmatrix.py,sha256=WQJnmPEVsDTL8kUfQmqg-GJEPeHx3HO4PQLTO-XUp44,13330
+networkx/linalg/modularitymatrix.py,sha256=gtFN_MajMpZlvfsUqzBygLS6l5hZKi2_g1YqzPPedJw,4698
+networkx/linalg/spectrum.py,sha256=oxo9HSRM6jP2g8hKT1lk54Yinhr38AcanSK6RwHnDG0,4194
+networkx/linalg/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/linalg/tests/__pycache__/__init__.cpython-311.pyc,,
+networkx/linalg/tests/__pycache__/test_algebraic_connectivity.cpython-311.pyc,,
+networkx/linalg/tests/__pycache__/test_attrmatrix.cpython-311.pyc,,
+networkx/linalg/tests/__pycache__/test_bethehessian.cpython-311.pyc,,
+networkx/linalg/tests/__pycache__/test_graphmatrix.cpython-311.pyc,,
+networkx/linalg/tests/__pycache__/test_laplacian.cpython-311.pyc,,
+networkx/linalg/tests/__pycache__/test_modularity.cpython-311.pyc,,
+networkx/linalg/tests/__pycache__/test_spectrum.cpython-311.pyc,,
+networkx/linalg/tests/test_algebraic_connectivity.py,sha256=Kj2ct6gQ71xXFP7usAbFLJxD7ZdtTzneHiFJQOoVCUQ,13737
+networkx/linalg/tests/test_attrmatrix.py,sha256=XD3YuPc5yXKWbhwVSI8YiV_wABWM-rLtwf1uwwWlnI0,2833
+networkx/linalg/tests/test_bethehessian.py,sha256=0r-Do902ywV10TyqTlIJ2Ls3iMqM6sSs2PZbod7kWBM,1327
+networkx/linalg/tests/test_graphmatrix.py,sha256=e5YSH9ih1VL64nnYgZFDvLyKbP3BFqpp0jY6t-8b2eY,8708
+networkx/linalg/tests/test_laplacian.py,sha256=K8p2upJTJLfNHfAf0B9ohPXBZ4k_2VMpSvIc-jXZ_rM,9934
+networkx/linalg/tests/test_modularity.py,sha256=mfKUvwc3bj6Rud1aG4oK3Eu1qg12o6cB8-pv5ZFicYY,3115
+networkx/linalg/tests/test_spectrum.py,sha256=agP2DsiEIvtkNUkT94mdPtJjwnobnjMTUOwjIQa4giA,2828
+networkx/readwrite/__init__.py,sha256=iHycAh1rjr4bCPQMNiHiqm8cP3iu-g1v_uKiGZtkuXY,562
+networkx/readwrite/__pycache__/__init__.cpython-311.pyc,,
+networkx/readwrite/__pycache__/adjlist.cpython-311.pyc,,
+networkx/readwrite/__pycache__/edgelist.cpython-311.pyc,,
+networkx/readwrite/__pycache__/gexf.cpython-311.pyc,,
+networkx/readwrite/__pycache__/gml.cpython-311.pyc,,
+networkx/readwrite/__pycache__/graph6.cpython-311.pyc,,
+networkx/readwrite/__pycache__/graphml.cpython-311.pyc,,
+networkx/readwrite/__pycache__/leda.cpython-311.pyc,,
+networkx/readwrite/__pycache__/multiline_adjlist.cpython-311.pyc,,
+networkx/readwrite/__pycache__/p2g.cpython-311.pyc,,
+networkx/readwrite/__pycache__/pajek.cpython-311.pyc,,
+networkx/readwrite/__pycache__/sparse6.cpython-311.pyc,,
+networkx/readwrite/__pycache__/text.cpython-311.pyc,,
+networkx/readwrite/adjlist.py,sha256=P8W_dQu-1NQCC8FX-Zpyta_b0L-NuruRE4X-GKSWNSQ,8386
+networkx/readwrite/edgelist.py,sha256=qkS9reBZWrSviBp2ZkUMt5gEo4FbFcBfQXhO14OSI-E,14160
+networkx/readwrite/gexf.py,sha256=UZPVSIlQNH_t0KNTEjclEcJ96FdeLWLVQ84f7u1NoDM,39668
+networkx/readwrite/gml.py,sha256=NK9jDDQhShmf70wrH2P2hNV59KdFUbC866vhvRc_qV8,31104
+networkx/readwrite/graph6.py,sha256=P2jrsgiX75XGMCK4wyIGpXo8snOJ--ZZ6r6N5m1jusE,11355
+networkx/readwrite/graphml.py,sha256=YIxHdP3zXFixYb_rVL051-yyfN9rJwFs_D1tB39NH8w,39183
+networkx/readwrite/json_graph/__init__.py,sha256=31_5zVLXYEZkjOB-TKXZ5bi83JybPWgpCaRKOXIGoOA,676
+networkx/readwrite/json_graph/__pycache__/__init__.cpython-311.pyc,,
+networkx/readwrite/json_graph/__pycache__/adjacency.cpython-311.pyc,,
+networkx/readwrite/json_graph/__pycache__/cytoscape.cpython-311.pyc,,
+networkx/readwrite/json_graph/__pycache__/node_link.cpython-311.pyc,,
+networkx/readwrite/json_graph/__pycache__/tree.cpython-311.pyc,,
+networkx/readwrite/json_graph/adjacency.py,sha256=QAUoN4LI5ehEjBv__T_hpmHA2n0eHuE3f3OwQv4kiqA,4692
+networkx/readwrite/json_graph/cytoscape.py,sha256=1UqpoAB-96c4sFGKqTjCziInavrHcFJRHFQo4_iits4,5234
+networkx/readwrite/json_graph/node_link.py,sha256=8ujpdgQapwClUautmCOF3Up3JoFiLgZRHu6PUxF1B7Q,7450
+networkx/readwrite/json_graph/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/readwrite/json_graph/tests/__pycache__/__init__.cpython-311.pyc,,
+networkx/readwrite/json_graph/tests/__pycache__/test_adjacency.cpython-311.pyc,,
+networkx/readwrite/json_graph/tests/__pycache__/test_cytoscape.cpython-311.pyc,,
+networkx/readwrite/json_graph/tests/__pycache__/test_node_link.cpython-311.pyc,,
+networkx/readwrite/json_graph/tests/__pycache__/test_tree.cpython-311.pyc,,
+networkx/readwrite/json_graph/tests/test_adjacency.py,sha256=jueQE3Z_W5BZuCjr0hEsOWSfoQ2fP51p0o0m7IcXUuE,2456
+networkx/readwrite/json_graph/tests/test_cytoscape.py,sha256=vFoDzcSRI9THlmp4Fu2HHhIF9AUmECWs5mftVWjaWWs,2044
+networkx/readwrite/json_graph/tests/test_node_link.py,sha256=bDe2Vv1M4h0IDbKjS482p8ZE7SZtBfHDgZ1OEPibwoo,4536
+networkx/readwrite/json_graph/tests/test_tree.py,sha256=zBXv3_db2XGxFs3XQ35btNf_ku52aLXXiHZmmX4ixAs,1352
+networkx/readwrite/json_graph/tree.py,sha256=ETjeYnUMyqZ0PbvSR97ar9rJnH8ncLI_Qd16qGFb-jw,3827
+networkx/readwrite/leda.py,sha256=No8DKw26vB2fzaDQNmfOEOuiUS9XGdvBXSKrctJhipg,2749
+networkx/readwrite/multiline_adjlist.py,sha256=Zo7K6gE-FpOBao4KiVaA-yRk4mbQzCJzIl4uUgrWYfM,11255
+networkx/readwrite/p2g.py,sha256=j8vNdr8KKD3o0d1zvfYUJnhe8J9vWxAHLzw3mW85apE,3043
+networkx/readwrite/pajek.py,sha256=aFKB04KvFuCqBawdjvR7U4N8BzPDDatqkf97s8zY_eI,8690
+networkx/readwrite/sparse6.py,sha256=sPL2NBYvB9blDaSJEEdYocHxaU7SmV1OVhYf8a_-LsI,10269
+networkx/readwrite/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/readwrite/tests/__pycache__/__init__.cpython-311.pyc,,
+networkx/readwrite/tests/__pycache__/test_adjlist.cpython-311.pyc,,
+networkx/readwrite/tests/__pycache__/test_edgelist.cpython-311.pyc,,
+networkx/readwrite/tests/__pycache__/test_gexf.cpython-311.pyc,,
+networkx/readwrite/tests/__pycache__/test_gml.cpython-311.pyc,,
+networkx/readwrite/tests/__pycache__/test_graph6.cpython-311.pyc,,
+networkx/readwrite/tests/__pycache__/test_graphml.cpython-311.pyc,,
+networkx/readwrite/tests/__pycache__/test_leda.cpython-311.pyc,,
+networkx/readwrite/tests/__pycache__/test_p2g.cpython-311.pyc,,
+networkx/readwrite/tests/__pycache__/test_pajek.cpython-311.pyc,,
+networkx/readwrite/tests/__pycache__/test_sparse6.cpython-311.pyc,,
+networkx/readwrite/tests/__pycache__/test_text.cpython-311.pyc,,
+networkx/readwrite/tests/test_adjlist.py,sha256=dLEv3txnBrHYxajOYAQhA8CA7axiuPw1ECbaHL5p338,9922
+networkx/readwrite/tests/test_edgelist.py,sha256=atBg6Qjhk8boXs3gUZk4gmg-6GOT5rCosEf30sqOZO4,9969
+networkx/readwrite/tests/test_gexf.py,sha256=Tbqueeh0XRQ8vtmGwXcyy9K3tWPlnLu6Gop0Hy4cZcc,19405
+networkx/readwrite/tests/test_gml.py,sha256=GF8rfOj2M3tMtdQ65DMsXypXSFMeWzKEI1qYV-jd5xA,21334
+networkx/readwrite/tests/test_graph6.py,sha256=IjBpfTr-czBLHb8UT_JzvOTBROpnOf5TKKkfCnEeQT8,6069
+networkx/readwrite/tests/test_graphml.py,sha256=u4u-udRXPCXFUZ9oB0_X4UUx3MVULQjx9tkXUdwebhI,67149
+networkx/readwrite/tests/test_leda.py,sha256=_5F4nLLQ1oAZQMZtTQoFncZL0Oc-IsztFBglEdQeH3k,1392
+networkx/readwrite/tests/test_p2g.py,sha256=drsdod5amV9TGCk-qE2RwsvAop78IKEI1WguVFfd9rs,1320
+networkx/readwrite/tests/test_pajek.py,sha256=XTsnaCaYjroysCHlTsYwMGGrDR0B1MRwWkA-WXbAXTg,4703
+networkx/readwrite/tests/test_sparse6.py,sha256=fLpTG0YgcptNOpUipcCcVlni5i8IyC21kkk3ZeD0XhM,5470
+networkx/readwrite/tests/test_text.py,sha256=w17FdFQ4vK3J8d2UKPZUEtIo5udp6UyilPXyIr8JfpE,56562
+networkx/readwrite/text.py,sha256=4rWNkDgtUSmqGUAIXPkOKU7u9PFQOlp5eBqn6yt9QKk,32132
+networkx/relabel.py,sha256=m8R1KovP9IBtzTE2_6NYgMRxB5AFDwZmUCOFYkDoNXI,10279
+networkx/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/tests/__pycache__/__init__.cpython-311.pyc,,
+networkx/tests/__pycache__/test_all_random_functions.cpython-311.pyc,,
+networkx/tests/__pycache__/test_convert.cpython-311.pyc,,
+networkx/tests/__pycache__/test_convert_numpy.cpython-311.pyc,,
+networkx/tests/__pycache__/test_convert_pandas.cpython-311.pyc,,
+networkx/tests/__pycache__/test_convert_scipy.cpython-311.pyc,,
+networkx/tests/__pycache__/test_exceptions.cpython-311.pyc,,
+networkx/tests/__pycache__/test_import.cpython-311.pyc,,
+networkx/tests/__pycache__/test_lazy_imports.cpython-311.pyc,,
+networkx/tests/__pycache__/test_relabel.cpython-311.pyc,,
+networkx/tests/test_all_random_functions.py,sha256=tbFGmaqLrF8lEp0Hn8sOuPzD5rzIpOVOeeBoBk3_W6g,8653
+networkx/tests/test_convert.py,sha256=SoIVrqJFF9Gu9Jff_apfbpqg8QhkfC6QW4qzoSM-ukM,12731
+networkx/tests/test_convert_numpy.py,sha256=R4y5ud0hVZFSGrFjUHD6Anu_aaasy2O_Eke4FaOhPqU,14951
+networkx/tests/test_convert_pandas.py,sha256=cZJEdV0jP8afRZMqJ8-aL9Ma5NdXSWMuj1hVbjGMR2g,12257
+networkx/tests/test_convert_scipy.py,sha256=C2cY_8dgBksO0uttkhyCnjACXtC6KHjxqHUk47P5wH8,10436
+networkx/tests/test_exceptions.py,sha256=XYkpPzqMepSw3MPRUJN5LcFsUsy3YT_fiRDhm0OeAeQ,927
+networkx/tests/test_import.py,sha256=Gm4ujfH9JkQtDrSjOlwXXXUuubI057wskKLCkF6Z92k,220
+networkx/tests/test_lazy_imports.py,sha256=nKykNQPt_ZV8JxCH_EkwwcPNayAgZGQVf89e8I7uIlI,2680
+networkx/tests/test_relabel.py,sha256=dffbjiW_VUAQe7iD8knFS_KepUITt0F6xuwf7daWwKw,14517
+networkx/utils/__init__.py,sha256=T8IdHaWU2MOGbU-1a7JZcAn5YFtO9iDQVt6ky-BRkJg,227
+networkx/utils/__pycache__/__init__.cpython-311.pyc,,
+networkx/utils/__pycache__/backends.cpython-311.pyc,,
+networkx/utils/__pycache__/decorators.cpython-311.pyc,,
+networkx/utils/__pycache__/heaps.cpython-311.pyc,,
+networkx/utils/__pycache__/mapped_queue.cpython-311.pyc,,
+networkx/utils/__pycache__/misc.cpython-311.pyc,,
+networkx/utils/__pycache__/random_sequence.cpython-311.pyc,,
+networkx/utils/__pycache__/rcm.cpython-311.pyc,,
+networkx/utils/__pycache__/union_find.cpython-311.pyc,,
+networkx/utils/backends.py,sha256=5z_pQQrT3kGUCtihbDDqy3TvR9t82KxyMGAaAdsgKLs,40939
+networkx/utils/decorators.py,sha256=Z3U3-pXWD1OKa3cciHG_LSwwylVrpSXdP2rPALq_gZc,46464
+networkx/utils/heaps.py,sha256=HUZuETHfELEqiXdMBPmD9fA2KiACVhp6iEahcrjFxYM,10391
+networkx/utils/mapped_queue.py,sha256=ywJN0Z32EAQ1dezF8ORXP_ca0n16sxQlcIrkQQn5i7I,10185
+networkx/utils/misc.py,sha256=pyN1TGuUFHFfPLubIL-wP-zl_Ybm_U_UWxVw37_tI3g,14351
+networkx/utils/random_sequence.py,sha256=KzKh0BRMri0MBZlzxHNMl3qRTy2DnBexW3eDzmxKab4,4237
+networkx/utils/rcm.py,sha256=MeOhFkv91ALieKJtGHqkhxgO7KJBz53mB8tRcYCX3xk,4623
+networkx/utils/tests/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+networkx/utils/tests/__pycache__/__init__.cpython-311.pyc,,
+networkx/utils/tests/__pycache__/test__init.cpython-311.pyc,,
+networkx/utils/tests/__pycache__/test_decorators.cpython-311.pyc,,
+networkx/utils/tests/__pycache__/test_heaps.cpython-311.pyc,,
+networkx/utils/tests/__pycache__/test_mapped_queue.cpython-311.pyc,,
+networkx/utils/tests/__pycache__/test_misc.cpython-311.pyc,,
+networkx/utils/tests/__pycache__/test_random_sequence.cpython-311.pyc,,
+networkx/utils/tests/__pycache__/test_rcm.cpython-311.pyc,,
+networkx/utils/tests/__pycache__/test_unionfind.cpython-311.pyc,,
+networkx/utils/tests/test__init.py,sha256=QE0i-lNE4pG2eYjB2mZ0uw7jPD-7TdL7Y9p73JoWQmo,363
+networkx/utils/tests/test_decorators.py,sha256=AfxQ_C4BcKG8q9wepyglzIebzD_pPpGRPR4dovl6JR4,13334
+networkx/utils/tests/test_heaps.py,sha256=qCuWMzpcMH1Gwu014CAams78o151QD5YL0mB1fz16Yw,3711
+networkx/utils/tests/test_mapped_queue.py,sha256=l1Nguzz68Fv91FnAT7y7B0GXSoje9uoWiObHo7TliGM,7354
+networkx/utils/tests/test_misc.py,sha256=3oa6D5fnxm9VFODhEwM540hU4IBzEucOoD6DiGvP5gc,8218
+networkx/utils/tests/test_random_sequence.py,sha256=Ou-IeCFybibZuycoin5gUQzzC-iy5yanZFmrqvdGt6Q,925
+networkx/utils/tests/test_rcm.py,sha256=UvUAkgmQMGk_Nn94TJyQsle4A5SLQFqMQWld1tiQ2lk,1421
+networkx/utils/tests/test_unionfind.py,sha256=j-DF5XyeJzq1hoeAgN5Nye2Au7EPD040t8oS4Aw2IwU,1579
+networkx/utils/union_find.py,sha256=NxKlBlyS71A1Wlnt28L-wyZoI9ExZvJth_0e2XSVris,3338

tuning-competition-baseline/.venv/lib/python3.11/site-packages/networkx-3.2.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[networkx.backends]
+nx-loopback = networkx.classes.tests.dispatch_interface:dispatcher

tuning-competition-baseline/.venv/lib/python3.11/site-packages/networkx-3.2.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+networkx

tuning-competition-baseline/.venv/lib/python3.11/site-packages/networkx/algorithms/bipartite/__init__.py

@@ -0,0 +1,87 @@
+r""" This module provides functions and operations for bipartite
+graphs.  Bipartite graphs `B = (U, V, E)` have two node sets `U,V` and edges in
+`E` that only connect nodes from opposite sets. It is common in the literature
+to use an spatial analogy referring to the two node sets as top and bottom nodes.
+
+The bipartite algorithms are not imported into the networkx namespace
+at the top level so the easiest way to use them is with:
+
+>>> from networkx.algorithms import bipartite
+
+NetworkX does not have a custom bipartite graph class but the Graph()
+or DiGraph() classes can be used to represent bipartite graphs. However,
+you have to keep track of which set each node belongs to, and make
+sure that there is no edge between nodes of the same set. The convention used
+in NetworkX is to use a node attribute named `bipartite` with values 0 or 1 to
+identify the sets each node belongs to. This convention is not enforced in
+the source code of bipartite functions, it's only a recommendation.
+
+For example:
+
+>>> B = nx.Graph()
+>>> # Add nodes with the node attribute "bipartite"
+>>> B.add_nodes_from([1, 2, 3, 4], bipartite=0)
+>>> B.add_nodes_from(["a", "b", "c"], bipartite=1)
+>>> # Add edges only between nodes of opposite node sets
+>>> B.add_edges_from([(1, "a"), (1, "b"), (2, "b"), (2, "c"), (3, "c"), (4, "a")])
+
+Many algorithms of the bipartite module of NetworkX require, as an argument, a
+container with all the nodes that belong to one set, in addition to the bipartite
+graph `B`. The functions in the bipartite package do not check that the node set
+is actually correct nor that the input graph is actually bipartite.
+If `B` is connected, you can find the two node sets using a two-coloring
+algorithm:
+
+>>> nx.is_connected(B)
+True
+>>> bottom_nodes, top_nodes = bipartite.sets(B)
+
+However, if the input graph is not connected, there are more than one possible
+colorations. This is the reason why we require the user to pass a container
+with all nodes of one bipartite node set as an argument to most bipartite
+functions. In the face of ambiguity, we refuse the temptation to guess and
+raise an :exc:`AmbiguousSolution <networkx.AmbiguousSolution>`
+Exception if the input graph for
+:func:`bipartite.sets <networkx.algorithms.bipartite.basic.sets>`
+is disconnected.
+
+Using the `bipartite` node attribute, you can easily get the two node sets:
+
+>>> top_nodes = {n for n, d in B.nodes(data=True) if d["bipartite"] == 0}
+>>> bottom_nodes = set(B) - top_nodes
+
+So you can easily use the bipartite algorithms that require, as an argument, a
+container with all nodes that belong to one node set:
+
+>>> print(round(bipartite.density(B, bottom_nodes), 2))
+0.5
+>>> G = bipartite.projected_graph(B, top_nodes)
+
+All bipartite graph generators in NetworkX build bipartite graphs with the
+`bipartite` node attribute. Thus, you can use the same approach:
+
+>>> RB = bipartite.random_graph(5, 7, 0.2)
+>>> RB_top = {n for n, d in RB.nodes(data=True) if d["bipartite"] == 0}
+>>> RB_bottom = set(RB) - RB_top
+>>> list(RB_top)
+[0, 1, 2, 3, 4]
+>>> list(RB_bottom)
+[5, 6, 7, 8, 9, 10, 11]
+
+For other bipartite graph generators see
+:mod:`Generators <networkx.algorithms.bipartite.generators>`.
+
+"""
+
+from networkx.algorithms.bipartite.basic import *
+from networkx.algorithms.bipartite.centrality import *
+from networkx.algorithms.bipartite.cluster import *
+from networkx.algorithms.bipartite.covering import *
+from networkx.algorithms.bipartite.edgelist import *
+from networkx.algorithms.bipartite.matching import *
+from networkx.algorithms.bipartite.matrix import *
+from networkx.algorithms.bipartite.projection import *
+from networkx.algorithms.bipartite.redundancy import *
+from networkx.algorithms.bipartite.spectral import *
+from networkx.algorithms.bipartite.generators import *
+from networkx.algorithms.bipartite.extendability import *

tuning-competition-baseline/.venv/lib/python3.11/site-packages/networkx/algorithms/bipartite/cluster.py

@@ -0,0 +1,280 @@
+"""Functions for computing clustering of pairs
+
+"""
+
+import itertools
+
+import networkx as nx
+
+__all__ = [
+    "clustering",
+    "average_clustering",
+    "latapy_clustering",
+    "robins_alexander_clustering",
+]
+
+
+def cc_dot(nu, nv):
+    return len(nu & nv) / len(nu | nv)
+
+
+def cc_max(nu, nv):
+    return len(nu & nv) / max(len(nu), len(nv))
+
+
+def cc_min(nu, nv):
+    return len(nu & nv) / min(len(nu), len(nv))
+
+
+modes = {"dot": cc_dot, "min": cc_min, "max": cc_max}
+
+
+@nx._dispatch
+def latapy_clustering(G, nodes=None, mode="dot"):
+    r"""Compute a bipartite clustering coefficient for nodes.
+
+    The bipartite clustering coefficient is a measure of local density
+    of connections defined as [1]_:
+
+    .. math::
+
+       c_u = \frac{\sum_{v \in N(N(u))} c_{uv} }{|N(N(u))|}
+
+    where `N(N(u))` are the second order neighbors of `u` in `G` excluding `u`,
+    and `c_{uv}` is the pairwise clustering coefficient between nodes
+    `u` and `v`.
+
+    The mode selects the function for `c_{uv}` which can be:
+
+    `dot`:
+
+    .. math::
+
+       c_{uv}=\frac{|N(u)\cap N(v)|}{|N(u) \cup N(v)|}
+
+    `min`:
+
+    .. math::
+
+       c_{uv}=\frac{|N(u)\cap N(v)|}{min(|N(u)|,|N(v)|)}
+
+    `max`:
+
+    .. math::
+
+       c_{uv}=\frac{|N(u)\cap N(v)|}{max(|N(u)|,|N(v)|)}
+
+
+    Parameters
+    ----------
+    G : graph
+        A bipartite graph
+
+    nodes : list or iterable (optional)
+        Compute bipartite clustering for these nodes. The default
+        is all nodes in G.
+
+    mode : string
+        The pairwise bipartite clustering method to be used in the computation.
+        It must be "dot", "max", or "min".
+
+    Returns
+    -------
+    clustering : dictionary
+        A dictionary keyed by node with the clustering coefficient value.
+
+
+    Examples
+    --------
+    >>> from networkx.algorithms import bipartite
+    >>> G = nx.path_graph(4)  # path graphs are bipartite
+    >>> c = bipartite.clustering(G)
+    >>> c[0]
+    0.5
+    >>> c = bipartite.clustering(G, mode="min")
+    >>> c[0]
+    1.0
+
+    See Also
+    --------
+    robins_alexander_clustering
+    average_clustering
+    networkx.algorithms.cluster.square_clustering
+
+    References
+    ----------
+    .. [1] Latapy, Matthieu, Clémence Magnien, and Nathalie Del Vecchio (2008).
+       Basic notions for the analysis of large two-mode networks.
+       Social Networks 30(1), 31--48.
+    """
+    if not nx.algorithms.bipartite.is_bipartite(G):
+        raise nx.NetworkXError("Graph is not bipartite")
+
+    try:
+        cc_func = modes[mode]
+    except KeyError as err:
+        raise nx.NetworkXError(
+            "Mode for bipartite clustering must be: dot, min or max"
+        ) from err
+
+    if nodes is None:
+        nodes = G
+    ccs = {}
+    for v in nodes:
+        cc = 0.0
+        nbrs2 = {u for nbr in G[v] for u in G[nbr]} - {v}
+        for u in nbrs2:
+            cc += cc_func(set(G[u]), set(G[v]))
+        if cc > 0.0:  # len(nbrs2)>0
+            cc /= len(nbrs2)
+        ccs[v] = cc
+    return ccs
+
+
+clustering = latapy_clustering
+
+
+@nx._dispatch(name="bipartite_average_clustering")
+def average_clustering(G, nodes=None, mode="dot"):
+    r"""Compute the average bipartite clustering coefficient.
+
+    A clustering coefficient for the whole graph is the average,
+
+    .. math::
+
+       C = \frac{1}{n}\sum_{v \in G} c_v,
+
+    where `n` is the number of nodes in `G`.
+
+    Similar measures for the two bipartite sets can be defined [1]_
+
+    .. math::
+
+       C_X = \frac{1}{|X|}\sum_{v \in X} c_v,
+
+    where `X` is a bipartite set of `G`.
+
+    Parameters
+    ----------
+    G : graph
+        a bipartite graph
+
+    nodes : list or iterable, optional
+        A container of nodes to use in computing the average.
+        The nodes should be either the entire graph (the default) or one of the
+        bipartite sets.
+
+    mode : string
+        The pairwise bipartite clustering method.
+        It must be "dot", "max", or "min"
+
+    Returns
+    -------
+    clustering : float
+       The average bipartite clustering for the given set of nodes or the
+       entire graph if no nodes are specified.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import bipartite
+    >>> G = nx.star_graph(3)  # star graphs are bipartite
+    >>> bipartite.average_clustering(G)
+    0.75
+    >>> X, Y = bipartite.sets(G)
+    >>> bipartite.average_clustering(G, X)
+    0.0
+    >>> bipartite.average_clustering(G, Y)
+    1.0
+
+    See Also
+    --------
+    clustering
+
+    Notes
+    -----
+    The container of nodes passed to this function must contain all of the nodes
+    in one of the bipartite sets ("top" or "bottom") in order to compute
+    the correct average bipartite clustering coefficients.
+    See :mod:`bipartite documentation <networkx.algorithms.bipartite>`
+    for further details on how bipartite graphs are handled in NetworkX.
+
+
+    References
+    ----------
+    .. [1] Latapy, Matthieu, Clémence Magnien, and Nathalie Del Vecchio (2008).
+        Basic notions for the analysis of large two-mode networks.
+        Social Networks 30(1), 31--48.
+    """
+    if nodes is None:
+        nodes = G
+    ccs = latapy_clustering(G, nodes=nodes, mode=mode)
+    return sum(ccs[v] for v in nodes) / len(nodes)
+
+
+@nx._dispatch
+def robins_alexander_clustering(G):
+    r"""Compute the bipartite clustering of G.
+
+    Robins and Alexander [1]_ defined bipartite clustering coefficient as
+    four times the number of four cycles `C_4` divided by the number of
+    three paths `L_3` in a bipartite graph:
+
+    .. math::
+
+       CC_4 = \frac{4 * C_4}{L_3}
+
+    Parameters
+    ----------
+    G : graph
+        a bipartite graph
+
+    Returns
+    -------
+    clustering : float
+       The Robins and Alexander bipartite clustering for the input graph.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import bipartite
+    >>> G = nx.davis_southern_women_graph()
+    >>> print(round(bipartite.robins_alexander_clustering(G), 3))
+    0.468
+
+    See Also
+    --------
+    latapy_clustering
+    networkx.algorithms.cluster.square_clustering
+
+    References
+    ----------
+    .. [1] Robins, G. and M. Alexander (2004). Small worlds among interlocking
+           directors: Network structure and distance in bipartite graphs.
+           Computational & Mathematical Organization Theory 10(1), 69–94.
+
+    """
+    if G.order() < 4 or G.size() < 3:
+        return 0
+    L_3 = _threepaths(G)
+    if L_3 == 0:
+        return 0
+    C_4 = _four_cycles(G)
+    return (4.0 * C_4) / L_3
+
+
+def _four_cycles(G):
+    cycles = 0
+    for v in G:
+        for u, w in itertools.combinations(G[v], 2):
+            cycles += len((set(G[u]) & set(G[w])) - {v})
+    return cycles / 4
+
+
+def _threepaths(G):
+    paths = 0
+    for v in G:
+        for u in G[v]:
+            for w in set(G[u]) - {v}:
+                paths += len(set(G[w]) - {v, u})
+    # Divide by two because we count each three path twice
+    # one for each possible starting point
+    return paths / 2

tuning-competition-baseline/.venv/lib/python3.11/site-packages/networkx/algorithms/bipartite/covering.py

@@ -0,0 +1,57 @@
+""" Functions related to graph covers."""
+
+import networkx as nx
+from networkx.algorithms.bipartite.matching import hopcroft_karp_matching
+from networkx.algorithms.covering import min_edge_cover as _min_edge_cover
+from networkx.utils import not_implemented_for
+
+__all__ = ["min_edge_cover"]
+
+
+@not_implemented_for("directed")
+@not_implemented_for("multigraph")
+@nx._dispatch(name="bipartite_min_edge_cover")
+def min_edge_cover(G, matching_algorithm=None):
+    """Returns a set of edges which constitutes
+    the minimum edge cover of the graph.
+
+    The smallest edge cover can be found in polynomial time by finding
+    a maximum matching and extending it greedily so that all nodes
+    are covered.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+        An undirected bipartite graph.
+
+    matching_algorithm : function
+        A function that returns a maximum cardinality matching in a
+        given bipartite graph. The function must take one input, the
+        graph ``G``, and return a dictionary mapping each node to its
+        mate. If not specified,
+        :func:`~networkx.algorithms.bipartite.matching.hopcroft_karp_matching`
+        will be used. Other possibilities include
+        :func:`~networkx.algorithms.bipartite.matching.eppstein_matching`,
+
+    Returns
+    -------
+    set
+        A set of the edges in a minimum edge cover of the graph, given as
+        pairs of nodes. It contains both the edges `(u, v)` and `(v, u)`
+        for given nodes `u` and `v` among the edges of minimum edge cover.
+
+    Notes
+    -----
+    An edge cover of a graph is a set of edges such that every node of
+    the graph is incident to at least one edge of the set.
+    A minimum edge cover is an edge covering of smallest cardinality.
+
+    Due to its implementation, the worst-case running time of this algorithm
+    is bounded by the worst-case running time of the function
+    ``matching_algorithm``.
+    """
+    if G.order() == 0:  # Special case for the empty graph
+        return set()
+    if matching_algorithm is None:
+        matching_algorithm = hopcroft_karp_matching
+    return _min_edge_cover(G, matching_algorithm=matching_algorithm)

tuning-competition-baseline/.venv/lib/python3.11/site-packages/networkx/algorithms/bipartite/edgelist.py

@@ -0,0 +1,359 @@
+"""
+********************
+Bipartite Edge Lists
+********************
+Read and write NetworkX graphs as bipartite edge lists.
+
+Format
+------
+You can read or write three formats of edge lists with these functions.
+
+Node pairs with no data::
+
+ 1 2
+
+Python dictionary as data::
+
+ 1 2 {'weight':7, 'color':'green'}
+
+Arbitrary data::
+
+ 1 2 7 green
+
+For each edge (u, v) the node u is assigned to part 0 and the node v to part 1.
+"""
+__all__ = ["generate_edgelist", "write_edgelist", "parse_edgelist", "read_edgelist"]
+
+import networkx as nx
+from networkx.utils import not_implemented_for, open_file
+
+
+@open_file(1, mode="wb")
+def write_edgelist(G, path, comments="#", delimiter=" ", data=True, encoding="utf-8"):
+    """Write a bipartite graph as a list of edges.
+
+    Parameters
+    ----------
+    G : Graph
+       A NetworkX bipartite graph
+    path : file or string
+       File or filename to write. If a file is provided, it must be
+       opened in 'wb' mode. Filenames ending in .gz or .bz2 will be compressed.
+    comments : string, optional
+       The character used to indicate the start of a comment
+    delimiter : string, optional
+       The string used to separate values.  The default is whitespace.
+    data : bool or list, optional
+       If False write no edge data.
+       If True write a string representation of the edge data dictionary..
+       If a list (or other iterable) is provided, write the  keys specified
+       in the list.
+    encoding: string, optional
+       Specify which encoding to use when writing file.
+
+    Examples
+    --------
+    >>> G = nx.path_graph(4)
+    >>> G.add_nodes_from([0, 2], bipartite=0)
+    >>> G.add_nodes_from([1, 3], bipartite=1)
+    >>> nx.write_edgelist(G, "test.edgelist")
+    >>> fh = open("test.edgelist", "wb")
+    >>> nx.write_edgelist(G, fh)
+    >>> nx.write_edgelist(G, "test.edgelist.gz")
+    >>> nx.write_edgelist(G, "test.edgelist.gz", data=False)
+
+    >>> G = nx.Graph()
+    >>> G.add_edge(1, 2, weight=7, color="red")
+    >>> nx.write_edgelist(G, "test.edgelist", data=False)
+    >>> nx.write_edgelist(G, "test.edgelist", data=["color"])
+    >>> nx.write_edgelist(G, "test.edgelist", data=["color", "weight"])
+
+    See Also
+    --------
+    write_edgelist
+    generate_edgelist
+    """
+    for line in generate_edgelist(G, delimiter, data):
+        line += "\n"
+        path.write(line.encode(encoding))
+
+
+@not_implemented_for("directed")
+def generate_edgelist(G, delimiter=" ", data=True):
+    """Generate a single line of the bipartite graph G in edge list format.
+
+    Parameters
+    ----------
+    G : NetworkX graph
+       The graph is assumed to have node attribute `part` set to 0,1 representing
+       the two graph parts
+
+    delimiter : string, optional
+       Separator for node labels
+
+    data : bool or list of keys
+       If False generate no edge data.  If True use a dictionary
+       representation of edge data.  If a list of keys use a list of data
+       values corresponding to the keys.
+
+    Returns
+    -------
+    lines : string
+        Lines of data in adjlist format.
+
+    Examples
+    --------
+    >>> from networkx.algorithms import bipartite
+    >>> G = nx.path_graph(4)
+    >>> G.add_nodes_from([0, 2], bipartite=0)
+    >>> G.add_nodes_from([1, 3], bipartite=1)
+    >>> G[1][2]["weight"] = 3
+    >>> G[2][3]["capacity"] = 12
+    >>> for line in bipartite.generate_edgelist(G, data=False):
+    ...     print(line)
+    0 1
+    2 1
+    2 3
+
+    >>> for line in bipartite.generate_edgelist(G):
+    ...     print(line)
+    0 1 {}
+    2 1 {'weight': 3}
+    2 3 {'capacity': 12}
+
+    >>> for line in bipartite.generate_edgelist(G, data=["weight"]):
+    ...     print(line)
+    0 1
+    2 1 3
+    2 3
+    """
+    try:
+        part0 = [n for n, d in G.nodes.items() if d["bipartite"] == 0]
+    except BaseException as err:
+        raise AttributeError("Missing node attribute `bipartite`") from err
+    if data is True or data is False:
+        for n in part0:
+            for edge in G.edges(n, data=data):
+                yield delimiter.join(map(str, edge))
+    else:
+        for n in part0:
+            for u, v, d in G.edges(n, data=True):
+                edge = [u, v]
+                try:
+                    edge.extend(d[k] for k in data)
+                except KeyError:
+                    pass  # missing data for this edge, should warn?
+                yield delimiter.join(map(str, edge))
+
+
+@nx._dispatch(name="bipartite_parse_edgelist", graphs=None)
+def parse_edgelist(
+    lines, comments="#", delimiter=None, create_using=None, nodetype=None, data=True
+):
+    """Parse lines of an edge list representation of a bipartite graph.
+
+    Parameters
+    ----------
+    lines : list or iterator of strings
+        Input data in edgelist format
+    comments : string, optional
+       Marker for comment lines
+    delimiter : string, optional
+       Separator for node labels
+    create_using: NetworkX graph container, optional
+       Use given NetworkX graph for holding nodes or edges.
+    nodetype : Python type, optional
+       Convert nodes to this type.
+    data : bool or list of (label,type) tuples
+       If False generate no edge data or if True use a dictionary
+       representation of edge data or a list tuples specifying dictionary
+       key names and types for edge data.
+
+    Returns
+    -------
+    G: NetworkX Graph
+        The bipartite graph corresponding to lines
+
+    Examples
+    --------
+    Edgelist with no data:
+
+    >>> from networkx.algorithms import bipartite
+    >>> lines = ["1 2", "2 3", "3 4"]
+    >>> G = bipartite.parse_edgelist(lines, nodetype=int)
+    >>> sorted(G.nodes())
+    [1, 2, 3, 4]
+    >>> sorted(G.nodes(data=True))
+    [(1, {'bipartite': 0}), (2, {'bipartite': 0}), (3, {'bipartite': 0}), (4, {'bipartite': 1})]
+    >>> sorted(G.edges())
+    [(1, 2), (2, 3), (3, 4)]
+
+    Edgelist with data in Python dictionary representation:
+
+    >>> lines = ["1 2 {'weight':3}", "2 3 {'weight':27}", "3 4 {'weight':3.0}"]
+    >>> G = bipartite.parse_edgelist(lines, nodetype=int)
+    >>> sorted(G.nodes())
+    [1, 2, 3, 4]
+    >>> sorted(G.edges(data=True))
+    [(1, 2, {'weight': 3}), (2, 3, {'weight': 27}), (3, 4, {'weight': 3.0})]
+
+    Edgelist with data in a list:
+
+    >>> lines = ["1 2 3", "2 3 27", "3 4 3.0"]
+    >>> G = bipartite.parse_edgelist(lines, nodetype=int, data=(("weight", float),))
+    >>> sorted(G.nodes())
+    [1, 2, 3, 4]
+    >>> sorted(G.edges(data=True))
+    [(1, 2, {'weight': 3.0}), (2, 3, {'weight': 27.0}), (3, 4, {'weight': 3.0})]
+
+    See Also
+    --------
+    """
+    from ast import literal_eval
+
+    G = nx.empty_graph(0, create_using)
+    for line in lines:
+        p = line.find(comments)
+        if p >= 0:
+            line = line[:p]
+        if not len(line):
+            continue
+        # split line, should have 2 or more
+        s = line.strip().split(delimiter)
+        if len(s) < 2:
+            continue
+        u = s.pop(0)
+        v = s.pop(0)
+        d = s
+        if nodetype is not None:
+            try:
+                u = nodetype(u)
+                v = nodetype(v)
+            except BaseException as err:
+                raise TypeError(
+                    f"Failed to convert nodes {u},{v} " f"to type {nodetype}."
+                ) from err
+
+        if len(d) == 0 or data is False:
+            # no data or data type specified
+            edgedata = {}
+        elif data is True:
+            # no edge types specified
+            try:  # try to evaluate as dictionary
+                edgedata = dict(literal_eval(" ".join(d)))
+            except BaseException as err:
+                raise TypeError(
+                    f"Failed to convert edge data ({d})" f"to dictionary."
+                ) from err
+        else:
+            # convert edge data to dictionary with specified keys and type
+            if len(d) != len(data):
+                raise IndexError(
+                    f"Edge data {d} and data_keys {data} are not the same length"
+                )
+            edgedata = {}
+            for (edge_key, edge_type), edge_value in zip(data, d):
+                try:
+                    edge_value = edge_type(edge_value)
+                except BaseException as err:
+                    raise TypeError(
+                        f"Failed to convert {edge_key} data "
+                        f"{edge_value} to type {edge_type}."
+                    ) from err
+                edgedata.update({edge_key: edge_value})
+        G.add_node(u, bipartite=0)
+        G.add_node(v, bipartite=1)
+        G.add_edge(u, v, **edgedata)
+    return G
+
+
+@open_file(0, mode="rb")
+@nx._dispatch(name="bipartite_read_edgelist", graphs=None)
+def read_edgelist(
+    path,
+    comments="#",
+    delimiter=None,
+    create_using=None,
+    nodetype=None,
+    data=True,
+    edgetype=None,
+    encoding="utf-8",
+):
+    """Read a bipartite graph from a list of edges.
+
+    Parameters
+    ----------
+    path : file or string
+       File or filename to read. If a file is provided, it must be
+       opened in 'rb' mode.
+       Filenames ending in .gz or .bz2 will be uncompressed.
+    comments : string, optional
+       The character used to indicate the start of a comment.
+    delimiter : string, optional
+       The string used to separate values.  The default is whitespace.
+    create_using : Graph container, optional,
+       Use specified container to build graph.  The default is networkx.Graph,
+       an undirected graph.
+    nodetype : int, float, str, Python type, optional
+       Convert node data from strings to specified type
+    data : bool or list of (label,type) tuples
+       Tuples specifying dictionary key names and types for edge data
+    edgetype : int, float, str, Python type, optional OBSOLETE
+       Convert edge data from strings to specified type and use as 'weight'
+    encoding: string, optional
+       Specify which encoding to use when reading file.
+
+    Returns
+    -------
+    G : graph
+       A networkx Graph or other type specified with create_using
+
+    Examples
+    --------
+    >>> from networkx.algorithms import bipartite
+    >>> G = nx.path_graph(4)
+    >>> G.add_nodes_from([0, 2], bipartite=0)
+    >>> G.add_nodes_from([1, 3], bipartite=1)
+    >>> bipartite.write_edgelist(G, "test.edgelist")
+    >>> G = bipartite.read_edgelist("test.edgelist")
+
+    >>> fh = open("test.edgelist", "rb")
+    >>> G = bipartite.read_edgelist(fh)
+    >>> fh.close()
+
+    >>> G = bipartite.read_edgelist("test.edgelist", nodetype=int)
+
+    Edgelist with data in a list:
+
+    >>> textline = "1 2 3"
+    >>> fh = open("test.edgelist", "w")
+    >>> d = fh.write(textline)
+    >>> fh.close()
+    >>> G = bipartite.read_edgelist(
+    ...     "test.edgelist", nodetype=int, data=(("weight", float),)
+    ... )
+    >>> list(G)
+    [1, 2]
+    >>> list(G.edges(data=True))
+    [(1, 2, {'weight': 3.0})]
+
+    See parse_edgelist() for more examples of formatting.
+
+    See Also
+    --------
+    parse_edgelist
+
+    Notes
+    -----
+    Since nodes must be hashable, the function nodetype must return hashable
+    types (e.g. int, float, str, frozenset - or tuples of those, etc.)
+    """
+    lines = (line.decode(encoding) for line in path)
+    return parse_edgelist(
+        lines,
+        comments=comments,
+        delimiter=delimiter,
+        create_using=create_using,
+        nodetype=nodetype,
+        data=data,
+    )

tuning-competition-baseline/.venv/lib/python3.11/site-packages/networkx/algorithms/bipartite/generators.py

@@ -0,0 +1,603 @@
+"""
+Generators and functions for bipartite graphs.
+"""
+import math
+import numbers
+from functools import reduce
+
+import networkx as nx
+from networkx.utils import nodes_or_number, py_random_state
+
+__all__ = [
+    "configuration_model",
+    "havel_hakimi_graph",
+    "reverse_havel_hakimi_graph",
+    "alternating_havel_hakimi_graph",
+    "preferential_attachment_graph",
+    "random_graph",
+    "gnmk_random_graph",
+    "complete_bipartite_graph",
+]
+
+
+@nodes_or_number([0, 1])
+@nx._dispatch(graphs=None)
+def complete_bipartite_graph(n1, n2, create_using=None):
+    """Returns the complete bipartite graph `K_{n_1,n_2}`.
+
+    The graph is composed of two partitions with nodes 0 to (n1 - 1)
+    in the first and nodes n1 to (n1 + n2 - 1) in the second.
+    Each node in the first is connected to each node in the second.
+
+    Parameters
+    ----------
+    n1, n2 : integer or iterable container of nodes
+        If integers, nodes are from `range(n1)` and `range(n1, n1 + n2)`.
+        If a container, the elements are the nodes.
+    create_using : NetworkX graph instance, (default: nx.Graph)
+       Return graph of this type.
+
+    Notes
+    -----
+    Nodes are the integers 0 to `n1 + n2 - 1` unless either n1 or n2 are
+    containers of nodes. If only one of n1 or n2 are integers, that
+    integer is replaced by `range` of that integer.
+
+    The nodes are assigned the attribute 'bipartite' with the value 0 or 1
+    to indicate which bipartite set the node belongs to.
+
+    This function is not imported in the main namespace.
+    To use it use nx.bipartite.complete_bipartite_graph
+    """
+    G = nx.empty_graph(0, create_using)
+    if G.is_directed():
+        raise nx.NetworkXError("Directed Graph not supported")
+
+    n1, top = n1
+    n2, bottom = n2
+    if isinstance(n1, numbers.Integral) and isinstance(n2, numbers.Integral):
+        bottom = [n1 + i for i in bottom]
+    G.add_nodes_from(top, bipartite=0)
+    G.add_nodes_from(bottom, bipartite=1)
+    if len(G) != len(top) + len(bottom):
+        raise nx.NetworkXError("Inputs n1 and n2 must contain distinct nodes")
+    G.add_edges_from((u, v) for u in top for v in bottom)
+    G.graph["name"] = f"complete_bipartite_graph({n1}, {n2})"
+    return G
+
+
+@py_random_state(3)
+@nx._dispatch(name="bipartite_configuration_model", graphs=None)
+def configuration_model(aseq, bseq, create_using=None, seed=None):
+    """Returns a random bipartite graph from two given degree sequences.
+
+    Parameters
+    ----------
+    aseq : list
+       Degree sequence for node set A.
+    bseq : list
+       Degree sequence for node set B.
+    create_using : NetworkX graph instance, optional
+       Return graph of this type.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    The graph is composed of two partitions. Set A has nodes 0 to
+    (len(aseq) - 1) and set B has nodes len(aseq) to (len(bseq) - 1).
+    Nodes from set A are connected to nodes in set B by choosing
+    randomly from the possible free stubs, one in A and one in B.
+
+    Notes
+    -----
+    The sum of the two sequences must be equal: sum(aseq)=sum(bseq)
+    If no graph type is specified use MultiGraph with parallel edges.
+    If you want a graph with no parallel edges use create_using=Graph()
+    but then the resulting degree sequences might not be exact.
+
+    The nodes are assigned the attribute 'bipartite' with the value 0 or 1
+    to indicate which bipartite set the node belongs to.
+
+    This function is not imported in the main namespace.
+    To use it use nx.bipartite.configuration_model
+    """
+    G = nx.empty_graph(0, create_using, default=nx.MultiGraph)
+    if G.is_directed():
+        raise nx.NetworkXError("Directed Graph not supported")
+
+    # length and sum of each sequence
+    lena = len(aseq)
+    lenb = len(bseq)
+    suma = sum(aseq)
+    sumb = sum(bseq)
+
+    if not suma == sumb:
+        raise nx.NetworkXError(
+            f"invalid degree sequences, sum(aseq)!=sum(bseq),{suma},{sumb}"
+        )
+
+    G = _add_nodes_with_bipartite_label(G, lena, lenb)
+
+    if len(aseq) == 0 or max(aseq) == 0:
+        return G  # done if no edges
+
+    # build lists of degree-repeated vertex numbers
+    stubs = [[v] * aseq[v] for v in range(lena)]
+    astubs = [x for subseq in stubs for x in subseq]
+
+    stubs = [[v] * bseq[v - lena] for v in range(lena, lena + lenb)]
+    bstubs = [x for subseq in stubs for x in subseq]
+
+    # shuffle lists
+    seed.shuffle(astubs)
+    seed.shuffle(bstubs)
+
+    G.add_edges_from([astubs[i], bstubs[i]] for i in range(suma))
+
+    G.name = "bipartite_configuration_model"
+    return G
+
+
+@nx._dispatch(name="bipartite_havel_hakimi_graph", graphs=None)
+def havel_hakimi_graph(aseq, bseq, create_using=None):
+    """Returns a bipartite graph from two given degree sequences using a
+    Havel-Hakimi style construction.
+
+    The graph is composed of two partitions. Set A has nodes 0 to
+    (len(aseq) - 1) and set B has nodes len(aseq) to (len(bseq) - 1).
+    Nodes from the set A are connected to nodes in the set B by
+    connecting the highest degree nodes in set A to the highest degree
+    nodes in set B until all stubs are connected.
+
+    Parameters
+    ----------
+    aseq : list
+       Degree sequence for node set A.
+    bseq : list
+       Degree sequence for node set B.
+    create_using : NetworkX graph instance, optional
+       Return graph of this type.
+
+    Notes
+    -----
+    The sum of the two sequences must be equal: sum(aseq)=sum(bseq)
+    If no graph type is specified use MultiGraph with parallel edges.
+    If you want a graph with no parallel edges use create_using=Graph()
+    but then the resulting degree sequences might not be exact.
+
+    The nodes are assigned the attribute 'bipartite' with the value 0 or 1
+    to indicate which bipartite set the node belongs to.
+
+    This function is not imported in the main namespace.
+    To use it use nx.bipartite.havel_hakimi_graph
+    """
+    G = nx.empty_graph(0, create_using, default=nx.MultiGraph)
+    if G.is_directed():
+        raise nx.NetworkXError("Directed Graph not supported")
+
+    # length of the each sequence
+    naseq = len(aseq)
+    nbseq = len(bseq)
+
+    suma = sum(aseq)
+    sumb = sum(bseq)
+
+    if not suma == sumb:
+        raise nx.NetworkXError(
+            f"invalid degree sequences, sum(aseq)!=sum(bseq),{suma},{sumb}"
+        )
+
+    G = _add_nodes_with_bipartite_label(G, naseq, nbseq)
+
+    if len(aseq) == 0 or max(aseq) == 0:
+        return G  # done if no edges
+
+    # build list of degree-repeated vertex numbers
+    astubs = [[aseq[v], v] for v in range(naseq)]
+    bstubs = [[bseq[v - naseq], v] for v in range(naseq, naseq + nbseq)]
+    astubs.sort()
+    while astubs:
+        (degree, u) = astubs.pop()  # take of largest degree node in the a set
+        if degree == 0:
+            break  # done, all are zero
+        # connect the source to largest degree nodes in the b set
+        bstubs.sort()
+        for target in bstubs[-degree:]:
+            v = target[1]
+            G.add_edge(u, v)
+            target[0] -= 1  # note this updates bstubs too.
+            if target[0] == 0:
+                bstubs.remove(target)
+
+    G.name = "bipartite_havel_hakimi_graph"
+    return G
+
+
+@nx._dispatch(graphs=None)
+def reverse_havel_hakimi_graph(aseq, bseq, create_using=None):
+    """Returns a bipartite graph from two given degree sequences using a
+    Havel-Hakimi style construction.
+
+    The graph is composed of two partitions. Set A has nodes 0 to
+    (len(aseq) - 1) and set B has nodes len(aseq) to (len(bseq) - 1).
+    Nodes from set A are connected to nodes in the set B by connecting
+    the highest degree nodes in set A to the lowest degree nodes in
+    set B until all stubs are connected.
+
+    Parameters
+    ----------
+    aseq : list
+       Degree sequence for node set A.
+    bseq : list
+       Degree sequence for node set B.
+    create_using : NetworkX graph instance, optional
+       Return graph of this type.
+
+    Notes
+    -----
+    The sum of the two sequences must be equal: sum(aseq)=sum(bseq)
+    If no graph type is specified use MultiGraph with parallel edges.
+    If you want a graph with no parallel edges use create_using=Graph()
+    but then the resulting degree sequences might not be exact.
+
+    The nodes are assigned the attribute 'bipartite' with the value 0 or 1
+    to indicate which bipartite set the node belongs to.
+
+    This function is not imported in the main namespace.
+    To use it use nx.bipartite.reverse_havel_hakimi_graph
+    """
+    G = nx.empty_graph(0, create_using, default=nx.MultiGraph)
+    if G.is_directed():
+        raise nx.NetworkXError("Directed Graph not supported")
+
+    # length of the each sequence
+    lena = len(aseq)
+    lenb = len(bseq)
+    suma = sum(aseq)
+    sumb = sum(bseq)
+
+    if not suma == sumb:
+        raise nx.NetworkXError(
+            f"invalid degree sequences, sum(aseq)!=sum(bseq),{suma},{sumb}"
+        )
+
+    G = _add_nodes_with_bipartite_label(G, lena, lenb)
+
+    if len(aseq) == 0 or max(aseq) == 0:
+        return G  # done if no edges
+
+    # build list of degree-repeated vertex numbers
+    astubs = [[aseq[v], v] for v in range(lena)]
+    bstubs = [[bseq[v - lena], v] for v in range(lena, lena + lenb)]
+    astubs.sort()
+    bstubs.sort()
+    while astubs:
+        (degree, u) = astubs.pop()  # take of largest degree node in the a set
+        if degree == 0:
+            break  # done, all are zero
+        # connect the source to the smallest degree nodes in the b set
+        for target in bstubs[0:degree]:
+            v = target[1]
+            G.add_edge(u, v)
+            target[0] -= 1  # note this updates bstubs too.
+            if target[0] == 0:
+                bstubs.remove(target)
+
+    G.name = "bipartite_reverse_havel_hakimi_graph"
+    return G
+
+
+@nx._dispatch(graphs=None)
+def alternating_havel_hakimi_graph(aseq, bseq, create_using=None):
+    """Returns a bipartite graph from two given degree sequences using
+    an alternating Havel-Hakimi style construction.
+
+    The graph is composed of two partitions. Set A has nodes 0 to
+    (len(aseq) - 1) and set B has nodes len(aseq) to (len(bseq) - 1).
+    Nodes from the set A are connected to nodes in the set B by
+    connecting the highest degree nodes in set A to alternatively the
+    highest and the lowest degree nodes in set B until all stubs are
+    connected.
+
+    Parameters
+    ----------
+    aseq : list
+       Degree sequence for node set A.
+    bseq : list
+       Degree sequence for node set B.
+    create_using : NetworkX graph instance, optional
+       Return graph of this type.
+
+    Notes
+    -----
+    The sum of the two sequences must be equal: sum(aseq)=sum(bseq)
+    If no graph type is specified use MultiGraph with parallel edges.
+    If you want a graph with no parallel edges use create_using=Graph()
+    but then the resulting degree sequences might not be exact.
+
+    The nodes are assigned the attribute 'bipartite' with the value 0 or 1
+    to indicate which bipartite set the node belongs to.
+
+    This function is not imported in the main namespace.
+    To use it use nx.bipartite.alternating_havel_hakimi_graph
+    """
+    G = nx.empty_graph(0, create_using, default=nx.MultiGraph)
+    if G.is_directed():
+        raise nx.NetworkXError("Directed Graph not supported")
+
+    # length of the each sequence
+    naseq = len(aseq)
+    nbseq = len(bseq)
+    suma = sum(aseq)
+    sumb = sum(bseq)
+
+    if not suma == sumb:
+        raise nx.NetworkXError(
+            f"invalid degree sequences, sum(aseq)!=sum(bseq),{suma},{sumb}"
+        )
+
+    G = _add_nodes_with_bipartite_label(G, naseq, nbseq)
+
+    if len(aseq) == 0 or max(aseq) == 0:
+        return G  # done if no edges
+    # build list of degree-repeated vertex numbers
+    astubs = [[aseq[v], v] for v in range(naseq)]
+    bstubs = [[bseq[v - naseq], v] for v in range(naseq, naseq + nbseq)]
+    while astubs:
+        astubs.sort()
+        (degree, u) = astubs.pop()  # take of largest degree node in the a set
+        if degree == 0:
+            break  # done, all are zero
+        bstubs.sort()
+        small = bstubs[0 : degree // 2]  # add these low degree targets
+        large = bstubs[(-degree + degree // 2) :]  # now high degree targets
+        stubs = [x for z in zip(large, small) for x in z]  # combine, sorry
+        if len(stubs) < len(small) + len(large):  # check for zip truncation
+            stubs.append(large.pop())
+        for target in stubs:
+            v = target[1]
+            G.add_edge(u, v)
+            target[0] -= 1  # note this updates bstubs too.
+            if target[0] == 0:
+                bstubs.remove(target)
+
+    G.name = "bipartite_alternating_havel_hakimi_graph"
+    return G
+
+
+@py_random_state(3)
+@nx._dispatch(graphs=None)
+def preferential_attachment_graph(aseq, p, create_using=None, seed=None):
+    """Create a bipartite graph with a preferential attachment model from
+    a given single degree sequence.
+
+    The graph is composed of two partitions. Set A has nodes 0 to
+    (len(aseq) - 1) and set B has nodes starting with node len(aseq).
+    The number of nodes in set B is random.
+
+    Parameters
+    ----------
+    aseq : list
+       Degree sequence for node set A.
+    p :  float
+       Probability that a new bottom node is added.
+    create_using : NetworkX graph instance, optional
+       Return graph of this type.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+
+    References
+    ----------
+    .. [1] Guillaume, J.L. and Latapy, M.,
+       Bipartite graphs as models of complex networks.
+       Physica A: Statistical Mechanics and its Applications,
+       2006, 371(2), pp.795-813.
+    .. [2] Jean-Loup Guillaume and Matthieu Latapy,
+       Bipartite structure of all complex networks,
+       Inf. Process. Lett. 90, 2004, pg. 215-221
+       https://doi.org/10.1016/j.ipl.2004.03.007
+
+    Notes
+    -----
+    The nodes are assigned the attribute 'bipartite' with the value 0 or 1
+    to indicate which bipartite set the node belongs to.
+
+    This function is not imported in the main namespace.
+    To use it use nx.bipartite.preferential_attachment_graph
+    """
+    G = nx.empty_graph(0, create_using, default=nx.MultiGraph)
+    if G.is_directed():
+        raise nx.NetworkXError("Directed Graph not supported")
+
+    if p > 1:
+        raise nx.NetworkXError(f"probability {p} > 1")
+
+    naseq = len(aseq)
+    G = _add_nodes_with_bipartite_label(G, naseq, 0)
+    vv = [[v] * aseq[v] for v in range(naseq)]
+    while vv:
+        while vv[0]:
+            source = vv[0][0]
+            vv[0].remove(source)
+            if seed.random() < p or len(G) == naseq:
+                target = len(G)
+                G.add_node(target, bipartite=1)
+                G.add_edge(source, target)
+            else:
+                bb = [[b] * G.degree(b) for b in range(naseq, len(G))]
+                # flatten the list of lists into a list.
+                bbstubs = reduce(lambda x, y: x + y, bb)
+                # choose preferentially a bottom node.
+                target = seed.choice(bbstubs)
+                G.add_node(target, bipartite=1)
+                G.add_edge(source, target)
+        vv.remove(vv[0])
+    G.name = "bipartite_preferential_attachment_model"
+    return G
+
+
+@py_random_state(3)
+@nx._dispatch(graphs=None)
+def random_graph(n, m, p, seed=None, directed=False):
+    """Returns a bipartite random graph.
+
+    This is a bipartite version of the binomial (Erdős-Rényi) graph.
+    The graph is composed of two partitions. Set A has nodes 0 to
+    (n - 1) and set B has nodes n to (n + m - 1).
+
+    Parameters
+    ----------
+    n : int
+        The number of nodes in the first bipartite set.
+    m : int
+        The number of nodes in the second bipartite set.
+    p : float
+        Probability for edge creation.
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+    directed : bool, optional (default=False)
+        If True return a directed graph
+
+    Notes
+    -----
+    The bipartite random graph algorithm chooses each of the n*m (undirected)
+    or 2*nm (directed) possible edges with probability p.
+
+    This algorithm is $O(n+m)$ where $m$ is the expected number of edges.
+
+    The nodes are assigned the attribute 'bipartite' with the value 0 or 1
+    to indicate which bipartite set the node belongs to.
+
+    This function is not imported in the main namespace.
+    To use it use nx.bipartite.random_graph
+
+    See Also
+    --------
+    gnp_random_graph, configuration_model
+
+    References
+    ----------
+    .. [1] Vladimir Batagelj and Ulrik Brandes,
+       "Efficient generation of large random networks",
+       Phys. Rev. E, 71, 036113, 2005.
+    """
+    G = nx.Graph()
+    G = _add_nodes_with_bipartite_label(G, n, m)
+    if directed:
+        G = nx.DiGraph(G)
+    G.name = f"fast_gnp_random_graph({n},{m},{p})"
+
+    if p <= 0:
+        return G
+    if p >= 1:
+        return nx.complete_bipartite_graph(n, m)
+
+    lp = math.log(1.0 - p)
+
+    v = 0
+    w = -1
+    while v < n:
+        lr = math.log(1.0 - seed.random())
+        w = w + 1 + int(lr / lp)
+        while w >= m and v < n:
+            w = w - m
+            v = v + 1
+        if v < n:
+            G.add_edge(v, n + w)
+
+    if directed:
+        # use the same algorithm to
+        # add edges from the "m" to "n" set
+        v = 0
+        w = -1
+        while v < n:
+            lr = math.log(1.0 - seed.random())
+            w = w + 1 + int(lr / lp)
+            while w >= m and v < n:
+                w = w - m
+                v = v + 1
+            if v < n:
+                G.add_edge(n + w, v)
+
+    return G
+
+
+@py_random_state(3)
+@nx._dispatch(graphs=None)
+def gnmk_random_graph(n, m, k, seed=None, directed=False):
+    """Returns a random bipartite graph G_{n,m,k}.
+
+    Produces a bipartite graph chosen randomly out of the set of all graphs
+    with n top nodes, m bottom nodes, and k edges.
+    The graph is composed of two sets of nodes.
+    Set A has nodes 0 to (n - 1) and set B has nodes n to (n + m - 1).
+
+    Parameters
+    ----------
+    n : int
+        The number of nodes in the first bipartite set.
+    m : int
+        The number of nodes in the second bipartite set.
+    k : int
+        The number of edges
+    seed : integer, random_state, or None (default)
+        Indicator of random number generation state.
+        See :ref:`Randomness<randomness>`.
+    directed : bool, optional (default=False)
+        If True return a directed graph
+
+    Examples
+    --------
+    from nx.algorithms import bipartite
+    G = bipartite.gnmk_random_graph(10,20,50)
+
+    See Also
+    --------
+    gnm_random_graph
+
+    Notes
+    -----
+    If k > m * n then a complete bipartite graph is returned.
+
+    This graph is a bipartite version of the `G_{nm}` random graph model.
+
+    The nodes are assigned the attribute 'bipartite' with the value 0 or 1
+    to indicate which bipartite set the node belongs to.
+
+    This function is not imported in the main namespace.
+    To use it use nx.bipartite.gnmk_random_graph
+    """
+    G = nx.Graph()
+    G = _add_nodes_with_bipartite_label(G, n, m)
+    if directed:
+        G = nx.DiGraph(G)
+    G.name = f"bipartite_gnm_random_graph({n},{m},{k})"
+    if n == 1 or m == 1:
+        return G
+    max_edges = n * m  # max_edges for bipartite networks
+    if k >= max_edges:  # Maybe we should raise an exception here
+        return nx.complete_bipartite_graph(n, m, create_using=G)
+
+    top = [n for n, d in G.nodes(data=True) if d["bipartite"] == 0]
+    bottom = list(set(G) - set(top))
+    edge_count = 0
+    while edge_count < k:
+        # generate random edge,u,v
+        u = seed.choice(top)
+        v = seed.choice(bottom)
+        if v in G[u]:
+            continue
+        else:
+            G.add_edge(u, v)
+            edge_count += 1
+    return G
+
+
+def _add_nodes_with_bipartite_label(G, lena, lenb):
+    G.add_nodes_from(range(lena + lenb))
+    b = dict(zip(range(lena), [0] * lena))
+    b.update(dict(zip(range(lena, lena + lenb), [1] * lenb)))
+    nx.set_node_attributes(G, b, "bipartite")
+    return G

tuning-competition-baseline/.venv/lib/python3.11/site-packages/networkx/algorithms/bipartite/matrix.py

@@ -0,0 +1,167 @@
+"""
+====================
+Biadjacency matrices
+====================
+"""
+import itertools
+
+import networkx as nx
+from networkx.convert_matrix import _generate_weighted_edges
+
+__all__ = ["biadjacency_matrix", "from_biadjacency_matrix"]
+
+
+@nx._dispatch(edge_attrs="weight")
+def biadjacency_matrix(
+    G, row_order, column_order=None, dtype=None, weight="weight", format="csr"
+):
+    r"""Returns the biadjacency matrix of the bipartite graph G.
+
+    Let `G = (U, V, E)` be a bipartite graph with node sets
+    `U = u_{1},...,u_{r}` and `V = v_{1},...,v_{s}`. The biadjacency
+    matrix [1]_ is the `r` x `s` matrix `B` in which `b_{i,j} = 1`
+    if, and only if, `(u_i, v_j) \in E`. If the parameter `weight` is
+    not `None` and matches the name of an edge attribute, its value is
+    used instead of 1.
+
+    Parameters
+    ----------
+    G : graph
+       A NetworkX graph
+
+    row_order : list of nodes
+       The rows of the matrix are ordered according to the list of nodes.
+
+    column_order : list, optional
+       The columns of the matrix are ordered according to the list of nodes.
+       If column_order is None, then the ordering of columns is arbitrary.
+
+    dtype : NumPy data-type, optional
+        A valid NumPy dtype used to initialize the array. If None, then the
+        NumPy default is used.
+
+    weight : string or None, optional (default='weight')
+       The edge data key used to provide each value in the matrix.
+       If None, then each edge has weight 1.
+
+    format : str in {'bsr', 'csr', 'csc', 'coo', 'lil', 'dia', 'dok'}
+        The type of the matrix to be returned (default 'csr').  For
+        some algorithms different implementations of sparse matrices
+        can perform better.  See [2]_ for details.
+
+    Returns
+    -------
+    M : SciPy sparse array
+        Biadjacency matrix representation of the bipartite graph G.
+
+    Notes
+    -----
+    No attempt is made to check that the input graph is bipartite.
+
+    For directed bipartite graphs only successors are considered as neighbors.
+    To obtain an adjacency matrix with ones (or weight values) for both
+    predecessors and successors you have to generate two biadjacency matrices
+    where the rows of one of them are the columns of the other, and then add
+    one to the transpose of the other.
+
+    See Also
+    --------
+    adjacency_matrix
+    from_biadjacency_matrix
+
+    References
+    ----------
+    .. [1] https://en.wikipedia.org/wiki/Adjacency_matrix#Adjacency_matrix_of_a_bipartite_graph
+    .. [2] Scipy Dev. References, "Sparse Matrices",
+       https://docs.scipy.org/doc/scipy/reference/sparse.html
+    """
+    import scipy as sp
+
+    nlen = len(row_order)
+    if nlen == 0:
+        raise nx.NetworkXError("row_order is empty list")
+    if len(row_order) != len(set(row_order)):
+        msg = "Ambiguous ordering: `row_order` contained duplicates."
+        raise nx.NetworkXError(msg)
+    if column_order is None:
+        column_order = list(set(G) - set(row_order))
+    mlen = len(column_order)
+    if len(column_order) != len(set(column_order)):
+        msg = "Ambiguous ordering: `column_order` contained duplicates."
+        raise nx.NetworkXError(msg)
+
+    row_index = dict(zip(row_order, itertools.count()))
+    col_index = dict(zip(column_order, itertools.count()))
+
+    if G.number_of_edges() == 0:
+        row, col, data = [], [], []
+    else:
+        row, col, data = zip(
+            *(
+                (row_index[u], col_index[v], d.get(weight, 1))
+                for u, v, d in G.edges(row_order, data=True)
+                if u in row_index and v in col_index
+            )
+        )
+    A = sp.sparse.coo_array((data, (row, col)), shape=(nlen, mlen), dtype=dtype)
+    try:
+        return A.asformat(format)
+    except ValueError as err:
+        raise nx.NetworkXError(f"Unknown sparse array format: {format}") from err
+
+
+@nx._dispatch(graphs=None)
+def from_biadjacency_matrix(A, create_using=None, edge_attribute="weight"):
+    r"""Creates a new bipartite graph from a biadjacency matrix given as a
+    SciPy sparse array.
+
+    Parameters
+    ----------
+    A: scipy sparse array
+      A biadjacency matrix representation of a graph
+
+    create_using: NetworkX graph
+       Use specified graph for result.  The default is Graph()
+
+    edge_attribute: string
+       Name of edge attribute to store matrix numeric value. The data will
+       have the same type as the matrix entry (int, float, (real,imag)).
+
+    Notes
+    -----
+    The nodes are labeled with the attribute `bipartite` set to an integer
+    0 or 1 representing membership in part 0 or part 1 of the bipartite graph.
+
+    If `create_using` is an instance of :class:`networkx.MultiGraph` or
+    :class:`networkx.MultiDiGraph` and the entries of `A` are of
+    type :class:`int`, then this function returns a multigraph (of the same
+    type as `create_using`) with parallel edges. In this case, `edge_attribute`
+    will be ignored.
+
+    See Also
+    --------
+    biadjacency_matrix
+    from_numpy_array
+
+    References
+    ----------
+    [1] https://en.wikipedia.org/wiki/Adjacency_matrix#Adjacency_matrix_of_a_bipartite_graph
+    """
+    G = nx.empty_graph(0, create_using)
+    n, m = A.shape
+    # Make sure we get even the isolated nodes of the graph.
+    G.add_nodes_from(range(n), bipartite=0)
+    G.add_nodes_from(range(n, n + m), bipartite=1)
+    # Create an iterable over (u, v, w) triples and for each triple, add an
+    # edge from u to v with weight w.
+    triples = ((u, n + v, d) for (u, v, d) in _generate_weighted_edges(A))
+    # If the entries in the adjacency matrix are integers and the graph is a
+    # multigraph, then create parallel edges, each with weight 1, for each
+    # entry in the adjacency matrix. Otherwise, create one edge for each
+    # positive entry in the adjacency matrix and set the weight of that edge to
+    # be the entry in the matrix.
+    if A.dtype.kind in ("i", "u") and G.is_multigraph():
+        chain = itertools.chain.from_iterable
+        triples = chain(((u, v, 1) for d in range(w)) for (u, v, w) in triples)
+    G.add_weighted_edges_from(triples, weight=edge_attribute)
+    return G

tuning-competition-baseline/.venv/lib/python3.11/site-packages/networkx/algorithms/flow/tests/gw1.gpickle.bz2

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6f79f0e90fa4c51ec79165f15963e1ed89477576e06bcaa67ae622c260411931
+size 42248

tuning-competition-baseline/.venv/lib/python3.11/site-packages/networkx/algorithms/traversal/tests/test_edgebfs.py

@@ -0,0 +1,147 @@
+import pytest
+
+import networkx as nx
+from networkx.algorithms.traversal.edgedfs import FORWARD, REVERSE
+
+
+class TestEdgeBFS:
+    @classmethod
+    def setup_class(cls):
+        cls.nodes = [0, 1, 2, 3]
+        cls.edges = [(0, 1), (1, 0), (1, 0), (2, 0), (2, 1), (3, 1)]
+
+    def test_empty(self):
+        G = nx.Graph()
+        edges = list(nx.edge_bfs(G))
+        assert edges == []
+
+    def test_graph_single_source(self):
+        G = nx.Graph(self.edges)
+        G.add_edge(4, 5)
+        x = list(nx.edge_bfs(G, [0]))
+        x_ = [(0, 1), (0, 2), (1, 2), (1, 3)]
+        assert x == x_
+
+    def test_graph(self):
+        G = nx.Graph(self.edges)
+        x = list(nx.edge_bfs(G, self.nodes))
+        x_ = [(0, 1), (0, 2), (1, 2), (1, 3)]
+        assert x == x_
+
+    def test_digraph(self):
+        G = nx.DiGraph(self.edges)
+        x = list(nx.edge_bfs(G, self.nodes))
+        x_ = [(0, 1), (1, 0), (2, 0), (2, 1), (3, 1)]
+        assert x == x_
+
+    def test_digraph_orientation_invalid(self):
+        G = nx.DiGraph(self.edges)
+        edge_iterator = nx.edge_bfs(G, self.nodes, orientation="hello")
+        pytest.raises(nx.NetworkXError, list, edge_iterator)
+
+    def test_digraph_orientation_none(self):
+        G = nx.DiGraph(self.edges)
+        x = list(nx.edge_bfs(G, self.nodes, orientation=None))
+        x_ = [(0, 1), (1, 0), (2, 0), (2, 1), (3, 1)]
+        assert x == x_
+
+    def test_digraph_orientation_original(self):
+        G = nx.DiGraph(self.edges)
+        x = list(nx.edge_bfs(G, self.nodes, orientation="original"))
+        x_ = [
+            (0, 1, FORWARD),
+            (1, 0, FORWARD),
+            (2, 0, FORWARD),
+            (2, 1, FORWARD),
+            (3, 1, FORWARD),
+        ]
+        assert x == x_
+
+    def test_digraph2(self):
+        G = nx.DiGraph()
+        nx.add_path(G, range(4))
+        x = list(nx.edge_bfs(G, [0]))
+        x_ = [(0, 1), (1, 2), (2, 3)]
+        assert x == x_
+
+    def test_digraph_rev(self):
+        G = nx.DiGraph(self.edges)
+        x = list(nx.edge_bfs(G, self.nodes, orientation="reverse"))
+        x_ = [
+            (1, 0, REVERSE),
+            (2, 0, REVERSE),
+            (0, 1, REVERSE),
+            (2, 1, REVERSE),
+            (3, 1, REVERSE),
+        ]
+        assert x == x_
+
+    def test_digraph_rev2(self):
+        G = nx.DiGraph()
+        nx.add_path(G, range(4))
+        x = list(nx.edge_bfs(G, [3], orientation="reverse"))
+        x_ = [(2, 3, REVERSE), (1, 2, REVERSE), (0, 1, REVERSE)]
+        assert x == x_
+
+    def test_multigraph(self):
+        G = nx.MultiGraph(self.edges)
+        x = list(nx.edge_bfs(G, self.nodes))
+        x_ = [(0, 1, 0), (0, 1, 1), (0, 1, 2), (0, 2, 0), (1, 2, 0), (1, 3, 0)]
+        # This is an example of where hash randomization can break.
+        # There are 3! * 2 alternative outputs, such as:
+        #    [(0, 1, 1), (1, 0, 0), (0, 1, 2), (1, 3, 0), (1, 2, 0)]
+        # But note, the edges (1,2,0) and (1,3,0) always follow the (0,1,k)
+        # edges. So the algorithm only guarantees a partial order. A total
+        # order is guaranteed only if the graph data structures are ordered.
+        assert x == x_
+
+    def test_multidigraph(self):
+        G = nx.MultiDiGraph(self.edges)
+        x = list(nx.edge_bfs(G, self.nodes))
+        x_ = [(0, 1, 0), (1, 0, 0), (1, 0, 1), (2, 0, 0), (2, 1, 0), (3, 1, 0)]
+        assert x == x_
+
+    def test_multidigraph_rev(self):
+        G = nx.MultiDiGraph(self.edges)
+        x = list(nx.edge_bfs(G, self.nodes, orientation="reverse"))
+        x_ = [
+            (1, 0, 0, REVERSE),
+            (1, 0, 1, REVERSE),
+            (2, 0, 0, REVERSE),
+            (0, 1, 0, REVERSE),
+            (2, 1, 0, REVERSE),
+            (3, 1, 0, REVERSE),
+        ]
+        assert x == x_
+
+    def test_digraph_ignore(self):
+        G = nx.DiGraph(self.edges)
+        x = list(nx.edge_bfs(G, self.nodes, orientation="ignore"))
+        x_ = [
+            (0, 1, FORWARD),
+            (1, 0, REVERSE),
+            (2, 0, REVERSE),
+            (2, 1, REVERSE),
+            (3, 1, REVERSE),
+        ]
+        assert x == x_
+
+    def test_digraph_ignore2(self):
+        G = nx.DiGraph()
+        nx.add_path(G, range(4))
+        x = list(nx.edge_bfs(G, [0], orientation="ignore"))
+        x_ = [(0, 1, FORWARD), (1, 2, FORWARD), (2, 3, FORWARD)]
+        assert x == x_
+
+    def test_multidigraph_ignore(self):
+        G = nx.MultiDiGraph(self.edges)
+        x = list(nx.edge_bfs(G, self.nodes, orientation="ignore"))
+        x_ = [
+            (0, 1, 0, FORWARD),
+            (1, 0, 0, REVERSE),
+            (1, 0, 1, REVERSE),
+            (2, 0, 0, REVERSE),
+            (2, 1, 0, REVERSE),
+            (3, 1, 0, REVERSE),
+        ]
+        assert x == x_

tuning-competition-baseline/.venv/lib/python3.11/site-packages/networkx/generators/tests/test_community.py

@@ -0,0 +1,362 @@
+import pytest
+
+import networkx as nx
+
+
+def test_random_partition_graph():
+    G = nx.random_partition_graph([3, 3, 3], 1, 0, seed=42)
+    C = G.graph["partition"]
+    assert C == [{0, 1, 2}, {3, 4, 5}, {6, 7, 8}]
+    assert len(G) == 9
+    assert len(list(G.edges())) == 9
+
+    G = nx.random_partition_graph([3, 3, 3], 0, 1)
+    C = G.graph["partition"]
+    assert C == [{0, 1, 2}, {3, 4, 5}, {6, 7, 8}]
+    assert len(G) == 9
+    assert len(list(G.edges())) == 27
+
+    G = nx.random_partition_graph([3, 3, 3], 1, 0, directed=True)
+    C = G.graph["partition"]
+    assert C == [{0, 1, 2}, {3, 4, 5}, {6, 7, 8}]
+    assert len(G) == 9
+    assert len(list(G.edges())) == 18
+
+    G = nx.random_partition_graph([3, 3, 3], 0, 1, directed=True)
+    C = G.graph["partition"]
+    assert C == [{0, 1, 2}, {3, 4, 5}, {6, 7, 8}]
+    assert len(G) == 9
+    assert len(list(G.edges())) == 54
+
+    G = nx.random_partition_graph([1, 2, 3, 4, 5], 0.5, 0.1)
+    C = G.graph["partition"]
+    assert C == [{0}, {1, 2}, {3, 4, 5}, {6, 7, 8, 9}, {10, 11, 12, 13, 14}]
+    assert len(G) == 15
+
+    rpg = nx.random_partition_graph
+    pytest.raises(nx.NetworkXError, rpg, [1, 2, 3], 1.1, 0.1)
+    pytest.raises(nx.NetworkXError, rpg, [1, 2, 3], -0.1, 0.1)
+    pytest.raises(nx.NetworkXError, rpg, [1, 2, 3], 0.1, 1.1)
+    pytest.raises(nx.NetworkXError, rpg, [1, 2, 3], 0.1, -0.1)
+
+
+def test_planted_partition_graph():
+    G = nx.planted_partition_graph(4, 3, 1, 0, seed=42)
+    C = G.graph["partition"]
+    assert len(C) == 4
+    assert len(G) == 12
+    assert len(list(G.edges())) == 12
+
+    G = nx.planted_partition_graph(4, 3, 0, 1)
+    C = G.graph["partition"]
+    assert len(C) == 4
+    assert len(G) == 12
+    assert len(list(G.edges())) == 54
+
+    G = nx.planted_partition_graph(10, 4, 0.5, 0.1, seed=42)
+    C = G.graph["partition"]
+    assert len(C) == 10
+    assert len(G) == 40
+
+    G = nx.planted_partition_graph(4, 3, 1, 0, directed=True)
+    C = G.graph["partition"]
+    assert len(C) == 4
+    assert len(G) == 12
+    assert len(list(G.edges())) == 24
+
+    G = nx.planted_partition_graph(4, 3, 0, 1, directed=True)
+    C = G.graph["partition"]
+    assert len(C) == 4
+    assert len(G) == 12
+    assert len(list(G.edges())) == 108
+
+    G = nx.planted_partition_graph(10, 4, 0.5, 0.1, seed=42, directed=True)
+    C = G.graph["partition"]
+    assert len(C) == 10
+    assert len(G) == 40
+
+    ppg = nx.planted_partition_graph
+    pytest.raises(nx.NetworkXError, ppg, 3, 3, 1.1, 0.1)
+    pytest.raises(nx.NetworkXError, ppg, 3, 3, -0.1, 0.1)
+    pytest.raises(nx.NetworkXError, ppg, 3, 3, 0.1, 1.1)
+    pytest.raises(nx.NetworkXError, ppg, 3, 3, 0.1, -0.1)
+
+
+def test_relaxed_caveman_graph():
+    G = nx.relaxed_caveman_graph(4, 3, 0)
+    assert len(G) == 12
+    G = nx.relaxed_caveman_graph(4, 3, 1)
+    assert len(G) == 12
+    G = nx.relaxed_caveman_graph(4, 3, 0.5)
+    assert len(G) == 12
+    G = nx.relaxed_caveman_graph(4, 3, 0.5, seed=42)
+    assert len(G) == 12
+
+
+def test_connected_caveman_graph():
+    G = nx.connected_caveman_graph(4, 3)
+    assert len(G) == 12
+
+    G = nx.connected_caveman_graph(1, 5)
+    K5 = nx.complete_graph(5)
+    K5.remove_edge(3, 4)
+    assert nx.is_isomorphic(G, K5)
+
+    # need at least 2 nodes in each clique
+    pytest.raises(nx.NetworkXError, nx.connected_caveman_graph, 4, 1)
+
+
+def test_caveman_graph():
+    G = nx.caveman_graph(4, 3)
+    assert len(G) == 12
+
+    G = nx.caveman_graph(5, 1)
+    E5 = nx.empty_graph(5)
+    assert nx.is_isomorphic(G, E5)
+
+    G = nx.caveman_graph(1, 5)
+    K5 = nx.complete_graph(5)
+    assert nx.is_isomorphic(G, K5)
+
+
+def test_gaussian_random_partition_graph():
+    G = nx.gaussian_random_partition_graph(100, 10, 10, 0.3, 0.01)
+    assert len(G) == 100
+    G = nx.gaussian_random_partition_graph(100, 10, 10, 0.3, 0.01, directed=True)
+    assert len(G) == 100
+    G = nx.gaussian_random_partition_graph(
+        100, 10, 10, 0.3, 0.01, directed=False, seed=42
+    )
+    assert len(G) == 100
+    assert not isinstance(G, nx.DiGraph)
+    G = nx.gaussian_random_partition_graph(
+        100, 10, 10, 0.3, 0.01, directed=True, seed=42
+    )
+    assert len(G) == 100
+    assert isinstance(G, nx.DiGraph)
+    pytest.raises(
+        nx.NetworkXError, nx.gaussian_random_partition_graph, 100, 101, 10, 1, 0
+    )
+    # Test when clusters are likely less than 1
+    G = nx.gaussian_random_partition_graph(10, 0.5, 0.5, 0.5, 0.5, seed=1)
+    assert len(G) == 10
+
+
+def test_ring_of_cliques():
+    for i in range(2, 20, 3):
+        for j in range(2, 20, 3):
+            G = nx.ring_of_cliques(i, j)
+            assert G.number_of_nodes() == i * j
+            if i != 2 or j != 1:
+                expected_num_edges = i * (((j * (j - 1)) // 2) + 1)
+            else:
+                # the edge that already exists cannot be duplicated
+                expected_num_edges = i * (((j * (j - 1)) // 2) + 1) - 1
+            assert G.number_of_edges() == expected_num_edges
+    with pytest.raises(
+        nx.NetworkXError, match="A ring of cliques must have at least two cliques"
+    ):
+        nx.ring_of_cliques(1, 5)
+    with pytest.raises(
+        nx.NetworkXError, match="The cliques must have at least two nodes"
+    ):
+        nx.ring_of_cliques(3, 0)
+
+
+def test_windmill_graph():
+    for n in range(2, 20, 3):
+        for k in range(2, 20, 3):
+            G = nx.windmill_graph(n, k)
+            assert G.number_of_nodes() == (k - 1) * n + 1
+            assert G.number_of_edges() == n * k * (k - 1) / 2
+            assert G.degree(0) == G.number_of_nodes() - 1
+            for i in range(1, G.number_of_nodes()):
+                assert G.degree(i) == k - 1
+    with pytest.raises(
+        nx.NetworkXError, match="A windmill graph must have at least two cliques"
+    ):
+        nx.windmill_graph(1, 3)
+    with pytest.raises(
+        nx.NetworkXError, match="The cliques must have at least two nodes"
+    ):
+        nx.windmill_graph(3, 0)
+
+
+def test_stochastic_block_model():
+    sizes = [75, 75, 300]
+    probs = [[0.25, 0.05, 0.02], [0.05, 0.35, 0.07], [0.02, 0.07, 0.40]]
+    G = nx.stochastic_block_model(sizes, probs, seed=0)
+    C = G.graph["partition"]
+    assert len(C) == 3
+    assert len(G) == 450
+    assert G.size() == 22160
+
+    GG = nx.stochastic_block_model(sizes, probs, range(450), seed=0)
+    assert G.nodes == GG.nodes
+
+    # Test Exceptions
+    sbm = nx.stochastic_block_model
+    badnodelist = list(range(400))  # not enough nodes to match sizes
+    badprobs1 = [[0.25, 0.05, 1.02], [0.05, 0.35, 0.07], [0.02, 0.07, 0.40]]
+    badprobs2 = [[0.25, 0.05, 0.02], [0.05, -0.35, 0.07], [0.02, 0.07, 0.40]]
+    probs_rect1 = [[0.25, 0.05, 0.02], [0.05, -0.35, 0.07]]
+    probs_rect2 = [[0.25, 0.05], [0.05, -0.35], [0.02, 0.07]]
+    asymprobs = [[0.25, 0.05, 0.01], [0.05, -0.35, 0.07], [0.02, 0.07, 0.40]]
+    pytest.raises(nx.NetworkXException, sbm, sizes, badprobs1)
+    pytest.raises(nx.NetworkXException, sbm, sizes, badprobs2)
+    pytest.raises(nx.NetworkXException, sbm, sizes, probs_rect1, directed=True)
+    pytest.raises(nx.NetworkXException, sbm, sizes, probs_rect2, directed=True)
+    pytest.raises(nx.NetworkXException, sbm, sizes, asymprobs, directed=False)
+    pytest.raises(nx.NetworkXException, sbm, sizes, probs, badnodelist)
+    nodelist = [0] + list(range(449))  # repeated node name in nodelist
+    pytest.raises(nx.NetworkXException, sbm, sizes, probs, nodelist)
+
+    # Extra keyword arguments test
+    GG = nx.stochastic_block_model(sizes, probs, seed=0, selfloops=True)
+    assert G.nodes == GG.nodes
+    GG = nx.stochastic_block_model(sizes, probs, selfloops=True, directed=True)
+    assert G.nodes == GG.nodes
+    GG = nx.stochastic_block_model(sizes, probs, seed=0, sparse=False)
+    assert G.nodes == GG.nodes
+
+
+def test_generator():
+    n = 250
+    tau1 = 3
+    tau2 = 1.5
+    mu = 0.1
+    G = nx.LFR_benchmark_graph(
+        n, tau1, tau2, mu, average_degree=5, min_community=20, seed=10
+    )
+    assert len(G) == 250
+    C = {frozenset(G.nodes[v]["community"]) for v in G}
+    assert nx.community.is_partition(G.nodes(), C)
+
+
+def test_invalid_tau1():
+    with pytest.raises(nx.NetworkXError, match="tau2 must be greater than one"):
+        n = 100
+        tau1 = 2
+        tau2 = 1
+        mu = 0.1
+        nx.LFR_benchmark_graph(n, tau1, tau2, mu, min_degree=2)
+
+
+def test_invalid_tau2():
+    with pytest.raises(nx.NetworkXError, match="tau1 must be greater than one"):
+        n = 100
+        tau1 = 1
+        tau2 = 2
+        mu = 0.1
+        nx.LFR_benchmark_graph(n, tau1, tau2, mu, min_degree=2)
+
+
+def test_mu_too_large():
+    with pytest.raises(nx.NetworkXError, match="mu must be in the interval \\[0, 1\\]"):
+        n = 100
+        tau1 = 2
+        tau2 = 2
+        mu = 1.1
+        nx.LFR_benchmark_graph(n, tau1, tau2, mu, min_degree=2)
+
+
+def test_mu_too_small():
+    with pytest.raises(nx.NetworkXError, match="mu must be in the interval \\[0, 1\\]"):
+        n = 100
+        tau1 = 2
+        tau2 = 2
+        mu = -1
+        nx.LFR_benchmark_graph(n, tau1, tau2, mu, min_degree=2)
+
+
+def test_both_degrees_none():
+    with pytest.raises(
+        nx.NetworkXError,
+        match="Must assign exactly one of min_degree and average_degree",
+    ):
+        n = 100
+        tau1 = 2
+        tau2 = 2
+        mu = 1
+        nx.LFR_benchmark_graph(n, tau1, tau2, mu)
+
+
+def test_neither_degrees_none():
+    with pytest.raises(
+        nx.NetworkXError,
+        match="Must assign exactly one of min_degree and average_degree",
+    ):
+        n = 100
+        tau1 = 2
+        tau2 = 2
+        mu = 1
+        nx.LFR_benchmark_graph(n, tau1, tau2, mu, min_degree=2, average_degree=5)
+
+
+def test_max_iters_exceeded():
+    with pytest.raises(
+        nx.ExceededMaxIterations,
+        match="Could not assign communities; try increasing min_community",
+    ):
+        n = 10
+        tau1 = 2
+        tau2 = 2
+        mu = 0.1
+        nx.LFR_benchmark_graph(n, tau1, tau2, mu, min_degree=2, max_iters=10, seed=1)
+
+
+def test_max_deg_out_of_range():
+    with pytest.raises(
+        nx.NetworkXError, match="max_degree must be in the interval \\(0, n\\]"
+    ):
+        n = 10
+        tau1 = 2
+        tau2 = 2
+        mu = 0.1
+        nx.LFR_benchmark_graph(
+            n, tau1, tau2, mu, max_degree=n + 1, max_iters=10, seed=1
+        )
+
+
+def test_max_community():
+    n = 250
+    tau1 = 3
+    tau2 = 1.5
+    mu = 0.1
+    G = nx.LFR_benchmark_graph(
+        n,
+        tau1,
+        tau2,
+        mu,
+        average_degree=5,
+        max_degree=100,
+        min_community=50,
+        max_community=200,
+        seed=10,
+    )
+    assert len(G) == 250
+    C = {frozenset(G.nodes[v]["community"]) for v in G}
+    assert nx.community.is_partition(G.nodes(), C)
+
+
+def test_powerlaw_iterations_exceeded():
+    with pytest.raises(
+        nx.ExceededMaxIterations, match="Could not create power law sequence"
+    ):
+        n = 100
+        tau1 = 2
+        tau2 = 2
+        mu = 1
+        nx.LFR_benchmark_graph(n, tau1, tau2, mu, min_degree=2, max_iters=0)
+
+
+def test_no_scipy_zeta():
+    zeta2 = 1.6449340668482264
+    assert abs(zeta2 - nx.generators.community._hurwitz_zeta(2, 1, 0.0001)) < 0.01
+
+
+def test_generate_min_degree_itr():
+    with pytest.raises(
+        nx.ExceededMaxIterations, match="Could not match average_degree"
+    ):
+        nx.generators.community._generate_min_degree(2, 2, 1, 0.01, 0)