Full Code of benfred/py-spy for AI

master 5e14e32f8d43 cached
73 files
1.8 MB
558.6k tokens
6646 symbols
1 requests
Download .txt
Showing preview only (1,920K chars total). Download the full file or copy to clipboard to get everything.
Repository: benfred/py-spy
Branch: master
Commit: 5e14e32f8d43
Files: 73
Total size: 1.8 MB

Directory structure:
gitextract_n9_1d35r/

├── .cargo/
│   └── config.toml
├── .github/
│   ├── dependabot.yml
│   ├── release-drafter.yml
│   └── workflows/
│       ├── build.yml
│       ├── release-drafter.yml
│       └── update_python_test.yml
├── .gitignore
├── .pre-commit-config.yaml
├── CHANGELOG.md
├── Cargo.toml
├── LICENSE
├── README.md
├── SECURITY.md
├── build.rs
├── ci/
│   ├── Vagrantfile
│   ├── publish_freebsd.sh
│   ├── test_freebsd.sh
│   ├── testdata/
│   │   ├── cython_test.c
│   │   └── cython_test.pyx
│   └── update_python_test_versions.py
├── examples/
│   └── dump_traces.rs
├── generate_bindings.py
├── pyproject.toml
├── setup.cfg
├── src/
│   ├── binary_parser.rs
│   ├── chrometrace.rs
│   ├── config.rs
│   ├── console_viewer.rs
│   ├── coredump.rs
│   ├── cython.rs
│   ├── dump.rs
│   ├── flamegraph.rs
│   ├── lib.rs
│   ├── main.rs
│   ├── native_stack_trace.rs
│   ├── python_bindings/
│   │   ├── mod.rs
│   │   ├── v2_7_15.rs
│   │   ├── v3_10_0.rs
│   │   ├── v3_11_0.rs
│   │   ├── v3_12_0.rs
│   │   ├── v3_13_0.rs
│   │   ├── v3_3_7.rs
│   │   ├── v3_4_8.rs
│   │   ├── v3_5_5.rs
│   │   ├── v3_6_6.rs
│   │   ├── v3_7_0.rs
│   │   ├── v3_8_0.rs
│   │   └── v3_9_5.rs
│   ├── python_data_access.rs
│   ├── python_interpreters.rs
│   ├── python_process_info.rs
│   ├── python_spy.rs
│   ├── python_threading.rs
│   ├── sampler.rs
│   ├── speedscope.rs
│   ├── stack_trace.rs
│   ├── timer.rs
│   ├── utils.rs
│   └── version.rs
└── tests/
    ├── integration_test.py
    ├── integration_test.rs
    └── scripts/
        ├── busyloop.py
        ├── cyrillic.py
        ├── delayed_launch.sh
        ├── local_vars.py
        ├── longsleep.py
        ├── negative_linenumber_offsets.py
        ├── recursive.py
        ├── subprocesses.py
        ├── subprocesses_zombie_child.py
        ├── thread_names.py
        ├── thread_reuse.py
        └── unicode💩.py

================================================
FILE CONTENTS
================================================

================================================
FILE: .cargo/config.toml
================================================
[target.armv7-unknown-linux-gnueabihf]
linker = "arm-linux-gnueabihf-gcc"


================================================
FILE: .github/dependabot.yml
================================================
# Keep GitHub Actions up to date with GitHub's Dependabot...
# https://docs.github.com/en/code-security/dependabot/working-with-dependabot/keeping-your-actions-up-to-date-with-dependabot
# https://docs.github.com/en/code-security/dependabot/dependabot-version-updates/configuration-options-for-the-dependabot.yml-file#package-ecosystem
version: 2
updates:
  - package-ecosystem: github-actions
    directory: /
    groups:
      github-actions:
        patterns:
          - "*" # Group all Actions updates into a single larger pull request
    schedule:
      interval: weekly


================================================
FILE: .github/release-drafter.yml
================================================
categories:
  - title: "⚠ Breaking Changes"
    labels:
      - "breaking"
  - title: "🚀 Features"
    labels:
      - "feature"
      - "enhancement"
  - title: "🐛 Bug Fixes"
    labels:
      - "fix"
      - "bugfix"
      - "bug"
  - title: "📄 Documentation"
    labels:
      - "documentation"
  - title: "🧰 Maintenance"
    label:
      - "chore"
      - "ci"
      - "dependencies"

exclude-labels:
  - "skip-changelog"

change-template: "- $TITLE @$AUTHOR (#$NUMBER)"
change-title-escapes: '\<*_&' # You can add # and @ to disable mentions, and add ` to disable code blocks.
version-resolver:
  major:
    labels:
      - "major"
  minor:
    labels:
      - "minor"
  patch:
    labels:
      - "patch"
  default: patch
template: |
  ## Changes

  $CHANGES


================================================
FILE: .github/workflows/build.yml
================================================
name: Build

on:
  workflow_dispatch:
  push:
    branches: [master]
    tags:
      - v*
  pull_request:
    branches: [master]

env:
  CARGO_TERM_COLOR: always

jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v5
      - uses: actions/setup-python@v5
        with:
          python-version: 3.11
      - uses: pre-commit/action@v3.0.1

  build:
    runs-on: ${{ matrix.os }}
    needs: [lint]
    strategy:
      fail-fast: false
      matrix:
        os: [ubuntu-latest, windows-latest, macos-latest]
    steps:
      - uses: actions/checkout@v5
      - uses: Swatinem/rust-cache@v2
      - name: Install Dependencies
        run: sudo apt install libunwind-dev
        if: runner.os == 'Linux'
      - uses: actions/setup-python@v5
        with:
          python-version: 3.9
      - name: Build
        run: cargo build --release --verbose --examples
      - uses: actions/setup-python@v5
        with:
          python-version: 3.9
      - name: Install optional numpy dependency
        run: pip install numpy>=2
      - name: Test
        id: test
        continue-on-error: true
        run: cargo test --release
      - name: Test (retry#1)
        id: test1
        run: cargo test --release
        if: steps.test.outcome=='failure'
        continue-on-error: true
      - name: Test (retry#2)
        run: cargo test --release
        if: steps.test1.outcome=='failure'
      - name: Build Wheel
        run: |
          pip install --upgrade maturin
          maturin build --release -o dist --all-features
        if: runner.os == 'Windows'
      - name: Build Wheel - universal2
        env:
          DEVELOPER_DIR: /Applications/Xcode.app/Contents/Developer
          SDKROOT: /Applications/Xcode.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk
          MACOSX_DEPLOYMENT_TARGET: 10.9
        run: |
          rustup target add aarch64-apple-darwin
          rustup target add x86_64-apple-darwin
          pip install --upgrade maturin
          maturin build --release -o dist
          maturin build --release -o dist --target universal2-apple-darwin
        if: matrix.os == 'macos-latest'
      - name: Rename Wheels
        run: |
          python3 -c "import shutil; import glob; wheels = glob.glob('dist/*.whl'); [shutil.move(wheel, wheel.replace('py3', 'py2.py3')) for wheel in wheels if 'py2' not in wheel]"
        if: runner.os != 'Linux'
      - name: Upload Windows Wheels
        uses: actions/upload-artifact@v4
        with:
          name: wheels-windows
          path: dist
        if: runner.os == 'Windows'
      - name: Upload Macos Wheels
        uses: actions/upload-artifact@v4
        with:
          name: wheels-macos
          path: dist
        if: runner.os == 'macOS'

  build-linux-cross:
    runs-on: ubuntu-latest
    needs: [lint]
    strategy:
      fail-fast: false
      matrix:
        target:
          [
            i686-unknown-linux-musl,
            armv7-unknown-linux-musleabihf,
            aarch64-unknown-linux-musl,
            x86_64-unknown-linux-musl,
          ]
    container:
      image: ghcr.io/benfred/rust-musl-cross:${{ matrix.target }}
      env:
        RUSTUP_HOME: /root/.rustup
        CARGO_HOME: /root/.cargo
    steps:
      - uses: actions/checkout@v5
      - uses: Swatinem/rust-cache@v2
      - name: Build
        run: |
          python3 -m pip install --upgrade maturin
          maturin build --release -o dist --target ${{ matrix.target }} --features unwind
          maturin sdist -o dist
        if: ${{ matrix.target == 'armv7-unknown-linux-musleabihf' || matrix.target == 'x86_64-unknown-linux-musl'}}
      - name: Build
        run: |
          python3 -m pip install --upgrade maturin
          maturin build --release -o dist --target ${{ matrix.target }}
          maturin sdist -o dist
        if: ${{ matrix.target == 'i686-unknown-linux-musl' || matrix.target == 'aarch64-unknown-linux-musl'}}
      - name: Rename Wheels
        run: |
          python3 -c "import shutil; import glob; wheels = glob.glob('dist/*.whl'); [shutil.move(wheel, wheel.replace('py3', 'py2.py3')) for wheel in wheels if 'py2' not in wheel]"
      - name: Upload wheels
        uses: actions/upload-artifact@v4
        with:
          name: wheels-${{ matrix.target }}
          path: dist

  build-freebsd:
    runs-on: ubuntu-22.04
    needs: [lint]
    timeout-minutes: 30
    strategy:
      matrix:
        box:
          - freebsd-14
    steps:
      - uses: actions/checkout@v5
      - name: Display CPU info
        run: lscpu
      - name: Install VM tools
        run: |
          sudo apt-get update -qq
          sudo apt-get install -qq -o=Dpkg::Use-Pty=0 moreutils
          sudo chronic apt-get install -qq -o=Dpkg::Use-Pty=0 vagrant virtualbox qemu libvirt-daemon-system
      - name: Set up VM
        shell: sudo bash {0}
        run: |
          vagrant plugin install vagrant-libvirt
          vagrant plugin install vagrant-scp
          ln -sf ci/Vagrantfile Vagrantfile
          vagrant status
          vagrant up --no-tty --provider libvirt ${{ matrix.box }}
      - name: Build and test
        shell: sudo bash {0}
        run: vagrant ssh ${{ matrix.box }} -- bash /vagrant/ci/test_freebsd.sh
      - name: Retrieve build artifacts for caching purposes
        shell: sudo bash {0}
        run: |
          vagrant scp ${{ matrix.box }}:/vagrant/build-artifacts.tar build-artifacts.tar
          ls -ahl build-artifacts.tar
      - name: Prepare binary for upload
        run: |
          tar xf build-artifacts.tar target/release/py-spy
          mv target/release/py-spy py-spy-x86_64-unknown-freebsd
      - name: Upload Binaries
        uses: actions/upload-artifact@v4
        with:
          name: py-spy-x86_64-unknown-freebsd
          path: py-spy-x86_64-unknown-freebsd

  test-wheels:
    name: Test Wheels
    needs: [build, build-linux-cross]
    runs-on: ${{ matrix.os }}
    strategy:
      fail-fast: false
      # automatically generated by ci/update_python_test_versions.py
      matrix:
        python-version:
          [
            3.6.7,
            3.6.15,
            3.7.1,
            3.7.17,
            3.8.0,
            3.8.18,
            3.9.0,
            3.9.23,
            3.10.0,
            3.10.18,
            3.11.0,
            3.11.13,
            3.12.0,
            3.12.1,
            3.12.2,
            3.12.3,
            3.12.4,
            3.12.5,
            3.12.6,
            3.12.7,
            3.12.8,
            3.12.9,
            3.12.10,
            3.12.11,
            3.13.0,
            3.13.1,
            3.13.2,
            3.13.3,
            3.13.4,
            3.13.5,
            3.13.6,
            3.13.7,
          ]
        os: [ubuntu-22.04, macos-13, windows-latest, ubuntu-22.04-arm]
        # some versions of python can't be tested on GHA with osx because of SIP:
        exclude:
          - os: ubuntu-22.04
            python-version: 3.6.7
          - os: ubuntu-22.04-arm
            python-version: 3.6.7
          - os: windows-latest
            python-version: 3.6.15
          - os: ubuntu-22.04
            python-version: 3.6.15
          - os: ubuntu-22.04-arm
            python-version: 3.6.15
          - os: ubuntu-22.04
            python-version: 3.7.1
          - os: ubuntu-22.04-arm
            python-version: 3.7.1
          - os: windows-latest
            python-version: 3.7.17
          - os: ubuntu-22.04-arm
            python-version: 3.7.17
          - os: ubuntu-22.04
            python-version: 3.8.0
          - os: ubuntu-22.04-arm
            python-version: 3.8.0
          - os: windows-latest
            python-version: 3.8.18
          - os: ubuntu-22.04
            python-version: 3.9.0
          - os: ubuntu-22.04-arm
            python-version: 3.9.0
          - os: windows-latest
            python-version: 3.9.23
          - os: ubuntu-22.04
            python-version: 3.10.0
          - os: ubuntu-22.04-arm
            python-version: 3.10.0
          - os: windows-latest
            python-version: 3.10.18
          - os: macos-13
            python-version: 3.11.13
          - os: windows-latest
            python-version: 3.11.13
          - os: macos-13
            python-version: 3.12.0
          - os: macos-13
            python-version: 3.12.1
          - os: macos-13
            python-version: 3.12.2
          - os: macos-13
            python-version: 3.12.3
          - os: macos-13
            python-version: 3.12.4
          - os: macos-13
            python-version: 3.12.5
          - os: macos-13
            python-version: 3.12.6
          - os: macos-13
            python-version: 3.12.7
          - os: macos-13
            python-version: 3.12.8
          - os: macos-13
            python-version: 3.12.9
          - os: macos-13
            python-version: 3.12.10
          - os: macos-13
            python-version: 3.12.11
          - os: windows-latest
            python-version: 3.12.11

    steps:
      - uses: actions/checkout@v5
      - uses: actions/download-artifact@v5
        with:
          pattern: wheels-*
          merge-multiple: true
      - uses: actions/setup-python@v5
        with:
          python-version: ${{ matrix.python-version }}
      - name: Install wheel
        run: |
          pip install --force-reinstall --no-index --find-links . py-spy
      - name: Test Wheel
        id: test
        run: python tests/integration_test.py
        if: runner.os != 'macOS'
        continue-on-error: true
      - name: Test Wheel (Retry#1)
        id: test1
        run: python tests/integration_test.py
        if: steps.test.outcome=='failure'
        continue-on-error: true
      - name: Test Wheel (Retry#2)
        id: test2
        run: python tests/integration_test.py
        if: steps.test1.outcome=='failure'
      - name: Test macOS Wheel
        id: osx_test
        run: sudo "PATH=$PATH" python tests/integration_test.py
        if: runner.os == 'macOS'
        continue-on-error: true
      - name: Test macOS Wheel (Retry#1)
        id: osx_test1
        run: sudo "PATH=$PATH" python tests/integration_test.py
        if: steps.osx_test.outcome=='failure'
        continue-on-error: true
      - name: Test macOS Wheel (Retry#2)
        id: osx_test2
        run: sudo "PATH=$PATH" python tests/integration_test.py
        if: steps.osx_test1.outcome=='failure'

  release:
    name: Release
    runs-on: ubuntu-latest
    if: "startsWith(github.ref, 'refs/tags/')"
    needs: [test-wheels]
    steps:
      - uses: actions/download-artifact@v5
        with:
          pattern: wheels-*
          merge-multiple: true
      - name: Create GitHub Release
        uses: fnkr/github-action-ghr@v1.3
        env:
          GHR_PATH: .
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
      - name: Install Dependencies
        run: sudo apt install libunwind-dev
        if: runner.os == 'Linux'
      - uses: actions/setup-python@v5
        with:
          python-version: 3.9
      - name: Push to PyPi
        env:
          TWINE_USERNAME: ${{ secrets.PYPI_USERNAME }}
          TWINE_PASSWORD: ${{ secrets.PYPI_PASSWORD }}
        run: |
          pip install --upgrade wheel pip setuptools twine
          twine upload *
          rm *
      - uses: actions/checkout@v5
      - name: Push to crates.io
        env:
          CARGO_REGISTRY_TOKEN: ${{ secrets.CARGO_REGISTRY_TOKEN }}
        run: cargo publish


================================================
FILE: .github/workflows/release-drafter.yml
================================================
# draft release notes with https://github.com/release-drafter/release-drafter
name: Release Drafter

on:
  push:
    branches:
      - master
  workflow_dispatch:

jobs:
  update_release_draft:
    runs-on: ubuntu-latest
    steps:
      # Drafts your next Release notes as Pull Requests are merged into "master"
      - uses: release-drafter/release-drafter@v6
        env:
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}


================================================
FILE: .github/workflows/update_python_test.yml
================================================
name: Update Python Test Versions
on:
  workflow_dispatch:
  schedule:
    - cron: "0 1 * * *"
jobs:
  update-dep:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v5
        with:
          ssh-key: ${{ secrets.SSH_PRIVATE_KEY }}
      - uses: actions/setup-python@v5
        with:
          python-version: 3.9
      - name: Install
        run: pip install --upgrade requests pyyaml
      - name: Scan for new python versions
        run: python ci/update_python_test_versions.py
      - name: Format results
        run: npx prettier --write ".github/workflows/update_python_test.yml"
      - name: Create Pull Request
        uses: peter-evans/create-pull-request@v7
        with:
          commit-message: Update tested python versions
          title: Update tested python versions
          branch: update-python-versions
          labels: |
            skip-changelog
            dependencies


================================================
FILE: .gitignore
================================================
/target
remoteprocess/target
**/*.rs.bk

# Python Distribution / packaging
.Python
env/
build/
develop-eggs/
dist/
downloads/
eggs/
.eggs/
lib/
lib64/
parts/
sdist/
var/
*.egg-info/
.installed.cfg
*.egg

.vscode/
**/.vagrant
*.log


================================================
FILE: .pre-commit-config.yaml
================================================
repos:
  - repo: https://github.com/codespell-project/codespell
    rev: v2.2.4
    hooks:
      - id: codespell
        additional_dependencies: [tomli]
        args: ["--toml", "pyproject.toml"]
        exclude: (?x)^(ci/testdata.*|images.*)$
  - repo: https://github.com/doublify/pre-commit-rust
    rev: v1.0
    hooks:
      - id: fmt
      - id: cargo-check
  - repo: https://github.com/rbubley/mirrors-prettier
    rev: v3.3.3
    hooks:
      - id: prettier
        types: [yaml]


================================================
FILE: CHANGELOG.md
================================================
# Release notes are now being hosted in Github Releases: https://github.com/benfred/py-spy/releases

## v0.3.11

* Update dependencies [#463](https://github.com/benfred/py-spy/pull/463), [#457](https://github.com/benfred/py-spy/pull/463)
* Warn about SYS_PTRACE when running in docker [#459](https://github.com/benfred/py-spy/pull/459)
* Fix spelling mistakes [#453](https://github.com/benfred/py-spy/pull/453)

## v0.3.10
* Add support for profiling Python v3.10 [#425](https://github.com/benfred/py-spy/pull/425)
* Fix issue with native profiling on Linux with Anaconda [#447](https://github.com/benfred/py-spy/pull/447)

## v0.3.9
* Add a subcommand to generate shell completions [#427](https://github.com/benfred/py-spy/issues/427)
* Allow attaching co_firstlineno to frame name [#428](https://github.com/benfred/py-spy/issues/428)
* Fix speedscope time interval [#434](https://github.com/benfred/py-spy/issues/434)
* Fix profiling on FreeBSD [#431](https://github.com/benfred/py-spy/issues/431)
* Use GitHub actions for FreeBSD CI [#433](https://github.com/benfred/py-spy/issues/433)

## v0.3.8
* Add wheels for Apple Silicon [#419](https://github.com/benfred/py-spy/issues/419)
* Add --gil and --idle options to top view [#406](https://github.com/benfred/py-spy/issues/406)
* Fix errors parsing python binaries [#407](https://github.com/benfred/py-spy/issues/407)
* Specify timeunit in speedscope profiles [#294](https://github.com/benfred/py-spy/issues/294)

## v0.3.7
* Fix error that sometimes left the profiled program suspended [#390](https://github.com/benfred/py-spy/issues/390)
* Documentation fixes for README [#391](https://github.com/benfred/py-spy/issues/391), [#393](https://github.com/benfred/py-spy/issues/393)

## v0.3.6
* Fix profiling inside a venv on windows [#216](https://github.com/benfred/py-spy/issues/216)
* Detect GIL on Python 3.9.3+, 3.8.9+ [#375](https://github.com/benfred/py-spy/issues/375)
* Fix getting thread names on python 3.9 [#387](https://github.com/benfred/py-spy/issues/387)
* Fix getting thread names on ARMv7 [#388](https://github.com/benfred/py-spy/issues/388)
* Add python integration tests, and test wheels across a range of different python versions [#378](https://github.com/benfred/py-spy/pull/378)
* Automatically add tests for new versions of python [#379](https://github.com/benfred/py-spy/pull/379)

## v0.3.5
* Handle case where linux kernel is compiled without ```process_vm_readv``` support  [#22](https://github.com/benfred/py-spy/issues/22)
* Handle case where /proc/self/ns/mnt is missing [#326](https://github.com/benfred/py-spy/issues/326)
* Allow attaching to processes where the python binary has been deleted [#109](https://github.com/benfred/py-spy/issues/109)
* Make '--output' optional [#229](https://github.com/benfred/py-spy/issues/229)
* Add --full-filenames to allow showing full Python filenames [#363](https://github.com/benfred/py-spy/issues/363)
* Count "samples" as the number of recorded stacks (per thread) [#365](https://github.com/benfred/py-spy/issues/365)
* Exit with an error if --gil but we failed to get necessary addrs/offsets [#361](https://github.com/benfred/py-spy/pull/361)
* Include command/options used to run py-spy in flamegraph output [#293](https://github.com/benfred/py-spy/issues/293)
* GIL Detection fixes for python 3.9.2/3.8.8 [#362](https://github.com/benfred/py-spy/pull/362)
* Move to Github Actions for CI

## v0.3.4
* Build armv7/aarch64 wheels [#328](https://github.com/benfred/py-spy/issues/328)
* Detect GIL on Python 3.9 / 3.7.7+ / 3.8.2+
* Add option for more verbose local variables [#287](https://github.com/benfred/py-spy/issues/287)
* Fix issues with profiling subprocesses [#265](https://github.com/benfred/py-spy/issues/265)
* Include python thread names in record [#237](https://github.com/benfred/py-spy/issues/237)
* Fix issue with threadids triggering differential flamegraphs [#234](https://github.com/benfred/py-spy/issues/234)

## v0.3.3

* Change to display stdout/stderr from profiled child process [#217](https://github.com/benfred/py-spy/issues/217)
* Fix memory leak on OSX [#227](https://github.com/benfred/py-spy/issues/227)
* Fix panic on dump --locals [#224](https://github.com/benfred/py-spy/issues/224)
* Fix cross container short filename generation [#220](https://github.com/benfred/py-spy/issues/220)

## v0.3.2

* Fix line numbers on python 3.8+ [#190](https://github.com/benfred/py-spy/issues/190)
* Fix profiling pyinstaller binaries on OSX [#207](https://github.com/benfred/py-spy/issues/207)
* Support getting GIL from Python 3.8.1/3.7.6/3.7.5 [#211](https://github.com/benfred/py-spy/issues/211)

## v0.3.1

* Fix ptrace errors on linux kernel older than v4.7 [#83](https://github.com/benfred/py-spy/issues/83)
* Fix for profiling docker containers from host os [#199](https://github.com/benfred/py-spy/issues/199)
* Fix for speedscope profiles aggregated by function name [#201](https://github.com/benfred/py-spy/issues/201)
* Use symbols from dynsym table of ELF binaries [#191](https://github.com/benfred/py-spy/pull/191)

## v0.3.0

* Add ability to profile subprocesses [#124](https://github.com/benfred/py-spy/issues/124)
* Fix overflow issue with linux symbolication [#183](https://github.com/benfred/py-spy/issues/183)
* Fixes for printing local variables [#180](https://github.com/benfred/py-spy/pull/180)

## v0.2.2

* Add ability to show local variables when dumping out stack traces [#77](https://github.com/benfred/py-spy/issues/77)
* Show python thread names in dump [#47](https://github.com/benfred/py-spy/issues/47)
* Fix issues with profiling python hosted by .NET exe [#171](https://github.com/benfred/py-spy/issues/171)

## v0.2.1

* Fix issue with profiling dockerized process from the host os [#168](https://github.com/benfred/py-spy/issues/168)

## v0.2.0

* Add ability to profile native python extensions [#2](https://github.com/benfred/py-spy/issues/2)
* Add FreeBSD support [#112](https://github.com/benfred/py-spy/issues/112)
* Relicense to MIT [#163](https://github.com/benfred/py-spy/issues/163)
* Add option to write out Speedscope files [#115](https://github.com/benfred/py-spy/issues/115)
* Add option to output raw call stack data [#35](https://github.com/benfred/py-spy/issues/35)
* Get thread idle status from OS [#92](https://github.com/benfred/py-spy/issues/92)
* Add 'unlimited' default option for the duration [#93](https://github.com/benfred/py-spy/issues/93)
* Allow use as a library by other rust programs [#110](https://github.com/benfred/py-spy/issues/110)
* Show OS threadids in dump [#57](https://github.com/benfred/py-spy/issues/57)
* Drop root permissions when starting new process [#116](https://github.com/benfred/py-spy/issues/116)
* Support building for ARM processors [#89](https://github.com/benfred/py-spy/issues/89)
* Python 3.8 compatibility
* Fix issues profiling functions with more than 4000 lines [#164](https://github.com/benfred/py-spy/issues/164)

## v0.1.11

* Fix to detect GIL status on Python 3.7+ [#104](https://github.com/benfred/py-spy/pull/104)
* Generate flamegraphs without perl (using Inferno) [#38](https://github.com/benfred/py-spy/issues/38)
* Use irregular sampling interval to avoid incorrect results [#94](https://github.com/benfred/py-spy/issues/94)
* Detect python packages when generating short filenames [#75](https://github.com/benfred/py-spy/issues/75)
* Fix issue with finding interpreter with Python 3.7 and 32bit Linux [#101](https://github.com/benfred/py-spy/issues/101)
* Detect "v2.7.15+" as a valid version string [#81](https://github.com/benfred/py-spy/issues/81)
* Fix to cleanup venv after failing to build with setup.py [#69](https://github.com/benfred/py-spy/issues/69)

## v0.1.10

* Fix running py-spy inside a docker container [#68](https://github.com/benfred/py-spy/issues/68)

## v0.1.9

* Fix partial stack traces from showing up, by pausing process while collecting samples [#56](https://github.com/benfred/py-spy/issues/56). Also add a ```--nonblocking``` option to use previous behaviour of not stopping process.
* Allow sampling process running in a docker container from the host OS [#49](https://github.com/benfred/py-spy/issues/49)
* Allow collecting data for flame graph until interrupted with Control-C  [#21](https://github.com/benfred/py-spy/issues/21)
* Support 'legacy' strings in python 3 [#64](https://github.com/benfred/py-spy/issues/64)

## v0.1.8

* Support profiling pyinstaller binaries [#42](https://github.com/benfred/py-spy/issues/42)
* Add fallback when failing to find exe in memory maps [#40](https://github.com/benfred/py-spy/issues/40)

## v0.1.7

* Console viewer improvements for Windows 7 [#37](https://github.com/benfred/py-spy/issues/37)

## v0.1.6

* Warn if we can't sample fast enough [#33](https://github.com/benfred/py-spy/issues/33)
* Support embedded python interpreters like UWSGI [#25](https://github.com/benfred/py-spy/issues/25)
* Better error message when failing with 32-bit python on windows

## v0.1.5

* Use musl libc for linux wheels [#5](https://github.com/benfred/py-spy/issues/5)
* Fix for OSX python built with '--enable-framework' [#15](https://github.com/benfred/py-spy/issues/15)
* Fix for running on Centos7

## v0.1.4

* Initial public release


================================================
FILE: Cargo.toml
================================================
[features]
unwind = ["remoteprocess/unwind"]

[package]
name = "py-spy"
version = "0.4.1"
authors = ["Ben Frederickson <github@benfrederickson.com>"]
repository = "https://github.com/benfred/py-spy"
homepage = "https://github.com/benfred/py-spy"
description = "Sampling profiler for Python programs "
readme = "README.md"
exclude = ["images/*", "test_programs/*"]
license = "MIT"
build="build.rs"
edition="2021"

[dependencies]
anyhow = "1"
clap = {version="3.2", features=["wrap_help", "cargo", "derive"]}
clap_complete="3.2"
console = "0.16"
ctrlc = "3"
indicatif = "0.18"
env_logger = "0.11"
goblin = "0.10.0"
inferno = "0.12.3"
lazy_static = "1.4.0"
libc = "0.2"
log = "0.4"
lru = "0.10"
num-traits = "0.2"
regex = ">=1.6.0"
tempfile = "3.6.0"
page_size = "0.6.0"
proc-maps = "0.4.0"
memmap2 = "0.9.4"
cpp_demangle = "0.4"
serde = {version="1.0", features=["rc"]}
serde_derive = "1.0"
serde_json = "1.0"
rand = "0.8"
rand_distr = "0.4"
remoteprocess = "0.5.1"
chrono = "0.4.26"

[dev-dependencies]
py-spy-testdata = "0.1.0"

[target.'cfg(unix)'.dependencies]
termios = "0.3.3"

[target.'cfg(windows)'.dependencies]
winapi = {version = "0.3", features = ["errhandlingapi", "winbase", "consoleapi", "wincon", "handleapi", "timeapi", "processenv" ]}


================================================
FILE: LICENSE
================================================
The MIT License (MIT)

Copyright (c) 2018-2019 Ben Frederickson

Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:

The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.

THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
SOFTWARE.


================================================
FILE: README.md
================================================
py-spy: Sampling profiler for Python programs
=====
[![Build Status](https://github.com/benfred/py-spy/workflows/Build/badge.svg?branch=master)](https://github.com/benfred/py-spy/actions?query=branch%3Amaster)
[![FreeBSD Build Status](https://api.cirrus-ci.com/github/benfred/py-spy.svg)](https://cirrus-ci.com/github/benfred/py-spy)

py-spy is a sampling profiler for Python programs. It lets you visualize what your Python
program is spending time on without restarting the program or modifying the code in any way.
py-spy is extremely low overhead: it is written in Rust for speed and doesn't run
in the same process as the profiled Python program. This means py-spy is safe to use against production Python code.

py-spy works on Linux, OSX, Windows and FreeBSD, and supports profiling all recent versions of the CPython
interpreter (versions 2.3-2.7 and 3.3-3.13).

## Installation

Prebuilt binary wheels can be installed from PyPI with:

```
pip install py-spy
```

You can also download prebuilt binaries from the [GitHub Releases
Page](https://github.com/benfred/py-spy/releases).

If you're a Rust user, py-spy can also be installed with: ```cargo install py-spy```. Note this
builds py-spy from source and requires `libunwind` on Linux and Window, e.g., 
`apt install libunwind-dev`.

On macOS, [py-spy is in Homebrew](https://formulae.brew.sh/formula/py-spy#default) and 
can be installed with ```brew install py-spy```.

On Arch Linux, [py-spy is in AUR](https://aur.archlinux.org/packages/py-spy/) and can be
installed with ```yay -S py-spy```.

On Alpine Linux, [py-spy is in testing repository](https://pkgs.alpinelinux.org/packages?name=py-spy&branch=edge&repo=testing) and
can be installed with ```apk add py-spy --update-cache --repository http://dl-3.alpinelinux.org/alpine/edge/testing/ --allow-untrusted```.

## Usage

py-spy works from the command line and takes either the PID of the program you want to sample from
or the command line of the python program you want to run. py-spy has three subcommands
```record```, ```top``` and ```dump```:

### record

py-spy supports recording profiles to a file using the ```record``` command. For example, you can
generate a [flame graph](http://www.brendangregg.com/flamegraphs.html) of your python process by
going:

``` bash
py-spy record -o profile.svg --pid 12345
# OR
py-spy record -o profile.svg -- python myprogram.py
```

Which will generate an interactive SVG file looking like:

![flame graph](./images/flamegraph.svg)

You can change the file format to generate
[speedscope](https://github.com/jlfwong/speedscope) profiles or raw data with the ```--format``` parameter.
See ```py-spy record --help``` for information on other options including changing
the sampling rate, filtering to only include threads that hold the GIL, profiling native C extensions,
showing thread-ids, profiling subprocesses and more.

### top

Top shows a live view of what functions are taking the most time in your python program, similar
to the Unix [top](https://linux.die.net/man/1/top) command. Running py-spy with:

``` bash
py-spy top --pid 12345
# OR
py-spy top -- python myprogram.py
```

will bring up a live updating high level view of your python program:

![console viewer demo](./images/console_viewer.gif)

### dump

py-spy can also display the current call stack for each python thread with the ```dump``` command:

```bash
py-spy dump --pid 12345
```

This will dump out the call stacks for each thread, and some other basic process info to the
console:

![dump output](./images/dump.png)

This is useful for the case where you just need a single call stack to figure out where your
python program is hung on. This command also has the ability to print out the local variables
associated with each stack frame by setting the ```--locals``` flag.

## Frequently Asked Questions

### Why do we need another Python profiler?

This project aims to let you profile and debug any running Python program, even if the program is
serving production traffic.

While there are many other python profiling projects, almost all of them require modifying
the profiled program in some way. Usually, the profiling code runs inside of the target python process,
which will slow down and change how the program operates. This means it's not generally safe
to use these profilers for debugging issues in production services since they will usually have
a noticeable impact on performance.

### How does py-spy work?

py-spy works by directly reading the memory of the python program using the
[process_vm_readv](http://man7.org/linux/man-pages/man2/process_vm_readv.2.html) system call on Linux,
the [vm_read](https://developer.apple.com/documentation/kernel/1585350-vm_read?language=objc) call on OSX
or the [ReadProcessMemory](https://msdn.microsoft.com/en-us/library/windows/desktop/ms680553(v=vs.85).aspx) call
on Windows.

Figuring out the call stack of the Python program is done by looking at the global PyInterpreterState variable
to get all the Python threads running in the interpreter, and then iterating over each PyFrameObject in each thread
to get the call stack. Since the Python ABI changes between versions, we use rust's [bindgen](https://github.com/rust-lang-nursery/rust-bindgen) to generate different rust structures for each Python interpreter
class we care about and use these generated structs to figure out the memory layout in the Python program.

Getting the memory address of the Python Interpreter can be a little tricky due to [Address Space Layout Randomization](https://en.wikipedia.org/wiki/Address_space_layout_randomization). If the target python interpreter ships
with symbols it is pretty easy to figure out the memory address of the interpreter by dereferencing the
```interp_head```  or ```_PyRuntime``` variables depending on the Python version. However, many Python
versions are shipped with either stripped binaries or shipped without the corresponding PDB symbol files on Windows. In
these cases we scan through the BSS section for addresses that look like they may point to a valid PyInterpreterState
and check if the layout of that address is what we expect.


### Can py-spy profile native extensions?

Yes! py-spy supports profiling native python extensions written in languages like C/C++ or Cython,
on some platforms (see table below). You can enable this mode by passing ```--native``` on the
command line. For best results, you should compile your Python extension with symbols. Also worth
noting for Cython programs is that py-spy needs the generated C or C++ file in order to return line
numbers of the original .pyx file.  Read the [blog post](https://www.benfrederickson.com/profiling-native-python-extensions-with-py-spy/)
for more information.

|         | Linux | Windows | OSX | FreeBSD |
|---------|-------|---------|-----|---------|
| i686    |       |         |     |         |
| x86-64  | yes   | yes     |     |         |
| ARM     | yes   |         |     |         |
| Aarch64 |       |         |     |         |

### How can I profile subprocesses?

By passing in the ```--subprocesses``` flag to either the record or top view, py-spy will also include
the output from any python process that is a child process of the target program. This is useful
for profiling applications that use multiprocessing or gunicorn worker pools. py-spy will monitor
for new processes being created, and automatically attach to them and include samples from them in
the output. The record view will include the PID and cmdline of each program in the callstack,
with subprocesses appearing as children of their parent processes.

### When do you need to run as sudo?

py-spy works by reading memory from a different python process, and this might not be allowed for security reasons depending on
your OS and system settings. In many cases, running as a root user (with sudo or similar) gets around these security restrictions.
OSX always requires running as root, but on Linux it depends on how you are launching py-spy and the system
security settings.

On Linux the default configuration is to require root permissions when attaching to a process that isn't a child.
For py-spy this means you can profile without root access by getting py-spy to create the process
(```py-spy record  -- python myprogram.py```) but attaching to an existing process by specifying a
PID will usually require root (```sudo py-spy record --pid 123456```).
You can remove this restriction on Linux by setting the [ptrace_scope sysctl variable](https://wiki.ubuntu.com/SecurityTeam/Roadmap/KernelHardening#ptrace_Protection).

### How do you detect if a thread is idle or not?

py-spy attempts to only include stack traces from threads that are actively running code, and exclude threads that
are sleeping or otherwise idle. When possible, py-spy attempts to get this thread activity information
from the OS: by reading in  ```/proc/PID/stat``` on Linux, by using the mach
[thread_basic_info](https://opensource.apple.com/source/xnu/xnu-792/osfmk/mach/thread_info.h.auto.html)
call on OSX, and by looking if the current SysCall is [known to be
idle](https://github.com/benfred/py-spy/blob/8326c6dbc6241d60125dfd4c01b70fed8b8b8138/remoteprocess/src/windows/mod.rs#L212-L229)
on Windows.

There are some limitations with this approach though that may cause idle threads to still be
marked as active. First off, we have to get this thread activity information before pausing the
program, because getting this from a paused program will cause it to always return that this is
idle. This means there is a potential race condition, where we get the thread activity and
then the thread is in a different state when we get the stack trace. Querying the OS for thread
activity also isn't implemented yet for FreeBSD and i686/ARM processors on Linux. On Windows,
calls that are blocked on IO also won't be marked as idle yet, for instance when reading input
from stdin. Finally, on some Linux calls the ptrace attach that we are using may cause idle threads
to wake up momentarily, causing false positives when reading from procfs. For these reasons, 
we also have a heuristic fallback that marks known certain known calls in
python as being idle. 

You can disable this functionality by setting the ```--idle``` flag, which
will include frames that py-spy considers idle.  

### How does GIL detection work?

We get GIL activity by looking at the threadid value pointed to by the ```_PyThreadState_Current``` symbol
for Python 3.6 and earlier and by figuring out the equivalent from the ```_PyRuntime``` struct in
Python 3.7 and later. These symbols might not be included in your python distribution, which will
cause resolving which thread holds on to the GIL to fail. Current GIL usage is also shown in the 
```top``` view as %GIL.

Passing the ```--gil``` flag will only include traces for threads that are holding on to the
[Global Interpreter Lock](https://wiki.python.org/moin/GlobalInterpreterLock). In some cases this
might be a more accurate view of how your python program is spending its time, though you should
be aware that this will miss activity in extensions that release the GIL while still active.

### Why am I having issues profiling /usr/bin/python on OSX?

OSX has a feature called [System Integrity Protection](https://en.wikipedia.org/wiki/System_Integrity_Protection) that prevents even the root user from reading memory from any binary located in /usr/bin. Unfortunately, this includes the python interpreter that ships with OSX.

There are a couple of different ways to deal with this:
 * You can install a different Python distribution. The built-in Python [will be removed](https://developer.apple.com/documentation/macos_release_notes/macos_catalina_10_15_release_notes) in a future OSX, and you probably want to migrate away from Python 2 anyways =).
 * You can use [virtualenv](https://virtualenv.pypa.io/en/stable/) to run the system python in an environment where SIP doesn't apply.
 * You can [disable System Integrity Protection](https://www.macworld.co.uk/how-to/mac/how-turn-off-mac-os-x-system-integrity-protection-rootless-3638975/).

### How do I run py-spy in Docker?

Running py-spy inside of a docker container will also usually bring up a permissions denied error even when running as root.

This error is caused by docker restricting the process_vm_readv system call we are using. This can
be overridden by setting
[```--cap-add SYS_PTRACE```](https://docs.docker.com/engine/security/seccomp/) when starting the docker container.

Alternatively you can edit the docker-compose yaml file

```
your_service:
   cap_add:
     - SYS_PTRACE
```

Note that you'll need to restart the docker container in order for this setting to take effect.

You can also use py-spy from the Host OS to profile a running process running inside the docker
container. 

### How do I run py-spy in Kubernetes?

py-spy needs `SYS_PTRACE` to be able to read process memory. Kubernetes drops that capability by default, resulting in the error
```
Permission Denied: Try running again with elevated permissions by going 'sudo env "PATH=$PATH" !!'
```
The recommended way to deal with this is to edit the spec and add that capability. For a Deployment, this is done by adding this to `Deployment.spec.template.spec.containers`
```
securityContext:
  capabilities:
    add:
    - SYS_PTRACE
```
More details on this here: https://kubernetes.io/docs/tasks/configure-pod-container/security-context/#set-capabilities-for-a-container
Note that if you modify the Deployment resource, this will remove the existing Pods and create those again.

You can also create an **ephemeral container** to attach to a running Pod, targeting a specific **container** where your application is running.
Make sure to use a `profile` that grants the `SYS_PTRACE` permission, for example:

```sh
kubectl debug --profile=general \
    -n your-namespace \
    --target=app-container-name \
    pod-name \
    --image=python:3.12-slim \
    -it -- bash
```

### How do I install py-spy on Alpine Linux?

Alpine python opts out of the `manylinux` wheels: [pypa/pip#3969 (comment)](https://github.com/pypa/pip/issues/3969#issuecomment-247381915).
You can override this behaviour to use pip to install py-spy on Alpine by going:

    echo 'manylinux1_compatible = True' > /usr/local/lib/python3.7/site-packages/_manylinux.py

Alternatively you can download a musl binary from the [GitHub releases page](https://github.com/benfred/py-spy/releases).

### How can I avoid pausing the Python program?

By setting the ```--nonblocking``` option, py-spy won't pause the target python you are profiling from. While
the performance impact of sampling from a process with py-spy is usually extremely low, setting this option
will totally avoid interrupting your running python program.

With this option set, py-spy will instead read the interpreter state from the python process as it is running.
Since the calls we use to read memory from are not atomic, and we have to issue multiple calls to get a stack trace this
means that occasionally we get errors when sampling. This can show up as an increased error rate when sampling, or as
partial stack frames being included in the output.

### Does py-spy support 32-bit Windows? Integrate with PyPy? Work with USC2 versions of Python2?

Not yet =).

If there are features you'd like to see in py-spy either thumb up the [appropriate
issue](https://github.com/benfred/py-spy/issues?q=is%3Aissue+is%3Aopen+sort%3Areactions-%2B1-desc) or create a new one that describes what functionality is missing.

### How to force colored output when piping to a pager?

py-spy follows the [CLICOLOR](https://bixense.com/clicolors/) specification, thus setting `CLICOLOR_FORCE=1` in your environment will have py-spy print colored output even when piped to a pager.

## Credits

py-spy is heavily inspired by [Julia Evans](https://github.com/jvns/) excellent work on [rbspy](http://github.com/rbspy/rbspy).
In particular, the code to generate flamegraph and speedscope files is taken directly from rbspy, and this project uses the
[read-process-memory](https://github.com/luser/read-process-memory) and [proc-maps](https://github.com/benfred/proc-maps) crates that were spun off from rbspy.

## License

py-spy is released under the MIT License, see the [LICENSE](https://github.com/benfred/py-spy/blob/master/LICENSE) file for the full text.


================================================
FILE: SECURITY.md
================================================
# Security Policy

## Reporting a Vulnerability

Please email any security vulnerabilities to ben@benfrederickson.com.

## Supported Versions

Only the most recent version of py-spy will get security updates.


================================================
FILE: build.rs
================================================
use std::env;

fn main() {
    let target_arch = env::var("CARGO_CFG_TARGET_ARCH").unwrap();
    let target_os = env::var("CARGO_CFG_TARGET_OS").unwrap();
    match (target_arch.as_ref(), target_os.as_ref()) {
        ("x86_64", "windows") | ("x86_64", "linux") | ("arm", "linux") => {
            println!("cargo:rustc-cfg=unwind")
        }
        _ => {}
    }
}


================================================
FILE: ci/Vagrantfile
================================================
Vagrant.configure("2") do |config|
  config.vm.define "freebsd-14" do |c|
    c.vm.box = "roboxes/freebsd14"
  end

  config.vm.boot_timeout = 600

  config.vm.provider "libvirt" do |qe|
    # https://vagrant-libvirt.github.io/vagrant-libvirt/configuration.html
    qe.driver = "kvm"
    qe.cpus = 3
    qe.memory = 8192
  end

  config.vm.synced_folder ".", "/vagrant", type: "rsync",
    rsync__exclude: [".git", ".vagrant.d"]

  config.vm.provision "shell", inline: <<~SHELL
    set -e
    pkg install -y curl bash python llvm
    chsh -s /usr/local/bin/bash vagrant
    pw groupmod wheel -m vagrant
    su -l vagrant <<'EOF'
    curl https://sh.rustup.rs -sSf | sh -s -- -y --profile minimal --default-toolchain 1.88.0
    EOF
  SHELL
end


================================================
FILE: ci/publish_freebsd.sh
================================================
#!/usr/bin/env bash
set -ex

if [[ "$CIRRUS_RELEASE" == "" ]]; then
  echo "Not a release. No need to deploy!"
  exit 0
fi

if [[ "$GITHUB_TOKEN" == "" ]]; then
  echo "Please provide GitHub access token via GITHUB_TOKEN environment variable!"
  exit 1
fi

file_content_type="application/octet-stream"
fpath=py-spy-$CIRRUS_TAG-x86_64-freebsd.tar.gz

tar -C ./target/release -czf $fpath py-spy

echo "Uploading $fpath..."
name=$(basename "$fpath")
url_to_upload="https://uploads.github.com/repos/$CIRRUS_REPO_FULL_NAME/releases/$CIRRUS_RELEASE/assets?name=$name"
curl -X POST \
--data-binary @$fpath \
--header "Authorization: token $GITHUB_TOKEN" \
--header "Content-Type: $file_content_type" \
$url_to_upload


================================================
FILE: ci/test_freebsd.sh
================================================
#!/usr/bin/env bash

source "$HOME/.cargo/env"

set -e

python --version
cargo --version

cd /vagrant

if [ -f build-artifacts.tar ]; then
  echo "Unpacking cached build artifacts..."
  tar xf build-artifacts.tar
  rm -f build-artifacts.tar
fi

cargo build --release --workspace --all-targets

# TODO: re-enable integration tests
# cargo test --release

set +e
tar cf build-artifacts.tar target
tar rf build-artifacts.tar "$HOME/.cargo/git"
tar rf build-artifacts.tar "$HOME/.cargo/registry"

exit 0


================================================
FILE: ci/testdata/cython_test.c
================================================
/* Generated by Cython 0.28.5 */

#define PY_SSIZE_T_CLEAN
#include "Python.h"
#ifndef Py_PYTHON_H
    #error Python headers needed to compile C extensions, please install development version of Python.
#elif PY_VERSION_HEX < 0x02060000 || (0x03000000 <= PY_VERSION_HEX && PY_VERSION_HEX < 0x03030000)
    #error Cython requires Python 2.6+ or Python 3.3+.
#else
#define CYTHON_ABI "0_28_5"
#define CYTHON_FUTURE_DIVISION 0
#include <stddef.h>
#ifndef offsetof
  #define offsetof(type, member) ( (size_t) & ((type*)0) -> member )
#endif
#if !defined(WIN32) && !defined(MS_WINDOWS)
  #ifndef __stdcall
    #define __stdcall
  #endif
  #ifndef __cdecl
    #define __cdecl
  #endif
  #ifndef __fastcall
    #define __fastcall
  #endif
#endif
#ifndef DL_IMPORT
  #define DL_IMPORT(t) t
#endif
#ifndef DL_EXPORT
  #define DL_EXPORT(t) t
#endif
#define __PYX_COMMA ,
#ifndef HAVE_LONG_LONG
  #if PY_VERSION_HEX >= 0x02070000
    #define HAVE_LONG_LONG
  #endif
#endif
#ifndef PY_LONG_LONG
  #define PY_LONG_LONG LONG_LONG
#endif
#ifndef Py_HUGE_VAL
  #define Py_HUGE_VAL HUGE_VAL
#endif
#ifdef PYPY_VERSION
  #define CYTHON_COMPILING_IN_PYPY 1
  #define CYTHON_COMPILING_IN_PYSTON 0
  #define CYTHON_COMPILING_IN_CPYTHON 0
  #undef CYTHON_USE_TYPE_SLOTS
  #define CYTHON_USE_TYPE_SLOTS 0
  #undef CYTHON_USE_PYTYPE_LOOKUP
  #define CYTHON_USE_PYTYPE_LOOKUP 0
  #if PY_VERSION_HEX < 0x03050000
    #undef CYTHON_USE_ASYNC_SLOTS
    #define CYTHON_USE_ASYNC_SLOTS 0
  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
    #define CYTHON_USE_ASYNC_SLOTS 1
  #endif
  #undef CYTHON_USE_PYLIST_INTERNALS
  #define CYTHON_USE_PYLIST_INTERNALS 0
  #undef CYTHON_USE_UNICODE_INTERNALS
  #define CYTHON_USE_UNICODE_INTERNALS 0
  #undef CYTHON_USE_UNICODE_WRITER
  #define CYTHON_USE_UNICODE_WRITER 0
  #undef CYTHON_USE_PYLONG_INTERNALS
  #define CYTHON_USE_PYLONG_INTERNALS 0
  #undef CYTHON_AVOID_BORROWED_REFS
  #define CYTHON_AVOID_BORROWED_REFS 1
  #undef CYTHON_ASSUME_SAFE_MACROS
  #define CYTHON_ASSUME_SAFE_MACROS 0
  #undef CYTHON_UNPACK_METHODS
  #define CYTHON_UNPACK_METHODS 0
  #undef CYTHON_FAST_THREAD_STATE
  #define CYTHON_FAST_THREAD_STATE 0
  #undef CYTHON_FAST_PYCALL
  #define CYTHON_FAST_PYCALL 0
  #undef CYTHON_PEP489_MULTI_PHASE_INIT
  #define CYTHON_PEP489_MULTI_PHASE_INIT 0
  #undef CYTHON_USE_TP_FINALIZE
  #define CYTHON_USE_TP_FINALIZE 0
#elif defined(PYSTON_VERSION)
  #define CYTHON_COMPILING_IN_PYPY 0
  #define CYTHON_COMPILING_IN_PYSTON 1
  #define CYTHON_COMPILING_IN_CPYTHON 0
  #ifndef CYTHON_USE_TYPE_SLOTS
    #define CYTHON_USE_TYPE_SLOTS 1
  #endif
  #undef CYTHON_USE_PYTYPE_LOOKUP
  #define CYTHON_USE_PYTYPE_LOOKUP 0
  #undef CYTHON_USE_ASYNC_SLOTS
  #define CYTHON_USE_ASYNC_SLOTS 0
  #undef CYTHON_USE_PYLIST_INTERNALS
  #define CYTHON_USE_PYLIST_INTERNALS 0
  #ifndef CYTHON_USE_UNICODE_INTERNALS
    #define CYTHON_USE_UNICODE_INTERNALS 1
  #endif
  #undef CYTHON_USE_UNICODE_WRITER
  #define CYTHON_USE_UNICODE_WRITER 0
  #undef CYTHON_USE_PYLONG_INTERNALS
  #define CYTHON_USE_PYLONG_INTERNALS 0
  #ifndef CYTHON_AVOID_BORROWED_REFS
    #define CYTHON_AVOID_BORROWED_REFS 0
  #endif
  #ifndef CYTHON_ASSUME_SAFE_MACROS
    #define CYTHON_ASSUME_SAFE_MACROS 1
  #endif
  #ifndef CYTHON_UNPACK_METHODS
    #define CYTHON_UNPACK_METHODS 1
  #endif
  #undef CYTHON_FAST_THREAD_STATE
  #define CYTHON_FAST_THREAD_STATE 0
  #undef CYTHON_FAST_PYCALL
  #define CYTHON_FAST_PYCALL 0
  #undef CYTHON_PEP489_MULTI_PHASE_INIT
  #define CYTHON_PEP489_MULTI_PHASE_INIT 0
  #undef CYTHON_USE_TP_FINALIZE
  #define CYTHON_USE_TP_FINALIZE 0
#else
  #define CYTHON_COMPILING_IN_PYPY 0
  #define CYTHON_COMPILING_IN_PYSTON 0
  #define CYTHON_COMPILING_IN_CPYTHON 1
  #ifndef CYTHON_USE_TYPE_SLOTS
    #define CYTHON_USE_TYPE_SLOTS 1
  #endif
  #if PY_VERSION_HEX < 0x02070000
    #undef CYTHON_USE_PYTYPE_LOOKUP
    #define CYTHON_USE_PYTYPE_LOOKUP 0
  #elif !defined(CYTHON_USE_PYTYPE_LOOKUP)
    #define CYTHON_USE_PYTYPE_LOOKUP 1
  #endif
  #if PY_MAJOR_VERSION < 3
    #undef CYTHON_USE_ASYNC_SLOTS
    #define CYTHON_USE_ASYNC_SLOTS 0
  #elif !defined(CYTHON_USE_ASYNC_SLOTS)
    #define CYTHON_USE_ASYNC_SLOTS 1
  #endif
  #if PY_VERSION_HEX < 0x02070000
    #undef CYTHON_USE_PYLONG_INTERNALS
    #define CYTHON_USE_PYLONG_INTERNALS 0
  #elif !defined(CYTHON_USE_PYLONG_INTERNALS)
    #define CYTHON_USE_PYLONG_INTERNALS 1
  #endif
  #ifndef CYTHON_USE_PYLIST_INTERNALS
    #define CYTHON_USE_PYLIST_INTERNALS 1
  #endif
  #ifndef CYTHON_USE_UNICODE_INTERNALS
    #define CYTHON_USE_UNICODE_INTERNALS 1
  #endif
  #if PY_VERSION_HEX < 0x030300F0
    #undef CYTHON_USE_UNICODE_WRITER
    #define CYTHON_USE_UNICODE_WRITER 0
  #elif !defined(CYTHON_USE_UNICODE_WRITER)
    #define CYTHON_USE_UNICODE_WRITER 1
  #endif
  #ifndef CYTHON_AVOID_BORROWED_REFS
    #define CYTHON_AVOID_BORROWED_REFS 0
  #endif
  #ifndef CYTHON_ASSUME_SAFE_MACROS
    #define CYTHON_ASSUME_SAFE_MACROS 1
  #endif
  #ifndef CYTHON_UNPACK_METHODS
    #define CYTHON_UNPACK_METHODS 1
  #endif
  #ifndef CYTHON_FAST_THREAD_STATE
    #define CYTHON_FAST_THREAD_STATE 1
  #endif
  #ifndef CYTHON_FAST_PYCALL
    #define CYTHON_FAST_PYCALL 1
  #endif
  #ifndef CYTHON_PEP489_MULTI_PHASE_INIT
    #define CYTHON_PEP489_MULTI_PHASE_INIT (0 && PY_VERSION_HEX >= 0x03050000)
  #endif
  #ifndef CYTHON_USE_TP_FINALIZE
    #define CYTHON_USE_TP_FINALIZE (PY_VERSION_HEX >= 0x030400a1)
  #endif
#endif
#if !defined(CYTHON_FAST_PYCCALL)
#define CYTHON_FAST_PYCCALL  (CYTHON_FAST_PYCALL && PY_VERSION_HEX >= 0x030600B1)
#endif
#if CYTHON_USE_PYLONG_INTERNALS
  #include "longintrepr.h"
  #undef SHIFT
  #undef BASE
  #undef MASK
#endif
#ifndef __has_attribute
  #define __has_attribute(x) 0
#endif
#ifndef __has_cpp_attribute
  #define __has_cpp_attribute(x) 0
#endif
#ifndef CYTHON_RESTRICT
  #if defined(__GNUC__)
    #define CYTHON_RESTRICT __restrict__
  #elif defined(_MSC_VER) && _MSC_VER >= 1400
    #define CYTHON_RESTRICT __restrict
  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
    #define CYTHON_RESTRICT restrict
  #else
    #define CYTHON_RESTRICT
  #endif
#endif
#ifndef CYTHON_UNUSED
# if defined(__GNUC__)
#   if !(defined(__cplusplus)) || (__GNUC__ > 3 || (__GNUC__ == 3 && __GNUC_MINOR__ >= 4))
#     define CYTHON_UNUSED __attribute__ ((__unused__))
#   else
#     define CYTHON_UNUSED
#   endif
# elif defined(__ICC) || (defined(__INTEL_COMPILER) && !defined(_MSC_VER))
#   define CYTHON_UNUSED __attribute__ ((__unused__))
# else
#   define CYTHON_UNUSED
# endif
#endif
#ifndef CYTHON_MAYBE_UNUSED_VAR
#  if defined(__cplusplus)
     template<class T> void CYTHON_MAYBE_UNUSED_VAR( const T& ) { }
#  else
#    define CYTHON_MAYBE_UNUSED_VAR(x) (void)(x)
#  endif
#endif
#ifndef CYTHON_NCP_UNUSED
# if CYTHON_COMPILING_IN_CPYTHON
#  define CYTHON_NCP_UNUSED
# else
#  define CYTHON_NCP_UNUSED CYTHON_UNUSED
# endif
#endif
#define __Pyx_void_to_None(void_result) ((void)(void_result), Py_INCREF(Py_None), Py_None)
#ifdef _MSC_VER
    #ifndef _MSC_STDINT_H_
        #if _MSC_VER < 1300
           typedef unsigned char     uint8_t;
           typedef unsigned int      uint32_t;
        #else
           typedef unsigned __int8   uint8_t;
           typedef unsigned __int32  uint32_t;
        #endif
    #endif
#else
   #include <stdint.h>
#endif
#ifndef CYTHON_FALLTHROUGH
  #if defined(__cplusplus) && __cplusplus >= 201103L
    #if __has_cpp_attribute(fallthrough)
      #define CYTHON_FALLTHROUGH [[fallthrough]]
    #elif __has_cpp_attribute(clang::fallthrough)
      #define CYTHON_FALLTHROUGH [[clang::fallthrough]]
    #elif __has_cpp_attribute(gnu::fallthrough)
      #define CYTHON_FALLTHROUGH [[gnu::fallthrough]]
    #endif
  #endif
  #ifndef CYTHON_FALLTHROUGH
    #if __has_attribute(fallthrough)
      #define CYTHON_FALLTHROUGH __attribute__((fallthrough))
    #else
      #define CYTHON_FALLTHROUGH
    #endif
  #endif
  #if defined(__clang__ ) && defined(__apple_build_version__)
    #if __apple_build_version__ < 7000000
      #undef  CYTHON_FALLTHROUGH
      #define CYTHON_FALLTHROUGH
    #endif
  #endif
#endif

#ifndef CYTHON_INLINE
  #if defined(__clang__)
    #define CYTHON_INLINE __inline__ __attribute__ ((__unused__))
  #elif defined(__GNUC__)
    #define CYTHON_INLINE __inline__
  #elif defined(_MSC_VER)
    #define CYTHON_INLINE __inline
  #elif defined (__STDC_VERSION__) && __STDC_VERSION__ >= 199901L
    #define CYTHON_INLINE inline
  #else
    #define CYTHON_INLINE
  #endif
#endif

#if CYTHON_COMPILING_IN_PYPY && PY_VERSION_HEX < 0x02070600 && !defined(Py_OptimizeFlag)
  #define Py_OptimizeFlag 0
#endif
#define __PYX_BUILD_PY_SSIZE_T "n"
#define CYTHON_FORMAT_SSIZE_T "z"
#if PY_MAJOR_VERSION < 3
  #define __Pyx_BUILTIN_MODULE_NAME "__builtin__"
  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
          PyCode_New(a+k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
  #define __Pyx_DefaultClassType PyClass_Type
#else
  #define __Pyx_BUILTIN_MODULE_NAME "builtins"
  #define __Pyx_PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)\
          PyCode_New(a, k, l, s, f, code, c, n, v, fv, cell, fn, name, fline, lnos)
  #define __Pyx_DefaultClassType PyType_Type
#endif
#ifndef Py_TPFLAGS_CHECKTYPES
  #define Py_TPFLAGS_CHECKTYPES 0
#endif
#ifndef Py_TPFLAGS_HAVE_INDEX
  #define Py_TPFLAGS_HAVE_INDEX 0
#endif
#ifndef Py_TPFLAGS_HAVE_NEWBUFFER
  #define Py_TPFLAGS_HAVE_NEWBUFFER 0
#endif
#ifndef Py_TPFLAGS_HAVE_FINALIZE
  #define Py_TPFLAGS_HAVE_FINALIZE 0
#endif
#if PY_VERSION_HEX <= 0x030700A3 || !defined(METH_FASTCALL)
  #ifndef METH_FASTCALL
     #define METH_FASTCALL 0x80
  #endif
  typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *const *args, Py_ssize_t nargs);
  typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, PyObject *const *args,
                                                          Py_ssize_t nargs, PyObject *kwnames);
#else
  #define __Pyx_PyCFunctionFast _PyCFunctionFast
  #define __Pyx_PyCFunctionFastWithKeywords _PyCFunctionFastWithKeywords
#endif
#if CYTHON_FAST_PYCCALL
#define __Pyx_PyFastCFunction_Check(func)\
    ((PyCFunction_Check(func) && (METH_FASTCALL == (PyCFunction_GET_FLAGS(func) & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS)))))
#else
#define __Pyx_PyFastCFunction_Check(func) 0
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Malloc)
  #define PyObject_Malloc(s)   PyMem_Malloc(s)
  #define PyObject_Free(p)     PyMem_Free(p)
  #define PyObject_Realloc(p)  PyMem_Realloc(p)
#endif
#if CYTHON_COMPILING_IN_PYSTON
  #define __Pyx_PyCode_HasFreeVars(co)  PyCode_HasFreeVars(co)
  #define __Pyx_PyFrame_SetLineNumber(frame, lineno) PyFrame_SetLineNumber(frame, lineno)
#else
  #define __Pyx_PyCode_HasFreeVars(co)  (PyCode_GetNumFree(co) > 0)
  #define __Pyx_PyFrame_SetLineNumber(frame, lineno)  (frame)->f_lineno = (lineno)
#endif
#if !CYTHON_FAST_THREAD_STATE || PY_VERSION_HEX < 0x02070000
  #define __Pyx_PyThreadState_Current PyThreadState_GET()
#elif PY_VERSION_HEX >= 0x03060000
  #define __Pyx_PyThreadState_Current _PyThreadState_UncheckedGet()
#elif PY_VERSION_HEX >= 0x03000000
  #define __Pyx_PyThreadState_Current PyThreadState_GET()
#else
  #define __Pyx_PyThreadState_Current _PyThreadState_Current
#endif
#if PY_VERSION_HEX < 0x030700A2 && !defined(PyThread_tss_create) && !defined(Py_tss_NEEDS_INIT)
#include "pythread.h"
#define Py_tss_NEEDS_INIT 0
typedef int Py_tss_t;
static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) {
  *key = PyThread_create_key();
  return 0; // PyThread_create_key reports success always
}
static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) {
  Py_tss_t *key = (Py_tss_t *)PyObject_Malloc(sizeof(Py_tss_t));
  *key = Py_tss_NEEDS_INIT;
  return key;
}
static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) {
  PyObject_Free(key);
}
static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) {
  return *key != Py_tss_NEEDS_INIT;
}
static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) {
  PyThread_delete_key(*key);
  *key = Py_tss_NEEDS_INIT;
}
static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) {
  return PyThread_set_key_value(*key, value);
}
static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
  return PyThread_get_key_value(*key);
}
#endif // TSS (Thread Specific Storage) API
#if CYTHON_COMPILING_IN_CPYTHON || defined(_PyDict_NewPresized)
#define __Pyx_PyDict_NewPresized(n)  ((n <= 8) ? PyDict_New() : _PyDict_NewPresized(n))
#else
#define __Pyx_PyDict_NewPresized(n)  PyDict_New()
#endif
#if PY_MAJOR_VERSION >= 3 || CYTHON_FUTURE_DIVISION
  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_TrueDivide(x,y)
  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceTrueDivide(x,y)
#else
  #define __Pyx_PyNumber_Divide(x,y)         PyNumber_Divide(x,y)
  #define __Pyx_PyNumber_InPlaceDivide(x,y)  PyNumber_InPlaceDivide(x,y)
#endif
#if CYTHON_COMPILING_IN_CPYTHON && PY_VERSION_HEX >= 0x030500A1 && CYTHON_USE_UNICODE_INTERNALS
#define __Pyx_PyDict_GetItemStr(dict, name)  _PyDict_GetItem_KnownHash(dict, name, ((PyASCIIObject *) name)->hash)
#else
#define __Pyx_PyDict_GetItemStr(dict, name)  PyDict_GetItem(dict, name)
#endif
#if PY_VERSION_HEX > 0x03030000 && defined(PyUnicode_KIND)
  #define CYTHON_PEP393_ENABLED 1
  #define __Pyx_PyUnicode_READY(op)       (likely(PyUnicode_IS_READY(op)) ?\
                                              0 : _PyUnicode_Ready((PyObject *)(op)))
  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_LENGTH(u)
  #define __Pyx_PyUnicode_READ_CHAR(u, i) PyUnicode_READ_CHAR(u, i)
  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   PyUnicode_MAX_CHAR_VALUE(u)
  #define __Pyx_PyUnicode_KIND(u)         PyUnicode_KIND(u)
  #define __Pyx_PyUnicode_DATA(u)         PyUnicode_DATA(u)
  #define __Pyx_PyUnicode_READ(k, d, i)   PyUnicode_READ(k, d, i)
  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  PyUnicode_WRITE(k, d, i, ch)
  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != (likely(PyUnicode_IS_READY(u)) ? PyUnicode_GET_LENGTH(u) : PyUnicode_GET_SIZE(u)))
#else
  #define CYTHON_PEP393_ENABLED 0
  #define PyUnicode_1BYTE_KIND  1
  #define PyUnicode_2BYTE_KIND  2
  #define PyUnicode_4BYTE_KIND  4
  #define __Pyx_PyUnicode_READY(op)       (0)
  #define __Pyx_PyUnicode_GET_LENGTH(u)   PyUnicode_GET_SIZE(u)
  #define __Pyx_PyUnicode_READ_CHAR(u, i) ((Py_UCS4)(PyUnicode_AS_UNICODE(u)[i]))
  #define __Pyx_PyUnicode_MAX_CHAR_VALUE(u)   ((sizeof(Py_UNICODE) == 2) ? 65535 : 1114111)
  #define __Pyx_PyUnicode_KIND(u)         (sizeof(Py_UNICODE))
  #define __Pyx_PyUnicode_DATA(u)         ((void*)PyUnicode_AS_UNICODE(u))
  #define __Pyx_PyUnicode_READ(k, d, i)   ((void)(k), (Py_UCS4)(((Py_UNICODE*)d)[i]))
  #define __Pyx_PyUnicode_WRITE(k, d, i, ch)  (((void)(k)), ((Py_UNICODE*)d)[i] = ch)
  #define __Pyx_PyUnicode_IS_TRUE(u)      (0 != PyUnicode_GET_SIZE(u))
#endif
#if CYTHON_COMPILING_IN_PYPY
  #define __Pyx_PyUnicode_Concat(a, b)      PyNumber_Add(a, b)
  #define __Pyx_PyUnicode_ConcatSafe(a, b)  PyNumber_Add(a, b)
#else
  #define __Pyx_PyUnicode_Concat(a, b)      PyUnicode_Concat(a, b)
  #define __Pyx_PyUnicode_ConcatSafe(a, b)  ((unlikely((a) == Py_None) || unlikely((b) == Py_None)) ?\
      PyNumber_Add(a, b) : __Pyx_PyUnicode_Concat(a, b))
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyUnicode_Contains)
  #define PyUnicode_Contains(u, s)  PySequence_Contains(u, s)
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyByteArray_Check)
  #define PyByteArray_Check(obj)  PyObject_TypeCheck(obj, &PyByteArray_Type)
#endif
#if CYTHON_COMPILING_IN_PYPY && !defined(PyObject_Format)
  #define PyObject_Format(obj, fmt)  PyObject_CallMethod(obj, "__format__", "O", fmt)
#endif
#define __Pyx_PyString_FormatSafe(a, b)   ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : __Pyx_PyString_Format(a, b))
#define __Pyx_PyUnicode_FormatSafe(a, b)  ((unlikely((a) == Py_None)) ? PyNumber_Remainder(a, b) : PyUnicode_Format(a, b))
#if PY_MAJOR_VERSION >= 3
  #define __Pyx_PyString_Format(a, b)  PyUnicode_Format(a, b)
#else
  #define __Pyx_PyString_Format(a, b)  PyString_Format(a, b)
#endif
#if PY_MAJOR_VERSION < 3 && !defined(PyObject_ASCII)
  #define PyObject_ASCII(o)            PyObject_Repr(o)
#endif
#if PY_MAJOR_VERSION >= 3
  #define PyBaseString_Type            PyUnicode_Type
  #define PyStringObject               PyUnicodeObject
  #define PyString_Type                PyUnicode_Type
  #define PyString_Check               PyUnicode_Check
  #define PyString_CheckExact          PyUnicode_CheckExact
  #define PyObject_Unicode             PyObject_Str
#endif
#if PY_MAJOR_VERSION >= 3
  #define __Pyx_PyBaseString_Check(obj) PyUnicode_Check(obj)
  #define __Pyx_PyBaseString_CheckExact(obj) PyUnicode_CheckExact(obj)
#else
  #define __Pyx_PyBaseString_Check(obj) (PyString_Check(obj) || PyUnicode_Check(obj))
  #define __Pyx_PyBaseString_CheckExact(obj) (PyString_CheckExact(obj) || PyUnicode_CheckExact(obj))
#endif
#ifndef PySet_CheckExact
  #define PySet_CheckExact(obj)        (Py_TYPE(obj) == &PySet_Type)
#endif
#if CYTHON_ASSUME_SAFE_MACROS
  #define __Pyx_PySequence_SIZE(seq)  Py_SIZE(seq)
#else
  #define __Pyx_PySequence_SIZE(seq)  PySequence_Size(seq)
#endif
#if PY_MAJOR_VERSION >= 3
  #define PyIntObject                  PyLongObject
  #define PyInt_Type                   PyLong_Type
  #define PyInt_Check(op)              PyLong_Check(op)
  #define PyInt_CheckExact(op)         PyLong_CheckExact(op)
  #define PyInt_FromString             PyLong_FromString
  #define PyInt_FromUnicode            PyLong_FromUnicode
  #define PyInt_FromLong               PyLong_FromLong
  #define PyInt_FromSize_t             PyLong_FromSize_t
  #define PyInt_FromSsize_t            PyLong_FromSsize_t
  #define PyInt_AsLong                 PyLong_AsLong
  #define PyInt_AS_LONG                PyLong_AS_LONG
  #define PyInt_AsSsize_t              PyLong_AsSsize_t
  #define PyInt_AsUnsignedLongMask     PyLong_AsUnsignedLongMask
  #define PyInt_AsUnsignedLongLongMask PyLong_AsUnsignedLongLongMask
  #define PyNumber_Int                 PyNumber_Long
#endif
#if PY_MAJOR_VERSION >= 3
  #define PyBoolObject                 PyLongObject
#endif
#if PY_MAJOR_VERSION >= 3 && CYTHON_COMPILING_IN_PYPY
  #ifndef PyUnicode_InternFromString
    #define PyUnicode_InternFromString(s) PyUnicode_FromString(s)
  #endif
#endif
#if PY_VERSION_HEX < 0x030200A4
  typedef long Py_hash_t;
  #define __Pyx_PyInt_FromHash_t PyInt_FromLong
  #define __Pyx_PyInt_AsHash_t   PyInt_AsLong
#else
  #define __Pyx_PyInt_FromHash_t PyInt_FromSsize_t
  #define __Pyx_PyInt_AsHash_t   PyInt_AsSsize_t
#endif
#if PY_MAJOR_VERSION >= 3
  #define __Pyx_PyMethod_New(func, self, klass) ((self) ? PyMethod_New(func, self) : (Py_INCREF(func), func))
#else
  #define __Pyx_PyMethod_New(func, self, klass) PyMethod_New(func, self, klass)
#endif
#if CYTHON_USE_ASYNC_SLOTS
  #if PY_VERSION_HEX >= 0x030500B1
    #define __Pyx_PyAsyncMethodsStruct PyAsyncMethods
    #define __Pyx_PyType_AsAsync(obj) (Py_TYPE(obj)->tp_as_async)
  #else
    #define __Pyx_PyType_AsAsync(obj) ((__Pyx_PyAsyncMethodsStruct*) (Py_TYPE(obj)->tp_reserved))
  #endif
#else
  #define __Pyx_PyType_AsAsync(obj) NULL
#endif
#ifndef __Pyx_PyAsyncMethodsStruct
    typedef struct {
        unaryfunc am_await;
        unaryfunc am_aiter;
        unaryfunc am_anext;
    } __Pyx_PyAsyncMethodsStruct;
#endif

#if defined(WIN32) || defined(MS_WINDOWS)
  #define _USE_MATH_DEFINES
#endif
#include <math.h>
#ifdef NAN
#define __PYX_NAN() ((float) NAN)
#else
static CYTHON_INLINE float __PYX_NAN() {
  float value;
  memset(&value, 0xFF, sizeof(value));
  return value;
}
#endif
#if defined(__CYGWIN__) && defined(_LDBL_EQ_DBL)
#define __Pyx_truncl trunc
#else
#define __Pyx_truncl truncl
#endif


#define __PYX_ERR(f_index, lineno, Ln_error) \
{ \
  __pyx_filename = __pyx_f[f_index]; __pyx_lineno = lineno; __pyx_clineno = __LINE__; goto Ln_error; \
}

#ifndef __PYX_EXTERN_C
  #ifdef __cplusplus
    #define __PYX_EXTERN_C extern "C"
  #else
    #define __PYX_EXTERN_C extern
  #endif
#endif

#define __PYX_HAVE__cython_test
#define __PYX_HAVE_API__cython_test
/* Early includes */
#ifdef _OPENMP
#include <omp.h>
#endif /* _OPENMP */

#if defined(PYREX_WITHOUT_ASSERTIONS) && !defined(CYTHON_WITHOUT_ASSERTIONS)
#define CYTHON_WITHOUT_ASSERTIONS
#endif

typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const char* encoding;
                const char is_unicode; const char is_str; const char intern; } __Pyx_StringTabEntry;

#define __PYX_DEFAULT_STRING_ENCODING_IS_ASCII 0
#define __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT 0
#define __PYX_DEFAULT_STRING_ENCODING ""
#define __Pyx_PyObject_FromString __Pyx_PyBytes_FromString
#define __Pyx_PyObject_FromStringAndSize __Pyx_PyBytes_FromStringAndSize
#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)))  )
#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)
    #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__)
    #define __Pyx_sst_abs(value) __builtin_llabs(value)
#else
    #define __Pyx_sst_abs(value) ((value<0) ? -value : value)
#endif
static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject*);
static CYTHON_INLINE const char* __Pyx_PyObject_AsStringAndSize(PyObject*, Py_ssize_t* length);
#define __Pyx_PyByteArray_FromString(s) PyByteArray_FromStringAndSize((const char*)s, strlen((const char*)s))
#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_PyObject_AsString(s))
#define __Pyx_PyObject_AsWritableSString(s)    ((signed char*) __Pyx_PyObject_AsString(s))
#define __Pyx_PyObject_AsWritableUString(s)    ((unsigned char*) __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)
static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) {
    const Py_UNICODE *u_end = u;
    while (*u_end++) ;
    return (size_t)(u_end - u - 1);
}
#define __Pyx_PyUnicode_FromUnicode(u)       PyUnicode_FromUnicode(u, __Pyx_Py_UNICODE_strlen(u))
#define __Pyx_PyUnicode_FromUnicodeAndLength PyUnicode_FromUnicode
#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 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);
#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
#define __Pyx_PyNumber_Float(x) (PyFloat_CheckExact(x) ? __Pyx_NewRef(x) : PyNumber_Float(x))
#if PY_MAJOR_VERSION < 3 && __PYX_DEFAULT_STRING_ENCODING_IS_ASCII
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] = 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)
#if __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT
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));
    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


/* Test for GCC > 2.95 */
#if defined(__GNUC__)     && (__GNUC__ > 2 || (__GNUC__ == 2 && (__GNUC_MINOR__ > 95)))
  #define likely(x)   __builtin_expect(!!(x), 1)
  #define unlikely(x) __builtin_expect(!!(x), 0)
#else /* !__GNUC__ or GCC < 2.95 */
  #define likely(x)   (x)
  #define unlikely(x) (x)
#endif /* __GNUC__ */
static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void)ptr; }

static PyObject *__pyx_m = NULL;
static PyObject *__pyx_d;
static PyObject *__pyx_b;
static PyObject *__pyx_cython_runtime = NULL;
static PyObject *__pyx_empty_tuple;
static PyObject *__pyx_empty_bytes;
static PyObject *__pyx_empty_unicode;
static int __pyx_lineno;
static int __pyx_clineno = 0;
static const char * __pyx_cfilenm= __FILE__;
static const char *__pyx_filename;


static const char *__pyx_f[] = {
  "cython_test.pyx",
};

/*--- Type declarations ---*/

/* --- Runtime support code (head) --- */
/* Refnanny.proto */
#ifndef CYTHON_REFNANNY
  #define CYTHON_REFNANNY 0
#endif
#if CYTHON_REFNANNY
  typedef struct {
    void (*INCREF)(void*, PyObject*, int);
    void (*DECREF)(void*, PyObject*, int);
    void (*GOTREF)(void*, PyObject*, int);
    void (*GIVEREF)(void*, PyObject*, int);
    void* (*SetupContext)(const char*, int, const char*);
    void (*FinishContext)(void**);
  } __Pyx_RefNannyAPIStruct;
  static __Pyx_RefNannyAPIStruct *__Pyx_RefNanny = NULL;
  static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname);
  #define __Pyx_RefNannyDeclarations void *__pyx_refnanny = NULL;
#ifdef WITH_THREAD
  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
          if (acquire_gil) {\
              PyGILState_STATE __pyx_gilstate_save = PyGILState_Ensure();\
              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
              PyGILState_Release(__pyx_gilstate_save);\
          } else {\
              __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__);\
          }
#else
  #define __Pyx_RefNannySetupContext(name, acquire_gil)\
          __pyx_refnanny = __Pyx_RefNanny->SetupContext((name), __LINE__, __FILE__)
#endif
  #define __Pyx_RefNannyFinishContext()\
          __Pyx_RefNanny->FinishContext(&__pyx_refnanny)
  #define __Pyx_INCREF(r)  __Pyx_RefNanny->INCREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
  #define __Pyx_DECREF(r)  __Pyx_RefNanny->DECREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
  #define __Pyx_GOTREF(r)  __Pyx_RefNanny->GOTREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
  #define __Pyx_GIVEREF(r) __Pyx_RefNanny->GIVEREF(__pyx_refnanny, (PyObject *)(r), __LINE__)
  #define __Pyx_XINCREF(r)  do { if((r) != NULL) {__Pyx_INCREF(r); }} while(0)
  #define __Pyx_XDECREF(r)  do { if((r) != NULL) {__Pyx_DECREF(r); }} while(0)
  #define __Pyx_XGOTREF(r)  do { if((r) != NULL) {__Pyx_GOTREF(r); }} while(0)
  #define __Pyx_XGIVEREF(r) do { if((r) != NULL) {__Pyx_GIVEREF(r);}} while(0)
#else
  #define __Pyx_RefNannyDeclarations
  #define __Pyx_RefNannySetupContext(name, acquire_gil)
  #define __Pyx_RefNannyFinishContext()
  #define __Pyx_INCREF(r) Py_INCREF(r)
  #define __Pyx_DECREF(r) Py_DECREF(r)
  #define __Pyx_GOTREF(r)
  #define __Pyx_GIVEREF(r)
  #define __Pyx_XINCREF(r) Py_XINCREF(r)
  #define __Pyx_XDECREF(r) Py_XDECREF(r)
  #define __Pyx_XGOTREF(r)
  #define __Pyx_XGIVEREF(r)
#endif
#define __Pyx_XDECREF_SET(r, v) do {\
        PyObject *tmp = (PyObject *) r;\
        r = v; __Pyx_XDECREF(tmp);\
    } while (0)
#define __Pyx_DECREF_SET(r, v) do {\
        PyObject *tmp = (PyObject *) r;\
        r = v; __Pyx_DECREF(tmp);\
    } while (0)
#define __Pyx_CLEAR(r)    do { PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);} while(0)
#define __Pyx_XCLEAR(r)   do { if((r) != NULL) {PyObject* tmp = ((PyObject*)(r)); r = NULL; __Pyx_DECREF(tmp);}} while(0)

/* PyObjectGetAttrStr.proto */
#if CYTHON_USE_TYPE_SLOTS
static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name);
#else
#define __Pyx_PyObject_GetAttrStr(o,n) PyObject_GetAttr(o,n)
#endif

/* GetBuiltinName.proto */
static PyObject *__Pyx_GetBuiltinName(PyObject *name);

/* RaiseArgTupleInvalid.proto */
static void __Pyx_RaiseArgtupleInvalid(const char* func_name, int exact,
    Py_ssize_t num_min, Py_ssize_t num_max, Py_ssize_t num_found);

/* RaiseDoubleKeywords.proto */
static void __Pyx_RaiseDoubleKeywordsError(const char* func_name, PyObject* kw_name);

/* ParseKeywords.proto */
static int __Pyx_ParseOptionalKeywords(PyObject *kwds, PyObject **argnames[],\
    PyObject *kwds2, PyObject *values[], Py_ssize_t num_pos_args,\
    const char* function_name);

/* GetItemInt.proto */
#define __Pyx_GetItemInt(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
    __Pyx_GetItemInt_Fast(o, (Py_ssize_t)i, is_list, wraparound, boundscheck) :\
    (is_list ? (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL) :\
               __Pyx_GetItemInt_Generic(o, to_py_func(i))))
#define __Pyx_GetItemInt_List(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
    __Pyx_GetItemInt_List_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
    (PyErr_SetString(PyExc_IndexError, "list index out of range"), (PyObject*)NULL))
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
                                                              int wraparound, int boundscheck);
#define __Pyx_GetItemInt_Tuple(o, i, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
    __Pyx_GetItemInt_Tuple_Fast(o, (Py_ssize_t)i, wraparound, boundscheck) :\
    (PyErr_SetString(PyExc_IndexError, "tuple index out of range"), (PyObject*)NULL))
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
                                                              int wraparound, int boundscheck);
static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j);
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i,
                                                     int is_list, int wraparound, int boundscheck);

/* PyDictContains.proto */
static CYTHON_INLINE int __Pyx_PyDict_ContainsTF(PyObject* item, PyObject* dict, int eq) {
    int result = PyDict_Contains(dict, item);
    return unlikely(result < 0) ? result : (result == (eq == Py_EQ));
}

/* DictGetItem.proto */
#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key);
#define __Pyx_PyObject_Dict_GetItem(obj, name)\
    (likely(PyDict_CheckExact(obj)) ?\
     __Pyx_PyDict_GetItem(obj, name) : PyObject_GetItem(obj, name))
#else
#define __Pyx_PyDict_GetItem(d, key) PyObject_GetItem(d, key)
#define __Pyx_PyObject_Dict_GetItem(obj, name)  PyObject_GetItem(obj, name)
#endif

/* PyCFunctionFastCall.proto */
#if CYTHON_FAST_PYCCALL
static CYTHON_INLINE PyObject *__Pyx_PyCFunction_FastCall(PyObject *func, PyObject **args, Py_ssize_t nargs);
#else
#define __Pyx_PyCFunction_FastCall(func, args, nargs)  (assert(0), NULL)
#endif

/* PyFunctionFastCall.proto */
#if CYTHON_FAST_PYCALL
#define __Pyx_PyFunction_FastCall(func, args, nargs)\
    __Pyx_PyFunction_FastCallDict((func), (args), (nargs), NULL)
#if 1 || PY_VERSION_HEX < 0x030600B1
static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs);
#else
#define __Pyx_PyFunction_FastCallDict(func, args, nargs, kwargs) _PyFunction_FastCallDict(func, args, nargs, kwargs)
#endif
#endif

/* PyObjectCall.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw);
#else
#define __Pyx_PyObject_Call(func, arg, kw) PyObject_Call(func, arg, kw)
#endif

/* PyObjectCallMethO.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg);
#endif

/* PyObjectCallOneArg.proto */
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg);

/* PyThreadStateGet.proto */
#if CYTHON_FAST_THREAD_STATE
#define __Pyx_PyThreadState_declare  PyThreadState *__pyx_tstate;
#define __Pyx_PyThreadState_assign  __pyx_tstate = __Pyx_PyThreadState_Current;
#define __Pyx_PyErr_Occurred()  __pyx_tstate->curexc_type
#else
#define __Pyx_PyThreadState_declare
#define __Pyx_PyThreadState_assign
#define __Pyx_PyErr_Occurred()  PyErr_Occurred()
#endif

/* PyErrFetchRestore.proto */
#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(__pyx_tstate, type, value, tb)
#define __Pyx_ErrFetch(type, value, tb)    __Pyx_ErrFetchInState(__pyx_tstate, type, value, tb)
static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb);
static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb);
#if CYTHON_COMPILING_IN_CPYTHON
#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

/* RaiseException.proto */
static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, PyObject *cause);

/* SetItemInt.proto */
#define __Pyx_SetItemInt(o, i, v, type, is_signed, to_py_func, is_list, wraparound, boundscheck)\
    (__Pyx_fits_Py_ssize_t(i, type, is_signed) ?\
    __Pyx_SetItemInt_Fast(o, (Py_ssize_t)i, v, is_list, wraparound, boundscheck) :\
    (is_list ? (PyErr_SetString(PyExc_IndexError, "list assignment index out of range"), -1) :\
               __Pyx_SetItemInt_Generic(o, to_py_func(i), v)))
static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v);
static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v,
                                               int is_list, int wraparound, int boundscheck);

/* IterFinish.proto */
static CYTHON_INLINE int __Pyx_IterFinish(void);

/* PyObjectCallNoArg.proto */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func);
#else
#define __Pyx_PyObject_CallNoArg(func) __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL)
#endif

/* PyObjectCallMethod0.proto */
static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name);

/* RaiseNeedMoreValuesToUnpack.proto */
static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index);

/* RaiseTooManyValuesToUnpack.proto */
static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected);

/* UnpackItemEndCheck.proto */
static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected);

/* RaiseNoneIterError.proto */
static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void);

/* UnpackTupleError.proto */
static void __Pyx_UnpackTupleError(PyObject *, Py_ssize_t index);

/* UnpackTuple2.proto */
#define __Pyx_unpack_tuple2(tuple, value1, value2, is_tuple, has_known_size, decref_tuple)\
    (likely(is_tuple || PyTuple_Check(tuple)) ?\
        (likely(has_known_size || PyTuple_GET_SIZE(tuple) == 2) ?\
            __Pyx_unpack_tuple2_exact(tuple, value1, value2, decref_tuple) :\
            (__Pyx_UnpackTupleError(tuple, 2), -1)) :\
        __Pyx_unpack_tuple2_generic(tuple, value1, value2, has_known_size, decref_tuple))
static CYTHON_INLINE int __Pyx_unpack_tuple2_exact(
    PyObject* tuple, PyObject** value1, PyObject** value2, int decref_tuple);
static int __Pyx_unpack_tuple2_generic(
    PyObject* tuple, PyObject** value1, PyObject** value2, int has_known_size, int decref_tuple);

/* 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);

/* 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);
        PyList_SET_ITEM(list, len, x);
        Py_SIZE(list) = len+1;
        return 0;
    }
    return PyList_Append(list, x);
}
#else
#define __Pyx_PyList_Append(L,x) PyList_Append(L,x)
#endif

/* FetchCommonType.proto */
static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type);

/* CythonFunction.proto */
#define __Pyx_CyFunction_USED 1
#define __Pyx_CYFUNCTION_STATICMETHOD  0x01
#define __Pyx_CYFUNCTION_CLASSMETHOD   0x02
#define __Pyx_CYFUNCTION_CCLASS        0x04
#define __Pyx_CyFunction_GetClosure(f)\
    (((__pyx_CyFunctionObject *) (f))->func_closure)
#define __Pyx_CyFunction_GetClassObj(f)\
    (((__pyx_CyFunctionObject *) (f))->func_classobj)
#define __Pyx_CyFunction_Defaults(type, f)\
    ((type *)(((__pyx_CyFunctionObject *) (f))->defaults))
#define __Pyx_CyFunction_SetDefaultsGetter(f, g)\
    ((__pyx_CyFunctionObject *) (f))->defaults_getter = (g)
typedef struct {
    PyCFunctionObject func;
#if PY_VERSION_HEX < 0x030500A0
    PyObject *func_weakreflist;
#endif
    PyObject *func_dict;
    PyObject *func_name;
    PyObject *func_qualname;
    PyObject *func_doc;
    PyObject *func_globals;
    PyObject *func_code;
    PyObject *func_closure;
    PyObject *func_classobj;
    void *defaults;
    int defaults_pyobjects;
    int flags;
    PyObject *defaults_tuple;
    PyObject *defaults_kwdict;
    PyObject *(*defaults_getter)(PyObject *);
    PyObject *func_annotations;
} __pyx_CyFunctionObject;
static PyTypeObject *__pyx_CyFunctionType = 0;
#define __Pyx_CyFunction_NewEx(ml, flags, qualname, self, module, globals, code)\
    __Pyx_CyFunction_New(__pyx_CyFunctionType, ml, flags, qualname, self, module, globals, code)
static PyObject *__Pyx_CyFunction_New(PyTypeObject *, PyMethodDef *ml,
                                      int flags, PyObject* qualname,
                                      PyObject *self,
                                      PyObject *module, PyObject *globals,
                                      PyObject* code);
static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *m,
                                                         size_t size,
                                                         int pyobjects);
static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *m,
                                                            PyObject *tuple);
static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *m,
                                                             PyObject *dict);
static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *m,
                                                              PyObject *dict);
static int __pyx_CyFunction_init(void);

/* FusedFunction.proto */
typedef struct {
    __pyx_CyFunctionObject func;
    PyObject *__signatures__;
    PyObject *type;
    PyObject *self;
} __pyx_FusedFunctionObject;
#define __pyx_FusedFunction_NewEx(ml, flags, qualname, self, module, globals, code)\
        __pyx_FusedFunction_New(__pyx_FusedFunctionType, ml, flags, qualname, self, module, globals, code)
static PyObject *__pyx_FusedFunction_New(PyTypeObject *type,
                                         PyMethodDef *ml, int flags,
                                         PyObject *qualname, PyObject *self,
                                         PyObject *module, PyObject *globals,
                                         PyObject *code);
static int __pyx_FusedFunction_clear(__pyx_FusedFunctionObject *self);
static PyTypeObject *__pyx_FusedFunctionType = NULL;
static int __pyx_FusedFunction_init(void);
#define __Pyx_FusedFunction_USED

/* CLineInTraceback.proto */
#ifdef CYTHON_CLINE_IN_TRACEBACK
#define __Pyx_CLineForTraceback(tstate, c_line)  (((CYTHON_CLINE_IN_TRACEBACK)) ? c_line : 0)
#else
static int __Pyx_CLineForTraceback(PyThreadState *tstate, int c_line);
#endif

/* CodeObjectCache.proto */
typedef struct {
    PyCodeObject* code_object;
    int code_line;
} __Pyx_CodeObjectCacheEntry;
struct __Pyx_CodeObjectCache {
    int count;
    int max_count;
    __Pyx_CodeObjectCacheEntry* entries;
};
static struct __Pyx_CodeObjectCache __pyx_code_cache = {0,0,NULL};
static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries, int count, int code_line);
static PyCodeObject *__pyx_find_code_object(int code_line);
static void __pyx_insert_code_object(int code_line, PyCodeObject* code_object);

/* AddTraceback.proto */
static void __Pyx_AddTraceback(const char *funcname, int c_line,
                               int py_line, const char *filename);

/* CIntToPy.proto */
static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value);

/* Import.proto */
static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int level);

/* CIntFromPy.proto */
static CYTHON_INLINE long __Pyx_PyInt_As_long(PyObject *);

/* ImportNumPyArray.proto */
static PyObject *__pyx_numpy_ndarray = NULL;
static PyObject* __Pyx_ImportNumPyArrayTypeIfAvailable(void);

/* CIntFromPy.proto */
static CYTHON_INLINE int __Pyx_PyInt_As_int(PyObject *);

/* FastTypeChecks.proto */
#if CYTHON_COMPILING_IN_CPYTHON
#define __Pyx_TypeCheck(obj, type) __Pyx_IsSubtype(Py_TYPE(obj), (PyTypeObject *)type)
static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *b);
static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err, PyObject *type);
static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *err, PyObject *type1, PyObject *type2);
#else
#define __Pyx_TypeCheck(obj, type) PyObject_TypeCheck(obj, (PyTypeObject *)type)
#define __Pyx_PyErr_GivenExceptionMatches(err, type) PyErr_GivenExceptionMatches(err, type)
#define __Pyx_PyErr_GivenExceptionMatches2(err, type1, type2) (PyErr_GivenExceptionMatches(err, type1) || PyErr_GivenExceptionMatches(err, type2))
#endif
#define __Pyx_PyException_Check(obj) __Pyx_TypeCheck(obj, PyExc_Exception)

/* CheckBinaryVersion.proto */
static int __Pyx_check_binary_version(void);

/* InitStrings.proto */
static int __Pyx_InitStrings(__Pyx_StringTabEntry *t);


/* Module declarations from 'cython' */

/* Module declarations from 'cython_test' */
static PyObject *__pyx_fuse_0__pyx_f_11cython_test_sqrt(float, int __pyx_skip_dispatch); /*proto*/
static PyObject *__pyx_fuse_1__pyx_f_11cython_test_sqrt(double, int __pyx_skip_dispatch); /*proto*/
#define __Pyx_MODULE_NAME "cython_test"
extern int __pyx_module_is_main_cython_test;
int __pyx_module_is_main_cython_test = 0;

/* Implementation of 'cython_test' */
static PyObject *__pyx_builtin_TypeError;
static PyObject *__pyx_builtin_range;
static const char __pyx_k_[] = "";
static const char __pyx_k__2[] = "()";
static const char __pyx_k__4[] = "|";
static const char __pyx_k_args[] = "args";
static const char __pyx_k_main[] = "__main__";
static const char __pyx_k_name[] = "__name__";
static const char __pyx_k_sqrt[] = "sqrt";
static const char __pyx_k_test[] = "__test__";
static const char __pyx_k_float[] = "float";
static const char __pyx_k_numpy[] = "numpy";
static const char __pyx_k_range[] = "range";
static const char __pyx_k_split[] = "split";
static const char __pyx_k_strip[] = "strip";
static const char __pyx_k_value[] = "value";
static const char __pyx_k_double[] = "double";
static const char __pyx_k_import[] = "__import__";
static const char __pyx_k_kwargs[] = "kwargs";
static const char __pyx_k_defaults[] = "defaults";
static const char __pyx_k_TypeError[] = "TypeError";
static const char __pyx_k_signatures[] = "signatures";
static const char __pyx_k_cython_test[] = "cython_test";
static const char __pyx_k_pyx_fuse_0sqrt[] = "__pyx_fuse_0sqrt";
static const char __pyx_k_pyx_fuse_1sqrt[] = "__pyx_fuse_1sqrt";
static const char __pyx_k_cython_test_pyx[] = "cython_test.pyx";
static const char __pyx_k_cline_in_traceback[] = "cline_in_traceback";
static const char __pyx_k_No_matching_signature_found[] = "No matching signature found";
static const char __pyx_k_simple_test_file_for_cython_sou[] = " simple test file for cython source mapping: defines a function\nthat uses newtowns method to compute the square root of a number ";
static const char __pyx_k_Expected_at_least_d_argument_s_g[] = "Expected at least %d argument%s, got %d";
static const char __pyx_k_Function_call_with_ambiguous_arg[] = "Function call with ambiguous argument types";
static PyObject *__pyx_kp_s_;
static PyObject *__pyx_kp_s_Expected_at_least_d_argument_s_g;
static PyObject *__pyx_kp_s_Function_call_with_ambiguous_arg;
static PyObject *__pyx_kp_s_No_matching_signature_found;
static PyObject *__pyx_n_s_TypeError;
static PyObject *__pyx_kp_s__2;
static PyObject *__pyx_kp_s__4;
static PyObject *__pyx_n_s_args;
static PyObject *__pyx_n_s_cline_in_traceback;
static PyObject *__pyx_n_s_cython_test;
static PyObject *__pyx_kp_s_cython_test_pyx;
static PyObject *__pyx_n_s_defaults;
static PyObject *__pyx_n_s_double;
static PyObject *__pyx_n_s_float;
static PyObject *__pyx_n_s_import;
static PyObject *__pyx_n_s_kwargs;
static PyObject *__pyx_n_s_main;
static PyObject *__pyx_n_s_name;
static PyObject *__pyx_n_s_numpy;
static PyObject *__pyx_n_s_pyx_fuse_0sqrt;
static PyObject *__pyx_n_s_pyx_fuse_1sqrt;
static PyObject *__pyx_n_s_range;
static PyObject *__pyx_n_s_signatures;
static PyObject *__pyx_n_s_split;
static PyObject *__pyx_n_s_sqrt;
static PyObject *__pyx_n_s_strip;
static PyObject *__pyx_n_s_test;
static PyObject *__pyx_n_s_value;
static PyObject *__pyx_pf_11cython_test_sqrt(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_signatures, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs, CYTHON_UNUSED PyObject *__pyx_v_defaults); /* proto */
static PyObject *__pyx_pf_11cython_test_2__pyx_fuse_0sqrt(CYTHON_UNUSED PyObject *__pyx_self, float __pyx_v_value); /* proto */
static PyObject *__pyx_pf_11cython_test_4__pyx_fuse_1sqrt(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_value); /* proto */
static PyObject *__pyx_int_1;
static PyObject *__pyx_tuple__3;
static PyObject *__pyx_tuple__5;
static PyObject *__pyx_tuple__6;
static PyObject *__pyx_tuple__7;
static PyObject *__pyx_tuple__8;
static PyObject *__pyx_codeobj__9;
/* Late includes */

/* "cython_test.pyx":6
 * from cython cimport floating
 * 
 * cpdef sqrt(floating value):             # <<<<<<<<<<<<<<
 *     # solve for the square root of value by finding the zeros of
 *     #   'x * x - value = 0' using newtons meethod
 */

/* Python wrapper */
static PyObject *__pyx_pw_11cython_test_1sqrt(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyMethodDef __pyx_mdef_11cython_test_1sqrt = {"sqrt", (PyCFunction)__pyx_pw_11cython_test_1sqrt, METH_VARARGS|METH_KEYWORDS, 0};
static PyObject *__pyx_pw_11cython_test_1sqrt(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds) {
  PyObject *__pyx_v_signatures = 0;
  PyObject *__pyx_v_args = 0;
  PyObject *__pyx_v_kwargs = 0;
  CYTHON_UNUSED PyObject *__pyx_v_defaults = 0;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__pyx_fused_cpdef (wrapper)", 0);
  {
    static PyObject **__pyx_pyargnames[] = {&__pyx_n_s_signatures,&__pyx_n_s_args,&__pyx_n_s_kwargs,&__pyx_n_s_defaults,0};
    PyObject* values[4] = {0,0,0,0};
    if (unlikely(__pyx_kwds)) {
      Py_ssize_t kw_args;
      const Py_ssize_t pos_args = PyTuple_GET_SIZE(__pyx_args);
      switch (pos_args) {
        case  4: values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
        CYTHON_FALLTHROUGH;
        case  3: values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
        CYTHON_FALLTHROUGH;
        case  2: values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
        CYTHON_FALLTHROUGH;
        case  1: values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
        CYTHON_FALLTHROUGH;
        case  0: break;
        default: goto __pyx_L5_argtuple_error;
      }
      kw_args = PyDict_Size(__pyx_kwds);
      switch (pos_args) {
        case  0:
        if (likely((values[0] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_signatures)) != 0)) kw_args--;
        else goto __pyx_L5_argtuple_error;
        CYTHON_FALLTHROUGH;
        case  1:
        if (likely((values[1] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_args)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 1); __PYX_ERR(0, 6, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  2:
        if (likely((values[2] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_kwargs)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 2); __PYX_ERR(0, 6, __pyx_L3_error)
        }
        CYTHON_FALLTHROUGH;
        case  3:
        if (likely((values[3] = __Pyx_PyDict_GetItemStr(__pyx_kwds, __pyx_n_s_defaults)) != 0)) kw_args--;
        else {
          __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, 3); __PYX_ERR(0, 6, __pyx_L3_error)
        }
      }
      if (unlikely(kw_args > 0)) {
        if (unlikely(__Pyx_ParseOptionalKeywords(__pyx_kwds, __pyx_pyargnames, 0, values, pos_args, "__pyx_fused_cpdef") < 0)) __PYX_ERR(0, 6, __pyx_L3_error)
      }
    } else if (PyTuple_GET_SIZE(__pyx_args) != 4) {
      goto __pyx_L5_argtuple_error;
    } else {
      values[0] = PyTuple_GET_ITEM(__pyx_args, 0);
      values[1] = PyTuple_GET_ITEM(__pyx_args, 1);
      values[2] = PyTuple_GET_ITEM(__pyx_args, 2);
      values[3] = PyTuple_GET_ITEM(__pyx_args, 3);
    }
    __pyx_v_signatures = values[0];
    __pyx_v_args = values[1];
    __pyx_v_kwargs = values[2];
    __pyx_v_defaults = values[3];
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L5_argtuple_error:;
  __Pyx_RaiseArgtupleInvalid("__pyx_fused_cpdef", 1, 4, 4, PyTuple_GET_SIZE(__pyx_args)); __PYX_ERR(0, 6, __pyx_L3_error)
  __pyx_L3_error:;
  __Pyx_AddTraceback("cython_test.__pyx_fused_cpdef", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_11cython_test_sqrt(__pyx_self, __pyx_v_signatures, __pyx_v_args, __pyx_v_kwargs, __pyx_v_defaults);

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_11cython_test_sqrt(CYTHON_UNUSED PyObject *__pyx_self, PyObject *__pyx_v_signatures, PyObject *__pyx_v_args, PyObject *__pyx_v_kwargs, CYTHON_UNUSED PyObject *__pyx_v_defaults) {
  PyObject *__pyx_v_dest_sig = NULL;
  Py_ssize_t __pyx_v_i;
  CYTHON_UNUSED PyTypeObject *__pyx_v_ndarray = 0;
  CYTHON_UNUSED Py_ssize_t __pyx_v_itemsize;
  PyObject *__pyx_v_arg = NULL;
  PyObject *__pyx_v_candidates = NULL;
  PyObject *__pyx_v_sig = NULL;
  int __pyx_v_match_found;
  PyObject *__pyx_v_src_sig = NULL;
  PyObject *__pyx_v_dst_type = NULL;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  int __pyx_t_2;
  int __pyx_t_3;
  int __pyx_t_4;
  Py_ssize_t __pyx_t_5;
  PyObject *__pyx_t_6 = NULL;
  Py_ssize_t __pyx_t_7;
  int __pyx_t_8;
  int __pyx_t_9;
  PyObject *__pyx_t_10 = NULL;
  Py_ssize_t __pyx_t_11;
  Py_ssize_t __pyx_t_12;
  Py_ssize_t __pyx_t_13;
  int __pyx_t_14;
  __Pyx_RefNannySetupContext("sqrt", 0);
  __Pyx_INCREF(__pyx_v_kwargs);
  __pyx_t_1 = PyList_New(1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_INCREF(Py_None);
  __Pyx_GIVEREF(Py_None);
  PyList_SET_ITEM(__pyx_t_1, 0, Py_None);
  __pyx_v_dest_sig = ((PyObject*)__pyx_t_1);
  __pyx_t_1 = 0;
  __pyx_t_3 = (__pyx_v_kwargs != Py_None);
  __pyx_t_4 = (__pyx_t_3 != 0);
  if (__pyx_t_4) {
  } else {
    __pyx_t_2 = __pyx_t_4;
    goto __pyx_L4_bool_binop_done;
  }
  __pyx_t_4 = __Pyx_PyObject_IsTrue(__pyx_v_kwargs); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 6, __pyx_L1_error)
  __pyx_t_3 = ((!__pyx_t_4) != 0);
  __pyx_t_2 = __pyx_t_3;
  __pyx_L4_bool_binop_done:;
  if (__pyx_t_2) {
    __Pyx_INCREF(Py_None);
    __Pyx_DECREF_SET(__pyx_v_kwargs, Py_None);
  }
  __pyx_t_1 = ((PyObject *)__Pyx_ImportNumPyArrayTypeIfAvailable()); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_v_ndarray = ((PyTypeObject*)__pyx_t_1);
  __pyx_t_1 = 0;
  __pyx_v_itemsize = -1L;
  if (unlikely(__pyx_v_args == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
    __PYX_ERR(0, 6, __pyx_L1_error)
  }
  __pyx_t_5 = PyTuple_GET_SIZE(((PyObject*)__pyx_v_args)); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6, __pyx_L1_error)
  __pyx_t_2 = ((0 < __pyx_t_5) != 0);
  if (__pyx_t_2) {
    if (unlikely(__pyx_v_args == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
      __PYX_ERR(0, 6, __pyx_L1_error)
    }
    __pyx_t_1 = __Pyx_GetItemInt_Tuple(((PyObject*)__pyx_v_args), 0, long, 1, __Pyx_PyInt_From_long, 0, 0, 1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_v_arg = __pyx_t_1;
    __pyx_t_1 = 0;
    goto __pyx_L6;
  }
  __pyx_t_3 = (__pyx_v_kwargs != Py_None);
  __pyx_t_4 = (__pyx_t_3 != 0);
  if (__pyx_t_4) {
  } else {
    __pyx_t_2 = __pyx_t_4;
    goto __pyx_L7_bool_binop_done;
  }
  if (unlikely(__pyx_v_kwargs == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
    __PYX_ERR(0, 6, __pyx_L1_error)
  }
  __pyx_t_4 = (__Pyx_PyDict_ContainsTF(__pyx_n_s_value, ((PyObject*)__pyx_v_kwargs), Py_EQ)); if (unlikely(__pyx_t_4 < 0)) __PYX_ERR(0, 6, __pyx_L1_error)
  __pyx_t_3 = (__pyx_t_4 != 0);
  __pyx_t_2 = __pyx_t_3;
  __pyx_L7_bool_binop_done:;
  if (__pyx_t_2) {
    if (unlikely(__pyx_v_kwargs == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
      __PYX_ERR(0, 6, __pyx_L1_error)
    }
    __pyx_t_1 = __Pyx_PyDict_GetItem(((PyObject*)__pyx_v_kwargs), __pyx_n_s_value); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_v_arg = __pyx_t_1;
    __pyx_t_1 = 0;
    goto __pyx_L6;
  }
  /*else*/ {
    if (unlikely(__pyx_v_args == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "object of type 'NoneType' has no len()");
      __PYX_ERR(0, 6, __pyx_L1_error)
    }
    __pyx_t_5 = PyTuple_GET_SIZE(((PyObject*)__pyx_v_args)); if (unlikely(__pyx_t_5 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6, __pyx_L1_error)
    __pyx_t_1 = PyInt_FromSsize_t(__pyx_t_5); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_6 = PyTuple_New(3); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_INCREF(__pyx_int_1);
    __Pyx_GIVEREF(__pyx_int_1);
    PyTuple_SET_ITEM(__pyx_t_6, 0, __pyx_int_1);
    __Pyx_INCREF(__pyx_kp_s_);
    __Pyx_GIVEREF(__pyx_kp_s_);
    PyTuple_SET_ITEM(__pyx_t_6, 1, __pyx_kp_s_);
    __Pyx_GIVEREF(__pyx_t_1);
    PyTuple_SET_ITEM(__pyx_t_6, 2, __pyx_t_1);
    __pyx_t_1 = 0;
    __pyx_t_1 = __Pyx_PyString_Format(__pyx_kp_s_Expected_at_least_d_argument_s_g, __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_t_6 = __Pyx_PyObject_CallOneArg(__pyx_builtin_TypeError, __pyx_t_1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_Raise(__pyx_t_6, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __PYX_ERR(0, 6, __pyx_L1_error)
  }
  __pyx_L6:;
  while (1) {
    __pyx_t_2 = PyFloat_Check(__pyx_v_arg); 
    __pyx_t_3 = (__pyx_t_2 != 0);
    if (__pyx_t_3) {
      if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, __pyx_n_s_double, long, 1, __Pyx_PyInt_From_long, 1, 0, 1) < 0)) __PYX_ERR(0, 6, __pyx_L1_error)
      goto __pyx_L10_break;
    }
    if (unlikely(__Pyx_SetItemInt(__pyx_v_dest_sig, 0, Py_None, long, 1, __Pyx_PyInt_From_long, 1, 0, 1) < 0)) __PYX_ERR(0, 6, __pyx_L1_error)
    goto __pyx_L10_break;
  }
  __pyx_L10_break:;
  __pyx_t_6 = PyList_New(0); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_6);
  __pyx_v_candidates = ((PyObject*)__pyx_t_6);
  __pyx_t_6 = 0;
  __pyx_t_5 = 0;
  if (unlikely(__pyx_v_signatures == Py_None)) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
    __PYX_ERR(0, 6, __pyx_L1_error)
  }
  __pyx_t_1 = __Pyx_dict_iterator(((PyObject*)__pyx_v_signatures), 1, ((PyObject *)NULL), (&__pyx_t_7), (&__pyx_t_8)); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_6);
  __pyx_t_6 = __pyx_t_1;
  __pyx_t_1 = 0;
  while (1) {
    __pyx_t_9 = __Pyx_dict_iter_next(__pyx_t_6, __pyx_t_7, &__pyx_t_5, &__pyx_t_1, NULL, NULL, __pyx_t_8);
    if (unlikely(__pyx_t_9 == 0)) break;
    if (unlikely(__pyx_t_9 == -1)) __PYX_ERR(0, 6, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_XDECREF_SET(__pyx_v_sig, __pyx_t_1);
    __pyx_t_1 = 0;
    __pyx_v_match_found = 0;
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_v_sig, __pyx_n_s_strip); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__3, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 6, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __pyx_t_1 = __Pyx_PyObject_GetAttrStr(__pyx_t_10, __pyx_n_s_split); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
    __pyx_t_10 = __Pyx_PyObject_Call(__pyx_t_1, __pyx_tuple__5, NULL); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 6, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_10);
    __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
    __Pyx_XDECREF_SET(__pyx_v_src_sig, __pyx_t_10);
    __pyx_t_10 = 0;
    __pyx_t_11 = PyList_GET_SIZE(__pyx_v_dest_sig); if (unlikely(__pyx_t_11 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6, __pyx_L1_error)
    __pyx_t_12 = __pyx_t_11;
    for (__pyx_t_13 = 0; __pyx_t_13 < __pyx_t_12; __pyx_t_13+=1) {
      __pyx_v_i = __pyx_t_13;
      __pyx_t_10 = __Pyx_GetItemInt_List(__pyx_v_dest_sig, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 1, 1, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 6, __pyx_L1_error)
      __Pyx_GOTREF(__pyx_t_10);
      __Pyx_XDECREF_SET(__pyx_v_dst_type, __pyx_t_10);
      __pyx_t_10 = 0;
      __pyx_t_3 = (__pyx_v_dst_type != Py_None);
      __pyx_t_2 = (__pyx_t_3 != 0);
      if (__pyx_t_2) {
        __pyx_t_10 = __Pyx_GetItemInt(__pyx_v_src_sig, __pyx_v_i, Py_ssize_t, 1, PyInt_FromSsize_t, 0, 1, 1); if (unlikely(!__pyx_t_10)) __PYX_ERR(0, 6, __pyx_L1_error)
        __Pyx_GOTREF(__pyx_t_10);
        __pyx_t_1 = PyObject_RichCompare(__pyx_t_10, __pyx_v_dst_type, Py_EQ); __Pyx_XGOTREF(__pyx_t_1); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_10); __pyx_t_10 = 0;
        __pyx_t_2 = __Pyx_PyObject_IsTrue(__pyx_t_1); if (unlikely(__pyx_t_2 < 0)) __PYX_ERR(0, 6, __pyx_L1_error)
        __Pyx_DECREF(__pyx_t_1); __pyx_t_1 = 0;
        if (__pyx_t_2) {
          __pyx_v_match_found = 1;
          goto __pyx_L17;
        }
        /*else*/ {
          __pyx_v_match_found = 0;
          goto __pyx_L15_break;
        }
        __pyx_L17:;
      }
    }
    __pyx_L15_break:;
    __pyx_t_2 = (__pyx_v_match_found != 0);
    if (__pyx_t_2) {
      __pyx_t_14 = __Pyx_PyList_Append(__pyx_v_candidates, __pyx_v_sig); if (unlikely(__pyx_t_14 == ((int)-1))) __PYX_ERR(0, 6, __pyx_L1_error)
    }
  }
  __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
  __pyx_t_2 = (PyList_GET_SIZE(__pyx_v_candidates) != 0);
  __pyx_t_3 = ((!__pyx_t_2) != 0);
  if (__pyx_t_3) {
    __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__6, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_Raise(__pyx_t_6, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __PYX_ERR(0, 6, __pyx_L1_error)
  }
  __pyx_t_7 = PyList_GET_SIZE(__pyx_v_candidates); if (unlikely(__pyx_t_7 == ((Py_ssize_t)-1))) __PYX_ERR(0, 6, __pyx_L1_error)
  __pyx_t_3 = ((__pyx_t_7 > 1) != 0);
  if (__pyx_t_3) {
    __pyx_t_6 = __Pyx_PyObject_Call(__pyx_builtin_TypeError, __pyx_tuple__7, NULL); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __Pyx_Raise(__pyx_t_6, 0, 0, 0);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __PYX_ERR(0, 6, __pyx_L1_error)
  }
  /*else*/ {
    __Pyx_XDECREF(__pyx_r);
    if (unlikely(__pyx_v_signatures == Py_None)) {
      PyErr_SetString(PyExc_TypeError, "'NoneType' object is not subscriptable");
      __PYX_ERR(0, 6, __pyx_L1_error)
    }
    __pyx_t_6 = __Pyx_GetItemInt_List(__pyx_v_candidates, 0, long, 1, __Pyx_PyInt_From_long, 1, 0, 1); if (unlikely(!__pyx_t_6)) __PYX_ERR(0, 6, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_6);
    __pyx_t_1 = __Pyx_PyDict_GetItem(((PyObject*)__pyx_v_signatures), __pyx_t_6); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error)
    __Pyx_GOTREF(__pyx_t_1);
    __Pyx_DECREF(__pyx_t_6); __pyx_t_6 = 0;
    __pyx_r = __pyx_t_1;
    __pyx_t_1 = 0;
    goto __pyx_L0;
  }

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_6);
  __Pyx_XDECREF(__pyx_t_10);
  __Pyx_AddTraceback("cython_test.__pyx_fused_cpdef", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XDECREF(__pyx_v_dest_sig);
  __Pyx_XDECREF(__pyx_v_ndarray);
  __Pyx_XDECREF(__pyx_v_arg);
  __Pyx_XDECREF(__pyx_v_candidates);
  __Pyx_XDECREF(__pyx_v_sig);
  __Pyx_XDECREF(__pyx_v_src_sig);
  __Pyx_XDECREF(__pyx_v_dst_type);
  __Pyx_XDECREF(__pyx_v_kwargs);
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pw_11cython_test_3__pyx_fuse_0sqrt(PyObject *__pyx_self, PyObject *__pyx_arg_value); /*proto*/
static PyObject *__pyx_pw_11cython_test_1sqrt(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyObject *__pyx_fuse_0__pyx_f_11cython_test_sqrt(float __pyx_v_value, CYTHON_UNUSED int __pyx_skip_dispatch) {
  double __pyx_v_x;
  CYTHON_UNUSED long __pyx_v__;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  long __pyx_t_1;
  double __pyx_t_2;
  double __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  __Pyx_RefNannySetupContext("__pyx_fuse_0sqrt", 0);

  /* "cython_test.pyx":9
 *     # solve for the square root of value by finding the zeros of
 *     #   'x * x - value = 0' using newtons meethod
 *     cdef double x = value / 2             # <<<<<<<<<<<<<<
 *     for _ in range(8):
 *         x -= (x * x - value) / (2 * x)
 */
  __pyx_v_x = (__pyx_v_value / 2.0);

  /* "cython_test.pyx":10
 *     #   'x * x - value = 0' using newtons meethod
 *     cdef double x = value / 2
 *     for _ in range(8):             # <<<<<<<<<<<<<<
 *         x -= (x * x - value) / (2 * x)
 *     return x
 */
  for (__pyx_t_1 = 0; __pyx_t_1 < 8; __pyx_t_1+=1) {
    __pyx_v__ = __pyx_t_1;

    /* "cython_test.pyx":11
 *     cdef double x = value / 2
 *     for _ in range(8):
 *         x -= (x * x - value) / (2 * x)             # <<<<<<<<<<<<<<
 *     return x
 */
    __pyx_t_2 = ((__pyx_v_x * __pyx_v_x) - __pyx_v_value);
    __pyx_t_3 = (2.0 * __pyx_v_x);
    if (unlikely(__pyx_t_3 == 0)) {
      PyErr_SetString(PyExc_ZeroDivisionError, "float division");
      __PYX_ERR(0, 11, __pyx_L1_error)
    }
    __pyx_v_x = (__pyx_v_x - (__pyx_t_2 / __pyx_t_3));
  }

  /* "cython_test.pyx":12
 *     for _ in range(8):
 *         x -= (x * x - value) / (2 * x)
 *     return x             # <<<<<<<<<<<<<<
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 12, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "cython_test.pyx":6
 * from cython cimport floating
 * 
 * cpdef sqrt(floating value):             # <<<<<<<<<<<<<<
 *     # solve for the square root of value by finding the zeros of
 *     #   'x * x - value = 0' using newtons meethod
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("cython_test.sqrt", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_11cython_test_3__pyx_fuse_0sqrt(PyObject *__pyx_self, PyObject *__pyx_arg_value); /*proto*/
static PyMethodDef __pyx_fuse_0__pyx_mdef_11cython_test_3__pyx_fuse_0sqrt = {"__pyx_fuse_0sqrt", (PyCFunction)__pyx_pw_11cython_test_3__pyx_fuse_0sqrt, METH_O, 0};
static PyObject *__pyx_pw_11cython_test_3__pyx_fuse_0sqrt(PyObject *__pyx_self, PyObject *__pyx_arg_value) {
  float __pyx_v_value;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__pyx_fuse_0sqrt (wrapper)", 0);
  assert(__pyx_arg_value); {
    __pyx_v_value = __pyx_PyFloat_AsFloat(__pyx_arg_value); if (unlikely((__pyx_v_value == (float)-1) && PyErr_Occurred())) __PYX_ERR(0, 6, __pyx_L3_error)
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  __Pyx_AddTraceback("cython_test.__pyx_fuse_0sqrt", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_11cython_test_2__pyx_fuse_0sqrt(__pyx_self, ((float)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_11cython_test_2__pyx_fuse_0sqrt(CYTHON_UNUSED PyObject *__pyx_self, float __pyx_v_value) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  __Pyx_RefNannySetupContext("__pyx_fuse_0sqrt", 0);
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_fuse_0__pyx_f_11cython_test_sqrt(__pyx_v_value, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("cython_test.__pyx_fuse_0sqrt", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pw_11cython_test_5__pyx_fuse_1sqrt(PyObject *__pyx_self, PyObject *__pyx_arg_value); /*proto*/
static PyObject *__pyx_pw_11cython_test_1sqrt(PyObject *__pyx_self, PyObject *__pyx_args, PyObject *__pyx_kwds); /*proto*/
static PyObject *__pyx_fuse_1__pyx_f_11cython_test_sqrt(double __pyx_v_value, CYTHON_UNUSED int __pyx_skip_dispatch) {
  double __pyx_v_x;
  CYTHON_UNUSED long __pyx_v__;
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  long __pyx_t_1;
  double __pyx_t_2;
  double __pyx_t_3;
  PyObject *__pyx_t_4 = NULL;
  __Pyx_RefNannySetupContext("__pyx_fuse_1sqrt", 0);

  /* "cython_test.pyx":9
 *     # solve for the square root of value by finding the zeros of
 *     #   'x * x - value = 0' using newtons meethod
 *     cdef double x = value / 2             # <<<<<<<<<<<<<<
 *     for _ in range(8):
 *         x -= (x * x - value) / (2 * x)
 */
  __pyx_v_x = (__pyx_v_value / 2.0);

  /* "cython_test.pyx":10
 *     #   'x * x - value = 0' using newtons meethod
 *     cdef double x = value / 2
 *     for _ in range(8):             # <<<<<<<<<<<<<<
 *         x -= (x * x - value) / (2 * x)
 *     return x
 */
  for (__pyx_t_1 = 0; __pyx_t_1 < 8; __pyx_t_1+=1) {
    __pyx_v__ = __pyx_t_1;

    /* "cython_test.pyx":11
 *     cdef double x = value / 2
 *     for _ in range(8):
 *         x -= (x * x - value) / (2 * x)             # <<<<<<<<<<<<<<
 *     return x
 */
    __pyx_t_2 = ((__pyx_v_x * __pyx_v_x) - __pyx_v_value);
    __pyx_t_3 = (2.0 * __pyx_v_x);
    if (unlikely(__pyx_t_3 == 0)) {
      PyErr_SetString(PyExc_ZeroDivisionError, "float division");
      __PYX_ERR(0, 11, __pyx_L1_error)
    }
    __pyx_v_x = (__pyx_v_x - (__pyx_t_2 / __pyx_t_3));
  }

  /* "cython_test.pyx":12
 *     for _ in range(8):
 *         x -= (x * x - value) / (2 * x)
 *     return x             # <<<<<<<<<<<<<<
 */
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_4 = PyFloat_FromDouble(__pyx_v_x); if (unlikely(!__pyx_t_4)) __PYX_ERR(0, 12, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_4);
  __pyx_r = __pyx_t_4;
  __pyx_t_4 = 0;
  goto __pyx_L0;

  /* "cython_test.pyx":6
 * from cython cimport floating
 * 
 * cpdef sqrt(floating value):             # <<<<<<<<<<<<<<
 *     # solve for the square root of value by finding the zeros of
 *     #   'x * x - value = 0' using newtons meethod
 */

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_4);
  __Pyx_AddTraceback("cython_test.sqrt", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = 0;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

/* Python wrapper */
static PyObject *__pyx_pw_11cython_test_5__pyx_fuse_1sqrt(PyObject *__pyx_self, PyObject *__pyx_arg_value); /*proto*/
static PyMethodDef __pyx_fuse_1__pyx_mdef_11cython_test_5__pyx_fuse_1sqrt = {"__pyx_fuse_1sqrt", (PyCFunction)__pyx_pw_11cython_test_5__pyx_fuse_1sqrt, METH_O, 0};
static PyObject *__pyx_pw_11cython_test_5__pyx_fuse_1sqrt(PyObject *__pyx_self, PyObject *__pyx_arg_value) {
  double __pyx_v_value;
  PyObject *__pyx_r = 0;
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__pyx_fuse_1sqrt (wrapper)", 0);
  assert(__pyx_arg_value); {
    __pyx_v_value = __pyx_PyFloat_AsDouble(__pyx_arg_value); if (unlikely((__pyx_v_value == (double)-1) && PyErr_Occurred())) __PYX_ERR(0, 6, __pyx_L3_error)
  }
  goto __pyx_L4_argument_unpacking_done;
  __pyx_L3_error:;
  __Pyx_AddTraceback("cython_test.__pyx_fuse_1sqrt", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __Pyx_RefNannyFinishContext();
  return NULL;
  __pyx_L4_argument_unpacking_done:;
  __pyx_r = __pyx_pf_11cython_test_4__pyx_fuse_1sqrt(__pyx_self, ((double)__pyx_v_value));

  /* function exit code */
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyObject *__pyx_pf_11cython_test_4__pyx_fuse_1sqrt(CYTHON_UNUSED PyObject *__pyx_self, double __pyx_v_value) {
  PyObject *__pyx_r = NULL;
  __Pyx_RefNannyDeclarations
  PyObject *__pyx_t_1 = NULL;
  __Pyx_RefNannySetupContext("__pyx_fuse_1sqrt", 0);
  __Pyx_XDECREF(__pyx_r);
  __pyx_t_1 = __pyx_fuse_1__pyx_f_11cython_test_sqrt(__pyx_v_value, 0); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_r = __pyx_t_1;
  __pyx_t_1 = 0;
  goto __pyx_L0;

  /* function exit code */
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_AddTraceback("cython_test.__pyx_fuse_1sqrt", __pyx_clineno, __pyx_lineno, __pyx_filename);
  __pyx_r = NULL;
  __pyx_L0:;
  __Pyx_XGIVEREF(__pyx_r);
  __Pyx_RefNannyFinishContext();
  return __pyx_r;
}

static PyMethodDef __pyx_methods[] = {
  {0, 0, 0, 0}
};

#if PY_MAJOR_VERSION >= 3
#if CYTHON_PEP489_MULTI_PHASE_INIT
static PyObject* __pyx_pymod_create(PyObject *spec, PyModuleDef *def); /*proto*/
static int __pyx_pymod_exec_cython_test(PyObject* module); /*proto*/
static PyModuleDef_Slot __pyx_moduledef_slots[] = {
  {Py_mod_create, (void*)__pyx_pymod_create},
  {Py_mod_exec, (void*)__pyx_pymod_exec_cython_test},
  {0, NULL}
};
#endif

static struct PyModuleDef __pyx_moduledef = {
    PyModuleDef_HEAD_INIT,
    "cython_test",
    __pyx_k_simple_test_file_for_cython_sou, /* m_doc */
  #if CYTHON_PEP489_MULTI_PHASE_INIT
    0, /* m_size */
  #else
    -1, /* m_size */
  #endif
    __pyx_methods /* m_methods */,
  #if CYTHON_PEP489_MULTI_PHASE_INIT
    __pyx_moduledef_slots, /* m_slots */
  #else
    NULL, /* m_reload */
  #endif
    NULL, /* m_traverse */
    NULL, /* m_clear */
    NULL /* m_free */
};
#endif

static __Pyx_StringTabEntry __pyx_string_tab[] = {
  {&__pyx_kp_s_, __pyx_k_, sizeof(__pyx_k_), 0, 0, 1, 0},
  {&__pyx_kp_s_Expected_at_least_d_argument_s_g, __pyx_k_Expected_at_least_d_argument_s_g, sizeof(__pyx_k_Expected_at_least_d_argument_s_g), 0, 0, 1, 0},
  {&__pyx_kp_s_Function_call_with_ambiguous_arg, __pyx_k_Function_call_with_ambiguous_arg, sizeof(__pyx_k_Function_call_with_ambiguous_arg), 0, 0, 1, 0},
  {&__pyx_kp_s_No_matching_signature_found, __pyx_k_No_matching_signature_found, sizeof(__pyx_k_No_matching_signature_found), 0, 0, 1, 0},
  {&__pyx_n_s_TypeError, __pyx_k_TypeError, sizeof(__pyx_k_TypeError), 0, 0, 1, 1},
  {&__pyx_kp_s__2, __pyx_k__2, sizeof(__pyx_k__2), 0, 0, 1, 0},
  {&__pyx_kp_s__4, __pyx_k__4, sizeof(__pyx_k__4), 0, 0, 1, 0},
  {&__pyx_n_s_args, __pyx_k_args, sizeof(__pyx_k_args), 0, 0, 1, 1},
  {&__pyx_n_s_cline_in_traceback, __pyx_k_cline_in_traceback, sizeof(__pyx_k_cline_in_traceback), 0, 0, 1, 1},
  {&__pyx_n_s_cython_test, __pyx_k_cython_test, sizeof(__pyx_k_cython_test), 0, 0, 1, 1},
  {&__pyx_kp_s_cython_test_pyx, __pyx_k_cython_test_pyx, sizeof(__pyx_k_cython_test_pyx), 0, 0, 1, 0},
  {&__pyx_n_s_defaults, __pyx_k_defaults, sizeof(__pyx_k_defaults), 0, 0, 1, 1},
  {&__pyx_n_s_double, __pyx_k_double, sizeof(__pyx_k_double), 0, 0, 1, 1},
  {&__pyx_n_s_float, __pyx_k_float, sizeof(__pyx_k_float), 0, 0, 1, 1},
  {&__pyx_n_s_import, __pyx_k_import, sizeof(__pyx_k_import), 0, 0, 1, 1},
  {&__pyx_n_s_kwargs, __pyx_k_kwargs, sizeof(__pyx_k_kwargs), 0, 0, 1, 1},
  {&__pyx_n_s_main, __pyx_k_main, sizeof(__pyx_k_main), 0, 0, 1, 1},
  {&__pyx_n_s_name, __pyx_k_name, sizeof(__pyx_k_name), 0, 0, 1, 1},
  {&__pyx_n_s_numpy, __pyx_k_numpy, sizeof(__pyx_k_numpy), 0, 0, 1, 1},
  {&__pyx_n_s_pyx_fuse_0sqrt, __pyx_k_pyx_fuse_0sqrt, sizeof(__pyx_k_pyx_fuse_0sqrt), 0, 0, 1, 1},
  {&__pyx_n_s_pyx_fuse_1sqrt, __pyx_k_pyx_fuse_1sqrt, sizeof(__pyx_k_pyx_fuse_1sqrt), 0, 0, 1, 1},
  {&__pyx_n_s_range, __pyx_k_range, sizeof(__pyx_k_range), 0, 0, 1, 1},
  {&__pyx_n_s_signatures, __pyx_k_signatures, sizeof(__pyx_k_signatures), 0, 0, 1, 1},
  {&__pyx_n_s_split, __pyx_k_split, sizeof(__pyx_k_split), 0, 0, 1, 1},
  {&__pyx_n_s_sqrt, __pyx_k_sqrt, sizeof(__pyx_k_sqrt), 0, 0, 1, 1},
  {&__pyx_n_s_strip, __pyx_k_strip, sizeof(__pyx_k_strip), 0, 0, 1, 1},
  {&__pyx_n_s_test, __pyx_k_test, sizeof(__pyx_k_test), 0, 0, 1, 1},
  {&__pyx_n_s_value, __pyx_k_value, sizeof(__pyx_k_value), 0, 0, 1, 1},
  {0, 0, 0, 0, 0, 0, 0}
};
static int __Pyx_InitCachedBuiltins(void) {
  __pyx_builtin_TypeError = __Pyx_GetBuiltinName(__pyx_n_s_TypeError); if (!__pyx_builtin_TypeError) __PYX_ERR(0, 6, __pyx_L1_error)
  __pyx_builtin_range = __Pyx_GetBuiltinName(__pyx_n_s_range); if (!__pyx_builtin_range) __PYX_ERR(0, 6, __pyx_L1_error)
  return 0;
  __pyx_L1_error:;
  return -1;
}

static int __Pyx_InitCachedConstants(void) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__Pyx_InitCachedConstants", 0);

  /* "cython_test.pyx":6
 * from cython cimport floating
 * 
 * cpdef sqrt(floating value):             # <<<<<<<<<<<<<<
 *     # solve for the square root of value by finding the zeros of
 *     #   'x * x - value = 0' using newtons meethod
 */
  __pyx_tuple__3 = PyTuple_Pack(1, __pyx_kp_s__2); if (unlikely(!__pyx_tuple__3)) __PYX_ERR(0, 6, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__3);
  __Pyx_GIVEREF(__pyx_tuple__3);
  __pyx_tuple__5 = PyTuple_Pack(1, __pyx_kp_s__4); if (unlikely(!__pyx_tuple__5)) __PYX_ERR(0, 6, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__5);
  __Pyx_GIVEREF(__pyx_tuple__5);
  __pyx_tuple__6 = PyTuple_Pack(1, __pyx_kp_s_No_matching_signature_found); if (unlikely(!__pyx_tuple__6)) __PYX_ERR(0, 6, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__6);
  __Pyx_GIVEREF(__pyx_tuple__6);
  __pyx_tuple__7 = PyTuple_Pack(1, __pyx_kp_s_Function_call_with_ambiguous_arg); if (unlikely(!__pyx_tuple__7)) __PYX_ERR(0, 6, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__7);
  __Pyx_GIVEREF(__pyx_tuple__7);
  __pyx_tuple__8 = PyTuple_Pack(2, __pyx_n_s_value, __pyx_n_s_value); if (unlikely(!__pyx_tuple__8)) __PYX_ERR(0, 6, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_tuple__8);
  __Pyx_GIVEREF(__pyx_tuple__8);
  __pyx_codeobj__9 = (PyObject*)__Pyx_PyCode_New(1, 0, 2, 0, CO_OPTIMIZED|CO_NEWLOCALS, __pyx_empty_bytes, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_tuple__8, __pyx_empty_tuple, __pyx_empty_tuple, __pyx_kp_s_cython_test_pyx, __pyx_n_s_pyx_fuse_0sqrt, 6, __pyx_empty_bytes); if (unlikely(!__pyx_codeobj__9)) __PYX_ERR(0, 6, __pyx_L1_error)
  __Pyx_RefNannyFinishContext();
  return 0;
  __pyx_L1_error:;
  __Pyx_RefNannyFinishContext();
  return -1;
}

static int __Pyx_InitGlobals(void) {
  if (__Pyx_InitStrings(__pyx_string_tab) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
  __pyx_int_1 = PyInt_FromLong(1); if (unlikely(!__pyx_int_1)) __PYX_ERR(0, 1, __pyx_L1_error)
  return 0;
  __pyx_L1_error:;
  return -1;
}

static int __Pyx_modinit_global_init_code(void); /*proto*/
static int __Pyx_modinit_variable_export_code(void); /*proto*/
static int __Pyx_modinit_function_export_code(void); /*proto*/
static int __Pyx_modinit_type_init_code(void); /*proto*/
static int __Pyx_modinit_type_import_code(void); /*proto*/
static int __Pyx_modinit_variable_import_code(void); /*proto*/
static int __Pyx_modinit_function_import_code(void); /*proto*/

static int __Pyx_modinit_global_init_code(void) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__Pyx_modinit_global_init_code", 0);
  /*--- Global init code ---*/
  __Pyx_RefNannyFinishContext();
  return 0;
}

static int __Pyx_modinit_variable_export_code(void) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_export_code", 0);
  /*--- Variable export code ---*/
  __Pyx_RefNannyFinishContext();
  return 0;
}

static int __Pyx_modinit_function_export_code(void) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__Pyx_modinit_function_export_code", 0);
  /*--- Function export code ---*/
  __Pyx_RefNannyFinishContext();
  return 0;
}

static int __Pyx_modinit_type_init_code(void) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__Pyx_modinit_type_init_code", 0);
  /*--- Type init code ---*/
  __Pyx_RefNannyFinishContext();
  return 0;
}

static int __Pyx_modinit_type_import_code(void) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__Pyx_modinit_type_import_code", 0);
  /*--- Type import code ---*/
  __Pyx_RefNannyFinishContext();
  return 0;
}

static int __Pyx_modinit_variable_import_code(void) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__Pyx_modinit_variable_import_code", 0);
  /*--- Variable import code ---*/
  __Pyx_RefNannyFinishContext();
  return 0;
}

static int __Pyx_modinit_function_import_code(void) {
  __Pyx_RefNannyDeclarations
  __Pyx_RefNannySetupContext("__Pyx_modinit_function_import_code", 0);
  /*--- Function import code ---*/
  __Pyx_RefNannyFinishContext();
  return 0;
}


#if PY_MAJOR_VERSION < 3
#ifdef CYTHON_NO_PYINIT_EXPORT
#define __Pyx_PyMODINIT_FUNC void
#else
#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
#endif
#else
#ifdef CYTHON_NO_PYINIT_EXPORT
#define __Pyx_PyMODINIT_FUNC PyObject *
#else
#define __Pyx_PyMODINIT_FUNC PyMODINIT_FUNC
#endif
#endif
#ifndef CYTHON_SMALL_CODE
#if defined(__clang__)
    #define CYTHON_SMALL_CODE
#elif defined(__GNUC__) && (!(defined(__cplusplus)) || (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ > 4)))
    #define CYTHON_SMALL_CODE __attribute__((cold))
#else
    #define CYTHON_SMALL_CODE
#endif
#endif


#if PY_MAJOR_VERSION < 3
__Pyx_PyMODINIT_FUNC initcython_test(void) CYTHON_SMALL_CODE; /*proto*/
__Pyx_PyMODINIT_FUNC initcython_test(void)
#else
__Pyx_PyMODINIT_FUNC PyInit_cython_test(void) CYTHON_SMALL_CODE; /*proto*/
__Pyx_PyMODINIT_FUNC PyInit_cython_test(void)
#if CYTHON_PEP489_MULTI_PHASE_INIT
{
  return PyModuleDef_Init(&__pyx_moduledef);
}
static int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, const char* from_name, const char* to_name) {
    PyObject *value = PyObject_GetAttrString(spec, from_name);
    int result = 0;
    if (likely(value)) {
        result = PyDict_SetItemString(moddict, to_name, value);
        Py_DECREF(value);
    } else if (PyErr_ExceptionMatches(PyExc_AttributeError)) {
        PyErr_Clear();
    } else {
        result = -1;
    }
    return result;
}
static PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModuleDef *def) {
    PyObject *module = NULL, *moddict, *modname;
    if (__pyx_m)
        return __Pyx_NewRef(__pyx_m);
    modname = PyObject_GetAttrString(spec, "name");
    if (unlikely(!modname)) goto bad;
    module = PyModule_NewObject(modname);
    Py_DECREF(modname);
    if (unlikely(!module)) goto bad;
    moddict = PyModule_GetDict(module);
    if (unlikely(!moddict)) goto bad;
    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "loader", "__loader__") < 0)) goto bad;
    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "origin", "__file__") < 0)) goto bad;
    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "parent", "__package__") < 0)) goto bad;
    if (unlikely(__Pyx_copy_spec_to_module(spec, moddict, "submodule_search_locations", "__path__") < 0)) goto bad;
    return module;
bad:
    Py_XDECREF(module);
    return NULL;
}


static int __pyx_pymod_exec_cython_test(PyObject *__pyx_pyinit_module)
#endif
#endif
{
  PyObject *__pyx_t_1 = NULL;
  PyObject *__pyx_t_2 = NULL;
  PyObject *__pyx_t_3 = NULL;
  __Pyx_RefNannyDeclarations
  #if CYTHON_PEP489_MULTI_PHASE_INIT
  if (__pyx_m && __pyx_m == __pyx_pyinit_module) return 0;
  #elif PY_MAJOR_VERSION >= 3
  if (__pyx_m) return __Pyx_NewRef(__pyx_m);
  #endif
  #if CYTHON_REFNANNY
__Pyx_RefNanny = __Pyx_RefNannyImportAPI("refnanny");
if (!__Pyx_RefNanny) {
  PyErr_Clear();
  __Pyx_RefNanny = __Pyx_RefNannyImportAPI("Cython.Runtime.refnanny");
  if (!__Pyx_RefNanny)
      Py_FatalError("failed to import 'refnanny' module");
}
#endif
  __Pyx_RefNannySetupContext("__Pyx_PyMODINIT_FUNC PyInit_cython_test(void)", 0);
  if (__Pyx_check_binary_version() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_empty_tuple = PyTuple_New(0); if (unlikely(!__pyx_empty_tuple)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_empty_bytes = PyBytes_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_bytes)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_empty_unicode = PyUnicode_FromStringAndSize("", 0); if (unlikely(!__pyx_empty_unicode)) __PYX_ERR(0, 1, __pyx_L1_error)
  #ifdef __Pyx_CyFunction_USED
  if (__pyx_CyFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_FusedFunction_USED
  if (__pyx_FusedFunction_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_Coroutine_USED
  if (__pyx_Coroutine_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_Generator_USED
  if (__pyx_Generator_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_AsyncGen_USED
  if (__pyx_AsyncGen_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  #ifdef __Pyx_StopAsyncIteration_USED
  if (__pyx_StopAsyncIteration_init() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  /*--- Library function declarations ---*/
  /*--- Threads initialization code ---*/
  #if defined(__PYX_FORCE_INIT_THREADS) && __PYX_FORCE_INIT_THREADS
  #ifdef WITH_THREAD /* Python build with threading support? */
  PyEval_InitThreads();
  #endif
  #endif
  /*--- Module creation code ---*/
  #if CYTHON_PEP489_MULTI_PHASE_INIT
  __pyx_m = __pyx_pyinit_module;
  Py_INCREF(__pyx_m);
  #else
  #if PY_MAJOR_VERSION < 3
  __pyx_m = Py_InitModule4("cython_test", __pyx_methods, __pyx_k_simple_test_file_for_cython_sou, 0, PYTHON_API_VERSION); Py_XINCREF(__pyx_m);
  #else
  __pyx_m = PyModule_Create(&__pyx_moduledef);
  #endif
  if (unlikely(!__pyx_m)) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  __pyx_d = PyModule_GetDict(__pyx_m); if (unlikely(!__pyx_d)) __PYX_ERR(0, 1, __pyx_L1_error)
  Py_INCREF(__pyx_d);
  __pyx_b = PyImport_AddModule(__Pyx_BUILTIN_MODULE_NAME); if (unlikely(!__pyx_b)) __PYX_ERR(0, 1, __pyx_L1_error)
  __pyx_cython_runtime = PyImport_AddModule((char *) "cython_runtime"); if (unlikely(!__pyx_cython_runtime)) __PYX_ERR(0, 1, __pyx_L1_error)
  #if CYTHON_COMPILING_IN_PYPY
  Py_INCREF(__pyx_b);
  #endif
  if (PyObject_SetAttrString(__pyx_m, "__builtins__", __pyx_b) < 0) __PYX_ERR(0, 1, __pyx_L1_error);
  /*--- Initialize various global constants etc. ---*/
  if (__Pyx_InitGlobals() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #if PY_MAJOR_VERSION < 3 && (__PYX_DEFAULT_STRING_ENCODING_IS_ASCII || __PYX_DEFAULT_STRING_ENCODING_IS_DEFAULT)
  if (__Pyx_init_sys_getdefaultencoding_params() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif
  if (__pyx_module_is_main_cython_test) {
    if (PyObject_SetAttrString(__pyx_m, "__name__", __pyx_n_s_main) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  }
  #if PY_MAJOR_VERSION >= 3
  {
    PyObject *modules = PyImport_GetModuleDict(); if (unlikely(!modules)) __PYX_ERR(0, 1, __pyx_L1_error)
    if (!PyDict_GetItemString(modules, "cython_test")) {
      if (unlikely(PyDict_SetItemString(modules, "cython_test", __pyx_m) < 0)) __PYX_ERR(0, 1, __pyx_L1_error)
    }
  }
  #endif
  /*--- Builtin init code ---*/
  if (__Pyx_InitCachedBuiltins() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  /*--- Constants init code ---*/
  if (__Pyx_InitCachedConstants() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  /*--- Global type/function init code ---*/
  (void)__Pyx_modinit_global_init_code();
  (void)__Pyx_modinit_variable_export_code();
  (void)__Pyx_modinit_function_export_code();
  (void)__Pyx_modinit_type_init_code();
  (void)__Pyx_modinit_type_import_code();
  (void)__Pyx_modinit_variable_import_code();
  (void)__Pyx_modinit_function_import_code();
  /*--- Execution code ---*/
  #if defined(__Pyx_Generator_USED) || defined(__Pyx_Coroutine_USED)
  if (__Pyx_patch_abc() < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  #endif

  /* "cython_test.pyx":6
 * from cython cimport floating
 * 
 * cpdef sqrt(floating value):             # <<<<<<<<<<<<<<
 *     # solve for the square root of value by finding the zeros of
 *     #   'x * x - value = 0' using newtons meethod
 */
  __pyx_t_1 = __Pyx_PyDict_NewPresized(2); if (unlikely(!__pyx_t_1)) __PYX_ERR(0, 6, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_1);
  __pyx_t_2 = __pyx_FusedFunction_NewEx(&__pyx_fuse_0__pyx_mdef_11cython_test_3__pyx_fuse_0sqrt, 0, __pyx_n_s_pyx_fuse_0sqrt, NULL, __pyx_n_s_cython_test, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_empty_tuple);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_float, __pyx_t_2) < 0) __PYX_ERR(0, 6, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __pyx_FusedFunction_NewEx(&__pyx_fuse_1__pyx_mdef_11cython_test_5__pyx_fuse_1sqrt, 0, __pyx_n_s_pyx_fuse_1sqrt, NULL, __pyx_n_s_cython_test, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_empty_tuple);
  if (PyDict_SetItem(__pyx_t_1, __pyx_n_s_double, __pyx_t_2) < 0) __PYX_ERR(0, 6, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;
  __pyx_t_2 = __pyx_FusedFunction_NewEx(&__pyx_mdef_11cython_test_1sqrt, 0, __pyx_n_s_sqrt, NULL, __pyx_n_s_cython_test, __pyx_d, ((PyObject *)__pyx_codeobj__9)); if (unlikely(!__pyx_t_2)) __PYX_ERR(0, 6, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_2);
  __Pyx_CyFunction_SetDefaultsTuple(__pyx_t_2, __pyx_empty_tuple);
  ((__pyx_FusedFunctionObject *) __pyx_t_2)->__signatures__ = __pyx_t_1;
  __Pyx_GIVEREF(__pyx_t_1);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_sqrt, __pyx_t_2) < 0) __PYX_ERR(0, 6, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_2); __pyx_t_2 = 0;

  /* "cython_test.pyx":1
 * """ simple test file for cython source mapping: defines a function             # <<<<<<<<<<<<<<
 * that uses newtowns method to compute the square root of a number """
 * 
 */
  __pyx_t_3 = __Pyx_PyDict_NewPresized(0); if (unlikely(!__pyx_t_3)) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_GOTREF(__pyx_t_3);
  if (PyDict_SetItem(__pyx_d, __pyx_n_s_test, __pyx_t_3) < 0) __PYX_ERR(0, 1, __pyx_L1_error)
  __Pyx_DECREF(__pyx_t_3); __pyx_t_3 = 0;

  /*--- Wrapped vars code ---*/

  goto __pyx_L0;
  __pyx_L1_error:;
  __Pyx_XDECREF(__pyx_t_1);
  __Pyx_XDECREF(__pyx_t_2);
  __Pyx_XDECREF(__pyx_t_3);
  if (__pyx_m) {
    if (__pyx_d) {
      __Pyx_AddTraceback("init cython_test", 0, __pyx_lineno, __pyx_filename);
    }
    Py_DECREF(__pyx_m); __pyx_m = 0;
  } else if (!PyErr_Occurred()) {
    PyErr_SetString(PyExc_ImportError, "init cython_test");
  }
  __pyx_L0:;
  __Pyx_RefNannyFinishContext();
  #if CYTHON_PEP489_MULTI_PHASE_INIT
  return (__pyx_m != NULL) ? 0 : -1;
  #elif PY_MAJOR_VERSION >= 3
  return __pyx_m;
  #else
  return;
  #endif
}

/* --- Runtime support code --- */
/* Refnanny */
#if CYTHON_REFNANNY
static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modname) {
    PyObject *m = NULL, *p = NULL;
    void *r = NULL;
    m = PyImport_ImportModule((char *)modname);
    if (!m) goto end;
    p = PyObject_GetAttrString(m, (char *)"RefNannyAPI");
    if (!p) goto end;
    r = PyLong_AsVoidPtr(p);
end:
    Py_XDECREF(p);
    Py_XDECREF(m);
    return (__Pyx_RefNannyAPIStruct *)r;
}
#endif

/* PyObjectGetAttrStr */
#if CYTHON_USE_TYPE_SLOTS
static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, PyObject* attr_name) {
    PyTypeObject* tp = Py_TYPE(obj);
    if (likely(tp->tp_getattro))
        return tp->tp_getattro(obj, attr_name);
#if PY_MAJOR_VERSION < 3
    if (likely(tp->tp_getattr))
        return tp->tp_getattr(obj, PyString_AS_STRING(attr_name));
#endif
    return PyObject_GetAttr(obj, attr_name);
}
#endif

/* GetBuiltinName */
static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
    PyObject* result = __Pyx_PyObject_GetAttrStr(__pyx_b, name);
    if (unlikely(!result)) {
        PyErr_Format(PyExc_NameError,
#if PY_MAJOR_VERSION >= 3
            "name '%U' is not defined", name);
#else
            "name '%.200s' is not defined", PyString_AS_STRING(name));
#endif
    }
    return result;
}

/* RaiseArgTupleInvalid */
static void __Pyx_RaiseArgtupleInvalid(
    const char* func_name,
    int exact,
    Py_ssize_t num_min,
    Py_ssize_t num_max,
    Py_ssize_t num_found)
{
    Py_ssize_t num_expected;
    const char *more_or_less;
    if (num_found < num_min) {
        num_expected = num_min;
        more_or_less = "at least";
    } else {
        num_expected = num_max;
        more_or_less = "at most";
    }
    if (exact) {
        more_or_less = "exactly";
    }
    PyErr_Format(PyExc_TypeError,
                 "%.200s() takes %.8s %" CYTHON_FORMAT_SSIZE_T "d positional argument%.1s (%" CYTHON_FORMAT_SSIZE_T "d given)",
                 func_name, more_or_less, num_expected,
                 (num_expected == 1) ? "" : "s", num_found);
}

/* RaiseDoubleKeywords */
static void __Pyx_RaiseDoubleKeywordsError(
    const char* func_name,
    PyObject* kw_name)
{
    PyErr_Format(PyExc_TypeError,
        #if PY_MAJOR_VERSION >= 3
        "%s() got multiple values for keyword argument '%U'", func_name, kw_name);
        #else
        "%s() got multiple values for keyword argument '%s'", func_name,
        PyString_AsString(kw_name));
        #endif
}

/* ParseKeywords */
static int __Pyx_ParseOptionalKeywords(
    PyObject *kwds,
    PyObject **argnames[],
    PyObject *kwds2,
    PyObject *values[],
    Py_ssize_t num_pos_args,
    const char* function_name)
{
    PyObject *key = 0, *value = 0;
    Py_ssize_t pos = 0;
    PyObject*** name;
    PyObject*** first_kw_arg = argnames + num_pos_args;
    while (PyDict_Next(kwds, &pos, &key, &value)) {
        name = first_kw_arg;
        while (*name && (**name != key)) name++;
        if (*name) {
            values[name-argnames] = value;
            continue;
        }
        name = first_kw_arg;
        #if PY_MAJOR_VERSION < 3
        if (likely(PyString_CheckExact(key)) || likely(PyString_Check(key))) {
            while (*name) {
                if ((CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**name) == PyString_GET_SIZE(key))
                        && _PyString_Eq(**name, key)) {
                    values[name-argnames] = value;
                    break;
                }
                name++;
            }
            if (*name) continue;
            else {
                PyObject*** argname = argnames;
                while (argname != first_kw_arg) {
                    if ((**argname == key) || (
                            (CYTHON_COMPILING_IN_PYPY || PyString_GET_SIZE(**argname) == PyString_GET_SIZE(key))
                             && _PyString_Eq(**argname, key))) {
                        goto arg_passed_twice;
                    }
                    argname++;
                }
            }
        } else
        #endif
        if (likely(PyUnicode_Check(key))) {
            while (*name) {
                int cmp = (**name == key) ? 0 :
                #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
                    (PyUnicode_GET_SIZE(**name) != PyUnicode_GET_SIZE(key)) ? 1 :
                #endif
                    PyUnicode_Compare(**name, key);
                if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
                if (cmp == 0) {
                    values[name-argnames] = value;
                    break;
                }
                name++;
            }
            if (*name) continue;
            else {
                PyObject*** argname = argnames;
                while (argname != first_kw_arg) {
                    int cmp = (**argname == key) ? 0 :
                    #if !CYTHON_COMPILING_IN_PYPY && PY_MAJOR_VERSION >= 3
                        (PyUnicode_GET_SIZE(**argname) != PyUnicode_GET_SIZE(key)) ? 1 :
                    #endif
                        PyUnicode_Compare(**argname, key);
                    if (cmp < 0 && unlikely(PyErr_Occurred())) goto bad;
                    if (cmp == 0) goto arg_passed_twice;
                    argname++;
                }
            }
        } else
            goto invalid_keyword_type;
        if (kwds2) {
            if (unlikely(PyDict_SetItem(kwds2, key, value))) goto bad;
        } else {
            goto invalid_keyword;
        }
    }
    return 0;
arg_passed_twice:
    __Pyx_RaiseDoubleKeywordsError(function_name, key);
    goto bad;
invalid_keyword_type:
    PyErr_Format(PyExc_TypeError,
        "%.200s() keywords must be strings", function_name);
    goto bad;
invalid_keyword:
    PyErr_Format(PyExc_TypeError,
    #if PY_MAJOR_VERSION < 3
        "%.200s() got an unexpected keyword argument '%.200s'",
        function_name, PyString_AsString(key));
    #else
        "%s() got an unexpected keyword argument '%U'",
        function_name, key);
    #endif
bad:
    return -1;
}

/* GetItemInt */
static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
    PyObject *r;
    if (!j) return NULL;
    r = PyObject_GetItem(o, j);
    Py_DECREF(j);
    return r;
}
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, Py_ssize_t i,
                                                              CYTHON_NCP_UNUSED int wraparound,
                                                              CYTHON_NCP_UNUSED int boundscheck) {
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    Py_ssize_t wrapped_i = i;
    if (wraparound & unlikely(i < 0)) {
        wrapped_i += PyList_GET_SIZE(o);
    }
    if ((!boundscheck) || likely((0 <= wrapped_i) & (wrapped_i < PyList_GET_SIZE(o)))) {
        PyObject *r = PyList_GET_ITEM(o, wrapped_i);
        Py_INCREF(r);
        return r;
    }
    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
#else
    return PySequence_GetItem(o, i);
#endif
}
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, Py_ssize_t i,
                                                              CYTHON_NCP_UNUSED int wraparound,
                                                              CYTHON_NCP_UNUSED int boundscheck) {
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    Py_ssize_t wrapped_i = i;
    if (wraparound & unlikely(i < 0)) {
        wrapped_i += PyTuple_GET_SIZE(o);
    }
    if ((!boundscheck) || likely((0 <= wrapped_i) & (wrapped_i < PyTuple_GET_SIZE(o)))) {
        PyObject *r = PyTuple_GET_ITEM(o, wrapped_i);
        Py_INCREF(r);
        return r;
    }
    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
#else
    return PySequence_GetItem(o, i);
#endif
}
static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssize_t i, int is_list,
                                                     CYTHON_NCP_UNUSED int wraparound,
                                                     CYTHON_NCP_UNUSED int boundscheck) {
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS
    if (is_list || PyList_CheckExact(o)) {
        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyList_GET_SIZE(o);
        if ((!boundscheck) || (likely((n >= 0) & (n < PyList_GET_SIZE(o))))) {
            PyObject *r = PyList_GET_ITEM(o, n);
            Py_INCREF(r);
            return r;
        }
    }
    else if (PyTuple_CheckExact(o)) {
        Py_ssize_t n = ((!wraparound) | likely(i >= 0)) ? i : i + PyTuple_GET_SIZE(o);
        if ((!boundscheck) || likely((n >= 0) & (n < PyTuple_GET_SIZE(o)))) {
            PyObject *r = PyTuple_GET_ITEM(o, n);
            Py_INCREF(r);
            return r;
        }
    } else {
        PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
        if (likely(m && m->sq_item)) {
            if (wraparound && unlikely(i < 0) && likely(m->sq_length)) {
                Py_ssize_t l = m->sq_length(o);
                if (likely(l >= 0)) {
                    i += l;
                } else {
                    if (!PyErr_ExceptionMatches(PyExc_OverflowError))
                        return NULL;
                    PyErr_Clear();
                }
            }
            return m->sq_item(o, i);
        }
    }
#else
    if (is_list || PySequence_Check(o)) {
        return PySequence_GetItem(o, i);
    }
#endif
    return __Pyx_GetItemInt_Generic(o, PyInt_FromSsize_t(i));
}

/* DictGetItem */
#if PY_MAJOR_VERSION >= 3 && !CYTHON_COMPILING_IN_PYPY
static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
    PyObject *value;
    value = PyDict_GetItemWithError(d, key);
    if (unlikely(!value)) {
        if (!PyErr_Occurred()) {
            PyObject* args = PyTuple_Pack(1, key);
            if (likely(args))
                PyErr_SetObject(PyExc_KeyError, args);
            Py_XDECREF(args);
        }
        return NULL;
    }
    Py_INCREF(value);
    return value;
}
#endif

/* PyCFunctionFastCall */
#if CYTHON_FAST_PYCCALL
static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *func_obj, PyObject **args, Py_ssize_t nargs) {
    PyCFunctionObject *func = (PyCFunctionObject*)func_obj;
    PyCFunction meth = PyCFunction_GET_FUNCTION(func);
    PyObject *self = PyCFunction_GET_SELF(func);
    int flags = PyCFunction_GET_FLAGS(func);
    assert(PyCFunction_Check(func));
    assert(METH_FASTCALL == (flags & ~(METH_CLASS | METH_STATIC | METH_COEXIST | METH_KEYWORDS)));
    assert(nargs >= 0);
    assert(nargs == 0 || args != NULL);
    /* _PyCFunction_FastCallDict() must not be called with an exception set,
       because it may clear it (directly or indirectly) and so the
       caller loses its exception */
    assert(!PyErr_Occurred());
    if ((PY_VERSION_HEX < 0x030700A0) || unlikely(flags & METH_KEYWORDS)) {
        return (*((__Pyx_PyCFunctionFastWithKeywords)meth)) (self, args, nargs, NULL);
    } else {
        return (*((__Pyx_PyCFunctionFast)meth)) (self, args, nargs);
    }
}
#endif

/* PyFunctionFastCall */
#if CYTHON_FAST_PYCALL
#include "frameobject.h"
static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObject **args, Py_ssize_t na,
                                               PyObject *globals) {
    PyFrameObject *f;
    PyThreadState *tstate = __Pyx_PyThreadState_Current;
    PyObject **fastlocals;
    Py_ssize_t i;
    PyObject *result;
    assert(globals != NULL);
    /* XXX Perhaps we should create a specialized
       PyFrame_New() that doesn't take locals, but does
       take builtins without sanity checking them.
       */
    assert(tstate != NULL);
    f = PyFrame_New(tstate, co, globals, NULL);
    if (f == NULL) {
        return NULL;
    }
    fastlocals = f->f_localsplus;
    for (i = 0; i < na; i++) {
        Py_INCREF(*args);
        fastlocals[i] = *args++;
    }
    result = PyEval_EvalFrameEx(f,0);
    ++tstate->recursion_depth;
    Py_DECREF(f);
    --tstate->recursion_depth;
    return result;
}
#if 1 || PY_VERSION_HEX < 0x030600B1
static PyObject *__Pyx_PyFunction_FastCallDict(PyObject *func, PyObject **args, int nargs, PyObject *kwargs) {
    PyCodeObject *co = (PyCodeObject *)PyFunction_GET_CODE(func);
    PyObject *globals = PyFunction_GET_GLOBALS(func);
    PyObject *argdefs = PyFunction_GET_DEFAULTS(func);
    PyObject *closure;
#if PY_MAJOR_VERSION >= 3
    PyObject *kwdefs;
#endif
    PyObject *kwtuple, **k;
    PyObject **d;
    Py_ssize_t nd;
    Py_ssize_t nk;
    PyObject *result;
    assert(kwargs == NULL || PyDict_Check(kwargs));
    nk = kwargs ? PyDict_Size(kwargs) : 0;
    if (Py_EnterRecursiveCall((char*)" while calling a Python object")) {
        return NULL;
    }
    if (
#if PY_MAJOR_VERSION >= 3
            co->co_kwonlyargcount == 0 &&
#endif
            likely(kwargs == NULL || nk == 0) &&
            co->co_flags == (CO_OPTIMIZED | CO_NEWLOCALS | CO_NOFREE)) {
        if (argdefs == NULL && co->co_argcount == nargs) {
            result = __Pyx_PyFunction_FastCallNoKw(co, args, nargs, globals);
            goto done;
        }
        else if (nargs == 0 && argdefs != NULL
                 && co->co_argcount == Py_SIZE(argdefs)) {
            /* function called with no arguments, but all parameters have
               a default value: use default values as arguments .*/
            args = &PyTuple_GET_ITEM(argdefs, 0);
            result =__Pyx_PyFunction_FastCallNoKw(co, args, Py_SIZE(argdefs), globals);
            goto done;
        }
    }
    if (kwargs != NULL) {
        Py_ssize_t pos, i;
        kwtuple = PyTuple_New(2 * nk);
        if (kwtuple == NULL) {
            result = NULL;
            goto done;
        }
        k = &PyTuple_GET_ITEM(kwtuple, 0);
        pos = i = 0;
        while (PyDict_Next(kwargs, &pos, &k[i], &k[i+1])) {
            Py_INCREF(k[i]);
            Py_INCREF(k[i+1]);
            i += 2;
        }
        nk = i / 2;
    }
    else {
        kwtuple = NULL;
        k = NULL;
    }
    closure = PyFunction_GET_CLOSURE(func);
#if PY_MAJOR_VERSION >= 3
    kwdefs = PyFunction_GET_KW_DEFAULTS(func);
#endif
    if (argdefs != NULL) {
        d = &PyTuple_GET_ITEM(argdefs, 0);
        nd = Py_SIZE(argdefs);
    }
    else {
        d = NULL;
        nd = 0;
    }
#if PY_MAJOR_VERSION >= 3
    result = PyEval_EvalCodeEx((PyObject*)co, globals, (PyObject *)NULL,
                               args, nargs,
                               k, (int)nk,
                               d, (int)nd, kwdefs, closure);
#else
    result = PyEval_EvalCodeEx(co, globals, (PyObject *)NULL,
                               args, nargs,
                               k, (int)nk,
                               d, (int)nd, closure);
#endif
    Py_XDECREF(kwtuple);
done:
    Py_LeaveRecursiveCall();
    return result;
}
#endif
#endif

/* PyObjectCall */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObject *arg, PyObject *kw) {
    PyObject *result;
    ternaryfunc call = func->ob_type->tp_call;
    if (unlikely(!call))
        return PyObject_Call(func, arg, kw);
    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
        return NULL;
    result = (*call)(func, arg, kw);
    Py_LeaveRecursiveCall();
    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
        PyErr_SetString(
            PyExc_SystemError,
            "NULL result without error in PyObject_Call");
    }
    return result;
}
#endif

/* PyObjectCallMethO */
#if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, PyObject *arg) {
    PyObject *self, *result;
    PyCFunction cfunc;
    cfunc = PyCFunction_GET_FUNCTION(func);
    self = PyCFunction_GET_SELF(func);
    if (unlikely(Py_EnterRecursiveCall((char*)" while calling a Python object")))
        return NULL;
    result = cfunc(self, arg);
    Py_LeaveRecursiveCall();
    if (unlikely(!result) && unlikely(!PyErr_Occurred())) {
        PyErr_SetString(
            PyExc_SystemError,
            "NULL result without error in PyObject_Call");
    }
    return result;
}
#endif

/* PyObjectCallOneArg */
#if CYTHON_COMPILING_IN_CPYTHON
static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *arg) {
    PyObject *result;
    PyObject *args = PyTuple_New(1);
    if (unlikely(!args)) return NULL;
    Py_INCREF(arg);
    PyTuple_SET_ITEM(args, 0, arg);
    result = __Pyx_PyObject_Call(func, args, NULL);
    Py_DECREF(args);
    return result;
}
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
#if CYTHON_FAST_PYCALL
    if (PyFunction_Check(func)) {
        return __Pyx_PyFunction_FastCall(func, &arg, 1);
    }
#endif
    if (likely(PyCFunction_Check(func))) {
        if (likely(PyCFunction_GET_FLAGS(func) & METH_O)) {
            return __Pyx_PyObject_CallMethO(func, arg);
#if CYTHON_FAST_PYCCALL
        } else if (PyCFunction_GET_FLAGS(func) & METH_FASTCALL) {
            return __Pyx_PyCFunction_FastCall(func, &arg, 1);
#endif
        }
    }
    return __Pyx__PyObject_CallOneArg(func, arg);
}
#else
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func, PyObject *arg) {
    PyObject *result;
    PyObject *args = PyTuple_Pack(1, arg);
    if (unlikely(!args)) return NULL;
    result = __Pyx_PyObject_Call(func, args, NULL);
    Py_DECREF(args);
    return result;
}
#endif

/* PyErrFetchRestore */
#if CYTHON_FAST_THREAD_STATE
static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate, PyObject *type, PyObject *value, PyObject *tb) {
    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);
}
static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, PyObject **type, PyObject **value, PyObject **tb) {
    *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

/* RaiseException */
#if PY_MAJOR_VERSION < 3
static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
                        CYTHON_UNUSED PyObject *cause) {
    __Pyx_PyThreadState_declare
    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)) {
#if CYTHON_COMPILING_IN_PYPY
        if (!value) {
            Py_INCREF(Py_None);
            value = Py_None;
        }
#endif
        PyErr_NormalizeException(&type, &value, &tb);
    } else {
        if (value) {
            PyErr_SetString(PyExc_TypeError,
                "instance exception may not have a separate value");
            goto raise_error;
        }
        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
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)) {
        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)) {
                    goto bad;
                } else {
                    type = instance_class;
                }
            }
        }
        if (!instance_class) {
            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) {
            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 CYTHON_COMPILING_IN_PYPY
        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);
#else
        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);
        }
#endif
    }
bad:
    Py_XDECREF(owned_instance);
    return;
}
#endif

/* SetItemInt */
static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *v) {
    int r;
    if (!j) return -1;
    r = PyObject_SetItem(o, j, v);
    Py_DECREF(j);
    return r;
}
static CYTHON_INLINE int __Pyx_SetItemInt_Fast(PyObject *o, Py_ssize_t i, PyObject *v, int is_list,
                                               CYTHON_NCP_UNUSED int wraparound, CYTHON_NCP_UNUSED int boundscheck) {
#if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS && CYTHON_USE_TYPE_SLOTS
    if (is_list || PyList_CheckExact(o)) {
        Py_ssize_t n = (!wraparound) ? i : ((likely(i >= 0)) ? i : i + PyList_GET_SIZE(o));
        if ((!boundscheck) || likely((n >= 0) & (n < PyList_GET_SIZE(o)))) {
            PyObject* old = PyList_GET_ITEM(o, n);
            Py_INCREF(v);
            PyList_SET_ITEM(o, n, v);
            Py_DECREF(old);
            return 1;
        }
    } else {
        PySequenceMethods *m = Py_TYPE(o)->tp_as_sequence;
        if (likely(m && m->sq_ass_item)) {
            if (wraparound && unlikely(i < 0) && likely(m->sq_length)) {
                Py_ssize_t l = m->sq_length(o);
                if (likely(l >= 0)) {
                    i += l;
                } else {
                    if (!PyErr_ExceptionMatches(PyExc_OverflowError))
                        return -1;
                    PyErr_Clear();
                }
            }
            return m->sq_ass_item(o, i, v);
        }
    }
#else
#if CYTHON_COMPILING_IN_PYPY
    if (is_list || (PySequence_Check(o) && !PyDict_Check(o))) {
#else
    if (is_list || PySequence_Check(o)) {
#endif
        return PySequence_SetItem(o, i, v);
    }
#endif
    return __Pyx_SetItemInt_Generic(o, PyInt_FromSsize_t(i), v);
}

/* IterFinish */
  static CYTHON_INLINE int __Pyx_IterFinish(void) {
#if CYTHON_FAST_THREAD_STATE
    PyThreadState *tstate = __Pyx_PyThreadState_Current;
    PyObject* exc_type = tstate->curexc_type;
    if (unlikely(exc_type)) {
        if (likely(__Pyx_PyErr_GivenExceptionMatches(exc_type, PyExc_StopIteration))) {
            PyObject *exc_value, *exc_tb;
            exc_value = tstate->curexc_value;
            exc_tb = tstate->curexc_traceback;
            tstate->curexc_type = 0;
            tstate->curexc_value = 0;
            tstate->curexc_traceback = 0;
            Py_DECREF(exc_type);
            Py_XDECREF(exc_value);
            Py_XDECREF(exc_tb);
            return 0;
        } else {
            return -1;
        }
    }
    return 0;
#else
    if (unlikely(PyErr_Occurred())) {
        if (likely(PyErr_ExceptionMatches(PyExc_StopIteration))) {
            PyErr_Clear();
            return 0;
        } else {
            return -1;
        }
    }
    return 0;
#endif
}

/* PyObjectCallNoArg */
  #if CYTHON_COMPILING_IN_CPYTHON
static CYTHON_INLINE PyObject* __Pyx_PyObject_CallNoArg(PyObject *func) {
#if CYTHON_FAST_PYCALL
    if (PyFunction_Check(func)) {
        return __Pyx_PyFunction_FastCall(func, NULL, 0);
    }
#endif
#ifdef __Pyx_CyFunction_USED
    if (likely(PyCFunction_Check(func) || __Pyx_TypeCheck(func, __pyx_CyFunctionType))) {
#else
    if (likely(PyCFunction_Check(func))) {
#endif
        if (likely(PyCFunction_GET_FLAGS(func) & METH_NOARGS)) {
            return __Pyx_PyObject_CallMethO(func, NULL);
        }
    }
    return __Pyx_PyObject_Call(func, __pyx_empty_tuple, NULL);
}
#endif

/* PyObjectCallMethod0 */
    static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* method_name) {
    PyObject *method, *result = NULL;
    method = __Pyx_PyObject_GetAttrStr(obj, method_name);
    if (unlikely(!method)) goto bad;
#if CYTHON_UNPACK_METHODS
    if (likely(PyMethod_Check(method))) {
        PyObject *self = PyMethod_GET_SELF(method);
        if (likely(self)) {
            PyObject *function = PyMethod_GET_FUNCTION(method);
            result = __Pyx_PyObject_CallOneArg(function, self);
            Py_DECREF(method);
            return result;
        }
    }
#endif
    result = __Pyx_PyObject_CallNoArg(method);
    Py_DECREF(method);
bad:
    return result;
}

/* RaiseNeedMoreValuesToUnpack */
    static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t index) {
    PyErr_Format(PyExc_ValueError,
                 "need more than %" CYTHON_FORMAT_SSIZE_T "d value%.1s to unpack",
                 index, (index == 1) ? "" : "s");
}

/* RaiseTooManyValuesToUnpack */
    static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expected) {
    PyErr_Format(PyExc_ValueError,
                 "too many values to unpack (expected %" CYTHON_FORMAT_SSIZE_T "d)", expected);
}

/* UnpackItemEndCheck */
    static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t expected) {
    if (unlikely(retval)) {
        Py_DECREF(retval);
        __Pyx_RaiseTooManyValuesError(expected);
        return -1;
    } else {
        return __Pyx_IterFinish();
    }
    return 0;
}

/* RaiseNoneIterError */
    static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
    PyErr_SetString(PyExc_TypeError, "'NoneType' object is not iterable");
}

/* UnpackTupleError */
    static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) {
    if (t == Py_None) {
      __Pyx_RaiseNoneNotIterableError();
    } else if (PyTuple_GET_SIZE(t) < index) {
      __Pyx_RaiseNeedMoreValuesError(PyTuple_GET_SIZE(t));
    } else {
      __Pyx_RaiseTooManyValuesError(index);
    }
}

/* UnpackTuple2 */
    static CYTHON_INLINE int __Pyx_unpack_tuple2_exact(
        PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2, int decref_tuple) {
    PyObject *value1 = NULL, *value2 = NULL;
#if CYTHON_COMPILING_IN_PYPY
    value1 = PySequence_ITEM(tuple, 0);  if (unlikely(!value1)) goto bad;
    value2 = PySequence_ITEM(tuple, 1);  if (unlikely(!value2)) goto bad;
#else
    value1 = PyTuple_GET_ITEM(tuple, 0);  Py_INCREF(value1);
    value2 = PyTuple_GET_ITEM(tuple, 1);  Py_INCREF(value2);
#endif
    if (decref_tuple) {
        Py_DECREF(tuple);
    }
    *pvalue1 = value1;
    *pvalue2 = value2;
    return 0;
#if CYTHON_COMPILING_IN_PYPY
bad:
    Py_XDECREF(value1);
    Py_XDECREF(value2);
    if (decref_tuple) { Py_XDECREF(tuple); }
    return -1;
#endif
}
static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalue1, PyObject** pvalue2,
                                       int has_known_size, int decref_tuple) {
    Py_ssize_t index;
    PyObject *value1 = NULL, *value2 = NULL, *iter = NULL;
    iternextfunc iternext;
    iter = PyObject_GetIter(tuple);
    if (unlikely(!iter)) goto bad;
    if (decref_tuple) { Py_DECREF(tuple); tuple = NULL; }
    iternext = Py_TYPE(iter)->tp_iternext;
    value1 = iternext(iter); if (unlikely(!value1)) { index = 0; goto unpacking_failed; }
    value2 = iternext(iter); if (unlikely(!value2)) { index = 1; goto unpacking_failed; }
    if (!has_known_size && unlikely(__Pyx_IternextUnpackEndCheck(iternext(iter), 2))) goto bad;
    Py_DECREF(iter);
    *pvalue1 = value1;
    *pvalue2 = value2;
    return 0;
unpacking_failed:
    if (!has_known_size && __Pyx_IterFinish() == 0)
        __Pyx_RaiseNeedMoreValuesError(index);
bad:
    Py_XDECREF(iter);
    Py_XDECREF(value1);
    Py_XDECREF(value2);
    if (decref_tuple) { Py_XDECREF(tuple); }
    return -1;
}

/* dict_iter */
    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
        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;
}

/* FetchCommonType */
    static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) {
    PyObject* fake_module;
    PyTypeObject* cached_type = NULL;
    fake_module = PyImport_AddModule((char*) "_cython_" CYTHON_ABI);
    if (!fake_module) return NULL;
    Py_INCREF(fake_module);
    cached_type = (PyTypeObject*) PyObject_GetAttrString(fake_module, type->tp_name);
    if (cached_type) {
        if (!PyType_Check((PyObject*)cached_type)) {
            PyErr_Format(PyExc_TypeError,
                "Shared Cython type %.200s is not a type object",
                type->tp_name);
            goto bad;
        }
        if (cached_type->tp_basicsize != type->tp_basicsize) {
            PyErr_Format(PyExc_TypeError,
                "Shared Cython type %.200s has the wrong size, try recompiling",
                type->tp_name);
            goto bad;
        }
    } else {
        if (!PyErr_ExceptionMatches(PyExc_AttributeError)) goto bad;
        PyErr_Clear();
        if (PyType_Ready(type) < 0) goto bad;
        if (PyObject_SetAttrString(fake_module, type->tp_name, (PyObject*) type) < 0)
            goto bad;
        Py_INCREF(type);
        cached_type = type;
    }
done:
    Py_DECREF(fake_module);
    return cached_type;
bad:
    Py_XDECREF(cached_type);
    cached_type = NULL;
    goto done;
}

/* CythonFunction */
    #include <structmember.h>
static PyObject *
__Pyx_CyFunction_get_doc(__pyx_CyFunctionObject *op, CYTHON_UNUSED void *closure)
{
    if (unlikely(op->func_doc == NULL)) {
        if (op->func.m_ml->ml_doc) {
#if PY_MAJOR_VERSION >= 3
            op->func_doc = PyUnicode_FromString(op->func.m_ml->ml_doc);
#else
            op->func_doc = PyString_FromString(op->func.m_ml->ml_doc);
#endif
            if (unlikely(op->func_doc == NULL))
                return NULL;
        } else {
            Py_INCREF(Py_None);
            return Py_None;
        }
    }
    Py_INCREF(op->func_doc);
    return op->func_doc;
}
static int
__Pyx_CyFunction_set_doc(__pyx_CyFunctionObject *op, PyObject *value)
{
    PyObject *tmp = op->func_doc;
    if (value == NULL) {
        value = Py_None;
    }
    Py_INCREF(value);
    op->func_doc = value;
    Py_XDECREF(tmp);
    return 0;
}
static PyObject *
__Pyx_CyFunction_get_name(__pyx_CyFunctionObject *op)
{
    if (unlikely(op->func_name == NULL)) {
#if PY_MAJOR_VERSION >= 3
        op->func_name = PyUnicode_InternFromString(op->func.m_ml->ml_name);
#else
        op->func_name = PyString_InternFromString(op->func.m_ml->ml_name);
#endif
        if (unlikely(op->func_name == NULL))
            return NULL;
    }
    Py_INCREF(op->func_name);
    return op->func_name;
}
static int
__Pyx_CyFunction_set_name(__pyx_CyFunctionObject *op, PyObject *value)
{
    PyObject *tmp;
#if PY_MAJOR_VERSION >= 3
    if (unlikely(value == NULL || !PyUnicode_Check(value))) {
#else
    if (unlikely(value == NULL || !PyString_Check(value))) {
#endif
        PyErr_SetString(PyExc_TypeError,
                        "__name__ must be set to a string object");
        return -1;
    }
    tmp = op->func_name;
    Py_INCREF(value);
    op->func_name = value;
    Py_XDECREF(tmp);
    return 0;
}
static PyObject *
__Pyx_CyFunction_get_qualname(__pyx_CyFunctionObject *op)
{
    Py_INCREF(op->func_qualname);
    return op->func_qualname;
}
static int
__Pyx_CyFunction_set_qualname(__pyx_CyFunctionObject *op, PyObject *value)
{
    PyObject *tmp;
#if PY_MAJOR_VERSION >= 3
    if (unlikely(value == NULL || !PyUnicode_Check(value))) {
#else
    if (unlikely(value == NULL || !PyString_Check(value))) {
#endif
        PyErr_SetString(PyExc_TypeError,
                        "__qualname__ must be set to a string object");
        return -1;
    }
    tmp = op->func_qualname;
    Py_INCREF(value);
    op->func_qualname = value;
    Py_XDECREF(tmp);
    return 0;
}
static PyObject *
__Pyx_CyFunction_get_self(__pyx_CyFunctionObject *m, CYTHON_UNUSED void *closure)
{
    PyObject *self;
    self = m->func_closure;
    if (self == NULL)
        self = Py_None;
    Py_INCREF(self);
    return self;
}
static PyObject *
__Pyx_CyFunction_get_dict(__pyx_CyFunctionObject *op)
{
    if (unlikely(op->func_dict == NULL)) {
        op->func_dict = PyDict_New();
        if (unlikely(op->func_dict == NULL))
            return NULL;
    }
    Py_INCREF(op->func_dict);
    return op->func_dict;
}
static int
__Pyx_CyFunction_set_dict(__pyx_CyFunctionObject *op, PyObject *value)
{
    PyObject *tmp;
    if (unlikely(value == NULL)) {
        PyErr_SetString(PyExc_TypeError,
               "function's dictionary may not be deleted");
        return -1;
    }
    if (unlikely(!PyDict_Check(value))) {
        PyErr_SetString(PyExc_TypeError,
               "setting function's dictionary to a non-dict");
        return -1;
    }
    tmp = op->func_dict;
    Py_INCREF(value);
    op->func_dict = value;
    Py_XDECREF(tmp);
    return 0;
}
static PyObject *
__Pyx_CyFunction_get_globals(__pyx_CyFunctionObject *op)
{
    Py_INCREF(op->func_globals);
    return op->func_globals;
}
static PyObject *
__Pyx_CyFunction_get_closure(CYTHON_UNUSED __pyx_CyFunctionObject *op)
{
    Py_INCREF(Py_None);
    return Py_None;
}
static PyObject *
__Pyx_CyFunction_get_code(__pyx_CyFunctionObject *op)
{
    PyObject* result = (op->func_code) ? op->func_code : Py_None;
    Py_INCREF(result);
    return result;
}
static int
__Pyx_CyFunction_init_defaults(__pyx_CyFunctionObject *op) {
    int result = 0;
    PyObject *res = op->defaults_getter((PyObject *) op);
    if (unlikely(!res))
        return -1;
    #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
    op->defaults_tuple = PyTuple_GET_ITEM(res, 0);
    Py_INCREF(op->defaults_tuple);
    op->defaults_kwdict = PyTuple_GET_ITEM(res, 1);
    Py_INCREF(op->defaults_kwdict);
    #else
    op->defaults_tuple = PySequence_ITEM(res, 0);
    if (unlikely(!op->defaults_tuple)) result = -1;
    else {
        op->defaults_kwdict = PySequence_ITEM(res, 1);
        if (unlikely(!op->defaults_kwdict)) result = -1;
    }
    #endif
    Py_DECREF(res);
    return result;
}
static int
__Pyx_CyFunction_set_defaults(__pyx_CyFunctionObject *op, PyObject* value) {
    PyObject* tmp;
    if (!value) {
        value = Py_None;
    } else if (value != Py_None && !PyTuple_Check(value)) {
        PyErr_SetString(PyExc_TypeError,
                        "__defaults__ must be set to a tuple object");
        return -1;
    }
    Py_INCREF(value);
    tmp = op->defaults_tuple;
    op->defaults_tuple = value;
    Py_XDECREF(tmp);
    return 0;
}
static PyObject *
__Pyx_CyFunction_get_defaults(__pyx_CyFunctionObject *op) {
    PyObject* result = op->defaults_tuple;
    if (unlikely(!result)) {
        if (op->defaults_getter) {
            if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL;
            result = op->defaults_tuple;
        } else {
            result = Py_None;
        }
    }
    Py_INCREF(result);
    return result;
}
static int
__Pyx_CyFunction_set_kwdefaults(__pyx_CyFunctionObject *op, PyObject* value) {
    PyObject* tmp;
    if (!value) {
        value = Py_None;
    } else if (value != Py_None && !PyDict_Check(value)) {
        PyErr_SetString(PyExc_TypeError,
                        "__kwdefaults__ must be set to a dict object");
        return -1;
    }
    Py_INCREF(value);
    tmp = op->defaults_kwdict;
    op->defaults_kwdict = value;
    Py_XDECREF(tmp);
    return 0;
}
static PyObject *
__Pyx_CyFunction_get_kwdefaults(__pyx_CyFunctionObject *op) {
    PyObject* result = op->defaults_kwdict;
    if (unlikely(!result)) {
        if (op->defaults_getter) {
            if (__Pyx_CyFunction_init_defaults(op) < 0) return NULL;
            result = op->defaults_kwdict;
        } else {
            result = Py_None;
        }
    }
    Py_INCREF(result);
    return result;
}
static int
__Pyx_CyFunction_set_annotations(__pyx_CyFunctionObject *op, PyObject* value) {
    PyObject* tmp;
    if (!value || value == Py_None) {
        value = NULL;
    } else if (!PyDict_Check(value)) {
        PyErr_SetString(PyExc_TypeError,
                        "__annotations__ must be set to a dict object");
        return -1;
    }
    Py_XINCREF(value);
    tmp = op->func_annotations;
    op->func_annotations = value;
    Py_XDECREF(tmp);
    return 0;
}
static PyObject *
__Pyx_CyFunction_get_annotations(__pyx_CyFunctionObject *op) {
    PyObject* result = op->func_annotations;
    if (unlikely(!result)) {
        result = PyDict_New();
        if (unlikely(!result)) return NULL;
        op->func_annotations = result;
    }
    Py_INCREF(result);
    return result;
}
static PyGetSetDef __pyx_CyFunction_getsets[] = {
    {(char *) "func_doc", (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
    {(char *) "__doc__",  (getter)__Pyx_CyFunction_get_doc, (setter)__Pyx_CyFunction_set_doc, 0, 0},
    {(char *) "func_name", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
    {(char *) "__name__", (getter)__Pyx_CyFunction_get_name, (setter)__Pyx_CyFunction_set_name, 0, 0},
    {(char *) "__qualname__", (getter)__Pyx_CyFunction_get_qualname, (setter)__Pyx_CyFunction_set_qualname, 0, 0},
    {(char *) "__self__", (getter)__Pyx_CyFunction_get_self, 0, 0, 0},
    {(char *) "func_dict", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
    {(char *) "__dict__", (getter)__Pyx_CyFunction_get_dict, (setter)__Pyx_CyFunction_set_dict, 0, 0},
    {(char *) "func_globals", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
    {(char *) "__globals__", (getter)__Pyx_CyFunction_get_globals, 0, 0, 0},
    {(char *) "func_closure", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
    {(char *) "__closure__", (getter)__Pyx_CyFunction_get_closure, 0, 0, 0},
    {(char *) "func_code", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
    {(char *) "__code__", (getter)__Pyx_CyFunction_get_code, 0, 0, 0},
    {(char *) "func_defaults", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
    {(char *) "__defaults__", (getter)__Pyx_CyFunction_get_defaults, (setter)__Pyx_CyFunction_set_defaults, 0, 0},
    {(char *) "__kwdefaults__", (getter)__Pyx_CyFunction_get_kwdefaults, (setter)__Pyx_CyFunction_set_kwdefaults, 0, 0},
    {(char *) "__annotations__", (getter)__Pyx_CyFunction_get_annotations, (setter)__Pyx_CyFunction_set_annotations, 0, 0},
    {0, 0, 0, 0, 0}
};
static PyMemberDef __pyx_CyFunction_members[] = {
    {(char *) "__module__", T_OBJECT, offsetof(PyCFunctionObject, m_module), PY_WRITE_RESTRICTED, 0},
    {0, 0, 0,  0, 0}
};
static PyObject *
__Pyx_CyFunction_reduce(__pyx_CyFunctionObject *m, CYTHON_UNUSED PyObject *args)
{
#if PY_MAJOR_VERSION >= 3
    return PyUnicode_FromString(m->func.m_ml->ml_name);
#else
    return PyString_FromString(m->func.m_ml->ml_name);
#endif
}
static PyMethodDef __pyx_CyFunction_methods[] = {
    {"__reduce__", (PyCFunction)__Pyx_CyFunction_reduce, METH_VARARGS, 0},
    {0, 0, 0, 0}
};
#if PY_VERSION_HEX < 0x030500A0
#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func_weakreflist)
#else
#define __Pyx_CyFunction_weakreflist(cyfunc) ((cyfunc)->func.m_weakreflist)
#endif
static PyObject *__Pyx_CyFunction_New(PyTypeObject *type, PyMethodDef *ml, int flags, PyObject* qualname,
                                      PyObject *closure, PyObject *module, PyObject* globals, PyObject* code) {
    __pyx_CyFunctionObject *op = PyObject_GC_New(__pyx_CyFunctionObject, type);
    if (op == NULL)
        return NULL;
    op->flags = flags;
    __Pyx_CyFunction_weakreflist(op) = NULL;
    op->func.m_ml = ml;
    op->func.m_self = (PyObject *) op;
    Py_XINCREF(closure);
    op->func_closure = closure;
    Py_XINCREF(module);
    op->func.m_module = module;
    op->func_dict = NULL;
    op->func_name = NULL;
    Py_INCREF(qualname);
    op->func_qualname = qualname;
    op->func_doc = NULL;
    op->func_classobj = NULL;
    op->func_globals = globals;
    Py_INCREF(op->func_globals);
    Py_XINCREF(code);
    op->func_code = code;
    op->defaults_pyobjects = 0;
    op->defaults = NULL;
    op->defaults_tuple = NULL;
    op->defaults_kwdict = NULL;
    op->defaults_getter = NULL;
    op->func_annotations = NULL;
    PyObject_GC_Track(op);
    return (PyObject *) op;
}
static int
__Pyx_CyFunction_clear(__pyx_CyFunctionObject *m)
{
    Py_CLEAR(m->func_closure);
    Py_CLEAR(m->func.m_module);
    Py_CLEAR(m->func_dict);
    Py_CLEAR(m->func_name);
    Py_CLEAR(m->func_qualname);
    Py_CLEAR(m->func_doc);
    Py_CLEAR(m->func_globals);
    Py_CLEAR(m->func_code);
    Py_CLEAR(m->func_classobj);
    Py_CLEAR(m->defaults_tuple);
    Py_CLEAR(m->defaults_kwdict);
    Py_CLEAR(m->func_annotations);
    if (m->defaults) {
        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
        int i;
        for (i = 0; i < m->defaults_pyobjects; i++)
            Py_XDECREF(pydefaults[i]);
        PyObject_Free(m->defaults);
        m->defaults = NULL;
    }
    return 0;
}
static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m)
{
    if (__Pyx_CyFunction_weakreflist(m) != NULL)
        PyObject_ClearWeakRefs((PyObject *) m);
    __Pyx_CyFunction_clear(m);
    PyObject_GC_Del(m);
}
static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m)
{
    PyObject_GC_UnTrack(m);
    __Pyx__CyFunction_dealloc(m);
}
static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitproc visit, void *arg)
{
    Py_VISIT(m->func_closure);
    Py_VISIT(m->func.m_module);
    Py_VISIT(m->func_dict);
    Py_VISIT(m->func_name);
    Py_VISIT(m->func_qualname);
    Py_VISIT(m->func_doc);
    Py_VISIT(m->func_globals);
    Py_VISIT(m->func_code);
    Py_VISIT(m->func_classobj);
    Py_VISIT(m->defaults_tuple);
    Py_VISIT(m->defaults_kwdict);
    if (m->defaults) {
        PyObject **pydefaults = __Pyx_CyFunction_Defaults(PyObject *, m);
        int i;
        for (i = 0; i < m->defaults_pyobjects; i++)
            Py_VISIT(pydefaults[i]);
    }
    return 0;
}
static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *obj, PyObject *type)
{
    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
    if (m->flags & __Pyx_CYFUNCTION_STATICMETHOD) {
        Py_INCREF(func);
        return func;
    }
    if (m->flags & __Pyx_CYFUNCTION_CLASSMETHOD) {
        if (type == NULL)
            type = (PyObject *)(Py_TYPE(obj));
        return __Pyx_PyMethod_New(func, type, (PyObject *)(Py_TYPE(type)));
    }
    if (obj == Py_None)
        obj = NULL;
    return __Pyx_PyMethod_New(func, obj, type);
}
static PyObject*
__Pyx_CyFunction_repr(__pyx_CyFunctionObject *op)
{
#if PY_MAJOR_VERSION >= 3
    return PyUnicode_FromFormat("<cyfunction %U at %p>",
                                op->func_qualname, (void *)op);
#else
    return PyString_FromFormat("<cyfunction %s at %p>",
                               PyString_AsString(op->func_qualname), (void *)op);
#endif
}
static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *self, PyObject *arg, PyObject *kw) {
    PyCFunctionObject* f = (PyCFunctionObject*)func;
    PyCFunction meth = f->m_ml->ml_meth;
    Py_ssize_t size;
    switch (f->m_ml->ml_flags & (METH_VARARGS | METH_KEYWORDS | METH_NOARGS | METH_O)) {
    case METH_VARARGS:
        if (likely(kw == NULL || PyDict_Size(kw) == 0))
            return (*meth)(self, arg);
        break;
    case METH_VARARGS | METH_KEYWORDS:
        return (*(PyCFunctionWithKeywords)meth)(self, arg, kw);
    case METH_NOARGS:
        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
            size = PyTuple_GET_SIZE(arg);
            if (likely(size == 0))
                return (*meth)(self, NULL);
            PyErr_Format(PyExc_TypeError,
                "%.200s() takes no arguments (%" CYTHON_FORMAT_SSIZE_T "d given)",
                f->m_ml->ml_name, size);
            return NULL;
        }
        break;
    case METH_O:
        if (likely(kw == NULL || PyDict_Size(kw) == 0)) {
            size = PyTuple_GET_SIZE(arg);
            if (likely(size == 1)) {
                PyObject *result, *arg0;
                #if CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS
                arg0 = PyTuple_GET_ITEM(arg, 0);
                #else
                arg0 = PySequence_ITEM(arg, 0); if (unlikely(!arg0)) return NULL;
                #endif
                result = (*meth)(self, arg0);
                #if !(CYTHON_ASSUME_SAFE_MACROS && !CYTHON_AVOID_BORROWED_REFS)
                Py_DECREF(arg0);
                #endif
                return result;
            }
            PyErr_Format(PyExc_TypeError,
                "%.200s() takes exactly one argument (%" CYTHON_FORMAT_SSIZE_T "d given)",
                f->m_ml->ml_name, size);
            return NULL;
        }
        break;
    default:
        PyErr_SetString(PyExc_SystemError, "Bad call flags in "
                        "__Pyx_CyFunction_Call. METH_OLDARGS is no "
                        "longer supported!");
        return NULL;
    }
    PyErr_Format(PyExc_TypeError, "%.200s() takes no keyword arguments",
                 f->m_ml->ml_name);
    return NULL;
}
static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyObject *arg, PyObject *kw) {
    return __Pyx_CyFunction_CallMethod(func, ((PyCFunctionObject*)func)->m_self, arg, kw);
}
static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject *args, PyObject *kw) {
    PyObject *result;
    __pyx_CyFunctionObject *cyfunc = (__pyx_CyFunctionObject *) func;
    if ((cyfunc->flags & __Pyx_CYFUNCTION_CCLASS) && !(cyfunc->flags & __Pyx_CYFUNCTION_STATICMETHOD)) {
        Py_ssize_t argc;
        PyObject *new_args;
        PyObject *self;
        argc = PyTuple_GET_SIZE(args);
        new_args = PyTuple_GetSlice(args, 1, argc);
        if (unlikely(!new_args))
            return NULL;
        self = PyTuple_GetItem(args, 0);
        if (unlikely(!self)) {
            Py_DECREF(new_args);
            return NULL;
        }
        result = __Pyx_CyFunction_CallMethod(func, self, new_args, kw);
        Py_DECREF(new_args);
    } else {
        result = __Pyx_CyFunction_Call(func, args, kw);
    }
    return result;
}
static PyTypeObject __pyx_CyFunctionType_type = {
    PyVarObject_HEAD_INIT(0, 0)
    "cython_function_or_method",
    sizeof(__pyx_CyFunctionObject),
    0,
    (destructor) __Pyx_CyFunction_dealloc,
    0,
    0,
    0,
#if PY_MAJOR_VERSION < 3
    0,
#else
    0,
#endif
    (reprfunc) __Pyx_CyFunction_repr,
    0,
    0,
    0,
    0,
    __Pyx_CyFunction_CallAsMethod,
    0,
    0,
    0,
    0,
    Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC,
    0,
    (traverseproc) __Pyx_CyFunction_traverse,
    (inquiry) __Pyx_CyFunction_clear,
    0,
#if PY_VERSION_HEX < 0x030500A0
    offsetof(__pyx_CyFunctionObject, func_weakreflist),
#else
    offsetof(PyCFunctionObject, m_weakreflist),
#endif
    0,
    0,
    __pyx_CyFunction_methods,
    __pyx_CyFunction_members,
    __pyx_CyFunction_getsets,
    0,
    0,
    __Pyx_CyFunction_descr_get,
    0,
    offsetof(__pyx_CyFunctionObject, func_dict),
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
    0,
#if PY_VERSION_HEX >= 0x030400a1
    0,
#endif
};
static int __pyx_CyFunction_init(void) {
    __pyx_CyFunctionType = __Pyx_FetchCommonType(&__pyx_CyFunctionType_type);
    if (unlikely(__pyx_CyFunctionType == NULL)) {
        return -1;
    }
    return 0;
}
static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func, size_t size, int pyobjects) {
    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
    m->defaults = PyObject_Malloc(size);
    if (unlikely(!m->defaults))
        return PyErr_NoMemory();
    memset(m->defaults, 0, size);
    m->defaults_pyobjects = pyobjects;
    return m->defaults;
}
static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *func, PyObject *tuple) {
    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
    m->defaults_tuple = tuple;
    Py_INCREF(tuple);
}
static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *func, PyObject *dict) {
    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
    m->defaults_kwdict = dict;
    Py_INCREF(dict);
}
static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *func, PyObject *dict) {
    __pyx_CyFunctionObject *m = (__pyx_CyFunctionObject *) func;
    m->func_annotations = dict;
    Py_INCREF(dict);
}

/* FusedFunction */
        static PyObject *
__pyx_FusedFunction_New(PyTypeObject *type, PyMethodDef *ml, int flags,
                        PyObject *qualname, PyObject *self,
                        PyObject *module, PyObject *globals,
                        PyObject *code)
{
    __pyx_FusedFunctionObject *fusedfunc =
        (__pyx_FusedFunctionObject *) __Pyx_CyFunction_New(type, ml, flags, qualname,
                                                           self, module, globals, code);
    if (!fusedfunc)
        return NULL;
    fusedfunc->__signatures__ = NULL;
    fusedfunc->type = NULL;
    fusedfunc->self = NULL;
    return (PyObject *) fusedfunc;
}
static void
__pyx_FusedFunction_dealloc(__pyx_FusedFunctionObject *self)
{
    PyObject_GC_UnTrack(self);
    Py_CLEAR(self->self);
    Py_CLEAR(self->type);
    Py_CLEAR(self->__signatures__);
    __Pyx__CyFunction_dealloc((__pyx_CyFunctionObject *) self);
}
static int
__pyx_FusedFunction_traverse(__pyx_FusedFunctionObject *self,
                             visitproc visit,
                             void *arg)
{
    Py_VISIT(self->self);
    Py_VISIT(self->type);
    Py_VISIT(self->__signatures__);
    return __Pyx_CyFunction_traverse((__pyx_CyFunctionObject *) self, visit, arg);
}
static int
__pyx_FusedFunction_clear(__pyx_FusedFunctionObject *self)
{
    Py_CLEAR(self->self);
    Py_CLEAR(self->type);
    Py_CLEAR(self->__signatures__);
    return __Pyx_CyFunction_clear((__pyx_CyFunctionObject *) self);
}
static PyObject *
__pyx_FusedFunction_descr_get(PyObject *self, PyObject *obj, PyObject *type)
{
    __pyx_FusedFunctionObject *func, *meth;
    func = (__pyx_FusedFunctionObject *) self;
    if (func->self || func->func.flags & __Pyx_CYFUNCTION_STATICMETHOD) {
        Py_INCREF(self);
        return self;
    }
    if (obj == Py_None)
        obj = NULL;
    meth = (__pyx_FusedFunctionObject *) __pyx_FusedFunction_NewEx(
                    ((PyCFunctionObject *) func)->m_ml,
                    ((__pyx_CyFunctionObject *) func)->flags,
                    ((__pyx_CyFunctionObject *) func)->func_qualname,
                    ((__pyx_CyFunctionObject *) func)->func_closure,
                    ((PyCFunctionObject *) func)->m_module,
                    ((__pyx_CyFunctionObject *) func)->func_globals,
                    ((__pyx_CyFunctionObject *) func)->func_code);
    if (!meth)
        return NULL;
    Py_XINCREF(func->func.func_classobj);
    meth->func.func_classobj = func->func.func_classobj;
    Py_XINCREF(func->__signatures__);
    meth->__signatures__ = func->__signatures__;
    Py_XINCREF(type);
    meth->type = type;
    Py_XINCREF(f
Download .txt
gitextract_n9_1d35r/

├── .cargo/
│   └── config.toml
├── .github/
│   ├── dependabot.yml
│   ├── release-drafter.yml
│   └── workflows/
│       ├── build.yml
│       ├── release-drafter.yml
│       └── update_python_test.yml
├── .gitignore
├── .pre-commit-config.yaml
├── CHANGELOG.md
├── Cargo.toml
├── LICENSE
├── README.md
├── SECURITY.md
├── build.rs
├── ci/
│   ├── Vagrantfile
│   ├── publish_freebsd.sh
│   ├── test_freebsd.sh
│   ├── testdata/
│   │   ├── cython_test.c
│   │   └── cython_test.pyx
│   └── update_python_test_versions.py
├── examples/
│   └── dump_traces.rs
├── generate_bindings.py
├── pyproject.toml
├── setup.cfg
├── src/
│   ├── binary_parser.rs
│   ├── chrometrace.rs
│   ├── config.rs
│   ├── console_viewer.rs
│   ├── coredump.rs
│   ├── cython.rs
│   ├── dump.rs
│   ├── flamegraph.rs
│   ├── lib.rs
│   ├── main.rs
│   ├── native_stack_trace.rs
│   ├── python_bindings/
│   │   ├── mod.rs
│   │   ├── v2_7_15.rs
│   │   ├── v3_10_0.rs
│   │   ├── v3_11_0.rs
│   │   ├── v3_12_0.rs
│   │   ├── v3_13_0.rs
│   │   ├── v3_3_7.rs
│   │   ├── v3_4_8.rs
│   │   ├── v3_5_5.rs
│   │   ├── v3_6_6.rs
│   │   ├── v3_7_0.rs
│   │   ├── v3_8_0.rs
│   │   └── v3_9_5.rs
│   ├── python_data_access.rs
│   ├── python_interpreters.rs
│   ├── python_process_info.rs
│   ├── python_spy.rs
│   ├── python_threading.rs
│   ├── sampler.rs
│   ├── speedscope.rs
│   ├── stack_trace.rs
│   ├── timer.rs
│   ├── utils.rs
│   └── version.rs
└── tests/
    ├── integration_test.py
    ├── integration_test.rs
    └── scripts/
        ├── busyloop.py
        ├── cyrillic.py
        ├── delayed_launch.sh
        ├── local_vars.py
        ├── longsleep.py
        ├── negative_linenumber_offsets.py
        ├── recursive.py
        ├── subprocesses.py
        ├── subprocesses_zombie_child.py
        ├── thread_names.py
        ├── thread_reuse.py
        └── unicode💩.py
Download .txt
Showing preview only (548K chars total). Download the full file or copy to clipboard to get everything.
SYMBOL INDEX (6646 symbols across 51 files)

FILE: build.rs
  function main (line 3) | fn main() {

FILE: ci/testdata/cython_test.c
  type PyObject (line 315) | typedef PyObject *(*__Pyx_PyCFunctionFast) (PyObject *self, PyObject *co...
  type PyObject (line 316) | typedef PyObject *(*__Pyx_PyCFunctionFastWithKeywords) (PyObject *self, ...
  type Py_tss_t (line 352) | typedef int Py_tss_t;
  function CYTHON_INLINE (line 353) | static CYTHON_INLINE int PyThread_tss_create(Py_tss_t *key) {
  function CYTHON_INLINE (line 357) | static CYTHON_INLINE Py_tss_t * PyThread_tss_alloc(void) {
  function CYTHON_INLINE (line 362) | static CYTHON_INLINE void PyThread_tss_free(Py_tss_t *key) {
  function CYTHON_INLINE (line 365) | static CYTHON_INLINE int PyThread_tss_is_created(Py_tss_t *key) {
  function CYTHON_INLINE (line 368) | static CYTHON_INLINE void PyThread_tss_delete(Py_tss_t *key) {
  function CYTHON_INLINE (line 372) | static CYTHON_INLINE int PyThread_tss_set(Py_tss_t *key, void *value) {
  function CYTHON_INLINE (line 375) | static CYTHON_INLINE void * PyThread_tss_get(Py_tss_t *key) {
  type Py_hash_t (line 499) | typedef long Py_hash_t;
  type __Pyx_PyAsyncMethodsStruct (line 522) | typedef struct {
  function CYTHON_INLINE (line 536) | static CYTHON_INLINE float __PYX_NAN() {
  type __Pyx_StringTabEntry (line 573) | typedef struct {PyObject **p; const char *s; const Py_ssize_t n; const c...
  function CYTHON_INLINE (line 639) | static CYTHON_INLINE size_t __Pyx_Py_UNICODE_strlen(const Py_UNICODE *u) {
  function __Pyx_init_sys_getdefaultencoding_params (line 670) | static int __Pyx_init_sys_getdefaultencoding_params(void) {
  function __Pyx_init_sys_getdefaultencoding_params (line 720) | static int __Pyx_init_sys_getdefaultencoding_params(void) {
  function CYTHON_INLINE (line 752) | static CYTHON_INLINE void __Pyx_pretend_to_initialize(void* ptr) { (void...
  type __Pyx_RefNannyAPIStruct (line 779) | typedef struct {
  function CYTHON_INLINE (line 882) | static CYTHON_INLINE int __Pyx_PyDict_ContainsTF(PyObject* item, PyObjec...
  function CYTHON_INLINE (line 1028) | static CYTHON_INLINE int __Pyx_PyList_Append(PyObject* list, PyObject* x) {
  type __pyx_CyFunctionObject (line 1059) | typedef struct {
  type __pyx_FusedFunctionObject (line 1100) | typedef struct {
  type __Pyx_CodeObjectCacheEntry (line 1126) | typedef struct {
  type __Pyx_CodeObjectCache (line 1130) | struct __Pyx_CodeObjectCache {
  type __Pyx_CodeObjectCache (line 1135) | struct __Pyx_CodeObjectCache
  function PyObject (line 1272) | static PyObject *__pyx_pw_11cython_test_1sqrt(PyObject *__pyx_self, PyOb...
  function PyObject (line 1353) | static PyObject *__pyx_pf_11cython_test_sqrt(CYTHON_UNUSED PyObject *__p...
  function PyObject (line 1620) | static PyObject *__pyx_fuse_0__pyx_f_11cython_test_sqrt(float __pyx_v_va...
  function PyObject (line 1699) | static PyObject *__pyx_pw_11cython_test_3__pyx_fuse_0sqrt(PyObject *__py...
  function PyObject (line 1720) | static PyObject *__pyx_pf_11cython_test_2__pyx_fuse_0sqrt(CYTHON_UNUSED ...
  function PyObject (line 1745) | static PyObject *__pyx_fuse_1__pyx_f_11cython_test_sqrt(double __pyx_v_v...
  function PyObject (line 1824) | static PyObject *__pyx_pw_11cython_test_5__pyx_fuse_1sqrt(PyObject *__py...
  function PyObject (line 1845) | static PyObject *__pyx_pf_11cython_test_4__pyx_fuse_1sqrt(CYTHON_UNUSED ...
  type PyModuleDef (line 1883) | struct PyModuleDef
  function __Pyx_InitCachedBuiltins (line 1935) | static int __Pyx_InitCachedBuiltins(void) {
  function __Pyx_InitCachedConstants (line 1943) | static int __Pyx_InitCachedConstants(void) {
  function __Pyx_InitGlobals (line 1977) | static int __Pyx_InitGlobals(void) {
  function __Pyx_modinit_global_init_code (line 1993) | static int __Pyx_modinit_global_init_code(void) {
  function __Pyx_modinit_variable_export_code (line 2001) | static int __Pyx_modinit_variable_export_code(void) {
  function __Pyx_modinit_function_export_code (line 2009) | static int __Pyx_modinit_function_export_code(void) {
  function __Pyx_modinit_type_init_code (line 2017) | static int __Pyx_modinit_type_init_code(void) {
  function __Pyx_modinit_type_import_code (line 2025) | static int __Pyx_modinit_type_import_code(void) {
  function __Pyx_modinit_variable_import_code (line 2033) | static int __Pyx_modinit_variable_import_code(void) {
  function __Pyx_modinit_function_import_code (line 2041) | static int __Pyx_modinit_function_import_code(void) {
  function __Pyx_PyMODINIT_FUNC (line 2079) | __Pyx_PyMODINIT_FUNC PyInit_cython_test(void)
  function __Pyx_copy_spec_to_module (line 2084) | static int __Pyx_copy_spec_to_module(PyObject *spec, PyObject *moddict, ...
  function PyObject (line 2097) | static PyObject* __pyx_pymod_create(PyObject *spec, CYTHON_UNUSED PyModu...
  function __Pyx_RefNannyAPIStruct (line 2290) | static __Pyx_RefNannyAPIStruct *__Pyx_RefNannyImportAPI(const char *modn...
  function CYTHON_INLINE (line 2307) | static CYTHON_INLINE PyObject* __Pyx_PyObject_GetAttrStr(PyObject* obj, ...
  function PyObject (line 2320) | static PyObject *__Pyx_GetBuiltinName(PyObject *name) {
  function __Pyx_RaiseArgtupleInvalid (line 2334) | static void __Pyx_RaiseArgtupleInvalid(
  function __Pyx_RaiseDoubleKeywordsError (line 2360) | static void __Pyx_RaiseDoubleKeywordsError(
  function __Pyx_ParseOptionalKeywords (line 2374) | static int __Pyx_ParseOptionalKeywords(
  function PyObject (line 2476) | static PyObject *__Pyx_GetItemInt_Generic(PyObject *o, PyObject* j) {
  function CYTHON_INLINE (line 2483) | static CYTHON_INLINE PyObject *__Pyx_GetItemInt_List_Fast(PyObject *o, P...
  function CYTHON_INLINE (line 2501) | static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Tuple_Fast(PyObject *o, ...
  function CYTHON_INLINE (line 2519) | static CYTHON_INLINE PyObject *__Pyx_GetItemInt_Fast(PyObject *o, Py_ssi...
  function PyObject (line 2564) | static PyObject *__Pyx_PyDict_GetItem(PyObject *d, PyObject* key) {
  function CYTHON_INLINE (line 2583) | static CYTHON_INLINE PyObject * __Pyx_PyCFunction_FastCall(PyObject *fun...
  function PyObject (line 2607) | static PyObject* __Pyx_PyFunction_FastCallNoKw(PyCodeObject *co, PyObjec...
  function CYTHON_INLINE (line 2726) | static CYTHON_INLINE PyObject* __Pyx_PyObject_Call(PyObject *func, PyObj...
  function CYTHON_INLINE (line 2746) | static CYTHON_INLINE PyObject* __Pyx_PyObject_CallMethO(PyObject *func, ...
  function PyObject (line 2766) | static PyObject* __Pyx__PyObject_CallOneArg(PyObject *func, PyObject *ar...
  function CYTHON_INLINE (line 2776) | static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func,...
  function CYTHON_INLINE (line 2794) | static CYTHON_INLINE PyObject* __Pyx_PyObject_CallOneArg(PyObject *func,...
  function CYTHON_INLINE (line 2806) | static CYTHON_INLINE void __Pyx_ErrRestoreInState(PyThreadState *tstate,...
  function CYTHON_INLINE (line 2818) | static CYTHON_INLINE void __Pyx_ErrFetchInState(PyThreadState *tstate, P...
  function __Pyx_Raise (line 2830) | static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb,
  function __Pyx_Raise (line 2881) | static void __Pyx_Raise(PyObject *type, PyObject *value, PyObject *tb, P...
  function __Pyx_SetItemInt_Generic (line 2988) | static int __Pyx_SetItemInt_Generic(PyObject *o, PyObject *j, PyObject *...
  function CYTHON_INLINE (line 3036) | static CYTHON_INLINE int __Pyx_IterFinish(void) {
  function PyObject (line 3092) | static PyObject* __Pyx_PyObject_CallMethod0(PyObject* obj, PyObject* met...
  function CYTHON_INLINE (line 3114) | static CYTHON_INLINE void __Pyx_RaiseNeedMoreValuesError(Py_ssize_t inde...
  function CYTHON_INLINE (line 3121) | static CYTHON_INLINE void __Pyx_RaiseTooManyValuesError(Py_ssize_t expec...
  function __Pyx_IternextUnpackEndCheck (line 3127) | static int __Pyx_IternextUnpackEndCheck(PyObject *retval, Py_ssize_t exp...
  function CYTHON_INLINE (line 3139) | static CYTHON_INLINE void __Pyx_RaiseNoneNotIterableError(void) {
  function __Pyx_UnpackTupleError (line 3144) | static void __Pyx_UnpackTupleError(PyObject *t, Py_ssize_t index) {
  function CYTHON_INLINE (line 3155) | static CYTHON_INLINE int __Pyx_unpack_tuple2_exact(
  function __Pyx_unpack_tuple2_generic (line 3179) | static int __Pyx_unpack_tuple2_generic(PyObject* tuple, PyObject** pvalu...
  function CYTHON_INLINE (line 3207) | static CYTHON_INLINE PyObject* __Pyx_dict_iterator(PyObject* iterable, i...
  function CYTHON_INLINE (line 3251) | static CYTHON_INLINE int __Pyx_dict_iter_next(
  function PyTypeObject (line 3320) | static PyTypeObject* __Pyx_FetchCommonType(PyTypeObject* type) {
  function PyObject (line 3360) | static PyObject *
  function __Pyx_CyFunction_set_doc (line 3380) | static int
  function PyObject (line 3392) | static PyObject *
  function PyObject (line 3426) | static PyObject *
  function PyObject (line 3451) | static PyObject *
  function PyObject (line 3461) | static PyObject *
  function __Pyx_CyFunction_set_dict (line 3472) | static int
  function PyObject (line 3492) | static PyObject *
  function PyObject (line 3498) | static PyObject *
  function PyObject (line 3504) | static PyObject *
  function __Pyx_CyFunction_init_defaults (line 3511) | static int
  function __Pyx_CyFunction_set_defaults (line 3533) | static int
  function PyObject (line 3549) | static PyObject *
  function __Pyx_CyFunction_set_kwdefaults (line 3563) | static int
  function PyObject (line 3579) | static PyObject *
  function __Pyx_CyFunction_set_annotations (line 3593) | static int
  function PyObject (line 3609) | static PyObject *
  function PyObject (line 3645) | static PyObject *
  function PyObject (line 3663) | static PyObject *__Pyx_CyFunction_New(PyTypeObject *type, PyMethodDef *m...
  function __Pyx_CyFunction_clear (line 3695) | static int
  function __Pyx__CyFunction_dealloc (line 3720) | static void __Pyx__CyFunction_dealloc(__pyx_CyFunctionObject *m)
  function __Pyx_CyFunction_dealloc (line 3727) | static void __Pyx_CyFunction_dealloc(__pyx_CyFunctionObject *m)
  function __Pyx_CyFunction_traverse (line 3732) | static int __Pyx_CyFunction_traverse(__pyx_CyFunctionObject *m, visitpro...
  function PyObject (line 3753) | static PyObject *__Pyx_CyFunction_descr_get(PyObject *func, PyObject *ob...
  function PyObject (line 3769) | static PyObject*
  function PyObject (line 3780) | static PyObject * __Pyx_CyFunction_CallMethod(PyObject *func, PyObject *...
  function CYTHON_INLINE (line 3834) | static CYTHON_INLINE PyObject *__Pyx_CyFunction_Call(PyObject *func, PyO...
  function PyObject (line 3837) | static PyObject *__Pyx_CyFunction_CallAsMethod(PyObject *func, PyObject ...
  function __pyx_CyFunction_init (line 3920) | static int __pyx_CyFunction_init(void) {
  function CYTHON_INLINE (line 3927) | static CYTHON_INLINE void *__Pyx_CyFunction_InitDefaults(PyObject *func,...
  function CYTHON_INLINE (line 3936) | static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsTuple(PyObject *fu...
  function CYTHON_INLINE (line 3941) | static CYTHON_INLINE void __Pyx_CyFunction_SetDefaultsKwDict(PyObject *f...
  function CYTHON_INLINE (line 3946) | static CYTHON_INLINE void __Pyx_CyFunction_SetAnnotationsDict(PyObject *...
  function PyObject (line 3953) | static PyObject *
  function __pyx_FusedFunction_dealloc (line 3969) | static void
  function __pyx_FusedFunction_traverse (line 3978) | static int
  function __pyx_FusedFunction_clear (line 3988) | static int
  function PyObject (line 3996) | static PyObject *
  function PyObject (line 4031) | static PyObject *
  function PyObject (line 4039) | static PyObject *
  function PyObject (line 4101) | static PyObject *
  function PyObject (line 4113) | static PyObject *
  function __pyx_FusedFunction_init (line 4274) | static int __pyx_FusedFunction_init(void) {
  function __Pyx_CLineForTraceback (line 4284) | static int __Pyx_CLineForTraceback(CYTHON_UNUSED PyThreadState *tstate, ...
  function __pyx_bisect_code_objects (line 4323) | static int __pyx_bisect_code_objects(__Pyx_CodeObjectCacheEntry* entries...
  function PyCodeObject (line 4344) | static PyCodeObject *__pyx_find_code_object(int code_line) {
  function __pyx_insert_code_object (line 4358) | static void __pyx_insert_code_object(int code_line, PyCodeObject* code_o...
  function PyCodeObject (line 4406) | static PyCodeObject* __Pyx_CreateCodeObjectForTraceback(
  function __Pyx_AddTraceback (line 4458) | static void __Pyx_AddTraceback(const char *funcname, int c_line,
  function CYTHON_INLINE (line 4488) | static CYTHON_INLINE PyObject* __Pyx_PyInt_From_long(long value) {
  function PyObject (line 4541) | static PyObject *__Pyx_Import(PyObject *name, PyObject *from_list, int l...
  function PyObject (line 4795) | static PyObject* __Pyx__ImportNumPyArray(void) {
  function CYTHON_INLINE (line 4812) | static CYTHON_INLINE PyObject* __Pyx_ImportNumPyArrayTypeIfAvailable(voi...
  function __Pyx_InBases (line 5011) | static int __Pyx_InBases(PyTypeObject *a, PyTypeObject *b) {
  function CYTHON_INLINE (line 5019) | static CYTHON_INLINE int __Pyx_IsSubtype(PyTypeObject *a, PyTypeObject *...
  function __Pyx_inner_PyErr_GivenExceptionMatches2 (line 5035) | static int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObject *err, PyObj...
  function CYTHON_INLINE (line 5057) | static CYTHON_INLINE int __Pyx_inner_PyErr_GivenExceptionMatches2(PyObje...
  function __Pyx_PyErr_GivenExceptionMatchesTuple (line 5065) | static int __Pyx_PyErr_GivenExceptionMatchesTuple(PyObject *exc_type, Py...
  function CYTHON_INLINE (line 5086) | static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches(PyObject *err...
  function CYTHON_INLINE (line 5098) | static CYTHON_INLINE int __Pyx_PyErr_GivenExceptionMatches2(PyObject *er...
  function __Pyx_check_binary_version (line 5110) | static int __Pyx_check_binary_version(void) {
  function __Pyx_InitStrings (line 5126) | static int __Pyx_InitStrings(__Pyx_StringTabEntry *t) {
  function CYTHON_INLINE (line 5158) | static CYTHON_INLINE PyObject* __Pyx_PyUnicode_FromString(const char* c_...
  function CYTHON_INLINE (line 5161) | static CYTHON_INLINE const char* __Pyx_PyObject_AsString(PyObject* o) {
  function CYTHON_INLINE (line 5188) | static CYTHON_INLINE const char* __Pyx_PyUnicode_AsStringAndSize(PyObjec...
  function CYTHON_INLINE (line 5230) | static CYTHON_INLINE int __Pyx_PyObject_IsTrue(PyObject* x) {
  function PyObject (line 5235) | static PyObject* __Pyx_PyNumber_IntOrLongWrongResultType(PyObject* resul...
  function CYTHON_INLINE (line 5304) | static CYTHON_INLINE Py_ssize_t __Pyx_PyIndex_AsSsize_t(PyObject* b) {
  function CYTHON_INLINE (line 5366) | static CYTHON_INLINE PyObject * __Pyx_PyBool_FromLong(long b) {
  function CYTHON_INLINE (line 5369) | static CYTHON_INLINE PyObject * __Pyx_PyInt_FromSize_t(size_t ival) {

FILE: ci/update_python_test_versions.py
  function parse_version (line 11) | def parse_version(v):
  function get_github_python_versions (line 15) | def get_github_python_versions():
  function update_python_test_versions (line 64) | def update_python_test_versions():

FILE: examples/dump_traces.rs
  function print_python_stacks (line 6) | fn print_python_stacks(pid: remoteprocess::Pid) -> Result<(), anyhow::Er...
  function main (line 24) | fn main() {

FILE: generate_bindings.py
  function build_python (line 15) | def build_python(cpython_path, version):
  function calculate_pyruntime_offsets (line 41) | def calculate_pyruntime_offsets(cpython_path, version, configure=False):
  function extract_bindings (line 103) | def extract_bindings(cpython_path, version, configure=False):

FILE: src/binary_parser.rs
  type BinaryInfo (line 11) | pub struct BinaryInfo {
    method contains (line 25) | pub fn contains(&self, addr: u64) -> bool {
  function parse_binary (line 31) | pub fn parse_binary(filename: &Path, addr: u64, size: u64) -> Result<Bin...

FILE: src/chrometrace.rs
  type Args (line 13) | struct Args {
  type Event (line 19) | struct Event {
  type Chrometrace (line 29) | pub struct Chrometrace {
    method new (line 37) | pub fn new(show_linenumbers: bool) -> Chrometrace {
    method should_merge_frames (line 48) | fn should_merge_frames(&self, a: &Frame, b: &Frame) -> bool {
    method event (line 52) | fn event(&self, trace: &StackTrace, frame: &Frame, phase: &str, ts: u6...
    method increment (line 71) | pub fn increment(&mut self, trace: &StackTrace) -> std::io::Result<()> {
    method write (line 107) | pub fn write(&self, w: &mut dyn Write) -> Result<(), Error> {

FILE: src/config.rs
  type Config (line 9) | pub struct Config {
    method from_commandline (line 148) | pub fn from_commandline() -> Config {
    method from_args (line 153) | pub fn from_args(args: &[String]) -> clap::Result<Config> {
  type FileFormat (line 66) | pub enum FileFormat {
    method possible_values (line 74) | pub fn possible_values() -> impl Iterator<Item = PossibleValue<'static...
    type Err (line 82) | type Err = String;
    method from_str (line 84) | fn from_str(s: &str) -> Result<Self, Self::Err> {
  type LockingStrategy (line 95) | pub enum LockingStrategy {
  type RecordDuration (line 103) | pub enum RecordDuration {
  type LineNo (line 109) | pub enum LineNo {
  method default (line 118) | fn default() -> Config {
  function get_config (line 497) | fn get_config(cmd: &str) -> clap::Result<Config> {
  function test_parse_record_args (line 505) | fn test_parse_record_args() {
  function test_parse_dump_args (line 551) | fn test_parse_dump_args() {
  function test_parse_top_args (line 569) | fn test_parse_top_args() {
  function test_parse_args (line 581) | fn test_parse_args() {

FILE: src/console_viewer.rs
  type ConsoleViewer (line 15) | pub struct ConsoleViewer {
    method new (line 29) | pub fn new(
    method increment (line 83) | pub fn increment(&mut self, traces: &[StackTrace]) -> Result<(), Error> {
    method display (line 135) | pub fn display(&self) -> std::io::Result<()> {
    method increment_error (line 330) | pub fn increment_error(&mut self, err: &Error) -> Result<(), Error> {
    method increment_late_sample (line 337) | pub fn increment_late_sample(&mut self, delay: std::time::Duration) {
    method should_refresh (line 342) | pub fn should_refresh(&self) -> bool {
    method increment_common (line 354) | fn increment_common(&mut self) -> Result<(), Error> {
    method maybe_reset (line 366) | fn maybe_reset(&mut self) {
  method drop (line 376) | fn drop(&mut self) {
  type FunctionStatistics (line 382) | struct FunctionStatistics {
  function update_function_statistics (line 389) | fn update_function_statistics<K>(
  type Options (line 420) | struct Options {
    method new (line 446) | fn new(show_linenumbers: bool) -> Options {
  type Stats (line 429) | struct Stats {
    method new (line 459) | fn new() -> Stats {
    method reset_current (line 477) | pub fn reset_current(&mut self) {
  function display_time (line 496) | fn display_time(val: f64) -> String {
  type ConsoleConfig (line 525) | pub struct ConsoleConfig {
    method new (line 531) | pub fn new() -> io::Result<ConsoleConfig> {
    method reset_cursor (line 550) | pub fn reset_cursor(&self) -> io::Result<()> {
    method new (line 586) | pub fn new() -> io::Result<ConsoleConfig> {
    method reset_cursor (line 633) | pub fn reset_cursor(&self) -> io::Result<()> {
    method reset_styles (line 646) | pub fn reset_styles(&self) -> io::Result<()> {
  method drop (line 558) | fn drop(&mut self) {
  type ConsoleConfig (line 579) | pub struct ConsoleConfig {
    method new (line 531) | pub fn new() -> io::Result<ConsoleConfig> {
    method reset_cursor (line 550) | pub fn reset_cursor(&self) -> io::Result<()> {
    method new (line 586) | pub fn new() -> io::Result<ConsoleConfig> {
    method reset_cursor (line 633) | pub fn reset_cursor(&self) -> io::Result<()> {
    method reset_styles (line 646) | pub fn reset_styles(&self) -> io::Result<()> {
  method drop (line 674) | fn drop(&mut self) {

FILE: src/coredump.rs
  type CoreMapRange (line 31) | pub struct CoreMapRange {
    method size (line 39) | pub fn size(&self) -> usize {
    method start (line 42) | pub fn start(&self) -> usize {
    method filename (line 45) | pub fn filename(&self) -> Option<&Path> {
    method is_exec (line 48) | pub fn is_exec(&self) -> bool {
    method is_write (line 51) | pub fn is_write(&self) -> bool {
    method is_read (line 54) | pub fn is_read(&self) -> bool {
  method contains_addr (line 60) | fn contains_addr(&self, addr: usize) -> bool {
  type CoreDump (line 66) | pub struct CoreDump {
    method new (line 75) | pub fn new<P: AsRef<Path>>(filename: P) -> Result<CoreDump, Error> {
  method read (line 158) | fn read(&self, addr: usize, buf: &mut [u8]) -> Result<(), remoteprocess:...
  type PythonCoreDump (line 179) | pub struct PythonCoreDump {
    method new (line 187) | pub fn new<P: AsRef<Path>>(filename: P) -> Result<PythonCoreDump, Erro...
    method get_stack (line 261) | pub fn get_stack(&self, config: &Config) -> Result<Vec<StackTrace>, Er...
    method _get_stack (line 328) | fn _get_stack<I: InterpreterState>(&self, config: &Config) -> Result<V...
    method print_traces (line 365) | pub fn print_traces(&self, traces: &Vec<StackTrace>, config: &Config) ...
  type elf_siginfo (line 398) | pub struct elf_siginfo {
  type timeval (line 406) | pub struct timeval {
  type elf_prstatus (line 413) | pub struct elf_prstatus {
  type elf_prpsinfo (line 432) | pub struct elf_prpsinfo {
  function test_coredump (line 456) | fn test_coredump() {

FILE: src/cython.rs
  type SourceMaps (line 10) | pub struct SourceMaps {
    method new (line 15) | pub fn new() -> SourceMaps {
    method translate (line 20) | pub fn translate(&mut self, frame: &mut Frame) {
    method translate_frame (line 29) | fn translate_frame(&mut self, frame: &mut Frame) -> bool {
    method load_map (line 47) | fn load_map(&mut self, frame: &Frame) {
  type SourceMap (line 66) | struct SourceMap {
    method new (line 71) | pub fn new(filename: &str, module: &Option<String>) -> Result<SourceMa...
    method from_contents (line 76) | pub fn from_contents(
    method lookup (line 115) | pub fn lookup(&self, lineno: u32) -> Option<&(String, u32)> {
  function ignore_frame (line 125) | pub fn ignore_frame(name: &str) -> bool {
  function demangle (line 136) | pub fn demangle(name: &str) -> &str {
  function resolve_cython_file (line 191) | fn resolve_cython_file(
  function test_demangle (line 217) | fn test_demangle() {
  function test_source_map (line 248) | fn test_source_map() {

FILE: src/dump.rs
  function print_traces (line 10) | pub fn print_traces(pid: Pid, config: &Config, parent: Option<Pid>) -> R...
  function print_trace (line 64) | pub fn print_trace(trace: &StackTrace, include_activity: bool) {

FILE: src/flamegraph.rs
  type Flamegraph (line 37) | pub struct Flamegraph {
    method new (line 43) | pub fn new(show_linenumbers: bool) -> Flamegraph {
    method increment (line 50) | pub fn increment(&mut self, trace: &StackTrace) -> std::io::Result<()> {
    method get_lines (line 76) | fn get_lines(&self) -> Vec<String> {
    method write (line 83) | pub fn write(&self, w: &mut dyn Write) -> Result<(), Error> {
    method write_raw (line 95) | pub fn write_raw(&self, w: &mut dyn Write) -> Result<(), Error> {

FILE: src/main.rs
  function permission_denied (line 46) | fn permission_denied(err: &Error) -> bool {
  function sample_console (line 60) | fn sample_console(pid: remoteprocess::Pid, config: &Config) -> Result<()...
  type Recorder (line 89) | pub trait Recorder {
    method increment (line 90) | fn increment(&mut self, trace: &StackTrace) -> Result<(), Error>;
    method write (line 91) | fn write(&self, w: &mut dyn Write) -> Result<(), Error>;
    method increment (line 95) | fn increment(&mut self, trace: &StackTrace) -> Result<(), Error> {
    method write (line 98) | fn write(&self, w: &mut dyn Write) -> Result<(), Error> {
    method increment (line 104) | fn increment(&mut self, trace: &StackTrace) -> Result<(), Error> {
    method write (line 107) | fn write(&self, w: &mut dyn Write) -> Result<(), Error> {
    method increment (line 113) | fn increment(&mut self, trace: &StackTrace) -> Result<(), Error> {
    method write (line 116) | fn write(&self, w: &mut dyn Write) -> Result<(), Error> {
    method increment (line 124) | fn increment(&mut self, trace: &StackTrace) -> Result<(), Error> {
    method write (line 128) | fn write(&self, w: &mut dyn Write) -> Result<(), Error> {
  type RawFlamegraph (line 121) | pub struct RawFlamegraph(flamegraph::Flamegraph);
  function record_samples (line 133) | fn record_samples(pid: remoteprocess::Pid, config: &Config) -> Result<()...
  function run_spy_command (line 369) | fn run_spy_command(pid: remoteprocess::Pid, config: &config::Config) -> ...
  function pyspy_main (line 388) | fn pyspy_main() -> Result<(), Error> {
  function main (line 479) | fn main() {

FILE: src/native_stack_trace.rs
  type NativeStack (line 15) | pub struct NativeStack {
    method new (line 29) | pub fn new(
    method merge_native_thread (line 52) | pub fn merge_native_thread(
    method merge_native_stack (line 68) | pub fn merge_native_stack(
    method get_merge_strategy (line 203) | fn get_merge_strategy(
    method translate_native_frame (line 259) | fn translate_native_frame(&self, frame: &remoteprocess::StackFrame) ->...
    method get_thread (line 314) | fn get_thread(&mut self, thread: &remoteprocess::Thread) -> Result<Vec...
  type MergeType (line 324) | enum MergeType {
  function ignore_frame (line 333) | fn ignore_frame(function: &str, module: &str) -> bool {
  function ignore_frame (line 350) | fn ignore_frame(function: &str, module: &str) -> bool {
  function ignore_frame (line 367) | fn ignore_frame(function: &str, module: &str) -> bool {

FILE: src/python_bindings/mod.rs
  function get_interp_head_offset (line 26) | pub fn get_interp_head_offset(version: &Version) -> usize {
  function get_interp_head_offset (line 48) | pub fn get_interp_head_offset(version: &Version) -> usize {
  function get_interp_head_offset (line 58) | pub fn get_interp_head_offset(version: &Version) -> usize {
  function get_tstate_current_offset (line 87) | pub fn get_tstate_current_offset(version: &Version) -> Option<usize> {
  function get_tstate_current_offset (line 127) | pub fn get_tstate_current_offset(version: &Version) -> Option<usize> {
  function get_tstate_current_offset (line 156) | pub fn get_tstate_current_offset(version: &Version) -> Option<usize> {
  function get_tstate_current_offset (line 174) | pub fn get_tstate_current_offset(version: &Version) -> Option<usize> {
  function get_tstate_current_offset (line 203) | pub fn get_tstate_current_offset(version: &Version) -> Option<usize> {
  function get_tstate_current_offset (line 253) | pub fn get_tstate_current_offset(version: &Version) -> Option<usize> {
  function get_tstate_current_offset (line 258) | pub fn get_tstate_current_offset(version: &Version) -> Option<usize> {
  function get_tstate_current_offset (line 295) | pub fn get_tstate_current_offset(version: &Version) -> Option<usize> {

FILE: src/python_bindings/v2_7_15.rs
  type __int64_t (line 14) | pub type __int64_t = ::std::os::raw::c_longlong;
  type __darwin_ssize_t (line 15) | pub type __darwin_ssize_t = ::std::os::raw::c_long;
  type __darwin_off_t (line 16) | pub type __darwin_off_t = __int64_t;
  type fpos_t (line 17) | pub type fpos_t = __darwin_off_t;
  type __sbuf (line 20) | pub struct __sbuf {
  method default (line 25) | fn default() -> Self {
  type __sFILEX (line 31) | pub struct __sFILEX {
  type __sFILE (line 36) | pub struct __sFILE {
  method default (line 79) | fn default() -> Self {
  type FILE (line 83) | pub type FILE = __sFILE;
  type Py_ssize_t (line 84) | pub type Py_ssize_t = isize;
  type _object (line 87) | pub struct _object {
  method default (line 92) | fn default() -> Self {
  type PyObject (line 96) | pub type PyObject = _object;
  type PyVarObject (line 99) | pub struct PyVarObject {
  method default (line 105) | fn default() -> Self {
  type unaryfunc (line 109) | pub type unaryfunc =
  type binaryfunc (line 111) | pub type binaryfunc = ::std::option::Option<
  type ternaryfunc (line 114) | pub type ternaryfunc = ::std::option::Option<
  type inquiry (line 121) | pub type inquiry =
  type lenfunc (line 123) | pub type lenfunc = ::std::option::Option<unsafe extern "C" fn(arg1: *mut...
  type coercion (line 124) | pub type coercion = ::std::option::Option<
  type ssizeargfunc (line 130) | pub type ssizeargfunc = ::std::option::Option<
  type ssizessizeargfunc (line 133) | pub type ssizessizeargfunc = ::std::option::Option<
  type ssizeobjargproc (line 136) | pub type ssizeobjargproc = ::std::option::Option<
  type ssizessizeobjargproc (line 143) | pub type ssizessizeobjargproc = ::std::option::Option<
  type objobjargproc (line 151) | pub type objobjargproc = ::std::option::Option<
  type readbufferproc (line 158) | pub type readbufferproc = ::std::option::Option<
  type writebufferproc (line 165) | pub type writebufferproc = ::std::option::Option<
  type segcountproc (line 172) | pub type segcountproc = ::std::option::Option<
  type charbufferproc (line 175) | pub type charbufferproc = ::std::option::Option<
  type bufferinfo (line 184) | pub struct bufferinfo {
  method default (line 199) | fn default() -> Self {
  type Py_buffer (line 203) | pub type Py_buffer = bufferinfo;
  type getbufferproc (line 204) | pub type getbufferproc = ::std::option::Option<
  type releasebufferproc (line 211) | pub type releasebufferproc =
  type objobjproc (line 213) | pub type objobjproc = ::std::option::Option<
  type visitproc (line 216) | pub type visitproc = ::std::option::Option<
  type traverseproc (line 222) | pub type traverseproc = ::std::option::Option<
  type PyNumberMethods (line 231) | pub struct PyNumberMethods {
  method default (line 273) | fn default() -> Self {
  type PySequenceMethods (line 279) | pub struct PySequenceMethods {
  method default (line 292) | fn default() -> Self {
  type PyMappingMethods (line 298) | pub struct PyMappingMethods {
  method default (line 304) | fn default() -> Self {
  type PyBufferProcs (line 310) | pub struct PyBufferProcs {
  method default (line 319) | fn default() -> Self {
  type freefunc (line 323) | pub type freefunc = ::std::option::Option<unsafe extern "C" fn(arg1: *mu...
  type destructor (line 324) | pub type destructor = ::std::option::Option<unsafe extern "C" fn(arg1: *...
  type printfunc (line 325) | pub type printfunc = ::std::option::Option<
  type getattrfunc (line 332) | pub type getattrfunc = ::std::option::Option<
  type getattrofunc (line 335) | pub type getattrofunc = ::std::option::Option<
  type setattrfunc (line 338) | pub type setattrfunc = ::std::option::Option<
  type setattrofunc (line 345) | pub type setattrofunc = ::std::option::Option<
  type cmpfunc (line 352) | pub type cmpfunc = ::std::option::Option<
  type reprfunc (line 355) | pub type reprfunc =
  type hashfunc (line 357) | pub type hashfunc =
  type richcmpfunc (line 359) | pub type richcmpfunc = ::std::option::Option<
  type getiterfunc (line 366) | pub type getiterfunc =
  type iternextfunc (line 368) | pub type iternextfunc =
  type descrgetfunc (line 370) | pub type descrgetfunc = ::std::option::Option<
  type descrsetfunc (line 377) | pub type descrsetfunc = ::std::option::Option<
  type initproc (line 384) | pub type initproc = ::std::option::Option<
  type newfunc (line 391) | pub type newfunc = ::std::option::Option<
  type allocfunc (line 398) | pub type allocfunc = ::std::option::Option<
  type _typeobject (line 403) | pub struct _typeobject {
  method default (line 455) | fn default() -> Self {
  type PyTypeObject (line 459) | pub type PyTypeObject = _typeobject;
  type PyIntObject (line 462) | pub struct PyIntObject {
  method default (line 468) | fn default() -> Self {
  type _longobject (line 474) | pub struct _longobject {
  type PyLongObject (line 477) | pub type PyLongObject = _longobject;
  type PyFloatObject (line 480) | pub struct PyFloatObject {
  method default (line 486) | fn default() -> Self {
  type PyStringObject (line 492) | pub struct PyStringObject {
  method default (line 501) | fn default() -> Self {
  type PyTupleObject (line 507) | pub struct PyTupleObject {
  method default (line 514) | fn default() -> Self {
  type PyListObject (line 520) | pub struct PyListObject {
  method default (line 528) | fn default() -> Self {
  type PyDictEntry (line 534) | pub struct PyDictEntry {
  method default (line 540) | fn default() -> Self {
  type PyDictObject (line 544) | pub type PyDictObject = _dictobject;
  type _dictobject (line 547) | pub struct _dictobject {
  method default (line 564) | fn default() -> Self {
  type PyCFunction (line 568) | pub type PyCFunction = ::std::option::Option<
  type PyMethodDef (line 573) | pub struct PyMethodDef {
  method default (line 580) | fn default() -> Self {
  type getter (line 584) | pub type getter = ::std::option::Option<
  type setter (line 587) | pub type setter = ::std::option::Option<
  type PyGetSetDef (line 596) | pub struct PyGetSetDef {
  method default (line 604) | fn default() -> Self {
  type _is (line 610) | pub struct _is {
  method default (line 623) | fn default() -> Self {
  type PyInterpreterState (line 627) | pub type PyInterpreterState = _is;
  type Py_tracefunc (line 628) | pub type Py_tracefunc = ::std::option::Option<
  type _ts (line 638) | pub struct _ts {
  method default (line 664) | fn default() -> Self {
  type PyThreadState (line 668) | pub type PyThreadState = _ts;
  type PyCodeObject (line 671) | pub struct PyCodeObject {
  method default (line 692) | fn default() -> Self {
  type PyTryBlock (line 698) | pub struct PyTryBlock {
  type _frame (line 705) | pub struct _frame {
  method default (line 728) | fn default() -> Self {
  type PyFrameObject (line 732) | pub type PyFrameObject = _frame;
  type PyMemberDef (line 735) | pub struct PyMemberDef {

FILE: src/python_bindings/v3_10_0.rs
  type __BindgenBitfieldUnit (line 16) | pub struct __BindgenBitfieldUnit<Storage, Align>
  function new (line 28) | pub fn new(storage: Storage) -> Self {
  function get_bit (line 32) | pub fn get_bit(&self, index: usize) -> bool {
  function set_bit (line 45) | pub fn set_bit(&mut self, index: usize, val: bool) {
  function get (line 62) | pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
  function set (line 80) | pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
  type __IncompleteArrayField (line 98) | pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; ...
  function new (line 101) | pub fn new() -> Self {
  function as_ptr (line 105) | pub unsafe fn as_ptr(&self) -> *const T {
  function as_mut_ptr (line 109) | pub unsafe fn as_mut_ptr(&mut self) -> *mut T {
  function as_slice (line 113) | pub unsafe fn as_slice(&self, len: usize) -> &[T] {
  function as_mut_slice (line 117) | pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
  function fmt (line 122) | fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
  function clone (line 128) | fn clone(&self) -> Self {
  type __uint8_t (line 132) | pub type __uint8_t = ::std::os::raw::c_uchar;
  type __uint16_t (line 133) | pub type __uint16_t = ::std::os::raw::c_ushort;
  type __uint32_t (line 134) | pub type __uint32_t = ::std::os::raw::c_uint;
  type __int64_t (line 135) | pub type __int64_t = ::std::os::raw::c_long;
  type __uint64_t (line 136) | pub type __uint64_t = ::std::os::raw::c_ulong;
  type __ssize_t (line 137) | pub type __ssize_t = ::std::os::raw::c_long;
  type wchar_t (line 138) | pub type wchar_t = ::std::os::raw::c_int;
  type __pthread_internal_list (line 141) | pub struct __pthread_internal_list {
  method default (line 146) | fn default() -> Self {
  type __pthread_list_t (line 150) | pub type __pthread_list_t = __pthread_internal_list;
  type __pthread_mutex_s (line 153) | pub struct __pthread_mutex_s {
  method default (line 164) | fn default() -> Self {
  type __pthread_cond_s (line 170) | pub struct __pthread_cond_s {
  type __pthread_cond_s__bindgen_ty_1__bindgen_ty_1 (line 188) | pub struct __pthread_cond_s__bindgen_ty_1__bindgen_ty_1 {
  method default (line 193) | fn default() -> Self {
  type __pthread_cond_s__bindgen_ty_2__bindgen_ty_1 (line 206) | pub struct __pthread_cond_s__bindgen_ty_2__bindgen_ty_1 {
  method default (line 211) | fn default() -> Self {
  method default (line 216) | fn default() -> Self {
  type pthread_key_t (line 220) | pub type pthread_key_t = ::std::os::raw::c_uint;
  method default (line 230) | fn default() -> Self {
  method default (line 243) | fn default() -> Self {
  type Py_ssize_t (line 247) | pub type Py_ssize_t = isize;
  type Py_hash_t (line 248) | pub type Py_hash_t = Py_ssize_t;
  type PyTypeObject (line 249) | pub type PyTypeObject = _typeobject;
  type _object (line 252) | pub struct _object {
  method default (line 257) | fn default() -> Self {
  type PyObject (line 261) | pub type PyObject = _object;
  type PyVarObject (line 264) | pub struct PyVarObject {
  method default (line 269) | fn default() -> Self {
  type unaryfunc (line 273) | pub type unaryfunc =
  type binaryfunc (line 275) | pub type binaryfunc = ::std::option::Option<
  type ternaryfunc (line 278) | pub type ternaryfunc = ::std::option::Option<
  type inquiry (line 285) | pub type inquiry =
  type lenfunc (line 287) | pub type lenfunc = ::std::option::Option<unsafe extern "C" fn(arg1: *mut...
  type ssizeargfunc (line 288) | pub type ssizeargfunc = ::std::option::Option<
  type ssizeobjargproc (line 291) | pub type ssizeobjargproc = ::std::option::Option<
  type objobjargproc (line 298) | pub type objobjargproc = ::std::option::Option<
  type objobjproc (line 305) | pub type objobjproc = ::std::option::Option<
  type visitproc (line 308) | pub type visitproc = ::std::option::Option<
  type traverseproc (line 314) | pub type traverseproc = ::std::option::Option<
  type freefunc (line 321) | pub type freefunc = ::std::option::Option<unsafe extern "C" fn(arg1: *mu...
  type destructor (line 322) | pub type destructor = ::std::option::Option<unsafe extern "C" fn(arg1: *...
  type getattrfunc (line 323) | pub type getattrfunc = ::std::option::Option<
  type getattrofunc (line 326) | pub type getattrofunc = ::std::option::Option<
  type setattrfunc (line 329) | pub type setattrfunc = ::std::option::Option<
  type setattrofunc (line 336) | pub type setattrofunc = ::std::option::Option<
  type reprfunc (line 343) | pub type reprfunc =
  type hashfunc (line 345) | pub type hashfunc = ::std::option::Option<unsafe extern "C" fn(arg1: *mu...
  type richcmpfunc (line 346) | pub type richcmpfunc = ::std::option::Option<
  type getiterfunc (line 353) | pub type getiterfunc =
  type iternextfunc (line 355) | pub type iternextfunc =
  type descrgetfunc (line 357) | pub type descrgetfunc = ::std::option::Option<
  type descrsetfunc (line 364) | pub type descrsetfunc = ::std::option::Option<
  type initproc (line 371) | pub type initproc = ::std::option::Option<
  type newfunc (line 378) | pub type newfunc = ::std::option::Option<
  type allocfunc (line 385) | pub type allocfunc = ::std::option::Option<
  constant PySendResult_PYGEN_RETURN (line 388) | pub const PySendResult_PYGEN_RETURN: PySendResult = 0;
  constant PySendResult_PYGEN_ERROR (line 389) | pub const PySendResult_PYGEN_ERROR: PySendResult = -1;
  constant PySendResult_PYGEN_NEXT (line 390) | pub const PySendResult_PYGEN_NEXT: PySendResult = 1;
  type PySendResult (line 391) | pub type PySendResult = i32;
  type bufferinfo (line 394) | pub struct bufferinfo {
  method default (line 408) | fn default() -> Self {
  type Py_buffer (line 412) | pub type Py_buffer = bufferinfo;
  type getbufferproc (line 413) | pub type getbufferproc = ::std::option::Option<
  type releasebufferproc (line 420) | pub type releasebufferproc =
  type vectorcallfunc (line 422) | pub type vectorcallfunc = ::std::option::Option<
  type PyNumberMethods (line 432) | pub struct PyNumberMethods {
  method default (line 471) | fn default() -> Self {
  type PySequenceMethods (line 477) | pub struct PySequenceMethods {
  method default (line 490) | fn default() -> Self {
  type PyMappingMethods (line 496) | pub struct PyMappingMethods {
  method default (line 502) | fn default() -> Self {
  type sendfunc (line 506) | pub type sendfunc = ::std::option::Option<
  type PyAsyncMethods (line 515) | pub struct PyAsyncMethods {
  method default (line 522) | fn default() -> Self {
  type PyBufferProcs (line 528) | pub struct PyBufferProcs {
  method default (line 533) | fn default() -> Self {
  type _typeobject (line 539) | pub struct _typeobject {
  method default (line 591) | fn default() -> Self {
  type PyBytesObject (line 597) | pub struct PyBytesObject {
  method default (line 603) | fn default() -> Self {
  type Py_UCS4 (line 607) | pub type Py_UCS4 = u32;
  type Py_UCS2 (line 608) | pub type Py_UCS2 = u16;
  type Py_UCS1 (line 609) | pub type Py_UCS1 = u8;
  type PyASCIIObject (line 612) | pub struct PyASCIIObject {
  type PyASCIIObject__bindgen_ty_1 (line 622) | pub struct PyASCIIObject__bindgen_ty_1 {
    method interned (line 627) | pub fn interned(&self) -> ::std::os::raw::c_uint {
    method set_interned (line 631) | pub fn set_interned(&mut self, val: ::std::os::raw::c_uint) {
    method kind (line 638) | pub fn kind(&self) -> ::std::os::raw::c_uint {
    method set_kind (line 642) | pub fn set_kind(&mut self, val: ::std::os::raw::c_uint) {
    method compact (line 649) | pub fn compact(&self) -> ::std::os::raw::c_uint {
    method set_compact (line 653) | pub fn set_compact(&mut self, val: ::std::os::raw::c_uint) {
    method ascii (line 660) | pub fn ascii(&self) -> ::std::os::raw::c_uint {
    method set_ascii (line 664) | pub fn set_ascii(&mut self, val: ::std::os::raw::c_uint) {
    method ready (line 671) | pub fn ready(&self) -> ::std::os::raw::c_uint {
    method set_ready (line 675) | pub fn set_ready(&mut self, val: ::std::os::raw::c_uint) {
    method new_bitfield_1 (line 682) | pub fn new_bitfield_1(
  method default (line 715) | fn default() -> Self {
  type PyCompactUnicodeObject (line 721) | pub struct PyCompactUnicodeObject {
  method default (line 728) | fn default() -> Self {
  type PyUnicodeObject (line 734) | pub struct PyUnicodeObject {
  method default (line 748) | fn default() -> Self {
  method default (line 753) | fn default() -> Self {
  type PyLongObject (line 757) | pub type PyLongObject = _longobject;
  type digit (line 758) | pub type digit = u32;
  type _longobject (line 761) | pub struct _longobject {
  method default (line 766) | fn default() -> Self {
  type PyFloatObject (line 772) | pub struct PyFloatObject {
  method default (line 777) | fn default() -> Self {
  type PyTupleObject (line 783) | pub struct PyTupleObject {
  method default (line 788) | fn default() -> Self {
  type PyListObject (line 794) | pub struct PyListObject {
  method default (line 800) | fn default() -> Self {
  type PyDictKeysObject (line 804) | pub type PyDictKeysObject = _dictkeysobject;
  type PyDictObject (line 807) | pub struct PyDictObject {
  method default (line 815) | fn default() -> Self {
  type PyCFunction (line 819) | pub type PyCFunction = ::std::option::Option<
  type PyMethodDef (line 824) | pub struct PyMethodDef {
  method default (line 831) | fn default() -> Self {
  type Py_OpenCodeHookFunction (line 835) | pub type Py_OpenCodeHookFunction = ::std::option::Option<
  type _PyOpcache (line 840) | pub struct _PyOpcache {
  type PyCodeObject (line 845) | pub struct PyCodeObject {
  method default (line 873) | fn default() -> Self {
  type PyFrameObject (line 877) | pub type PyFrameObject = _frame;
  type PySliceObject (line 880) | pub struct PySliceObject {
  method default (line 887) | fn default() -> Self {
  type PyThreadState (line 891) | pub type PyThreadState = _ts;
  type PyInterpreterState (line 892) | pub type PyInterpreterState = _is;
  type PyWideStringList (line 895) | pub struct PyWideStringList {
  method default (line 900) | fn default() -> Self {
  type PyPreConfig (line 906) | pub struct PyPreConfig {
  type PyConfig (line 920) | pub struct PyConfig {
  method default (line 980) | fn default() -> Self {
  type Py_tracefunc (line 984) | pub type Py_tracefunc = ::std::option::Option<
  type _cframe (line 994) | pub struct _cframe {
  method default (line 999) | fn default() -> Self {
  type CFrame (line 1003) | pub type CFrame = _cframe;
  type _err_stackitem (line 1006) | pub struct _err_stackitem {
  method default (line 1013) | fn default() -> Self {
  type _PyErr_StackItem (line 1017) | pub type _PyErr_StackItem = _err_stackitem;
  type _ts (line 1020) | pub struct _ts {
  method default (line 1056) | fn default() -> Self {
  type _PyFrameEvalFunction (line 1060) | pub type _PyFrameEvalFunction = ::std::option::Option<
  type _xid (line 1069) | pub struct _xid {
  method default (line 1077) | fn default() -> Self {
  type crossinterpdatafunc (line 1081) | pub type crossinterpdatafunc = ::std::option::Option<
  type getter (line 1084) | pub type getter = ::std::option::Option<
  type setter (line 1087) | pub type setter = ::std::option::Option<
  type PyGetSetDef (line 1096) | pub struct PyGetSetDef {
  method default (line 1104) | fn default() -> Self {
  type PyMemberDef (line 1110) | pub struct PyMemberDef {
  type PyBaseExceptionObject (line 1115) | pub struct PyBaseExceptionObject {
  method default (line 1125) | fn default() -> Self {
  type PyThread_type_lock (line 1129) | pub type PyThread_type_lock = *mut ::std::os::raw::c_void;
  type Py_tss_t (line 1130) | pub type Py_tss_t = _Py_tss_t;
  type _Py_tss_t (line 1133) | pub struct _Py_tss_t {
  type _pycontextobject (line 1139) | pub struct _pycontextobject {
  type PyContext (line 1142) | pub type PyContext = _pycontextobject;
  type Py_AuditHookFunction (line 1143) | pub type Py_AuditHookFunction = ::std::option::Option<
  constant _Py_error_handler__Py_ERROR_UNKNOWN (line 1150) | pub const _Py_error_handler__Py_ERROR_UNKNOWN: _Py_error_handler = 0;
  constant _Py_error_handler__Py_ERROR_STRICT (line 1151) | pub const _Py_error_handler__Py_ERROR_STRICT: _Py_error_handler = 1;
  constant _Py_error_handler__Py_ERROR_SURROGATEESCAPE (line 1152) | pub const _Py_error_handler__Py_ERROR_SURROGATEESCAPE: _Py_error_handler...
  constant _Py_error_handler__Py_ERROR_REPLACE (line 1153) | pub const _Py_error_handler__Py_ERROR_REPLACE: _Py_error_handler = 3;
  constant _Py_error_handler__Py_ERROR_IGNORE (line 1154) | pub const _Py_error_handler__Py_ERROR_IGNORE: _Py_error_handler = 4;
  constant _Py_error_handler__Py_ERROR_BACKSLASHREPLACE (line 1155) | pub const _Py_error_handler__Py_ERROR_BACKSLASHREPLACE: _Py_error_handle...
  constant _Py_error_handler__Py_ERROR_SURROGATEPASS (line 1156) | pub const _Py_error_handler__Py_ERROR_SURROGATEPASS: _Py_error_handler = 6;
  constant _Py_error_handler__Py_ERROR_XMLCHARREFREPLACE (line 1157) | pub const _Py_error_handler__Py_ERROR_XMLCHARREFREPLACE: _Py_error_handl...
  constant _Py_error_handler__Py_ERROR_OTHER (line 1158) | pub const _Py_error_handler__Py_ERROR_OTHER: _Py_error_handler = 8;
  type _Py_error_handler (line 1159) | pub type _Py_error_handler = u32;
  type PyFrameState (line 1160) | pub type PyFrameState = ::std::os::raw::c_schar;
  type PyTryBlock (line 1163) | pub struct PyTryBlock {
  type _frame (line 1170) | pub struct _frame {
  method default (line 1191) | fn default() -> Self {
  type PyDictKeyEntry (line 1197) | pub struct PyDictKeyEntry {
  method default (line 1203) | fn default() -> Self {
  type dict_lookup_func (line 1207) | pub type dict_lookup_func = ::std::option::Option<
  type _dictkeysobject (line 1217) | pub struct _dictkeysobject {
  method default (line 1226) | fn default() -> Self {
  type atomic_int (line 1230) | pub type atomic_int = u32;
  type atomic_uintptr_t (line 1231) | pub type atomic_uintptr_t = usize;
  type _Py_atomic_address (line 1234) | pub struct _Py_atomic_address {
  type _Py_atomic_int (line 1239) | pub struct _Py_atomic_int {
  type _gil_runtime_state (line 1244) | pub struct _gil_runtime_state {
  method default (line 1255) | fn default() -> Self {
  type _ceval_runtime_state (line 1261) | pub struct _ceval_runtime_state {
  method default (line 1266) | fn default() -> Self {
  type _gilstate_runtime_state (line 1272) | pub struct _gilstate_runtime_state {
  method default (line 1279) | fn default() -> Self {
  type _Py_AuditHookEntry (line 1285) | pub struct _Py_AuditHookEntry {
  method default (line 1291) | fn default() -> Self {
  type _Py_unicode_runtime_ids (line 1297) | pub struct _Py_unicode_runtime_ids {
  method default (line 1302) | fn default() -> Self {
  type pyruntimestate (line 1308) | pub struct pyruntimestate {
  type pyruntimestate_pyinterpreters (line 1329) | pub struct pyruntimestate_pyinterpreters {
  method default (line 1336) | fn default() -> Self {
  type pyruntimestate__xidregistry (line 1342) | pub struct pyruntimestate__xidregistry {
  method default (line 1347) | fn default() -> Self {
  method default (line 1352) | fn default() -> Self {
  type ast_state (line 1358) | pub struct ast_state {
  method default (line 1596) | fn default() -> Self {
  type PyGC_Head (line 1602) | pub struct PyGC_Head {
  type gc_generation (line 1608) | pub struct gc_generation {
  type gc_generation_stats (line 1615) | pub struct gc_generation_stats {
  type _gc_runtime_state (line 1622) | pub struct _gc_runtime_state {
  method default (line 1638) | fn default() -> Self {
  type _warnings_runtime_state (line 1644) | pub struct _warnings_runtime_state {
  method default (line 1651) | fn default() -> Self {
  type _pending_calls (line 1657) | pub struct _pending_calls {
  type _pending_calls__bindgen_ty_1 (line 1667) | pub struct _pending_calls__bindgen_ty_1 {
  method default (line 1674) | fn default() -> Self {
  method default (line 1679) | fn default() -> Self {
  type _ceval_state (line 1685) | pub struct _ceval_state {
  method default (line 1692) | fn default() -> Self {
  type _Py_unicode_fs_codec (line 1698) | pub struct _Py_unicode_fs_codec {
  method default (line 1705) | fn default() -> Self {
  type _Py_bytes_state (line 1711) | pub struct _Py_bytes_state {
  method default (line 1716) | fn default() -> Self {
  type _Py_unicode_ids (line 1722) | pub struct _Py_unicode_ids {
  method default (line 1727) | fn default() -> Self {
  type _Py_unicode_state (line 1733) | pub struct _Py_unicode_state {
  method default (line 1741) | fn default() -> Self {
  type _Py_float_state (line 1747) | pub struct _Py_float_state {
  method default (line 1752) | fn default() -> Self {
  type _Py_tuple_state (line 1758) | pub struct _Py_tuple_state {
  method default (line 1763) | fn default() -> Self {
  type _Py_list_state (line 1769) | pub struct _Py_list_state {
  method default (line 1774) | fn default() -> Self {
  type _Py_dict_state (line 1780) | pub struct _Py_dict_state {
  method default (line 1787) | fn default() -> Self {
  type _Py_frame_state (line 1793) | pub struct _Py_frame_state {
  method default (line 1798) | fn default() -> Self {
  type _Py_async_gen_state (line 1804) | pub struct _Py_async_gen_state {
  method default (line 1811) | fn default() -> Self {
  type _Py_context_state (line 1817) | pub struct _Py_context_state {
  method default (line 1822) | fn default() -> Self {
  type _Py_exc_state (line 1828) | pub struct _Py_exc_state {
  method default (line 1834) | fn default() -> Self {
  type atexit_callback (line 1840) | pub struct atexit_callback {
  method default (line 1846) | fn default() -> Self {
  type atexit_state (line 1852) | pub struct atexit_state {
  method default (line 1858) | fn default() -> Self {
  type type_cache_entry (line 1864) | pub struct type_cache_entry {
  method default (line 1870) | fn default() -> Self {
  type type_cache (line 1876) | pub struct type_cache {
  method default (line 1880) | fn default() -> Self {
  type _is (line 1886) | pub struct _is {
  method default (line 1939) | fn default() -> Self {
  type _xidregitem (line 1945) | pub struct _xidregitem {
  method default (line 1951) | fn default() -> Self {
  type _PyAsyncGenWrappedValue (line 1957) | pub struct _PyAsyncGenWrappedValue {
  type PyAsyncGenASend (line 1962) | pub struct PyAsyncGenASend {

FILE: src/python_bindings/v3_11_0.rs
  type __BindgenBitfieldUnit (line 17) | pub struct __BindgenBitfieldUnit<Storage> {
  function new (line 22) | pub const fn new(storage: Storage) -> Self {
  function extract_bit (line 31) | fn extract_bit(byte: u8, index: usize) -> bool {
  function get_bit (line 41) | pub fn get_bit(&self, index: usize) -> bool {
  function raw_get_bit (line 48) | pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
  function change_bit (line 55) | fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
  function set_bit (line 69) | pub fn set_bit(&mut self, index: usize, val: bool) {
  function raw_set_bit (line 76) | pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
  function get (line 83) | pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
  function raw_get (line 101) | pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u...
  function set (line 119) | pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
  function raw_set (line 135) | pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8,...
  type __IncompleteArrayField (line 153) | pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; ...
  function new (line 156) | pub const fn new() -> Self {
  function as_ptr (line 160) | pub fn as_ptr(&self) -> *const T {
  function as_mut_ptr (line 164) | pub fn as_mut_ptr(&mut self) -> *mut T {
  function as_slice (line 168) | pub unsafe fn as_slice(&self, len: usize) -> &[T] {
  function as_mut_slice (line 172) | pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
  function fmt (line 177) | fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
  type wchar_t (line 181) | pub type wchar_t = ::std::os::raw::c_int;
  type Py_ssize_t (line 182) | pub type Py_ssize_t = isize;
  type Py_hash_t (line 183) | pub type Py_hash_t = Py_ssize_t;
  type PyMemberDef (line 186) | pub struct PyMemberDef {
  type PyObject (line 189) | pub type PyObject = _object;
  type PyLongObject (line 190) | pub type PyLongObject = _longobject;
  type PyTypeObject (line 191) | pub type PyTypeObject = _typeobject;
  type PyFrameObject (line 192) | pub type PyFrameObject = _frame;
  type PyThreadState (line 193) | pub type PyThreadState = _ts;
  type PyInterpreterState (line 194) | pub type PyInterpreterState = _is;
  type Py_buffer (line 197) | pub struct Py_buffer {
  method default (line 211) | fn default() -> Self {
  type _object (line 221) | pub struct _object {
  method default (line 226) | fn default() -> Self {
  type PyVarObject (line 236) | pub struct PyVarObject {
  method default (line 241) | fn default() -> Self {
  type unaryfunc (line 249) | pub type unaryfunc =
  type binaryfunc (line 251) | pub type binaryfunc = ::std::option::Option<
  type ternaryfunc (line 254) | pub type ternaryfunc = ::std::option::Option<
  type inquiry (line 261) | pub type inquiry =
  type lenfunc (line 263) | pub type lenfunc = ::std::option::Option<unsafe extern "C" fn(arg1: *mut...
  type ssizeargfunc (line 264) | pub type ssizeargfunc = ::std::option::Option<
  type ssizeobjargproc (line 267) | pub type ssizeobjargproc = ::std::option::Option<
  type objobjargproc (line 274) | pub type objobjargproc = ::std::option::Option<
  type objobjproc (line 281) | pub type objobjproc = ::std::option::Option<
  type visitproc (line 284) | pub type visitproc = ::std::option::Option<
  type traverseproc (line 290) | pub type traverseproc = ::std::option::Option<
  type freefunc (line 297) | pub type freefunc = ::std::option::Option<unsafe extern "C" fn(arg1: *mu...
  type destructor (line 298) | pub type destructor = ::std::option::Option<unsafe extern "C" fn(arg1: *...
  type getattrfunc (line 299) | pub type getattrfunc = ::std::option::Option<
  type getattrofunc (line 302) | pub type getattrofunc = ::std::option::Option<
  type setattrfunc (line 305) | pub type setattrfunc = ::std::option::Option<
  type setattrofunc (line 312) | pub type setattrofunc = ::std::option::Option<
  type reprfunc (line 319) | pub type reprfunc =
  type hashfunc (line 321) | pub type hashfunc = ::std::option::Option<unsafe extern "C" fn(arg1: *mu...
  type richcmpfunc (line 322) | pub type richcmpfunc = ::std::option::Option<
  type getiterfunc (line 329) | pub type getiterfunc =
  type iternextfunc (line 331) | pub type iternextfunc =
  type descrgetfunc (line 333) | pub type descrgetfunc = ::std::option::Option<
  type descrsetfunc (line 340) | pub type descrsetfunc = ::std::option::Option<
  type initproc (line 347) | pub type initproc = ::std::option::Option<
  type newfunc (line 354) | pub type newfunc = ::std::option::Option<
  type allocfunc (line 361) | pub type allocfunc = ::std::option::Option<
  constant PySendResult_PYGEN_RETURN (line 364) | pub const PySendResult_PYGEN_RETURN: PySendResult = 0;
  constant PySendResult_PYGEN_ERROR (line 365) | pub const PySendResult_PYGEN_ERROR: PySendResult = -1;
  constant PySendResult_PYGEN_NEXT (line 366) | pub const PySendResult_PYGEN_NEXT: PySendResult = 1;
  type PySendResult (line 367) | pub type PySendResult = ::std::os::raw::c_int;
  type getbufferproc (line 368) | pub type getbufferproc = ::std::option::Option<
  type releasebufferproc (line 375) | pub type releasebufferproc =
  type vectorcallfunc (line 377) | pub type vectorcallfunc = ::std::option::Option<
  type PyNumberMethods (line 387) | pub struct PyNumberMethods {
  method default (line 426) | fn default() -> Self {
  type PySequenceMethods (line 436) | pub struct PySequenceMethods {
  method default (line 449) | fn default() -> Self {
  type PyMappingMethods (line 459) | pub struct PyMappingMethods {
  type sendfunc (line 464) | pub type sendfunc = ::std::option::Option<
  type PyAsyncMethods (line 473) | pub struct PyAsyncMethods {
  type PyBufferProcs (line 481) | pub struct PyBufferProcs {
  type _typeobject (line 487) | pub struct _typeobject {
  method default (line 539) | fn default() -> Self {
  type _specialization_cache (line 549) | pub struct _specialization_cache {
  method default (line 553) | fn default() -> Self {
  type _heaptypeobject (line 563) | pub struct _heaptypeobject {
  method default (line 579) | fn default() -> Self {
  type PyHeapTypeObject (line 587) | pub type PyHeapTypeObject = _heaptypeobject;
  type PyBytesObject (line 590) | pub struct PyBytesObject {
  method default (line 596) | fn default() -> Self {
  type Py_UCS4 (line 604) | pub type Py_UCS4 = u32;
  type Py_UCS2 (line 605) | pub type Py_UCS2 = u16;
  type Py_UCS1 (line 606) | pub type Py_UCS1 = u8;
  type PyASCIIObject (line 609) | pub struct PyASCIIObject {
  type PyASCIIObject__bindgen_ty_1 (line 619) | pub struct PyASCIIObject__bindgen_ty_1 {
    method interned (line 625) | pub fn interned(&self) -> ::std::os::raw::c_uint {
    method set_interned (line 629) | pub fn set_interned(&mut self, val: ::std::os::raw::c_uint) {
    method interned_raw (line 636) | pub unsafe fn interned_raw(this: *const Self) -> ::std::os::raw::c_uint {
    method set_interned_raw (line 646) | pub unsafe fn set_interned_raw(this: *mut Self, val: ::std::os::raw::c...
    method kind (line 658) | pub fn kind(&self) -> ::std::os::raw::c_uint {
    method set_kind (line 662) | pub fn set_kind(&mut self, val: ::std::os::raw::c_uint) {
    method kind_raw (line 669) | pub unsafe fn kind_raw(this: *const Self) -> ::std::os::raw::c_uint {
    method set_kind_raw (line 679) | pub unsafe fn set_kind_raw(this: *mut Self, val: ::std::os::raw::c_uin...
    method compact (line 691) | pub fn compact(&self) -> ::std::os::raw::c_uint {
    method set_compact (line 695) | pub fn set_compact(&mut self, val: ::std::os::raw::c_uint) {
    method compact_raw (line 702) | pub unsafe fn compact_raw(this: *const Self) -> ::std::os::raw::c_uint {
    method set_compact_raw (line 712) | pub unsafe fn set_compact_raw(this: *mut Self, val: ::std::os::raw::c_...
    method ascii (line 724) | pub fn ascii(&self) -> ::std::os::raw::c_uint {
    method set_ascii (line 728) | pub fn set_ascii(&mut self, val: ::std::os::raw::c_uint) {
    method ascii_raw (line 735) | pub unsafe fn ascii_raw(this: *const Self) -> ::std::os::raw::c_uint {
    method set_ascii_raw (line 745) | pub unsafe fn set_ascii_raw(this: *mut Self, val: ::std::os::raw::c_ui...
    method ready (line 757) | pub fn ready(&self) -> ::std::os::raw::c_uint {
    method set_ready (line 761) | pub fn set_ready(&mut self, val: ::std::os::raw::c_uint) {
    method ready_raw (line 768) | pub unsafe fn ready_raw(this: *const Self) -> ::std::os::raw::c_uint {
    method set_ready_raw (line 778) | pub unsafe fn set_ready_raw(this: *mut Self, val: ::std::os::raw::c_ui...
    method new_bitfield_1 (line 790) | pub fn new_bitfield_1(
  method default (line 822) | fn default() -> Self {
  type PyCompactUnicodeObject (line 832) | pub struct PyCompactUnicodeObject {
  method default (line 839) | fn default() -> Self {
  type PyUnicodeObject (line 849) | pub struct PyUnicodeObject {
  method default (line 862) | fn default() -> Self {
  method default (line 871) | fn default() -> Self {
  type digit (line 879) | pub type digit = u32;
  type _longobject (line 882) | pub struct _longobject {
  method default (line 887) | fn default() -> Self {
  type PyFloatObject (line 897) | pub struct PyFloatObject {
  method default (line 902) | fn default() -> Self {
  type PyTupleObject (line 912) | pub struct PyTupleObject {
  method default (line 917) | fn default() -> Self {
  type PyListObject (line 927) | pub struct PyListObject {
  method default (line 933) | fn default() -> Self {
  type PyDictKeysObject (line 941) | pub type PyDictKeysObject = _dictkeysobject;
  type PyDictValues (line 942) | pub type PyDictValues = _dictvalues;
  type PyDictObject (line 945) | pub struct PyDictObject {
  method default (line 953) | fn default() -> Self {
  type PyCFunction (line 961) | pub type PyCFunction = ::std::option::Option<
  type PyMethodDef (line 966) | pub struct PyMethodDef {
  method default (line 973) | fn default() -> Self {
  type PyFunctionObject (line 983) | pub struct PyFunctionObject {
  method default (line 1002) | fn default() -> Self {
  type _Py_CODEUNIT (line 1010) | pub type _Py_CODEUNIT = u16;
  type PyCodeObject (line 1013) | pub struct PyCodeObject {
  method default (line 1045) | fn default() -> Self {
  type _opaque (line 1055) | pub struct _opaque {
  method default (line 1061) | fn default() -> Self {
  type _line_offsets (line 1071) | pub struct _line_offsets {
  method default (line 1078) | fn default() -> Self {
  type PyCodeAddressRange (line 1086) | pub type PyCodeAddressRange = _line_offsets;
  type PySliceObject (line 1089) | pub struct PySliceObject {
  method default (line 1096) | fn default() -> Self {
  type PyWideStringList (line 1106) | pub struct PyWideStringList {
  method default (line 1111) | fn default() -> Self {
  type PyConfig (line 1121) | pub struct PyConfig {
  method default (line 1187) | fn default() -> Self {
  type Py_tracefunc (line 1195) | pub type Py_tracefunc = ::std::option::Option<
  type PyTraceInfo (line 1205) | pub struct PyTraceInfo {
  method default (line 1210) | fn default() -> Self {
  type _PyCFrame (line 1220) | pub struct _PyCFrame {
  method default (line 1226) | fn default() -> Self {
  type _err_stackitem (line 1236) | pub struct _err_stackitem {
  method default (line 1241) | fn default() -> Self {
  type _PyErr_StackItem (line 1249) | pub type _PyErr_StackItem = _err_stackitem;
  type _stack_chunk (line 1252) | pub struct _stack_chunk {
  method default (line 1259) | fn default() -> Self {
  type _PyStackChunk (line 1267) | pub type _PyStackChunk = _stack_chunk;
  type _ts (line 1270) | pub struct _ts {
  method default (line 1313) | fn default() -> Self {
  type _PyFrameEvalFunction (line 1321) | pub type _PyFrameEvalFunction = ::std::option::Option<
  type getter (line 1328) | pub type getter = ::std::option::Option<
  type setter (line 1331) | pub type setter = ::std::option::Option<
  type PyGetSetDef (line 1340) | pub struct PyGetSetDef {
  method default (line 1348) | fn default() -> Self {
  type PyBaseExceptionObject (line 1358) | pub struct PyBaseExceptionObject {
  method default (line 1369) | fn default() -> Self {
  type PyThread_type_lock (line 1377) | pub type PyThread_type_lock = *mut ::std::os::raw::c_void;
  type _Py_atomic_int (line 1380) | pub struct _Py_atomic_int {
  type ast_state (line 1385) | pub struct ast_state {
  method default (line 1626) | fn default() -> Self {
  type callable_cache (line 1636) | pub struct callable_cache {
  method default (line 1642) | fn default() -> Self {
  type _Py_context_state (line 1652) | pub struct _Py_context_state {}
  type _Py_dict_state (line 1655) | pub struct _Py_dict_state {}
  type PyDictUnicodeEntry (line 1658) | pub struct PyDictUnicodeEntry {
  method default (line 1663) | fn default() -> Self {
  type _dictkeysobject (line 1673) | pub struct _dictkeysobject {
  type _dictvalues (line 1685) | pub struct _dictvalues {
  method default (line 1689) | fn default() -> Self {
  type _Py_exc_state (line 1699) | pub struct _Py_exc_state {
  method default (line 1706) | fn default() -> Self {
  type _Py_float_state (line 1716) | pub struct _Py_float_state {}
  type _Py_async_gen_state (line 1719) | pub struct _Py_async_gen_state {}
  type PyGC_Head (line 1722) | pub struct PyGC_Head {
  type gc_generation (line 1728) | pub struct gc_generation {
  type gc_generation_stats (line 1735) | pub struct gc_generation_stats {
  type _gc_runtime_state (line 1742) | pub struct _gc_runtime_state {
  method default (line 1758) | fn default() -> Self {
  type _Py_list_state (line 1768) | pub struct _Py_list_state {}
  type _Py_tuple_state (line 1771) | pub struct _Py_tuple_state {
  type type_cache_entry (line 1776) | pub struct type_cache_entry {
  method default (line 1782) | fn default() -> Self {
  type type_cache (line 1792) | pub struct type_cache {
  method default (line 1796) | fn default() -> Self {
  constant _Py_error_handler__Py_ERROR_UNKNOWN (line 1804) | pub const _Py_error_handler__Py_ERROR_UNKNOWN: _Py_error_handler = 0;
  constant _Py_error_handler__Py_ERROR_STRICT (line 1805) | pub const _Py_error_handler__Py_ERROR_STRICT: _Py_error_handler = 1;
  constant _Py_error_handler__Py_ERROR_SURROGATEESCAPE (line 1806) | pub const _Py_error_handler__Py_ERROR_SURROGATEESCAPE: _Py_error_handler...
  constant _Py_error_handler__Py_ERROR_REPLACE (line 1807) | pub const _Py_error_handler__Py_ERROR_REPLACE: _Py_error_handler = 3;
  constant _Py_error_handler__Py_ERROR_IGNORE (line 1808) | pub const _Py_error_handler__Py_ERROR_IGNORE: _Py_error_handler = 4;
  constant _Py_error_handler__Py_ERROR_BACKSLASHREPLACE (line 1809) | pub const _Py_error_handler__Py_ERROR_BACKSLASHREPLACE: _Py_error_handle...
  constant _Py_error_handler__Py_ERROR_SURROGATEPASS (line 1810) | pub const _Py_error_handler__Py_ERROR_SURROGATEPASS: _Py_error_handler = 6;
  constant _Py_error_handler__Py_ERROR_XMLCHARREFREPLACE (line 1811) | pub const _Py_error_handler__Py_ERROR_XMLCHARREFREPLACE: _Py_error_handl...
  constant _Py_error_handler__Py_ERROR_OTHER (line 1812) | pub const _Py_error_handler__Py_ERROR_OTHER: _Py_error_handler = 8;
  type _Py_error_handler (line 1813) | pub type _Py_error_handler = ::std::os::raw::c_uint;
  type _Py_unicode_fs_codec (line 1816) | pub struct _Py_unicode_fs_codec {
  method default (line 1823) | fn default() -> Self {
  type _Py_unicode_ids (line 1833) | pub struct _Py_unicode_ids {
  method default (line 1838) | fn default() -> Self {
  type _Py_unicode_state (line 1848) | pub struct _Py_unicode_state {
  method default (line 1853) | fn default() -> Self {
  type _warnings_runtime_state (line 1863) | pub struct _warnings_runtime_state {
  method default (line 1870) | fn default() -> Self {
  type _pending_calls (line 1880) | pub struct _pending_calls {
  type _pending_calls__bindgen_ty_1 (line 1890) | pub struct _pending_calls__bindgen_ty_1 {
  method default (line 1897) | fn default() -> Self {
  method default (line 1906) | fn default() -> Self {
  type _ceval_state (line 1916) | pub struct _ceval_state {
  method default (line 1923) | fn default() -> Self {
  type atexit_callback (line 1933) | pub struct atexit_callback {
  method default (line 1939) | fn default() -> Self {
  type atexit_state (line 1949) | pub struct atexit_state {
  method default (line 1955) | fn default() -> Self {
  type _is (line 1965) | pub struct _is {
  type _is_pythreads (line 2019) | pub struct _is_pythreads {
  method default (line 2026) | fn default() -> Self {
  method default (line 2035) | fn default() -> Self {
  type _frame (line 2045) | pub struct _frame {
  method default (line 2057) | fn default() -> Self {
  type _PyInterpreterFrame (line 2067) | pub struct _PyInterpreterFrame {
  method default (line 2082) | fn default() -> Self {
  type pyruntimestate (line 2092) | pub struct pyruntimestate {

FILE: src/python_bindings/v3_12_0.rs
  type __BindgenBitfieldUnit (line 17) | pub struct __BindgenBitfieldUnit<Storage> {
  function new (line 22) | pub const fn new(storage: Storage) -> Self {
  function extract_bit (line 31) | fn extract_bit(byte: u8, index: usize) -> bool {
  function get_bit (line 41) | pub fn get_bit(&self, index: usize) -> bool {
  function raw_get_bit (line 48) | pub unsafe fn raw_get_bit(this: *const Self, index: usize) -> bool {
  function change_bit (line 55) | fn change_bit(byte: u8, index: usize, val: bool) -> u8 {
  function set_bit (line 69) | pub fn set_bit(&mut self, index: usize, val: bool) {
  function raw_set_bit (line 76) | pub unsafe fn raw_set_bit(this: *mut Self, index: usize, val: bool) {
  function get (line 83) | pub fn get(&self, bit_offset: usize, bit_width: u8) -> u64 {
  function raw_get (line 101) | pub unsafe fn raw_get(this: *const Self, bit_offset: usize, bit_width: u...
  function set (line 119) | pub fn set(&mut self, bit_offset: usize, bit_width: u8, val: u64) {
  function raw_set (line 135) | pub unsafe fn raw_set(this: *mut Self, bit_offset: usize, bit_width: u8,...
  type __IncompleteArrayField (line 153) | pub struct __IncompleteArrayField<T>(::std::marker::PhantomData<T>, [T; ...
  function new (line 156) | pub const fn new() -> Self {
  function as_ptr (line 160) | pub fn as_ptr(&self) -> *const T {
  function as_mut_ptr (line 164) | pub fn as_mut_ptr(&mut self) -> *mut T {
  function as_slice (line 168) | pub unsafe fn as_slice(&self, len: usize) -> &[T] {
  function as_mut_slice (line 172) | pub unsafe fn as_mut_slice(&mut self, len: usize) -> &mut [T] {
  function fmt (line 177) | fn fmt(&self, fmt: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
  type wchar_t (line 181) | pub type wchar_t = ::std::os::raw::c_int;
  type __uint32_t (line 182) | pub type __uint32_t = ::std::os::raw::c_uint;
  type __dev_t (line 183) | pub type __dev_t = ::std::os::raw::c_ulong;
  type __uid_t (line 184) | pub type __uid_t = ::std::os::raw::c_uint;
  type __ino64_t (line 185) | pub type __ino64_t = ::std::os::raw::c_ulong;
  type __pid_t (line 186) | pub type __pid_t = ::std::os::raw::c_int;
  type __clock_t (line 187) | pub type __clock_t = ::std::os::raw::c_long;
  type __sig_atomic_t (line 188) | pub type __sig_atomic_t = ::std::os::raw::c_int;
  type ino_t (line 189) | pub type ino_t = __ino64_t;
  type dev_t (line 190) | pub type dev_t = __dev_t;
  type __sigset_t (line 193) | pub struct __sigset_t {
  type __atomic_wide_counter__bindgen_ty_1 (line 204) | pub struct __atomic_wide_counter__bindgen_ty_1 {
  method default (line 209) | fn default() -> Self {
  type __pthread_internal_list (line 219) | pub struct __pthread_internal_list {
  method default (line 224) | fn default() -> Self {
  type __pthread_list_t (line 232) | pub type __pthread_list_t = __pthread_internal_list;
  type __pthread_mutex_s (line 235) | pub struct __pthread_mutex_s {
  method default (line 246) | fn default() -> Self {
  type __pthread_cond_s (line 256) | pub struct __pthread_cond_s {
  method default (line 266) | fn default() -> Self {
  method default (line 281) | fn default() -> Self {
  type pthread_key_t (line 289) | pub type pthread_key_t = ::std::os::raw::c_uint;
  method default (line 298) | fn default() -> Self {
  method default (line 314) | fn default() -> Self {
  type Py_ssize_t (line 322) | pub type Py_ssize_t = isize;
  type Py_hash_t (line 323) | pub type Py_hash_t = Py_ssize_t;
  type Py_uhash_t (line 324) | pub type Py_uhash_t = usize;
  type PyMemAllocatorEx (line 327) | pub struct PyMemAllocatorEx {
  method default (line 354) | fn default() -> Self {
  type PyObject (line 362) | pub type PyObject = _object;
  type PyLongObject (line 363) | pub type PyLongObject = _longobject;
  type PyTypeObject (line 364) | pub type PyTypeObject = _typeobject;
  type PyFrameObject (line 365) | pub type PyFrameObject = _frame;
  type PyThreadState (line 366) | pub type PyThreadState = _ts;
  type PyInterpreterState (line 367) | pub type PyInterpreterState = _is;
  type Py_buffer (line 370) | pub struct Py_buffer {
  method default (line 384) | fn default() -> Self {
  type getbufferproc (line 392) | pub type getbufferproc = ::std::option::Option<
  type releasebufferproc (line 399) | pub type releasebufferproc =
  type _object (line 403) | pub struct _object {
  method default (line 419) | fn default() -> Self {
  method default (line 428) | fn default() -> Self {
  type PyVarObject (line 438) | pub struct PyVarObject {
  method default (line 443) | fn default() -> Self {
  type unaryfunc (line 451) | pub type unaryfunc =
  type binaryfunc (line 453) | pub type binaryfunc = ::std::option::Option<
  type ternaryfunc (line 456) | pub type ternaryfunc = ::std::option::Option<
  type inquiry (line 463) | pub type inquiry =
  type lenfunc (line 465) | pub type lenfunc = ::std::option::Option<unsafe extern "C" fn(arg1: *mut...
  type ssizeargfunc (line 466) | pub type ssizeargfunc = ::std::option::Option<
  type ssizeobjargproc (line 469) | pub type ssizeobjargproc = ::std::option::Option<
  type objobjargproc (line 476) | pub type objobjargproc = ::std::option::Option<
  type objobjproc (line 483) | pub type objobjproc = ::std::option::Option<
  type visitproc (line 486) | pub type visitproc = ::std::option::Option<
  type traverseproc (line 492) | pub type traverseproc = ::std::option::Option<
  type freefunc (line 499) | pub type freefunc = ::std::option::Option<unsafe extern "C" fn(arg1: *mu...
  type destructor (line 500) | pub type destructor = ::std::option::Option<unsafe extern "C" fn(arg1: *...
  type getattrfunc (line 501) | pub type getattrfunc = ::std::option::Option<
  type getattrofunc (line 504) | pub type getattrofunc = ::std::option::Option<
  type setattrfunc (line 507) | pub type setattrfunc = ::std::option::Option<
  type setattrofunc (line 514) | pub type setattrofunc = ::std::option::Option<
  type reprfunc (line 521) | pub type reprfunc =
  type hashfunc (line 523) | pub type hashfunc = ::std::option::Option<unsafe extern "C" fn(arg1: *mu...
  type richcmpfunc (line 524) | pub type richcmpfunc = ::std::option::Option<
  type getiterfunc (line 531) | pub type getiterfunc =
  type iternextfunc (line 533) | pub type iternextfunc =
  type descrgetfunc (line 535) | pub type descrgetfunc = ::std::option::Option<
  type descrsetfunc (line 542) | pub type descrsetfunc = ::std::option::Option<
  type initproc (line 549) | pub type initproc = ::std::option::Option<
  type newfunc (line 556) | pub type newfunc = ::std::option::Option<
  type allocfunc (line 563) | pub type allocfunc = ::std::option::Option<
  type vectorcallfunc (line 566) | pub type vectorcallfunc = ::std::option::Option<
  constant PySendResult_PYGEN_RETURN (line 574) | pub const PySendResult_PYGEN_RETURN: PySendResult = 0;
  constant PySendResult_PYGEN_ERROR (line 575) | pub const PySendResult_PYGEN_ERROR: PySendResult = -1;
  constant PySendResult_PYGEN_NEXT (line 576) | pub const PySendResult_PYGEN_NEXT: PySendResult = 1;
  type PySendResult (line 577) | pub type PySendResult = ::std::os::raw::c_int;
  type PyNumberMethods (line 580) | pub struct PyNumberMethods {
  method default (line 619) | fn default() -> Self {
  type PySequenceMethods (line 629) | pub struct PySequenceMethods {
  method default (line 642) | fn default() -> Self {
  type PyMappingMethods (line 652) | pub struct PyMappingMethods {
  type sendfunc (line 657) | pub type sendfunc = ::std::option::Option<
  type PyAsyncMethods (line 666) | pub struct PyAsyncMethods {
  type PyBufferProcs (line 674) | pub struct PyBufferProcs {
  type _typeobject (line 680) | pub struct _typeobject {
  method default (line 733) | fn default() -> Self {
  type _specialization_cache (line 743) | pub struct _specialization_cache {
  method default (line 748) | fn default() -> Self {
  type _heaptypeobject (line 758) | pub struct _heaptypeobject {
  method default (line 774) | fn default() -> Self {
  type PyHeapTypeObject (line 782) | pub type PyHeapTypeObject = _heaptypeobject;
  type PyType_WatchCallback (line 783) | pub type PyType_WatchCallback =
  type PyObjectArenaAllocator (line 787) | pub struct PyObjectArenaAllocator {
  method default (line 804) | fn default() -> Self {
  type PyBytesObject (line 814) | pub struct PyBytesObject {
  method default (line 820) | fn default() -> Self {
  type Py_UCS4 (line 828) | pub type Py_UCS4 = u32;
  type Py_UCS2 (line 829) | pub type Py_UCS2 = u16;
  type Py_UCS1 (line 830) | pub type Py_UCS1 = u8;
  type PyASCIIObject (line 833) | pub struct PyASCIIObject {
  type PyASCIIObject__bindgen_ty_1 (line 842) | pub struct PyASCIIObject__bindgen_ty_1 {
    method interned (line 848) | pub fn interned(&self) -> ::std::os::raw::c_uint {
    method set_interned (line 852) | pub fn set_interned(&mut self, val: ::std::os::raw::c_uint) {
    method interned_raw (line 859) | pub unsafe fn interned_raw(this: *const Self) -> ::std::os::raw::c_uint {
    method set_interned_raw (line 869) | pub unsafe fn set_interned_raw(this: *mut Self, val: ::std::os::raw::c...
    method kind (line 881) | pub fn kind(&self) -> ::std::os::raw::c_uint {
    method set_kind (line 885) | pub fn set_kind(&mut self, val: ::std::os::raw::c_uint) {
    method kind_raw (line 892) | pub unsafe fn kind_raw(this: *const Self) -> ::std::os::raw::c_uint {
    method set_kind_raw (line 902) | pub unsafe fn set_kind_raw(this: *mut Self, val: ::std::os::raw::c_uin...
    method compact (line 914) | pub fn compact(&self) -> ::std::os::raw::c_uint {
    method set_compact (line 918) | pub fn set_compact(&mut self, val: ::std::os::raw::c_uint) {
    method compact_raw (line 925) | pub unsafe fn compact_raw(this: *const Self) -> ::std::os::raw::c_uint {
    method set_compact_raw (line 935) | pub unsafe fn set_compact_raw(this: *mut Self, val: ::std::os::raw::c_...
    method ascii (line 947) | pub fn ascii(&self) -> ::std::os::raw::c_uint {
    method set_ascii (line 951) | pub fn set_ascii(&mut self, val: ::std::os::raw::c_uint) {
    method ascii_raw (line 958) | pub unsafe fn ascii_raw(this: *const Self) -> ::std::os::raw::c_uint {
    method set_ascii_raw (line 968) | pub unsafe fn set_ascii_raw(this: *mut Self, val: ::std::os::raw::c_ui...
    method new_bitfield_1 (line 980) | pub fn new_bitfield_1(
  method default (line 1007) | fn default() -> Self {
  type PyCompactUnicodeObject (line 1017) | pub struct PyCompactUnicodeObject {
  method default (line 1023) | fn default() -> Self {
  type PyUnicodeObject (line 1033) | pub struct PyUnicodeObject {
  method default (line 1046) | fn default() -> Self {
  method default (line 1055) | fn default() -> Self {
  type digit (line 1063) | pub type digit = u32;
  type _PyLongValue (line 1066) | pub struct _PyLongValue {
  type _longobject (line 1072) | pub struct _longobject {
  method default (line 1077) | fn default() -> Self {
  type PyFloatObject (line 1087) | pub struct PyFloatObject {
  method default (line 1092) | fn default() -> Self {
  type PyTupleObject (line 1102) | pub struct PyTupleObject {
  method default (line 1107) | fn default() -> Self {
  type PyListObject (line 1117) | pub struct PyListObject {
  method default (line 1123) | fn default() -> Self {
  type PyDictKeysObject (line 1131) | pub type PyDictKeysObject = _dictkeysobject;
  type PyDictValues (line 1132) | pub type PyDictValues = _dictvalues;
  type PyDictObject (line 1135) | pub struct PyDictObject {
  method default (line 1143) | fn default() -> Self {
  constant PyDict_WatchEvent_PyDict_EVENT_ADDED (line 1151) | pub const PyDict_WatchEvent_PyDict_EVENT_ADDED: PyDict_WatchEvent = 0;
  constant PyDict_WatchEvent_PyDict_EVENT_MODIFIED (line 1152) | pub const PyDict_WatchEvent_PyDict_EVENT_MODIFIED: PyDict_WatchEvent = 1;
  constant PyDict_WatchEvent_PyDict_EVENT_DELETED (line 1153) | pub const PyDict_WatchEvent_PyDict_EVENT_DELETED: PyDict_WatchEvent = 2;
  constant PyDict_WatchEvent_PyDict_EVENT_CLONED (line 1154) | pub const PyDict_WatchEvent_PyDict_EVENT_CLONED: PyDict_WatchEvent = 3;
  constant PyDict_WatchEvent_PyDict_EVENT_CLEARED (line 1155) | pub const PyDict_WatchEvent_PyDict_EVENT_CLEARED: PyDict_WatchEvent = 4;
  constant PyDict_WatchEvent_PyDict_EVENT_DEALLOCATED (line 1156) | pub const PyDict_WatchEvent_PyDict_EVENT_DEALLOCATED: PyDict_WatchEvent ...
  type PyDict_WatchEvent (line 1157) | pub type PyDict_WatchEvent = ::std::os::raw::c_uint;
  type PyDict_WatchCallback (line 1158) | pub type PyDict_WatchCallback = ::std::option::Option<
  type PyCFunction (line 1166) | pub type PyCFunction = ::std::option::Option<
  type PyMethodDef (line 1171) | pub struct PyMethodDef {
  method default (line 1178) | fn default() -> Self {
  type PyFunctionObject (line 1188) | pub struct PyFunctionObject {
  method default (line 1208) | fn default() -> Self {
  constant PyFunction_WatchEvent_PyFunction_EVENT_CREATE (line 1216) | pub const PyFunction_WatchEvent_PyFunction_EVENT_CREATE: PyFunction_Watc...
  constant PyFunction_WatchEvent_PyFunction_EVENT_DESTROY (line 1217) | pub const PyFunction_WatchEvent_PyFunction_EVENT_DESTROY: PyFunction_Wat...
  constant PyFunction_WatchEvent_PyFunction_EVENT_MODIFY_CODE (line 1218) | pub const PyFunction_WatchEvent_PyFunction_EVENT_MODIFY_CODE: PyFunction...
  constant PyFunction_WatchEvent_PyFunction_EVENT_MODIFY_DEFAULTS (line 1219) | pub const PyFunction_WatchEvent_PyFunction_EVENT_MODIFY_DEFAULTS: PyFunc...
  constant PyFunction_WatchEvent_PyFunction_EVENT_MODIFY_KWDEFAULTS (line 1220) | pub const PyFunction_WatchEvent_PyFunction_EVENT_MODIFY_KWDEFAULTS: PyFu...
  type PyFunction_WatchEvent (line 1221) | pub type PyFunction_WatchEvent = ::std::os::raw::c_uint;
  type PyFunction_WatchCallback (line 1222) | pub type PyFunction_WatchCallback = ::std::option::Option<
  type Py_OpenCodeHookFunction (line 1229) | pub type Py_OpenCodeHookFunction = ::std::option::Option<
  type _Py_LocalMonitors (line 1234) | pub struct _Py_LocalMonitors {
  type _Py_GlobalMonitors (line 1239) | pub struct _Py_GlobalMonitors {
  type _Py_CODEUNIT__bindgen_ty_1 (line 1250) | pub struct _Py_CODEUNIT__bindgen_ty_1 {
  method default (line 1255) | fn default() -> Self {
  type _PyCoCached (line 1265) | pub struct _PyCoCached {
  method default (line 1272) | fn default() -> Self {
  type _PyCoLineInstrumentationData (line 1282) | pub struct _PyCoLineInstrumentationData {
  type _PyCoMonitoringData (line 1288) | pub struct _PyCoMonitoringData {
  method default (line 1298) | fn default() -> Self {
  type PyCodeObject (line 1308) | pub struct PyCodeObject {
  method default (line 1340) | fn default() -> Self {
  constant PyCodeEvent_PY_CODE_EVENT_CREATE (line 1348) | pub const PyCodeEvent_PY_CODE_EVENT_CREATE: PyCodeEvent = 0;
  constant PyCodeEvent_PY_CODE_EVENT_DESTROY (line 1349) | pub const PyCodeEvent_PY_CODE_EVENT_DESTROY: PyCodeEvent = 1;
  type PyCodeEvent (line 1350) | pub type PyCodeEvent = ::std::os::raw::c_uint;
  type PyCode_WatchCallback (line 1351) | pub type PyCode_WatchCallback = ::std::option::Option<
  type PySliceObject (line 1356) | pub struct PySliceObject {
  method default (line 1363) | fn default() -> Self {
  type PyWideStringList (line 1373) | pub struct PyWideStringList {
  method default (line 1378) | fn default() -> Self {
  type PyPreConfig (line 1388) | pub struct PyPreConfig {
  type PyConfig (line 1402) | pub struct PyConfig {
  method default (line 1469) | fn default() -> Self {
  type Py_tracefunc (line 1477) | pub type Py_tracefunc = ::std::option::Option<
  type _PyCFrame (line 1487) | pub struct _PyCFrame {
  method default (line 1492) | fn default() -> Self {
  type _err_stackitem (line 1502) | pub struct _err_stackitem {
  method default (line 1507) | fn default() -> Self {
  type _PyErr_StackItem (line 1515) | pub type _PyErr_StackItem = _err_stackitem;
  type _stack_chunk (line 1518) | pub struct _stack_chunk {
  method default (line 1525) | fn default() -> Self {
  type _PyStackChunk (line 1533) | pub type _PyStackChunk = _stack_chunk;
  type _py_trashcan (line 1536) | pub struct _py_trashcan {
  method default (line 1541) | fn default() -> Self {
  type _ts (line 1551) | pub struct _ts {
  type _ts__bindgen_ty_1 (line 1592) | pub struct _ts__bindgen_ty_1 {
    method initialized (line 1598) | pub fn initialized(&self) -> ::std::os::raw::c_uint {
    method set_initialized (line 1602) | pub fn set_initialized(&mut self, val: ::std::os::raw::c_uint) {
    method initialized_raw (line 1609) | pub unsafe fn initialized_raw(this: *const Self) -> ::std::os::raw::c_...
    method set_initialized_raw (line 1619) | pub unsafe fn set_initialized_raw(this: *mut Self, val: ::std::os::raw...
    method bound (line 1631) | pub fn bound(&self) -> ::std::os::raw::c_uint {
    method set_bound (line 1635) | pub fn set_bound(&mut self, val: ::std::os::raw::c_uint) {
    method bound_raw (line 1642) | pub unsafe fn bound_raw(this: *const Self) -> ::std::os::raw::c_uint {
    method set_bound_raw (line 1652) | pub unsafe fn set_bound_raw(this: *mut Self, val: ::std::os::raw::c_ui...
    method unbound (line 1664) | pub fn unbound(&self) -> ::std::os::raw::c_uint {
    method set_unbound (line 1668) | pub fn set_unbound(&mut self, val: ::std::os::raw::c_uint) {
    method unbound_raw (line 1675) | pub unsafe fn unbound_raw(this: *const Self) -> ::std::os::raw::c_uint {
    method set_unbound_raw (line 1685) | pub unsafe fn set_unbound_raw(this: *mut Self, val: ::std::os::raw::c_...
    method bound_gilstate (line 1697) | pub fn bound_gilstate(&self) -> ::std::os::raw::c_uint {
    method set_bound_gilstate (line 1701) | pub fn set_bound_gilstate(&mut self, val: ::std::os::raw::c_uint) {
    method bound_gilstate_raw (line 1708) | pub unsafe fn bound_gilstate_raw(this: *const Self) -> ::std::os::raw:...
    method set_bound_gilstate_raw (line 1718) | pub unsafe fn set_bound_gilstate_raw(this: *mut Self, val: ::std::os::...
    method active (line 1730) | pub fn active(&self) -> ::std::os::raw::c_uint {
    method set_active (line 1734) | pub fn set_active(&mut self, val: ::std::os::raw::c_uint) {
    method active_raw (line 1741) | pub unsafe fn active_raw(this: *const Self) -> ::std::os::raw::c_uint {
    method set_active_raw (line 1751) | pub unsafe fn set_active_raw(this: *mut Self, val: ::std::os::raw::c_u...
    method finalizing (line 1763) | pub fn finalizing(&self) -> ::std::os::raw::c_uint {
    method set_finalizing (line 1767) | pub fn set_finalizing(&mut self, val: ::std::os::raw::c_uint) {
    method finalizing_raw (line 1774) | pub unsafe fn finalizing_raw(this: *const Self) -> ::std::os::raw::c_u...
    method set_finalizing_raw (line 1784) | pub unsafe fn set_finalizing_raw(this: *mut Self, val: ::std::os::raw:...
    method cleared (line 1796) | pub fn cleared(&self) -> ::std::os::raw::c_uint {
    method set_cleared (line 1800) | pub fn set_cleared(&mut self, val: ::std::os::raw::c_uint) {
    method cleared_raw (line 1807) | pub unsafe fn cleared_raw(this: *const Self) -> ::std::os::raw::c_uint {
    method set_cleared_raw (line 1817) | pub unsafe fn set_cleared_raw(this: *mut Self, val: ::std::os::raw::c_...
    method finalized (line 1829) | pub fn finalized(&self) -> ::std::os::raw::c_uint {
    method set_finalized (line 1833) | pub fn set_finalized(&mut self, val: ::std::os::raw::c_uint) {
    method finalized_raw (line 1840) | pub unsafe fn finalized_raw(this: *const Self) -> ::std::os::raw::c_ui...
    method set_finalized_raw (line 1850) | pub unsafe fn set_finalized_raw(this: *mut Self, val: ::std::os::raw::...
    method new_bitfield_1 (line 1862) | pub fn new_bitfield_1(
  method default (line 1909) | fn default() -> Self {
  type _PyFrameEvalFunction (line 1917) | pub type _PyFrameEvalFunction = ::std::option::Option<
  type _PyCrossInterpreterData (line 1924) | pub type _PyCrossInterpreterData = _xid;
  type xid_newobjectfunc (line 1925) | pub type xid_newobjectfunc = ::std::option::Option<
  type xid_freefunc (line 1928) | pub type xid_freefunc =
  type _xid (line 1932) | pub struct _xid {
  method default (line 1940) | fn default() -> Self {
  type crossinterpdatafunc (line 1948) | pub type crossinterpdatafunc = ::std::option::Option<
  type getter (line 1955) | pub type getter = ::std::option::Option<
  type setter (line 1958) | pub type setter = ::std::option::Option<
  type PyGetSetDef (line 1967) | pub struct PyGetSetDef {
  method default (line 1975) | fn default() -> Self {
  type PyMemberDef (line 1985) | pub struct PyMemberDef {
  method default (line 1993) | fn default() -> Self {
  type wrapperfunc (line 2001) | pub type wrapperfunc = ::std::option::Option<
  type wrapperbase (line 2010) | pub struct wrapperbase {
  method default (line 2020) | fn default() -> Self {
  type _PyTime_t (line 2028) | pub type _PyTime_t = i64;
  type PyBaseExceptionObject (line 2031) | pub struct PyBaseExceptionObject {
  method default (line 2042) | fn default() -> Self {
  type PyThread_type_lock (line 2050) | pub type PyThread_type_lock = *mut ::std::os::raw::c_void;
  type Py_tss_t (line 2051) | pub type Py_tss_t = _Py_tss_t;
  type _Py_tss_t (line 2054) | pub struct _Py_tss_t {
  type _PyArg_Parser (line 2060) | pub struct _PyArg_Parser {
  method default (line 2073) | fn default() -> Self {
  type atexit_datacallbackfunc (line 2081) | pub type atexit_datacallbackfunc =
  type Py_AuditHookFunction (line 2083) | pub type Py_AuditHookFunction = ::std::option::Option<
  type _inittab (line 2092) | pub struct _inittab {
  method default (line 2097) | fn default() -> Self {
  type ast_state (line 2107) | pub struct ast_state {
  method default (line 2355) | fn default() -> Self {
  type atexit_callbackfunc (line 2363) | pub type atexit_callbackfunc = ::std::option::Option<unsafe extern "C" f...
  type _atexit_runtime_state (line 2366) | pub struct _atexit_runtime_state {
  method default (line 2372) | fn default() -> Self {
  type atexit_callback (line 2382) | pub struct atexit_callback {
  method default (line 2388) | fn default() -> Self {
  type atexit_py_callback (line 2398) | pub struct atexit_py_callback {
  method default (line 2404) | fn default() -> Self {
  type atexit_state (line 2414) | pub struct atexit_state {
  method default (line 2422) | fn default() -> Self {
  type _Py_atomic_address (line 2432) | pub struct _Py_atomic_address {
  type _Py_atomic_int (line 2437) | pub struct _Py_atomic_int {
  type _gil_runtime_state (line 2442) | pub struct _gil_runtime_state {
  method default (line 2453) | fn default() -> Self {
  type _pending_calls (line 2463) | pub struct _pending_calls {
  type _pending_calls__pending_call (line 2474) | pub struct _pending_calls__pending_call {
  method default (line 2481) | fn default() -> Self {
  method default (line 2490) | fn default() -> Self {
  type _ceval_runtime_state (line 2500) | pub struct _ceval_runtime_state {
  type _ceval_runtime_state__bindgen_ty_1 (line 2507) | pub struct _ceval_runtime_state__bindgen_ty_1 {
  method default (line 2511) | fn default() -> Self {
  type _ceval_state (line 2521) | pub struct _ceval_state {
  method default (line 2531) | fn default() -> Self {
  type callable_cache (line 2541) | pub struct callable_cache {
  method default (line 2548) | fn default() -> Self {
  type PyHamtNode (line 2558) | pub struct PyHamtNode {
  method default (line 2562) | fn default() -> Self {
  type PyHamtObject (line 2572) | pub struct PyHamtObject {
  method default (line 2579) | fn default() -> Self {
  type PyHamtNode_Bitmap (line 2589) | pub struct PyHamtNode_Bitmap {
  method default (line 2595) | fn default() -> Self {
  type _PyContextTokenMissing (line 2605) | pub struct _PyContextTokenMissing {
  method default (line 2609) | fn default() -> Self {
  type _Py_context_state (line 2619) | pub struct _Py_context_state {}
  type _Py_dict_state (line 2622) | pub struct _Py_dict_state {
  type ULong (line 2627) | pub type ULong = u32;
  type Bigint (line 2630) | pub struct Bigint {
  method default (line 2639) | fn default() -> Self {
  type _dtoa_state (line 2649) | pub struct _dtoa_state {
  method default (line 2656) | fn default() -> Self {
  type _Py_exc_state (line 2666) | pub struct _Py_exc_state {
  method default (line 2673) | fn default() -> Self {
  constant _py_float_format_type__py_float_format_unknown (line 2681) | pub const _py_float_format_type__py_float_format_unknown: _py_float_form...
  constant _py_float_format_type__py_float_format_ieee_big_endian (line 2682) | pub const _py_float_format_type__py_float_format_ieee_big_endian: _py_fl...
  constant _py_float_format_type__py_float_format_ieee_little_endian (line 2683) | pub const _py_float_format_type__py_float_format_ieee_little_endian: _py...
  type _py_float_format_type (line 2684) | pub type _py_float_format_type = ::std::os::raw::c_uint;
  type _Py_float_runtime_state (line 2687) | pub struct _Py_float_runtime_state {
  method default (line 2692) | fn default() -> Self {
  type _Py_float_state (line 2702) | pub struct _Py_float_state {}
  type _py_func_state (line 2705) | pub struct _py_func_state {
  type _Py_async_gen_state (line 2710) | pub struct _Py_async_gen_state {}
  type PyGC_Head (line 2713) | pub struct PyGC_Head {
  type gc_generation (line 2719) | pub struct gc_generation {
  type gc_generation_stats (line 2726) | pub struct gc_generation_stats {
  type _gc_runtime_state (line 2733) | pub struct _gc_runtime_state {
  method default (line 2749) | fn default() -> Self {
  type _Py_global_strings (line 2759) | pub struct _Py_global_strings {
  type _Py_global_strings__bindgen_ty_1 (line 2767) | pub struct _Py_global_strings__bindgen_ty_1 {
  type _Py_global_strings__bindgen_ty_1__bindgen_ty_1 (line 2797) | pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_1 {
  method default (line 2802) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_1__bindgen_ty_2 (line 2812) | pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_2 {
  method default (line 2817) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_1__bindgen_ty_3 (line 2827) | pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_3 {
  method default (line 2832) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_1__bindgen_ty_4 (line 2842) | pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_4 {
  method default (line 2847) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_1__bindgen_ty_5 (line 2857) | pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_5 {
  method default (line 2862) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_1__bindgen_ty_6 (line 2872) | pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_6 {
  method default (line 2877) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_1__bindgen_ty_7 (line 2887) | pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_7 {
  method default (line 2892) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_1__bindgen_ty_8 (line 2902) | pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_8 {
  method default (line 2907) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_1__bindgen_ty_9 (line 2917) | pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_9 {
  method default (line 2922) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_1__bindgen_ty_10 (line 2932) | pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_10 {
  method default (line 2937) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_1__bindgen_ty_11 (line 2947) | pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_11 {
  method default (line 2952) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_1__bindgen_ty_12 (line 2962) | pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_12 {
  method default (line 2967) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_1__bindgen_ty_13 (line 2977) | pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_13 {
  method default (line 2982) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_1__bindgen_ty_14 (line 2992) | pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_14 {
  method default (line 2997) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_1__bindgen_ty_15 (line 3007) | pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_15 {
  method default (line 3012) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_1__bindgen_ty_16 (line 3022) | pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_16 {
  method default (line 3027) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_1__bindgen_ty_17 (line 3037) | pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_17 {
  method default (line 3042) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_1__bindgen_ty_18 (line 3052) | pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_18 {
  method default (line 3057) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_1__bindgen_ty_19 (line 3067) | pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_19 {
  method default (line 3072) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_1__bindgen_ty_20 (line 3082) | pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_20 {
  method default (line 3087) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_1__bindgen_ty_21 (line 3097) | pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_21 {
  method default (line 3102) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_1__bindgen_ty_22 (line 3112) | pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_22 {
  method default (line 3117) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_1__bindgen_ty_23 (line 3127) | pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_23 {
  method default (line 3132) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_1__bindgen_ty_24 (line 3142) | pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_24 {
  method default (line 3147) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_1__bindgen_ty_25 (line 3157) | pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_25 {
  method default (line 3162) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_1__bindgen_ty_26 (line 3172) | pub struct _Py_global_strings__bindgen_ty_1__bindgen_ty_26 {
  method default (line 3177) | fn default() -> Self {
  method default (line 3186) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2 (line 3196) | pub struct _Py_global_strings__bindgen_ty_2 {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_1 (line 3891) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_1 {
  method default (line 3896) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_2 (line 3906) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_2 {
  method default (line 3911) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_3 (line 3921) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_3 {
  method default (line 3926) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_4 (line 3936) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_4 {
  method default (line 3941) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_5 (line 3951) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_5 {
  method default (line 3956) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_6 (line 3966) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_6 {
  method default (line 3971) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_7 (line 3981) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_7 {
  method default (line 3986) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_8 (line 3996) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_8 {
  method default (line 4001) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_9 (line 4011) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_9 {
  method default (line 4016) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_10 (line 4026) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_10 {
  method default (line 4031) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_11 (line 4041) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_11 {
  method default (line 4046) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_12 (line 4056) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_12 {
  method default (line 4061) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_13 (line 4071) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_13 {
  method default (line 4076) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_14 (line 4086) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_14 {
  method default (line 4091) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_15 (line 4101) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_15 {
  method default (line 4106) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_16 (line 4116) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_16 {
  method default (line 4121) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_17 (line 4131) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_17 {
  method default (line 4136) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_18 (line 4146) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_18 {
  method default (line 4151) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_19 (line 4161) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_19 {
  method default (line 4166) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_20 (line 4176) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_20 {
  method default (line 4181) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_21 (line 4191) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_21 {
  method default (line 4196) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_22 (line 4206) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_22 {
  method default (line 4211) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_23 (line 4221) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_23 {
  method default (line 4226) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_24 (line 4236) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_24 {
  method default (line 4241) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_25 (line 4251) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_25 {
  method default (line 4256) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_26 (line 4266) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_26 {
  method default (line 4271) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_27 (line 4281) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_27 {
  method default (line 4286) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_28 (line 4296) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_28 {
  method default (line 4301) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_29 (line 4311) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_29 {
  method default (line 4316) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_30 (line 4326) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_30 {
  method default (line 4331) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_31 (line 4341) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_31 {
  method default (line 4346) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_32 (line 4356) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_32 {
  method default (line 4361) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_33 (line 4371) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_33 {
  method default (line 4376) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_34 (line 4386) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_34 {
  method default (line 4391) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_35 (line 4401) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_35 {
  method default (line 4406) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_36 (line 4416) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_36 {
  method default (line 4421) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_37 (line 4431) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_37 {
  method default (line 4436) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_38 (line 4446) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_38 {
  method default (line 4451) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_39 (line 4461) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_39 {
  method default (line 4466) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_40 (line 4476) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_40 {
  method default (line 4481) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_41 (line 4491) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_41 {
  method default (line 4496) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_42 (line 4506) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_42 {
  method default (line 4511) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_43 (line 4521) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_43 {
  method default (line 4526) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_44 (line 4536) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_44 {
  method default (line 4541) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_45 (line 4551) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_45 {
  method default (line 4556) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_46 (line 4566) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_46 {
  method default (line 4571) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_47 (line 4581) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_47 {
  method default (line 4586) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_48 (line 4596) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_48 {
  method default (line 4601) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_49 (line 4611) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_49 {
  method default (line 4616) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_50 (line 4626) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_50 {
  method default (line 4631) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_51 (line 4641) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_51 {
  method default (line 4646) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_52 (line 4656) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_52 {
  method default (line 4661) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_53 (line 4671) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_53 {
  method default (line 4676) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_54 (line 4686) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_54 {
  method default (line 4691) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_55 (line 4701) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_55 {
  method default (line 4706) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_56 (line 4716) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_56 {
  method default (line 4721) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_57 (line 4731) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_57 {
  method default (line 4736) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_58 (line 4746) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_58 {
  method default (line 4751) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_59 (line 4761) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_59 {
  method default (line 4766) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_60 (line 4776) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_60 {
  method default (line 4781) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_61 (line 4791) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_61 {
  method default (line 4796) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_62 (line 4806) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_62 {
  method default (line 4811) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_63 (line 4821) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_63 {
  method default (line 4826) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_64 (line 4836) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_64 {
  method default (line 4841) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_65 (line 4851) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_65 {
  method default (line 4856) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_66 (line 4866) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_66 {
  method default (line 4871) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_67 (line 4881) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_67 {
  method default (line 4886) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_68 (line 4896) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_68 {
  method default (line 4901) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_69 (line 4911) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_69 {
  method default (line 4916) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_70 (line 4926) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_70 {
  method default (line 4931) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_71 (line 4941) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_71 {
  method default (line 4946) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_72 (line 4956) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_72 {
  method default (line 4961) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_73 (line 4971) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_73 {
  method default (line 4976) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_74 (line 4986) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_74 {
  method default (line 4991) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_75 (line 5001) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_75 {
  method default (line 5006) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_76 (line 5016) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_76 {
  method default (line 5021) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_77 (line 5031) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_77 {
  method default (line 5036) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_78 (line 5046) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_78 {
  method default (line 5051) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_79 (line 5061) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_79 {
  method default (line 5066) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_80 (line 5076) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_80 {
  method default (line 5081) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_81 (line 5091) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_81 {
  method default (line 5096) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_82 (line 5106) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_82 {
  method default (line 5111) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_83 (line 5121) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_83 {
  method default (line 5126) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_84 (line 5136) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_84 {
  method default (line 5141) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_85 (line 5151) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_85 {
  method default (line 5156) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_86 (line 5166) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_86 {
  method default (line 5171) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_87 (line 5181) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_87 {
  method default (line 5186) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_88 (line 5196) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_88 {
  method default (line 5201) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_89 (line 5211) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_89 {
  method default (line 5216) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_90 (line 5226) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_90 {
  method default (line 5231) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_91 (line 5241) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_91 {
  method default (line 5246) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_92 (line 5256) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_92 {
  method default (line 5261) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_93 (line 5271) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_93 {
  method default (line 5276) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_94 (line 5286) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_94 {
  method default (line 5291) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_95 (line 5301) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_95 {
  method default (line 5306) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_96 (line 5316) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_96 {
  method default (line 5321) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_97 (line 5331) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_97 {
  method default (line 5336) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_98 (line 5346) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_98 {
  method default (line 5351) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_99 (line 5361) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_99 {
  method default (line 5366) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_100 (line 5376) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_100 {
  method default (line 5381) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_101 (line 5391) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_101 {
  method default (line 5396) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_102 (line 5406) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_102 {
  method default (line 5411) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_103 (line 5421) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_103 {
  method default (line 5426) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_104 (line 5436) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_104 {
  method default (line 5441) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_105 (line 5451) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_105 {
  method default (line 5456) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_106 (line 5466) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_106 {
  method default (line 5471) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_107 (line 5481) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_107 {
  method default (line 5486) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_108 (line 5496) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_108 {
  method default (line 5501) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_109 (line 5511) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_109 {
  method default (line 5516) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_110 (line 5526) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_110 {
  method default (line 5531) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_111 (line 5541) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_111 {
  method default (line 5546) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_112 (line 5556) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_112 {
  method default (line 5561) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_113 (line 5571) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_113 {
  method default (line 5576) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_114 (line 5586) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_114 {
  method default (line 5591) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_115 (line 5601) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_115 {
  method default (line 5606) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_116 (line 5616) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_116 {
  method default (line 5621) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_117 (line 5631) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_117 {
  method default (line 5636) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_118 (line 5646) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_118 {
  method default (line 5651) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_119 (line 5661) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_119 {
  method default (line 5666) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_120 (line 5676) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_120 {
  method default (line 5681) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_121 (line 5691) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_121 {
  method default (line 5696) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_122 (line 5706) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_122 {
  method default (line 5711) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_123 (line 5721) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_123 {
  method default (line 5726) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_124 (line 5736) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_124 {
  method default (line 5741) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_125 (line 5751) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_125 {
  method default (line 5756) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_126 (line 5766) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_126 {
  method default (line 5771) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_127 (line 5781) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_127 {
  method default (line 5786) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_128 (line 5796) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_128 {
  method default (line 5801) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_129 (line 5811) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_129 {
  method default (line 5816) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_130 (line 5826) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_130 {
  method default (line 5831) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_131 (line 5841) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_131 {
  method default (line 5846) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_132 (line 5856) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_132 {
  method default (line 5861) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_133 (line 5871) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_133 {
  method default (line 5876) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_134 (line 5886) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_134 {
  method default (line 5891) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_135 (line 5901) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_135 {
  method default (line 5906) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_136 (line 5916) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_136 {
  method default (line 5921) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_137 (line 5931) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_137 {
  method default (line 5936) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_138 (line 5946) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_138 {
  method default (line 5951) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_139 (line 5961) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_139 {
  method default (line 5966) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_140 (line 5976) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_140 {
  method default (line 5981) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_141 (line 5991) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_141 {
  method default (line 5996) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_142 (line 6006) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_142 {
  method default (line 6011) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_143 (line 6021) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_143 {
  method default (line 6026) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_144 (line 6036) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_144 {
  method default (line 6041) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_145 (line 6051) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_145 {
  method default (line 6056) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_146 (line 6066) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_146 {
  method default (line 6071) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_147 (line 6081) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_147 {
  method default (line 6086) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_148 (line 6096) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_148 {
  method default (line 6101) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_149 (line 6111) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_149 {
  method default (line 6116) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_150 (line 6126) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_150 {
  method default (line 6131) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_151 (line 6141) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_151 {
  method default (line 6146) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_152 (line 6156) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_152 {
  method default (line 6161) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_153 (line 6171) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_153 {
  method default (line 6176) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_154 (line 6186) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_154 {
  method default (line 6191) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_155 (line 6201) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_155 {
  method default (line 6206) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_156 (line 6216) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_156 {
  method default (line 6221) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_157 (line 6231) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_157 {
  method default (line 6236) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_158 (line 6246) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_158 {
  method default (line 6251) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_159 (line 6261) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_159 {
  method default (line 6266) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_160 (line 6276) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_160 {
  method default (line 6281) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_161 (line 6291) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_161 {
  method default (line 6296) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_162 (line 6306) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_162 {
  method default (line 6311) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_163 (line 6321) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_163 {
  method default (line 6326) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_164 (line 6336) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_164 {
  method default (line 6341) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_165 (line 6351) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_165 {
  method default (line 6356) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_166 (line 6366) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_166 {
  method default (line 6371) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_167 (line 6381) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_167 {
  method default (line 6386) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_168 (line 6396) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_168 {
  method default (line 6401) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_169 (line 6411) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_169 {
  method default (line 6416) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_170 (line 6426) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_170 {
  method default (line 6431) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_171 (line 6441) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_171 {
  method default (line 6446) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_172 (line 6456) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_172 {
  method default (line 6461) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_173 (line 6471) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_173 {
  method default (line 6476) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_174 (line 6486) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_174 {
  method default (line 6491) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_175 (line 6501) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_175 {
  method default (line 6506) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_176 (line 6516) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_176 {
  method default (line 6521) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_177 (line 6531) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_177 {
  method default (line 6536) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_178 (line 6546) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_178 {
  method default (line 6551) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_179 (line 6561) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_179 {
  method default (line 6566) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_180 (line 6576) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_180 {
  method default (line 6581) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_181 (line 6591) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_181 {
  method default (line 6596) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_182 (line 6606) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_182 {
  method default (line 6611) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_183 (line 6621) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_183 {
  method default (line 6626) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_184 (line 6636) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_184 {
  method default (line 6641) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_185 (line 6651) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_185 {
  method default (line 6656) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_186 (line 6666) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_186 {
  method default (line 6671) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_187 (line 6681) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_187 {
  method default (line 6686) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_188 (line 6696) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_188 {
  method default (line 6701) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_189 (line 6711) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_189 {
  method default (line 6716) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_190 (line 6726) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_190 {
  method default (line 6731) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_191 (line 6741) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_191 {
  method default (line 6746) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_192 (line 6756) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_192 {
  method default (line 6761) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_193 (line 6771) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_193 {
  method default (line 6776) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_194 (line 6786) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_194 {
  method default (line 6791) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_195 (line 6801) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_195 {
  method default (line 6806) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_196 (line 6816) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_196 {
  method default (line 6821) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_197 (line 6831) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_197 {
  method default (line 6836) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_198 (line 6846) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_198 {
  method default (line 6851) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_199 (line 6861) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_199 {
  method default (line 6866) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_200 (line 6876) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_200 {
  method default (line 6881) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_201 (line 6891) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_201 {
  method default (line 6896) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_202 (line 6906) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_202 {
  method default (line 6911) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_203 (line 6921) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_203 {
  method default (line 6926) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_204 (line 6936) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_204 {
  method default (line 6941) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_205 (line 6951) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_205 {
  method default (line 6956) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_206 (line 6966) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_206 {
  method default (line 6971) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_207 (line 6981) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_207 {
  method default (line 6986) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_208 (line 6996) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_208 {
  method default (line 7001) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_209 (line 7011) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_209 {
  method default (line 7016) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_210 (line 7026) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_210 {
  method default (line 7031) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_211 (line 7041) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_211 {
  method default (line 7046) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_212 (line 7056) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_212 {
  method default (line 7061) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_213 (line 7071) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_213 {
  method default (line 7076) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_214 (line 7086) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_214 {
  method default (line 7091) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_215 (line 7101) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_215 {
  method default (line 7106) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_216 (line 7116) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_216 {
  method default (line 7121) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_217 (line 7131) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_217 {
  method default (line 7136) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_218 (line 7146) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_218 {
  method default (line 7151) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_219 (line 7161) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_219 {
  method default (line 7166) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_220 (line 7176) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_220 {
  method default (line 7181) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_221 (line 7191) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_221 {
  method default (line 7196) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_222 (line 7206) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_222 {
  method default (line 7211) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_223 (line 7221) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_223 {
  method default (line 7226) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_224 (line 7236) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_224 {
  method default (line 7241) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_225 (line 7251) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_225 {
  method default (line 7256) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_226 (line 7266) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_226 {
  method default (line 7271) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_227 (line 7281) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_227 {
  method default (line 7286) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_228 (line 7296) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_228 {
  method default (line 7301) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_229 (line 7311) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_229 {
  method default (line 7316) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_230 (line 7326) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_230 {
  method default (line 7331) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_231 (line 7341) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_231 {
  method default (line 7346) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_232 (line 7356) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_232 {
  method default (line 7361) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_233 (line 7371) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_233 {
  method default (line 7376) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_234 (line 7386) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_234 {
  method default (line 7391) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_235 (line 7401) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_235 {
  method default (line 7406) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_236 (line 7416) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_236 {
  method default (line 7421) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_237 (line 7431) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_237 {
  method default (line 7436) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_238 (line 7446) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_238 {
  method default (line 7451) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_239 (line 7461) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_239 {
  method default (line 7466) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_240 (line 7476) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_240 {
  method default (line 7481) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_241 (line 7491) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_241 {
  method default (line 7496) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_242 (line 7506) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_242 {
  method default (line 7511) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_243 (line 7521) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_243 {
  method default (line 7526) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_244 (line 7536) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_244 {
  method default (line 7541) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_245 (line 7551) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_245 {
  method default (line 7556) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_246 (line 7566) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_246 {
  method default (line 7571) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_247 (line 7581) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_247 {
  method default (line 7586) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_248 (line 7596) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_248 {
  method default (line 7601) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_249 (line 7611) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_249 {
  method default (line 7616) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_250 (line 7626) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_250 {
  method default (line 7631) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_251 (line 7641) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_251 {
  method default (line 7646) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_252 (line 7656) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_252 {
  method default (line 7661) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_253 (line 7671) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_253 {
  method default (line 7676) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_254 (line 7686) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_254 {
  method default (line 7691) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_255 (line 7701) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_255 {
  method default (line 7706) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_256 (line 7716) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_256 {
  method default (line 7721) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_257 (line 7731) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_257 {
  method default (line 7736) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_258 (line 7746) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_258 {
  method default (line 7751) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_259 (line 7761) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_259 {
  method default (line 7766) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_260 (line 7776) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_260 {
  method default (line 7781) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_261 (line 7791) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_261 {
  method default (line 7796) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_262 (line 7806) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_262 {
  method default (line 7811) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_263 (line 7821) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_263 {
  method default (line 7826) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_264 (line 7836) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_264 {
  method default (line 7841) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_265 (line 7851) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_265 {
  method default (line 7856) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_266 (line 7866) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_266 {
  method default (line 7871) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_267 (line 7881) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_267 {
  method default (line 7886) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_268 (line 7896) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_268 {
  method default (line 7901) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_269 (line 7911) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_269 {
  method default (line 7916) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_270 (line 7926) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_270 {
  method default (line 7931) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_271 (line 7941) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_271 {
  method default (line 7946) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_272 (line 7956) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_272 {
  method default (line 7961) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_273 (line 7971) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_273 {
  method default (line 7976) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_274 (line 7986) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_274 {
  method default (line 7991) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_275 (line 8001) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_275 {
  method default (line 8006) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_276 (line 8016) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_276 {
  method default (line 8021) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_277 (line 8031) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_277 {
  method default (line 8036) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_278 (line 8046) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_278 {
  method default (line 8051) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_279 (line 8061) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_279 {
  method default (line 8066) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_280 (line 8076) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_280 {
  method default (line 8081) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_281 (line 8091) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_281 {
  method default (line 8096) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_282 (line 8106) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_282 {
  method default (line 8111) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_283 (line 8121) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_283 {
  method default (line 8126) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_284 (line 8136) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_284 {
  method default (line 8141) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_285 (line 8151) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_285 {
  method default (line 8156) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_286 (line 8166) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_286 {
  method default (line 8171) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_287 (line 8181) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_287 {
  method default (line 8186) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_288 (line 8196) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_288 {
  method default (line 8201) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_289 (line 8211) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_289 {
  method default (line 8216) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_290 (line 8226) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_290 {
  method default (line 8231) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_291 (line 8241) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_291 {
  method default (line 8246) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_292 (line 8256) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_292 {
  method default (line 8261) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_293 (line 8271) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_293 {
  method default (line 8276) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_294 (line 8286) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_294 {
  method default (line 8291) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_295 (line 8301) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_295 {
  method default (line 8306) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_296 (line 8316) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_296 {
  method default (line 8321) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_297 (line 8331) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_297 {
  method default (line 8336) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_298 (line 8346) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_298 {
  method default (line 8351) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_299 (line 8361) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_299 {
  method default (line 8366) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_300 (line 8376) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_300 {
  method default (line 8381) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_301 (line 8391) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_301 {
  method default (line 8396) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_302 (line 8406) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_302 {
  method default (line 8411) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_303 (line 8421) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_303 {
  method default (line 8426) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_304 (line 8436) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_304 {
  method default (line 8441) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_305 (line 8451) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_305 {
  method default (line 8456) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_306 (line 8466) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_306 {
  method default (line 8471) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_307 (line 8481) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_307 {
  method default (line 8486) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_308 (line 8496) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_308 {
  method default (line 8501) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_309 (line 8511) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_309 {
  method default (line 8516) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_310 (line 8526) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_310 {
  method default (line 8531) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_311 (line 8541) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_311 {
  method default (line 8546) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_312 (line 8556) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_312 {
  method default (line 8561) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_313 (line 8571) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_313 {
  method default (line 8576) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_314 (line 8586) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_314 {
  method default (line 8591) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_315 (line 8601) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_315 {
  method default (line 8606) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_316 (line 8616) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_316 {
  method default (line 8621) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_317 (line 8631) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_317 {
  method default (line 8636) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_318 (line 8646) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_318 {
  method default (line 8651) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_319 (line 8661) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_319 {
  method default (line 8666) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_320 (line 8676) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_320 {
  method default (line 8681) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_321 (line 8691) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_321 {
  method default (line 8696) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_322 (line 8706) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_322 {
  method default (line 8711) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_323 (line 8721) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_323 {
  method default (line 8726) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_324 (line 8736) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_324 {
  method default (line 8741) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_325 (line 8751) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_325 {
  method default (line 8756) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_326 (line 8766) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_326 {
  method default (line 8771) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_327 (line 8781) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_327 {
  method default (line 8786) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_328 (line 8796) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_328 {
  method default (line 8801) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_329 (line 8811) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_329 {
  method default (line 8816) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_330 (line 8826) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_330 {
  method default (line 8831) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_331 (line 8841) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_331 {
  method default (line 8846) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_332 (line 8856) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_332 {
  method default (line 8861) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_333 (line 8871) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_333 {
  method default (line 8876) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_334 (line 8886) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_334 {
  method default (line 8891) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_335 (line 8901) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_335 {
  method default (line 8906) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_336 (line 8916) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_336 {
  method default (line 8921) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_337 (line 8931) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_337 {
  method default (line 8936) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_338 (line 8946) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_338 {
  method default (line 8951) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_339 (line 8961) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_339 {
  method default (line 8966) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_340 (line 8976) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_340 {
  method default (line 8981) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_341 (line 8991) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_341 {
  method default (line 8996) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_342 (line 9006) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_342 {
  method default (line 9011) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_343 (line 9021) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_343 {
  method default (line 9026) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_344 (line 9036) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_344 {
  method default (line 9041) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_345 (line 9051) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_345 {
  method default (line 9056) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_346 (line 9066) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_346 {
  method default (line 9071) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_347 (line 9081) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_347 {
  method default (line 9086) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_348 (line 9096) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_348 {
  method default (line 9101) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_349 (line 9111) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_349 {
  method default (line 9116) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_350 (line 9126) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_350 {
  method default (line 9131) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_351 (line 9141) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_351 {
  method default (line 9146) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_352 (line 9156) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_352 {
  method default (line 9161) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_353 (line 9171) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_353 {
  method default (line 9176) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_354 (line 9186) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_354 {
  method default (line 9191) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_355 (line 9201) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_355 {
  method default (line 9206) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_356 (line 9216) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_356 {
  method default (line 9221) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_357 (line 9231) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_357 {
  method default (line 9236) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_358 (line 9246) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_358 {
  method default (line 9251) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_359 (line 9261) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_359 {
  method default (line 9266) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_360 (line 9276) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_360 {
  method default (line 9281) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_361 (line 9291) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_361 {
  method default (line 9296) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_362 (line 9306) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_362 {
  method default (line 9311) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_363 (line 9321) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_363 {
  method default (line 9326) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_364 (line 9336) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_364 {
  method default (line 9341) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_365 (line 9351) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_365 {
  method default (line 9356) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_366 (line 9366) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_366 {
  method default (line 9371) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_367 (line 9381) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_367 {
  method default (line 9386) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_368 (line 9396) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_368 {
  method default (line 9401) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_369 (line 9411) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_369 {
  method default (line 9416) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_370 (line 9426) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_370 {
  method default (line 9431) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_371 (line 9441) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_371 {
  method default (line 9446) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_372 (line 9456) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_372 {
  method default (line 9461) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_373 (line 9471) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_373 {
  method default (line 9476) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_374 (line 9486) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_374 {
  method default (line 9491) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_375 (line 9501) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_375 {
  method default (line 9506) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_376 (line 9516) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_376 {
  method default (line 9521) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_377 (line 9531) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_377 {
  method default (line 9536) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_378 (line 9546) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_378 {
  method default (line 9551) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_379 (line 9561) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_379 {
  method default (line 9566) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_380 (line 9576) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_380 {
  method default (line 9581) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_381 (line 9591) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_381 {
  method default (line 9596) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_382 (line 9606) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_382 {
  method default (line 9611) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_383 (line 9621) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_383 {
  method default (line 9626) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_384 (line 9636) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_384 {
  method default (line 9641) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_385 (line 9651) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_385 {
  method default (line 9656) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_386 (line 9666) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_386 {
  method default (line 9671) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_387 (line 9681) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_387 {
  method default (line 9686) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_388 (line 9696) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_388 {
  method default (line 9701) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_389 (line 9711) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_389 {
  method default (line 9716) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_390 (line 9726) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_390 {
  method default (line 9731) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_391 (line 9741) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_391 {
  method default (line 9746) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_392 (line 9756) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_392 {
  method default (line 9761) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_393 (line 9771) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_393 {
  method default (line 9776) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_394 (line 9786) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_394 {
  method default (line 9791) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_395 (line 9801) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_395 {
  method default (line 9806) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_396 (line 9816) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_396 {
  method default (line 9821) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_397 (line 9831) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_397 {
  method default (line 9836) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_398 (line 9846) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_398 {
  method default (line 9851) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_399 (line 9861) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_399 {
  method default (line 9866) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_400 (line 9876) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_400 {
  method default (line 9881) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_401 (line 9891) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_401 {
  method default (line 9896) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_402 (line 9906) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_402 {
  method default (line 9911) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_403 (line 9921) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_403 {
  method default (line 9926) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_404 (line 9936) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_404 {
  method default (line 9941) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_405 (line 9951) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_405 {
  method default (line 9956) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_406 (line 9966) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_406 {
  method default (line 9971) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_407 (line 9981) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_407 {
  method default (line 9986) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_408 (line 9996) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_408 {
  method default (line 10001) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_409 (line 10011) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_409 {
  method default (line 10016) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_410 (line 10026) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_410 {
  method default (line 10031) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_411 (line 10041) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_411 {
  method default (line 10046) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_412 (line 10056) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_412 {
  method default (line 10061) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_413 (line 10071) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_413 {
  method default (line 10076) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_414 (line 10086) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_414 {
  method default (line 10091) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_415 (line 10101) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_415 {
  method default (line 10106) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_416 (line 10116) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_416 {
  method default (line 10121) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_417 (line 10131) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_417 {
  method default (line 10136) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_418 (line 10146) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_418 {
  method default (line 10151) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_419 (line 10161) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_419 {
  method default (line 10166) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_420 (line 10176) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_420 {
  method default (line 10181) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_421 (line 10191) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_421 {
  method default (line 10196) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_422 (line 10206) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_422 {
  method default (line 10211) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_423 (line 10221) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_423 {
  method default (line 10226) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_424 (line 10236) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_424 {
  method default (line 10241) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_425 (line 10251) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_425 {
  method default (line 10256) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_426 (line 10266) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_426 {
  method default (line 10271) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_427 (line 10281) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_427 {
  method default (line 10286) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_428 (line 10296) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_428 {
  method default (line 10301) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_429 (line 10311) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_429 {
  method default (line 10316) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_430 (line 10326) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_430 {
  method default (line 10331) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_431 (line 10341) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_431 {
  method default (line 10346) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_432 (line 10356) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_432 {
  method default (line 10361) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_433 (line 10371) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_433 {
  method default (line 10376) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_434 (line 10386) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_434 {
  method default (line 10391) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_435 (line 10401) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_435 {
  method default (line 10406) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_436 (line 10416) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_436 {
  method default (line 10421) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_437 (line 10431) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_437 {
  method default (line 10436) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_438 (line 10446) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_438 {
  method default (line 10451) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_439 (line 10461) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_439 {
  method default (line 10466) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_440 (line 10476) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_440 {
  method default (line 10481) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_441 (line 10491) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_441 {
  method default (line 10496) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_442 (line 10506) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_442 {
  method default (line 10511) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_443 (line 10521) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_443 {
  method default (line 10526) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_444 (line 10536) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_444 {
  method default (line 10541) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_445 (line 10551) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_445 {
  method default (line 10556) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_446 (line 10566) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_446 {
  method default (line 10571) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_447 (line 10581) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_447 {
  method default (line 10586) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_448 (line 10596) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_448 {
  method default (line 10601) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_449 (line 10611) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_449 {
  method default (line 10616) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_450 (line 10626) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_450 {
  method default (line 10631) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_451 (line 10641) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_451 {
  method default (line 10646) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_452 (line 10656) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_452 {
  method default (line 10661) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_453 (line 10671) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_453 {
  method default (line 10676) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_454 (line 10686) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_454 {
  method default (line 10691) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_455 (line 10701) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_455 {
  method default (line 10706) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_456 (line 10716) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_456 {
  method default (line 10721) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_457 (line 10731) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_457 {
  method default (line 10736) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_458 (line 10746) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_458 {
  method default (line 10751) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_459 (line 10761) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_459 {
  method default (line 10766) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_460 (line 10776) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_460 {
  method default (line 10781) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_461 (line 10791) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_461 {
  method default (line 10796) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_462 (line 10806) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_462 {
  method default (line 10811) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_463 (line 10821) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_463 {
  method default (line 10826) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_464 (line 10836) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_464 {
  method default (line 10841) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_465 (line 10851) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_465 {
  method default (line 10856) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_466 (line 10866) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_466 {
  method default (line 10871) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_467 (line 10881) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_467 {
  method default (line 10886) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_468 (line 10896) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_468 {
  method default (line 10901) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_469 (line 10911) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_469 {
  method default (line 10916) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_470 (line 10926) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_470 {
  method default (line 10931) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_471 (line 10941) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_471 {
  method default (line 10946) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_472 (line 10956) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_472 {
  method default (line 10961) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_473 (line 10971) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_473 {
  method default (line 10976) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_474 (line 10986) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_474 {
  method default (line 10991) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_475 (line 11001) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_475 {
  method default (line 11006) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_476 (line 11016) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_476 {
  method default (line 11021) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_477 (line 11031) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_477 {
  method default (line 11036) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_478 (line 11046) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_478 {
  method default (line 11051) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_479 (line 11061) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_479 {
  method default (line 11066) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_480 (line 11076) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_480 {
  method default (line 11081) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_481 (line 11091) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_481 {
  method default (line 11096) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_482 (line 11106) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_482 {
  method default (line 11111) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_483 (line 11121) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_483 {
  method default (line 11126) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_484 (line 11136) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_484 {
  method default (line 11141) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_485 (line 11151) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_485 {
  method default (line 11156) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_486 (line 11166) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_486 {
  method default (line 11171) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_487 (line 11181) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_487 {
  method default (line 11186) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_488 (line 11196) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_488 {
  method default (line 11201) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_489 (line 11211) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_489 {
  method default (line 11216) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_490 (line 11226) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_490 {
  method default (line 11231) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_491 (line 11241) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_491 {
  method default (line 11246) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_492 (line 11256) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_492 {
  method default (line 11261) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_493 (line 11271) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_493 {
  method default (line 11276) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_494 (line 11286) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_494 {
  method default (line 11291) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_495 (line 11301) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_495 {
  method default (line 11306) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_496 (line 11316) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_496 {
  method default (line 11321) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_497 (line 11331) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_497 {
  method default (line 11336) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_498 (line 11346) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_498 {
  method default (line 11351) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_499 (line 11361) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_499 {
  method default (line 11366) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_500 (line 11376) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_500 {
  method default (line 11381) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_501 (line 11391) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_501 {
  method default (line 11396) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_502 (line 11406) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_502 {
  method default (line 11411) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_503 (line 11421) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_503 {
  method default (line 11426) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_504 (line 11436) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_504 {
  method default (line 11441) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_505 (line 11451) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_505 {
  method default (line 11456) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_506 (line 11466) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_506 {
  method default (line 11471) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_507 (line 11481) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_507 {
  method default (line 11486) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_508 (line 11496) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_508 {
  method default (line 11501) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_509 (line 11511) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_509 {
  method default (line 11516) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_510 (line 11526) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_510 {
  method default (line 11531) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_511 (line 11541) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_511 {
  method default (line 11546) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_512 (line 11556) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_512 {
  method default (line 11561) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_513 (line 11571) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_513 {
  method default (line 11576) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_514 (line 11586) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_514 {
  method default (line 11591) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_515 (line 11601) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_515 {
  method default (line 11606) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_516 (line 11616) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_516 {
  method default (line 11621) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_517 (line 11631) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_517 {
  method default (line 11636) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_518 (line 11646) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_518 {
  method default (line 11651) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_519 (line 11661) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_519 {
  method default (line 11666) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_520 (line 11676) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_520 {
  method default (line 11681) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_521 (line 11691) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_521 {
  method default (line 11696) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_522 (line 11706) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_522 {
  method default (line 11711) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_523 (line 11721) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_523 {
  method default (line 11726) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_524 (line 11736) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_524 {
  method default (line 11741) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_525 (line 11751) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_525 {
  method default (line 11756) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_526 (line 11766) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_526 {
  method default (line 11771) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_527 (line 11781) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_527 {
  method default (line 11786) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_528 (line 11796) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_528 {
  method default (line 11801) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_529 (line 11811) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_529 {
  method default (line 11816) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_530 (line 11826) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_530 {
  method default (line 11831) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_531 (line 11841) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_531 {
  method default (line 11846) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_532 (line 11856) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_532 {
  method default (line 11861) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_533 (line 11871) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_533 {
  method default (line 11876) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_534 (line 11886) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_534 {
  method default (line 11891) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_535 (line 11901) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_535 {
  method default (line 11906) | fn default() -> Self {
  type _Py_global_strings__bindgen_ty_2__bindgen_ty_536 (line 11916) | pub struct _Py_global_strings__bindgen_ty_2__bindgen_ty_536 {
  method
Condensed preview — 73 files, each showing path, character count, and a content snippet. Download the .json file or copy for the full structured content (1,975K chars).
[
  {
    "path": ".cargo/config.toml",
    "chars": 74,
    "preview": "[target.armv7-unknown-linux-gnueabihf]\nlinker = \"arm-linux-gnueabihf-gcc\"\n"
  },
  {
    "path": ".github/dependabot.yml",
    "chars": 578,
    "preview": "# Keep GitHub Actions up to date with GitHub's Dependabot...\n# https://docs.github.com/en/code-security/dependabot/worki"
  },
  {
    "path": ".github/release-drafter.yml",
    "chars": 765,
    "preview": "categories:\n  - title: \"⚠ Breaking Changes\"\n    labels:\n      - \"breaking\"\n  - title: \"🚀 Features\"\n    labels:\n      - \""
  },
  {
    "path": ".github/workflows/build.yml",
    "chars": 11506,
    "preview": "name: Build\n\non:\n  workflow_dispatch:\n  push:\n    branches: [master]\n    tags:\n      - v*\n  pull_request:\n    branches: "
  },
  {
    "path": ".github/workflows/release-drafter.yml",
    "chars": 427,
    "preview": "# draft release notes with https://github.com/release-drafter/release-drafter\nname: Release Drafter\n\non:\n  push:\n    bra"
  },
  {
    "path": ".github/workflows/update_python_test.yml",
    "chars": 922,
    "preview": "name: Update Python Test Versions\non:\n  workflow_dispatch:\n  schedule:\n    - cron: \"0 1 * * *\"\njobs:\n  update-dep:\n    r"
  },
  {
    "path": ".gitignore",
    "chars": 231,
    "preview": "/target\nremoteprocess/target\n**/*.rs.bk\n\n# Python Distribution / packaging\n.Python\nenv/\nbuild/\ndevelop-eggs/\ndist/\ndownl"
  },
  {
    "path": ".pre-commit-config.yaml",
    "chars": 488,
    "preview": "repos:\n  - repo: https://github.com/codespell-project/codespell\n    rev: v2.2.4\n    hooks:\n      - id: codespell\n       "
  },
  {
    "path": "CHANGELOG.md",
    "chars": 9258,
    "preview": "# Release notes are now being hosted in Github Releases: https://github.com/benfred/py-spy/releases\n\n## v0.3.11\n\n* Updat"
  },
  {
    "path": "Cargo.toml",
    "chars": 1251,
    "preview": "[features]\nunwind = [\"remoteprocess/unwind\"]\n\n[package]\nname = \"py-spy\"\nversion = \"0.4.1\"\nauthors = [\"Ben Frederickson <"
  },
  {
    "path": "LICENSE",
    "chars": 1088,
    "preview": "The MIT License (MIT)\n\nCopyright (c) 2018-2019 Ben Frederickson\n\nPermission is hereby granted, free of charge, to any pe"
  },
  {
    "path": "README.md",
    "chars": 16424,
    "preview": "py-spy: Sampling profiler for Python programs\n=====\n[![Build Status](https://github.com/benfred/py-spy/workflows/Build/b"
  },
  {
    "path": "SECURITY.md",
    "chars": 209,
    "preview": "# Security Policy\n\n## Reporting a Vulnerability\n\nPlease email any security vulnerabilities to ben@benfrederickson.com.\n\n"
  },
  {
    "path": "build.rs",
    "chars": 367,
    "preview": "use std::env;\n\nfn main() {\n    let target_arch = env::var(\"CARGO_CFG_TARGET_ARCH\").unwrap();\n    let target_os = env::va"
  },
  {
    "path": "ci/Vagrantfile",
    "chars": 743,
    "preview": "Vagrant.configure(\"2\") do |config|\n  config.vm.define \"freebsd-14\" do |c|\n    c.vm.box = \"roboxes/freebsd14\"\n  end\n\n  co"
  },
  {
    "path": "ci/publish_freebsd.sh",
    "chars": 710,
    "preview": "#!/usr/bin/env bash\nset -ex\n\nif [[ \"$CIRRUS_RELEASE\" == \"\" ]]; then\n  echo \"Not a release. No need to deploy!\"\n  exit 0\n"
  },
  {
    "path": "ci/test_freebsd.sh",
    "chars": 500,
    "preview": "#!/usr/bin/env bash\n\nsource \"$HOME/.cargo/env\"\n\nset -e\n\npython --version\ncargo --version\n\ncd /vagrant\n\nif [ -f build-art"
  },
  {
    "path": "ci/testdata/cython_test.c",
    "chars": 203961,
    "preview": "/* Generated by Cython 0.28.5 */\n\n#define PY_SSIZE_T_CLEAN\n#include \"Python.h\"\n#ifndef Py_PYTHON_H\n    #error Python hea"
  },
  {
    "path": "ci/testdata/cython_test.pyx",
    "chars": 414,
    "preview": "\"\"\" simple test file for cython source mapping: defines a function\nthat uses newtowns method to compute the square root "
  },
  {
    "path": "ci/update_python_test_versions.py",
    "chars": 4501,
    "preview": "from collections import defaultdict\nimport requests\nimport pathlib\nimport yaml\nimport re\n\n\n_VERSIONS_URL = \"https://raw."
  },
  {
    "path": "examples/dump_traces.rs",
    "chars": 1140,
    "preview": "use log::error;\n\n// Simple example of showing how to use the rust API to\n// print out stack traces from a python program"
  },
  {
    "path": "generate_bindings.py",
    "chars": 9271,
    "preview": "\"\"\" Scripts to generate bindings of different python interpreter versions\n\nRequires bindgen to be installed (cargo insta"
  },
  {
    "path": "pyproject.toml",
    "chars": 605,
    "preview": "[build-system]\nrequires = [\"maturin>=1.0,<2.0\"]\nbuild-backend = \"maturin\"\n\n[project]\nname = \"py-spy\"\nclassifiers = [\n\t\"D"
  },
  {
    "path": "setup.cfg",
    "chars": 562,
    "preview": "[bumpversion]\ncurrent_version = 0.4.1\ncommit = True\ntag = True\nparse = (?P<major>\\d+)\\.(?P<minor>\\d+)\\.(?P<patch>\\d+)((?"
  },
  {
    "path": "src/binary_parser.rs",
    "chars": 11235,
    "preview": "use std::collections::HashMap;\nuse std::fs::File;\nuse std::path::Path;\n\nuse anyhow::Error;\nuse goblin::Object;\nuse memma"
  },
  {
    "path": "src/chrometrace.rs",
    "chars": 3617,
    "preview": "use std::cmp::min;\nuse std::collections::HashMap;\nuse std::io::Write;\nuse std::time::Instant;\n\nuse anyhow::Error;\nuse se"
  },
  {
    "path": "src/config.rs",
    "chars": 21077,
    "preview": "use clap::{\n    crate_description, crate_name, crate_version, value_parser, Arg, ArgEnum, Command,\n    PossibleValue,\n};"
  },
  {
    "path": "src/console_viewer.rs",
    "chars": 22817,
    "preview": "use std::collections::HashMap;\nuse std::io;\nuse std::io::{BufReader, Read, Write};\nuse std::sync::{atomic, Arc, Mutex};\n"
  },
  {
    "path": "src/coredump.rs",
    "chars": 17147,
    "preview": "use std::collections::HashMap;\nuse std::ffi::OsStr;\nuse std::fs::File;\nuse std::io::Read;\nuse std::os::unix::ffi::OsStrE"
  },
  {
    "path": "src/cython.rs",
    "chars": 8418,
    "preview": "use regex::Regex;\nuse std::collections::{BTreeMap, HashMap};\n\nuse anyhow::Error;\nuse lazy_static::lazy_static;\n\nuse crat"
  },
  {
    "path": "src/dump.rs",
    "chars": 3820,
    "preview": "use anyhow::Error;\nuse console::{style, Term};\n\nuse crate::config::Config;\nuse crate::python_spy::PythonSpy;\nuse crate::"
  },
  {
    "path": "src/flamegraph.rs",
    "chars": 3548,
    "preview": "// This code is taken from the flamegraph.rs from rbspy\n// https://github.com/rbspy/rbspy/tree/master/src/ui/flamegraph."
  },
  {
    "path": "src/lib.rs",
    "chars": 1561,
    "preview": "//! py-spy: a sampling profiler for python programs\n//!\n//! This crate lets you use py-spy as a rust library, and gather"
  },
  {
    "path": "src/main.rs",
    "chars": 17939,
    "preview": "#[macro_use]\nextern crate anyhow;\n#[macro_use]\nextern crate log;\n\nmod binary_parser;\nmod chrometrace;\nmod config;\nmod co"
  },
  {
    "path": "src/native_stack_trace.rs",
    "chars": 14544,
    "preview": "use anyhow::Error;\nuse std::collections::HashSet;\nuse std::num::NonZeroUsize;\n\nuse cpp_demangle::{BorrowedSymbol, Demang"
  },
  {
    "path": "src/python_bindings/mod.rs",
    "chars": 9322,
    "preview": "pub mod v2_7_15;\npub mod v3_10_0;\npub mod v3_11_0;\npub mod v3_12_0;\npub mod v3_13_0;\npub mod v3_3_7;\npub mod v3_5_5;\npub"
  },
  {
    "path": "src/python_bindings/v2_7_15.rs",
    "chars": 22187,
    "preview": "// Generated bindings for python v2.7.15\n#![allow(dead_code)]\n#![allow(non_upper_case_globals)]\n#![allow(non_camel_case_"
  },
  {
    "path": "src/python_bindings/v3_10_0.rs",
    "chars": 60332,
    "preview": "// Generated bindings for python v3.10.0rc1\n#![allow(dead_code)]\n#![allow(non_upper_case_globals)]\n#![allow(non_camel_ca"
  },
  {
    "path": "src/python_bindings/v3_11_0.rs",
    "chars": 66609,
    "preview": "// Generated bindings for python v3.11.0\n#![allow(dead_code)]\n#![allow(non_upper_case_globals)]\n#![allow(non_camel_case_"
  },
  {
    "path": "src/python_bindings/v3_12_0.rs",
    "chars": 525235,
    "preview": "// Generated bindings for python v3.12.0\n#![allow(dead_code)]\n#![allow(non_upper_case_globals)]\n#![allow(non_camel_case_"
  },
  {
    "path": "src/python_bindings/v3_13_0.rs",
    "chars": 422206,
    "preview": "// Generated bindings for python v3.13.0\n#![allow(dead_code)]\n#![allow(non_upper_case_globals)]\n#![allow(non_camel_case_"
  },
  {
    "path": "src/python_bindings/v3_3_7.rs",
    "chars": 27056,
    "preview": "// Generated bindings for python v3.3.7\n#![allow(dead_code)]\n#![allow(non_upper_case_globals)]\n#![allow(non_camel_case_t"
  },
  {
    "path": "src/python_bindings/v3_4_8.rs",
    "chars": 26980,
    "preview": "// Generated bindings for python v3.4.8\n#![allow(dead_code)]\n#![allow(non_upper_case_globals)]\n#![allow(non_camel_case_t"
  },
  {
    "path": "src/python_bindings/v3_5_5.rs",
    "chars": 28186,
    "preview": "// Generated bindings for python v3.5.5\n#![allow(dead_code)]\n#![allow(non_upper_case_globals)]\n#![allow(non_camel_case_t"
  },
  {
    "path": "src/python_bindings/v3_6_6.rs",
    "chars": 29097,
    "preview": "// Generated bindings for python v3.6.6\n#![allow(dead_code)]\n#![allow(non_upper_case_globals)]\n#![allow(non_camel_case_t"
  },
  {
    "path": "src/python_bindings/v3_7_0.rs",
    "chars": 33246,
    "preview": "// Generated bindings for python v3.7.0\n#![allow(dead_code)]\n#![allow(non_upper_case_globals)]\n#![allow(non_camel_case_t"
  },
  {
    "path": "src/python_bindings/v3_8_0.rs",
    "chars": 35826,
    "preview": "// Generated bindings for python v3.8.0b4\n#![allow(dead_code)]\n#![allow(non_upper_case_globals)]\n#![allow(non_camel_case"
  },
  {
    "path": "src/python_bindings/v3_9_5.rs",
    "chars": 45873,
    "preview": "// Generated bindings for python v3.9.5\n#![allow(dead_code)]\n#![allow(non_upper_case_globals)]\n#![allow(non_camel_case_t"
  },
  {
    "path": "src/python_data_access.rs",
    "chars": 22713,
    "preview": "#![allow(clippy::unnecessary_cast)]\nuse anyhow::Error;\n\nuse crate::python_bindings::v3_13_0;\nuse crate::python_interpret"
  },
  {
    "path": "src/python_interpreters.rs",
    "chars": 27725,
    "preview": "/* This code abstracts over different python interpreters by providing\ntraits for the classes/methods we need and implem"
  },
  {
    "path": "src/python_process_info.rs",
    "chars": 32995,
    "preview": "use regex::Regex;\n#[cfg(windows)]\nuse regex::RegexBuilder;\n#[cfg(windows)]\nuse std::collections::HashMap;\nuse std::mem::"
  },
  {
    "path": "src/python_spy.rs",
    "chars": 23607,
    "preview": "use std::collections::HashMap;\n#[cfg(all(target_os = \"linux\", feature = \"unwind\"))]\nuse std::collections::HashSet;\n#[cfg"
  },
  {
    "path": "src/python_threading.rs",
    "chars": 5310,
    "preview": "use std::collections::HashMap;\n\nuse anyhow::{Context, Error};\n\nuse crate::python_bindings::{v3_10_0, v3_11_0, v3_12_0, v"
  },
  {
    "path": "src/sampler.rs",
    "chars": 14208,
    "preview": "#![allow(clippy::type_complexity)]\n\nuse std::collections::HashMap;\nuse std::sync::mpsc::{self, Receiver, Sender};\nuse st"
  },
  {
    "path": "src/speedscope.rs",
    "chars": 9733,
    "preview": "// This code is adapted from rbspy:\n// https://github.com/rbspy/rbspy/tree/master/src/ui/speedscope.rs\n// licensed under"
  },
  {
    "path": "src/stack_trace.rs",
    "chars": 12285,
    "preview": "use std::sync::Arc;\n\nuse anyhow::{Context, Error, Result};\n\nuse remoteprocess::{Pid, ProcessMemory};\nuse serde_derive::S"
  },
  {
    "path": "src/timer.rs",
    "chars": 2526,
    "preview": "use std::time::{Duration, Instant};\n#[cfg(windows)]\nuse winapi::um::timeapi;\n\nuse rand_distr::{Distribution, Exp};\n\n/// "
  },
  {
    "path": "src/utils.rs",
    "chars": 2205,
    "preview": "use num_traits::{CheckedAdd, Zero};\nuse std::ops::Add;\n\n#[cfg(feature = \"unwind\")]\npub fn resolve_filename(filename: &st"
  },
  {
    "path": "src/version.rs",
    "chars": 6172,
    "preview": "use lazy_static::lazy_static;\nuse regex::bytes::Regex;\n\nuse anyhow::Error;\n\n#[derive(Debug, PartialEq, Eq, Clone)]\npub s"
  },
  {
    "path": "tests/integration_test.py",
    "chars": 4715,
    "preview": "from __future__ import print_function\n\nimport json\nimport os\nimport subprocess\nimport sys\nimport re\nimport tempfile\nimpo"
  },
  {
    "path": "tests/integration_test.rs",
    "chars": 17109,
    "preview": "extern crate py_spy;\nuse py_spy::{Config, Pid, PythonSpy};\nuse std::collections::HashSet;\n\nstruct ScriptRunner {\n    #[a"
  },
  {
    "path": "tests/scripts/busyloop.py",
    "chars": 91,
    "preview": "def busy_loop():\n    while True:\n        pass\n\n\nif __name__ == \"__main__\":\n    busy_loop()\n"
  },
  {
    "path": "tests/scripts/cyrillic.py",
    "chars": 108,
    "preview": "import time\n\ndef кириллица(seconds):\n    time.sleep(seconds)\n\nif __name__ == \"__main__\":\n    кириллица(100)\n"
  },
  {
    "path": "tests/scripts/delayed_launch.sh",
    "chars": 52,
    "preview": "sleep 0.5\npython -c \"import time; time.sleep(1000)\"\n"
  },
  {
    "path": "tests/scripts/local_vars.py",
    "chars": 1170,
    "preview": "import time\nimport numpy as np\n\n\ndef local_variable_lookup(arg1=\"foo\", arg2=None, arg3=True):\n    local1 = [-1234, 5678]"
  },
  {
    "path": "tests/scripts/longsleep.py",
    "chars": 99,
    "preview": "import time\n\n\ndef longsleep():\n    time.sleep(100000)\n\n\nif __name__ == \"__main__\":\n    longsleep()\n"
  },
  {
    "path": "tests/scripts/negative_linenumber_offsets.py",
    "chars": 207,
    "preview": "import time\n\n\ndef f():\n    [\n        # Must be split over multiple lines to see the error.\n        # https://github.com/"
  },
  {
    "path": "tests/scripts/recursive.py",
    "chars": 93,
    "preview": "def recurse(x):\n    if x == 0:\n        return\n    recurse(x-1)\n\n\nwhile True:\n    recurse(20)\n"
  },
  {
    "path": "tests/scripts/subprocesses.py",
    "chars": 396,
    "preview": "import time\nimport multiprocessing\n\ndef target():\n    multiprocessing.freeze_support()\n    time.sleep(1000)\n\ndef main():"
  },
  {
    "path": "tests/scripts/subprocesses_zombie_child.py",
    "chars": 232,
    "preview": "import time\nimport multiprocessing\n\ndef target():\n    pass\n\nif __name__ == \"__main__\":\n    multiprocessing.freeze_suppor"
  },
  {
    "path": "tests/scripts/thread_names.py",
    "chars": 257,
    "preview": "import time\nimport threading\n\n\ndef main():\n    for i in range(10):\n        th = threading.Thread(target = lambda: time.s"
  },
  {
    "path": "tests/scripts/thread_reuse.py",
    "chars": 130,
    "preview": "import time\nimport threading\n\nwhile True:\n    th = threading.Thread(target = lambda: time.sleep(.5))\n    th.start()\n    "
  },
  {
    "path": "tests/scripts/unicode💩.py",
    "chars": 150,
    "preview": "#!/env/bin/python\n# -*- coding: utf-8 -*-\nimport time\n\ndef function1(seconds):\n    time.sleep(seconds)\n\nif __name__ == \""
  }
]

About this extraction

This page contains the full source code of the benfred/py-spy GitHub repository, extracted and formatted as plain text for AI agents and large language models (LLMs). The extraction includes 73 files (1.8 MB), approximately 558.6k tokens, and a symbol index with 6646 extracted functions, classes, methods, constants, and types. Use this with OpenClaw, Claude, ChatGPT, Cursor, Windsurf, or any other AI tool that accepts text input. You can copy the full output to your clipboard or download it as a .txt file.

Extracted by GitExtract — free GitHub repo to text converter for AI. Built by Nikandr Surkov.

Copied to clipboard!