[INFO] crate specialized-div-rem 0.0.3 is already in cache
[INFO] extracting crate specialized-div-rem 0.0.3 into work/ex/clippy-test-run/sources/stable/reg/specialized-div-rem/0.0.3
[INFO] extracting crate specialized-div-rem 0.0.3 into work/ex/clippy-test-run/sources/stable+rustflags=-Dclippy%3A%3Ainto_iter_on_array/reg/specialized-div-rem/0.0.3
[INFO] validating manifest of specialized-div-rem-0.0.3 on toolchain stable
[INFO] running `"/mnt/big/crater/work/local/cargo-home/bin/cargo" "+stable" "read-manifest" "--manifest-path" "Cargo.toml"`
[INFO] validating manifest of specialized-div-rem-0.0.3 on toolchain stable+rustflags=-Dclippy::into_iter_on_array
[INFO] running `"/mnt/big/crater/work/local/cargo-home/bin/cargo" "+stable" "read-manifest" "--manifest-path" "Cargo.toml"`
[INFO] started frobbing specialized-div-rem-0.0.3
[INFO] finished frobbing specialized-div-rem-0.0.3
[INFO] frobbed toml for specialized-div-rem-0.0.3 written to work/ex/clippy-test-run/sources/stable/reg/specialized-div-rem/0.0.3/Cargo.toml
[INFO] started frobbing specialized-div-rem-0.0.3
[INFO] finished frobbing specialized-div-rem-0.0.3
[INFO] frobbed toml for specialized-div-rem-0.0.3 written to work/ex/clippy-test-run/sources/stable+rustflags=-Dclippy%3A%3Ainto_iter_on_array/reg/specialized-div-rem/0.0.3/Cargo.toml
[INFO] running `"/mnt/big/crater/work/local/cargo-home/bin/cargo" "+stable" "generate-lockfile" "--manifest-path" "Cargo.toml" "-Zno-index-update"`
[INFO] running `"/mnt/big/crater/work/local/cargo-home/bin/cargo" "+stable" "generate-lockfile" "--manifest-path" "Cargo.toml" "-Zno-index-update"`
[INFO] running `"/mnt/big/crater/work/local/cargo-home/bin/cargo" "+stable" "fetch" "--locked" "--manifest-path" "Cargo.toml"`
[INFO] running `"/mnt/big/crater/work/local/cargo-home/bin/cargo" "+stable" "fetch" "--locked" "--manifest-path" "Cargo.toml"`
[INFO] linting specialized-div-rem-0.0.3 against stable for clippy-test-run
[INFO] running `"docker" "create" "-v" "/mnt/big/crater/work/local/target-dirs/clippy-test-run/worker-3/stable:/opt/crater/target:rw,Z" "-v" "/mnt/big/crater/work/ex/clippy-test-run/sources/stable/reg/specialized-div-rem/0.0.3:/opt/crater/workdir:ro,Z" "-v" "/mnt/big/crater/work/local/cargo-home:/opt/crater/cargo-home:ro,Z" "-v" "/mnt/big/crater/work/local/rustup-home:/opt/crater/rustup-home:ro,Z" "-e" "USER_ID=1000" "-e" "SOURCE_DIR=/opt/crater/workdir" "-e" "MAP_USER_ID=1000" "-e" "CARGO_TARGET_DIR=/opt/crater/target" "-e" "CARGO_INCREMENTAL=0" "-e" "RUST_BACKTRACE=full" "-e" "RUSTFLAGS=--cap-lints=forbid" "-e" "CARGO_HOME=/opt/crater/cargo-home" "-e" "RUSTUP_HOME=/opt/crater/rustup-home" "-w" "/opt/crater/workdir" "-m" "1536M" "--network" "none" "rustops/crates-build-env" "/opt/crater/cargo-home/bin/cargo" "+stable" "clippy" "--frozen" "--all" "--all-targets"`
[INFO] [stdout] 9462ada61303b6718415c850bbd27eb1c52cf191c3b09c2fb86a8f36484ac986
[INFO] running `"docker" "start" "-a" "9462ada61303b6718415c850bbd27eb1c52cf191c3b09c2fb86a8f36484ac986"`
[INFO] [stderr]     Checking specialized-div-rem v0.0.3 (/opt/crater/workdir)
[INFO] [stderr]     Checking rand v0.5.6
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:29:28
[INFO] [stderr]     |
[INFO] [stderr] 29  |                 let temp = (lhs as $uD).wrapping_mul(rhs as $uD);
[INFO] [stderr]     |                            ^^^^^^^^^^^^ help: try: `u32::from(lhs)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: #[warn(clippy::cast_lossless)] on by default
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:29:54
[INFO] [stderr]     |
[INFO] [stderr] 29  |                 let temp = (lhs as $uD).wrapping_mul(rhs as $uD);
[INFO] [stderr]     |                                                      ^^^^^^^^^^ help: try: `u32::from(rhs)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:34:28
[INFO] [stderr]     |
[INFO] [stderr] 34  |                 let temp = (lhs as $uD).wrapping_mul(mul as $uD).wrapping_add(add as $uD);
[INFO] [stderr]     |                            ^^^^^^^^^^^^ help: try: `u32::from(lhs)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:34:54
[INFO] [stderr]     |
[INFO] [stderr] 34  |                 let temp = (lhs as $uD).wrapping_mul(mul as $uD).wrapping_add(add as $uD);
[INFO] [stderr]     |                                                      ^^^^^^^^^^ help: try: `u32::from(mul)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:34:79
[INFO] [stderr]     |
[INFO] [stderr] 34  |                 let temp = (lhs as $uD).wrapping_mul(mul as $uD).wrapping_add(add as $uD);
[INFO] [stderr]     |                                                                               ^^^^^^^^^^ help: try: `u32::from(add)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:76:21
[INFO] [stderr]     |
[INFO] [stderr] 76  |                     (duo as $uX).wrapping_div(div as $uX) as $uD,
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::from((duo as $uX).wrapping_div(div as $uX))`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:77:21
[INFO] [stderr]     |
[INFO] [stderr] 77  |                     (duo as $uX).wrapping_rem(div as $uX) as $uD
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::from((duo as $uX).wrapping_rem(div as $uX))`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u8 to u16 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:85:30
[INFO] [stderr]     |
[INFO] [stderr] 85  |                 let div_lo = (div as $uH) as $uX;
[INFO] [stderr]     |                              ^^^^^^^^^^^^^^^^^^^ help: try: `u16::from((div as $uH))`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u8 to u16 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:94:22
[INFO] [stderr]     |
[INFO] [stderr] 94  |                     ((rem_2 as $uX) << $n_h) |
[INFO] [stderr]     |                      ^^^^^^^^^^^^^^ help: try: `u16::from(rem_2)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u8 to u16 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:95:21
[INFO] [stderr]     |
[INFO] [stderr] 95  |                     (((duo >> $n_h) as $uH) as $uX);
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u16::from(((duo >> $n_h) as $uH))`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u8 to u16 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:100:22
[INFO] [stderr]     |
[INFO] [stderr] 100 |                     ((rem_1 as $uX) << $n_h) |
[INFO] [stderr]     |                      ^^^^^^^^^^^^^^ help: try: `u16::from(rem_1)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u8 to u16 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:101:21
[INFO] [stderr]     |
[INFO] [stderr] 101 |                     ((duo as $uH) as $uX);
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^ help: try: `u16::from((duo as $uH))`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:104:22
[INFO] [stderr]     |
[INFO] [stderr] 104 |                     ((quo_hi as $uD) << n) | ((quo_1 as $uD) << $n_h) | (quo_0 as $uD),
[INFO] [stderr]     |                      ^^^^^^^^^^^^^^^ help: try: `u32::from(quo_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u8 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:104:47
[INFO] [stderr]     |
[INFO] [stderr] 104 |                     ((quo_hi as $uD) << n) | ((quo_1 as $uD) << $n_h) | (quo_0 as $uD),
[INFO] [stderr]     |                                               ^^^^^^^^^^^^^^ help: try: `u32::from(quo_1)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u8 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:104:73
[INFO] [stderr]     |
[INFO] [stderr] 104 |                     ((quo_hi as $uD) << n) | ((quo_1 as $uD) << $n_h) | (quo_0 as $uD),
[INFO] [stderr]     |                                                                         ^^^^^^^^^^^^^^ help: try: `u32::from(quo_0)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u8 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:105:21
[INFO] [stderr]     |
[INFO] [stderr] 105 |                     (duo_lo.wrapping_rem(div_lo) as $uH) as $uD
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::from((duo_lo.wrapping_rem(div_lo) as $uH))`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:158:41
[INFO] [stderr]     |
[INFO] [stderr] 158 |                 if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                         ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:158:61
[INFO] [stderr]     |
[INFO] [stderr] 158 |                 if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                             ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:169:25
[INFO] [stderr]     |
[INFO] [stderr] 169 |                         mul.wrapping_sub(1) as $uD,
[INFO] [stderr]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::from(mul.wrapping_sub(1))`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:170:59
[INFO] [stderr]     |
[INFO] [stderr] 170 |                         duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                           ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:170:79
[INFO] [stderr]     |
[INFO] [stderr] 170 |                         duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                               ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:174:25
[INFO] [stderr]     |
[INFO] [stderr] 174 |                         mul as $uD,
[INFO] [stderr]     |                         ^^^^^^^^^^ help: try: `u32::from(mul)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:175:42
[INFO] [stderr]     |
[INFO] [stderr] 175 |                         duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                          ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:175:62
[INFO] [stderr]     |
[INFO] [stderr] 175 |                         duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                              ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u8 to u16 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:226:36
[INFO] [stderr]     |
[INFO] [stderr] 226 |             let div_sig_n_h_add1 = (div_sig_n_h as $uX).wrapping_add(1);
[INFO] [stderr]     |                                    ^^^^^^^^^^^^^^^^^^^^ help: try: `u16::from(div_sig_n_h)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:234:31
[INFO] [stderr]     |
[INFO] [stderr] 234 |                     let mul = duo_sig_n.wrapping_div(div_sig_n_h_add1) as $uD;
[INFO] [stderr]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::from(duo_sig_n.wrapping_div(div_sig_n_h_add1))`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:253:49
[INFO] [stderr]     |
[INFO] [stderr] 253 |                         if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                 ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:253:69
[INFO] [stderr]     |
[INFO] [stderr] 253 |                         if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                                     ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:256:50
[INFO] [stderr]     |
[INFO] [stderr] 256 |                                 quo.wrapping_add(mul.wrapping_sub(1) as $uD),
[INFO] [stderr]     |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::from(mul.wrapping_sub(1))`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:257:67
[INFO] [stderr]     |
[INFO] [stderr] 257 |                                 duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                   ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:257:87
[INFO] [stderr]     |
[INFO] [stderr] 257 |                                 duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                                       ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:261:50
[INFO] [stderr]     |
[INFO] [stderr] 261 |                                 quo.wrapping_add(mul as $uD),
[INFO] [stderr]     |                                                  ^^^^^^^^^^ help: try: `u32::from(mul)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:262:50
[INFO] [stderr]     |
[INFO] [stderr] 262 |                                 duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                  ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:262:70
[INFO] [stderr]     |
[INFO] [stderr] 262 |                                 duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                                      ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:270:46
[INFO] [stderr]     |
[INFO] [stderr] 270 |                             quo.wrapping_add((duo as $uX).wrapping_div(div as $uX) as $uD),
[INFO] [stderr]     |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::from((duo as $uX).wrapping_div(div as $uX))`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:271:29
[INFO] [stderr]     |
[INFO] [stderr] 271 |                             (duo as $uX).wrapping_rem(div as $uX) as $uD
[INFO] [stderr]     |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::from((duo as $uX).wrapping_rem(div as $uX))`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:281:31
[INFO] [stderr]     |
[INFO] [stderr] 281 |                     let mul = duo_sig_n.wrapping_div(div_sig_n_h_add1) as $uD;
[INFO] [stderr]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::from(duo_sig_n.wrapping_div(div_sig_n_h_add1))`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:300:49
[INFO] [stderr]     |
[INFO] [stderr] 300 |                         if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                 ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:300:69
[INFO] [stderr]     |
[INFO] [stderr] 300 |                         if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                                     ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:302:50
[INFO] [stderr]     |
[INFO] [stderr] 302 |                                 quo.wrapping_add(mul.wrapping_sub(1) as $uD),
[INFO] [stderr]     |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::from(mul.wrapping_sub(1))`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:303:67
[INFO] [stderr]     |
[INFO] [stderr] 303 |                                 duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                   ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:303:87
[INFO] [stderr]     |
[INFO] [stderr] 303 |                                 duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                                       ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:307:50
[INFO] [stderr]     |
[INFO] [stderr] 307 |                                 quo.wrapping_add(mul as $uD),
[INFO] [stderr]     |                                                  ^^^^^^^^^^ help: try: `u32::from(mul)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:308:50
[INFO] [stderr]     |
[INFO] [stderr] 308 |                                 duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                  ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:308:70
[INFO] [stderr]     |
[INFO] [stderr] 308 |                                 duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                                      ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:29:28
[INFO] [stderr]     |
[INFO] [stderr] 29  |                 let temp = (lhs as $uD).wrapping_mul(rhs as $uD);
[INFO] [stderr]     |                            ^^^^^^^^^^^^ help: try: `u64::from(lhs)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:29:54
[INFO] [stderr]     |
[INFO] [stderr] 29  |                 let temp = (lhs as $uD).wrapping_mul(rhs as $uD);
[INFO] [stderr]     |                                                      ^^^^^^^^^^ help: try: `u64::from(rhs)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:34:28
[INFO] [stderr]     |
[INFO] [stderr] 34  |                 let temp = (lhs as $uD).wrapping_mul(mul as $uD).wrapping_add(add as $uD);
[INFO] [stderr]     |                            ^^^^^^^^^^^^ help: try: `u64::from(lhs)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:34:54
[INFO] [stderr]     |
[INFO] [stderr] 34  |                 let temp = (lhs as $uD).wrapping_mul(mul as $uD).wrapping_add(add as $uD);
[INFO] [stderr]     |                                                      ^^^^^^^^^^ help: try: `u64::from(mul)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:34:79
[INFO] [stderr]     |
[INFO] [stderr] 34  |                 let temp = (lhs as $uD).wrapping_mul(mul as $uD).wrapping_add(add as $uD);
[INFO] [stderr]     |                                                                               ^^^^^^^^^^ help: try: `u64::from(add)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:76:21
[INFO] [stderr]     |
[INFO] [stderr] 76  |                     (duo as $uX).wrapping_div(div as $uX) as $uD,
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u64::from((duo as $uX).wrapping_div(div as $uX))`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:77:21
[INFO] [stderr]     |
[INFO] [stderr] 77  |                     (duo as $uX).wrapping_rem(div as $uX) as $uD
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u64::from((duo as $uX).wrapping_rem(div as $uX))`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:85:30
[INFO] [stderr]     |
[INFO] [stderr] 85  |                 let div_lo = (div as $uH) as $uX;
[INFO] [stderr]     |                              ^^^^^^^^^^^^^^^^^^^ help: try: `u32::from((div as $uH))`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:94:22
[INFO] [stderr]     |
[INFO] [stderr] 94  |                     ((rem_2 as $uX) << $n_h) |
[INFO] [stderr]     |                      ^^^^^^^^^^^^^^ help: try: `u32::from(rem_2)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:95:21
[INFO] [stderr]     |
[INFO] [stderr] 95  |                     (((duo >> $n_h) as $uH) as $uX);
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::from(((duo >> $n_h) as $uH))`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:100:22
[INFO] [stderr]     |
[INFO] [stderr] 100 |                     ((rem_1 as $uX) << $n_h) |
[INFO] [stderr]     |                      ^^^^^^^^^^^^^^ help: try: `u32::from(rem_1)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:101:21
[INFO] [stderr]     |
[INFO] [stderr] 101 |                     ((duo as $uH) as $uX);
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::from((duo as $uH))`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:104:22
[INFO] [stderr]     |
[INFO] [stderr] 104 |                     ((quo_hi as $uD) << n) | ((quo_1 as $uD) << $n_h) | (quo_0 as $uD),
[INFO] [stderr]     |                      ^^^^^^^^^^^^^^^ help: try: `u64::from(quo_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:104:47
[INFO] [stderr]     |
[INFO] [stderr] 104 |                     ((quo_hi as $uD) << n) | ((quo_1 as $uD) << $n_h) | (quo_0 as $uD),
[INFO] [stderr]     |                                               ^^^^^^^^^^^^^^ help: try: `u64::from(quo_1)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:104:73
[INFO] [stderr]     |
[INFO] [stderr] 104 |                     ((quo_hi as $uD) << n) | ((quo_1 as $uD) << $n_h) | (quo_0 as $uD),
[INFO] [stderr]     |                                                                         ^^^^^^^^^^^^^^ help: try: `u64::from(quo_0)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:105:21
[INFO] [stderr]     |
[INFO] [stderr] 105 |                     (duo_lo.wrapping_rem(div_lo) as $uH) as $uD
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u64::from((duo_lo.wrapping_rem(div_lo) as $uH))`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:158:41
[INFO] [stderr]     |
[INFO] [stderr] 158 |                 if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                         ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:158:61
[INFO] [stderr]     |
[INFO] [stderr] 158 |                 if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                             ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:169:25
[INFO] [stderr]     |
[INFO] [stderr] 169 |                         mul.wrapping_sub(1) as $uD,
[INFO] [stderr]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u64::from(mul.wrapping_sub(1))`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:170:59
[INFO] [stderr]     |
[INFO] [stderr] 170 |                         duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                           ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:170:79
[INFO] [stderr]     |
[INFO] [stderr] 170 |                         duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                               ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:174:25
[INFO] [stderr]     |
[INFO] [stderr] 174 |                         mul as $uD,
[INFO] [stderr]     |                         ^^^^^^^^^^ help: try: `u64::from(mul)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:175:42
[INFO] [stderr]     |
[INFO] [stderr] 175 |                         duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                          ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:175:62
[INFO] [stderr]     |
[INFO] [stderr] 175 |                         duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                              ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:226:36
[INFO] [stderr]     |
[INFO] [stderr] 226 |             let div_sig_n_h_add1 = (div_sig_n_h as $uX).wrapping_add(1);
[INFO] [stderr]     |                                    ^^^^^^^^^^^^^^^^^^^^ help: try: `u32::from(div_sig_n_h)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:234:31
[INFO] [stderr]     |
[INFO] [stderr] 234 |                     let mul = duo_sig_n.wrapping_div(div_sig_n_h_add1) as $uD;
[INFO] [stderr]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u64::from(duo_sig_n.wrapping_div(div_sig_n_h_add1))`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:253:49
[INFO] [stderr]     |
[INFO] [stderr] 253 |                         if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                 ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:253:69
[INFO] [stderr]     |
[INFO] [stderr] 253 |                         if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                                     ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:256:50
[INFO] [stderr]     |
[INFO] [stderr] 256 |                                 quo.wrapping_add(mul.wrapping_sub(1) as $uD),
[INFO] [stderr]     |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u64::from(mul.wrapping_sub(1))`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:257:67
[INFO] [stderr]     |
[INFO] [stderr] 257 |                                 duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                   ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:257:87
[INFO] [stderr]     |
[INFO] [stderr] 257 |                                 duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                                       ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:261:50
[INFO] [stderr]     |
[INFO] [stderr] 261 |                                 quo.wrapping_add(mul as $uD),
[INFO] [stderr]     |                                                  ^^^^^^^^^^ help: try: `u64::from(mul)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:262:50
[INFO] [stderr]     |
[INFO] [stderr] 262 |                                 duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                  ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:262:70
[INFO] [stderr]     |
[INFO] [stderr] 262 |                                 duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                                      ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:270:46
[INFO] [stderr]     |
[INFO] [stderr] 270 |                             quo.wrapping_add((duo as $uX).wrapping_div(div as $uX) as $uD),
[INFO] [stderr]     |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u64::from((duo as $uX).wrapping_div(div as $uX))`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:271:29
[INFO] [stderr]     |
[INFO] [stderr] 271 |                             (duo as $uX).wrapping_rem(div as $uX) as $uD
[INFO] [stderr]     |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u64::from((duo as $uX).wrapping_rem(div as $uX))`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:281:31
[INFO] [stderr]     |
[INFO] [stderr] 281 |                     let mul = duo_sig_n.wrapping_div(div_sig_n_h_add1) as $uD;
[INFO] [stderr]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u64::from(duo_sig_n.wrapping_div(div_sig_n_h_add1))`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:300:49
[INFO] [stderr]     |
[INFO] [stderr] 300 |                         if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                 ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:300:69
[INFO] [stderr]     |
[INFO] [stderr] 300 |                         if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                                     ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:302:50
[INFO] [stderr]     |
[INFO] [stderr] 302 |                                 quo.wrapping_add(mul.wrapping_sub(1) as $uD),
[INFO] [stderr]     |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u64::from(mul.wrapping_sub(1))`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:303:67
[INFO] [stderr]     |
[INFO] [stderr] 303 |                                 duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                   ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:303:87
[INFO] [stderr]     |
[INFO] [stderr] 303 |                                 duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                                       ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:307:50
[INFO] [stderr]     |
[INFO] [stderr] 307 |                                 quo.wrapping_add(mul as $uD),
[INFO] [stderr]     |                                                  ^^^^^^^^^^ help: try: `u64::from(mul)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:308:50
[INFO] [stderr]     |
[INFO] [stderr] 308 |                                 duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                  ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:308:70
[INFO] [stderr]     |
[INFO] [stderr] 308 |                                 duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                                      ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:29:28
[INFO] [stderr]     |
[INFO] [stderr] 29  |                 let temp = (lhs as $uD).wrapping_mul(rhs as $uD);
[INFO] [stderr]     |                            ^^^^^^^^^^^^ help: try: `u128::from(lhs)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:29:54
[INFO] [stderr]     |
[INFO] [stderr] 29  |                 let temp = (lhs as $uD).wrapping_mul(rhs as $uD);
[INFO] [stderr]     |                                                      ^^^^^^^^^^ help: try: `u128::from(rhs)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:34:28
[INFO] [stderr]     |
[INFO] [stderr] 34  |                 let temp = (lhs as $uD).wrapping_mul(mul as $uD).wrapping_add(add as $uD);
[INFO] [stderr]     |                            ^^^^^^^^^^^^ help: try: `u128::from(lhs)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:34:54
[INFO] [stderr]     |
[INFO] [stderr] 34  |                 let temp = (lhs as $uD).wrapping_mul(mul as $uD).wrapping_add(add as $uD);
[INFO] [stderr]     |                                                      ^^^^^^^^^^ help: try: `u128::from(mul)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:34:79
[INFO] [stderr]     |
[INFO] [stderr] 34  |                 let temp = (lhs as $uD).wrapping_mul(mul as $uD).wrapping_add(add as $uD);
[INFO] [stderr]     |                                                                               ^^^^^^^^^^ help: try: `u128::from(add)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:76:21
[INFO] [stderr]     |
[INFO] [stderr] 76  |                     (duo as $uX).wrapping_div(div as $uX) as $uD,
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u128::from((duo as $uX).wrapping_div(div as $uX))`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:77:21
[INFO] [stderr]     |
[INFO] [stderr] 77  |                     (duo as $uX).wrapping_rem(div as $uX) as $uD
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u128::from((duo as $uX).wrapping_rem(div as $uX))`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:85:30
[INFO] [stderr]     |
[INFO] [stderr] 85  |                 let div_lo = (div as $uH) as $uX;
[INFO] [stderr]     |                              ^^^^^^^^^^^^^^^^^^^ help: try: `u64::from((div as $uH))`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:94:22
[INFO] [stderr]     |
[INFO] [stderr] 94  |                     ((rem_2 as $uX) << $n_h) |
[INFO] [stderr]     |                      ^^^^^^^^^^^^^^ help: try: `u64::from(rem_2)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:95:21
[INFO] [stderr]     |
[INFO] [stderr] 95  |                     (((duo >> $n_h) as $uH) as $uX);
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u64::from(((duo >> $n_h) as $uH))`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:100:22
[INFO] [stderr]     |
[INFO] [stderr] 100 |                     ((rem_1 as $uX) << $n_h) |
[INFO] [stderr]     |                      ^^^^^^^^^^^^^^ help: try: `u64::from(rem_1)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:101:21
[INFO] [stderr]     |
[INFO] [stderr] 101 |                     ((duo as $uH) as $uX);
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^ help: try: `u64::from((duo as $uH))`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:104:22
[INFO] [stderr]     |
[INFO] [stderr] 104 |                     ((quo_hi as $uD) << n) | ((quo_1 as $uD) << $n_h) | (quo_0 as $uD),
[INFO] [stderr]     |                      ^^^^^^^^^^^^^^^ help: try: `u128::from(quo_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:104:47
[INFO] [stderr]     |
[INFO] [stderr] 104 |                     ((quo_hi as $uD) << n) | ((quo_1 as $uD) << $n_h) | (quo_0 as $uD),
[INFO] [stderr]     |                                               ^^^^^^^^^^^^^^ help: try: `u128::from(quo_1)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:104:73
[INFO] [stderr]     |
[INFO] [stderr] 104 |                     ((quo_hi as $uD) << n) | ((quo_1 as $uD) << $n_h) | (quo_0 as $uD),
[INFO] [stderr]     |                                                                         ^^^^^^^^^^^^^^ help: try: `u128::from(quo_0)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:105:21
[INFO] [stderr]     |
[INFO] [stderr] 105 |                     (duo_lo.wrapping_rem(div_lo) as $uH) as $uD
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u128::from((duo_lo.wrapping_rem(div_lo) as $uH))`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:158:41
[INFO] [stderr]     |
[INFO] [stderr] 158 |                 if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                         ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:158:61
[INFO] [stderr]     |
[INFO] [stderr] 158 |                 if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                             ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:169:25
[INFO] [stderr]     |
[INFO] [stderr] 169 |                         mul.wrapping_sub(1) as $uD,
[INFO] [stderr]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u128::from(mul.wrapping_sub(1))`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:170:59
[INFO] [stderr]     |
[INFO] [stderr] 170 |                         duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                           ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:170:79
[INFO] [stderr]     |
[INFO] [stderr] 170 |                         duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                               ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:174:25
[INFO] [stderr]     |
[INFO] [stderr] 174 |                         mul as $uD,
[INFO] [stderr]     |                         ^^^^^^^^^^ help: try: `u128::from(mul)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:175:42
[INFO] [stderr]     |
[INFO] [stderr] 175 |                         duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                          ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:175:62
[INFO] [stderr]     |
[INFO] [stderr] 175 |                         duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                              ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:226:36
[INFO] [stderr]     |
[INFO] [stderr] 226 |             let div_sig_n_h_add1 = (div_sig_n_h as $uX).wrapping_add(1);
[INFO] [stderr]     |                                    ^^^^^^^^^^^^^^^^^^^^ help: try: `u64::from(div_sig_n_h)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:234:31
[INFO] [stderr]     |
[INFO] [stderr] 234 |                     let mul = duo_sig_n.wrapping_div(div_sig_n_h_add1) as $uD;
[INFO] [stderr]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u128::from(duo_sig_n.wrapping_div(div_sig_n_h_add1))`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:253:49
[INFO] [stderr]     |
[INFO] [stderr] 253 |                         if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                 ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:253:69
[INFO] [stderr]     |
[INFO] [stderr] 253 |                         if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                                     ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:256:50
[INFO] [stderr]     |
[INFO] [stderr] 256 |                                 quo.wrapping_add(mul.wrapping_sub(1) as $uD),
[INFO] [stderr]     |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u128::from(mul.wrapping_sub(1))`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:257:67
[INFO] [stderr]     |
[INFO] [stderr] 257 |                                 duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                   ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:257:87
[INFO] [stderr]     |
[INFO] [stderr] 257 |                                 duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                                       ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:261:50
[INFO] [stderr]     |
[INFO] [stderr] 261 |                                 quo.wrapping_add(mul as $uD),
[INFO] [stderr]     |                                                  ^^^^^^^^^^ help: try: `u128::from(mul)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:262:50
[INFO] [stderr]     |
[INFO] [stderr] 262 |                                 duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                  ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:262:70
[INFO] [stderr]     |
[INFO] [stderr] 262 |                                 duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                                      ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:270:46
[INFO] [stderr]     |
[INFO] [stderr] 270 |                             quo.wrapping_add((duo as $uX).wrapping_div(div as $uX) as $uD),
[INFO] [stderr]     |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u128::from((duo as $uX).wrapping_div(div as $uX))`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:271:29
[INFO] [stderr]     |
[INFO] [stderr] 271 |                             (duo as $uX).wrapping_rem(div as $uX) as $uD
[INFO] [stderr]     |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u128::from((duo as $uX).wrapping_rem(div as $uX))`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:281:31
[INFO] [stderr]     |
[INFO] [stderr] 281 |                     let mul = duo_sig_n.wrapping_div(div_sig_n_h_add1) as $uD;
[INFO] [stderr]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u128::from(duo_sig_n.wrapping_div(div_sig_n_h_add1))`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:300:49
[INFO] [stderr]     |
[INFO] [stderr] 300 |                         if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                 ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:300:69
[INFO] [stderr]     |
[INFO] [stderr] 300 |                         if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                                     ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:302:50
[INFO] [stderr]     |
[INFO] [stderr] 302 |                                 quo.wrapping_add(mul.wrapping_sub(1) as $uD),
[INFO] [stderr]     |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u128::from(mul.wrapping_sub(1))`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:303:67
[INFO] [stderr]     |
[INFO] [stderr] 303 |                                 duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                   ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:303:87
[INFO] [stderr]     |
[INFO] [stderr] 303 |                                 duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                                       ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:307:50
[INFO] [stderr]     |
[INFO] [stderr] 307 |                                 quo.wrapping_add(mul as $uD),
[INFO] [stderr]     |                                                  ^^^^^^^^^^ help: try: `u128::from(mul)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:308:50
[INFO] [stderr]     |
[INFO] [stderr] 308 |                                 duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                  ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:308:70
[INFO] [stderr]     |
[INFO] [stderr] 308 |                                 duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                                      ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] error[E0554]: #![feature] may not be used on the stable release channel
[INFO] [stderr]  --> benches/bench.rs:1:1
[INFO] [stderr]   |
[INFO] [stderr] 1 | #![feature(test)]
[INFO] [stderr]   | ^^^^^^^^^^^^^^^^^
[INFO] [stderr] 
[INFO] [stderr] error: aborting due to previous error
[INFO] [stderr] 
[INFO] [stderr] For more information about this error, try `rustc --explain E0554`.
[INFO] [stderr] error: Could not compile `specialized-div-rem`.
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stderr] warning: long literal lacking separators
[INFO] [stderr]    --> src/all_all.rs:424:90
[INFO] [stderr]     |
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     |                                                                                          ^^^^^^^^^^^ help: consider: `0b11_1111u32`
[INFO] [stderr]     |
[INFO] [stderr]     = note: #[warn(clippy::unreadable_literal)] on by default
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal
[INFO] [stderr] 
[INFO] [stderr] warning: long literal lacking separators
[INFO] [stderr]    --> src/all_all.rs:424:90
[INFO] [stderr]     |
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     |                                                                                          ^^^^^^^^^^^ help: consider: `0b11_1111u32`
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal
[INFO] [stderr] 
[INFO] [stderr] warning: long literal lacking separators
[INFO] [stderr]    --> src/all_all.rs:425:96
[INFO] [stderr]     |
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     |                                                                                                ^^^^^^^^^^^^ help: consider: `0b111_1111u32`
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#unreadable_literal
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:29:28
[INFO] [stderr]     |
[INFO] [stderr] 29  |                 let temp = (lhs as $uD).wrapping_mul(rhs as $uD);
[INFO] [stderr]     |                            ^^^^^^^^^^^^ help: try: `u32::from(lhs)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = note: #[warn(clippy::cast_lossless)] on by default
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:29:54
[INFO] [stderr]     |
[INFO] [stderr] 29  |                 let temp = (lhs as $uD).wrapping_mul(rhs as $uD);
[INFO] [stderr]     |                                                      ^^^^^^^^^^ help: try: `u32::from(rhs)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:34:28
[INFO] [stderr]     |
[INFO] [stderr] 34  |                 let temp = (lhs as $uD).wrapping_mul(mul as $uD).wrapping_add(add as $uD);
[INFO] [stderr]     |                            ^^^^^^^^^^^^ help: try: `u32::from(lhs)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:34:54
[INFO] [stderr]     |
[INFO] [stderr] 34  |                 let temp = (lhs as $uD).wrapping_mul(mul as $uD).wrapping_add(add as $uD);
[INFO] [stderr]     |                                                      ^^^^^^^^^^ help: try: `u32::from(mul)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:34:79
[INFO] [stderr]     |
[INFO] [stderr] 34  |                 let temp = (lhs as $uD).wrapping_mul(mul as $uD).wrapping_add(add as $uD);
[INFO] [stderr]     |                                                                               ^^^^^^^^^^ help: try: `u32::from(add)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:76:21
[INFO] [stderr]     |
[INFO] [stderr] 76  |                     (duo as $uX).wrapping_div(div as $uX) as $uD,
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::from((duo as $uX).wrapping_div(div as $uX))`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:77:21
[INFO] [stderr]     |
[INFO] [stderr] 77  |                     (duo as $uX).wrapping_rem(div as $uX) as $uD
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::from((duo as $uX).wrapping_rem(div as $uX))`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u8 to u16 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:85:30
[INFO] [stderr]     |
[INFO] [stderr] 85  |                 let div_lo = (div as $uH) as $uX;
[INFO] [stderr]     |                              ^^^^^^^^^^^^^^^^^^^ help: try: `u16::from((div as $uH))`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u8 to u16 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:94:22
[INFO] [stderr]     |
[INFO] [stderr] 94  |                     ((rem_2 as $uX) << $n_h) |
[INFO] [stderr]     |                      ^^^^^^^^^^^^^^ help: try: `u16::from(rem_2)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u8 to u16 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:95:21
[INFO] [stderr]     |
[INFO] [stderr] 95  |                     (((duo >> $n_h) as $uH) as $uX);
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u16::from(((duo >> $n_h) as $uH))`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u8 to u16 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:100:22
[INFO] [stderr]     |
[INFO] [stderr] 100 |                     ((rem_1 as $uX) << $n_h) |
[INFO] [stderr]     |                      ^^^^^^^^^^^^^^ help: try: `u16::from(rem_1)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u8 to u16 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:101:21
[INFO] [stderr]     |
[INFO] [stderr] 101 |                     ((duo as $uH) as $uX);
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^ help: try: `u16::from((duo as $uH))`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:104:22
[INFO] [stderr]     |
[INFO] [stderr] 104 |                     ((quo_hi as $uD) << n) | ((quo_1 as $uD) << $n_h) | (quo_0 as $uD),
[INFO] [stderr]     |                      ^^^^^^^^^^^^^^^ help: try: `u32::from(quo_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u8 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:104:47
[INFO] [stderr]     |
[INFO] [stderr] 104 |                     ((quo_hi as $uD) << n) | ((quo_1 as $uD) << $n_h) | (quo_0 as $uD),
[INFO] [stderr]     |                                               ^^^^^^^^^^^^^^ help: try: `u32::from(quo_1)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u8 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:104:73
[INFO] [stderr]     |
[INFO] [stderr] 104 |                     ((quo_hi as $uD) << n) | ((quo_1 as $uD) << $n_h) | (quo_0 as $uD),
[INFO] [stderr]     |                                                                         ^^^^^^^^^^^^^^ help: try: `u32::from(quo_0)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u8 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:105:21
[INFO] [stderr]     |
[INFO] [stderr] 105 |                     (duo_lo.wrapping_rem(div_lo) as $uH) as $uD
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::from((duo_lo.wrapping_rem(div_lo) as $uH))`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:158:41
[INFO] [stderr]     |
[INFO] [stderr] 158 |                 if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                         ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:158:61
[INFO] [stderr]     |
[INFO] [stderr] 158 |                 if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                             ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:169:25
[INFO] [stderr]     |
[INFO] [stderr] 169 |                         mul.wrapping_sub(1) as $uD,
[INFO] [stderr]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::from(mul.wrapping_sub(1))`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:170:59
[INFO] [stderr]     |
[INFO] [stderr] 170 |                         duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                           ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:170:79
[INFO] [stderr]     |
[INFO] [stderr] 170 |                         duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                               ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:174:25
[INFO] [stderr]     |
[INFO] [stderr] 174 |                         mul as $uD,
[INFO] [stderr]     |                         ^^^^^^^^^^ help: try: `u32::from(mul)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:175:42
[INFO] [stderr]     |
[INFO] [stderr] 175 |                         duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                          ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:175:62
[INFO] [stderr]     |
[INFO] [stderr] 175 |                         duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                              ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u8 to u16 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:226:36
[INFO] [stderr]     |
[INFO] [stderr] 226 |             let div_sig_n_h_add1 = (div_sig_n_h as $uX).wrapping_add(1);
[INFO] [stderr]     |                                    ^^^^^^^^^^^^^^^^^^^^ help: try: `u16::from(div_sig_n_h)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:234:31
[INFO] [stderr]     |
[INFO] [stderr] 234 |                     let mul = duo_sig_n.wrapping_div(div_sig_n_h_add1) as $uD;
[INFO] [stderr]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::from(duo_sig_n.wrapping_div(div_sig_n_h_add1))`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:253:49
[INFO] [stderr]     |
[INFO] [stderr] 253 |                         if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                 ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:253:69
[INFO] [stderr]     |
[INFO] [stderr] 253 |                         if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                                     ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:256:50
[INFO] [stderr]     |
[INFO] [stderr] 256 |                                 quo.wrapping_add(mul.wrapping_sub(1) as $uD),
[INFO] [stderr]     |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::from(mul.wrapping_sub(1))`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:257:67
[INFO] [stderr]     |
[INFO] [stderr] 257 |                                 duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                   ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:257:87
[INFO] [stderr]     |
[INFO] [stderr] 257 |                                 duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                                       ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:261:50
[INFO] [stderr]     |
[INFO] [stderr] 261 |                                 quo.wrapping_add(mul as $uD),
[INFO] [stderr]     |                                                  ^^^^^^^^^^ help: try: `u32::from(mul)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:262:50
[INFO] [stderr]     |
[INFO] [stderr] 262 |                                 duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                  ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:262:70
[INFO] [stderr]     |
[INFO] [stderr] 262 |                                 duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                                      ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:270:46
[INFO] [stderr]     |
[INFO] [stderr] 270 |                             quo.wrapping_add((duo as $uX).wrapping_div(div as $uX) as $uD),
[INFO] [stderr]     |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::from((duo as $uX).wrapping_div(div as $uX))`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:271:29
[INFO] [stderr]     |
[INFO] [stderr] 271 |                             (duo as $uX).wrapping_rem(div as $uX) as $uD
[INFO] [stderr]     |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::from((duo as $uX).wrapping_rem(div as $uX))`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:281:31
[INFO] [stderr]     |
[INFO] [stderr] 281 |                     let mul = duo_sig_n.wrapping_div(div_sig_n_h_add1) as $uD;
[INFO] [stderr]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::from(duo_sig_n.wrapping_div(div_sig_n_h_add1))`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:300:49
[INFO] [stderr]     |
[INFO] [stderr] 300 |                         if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                 ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:300:69
[INFO] [stderr]     |
[INFO] [stderr] 300 |                         if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                                     ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:302:50
[INFO] [stderr]     |
[INFO] [stderr] 302 |                                 quo.wrapping_add(mul.wrapping_sub(1) as $uD),
[INFO] [stderr]     |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::from(mul.wrapping_sub(1))`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:303:67
[INFO] [stderr]     |
[INFO] [stderr] 303 |                                 duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                   ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:303:87
[INFO] [stderr]     |
[INFO] [stderr] 303 |                                 duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                                       ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:307:50
[INFO] [stderr]     |
[INFO] [stderr] 307 |                                 quo.wrapping_add(mul as $uD),
[INFO] [stderr]     |                                                  ^^^^^^^^^^ help: try: `u32::from(mul)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:308:50
[INFO] [stderr]     |
[INFO] [stderr] 308 |                                 duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                  ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:308:70
[INFO] [stderr]     |
[INFO] [stderr] 308 |                                 duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                                      ^^^^^^^^^^^^^^^^ help: try: `u32::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 423 | impl_div_rem!(u32_div_rem, i32_div_rem, u32_i32_div_rem_test, 8u32, u8, u16, u32, i32, 0b11111u32, inline; inline, doc = "Note that unlike Rust's division, `i32_div_rem(i32::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i32::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:29:28
[INFO] [stderr]     |
[INFO] [stderr] 29  |                 let temp = (lhs as $uD).wrapping_mul(rhs as $uD);
[INFO] [stderr]     |                            ^^^^^^^^^^^^ help: try: `u64::from(lhs)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:29:54
[INFO] [stderr]     |
[INFO] [stderr] 29  |                 let temp = (lhs as $uD).wrapping_mul(rhs as $uD);
[INFO] [stderr]     |                                                      ^^^^^^^^^^ help: try: `u64::from(rhs)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:34:28
[INFO] [stderr]     |
[INFO] [stderr] 34  |                 let temp = (lhs as $uD).wrapping_mul(mul as $uD).wrapping_add(add as $uD);
[INFO] [stderr]     |                            ^^^^^^^^^^^^ help: try: `u64::from(lhs)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:34:54
[INFO] [stderr]     |
[INFO] [stderr] 34  |                 let temp = (lhs as $uD).wrapping_mul(mul as $uD).wrapping_add(add as $uD);
[INFO] [stderr]     |                                                      ^^^^^^^^^^ help: try: `u64::from(mul)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:34:79
[INFO] [stderr]     |
[INFO] [stderr] 34  |                 let temp = (lhs as $uD).wrapping_mul(mul as $uD).wrapping_add(add as $uD);
[INFO] [stderr]     |                                                                               ^^^^^^^^^^ help: try: `u64::from(add)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:76:21
[INFO] [stderr]     |
[INFO] [stderr] 76  |                     (duo as $uX).wrapping_div(div as $uX) as $uD,
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u64::from((duo as $uX).wrapping_div(div as $uX))`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:77:21
[INFO] [stderr]     |
[INFO] [stderr] 77  |                     (duo as $uX).wrapping_rem(div as $uX) as $uD
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u64::from((duo as $uX).wrapping_rem(div as $uX))`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:85:30
[INFO] [stderr]     |
[INFO] [stderr] 85  |                 let div_lo = (div as $uH) as $uX;
[INFO] [stderr]     |                              ^^^^^^^^^^^^^^^^^^^ help: try: `u32::from((div as $uH))`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:94:22
[INFO] [stderr]     |
[INFO] [stderr] 94  |                     ((rem_2 as $uX) << $n_h) |
[INFO] [stderr]     |                      ^^^^^^^^^^^^^^ help: try: `u32::from(rem_2)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:95:21
[INFO] [stderr]     |
[INFO] [stderr] 95  |                     (((duo >> $n_h) as $uH) as $uX);
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::from(((duo >> $n_h) as $uH))`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:100:22
[INFO] [stderr]     |
[INFO] [stderr] 100 |                     ((rem_1 as $uX) << $n_h) |
[INFO] [stderr]     |                      ^^^^^^^^^^^^^^ help: try: `u32::from(rem_1)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:101:21
[INFO] [stderr]     |
[INFO] [stderr] 101 |                     ((duo as $uH) as $uX);
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::from((duo as $uH))`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:104:22
[INFO] [stderr]     |
[INFO] [stderr] 104 |                     ((quo_hi as $uD) << n) | ((quo_1 as $uD) << $n_h) | (quo_0 as $uD),
[INFO] [stderr]     |                      ^^^^^^^^^^^^^^^ help: try: `u64::from(quo_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:104:47
[INFO] [stderr]     |
[INFO] [stderr] 104 |                     ((quo_hi as $uD) << n) | ((quo_1 as $uD) << $n_h) | (quo_0 as $uD),
[INFO] [stderr]     |                                               ^^^^^^^^^^^^^^ help: try: `u64::from(quo_1)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:104:73
[INFO] [stderr]     |
[INFO] [stderr] 104 |                     ((quo_hi as $uD) << n) | ((quo_1 as $uD) << $n_h) | (quo_0 as $uD),
[INFO] [stderr]     |                                                                         ^^^^^^^^^^^^^^ help: try: `u64::from(quo_0)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:105:21
[INFO] [stderr]     |
[INFO] [stderr] 105 |                     (duo_lo.wrapping_rem(div_lo) as $uH) as $uD
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u64::from((duo_lo.wrapping_rem(div_lo) as $uH))`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:158:41
[INFO] [stderr]     |
[INFO] [stderr] 158 |                 if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                         ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:158:61
[INFO] [stderr]     |
[INFO] [stderr] 158 |                 if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                             ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:169:25
[INFO] [stderr]     |
[INFO] [stderr] 169 |                         mul.wrapping_sub(1) as $uD,
[INFO] [stderr]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u64::from(mul.wrapping_sub(1))`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:170:59
[INFO] [stderr]     |
[INFO] [stderr] 170 |                         duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                           ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:170:79
[INFO] [stderr]     |
[INFO] [stderr] 170 |                         duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                               ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:174:25
[INFO] [stderr]     |
[INFO] [stderr] 174 |                         mul as $uD,
[INFO] [stderr]     |                         ^^^^^^^^^^ help: try: `u64::from(mul)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:175:42
[INFO] [stderr]     |
[INFO] [stderr] 175 |                         duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                          ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:175:62
[INFO] [stderr]     |
[INFO] [stderr] 175 |                         duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                              ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u16 to u32 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:226:36
[INFO] [stderr]     |
[INFO] [stderr] 226 |             let div_sig_n_h_add1 = (div_sig_n_h as $uX).wrapping_add(1);
[INFO] [stderr]     |                                    ^^^^^^^^^^^^^^^^^^^^ help: try: `u32::from(div_sig_n_h)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:234:31
[INFO] [stderr]     |
[INFO] [stderr] 234 |                     let mul = duo_sig_n.wrapping_div(div_sig_n_h_add1) as $uD;
[INFO] [stderr]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u64::from(duo_sig_n.wrapping_div(div_sig_n_h_add1))`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:253:49
[INFO] [stderr]     |
[INFO] [stderr] 253 |                         if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                 ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:253:69
[INFO] [stderr]     |
[INFO] [stderr] 253 |                         if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                                     ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:256:50
[INFO] [stderr]     |
[INFO] [stderr] 256 |                                 quo.wrapping_add(mul.wrapping_sub(1) as $uD),
[INFO] [stderr]     |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u64::from(mul.wrapping_sub(1))`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:257:67
[INFO] [stderr]     |
[INFO] [stderr] 257 |                                 duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                   ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:257:87
[INFO] [stderr]     |
[INFO] [stderr] 257 |                                 duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                                       ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:261:50
[INFO] [stderr]     |
[INFO] [stderr] 261 |                                 quo.wrapping_add(mul as $uD),
[INFO] [stderr]     |                                                  ^^^^^^^^^^ help: try: `u64::from(mul)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:262:50
[INFO] [stderr]     |
[INFO] [stderr] 262 |                                 duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                  ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:262:70
[INFO] [stderr]     |
[INFO] [stderr] 262 |                                 duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                                      ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:270:46
[INFO] [stderr]     |
[INFO] [stderr] 270 |                             quo.wrapping_add((duo as $uX).wrapping_div(div as $uX) as $uD),
[INFO] [stderr]     |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u64::from((duo as $uX).wrapping_div(div as $uX))`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:271:29
[INFO] [stderr]     |
[INFO] [stderr] 271 |                             (duo as $uX).wrapping_rem(div as $uX) as $uD
[INFO] [stderr]     |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u64::from((duo as $uX).wrapping_rem(div as $uX))`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:281:31
[INFO] [stderr]     |
[INFO] [stderr] 281 |                     let mul = duo_sig_n.wrapping_div(div_sig_n_h_add1) as $uD;
[INFO] [stderr]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u64::from(duo_sig_n.wrapping_div(div_sig_n_h_add1))`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:300:49
[INFO] [stderr]     |
[INFO] [stderr] 300 |                         if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                 ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:300:69
[INFO] [stderr]     |
[INFO] [stderr] 300 |                         if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                                     ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:302:50
[INFO] [stderr]     |
[INFO] [stderr] 302 |                                 quo.wrapping_add(mul.wrapping_sub(1) as $uD),
[INFO] [stderr]     |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u64::from(mul.wrapping_sub(1))`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:303:67
[INFO] [stderr]     |
[INFO] [stderr] 303 |                                 duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                   ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:303:87
[INFO] [stderr]     |
[INFO] [stderr] 303 |                                 duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                                       ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:307:50
[INFO] [stderr]     |
[INFO] [stderr] 307 |                                 quo.wrapping_add(mul as $uD),
[INFO] [stderr]     |                                                  ^^^^^^^^^^ help: try: `u64::from(mul)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:308:50
[INFO] [stderr]     |
[INFO] [stderr] 308 |                                 duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                  ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:308:70
[INFO] [stderr]     |
[INFO] [stderr] 308 |                                 duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                                      ^^^^^^^^^^^^^^^^ help: try: `u64::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 424 | impl_div_rem!(u64_div_rem, i64_div_rem, u64_i64_div_rem_test, 16u32, u16, u32, u64, i64, 0b111111u32, inline; inline, doc = "Note that unlike Rust's division, `i64_div_rem(i64::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i64::MIN,0)`.");
[INFO] [stderr]     | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:29:28
[INFO] [stderr]     |
[INFO] [stderr] 29  |                 let temp = (lhs as $uD).wrapping_mul(rhs as $uD);
[INFO] [stderr]     |                            ^^^^^^^^^^^^ help: try: `u128::from(lhs)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:29:54
[INFO] [stderr]     |
[INFO] [stderr] 29  |                 let temp = (lhs as $uD).wrapping_mul(rhs as $uD);
[INFO] [stderr]     |                                                      ^^^^^^^^^^ help: try: `u128::from(rhs)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:34:28
[INFO] [stderr]     |
[INFO] [stderr] 34  |                 let temp = (lhs as $uD).wrapping_mul(mul as $uD).wrapping_add(add as $uD);
[INFO] [stderr]     |                            ^^^^^^^^^^^^ help: try: `u128::from(lhs)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:34:54
[INFO] [stderr]     |
[INFO] [stderr] 34  |                 let temp = (lhs as $uD).wrapping_mul(mul as $uD).wrapping_add(add as $uD);
[INFO] [stderr]     |                                                      ^^^^^^^^^^ help: try: `u128::from(mul)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:34:79
[INFO] [stderr]     |
[INFO] [stderr] 34  |                 let temp = (lhs as $uD).wrapping_mul(mul as $uD).wrapping_add(add as $uD);
[INFO] [stderr]     |                                                                               ^^^^^^^^^^ help: try: `u128::from(add)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:76:21
[INFO] [stderr]     |
[INFO] [stderr] 76  |                     (duo as $uX).wrapping_div(div as $uX) as $uD,
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u128::from((duo as $uX).wrapping_div(div as $uX))`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:77:21
[INFO] [stderr]     |
[INFO] [stderr] 77  |                     (duo as $uX).wrapping_rem(div as $uX) as $uD
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u128::from((duo as $uX).wrapping_rem(div as $uX))`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:85:30
[INFO] [stderr]     |
[INFO] [stderr] 85  |                 let div_lo = (div as $uH) as $uX;
[INFO] [stderr]     |                              ^^^^^^^^^^^^^^^^^^^ help: try: `u64::from((div as $uH))`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:94:22
[INFO] [stderr]     |
[INFO] [stderr] 94  |                     ((rem_2 as $uX) << $n_h) |
[INFO] [stderr]     |                      ^^^^^^^^^^^^^^ help: try: `u64::from(rem_2)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:95:21
[INFO] [stderr]     |
[INFO] [stderr] 95  |                     (((duo >> $n_h) as $uH) as $uX);
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u64::from(((duo >> $n_h) as $uH))`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:100:22
[INFO] [stderr]     |
[INFO] [stderr] 100 |                     ((rem_1 as $uX) << $n_h) |
[INFO] [stderr]     |                      ^^^^^^^^^^^^^^ help: try: `u64::from(rem_1)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:101:21
[INFO] [stderr]     |
[INFO] [stderr] 101 |                     ((duo as $uH) as $uX);
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^ help: try: `u64::from((duo as $uH))`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:104:22
[INFO] [stderr]     |
[INFO] [stderr] 104 |                     ((quo_hi as $uD) << n) | ((quo_1 as $uD) << $n_h) | (quo_0 as $uD),
[INFO] [stderr]     |                      ^^^^^^^^^^^^^^^ help: try: `u128::from(quo_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:104:47
[INFO] [stderr]     |
[INFO] [stderr] 104 |                     ((quo_hi as $uD) << n) | ((quo_1 as $uD) << $n_h) | (quo_0 as $uD),
[INFO] [stderr]     |                                               ^^^^^^^^^^^^^^ help: try: `u128::from(quo_1)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:104:73
[INFO] [stderr]     |
[INFO] [stderr] 104 |                     ((quo_hi as $uD) << n) | ((quo_1 as $uD) << $n_h) | (quo_0 as $uD),
[INFO] [stderr]     |                                                                         ^^^^^^^^^^^^^^ help: try: `u128::from(quo_0)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:105:21
[INFO] [stderr]     |
[INFO] [stderr] 105 |                     (duo_lo.wrapping_rem(div_lo) as $uH) as $uD
[INFO] [stderr]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u128::from((duo_lo.wrapping_rem(div_lo) as $uH))`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:158:41
[INFO] [stderr]     |
[INFO] [stderr] 158 |                 if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                         ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:158:61
[INFO] [stderr]     |
[INFO] [stderr] 158 |                 if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                             ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:169:25
[INFO] [stderr]     |
[INFO] [stderr] 169 |                         mul.wrapping_sub(1) as $uD,
[INFO] [stderr]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u128::from(mul.wrapping_sub(1))`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:170:59
[INFO] [stderr]     |
[INFO] [stderr] 170 |                         duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                           ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:170:79
[INFO] [stderr]     |
[INFO] [stderr] 170 |                         duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                               ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:174:25
[INFO] [stderr]     |
[INFO] [stderr] 174 |                         mul as $uD,
[INFO] [stderr]     |                         ^^^^^^^^^^ help: try: `u128::from(mul)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:175:42
[INFO] [stderr]     |
[INFO] [stderr] 175 |                         duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                          ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:175:62
[INFO] [stderr]     |
[INFO] [stderr] 175 |                         duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                              ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u32 to u64 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:226:36
[INFO] [stderr]     |
[INFO] [stderr] 226 |             let div_sig_n_h_add1 = (div_sig_n_h as $uX).wrapping_add(1);
[INFO] [stderr]     |                                    ^^^^^^^^^^^^^^^^^^^^ help: try: `u64::from(div_sig_n_h)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:234:31
[INFO] [stderr]     |
[INFO] [stderr] 234 |                     let mul = duo_sig_n.wrapping_div(div_sig_n_h_add1) as $uD;
[INFO] [stderr]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u128::from(duo_sig_n.wrapping_div(div_sig_n_h_add1))`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:253:49
[INFO] [stderr]     |
[INFO] [stderr] 253 |                         if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                 ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:253:69
[INFO] [stderr]     |
[INFO] [stderr] 253 |                         if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                                     ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:256:50
[INFO] [stderr]     |
[INFO] [stderr] 256 |                                 quo.wrapping_add(mul.wrapping_sub(1) as $uD),
[INFO] [stderr]     |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u128::from(mul.wrapping_sub(1))`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:257:67
[INFO] [stderr]     |
[INFO] [stderr] 257 |                                 duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                   ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:257:87
[INFO] [stderr]     |
[INFO] [stderr] 257 |                                 duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                                       ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:261:50
[INFO] [stderr]     |
[INFO] [stderr] 261 |                                 quo.wrapping_add(mul as $uD),
[INFO] [stderr]     |                                                  ^^^^^^^^^^ help: try: `u128::from(mul)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:262:50
[INFO] [stderr]     |
[INFO] [stderr] 262 |                                 duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                  ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:262:70
[INFO] [stderr]     |
[INFO] [stderr] 262 |                                 duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                                      ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:270:46
[INFO] [stderr]     |
[INFO] [stderr] 270 |                             quo.wrapping_add((duo as $uX).wrapping_div(div as $uX) as $uD),
[INFO] [stderr]     |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u128::from((duo as $uX).wrapping_div(div as $uX))`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:271:29
[INFO] [stderr]     |
[INFO] [stderr] 271 |                             (duo as $uX).wrapping_rem(div as $uX) as $uD
[INFO] [stderr]     |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u128::from((duo as $uX).wrapping_rem(div as $uX))`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:281:31
[INFO] [stderr]     |
[INFO] [stderr] 281 |                     let mul = duo_sig_n.wrapping_div(div_sig_n_h_add1) as $uD;
[INFO] [stderr]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u128::from(duo_sig_n.wrapping_div(div_sig_n_h_add1))`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:300:49
[INFO] [stderr]     |
[INFO] [stderr] 300 |                         if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                 ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:300:69
[INFO] [stderr]     |
[INFO] [stderr] 300 |                         if (overflow != 0) || (((temp_lo as $uD) | ((temp_hi as $uD) << n)) > duo) {
[INFO] [stderr]     |                                                                     ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:302:50
[INFO] [stderr]     |
[INFO] [stderr] 302 |                                 quo.wrapping_add(mul.wrapping_sub(1) as $uD),
[INFO] [stderr]     |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u128::from(mul.wrapping_sub(1))`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:303:67
[INFO] [stderr]     |
[INFO] [stderr] 303 |                                 duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                   ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:303:87
[INFO] [stderr]     |
[INFO] [stderr] 303 |                                 duo.wrapping_add(div.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n)))
[INFO] [stderr]     |                                                                                       ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:307:50
[INFO] [stderr]     |
[INFO] [stderr] 307 |                                 quo.wrapping_add(mul as $uD),
[INFO] [stderr]     |                                                  ^^^^^^^^^^ help: try: `u128::from(mul)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:308:50
[INFO] [stderr]     |
[INFO] [stderr] 308 |                                 duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                  ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_lo)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] warning: casting u64 to u128 may become silently lossy if types change
[INFO] [stderr]    --> src/all_all.rs:308:70
[INFO] [stderr]     |
[INFO] [stderr] 308 |                                 duo.wrapping_sub((temp_lo as $uD) | ((temp_hi as $uD) << n))
[INFO] [stderr]     |                                                                      ^^^^^^^^^^^^^^^^ help: try: `u128::from(temp_hi)`
[INFO] [stderr] ...
[INFO] [stderr] 425 | impl_div_rem!(u128_div_rem, i128_div_rem, u128_i128_div_rem_test, 32u32, u32, u64, u128, i128, 0b1111111u32, inline; inline, doc = "Note that unlike Rust's division, `i128_div_rem(i128::MIN,-1)` will not panic but instead overflow and produce the correct truncated two's complement `(i128::MIN,0)`.");
[INFO] [stderr]     | ------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stderr]     |
[INFO] [stderr]     = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#cast_lossless
[INFO] [stderr] 
[INFO] [stderr] error: build failed
[INFO] running `"docker" "inspect" "9462ada61303b6718415c850bbd27eb1c52cf191c3b09c2fb86a8f36484ac986"`
[INFO] running `"docker" "rm" "-f" "9462ada61303b6718415c850bbd27eb1c52cf191c3b09c2fb86a8f36484ac986"`
[INFO] [stdout] 9462ada61303b6718415c850bbd27eb1c52cf191c3b09c2fb86a8f36484ac986