From 32af644fcc91bebd329c8b41a373d1ccc95c936b Mon Sep 17 00:00:00 2001 From: Nicholas Nethercote Date: Wed, 30 Apr 2025 13:40:22 +1000 Subject: [PATCH 1/2] Add `typenum-1.18.0` benchmark. --- .../typenum-1.18.0/.cargo_vcs_info.json | 6 + .../compile-benchmarks/typenum-1.18.0/.envrc | 1 + .../.github/workflows/check.yml | 107 + .../.github/workflows/publish.yml | 27 + .../typenum-1.18.0/.gitignore | 2 + .../typenum-1.18.0/CHANGELOG.md | 125 + .../typenum-1.18.0/Cargo.lock | 214 + .../typenum-1.18.0/Cargo.toml | 73 + .../typenum-1.18.0/Cargo.toml.orig | 39 + .../compile-benchmarks/typenum-1.18.0/LICENSE | 1 + .../typenum-1.18.0/LICENSE-APACHE | 201 + .../typenum-1.18.0/LICENSE-MIT | 21 + .../typenum-1.18.0/README.md | 67 + .../typenum-1.18.0/build.rs | 417 ++ .../typenum-1.18.0/clippy.toml | 1 + .../typenum-1.18.0/flake.lock | 95 + .../typenum-1.18.0/flake.nix | 42 + .../typenum-1.18.0/justfile | 34 + .../typenum-1.18.0/perf-config.json | 4 + .../typenum-1.18.0/src/array.rs | 396 ++ .../typenum-1.18.0/src/bit.rs | 347 + .../typenum-1.18.0/src/gen.rs | 4 + .../typenum-1.18.0/src/gen/consts.rs | 5899 +++++++++++++++++ .../src/gen/generic_const_mappings.rs | 4478 +++++++++++++ .../typenum-1.18.0/src/gen/op.rs | 1030 +++ .../typenum-1.18.0/src/int.rs | 1401 ++++ .../typenum-1.18.0/src/lib.rs | 175 + .../typenum-1.18.0/src/marker_traits.rs | 189 + .../typenum-1.18.0/src/operator_aliases.rs | 115 + .../typenum-1.18.0/src/private.rs | 592 ++ .../typenum-1.18.0/src/type_operators.rs | 626 ++ .../typenum-1.18.0/src/uint.rs | 2670 ++++++++ .../typenum-1.18.0/tests/test.rs | 2 + 33 files changed, 19401 insertions(+) create mode 100644 collector/compile-benchmarks/typenum-1.18.0/.cargo_vcs_info.json create mode 100644 collector/compile-benchmarks/typenum-1.18.0/.envrc create mode 100644 collector/compile-benchmarks/typenum-1.18.0/.github/workflows/check.yml create mode 100644 collector/compile-benchmarks/typenum-1.18.0/.github/workflows/publish.yml create mode 100644 collector/compile-benchmarks/typenum-1.18.0/.gitignore create mode 100644 collector/compile-benchmarks/typenum-1.18.0/CHANGELOG.md create mode 100644 collector/compile-benchmarks/typenum-1.18.0/Cargo.lock create mode 100644 collector/compile-benchmarks/typenum-1.18.0/Cargo.toml create mode 100644 collector/compile-benchmarks/typenum-1.18.0/Cargo.toml.orig create mode 100644 collector/compile-benchmarks/typenum-1.18.0/LICENSE create mode 100644 collector/compile-benchmarks/typenum-1.18.0/LICENSE-APACHE create mode 100644 collector/compile-benchmarks/typenum-1.18.0/LICENSE-MIT create mode 100644 collector/compile-benchmarks/typenum-1.18.0/README.md create mode 100644 collector/compile-benchmarks/typenum-1.18.0/build.rs create mode 100644 collector/compile-benchmarks/typenum-1.18.0/clippy.toml create mode 100644 collector/compile-benchmarks/typenum-1.18.0/flake.lock create mode 100644 collector/compile-benchmarks/typenum-1.18.0/flake.nix create mode 100644 collector/compile-benchmarks/typenum-1.18.0/justfile create mode 100644 collector/compile-benchmarks/typenum-1.18.0/perf-config.json create mode 100644 collector/compile-benchmarks/typenum-1.18.0/src/array.rs create mode 100644 collector/compile-benchmarks/typenum-1.18.0/src/bit.rs create mode 100644 collector/compile-benchmarks/typenum-1.18.0/src/gen.rs create mode 100644 collector/compile-benchmarks/typenum-1.18.0/src/gen/consts.rs create mode 100644 collector/compile-benchmarks/typenum-1.18.0/src/gen/generic_const_mappings.rs create mode 100644 collector/compile-benchmarks/typenum-1.18.0/src/gen/op.rs create mode 100644 collector/compile-benchmarks/typenum-1.18.0/src/int.rs create mode 100644 collector/compile-benchmarks/typenum-1.18.0/src/lib.rs create mode 100644 collector/compile-benchmarks/typenum-1.18.0/src/marker_traits.rs create mode 100644 collector/compile-benchmarks/typenum-1.18.0/src/operator_aliases.rs create mode 100644 collector/compile-benchmarks/typenum-1.18.0/src/private.rs create mode 100644 collector/compile-benchmarks/typenum-1.18.0/src/type_operators.rs create mode 100644 collector/compile-benchmarks/typenum-1.18.0/src/uint.rs create mode 100644 collector/compile-benchmarks/typenum-1.18.0/tests/test.rs diff --git a/collector/compile-benchmarks/typenum-1.18.0/.cargo_vcs_info.json b/collector/compile-benchmarks/typenum-1.18.0/.cargo_vcs_info.json new file mode 100644 index 000000000..f4a43f133 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.18.0/.cargo_vcs_info.json @@ -0,0 +1,6 @@ +{ + "git": { + "sha1": "67584b536d97c5503fa0f8d6ea1162eb4d9b8383" + }, + "path_in_vcs": "" +} \ No newline at end of file diff --git a/collector/compile-benchmarks/typenum-1.18.0/.envrc b/collector/compile-benchmarks/typenum-1.18.0/.envrc new file mode 100644 index 000000000..3550a30f2 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.18.0/.envrc @@ -0,0 +1 @@ +use flake diff --git a/collector/compile-benchmarks/typenum-1.18.0/.github/workflows/check.yml b/collector/compile-benchmarks/typenum-1.18.0/.github/workflows/check.yml new file mode 100644 index 000000000..cb1145b13 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.18.0/.github/workflows/check.yml @@ -0,0 +1,107 @@ +on: + push: + branches: + - main + pull_request: + branches: + - main + +name: CI + +jobs: + all-succeeded: + name: All Succeeded + if: always() + runs-on: ubuntu-latest + needs: + - test-linux + - test-non-linux + - lint + + steps: + - name: Check if all jubs succeeded + uses: re-actors/alls-green@release/v1 + with: + jobs: ${{ toJSON(needs) }} + + test-linux: + name: Test Linux + runs-on: ubuntu-latest + strategy: + fail-fast: false + matrix: + rust: + - stable + - beta + - nightly + mb_const_generics: + - "" + - "--features const-generics" + target: + - x86_64 + - i686 + - sparc64 + include: + - mb_const_generics: "" + rust: 1.37.0 + target: x86_64 + steps: + - uses: actions/checkout@v3 + - if: matrix.rust == '1.37.0' + # Rust 1.37 doesn't like modern lock files :( + run: rm Cargo.lock + - uses: dtolnay/rust-toolchain@master + with: + toolchain: ${{ matrix.rust }} + - uses: actions-rs/cargo@v1 + with: + use-cross: ${{ matrix.target != 'x86_64' }} + command: test + args: --verbose --features "strict" ${{ matrix.mb_const_generics }} --target ${{ matrix.target }}-unknown-linux-gnu + - uses: actions-rs/cargo@v1 + with: + use-cross: ${{ matrix.target != 'x86_64' }} + command: doc + args: --features "strict" ${{ matrix.mb_const_generics }} --target ${{ matrix.target }}-unknown-linux-gnu + + test-non-linux: + name: Test non-Linux + runs-on: ${{ matrix.os }} + strategy: + matrix: + os: + - macos-latest + - windows-latest + rust: + - stable + mb_const_generics: + - "" + - "--features const-generics" + steps: + - uses: actions/checkout@v3 + - uses: dtolnay/rust-toolchain@master + with: + toolchain: ${{ matrix.rust }} + - uses: extractions/setup-just@v2 + - run: just test ${{ matrix.mb_const_generics }} + + lint: + name: Lint + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + - uses: dtolnay/rust-toolchain@nightly + with: + components: rustfmt, clippy + - uses: extractions/setup-just@v2 + - run: just lint + + test-generated: + name: Test Generated + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + - uses: dtolnay/rust-toolchain@stable + - uses: extractions/setup-just@v2 + - run: just gen + - run: git diff --exit-code diff --git a/collector/compile-benchmarks/typenum-1.18.0/.github/workflows/publish.yml b/collector/compile-benchmarks/typenum-1.18.0/.github/workflows/publish.yml new file mode 100644 index 000000000..efc72c52a --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.18.0/.github/workflows/publish.yml @@ -0,0 +1,27 @@ +on: + push: + tags: + - 'v*' + +name: Publish + +jobs: + release: + name: GitHub Release + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + - uses: marvinpinto/action-automatic-releases@latest + with: + repo_token: "${{ secrets.GITHUB_TOKEN }}" + prerelease: false + + publish: + name: Crates.io Publish + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v3 + - uses: dtolnay/rust-toolchain@stable + - uses: katyo/publish-crates@v1 + with: + registry-token: ${{ secrets.CARGO_REGISTRY_TOKEN }} diff --git a/collector/compile-benchmarks/typenum-1.18.0/.gitignore b/collector/compile-benchmarks/typenum-1.18.0/.gitignore new file mode 100644 index 000000000..34169b35c --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.18.0/.gitignore @@ -0,0 +1,2 @@ +target +.direnv/ diff --git a/collector/compile-benchmarks/typenum-1.18.0/CHANGELOG.md b/collector/compile-benchmarks/typenum-1.18.0/CHANGELOG.md new file mode 100644 index 000000000..4667b84c7 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.18.0/CHANGELOG.md @@ -0,0 +1,125 @@ +# Changelog + +This project follows semantic versioning. + +The MSRV (Minimum Supported Rust Version) is 1.37.0, and typenum is tested +against this Rust version. + +### Unreleased + +### 1.18.0 (2025-02-17) +- [changed] Remove build scripts; instead check-in the built code (PR #219) +- [added] Constants for 3600 (PR #220) +- [added] Elixir-style syntax for `tarr!` macro (PR #214) +- [added] `FoldAdd` and `FoldMul` to get the sum/product of an array (PR #209) + +### 1.17.0 (2023-09-15) +- [removed] Remove `force_unix_path_separator` feature, make it the default +- [added] docs.rs metadata and cfg options +- [added] Playground metadata + +### 1.16.0 (2022-12-05) +- [added] `const INT` field to the `ToInt` trait. +- [added] `const-generics` field with `U` mapping where `N` is a const generic. + +### 1.15.0 (2021-12-25) +- [fixed] Cross-compilation issue due to doing math in build script. (PR #177) +- [added] New feature `scale_info` for using inside + [Substrate](https://github.com/paritytech/substrate.git)-based runtimes (PR + #175) + +### 1.14.0 (2021-09-01) +- [changed] Sealed all marker traits. Documentation already stated that these + should not be implemented outside the crate, so this is not considered a + breaking change. + +### 1.13.0 (2021-03-12) +- [changed] MSRV from 1.22.0 to 1.37.0. +- [fixed] `op` macro with 2018 edition import. +- [changed] Allowed calling `assert_type_eq` and `assert_type` at top level. +- [added] Marker trait `Zero` for `Z0`, `U0`, and `B0`. +- [added] Implementation of `Pow` trait for f32 and f64 with negative exponent. +- [added] Trait `ToInt`. + +### 1.12.0 (2020-04-13) +- [added] Feature `force_unix_path_separator` to support building without Cargo. +- [added] Greatest common divisor operator `Gcd` with alias `Gcf`. +- [added] `gcd` to the `op!` macro. +- [changed] Added `Copy` bound to `Rhs` of `Mul` impl for ``. +- [changed] Added `Copy` bound to `Rhs` of `Div` impl for ``. +- [changed] Added `Copy` bound to `Rhs` of `PartialDiv` impl for ``. +- [changed] Added `Copy` bound to `Rhs` of `Rem` impl for ``. +- [fixed] Make all functions #[inline]. + +### 1.11.2 (2019-08-26) +- [fixed] Cross compilation from Linux to Windows. + +### 1.11.1 (2019-08-25) +- [fixed] Builds on earlier Rust builds again and added Rust 1.22.0 to Travis to + prevent future breakage. + +### 1.11.0 (2019-08-25) +- [added] Integer `log2` to the `op!` macro. +- [added] Integer binary logarithm operator `Logarithm2` with alias `Log2`. +- [changed] Removed `feature(i128_type)` when running with the `i128` + feature. Kept the feature flag. for typenum to maintain compatibility with + old Rust versions. +- [added] Integer `sqrt` to the `op!` macro. +- [added] Integer square root operator `SquareRoot` with alias `Sqrt`. +- [fixed] Bug with attempting to create U1024 type alias twice. + +### 1.10.0 (2018-03-11) +- [added] The `PowerOfTwo` marker trait. +- [added] Associated constants for `Bit`, `Unsigned`, and `Integer`. + +### 1.9.0 (2017-05-14) +- [added] The `Abs` type operator and corresponding `AbsVal` alias. +- [added] The feature `i128` that enables creating 128-bit integers from + typenums. +- [added] The `assert_type!` and `assert_type_eq!` macros. +- [added] Operators to the `op!` macro, including those performed by `cmp!`. +- [fixed] Bug in `op!` macro involving functions and convoluted expressions. +- [deprecated] The `cmp!` macro. + +### 1.8.0 (2017-04-12) +- [added] The `op!` macro for conveniently performing type-level operations. +- [added] The `cmp!` macro for conveniently performing type-level comparisons. +- [added] Some comparison type-operators that are used by the `cmp!` macro. + +### 1.7.0 (2017-03-24) +- [added] Type operators `Min` and `Max` with accompanying aliases `Minimum` and + `Maximum` + +### 1.6.0 (2017-02-24) +- [fixed] Bug in `Array` division. +- [fixed] Bug where `Rem` would sometimes exit early with the wrong answer. +- [added] `PartialDiv` operator that performs division as a partial function -- + it's defined only when there is no remainder. + +### 1.5.2 (2017-02-04) +- [fixed] Bug between `Div` implementation and type system. + +### 1.5.1 (2016-11-08) +- [fixed] Expanded implementation of `Pow` for primitives. + +### 1.5.0 (2016-11-03) +- [added] Functions to the `Pow` and `Len` traits. This is *technically* a + breaking change, but it would only break someone's code if they have a custom + impl for `Pow`. I would be very surprised if that is anyone other than me. + +### 1.4.0 (2016-10-29) +- [added] Type-level arrays of type-level integers. (PR #66) +- [added] The types in this crate are now instantiable. (Issue #67, PR #68) + +### 1.3.1 (2016-03-31) +- [fixed] Bug with recent nightlies. + +### 1.3.0 (2016-02-07) +- [changed] Removed dependency on libstd. (Issue #53, PR #55) +- [changed] Reorganized module structure. (PR #57) + +### 1.2.0 (2016-01-03) +- [added] This change log! +- [added] Convenience type aliases for operators. (Issue #48, PR #50) +- [added] Types in this crate now derive all possible traits. (Issue #42, PR + #51) diff --git a/collector/compile-benchmarks/typenum-1.18.0/Cargo.lock b/collector/compile-benchmarks/typenum-1.18.0/Cargo.lock new file mode 100644 index 000000000..759f06a64 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.18.0/Cargo.lock @@ -0,0 +1,214 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "arrayvec" +version = "0.7.6" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7c02d123df017efcdfbd739ef81735b36c5ba83ec3c59c80a9d7ecc718f92e50" + +[[package]] +name = "byte-slice-cast" +version = "1.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "c3ac9f8b63eca6fd385229b3675f6cc0dc5c8a5c8a54a59d4f52ffd670d87b0c" + +[[package]] +name = "cfg-if" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd" + +[[package]] +name = "derive_more" +version = "0.99.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3da29a38df43d6f156149c9b43ded5e018ddff2a855cf2cfd62e8cd7d079c69f" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.98", +] + +[[package]] +name = "equivalent" +version = "1.0.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "877a4ace8713b0bcf2a4e7eec82529c029f1d0619886d18145fea96c3ffe5c0f" + +[[package]] +name = "hashbrown" +version = "0.15.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289" + +[[package]] +name = "impl-trait-for-tuples" +version = "0.2.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a0eb5a3343abf848c0984fe4604b2b105da9539376e24fc0a3b0007411ae4fd9" +dependencies = [ + "proc-macro2", + "quote", + "syn 2.0.98", +] + +[[package]] +name = "indexmap" +version = "2.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "8c9c992b02b5b4c94ea26e32fe5bccb7aa7d9f390ab5c1221ff895bc7ea8b652" +dependencies = [ + "equivalent", + "hashbrown", +] + +[[package]] +name = "memchr" +version = "2.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3" + +[[package]] +name = "once_cell" +version = "1.20.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "945462a4b81e43c4e3ba96bd7b49d834c6f61198356aa858733bc4acf3cbe62e" + +[[package]] +name = "parity-scale-codec" +version = "2.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "373b1a4c1338d9cd3d1fa53b3a11bdab5ab6bd80a20f7f7becd76953ae2be909" +dependencies = [ + "arrayvec", + "byte-slice-cast", + "impl-trait-for-tuples", + "parity-scale-codec-derive", +] + +[[package]] +name = "parity-scale-codec-derive" +version = "2.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1557010476e0595c9b568d16dcfb81b93cdeb157612726f5170d31aa707bed27" +dependencies = [ + "proc-macro-crate", + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "proc-macro-crate" +version = "1.3.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7f4c021e1093a56626774e81216a4ce732a735e5bad4868a03f3ed65ca0c3919" +dependencies = [ + "once_cell", + "toml_edit", +] + +[[package]] +name = "proc-macro2" +version = "1.0.93" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "60946a68e5f9d28b0dc1c21bb8a97ee7d018a8b322fa57838ba31cc878e22d99" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.38" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc" +dependencies = [ + "proc-macro2", +] + +[[package]] +name = "scale-info" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5c55b744399c25532d63a0d2789b109df8d46fc93752d46b0782991a931a782f" +dependencies = [ + "cfg-if", + "derive_more", + "parity-scale-codec", + "scale-info-derive", +] + +[[package]] +name = "scale-info-derive" +version = "1.0.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "baeb2780690380592f86205aa4ee49815feb2acad8c2f59e6dd207148c3f1fcd" +dependencies = [ + "proc-macro-crate", + "proc-macro2", + "quote", + "syn 1.0.109", +] + +[[package]] +name = "syn" +version = "1.0.109" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "syn" +version = "2.0.98" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "36147f1a48ae0ec2b5b3bc5b537d267457555a10dc06f3dbc8cb11ba3006d3b1" +dependencies = [ + "proc-macro2", + "quote", + "unicode-ident", +] + +[[package]] +name = "toml_datetime" +version = "0.6.8" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0dd7358ecb8fc2f8d014bf86f6f638ce72ba252a2c3a2572f2a795f1d23efb41" + +[[package]] +name = "toml_edit" +version = "0.19.15" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "1b5bb770da30e5cbfde35a2d7b9b8a2c4b8ef89548a7a6aeab5c9a576e3e7421" +dependencies = [ + "indexmap", + "toml_datetime", + "winnow", +] + +[[package]] +name = "typenum" +version = "1.18.0" +dependencies = [ + "scale-info", +] + +[[package]] +name = "unicode-ident" +version = "1.0.16" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "a210d160f08b701c8721ba1c726c11662f877ea6b7094007e1ca9a1041945034" + +[[package]] +name = "winnow" +version = "0.5.40" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "f593a95398737aeed53e489c785df13f3618e41dbcd6718c6addbf1395aa6876" +dependencies = [ + "memchr", +] diff --git a/collector/compile-benchmarks/typenum-1.18.0/Cargo.toml b/collector/compile-benchmarks/typenum-1.18.0/Cargo.toml new file mode 100644 index 000000000..172156387 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.18.0/Cargo.toml @@ -0,0 +1,73 @@ +# THIS FILE IS AUTOMATICALLY GENERATED BY CARGO +# +# When uploading crates to the registry Cargo will automatically +# "normalize" Cargo.toml files for maximal compatibility +# with all versions of Cargo and also rewrite `path` dependencies +# to registry (e.g., crates.io) dependencies. +# +# If you are reading this file be aware that the original Cargo.toml +# will likely look very different (and much more reasonable). +# See Cargo.toml.orig for the original contents. + +[package] +edition = "2018" +rust-version = "1.37.0" +name = "typenum" +version = "1.18.0" +authors = [ + "Paho Lurie-Gregg ", + "Andre Bogus ", +] +build = "build.rs" +autolib = false +autobins = false +autoexamples = false +autotests = false +autobenches = false +description = """ +Typenum is a Rust library for type-level numbers evaluated at + compile time. It currently supports bits, unsigned integers, and signed + integers. It also provides a type-level array of type-level numbers, but its + implementation is incomplete.""" +documentation = "https://docs.rs/typenum" +readme = "README.md" +categories = ["no-std"] +license = "MIT OR Apache-2.0" +repository = "https://github.com/paholg/typenum" + +[package.metadata.docs.rs] +features = [ + "i128", + "const-generics", +] +rustdoc-args = [ + "--cfg", + "docsrs", +] + +[package.metadata.playground] +features = [ + "i128", + "const-generics", +] + +[lib] +name = "typenum" +path = "src/lib.rs" + +[[test]] +name = "test" +path = "tests/test.rs" + +[dependencies.scale-info] +version = "1.0" +optional = true +default-features = false + +[features] +const-generics = [] +force_unix_path_separator = [] +i128 = [] +no_std = [] +scale_info = ["scale-info/derive"] +strict = [] diff --git a/collector/compile-benchmarks/typenum-1.18.0/Cargo.toml.orig b/collector/compile-benchmarks/typenum-1.18.0/Cargo.toml.orig new file mode 100644 index 000000000..5dc761fce --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.18.0/Cargo.toml.orig @@ -0,0 +1,39 @@ +[package] +name = "typenum" +version = "1.18.0" # remember to update html_root_url +authors = ["Paho Lurie-Gregg ", "Andre Bogus "] +documentation = "https://docs.rs/typenum" +repository = "https://github.com/paholg/typenum" +readme = "README.md" +license = "MIT OR Apache-2.0" +description = """Typenum is a Rust library for type-level numbers evaluated at + compile time. It currently supports bits, unsigned integers, and signed + integers. It also provides a type-level array of type-level numbers, but its + implementation is incomplete.""" +categories = ["no-std"] +edition = "2018" +rust-version = "1.37.0" + +[dependencies] +scale-info = { version = "1.0", default-features = false, optional = true } + +[lib] +name = "typenum" + +[features] +no_std = [] # Deprecated +i128 = [] +strict = [] +force_unix_path_separator = [] # Deprecated +const-generics = [] +scale_info = ["scale-info/derive"] + +[package.metadata.docs.rs] +features = ["i128", "const-generics"] +rustdoc-args = ["--cfg", "docsrs"] + +[package.metadata.playground] +features = ["i128", "const-generics"] + +[workspace] +members = ["generate"] diff --git a/collector/compile-benchmarks/typenum-1.18.0/LICENSE b/collector/compile-benchmarks/typenum-1.18.0/LICENSE new file mode 100644 index 000000000..364b7731c --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.18.0/LICENSE @@ -0,0 +1 @@ +MIT OR Apache-2.0 \ No newline at end of file diff --git a/collector/compile-benchmarks/typenum-1.18.0/LICENSE-APACHE b/collector/compile-benchmarks/typenum-1.18.0/LICENSE-APACHE new file mode 100644 index 000000000..4bf355c3e --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.18.0/LICENSE-APACHE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + +TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + +1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + +2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + +3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + +4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + +5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + +6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + +7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + +8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + +9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + +END OF TERMS AND CONDITIONS + +APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + +Copyright 2014 Paho Lurie-Gregg + +Licensed under the Apache License, Version 2.0 (the "License"); +you may not use this file except in compliance with the License. +You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + +Unless required by applicable law or agreed to in writing, software +distributed under the License is distributed on an "AS IS" BASIS, +WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +See the License for the specific language governing permissions and +limitations under the License. \ No newline at end of file diff --git a/collector/compile-benchmarks/typenum-1.18.0/LICENSE-MIT b/collector/compile-benchmarks/typenum-1.18.0/LICENSE-MIT new file mode 100644 index 000000000..e567a4d28 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.18.0/LICENSE-MIT @@ -0,0 +1,21 @@ +The MIT License (MIT) + +Copyright (c) 2014 Paho Lurie-Gregg + +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. diff --git a/collector/compile-benchmarks/typenum-1.18.0/README.md b/collector/compile-benchmarks/typenum-1.18.0/README.md new file mode 100644 index 000000000..6b198775f --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.18.0/README.md @@ -0,0 +1,67 @@ +[![crates.io](https://img.shields.io/crates/v/typenum.svg)](https://crates.io/crates/typenum) +[![Build Status](https://github.com/paholg/typenum/actions/workflows/check.yml/badge.svg)](https://github.com/paholg/typenum/actions/workflows/check.yml) + +Typenum +===== + +Typenum is a Rust library for type-level numbers evaluated at compile time. It +currently supports bits, unsigned integers, and signed integers. + +Typenum depends only on libcore, and so is suitable for use on any platform! + +For the full documentation, go [here](https://docs.rs/typenum). + +### Importing + +While `typenum` is divided into several modules, they are all re-exported +through the crate root, so you can import anything contained herein with `use +typenum::whatever;`, ignoring the crate structure. + +You may also find it useful to treat the `consts` module as a prelude, +performing a glob import. + +### Example + +Here is a trivial example of `typenum`'s use: + +```rust +use typenum::{Sum, Exp, Integer, N2, P3, P4}; + +type X = Sum; +assert_eq!(::to_i32(), 7); + +type Y = Exp; +assert_eq!(::to_i32(), -8); +``` + +For a non-trivial example of its use, see one of the crates that depends on +it. The full list is +[here](https://crates.io/crates/typenum/reverse_dependencies). Of note are +[dimensioned](https://crates.io/crates/dimensioned/) which does compile-time +type checking for arbitrary unit systems and +[generic-array](https://crates.io/crates/generic-array/) which provides arrays +whose length you can generically refer to. + +### Error messages + + +Typenum's error messages aren't great, and can be difficult to parse. The good +news is that the fine folks at Auxon have written a tool to help with it. Please +take a look at [tnfilt](https://github.com/auxoncorp/tnfilt). + +### License + +Licensed under either of + + * Apache License, Version 2.0 ([LICENSE-APACHE](LICENSE-APACHE) or + http://www.apache.org/licenses/LICENSE-2.0) + * MIT license + ([LICENSE-MIT](LICENSE-MIT) or http://opensource.org/licenses/MIT) + +at your option. + +### Contribution + +Unless you explicitly state otherwise, any contribution intentionally submitted +for inclusion in the work by you, as defined in the Apache-2.0 license, shall be +dual licensed as above, without any additional terms or conditions. diff --git a/collector/compile-benchmarks/typenum-1.18.0/build.rs b/collector/compile-benchmarks/typenum-1.18.0/build.rs new file mode 100644 index 000000000..d76d5b4f8 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.18.0/build.rs @@ -0,0 +1,417 @@ +use std::{cmp, env, fmt, fs::File, io::Write, path::PathBuf}; + +enum UIntCode { + Term, + Zero(Box), + One(Box), +} + +enum IntCode { + Zero, + Pos(Box), + Neg(Box), +} + +impl fmt::Display for UIntCode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match *self { + UIntCode::Term => write!(f, "UTerm"), + UIntCode::Zero(ref inner) => write!(f, "UInt<{}, B0>", inner), + UIntCode::One(ref inner) => write!(f, "UInt<{}, B1>", inner), + } + } +} + +impl fmt::Display for IntCode { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match *self { + IntCode::Zero => write!(f, "Z0"), + IntCode::Pos(ref inner) => write!(f, "PInt<{}>", inner), + IntCode::Neg(ref inner) => write!(f, "NInt<{}>", inner), + } + } +} + +fn gen_uint(u: u64) -> UIntCode { + let mut result = UIntCode::Term; + let mut x = 1u64 << 63; + while x > u { + x >>= 1 + } + while x > 0 { + result = if x & u > 0 { + UIntCode::One(Box::new(result)) + } else { + UIntCode::Zero(Box::new(result)) + }; + x >>= 1; + } + result +} + +fn gen_int(i: i64) -> IntCode { + use std::cmp::Ordering::{Equal, Greater, Less}; + + match i.cmp(&0) { + Greater => IntCode::Pos(Box::new(gen_uint(i as u64))), + Less => IntCode::Neg(Box::new(gen_uint(i.abs() as u64))), + Equal => IntCode::Zero, + } +} + +/// Computes the greatest common divisor of two integers. +fn gcdi(mut a: i64, mut b: i64) -> i64 { + a = a.abs(); + b = b.abs(); + + while a != 0 { + let tmp = b % a; + b = a; + a = tmp; + } + + b +} + +fn gcdu(mut a: u64, mut b: u64) -> u64 { + while a != 0 { + let tmp = b % a; + b = a; + a = tmp; + } + + b +} + +fn sign(i: i64) -> char { + use std::cmp::Ordering::*; + match i.cmp(&0) { + Greater => 'P', + Less => 'N', + Equal => '_', + } +} + +struct UIntTest { + a: u64, + op: &'static str, + b: Option, + r: u64, +} + +impl fmt::Display for UIntTest { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + match self.b { + Some(b) => write!( + f, + " +#[test] +#[allow(non_snake_case)] +fn test_{a}_{op}_{b}() {{ + type A = {gen_a}; + type B = {gen_b}; + type U{r} = {result}; + + #[allow(non_camel_case_types)] + type U{a}{op}U{b} = <>::Output as Same>::Output; + + assert_eq!(::to_u64(), ::to_u64()); +}}", + gen_a = gen_uint(self.a), + gen_b = gen_uint(b), + r = self.r, + result = gen_uint(self.r), + a = self.a, + b = b, + op = self.op + ), + None => write!( + f, + " +#[test] +#[allow(non_snake_case)] +fn test_{a}_{op}() {{ + type A = {gen_a}; + type U{r} = {result}; + + #[allow(non_camel_case_types)] + type {op}U{a} = <::Output as Same>::Output; + assert_eq!(<{op}U{a} as Unsigned>::to_u64(), ::to_u64()); +}}", + gen_a = gen_uint(self.a), + r = self.r, + result = gen_uint(self.r), + a = self.a, + op = self.op + ), + } + } +} + +fn uint_binary_test(left: u64, operator: &'static str, right: u64, result: u64) -> UIntTest { + UIntTest { + a: left, + op: operator, + b: Option::Some(right), + r: result, + } +} + +struct IntBinaryTest { + a: i64, + op: &'static str, + b: i64, + r: i64, +} + +impl fmt::Display for IntBinaryTest { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!( + f, + " +#[test] +#[allow(non_snake_case)] +fn test_{sa}{a}_{op}_{sb}{b}() {{ + type A = {gen_a}; + type B = {gen_b}; + type {sr}{r} = {result}; + + #[allow(non_camel_case_types)] + type {sa}{a}{op}{sb}{b} = <>::Output as Same<{sr}{r}>>::Output; + + assert_eq!(<{sa}{a}{op}{sb}{b} as Integer>::to_i64(), <{sr}{r} as Integer>::to_i64()); +}}", + gen_a = gen_int(self.a), + gen_b = gen_int(self.b), + r = self.r.abs(), + sr = sign(self.r), + result = gen_int(self.r), + a = self.a.abs(), + b = self.b.abs(), + sa = sign(self.a), + sb = sign(self.b), + op = self.op + ) + } +} + +fn int_binary_test(left: i64, operator: &'static str, right: i64, result: i64) -> IntBinaryTest { + IntBinaryTest { + a: left, + op: operator, + b: right, + r: result, + } +} + +struct IntUnaryTest { + op: &'static str, + a: i64, + r: i64, +} + +impl fmt::Display for IntUnaryTest { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!( + f, + " +#[test] +#[allow(non_snake_case)] +fn test_{sa}{a}_{op}() {{ + type A = {gen_a}; + type {sr}{r} = {result}; + + #[allow(non_camel_case_types)] + type {op}{sa}{a} = <::Output as Same<{sr}{r}>>::Output; + assert_eq!(<{op}{sa}{a} as Integer>::to_i64(), <{sr}{r} as Integer>::to_i64()); +}}", + gen_a = gen_int(self.a), + r = self.r.abs(), + sr = sign(self.r), + result = gen_int(self.r), + a = self.a.abs(), + sa = sign(self.a), + op = self.op + ) + } +} + +fn int_unary_test(operator: &'static str, num: i64, result: i64) -> IntUnaryTest { + IntUnaryTest { + op: operator, + a: num, + r: result, + } +} + +fn uint_cmp_test(a: u64, b: u64) -> String { + format!( + " +#[test] +#[allow(non_snake_case)] +fn test_{a}_Cmp_{b}() {{ + type A = {gen_a}; + type B = {gen_b}; + + #[allow(non_camel_case_types)] + type U{a}CmpU{b} = >::Output; + assert_eq!(::to_ordering(), Ordering::{result:?}); +}}", + a = a, + b = b, + gen_a = gen_uint(a), + gen_b = gen_uint(b), + result = a.cmp(&b) + ) +} + +fn int_cmp_test(a: i64, b: i64) -> String { + format!( + " +#[test] +#[allow(non_snake_case)] +fn test_{sa}{a}_Cmp_{sb}{b}() {{ + type A = {gen_a}; + type B = {gen_b}; + + #[allow(non_camel_case_types)] + type {sa}{a}Cmp{sb}{b} = >::Output; + assert_eq!(<{sa}{a}Cmp{sb}{b} as Ord>::to_ordering(), Ordering::{result:?}); +}}", + a = a.abs(), + b = b.abs(), + sa = sign(a), + sb = sign(b), + gen_a = gen_int(a), + gen_b = gen_int(b), + result = a.cmp(&b) + ) +} +pub fn gen_tests() -> String { + // will test all permutations of number pairs up to this (and down to its opposite for ints) + let high: i64 = 5; + + let uints = (0u64..high as u64 + 1).flat_map(|a| (a..a + 1).cycle().zip(0..high as u64 + 1)); + let ints = (-high..high + 1).flat_map(|a| (a..a + 1).cycle().zip(-high..high + 1)); + + let mut result = String::new(); + + result.push_str( + " +use typenum::*; +use core::ops::*; +use core::cmp::Ordering; +", + ); + // uint operators: + for (a, b) in uints { + let mut tests = vec![ + uint_binary_test(a, "BitAnd", b, a & b), + uint_binary_test(a, "BitOr", b, a | b), + uint_binary_test(a, "BitXor", b, a ^ b), + uint_binary_test(a, "Shl", b, a << b), + uint_binary_test(a, "Shr", b, a >> b), + uint_binary_test(a, "Add", b, a + b), + uint_binary_test(a, "Mul", b, a * b), + uint_binary_test(a, "Pow", b, a.pow(b as u32)), + uint_binary_test(a, "Min", b, cmp::min(a, b)), + uint_binary_test(a, "Max", b, cmp::max(a, b)), + uint_binary_test(a, "Gcd", b, gcdu(a, b)), + ]; + if a >= b { + tests.push(uint_binary_test(a, "Sub", b, a - b)); + } + if b != 0 { + tests.push(uint_binary_test(a, "Div", b, a / b)); + tests.push(uint_binary_test(a, "Rem", b, a % b)); + if a % b == 0 { + tests.push(uint_binary_test(a, "PartialDiv", b, a / b)); + } + } + + for test in tests { + result.push_str(&test.to_string()); + } + result.push_str(&uint_cmp_test(a, b)); + } + + // int operators: + for (a, b) in ints { + let mut tests = vec![ + int_binary_test(a, "Add", b, a + b), + int_binary_test(a, "Sub", b, a - b), + int_binary_test(a, "Mul", b, a * b), + int_binary_test(a, "Min", b, cmp::min(a, b)), + int_binary_test(a, "Max", b, cmp::max(a, b)), + int_binary_test(a, "Gcd", b, gcdi(a, b)), + ]; + if b != 0 { + tests.push(int_binary_test(a, "Div", b, a / b)); + tests.push(int_binary_test(a, "Rem", b, a % b)); + if a % b == 0 { + tests.push(int_binary_test(a, "PartialDiv", b, a / b)); + } + } + if b >= 0 || a.abs() == 1 { + let result = if b < 0 { + if a == 1 { + a + } else if a == -1 { + a.pow((-b) as u32) + } else { + unreachable!() + } + } else { + a.pow(b as u32) + }; + tests.push(int_binary_test(a, "Pow", b, result)); + } + for test in tests { + result.push_str(&test.to_string()); + } + result.push_str(&int_cmp_test(a, b)); + } + + // int unary operators: + for n in -high..high + 1 { + let tests = vec![ + int_unary_test("Neg", n, -n), + int_unary_test("Abs", n, n.abs()), + ]; + for test in tests { + result.push_str(&test.to_string()); + } + } + + result +} + +#[cfg_attr( + feature = "no_std", + deprecated( + since = "1.3.0", + note = "the `no_std` flag is no longer necessary and will be removed in the future" + ) +)] +pub fn no_std() {} + +#[cfg_attr( + feature = "force_unix_path_separator", + deprecated( + since = "1.17.0", + note = "the `force_unix_path_separator` flag is no longer necessary and will be removed in the future" + ) +)] +pub fn force_unix_path_separator() {} + +fn main() { + no_std(); + force_unix_path_separator(); + println!("cargo:rerun-if-changed=tests"); + + let tests = gen_tests(); + let out_dir = env::var("OUT_DIR").unwrap(); + let dest = PathBuf::from(out_dir).join("tests.rs"); + let mut f = File::create(&dest).unwrap(); + f.write_all(tests.as_bytes()).unwrap(); +} diff --git a/collector/compile-benchmarks/typenum-1.18.0/clippy.toml b/collector/compile-benchmarks/typenum-1.18.0/clippy.toml new file mode 100644 index 000000000..719c94d5d --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.18.0/clippy.toml @@ -0,0 +1 @@ +cognitive-complexity-threshold=35 diff --git a/collector/compile-benchmarks/typenum-1.18.0/flake.lock b/collector/compile-benchmarks/typenum-1.18.0/flake.lock new file mode 100644 index 000000000..a8cb09b4e --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.18.0/flake.lock @@ -0,0 +1,95 @@ +{ + "nodes": { + "flake-utils": { + "inputs": { + "systems": "systems" + }, + "locked": { + "lastModified": 1731533236, + "narHash": "sha256-l0KFg5HjrsfsO/JpG+r7fRrqm12kzFHyUHqHCVpMMbI=", + "owner": "numtide", + "repo": "flake-utils", + "rev": "11707dc2f618dd54ca8739b309ec4fc024de578b", + "type": "github" + }, + "original": { + "owner": "numtide", + "repo": "flake-utils", + "type": "github" + } + }, + "nixpkgs": { + "locked": { + "lastModified": 1739736696, + "narHash": "sha256-zON2GNBkzsIyALlOCFiEBcIjI4w38GYOb+P+R4S8Jsw=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "d74a2335ac9c133d6bbec9fc98d91a77f1604c1f", + "type": "github" + }, + "original": { + "id": "nixpkgs", + "ref": "nixos-unstable", + "type": "indirect" + } + }, + "nixpkgs_2": { + "locked": { + "lastModified": 1736320768, + "narHash": "sha256-nIYdTAiKIGnFNugbomgBJR+Xv5F1ZQU+HfaBqJKroC0=", + "owner": "NixOS", + "repo": "nixpkgs", + "rev": "4bc9c909d9ac828a039f288cf872d16d38185db8", + "type": "github" + }, + "original": { + "owner": "NixOS", + "ref": "nixpkgs-unstable", + "repo": "nixpkgs", + "type": "github" + } + }, + "root": { + "inputs": { + "flake-utils": "flake-utils", + "nixpkgs": "nixpkgs", + "rust-overlay": "rust-overlay" + } + }, + "rust-overlay": { + "inputs": { + "nixpkgs": "nixpkgs_2" + }, + "locked": { + "lastModified": 1739759407, + "narHash": "sha256-YIrVxD2SaUyaEdMry2nAd2qG1E0V38QIV6t6rpguFwk=", + "owner": "oxalica", + "repo": "rust-overlay", + "rev": "6e6ae2acf4221380140c22d65b6c41f4726f5932", + "type": "github" + }, + "original": { + "owner": "oxalica", + "repo": "rust-overlay", + "type": "github" + } + }, + "systems": { + "locked": { + "lastModified": 1681028828, + "narHash": "sha256-Vy1rq5AaRuLzOxct8nz4T6wlgyUR7zLU309k9mBC768=", + "owner": "nix-systems", + "repo": "default", + "rev": "da67096a3b9bf56a91d16901293e51ba5b49a27e", + "type": "github" + }, + "original": { + "owner": "nix-systems", + "repo": "default", + "type": "github" + } + } + }, + "root": "root", + "version": 7 +} diff --git a/collector/compile-benchmarks/typenum-1.18.0/flake.nix b/collector/compile-benchmarks/typenum-1.18.0/flake.nix new file mode 100644 index 000000000..1cb6aafea --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.18.0/flake.nix @@ -0,0 +1,42 @@ +{ + inputs = { + nixpkgs.url = "nixpkgs/nixos-unstable"; + flake-utils.url = "github:numtide/flake-utils"; + rust-overlay.url = "github:oxalica/rust-overlay"; + }; + + outputs = + { + nixpkgs, + flake-utils, + rust-overlay, + ... + }: + flake-utils.lib.eachDefaultSystem ( + system: + let + overlays = [ + (import rust-overlay) + ]; + pkgs = import nixpkgs { + inherit system overlays; + }; + + rust = pkgs.rust-bin.stable.latest.default.override { + extensions = [ + "rust-analyzer" + "rust-src" + ]; + }; + in + { + devShells.default = pkgs.mkShell { + packages = [ + pkgs.just + rust + ]; + }; + + } + ); +} diff --git a/collector/compile-benchmarks/typenum-1.18.0/justfile b/collector/compile-benchmarks/typenum-1.18.0/justfile new file mode 100644 index 000000000..d50310ee4 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.18.0/justfile @@ -0,0 +1,34 @@ +# Generate code and run lints and tests +test-local: gen lint test + @just test --features const-generics + +# Produce generated code +gen: + cargo run --package generate + cargo fmt + +# Update lockfiles +up: + nix flake update + cargo update + +# Run all lints +lint: fmt-check clippy clippy-all + +# Check formatting +fmt-check: + cargo fmt --all -- --check + +# Clippy +clippy: + cargo clippy -- -D warnings + +# Clippy with all features +clippy-all: + # Allow deprecated because we test the no_std feature. + cargo clippy --all-features -- -D warnings -A deprecated + +# Run test +test *args: + cargo test --verbose --features "strict" {{args}} + cargo doc --features "strict" {{args}} diff --git a/collector/compile-benchmarks/typenum-1.18.0/perf-config.json b/collector/compile-benchmarks/typenum-1.18.0/perf-config.json new file mode 100644 index 000000000..710581fa8 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.18.0/perf-config.json @@ -0,0 +1,4 @@ +{ + "artifact": "library", + "category": "primary" +} diff --git a/collector/compile-benchmarks/typenum-1.18.0/src/array.rs b/collector/compile-benchmarks/typenum-1.18.0/src/array.rs new file mode 100644 index 000000000..19483c0da --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.18.0/src/array.rs @@ -0,0 +1,396 @@ +//! A type-level array of type-level numbers. +//! +//! It is not very featureful right now, and should be considered a work in progress. + +use core::ops::{Add, Div, Mul, Sub}; + +use super::*; + +/// The terminating type for type arrays. +#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Debug)] +#[cfg_attr(feature = "scale_info", derive(scale_info::TypeInfo))] +pub struct ATerm; + +impl TypeArray for ATerm {} + +/// `TArr` is a type that acts as an array of types. It is defined similarly to `UInt`, only its +/// values can be more than bits, and it is designed to act as an array. So you can only add two if +/// they have the same number of elements, for example. +/// +/// This array is only really designed to contain `Integer` types. If you use it with others, you +/// may find it lacking functionality. +#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Debug)] +#[cfg_attr(feature = "scale_info", derive(scale_info::TypeInfo))] +pub struct TArr { + first: V, + rest: A, +} + +impl TypeArray for TArr {} + +/// Create a new type-level array. Only usable on Rust 1.13.0 or newer. +/// +/// There's not a whole lot you can do with it right now. +/// +/// # Example +/// ```rust +/// #[macro_use] +/// extern crate typenum; +/// use typenum::consts::*; +/// +/// type Array = tarr![P3, N4, Z0, P38]; +/// # fn main() { let _: Array; } +#[macro_export] +macro_rules! tarr { + () => ( $crate::ATerm ); + ($n:ty) => ( $crate::TArr<$n, $crate::ATerm> ); + ($n:ty,) => ( $crate::TArr<$n, $crate::ATerm> ); + ($n:ty, $($tail:ty),+) => ( $crate::TArr<$n, tarr![$($tail),+]> ); + ($n:ty, $($tail:ty),+,) => ( $crate::TArr<$n, tarr![$($tail),+]> ); + ($n:ty | $rest:ty) => ( $crate::TArr<$n, $rest> ); + ($n:ty, $($tail:ty),+ | $rest:ty) => ( $crate::TArr<$n, ta![$($tail),+ | $rest]> ); +} + +// --------------------------------------------------------------------------------------- +// Length + +/// Length of `ATerm` by itself is 0 +impl Len for ATerm { + type Output = U0; + #[inline] + fn len(&self) -> Self::Output { + UTerm + } +} + +/// Size of a `TypeArray` +impl Len for TArr +where + A: Len, + Length: Add, + Sum, B1>: Unsigned, +{ + type Output = Add1>; + #[inline] + fn len(&self) -> Self::Output { + self.rest.len() + B1 + } +} + +// --------------------------------------------------------------------------------------- +// FoldAdd + +/// Hide our `Null` type +const _: () = { + /// A type which contributes nothing when adding (i.e. a zero) + pub struct Null; + impl Add for Null { + type Output = T; + fn add(self, rhs: T) -> Self::Output { + rhs + } + } + + impl FoldAdd for ATerm { + type Output = Null; + } +}; + +impl FoldAdd for TArr +where + A: FoldAdd, + FoldSum: Add, +{ + type Output = Sum, V>; +} + +// --------------------------------------------------------------------------------------- +// FoldMul + +/// Hide our `Null` type +const _: () = { + /// A type which contributes nothing when multiplying (i.e. a one) + pub struct Null; + impl Mul for Null { + type Output = T; + fn mul(self, rhs: T) -> Self::Output { + rhs + } + } + + impl FoldMul for ATerm { + type Output = Null; + } +}; + +impl FoldMul for TArr +where + A: FoldMul, + FoldProd: Mul, +{ + type Output = Prod, V>; +} + +// --------------------------------------------------------------------------------------- +// Add arrays +// Note that two arrays are only addable if they are the same length. + +impl Add for ATerm { + type Output = ATerm; + #[inline] + fn add(self, _: ATerm) -> Self::Output { + ATerm + } +} + +impl Add> for TArr +where + Al: Add, + Vl: Add, +{ + type Output = TArr, Sum>; + #[inline] + fn add(self, rhs: TArr) -> Self::Output { + TArr { + first: self.first + rhs.first, + rest: self.rest + rhs.rest, + } + } +} + +// --------------------------------------------------------------------------------------- +// Subtract arrays +// Note that two arrays are only subtractable if they are the same length. + +impl Sub for ATerm { + type Output = ATerm; + #[inline] + fn sub(self, _: ATerm) -> Self::Output { + ATerm + } +} + +impl Sub> for TArr +where + Vl: Sub, + Al: Sub, +{ + type Output = TArr, Diff>; + #[inline] + fn sub(self, rhs: TArr) -> Self::Output { + TArr { + first: self.first - rhs.first, + rest: self.rest - rhs.rest, + } + } +} + +// --------------------------------------------------------------------------------------- +// Multiply an array by a scalar + +impl Mul for ATerm { + type Output = ATerm; + #[inline] + fn mul(self, _: Rhs) -> Self::Output { + ATerm + } +} + +impl Mul for TArr +where + V: Mul, + A: Mul, + Rhs: Copy, +{ + type Output = TArr, Prod>; + #[inline] + fn mul(self, rhs: Rhs) -> Self::Output { + TArr { + first: self.first * rhs, + rest: self.rest * rhs, + } + } +} + +impl Mul for Z0 { + type Output = ATerm; + #[inline] + fn mul(self, _: ATerm) -> Self::Output { + ATerm + } +} + +impl Mul for PInt +where + U: Unsigned + NonZero, +{ + type Output = ATerm; + #[inline] + fn mul(self, _: ATerm) -> Self::Output { + ATerm + } +} + +impl Mul for NInt +where + U: Unsigned + NonZero, +{ + type Output = ATerm; + #[inline] + fn mul(self, _: ATerm) -> Self::Output { + ATerm + } +} + +impl Mul> for Z0 +where + Z0: Mul, +{ + type Output = TArr>; + #[inline] + fn mul(self, rhs: TArr) -> Self::Output { + TArr { + first: Z0, + rest: self * rhs.rest, + } + } +} + +impl Mul> for PInt +where + U: Unsigned + NonZero, + PInt: Mul + Mul, +{ + type Output = TArr, V>, Prod, A>>; + #[inline] + fn mul(self, rhs: TArr) -> Self::Output { + TArr { + first: self * rhs.first, + rest: self * rhs.rest, + } + } +} + +impl Mul> for NInt +where + U: Unsigned + NonZero, + NInt: Mul + Mul, +{ + type Output = TArr, V>, Prod, A>>; + #[inline] + fn mul(self, rhs: TArr) -> Self::Output { + TArr { + first: self * rhs.first, + rest: self * rhs.rest, + } + } +} + +// --------------------------------------------------------------------------------------- +// Divide an array by a scalar + +impl Div for ATerm { + type Output = ATerm; + #[inline] + fn div(self, _: Rhs) -> Self::Output { + ATerm + } +} + +impl Div for TArr +where + V: Div, + A: Div, + Rhs: Copy, +{ + type Output = TArr, Quot>; + #[inline] + fn div(self, rhs: Rhs) -> Self::Output { + TArr { + first: self.first / rhs, + rest: self.rest / rhs, + } + } +} + +// --------------------------------------------------------------------------------------- +// Partial Divide an array by a scalar + +impl PartialDiv for ATerm { + type Output = ATerm; + #[inline] + fn partial_div(self, _: Rhs) -> Self::Output { + ATerm + } +} + +impl PartialDiv for TArr +where + V: PartialDiv, + A: PartialDiv, + Rhs: Copy, +{ + type Output = TArr, PartialQuot>; + #[inline] + fn partial_div(self, rhs: Rhs) -> Self::Output { + TArr { + first: self.first.partial_div(rhs), + rest: self.rest.partial_div(rhs), + } + } +} + +// --------------------------------------------------------------------------------------- +// Modulo an array by a scalar +use core::ops::Rem; + +impl Rem for ATerm { + type Output = ATerm; + #[inline] + fn rem(self, _: Rhs) -> Self::Output { + ATerm + } +} + +impl Rem for TArr +where + V: Rem, + A: Rem, + Rhs: Copy, +{ + type Output = TArr, Mod>; + #[inline] + fn rem(self, rhs: Rhs) -> Self::Output { + TArr { + first: self.first % rhs, + rest: self.rest % rhs, + } + } +} + +// --------------------------------------------------------------------------------------- +// Negate an array +use core::ops::Neg; + +impl Neg for ATerm { + type Output = ATerm; + #[inline] + fn neg(self) -> Self::Output { + ATerm + } +} + +impl Neg for TArr +where + V: Neg, + A: Neg, +{ + type Output = TArr, Negate>; + #[inline] + fn neg(self) -> Self::Output { + TArr { + first: -self.first, + rest: -self.rest, + } + } +} diff --git a/collector/compile-benchmarks/typenum-1.18.0/src/bit.rs b/collector/compile-benchmarks/typenum-1.18.0/src/bit.rs new file mode 100644 index 000000000..4e3f3e87e --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.18.0/src/bit.rs @@ -0,0 +1,347 @@ +//! Type-level bits. +//! +//! These are rather simple and are used as the building blocks of the +//! other number types in this crate. +//! +//! +//! **Type operators** implemented: +//! +//! - From `core::ops`: `BitAnd`, `BitOr`, `BitXor`, and `Not`. +//! - From `typenum`: `Same` and `Cmp`. + +use crate::{private::InternalMarker, Cmp, Equal, Greater, Less, NonZero, PowerOfTwo, Zero}; +use core::ops::{BitAnd, BitOr, BitXor, Not}; + +pub use crate::marker_traits::Bit; + +/// The type-level bit 0. +#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Debug, Default)] +#[cfg_attr(feature = "scale_info", derive(scale_info::TypeInfo))] +pub struct B0; + +impl B0 { + /// Instantiates a singleton representing this bit. + #[inline] + pub fn new() -> B0 { + B0 + } +} + +/// The type-level bit 1. +#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Debug, Default)] +#[cfg_attr(feature = "scale_info", derive(scale_info::TypeInfo))] +pub struct B1; + +impl B1 { + /// Instantiates a singleton representing this bit. + #[inline] + pub fn new() -> B1 { + B1 + } +} + +impl Bit for B0 { + const U8: u8 = 0; + const BOOL: bool = false; + + #[inline] + fn new() -> Self { + Self + } + #[inline] + fn to_u8() -> u8 { + 0 + } + #[inline] + fn to_bool() -> bool { + false + } +} + +impl Bit for B1 { + const U8: u8 = 1; + const BOOL: bool = true; + + #[inline] + fn new() -> Self { + Self + } + #[inline] + fn to_u8() -> u8 { + 1 + } + #[inline] + fn to_bool() -> bool { + true + } +} + +impl Zero for B0 {} +impl NonZero for B1 {} +impl PowerOfTwo for B1 {} + +/// Not of 0 (!0 = 1) +impl Not for B0 { + type Output = B1; + #[inline] + fn not(self) -> Self::Output { + B1 + } +} +/// Not of 1 (!1 = 0) +impl Not for B1 { + type Output = B0; + #[inline] + fn not(self) -> Self::Output { + B0 + } +} + +/// And with 0 ( 0 & B = 0) +impl BitAnd for B0 { + type Output = B0; + #[inline] + fn bitand(self, _: Rhs) -> Self::Output { + B0 + } +} + +/// And with 1 ( 1 & 0 = 0) +impl BitAnd for B1 { + type Output = B0; + #[inline] + fn bitand(self, _: B0) -> Self::Output { + B0 + } +} + +/// And with 1 ( 1 & 1 = 1) +impl BitAnd for B1 { + type Output = B1; + #[inline] + fn bitand(self, _: B1) -> Self::Output { + B1 + } +} + +/// Or with 0 ( 0 | 0 = 0) +impl BitOr for B0 { + type Output = B0; + #[inline] + fn bitor(self, _: B0) -> Self::Output { + B0 + } +} + +/// Or with 0 ( 0 | 1 = 1) +impl BitOr for B0 { + type Output = B1; + #[inline] + fn bitor(self, _: B1) -> Self::Output { + B1 + } +} + +/// Or with 1 ( 1 | B = 1) +impl BitOr for B1 { + type Output = B1; + #[inline] + fn bitor(self, _: Rhs) -> Self::Output { + B1 + } +} + +/// Xor between 0 and 0 ( 0 ^ 0 = 0) +impl BitXor for B0 { + type Output = B0; + #[inline] + fn bitxor(self, _: B0) -> Self::Output { + B0 + } +} +/// Xor between 1 and 0 ( 1 ^ 0 = 1) +impl BitXor for B1 { + type Output = B1; + #[inline] + fn bitxor(self, _: B0) -> Self::Output { + B1 + } +} +/// Xor between 0 and 1 ( 0 ^ 1 = 1) +impl BitXor for B0 { + type Output = B1; + #[inline] + fn bitxor(self, _: B1) -> Self::Output { + B1 + } +} +/// Xor between 1 and 1 ( 1 ^ 1 = 0) +impl BitXor for B1 { + type Output = B0; + #[inline] + fn bitxor(self, _: B1) -> Self::Output { + B0 + } +} + +#[cfg(test)] +mod bit_op_tests { + use core::ops::{BitAnd, BitOr, BitXor, Not}; + + use crate::{B0, B1}; + + // macro for testing operation results. Uses `Same` to ensure the types are equal and + // not just the values they evaluate to. + macro_rules! test_bit_op { + ($op:ident $Lhs:ident = $Answer:ident) => {{ + type Test = <<$Lhs as $op>::Output as $crate::Same<$Answer>>::Output; + assert_eq!( + <$Answer as $crate::Bit>::to_u8(), + ::to_u8() + ); + }}; + ($Lhs:ident $op:ident $Rhs:ident = $Answer:ident) => {{ + type Test = <<$Lhs as $op<$Rhs>>::Output as $crate::Same<$Answer>>::Output; + assert_eq!( + <$Answer as $crate::Bit>::to_u8(), + ::to_u8() + ); + }}; + } + + #[test] + fn bit_operations() { + test_bit_op!(Not B0 = B1); + test_bit_op!(Not B1 = B0); + + test_bit_op!(B0 BitAnd B0 = B0); + test_bit_op!(B0 BitAnd B1 = B0); + test_bit_op!(B1 BitAnd B0 = B0); + test_bit_op!(B1 BitAnd B1 = B1); + + test_bit_op!(B0 BitOr B0 = B0); + test_bit_op!(B0 BitOr B1 = B1); + test_bit_op!(B1 BitOr B0 = B1); + test_bit_op!(B1 BitOr B1 = B1); + + test_bit_op!(B0 BitXor B0 = B0); + test_bit_op!(B0 BitXor B1 = B1); + test_bit_op!(B1 BitXor B0 = B1); + test_bit_op!(B1 BitXor B1 = B0); + } +} + +impl Cmp for B0 { + type Output = Equal; + + #[inline] + fn compare(&self, _: &B0) -> Self::Output { + Equal + } +} + +impl Cmp for B0 { + type Output = Less; + + #[inline] + fn compare(&self, _: &B1) -> Self::Output { + Less + } +} + +impl Cmp for B1 { + type Output = Greater; + + #[inline] + fn compare(&self, _: &B0) -> Self::Output { + Greater + } +} + +impl Cmp for B1 { + type Output = Equal; + + #[inline] + fn compare(&self, _: &B1) -> Self::Output { + Equal + } +} + +use crate::Min; +impl Min for B0 { + type Output = B0; + #[inline] + fn min(self, _: B0) -> B0 { + self + } +} +impl Min for B0 { + type Output = B0; + #[inline] + fn min(self, _: B1) -> B0 { + self + } +} +impl Min for B1 { + type Output = B0; + #[inline] + fn min(self, rhs: B0) -> B0 { + rhs + } +} +impl Min for B1 { + type Output = B1; + #[inline] + fn min(self, _: B1) -> B1 { + self + } +} + +use crate::Max; +impl Max for B0 { + type Output = B0; + #[inline] + fn max(self, _: B0) -> B0 { + self + } +} +impl Max for B0 { + type Output = B1; + #[inline] + fn max(self, rhs: B1) -> B1 { + rhs + } +} +impl Max for B1 { + type Output = B1; + #[inline] + fn max(self, _: B0) -> B1 { + self + } +} +impl Max for B1 { + type Output = B1; + #[inline] + fn max(self, _: B1) -> B1 { + self + } +} + +#[cfg(test)] +mod bit_creation_tests { + #[test] + fn bit_creation() { + { + use crate::{B0, B1}; + let _: B0 = B0::new(); + let _: B1 = B1::new(); + } + + { + use crate::{Bit, B0, B1}; + + let _: B0 = ::new(); + let _: B1 = ::new(); + } + } +} diff --git a/collector/compile-benchmarks/typenum-1.18.0/src/gen.rs b/collector/compile-benchmarks/typenum-1.18.0/src/gen.rs new file mode 100644 index 000000000..86ab77c93 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.18.0/src/gen.rs @@ -0,0 +1,4 @@ +pub mod consts; +#[cfg(feature = "const-generics")] +pub mod generic_const_mappings; +pub mod op; diff --git a/collector/compile-benchmarks/typenum-1.18.0/src/gen/consts.rs b/collector/compile-benchmarks/typenum-1.18.0/src/gen/consts.rs new file mode 100644 index 000000000..0aafdd3a2 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.18.0/src/gen/consts.rs @@ -0,0 +1,5899 @@ +// THIS IS GENERATED CODE +#![allow(missing_docs)] +use crate::int::{NInt, PInt}; +/** +Type aliases for many constants. + +This file is generated by typenum's build script. + +For unsigned integers, the format is `U` followed by the number. We define aliases for + +- Numbers 0 through 1024 +- Powers of 2 below `u64::MAX` +- Powers of 10 below `u64::MAX` + +These alias definitions look like this: + +```rust +use typenum::{B0, B1, UInt, UTerm}; + +# #[allow(dead_code)] +type U6 = UInt, B1>, B0>; +``` + +For positive signed integers, the format is `P` followed by the number and for negative +signed integers it is `N` followed by the number. For the signed integer zero, we use +`Z0`. We define aliases for + +- Numbers -1024 through 1024 +- Powers of 2 between `i64::MIN` and `i64::MAX` +- Powers of 10 between `i64::MIN` and `i64::MAX` + +These alias definitions look like this: + +```rust +use typenum::{B0, B1, UInt, UTerm, PInt, NInt}; + +# #[allow(dead_code)] +type P6 = PInt, B1>, B0>>; +# #[allow(dead_code)] +type N6 = NInt, B1>, B0>>; +``` + +# Example +```rust +# #[allow(unused_imports)] +use typenum::{U0, U1, U2, U3, U4, U5, U6}; +# #[allow(unused_imports)] +use typenum::{N3, N2, N1, Z0, P1, P2, P3}; +# #[allow(unused_imports)] +use typenum::{U774, N17, N10000, P1024, P4096}; +``` + +We also define the aliases `False` and `True` for `B0` and `B1`, respectively. +*/ +use crate::uint::{UInt, UTerm}; + +pub use crate::bit::{B0, B1}; +pub use crate::int::Z0; + +pub type True = B1; +pub type False = B0; +pub type U0 = UTerm; +pub type U1 = UInt; +pub type P1 = PInt; +pub type N1 = NInt; +pub type U2 = UInt, B0>; +pub type P2 = PInt; +pub type N2 = NInt; +pub type U3 = UInt, B1>; +pub type P3 = PInt; +pub type N3 = NInt; +pub type U4 = UInt, B0>, B0>; +pub type P4 = PInt; +pub type N4 = NInt; +pub type U5 = UInt, B0>, B1>; +pub type P5 = PInt; +pub type N5 = NInt; +pub type U6 = UInt, B1>, B0>; +pub type P6 = PInt; +pub type N6 = NInt; +pub type U7 = UInt, B1>, B1>; +pub type P7 = PInt; +pub type N7 = NInt; +pub type U8 = UInt, B0>, B0>, B0>; +pub type P8 = PInt; +pub type N8 = NInt; +pub type U9 = UInt, B0>, B0>, B1>; +pub type P9 = PInt; +pub type N9 = NInt; +pub type U10 = UInt, B0>, B1>, B0>; +pub type P10 = PInt; +pub type N10 = NInt; +pub type U11 = UInt, B0>, B1>, B1>; +pub type P11 = PInt; +pub type N11 = NInt; +pub type U12 = UInt, B1>, B0>, B0>; +pub type P12 = PInt; +pub type N12 = NInt; +pub type U13 = UInt, B1>, B0>, B1>; +pub type P13 = PInt; +pub type N13 = NInt; +pub type U14 = UInt, B1>, B1>, B0>; +pub type P14 = PInt; +pub type N14 = NInt; +pub type U15 = UInt, B1>, B1>, B1>; +pub type P15 = PInt; +pub type N15 = NInt; +pub type U16 = UInt, B0>, B0>, B0>, B0>; +pub type P16 = PInt; +pub type N16 = NInt; +pub type U17 = UInt, B0>, B0>, B0>, B1>; +pub type P17 = PInt; +pub type N17 = NInt; +pub type U18 = UInt, B0>, B0>, B1>, B0>; +pub type P18 = PInt; +pub type N18 = NInt; +pub type U19 = UInt, B0>, B0>, B1>, B1>; +pub type P19 = PInt; +pub type N19 = NInt; +pub type U20 = UInt, B0>, B1>, B0>, B0>; +pub type P20 = PInt; +pub type N20 = NInt; +pub type U21 = UInt, B0>, B1>, B0>, B1>; +pub type P21 = PInt; +pub type N21 = NInt; +pub type U22 = UInt, B0>, B1>, B1>, B0>; +pub type P22 = PInt; +pub type N22 = NInt; +pub type U23 = UInt, B0>, B1>, B1>, B1>; +pub type P23 = PInt; +pub type N23 = NInt; +pub type U24 = UInt, B1>, B0>, B0>, B0>; +pub type P24 = PInt; +pub type N24 = NInt; +pub type U25 = UInt, B1>, B0>, B0>, B1>; +pub type P25 = PInt; +pub type N25 = NInt; +pub type U26 = UInt, B1>, B0>, B1>, B0>; +pub type P26 = PInt; +pub type N26 = NInt; +pub type U27 = UInt, B1>, B0>, B1>, B1>; +pub type P27 = PInt; +pub type N27 = NInt; +pub type U28 = UInt, B1>, B1>, B0>, B0>; +pub type P28 = PInt; +pub type N28 = NInt; +pub type U29 = UInt, B1>, B1>, B0>, B1>; +pub type P29 = PInt; +pub type N29 = NInt; +pub type U30 = UInt, B1>, B1>, B1>, B0>; +pub type P30 = PInt; +pub type N30 = NInt; +pub type U31 = UInt, B1>, B1>, B1>, B1>; +pub type P31 = PInt; +pub type N31 = NInt; +pub type U32 = UInt, B0>, B0>, B0>, B0>, B0>; +pub type P32 = PInt; +pub type N32 = NInt; +pub type U33 = UInt, B0>, B0>, B0>, B0>, B1>; +pub type P33 = PInt; +pub type N33 = NInt; +pub type U34 = UInt, B0>, B0>, B0>, B1>, B0>; +pub type P34 = PInt; +pub type N34 = NInt; +pub type U35 = UInt, B0>, B0>, B0>, B1>, B1>; +pub type P35 = PInt; +pub type N35 = NInt; +pub type U36 = UInt, B0>, B0>, B1>, B0>, B0>; +pub type P36 = PInt; +pub type N36 = NInt; +pub type U37 = UInt, B0>, B0>, B1>, B0>, B1>; +pub type P37 = PInt; +pub type N37 = NInt; +pub type U38 = UInt, B0>, B0>, B1>, B1>, B0>; +pub type P38 = PInt; +pub type N38 = NInt; +pub type U39 = UInt, B0>, B0>, B1>, B1>, B1>; +pub type P39 = PInt; +pub type N39 = NInt; +pub type U40 = UInt, B0>, B1>, B0>, B0>, B0>; +pub type P40 = PInt; +pub type N40 = NInt; +pub type U41 = UInt, B0>, B1>, B0>, B0>, B1>; +pub type P41 = PInt; +pub type N41 = NInt; +pub type U42 = UInt, B0>, B1>, B0>, B1>, B0>; +pub type P42 = PInt; +pub type N42 = NInt; +pub type U43 = UInt, B0>, B1>, B0>, B1>, B1>; +pub type P43 = PInt; +pub type N43 = NInt; +pub type U44 = UInt, B0>, B1>, B1>, B0>, B0>; +pub type P44 = PInt; +pub type N44 = NInt; +pub type U45 = UInt, B0>, B1>, B1>, B0>, B1>; +pub type P45 = PInt; +pub type N45 = NInt; +pub type U46 = UInt, B0>, B1>, B1>, B1>, B0>; +pub type P46 = PInt; +pub type N46 = NInt; +pub type U47 = UInt, B0>, B1>, B1>, B1>, B1>; +pub type P47 = PInt; +pub type N47 = NInt; +pub type U48 = UInt, B1>, B0>, B0>, B0>, B0>; +pub type P48 = PInt; +pub type N48 = NInt; +pub type U49 = UInt, B1>, B0>, B0>, B0>, B1>; +pub type P49 = PInt; +pub type N49 = NInt; +pub type U50 = UInt, B1>, B0>, B0>, B1>, B0>; +pub type P50 = PInt; +pub type N50 = NInt; +pub type U51 = UInt, B1>, B0>, B0>, B1>, B1>; +pub type P51 = PInt; +pub type N51 = NInt; +pub type U52 = UInt, B1>, B0>, B1>, B0>, B0>; +pub type P52 = PInt; +pub type N52 = NInt; +pub type U53 = UInt, B1>, B0>, B1>, B0>, B1>; +pub type P53 = PInt; +pub type N53 = NInt; +pub type U54 = UInt, B1>, B0>, B1>, B1>, B0>; +pub type P54 = PInt; +pub type N54 = NInt; +pub type U55 = UInt, B1>, B0>, B1>, B1>, B1>; +pub type P55 = PInt; +pub type N55 = NInt; +pub type U56 = UInt, B1>, B1>, B0>, B0>, B0>; +pub type P56 = PInt; +pub type N56 = NInt; +pub type U57 = UInt, B1>, B1>, B0>, B0>, B1>; +pub type P57 = PInt; +pub type N57 = NInt; +pub type U58 = UInt, B1>, B1>, B0>, B1>, B0>; +pub type P58 = PInt; +pub type N58 = NInt; +pub type U59 = UInt, B1>, B1>, B0>, B1>, B1>; +pub type P59 = PInt; +pub type N59 = NInt; +pub type U60 = UInt, B1>, B1>, B1>, B0>, B0>; +pub type P60 = PInt; +pub type N60 = NInt; +pub type U61 = UInt, B1>, B1>, B1>, B0>, B1>; +pub type P61 = PInt; +pub type N61 = NInt; +pub type U62 = UInt, B1>, B1>, B1>, B1>, B0>; +pub type P62 = PInt; +pub type N62 = NInt; +pub type U63 = UInt, B1>, B1>, B1>, B1>, B1>; +pub type P63 = PInt; +pub type N63 = NInt; +pub type U64 = UInt, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P64 = PInt; +pub type N64 = NInt; +pub type U65 = UInt, B0>, B0>, B0>, B0>, B0>, B1>; +pub type P65 = PInt; +pub type N65 = NInt; +pub type U66 = UInt, B0>, B0>, B0>, B0>, B1>, B0>; +pub type P66 = PInt; +pub type N66 = NInt; +pub type U67 = UInt, B0>, B0>, B0>, B0>, B1>, B1>; +pub type P67 = PInt; +pub type N67 = NInt; +pub type U68 = UInt, B0>, B0>, B0>, B1>, B0>, B0>; +pub type P68 = PInt; +pub type N68 = NInt; +pub type U69 = UInt, B0>, B0>, B0>, B1>, B0>, B1>; +pub type P69 = PInt; +pub type N69 = NInt; +pub type U70 = UInt, B0>, B0>, B0>, B1>, B1>, B0>; +pub type P70 = PInt; +pub type N70 = NInt; +pub type U71 = UInt, B0>, B0>, B0>, B1>, B1>, B1>; +pub type P71 = PInt; +pub type N71 = NInt; +pub type U72 = UInt, B0>, B0>, B1>, B0>, B0>, B0>; +pub type P72 = PInt; +pub type N72 = NInt; +pub type U73 = UInt, B0>, B0>, B1>, B0>, B0>, B1>; +pub type P73 = PInt; +pub type N73 = NInt; +pub type U74 = UInt, B0>, B0>, B1>, B0>, B1>, B0>; +pub type P74 = PInt; +pub type N74 = NInt; +pub type U75 = UInt, B0>, B0>, B1>, B0>, B1>, B1>; +pub type P75 = PInt; +pub type N75 = NInt; +pub type U76 = UInt, B0>, B0>, B1>, B1>, B0>, B0>; +pub type P76 = PInt; +pub type N76 = NInt; +pub type U77 = UInt, B0>, B0>, B1>, B1>, B0>, B1>; +pub type P77 = PInt; +pub type N77 = NInt; +pub type U78 = UInt, B0>, B0>, B1>, B1>, B1>, B0>; +pub type P78 = PInt; +pub type N78 = NInt; +pub type U79 = UInt, B0>, B0>, B1>, B1>, B1>, B1>; +pub type P79 = PInt; +pub type N79 = NInt; +pub type U80 = UInt, B0>, B1>, B0>, B0>, B0>, B0>; +pub type P80 = PInt; +pub type N80 = NInt; +pub type U81 = UInt, B0>, B1>, B0>, B0>, B0>, B1>; +pub type P81 = PInt; +pub type N81 = NInt; +pub type U82 = UInt, B0>, B1>, B0>, B0>, B1>, B0>; +pub type P82 = PInt; +pub type N82 = NInt; +pub type U83 = UInt, B0>, B1>, B0>, B0>, B1>, B1>; +pub type P83 = PInt; +pub type N83 = NInt; +pub type U84 = UInt, B0>, B1>, B0>, B1>, B0>, B0>; +pub type P84 = PInt; +pub type N84 = NInt; +pub type U85 = UInt, B0>, B1>, B0>, B1>, B0>, B1>; +pub type P85 = PInt; +pub type N85 = NInt; +pub type U86 = UInt, B0>, B1>, B0>, B1>, B1>, B0>; +pub type P86 = PInt; +pub type N86 = NInt; +pub type U87 = UInt, B0>, B1>, B0>, B1>, B1>, B1>; +pub type P87 = PInt; +pub type N87 = NInt; +pub type U88 = UInt, B0>, B1>, B1>, B0>, B0>, B0>; +pub type P88 = PInt; +pub type N88 = NInt; +pub type U89 = UInt, B0>, B1>, B1>, B0>, B0>, B1>; +pub type P89 = PInt; +pub type N89 = NInt; +pub type U90 = UInt, B0>, B1>, B1>, B0>, B1>, B0>; +pub type P90 = PInt; +pub type N90 = NInt; +pub type U91 = UInt, B0>, B1>, B1>, B0>, B1>, B1>; +pub type P91 = PInt; +pub type N91 = NInt; +pub type U92 = UInt, B0>, B1>, B1>, B1>, B0>, B0>; +pub type P92 = PInt; +pub type N92 = NInt; +pub type U93 = UInt, B0>, B1>, B1>, B1>, B0>, B1>; +pub type P93 = PInt; +pub type N93 = NInt; +pub type U94 = UInt, B0>, B1>, B1>, B1>, B1>, B0>; +pub type P94 = PInt; +pub type N94 = NInt; +pub type U95 = UInt, B0>, B1>, B1>, B1>, B1>, B1>; +pub type P95 = PInt; +pub type N95 = NInt; +pub type U96 = UInt, B1>, B0>, B0>, B0>, B0>, B0>; +pub type P96 = PInt; +pub type N96 = NInt; +pub type U97 = UInt, B1>, B0>, B0>, B0>, B0>, B1>; +pub type P97 = PInt; +pub type N97 = NInt; +pub type U98 = UInt, B1>, B0>, B0>, B0>, B1>, B0>; +pub type P98 = PInt; +pub type N98 = NInt; +pub type U99 = UInt, B1>, B0>, B0>, B0>, B1>, B1>; +pub type P99 = PInt; +pub type N99 = NInt; +pub type U100 = UInt, B1>, B0>, B0>, B1>, B0>, B0>; +pub type P100 = PInt; +pub type N100 = NInt; +pub type U101 = UInt, B1>, B0>, B0>, B1>, B0>, B1>; +pub type P101 = PInt; +pub type N101 = NInt; +pub type U102 = UInt, B1>, B0>, B0>, B1>, B1>, B0>; +pub type P102 = PInt; +pub type N102 = NInt; +pub type U103 = UInt, B1>, B0>, B0>, B1>, B1>, B1>; +pub type P103 = PInt; +pub type N103 = NInt; +pub type U104 = UInt, B1>, B0>, B1>, B0>, B0>, B0>; +pub type P104 = PInt; +pub type N104 = NInt; +pub type U105 = UInt, B1>, B0>, B1>, B0>, B0>, B1>; +pub type P105 = PInt; +pub type N105 = NInt; +pub type U106 = UInt, B1>, B0>, B1>, B0>, B1>, B0>; +pub type P106 = PInt; +pub type N106 = NInt; +pub type U107 = UInt, B1>, B0>, B1>, B0>, B1>, B1>; +pub type P107 = PInt; +pub type N107 = NInt; +pub type U108 = UInt, B1>, B0>, B1>, B1>, B0>, B0>; +pub type P108 = PInt; +pub type N108 = NInt; +pub type U109 = UInt, B1>, B0>, B1>, B1>, B0>, B1>; +pub type P109 = PInt; +pub type N109 = NInt; +pub type U110 = UInt, B1>, B0>, B1>, B1>, B1>, B0>; +pub type P110 = PInt; +pub type N110 = NInt; +pub type U111 = UInt, B1>, B0>, B1>, B1>, B1>, B1>; +pub type P111 = PInt; +pub type N111 = NInt; +pub type U112 = UInt, B1>, B1>, B0>, B0>, B0>, B0>; +pub type P112 = PInt; +pub type N112 = NInt; +pub type U113 = UInt, B1>, B1>, B0>, B0>, B0>, B1>; +pub type P113 = PInt; +pub type N113 = NInt; +pub type U114 = UInt, B1>, B1>, B0>, B0>, B1>, B0>; +pub type P114 = PInt; +pub type N114 = NInt; +pub type U115 = UInt, B1>, B1>, B0>, B0>, B1>, B1>; +pub type P115 = PInt; +pub type N115 = NInt; +pub type U116 = UInt, B1>, B1>, B0>, B1>, B0>, B0>; +pub type P116 = PInt; +pub type N116 = NInt; +pub type U117 = UInt, B1>, B1>, B0>, B1>, B0>, B1>; +pub type P117 = PInt; +pub type N117 = NInt; +pub type U118 = UInt, B1>, B1>, B0>, B1>, B1>, B0>; +pub type P118 = PInt; +pub type N118 = NInt; +pub type U119 = UInt, B1>, B1>, B0>, B1>, B1>, B1>; +pub type P119 = PInt; +pub type N119 = NInt; +pub type U120 = UInt, B1>, B1>, B1>, B0>, B0>, B0>; +pub type P120 = PInt; +pub type N120 = NInt; +pub type U121 = UInt, B1>, B1>, B1>, B0>, B0>, B1>; +pub type P121 = PInt; +pub type N121 = NInt; +pub type U122 = UInt, B1>, B1>, B1>, B0>, B1>, B0>; +pub type P122 = PInt; +pub type N122 = NInt; +pub type U123 = UInt, B1>, B1>, B1>, B0>, B1>, B1>; +pub type P123 = PInt; +pub type N123 = NInt; +pub type U124 = UInt, B1>, B1>, B1>, B1>, B0>, B0>; +pub type P124 = PInt; +pub type N124 = NInt; +pub type U125 = UInt, B1>, B1>, B1>, B1>, B0>, B1>; +pub type P125 = PInt; +pub type N125 = NInt; +pub type U126 = UInt, B1>, B1>, B1>, B1>, B1>, B0>; +pub type P126 = PInt; +pub type N126 = NInt; +pub type U127 = UInt, B1>, B1>, B1>, B1>, B1>, B1>; +pub type P127 = PInt; +pub type N127 = NInt; +pub type U128 = + UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P128 = PInt; +pub type N128 = NInt; +pub type U129 = + UInt, B0>, B0>, B0>, B0>, B0>, B0>, B1>; +pub type P129 = PInt; +pub type N129 = NInt; +pub type U130 = + UInt, B0>, B0>, B0>, B0>, B0>, B1>, B0>; +pub type P130 = PInt; +pub type N130 = NInt; +pub type U131 = + UInt, B0>, B0>, B0>, B0>, B0>, B1>, B1>; +pub type P131 = PInt; +pub type N131 = NInt; +pub type U132 = + UInt, B0>, B0>, B0>, B0>, B1>, B0>, B0>; +pub type P132 = PInt; +pub type N132 = NInt; +pub type U133 = + UInt, B0>, B0>, B0>, B0>, B1>, B0>, B1>; +pub type P133 = PInt; +pub type N133 = NInt; +pub type U134 = + UInt, B0>, B0>, B0>, B0>, B1>, B1>, B0>; +pub type P134 = PInt; +pub type N134 = NInt; +pub type U135 = + UInt, B0>, B0>, B0>, B0>, B1>, B1>, B1>; +pub type P135 = PInt; +pub type N135 = NInt; +pub type U136 = + UInt, B0>, B0>, B0>, B1>, B0>, B0>, B0>; +pub type P136 = PInt; +pub type N136 = NInt; +pub type U137 = + UInt, B0>, B0>, B0>, B1>, B0>, B0>, B1>; +pub type P137 = PInt; +pub type N137 = NInt; +pub type U138 = + UInt, B0>, B0>, B0>, B1>, B0>, B1>, B0>; +pub type P138 = PInt; +pub type N138 = NInt; +pub type U139 = + UInt, B0>, B0>, B0>, B1>, B0>, B1>, B1>; +pub type P139 = PInt; +pub type N139 = NInt; +pub type U140 = + UInt, B0>, B0>, B0>, B1>, B1>, B0>, B0>; +pub type P140 = PInt; +pub type N140 = NInt; +pub type U141 = + UInt, B0>, B0>, B0>, B1>, B1>, B0>, B1>; +pub type P141 = PInt; +pub type N141 = NInt; +pub type U142 = + UInt, B0>, B0>, B0>, B1>, B1>, B1>, B0>; +pub type P142 = PInt; +pub type N142 = NInt; +pub type U143 = + UInt, B0>, B0>, B0>, B1>, B1>, B1>, B1>; +pub type P143 = PInt; +pub type N143 = NInt; +pub type U144 = + UInt, B0>, B0>, B1>, B0>, B0>, B0>, B0>; +pub type P144 = PInt; +pub type N144 = NInt; +pub type U145 = + UInt, B0>, B0>, B1>, B0>, B0>, B0>, B1>; +pub type P145 = PInt; +pub type N145 = NInt; +pub type U146 = + UInt, B0>, B0>, B1>, B0>, B0>, B1>, B0>; +pub type P146 = PInt; +pub type N146 = NInt; +pub type U147 = + UInt, B0>, B0>, B1>, B0>, B0>, B1>, B1>; +pub type P147 = PInt; +pub type N147 = NInt; +pub type U148 = + UInt, B0>, B0>, B1>, B0>, B1>, B0>, B0>; +pub type P148 = PInt; +pub type N148 = NInt; +pub type U149 = + UInt, B0>, B0>, B1>, B0>, B1>, B0>, B1>; +pub type P149 = PInt; +pub type N149 = NInt; +pub type U150 = + UInt, B0>, B0>, B1>, B0>, B1>, B1>, B0>; +pub type P150 = PInt; +pub type N150 = NInt; +pub type U151 = + UInt, B0>, B0>, B1>, B0>, B1>, B1>, B1>; +pub type P151 = PInt; +pub type N151 = NInt; +pub type U152 = + UInt, B0>, B0>, B1>, B1>, B0>, B0>, B0>; +pub type P152 = PInt; +pub type N152 = NInt; +pub type U153 = + UInt, B0>, B0>, B1>, B1>, B0>, B0>, B1>; +pub type P153 = PInt; +pub type N153 = NInt; +pub type U154 = + UInt, B0>, B0>, B1>, B1>, B0>, B1>, B0>; +pub type P154 = PInt; +pub type N154 = NInt; +pub type U155 = + UInt, B0>, B0>, B1>, B1>, B0>, B1>, B1>; +pub type P155 = PInt; +pub type N155 = NInt; +pub type U156 = + UInt, B0>, B0>, B1>, B1>, B1>, B0>, B0>; +pub type P156 = PInt; +pub type N156 = NInt; +pub type U157 = + UInt, B0>, B0>, B1>, B1>, B1>, B0>, B1>; +pub type P157 = PInt; +pub type N157 = NInt; +pub type U158 = + UInt, B0>, B0>, B1>, B1>, B1>, B1>, B0>; +pub type P158 = PInt; +pub type N158 = NInt; +pub type U159 = + UInt, B0>, B0>, B1>, B1>, B1>, B1>, B1>; +pub type P159 = PInt; +pub type N159 = NInt; +pub type U160 = + UInt, B0>, B1>, B0>, B0>, B0>, B0>, B0>; +pub type P160 = PInt; +pub type N160 = NInt; +pub type U161 = + UInt, B0>, B1>, B0>, B0>, B0>, B0>, B1>; +pub type P161 = PInt; +pub type N161 = NInt; +pub type U162 = + UInt, B0>, B1>, B0>, B0>, B0>, B1>, B0>; +pub type P162 = PInt; +pub type N162 = NInt; +pub type U163 = + UInt, B0>, B1>, B0>, B0>, B0>, B1>, B1>; +pub type P163 = PInt; +pub type N163 = NInt; +pub type U164 = + UInt, B0>, B1>, B0>, B0>, B1>, B0>, B0>; +pub type P164 = PInt; +pub type N164 = NInt; +pub type U165 = + UInt, B0>, B1>, B0>, B0>, B1>, B0>, B1>; +pub type P165 = PInt; +pub type N165 = NInt; +pub type U166 = + UInt, B0>, B1>, B0>, B0>, B1>, B1>, B0>; +pub type P166 = PInt; +pub type N166 = NInt; +pub type U167 = + UInt, B0>, B1>, B0>, B0>, B1>, B1>, B1>; +pub type P167 = PInt; +pub type N167 = NInt; +pub type U168 = + UInt, B0>, B1>, B0>, B1>, B0>, B0>, B0>; +pub type P168 = PInt; +pub type N168 = NInt; +pub type U169 = + UInt, B0>, B1>, B0>, B1>, B0>, B0>, B1>; +pub type P169 = PInt; +pub type N169 = NInt; +pub type U170 = + UInt, B0>, B1>, B0>, B1>, B0>, B1>, B0>; +pub type P170 = PInt; +pub type N170 = NInt; +pub type U171 = + UInt, B0>, B1>, B0>, B1>, B0>, B1>, B1>; +pub type P171 = PInt; +pub type N171 = NInt; +pub type U172 = + UInt, B0>, B1>, B0>, B1>, B1>, B0>, B0>; +pub type P172 = PInt; +pub type N172 = NInt; +pub type U173 = + UInt, B0>, B1>, B0>, B1>, B1>, B0>, B1>; +pub type P173 = PInt; +pub type N173 = NInt; +pub type U174 = + UInt, B0>, B1>, B0>, B1>, B1>, B1>, B0>; +pub type P174 = PInt; +pub type N174 = NInt; +pub type U175 = + UInt, B0>, B1>, B0>, B1>, B1>, B1>, B1>; +pub type P175 = PInt; +pub type N175 = NInt; +pub type U176 = + UInt, B0>, B1>, B1>, B0>, B0>, B0>, B0>; +pub type P176 = PInt; +pub type N176 = NInt; +pub type U177 = + UInt, B0>, B1>, B1>, B0>, B0>, B0>, B1>; +pub type P177 = PInt; +pub type N177 = NInt; +pub type U178 = + UInt, B0>, B1>, B1>, B0>, B0>, B1>, B0>; +pub type P178 = PInt; +pub type N178 = NInt; +pub type U179 = + UInt, B0>, B1>, B1>, B0>, B0>, B1>, B1>; +pub type P179 = PInt; +pub type N179 = NInt; +pub type U180 = + UInt, B0>, B1>, B1>, B0>, B1>, B0>, B0>; +pub type P180 = PInt; +pub type N180 = NInt; +pub type U181 = + UInt, B0>, B1>, B1>, B0>, B1>, B0>, B1>; +pub type P181 = PInt; +pub type N181 = NInt; +pub type U182 = + UInt, B0>, B1>, B1>, B0>, B1>, B1>, B0>; +pub type P182 = PInt; +pub type N182 = NInt; +pub type U183 = + UInt, B0>, B1>, B1>, B0>, B1>, B1>, B1>; +pub type P183 = PInt; +pub type N183 = NInt; +pub type U184 = + UInt, B0>, B1>, B1>, B1>, B0>, B0>, B0>; +pub type P184 = PInt; +pub type N184 = NInt; +pub type U185 = + UInt, B0>, B1>, B1>, B1>, B0>, B0>, B1>; +pub type P185 = PInt; +pub type N185 = NInt; +pub type U186 = + UInt, B0>, B1>, B1>, B1>, B0>, B1>, B0>; +pub type P186 = PInt; +pub type N186 = NInt; +pub type U187 = + UInt, B0>, B1>, B1>, B1>, B0>, B1>, B1>; +pub type P187 = PInt; +pub type N187 = NInt; +pub type U188 = + UInt, B0>, B1>, B1>, B1>, B1>, B0>, B0>; +pub type P188 = PInt; +pub type N188 = NInt; +pub type U189 = + UInt, B0>, B1>, B1>, B1>, B1>, B0>, B1>; +pub type P189 = PInt; +pub type N189 = NInt; +pub type U190 = + UInt, B0>, B1>, B1>, B1>, B1>, B1>, B0>; +pub type P190 = PInt; +pub type N190 = NInt; +pub type U191 = + UInt, B0>, B1>, B1>, B1>, B1>, B1>, B1>; +pub type P191 = PInt; +pub type N191 = NInt; +pub type U192 = + UInt, B1>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P192 = PInt; +pub type N192 = NInt; +pub type U193 = + UInt, B1>, B0>, B0>, B0>, B0>, B0>, B1>; +pub type P193 = PInt; +pub type N193 = NInt; +pub type U194 = + UInt, B1>, B0>, B0>, B0>, B0>, B1>, B0>; +pub type P194 = PInt; +pub type N194 = NInt; +pub type U195 = + UInt, B1>, B0>, B0>, B0>, B0>, B1>, B1>; +pub type P195 = PInt; +pub type N195 = NInt; +pub type U196 = + UInt, B1>, B0>, B0>, B0>, B1>, B0>, B0>; +pub type P196 = PInt; +pub type N196 = NInt; +pub type U197 = + UInt, B1>, B0>, B0>, B0>, B1>, B0>, B1>; +pub type P197 = PInt; +pub type N197 = NInt; +pub type U198 = + UInt, B1>, B0>, B0>, B0>, B1>, B1>, B0>; +pub type P198 = PInt; +pub type N198 = NInt; +pub type U199 = + UInt, B1>, B0>, B0>, B0>, B1>, B1>, B1>; +pub type P199 = PInt; +pub type N199 = NInt; +pub type U200 = + UInt, B1>, B0>, B0>, B1>, B0>, B0>, B0>; +pub type P200 = PInt; +pub type N200 = NInt; +pub type U201 = + UInt, B1>, B0>, B0>, B1>, B0>, B0>, B1>; +pub type P201 = PInt; +pub type N201 = NInt; +pub type U202 = + UInt, B1>, B0>, B0>, B1>, B0>, B1>, B0>; +pub type P202 = PInt; +pub type N202 = NInt; +pub type U203 = + UInt, B1>, B0>, B0>, B1>, B0>, B1>, B1>; +pub type P203 = PInt; +pub type N203 = NInt; +pub type U204 = + UInt, B1>, B0>, B0>, B1>, B1>, B0>, B0>; +pub type P204 = PInt; +pub type N204 = NInt; +pub type U205 = + UInt, B1>, B0>, B0>, B1>, B1>, B0>, B1>; +pub type P205 = PInt; +pub type N205 = NInt; +pub type U206 = + UInt, B1>, B0>, B0>, B1>, B1>, B1>, B0>; +pub type P206 = PInt; +pub type N206 = NInt; +pub type U207 = + UInt, B1>, B0>, B0>, B1>, B1>, B1>, B1>; +pub type P207 = PInt; +pub type N207 = NInt; +pub type U208 = + UInt, B1>, B0>, B1>, B0>, B0>, B0>, B0>; +pub type P208 = PInt; +pub type N208 = NInt; +pub type U209 = + UInt, B1>, B0>, B1>, B0>, B0>, B0>, B1>; +pub type P209 = PInt; +pub type N209 = NInt; +pub type U210 = + UInt, B1>, B0>, B1>, B0>, B0>, B1>, B0>; +pub type P210 = PInt; +pub type N210 = NInt; +pub type U211 = + UInt, B1>, B0>, B1>, B0>, B0>, B1>, B1>; +pub type P211 = PInt; +pub type N211 = NInt; +pub type U212 = + UInt, B1>, B0>, B1>, B0>, B1>, B0>, B0>; +pub type P212 = PInt; +pub type N212 = NInt; +pub type U213 = + UInt, B1>, B0>, B1>, B0>, B1>, B0>, B1>; +pub type P213 = PInt; +pub type N213 = NInt; +pub type U214 = + UInt, B1>, B0>, B1>, B0>, B1>, B1>, B0>; +pub type P214 = PInt; +pub type N214 = NInt; +pub type U215 = + UInt, B1>, B0>, B1>, B0>, B1>, B1>, B1>; +pub type P215 = PInt; +pub type N215 = NInt; +pub type U216 = + UInt, B1>, B0>, B1>, B1>, B0>, B0>, B0>; +pub type P216 = PInt; +pub type N216 = NInt; +pub type U217 = + UInt, B1>, B0>, B1>, B1>, B0>, B0>, B1>; +pub type P217 = PInt; +pub type N217 = NInt; +pub type U218 = + UInt, B1>, B0>, B1>, B1>, B0>, B1>, B0>; +pub type P218 = PInt; +pub type N218 = NInt; +pub type U219 = + UInt, B1>, B0>, B1>, B1>, B0>, B1>, B1>; +pub type P219 = PInt; +pub type N219 = NInt; +pub type U220 = + UInt, B1>, B0>, B1>, B1>, B1>, B0>, B0>; +pub type P220 = PInt; +pub type N220 = NInt; +pub type U221 = + UInt, B1>, B0>, B1>, B1>, B1>, B0>, B1>; +pub type P221 = PInt; +pub type N221 = NInt; +pub type U222 = + UInt, B1>, B0>, B1>, B1>, B1>, B1>, B0>; +pub type P222 = PInt; +pub type N222 = NInt; +pub type U223 = + UInt, B1>, B0>, B1>, B1>, B1>, B1>, B1>; +pub type P223 = PInt; +pub type N223 = NInt; +pub type U224 = + UInt, B1>, B1>, B0>, B0>, B0>, B0>, B0>; +pub type P224 = PInt; +pub type N224 = NInt; +pub type U225 = + UInt, B1>, B1>, B0>, B0>, B0>, B0>, B1>; +pub type P225 = PInt; +pub type N225 = NInt; +pub type U226 = + UInt, B1>, B1>, B0>, B0>, B0>, B1>, B0>; +pub type P226 = PInt; +pub type N226 = NInt; +pub type U227 = + UInt, B1>, B1>, B0>, B0>, B0>, B1>, B1>; +pub type P227 = PInt; +pub type N227 = NInt; +pub type U228 = + UInt, B1>, B1>, B0>, B0>, B1>, B0>, B0>; +pub type P228 = PInt; +pub type N228 = NInt; +pub type U229 = + UInt, B1>, B1>, B0>, B0>, B1>, B0>, B1>; +pub type P229 = PInt; +pub type N229 = NInt; +pub type U230 = + UInt, B1>, B1>, B0>, B0>, B1>, B1>, B0>; +pub type P230 = PInt; +pub type N230 = NInt; +pub type U231 = + UInt, B1>, B1>, B0>, B0>, B1>, B1>, B1>; +pub type P231 = PInt; +pub type N231 = NInt; +pub type U232 = + UInt, B1>, B1>, B0>, B1>, B0>, B0>, B0>; +pub type P232 = PInt; +pub type N232 = NInt; +pub type U233 = + UInt, B1>, B1>, B0>, B1>, B0>, B0>, B1>; +pub type P233 = PInt; +pub type N233 = NInt; +pub type U234 = + UInt, B1>, B1>, B0>, B1>, B0>, B1>, B0>; +pub type P234 = PInt; +pub type N234 = NInt; +pub type U235 = + UInt, B1>, B1>, B0>, B1>, B0>, B1>, B1>; +pub type P235 = PInt; +pub type N235 = NInt; +pub type U236 = + UInt, B1>, B1>, B0>, B1>, B1>, B0>, B0>; +pub type P236 = PInt; +pub type N236 = NInt; +pub type U237 = + UInt, B1>, B1>, B0>, B1>, B1>, B0>, B1>; +pub type P237 = PInt; +pub type N237 = NInt; +pub type U238 = + UInt, B1>, B1>, B0>, B1>, B1>, B1>, B0>; +pub type P238 = PInt; +pub type N238 = NInt; +pub type U239 = + UInt, B1>, B1>, B0>, B1>, B1>, B1>, B1>; +pub type P239 = PInt; +pub type N239 = NInt; +pub type U240 = + UInt, B1>, B1>, B1>, B0>, B0>, B0>, B0>; +pub type P240 = PInt; +pub type N240 = NInt; +pub type U241 = + UInt, B1>, B1>, B1>, B0>, B0>, B0>, B1>; +pub type P241 = PInt; +pub type N241 = NInt; +pub type U242 = + UInt, B1>, B1>, B1>, B0>, B0>, B1>, B0>; +pub type P242 = PInt; +pub type N242 = NInt; +pub type U243 = + UInt, B1>, B1>, B1>, B0>, B0>, B1>, B1>; +pub type P243 = PInt; +pub type N243 = NInt; +pub type U244 = + UInt, B1>, B1>, B1>, B0>, B1>, B0>, B0>; +pub type P244 = PInt; +pub type N244 = NInt; +pub type U245 = + UInt, B1>, B1>, B1>, B0>, B1>, B0>, B1>; +pub type P245 = PInt; +pub type N245 = NInt; +pub type U246 = + UInt, B1>, B1>, B1>, B0>, B1>, B1>, B0>; +pub type P246 = PInt; +pub type N246 = NInt; +pub type U247 = + UInt, B1>, B1>, B1>, B0>, B1>, B1>, B1>; +pub type P247 = PInt; +pub type N247 = NInt; +pub type U248 = + UInt, B1>, B1>, B1>, B1>, B0>, B0>, B0>; +pub type P248 = PInt; +pub type N248 = NInt; +pub type U249 = + UInt, B1>, B1>, B1>, B1>, B0>, B0>, B1>; +pub type P249 = PInt; +pub type N249 = NInt; +pub type U250 = + UInt, B1>, B1>, B1>, B1>, B0>, B1>, B0>; +pub type P250 = PInt; +pub type N250 = NInt; +pub type U251 = + UInt, B1>, B1>, B1>, B1>, B0>, B1>, B1>; +pub type P251 = PInt; +pub type N251 = NInt; +pub type U252 = + UInt, B1>, B1>, B1>, B1>, B1>, B0>, B0>; +pub type P252 = PInt; +pub type N252 = NInt; +pub type U253 = + UInt, B1>, B1>, B1>, B1>, B1>, B0>, B1>; +pub type P253 = PInt; +pub type N253 = NInt; +pub type U254 = + UInt, B1>, B1>, B1>, B1>, B1>, B1>, B0>; +pub type P254 = PInt; +pub type N254 = NInt; +pub type U255 = + UInt, B1>, B1>, B1>, B1>, B1>, B1>, B1>; +pub type P255 = PInt; +pub type N255 = NInt; +pub type U256 = + UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P256 = PInt; +pub type N256 = NInt; +pub type U257 = + UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B1>; +pub type P257 = PInt; +pub type N257 = NInt; +pub type U258 = + UInt, B0>, B0>, B0>, B0>, B0>, B0>, B1>, B0>; +pub type P258 = PInt; +pub type N258 = NInt; +pub type U259 = + UInt, B0>, B0>, B0>, B0>, B0>, B0>, B1>, B1>; +pub type P259 = PInt; +pub type N259 = NInt; +pub type U260 = + UInt, B0>, B0>, B0>, B0>, B0>, B1>, B0>, B0>; +pub type P260 = PInt; +pub type N260 = NInt; +pub type U261 = + UInt, B0>, B0>, B0>, B0>, B0>, B1>, B0>, B1>; +pub type P261 = PInt; +pub type N261 = NInt; +pub type U262 = + UInt, B0>, B0>, B0>, B0>, B0>, B1>, B1>, B0>; +pub type P262 = PInt; +pub type N262 = NInt; +pub type U263 = + UInt, B0>, B0>, B0>, B0>, B0>, B1>, B1>, B1>; +pub type P263 = PInt; +pub type N263 = NInt; +pub type U264 = + UInt, B0>, B0>, B0>, B0>, B1>, B0>, B0>, B0>; +pub type P264 = PInt; +pub type N264 = NInt; +pub type U265 = + UInt, B0>, B0>, B0>, B0>, B1>, B0>, B0>, B1>; +pub type P265 = PInt; +pub type N265 = NInt; +pub type U266 = + UInt, B0>, B0>, B0>, B0>, B1>, B0>, B1>, B0>; +pub type P266 = PInt; +pub type N266 = NInt; +pub type U267 = + UInt, B0>, B0>, B0>, B0>, B1>, B0>, B1>, B1>; +pub type P267 = PInt; +pub type N267 = NInt; +pub type U268 = + UInt, B0>, B0>, B0>, B0>, B1>, B1>, B0>, B0>; +pub type P268 = PInt; +pub type N268 = NInt; +pub type U269 = + UInt, B0>, B0>, B0>, B0>, B1>, B1>, B0>, B1>; +pub type P269 = PInt; +pub type N269 = NInt; +pub type U270 = + UInt, B0>, B0>, B0>, B0>, B1>, B1>, B1>, B0>; +pub type P270 = PInt; +pub type N270 = NInt; +pub type U271 = + UInt, B0>, B0>, B0>, B0>, B1>, B1>, B1>, B1>; +pub type P271 = PInt; +pub type N271 = NInt; +pub type U272 = + UInt, B0>, B0>, B0>, B1>, B0>, B0>, B0>, B0>; +pub type P272 = PInt; +pub type N272 = NInt; +pub type U273 = + UInt, B0>, B0>, B0>, B1>, B0>, B0>, B0>, B1>; +pub type P273 = PInt; +pub type N273 = NInt; +pub type U274 = + UInt, B0>, B0>, B0>, B1>, B0>, B0>, B1>, B0>; +pub type P274 = PInt; +pub type N274 = NInt; +pub type U275 = + UInt, B0>, B0>, B0>, B1>, B0>, B0>, B1>, B1>; +pub type P275 = PInt; +pub type N275 = NInt; +pub type U276 = + UInt, B0>, B0>, B0>, B1>, B0>, B1>, B0>, B0>; +pub type P276 = PInt; +pub type N276 = NInt; +pub type U277 = + UInt, B0>, B0>, B0>, B1>, B0>, B1>, B0>, B1>; +pub type P277 = PInt; +pub type N277 = NInt; +pub type U278 = + UInt, B0>, B0>, B0>, B1>, B0>, B1>, B1>, B0>; +pub type P278 = PInt; +pub type N278 = NInt; +pub type U279 = + UInt, B0>, B0>, B0>, B1>, B0>, B1>, B1>, B1>; +pub type P279 = PInt; +pub type N279 = NInt; +pub type U280 = + UInt, B0>, B0>, B0>, B1>, B1>, B0>, B0>, B0>; +pub type P280 = PInt; +pub type N280 = NInt; +pub type U281 = + UInt, B0>, B0>, B0>, B1>, B1>, B0>, B0>, B1>; +pub type P281 = PInt; +pub type N281 = NInt; +pub type U282 = + UInt, B0>, B0>, B0>, B1>, B1>, B0>, B1>, B0>; +pub type P282 = PInt; +pub type N282 = NInt; +pub type U283 = + UInt, B0>, B0>, B0>, B1>, B1>, B0>, B1>, B1>; +pub type P283 = PInt; +pub type N283 = NInt; +pub type U284 = + UInt, B0>, B0>, B0>, B1>, B1>, B1>, B0>, B0>; +pub type P284 = PInt; +pub type N284 = NInt; +pub type U285 = + UInt, B0>, B0>, B0>, B1>, B1>, B1>, B0>, B1>; +pub type P285 = PInt; +pub type N285 = NInt; +pub type U286 = + UInt, B0>, B0>, B0>, B1>, B1>, B1>, B1>, B0>; +pub type P286 = PInt; +pub type N286 = NInt; +pub type U287 = + UInt, B0>, B0>, B0>, B1>, B1>, B1>, B1>, B1>; +pub type P287 = PInt; +pub type N287 = NInt; +pub type U288 = + UInt, B0>, B0>, B1>, B0>, B0>, B0>, B0>, B0>; +pub type P288 = PInt; +pub type N288 = NInt; +pub type U289 = + UInt, B0>, B0>, B1>, B0>, B0>, B0>, B0>, B1>; +pub type P289 = PInt; +pub type N289 = NInt; +pub type U290 = + UInt, B0>, B0>, B1>, B0>, B0>, B0>, B1>, B0>; +pub type P290 = PInt; +pub type N290 = NInt; +pub type U291 = + UInt, B0>, B0>, B1>, B0>, B0>, B0>, B1>, B1>; +pub type P291 = PInt; +pub type N291 = NInt; +pub type U292 = + UInt, B0>, B0>, B1>, B0>, B0>, B1>, B0>, B0>; +pub type P292 = PInt; +pub type N292 = NInt; +pub type U293 = + UInt, B0>, B0>, B1>, B0>, B0>, B1>, B0>, B1>; +pub type P293 = PInt; +pub type N293 = NInt; +pub type U294 = + UInt, B0>, B0>, B1>, B0>, B0>, B1>, B1>, B0>; +pub type P294 = PInt; +pub type N294 = NInt; +pub type U295 = + UInt, B0>, B0>, B1>, B0>, B0>, B1>, B1>, B1>; +pub type P295 = PInt; +pub type N295 = NInt; +pub type U296 = + UInt, B0>, B0>, B1>, B0>, B1>, B0>, B0>, B0>; +pub type P296 = PInt; +pub type N296 = NInt; +pub type U297 = + UInt, B0>, B0>, B1>, B0>, B1>, B0>, B0>, B1>; +pub type P297 = PInt; +pub type N297 = NInt; +pub type U298 = + UInt, B0>, B0>, B1>, B0>, B1>, B0>, B1>, B0>; +pub type P298 = PInt; +pub type N298 = NInt; +pub type U299 = + UInt, B0>, B0>, B1>, B0>, B1>, B0>, B1>, B1>; +pub type P299 = PInt; +pub type N299 = NInt; +pub type U300 = + UInt, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B0>; +pub type P300 = PInt; +pub type N300 = NInt; +pub type U301 = + UInt, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B1>; +pub type P301 = PInt; +pub type N301 = NInt; +pub type U302 = + UInt, B0>, B0>, B1>, B0>, B1>, B1>, B1>, B0>; +pub type P302 = PInt; +pub type N302 = NInt; +pub type U303 = + UInt, B0>, B0>, B1>, B0>, B1>, B1>, B1>, B1>; +pub type P303 = PInt; +pub type N303 = NInt; +pub type U304 = + UInt, B0>, B0>, B1>, B1>, B0>, B0>, B0>, B0>; +pub type P304 = PInt; +pub type N304 = NInt; +pub type U305 = + UInt, B0>, B0>, B1>, B1>, B0>, B0>, B0>, B1>; +pub type P305 = PInt; +pub type N305 = NInt; +pub type U306 = + UInt, B0>, B0>, B1>, B1>, B0>, B0>, B1>, B0>; +pub type P306 = PInt; +pub type N306 = NInt; +pub type U307 = + UInt, B0>, B0>, B1>, B1>, B0>, B0>, B1>, B1>; +pub type P307 = PInt; +pub type N307 = NInt; +pub type U308 = + UInt, B0>, B0>, B1>, B1>, B0>, B1>, B0>, B0>; +pub type P308 = PInt; +pub type N308 = NInt; +pub type U309 = + UInt, B0>, B0>, B1>, B1>, B0>, B1>, B0>, B1>; +pub type P309 = PInt; +pub type N309 = NInt; +pub type U310 = + UInt, B0>, B0>, B1>, B1>, B0>, B1>, B1>, B0>; +pub type P310 = PInt; +pub type N310 = NInt; +pub type U311 = + UInt, B0>, B0>, B1>, B1>, B0>, B1>, B1>, B1>; +pub type P311 = PInt; +pub type N311 = NInt; +pub type U312 = + UInt, B0>, B0>, B1>, B1>, B1>, B0>, B0>, B0>; +pub type P312 = PInt; +pub type N312 = NInt; +pub type U313 = + UInt, B0>, B0>, B1>, B1>, B1>, B0>, B0>, B1>; +pub type P313 = PInt; +pub type N313 = NInt; +pub type U314 = + UInt, B0>, B0>, B1>, B1>, B1>, B0>, B1>, B0>; +pub type P314 = PInt; +pub type N314 = NInt; +pub type U315 = + UInt, B0>, B0>, B1>, B1>, B1>, B0>, B1>, B1>; +pub type P315 = PInt; +pub type N315 = NInt; +pub type U316 = + UInt, B0>, B0>, B1>, B1>, B1>, B1>, B0>, B0>; +pub type P316 = PInt; +pub type N316 = NInt; +pub type U317 = + UInt, B0>, B0>, B1>, B1>, B1>, B1>, B0>, B1>; +pub type P317 = PInt; +pub type N317 = NInt; +pub type U318 = + UInt, B0>, B0>, B1>, B1>, B1>, B1>, B1>, B0>; +pub type P318 = PInt; +pub type N318 = NInt; +pub type U319 = + UInt, B0>, B0>, B1>, B1>, B1>, B1>, B1>, B1>; +pub type P319 = PInt; +pub type N319 = NInt; +pub type U320 = + UInt, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P320 = PInt; +pub type N320 = NInt; +pub type U321 = + UInt, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B1>; +pub type P321 = PInt; +pub type N321 = NInt; +pub type U322 = + UInt, B0>, B1>, B0>, B0>, B0>, B0>, B1>, B0>; +pub type P322 = PInt; +pub type N322 = NInt; +pub type U323 = + UInt, B0>, B1>, B0>, B0>, B0>, B0>, B1>, B1>; +pub type P323 = PInt; +pub type N323 = NInt; +pub type U324 = + UInt, B0>, B1>, B0>, B0>, B0>, B1>, B0>, B0>; +pub type P324 = PInt; +pub type N324 = NInt; +pub type U325 = + UInt, B0>, B1>, B0>, B0>, B0>, B1>, B0>, B1>; +pub type P325 = PInt; +pub type N325 = NInt; +pub type U326 = + UInt, B0>, B1>, B0>, B0>, B0>, B1>, B1>, B0>; +pub type P326 = PInt; +pub type N326 = NInt; +pub type U327 = + UInt, B0>, B1>, B0>, B0>, B0>, B1>, B1>, B1>; +pub type P327 = PInt; +pub type N327 = NInt; +pub type U328 = + UInt, B0>, B1>, B0>, B0>, B1>, B0>, B0>, B0>; +pub type P328 = PInt; +pub type N328 = NInt; +pub type U329 = + UInt, B0>, B1>, B0>, B0>, B1>, B0>, B0>, B1>; +pub type P329 = PInt; +pub type N329 = NInt; +pub type U330 = + UInt, B0>, B1>, B0>, B0>, B1>, B0>, B1>, B0>; +pub type P330 = PInt; +pub type N330 = NInt; +pub type U331 = + UInt, B0>, B1>, B0>, B0>, B1>, B0>, B1>, B1>; +pub type P331 = PInt; +pub type N331 = NInt; +pub type U332 = + UInt, B0>, B1>, B0>, B0>, B1>, B1>, B0>, B0>; +pub type P332 = PInt; +pub type N332 = NInt; +pub type U333 = + UInt, B0>, B1>, B0>, B0>, B1>, B1>, B0>, B1>; +pub type P333 = PInt; +pub type N333 = NInt; +pub type U334 = + UInt, B0>, B1>, B0>, B0>, B1>, B1>, B1>, B0>; +pub type P334 = PInt; +pub type N334 = NInt; +pub type U335 = + UInt, B0>, B1>, B0>, B0>, B1>, B1>, B1>, B1>; +pub type P335 = PInt; +pub type N335 = NInt; +pub type U336 = + UInt, B0>, B1>, B0>, B1>, B0>, B0>, B0>, B0>; +pub type P336 = PInt; +pub type N336 = NInt; +pub type U337 = + UInt, B0>, B1>, B0>, B1>, B0>, B0>, B0>, B1>; +pub type P337 = PInt; +pub type N337 = NInt; +pub type U338 = + UInt, B0>, B1>, B0>, B1>, B0>, B0>, B1>, B0>; +pub type P338 = PInt; +pub type N338 = NInt; +pub type U339 = + UInt, B0>, B1>, B0>, B1>, B0>, B0>, B1>, B1>; +pub type P339 = PInt; +pub type N339 = NInt; +pub type U340 = + UInt, B0>, B1>, B0>, B1>, B0>, B1>, B0>, B0>; +pub type P340 = PInt; +pub type N340 = NInt; +pub type U341 = + UInt, B0>, B1>, B0>, B1>, B0>, B1>, B0>, B1>; +pub type P341 = PInt; +pub type N341 = NInt; +pub type U342 = + UInt, B0>, B1>, B0>, B1>, B0>, B1>, B1>, B0>; +pub type P342 = PInt; +pub type N342 = NInt; +pub type U343 = + UInt, B0>, B1>, B0>, B1>, B0>, B1>, B1>, B1>; +pub type P343 = PInt; +pub type N343 = NInt; +pub type U344 = + UInt, B0>, B1>, B0>, B1>, B1>, B0>, B0>, B0>; +pub type P344 = PInt; +pub type N344 = NInt; +pub type U345 = + UInt, B0>, B1>, B0>, B1>, B1>, B0>, B0>, B1>; +pub type P345 = PInt; +pub type N345 = NInt; +pub type U346 = + UInt, B0>, B1>, B0>, B1>, B1>, B0>, B1>, B0>; +pub type P346 = PInt; +pub type N346 = NInt; +pub type U347 = + UInt, B0>, B1>, B0>, B1>, B1>, B0>, B1>, B1>; +pub type P347 = PInt; +pub type N347 = NInt; +pub type U348 = + UInt, B0>, B1>, B0>, B1>, B1>, B1>, B0>, B0>; +pub type P348 = PInt; +pub type N348 = NInt; +pub type U349 = + UInt, B0>, B1>, B0>, B1>, B1>, B1>, B0>, B1>; +pub type P349 = PInt; +pub type N349 = NInt; +pub type U350 = + UInt, B0>, B1>, B0>, B1>, B1>, B1>, B1>, B0>; +pub type P350 = PInt; +pub type N350 = NInt; +pub type U351 = + UInt, B0>, B1>, B0>, B1>, B1>, B1>, B1>, B1>; +pub type P351 = PInt; +pub type N351 = NInt; +pub type U352 = + UInt, B0>, B1>, B1>, B0>, B0>, B0>, B0>, B0>; +pub type P352 = PInt; +pub type N352 = NInt; +pub type U353 = + UInt, B0>, B1>, B1>, B0>, B0>, B0>, B0>, B1>; +pub type P353 = PInt; +pub type N353 = NInt; +pub type U354 = + UInt, B0>, B1>, B1>, B0>, B0>, B0>, B1>, B0>; +pub type P354 = PInt; +pub type N354 = NInt; +pub type U355 = + UInt, B0>, B1>, B1>, B0>, B0>, B0>, B1>, B1>; +pub type P355 = PInt; +pub type N355 = NInt; +pub type U356 = + UInt, B0>, B1>, B1>, B0>, B0>, B1>, B0>, B0>; +pub type P356 = PInt; +pub type N356 = NInt; +pub type U357 = + UInt, B0>, B1>, B1>, B0>, B0>, B1>, B0>, B1>; +pub type P357 = PInt; +pub type N357 = NInt; +pub type U358 = + UInt, B0>, B1>, B1>, B0>, B0>, B1>, B1>, B0>; +pub type P358 = PInt; +pub type N358 = NInt; +pub type U359 = + UInt, B0>, B1>, B1>, B0>, B0>, B1>, B1>, B1>; +pub type P359 = PInt; +pub type N359 = NInt; +pub type U360 = + UInt, B0>, B1>, B1>, B0>, B1>, B0>, B0>, B0>; +pub type P360 = PInt; +pub type N360 = NInt; +pub type U361 = + UInt, B0>, B1>, B1>, B0>, B1>, B0>, B0>, B1>; +pub type P361 = PInt; +pub type N361 = NInt; +pub type U362 = + UInt, B0>, B1>, B1>, B0>, B1>, B0>, B1>, B0>; +pub type P362 = PInt; +pub type N362 = NInt; +pub type U363 = + UInt, B0>, B1>, B1>, B0>, B1>, B0>, B1>, B1>; +pub type P363 = PInt; +pub type N363 = NInt; +pub type U364 = + UInt, B0>, B1>, B1>, B0>, B1>, B1>, B0>, B0>; +pub type P364 = PInt; +pub type N364 = NInt; +pub type U365 = + UInt, B0>, B1>, B1>, B0>, B1>, B1>, B0>, B1>; +pub type P365 = PInt; +pub type N365 = NInt; +pub type U366 = + UInt, B0>, B1>, B1>, B0>, B1>, B1>, B1>, B0>; +pub type P366 = PInt; +pub type N366 = NInt; +pub type U367 = + UInt, B0>, B1>, B1>, B0>, B1>, B1>, B1>, B1>; +pub type P367 = PInt; +pub type N367 = NInt; +pub type U368 = + UInt, B0>, B1>, B1>, B1>, B0>, B0>, B0>, B0>; +pub type P368 = PInt; +pub type N368 = NInt; +pub type U369 = + UInt, B0>, B1>, B1>, B1>, B0>, B0>, B0>, B1>; +pub type P369 = PInt; +pub type N369 = NInt; +pub type U370 = + UInt, B0>, B1>, B1>, B1>, B0>, B0>, B1>, B0>; +pub type P370 = PInt; +pub type N370 = NInt; +pub type U371 = + UInt, B0>, B1>, B1>, B1>, B0>, B0>, B1>, B1>; +pub type P371 = PInt; +pub type N371 = NInt; +pub type U372 = + UInt, B0>, B1>, B1>, B1>, B0>, B1>, B0>, B0>; +pub type P372 = PInt; +pub type N372 = NInt; +pub type U373 = + UInt, B0>, B1>, B1>, B1>, B0>, B1>, B0>, B1>; +pub type P373 = PInt; +pub type N373 = NInt; +pub type U374 = + UInt, B0>, B1>, B1>, B1>, B0>, B1>, B1>, B0>; +pub type P374 = PInt; +pub type N374 = NInt; +pub type U375 = + UInt, B0>, B1>, B1>, B1>, B0>, B1>, B1>, B1>; +pub type P375 = PInt; +pub type N375 = NInt; +pub type U376 = + UInt, B0>, B1>, B1>, B1>, B1>, B0>, B0>, B0>; +pub type P376 = PInt; +pub type N376 = NInt; +pub type U377 = + UInt, B0>, B1>, B1>, B1>, B1>, B0>, B0>, B1>; +pub type P377 = PInt; +pub type N377 = NInt; +pub type U378 = + UInt, B0>, B1>, B1>, B1>, B1>, B0>, B1>, B0>; +pub type P378 = PInt; +pub type N378 = NInt; +pub type U379 = + UInt, B0>, B1>, B1>, B1>, B1>, B0>, B1>, B1>; +pub type P379 = PInt; +pub type N379 = NInt; +pub type U380 = + UInt, B0>, B1>, B1>, B1>, B1>, B1>, B0>, B0>; +pub type P380 = PInt; +pub type N380 = NInt; +pub type U381 = + UInt, B0>, B1>, B1>, B1>, B1>, B1>, B0>, B1>; +pub type P381 = PInt; +pub type N381 = NInt; +pub type U382 = + UInt, B0>, B1>, B1>, B1>, B1>, B1>, B1>, B0>; +pub type P382 = PInt; +pub type N382 = NInt; +pub type U383 = + UInt, B0>, B1>, B1>, B1>, B1>, B1>, B1>, B1>; +pub type P383 = PInt; +pub type N383 = NInt; +pub type U384 = + UInt, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P384 = PInt; +pub type N384 = NInt; +pub type U385 = + UInt, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B1>; +pub type P385 = PInt; +pub type N385 = NInt; +pub type U386 = + UInt, B1>, B0>, B0>, B0>, B0>, B0>, B1>, B0>; +pub type P386 = PInt; +pub type N386 = NInt; +pub type U387 = + UInt, B1>, B0>, B0>, B0>, B0>, B0>, B1>, B1>; +pub type P387 = PInt; +pub type N387 = NInt; +pub type U388 = + UInt, B1>, B0>, B0>, B0>, B0>, B1>, B0>, B0>; +pub type P388 = PInt; +pub type N388 = NInt; +pub type U389 = + UInt, B1>, B0>, B0>, B0>, B0>, B1>, B0>, B1>; +pub type P389 = PInt; +pub type N389 = NInt; +pub type U390 = + UInt, B1>, B0>, B0>, B0>, B0>, B1>, B1>, B0>; +pub type P390 = PInt; +pub type N390 = NInt; +pub type U391 = + UInt, B1>, B0>, B0>, B0>, B0>, B1>, B1>, B1>; +pub type P391 = PInt; +pub type N391 = NInt; +pub type U392 = + UInt, B1>, B0>, B0>, B0>, B1>, B0>, B0>, B0>; +pub type P392 = PInt; +pub type N392 = NInt; +pub type U393 = + UInt, B1>, B0>, B0>, B0>, B1>, B0>, B0>, B1>; +pub type P393 = PInt; +pub type N393 = NInt; +pub type U394 = + UInt, B1>, B0>, B0>, B0>, B1>, B0>, B1>, B0>; +pub type P394 = PInt; +pub type N394 = NInt; +pub type U395 = + UInt, B1>, B0>, B0>, B0>, B1>, B0>, B1>, B1>; +pub type P395 = PInt; +pub type N395 = NInt; +pub type U396 = + UInt, B1>, B0>, B0>, B0>, B1>, B1>, B0>, B0>; +pub type P396 = PInt; +pub type N396 = NInt; +pub type U397 = + UInt, B1>, B0>, B0>, B0>, B1>, B1>, B0>, B1>; +pub type P397 = PInt; +pub type N397 = NInt; +pub type U398 = + UInt, B1>, B0>, B0>, B0>, B1>, B1>, B1>, B0>; +pub type P398 = PInt; +pub type N398 = NInt; +pub type U399 = + UInt, B1>, B0>, B0>, B0>, B1>, B1>, B1>, B1>; +pub type P399 = PInt; +pub type N399 = NInt; +pub type U400 = + UInt, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0>; +pub type P400 = PInt; +pub type N400 = NInt; +pub type U401 = + UInt, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B1>; +pub type P401 = PInt; +pub type N401 = NInt; +pub type U402 = + UInt, B1>, B0>, B0>, B1>, B0>, B0>, B1>, B0>; +pub type P402 = PInt; +pub type N402 = NInt; +pub type U403 = + UInt, B1>, B0>, B0>, B1>, B0>, B0>, B1>, B1>; +pub type P403 = PInt; +pub type N403 = NInt; +pub type U404 = + UInt, B1>, B0>, B0>, B1>, B0>, B1>, B0>, B0>; +pub type P404 = PInt; +pub type N404 = NInt; +pub type U405 = + UInt, B1>, B0>, B0>, B1>, B0>, B1>, B0>, B1>; +pub type P405 = PInt; +pub type N405 = NInt; +pub type U406 = + UInt, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B0>; +pub type P406 = PInt; +pub type N406 = NInt; +pub type U407 = + UInt, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B1>; +pub type P407 = PInt; +pub type N407 = NInt; +pub type U408 = + UInt, B1>, B0>, B0>, B1>, B1>, B0>, B0>, B0>; +pub type P408 = PInt; +pub type N408 = NInt; +pub type U409 = + UInt, B1>, B0>, B0>, B1>, B1>, B0>, B0>, B1>; +pub type P409 = PInt; +pub type N409 = NInt; +pub type U410 = + UInt, B1>, B0>, B0>, B1>, B1>, B0>, B1>, B0>; +pub type P410 = PInt; +pub type N410 = NInt; +pub type U411 = + UInt, B1>, B0>, B0>, B1>, B1>, B0>, B1>, B1>; +pub type P411 = PInt; +pub type N411 = NInt; +pub type U412 = + UInt, B1>, B0>, B0>, B1>, B1>, B1>, B0>, B0>; +pub type P412 = PInt; +pub type N412 = NInt; +pub type U413 = + UInt, B1>, B0>, B0>, B1>, B1>, B1>, B0>, B1>; +pub type P413 = PInt; +pub type N413 = NInt; +pub type U414 = + UInt, B1>, B0>, B0>, B1>, B1>, B1>, B1>, B0>; +pub type P414 = PInt; +pub type N414 = NInt; +pub type U415 = + UInt, B1>, B0>, B0>, B1>, B1>, B1>, B1>, B1>; +pub type P415 = PInt; +pub type N415 = NInt; +pub type U416 = + UInt, B1>, B0>, B1>, B0>, B0>, B0>, B0>, B0>; +pub type P416 = PInt; +pub type N416 = NInt; +pub type U417 = + UInt, B1>, B0>, B1>, B0>, B0>, B0>, B0>, B1>; +pub type P417 = PInt; +pub type N417 = NInt; +pub type U418 = + UInt, B1>, B0>, B1>, B0>, B0>, B0>, B1>, B0>; +pub type P418 = PInt; +pub type N418 = NInt; +pub type U419 = + UInt, B1>, B0>, B1>, B0>, B0>, B0>, B1>, B1>; +pub type P419 = PInt; +pub type N419 = NInt; +pub type U420 = + UInt, B1>, B0>, B1>, B0>, B0>, B1>, B0>, B0>; +pub type P420 = PInt; +pub type N420 = NInt; +pub type U421 = + UInt, B1>, B0>, B1>, B0>, B0>, B1>, B0>, B1>; +pub type P421 = PInt; +pub type N421 = NInt; +pub type U422 = + UInt, B1>, B0>, B1>, B0>, B0>, B1>, B1>, B0>; +pub type P422 = PInt; +pub type N422 = NInt; +pub type U423 = + UInt, B1>, B0>, B1>, B0>, B0>, B1>, B1>, B1>; +pub type P423 = PInt; +pub type N423 = NInt; +pub type U424 = + UInt, B1>, B0>, B1>, B0>, B1>, B0>, B0>, B0>; +pub type P424 = PInt; +pub type N424 = NInt; +pub type U425 = + UInt, B1>, B0>, B1>, B0>, B1>, B0>, B0>, B1>; +pub type P425 = PInt; +pub type N425 = NInt; +pub type U426 = + UInt, B1>, B0>, B1>, B0>, B1>, B0>, B1>, B0>; +pub type P426 = PInt; +pub type N426 = NInt; +pub type U427 = + UInt, B1>, B0>, B1>, B0>, B1>, B0>, B1>, B1>; +pub type P427 = PInt; +pub type N427 = NInt; +pub type U428 = + UInt, B1>, B0>, B1>, B0>, B1>, B1>, B0>, B0>; +pub type P428 = PInt; +pub type N428 = NInt; +pub type U429 = + UInt, B1>, B0>, B1>, B0>, B1>, B1>, B0>, B1>; +pub type P429 = PInt; +pub type N429 = NInt; +pub type U430 = + UInt, B1>, B0>, B1>, B0>, B1>, B1>, B1>, B0>; +pub type P430 = PInt; +pub type N430 = NInt; +pub type U431 = + UInt, B1>, B0>, B1>, B0>, B1>, B1>, B1>, B1>; +pub type P431 = PInt; +pub type N431 = NInt; +pub type U432 = + UInt, B1>, B0>, B1>, B1>, B0>, B0>, B0>, B0>; +pub type P432 = PInt; +pub type N432 = NInt; +pub type U433 = + UInt, B1>, B0>, B1>, B1>, B0>, B0>, B0>, B1>; +pub type P433 = PInt; +pub type N433 = NInt; +pub type U434 = + UInt, B1>, B0>, B1>, B1>, B0>, B0>, B1>, B0>; +pub type P434 = PInt; +pub type N434 = NInt; +pub type U435 = + UInt, B1>, B0>, B1>, B1>, B0>, B0>, B1>, B1>; +pub type P435 = PInt; +pub type N435 = NInt; +pub type U436 = + UInt, B1>, B0>, B1>, B1>, B0>, B1>, B0>, B0>; +pub type P436 = PInt; +pub type N436 = NInt; +pub type U437 = + UInt, B1>, B0>, B1>, B1>, B0>, B1>, B0>, B1>; +pub type P437 = PInt; +pub type N437 = NInt; +pub type U438 = + UInt, B1>, B0>, B1>, B1>, B0>, B1>, B1>, B0>; +pub type P438 = PInt; +pub type N438 = NInt; +pub type U439 = + UInt, B1>, B0>, B1>, B1>, B0>, B1>, B1>, B1>; +pub type P439 = PInt; +pub type N439 = NInt; +pub type U440 = + UInt, B1>, B0>, B1>, B1>, B1>, B0>, B0>, B0>; +pub type P440 = PInt; +pub type N440 = NInt; +pub type U441 = + UInt, B1>, B0>, B1>, B1>, B1>, B0>, B0>, B1>; +pub type P441 = PInt; +pub type N441 = NInt; +pub type U442 = + UInt, B1>, B0>, B1>, B1>, B1>, B0>, B1>, B0>; +pub type P442 = PInt; +pub type N442 = NInt; +pub type U443 = + UInt, B1>, B0>, B1>, B1>, B1>, B0>, B1>, B1>; +pub type P443 = PInt; +pub type N443 = NInt; +pub type U444 = + UInt, B1>, B0>, B1>, B1>, B1>, B1>, B0>, B0>; +pub type P444 = PInt; +pub type N444 = NInt; +pub type U445 = + UInt, B1>, B0>, B1>, B1>, B1>, B1>, B0>, B1>; +pub type P445 = PInt; +pub type N445 = NInt; +pub type U446 = + UInt, B1>, B0>, B1>, B1>, B1>, B1>, B1>, B0>; +pub type P446 = PInt; +pub type N446 = NInt; +pub type U447 = + UInt, B1>, B0>, B1>, B1>, B1>, B1>, B1>, B1>; +pub type P447 = PInt; +pub type N447 = NInt; +pub type U448 = + UInt, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P448 = PInt; +pub type N448 = NInt; +pub type U449 = + UInt, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B1>; +pub type P449 = PInt; +pub type N449 = NInt; +pub type U450 = + UInt, B1>, B1>, B0>, B0>, B0>, B0>, B1>, B0>; +pub type P450 = PInt; +pub type N450 = NInt; +pub type U451 = + UInt, B1>, B1>, B0>, B0>, B0>, B0>, B1>, B1>; +pub type P451 = PInt; +pub type N451 = NInt; +pub type U452 = + UInt, B1>, B1>, B0>, B0>, B0>, B1>, B0>, B0>; +pub type P452 = PInt; +pub type N452 = NInt; +pub type U453 = + UInt, B1>, B1>, B0>, B0>, B0>, B1>, B0>, B1>; +pub type P453 = PInt; +pub type N453 = NInt; +pub type U454 = + UInt, B1>, B1>, B0>, B0>, B0>, B1>, B1>, B0>; +pub type P454 = PInt; +pub type N454 = NInt; +pub type U455 = + UInt, B1>, B1>, B0>, B0>, B0>, B1>, B1>, B1>; +pub type P455 = PInt; +pub type N455 = NInt; +pub type U456 = + UInt, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>; +pub type P456 = PInt; +pub type N456 = NInt; +pub type U457 = + UInt, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B1>; +pub type P457 = PInt; +pub type N457 = NInt; +pub type U458 = + UInt, B1>, B1>, B0>, B0>, B1>, B0>, B1>, B0>; +pub type P458 = PInt; +pub type N458 = NInt; +pub type U459 = + UInt, B1>, B1>, B0>, B0>, B1>, B0>, B1>, B1>; +pub type P459 = PInt; +pub type N459 = NInt; +pub type U460 = + UInt, B1>, B1>, B0>, B0>, B1>, B1>, B0>, B0>; +pub type P460 = PInt; +pub type N460 = NInt; +pub type U461 = + UInt, B1>, B1>, B0>, B0>, B1>, B1>, B0>, B1>; +pub type P461 = PInt; +pub type N461 = NInt; +pub type U462 = + UInt, B1>, B1>, B0>, B0>, B1>, B1>, B1>, B0>; +pub type P462 = PInt; +pub type N462 = NInt; +pub type U463 = + UInt, B1>, B1>, B0>, B0>, B1>, B1>, B1>, B1>; +pub type P463 = PInt; +pub type N463 = NInt; +pub type U464 = + UInt, B1>, B1>, B0>, B1>, B0>, B0>, B0>, B0>; +pub type P464 = PInt; +pub type N464 = NInt; +pub type U465 = + UInt, B1>, B1>, B0>, B1>, B0>, B0>, B0>, B1>; +pub type P465 = PInt; +pub type N465 = NInt; +pub type U466 = + UInt, B1>, B1>, B0>, B1>, B0>, B0>, B1>, B0>; +pub type P466 = PInt; +pub type N466 = NInt; +pub type U467 = + UInt, B1>, B1>, B0>, B1>, B0>, B0>, B1>, B1>; +pub type P467 = PInt; +pub type N467 = NInt; +pub type U468 = + UInt, B1>, B1>, B0>, B1>, B0>, B1>, B0>, B0>; +pub type P468 = PInt; +pub type N468 = NInt; +pub type U469 = + UInt, B1>, B1>, B0>, B1>, B0>, B1>, B0>, B1>; +pub type P469 = PInt; +pub type N469 = NInt; +pub type U470 = + UInt, B1>, B1>, B0>, B1>, B0>, B1>, B1>, B0>; +pub type P470 = PInt; +pub type N470 = NInt; +pub type U471 = + UInt, B1>, B1>, B0>, B1>, B0>, B1>, B1>, B1>; +pub type P471 = PInt; +pub type N471 = NInt; +pub type U472 = + UInt, B1>, B1>, B0>, B1>, B1>, B0>, B0>, B0>; +pub type P472 = PInt; +pub type N472 = NInt; +pub type U473 = + UInt, B1>, B1>, B0>, B1>, B1>, B0>, B0>, B1>; +pub type P473 = PInt; +pub type N473 = NInt; +pub type U474 = + UInt, B1>, B1>, B0>, B1>, B1>, B0>, B1>, B0>; +pub type P474 = PInt; +pub type N474 = NInt; +pub type U475 = + UInt, B1>, B1>, B0>, B1>, B1>, B0>, B1>, B1>; +pub type P475 = PInt; +pub type N475 = NInt; +pub type U476 = + UInt, B1>, B1>, B0>, B1>, B1>, B1>, B0>, B0>; +pub type P476 = PInt; +pub type N476 = NInt; +pub type U477 = + UInt, B1>, B1>, B0>, B1>, B1>, B1>, B0>, B1>; +pub type P477 = PInt; +pub type N477 = NInt; +pub type U478 = + UInt, B1>, B1>, B0>, B1>, B1>, B1>, B1>, B0>; +pub type P478 = PInt; +pub type N478 = NInt; +pub type U479 = + UInt, B1>, B1>, B0>, B1>, B1>, B1>, B1>, B1>; +pub type P479 = PInt; +pub type N479 = NInt; +pub type U480 = + UInt, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B0>; +pub type P480 = PInt; +pub type N480 = NInt; +pub type U481 = + UInt, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B1>; +pub type P481 = PInt; +pub type N481 = NInt; +pub type U482 = + UInt, B1>, B1>, B1>, B0>, B0>, B0>, B1>, B0>; +pub type P482 = PInt; +pub type N482 = NInt; +pub type U483 = + UInt, B1>, B1>, B1>, B0>, B0>, B0>, B1>, B1>; +pub type P483 = PInt; +pub type N483 = NInt; +pub type U484 = + UInt, B1>, B1>, B1>, B0>, B0>, B1>, B0>, B0>; +pub type P484 = PInt; +pub type N484 = NInt; +pub type U485 = + UInt, B1>, B1>, B1>, B0>, B0>, B1>, B0>, B1>; +pub type P485 = PInt; +pub type N485 = NInt; +pub type U486 = + UInt, B1>, B1>, B1>, B0>, B0>, B1>, B1>, B0>; +pub type P486 = PInt; +pub type N486 = NInt; +pub type U487 = + UInt, B1>, B1>, B1>, B0>, B0>, B1>, B1>, B1>; +pub type P487 = PInt; +pub type N487 = NInt; +pub type U488 = + UInt, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B0>; +pub type P488 = PInt; +pub type N488 = NInt; +pub type U489 = + UInt, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B1>; +pub type P489 = PInt; +pub type N489 = NInt; +pub type U490 = + UInt, B1>, B1>, B1>, B0>, B1>, B0>, B1>, B0>; +pub type P490 = PInt; +pub type N490 = NInt; +pub type U491 = + UInt, B1>, B1>, B1>, B0>, B1>, B0>, B1>, B1>; +pub type P491 = PInt; +pub type N491 = NInt; +pub type U492 = + UInt, B1>, B1>, B1>, B0>, B1>, B1>, B0>, B0>; +pub type P492 = PInt; +pub type N492 = NInt; +pub type U493 = + UInt, B1>, B1>, B1>, B0>, B1>, B1>, B0>, B1>; +pub type P493 = PInt; +pub type N493 = NInt; +pub type U494 = + UInt, B1>, B1>, B1>, B0>, B1>, B1>, B1>, B0>; +pub type P494 = PInt; +pub type N494 = NInt; +pub type U495 = + UInt, B1>, B1>, B1>, B0>, B1>, B1>, B1>, B1>; +pub type P495 = PInt; +pub type N495 = NInt; +pub type U496 = + UInt, B1>, B1>, B1>, B1>, B0>, B0>, B0>, B0>; +pub type P496 = PInt; +pub type N496 = NInt; +pub type U497 = + UInt, B1>, B1>, B1>, B1>, B0>, B0>, B0>, B1>; +pub type P497 = PInt; +pub type N497 = NInt; +pub type U498 = + UInt, B1>, B1>, B1>, B1>, B0>, B0>, B1>, B0>; +pub type P498 = PInt; +pub type N498 = NInt; +pub type U499 = + UInt, B1>, B1>, B1>, B1>, B0>, B0>, B1>, B1>; +pub type P499 = PInt; +pub type N499 = NInt; +pub type U500 = + UInt, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>; +pub type P500 = PInt; +pub type N500 = NInt; +pub type U501 = + UInt, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B1>; +pub type P501 = PInt; +pub type N501 = NInt; +pub type U502 = + UInt, B1>, B1>, B1>, B1>, B0>, B1>, B1>, B0>; +pub type P502 = PInt; +pub type N502 = NInt; +pub type U503 = + UInt, B1>, B1>, B1>, B1>, B0>, B1>, B1>, B1>; +pub type P503 = PInt; +pub type N503 = NInt; +pub type U504 = + UInt, B1>, B1>, B1>, B1>, B1>, B0>, B0>, B0>; +pub type P504 = PInt; +pub type N504 = NInt; +pub type U505 = + UInt, B1>, B1>, B1>, B1>, B1>, B0>, B0>, B1>; +pub type P505 = PInt; +pub type N505 = NInt; +pub type U506 = + UInt, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>; +pub type P506 = PInt; +pub type N506 = NInt; +pub type U507 = + UInt, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B1>; +pub type P507 = PInt; +pub type N507 = NInt; +pub type U508 = + UInt, B1>, B1>, B1>, B1>, B1>, B1>, B0>, B0>; +pub type P508 = PInt; +pub type N508 = NInt; +pub type U509 = + UInt, B1>, B1>, B1>, B1>, B1>, B1>, B0>, B1>; +pub type P509 = PInt; +pub type N509 = NInt; +pub type U510 = + UInt, B1>, B1>, B1>, B1>, B1>, B1>, B1>, B0>; +pub type P510 = PInt; +pub type N510 = NInt; +pub type U511 = + UInt, B1>, B1>, B1>, B1>, B1>, B1>, B1>, B1>; +pub type P511 = PInt; +pub type N511 = NInt; +pub type U512 = UInt< + UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, + B0, +>; +pub type P512 = PInt; +pub type N512 = NInt; +pub type U513 = UInt< + UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, + B1, +>; +pub type P513 = PInt; +pub type N513 = NInt; +pub type U514 = UInt< + UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B1>, + B0, +>; +pub type P514 = PInt; +pub type N514 = NInt; +pub type U515 = UInt< + UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B1>, + B1, +>; +pub type P515 = PInt; +pub type N515 = NInt; +pub type U516 = UInt< + UInt, B0>, B0>, B0>, B0>, B0>, B0>, B1>, B0>, + B0, +>; +pub type P516 = PInt; +pub type N516 = NInt; +pub type U517 = UInt< + UInt, B0>, B0>, B0>, B0>, B0>, B0>, B1>, B0>, + B1, +>; +pub type P517 = PInt; +pub type N517 = NInt; +pub type U518 = UInt< + UInt, B0>, B0>, B0>, B0>, B0>, B0>, B1>, B1>, + B0, +>; +pub type P518 = PInt; +pub type N518 = NInt; +pub type U519 = UInt< + UInt, B0>, B0>, B0>, B0>, B0>, B0>, B1>, B1>, + B1, +>; +pub type P519 = PInt; +pub type N519 = NInt; +pub type U520 = UInt< + UInt, B0>, B0>, B0>, B0>, B0>, B1>, B0>, B0>, + B0, +>; +pub type P520 = PInt; +pub type N520 = NInt; +pub type U521 = UInt< + UInt, B0>, B0>, B0>, B0>, B0>, B1>, B0>, B0>, + B1, +>; +pub type P521 = PInt; +pub type N521 = NInt; +pub type U522 = UInt< + UInt, B0>, B0>, B0>, B0>, B0>, B1>, B0>, B1>, + B0, +>; +pub type P522 = PInt; +pub type N522 = NInt; +pub type U523 = UInt< + UInt, B0>, B0>, B0>, B0>, B0>, B1>, B0>, B1>, + B1, +>; +pub type P523 = PInt; +pub type N523 = NInt; +pub type U524 = UInt< + UInt, B0>, B0>, B0>, B0>, B0>, B1>, B1>, B0>, + B0, +>; +pub type P524 = PInt; +pub type N524 = NInt; +pub type U525 = UInt< + UInt, B0>, B0>, B0>, B0>, B0>, B1>, B1>, B0>, + B1, +>; +pub type P525 = PInt; +pub type N525 = NInt; +pub type U526 = UInt< + UInt, B0>, B0>, B0>, B0>, B0>, B1>, B1>, B1>, + B0, +>; +pub type P526 = PInt; +pub type N526 = NInt; +pub type U527 = UInt< + UInt, B0>, B0>, B0>, B0>, B0>, B1>, B1>, B1>, + B1, +>; +pub type P527 = PInt; +pub type N527 = NInt; +pub type U528 = UInt< + UInt, B0>, B0>, B0>, B0>, B1>, B0>, B0>, B0>, + B0, +>; +pub type P528 = PInt; +pub type N528 = NInt; +pub type U529 = UInt< + UInt, B0>, B0>, B0>, B0>, B1>, B0>, B0>, B0>, + B1, +>; +pub type P529 = PInt; +pub type N529 = NInt; +pub type U530 = UInt< + UInt, B0>, B0>, B0>, B0>, B1>, B0>, B0>, B1>, + B0, +>; +pub type P530 = PInt; +pub type N530 = NInt; +pub type U531 = UInt< + UInt, B0>, B0>, B0>, B0>, B1>, B0>, B0>, B1>, + B1, +>; +pub type P531 = PInt; +pub type N531 = NInt; +pub type U532 = UInt< + UInt, B0>, B0>, B0>, B0>, B1>, B0>, B1>, B0>, + B0, +>; +pub type P532 = PInt; +pub type N532 = NInt; +pub type U533 = UInt< + UInt, B0>, B0>, B0>, B0>, B1>, B0>, B1>, B0>, + B1, +>; +pub type P533 = PInt; +pub type N533 = NInt; +pub type U534 = UInt< + UInt, B0>, B0>, B0>, B0>, B1>, B0>, B1>, B1>, + B0, +>; +pub type P534 = PInt; +pub type N534 = NInt; +pub type U535 = UInt< + UInt, B0>, B0>, B0>, B0>, B1>, B0>, B1>, B1>, + B1, +>; +pub type P535 = PInt; +pub type N535 = NInt; +pub type U536 = UInt< + UInt, B0>, B0>, B0>, B0>, B1>, B1>, B0>, B0>, + B0, +>; +pub type P536 = PInt; +pub type N536 = NInt; +pub type U537 = UInt< + UInt, B0>, B0>, B0>, B0>, B1>, B1>, B0>, B0>, + B1, +>; +pub type P537 = PInt; +pub type N537 = NInt; +pub type U538 = UInt< + UInt, B0>, B0>, B0>, B0>, B1>, B1>, B0>, B1>, + B0, +>; +pub type P538 = PInt; +pub type N538 = NInt; +pub type U539 = UInt< + UInt, B0>, B0>, B0>, B0>, B1>, B1>, B0>, B1>, + B1, +>; +pub type P539 = PInt; +pub type N539 = NInt; +pub type U540 = UInt< + UInt, B0>, B0>, B0>, B0>, B1>, B1>, B1>, B0>, + B0, +>; +pub type P540 = PInt; +pub type N540 = NInt; +pub type U541 = UInt< + UInt, B0>, B0>, B0>, B0>, B1>, B1>, B1>, B0>, + B1, +>; +pub type P541 = PInt; +pub type N541 = NInt; +pub type U542 = UInt< + UInt, B0>, B0>, B0>, B0>, B1>, B1>, B1>, B1>, + B0, +>; +pub type P542 = PInt; +pub type N542 = NInt; +pub type U543 = UInt< + UInt, B0>, B0>, B0>, B0>, B1>, B1>, B1>, B1>, + B1, +>; +pub type P543 = PInt; +pub type N543 = NInt; +pub type U544 = UInt< + UInt, B0>, B0>, B0>, B1>, B0>, B0>, B0>, B0>, + B0, +>; +pub type P544 = PInt; +pub type N544 = NInt; +pub type U545 = UInt< + UInt, B0>, B0>, B0>, B1>, B0>, B0>, B0>, B0>, + B1, +>; +pub type P545 = PInt; +pub type N545 = NInt; +pub type U546 = UInt< + UInt, B0>, B0>, B0>, B1>, B0>, B0>, B0>, B1>, + B0, +>; +pub type P546 = PInt; +pub type N546 = NInt; +pub type U547 = UInt< + UInt, B0>, B0>, B0>, B1>, B0>, B0>, B0>, B1>, + B1, +>; +pub type P547 = PInt; +pub type N547 = NInt; +pub type U548 = UInt< + UInt, B0>, B0>, B0>, B1>, B0>, B0>, B1>, B0>, + B0, +>; +pub type P548 = PInt; +pub type N548 = NInt; +pub type U549 = UInt< + UInt, B0>, B0>, B0>, B1>, B0>, B0>, B1>, B0>, + B1, +>; +pub type P549 = PInt; +pub type N549 = NInt; +pub type U550 = UInt< + UInt, B0>, B0>, B0>, B1>, B0>, B0>, B1>, B1>, + B0, +>; +pub type P550 = PInt; +pub type N550 = NInt; +pub type U551 = UInt< + UInt, B0>, B0>, B0>, B1>, B0>, B0>, B1>, B1>, + B1, +>; +pub type P551 = PInt; +pub type N551 = NInt; +pub type U552 = UInt< + UInt, B0>, B0>, B0>, B1>, B0>, B1>, B0>, B0>, + B0, +>; +pub type P552 = PInt; +pub type N552 = NInt; +pub type U553 = UInt< + UInt, B0>, B0>, B0>, B1>, B0>, B1>, B0>, B0>, + B1, +>; +pub type P553 = PInt; +pub type N553 = NInt; +pub type U554 = UInt< + UInt, B0>, B0>, B0>, B1>, B0>, B1>, B0>, B1>, + B0, +>; +pub type P554 = PInt; +pub type N554 = NInt; +pub type U555 = UInt< + UInt, B0>, B0>, B0>, B1>, B0>, B1>, B0>, B1>, + B1, +>; +pub type P555 = PInt; +pub type N555 = NInt; +pub type U556 = UInt< + UInt, B0>, B0>, B0>, B1>, B0>, B1>, B1>, B0>, + B0, +>; +pub type P556 = PInt; +pub type N556 = NInt; +pub type U557 = UInt< + UInt, B0>, B0>, B0>, B1>, B0>, B1>, B1>, B0>, + B1, +>; +pub type P557 = PInt; +pub type N557 = NInt; +pub type U558 = UInt< + UInt, B0>, B0>, B0>, B1>, B0>, B1>, B1>, B1>, + B0, +>; +pub type P558 = PInt; +pub type N558 = NInt; +pub type U559 = UInt< + UInt, B0>, B0>, B0>, B1>, B0>, B1>, B1>, B1>, + B1, +>; +pub type P559 = PInt; +pub type N559 = NInt; +pub type U560 = UInt< + UInt, B0>, B0>, B0>, B1>, B1>, B0>, B0>, B0>, + B0, +>; +pub type P560 = PInt; +pub type N560 = NInt; +pub type U561 = UInt< + UInt, B0>, B0>, B0>, B1>, B1>, B0>, B0>, B0>, + B1, +>; +pub type P561 = PInt; +pub type N561 = NInt; +pub type U562 = UInt< + UInt, B0>, B0>, B0>, B1>, B1>, B0>, B0>, B1>, + B0, +>; +pub type P562 = PInt; +pub type N562 = NInt; +pub type U563 = UInt< + UInt, B0>, B0>, B0>, B1>, B1>, B0>, B0>, B1>, + B1, +>; +pub type P563 = PInt; +pub type N563 = NInt; +pub type U564 = UInt< + UInt, B0>, B0>, B0>, B1>, B1>, B0>, B1>, B0>, + B0, +>; +pub type P564 = PInt; +pub type N564 = NInt; +pub type U565 = UInt< + UInt, B0>, B0>, B0>, B1>, B1>, B0>, B1>, B0>, + B1, +>; +pub type P565 = PInt; +pub type N565 = NInt; +pub type U566 = UInt< + UInt, B0>, B0>, B0>, B1>, B1>, B0>, B1>, B1>, + B0, +>; +pub type P566 = PInt; +pub type N566 = NInt; +pub type U567 = UInt< + UInt, B0>, B0>, B0>, B1>, B1>, B0>, B1>, B1>, + B1, +>; +pub type P567 = PInt; +pub type N567 = NInt; +pub type U568 = UInt< + UInt, B0>, B0>, B0>, B1>, B1>, B1>, B0>, B0>, + B0, +>; +pub type P568 = PInt; +pub type N568 = NInt; +pub type U569 = UInt< + UInt, B0>, B0>, B0>, B1>, B1>, B1>, B0>, B0>, + B1, +>; +pub type P569 = PInt; +pub type N569 = NInt; +pub type U570 = UInt< + UInt, B0>, B0>, B0>, B1>, B1>, B1>, B0>, B1>, + B0, +>; +pub type P570 = PInt; +pub type N570 = NInt; +pub type U571 = UInt< + UInt, B0>, B0>, B0>, B1>, B1>, B1>, B0>, B1>, + B1, +>; +pub type P571 = PInt; +pub type N571 = NInt; +pub type U572 = UInt< + UInt, B0>, B0>, B0>, B1>, B1>, B1>, B1>, B0>, + B0, +>; +pub type P572 = PInt; +pub type N572 = NInt; +pub type U573 = UInt< + UInt, B0>, B0>, B0>, B1>, B1>, B1>, B1>, B0>, + B1, +>; +pub type P573 = PInt; +pub type N573 = NInt; +pub type U574 = UInt< + UInt, B0>, B0>, B0>, B1>, B1>, B1>, B1>, B1>, + B0, +>; +pub type P574 = PInt; +pub type N574 = NInt; +pub type U575 = UInt< + UInt, B0>, B0>, B0>, B1>, B1>, B1>, B1>, B1>, + B1, +>; +pub type P575 = PInt; +pub type N575 = NInt; +pub type U576 = UInt< + UInt, B0>, B0>, B1>, B0>, B0>, B0>, B0>, B0>, + B0, +>; +pub type P576 = PInt; +pub type N576 = NInt; +pub type U577 = UInt< + UInt, B0>, B0>, B1>, B0>, B0>, B0>, B0>, B0>, + B1, +>; +pub type P577 = PInt; +pub type N577 = NInt; +pub type U578 = UInt< + UInt, B0>, B0>, B1>, B0>, B0>, B0>, B0>, B1>, + B0, +>; +pub type P578 = PInt; +pub type N578 = NInt; +pub type U579 = UInt< + UInt, B0>, B0>, B1>, B0>, B0>, B0>, B0>, B1>, + B1, +>; +pub type P579 = PInt; +pub type N579 = NInt; +pub type U580 = UInt< + UInt, B0>, B0>, B1>, B0>, B0>, B0>, B1>, B0>, + B0, +>; +pub type P580 = PInt; +pub type N580 = NInt; +pub type U581 = UInt< + UInt, B0>, B0>, B1>, B0>, B0>, B0>, B1>, B0>, + B1, +>; +pub type P581 = PInt; +pub type N581 = NInt; +pub type U582 = UInt< + UInt, B0>, B0>, B1>, B0>, B0>, B0>, B1>, B1>, + B0, +>; +pub type P582 = PInt; +pub type N582 = NInt; +pub type U583 = UInt< + UInt, B0>, B0>, B1>, B0>, B0>, B0>, B1>, B1>, + B1, +>; +pub type P583 = PInt; +pub type N583 = NInt; +pub type U584 = UInt< + UInt, B0>, B0>, B1>, B0>, B0>, B1>, B0>, B0>, + B0, +>; +pub type P584 = PInt; +pub type N584 = NInt; +pub type U585 = UInt< + UInt, B0>, B0>, B1>, B0>, B0>, B1>, B0>, B0>, + B1, +>; +pub type P585 = PInt; +pub type N585 = NInt; +pub type U586 = UInt< + UInt, B0>, B0>, B1>, B0>, B0>, B1>, B0>, B1>, + B0, +>; +pub type P586 = PInt; +pub type N586 = NInt; +pub type U587 = UInt< + UInt, B0>, B0>, B1>, B0>, B0>, B1>, B0>, B1>, + B1, +>; +pub type P587 = PInt; +pub type N587 = NInt; +pub type U588 = UInt< + UInt, B0>, B0>, B1>, B0>, B0>, B1>, B1>, B0>, + B0, +>; +pub type P588 = PInt; +pub type N588 = NInt; +pub type U589 = UInt< + UInt, B0>, B0>, B1>, B0>, B0>, B1>, B1>, B0>, + B1, +>; +pub type P589 = PInt; +pub type N589 = NInt; +pub type U590 = UInt< + UInt, B0>, B0>, B1>, B0>, B0>, B1>, B1>, B1>, + B0, +>; +pub type P590 = PInt; +pub type N590 = NInt; +pub type U591 = UInt< + UInt, B0>, B0>, B1>, B0>, B0>, B1>, B1>, B1>, + B1, +>; +pub type P591 = PInt; +pub type N591 = NInt; +pub type U592 = UInt< + UInt, B0>, B0>, B1>, B0>, B1>, B0>, B0>, B0>, + B0, +>; +pub type P592 = PInt; +pub type N592 = NInt; +pub type U593 = UInt< + UInt, B0>, B0>, B1>, B0>, B1>, B0>, B0>, B0>, + B1, +>; +pub type P593 = PInt; +pub type N593 = NInt; +pub type U594 = UInt< + UInt, B0>, B0>, B1>, B0>, B1>, B0>, B0>, B1>, + B0, +>; +pub type P594 = PInt; +pub type N594 = NInt; +pub type U595 = UInt< + UInt, B0>, B0>, B1>, B0>, B1>, B0>, B0>, B1>, + B1, +>; +pub type P595 = PInt; +pub type N595 = NInt; +pub type U596 = UInt< + UInt, B0>, B0>, B1>, B0>, B1>, B0>, B1>, B0>, + B0, +>; +pub type P596 = PInt; +pub type N596 = NInt; +pub type U597 = UInt< + UInt, B0>, B0>, B1>, B0>, B1>, B0>, B1>, B0>, + B1, +>; +pub type P597 = PInt; +pub type N597 = NInt; +pub type U598 = UInt< + UInt, B0>, B0>, B1>, B0>, B1>, B0>, B1>, B1>, + B0, +>; +pub type P598 = PInt; +pub type N598 = NInt; +pub type U599 = UInt< + UInt, B0>, B0>, B1>, B0>, B1>, B0>, B1>, B1>, + B1, +>; +pub type P599 = PInt; +pub type N599 = NInt; +pub type U600 = UInt< + UInt, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B0>, + B0, +>; +pub type P600 = PInt; +pub type N600 = NInt; +pub type U601 = UInt< + UInt, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B0>, + B1, +>; +pub type P601 = PInt; +pub type N601 = NInt; +pub type U602 = UInt< + UInt, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B1>, + B0, +>; +pub type P602 = PInt; +pub type N602 = NInt; +pub type U603 = UInt< + UInt, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B1>, + B1, +>; +pub type P603 = PInt; +pub type N603 = NInt; +pub type U604 = UInt< + UInt, B0>, B0>, B1>, B0>, B1>, B1>, B1>, B0>, + B0, +>; +pub type P604 = PInt; +pub type N604 = NInt; +pub type U605 = UInt< + UInt, B0>, B0>, B1>, B0>, B1>, B1>, B1>, B0>, + B1, +>; +pub type P605 = PInt; +pub type N605 = NInt; +pub type U606 = UInt< + UInt, B0>, B0>, B1>, B0>, B1>, B1>, B1>, B1>, + B0, +>; +pub type P606 = PInt; +pub type N606 = NInt; +pub type U607 = UInt< + UInt, B0>, B0>, B1>, B0>, B1>, B1>, B1>, B1>, + B1, +>; +pub type P607 = PInt; +pub type N607 = NInt; +pub type U608 = UInt< + UInt, B0>, B0>, B1>, B1>, B0>, B0>, B0>, B0>, + B0, +>; +pub type P608 = PInt; +pub type N608 = NInt; +pub type U609 = UInt< + UInt, B0>, B0>, B1>, B1>, B0>, B0>, B0>, B0>, + B1, +>; +pub type P609 = PInt; +pub type N609 = NInt; +pub type U610 = UInt< + UInt, B0>, B0>, B1>, B1>, B0>, B0>, B0>, B1>, + B0, +>; +pub type P610 = PInt; +pub type N610 = NInt; +pub type U611 = UInt< + UInt, B0>, B0>, B1>, B1>, B0>, B0>, B0>, B1>, + B1, +>; +pub type P611 = PInt; +pub type N611 = NInt; +pub type U612 = UInt< + UInt, B0>, B0>, B1>, B1>, B0>, B0>, B1>, B0>, + B0, +>; +pub type P612 = PInt; +pub type N612 = NInt; +pub type U613 = UInt< + UInt, B0>, B0>, B1>, B1>, B0>, B0>, B1>, B0>, + B1, +>; +pub type P613 = PInt; +pub type N613 = NInt; +pub type U614 = UInt< + UInt, B0>, B0>, B1>, B1>, B0>, B0>, B1>, B1>, + B0, +>; +pub type P614 = PInt; +pub type N614 = NInt; +pub type U615 = UInt< + UInt, B0>, B0>, B1>, B1>, B0>, B0>, B1>, B1>, + B1, +>; +pub type P615 = PInt; +pub type N615 = NInt; +pub type U616 = UInt< + UInt, B0>, B0>, B1>, B1>, B0>, B1>, B0>, B0>, + B0, +>; +pub type P616 = PInt; +pub type N616 = NInt; +pub type U617 = UInt< + UInt, B0>, B0>, B1>, B1>, B0>, B1>, B0>, B0>, + B1, +>; +pub type P617 = PInt; +pub type N617 = NInt; +pub type U618 = UInt< + UInt, B0>, B0>, B1>, B1>, B0>, B1>, B0>, B1>, + B0, +>; +pub type P618 = PInt; +pub type N618 = NInt; +pub type U619 = UInt< + UInt, B0>, B0>, B1>, B1>, B0>, B1>, B0>, B1>, + B1, +>; +pub type P619 = PInt; +pub type N619 = NInt; +pub type U620 = UInt< + UInt, B0>, B0>, B1>, B1>, B0>, B1>, B1>, B0>, + B0, +>; +pub type P620 = PInt; +pub type N620 = NInt; +pub type U621 = UInt< + UInt, B0>, B0>, B1>, B1>, B0>, B1>, B1>, B0>, + B1, +>; +pub type P621 = PInt; +pub type N621 = NInt; +pub type U622 = UInt< + UInt, B0>, B0>, B1>, B1>, B0>, B1>, B1>, B1>, + B0, +>; +pub type P622 = PInt; +pub type N622 = NInt; +pub type U623 = UInt< + UInt, B0>, B0>, B1>, B1>, B0>, B1>, B1>, B1>, + B1, +>; +pub type P623 = PInt; +pub type N623 = NInt; +pub type U624 = UInt< + UInt, B0>, B0>, B1>, B1>, B1>, B0>, B0>, B0>, + B0, +>; +pub type P624 = PInt; +pub type N624 = NInt; +pub type U625 = UInt< + UInt, B0>, B0>, B1>, B1>, B1>, B0>, B0>, B0>, + B1, +>; +pub type P625 = PInt; +pub type N625 = NInt; +pub type U626 = UInt< + UInt, B0>, B0>, B1>, B1>, B1>, B0>, B0>, B1>, + B0, +>; +pub type P626 = PInt; +pub type N626 = NInt; +pub type U627 = UInt< + UInt, B0>, B0>, B1>, B1>, B1>, B0>, B0>, B1>, + B1, +>; +pub type P627 = PInt; +pub type N627 = NInt; +pub type U628 = UInt< + UInt, B0>, B0>, B1>, B1>, B1>, B0>, B1>, B0>, + B0, +>; +pub type P628 = PInt; +pub type N628 = NInt; +pub type U629 = UInt< + UInt, B0>, B0>, B1>, B1>, B1>, B0>, B1>, B0>, + B1, +>; +pub type P629 = PInt; +pub type N629 = NInt; +pub type U630 = UInt< + UInt, B0>, B0>, B1>, B1>, B1>, B0>, B1>, B1>, + B0, +>; +pub type P630 = PInt; +pub type N630 = NInt; +pub type U631 = UInt< + UInt, B0>, B0>, B1>, B1>, B1>, B0>, B1>, B1>, + B1, +>; +pub type P631 = PInt; +pub type N631 = NInt; +pub type U632 = UInt< + UInt, B0>, B0>, B1>, B1>, B1>, B1>, B0>, B0>, + B0, +>; +pub type P632 = PInt; +pub type N632 = NInt; +pub type U633 = UInt< + UInt, B0>, B0>, B1>, B1>, B1>, B1>, B0>, B0>, + B1, +>; +pub type P633 = PInt; +pub type N633 = NInt; +pub type U634 = UInt< + UInt, B0>, B0>, B1>, B1>, B1>, B1>, B0>, B1>, + B0, +>; +pub type P634 = PInt; +pub type N634 = NInt; +pub type U635 = UInt< + UInt, B0>, B0>, B1>, B1>, B1>, B1>, B0>, B1>, + B1, +>; +pub type P635 = PInt; +pub type N635 = NInt; +pub type U636 = UInt< + UInt, B0>, B0>, B1>, B1>, B1>, B1>, B1>, B0>, + B0, +>; +pub type P636 = PInt; +pub type N636 = NInt; +pub type U637 = UInt< + UInt, B0>, B0>, B1>, B1>, B1>, B1>, B1>, B0>, + B1, +>; +pub type P637 = PInt; +pub type N637 = NInt; +pub type U638 = UInt< + UInt, B0>, B0>, B1>, B1>, B1>, B1>, B1>, B1>, + B0, +>; +pub type P638 = PInt; +pub type N638 = NInt; +pub type U639 = UInt< + UInt, B0>, B0>, B1>, B1>, B1>, B1>, B1>, B1>, + B1, +>; +pub type P639 = PInt; +pub type N639 = NInt; +pub type U640 = UInt< + UInt, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, + B0, +>; +pub type P640 = PInt; +pub type N640 = NInt; +pub type U641 = UInt< + UInt, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, + B1, +>; +pub type P641 = PInt; +pub type N641 = NInt; +pub type U642 = UInt< + UInt, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B1>, + B0, +>; +pub type P642 = PInt; +pub type N642 = NInt; +pub type U643 = UInt< + UInt, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B1>, + B1, +>; +pub type P643 = PInt; +pub type N643 = NInt; +pub type U644 = UInt< + UInt, B0>, B1>, B0>, B0>, B0>, B0>, B1>, B0>, + B0, +>; +pub type P644 = PInt; +pub type N644 = NInt; +pub type U645 = UInt< + UInt, B0>, B1>, B0>, B0>, B0>, B0>, B1>, B0>, + B1, +>; +pub type P645 = PInt; +pub type N645 = NInt; +pub type U646 = UInt< + UInt, B0>, B1>, B0>, B0>, B0>, B0>, B1>, B1>, + B0, +>; +pub type P646 = PInt; +pub type N646 = NInt; +pub type U647 = UInt< + UInt, B0>, B1>, B0>, B0>, B0>, B0>, B1>, B1>, + B1, +>; +pub type P647 = PInt; +pub type N647 = NInt; +pub type U648 = UInt< + UInt, B0>, B1>, B0>, B0>, B0>, B1>, B0>, B0>, + B0, +>; +pub type P648 = PInt; +pub type N648 = NInt; +pub type U649 = UInt< + UInt, B0>, B1>, B0>, B0>, B0>, B1>, B0>, B0>, + B1, +>; +pub type P649 = PInt; +pub type N649 = NInt; +pub type U650 = UInt< + UInt, B0>, B1>, B0>, B0>, B0>, B1>, B0>, B1>, + B0, +>; +pub type P650 = PInt; +pub type N650 = NInt; +pub type U651 = UInt< + UInt, B0>, B1>, B0>, B0>, B0>, B1>, B0>, B1>, + B1, +>; +pub type P651 = PInt; +pub type N651 = NInt; +pub type U652 = UInt< + UInt, B0>, B1>, B0>, B0>, B0>, B1>, B1>, B0>, + B0, +>; +pub type P652 = PInt; +pub type N652 = NInt; +pub type U653 = UInt< + UInt, B0>, B1>, B0>, B0>, B0>, B1>, B1>, B0>, + B1, +>; +pub type P653 = PInt; +pub type N653 = NInt; +pub type U654 = UInt< + UInt, B0>, B1>, B0>, B0>, B0>, B1>, B1>, B1>, + B0, +>; +pub type P654 = PInt; +pub type N654 = NInt; +pub type U655 = UInt< + UInt, B0>, B1>, B0>, B0>, B0>, B1>, B1>, B1>, + B1, +>; +pub type P655 = PInt; +pub type N655 = NInt; +pub type U656 = UInt< + UInt, B0>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, + B0, +>; +pub type P656 = PInt; +pub type N656 = NInt; +pub type U657 = UInt< + UInt, B0>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, + B1, +>; +pub type P657 = PInt; +pub type N657 = NInt; +pub type U658 = UInt< + UInt, B0>, B1>, B0>, B0>, B1>, B0>, B0>, B1>, + B0, +>; +pub type P658 = PInt; +pub type N658 = NInt; +pub type U659 = UInt< + UInt, B0>, B1>, B0>, B0>, B1>, B0>, B0>, B1>, + B1, +>; +pub type P659 = PInt; +pub type N659 = NInt; +pub type U660 = UInt< + UInt, B0>, B1>, B0>, B0>, B1>, B0>, B1>, B0>, + B0, +>; +pub type P660 = PInt; +pub type N660 = NInt; +pub type U661 = UInt< + UInt, B0>, B1>, B0>, B0>, B1>, B0>, B1>, B0>, + B1, +>; +pub type P661 = PInt; +pub type N661 = NInt; +pub type U662 = UInt< + UInt, B0>, B1>, B0>, B0>, B1>, B0>, B1>, B1>, + B0, +>; +pub type P662 = PInt; +pub type N662 = NInt; +pub type U663 = UInt< + UInt, B0>, B1>, B0>, B0>, B1>, B0>, B1>, B1>, + B1, +>; +pub type P663 = PInt; +pub type N663 = NInt; +pub type U664 = UInt< + UInt, B0>, B1>, B0>, B0>, B1>, B1>, B0>, B0>, + B0, +>; +pub type P664 = PInt; +pub type N664 = NInt; +pub type U665 = UInt< + UInt, B0>, B1>, B0>, B0>, B1>, B1>, B0>, B0>, + B1, +>; +pub type P665 = PInt; +pub type N665 = NInt; +pub type U666 = UInt< + UInt, B0>, B1>, B0>, B0>, B1>, B1>, B0>, B1>, + B0, +>; +pub type P666 = PInt; +pub type N666 = NInt; +pub type U667 = UInt< + UInt, B0>, B1>, B0>, B0>, B1>, B1>, B0>, B1>, + B1, +>; +pub type P667 = PInt; +pub type N667 = NInt; +pub type U668 = UInt< + UInt, B0>, B1>, B0>, B0>, B1>, B1>, B1>, B0>, + B0, +>; +pub type P668 = PInt; +pub type N668 = NInt; +pub type U669 = UInt< + UInt, B0>, B1>, B0>, B0>, B1>, B1>, B1>, B0>, + B1, +>; +pub type P669 = PInt; +pub type N669 = NInt; +pub type U670 = UInt< + UInt, B0>, B1>, B0>, B0>, B1>, B1>, B1>, B1>, + B0, +>; +pub type P670 = PInt; +pub type N670 = NInt; +pub type U671 = UInt< + UInt, B0>, B1>, B0>, B0>, B1>, B1>, B1>, B1>, + B1, +>; +pub type P671 = PInt; +pub type N671 = NInt; +pub type U672 = UInt< + UInt, B0>, B1>, B0>, B1>, B0>, B0>, B0>, B0>, + B0, +>; +pub type P672 = PInt; +pub type N672 = NInt; +pub type U673 = UInt< + UInt, B0>, B1>, B0>, B1>, B0>, B0>, B0>, B0>, + B1, +>; +pub type P673 = PInt; +pub type N673 = NInt; +pub type U674 = UInt< + UInt, B0>, B1>, B0>, B1>, B0>, B0>, B0>, B1>, + B0, +>; +pub type P674 = PInt; +pub type N674 = NInt; +pub type U675 = UInt< + UInt, B0>, B1>, B0>, B1>, B0>, B0>, B0>, B1>, + B1, +>; +pub type P675 = PInt; +pub type N675 = NInt; +pub type U676 = UInt< + UInt, B0>, B1>, B0>, B1>, B0>, B0>, B1>, B0>, + B0, +>; +pub type P676 = PInt; +pub type N676 = NInt; +pub type U677 = UInt< + UInt, B0>, B1>, B0>, B1>, B0>, B0>, B1>, B0>, + B1, +>; +pub type P677 = PInt; +pub type N677 = NInt; +pub type U678 = UInt< + UInt, B0>, B1>, B0>, B1>, B0>, B0>, B1>, B1>, + B0, +>; +pub type P678 = PInt; +pub type N678 = NInt; +pub type U679 = UInt< + UInt, B0>, B1>, B0>, B1>, B0>, B0>, B1>, B1>, + B1, +>; +pub type P679 = PInt; +pub type N679 = NInt; +pub type U680 = UInt< + UInt, B0>, B1>, B0>, B1>, B0>, B1>, B0>, B0>, + B0, +>; +pub type P680 = PInt; +pub type N680 = NInt; +pub type U681 = UInt< + UInt, B0>, B1>, B0>, B1>, B0>, B1>, B0>, B0>, + B1, +>; +pub type P681 = PInt; +pub type N681 = NInt; +pub type U682 = UInt< + UInt, B0>, B1>, B0>, B1>, B0>, B1>, B0>, B1>, + B0, +>; +pub type P682 = PInt; +pub type N682 = NInt; +pub type U683 = UInt< + UInt, B0>, B1>, B0>, B1>, B0>, B1>, B0>, B1>, + B1, +>; +pub type P683 = PInt; +pub type N683 = NInt; +pub type U684 = UInt< + UInt, B0>, B1>, B0>, B1>, B0>, B1>, B1>, B0>, + B0, +>; +pub type P684 = PInt; +pub type N684 = NInt; +pub type U685 = UInt< + UInt, B0>, B1>, B0>, B1>, B0>, B1>, B1>, B0>, + B1, +>; +pub type P685 = PInt; +pub type N685 = NInt; +pub type U686 = UInt< + UInt, B0>, B1>, B0>, B1>, B0>, B1>, B1>, B1>, + B0, +>; +pub type P686 = PInt; +pub type N686 = NInt; +pub type U687 = UInt< + UInt, B0>, B1>, B0>, B1>, B0>, B1>, B1>, B1>, + B1, +>; +pub type P687 = PInt; +pub type N687 = NInt; +pub type U688 = UInt< + UInt, B0>, B1>, B0>, B1>, B1>, B0>, B0>, B0>, + B0, +>; +pub type P688 = PInt; +pub type N688 = NInt; +pub type U689 = UInt< + UInt, B0>, B1>, B0>, B1>, B1>, B0>, B0>, B0>, + B1, +>; +pub type P689 = PInt; +pub type N689 = NInt; +pub type U690 = UInt< + UInt, B0>, B1>, B0>, B1>, B1>, B0>, B0>, B1>, + B0, +>; +pub type P690 = PInt; +pub type N690 = NInt; +pub type U691 = UInt< + UInt, B0>, B1>, B0>, B1>, B1>, B0>, B0>, B1>, + B1, +>; +pub type P691 = PInt; +pub type N691 = NInt; +pub type U692 = UInt< + UInt, B0>, B1>, B0>, B1>, B1>, B0>, B1>, B0>, + B0, +>; +pub type P692 = PInt; +pub type N692 = NInt; +pub type U693 = UInt< + UInt, B0>, B1>, B0>, B1>, B1>, B0>, B1>, B0>, + B1, +>; +pub type P693 = PInt; +pub type N693 = NInt; +pub type U694 = UInt< + UInt, B0>, B1>, B0>, B1>, B1>, B0>, B1>, B1>, + B0, +>; +pub type P694 = PInt; +pub type N694 = NInt; +pub type U695 = UInt< + UInt, B0>, B1>, B0>, B1>, B1>, B0>, B1>, B1>, + B1, +>; +pub type P695 = PInt; +pub type N695 = NInt; +pub type U696 = UInt< + UInt, B0>, B1>, B0>, B1>, B1>, B1>, B0>, B0>, + B0, +>; +pub type P696 = PInt; +pub type N696 = NInt; +pub type U697 = UInt< + UInt, B0>, B1>, B0>, B1>, B1>, B1>, B0>, B0>, + B1, +>; +pub type P697 = PInt; +pub type N697 = NInt; +pub type U698 = UInt< + UInt, B0>, B1>, B0>, B1>, B1>, B1>, B0>, B1>, + B0, +>; +pub type P698 = PInt; +pub type N698 = NInt; +pub type U699 = UInt< + UInt, B0>, B1>, B0>, B1>, B1>, B1>, B0>, B1>, + B1, +>; +pub type P699 = PInt; +pub type N699 = NInt; +pub type U700 = UInt< + UInt, B0>, B1>, B0>, B1>, B1>, B1>, B1>, B0>, + B0, +>; +pub type P700 = PInt; +pub type N700 = NInt; +pub type U701 = UInt< + UInt, B0>, B1>, B0>, B1>, B1>, B1>, B1>, B0>, + B1, +>; +pub type P701 = PInt; +pub type N701 = NInt; +pub type U702 = UInt< + UInt, B0>, B1>, B0>, B1>, B1>, B1>, B1>, B1>, + B0, +>; +pub type P702 = PInt; +pub type N702 = NInt; +pub type U703 = UInt< + UInt, B0>, B1>, B0>, B1>, B1>, B1>, B1>, B1>, + B1, +>; +pub type P703 = PInt; +pub type N703 = NInt; +pub type U704 = UInt< + UInt, B0>, B1>, B1>, B0>, B0>, B0>, B0>, B0>, + B0, +>; +pub type P704 = PInt; +pub type N704 = NInt; +pub type U705 = UInt< + UInt, B0>, B1>, B1>, B0>, B0>, B0>, B0>, B0>, + B1, +>; +pub type P705 = PInt; +pub type N705 = NInt; +pub type U706 = UInt< + UInt, B0>, B1>, B1>, B0>, B0>, B0>, B0>, B1>, + B0, +>; +pub type P706 = PInt; +pub type N706 = NInt; +pub type U707 = UInt< + UInt, B0>, B1>, B1>, B0>, B0>, B0>, B0>, B1>, + B1, +>; +pub type P707 = PInt; +pub type N707 = NInt; +pub type U708 = UInt< + UInt, B0>, B1>, B1>, B0>, B0>, B0>, B1>, B0>, + B0, +>; +pub type P708 = PInt; +pub type N708 = NInt; +pub type U709 = UInt< + UInt, B0>, B1>, B1>, B0>, B0>, B0>, B1>, B0>, + B1, +>; +pub type P709 = PInt; +pub type N709 = NInt; +pub type U710 = UInt< + UInt, B0>, B1>, B1>, B0>, B0>, B0>, B1>, B1>, + B0, +>; +pub type P710 = PInt; +pub type N710 = NInt; +pub type U711 = UInt< + UInt, B0>, B1>, B1>, B0>, B0>, B0>, B1>, B1>, + B1, +>; +pub type P711 = PInt; +pub type N711 = NInt; +pub type U712 = UInt< + UInt, B0>, B1>, B1>, B0>, B0>, B1>, B0>, B0>, + B0, +>; +pub type P712 = PInt; +pub type N712 = NInt; +pub type U713 = UInt< + UInt, B0>, B1>, B1>, B0>, B0>, B1>, B0>, B0>, + B1, +>; +pub type P713 = PInt; +pub type N713 = NInt; +pub type U714 = UInt< + UInt, B0>, B1>, B1>, B0>, B0>, B1>, B0>, B1>, + B0, +>; +pub type P714 = PInt; +pub type N714 = NInt; +pub type U715 = UInt< + UInt, B0>, B1>, B1>, B0>, B0>, B1>, B0>, B1>, + B1, +>; +pub type P715 = PInt; +pub type N715 = NInt; +pub type U716 = UInt< + UInt, B0>, B1>, B1>, B0>, B0>, B1>, B1>, B0>, + B0, +>; +pub type P716 = PInt; +pub type N716 = NInt; +pub type U717 = UInt< + UInt, B0>, B1>, B1>, B0>, B0>, B1>, B1>, B0>, + B1, +>; +pub type P717 = PInt; +pub type N717 = NInt; +pub type U718 = UInt< + UInt, B0>, B1>, B1>, B0>, B0>, B1>, B1>, B1>, + B0, +>; +pub type P718 = PInt; +pub type N718 = NInt; +pub type U719 = UInt< + UInt, B0>, B1>, B1>, B0>, B0>, B1>, B1>, B1>, + B1, +>; +pub type P719 = PInt; +pub type N719 = NInt; +pub type U720 = UInt< + UInt, B0>, B1>, B1>, B0>, B1>, B0>, B0>, B0>, + B0, +>; +pub type P720 = PInt; +pub type N720 = NInt; +pub type U721 = UInt< + UInt, B0>, B1>, B1>, B0>, B1>, B0>, B0>, B0>, + B1, +>; +pub type P721 = PInt; +pub type N721 = NInt; +pub type U722 = UInt< + UInt, B0>, B1>, B1>, B0>, B1>, B0>, B0>, B1>, + B0, +>; +pub type P722 = PInt; +pub type N722 = NInt; +pub type U723 = UInt< + UInt, B0>, B1>, B1>, B0>, B1>, B0>, B0>, B1>, + B1, +>; +pub type P723 = PInt; +pub type N723 = NInt; +pub type U724 = UInt< + UInt, B0>, B1>, B1>, B0>, B1>, B0>, B1>, B0>, + B0, +>; +pub type P724 = PInt; +pub type N724 = NInt; +pub type U725 = UInt< + UInt, B0>, B1>, B1>, B0>, B1>, B0>, B1>, B0>, + B1, +>; +pub type P725 = PInt; +pub type N725 = NInt; +pub type U726 = UInt< + UInt, B0>, B1>, B1>, B0>, B1>, B0>, B1>, B1>, + B0, +>; +pub type P726 = PInt; +pub type N726 = NInt; +pub type U727 = UInt< + UInt, B0>, B1>, B1>, B0>, B1>, B0>, B1>, B1>, + B1, +>; +pub type P727 = PInt; +pub type N727 = NInt; +pub type U728 = UInt< + UInt, B0>, B1>, B1>, B0>, B1>, B1>, B0>, B0>, + B0, +>; +pub type P728 = PInt; +pub type N728 = NInt; +pub type U729 = UInt< + UInt, B0>, B1>, B1>, B0>, B1>, B1>, B0>, B0>, + B1, +>; +pub type P729 = PInt; +pub type N729 = NInt; +pub type U730 = UInt< + UInt, B0>, B1>, B1>, B0>, B1>, B1>, B0>, B1>, + B0, +>; +pub type P730 = PInt; +pub type N730 = NInt; +pub type U731 = UInt< + UInt, B0>, B1>, B1>, B0>, B1>, B1>, B0>, B1>, + B1, +>; +pub type P731 = PInt; +pub type N731 = NInt; +pub type U732 = UInt< + UInt, B0>, B1>, B1>, B0>, B1>, B1>, B1>, B0>, + B0, +>; +pub type P732 = PInt; +pub type N732 = NInt; +pub type U733 = UInt< + UInt, B0>, B1>, B1>, B0>, B1>, B1>, B1>, B0>, + B1, +>; +pub type P733 = PInt; +pub type N733 = NInt; +pub type U734 = UInt< + UInt, B0>, B1>, B1>, B0>, B1>, B1>, B1>, B1>, + B0, +>; +pub type P734 = PInt; +pub type N734 = NInt; +pub type U735 = UInt< + UInt, B0>, B1>, B1>, B0>, B1>, B1>, B1>, B1>, + B1, +>; +pub type P735 = PInt; +pub type N735 = NInt; +pub type U736 = UInt< + UInt, B0>, B1>, B1>, B1>, B0>, B0>, B0>, B0>, + B0, +>; +pub type P736 = PInt; +pub type N736 = NInt; +pub type U737 = UInt< + UInt, B0>, B1>, B1>, B1>, B0>, B0>, B0>, B0>, + B1, +>; +pub type P737 = PInt; +pub type N737 = NInt; +pub type U738 = UInt< + UInt, B0>, B1>, B1>, B1>, B0>, B0>, B0>, B1>, + B0, +>; +pub type P738 = PInt; +pub type N738 = NInt; +pub type U739 = UInt< + UInt, B0>, B1>, B1>, B1>, B0>, B0>, B0>, B1>, + B1, +>; +pub type P739 = PInt; +pub type N739 = NInt; +pub type U740 = UInt< + UInt, B0>, B1>, B1>, B1>, B0>, B0>, B1>, B0>, + B0, +>; +pub type P740 = PInt; +pub type N740 = NInt; +pub type U741 = UInt< + UInt, B0>, B1>, B1>, B1>, B0>, B0>, B1>, B0>, + B1, +>; +pub type P741 = PInt; +pub type N741 = NInt; +pub type U742 = UInt< + UInt, B0>, B1>, B1>, B1>, B0>, B0>, B1>, B1>, + B0, +>; +pub type P742 = PInt; +pub type N742 = NInt; +pub type U743 = UInt< + UInt, B0>, B1>, B1>, B1>, B0>, B0>, B1>, B1>, + B1, +>; +pub type P743 = PInt; +pub type N743 = NInt; +pub type U744 = UInt< + UInt, B0>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, + B0, +>; +pub type P744 = PInt; +pub type N744 = NInt; +pub type U745 = UInt< + UInt, B0>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, + B1, +>; +pub type P745 = PInt; +pub type N745 = NInt; +pub type U746 = UInt< + UInt, B0>, B1>, B1>, B1>, B0>, B1>, B0>, B1>, + B0, +>; +pub type P746 = PInt; +pub type N746 = NInt; +pub type U747 = UInt< + UInt, B0>, B1>, B1>, B1>, B0>, B1>, B0>, B1>, + B1, +>; +pub type P747 = PInt; +pub type N747 = NInt; +pub type U748 = UInt< + UInt, B0>, B1>, B1>, B1>, B0>, B1>, B1>, B0>, + B0, +>; +pub type P748 = PInt; +pub type N748 = NInt; +pub type U749 = UInt< + UInt, B0>, B1>, B1>, B1>, B0>, B1>, B1>, B0>, + B1, +>; +pub type P749 = PInt; +pub type N749 = NInt; +pub type U750 = UInt< + UInt, B0>, B1>, B1>, B1>, B0>, B1>, B1>, B1>, + B0, +>; +pub type P750 = PInt; +pub type N750 = NInt; +pub type U751 = UInt< + UInt, B0>, B1>, B1>, B1>, B0>, B1>, B1>, B1>, + B1, +>; +pub type P751 = PInt; +pub type N751 = NInt; +pub type U752 = UInt< + UInt, B0>, B1>, B1>, B1>, B1>, B0>, B0>, B0>, + B0, +>; +pub type P752 = PInt; +pub type N752 = NInt; +pub type U753 = UInt< + UInt, B0>, B1>, B1>, B1>, B1>, B0>, B0>, B0>, + B1, +>; +pub type P753 = PInt; +pub type N753 = NInt; +pub type U754 = UInt< + UInt, B0>, B1>, B1>, B1>, B1>, B0>, B0>, B1>, + B0, +>; +pub type P754 = PInt; +pub type N754 = NInt; +pub type U755 = UInt< + UInt, B0>, B1>, B1>, B1>, B1>, B0>, B0>, B1>, + B1, +>; +pub type P755 = PInt; +pub type N755 = NInt; +pub type U756 = UInt< + UInt, B0>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, + B0, +>; +pub type P756 = PInt; +pub type N756 = NInt; +pub type U757 = UInt< + UInt, B0>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, + B1, +>; +pub type P757 = PInt; +pub type N757 = NInt; +pub type U758 = UInt< + UInt, B0>, B1>, B1>, B1>, B1>, B0>, B1>, B1>, + B0, +>; +pub type P758 = PInt; +pub type N758 = NInt; +pub type U759 = UInt< + UInt, B0>, B1>, B1>, B1>, B1>, B0>, B1>, B1>, + B1, +>; +pub type P759 = PInt; +pub type N759 = NInt; +pub type U760 = UInt< + UInt, B0>, B1>, B1>, B1>, B1>, B1>, B0>, B0>, + B0, +>; +pub type P760 = PInt; +pub type N760 = NInt; +pub type U761 = UInt< + UInt, B0>, B1>, B1>, B1>, B1>, B1>, B0>, B0>, + B1, +>; +pub type P761 = PInt; +pub type N761 = NInt; +pub type U762 = UInt< + UInt, B0>, B1>, B1>, B1>, B1>, B1>, B0>, B1>, + B0, +>; +pub type P762 = PInt; +pub type N762 = NInt; +pub type U763 = UInt< + UInt, B0>, B1>, B1>, B1>, B1>, B1>, B0>, B1>, + B1, +>; +pub type P763 = PInt; +pub type N763 = NInt; +pub type U764 = UInt< + UInt, B0>, B1>, B1>, B1>, B1>, B1>, B1>, B0>, + B0, +>; +pub type P764 = PInt; +pub type N764 = NInt; +pub type U765 = UInt< + UInt, B0>, B1>, B1>, B1>, B1>, B1>, B1>, B0>, + B1, +>; +pub type P765 = PInt; +pub type N765 = NInt; +pub type U766 = UInt< + UInt, B0>, B1>, B1>, B1>, B1>, B1>, B1>, B1>, + B0, +>; +pub type P766 = PInt; +pub type N766 = NInt; +pub type U767 = UInt< + UInt, B0>, B1>, B1>, B1>, B1>, B1>, B1>, B1>, + B1, +>; +pub type P767 = PInt; +pub type N767 = NInt; +pub type U768 = UInt< + UInt, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, + B0, +>; +pub type P768 = PInt; +pub type N768 = NInt; +pub type U769 = UInt< + UInt, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, + B1, +>; +pub type P769 = PInt; +pub type N769 = NInt; +pub type U770 = UInt< + UInt, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B1>, + B0, +>; +pub type P770 = PInt; +pub type N770 = NInt; +pub type U771 = UInt< + UInt, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B1>, + B1, +>; +pub type P771 = PInt; +pub type N771 = NInt; +pub type U772 = UInt< + UInt, B1>, B0>, B0>, B0>, B0>, B0>, B1>, B0>, + B0, +>; +pub type P772 = PInt; +pub type N772 = NInt; +pub type U773 = UInt< + UInt, B1>, B0>, B0>, B0>, B0>, B0>, B1>, B0>, + B1, +>; +pub type P773 = PInt; +pub type N773 = NInt; +pub type U774 = UInt< + UInt, B1>, B0>, B0>, B0>, B0>, B0>, B1>, B1>, + B0, +>; +pub type P774 = PInt; +pub type N774 = NInt; +pub type U775 = UInt< + UInt, B1>, B0>, B0>, B0>, B0>, B0>, B1>, B1>, + B1, +>; +pub type P775 = PInt; +pub type N775 = NInt; +pub type U776 = UInt< + UInt, B1>, B0>, B0>, B0>, B0>, B1>, B0>, B0>, + B0, +>; +pub type P776 = PInt; +pub type N776 = NInt; +pub type U777 = UInt< + UInt, B1>, B0>, B0>, B0>, B0>, B1>, B0>, B0>, + B1, +>; +pub type P777 = PInt; +pub type N777 = NInt; +pub type U778 = UInt< + UInt, B1>, B0>, B0>, B0>, B0>, B1>, B0>, B1>, + B0, +>; +pub type P778 = PInt; +pub type N778 = NInt; +pub type U779 = UInt< + UInt, B1>, B0>, B0>, B0>, B0>, B1>, B0>, B1>, + B1, +>; +pub type P779 = PInt; +pub type N779 = NInt; +pub type U780 = UInt< + UInt, B1>, B0>, B0>, B0>, B0>, B1>, B1>, B0>, + B0, +>; +pub type P780 = PInt; +pub type N780 = NInt; +pub type U781 = UInt< + UInt, B1>, B0>, B0>, B0>, B0>, B1>, B1>, B0>, + B1, +>; +pub type P781 = PInt; +pub type N781 = NInt; +pub type U782 = UInt< + UInt, B1>, B0>, B0>, B0>, B0>, B1>, B1>, B1>, + B0, +>; +pub type P782 = PInt; +pub type N782 = NInt; +pub type U783 = UInt< + UInt, B1>, B0>, B0>, B0>, B0>, B1>, B1>, B1>, + B1, +>; +pub type P783 = PInt; +pub type N783 = NInt; +pub type U784 = UInt< + UInt, B1>, B0>, B0>, B0>, B1>, B0>, B0>, B0>, + B0, +>; +pub type P784 = PInt; +pub type N784 = NInt; +pub type U785 = UInt< + UInt, B1>, B0>, B0>, B0>, B1>, B0>, B0>, B0>, + B1, +>; +pub type P785 = PInt; +pub type N785 = NInt; +pub type U786 = UInt< + UInt, B1>, B0>, B0>, B0>, B1>, B0>, B0>, B1>, + B0, +>; +pub type P786 = PInt; +pub type N786 = NInt; +pub type U787 = UInt< + UInt, B1>, B0>, B0>, B0>, B1>, B0>, B0>, B1>, + B1, +>; +pub type P787 = PInt; +pub type N787 = NInt; +pub type U788 = UInt< + UInt, B1>, B0>, B0>, B0>, B1>, B0>, B1>, B0>, + B0, +>; +pub type P788 = PInt; +pub type N788 = NInt; +pub type U789 = UInt< + UInt, B1>, B0>, B0>, B0>, B1>, B0>, B1>, B0>, + B1, +>; +pub type P789 = PInt; +pub type N789 = NInt; +pub type U790 = UInt< + UInt, B1>, B0>, B0>, B0>, B1>, B0>, B1>, B1>, + B0, +>; +pub type P790 = PInt; +pub type N790 = NInt; +pub type U791 = UInt< + UInt, B1>, B0>, B0>, B0>, B1>, B0>, B1>, B1>, + B1, +>; +pub type P791 = PInt; +pub type N791 = NInt; +pub type U792 = UInt< + UInt, B1>, B0>, B0>, B0>, B1>, B1>, B0>, B0>, + B0, +>; +pub type P792 = PInt; +pub type N792 = NInt; +pub type U793 = UInt< + UInt, B1>, B0>, B0>, B0>, B1>, B1>, B0>, B0>, + B1, +>; +pub type P793 = PInt; +pub type N793 = NInt; +pub type U794 = UInt< + UInt, B1>, B0>, B0>, B0>, B1>, B1>, B0>, B1>, + B0, +>; +pub type P794 = PInt; +pub type N794 = NInt; +pub type U795 = UInt< + UInt, B1>, B0>, B0>, B0>, B1>, B1>, B0>, B1>, + B1, +>; +pub type P795 = PInt; +pub type N795 = NInt; +pub type U796 = UInt< + UInt, B1>, B0>, B0>, B0>, B1>, B1>, B1>, B0>, + B0, +>; +pub type P796 = PInt; +pub type N796 = NInt; +pub type U797 = UInt< + UInt, B1>, B0>, B0>, B0>, B1>, B1>, B1>, B0>, + B1, +>; +pub type P797 = PInt; +pub type N797 = NInt; +pub type U798 = UInt< + UInt, B1>, B0>, B0>, B0>, B1>, B1>, B1>, B1>, + B0, +>; +pub type P798 = PInt; +pub type N798 = NInt; +pub type U799 = UInt< + UInt, B1>, B0>, B0>, B0>, B1>, B1>, B1>, B1>, + B1, +>; +pub type P799 = PInt; +pub type N799 = NInt; +pub type U800 = UInt< + UInt, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0>, + B0, +>; +pub type P800 = PInt; +pub type N800 = NInt; +pub type U801 = UInt< + UInt, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0>, + B1, +>; +pub type P801 = PInt; +pub type N801 = NInt; +pub type U802 = UInt< + UInt, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B1>, + B0, +>; +pub type P802 = PInt; +pub type N802 = NInt; +pub type U803 = UInt< + UInt, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B1>, + B1, +>; +pub type P803 = PInt; +pub type N803 = NInt; +pub type U804 = UInt< + UInt, B1>, B0>, B0>, B1>, B0>, B0>, B1>, B0>, + B0, +>; +pub type P804 = PInt; +pub type N804 = NInt; +pub type U805 = UInt< + UInt, B1>, B0>, B0>, B1>, B0>, B0>, B1>, B0>, + B1, +>; +pub type P805 = PInt; +pub type N805 = NInt; +pub type U806 = UInt< + UInt, B1>, B0>, B0>, B1>, B0>, B0>, B1>, B1>, + B0, +>; +pub type P806 = PInt; +pub type N806 = NInt; +pub type U807 = UInt< + UInt, B1>, B0>, B0>, B1>, B0>, B0>, B1>, B1>, + B1, +>; +pub type P807 = PInt; +pub type N807 = NInt; +pub type U808 = UInt< + UInt, B1>, B0>, B0>, B1>, B0>, B1>, B0>, B0>, + B0, +>; +pub type P808 = PInt; +pub type N808 = NInt; +pub type U809 = UInt< + UInt, B1>, B0>, B0>, B1>, B0>, B1>, B0>, B0>, + B1, +>; +pub type P809 = PInt; +pub type N809 = NInt; +pub type U810 = UInt< + UInt, B1>, B0>, B0>, B1>, B0>, B1>, B0>, B1>, + B0, +>; +pub type P810 = PInt; +pub type N810 = NInt; +pub type U811 = UInt< + UInt, B1>, B0>, B0>, B1>, B0>, B1>, B0>, B1>, + B1, +>; +pub type P811 = PInt; +pub type N811 = NInt; +pub type U812 = UInt< + UInt, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B0>, + B0, +>; +pub type P812 = PInt; +pub type N812 = NInt; +pub type U813 = UInt< + UInt, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B0>, + B1, +>; +pub type P813 = PInt; +pub type N813 = NInt; +pub type U814 = UInt< + UInt, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B1>, + B0, +>; +pub type P814 = PInt; +pub type N814 = NInt; +pub type U815 = UInt< + UInt, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B1>, + B1, +>; +pub type P815 = PInt; +pub type N815 = NInt; +pub type U816 = UInt< + UInt, B1>, B0>, B0>, B1>, B1>, B0>, B0>, B0>, + B0, +>; +pub type P816 = PInt; +pub type N816 = NInt; +pub type U817 = UInt< + UInt, B1>, B0>, B0>, B1>, B1>, B0>, B0>, B0>, + B1, +>; +pub type P817 = PInt; +pub type N817 = NInt; +pub type U818 = UInt< + UInt, B1>, B0>, B0>, B1>, B1>, B0>, B0>, B1>, + B0, +>; +pub type P818 = PInt; +pub type N818 = NInt; +pub type U819 = UInt< + UInt, B1>, B0>, B0>, B1>, B1>, B0>, B0>, B1>, + B1, +>; +pub type P819 = PInt; +pub type N819 = NInt; +pub type U820 = UInt< + UInt, B1>, B0>, B0>, B1>, B1>, B0>, B1>, B0>, + B0, +>; +pub type P820 = PInt; +pub type N820 = NInt; +pub type U821 = UInt< + UInt, B1>, B0>, B0>, B1>, B1>, B0>, B1>, B0>, + B1, +>; +pub type P821 = PInt; +pub type N821 = NInt; +pub type U822 = UInt< + UInt, B1>, B0>, B0>, B1>, B1>, B0>, B1>, B1>, + B0, +>; +pub type P822 = PInt; +pub type N822 = NInt; +pub type U823 = UInt< + UInt, B1>, B0>, B0>, B1>, B1>, B0>, B1>, B1>, + B1, +>; +pub type P823 = PInt; +pub type N823 = NInt; +pub type U824 = UInt< + UInt, B1>, B0>, B0>, B1>, B1>, B1>, B0>, B0>, + B0, +>; +pub type P824 = PInt; +pub type N824 = NInt; +pub type U825 = UInt< + UInt, B1>, B0>, B0>, B1>, B1>, B1>, B0>, B0>, + B1, +>; +pub type P825 = PInt; +pub type N825 = NInt; +pub type U826 = UInt< + UInt, B1>, B0>, B0>, B1>, B1>, B1>, B0>, B1>, + B0, +>; +pub type P826 = PInt; +pub type N826 = NInt; +pub type U827 = UInt< + UInt, B1>, B0>, B0>, B1>, B1>, B1>, B0>, B1>, + B1, +>; +pub type P827 = PInt; +pub type N827 = NInt; +pub type U828 = UInt< + UInt, B1>, B0>, B0>, B1>, B1>, B1>, B1>, B0>, + B0, +>; +pub type P828 = PInt; +pub type N828 = NInt; +pub type U829 = UInt< + UInt, B1>, B0>, B0>, B1>, B1>, B1>, B1>, B0>, + B1, +>; +pub type P829 = PInt; +pub type N829 = NInt; +pub type U830 = UInt< + UInt, B1>, B0>, B0>, B1>, B1>, B1>, B1>, B1>, + B0, +>; +pub type P830 = PInt; +pub type N830 = NInt; +pub type U831 = UInt< + UInt, B1>, B0>, B0>, B1>, B1>, B1>, B1>, B1>, + B1, +>; +pub type P831 = PInt; +pub type N831 = NInt; +pub type U832 = UInt< + UInt, B1>, B0>, B1>, B0>, B0>, B0>, B0>, B0>, + B0, +>; +pub type P832 = PInt; +pub type N832 = NInt; +pub type U833 = UInt< + UInt, B1>, B0>, B1>, B0>, B0>, B0>, B0>, B0>, + B1, +>; +pub type P833 = PInt; +pub type N833 = NInt; +pub type U834 = UInt< + UInt, B1>, B0>, B1>, B0>, B0>, B0>, B0>, B1>, + B0, +>; +pub type P834 = PInt; +pub type N834 = NInt; +pub type U835 = UInt< + UInt, B1>, B0>, B1>, B0>, B0>, B0>, B0>, B1>, + B1, +>; +pub type P835 = PInt; +pub type N835 = NInt; +pub type U836 = UInt< + UInt, B1>, B0>, B1>, B0>, B0>, B0>, B1>, B0>, + B0, +>; +pub type P836 = PInt; +pub type N836 = NInt; +pub type U837 = UInt< + UInt, B1>, B0>, B1>, B0>, B0>, B0>, B1>, B0>, + B1, +>; +pub type P837 = PInt; +pub type N837 = NInt; +pub type U838 = UInt< + UInt, B1>, B0>, B1>, B0>, B0>, B0>, B1>, B1>, + B0, +>; +pub type P838 = PInt; +pub type N838 = NInt; +pub type U839 = UInt< + UInt, B1>, B0>, B1>, B0>, B0>, B0>, B1>, B1>, + B1, +>; +pub type P839 = PInt; +pub type N839 = NInt; +pub type U840 = UInt< + UInt, B1>, B0>, B1>, B0>, B0>, B1>, B0>, B0>, + B0, +>; +pub type P840 = PInt; +pub type N840 = NInt; +pub type U841 = UInt< + UInt, B1>, B0>, B1>, B0>, B0>, B1>, B0>, B0>, + B1, +>; +pub type P841 = PInt; +pub type N841 = NInt; +pub type U842 = UInt< + UInt, B1>, B0>, B1>, B0>, B0>, B1>, B0>, B1>, + B0, +>; +pub type P842 = PInt; +pub type N842 = NInt; +pub type U843 = UInt< + UInt, B1>, B0>, B1>, B0>, B0>, B1>, B0>, B1>, + B1, +>; +pub type P843 = PInt; +pub type N843 = NInt; +pub type U844 = UInt< + UInt, B1>, B0>, B1>, B0>, B0>, B1>, B1>, B0>, + B0, +>; +pub type P844 = PInt; +pub type N844 = NInt; +pub type U845 = UInt< + UInt, B1>, B0>, B1>, B0>, B0>, B1>, B1>, B0>, + B1, +>; +pub type P845 = PInt; +pub type N845 = NInt; +pub type U846 = UInt< + UInt, B1>, B0>, B1>, B0>, B0>, B1>, B1>, B1>, + B0, +>; +pub type P846 = PInt; +pub type N846 = NInt; +pub type U847 = UInt< + UInt, B1>, B0>, B1>, B0>, B0>, B1>, B1>, B1>, + B1, +>; +pub type P847 = PInt; +pub type N847 = NInt; +pub type U848 = UInt< + UInt, B1>, B0>, B1>, B0>, B1>, B0>, B0>, B0>, + B0, +>; +pub type P848 = PInt; +pub type N848 = NInt; +pub type U849 = UInt< + UInt, B1>, B0>, B1>, B0>, B1>, B0>, B0>, B0>, + B1, +>; +pub type P849 = PInt; +pub type N849 = NInt; +pub type U850 = UInt< + UInt, B1>, B0>, B1>, B0>, B1>, B0>, B0>, B1>, + B0, +>; +pub type P850 = PInt; +pub type N850 = NInt; +pub type U851 = UInt< + UInt, B1>, B0>, B1>, B0>, B1>, B0>, B0>, B1>, + B1, +>; +pub type P851 = PInt; +pub type N851 = NInt; +pub type U852 = UInt< + UInt, B1>, B0>, B1>, B0>, B1>, B0>, B1>, B0>, + B0, +>; +pub type P852 = PInt; +pub type N852 = NInt; +pub type U853 = UInt< + UInt, B1>, B0>, B1>, B0>, B1>, B0>, B1>, B0>, + B1, +>; +pub type P853 = PInt; +pub type N853 = NInt; +pub type U854 = UInt< + UInt, B1>, B0>, B1>, B0>, B1>, B0>, B1>, B1>, + B0, +>; +pub type P854 = PInt; +pub type N854 = NInt; +pub type U855 = UInt< + UInt, B1>, B0>, B1>, B0>, B1>, B0>, B1>, B1>, + B1, +>; +pub type P855 = PInt; +pub type N855 = NInt; +pub type U856 = UInt< + UInt, B1>, B0>, B1>, B0>, B1>, B1>, B0>, B0>, + B0, +>; +pub type P856 = PInt; +pub type N856 = NInt; +pub type U857 = UInt< + UInt, B1>, B0>, B1>, B0>, B1>, B1>, B0>, B0>, + B1, +>; +pub type P857 = PInt; +pub type N857 = NInt; +pub type U858 = UInt< + UInt, B1>, B0>, B1>, B0>, B1>, B1>, B0>, B1>, + B0, +>; +pub type P858 = PInt; +pub type N858 = NInt; +pub type U859 = UInt< + UInt, B1>, B0>, B1>, B0>, B1>, B1>, B0>, B1>, + B1, +>; +pub type P859 = PInt; +pub type N859 = NInt; +pub type U860 = UInt< + UInt, B1>, B0>, B1>, B0>, B1>, B1>, B1>, B0>, + B0, +>; +pub type P860 = PInt; +pub type N860 = NInt; +pub type U861 = UInt< + UInt, B1>, B0>, B1>, B0>, B1>, B1>, B1>, B0>, + B1, +>; +pub type P861 = PInt; +pub type N861 = NInt; +pub type U862 = UInt< + UInt, B1>, B0>, B1>, B0>, B1>, B1>, B1>, B1>, + B0, +>; +pub type P862 = PInt; +pub type N862 = NInt; +pub type U863 = UInt< + UInt, B1>, B0>, B1>, B0>, B1>, B1>, B1>, B1>, + B1, +>; +pub type P863 = PInt; +pub type N863 = NInt; +pub type U864 = UInt< + UInt, B1>, B0>, B1>, B1>, B0>, B0>, B0>, B0>, + B0, +>; +pub type P864 = PInt; +pub type N864 = NInt; +pub type U865 = UInt< + UInt, B1>, B0>, B1>, B1>, B0>, B0>, B0>, B0>, + B1, +>; +pub type P865 = PInt; +pub type N865 = NInt; +pub type U866 = UInt< + UInt, B1>, B0>, B1>, B1>, B0>, B0>, B0>, B1>, + B0, +>; +pub type P866 = PInt; +pub type N866 = NInt; +pub type U867 = UInt< + UInt, B1>, B0>, B1>, B1>, B0>, B0>, B0>, B1>, + B1, +>; +pub type P867 = PInt; +pub type N867 = NInt; +pub type U868 = UInt< + UInt, B1>, B0>, B1>, B1>, B0>, B0>, B1>, B0>, + B0, +>; +pub type P868 = PInt; +pub type N868 = NInt; +pub type U869 = UInt< + UInt, B1>, B0>, B1>, B1>, B0>, B0>, B1>, B0>, + B1, +>; +pub type P869 = PInt; +pub type N869 = NInt; +pub type U870 = UInt< + UInt, B1>, B0>, B1>, B1>, B0>, B0>, B1>, B1>, + B0, +>; +pub type P870 = PInt; +pub type N870 = NInt; +pub type U871 = UInt< + UInt, B1>, B0>, B1>, B1>, B0>, B0>, B1>, B1>, + B1, +>; +pub type P871 = PInt; +pub type N871 = NInt; +pub type U872 = UInt< + UInt, B1>, B0>, B1>, B1>, B0>, B1>, B0>, B0>, + B0, +>; +pub type P872 = PInt; +pub type N872 = NInt; +pub type U873 = UInt< + UInt, B1>, B0>, B1>, B1>, B0>, B1>, B0>, B0>, + B1, +>; +pub type P873 = PInt; +pub type N873 = NInt; +pub type U874 = UInt< + UInt, B1>, B0>, B1>, B1>, B0>, B1>, B0>, B1>, + B0, +>; +pub type P874 = PInt; +pub type N874 = NInt; +pub type U875 = UInt< + UInt, B1>, B0>, B1>, B1>, B0>, B1>, B0>, B1>, + B1, +>; +pub type P875 = PInt; +pub type N875 = NInt; +pub type U876 = UInt< + UInt, B1>, B0>, B1>, B1>, B0>, B1>, B1>, B0>, + B0, +>; +pub type P876 = PInt; +pub type N876 = NInt; +pub type U877 = UInt< + UInt, B1>, B0>, B1>, B1>, B0>, B1>, B1>, B0>, + B1, +>; +pub type P877 = PInt; +pub type N877 = NInt; +pub type U878 = UInt< + UInt, B1>, B0>, B1>, B1>, B0>, B1>, B1>, B1>, + B0, +>; +pub type P878 = PInt; +pub type N878 = NInt; +pub type U879 = UInt< + UInt, B1>, B0>, B1>, B1>, B0>, B1>, B1>, B1>, + B1, +>; +pub type P879 = PInt; +pub type N879 = NInt; +pub type U880 = UInt< + UInt, B1>, B0>, B1>, B1>, B1>, B0>, B0>, B0>, + B0, +>; +pub type P880 = PInt; +pub type N880 = NInt; +pub type U881 = UInt< + UInt, B1>, B0>, B1>, B1>, B1>, B0>, B0>, B0>, + B1, +>; +pub type P881 = PInt; +pub type N881 = NInt; +pub type U882 = UInt< + UInt, B1>, B0>, B1>, B1>, B1>, B0>, B0>, B1>, + B0, +>; +pub type P882 = PInt; +pub type N882 = NInt; +pub type U883 = UInt< + UInt, B1>, B0>, B1>, B1>, B1>, B0>, B0>, B1>, + B1, +>; +pub type P883 = PInt; +pub type N883 = NInt; +pub type U884 = UInt< + UInt, B1>, B0>, B1>, B1>, B1>, B0>, B1>, B0>, + B0, +>; +pub type P884 = PInt; +pub type N884 = NInt; +pub type U885 = UInt< + UInt, B1>, B0>, B1>, B1>, B1>, B0>, B1>, B0>, + B1, +>; +pub type P885 = PInt; +pub type N885 = NInt; +pub type U886 = UInt< + UInt, B1>, B0>, B1>, B1>, B1>, B0>, B1>, B1>, + B0, +>; +pub type P886 = PInt; +pub type N886 = NInt; +pub type U887 = UInt< + UInt, B1>, B0>, B1>, B1>, B1>, B0>, B1>, B1>, + B1, +>; +pub type P887 = PInt; +pub type N887 = NInt; +pub type U888 = UInt< + UInt, B1>, B0>, B1>, B1>, B1>, B1>, B0>, B0>, + B0, +>; +pub type P888 = PInt; +pub type N888 = NInt; +pub type U889 = UInt< + UInt, B1>, B0>, B1>, B1>, B1>, B1>, B0>, B0>, + B1, +>; +pub type P889 = PInt; +pub type N889 = NInt; +pub type U890 = UInt< + UInt, B1>, B0>, B1>, B1>, B1>, B1>, B0>, B1>, + B0, +>; +pub type P890 = PInt; +pub type N890 = NInt; +pub type U891 = UInt< + UInt, B1>, B0>, B1>, B1>, B1>, B1>, B0>, B1>, + B1, +>; +pub type P891 = PInt; +pub type N891 = NInt; +pub type U892 = UInt< + UInt, B1>, B0>, B1>, B1>, B1>, B1>, B1>, B0>, + B0, +>; +pub type P892 = PInt; +pub type N892 = NInt; +pub type U893 = UInt< + UInt, B1>, B0>, B1>, B1>, B1>, B1>, B1>, B0>, + B1, +>; +pub type P893 = PInt; +pub type N893 = NInt; +pub type U894 = UInt< + UInt, B1>, B0>, B1>, B1>, B1>, B1>, B1>, B1>, + B0, +>; +pub type P894 = PInt; +pub type N894 = NInt; +pub type U895 = UInt< + UInt, B1>, B0>, B1>, B1>, B1>, B1>, B1>, B1>, + B1, +>; +pub type P895 = PInt; +pub type N895 = NInt; +pub type U896 = UInt< + UInt, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, + B0, +>; +pub type P896 = PInt; +pub type N896 = NInt; +pub type U897 = UInt< + UInt, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, + B1, +>; +pub type P897 = PInt; +pub type N897 = NInt; +pub type U898 = UInt< + UInt, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B1>, + B0, +>; +pub type P898 = PInt; +pub type N898 = NInt; +pub type U899 = UInt< + UInt, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B1>, + B1, +>; +pub type P899 = PInt; +pub type N899 = NInt; +pub type U900 = UInt< + UInt, B1>, B1>, B0>, B0>, B0>, B0>, B1>, B0>, + B0, +>; +pub type P900 = PInt; +pub type N900 = NInt; +pub type U901 = UInt< + UInt, B1>, B1>, B0>, B0>, B0>, B0>, B1>, B0>, + B1, +>; +pub type P901 = PInt; +pub type N901 = NInt; +pub type U902 = UInt< + UInt, B1>, B1>, B0>, B0>, B0>, B0>, B1>, B1>, + B0, +>; +pub type P902 = PInt; +pub type N902 = NInt; +pub type U903 = UInt< + UInt, B1>, B1>, B0>, B0>, B0>, B0>, B1>, B1>, + B1, +>; +pub type P903 = PInt; +pub type N903 = NInt; +pub type U904 = UInt< + UInt, B1>, B1>, B0>, B0>, B0>, B1>, B0>, B0>, + B0, +>; +pub type P904 = PInt; +pub type N904 = NInt; +pub type U905 = UInt< + UInt, B1>, B1>, B0>, B0>, B0>, B1>, B0>, B0>, + B1, +>; +pub type P905 = PInt; +pub type N905 = NInt; +pub type U906 = UInt< + UInt, B1>, B1>, B0>, B0>, B0>, B1>, B0>, B1>, + B0, +>; +pub type P906 = PInt; +pub type N906 = NInt; +pub type U907 = UInt< + UInt, B1>, B1>, B0>, B0>, B0>, B1>, B0>, B1>, + B1, +>; +pub type P907 = PInt; +pub type N907 = NInt; +pub type U908 = UInt< + UInt, B1>, B1>, B0>, B0>, B0>, B1>, B1>, B0>, + B0, +>; +pub type P908 = PInt; +pub type N908 = NInt; +pub type U909 = UInt< + UInt, B1>, B1>, B0>, B0>, B0>, B1>, B1>, B0>, + B1, +>; +pub type P909 = PInt; +pub type N909 = NInt; +pub type U910 = UInt< + UInt, B1>, B1>, B0>, B0>, B0>, B1>, B1>, B1>, + B0, +>; +pub type P910 = PInt; +pub type N910 = NInt; +pub type U911 = UInt< + UInt, B1>, B1>, B0>, B0>, B0>, B1>, B1>, B1>, + B1, +>; +pub type P911 = PInt; +pub type N911 = NInt; +pub type U912 = UInt< + UInt, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, + B0, +>; +pub type P912 = PInt; +pub type N912 = NInt; +pub type U913 = UInt< + UInt, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, + B1, +>; +pub type P913 = PInt; +pub type N913 = NInt; +pub type U914 = UInt< + UInt, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B1>, + B0, +>; +pub type P914 = PInt; +pub type N914 = NInt; +pub type U915 = UInt< + UInt, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B1>, + B1, +>; +pub type P915 = PInt; +pub type N915 = NInt; +pub type U916 = UInt< + UInt, B1>, B1>, B0>, B0>, B1>, B0>, B1>, B0>, + B0, +>; +pub type P916 = PInt; +pub type N916 = NInt; +pub type U917 = UInt< + UInt, B1>, B1>, B0>, B0>, B1>, B0>, B1>, B0>, + B1, +>; +pub type P917 = PInt; +pub type N917 = NInt; +pub type U918 = UInt< + UInt, B1>, B1>, B0>, B0>, B1>, B0>, B1>, B1>, + B0, +>; +pub type P918 = PInt; +pub type N918 = NInt; +pub type U919 = UInt< + UInt, B1>, B1>, B0>, B0>, B1>, B0>, B1>, B1>, + B1, +>; +pub type P919 = PInt; +pub type N919 = NInt; +pub type U920 = UInt< + UInt, B1>, B1>, B0>, B0>, B1>, B1>, B0>, B0>, + B0, +>; +pub type P920 = PInt; +pub type N920 = NInt; +pub type U921 = UInt< + UInt, B1>, B1>, B0>, B0>, B1>, B1>, B0>, B0>, + B1, +>; +pub type P921 = PInt; +pub type N921 = NInt; +pub type U922 = UInt< + UInt, B1>, B1>, B0>, B0>, B1>, B1>, B0>, B1>, + B0, +>; +pub type P922 = PInt; +pub type N922 = NInt; +pub type U923 = UInt< + UInt, B1>, B1>, B0>, B0>, B1>, B1>, B0>, B1>, + B1, +>; +pub type P923 = PInt; +pub type N923 = NInt; +pub type U924 = UInt< + UInt, B1>, B1>, B0>, B0>, B1>, B1>, B1>, B0>, + B0, +>; +pub type P924 = PInt; +pub type N924 = NInt; +pub type U925 = UInt< + UInt, B1>, B1>, B0>, B0>, B1>, B1>, B1>, B0>, + B1, +>; +pub type P925 = PInt; +pub type N925 = NInt; +pub type U926 = UInt< + UInt, B1>, B1>, B0>, B0>, B1>, B1>, B1>, B1>, + B0, +>; +pub type P926 = PInt; +pub type N926 = NInt; +pub type U927 = UInt< + UInt, B1>, B1>, B0>, B0>, B1>, B1>, B1>, B1>, + B1, +>; +pub type P927 = PInt; +pub type N927 = NInt; +pub type U928 = UInt< + UInt, B1>, B1>, B0>, B1>, B0>, B0>, B0>, B0>, + B0, +>; +pub type P928 = PInt; +pub type N928 = NInt; +pub type U929 = UInt< + UInt, B1>, B1>, B0>, B1>, B0>, B0>, B0>, B0>, + B1, +>; +pub type P929 = PInt; +pub type N929 = NInt; +pub type U930 = UInt< + UInt, B1>, B1>, B0>, B1>, B0>, B0>, B0>, B1>, + B0, +>; +pub type P930 = PInt; +pub type N930 = NInt; +pub type U931 = UInt< + UInt, B1>, B1>, B0>, B1>, B0>, B0>, B0>, B1>, + B1, +>; +pub type P931 = PInt; +pub type N931 = NInt; +pub type U932 = UInt< + UInt, B1>, B1>, B0>, B1>, B0>, B0>, B1>, B0>, + B0, +>; +pub type P932 = PInt; +pub type N932 = NInt; +pub type U933 = UInt< + UInt, B1>, B1>, B0>, B1>, B0>, B0>, B1>, B0>, + B1, +>; +pub type P933 = PInt; +pub type N933 = NInt; +pub type U934 = UInt< + UInt, B1>, B1>, B0>, B1>, B0>, B0>, B1>, B1>, + B0, +>; +pub type P934 = PInt; +pub type N934 = NInt; +pub type U935 = UInt< + UInt, B1>, B1>, B0>, B1>, B0>, B0>, B1>, B1>, + B1, +>; +pub type P935 = PInt; +pub type N935 = NInt; +pub type U936 = UInt< + UInt, B1>, B1>, B0>, B1>, B0>, B1>, B0>, B0>, + B0, +>; +pub type P936 = PInt; +pub type N936 = NInt; +pub type U937 = UInt< + UInt, B1>, B1>, B0>, B1>, B0>, B1>, B0>, B0>, + B1, +>; +pub type P937 = PInt; +pub type N937 = NInt; +pub type U938 = UInt< + UInt, B1>, B1>, B0>, B1>, B0>, B1>, B0>, B1>, + B0, +>; +pub type P938 = PInt; +pub type N938 = NInt; +pub type U939 = UInt< + UInt, B1>, B1>, B0>, B1>, B0>, B1>, B0>, B1>, + B1, +>; +pub type P939 = PInt; +pub type N939 = NInt; +pub type U940 = UInt< + UInt, B1>, B1>, B0>, B1>, B0>, B1>, B1>, B0>, + B0, +>; +pub type P940 = PInt; +pub type N940 = NInt; +pub type U941 = UInt< + UInt, B1>, B1>, B0>, B1>, B0>, B1>, B1>, B0>, + B1, +>; +pub type P941 = PInt; +pub type N941 = NInt; +pub type U942 = UInt< + UInt, B1>, B1>, B0>, B1>, B0>, B1>, B1>, B1>, + B0, +>; +pub type P942 = PInt; +pub type N942 = NInt; +pub type U943 = UInt< + UInt, B1>, B1>, B0>, B1>, B0>, B1>, B1>, B1>, + B1, +>; +pub type P943 = PInt; +pub type N943 = NInt; +pub type U944 = UInt< + UInt, B1>, B1>, B0>, B1>, B1>, B0>, B0>, B0>, + B0, +>; +pub type P944 = PInt; +pub type N944 = NInt; +pub type U945 = UInt< + UInt, B1>, B1>, B0>, B1>, B1>, B0>, B0>, B0>, + B1, +>; +pub type P945 = PInt; +pub type N945 = NInt; +pub type U946 = UInt< + UInt, B1>, B1>, B0>, B1>, B1>, B0>, B0>, B1>, + B0, +>; +pub type P946 = PInt; +pub type N946 = NInt; +pub type U947 = UInt< + UInt, B1>, B1>, B0>, B1>, B1>, B0>, B0>, B1>, + B1, +>; +pub type P947 = PInt; +pub type N947 = NInt; +pub type U948 = UInt< + UInt, B1>, B1>, B0>, B1>, B1>, B0>, B1>, B0>, + B0, +>; +pub type P948 = PInt; +pub type N948 = NInt; +pub type U949 = UInt< + UInt, B1>, B1>, B0>, B1>, B1>, B0>, B1>, B0>, + B1, +>; +pub type P949 = PInt; +pub type N949 = NInt; +pub type U950 = UInt< + UInt, B1>, B1>, B0>, B1>, B1>, B0>, B1>, B1>, + B0, +>; +pub type P950 = PInt; +pub type N950 = NInt; +pub type U951 = UInt< + UInt, B1>, B1>, B0>, B1>, B1>, B0>, B1>, B1>, + B1, +>; +pub type P951 = PInt; +pub type N951 = NInt; +pub type U952 = UInt< + UInt, B1>, B1>, B0>, B1>, B1>, B1>, B0>, B0>, + B0, +>; +pub type P952 = PInt; +pub type N952 = NInt; +pub type U953 = UInt< + UInt, B1>, B1>, B0>, B1>, B1>, B1>, B0>, B0>, + B1, +>; +pub type P953 = PInt; +pub type N953 = NInt; +pub type U954 = UInt< + UInt, B1>, B1>, B0>, B1>, B1>, B1>, B0>, B1>, + B0, +>; +pub type P954 = PInt; +pub type N954 = NInt; +pub type U955 = UInt< + UInt, B1>, B1>, B0>, B1>, B1>, B1>, B0>, B1>, + B1, +>; +pub type P955 = PInt; +pub type N955 = NInt; +pub type U956 = UInt< + UInt, B1>, B1>, B0>, B1>, B1>, B1>, B1>, B0>, + B0, +>; +pub type P956 = PInt; +pub type N956 = NInt; +pub type U957 = UInt< + UInt, B1>, B1>, B0>, B1>, B1>, B1>, B1>, B0>, + B1, +>; +pub type P957 = PInt; +pub type N957 = NInt; +pub type U958 = UInt< + UInt, B1>, B1>, B0>, B1>, B1>, B1>, B1>, B1>, + B0, +>; +pub type P958 = PInt; +pub type N958 = NInt; +pub type U959 = UInt< + UInt, B1>, B1>, B0>, B1>, B1>, B1>, B1>, B1>, + B1, +>; +pub type P959 = PInt; +pub type N959 = NInt; +pub type U960 = UInt< + UInt, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B0>, + B0, +>; +pub type P960 = PInt; +pub type N960 = NInt; +pub type U961 = UInt< + UInt, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B0>, + B1, +>; +pub type P961 = PInt; +pub type N961 = NInt; +pub type U962 = UInt< + UInt, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B1>, + B0, +>; +pub type P962 = PInt; +pub type N962 = NInt; +pub type U963 = UInt< + UInt, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B1>, + B1, +>; +pub type P963 = PInt; +pub type N963 = NInt; +pub type U964 = UInt< + UInt, B1>, B1>, B1>, B0>, B0>, B0>, B1>, B0>, + B0, +>; +pub type P964 = PInt; +pub type N964 = NInt; +pub type U965 = UInt< + UInt, B1>, B1>, B1>, B0>, B0>, B0>, B1>, B0>, + B1, +>; +pub type P965 = PInt; +pub type N965 = NInt; +pub type U966 = UInt< + UInt, B1>, B1>, B1>, B0>, B0>, B0>, B1>, B1>, + B0, +>; +pub type P966 = PInt; +pub type N966 = NInt; +pub type U967 = UInt< + UInt, B1>, B1>, B1>, B0>, B0>, B0>, B1>, B1>, + B1, +>; +pub type P967 = PInt; +pub type N967 = NInt; +pub type U968 = UInt< + UInt, B1>, B1>, B1>, B0>, B0>, B1>, B0>, B0>, + B0, +>; +pub type P968 = PInt; +pub type N968 = NInt; +pub type U969 = UInt< + UInt, B1>, B1>, B1>, B0>, B0>, B1>, B0>, B0>, + B1, +>; +pub type P969 = PInt; +pub type N969 = NInt; +pub type U970 = UInt< + UInt, B1>, B1>, B1>, B0>, B0>, B1>, B0>, B1>, + B0, +>; +pub type P970 = PInt; +pub type N970 = NInt; +pub type U971 = UInt< + UInt, B1>, B1>, B1>, B0>, B0>, B1>, B0>, B1>, + B1, +>; +pub type P971 = PInt; +pub type N971 = NInt; +pub type U972 = UInt< + UInt, B1>, B1>, B1>, B0>, B0>, B1>, B1>, B0>, + B0, +>; +pub type P972 = PInt; +pub type N972 = NInt; +pub type U973 = UInt< + UInt, B1>, B1>, B1>, B0>, B0>, B1>, B1>, B0>, + B1, +>; +pub type P973 = PInt; +pub type N973 = NInt; +pub type U974 = UInt< + UInt, B1>, B1>, B1>, B0>, B0>, B1>, B1>, B1>, + B0, +>; +pub type P974 = PInt; +pub type N974 = NInt; +pub type U975 = UInt< + UInt, B1>, B1>, B1>, B0>, B0>, B1>, B1>, B1>, + B1, +>; +pub type P975 = PInt; +pub type N975 = NInt; +pub type U976 = UInt< + UInt, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B0>, + B0, +>; +pub type P976 = PInt; +pub type N976 = NInt; +pub type U977 = UInt< + UInt, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B0>, + B1, +>; +pub type P977 = PInt; +pub type N977 = NInt; +pub type U978 = UInt< + UInt, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B1>, + B0, +>; +pub type P978 = PInt; +pub type N978 = NInt; +pub type U979 = UInt< + UInt, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B1>, + B1, +>; +pub type P979 = PInt; +pub type N979 = NInt; +pub type U980 = UInt< + UInt, B1>, B1>, B1>, B0>, B1>, B0>, B1>, B0>, + B0, +>; +pub type P980 = PInt; +pub type N980 = NInt; +pub type U981 = UInt< + UInt, B1>, B1>, B1>, B0>, B1>, B0>, B1>, B0>, + B1, +>; +pub type P981 = PInt; +pub type N981 = NInt; +pub type U982 = UInt< + UInt, B1>, B1>, B1>, B0>, B1>, B0>, B1>, B1>, + B0, +>; +pub type P982 = PInt; +pub type N982 = NInt; +pub type U983 = UInt< + UInt, B1>, B1>, B1>, B0>, B1>, B0>, B1>, B1>, + B1, +>; +pub type P983 = PInt; +pub type N983 = NInt; +pub type U984 = UInt< + UInt, B1>, B1>, B1>, B0>, B1>, B1>, B0>, B0>, + B0, +>; +pub type P984 = PInt; +pub type N984 = NInt; +pub type U985 = UInt< + UInt, B1>, B1>, B1>, B0>, B1>, B1>, B0>, B0>, + B1, +>; +pub type P985 = PInt; +pub type N985 = NInt; +pub type U986 = UInt< + UInt, B1>, B1>, B1>, B0>, B1>, B1>, B0>, B1>, + B0, +>; +pub type P986 = PInt; +pub type N986 = NInt; +pub type U987 = UInt< + UInt, B1>, B1>, B1>, B0>, B1>, B1>, B0>, B1>, + B1, +>; +pub type P987 = PInt; +pub type N987 = NInt; +pub type U988 = UInt< + UInt, B1>, B1>, B1>, B0>, B1>, B1>, B1>, B0>, + B0, +>; +pub type P988 = PInt; +pub type N988 = NInt; +pub type U989 = UInt< + UInt, B1>, B1>, B1>, B0>, B1>, B1>, B1>, B0>, + B1, +>; +pub type P989 = PInt; +pub type N989 = NInt; +pub type U990 = UInt< + UInt, B1>, B1>, B1>, B0>, B1>, B1>, B1>, B1>, + B0, +>; +pub type P990 = PInt; +pub type N990 = NInt; +pub type U991 = UInt< + UInt, B1>, B1>, B1>, B0>, B1>, B1>, B1>, B1>, + B1, +>; +pub type P991 = PInt; +pub type N991 = NInt; +pub type U992 = UInt< + UInt, B1>, B1>, B1>, B1>, B0>, B0>, B0>, B0>, + B0, +>; +pub type P992 = PInt; +pub type N992 = NInt; +pub type U993 = UInt< + UInt, B1>, B1>, B1>, B1>, B0>, B0>, B0>, B0>, + B1, +>; +pub type P993 = PInt; +pub type N993 = NInt; +pub type U994 = UInt< + UInt, B1>, B1>, B1>, B1>, B0>, B0>, B0>, B1>, + B0, +>; +pub type P994 = PInt; +pub type N994 = NInt; +pub type U995 = UInt< + UInt, B1>, B1>, B1>, B1>, B0>, B0>, B0>, B1>, + B1, +>; +pub type P995 = PInt; +pub type N995 = NInt; +pub type U996 = UInt< + UInt, B1>, B1>, B1>, B1>, B0>, B0>, B1>, B0>, + B0, +>; +pub type P996 = PInt; +pub type N996 = NInt; +pub type U997 = UInt< + UInt, B1>, B1>, B1>, B1>, B0>, B0>, B1>, B0>, + B1, +>; +pub type P997 = PInt; +pub type N997 = NInt; +pub type U998 = UInt< + UInt, B1>, B1>, B1>, B1>, B0>, B0>, B1>, B1>, + B0, +>; +pub type P998 = PInt; +pub type N998 = NInt; +pub type U999 = UInt< + UInt, B1>, B1>, B1>, B1>, B0>, B0>, B1>, B1>, + B1, +>; +pub type P999 = PInt; +pub type N999 = NInt; +pub type U1000 = UInt< + UInt, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, + B0, +>; +pub type P1000 = PInt; +pub type N1000 = NInt; +pub type U1001 = UInt< + UInt, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, + B1, +>; +pub type P1001 = PInt; +pub type N1001 = NInt; +pub type U1002 = UInt< + UInt, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B1>, + B0, +>; +pub type P1002 = PInt; +pub type N1002 = NInt; +pub type U1003 = UInt< + UInt, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B1>, + B1, +>; +pub type P1003 = PInt; +pub type N1003 = NInt; +pub type U1004 = UInt< + UInt, B1>, B1>, B1>, B1>, B0>, B1>, B1>, B0>, + B0, +>; +pub type P1004 = PInt; +pub type N1004 = NInt; +pub type U1005 = UInt< + UInt, B1>, B1>, B1>, B1>, B0>, B1>, B1>, B0>, + B1, +>; +pub type P1005 = PInt; +pub type N1005 = NInt; +pub type U1006 = UInt< + UInt, B1>, B1>, B1>, B1>, B0>, B1>, B1>, B1>, + B0, +>; +pub type P1006 = PInt; +pub type N1006 = NInt; +pub type U1007 = UInt< + UInt, B1>, B1>, B1>, B1>, B0>, B1>, B1>, B1>, + B1, +>; +pub type P1007 = PInt; +pub type N1007 = NInt; +pub type U1008 = UInt< + UInt, B1>, B1>, B1>, B1>, B1>, B0>, B0>, B0>, + B0, +>; +pub type P1008 = PInt; +pub type N1008 = NInt; +pub type U1009 = UInt< + UInt, B1>, B1>, B1>, B1>, B1>, B0>, B0>, B0>, + B1, +>; +pub type P1009 = PInt; +pub type N1009 = NInt; +pub type U1010 = UInt< + UInt, B1>, B1>, B1>, B1>, B1>, B0>, B0>, B1>, + B0, +>; +pub type P1010 = PInt; +pub type N1010 = NInt; +pub type U1011 = UInt< + UInt, B1>, B1>, B1>, B1>, B1>, B0>, B0>, B1>, + B1, +>; +pub type P1011 = PInt; +pub type N1011 = NInt; +pub type U1012 = UInt< + UInt, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, + B0, +>; +pub type P1012 = PInt; +pub type N1012 = NInt; +pub type U1013 = UInt< + UInt, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, + B1, +>; +pub type P1013 = PInt; +pub type N1013 = NInt; +pub type U1014 = UInt< + UInt, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B1>, + B0, +>; +pub type P1014 = PInt; +pub type N1014 = NInt; +pub type U1015 = UInt< + UInt, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B1>, + B1, +>; +pub type P1015 = PInt; +pub type N1015 = NInt; +pub type U1016 = UInt< + UInt, B1>, B1>, B1>, B1>, B1>, B1>, B0>, B0>, + B0, +>; +pub type P1016 = PInt; +pub type N1016 = NInt; +pub type U1017 = UInt< + UInt, B1>, B1>, B1>, B1>, B1>, B1>, B0>, B0>, + B1, +>; +pub type P1017 = PInt; +pub type N1017 = NInt; +pub type U1018 = UInt< + UInt, B1>, B1>, B1>, B1>, B1>, B1>, B0>, B1>, + B0, +>; +pub type P1018 = PInt; +pub type N1018 = NInt; +pub type U1019 = UInt< + UInt, B1>, B1>, B1>, B1>, B1>, B1>, B0>, B1>, + B1, +>; +pub type P1019 = PInt; +pub type N1019 = NInt; +pub type U1020 = UInt< + UInt, B1>, B1>, B1>, B1>, B1>, B1>, B1>, B0>, + B0, +>; +pub type P1020 = PInt; +pub type N1020 = NInt; +pub type U1021 = UInt< + UInt, B1>, B1>, B1>, B1>, B1>, B1>, B1>, B0>, + B1, +>; +pub type P1021 = PInt; +pub type N1021 = NInt; +pub type U1022 = UInt< + UInt, B1>, B1>, B1>, B1>, B1>, B1>, B1>, B1>, + B0, +>; +pub type P1022 = PInt; +pub type N1022 = NInt; +pub type U1023 = UInt< + UInt, B1>, B1>, B1>, B1>, B1>, B1>, B1>, B1>, + B1, +>; +pub type P1023 = PInt; +pub type N1023 = NInt; +pub type U1024 = UInt< + UInt< + UInt< + UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, + B0, + >, + B0, + >, + B0, +>; +pub type P1024 = PInt; +pub type N1024 = NInt; +pub type U3600 = UInt< + UInt< + UInt< + UInt< + UInt< + UInt, B1>, B1>, B0>, B0>, B0>, B0>, + B1, + >, + B0, + >, + B0, + >, + B0, + >, + B0, +>; +pub type P3600 = PInt; +pub type N3600 = NInt; +pub type U2048 = UInt< + UInt< + UInt< + UInt< + UInt< + UInt, B0>, B0>, B0>, B0>, B0>, B0>, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, +>; +pub type P2048 = PInt; +pub type N2048 = NInt; +pub type U4096 = UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt, B0>, B0>, B0>, B0>, B0>, B0>, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, +>; +pub type P4096 = PInt; +pub type N4096 = NInt; +pub type U8192 = UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt, B0>, B0>, B0>, B0>, B0>, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, +>; +pub type P8192 = PInt; +pub type N8192 = NInt; +pub type U16384 = UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt, B0>, B0>, B0>, B0>, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, +>; +pub type P16384 = PInt; +pub type N16384 = NInt; +pub type U32768 = UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt, B0>, B0>, B0>, B0>, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, +>; +pub type P32768 = PInt; +pub type N32768 = NInt; +pub type U65536 = UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt, B0>, B0>, B0>, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, +>; +pub type P65536 = PInt; +pub type N65536 = NInt; +pub type U131072 = UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt, B0>, B0>, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, +>; +pub type P131072 = PInt; +pub type N131072 = NInt; +pub type U262144 = UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt, B0>, B0>, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, +>; +pub type P262144 = PInt; +pub type N262144 = NInt; +pub type U524288 = UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt, B0>, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, +>; +pub type P524288 = PInt; +pub type N524288 = NInt; +pub type U1048576 = UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, +>; +pub type P1048576 = PInt; +pub type N1048576 = NInt; +pub type U2097152 = UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, +>; +pub type P2097152 = PInt; +pub type N2097152 = NInt; +pub type U4194304 = UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UTerm, + B1, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, +>; +pub type P4194304 = PInt; +pub type N4194304 = NInt; +pub type U8388608 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P8388608 = PInt; +pub type N8388608 = NInt; +pub type U16777216 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P16777216 = PInt; +pub type N16777216 = NInt; +pub type U33554432 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P33554432 = PInt; +pub type N33554432 = NInt; +pub type U67108864 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P67108864 = PInt; +pub type N67108864 = NInt; +pub type U134217728 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P134217728 = PInt; +pub type N134217728 = NInt; +pub type U268435456 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P268435456 = PInt; +pub type N268435456 = NInt; +pub type U536870912 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P536870912 = PInt; +pub type N536870912 = NInt; +pub type U1073741824 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P1073741824 = PInt; +pub type N1073741824 = NInt; +pub type U2147483648 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P2147483648 = PInt; +pub type N2147483648 = NInt; +pub type U4294967296 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P4294967296 = PInt; +pub type N4294967296 = NInt; +pub type U8589934592 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P8589934592 = PInt; +pub type N8589934592 = NInt; +pub type U17179869184 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P17179869184 = PInt; +pub type N17179869184 = NInt; +pub type U34359738368 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P34359738368 = PInt; +pub type N34359738368 = NInt; +pub type U68719476736 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P68719476736 = PInt; +pub type N68719476736 = NInt; +pub type U137438953472 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P137438953472 = PInt; +pub type N137438953472 = NInt; +pub type U274877906944 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P274877906944 = PInt; +pub type N274877906944 = NInt; +pub type U549755813888 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P549755813888 = PInt; +pub type N549755813888 = NInt; +pub type U1099511627776 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P1099511627776 = PInt; +pub type N1099511627776 = NInt; +pub type U2199023255552 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P2199023255552 = PInt; +pub type N2199023255552 = NInt; +pub type U4398046511104 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P4398046511104 = PInt; +pub type N4398046511104 = NInt; +pub type U8796093022208 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P8796093022208 = PInt; +pub type N8796093022208 = NInt; +pub type U17592186044416 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P17592186044416 = PInt; +pub type N17592186044416 = NInt; +pub type U35184372088832 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P35184372088832 = PInt; +pub type N35184372088832 = NInt; +pub type U70368744177664 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P70368744177664 = PInt; +pub type N70368744177664 = NInt; +pub type U140737488355328 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P140737488355328 = PInt; +pub type N140737488355328 = NInt; +pub type U281474976710656 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P281474976710656 = PInt; +pub type N281474976710656 = NInt; +pub type U562949953421312 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P562949953421312 = PInt; +pub type N562949953421312 = NInt; +pub type U1125899906842624 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P1125899906842624 = PInt; +pub type N1125899906842624 = NInt; +pub type U2251799813685248 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P2251799813685248 = PInt; +pub type N2251799813685248 = NInt; +pub type U4503599627370496 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P4503599627370496 = PInt; +pub type N4503599627370496 = NInt; +pub type U9007199254740992 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P9007199254740992 = PInt; +pub type N9007199254740992 = NInt; +pub type U18014398509481984 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P18014398509481984 = PInt; +pub type N18014398509481984 = NInt; +pub type U36028797018963968 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P36028797018963968 = PInt; +pub type N36028797018963968 = NInt; +pub type U72057594037927936 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P72057594037927936 = PInt; +pub type N72057594037927936 = NInt; +pub type U144115188075855872 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P144115188075855872 = PInt; +pub type N144115188075855872 = NInt; +pub type U288230376151711744 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P288230376151711744 = PInt; +pub type N288230376151711744 = NInt; +pub type U576460752303423488 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P576460752303423488 = PInt; +pub type N576460752303423488 = NInt; +pub type U1152921504606846976 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P1152921504606846976 = PInt; +pub type N1152921504606846976 = NInt; +pub type U2305843009213693952 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P2305843009213693952 = PInt; +pub type N2305843009213693952 = NInt; +pub type U4611686018427387904 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P4611686018427387904 = PInt; +pub type N4611686018427387904 = NInt; +pub type U9223372036854775808 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type U10000 = UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt, B0>, B0>, B1>, B1>, B1>, + B0, + >, + B0, + >, + B0, + >, + B1, + >, + B0, + >, + B0, + >, + B0, + >, + B0, +>; +pub type P10000 = PInt; +pub type N10000 = NInt; +pub type U100000 = UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt, B1>, B0>, B0>, + B0, + >, + B0, + >, + B1, + >, + B1, + >, + B0, + >, + B1, + >, + B0, + >, + B1, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, +>; +pub type P100000 = PInt; +pub type N100000 = NInt; +pub type U1000000 = UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt< + UInt, B1>, + B1, + >, + B1, + >, + B0, + >, + B1, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B1, + >, + B0, + >, + B0, + >, + B1, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, + >, + B0, +>; +pub type P1000000 = PInt; +pub type N1000000 = NInt; +pub type U10000000 = UInt, B0>, B0>, B1>, B1>, B0>, B0>, B0>, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P10000000 = PInt; +pub type N10000000 = NInt; +pub type U100000000 = UInt, B0>, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B1>, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P100000000 = PInt; +pub type N100000000 = NInt; +pub type U1000000000 = UInt, B1>, B1>, B0>, B1>, B1>, B1>, B0>, B0>, B1>, B1>, B0>, B1>, B0>, B1>, B1>, B0>, B0>, B1>, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P1000000000 = PInt; +pub type N1000000000 = NInt; +pub type U10000000000 = UInt, B0>, B0>, B1>, B0>, B1>, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B1>, B0>, B1>, B1>, B1>, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P10000000000 = PInt; +pub type N10000000000 = NInt; +pub type U100000000000 = UInt, B0>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0>, B1>, B1>, B1>, B0>, B1>, B1>, B0>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P100000000000 = PInt; +pub type N100000000000 = NInt; +pub type U1000000000000 = UInt, B1>, B1>, B0>, B1>, B0>, B0>, B0>, B1>, B1>, B0>, B1>, B0>, B1>, B0>, B0>, B1>, B0>, B1>, B0>, B0>, B1>, B0>, B1>, B0>, B0>, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P1000000000000 = PInt; +pub type N1000000000000 = NInt; +pub type U10000000000000 = UInt, B0>, B0>, B1>, B0>, B0>, B0>, B1>, B1>, B0>, B0>, B0>, B0>, B1>, B0>, B0>, B1>, B1>, B1>, B0>, B0>, B1>, B1>, B1>, B0>, B0>, B1>, B0>, B1>, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P10000000000000 = PInt; +pub type N10000000000000 = NInt; +pub type U100000000000000 = UInt, B0>, B1>, B1>, B0>, B1>, B0>, B1>, B1>, B1>, B1>, B0>, B0>, B1>, B1>, B0>, B0>, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P100000000000000 = PInt; +pub type N100000000000000 = NInt; +pub type U1000000000000000 = UInt, B1>, B1>, B0>, B0>, B0>, B1>, B1>, B0>, B1>, B0>, B1>, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B1>, B0>, B0>, B1>, B0>, B0>, B1>, B1>, B0>, B0>, B0>, B1>, B1>, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P1000000000000000 = PInt; +pub type N1000000000000000 = NInt; +pub type U10000000000000000 = UInt, B0>, B0>, B0>, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B1>, B1>, B0>, B1>, B1>, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B1>, B1>, B0>, B1>, B1>, B1>, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P10000000000000000 = PInt; +pub type N10000000000000000 = NInt; +pub type U100000000000000000 = UInt, B0>, B1>, B1>, B0>, B0>, B0>, B1>, B1>, B0>, B1>, B0>, B0>, B0>, B1>, B0>, B1>, B0>, B1>, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B1>, B0>, B1>, B1>, B1>, B0>, B1>, B1>, B0>, B0>, B0>, B1>, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P100000000000000000 = PInt; +pub type N100000000000000000 = NInt; +pub type U1000000000000000000 = UInt, B1>, B0>, B1>, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B1>, B1>, B0>, B1>, B0>, B1>, B1>, B0>, B0>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B1>, B1>, B1>, B0>, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; +pub type P1000000000000000000 = PInt; +pub type N1000000000000000000 = NInt; +pub type U10000000000000000000 = UInt, B0>, B0>, B0>, B1>, B0>, B1>, B0>, B1>, B1>, B0>, B0>, B0>, B1>, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B1>, B0>, B0>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; diff --git a/collector/compile-benchmarks/typenum-1.18.0/src/gen/generic_const_mappings.rs b/collector/compile-benchmarks/typenum-1.18.0/src/gen/generic_const_mappings.rs new file mode 100644 index 000000000..99f4d8a2b --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.18.0/src/gen/generic_const_mappings.rs @@ -0,0 +1,4478 @@ +// THIS IS GENERATED CODE +//! Module with some `const`-generics-friendly definitions, to help bridge the gap +//! between those and `typenum` types. +//! +//! - It requires the `const-generics` crate feature to be enabled. +//! +//! The main type to use here is [`U`], although [`Const`] and [`ToUInt`] may be needed +//! in a generic context. + +use crate::*; + +/// The main mapping from a generic `const: usize` to a [`UInt`]: [`U`] is expected to work like [`UN`]. +/// +/// - It requires the `const-generics` crate feature to be enabled. +/// +/// [`U`]: `U` +/// [`UN`]: `U42` +/// +/// # Example +/// +/// ```rust +/// use typenum::*; +/// +/// assert_type_eq!(U<42>, U42); +/// ``` +/// +/// This can even be used in a generic `const N: usize` context, provided the +/// genericity is guarded by a `where` clause: +/// +/// ```rust +/// use typenum::*; +/// +/// struct MyStruct; +/// +/// trait MyTrait { type AssocType; } +/// +/// impl MyTrait +/// for MyStruct +/// where +/// Const : ToUInt, +/// { +/// type AssocType = U; +/// } +/// +/// assert_type_eq!( as MyTrait>::AssocType, U42); +/// ``` +pub type U = as ToUInt>::Output; + +/// Used to allow the usage of [`U`] in a generic context. +pub struct Const; + +/// Used to allow the usage of [`U`] in a generic context. +pub trait ToUInt { + /// The [`UN`][`crate::U42`] type corresponding to `Self = Const`. + type Output; +} + +impl ToUInt for Const<0> { + type Output = U0; +} + +impl ToUInt for Const<1> { + type Output = U1; +} + +impl ToUInt for Const<2> { + type Output = U2; +} + +impl ToUInt for Const<3> { + type Output = U3; +} + +impl ToUInt for Const<4> { + type Output = U4; +} + +impl ToUInt for Const<5> { + type Output = U5; +} + +impl ToUInt for Const<6> { + type Output = U6; +} + +impl ToUInt for Const<7> { + type Output = U7; +} + +impl ToUInt for Const<8> { + type Output = U8; +} + +impl ToUInt for Const<9> { + type Output = U9; +} + +impl ToUInt for Const<10> { + type Output = U10; +} + +impl ToUInt for Const<11> { + type Output = U11; +} + +impl ToUInt for Const<12> { + type Output = U12; +} + +impl ToUInt for Const<13> { + type Output = U13; +} + +impl ToUInt for Const<14> { + type Output = U14; +} + +impl ToUInt for Const<15> { + type Output = U15; +} + +impl ToUInt for Const<16> { + type Output = U16; +} + +impl ToUInt for Const<17> { + type Output = U17; +} + +impl ToUInt for Const<18> { + type Output = U18; +} + +impl ToUInt for Const<19> { + type Output = U19; +} + +impl ToUInt for Const<20> { + type Output = U20; +} + +impl ToUInt for Const<21> { + type Output = U21; +} + +impl ToUInt for Const<22> { + type Output = U22; +} + +impl ToUInt for Const<23> { + type Output = U23; +} + +impl ToUInt for Const<24> { + type Output = U24; +} + +impl ToUInt for Const<25> { + type Output = U25; +} + +impl ToUInt for Const<26> { + type Output = U26; +} + +impl ToUInt for Const<27> { + type Output = U27; +} + +impl ToUInt for Const<28> { + type Output = U28; +} + +impl ToUInt for Const<29> { + type Output = U29; +} + +impl ToUInt for Const<30> { + type Output = U30; +} + +impl ToUInt for Const<31> { + type Output = U31; +} + +impl ToUInt for Const<32> { + type Output = U32; +} + +impl ToUInt for Const<33> { + type Output = U33; +} + +impl ToUInt for Const<34> { + type Output = U34; +} + +impl ToUInt for Const<35> { + type Output = U35; +} + +impl ToUInt for Const<36> { + type Output = U36; +} + +impl ToUInt for Const<37> { + type Output = U37; +} + +impl ToUInt for Const<38> { + type Output = U38; +} + +impl ToUInt for Const<39> { + type Output = U39; +} + +impl ToUInt for Const<40> { + type Output = U40; +} + +impl ToUInt for Const<41> { + type Output = U41; +} + +impl ToUInt for Const<42> { + type Output = U42; +} + +impl ToUInt for Const<43> { + type Output = U43; +} + +impl ToUInt for Const<44> { + type Output = U44; +} + +impl ToUInt for Const<45> { + type Output = U45; +} + +impl ToUInt for Const<46> { + type Output = U46; +} + +impl ToUInt for Const<47> { + type Output = U47; +} + +impl ToUInt for Const<48> { + type Output = U48; +} + +impl ToUInt for Const<49> { + type Output = U49; +} + +impl ToUInt for Const<50> { + type Output = U50; +} + +impl ToUInt for Const<51> { + type Output = U51; +} + +impl ToUInt for Const<52> { + type Output = U52; +} + +impl ToUInt for Const<53> { + type Output = U53; +} + +impl ToUInt for Const<54> { + type Output = U54; +} + +impl ToUInt for Const<55> { + type Output = U55; +} + +impl ToUInt for Const<56> { + type Output = U56; +} + +impl ToUInt for Const<57> { + type Output = U57; +} + +impl ToUInt for Const<58> { + type Output = U58; +} + +impl ToUInt for Const<59> { + type Output = U59; +} + +impl ToUInt for Const<60> { + type Output = U60; +} + +impl ToUInt for Const<61> { + type Output = U61; +} + +impl ToUInt for Const<62> { + type Output = U62; +} + +impl ToUInt for Const<63> { + type Output = U63; +} + +impl ToUInt for Const<64> { + type Output = U64; +} + +impl ToUInt for Const<65> { + type Output = U65; +} + +impl ToUInt for Const<66> { + type Output = U66; +} + +impl ToUInt for Const<67> { + type Output = U67; +} + +impl ToUInt for Const<68> { + type Output = U68; +} + +impl ToUInt for Const<69> { + type Output = U69; +} + +impl ToUInt for Const<70> { + type Output = U70; +} + +impl ToUInt for Const<71> { + type Output = U71; +} + +impl ToUInt for Const<72> { + type Output = U72; +} + +impl ToUInt for Const<73> { + type Output = U73; +} + +impl ToUInt for Const<74> { + type Output = U74; +} + +impl ToUInt for Const<75> { + type Output = U75; +} + +impl ToUInt for Const<76> { + type Output = U76; +} + +impl ToUInt for Const<77> { + type Output = U77; +} + +impl ToUInt for Const<78> { + type Output = U78; +} + +impl ToUInt for Const<79> { + type Output = U79; +} + +impl ToUInt for Const<80> { + type Output = U80; +} + +impl ToUInt for Const<81> { + type Output = U81; +} + +impl ToUInt for Const<82> { + type Output = U82; +} + +impl ToUInt for Const<83> { + type Output = U83; +} + +impl ToUInt for Const<84> { + type Output = U84; +} + +impl ToUInt for Const<85> { + type Output = U85; +} + +impl ToUInt for Const<86> { + type Output = U86; +} + +impl ToUInt for Const<87> { + type Output = U87; +} + +impl ToUInt for Const<88> { + type Output = U88; +} + +impl ToUInt for Const<89> { + type Output = U89; +} + +impl ToUInt for Const<90> { + type Output = U90; +} + +impl ToUInt for Const<91> { + type Output = U91; +} + +impl ToUInt for Const<92> { + type Output = U92; +} + +impl ToUInt for Const<93> { + type Output = U93; +} + +impl ToUInt for Const<94> { + type Output = U94; +} + +impl ToUInt for Const<95> { + type Output = U95; +} + +impl ToUInt for Const<96> { + type Output = U96; +} + +impl ToUInt for Const<97> { + type Output = U97; +} + +impl ToUInt for Const<98> { + type Output = U98; +} + +impl ToUInt for Const<99> { + type Output = U99; +} + +impl ToUInt for Const<100> { + type Output = U100; +} + +impl ToUInt for Const<101> { + type Output = U101; +} + +impl ToUInt for Const<102> { + type Output = U102; +} + +impl ToUInt for Const<103> { + type Output = U103; +} + +impl ToUInt for Const<104> { + type Output = U104; +} + +impl ToUInt for Const<105> { + type Output = U105; +} + +impl ToUInt for Const<106> { + type Output = U106; +} + +impl ToUInt for Const<107> { + type Output = U107; +} + +impl ToUInt for Const<108> { + type Output = U108; +} + +impl ToUInt for Const<109> { + type Output = U109; +} + +impl ToUInt for Const<110> { + type Output = U110; +} + +impl ToUInt for Const<111> { + type Output = U111; +} + +impl ToUInt for Const<112> { + type Output = U112; +} + +impl ToUInt for Const<113> { + type Output = U113; +} + +impl ToUInt for Const<114> { + type Output = U114; +} + +impl ToUInt for Const<115> { + type Output = U115; +} + +impl ToUInt for Const<116> { + type Output = U116; +} + +impl ToUInt for Const<117> { + type Output = U117; +} + +impl ToUInt for Const<118> { + type Output = U118; +} + +impl ToUInt for Const<119> { + type Output = U119; +} + +impl ToUInt for Const<120> { + type Output = U120; +} + +impl ToUInt for Const<121> { + type Output = U121; +} + +impl ToUInt for Const<122> { + type Output = U122; +} + +impl ToUInt for Const<123> { + type Output = U123; +} + +impl ToUInt for Const<124> { + type Output = U124; +} + +impl ToUInt for Const<125> { + type Output = U125; +} + +impl ToUInt for Const<126> { + type Output = U126; +} + +impl ToUInt for Const<127> { + type Output = U127; +} + +impl ToUInt for Const<128> { + type Output = U128; +} + +impl ToUInt for Const<129> { + type Output = U129; +} + +impl ToUInt for Const<130> { + type Output = U130; +} + +impl ToUInt for Const<131> { + type Output = U131; +} + +impl ToUInt for Const<132> { + type Output = U132; +} + +impl ToUInt for Const<133> { + type Output = U133; +} + +impl ToUInt for Const<134> { + type Output = U134; +} + +impl ToUInt for Const<135> { + type Output = U135; +} + +impl ToUInt for Const<136> { + type Output = U136; +} + +impl ToUInt for Const<137> { + type Output = U137; +} + +impl ToUInt for Const<138> { + type Output = U138; +} + +impl ToUInt for Const<139> { + type Output = U139; +} + +impl ToUInt for Const<140> { + type Output = U140; +} + +impl ToUInt for Const<141> { + type Output = U141; +} + +impl ToUInt for Const<142> { + type Output = U142; +} + +impl ToUInt for Const<143> { + type Output = U143; +} + +impl ToUInt for Const<144> { + type Output = U144; +} + +impl ToUInt for Const<145> { + type Output = U145; +} + +impl ToUInt for Const<146> { + type Output = U146; +} + +impl ToUInt for Const<147> { + type Output = U147; +} + +impl ToUInt for Const<148> { + type Output = U148; +} + +impl ToUInt for Const<149> { + type Output = U149; +} + +impl ToUInt for Const<150> { + type Output = U150; +} + +impl ToUInt for Const<151> { + type Output = U151; +} + +impl ToUInt for Const<152> { + type Output = U152; +} + +impl ToUInt for Const<153> { + type Output = U153; +} + +impl ToUInt for Const<154> { + type Output = U154; +} + +impl ToUInt for Const<155> { + type Output = U155; +} + +impl ToUInt for Const<156> { + type Output = U156; +} + +impl ToUInt for Const<157> { + type Output = U157; +} + +impl ToUInt for Const<158> { + type Output = U158; +} + +impl ToUInt for Const<159> { + type Output = U159; +} + +impl ToUInt for Const<160> { + type Output = U160; +} + +impl ToUInt for Const<161> { + type Output = U161; +} + +impl ToUInt for Const<162> { + type Output = U162; +} + +impl ToUInt for Const<163> { + type Output = U163; +} + +impl ToUInt for Const<164> { + type Output = U164; +} + +impl ToUInt for Const<165> { + type Output = U165; +} + +impl ToUInt for Const<166> { + type Output = U166; +} + +impl ToUInt for Const<167> { + type Output = U167; +} + +impl ToUInt for Const<168> { + type Output = U168; +} + +impl ToUInt for Const<169> { + type Output = U169; +} + +impl ToUInt for Const<170> { + type Output = U170; +} + +impl ToUInt for Const<171> { + type Output = U171; +} + +impl ToUInt for Const<172> { + type Output = U172; +} + +impl ToUInt for Const<173> { + type Output = U173; +} + +impl ToUInt for Const<174> { + type Output = U174; +} + +impl ToUInt for Const<175> { + type Output = U175; +} + +impl ToUInt for Const<176> { + type Output = U176; +} + +impl ToUInt for Const<177> { + type Output = U177; +} + +impl ToUInt for Const<178> { + type Output = U178; +} + +impl ToUInt for Const<179> { + type Output = U179; +} + +impl ToUInt for Const<180> { + type Output = U180; +} + +impl ToUInt for Const<181> { + type Output = U181; +} + +impl ToUInt for Const<182> { + type Output = U182; +} + +impl ToUInt for Const<183> { + type Output = U183; +} + +impl ToUInt for Const<184> { + type Output = U184; +} + +impl ToUInt for Const<185> { + type Output = U185; +} + +impl ToUInt for Const<186> { + type Output = U186; +} + +impl ToUInt for Const<187> { + type Output = U187; +} + +impl ToUInt for Const<188> { + type Output = U188; +} + +impl ToUInt for Const<189> { + type Output = U189; +} + +impl ToUInt for Const<190> { + type Output = U190; +} + +impl ToUInt for Const<191> { + type Output = U191; +} + +impl ToUInt for Const<192> { + type Output = U192; +} + +impl ToUInt for Const<193> { + type Output = U193; +} + +impl ToUInt for Const<194> { + type Output = U194; +} + +impl ToUInt for Const<195> { + type Output = U195; +} + +impl ToUInt for Const<196> { + type Output = U196; +} + +impl ToUInt for Const<197> { + type Output = U197; +} + +impl ToUInt for Const<198> { + type Output = U198; +} + +impl ToUInt for Const<199> { + type Output = U199; +} + +impl ToUInt for Const<200> { + type Output = U200; +} + +impl ToUInt for Const<201> { + type Output = U201; +} + +impl ToUInt for Const<202> { + type Output = U202; +} + +impl ToUInt for Const<203> { + type Output = U203; +} + +impl ToUInt for Const<204> { + type Output = U204; +} + +impl ToUInt for Const<205> { + type Output = U205; +} + +impl ToUInt for Const<206> { + type Output = U206; +} + +impl ToUInt for Const<207> { + type Output = U207; +} + +impl ToUInt for Const<208> { + type Output = U208; +} + +impl ToUInt for Const<209> { + type Output = U209; +} + +impl ToUInt for Const<210> { + type Output = U210; +} + +impl ToUInt for Const<211> { + type Output = U211; +} + +impl ToUInt for Const<212> { + type Output = U212; +} + +impl ToUInt for Const<213> { + type Output = U213; +} + +impl ToUInt for Const<214> { + type Output = U214; +} + +impl ToUInt for Const<215> { + type Output = U215; +} + +impl ToUInt for Const<216> { + type Output = U216; +} + +impl ToUInt for Const<217> { + type Output = U217; +} + +impl ToUInt for Const<218> { + type Output = U218; +} + +impl ToUInt for Const<219> { + type Output = U219; +} + +impl ToUInt for Const<220> { + type Output = U220; +} + +impl ToUInt for Const<221> { + type Output = U221; +} + +impl ToUInt for Const<222> { + type Output = U222; +} + +impl ToUInt for Const<223> { + type Output = U223; +} + +impl ToUInt for Const<224> { + type Output = U224; +} + +impl ToUInt for Const<225> { + type Output = U225; +} + +impl ToUInt for Const<226> { + type Output = U226; +} + +impl ToUInt for Const<227> { + type Output = U227; +} + +impl ToUInt for Const<228> { + type Output = U228; +} + +impl ToUInt for Const<229> { + type Output = U229; +} + +impl ToUInt for Const<230> { + type Output = U230; +} + +impl ToUInt for Const<231> { + type Output = U231; +} + +impl ToUInt for Const<232> { + type Output = U232; +} + +impl ToUInt for Const<233> { + type Output = U233; +} + +impl ToUInt for Const<234> { + type Output = U234; +} + +impl ToUInt for Const<235> { + type Output = U235; +} + +impl ToUInt for Const<236> { + type Output = U236; +} + +impl ToUInt for Const<237> { + type Output = U237; +} + +impl ToUInt for Const<238> { + type Output = U238; +} + +impl ToUInt for Const<239> { + type Output = U239; +} + +impl ToUInt for Const<240> { + type Output = U240; +} + +impl ToUInt for Const<241> { + type Output = U241; +} + +impl ToUInt for Const<242> { + type Output = U242; +} + +impl ToUInt for Const<243> { + type Output = U243; +} + +impl ToUInt for Const<244> { + type Output = U244; +} + +impl ToUInt for Const<245> { + type Output = U245; +} + +impl ToUInt for Const<246> { + type Output = U246; +} + +impl ToUInt for Const<247> { + type Output = U247; +} + +impl ToUInt for Const<248> { + type Output = U248; +} + +impl ToUInt for Const<249> { + type Output = U249; +} + +impl ToUInt for Const<250> { + type Output = U250; +} + +impl ToUInt for Const<251> { + type Output = U251; +} + +impl ToUInt for Const<252> { + type Output = U252; +} + +impl ToUInt for Const<253> { + type Output = U253; +} + +impl ToUInt for Const<254> { + type Output = U254; +} + +impl ToUInt for Const<255> { + type Output = U255; +} + +impl ToUInt for Const<256> { + type Output = U256; +} + +impl ToUInt for Const<257> { + type Output = U257; +} + +impl ToUInt for Const<258> { + type Output = U258; +} + +impl ToUInt for Const<259> { + type Output = U259; +} + +impl ToUInt for Const<260> { + type Output = U260; +} + +impl ToUInt for Const<261> { + type Output = U261; +} + +impl ToUInt for Const<262> { + type Output = U262; +} + +impl ToUInt for Const<263> { + type Output = U263; +} + +impl ToUInt for Const<264> { + type Output = U264; +} + +impl ToUInt for Const<265> { + type Output = U265; +} + +impl ToUInt for Const<266> { + type Output = U266; +} + +impl ToUInt for Const<267> { + type Output = U267; +} + +impl ToUInt for Const<268> { + type Output = U268; +} + +impl ToUInt for Const<269> { + type Output = U269; +} + +impl ToUInt for Const<270> { + type Output = U270; +} + +impl ToUInt for Const<271> { + type Output = U271; +} + +impl ToUInt for Const<272> { + type Output = U272; +} + +impl ToUInt for Const<273> { + type Output = U273; +} + +impl ToUInt for Const<274> { + type Output = U274; +} + +impl ToUInt for Const<275> { + type Output = U275; +} + +impl ToUInt for Const<276> { + type Output = U276; +} + +impl ToUInt for Const<277> { + type Output = U277; +} + +impl ToUInt for Const<278> { + type Output = U278; +} + +impl ToUInt for Const<279> { + type Output = U279; +} + +impl ToUInt for Const<280> { + type Output = U280; +} + +impl ToUInt for Const<281> { + type Output = U281; +} + +impl ToUInt for Const<282> { + type Output = U282; +} + +impl ToUInt for Const<283> { + type Output = U283; +} + +impl ToUInt for Const<284> { + type Output = U284; +} + +impl ToUInt for Const<285> { + type Output = U285; +} + +impl ToUInt for Const<286> { + type Output = U286; +} + +impl ToUInt for Const<287> { + type Output = U287; +} + +impl ToUInt for Const<288> { + type Output = U288; +} + +impl ToUInt for Const<289> { + type Output = U289; +} + +impl ToUInt for Const<290> { + type Output = U290; +} + +impl ToUInt for Const<291> { + type Output = U291; +} + +impl ToUInt for Const<292> { + type Output = U292; +} + +impl ToUInt for Const<293> { + type Output = U293; +} + +impl ToUInt for Const<294> { + type Output = U294; +} + +impl ToUInt for Const<295> { + type Output = U295; +} + +impl ToUInt for Const<296> { + type Output = U296; +} + +impl ToUInt for Const<297> { + type Output = U297; +} + +impl ToUInt for Const<298> { + type Output = U298; +} + +impl ToUInt for Const<299> { + type Output = U299; +} + +impl ToUInt for Const<300> { + type Output = U300; +} + +impl ToUInt for Const<301> { + type Output = U301; +} + +impl ToUInt for Const<302> { + type Output = U302; +} + +impl ToUInt for Const<303> { + type Output = U303; +} + +impl ToUInt for Const<304> { + type Output = U304; +} + +impl ToUInt for Const<305> { + type Output = U305; +} + +impl ToUInt for Const<306> { + type Output = U306; +} + +impl ToUInt for Const<307> { + type Output = U307; +} + +impl ToUInt for Const<308> { + type Output = U308; +} + +impl ToUInt for Const<309> { + type Output = U309; +} + +impl ToUInt for Const<310> { + type Output = U310; +} + +impl ToUInt for Const<311> { + type Output = U311; +} + +impl ToUInt for Const<312> { + type Output = U312; +} + +impl ToUInt for Const<313> { + type Output = U313; +} + +impl ToUInt for Const<314> { + type Output = U314; +} + +impl ToUInt for Const<315> { + type Output = U315; +} + +impl ToUInt for Const<316> { + type Output = U316; +} + +impl ToUInt for Const<317> { + type Output = U317; +} + +impl ToUInt for Const<318> { + type Output = U318; +} + +impl ToUInt for Const<319> { + type Output = U319; +} + +impl ToUInt for Const<320> { + type Output = U320; +} + +impl ToUInt for Const<321> { + type Output = U321; +} + +impl ToUInt for Const<322> { + type Output = U322; +} + +impl ToUInt for Const<323> { + type Output = U323; +} + +impl ToUInt for Const<324> { + type Output = U324; +} + +impl ToUInt for Const<325> { + type Output = U325; +} + +impl ToUInt for Const<326> { + type Output = U326; +} + +impl ToUInt for Const<327> { + type Output = U327; +} + +impl ToUInt for Const<328> { + type Output = U328; +} + +impl ToUInt for Const<329> { + type Output = U329; +} + +impl ToUInt for Const<330> { + type Output = U330; +} + +impl ToUInt for Const<331> { + type Output = U331; +} + +impl ToUInt for Const<332> { + type Output = U332; +} + +impl ToUInt for Const<333> { + type Output = U333; +} + +impl ToUInt for Const<334> { + type Output = U334; +} + +impl ToUInt for Const<335> { + type Output = U335; +} + +impl ToUInt for Const<336> { + type Output = U336; +} + +impl ToUInt for Const<337> { + type Output = U337; +} + +impl ToUInt for Const<338> { + type Output = U338; +} + +impl ToUInt for Const<339> { + type Output = U339; +} + +impl ToUInt for Const<340> { + type Output = U340; +} + +impl ToUInt for Const<341> { + type Output = U341; +} + +impl ToUInt for Const<342> { + type Output = U342; +} + +impl ToUInt for Const<343> { + type Output = U343; +} + +impl ToUInt for Const<344> { + type Output = U344; +} + +impl ToUInt for Const<345> { + type Output = U345; +} + +impl ToUInt for Const<346> { + type Output = U346; +} + +impl ToUInt for Const<347> { + type Output = U347; +} + +impl ToUInt for Const<348> { + type Output = U348; +} + +impl ToUInt for Const<349> { + type Output = U349; +} + +impl ToUInt for Const<350> { + type Output = U350; +} + +impl ToUInt for Const<351> { + type Output = U351; +} + +impl ToUInt for Const<352> { + type Output = U352; +} + +impl ToUInt for Const<353> { + type Output = U353; +} + +impl ToUInt for Const<354> { + type Output = U354; +} + +impl ToUInt for Const<355> { + type Output = U355; +} + +impl ToUInt for Const<356> { + type Output = U356; +} + +impl ToUInt for Const<357> { + type Output = U357; +} + +impl ToUInt for Const<358> { + type Output = U358; +} + +impl ToUInt for Const<359> { + type Output = U359; +} + +impl ToUInt for Const<360> { + type Output = U360; +} + +impl ToUInt for Const<361> { + type Output = U361; +} + +impl ToUInt for Const<362> { + type Output = U362; +} + +impl ToUInt for Const<363> { + type Output = U363; +} + +impl ToUInt for Const<364> { + type Output = U364; +} + +impl ToUInt for Const<365> { + type Output = U365; +} + +impl ToUInt for Const<366> { + type Output = U366; +} + +impl ToUInt for Const<367> { + type Output = U367; +} + +impl ToUInt for Const<368> { + type Output = U368; +} + +impl ToUInt for Const<369> { + type Output = U369; +} + +impl ToUInt for Const<370> { + type Output = U370; +} + +impl ToUInt for Const<371> { + type Output = U371; +} + +impl ToUInt for Const<372> { + type Output = U372; +} + +impl ToUInt for Const<373> { + type Output = U373; +} + +impl ToUInt for Const<374> { + type Output = U374; +} + +impl ToUInt for Const<375> { + type Output = U375; +} + +impl ToUInt for Const<376> { + type Output = U376; +} + +impl ToUInt for Const<377> { + type Output = U377; +} + +impl ToUInt for Const<378> { + type Output = U378; +} + +impl ToUInt for Const<379> { + type Output = U379; +} + +impl ToUInt for Const<380> { + type Output = U380; +} + +impl ToUInt for Const<381> { + type Output = U381; +} + +impl ToUInt for Const<382> { + type Output = U382; +} + +impl ToUInt for Const<383> { + type Output = U383; +} + +impl ToUInt for Const<384> { + type Output = U384; +} + +impl ToUInt for Const<385> { + type Output = U385; +} + +impl ToUInt for Const<386> { + type Output = U386; +} + +impl ToUInt for Const<387> { + type Output = U387; +} + +impl ToUInt for Const<388> { + type Output = U388; +} + +impl ToUInt for Const<389> { + type Output = U389; +} + +impl ToUInt for Const<390> { + type Output = U390; +} + +impl ToUInt for Const<391> { + type Output = U391; +} + +impl ToUInt for Const<392> { + type Output = U392; +} + +impl ToUInt for Const<393> { + type Output = U393; +} + +impl ToUInt for Const<394> { + type Output = U394; +} + +impl ToUInt for Const<395> { + type Output = U395; +} + +impl ToUInt for Const<396> { + type Output = U396; +} + +impl ToUInt for Const<397> { + type Output = U397; +} + +impl ToUInt for Const<398> { + type Output = U398; +} + +impl ToUInt for Const<399> { + type Output = U399; +} + +impl ToUInt for Const<400> { + type Output = U400; +} + +impl ToUInt for Const<401> { + type Output = U401; +} + +impl ToUInt for Const<402> { + type Output = U402; +} + +impl ToUInt for Const<403> { + type Output = U403; +} + +impl ToUInt for Const<404> { + type Output = U404; +} + +impl ToUInt for Const<405> { + type Output = U405; +} + +impl ToUInt for Const<406> { + type Output = U406; +} + +impl ToUInt for Const<407> { + type Output = U407; +} + +impl ToUInt for Const<408> { + type Output = U408; +} + +impl ToUInt for Const<409> { + type Output = U409; +} + +impl ToUInt for Const<410> { + type Output = U410; +} + +impl ToUInt for Const<411> { + type Output = U411; +} + +impl ToUInt for Const<412> { + type Output = U412; +} + +impl ToUInt for Const<413> { + type Output = U413; +} + +impl ToUInt for Const<414> { + type Output = U414; +} + +impl ToUInt for Const<415> { + type Output = U415; +} + +impl ToUInt for Const<416> { + type Output = U416; +} + +impl ToUInt for Const<417> { + type Output = U417; +} + +impl ToUInt for Const<418> { + type Output = U418; +} + +impl ToUInt for Const<419> { + type Output = U419; +} + +impl ToUInt for Const<420> { + type Output = U420; +} + +impl ToUInt for Const<421> { + type Output = U421; +} + +impl ToUInt for Const<422> { + type Output = U422; +} + +impl ToUInt for Const<423> { + type Output = U423; +} + +impl ToUInt for Const<424> { + type Output = U424; +} + +impl ToUInt for Const<425> { + type Output = U425; +} + +impl ToUInt for Const<426> { + type Output = U426; +} + +impl ToUInt for Const<427> { + type Output = U427; +} + +impl ToUInt for Const<428> { + type Output = U428; +} + +impl ToUInt for Const<429> { + type Output = U429; +} + +impl ToUInt for Const<430> { + type Output = U430; +} + +impl ToUInt for Const<431> { + type Output = U431; +} + +impl ToUInt for Const<432> { + type Output = U432; +} + +impl ToUInt for Const<433> { + type Output = U433; +} + +impl ToUInt for Const<434> { + type Output = U434; +} + +impl ToUInt for Const<435> { + type Output = U435; +} + +impl ToUInt for Const<436> { + type Output = U436; +} + +impl ToUInt for Const<437> { + type Output = U437; +} + +impl ToUInt for Const<438> { + type Output = U438; +} + +impl ToUInt for Const<439> { + type Output = U439; +} + +impl ToUInt for Const<440> { + type Output = U440; +} + +impl ToUInt for Const<441> { + type Output = U441; +} + +impl ToUInt for Const<442> { + type Output = U442; +} + +impl ToUInt for Const<443> { + type Output = U443; +} + +impl ToUInt for Const<444> { + type Output = U444; +} + +impl ToUInt for Const<445> { + type Output = U445; +} + +impl ToUInt for Const<446> { + type Output = U446; +} + +impl ToUInt for Const<447> { + type Output = U447; +} + +impl ToUInt for Const<448> { + type Output = U448; +} + +impl ToUInt for Const<449> { + type Output = U449; +} + +impl ToUInt for Const<450> { + type Output = U450; +} + +impl ToUInt for Const<451> { + type Output = U451; +} + +impl ToUInt for Const<452> { + type Output = U452; +} + +impl ToUInt for Const<453> { + type Output = U453; +} + +impl ToUInt for Const<454> { + type Output = U454; +} + +impl ToUInt for Const<455> { + type Output = U455; +} + +impl ToUInt for Const<456> { + type Output = U456; +} + +impl ToUInt for Const<457> { + type Output = U457; +} + +impl ToUInt for Const<458> { + type Output = U458; +} + +impl ToUInt for Const<459> { + type Output = U459; +} + +impl ToUInt for Const<460> { + type Output = U460; +} + +impl ToUInt for Const<461> { + type Output = U461; +} + +impl ToUInt for Const<462> { + type Output = U462; +} + +impl ToUInt for Const<463> { + type Output = U463; +} + +impl ToUInt for Const<464> { + type Output = U464; +} + +impl ToUInt for Const<465> { + type Output = U465; +} + +impl ToUInt for Const<466> { + type Output = U466; +} + +impl ToUInt for Const<467> { + type Output = U467; +} + +impl ToUInt for Const<468> { + type Output = U468; +} + +impl ToUInt for Const<469> { + type Output = U469; +} + +impl ToUInt for Const<470> { + type Output = U470; +} + +impl ToUInt for Const<471> { + type Output = U471; +} + +impl ToUInt for Const<472> { + type Output = U472; +} + +impl ToUInt for Const<473> { + type Output = U473; +} + +impl ToUInt for Const<474> { + type Output = U474; +} + +impl ToUInt for Const<475> { + type Output = U475; +} + +impl ToUInt for Const<476> { + type Output = U476; +} + +impl ToUInt for Const<477> { + type Output = U477; +} + +impl ToUInt for Const<478> { + type Output = U478; +} + +impl ToUInt for Const<479> { + type Output = U479; +} + +impl ToUInt for Const<480> { + type Output = U480; +} + +impl ToUInt for Const<481> { + type Output = U481; +} + +impl ToUInt for Const<482> { + type Output = U482; +} + +impl ToUInt for Const<483> { + type Output = U483; +} + +impl ToUInt for Const<484> { + type Output = U484; +} + +impl ToUInt for Const<485> { + type Output = U485; +} + +impl ToUInt for Const<486> { + type Output = U486; +} + +impl ToUInt for Const<487> { + type Output = U487; +} + +impl ToUInt for Const<488> { + type Output = U488; +} + +impl ToUInt for Const<489> { + type Output = U489; +} + +impl ToUInt for Const<490> { + type Output = U490; +} + +impl ToUInt for Const<491> { + type Output = U491; +} + +impl ToUInt for Const<492> { + type Output = U492; +} + +impl ToUInt for Const<493> { + type Output = U493; +} + +impl ToUInt for Const<494> { + type Output = U494; +} + +impl ToUInt for Const<495> { + type Output = U495; +} + +impl ToUInt for Const<496> { + type Output = U496; +} + +impl ToUInt for Const<497> { + type Output = U497; +} + +impl ToUInt for Const<498> { + type Output = U498; +} + +impl ToUInt for Const<499> { + type Output = U499; +} + +impl ToUInt for Const<500> { + type Output = U500; +} + +impl ToUInt for Const<501> { + type Output = U501; +} + +impl ToUInt for Const<502> { + type Output = U502; +} + +impl ToUInt for Const<503> { + type Output = U503; +} + +impl ToUInt for Const<504> { + type Output = U504; +} + +impl ToUInt for Const<505> { + type Output = U505; +} + +impl ToUInt for Const<506> { + type Output = U506; +} + +impl ToUInt for Const<507> { + type Output = U507; +} + +impl ToUInt for Const<508> { + type Output = U508; +} + +impl ToUInt for Const<509> { + type Output = U509; +} + +impl ToUInt for Const<510> { + type Output = U510; +} + +impl ToUInt for Const<511> { + type Output = U511; +} + +impl ToUInt for Const<512> { + type Output = U512; +} + +impl ToUInt for Const<513> { + type Output = U513; +} + +impl ToUInt for Const<514> { + type Output = U514; +} + +impl ToUInt for Const<515> { + type Output = U515; +} + +impl ToUInt for Const<516> { + type Output = U516; +} + +impl ToUInt for Const<517> { + type Output = U517; +} + +impl ToUInt for Const<518> { + type Output = U518; +} + +impl ToUInt for Const<519> { + type Output = U519; +} + +impl ToUInt for Const<520> { + type Output = U520; +} + +impl ToUInt for Const<521> { + type Output = U521; +} + +impl ToUInt for Const<522> { + type Output = U522; +} + +impl ToUInt for Const<523> { + type Output = U523; +} + +impl ToUInt for Const<524> { + type Output = U524; +} + +impl ToUInt for Const<525> { + type Output = U525; +} + +impl ToUInt for Const<526> { + type Output = U526; +} + +impl ToUInt for Const<527> { + type Output = U527; +} + +impl ToUInt for Const<528> { + type Output = U528; +} + +impl ToUInt for Const<529> { + type Output = U529; +} + +impl ToUInt for Const<530> { + type Output = U530; +} + +impl ToUInt for Const<531> { + type Output = U531; +} + +impl ToUInt for Const<532> { + type Output = U532; +} + +impl ToUInt for Const<533> { + type Output = U533; +} + +impl ToUInt for Const<534> { + type Output = U534; +} + +impl ToUInt for Const<535> { + type Output = U535; +} + +impl ToUInt for Const<536> { + type Output = U536; +} + +impl ToUInt for Const<537> { + type Output = U537; +} + +impl ToUInt for Const<538> { + type Output = U538; +} + +impl ToUInt for Const<539> { + type Output = U539; +} + +impl ToUInt for Const<540> { + type Output = U540; +} + +impl ToUInt for Const<541> { + type Output = U541; +} + +impl ToUInt for Const<542> { + type Output = U542; +} + +impl ToUInt for Const<543> { + type Output = U543; +} + +impl ToUInt for Const<544> { + type Output = U544; +} + +impl ToUInt for Const<545> { + type Output = U545; +} + +impl ToUInt for Const<546> { + type Output = U546; +} + +impl ToUInt for Const<547> { + type Output = U547; +} + +impl ToUInt for Const<548> { + type Output = U548; +} + +impl ToUInt for Const<549> { + type Output = U549; +} + +impl ToUInt for Const<550> { + type Output = U550; +} + +impl ToUInt for Const<551> { + type Output = U551; +} + +impl ToUInt for Const<552> { + type Output = U552; +} + +impl ToUInt for Const<553> { + type Output = U553; +} + +impl ToUInt for Const<554> { + type Output = U554; +} + +impl ToUInt for Const<555> { + type Output = U555; +} + +impl ToUInt for Const<556> { + type Output = U556; +} + +impl ToUInt for Const<557> { + type Output = U557; +} + +impl ToUInt for Const<558> { + type Output = U558; +} + +impl ToUInt for Const<559> { + type Output = U559; +} + +impl ToUInt for Const<560> { + type Output = U560; +} + +impl ToUInt for Const<561> { + type Output = U561; +} + +impl ToUInt for Const<562> { + type Output = U562; +} + +impl ToUInt for Const<563> { + type Output = U563; +} + +impl ToUInt for Const<564> { + type Output = U564; +} + +impl ToUInt for Const<565> { + type Output = U565; +} + +impl ToUInt for Const<566> { + type Output = U566; +} + +impl ToUInt for Const<567> { + type Output = U567; +} + +impl ToUInt for Const<568> { + type Output = U568; +} + +impl ToUInt for Const<569> { + type Output = U569; +} + +impl ToUInt for Const<570> { + type Output = U570; +} + +impl ToUInt for Const<571> { + type Output = U571; +} + +impl ToUInt for Const<572> { + type Output = U572; +} + +impl ToUInt for Const<573> { + type Output = U573; +} + +impl ToUInt for Const<574> { + type Output = U574; +} + +impl ToUInt for Const<575> { + type Output = U575; +} + +impl ToUInt for Const<576> { + type Output = U576; +} + +impl ToUInt for Const<577> { + type Output = U577; +} + +impl ToUInt for Const<578> { + type Output = U578; +} + +impl ToUInt for Const<579> { + type Output = U579; +} + +impl ToUInt for Const<580> { + type Output = U580; +} + +impl ToUInt for Const<581> { + type Output = U581; +} + +impl ToUInt for Const<582> { + type Output = U582; +} + +impl ToUInt for Const<583> { + type Output = U583; +} + +impl ToUInt for Const<584> { + type Output = U584; +} + +impl ToUInt for Const<585> { + type Output = U585; +} + +impl ToUInt for Const<586> { + type Output = U586; +} + +impl ToUInt for Const<587> { + type Output = U587; +} + +impl ToUInt for Const<588> { + type Output = U588; +} + +impl ToUInt for Const<589> { + type Output = U589; +} + +impl ToUInt for Const<590> { + type Output = U590; +} + +impl ToUInt for Const<591> { + type Output = U591; +} + +impl ToUInt for Const<592> { + type Output = U592; +} + +impl ToUInt for Const<593> { + type Output = U593; +} + +impl ToUInt for Const<594> { + type Output = U594; +} + +impl ToUInt for Const<595> { + type Output = U595; +} + +impl ToUInt for Const<596> { + type Output = U596; +} + +impl ToUInt for Const<597> { + type Output = U597; +} + +impl ToUInt for Const<598> { + type Output = U598; +} + +impl ToUInt for Const<599> { + type Output = U599; +} + +impl ToUInt for Const<600> { + type Output = U600; +} + +impl ToUInt for Const<601> { + type Output = U601; +} + +impl ToUInt for Const<602> { + type Output = U602; +} + +impl ToUInt for Const<603> { + type Output = U603; +} + +impl ToUInt for Const<604> { + type Output = U604; +} + +impl ToUInt for Const<605> { + type Output = U605; +} + +impl ToUInt for Const<606> { + type Output = U606; +} + +impl ToUInt for Const<607> { + type Output = U607; +} + +impl ToUInt for Const<608> { + type Output = U608; +} + +impl ToUInt for Const<609> { + type Output = U609; +} + +impl ToUInt for Const<610> { + type Output = U610; +} + +impl ToUInt for Const<611> { + type Output = U611; +} + +impl ToUInt for Const<612> { + type Output = U612; +} + +impl ToUInt for Const<613> { + type Output = U613; +} + +impl ToUInt for Const<614> { + type Output = U614; +} + +impl ToUInt for Const<615> { + type Output = U615; +} + +impl ToUInt for Const<616> { + type Output = U616; +} + +impl ToUInt for Const<617> { + type Output = U617; +} + +impl ToUInt for Const<618> { + type Output = U618; +} + +impl ToUInt for Const<619> { + type Output = U619; +} + +impl ToUInt for Const<620> { + type Output = U620; +} + +impl ToUInt for Const<621> { + type Output = U621; +} + +impl ToUInt for Const<622> { + type Output = U622; +} + +impl ToUInt for Const<623> { + type Output = U623; +} + +impl ToUInt for Const<624> { + type Output = U624; +} + +impl ToUInt for Const<625> { + type Output = U625; +} + +impl ToUInt for Const<626> { + type Output = U626; +} + +impl ToUInt for Const<627> { + type Output = U627; +} + +impl ToUInt for Const<628> { + type Output = U628; +} + +impl ToUInt for Const<629> { + type Output = U629; +} + +impl ToUInt for Const<630> { + type Output = U630; +} + +impl ToUInt for Const<631> { + type Output = U631; +} + +impl ToUInt for Const<632> { + type Output = U632; +} + +impl ToUInt for Const<633> { + type Output = U633; +} + +impl ToUInt for Const<634> { + type Output = U634; +} + +impl ToUInt for Const<635> { + type Output = U635; +} + +impl ToUInt for Const<636> { + type Output = U636; +} + +impl ToUInt for Const<637> { + type Output = U637; +} + +impl ToUInt for Const<638> { + type Output = U638; +} + +impl ToUInt for Const<639> { + type Output = U639; +} + +impl ToUInt for Const<640> { + type Output = U640; +} + +impl ToUInt for Const<641> { + type Output = U641; +} + +impl ToUInt for Const<642> { + type Output = U642; +} + +impl ToUInt for Const<643> { + type Output = U643; +} + +impl ToUInt for Const<644> { + type Output = U644; +} + +impl ToUInt for Const<645> { + type Output = U645; +} + +impl ToUInt for Const<646> { + type Output = U646; +} + +impl ToUInt for Const<647> { + type Output = U647; +} + +impl ToUInt for Const<648> { + type Output = U648; +} + +impl ToUInt for Const<649> { + type Output = U649; +} + +impl ToUInt for Const<650> { + type Output = U650; +} + +impl ToUInt for Const<651> { + type Output = U651; +} + +impl ToUInt for Const<652> { + type Output = U652; +} + +impl ToUInt for Const<653> { + type Output = U653; +} + +impl ToUInt for Const<654> { + type Output = U654; +} + +impl ToUInt for Const<655> { + type Output = U655; +} + +impl ToUInt for Const<656> { + type Output = U656; +} + +impl ToUInt for Const<657> { + type Output = U657; +} + +impl ToUInt for Const<658> { + type Output = U658; +} + +impl ToUInt for Const<659> { + type Output = U659; +} + +impl ToUInt for Const<660> { + type Output = U660; +} + +impl ToUInt for Const<661> { + type Output = U661; +} + +impl ToUInt for Const<662> { + type Output = U662; +} + +impl ToUInt for Const<663> { + type Output = U663; +} + +impl ToUInt for Const<664> { + type Output = U664; +} + +impl ToUInt for Const<665> { + type Output = U665; +} + +impl ToUInt for Const<666> { + type Output = U666; +} + +impl ToUInt for Const<667> { + type Output = U667; +} + +impl ToUInt for Const<668> { + type Output = U668; +} + +impl ToUInt for Const<669> { + type Output = U669; +} + +impl ToUInt for Const<670> { + type Output = U670; +} + +impl ToUInt for Const<671> { + type Output = U671; +} + +impl ToUInt for Const<672> { + type Output = U672; +} + +impl ToUInt for Const<673> { + type Output = U673; +} + +impl ToUInt for Const<674> { + type Output = U674; +} + +impl ToUInt for Const<675> { + type Output = U675; +} + +impl ToUInt for Const<676> { + type Output = U676; +} + +impl ToUInt for Const<677> { + type Output = U677; +} + +impl ToUInt for Const<678> { + type Output = U678; +} + +impl ToUInt for Const<679> { + type Output = U679; +} + +impl ToUInt for Const<680> { + type Output = U680; +} + +impl ToUInt for Const<681> { + type Output = U681; +} + +impl ToUInt for Const<682> { + type Output = U682; +} + +impl ToUInt for Const<683> { + type Output = U683; +} + +impl ToUInt for Const<684> { + type Output = U684; +} + +impl ToUInt for Const<685> { + type Output = U685; +} + +impl ToUInt for Const<686> { + type Output = U686; +} + +impl ToUInt for Const<687> { + type Output = U687; +} + +impl ToUInt for Const<688> { + type Output = U688; +} + +impl ToUInt for Const<689> { + type Output = U689; +} + +impl ToUInt for Const<690> { + type Output = U690; +} + +impl ToUInt for Const<691> { + type Output = U691; +} + +impl ToUInt for Const<692> { + type Output = U692; +} + +impl ToUInt for Const<693> { + type Output = U693; +} + +impl ToUInt for Const<694> { + type Output = U694; +} + +impl ToUInt for Const<695> { + type Output = U695; +} + +impl ToUInt for Const<696> { + type Output = U696; +} + +impl ToUInt for Const<697> { + type Output = U697; +} + +impl ToUInt for Const<698> { + type Output = U698; +} + +impl ToUInt for Const<699> { + type Output = U699; +} + +impl ToUInt for Const<700> { + type Output = U700; +} + +impl ToUInt for Const<701> { + type Output = U701; +} + +impl ToUInt for Const<702> { + type Output = U702; +} + +impl ToUInt for Const<703> { + type Output = U703; +} + +impl ToUInt for Const<704> { + type Output = U704; +} + +impl ToUInt for Const<705> { + type Output = U705; +} + +impl ToUInt for Const<706> { + type Output = U706; +} + +impl ToUInt for Const<707> { + type Output = U707; +} + +impl ToUInt for Const<708> { + type Output = U708; +} + +impl ToUInt for Const<709> { + type Output = U709; +} + +impl ToUInt for Const<710> { + type Output = U710; +} + +impl ToUInt for Const<711> { + type Output = U711; +} + +impl ToUInt for Const<712> { + type Output = U712; +} + +impl ToUInt for Const<713> { + type Output = U713; +} + +impl ToUInt for Const<714> { + type Output = U714; +} + +impl ToUInt for Const<715> { + type Output = U715; +} + +impl ToUInt for Const<716> { + type Output = U716; +} + +impl ToUInt for Const<717> { + type Output = U717; +} + +impl ToUInt for Const<718> { + type Output = U718; +} + +impl ToUInt for Const<719> { + type Output = U719; +} + +impl ToUInt for Const<720> { + type Output = U720; +} + +impl ToUInt for Const<721> { + type Output = U721; +} + +impl ToUInt for Const<722> { + type Output = U722; +} + +impl ToUInt for Const<723> { + type Output = U723; +} + +impl ToUInt for Const<724> { + type Output = U724; +} + +impl ToUInt for Const<725> { + type Output = U725; +} + +impl ToUInt for Const<726> { + type Output = U726; +} + +impl ToUInt for Const<727> { + type Output = U727; +} + +impl ToUInt for Const<728> { + type Output = U728; +} + +impl ToUInt for Const<729> { + type Output = U729; +} + +impl ToUInt for Const<730> { + type Output = U730; +} + +impl ToUInt for Const<731> { + type Output = U731; +} + +impl ToUInt for Const<732> { + type Output = U732; +} + +impl ToUInt for Const<733> { + type Output = U733; +} + +impl ToUInt for Const<734> { + type Output = U734; +} + +impl ToUInt for Const<735> { + type Output = U735; +} + +impl ToUInt for Const<736> { + type Output = U736; +} + +impl ToUInt for Const<737> { + type Output = U737; +} + +impl ToUInt for Const<738> { + type Output = U738; +} + +impl ToUInt for Const<739> { + type Output = U739; +} + +impl ToUInt for Const<740> { + type Output = U740; +} + +impl ToUInt for Const<741> { + type Output = U741; +} + +impl ToUInt for Const<742> { + type Output = U742; +} + +impl ToUInt for Const<743> { + type Output = U743; +} + +impl ToUInt for Const<744> { + type Output = U744; +} + +impl ToUInt for Const<745> { + type Output = U745; +} + +impl ToUInt for Const<746> { + type Output = U746; +} + +impl ToUInt for Const<747> { + type Output = U747; +} + +impl ToUInt for Const<748> { + type Output = U748; +} + +impl ToUInt for Const<749> { + type Output = U749; +} + +impl ToUInt for Const<750> { + type Output = U750; +} + +impl ToUInt for Const<751> { + type Output = U751; +} + +impl ToUInt for Const<752> { + type Output = U752; +} + +impl ToUInt for Const<753> { + type Output = U753; +} + +impl ToUInt for Const<754> { + type Output = U754; +} + +impl ToUInt for Const<755> { + type Output = U755; +} + +impl ToUInt for Const<756> { + type Output = U756; +} + +impl ToUInt for Const<757> { + type Output = U757; +} + +impl ToUInt for Const<758> { + type Output = U758; +} + +impl ToUInt for Const<759> { + type Output = U759; +} + +impl ToUInt for Const<760> { + type Output = U760; +} + +impl ToUInt for Const<761> { + type Output = U761; +} + +impl ToUInt for Const<762> { + type Output = U762; +} + +impl ToUInt for Const<763> { + type Output = U763; +} + +impl ToUInt for Const<764> { + type Output = U764; +} + +impl ToUInt for Const<765> { + type Output = U765; +} + +impl ToUInt for Const<766> { + type Output = U766; +} + +impl ToUInt for Const<767> { + type Output = U767; +} + +impl ToUInt for Const<768> { + type Output = U768; +} + +impl ToUInt for Const<769> { + type Output = U769; +} + +impl ToUInt for Const<770> { + type Output = U770; +} + +impl ToUInt for Const<771> { + type Output = U771; +} + +impl ToUInt for Const<772> { + type Output = U772; +} + +impl ToUInt for Const<773> { + type Output = U773; +} + +impl ToUInt for Const<774> { + type Output = U774; +} + +impl ToUInt for Const<775> { + type Output = U775; +} + +impl ToUInt for Const<776> { + type Output = U776; +} + +impl ToUInt for Const<777> { + type Output = U777; +} + +impl ToUInt for Const<778> { + type Output = U778; +} + +impl ToUInt for Const<779> { + type Output = U779; +} + +impl ToUInt for Const<780> { + type Output = U780; +} + +impl ToUInt for Const<781> { + type Output = U781; +} + +impl ToUInt for Const<782> { + type Output = U782; +} + +impl ToUInt for Const<783> { + type Output = U783; +} + +impl ToUInt for Const<784> { + type Output = U784; +} + +impl ToUInt for Const<785> { + type Output = U785; +} + +impl ToUInt for Const<786> { + type Output = U786; +} + +impl ToUInt for Const<787> { + type Output = U787; +} + +impl ToUInt for Const<788> { + type Output = U788; +} + +impl ToUInt for Const<789> { + type Output = U789; +} + +impl ToUInt for Const<790> { + type Output = U790; +} + +impl ToUInt for Const<791> { + type Output = U791; +} + +impl ToUInt for Const<792> { + type Output = U792; +} + +impl ToUInt for Const<793> { + type Output = U793; +} + +impl ToUInt for Const<794> { + type Output = U794; +} + +impl ToUInt for Const<795> { + type Output = U795; +} + +impl ToUInt for Const<796> { + type Output = U796; +} + +impl ToUInt for Const<797> { + type Output = U797; +} + +impl ToUInt for Const<798> { + type Output = U798; +} + +impl ToUInt for Const<799> { + type Output = U799; +} + +impl ToUInt for Const<800> { + type Output = U800; +} + +impl ToUInt for Const<801> { + type Output = U801; +} + +impl ToUInt for Const<802> { + type Output = U802; +} + +impl ToUInt for Const<803> { + type Output = U803; +} + +impl ToUInt for Const<804> { + type Output = U804; +} + +impl ToUInt for Const<805> { + type Output = U805; +} + +impl ToUInt for Const<806> { + type Output = U806; +} + +impl ToUInt for Const<807> { + type Output = U807; +} + +impl ToUInt for Const<808> { + type Output = U808; +} + +impl ToUInt for Const<809> { + type Output = U809; +} + +impl ToUInt for Const<810> { + type Output = U810; +} + +impl ToUInt for Const<811> { + type Output = U811; +} + +impl ToUInt for Const<812> { + type Output = U812; +} + +impl ToUInt for Const<813> { + type Output = U813; +} + +impl ToUInt for Const<814> { + type Output = U814; +} + +impl ToUInt for Const<815> { + type Output = U815; +} + +impl ToUInt for Const<816> { + type Output = U816; +} + +impl ToUInt for Const<817> { + type Output = U817; +} + +impl ToUInt for Const<818> { + type Output = U818; +} + +impl ToUInt for Const<819> { + type Output = U819; +} + +impl ToUInt for Const<820> { + type Output = U820; +} + +impl ToUInt for Const<821> { + type Output = U821; +} + +impl ToUInt for Const<822> { + type Output = U822; +} + +impl ToUInt for Const<823> { + type Output = U823; +} + +impl ToUInt for Const<824> { + type Output = U824; +} + +impl ToUInt for Const<825> { + type Output = U825; +} + +impl ToUInt for Const<826> { + type Output = U826; +} + +impl ToUInt for Const<827> { + type Output = U827; +} + +impl ToUInt for Const<828> { + type Output = U828; +} + +impl ToUInt for Const<829> { + type Output = U829; +} + +impl ToUInt for Const<830> { + type Output = U830; +} + +impl ToUInt for Const<831> { + type Output = U831; +} + +impl ToUInt for Const<832> { + type Output = U832; +} + +impl ToUInt for Const<833> { + type Output = U833; +} + +impl ToUInt for Const<834> { + type Output = U834; +} + +impl ToUInt for Const<835> { + type Output = U835; +} + +impl ToUInt for Const<836> { + type Output = U836; +} + +impl ToUInt for Const<837> { + type Output = U837; +} + +impl ToUInt for Const<838> { + type Output = U838; +} + +impl ToUInt for Const<839> { + type Output = U839; +} + +impl ToUInt for Const<840> { + type Output = U840; +} + +impl ToUInt for Const<841> { + type Output = U841; +} + +impl ToUInt for Const<842> { + type Output = U842; +} + +impl ToUInt for Const<843> { + type Output = U843; +} + +impl ToUInt for Const<844> { + type Output = U844; +} + +impl ToUInt for Const<845> { + type Output = U845; +} + +impl ToUInt for Const<846> { + type Output = U846; +} + +impl ToUInt for Const<847> { + type Output = U847; +} + +impl ToUInt for Const<848> { + type Output = U848; +} + +impl ToUInt for Const<849> { + type Output = U849; +} + +impl ToUInt for Const<850> { + type Output = U850; +} + +impl ToUInt for Const<851> { + type Output = U851; +} + +impl ToUInt for Const<852> { + type Output = U852; +} + +impl ToUInt for Const<853> { + type Output = U853; +} + +impl ToUInt for Const<854> { + type Output = U854; +} + +impl ToUInt for Const<855> { + type Output = U855; +} + +impl ToUInt for Const<856> { + type Output = U856; +} + +impl ToUInt for Const<857> { + type Output = U857; +} + +impl ToUInt for Const<858> { + type Output = U858; +} + +impl ToUInt for Const<859> { + type Output = U859; +} + +impl ToUInt for Const<860> { + type Output = U860; +} + +impl ToUInt for Const<861> { + type Output = U861; +} + +impl ToUInt for Const<862> { + type Output = U862; +} + +impl ToUInt for Const<863> { + type Output = U863; +} + +impl ToUInt for Const<864> { + type Output = U864; +} + +impl ToUInt for Const<865> { + type Output = U865; +} + +impl ToUInt for Const<866> { + type Output = U866; +} + +impl ToUInt for Const<867> { + type Output = U867; +} + +impl ToUInt for Const<868> { + type Output = U868; +} + +impl ToUInt for Const<869> { + type Output = U869; +} + +impl ToUInt for Const<870> { + type Output = U870; +} + +impl ToUInt for Const<871> { + type Output = U871; +} + +impl ToUInt for Const<872> { + type Output = U872; +} + +impl ToUInt for Const<873> { + type Output = U873; +} + +impl ToUInt for Const<874> { + type Output = U874; +} + +impl ToUInt for Const<875> { + type Output = U875; +} + +impl ToUInt for Const<876> { + type Output = U876; +} + +impl ToUInt for Const<877> { + type Output = U877; +} + +impl ToUInt for Const<878> { + type Output = U878; +} + +impl ToUInt for Const<879> { + type Output = U879; +} + +impl ToUInt for Const<880> { + type Output = U880; +} + +impl ToUInt for Const<881> { + type Output = U881; +} + +impl ToUInt for Const<882> { + type Output = U882; +} + +impl ToUInt for Const<883> { + type Output = U883; +} + +impl ToUInt for Const<884> { + type Output = U884; +} + +impl ToUInt for Const<885> { + type Output = U885; +} + +impl ToUInt for Const<886> { + type Output = U886; +} + +impl ToUInt for Const<887> { + type Output = U887; +} + +impl ToUInt for Const<888> { + type Output = U888; +} + +impl ToUInt for Const<889> { + type Output = U889; +} + +impl ToUInt for Const<890> { + type Output = U890; +} + +impl ToUInt for Const<891> { + type Output = U891; +} + +impl ToUInt for Const<892> { + type Output = U892; +} + +impl ToUInt for Const<893> { + type Output = U893; +} + +impl ToUInt for Const<894> { + type Output = U894; +} + +impl ToUInt for Const<895> { + type Output = U895; +} + +impl ToUInt for Const<896> { + type Output = U896; +} + +impl ToUInt for Const<897> { + type Output = U897; +} + +impl ToUInt for Const<898> { + type Output = U898; +} + +impl ToUInt for Const<899> { + type Output = U899; +} + +impl ToUInt for Const<900> { + type Output = U900; +} + +impl ToUInt for Const<901> { + type Output = U901; +} + +impl ToUInt for Const<902> { + type Output = U902; +} + +impl ToUInt for Const<903> { + type Output = U903; +} + +impl ToUInt for Const<904> { + type Output = U904; +} + +impl ToUInt for Const<905> { + type Output = U905; +} + +impl ToUInt for Const<906> { + type Output = U906; +} + +impl ToUInt for Const<907> { + type Output = U907; +} + +impl ToUInt for Const<908> { + type Output = U908; +} + +impl ToUInt for Const<909> { + type Output = U909; +} + +impl ToUInt for Const<910> { + type Output = U910; +} + +impl ToUInt for Const<911> { + type Output = U911; +} + +impl ToUInt for Const<912> { + type Output = U912; +} + +impl ToUInt for Const<913> { + type Output = U913; +} + +impl ToUInt for Const<914> { + type Output = U914; +} + +impl ToUInt for Const<915> { + type Output = U915; +} + +impl ToUInt for Const<916> { + type Output = U916; +} + +impl ToUInt for Const<917> { + type Output = U917; +} + +impl ToUInt for Const<918> { + type Output = U918; +} + +impl ToUInt for Const<919> { + type Output = U919; +} + +impl ToUInt for Const<920> { + type Output = U920; +} + +impl ToUInt for Const<921> { + type Output = U921; +} + +impl ToUInt for Const<922> { + type Output = U922; +} + +impl ToUInt for Const<923> { + type Output = U923; +} + +impl ToUInt for Const<924> { + type Output = U924; +} + +impl ToUInt for Const<925> { + type Output = U925; +} + +impl ToUInt for Const<926> { + type Output = U926; +} + +impl ToUInt for Const<927> { + type Output = U927; +} + +impl ToUInt for Const<928> { + type Output = U928; +} + +impl ToUInt for Const<929> { + type Output = U929; +} + +impl ToUInt for Const<930> { + type Output = U930; +} + +impl ToUInt for Const<931> { + type Output = U931; +} + +impl ToUInt for Const<932> { + type Output = U932; +} + +impl ToUInt for Const<933> { + type Output = U933; +} + +impl ToUInt for Const<934> { + type Output = U934; +} + +impl ToUInt for Const<935> { + type Output = U935; +} + +impl ToUInt for Const<936> { + type Output = U936; +} + +impl ToUInt for Const<937> { + type Output = U937; +} + +impl ToUInt for Const<938> { + type Output = U938; +} + +impl ToUInt for Const<939> { + type Output = U939; +} + +impl ToUInt for Const<940> { + type Output = U940; +} + +impl ToUInt for Const<941> { + type Output = U941; +} + +impl ToUInt for Const<942> { + type Output = U942; +} + +impl ToUInt for Const<943> { + type Output = U943; +} + +impl ToUInt for Const<944> { + type Output = U944; +} + +impl ToUInt for Const<945> { + type Output = U945; +} + +impl ToUInt for Const<946> { + type Output = U946; +} + +impl ToUInt for Const<947> { + type Output = U947; +} + +impl ToUInt for Const<948> { + type Output = U948; +} + +impl ToUInt for Const<949> { + type Output = U949; +} + +impl ToUInt for Const<950> { + type Output = U950; +} + +impl ToUInt for Const<951> { + type Output = U951; +} + +impl ToUInt for Const<952> { + type Output = U952; +} + +impl ToUInt for Const<953> { + type Output = U953; +} + +impl ToUInt for Const<954> { + type Output = U954; +} + +impl ToUInt for Const<955> { + type Output = U955; +} + +impl ToUInt for Const<956> { + type Output = U956; +} + +impl ToUInt for Const<957> { + type Output = U957; +} + +impl ToUInt for Const<958> { + type Output = U958; +} + +impl ToUInt for Const<959> { + type Output = U959; +} + +impl ToUInt for Const<960> { + type Output = U960; +} + +impl ToUInt for Const<961> { + type Output = U961; +} + +impl ToUInt for Const<962> { + type Output = U962; +} + +impl ToUInt for Const<963> { + type Output = U963; +} + +impl ToUInt for Const<964> { + type Output = U964; +} + +impl ToUInt for Const<965> { + type Output = U965; +} + +impl ToUInt for Const<966> { + type Output = U966; +} + +impl ToUInt for Const<967> { + type Output = U967; +} + +impl ToUInt for Const<968> { + type Output = U968; +} + +impl ToUInt for Const<969> { + type Output = U969; +} + +impl ToUInt for Const<970> { + type Output = U970; +} + +impl ToUInt for Const<971> { + type Output = U971; +} + +impl ToUInt for Const<972> { + type Output = U972; +} + +impl ToUInt for Const<973> { + type Output = U973; +} + +impl ToUInt for Const<974> { + type Output = U974; +} + +impl ToUInt for Const<975> { + type Output = U975; +} + +impl ToUInt for Const<976> { + type Output = U976; +} + +impl ToUInt for Const<977> { + type Output = U977; +} + +impl ToUInt for Const<978> { + type Output = U978; +} + +impl ToUInt for Const<979> { + type Output = U979; +} + +impl ToUInt for Const<980> { + type Output = U980; +} + +impl ToUInt for Const<981> { + type Output = U981; +} + +impl ToUInt for Const<982> { + type Output = U982; +} + +impl ToUInt for Const<983> { + type Output = U983; +} + +impl ToUInt for Const<984> { + type Output = U984; +} + +impl ToUInt for Const<985> { + type Output = U985; +} + +impl ToUInt for Const<986> { + type Output = U986; +} + +impl ToUInt for Const<987> { + type Output = U987; +} + +impl ToUInt for Const<988> { + type Output = U988; +} + +impl ToUInt for Const<989> { + type Output = U989; +} + +impl ToUInt for Const<990> { + type Output = U990; +} + +impl ToUInt for Const<991> { + type Output = U991; +} + +impl ToUInt for Const<992> { + type Output = U992; +} + +impl ToUInt for Const<993> { + type Output = U993; +} + +impl ToUInt for Const<994> { + type Output = U994; +} + +impl ToUInt for Const<995> { + type Output = U995; +} + +impl ToUInt for Const<996> { + type Output = U996; +} + +impl ToUInt for Const<997> { + type Output = U997; +} + +impl ToUInt for Const<998> { + type Output = U998; +} + +impl ToUInt for Const<999> { + type Output = U999; +} + +impl ToUInt for Const<1000> { + type Output = U1000; +} + +impl ToUInt for Const<1001> { + type Output = U1001; +} + +impl ToUInt for Const<1002> { + type Output = U1002; +} + +impl ToUInt for Const<1003> { + type Output = U1003; +} + +impl ToUInt for Const<1004> { + type Output = U1004; +} + +impl ToUInt for Const<1005> { + type Output = U1005; +} + +impl ToUInt for Const<1006> { + type Output = U1006; +} + +impl ToUInt for Const<1007> { + type Output = U1007; +} + +impl ToUInt for Const<1008> { + type Output = U1008; +} + +impl ToUInt for Const<1009> { + type Output = U1009; +} + +impl ToUInt for Const<1010> { + type Output = U1010; +} + +impl ToUInt for Const<1011> { + type Output = U1011; +} + +impl ToUInt for Const<1012> { + type Output = U1012; +} + +impl ToUInt for Const<1013> { + type Output = U1013; +} + +impl ToUInt for Const<1014> { + type Output = U1014; +} + +impl ToUInt for Const<1015> { + type Output = U1015; +} + +impl ToUInt for Const<1016> { + type Output = U1016; +} + +impl ToUInt for Const<1017> { + type Output = U1017; +} + +impl ToUInt for Const<1018> { + type Output = U1018; +} + +impl ToUInt for Const<1019> { + type Output = U1019; +} + +impl ToUInt for Const<1020> { + type Output = U1020; +} + +impl ToUInt for Const<1021> { + type Output = U1021; +} + +impl ToUInt for Const<1022> { + type Output = U1022; +} + +impl ToUInt for Const<1023> { + type Output = U1023; +} + +impl ToUInt for Const<1024> { + type Output = U1024; +} + +impl ToUInt for Const<3600> { + type Output = U3600; +} + +impl ToUInt for Const<2048> { + type Output = U2048; +} + +impl ToUInt for Const<4096> { + type Output = U4096; +} + +impl ToUInt for Const<8192> { + type Output = U8192; +} + +impl ToUInt for Const<16384> { + type Output = U16384; +} + +impl ToUInt for Const<32768> { + type Output = U32768; +} + +impl ToUInt for Const<65536> { + type Output = U65536; +} + +impl ToUInt for Const<131072> { + type Output = U131072; +} + +impl ToUInt for Const<262144> { + type Output = U262144; +} + +impl ToUInt for Const<524288> { + type Output = U524288; +} + +impl ToUInt for Const<1048576> { + type Output = U1048576; +} + +impl ToUInt for Const<2097152> { + type Output = U2097152; +} + +impl ToUInt for Const<4194304> { + type Output = U4194304; +} + +impl ToUInt for Const<8388608> { + type Output = U8388608; +} + +impl ToUInt for Const<16777216> { + type Output = U16777216; +} + +impl ToUInt for Const<33554432> { + type Output = U33554432; +} + +impl ToUInt for Const<67108864> { + type Output = U67108864; +} + +impl ToUInt for Const<134217728> { + type Output = U134217728; +} + +impl ToUInt for Const<268435456> { + type Output = U268435456; +} + +impl ToUInt for Const<536870912> { + type Output = U536870912; +} + +impl ToUInt for Const<1073741824> { + type Output = U1073741824; +} + +impl ToUInt for Const<2147483648> { + type Output = U2147483648; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<4294967296> { + type Output = U4294967296; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<8589934592> { + type Output = U8589934592; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<17179869184> { + type Output = U17179869184; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<34359738368> { + type Output = U34359738368; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<68719476736> { + type Output = U68719476736; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<137438953472> { + type Output = U137438953472; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<274877906944> { + type Output = U274877906944; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<549755813888> { + type Output = U549755813888; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<1099511627776> { + type Output = U1099511627776; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<2199023255552> { + type Output = U2199023255552; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<4398046511104> { + type Output = U4398046511104; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<8796093022208> { + type Output = U8796093022208; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<17592186044416> { + type Output = U17592186044416; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<35184372088832> { + type Output = U35184372088832; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<70368744177664> { + type Output = U70368744177664; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<140737488355328> { + type Output = U140737488355328; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<281474976710656> { + type Output = U281474976710656; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<562949953421312> { + type Output = U562949953421312; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<1125899906842624> { + type Output = U1125899906842624; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<2251799813685248> { + type Output = U2251799813685248; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<4503599627370496> { + type Output = U4503599627370496; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<9007199254740992> { + type Output = U9007199254740992; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<18014398509481984> { + type Output = U18014398509481984; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<36028797018963968> { + type Output = U36028797018963968; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<72057594037927936> { + type Output = U72057594037927936; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<144115188075855872> { + type Output = U144115188075855872; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<288230376151711744> { + type Output = U288230376151711744; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<576460752303423488> { + type Output = U576460752303423488; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<1152921504606846976> { + type Output = U1152921504606846976; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<2305843009213693952> { + type Output = U2305843009213693952; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<4611686018427387904> { + type Output = U4611686018427387904; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<9223372036854775808> { + type Output = U9223372036854775808; +} + +impl ToUInt for Const<10000> { + type Output = U10000; +} + +impl ToUInt for Const<100000> { + type Output = U100000; +} + +impl ToUInt for Const<1000000> { + type Output = U1000000; +} + +impl ToUInt for Const<10000000> { + type Output = U10000000; +} + +impl ToUInt for Const<100000000> { + type Output = U100000000; +} + +impl ToUInt for Const<1000000000> { + type Output = U1000000000; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<10000000000> { + type Output = U10000000000; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<100000000000> { + type Output = U100000000000; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<1000000000000> { + type Output = U1000000000000; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<10000000000000> { + type Output = U10000000000000; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<100000000000000> { + type Output = U100000000000000; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<1000000000000000> { + type Output = U1000000000000000; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<10000000000000000> { + type Output = U10000000000000000; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<100000000000000000> { + type Output = U100000000000000000; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<1000000000000000000> { + type Output = U1000000000000000000; +} + +#[cfg(target_pointer_width = "64")] +impl ToUInt for Const<10000000000000000000> { + type Output = U10000000000000000000; +} diff --git a/collector/compile-benchmarks/typenum-1.18.0/src/gen/op.rs b/collector/compile-benchmarks/typenum-1.18.0/src/gen/op.rs new file mode 100644 index 000000000..15120a131 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.18.0/src/gen/op.rs @@ -0,0 +1,1030 @@ +// THIS IS GENERATED CODE +/** +Convenient type operations. + +Any types representing values must be able to be expressed as `ident`s. That means they need to be +in scope. + +For example, `P5` is okay, but `typenum::P5` is not. + +You may combine operators arbitrarily, although doing so excessively may require raising the +recursion limit. + +# Example +```rust +#![recursion_limit="128"] +#[macro_use] extern crate typenum; +use typenum::consts::*; + +fn main() { + assert_type!( + op!(min((P1 - P2) * (N3 + N7), P5 * (P3 + P4)) == P10) + ); +} +``` +Operators are evaluated based on the operator precedence outlined +[here](https://doc.rust-lang.org/reference.html#operator-precedence). + +The full list of supported operators and functions is as follows: + +`*`, `/`, `%`, `+`, `-`, `<<`, `>>`, `&`, `^`, `|`, `==`, `!=`, `<=`, `>=`, `<`, `>`, `cmp`, `sqr`, `sqrt`, `abs`, `cube`, `pow`, `min`, `max`, `log2`, `gcd` + +They all expand to type aliases defined in the `operator_aliases` module. Here is an expanded list, +including examples: + +--- +Operator `*`. Expands to `Prod`. + +```rust +# #[macro_use] extern crate typenum; +# use typenum::*; +# fn main() { +assert_type_eq!(op!(P2 * P3), P6); +# } +``` + +--- +Operator `/`. Expands to `Quot`. + +```rust +# #[macro_use] extern crate typenum; +# use typenum::*; +# fn main() { +assert_type_eq!(op!(P6 / P2), P3); +# } +``` + +--- +Operator `%`. Expands to `Mod`. + +```rust +# #[macro_use] extern crate typenum; +# use typenum::*; +# fn main() { +assert_type_eq!(op!(P5 % P3), P2); +# } +``` + +--- +Operator `+`. Expands to `Sum`. + +```rust +# #[macro_use] extern crate typenum; +# use typenum::*; +# fn main() { +assert_type_eq!(op!(P2 + P3), P5); +# } +``` + +--- +Operator `-`. Expands to `Diff`. + +```rust +# #[macro_use] extern crate typenum; +# use typenum::*; +# fn main() { +assert_type_eq!(op!(P2 - P3), N1); +# } +``` + +--- +Operator `<<`. Expands to `Shleft`. + +```rust +# #[macro_use] extern crate typenum; +# use typenum::*; +# fn main() { +assert_type_eq!(op!(U1 << U5), U32); +# } +``` + +--- +Operator `>>`. Expands to `Shright`. + +```rust +# #[macro_use] extern crate typenum; +# use typenum::*; +# fn main() { +assert_type_eq!(op!(U32 >> U5), U1); +# } +``` + +--- +Operator `&`. Expands to `And`. + +```rust +# #[macro_use] extern crate typenum; +# use typenum::*; +# fn main() { +assert_type_eq!(op!(U5 & U3), U1); +# } +``` + +--- +Operator `^`. Expands to `Xor`. + +```rust +# #[macro_use] extern crate typenum; +# use typenum::*; +# fn main() { +assert_type_eq!(op!(U5 ^ U3), U6); +# } +``` + +--- +Operator `|`. Expands to `Or`. + +```rust +# #[macro_use] extern crate typenum; +# use typenum::*; +# fn main() { +assert_type_eq!(op!(U5 | U3), U7); +# } +``` + +--- +Operator `==`. Expands to `Eq`. + +```rust +# #[macro_use] extern crate typenum; +# use typenum::*; +# fn main() { +assert_type_eq!(op!(P5 == P3 + P2), True); +# } +``` + +--- +Operator `!=`. Expands to `NotEq`. + +```rust +# #[macro_use] extern crate typenum; +# use typenum::*; +# fn main() { +assert_type_eq!(op!(P5 != P3 + P2), False); +# } +``` + +--- +Operator `<=`. Expands to `LeEq`. + +```rust +# #[macro_use] extern crate typenum; +# use typenum::*; +# fn main() { +assert_type_eq!(op!(P6 <= P3 + P2), False); +# } +``` + +--- +Operator `>=`. Expands to `GrEq`. + +```rust +# #[macro_use] extern crate typenum; +# use typenum::*; +# fn main() { +assert_type_eq!(op!(P6 >= P3 + P2), True); +# } +``` + +--- +Operator `<`. Expands to `Le`. + +```rust +# #[macro_use] extern crate typenum; +# use typenum::*; +# fn main() { +assert_type_eq!(op!(P4 < P3 + P2), True); +# } +``` + +--- +Operator `>`. Expands to `Gr`. + +```rust +# #[macro_use] extern crate typenum; +# use typenum::*; +# fn main() { +assert_type_eq!(op!(P5 < P3 + P2), False); +# } +``` + +--- +Operator `cmp`. Expands to `Compare`. + +```rust +# #[macro_use] extern crate typenum; +# use typenum::*; +# fn main() { +assert_type_eq!(op!(cmp(P2, P3)), Less); +# } +``` + +--- +Operator `sqr`. Expands to `Square`. + +```rust +# #[macro_use] extern crate typenum; +# use typenum::*; +# fn main() { +assert_type_eq!(op!(sqr(P2)), P4); +# } +``` + +--- +Operator `sqrt`. Expands to `Sqrt`. + +```rust +# #[macro_use] extern crate typenum; +# use typenum::*; +# fn main() { +assert_type_eq!(op!(sqrt(U9)), U3); +# } +``` + +--- +Operator `abs`. Expands to `AbsVal`. + +```rust +# #[macro_use] extern crate typenum; +# use typenum::*; +# fn main() { +assert_type_eq!(op!(abs(N2)), P2); +# } +``` + +--- +Operator `cube`. Expands to `Cube`. + +```rust +# #[macro_use] extern crate typenum; +# use typenum::*; +# fn main() { +assert_type_eq!(op!(cube(P2)), P8); +# } +``` + +--- +Operator `pow`. Expands to `Exp`. + +```rust +# #[macro_use] extern crate typenum; +# use typenum::*; +# fn main() { +assert_type_eq!(op!(pow(P2, P3)), P8); +# } +``` + +--- +Operator `min`. Expands to `Minimum`. + +```rust +# #[macro_use] extern crate typenum; +# use typenum::*; +# fn main() { +assert_type_eq!(op!(min(P2, P3)), P2); +# } +``` + +--- +Operator `max`. Expands to `Maximum`. + +```rust +# #[macro_use] extern crate typenum; +# use typenum::*; +# fn main() { +assert_type_eq!(op!(max(P2, P3)), P3); +# } +``` + +--- +Operator `log2`. Expands to `Log2`. + +```rust +# #[macro_use] extern crate typenum; +# use typenum::*; +# fn main() { +assert_type_eq!(op!(log2(U9)), U3); +# } +``` + +--- +Operator `gcd`. Expands to `Gcf`. + +```rust +# #[macro_use] extern crate typenum; +# use typenum::*; +# fn main() { +assert_type_eq!(op!(gcd(U9, U21)), U3); +# } +``` + +*/ +#[macro_export(local_inner_macros)] +macro_rules! op { + ($($tail:tt)*) => ( __op_internal__!($($tail)*) ); +} + +#[doc(hidden)] +#[macro_export(local_inner_macros)] +macro_rules! __op_internal__ { + +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: cmp $($tail:tt)*) => ( + __op_internal__!(@stack[Compare, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: sqr $($tail:tt)*) => ( + __op_internal__!(@stack[Square, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: sqrt $($tail:tt)*) => ( + __op_internal__!(@stack[Sqrt, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: abs $($tail:tt)*) => ( + __op_internal__!(@stack[AbsVal, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: cube $($tail:tt)*) => ( + __op_internal__!(@stack[Cube, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: pow $($tail:tt)*) => ( + __op_internal__!(@stack[Exp, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: min $($tail:tt)*) => ( + __op_internal__!(@stack[Minimum, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: max $($tail:tt)*) => ( + __op_internal__!(@stack[Maximum, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: log2 $($tail:tt)*) => ( + __op_internal__!(@stack[Log2, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: gcd $($tail:tt)*) => ( + __op_internal__!(@stack[Gcf, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[LParen, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: , $($tail:tt)*) => ( + __op_internal__!(@stack[LParen, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[$stack_top:ident, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: , $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[$stack_top, $($queue,)*] @tail: , $($tail)*) +); +(@stack[Prod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: * $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Prod, $($queue,)*] @tail: * $($tail)*) +); +(@stack[Quot, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: * $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Quot, $($queue,)*] @tail: * $($tail)*) +); +(@stack[Mod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: * $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Mod, $($queue,)*] @tail: * $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: * $($tail:tt)*) => ( + __op_internal__!(@stack[Prod, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[Prod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: / $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Prod, $($queue,)*] @tail: / $($tail)*) +); +(@stack[Quot, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: / $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Quot, $($queue,)*] @tail: / $($tail)*) +); +(@stack[Mod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: / $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Mod, $($queue,)*] @tail: / $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: / $($tail:tt)*) => ( + __op_internal__!(@stack[Quot, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[Prod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: % $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Prod, $($queue,)*] @tail: % $($tail)*) +); +(@stack[Quot, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: % $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Quot, $($queue,)*] @tail: % $($tail)*) +); +(@stack[Mod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: % $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Mod, $($queue,)*] @tail: % $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: % $($tail:tt)*) => ( + __op_internal__!(@stack[Mod, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[Prod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: + $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Prod, $($queue,)*] @tail: + $($tail)*) +); +(@stack[Quot, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: + $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Quot, $($queue,)*] @tail: + $($tail)*) +); +(@stack[Mod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: + $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Mod, $($queue,)*] @tail: + $($tail)*) +); +(@stack[Sum, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: + $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Sum, $($queue,)*] @tail: + $($tail)*) +); +(@stack[Diff, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: + $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Diff, $($queue,)*] @tail: + $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: + $($tail:tt)*) => ( + __op_internal__!(@stack[Sum, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[Prod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: - $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Prod, $($queue,)*] @tail: - $($tail)*) +); +(@stack[Quot, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: - $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Quot, $($queue,)*] @tail: - $($tail)*) +); +(@stack[Mod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: - $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Mod, $($queue,)*] @tail: - $($tail)*) +); +(@stack[Sum, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: - $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Sum, $($queue,)*] @tail: - $($tail)*) +); +(@stack[Diff, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: - $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Diff, $($queue,)*] @tail: - $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: - $($tail:tt)*) => ( + __op_internal__!(@stack[Diff, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[Prod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: << $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Prod, $($queue,)*] @tail: << $($tail)*) +); +(@stack[Quot, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: << $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Quot, $($queue,)*] @tail: << $($tail)*) +); +(@stack[Mod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: << $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Mod, $($queue,)*] @tail: << $($tail)*) +); +(@stack[Sum, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: << $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Sum, $($queue,)*] @tail: << $($tail)*) +); +(@stack[Diff, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: << $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Diff, $($queue,)*] @tail: << $($tail)*) +); +(@stack[Shleft, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: << $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Shleft, $($queue,)*] @tail: << $($tail)*) +); +(@stack[Shright, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: << $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Shright, $($queue,)*] @tail: << $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: << $($tail:tt)*) => ( + __op_internal__!(@stack[Shleft, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[Prod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: >> $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Prod, $($queue,)*] @tail: >> $($tail)*) +); +(@stack[Quot, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: >> $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Quot, $($queue,)*] @tail: >> $($tail)*) +); +(@stack[Mod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: >> $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Mod, $($queue,)*] @tail: >> $($tail)*) +); +(@stack[Sum, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: >> $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Sum, $($queue,)*] @tail: >> $($tail)*) +); +(@stack[Diff, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: >> $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Diff, $($queue,)*] @tail: >> $($tail)*) +); +(@stack[Shleft, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: >> $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Shleft, $($queue,)*] @tail: >> $($tail)*) +); +(@stack[Shright, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: >> $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Shright, $($queue,)*] @tail: >> $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: >> $($tail:tt)*) => ( + __op_internal__!(@stack[Shright, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[Prod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: & $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Prod, $($queue,)*] @tail: & $($tail)*) +); +(@stack[Quot, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: & $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Quot, $($queue,)*] @tail: & $($tail)*) +); +(@stack[Mod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: & $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Mod, $($queue,)*] @tail: & $($tail)*) +); +(@stack[Sum, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: & $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Sum, $($queue,)*] @tail: & $($tail)*) +); +(@stack[Diff, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: & $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Diff, $($queue,)*] @tail: & $($tail)*) +); +(@stack[Shleft, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: & $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Shleft, $($queue,)*] @tail: & $($tail)*) +); +(@stack[Shright, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: & $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Shright, $($queue,)*] @tail: & $($tail)*) +); +(@stack[And, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: & $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[And, $($queue,)*] @tail: & $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: & $($tail:tt)*) => ( + __op_internal__!(@stack[And, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[Prod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: ^ $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Prod, $($queue,)*] @tail: ^ $($tail)*) +); +(@stack[Quot, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: ^ $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Quot, $($queue,)*] @tail: ^ $($tail)*) +); +(@stack[Mod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: ^ $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Mod, $($queue,)*] @tail: ^ $($tail)*) +); +(@stack[Sum, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: ^ $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Sum, $($queue,)*] @tail: ^ $($tail)*) +); +(@stack[Diff, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: ^ $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Diff, $($queue,)*] @tail: ^ $($tail)*) +); +(@stack[Shleft, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: ^ $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Shleft, $($queue,)*] @tail: ^ $($tail)*) +); +(@stack[Shright, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: ^ $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Shright, $($queue,)*] @tail: ^ $($tail)*) +); +(@stack[And, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: ^ $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[And, $($queue,)*] @tail: ^ $($tail)*) +); +(@stack[Xor, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: ^ $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Xor, $($queue,)*] @tail: ^ $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: ^ $($tail:tt)*) => ( + __op_internal__!(@stack[Xor, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[Prod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: | $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Prod, $($queue,)*] @tail: | $($tail)*) +); +(@stack[Quot, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: | $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Quot, $($queue,)*] @tail: | $($tail)*) +); +(@stack[Mod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: | $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Mod, $($queue,)*] @tail: | $($tail)*) +); +(@stack[Sum, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: | $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Sum, $($queue,)*] @tail: | $($tail)*) +); +(@stack[Diff, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: | $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Diff, $($queue,)*] @tail: | $($tail)*) +); +(@stack[Shleft, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: | $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Shleft, $($queue,)*] @tail: | $($tail)*) +); +(@stack[Shright, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: | $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Shright, $($queue,)*] @tail: | $($tail)*) +); +(@stack[And, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: | $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[And, $($queue,)*] @tail: | $($tail)*) +); +(@stack[Xor, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: | $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Xor, $($queue,)*] @tail: | $($tail)*) +); +(@stack[Or, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: | $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Or, $($queue,)*] @tail: | $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: | $($tail:tt)*) => ( + __op_internal__!(@stack[Or, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[Prod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: == $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Prod, $($queue,)*] @tail: == $($tail)*) +); +(@stack[Quot, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: == $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Quot, $($queue,)*] @tail: == $($tail)*) +); +(@stack[Mod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: == $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Mod, $($queue,)*] @tail: == $($tail)*) +); +(@stack[Sum, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: == $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Sum, $($queue,)*] @tail: == $($tail)*) +); +(@stack[Diff, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: == $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Diff, $($queue,)*] @tail: == $($tail)*) +); +(@stack[Shleft, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: == $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Shleft, $($queue,)*] @tail: == $($tail)*) +); +(@stack[Shright, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: == $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Shright, $($queue,)*] @tail: == $($tail)*) +); +(@stack[And, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: == $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[And, $($queue,)*] @tail: == $($tail)*) +); +(@stack[Xor, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: == $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Xor, $($queue,)*] @tail: == $($tail)*) +); +(@stack[Or, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: == $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Or, $($queue,)*] @tail: == $($tail)*) +); +(@stack[Eq, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: == $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Eq, $($queue,)*] @tail: == $($tail)*) +); +(@stack[NotEq, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: == $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[NotEq, $($queue,)*] @tail: == $($tail)*) +); +(@stack[LeEq, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: == $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[LeEq, $($queue,)*] @tail: == $($tail)*) +); +(@stack[GrEq, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: == $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[GrEq, $($queue,)*] @tail: == $($tail)*) +); +(@stack[Le, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: == $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Le, $($queue,)*] @tail: == $($tail)*) +); +(@stack[Gr, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: == $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Gr, $($queue,)*] @tail: == $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: == $($tail:tt)*) => ( + __op_internal__!(@stack[Eq, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[Prod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: != $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Prod, $($queue,)*] @tail: != $($tail)*) +); +(@stack[Quot, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: != $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Quot, $($queue,)*] @tail: != $($tail)*) +); +(@stack[Mod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: != $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Mod, $($queue,)*] @tail: != $($tail)*) +); +(@stack[Sum, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: != $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Sum, $($queue,)*] @tail: != $($tail)*) +); +(@stack[Diff, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: != $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Diff, $($queue,)*] @tail: != $($tail)*) +); +(@stack[Shleft, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: != $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Shleft, $($queue,)*] @tail: != $($tail)*) +); +(@stack[Shright, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: != $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Shright, $($queue,)*] @tail: != $($tail)*) +); +(@stack[And, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: != $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[And, $($queue,)*] @tail: != $($tail)*) +); +(@stack[Xor, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: != $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Xor, $($queue,)*] @tail: != $($tail)*) +); +(@stack[Or, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: != $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Or, $($queue,)*] @tail: != $($tail)*) +); +(@stack[Eq, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: != $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Eq, $($queue,)*] @tail: != $($tail)*) +); +(@stack[NotEq, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: != $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[NotEq, $($queue,)*] @tail: != $($tail)*) +); +(@stack[LeEq, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: != $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[LeEq, $($queue,)*] @tail: != $($tail)*) +); +(@stack[GrEq, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: != $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[GrEq, $($queue,)*] @tail: != $($tail)*) +); +(@stack[Le, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: != $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Le, $($queue,)*] @tail: != $($tail)*) +); +(@stack[Gr, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: != $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Gr, $($queue,)*] @tail: != $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: != $($tail:tt)*) => ( + __op_internal__!(@stack[NotEq, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[Prod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: <= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Prod, $($queue,)*] @tail: <= $($tail)*) +); +(@stack[Quot, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: <= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Quot, $($queue,)*] @tail: <= $($tail)*) +); +(@stack[Mod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: <= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Mod, $($queue,)*] @tail: <= $($tail)*) +); +(@stack[Sum, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: <= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Sum, $($queue,)*] @tail: <= $($tail)*) +); +(@stack[Diff, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: <= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Diff, $($queue,)*] @tail: <= $($tail)*) +); +(@stack[Shleft, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: <= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Shleft, $($queue,)*] @tail: <= $($tail)*) +); +(@stack[Shright, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: <= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Shright, $($queue,)*] @tail: <= $($tail)*) +); +(@stack[And, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: <= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[And, $($queue,)*] @tail: <= $($tail)*) +); +(@stack[Xor, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: <= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Xor, $($queue,)*] @tail: <= $($tail)*) +); +(@stack[Or, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: <= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Or, $($queue,)*] @tail: <= $($tail)*) +); +(@stack[Eq, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: <= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Eq, $($queue,)*] @tail: <= $($tail)*) +); +(@stack[NotEq, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: <= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[NotEq, $($queue,)*] @tail: <= $($tail)*) +); +(@stack[LeEq, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: <= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[LeEq, $($queue,)*] @tail: <= $($tail)*) +); +(@stack[GrEq, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: <= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[GrEq, $($queue,)*] @tail: <= $($tail)*) +); +(@stack[Le, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: <= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Le, $($queue,)*] @tail: <= $($tail)*) +); +(@stack[Gr, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: <= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Gr, $($queue,)*] @tail: <= $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: <= $($tail:tt)*) => ( + __op_internal__!(@stack[LeEq, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[Prod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: >= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Prod, $($queue,)*] @tail: >= $($tail)*) +); +(@stack[Quot, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: >= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Quot, $($queue,)*] @tail: >= $($tail)*) +); +(@stack[Mod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: >= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Mod, $($queue,)*] @tail: >= $($tail)*) +); +(@stack[Sum, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: >= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Sum, $($queue,)*] @tail: >= $($tail)*) +); +(@stack[Diff, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: >= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Diff, $($queue,)*] @tail: >= $($tail)*) +); +(@stack[Shleft, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: >= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Shleft, $($queue,)*] @tail: >= $($tail)*) +); +(@stack[Shright, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: >= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Shright, $($queue,)*] @tail: >= $($tail)*) +); +(@stack[And, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: >= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[And, $($queue,)*] @tail: >= $($tail)*) +); +(@stack[Xor, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: >= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Xor, $($queue,)*] @tail: >= $($tail)*) +); +(@stack[Or, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: >= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Or, $($queue,)*] @tail: >= $($tail)*) +); +(@stack[Eq, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: >= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Eq, $($queue,)*] @tail: >= $($tail)*) +); +(@stack[NotEq, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: >= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[NotEq, $($queue,)*] @tail: >= $($tail)*) +); +(@stack[LeEq, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: >= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[LeEq, $($queue,)*] @tail: >= $($tail)*) +); +(@stack[GrEq, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: >= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[GrEq, $($queue,)*] @tail: >= $($tail)*) +); +(@stack[Le, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: >= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Le, $($queue,)*] @tail: >= $($tail)*) +); +(@stack[Gr, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: >= $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Gr, $($queue,)*] @tail: >= $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: >= $($tail:tt)*) => ( + __op_internal__!(@stack[GrEq, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[Prod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: < $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Prod, $($queue,)*] @tail: < $($tail)*) +); +(@stack[Quot, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: < $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Quot, $($queue,)*] @tail: < $($tail)*) +); +(@stack[Mod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: < $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Mod, $($queue,)*] @tail: < $($tail)*) +); +(@stack[Sum, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: < $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Sum, $($queue,)*] @tail: < $($tail)*) +); +(@stack[Diff, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: < $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Diff, $($queue,)*] @tail: < $($tail)*) +); +(@stack[Shleft, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: < $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Shleft, $($queue,)*] @tail: < $($tail)*) +); +(@stack[Shright, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: < $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Shright, $($queue,)*] @tail: < $($tail)*) +); +(@stack[And, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: < $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[And, $($queue,)*] @tail: < $($tail)*) +); +(@stack[Xor, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: < $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Xor, $($queue,)*] @tail: < $($tail)*) +); +(@stack[Or, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: < $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Or, $($queue,)*] @tail: < $($tail)*) +); +(@stack[Eq, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: < $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Eq, $($queue,)*] @tail: < $($tail)*) +); +(@stack[NotEq, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: < $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[NotEq, $($queue,)*] @tail: < $($tail)*) +); +(@stack[LeEq, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: < $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[LeEq, $($queue,)*] @tail: < $($tail)*) +); +(@stack[GrEq, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: < $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[GrEq, $($queue,)*] @tail: < $($tail)*) +); +(@stack[Le, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: < $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Le, $($queue,)*] @tail: < $($tail)*) +); +(@stack[Gr, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: < $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Gr, $($queue,)*] @tail: < $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: < $($tail:tt)*) => ( + __op_internal__!(@stack[Le, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[Prod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: > $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Prod, $($queue,)*] @tail: > $($tail)*) +); +(@stack[Quot, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: > $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Quot, $($queue,)*] @tail: > $($tail)*) +); +(@stack[Mod, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: > $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Mod, $($queue,)*] @tail: > $($tail)*) +); +(@stack[Sum, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: > $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Sum, $($queue,)*] @tail: > $($tail)*) +); +(@stack[Diff, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: > $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Diff, $($queue,)*] @tail: > $($tail)*) +); +(@stack[Shleft, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: > $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Shleft, $($queue,)*] @tail: > $($tail)*) +); +(@stack[Shright, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: > $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Shright, $($queue,)*] @tail: > $($tail)*) +); +(@stack[And, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: > $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[And, $($queue,)*] @tail: > $($tail)*) +); +(@stack[Xor, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: > $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Xor, $($queue,)*] @tail: > $($tail)*) +); +(@stack[Or, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: > $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Or, $($queue,)*] @tail: > $($tail)*) +); +(@stack[Eq, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: > $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Eq, $($queue,)*] @tail: > $($tail)*) +); +(@stack[NotEq, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: > $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[NotEq, $($queue,)*] @tail: > $($tail)*) +); +(@stack[LeEq, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: > $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[LeEq, $($queue,)*] @tail: > $($tail)*) +); +(@stack[GrEq, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: > $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[GrEq, $($queue,)*] @tail: > $($tail)*) +); +(@stack[Le, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: > $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Le, $($queue,)*] @tail: > $($tail)*) +); +(@stack[Gr, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: > $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Gr, $($queue,)*] @tail: > $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: > $($tail:tt)*) => ( + __op_internal__!(@stack[Gr, $($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: ( $($stuff:tt)* ) $($tail:tt)* ) + => ( + __op_internal__!(@stack[LParen, $($stack,)*] @queue[$($queue,)*] + @tail: $($stuff)* RParen $($tail)*) +); +(@stack[LParen, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: RParen $($tail:tt)*) => ( + __op_internal__!(@rp3 @stack[$($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[$stack_top:ident, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: RParen $($tail:tt)*) + => ( + __op_internal__!(@stack[$($stack,)*] @queue[$stack_top, $($queue,)*] @tail: RParen $($tail)*) +); +(@rp3 @stack[Compare, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Compare, $($queue,)*] @tail: $($tail)*) +); +(@rp3 @stack[Square, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Square, $($queue,)*] @tail: $($tail)*) +); +(@rp3 @stack[Sqrt, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Sqrt, $($queue,)*] @tail: $($tail)*) +); +(@rp3 @stack[AbsVal, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[AbsVal, $($queue,)*] @tail: $($tail)*) +); +(@rp3 @stack[Cube, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Cube, $($queue,)*] @tail: $($tail)*) +); +(@rp3 @stack[Exp, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Exp, $($queue,)*] @tail: $($tail)*) +); +(@rp3 @stack[Minimum, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Minimum, $($queue,)*] @tail: $($tail)*) +); +(@rp3 @stack[Maximum, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Maximum, $($queue,)*] @tail: $($tail)*) +); +(@rp3 @stack[Log2, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Log2, $($queue,)*] @tail: $($tail)*) +); +(@rp3 @stack[Gcf, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail: $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[Gcf, $($queue,)*] @tail: $($tail)*) +); +(@rp3 @stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[$($queue,)*] @tail: $($tail)*) +); +(@stack[$($stack:ident,)*] @queue[$($queue:ident,)*] @tail: $num:ident $($tail:tt)*) => ( + __op_internal__!(@stack[$($stack,)*] @queue[$num, $($queue,)*] @tail: $($tail)*) +); +(@stack[] @queue[$($queue:ident,)*] @tail: ) => ( + __op_internal__!(@reverse[] @input: $($queue,)*) +); +(@stack[$stack_top:ident, $($stack:ident,)*] @queue[$($queue:ident,)*] @tail:) => ( + __op_internal__!(@stack[$($stack,)*] @queue[$stack_top, $($queue,)*] @tail: ) +); +(@reverse[$($revved:ident,)*] @input: $head:ident, $($tail:ident,)* ) => ( + __op_internal__!(@reverse[$head, $($revved,)*] @input: $($tail,)*) +); +(@reverse[$($revved:ident,)*] @input: ) => ( + __op_internal__!(@eval @stack[] @input[$($revved,)*]) +); +(@eval @stack[$a:ty, $b:ty, $($stack:ty,)*] @input[Prod, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$crate::Prod<$b, $a>, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$a:ty, $b:ty, $($stack:ty,)*] @input[Quot, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$crate::Quot<$b, $a>, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$a:ty, $b:ty, $($stack:ty,)*] @input[Mod, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$crate::Mod<$b, $a>, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$a:ty, $b:ty, $($stack:ty,)*] @input[Sum, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$crate::Sum<$b, $a>, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$a:ty, $b:ty, $($stack:ty,)*] @input[Diff, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$crate::Diff<$b, $a>, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$a:ty, $b:ty, $($stack:ty,)*] @input[Shleft, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$crate::Shleft<$b, $a>, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$a:ty, $b:ty, $($stack:ty,)*] @input[Shright, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$crate::Shright<$b, $a>, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$a:ty, $b:ty, $($stack:ty,)*] @input[And, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$crate::And<$b, $a>, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$a:ty, $b:ty, $($stack:ty,)*] @input[Xor, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$crate::Xor<$b, $a>, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$a:ty, $b:ty, $($stack:ty,)*] @input[Or, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$crate::Or<$b, $a>, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$a:ty, $b:ty, $($stack:ty,)*] @input[Eq, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$crate::Eq<$b, $a>, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$a:ty, $b:ty, $($stack:ty,)*] @input[NotEq, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$crate::NotEq<$b, $a>, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$a:ty, $b:ty, $($stack:ty,)*] @input[LeEq, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$crate::LeEq<$b, $a>, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$a:ty, $b:ty, $($stack:ty,)*] @input[GrEq, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$crate::GrEq<$b, $a>, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$a:ty, $b:ty, $($stack:ty,)*] @input[Le, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$crate::Le<$b, $a>, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$a:ty, $b:ty, $($stack:ty,)*] @input[Gr, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$crate::Gr<$b, $a>, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$a:ty, $b:ty, $($stack:ty,)*] @input[Compare, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$crate::Compare<$b, $a>, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$a:ty, $b:ty, $($stack:ty,)*] @input[Exp, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$crate::Exp<$b, $a>, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$a:ty, $b:ty, $($stack:ty,)*] @input[Minimum, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$crate::Minimum<$b, $a>, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$a:ty, $b:ty, $($stack:ty,)*] @input[Maximum, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$crate::Maximum<$b, $a>, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$a:ty, $b:ty, $($stack:ty,)*] @input[Gcf, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$crate::Gcf<$b, $a>, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$a:ty, $($stack:ty,)*] @input[Square, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$crate::Square<$a>, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$a:ty, $($stack:ty,)*] @input[Sqrt, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$crate::Sqrt<$a>, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$a:ty, $($stack:ty,)*] @input[AbsVal, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$crate::AbsVal<$a>, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$a:ty, $($stack:ty,)*] @input[Cube, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$crate::Cube<$a>, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$a:ty, $($stack:ty,)*] @input[Log2, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$crate::Log2<$a>, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$($stack:ty,)*] @input[$head:ident, $($tail:ident,)*]) => ( + __op_internal__!(@eval @stack[$head, $($stack,)*] @input[$($tail,)*]) +); +(@eval @stack[$stack:ty,] @input[]) => ( + $stack +); +($($tail:tt)* ) => ( + __op_internal__!(@stack[] @queue[] @tail: $($tail)*) +); +} diff --git a/collector/compile-benchmarks/typenum-1.18.0/src/int.rs b/collector/compile-benchmarks/typenum-1.18.0/src/int.rs new file mode 100644 index 000000000..1f6eaebc1 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.18.0/src/int.rs @@ -0,0 +1,1401 @@ +//! Type-level signed integers. +//! +//! +//! Type **operators** implemented: +//! +//! From `core::ops`: `Add`, `Sub`, `Mul`, `Div`, and `Rem`. +//! From `typenum`: `Same`, `Cmp`, and `Pow`. +//! +//! Rather than directly using the structs defined in this module, it is recommended that +//! you import and use the relevant aliases from the [consts](../consts/index.html) module. +//! +//! Note that operators that work on the underlying structure of the number are +//! intentionally not implemented. This is because this implementation of signed integers +//! does *not* use twos-complement, and implementing them would require making arbitrary +//! choices, causing the results of such operators to be difficult to reason about. +//! +//! # Example +//! ```rust +//! use std::ops::{Add, Div, Mul, Rem, Sub}; +//! use typenum::{Integer, N3, P2}; +//! +//! assert_eq!(>::Output::to_i32(), -1); +//! assert_eq!(>::Output::to_i32(), -5); +//! assert_eq!(>::Output::to_i32(), -6); +//! assert_eq!(>::Output::to_i32(), -1); +//! assert_eq!(>::Output::to_i32(), -1); +//! ``` + +pub use crate::marker_traits::Integer; +use crate::{ + bit::{Bit, B0, B1}, + consts::{N1, P1, U0, U1}, + private::{Internal, InternalMarker, PrivateDivInt, PrivateIntegerAdd, PrivateRem}, + uint::{UInt, Unsigned}, + Cmp, Equal, Greater, Less, NonZero, Pow, PowerOfTwo, ToInt, Zero, +}; +use core::ops::{Add, Div, Mul, Neg, Rem, Sub}; + +/// Type-level signed integers with positive sign. +#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Debug, Default)] +#[cfg_attr(feature = "scale_info", derive(scale_info::TypeInfo))] +pub struct PInt { + pub(crate) n: U, +} + +/// Type-level signed integers with negative sign. +#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Debug, Default)] +#[cfg_attr(feature = "scale_info", derive(scale_info::TypeInfo))] +pub struct NInt { + pub(crate) n: U, +} + +impl PInt { + /// Instantiates a singleton representing this strictly positive integer. + #[inline] + pub fn new() -> PInt { + PInt::default() + } +} + +impl NInt { + /// Instantiates a singleton representing this strictly negative integer. + #[inline] + pub fn new() -> NInt { + NInt::default() + } +} + +/// The type-level signed integer 0. +#[derive(Eq, PartialEq, Ord, PartialOrd, Clone, Copy, Hash, Debug, Default)] +#[cfg_attr(feature = "scale_info", derive(scale_info::TypeInfo))] +pub struct Z0; + +impl Z0 { + /// Instantiates a singleton representing the integer 0. + #[inline] + pub fn new() -> Z0 { + Z0 + } +} + +impl NonZero for PInt {} +impl NonZero for NInt {} +impl Zero for Z0 {} + +impl PowerOfTwo for PInt {} + +impl Integer for Z0 { + const I8: i8 = 0; + const I16: i16 = 0; + const I32: i32 = 0; + const I64: i64 = 0; + #[cfg(feature = "i128")] + const I128: i128 = 0; + const ISIZE: isize = 0; + + #[inline] + fn to_i8() -> i8 { + 0 + } + #[inline] + fn to_i16() -> i16 { + 0 + } + #[inline] + fn to_i32() -> i32 { + 0 + } + #[inline] + fn to_i64() -> i64 { + 0 + } + #[cfg(feature = "i128")] + #[inline] + fn to_i128() -> i128 { + 0 + } + #[inline] + fn to_isize() -> isize { + 0 + } +} + +impl Integer for PInt { + const I8: i8 = U::I8; + const I16: i16 = U::I16; + const I32: i32 = U::I32; + const I64: i64 = U::I64; + #[cfg(feature = "i128")] + const I128: i128 = U::I128; + const ISIZE: isize = U::ISIZE; + + #[inline] + fn to_i8() -> i8 { + ::to_i8() + } + #[inline] + fn to_i16() -> i16 { + ::to_i16() + } + #[inline] + fn to_i32() -> i32 { + ::to_i32() + } + #[inline] + fn to_i64() -> i64 { + ::to_i64() + } + #[cfg(feature = "i128")] + #[inline] + fn to_i128() -> i128 { + ::to_i128() + } + #[inline] + fn to_isize() -> isize { + ::to_isize() + } +} + +// Simply negating the result of e.g. `U::I8` will result in overflow for `std::i8::MIN`. Instead, +// we use the fact that `U: NonZero` by subtracting one from the `U::U8` before negating. +impl Integer for NInt { + const I8: i8 = -((U::U8 - 1) as i8) - 1; + const I16: i16 = -((U::U16 - 1) as i16) - 1; + const I32: i32 = -((U::U32 - 1) as i32) - 1; + const I64: i64 = -((U::U64 - 1) as i64) - 1; + #[cfg(feature = "i128")] + const I128: i128 = -((U::U128 - 1) as i128) - 1; + const ISIZE: isize = -((U::USIZE - 1) as isize) - 1; + + #[inline] + fn to_i8() -> i8 { + Self::I8 + } + #[inline] + fn to_i16() -> i16 { + Self::I16 + } + #[inline] + fn to_i32() -> i32 { + Self::I32 + } + #[inline] + fn to_i64() -> i64 { + Self::I64 + } + #[cfg(feature = "i128")] + #[inline] + fn to_i128() -> i128 { + Self::I128 + } + #[inline] + fn to_isize() -> isize { + Self::ISIZE + } +} + +// --------------------------------------------------------------------------------------- +// Neg + +/// `-Z0 = Z0` +impl Neg for Z0 { + type Output = Z0; + #[inline] + fn neg(self) -> Self::Output { + Z0 + } +} + +/// `-PInt = NInt` +impl Neg for PInt { + type Output = NInt; + #[inline] + fn neg(self) -> Self::Output { + NInt::new() + } +} + +/// `-NInt = PInt` +impl Neg for NInt { + type Output = PInt; + #[inline] + fn neg(self) -> Self::Output { + PInt::new() + } +} + +// --------------------------------------------------------------------------------------- +// Add + +/// `Z0 + I = I` +impl Add for Z0 { + type Output = I; + #[inline] + fn add(self, rhs: I) -> Self::Output { + rhs + } +} + +/// `PInt + Z0 = PInt` +impl Add for PInt { + type Output = PInt; + #[inline] + fn add(self, _: Z0) -> Self::Output { + PInt::new() + } +} + +/// `NInt + Z0 = NInt` +impl Add for NInt { + type Output = NInt; + #[inline] + fn add(self, _: Z0) -> Self::Output { + NInt::new() + } +} + +/// `P(Ul) + P(Ur) = P(Ul + Ur)` +impl Add> for PInt