diff --git a/collector/compile-benchmarks/README.md b/collector/compile-benchmarks/README.md index 7ec9a9f54..2bf8a10b8 100644 --- a/collector/compile-benchmarks/README.md +++ b/collector/compile-benchmarks/README.md @@ -53,6 +53,8 @@ They mostly consist of real-world crates. built with `--features=stm32f410` to have faster benchmarking times. - **syn-1.0.89**: A library for parsing Rust code. An important part of the Rust ecosystem. +- **typenum-1.17.0**: A library that encodes integer computation within the trait system. Serves as + a stress test for the trait solver, but at the same time it is also a very popular crate. - **unicode-normalization-0.1.19**: Unicode character composition and decomposition utilities. Uses huge `match` statements that stress the compiler in unusual ways. diff --git a/collector/compile-benchmarks/typenum-1.17.0/.cargo_vcs_info.json b/collector/compile-benchmarks/typenum-1.17.0/.cargo_vcs_info.json new file mode 100644 index 000000000..439e6b4c9 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.17.0/.cargo_vcs_info.json @@ -0,0 +1,6 @@ +{ + "git": { + "sha1": "b237efbb1da9646435274f63d7290cb7651b031f" + }, + "path_in_vcs": "" +} \ No newline at end of file diff --git a/collector/compile-benchmarks/typenum-1.17.0/.github/workflows/check.yml b/collector/compile-benchmarks/typenum-1.17.0/.github/workflows/check.yml new file mode 100644 index 000000000..4ee1472c7 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.17.0/.github/workflows/check.yml @@ -0,0 +1,96 @@ +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 + - 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 }} + - run: cargo test --verbose --features "strict" ${{ matrix.mb_const_generics }} + - run: cargo doc --features "strict" ${{ 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 + - run: cargo fmt --all -- --check + - run: cargo clippy -- -D warnings + # Allow deprecated because we test the no_std feature. + - run: cargo clippy --all-features -- -D warnings -A deprecated diff --git a/collector/compile-benchmarks/typenum-1.17.0/.github/workflows/publish.yml b/collector/compile-benchmarks/typenum-1.17.0/.github/workflows/publish.yml new file mode 100644 index 000000000..efc72c52a --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.17.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.17.0/.gitignore b/collector/compile-benchmarks/typenum-1.17.0/.gitignore new file mode 100644 index 000000000..d1d2032a5 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.17.0/.gitignore @@ -0,0 +1,5 @@ +target +Cargo.lock + +*.bk +*\~ diff --git a/collector/compile-benchmarks/typenum-1.17.0/0-add-fn.patch b/collector/compile-benchmarks/typenum-1.17.0/0-add-fn.patch new file mode 100644 index 000000000..e6a8a49f5 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.17.0/0-add-fn.patch @@ -0,0 +1,9 @@ +diff --git a/src/lib.rs b/src/lib.rs +index 7a40b2a0..1992946c 100644 +--- a/src/lib.rs ++++ b/src/lib.rs +@@ -196,3 +196,4 @@ mod sealed { + impl Sealed for ATerm {} + impl Sealed for TArr {} + } ++fn foo() { let a = 5; } diff --git a/collector/compile-benchmarks/typenum-1.17.0/CHANGELOG.md b/collector/compile-benchmarks/typenum-1.17.0/CHANGELOG.md new file mode 100644 index 000000000..e6b57c606 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.17.0/CHANGELOG.md @@ -0,0 +1,117 @@ +# 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 +- [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.17.0/Cargo.lock b/collector/compile-benchmarks/typenum-1.17.0/Cargo.lock new file mode 100644 index 000000000..373a73136 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.17.0/Cargo.lock @@ -0,0 +1,203 @@ +# This file is automatically @generated by Cargo. +# It is not intended for manual editing. +version = 3 + +[[package]] +name = "arrayvec" +version = "0.7.4" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711" + +[[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.17" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "4fb810d30a7c1953f91334de7244731fc3f3c10d7fe163338a35b9f640960321" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "equivalent" +version = "1.0.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5" + +[[package]] +name = "hashbrown" +version = "0.14.3" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "290f1a1d9242c78d09ce40a5e87e7554ee637af1351968159f4952f028f75604" + +[[package]] +name = "impl-trait-for-tuples" +version = "0.2.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "11d7a9f6330b71fea57921c9b61c47ee6e84f72d394754eff6163ae67e7395eb" +dependencies = [ + "proc-macro2", + "quote", + "syn", +] + +[[package]] +name = "indexmap" +version = "2.2.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "7b0b929d511467233429c45a44ac1dcaa21ba0f5ba11e4879e6ed28ddb4f9df4" +dependencies = [ + "equivalent", + "hashbrown", +] + +[[package]] +name = "memchr" +version = "2.7.1" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "523dc4f511e55ab87b694dc30d0f820d60906ef06413f93d4d7a1385599cc149" + +[[package]] +name = "once_cell" +version = "1.19.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3fdb12b2476b595f9358c5161aa467c2438859caa136dec86c26fdd2efe17b92" + +[[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", +] + +[[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.79" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "e835ff2298f5721608eb1a980ecaee1aef2c132bf95ecc026a11b7bf3c01c02e" +dependencies = [ + "unicode-ident", +] + +[[package]] +name = "quote" +version = "1.0.35" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "291ec9ab5efd934aaf503a6466c5d5251535d108ee747472c3977cc5acc868ef" +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", +] + +[[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 = "toml_datetime" +version = "0.6.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3550f4e9685620ac18a50ed434eb3aec30db8ba93b0287467bca5826ea25baf1" + +[[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.17.0" +dependencies = [ + "scale-info", +] + +[[package]] +name = "unicode-ident" +version = "1.0.12" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b" + +[[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.17.0/Cargo.toml b/collector/compile-benchmarks/typenum-1.17.0/Cargo.toml new file mode 100644 index 000000000..4c5b7baee --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.17.0/Cargo.toml @@ -0,0 +1,64 @@ +# 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.17.0" +authors = [ + "Paho Lurie-Gregg ", + "Andre Bogus ", +] +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" + +[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 = [] + +[workspace] \ No newline at end of file diff --git a/collector/compile-benchmarks/typenum-1.17.0/Cargo.toml.orig b/collector/compile-benchmarks/typenum-1.17.0/Cargo.toml.orig new file mode 100644 index 000000000..84bfeb743 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.17.0/Cargo.toml.orig @@ -0,0 +1,40 @@ +[package] +name = "typenum" +build = "build/main.rs" +version = "1.17.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"] diff --git a/collector/compile-benchmarks/typenum-1.17.0/LICENSE b/collector/compile-benchmarks/typenum-1.17.0/LICENSE new file mode 100644 index 000000000..364b7731c --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.17.0/LICENSE @@ -0,0 +1 @@ +MIT OR Apache-2.0 \ No newline at end of file diff --git a/collector/compile-benchmarks/typenum-1.17.0/LICENSE-APACHE b/collector/compile-benchmarks/typenum-1.17.0/LICENSE-APACHE new file mode 100644 index 000000000..4bf355c3e --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.17.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.17.0/LICENSE-MIT b/collector/compile-benchmarks/typenum-1.17.0/LICENSE-MIT new file mode 100644 index 000000000..e567a4d28 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.17.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.17.0/README.md b/collector/compile-benchmarks/typenum-1.17.0/README.md new file mode 100644 index 000000000..6b198775f --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.17.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.17.0/clippy.toml b/collector/compile-benchmarks/typenum-1.17.0/clippy.toml new file mode 100644 index 000000000..719c94d5d --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.17.0/clippy.toml @@ -0,0 +1 @@ +cognitive-complexity-threshold=35 diff --git a/collector/compile-benchmarks/typenum-1.17.0/perf-config.json b/collector/compile-benchmarks/typenum-1.17.0/perf-config.json new file mode 100644 index 000000000..f21443f22 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.17.0/perf-config.json @@ -0,0 +1,5 @@ +{ + "cargo_opts": "--features=i128,const-generics", + "artifact": "library", + "category": "primary" +} diff --git a/collector/compile-benchmarks/typenum-1.17.0/rustfmt.toml b/collector/compile-benchmarks/typenum-1.17.0/rustfmt.toml new file mode 100644 index 000000000..16bdde911 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.17.0/rustfmt.toml @@ -0,0 +1 @@ +format_code_in_doc_comments = true diff --git a/collector/compile-benchmarks/typenum-1.17.0/src/array.rs b/collector/compile-benchmarks/typenum-1.17.0/src/array.rs new file mode 100644 index 000000000..68693facf --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.17.0/src/array.rs @@ -0,0 +1,340 @@ +//! 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),+]> ); +} + +// --------------------------------------------------------------------------------------- +// 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 + } +} + +// --------------------------------------------------------------------------------------- +// 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.17.0/src/bit.rs b/collector/compile-benchmarks/typenum-1.17.0/src/bit.rs new file mode 100644 index 000000000..4a098fe84 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.17.0/src/bit.rs @@ -0,0 +1,337 @@ +//! 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(tests)] +mod tests { + // 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 ::Same<$Answer>>::Output; + assert_eq!(<$Answer as Bit>::to_u8(), ::to_u8()); + }}; + ($Lhs:ident $op:ident $Rhs:ident = $Answer:ident) => {{ + type Test = <<$Lhs as $op<$Rhs>>::Output as ::Same<$Answer>>::Output; + assert_eq!(<$Answer as 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 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.17.0/src/generated/consts.rs b/collector/compile-benchmarks/typenum-1.17.0/src/generated/consts.rs new file mode 100644 index 000000000..cbbb54664 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.17.0/src/generated/consts.rs @@ -0,0 +1,2248 @@ + +/** +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. +*/ +#[allow(missing_docs)] +pub mod consts { + use crate::uint::{UInt, UTerm}; + use crate::int::{PInt, NInt}; + + 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, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; + pub type P512 = PInt; pub type N512 = NInt; + pub type U513 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B1>; + pub type P513 = PInt; pub type N513 = NInt; + pub type U514 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B1>, B0>; + pub type P514 = PInt; pub type N514 = NInt; + pub type U515 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B1>, B1>; + pub type P515 = PInt; pub type N515 = NInt; + pub type U516 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B1>, B0>, B0>; + pub type P516 = PInt; pub type N516 = NInt; + pub type U517 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B1>, B0>, B1>; + pub type P517 = PInt; pub type N517 = NInt; + pub type U518 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B1>, B1>, B0>; + pub type P518 = PInt; pub type N518 = NInt; + pub type U519 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B1>, B1>, B1>; + pub type P519 = PInt; pub type N519 = NInt; + pub type U520 = UInt, B0>, B0>, B0>, B0>, B0>, B1>, B0>, B0>, B0>; + pub type P520 = PInt; pub type N520 = NInt; + pub type U521 = UInt, B0>, B0>, B0>, B0>, B0>, B1>, B0>, B0>, B1>; + pub type P521 = PInt; pub type N521 = NInt; + pub type U522 = UInt, B0>, B0>, B0>, B0>, B0>, B1>, B0>, B1>, B0>; + pub type P522 = PInt; pub type N522 = NInt; + pub type U523 = UInt, B0>, B0>, B0>, B0>, B0>, B1>, B0>, B1>, B1>; + pub type P523 = PInt; pub type N523 = NInt; + pub type U524 = UInt, B0>, B0>, B0>, B0>, B0>, B1>, B1>, B0>, B0>; + pub type P524 = PInt; pub type N524 = NInt; + pub type U525 = UInt, B0>, B0>, B0>, B0>, B0>, B1>, B1>, B0>, B1>; + pub type P525 = PInt; pub type N525 = NInt; + pub type U526 = UInt, B0>, B0>, B0>, B0>, B0>, B1>, B1>, B1>, B0>; + pub type P526 = PInt; pub type N526 = NInt; + pub type U527 = UInt, B0>, B0>, B0>, B0>, B0>, B1>, B1>, B1>, B1>; + pub type P527 = PInt; pub type N527 = NInt; + pub type U528 = UInt, B0>, B0>, B0>, B0>, B1>, B0>, B0>, B0>, B0>; + pub type P528 = PInt; pub type N528 = NInt; + pub type U529 = UInt, B0>, B0>, B0>, B0>, B1>, B0>, B0>, B0>, B1>; + pub type P529 = PInt; pub type N529 = NInt; + pub type U530 = UInt, B0>, B0>, B0>, B0>, B1>, B0>, B0>, B1>, B0>; + pub type P530 = PInt; pub type N530 = NInt; + pub type U531 = UInt, B0>, B0>, B0>, B0>, B1>, B0>, B0>, B1>, B1>; + pub type P531 = PInt; pub type N531 = NInt; + pub type U532 = UInt, B0>, B0>, B0>, B0>, B1>, B0>, B1>, B0>, B0>; + pub type P532 = PInt; pub type N532 = NInt; + pub type U533 = UInt, B0>, B0>, B0>, B0>, B1>, B0>, B1>, B0>, B1>; + pub type P533 = PInt; pub type N533 = NInt; + pub type U534 = UInt, B0>, B0>, B0>, B0>, B1>, B0>, B1>, B1>, B0>; + pub type P534 = PInt; pub type N534 = NInt; + pub type U535 = UInt, B0>, B0>, B0>, B0>, B1>, B0>, B1>, B1>, B1>; + pub type P535 = PInt; pub type N535 = NInt; + pub type U536 = UInt, B0>, B0>, B0>, B0>, B1>, B1>, B0>, B0>, B0>; + pub type P536 = PInt; pub type N536 = NInt; + pub type U537 = UInt, B0>, B0>, B0>, B0>, B1>, B1>, B0>, B0>, B1>; + pub type P537 = PInt; pub type N537 = NInt; + pub type U538 = UInt, B0>, B0>, B0>, B0>, B1>, B1>, B0>, B1>, B0>; + pub type P538 = PInt; pub type N538 = NInt; + pub type U539 = UInt, B0>, B0>, B0>, B0>, B1>, B1>, B0>, B1>, B1>; + pub type P539 = PInt; pub type N539 = NInt; + pub type U540 = UInt, B0>, B0>, B0>, B0>, B1>, B1>, B1>, B0>, B0>; + pub type P540 = PInt; pub type N540 = NInt; + pub type U541 = UInt, B0>, B0>, B0>, B0>, B1>, B1>, B1>, B0>, B1>; + pub type P541 = PInt; pub type N541 = NInt; + pub type U542 = UInt, B0>, B0>, B0>, B0>, B1>, B1>, B1>, B1>, B0>; + pub type P542 = PInt; pub type N542 = NInt; + pub type U543 = UInt, B0>, B0>, B0>, B0>, B1>, B1>, B1>, B1>, B1>; + pub type P543 = PInt; pub type N543 = NInt; + pub type U544 = UInt, B0>, B0>, B0>, B1>, B0>, B0>, B0>, B0>, B0>; + pub type P544 = PInt; pub type N544 = NInt; + pub type U545 = UInt, B0>, B0>, B0>, B1>, B0>, B0>, B0>, B0>, B1>; + pub type P545 = PInt; pub type N545 = NInt; + pub type U546 = UInt, B0>, B0>, B0>, B1>, B0>, B0>, B0>, B1>, B0>; + pub type P546 = PInt; pub type N546 = NInt; + pub type U547 = UInt, B0>, B0>, B0>, B1>, B0>, B0>, B0>, B1>, B1>; + pub type P547 = PInt; pub type N547 = NInt; + pub type U548 = UInt, B0>, B0>, B0>, B1>, B0>, B0>, B1>, B0>, B0>; + pub type P548 = PInt; pub type N548 = NInt; + pub type U549 = UInt, B0>, B0>, B0>, B1>, B0>, B0>, B1>, B0>, B1>; + pub type P549 = PInt; pub type N549 = NInt; + pub type U550 = UInt, B0>, B0>, B0>, B1>, B0>, B0>, B1>, B1>, B0>; + pub type P550 = PInt; pub type N550 = NInt; + pub type U551 = UInt, B0>, B0>, B0>, B1>, B0>, B0>, B1>, B1>, B1>; + pub type P551 = PInt; pub type N551 = NInt; + pub type U552 = UInt, B0>, B0>, B0>, B1>, B0>, B1>, B0>, B0>, B0>; + pub type P552 = PInt; pub type N552 = NInt; + pub type U553 = UInt, B0>, B0>, B0>, B1>, B0>, B1>, B0>, B0>, B1>; + pub type P553 = PInt; pub type N553 = NInt; + pub type U554 = UInt, B0>, B0>, B0>, B1>, B0>, B1>, B0>, B1>, B0>; + pub type P554 = PInt; pub type N554 = NInt; + pub type U555 = UInt, B0>, B0>, B0>, B1>, B0>, B1>, B0>, B1>, B1>; + pub type P555 = PInt; pub type N555 = NInt; + pub type U556 = UInt, B0>, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B0>; + pub type P556 = PInt; pub type N556 = NInt; + pub type U557 = UInt, B0>, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B1>; + pub type P557 = PInt; pub type N557 = NInt; + pub type U558 = UInt, B0>, B0>, B0>, B1>, B0>, B1>, B1>, B1>, B0>; + pub type P558 = PInt; pub type N558 = NInt; + pub type U559 = UInt, B0>, B0>, B0>, B1>, B0>, B1>, B1>, B1>, B1>; + pub type P559 = PInt; pub type N559 = NInt; + pub type U560 = UInt, B0>, B0>, B0>, B1>, B1>, B0>, B0>, B0>, B0>; + pub type P560 = PInt; pub type N560 = NInt; + pub type U561 = UInt, B0>, B0>, B0>, B1>, B1>, B0>, B0>, B0>, B1>; + pub type P561 = PInt; pub type N561 = NInt; + pub type U562 = UInt, B0>, B0>, B0>, B1>, B1>, B0>, B0>, B1>, B0>; + pub type P562 = PInt; pub type N562 = NInt; + pub type U563 = UInt, B0>, B0>, B0>, B1>, B1>, B0>, B0>, B1>, B1>; + pub type P563 = PInt; pub type N563 = NInt; + pub type U564 = UInt, B0>, B0>, B0>, B1>, B1>, B0>, B1>, B0>, B0>; + pub type P564 = PInt; pub type N564 = NInt; + pub type U565 = UInt, B0>, B0>, B0>, B1>, B1>, B0>, B1>, B0>, B1>; + pub type P565 = PInt; pub type N565 = NInt; + pub type U566 = UInt, B0>, B0>, B0>, B1>, B1>, B0>, B1>, B1>, B0>; + pub type P566 = PInt; pub type N566 = NInt; + pub type U567 = UInt, B0>, B0>, B0>, B1>, B1>, B0>, B1>, B1>, B1>; + pub type P567 = PInt; pub type N567 = NInt; + pub type U568 = UInt, B0>, B0>, B0>, B1>, B1>, B1>, B0>, B0>, B0>; + pub type P568 = PInt; pub type N568 = NInt; + pub type U569 = UInt, B0>, B0>, B0>, B1>, B1>, B1>, B0>, B0>, B1>; + pub type P569 = PInt; pub type N569 = NInt; + pub type U570 = UInt, B0>, B0>, B0>, B1>, B1>, B1>, B0>, B1>, B0>; + pub type P570 = PInt; pub type N570 = NInt; + pub type U571 = UInt, B0>, B0>, B0>, B1>, B1>, B1>, B0>, B1>, B1>; + pub type P571 = PInt; pub type N571 = NInt; + pub type U572 = UInt, B0>, B0>, B0>, B1>, B1>, B1>, B1>, B0>, B0>; + pub type P572 = PInt; pub type N572 = NInt; + pub type U573 = UInt, B0>, B0>, B0>, B1>, B1>, B1>, B1>, B0>, B1>; + pub type P573 = PInt; pub type N573 = NInt; + pub type U574 = UInt, B0>, B0>, B0>, B1>, B1>, B1>, B1>, B1>, B0>; + pub type P574 = PInt; pub type N574 = NInt; + pub type U575 = UInt, B0>, B0>, B0>, B1>, B1>, B1>, B1>, B1>, B1>; + pub type P575 = PInt; pub type N575 = NInt; + pub type U576 = UInt, B0>, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B0>; + pub type P576 = PInt; pub type N576 = NInt; + pub type U577 = UInt, B0>, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B1>; + pub type P577 = PInt; pub type N577 = NInt; + pub type U578 = UInt, B0>, B0>, B1>, B0>, B0>, B0>, B0>, B1>, B0>; + pub type P578 = PInt; pub type N578 = NInt; + pub type U579 = UInt, B0>, B0>, B1>, B0>, B0>, B0>, B0>, B1>, B1>; + pub type P579 = PInt; pub type N579 = NInt; + pub type U580 = UInt, B0>, B0>, B1>, B0>, B0>, B0>, B1>, B0>, B0>; + pub type P580 = PInt; pub type N580 = NInt; + pub type U581 = UInt, B0>, B0>, B1>, B0>, B0>, B0>, B1>, B0>, B1>; + pub type P581 = PInt; pub type N581 = NInt; + pub type U582 = UInt, B0>, B0>, B1>, B0>, B0>, B0>, B1>, B1>, B0>; + pub type P582 = PInt; pub type N582 = NInt; + pub type U583 = UInt, B0>, B0>, B1>, B0>, B0>, B0>, B1>, B1>, B1>; + pub type P583 = PInt; pub type N583 = NInt; + pub type U584 = UInt, B0>, B0>, B1>, B0>, B0>, B1>, B0>, B0>, B0>; + pub type P584 = PInt; pub type N584 = NInt; + pub type U585 = UInt, B0>, B0>, B1>, B0>, B0>, B1>, B0>, B0>, B1>; + pub type P585 = PInt; pub type N585 = NInt; + pub type U586 = UInt, B0>, B0>, B1>, B0>, B0>, B1>, B0>, B1>, B0>; + pub type P586 = PInt; pub type N586 = NInt; + pub type U587 = UInt, B0>, B0>, B1>, B0>, B0>, B1>, B0>, B1>, B1>; + pub type P587 = PInt; pub type N587 = NInt; + pub type U588 = UInt, B0>, B0>, B1>, B0>, B0>, B1>, B1>, B0>, B0>; + pub type P588 = PInt; pub type N588 = NInt; + pub type U589 = UInt, B0>, B0>, B1>, B0>, B0>, B1>, B1>, B0>, B1>; + pub type P589 = PInt; pub type N589 = NInt; + pub type U590 = UInt, B0>, B0>, B1>, B0>, B0>, B1>, B1>, B1>, B0>; + pub type P590 = PInt; pub type N590 = NInt; + pub type U591 = UInt, B0>, B0>, B1>, B0>, B0>, B1>, B1>, B1>, B1>; + pub type P591 = PInt; pub type N591 = NInt; + pub type U592 = UInt, B0>, B0>, B1>, B0>, B1>, B0>, B0>, B0>, B0>; + pub type P592 = PInt; pub type N592 = NInt; + pub type U593 = UInt, B0>, B0>, B1>, B0>, B1>, B0>, B0>, B0>, B1>; + pub type P593 = PInt; pub type N593 = NInt; + pub type U594 = UInt, B0>, B0>, B1>, B0>, B1>, B0>, B0>, B1>, B0>; + pub type P594 = PInt; pub type N594 = NInt; + pub type U595 = UInt, B0>, B0>, B1>, B0>, B1>, B0>, B0>, B1>, B1>; + pub type P595 = PInt; pub type N595 = NInt; + pub type U596 = UInt, B0>, B0>, B1>, B0>, B1>, B0>, B1>, B0>, B0>; + pub type P596 = PInt; pub type N596 = NInt; + pub type U597 = UInt, B0>, B0>, B1>, B0>, B1>, B0>, B1>, B0>, B1>; + pub type P597 = PInt; pub type N597 = NInt; + pub type U598 = UInt, B0>, B0>, B1>, B0>, B1>, B0>, B1>, B1>, B0>; + pub type P598 = PInt; pub type N598 = NInt; + pub type U599 = UInt, B0>, B0>, B1>, B0>, B1>, B0>, B1>, B1>, B1>; + pub type P599 = PInt; pub type N599 = NInt; + pub type U600 = UInt, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B0>, B0>; + pub type P600 = PInt; pub type N600 = NInt; + pub type U601 = UInt, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B0>, B1>; + pub type P601 = PInt; pub type N601 = NInt; + pub type U602 = UInt, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B1>, B0>; + pub type P602 = PInt; pub type N602 = NInt; + pub type U603 = UInt, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B1>, B1>; + pub type P603 = PInt; pub type N603 = NInt; + pub type U604 = UInt, B0>, B0>, B1>, B0>, B1>, B1>, B1>, B0>, B0>; + pub type P604 = PInt; pub type N604 = NInt; + pub type U605 = UInt, B0>, B0>, B1>, B0>, B1>, B1>, B1>, B0>, B1>; + pub type P605 = PInt; pub type N605 = NInt; + pub type U606 = UInt, B0>, B0>, B1>, B0>, B1>, B1>, B1>, B1>, B0>; + pub type P606 = PInt; pub type N606 = NInt; + pub type U607 = UInt, B0>, B0>, B1>, B0>, B1>, B1>, B1>, B1>, B1>; + pub type P607 = PInt; pub type N607 = NInt; + pub type U608 = UInt, B0>, B0>, B1>, B1>, B0>, B0>, B0>, B0>, B0>; + pub type P608 = PInt; pub type N608 = NInt; + pub type U609 = UInt, B0>, B0>, B1>, B1>, B0>, B0>, B0>, B0>, B1>; + pub type P609 = PInt; pub type N609 = NInt; + pub type U610 = UInt, B0>, B0>, B1>, B1>, B0>, B0>, B0>, B1>, B0>; + pub type P610 = PInt; pub type N610 = NInt; + pub type U611 = UInt, B0>, B0>, B1>, B1>, B0>, B0>, B0>, B1>, B1>; + pub type P611 = PInt; pub type N611 = NInt; + pub type U612 = UInt, B0>, B0>, B1>, B1>, B0>, B0>, B1>, B0>, B0>; + pub type P612 = PInt; pub type N612 = NInt; + pub type U613 = UInt, B0>, B0>, B1>, B1>, B0>, B0>, B1>, B0>, B1>; + pub type P613 = PInt; pub type N613 = NInt; + pub type U614 = UInt, B0>, B0>, B1>, B1>, B0>, B0>, B1>, B1>, B0>; + pub type P614 = PInt; pub type N614 = NInt; + pub type U615 = UInt, B0>, B0>, B1>, B1>, B0>, B0>, B1>, B1>, B1>; + pub type P615 = PInt; pub type N615 = NInt; + pub type U616 = UInt, B0>, B0>, B1>, B1>, B0>, B1>, B0>, B0>, B0>; + pub type P616 = PInt; pub type N616 = NInt; + pub type U617 = UInt, B0>, B0>, B1>, B1>, B0>, B1>, B0>, B0>, B1>; + pub type P617 = PInt; pub type N617 = NInt; + pub type U618 = UInt, B0>, B0>, B1>, B1>, B0>, B1>, B0>, B1>, B0>; + pub type P618 = PInt; pub type N618 = NInt; + pub type U619 = UInt, B0>, B0>, B1>, B1>, B0>, B1>, B0>, B1>, B1>; + pub type P619 = PInt; pub type N619 = NInt; + pub type U620 = UInt, B0>, B0>, B1>, B1>, B0>, B1>, B1>, B0>, B0>; + pub type P620 = PInt; pub type N620 = NInt; + pub type U621 = UInt, B0>, B0>, B1>, B1>, B0>, B1>, B1>, B0>, B1>; + pub type P621 = PInt; pub type N621 = NInt; + pub type U622 = UInt, B0>, B0>, B1>, B1>, B0>, B1>, B1>, B1>, B0>; + pub type P622 = PInt; pub type N622 = NInt; + pub type U623 = UInt, B0>, B0>, B1>, B1>, B0>, B1>, B1>, B1>, B1>; + pub type P623 = PInt; pub type N623 = NInt; + pub type U624 = UInt, B0>, B0>, B1>, B1>, B1>, B0>, B0>, B0>, B0>; + pub type P624 = PInt; pub type N624 = NInt; + pub type U625 = UInt, B0>, B0>, B1>, B1>, B1>, B0>, B0>, B0>, B1>; + pub type P625 = PInt; pub type N625 = NInt; + pub type U626 = UInt, B0>, B0>, B1>, B1>, B1>, B0>, B0>, B1>, B0>; + pub type P626 = PInt; pub type N626 = NInt; + pub type U627 = UInt, B0>, B0>, B1>, B1>, B1>, B0>, B0>, B1>, B1>; + pub type P627 = PInt; pub type N627 = NInt; + pub type U628 = UInt, B0>, B0>, B1>, B1>, B1>, B0>, B1>, B0>, B0>; + pub type P628 = PInt; pub type N628 = NInt; + pub type U629 = UInt, B0>, B0>, B1>, B1>, B1>, B0>, B1>, B0>, B1>; + pub type P629 = PInt; pub type N629 = NInt; + pub type U630 = UInt, B0>, B0>, B1>, B1>, B1>, B0>, B1>, B1>, B0>; + pub type P630 = PInt; pub type N630 = NInt; + pub type U631 = UInt, B0>, B0>, B1>, B1>, B1>, B0>, B1>, B1>, B1>; + pub type P631 = PInt; pub type N631 = NInt; + pub type U632 = UInt, B0>, B0>, B1>, B1>, B1>, B1>, B0>, B0>, B0>; + pub type P632 = PInt; pub type N632 = NInt; + pub type U633 = UInt, B0>, B0>, B1>, B1>, B1>, B1>, B0>, B0>, B1>; + pub type P633 = PInt; pub type N633 = NInt; + pub type U634 = UInt, B0>, B0>, B1>, B1>, B1>, B1>, B0>, B1>, B0>; + pub type P634 = PInt; pub type N634 = NInt; + pub type U635 = UInt, B0>, B0>, B1>, B1>, B1>, B1>, B0>, B1>, B1>; + pub type P635 = PInt; pub type N635 = NInt; + pub type U636 = UInt, B0>, B0>, B1>, B1>, B1>, B1>, B1>, B0>, B0>; + pub type P636 = PInt; pub type N636 = NInt; + pub type U637 = UInt, B0>, B0>, B1>, B1>, B1>, B1>, B1>, B0>, B1>; + pub type P637 = PInt; pub type N637 = NInt; + pub type U638 = UInt, B0>, B0>, B1>, B1>, B1>, B1>, B1>, B1>, B0>; + pub type P638 = PInt; pub type N638 = NInt; + pub type U639 = UInt, B0>, B0>, B1>, B1>, B1>, B1>, B1>, B1>, B1>; + pub type P639 = PInt; pub type N639 = NInt; + pub type U640 = UInt, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; + pub type P640 = PInt; pub type N640 = NInt; + pub type U641 = UInt, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B1>; + pub type P641 = PInt; pub type N641 = NInt; + pub type U642 = UInt, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B1>, B0>; + pub type P642 = PInt; pub type N642 = NInt; + pub type U643 = UInt, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B1>, B1>; + pub type P643 = PInt; pub type N643 = NInt; + pub type U644 = UInt, B0>, B1>, B0>, B0>, B0>, B0>, B1>, B0>, B0>; + pub type P644 = PInt; pub type N644 = NInt; + pub type U645 = UInt, B0>, B1>, B0>, B0>, B0>, B0>, B1>, B0>, B1>; + pub type P645 = PInt; pub type N645 = NInt; + pub type U646 = UInt, B0>, B1>, B0>, B0>, B0>, B0>, B1>, B1>, B0>; + pub type P646 = PInt; pub type N646 = NInt; + pub type U647 = UInt, B0>, B1>, B0>, B0>, B0>, B0>, B1>, B1>, B1>; + pub type P647 = PInt; pub type N647 = NInt; + pub type U648 = UInt, B0>, B1>, B0>, B0>, B0>, B1>, B0>, B0>, B0>; + pub type P648 = PInt; pub type N648 = NInt; + pub type U649 = UInt, B0>, B1>, B0>, B0>, B0>, B1>, B0>, B0>, B1>; + pub type P649 = PInt; pub type N649 = NInt; + pub type U650 = UInt, B0>, B1>, B0>, B0>, B0>, B1>, B0>, B1>, B0>; + pub type P650 = PInt; pub type N650 = NInt; + pub type U651 = UInt, B0>, B1>, B0>, B0>, B0>, B1>, B0>, B1>, B1>; + pub type P651 = PInt; pub type N651 = NInt; + pub type U652 = UInt, B0>, B1>, B0>, B0>, B0>, B1>, B1>, B0>, B0>; + pub type P652 = PInt; pub type N652 = NInt; + pub type U653 = UInt, B0>, B1>, B0>, B0>, B0>, B1>, B1>, B0>, B1>; + pub type P653 = PInt; pub type N653 = NInt; + pub type U654 = UInt, B0>, B1>, B0>, B0>, B0>, B1>, B1>, B1>, B0>; + pub type P654 = PInt; pub type N654 = NInt; + pub type U655 = UInt, B0>, B1>, B0>, B0>, B0>, B1>, B1>, B1>, B1>; + pub type P655 = PInt; pub type N655 = NInt; + pub type U656 = UInt, B0>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0>; + pub type P656 = PInt; pub type N656 = NInt; + pub type U657 = UInt, B0>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B1>; + pub type P657 = PInt; pub type N657 = NInt; + pub type U658 = UInt, B0>, B1>, B0>, B0>, B1>, B0>, B0>, B1>, B0>; + pub type P658 = PInt; pub type N658 = NInt; + pub type U659 = UInt, B0>, B1>, B0>, B0>, B1>, B0>, B0>, B1>, B1>; + pub type P659 = PInt; pub type N659 = NInt; + pub type U660 = UInt, B0>, B1>, B0>, B0>, B1>, B0>, B1>, B0>, B0>; + pub type P660 = PInt; pub type N660 = NInt; + pub type U661 = UInt, B0>, B1>, B0>, B0>, B1>, B0>, B1>, B0>, B1>; + pub type P661 = PInt; pub type N661 = NInt; + pub type U662 = UInt, B0>, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B0>; + pub type P662 = PInt; pub type N662 = NInt; + pub type U663 = UInt, B0>, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B1>; + pub type P663 = PInt; pub type N663 = NInt; + pub type U664 = UInt, B0>, B1>, B0>, B0>, B1>, B1>, B0>, B0>, B0>; + pub type P664 = PInt; pub type N664 = NInt; + pub type U665 = UInt, B0>, B1>, B0>, B0>, B1>, B1>, B0>, B0>, B1>; + pub type P665 = PInt; pub type N665 = NInt; + pub type U666 = UInt, B0>, B1>, B0>, B0>, B1>, B1>, B0>, B1>, B0>; + pub type P666 = PInt; pub type N666 = NInt; + pub type U667 = UInt, B0>, B1>, B0>, B0>, B1>, B1>, B0>, B1>, B1>; + pub type P667 = PInt; pub type N667 = NInt; + pub type U668 = UInt, B0>, B1>, B0>, B0>, B1>, B1>, B1>, B0>, B0>; + pub type P668 = PInt; pub type N668 = NInt; + pub type U669 = UInt, B0>, B1>, B0>, B0>, B1>, B1>, B1>, B0>, B1>; + pub type P669 = PInt; pub type N669 = NInt; + pub type U670 = UInt, B0>, B1>, B0>, B0>, B1>, B1>, B1>, B1>, B0>; + pub type P670 = PInt; pub type N670 = NInt; + pub type U671 = UInt, B0>, B1>, B0>, B0>, B1>, B1>, B1>, B1>, B1>; + pub type P671 = PInt; pub type N671 = NInt; + pub type U672 = UInt, B0>, B1>, B0>, B1>, B0>, B0>, B0>, B0>, B0>; + pub type P672 = PInt; pub type N672 = NInt; + pub type U673 = UInt, B0>, B1>, B0>, B1>, B0>, B0>, B0>, B0>, B1>; + pub type P673 = PInt; pub type N673 = NInt; + pub type U674 = UInt, B0>, B1>, B0>, B1>, B0>, B0>, B0>, B1>, B0>; + pub type P674 = PInt; pub type N674 = NInt; + pub type U675 = UInt, B0>, B1>, B0>, B1>, B0>, B0>, B0>, B1>, B1>; + pub type P675 = PInt; pub type N675 = NInt; + pub type U676 = UInt, B0>, B1>, B0>, B1>, B0>, B0>, B1>, B0>, B0>; + pub type P676 = PInt; pub type N676 = NInt; + pub type U677 = UInt, B0>, B1>, B0>, B1>, B0>, B0>, B1>, B0>, B1>; + pub type P677 = PInt; pub type N677 = NInt; + pub type U678 = UInt, B0>, B1>, B0>, B1>, B0>, B0>, B1>, B1>, B0>; + pub type P678 = PInt; pub type N678 = NInt; + pub type U679 = UInt, B0>, B1>, B0>, B1>, B0>, B0>, B1>, B1>, B1>; + pub type P679 = PInt; pub type N679 = NInt; + pub type U680 = UInt, B0>, B1>, B0>, B1>, B0>, B1>, B0>, B0>, B0>; + pub type P680 = PInt; pub type N680 = NInt; + pub type U681 = UInt, B0>, B1>, B0>, B1>, B0>, B1>, B0>, B0>, B1>; + pub type P681 = PInt; pub type N681 = NInt; + pub type U682 = UInt, B0>, B1>, B0>, B1>, B0>, B1>, B0>, B1>, B0>; + pub type P682 = PInt; pub type N682 = NInt; + pub type U683 = UInt, B0>, B1>, B0>, B1>, B0>, B1>, B0>, B1>, B1>; + pub type P683 = PInt; pub type N683 = NInt; + pub type U684 = UInt, B0>, B1>, B0>, B1>, B0>, B1>, B1>, B0>, B0>; + pub type P684 = PInt; pub type N684 = NInt; + pub type U685 = UInt, B0>, B1>, B0>, B1>, B0>, B1>, B1>, B0>, B1>; + pub type P685 = PInt; pub type N685 = NInt; + pub type U686 = UInt, B0>, B1>, B0>, B1>, B0>, B1>, B1>, B1>, B0>; + pub type P686 = PInt; pub type N686 = NInt; + pub type U687 = UInt, B0>, B1>, B0>, B1>, B0>, B1>, B1>, B1>, B1>; + pub type P687 = PInt; pub type N687 = NInt; + pub type U688 = UInt, B0>, B1>, B0>, B1>, B1>, B0>, B0>, B0>, B0>; + pub type P688 = PInt; pub type N688 = NInt; + pub type U689 = UInt, B0>, B1>, B0>, B1>, B1>, B0>, B0>, B0>, B1>; + pub type P689 = PInt; pub type N689 = NInt; + pub type U690 = UInt, B0>, B1>, B0>, B1>, B1>, B0>, B0>, B1>, B0>; + pub type P690 = PInt; pub type N690 = NInt; + pub type U691 = UInt, B0>, B1>, B0>, B1>, B1>, B0>, B0>, B1>, B1>; + pub type P691 = PInt; pub type N691 = NInt; + pub type U692 = UInt, B0>, B1>, B0>, B1>, B1>, B0>, B1>, B0>, B0>; + pub type P692 = PInt; pub type N692 = NInt; + pub type U693 = UInt, B0>, B1>, B0>, B1>, B1>, B0>, B1>, B0>, B1>; + pub type P693 = PInt; pub type N693 = NInt; + pub type U694 = UInt, B0>, B1>, B0>, B1>, B1>, B0>, B1>, B1>, B0>; + pub type P694 = PInt; pub type N694 = NInt; + pub type U695 = UInt, B0>, B1>, B0>, B1>, B1>, B0>, B1>, B1>, B1>; + pub type P695 = PInt; pub type N695 = NInt; + pub type U696 = UInt, B0>, B1>, B0>, B1>, B1>, B1>, B0>, B0>, B0>; + pub type P696 = PInt; pub type N696 = NInt; + pub type U697 = UInt, B0>, B1>, B0>, B1>, B1>, B1>, B0>, B0>, B1>; + pub type P697 = PInt; pub type N697 = NInt; + pub type U698 = UInt, B0>, B1>, B0>, B1>, B1>, B1>, B0>, B1>, B0>; + pub type P698 = PInt; pub type N698 = NInt; + pub type U699 = UInt, B0>, B1>, B0>, B1>, B1>, B1>, B0>, B1>, B1>; + pub type P699 = PInt; pub type N699 = NInt; + pub type U700 = UInt, B0>, B1>, B0>, B1>, B1>, B1>, B1>, B0>, B0>; + pub type P700 = PInt; pub type N700 = NInt; + pub type U701 = UInt, B0>, B1>, B0>, B1>, B1>, B1>, B1>, B0>, B1>; + pub type P701 = PInt; pub type N701 = NInt; + pub type U702 = UInt, B0>, B1>, B0>, B1>, B1>, B1>, B1>, B1>, B0>; + pub type P702 = PInt; pub type N702 = NInt; + pub type U703 = UInt, B0>, B1>, B0>, B1>, B1>, B1>, B1>, B1>, B1>; + pub type P703 = PInt; pub type N703 = NInt; + pub type U704 = UInt, B0>, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0>; + pub type P704 = PInt; pub type N704 = NInt; + pub type U705 = UInt, B0>, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B1>; + pub type P705 = PInt; pub type N705 = NInt; + pub type U706 = UInt, B0>, B1>, B1>, B0>, B0>, B0>, B0>, B1>, B0>; + pub type P706 = PInt; pub type N706 = NInt; + pub type U707 = UInt, B0>, B1>, B1>, B0>, B0>, B0>, B0>, B1>, B1>; + pub type P707 = PInt; pub type N707 = NInt; + pub type U708 = UInt, B0>, B1>, B1>, B0>, B0>, B0>, B1>, B0>, B0>; + pub type P708 = PInt; pub type N708 = NInt; + pub type U709 = UInt, B0>, B1>, B1>, B0>, B0>, B0>, B1>, B0>, B1>; + pub type P709 = PInt; pub type N709 = NInt; + pub type U710 = UInt, B0>, B1>, B1>, B0>, B0>, B0>, B1>, B1>, B0>; + pub type P710 = PInt; pub type N710 = NInt; + pub type U711 = UInt, B0>, B1>, B1>, B0>, B0>, B0>, B1>, B1>, B1>; + pub type P711 = PInt; pub type N711 = NInt; + pub type U712 = UInt, B0>, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>; + pub type P712 = PInt; pub type N712 = NInt; + pub type U713 = UInt, B0>, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B1>; + pub type P713 = PInt; pub type N713 = NInt; + pub type U714 = UInt, B0>, B1>, B1>, B0>, B0>, B1>, B0>, B1>, B0>; + pub type P714 = PInt; pub type N714 = NInt; + pub type U715 = UInt, B0>, B1>, B1>, B0>, B0>, B1>, B0>, B1>, B1>; + pub type P715 = PInt; pub type N715 = NInt; + pub type U716 = UInt, B0>, B1>, B1>, B0>, B0>, B1>, B1>, B0>, B0>; + pub type P716 = PInt; pub type N716 = NInt; + pub type U717 = UInt, B0>, B1>, B1>, B0>, B0>, B1>, B1>, B0>, B1>; + pub type P717 = PInt; pub type N717 = NInt; + pub type U718 = UInt, B0>, B1>, B1>, B0>, B0>, B1>, B1>, B1>, B0>; + pub type P718 = PInt; pub type N718 = NInt; + pub type U719 = UInt, B0>, B1>, B1>, B0>, B0>, B1>, B1>, B1>, B1>; + pub type P719 = PInt; pub type N719 = NInt; + pub type U720 = UInt, B0>, B1>, B1>, B0>, B1>, B0>, B0>, B0>, B0>; + pub type P720 = PInt; pub type N720 = NInt; + pub type U721 = UInt, B0>, B1>, B1>, B0>, B1>, B0>, B0>, B0>, B1>; + pub type P721 = PInt; pub type N721 = NInt; + pub type U722 = UInt, B0>, B1>, B1>, B0>, B1>, B0>, B0>, B1>, B0>; + pub type P722 = PInt; pub type N722 = NInt; + pub type U723 = UInt, B0>, B1>, B1>, B0>, B1>, B0>, B0>, B1>, B1>; + pub type P723 = PInt; pub type N723 = NInt; + pub type U724 = UInt, B0>, B1>, B1>, B0>, B1>, B0>, B1>, B0>, B0>; + pub type P724 = PInt; pub type N724 = NInt; + pub type U725 = UInt, B0>, B1>, B1>, B0>, B1>, B0>, B1>, B0>, B1>; + pub type P725 = PInt; pub type N725 = NInt; + pub type U726 = UInt, B0>, B1>, B1>, B0>, B1>, B0>, B1>, B1>, B0>; + pub type P726 = PInt; pub type N726 = NInt; + pub type U727 = UInt, B0>, B1>, B1>, B0>, B1>, B0>, B1>, B1>, B1>; + pub type P727 = PInt; pub type N727 = NInt; + pub type U728 = UInt, B0>, B1>, B1>, B0>, B1>, B1>, B0>, B0>, B0>; + pub type P728 = PInt; pub type N728 = NInt; + pub type U729 = UInt, B0>, B1>, B1>, B0>, B1>, B1>, B0>, B0>, B1>; + pub type P729 = PInt; pub type N729 = NInt; + pub type U730 = UInt, B0>, B1>, B1>, B0>, B1>, B1>, B0>, B1>, B0>; + pub type P730 = PInt; pub type N730 = NInt; + pub type U731 = UInt, B0>, B1>, B1>, B0>, B1>, B1>, B0>, B1>, B1>; + pub type P731 = PInt; pub type N731 = NInt; + pub type U732 = UInt, B0>, B1>, B1>, B0>, B1>, B1>, B1>, B0>, B0>; + pub type P732 = PInt; pub type N732 = NInt; + pub type U733 = UInt, B0>, B1>, B1>, B0>, B1>, B1>, B1>, B0>, B1>; + pub type P733 = PInt; pub type N733 = NInt; + pub type U734 = UInt, B0>, B1>, B1>, B0>, B1>, B1>, B1>, B1>, B0>; + pub type P734 = PInt; pub type N734 = NInt; + pub type U735 = UInt, B0>, B1>, B1>, B0>, B1>, B1>, B1>, B1>, B1>; + pub type P735 = PInt; pub type N735 = NInt; + pub type U736 = UInt, B0>, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B0>; + pub type P736 = PInt; pub type N736 = NInt; + pub type U737 = UInt, B0>, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B1>; + pub type P737 = PInt; pub type N737 = NInt; + pub type U738 = UInt, B0>, B1>, B1>, B1>, B0>, B0>, B0>, B1>, B0>; + pub type P738 = PInt; pub type N738 = NInt; + pub type U739 = UInt, B0>, B1>, B1>, B1>, B0>, B0>, B0>, B1>, B1>; + pub type P739 = PInt; pub type N739 = NInt; + pub type U740 = UInt, B0>, B1>, B1>, B1>, B0>, B0>, B1>, B0>, B0>; + pub type P740 = PInt; pub type N740 = NInt; + pub type U741 = UInt, B0>, B1>, B1>, B1>, B0>, B0>, B1>, B0>, B1>; + pub type P741 = PInt; pub type N741 = NInt; + pub type U742 = UInt, B0>, B1>, B1>, B1>, B0>, B0>, B1>, B1>, B0>; + pub type P742 = PInt; pub type N742 = NInt; + pub type U743 = UInt, B0>, B1>, B1>, B1>, B0>, B0>, B1>, B1>, B1>; + pub type P743 = PInt; pub type N743 = NInt; + pub type U744 = UInt, B0>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B0>; + pub type P744 = PInt; pub type N744 = NInt; + pub type U745 = UInt, B0>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B1>; + pub type P745 = PInt; pub type N745 = NInt; + pub type U746 = UInt, B0>, B1>, B1>, B1>, B0>, B1>, B0>, B1>, B0>; + pub type P746 = PInt; pub type N746 = NInt; + pub type U747 = UInt, B0>, B1>, B1>, B1>, B0>, B1>, B0>, B1>, B1>; + pub type P747 = PInt; pub type N747 = NInt; + pub type U748 = UInt, B0>, B1>, B1>, B1>, B0>, B1>, B1>, B0>, B0>; + pub type P748 = PInt; pub type N748 = NInt; + pub type U749 = UInt, B0>, B1>, B1>, B1>, B0>, B1>, B1>, B0>, B1>; + pub type P749 = PInt; pub type N749 = NInt; + pub type U750 = UInt, B0>, B1>, B1>, B1>, B0>, B1>, B1>, B1>, B0>; + pub type P750 = PInt; pub type N750 = NInt; + pub type U751 = UInt, B0>, B1>, B1>, B1>, B0>, B1>, B1>, B1>, B1>; + pub type P751 = PInt; pub type N751 = NInt; + pub type U752 = UInt, B0>, B1>, B1>, B1>, B1>, B0>, B0>, B0>, B0>; + pub type P752 = PInt; pub type N752 = NInt; + pub type U753 = UInt, B0>, B1>, B1>, B1>, B1>, B0>, B0>, B0>, B1>; + pub type P753 = PInt; pub type N753 = NInt; + pub type U754 = UInt, B0>, B1>, B1>, B1>, B1>, B0>, B0>, B1>, B0>; + pub type P754 = PInt; pub type N754 = NInt; + pub type U755 = UInt, B0>, B1>, B1>, B1>, B1>, B0>, B0>, B1>, B1>; + pub type P755 = PInt; pub type N755 = NInt; + pub type U756 = UInt, B0>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>; + pub type P756 = PInt; pub type N756 = NInt; + pub type U757 = UInt, B0>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B1>; + pub type P757 = PInt; pub type N757 = NInt; + pub type U758 = UInt, B0>, B1>, B1>, B1>, B1>, B0>, B1>, B1>, B0>; + pub type P758 = PInt; pub type N758 = NInt; + pub type U759 = UInt, B0>, B1>, B1>, B1>, B1>, B0>, B1>, B1>, B1>; + pub type P759 = PInt; pub type N759 = NInt; + pub type U760 = UInt, B0>, B1>, B1>, B1>, B1>, B1>, B0>, B0>, B0>; + pub type P760 = PInt; pub type N760 = NInt; + pub type U761 = UInt, B0>, B1>, B1>, B1>, B1>, B1>, B0>, B0>, B1>; + pub type P761 = PInt; pub type N761 = NInt; + pub type U762 = UInt, B0>, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>; + pub type P762 = PInt; pub type N762 = NInt; + pub type U763 = UInt, B0>, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B1>; + pub type P763 = PInt; pub type N763 = NInt; + pub type U764 = UInt, B0>, B1>, B1>, B1>, B1>, B1>, B1>, B0>, B0>; + pub type P764 = PInt; pub type N764 = NInt; + pub type U765 = UInt, B0>, B1>, B1>, B1>, B1>, B1>, B1>, B0>, B1>; + pub type P765 = PInt; pub type N765 = NInt; + pub type U766 = UInt, B0>, B1>, B1>, B1>, B1>, B1>, B1>, B1>, B0>; + pub type P766 = PInt; pub type N766 = NInt; + pub type U767 = UInt, B0>, B1>, B1>, B1>, B1>, B1>, B1>, B1>, B1>; + pub type P767 = PInt; pub type N767 = NInt; + pub type U768 = UInt, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; + pub type P768 = PInt; pub type N768 = NInt; + pub type U769 = UInt, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B1>; + pub type P769 = PInt; pub type N769 = NInt; + pub type U770 = UInt, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B1>, B0>; + pub type P770 = PInt; pub type N770 = NInt; + pub type U771 = UInt, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B1>, B1>; + pub type P771 = PInt; pub type N771 = NInt; + pub type U772 = UInt, B1>, B0>, B0>, B0>, B0>, B0>, B1>, B0>, B0>; + pub type P772 = PInt; pub type N772 = NInt; + pub type U773 = UInt, B1>, B0>, B0>, B0>, B0>, B0>, B1>, B0>, B1>; + pub type P773 = PInt; pub type N773 = NInt; + pub type U774 = UInt, B1>, B0>, B0>, B0>, B0>, B0>, B1>, B1>, B0>; + pub type P774 = PInt; pub type N774 = NInt; + pub type U775 = UInt, B1>, B0>, B0>, B0>, B0>, B0>, B1>, B1>, B1>; + pub type P775 = PInt; pub type N775 = NInt; + pub type U776 = UInt, B1>, B0>, B0>, B0>, B0>, B1>, B0>, B0>, B0>; + pub type P776 = PInt; pub type N776 = NInt; + pub type U777 = UInt, B1>, B0>, B0>, B0>, B0>, B1>, B0>, B0>, B1>; + pub type P777 = PInt; pub type N777 = NInt; + pub type U778 = UInt, B1>, B0>, B0>, B0>, B0>, B1>, B0>, B1>, B0>; + pub type P778 = PInt; pub type N778 = NInt; + pub type U779 = UInt, B1>, B0>, B0>, B0>, B0>, B1>, B0>, B1>, B1>; + pub type P779 = PInt; pub type N779 = NInt; + pub type U780 = UInt, B1>, B0>, B0>, B0>, B0>, B1>, B1>, B0>, B0>; + pub type P780 = PInt; pub type N780 = NInt; + pub type U781 = UInt, B1>, B0>, B0>, B0>, B0>, B1>, B1>, B0>, B1>; + pub type P781 = PInt; pub type N781 = NInt; + pub type U782 = UInt, B1>, B0>, B0>, B0>, B0>, B1>, B1>, B1>, B0>; + pub type P782 = PInt; pub type N782 = NInt; + pub type U783 = UInt, B1>, B0>, B0>, B0>, B0>, B1>, B1>, B1>, B1>; + pub type P783 = PInt; pub type N783 = NInt; + pub type U784 = UInt, B1>, B0>, B0>, B0>, B1>, B0>, B0>, B0>, B0>; + pub type P784 = PInt; pub type N784 = NInt; + pub type U785 = UInt, B1>, B0>, B0>, B0>, B1>, B0>, B0>, B0>, B1>; + pub type P785 = PInt; pub type N785 = NInt; + pub type U786 = UInt, B1>, B0>, B0>, B0>, B1>, B0>, B0>, B1>, B0>; + pub type P786 = PInt; pub type N786 = NInt; + pub type U787 = UInt, B1>, B0>, B0>, B0>, B1>, B0>, B0>, B1>, B1>; + pub type P787 = PInt; pub type N787 = NInt; + pub type U788 = UInt, B1>, B0>, B0>, B0>, B1>, B0>, B1>, B0>, B0>; + pub type P788 = PInt; pub type N788 = NInt; + pub type U789 = UInt, B1>, B0>, B0>, B0>, B1>, B0>, B1>, B0>, B1>; + pub type P789 = PInt; pub type N789 = NInt; + pub type U790 = UInt, B1>, B0>, B0>, B0>, B1>, B0>, B1>, B1>, B0>; + pub type P790 = PInt; pub type N790 = NInt; + pub type U791 = UInt, B1>, B0>, B0>, B0>, B1>, B0>, B1>, B1>, B1>; + pub type P791 = PInt; pub type N791 = NInt; + pub type U792 = UInt, B1>, B0>, B0>, B0>, B1>, B1>, B0>, B0>, B0>; + pub type P792 = PInt; pub type N792 = NInt; + pub type U793 = UInt, B1>, B0>, B0>, B0>, B1>, B1>, B0>, B0>, B1>; + pub type P793 = PInt; pub type N793 = NInt; + pub type U794 = UInt, B1>, B0>, B0>, B0>, B1>, B1>, B0>, B1>, B0>; + pub type P794 = PInt; pub type N794 = NInt; + pub type U795 = UInt, B1>, B0>, B0>, B0>, B1>, B1>, B0>, B1>, B1>; + pub type P795 = PInt; pub type N795 = NInt; + pub type U796 = UInt, B1>, B0>, B0>, B0>, B1>, B1>, B1>, B0>, B0>; + pub type P796 = PInt; pub type N796 = NInt; + pub type U797 = UInt, B1>, B0>, B0>, B0>, B1>, B1>, B1>, B0>, B1>; + pub type P797 = PInt; pub type N797 = NInt; + pub type U798 = UInt, B1>, B0>, B0>, B0>, B1>, B1>, B1>, B1>, B0>; + pub type P798 = PInt; pub type N798 = NInt; + pub type U799 = UInt, B1>, B0>, B0>, B0>, B1>, B1>, B1>, B1>, B1>; + pub type P799 = PInt; pub type N799 = NInt; + pub type U800 = UInt, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0>, B0>; + pub type P800 = PInt; pub type N800 = NInt; + pub type U801 = UInt, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0>, B1>; + pub type P801 = PInt; pub type N801 = NInt; + pub type U802 = UInt, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B1>, B0>; + pub type P802 = PInt; pub type N802 = NInt; + pub type U803 = UInt, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B1>, B1>; + pub type P803 = PInt; pub type N803 = NInt; + pub type U804 = UInt, B1>, B0>, B0>, B1>, B0>, B0>, B1>, B0>, B0>; + pub type P804 = PInt; pub type N804 = NInt; + pub type U805 = UInt, B1>, B0>, B0>, B1>, B0>, B0>, B1>, B0>, B1>; + pub type P805 = PInt; pub type N805 = NInt; + pub type U806 = UInt, B1>, B0>, B0>, B1>, B0>, B0>, B1>, B1>, B0>; + pub type P806 = PInt; pub type N806 = NInt; + pub type U807 = UInt, B1>, B0>, B0>, B1>, B0>, B0>, B1>, B1>, B1>; + pub type P807 = PInt; pub type N807 = NInt; + pub type U808 = UInt, B1>, B0>, B0>, B1>, B0>, B1>, B0>, B0>, B0>; + pub type P808 = PInt; pub type N808 = NInt; + pub type U809 = UInt, B1>, B0>, B0>, B1>, B0>, B1>, B0>, B0>, B1>; + pub type P809 = PInt; pub type N809 = NInt; + pub type U810 = UInt, B1>, B0>, B0>, B1>, B0>, B1>, B0>, B1>, B0>; + pub type P810 = PInt; pub type N810 = NInt; + pub type U811 = UInt, B1>, B0>, B0>, B1>, B0>, B1>, B0>, B1>, B1>; + pub type P811 = PInt; pub type N811 = NInt; + pub type U812 = UInt, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B0>; + pub type P812 = PInt; pub type N812 = NInt; + pub type U813 = UInt, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B0>, B1>; + pub type P813 = PInt; pub type N813 = NInt; + pub type U814 = UInt, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B1>, B0>; + pub type P814 = PInt; pub type N814 = NInt; + pub type U815 = UInt, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B1>, B1>; + pub type P815 = PInt; pub type N815 = NInt; + pub type U816 = UInt, B1>, B0>, B0>, B1>, B1>, B0>, B0>, B0>, B0>; + pub type P816 = PInt; pub type N816 = NInt; + pub type U817 = UInt, B1>, B0>, B0>, B1>, B1>, B0>, B0>, B0>, B1>; + pub type P817 = PInt; pub type N817 = NInt; + pub type U818 = UInt, B1>, B0>, B0>, B1>, B1>, B0>, B0>, B1>, B0>; + pub type P818 = PInt; pub type N818 = NInt; + pub type U819 = UInt, B1>, B0>, B0>, B1>, B1>, B0>, B0>, B1>, B1>; + pub type P819 = PInt; pub type N819 = NInt; + pub type U820 = UInt, B1>, B0>, B0>, B1>, B1>, B0>, B1>, B0>, B0>; + pub type P820 = PInt; pub type N820 = NInt; + pub type U821 = UInt, B1>, B0>, B0>, B1>, B1>, B0>, B1>, B0>, B1>; + pub type P821 = PInt; pub type N821 = NInt; + pub type U822 = UInt, B1>, B0>, B0>, B1>, B1>, B0>, B1>, B1>, B0>; + pub type P822 = PInt; pub type N822 = NInt; + pub type U823 = UInt, B1>, B0>, B0>, B1>, B1>, B0>, B1>, B1>, B1>; + pub type P823 = PInt; pub type N823 = NInt; + pub type U824 = UInt, B1>, B0>, B0>, B1>, B1>, B1>, B0>, B0>, B0>; + pub type P824 = PInt; pub type N824 = NInt; + pub type U825 = UInt, B1>, B0>, B0>, B1>, B1>, B1>, B0>, B0>, B1>; + pub type P825 = PInt; pub type N825 = NInt; + pub type U826 = UInt, B1>, B0>, B0>, B1>, B1>, B1>, B0>, B1>, B0>; + pub type P826 = PInt; pub type N826 = NInt; + pub type U827 = UInt, B1>, B0>, B0>, B1>, B1>, B1>, B0>, B1>, B1>; + pub type P827 = PInt; pub type N827 = NInt; + pub type U828 = UInt, B1>, B0>, B0>, B1>, B1>, B1>, B1>, B0>, B0>; + pub type P828 = PInt; pub type N828 = NInt; + pub type U829 = UInt, B1>, B0>, B0>, B1>, B1>, B1>, B1>, B0>, B1>; + pub type P829 = PInt; pub type N829 = NInt; + pub type U830 = UInt, B1>, B0>, B0>, B1>, B1>, B1>, B1>, B1>, B0>; + pub type P830 = PInt; pub type N830 = NInt; + pub type U831 = UInt, B1>, B0>, B0>, B1>, B1>, B1>, B1>, B1>, B1>; + pub type P831 = PInt; pub type N831 = NInt; + pub type U832 = UInt, B1>, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B0>; + pub type P832 = PInt; pub type N832 = NInt; + pub type U833 = UInt, B1>, B0>, B1>, B0>, B0>, B0>, B0>, B0>, B1>; + pub type P833 = PInt; pub type N833 = NInt; + pub type U834 = UInt, B1>, B0>, B1>, B0>, B0>, B0>, B0>, B1>, B0>; + pub type P834 = PInt; pub type N834 = NInt; + pub type U835 = UInt, B1>, B0>, B1>, B0>, B0>, B0>, B0>, B1>, B1>; + pub type P835 = PInt; pub type N835 = NInt; + pub type U836 = UInt, B1>, B0>, B1>, B0>, B0>, B0>, B1>, B0>, B0>; + pub type P836 = PInt; pub type N836 = NInt; + pub type U837 = UInt, B1>, B0>, B1>, B0>, B0>, B0>, B1>, B0>, B1>; + pub type P837 = PInt; pub type N837 = NInt; + pub type U838 = UInt, B1>, B0>, B1>, B0>, B0>, B0>, B1>, B1>, B0>; + pub type P838 = PInt; pub type N838 = NInt; + pub type U839 = UInt, B1>, B0>, B1>, B0>, B0>, B0>, B1>, B1>, B1>; + pub type P839 = PInt; pub type N839 = NInt; + pub type U840 = UInt, B1>, B0>, B1>, B0>, B0>, B1>, B0>, B0>, B0>; + pub type P840 = PInt; pub type N840 = NInt; + pub type U841 = UInt, B1>, B0>, B1>, B0>, B0>, B1>, B0>, B0>, B1>; + pub type P841 = PInt; pub type N841 = NInt; + pub type U842 = UInt, B1>, B0>, B1>, B0>, B0>, B1>, B0>, B1>, B0>; + pub type P842 = PInt; pub type N842 = NInt; + pub type U843 = UInt, B1>, B0>, B1>, B0>, B0>, B1>, B0>, B1>, B1>; + pub type P843 = PInt; pub type N843 = NInt; + pub type U844 = UInt, B1>, B0>, B1>, B0>, B0>, B1>, B1>, B0>, B0>; + pub type P844 = PInt; pub type N844 = NInt; + pub type U845 = UInt, B1>, B0>, B1>, B0>, B0>, B1>, B1>, B0>, B1>; + pub type P845 = PInt; pub type N845 = NInt; + pub type U846 = UInt, B1>, B0>, B1>, B0>, B0>, B1>, B1>, B1>, B0>; + pub type P846 = PInt; pub type N846 = NInt; + pub type U847 = UInt, B1>, B0>, B1>, B0>, B0>, B1>, B1>, B1>, B1>; + pub type P847 = PInt; pub type N847 = NInt; + pub type U848 = UInt, B1>, B0>, B1>, B0>, B1>, B0>, B0>, B0>, B0>; + pub type P848 = PInt; pub type N848 = NInt; + pub type U849 = UInt, B1>, B0>, B1>, B0>, B1>, B0>, B0>, B0>, B1>; + pub type P849 = PInt; pub type N849 = NInt; + pub type U850 = UInt, B1>, B0>, B1>, B0>, B1>, B0>, B0>, B1>, B0>; + pub type P850 = PInt; pub type N850 = NInt; + pub type U851 = UInt, B1>, B0>, B1>, B0>, B1>, B0>, B0>, B1>, B1>; + pub type P851 = PInt; pub type N851 = NInt; + pub type U852 = UInt, B1>, B0>, B1>, B0>, B1>, B0>, B1>, B0>, B0>; + pub type P852 = PInt; pub type N852 = NInt; + pub type U853 = UInt, B1>, B0>, B1>, B0>, B1>, B0>, B1>, B0>, B1>; + pub type P853 = PInt; pub type N853 = NInt; + pub type U854 = UInt, B1>, B0>, B1>, B0>, B1>, B0>, B1>, B1>, B0>; + pub type P854 = PInt; pub type N854 = NInt; + pub type U855 = UInt, B1>, B0>, B1>, B0>, B1>, B0>, B1>, B1>, B1>; + pub type P855 = PInt; pub type N855 = NInt; + pub type U856 = UInt, B1>, B0>, B1>, B0>, B1>, B1>, B0>, B0>, B0>; + pub type P856 = PInt; pub type N856 = NInt; + pub type U857 = UInt, B1>, B0>, B1>, B0>, B1>, B1>, B0>, B0>, B1>; + pub type P857 = PInt; pub type N857 = NInt; + pub type U858 = UInt, B1>, B0>, B1>, B0>, B1>, B1>, B0>, B1>, B0>; + pub type P858 = PInt; pub type N858 = NInt; + pub type U859 = UInt, B1>, B0>, B1>, B0>, B1>, B1>, B0>, B1>, B1>; + pub type P859 = PInt; pub type N859 = NInt; + pub type U860 = UInt, B1>, B0>, B1>, B0>, B1>, B1>, B1>, B0>, B0>; + pub type P860 = PInt; pub type N860 = NInt; + pub type U861 = UInt, B1>, B0>, B1>, B0>, B1>, B1>, B1>, B0>, B1>; + pub type P861 = PInt; pub type N861 = NInt; + pub type U862 = UInt, B1>, B0>, B1>, B0>, B1>, B1>, B1>, B1>, B0>; + pub type P862 = PInt; pub type N862 = NInt; + pub type U863 = UInt, B1>, B0>, B1>, B0>, B1>, B1>, B1>, B1>, B1>; + pub type P863 = PInt; pub type N863 = NInt; + pub type U864 = UInt, B1>, B0>, B1>, B1>, B0>, B0>, B0>, B0>, B0>; + pub type P864 = PInt; pub type N864 = NInt; + pub type U865 = UInt, B1>, B0>, B1>, B1>, B0>, B0>, B0>, B0>, B1>; + pub type P865 = PInt; pub type N865 = NInt; + pub type U866 = UInt, B1>, B0>, B1>, B1>, B0>, B0>, B0>, B1>, B0>; + pub type P866 = PInt; pub type N866 = NInt; + pub type U867 = UInt, B1>, B0>, B1>, B1>, B0>, B0>, B0>, B1>, B1>; + pub type P867 = PInt; pub type N867 = NInt; + pub type U868 = UInt, B1>, B0>, B1>, B1>, B0>, B0>, B1>, B0>, B0>; + pub type P868 = PInt; pub type N868 = NInt; + pub type U869 = UInt, B1>, B0>, B1>, B1>, B0>, B0>, B1>, B0>, B1>; + pub type P869 = PInt; pub type N869 = NInt; + pub type U870 = UInt, B1>, B0>, B1>, B1>, B0>, B0>, B1>, B1>, B0>; + pub type P870 = PInt; pub type N870 = NInt; + pub type U871 = UInt, B1>, B0>, B1>, B1>, B0>, B0>, B1>, B1>, B1>; + pub type P871 = PInt; pub type N871 = NInt; + pub type U872 = UInt, B1>, B0>, B1>, B1>, B0>, B1>, B0>, B0>, B0>; + pub type P872 = PInt; pub type N872 = NInt; + pub type U873 = UInt, B1>, B0>, B1>, B1>, B0>, B1>, B0>, B0>, B1>; + pub type P873 = PInt; pub type N873 = NInt; + pub type U874 = UInt, B1>, B0>, B1>, B1>, B0>, B1>, B0>, B1>, B0>; + pub type P874 = PInt; pub type N874 = NInt; + pub type U875 = UInt, B1>, B0>, B1>, B1>, B0>, B1>, B0>, B1>, B1>; + pub type P875 = PInt; pub type N875 = NInt; + pub type U876 = UInt, B1>, B0>, B1>, B1>, B0>, B1>, B1>, B0>, B0>; + pub type P876 = PInt; pub type N876 = NInt; + pub type U877 = UInt, B1>, B0>, B1>, B1>, B0>, B1>, B1>, B0>, B1>; + pub type P877 = PInt; pub type N877 = NInt; + pub type U878 = UInt, B1>, B0>, B1>, B1>, B0>, B1>, B1>, B1>, B0>; + pub type P878 = PInt; pub type N878 = NInt; + pub type U879 = UInt, B1>, B0>, B1>, B1>, B0>, B1>, B1>, B1>, B1>; + pub type P879 = PInt; pub type N879 = NInt; + pub type U880 = UInt, B1>, B0>, B1>, B1>, B1>, B0>, B0>, B0>, B0>; + pub type P880 = PInt; pub type N880 = NInt; + pub type U881 = UInt, B1>, B0>, B1>, B1>, B1>, B0>, B0>, B0>, B1>; + pub type P881 = PInt; pub type N881 = NInt; + pub type U882 = UInt, B1>, B0>, B1>, B1>, B1>, B0>, B0>, B1>, B0>; + pub type P882 = PInt; pub type N882 = NInt; + pub type U883 = UInt, B1>, B0>, B1>, B1>, B1>, B0>, B0>, B1>, B1>; + pub type P883 = PInt; pub type N883 = NInt; + pub type U884 = UInt, B1>, B0>, B1>, B1>, B1>, B0>, B1>, B0>, B0>; + pub type P884 = PInt; pub type N884 = NInt; + pub type U885 = UInt, B1>, B0>, B1>, B1>, B1>, B0>, B1>, B0>, B1>; + pub type P885 = PInt; pub type N885 = NInt; + pub type U886 = UInt, B1>, B0>, B1>, B1>, B1>, B0>, B1>, B1>, B0>; + pub type P886 = PInt; pub type N886 = NInt; + pub type U887 = UInt, B1>, B0>, B1>, B1>, B1>, B0>, B1>, B1>, B1>; + pub type P887 = PInt; pub type N887 = NInt; + pub type U888 = UInt, B1>, B0>, B1>, B1>, B1>, B1>, B0>, B0>, B0>; + pub type P888 = PInt; pub type N888 = NInt; + pub type U889 = UInt, B1>, B0>, B1>, B1>, B1>, B1>, B0>, B0>, B1>; + pub type P889 = PInt; pub type N889 = NInt; + pub type U890 = UInt, B1>, B0>, B1>, B1>, B1>, B1>, B0>, B1>, B0>; + pub type P890 = PInt; pub type N890 = NInt; + pub type U891 = UInt, B1>, B0>, B1>, B1>, B1>, B1>, B0>, B1>, B1>; + pub type P891 = PInt; pub type N891 = NInt; + pub type U892 = UInt, B1>, B0>, B1>, B1>, B1>, B1>, B1>, B0>, B0>; + pub type P892 = PInt; pub type N892 = NInt; + pub type U893 = UInt, B1>, B0>, B1>, B1>, B1>, B1>, B1>, B0>, B1>; + pub type P893 = PInt; pub type N893 = NInt; + pub type U894 = UInt, B1>, B0>, B1>, B1>, B1>, B1>, B1>, B1>, B0>; + pub type P894 = PInt; pub type N894 = NInt; + pub type U895 = UInt, B1>, B0>, B1>, B1>, B1>, B1>, B1>, B1>, B1>; + pub type P895 = PInt; pub type N895 = NInt; + pub type U896 = UInt, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; + pub type P896 = PInt; pub type N896 = NInt; + pub type U897 = UInt, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B1>; + pub type P897 = PInt; pub type N897 = NInt; + pub type U898 = UInt, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B1>, B0>; + pub type P898 = PInt; pub type N898 = NInt; + pub type U899 = UInt, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B1>, B1>; + pub type P899 = PInt; pub type N899 = NInt; + pub type U900 = UInt, B1>, B1>, B0>, B0>, B0>, B0>, B1>, B0>, B0>; + pub type P900 = PInt; pub type N900 = NInt; + pub type U901 = UInt, B1>, B1>, B0>, B0>, B0>, B0>, B1>, B0>, B1>; + pub type P901 = PInt; pub type N901 = NInt; + pub type U902 = UInt, B1>, B1>, B0>, B0>, B0>, B0>, B1>, B1>, B0>; + pub type P902 = PInt; pub type N902 = NInt; + pub type U903 = UInt, B1>, B1>, B0>, B0>, B0>, B0>, B1>, B1>, B1>; + pub type P903 = PInt; pub type N903 = NInt; + pub type U904 = UInt, B1>, B1>, B0>, B0>, B0>, B1>, B0>, B0>, B0>; + pub type P904 = PInt; pub type N904 = NInt; + pub type U905 = UInt, B1>, B1>, B0>, B0>, B0>, B1>, B0>, B0>, B1>; + pub type P905 = PInt; pub type N905 = NInt; + pub type U906 = UInt, B1>, B1>, B0>, B0>, B0>, B1>, B0>, B1>, B0>; + pub type P906 = PInt; pub type N906 = NInt; + pub type U907 = UInt, B1>, B1>, B0>, B0>, B0>, B1>, B0>, B1>, B1>; + pub type P907 = PInt; pub type N907 = NInt; + pub type U908 = UInt, B1>, B1>, B0>, B0>, B0>, B1>, B1>, B0>, B0>; + pub type P908 = PInt; pub type N908 = NInt; + pub type U909 = UInt, B1>, B1>, B0>, B0>, B0>, B1>, B1>, B0>, B1>; + pub type P909 = PInt; pub type N909 = NInt; + pub type U910 = UInt, B1>, B1>, B0>, B0>, B0>, B1>, B1>, B1>, B0>; + pub type P910 = PInt; pub type N910 = NInt; + pub type U911 = UInt, B1>, B1>, B0>, B0>, B0>, B1>, B1>, B1>, B1>; + pub type P911 = PInt; pub type N911 = NInt; + pub type U912 = UInt, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B0>; + pub type P912 = PInt; pub type N912 = NInt; + pub type U913 = UInt, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>, B1>; + pub type P913 = PInt; pub type N913 = NInt; + pub type U914 = UInt, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B1>, B0>; + pub type P914 = PInt; pub type N914 = NInt; + pub type U915 = UInt, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B1>, B1>; + pub type P915 = PInt; pub type N915 = NInt; + pub type U916 = UInt, B1>, B1>, B0>, B0>, B1>, B0>, B1>, B0>, B0>; + pub type P916 = PInt; pub type N916 = NInt; + pub type U917 = UInt, B1>, B1>, B0>, B0>, B1>, B0>, B1>, B0>, B1>; + pub type P917 = PInt; pub type N917 = NInt; + pub type U918 = UInt, B1>, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B0>; + pub type P918 = PInt; pub type N918 = NInt; + pub type U919 = UInt, B1>, B1>, B0>, B0>, B1>, B0>, B1>, B1>, B1>; + pub type P919 = PInt; pub type N919 = NInt; + pub type U920 = UInt, B1>, B1>, B0>, B0>, B1>, B1>, B0>, B0>, B0>; + pub type P920 = PInt; pub type N920 = NInt; + pub type U921 = UInt, B1>, B1>, B0>, B0>, B1>, B1>, B0>, B0>, B1>; + pub type P921 = PInt; pub type N921 = NInt; + pub type U922 = UInt, B1>, B1>, B0>, B0>, B1>, B1>, B0>, B1>, B0>; + pub type P922 = PInt; pub type N922 = NInt; + pub type U923 = UInt, B1>, B1>, B0>, B0>, B1>, B1>, B0>, B1>, B1>; + pub type P923 = PInt; pub type N923 = NInt; + pub type U924 = UInt, B1>, B1>, B0>, B0>, B1>, B1>, B1>, B0>, B0>; + pub type P924 = PInt; pub type N924 = NInt; + pub type U925 = UInt, B1>, B1>, B0>, B0>, B1>, B1>, B1>, B0>, B1>; + pub type P925 = PInt; pub type N925 = NInt; + pub type U926 = UInt, B1>, B1>, B0>, B0>, B1>, B1>, B1>, B1>, B0>; + pub type P926 = PInt; pub type N926 = NInt; + pub type U927 = UInt, B1>, B1>, B0>, B0>, B1>, B1>, B1>, B1>, B1>; + pub type P927 = PInt; pub type N927 = NInt; + pub type U928 = UInt, B1>, B1>, B0>, B1>, B0>, B0>, B0>, B0>, B0>; + pub type P928 = PInt; pub type N928 = NInt; + pub type U929 = UInt, B1>, B1>, B0>, B1>, B0>, B0>, B0>, B0>, B1>; + pub type P929 = PInt; pub type N929 = NInt; + pub type U930 = UInt, B1>, B1>, B0>, B1>, B0>, B0>, B0>, B1>, B0>; + pub type P930 = PInt; pub type N930 = NInt; + pub type U931 = UInt, B1>, B1>, B0>, B1>, B0>, B0>, B0>, B1>, B1>; + pub type P931 = PInt; pub type N931 = NInt; + pub type U932 = UInt, B1>, B1>, B0>, B1>, B0>, B0>, B1>, B0>, B0>; + pub type P932 = PInt; pub type N932 = NInt; + pub type U933 = UInt, B1>, B1>, B0>, B1>, B0>, B0>, B1>, B0>, B1>; + pub type P933 = PInt; pub type N933 = NInt; + pub type U934 = UInt, B1>, B1>, B0>, B1>, B0>, B0>, B1>, B1>, B0>; + pub type P934 = PInt; pub type N934 = NInt; + pub type U935 = UInt, B1>, B1>, B0>, B1>, B0>, B0>, B1>, B1>, B1>; + pub type P935 = PInt; pub type N935 = NInt; + pub type U936 = UInt, B1>, B1>, B0>, B1>, B0>, B1>, B0>, B0>, B0>; + pub type P936 = PInt; pub type N936 = NInt; + pub type U937 = UInt, B1>, B1>, B0>, B1>, B0>, B1>, B0>, B0>, B1>; + pub type P937 = PInt; pub type N937 = NInt; + pub type U938 = UInt, B1>, B1>, B0>, B1>, B0>, B1>, B0>, B1>, B0>; + pub type P938 = PInt; pub type N938 = NInt; + pub type U939 = UInt, B1>, B1>, B0>, B1>, B0>, B1>, B0>, B1>, B1>; + pub type P939 = PInt; pub type N939 = NInt; + pub type U940 = UInt, B1>, B1>, B0>, B1>, B0>, B1>, B1>, B0>, B0>; + pub type P940 = PInt; pub type N940 = NInt; + pub type U941 = UInt, B1>, B1>, B0>, B1>, B0>, B1>, B1>, B0>, B1>; + pub type P941 = PInt; pub type N941 = NInt; + pub type U942 = UInt, B1>, B1>, B0>, B1>, B0>, B1>, B1>, B1>, B0>; + pub type P942 = PInt; pub type N942 = NInt; + pub type U943 = UInt, B1>, B1>, B0>, B1>, B0>, B1>, B1>, B1>, B1>; + pub type P943 = PInt; pub type N943 = NInt; + pub type U944 = UInt, B1>, B1>, B0>, B1>, B1>, B0>, B0>, B0>, B0>; + pub type P944 = PInt; pub type N944 = NInt; + pub type U945 = UInt, B1>, B1>, B0>, B1>, B1>, B0>, B0>, B0>, B1>; + pub type P945 = PInt; pub type N945 = NInt; + pub type U946 = UInt, B1>, B1>, B0>, B1>, B1>, B0>, B0>, B1>, B0>; + pub type P946 = PInt; pub type N946 = NInt; + pub type U947 = UInt, B1>, B1>, B0>, B1>, B1>, B0>, B0>, B1>, B1>; + pub type P947 = PInt; pub type N947 = NInt; + pub type U948 = UInt, B1>, B1>, B0>, B1>, B1>, B0>, B1>, B0>, B0>; + pub type P948 = PInt; pub type N948 = NInt; + pub type U949 = UInt, B1>, B1>, B0>, B1>, B1>, B0>, B1>, B0>, B1>; + pub type P949 = PInt; pub type N949 = NInt; + pub type U950 = UInt, B1>, B1>, B0>, B1>, B1>, B0>, B1>, B1>, B0>; + pub type P950 = PInt; pub type N950 = NInt; + pub type U951 = UInt, B1>, B1>, B0>, B1>, B1>, B0>, B1>, B1>, B1>; + pub type P951 = PInt; pub type N951 = NInt; + pub type U952 = UInt, B1>, B1>, B0>, B1>, B1>, B1>, B0>, B0>, B0>; + pub type P952 = PInt; pub type N952 = NInt; + pub type U953 = UInt, B1>, B1>, B0>, B1>, B1>, B1>, B0>, B0>, B1>; + pub type P953 = PInt; pub type N953 = NInt; + pub type U954 = UInt, B1>, B1>, B0>, B1>, B1>, B1>, B0>, B1>, B0>; + pub type P954 = PInt; pub type N954 = NInt; + pub type U955 = UInt, B1>, B1>, B0>, B1>, B1>, B1>, B0>, B1>, B1>; + pub type P955 = PInt; pub type N955 = NInt; + pub type U956 = UInt, B1>, B1>, B0>, B1>, B1>, B1>, B1>, B0>, B0>; + pub type P956 = PInt; pub type N956 = NInt; + pub type U957 = UInt, B1>, B1>, B0>, B1>, B1>, B1>, B1>, B0>, B1>; + pub type P957 = PInt; pub type N957 = NInt; + pub type U958 = UInt, B1>, B1>, B0>, B1>, B1>, B1>, B1>, B1>, B0>; + pub type P958 = PInt; pub type N958 = NInt; + pub type U959 = UInt, B1>, B1>, B0>, B1>, B1>, B1>, B1>, B1>, B1>; + pub type P959 = PInt; pub type N959 = NInt; + pub type U960 = UInt, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B0>; + pub type P960 = PInt; pub type N960 = NInt; + pub type U961 = UInt, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B0>, B1>; + pub type P961 = PInt; pub type N961 = NInt; + pub type U962 = UInt, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B1>, B0>; + pub type P962 = PInt; pub type N962 = NInt; + pub type U963 = UInt, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B1>, B1>; + pub type P963 = PInt; pub type N963 = NInt; + pub type U964 = UInt, B1>, B1>, B1>, B0>, B0>, B0>, B1>, B0>, B0>; + pub type P964 = PInt; pub type N964 = NInt; + pub type U965 = UInt, B1>, B1>, B1>, B0>, B0>, B0>, B1>, B0>, B1>; + pub type P965 = PInt; pub type N965 = NInt; + pub type U966 = UInt, B1>, B1>, B1>, B0>, B0>, B0>, B1>, B1>, B0>; + pub type P966 = PInt; pub type N966 = NInt; + pub type U967 = UInt, B1>, B1>, B1>, B0>, B0>, B0>, B1>, B1>, B1>; + pub type P967 = PInt; pub type N967 = NInt; + pub type U968 = UInt, B1>, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B0>; + pub type P968 = PInt; pub type N968 = NInt; + pub type U969 = UInt, B1>, B1>, B1>, B0>, B0>, B1>, B0>, B0>, B1>; + pub type P969 = PInt; pub type N969 = NInt; + pub type U970 = UInt, B1>, B1>, B1>, B0>, B0>, B1>, B0>, B1>, B0>; + pub type P970 = PInt; pub type N970 = NInt; + pub type U971 = UInt, B1>, B1>, B1>, B0>, B0>, B1>, B0>, B1>, B1>; + pub type P971 = PInt; pub type N971 = NInt; + pub type U972 = UInt, B1>, B1>, B1>, B0>, B0>, B1>, B1>, B0>, B0>; + pub type P972 = PInt; pub type N972 = NInt; + pub type U973 = UInt, B1>, B1>, B1>, B0>, B0>, B1>, B1>, B0>, B1>; + pub type P973 = PInt; pub type N973 = NInt; + pub type U974 = UInt, B1>, B1>, B1>, B0>, B0>, B1>, B1>, B1>, B0>; + pub type P974 = PInt; pub type N974 = NInt; + pub type U975 = UInt, B1>, B1>, B1>, B0>, B0>, B1>, B1>, B1>, B1>; + pub type P975 = PInt; pub type N975 = NInt; + pub type U976 = UInt, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B0>, B0>; + pub type P976 = PInt; pub type N976 = NInt; + pub type U977 = UInt, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B0>, B1>; + pub type P977 = PInt; pub type N977 = NInt; + pub type U978 = UInt, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B1>, B0>; + pub type P978 = PInt; pub type N978 = NInt; + pub type U979 = UInt, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B1>, B1>; + pub type P979 = PInt; pub type N979 = NInt; + pub type U980 = UInt, B1>, B1>, B1>, B0>, B1>, B0>, B1>, B0>, B0>; + pub type P980 = PInt; pub type N980 = NInt; + pub type U981 = UInt, B1>, B1>, B1>, B0>, B1>, B0>, B1>, B0>, B1>; + pub type P981 = PInt; pub type N981 = NInt; + pub type U982 = UInt, B1>, B1>, B1>, B0>, B1>, B0>, B1>, B1>, B0>; + pub type P982 = PInt; pub type N982 = NInt; + pub type U983 = UInt, B1>, B1>, B1>, B0>, B1>, B0>, B1>, B1>, B1>; + pub type P983 = PInt; pub type N983 = NInt; + pub type U984 = UInt, B1>, B1>, B1>, B0>, B1>, B1>, B0>, B0>, B0>; + pub type P984 = PInt; pub type N984 = NInt; + pub type U985 = UInt, B1>, B1>, B1>, B0>, B1>, B1>, B0>, B0>, B1>; + pub type P985 = PInt; pub type N985 = NInt; + pub type U986 = UInt, B1>, B1>, B1>, B0>, B1>, B1>, B0>, B1>, B0>; + pub type P986 = PInt; pub type N986 = NInt; + pub type U987 = UInt, B1>, B1>, B1>, B0>, B1>, B1>, B0>, B1>, B1>; + pub type P987 = PInt; pub type N987 = NInt; + pub type U988 = UInt, B1>, B1>, B1>, B0>, B1>, B1>, B1>, B0>, B0>; + pub type P988 = PInt; pub type N988 = NInt; + pub type U989 = UInt, B1>, B1>, B1>, B0>, B1>, B1>, B1>, B0>, B1>; + pub type P989 = PInt; pub type N989 = NInt; + pub type U990 = UInt, B1>, B1>, B1>, B0>, B1>, B1>, B1>, B1>, B0>; + pub type P990 = PInt; pub type N990 = NInt; + pub type U991 = UInt, B1>, B1>, B1>, B0>, B1>, B1>, B1>, B1>, B1>; + pub type P991 = PInt; pub type N991 = NInt; + pub type U992 = UInt, B1>, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B0>; + pub type P992 = PInt; pub type N992 = NInt; + pub type U993 = UInt, B1>, B1>, B1>, B1>, B0>, B0>, B0>, B0>, B1>; + pub type P993 = PInt; pub type N993 = NInt; + pub type U994 = UInt, B1>, B1>, B1>, B1>, B0>, B0>, B0>, B1>, B0>; + pub type P994 = PInt; pub type N994 = NInt; + pub type U995 = UInt, B1>, B1>, B1>, B1>, B0>, B0>, B0>, B1>, B1>; + pub type P995 = PInt; pub type N995 = NInt; + pub type U996 = UInt, B1>, B1>, B1>, B1>, B0>, B0>, B1>, B0>, B0>; + pub type P996 = PInt; pub type N996 = NInt; + pub type U997 = UInt, B1>, B1>, B1>, B1>, B0>, B0>, B1>, B0>, B1>; + pub type P997 = PInt; pub type N997 = NInt; + pub type U998 = UInt, B1>, B1>, B1>, B1>, B0>, B0>, B1>, B1>, B0>; + pub type P998 = PInt; pub type N998 = NInt; + pub type U999 = UInt, B1>, B1>, B1>, B1>, B0>, B0>, B1>, B1>, B1>; + pub type P999 = PInt; pub type N999 = NInt; + pub type U1000 = UInt, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B0>; + pub type P1000 = PInt; pub type N1000 = NInt; + pub type U1001 = UInt, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>, B1>; + pub type P1001 = PInt; pub type N1001 = NInt; + pub type U1002 = UInt, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B1>, B0>; + pub type P1002 = PInt; pub type N1002 = NInt; + pub type U1003 = UInt, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B1>, B1>; + pub type P1003 = PInt; pub type N1003 = NInt; + pub type U1004 = UInt, B1>, B1>, B1>, B1>, B0>, B1>, B1>, B0>, B0>; + pub type P1004 = PInt; pub type N1004 = NInt; + pub type U1005 = UInt, B1>, B1>, B1>, B1>, B0>, B1>, B1>, B0>, B1>; + pub type P1005 = PInt; pub type N1005 = NInt; + pub type U1006 = UInt, B1>, B1>, B1>, B1>, B0>, B1>, B1>, B1>, B0>; + pub type P1006 = PInt; pub type N1006 = NInt; + pub type U1007 = UInt, B1>, B1>, B1>, B1>, B0>, B1>, B1>, B1>, B1>; + pub type P1007 = PInt; pub type N1007 = NInt; + pub type U1008 = UInt, B1>, B1>, B1>, B1>, B1>, B0>, B0>, B0>, B0>; + pub type P1008 = PInt; pub type N1008 = NInt; + pub type U1009 = UInt, B1>, B1>, B1>, B1>, B1>, B0>, B0>, B0>, B1>; + pub type P1009 = PInt; pub type N1009 = NInt; + pub type U1010 = UInt, B1>, B1>, B1>, B1>, B1>, B0>, B0>, B1>, B0>; + pub type P1010 = PInt; pub type N1010 = NInt; + pub type U1011 = UInt, B1>, B1>, B1>, B1>, B1>, B0>, B0>, B1>, B1>; + pub type P1011 = PInt; pub type N1011 = NInt; + pub type U1012 = UInt, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B0>; + pub type P1012 = PInt; pub type N1012 = NInt; + pub type U1013 = UInt, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>, B1>; + pub type P1013 = PInt; pub type N1013 = NInt; + pub type U1014 = UInt, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B1>, B0>; + pub type P1014 = PInt; pub type N1014 = NInt; + pub type U1015 = UInt, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B1>, B1>; + pub type P1015 = PInt; pub type N1015 = NInt; + pub type U1016 = UInt, B1>, B1>, B1>, B1>, B1>, B1>, B0>, B0>, B0>; + pub type P1016 = PInt; pub type N1016 = NInt; + pub type U1017 = UInt, B1>, B1>, B1>, B1>, B1>, B1>, B0>, B0>, B1>; + pub type P1017 = PInt; pub type N1017 = NInt; + pub type U1018 = UInt, B1>, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B0>; + pub type P1018 = PInt; pub type N1018 = NInt; + pub type U1019 = UInt, B1>, B1>, B1>, B1>, B1>, B1>, B0>, B1>, B1>; + pub type P1019 = PInt; pub type N1019 = NInt; + pub type U1020 = UInt, B1>, B1>, B1>, B1>, B1>, B1>, B1>, B0>, B0>; + pub type P1020 = PInt; pub type N1020 = NInt; + pub type U1021 = UInt, B1>, B1>, B1>, B1>, B1>, B1>, B1>, B0>, B1>; + pub type P1021 = PInt; pub type N1021 = NInt; + pub type U1022 = UInt, B1>, B1>, B1>, B1>, B1>, B1>, B1>, B1>, B0>; + pub type P1022 = PInt; pub type N1022 = NInt; + pub type U1023 = UInt, B1>, B1>, B1>, B1>, B1>, B1>, B1>, B1>, B1>; + pub type P1023 = PInt; pub type N1023 = NInt; + pub type U1024 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; + pub type P1024 = PInt; pub type N1024 = NInt; + pub type U2048 = UInt, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>; + pub type P2048 = PInt; pub type N2048 = NInt; + pub type U4096 = 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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, 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>; +} \ No newline at end of file diff --git a/collector/compile-benchmarks/typenum-1.17.0/src/generated/generic_const_mappings.rs b/collector/compile-benchmarks/typenum-1.17.0/src/generated/generic_const_mappings.rs new file mode 100644 index 000000000..2a8098c15 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.17.0/src/generated/generic_const_mappings.rs @@ -0,0 +1,5531 @@ +#[cfg(doc)] +use generic_const_mappings::*; + +/// 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. +#[allow(warnings)] // script-generated code +#[cfg(feature = "const-generics")] // hints at doc_auto_cfg +pub mod generic_const_mappings { + 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<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; + } +} \ No newline at end of file diff --git a/collector/compile-benchmarks/typenum-1.17.0/src/generated/op.rs b/collector/compile-benchmarks/typenum-1.17.0/src/generated/op.rs new file mode 100644 index 000000000..ce6f3e01a --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.17.0/src/generated/op.rs @@ -0,0 +1,1030 @@ + +/** +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)*) +); +} \ No newline at end of file diff --git a/collector/compile-benchmarks/typenum-1.17.0/src/int.rs b/collector/compile-benchmarks/typenum-1.17.0/src/int.rs new file mode 100644 index 000000000..1f6eaebc1 --- /dev/null +++ b/collector/compile-benchmarks/typenum-1.17.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