Debian Codegraph @

target/debug/build/typenum-87a23218204ae76e/out/tests.rs

raw
1
2 use typenum::*;
3 use core::ops::*;
4 use core::cmp::Ordering;
5
6 #[test]
7 #[allow(non_snake_case)]
8 fn test_0_BitAnd_0() {
9 type A = UTerm;
10 type B = UTerm;
11 type U0 = UTerm;
12
13 #[allow(non_camel_case_types)]
14 type U0BitAndU0 = <<A as BitAnd<B>>::Output as Same<U0>>::Output;
15
16 assert_eq!(<U0BitAndU0 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
17 }
18 #[test]
19 #[allow(non_snake_case)]
20 fn test_0_BitOr_0() {
21 type A = UTerm;
22 type B = UTerm;
23 type U0 = UTerm;
24
25 #[allow(non_camel_case_types)]
26 type U0BitOrU0 = <<A as BitOr<B>>::Output as Same<U0>>::Output;
27
28 assert_eq!(<U0BitOrU0 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
29 }
30 #[test]
31 #[allow(non_snake_case)]
32 fn test_0_BitXor_0() {
33 type A = UTerm;
34 type B = UTerm;
35 type U0 = UTerm;
36
37 #[allow(non_camel_case_types)]
38 type U0BitXorU0 = <<A as BitXor<B>>::Output as Same<U0>>::Output;
39
40 assert_eq!(<U0BitXorU0 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
41 }
42 #[test]
43 #[allow(non_snake_case)]
44 fn test_0_Shl_0() {
45 type A = UTerm;
46 type B = UTerm;
47 type U0 = UTerm;
48
49 #[allow(non_camel_case_types)]
50 type U0ShlU0 = <<A as Shl<B>>::Output as Same<U0>>::Output;
51
52 assert_eq!(<U0ShlU0 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
53 }
54 #[test]
55 #[allow(non_snake_case)]
56 fn test_0_Shr_0() {
57 type A = UTerm;
58 type B = UTerm;
59 type U0 = UTerm;
60
61 #[allow(non_camel_case_types)]
62 type U0ShrU0 = <<A as Shr<B>>::Output as Same<U0>>::Output;
63
64 assert_eq!(<U0ShrU0 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
65 }
66 #[test]
67 #[allow(non_snake_case)]
68 fn test_0_Add_0() {
69 type A = UTerm;
70 type B = UTerm;
71 type U0 = UTerm;
72
73 #[allow(non_camel_case_types)]
74 type U0AddU0 = <<A as Add<B>>::Output as Same<U0>>::Output;
75
76 assert_eq!(<U0AddU0 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
77 }
78 #[test]
79 #[allow(non_snake_case)]
80 fn test_0_Mul_0() {
81 type A = UTerm;
82 type B = UTerm;
83 type U0 = UTerm;
84
85 #[allow(non_camel_case_types)]
86 type U0MulU0 = <<A as Mul<B>>::Output as Same<U0>>::Output;
87
88 assert_eq!(<U0MulU0 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
89 }
90 #[test]
91 #[allow(non_snake_case)]
92 fn test_0_Pow_0() {
93 type A = UTerm;
94 type B = UTerm;
95 type U1 = UInt<UTerm, B1>;
96
97 #[allow(non_camel_case_types)]
98 type U0PowU0 = <<A as Pow<B>>::Output as Same<U1>>::Output;
99
100 assert_eq!(<U0PowU0 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
101 }
102 #[test]
103 #[allow(non_snake_case)]
104 fn test_0_Min_0() {
105 type A = UTerm;
106 type B = UTerm;
107 type U0 = UTerm;
108
109 #[allow(non_camel_case_types)]
110 type U0MinU0 = <<A as Min<B>>::Output as Same<U0>>::Output;
111
112 assert_eq!(<U0MinU0 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
113 }
114 #[test]
115 #[allow(non_snake_case)]
116 fn test_0_Max_0() {
117 type A = UTerm;
118 type B = UTerm;
119 type U0 = UTerm;
120
121 #[allow(non_camel_case_types)]
122 type U0MaxU0 = <<A as Max<B>>::Output as Same<U0>>::Output;
123
124 assert_eq!(<U0MaxU0 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
125 }
126 #[test]
127 #[allow(non_snake_case)]
128 fn test_0_Gcd_0() {
129 type A = UTerm;
130 type B = UTerm;
131 type U0 = UTerm;
132
133 #[allow(non_camel_case_types)]
134 type U0GcdU0 = <<A as Gcd<B>>::Output as Same<U0>>::Output;
135
136 assert_eq!(<U0GcdU0 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
137 }
138 #[test]
139 #[allow(non_snake_case)]
140 fn test_0_Sub_0() {
141 type A = UTerm;
142 type B = UTerm;
143 type U0 = UTerm;
144
145 #[allow(non_camel_case_types)]
146 type U0SubU0 = <<A as Sub<B>>::Output as Same<U0>>::Output;
147
148 assert_eq!(<U0SubU0 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
149 }
150 #[test]
151 #[allow(non_snake_case)]
152 fn test_0_Cmp_0() {
153 type A = UTerm;
154 type B = UTerm;
155
156 #[allow(non_camel_case_types)]
157 type U0CmpU0 = <A as Cmp<B>>::Output;
158 assert_eq!(<U0CmpU0 as Ord>::to_ordering(), Ordering::Equal);
159 }
160 #[test]
161 #[allow(non_snake_case)]
162 fn test_0_BitAnd_1() {
163 type A = UTerm;
164 type B = UInt<UTerm, B1>;
165 type U0 = UTerm;
166
167 #[allow(non_camel_case_types)]
168 type U0BitAndU1 = <<A as BitAnd<B>>::Output as Same<U0>>::Output;
169
170 assert_eq!(<U0BitAndU1 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
171 }
172 #[test]
173 #[allow(non_snake_case)]
174 fn test_0_BitOr_1() {
175 type A = UTerm;
176 type B = UInt<UTerm, B1>;
177 type U1 = UInt<UTerm, B1>;
178
179 #[allow(non_camel_case_types)]
180 type U0BitOrU1 = <<A as BitOr<B>>::Output as Same<U1>>::Output;
181
182 assert_eq!(<U0BitOrU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
183 }
184 #[test]
185 #[allow(non_snake_case)]
186 fn test_0_BitXor_1() {
187 type A = UTerm;
188 type B = UInt<UTerm, B1>;
189 type U1 = UInt<UTerm, B1>;
190
191 #[allow(non_camel_case_types)]
192 type U0BitXorU1 = <<A as BitXor<B>>::Output as Same<U1>>::Output;
193
194 assert_eq!(<U0BitXorU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
195 }
196 #[test]
197 #[allow(non_snake_case)]
198 fn test_0_Shl_1() {
199 type A = UTerm;
200 type B = UInt<UTerm, B1>;
201 type U0 = UTerm;
202
203 #[allow(non_camel_case_types)]
204 type U0ShlU1 = <<A as Shl<B>>::Output as Same<U0>>::Output;
205
206 assert_eq!(<U0ShlU1 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
207 }
208 #[test]
209 #[allow(non_snake_case)]
210 fn test_0_Shr_1() {
211 type A = UTerm;
212 type B = UInt<UTerm, B1>;
213 type U0 = UTerm;
214
215 #[allow(non_camel_case_types)]
216 type U0ShrU1 = <<A as Shr<B>>::Output as Same<U0>>::Output;
217
218 assert_eq!(<U0ShrU1 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
219 }
220 #[test]
221 #[allow(non_snake_case)]
222 fn test_0_Add_1() {
223 type A = UTerm;
224 type B = UInt<UTerm, B1>;
225 type U1 = UInt<UTerm, B1>;
226
227 #[allow(non_camel_case_types)]
228 type U0AddU1 = <<A as Add<B>>::Output as Same<U1>>::Output;
229
230 assert_eq!(<U0AddU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
231 }
232 #[test]
233 #[allow(non_snake_case)]
234 fn test_0_Mul_1() {
235 type A = UTerm;
236 type B = UInt<UTerm, B1>;
237 type U0 = UTerm;
238
239 #[allow(non_camel_case_types)]
240 type U0MulU1 = <<A as Mul<B>>::Output as Same<U0>>::Output;
241
242 assert_eq!(<U0MulU1 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
243 }
244 #[test]
245 #[allow(non_snake_case)]
246 fn test_0_Pow_1() {
247 type A = UTerm;
248 type B = UInt<UTerm, B1>;
249 type U0 = UTerm;
250
251 #[allow(non_camel_case_types)]
252 type U0PowU1 = <<A as Pow<B>>::Output as Same<U0>>::Output;
253
254 assert_eq!(<U0PowU1 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
255 }
256 #[test]
257 #[allow(non_snake_case)]
258 fn test_0_Min_1() {
259 type A = UTerm;
260 type B = UInt<UTerm, B1>;
261 type U0 = UTerm;
262
263 #[allow(non_camel_case_types)]
264 type U0MinU1 = <<A as Min<B>>::Output as Same<U0>>::Output;
265
266 assert_eq!(<U0MinU1 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
267 }
268 #[test]
269 #[allow(non_snake_case)]
270 fn test_0_Max_1() {
271 type A = UTerm;
272 type B = UInt<UTerm, B1>;
273 type U1 = UInt<UTerm, B1>;
274
275 #[allow(non_camel_case_types)]
276 type U0MaxU1 = <<A as Max<B>>::Output as Same<U1>>::Output;
277
278 assert_eq!(<U0MaxU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
279 }
280 #[test]
281 #[allow(non_snake_case)]
282 fn test_0_Gcd_1() {
283 type A = UTerm;
284 type B = UInt<UTerm, B1>;
285 type U1 = UInt<UTerm, B1>;
286
287 #[allow(non_camel_case_types)]
288 type U0GcdU1 = <<A as Gcd<B>>::Output as Same<U1>>::Output;
289
290 assert_eq!(<U0GcdU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
291 }
292 #[test]
293 #[allow(non_snake_case)]
294 fn test_0_Div_1() {
295 type A = UTerm;
296 type B = UInt<UTerm, B1>;
297 type U0 = UTerm;
298
299 #[allow(non_camel_case_types)]
300 type U0DivU1 = <<A as Div<B>>::Output as Same<U0>>::Output;
301
302 assert_eq!(<U0DivU1 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
303 }
304 #[test]
305 #[allow(non_snake_case)]
306 fn test_0_Rem_1() {
307 type A = UTerm;
308 type B = UInt<UTerm, B1>;
309 type U0 = UTerm;
310
311 #[allow(non_camel_case_types)]
312 type U0RemU1 = <<A as Rem<B>>::Output as Same<U0>>::Output;
313
314 assert_eq!(<U0RemU1 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
315 }
316 #[test]
317 #[allow(non_snake_case)]
318 fn test_0_PartialDiv_1() {
319 type A = UTerm;
320 type B = UInt<UTerm, B1>;
321 type U0 = UTerm;
322
323 #[allow(non_camel_case_types)]
324 type U0PartialDivU1 = <<A as PartialDiv<B>>::Output as Same<U0>>::Output;
325
326 assert_eq!(<U0PartialDivU1 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
327 }
328 #[test]
329 #[allow(non_snake_case)]
330 fn test_0_Cmp_1() {
331 type A = UTerm;
332 type B = UInt<UTerm, B1>;
333
334 #[allow(non_camel_case_types)]
335 type U0CmpU1 = <A as Cmp<B>>::Output;
336 assert_eq!(<U0CmpU1 as Ord>::to_ordering(), Ordering::Less);
337 }
338 #[test]
339 #[allow(non_snake_case)]
340 fn test_0_BitAnd_2() {
341 type A = UTerm;
342 type B = UInt<UInt<UTerm, B1>, B0>;
343 type U0 = UTerm;
344
345 #[allow(non_camel_case_types)]
346 type U0BitAndU2 = <<A as BitAnd<B>>::Output as Same<U0>>::Output;
347
348 assert_eq!(<U0BitAndU2 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
349 }
350 #[test]
351 #[allow(non_snake_case)]
352 fn test_0_BitOr_2() {
353 type A = UTerm;
354 type B = UInt<UInt<UTerm, B1>, B0>;
355 type U2 = UInt<UInt<UTerm, B1>, B0>;
356
357 #[allow(non_camel_case_types)]
358 type U0BitOrU2 = <<A as BitOr<B>>::Output as Same<U2>>::Output;
359
360 assert_eq!(<U0BitOrU2 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
361 }
362 #[test]
363 #[allow(non_snake_case)]
364 fn test_0_BitXor_2() {
365 type A = UTerm;
366 type B = UInt<UInt<UTerm, B1>, B0>;
367 type U2 = UInt<UInt<UTerm, B1>, B0>;
368
369 #[allow(non_camel_case_types)]
370 type U0BitXorU2 = <<A as BitXor<B>>::Output as Same<U2>>::Output;
371
372 assert_eq!(<U0BitXorU2 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
373 }
374 #[test]
375 #[allow(non_snake_case)]
376 fn test_0_Shl_2() {
377 type A = UTerm;
378 type B = UInt<UInt<UTerm, B1>, B0>;
379 type U0 = UTerm;
380
381 #[allow(non_camel_case_types)]
382 type U0ShlU2 = <<A as Shl<B>>::Output as Same<U0>>::Output;
383
384 assert_eq!(<U0ShlU2 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
385 }
386 #[test]
387 #[allow(non_snake_case)]
388 fn test_0_Shr_2() {
389 type A = UTerm;
390 type B = UInt<UInt<UTerm, B1>, B0>;
391 type U0 = UTerm;
392
393 #[allow(non_camel_case_types)]
394 type U0ShrU2 = <<A as Shr<B>>::Output as Same<U0>>::Output;
395
396 assert_eq!(<U0ShrU2 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
397 }
398 #[test]
399 #[allow(non_snake_case)]
400 fn test_0_Add_2() {
401 type A = UTerm;
402 type B = UInt<UInt<UTerm, B1>, B0>;
403 type U2 = UInt<UInt<UTerm, B1>, B0>;
404
405 #[allow(non_camel_case_types)]
406 type U0AddU2 = <<A as Add<B>>::Output as Same<U2>>::Output;
407
408 assert_eq!(<U0AddU2 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
409 }
410 #[test]
411 #[allow(non_snake_case)]
412 fn test_0_Mul_2() {
413 type A = UTerm;
414 type B = UInt<UInt<UTerm, B1>, B0>;
415 type U0 = UTerm;
416
417 #[allow(non_camel_case_types)]
418 type U0MulU2 = <<A as Mul<B>>::Output as Same<U0>>::Output;
419
420 assert_eq!(<U0MulU2 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
421 }
422 #[test]
423 #[allow(non_snake_case)]
424 fn test_0_Pow_2() {
425 type A = UTerm;
426 type B = UInt<UInt<UTerm, B1>, B0>;
427 type U0 = UTerm;
428
429 #[allow(non_camel_case_types)]
430 type U0PowU2 = <<A as Pow<B>>::Output as Same<U0>>::Output;
431
432 assert_eq!(<U0PowU2 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
433 }
434 #[test]
435 #[allow(non_snake_case)]
436 fn test_0_Min_2() {
437 type A = UTerm;
438 type B = UInt<UInt<UTerm, B1>, B0>;
439 type U0 = UTerm;
440
441 #[allow(non_camel_case_types)]
442 type U0MinU2 = <<A as Min<B>>::Output as Same<U0>>::Output;
443
444 assert_eq!(<U0MinU2 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
445 }
446 #[test]
447 #[allow(non_snake_case)]
448 fn test_0_Max_2() {
449 type A = UTerm;
450 type B = UInt<UInt<UTerm, B1>, B0>;
451 type U2 = UInt<UInt<UTerm, B1>, B0>;
452
453 #[allow(non_camel_case_types)]
454 type U0MaxU2 = <<A as Max<B>>::Output as Same<U2>>::Output;
455
456 assert_eq!(<U0MaxU2 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
457 }
458 #[test]
459 #[allow(non_snake_case)]
460 fn test_0_Gcd_2() {
461 type A = UTerm;
462 type B = UInt<UInt<UTerm, B1>, B0>;
463 type U2 = UInt<UInt<UTerm, B1>, B0>;
464
465 #[allow(non_camel_case_types)]
466 type U0GcdU2 = <<A as Gcd<B>>::Output as Same<U2>>::Output;
467
468 assert_eq!(<U0GcdU2 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
469 }
470 #[test]
471 #[allow(non_snake_case)]
472 fn test_0_Div_2() {
473 type A = UTerm;
474 type B = UInt<UInt<UTerm, B1>, B0>;
475 type U0 = UTerm;
476
477 #[allow(non_camel_case_types)]
478 type U0DivU2 = <<A as Div<B>>::Output as Same<U0>>::Output;
479
480 assert_eq!(<U0DivU2 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
481 }
482 #[test]
483 #[allow(non_snake_case)]
484 fn test_0_Rem_2() {
485 type A = UTerm;
486 type B = UInt<UInt<UTerm, B1>, B0>;
487 type U0 = UTerm;
488
489 #[allow(non_camel_case_types)]
490 type U0RemU2 = <<A as Rem<B>>::Output as Same<U0>>::Output;
491
492 assert_eq!(<U0RemU2 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
493 }
494 #[test]
495 #[allow(non_snake_case)]
496 fn test_0_PartialDiv_2() {
497 type A = UTerm;
498 type B = UInt<UInt<UTerm, B1>, B0>;
499 type U0 = UTerm;
500
501 #[allow(non_camel_case_types)]
502 type U0PartialDivU2 = <<A as PartialDiv<B>>::Output as Same<U0>>::Output;
503
504 assert_eq!(<U0PartialDivU2 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
505 }
506 #[test]
507 #[allow(non_snake_case)]
508 fn test_0_Cmp_2() {
509 type A = UTerm;
510 type B = UInt<UInt<UTerm, B1>, B0>;
511
512 #[allow(non_camel_case_types)]
513 type U0CmpU2 = <A as Cmp<B>>::Output;
514 assert_eq!(<U0CmpU2 as Ord>::to_ordering(), Ordering::Less);
515 }
516 #[test]
517 #[allow(non_snake_case)]
518 fn test_0_BitAnd_3() {
519 type A = UTerm;
520 type B = UInt<UInt<UTerm, B1>, B1>;
521 type U0 = UTerm;
522
523 #[allow(non_camel_case_types)]
524 type U0BitAndU3 = <<A as BitAnd<B>>::Output as Same<U0>>::Output;
525
526 assert_eq!(<U0BitAndU3 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
527 }
528 #[test]
529 #[allow(non_snake_case)]
530 fn test_0_BitOr_3() {
531 type A = UTerm;
532 type B = UInt<UInt<UTerm, B1>, B1>;
533 type U3 = UInt<UInt<UTerm, B1>, B1>;
534
535 #[allow(non_camel_case_types)]
536 type U0BitOrU3 = <<A as BitOr<B>>::Output as Same<U3>>::Output;
537
538 assert_eq!(<U0BitOrU3 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
539 }
540 #[test]
541 #[allow(non_snake_case)]
542 fn test_0_BitXor_3() {
543 type A = UTerm;
544 type B = UInt<UInt<UTerm, B1>, B1>;
545 type U3 = UInt<UInt<UTerm, B1>, B1>;
546
547 #[allow(non_camel_case_types)]
548 type U0BitXorU3 = <<A as BitXor<B>>::Output as Same<U3>>::Output;
549
550 assert_eq!(<U0BitXorU3 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
551 }
552 #[test]
553 #[allow(non_snake_case)]
554 fn test_0_Shl_3() {
555 type A = UTerm;
556 type B = UInt<UInt<UTerm, B1>, B1>;
557 type U0 = UTerm;
558
559 #[allow(non_camel_case_types)]
560 type U0ShlU3 = <<A as Shl<B>>::Output as Same<U0>>::Output;
561
562 assert_eq!(<U0ShlU3 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
563 }
564 #[test]
565 #[allow(non_snake_case)]
566 fn test_0_Shr_3() {
567 type A = UTerm;
568 type B = UInt<UInt<UTerm, B1>, B1>;
569 type U0 = UTerm;
570
571 #[allow(non_camel_case_types)]
572 type U0ShrU3 = <<A as Shr<B>>::Output as Same<U0>>::Output;
573
574 assert_eq!(<U0ShrU3 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
575 }
576 #[test]
577 #[allow(non_snake_case)]
578 fn test_0_Add_3() {
579 type A = UTerm;
580 type B = UInt<UInt<UTerm, B1>, B1>;
581 type U3 = UInt<UInt<UTerm, B1>, B1>;
582
583 #[allow(non_camel_case_types)]
584 type U0AddU3 = <<A as Add<B>>::Output as Same<U3>>::Output;
585
586 assert_eq!(<U0AddU3 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
587 }
588 #[test]
589 #[allow(non_snake_case)]
590 fn test_0_Mul_3() {
591 type A = UTerm;
592 type B = UInt<UInt<UTerm, B1>, B1>;
593 type U0 = UTerm;
594
595 #[allow(non_camel_case_types)]
596 type U0MulU3 = <<A as Mul<B>>::Output as Same<U0>>::Output;
597
598 assert_eq!(<U0MulU3 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
599 }
600 #[test]
601 #[allow(non_snake_case)]
602 fn test_0_Pow_3() {
603 type A = UTerm;
604 type B = UInt<UInt<UTerm, B1>, B1>;
605 type U0 = UTerm;
606
607 #[allow(non_camel_case_types)]
608 type U0PowU3 = <<A as Pow<B>>::Output as Same<U0>>::Output;
609
610 assert_eq!(<U0PowU3 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
611 }
612 #[test]
613 #[allow(non_snake_case)]
614 fn test_0_Min_3() {
615 type A = UTerm;
616 type B = UInt<UInt<UTerm, B1>, B1>;
617 type U0 = UTerm;
618
619 #[allow(non_camel_case_types)]
620 type U0MinU3 = <<A as Min<B>>::Output as Same<U0>>::Output;
621
622 assert_eq!(<U0MinU3 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
623 }
624 #[test]
625 #[allow(non_snake_case)]
626 fn test_0_Max_3() {
627 type A = UTerm;
628 type B = UInt<UInt<UTerm, B1>, B1>;
629 type U3 = UInt<UInt<UTerm, B1>, B1>;
630
631 #[allow(non_camel_case_types)]
632 type U0MaxU3 = <<A as Max<B>>::Output as Same<U3>>::Output;
633
634 assert_eq!(<U0MaxU3 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
635 }
636 #[test]
637 #[allow(non_snake_case)]
638 fn test_0_Gcd_3() {
639 type A = UTerm;
640 type B = UInt<UInt<UTerm, B1>, B1>;
641 type U3 = UInt<UInt<UTerm, B1>, B1>;
642
643 #[allow(non_camel_case_types)]
644 type U0GcdU3 = <<A as Gcd<B>>::Output as Same<U3>>::Output;
645
646 assert_eq!(<U0GcdU3 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
647 }
648 #[test]
649 #[allow(non_snake_case)]
650 fn test_0_Div_3() {
651 type A = UTerm;
652 type B = UInt<UInt<UTerm, B1>, B1>;
653 type U0 = UTerm;
654
655 #[allow(non_camel_case_types)]
656 type U0DivU3 = <<A as Div<B>>::Output as Same<U0>>::Output;
657
658 assert_eq!(<U0DivU3 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
659 }
660 #[test]
661 #[allow(non_snake_case)]
662 fn test_0_Rem_3() {
663 type A = UTerm;
664 type B = UInt<UInt<UTerm, B1>, B1>;
665 type U0 = UTerm;
666
667 #[allow(non_camel_case_types)]
668 type U0RemU3 = <<A as Rem<B>>::Output as Same<U0>>::Output;
669
670 assert_eq!(<U0RemU3 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
671 }
672 #[test]
673 #[allow(non_snake_case)]
674 fn test_0_PartialDiv_3() {
675 type A = UTerm;
676 type B = UInt<UInt<UTerm, B1>, B1>;
677 type U0 = UTerm;
678
679 #[allow(non_camel_case_types)]
680 type U0PartialDivU3 = <<A as PartialDiv<B>>::Output as Same<U0>>::Output;
681
682 assert_eq!(<U0PartialDivU3 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
683 }
684 #[test]
685 #[allow(non_snake_case)]
686 fn test_0_Cmp_3() {
687 type A = UTerm;
688 type B = UInt<UInt<UTerm, B1>, B1>;
689
690 #[allow(non_camel_case_types)]
691 type U0CmpU3 = <A as Cmp<B>>::Output;
692 assert_eq!(<U0CmpU3 as Ord>::to_ordering(), Ordering::Less);
693 }
694 #[test]
695 #[allow(non_snake_case)]
696 fn test_0_BitAnd_4() {
697 type A = UTerm;
698 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
699 type U0 = UTerm;
700
701 #[allow(non_camel_case_types)]
702 type U0BitAndU4 = <<A as BitAnd<B>>::Output as Same<U0>>::Output;
703
704 assert_eq!(<U0BitAndU4 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
705 }
706 #[test]
707 #[allow(non_snake_case)]
708 fn test_0_BitOr_4() {
709 type A = UTerm;
710 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
711 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
712
713 #[allow(non_camel_case_types)]
714 type U0BitOrU4 = <<A as BitOr<B>>::Output as Same<U4>>::Output;
715
716 assert_eq!(<U0BitOrU4 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
717 }
718 #[test]
719 #[allow(non_snake_case)]
720 fn test_0_BitXor_4() {
721 type A = UTerm;
722 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
723 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
724
725 #[allow(non_camel_case_types)]
726 type U0BitXorU4 = <<A as BitXor<B>>::Output as Same<U4>>::Output;
727
728 assert_eq!(<U0BitXorU4 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
729 }
730 #[test]
731 #[allow(non_snake_case)]
732 fn test_0_Shl_4() {
733 type A = UTerm;
734 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
735 type U0 = UTerm;
736
737 #[allow(non_camel_case_types)]
738 type U0ShlU4 = <<A as Shl<B>>::Output as Same<U0>>::Output;
739
740 assert_eq!(<U0ShlU4 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
741 }
742 #[test]
743 #[allow(non_snake_case)]
744 fn test_0_Shr_4() {
745 type A = UTerm;
746 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
747 type U0 = UTerm;
748
749 #[allow(non_camel_case_types)]
750 type U0ShrU4 = <<A as Shr<B>>::Output as Same<U0>>::Output;
751
752 assert_eq!(<U0ShrU4 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
753 }
754 #[test]
755 #[allow(non_snake_case)]
756 fn test_0_Add_4() {
757 type A = UTerm;
758 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
759 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
760
761 #[allow(non_camel_case_types)]
762 type U0AddU4 = <<A as Add<B>>::Output as Same<U4>>::Output;
763
764 assert_eq!(<U0AddU4 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
765 }
766 #[test]
767 #[allow(non_snake_case)]
768 fn test_0_Mul_4() {
769 type A = UTerm;
770 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
771 type U0 = UTerm;
772
773 #[allow(non_camel_case_types)]
774 type U0MulU4 = <<A as Mul<B>>::Output as Same<U0>>::Output;
775
776 assert_eq!(<U0MulU4 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
777 }
778 #[test]
779 #[allow(non_snake_case)]
780 fn test_0_Pow_4() {
781 type A = UTerm;
782 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
783 type U0 = UTerm;
784
785 #[allow(non_camel_case_types)]
786 type U0PowU4 = <<A as Pow<B>>::Output as Same<U0>>::Output;
787
788 assert_eq!(<U0PowU4 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
789 }
790 #[test]
791 #[allow(non_snake_case)]
792 fn test_0_Min_4() {
793 type A = UTerm;
794 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
795 type U0 = UTerm;
796
797 #[allow(non_camel_case_types)]
798 type U0MinU4 = <<A as Min<B>>::Output as Same<U0>>::Output;
799
800 assert_eq!(<U0MinU4 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
801 }
802 #[test]
803 #[allow(non_snake_case)]
804 fn test_0_Max_4() {
805 type A = UTerm;
806 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
807 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
808
809 #[allow(non_camel_case_types)]
810 type U0MaxU4 = <<A as Max<B>>::Output as Same<U4>>::Output;
811
812 assert_eq!(<U0MaxU4 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
813 }
814 #[test]
815 #[allow(non_snake_case)]
816 fn test_0_Gcd_4() {
817 type A = UTerm;
818 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
819 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
820
821 #[allow(non_camel_case_types)]
822 type U0GcdU4 = <<A as Gcd<B>>::Output as Same<U4>>::Output;
823
824 assert_eq!(<U0GcdU4 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
825 }
826 #[test]
827 #[allow(non_snake_case)]
828 fn test_0_Div_4() {
829 type A = UTerm;
830 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
831 type U0 = UTerm;
832
833 #[allow(non_camel_case_types)]
834 type U0DivU4 = <<A as Div<B>>::Output as Same<U0>>::Output;
835
836 assert_eq!(<U0DivU4 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
837 }
838 #[test]
839 #[allow(non_snake_case)]
840 fn test_0_Rem_4() {
841 type A = UTerm;
842 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
843 type U0 = UTerm;
844
845 #[allow(non_camel_case_types)]
846 type U0RemU4 = <<A as Rem<B>>::Output as Same<U0>>::Output;
847
848 assert_eq!(<U0RemU4 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
849 }
850 #[test]
851 #[allow(non_snake_case)]
852 fn test_0_PartialDiv_4() {
853 type A = UTerm;
854 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
855 type U0 = UTerm;
856
857 #[allow(non_camel_case_types)]
858 type U0PartialDivU4 = <<A as PartialDiv<B>>::Output as Same<U0>>::Output;
859
860 assert_eq!(<U0PartialDivU4 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
861 }
862 #[test]
863 #[allow(non_snake_case)]
864 fn test_0_Cmp_4() {
865 type A = UTerm;
866 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
867
868 #[allow(non_camel_case_types)]
869 type U0CmpU4 = <A as Cmp<B>>::Output;
870 assert_eq!(<U0CmpU4 as Ord>::to_ordering(), Ordering::Less);
871 }
872 #[test]
873 #[allow(non_snake_case)]
874 fn test_0_BitAnd_5() {
875 type A = UTerm;
876 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
877 type U0 = UTerm;
878
879 #[allow(non_camel_case_types)]
880 type U0BitAndU5 = <<A as BitAnd<B>>::Output as Same<U0>>::Output;
881
882 assert_eq!(<U0BitAndU5 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
883 }
884 #[test]
885 #[allow(non_snake_case)]
886 fn test_0_BitOr_5() {
887 type A = UTerm;
888 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
889 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
890
891 #[allow(non_camel_case_types)]
892 type U0BitOrU5 = <<A as BitOr<B>>::Output as Same<U5>>::Output;
893
894 assert_eq!(<U0BitOrU5 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
895 }
896 #[test]
897 #[allow(non_snake_case)]
898 fn test_0_BitXor_5() {
899 type A = UTerm;
900 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
901 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
902
903 #[allow(non_camel_case_types)]
904 type U0BitXorU5 = <<A as BitXor<B>>::Output as Same<U5>>::Output;
905
906 assert_eq!(<U0BitXorU5 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
907 }
908 #[test]
909 #[allow(non_snake_case)]
910 fn test_0_Shl_5() {
911 type A = UTerm;
912 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
913 type U0 = UTerm;
914
915 #[allow(non_camel_case_types)]
916 type U0ShlU5 = <<A as Shl<B>>::Output as Same<U0>>::Output;
917
918 assert_eq!(<U0ShlU5 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
919 }
920 #[test]
921 #[allow(non_snake_case)]
922 fn test_0_Shr_5() {
923 type A = UTerm;
924 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
925 type U0 = UTerm;
926
927 #[allow(non_camel_case_types)]
928 type U0ShrU5 = <<A as Shr<B>>::Output as Same<U0>>::Output;
929
930 assert_eq!(<U0ShrU5 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
931 }
932 #[test]
933 #[allow(non_snake_case)]
934 fn test_0_Add_5() {
935 type A = UTerm;
936 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
937 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
938
939 #[allow(non_camel_case_types)]
940 type U0AddU5 = <<A as Add<B>>::Output as Same<U5>>::Output;
941
942 assert_eq!(<U0AddU5 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
943 }
944 #[test]
945 #[allow(non_snake_case)]
946 fn test_0_Mul_5() {
947 type A = UTerm;
948 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
949 type U0 = UTerm;
950
951 #[allow(non_camel_case_types)]
952 type U0MulU5 = <<A as Mul<B>>::Output as Same<U0>>::Output;
953
954 assert_eq!(<U0MulU5 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
955 }
956 #[test]
957 #[allow(non_snake_case)]
958 fn test_0_Pow_5() {
959 type A = UTerm;
960 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
961 type U0 = UTerm;
962
963 #[allow(non_camel_case_types)]
964 type U0PowU5 = <<A as Pow<B>>::Output as Same<U0>>::Output;
965
966 assert_eq!(<U0PowU5 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
967 }
968 #[test]
969 #[allow(non_snake_case)]
970 fn test_0_Min_5() {
971 type A = UTerm;
972 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
973 type U0 = UTerm;
974
975 #[allow(non_camel_case_types)]
976 type U0MinU5 = <<A as Min<B>>::Output as Same<U0>>::Output;
977
978 assert_eq!(<U0MinU5 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
979 }
980 #[test]
981 #[allow(non_snake_case)]
982 fn test_0_Max_5() {
983 type A = UTerm;
984 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
985 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
986
987 #[allow(non_camel_case_types)]
988 type U0MaxU5 = <<A as Max<B>>::Output as Same<U5>>::Output;
989
990 assert_eq!(<U0MaxU5 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
991 }
992 #[test]
993 #[allow(non_snake_case)]
994 fn test_0_Gcd_5() {
995 type A = UTerm;
996 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
997 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
998
999 #[allow(non_camel_case_types)]
1000 type U0GcdU5 = <<A as Gcd<B>>::Output as Same<U5>>::Output;
1001
1002 assert_eq!(<U0GcdU5 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
1003 }
1004 #[test]
1005 #[allow(non_snake_case)]
1006 fn test_0_Div_5() {
1007 type A = UTerm;
1008 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
1009 type U0 = UTerm;
1010
1011 #[allow(non_camel_case_types)]
1012 type U0DivU5 = <<A as Div<B>>::Output as Same<U0>>::Output;
1013
1014 assert_eq!(<U0DivU5 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
1015 }
1016 #[test]
1017 #[allow(non_snake_case)]
1018 fn test_0_Rem_5() {
1019 type A = UTerm;
1020 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
1021 type U0 = UTerm;
1022
1023 #[allow(non_camel_case_types)]
1024 type U0RemU5 = <<A as Rem<B>>::Output as Same<U0>>::Output;
1025
1026 assert_eq!(<U0RemU5 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
1027 }
1028 #[test]
1029 #[allow(non_snake_case)]
1030 fn test_0_PartialDiv_5() {
1031 type A = UTerm;
1032 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
1033 type U0 = UTerm;
1034
1035 #[allow(non_camel_case_types)]
1036 type U0PartialDivU5 = <<A as PartialDiv<B>>::Output as Same<U0>>::Output;
1037
1038 assert_eq!(<U0PartialDivU5 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
1039 }
1040 #[test]
1041 #[allow(non_snake_case)]
1042 fn test_0_Cmp_5() {
1043 type A = UTerm;
1044 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
1045
1046 #[allow(non_camel_case_types)]
1047 type U0CmpU5 = <A as Cmp<B>>::Output;
1048 assert_eq!(<U0CmpU5 as Ord>::to_ordering(), Ordering::Less);
1049 }
1050 #[test]
1051 #[allow(non_snake_case)]
1052 fn test_1_BitAnd_0() {
1053 type A = UInt<UTerm, B1>;
1054 type B = UTerm;
1055 type U0 = UTerm;
1056
1057 #[allow(non_camel_case_types)]
1058 type U1BitAndU0 = <<A as BitAnd<B>>::Output as Same<U0>>::Output;
1059
1060 assert_eq!(<U1BitAndU0 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
1061 }
1062 #[test]
1063 #[allow(non_snake_case)]
1064 fn test_1_BitOr_0() {
1065 type A = UInt<UTerm, B1>;
1066 type B = UTerm;
1067 type U1 = UInt<UTerm, B1>;
1068
1069 #[allow(non_camel_case_types)]
1070 type U1BitOrU0 = <<A as BitOr<B>>::Output as Same<U1>>::Output;
1071
1072 assert_eq!(<U1BitOrU0 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1073 }
1074 #[test]
1075 #[allow(non_snake_case)]
1076 fn test_1_BitXor_0() {
1077 type A = UInt<UTerm, B1>;
1078 type B = UTerm;
1079 type U1 = UInt<UTerm, B1>;
1080
1081 #[allow(non_camel_case_types)]
1082 type U1BitXorU0 = <<A as BitXor<B>>::Output as Same<U1>>::Output;
1083
1084 assert_eq!(<U1BitXorU0 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1085 }
1086 #[test]
1087 #[allow(non_snake_case)]
1088 fn test_1_Shl_0() {
1089 type A = UInt<UTerm, B1>;
1090 type B = UTerm;
1091 type U1 = UInt<UTerm, B1>;
1092
1093 #[allow(non_camel_case_types)]
1094 type U1ShlU0 = <<A as Shl<B>>::Output as Same<U1>>::Output;
1095
1096 assert_eq!(<U1ShlU0 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1097 }
1098 #[test]
1099 #[allow(non_snake_case)]
1100 fn test_1_Shr_0() {
1101 type A = UInt<UTerm, B1>;
1102 type B = UTerm;
1103 type U1 = UInt<UTerm, B1>;
1104
1105 #[allow(non_camel_case_types)]
1106 type U1ShrU0 = <<A as Shr<B>>::Output as Same<U1>>::Output;
1107
1108 assert_eq!(<U1ShrU0 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1109 }
1110 #[test]
1111 #[allow(non_snake_case)]
1112 fn test_1_Add_0() {
1113 type A = UInt<UTerm, B1>;
1114 type B = UTerm;
1115 type U1 = UInt<UTerm, B1>;
1116
1117 #[allow(non_camel_case_types)]
1118 type U1AddU0 = <<A as Add<B>>::Output as Same<U1>>::Output;
1119
1120 assert_eq!(<U1AddU0 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1121 }
1122 #[test]
1123 #[allow(non_snake_case)]
1124 fn test_1_Mul_0() {
1125 type A = UInt<UTerm, B1>;
1126 type B = UTerm;
1127 type U0 = UTerm;
1128
1129 #[allow(non_camel_case_types)]
1130 type U1MulU0 = <<A as Mul<B>>::Output as Same<U0>>::Output;
1131
1132 assert_eq!(<U1MulU0 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
1133 }
1134 #[test]
1135 #[allow(non_snake_case)]
1136 fn test_1_Pow_0() {
1137 type A = UInt<UTerm, B1>;
1138 type B = UTerm;
1139 type U1 = UInt<UTerm, B1>;
1140
1141 #[allow(non_camel_case_types)]
1142 type U1PowU0 = <<A as Pow<B>>::Output as Same<U1>>::Output;
1143
1144 assert_eq!(<U1PowU0 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1145 }
1146 #[test]
1147 #[allow(non_snake_case)]
1148 fn test_1_Min_0() {
1149 type A = UInt<UTerm, B1>;
1150 type B = UTerm;
1151 type U0 = UTerm;
1152
1153 #[allow(non_camel_case_types)]
1154 type U1MinU0 = <<A as Min<B>>::Output as Same<U0>>::Output;
1155
1156 assert_eq!(<U1MinU0 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
1157 }
1158 #[test]
1159 #[allow(non_snake_case)]
1160 fn test_1_Max_0() {
1161 type A = UInt<UTerm, B1>;
1162 type B = UTerm;
1163 type U1 = UInt<UTerm, B1>;
1164
1165 #[allow(non_camel_case_types)]
1166 type U1MaxU0 = <<A as Max<B>>::Output as Same<U1>>::Output;
1167
1168 assert_eq!(<U1MaxU0 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1169 }
1170 #[test]
1171 #[allow(non_snake_case)]
1172 fn test_1_Gcd_0() {
1173 type A = UInt<UTerm, B1>;
1174 type B = UTerm;
1175 type U1 = UInt<UTerm, B1>;
1176
1177 #[allow(non_camel_case_types)]
1178 type U1GcdU0 = <<A as Gcd<B>>::Output as Same<U1>>::Output;
1179
1180 assert_eq!(<U1GcdU0 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1181 }
1182 #[test]
1183 #[allow(non_snake_case)]
1184 fn test_1_Sub_0() {
1185 type A = UInt<UTerm, B1>;
1186 type B = UTerm;
1187 type U1 = UInt<UTerm, B1>;
1188
1189 #[allow(non_camel_case_types)]
1190 type U1SubU0 = <<A as Sub<B>>::Output as Same<U1>>::Output;
1191
1192 assert_eq!(<U1SubU0 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1193 }
1194 #[test]
1195 #[allow(non_snake_case)]
1196 fn test_1_Cmp_0() {
1197 type A = UInt<UTerm, B1>;
1198 type B = UTerm;
1199
1200 #[allow(non_camel_case_types)]
1201 type U1CmpU0 = <A as Cmp<B>>::Output;
1202 assert_eq!(<U1CmpU0 as Ord>::to_ordering(), Ordering::Greater);
1203 }
1204 #[test]
1205 #[allow(non_snake_case)]
1206 fn test_1_BitAnd_1() {
1207 type A = UInt<UTerm, B1>;
1208 type B = UInt<UTerm, B1>;
1209 type U1 = UInt<UTerm, B1>;
1210
1211 #[allow(non_camel_case_types)]
1212 type U1BitAndU1 = <<A as BitAnd<B>>::Output as Same<U1>>::Output;
1213
1214 assert_eq!(<U1BitAndU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1215 }
1216 #[test]
1217 #[allow(non_snake_case)]
1218 fn test_1_BitOr_1() {
1219 type A = UInt<UTerm, B1>;
1220 type B = UInt<UTerm, B1>;
1221 type U1 = UInt<UTerm, B1>;
1222
1223 #[allow(non_camel_case_types)]
1224 type U1BitOrU1 = <<A as BitOr<B>>::Output as Same<U1>>::Output;
1225
1226 assert_eq!(<U1BitOrU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1227 }
1228 #[test]
1229 #[allow(non_snake_case)]
1230 fn test_1_BitXor_1() {
1231 type A = UInt<UTerm, B1>;
1232 type B = UInt<UTerm, B1>;
1233 type U0 = UTerm;
1234
1235 #[allow(non_camel_case_types)]
1236 type U1BitXorU1 = <<A as BitXor<B>>::Output as Same<U0>>::Output;
1237
1238 assert_eq!(<U1BitXorU1 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
1239 }
1240 #[test]
1241 #[allow(non_snake_case)]
1242 fn test_1_Shl_1() {
1243 type A = UInt<UTerm, B1>;
1244 type B = UInt<UTerm, B1>;
1245 type U2 = UInt<UInt<UTerm, B1>, B0>;
1246
1247 #[allow(non_camel_case_types)]
1248 type U1ShlU1 = <<A as Shl<B>>::Output as Same<U2>>::Output;
1249
1250 assert_eq!(<U1ShlU1 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
1251 }
1252 #[test]
1253 #[allow(non_snake_case)]
1254 fn test_1_Shr_1() {
1255 type A = UInt<UTerm, B1>;
1256 type B = UInt<UTerm, B1>;
1257 type U0 = UTerm;
1258
1259 #[allow(non_camel_case_types)]
1260 type U1ShrU1 = <<A as Shr<B>>::Output as Same<U0>>::Output;
1261
1262 assert_eq!(<U1ShrU1 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
1263 }
1264 #[test]
1265 #[allow(non_snake_case)]
1266 fn test_1_Add_1() {
1267 type A = UInt<UTerm, B1>;
1268 type B = UInt<UTerm, B1>;
1269 type U2 = UInt<UInt<UTerm, B1>, B0>;
1270
1271 #[allow(non_camel_case_types)]
1272 type U1AddU1 = <<A as Add<B>>::Output as Same<U2>>::Output;
1273
1274 assert_eq!(<U1AddU1 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
1275 }
1276 #[test]
1277 #[allow(non_snake_case)]
1278 fn test_1_Mul_1() {
1279 type A = UInt<UTerm, B1>;
1280 type B = UInt<UTerm, B1>;
1281 type U1 = UInt<UTerm, B1>;
1282
1283 #[allow(non_camel_case_types)]
1284 type U1MulU1 = <<A as Mul<B>>::Output as Same<U1>>::Output;
1285
1286 assert_eq!(<U1MulU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1287 }
1288 #[test]
1289 #[allow(non_snake_case)]
1290 fn test_1_Pow_1() {
1291 type A = UInt<UTerm, B1>;
1292 type B = UInt<UTerm, B1>;
1293 type U1 = UInt<UTerm, B1>;
1294
1295 #[allow(non_camel_case_types)]
1296 type U1PowU1 = <<A as Pow<B>>::Output as Same<U1>>::Output;
1297
1298 assert_eq!(<U1PowU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1299 }
1300 #[test]
1301 #[allow(non_snake_case)]
1302 fn test_1_Min_1() {
1303 type A = UInt<UTerm, B1>;
1304 type B = UInt<UTerm, B1>;
1305 type U1 = UInt<UTerm, B1>;
1306
1307 #[allow(non_camel_case_types)]
1308 type U1MinU1 = <<A as Min<B>>::Output as Same<U1>>::Output;
1309
1310 assert_eq!(<U1MinU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1311 }
1312 #[test]
1313 #[allow(non_snake_case)]
1314 fn test_1_Max_1() {
1315 type A = UInt<UTerm, B1>;
1316 type B = UInt<UTerm, B1>;
1317 type U1 = UInt<UTerm, B1>;
1318
1319 #[allow(non_camel_case_types)]
1320 type U1MaxU1 = <<A as Max<B>>::Output as Same<U1>>::Output;
1321
1322 assert_eq!(<U1MaxU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1323 }
1324 #[test]
1325 #[allow(non_snake_case)]
1326 fn test_1_Gcd_1() {
1327 type A = UInt<UTerm, B1>;
1328 type B = UInt<UTerm, B1>;
1329 type U1 = UInt<UTerm, B1>;
1330
1331 #[allow(non_camel_case_types)]
1332 type U1GcdU1 = <<A as Gcd<B>>::Output as Same<U1>>::Output;
1333
1334 assert_eq!(<U1GcdU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1335 }
1336 #[test]
1337 #[allow(non_snake_case)]
1338 fn test_1_Sub_1() {
1339 type A = UInt<UTerm, B1>;
1340 type B = UInt<UTerm, B1>;
1341 type U0 = UTerm;
1342
1343 #[allow(non_camel_case_types)]
1344 type U1SubU1 = <<A as Sub<B>>::Output as Same<U0>>::Output;
1345
1346 assert_eq!(<U1SubU1 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
1347 }
1348 #[test]
1349 #[allow(non_snake_case)]
1350 fn test_1_Div_1() {
1351 type A = UInt<UTerm, B1>;
1352 type B = UInt<UTerm, B1>;
1353 type U1 = UInt<UTerm, B1>;
1354
1355 #[allow(non_camel_case_types)]
1356 type U1DivU1 = <<A as Div<B>>::Output as Same<U1>>::Output;
1357
1358 assert_eq!(<U1DivU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1359 }
1360 #[test]
1361 #[allow(non_snake_case)]
1362 fn test_1_Rem_1() {
1363 type A = UInt<UTerm, B1>;
1364 type B = UInt<UTerm, B1>;
1365 type U0 = UTerm;
1366
1367 #[allow(non_camel_case_types)]
1368 type U1RemU1 = <<A as Rem<B>>::Output as Same<U0>>::Output;
1369
1370 assert_eq!(<U1RemU1 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
1371 }
1372 #[test]
1373 #[allow(non_snake_case)]
1374 fn test_1_PartialDiv_1() {
1375 type A = UInt<UTerm, B1>;
1376 type B = UInt<UTerm, B1>;
1377 type U1 = UInt<UTerm, B1>;
1378
1379 #[allow(non_camel_case_types)]
1380 type U1PartialDivU1 = <<A as PartialDiv<B>>::Output as Same<U1>>::Output;
1381
1382 assert_eq!(<U1PartialDivU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1383 }
1384 #[test]
1385 #[allow(non_snake_case)]
1386 fn test_1_Cmp_1() {
1387 type A = UInt<UTerm, B1>;
1388 type B = UInt<UTerm, B1>;
1389
1390 #[allow(non_camel_case_types)]
1391 type U1CmpU1 = <A as Cmp<B>>::Output;
1392 assert_eq!(<U1CmpU1 as Ord>::to_ordering(), Ordering::Equal);
1393 }
1394 #[test]
1395 #[allow(non_snake_case)]
1396 fn test_1_BitAnd_2() {
1397 type A = UInt<UTerm, B1>;
1398 type B = UInt<UInt<UTerm, B1>, B0>;
1399 type U0 = UTerm;
1400
1401 #[allow(non_camel_case_types)]
1402 type U1BitAndU2 = <<A as BitAnd<B>>::Output as Same<U0>>::Output;
1403
1404 assert_eq!(<U1BitAndU2 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
1405 }
1406 #[test]
1407 #[allow(non_snake_case)]
1408 fn test_1_BitOr_2() {
1409 type A = UInt<UTerm, B1>;
1410 type B = UInt<UInt<UTerm, B1>, B0>;
1411 type U3 = UInt<UInt<UTerm, B1>, B1>;
1412
1413 #[allow(non_camel_case_types)]
1414 type U1BitOrU2 = <<A as BitOr<B>>::Output as Same<U3>>::Output;
1415
1416 assert_eq!(<U1BitOrU2 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
1417 }
1418 #[test]
1419 #[allow(non_snake_case)]
1420 fn test_1_BitXor_2() {
1421 type A = UInt<UTerm, B1>;
1422 type B = UInt<UInt<UTerm, B1>, B0>;
1423 type U3 = UInt<UInt<UTerm, B1>, B1>;
1424
1425 #[allow(non_camel_case_types)]
1426 type U1BitXorU2 = <<A as BitXor<B>>::Output as Same<U3>>::Output;
1427
1428 assert_eq!(<U1BitXorU2 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
1429 }
1430 #[test]
1431 #[allow(non_snake_case)]
1432 fn test_1_Shl_2() {
1433 type A = UInt<UTerm, B1>;
1434 type B = UInt<UInt<UTerm, B1>, B0>;
1435 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
1436
1437 #[allow(non_camel_case_types)]
1438 type U1ShlU2 = <<A as Shl<B>>::Output as Same<U4>>::Output;
1439
1440 assert_eq!(<U1ShlU2 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
1441 }
1442 #[test]
1443 #[allow(non_snake_case)]
1444 fn test_1_Shr_2() {
1445 type A = UInt<UTerm, B1>;
1446 type B = UInt<UInt<UTerm, B1>, B0>;
1447 type U0 = UTerm;
1448
1449 #[allow(non_camel_case_types)]
1450 type U1ShrU2 = <<A as Shr<B>>::Output as Same<U0>>::Output;
1451
1452 assert_eq!(<U1ShrU2 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
1453 }
1454 #[test]
1455 #[allow(non_snake_case)]
1456 fn test_1_Add_2() {
1457 type A = UInt<UTerm, B1>;
1458 type B = UInt<UInt<UTerm, B1>, B0>;
1459 type U3 = UInt<UInt<UTerm, B1>, B1>;
1460
1461 #[allow(non_camel_case_types)]
1462 type U1AddU2 = <<A as Add<B>>::Output as Same<U3>>::Output;
1463
1464 assert_eq!(<U1AddU2 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
1465 }
1466 #[test]
1467 #[allow(non_snake_case)]
1468 fn test_1_Mul_2() {
1469 type A = UInt<UTerm, B1>;
1470 type B = UInt<UInt<UTerm, B1>, B0>;
1471 type U2 = UInt<UInt<UTerm, B1>, B0>;
1472
1473 #[allow(non_camel_case_types)]
1474 type U1MulU2 = <<A as Mul<B>>::Output as Same<U2>>::Output;
1475
1476 assert_eq!(<U1MulU2 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
1477 }
1478 #[test]
1479 #[allow(non_snake_case)]
1480 fn test_1_Pow_2() {
1481 type A = UInt<UTerm, B1>;
1482 type B = UInt<UInt<UTerm, B1>, B0>;
1483 type U1 = UInt<UTerm, B1>;
1484
1485 #[allow(non_camel_case_types)]
1486 type U1PowU2 = <<A as Pow<B>>::Output as Same<U1>>::Output;
1487
1488 assert_eq!(<U1PowU2 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1489 }
1490 #[test]
1491 #[allow(non_snake_case)]
1492 fn test_1_Min_2() {
1493 type A = UInt<UTerm, B1>;
1494 type B = UInt<UInt<UTerm, B1>, B0>;
1495 type U1 = UInt<UTerm, B1>;
1496
1497 #[allow(non_camel_case_types)]
1498 type U1MinU2 = <<A as Min<B>>::Output as Same<U1>>::Output;
1499
1500 assert_eq!(<U1MinU2 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1501 }
1502 #[test]
1503 #[allow(non_snake_case)]
1504 fn test_1_Max_2() {
1505 type A = UInt<UTerm, B1>;
1506 type B = UInt<UInt<UTerm, B1>, B0>;
1507 type U2 = UInt<UInt<UTerm, B1>, B0>;
1508
1509 #[allow(non_camel_case_types)]
1510 type U1MaxU2 = <<A as Max<B>>::Output as Same<U2>>::Output;
1511
1512 assert_eq!(<U1MaxU2 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
1513 }
1514 #[test]
1515 #[allow(non_snake_case)]
1516 fn test_1_Gcd_2() {
1517 type A = UInt<UTerm, B1>;
1518 type B = UInt<UInt<UTerm, B1>, B0>;
1519 type U1 = UInt<UTerm, B1>;
1520
1521 #[allow(non_camel_case_types)]
1522 type U1GcdU2 = <<A as Gcd<B>>::Output as Same<U1>>::Output;
1523
1524 assert_eq!(<U1GcdU2 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1525 }
1526 #[test]
1527 #[allow(non_snake_case)]
1528 fn test_1_Div_2() {
1529 type A = UInt<UTerm, B1>;
1530 type B = UInt<UInt<UTerm, B1>, B0>;
1531 type U0 = UTerm;
1532
1533 #[allow(non_camel_case_types)]
1534 type U1DivU2 = <<A as Div<B>>::Output as Same<U0>>::Output;
1535
1536 assert_eq!(<U1DivU2 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
1537 }
1538 #[test]
1539 #[allow(non_snake_case)]
1540 fn test_1_Rem_2() {
1541 type A = UInt<UTerm, B1>;
1542 type B = UInt<UInt<UTerm, B1>, B0>;
1543 type U1 = UInt<UTerm, B1>;
1544
1545 #[allow(non_camel_case_types)]
1546 type U1RemU2 = <<A as Rem<B>>::Output as Same<U1>>::Output;
1547
1548 assert_eq!(<U1RemU2 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1549 }
1550 #[test]
1551 #[allow(non_snake_case)]
1552 fn test_1_Cmp_2() {
1553 type A = UInt<UTerm, B1>;
1554 type B = UInt<UInt<UTerm, B1>, B0>;
1555
1556 #[allow(non_camel_case_types)]
1557 type U1CmpU2 = <A as Cmp<B>>::Output;
1558 assert_eq!(<U1CmpU2 as Ord>::to_ordering(), Ordering::Less);
1559 }
1560 #[test]
1561 #[allow(non_snake_case)]
1562 fn test_1_BitAnd_3() {
1563 type A = UInt<UTerm, B1>;
1564 type B = UInt<UInt<UTerm, B1>, B1>;
1565 type U1 = UInt<UTerm, B1>;
1566
1567 #[allow(non_camel_case_types)]
1568 type U1BitAndU3 = <<A as BitAnd<B>>::Output as Same<U1>>::Output;
1569
1570 assert_eq!(<U1BitAndU3 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1571 }
1572 #[test]
1573 #[allow(non_snake_case)]
1574 fn test_1_BitOr_3() {
1575 type A = UInt<UTerm, B1>;
1576 type B = UInt<UInt<UTerm, B1>, B1>;
1577 type U3 = UInt<UInt<UTerm, B1>, B1>;
1578
1579 #[allow(non_camel_case_types)]
1580 type U1BitOrU3 = <<A as BitOr<B>>::Output as Same<U3>>::Output;
1581
1582 assert_eq!(<U1BitOrU3 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
1583 }
1584 #[test]
1585 #[allow(non_snake_case)]
1586 fn test_1_BitXor_3() {
1587 type A = UInt<UTerm, B1>;
1588 type B = UInt<UInt<UTerm, B1>, B1>;
1589 type U2 = UInt<UInt<UTerm, B1>, B0>;
1590
1591 #[allow(non_camel_case_types)]
1592 type U1BitXorU3 = <<A as BitXor<B>>::Output as Same<U2>>::Output;
1593
1594 assert_eq!(<U1BitXorU3 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
1595 }
1596 #[test]
1597 #[allow(non_snake_case)]
1598 fn test_1_Shl_3() {
1599 type A = UInt<UTerm, B1>;
1600 type B = UInt<UInt<UTerm, B1>, B1>;
1601 type U8 = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>;
1602
1603 #[allow(non_camel_case_types)]
1604 type U1ShlU3 = <<A as Shl<B>>::Output as Same<U8>>::Output;
1605
1606 assert_eq!(<U1ShlU3 as Unsigned>::to_u64(), <U8 as Unsigned>::to_u64());
1607 }
1608 #[test]
1609 #[allow(non_snake_case)]
1610 fn test_1_Shr_3() {
1611 type A = UInt<UTerm, B1>;
1612 type B = UInt<UInt<UTerm, B1>, B1>;
1613 type U0 = UTerm;
1614
1615 #[allow(non_camel_case_types)]
1616 type U1ShrU3 = <<A as Shr<B>>::Output as Same<U0>>::Output;
1617
1618 assert_eq!(<U1ShrU3 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
1619 }
1620 #[test]
1621 #[allow(non_snake_case)]
1622 fn test_1_Add_3() {
1623 type A = UInt<UTerm, B1>;
1624 type B = UInt<UInt<UTerm, B1>, B1>;
1625 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
1626
1627 #[allow(non_camel_case_types)]
1628 type U1AddU3 = <<A as Add<B>>::Output as Same<U4>>::Output;
1629
1630 assert_eq!(<U1AddU3 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
1631 }
1632 #[test]
1633 #[allow(non_snake_case)]
1634 fn test_1_Mul_3() {
1635 type A = UInt<UTerm, B1>;
1636 type B = UInt<UInt<UTerm, B1>, B1>;
1637 type U3 = UInt<UInt<UTerm, B1>, B1>;
1638
1639 #[allow(non_camel_case_types)]
1640 type U1MulU3 = <<A as Mul<B>>::Output as Same<U3>>::Output;
1641
1642 assert_eq!(<U1MulU3 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
1643 }
1644 #[test]
1645 #[allow(non_snake_case)]
1646 fn test_1_Pow_3() {
1647 type A = UInt<UTerm, B1>;
1648 type B = UInt<UInt<UTerm, B1>, B1>;
1649 type U1 = UInt<UTerm, B1>;
1650
1651 #[allow(non_camel_case_types)]
1652 type U1PowU3 = <<A as Pow<B>>::Output as Same<U1>>::Output;
1653
1654 assert_eq!(<U1PowU3 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1655 }
1656 #[test]
1657 #[allow(non_snake_case)]
1658 fn test_1_Min_3() {
1659 type A = UInt<UTerm, B1>;
1660 type B = UInt<UInt<UTerm, B1>, B1>;
1661 type U1 = UInt<UTerm, B1>;
1662
1663 #[allow(non_camel_case_types)]
1664 type U1MinU3 = <<A as Min<B>>::Output as Same<U1>>::Output;
1665
1666 assert_eq!(<U1MinU3 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1667 }
1668 #[test]
1669 #[allow(non_snake_case)]
1670 fn test_1_Max_3() {
1671 type A = UInt<UTerm, B1>;
1672 type B = UInt<UInt<UTerm, B1>, B1>;
1673 type U3 = UInt<UInt<UTerm, B1>, B1>;
1674
1675 #[allow(non_camel_case_types)]
1676 type U1MaxU3 = <<A as Max<B>>::Output as Same<U3>>::Output;
1677
1678 assert_eq!(<U1MaxU3 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
1679 }
1680 #[test]
1681 #[allow(non_snake_case)]
1682 fn test_1_Gcd_3() {
1683 type A = UInt<UTerm, B1>;
1684 type B = UInt<UInt<UTerm, B1>, B1>;
1685 type U1 = UInt<UTerm, B1>;
1686
1687 #[allow(non_camel_case_types)]
1688 type U1GcdU3 = <<A as Gcd<B>>::Output as Same<U1>>::Output;
1689
1690 assert_eq!(<U1GcdU3 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1691 }
1692 #[test]
1693 #[allow(non_snake_case)]
1694 fn test_1_Div_3() {
1695 type A = UInt<UTerm, B1>;
1696 type B = UInt<UInt<UTerm, B1>, B1>;
1697 type U0 = UTerm;
1698
1699 #[allow(non_camel_case_types)]
1700 type U1DivU3 = <<A as Div<B>>::Output as Same<U0>>::Output;
1701
1702 assert_eq!(<U1DivU3 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
1703 }
1704 #[test]
1705 #[allow(non_snake_case)]
1706 fn test_1_Rem_3() {
1707 type A = UInt<UTerm, B1>;
1708 type B = UInt<UInt<UTerm, B1>, B1>;
1709 type U1 = UInt<UTerm, B1>;
1710
1711 #[allow(non_camel_case_types)]
1712 type U1RemU3 = <<A as Rem<B>>::Output as Same<U1>>::Output;
1713
1714 assert_eq!(<U1RemU3 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1715 }
1716 #[test]
1717 #[allow(non_snake_case)]
1718 fn test_1_Cmp_3() {
1719 type A = UInt<UTerm, B1>;
1720 type B = UInt<UInt<UTerm, B1>, B1>;
1721
1722 #[allow(non_camel_case_types)]
1723 type U1CmpU3 = <A as Cmp<B>>::Output;
1724 assert_eq!(<U1CmpU3 as Ord>::to_ordering(), Ordering::Less);
1725 }
1726 #[test]
1727 #[allow(non_snake_case)]
1728 fn test_1_BitAnd_4() {
1729 type A = UInt<UTerm, B1>;
1730 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
1731 type U0 = UTerm;
1732
1733 #[allow(non_camel_case_types)]
1734 type U1BitAndU4 = <<A as BitAnd<B>>::Output as Same<U0>>::Output;
1735
1736 assert_eq!(<U1BitAndU4 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
1737 }
1738 #[test]
1739 #[allow(non_snake_case)]
1740 fn test_1_BitOr_4() {
1741 type A = UInt<UTerm, B1>;
1742 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
1743 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
1744
1745 #[allow(non_camel_case_types)]
1746 type U1BitOrU4 = <<A as BitOr<B>>::Output as Same<U5>>::Output;
1747
1748 assert_eq!(<U1BitOrU4 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
1749 }
1750 #[test]
1751 #[allow(non_snake_case)]
1752 fn test_1_BitXor_4() {
1753 type A = UInt<UTerm, B1>;
1754 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
1755 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
1756
1757 #[allow(non_camel_case_types)]
1758 type U1BitXorU4 = <<A as BitXor<B>>::Output as Same<U5>>::Output;
1759
1760 assert_eq!(<U1BitXorU4 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
1761 }
1762 #[test]
1763 #[allow(non_snake_case)]
1764 fn test_1_Shl_4() {
1765 type A = UInt<UTerm, B1>;
1766 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
1767 type U16 = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>;
1768
1769 #[allow(non_camel_case_types)]
1770 type U1ShlU4 = <<A as Shl<B>>::Output as Same<U16>>::Output;
1771
1772 assert_eq!(<U1ShlU4 as Unsigned>::to_u64(), <U16 as Unsigned>::to_u64());
1773 }
1774 #[test]
1775 #[allow(non_snake_case)]
1776 fn test_1_Shr_4() {
1777 type A = UInt<UTerm, B1>;
1778 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
1779 type U0 = UTerm;
1780
1781 #[allow(non_camel_case_types)]
1782 type U1ShrU4 = <<A as Shr<B>>::Output as Same<U0>>::Output;
1783
1784 assert_eq!(<U1ShrU4 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
1785 }
1786 #[test]
1787 #[allow(non_snake_case)]
1788 fn test_1_Add_4() {
1789 type A = UInt<UTerm, B1>;
1790 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
1791 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
1792
1793 #[allow(non_camel_case_types)]
1794 type U1AddU4 = <<A as Add<B>>::Output as Same<U5>>::Output;
1795
1796 assert_eq!(<U1AddU4 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
1797 }
1798 #[test]
1799 #[allow(non_snake_case)]
1800 fn test_1_Mul_4() {
1801 type A = UInt<UTerm, B1>;
1802 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
1803 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
1804
1805 #[allow(non_camel_case_types)]
1806 type U1MulU4 = <<A as Mul<B>>::Output as Same<U4>>::Output;
1807
1808 assert_eq!(<U1MulU4 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
1809 }
1810 #[test]
1811 #[allow(non_snake_case)]
1812 fn test_1_Pow_4() {
1813 type A = UInt<UTerm, B1>;
1814 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
1815 type U1 = UInt<UTerm, B1>;
1816
1817 #[allow(non_camel_case_types)]
1818 type U1PowU4 = <<A as Pow<B>>::Output as Same<U1>>::Output;
1819
1820 assert_eq!(<U1PowU4 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1821 }
1822 #[test]
1823 #[allow(non_snake_case)]
1824 fn test_1_Min_4() {
1825 type A = UInt<UTerm, B1>;
1826 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
1827 type U1 = UInt<UTerm, B1>;
1828
1829 #[allow(non_camel_case_types)]
1830 type U1MinU4 = <<A as Min<B>>::Output as Same<U1>>::Output;
1831
1832 assert_eq!(<U1MinU4 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1833 }
1834 #[test]
1835 #[allow(non_snake_case)]
1836 fn test_1_Max_4() {
1837 type A = UInt<UTerm, B1>;
1838 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
1839 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
1840
1841 #[allow(non_camel_case_types)]
1842 type U1MaxU4 = <<A as Max<B>>::Output as Same<U4>>::Output;
1843
1844 assert_eq!(<U1MaxU4 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
1845 }
1846 #[test]
1847 #[allow(non_snake_case)]
1848 fn test_1_Gcd_4() {
1849 type A = UInt<UTerm, B1>;
1850 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
1851 type U1 = UInt<UTerm, B1>;
1852
1853 #[allow(non_camel_case_types)]
1854 type U1GcdU4 = <<A as Gcd<B>>::Output as Same<U1>>::Output;
1855
1856 assert_eq!(<U1GcdU4 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1857 }
1858 #[test]
1859 #[allow(non_snake_case)]
1860 fn test_1_Div_4() {
1861 type A = UInt<UTerm, B1>;
1862 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
1863 type U0 = UTerm;
1864
1865 #[allow(non_camel_case_types)]
1866 type U1DivU4 = <<A as Div<B>>::Output as Same<U0>>::Output;
1867
1868 assert_eq!(<U1DivU4 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
1869 }
1870 #[test]
1871 #[allow(non_snake_case)]
1872 fn test_1_Rem_4() {
1873 type A = UInt<UTerm, B1>;
1874 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
1875 type U1 = UInt<UTerm, B1>;
1876
1877 #[allow(non_camel_case_types)]
1878 type U1RemU4 = <<A as Rem<B>>::Output as Same<U1>>::Output;
1879
1880 assert_eq!(<U1RemU4 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1881 }
1882 #[test]
1883 #[allow(non_snake_case)]
1884 fn test_1_Cmp_4() {
1885 type A = UInt<UTerm, B1>;
1886 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
1887
1888 #[allow(non_camel_case_types)]
1889 type U1CmpU4 = <A as Cmp<B>>::Output;
1890 assert_eq!(<U1CmpU4 as Ord>::to_ordering(), Ordering::Less);
1891 }
1892 #[test]
1893 #[allow(non_snake_case)]
1894 fn test_1_BitAnd_5() {
1895 type A = UInt<UTerm, B1>;
1896 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
1897 type U1 = UInt<UTerm, B1>;
1898
1899 #[allow(non_camel_case_types)]
1900 type U1BitAndU5 = <<A as BitAnd<B>>::Output as Same<U1>>::Output;
1901
1902 assert_eq!(<U1BitAndU5 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1903 }
1904 #[test]
1905 #[allow(non_snake_case)]
1906 fn test_1_BitOr_5() {
1907 type A = UInt<UTerm, B1>;
1908 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
1909 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
1910
1911 #[allow(non_camel_case_types)]
1912 type U1BitOrU5 = <<A as BitOr<B>>::Output as Same<U5>>::Output;
1913
1914 assert_eq!(<U1BitOrU5 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
1915 }
1916 #[test]
1917 #[allow(non_snake_case)]
1918 fn test_1_BitXor_5() {
1919 type A = UInt<UTerm, B1>;
1920 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
1921 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
1922
1923 #[allow(non_camel_case_types)]
1924 type U1BitXorU5 = <<A as BitXor<B>>::Output as Same<U4>>::Output;
1925
1926 assert_eq!(<U1BitXorU5 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
1927 }
1928 #[test]
1929 #[allow(non_snake_case)]
1930 fn test_1_Shl_5() {
1931 type A = UInt<UTerm, B1>;
1932 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
1933 type U32 = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>;
1934
1935 #[allow(non_camel_case_types)]
1936 type U1ShlU5 = <<A as Shl<B>>::Output as Same<U32>>::Output;
1937
1938 assert_eq!(<U1ShlU5 as Unsigned>::to_u64(), <U32 as Unsigned>::to_u64());
1939 }
1940 #[test]
1941 #[allow(non_snake_case)]
1942 fn test_1_Shr_5() {
1943 type A = UInt<UTerm, B1>;
1944 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
1945 type U0 = UTerm;
1946
1947 #[allow(non_camel_case_types)]
1948 type U1ShrU5 = <<A as Shr<B>>::Output as Same<U0>>::Output;
1949
1950 assert_eq!(<U1ShrU5 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
1951 }
1952 #[test]
1953 #[allow(non_snake_case)]
1954 fn test_1_Add_5() {
1955 type A = UInt<UTerm, B1>;
1956 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
1957 type U6 = UInt<UInt<UInt<UTerm, B1>, B1>, B0>;
1958
1959 #[allow(non_camel_case_types)]
1960 type U1AddU5 = <<A as Add<B>>::Output as Same<U6>>::Output;
1961
1962 assert_eq!(<U1AddU5 as Unsigned>::to_u64(), <U6 as Unsigned>::to_u64());
1963 }
1964 #[test]
1965 #[allow(non_snake_case)]
1966 fn test_1_Mul_5() {
1967 type A = UInt<UTerm, B1>;
1968 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
1969 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
1970
1971 #[allow(non_camel_case_types)]
1972 type U1MulU5 = <<A as Mul<B>>::Output as Same<U5>>::Output;
1973
1974 assert_eq!(<U1MulU5 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
1975 }
1976 #[test]
1977 #[allow(non_snake_case)]
1978 fn test_1_Pow_5() {
1979 type A = UInt<UTerm, B1>;
1980 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
1981 type U1 = UInt<UTerm, B1>;
1982
1983 #[allow(non_camel_case_types)]
1984 type U1PowU5 = <<A as Pow<B>>::Output as Same<U1>>::Output;
1985
1986 assert_eq!(<U1PowU5 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1987 }
1988 #[test]
1989 #[allow(non_snake_case)]
1990 fn test_1_Min_5() {
1991 type A = UInt<UTerm, B1>;
1992 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
1993 type U1 = UInt<UTerm, B1>;
1994
1995 #[allow(non_camel_case_types)]
1996 type U1MinU5 = <<A as Min<B>>::Output as Same<U1>>::Output;
1997
1998 assert_eq!(<U1MinU5 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
1999 }
2000 #[test]
2001 #[allow(non_snake_case)]
2002 fn test_1_Max_5() {
2003 type A = UInt<UTerm, B1>;
2004 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
2005 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
2006
2007 #[allow(non_camel_case_types)]
2008 type U1MaxU5 = <<A as Max<B>>::Output as Same<U5>>::Output;
2009
2010 assert_eq!(<U1MaxU5 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
2011 }
2012 #[test]
2013 #[allow(non_snake_case)]
2014 fn test_1_Gcd_5() {
2015 type A = UInt<UTerm, B1>;
2016 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
2017 type U1 = UInt<UTerm, B1>;
2018
2019 #[allow(non_camel_case_types)]
2020 type U1GcdU5 = <<A as Gcd<B>>::Output as Same<U1>>::Output;
2021
2022 assert_eq!(<U1GcdU5 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
2023 }
2024 #[test]
2025 #[allow(non_snake_case)]
2026 fn test_1_Div_5() {
2027 type A = UInt<UTerm, B1>;
2028 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
2029 type U0 = UTerm;
2030
2031 #[allow(non_camel_case_types)]
2032 type U1DivU5 = <<A as Div<B>>::Output as Same<U0>>::Output;
2033
2034 assert_eq!(<U1DivU5 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
2035 }
2036 #[test]
2037 #[allow(non_snake_case)]
2038 fn test_1_Rem_5() {
2039 type A = UInt<UTerm, B1>;
2040 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
2041 type U1 = UInt<UTerm, B1>;
2042
2043 #[allow(non_camel_case_types)]
2044 type U1RemU5 = <<A as Rem<B>>::Output as Same<U1>>::Output;
2045
2046 assert_eq!(<U1RemU5 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
2047 }
2048 #[test]
2049 #[allow(non_snake_case)]
2050 fn test_1_Cmp_5() {
2051 type A = UInt<UTerm, B1>;
2052 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
2053
2054 #[allow(non_camel_case_types)]
2055 type U1CmpU5 = <A as Cmp<B>>::Output;
2056 assert_eq!(<U1CmpU5 as Ord>::to_ordering(), Ordering::Less);
2057 }
2058 #[test]
2059 #[allow(non_snake_case)]
2060 fn test_2_BitAnd_0() {
2061 type A = UInt<UInt<UTerm, B1>, B0>;
2062 type B = UTerm;
2063 type U0 = UTerm;
2064
2065 #[allow(non_camel_case_types)]
2066 type U2BitAndU0 = <<A as BitAnd<B>>::Output as Same<U0>>::Output;
2067
2068 assert_eq!(<U2BitAndU0 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
2069 }
2070 #[test]
2071 #[allow(non_snake_case)]
2072 fn test_2_BitOr_0() {
2073 type A = UInt<UInt<UTerm, B1>, B0>;
2074 type B = UTerm;
2075 type U2 = UInt<UInt<UTerm, B1>, B0>;
2076
2077 #[allow(non_camel_case_types)]
2078 type U2BitOrU0 = <<A as BitOr<B>>::Output as Same<U2>>::Output;
2079
2080 assert_eq!(<U2BitOrU0 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
2081 }
2082 #[test]
2083 #[allow(non_snake_case)]
2084 fn test_2_BitXor_0() {
2085 type A = UInt<UInt<UTerm, B1>, B0>;
2086 type B = UTerm;
2087 type U2 = UInt<UInt<UTerm, B1>, B0>;
2088
2089 #[allow(non_camel_case_types)]
2090 type U2BitXorU0 = <<A as BitXor<B>>::Output as Same<U2>>::Output;
2091
2092 assert_eq!(<U2BitXorU0 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
2093 }
2094 #[test]
2095 #[allow(non_snake_case)]
2096 fn test_2_Shl_0() {
2097 type A = UInt<UInt<UTerm, B1>, B0>;
2098 type B = UTerm;
2099 type U2 = UInt<UInt<UTerm, B1>, B0>;
2100
2101 #[allow(non_camel_case_types)]
2102 type U2ShlU0 = <<A as Shl<B>>::Output as Same<U2>>::Output;
2103
2104 assert_eq!(<U2ShlU0 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
2105 }
2106 #[test]
2107 #[allow(non_snake_case)]
2108 fn test_2_Shr_0() {
2109 type A = UInt<UInt<UTerm, B1>, B0>;
2110 type B = UTerm;
2111 type U2 = UInt<UInt<UTerm, B1>, B0>;
2112
2113 #[allow(non_camel_case_types)]
2114 type U2ShrU0 = <<A as Shr<B>>::Output as Same<U2>>::Output;
2115
2116 assert_eq!(<U2ShrU0 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
2117 }
2118 #[test]
2119 #[allow(non_snake_case)]
2120 fn test_2_Add_0() {
2121 type A = UInt<UInt<UTerm, B1>, B0>;
2122 type B = UTerm;
2123 type U2 = UInt<UInt<UTerm, B1>, B0>;
2124
2125 #[allow(non_camel_case_types)]
2126 type U2AddU0 = <<A as Add<B>>::Output as Same<U2>>::Output;
2127
2128 assert_eq!(<U2AddU0 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
2129 }
2130 #[test]
2131 #[allow(non_snake_case)]
2132 fn test_2_Mul_0() {
2133 type A = UInt<UInt<UTerm, B1>, B0>;
2134 type B = UTerm;
2135 type U0 = UTerm;
2136
2137 #[allow(non_camel_case_types)]
2138 type U2MulU0 = <<A as Mul<B>>::Output as Same<U0>>::Output;
2139
2140 assert_eq!(<U2MulU0 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
2141 }
2142 #[test]
2143 #[allow(non_snake_case)]
2144 fn test_2_Pow_0() {
2145 type A = UInt<UInt<UTerm, B1>, B0>;
2146 type B = UTerm;
2147 type U1 = UInt<UTerm, B1>;
2148
2149 #[allow(non_camel_case_types)]
2150 type U2PowU0 = <<A as Pow<B>>::Output as Same<U1>>::Output;
2151
2152 assert_eq!(<U2PowU0 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
2153 }
2154 #[test]
2155 #[allow(non_snake_case)]
2156 fn test_2_Min_0() {
2157 type A = UInt<UInt<UTerm, B1>, B0>;
2158 type B = UTerm;
2159 type U0 = UTerm;
2160
2161 #[allow(non_camel_case_types)]
2162 type U2MinU0 = <<A as Min<B>>::Output as Same<U0>>::Output;
2163
2164 assert_eq!(<U2MinU0 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
2165 }
2166 #[test]
2167 #[allow(non_snake_case)]
2168 fn test_2_Max_0() {
2169 type A = UInt<UInt<UTerm, B1>, B0>;
2170 type B = UTerm;
2171 type U2 = UInt<UInt<UTerm, B1>, B0>;
2172
2173 #[allow(non_camel_case_types)]
2174 type U2MaxU0 = <<A as Max<B>>::Output as Same<U2>>::Output;
2175
2176 assert_eq!(<U2MaxU0 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
2177 }
2178 #[test]
2179 #[allow(non_snake_case)]
2180 fn test_2_Gcd_0() {
2181 type A = UInt<UInt<UTerm, B1>, B0>;
2182 type B = UTerm;
2183 type U2 = UInt<UInt<UTerm, B1>, B0>;
2184
2185 #[allow(non_camel_case_types)]
2186 type U2GcdU0 = <<A as Gcd<B>>::Output as Same<U2>>::Output;
2187
2188 assert_eq!(<U2GcdU0 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
2189 }
2190 #[test]
2191 #[allow(non_snake_case)]
2192 fn test_2_Sub_0() {
2193 type A = UInt<UInt<UTerm, B1>, B0>;
2194 type B = UTerm;
2195 type U2 = UInt<UInt<UTerm, B1>, B0>;
2196
2197 #[allow(non_camel_case_types)]
2198 type U2SubU0 = <<A as Sub<B>>::Output as Same<U2>>::Output;
2199
2200 assert_eq!(<U2SubU0 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
2201 }
2202 #[test]
2203 #[allow(non_snake_case)]
2204 fn test_2_Cmp_0() {
2205 type A = UInt<UInt<UTerm, B1>, B0>;
2206 type B = UTerm;
2207
2208 #[allow(non_camel_case_types)]
2209 type U2CmpU0 = <A as Cmp<B>>::Output;
2210 assert_eq!(<U2CmpU0 as Ord>::to_ordering(), Ordering::Greater);
2211 }
2212 #[test]
2213 #[allow(non_snake_case)]
2214 fn test_2_BitAnd_1() {
2215 type A = UInt<UInt<UTerm, B1>, B0>;
2216 type B = UInt<UTerm, B1>;
2217 type U0 = UTerm;
2218
2219 #[allow(non_camel_case_types)]
2220 type U2BitAndU1 = <<A as BitAnd<B>>::Output as Same<U0>>::Output;
2221
2222 assert_eq!(<U2BitAndU1 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
2223 }
2224 #[test]
2225 #[allow(non_snake_case)]
2226 fn test_2_BitOr_1() {
2227 type A = UInt<UInt<UTerm, B1>, B0>;
2228 type B = UInt<UTerm, B1>;
2229 type U3 = UInt<UInt<UTerm, B1>, B1>;
2230
2231 #[allow(non_camel_case_types)]
2232 type U2BitOrU1 = <<A as BitOr<B>>::Output as Same<U3>>::Output;
2233
2234 assert_eq!(<U2BitOrU1 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
2235 }
2236 #[test]
2237 #[allow(non_snake_case)]
2238 fn test_2_BitXor_1() {
2239 type A = UInt<UInt<UTerm, B1>, B0>;
2240 type B = UInt<UTerm, B1>;
2241 type U3 = UInt<UInt<UTerm, B1>, B1>;
2242
2243 #[allow(non_camel_case_types)]
2244 type U2BitXorU1 = <<A as BitXor<B>>::Output as Same<U3>>::Output;
2245
2246 assert_eq!(<U2BitXorU1 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
2247 }
2248 #[test]
2249 #[allow(non_snake_case)]
2250 fn test_2_Shl_1() {
2251 type A = UInt<UInt<UTerm, B1>, B0>;
2252 type B = UInt<UTerm, B1>;
2253 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
2254
2255 #[allow(non_camel_case_types)]
2256 type U2ShlU1 = <<A as Shl<B>>::Output as Same<U4>>::Output;
2257
2258 assert_eq!(<U2ShlU1 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
2259 }
2260 #[test]
2261 #[allow(non_snake_case)]
2262 fn test_2_Shr_1() {
2263 type A = UInt<UInt<UTerm, B1>, B0>;
2264 type B = UInt<UTerm, B1>;
2265 type U1 = UInt<UTerm, B1>;
2266
2267 #[allow(non_camel_case_types)]
2268 type U2ShrU1 = <<A as Shr<B>>::Output as Same<U1>>::Output;
2269
2270 assert_eq!(<U2ShrU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
2271 }
2272 #[test]
2273 #[allow(non_snake_case)]
2274 fn test_2_Add_1() {
2275 type A = UInt<UInt<UTerm, B1>, B0>;
2276 type B = UInt<UTerm, B1>;
2277 type U3 = UInt<UInt<UTerm, B1>, B1>;
2278
2279 #[allow(non_camel_case_types)]
2280 type U2AddU1 = <<A as Add<B>>::Output as Same<U3>>::Output;
2281
2282 assert_eq!(<U2AddU1 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
2283 }
2284 #[test]
2285 #[allow(non_snake_case)]
2286 fn test_2_Mul_1() {
2287 type A = UInt<UInt<UTerm, B1>, B0>;
2288 type B = UInt<UTerm, B1>;
2289 type U2 = UInt<UInt<UTerm, B1>, B0>;
2290
2291 #[allow(non_camel_case_types)]
2292 type U2MulU1 = <<A as Mul<B>>::Output as Same<U2>>::Output;
2293
2294 assert_eq!(<U2MulU1 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
2295 }
2296 #[test]
2297 #[allow(non_snake_case)]
2298 fn test_2_Pow_1() {
2299 type A = UInt<UInt<UTerm, B1>, B0>;
2300 type B = UInt<UTerm, B1>;
2301 type U2 = UInt<UInt<UTerm, B1>, B0>;
2302
2303 #[allow(non_camel_case_types)]
2304 type U2PowU1 = <<A as Pow<B>>::Output as Same<U2>>::Output;
2305
2306 assert_eq!(<U2PowU1 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
2307 }
2308 #[test]
2309 #[allow(non_snake_case)]
2310 fn test_2_Min_1() {
2311 type A = UInt<UInt<UTerm, B1>, B0>;
2312 type B = UInt<UTerm, B1>;
2313 type U1 = UInt<UTerm, B1>;
2314
2315 #[allow(non_camel_case_types)]
2316 type U2MinU1 = <<A as Min<B>>::Output as Same<U1>>::Output;
2317
2318 assert_eq!(<U2MinU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
2319 }
2320 #[test]
2321 #[allow(non_snake_case)]
2322 fn test_2_Max_1() {
2323 type A = UInt<UInt<UTerm, B1>, B0>;
2324 type B = UInt<UTerm, B1>;
2325 type U2 = UInt<UInt<UTerm, B1>, B0>;
2326
2327 #[allow(non_camel_case_types)]
2328 type U2MaxU1 = <<A as Max<B>>::Output as Same<U2>>::Output;
2329
2330 assert_eq!(<U2MaxU1 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
2331 }
2332 #[test]
2333 #[allow(non_snake_case)]
2334 fn test_2_Gcd_1() {
2335 type A = UInt<UInt<UTerm, B1>, B0>;
2336 type B = UInt<UTerm, B1>;
2337 type U1 = UInt<UTerm, B1>;
2338
2339 #[allow(non_camel_case_types)]
2340 type U2GcdU1 = <<A as Gcd<B>>::Output as Same<U1>>::Output;
2341
2342 assert_eq!(<U2GcdU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
2343 }
2344 #[test]
2345 #[allow(non_snake_case)]
2346 fn test_2_Sub_1() {
2347 type A = UInt<UInt<UTerm, B1>, B0>;
2348 type B = UInt<UTerm, B1>;
2349 type U1 = UInt<UTerm, B1>;
2350
2351 #[allow(non_camel_case_types)]
2352 type U2SubU1 = <<A as Sub<B>>::Output as Same<U1>>::Output;
2353
2354 assert_eq!(<U2SubU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
2355 }
2356 #[test]
2357 #[allow(non_snake_case)]
2358 fn test_2_Div_1() {
2359 type A = UInt<UInt<UTerm, B1>, B0>;
2360 type B = UInt<UTerm, B1>;
2361 type U2 = UInt<UInt<UTerm, B1>, B0>;
2362
2363 #[allow(non_camel_case_types)]
2364 type U2DivU1 = <<A as Div<B>>::Output as Same<U2>>::Output;
2365
2366 assert_eq!(<U2DivU1 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
2367 }
2368 #[test]
2369 #[allow(non_snake_case)]
2370 fn test_2_Rem_1() {
2371 type A = UInt<UInt<UTerm, B1>, B0>;
2372 type B = UInt<UTerm, B1>;
2373 type U0 = UTerm;
2374
2375 #[allow(non_camel_case_types)]
2376 type U2RemU1 = <<A as Rem<B>>::Output as Same<U0>>::Output;
2377
2378 assert_eq!(<U2RemU1 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
2379 }
2380 #[test]
2381 #[allow(non_snake_case)]
2382 fn test_2_PartialDiv_1() {
2383 type A = UInt<UInt<UTerm, B1>, B0>;
2384 type B = UInt<UTerm, B1>;
2385 type U2 = UInt<UInt<UTerm, B1>, B0>;
2386
2387 #[allow(non_camel_case_types)]
2388 type U2PartialDivU1 = <<A as PartialDiv<B>>::Output as Same<U2>>::Output;
2389
2390 assert_eq!(<U2PartialDivU1 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
2391 }
2392 #[test]
2393 #[allow(non_snake_case)]
2394 fn test_2_Cmp_1() {
2395 type A = UInt<UInt<UTerm, B1>, B0>;
2396 type B = UInt<UTerm, B1>;
2397
2398 #[allow(non_camel_case_types)]
2399 type U2CmpU1 = <A as Cmp<B>>::Output;
2400 assert_eq!(<U2CmpU1 as Ord>::to_ordering(), Ordering::Greater);
2401 }
2402 #[test]
2403 #[allow(non_snake_case)]
2404 fn test_2_BitAnd_2() {
2405 type A = UInt<UInt<UTerm, B1>, B0>;
2406 type B = UInt<UInt<UTerm, B1>, B0>;
2407 type U2 = UInt<UInt<UTerm, B1>, B0>;
2408
2409 #[allow(non_camel_case_types)]
2410 type U2BitAndU2 = <<A as BitAnd<B>>::Output as Same<U2>>::Output;
2411
2412 assert_eq!(<U2BitAndU2 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
2413 }
2414 #[test]
2415 #[allow(non_snake_case)]
2416 fn test_2_BitOr_2() {
2417 type A = UInt<UInt<UTerm, B1>, B0>;
2418 type B = UInt<UInt<UTerm, B1>, B0>;
2419 type U2 = UInt<UInt<UTerm, B1>, B0>;
2420
2421 #[allow(non_camel_case_types)]
2422 type U2BitOrU2 = <<A as BitOr<B>>::Output as Same<U2>>::Output;
2423
2424 assert_eq!(<U2BitOrU2 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
2425 }
2426 #[test]
2427 #[allow(non_snake_case)]
2428 fn test_2_BitXor_2() {
2429 type A = UInt<UInt<UTerm, B1>, B0>;
2430 type B = UInt<UInt<UTerm, B1>, B0>;
2431 type U0 = UTerm;
2432
2433 #[allow(non_camel_case_types)]
2434 type U2BitXorU2 = <<A as BitXor<B>>::Output as Same<U0>>::Output;
2435
2436 assert_eq!(<U2BitXorU2 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
2437 }
2438 #[test]
2439 #[allow(non_snake_case)]
2440 fn test_2_Shl_2() {
2441 type A = UInt<UInt<UTerm, B1>, B0>;
2442 type B = UInt<UInt<UTerm, B1>, B0>;
2443 type U8 = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>;
2444
2445 #[allow(non_camel_case_types)]
2446 type U2ShlU2 = <<A as Shl<B>>::Output as Same<U8>>::Output;
2447
2448 assert_eq!(<U2ShlU2 as Unsigned>::to_u64(), <U8 as Unsigned>::to_u64());
2449 }
2450 #[test]
2451 #[allow(non_snake_case)]
2452 fn test_2_Shr_2() {
2453 type A = UInt<UInt<UTerm, B1>, B0>;
2454 type B = UInt<UInt<UTerm, B1>, B0>;
2455 type U0 = UTerm;
2456
2457 #[allow(non_camel_case_types)]
2458 type U2ShrU2 = <<A as Shr<B>>::Output as Same<U0>>::Output;
2459
2460 assert_eq!(<U2ShrU2 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
2461 }
2462 #[test]
2463 #[allow(non_snake_case)]
2464 fn test_2_Add_2() {
2465 type A = UInt<UInt<UTerm, B1>, B0>;
2466 type B = UInt<UInt<UTerm, B1>, B0>;
2467 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
2468
2469 #[allow(non_camel_case_types)]
2470 type U2AddU2 = <<A as Add<B>>::Output as Same<U4>>::Output;
2471
2472 assert_eq!(<U2AddU2 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
2473 }
2474 #[test]
2475 #[allow(non_snake_case)]
2476 fn test_2_Mul_2() {
2477 type A = UInt<UInt<UTerm, B1>, B0>;
2478 type B = UInt<UInt<UTerm, B1>, B0>;
2479 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
2480
2481 #[allow(non_camel_case_types)]
2482 type U2MulU2 = <<A as Mul<B>>::Output as Same<U4>>::Output;
2483
2484 assert_eq!(<U2MulU2 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
2485 }
2486 #[test]
2487 #[allow(non_snake_case)]
2488 fn test_2_Pow_2() {
2489 type A = UInt<UInt<UTerm, B1>, B0>;
2490 type B = UInt<UInt<UTerm, B1>, B0>;
2491 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
2492
2493 #[allow(non_camel_case_types)]
2494 type U2PowU2 = <<A as Pow<B>>::Output as Same<U4>>::Output;
2495
2496 assert_eq!(<U2PowU2 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
2497 }
2498 #[test]
2499 #[allow(non_snake_case)]
2500 fn test_2_Min_2() {
2501 type A = UInt<UInt<UTerm, B1>, B0>;
2502 type B = UInt<UInt<UTerm, B1>, B0>;
2503 type U2 = UInt<UInt<UTerm, B1>, B0>;
2504
2505 #[allow(non_camel_case_types)]
2506 type U2MinU2 = <<A as Min<B>>::Output as Same<U2>>::Output;
2507
2508 assert_eq!(<U2MinU2 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
2509 }
2510 #[test]
2511 #[allow(non_snake_case)]
2512 fn test_2_Max_2() {
2513 type A = UInt<UInt<UTerm, B1>, B0>;
2514 type B = UInt<UInt<UTerm, B1>, B0>;
2515 type U2 = UInt<UInt<UTerm, B1>, B0>;
2516
2517 #[allow(non_camel_case_types)]
2518 type U2MaxU2 = <<A as Max<B>>::Output as Same<U2>>::Output;
2519
2520 assert_eq!(<U2MaxU2 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
2521 }
2522 #[test]
2523 #[allow(non_snake_case)]
2524 fn test_2_Gcd_2() {
2525 type A = UInt<UInt<UTerm, B1>, B0>;
2526 type B = UInt<UInt<UTerm, B1>, B0>;
2527 type U2 = UInt<UInt<UTerm, B1>, B0>;
2528
2529 #[allow(non_camel_case_types)]
2530 type U2GcdU2 = <<A as Gcd<B>>::Output as Same<U2>>::Output;
2531
2532 assert_eq!(<U2GcdU2 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
2533 }
2534 #[test]
2535 #[allow(non_snake_case)]
2536 fn test_2_Sub_2() {
2537 type A = UInt<UInt<UTerm, B1>, B0>;
2538 type B = UInt<UInt<UTerm, B1>, B0>;
2539 type U0 = UTerm;
2540
2541 #[allow(non_camel_case_types)]
2542 type U2SubU2 = <<A as Sub<B>>::Output as Same<U0>>::Output;
2543
2544 assert_eq!(<U2SubU2 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
2545 }
2546 #[test]
2547 #[allow(non_snake_case)]
2548 fn test_2_Div_2() {
2549 type A = UInt<UInt<UTerm, B1>, B0>;
2550 type B = UInt<UInt<UTerm, B1>, B0>;
2551 type U1 = UInt<UTerm, B1>;
2552
2553 #[allow(non_camel_case_types)]
2554 type U2DivU2 = <<A as Div<B>>::Output as Same<U1>>::Output;
2555
2556 assert_eq!(<U2DivU2 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
2557 }
2558 #[test]
2559 #[allow(non_snake_case)]
2560 fn test_2_Rem_2() {
2561 type A = UInt<UInt<UTerm, B1>, B0>;
2562 type B = UInt<UInt<UTerm, B1>, B0>;
2563 type U0 = UTerm;
2564
2565 #[allow(non_camel_case_types)]
2566 type U2RemU2 = <<A as Rem<B>>::Output as Same<U0>>::Output;
2567
2568 assert_eq!(<U2RemU2 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
2569 }
2570 #[test]
2571 #[allow(non_snake_case)]
2572 fn test_2_PartialDiv_2() {
2573 type A = UInt<UInt<UTerm, B1>, B0>;
2574 type B = UInt<UInt<UTerm, B1>, B0>;
2575 type U1 = UInt<UTerm, B1>;
2576
2577 #[allow(non_camel_case_types)]
2578 type U2PartialDivU2 = <<A as PartialDiv<B>>::Output as Same<U1>>::Output;
2579
2580 assert_eq!(<U2PartialDivU2 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
2581 }
2582 #[test]
2583 #[allow(non_snake_case)]
2584 fn test_2_Cmp_2() {
2585 type A = UInt<UInt<UTerm, B1>, B0>;
2586 type B = UInt<UInt<UTerm, B1>, B0>;
2587
2588 #[allow(non_camel_case_types)]
2589 type U2CmpU2 = <A as Cmp<B>>::Output;
2590 assert_eq!(<U2CmpU2 as Ord>::to_ordering(), Ordering::Equal);
2591 }
2592 #[test]
2593 #[allow(non_snake_case)]
2594 fn test_2_BitAnd_3() {
2595 type A = UInt<UInt<UTerm, B1>, B0>;
2596 type B = UInt<UInt<UTerm, B1>, B1>;
2597 type U2 = UInt<UInt<UTerm, B1>, B0>;
2598
2599 #[allow(non_camel_case_types)]
2600 type U2BitAndU3 = <<A as BitAnd<B>>::Output as Same<U2>>::Output;
2601
2602 assert_eq!(<U2BitAndU3 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
2603 }
2604 #[test]
2605 #[allow(non_snake_case)]
2606 fn test_2_BitOr_3() {
2607 type A = UInt<UInt<UTerm, B1>, B0>;
2608 type B = UInt<UInt<UTerm, B1>, B1>;
2609 type U3 = UInt<UInt<UTerm, B1>, B1>;
2610
2611 #[allow(non_camel_case_types)]
2612 type U2BitOrU3 = <<A as BitOr<B>>::Output as Same<U3>>::Output;
2613
2614 assert_eq!(<U2BitOrU3 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
2615 }
2616 #[test]
2617 #[allow(non_snake_case)]
2618 fn test_2_BitXor_3() {
2619 type A = UInt<UInt<UTerm, B1>, B0>;
2620 type B = UInt<UInt<UTerm, B1>, B1>;
2621 type U1 = UInt<UTerm, B1>;
2622
2623 #[allow(non_camel_case_types)]
2624 type U2BitXorU3 = <<A as BitXor<B>>::Output as Same<U1>>::Output;
2625
2626 assert_eq!(<U2BitXorU3 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
2627 }
2628 #[test]
2629 #[allow(non_snake_case)]
2630 fn test_2_Shl_3() {
2631 type A = UInt<UInt<UTerm, B1>, B0>;
2632 type B = UInt<UInt<UTerm, B1>, B1>;
2633 type U16 = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>;
2634
2635 #[allow(non_camel_case_types)]
2636 type U2ShlU3 = <<A as Shl<B>>::Output as Same<U16>>::Output;
2637
2638 assert_eq!(<U2ShlU3 as Unsigned>::to_u64(), <U16 as Unsigned>::to_u64());
2639 }
2640 #[test]
2641 #[allow(non_snake_case)]
2642 fn test_2_Shr_3() {
2643 type A = UInt<UInt<UTerm, B1>, B0>;
2644 type B = UInt<UInt<UTerm, B1>, B1>;
2645 type U0 = UTerm;
2646
2647 #[allow(non_camel_case_types)]
2648 type U2ShrU3 = <<A as Shr<B>>::Output as Same<U0>>::Output;
2649
2650 assert_eq!(<U2ShrU3 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
2651 }
2652 #[test]
2653 #[allow(non_snake_case)]
2654 fn test_2_Add_3() {
2655 type A = UInt<UInt<UTerm, B1>, B0>;
2656 type B = UInt<UInt<UTerm, B1>, B1>;
2657 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
2658
2659 #[allow(non_camel_case_types)]
2660 type U2AddU3 = <<A as Add<B>>::Output as Same<U5>>::Output;
2661
2662 assert_eq!(<U2AddU3 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
2663 }
2664 #[test]
2665 #[allow(non_snake_case)]
2666 fn test_2_Mul_3() {
2667 type A = UInt<UInt<UTerm, B1>, B0>;
2668 type B = UInt<UInt<UTerm, B1>, B1>;
2669 type U6 = UInt<UInt<UInt<UTerm, B1>, B1>, B0>;
2670
2671 #[allow(non_camel_case_types)]
2672 type U2MulU3 = <<A as Mul<B>>::Output as Same<U6>>::Output;
2673
2674 assert_eq!(<U2MulU3 as Unsigned>::to_u64(), <U6 as Unsigned>::to_u64());
2675 }
2676 #[test]
2677 #[allow(non_snake_case)]
2678 fn test_2_Pow_3() {
2679 type A = UInt<UInt<UTerm, B1>, B0>;
2680 type B = UInt<UInt<UTerm, B1>, B1>;
2681 type U8 = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>;
2682
2683 #[allow(non_camel_case_types)]
2684 type U2PowU3 = <<A as Pow<B>>::Output as Same<U8>>::Output;
2685
2686 assert_eq!(<U2PowU3 as Unsigned>::to_u64(), <U8 as Unsigned>::to_u64());
2687 }
2688 #[test]
2689 #[allow(non_snake_case)]
2690 fn test_2_Min_3() {
2691 type A = UInt<UInt<UTerm, B1>, B0>;
2692 type B = UInt<UInt<UTerm, B1>, B1>;
2693 type U2 = UInt<UInt<UTerm, B1>, B0>;
2694
2695 #[allow(non_camel_case_types)]
2696 type U2MinU3 = <<A as Min<B>>::Output as Same<U2>>::Output;
2697
2698 assert_eq!(<U2MinU3 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
2699 }
2700 #[test]
2701 #[allow(non_snake_case)]
2702 fn test_2_Max_3() {
2703 type A = UInt<UInt<UTerm, B1>, B0>;
2704 type B = UInt<UInt<UTerm, B1>, B1>;
2705 type U3 = UInt<UInt<UTerm, B1>, B1>;
2706
2707 #[allow(non_camel_case_types)]
2708 type U2MaxU3 = <<A as Max<B>>::Output as Same<U3>>::Output;
2709
2710 assert_eq!(<U2MaxU3 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
2711 }
2712 #[test]
2713 #[allow(non_snake_case)]
2714 fn test_2_Gcd_3() {
2715 type A = UInt<UInt<UTerm, B1>, B0>;
2716 type B = UInt<UInt<UTerm, B1>, B1>;
2717 type U1 = UInt<UTerm, B1>;
2718
2719 #[allow(non_camel_case_types)]
2720 type U2GcdU3 = <<A as Gcd<B>>::Output as Same<U1>>::Output;
2721
2722 assert_eq!(<U2GcdU3 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
2723 }
2724 #[test]
2725 #[allow(non_snake_case)]
2726 fn test_2_Div_3() {
2727 type A = UInt<UInt<UTerm, B1>, B0>;
2728 type B = UInt<UInt<UTerm, B1>, B1>;
2729 type U0 = UTerm;
2730
2731 #[allow(non_camel_case_types)]
2732 type U2DivU3 = <<A as Div<B>>::Output as Same<U0>>::Output;
2733
2734 assert_eq!(<U2DivU3 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
2735 }
2736 #[test]
2737 #[allow(non_snake_case)]
2738 fn test_2_Rem_3() {
2739 type A = UInt<UInt<UTerm, B1>, B0>;
2740 type B = UInt<UInt<UTerm, B1>, B1>;
2741 type U2 = UInt<UInt<UTerm, B1>, B0>;
2742
2743 #[allow(non_camel_case_types)]
2744 type U2RemU3 = <<A as Rem<B>>::Output as Same<U2>>::Output;
2745
2746 assert_eq!(<U2RemU3 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
2747 }
2748 #[test]
2749 #[allow(non_snake_case)]
2750 fn test_2_Cmp_3() {
2751 type A = UInt<UInt<UTerm, B1>, B0>;
2752 type B = UInt<UInt<UTerm, B1>, B1>;
2753
2754 #[allow(non_camel_case_types)]
2755 type U2CmpU3 = <A as Cmp<B>>::Output;
2756 assert_eq!(<U2CmpU3 as Ord>::to_ordering(), Ordering::Less);
2757 }
2758 #[test]
2759 #[allow(non_snake_case)]
2760 fn test_2_BitAnd_4() {
2761 type A = UInt<UInt<UTerm, B1>, B0>;
2762 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
2763 type U0 = UTerm;
2764
2765 #[allow(non_camel_case_types)]
2766 type U2BitAndU4 = <<A as BitAnd<B>>::Output as Same<U0>>::Output;
2767
2768 assert_eq!(<U2BitAndU4 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
2769 }
2770 #[test]
2771 #[allow(non_snake_case)]
2772 fn test_2_BitOr_4() {
2773 type A = UInt<UInt<UTerm, B1>, B0>;
2774 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
2775 type U6 = UInt<UInt<UInt<UTerm, B1>, B1>, B0>;
2776
2777 #[allow(non_camel_case_types)]
2778 type U2BitOrU4 = <<A as BitOr<B>>::Output as Same<U6>>::Output;
2779
2780 assert_eq!(<U2BitOrU4 as Unsigned>::to_u64(), <U6 as Unsigned>::to_u64());
2781 }
2782 #[test]
2783 #[allow(non_snake_case)]
2784 fn test_2_BitXor_4() {
2785 type A = UInt<UInt<UTerm, B1>, B0>;
2786 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
2787 type U6 = UInt<UInt<UInt<UTerm, B1>, B1>, B0>;
2788
2789 #[allow(non_camel_case_types)]
2790 type U2BitXorU4 = <<A as BitXor<B>>::Output as Same<U6>>::Output;
2791
2792 assert_eq!(<U2BitXorU4 as Unsigned>::to_u64(), <U6 as Unsigned>::to_u64());
2793 }
2794 #[test]
2795 #[allow(non_snake_case)]
2796 fn test_2_Shl_4() {
2797 type A = UInt<UInt<UTerm, B1>, B0>;
2798 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
2799 type U32 = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>;
2800
2801 #[allow(non_camel_case_types)]
2802 type U2ShlU4 = <<A as Shl<B>>::Output as Same<U32>>::Output;
2803
2804 assert_eq!(<U2ShlU4 as Unsigned>::to_u64(), <U32 as Unsigned>::to_u64());
2805 }
2806 #[test]
2807 #[allow(non_snake_case)]
2808 fn test_2_Shr_4() {
2809 type A = UInt<UInt<UTerm, B1>, B0>;
2810 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
2811 type U0 = UTerm;
2812
2813 #[allow(non_camel_case_types)]
2814 type U2ShrU4 = <<A as Shr<B>>::Output as Same<U0>>::Output;
2815
2816 assert_eq!(<U2ShrU4 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
2817 }
2818 #[test]
2819 #[allow(non_snake_case)]
2820 fn test_2_Add_4() {
2821 type A = UInt<UInt<UTerm, B1>, B0>;
2822 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
2823 type U6 = UInt<UInt<UInt<UTerm, B1>, B1>, B0>;
2824
2825 #[allow(non_camel_case_types)]
2826 type U2AddU4 = <<A as Add<B>>::Output as Same<U6>>::Output;
2827
2828 assert_eq!(<U2AddU4 as Unsigned>::to_u64(), <U6 as Unsigned>::to_u64());
2829 }
2830 #[test]
2831 #[allow(non_snake_case)]
2832 fn test_2_Mul_4() {
2833 type A = UInt<UInt<UTerm, B1>, B0>;
2834 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
2835 type U8 = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>;
2836
2837 #[allow(non_camel_case_types)]
2838 type U2MulU4 = <<A as Mul<B>>::Output as Same<U8>>::Output;
2839
2840 assert_eq!(<U2MulU4 as Unsigned>::to_u64(), <U8 as Unsigned>::to_u64());
2841 }
2842 #[test]
2843 #[allow(non_snake_case)]
2844 fn test_2_Pow_4() {
2845 type A = UInt<UInt<UTerm, B1>, B0>;
2846 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
2847 type U16 = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>;
2848
2849 #[allow(non_camel_case_types)]
2850 type U2PowU4 = <<A as Pow<B>>::Output as Same<U16>>::Output;
2851
2852 assert_eq!(<U2PowU4 as Unsigned>::to_u64(), <U16 as Unsigned>::to_u64());
2853 }
2854 #[test]
2855 #[allow(non_snake_case)]
2856 fn test_2_Min_4() {
2857 type A = UInt<UInt<UTerm, B1>, B0>;
2858 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
2859 type U2 = UInt<UInt<UTerm, B1>, B0>;
2860
2861 #[allow(non_camel_case_types)]
2862 type U2MinU4 = <<A as Min<B>>::Output as Same<U2>>::Output;
2863
2864 assert_eq!(<U2MinU4 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
2865 }
2866 #[test]
2867 #[allow(non_snake_case)]
2868 fn test_2_Max_4() {
2869 type A = UInt<UInt<UTerm, B1>, B0>;
2870 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
2871 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
2872
2873 #[allow(non_camel_case_types)]
2874 type U2MaxU4 = <<A as Max<B>>::Output as Same<U4>>::Output;
2875
2876 assert_eq!(<U2MaxU4 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
2877 }
2878 #[test]
2879 #[allow(non_snake_case)]
2880 fn test_2_Gcd_4() {
2881 type A = UInt<UInt<UTerm, B1>, B0>;
2882 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
2883 type U2 = UInt<UInt<UTerm, B1>, B0>;
2884
2885 #[allow(non_camel_case_types)]
2886 type U2GcdU4 = <<A as Gcd<B>>::Output as Same<U2>>::Output;
2887
2888 assert_eq!(<U2GcdU4 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
2889 }
2890 #[test]
2891 #[allow(non_snake_case)]
2892 fn test_2_Div_4() {
2893 type A = UInt<UInt<UTerm, B1>, B0>;
2894 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
2895 type U0 = UTerm;
2896
2897 #[allow(non_camel_case_types)]
2898 type U2DivU4 = <<A as Div<B>>::Output as Same<U0>>::Output;
2899
2900 assert_eq!(<U2DivU4 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
2901 }
2902 #[test]
2903 #[allow(non_snake_case)]
2904 fn test_2_Rem_4() {
2905 type A = UInt<UInt<UTerm, B1>, B0>;
2906 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
2907 type U2 = UInt<UInt<UTerm, B1>, B0>;
2908
2909 #[allow(non_camel_case_types)]
2910 type U2RemU4 = <<A as Rem<B>>::Output as Same<U2>>::Output;
2911
2912 assert_eq!(<U2RemU4 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
2913 }
2914 #[test]
2915 #[allow(non_snake_case)]
2916 fn test_2_Cmp_4() {
2917 type A = UInt<UInt<UTerm, B1>, B0>;
2918 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
2919
2920 #[allow(non_camel_case_types)]
2921 type U2CmpU4 = <A as Cmp<B>>::Output;
2922 assert_eq!(<U2CmpU4 as Ord>::to_ordering(), Ordering::Less);
2923 }
2924 #[test]
2925 #[allow(non_snake_case)]
2926 fn test_2_BitAnd_5() {
2927 type A = UInt<UInt<UTerm, B1>, B0>;
2928 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
2929 type U0 = UTerm;
2930
2931 #[allow(non_camel_case_types)]
2932 type U2BitAndU5 = <<A as BitAnd<B>>::Output as Same<U0>>::Output;
2933
2934 assert_eq!(<U2BitAndU5 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
2935 }
2936 #[test]
2937 #[allow(non_snake_case)]
2938 fn test_2_BitOr_5() {
2939 type A = UInt<UInt<UTerm, B1>, B0>;
2940 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
2941 type U7 = UInt<UInt<UInt<UTerm, B1>, B1>, B1>;
2942
2943 #[allow(non_camel_case_types)]
2944 type U2BitOrU5 = <<A as BitOr<B>>::Output as Same<U7>>::Output;
2945
2946 assert_eq!(<U2BitOrU5 as Unsigned>::to_u64(), <U7 as Unsigned>::to_u64());
2947 }
2948 #[test]
2949 #[allow(non_snake_case)]
2950 fn test_2_BitXor_5() {
2951 type A = UInt<UInt<UTerm, B1>, B0>;
2952 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
2953 type U7 = UInt<UInt<UInt<UTerm, B1>, B1>, B1>;
2954
2955 #[allow(non_camel_case_types)]
2956 type U2BitXorU5 = <<A as BitXor<B>>::Output as Same<U7>>::Output;
2957
2958 assert_eq!(<U2BitXorU5 as Unsigned>::to_u64(), <U7 as Unsigned>::to_u64());
2959 }
2960 #[test]
2961 #[allow(non_snake_case)]
2962 fn test_2_Shl_5() {
2963 type A = UInt<UInt<UTerm, B1>, B0>;
2964 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
2965 type U64 = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>;
2966
2967 #[allow(non_camel_case_types)]
2968 type U2ShlU5 = <<A as Shl<B>>::Output as Same<U64>>::Output;
2969
2970 assert_eq!(<U2ShlU5 as Unsigned>::to_u64(), <U64 as Unsigned>::to_u64());
2971 }
2972 #[test]
2973 #[allow(non_snake_case)]
2974 fn test_2_Shr_5() {
2975 type A = UInt<UInt<UTerm, B1>, B0>;
2976 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
2977 type U0 = UTerm;
2978
2979 #[allow(non_camel_case_types)]
2980 type U2ShrU5 = <<A as Shr<B>>::Output as Same<U0>>::Output;
2981
2982 assert_eq!(<U2ShrU5 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
2983 }
2984 #[test]
2985 #[allow(non_snake_case)]
2986 fn test_2_Add_5() {
2987 type A = UInt<UInt<UTerm, B1>, B0>;
2988 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
2989 type U7 = UInt<UInt<UInt<UTerm, B1>, B1>, B1>;
2990
2991 #[allow(non_camel_case_types)]
2992 type U2AddU5 = <<A as Add<B>>::Output as Same<U7>>::Output;
2993
2994 assert_eq!(<U2AddU5 as Unsigned>::to_u64(), <U7 as Unsigned>::to_u64());
2995 }
2996 #[test]
2997 #[allow(non_snake_case)]
2998 fn test_2_Mul_5() {
2999 type A = UInt<UInt<UTerm, B1>, B0>;
3000 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
3001 type U10 = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>;
3002
3003 #[allow(non_camel_case_types)]
3004 type U2MulU5 = <<A as Mul<B>>::Output as Same<U10>>::Output;
3005
3006 assert_eq!(<U2MulU5 as Unsigned>::to_u64(), <U10 as Unsigned>::to_u64());
3007 }
3008 #[test]
3009 #[allow(non_snake_case)]
3010 fn test_2_Pow_5() {
3011 type A = UInt<UInt<UTerm, B1>, B0>;
3012 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
3013 type U32 = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>;
3014
3015 #[allow(non_camel_case_types)]
3016 type U2PowU5 = <<A as Pow<B>>::Output as Same<U32>>::Output;
3017
3018 assert_eq!(<U2PowU5 as Unsigned>::to_u64(), <U32 as Unsigned>::to_u64());
3019 }
3020 #[test]
3021 #[allow(non_snake_case)]
3022 fn test_2_Min_5() {
3023 type A = UInt<UInt<UTerm, B1>, B0>;
3024 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
3025 type U2 = UInt<UInt<UTerm, B1>, B0>;
3026
3027 #[allow(non_camel_case_types)]
3028 type U2MinU5 = <<A as Min<B>>::Output as Same<U2>>::Output;
3029
3030 assert_eq!(<U2MinU5 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
3031 }
3032 #[test]
3033 #[allow(non_snake_case)]
3034 fn test_2_Max_5() {
3035 type A = UInt<UInt<UTerm, B1>, B0>;
3036 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
3037 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
3038
3039 #[allow(non_camel_case_types)]
3040 type U2MaxU5 = <<A as Max<B>>::Output as Same<U5>>::Output;
3041
3042 assert_eq!(<U2MaxU5 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
3043 }
3044 #[test]
3045 #[allow(non_snake_case)]
3046 fn test_2_Gcd_5() {
3047 type A = UInt<UInt<UTerm, B1>, B0>;
3048 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
3049 type U1 = UInt<UTerm, B1>;
3050
3051 #[allow(non_camel_case_types)]
3052 type U2GcdU5 = <<A as Gcd<B>>::Output as Same<U1>>::Output;
3053
3054 assert_eq!(<U2GcdU5 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
3055 }
3056 #[test]
3057 #[allow(non_snake_case)]
3058 fn test_2_Div_5() {
3059 type A = UInt<UInt<UTerm, B1>, B0>;
3060 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
3061 type U0 = UTerm;
3062
3063 #[allow(non_camel_case_types)]
3064 type U2DivU5 = <<A as Div<B>>::Output as Same<U0>>::Output;
3065
3066 assert_eq!(<U2DivU5 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
3067 }
3068 #[test]
3069 #[allow(non_snake_case)]
3070 fn test_2_Rem_5() {
3071 type A = UInt<UInt<UTerm, B1>, B0>;
3072 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
3073 type U2 = UInt<UInt<UTerm, B1>, B0>;
3074
3075 #[allow(non_camel_case_types)]
3076 type U2RemU5 = <<A as Rem<B>>::Output as Same<U2>>::Output;
3077
3078 assert_eq!(<U2RemU5 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
3079 }
3080 #[test]
3081 #[allow(non_snake_case)]
3082 fn test_2_Cmp_5() {
3083 type A = UInt<UInt<UTerm, B1>, B0>;
3084 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
3085
3086 #[allow(non_camel_case_types)]
3087 type U2CmpU5 = <A as Cmp<B>>::Output;
3088 assert_eq!(<U2CmpU5 as Ord>::to_ordering(), Ordering::Less);
3089 }
3090 #[test]
3091 #[allow(non_snake_case)]
3092 fn test_3_BitAnd_0() {
3093 type A = UInt<UInt<UTerm, B1>, B1>;
3094 type B = UTerm;
3095 type U0 = UTerm;
3096
3097 #[allow(non_camel_case_types)]
3098 type U3BitAndU0 = <<A as BitAnd<B>>::Output as Same<U0>>::Output;
3099
3100 assert_eq!(<U3BitAndU0 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
3101 }
3102 #[test]
3103 #[allow(non_snake_case)]
3104 fn test_3_BitOr_0() {
3105 type A = UInt<UInt<UTerm, B1>, B1>;
3106 type B = UTerm;
3107 type U3 = UInt<UInt<UTerm, B1>, B1>;
3108
3109 #[allow(non_camel_case_types)]
3110 type U3BitOrU0 = <<A as BitOr<B>>::Output as Same<U3>>::Output;
3111
3112 assert_eq!(<U3BitOrU0 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
3113 }
3114 #[test]
3115 #[allow(non_snake_case)]
3116 fn test_3_BitXor_0() {
3117 type A = UInt<UInt<UTerm, B1>, B1>;
3118 type B = UTerm;
3119 type U3 = UInt<UInt<UTerm, B1>, B1>;
3120
3121 #[allow(non_camel_case_types)]
3122 type U3BitXorU0 = <<A as BitXor<B>>::Output as Same<U3>>::Output;
3123
3124 assert_eq!(<U3BitXorU0 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
3125 }
3126 #[test]
3127 #[allow(non_snake_case)]
3128 fn test_3_Shl_0() {
3129 type A = UInt<UInt<UTerm, B1>, B1>;
3130 type B = UTerm;
3131 type U3 = UInt<UInt<UTerm, B1>, B1>;
3132
3133 #[allow(non_camel_case_types)]
3134 type U3ShlU0 = <<A as Shl<B>>::Output as Same<U3>>::Output;
3135
3136 assert_eq!(<U3ShlU0 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
3137 }
3138 #[test]
3139 #[allow(non_snake_case)]
3140 fn test_3_Shr_0() {
3141 type A = UInt<UInt<UTerm, B1>, B1>;
3142 type B = UTerm;
3143 type U3 = UInt<UInt<UTerm, B1>, B1>;
3144
3145 #[allow(non_camel_case_types)]
3146 type U3ShrU0 = <<A as Shr<B>>::Output as Same<U3>>::Output;
3147
3148 assert_eq!(<U3ShrU0 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
3149 }
3150 #[test]
3151 #[allow(non_snake_case)]
3152 fn test_3_Add_0() {
3153 type A = UInt<UInt<UTerm, B1>, B1>;
3154 type B = UTerm;
3155 type U3 = UInt<UInt<UTerm, B1>, B1>;
3156
3157 #[allow(non_camel_case_types)]
3158 type U3AddU0 = <<A as Add<B>>::Output as Same<U3>>::Output;
3159
3160 assert_eq!(<U3AddU0 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
3161 }
3162 #[test]
3163 #[allow(non_snake_case)]
3164 fn test_3_Mul_0() {
3165 type A = UInt<UInt<UTerm, B1>, B1>;
3166 type B = UTerm;
3167 type U0 = UTerm;
3168
3169 #[allow(non_camel_case_types)]
3170 type U3MulU0 = <<A as Mul<B>>::Output as Same<U0>>::Output;
3171
3172 assert_eq!(<U3MulU0 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
3173 }
3174 #[test]
3175 #[allow(non_snake_case)]
3176 fn test_3_Pow_0() {
3177 type A = UInt<UInt<UTerm, B1>, B1>;
3178 type B = UTerm;
3179 type U1 = UInt<UTerm, B1>;
3180
3181 #[allow(non_camel_case_types)]
3182 type U3PowU0 = <<A as Pow<B>>::Output as Same<U1>>::Output;
3183
3184 assert_eq!(<U3PowU0 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
3185 }
3186 #[test]
3187 #[allow(non_snake_case)]
3188 fn test_3_Min_0() {
3189 type A = UInt<UInt<UTerm, B1>, B1>;
3190 type B = UTerm;
3191 type U0 = UTerm;
3192
3193 #[allow(non_camel_case_types)]
3194 type U3MinU0 = <<A as Min<B>>::Output as Same<U0>>::Output;
3195
3196 assert_eq!(<U3MinU0 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
3197 }
3198 #[test]
3199 #[allow(non_snake_case)]
3200 fn test_3_Max_0() {
3201 type A = UInt<UInt<UTerm, B1>, B1>;
3202 type B = UTerm;
3203 type U3 = UInt<UInt<UTerm, B1>, B1>;
3204
3205 #[allow(non_camel_case_types)]
3206 type U3MaxU0 = <<A as Max<B>>::Output as Same<U3>>::Output;
3207
3208 assert_eq!(<U3MaxU0 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
3209 }
3210 #[test]
3211 #[allow(non_snake_case)]
3212 fn test_3_Gcd_0() {
3213 type A = UInt<UInt<UTerm, B1>, B1>;
3214 type B = UTerm;
3215 type U3 = UInt<UInt<UTerm, B1>, B1>;
3216
3217 #[allow(non_camel_case_types)]
3218 type U3GcdU0 = <<A as Gcd<B>>::Output as Same<U3>>::Output;
3219
3220 assert_eq!(<U3GcdU0 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
3221 }
3222 #[test]
3223 #[allow(non_snake_case)]
3224 fn test_3_Sub_0() {
3225 type A = UInt<UInt<UTerm, B1>, B1>;
3226 type B = UTerm;
3227 type U3 = UInt<UInt<UTerm, B1>, B1>;
3228
3229 #[allow(non_camel_case_types)]
3230 type U3SubU0 = <<A as Sub<B>>::Output as Same<U3>>::Output;
3231
3232 assert_eq!(<U3SubU0 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
3233 }
3234 #[test]
3235 #[allow(non_snake_case)]
3236 fn test_3_Cmp_0() {
3237 type A = UInt<UInt<UTerm, B1>, B1>;
3238 type B = UTerm;
3239
3240 #[allow(non_camel_case_types)]
3241 type U3CmpU0 = <A as Cmp<B>>::Output;
3242 assert_eq!(<U3CmpU0 as Ord>::to_ordering(), Ordering::Greater);
3243 }
3244 #[test]
3245 #[allow(non_snake_case)]
3246 fn test_3_BitAnd_1() {
3247 type A = UInt<UInt<UTerm, B1>, B1>;
3248 type B = UInt<UTerm, B1>;
3249 type U1 = UInt<UTerm, B1>;
3250
3251 #[allow(non_camel_case_types)]
3252 type U3BitAndU1 = <<A as BitAnd<B>>::Output as Same<U1>>::Output;
3253
3254 assert_eq!(<U3BitAndU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
3255 }
3256 #[test]
3257 #[allow(non_snake_case)]
3258 fn test_3_BitOr_1() {
3259 type A = UInt<UInt<UTerm, B1>, B1>;
3260 type B = UInt<UTerm, B1>;
3261 type U3 = UInt<UInt<UTerm, B1>, B1>;
3262
3263 #[allow(non_camel_case_types)]
3264 type U3BitOrU1 = <<A as BitOr<B>>::Output as Same<U3>>::Output;
3265
3266 assert_eq!(<U3BitOrU1 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
3267 }
3268 #[test]
3269 #[allow(non_snake_case)]
3270 fn test_3_BitXor_1() {
3271 type A = UInt<UInt<UTerm, B1>, B1>;
3272 type B = UInt<UTerm, B1>;
3273 type U2 = UInt<UInt<UTerm, B1>, B0>;
3274
3275 #[allow(non_camel_case_types)]
3276 type U3BitXorU1 = <<A as BitXor<B>>::Output as Same<U2>>::Output;
3277
3278 assert_eq!(<U3BitXorU1 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
3279 }
3280 #[test]
3281 #[allow(non_snake_case)]
3282 fn test_3_Shl_1() {
3283 type A = UInt<UInt<UTerm, B1>, B1>;
3284 type B = UInt<UTerm, B1>;
3285 type U6 = UInt<UInt<UInt<UTerm, B1>, B1>, B0>;
3286
3287 #[allow(non_camel_case_types)]
3288 type U3ShlU1 = <<A as Shl<B>>::Output as Same<U6>>::Output;
3289
3290 assert_eq!(<U3ShlU1 as Unsigned>::to_u64(), <U6 as Unsigned>::to_u64());
3291 }
3292 #[test]
3293 #[allow(non_snake_case)]
3294 fn test_3_Shr_1() {
3295 type A = UInt<UInt<UTerm, B1>, B1>;
3296 type B = UInt<UTerm, B1>;
3297 type U1 = UInt<UTerm, B1>;
3298
3299 #[allow(non_camel_case_types)]
3300 type U3ShrU1 = <<A as Shr<B>>::Output as Same<U1>>::Output;
3301
3302 assert_eq!(<U3ShrU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
3303 }
3304 #[test]
3305 #[allow(non_snake_case)]
3306 fn test_3_Add_1() {
3307 type A = UInt<UInt<UTerm, B1>, B1>;
3308 type B = UInt<UTerm, B1>;
3309 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
3310
3311 #[allow(non_camel_case_types)]
3312 type U3AddU1 = <<A as Add<B>>::Output as Same<U4>>::Output;
3313
3314 assert_eq!(<U3AddU1 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
3315 }
3316 #[test]
3317 #[allow(non_snake_case)]
3318 fn test_3_Mul_1() {
3319 type A = UInt<UInt<UTerm, B1>, B1>;
3320 type B = UInt<UTerm, B1>;
3321 type U3 = UInt<UInt<UTerm, B1>, B1>;
3322
3323 #[allow(non_camel_case_types)]
3324 type U3MulU1 = <<A as Mul<B>>::Output as Same<U3>>::Output;
3325
3326 assert_eq!(<U3MulU1 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
3327 }
3328 #[test]
3329 #[allow(non_snake_case)]
3330 fn test_3_Pow_1() {
3331 type A = UInt<UInt<UTerm, B1>, B1>;
3332 type B = UInt<UTerm, B1>;
3333 type U3 = UInt<UInt<UTerm, B1>, B1>;
3334
3335 #[allow(non_camel_case_types)]
3336 type U3PowU1 = <<A as Pow<B>>::Output as Same<U3>>::Output;
3337
3338 assert_eq!(<U3PowU1 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
3339 }
3340 #[test]
3341 #[allow(non_snake_case)]
3342 fn test_3_Min_1() {
3343 type A = UInt<UInt<UTerm, B1>, B1>;
3344 type B = UInt<UTerm, B1>;
3345 type U1 = UInt<UTerm, B1>;
3346
3347 #[allow(non_camel_case_types)]
3348 type U3MinU1 = <<A as Min<B>>::Output as Same<U1>>::Output;
3349
3350 assert_eq!(<U3MinU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
3351 }
3352 #[test]
3353 #[allow(non_snake_case)]
3354 fn test_3_Max_1() {
3355 type A = UInt<UInt<UTerm, B1>, B1>;
3356 type B = UInt<UTerm, B1>;
3357 type U3 = UInt<UInt<UTerm, B1>, B1>;
3358
3359 #[allow(non_camel_case_types)]
3360 type U3MaxU1 = <<A as Max<B>>::Output as Same<U3>>::Output;
3361
3362 assert_eq!(<U3MaxU1 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
3363 }
3364 #[test]
3365 #[allow(non_snake_case)]
3366 fn test_3_Gcd_1() {
3367 type A = UInt<UInt<UTerm, B1>, B1>;
3368 type B = UInt<UTerm, B1>;
3369 type U1 = UInt<UTerm, B1>;
3370
3371 #[allow(non_camel_case_types)]
3372 type U3GcdU1 = <<A as Gcd<B>>::Output as Same<U1>>::Output;
3373
3374 assert_eq!(<U3GcdU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
3375 }
3376 #[test]
3377 #[allow(non_snake_case)]
3378 fn test_3_Sub_1() {
3379 type A = UInt<UInt<UTerm, B1>, B1>;
3380 type B = UInt<UTerm, B1>;
3381 type U2 = UInt<UInt<UTerm, B1>, B0>;
3382
3383 #[allow(non_camel_case_types)]
3384 type U3SubU1 = <<A as Sub<B>>::Output as Same<U2>>::Output;
3385
3386 assert_eq!(<U3SubU1 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
3387 }
3388 #[test]
3389 #[allow(non_snake_case)]
3390 fn test_3_Div_1() {
3391 type A = UInt<UInt<UTerm, B1>, B1>;
3392 type B = UInt<UTerm, B1>;
3393 type U3 = UInt<UInt<UTerm, B1>, B1>;
3394
3395 #[allow(non_camel_case_types)]
3396 type U3DivU1 = <<A as Div<B>>::Output as Same<U3>>::Output;
3397
3398 assert_eq!(<U3DivU1 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
3399 }
3400 #[test]
3401 #[allow(non_snake_case)]
3402 fn test_3_Rem_1() {
3403 type A = UInt<UInt<UTerm, B1>, B1>;
3404 type B = UInt<UTerm, B1>;
3405 type U0 = UTerm;
3406
3407 #[allow(non_camel_case_types)]
3408 type U3RemU1 = <<A as Rem<B>>::Output as Same<U0>>::Output;
3409
3410 assert_eq!(<U3RemU1 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
3411 }
3412 #[test]
3413 #[allow(non_snake_case)]
3414 fn test_3_PartialDiv_1() {
3415 type A = UInt<UInt<UTerm, B1>, B1>;
3416 type B = UInt<UTerm, B1>;
3417 type U3 = UInt<UInt<UTerm, B1>, B1>;
3418
3419 #[allow(non_camel_case_types)]
3420 type U3PartialDivU1 = <<A as PartialDiv<B>>::Output as Same<U3>>::Output;
3421
3422 assert_eq!(<U3PartialDivU1 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
3423 }
3424 #[test]
3425 #[allow(non_snake_case)]
3426 fn test_3_Cmp_1() {
3427 type A = UInt<UInt<UTerm, B1>, B1>;
3428 type B = UInt<UTerm, B1>;
3429
3430 #[allow(non_camel_case_types)]
3431 type U3CmpU1 = <A as Cmp<B>>::Output;
3432 assert_eq!(<U3CmpU1 as Ord>::to_ordering(), Ordering::Greater);
3433 }
3434 #[test]
3435 #[allow(non_snake_case)]
3436 fn test_3_BitAnd_2() {
3437 type A = UInt<UInt<UTerm, B1>, B1>;
3438 type B = UInt<UInt<UTerm, B1>, B0>;
3439 type U2 = UInt<UInt<UTerm, B1>, B0>;
3440
3441 #[allow(non_camel_case_types)]
3442 type U3BitAndU2 = <<A as BitAnd<B>>::Output as Same<U2>>::Output;
3443
3444 assert_eq!(<U3BitAndU2 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
3445 }
3446 #[test]
3447 #[allow(non_snake_case)]
3448 fn test_3_BitOr_2() {
3449 type A = UInt<UInt<UTerm, B1>, B1>;
3450 type B = UInt<UInt<UTerm, B1>, B0>;
3451 type U3 = UInt<UInt<UTerm, B1>, B1>;
3452
3453 #[allow(non_camel_case_types)]
3454 type U3BitOrU2 = <<A as BitOr<B>>::Output as Same<U3>>::Output;
3455
3456 assert_eq!(<U3BitOrU2 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
3457 }
3458 #[test]
3459 #[allow(non_snake_case)]
3460 fn test_3_BitXor_2() {
3461 type A = UInt<UInt<UTerm, B1>, B1>;
3462 type B = UInt<UInt<UTerm, B1>, B0>;
3463 type U1 = UInt<UTerm, B1>;
3464
3465 #[allow(non_camel_case_types)]
3466 type U3BitXorU2 = <<A as BitXor<B>>::Output as Same<U1>>::Output;
3467
3468 assert_eq!(<U3BitXorU2 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
3469 }
3470 #[test]
3471 #[allow(non_snake_case)]
3472 fn test_3_Shl_2() {
3473 type A = UInt<UInt<UTerm, B1>, B1>;
3474 type B = UInt<UInt<UTerm, B1>, B0>;
3475 type U12 = UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>;
3476
3477 #[allow(non_camel_case_types)]
3478 type U3ShlU2 = <<A as Shl<B>>::Output as Same<U12>>::Output;
3479
3480 assert_eq!(<U3ShlU2 as Unsigned>::to_u64(), <U12 as Unsigned>::to_u64());
3481 }
3482 #[test]
3483 #[allow(non_snake_case)]
3484 fn test_3_Shr_2() {
3485 type A = UInt<UInt<UTerm, B1>, B1>;
3486 type B = UInt<UInt<UTerm, B1>, B0>;
3487 type U0 = UTerm;
3488
3489 #[allow(non_camel_case_types)]
3490 type U3ShrU2 = <<A as Shr<B>>::Output as Same<U0>>::Output;
3491
3492 assert_eq!(<U3ShrU2 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
3493 }
3494 #[test]
3495 #[allow(non_snake_case)]
3496 fn test_3_Add_2() {
3497 type A = UInt<UInt<UTerm, B1>, B1>;
3498 type B = UInt<UInt<UTerm, B1>, B0>;
3499 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
3500
3501 #[allow(non_camel_case_types)]
3502 type U3AddU2 = <<A as Add<B>>::Output as Same<U5>>::Output;
3503
3504 assert_eq!(<U3AddU2 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
3505 }
3506 #[test]
3507 #[allow(non_snake_case)]
3508 fn test_3_Mul_2() {
3509 type A = UInt<UInt<UTerm, B1>, B1>;
3510 type B = UInt<UInt<UTerm, B1>, B0>;
3511 type U6 = UInt<UInt<UInt<UTerm, B1>, B1>, B0>;
3512
3513 #[allow(non_camel_case_types)]
3514 type U3MulU2 = <<A as Mul<B>>::Output as Same<U6>>::Output;
3515
3516 assert_eq!(<U3MulU2 as Unsigned>::to_u64(), <U6 as Unsigned>::to_u64());
3517 }
3518 #[test]
3519 #[allow(non_snake_case)]
3520 fn test_3_Pow_2() {
3521 type A = UInt<UInt<UTerm, B1>, B1>;
3522 type B = UInt<UInt<UTerm, B1>, B0>;
3523 type U9 = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>;
3524
3525 #[allow(non_camel_case_types)]
3526 type U3PowU2 = <<A as Pow<B>>::Output as Same<U9>>::Output;
3527
3528 assert_eq!(<U3PowU2 as Unsigned>::to_u64(), <U9 as Unsigned>::to_u64());
3529 }
3530 #[test]
3531 #[allow(non_snake_case)]
3532 fn test_3_Min_2() {
3533 type A = UInt<UInt<UTerm, B1>, B1>;
3534 type B = UInt<UInt<UTerm, B1>, B0>;
3535 type U2 = UInt<UInt<UTerm, B1>, B0>;
3536
3537 #[allow(non_camel_case_types)]
3538 type U3MinU2 = <<A as Min<B>>::Output as Same<U2>>::Output;
3539
3540 assert_eq!(<U3MinU2 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
3541 }
3542 #[test]
3543 #[allow(non_snake_case)]
3544 fn test_3_Max_2() {
3545 type A = UInt<UInt<UTerm, B1>, B1>;
3546 type B = UInt<UInt<UTerm, B1>, B0>;
3547 type U3 = UInt<UInt<UTerm, B1>, B1>;
3548
3549 #[allow(non_camel_case_types)]
3550 type U3MaxU2 = <<A as Max<B>>::Output as Same<U3>>::Output;
3551
3552 assert_eq!(<U3MaxU2 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
3553 }
3554 #[test]
3555 #[allow(non_snake_case)]
3556 fn test_3_Gcd_2() {
3557 type A = UInt<UInt<UTerm, B1>, B1>;
3558 type B = UInt<UInt<UTerm, B1>, B0>;
3559 type U1 = UInt<UTerm, B1>;
3560
3561 #[allow(non_camel_case_types)]
3562 type U3GcdU2 = <<A as Gcd<B>>::Output as Same<U1>>::Output;
3563
3564 assert_eq!(<U3GcdU2 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
3565 }
3566 #[test]
3567 #[allow(non_snake_case)]
3568 fn test_3_Sub_2() {
3569 type A = UInt<UInt<UTerm, B1>, B1>;
3570 type B = UInt<UInt<UTerm, B1>, B0>;
3571 type U1 = UInt<UTerm, B1>;
3572
3573 #[allow(non_camel_case_types)]
3574 type U3SubU2 = <<A as Sub<B>>::Output as Same<U1>>::Output;
3575
3576 assert_eq!(<U3SubU2 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
3577 }
3578 #[test]
3579 #[allow(non_snake_case)]
3580 fn test_3_Div_2() {
3581 type A = UInt<UInt<UTerm, B1>, B1>;
3582 type B = UInt<UInt<UTerm, B1>, B0>;
3583 type U1 = UInt<UTerm, B1>;
3584
3585 #[allow(non_camel_case_types)]
3586 type U3DivU2 = <<A as Div<B>>::Output as Same<U1>>::Output;
3587
3588 assert_eq!(<U3DivU2 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
3589 }
3590 #[test]
3591 #[allow(non_snake_case)]
3592 fn test_3_Rem_2() {
3593 type A = UInt<UInt<UTerm, B1>, B1>;
3594 type B = UInt<UInt<UTerm, B1>, B0>;
3595 type U1 = UInt<UTerm, B1>;
3596
3597 #[allow(non_camel_case_types)]
3598 type U3RemU2 = <<A as Rem<B>>::Output as Same<U1>>::Output;
3599
3600 assert_eq!(<U3RemU2 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
3601 }
3602 #[test]
3603 #[allow(non_snake_case)]
3604 fn test_3_Cmp_2() {
3605 type A = UInt<UInt<UTerm, B1>, B1>;
3606 type B = UInt<UInt<UTerm, B1>, B0>;
3607
3608 #[allow(non_camel_case_types)]
3609 type U3CmpU2 = <A as Cmp<B>>::Output;
3610 assert_eq!(<U3CmpU2 as Ord>::to_ordering(), Ordering::Greater);
3611 }
3612 #[test]
3613 #[allow(non_snake_case)]
3614 fn test_3_BitAnd_3() {
3615 type A = UInt<UInt<UTerm, B1>, B1>;
3616 type B = UInt<UInt<UTerm, B1>, B1>;
3617 type U3 = UInt<UInt<UTerm, B1>, B1>;
3618
3619 #[allow(non_camel_case_types)]
3620 type U3BitAndU3 = <<A as BitAnd<B>>::Output as Same<U3>>::Output;
3621
3622 assert_eq!(<U3BitAndU3 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
3623 }
3624 #[test]
3625 #[allow(non_snake_case)]
3626 fn test_3_BitOr_3() {
3627 type A = UInt<UInt<UTerm, B1>, B1>;
3628 type B = UInt<UInt<UTerm, B1>, B1>;
3629 type U3 = UInt<UInt<UTerm, B1>, B1>;
3630
3631 #[allow(non_camel_case_types)]
3632 type U3BitOrU3 = <<A as BitOr<B>>::Output as Same<U3>>::Output;
3633
3634 assert_eq!(<U3BitOrU3 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
3635 }
3636 #[test]
3637 #[allow(non_snake_case)]
3638 fn test_3_BitXor_3() {
3639 type A = UInt<UInt<UTerm, B1>, B1>;
3640 type B = UInt<UInt<UTerm, B1>, B1>;
3641 type U0 = UTerm;
3642
3643 #[allow(non_camel_case_types)]
3644 type U3BitXorU3 = <<A as BitXor<B>>::Output as Same<U0>>::Output;
3645
3646 assert_eq!(<U3BitXorU3 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
3647 }
3648 #[test]
3649 #[allow(non_snake_case)]
3650 fn test_3_Shl_3() {
3651 type A = UInt<UInt<UTerm, B1>, B1>;
3652 type B = UInt<UInt<UTerm, B1>, B1>;
3653 type U24 = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>;
3654
3655 #[allow(non_camel_case_types)]
3656 type U3ShlU3 = <<A as Shl<B>>::Output as Same<U24>>::Output;
3657
3658 assert_eq!(<U3ShlU3 as Unsigned>::to_u64(), <U24 as Unsigned>::to_u64());
3659 }
3660 #[test]
3661 #[allow(non_snake_case)]
3662 fn test_3_Shr_3() {
3663 type A = UInt<UInt<UTerm, B1>, B1>;
3664 type B = UInt<UInt<UTerm, B1>, B1>;
3665 type U0 = UTerm;
3666
3667 #[allow(non_camel_case_types)]
3668 type U3ShrU3 = <<A as Shr<B>>::Output as Same<U0>>::Output;
3669
3670 assert_eq!(<U3ShrU3 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
3671 }
3672 #[test]
3673 #[allow(non_snake_case)]
3674 fn test_3_Add_3() {
3675 type A = UInt<UInt<UTerm, B1>, B1>;
3676 type B = UInt<UInt<UTerm, B1>, B1>;
3677 type U6 = UInt<UInt<UInt<UTerm, B1>, B1>, B0>;
3678
3679 #[allow(non_camel_case_types)]
3680 type U3AddU3 = <<A as Add<B>>::Output as Same<U6>>::Output;
3681
3682 assert_eq!(<U3AddU3 as Unsigned>::to_u64(), <U6 as Unsigned>::to_u64());
3683 }
3684 #[test]
3685 #[allow(non_snake_case)]
3686 fn test_3_Mul_3() {
3687 type A = UInt<UInt<UTerm, B1>, B1>;
3688 type B = UInt<UInt<UTerm, B1>, B1>;
3689 type U9 = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>;
3690
3691 #[allow(non_camel_case_types)]
3692 type U3MulU3 = <<A as Mul<B>>::Output as Same<U9>>::Output;
3693
3694 assert_eq!(<U3MulU3 as Unsigned>::to_u64(), <U9 as Unsigned>::to_u64());
3695 }
3696 #[test]
3697 #[allow(non_snake_case)]
3698 fn test_3_Pow_3() {
3699 type A = UInt<UInt<UTerm, B1>, B1>;
3700 type B = UInt<UInt<UTerm, B1>, B1>;
3701 type U27 = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>;
3702
3703 #[allow(non_camel_case_types)]
3704 type U3PowU3 = <<A as Pow<B>>::Output as Same<U27>>::Output;
3705
3706 assert_eq!(<U3PowU3 as Unsigned>::to_u64(), <U27 as Unsigned>::to_u64());
3707 }
3708 #[test]
3709 #[allow(non_snake_case)]
3710 fn test_3_Min_3() {
3711 type A = UInt<UInt<UTerm, B1>, B1>;
3712 type B = UInt<UInt<UTerm, B1>, B1>;
3713 type U3 = UInt<UInt<UTerm, B1>, B1>;
3714
3715 #[allow(non_camel_case_types)]
3716 type U3MinU3 = <<A as Min<B>>::Output as Same<U3>>::Output;
3717
3718 assert_eq!(<U3MinU3 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
3719 }
3720 #[test]
3721 #[allow(non_snake_case)]
3722 fn test_3_Max_3() {
3723 type A = UInt<UInt<UTerm, B1>, B1>;
3724 type B = UInt<UInt<UTerm, B1>, B1>;
3725 type U3 = UInt<UInt<UTerm, B1>, B1>;
3726
3727 #[allow(non_camel_case_types)]
3728 type U3MaxU3 = <<A as Max<B>>::Output as Same<U3>>::Output;
3729
3730 assert_eq!(<U3MaxU3 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
3731 }
3732 #[test]
3733 #[allow(non_snake_case)]
3734 fn test_3_Gcd_3() {
3735 type A = UInt<UInt<UTerm, B1>, B1>;
3736 type B = UInt<UInt<UTerm, B1>, B1>;
3737 type U3 = UInt<UInt<UTerm, B1>, B1>;
3738
3739 #[allow(non_camel_case_types)]
3740 type U3GcdU3 = <<A as Gcd<B>>::Output as Same<U3>>::Output;
3741
3742 assert_eq!(<U3GcdU3 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
3743 }
3744 #[test]
3745 #[allow(non_snake_case)]
3746 fn test_3_Sub_3() {
3747 type A = UInt<UInt<UTerm, B1>, B1>;
3748 type B = UInt<UInt<UTerm, B1>, B1>;
3749 type U0 = UTerm;
3750
3751 #[allow(non_camel_case_types)]
3752 type U3SubU3 = <<A as Sub<B>>::Output as Same<U0>>::Output;
3753
3754 assert_eq!(<U3SubU3 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
3755 }
3756 #[test]
3757 #[allow(non_snake_case)]
3758 fn test_3_Div_3() {
3759 type A = UInt<UInt<UTerm, B1>, B1>;
3760 type B = UInt<UInt<UTerm, B1>, B1>;
3761 type U1 = UInt<UTerm, B1>;
3762
3763 #[allow(non_camel_case_types)]
3764 type U3DivU3 = <<A as Div<B>>::Output as Same<U1>>::Output;
3765
3766 assert_eq!(<U3DivU3 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
3767 }
3768 #[test]
3769 #[allow(non_snake_case)]
3770 fn test_3_Rem_3() {
3771 type A = UInt<UInt<UTerm, B1>, B1>;
3772 type B = UInt<UInt<UTerm, B1>, B1>;
3773 type U0 = UTerm;
3774
3775 #[allow(non_camel_case_types)]
3776 type U3RemU3 = <<A as Rem<B>>::Output as Same<U0>>::Output;
3777
3778 assert_eq!(<U3RemU3 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
3779 }
3780 #[test]
3781 #[allow(non_snake_case)]
3782 fn test_3_PartialDiv_3() {
3783 type A = UInt<UInt<UTerm, B1>, B1>;
3784 type B = UInt<UInt<UTerm, B1>, B1>;
3785 type U1 = UInt<UTerm, B1>;
3786
3787 #[allow(non_camel_case_types)]
3788 type U3PartialDivU3 = <<A as PartialDiv<B>>::Output as Same<U1>>::Output;
3789
3790 assert_eq!(<U3PartialDivU3 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
3791 }
3792 #[test]
3793 #[allow(non_snake_case)]
3794 fn test_3_Cmp_3() {
3795 type A = UInt<UInt<UTerm, B1>, B1>;
3796 type B = UInt<UInt<UTerm, B1>, B1>;
3797
3798 #[allow(non_camel_case_types)]
3799 type U3CmpU3 = <A as Cmp<B>>::Output;
3800 assert_eq!(<U3CmpU3 as Ord>::to_ordering(), Ordering::Equal);
3801 }
3802 #[test]
3803 #[allow(non_snake_case)]
3804 fn test_3_BitAnd_4() {
3805 type A = UInt<UInt<UTerm, B1>, B1>;
3806 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
3807 type U0 = UTerm;
3808
3809 #[allow(non_camel_case_types)]
3810 type U3BitAndU4 = <<A as BitAnd<B>>::Output as Same<U0>>::Output;
3811
3812 assert_eq!(<U3BitAndU4 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
3813 }
3814 #[test]
3815 #[allow(non_snake_case)]
3816 fn test_3_BitOr_4() {
3817 type A = UInt<UInt<UTerm, B1>, B1>;
3818 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
3819 type U7 = UInt<UInt<UInt<UTerm, B1>, B1>, B1>;
3820
3821 #[allow(non_camel_case_types)]
3822 type U3BitOrU4 = <<A as BitOr<B>>::Output as Same<U7>>::Output;
3823
3824 assert_eq!(<U3BitOrU4 as Unsigned>::to_u64(), <U7 as Unsigned>::to_u64());
3825 }
3826 #[test]
3827 #[allow(non_snake_case)]
3828 fn test_3_BitXor_4() {
3829 type A = UInt<UInt<UTerm, B1>, B1>;
3830 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
3831 type U7 = UInt<UInt<UInt<UTerm, B1>, B1>, B1>;
3832
3833 #[allow(non_camel_case_types)]
3834 type U3BitXorU4 = <<A as BitXor<B>>::Output as Same<U7>>::Output;
3835
3836 assert_eq!(<U3BitXorU4 as Unsigned>::to_u64(), <U7 as Unsigned>::to_u64());
3837 }
3838 #[test]
3839 #[allow(non_snake_case)]
3840 fn test_3_Shl_4() {
3841 type A = UInt<UInt<UTerm, B1>, B1>;
3842 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
3843 type U48 = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>;
3844
3845 #[allow(non_camel_case_types)]
3846 type U3ShlU4 = <<A as Shl<B>>::Output as Same<U48>>::Output;
3847
3848 assert_eq!(<U3ShlU4 as Unsigned>::to_u64(), <U48 as Unsigned>::to_u64());
3849 }
3850 #[test]
3851 #[allow(non_snake_case)]
3852 fn test_3_Shr_4() {
3853 type A = UInt<UInt<UTerm, B1>, B1>;
3854 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
3855 type U0 = UTerm;
3856
3857 #[allow(non_camel_case_types)]
3858 type U3ShrU4 = <<A as Shr<B>>::Output as Same<U0>>::Output;
3859
3860 assert_eq!(<U3ShrU4 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
3861 }
3862 #[test]
3863 #[allow(non_snake_case)]
3864 fn test_3_Add_4() {
3865 type A = UInt<UInt<UTerm, B1>, B1>;
3866 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
3867 type U7 = UInt<UInt<UInt<UTerm, B1>, B1>, B1>;
3868
3869 #[allow(non_camel_case_types)]
3870 type U3AddU4 = <<A as Add<B>>::Output as Same<U7>>::Output;
3871
3872 assert_eq!(<U3AddU4 as Unsigned>::to_u64(), <U7 as Unsigned>::to_u64());
3873 }
3874 #[test]
3875 #[allow(non_snake_case)]
3876 fn test_3_Mul_4() {
3877 type A = UInt<UInt<UTerm, B1>, B1>;
3878 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
3879 type U12 = UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>;
3880
3881 #[allow(non_camel_case_types)]
3882 type U3MulU4 = <<A as Mul<B>>::Output as Same<U12>>::Output;
3883
3884 assert_eq!(<U3MulU4 as Unsigned>::to_u64(), <U12 as Unsigned>::to_u64());
3885 }
3886 #[test]
3887 #[allow(non_snake_case)]
3888 fn test_3_Pow_4() {
3889 type A = UInt<UInt<UTerm, B1>, B1>;
3890 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
3891 type U81 = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>, B1>;
3892
3893 #[allow(non_camel_case_types)]
3894 type U3PowU4 = <<A as Pow<B>>::Output as Same<U81>>::Output;
3895
3896 assert_eq!(<U3PowU4 as Unsigned>::to_u64(), <U81 as Unsigned>::to_u64());
3897 }
3898 #[test]
3899 #[allow(non_snake_case)]
3900 fn test_3_Min_4() {
3901 type A = UInt<UInt<UTerm, B1>, B1>;
3902 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
3903 type U3 = UInt<UInt<UTerm, B1>, B1>;
3904
3905 #[allow(non_camel_case_types)]
3906 type U3MinU4 = <<A as Min<B>>::Output as Same<U3>>::Output;
3907
3908 assert_eq!(<U3MinU4 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
3909 }
3910 #[test]
3911 #[allow(non_snake_case)]
3912 fn test_3_Max_4() {
3913 type A = UInt<UInt<UTerm, B1>, B1>;
3914 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
3915 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
3916
3917 #[allow(non_camel_case_types)]
3918 type U3MaxU4 = <<A as Max<B>>::Output as Same<U4>>::Output;
3919
3920 assert_eq!(<U3MaxU4 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
3921 }
3922 #[test]
3923 #[allow(non_snake_case)]
3924 fn test_3_Gcd_4() {
3925 type A = UInt<UInt<UTerm, B1>, B1>;
3926 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
3927 type U1 = UInt<UTerm, B1>;
3928
3929 #[allow(non_camel_case_types)]
3930 type U3GcdU4 = <<A as Gcd<B>>::Output as Same<U1>>::Output;
3931
3932 assert_eq!(<U3GcdU4 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
3933 }
3934 #[test]
3935 #[allow(non_snake_case)]
3936 fn test_3_Div_4() {
3937 type A = UInt<UInt<UTerm, B1>, B1>;
3938 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
3939 type U0 = UTerm;
3940
3941 #[allow(non_camel_case_types)]
3942 type U3DivU4 = <<A as Div<B>>::Output as Same<U0>>::Output;
3943
3944 assert_eq!(<U3DivU4 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
3945 }
3946 #[test]
3947 #[allow(non_snake_case)]
3948 fn test_3_Rem_4() {
3949 type A = UInt<UInt<UTerm, B1>, B1>;
3950 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
3951 type U3 = UInt<UInt<UTerm, B1>, B1>;
3952
3953 #[allow(non_camel_case_types)]
3954 type U3RemU4 = <<A as Rem<B>>::Output as Same<U3>>::Output;
3955
3956 assert_eq!(<U3RemU4 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
3957 }
3958 #[test]
3959 #[allow(non_snake_case)]
3960 fn test_3_Cmp_4() {
3961 type A = UInt<UInt<UTerm, B1>, B1>;
3962 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
3963
3964 #[allow(non_camel_case_types)]
3965 type U3CmpU4 = <A as Cmp<B>>::Output;
3966 assert_eq!(<U3CmpU4 as Ord>::to_ordering(), Ordering::Less);
3967 }
3968 #[test]
3969 #[allow(non_snake_case)]
3970 fn test_3_BitAnd_5() {
3971 type A = UInt<UInt<UTerm, B1>, B1>;
3972 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
3973 type U1 = UInt<UTerm, B1>;
3974
3975 #[allow(non_camel_case_types)]
3976 type U3BitAndU5 = <<A as BitAnd<B>>::Output as Same<U1>>::Output;
3977
3978 assert_eq!(<U3BitAndU5 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
3979 }
3980 #[test]
3981 #[allow(non_snake_case)]
3982 fn test_3_BitOr_5() {
3983 type A = UInt<UInt<UTerm, B1>, B1>;
3984 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
3985 type U7 = UInt<UInt<UInt<UTerm, B1>, B1>, B1>;
3986
3987 #[allow(non_camel_case_types)]
3988 type U3BitOrU5 = <<A as BitOr<B>>::Output as Same<U7>>::Output;
3989
3990 assert_eq!(<U3BitOrU5 as Unsigned>::to_u64(), <U7 as Unsigned>::to_u64());
3991 }
3992 #[test]
3993 #[allow(non_snake_case)]
3994 fn test_3_BitXor_5() {
3995 type A = UInt<UInt<UTerm, B1>, B1>;
3996 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
3997 type U6 = UInt<UInt<UInt<UTerm, B1>, B1>, B0>;
3998
3999 #[allow(non_camel_case_types)]
4000 type U3BitXorU5 = <<A as BitXor<B>>::Output as Same<U6>>::Output;
4001
4002 assert_eq!(<U3BitXorU5 as Unsigned>::to_u64(), <U6 as Unsigned>::to_u64());
4003 }
4004 #[test]
4005 #[allow(non_snake_case)]
4006 fn test_3_Shl_5() {
4007 type A = UInt<UInt<UTerm, B1>, B1>;
4008 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
4009 type U96 = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>, B0>;
4010
4011 #[allow(non_camel_case_types)]
4012 type U3ShlU5 = <<A as Shl<B>>::Output as Same<U96>>::Output;
4013
4014 assert_eq!(<U3ShlU5 as Unsigned>::to_u64(), <U96 as Unsigned>::to_u64());
4015 }
4016 #[test]
4017 #[allow(non_snake_case)]
4018 fn test_3_Shr_5() {
4019 type A = UInt<UInt<UTerm, B1>, B1>;
4020 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
4021 type U0 = UTerm;
4022
4023 #[allow(non_camel_case_types)]
4024 type U3ShrU5 = <<A as Shr<B>>::Output as Same<U0>>::Output;
4025
4026 assert_eq!(<U3ShrU5 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
4027 }
4028 #[test]
4029 #[allow(non_snake_case)]
4030 fn test_3_Add_5() {
4031 type A = UInt<UInt<UTerm, B1>, B1>;
4032 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
4033 type U8 = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>;
4034
4035 #[allow(non_camel_case_types)]
4036 type U3AddU5 = <<A as Add<B>>::Output as Same<U8>>::Output;
4037
4038 assert_eq!(<U3AddU5 as Unsigned>::to_u64(), <U8 as Unsigned>::to_u64());
4039 }
4040 #[test]
4041 #[allow(non_snake_case)]
4042 fn test_3_Mul_5() {
4043 type A = UInt<UInt<UTerm, B1>, B1>;
4044 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
4045 type U15 = UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>;
4046
4047 #[allow(non_camel_case_types)]
4048 type U3MulU5 = <<A as Mul<B>>::Output as Same<U15>>::Output;
4049
4050 assert_eq!(<U3MulU5 as Unsigned>::to_u64(), <U15 as Unsigned>::to_u64());
4051 }
4052 #[test]
4053 #[allow(non_snake_case)]
4054 fn test_3_Pow_5() {
4055 type A = UInt<UInt<UTerm, B1>, B1>;
4056 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
4057 type U243 = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B0>, B1>, B1>;
4058
4059 #[allow(non_camel_case_types)]
4060 type U3PowU5 = <<A as Pow<B>>::Output as Same<U243>>::Output;
4061
4062 assert_eq!(<U3PowU5 as Unsigned>::to_u64(), <U243 as Unsigned>::to_u64());
4063 }
4064 #[test]
4065 #[allow(non_snake_case)]
4066 fn test_3_Min_5() {
4067 type A = UInt<UInt<UTerm, B1>, B1>;
4068 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
4069 type U3 = UInt<UInt<UTerm, B1>, B1>;
4070
4071 #[allow(non_camel_case_types)]
4072 type U3MinU5 = <<A as Min<B>>::Output as Same<U3>>::Output;
4073
4074 assert_eq!(<U3MinU5 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
4075 }
4076 #[test]
4077 #[allow(non_snake_case)]
4078 fn test_3_Max_5() {
4079 type A = UInt<UInt<UTerm, B1>, B1>;
4080 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
4081 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
4082
4083 #[allow(non_camel_case_types)]
4084 type U3MaxU5 = <<A as Max<B>>::Output as Same<U5>>::Output;
4085
4086 assert_eq!(<U3MaxU5 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
4087 }
4088 #[test]
4089 #[allow(non_snake_case)]
4090 fn test_3_Gcd_5() {
4091 type A = UInt<UInt<UTerm, B1>, B1>;
4092 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
4093 type U1 = UInt<UTerm, B1>;
4094
4095 #[allow(non_camel_case_types)]
4096 type U3GcdU5 = <<A as Gcd<B>>::Output as Same<U1>>::Output;
4097
4098 assert_eq!(<U3GcdU5 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
4099 }
4100 #[test]
4101 #[allow(non_snake_case)]
4102 fn test_3_Div_5() {
4103 type A = UInt<UInt<UTerm, B1>, B1>;
4104 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
4105 type U0 = UTerm;
4106
4107 #[allow(non_camel_case_types)]
4108 type U3DivU5 = <<A as Div<B>>::Output as Same<U0>>::Output;
4109
4110 assert_eq!(<U3DivU5 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
4111 }
4112 #[test]
4113 #[allow(non_snake_case)]
4114 fn test_3_Rem_5() {
4115 type A = UInt<UInt<UTerm, B1>, B1>;
4116 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
4117 type U3 = UInt<UInt<UTerm, B1>, B1>;
4118
4119 #[allow(non_camel_case_types)]
4120 type U3RemU5 = <<A as Rem<B>>::Output as Same<U3>>::Output;
4121
4122 assert_eq!(<U3RemU5 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
4123 }
4124 #[test]
4125 #[allow(non_snake_case)]
4126 fn test_3_Cmp_5() {
4127 type A = UInt<UInt<UTerm, B1>, B1>;
4128 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
4129
4130 #[allow(non_camel_case_types)]
4131 type U3CmpU5 = <A as Cmp<B>>::Output;
4132 assert_eq!(<U3CmpU5 as Ord>::to_ordering(), Ordering::Less);
4133 }
4134 #[test]
4135 #[allow(non_snake_case)]
4136 fn test_4_BitAnd_0() {
4137 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4138 type B = UTerm;
4139 type U0 = UTerm;
4140
4141 #[allow(non_camel_case_types)]
4142 type U4BitAndU0 = <<A as BitAnd<B>>::Output as Same<U0>>::Output;
4143
4144 assert_eq!(<U4BitAndU0 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
4145 }
4146 #[test]
4147 #[allow(non_snake_case)]
4148 fn test_4_BitOr_0() {
4149 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4150 type B = UTerm;
4151 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4152
4153 #[allow(non_camel_case_types)]
4154 type U4BitOrU0 = <<A as BitOr<B>>::Output as Same<U4>>::Output;
4155
4156 assert_eq!(<U4BitOrU0 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
4157 }
4158 #[test]
4159 #[allow(non_snake_case)]
4160 fn test_4_BitXor_0() {
4161 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4162 type B = UTerm;
4163 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4164
4165 #[allow(non_camel_case_types)]
4166 type U4BitXorU0 = <<A as BitXor<B>>::Output as Same<U4>>::Output;
4167
4168 assert_eq!(<U4BitXorU0 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
4169 }
4170 #[test]
4171 #[allow(non_snake_case)]
4172 fn test_4_Shl_0() {
4173 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4174 type B = UTerm;
4175 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4176
4177 #[allow(non_camel_case_types)]
4178 type U4ShlU0 = <<A as Shl<B>>::Output as Same<U4>>::Output;
4179
4180 assert_eq!(<U4ShlU0 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
4181 }
4182 #[test]
4183 #[allow(non_snake_case)]
4184 fn test_4_Shr_0() {
4185 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4186 type B = UTerm;
4187 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4188
4189 #[allow(non_camel_case_types)]
4190 type U4ShrU0 = <<A as Shr<B>>::Output as Same<U4>>::Output;
4191
4192 assert_eq!(<U4ShrU0 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
4193 }
4194 #[test]
4195 #[allow(non_snake_case)]
4196 fn test_4_Add_0() {
4197 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4198 type B = UTerm;
4199 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4200
4201 #[allow(non_camel_case_types)]
4202 type U4AddU0 = <<A as Add<B>>::Output as Same<U4>>::Output;
4203
4204 assert_eq!(<U4AddU0 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
4205 }
4206 #[test]
4207 #[allow(non_snake_case)]
4208 fn test_4_Mul_0() {
4209 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4210 type B = UTerm;
4211 type U0 = UTerm;
4212
4213 #[allow(non_camel_case_types)]
4214 type U4MulU0 = <<A as Mul<B>>::Output as Same<U0>>::Output;
4215
4216 assert_eq!(<U4MulU0 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
4217 }
4218 #[test]
4219 #[allow(non_snake_case)]
4220 fn test_4_Pow_0() {
4221 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4222 type B = UTerm;
4223 type U1 = UInt<UTerm, B1>;
4224
4225 #[allow(non_camel_case_types)]
4226 type U4PowU0 = <<A as Pow<B>>::Output as Same<U1>>::Output;
4227
4228 assert_eq!(<U4PowU0 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
4229 }
4230 #[test]
4231 #[allow(non_snake_case)]
4232 fn test_4_Min_0() {
4233 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4234 type B = UTerm;
4235 type U0 = UTerm;
4236
4237 #[allow(non_camel_case_types)]
4238 type U4MinU0 = <<A as Min<B>>::Output as Same<U0>>::Output;
4239
4240 assert_eq!(<U4MinU0 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
4241 }
4242 #[test]
4243 #[allow(non_snake_case)]
4244 fn test_4_Max_0() {
4245 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4246 type B = UTerm;
4247 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4248
4249 #[allow(non_camel_case_types)]
4250 type U4MaxU0 = <<A as Max<B>>::Output as Same<U4>>::Output;
4251
4252 assert_eq!(<U4MaxU0 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
4253 }
4254 #[test]
4255 #[allow(non_snake_case)]
4256 fn test_4_Gcd_0() {
4257 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4258 type B = UTerm;
4259 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4260
4261 #[allow(non_camel_case_types)]
4262 type U4GcdU0 = <<A as Gcd<B>>::Output as Same<U4>>::Output;
4263
4264 assert_eq!(<U4GcdU0 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
4265 }
4266 #[test]
4267 #[allow(non_snake_case)]
4268 fn test_4_Sub_0() {
4269 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4270 type B = UTerm;
4271 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4272
4273 #[allow(non_camel_case_types)]
4274 type U4SubU0 = <<A as Sub<B>>::Output as Same<U4>>::Output;
4275
4276 assert_eq!(<U4SubU0 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
4277 }
4278 #[test]
4279 #[allow(non_snake_case)]
4280 fn test_4_Cmp_0() {
4281 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4282 type B = UTerm;
4283
4284 #[allow(non_camel_case_types)]
4285 type U4CmpU0 = <A as Cmp<B>>::Output;
4286 assert_eq!(<U4CmpU0 as Ord>::to_ordering(), Ordering::Greater);
4287 }
4288 #[test]
4289 #[allow(non_snake_case)]
4290 fn test_4_BitAnd_1() {
4291 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4292 type B = UInt<UTerm, B1>;
4293 type U0 = UTerm;
4294
4295 #[allow(non_camel_case_types)]
4296 type U4BitAndU1 = <<A as BitAnd<B>>::Output as Same<U0>>::Output;
4297
4298 assert_eq!(<U4BitAndU1 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
4299 }
4300 #[test]
4301 #[allow(non_snake_case)]
4302 fn test_4_BitOr_1() {
4303 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4304 type B = UInt<UTerm, B1>;
4305 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
4306
4307 #[allow(non_camel_case_types)]
4308 type U4BitOrU1 = <<A as BitOr<B>>::Output as Same<U5>>::Output;
4309
4310 assert_eq!(<U4BitOrU1 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
4311 }
4312 #[test]
4313 #[allow(non_snake_case)]
4314 fn test_4_BitXor_1() {
4315 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4316 type B = UInt<UTerm, B1>;
4317 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
4318
4319 #[allow(non_camel_case_types)]
4320 type U4BitXorU1 = <<A as BitXor<B>>::Output as Same<U5>>::Output;
4321
4322 assert_eq!(<U4BitXorU1 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
4323 }
4324 #[test]
4325 #[allow(non_snake_case)]
4326 fn test_4_Shl_1() {
4327 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4328 type B = UInt<UTerm, B1>;
4329 type U8 = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>;
4330
4331 #[allow(non_camel_case_types)]
4332 type U4ShlU1 = <<A as Shl<B>>::Output as Same<U8>>::Output;
4333
4334 assert_eq!(<U4ShlU1 as Unsigned>::to_u64(), <U8 as Unsigned>::to_u64());
4335 }
4336 #[test]
4337 #[allow(non_snake_case)]
4338 fn test_4_Shr_1() {
4339 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4340 type B = UInt<UTerm, B1>;
4341 type U2 = UInt<UInt<UTerm, B1>, B0>;
4342
4343 #[allow(non_camel_case_types)]
4344 type U4ShrU1 = <<A as Shr<B>>::Output as Same<U2>>::Output;
4345
4346 assert_eq!(<U4ShrU1 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
4347 }
4348 #[test]
4349 #[allow(non_snake_case)]
4350 fn test_4_Add_1() {
4351 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4352 type B = UInt<UTerm, B1>;
4353 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
4354
4355 #[allow(non_camel_case_types)]
4356 type U4AddU1 = <<A as Add<B>>::Output as Same<U5>>::Output;
4357
4358 assert_eq!(<U4AddU1 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
4359 }
4360 #[test]
4361 #[allow(non_snake_case)]
4362 fn test_4_Mul_1() {
4363 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4364 type B = UInt<UTerm, B1>;
4365 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4366
4367 #[allow(non_camel_case_types)]
4368 type U4MulU1 = <<A as Mul<B>>::Output as Same<U4>>::Output;
4369
4370 assert_eq!(<U4MulU1 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
4371 }
4372 #[test]
4373 #[allow(non_snake_case)]
4374 fn test_4_Pow_1() {
4375 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4376 type B = UInt<UTerm, B1>;
4377 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4378
4379 #[allow(non_camel_case_types)]
4380 type U4PowU1 = <<A as Pow<B>>::Output as Same<U4>>::Output;
4381
4382 assert_eq!(<U4PowU1 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
4383 }
4384 #[test]
4385 #[allow(non_snake_case)]
4386 fn test_4_Min_1() {
4387 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4388 type B = UInt<UTerm, B1>;
4389 type U1 = UInt<UTerm, B1>;
4390
4391 #[allow(non_camel_case_types)]
4392 type U4MinU1 = <<A as Min<B>>::Output as Same<U1>>::Output;
4393
4394 assert_eq!(<U4MinU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
4395 }
4396 #[test]
4397 #[allow(non_snake_case)]
4398 fn test_4_Max_1() {
4399 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4400 type B = UInt<UTerm, B1>;
4401 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4402
4403 #[allow(non_camel_case_types)]
4404 type U4MaxU1 = <<A as Max<B>>::Output as Same<U4>>::Output;
4405
4406 assert_eq!(<U4MaxU1 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
4407 }
4408 #[test]
4409 #[allow(non_snake_case)]
4410 fn test_4_Gcd_1() {
4411 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4412 type B = UInt<UTerm, B1>;
4413 type U1 = UInt<UTerm, B1>;
4414
4415 #[allow(non_camel_case_types)]
4416 type U4GcdU1 = <<A as Gcd<B>>::Output as Same<U1>>::Output;
4417
4418 assert_eq!(<U4GcdU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
4419 }
4420 #[test]
4421 #[allow(non_snake_case)]
4422 fn test_4_Sub_1() {
4423 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4424 type B = UInt<UTerm, B1>;
4425 type U3 = UInt<UInt<UTerm, B1>, B1>;
4426
4427 #[allow(non_camel_case_types)]
4428 type U4SubU1 = <<A as Sub<B>>::Output as Same<U3>>::Output;
4429
4430 assert_eq!(<U4SubU1 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
4431 }
4432 #[test]
4433 #[allow(non_snake_case)]
4434 fn test_4_Div_1() {
4435 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4436 type B = UInt<UTerm, B1>;
4437 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4438
4439 #[allow(non_camel_case_types)]
4440 type U4DivU1 = <<A as Div<B>>::Output as Same<U4>>::Output;
4441
4442 assert_eq!(<U4DivU1 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
4443 }
4444 #[test]
4445 #[allow(non_snake_case)]
4446 fn test_4_Rem_1() {
4447 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4448 type B = UInt<UTerm, B1>;
4449 type U0 = UTerm;
4450
4451 #[allow(non_camel_case_types)]
4452 type U4RemU1 = <<A as Rem<B>>::Output as Same<U0>>::Output;
4453
4454 assert_eq!(<U4RemU1 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
4455 }
4456 #[test]
4457 #[allow(non_snake_case)]
4458 fn test_4_PartialDiv_1() {
4459 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4460 type B = UInt<UTerm, B1>;
4461 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4462
4463 #[allow(non_camel_case_types)]
4464 type U4PartialDivU1 = <<A as PartialDiv<B>>::Output as Same<U4>>::Output;
4465
4466 assert_eq!(<U4PartialDivU1 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
4467 }
4468 #[test]
4469 #[allow(non_snake_case)]
4470 fn test_4_Cmp_1() {
4471 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4472 type B = UInt<UTerm, B1>;
4473
4474 #[allow(non_camel_case_types)]
4475 type U4CmpU1 = <A as Cmp<B>>::Output;
4476 assert_eq!(<U4CmpU1 as Ord>::to_ordering(), Ordering::Greater);
4477 }
4478 #[test]
4479 #[allow(non_snake_case)]
4480 fn test_4_BitAnd_2() {
4481 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4482 type B = UInt<UInt<UTerm, B1>, B0>;
4483 type U0 = UTerm;
4484
4485 #[allow(non_camel_case_types)]
4486 type U4BitAndU2 = <<A as BitAnd<B>>::Output as Same<U0>>::Output;
4487
4488 assert_eq!(<U4BitAndU2 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
4489 }
4490 #[test]
4491 #[allow(non_snake_case)]
4492 fn test_4_BitOr_2() {
4493 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4494 type B = UInt<UInt<UTerm, B1>, B0>;
4495 type U6 = UInt<UInt<UInt<UTerm, B1>, B1>, B0>;
4496
4497 #[allow(non_camel_case_types)]
4498 type U4BitOrU2 = <<A as BitOr<B>>::Output as Same<U6>>::Output;
4499
4500 assert_eq!(<U4BitOrU2 as Unsigned>::to_u64(), <U6 as Unsigned>::to_u64());
4501 }
4502 #[test]
4503 #[allow(non_snake_case)]
4504 fn test_4_BitXor_2() {
4505 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4506 type B = UInt<UInt<UTerm, B1>, B0>;
4507 type U6 = UInt<UInt<UInt<UTerm, B1>, B1>, B0>;
4508
4509 #[allow(non_camel_case_types)]
4510 type U4BitXorU2 = <<A as BitXor<B>>::Output as Same<U6>>::Output;
4511
4512 assert_eq!(<U4BitXorU2 as Unsigned>::to_u64(), <U6 as Unsigned>::to_u64());
4513 }
4514 #[test]
4515 #[allow(non_snake_case)]
4516 fn test_4_Shl_2() {
4517 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4518 type B = UInt<UInt<UTerm, B1>, B0>;
4519 type U16 = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>;
4520
4521 #[allow(non_camel_case_types)]
4522 type U4ShlU2 = <<A as Shl<B>>::Output as Same<U16>>::Output;
4523
4524 assert_eq!(<U4ShlU2 as Unsigned>::to_u64(), <U16 as Unsigned>::to_u64());
4525 }
4526 #[test]
4527 #[allow(non_snake_case)]
4528 fn test_4_Shr_2() {
4529 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4530 type B = UInt<UInt<UTerm, B1>, B0>;
4531 type U1 = UInt<UTerm, B1>;
4532
4533 #[allow(non_camel_case_types)]
4534 type U4ShrU2 = <<A as Shr<B>>::Output as Same<U1>>::Output;
4535
4536 assert_eq!(<U4ShrU2 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
4537 }
4538 #[test]
4539 #[allow(non_snake_case)]
4540 fn test_4_Add_2() {
4541 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4542 type B = UInt<UInt<UTerm, B1>, B0>;
4543 type U6 = UInt<UInt<UInt<UTerm, B1>, B1>, B0>;
4544
4545 #[allow(non_camel_case_types)]
4546 type U4AddU2 = <<A as Add<B>>::Output as Same<U6>>::Output;
4547
4548 assert_eq!(<U4AddU2 as Unsigned>::to_u64(), <U6 as Unsigned>::to_u64());
4549 }
4550 #[test]
4551 #[allow(non_snake_case)]
4552 fn test_4_Mul_2() {
4553 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4554 type B = UInt<UInt<UTerm, B1>, B0>;
4555 type U8 = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>;
4556
4557 #[allow(non_camel_case_types)]
4558 type U4MulU2 = <<A as Mul<B>>::Output as Same<U8>>::Output;
4559
4560 assert_eq!(<U4MulU2 as Unsigned>::to_u64(), <U8 as Unsigned>::to_u64());
4561 }
4562 #[test]
4563 #[allow(non_snake_case)]
4564 fn test_4_Pow_2() {
4565 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4566 type B = UInt<UInt<UTerm, B1>, B0>;
4567 type U16 = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>;
4568
4569 #[allow(non_camel_case_types)]
4570 type U4PowU2 = <<A as Pow<B>>::Output as Same<U16>>::Output;
4571
4572 assert_eq!(<U4PowU2 as Unsigned>::to_u64(), <U16 as Unsigned>::to_u64());
4573 }
4574 #[test]
4575 #[allow(non_snake_case)]
4576 fn test_4_Min_2() {
4577 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4578 type B = UInt<UInt<UTerm, B1>, B0>;
4579 type U2 = UInt<UInt<UTerm, B1>, B0>;
4580
4581 #[allow(non_camel_case_types)]
4582 type U4MinU2 = <<A as Min<B>>::Output as Same<U2>>::Output;
4583
4584 assert_eq!(<U4MinU2 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
4585 }
4586 #[test]
4587 #[allow(non_snake_case)]
4588 fn test_4_Max_2() {
4589 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4590 type B = UInt<UInt<UTerm, B1>, B0>;
4591 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4592
4593 #[allow(non_camel_case_types)]
4594 type U4MaxU2 = <<A as Max<B>>::Output as Same<U4>>::Output;
4595
4596 assert_eq!(<U4MaxU2 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
4597 }
4598 #[test]
4599 #[allow(non_snake_case)]
4600 fn test_4_Gcd_2() {
4601 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4602 type B = UInt<UInt<UTerm, B1>, B0>;
4603 type U2 = UInt<UInt<UTerm, B1>, B0>;
4604
4605 #[allow(non_camel_case_types)]
4606 type U4GcdU2 = <<A as Gcd<B>>::Output as Same<U2>>::Output;
4607
4608 assert_eq!(<U4GcdU2 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
4609 }
4610 #[test]
4611 #[allow(non_snake_case)]
4612 fn test_4_Sub_2() {
4613 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4614 type B = UInt<UInt<UTerm, B1>, B0>;
4615 type U2 = UInt<UInt<UTerm, B1>, B0>;
4616
4617 #[allow(non_camel_case_types)]
4618 type U4SubU2 = <<A as Sub<B>>::Output as Same<U2>>::Output;
4619
4620 assert_eq!(<U4SubU2 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
4621 }
4622 #[test]
4623 #[allow(non_snake_case)]
4624 fn test_4_Div_2() {
4625 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4626 type B = UInt<UInt<UTerm, B1>, B0>;
4627 type U2 = UInt<UInt<UTerm, B1>, B0>;
4628
4629 #[allow(non_camel_case_types)]
4630 type U4DivU2 = <<A as Div<B>>::Output as Same<U2>>::Output;
4631
4632 assert_eq!(<U4DivU2 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
4633 }
4634 #[test]
4635 #[allow(non_snake_case)]
4636 fn test_4_Rem_2() {
4637 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4638 type B = UInt<UInt<UTerm, B1>, B0>;
4639 type U0 = UTerm;
4640
4641 #[allow(non_camel_case_types)]
4642 type U4RemU2 = <<A as Rem<B>>::Output as Same<U0>>::Output;
4643
4644 assert_eq!(<U4RemU2 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
4645 }
4646 #[test]
4647 #[allow(non_snake_case)]
4648 fn test_4_PartialDiv_2() {
4649 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4650 type B = UInt<UInt<UTerm, B1>, B0>;
4651 type U2 = UInt<UInt<UTerm, B1>, B0>;
4652
4653 #[allow(non_camel_case_types)]
4654 type U4PartialDivU2 = <<A as PartialDiv<B>>::Output as Same<U2>>::Output;
4655
4656 assert_eq!(<U4PartialDivU2 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
4657 }
4658 #[test]
4659 #[allow(non_snake_case)]
4660 fn test_4_Cmp_2() {
4661 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4662 type B = UInt<UInt<UTerm, B1>, B0>;
4663
4664 #[allow(non_camel_case_types)]
4665 type U4CmpU2 = <A as Cmp<B>>::Output;
4666 assert_eq!(<U4CmpU2 as Ord>::to_ordering(), Ordering::Greater);
4667 }
4668 #[test]
4669 #[allow(non_snake_case)]
4670 fn test_4_BitAnd_3() {
4671 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4672 type B = UInt<UInt<UTerm, B1>, B1>;
4673 type U0 = UTerm;
4674
4675 #[allow(non_camel_case_types)]
4676 type U4BitAndU3 = <<A as BitAnd<B>>::Output as Same<U0>>::Output;
4677
4678 assert_eq!(<U4BitAndU3 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
4679 }
4680 #[test]
4681 #[allow(non_snake_case)]
4682 fn test_4_BitOr_3() {
4683 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4684 type B = UInt<UInt<UTerm, B1>, B1>;
4685 type U7 = UInt<UInt<UInt<UTerm, B1>, B1>, B1>;
4686
4687 #[allow(non_camel_case_types)]
4688 type U4BitOrU3 = <<A as BitOr<B>>::Output as Same<U7>>::Output;
4689
4690 assert_eq!(<U4BitOrU3 as Unsigned>::to_u64(), <U7 as Unsigned>::to_u64());
4691 }
4692 #[test]
4693 #[allow(non_snake_case)]
4694 fn test_4_BitXor_3() {
4695 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4696 type B = UInt<UInt<UTerm, B1>, B1>;
4697 type U7 = UInt<UInt<UInt<UTerm, B1>, B1>, B1>;
4698
4699 #[allow(non_camel_case_types)]
4700 type U4BitXorU3 = <<A as BitXor<B>>::Output as Same<U7>>::Output;
4701
4702 assert_eq!(<U4BitXorU3 as Unsigned>::to_u64(), <U7 as Unsigned>::to_u64());
4703 }
4704 #[test]
4705 #[allow(non_snake_case)]
4706 fn test_4_Shl_3() {
4707 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4708 type B = UInt<UInt<UTerm, B1>, B1>;
4709 type U32 = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>;
4710
4711 #[allow(non_camel_case_types)]
4712 type U4ShlU3 = <<A as Shl<B>>::Output as Same<U32>>::Output;
4713
4714 assert_eq!(<U4ShlU3 as Unsigned>::to_u64(), <U32 as Unsigned>::to_u64());
4715 }
4716 #[test]
4717 #[allow(non_snake_case)]
4718 fn test_4_Shr_3() {
4719 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4720 type B = UInt<UInt<UTerm, B1>, B1>;
4721 type U0 = UTerm;
4722
4723 #[allow(non_camel_case_types)]
4724 type U4ShrU3 = <<A as Shr<B>>::Output as Same<U0>>::Output;
4725
4726 assert_eq!(<U4ShrU3 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
4727 }
4728 #[test]
4729 #[allow(non_snake_case)]
4730 fn test_4_Add_3() {
4731 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4732 type B = UInt<UInt<UTerm, B1>, B1>;
4733 type U7 = UInt<UInt<UInt<UTerm, B1>, B1>, B1>;
4734
4735 #[allow(non_camel_case_types)]
4736 type U4AddU3 = <<A as Add<B>>::Output as Same<U7>>::Output;
4737
4738 assert_eq!(<U4AddU3 as Unsigned>::to_u64(), <U7 as Unsigned>::to_u64());
4739 }
4740 #[test]
4741 #[allow(non_snake_case)]
4742 fn test_4_Mul_3() {
4743 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4744 type B = UInt<UInt<UTerm, B1>, B1>;
4745 type U12 = UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>;
4746
4747 #[allow(non_camel_case_types)]
4748 type U4MulU3 = <<A as Mul<B>>::Output as Same<U12>>::Output;
4749
4750 assert_eq!(<U4MulU3 as Unsigned>::to_u64(), <U12 as Unsigned>::to_u64());
4751 }
4752 #[test]
4753 #[allow(non_snake_case)]
4754 fn test_4_Pow_3() {
4755 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4756 type B = UInt<UInt<UTerm, B1>, B1>;
4757 type U64 = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>;
4758
4759 #[allow(non_camel_case_types)]
4760 type U4PowU3 = <<A as Pow<B>>::Output as Same<U64>>::Output;
4761
4762 assert_eq!(<U4PowU3 as Unsigned>::to_u64(), <U64 as Unsigned>::to_u64());
4763 }
4764 #[test]
4765 #[allow(non_snake_case)]
4766 fn test_4_Min_3() {
4767 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4768 type B = UInt<UInt<UTerm, B1>, B1>;
4769 type U3 = UInt<UInt<UTerm, B1>, B1>;
4770
4771 #[allow(non_camel_case_types)]
4772 type U4MinU3 = <<A as Min<B>>::Output as Same<U3>>::Output;
4773
4774 assert_eq!(<U4MinU3 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
4775 }
4776 #[test]
4777 #[allow(non_snake_case)]
4778 fn test_4_Max_3() {
4779 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4780 type B = UInt<UInt<UTerm, B1>, B1>;
4781 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4782
4783 #[allow(non_camel_case_types)]
4784 type U4MaxU3 = <<A as Max<B>>::Output as Same<U4>>::Output;
4785
4786 assert_eq!(<U4MaxU3 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
4787 }
4788 #[test]
4789 #[allow(non_snake_case)]
4790 fn test_4_Gcd_3() {
4791 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4792 type B = UInt<UInt<UTerm, B1>, B1>;
4793 type U1 = UInt<UTerm, B1>;
4794
4795 #[allow(non_camel_case_types)]
4796 type U4GcdU3 = <<A as Gcd<B>>::Output as Same<U1>>::Output;
4797
4798 assert_eq!(<U4GcdU3 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
4799 }
4800 #[test]
4801 #[allow(non_snake_case)]
4802 fn test_4_Sub_3() {
4803 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4804 type B = UInt<UInt<UTerm, B1>, B1>;
4805 type U1 = UInt<UTerm, B1>;
4806
4807 #[allow(non_camel_case_types)]
4808 type U4SubU3 = <<A as Sub<B>>::Output as Same<U1>>::Output;
4809
4810 assert_eq!(<U4SubU3 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
4811 }
4812 #[test]
4813 #[allow(non_snake_case)]
4814 fn test_4_Div_3() {
4815 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4816 type B = UInt<UInt<UTerm, B1>, B1>;
4817 type U1 = UInt<UTerm, B1>;
4818
4819 #[allow(non_camel_case_types)]
4820 type U4DivU3 = <<A as Div<B>>::Output as Same<U1>>::Output;
4821
4822 assert_eq!(<U4DivU3 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
4823 }
4824 #[test]
4825 #[allow(non_snake_case)]
4826 fn test_4_Rem_3() {
4827 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4828 type B = UInt<UInt<UTerm, B1>, B1>;
4829 type U1 = UInt<UTerm, B1>;
4830
4831 #[allow(non_camel_case_types)]
4832 type U4RemU3 = <<A as Rem<B>>::Output as Same<U1>>::Output;
4833
4834 assert_eq!(<U4RemU3 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
4835 }
4836 #[test]
4837 #[allow(non_snake_case)]
4838 fn test_4_Cmp_3() {
4839 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4840 type B = UInt<UInt<UTerm, B1>, B1>;
4841
4842 #[allow(non_camel_case_types)]
4843 type U4CmpU3 = <A as Cmp<B>>::Output;
4844 assert_eq!(<U4CmpU3 as Ord>::to_ordering(), Ordering::Greater);
4845 }
4846 #[test]
4847 #[allow(non_snake_case)]
4848 fn test_4_BitAnd_4() {
4849 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4850 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4851 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4852
4853 #[allow(non_camel_case_types)]
4854 type U4BitAndU4 = <<A as BitAnd<B>>::Output as Same<U4>>::Output;
4855
4856 assert_eq!(<U4BitAndU4 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
4857 }
4858 #[test]
4859 #[allow(non_snake_case)]
4860 fn test_4_BitOr_4() {
4861 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4862 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4863 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4864
4865 #[allow(non_camel_case_types)]
4866 type U4BitOrU4 = <<A as BitOr<B>>::Output as Same<U4>>::Output;
4867
4868 assert_eq!(<U4BitOrU4 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
4869 }
4870 #[test]
4871 #[allow(non_snake_case)]
4872 fn test_4_BitXor_4() {
4873 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4874 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4875 type U0 = UTerm;
4876
4877 #[allow(non_camel_case_types)]
4878 type U4BitXorU4 = <<A as BitXor<B>>::Output as Same<U0>>::Output;
4879
4880 assert_eq!(<U4BitXorU4 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
4881 }
4882 #[test]
4883 #[allow(non_snake_case)]
4884 fn test_4_Shl_4() {
4885 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4886 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4887 type U64 = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>;
4888
4889 #[allow(non_camel_case_types)]
4890 type U4ShlU4 = <<A as Shl<B>>::Output as Same<U64>>::Output;
4891
4892 assert_eq!(<U4ShlU4 as Unsigned>::to_u64(), <U64 as Unsigned>::to_u64());
4893 }
4894 #[test]
4895 #[allow(non_snake_case)]
4896 fn test_4_Shr_4() {
4897 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4898 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4899 type U0 = UTerm;
4900
4901 #[allow(non_camel_case_types)]
4902 type U4ShrU4 = <<A as Shr<B>>::Output as Same<U0>>::Output;
4903
4904 assert_eq!(<U4ShrU4 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
4905 }
4906 #[test]
4907 #[allow(non_snake_case)]
4908 fn test_4_Add_4() {
4909 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4910 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4911 type U8 = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>;
4912
4913 #[allow(non_camel_case_types)]
4914 type U4AddU4 = <<A as Add<B>>::Output as Same<U8>>::Output;
4915
4916 assert_eq!(<U4AddU4 as Unsigned>::to_u64(), <U8 as Unsigned>::to_u64());
4917 }
4918 #[test]
4919 #[allow(non_snake_case)]
4920 fn test_4_Mul_4() {
4921 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4922 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4923 type U16 = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>;
4924
4925 #[allow(non_camel_case_types)]
4926 type U4MulU4 = <<A as Mul<B>>::Output as Same<U16>>::Output;
4927
4928 assert_eq!(<U4MulU4 as Unsigned>::to_u64(), <U16 as Unsigned>::to_u64());
4929 }
4930 #[test]
4931 #[allow(non_snake_case)]
4932 fn test_4_Pow_4() {
4933 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4934 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4935 type U256 = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>;
4936
4937 #[allow(non_camel_case_types)]
4938 type U4PowU4 = <<A as Pow<B>>::Output as Same<U256>>::Output;
4939
4940 assert_eq!(<U4PowU4 as Unsigned>::to_u64(), <U256 as Unsigned>::to_u64());
4941 }
4942 #[test]
4943 #[allow(non_snake_case)]
4944 fn test_4_Min_4() {
4945 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4946 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4947 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4948
4949 #[allow(non_camel_case_types)]
4950 type U4MinU4 = <<A as Min<B>>::Output as Same<U4>>::Output;
4951
4952 assert_eq!(<U4MinU4 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
4953 }
4954 #[test]
4955 #[allow(non_snake_case)]
4956 fn test_4_Max_4() {
4957 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4958 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4959 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4960
4961 #[allow(non_camel_case_types)]
4962 type U4MaxU4 = <<A as Max<B>>::Output as Same<U4>>::Output;
4963
4964 assert_eq!(<U4MaxU4 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
4965 }
4966 #[test]
4967 #[allow(non_snake_case)]
4968 fn test_4_Gcd_4() {
4969 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4970 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4971 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4972
4973 #[allow(non_camel_case_types)]
4974 type U4GcdU4 = <<A as Gcd<B>>::Output as Same<U4>>::Output;
4975
4976 assert_eq!(<U4GcdU4 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
4977 }
4978 #[test]
4979 #[allow(non_snake_case)]
4980 fn test_4_Sub_4() {
4981 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4982 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4983 type U0 = UTerm;
4984
4985 #[allow(non_camel_case_types)]
4986 type U4SubU4 = <<A as Sub<B>>::Output as Same<U0>>::Output;
4987
4988 assert_eq!(<U4SubU4 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
4989 }
4990 #[test]
4991 #[allow(non_snake_case)]
4992 fn test_4_Div_4() {
4993 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4994 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
4995 type U1 = UInt<UTerm, B1>;
4996
4997 #[allow(non_camel_case_types)]
4998 type U4DivU4 = <<A as Div<B>>::Output as Same<U1>>::Output;
4999
5000 assert_eq!(<U4DivU4 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
5001 }
5002 #[test]
5003 #[allow(non_snake_case)]
5004 fn test_4_Rem_4() {
5005 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5006 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5007 type U0 = UTerm;
5008
5009 #[allow(non_camel_case_types)]
5010 type U4RemU4 = <<A as Rem<B>>::Output as Same<U0>>::Output;
5011
5012 assert_eq!(<U4RemU4 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
5013 }
5014 #[test]
5015 #[allow(non_snake_case)]
5016 fn test_4_PartialDiv_4() {
5017 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5018 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5019 type U1 = UInt<UTerm, B1>;
5020
5021 #[allow(non_camel_case_types)]
5022 type U4PartialDivU4 = <<A as PartialDiv<B>>::Output as Same<U1>>::Output;
5023
5024 assert_eq!(<U4PartialDivU4 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
5025 }
5026 #[test]
5027 #[allow(non_snake_case)]
5028 fn test_4_Cmp_4() {
5029 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5030 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5031
5032 #[allow(non_camel_case_types)]
5033 type U4CmpU4 = <A as Cmp<B>>::Output;
5034 assert_eq!(<U4CmpU4 as Ord>::to_ordering(), Ordering::Equal);
5035 }
5036 #[test]
5037 #[allow(non_snake_case)]
5038 fn test_4_BitAnd_5() {
5039 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5040 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5041 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5042
5043 #[allow(non_camel_case_types)]
5044 type U4BitAndU5 = <<A as BitAnd<B>>::Output as Same<U4>>::Output;
5045
5046 assert_eq!(<U4BitAndU5 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
5047 }
5048 #[test]
5049 #[allow(non_snake_case)]
5050 fn test_4_BitOr_5() {
5051 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5052 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5053 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5054
5055 #[allow(non_camel_case_types)]
5056 type U4BitOrU5 = <<A as BitOr<B>>::Output as Same<U5>>::Output;
5057
5058 assert_eq!(<U4BitOrU5 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
5059 }
5060 #[test]
5061 #[allow(non_snake_case)]
5062 fn test_4_BitXor_5() {
5063 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5064 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5065 type U1 = UInt<UTerm, B1>;
5066
5067 #[allow(non_camel_case_types)]
5068 type U4BitXorU5 = <<A as BitXor<B>>::Output as Same<U1>>::Output;
5069
5070 assert_eq!(<U4BitXorU5 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
5071 }
5072 #[test]
5073 #[allow(non_snake_case)]
5074 fn test_4_Shl_5() {
5075 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5076 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5077 type U128 = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>;
5078
5079 #[allow(non_camel_case_types)]
5080 type U4ShlU5 = <<A as Shl<B>>::Output as Same<U128>>::Output;
5081
5082 assert_eq!(<U4ShlU5 as Unsigned>::to_u64(), <U128 as Unsigned>::to_u64());
5083 }
5084 #[test]
5085 #[allow(non_snake_case)]
5086 fn test_4_Shr_5() {
5087 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5088 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5089 type U0 = UTerm;
5090
5091 #[allow(non_camel_case_types)]
5092 type U4ShrU5 = <<A as Shr<B>>::Output as Same<U0>>::Output;
5093
5094 assert_eq!(<U4ShrU5 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
5095 }
5096 #[test]
5097 #[allow(non_snake_case)]
5098 fn test_4_Add_5() {
5099 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5100 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5101 type U9 = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>;
5102
5103 #[allow(non_camel_case_types)]
5104 type U4AddU5 = <<A as Add<B>>::Output as Same<U9>>::Output;
5105
5106 assert_eq!(<U4AddU5 as Unsigned>::to_u64(), <U9 as Unsigned>::to_u64());
5107 }
5108 #[test]
5109 #[allow(non_snake_case)]
5110 fn test_4_Mul_5() {
5111 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5112 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5113 type U20 = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>;
5114
5115 #[allow(non_camel_case_types)]
5116 type U4MulU5 = <<A as Mul<B>>::Output as Same<U20>>::Output;
5117
5118 assert_eq!(<U4MulU5 as Unsigned>::to_u64(), <U20 as Unsigned>::to_u64());
5119 }
5120 #[test]
5121 #[allow(non_snake_case)]
5122 fn test_4_Pow_5() {
5123 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5124 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5125 type U1024 = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>;
5126
5127 #[allow(non_camel_case_types)]
5128 type U4PowU5 = <<A as Pow<B>>::Output as Same<U1024>>::Output;
5129
5130 assert_eq!(<U4PowU5 as Unsigned>::to_u64(), <U1024 as Unsigned>::to_u64());
5131 }
5132 #[test]
5133 #[allow(non_snake_case)]
5134 fn test_4_Min_5() {
5135 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5136 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5137 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5138
5139 #[allow(non_camel_case_types)]
5140 type U4MinU5 = <<A as Min<B>>::Output as Same<U4>>::Output;
5141
5142 assert_eq!(<U4MinU5 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
5143 }
5144 #[test]
5145 #[allow(non_snake_case)]
5146 fn test_4_Max_5() {
5147 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5148 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5149 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5150
5151 #[allow(non_camel_case_types)]
5152 type U4MaxU5 = <<A as Max<B>>::Output as Same<U5>>::Output;
5153
5154 assert_eq!(<U4MaxU5 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
5155 }
5156 #[test]
5157 #[allow(non_snake_case)]
5158 fn test_4_Gcd_5() {
5159 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5160 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5161 type U1 = UInt<UTerm, B1>;
5162
5163 #[allow(non_camel_case_types)]
5164 type U4GcdU5 = <<A as Gcd<B>>::Output as Same<U1>>::Output;
5165
5166 assert_eq!(<U4GcdU5 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
5167 }
5168 #[test]
5169 #[allow(non_snake_case)]
5170 fn test_4_Div_5() {
5171 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5172 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5173 type U0 = UTerm;
5174
5175 #[allow(non_camel_case_types)]
5176 type U4DivU5 = <<A as Div<B>>::Output as Same<U0>>::Output;
5177
5178 assert_eq!(<U4DivU5 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
5179 }
5180 #[test]
5181 #[allow(non_snake_case)]
5182 fn test_4_Rem_5() {
5183 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5184 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5185 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5186
5187 #[allow(non_camel_case_types)]
5188 type U4RemU5 = <<A as Rem<B>>::Output as Same<U4>>::Output;
5189
5190 assert_eq!(<U4RemU5 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
5191 }
5192 #[test]
5193 #[allow(non_snake_case)]
5194 fn test_4_Cmp_5() {
5195 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5196 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5197
5198 #[allow(non_camel_case_types)]
5199 type U4CmpU5 = <A as Cmp<B>>::Output;
5200 assert_eq!(<U4CmpU5 as Ord>::to_ordering(), Ordering::Less);
5201 }
5202 #[test]
5203 #[allow(non_snake_case)]
5204 fn test_5_BitAnd_0() {
5205 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5206 type B = UTerm;
5207 type U0 = UTerm;
5208
5209 #[allow(non_camel_case_types)]
5210 type U5BitAndU0 = <<A as BitAnd<B>>::Output as Same<U0>>::Output;
5211
5212 assert_eq!(<U5BitAndU0 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
5213 }
5214 #[test]
5215 #[allow(non_snake_case)]
5216 fn test_5_BitOr_0() {
5217 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5218 type B = UTerm;
5219 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5220
5221 #[allow(non_camel_case_types)]
5222 type U5BitOrU0 = <<A as BitOr<B>>::Output as Same<U5>>::Output;
5223
5224 assert_eq!(<U5BitOrU0 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
5225 }
5226 #[test]
5227 #[allow(non_snake_case)]
5228 fn test_5_BitXor_0() {
5229 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5230 type B = UTerm;
5231 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5232
5233 #[allow(non_camel_case_types)]
5234 type U5BitXorU0 = <<A as BitXor<B>>::Output as Same<U5>>::Output;
5235
5236 assert_eq!(<U5BitXorU0 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
5237 }
5238 #[test]
5239 #[allow(non_snake_case)]
5240 fn test_5_Shl_0() {
5241 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5242 type B = UTerm;
5243 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5244
5245 #[allow(non_camel_case_types)]
5246 type U5ShlU0 = <<A as Shl<B>>::Output as Same<U5>>::Output;
5247
5248 assert_eq!(<U5ShlU0 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
5249 }
5250 #[test]
5251 #[allow(non_snake_case)]
5252 fn test_5_Shr_0() {
5253 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5254 type B = UTerm;
5255 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5256
5257 #[allow(non_camel_case_types)]
5258 type U5ShrU0 = <<A as Shr<B>>::Output as Same<U5>>::Output;
5259
5260 assert_eq!(<U5ShrU0 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
5261 }
5262 #[test]
5263 #[allow(non_snake_case)]
5264 fn test_5_Add_0() {
5265 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5266 type B = UTerm;
5267 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5268
5269 #[allow(non_camel_case_types)]
5270 type U5AddU0 = <<A as Add<B>>::Output as Same<U5>>::Output;
5271
5272 assert_eq!(<U5AddU0 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
5273 }
5274 #[test]
5275 #[allow(non_snake_case)]
5276 fn test_5_Mul_0() {
5277 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5278 type B = UTerm;
5279 type U0 = UTerm;
5280
5281 #[allow(non_camel_case_types)]
5282 type U5MulU0 = <<A as Mul<B>>::Output as Same<U0>>::Output;
5283
5284 assert_eq!(<U5MulU0 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
5285 }
5286 #[test]
5287 #[allow(non_snake_case)]
5288 fn test_5_Pow_0() {
5289 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5290 type B = UTerm;
5291 type U1 = UInt<UTerm, B1>;
5292
5293 #[allow(non_camel_case_types)]
5294 type U5PowU0 = <<A as Pow<B>>::Output as Same<U1>>::Output;
5295
5296 assert_eq!(<U5PowU0 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
5297 }
5298 #[test]
5299 #[allow(non_snake_case)]
5300 fn test_5_Min_0() {
5301 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5302 type B = UTerm;
5303 type U0 = UTerm;
5304
5305 #[allow(non_camel_case_types)]
5306 type U5MinU0 = <<A as Min<B>>::Output as Same<U0>>::Output;
5307
5308 assert_eq!(<U5MinU0 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
5309 }
5310 #[test]
5311 #[allow(non_snake_case)]
5312 fn test_5_Max_0() {
5313 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5314 type B = UTerm;
5315 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5316
5317 #[allow(non_camel_case_types)]
5318 type U5MaxU0 = <<A as Max<B>>::Output as Same<U5>>::Output;
5319
5320 assert_eq!(<U5MaxU0 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
5321 }
5322 #[test]
5323 #[allow(non_snake_case)]
5324 fn test_5_Gcd_0() {
5325 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5326 type B = UTerm;
5327 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5328
5329 #[allow(non_camel_case_types)]
5330 type U5GcdU0 = <<A as Gcd<B>>::Output as Same<U5>>::Output;
5331
5332 assert_eq!(<U5GcdU0 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
5333 }
5334 #[test]
5335 #[allow(non_snake_case)]
5336 fn test_5_Sub_0() {
5337 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5338 type B = UTerm;
5339 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5340
5341 #[allow(non_camel_case_types)]
5342 type U5SubU0 = <<A as Sub<B>>::Output as Same<U5>>::Output;
5343
5344 assert_eq!(<U5SubU0 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
5345 }
5346 #[test]
5347 #[allow(non_snake_case)]
5348 fn test_5_Cmp_0() {
5349 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5350 type B = UTerm;
5351
5352 #[allow(non_camel_case_types)]
5353 type U5CmpU0 = <A as Cmp<B>>::Output;
5354 assert_eq!(<U5CmpU0 as Ord>::to_ordering(), Ordering::Greater);
5355 }
5356 #[test]
5357 #[allow(non_snake_case)]
5358 fn test_5_BitAnd_1() {
5359 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5360 type B = UInt<UTerm, B1>;
5361 type U1 = UInt<UTerm, B1>;
5362
5363 #[allow(non_camel_case_types)]
5364 type U5BitAndU1 = <<A as BitAnd<B>>::Output as Same<U1>>::Output;
5365
5366 assert_eq!(<U5BitAndU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
5367 }
5368 #[test]
5369 #[allow(non_snake_case)]
5370 fn test_5_BitOr_1() {
5371 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5372 type B = UInt<UTerm, B1>;
5373 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5374
5375 #[allow(non_camel_case_types)]
5376 type U5BitOrU1 = <<A as BitOr<B>>::Output as Same<U5>>::Output;
5377
5378 assert_eq!(<U5BitOrU1 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
5379 }
5380 #[test]
5381 #[allow(non_snake_case)]
5382 fn test_5_BitXor_1() {
5383 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5384 type B = UInt<UTerm, B1>;
5385 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5386
5387 #[allow(non_camel_case_types)]
5388 type U5BitXorU1 = <<A as BitXor<B>>::Output as Same<U4>>::Output;
5389
5390 assert_eq!(<U5BitXorU1 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
5391 }
5392 #[test]
5393 #[allow(non_snake_case)]
5394 fn test_5_Shl_1() {
5395 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5396 type B = UInt<UTerm, B1>;
5397 type U10 = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>;
5398
5399 #[allow(non_camel_case_types)]
5400 type U5ShlU1 = <<A as Shl<B>>::Output as Same<U10>>::Output;
5401
5402 assert_eq!(<U5ShlU1 as Unsigned>::to_u64(), <U10 as Unsigned>::to_u64());
5403 }
5404 #[test]
5405 #[allow(non_snake_case)]
5406 fn test_5_Shr_1() {
5407 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5408 type B = UInt<UTerm, B1>;
5409 type U2 = UInt<UInt<UTerm, B1>, B0>;
5410
5411 #[allow(non_camel_case_types)]
5412 type U5ShrU1 = <<A as Shr<B>>::Output as Same<U2>>::Output;
5413
5414 assert_eq!(<U5ShrU1 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
5415 }
5416 #[test]
5417 #[allow(non_snake_case)]
5418 fn test_5_Add_1() {
5419 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5420 type B = UInt<UTerm, B1>;
5421 type U6 = UInt<UInt<UInt<UTerm, B1>, B1>, B0>;
5422
5423 #[allow(non_camel_case_types)]
5424 type U5AddU1 = <<A as Add<B>>::Output as Same<U6>>::Output;
5425
5426 assert_eq!(<U5AddU1 as Unsigned>::to_u64(), <U6 as Unsigned>::to_u64());
5427 }
5428 #[test]
5429 #[allow(non_snake_case)]
5430 fn test_5_Mul_1() {
5431 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5432 type B = UInt<UTerm, B1>;
5433 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5434
5435 #[allow(non_camel_case_types)]
5436 type U5MulU1 = <<A as Mul<B>>::Output as Same<U5>>::Output;
5437
5438 assert_eq!(<U5MulU1 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
5439 }
5440 #[test]
5441 #[allow(non_snake_case)]
5442 fn test_5_Pow_1() {
5443 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5444 type B = UInt<UTerm, B1>;
5445 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5446
5447 #[allow(non_camel_case_types)]
5448 type U5PowU1 = <<A as Pow<B>>::Output as Same<U5>>::Output;
5449
5450 assert_eq!(<U5PowU1 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
5451 }
5452 #[test]
5453 #[allow(non_snake_case)]
5454 fn test_5_Min_1() {
5455 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5456 type B = UInt<UTerm, B1>;
5457 type U1 = UInt<UTerm, B1>;
5458
5459 #[allow(non_camel_case_types)]
5460 type U5MinU1 = <<A as Min<B>>::Output as Same<U1>>::Output;
5461
5462 assert_eq!(<U5MinU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
5463 }
5464 #[test]
5465 #[allow(non_snake_case)]
5466 fn test_5_Max_1() {
5467 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5468 type B = UInt<UTerm, B1>;
5469 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5470
5471 #[allow(non_camel_case_types)]
5472 type U5MaxU1 = <<A as Max<B>>::Output as Same<U5>>::Output;
5473
5474 assert_eq!(<U5MaxU1 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
5475 }
5476 #[test]
5477 #[allow(non_snake_case)]
5478 fn test_5_Gcd_1() {
5479 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5480 type B = UInt<UTerm, B1>;
5481 type U1 = UInt<UTerm, B1>;
5482
5483 #[allow(non_camel_case_types)]
5484 type U5GcdU1 = <<A as Gcd<B>>::Output as Same<U1>>::Output;
5485
5486 assert_eq!(<U5GcdU1 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
5487 }
5488 #[test]
5489 #[allow(non_snake_case)]
5490 fn test_5_Sub_1() {
5491 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5492 type B = UInt<UTerm, B1>;
5493 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5494
5495 #[allow(non_camel_case_types)]
5496 type U5SubU1 = <<A as Sub<B>>::Output as Same<U4>>::Output;
5497
5498 assert_eq!(<U5SubU1 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
5499 }
5500 #[test]
5501 #[allow(non_snake_case)]
5502 fn test_5_Div_1() {
5503 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5504 type B = UInt<UTerm, B1>;
5505 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5506
5507 #[allow(non_camel_case_types)]
5508 type U5DivU1 = <<A as Div<B>>::Output as Same<U5>>::Output;
5509
5510 assert_eq!(<U5DivU1 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
5511 }
5512 #[test]
5513 #[allow(non_snake_case)]
5514 fn test_5_Rem_1() {
5515 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5516 type B = UInt<UTerm, B1>;
5517 type U0 = UTerm;
5518
5519 #[allow(non_camel_case_types)]
5520 type U5RemU1 = <<A as Rem<B>>::Output as Same<U0>>::Output;
5521
5522 assert_eq!(<U5RemU1 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
5523 }
5524 #[test]
5525 #[allow(non_snake_case)]
5526 fn test_5_PartialDiv_1() {
5527 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5528 type B = UInt<UTerm, B1>;
5529 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5530
5531 #[allow(non_camel_case_types)]
5532 type U5PartialDivU1 = <<A as PartialDiv<B>>::Output as Same<U5>>::Output;
5533
5534 assert_eq!(<U5PartialDivU1 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
5535 }
5536 #[test]
5537 #[allow(non_snake_case)]
5538 fn test_5_Cmp_1() {
5539 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5540 type B = UInt<UTerm, B1>;
5541
5542 #[allow(non_camel_case_types)]
5543 type U5CmpU1 = <A as Cmp<B>>::Output;
5544 assert_eq!(<U5CmpU1 as Ord>::to_ordering(), Ordering::Greater);
5545 }
5546 #[test]
5547 #[allow(non_snake_case)]
5548 fn test_5_BitAnd_2() {
5549 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5550 type B = UInt<UInt<UTerm, B1>, B0>;
5551 type U0 = UTerm;
5552
5553 #[allow(non_camel_case_types)]
5554 type U5BitAndU2 = <<A as BitAnd<B>>::Output as Same<U0>>::Output;
5555
5556 assert_eq!(<U5BitAndU2 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
5557 }
5558 #[test]
5559 #[allow(non_snake_case)]
5560 fn test_5_BitOr_2() {
5561 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5562 type B = UInt<UInt<UTerm, B1>, B0>;
5563 type U7 = UInt<UInt<UInt<UTerm, B1>, B1>, B1>;
5564
5565 #[allow(non_camel_case_types)]
5566 type U5BitOrU2 = <<A as BitOr<B>>::Output as Same<U7>>::Output;
5567
5568 assert_eq!(<U5BitOrU2 as Unsigned>::to_u64(), <U7 as Unsigned>::to_u64());
5569 }
5570 #[test]
5571 #[allow(non_snake_case)]
5572 fn test_5_BitXor_2() {
5573 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5574 type B = UInt<UInt<UTerm, B1>, B0>;
5575 type U7 = UInt<UInt<UInt<UTerm, B1>, B1>, B1>;
5576
5577 #[allow(non_camel_case_types)]
5578 type U5BitXorU2 = <<A as BitXor<B>>::Output as Same<U7>>::Output;
5579
5580 assert_eq!(<U5BitXorU2 as Unsigned>::to_u64(), <U7 as Unsigned>::to_u64());
5581 }
5582 #[test]
5583 #[allow(non_snake_case)]
5584 fn test_5_Shl_2() {
5585 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5586 type B = UInt<UInt<UTerm, B1>, B0>;
5587 type U20 = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>;
5588
5589 #[allow(non_camel_case_types)]
5590 type U5ShlU2 = <<A as Shl<B>>::Output as Same<U20>>::Output;
5591
5592 assert_eq!(<U5ShlU2 as Unsigned>::to_u64(), <U20 as Unsigned>::to_u64());
5593 }
5594 #[test]
5595 #[allow(non_snake_case)]
5596 fn test_5_Shr_2() {
5597 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5598 type B = UInt<UInt<UTerm, B1>, B0>;
5599 type U1 = UInt<UTerm, B1>;
5600
5601 #[allow(non_camel_case_types)]
5602 type U5ShrU2 = <<A as Shr<B>>::Output as Same<U1>>::Output;
5603
5604 assert_eq!(<U5ShrU2 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
5605 }
5606 #[test]
5607 #[allow(non_snake_case)]
5608 fn test_5_Add_2() {
5609 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5610 type B = UInt<UInt<UTerm, B1>, B0>;
5611 type U7 = UInt<UInt<UInt<UTerm, B1>, B1>, B1>;
5612
5613 #[allow(non_camel_case_types)]
5614 type U5AddU2 = <<A as Add<B>>::Output as Same<U7>>::Output;
5615
5616 assert_eq!(<U5AddU2 as Unsigned>::to_u64(), <U7 as Unsigned>::to_u64());
5617 }
5618 #[test]
5619 #[allow(non_snake_case)]
5620 fn test_5_Mul_2() {
5621 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5622 type B = UInt<UInt<UTerm, B1>, B0>;
5623 type U10 = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>;
5624
5625 #[allow(non_camel_case_types)]
5626 type U5MulU2 = <<A as Mul<B>>::Output as Same<U10>>::Output;
5627
5628 assert_eq!(<U5MulU2 as Unsigned>::to_u64(), <U10 as Unsigned>::to_u64());
5629 }
5630 #[test]
5631 #[allow(non_snake_case)]
5632 fn test_5_Pow_2() {
5633 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5634 type B = UInt<UInt<UTerm, B1>, B0>;
5635 type U25 = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>;
5636
5637 #[allow(non_camel_case_types)]
5638 type U5PowU2 = <<A as Pow<B>>::Output as Same<U25>>::Output;
5639
5640 assert_eq!(<U5PowU2 as Unsigned>::to_u64(), <U25 as Unsigned>::to_u64());
5641 }
5642 #[test]
5643 #[allow(non_snake_case)]
5644 fn test_5_Min_2() {
5645 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5646 type B = UInt<UInt<UTerm, B1>, B0>;
5647 type U2 = UInt<UInt<UTerm, B1>, B0>;
5648
5649 #[allow(non_camel_case_types)]
5650 type U5MinU2 = <<A as Min<B>>::Output as Same<U2>>::Output;
5651
5652 assert_eq!(<U5MinU2 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
5653 }
5654 #[test]
5655 #[allow(non_snake_case)]
5656 fn test_5_Max_2() {
5657 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5658 type B = UInt<UInt<UTerm, B1>, B0>;
5659 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5660
5661 #[allow(non_camel_case_types)]
5662 type U5MaxU2 = <<A as Max<B>>::Output as Same<U5>>::Output;
5663
5664 assert_eq!(<U5MaxU2 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
5665 }
5666 #[test]
5667 #[allow(non_snake_case)]
5668 fn test_5_Gcd_2() {
5669 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5670 type B = UInt<UInt<UTerm, B1>, B0>;
5671 type U1 = UInt<UTerm, B1>;
5672
5673 #[allow(non_camel_case_types)]
5674 type U5GcdU2 = <<A as Gcd<B>>::Output as Same<U1>>::Output;
5675
5676 assert_eq!(<U5GcdU2 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
5677 }
5678 #[test]
5679 #[allow(non_snake_case)]
5680 fn test_5_Sub_2() {
5681 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5682 type B = UInt<UInt<UTerm, B1>, B0>;
5683 type U3 = UInt<UInt<UTerm, B1>, B1>;
5684
5685 #[allow(non_camel_case_types)]
5686 type U5SubU2 = <<A as Sub<B>>::Output as Same<U3>>::Output;
5687
5688 assert_eq!(<U5SubU2 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
5689 }
5690 #[test]
5691 #[allow(non_snake_case)]
5692 fn test_5_Div_2() {
5693 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5694 type B = UInt<UInt<UTerm, B1>, B0>;
5695 type U2 = UInt<UInt<UTerm, B1>, B0>;
5696
5697 #[allow(non_camel_case_types)]
5698 type U5DivU2 = <<A as Div<B>>::Output as Same<U2>>::Output;
5699
5700 assert_eq!(<U5DivU2 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
5701 }
5702 #[test]
5703 #[allow(non_snake_case)]
5704 fn test_5_Rem_2() {
5705 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5706 type B = UInt<UInt<UTerm, B1>, B0>;
5707 type U1 = UInt<UTerm, B1>;
5708
5709 #[allow(non_camel_case_types)]
5710 type U5RemU2 = <<A as Rem<B>>::Output as Same<U1>>::Output;
5711
5712 assert_eq!(<U5RemU2 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
5713 }
5714 #[test]
5715 #[allow(non_snake_case)]
5716 fn test_5_Cmp_2() {
5717 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5718 type B = UInt<UInt<UTerm, B1>, B0>;
5719
5720 #[allow(non_camel_case_types)]
5721 type U5CmpU2 = <A as Cmp<B>>::Output;
5722 assert_eq!(<U5CmpU2 as Ord>::to_ordering(), Ordering::Greater);
5723 }
5724 #[test]
5725 #[allow(non_snake_case)]
5726 fn test_5_BitAnd_3() {
5727 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5728 type B = UInt<UInt<UTerm, B1>, B1>;
5729 type U1 = UInt<UTerm, B1>;
5730
5731 #[allow(non_camel_case_types)]
5732 type U5BitAndU3 = <<A as BitAnd<B>>::Output as Same<U1>>::Output;
5733
5734 assert_eq!(<U5BitAndU3 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
5735 }
5736 #[test]
5737 #[allow(non_snake_case)]
5738 fn test_5_BitOr_3() {
5739 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5740 type B = UInt<UInt<UTerm, B1>, B1>;
5741 type U7 = UInt<UInt<UInt<UTerm, B1>, B1>, B1>;
5742
5743 #[allow(non_camel_case_types)]
5744 type U5BitOrU3 = <<A as BitOr<B>>::Output as Same<U7>>::Output;
5745
5746 assert_eq!(<U5BitOrU3 as Unsigned>::to_u64(), <U7 as Unsigned>::to_u64());
5747 }
5748 #[test]
5749 #[allow(non_snake_case)]
5750 fn test_5_BitXor_3() {
5751 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5752 type B = UInt<UInt<UTerm, B1>, B1>;
5753 type U6 = UInt<UInt<UInt<UTerm, B1>, B1>, B0>;
5754
5755 #[allow(non_camel_case_types)]
5756 type U5BitXorU3 = <<A as BitXor<B>>::Output as Same<U6>>::Output;
5757
5758 assert_eq!(<U5BitXorU3 as Unsigned>::to_u64(), <U6 as Unsigned>::to_u64());
5759 }
5760 #[test]
5761 #[allow(non_snake_case)]
5762 fn test_5_Shl_3() {
5763 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5764 type B = UInt<UInt<UTerm, B1>, B1>;
5765 type U40 = UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>;
5766
5767 #[allow(non_camel_case_types)]
5768 type U5ShlU3 = <<A as Shl<B>>::Output as Same<U40>>::Output;
5769
5770 assert_eq!(<U5ShlU3 as Unsigned>::to_u64(), <U40 as Unsigned>::to_u64());
5771 }
5772 #[test]
5773 #[allow(non_snake_case)]
5774 fn test_5_Shr_3() {
5775 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5776 type B = UInt<UInt<UTerm, B1>, B1>;
5777 type U0 = UTerm;
5778
5779 #[allow(non_camel_case_types)]
5780 type U5ShrU3 = <<A as Shr<B>>::Output as Same<U0>>::Output;
5781
5782 assert_eq!(<U5ShrU3 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
5783 }
5784 #[test]
5785 #[allow(non_snake_case)]
5786 fn test_5_Add_3() {
5787 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5788 type B = UInt<UInt<UTerm, B1>, B1>;
5789 type U8 = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>;
5790
5791 #[allow(non_camel_case_types)]
5792 type U5AddU3 = <<A as Add<B>>::Output as Same<U8>>::Output;
5793
5794 assert_eq!(<U5AddU3 as Unsigned>::to_u64(), <U8 as Unsigned>::to_u64());
5795 }
5796 #[test]
5797 #[allow(non_snake_case)]
5798 fn test_5_Mul_3() {
5799 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5800 type B = UInt<UInt<UTerm, B1>, B1>;
5801 type U15 = UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>;
5802
5803 #[allow(non_camel_case_types)]
5804 type U5MulU3 = <<A as Mul<B>>::Output as Same<U15>>::Output;
5805
5806 assert_eq!(<U5MulU3 as Unsigned>::to_u64(), <U15 as Unsigned>::to_u64());
5807 }
5808 #[test]
5809 #[allow(non_snake_case)]
5810 fn test_5_Pow_3() {
5811 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5812 type B = UInt<UInt<UTerm, B1>, B1>;
5813 type U125 = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>;
5814
5815 #[allow(non_camel_case_types)]
5816 type U5PowU3 = <<A as Pow<B>>::Output as Same<U125>>::Output;
5817
5818 assert_eq!(<U5PowU3 as Unsigned>::to_u64(), <U125 as Unsigned>::to_u64());
5819 }
5820 #[test]
5821 #[allow(non_snake_case)]
5822 fn test_5_Min_3() {
5823 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5824 type B = UInt<UInt<UTerm, B1>, B1>;
5825 type U3 = UInt<UInt<UTerm, B1>, B1>;
5826
5827 #[allow(non_camel_case_types)]
5828 type U5MinU3 = <<A as Min<B>>::Output as Same<U3>>::Output;
5829
5830 assert_eq!(<U5MinU3 as Unsigned>::to_u64(), <U3 as Unsigned>::to_u64());
5831 }
5832 #[test]
5833 #[allow(non_snake_case)]
5834 fn test_5_Max_3() {
5835 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5836 type B = UInt<UInt<UTerm, B1>, B1>;
5837 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5838
5839 #[allow(non_camel_case_types)]
5840 type U5MaxU3 = <<A as Max<B>>::Output as Same<U5>>::Output;
5841
5842 assert_eq!(<U5MaxU3 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
5843 }
5844 #[test]
5845 #[allow(non_snake_case)]
5846 fn test_5_Gcd_3() {
5847 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5848 type B = UInt<UInt<UTerm, B1>, B1>;
5849 type U1 = UInt<UTerm, B1>;
5850
5851 #[allow(non_camel_case_types)]
5852 type U5GcdU3 = <<A as Gcd<B>>::Output as Same<U1>>::Output;
5853
5854 assert_eq!(<U5GcdU3 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
5855 }
5856 #[test]
5857 #[allow(non_snake_case)]
5858 fn test_5_Sub_3() {
5859 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5860 type B = UInt<UInt<UTerm, B1>, B1>;
5861 type U2 = UInt<UInt<UTerm, B1>, B0>;
5862
5863 #[allow(non_camel_case_types)]
5864 type U5SubU3 = <<A as Sub<B>>::Output as Same<U2>>::Output;
5865
5866 assert_eq!(<U5SubU3 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
5867 }
5868 #[test]
5869 #[allow(non_snake_case)]
5870 fn test_5_Div_3() {
5871 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5872 type B = UInt<UInt<UTerm, B1>, B1>;
5873 type U1 = UInt<UTerm, B1>;
5874
5875 #[allow(non_camel_case_types)]
5876 type U5DivU3 = <<A as Div<B>>::Output as Same<U1>>::Output;
5877
5878 assert_eq!(<U5DivU3 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
5879 }
5880 #[test]
5881 #[allow(non_snake_case)]
5882 fn test_5_Rem_3() {
5883 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5884 type B = UInt<UInt<UTerm, B1>, B1>;
5885 type U2 = UInt<UInt<UTerm, B1>, B0>;
5886
5887 #[allow(non_camel_case_types)]
5888 type U5RemU3 = <<A as Rem<B>>::Output as Same<U2>>::Output;
5889
5890 assert_eq!(<U5RemU3 as Unsigned>::to_u64(), <U2 as Unsigned>::to_u64());
5891 }
5892 #[test]
5893 #[allow(non_snake_case)]
5894 fn test_5_Cmp_3() {
5895 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5896 type B = UInt<UInt<UTerm, B1>, B1>;
5897
5898 #[allow(non_camel_case_types)]
5899 type U5CmpU3 = <A as Cmp<B>>::Output;
5900 assert_eq!(<U5CmpU3 as Ord>::to_ordering(), Ordering::Greater);
5901 }
5902 #[test]
5903 #[allow(non_snake_case)]
5904 fn test_5_BitAnd_4() {
5905 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5906 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5907 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5908
5909 #[allow(non_camel_case_types)]
5910 type U5BitAndU4 = <<A as BitAnd<B>>::Output as Same<U4>>::Output;
5911
5912 assert_eq!(<U5BitAndU4 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
5913 }
5914 #[test]
5915 #[allow(non_snake_case)]
5916 fn test_5_BitOr_4() {
5917 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5918 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5919 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5920
5921 #[allow(non_camel_case_types)]
5922 type U5BitOrU4 = <<A as BitOr<B>>::Output as Same<U5>>::Output;
5923
5924 assert_eq!(<U5BitOrU4 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
5925 }
5926 #[test]
5927 #[allow(non_snake_case)]
5928 fn test_5_BitXor_4() {
5929 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5930 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5931 type U1 = UInt<UTerm, B1>;
5932
5933 #[allow(non_camel_case_types)]
5934 type U5BitXorU4 = <<A as BitXor<B>>::Output as Same<U1>>::Output;
5935
5936 assert_eq!(<U5BitXorU4 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
5937 }
5938 #[test]
5939 #[allow(non_snake_case)]
5940 fn test_5_Shl_4() {
5941 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5942 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5943 type U80 = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>, B0>;
5944
5945 #[allow(non_camel_case_types)]
5946 type U5ShlU4 = <<A as Shl<B>>::Output as Same<U80>>::Output;
5947
5948 assert_eq!(<U5ShlU4 as Unsigned>::to_u64(), <U80 as Unsigned>::to_u64());
5949 }
5950 #[test]
5951 #[allow(non_snake_case)]
5952 fn test_5_Shr_4() {
5953 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5954 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5955 type U0 = UTerm;
5956
5957 #[allow(non_camel_case_types)]
5958 type U5ShrU4 = <<A as Shr<B>>::Output as Same<U0>>::Output;
5959
5960 assert_eq!(<U5ShrU4 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
5961 }
5962 #[test]
5963 #[allow(non_snake_case)]
5964 fn test_5_Add_4() {
5965 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5966 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5967 type U9 = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>;
5968
5969 #[allow(non_camel_case_types)]
5970 type U5AddU4 = <<A as Add<B>>::Output as Same<U9>>::Output;
5971
5972 assert_eq!(<U5AddU4 as Unsigned>::to_u64(), <U9 as Unsigned>::to_u64());
5973 }
5974 #[test]
5975 #[allow(non_snake_case)]
5976 fn test_5_Mul_4() {
5977 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5978 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5979 type U20 = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>;
5980
5981 #[allow(non_camel_case_types)]
5982 type U5MulU4 = <<A as Mul<B>>::Output as Same<U20>>::Output;
5983
5984 assert_eq!(<U5MulU4 as Unsigned>::to_u64(), <U20 as Unsigned>::to_u64());
5985 }
5986 #[test]
5987 #[allow(non_snake_case)]
5988 fn test_5_Pow_4() {
5989 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
5990 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
5991 type U625 = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B1>, B0>, B0>, B0>, B1>;
5992
5993 #[allow(non_camel_case_types)]
5994 type U5PowU4 = <<A as Pow<B>>::Output as Same<U625>>::Output;
5995
5996 assert_eq!(<U5PowU4 as Unsigned>::to_u64(), <U625 as Unsigned>::to_u64());
5997 }
5998 #[test]
5999 #[allow(non_snake_case)]
6000 fn test_5_Min_4() {
6001 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6002 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
6003 type U4 = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
6004
6005 #[allow(non_camel_case_types)]
6006 type U5MinU4 = <<A as Min<B>>::Output as Same<U4>>::Output;
6007
6008 assert_eq!(<U5MinU4 as Unsigned>::to_u64(), <U4 as Unsigned>::to_u64());
6009 }
6010 #[test]
6011 #[allow(non_snake_case)]
6012 fn test_5_Max_4() {
6013 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6014 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
6015 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6016
6017 #[allow(non_camel_case_types)]
6018 type U5MaxU4 = <<A as Max<B>>::Output as Same<U5>>::Output;
6019
6020 assert_eq!(<U5MaxU4 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
6021 }
6022 #[test]
6023 #[allow(non_snake_case)]
6024 fn test_5_Gcd_4() {
6025 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6026 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
6027 type U1 = UInt<UTerm, B1>;
6028
6029 #[allow(non_camel_case_types)]
6030 type U5GcdU4 = <<A as Gcd<B>>::Output as Same<U1>>::Output;
6031
6032 assert_eq!(<U5GcdU4 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
6033 }
6034 #[test]
6035 #[allow(non_snake_case)]
6036 fn test_5_Sub_4() {
6037 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6038 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
6039 type U1 = UInt<UTerm, B1>;
6040
6041 #[allow(non_camel_case_types)]
6042 type U5SubU4 = <<A as Sub<B>>::Output as Same<U1>>::Output;
6043
6044 assert_eq!(<U5SubU4 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
6045 }
6046 #[test]
6047 #[allow(non_snake_case)]
6048 fn test_5_Div_4() {
6049 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6050 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
6051 type U1 = UInt<UTerm, B1>;
6052
6053 #[allow(non_camel_case_types)]
6054 type U5DivU4 = <<A as Div<B>>::Output as Same<U1>>::Output;
6055
6056 assert_eq!(<U5DivU4 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
6057 }
6058 #[test]
6059 #[allow(non_snake_case)]
6060 fn test_5_Rem_4() {
6061 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6062 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
6063 type U1 = UInt<UTerm, B1>;
6064
6065 #[allow(non_camel_case_types)]
6066 type U5RemU4 = <<A as Rem<B>>::Output as Same<U1>>::Output;
6067
6068 assert_eq!(<U5RemU4 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
6069 }
6070 #[test]
6071 #[allow(non_snake_case)]
6072 fn test_5_Cmp_4() {
6073 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6074 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B0>;
6075
6076 #[allow(non_camel_case_types)]
6077 type U5CmpU4 = <A as Cmp<B>>::Output;
6078 assert_eq!(<U5CmpU4 as Ord>::to_ordering(), Ordering::Greater);
6079 }
6080 #[test]
6081 #[allow(non_snake_case)]
6082 fn test_5_BitAnd_5() {
6083 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6084 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6085 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6086
6087 #[allow(non_camel_case_types)]
6088 type U5BitAndU5 = <<A as BitAnd<B>>::Output as Same<U5>>::Output;
6089
6090 assert_eq!(<U5BitAndU5 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
6091 }
6092 #[test]
6093 #[allow(non_snake_case)]
6094 fn test_5_BitOr_5() {
6095 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6096 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6097 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6098
6099 #[allow(non_camel_case_types)]
6100 type U5BitOrU5 = <<A as BitOr<B>>::Output as Same<U5>>::Output;
6101
6102 assert_eq!(<U5BitOrU5 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
6103 }
6104 #[test]
6105 #[allow(non_snake_case)]
6106 fn test_5_BitXor_5() {
6107 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6108 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6109 type U0 = UTerm;
6110
6111 #[allow(non_camel_case_types)]
6112 type U5BitXorU5 = <<A as BitXor<B>>::Output as Same<U0>>::Output;
6113
6114 assert_eq!(<U5BitXorU5 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
6115 }
6116 #[test]
6117 #[allow(non_snake_case)]
6118 fn test_5_Shl_5() {
6119 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6120 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6121 type U160 = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>, B0>, B0>;
6122
6123 #[allow(non_camel_case_types)]
6124 type U5ShlU5 = <<A as Shl<B>>::Output as Same<U160>>::Output;
6125
6126 assert_eq!(<U5ShlU5 as Unsigned>::to_u64(), <U160 as Unsigned>::to_u64());
6127 }
6128 #[test]
6129 #[allow(non_snake_case)]
6130 fn test_5_Shr_5() {
6131 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6132 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6133 type U0 = UTerm;
6134
6135 #[allow(non_camel_case_types)]
6136 type U5ShrU5 = <<A as Shr<B>>::Output as Same<U0>>::Output;
6137
6138 assert_eq!(<U5ShrU5 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
6139 }
6140 #[test]
6141 #[allow(non_snake_case)]
6142 fn test_5_Add_5() {
6143 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6144 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6145 type U10 = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>;
6146
6147 #[allow(non_camel_case_types)]
6148 type U5AddU5 = <<A as Add<B>>::Output as Same<U10>>::Output;
6149
6150 assert_eq!(<U5AddU5 as Unsigned>::to_u64(), <U10 as Unsigned>::to_u64());
6151 }
6152 #[test]
6153 #[allow(non_snake_case)]
6154 fn test_5_Mul_5() {
6155 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6156 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6157 type U25 = UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>;
6158
6159 #[allow(non_camel_case_types)]
6160 type U5MulU5 = <<A as Mul<B>>::Output as Same<U25>>::Output;
6161
6162 assert_eq!(<U5MulU5 as Unsigned>::to_u64(), <U25 as Unsigned>::to_u64());
6163 }
6164 #[test]
6165 #[allow(non_snake_case)]
6166 fn test_5_Pow_5() {
6167 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6168 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6169 type U3125 = UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>, B1>, B1>, B0>, B1>, B0>, B1>;
6170
6171 #[allow(non_camel_case_types)]
6172 type U5PowU5 = <<A as Pow<B>>::Output as Same<U3125>>::Output;
6173
6174 assert_eq!(<U5PowU5 as Unsigned>::to_u64(), <U3125 as Unsigned>::to_u64());
6175 }
6176 #[test]
6177 #[allow(non_snake_case)]
6178 fn test_5_Min_5() {
6179 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6180 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6181 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6182
6183 #[allow(non_camel_case_types)]
6184 type U5MinU5 = <<A as Min<B>>::Output as Same<U5>>::Output;
6185
6186 assert_eq!(<U5MinU5 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
6187 }
6188 #[test]
6189 #[allow(non_snake_case)]
6190 fn test_5_Max_5() {
6191 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6192 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6193 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6194
6195 #[allow(non_camel_case_types)]
6196 type U5MaxU5 = <<A as Max<B>>::Output as Same<U5>>::Output;
6197
6198 assert_eq!(<U5MaxU5 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
6199 }
6200 #[test]
6201 #[allow(non_snake_case)]
6202 fn test_5_Gcd_5() {
6203 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6204 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6205 type U5 = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6206
6207 #[allow(non_camel_case_types)]
6208 type U5GcdU5 = <<A as Gcd<B>>::Output as Same<U5>>::Output;
6209
6210 assert_eq!(<U5GcdU5 as Unsigned>::to_u64(), <U5 as Unsigned>::to_u64());
6211 }
6212 #[test]
6213 #[allow(non_snake_case)]
6214 fn test_5_Sub_5() {
6215 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6216 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6217 type U0 = UTerm;
6218
6219 #[allow(non_camel_case_types)]
6220 type U5SubU5 = <<A as Sub<B>>::Output as Same<U0>>::Output;
6221
6222 assert_eq!(<U5SubU5 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
6223 }
6224 #[test]
6225 #[allow(non_snake_case)]
6226 fn test_5_Div_5() {
6227 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6228 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6229 type U1 = UInt<UTerm, B1>;
6230
6231 #[allow(non_camel_case_types)]
6232 type U5DivU5 = <<A as Div<B>>::Output as Same<U1>>::Output;
6233
6234 assert_eq!(<U5DivU5 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
6235 }
6236 #[test]
6237 #[allow(non_snake_case)]
6238 fn test_5_Rem_5() {
6239 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6240 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6241 type U0 = UTerm;
6242
6243 #[allow(non_camel_case_types)]
6244 type U5RemU5 = <<A as Rem<B>>::Output as Same<U0>>::Output;
6245
6246 assert_eq!(<U5RemU5 as Unsigned>::to_u64(), <U0 as Unsigned>::to_u64());
6247 }
6248 #[test]
6249 #[allow(non_snake_case)]
6250 fn test_5_PartialDiv_5() {
6251 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6252 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6253 type U1 = UInt<UTerm, B1>;
6254
6255 #[allow(non_camel_case_types)]
6256 type U5PartialDivU5 = <<A as PartialDiv<B>>::Output as Same<U1>>::Output;
6257
6258 assert_eq!(<U5PartialDivU5 as Unsigned>::to_u64(), <U1 as Unsigned>::to_u64());
6259 }
6260 #[test]
6261 #[allow(non_snake_case)]
6262 fn test_5_Cmp_5() {
6263 type A = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6264 type B = UInt<UInt<UInt<UTerm, B1>, B0>, B1>;
6265
6266 #[allow(non_camel_case_types)]
6267 type U5CmpU5 = <A as Cmp<B>>::Output;
6268 assert_eq!(<U5CmpU5 as Ord>::to_ordering(), Ordering::Equal);
6269 }
6270 #[test]
6271 #[allow(non_snake_case)]
6272 fn test_N5_Add_N5() {
6273 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6274 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6275 type N10 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>;
6276
6277 #[allow(non_camel_case_types)]
6278 type N5AddN5 = <<A as Add<B>>::Output as Same<N10>>::Output;
6279
6280 assert_eq!(<N5AddN5 as Integer>::to_i64(), <N10 as Integer>::to_i64());
6281 }
6282 #[test]
6283 #[allow(non_snake_case)]
6284 fn test_N5_Sub_N5() {
6285 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6286 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6287 type _0 = Z0;
6288
6289 #[allow(non_camel_case_types)]
6290 type N5SubN5 = <<A as Sub<B>>::Output as Same<_0>>::Output;
6291
6292 assert_eq!(<N5SubN5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
6293 }
6294 #[test]
6295 #[allow(non_snake_case)]
6296 fn test_N5_Mul_N5() {
6297 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6298 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6299 type P25 = PInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>>;
6300
6301 #[allow(non_camel_case_types)]
6302 type N5MulN5 = <<A as Mul<B>>::Output as Same<P25>>::Output;
6303
6304 assert_eq!(<N5MulN5 as Integer>::to_i64(), <P25 as Integer>::to_i64());
6305 }
6306 #[test]
6307 #[allow(non_snake_case)]
6308 fn test_N5_Min_N5() {
6309 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6310 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6311 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6312
6313 #[allow(non_camel_case_types)]
6314 type N5MinN5 = <<A as Min<B>>::Output as Same<N5>>::Output;
6315
6316 assert_eq!(<N5MinN5 as Integer>::to_i64(), <N5 as Integer>::to_i64());
6317 }
6318 #[test]
6319 #[allow(non_snake_case)]
6320 fn test_N5_Max_N5() {
6321 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6322 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6323 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6324
6325 #[allow(non_camel_case_types)]
6326 type N5MaxN5 = <<A as Max<B>>::Output as Same<N5>>::Output;
6327
6328 assert_eq!(<N5MaxN5 as Integer>::to_i64(), <N5 as Integer>::to_i64());
6329 }
6330 #[test]
6331 #[allow(non_snake_case)]
6332 fn test_N5_Gcd_N5() {
6333 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6334 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6335 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6336
6337 #[allow(non_camel_case_types)]
6338 type N5GcdN5 = <<A as Gcd<B>>::Output as Same<P5>>::Output;
6339
6340 assert_eq!(<N5GcdN5 as Integer>::to_i64(), <P5 as Integer>::to_i64());
6341 }
6342 #[test]
6343 #[allow(non_snake_case)]
6344 fn test_N5_Div_N5() {
6345 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6346 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6347 type P1 = PInt<UInt<UTerm, B1>>;
6348
6349 #[allow(non_camel_case_types)]
6350 type N5DivN5 = <<A as Div<B>>::Output as Same<P1>>::Output;
6351
6352 assert_eq!(<N5DivN5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
6353 }
6354 #[test]
6355 #[allow(non_snake_case)]
6356 fn test_N5_Rem_N5() {
6357 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6358 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6359 type _0 = Z0;
6360
6361 #[allow(non_camel_case_types)]
6362 type N5RemN5 = <<A as Rem<B>>::Output as Same<_0>>::Output;
6363
6364 assert_eq!(<N5RemN5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
6365 }
6366 #[test]
6367 #[allow(non_snake_case)]
6368 fn test_N5_PartialDiv_N5() {
6369 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6370 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6371 type P1 = PInt<UInt<UTerm, B1>>;
6372
6373 #[allow(non_camel_case_types)]
6374 type N5PartialDivN5 = <<A as PartialDiv<B>>::Output as Same<P1>>::Output;
6375
6376 assert_eq!(<N5PartialDivN5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
6377 }
6378 #[test]
6379 #[allow(non_snake_case)]
6380 fn test_N5_Cmp_N5() {
6381 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6382 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6383
6384 #[allow(non_camel_case_types)]
6385 type N5CmpN5 = <A as Cmp<B>>::Output;
6386 assert_eq!(<N5CmpN5 as Ord>::to_ordering(), Ordering::Equal);
6387 }
6388 #[test]
6389 #[allow(non_snake_case)]
6390 fn test_N5_Add_N4() {
6391 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6392 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
6393 type N9 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>>;
6394
6395 #[allow(non_camel_case_types)]
6396 type N5AddN4 = <<A as Add<B>>::Output as Same<N9>>::Output;
6397
6398 assert_eq!(<N5AddN4 as Integer>::to_i64(), <N9 as Integer>::to_i64());
6399 }
6400 #[test]
6401 #[allow(non_snake_case)]
6402 fn test_N5_Sub_N4() {
6403 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6404 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
6405 type N1 = NInt<UInt<UTerm, B1>>;
6406
6407 #[allow(non_camel_case_types)]
6408 type N5SubN4 = <<A as Sub<B>>::Output as Same<N1>>::Output;
6409
6410 assert_eq!(<N5SubN4 as Integer>::to_i64(), <N1 as Integer>::to_i64());
6411 }
6412 #[test]
6413 #[allow(non_snake_case)]
6414 fn test_N5_Mul_N4() {
6415 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6416 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
6417 type P20 = PInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>>;
6418
6419 #[allow(non_camel_case_types)]
6420 type N5MulN4 = <<A as Mul<B>>::Output as Same<P20>>::Output;
6421
6422 assert_eq!(<N5MulN4 as Integer>::to_i64(), <P20 as Integer>::to_i64());
6423 }
6424 #[test]
6425 #[allow(non_snake_case)]
6426 fn test_N5_Min_N4() {
6427 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6428 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
6429 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6430
6431 #[allow(non_camel_case_types)]
6432 type N5MinN4 = <<A as Min<B>>::Output as Same<N5>>::Output;
6433
6434 assert_eq!(<N5MinN4 as Integer>::to_i64(), <N5 as Integer>::to_i64());
6435 }
6436 #[test]
6437 #[allow(non_snake_case)]
6438 fn test_N5_Max_N4() {
6439 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6440 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
6441 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
6442
6443 #[allow(non_camel_case_types)]
6444 type N5MaxN4 = <<A as Max<B>>::Output as Same<N4>>::Output;
6445
6446 assert_eq!(<N5MaxN4 as Integer>::to_i64(), <N4 as Integer>::to_i64());
6447 }
6448 #[test]
6449 #[allow(non_snake_case)]
6450 fn test_N5_Gcd_N4() {
6451 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6452 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
6453 type P1 = PInt<UInt<UTerm, B1>>;
6454
6455 #[allow(non_camel_case_types)]
6456 type N5GcdN4 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
6457
6458 assert_eq!(<N5GcdN4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
6459 }
6460 #[test]
6461 #[allow(non_snake_case)]
6462 fn test_N5_Div_N4() {
6463 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6464 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
6465 type P1 = PInt<UInt<UTerm, B1>>;
6466
6467 #[allow(non_camel_case_types)]
6468 type N5DivN4 = <<A as Div<B>>::Output as Same<P1>>::Output;
6469
6470 assert_eq!(<N5DivN4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
6471 }
6472 #[test]
6473 #[allow(non_snake_case)]
6474 fn test_N5_Rem_N4() {
6475 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6476 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
6477 type N1 = NInt<UInt<UTerm, B1>>;
6478
6479 #[allow(non_camel_case_types)]
6480 type N5RemN4 = <<A as Rem<B>>::Output as Same<N1>>::Output;
6481
6482 assert_eq!(<N5RemN4 as Integer>::to_i64(), <N1 as Integer>::to_i64());
6483 }
6484 #[test]
6485 #[allow(non_snake_case)]
6486 fn test_N5_Cmp_N4() {
6487 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6488 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
6489
6490 #[allow(non_camel_case_types)]
6491 type N5CmpN4 = <A as Cmp<B>>::Output;
6492 assert_eq!(<N5CmpN4 as Ord>::to_ordering(), Ordering::Less);
6493 }
6494 #[test]
6495 #[allow(non_snake_case)]
6496 fn test_N5_Add_N3() {
6497 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6498 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
6499 type N8 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>;
6500
6501 #[allow(non_camel_case_types)]
6502 type N5AddN3 = <<A as Add<B>>::Output as Same<N8>>::Output;
6503
6504 assert_eq!(<N5AddN3 as Integer>::to_i64(), <N8 as Integer>::to_i64());
6505 }
6506 #[test]
6507 #[allow(non_snake_case)]
6508 fn test_N5_Sub_N3() {
6509 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6510 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
6511 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
6512
6513 #[allow(non_camel_case_types)]
6514 type N5SubN3 = <<A as Sub<B>>::Output as Same<N2>>::Output;
6515
6516 assert_eq!(<N5SubN3 as Integer>::to_i64(), <N2 as Integer>::to_i64());
6517 }
6518 #[test]
6519 #[allow(non_snake_case)]
6520 fn test_N5_Mul_N3() {
6521 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6522 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
6523 type P15 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>;
6524
6525 #[allow(non_camel_case_types)]
6526 type N5MulN3 = <<A as Mul<B>>::Output as Same<P15>>::Output;
6527
6528 assert_eq!(<N5MulN3 as Integer>::to_i64(), <P15 as Integer>::to_i64());
6529 }
6530 #[test]
6531 #[allow(non_snake_case)]
6532 fn test_N5_Min_N3() {
6533 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6534 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
6535 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6536
6537 #[allow(non_camel_case_types)]
6538 type N5MinN3 = <<A as Min<B>>::Output as Same<N5>>::Output;
6539
6540 assert_eq!(<N5MinN3 as Integer>::to_i64(), <N5 as Integer>::to_i64());
6541 }
6542 #[test]
6543 #[allow(non_snake_case)]
6544 fn test_N5_Max_N3() {
6545 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6546 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
6547 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
6548
6549 #[allow(non_camel_case_types)]
6550 type N5MaxN3 = <<A as Max<B>>::Output as Same<N3>>::Output;
6551
6552 assert_eq!(<N5MaxN3 as Integer>::to_i64(), <N3 as Integer>::to_i64());
6553 }
6554 #[test]
6555 #[allow(non_snake_case)]
6556 fn test_N5_Gcd_N3() {
6557 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6558 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
6559 type P1 = PInt<UInt<UTerm, B1>>;
6560
6561 #[allow(non_camel_case_types)]
6562 type N5GcdN3 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
6563
6564 assert_eq!(<N5GcdN3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
6565 }
6566 #[test]
6567 #[allow(non_snake_case)]
6568 fn test_N5_Div_N3() {
6569 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6570 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
6571 type P1 = PInt<UInt<UTerm, B1>>;
6572
6573 #[allow(non_camel_case_types)]
6574 type N5DivN3 = <<A as Div<B>>::Output as Same<P1>>::Output;
6575
6576 assert_eq!(<N5DivN3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
6577 }
6578 #[test]
6579 #[allow(non_snake_case)]
6580 fn test_N5_Rem_N3() {
6581 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6582 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
6583 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
6584
6585 #[allow(non_camel_case_types)]
6586 type N5RemN3 = <<A as Rem<B>>::Output as Same<N2>>::Output;
6587
6588 assert_eq!(<N5RemN3 as Integer>::to_i64(), <N2 as Integer>::to_i64());
6589 }
6590 #[test]
6591 #[allow(non_snake_case)]
6592 fn test_N5_Cmp_N3() {
6593 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6594 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
6595
6596 #[allow(non_camel_case_types)]
6597 type N5CmpN3 = <A as Cmp<B>>::Output;
6598 assert_eq!(<N5CmpN3 as Ord>::to_ordering(), Ordering::Less);
6599 }
6600 #[test]
6601 #[allow(non_snake_case)]
6602 fn test_N5_Add_N2() {
6603 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6604 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
6605 type N7 = NInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>>;
6606
6607 #[allow(non_camel_case_types)]
6608 type N5AddN2 = <<A as Add<B>>::Output as Same<N7>>::Output;
6609
6610 assert_eq!(<N5AddN2 as Integer>::to_i64(), <N7 as Integer>::to_i64());
6611 }
6612 #[test]
6613 #[allow(non_snake_case)]
6614 fn test_N5_Sub_N2() {
6615 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6616 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
6617 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
6618
6619 #[allow(non_camel_case_types)]
6620 type N5SubN2 = <<A as Sub<B>>::Output as Same<N3>>::Output;
6621
6622 assert_eq!(<N5SubN2 as Integer>::to_i64(), <N3 as Integer>::to_i64());
6623 }
6624 #[test]
6625 #[allow(non_snake_case)]
6626 fn test_N5_Mul_N2() {
6627 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6628 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
6629 type P10 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>;
6630
6631 #[allow(non_camel_case_types)]
6632 type N5MulN2 = <<A as Mul<B>>::Output as Same<P10>>::Output;
6633
6634 assert_eq!(<N5MulN2 as Integer>::to_i64(), <P10 as Integer>::to_i64());
6635 }
6636 #[test]
6637 #[allow(non_snake_case)]
6638 fn test_N5_Min_N2() {
6639 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6640 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
6641 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6642
6643 #[allow(non_camel_case_types)]
6644 type N5MinN2 = <<A as Min<B>>::Output as Same<N5>>::Output;
6645
6646 assert_eq!(<N5MinN2 as Integer>::to_i64(), <N5 as Integer>::to_i64());
6647 }
6648 #[test]
6649 #[allow(non_snake_case)]
6650 fn test_N5_Max_N2() {
6651 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6652 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
6653 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
6654
6655 #[allow(non_camel_case_types)]
6656 type N5MaxN2 = <<A as Max<B>>::Output as Same<N2>>::Output;
6657
6658 assert_eq!(<N5MaxN2 as Integer>::to_i64(), <N2 as Integer>::to_i64());
6659 }
6660 #[test]
6661 #[allow(non_snake_case)]
6662 fn test_N5_Gcd_N2() {
6663 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6664 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
6665 type P1 = PInt<UInt<UTerm, B1>>;
6666
6667 #[allow(non_camel_case_types)]
6668 type N5GcdN2 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
6669
6670 assert_eq!(<N5GcdN2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
6671 }
6672 #[test]
6673 #[allow(non_snake_case)]
6674 fn test_N5_Div_N2() {
6675 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6676 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
6677 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
6678
6679 #[allow(non_camel_case_types)]
6680 type N5DivN2 = <<A as Div<B>>::Output as Same<P2>>::Output;
6681
6682 assert_eq!(<N5DivN2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
6683 }
6684 #[test]
6685 #[allow(non_snake_case)]
6686 fn test_N5_Rem_N2() {
6687 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6688 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
6689 type N1 = NInt<UInt<UTerm, B1>>;
6690
6691 #[allow(non_camel_case_types)]
6692 type N5RemN2 = <<A as Rem<B>>::Output as Same<N1>>::Output;
6693
6694 assert_eq!(<N5RemN2 as Integer>::to_i64(), <N1 as Integer>::to_i64());
6695 }
6696 #[test]
6697 #[allow(non_snake_case)]
6698 fn test_N5_Cmp_N2() {
6699 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6700 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
6701
6702 #[allow(non_camel_case_types)]
6703 type N5CmpN2 = <A as Cmp<B>>::Output;
6704 assert_eq!(<N5CmpN2 as Ord>::to_ordering(), Ordering::Less);
6705 }
6706 #[test]
6707 #[allow(non_snake_case)]
6708 fn test_N5_Add_N1() {
6709 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6710 type B = NInt<UInt<UTerm, B1>>;
6711 type N6 = NInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
6712
6713 #[allow(non_camel_case_types)]
6714 type N5AddN1 = <<A as Add<B>>::Output as Same<N6>>::Output;
6715
6716 assert_eq!(<N5AddN1 as Integer>::to_i64(), <N6 as Integer>::to_i64());
6717 }
6718 #[test]
6719 #[allow(non_snake_case)]
6720 fn test_N5_Sub_N1() {
6721 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6722 type B = NInt<UInt<UTerm, B1>>;
6723 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
6724
6725 #[allow(non_camel_case_types)]
6726 type N5SubN1 = <<A as Sub<B>>::Output as Same<N4>>::Output;
6727
6728 assert_eq!(<N5SubN1 as Integer>::to_i64(), <N4 as Integer>::to_i64());
6729 }
6730 #[test]
6731 #[allow(non_snake_case)]
6732 fn test_N5_Mul_N1() {
6733 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6734 type B = NInt<UInt<UTerm, B1>>;
6735 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6736
6737 #[allow(non_camel_case_types)]
6738 type N5MulN1 = <<A as Mul<B>>::Output as Same<P5>>::Output;
6739
6740 assert_eq!(<N5MulN1 as Integer>::to_i64(), <P5 as Integer>::to_i64());
6741 }
6742 #[test]
6743 #[allow(non_snake_case)]
6744 fn test_N5_Min_N1() {
6745 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6746 type B = NInt<UInt<UTerm, B1>>;
6747 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6748
6749 #[allow(non_camel_case_types)]
6750 type N5MinN1 = <<A as Min<B>>::Output as Same<N5>>::Output;
6751
6752 assert_eq!(<N5MinN1 as Integer>::to_i64(), <N5 as Integer>::to_i64());
6753 }
6754 #[test]
6755 #[allow(non_snake_case)]
6756 fn test_N5_Max_N1() {
6757 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6758 type B = NInt<UInt<UTerm, B1>>;
6759 type N1 = NInt<UInt<UTerm, B1>>;
6760
6761 #[allow(non_camel_case_types)]
6762 type N5MaxN1 = <<A as Max<B>>::Output as Same<N1>>::Output;
6763
6764 assert_eq!(<N5MaxN1 as Integer>::to_i64(), <N1 as Integer>::to_i64());
6765 }
6766 #[test]
6767 #[allow(non_snake_case)]
6768 fn test_N5_Gcd_N1() {
6769 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6770 type B = NInt<UInt<UTerm, B1>>;
6771 type P1 = PInt<UInt<UTerm, B1>>;
6772
6773 #[allow(non_camel_case_types)]
6774 type N5GcdN1 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
6775
6776 assert_eq!(<N5GcdN1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
6777 }
6778 #[test]
6779 #[allow(non_snake_case)]
6780 fn test_N5_Div_N1() {
6781 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6782 type B = NInt<UInt<UTerm, B1>>;
6783 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6784
6785 #[allow(non_camel_case_types)]
6786 type N5DivN1 = <<A as Div<B>>::Output as Same<P5>>::Output;
6787
6788 assert_eq!(<N5DivN1 as Integer>::to_i64(), <P5 as Integer>::to_i64());
6789 }
6790 #[test]
6791 #[allow(non_snake_case)]
6792 fn test_N5_Rem_N1() {
6793 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6794 type B = NInt<UInt<UTerm, B1>>;
6795 type _0 = Z0;
6796
6797 #[allow(non_camel_case_types)]
6798 type N5RemN1 = <<A as Rem<B>>::Output as Same<_0>>::Output;
6799
6800 assert_eq!(<N5RemN1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
6801 }
6802 #[test]
6803 #[allow(non_snake_case)]
6804 fn test_N5_PartialDiv_N1() {
6805 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6806 type B = NInt<UInt<UTerm, B1>>;
6807 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6808
6809 #[allow(non_camel_case_types)]
6810 type N5PartialDivN1 = <<A as PartialDiv<B>>::Output as Same<P5>>::Output;
6811
6812 assert_eq!(<N5PartialDivN1 as Integer>::to_i64(), <P5 as Integer>::to_i64());
6813 }
6814 #[test]
6815 #[allow(non_snake_case)]
6816 fn test_N5_Cmp_N1() {
6817 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6818 type B = NInt<UInt<UTerm, B1>>;
6819
6820 #[allow(non_camel_case_types)]
6821 type N5CmpN1 = <A as Cmp<B>>::Output;
6822 assert_eq!(<N5CmpN1 as Ord>::to_ordering(), Ordering::Less);
6823 }
6824 #[test]
6825 #[allow(non_snake_case)]
6826 fn test_N5_Add__0() {
6827 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6828 type B = Z0;
6829 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6830
6831 #[allow(non_camel_case_types)]
6832 type N5Add_0 = <<A as Add<B>>::Output as Same<N5>>::Output;
6833
6834 assert_eq!(<N5Add_0 as Integer>::to_i64(), <N5 as Integer>::to_i64());
6835 }
6836 #[test]
6837 #[allow(non_snake_case)]
6838 fn test_N5_Sub__0() {
6839 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6840 type B = Z0;
6841 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6842
6843 #[allow(non_camel_case_types)]
6844 type N5Sub_0 = <<A as Sub<B>>::Output as Same<N5>>::Output;
6845
6846 assert_eq!(<N5Sub_0 as Integer>::to_i64(), <N5 as Integer>::to_i64());
6847 }
6848 #[test]
6849 #[allow(non_snake_case)]
6850 fn test_N5_Mul__0() {
6851 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6852 type B = Z0;
6853 type _0 = Z0;
6854
6855 #[allow(non_camel_case_types)]
6856 type N5Mul_0 = <<A as Mul<B>>::Output as Same<_0>>::Output;
6857
6858 assert_eq!(<N5Mul_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
6859 }
6860 #[test]
6861 #[allow(non_snake_case)]
6862 fn test_N5_Min__0() {
6863 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6864 type B = Z0;
6865 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6866
6867 #[allow(non_camel_case_types)]
6868 type N5Min_0 = <<A as Min<B>>::Output as Same<N5>>::Output;
6869
6870 assert_eq!(<N5Min_0 as Integer>::to_i64(), <N5 as Integer>::to_i64());
6871 }
6872 #[test]
6873 #[allow(non_snake_case)]
6874 fn test_N5_Max__0() {
6875 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6876 type B = Z0;
6877 type _0 = Z0;
6878
6879 #[allow(non_camel_case_types)]
6880 type N5Max_0 = <<A as Max<B>>::Output as Same<_0>>::Output;
6881
6882 assert_eq!(<N5Max_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
6883 }
6884 #[test]
6885 #[allow(non_snake_case)]
6886 fn test_N5_Gcd__0() {
6887 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6888 type B = Z0;
6889 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6890
6891 #[allow(non_camel_case_types)]
6892 type N5Gcd_0 = <<A as Gcd<B>>::Output as Same<P5>>::Output;
6893
6894 assert_eq!(<N5Gcd_0 as Integer>::to_i64(), <P5 as Integer>::to_i64());
6895 }
6896 #[test]
6897 #[allow(non_snake_case)]
6898 fn test_N5_Pow__0() {
6899 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6900 type B = Z0;
6901 type P1 = PInt<UInt<UTerm, B1>>;
6902
6903 #[allow(non_camel_case_types)]
6904 type N5Pow_0 = <<A as Pow<B>>::Output as Same<P1>>::Output;
6905
6906 assert_eq!(<N5Pow_0 as Integer>::to_i64(), <P1 as Integer>::to_i64());
6907 }
6908 #[test]
6909 #[allow(non_snake_case)]
6910 fn test_N5_Cmp__0() {
6911 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6912 type B = Z0;
6913
6914 #[allow(non_camel_case_types)]
6915 type N5Cmp_0 = <A as Cmp<B>>::Output;
6916 assert_eq!(<N5Cmp_0 as Ord>::to_ordering(), Ordering::Less);
6917 }
6918 #[test]
6919 #[allow(non_snake_case)]
6920 fn test_N5_Add_P1() {
6921 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6922 type B = PInt<UInt<UTerm, B1>>;
6923 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
6924
6925 #[allow(non_camel_case_types)]
6926 type N5AddP1 = <<A as Add<B>>::Output as Same<N4>>::Output;
6927
6928 assert_eq!(<N5AddP1 as Integer>::to_i64(), <N4 as Integer>::to_i64());
6929 }
6930 #[test]
6931 #[allow(non_snake_case)]
6932 fn test_N5_Sub_P1() {
6933 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6934 type B = PInt<UInt<UTerm, B1>>;
6935 type N6 = NInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
6936
6937 #[allow(non_camel_case_types)]
6938 type N5SubP1 = <<A as Sub<B>>::Output as Same<N6>>::Output;
6939
6940 assert_eq!(<N5SubP1 as Integer>::to_i64(), <N6 as Integer>::to_i64());
6941 }
6942 #[test]
6943 #[allow(non_snake_case)]
6944 fn test_N5_Mul_P1() {
6945 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6946 type B = PInt<UInt<UTerm, B1>>;
6947 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6948
6949 #[allow(non_camel_case_types)]
6950 type N5MulP1 = <<A as Mul<B>>::Output as Same<N5>>::Output;
6951
6952 assert_eq!(<N5MulP1 as Integer>::to_i64(), <N5 as Integer>::to_i64());
6953 }
6954 #[test]
6955 #[allow(non_snake_case)]
6956 fn test_N5_Min_P1() {
6957 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6958 type B = PInt<UInt<UTerm, B1>>;
6959 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6960
6961 #[allow(non_camel_case_types)]
6962 type N5MinP1 = <<A as Min<B>>::Output as Same<N5>>::Output;
6963
6964 assert_eq!(<N5MinP1 as Integer>::to_i64(), <N5 as Integer>::to_i64());
6965 }
6966 #[test]
6967 #[allow(non_snake_case)]
6968 fn test_N5_Max_P1() {
6969 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6970 type B = PInt<UInt<UTerm, B1>>;
6971 type P1 = PInt<UInt<UTerm, B1>>;
6972
6973 #[allow(non_camel_case_types)]
6974 type N5MaxP1 = <<A as Max<B>>::Output as Same<P1>>::Output;
6975
6976 assert_eq!(<N5MaxP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
6977 }
6978 #[test]
6979 #[allow(non_snake_case)]
6980 fn test_N5_Gcd_P1() {
6981 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6982 type B = PInt<UInt<UTerm, B1>>;
6983 type P1 = PInt<UInt<UTerm, B1>>;
6984
6985 #[allow(non_camel_case_types)]
6986 type N5GcdP1 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
6987
6988 assert_eq!(<N5GcdP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
6989 }
6990 #[test]
6991 #[allow(non_snake_case)]
6992 fn test_N5_Div_P1() {
6993 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6994 type B = PInt<UInt<UTerm, B1>>;
6995 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
6996
6997 #[allow(non_camel_case_types)]
6998 type N5DivP1 = <<A as Div<B>>::Output as Same<N5>>::Output;
6999
7000 assert_eq!(<N5DivP1 as Integer>::to_i64(), <N5 as Integer>::to_i64());
7001 }
7002 #[test]
7003 #[allow(non_snake_case)]
7004 fn test_N5_Rem_P1() {
7005 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7006 type B = PInt<UInt<UTerm, B1>>;
7007 type _0 = Z0;
7008
7009 #[allow(non_camel_case_types)]
7010 type N5RemP1 = <<A as Rem<B>>::Output as Same<_0>>::Output;
7011
7012 assert_eq!(<N5RemP1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
7013 }
7014 #[test]
7015 #[allow(non_snake_case)]
7016 fn test_N5_PartialDiv_P1() {
7017 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7018 type B = PInt<UInt<UTerm, B1>>;
7019 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7020
7021 #[allow(non_camel_case_types)]
7022 type N5PartialDivP1 = <<A as PartialDiv<B>>::Output as Same<N5>>::Output;
7023
7024 assert_eq!(<N5PartialDivP1 as Integer>::to_i64(), <N5 as Integer>::to_i64());
7025 }
7026 #[test]
7027 #[allow(non_snake_case)]
7028 fn test_N5_Pow_P1() {
7029 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7030 type B = PInt<UInt<UTerm, B1>>;
7031 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7032
7033 #[allow(non_camel_case_types)]
7034 type N5PowP1 = <<A as Pow<B>>::Output as Same<N5>>::Output;
7035
7036 assert_eq!(<N5PowP1 as Integer>::to_i64(), <N5 as Integer>::to_i64());
7037 }
7038 #[test]
7039 #[allow(non_snake_case)]
7040 fn test_N5_Cmp_P1() {
7041 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7042 type B = PInt<UInt<UTerm, B1>>;
7043
7044 #[allow(non_camel_case_types)]
7045 type N5CmpP1 = <A as Cmp<B>>::Output;
7046 assert_eq!(<N5CmpP1 as Ord>::to_ordering(), Ordering::Less);
7047 }
7048 #[test]
7049 #[allow(non_snake_case)]
7050 fn test_N5_Add_P2() {
7051 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7052 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
7053 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
7054
7055 #[allow(non_camel_case_types)]
7056 type N5AddP2 = <<A as Add<B>>::Output as Same<N3>>::Output;
7057
7058 assert_eq!(<N5AddP2 as Integer>::to_i64(), <N3 as Integer>::to_i64());
7059 }
7060 #[test]
7061 #[allow(non_snake_case)]
7062 fn test_N5_Sub_P2() {
7063 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7064 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
7065 type N7 = NInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>>;
7066
7067 #[allow(non_camel_case_types)]
7068 type N5SubP2 = <<A as Sub<B>>::Output as Same<N7>>::Output;
7069
7070 assert_eq!(<N5SubP2 as Integer>::to_i64(), <N7 as Integer>::to_i64());
7071 }
7072 #[test]
7073 #[allow(non_snake_case)]
7074 fn test_N5_Mul_P2() {
7075 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7076 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
7077 type N10 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>;
7078
7079 #[allow(non_camel_case_types)]
7080 type N5MulP2 = <<A as Mul<B>>::Output as Same<N10>>::Output;
7081
7082 assert_eq!(<N5MulP2 as Integer>::to_i64(), <N10 as Integer>::to_i64());
7083 }
7084 #[test]
7085 #[allow(non_snake_case)]
7086 fn test_N5_Min_P2() {
7087 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7088 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
7089 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7090
7091 #[allow(non_camel_case_types)]
7092 type N5MinP2 = <<A as Min<B>>::Output as Same<N5>>::Output;
7093
7094 assert_eq!(<N5MinP2 as Integer>::to_i64(), <N5 as Integer>::to_i64());
7095 }
7096 #[test]
7097 #[allow(non_snake_case)]
7098 fn test_N5_Max_P2() {
7099 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7100 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
7101 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
7102
7103 #[allow(non_camel_case_types)]
7104 type N5MaxP2 = <<A as Max<B>>::Output as Same<P2>>::Output;
7105
7106 assert_eq!(<N5MaxP2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
7107 }
7108 #[test]
7109 #[allow(non_snake_case)]
7110 fn test_N5_Gcd_P2() {
7111 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7112 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
7113 type P1 = PInt<UInt<UTerm, B1>>;
7114
7115 #[allow(non_camel_case_types)]
7116 type N5GcdP2 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
7117
7118 assert_eq!(<N5GcdP2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
7119 }
7120 #[test]
7121 #[allow(non_snake_case)]
7122 fn test_N5_Div_P2() {
7123 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7124 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
7125 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
7126
7127 #[allow(non_camel_case_types)]
7128 type N5DivP2 = <<A as Div<B>>::Output as Same<N2>>::Output;
7129
7130 assert_eq!(<N5DivP2 as Integer>::to_i64(), <N2 as Integer>::to_i64());
7131 }
7132 #[test]
7133 #[allow(non_snake_case)]
7134 fn test_N5_Rem_P2() {
7135 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7136 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
7137 type N1 = NInt<UInt<UTerm, B1>>;
7138
7139 #[allow(non_camel_case_types)]
7140 type N5RemP2 = <<A as Rem<B>>::Output as Same<N1>>::Output;
7141
7142 assert_eq!(<N5RemP2 as Integer>::to_i64(), <N1 as Integer>::to_i64());
7143 }
7144 #[test]
7145 #[allow(non_snake_case)]
7146 fn test_N5_Pow_P2() {
7147 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7148 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
7149 type P25 = PInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>>;
7150
7151 #[allow(non_camel_case_types)]
7152 type N5PowP2 = <<A as Pow<B>>::Output as Same<P25>>::Output;
7153
7154 assert_eq!(<N5PowP2 as Integer>::to_i64(), <P25 as Integer>::to_i64());
7155 }
7156 #[test]
7157 #[allow(non_snake_case)]
7158 fn test_N5_Cmp_P2() {
7159 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7160 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
7161
7162 #[allow(non_camel_case_types)]
7163 type N5CmpP2 = <A as Cmp<B>>::Output;
7164 assert_eq!(<N5CmpP2 as Ord>::to_ordering(), Ordering::Less);
7165 }
7166 #[test]
7167 #[allow(non_snake_case)]
7168 fn test_N5_Add_P3() {
7169 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7170 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
7171 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
7172
7173 #[allow(non_camel_case_types)]
7174 type N5AddP3 = <<A as Add<B>>::Output as Same<N2>>::Output;
7175
7176 assert_eq!(<N5AddP3 as Integer>::to_i64(), <N2 as Integer>::to_i64());
7177 }
7178 #[test]
7179 #[allow(non_snake_case)]
7180 fn test_N5_Sub_P3() {
7181 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7182 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
7183 type N8 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>;
7184
7185 #[allow(non_camel_case_types)]
7186 type N5SubP3 = <<A as Sub<B>>::Output as Same<N8>>::Output;
7187
7188 assert_eq!(<N5SubP3 as Integer>::to_i64(), <N8 as Integer>::to_i64());
7189 }
7190 #[test]
7191 #[allow(non_snake_case)]
7192 fn test_N5_Mul_P3() {
7193 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7194 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
7195 type N15 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>;
7196
7197 #[allow(non_camel_case_types)]
7198 type N5MulP3 = <<A as Mul<B>>::Output as Same<N15>>::Output;
7199
7200 assert_eq!(<N5MulP3 as Integer>::to_i64(), <N15 as Integer>::to_i64());
7201 }
7202 #[test]
7203 #[allow(non_snake_case)]
7204 fn test_N5_Min_P3() {
7205 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7206 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
7207 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7208
7209 #[allow(non_camel_case_types)]
7210 type N5MinP3 = <<A as Min<B>>::Output as Same<N5>>::Output;
7211
7212 assert_eq!(<N5MinP3 as Integer>::to_i64(), <N5 as Integer>::to_i64());
7213 }
7214 #[test]
7215 #[allow(non_snake_case)]
7216 fn test_N5_Max_P3() {
7217 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7218 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
7219 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
7220
7221 #[allow(non_camel_case_types)]
7222 type N5MaxP3 = <<A as Max<B>>::Output as Same<P3>>::Output;
7223
7224 assert_eq!(<N5MaxP3 as Integer>::to_i64(), <P3 as Integer>::to_i64());
7225 }
7226 #[test]
7227 #[allow(non_snake_case)]
7228 fn test_N5_Gcd_P3() {
7229 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7230 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
7231 type P1 = PInt<UInt<UTerm, B1>>;
7232
7233 #[allow(non_camel_case_types)]
7234 type N5GcdP3 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
7235
7236 assert_eq!(<N5GcdP3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
7237 }
7238 #[test]
7239 #[allow(non_snake_case)]
7240 fn test_N5_Div_P3() {
7241 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7242 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
7243 type N1 = NInt<UInt<UTerm, B1>>;
7244
7245 #[allow(non_camel_case_types)]
7246 type N5DivP3 = <<A as Div<B>>::Output as Same<N1>>::Output;
7247
7248 assert_eq!(<N5DivP3 as Integer>::to_i64(), <N1 as Integer>::to_i64());
7249 }
7250 #[test]
7251 #[allow(non_snake_case)]
7252 fn test_N5_Rem_P3() {
7253 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7254 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
7255 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
7256
7257 #[allow(non_camel_case_types)]
7258 type N5RemP3 = <<A as Rem<B>>::Output as Same<N2>>::Output;
7259
7260 assert_eq!(<N5RemP3 as Integer>::to_i64(), <N2 as Integer>::to_i64());
7261 }
7262 #[test]
7263 #[allow(non_snake_case)]
7264 fn test_N5_Pow_P3() {
7265 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7266 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
7267 type N125 = NInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>>;
7268
7269 #[allow(non_camel_case_types)]
7270 type N5PowP3 = <<A as Pow<B>>::Output as Same<N125>>::Output;
7271
7272 assert_eq!(<N5PowP3 as Integer>::to_i64(), <N125 as Integer>::to_i64());
7273 }
7274 #[test]
7275 #[allow(non_snake_case)]
7276 fn test_N5_Cmp_P3() {
7277 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7278 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
7279
7280 #[allow(non_camel_case_types)]
7281 type N5CmpP3 = <A as Cmp<B>>::Output;
7282 assert_eq!(<N5CmpP3 as Ord>::to_ordering(), Ordering::Less);
7283 }
7284 #[test]
7285 #[allow(non_snake_case)]
7286 fn test_N5_Add_P4() {
7287 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7288 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7289 type N1 = NInt<UInt<UTerm, B1>>;
7290
7291 #[allow(non_camel_case_types)]
7292 type N5AddP4 = <<A as Add<B>>::Output as Same<N1>>::Output;
7293
7294 assert_eq!(<N5AddP4 as Integer>::to_i64(), <N1 as Integer>::to_i64());
7295 }
7296 #[test]
7297 #[allow(non_snake_case)]
7298 fn test_N5_Sub_P4() {
7299 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7300 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7301 type N9 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>>;
7302
7303 #[allow(non_camel_case_types)]
7304 type N5SubP4 = <<A as Sub<B>>::Output as Same<N9>>::Output;
7305
7306 assert_eq!(<N5SubP4 as Integer>::to_i64(), <N9 as Integer>::to_i64());
7307 }
7308 #[test]
7309 #[allow(non_snake_case)]
7310 fn test_N5_Mul_P4() {
7311 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7312 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7313 type N20 = NInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>>;
7314
7315 #[allow(non_camel_case_types)]
7316 type N5MulP4 = <<A as Mul<B>>::Output as Same<N20>>::Output;
7317
7318 assert_eq!(<N5MulP4 as Integer>::to_i64(), <N20 as Integer>::to_i64());
7319 }
7320 #[test]
7321 #[allow(non_snake_case)]
7322 fn test_N5_Min_P4() {
7323 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7324 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7325 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7326
7327 #[allow(non_camel_case_types)]
7328 type N5MinP4 = <<A as Min<B>>::Output as Same<N5>>::Output;
7329
7330 assert_eq!(<N5MinP4 as Integer>::to_i64(), <N5 as Integer>::to_i64());
7331 }
7332 #[test]
7333 #[allow(non_snake_case)]
7334 fn test_N5_Max_P4() {
7335 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7336 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7337 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7338
7339 #[allow(non_camel_case_types)]
7340 type N5MaxP4 = <<A as Max<B>>::Output as Same<P4>>::Output;
7341
7342 assert_eq!(<N5MaxP4 as Integer>::to_i64(), <P4 as Integer>::to_i64());
7343 }
7344 #[test]
7345 #[allow(non_snake_case)]
7346 fn test_N5_Gcd_P4() {
7347 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7348 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7349 type P1 = PInt<UInt<UTerm, B1>>;
7350
7351 #[allow(non_camel_case_types)]
7352 type N5GcdP4 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
7353
7354 assert_eq!(<N5GcdP4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
7355 }
7356 #[test]
7357 #[allow(non_snake_case)]
7358 fn test_N5_Div_P4() {
7359 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7360 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7361 type N1 = NInt<UInt<UTerm, B1>>;
7362
7363 #[allow(non_camel_case_types)]
7364 type N5DivP4 = <<A as Div<B>>::Output as Same<N1>>::Output;
7365
7366 assert_eq!(<N5DivP4 as Integer>::to_i64(), <N1 as Integer>::to_i64());
7367 }
7368 #[test]
7369 #[allow(non_snake_case)]
7370 fn test_N5_Rem_P4() {
7371 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7372 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7373 type N1 = NInt<UInt<UTerm, B1>>;
7374
7375 #[allow(non_camel_case_types)]
7376 type N5RemP4 = <<A as Rem<B>>::Output as Same<N1>>::Output;
7377
7378 assert_eq!(<N5RemP4 as Integer>::to_i64(), <N1 as Integer>::to_i64());
7379 }
7380 #[test]
7381 #[allow(non_snake_case)]
7382 fn test_N5_Pow_P4() {
7383 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7384 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7385 type P625 = PInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B1>, B0>, B0>, B0>, B1>>;
7386
7387 #[allow(non_camel_case_types)]
7388 type N5PowP4 = <<A as Pow<B>>::Output as Same<P625>>::Output;
7389
7390 assert_eq!(<N5PowP4 as Integer>::to_i64(), <P625 as Integer>::to_i64());
7391 }
7392 #[test]
7393 #[allow(non_snake_case)]
7394 fn test_N5_Cmp_P4() {
7395 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7396 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7397
7398 #[allow(non_camel_case_types)]
7399 type N5CmpP4 = <A as Cmp<B>>::Output;
7400 assert_eq!(<N5CmpP4 as Ord>::to_ordering(), Ordering::Less);
7401 }
7402 #[test]
7403 #[allow(non_snake_case)]
7404 fn test_N5_Add_P5() {
7405 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7406 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7407 type _0 = Z0;
7408
7409 #[allow(non_camel_case_types)]
7410 type N5AddP5 = <<A as Add<B>>::Output as Same<_0>>::Output;
7411
7412 assert_eq!(<N5AddP5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
7413 }
7414 #[test]
7415 #[allow(non_snake_case)]
7416 fn test_N5_Sub_P5() {
7417 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7418 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7419 type N10 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>;
7420
7421 #[allow(non_camel_case_types)]
7422 type N5SubP5 = <<A as Sub<B>>::Output as Same<N10>>::Output;
7423
7424 assert_eq!(<N5SubP5 as Integer>::to_i64(), <N10 as Integer>::to_i64());
7425 }
7426 #[test]
7427 #[allow(non_snake_case)]
7428 fn test_N5_Mul_P5() {
7429 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7430 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7431 type N25 = NInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>>;
7432
7433 #[allow(non_camel_case_types)]
7434 type N5MulP5 = <<A as Mul<B>>::Output as Same<N25>>::Output;
7435
7436 assert_eq!(<N5MulP5 as Integer>::to_i64(), <N25 as Integer>::to_i64());
7437 }
7438 #[test]
7439 #[allow(non_snake_case)]
7440 fn test_N5_Min_P5() {
7441 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7442 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7443 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7444
7445 #[allow(non_camel_case_types)]
7446 type N5MinP5 = <<A as Min<B>>::Output as Same<N5>>::Output;
7447
7448 assert_eq!(<N5MinP5 as Integer>::to_i64(), <N5 as Integer>::to_i64());
7449 }
7450 #[test]
7451 #[allow(non_snake_case)]
7452 fn test_N5_Max_P5() {
7453 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7454 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7455 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7456
7457 #[allow(non_camel_case_types)]
7458 type N5MaxP5 = <<A as Max<B>>::Output as Same<P5>>::Output;
7459
7460 assert_eq!(<N5MaxP5 as Integer>::to_i64(), <P5 as Integer>::to_i64());
7461 }
7462 #[test]
7463 #[allow(non_snake_case)]
7464 fn test_N5_Gcd_P5() {
7465 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7466 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7467 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7468
7469 #[allow(non_camel_case_types)]
7470 type N5GcdP5 = <<A as Gcd<B>>::Output as Same<P5>>::Output;
7471
7472 assert_eq!(<N5GcdP5 as Integer>::to_i64(), <P5 as Integer>::to_i64());
7473 }
7474 #[test]
7475 #[allow(non_snake_case)]
7476 fn test_N5_Div_P5() {
7477 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7478 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7479 type N1 = NInt<UInt<UTerm, B1>>;
7480
7481 #[allow(non_camel_case_types)]
7482 type N5DivP5 = <<A as Div<B>>::Output as Same<N1>>::Output;
7483
7484 assert_eq!(<N5DivP5 as Integer>::to_i64(), <N1 as Integer>::to_i64());
7485 }
7486 #[test]
7487 #[allow(non_snake_case)]
7488 fn test_N5_Rem_P5() {
7489 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7490 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7491 type _0 = Z0;
7492
7493 #[allow(non_camel_case_types)]
7494 type N5RemP5 = <<A as Rem<B>>::Output as Same<_0>>::Output;
7495
7496 assert_eq!(<N5RemP5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
7497 }
7498 #[test]
7499 #[allow(non_snake_case)]
7500 fn test_N5_PartialDiv_P5() {
7501 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7502 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7503 type N1 = NInt<UInt<UTerm, B1>>;
7504
7505 #[allow(non_camel_case_types)]
7506 type N5PartialDivP5 = <<A as PartialDiv<B>>::Output as Same<N1>>::Output;
7507
7508 assert_eq!(<N5PartialDivP5 as Integer>::to_i64(), <N1 as Integer>::to_i64());
7509 }
7510 #[test]
7511 #[allow(non_snake_case)]
7512 fn test_N5_Pow_P5() {
7513 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7514 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7515 type N3125 = NInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>, B1>, B1>, B0>, B1>, B0>, B1>>;
7516
7517 #[allow(non_camel_case_types)]
7518 type N5PowP5 = <<A as Pow<B>>::Output as Same<N3125>>::Output;
7519
7520 assert_eq!(<N5PowP5 as Integer>::to_i64(), <N3125 as Integer>::to_i64());
7521 }
7522 #[test]
7523 #[allow(non_snake_case)]
7524 fn test_N5_Cmp_P5() {
7525 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7526 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7527
7528 #[allow(non_camel_case_types)]
7529 type N5CmpP5 = <A as Cmp<B>>::Output;
7530 assert_eq!(<N5CmpP5 as Ord>::to_ordering(), Ordering::Less);
7531 }
7532 #[test]
7533 #[allow(non_snake_case)]
7534 fn test_N4_Add_N5() {
7535 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7536 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7537 type N9 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>>;
7538
7539 #[allow(non_camel_case_types)]
7540 type N4AddN5 = <<A as Add<B>>::Output as Same<N9>>::Output;
7541
7542 assert_eq!(<N4AddN5 as Integer>::to_i64(), <N9 as Integer>::to_i64());
7543 }
7544 #[test]
7545 #[allow(non_snake_case)]
7546 fn test_N4_Sub_N5() {
7547 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7548 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7549 type P1 = PInt<UInt<UTerm, B1>>;
7550
7551 #[allow(non_camel_case_types)]
7552 type N4SubN5 = <<A as Sub<B>>::Output as Same<P1>>::Output;
7553
7554 assert_eq!(<N4SubN5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
7555 }
7556 #[test]
7557 #[allow(non_snake_case)]
7558 fn test_N4_Mul_N5() {
7559 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7560 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7561 type P20 = PInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>>;
7562
7563 #[allow(non_camel_case_types)]
7564 type N4MulN5 = <<A as Mul<B>>::Output as Same<P20>>::Output;
7565
7566 assert_eq!(<N4MulN5 as Integer>::to_i64(), <P20 as Integer>::to_i64());
7567 }
7568 #[test]
7569 #[allow(non_snake_case)]
7570 fn test_N4_Min_N5() {
7571 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7572 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7573 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7574
7575 #[allow(non_camel_case_types)]
7576 type N4MinN5 = <<A as Min<B>>::Output as Same<N5>>::Output;
7577
7578 assert_eq!(<N4MinN5 as Integer>::to_i64(), <N5 as Integer>::to_i64());
7579 }
7580 #[test]
7581 #[allow(non_snake_case)]
7582 fn test_N4_Max_N5() {
7583 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7584 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7585 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7586
7587 #[allow(non_camel_case_types)]
7588 type N4MaxN5 = <<A as Max<B>>::Output as Same<N4>>::Output;
7589
7590 assert_eq!(<N4MaxN5 as Integer>::to_i64(), <N4 as Integer>::to_i64());
7591 }
7592 #[test]
7593 #[allow(non_snake_case)]
7594 fn test_N4_Gcd_N5() {
7595 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7596 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7597 type P1 = PInt<UInt<UTerm, B1>>;
7598
7599 #[allow(non_camel_case_types)]
7600 type N4GcdN5 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
7601
7602 assert_eq!(<N4GcdN5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
7603 }
7604 #[test]
7605 #[allow(non_snake_case)]
7606 fn test_N4_Div_N5() {
7607 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7608 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7609 type _0 = Z0;
7610
7611 #[allow(non_camel_case_types)]
7612 type N4DivN5 = <<A as Div<B>>::Output as Same<_0>>::Output;
7613
7614 assert_eq!(<N4DivN5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
7615 }
7616 #[test]
7617 #[allow(non_snake_case)]
7618 fn test_N4_Rem_N5() {
7619 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7620 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7621 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7622
7623 #[allow(non_camel_case_types)]
7624 type N4RemN5 = <<A as Rem<B>>::Output as Same<N4>>::Output;
7625
7626 assert_eq!(<N4RemN5 as Integer>::to_i64(), <N4 as Integer>::to_i64());
7627 }
7628 #[test]
7629 #[allow(non_snake_case)]
7630 fn test_N4_Cmp_N5() {
7631 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7632 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7633
7634 #[allow(non_camel_case_types)]
7635 type N4CmpN5 = <A as Cmp<B>>::Output;
7636 assert_eq!(<N4CmpN5 as Ord>::to_ordering(), Ordering::Greater);
7637 }
7638 #[test]
7639 #[allow(non_snake_case)]
7640 fn test_N4_Add_N4() {
7641 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7642 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7643 type N8 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>;
7644
7645 #[allow(non_camel_case_types)]
7646 type N4AddN4 = <<A as Add<B>>::Output as Same<N8>>::Output;
7647
7648 assert_eq!(<N4AddN4 as Integer>::to_i64(), <N8 as Integer>::to_i64());
7649 }
7650 #[test]
7651 #[allow(non_snake_case)]
7652 fn test_N4_Sub_N4() {
7653 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7654 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7655 type _0 = Z0;
7656
7657 #[allow(non_camel_case_types)]
7658 type N4SubN4 = <<A as Sub<B>>::Output as Same<_0>>::Output;
7659
7660 assert_eq!(<N4SubN4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
7661 }
7662 #[test]
7663 #[allow(non_snake_case)]
7664 fn test_N4_Mul_N4() {
7665 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7666 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7667 type P16 = PInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>>;
7668
7669 #[allow(non_camel_case_types)]
7670 type N4MulN4 = <<A as Mul<B>>::Output as Same<P16>>::Output;
7671
7672 assert_eq!(<N4MulN4 as Integer>::to_i64(), <P16 as Integer>::to_i64());
7673 }
7674 #[test]
7675 #[allow(non_snake_case)]
7676 fn test_N4_Min_N4() {
7677 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7678 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7679 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7680
7681 #[allow(non_camel_case_types)]
7682 type N4MinN4 = <<A as Min<B>>::Output as Same<N4>>::Output;
7683
7684 assert_eq!(<N4MinN4 as Integer>::to_i64(), <N4 as Integer>::to_i64());
7685 }
7686 #[test]
7687 #[allow(non_snake_case)]
7688 fn test_N4_Max_N4() {
7689 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7690 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7691 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7692
7693 #[allow(non_camel_case_types)]
7694 type N4MaxN4 = <<A as Max<B>>::Output as Same<N4>>::Output;
7695
7696 assert_eq!(<N4MaxN4 as Integer>::to_i64(), <N4 as Integer>::to_i64());
7697 }
7698 #[test]
7699 #[allow(non_snake_case)]
7700 fn test_N4_Gcd_N4() {
7701 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7702 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7703 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7704
7705 #[allow(non_camel_case_types)]
7706 type N4GcdN4 = <<A as Gcd<B>>::Output as Same<P4>>::Output;
7707
7708 assert_eq!(<N4GcdN4 as Integer>::to_i64(), <P4 as Integer>::to_i64());
7709 }
7710 #[test]
7711 #[allow(non_snake_case)]
7712 fn test_N4_Div_N4() {
7713 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7714 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7715 type P1 = PInt<UInt<UTerm, B1>>;
7716
7717 #[allow(non_camel_case_types)]
7718 type N4DivN4 = <<A as Div<B>>::Output as Same<P1>>::Output;
7719
7720 assert_eq!(<N4DivN4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
7721 }
7722 #[test]
7723 #[allow(non_snake_case)]
7724 fn test_N4_Rem_N4() {
7725 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7726 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7727 type _0 = Z0;
7728
7729 #[allow(non_camel_case_types)]
7730 type N4RemN4 = <<A as Rem<B>>::Output as Same<_0>>::Output;
7731
7732 assert_eq!(<N4RemN4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
7733 }
7734 #[test]
7735 #[allow(non_snake_case)]
7736 fn test_N4_PartialDiv_N4() {
7737 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7738 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7739 type P1 = PInt<UInt<UTerm, B1>>;
7740
7741 #[allow(non_camel_case_types)]
7742 type N4PartialDivN4 = <<A as PartialDiv<B>>::Output as Same<P1>>::Output;
7743
7744 assert_eq!(<N4PartialDivN4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
7745 }
7746 #[test]
7747 #[allow(non_snake_case)]
7748 fn test_N4_Cmp_N4() {
7749 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7750 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7751
7752 #[allow(non_camel_case_types)]
7753 type N4CmpN4 = <A as Cmp<B>>::Output;
7754 assert_eq!(<N4CmpN4 as Ord>::to_ordering(), Ordering::Equal);
7755 }
7756 #[test]
7757 #[allow(non_snake_case)]
7758 fn test_N4_Add_N3() {
7759 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7760 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
7761 type N7 = NInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>>;
7762
7763 #[allow(non_camel_case_types)]
7764 type N4AddN3 = <<A as Add<B>>::Output as Same<N7>>::Output;
7765
7766 assert_eq!(<N4AddN3 as Integer>::to_i64(), <N7 as Integer>::to_i64());
7767 }
7768 #[test]
7769 #[allow(non_snake_case)]
7770 fn test_N4_Sub_N3() {
7771 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7772 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
7773 type N1 = NInt<UInt<UTerm, B1>>;
7774
7775 #[allow(non_camel_case_types)]
7776 type N4SubN3 = <<A as Sub<B>>::Output as Same<N1>>::Output;
7777
7778 assert_eq!(<N4SubN3 as Integer>::to_i64(), <N1 as Integer>::to_i64());
7779 }
7780 #[test]
7781 #[allow(non_snake_case)]
7782 fn test_N4_Mul_N3() {
7783 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7784 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
7785 type P12 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>>;
7786
7787 #[allow(non_camel_case_types)]
7788 type N4MulN3 = <<A as Mul<B>>::Output as Same<P12>>::Output;
7789
7790 assert_eq!(<N4MulN3 as Integer>::to_i64(), <P12 as Integer>::to_i64());
7791 }
7792 #[test]
7793 #[allow(non_snake_case)]
7794 fn test_N4_Min_N3() {
7795 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7796 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
7797 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7798
7799 #[allow(non_camel_case_types)]
7800 type N4MinN3 = <<A as Min<B>>::Output as Same<N4>>::Output;
7801
7802 assert_eq!(<N4MinN3 as Integer>::to_i64(), <N4 as Integer>::to_i64());
7803 }
7804 #[test]
7805 #[allow(non_snake_case)]
7806 fn test_N4_Max_N3() {
7807 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7808 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
7809 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
7810
7811 #[allow(non_camel_case_types)]
7812 type N4MaxN3 = <<A as Max<B>>::Output as Same<N3>>::Output;
7813
7814 assert_eq!(<N4MaxN3 as Integer>::to_i64(), <N3 as Integer>::to_i64());
7815 }
7816 #[test]
7817 #[allow(non_snake_case)]
7818 fn test_N4_Gcd_N3() {
7819 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7820 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
7821 type P1 = PInt<UInt<UTerm, B1>>;
7822
7823 #[allow(non_camel_case_types)]
7824 type N4GcdN3 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
7825
7826 assert_eq!(<N4GcdN3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
7827 }
7828 #[test]
7829 #[allow(non_snake_case)]
7830 fn test_N4_Div_N3() {
7831 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7832 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
7833 type P1 = PInt<UInt<UTerm, B1>>;
7834
7835 #[allow(non_camel_case_types)]
7836 type N4DivN3 = <<A as Div<B>>::Output as Same<P1>>::Output;
7837
7838 assert_eq!(<N4DivN3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
7839 }
7840 #[test]
7841 #[allow(non_snake_case)]
7842 fn test_N4_Rem_N3() {
7843 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7844 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
7845 type N1 = NInt<UInt<UTerm, B1>>;
7846
7847 #[allow(non_camel_case_types)]
7848 type N4RemN3 = <<A as Rem<B>>::Output as Same<N1>>::Output;
7849
7850 assert_eq!(<N4RemN3 as Integer>::to_i64(), <N1 as Integer>::to_i64());
7851 }
7852 #[test]
7853 #[allow(non_snake_case)]
7854 fn test_N4_Cmp_N3() {
7855 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7856 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
7857
7858 #[allow(non_camel_case_types)]
7859 type N4CmpN3 = <A as Cmp<B>>::Output;
7860 assert_eq!(<N4CmpN3 as Ord>::to_ordering(), Ordering::Less);
7861 }
7862 #[test]
7863 #[allow(non_snake_case)]
7864 fn test_N4_Add_N2() {
7865 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7866 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
7867 type N6 = NInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
7868
7869 #[allow(non_camel_case_types)]
7870 type N4AddN2 = <<A as Add<B>>::Output as Same<N6>>::Output;
7871
7872 assert_eq!(<N4AddN2 as Integer>::to_i64(), <N6 as Integer>::to_i64());
7873 }
7874 #[test]
7875 #[allow(non_snake_case)]
7876 fn test_N4_Sub_N2() {
7877 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7878 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
7879 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
7880
7881 #[allow(non_camel_case_types)]
7882 type N4SubN2 = <<A as Sub<B>>::Output as Same<N2>>::Output;
7883
7884 assert_eq!(<N4SubN2 as Integer>::to_i64(), <N2 as Integer>::to_i64());
7885 }
7886 #[test]
7887 #[allow(non_snake_case)]
7888 fn test_N4_Mul_N2() {
7889 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7890 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
7891 type P8 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>;
7892
7893 #[allow(non_camel_case_types)]
7894 type N4MulN2 = <<A as Mul<B>>::Output as Same<P8>>::Output;
7895
7896 assert_eq!(<N4MulN2 as Integer>::to_i64(), <P8 as Integer>::to_i64());
7897 }
7898 #[test]
7899 #[allow(non_snake_case)]
7900 fn test_N4_Min_N2() {
7901 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7902 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
7903 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7904
7905 #[allow(non_camel_case_types)]
7906 type N4MinN2 = <<A as Min<B>>::Output as Same<N4>>::Output;
7907
7908 assert_eq!(<N4MinN2 as Integer>::to_i64(), <N4 as Integer>::to_i64());
7909 }
7910 #[test]
7911 #[allow(non_snake_case)]
7912 fn test_N4_Max_N2() {
7913 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7914 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
7915 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
7916
7917 #[allow(non_camel_case_types)]
7918 type N4MaxN2 = <<A as Max<B>>::Output as Same<N2>>::Output;
7919
7920 assert_eq!(<N4MaxN2 as Integer>::to_i64(), <N2 as Integer>::to_i64());
7921 }
7922 #[test]
7923 #[allow(non_snake_case)]
7924 fn test_N4_Gcd_N2() {
7925 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7926 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
7927 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
7928
7929 #[allow(non_camel_case_types)]
7930 type N4GcdN2 = <<A as Gcd<B>>::Output as Same<P2>>::Output;
7931
7932 assert_eq!(<N4GcdN2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
7933 }
7934 #[test]
7935 #[allow(non_snake_case)]
7936 fn test_N4_Div_N2() {
7937 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7938 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
7939 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
7940
7941 #[allow(non_camel_case_types)]
7942 type N4DivN2 = <<A as Div<B>>::Output as Same<P2>>::Output;
7943
7944 assert_eq!(<N4DivN2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
7945 }
7946 #[test]
7947 #[allow(non_snake_case)]
7948 fn test_N4_Rem_N2() {
7949 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7950 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
7951 type _0 = Z0;
7952
7953 #[allow(non_camel_case_types)]
7954 type N4RemN2 = <<A as Rem<B>>::Output as Same<_0>>::Output;
7955
7956 assert_eq!(<N4RemN2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
7957 }
7958 #[test]
7959 #[allow(non_snake_case)]
7960 fn test_N4_PartialDiv_N2() {
7961 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7962 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
7963 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
7964
7965 #[allow(non_camel_case_types)]
7966 type N4PartialDivN2 = <<A as PartialDiv<B>>::Output as Same<P2>>::Output;
7967
7968 assert_eq!(<N4PartialDivN2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
7969 }
7970 #[test]
7971 #[allow(non_snake_case)]
7972 fn test_N4_Cmp_N2() {
7973 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7974 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
7975
7976 #[allow(non_camel_case_types)]
7977 type N4CmpN2 = <A as Cmp<B>>::Output;
7978 assert_eq!(<N4CmpN2 as Ord>::to_ordering(), Ordering::Less);
7979 }
7980 #[test]
7981 #[allow(non_snake_case)]
7982 fn test_N4_Add_N1() {
7983 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7984 type B = NInt<UInt<UTerm, B1>>;
7985 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
7986
7987 #[allow(non_camel_case_types)]
7988 type N4AddN1 = <<A as Add<B>>::Output as Same<N5>>::Output;
7989
7990 assert_eq!(<N4AddN1 as Integer>::to_i64(), <N5 as Integer>::to_i64());
7991 }
7992 #[test]
7993 #[allow(non_snake_case)]
7994 fn test_N4_Sub_N1() {
7995 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
7996 type B = NInt<UInt<UTerm, B1>>;
7997 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
7998
7999 #[allow(non_camel_case_types)]
8000 type N4SubN1 = <<A as Sub<B>>::Output as Same<N3>>::Output;
8001
8002 assert_eq!(<N4SubN1 as Integer>::to_i64(), <N3 as Integer>::to_i64());
8003 }
8004 #[test]
8005 #[allow(non_snake_case)]
8006 fn test_N4_Mul_N1() {
8007 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8008 type B = NInt<UInt<UTerm, B1>>;
8009 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8010
8011 #[allow(non_camel_case_types)]
8012 type N4MulN1 = <<A as Mul<B>>::Output as Same<P4>>::Output;
8013
8014 assert_eq!(<N4MulN1 as Integer>::to_i64(), <P4 as Integer>::to_i64());
8015 }
8016 #[test]
8017 #[allow(non_snake_case)]
8018 fn test_N4_Min_N1() {
8019 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8020 type B = NInt<UInt<UTerm, B1>>;
8021 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8022
8023 #[allow(non_camel_case_types)]
8024 type N4MinN1 = <<A as Min<B>>::Output as Same<N4>>::Output;
8025
8026 assert_eq!(<N4MinN1 as Integer>::to_i64(), <N4 as Integer>::to_i64());
8027 }
8028 #[test]
8029 #[allow(non_snake_case)]
8030 fn test_N4_Max_N1() {
8031 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8032 type B = NInt<UInt<UTerm, B1>>;
8033 type N1 = NInt<UInt<UTerm, B1>>;
8034
8035 #[allow(non_camel_case_types)]
8036 type N4MaxN1 = <<A as Max<B>>::Output as Same<N1>>::Output;
8037
8038 assert_eq!(<N4MaxN1 as Integer>::to_i64(), <N1 as Integer>::to_i64());
8039 }
8040 #[test]
8041 #[allow(non_snake_case)]
8042 fn test_N4_Gcd_N1() {
8043 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8044 type B = NInt<UInt<UTerm, B1>>;
8045 type P1 = PInt<UInt<UTerm, B1>>;
8046
8047 #[allow(non_camel_case_types)]
8048 type N4GcdN1 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
8049
8050 assert_eq!(<N4GcdN1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
8051 }
8052 #[test]
8053 #[allow(non_snake_case)]
8054 fn test_N4_Div_N1() {
8055 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8056 type B = NInt<UInt<UTerm, B1>>;
8057 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8058
8059 #[allow(non_camel_case_types)]
8060 type N4DivN1 = <<A as Div<B>>::Output as Same<P4>>::Output;
8061
8062 assert_eq!(<N4DivN1 as Integer>::to_i64(), <P4 as Integer>::to_i64());
8063 }
8064 #[test]
8065 #[allow(non_snake_case)]
8066 fn test_N4_Rem_N1() {
8067 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8068 type B = NInt<UInt<UTerm, B1>>;
8069 type _0 = Z0;
8070
8071 #[allow(non_camel_case_types)]
8072 type N4RemN1 = <<A as Rem<B>>::Output as Same<_0>>::Output;
8073
8074 assert_eq!(<N4RemN1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
8075 }
8076 #[test]
8077 #[allow(non_snake_case)]
8078 fn test_N4_PartialDiv_N1() {
8079 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8080 type B = NInt<UInt<UTerm, B1>>;
8081 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8082
8083 #[allow(non_camel_case_types)]
8084 type N4PartialDivN1 = <<A as PartialDiv<B>>::Output as Same<P4>>::Output;
8085
8086 assert_eq!(<N4PartialDivN1 as Integer>::to_i64(), <P4 as Integer>::to_i64());
8087 }
8088 #[test]
8089 #[allow(non_snake_case)]
8090 fn test_N4_Cmp_N1() {
8091 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8092 type B = NInt<UInt<UTerm, B1>>;
8093
8094 #[allow(non_camel_case_types)]
8095 type N4CmpN1 = <A as Cmp<B>>::Output;
8096 assert_eq!(<N4CmpN1 as Ord>::to_ordering(), Ordering::Less);
8097 }
8098 #[test]
8099 #[allow(non_snake_case)]
8100 fn test_N4_Add__0() {
8101 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8102 type B = Z0;
8103 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8104
8105 #[allow(non_camel_case_types)]
8106 type N4Add_0 = <<A as Add<B>>::Output as Same<N4>>::Output;
8107
8108 assert_eq!(<N4Add_0 as Integer>::to_i64(), <N4 as Integer>::to_i64());
8109 }
8110 #[test]
8111 #[allow(non_snake_case)]
8112 fn test_N4_Sub__0() {
8113 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8114 type B = Z0;
8115 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8116
8117 #[allow(non_camel_case_types)]
8118 type N4Sub_0 = <<A as Sub<B>>::Output as Same<N4>>::Output;
8119
8120 assert_eq!(<N4Sub_0 as Integer>::to_i64(), <N4 as Integer>::to_i64());
8121 }
8122 #[test]
8123 #[allow(non_snake_case)]
8124 fn test_N4_Mul__0() {
8125 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8126 type B = Z0;
8127 type _0 = Z0;
8128
8129 #[allow(non_camel_case_types)]
8130 type N4Mul_0 = <<A as Mul<B>>::Output as Same<_0>>::Output;
8131
8132 assert_eq!(<N4Mul_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
8133 }
8134 #[test]
8135 #[allow(non_snake_case)]
8136 fn test_N4_Min__0() {
8137 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8138 type B = Z0;
8139 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8140
8141 #[allow(non_camel_case_types)]
8142 type N4Min_0 = <<A as Min<B>>::Output as Same<N4>>::Output;
8143
8144 assert_eq!(<N4Min_0 as Integer>::to_i64(), <N4 as Integer>::to_i64());
8145 }
8146 #[test]
8147 #[allow(non_snake_case)]
8148 fn test_N4_Max__0() {
8149 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8150 type B = Z0;
8151 type _0 = Z0;
8152
8153 #[allow(non_camel_case_types)]
8154 type N4Max_0 = <<A as Max<B>>::Output as Same<_0>>::Output;
8155
8156 assert_eq!(<N4Max_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
8157 }
8158 #[test]
8159 #[allow(non_snake_case)]
8160 fn test_N4_Gcd__0() {
8161 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8162 type B = Z0;
8163 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8164
8165 #[allow(non_camel_case_types)]
8166 type N4Gcd_0 = <<A as Gcd<B>>::Output as Same<P4>>::Output;
8167
8168 assert_eq!(<N4Gcd_0 as Integer>::to_i64(), <P4 as Integer>::to_i64());
8169 }
8170 #[test]
8171 #[allow(non_snake_case)]
8172 fn test_N4_Pow__0() {
8173 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8174 type B = Z0;
8175 type P1 = PInt<UInt<UTerm, B1>>;
8176
8177 #[allow(non_camel_case_types)]
8178 type N4Pow_0 = <<A as Pow<B>>::Output as Same<P1>>::Output;
8179
8180 assert_eq!(<N4Pow_0 as Integer>::to_i64(), <P1 as Integer>::to_i64());
8181 }
8182 #[test]
8183 #[allow(non_snake_case)]
8184 fn test_N4_Cmp__0() {
8185 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8186 type B = Z0;
8187
8188 #[allow(non_camel_case_types)]
8189 type N4Cmp_0 = <A as Cmp<B>>::Output;
8190 assert_eq!(<N4Cmp_0 as Ord>::to_ordering(), Ordering::Less);
8191 }
8192 #[test]
8193 #[allow(non_snake_case)]
8194 fn test_N4_Add_P1() {
8195 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8196 type B = PInt<UInt<UTerm, B1>>;
8197 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
8198
8199 #[allow(non_camel_case_types)]
8200 type N4AddP1 = <<A as Add<B>>::Output as Same<N3>>::Output;
8201
8202 assert_eq!(<N4AddP1 as Integer>::to_i64(), <N3 as Integer>::to_i64());
8203 }
8204 #[test]
8205 #[allow(non_snake_case)]
8206 fn test_N4_Sub_P1() {
8207 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8208 type B = PInt<UInt<UTerm, B1>>;
8209 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
8210
8211 #[allow(non_camel_case_types)]
8212 type N4SubP1 = <<A as Sub<B>>::Output as Same<N5>>::Output;
8213
8214 assert_eq!(<N4SubP1 as Integer>::to_i64(), <N5 as Integer>::to_i64());
8215 }
8216 #[test]
8217 #[allow(non_snake_case)]
8218 fn test_N4_Mul_P1() {
8219 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8220 type B = PInt<UInt<UTerm, B1>>;
8221 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8222
8223 #[allow(non_camel_case_types)]
8224 type N4MulP1 = <<A as Mul<B>>::Output as Same<N4>>::Output;
8225
8226 assert_eq!(<N4MulP1 as Integer>::to_i64(), <N4 as Integer>::to_i64());
8227 }
8228 #[test]
8229 #[allow(non_snake_case)]
8230 fn test_N4_Min_P1() {
8231 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8232 type B = PInt<UInt<UTerm, B1>>;
8233 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8234
8235 #[allow(non_camel_case_types)]
8236 type N4MinP1 = <<A as Min<B>>::Output as Same<N4>>::Output;
8237
8238 assert_eq!(<N4MinP1 as Integer>::to_i64(), <N4 as Integer>::to_i64());
8239 }
8240 #[test]
8241 #[allow(non_snake_case)]
8242 fn test_N4_Max_P1() {
8243 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8244 type B = PInt<UInt<UTerm, B1>>;
8245 type P1 = PInt<UInt<UTerm, B1>>;
8246
8247 #[allow(non_camel_case_types)]
8248 type N4MaxP1 = <<A as Max<B>>::Output as Same<P1>>::Output;
8249
8250 assert_eq!(<N4MaxP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
8251 }
8252 #[test]
8253 #[allow(non_snake_case)]
8254 fn test_N4_Gcd_P1() {
8255 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8256 type B = PInt<UInt<UTerm, B1>>;
8257 type P1 = PInt<UInt<UTerm, B1>>;
8258
8259 #[allow(non_camel_case_types)]
8260 type N4GcdP1 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
8261
8262 assert_eq!(<N4GcdP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
8263 }
8264 #[test]
8265 #[allow(non_snake_case)]
8266 fn test_N4_Div_P1() {
8267 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8268 type B = PInt<UInt<UTerm, B1>>;
8269 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8270
8271 #[allow(non_camel_case_types)]
8272 type N4DivP1 = <<A as Div<B>>::Output as Same<N4>>::Output;
8273
8274 assert_eq!(<N4DivP1 as Integer>::to_i64(), <N4 as Integer>::to_i64());
8275 }
8276 #[test]
8277 #[allow(non_snake_case)]
8278 fn test_N4_Rem_P1() {
8279 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8280 type B = PInt<UInt<UTerm, B1>>;
8281 type _0 = Z0;
8282
8283 #[allow(non_camel_case_types)]
8284 type N4RemP1 = <<A as Rem<B>>::Output as Same<_0>>::Output;
8285
8286 assert_eq!(<N4RemP1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
8287 }
8288 #[test]
8289 #[allow(non_snake_case)]
8290 fn test_N4_PartialDiv_P1() {
8291 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8292 type B = PInt<UInt<UTerm, B1>>;
8293 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8294
8295 #[allow(non_camel_case_types)]
8296 type N4PartialDivP1 = <<A as PartialDiv<B>>::Output as Same<N4>>::Output;
8297
8298 assert_eq!(<N4PartialDivP1 as Integer>::to_i64(), <N4 as Integer>::to_i64());
8299 }
8300 #[test]
8301 #[allow(non_snake_case)]
8302 fn test_N4_Pow_P1() {
8303 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8304 type B = PInt<UInt<UTerm, B1>>;
8305 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8306
8307 #[allow(non_camel_case_types)]
8308 type N4PowP1 = <<A as Pow<B>>::Output as Same<N4>>::Output;
8309
8310 assert_eq!(<N4PowP1 as Integer>::to_i64(), <N4 as Integer>::to_i64());
8311 }
8312 #[test]
8313 #[allow(non_snake_case)]
8314 fn test_N4_Cmp_P1() {
8315 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8316 type B = PInt<UInt<UTerm, B1>>;
8317
8318 #[allow(non_camel_case_types)]
8319 type N4CmpP1 = <A as Cmp<B>>::Output;
8320 assert_eq!(<N4CmpP1 as Ord>::to_ordering(), Ordering::Less);
8321 }
8322 #[test]
8323 #[allow(non_snake_case)]
8324 fn test_N4_Add_P2() {
8325 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8326 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
8327 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
8328
8329 #[allow(non_camel_case_types)]
8330 type N4AddP2 = <<A as Add<B>>::Output as Same<N2>>::Output;
8331
8332 assert_eq!(<N4AddP2 as Integer>::to_i64(), <N2 as Integer>::to_i64());
8333 }
8334 #[test]
8335 #[allow(non_snake_case)]
8336 fn test_N4_Sub_P2() {
8337 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8338 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
8339 type N6 = NInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
8340
8341 #[allow(non_camel_case_types)]
8342 type N4SubP2 = <<A as Sub<B>>::Output as Same<N6>>::Output;
8343
8344 assert_eq!(<N4SubP2 as Integer>::to_i64(), <N6 as Integer>::to_i64());
8345 }
8346 #[test]
8347 #[allow(non_snake_case)]
8348 fn test_N4_Mul_P2() {
8349 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8350 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
8351 type N8 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>;
8352
8353 #[allow(non_camel_case_types)]
8354 type N4MulP2 = <<A as Mul<B>>::Output as Same<N8>>::Output;
8355
8356 assert_eq!(<N4MulP2 as Integer>::to_i64(), <N8 as Integer>::to_i64());
8357 }
8358 #[test]
8359 #[allow(non_snake_case)]
8360 fn test_N4_Min_P2() {
8361 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8362 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
8363 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8364
8365 #[allow(non_camel_case_types)]
8366 type N4MinP2 = <<A as Min<B>>::Output as Same<N4>>::Output;
8367
8368 assert_eq!(<N4MinP2 as Integer>::to_i64(), <N4 as Integer>::to_i64());
8369 }
8370 #[test]
8371 #[allow(non_snake_case)]
8372 fn test_N4_Max_P2() {
8373 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8374 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
8375 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
8376
8377 #[allow(non_camel_case_types)]
8378 type N4MaxP2 = <<A as Max<B>>::Output as Same<P2>>::Output;
8379
8380 assert_eq!(<N4MaxP2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
8381 }
8382 #[test]
8383 #[allow(non_snake_case)]
8384 fn test_N4_Gcd_P2() {
8385 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8386 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
8387 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
8388
8389 #[allow(non_camel_case_types)]
8390 type N4GcdP2 = <<A as Gcd<B>>::Output as Same<P2>>::Output;
8391
8392 assert_eq!(<N4GcdP2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
8393 }
8394 #[test]
8395 #[allow(non_snake_case)]
8396 fn test_N4_Div_P2() {
8397 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8398 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
8399 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
8400
8401 #[allow(non_camel_case_types)]
8402 type N4DivP2 = <<A as Div<B>>::Output as Same<N2>>::Output;
8403
8404 assert_eq!(<N4DivP2 as Integer>::to_i64(), <N2 as Integer>::to_i64());
8405 }
8406 #[test]
8407 #[allow(non_snake_case)]
8408 fn test_N4_Rem_P2() {
8409 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8410 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
8411 type _0 = Z0;
8412
8413 #[allow(non_camel_case_types)]
8414 type N4RemP2 = <<A as Rem<B>>::Output as Same<_0>>::Output;
8415
8416 assert_eq!(<N4RemP2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
8417 }
8418 #[test]
8419 #[allow(non_snake_case)]
8420 fn test_N4_PartialDiv_P2() {
8421 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8422 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
8423 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
8424
8425 #[allow(non_camel_case_types)]
8426 type N4PartialDivP2 = <<A as PartialDiv<B>>::Output as Same<N2>>::Output;
8427
8428 assert_eq!(<N4PartialDivP2 as Integer>::to_i64(), <N2 as Integer>::to_i64());
8429 }
8430 #[test]
8431 #[allow(non_snake_case)]
8432 fn test_N4_Pow_P2() {
8433 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8434 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
8435 type P16 = PInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>>;
8436
8437 #[allow(non_camel_case_types)]
8438 type N4PowP2 = <<A as Pow<B>>::Output as Same<P16>>::Output;
8439
8440 assert_eq!(<N4PowP2 as Integer>::to_i64(), <P16 as Integer>::to_i64());
8441 }
8442 #[test]
8443 #[allow(non_snake_case)]
8444 fn test_N4_Cmp_P2() {
8445 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8446 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
8447
8448 #[allow(non_camel_case_types)]
8449 type N4CmpP2 = <A as Cmp<B>>::Output;
8450 assert_eq!(<N4CmpP2 as Ord>::to_ordering(), Ordering::Less);
8451 }
8452 #[test]
8453 #[allow(non_snake_case)]
8454 fn test_N4_Add_P3() {
8455 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8456 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
8457 type N1 = NInt<UInt<UTerm, B1>>;
8458
8459 #[allow(non_camel_case_types)]
8460 type N4AddP3 = <<A as Add<B>>::Output as Same<N1>>::Output;
8461
8462 assert_eq!(<N4AddP3 as Integer>::to_i64(), <N1 as Integer>::to_i64());
8463 }
8464 #[test]
8465 #[allow(non_snake_case)]
8466 fn test_N4_Sub_P3() {
8467 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8468 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
8469 type N7 = NInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>>;
8470
8471 #[allow(non_camel_case_types)]
8472 type N4SubP3 = <<A as Sub<B>>::Output as Same<N7>>::Output;
8473
8474 assert_eq!(<N4SubP3 as Integer>::to_i64(), <N7 as Integer>::to_i64());
8475 }
8476 #[test]
8477 #[allow(non_snake_case)]
8478 fn test_N4_Mul_P3() {
8479 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8480 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
8481 type N12 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>>;
8482
8483 #[allow(non_camel_case_types)]
8484 type N4MulP3 = <<A as Mul<B>>::Output as Same<N12>>::Output;
8485
8486 assert_eq!(<N4MulP3 as Integer>::to_i64(), <N12 as Integer>::to_i64());
8487 }
8488 #[test]
8489 #[allow(non_snake_case)]
8490 fn test_N4_Min_P3() {
8491 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8492 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
8493 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8494
8495 #[allow(non_camel_case_types)]
8496 type N4MinP3 = <<A as Min<B>>::Output as Same<N4>>::Output;
8497
8498 assert_eq!(<N4MinP3 as Integer>::to_i64(), <N4 as Integer>::to_i64());
8499 }
8500 #[test]
8501 #[allow(non_snake_case)]
8502 fn test_N4_Max_P3() {
8503 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8504 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
8505 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
8506
8507 #[allow(non_camel_case_types)]
8508 type N4MaxP3 = <<A as Max<B>>::Output as Same<P3>>::Output;
8509
8510 assert_eq!(<N4MaxP3 as Integer>::to_i64(), <P3 as Integer>::to_i64());
8511 }
8512 #[test]
8513 #[allow(non_snake_case)]
8514 fn test_N4_Gcd_P3() {
8515 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8516 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
8517 type P1 = PInt<UInt<UTerm, B1>>;
8518
8519 #[allow(non_camel_case_types)]
8520 type N4GcdP3 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
8521
8522 assert_eq!(<N4GcdP3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
8523 }
8524 #[test]
8525 #[allow(non_snake_case)]
8526 fn test_N4_Div_P3() {
8527 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8528 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
8529 type N1 = NInt<UInt<UTerm, B1>>;
8530
8531 #[allow(non_camel_case_types)]
8532 type N4DivP3 = <<A as Div<B>>::Output as Same<N1>>::Output;
8533
8534 assert_eq!(<N4DivP3 as Integer>::to_i64(), <N1 as Integer>::to_i64());
8535 }
8536 #[test]
8537 #[allow(non_snake_case)]
8538 fn test_N4_Rem_P3() {
8539 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8540 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
8541 type N1 = NInt<UInt<UTerm, B1>>;
8542
8543 #[allow(non_camel_case_types)]
8544 type N4RemP3 = <<A as Rem<B>>::Output as Same<N1>>::Output;
8545
8546 assert_eq!(<N4RemP3 as Integer>::to_i64(), <N1 as Integer>::to_i64());
8547 }
8548 #[test]
8549 #[allow(non_snake_case)]
8550 fn test_N4_Pow_P3() {
8551 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8552 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
8553 type N64 = NInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>>;
8554
8555 #[allow(non_camel_case_types)]
8556 type N4PowP3 = <<A as Pow<B>>::Output as Same<N64>>::Output;
8557
8558 assert_eq!(<N4PowP3 as Integer>::to_i64(), <N64 as Integer>::to_i64());
8559 }
8560 #[test]
8561 #[allow(non_snake_case)]
8562 fn test_N4_Cmp_P3() {
8563 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8564 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
8565
8566 #[allow(non_camel_case_types)]
8567 type N4CmpP3 = <A as Cmp<B>>::Output;
8568 assert_eq!(<N4CmpP3 as Ord>::to_ordering(), Ordering::Less);
8569 }
8570 #[test]
8571 #[allow(non_snake_case)]
8572 fn test_N4_Add_P4() {
8573 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8574 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8575 type _0 = Z0;
8576
8577 #[allow(non_camel_case_types)]
8578 type N4AddP4 = <<A as Add<B>>::Output as Same<_0>>::Output;
8579
8580 assert_eq!(<N4AddP4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
8581 }
8582 #[test]
8583 #[allow(non_snake_case)]
8584 fn test_N4_Sub_P4() {
8585 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8586 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8587 type N8 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>;
8588
8589 #[allow(non_camel_case_types)]
8590 type N4SubP4 = <<A as Sub<B>>::Output as Same<N8>>::Output;
8591
8592 assert_eq!(<N4SubP4 as Integer>::to_i64(), <N8 as Integer>::to_i64());
8593 }
8594 #[test]
8595 #[allow(non_snake_case)]
8596 fn test_N4_Mul_P4() {
8597 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8598 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8599 type N16 = NInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>>;
8600
8601 #[allow(non_camel_case_types)]
8602 type N4MulP4 = <<A as Mul<B>>::Output as Same<N16>>::Output;
8603
8604 assert_eq!(<N4MulP4 as Integer>::to_i64(), <N16 as Integer>::to_i64());
8605 }
8606 #[test]
8607 #[allow(non_snake_case)]
8608 fn test_N4_Min_P4() {
8609 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8610 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8611 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8612
8613 #[allow(non_camel_case_types)]
8614 type N4MinP4 = <<A as Min<B>>::Output as Same<N4>>::Output;
8615
8616 assert_eq!(<N4MinP4 as Integer>::to_i64(), <N4 as Integer>::to_i64());
8617 }
8618 #[test]
8619 #[allow(non_snake_case)]
8620 fn test_N4_Max_P4() {
8621 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8622 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8623 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8624
8625 #[allow(non_camel_case_types)]
8626 type N4MaxP4 = <<A as Max<B>>::Output as Same<P4>>::Output;
8627
8628 assert_eq!(<N4MaxP4 as Integer>::to_i64(), <P4 as Integer>::to_i64());
8629 }
8630 #[test]
8631 #[allow(non_snake_case)]
8632 fn test_N4_Gcd_P4() {
8633 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8634 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8635 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8636
8637 #[allow(non_camel_case_types)]
8638 type N4GcdP4 = <<A as Gcd<B>>::Output as Same<P4>>::Output;
8639
8640 assert_eq!(<N4GcdP4 as Integer>::to_i64(), <P4 as Integer>::to_i64());
8641 }
8642 #[test]
8643 #[allow(non_snake_case)]
8644 fn test_N4_Div_P4() {
8645 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8646 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8647 type N1 = NInt<UInt<UTerm, B1>>;
8648
8649 #[allow(non_camel_case_types)]
8650 type N4DivP4 = <<A as Div<B>>::Output as Same<N1>>::Output;
8651
8652 assert_eq!(<N4DivP4 as Integer>::to_i64(), <N1 as Integer>::to_i64());
8653 }
8654 #[test]
8655 #[allow(non_snake_case)]
8656 fn test_N4_Rem_P4() {
8657 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8658 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8659 type _0 = Z0;
8660
8661 #[allow(non_camel_case_types)]
8662 type N4RemP4 = <<A as Rem<B>>::Output as Same<_0>>::Output;
8663
8664 assert_eq!(<N4RemP4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
8665 }
8666 #[test]
8667 #[allow(non_snake_case)]
8668 fn test_N4_PartialDiv_P4() {
8669 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8670 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8671 type N1 = NInt<UInt<UTerm, B1>>;
8672
8673 #[allow(non_camel_case_types)]
8674 type N4PartialDivP4 = <<A as PartialDiv<B>>::Output as Same<N1>>::Output;
8675
8676 assert_eq!(<N4PartialDivP4 as Integer>::to_i64(), <N1 as Integer>::to_i64());
8677 }
8678 #[test]
8679 #[allow(non_snake_case)]
8680 fn test_N4_Pow_P4() {
8681 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8682 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8683 type P256 = PInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>;
8684
8685 #[allow(non_camel_case_types)]
8686 type N4PowP4 = <<A as Pow<B>>::Output as Same<P256>>::Output;
8687
8688 assert_eq!(<N4PowP4 as Integer>::to_i64(), <P256 as Integer>::to_i64());
8689 }
8690 #[test]
8691 #[allow(non_snake_case)]
8692 fn test_N4_Cmp_P4() {
8693 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8694 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8695
8696 #[allow(non_camel_case_types)]
8697 type N4CmpP4 = <A as Cmp<B>>::Output;
8698 assert_eq!(<N4CmpP4 as Ord>::to_ordering(), Ordering::Less);
8699 }
8700 #[test]
8701 #[allow(non_snake_case)]
8702 fn test_N4_Add_P5() {
8703 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8704 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
8705 type P1 = PInt<UInt<UTerm, B1>>;
8706
8707 #[allow(non_camel_case_types)]
8708 type N4AddP5 = <<A as Add<B>>::Output as Same<P1>>::Output;
8709
8710 assert_eq!(<N4AddP5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
8711 }
8712 #[test]
8713 #[allow(non_snake_case)]
8714 fn test_N4_Sub_P5() {
8715 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8716 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
8717 type N9 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>>;
8718
8719 #[allow(non_camel_case_types)]
8720 type N4SubP5 = <<A as Sub<B>>::Output as Same<N9>>::Output;
8721
8722 assert_eq!(<N4SubP5 as Integer>::to_i64(), <N9 as Integer>::to_i64());
8723 }
8724 #[test]
8725 #[allow(non_snake_case)]
8726 fn test_N4_Mul_P5() {
8727 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8728 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
8729 type N20 = NInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>>;
8730
8731 #[allow(non_camel_case_types)]
8732 type N4MulP5 = <<A as Mul<B>>::Output as Same<N20>>::Output;
8733
8734 assert_eq!(<N4MulP5 as Integer>::to_i64(), <N20 as Integer>::to_i64());
8735 }
8736 #[test]
8737 #[allow(non_snake_case)]
8738 fn test_N4_Min_P5() {
8739 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8740 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
8741 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8742
8743 #[allow(non_camel_case_types)]
8744 type N4MinP5 = <<A as Min<B>>::Output as Same<N4>>::Output;
8745
8746 assert_eq!(<N4MinP5 as Integer>::to_i64(), <N4 as Integer>::to_i64());
8747 }
8748 #[test]
8749 #[allow(non_snake_case)]
8750 fn test_N4_Max_P5() {
8751 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8752 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
8753 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
8754
8755 #[allow(non_camel_case_types)]
8756 type N4MaxP5 = <<A as Max<B>>::Output as Same<P5>>::Output;
8757
8758 assert_eq!(<N4MaxP5 as Integer>::to_i64(), <P5 as Integer>::to_i64());
8759 }
8760 #[test]
8761 #[allow(non_snake_case)]
8762 fn test_N4_Gcd_P5() {
8763 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8764 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
8765 type P1 = PInt<UInt<UTerm, B1>>;
8766
8767 #[allow(non_camel_case_types)]
8768 type N4GcdP5 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
8769
8770 assert_eq!(<N4GcdP5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
8771 }
8772 #[test]
8773 #[allow(non_snake_case)]
8774 fn test_N4_Div_P5() {
8775 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8776 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
8777 type _0 = Z0;
8778
8779 #[allow(non_camel_case_types)]
8780 type N4DivP5 = <<A as Div<B>>::Output as Same<_0>>::Output;
8781
8782 assert_eq!(<N4DivP5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
8783 }
8784 #[test]
8785 #[allow(non_snake_case)]
8786 fn test_N4_Rem_P5() {
8787 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8788 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
8789 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8790
8791 #[allow(non_camel_case_types)]
8792 type N4RemP5 = <<A as Rem<B>>::Output as Same<N4>>::Output;
8793
8794 assert_eq!(<N4RemP5 as Integer>::to_i64(), <N4 as Integer>::to_i64());
8795 }
8796 #[test]
8797 #[allow(non_snake_case)]
8798 fn test_N4_Pow_P5() {
8799 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8800 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
8801 type N1024 = NInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>;
8802
8803 #[allow(non_camel_case_types)]
8804 type N4PowP5 = <<A as Pow<B>>::Output as Same<N1024>>::Output;
8805
8806 assert_eq!(<N4PowP5 as Integer>::to_i64(), <N1024 as Integer>::to_i64());
8807 }
8808 #[test]
8809 #[allow(non_snake_case)]
8810 fn test_N4_Cmp_P5() {
8811 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8812 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
8813
8814 #[allow(non_camel_case_types)]
8815 type N4CmpP5 = <A as Cmp<B>>::Output;
8816 assert_eq!(<N4CmpP5 as Ord>::to_ordering(), Ordering::Less);
8817 }
8818 #[test]
8819 #[allow(non_snake_case)]
8820 fn test_N3_Add_N5() {
8821 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
8822 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
8823 type N8 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>;
8824
8825 #[allow(non_camel_case_types)]
8826 type N3AddN5 = <<A as Add<B>>::Output as Same<N8>>::Output;
8827
8828 assert_eq!(<N3AddN5 as Integer>::to_i64(), <N8 as Integer>::to_i64());
8829 }
8830 #[test]
8831 #[allow(non_snake_case)]
8832 fn test_N3_Sub_N5() {
8833 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
8834 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
8835 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
8836
8837 #[allow(non_camel_case_types)]
8838 type N3SubN5 = <<A as Sub<B>>::Output as Same<P2>>::Output;
8839
8840 assert_eq!(<N3SubN5 as Integer>::to_i64(), <P2 as Integer>::to_i64());
8841 }
8842 #[test]
8843 #[allow(non_snake_case)]
8844 fn test_N3_Mul_N5() {
8845 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
8846 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
8847 type P15 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>;
8848
8849 #[allow(non_camel_case_types)]
8850 type N3MulN5 = <<A as Mul<B>>::Output as Same<P15>>::Output;
8851
8852 assert_eq!(<N3MulN5 as Integer>::to_i64(), <P15 as Integer>::to_i64());
8853 }
8854 #[test]
8855 #[allow(non_snake_case)]
8856 fn test_N3_Min_N5() {
8857 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
8858 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
8859 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
8860
8861 #[allow(non_camel_case_types)]
8862 type N3MinN5 = <<A as Min<B>>::Output as Same<N5>>::Output;
8863
8864 assert_eq!(<N3MinN5 as Integer>::to_i64(), <N5 as Integer>::to_i64());
8865 }
8866 #[test]
8867 #[allow(non_snake_case)]
8868 fn test_N3_Max_N5() {
8869 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
8870 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
8871 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
8872
8873 #[allow(non_camel_case_types)]
8874 type N3MaxN5 = <<A as Max<B>>::Output as Same<N3>>::Output;
8875
8876 assert_eq!(<N3MaxN5 as Integer>::to_i64(), <N3 as Integer>::to_i64());
8877 }
8878 #[test]
8879 #[allow(non_snake_case)]
8880 fn test_N3_Gcd_N5() {
8881 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
8882 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
8883 type P1 = PInt<UInt<UTerm, B1>>;
8884
8885 #[allow(non_camel_case_types)]
8886 type N3GcdN5 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
8887
8888 assert_eq!(<N3GcdN5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
8889 }
8890 #[test]
8891 #[allow(non_snake_case)]
8892 fn test_N3_Div_N5() {
8893 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
8894 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
8895 type _0 = Z0;
8896
8897 #[allow(non_camel_case_types)]
8898 type N3DivN5 = <<A as Div<B>>::Output as Same<_0>>::Output;
8899
8900 assert_eq!(<N3DivN5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
8901 }
8902 #[test]
8903 #[allow(non_snake_case)]
8904 fn test_N3_Rem_N5() {
8905 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
8906 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
8907 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
8908
8909 #[allow(non_camel_case_types)]
8910 type N3RemN5 = <<A as Rem<B>>::Output as Same<N3>>::Output;
8911
8912 assert_eq!(<N3RemN5 as Integer>::to_i64(), <N3 as Integer>::to_i64());
8913 }
8914 #[test]
8915 #[allow(non_snake_case)]
8916 fn test_N3_Cmp_N5() {
8917 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
8918 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
8919
8920 #[allow(non_camel_case_types)]
8921 type N3CmpN5 = <A as Cmp<B>>::Output;
8922 assert_eq!(<N3CmpN5 as Ord>::to_ordering(), Ordering::Greater);
8923 }
8924 #[test]
8925 #[allow(non_snake_case)]
8926 fn test_N3_Add_N4() {
8927 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
8928 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8929 type N7 = NInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>>;
8930
8931 #[allow(non_camel_case_types)]
8932 type N3AddN4 = <<A as Add<B>>::Output as Same<N7>>::Output;
8933
8934 assert_eq!(<N3AddN4 as Integer>::to_i64(), <N7 as Integer>::to_i64());
8935 }
8936 #[test]
8937 #[allow(non_snake_case)]
8938 fn test_N3_Sub_N4() {
8939 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
8940 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8941 type P1 = PInt<UInt<UTerm, B1>>;
8942
8943 #[allow(non_camel_case_types)]
8944 type N3SubN4 = <<A as Sub<B>>::Output as Same<P1>>::Output;
8945
8946 assert_eq!(<N3SubN4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
8947 }
8948 #[test]
8949 #[allow(non_snake_case)]
8950 fn test_N3_Mul_N4() {
8951 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
8952 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8953 type P12 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>>;
8954
8955 #[allow(non_camel_case_types)]
8956 type N3MulN4 = <<A as Mul<B>>::Output as Same<P12>>::Output;
8957
8958 assert_eq!(<N3MulN4 as Integer>::to_i64(), <P12 as Integer>::to_i64());
8959 }
8960 #[test]
8961 #[allow(non_snake_case)]
8962 fn test_N3_Min_N4() {
8963 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
8964 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8965 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8966
8967 #[allow(non_camel_case_types)]
8968 type N3MinN4 = <<A as Min<B>>::Output as Same<N4>>::Output;
8969
8970 assert_eq!(<N3MinN4 as Integer>::to_i64(), <N4 as Integer>::to_i64());
8971 }
8972 #[test]
8973 #[allow(non_snake_case)]
8974 fn test_N3_Max_N4() {
8975 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
8976 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8977 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
8978
8979 #[allow(non_camel_case_types)]
8980 type N3MaxN4 = <<A as Max<B>>::Output as Same<N3>>::Output;
8981
8982 assert_eq!(<N3MaxN4 as Integer>::to_i64(), <N3 as Integer>::to_i64());
8983 }
8984 #[test]
8985 #[allow(non_snake_case)]
8986 fn test_N3_Gcd_N4() {
8987 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
8988 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
8989 type P1 = PInt<UInt<UTerm, B1>>;
8990
8991 #[allow(non_camel_case_types)]
8992 type N3GcdN4 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
8993
8994 assert_eq!(<N3GcdN4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
8995 }
8996 #[test]
8997 #[allow(non_snake_case)]
8998 fn test_N3_Div_N4() {
8999 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9000 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
9001 type _0 = Z0;
9002
9003 #[allow(non_camel_case_types)]
9004 type N3DivN4 = <<A as Div<B>>::Output as Same<_0>>::Output;
9005
9006 assert_eq!(<N3DivN4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
9007 }
9008 #[test]
9009 #[allow(non_snake_case)]
9010 fn test_N3_Rem_N4() {
9011 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9012 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
9013 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
9014
9015 #[allow(non_camel_case_types)]
9016 type N3RemN4 = <<A as Rem<B>>::Output as Same<N3>>::Output;
9017
9018 assert_eq!(<N3RemN4 as Integer>::to_i64(), <N3 as Integer>::to_i64());
9019 }
9020 #[test]
9021 #[allow(non_snake_case)]
9022 fn test_N3_Cmp_N4() {
9023 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9024 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
9025
9026 #[allow(non_camel_case_types)]
9027 type N3CmpN4 = <A as Cmp<B>>::Output;
9028 assert_eq!(<N3CmpN4 as Ord>::to_ordering(), Ordering::Greater);
9029 }
9030 #[test]
9031 #[allow(non_snake_case)]
9032 fn test_N3_Add_N3() {
9033 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9034 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
9035 type N6 = NInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
9036
9037 #[allow(non_camel_case_types)]
9038 type N3AddN3 = <<A as Add<B>>::Output as Same<N6>>::Output;
9039
9040 assert_eq!(<N3AddN3 as Integer>::to_i64(), <N6 as Integer>::to_i64());
9041 }
9042 #[test]
9043 #[allow(non_snake_case)]
9044 fn test_N3_Sub_N3() {
9045 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9046 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
9047 type _0 = Z0;
9048
9049 #[allow(non_camel_case_types)]
9050 type N3SubN3 = <<A as Sub<B>>::Output as Same<_0>>::Output;
9051
9052 assert_eq!(<N3SubN3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
9053 }
9054 #[test]
9055 #[allow(non_snake_case)]
9056 fn test_N3_Mul_N3() {
9057 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9058 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
9059 type P9 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>>;
9060
9061 #[allow(non_camel_case_types)]
9062 type N3MulN3 = <<A as Mul<B>>::Output as Same<P9>>::Output;
9063
9064 assert_eq!(<N3MulN3 as Integer>::to_i64(), <P9 as Integer>::to_i64());
9065 }
9066 #[test]
9067 #[allow(non_snake_case)]
9068 fn test_N3_Min_N3() {
9069 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9070 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
9071 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
9072
9073 #[allow(non_camel_case_types)]
9074 type N3MinN3 = <<A as Min<B>>::Output as Same<N3>>::Output;
9075
9076 assert_eq!(<N3MinN3 as Integer>::to_i64(), <N3 as Integer>::to_i64());
9077 }
9078 #[test]
9079 #[allow(non_snake_case)]
9080 fn test_N3_Max_N3() {
9081 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9082 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
9083 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
9084
9085 #[allow(non_camel_case_types)]
9086 type N3MaxN3 = <<A as Max<B>>::Output as Same<N3>>::Output;
9087
9088 assert_eq!(<N3MaxN3 as Integer>::to_i64(), <N3 as Integer>::to_i64());
9089 }
9090 #[test]
9091 #[allow(non_snake_case)]
9092 fn test_N3_Gcd_N3() {
9093 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9094 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
9095 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
9096
9097 #[allow(non_camel_case_types)]
9098 type N3GcdN3 = <<A as Gcd<B>>::Output as Same<P3>>::Output;
9099
9100 assert_eq!(<N3GcdN3 as Integer>::to_i64(), <P3 as Integer>::to_i64());
9101 }
9102 #[test]
9103 #[allow(non_snake_case)]
9104 fn test_N3_Div_N3() {
9105 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9106 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
9107 type P1 = PInt<UInt<UTerm, B1>>;
9108
9109 #[allow(non_camel_case_types)]
9110 type N3DivN3 = <<A as Div<B>>::Output as Same<P1>>::Output;
9111
9112 assert_eq!(<N3DivN3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
9113 }
9114 #[test]
9115 #[allow(non_snake_case)]
9116 fn test_N3_Rem_N3() {
9117 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9118 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
9119 type _0 = Z0;
9120
9121 #[allow(non_camel_case_types)]
9122 type N3RemN3 = <<A as Rem<B>>::Output as Same<_0>>::Output;
9123
9124 assert_eq!(<N3RemN3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
9125 }
9126 #[test]
9127 #[allow(non_snake_case)]
9128 fn test_N3_PartialDiv_N3() {
9129 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9130 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
9131 type P1 = PInt<UInt<UTerm, B1>>;
9132
9133 #[allow(non_camel_case_types)]
9134 type N3PartialDivN3 = <<A as PartialDiv<B>>::Output as Same<P1>>::Output;
9135
9136 assert_eq!(<N3PartialDivN3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
9137 }
9138 #[test]
9139 #[allow(non_snake_case)]
9140 fn test_N3_Cmp_N3() {
9141 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9142 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
9143
9144 #[allow(non_camel_case_types)]
9145 type N3CmpN3 = <A as Cmp<B>>::Output;
9146 assert_eq!(<N3CmpN3 as Ord>::to_ordering(), Ordering::Equal);
9147 }
9148 #[test]
9149 #[allow(non_snake_case)]
9150 fn test_N3_Add_N2() {
9151 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9152 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
9153 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
9154
9155 #[allow(non_camel_case_types)]
9156 type N3AddN2 = <<A as Add<B>>::Output as Same<N5>>::Output;
9157
9158 assert_eq!(<N3AddN2 as Integer>::to_i64(), <N5 as Integer>::to_i64());
9159 }
9160 #[test]
9161 #[allow(non_snake_case)]
9162 fn test_N3_Sub_N2() {
9163 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9164 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
9165 type N1 = NInt<UInt<UTerm, B1>>;
9166
9167 #[allow(non_camel_case_types)]
9168 type N3SubN2 = <<A as Sub<B>>::Output as Same<N1>>::Output;
9169
9170 assert_eq!(<N3SubN2 as Integer>::to_i64(), <N1 as Integer>::to_i64());
9171 }
9172 #[test]
9173 #[allow(non_snake_case)]
9174 fn test_N3_Mul_N2() {
9175 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9176 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
9177 type P6 = PInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
9178
9179 #[allow(non_camel_case_types)]
9180 type N3MulN2 = <<A as Mul<B>>::Output as Same<P6>>::Output;
9181
9182 assert_eq!(<N3MulN2 as Integer>::to_i64(), <P6 as Integer>::to_i64());
9183 }
9184 #[test]
9185 #[allow(non_snake_case)]
9186 fn test_N3_Min_N2() {
9187 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9188 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
9189 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
9190
9191 #[allow(non_camel_case_types)]
9192 type N3MinN2 = <<A as Min<B>>::Output as Same<N3>>::Output;
9193
9194 assert_eq!(<N3MinN2 as Integer>::to_i64(), <N3 as Integer>::to_i64());
9195 }
9196 #[test]
9197 #[allow(non_snake_case)]
9198 fn test_N3_Max_N2() {
9199 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9200 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
9201 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
9202
9203 #[allow(non_camel_case_types)]
9204 type N3MaxN2 = <<A as Max<B>>::Output as Same<N2>>::Output;
9205
9206 assert_eq!(<N3MaxN2 as Integer>::to_i64(), <N2 as Integer>::to_i64());
9207 }
9208 #[test]
9209 #[allow(non_snake_case)]
9210 fn test_N3_Gcd_N2() {
9211 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9212 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
9213 type P1 = PInt<UInt<UTerm, B1>>;
9214
9215 #[allow(non_camel_case_types)]
9216 type N3GcdN2 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
9217
9218 assert_eq!(<N3GcdN2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
9219 }
9220 #[test]
9221 #[allow(non_snake_case)]
9222 fn test_N3_Div_N2() {
9223 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9224 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
9225 type P1 = PInt<UInt<UTerm, B1>>;
9226
9227 #[allow(non_camel_case_types)]
9228 type N3DivN2 = <<A as Div<B>>::Output as Same<P1>>::Output;
9229
9230 assert_eq!(<N3DivN2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
9231 }
9232 #[test]
9233 #[allow(non_snake_case)]
9234 fn test_N3_Rem_N2() {
9235 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9236 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
9237 type N1 = NInt<UInt<UTerm, B1>>;
9238
9239 #[allow(non_camel_case_types)]
9240 type N3RemN2 = <<A as Rem<B>>::Output as Same<N1>>::Output;
9241
9242 assert_eq!(<N3RemN2 as Integer>::to_i64(), <N1 as Integer>::to_i64());
9243 }
9244 #[test]
9245 #[allow(non_snake_case)]
9246 fn test_N3_Cmp_N2() {
9247 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9248 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
9249
9250 #[allow(non_camel_case_types)]
9251 type N3CmpN2 = <A as Cmp<B>>::Output;
9252 assert_eq!(<N3CmpN2 as Ord>::to_ordering(), Ordering::Less);
9253 }
9254 #[test]
9255 #[allow(non_snake_case)]
9256 fn test_N3_Add_N1() {
9257 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9258 type B = NInt<UInt<UTerm, B1>>;
9259 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
9260
9261 #[allow(non_camel_case_types)]
9262 type N3AddN1 = <<A as Add<B>>::Output as Same<N4>>::Output;
9263
9264 assert_eq!(<N3AddN1 as Integer>::to_i64(), <N4 as Integer>::to_i64());
9265 }
9266 #[test]
9267 #[allow(non_snake_case)]
9268 fn test_N3_Sub_N1() {
9269 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9270 type B = NInt<UInt<UTerm, B1>>;
9271 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
9272
9273 #[allow(non_camel_case_types)]
9274 type N3SubN1 = <<A as Sub<B>>::Output as Same<N2>>::Output;
9275
9276 assert_eq!(<N3SubN1 as Integer>::to_i64(), <N2 as Integer>::to_i64());
9277 }
9278 #[test]
9279 #[allow(non_snake_case)]
9280 fn test_N3_Mul_N1() {
9281 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9282 type B = NInt<UInt<UTerm, B1>>;
9283 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
9284
9285 #[allow(non_camel_case_types)]
9286 type N3MulN1 = <<A as Mul<B>>::Output as Same<P3>>::Output;
9287
9288 assert_eq!(<N3MulN1 as Integer>::to_i64(), <P3 as Integer>::to_i64());
9289 }
9290 #[test]
9291 #[allow(non_snake_case)]
9292 fn test_N3_Min_N1() {
9293 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9294 type B = NInt<UInt<UTerm, B1>>;
9295 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
9296
9297 #[allow(non_camel_case_types)]
9298 type N3MinN1 = <<A as Min<B>>::Output as Same<N3>>::Output;
9299
9300 assert_eq!(<N3MinN1 as Integer>::to_i64(), <N3 as Integer>::to_i64());
9301 }
9302 #[test]
9303 #[allow(non_snake_case)]
9304 fn test_N3_Max_N1() {
9305 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9306 type B = NInt<UInt<UTerm, B1>>;
9307 type N1 = NInt<UInt<UTerm, B1>>;
9308
9309 #[allow(non_camel_case_types)]
9310 type N3MaxN1 = <<A as Max<B>>::Output as Same<N1>>::Output;
9311
9312 assert_eq!(<N3MaxN1 as Integer>::to_i64(), <N1 as Integer>::to_i64());
9313 }
9314 #[test]
9315 #[allow(non_snake_case)]
9316 fn test_N3_Gcd_N1() {
9317 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9318 type B = NInt<UInt<UTerm, B1>>;
9319 type P1 = PInt<UInt<UTerm, B1>>;
9320
9321 #[allow(non_camel_case_types)]
9322 type N3GcdN1 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
9323
9324 assert_eq!(<N3GcdN1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
9325 }
9326 #[test]
9327 #[allow(non_snake_case)]
9328 fn test_N3_Div_N1() {
9329 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9330 type B = NInt<UInt<UTerm, B1>>;
9331 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
9332
9333 #[allow(non_camel_case_types)]
9334 type N3DivN1 = <<A as Div<B>>::Output as Same<P3>>::Output;
9335
9336 assert_eq!(<N3DivN1 as Integer>::to_i64(), <P3 as Integer>::to_i64());
9337 }
9338 #[test]
9339 #[allow(non_snake_case)]
9340 fn test_N3_Rem_N1() {
9341 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9342 type B = NInt<UInt<UTerm, B1>>;
9343 type _0 = Z0;
9344
9345 #[allow(non_camel_case_types)]
9346 type N3RemN1 = <<A as Rem<B>>::Output as Same<_0>>::Output;
9347
9348 assert_eq!(<N3RemN1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
9349 }
9350 #[test]
9351 #[allow(non_snake_case)]
9352 fn test_N3_PartialDiv_N1() {
9353 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9354 type B = NInt<UInt<UTerm, B1>>;
9355 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
9356
9357 #[allow(non_camel_case_types)]
9358 type N3PartialDivN1 = <<A as PartialDiv<B>>::Output as Same<P3>>::Output;
9359
9360 assert_eq!(<N3PartialDivN1 as Integer>::to_i64(), <P3 as Integer>::to_i64());
9361 }
9362 #[test]
9363 #[allow(non_snake_case)]
9364 fn test_N3_Cmp_N1() {
9365 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9366 type B = NInt<UInt<UTerm, B1>>;
9367
9368 #[allow(non_camel_case_types)]
9369 type N3CmpN1 = <A as Cmp<B>>::Output;
9370 assert_eq!(<N3CmpN1 as Ord>::to_ordering(), Ordering::Less);
9371 }
9372 #[test]
9373 #[allow(non_snake_case)]
9374 fn test_N3_Add__0() {
9375 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9376 type B = Z0;
9377 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
9378
9379 #[allow(non_camel_case_types)]
9380 type N3Add_0 = <<A as Add<B>>::Output as Same<N3>>::Output;
9381
9382 assert_eq!(<N3Add_0 as Integer>::to_i64(), <N3 as Integer>::to_i64());
9383 }
9384 #[test]
9385 #[allow(non_snake_case)]
9386 fn test_N3_Sub__0() {
9387 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9388 type B = Z0;
9389 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
9390
9391 #[allow(non_camel_case_types)]
9392 type N3Sub_0 = <<A as Sub<B>>::Output as Same<N3>>::Output;
9393
9394 assert_eq!(<N3Sub_0 as Integer>::to_i64(), <N3 as Integer>::to_i64());
9395 }
9396 #[test]
9397 #[allow(non_snake_case)]
9398 fn test_N3_Mul__0() {
9399 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9400 type B = Z0;
9401 type _0 = Z0;
9402
9403 #[allow(non_camel_case_types)]
9404 type N3Mul_0 = <<A as Mul<B>>::Output as Same<_0>>::Output;
9405
9406 assert_eq!(<N3Mul_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
9407 }
9408 #[test]
9409 #[allow(non_snake_case)]
9410 fn test_N3_Min__0() {
9411 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9412 type B = Z0;
9413 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
9414
9415 #[allow(non_camel_case_types)]
9416 type N3Min_0 = <<A as Min<B>>::Output as Same<N3>>::Output;
9417
9418 assert_eq!(<N3Min_0 as Integer>::to_i64(), <N3 as Integer>::to_i64());
9419 }
9420 #[test]
9421 #[allow(non_snake_case)]
9422 fn test_N3_Max__0() {
9423 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9424 type B = Z0;
9425 type _0 = Z0;
9426
9427 #[allow(non_camel_case_types)]
9428 type N3Max_0 = <<A as Max<B>>::Output as Same<_0>>::Output;
9429
9430 assert_eq!(<N3Max_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
9431 }
9432 #[test]
9433 #[allow(non_snake_case)]
9434 fn test_N3_Gcd__0() {
9435 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9436 type B = Z0;
9437 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
9438
9439 #[allow(non_camel_case_types)]
9440 type N3Gcd_0 = <<A as Gcd<B>>::Output as Same<P3>>::Output;
9441
9442 assert_eq!(<N3Gcd_0 as Integer>::to_i64(), <P3 as Integer>::to_i64());
9443 }
9444 #[test]
9445 #[allow(non_snake_case)]
9446 fn test_N3_Pow__0() {
9447 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9448 type B = Z0;
9449 type P1 = PInt<UInt<UTerm, B1>>;
9450
9451 #[allow(non_camel_case_types)]
9452 type N3Pow_0 = <<A as Pow<B>>::Output as Same<P1>>::Output;
9453
9454 assert_eq!(<N3Pow_0 as Integer>::to_i64(), <P1 as Integer>::to_i64());
9455 }
9456 #[test]
9457 #[allow(non_snake_case)]
9458 fn test_N3_Cmp__0() {
9459 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9460 type B = Z0;
9461
9462 #[allow(non_camel_case_types)]
9463 type N3Cmp_0 = <A as Cmp<B>>::Output;
9464 assert_eq!(<N3Cmp_0 as Ord>::to_ordering(), Ordering::Less);
9465 }
9466 #[test]
9467 #[allow(non_snake_case)]
9468 fn test_N3_Add_P1() {
9469 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9470 type B = PInt<UInt<UTerm, B1>>;
9471 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
9472
9473 #[allow(non_camel_case_types)]
9474 type N3AddP1 = <<A as Add<B>>::Output as Same<N2>>::Output;
9475
9476 assert_eq!(<N3AddP1 as Integer>::to_i64(), <N2 as Integer>::to_i64());
9477 }
9478 #[test]
9479 #[allow(non_snake_case)]
9480 fn test_N3_Sub_P1() {
9481 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9482 type B = PInt<UInt<UTerm, B1>>;
9483 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
9484
9485 #[allow(non_camel_case_types)]
9486 type N3SubP1 = <<A as Sub<B>>::Output as Same<N4>>::Output;
9487
9488 assert_eq!(<N3SubP1 as Integer>::to_i64(), <N4 as Integer>::to_i64());
9489 }
9490 #[test]
9491 #[allow(non_snake_case)]
9492 fn test_N3_Mul_P1() {
9493 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9494 type B = PInt<UInt<UTerm, B1>>;
9495 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
9496
9497 #[allow(non_camel_case_types)]
9498 type N3MulP1 = <<A as Mul<B>>::Output as Same<N3>>::Output;
9499
9500 assert_eq!(<N3MulP1 as Integer>::to_i64(), <N3 as Integer>::to_i64());
9501 }
9502 #[test]
9503 #[allow(non_snake_case)]
9504 fn test_N3_Min_P1() {
9505 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9506 type B = PInt<UInt<UTerm, B1>>;
9507 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
9508
9509 #[allow(non_camel_case_types)]
9510 type N3MinP1 = <<A as Min<B>>::Output as Same<N3>>::Output;
9511
9512 assert_eq!(<N3MinP1 as Integer>::to_i64(), <N3 as Integer>::to_i64());
9513 }
9514 #[test]
9515 #[allow(non_snake_case)]
9516 fn test_N3_Max_P1() {
9517 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9518 type B = PInt<UInt<UTerm, B1>>;
9519 type P1 = PInt<UInt<UTerm, B1>>;
9520
9521 #[allow(non_camel_case_types)]
9522 type N3MaxP1 = <<A as Max<B>>::Output as Same<P1>>::Output;
9523
9524 assert_eq!(<N3MaxP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
9525 }
9526 #[test]
9527 #[allow(non_snake_case)]
9528 fn test_N3_Gcd_P1() {
9529 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9530 type B = PInt<UInt<UTerm, B1>>;
9531 type P1 = PInt<UInt<UTerm, B1>>;
9532
9533 #[allow(non_camel_case_types)]
9534 type N3GcdP1 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
9535
9536 assert_eq!(<N3GcdP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
9537 }
9538 #[test]
9539 #[allow(non_snake_case)]
9540 fn test_N3_Div_P1() {
9541 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9542 type B = PInt<UInt<UTerm, B1>>;
9543 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
9544
9545 #[allow(non_camel_case_types)]
9546 type N3DivP1 = <<A as Div<B>>::Output as Same<N3>>::Output;
9547
9548 assert_eq!(<N3DivP1 as Integer>::to_i64(), <N3 as Integer>::to_i64());
9549 }
9550 #[test]
9551 #[allow(non_snake_case)]
9552 fn test_N3_Rem_P1() {
9553 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9554 type B = PInt<UInt<UTerm, B1>>;
9555 type _0 = Z0;
9556
9557 #[allow(non_camel_case_types)]
9558 type N3RemP1 = <<A as Rem<B>>::Output as Same<_0>>::Output;
9559
9560 assert_eq!(<N3RemP1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
9561 }
9562 #[test]
9563 #[allow(non_snake_case)]
9564 fn test_N3_PartialDiv_P1() {
9565 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9566 type B = PInt<UInt<UTerm, B1>>;
9567 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
9568
9569 #[allow(non_camel_case_types)]
9570 type N3PartialDivP1 = <<A as PartialDiv<B>>::Output as Same<N3>>::Output;
9571
9572 assert_eq!(<N3PartialDivP1 as Integer>::to_i64(), <N3 as Integer>::to_i64());
9573 }
9574 #[test]
9575 #[allow(non_snake_case)]
9576 fn test_N3_Pow_P1() {
9577 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9578 type B = PInt<UInt<UTerm, B1>>;
9579 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
9580
9581 #[allow(non_camel_case_types)]
9582 type N3PowP1 = <<A as Pow<B>>::Output as Same<N3>>::Output;
9583
9584 assert_eq!(<N3PowP1 as Integer>::to_i64(), <N3 as Integer>::to_i64());
9585 }
9586 #[test]
9587 #[allow(non_snake_case)]
9588 fn test_N3_Cmp_P1() {
9589 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9590 type B = PInt<UInt<UTerm, B1>>;
9591
9592 #[allow(non_camel_case_types)]
9593 type N3CmpP1 = <A as Cmp<B>>::Output;
9594 assert_eq!(<N3CmpP1 as Ord>::to_ordering(), Ordering::Less);
9595 }
9596 #[test]
9597 #[allow(non_snake_case)]
9598 fn test_N3_Add_P2() {
9599 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9600 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
9601 type N1 = NInt<UInt<UTerm, B1>>;
9602
9603 #[allow(non_camel_case_types)]
9604 type N3AddP2 = <<A as Add<B>>::Output as Same<N1>>::Output;
9605
9606 assert_eq!(<N3AddP2 as Integer>::to_i64(), <N1 as Integer>::to_i64());
9607 }
9608 #[test]
9609 #[allow(non_snake_case)]
9610 fn test_N3_Sub_P2() {
9611 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9612 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
9613 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
9614
9615 #[allow(non_camel_case_types)]
9616 type N3SubP2 = <<A as Sub<B>>::Output as Same<N5>>::Output;
9617
9618 assert_eq!(<N3SubP2 as Integer>::to_i64(), <N5 as Integer>::to_i64());
9619 }
9620 #[test]
9621 #[allow(non_snake_case)]
9622 fn test_N3_Mul_P2() {
9623 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9624 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
9625 type N6 = NInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
9626
9627 #[allow(non_camel_case_types)]
9628 type N3MulP2 = <<A as Mul<B>>::Output as Same<N6>>::Output;
9629
9630 assert_eq!(<N3MulP2 as Integer>::to_i64(), <N6 as Integer>::to_i64());
9631 }
9632 #[test]
9633 #[allow(non_snake_case)]
9634 fn test_N3_Min_P2() {
9635 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9636 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
9637 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
9638
9639 #[allow(non_camel_case_types)]
9640 type N3MinP2 = <<A as Min<B>>::Output as Same<N3>>::Output;
9641
9642 assert_eq!(<N3MinP2 as Integer>::to_i64(), <N3 as Integer>::to_i64());
9643 }
9644 #[test]
9645 #[allow(non_snake_case)]
9646 fn test_N3_Max_P2() {
9647 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9648 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
9649 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
9650
9651 #[allow(non_camel_case_types)]
9652 type N3MaxP2 = <<A as Max<B>>::Output as Same<P2>>::Output;
9653
9654 assert_eq!(<N3MaxP2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
9655 }
9656 #[test]
9657 #[allow(non_snake_case)]
9658 fn test_N3_Gcd_P2() {
9659 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9660 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
9661 type P1 = PInt<UInt<UTerm, B1>>;
9662
9663 #[allow(non_camel_case_types)]
9664 type N3GcdP2 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
9665
9666 assert_eq!(<N3GcdP2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
9667 }
9668 #[test]
9669 #[allow(non_snake_case)]
9670 fn test_N3_Div_P2() {
9671 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9672 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
9673 type N1 = NInt<UInt<UTerm, B1>>;
9674
9675 #[allow(non_camel_case_types)]
9676 type N3DivP2 = <<A as Div<B>>::Output as Same<N1>>::Output;
9677
9678 assert_eq!(<N3DivP2 as Integer>::to_i64(), <N1 as Integer>::to_i64());
9679 }
9680 #[test]
9681 #[allow(non_snake_case)]
9682 fn test_N3_Rem_P2() {
9683 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9684 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
9685 type N1 = NInt<UInt<UTerm, B1>>;
9686
9687 #[allow(non_camel_case_types)]
9688 type N3RemP2 = <<A as Rem<B>>::Output as Same<N1>>::Output;
9689
9690 assert_eq!(<N3RemP2 as Integer>::to_i64(), <N1 as Integer>::to_i64());
9691 }
9692 #[test]
9693 #[allow(non_snake_case)]
9694 fn test_N3_Pow_P2() {
9695 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9696 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
9697 type P9 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>>;
9698
9699 #[allow(non_camel_case_types)]
9700 type N3PowP2 = <<A as Pow<B>>::Output as Same<P9>>::Output;
9701
9702 assert_eq!(<N3PowP2 as Integer>::to_i64(), <P9 as Integer>::to_i64());
9703 }
9704 #[test]
9705 #[allow(non_snake_case)]
9706 fn test_N3_Cmp_P2() {
9707 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9708 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
9709
9710 #[allow(non_camel_case_types)]
9711 type N3CmpP2 = <A as Cmp<B>>::Output;
9712 assert_eq!(<N3CmpP2 as Ord>::to_ordering(), Ordering::Less);
9713 }
9714 #[test]
9715 #[allow(non_snake_case)]
9716 fn test_N3_Add_P3() {
9717 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9718 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
9719 type _0 = Z0;
9720
9721 #[allow(non_camel_case_types)]
9722 type N3AddP3 = <<A as Add<B>>::Output as Same<_0>>::Output;
9723
9724 assert_eq!(<N3AddP3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
9725 }
9726 #[test]
9727 #[allow(non_snake_case)]
9728 fn test_N3_Sub_P3() {
9729 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9730 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
9731 type N6 = NInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
9732
9733 #[allow(non_camel_case_types)]
9734 type N3SubP3 = <<A as Sub<B>>::Output as Same<N6>>::Output;
9735
9736 assert_eq!(<N3SubP3 as Integer>::to_i64(), <N6 as Integer>::to_i64());
9737 }
9738 #[test]
9739 #[allow(non_snake_case)]
9740 fn test_N3_Mul_P3() {
9741 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9742 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
9743 type N9 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>>;
9744
9745 #[allow(non_camel_case_types)]
9746 type N3MulP3 = <<A as Mul<B>>::Output as Same<N9>>::Output;
9747
9748 assert_eq!(<N3MulP3 as Integer>::to_i64(), <N9 as Integer>::to_i64());
9749 }
9750 #[test]
9751 #[allow(non_snake_case)]
9752 fn test_N3_Min_P3() {
9753 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9754 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
9755 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
9756
9757 #[allow(non_camel_case_types)]
9758 type N3MinP3 = <<A as Min<B>>::Output as Same<N3>>::Output;
9759
9760 assert_eq!(<N3MinP3 as Integer>::to_i64(), <N3 as Integer>::to_i64());
9761 }
9762 #[test]
9763 #[allow(non_snake_case)]
9764 fn test_N3_Max_P3() {
9765 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9766 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
9767 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
9768
9769 #[allow(non_camel_case_types)]
9770 type N3MaxP3 = <<A as Max<B>>::Output as Same<P3>>::Output;
9771
9772 assert_eq!(<N3MaxP3 as Integer>::to_i64(), <P3 as Integer>::to_i64());
9773 }
9774 #[test]
9775 #[allow(non_snake_case)]
9776 fn test_N3_Gcd_P3() {
9777 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9778 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
9779 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
9780
9781 #[allow(non_camel_case_types)]
9782 type N3GcdP3 = <<A as Gcd<B>>::Output as Same<P3>>::Output;
9783
9784 assert_eq!(<N3GcdP3 as Integer>::to_i64(), <P3 as Integer>::to_i64());
9785 }
9786 #[test]
9787 #[allow(non_snake_case)]
9788 fn test_N3_Div_P3() {
9789 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9790 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
9791 type N1 = NInt<UInt<UTerm, B1>>;
9792
9793 #[allow(non_camel_case_types)]
9794 type N3DivP3 = <<A as Div<B>>::Output as Same<N1>>::Output;
9795
9796 assert_eq!(<N3DivP3 as Integer>::to_i64(), <N1 as Integer>::to_i64());
9797 }
9798 #[test]
9799 #[allow(non_snake_case)]
9800 fn test_N3_Rem_P3() {
9801 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9802 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
9803 type _0 = Z0;
9804
9805 #[allow(non_camel_case_types)]
9806 type N3RemP3 = <<A as Rem<B>>::Output as Same<_0>>::Output;
9807
9808 assert_eq!(<N3RemP3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
9809 }
9810 #[test]
9811 #[allow(non_snake_case)]
9812 fn test_N3_PartialDiv_P3() {
9813 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9814 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
9815 type N1 = NInt<UInt<UTerm, B1>>;
9816
9817 #[allow(non_camel_case_types)]
9818 type N3PartialDivP3 = <<A as PartialDiv<B>>::Output as Same<N1>>::Output;
9819
9820 assert_eq!(<N3PartialDivP3 as Integer>::to_i64(), <N1 as Integer>::to_i64());
9821 }
9822 #[test]
9823 #[allow(non_snake_case)]
9824 fn test_N3_Pow_P3() {
9825 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9826 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
9827 type N27 = NInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>>;
9828
9829 #[allow(non_camel_case_types)]
9830 type N3PowP3 = <<A as Pow<B>>::Output as Same<N27>>::Output;
9831
9832 assert_eq!(<N3PowP3 as Integer>::to_i64(), <N27 as Integer>::to_i64());
9833 }
9834 #[test]
9835 #[allow(non_snake_case)]
9836 fn test_N3_Cmp_P3() {
9837 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9838 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
9839
9840 #[allow(non_camel_case_types)]
9841 type N3CmpP3 = <A as Cmp<B>>::Output;
9842 assert_eq!(<N3CmpP3 as Ord>::to_ordering(), Ordering::Less);
9843 }
9844 #[test]
9845 #[allow(non_snake_case)]
9846 fn test_N3_Add_P4() {
9847 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9848 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
9849 type P1 = PInt<UInt<UTerm, B1>>;
9850
9851 #[allow(non_camel_case_types)]
9852 type N3AddP4 = <<A as Add<B>>::Output as Same<P1>>::Output;
9853
9854 assert_eq!(<N3AddP4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
9855 }
9856 #[test]
9857 #[allow(non_snake_case)]
9858 fn test_N3_Sub_P4() {
9859 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9860 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
9861 type N7 = NInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>>;
9862
9863 #[allow(non_camel_case_types)]
9864 type N3SubP4 = <<A as Sub<B>>::Output as Same<N7>>::Output;
9865
9866 assert_eq!(<N3SubP4 as Integer>::to_i64(), <N7 as Integer>::to_i64());
9867 }
9868 #[test]
9869 #[allow(non_snake_case)]
9870 fn test_N3_Mul_P4() {
9871 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9872 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
9873 type N12 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>>;
9874
9875 #[allow(non_camel_case_types)]
9876 type N3MulP4 = <<A as Mul<B>>::Output as Same<N12>>::Output;
9877
9878 assert_eq!(<N3MulP4 as Integer>::to_i64(), <N12 as Integer>::to_i64());
9879 }
9880 #[test]
9881 #[allow(non_snake_case)]
9882 fn test_N3_Min_P4() {
9883 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9884 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
9885 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
9886
9887 #[allow(non_camel_case_types)]
9888 type N3MinP4 = <<A as Min<B>>::Output as Same<N3>>::Output;
9889
9890 assert_eq!(<N3MinP4 as Integer>::to_i64(), <N3 as Integer>::to_i64());
9891 }
9892 #[test]
9893 #[allow(non_snake_case)]
9894 fn test_N3_Max_P4() {
9895 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9896 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
9897 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
9898
9899 #[allow(non_camel_case_types)]
9900 type N3MaxP4 = <<A as Max<B>>::Output as Same<P4>>::Output;
9901
9902 assert_eq!(<N3MaxP4 as Integer>::to_i64(), <P4 as Integer>::to_i64());
9903 }
9904 #[test]
9905 #[allow(non_snake_case)]
9906 fn test_N3_Gcd_P4() {
9907 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9908 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
9909 type P1 = PInt<UInt<UTerm, B1>>;
9910
9911 #[allow(non_camel_case_types)]
9912 type N3GcdP4 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
9913
9914 assert_eq!(<N3GcdP4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
9915 }
9916 #[test]
9917 #[allow(non_snake_case)]
9918 fn test_N3_Div_P4() {
9919 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9920 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
9921 type _0 = Z0;
9922
9923 #[allow(non_camel_case_types)]
9924 type N3DivP4 = <<A as Div<B>>::Output as Same<_0>>::Output;
9925
9926 assert_eq!(<N3DivP4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
9927 }
9928 #[test]
9929 #[allow(non_snake_case)]
9930 fn test_N3_Rem_P4() {
9931 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9932 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
9933 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
9934
9935 #[allow(non_camel_case_types)]
9936 type N3RemP4 = <<A as Rem<B>>::Output as Same<N3>>::Output;
9937
9938 assert_eq!(<N3RemP4 as Integer>::to_i64(), <N3 as Integer>::to_i64());
9939 }
9940 #[test]
9941 #[allow(non_snake_case)]
9942 fn test_N3_Pow_P4() {
9943 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9944 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
9945 type P81 = PInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>, B1>>;
9946
9947 #[allow(non_camel_case_types)]
9948 type N3PowP4 = <<A as Pow<B>>::Output as Same<P81>>::Output;
9949
9950 assert_eq!(<N3PowP4 as Integer>::to_i64(), <P81 as Integer>::to_i64());
9951 }
9952 #[test]
9953 #[allow(non_snake_case)]
9954 fn test_N3_Cmp_P4() {
9955 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9956 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
9957
9958 #[allow(non_camel_case_types)]
9959 type N3CmpP4 = <A as Cmp<B>>::Output;
9960 assert_eq!(<N3CmpP4 as Ord>::to_ordering(), Ordering::Less);
9961 }
9962 #[test]
9963 #[allow(non_snake_case)]
9964 fn test_N3_Add_P5() {
9965 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9966 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
9967 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
9968
9969 #[allow(non_camel_case_types)]
9970 type N3AddP5 = <<A as Add<B>>::Output as Same<P2>>::Output;
9971
9972 assert_eq!(<N3AddP5 as Integer>::to_i64(), <P2 as Integer>::to_i64());
9973 }
9974 #[test]
9975 #[allow(non_snake_case)]
9976 fn test_N3_Sub_P5() {
9977 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9978 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
9979 type N8 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>;
9980
9981 #[allow(non_camel_case_types)]
9982 type N3SubP5 = <<A as Sub<B>>::Output as Same<N8>>::Output;
9983
9984 assert_eq!(<N3SubP5 as Integer>::to_i64(), <N8 as Integer>::to_i64());
9985 }
9986 #[test]
9987 #[allow(non_snake_case)]
9988 fn test_N3_Mul_P5() {
9989 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
9990 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
9991 type N15 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>;
9992
9993 #[allow(non_camel_case_types)]
9994 type N3MulP5 = <<A as Mul<B>>::Output as Same<N15>>::Output;
9995
9996 assert_eq!(<N3MulP5 as Integer>::to_i64(), <N15 as Integer>::to_i64());
9997 }
9998 #[test]
9999 #[allow(non_snake_case)]
10000 fn test_N3_Min_P5() {
10001 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
10002 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
10003 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
10004
10005 #[allow(non_camel_case_types)]
10006 type N3MinP5 = <<A as Min<B>>::Output as Same<N3>>::Output;
10007
10008 assert_eq!(<N3MinP5 as Integer>::to_i64(), <N3 as Integer>::to_i64());
10009 }
10010 #[test]
10011 #[allow(non_snake_case)]
10012 fn test_N3_Max_P5() {
10013 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
10014 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
10015 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
10016
10017 #[allow(non_camel_case_types)]
10018 type N3MaxP5 = <<A as Max<B>>::Output as Same<P5>>::Output;
10019
10020 assert_eq!(<N3MaxP5 as Integer>::to_i64(), <P5 as Integer>::to_i64());
10021 }
10022 #[test]
10023 #[allow(non_snake_case)]
10024 fn test_N3_Gcd_P5() {
10025 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
10026 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
10027 type P1 = PInt<UInt<UTerm, B1>>;
10028
10029 #[allow(non_camel_case_types)]
10030 type N3GcdP5 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
10031
10032 assert_eq!(<N3GcdP5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
10033 }
10034 #[test]
10035 #[allow(non_snake_case)]
10036 fn test_N3_Div_P5() {
10037 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
10038 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
10039 type _0 = Z0;
10040
10041 #[allow(non_camel_case_types)]
10042 type N3DivP5 = <<A as Div<B>>::Output as Same<_0>>::Output;
10043
10044 assert_eq!(<N3DivP5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
10045 }
10046 #[test]
10047 #[allow(non_snake_case)]
10048 fn test_N3_Rem_P5() {
10049 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
10050 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
10051 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
10052
10053 #[allow(non_camel_case_types)]
10054 type N3RemP5 = <<A as Rem<B>>::Output as Same<N3>>::Output;
10055
10056 assert_eq!(<N3RemP5 as Integer>::to_i64(), <N3 as Integer>::to_i64());
10057 }
10058 #[test]
10059 #[allow(non_snake_case)]
10060 fn test_N3_Pow_P5() {
10061 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
10062 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
10063 type N243 = NInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B0>, B1>, B1>>;
10064
10065 #[allow(non_camel_case_types)]
10066 type N3PowP5 = <<A as Pow<B>>::Output as Same<N243>>::Output;
10067
10068 assert_eq!(<N3PowP5 as Integer>::to_i64(), <N243 as Integer>::to_i64());
10069 }
10070 #[test]
10071 #[allow(non_snake_case)]
10072 fn test_N3_Cmp_P5() {
10073 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
10074 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
10075
10076 #[allow(non_camel_case_types)]
10077 type N3CmpP5 = <A as Cmp<B>>::Output;
10078 assert_eq!(<N3CmpP5 as Ord>::to_ordering(), Ordering::Less);
10079 }
10080 #[test]
10081 #[allow(non_snake_case)]
10082 fn test_N2_Add_N5() {
10083 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10084 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
10085 type N7 = NInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>>;
10086
10087 #[allow(non_camel_case_types)]
10088 type N2AddN5 = <<A as Add<B>>::Output as Same<N7>>::Output;
10089
10090 assert_eq!(<N2AddN5 as Integer>::to_i64(), <N7 as Integer>::to_i64());
10091 }
10092 #[test]
10093 #[allow(non_snake_case)]
10094 fn test_N2_Sub_N5() {
10095 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10096 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
10097 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
10098
10099 #[allow(non_camel_case_types)]
10100 type N2SubN5 = <<A as Sub<B>>::Output as Same<P3>>::Output;
10101
10102 assert_eq!(<N2SubN5 as Integer>::to_i64(), <P3 as Integer>::to_i64());
10103 }
10104 #[test]
10105 #[allow(non_snake_case)]
10106 fn test_N2_Mul_N5() {
10107 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10108 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
10109 type P10 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>;
10110
10111 #[allow(non_camel_case_types)]
10112 type N2MulN5 = <<A as Mul<B>>::Output as Same<P10>>::Output;
10113
10114 assert_eq!(<N2MulN5 as Integer>::to_i64(), <P10 as Integer>::to_i64());
10115 }
10116 #[test]
10117 #[allow(non_snake_case)]
10118 fn test_N2_Min_N5() {
10119 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10120 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
10121 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
10122
10123 #[allow(non_camel_case_types)]
10124 type N2MinN5 = <<A as Min<B>>::Output as Same<N5>>::Output;
10125
10126 assert_eq!(<N2MinN5 as Integer>::to_i64(), <N5 as Integer>::to_i64());
10127 }
10128 #[test]
10129 #[allow(non_snake_case)]
10130 fn test_N2_Max_N5() {
10131 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10132 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
10133 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
10134
10135 #[allow(non_camel_case_types)]
10136 type N2MaxN5 = <<A as Max<B>>::Output as Same<N2>>::Output;
10137
10138 assert_eq!(<N2MaxN5 as Integer>::to_i64(), <N2 as Integer>::to_i64());
10139 }
10140 #[test]
10141 #[allow(non_snake_case)]
10142 fn test_N2_Gcd_N5() {
10143 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10144 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
10145 type P1 = PInt<UInt<UTerm, B1>>;
10146
10147 #[allow(non_camel_case_types)]
10148 type N2GcdN5 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
10149
10150 assert_eq!(<N2GcdN5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
10151 }
10152 #[test]
10153 #[allow(non_snake_case)]
10154 fn test_N2_Div_N5() {
10155 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10156 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
10157 type _0 = Z0;
10158
10159 #[allow(non_camel_case_types)]
10160 type N2DivN5 = <<A as Div<B>>::Output as Same<_0>>::Output;
10161
10162 assert_eq!(<N2DivN5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
10163 }
10164 #[test]
10165 #[allow(non_snake_case)]
10166 fn test_N2_Rem_N5() {
10167 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10168 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
10169 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
10170
10171 #[allow(non_camel_case_types)]
10172 type N2RemN5 = <<A as Rem<B>>::Output as Same<N2>>::Output;
10173
10174 assert_eq!(<N2RemN5 as Integer>::to_i64(), <N2 as Integer>::to_i64());
10175 }
10176 #[test]
10177 #[allow(non_snake_case)]
10178 fn test_N2_Cmp_N5() {
10179 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10180 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
10181
10182 #[allow(non_camel_case_types)]
10183 type N2CmpN5 = <A as Cmp<B>>::Output;
10184 assert_eq!(<N2CmpN5 as Ord>::to_ordering(), Ordering::Greater);
10185 }
10186 #[test]
10187 #[allow(non_snake_case)]
10188 fn test_N2_Add_N4() {
10189 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10190 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
10191 type N6 = NInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
10192
10193 #[allow(non_camel_case_types)]
10194 type N2AddN4 = <<A as Add<B>>::Output as Same<N6>>::Output;
10195
10196 assert_eq!(<N2AddN4 as Integer>::to_i64(), <N6 as Integer>::to_i64());
10197 }
10198 #[test]
10199 #[allow(non_snake_case)]
10200 fn test_N2_Sub_N4() {
10201 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10202 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
10203 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
10204
10205 #[allow(non_camel_case_types)]
10206 type N2SubN4 = <<A as Sub<B>>::Output as Same<P2>>::Output;
10207
10208 assert_eq!(<N2SubN4 as Integer>::to_i64(), <P2 as Integer>::to_i64());
10209 }
10210 #[test]
10211 #[allow(non_snake_case)]
10212 fn test_N2_Mul_N4() {
10213 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10214 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
10215 type P8 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>;
10216
10217 #[allow(non_camel_case_types)]
10218 type N2MulN4 = <<A as Mul<B>>::Output as Same<P8>>::Output;
10219
10220 assert_eq!(<N2MulN4 as Integer>::to_i64(), <P8 as Integer>::to_i64());
10221 }
10222 #[test]
10223 #[allow(non_snake_case)]
10224 fn test_N2_Min_N4() {
10225 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10226 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
10227 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
10228
10229 #[allow(non_camel_case_types)]
10230 type N2MinN4 = <<A as Min<B>>::Output as Same<N4>>::Output;
10231
10232 assert_eq!(<N2MinN4 as Integer>::to_i64(), <N4 as Integer>::to_i64());
10233 }
10234 #[test]
10235 #[allow(non_snake_case)]
10236 fn test_N2_Max_N4() {
10237 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10238 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
10239 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
10240
10241 #[allow(non_camel_case_types)]
10242 type N2MaxN4 = <<A as Max<B>>::Output as Same<N2>>::Output;
10243
10244 assert_eq!(<N2MaxN4 as Integer>::to_i64(), <N2 as Integer>::to_i64());
10245 }
10246 #[test]
10247 #[allow(non_snake_case)]
10248 fn test_N2_Gcd_N4() {
10249 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10250 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
10251 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
10252
10253 #[allow(non_camel_case_types)]
10254 type N2GcdN4 = <<A as Gcd<B>>::Output as Same<P2>>::Output;
10255
10256 assert_eq!(<N2GcdN4 as Integer>::to_i64(), <P2 as Integer>::to_i64());
10257 }
10258 #[test]
10259 #[allow(non_snake_case)]
10260 fn test_N2_Div_N4() {
10261 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10262 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
10263 type _0 = Z0;
10264
10265 #[allow(non_camel_case_types)]
10266 type N2DivN4 = <<A as Div<B>>::Output as Same<_0>>::Output;
10267
10268 assert_eq!(<N2DivN4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
10269 }
10270 #[test]
10271 #[allow(non_snake_case)]
10272 fn test_N2_Rem_N4() {
10273 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10274 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
10275 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
10276
10277 #[allow(non_camel_case_types)]
10278 type N2RemN4 = <<A as Rem<B>>::Output as Same<N2>>::Output;
10279
10280 assert_eq!(<N2RemN4 as Integer>::to_i64(), <N2 as Integer>::to_i64());
10281 }
10282 #[test]
10283 #[allow(non_snake_case)]
10284 fn test_N2_Cmp_N4() {
10285 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10286 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
10287
10288 #[allow(non_camel_case_types)]
10289 type N2CmpN4 = <A as Cmp<B>>::Output;
10290 assert_eq!(<N2CmpN4 as Ord>::to_ordering(), Ordering::Greater);
10291 }
10292 #[test]
10293 #[allow(non_snake_case)]
10294 fn test_N2_Add_N3() {
10295 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10296 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
10297 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
10298
10299 #[allow(non_camel_case_types)]
10300 type N2AddN3 = <<A as Add<B>>::Output as Same<N5>>::Output;
10301
10302 assert_eq!(<N2AddN3 as Integer>::to_i64(), <N5 as Integer>::to_i64());
10303 }
10304 #[test]
10305 #[allow(non_snake_case)]
10306 fn test_N2_Sub_N3() {
10307 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10308 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
10309 type P1 = PInt<UInt<UTerm, B1>>;
10310
10311 #[allow(non_camel_case_types)]
10312 type N2SubN3 = <<A as Sub<B>>::Output as Same<P1>>::Output;
10313
10314 assert_eq!(<N2SubN3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
10315 }
10316 #[test]
10317 #[allow(non_snake_case)]
10318 fn test_N2_Mul_N3() {
10319 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10320 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
10321 type P6 = PInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
10322
10323 #[allow(non_camel_case_types)]
10324 type N2MulN3 = <<A as Mul<B>>::Output as Same<P6>>::Output;
10325
10326 assert_eq!(<N2MulN3 as Integer>::to_i64(), <P6 as Integer>::to_i64());
10327 }
10328 #[test]
10329 #[allow(non_snake_case)]
10330 fn test_N2_Min_N3() {
10331 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10332 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
10333 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
10334
10335 #[allow(non_camel_case_types)]
10336 type N2MinN3 = <<A as Min<B>>::Output as Same<N3>>::Output;
10337
10338 assert_eq!(<N2MinN3 as Integer>::to_i64(), <N3 as Integer>::to_i64());
10339 }
10340 #[test]
10341 #[allow(non_snake_case)]
10342 fn test_N2_Max_N3() {
10343 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10344 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
10345 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
10346
10347 #[allow(non_camel_case_types)]
10348 type N2MaxN3 = <<A as Max<B>>::Output as Same<N2>>::Output;
10349
10350 assert_eq!(<N2MaxN3 as Integer>::to_i64(), <N2 as Integer>::to_i64());
10351 }
10352 #[test]
10353 #[allow(non_snake_case)]
10354 fn test_N2_Gcd_N3() {
10355 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10356 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
10357 type P1 = PInt<UInt<UTerm, B1>>;
10358
10359 #[allow(non_camel_case_types)]
10360 type N2GcdN3 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
10361
10362 assert_eq!(<N2GcdN3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
10363 }
10364 #[test]
10365 #[allow(non_snake_case)]
10366 fn test_N2_Div_N3() {
10367 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10368 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
10369 type _0 = Z0;
10370
10371 #[allow(non_camel_case_types)]
10372 type N2DivN3 = <<A as Div<B>>::Output as Same<_0>>::Output;
10373
10374 assert_eq!(<N2DivN3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
10375 }
10376 #[test]
10377 #[allow(non_snake_case)]
10378 fn test_N2_Rem_N3() {
10379 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10380 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
10381 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
10382
10383 #[allow(non_camel_case_types)]
10384 type N2RemN3 = <<A as Rem<B>>::Output as Same<N2>>::Output;
10385
10386 assert_eq!(<N2RemN3 as Integer>::to_i64(), <N2 as Integer>::to_i64());
10387 }
10388 #[test]
10389 #[allow(non_snake_case)]
10390 fn test_N2_Cmp_N3() {
10391 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10392 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
10393
10394 #[allow(non_camel_case_types)]
10395 type N2CmpN3 = <A as Cmp<B>>::Output;
10396 assert_eq!(<N2CmpN3 as Ord>::to_ordering(), Ordering::Greater);
10397 }
10398 #[test]
10399 #[allow(non_snake_case)]
10400 fn test_N2_Add_N2() {
10401 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10402 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
10403 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
10404
10405 #[allow(non_camel_case_types)]
10406 type N2AddN2 = <<A as Add<B>>::Output as Same<N4>>::Output;
10407
10408 assert_eq!(<N2AddN2 as Integer>::to_i64(), <N4 as Integer>::to_i64());
10409 }
10410 #[test]
10411 #[allow(non_snake_case)]
10412 fn test_N2_Sub_N2() {
10413 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10414 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
10415 type _0 = Z0;
10416
10417 #[allow(non_camel_case_types)]
10418 type N2SubN2 = <<A as Sub<B>>::Output as Same<_0>>::Output;
10419
10420 assert_eq!(<N2SubN2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
10421 }
10422 #[test]
10423 #[allow(non_snake_case)]
10424 fn test_N2_Mul_N2() {
10425 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10426 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
10427 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
10428
10429 #[allow(non_camel_case_types)]
10430 type N2MulN2 = <<A as Mul<B>>::Output as Same<P4>>::Output;
10431
10432 assert_eq!(<N2MulN2 as Integer>::to_i64(), <P4 as Integer>::to_i64());
10433 }
10434 #[test]
10435 #[allow(non_snake_case)]
10436 fn test_N2_Min_N2() {
10437 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10438 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
10439 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
10440
10441 #[allow(non_camel_case_types)]
10442 type N2MinN2 = <<A as Min<B>>::Output as Same<N2>>::Output;
10443
10444 assert_eq!(<N2MinN2 as Integer>::to_i64(), <N2 as Integer>::to_i64());
10445 }
10446 #[test]
10447 #[allow(non_snake_case)]
10448 fn test_N2_Max_N2() {
10449 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10450 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
10451 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
10452
10453 #[allow(non_camel_case_types)]
10454 type N2MaxN2 = <<A as Max<B>>::Output as Same<N2>>::Output;
10455
10456 assert_eq!(<N2MaxN2 as Integer>::to_i64(), <N2 as Integer>::to_i64());
10457 }
10458 #[test]
10459 #[allow(non_snake_case)]
10460 fn test_N2_Gcd_N2() {
10461 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10462 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
10463 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
10464
10465 #[allow(non_camel_case_types)]
10466 type N2GcdN2 = <<A as Gcd<B>>::Output as Same<P2>>::Output;
10467
10468 assert_eq!(<N2GcdN2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
10469 }
10470 #[test]
10471 #[allow(non_snake_case)]
10472 fn test_N2_Div_N2() {
10473 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10474 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
10475 type P1 = PInt<UInt<UTerm, B1>>;
10476
10477 #[allow(non_camel_case_types)]
10478 type N2DivN2 = <<A as Div<B>>::Output as Same<P1>>::Output;
10479
10480 assert_eq!(<N2DivN2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
10481 }
10482 #[test]
10483 #[allow(non_snake_case)]
10484 fn test_N2_Rem_N2() {
10485 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10486 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
10487 type _0 = Z0;
10488
10489 #[allow(non_camel_case_types)]
10490 type N2RemN2 = <<A as Rem<B>>::Output as Same<_0>>::Output;
10491
10492 assert_eq!(<N2RemN2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
10493 }
10494 #[test]
10495 #[allow(non_snake_case)]
10496 fn test_N2_PartialDiv_N2() {
10497 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10498 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
10499 type P1 = PInt<UInt<UTerm, B1>>;
10500
10501 #[allow(non_camel_case_types)]
10502 type N2PartialDivN2 = <<A as PartialDiv<B>>::Output as Same<P1>>::Output;
10503
10504 assert_eq!(<N2PartialDivN2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
10505 }
10506 #[test]
10507 #[allow(non_snake_case)]
10508 fn test_N2_Cmp_N2() {
10509 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10510 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
10511
10512 #[allow(non_camel_case_types)]
10513 type N2CmpN2 = <A as Cmp<B>>::Output;
10514 assert_eq!(<N2CmpN2 as Ord>::to_ordering(), Ordering::Equal);
10515 }
10516 #[test]
10517 #[allow(non_snake_case)]
10518 fn test_N2_Add_N1() {
10519 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10520 type B = NInt<UInt<UTerm, B1>>;
10521 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
10522
10523 #[allow(non_camel_case_types)]
10524 type N2AddN1 = <<A as Add<B>>::Output as Same<N3>>::Output;
10525
10526 assert_eq!(<N2AddN1 as Integer>::to_i64(), <N3 as Integer>::to_i64());
10527 }
10528 #[test]
10529 #[allow(non_snake_case)]
10530 fn test_N2_Sub_N1() {
10531 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10532 type B = NInt<UInt<UTerm, B1>>;
10533 type N1 = NInt<UInt<UTerm, B1>>;
10534
10535 #[allow(non_camel_case_types)]
10536 type N2SubN1 = <<A as Sub<B>>::Output as Same<N1>>::Output;
10537
10538 assert_eq!(<N2SubN1 as Integer>::to_i64(), <N1 as Integer>::to_i64());
10539 }
10540 #[test]
10541 #[allow(non_snake_case)]
10542 fn test_N2_Mul_N1() {
10543 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10544 type B = NInt<UInt<UTerm, B1>>;
10545 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
10546
10547 #[allow(non_camel_case_types)]
10548 type N2MulN1 = <<A as Mul<B>>::Output as Same<P2>>::Output;
10549
10550 assert_eq!(<N2MulN1 as Integer>::to_i64(), <P2 as Integer>::to_i64());
10551 }
10552 #[test]
10553 #[allow(non_snake_case)]
10554 fn test_N2_Min_N1() {
10555 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10556 type B = NInt<UInt<UTerm, B1>>;
10557 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
10558
10559 #[allow(non_camel_case_types)]
10560 type N2MinN1 = <<A as Min<B>>::Output as Same<N2>>::Output;
10561
10562 assert_eq!(<N2MinN1 as Integer>::to_i64(), <N2 as Integer>::to_i64());
10563 }
10564 #[test]
10565 #[allow(non_snake_case)]
10566 fn test_N2_Max_N1() {
10567 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10568 type B = NInt<UInt<UTerm, B1>>;
10569 type N1 = NInt<UInt<UTerm, B1>>;
10570
10571 #[allow(non_camel_case_types)]
10572 type N2MaxN1 = <<A as Max<B>>::Output as Same<N1>>::Output;
10573
10574 assert_eq!(<N2MaxN1 as Integer>::to_i64(), <N1 as Integer>::to_i64());
10575 }
10576 #[test]
10577 #[allow(non_snake_case)]
10578 fn test_N2_Gcd_N1() {
10579 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10580 type B = NInt<UInt<UTerm, B1>>;
10581 type P1 = PInt<UInt<UTerm, B1>>;
10582
10583 #[allow(non_camel_case_types)]
10584 type N2GcdN1 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
10585
10586 assert_eq!(<N2GcdN1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
10587 }
10588 #[test]
10589 #[allow(non_snake_case)]
10590 fn test_N2_Div_N1() {
10591 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10592 type B = NInt<UInt<UTerm, B1>>;
10593 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
10594
10595 #[allow(non_camel_case_types)]
10596 type N2DivN1 = <<A as Div<B>>::Output as Same<P2>>::Output;
10597
10598 assert_eq!(<N2DivN1 as Integer>::to_i64(), <P2 as Integer>::to_i64());
10599 }
10600 #[test]
10601 #[allow(non_snake_case)]
10602 fn test_N2_Rem_N1() {
10603 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10604 type B = NInt<UInt<UTerm, B1>>;
10605 type _0 = Z0;
10606
10607 #[allow(non_camel_case_types)]
10608 type N2RemN1 = <<A as Rem<B>>::Output as Same<_0>>::Output;
10609
10610 assert_eq!(<N2RemN1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
10611 }
10612 #[test]
10613 #[allow(non_snake_case)]
10614 fn test_N2_PartialDiv_N1() {
10615 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10616 type B = NInt<UInt<UTerm, B1>>;
10617 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
10618
10619 #[allow(non_camel_case_types)]
10620 type N2PartialDivN1 = <<A as PartialDiv<B>>::Output as Same<P2>>::Output;
10621
10622 assert_eq!(<N2PartialDivN1 as Integer>::to_i64(), <P2 as Integer>::to_i64());
10623 }
10624 #[test]
10625 #[allow(non_snake_case)]
10626 fn test_N2_Cmp_N1() {
10627 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10628 type B = NInt<UInt<UTerm, B1>>;
10629
10630 #[allow(non_camel_case_types)]
10631 type N2CmpN1 = <A as Cmp<B>>::Output;
10632 assert_eq!(<N2CmpN1 as Ord>::to_ordering(), Ordering::Less);
10633 }
10634 #[test]
10635 #[allow(non_snake_case)]
10636 fn test_N2_Add__0() {
10637 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10638 type B = Z0;
10639 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
10640
10641 #[allow(non_camel_case_types)]
10642 type N2Add_0 = <<A as Add<B>>::Output as Same<N2>>::Output;
10643
10644 assert_eq!(<N2Add_0 as Integer>::to_i64(), <N2 as Integer>::to_i64());
10645 }
10646 #[test]
10647 #[allow(non_snake_case)]
10648 fn test_N2_Sub__0() {
10649 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10650 type B = Z0;
10651 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
10652
10653 #[allow(non_camel_case_types)]
10654 type N2Sub_0 = <<A as Sub<B>>::Output as Same<N2>>::Output;
10655
10656 assert_eq!(<N2Sub_0 as Integer>::to_i64(), <N2 as Integer>::to_i64());
10657 }
10658 #[test]
10659 #[allow(non_snake_case)]
10660 fn test_N2_Mul__0() {
10661 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10662 type B = Z0;
10663 type _0 = Z0;
10664
10665 #[allow(non_camel_case_types)]
10666 type N2Mul_0 = <<A as Mul<B>>::Output as Same<_0>>::Output;
10667
10668 assert_eq!(<N2Mul_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
10669 }
10670 #[test]
10671 #[allow(non_snake_case)]
10672 fn test_N2_Min__0() {
10673 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10674 type B = Z0;
10675 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
10676
10677 #[allow(non_camel_case_types)]
10678 type N2Min_0 = <<A as Min<B>>::Output as Same<N2>>::Output;
10679
10680 assert_eq!(<N2Min_0 as Integer>::to_i64(), <N2 as Integer>::to_i64());
10681 }
10682 #[test]
10683 #[allow(non_snake_case)]
10684 fn test_N2_Max__0() {
10685 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10686 type B = Z0;
10687 type _0 = Z0;
10688
10689 #[allow(non_camel_case_types)]
10690 type N2Max_0 = <<A as Max<B>>::Output as Same<_0>>::Output;
10691
10692 assert_eq!(<N2Max_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
10693 }
10694 #[test]
10695 #[allow(non_snake_case)]
10696 fn test_N2_Gcd__0() {
10697 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10698 type B = Z0;
10699 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
10700
10701 #[allow(non_camel_case_types)]
10702 type N2Gcd_0 = <<A as Gcd<B>>::Output as Same<P2>>::Output;
10703
10704 assert_eq!(<N2Gcd_0 as Integer>::to_i64(), <P2 as Integer>::to_i64());
10705 }
10706 #[test]
10707 #[allow(non_snake_case)]
10708 fn test_N2_Pow__0() {
10709 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10710 type B = Z0;
10711 type P1 = PInt<UInt<UTerm, B1>>;
10712
10713 #[allow(non_camel_case_types)]
10714 type N2Pow_0 = <<A as Pow<B>>::Output as Same<P1>>::Output;
10715
10716 assert_eq!(<N2Pow_0 as Integer>::to_i64(), <P1 as Integer>::to_i64());
10717 }
10718 #[test]
10719 #[allow(non_snake_case)]
10720 fn test_N2_Cmp__0() {
10721 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10722 type B = Z0;
10723
10724 #[allow(non_camel_case_types)]
10725 type N2Cmp_0 = <A as Cmp<B>>::Output;
10726 assert_eq!(<N2Cmp_0 as Ord>::to_ordering(), Ordering::Less);
10727 }
10728 #[test]
10729 #[allow(non_snake_case)]
10730 fn test_N2_Add_P1() {
10731 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10732 type B = PInt<UInt<UTerm, B1>>;
10733 type N1 = NInt<UInt<UTerm, B1>>;
10734
10735 #[allow(non_camel_case_types)]
10736 type N2AddP1 = <<A as Add<B>>::Output as Same<N1>>::Output;
10737
10738 assert_eq!(<N2AddP1 as Integer>::to_i64(), <N1 as Integer>::to_i64());
10739 }
10740 #[test]
10741 #[allow(non_snake_case)]
10742 fn test_N2_Sub_P1() {
10743 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10744 type B = PInt<UInt<UTerm, B1>>;
10745 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
10746
10747 #[allow(non_camel_case_types)]
10748 type N2SubP1 = <<A as Sub<B>>::Output as Same<N3>>::Output;
10749
10750 assert_eq!(<N2SubP1 as Integer>::to_i64(), <N3 as Integer>::to_i64());
10751 }
10752 #[test]
10753 #[allow(non_snake_case)]
10754 fn test_N2_Mul_P1() {
10755 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10756 type B = PInt<UInt<UTerm, B1>>;
10757 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
10758
10759 #[allow(non_camel_case_types)]
10760 type N2MulP1 = <<A as Mul<B>>::Output as Same<N2>>::Output;
10761
10762 assert_eq!(<N2MulP1 as Integer>::to_i64(), <N2 as Integer>::to_i64());
10763 }
10764 #[test]
10765 #[allow(non_snake_case)]
10766 fn test_N2_Min_P1() {
10767 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10768 type B = PInt<UInt<UTerm, B1>>;
10769 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
10770
10771 #[allow(non_camel_case_types)]
10772 type N2MinP1 = <<A as Min<B>>::Output as Same<N2>>::Output;
10773
10774 assert_eq!(<N2MinP1 as Integer>::to_i64(), <N2 as Integer>::to_i64());
10775 }
10776 #[test]
10777 #[allow(non_snake_case)]
10778 fn test_N2_Max_P1() {
10779 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10780 type B = PInt<UInt<UTerm, B1>>;
10781 type P1 = PInt<UInt<UTerm, B1>>;
10782
10783 #[allow(non_camel_case_types)]
10784 type N2MaxP1 = <<A as Max<B>>::Output as Same<P1>>::Output;
10785
10786 assert_eq!(<N2MaxP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
10787 }
10788 #[test]
10789 #[allow(non_snake_case)]
10790 fn test_N2_Gcd_P1() {
10791 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10792 type B = PInt<UInt<UTerm, B1>>;
10793 type P1 = PInt<UInt<UTerm, B1>>;
10794
10795 #[allow(non_camel_case_types)]
10796 type N2GcdP1 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
10797
10798 assert_eq!(<N2GcdP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
10799 }
10800 #[test]
10801 #[allow(non_snake_case)]
10802 fn test_N2_Div_P1() {
10803 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10804 type B = PInt<UInt<UTerm, B1>>;
10805 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
10806
10807 #[allow(non_camel_case_types)]
10808 type N2DivP1 = <<A as Div<B>>::Output as Same<N2>>::Output;
10809
10810 assert_eq!(<N2DivP1 as Integer>::to_i64(), <N2 as Integer>::to_i64());
10811 }
10812 #[test]
10813 #[allow(non_snake_case)]
10814 fn test_N2_Rem_P1() {
10815 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10816 type B = PInt<UInt<UTerm, B1>>;
10817 type _0 = Z0;
10818
10819 #[allow(non_camel_case_types)]
10820 type N2RemP1 = <<A as Rem<B>>::Output as Same<_0>>::Output;
10821
10822 assert_eq!(<N2RemP1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
10823 }
10824 #[test]
10825 #[allow(non_snake_case)]
10826 fn test_N2_PartialDiv_P1() {
10827 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10828 type B = PInt<UInt<UTerm, B1>>;
10829 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
10830
10831 #[allow(non_camel_case_types)]
10832 type N2PartialDivP1 = <<A as PartialDiv<B>>::Output as Same<N2>>::Output;
10833
10834 assert_eq!(<N2PartialDivP1 as Integer>::to_i64(), <N2 as Integer>::to_i64());
10835 }
10836 #[test]
10837 #[allow(non_snake_case)]
10838 fn test_N2_Pow_P1() {
10839 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10840 type B = PInt<UInt<UTerm, B1>>;
10841 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
10842
10843 #[allow(non_camel_case_types)]
10844 type N2PowP1 = <<A as Pow<B>>::Output as Same<N2>>::Output;
10845
10846 assert_eq!(<N2PowP1 as Integer>::to_i64(), <N2 as Integer>::to_i64());
10847 }
10848 #[test]
10849 #[allow(non_snake_case)]
10850 fn test_N2_Cmp_P1() {
10851 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10852 type B = PInt<UInt<UTerm, B1>>;
10853
10854 #[allow(non_camel_case_types)]
10855 type N2CmpP1 = <A as Cmp<B>>::Output;
10856 assert_eq!(<N2CmpP1 as Ord>::to_ordering(), Ordering::Less);
10857 }
10858 #[test]
10859 #[allow(non_snake_case)]
10860 fn test_N2_Add_P2() {
10861 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10862 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
10863 type _0 = Z0;
10864
10865 #[allow(non_camel_case_types)]
10866 type N2AddP2 = <<A as Add<B>>::Output as Same<_0>>::Output;
10867
10868 assert_eq!(<N2AddP2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
10869 }
10870 #[test]
10871 #[allow(non_snake_case)]
10872 fn test_N2_Sub_P2() {
10873 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10874 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
10875 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
10876
10877 #[allow(non_camel_case_types)]
10878 type N2SubP2 = <<A as Sub<B>>::Output as Same<N4>>::Output;
10879
10880 assert_eq!(<N2SubP2 as Integer>::to_i64(), <N4 as Integer>::to_i64());
10881 }
10882 #[test]
10883 #[allow(non_snake_case)]
10884 fn test_N2_Mul_P2() {
10885 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10886 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
10887 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
10888
10889 #[allow(non_camel_case_types)]
10890 type N2MulP2 = <<A as Mul<B>>::Output as Same<N4>>::Output;
10891
10892 assert_eq!(<N2MulP2 as Integer>::to_i64(), <N4 as Integer>::to_i64());
10893 }
10894 #[test]
10895 #[allow(non_snake_case)]
10896 fn test_N2_Min_P2() {
10897 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10898 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
10899 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
10900
10901 #[allow(non_camel_case_types)]
10902 type N2MinP2 = <<A as Min<B>>::Output as Same<N2>>::Output;
10903
10904 assert_eq!(<N2MinP2 as Integer>::to_i64(), <N2 as Integer>::to_i64());
10905 }
10906 #[test]
10907 #[allow(non_snake_case)]
10908 fn test_N2_Max_P2() {
10909 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10910 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
10911 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
10912
10913 #[allow(non_camel_case_types)]
10914 type N2MaxP2 = <<A as Max<B>>::Output as Same<P2>>::Output;
10915
10916 assert_eq!(<N2MaxP2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
10917 }
10918 #[test]
10919 #[allow(non_snake_case)]
10920 fn test_N2_Gcd_P2() {
10921 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10922 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
10923 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
10924
10925 #[allow(non_camel_case_types)]
10926 type N2GcdP2 = <<A as Gcd<B>>::Output as Same<P2>>::Output;
10927
10928 assert_eq!(<N2GcdP2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
10929 }
10930 #[test]
10931 #[allow(non_snake_case)]
10932 fn test_N2_Div_P2() {
10933 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10934 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
10935 type N1 = NInt<UInt<UTerm, B1>>;
10936
10937 #[allow(non_camel_case_types)]
10938 type N2DivP2 = <<A as Div<B>>::Output as Same<N1>>::Output;
10939
10940 assert_eq!(<N2DivP2 as Integer>::to_i64(), <N1 as Integer>::to_i64());
10941 }
10942 #[test]
10943 #[allow(non_snake_case)]
10944 fn test_N2_Rem_P2() {
10945 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10946 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
10947 type _0 = Z0;
10948
10949 #[allow(non_camel_case_types)]
10950 type N2RemP2 = <<A as Rem<B>>::Output as Same<_0>>::Output;
10951
10952 assert_eq!(<N2RemP2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
10953 }
10954 #[test]
10955 #[allow(non_snake_case)]
10956 fn test_N2_PartialDiv_P2() {
10957 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10958 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
10959 type N1 = NInt<UInt<UTerm, B1>>;
10960
10961 #[allow(non_camel_case_types)]
10962 type N2PartialDivP2 = <<A as PartialDiv<B>>::Output as Same<N1>>::Output;
10963
10964 assert_eq!(<N2PartialDivP2 as Integer>::to_i64(), <N1 as Integer>::to_i64());
10965 }
10966 #[test]
10967 #[allow(non_snake_case)]
10968 fn test_N2_Pow_P2() {
10969 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10970 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
10971 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
10972
10973 #[allow(non_camel_case_types)]
10974 type N2PowP2 = <<A as Pow<B>>::Output as Same<P4>>::Output;
10975
10976 assert_eq!(<N2PowP2 as Integer>::to_i64(), <P4 as Integer>::to_i64());
10977 }
10978 #[test]
10979 #[allow(non_snake_case)]
10980 fn test_N2_Cmp_P2() {
10981 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10982 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
10983
10984 #[allow(non_camel_case_types)]
10985 type N2CmpP2 = <A as Cmp<B>>::Output;
10986 assert_eq!(<N2CmpP2 as Ord>::to_ordering(), Ordering::Less);
10987 }
10988 #[test]
10989 #[allow(non_snake_case)]
10990 fn test_N2_Add_P3() {
10991 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
10992 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
10993 type P1 = PInt<UInt<UTerm, B1>>;
10994
10995 #[allow(non_camel_case_types)]
10996 type N2AddP3 = <<A as Add<B>>::Output as Same<P1>>::Output;
10997
10998 assert_eq!(<N2AddP3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
10999 }
11000 #[test]
11001 #[allow(non_snake_case)]
11002 fn test_N2_Sub_P3() {
11003 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11004 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
11005 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
11006
11007 #[allow(non_camel_case_types)]
11008 type N2SubP3 = <<A as Sub<B>>::Output as Same<N5>>::Output;
11009
11010 assert_eq!(<N2SubP3 as Integer>::to_i64(), <N5 as Integer>::to_i64());
11011 }
11012 #[test]
11013 #[allow(non_snake_case)]
11014 fn test_N2_Mul_P3() {
11015 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11016 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
11017 type N6 = NInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
11018
11019 #[allow(non_camel_case_types)]
11020 type N2MulP3 = <<A as Mul<B>>::Output as Same<N6>>::Output;
11021
11022 assert_eq!(<N2MulP3 as Integer>::to_i64(), <N6 as Integer>::to_i64());
11023 }
11024 #[test]
11025 #[allow(non_snake_case)]
11026 fn test_N2_Min_P3() {
11027 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11028 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
11029 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
11030
11031 #[allow(non_camel_case_types)]
11032 type N2MinP3 = <<A as Min<B>>::Output as Same<N2>>::Output;
11033
11034 assert_eq!(<N2MinP3 as Integer>::to_i64(), <N2 as Integer>::to_i64());
11035 }
11036 #[test]
11037 #[allow(non_snake_case)]
11038 fn test_N2_Max_P3() {
11039 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11040 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
11041 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
11042
11043 #[allow(non_camel_case_types)]
11044 type N2MaxP3 = <<A as Max<B>>::Output as Same<P3>>::Output;
11045
11046 assert_eq!(<N2MaxP3 as Integer>::to_i64(), <P3 as Integer>::to_i64());
11047 }
11048 #[test]
11049 #[allow(non_snake_case)]
11050 fn test_N2_Gcd_P3() {
11051 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11052 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
11053 type P1 = PInt<UInt<UTerm, B1>>;
11054
11055 #[allow(non_camel_case_types)]
11056 type N2GcdP3 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
11057
11058 assert_eq!(<N2GcdP3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
11059 }
11060 #[test]
11061 #[allow(non_snake_case)]
11062 fn test_N2_Div_P3() {
11063 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11064 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
11065 type _0 = Z0;
11066
11067 #[allow(non_camel_case_types)]
11068 type N2DivP3 = <<A as Div<B>>::Output as Same<_0>>::Output;
11069
11070 assert_eq!(<N2DivP3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
11071 }
11072 #[test]
11073 #[allow(non_snake_case)]
11074 fn test_N2_Rem_P3() {
11075 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11076 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
11077 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
11078
11079 #[allow(non_camel_case_types)]
11080 type N2RemP3 = <<A as Rem<B>>::Output as Same<N2>>::Output;
11081
11082 assert_eq!(<N2RemP3 as Integer>::to_i64(), <N2 as Integer>::to_i64());
11083 }
11084 #[test]
11085 #[allow(non_snake_case)]
11086 fn test_N2_Pow_P3() {
11087 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11088 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
11089 type N8 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>;
11090
11091 #[allow(non_camel_case_types)]
11092 type N2PowP3 = <<A as Pow<B>>::Output as Same<N8>>::Output;
11093
11094 assert_eq!(<N2PowP3 as Integer>::to_i64(), <N8 as Integer>::to_i64());
11095 }
11096 #[test]
11097 #[allow(non_snake_case)]
11098 fn test_N2_Cmp_P3() {
11099 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11100 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
11101
11102 #[allow(non_camel_case_types)]
11103 type N2CmpP3 = <A as Cmp<B>>::Output;
11104 assert_eq!(<N2CmpP3 as Ord>::to_ordering(), Ordering::Less);
11105 }
11106 #[test]
11107 #[allow(non_snake_case)]
11108 fn test_N2_Add_P4() {
11109 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11110 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
11111 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
11112
11113 #[allow(non_camel_case_types)]
11114 type N2AddP4 = <<A as Add<B>>::Output as Same<P2>>::Output;
11115
11116 assert_eq!(<N2AddP4 as Integer>::to_i64(), <P2 as Integer>::to_i64());
11117 }
11118 #[test]
11119 #[allow(non_snake_case)]
11120 fn test_N2_Sub_P4() {
11121 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11122 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
11123 type N6 = NInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
11124
11125 #[allow(non_camel_case_types)]
11126 type N2SubP4 = <<A as Sub<B>>::Output as Same<N6>>::Output;
11127
11128 assert_eq!(<N2SubP4 as Integer>::to_i64(), <N6 as Integer>::to_i64());
11129 }
11130 #[test]
11131 #[allow(non_snake_case)]
11132 fn test_N2_Mul_P4() {
11133 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11134 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
11135 type N8 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>;
11136
11137 #[allow(non_camel_case_types)]
11138 type N2MulP4 = <<A as Mul<B>>::Output as Same<N8>>::Output;
11139
11140 assert_eq!(<N2MulP4 as Integer>::to_i64(), <N8 as Integer>::to_i64());
11141 }
11142 #[test]
11143 #[allow(non_snake_case)]
11144 fn test_N2_Min_P4() {
11145 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11146 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
11147 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
11148
11149 #[allow(non_camel_case_types)]
11150 type N2MinP4 = <<A as Min<B>>::Output as Same<N2>>::Output;
11151
11152 assert_eq!(<N2MinP4 as Integer>::to_i64(), <N2 as Integer>::to_i64());
11153 }
11154 #[test]
11155 #[allow(non_snake_case)]
11156 fn test_N2_Max_P4() {
11157 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11158 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
11159 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
11160
11161 #[allow(non_camel_case_types)]
11162 type N2MaxP4 = <<A as Max<B>>::Output as Same<P4>>::Output;
11163
11164 assert_eq!(<N2MaxP4 as Integer>::to_i64(), <P4 as Integer>::to_i64());
11165 }
11166 #[test]
11167 #[allow(non_snake_case)]
11168 fn test_N2_Gcd_P4() {
11169 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11170 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
11171 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
11172
11173 #[allow(non_camel_case_types)]
11174 type N2GcdP4 = <<A as Gcd<B>>::Output as Same<P2>>::Output;
11175
11176 assert_eq!(<N2GcdP4 as Integer>::to_i64(), <P2 as Integer>::to_i64());
11177 }
11178 #[test]
11179 #[allow(non_snake_case)]
11180 fn test_N2_Div_P4() {
11181 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11182 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
11183 type _0 = Z0;
11184
11185 #[allow(non_camel_case_types)]
11186 type N2DivP4 = <<A as Div<B>>::Output as Same<_0>>::Output;
11187
11188 assert_eq!(<N2DivP4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
11189 }
11190 #[test]
11191 #[allow(non_snake_case)]
11192 fn test_N2_Rem_P4() {
11193 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11194 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
11195 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
11196
11197 #[allow(non_camel_case_types)]
11198 type N2RemP4 = <<A as Rem<B>>::Output as Same<N2>>::Output;
11199
11200 assert_eq!(<N2RemP4 as Integer>::to_i64(), <N2 as Integer>::to_i64());
11201 }
11202 #[test]
11203 #[allow(non_snake_case)]
11204 fn test_N2_Pow_P4() {
11205 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11206 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
11207 type P16 = PInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>>;
11208
11209 #[allow(non_camel_case_types)]
11210 type N2PowP4 = <<A as Pow<B>>::Output as Same<P16>>::Output;
11211
11212 assert_eq!(<N2PowP4 as Integer>::to_i64(), <P16 as Integer>::to_i64());
11213 }
11214 #[test]
11215 #[allow(non_snake_case)]
11216 fn test_N2_Cmp_P4() {
11217 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11218 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
11219
11220 #[allow(non_camel_case_types)]
11221 type N2CmpP4 = <A as Cmp<B>>::Output;
11222 assert_eq!(<N2CmpP4 as Ord>::to_ordering(), Ordering::Less);
11223 }
11224 #[test]
11225 #[allow(non_snake_case)]
11226 fn test_N2_Add_P5() {
11227 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11228 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
11229 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
11230
11231 #[allow(non_camel_case_types)]
11232 type N2AddP5 = <<A as Add<B>>::Output as Same<P3>>::Output;
11233
11234 assert_eq!(<N2AddP5 as Integer>::to_i64(), <P3 as Integer>::to_i64());
11235 }
11236 #[test]
11237 #[allow(non_snake_case)]
11238 fn test_N2_Sub_P5() {
11239 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11240 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
11241 type N7 = NInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>>;
11242
11243 #[allow(non_camel_case_types)]
11244 type N2SubP5 = <<A as Sub<B>>::Output as Same<N7>>::Output;
11245
11246 assert_eq!(<N2SubP5 as Integer>::to_i64(), <N7 as Integer>::to_i64());
11247 }
11248 #[test]
11249 #[allow(non_snake_case)]
11250 fn test_N2_Mul_P5() {
11251 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11252 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
11253 type N10 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>;
11254
11255 #[allow(non_camel_case_types)]
11256 type N2MulP5 = <<A as Mul<B>>::Output as Same<N10>>::Output;
11257
11258 assert_eq!(<N2MulP5 as Integer>::to_i64(), <N10 as Integer>::to_i64());
11259 }
11260 #[test]
11261 #[allow(non_snake_case)]
11262 fn test_N2_Min_P5() {
11263 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11264 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
11265 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
11266
11267 #[allow(non_camel_case_types)]
11268 type N2MinP5 = <<A as Min<B>>::Output as Same<N2>>::Output;
11269
11270 assert_eq!(<N2MinP5 as Integer>::to_i64(), <N2 as Integer>::to_i64());
11271 }
11272 #[test]
11273 #[allow(non_snake_case)]
11274 fn test_N2_Max_P5() {
11275 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11276 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
11277 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
11278
11279 #[allow(non_camel_case_types)]
11280 type N2MaxP5 = <<A as Max<B>>::Output as Same<P5>>::Output;
11281
11282 assert_eq!(<N2MaxP5 as Integer>::to_i64(), <P5 as Integer>::to_i64());
11283 }
11284 #[test]
11285 #[allow(non_snake_case)]
11286 fn test_N2_Gcd_P5() {
11287 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11288 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
11289 type P1 = PInt<UInt<UTerm, B1>>;
11290
11291 #[allow(non_camel_case_types)]
11292 type N2GcdP5 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
11293
11294 assert_eq!(<N2GcdP5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
11295 }
11296 #[test]
11297 #[allow(non_snake_case)]
11298 fn test_N2_Div_P5() {
11299 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11300 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
11301 type _0 = Z0;
11302
11303 #[allow(non_camel_case_types)]
11304 type N2DivP5 = <<A as Div<B>>::Output as Same<_0>>::Output;
11305
11306 assert_eq!(<N2DivP5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
11307 }
11308 #[test]
11309 #[allow(non_snake_case)]
11310 fn test_N2_Rem_P5() {
11311 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11312 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
11313 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
11314
11315 #[allow(non_camel_case_types)]
11316 type N2RemP5 = <<A as Rem<B>>::Output as Same<N2>>::Output;
11317
11318 assert_eq!(<N2RemP5 as Integer>::to_i64(), <N2 as Integer>::to_i64());
11319 }
11320 #[test]
11321 #[allow(non_snake_case)]
11322 fn test_N2_Pow_P5() {
11323 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11324 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
11325 type N32 = NInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>>;
11326
11327 #[allow(non_camel_case_types)]
11328 type N2PowP5 = <<A as Pow<B>>::Output as Same<N32>>::Output;
11329
11330 assert_eq!(<N2PowP5 as Integer>::to_i64(), <N32 as Integer>::to_i64());
11331 }
11332 #[test]
11333 #[allow(non_snake_case)]
11334 fn test_N2_Cmp_P5() {
11335 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
11336 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
11337
11338 #[allow(non_camel_case_types)]
11339 type N2CmpP5 = <A as Cmp<B>>::Output;
11340 assert_eq!(<N2CmpP5 as Ord>::to_ordering(), Ordering::Less);
11341 }
11342 #[test]
11343 #[allow(non_snake_case)]
11344 fn test_N1_Add_N5() {
11345 type A = NInt<UInt<UTerm, B1>>;
11346 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
11347 type N6 = NInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
11348
11349 #[allow(non_camel_case_types)]
11350 type N1AddN5 = <<A as Add<B>>::Output as Same<N6>>::Output;
11351
11352 assert_eq!(<N1AddN5 as Integer>::to_i64(), <N6 as Integer>::to_i64());
11353 }
11354 #[test]
11355 #[allow(non_snake_case)]
11356 fn test_N1_Sub_N5() {
11357 type A = NInt<UInt<UTerm, B1>>;
11358 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
11359 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
11360
11361 #[allow(non_camel_case_types)]
11362 type N1SubN5 = <<A as Sub<B>>::Output as Same<P4>>::Output;
11363
11364 assert_eq!(<N1SubN5 as Integer>::to_i64(), <P4 as Integer>::to_i64());
11365 }
11366 #[test]
11367 #[allow(non_snake_case)]
11368 fn test_N1_Mul_N5() {
11369 type A = NInt<UInt<UTerm, B1>>;
11370 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
11371 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
11372
11373 #[allow(non_camel_case_types)]
11374 type N1MulN5 = <<A as Mul<B>>::Output as Same<P5>>::Output;
11375
11376 assert_eq!(<N1MulN5 as Integer>::to_i64(), <P5 as Integer>::to_i64());
11377 }
11378 #[test]
11379 #[allow(non_snake_case)]
11380 fn test_N1_Min_N5() {
11381 type A = NInt<UInt<UTerm, B1>>;
11382 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
11383 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
11384
11385 #[allow(non_camel_case_types)]
11386 type N1MinN5 = <<A as Min<B>>::Output as Same<N5>>::Output;
11387
11388 assert_eq!(<N1MinN5 as Integer>::to_i64(), <N5 as Integer>::to_i64());
11389 }
11390 #[test]
11391 #[allow(non_snake_case)]
11392 fn test_N1_Max_N5() {
11393 type A = NInt<UInt<UTerm, B1>>;
11394 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
11395 type N1 = NInt<UInt<UTerm, B1>>;
11396
11397 #[allow(non_camel_case_types)]
11398 type N1MaxN5 = <<A as Max<B>>::Output as Same<N1>>::Output;
11399
11400 assert_eq!(<N1MaxN5 as Integer>::to_i64(), <N1 as Integer>::to_i64());
11401 }
11402 #[test]
11403 #[allow(non_snake_case)]
11404 fn test_N1_Gcd_N5() {
11405 type A = NInt<UInt<UTerm, B1>>;
11406 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
11407 type P1 = PInt<UInt<UTerm, B1>>;
11408
11409 #[allow(non_camel_case_types)]
11410 type N1GcdN5 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
11411
11412 assert_eq!(<N1GcdN5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
11413 }
11414 #[test]
11415 #[allow(non_snake_case)]
11416 fn test_N1_Div_N5() {
11417 type A = NInt<UInt<UTerm, B1>>;
11418 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
11419 type _0 = Z0;
11420
11421 #[allow(non_camel_case_types)]
11422 type N1DivN5 = <<A as Div<B>>::Output as Same<_0>>::Output;
11423
11424 assert_eq!(<N1DivN5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
11425 }
11426 #[test]
11427 #[allow(non_snake_case)]
11428 fn test_N1_Rem_N5() {
11429 type A = NInt<UInt<UTerm, B1>>;
11430 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
11431 type N1 = NInt<UInt<UTerm, B1>>;
11432
11433 #[allow(non_camel_case_types)]
11434 type N1RemN5 = <<A as Rem<B>>::Output as Same<N1>>::Output;
11435
11436 assert_eq!(<N1RemN5 as Integer>::to_i64(), <N1 as Integer>::to_i64());
11437 }
11438 #[test]
11439 #[allow(non_snake_case)]
11440 fn test_N1_Pow_N5() {
11441 type A = NInt<UInt<UTerm, B1>>;
11442 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
11443 type N1 = NInt<UInt<UTerm, B1>>;
11444
11445 #[allow(non_camel_case_types)]
11446 type N1PowN5 = <<A as Pow<B>>::Output as Same<N1>>::Output;
11447
11448 assert_eq!(<N1PowN5 as Integer>::to_i64(), <N1 as Integer>::to_i64());
11449 }
11450 #[test]
11451 #[allow(non_snake_case)]
11452 fn test_N1_Cmp_N5() {
11453 type A = NInt<UInt<UTerm, B1>>;
11454 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
11455
11456 #[allow(non_camel_case_types)]
11457 type N1CmpN5 = <A as Cmp<B>>::Output;
11458 assert_eq!(<N1CmpN5 as Ord>::to_ordering(), Ordering::Greater);
11459 }
11460 #[test]
11461 #[allow(non_snake_case)]
11462 fn test_N1_Add_N4() {
11463 type A = NInt<UInt<UTerm, B1>>;
11464 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
11465 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
11466
11467 #[allow(non_camel_case_types)]
11468 type N1AddN4 = <<A as Add<B>>::Output as Same<N5>>::Output;
11469
11470 assert_eq!(<N1AddN4 as Integer>::to_i64(), <N5 as Integer>::to_i64());
11471 }
11472 #[test]
11473 #[allow(non_snake_case)]
11474 fn test_N1_Sub_N4() {
11475 type A = NInt<UInt<UTerm, B1>>;
11476 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
11477 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
11478
11479 #[allow(non_camel_case_types)]
11480 type N1SubN4 = <<A as Sub<B>>::Output as Same<P3>>::Output;
11481
11482 assert_eq!(<N1SubN4 as Integer>::to_i64(), <P3 as Integer>::to_i64());
11483 }
11484 #[test]
11485 #[allow(non_snake_case)]
11486 fn test_N1_Mul_N4() {
11487 type A = NInt<UInt<UTerm, B1>>;
11488 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
11489 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
11490
11491 #[allow(non_camel_case_types)]
11492 type N1MulN4 = <<A as Mul<B>>::Output as Same<P4>>::Output;
11493
11494 assert_eq!(<N1MulN4 as Integer>::to_i64(), <P4 as Integer>::to_i64());
11495 }
11496 #[test]
11497 #[allow(non_snake_case)]
11498 fn test_N1_Min_N4() {
11499 type A = NInt<UInt<UTerm, B1>>;
11500 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
11501 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
11502
11503 #[allow(non_camel_case_types)]
11504 type N1MinN4 = <<A as Min<B>>::Output as Same<N4>>::Output;
11505
11506 assert_eq!(<N1MinN4 as Integer>::to_i64(), <N4 as Integer>::to_i64());
11507 }
11508 #[test]
11509 #[allow(non_snake_case)]
11510 fn test_N1_Max_N4() {
11511 type A = NInt<UInt<UTerm, B1>>;
11512 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
11513 type N1 = NInt<UInt<UTerm, B1>>;
11514
11515 #[allow(non_camel_case_types)]
11516 type N1MaxN4 = <<A as Max<B>>::Output as Same<N1>>::Output;
11517
11518 assert_eq!(<N1MaxN4 as Integer>::to_i64(), <N1 as Integer>::to_i64());
11519 }
11520 #[test]
11521 #[allow(non_snake_case)]
11522 fn test_N1_Gcd_N4() {
11523 type A = NInt<UInt<UTerm, B1>>;
11524 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
11525 type P1 = PInt<UInt<UTerm, B1>>;
11526
11527 #[allow(non_camel_case_types)]
11528 type N1GcdN4 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
11529
11530 assert_eq!(<N1GcdN4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
11531 }
11532 #[test]
11533 #[allow(non_snake_case)]
11534 fn test_N1_Div_N4() {
11535 type A = NInt<UInt<UTerm, B1>>;
11536 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
11537 type _0 = Z0;
11538
11539 #[allow(non_camel_case_types)]
11540 type N1DivN4 = <<A as Div<B>>::Output as Same<_0>>::Output;
11541
11542 assert_eq!(<N1DivN4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
11543 }
11544 #[test]
11545 #[allow(non_snake_case)]
11546 fn test_N1_Rem_N4() {
11547 type A = NInt<UInt<UTerm, B1>>;
11548 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
11549 type N1 = NInt<UInt<UTerm, B1>>;
11550
11551 #[allow(non_camel_case_types)]
11552 type N1RemN4 = <<A as Rem<B>>::Output as Same<N1>>::Output;
11553
11554 assert_eq!(<N1RemN4 as Integer>::to_i64(), <N1 as Integer>::to_i64());
11555 }
11556 #[test]
11557 #[allow(non_snake_case)]
11558 fn test_N1_Pow_N4() {
11559 type A = NInt<UInt<UTerm, B1>>;
11560 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
11561 type P1 = PInt<UInt<UTerm, B1>>;
11562
11563 #[allow(non_camel_case_types)]
11564 type N1PowN4 = <<A as Pow<B>>::Output as Same<P1>>::Output;
11565
11566 assert_eq!(<N1PowN4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
11567 }
11568 #[test]
11569 #[allow(non_snake_case)]
11570 fn test_N1_Cmp_N4() {
11571 type A = NInt<UInt<UTerm, B1>>;
11572 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
11573
11574 #[allow(non_camel_case_types)]
11575 type N1CmpN4 = <A as Cmp<B>>::Output;
11576 assert_eq!(<N1CmpN4 as Ord>::to_ordering(), Ordering::Greater);
11577 }
11578 #[test]
11579 #[allow(non_snake_case)]
11580 fn test_N1_Add_N3() {
11581 type A = NInt<UInt<UTerm, B1>>;
11582 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
11583 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
11584
11585 #[allow(non_camel_case_types)]
11586 type N1AddN3 = <<A as Add<B>>::Output as Same<N4>>::Output;
11587
11588 assert_eq!(<N1AddN3 as Integer>::to_i64(), <N4 as Integer>::to_i64());
11589 }
11590 #[test]
11591 #[allow(non_snake_case)]
11592 fn test_N1_Sub_N3() {
11593 type A = NInt<UInt<UTerm, B1>>;
11594 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
11595 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
11596
11597 #[allow(non_camel_case_types)]
11598 type N1SubN3 = <<A as Sub<B>>::Output as Same<P2>>::Output;
11599
11600 assert_eq!(<N1SubN3 as Integer>::to_i64(), <P2 as Integer>::to_i64());
11601 }
11602 #[test]
11603 #[allow(non_snake_case)]
11604 fn test_N1_Mul_N3() {
11605 type A = NInt<UInt<UTerm, B1>>;
11606 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
11607 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
11608
11609 #[allow(non_camel_case_types)]
11610 type N1MulN3 = <<A as Mul<B>>::Output as Same<P3>>::Output;
11611
11612 assert_eq!(<N1MulN3 as Integer>::to_i64(), <P3 as Integer>::to_i64());
11613 }
11614 #[test]
11615 #[allow(non_snake_case)]
11616 fn test_N1_Min_N3() {
11617 type A = NInt<UInt<UTerm, B1>>;
11618 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
11619 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
11620
11621 #[allow(non_camel_case_types)]
11622 type N1MinN3 = <<A as Min<B>>::Output as Same<N3>>::Output;
11623
11624 assert_eq!(<N1MinN3 as Integer>::to_i64(), <N3 as Integer>::to_i64());
11625 }
11626 #[test]
11627 #[allow(non_snake_case)]
11628 fn test_N1_Max_N3() {
11629 type A = NInt<UInt<UTerm, B1>>;
11630 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
11631 type N1 = NInt<UInt<UTerm, B1>>;
11632
11633 #[allow(non_camel_case_types)]
11634 type N1MaxN3 = <<A as Max<B>>::Output as Same<N1>>::Output;
11635
11636 assert_eq!(<N1MaxN3 as Integer>::to_i64(), <N1 as Integer>::to_i64());
11637 }
11638 #[test]
11639 #[allow(non_snake_case)]
11640 fn test_N1_Gcd_N3() {
11641 type A = NInt<UInt<UTerm, B1>>;
11642 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
11643 type P1 = PInt<UInt<UTerm, B1>>;
11644
11645 #[allow(non_camel_case_types)]
11646 type N1GcdN3 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
11647
11648 assert_eq!(<N1GcdN3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
11649 }
11650 #[test]
11651 #[allow(non_snake_case)]
11652 fn test_N1_Div_N3() {
11653 type A = NInt<UInt<UTerm, B1>>;
11654 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
11655 type _0 = Z0;
11656
11657 #[allow(non_camel_case_types)]
11658 type N1DivN3 = <<A as Div<B>>::Output as Same<_0>>::Output;
11659
11660 assert_eq!(<N1DivN3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
11661 }
11662 #[test]
11663 #[allow(non_snake_case)]
11664 fn test_N1_Rem_N3() {
11665 type A = NInt<UInt<UTerm, B1>>;
11666 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
11667 type N1 = NInt<UInt<UTerm, B1>>;
11668
11669 #[allow(non_camel_case_types)]
11670 type N1RemN3 = <<A as Rem<B>>::Output as Same<N1>>::Output;
11671
11672 assert_eq!(<N1RemN3 as Integer>::to_i64(), <N1 as Integer>::to_i64());
11673 }
11674 #[test]
11675 #[allow(non_snake_case)]
11676 fn test_N1_Pow_N3() {
11677 type A = NInt<UInt<UTerm, B1>>;
11678 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
11679 type N1 = NInt<UInt<UTerm, B1>>;
11680
11681 #[allow(non_camel_case_types)]
11682 type N1PowN3 = <<A as Pow<B>>::Output as Same<N1>>::Output;
11683
11684 assert_eq!(<N1PowN3 as Integer>::to_i64(), <N1 as Integer>::to_i64());
11685 }
11686 #[test]
11687 #[allow(non_snake_case)]
11688 fn test_N1_Cmp_N3() {
11689 type A = NInt<UInt<UTerm, B1>>;
11690 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
11691
11692 #[allow(non_camel_case_types)]
11693 type N1CmpN3 = <A as Cmp<B>>::Output;
11694 assert_eq!(<N1CmpN3 as Ord>::to_ordering(), Ordering::Greater);
11695 }
11696 #[test]
11697 #[allow(non_snake_case)]
11698 fn test_N1_Add_N2() {
11699 type A = NInt<UInt<UTerm, B1>>;
11700 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
11701 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
11702
11703 #[allow(non_camel_case_types)]
11704 type N1AddN2 = <<A as Add<B>>::Output as Same<N3>>::Output;
11705
11706 assert_eq!(<N1AddN2 as Integer>::to_i64(), <N3 as Integer>::to_i64());
11707 }
11708 #[test]
11709 #[allow(non_snake_case)]
11710 fn test_N1_Sub_N2() {
11711 type A = NInt<UInt<UTerm, B1>>;
11712 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
11713 type P1 = PInt<UInt<UTerm, B1>>;
11714
11715 #[allow(non_camel_case_types)]
11716 type N1SubN2 = <<A as Sub<B>>::Output as Same<P1>>::Output;
11717
11718 assert_eq!(<N1SubN2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
11719 }
11720 #[test]
11721 #[allow(non_snake_case)]
11722 fn test_N1_Mul_N2() {
11723 type A = NInt<UInt<UTerm, B1>>;
11724 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
11725 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
11726
11727 #[allow(non_camel_case_types)]
11728 type N1MulN2 = <<A as Mul<B>>::Output as Same<P2>>::Output;
11729
11730 assert_eq!(<N1MulN2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
11731 }
11732 #[test]
11733 #[allow(non_snake_case)]
11734 fn test_N1_Min_N2() {
11735 type A = NInt<UInt<UTerm, B1>>;
11736 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
11737 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
11738
11739 #[allow(non_camel_case_types)]
11740 type N1MinN2 = <<A as Min<B>>::Output as Same<N2>>::Output;
11741
11742 assert_eq!(<N1MinN2 as Integer>::to_i64(), <N2 as Integer>::to_i64());
11743 }
11744 #[test]
11745 #[allow(non_snake_case)]
11746 fn test_N1_Max_N2() {
11747 type A = NInt<UInt<UTerm, B1>>;
11748 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
11749 type N1 = NInt<UInt<UTerm, B1>>;
11750
11751 #[allow(non_camel_case_types)]
11752 type N1MaxN2 = <<A as Max<B>>::Output as Same<N1>>::Output;
11753
11754 assert_eq!(<N1MaxN2 as Integer>::to_i64(), <N1 as Integer>::to_i64());
11755 }
11756 #[test]
11757 #[allow(non_snake_case)]
11758 fn test_N1_Gcd_N2() {
11759 type A = NInt<UInt<UTerm, B1>>;
11760 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
11761 type P1 = PInt<UInt<UTerm, B1>>;
11762
11763 #[allow(non_camel_case_types)]
11764 type N1GcdN2 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
11765
11766 assert_eq!(<N1GcdN2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
11767 }
11768 #[test]
11769 #[allow(non_snake_case)]
11770 fn test_N1_Div_N2() {
11771 type A = NInt<UInt<UTerm, B1>>;
11772 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
11773 type _0 = Z0;
11774
11775 #[allow(non_camel_case_types)]
11776 type N1DivN2 = <<A as Div<B>>::Output as Same<_0>>::Output;
11777
11778 assert_eq!(<N1DivN2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
11779 }
11780 #[test]
11781 #[allow(non_snake_case)]
11782 fn test_N1_Rem_N2() {
11783 type A = NInt<UInt<UTerm, B1>>;
11784 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
11785 type N1 = NInt<UInt<UTerm, B1>>;
11786
11787 #[allow(non_camel_case_types)]
11788 type N1RemN2 = <<A as Rem<B>>::Output as Same<N1>>::Output;
11789
11790 assert_eq!(<N1RemN2 as Integer>::to_i64(), <N1 as Integer>::to_i64());
11791 }
11792 #[test]
11793 #[allow(non_snake_case)]
11794 fn test_N1_Pow_N2() {
11795 type A = NInt<UInt<UTerm, B1>>;
11796 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
11797 type P1 = PInt<UInt<UTerm, B1>>;
11798
11799 #[allow(non_camel_case_types)]
11800 type N1PowN2 = <<A as Pow<B>>::Output as Same<P1>>::Output;
11801
11802 assert_eq!(<N1PowN2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
11803 }
11804 #[test]
11805 #[allow(non_snake_case)]
11806 fn test_N1_Cmp_N2() {
11807 type A = NInt<UInt<UTerm, B1>>;
11808 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
11809
11810 #[allow(non_camel_case_types)]
11811 type N1CmpN2 = <A as Cmp<B>>::Output;
11812 assert_eq!(<N1CmpN2 as Ord>::to_ordering(), Ordering::Greater);
11813 }
11814 #[test]
11815 #[allow(non_snake_case)]
11816 fn test_N1_Add_N1() {
11817 type A = NInt<UInt<UTerm, B1>>;
11818 type B = NInt<UInt<UTerm, B1>>;
11819 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
11820
11821 #[allow(non_camel_case_types)]
11822 type N1AddN1 = <<A as Add<B>>::Output as Same<N2>>::Output;
11823
11824 assert_eq!(<N1AddN1 as Integer>::to_i64(), <N2 as Integer>::to_i64());
11825 }
11826 #[test]
11827 #[allow(non_snake_case)]
11828 fn test_N1_Sub_N1() {
11829 type A = NInt<UInt<UTerm, B1>>;
11830 type B = NInt<UInt<UTerm, B1>>;
11831 type _0 = Z0;
11832
11833 #[allow(non_camel_case_types)]
11834 type N1SubN1 = <<A as Sub<B>>::Output as Same<_0>>::Output;
11835
11836 assert_eq!(<N1SubN1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
11837 }
11838 #[test]
11839 #[allow(non_snake_case)]
11840 fn test_N1_Mul_N1() {
11841 type A = NInt<UInt<UTerm, B1>>;
11842 type B = NInt<UInt<UTerm, B1>>;
11843 type P1 = PInt<UInt<UTerm, B1>>;
11844
11845 #[allow(non_camel_case_types)]
11846 type N1MulN1 = <<A as Mul<B>>::Output as Same<P1>>::Output;
11847
11848 assert_eq!(<N1MulN1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
11849 }
11850 #[test]
11851 #[allow(non_snake_case)]
11852 fn test_N1_Min_N1() {
11853 type A = NInt<UInt<UTerm, B1>>;
11854 type B = NInt<UInt<UTerm, B1>>;
11855 type N1 = NInt<UInt<UTerm, B1>>;
11856
11857 #[allow(non_camel_case_types)]
11858 type N1MinN1 = <<A as Min<B>>::Output as Same<N1>>::Output;
11859
11860 assert_eq!(<N1MinN1 as Integer>::to_i64(), <N1 as Integer>::to_i64());
11861 }
11862 #[test]
11863 #[allow(non_snake_case)]
11864 fn test_N1_Max_N1() {
11865 type A = NInt<UInt<UTerm, B1>>;
11866 type B = NInt<UInt<UTerm, B1>>;
11867 type N1 = NInt<UInt<UTerm, B1>>;
11868
11869 #[allow(non_camel_case_types)]
11870 type N1MaxN1 = <<A as Max<B>>::Output as Same<N1>>::Output;
11871
11872 assert_eq!(<N1MaxN1 as Integer>::to_i64(), <N1 as Integer>::to_i64());
11873 }
11874 #[test]
11875 #[allow(non_snake_case)]
11876 fn test_N1_Gcd_N1() {
11877 type A = NInt<UInt<UTerm, B1>>;
11878 type B = NInt<UInt<UTerm, B1>>;
11879 type P1 = PInt<UInt<UTerm, B1>>;
11880
11881 #[allow(non_camel_case_types)]
11882 type N1GcdN1 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
11883
11884 assert_eq!(<N1GcdN1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
11885 }
11886 #[test]
11887 #[allow(non_snake_case)]
11888 fn test_N1_Div_N1() {
11889 type A = NInt<UInt<UTerm, B1>>;
11890 type B = NInt<UInt<UTerm, B1>>;
11891 type P1 = PInt<UInt<UTerm, B1>>;
11892
11893 #[allow(non_camel_case_types)]
11894 type N1DivN1 = <<A as Div<B>>::Output as Same<P1>>::Output;
11895
11896 assert_eq!(<N1DivN1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
11897 }
11898 #[test]
11899 #[allow(non_snake_case)]
11900 fn test_N1_Rem_N1() {
11901 type A = NInt<UInt<UTerm, B1>>;
11902 type B = NInt<UInt<UTerm, B1>>;
11903 type _0 = Z0;
11904
11905 #[allow(non_camel_case_types)]
11906 type N1RemN1 = <<A as Rem<B>>::Output as Same<_0>>::Output;
11907
11908 assert_eq!(<N1RemN1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
11909 }
11910 #[test]
11911 #[allow(non_snake_case)]
11912 fn test_N1_PartialDiv_N1() {
11913 type A = NInt<UInt<UTerm, B1>>;
11914 type B = NInt<UInt<UTerm, B1>>;
11915 type P1 = PInt<UInt<UTerm, B1>>;
11916
11917 #[allow(non_camel_case_types)]
11918 type N1PartialDivN1 = <<A as PartialDiv<B>>::Output as Same<P1>>::Output;
11919
11920 assert_eq!(<N1PartialDivN1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
11921 }
11922 #[test]
11923 #[allow(non_snake_case)]
11924 fn test_N1_Pow_N1() {
11925 type A = NInt<UInt<UTerm, B1>>;
11926 type B = NInt<UInt<UTerm, B1>>;
11927 type N1 = NInt<UInt<UTerm, B1>>;
11928
11929 #[allow(non_camel_case_types)]
11930 type N1PowN1 = <<A as Pow<B>>::Output as Same<N1>>::Output;
11931
11932 assert_eq!(<N1PowN1 as Integer>::to_i64(), <N1 as Integer>::to_i64());
11933 }
11934 #[test]
11935 #[allow(non_snake_case)]
11936 fn test_N1_Cmp_N1() {
11937 type A = NInt<UInt<UTerm, B1>>;
11938 type B = NInt<UInt<UTerm, B1>>;
11939
11940 #[allow(non_camel_case_types)]
11941 type N1CmpN1 = <A as Cmp<B>>::Output;
11942 assert_eq!(<N1CmpN1 as Ord>::to_ordering(), Ordering::Equal);
11943 }
11944 #[test]
11945 #[allow(non_snake_case)]
11946 fn test_N1_Add__0() {
11947 type A = NInt<UInt<UTerm, B1>>;
11948 type B = Z0;
11949 type N1 = NInt<UInt<UTerm, B1>>;
11950
11951 #[allow(non_camel_case_types)]
11952 type N1Add_0 = <<A as Add<B>>::Output as Same<N1>>::Output;
11953
11954 assert_eq!(<N1Add_0 as Integer>::to_i64(), <N1 as Integer>::to_i64());
11955 }
11956 #[test]
11957 #[allow(non_snake_case)]
11958 fn test_N1_Sub__0() {
11959 type A = NInt<UInt<UTerm, B1>>;
11960 type B = Z0;
11961 type N1 = NInt<UInt<UTerm, B1>>;
11962
11963 #[allow(non_camel_case_types)]
11964 type N1Sub_0 = <<A as Sub<B>>::Output as Same<N1>>::Output;
11965
11966 assert_eq!(<N1Sub_0 as Integer>::to_i64(), <N1 as Integer>::to_i64());
11967 }
11968 #[test]
11969 #[allow(non_snake_case)]
11970 fn test_N1_Mul__0() {
11971 type A = NInt<UInt<UTerm, B1>>;
11972 type B = Z0;
11973 type _0 = Z0;
11974
11975 #[allow(non_camel_case_types)]
11976 type N1Mul_0 = <<A as Mul<B>>::Output as Same<_0>>::Output;
11977
11978 assert_eq!(<N1Mul_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
11979 }
11980 #[test]
11981 #[allow(non_snake_case)]
11982 fn test_N1_Min__0() {
11983 type A = NInt<UInt<UTerm, B1>>;
11984 type B = Z0;
11985 type N1 = NInt<UInt<UTerm, B1>>;
11986
11987 #[allow(non_camel_case_types)]
11988 type N1Min_0 = <<A as Min<B>>::Output as Same<N1>>::Output;
11989
11990 assert_eq!(<N1Min_0 as Integer>::to_i64(), <N1 as Integer>::to_i64());
11991 }
11992 #[test]
11993 #[allow(non_snake_case)]
11994 fn test_N1_Max__0() {
11995 type A = NInt<UInt<UTerm, B1>>;
11996 type B = Z0;
11997 type _0 = Z0;
11998
11999 #[allow(non_camel_case_types)]
12000 type N1Max_0 = <<A as Max<B>>::Output as Same<_0>>::Output;
12001
12002 assert_eq!(<N1Max_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
12003 }
12004 #[test]
12005 #[allow(non_snake_case)]
12006 fn test_N1_Gcd__0() {
12007 type A = NInt<UInt<UTerm, B1>>;
12008 type B = Z0;
12009 type P1 = PInt<UInt<UTerm, B1>>;
12010
12011 #[allow(non_camel_case_types)]
12012 type N1Gcd_0 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
12013
12014 assert_eq!(<N1Gcd_0 as Integer>::to_i64(), <P1 as Integer>::to_i64());
12015 }
12016 #[test]
12017 #[allow(non_snake_case)]
12018 fn test_N1_Pow__0() {
12019 type A = NInt<UInt<UTerm, B1>>;
12020 type B = Z0;
12021 type P1 = PInt<UInt<UTerm, B1>>;
12022
12023 #[allow(non_camel_case_types)]
12024 type N1Pow_0 = <<A as Pow<B>>::Output as Same<P1>>::Output;
12025
12026 assert_eq!(<N1Pow_0 as Integer>::to_i64(), <P1 as Integer>::to_i64());
12027 }
12028 #[test]
12029 #[allow(non_snake_case)]
12030 fn test_N1_Cmp__0() {
12031 type A = NInt<UInt<UTerm, B1>>;
12032 type B = Z0;
12033
12034 #[allow(non_camel_case_types)]
12035 type N1Cmp_0 = <A as Cmp<B>>::Output;
12036 assert_eq!(<N1Cmp_0 as Ord>::to_ordering(), Ordering::Less);
12037 }
12038 #[test]
12039 #[allow(non_snake_case)]
12040 fn test_N1_Add_P1() {
12041 type A = NInt<UInt<UTerm, B1>>;
12042 type B = PInt<UInt<UTerm, B1>>;
12043 type _0 = Z0;
12044
12045 #[allow(non_camel_case_types)]
12046 type N1AddP1 = <<A as Add<B>>::Output as Same<_0>>::Output;
12047
12048 assert_eq!(<N1AddP1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
12049 }
12050 #[test]
12051 #[allow(non_snake_case)]
12052 fn test_N1_Sub_P1() {
12053 type A = NInt<UInt<UTerm, B1>>;
12054 type B = PInt<UInt<UTerm, B1>>;
12055 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
12056
12057 #[allow(non_camel_case_types)]
12058 type N1SubP1 = <<A as Sub<B>>::Output as Same<N2>>::Output;
12059
12060 assert_eq!(<N1SubP1 as Integer>::to_i64(), <N2 as Integer>::to_i64());
12061 }
12062 #[test]
12063 #[allow(non_snake_case)]
12064 fn test_N1_Mul_P1() {
12065 type A = NInt<UInt<UTerm, B1>>;
12066 type B = PInt<UInt<UTerm, B1>>;
12067 type N1 = NInt<UInt<UTerm, B1>>;
12068
12069 #[allow(non_camel_case_types)]
12070 type N1MulP1 = <<A as Mul<B>>::Output as Same<N1>>::Output;
12071
12072 assert_eq!(<N1MulP1 as Integer>::to_i64(), <N1 as Integer>::to_i64());
12073 }
12074 #[test]
12075 #[allow(non_snake_case)]
12076 fn test_N1_Min_P1() {
12077 type A = NInt<UInt<UTerm, B1>>;
12078 type B = PInt<UInt<UTerm, B1>>;
12079 type N1 = NInt<UInt<UTerm, B1>>;
12080
12081 #[allow(non_camel_case_types)]
12082 type N1MinP1 = <<A as Min<B>>::Output as Same<N1>>::Output;
12083
12084 assert_eq!(<N1MinP1 as Integer>::to_i64(), <N1 as Integer>::to_i64());
12085 }
12086 #[test]
12087 #[allow(non_snake_case)]
12088 fn test_N1_Max_P1() {
12089 type A = NInt<UInt<UTerm, B1>>;
12090 type B = PInt<UInt<UTerm, B1>>;
12091 type P1 = PInt<UInt<UTerm, B1>>;
12092
12093 #[allow(non_camel_case_types)]
12094 type N1MaxP1 = <<A as Max<B>>::Output as Same<P1>>::Output;
12095
12096 assert_eq!(<N1MaxP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
12097 }
12098 #[test]
12099 #[allow(non_snake_case)]
12100 fn test_N1_Gcd_P1() {
12101 type A = NInt<UInt<UTerm, B1>>;
12102 type B = PInt<UInt<UTerm, B1>>;
12103 type P1 = PInt<UInt<UTerm, B1>>;
12104
12105 #[allow(non_camel_case_types)]
12106 type N1GcdP1 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
12107
12108 assert_eq!(<N1GcdP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
12109 }
12110 #[test]
12111 #[allow(non_snake_case)]
12112 fn test_N1_Div_P1() {
12113 type A = NInt<UInt<UTerm, B1>>;
12114 type B = PInt<UInt<UTerm, B1>>;
12115 type N1 = NInt<UInt<UTerm, B1>>;
12116
12117 #[allow(non_camel_case_types)]
12118 type N1DivP1 = <<A as Div<B>>::Output as Same<N1>>::Output;
12119
12120 assert_eq!(<N1DivP1 as Integer>::to_i64(), <N1 as Integer>::to_i64());
12121 }
12122 #[test]
12123 #[allow(non_snake_case)]
12124 fn test_N1_Rem_P1() {
12125 type A = NInt<UInt<UTerm, B1>>;
12126 type B = PInt<UInt<UTerm, B1>>;
12127 type _0 = Z0;
12128
12129 #[allow(non_camel_case_types)]
12130 type N1RemP1 = <<A as Rem<B>>::Output as Same<_0>>::Output;
12131
12132 assert_eq!(<N1RemP1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
12133 }
12134 #[test]
12135 #[allow(non_snake_case)]
12136 fn test_N1_PartialDiv_P1() {
12137 type A = NInt<UInt<UTerm, B1>>;
12138 type B = PInt<UInt<UTerm, B1>>;
12139 type N1 = NInt<UInt<UTerm, B1>>;
12140
12141 #[allow(non_camel_case_types)]
12142 type N1PartialDivP1 = <<A as PartialDiv<B>>::Output as Same<N1>>::Output;
12143
12144 assert_eq!(<N1PartialDivP1 as Integer>::to_i64(), <N1 as Integer>::to_i64());
12145 }
12146 #[test]
12147 #[allow(non_snake_case)]
12148 fn test_N1_Pow_P1() {
12149 type A = NInt<UInt<UTerm, B1>>;
12150 type B = PInt<UInt<UTerm, B1>>;
12151 type N1 = NInt<UInt<UTerm, B1>>;
12152
12153 #[allow(non_camel_case_types)]
12154 type N1PowP1 = <<A as Pow<B>>::Output as Same<N1>>::Output;
12155
12156 assert_eq!(<N1PowP1 as Integer>::to_i64(), <N1 as Integer>::to_i64());
12157 }
12158 #[test]
12159 #[allow(non_snake_case)]
12160 fn test_N1_Cmp_P1() {
12161 type A = NInt<UInt<UTerm, B1>>;
12162 type B = PInt<UInt<UTerm, B1>>;
12163
12164 #[allow(non_camel_case_types)]
12165 type N1CmpP1 = <A as Cmp<B>>::Output;
12166 assert_eq!(<N1CmpP1 as Ord>::to_ordering(), Ordering::Less);
12167 }
12168 #[test]
12169 #[allow(non_snake_case)]
12170 fn test_N1_Add_P2() {
12171 type A = NInt<UInt<UTerm, B1>>;
12172 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
12173 type P1 = PInt<UInt<UTerm, B1>>;
12174
12175 #[allow(non_camel_case_types)]
12176 type N1AddP2 = <<A as Add<B>>::Output as Same<P1>>::Output;
12177
12178 assert_eq!(<N1AddP2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
12179 }
12180 #[test]
12181 #[allow(non_snake_case)]
12182 fn test_N1_Sub_P2() {
12183 type A = NInt<UInt<UTerm, B1>>;
12184 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
12185 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
12186
12187 #[allow(non_camel_case_types)]
12188 type N1SubP2 = <<A as Sub<B>>::Output as Same<N3>>::Output;
12189
12190 assert_eq!(<N1SubP2 as Integer>::to_i64(), <N3 as Integer>::to_i64());
12191 }
12192 #[test]
12193 #[allow(non_snake_case)]
12194 fn test_N1_Mul_P2() {
12195 type A = NInt<UInt<UTerm, B1>>;
12196 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
12197 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
12198
12199 #[allow(non_camel_case_types)]
12200 type N1MulP2 = <<A as Mul<B>>::Output as Same<N2>>::Output;
12201
12202 assert_eq!(<N1MulP2 as Integer>::to_i64(), <N2 as Integer>::to_i64());
12203 }
12204 #[test]
12205 #[allow(non_snake_case)]
12206 fn test_N1_Min_P2() {
12207 type A = NInt<UInt<UTerm, B1>>;
12208 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
12209 type N1 = NInt<UInt<UTerm, B1>>;
12210
12211 #[allow(non_camel_case_types)]
12212 type N1MinP2 = <<A as Min<B>>::Output as Same<N1>>::Output;
12213
12214 assert_eq!(<N1MinP2 as Integer>::to_i64(), <N1 as Integer>::to_i64());
12215 }
12216 #[test]
12217 #[allow(non_snake_case)]
12218 fn test_N1_Max_P2() {
12219 type A = NInt<UInt<UTerm, B1>>;
12220 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
12221 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
12222
12223 #[allow(non_camel_case_types)]
12224 type N1MaxP2 = <<A as Max<B>>::Output as Same<P2>>::Output;
12225
12226 assert_eq!(<N1MaxP2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
12227 }
12228 #[test]
12229 #[allow(non_snake_case)]
12230 fn test_N1_Gcd_P2() {
12231 type A = NInt<UInt<UTerm, B1>>;
12232 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
12233 type P1 = PInt<UInt<UTerm, B1>>;
12234
12235 #[allow(non_camel_case_types)]
12236 type N1GcdP2 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
12237
12238 assert_eq!(<N1GcdP2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
12239 }
12240 #[test]
12241 #[allow(non_snake_case)]
12242 fn test_N1_Div_P2() {
12243 type A = NInt<UInt<UTerm, B1>>;
12244 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
12245 type _0 = Z0;
12246
12247 #[allow(non_camel_case_types)]
12248 type N1DivP2 = <<A as Div<B>>::Output as Same<_0>>::Output;
12249
12250 assert_eq!(<N1DivP2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
12251 }
12252 #[test]
12253 #[allow(non_snake_case)]
12254 fn test_N1_Rem_P2() {
12255 type A = NInt<UInt<UTerm, B1>>;
12256 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
12257 type N1 = NInt<UInt<UTerm, B1>>;
12258
12259 #[allow(non_camel_case_types)]
12260 type N1RemP2 = <<A as Rem<B>>::Output as Same<N1>>::Output;
12261
12262 assert_eq!(<N1RemP2 as Integer>::to_i64(), <N1 as Integer>::to_i64());
12263 }
12264 #[test]
12265 #[allow(non_snake_case)]
12266 fn test_N1_Pow_P2() {
12267 type A = NInt<UInt<UTerm, B1>>;
12268 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
12269 type P1 = PInt<UInt<UTerm, B1>>;
12270
12271 #[allow(non_camel_case_types)]
12272 type N1PowP2 = <<A as Pow<B>>::Output as Same<P1>>::Output;
12273
12274 assert_eq!(<N1PowP2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
12275 }
12276 #[test]
12277 #[allow(non_snake_case)]
12278 fn test_N1_Cmp_P2() {
12279 type A = NInt<UInt<UTerm, B1>>;
12280 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
12281
12282 #[allow(non_camel_case_types)]
12283 type N1CmpP2 = <A as Cmp<B>>::Output;
12284 assert_eq!(<N1CmpP2 as Ord>::to_ordering(), Ordering::Less);
12285 }
12286 #[test]
12287 #[allow(non_snake_case)]
12288 fn test_N1_Add_P3() {
12289 type A = NInt<UInt<UTerm, B1>>;
12290 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
12291 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
12292
12293 #[allow(non_camel_case_types)]
12294 type N1AddP3 = <<A as Add<B>>::Output as Same<P2>>::Output;
12295
12296 assert_eq!(<N1AddP3 as Integer>::to_i64(), <P2 as Integer>::to_i64());
12297 }
12298 #[test]
12299 #[allow(non_snake_case)]
12300 fn test_N1_Sub_P3() {
12301 type A = NInt<UInt<UTerm, B1>>;
12302 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
12303 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12304
12305 #[allow(non_camel_case_types)]
12306 type N1SubP3 = <<A as Sub<B>>::Output as Same<N4>>::Output;
12307
12308 assert_eq!(<N1SubP3 as Integer>::to_i64(), <N4 as Integer>::to_i64());
12309 }
12310 #[test]
12311 #[allow(non_snake_case)]
12312 fn test_N1_Mul_P3() {
12313 type A = NInt<UInt<UTerm, B1>>;
12314 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
12315 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
12316
12317 #[allow(non_camel_case_types)]
12318 type N1MulP3 = <<A as Mul<B>>::Output as Same<N3>>::Output;
12319
12320 assert_eq!(<N1MulP3 as Integer>::to_i64(), <N3 as Integer>::to_i64());
12321 }
12322 #[test]
12323 #[allow(non_snake_case)]
12324 fn test_N1_Min_P3() {
12325 type A = NInt<UInt<UTerm, B1>>;
12326 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
12327 type N1 = NInt<UInt<UTerm, B1>>;
12328
12329 #[allow(non_camel_case_types)]
12330 type N1MinP3 = <<A as Min<B>>::Output as Same<N1>>::Output;
12331
12332 assert_eq!(<N1MinP3 as Integer>::to_i64(), <N1 as Integer>::to_i64());
12333 }
12334 #[test]
12335 #[allow(non_snake_case)]
12336 fn test_N1_Max_P3() {
12337 type A = NInt<UInt<UTerm, B1>>;
12338 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
12339 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
12340
12341 #[allow(non_camel_case_types)]
12342 type N1MaxP3 = <<A as Max<B>>::Output as Same<P3>>::Output;
12343
12344 assert_eq!(<N1MaxP3 as Integer>::to_i64(), <P3 as Integer>::to_i64());
12345 }
12346 #[test]
12347 #[allow(non_snake_case)]
12348 fn test_N1_Gcd_P3() {
12349 type A = NInt<UInt<UTerm, B1>>;
12350 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
12351 type P1 = PInt<UInt<UTerm, B1>>;
12352
12353 #[allow(non_camel_case_types)]
12354 type N1GcdP3 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
12355
12356 assert_eq!(<N1GcdP3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
12357 }
12358 #[test]
12359 #[allow(non_snake_case)]
12360 fn test_N1_Div_P3() {
12361 type A = NInt<UInt<UTerm, B1>>;
12362 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
12363 type _0 = Z0;
12364
12365 #[allow(non_camel_case_types)]
12366 type N1DivP3 = <<A as Div<B>>::Output as Same<_0>>::Output;
12367
12368 assert_eq!(<N1DivP3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
12369 }
12370 #[test]
12371 #[allow(non_snake_case)]
12372 fn test_N1_Rem_P3() {
12373 type A = NInt<UInt<UTerm, B1>>;
12374 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
12375 type N1 = NInt<UInt<UTerm, B1>>;
12376
12377 #[allow(non_camel_case_types)]
12378 type N1RemP3 = <<A as Rem<B>>::Output as Same<N1>>::Output;
12379
12380 assert_eq!(<N1RemP3 as Integer>::to_i64(), <N1 as Integer>::to_i64());
12381 }
12382 #[test]
12383 #[allow(non_snake_case)]
12384 fn test_N1_Pow_P3() {
12385 type A = NInt<UInt<UTerm, B1>>;
12386 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
12387 type N1 = NInt<UInt<UTerm, B1>>;
12388
12389 #[allow(non_camel_case_types)]
12390 type N1PowP3 = <<A as Pow<B>>::Output as Same<N1>>::Output;
12391
12392 assert_eq!(<N1PowP3 as Integer>::to_i64(), <N1 as Integer>::to_i64());
12393 }
12394 #[test]
12395 #[allow(non_snake_case)]
12396 fn test_N1_Cmp_P3() {
12397 type A = NInt<UInt<UTerm, B1>>;
12398 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
12399
12400 #[allow(non_camel_case_types)]
12401 type N1CmpP3 = <A as Cmp<B>>::Output;
12402 assert_eq!(<N1CmpP3 as Ord>::to_ordering(), Ordering::Less);
12403 }
12404 #[test]
12405 #[allow(non_snake_case)]
12406 fn test_N1_Add_P4() {
12407 type A = NInt<UInt<UTerm, B1>>;
12408 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12409 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
12410
12411 #[allow(non_camel_case_types)]
12412 type N1AddP4 = <<A as Add<B>>::Output as Same<P3>>::Output;
12413
12414 assert_eq!(<N1AddP4 as Integer>::to_i64(), <P3 as Integer>::to_i64());
12415 }
12416 #[test]
12417 #[allow(non_snake_case)]
12418 fn test_N1_Sub_P4() {
12419 type A = NInt<UInt<UTerm, B1>>;
12420 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12421 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12422
12423 #[allow(non_camel_case_types)]
12424 type N1SubP4 = <<A as Sub<B>>::Output as Same<N5>>::Output;
12425
12426 assert_eq!(<N1SubP4 as Integer>::to_i64(), <N5 as Integer>::to_i64());
12427 }
12428 #[test]
12429 #[allow(non_snake_case)]
12430 fn test_N1_Mul_P4() {
12431 type A = NInt<UInt<UTerm, B1>>;
12432 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12433 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12434
12435 #[allow(non_camel_case_types)]
12436 type N1MulP4 = <<A as Mul<B>>::Output as Same<N4>>::Output;
12437
12438 assert_eq!(<N1MulP4 as Integer>::to_i64(), <N4 as Integer>::to_i64());
12439 }
12440 #[test]
12441 #[allow(non_snake_case)]
12442 fn test_N1_Min_P4() {
12443 type A = NInt<UInt<UTerm, B1>>;
12444 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12445 type N1 = NInt<UInt<UTerm, B1>>;
12446
12447 #[allow(non_camel_case_types)]
12448 type N1MinP4 = <<A as Min<B>>::Output as Same<N1>>::Output;
12449
12450 assert_eq!(<N1MinP4 as Integer>::to_i64(), <N1 as Integer>::to_i64());
12451 }
12452 #[test]
12453 #[allow(non_snake_case)]
12454 fn test_N1_Max_P4() {
12455 type A = NInt<UInt<UTerm, B1>>;
12456 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12457 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12458
12459 #[allow(non_camel_case_types)]
12460 type N1MaxP4 = <<A as Max<B>>::Output as Same<P4>>::Output;
12461
12462 assert_eq!(<N1MaxP4 as Integer>::to_i64(), <P4 as Integer>::to_i64());
12463 }
12464 #[test]
12465 #[allow(non_snake_case)]
12466 fn test_N1_Gcd_P4() {
12467 type A = NInt<UInt<UTerm, B1>>;
12468 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12469 type P1 = PInt<UInt<UTerm, B1>>;
12470
12471 #[allow(non_camel_case_types)]
12472 type N1GcdP4 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
12473
12474 assert_eq!(<N1GcdP4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
12475 }
12476 #[test]
12477 #[allow(non_snake_case)]
12478 fn test_N1_Div_P4() {
12479 type A = NInt<UInt<UTerm, B1>>;
12480 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12481 type _0 = Z0;
12482
12483 #[allow(non_camel_case_types)]
12484 type N1DivP4 = <<A as Div<B>>::Output as Same<_0>>::Output;
12485
12486 assert_eq!(<N1DivP4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
12487 }
12488 #[test]
12489 #[allow(non_snake_case)]
12490 fn test_N1_Rem_P4() {
12491 type A = NInt<UInt<UTerm, B1>>;
12492 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12493 type N1 = NInt<UInt<UTerm, B1>>;
12494
12495 #[allow(non_camel_case_types)]
12496 type N1RemP4 = <<A as Rem<B>>::Output as Same<N1>>::Output;
12497
12498 assert_eq!(<N1RemP4 as Integer>::to_i64(), <N1 as Integer>::to_i64());
12499 }
12500 #[test]
12501 #[allow(non_snake_case)]
12502 fn test_N1_Pow_P4() {
12503 type A = NInt<UInt<UTerm, B1>>;
12504 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12505 type P1 = PInt<UInt<UTerm, B1>>;
12506
12507 #[allow(non_camel_case_types)]
12508 type N1PowP4 = <<A as Pow<B>>::Output as Same<P1>>::Output;
12509
12510 assert_eq!(<N1PowP4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
12511 }
12512 #[test]
12513 #[allow(non_snake_case)]
12514 fn test_N1_Cmp_P4() {
12515 type A = NInt<UInt<UTerm, B1>>;
12516 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12517
12518 #[allow(non_camel_case_types)]
12519 type N1CmpP4 = <A as Cmp<B>>::Output;
12520 assert_eq!(<N1CmpP4 as Ord>::to_ordering(), Ordering::Less);
12521 }
12522 #[test]
12523 #[allow(non_snake_case)]
12524 fn test_N1_Add_P5() {
12525 type A = NInt<UInt<UTerm, B1>>;
12526 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12527 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12528
12529 #[allow(non_camel_case_types)]
12530 type N1AddP5 = <<A as Add<B>>::Output as Same<P4>>::Output;
12531
12532 assert_eq!(<N1AddP5 as Integer>::to_i64(), <P4 as Integer>::to_i64());
12533 }
12534 #[test]
12535 #[allow(non_snake_case)]
12536 fn test_N1_Sub_P5() {
12537 type A = NInt<UInt<UTerm, B1>>;
12538 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12539 type N6 = NInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
12540
12541 #[allow(non_camel_case_types)]
12542 type N1SubP5 = <<A as Sub<B>>::Output as Same<N6>>::Output;
12543
12544 assert_eq!(<N1SubP5 as Integer>::to_i64(), <N6 as Integer>::to_i64());
12545 }
12546 #[test]
12547 #[allow(non_snake_case)]
12548 fn test_N1_Mul_P5() {
12549 type A = NInt<UInt<UTerm, B1>>;
12550 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12551 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12552
12553 #[allow(non_camel_case_types)]
12554 type N1MulP5 = <<A as Mul<B>>::Output as Same<N5>>::Output;
12555
12556 assert_eq!(<N1MulP5 as Integer>::to_i64(), <N5 as Integer>::to_i64());
12557 }
12558 #[test]
12559 #[allow(non_snake_case)]
12560 fn test_N1_Min_P5() {
12561 type A = NInt<UInt<UTerm, B1>>;
12562 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12563 type N1 = NInt<UInt<UTerm, B1>>;
12564
12565 #[allow(non_camel_case_types)]
12566 type N1MinP5 = <<A as Min<B>>::Output as Same<N1>>::Output;
12567
12568 assert_eq!(<N1MinP5 as Integer>::to_i64(), <N1 as Integer>::to_i64());
12569 }
12570 #[test]
12571 #[allow(non_snake_case)]
12572 fn test_N1_Max_P5() {
12573 type A = NInt<UInt<UTerm, B1>>;
12574 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12575 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12576
12577 #[allow(non_camel_case_types)]
12578 type N1MaxP5 = <<A as Max<B>>::Output as Same<P5>>::Output;
12579
12580 assert_eq!(<N1MaxP5 as Integer>::to_i64(), <P5 as Integer>::to_i64());
12581 }
12582 #[test]
12583 #[allow(non_snake_case)]
12584 fn test_N1_Gcd_P5() {
12585 type A = NInt<UInt<UTerm, B1>>;
12586 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12587 type P1 = PInt<UInt<UTerm, B1>>;
12588
12589 #[allow(non_camel_case_types)]
12590 type N1GcdP5 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
12591
12592 assert_eq!(<N1GcdP5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
12593 }
12594 #[test]
12595 #[allow(non_snake_case)]
12596 fn test_N1_Div_P5() {
12597 type A = NInt<UInt<UTerm, B1>>;
12598 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12599 type _0 = Z0;
12600
12601 #[allow(non_camel_case_types)]
12602 type N1DivP5 = <<A as Div<B>>::Output as Same<_0>>::Output;
12603
12604 assert_eq!(<N1DivP5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
12605 }
12606 #[test]
12607 #[allow(non_snake_case)]
12608 fn test_N1_Rem_P5() {
12609 type A = NInt<UInt<UTerm, B1>>;
12610 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12611 type N1 = NInt<UInt<UTerm, B1>>;
12612
12613 #[allow(non_camel_case_types)]
12614 type N1RemP5 = <<A as Rem<B>>::Output as Same<N1>>::Output;
12615
12616 assert_eq!(<N1RemP5 as Integer>::to_i64(), <N1 as Integer>::to_i64());
12617 }
12618 #[test]
12619 #[allow(non_snake_case)]
12620 fn test_N1_Pow_P5() {
12621 type A = NInt<UInt<UTerm, B1>>;
12622 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12623 type N1 = NInt<UInt<UTerm, B1>>;
12624
12625 #[allow(non_camel_case_types)]
12626 type N1PowP5 = <<A as Pow<B>>::Output as Same<N1>>::Output;
12627
12628 assert_eq!(<N1PowP5 as Integer>::to_i64(), <N1 as Integer>::to_i64());
12629 }
12630 #[test]
12631 #[allow(non_snake_case)]
12632 fn test_N1_Cmp_P5() {
12633 type A = NInt<UInt<UTerm, B1>>;
12634 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12635
12636 #[allow(non_camel_case_types)]
12637 type N1CmpP5 = <A as Cmp<B>>::Output;
12638 assert_eq!(<N1CmpP5 as Ord>::to_ordering(), Ordering::Less);
12639 }
12640 #[test]
12641 #[allow(non_snake_case)]
12642 fn test__0_Add_N5() {
12643 type A = Z0;
12644 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12645 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12646
12647 #[allow(non_camel_case_types)]
12648 type _0AddN5 = <<A as Add<B>>::Output as Same<N5>>::Output;
12649
12650 assert_eq!(<_0AddN5 as Integer>::to_i64(), <N5 as Integer>::to_i64());
12651 }
12652 #[test]
12653 #[allow(non_snake_case)]
12654 fn test__0_Sub_N5() {
12655 type A = Z0;
12656 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12657 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12658
12659 #[allow(non_camel_case_types)]
12660 type _0SubN5 = <<A as Sub<B>>::Output as Same<P5>>::Output;
12661
12662 assert_eq!(<_0SubN5 as Integer>::to_i64(), <P5 as Integer>::to_i64());
12663 }
12664 #[test]
12665 #[allow(non_snake_case)]
12666 fn test__0_Mul_N5() {
12667 type A = Z0;
12668 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12669 type _0 = Z0;
12670
12671 #[allow(non_camel_case_types)]
12672 type _0MulN5 = <<A as Mul<B>>::Output as Same<_0>>::Output;
12673
12674 assert_eq!(<_0MulN5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
12675 }
12676 #[test]
12677 #[allow(non_snake_case)]
12678 fn test__0_Min_N5() {
12679 type A = Z0;
12680 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12681 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12682
12683 #[allow(non_camel_case_types)]
12684 type _0MinN5 = <<A as Min<B>>::Output as Same<N5>>::Output;
12685
12686 assert_eq!(<_0MinN5 as Integer>::to_i64(), <N5 as Integer>::to_i64());
12687 }
12688 #[test]
12689 #[allow(non_snake_case)]
12690 fn test__0_Max_N5() {
12691 type A = Z0;
12692 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12693 type _0 = Z0;
12694
12695 #[allow(non_camel_case_types)]
12696 type _0MaxN5 = <<A as Max<B>>::Output as Same<_0>>::Output;
12697
12698 assert_eq!(<_0MaxN5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
12699 }
12700 #[test]
12701 #[allow(non_snake_case)]
12702 fn test__0_Gcd_N5() {
12703 type A = Z0;
12704 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12705 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12706
12707 #[allow(non_camel_case_types)]
12708 type _0GcdN5 = <<A as Gcd<B>>::Output as Same<P5>>::Output;
12709
12710 assert_eq!(<_0GcdN5 as Integer>::to_i64(), <P5 as Integer>::to_i64());
12711 }
12712 #[test]
12713 #[allow(non_snake_case)]
12714 fn test__0_Div_N5() {
12715 type A = Z0;
12716 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12717 type _0 = Z0;
12718
12719 #[allow(non_camel_case_types)]
12720 type _0DivN5 = <<A as Div<B>>::Output as Same<_0>>::Output;
12721
12722 assert_eq!(<_0DivN5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
12723 }
12724 #[test]
12725 #[allow(non_snake_case)]
12726 fn test__0_Rem_N5() {
12727 type A = Z0;
12728 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12729 type _0 = Z0;
12730
12731 #[allow(non_camel_case_types)]
12732 type _0RemN5 = <<A as Rem<B>>::Output as Same<_0>>::Output;
12733
12734 assert_eq!(<_0RemN5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
12735 }
12736 #[test]
12737 #[allow(non_snake_case)]
12738 fn test__0_PartialDiv_N5() {
12739 type A = Z0;
12740 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12741 type _0 = Z0;
12742
12743 #[allow(non_camel_case_types)]
12744 type _0PartialDivN5 = <<A as PartialDiv<B>>::Output as Same<_0>>::Output;
12745
12746 assert_eq!(<_0PartialDivN5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
12747 }
12748 #[test]
12749 #[allow(non_snake_case)]
12750 fn test__0_Cmp_N5() {
12751 type A = Z0;
12752 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
12753
12754 #[allow(non_camel_case_types)]
12755 type _0CmpN5 = <A as Cmp<B>>::Output;
12756 assert_eq!(<_0CmpN5 as Ord>::to_ordering(), Ordering::Greater);
12757 }
12758 #[test]
12759 #[allow(non_snake_case)]
12760 fn test__0_Add_N4() {
12761 type A = Z0;
12762 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12763 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12764
12765 #[allow(non_camel_case_types)]
12766 type _0AddN4 = <<A as Add<B>>::Output as Same<N4>>::Output;
12767
12768 assert_eq!(<_0AddN4 as Integer>::to_i64(), <N4 as Integer>::to_i64());
12769 }
12770 #[test]
12771 #[allow(non_snake_case)]
12772 fn test__0_Sub_N4() {
12773 type A = Z0;
12774 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12775 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12776
12777 #[allow(non_camel_case_types)]
12778 type _0SubN4 = <<A as Sub<B>>::Output as Same<P4>>::Output;
12779
12780 assert_eq!(<_0SubN4 as Integer>::to_i64(), <P4 as Integer>::to_i64());
12781 }
12782 #[test]
12783 #[allow(non_snake_case)]
12784 fn test__0_Mul_N4() {
12785 type A = Z0;
12786 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12787 type _0 = Z0;
12788
12789 #[allow(non_camel_case_types)]
12790 type _0MulN4 = <<A as Mul<B>>::Output as Same<_0>>::Output;
12791
12792 assert_eq!(<_0MulN4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
12793 }
12794 #[test]
12795 #[allow(non_snake_case)]
12796 fn test__0_Min_N4() {
12797 type A = Z0;
12798 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12799 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12800
12801 #[allow(non_camel_case_types)]
12802 type _0MinN4 = <<A as Min<B>>::Output as Same<N4>>::Output;
12803
12804 assert_eq!(<_0MinN4 as Integer>::to_i64(), <N4 as Integer>::to_i64());
12805 }
12806 #[test]
12807 #[allow(non_snake_case)]
12808 fn test__0_Max_N4() {
12809 type A = Z0;
12810 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12811 type _0 = Z0;
12812
12813 #[allow(non_camel_case_types)]
12814 type _0MaxN4 = <<A as Max<B>>::Output as Same<_0>>::Output;
12815
12816 assert_eq!(<_0MaxN4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
12817 }
12818 #[test]
12819 #[allow(non_snake_case)]
12820 fn test__0_Gcd_N4() {
12821 type A = Z0;
12822 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12823 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12824
12825 #[allow(non_camel_case_types)]
12826 type _0GcdN4 = <<A as Gcd<B>>::Output as Same<P4>>::Output;
12827
12828 assert_eq!(<_0GcdN4 as Integer>::to_i64(), <P4 as Integer>::to_i64());
12829 }
12830 #[test]
12831 #[allow(non_snake_case)]
12832 fn test__0_Div_N4() {
12833 type A = Z0;
12834 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12835 type _0 = Z0;
12836
12837 #[allow(non_camel_case_types)]
12838 type _0DivN4 = <<A as Div<B>>::Output as Same<_0>>::Output;
12839
12840 assert_eq!(<_0DivN4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
12841 }
12842 #[test]
12843 #[allow(non_snake_case)]
12844 fn test__0_Rem_N4() {
12845 type A = Z0;
12846 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12847 type _0 = Z0;
12848
12849 #[allow(non_camel_case_types)]
12850 type _0RemN4 = <<A as Rem<B>>::Output as Same<_0>>::Output;
12851
12852 assert_eq!(<_0RemN4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
12853 }
12854 #[test]
12855 #[allow(non_snake_case)]
12856 fn test__0_PartialDiv_N4() {
12857 type A = Z0;
12858 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12859 type _0 = Z0;
12860
12861 #[allow(non_camel_case_types)]
12862 type _0PartialDivN4 = <<A as PartialDiv<B>>::Output as Same<_0>>::Output;
12863
12864 assert_eq!(<_0PartialDivN4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
12865 }
12866 #[test]
12867 #[allow(non_snake_case)]
12868 fn test__0_Cmp_N4() {
12869 type A = Z0;
12870 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
12871
12872 #[allow(non_camel_case_types)]
12873 type _0CmpN4 = <A as Cmp<B>>::Output;
12874 assert_eq!(<_0CmpN4 as Ord>::to_ordering(), Ordering::Greater);
12875 }
12876 #[test]
12877 #[allow(non_snake_case)]
12878 fn test__0_Add_N3() {
12879 type A = Z0;
12880 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
12881 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
12882
12883 #[allow(non_camel_case_types)]
12884 type _0AddN3 = <<A as Add<B>>::Output as Same<N3>>::Output;
12885
12886 assert_eq!(<_0AddN3 as Integer>::to_i64(), <N3 as Integer>::to_i64());
12887 }
12888 #[test]
12889 #[allow(non_snake_case)]
12890 fn test__0_Sub_N3() {
12891 type A = Z0;
12892 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
12893 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
12894
12895 #[allow(non_camel_case_types)]
12896 type _0SubN3 = <<A as Sub<B>>::Output as Same<P3>>::Output;
12897
12898 assert_eq!(<_0SubN3 as Integer>::to_i64(), <P3 as Integer>::to_i64());
12899 }
12900 #[test]
12901 #[allow(non_snake_case)]
12902 fn test__0_Mul_N3() {
12903 type A = Z0;
12904 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
12905 type _0 = Z0;
12906
12907 #[allow(non_camel_case_types)]
12908 type _0MulN3 = <<A as Mul<B>>::Output as Same<_0>>::Output;
12909
12910 assert_eq!(<_0MulN3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
12911 }
12912 #[test]
12913 #[allow(non_snake_case)]
12914 fn test__0_Min_N3() {
12915 type A = Z0;
12916 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
12917 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
12918
12919 #[allow(non_camel_case_types)]
12920 type _0MinN3 = <<A as Min<B>>::Output as Same<N3>>::Output;
12921
12922 assert_eq!(<_0MinN3 as Integer>::to_i64(), <N3 as Integer>::to_i64());
12923 }
12924 #[test]
12925 #[allow(non_snake_case)]
12926 fn test__0_Max_N3() {
12927 type A = Z0;
12928 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
12929 type _0 = Z0;
12930
12931 #[allow(non_camel_case_types)]
12932 type _0MaxN3 = <<A as Max<B>>::Output as Same<_0>>::Output;
12933
12934 assert_eq!(<_0MaxN3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
12935 }
12936 #[test]
12937 #[allow(non_snake_case)]
12938 fn test__0_Gcd_N3() {
12939 type A = Z0;
12940 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
12941 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
12942
12943 #[allow(non_camel_case_types)]
12944 type _0GcdN3 = <<A as Gcd<B>>::Output as Same<P3>>::Output;
12945
12946 assert_eq!(<_0GcdN3 as Integer>::to_i64(), <P3 as Integer>::to_i64());
12947 }
12948 #[test]
12949 #[allow(non_snake_case)]
12950 fn test__0_Div_N3() {
12951 type A = Z0;
12952 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
12953 type _0 = Z0;
12954
12955 #[allow(non_camel_case_types)]
12956 type _0DivN3 = <<A as Div<B>>::Output as Same<_0>>::Output;
12957
12958 assert_eq!(<_0DivN3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
12959 }
12960 #[test]
12961 #[allow(non_snake_case)]
12962 fn test__0_Rem_N3() {
12963 type A = Z0;
12964 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
12965 type _0 = Z0;
12966
12967 #[allow(non_camel_case_types)]
12968 type _0RemN3 = <<A as Rem<B>>::Output as Same<_0>>::Output;
12969
12970 assert_eq!(<_0RemN3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
12971 }
12972 #[test]
12973 #[allow(non_snake_case)]
12974 fn test__0_PartialDiv_N3() {
12975 type A = Z0;
12976 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
12977 type _0 = Z0;
12978
12979 #[allow(non_camel_case_types)]
12980 type _0PartialDivN3 = <<A as PartialDiv<B>>::Output as Same<_0>>::Output;
12981
12982 assert_eq!(<_0PartialDivN3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
12983 }
12984 #[test]
12985 #[allow(non_snake_case)]
12986 fn test__0_Cmp_N3() {
12987 type A = Z0;
12988 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
12989
12990 #[allow(non_camel_case_types)]
12991 type _0CmpN3 = <A as Cmp<B>>::Output;
12992 assert_eq!(<_0CmpN3 as Ord>::to_ordering(), Ordering::Greater);
12993 }
12994 #[test]
12995 #[allow(non_snake_case)]
12996 fn test__0_Add_N2() {
12997 type A = Z0;
12998 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
12999 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
13000
13001 #[allow(non_camel_case_types)]
13002 type _0AddN2 = <<A as Add<B>>::Output as Same<N2>>::Output;
13003
13004 assert_eq!(<_0AddN2 as Integer>::to_i64(), <N2 as Integer>::to_i64());
13005 }
13006 #[test]
13007 #[allow(non_snake_case)]
13008 fn test__0_Sub_N2() {
13009 type A = Z0;
13010 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
13011 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
13012
13013 #[allow(non_camel_case_types)]
13014 type _0SubN2 = <<A as Sub<B>>::Output as Same<P2>>::Output;
13015
13016 assert_eq!(<_0SubN2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
13017 }
13018 #[test]
13019 #[allow(non_snake_case)]
13020 fn test__0_Mul_N2() {
13021 type A = Z0;
13022 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
13023 type _0 = Z0;
13024
13025 #[allow(non_camel_case_types)]
13026 type _0MulN2 = <<A as Mul<B>>::Output as Same<_0>>::Output;
13027
13028 assert_eq!(<_0MulN2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13029 }
13030 #[test]
13031 #[allow(non_snake_case)]
13032 fn test__0_Min_N2() {
13033 type A = Z0;
13034 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
13035 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
13036
13037 #[allow(non_camel_case_types)]
13038 type _0MinN2 = <<A as Min<B>>::Output as Same<N2>>::Output;
13039
13040 assert_eq!(<_0MinN2 as Integer>::to_i64(), <N2 as Integer>::to_i64());
13041 }
13042 #[test]
13043 #[allow(non_snake_case)]
13044 fn test__0_Max_N2() {
13045 type A = Z0;
13046 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
13047 type _0 = Z0;
13048
13049 #[allow(non_camel_case_types)]
13050 type _0MaxN2 = <<A as Max<B>>::Output as Same<_0>>::Output;
13051
13052 assert_eq!(<_0MaxN2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13053 }
13054 #[test]
13055 #[allow(non_snake_case)]
13056 fn test__0_Gcd_N2() {
13057 type A = Z0;
13058 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
13059 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
13060
13061 #[allow(non_camel_case_types)]
13062 type _0GcdN2 = <<A as Gcd<B>>::Output as Same<P2>>::Output;
13063
13064 assert_eq!(<_0GcdN2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
13065 }
13066 #[test]
13067 #[allow(non_snake_case)]
13068 fn test__0_Div_N2() {
13069 type A = Z0;
13070 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
13071 type _0 = Z0;
13072
13073 #[allow(non_camel_case_types)]
13074 type _0DivN2 = <<A as Div<B>>::Output as Same<_0>>::Output;
13075
13076 assert_eq!(<_0DivN2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13077 }
13078 #[test]
13079 #[allow(non_snake_case)]
13080 fn test__0_Rem_N2() {
13081 type A = Z0;
13082 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
13083 type _0 = Z0;
13084
13085 #[allow(non_camel_case_types)]
13086 type _0RemN2 = <<A as Rem<B>>::Output as Same<_0>>::Output;
13087
13088 assert_eq!(<_0RemN2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13089 }
13090 #[test]
13091 #[allow(non_snake_case)]
13092 fn test__0_PartialDiv_N2() {
13093 type A = Z0;
13094 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
13095 type _0 = Z0;
13096
13097 #[allow(non_camel_case_types)]
13098 type _0PartialDivN2 = <<A as PartialDiv<B>>::Output as Same<_0>>::Output;
13099
13100 assert_eq!(<_0PartialDivN2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13101 }
13102 #[test]
13103 #[allow(non_snake_case)]
13104 fn test__0_Cmp_N2() {
13105 type A = Z0;
13106 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
13107
13108 #[allow(non_camel_case_types)]
13109 type _0CmpN2 = <A as Cmp<B>>::Output;
13110 assert_eq!(<_0CmpN2 as Ord>::to_ordering(), Ordering::Greater);
13111 }
13112 #[test]
13113 #[allow(non_snake_case)]
13114 fn test__0_Add_N1() {
13115 type A = Z0;
13116 type B = NInt<UInt<UTerm, B1>>;
13117 type N1 = NInt<UInt<UTerm, B1>>;
13118
13119 #[allow(non_camel_case_types)]
13120 type _0AddN1 = <<A as Add<B>>::Output as Same<N1>>::Output;
13121
13122 assert_eq!(<_0AddN1 as Integer>::to_i64(), <N1 as Integer>::to_i64());
13123 }
13124 #[test]
13125 #[allow(non_snake_case)]
13126 fn test__0_Sub_N1() {
13127 type A = Z0;
13128 type B = NInt<UInt<UTerm, B1>>;
13129 type P1 = PInt<UInt<UTerm, B1>>;
13130
13131 #[allow(non_camel_case_types)]
13132 type _0SubN1 = <<A as Sub<B>>::Output as Same<P1>>::Output;
13133
13134 assert_eq!(<_0SubN1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
13135 }
13136 #[test]
13137 #[allow(non_snake_case)]
13138 fn test__0_Mul_N1() {
13139 type A = Z0;
13140 type B = NInt<UInt<UTerm, B1>>;
13141 type _0 = Z0;
13142
13143 #[allow(non_camel_case_types)]
13144 type _0MulN1 = <<A as Mul<B>>::Output as Same<_0>>::Output;
13145
13146 assert_eq!(<_0MulN1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13147 }
13148 #[test]
13149 #[allow(non_snake_case)]
13150 fn test__0_Min_N1() {
13151 type A = Z0;
13152 type B = NInt<UInt<UTerm, B1>>;
13153 type N1 = NInt<UInt<UTerm, B1>>;
13154
13155 #[allow(non_camel_case_types)]
13156 type _0MinN1 = <<A as Min<B>>::Output as Same<N1>>::Output;
13157
13158 assert_eq!(<_0MinN1 as Integer>::to_i64(), <N1 as Integer>::to_i64());
13159 }
13160 #[test]
13161 #[allow(non_snake_case)]
13162 fn test__0_Max_N1() {
13163 type A = Z0;
13164 type B = NInt<UInt<UTerm, B1>>;
13165 type _0 = Z0;
13166
13167 #[allow(non_camel_case_types)]
13168 type _0MaxN1 = <<A as Max<B>>::Output as Same<_0>>::Output;
13169
13170 assert_eq!(<_0MaxN1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13171 }
13172 #[test]
13173 #[allow(non_snake_case)]
13174 fn test__0_Gcd_N1() {
13175 type A = Z0;
13176 type B = NInt<UInt<UTerm, B1>>;
13177 type P1 = PInt<UInt<UTerm, B1>>;
13178
13179 #[allow(non_camel_case_types)]
13180 type _0GcdN1 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
13181
13182 assert_eq!(<_0GcdN1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
13183 }
13184 #[test]
13185 #[allow(non_snake_case)]
13186 fn test__0_Div_N1() {
13187 type A = Z0;
13188 type B = NInt<UInt<UTerm, B1>>;
13189 type _0 = Z0;
13190
13191 #[allow(non_camel_case_types)]
13192 type _0DivN1 = <<A as Div<B>>::Output as Same<_0>>::Output;
13193
13194 assert_eq!(<_0DivN1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13195 }
13196 #[test]
13197 #[allow(non_snake_case)]
13198 fn test__0_Rem_N1() {
13199 type A = Z0;
13200 type B = NInt<UInt<UTerm, B1>>;
13201 type _0 = Z0;
13202
13203 #[allow(non_camel_case_types)]
13204 type _0RemN1 = <<A as Rem<B>>::Output as Same<_0>>::Output;
13205
13206 assert_eq!(<_0RemN1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13207 }
13208 #[test]
13209 #[allow(non_snake_case)]
13210 fn test__0_PartialDiv_N1() {
13211 type A = Z0;
13212 type B = NInt<UInt<UTerm, B1>>;
13213 type _0 = Z0;
13214
13215 #[allow(non_camel_case_types)]
13216 type _0PartialDivN1 = <<A as PartialDiv<B>>::Output as Same<_0>>::Output;
13217
13218 assert_eq!(<_0PartialDivN1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13219 }
13220 #[test]
13221 #[allow(non_snake_case)]
13222 fn test__0_Cmp_N1() {
13223 type A = Z0;
13224 type B = NInt<UInt<UTerm, B1>>;
13225
13226 #[allow(non_camel_case_types)]
13227 type _0CmpN1 = <A as Cmp<B>>::Output;
13228 assert_eq!(<_0CmpN1 as Ord>::to_ordering(), Ordering::Greater);
13229 }
13230 #[test]
13231 #[allow(non_snake_case)]
13232 fn test__0_Add__0() {
13233 type A = Z0;
13234 type B = Z0;
13235 type _0 = Z0;
13236
13237 #[allow(non_camel_case_types)]
13238 type _0Add_0 = <<A as Add<B>>::Output as Same<_0>>::Output;
13239
13240 assert_eq!(<_0Add_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13241 }
13242 #[test]
13243 #[allow(non_snake_case)]
13244 fn test__0_Sub__0() {
13245 type A = Z0;
13246 type B = Z0;
13247 type _0 = Z0;
13248
13249 #[allow(non_camel_case_types)]
13250 type _0Sub_0 = <<A as Sub<B>>::Output as Same<_0>>::Output;
13251
13252 assert_eq!(<_0Sub_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13253 }
13254 #[test]
13255 #[allow(non_snake_case)]
13256 fn test__0_Mul__0() {
13257 type A = Z0;
13258 type B = Z0;
13259 type _0 = Z0;
13260
13261 #[allow(non_camel_case_types)]
13262 type _0Mul_0 = <<A as Mul<B>>::Output as Same<_0>>::Output;
13263
13264 assert_eq!(<_0Mul_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13265 }
13266 #[test]
13267 #[allow(non_snake_case)]
13268 fn test__0_Min__0() {
13269 type A = Z0;
13270 type B = Z0;
13271 type _0 = Z0;
13272
13273 #[allow(non_camel_case_types)]
13274 type _0Min_0 = <<A as Min<B>>::Output as Same<_0>>::Output;
13275
13276 assert_eq!(<_0Min_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13277 }
13278 #[test]
13279 #[allow(non_snake_case)]
13280 fn test__0_Max__0() {
13281 type A = Z0;
13282 type B = Z0;
13283 type _0 = Z0;
13284
13285 #[allow(non_camel_case_types)]
13286 type _0Max_0 = <<A as Max<B>>::Output as Same<_0>>::Output;
13287
13288 assert_eq!(<_0Max_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13289 }
13290 #[test]
13291 #[allow(non_snake_case)]
13292 fn test__0_Gcd__0() {
13293 type A = Z0;
13294 type B = Z0;
13295 type _0 = Z0;
13296
13297 #[allow(non_camel_case_types)]
13298 type _0Gcd_0 = <<A as Gcd<B>>::Output as Same<_0>>::Output;
13299
13300 assert_eq!(<_0Gcd_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13301 }
13302 #[test]
13303 #[allow(non_snake_case)]
13304 fn test__0_Pow__0() {
13305 type A = Z0;
13306 type B = Z0;
13307 type P1 = PInt<UInt<UTerm, B1>>;
13308
13309 #[allow(non_camel_case_types)]
13310 type _0Pow_0 = <<A as Pow<B>>::Output as Same<P1>>::Output;
13311
13312 assert_eq!(<_0Pow_0 as Integer>::to_i64(), <P1 as Integer>::to_i64());
13313 }
13314 #[test]
13315 #[allow(non_snake_case)]
13316 fn test__0_Cmp__0() {
13317 type A = Z0;
13318 type B = Z0;
13319
13320 #[allow(non_camel_case_types)]
13321 type _0Cmp_0 = <A as Cmp<B>>::Output;
13322 assert_eq!(<_0Cmp_0 as Ord>::to_ordering(), Ordering::Equal);
13323 }
13324 #[test]
13325 #[allow(non_snake_case)]
13326 fn test__0_Add_P1() {
13327 type A = Z0;
13328 type B = PInt<UInt<UTerm, B1>>;
13329 type P1 = PInt<UInt<UTerm, B1>>;
13330
13331 #[allow(non_camel_case_types)]
13332 type _0AddP1 = <<A as Add<B>>::Output as Same<P1>>::Output;
13333
13334 assert_eq!(<_0AddP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
13335 }
13336 #[test]
13337 #[allow(non_snake_case)]
13338 fn test__0_Sub_P1() {
13339 type A = Z0;
13340 type B = PInt<UInt<UTerm, B1>>;
13341 type N1 = NInt<UInt<UTerm, B1>>;
13342
13343 #[allow(non_camel_case_types)]
13344 type _0SubP1 = <<A as Sub<B>>::Output as Same<N1>>::Output;
13345
13346 assert_eq!(<_0SubP1 as Integer>::to_i64(), <N1 as Integer>::to_i64());
13347 }
13348 #[test]
13349 #[allow(non_snake_case)]
13350 fn test__0_Mul_P1() {
13351 type A = Z0;
13352 type B = PInt<UInt<UTerm, B1>>;
13353 type _0 = Z0;
13354
13355 #[allow(non_camel_case_types)]
13356 type _0MulP1 = <<A as Mul<B>>::Output as Same<_0>>::Output;
13357
13358 assert_eq!(<_0MulP1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13359 }
13360 #[test]
13361 #[allow(non_snake_case)]
13362 fn test__0_Min_P1() {
13363 type A = Z0;
13364 type B = PInt<UInt<UTerm, B1>>;
13365 type _0 = Z0;
13366
13367 #[allow(non_camel_case_types)]
13368 type _0MinP1 = <<A as Min<B>>::Output as Same<_0>>::Output;
13369
13370 assert_eq!(<_0MinP1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13371 }
13372 #[test]
13373 #[allow(non_snake_case)]
13374 fn test__0_Max_P1() {
13375 type A = Z0;
13376 type B = PInt<UInt<UTerm, B1>>;
13377 type P1 = PInt<UInt<UTerm, B1>>;
13378
13379 #[allow(non_camel_case_types)]
13380 type _0MaxP1 = <<A as Max<B>>::Output as Same<P1>>::Output;
13381
13382 assert_eq!(<_0MaxP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
13383 }
13384 #[test]
13385 #[allow(non_snake_case)]
13386 fn test__0_Gcd_P1() {
13387 type A = Z0;
13388 type B = PInt<UInt<UTerm, B1>>;
13389 type P1 = PInt<UInt<UTerm, B1>>;
13390
13391 #[allow(non_camel_case_types)]
13392 type _0GcdP1 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
13393
13394 assert_eq!(<_0GcdP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
13395 }
13396 #[test]
13397 #[allow(non_snake_case)]
13398 fn test__0_Div_P1() {
13399 type A = Z0;
13400 type B = PInt<UInt<UTerm, B1>>;
13401 type _0 = Z0;
13402
13403 #[allow(non_camel_case_types)]
13404 type _0DivP1 = <<A as Div<B>>::Output as Same<_0>>::Output;
13405
13406 assert_eq!(<_0DivP1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13407 }
13408 #[test]
13409 #[allow(non_snake_case)]
13410 fn test__0_Rem_P1() {
13411 type A = Z0;
13412 type B = PInt<UInt<UTerm, B1>>;
13413 type _0 = Z0;
13414
13415 #[allow(non_camel_case_types)]
13416 type _0RemP1 = <<A as Rem<B>>::Output as Same<_0>>::Output;
13417
13418 assert_eq!(<_0RemP1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13419 }
13420 #[test]
13421 #[allow(non_snake_case)]
13422 fn test__0_PartialDiv_P1() {
13423 type A = Z0;
13424 type B = PInt<UInt<UTerm, B1>>;
13425 type _0 = Z0;
13426
13427 #[allow(non_camel_case_types)]
13428 type _0PartialDivP1 = <<A as PartialDiv<B>>::Output as Same<_0>>::Output;
13429
13430 assert_eq!(<_0PartialDivP1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13431 }
13432 #[test]
13433 #[allow(non_snake_case)]
13434 fn test__0_Pow_P1() {
13435 type A = Z0;
13436 type B = PInt<UInt<UTerm, B1>>;
13437 type _0 = Z0;
13438
13439 #[allow(non_camel_case_types)]
13440 type _0PowP1 = <<A as Pow<B>>::Output as Same<_0>>::Output;
13441
13442 assert_eq!(<_0PowP1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13443 }
13444 #[test]
13445 #[allow(non_snake_case)]
13446 fn test__0_Cmp_P1() {
13447 type A = Z0;
13448 type B = PInt<UInt<UTerm, B1>>;
13449
13450 #[allow(non_camel_case_types)]
13451 type _0CmpP1 = <A as Cmp<B>>::Output;
13452 assert_eq!(<_0CmpP1 as Ord>::to_ordering(), Ordering::Less);
13453 }
13454 #[test]
13455 #[allow(non_snake_case)]
13456 fn test__0_Add_P2() {
13457 type A = Z0;
13458 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
13459 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
13460
13461 #[allow(non_camel_case_types)]
13462 type _0AddP2 = <<A as Add<B>>::Output as Same<P2>>::Output;
13463
13464 assert_eq!(<_0AddP2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
13465 }
13466 #[test]
13467 #[allow(non_snake_case)]
13468 fn test__0_Sub_P2() {
13469 type A = Z0;
13470 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
13471 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
13472
13473 #[allow(non_camel_case_types)]
13474 type _0SubP2 = <<A as Sub<B>>::Output as Same<N2>>::Output;
13475
13476 assert_eq!(<_0SubP2 as Integer>::to_i64(), <N2 as Integer>::to_i64());
13477 }
13478 #[test]
13479 #[allow(non_snake_case)]
13480 fn test__0_Mul_P2() {
13481 type A = Z0;
13482 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
13483 type _0 = Z0;
13484
13485 #[allow(non_camel_case_types)]
13486 type _0MulP2 = <<A as Mul<B>>::Output as Same<_0>>::Output;
13487
13488 assert_eq!(<_0MulP2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13489 }
13490 #[test]
13491 #[allow(non_snake_case)]
13492 fn test__0_Min_P2() {
13493 type A = Z0;
13494 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
13495 type _0 = Z0;
13496
13497 #[allow(non_camel_case_types)]
13498 type _0MinP2 = <<A as Min<B>>::Output as Same<_0>>::Output;
13499
13500 assert_eq!(<_0MinP2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13501 }
13502 #[test]
13503 #[allow(non_snake_case)]
13504 fn test__0_Max_P2() {
13505 type A = Z0;
13506 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
13507 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
13508
13509 #[allow(non_camel_case_types)]
13510 type _0MaxP2 = <<A as Max<B>>::Output as Same<P2>>::Output;
13511
13512 assert_eq!(<_0MaxP2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
13513 }
13514 #[test]
13515 #[allow(non_snake_case)]
13516 fn test__0_Gcd_P2() {
13517 type A = Z0;
13518 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
13519 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
13520
13521 #[allow(non_camel_case_types)]
13522 type _0GcdP2 = <<A as Gcd<B>>::Output as Same<P2>>::Output;
13523
13524 assert_eq!(<_0GcdP2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
13525 }
13526 #[test]
13527 #[allow(non_snake_case)]
13528 fn test__0_Div_P2() {
13529 type A = Z0;
13530 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
13531 type _0 = Z0;
13532
13533 #[allow(non_camel_case_types)]
13534 type _0DivP2 = <<A as Div<B>>::Output as Same<_0>>::Output;
13535
13536 assert_eq!(<_0DivP2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13537 }
13538 #[test]
13539 #[allow(non_snake_case)]
13540 fn test__0_Rem_P2() {
13541 type A = Z0;
13542 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
13543 type _0 = Z0;
13544
13545 #[allow(non_camel_case_types)]
13546 type _0RemP2 = <<A as Rem<B>>::Output as Same<_0>>::Output;
13547
13548 assert_eq!(<_0RemP2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13549 }
13550 #[test]
13551 #[allow(non_snake_case)]
13552 fn test__0_PartialDiv_P2() {
13553 type A = Z0;
13554 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
13555 type _0 = Z0;
13556
13557 #[allow(non_camel_case_types)]
13558 type _0PartialDivP2 = <<A as PartialDiv<B>>::Output as Same<_0>>::Output;
13559
13560 assert_eq!(<_0PartialDivP2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13561 }
13562 #[test]
13563 #[allow(non_snake_case)]
13564 fn test__0_Pow_P2() {
13565 type A = Z0;
13566 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
13567 type _0 = Z0;
13568
13569 #[allow(non_camel_case_types)]
13570 type _0PowP2 = <<A as Pow<B>>::Output as Same<_0>>::Output;
13571
13572 assert_eq!(<_0PowP2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13573 }
13574 #[test]
13575 #[allow(non_snake_case)]
13576 fn test__0_Cmp_P2() {
13577 type A = Z0;
13578 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
13579
13580 #[allow(non_camel_case_types)]
13581 type _0CmpP2 = <A as Cmp<B>>::Output;
13582 assert_eq!(<_0CmpP2 as Ord>::to_ordering(), Ordering::Less);
13583 }
13584 #[test]
13585 #[allow(non_snake_case)]
13586 fn test__0_Add_P3() {
13587 type A = Z0;
13588 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
13589 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
13590
13591 #[allow(non_camel_case_types)]
13592 type _0AddP3 = <<A as Add<B>>::Output as Same<P3>>::Output;
13593
13594 assert_eq!(<_0AddP3 as Integer>::to_i64(), <P3 as Integer>::to_i64());
13595 }
13596 #[test]
13597 #[allow(non_snake_case)]
13598 fn test__0_Sub_P3() {
13599 type A = Z0;
13600 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
13601 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
13602
13603 #[allow(non_camel_case_types)]
13604 type _0SubP3 = <<A as Sub<B>>::Output as Same<N3>>::Output;
13605
13606 assert_eq!(<_0SubP3 as Integer>::to_i64(), <N3 as Integer>::to_i64());
13607 }
13608 #[test]
13609 #[allow(non_snake_case)]
13610 fn test__0_Mul_P3() {
13611 type A = Z0;
13612 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
13613 type _0 = Z0;
13614
13615 #[allow(non_camel_case_types)]
13616 type _0MulP3 = <<A as Mul<B>>::Output as Same<_0>>::Output;
13617
13618 assert_eq!(<_0MulP3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13619 }
13620 #[test]
13621 #[allow(non_snake_case)]
13622 fn test__0_Min_P3() {
13623 type A = Z0;
13624 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
13625 type _0 = Z0;
13626
13627 #[allow(non_camel_case_types)]
13628 type _0MinP3 = <<A as Min<B>>::Output as Same<_0>>::Output;
13629
13630 assert_eq!(<_0MinP3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13631 }
13632 #[test]
13633 #[allow(non_snake_case)]
13634 fn test__0_Max_P3() {
13635 type A = Z0;
13636 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
13637 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
13638
13639 #[allow(non_camel_case_types)]
13640 type _0MaxP3 = <<A as Max<B>>::Output as Same<P3>>::Output;
13641
13642 assert_eq!(<_0MaxP3 as Integer>::to_i64(), <P3 as Integer>::to_i64());
13643 }
13644 #[test]
13645 #[allow(non_snake_case)]
13646 fn test__0_Gcd_P3() {
13647 type A = Z0;
13648 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
13649 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
13650
13651 #[allow(non_camel_case_types)]
13652 type _0GcdP3 = <<A as Gcd<B>>::Output as Same<P3>>::Output;
13653
13654 assert_eq!(<_0GcdP3 as Integer>::to_i64(), <P3 as Integer>::to_i64());
13655 }
13656 #[test]
13657 #[allow(non_snake_case)]
13658 fn test__0_Div_P3() {
13659 type A = Z0;
13660 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
13661 type _0 = Z0;
13662
13663 #[allow(non_camel_case_types)]
13664 type _0DivP3 = <<A as Div<B>>::Output as Same<_0>>::Output;
13665
13666 assert_eq!(<_0DivP3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13667 }
13668 #[test]
13669 #[allow(non_snake_case)]
13670 fn test__0_Rem_P3() {
13671 type A = Z0;
13672 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
13673 type _0 = Z0;
13674
13675 #[allow(non_camel_case_types)]
13676 type _0RemP3 = <<A as Rem<B>>::Output as Same<_0>>::Output;
13677
13678 assert_eq!(<_0RemP3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13679 }
13680 #[test]
13681 #[allow(non_snake_case)]
13682 fn test__0_PartialDiv_P3() {
13683 type A = Z0;
13684 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
13685 type _0 = Z0;
13686
13687 #[allow(non_camel_case_types)]
13688 type _0PartialDivP3 = <<A as PartialDiv<B>>::Output as Same<_0>>::Output;
13689
13690 assert_eq!(<_0PartialDivP3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13691 }
13692 #[test]
13693 #[allow(non_snake_case)]
13694 fn test__0_Pow_P3() {
13695 type A = Z0;
13696 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
13697 type _0 = Z0;
13698
13699 #[allow(non_camel_case_types)]
13700 type _0PowP3 = <<A as Pow<B>>::Output as Same<_0>>::Output;
13701
13702 assert_eq!(<_0PowP3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13703 }
13704 #[test]
13705 #[allow(non_snake_case)]
13706 fn test__0_Cmp_P3() {
13707 type A = Z0;
13708 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
13709
13710 #[allow(non_camel_case_types)]
13711 type _0CmpP3 = <A as Cmp<B>>::Output;
13712 assert_eq!(<_0CmpP3 as Ord>::to_ordering(), Ordering::Less);
13713 }
13714 #[test]
13715 #[allow(non_snake_case)]
13716 fn test__0_Add_P4() {
13717 type A = Z0;
13718 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
13719 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
13720
13721 #[allow(non_camel_case_types)]
13722 type _0AddP4 = <<A as Add<B>>::Output as Same<P4>>::Output;
13723
13724 assert_eq!(<_0AddP4 as Integer>::to_i64(), <P4 as Integer>::to_i64());
13725 }
13726 #[test]
13727 #[allow(non_snake_case)]
13728 fn test__0_Sub_P4() {
13729 type A = Z0;
13730 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
13731 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
13732
13733 #[allow(non_camel_case_types)]
13734 type _0SubP4 = <<A as Sub<B>>::Output as Same<N4>>::Output;
13735
13736 assert_eq!(<_0SubP4 as Integer>::to_i64(), <N4 as Integer>::to_i64());
13737 }
13738 #[test]
13739 #[allow(non_snake_case)]
13740 fn test__0_Mul_P4() {
13741 type A = Z0;
13742 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
13743 type _0 = Z0;
13744
13745 #[allow(non_camel_case_types)]
13746 type _0MulP4 = <<A as Mul<B>>::Output as Same<_0>>::Output;
13747
13748 assert_eq!(<_0MulP4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13749 }
13750 #[test]
13751 #[allow(non_snake_case)]
13752 fn test__0_Min_P4() {
13753 type A = Z0;
13754 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
13755 type _0 = Z0;
13756
13757 #[allow(non_camel_case_types)]
13758 type _0MinP4 = <<A as Min<B>>::Output as Same<_0>>::Output;
13759
13760 assert_eq!(<_0MinP4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13761 }
13762 #[test]
13763 #[allow(non_snake_case)]
13764 fn test__0_Max_P4() {
13765 type A = Z0;
13766 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
13767 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
13768
13769 #[allow(non_camel_case_types)]
13770 type _0MaxP4 = <<A as Max<B>>::Output as Same<P4>>::Output;
13771
13772 assert_eq!(<_0MaxP4 as Integer>::to_i64(), <P4 as Integer>::to_i64());
13773 }
13774 #[test]
13775 #[allow(non_snake_case)]
13776 fn test__0_Gcd_P4() {
13777 type A = Z0;
13778 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
13779 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
13780
13781 #[allow(non_camel_case_types)]
13782 type _0GcdP4 = <<A as Gcd<B>>::Output as Same<P4>>::Output;
13783
13784 assert_eq!(<_0GcdP4 as Integer>::to_i64(), <P4 as Integer>::to_i64());
13785 }
13786 #[test]
13787 #[allow(non_snake_case)]
13788 fn test__0_Div_P4() {
13789 type A = Z0;
13790 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
13791 type _0 = Z0;
13792
13793 #[allow(non_camel_case_types)]
13794 type _0DivP4 = <<A as Div<B>>::Output as Same<_0>>::Output;
13795
13796 assert_eq!(<_0DivP4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13797 }
13798 #[test]
13799 #[allow(non_snake_case)]
13800 fn test__0_Rem_P4() {
13801 type A = Z0;
13802 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
13803 type _0 = Z0;
13804
13805 #[allow(non_camel_case_types)]
13806 type _0RemP4 = <<A as Rem<B>>::Output as Same<_0>>::Output;
13807
13808 assert_eq!(<_0RemP4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13809 }
13810 #[test]
13811 #[allow(non_snake_case)]
13812 fn test__0_PartialDiv_P4() {
13813 type A = Z0;
13814 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
13815 type _0 = Z0;
13816
13817 #[allow(non_camel_case_types)]
13818 type _0PartialDivP4 = <<A as PartialDiv<B>>::Output as Same<_0>>::Output;
13819
13820 assert_eq!(<_0PartialDivP4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13821 }
13822 #[test]
13823 #[allow(non_snake_case)]
13824 fn test__0_Pow_P4() {
13825 type A = Z0;
13826 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
13827 type _0 = Z0;
13828
13829 #[allow(non_camel_case_types)]
13830 type _0PowP4 = <<A as Pow<B>>::Output as Same<_0>>::Output;
13831
13832 assert_eq!(<_0PowP4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13833 }
13834 #[test]
13835 #[allow(non_snake_case)]
13836 fn test__0_Cmp_P4() {
13837 type A = Z0;
13838 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
13839
13840 #[allow(non_camel_case_types)]
13841 type _0CmpP4 = <A as Cmp<B>>::Output;
13842 assert_eq!(<_0CmpP4 as Ord>::to_ordering(), Ordering::Less);
13843 }
13844 #[test]
13845 #[allow(non_snake_case)]
13846 fn test__0_Add_P5() {
13847 type A = Z0;
13848 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
13849 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
13850
13851 #[allow(non_camel_case_types)]
13852 type _0AddP5 = <<A as Add<B>>::Output as Same<P5>>::Output;
13853
13854 assert_eq!(<_0AddP5 as Integer>::to_i64(), <P5 as Integer>::to_i64());
13855 }
13856 #[test]
13857 #[allow(non_snake_case)]
13858 fn test__0_Sub_P5() {
13859 type A = Z0;
13860 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
13861 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
13862
13863 #[allow(non_camel_case_types)]
13864 type _0SubP5 = <<A as Sub<B>>::Output as Same<N5>>::Output;
13865
13866 assert_eq!(<_0SubP5 as Integer>::to_i64(), <N5 as Integer>::to_i64());
13867 }
13868 #[test]
13869 #[allow(non_snake_case)]
13870 fn test__0_Mul_P5() {
13871 type A = Z0;
13872 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
13873 type _0 = Z0;
13874
13875 #[allow(non_camel_case_types)]
13876 type _0MulP5 = <<A as Mul<B>>::Output as Same<_0>>::Output;
13877
13878 assert_eq!(<_0MulP5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13879 }
13880 #[test]
13881 #[allow(non_snake_case)]
13882 fn test__0_Min_P5() {
13883 type A = Z0;
13884 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
13885 type _0 = Z0;
13886
13887 #[allow(non_camel_case_types)]
13888 type _0MinP5 = <<A as Min<B>>::Output as Same<_0>>::Output;
13889
13890 assert_eq!(<_0MinP5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13891 }
13892 #[test]
13893 #[allow(non_snake_case)]
13894 fn test__0_Max_P5() {
13895 type A = Z0;
13896 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
13897 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
13898
13899 #[allow(non_camel_case_types)]
13900 type _0MaxP5 = <<A as Max<B>>::Output as Same<P5>>::Output;
13901
13902 assert_eq!(<_0MaxP5 as Integer>::to_i64(), <P5 as Integer>::to_i64());
13903 }
13904 #[test]
13905 #[allow(non_snake_case)]
13906 fn test__0_Gcd_P5() {
13907 type A = Z0;
13908 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
13909 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
13910
13911 #[allow(non_camel_case_types)]
13912 type _0GcdP5 = <<A as Gcd<B>>::Output as Same<P5>>::Output;
13913
13914 assert_eq!(<_0GcdP5 as Integer>::to_i64(), <P5 as Integer>::to_i64());
13915 }
13916 #[test]
13917 #[allow(non_snake_case)]
13918 fn test__0_Div_P5() {
13919 type A = Z0;
13920 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
13921 type _0 = Z0;
13922
13923 #[allow(non_camel_case_types)]
13924 type _0DivP5 = <<A as Div<B>>::Output as Same<_0>>::Output;
13925
13926 assert_eq!(<_0DivP5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13927 }
13928 #[test]
13929 #[allow(non_snake_case)]
13930 fn test__0_Rem_P5() {
13931 type A = Z0;
13932 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
13933 type _0 = Z0;
13934
13935 #[allow(non_camel_case_types)]
13936 type _0RemP5 = <<A as Rem<B>>::Output as Same<_0>>::Output;
13937
13938 assert_eq!(<_0RemP5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13939 }
13940 #[test]
13941 #[allow(non_snake_case)]
13942 fn test__0_PartialDiv_P5() {
13943 type A = Z0;
13944 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
13945 type _0 = Z0;
13946
13947 #[allow(non_camel_case_types)]
13948 type _0PartialDivP5 = <<A as PartialDiv<B>>::Output as Same<_0>>::Output;
13949
13950 assert_eq!(<_0PartialDivP5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13951 }
13952 #[test]
13953 #[allow(non_snake_case)]
13954 fn test__0_Pow_P5() {
13955 type A = Z0;
13956 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
13957 type _0 = Z0;
13958
13959 #[allow(non_camel_case_types)]
13960 type _0PowP5 = <<A as Pow<B>>::Output as Same<_0>>::Output;
13961
13962 assert_eq!(<_0PowP5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
13963 }
13964 #[test]
13965 #[allow(non_snake_case)]
13966 fn test__0_Cmp_P5() {
13967 type A = Z0;
13968 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
13969
13970 #[allow(non_camel_case_types)]
13971 type _0CmpP5 = <A as Cmp<B>>::Output;
13972 assert_eq!(<_0CmpP5 as Ord>::to_ordering(), Ordering::Less);
13973 }
13974 #[test]
13975 #[allow(non_snake_case)]
13976 fn test_P1_Add_N5() {
13977 type A = PInt<UInt<UTerm, B1>>;
13978 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
13979 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
13980
13981 #[allow(non_camel_case_types)]
13982 type P1AddN5 = <<A as Add<B>>::Output as Same<N4>>::Output;
13983
13984 assert_eq!(<P1AddN5 as Integer>::to_i64(), <N4 as Integer>::to_i64());
13985 }
13986 #[test]
13987 #[allow(non_snake_case)]
13988 fn test_P1_Sub_N5() {
13989 type A = PInt<UInt<UTerm, B1>>;
13990 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
13991 type P6 = PInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
13992
13993 #[allow(non_camel_case_types)]
13994 type P1SubN5 = <<A as Sub<B>>::Output as Same<P6>>::Output;
13995
13996 assert_eq!(<P1SubN5 as Integer>::to_i64(), <P6 as Integer>::to_i64());
13997 }
13998 #[test]
13999 #[allow(non_snake_case)]
14000 fn test_P1_Mul_N5() {
14001 type A = PInt<UInt<UTerm, B1>>;
14002 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
14003 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
14004
14005 #[allow(non_camel_case_types)]
14006 type P1MulN5 = <<A as Mul<B>>::Output as Same<N5>>::Output;
14007
14008 assert_eq!(<P1MulN5 as Integer>::to_i64(), <N5 as Integer>::to_i64());
14009 }
14010 #[test]
14011 #[allow(non_snake_case)]
14012 fn test_P1_Min_N5() {
14013 type A = PInt<UInt<UTerm, B1>>;
14014 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
14015 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
14016
14017 #[allow(non_camel_case_types)]
14018 type P1MinN5 = <<A as Min<B>>::Output as Same<N5>>::Output;
14019
14020 assert_eq!(<P1MinN5 as Integer>::to_i64(), <N5 as Integer>::to_i64());
14021 }
14022 #[test]
14023 #[allow(non_snake_case)]
14024 fn test_P1_Max_N5() {
14025 type A = PInt<UInt<UTerm, B1>>;
14026 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
14027 type P1 = PInt<UInt<UTerm, B1>>;
14028
14029 #[allow(non_camel_case_types)]
14030 type P1MaxN5 = <<A as Max<B>>::Output as Same<P1>>::Output;
14031
14032 assert_eq!(<P1MaxN5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14033 }
14034 #[test]
14035 #[allow(non_snake_case)]
14036 fn test_P1_Gcd_N5() {
14037 type A = PInt<UInt<UTerm, B1>>;
14038 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
14039 type P1 = PInt<UInt<UTerm, B1>>;
14040
14041 #[allow(non_camel_case_types)]
14042 type P1GcdN5 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
14043
14044 assert_eq!(<P1GcdN5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14045 }
14046 #[test]
14047 #[allow(non_snake_case)]
14048 fn test_P1_Div_N5() {
14049 type A = PInt<UInt<UTerm, B1>>;
14050 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
14051 type _0 = Z0;
14052
14053 #[allow(non_camel_case_types)]
14054 type P1DivN5 = <<A as Div<B>>::Output as Same<_0>>::Output;
14055
14056 assert_eq!(<P1DivN5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
14057 }
14058 #[test]
14059 #[allow(non_snake_case)]
14060 fn test_P1_Rem_N5() {
14061 type A = PInt<UInt<UTerm, B1>>;
14062 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
14063 type P1 = PInt<UInt<UTerm, B1>>;
14064
14065 #[allow(non_camel_case_types)]
14066 type P1RemN5 = <<A as Rem<B>>::Output as Same<P1>>::Output;
14067
14068 assert_eq!(<P1RemN5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14069 }
14070 #[test]
14071 #[allow(non_snake_case)]
14072 fn test_P1_Pow_N5() {
14073 type A = PInt<UInt<UTerm, B1>>;
14074 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
14075 type P1 = PInt<UInt<UTerm, B1>>;
14076
14077 #[allow(non_camel_case_types)]
14078 type P1PowN5 = <<A as Pow<B>>::Output as Same<P1>>::Output;
14079
14080 assert_eq!(<P1PowN5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14081 }
14082 #[test]
14083 #[allow(non_snake_case)]
14084 fn test_P1_Cmp_N5() {
14085 type A = PInt<UInt<UTerm, B1>>;
14086 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
14087
14088 #[allow(non_camel_case_types)]
14089 type P1CmpN5 = <A as Cmp<B>>::Output;
14090 assert_eq!(<P1CmpN5 as Ord>::to_ordering(), Ordering::Greater);
14091 }
14092 #[test]
14093 #[allow(non_snake_case)]
14094 fn test_P1_Add_N4() {
14095 type A = PInt<UInt<UTerm, B1>>;
14096 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
14097 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
14098
14099 #[allow(non_camel_case_types)]
14100 type P1AddN4 = <<A as Add<B>>::Output as Same<N3>>::Output;
14101
14102 assert_eq!(<P1AddN4 as Integer>::to_i64(), <N3 as Integer>::to_i64());
14103 }
14104 #[test]
14105 #[allow(non_snake_case)]
14106 fn test_P1_Sub_N4() {
14107 type A = PInt<UInt<UTerm, B1>>;
14108 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
14109 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
14110
14111 #[allow(non_camel_case_types)]
14112 type P1SubN4 = <<A as Sub<B>>::Output as Same<P5>>::Output;
14113
14114 assert_eq!(<P1SubN4 as Integer>::to_i64(), <P5 as Integer>::to_i64());
14115 }
14116 #[test]
14117 #[allow(non_snake_case)]
14118 fn test_P1_Mul_N4() {
14119 type A = PInt<UInt<UTerm, B1>>;
14120 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
14121 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
14122
14123 #[allow(non_camel_case_types)]
14124 type P1MulN4 = <<A as Mul<B>>::Output as Same<N4>>::Output;
14125
14126 assert_eq!(<P1MulN4 as Integer>::to_i64(), <N4 as Integer>::to_i64());
14127 }
14128 #[test]
14129 #[allow(non_snake_case)]
14130 fn test_P1_Min_N4() {
14131 type A = PInt<UInt<UTerm, B1>>;
14132 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
14133 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
14134
14135 #[allow(non_camel_case_types)]
14136 type P1MinN4 = <<A as Min<B>>::Output as Same<N4>>::Output;
14137
14138 assert_eq!(<P1MinN4 as Integer>::to_i64(), <N4 as Integer>::to_i64());
14139 }
14140 #[test]
14141 #[allow(non_snake_case)]
14142 fn test_P1_Max_N4() {
14143 type A = PInt<UInt<UTerm, B1>>;
14144 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
14145 type P1 = PInt<UInt<UTerm, B1>>;
14146
14147 #[allow(non_camel_case_types)]
14148 type P1MaxN4 = <<A as Max<B>>::Output as Same<P1>>::Output;
14149
14150 assert_eq!(<P1MaxN4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14151 }
14152 #[test]
14153 #[allow(non_snake_case)]
14154 fn test_P1_Gcd_N4() {
14155 type A = PInt<UInt<UTerm, B1>>;
14156 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
14157 type P1 = PInt<UInt<UTerm, B1>>;
14158
14159 #[allow(non_camel_case_types)]
14160 type P1GcdN4 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
14161
14162 assert_eq!(<P1GcdN4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14163 }
14164 #[test]
14165 #[allow(non_snake_case)]
14166 fn test_P1_Div_N4() {
14167 type A = PInt<UInt<UTerm, B1>>;
14168 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
14169 type _0 = Z0;
14170
14171 #[allow(non_camel_case_types)]
14172 type P1DivN4 = <<A as Div<B>>::Output as Same<_0>>::Output;
14173
14174 assert_eq!(<P1DivN4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
14175 }
14176 #[test]
14177 #[allow(non_snake_case)]
14178 fn test_P1_Rem_N4() {
14179 type A = PInt<UInt<UTerm, B1>>;
14180 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
14181 type P1 = PInt<UInt<UTerm, B1>>;
14182
14183 #[allow(non_camel_case_types)]
14184 type P1RemN4 = <<A as Rem<B>>::Output as Same<P1>>::Output;
14185
14186 assert_eq!(<P1RemN4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14187 }
14188 #[test]
14189 #[allow(non_snake_case)]
14190 fn test_P1_Pow_N4() {
14191 type A = PInt<UInt<UTerm, B1>>;
14192 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
14193 type P1 = PInt<UInt<UTerm, B1>>;
14194
14195 #[allow(non_camel_case_types)]
14196 type P1PowN4 = <<A as Pow<B>>::Output as Same<P1>>::Output;
14197
14198 assert_eq!(<P1PowN4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14199 }
14200 #[test]
14201 #[allow(non_snake_case)]
14202 fn test_P1_Cmp_N4() {
14203 type A = PInt<UInt<UTerm, B1>>;
14204 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
14205
14206 #[allow(non_camel_case_types)]
14207 type P1CmpN4 = <A as Cmp<B>>::Output;
14208 assert_eq!(<P1CmpN4 as Ord>::to_ordering(), Ordering::Greater);
14209 }
14210 #[test]
14211 #[allow(non_snake_case)]
14212 fn test_P1_Add_N3() {
14213 type A = PInt<UInt<UTerm, B1>>;
14214 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
14215 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
14216
14217 #[allow(non_camel_case_types)]
14218 type P1AddN3 = <<A as Add<B>>::Output as Same<N2>>::Output;
14219
14220 assert_eq!(<P1AddN3 as Integer>::to_i64(), <N2 as Integer>::to_i64());
14221 }
14222 #[test]
14223 #[allow(non_snake_case)]
14224 fn test_P1_Sub_N3() {
14225 type A = PInt<UInt<UTerm, B1>>;
14226 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
14227 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
14228
14229 #[allow(non_camel_case_types)]
14230 type P1SubN3 = <<A as Sub<B>>::Output as Same<P4>>::Output;
14231
14232 assert_eq!(<P1SubN3 as Integer>::to_i64(), <P4 as Integer>::to_i64());
14233 }
14234 #[test]
14235 #[allow(non_snake_case)]
14236 fn test_P1_Mul_N3() {
14237 type A = PInt<UInt<UTerm, B1>>;
14238 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
14239 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
14240
14241 #[allow(non_camel_case_types)]
14242 type P1MulN3 = <<A as Mul<B>>::Output as Same<N3>>::Output;
14243
14244 assert_eq!(<P1MulN3 as Integer>::to_i64(), <N3 as Integer>::to_i64());
14245 }
14246 #[test]
14247 #[allow(non_snake_case)]
14248 fn test_P1_Min_N3() {
14249 type A = PInt<UInt<UTerm, B1>>;
14250 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
14251 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
14252
14253 #[allow(non_camel_case_types)]
14254 type P1MinN3 = <<A as Min<B>>::Output as Same<N3>>::Output;
14255
14256 assert_eq!(<P1MinN3 as Integer>::to_i64(), <N3 as Integer>::to_i64());
14257 }
14258 #[test]
14259 #[allow(non_snake_case)]
14260 fn test_P1_Max_N3() {
14261 type A = PInt<UInt<UTerm, B1>>;
14262 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
14263 type P1 = PInt<UInt<UTerm, B1>>;
14264
14265 #[allow(non_camel_case_types)]
14266 type P1MaxN3 = <<A as Max<B>>::Output as Same<P1>>::Output;
14267
14268 assert_eq!(<P1MaxN3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14269 }
14270 #[test]
14271 #[allow(non_snake_case)]
14272 fn test_P1_Gcd_N3() {
14273 type A = PInt<UInt<UTerm, B1>>;
14274 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
14275 type P1 = PInt<UInt<UTerm, B1>>;
14276
14277 #[allow(non_camel_case_types)]
14278 type P1GcdN3 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
14279
14280 assert_eq!(<P1GcdN3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14281 }
14282 #[test]
14283 #[allow(non_snake_case)]
14284 fn test_P1_Div_N3() {
14285 type A = PInt<UInt<UTerm, B1>>;
14286 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
14287 type _0 = Z0;
14288
14289 #[allow(non_camel_case_types)]
14290 type P1DivN3 = <<A as Div<B>>::Output as Same<_0>>::Output;
14291
14292 assert_eq!(<P1DivN3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
14293 }
14294 #[test]
14295 #[allow(non_snake_case)]
14296 fn test_P1_Rem_N3() {
14297 type A = PInt<UInt<UTerm, B1>>;
14298 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
14299 type P1 = PInt<UInt<UTerm, B1>>;
14300
14301 #[allow(non_camel_case_types)]
14302 type P1RemN3 = <<A as Rem<B>>::Output as Same<P1>>::Output;
14303
14304 assert_eq!(<P1RemN3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14305 }
14306 #[test]
14307 #[allow(non_snake_case)]
14308 fn test_P1_Pow_N3() {
14309 type A = PInt<UInt<UTerm, B1>>;
14310 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
14311 type P1 = PInt<UInt<UTerm, B1>>;
14312
14313 #[allow(non_camel_case_types)]
14314 type P1PowN3 = <<A as Pow<B>>::Output as Same<P1>>::Output;
14315
14316 assert_eq!(<P1PowN3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14317 }
14318 #[test]
14319 #[allow(non_snake_case)]
14320 fn test_P1_Cmp_N3() {
14321 type A = PInt<UInt<UTerm, B1>>;
14322 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
14323
14324 #[allow(non_camel_case_types)]
14325 type P1CmpN3 = <A as Cmp<B>>::Output;
14326 assert_eq!(<P1CmpN3 as Ord>::to_ordering(), Ordering::Greater);
14327 }
14328 #[test]
14329 #[allow(non_snake_case)]
14330 fn test_P1_Add_N2() {
14331 type A = PInt<UInt<UTerm, B1>>;
14332 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
14333 type N1 = NInt<UInt<UTerm, B1>>;
14334
14335 #[allow(non_camel_case_types)]
14336 type P1AddN2 = <<A as Add<B>>::Output as Same<N1>>::Output;
14337
14338 assert_eq!(<P1AddN2 as Integer>::to_i64(), <N1 as Integer>::to_i64());
14339 }
14340 #[test]
14341 #[allow(non_snake_case)]
14342 fn test_P1_Sub_N2() {
14343 type A = PInt<UInt<UTerm, B1>>;
14344 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
14345 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
14346
14347 #[allow(non_camel_case_types)]
14348 type P1SubN2 = <<A as Sub<B>>::Output as Same<P3>>::Output;
14349
14350 assert_eq!(<P1SubN2 as Integer>::to_i64(), <P3 as Integer>::to_i64());
14351 }
14352 #[test]
14353 #[allow(non_snake_case)]
14354 fn test_P1_Mul_N2() {
14355 type A = PInt<UInt<UTerm, B1>>;
14356 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
14357 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
14358
14359 #[allow(non_camel_case_types)]
14360 type P1MulN2 = <<A as Mul<B>>::Output as Same<N2>>::Output;
14361
14362 assert_eq!(<P1MulN2 as Integer>::to_i64(), <N2 as Integer>::to_i64());
14363 }
14364 #[test]
14365 #[allow(non_snake_case)]
14366 fn test_P1_Min_N2() {
14367 type A = PInt<UInt<UTerm, B1>>;
14368 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
14369 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
14370
14371 #[allow(non_camel_case_types)]
14372 type P1MinN2 = <<A as Min<B>>::Output as Same<N2>>::Output;
14373
14374 assert_eq!(<P1MinN2 as Integer>::to_i64(), <N2 as Integer>::to_i64());
14375 }
14376 #[test]
14377 #[allow(non_snake_case)]
14378 fn test_P1_Max_N2() {
14379 type A = PInt<UInt<UTerm, B1>>;
14380 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
14381 type P1 = PInt<UInt<UTerm, B1>>;
14382
14383 #[allow(non_camel_case_types)]
14384 type P1MaxN2 = <<A as Max<B>>::Output as Same<P1>>::Output;
14385
14386 assert_eq!(<P1MaxN2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14387 }
14388 #[test]
14389 #[allow(non_snake_case)]
14390 fn test_P1_Gcd_N2() {
14391 type A = PInt<UInt<UTerm, B1>>;
14392 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
14393 type P1 = PInt<UInt<UTerm, B1>>;
14394
14395 #[allow(non_camel_case_types)]
14396 type P1GcdN2 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
14397
14398 assert_eq!(<P1GcdN2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14399 }
14400 #[test]
14401 #[allow(non_snake_case)]
14402 fn test_P1_Div_N2() {
14403 type A = PInt<UInt<UTerm, B1>>;
14404 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
14405 type _0 = Z0;
14406
14407 #[allow(non_camel_case_types)]
14408 type P1DivN2 = <<A as Div<B>>::Output as Same<_0>>::Output;
14409
14410 assert_eq!(<P1DivN2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
14411 }
14412 #[test]
14413 #[allow(non_snake_case)]
14414 fn test_P1_Rem_N2() {
14415 type A = PInt<UInt<UTerm, B1>>;
14416 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
14417 type P1 = PInt<UInt<UTerm, B1>>;
14418
14419 #[allow(non_camel_case_types)]
14420 type P1RemN2 = <<A as Rem<B>>::Output as Same<P1>>::Output;
14421
14422 assert_eq!(<P1RemN2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14423 }
14424 #[test]
14425 #[allow(non_snake_case)]
14426 fn test_P1_Pow_N2() {
14427 type A = PInt<UInt<UTerm, B1>>;
14428 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
14429 type P1 = PInt<UInt<UTerm, B1>>;
14430
14431 #[allow(non_camel_case_types)]
14432 type P1PowN2 = <<A as Pow<B>>::Output as Same<P1>>::Output;
14433
14434 assert_eq!(<P1PowN2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14435 }
14436 #[test]
14437 #[allow(non_snake_case)]
14438 fn test_P1_Cmp_N2() {
14439 type A = PInt<UInt<UTerm, B1>>;
14440 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
14441
14442 #[allow(non_camel_case_types)]
14443 type P1CmpN2 = <A as Cmp<B>>::Output;
14444 assert_eq!(<P1CmpN2 as Ord>::to_ordering(), Ordering::Greater);
14445 }
14446 #[test]
14447 #[allow(non_snake_case)]
14448 fn test_P1_Add_N1() {
14449 type A = PInt<UInt<UTerm, B1>>;
14450 type B = NInt<UInt<UTerm, B1>>;
14451 type _0 = Z0;
14452
14453 #[allow(non_camel_case_types)]
14454 type P1AddN1 = <<A as Add<B>>::Output as Same<_0>>::Output;
14455
14456 assert_eq!(<P1AddN1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
14457 }
14458 #[test]
14459 #[allow(non_snake_case)]
14460 fn test_P1_Sub_N1() {
14461 type A = PInt<UInt<UTerm, B1>>;
14462 type B = NInt<UInt<UTerm, B1>>;
14463 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
14464
14465 #[allow(non_camel_case_types)]
14466 type P1SubN1 = <<A as Sub<B>>::Output as Same<P2>>::Output;
14467
14468 assert_eq!(<P1SubN1 as Integer>::to_i64(), <P2 as Integer>::to_i64());
14469 }
14470 #[test]
14471 #[allow(non_snake_case)]
14472 fn test_P1_Mul_N1() {
14473 type A = PInt<UInt<UTerm, B1>>;
14474 type B = NInt<UInt<UTerm, B1>>;
14475 type N1 = NInt<UInt<UTerm, B1>>;
14476
14477 #[allow(non_camel_case_types)]
14478 type P1MulN1 = <<A as Mul<B>>::Output as Same<N1>>::Output;
14479
14480 assert_eq!(<P1MulN1 as Integer>::to_i64(), <N1 as Integer>::to_i64());
14481 }
14482 #[test]
14483 #[allow(non_snake_case)]
14484 fn test_P1_Min_N1() {
14485 type A = PInt<UInt<UTerm, B1>>;
14486 type B = NInt<UInt<UTerm, B1>>;
14487 type N1 = NInt<UInt<UTerm, B1>>;
14488
14489 #[allow(non_camel_case_types)]
14490 type P1MinN1 = <<A as Min<B>>::Output as Same<N1>>::Output;
14491
14492 assert_eq!(<P1MinN1 as Integer>::to_i64(), <N1 as Integer>::to_i64());
14493 }
14494 #[test]
14495 #[allow(non_snake_case)]
14496 fn test_P1_Max_N1() {
14497 type A = PInt<UInt<UTerm, B1>>;
14498 type B = NInt<UInt<UTerm, B1>>;
14499 type P1 = PInt<UInt<UTerm, B1>>;
14500
14501 #[allow(non_camel_case_types)]
14502 type P1MaxN1 = <<A as Max<B>>::Output as Same<P1>>::Output;
14503
14504 assert_eq!(<P1MaxN1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14505 }
14506 #[test]
14507 #[allow(non_snake_case)]
14508 fn test_P1_Gcd_N1() {
14509 type A = PInt<UInt<UTerm, B1>>;
14510 type B = NInt<UInt<UTerm, B1>>;
14511 type P1 = PInt<UInt<UTerm, B1>>;
14512
14513 #[allow(non_camel_case_types)]
14514 type P1GcdN1 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
14515
14516 assert_eq!(<P1GcdN1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14517 }
14518 #[test]
14519 #[allow(non_snake_case)]
14520 fn test_P1_Div_N1() {
14521 type A = PInt<UInt<UTerm, B1>>;
14522 type B = NInt<UInt<UTerm, B1>>;
14523 type N1 = NInt<UInt<UTerm, B1>>;
14524
14525 #[allow(non_camel_case_types)]
14526 type P1DivN1 = <<A as Div<B>>::Output as Same<N1>>::Output;
14527
14528 assert_eq!(<P1DivN1 as Integer>::to_i64(), <N1 as Integer>::to_i64());
14529 }
14530 #[test]
14531 #[allow(non_snake_case)]
14532 fn test_P1_Rem_N1() {
14533 type A = PInt<UInt<UTerm, B1>>;
14534 type B = NInt<UInt<UTerm, B1>>;
14535 type _0 = Z0;
14536
14537 #[allow(non_camel_case_types)]
14538 type P1RemN1 = <<A as Rem<B>>::Output as Same<_0>>::Output;
14539
14540 assert_eq!(<P1RemN1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
14541 }
14542 #[test]
14543 #[allow(non_snake_case)]
14544 fn test_P1_PartialDiv_N1() {
14545 type A = PInt<UInt<UTerm, B1>>;
14546 type B = NInt<UInt<UTerm, B1>>;
14547 type N1 = NInt<UInt<UTerm, B1>>;
14548
14549 #[allow(non_camel_case_types)]
14550 type P1PartialDivN1 = <<A as PartialDiv<B>>::Output as Same<N1>>::Output;
14551
14552 assert_eq!(<P1PartialDivN1 as Integer>::to_i64(), <N1 as Integer>::to_i64());
14553 }
14554 #[test]
14555 #[allow(non_snake_case)]
14556 fn test_P1_Pow_N1() {
14557 type A = PInt<UInt<UTerm, B1>>;
14558 type B = NInt<UInt<UTerm, B1>>;
14559 type P1 = PInt<UInt<UTerm, B1>>;
14560
14561 #[allow(non_camel_case_types)]
14562 type P1PowN1 = <<A as Pow<B>>::Output as Same<P1>>::Output;
14563
14564 assert_eq!(<P1PowN1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14565 }
14566 #[test]
14567 #[allow(non_snake_case)]
14568 fn test_P1_Cmp_N1() {
14569 type A = PInt<UInt<UTerm, B1>>;
14570 type B = NInt<UInt<UTerm, B1>>;
14571
14572 #[allow(non_camel_case_types)]
14573 type P1CmpN1 = <A as Cmp<B>>::Output;
14574 assert_eq!(<P1CmpN1 as Ord>::to_ordering(), Ordering::Greater);
14575 }
14576 #[test]
14577 #[allow(non_snake_case)]
14578 fn test_P1_Add__0() {
14579 type A = PInt<UInt<UTerm, B1>>;
14580 type B = Z0;
14581 type P1 = PInt<UInt<UTerm, B1>>;
14582
14583 #[allow(non_camel_case_types)]
14584 type P1Add_0 = <<A as Add<B>>::Output as Same<P1>>::Output;
14585
14586 assert_eq!(<P1Add_0 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14587 }
14588 #[test]
14589 #[allow(non_snake_case)]
14590 fn test_P1_Sub__0() {
14591 type A = PInt<UInt<UTerm, B1>>;
14592 type B = Z0;
14593 type P1 = PInt<UInt<UTerm, B1>>;
14594
14595 #[allow(non_camel_case_types)]
14596 type P1Sub_0 = <<A as Sub<B>>::Output as Same<P1>>::Output;
14597
14598 assert_eq!(<P1Sub_0 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14599 }
14600 #[test]
14601 #[allow(non_snake_case)]
14602 fn test_P1_Mul__0() {
14603 type A = PInt<UInt<UTerm, B1>>;
14604 type B = Z0;
14605 type _0 = Z0;
14606
14607 #[allow(non_camel_case_types)]
14608 type P1Mul_0 = <<A as Mul<B>>::Output as Same<_0>>::Output;
14609
14610 assert_eq!(<P1Mul_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
14611 }
14612 #[test]
14613 #[allow(non_snake_case)]
14614 fn test_P1_Min__0() {
14615 type A = PInt<UInt<UTerm, B1>>;
14616 type B = Z0;
14617 type _0 = Z0;
14618
14619 #[allow(non_camel_case_types)]
14620 type P1Min_0 = <<A as Min<B>>::Output as Same<_0>>::Output;
14621
14622 assert_eq!(<P1Min_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
14623 }
14624 #[test]
14625 #[allow(non_snake_case)]
14626 fn test_P1_Max__0() {
14627 type A = PInt<UInt<UTerm, B1>>;
14628 type B = Z0;
14629 type P1 = PInt<UInt<UTerm, B1>>;
14630
14631 #[allow(non_camel_case_types)]
14632 type P1Max_0 = <<A as Max<B>>::Output as Same<P1>>::Output;
14633
14634 assert_eq!(<P1Max_0 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14635 }
14636 #[test]
14637 #[allow(non_snake_case)]
14638 fn test_P1_Gcd__0() {
14639 type A = PInt<UInt<UTerm, B1>>;
14640 type B = Z0;
14641 type P1 = PInt<UInt<UTerm, B1>>;
14642
14643 #[allow(non_camel_case_types)]
14644 type P1Gcd_0 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
14645
14646 assert_eq!(<P1Gcd_0 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14647 }
14648 #[test]
14649 #[allow(non_snake_case)]
14650 fn test_P1_Pow__0() {
14651 type A = PInt<UInt<UTerm, B1>>;
14652 type B = Z0;
14653 type P1 = PInt<UInt<UTerm, B1>>;
14654
14655 #[allow(non_camel_case_types)]
14656 type P1Pow_0 = <<A as Pow<B>>::Output as Same<P1>>::Output;
14657
14658 assert_eq!(<P1Pow_0 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14659 }
14660 #[test]
14661 #[allow(non_snake_case)]
14662 fn test_P1_Cmp__0() {
14663 type A = PInt<UInt<UTerm, B1>>;
14664 type B = Z0;
14665
14666 #[allow(non_camel_case_types)]
14667 type P1Cmp_0 = <A as Cmp<B>>::Output;
14668 assert_eq!(<P1Cmp_0 as Ord>::to_ordering(), Ordering::Greater);
14669 }
14670 #[test]
14671 #[allow(non_snake_case)]
14672 fn test_P1_Add_P1() {
14673 type A = PInt<UInt<UTerm, B1>>;
14674 type B = PInt<UInt<UTerm, B1>>;
14675 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
14676
14677 #[allow(non_camel_case_types)]
14678 type P1AddP1 = <<A as Add<B>>::Output as Same<P2>>::Output;
14679
14680 assert_eq!(<P1AddP1 as Integer>::to_i64(), <P2 as Integer>::to_i64());
14681 }
14682 #[test]
14683 #[allow(non_snake_case)]
14684 fn test_P1_Sub_P1() {
14685 type A = PInt<UInt<UTerm, B1>>;
14686 type B = PInt<UInt<UTerm, B1>>;
14687 type _0 = Z0;
14688
14689 #[allow(non_camel_case_types)]
14690 type P1SubP1 = <<A as Sub<B>>::Output as Same<_0>>::Output;
14691
14692 assert_eq!(<P1SubP1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
14693 }
14694 #[test]
14695 #[allow(non_snake_case)]
14696 fn test_P1_Mul_P1() {
14697 type A = PInt<UInt<UTerm, B1>>;
14698 type B = PInt<UInt<UTerm, B1>>;
14699 type P1 = PInt<UInt<UTerm, B1>>;
14700
14701 #[allow(non_camel_case_types)]
14702 type P1MulP1 = <<A as Mul<B>>::Output as Same<P1>>::Output;
14703
14704 assert_eq!(<P1MulP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14705 }
14706 #[test]
14707 #[allow(non_snake_case)]
14708 fn test_P1_Min_P1() {
14709 type A = PInt<UInt<UTerm, B1>>;
14710 type B = PInt<UInt<UTerm, B1>>;
14711 type P1 = PInt<UInt<UTerm, B1>>;
14712
14713 #[allow(non_camel_case_types)]
14714 type P1MinP1 = <<A as Min<B>>::Output as Same<P1>>::Output;
14715
14716 assert_eq!(<P1MinP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14717 }
14718 #[test]
14719 #[allow(non_snake_case)]
14720 fn test_P1_Max_P1() {
14721 type A = PInt<UInt<UTerm, B1>>;
14722 type B = PInt<UInt<UTerm, B1>>;
14723 type P1 = PInt<UInt<UTerm, B1>>;
14724
14725 #[allow(non_camel_case_types)]
14726 type P1MaxP1 = <<A as Max<B>>::Output as Same<P1>>::Output;
14727
14728 assert_eq!(<P1MaxP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14729 }
14730 #[test]
14731 #[allow(non_snake_case)]
14732 fn test_P1_Gcd_P1() {
14733 type A = PInt<UInt<UTerm, B1>>;
14734 type B = PInt<UInt<UTerm, B1>>;
14735 type P1 = PInt<UInt<UTerm, B1>>;
14736
14737 #[allow(non_camel_case_types)]
14738 type P1GcdP1 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
14739
14740 assert_eq!(<P1GcdP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14741 }
14742 #[test]
14743 #[allow(non_snake_case)]
14744 fn test_P1_Div_P1() {
14745 type A = PInt<UInt<UTerm, B1>>;
14746 type B = PInt<UInt<UTerm, B1>>;
14747 type P1 = PInt<UInt<UTerm, B1>>;
14748
14749 #[allow(non_camel_case_types)]
14750 type P1DivP1 = <<A as Div<B>>::Output as Same<P1>>::Output;
14751
14752 assert_eq!(<P1DivP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14753 }
14754 #[test]
14755 #[allow(non_snake_case)]
14756 fn test_P1_Rem_P1() {
14757 type A = PInt<UInt<UTerm, B1>>;
14758 type B = PInt<UInt<UTerm, B1>>;
14759 type _0 = Z0;
14760
14761 #[allow(non_camel_case_types)]
14762 type P1RemP1 = <<A as Rem<B>>::Output as Same<_0>>::Output;
14763
14764 assert_eq!(<P1RemP1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
14765 }
14766 #[test]
14767 #[allow(non_snake_case)]
14768 fn test_P1_PartialDiv_P1() {
14769 type A = PInt<UInt<UTerm, B1>>;
14770 type B = PInt<UInt<UTerm, B1>>;
14771 type P1 = PInt<UInt<UTerm, B1>>;
14772
14773 #[allow(non_camel_case_types)]
14774 type P1PartialDivP1 = <<A as PartialDiv<B>>::Output as Same<P1>>::Output;
14775
14776 assert_eq!(<P1PartialDivP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14777 }
14778 #[test]
14779 #[allow(non_snake_case)]
14780 fn test_P1_Pow_P1() {
14781 type A = PInt<UInt<UTerm, B1>>;
14782 type B = PInt<UInt<UTerm, B1>>;
14783 type P1 = PInt<UInt<UTerm, B1>>;
14784
14785 #[allow(non_camel_case_types)]
14786 type P1PowP1 = <<A as Pow<B>>::Output as Same<P1>>::Output;
14787
14788 assert_eq!(<P1PowP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14789 }
14790 #[test]
14791 #[allow(non_snake_case)]
14792 fn test_P1_Cmp_P1() {
14793 type A = PInt<UInt<UTerm, B1>>;
14794 type B = PInt<UInt<UTerm, B1>>;
14795
14796 #[allow(non_camel_case_types)]
14797 type P1CmpP1 = <A as Cmp<B>>::Output;
14798 assert_eq!(<P1CmpP1 as Ord>::to_ordering(), Ordering::Equal);
14799 }
14800 #[test]
14801 #[allow(non_snake_case)]
14802 fn test_P1_Add_P2() {
14803 type A = PInt<UInt<UTerm, B1>>;
14804 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
14805 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
14806
14807 #[allow(non_camel_case_types)]
14808 type P1AddP2 = <<A as Add<B>>::Output as Same<P3>>::Output;
14809
14810 assert_eq!(<P1AddP2 as Integer>::to_i64(), <P3 as Integer>::to_i64());
14811 }
14812 #[test]
14813 #[allow(non_snake_case)]
14814 fn test_P1_Sub_P2() {
14815 type A = PInt<UInt<UTerm, B1>>;
14816 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
14817 type N1 = NInt<UInt<UTerm, B1>>;
14818
14819 #[allow(non_camel_case_types)]
14820 type P1SubP2 = <<A as Sub<B>>::Output as Same<N1>>::Output;
14821
14822 assert_eq!(<P1SubP2 as Integer>::to_i64(), <N1 as Integer>::to_i64());
14823 }
14824 #[test]
14825 #[allow(non_snake_case)]
14826 fn test_P1_Mul_P2() {
14827 type A = PInt<UInt<UTerm, B1>>;
14828 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
14829 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
14830
14831 #[allow(non_camel_case_types)]
14832 type P1MulP2 = <<A as Mul<B>>::Output as Same<P2>>::Output;
14833
14834 assert_eq!(<P1MulP2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
14835 }
14836 #[test]
14837 #[allow(non_snake_case)]
14838 fn test_P1_Min_P2() {
14839 type A = PInt<UInt<UTerm, B1>>;
14840 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
14841 type P1 = PInt<UInt<UTerm, B1>>;
14842
14843 #[allow(non_camel_case_types)]
14844 type P1MinP2 = <<A as Min<B>>::Output as Same<P1>>::Output;
14845
14846 assert_eq!(<P1MinP2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14847 }
14848 #[test]
14849 #[allow(non_snake_case)]
14850 fn test_P1_Max_P2() {
14851 type A = PInt<UInt<UTerm, B1>>;
14852 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
14853 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
14854
14855 #[allow(non_camel_case_types)]
14856 type P1MaxP2 = <<A as Max<B>>::Output as Same<P2>>::Output;
14857
14858 assert_eq!(<P1MaxP2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
14859 }
14860 #[test]
14861 #[allow(non_snake_case)]
14862 fn test_P1_Gcd_P2() {
14863 type A = PInt<UInt<UTerm, B1>>;
14864 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
14865 type P1 = PInt<UInt<UTerm, B1>>;
14866
14867 #[allow(non_camel_case_types)]
14868 type P1GcdP2 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
14869
14870 assert_eq!(<P1GcdP2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14871 }
14872 #[test]
14873 #[allow(non_snake_case)]
14874 fn test_P1_Div_P2() {
14875 type A = PInt<UInt<UTerm, B1>>;
14876 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
14877 type _0 = Z0;
14878
14879 #[allow(non_camel_case_types)]
14880 type P1DivP2 = <<A as Div<B>>::Output as Same<_0>>::Output;
14881
14882 assert_eq!(<P1DivP2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
14883 }
14884 #[test]
14885 #[allow(non_snake_case)]
14886 fn test_P1_Rem_P2() {
14887 type A = PInt<UInt<UTerm, B1>>;
14888 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
14889 type P1 = PInt<UInt<UTerm, B1>>;
14890
14891 #[allow(non_camel_case_types)]
14892 type P1RemP2 = <<A as Rem<B>>::Output as Same<P1>>::Output;
14893
14894 assert_eq!(<P1RemP2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14895 }
14896 #[test]
14897 #[allow(non_snake_case)]
14898 fn test_P1_Pow_P2() {
14899 type A = PInt<UInt<UTerm, B1>>;
14900 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
14901 type P1 = PInt<UInt<UTerm, B1>>;
14902
14903 #[allow(non_camel_case_types)]
14904 type P1PowP2 = <<A as Pow<B>>::Output as Same<P1>>::Output;
14905
14906 assert_eq!(<P1PowP2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14907 }
14908 #[test]
14909 #[allow(non_snake_case)]
14910 fn test_P1_Cmp_P2() {
14911 type A = PInt<UInt<UTerm, B1>>;
14912 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
14913
14914 #[allow(non_camel_case_types)]
14915 type P1CmpP2 = <A as Cmp<B>>::Output;
14916 assert_eq!(<P1CmpP2 as Ord>::to_ordering(), Ordering::Less);
14917 }
14918 #[test]
14919 #[allow(non_snake_case)]
14920 fn test_P1_Add_P3() {
14921 type A = PInt<UInt<UTerm, B1>>;
14922 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
14923 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
14924
14925 #[allow(non_camel_case_types)]
14926 type P1AddP3 = <<A as Add<B>>::Output as Same<P4>>::Output;
14927
14928 assert_eq!(<P1AddP3 as Integer>::to_i64(), <P4 as Integer>::to_i64());
14929 }
14930 #[test]
14931 #[allow(non_snake_case)]
14932 fn test_P1_Sub_P3() {
14933 type A = PInt<UInt<UTerm, B1>>;
14934 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
14935 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
14936
14937 #[allow(non_camel_case_types)]
14938 type P1SubP3 = <<A as Sub<B>>::Output as Same<N2>>::Output;
14939
14940 assert_eq!(<P1SubP3 as Integer>::to_i64(), <N2 as Integer>::to_i64());
14941 }
14942 #[test]
14943 #[allow(non_snake_case)]
14944 fn test_P1_Mul_P3() {
14945 type A = PInt<UInt<UTerm, B1>>;
14946 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
14947 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
14948
14949 #[allow(non_camel_case_types)]
14950 type P1MulP3 = <<A as Mul<B>>::Output as Same<P3>>::Output;
14951
14952 assert_eq!(<P1MulP3 as Integer>::to_i64(), <P3 as Integer>::to_i64());
14953 }
14954 #[test]
14955 #[allow(non_snake_case)]
14956 fn test_P1_Min_P3() {
14957 type A = PInt<UInt<UTerm, B1>>;
14958 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
14959 type P1 = PInt<UInt<UTerm, B1>>;
14960
14961 #[allow(non_camel_case_types)]
14962 type P1MinP3 = <<A as Min<B>>::Output as Same<P1>>::Output;
14963
14964 assert_eq!(<P1MinP3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14965 }
14966 #[test]
14967 #[allow(non_snake_case)]
14968 fn test_P1_Max_P3() {
14969 type A = PInt<UInt<UTerm, B1>>;
14970 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
14971 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
14972
14973 #[allow(non_camel_case_types)]
14974 type P1MaxP3 = <<A as Max<B>>::Output as Same<P3>>::Output;
14975
14976 assert_eq!(<P1MaxP3 as Integer>::to_i64(), <P3 as Integer>::to_i64());
14977 }
14978 #[test]
14979 #[allow(non_snake_case)]
14980 fn test_P1_Gcd_P3() {
14981 type A = PInt<UInt<UTerm, B1>>;
14982 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
14983 type P1 = PInt<UInt<UTerm, B1>>;
14984
14985 #[allow(non_camel_case_types)]
14986 type P1GcdP3 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
14987
14988 assert_eq!(<P1GcdP3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
14989 }
14990 #[test]
14991 #[allow(non_snake_case)]
14992 fn test_P1_Div_P3() {
14993 type A = PInt<UInt<UTerm, B1>>;
14994 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
14995 type _0 = Z0;
14996
14997 #[allow(non_camel_case_types)]
14998 type P1DivP3 = <<A as Div<B>>::Output as Same<_0>>::Output;
14999
15000 assert_eq!(<P1DivP3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
15001 }
15002 #[test]
15003 #[allow(non_snake_case)]
15004 fn test_P1_Rem_P3() {
15005 type A = PInt<UInt<UTerm, B1>>;
15006 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
15007 type P1 = PInt<UInt<UTerm, B1>>;
15008
15009 #[allow(non_camel_case_types)]
15010 type P1RemP3 = <<A as Rem<B>>::Output as Same<P1>>::Output;
15011
15012 assert_eq!(<P1RemP3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
15013 }
15014 #[test]
15015 #[allow(non_snake_case)]
15016 fn test_P1_Pow_P3() {
15017 type A = PInt<UInt<UTerm, B1>>;
15018 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
15019 type P1 = PInt<UInt<UTerm, B1>>;
15020
15021 #[allow(non_camel_case_types)]
15022 type P1PowP3 = <<A as Pow<B>>::Output as Same<P1>>::Output;
15023
15024 assert_eq!(<P1PowP3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
15025 }
15026 #[test]
15027 #[allow(non_snake_case)]
15028 fn test_P1_Cmp_P3() {
15029 type A = PInt<UInt<UTerm, B1>>;
15030 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
15031
15032 #[allow(non_camel_case_types)]
15033 type P1CmpP3 = <A as Cmp<B>>::Output;
15034 assert_eq!(<P1CmpP3 as Ord>::to_ordering(), Ordering::Less);
15035 }
15036 #[test]
15037 #[allow(non_snake_case)]
15038 fn test_P1_Add_P4() {
15039 type A = PInt<UInt<UTerm, B1>>;
15040 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
15041 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
15042
15043 #[allow(non_camel_case_types)]
15044 type P1AddP4 = <<A as Add<B>>::Output as Same<P5>>::Output;
15045
15046 assert_eq!(<P1AddP4 as Integer>::to_i64(), <P5 as Integer>::to_i64());
15047 }
15048 #[test]
15049 #[allow(non_snake_case)]
15050 fn test_P1_Sub_P4() {
15051 type A = PInt<UInt<UTerm, B1>>;
15052 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
15053 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
15054
15055 #[allow(non_camel_case_types)]
15056 type P1SubP4 = <<A as Sub<B>>::Output as Same<N3>>::Output;
15057
15058 assert_eq!(<P1SubP4 as Integer>::to_i64(), <N3 as Integer>::to_i64());
15059 }
15060 #[test]
15061 #[allow(non_snake_case)]
15062 fn test_P1_Mul_P4() {
15063 type A = PInt<UInt<UTerm, B1>>;
15064 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
15065 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
15066
15067 #[allow(non_camel_case_types)]
15068 type P1MulP4 = <<A as Mul<B>>::Output as Same<P4>>::Output;
15069
15070 assert_eq!(<P1MulP4 as Integer>::to_i64(), <P4 as Integer>::to_i64());
15071 }
15072 #[test]
15073 #[allow(non_snake_case)]
15074 fn test_P1_Min_P4() {
15075 type A = PInt<UInt<UTerm, B1>>;
15076 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
15077 type P1 = PInt<UInt<UTerm, B1>>;
15078
15079 #[allow(non_camel_case_types)]
15080 type P1MinP4 = <<A as Min<B>>::Output as Same<P1>>::Output;
15081
15082 assert_eq!(<P1MinP4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
15083 }
15084 #[test]
15085 #[allow(non_snake_case)]
15086 fn test_P1_Max_P4() {
15087 type A = PInt<UInt<UTerm, B1>>;
15088 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
15089 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
15090
15091 #[allow(non_camel_case_types)]
15092 type P1MaxP4 = <<A as Max<B>>::Output as Same<P4>>::Output;
15093
15094 assert_eq!(<P1MaxP4 as Integer>::to_i64(), <P4 as Integer>::to_i64());
15095 }
15096 #[test]
15097 #[allow(non_snake_case)]
15098 fn test_P1_Gcd_P4() {
15099 type A = PInt<UInt<UTerm, B1>>;
15100 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
15101 type P1 = PInt<UInt<UTerm, B1>>;
15102
15103 #[allow(non_camel_case_types)]
15104 type P1GcdP4 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
15105
15106 assert_eq!(<P1GcdP4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
15107 }
15108 #[test]
15109 #[allow(non_snake_case)]
15110 fn test_P1_Div_P4() {
15111 type A = PInt<UInt<UTerm, B1>>;
15112 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
15113 type _0 = Z0;
15114
15115 #[allow(non_camel_case_types)]
15116 type P1DivP4 = <<A as Div<B>>::Output as Same<_0>>::Output;
15117
15118 assert_eq!(<P1DivP4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
15119 }
15120 #[test]
15121 #[allow(non_snake_case)]
15122 fn test_P1_Rem_P4() {
15123 type A = PInt<UInt<UTerm, B1>>;
15124 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
15125 type P1 = PInt<UInt<UTerm, B1>>;
15126
15127 #[allow(non_camel_case_types)]
15128 type P1RemP4 = <<A as Rem<B>>::Output as Same<P1>>::Output;
15129
15130 assert_eq!(<P1RemP4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
15131 }
15132 #[test]
15133 #[allow(non_snake_case)]
15134 fn test_P1_Pow_P4() {
15135 type A = PInt<UInt<UTerm, B1>>;
15136 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
15137 type P1 = PInt<UInt<UTerm, B1>>;
15138
15139 #[allow(non_camel_case_types)]
15140 type P1PowP4 = <<A as Pow<B>>::Output as Same<P1>>::Output;
15141
15142 assert_eq!(<P1PowP4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
15143 }
15144 #[test]
15145 #[allow(non_snake_case)]
15146 fn test_P1_Cmp_P4() {
15147 type A = PInt<UInt<UTerm, B1>>;
15148 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
15149
15150 #[allow(non_camel_case_types)]
15151 type P1CmpP4 = <A as Cmp<B>>::Output;
15152 assert_eq!(<P1CmpP4 as Ord>::to_ordering(), Ordering::Less);
15153 }
15154 #[test]
15155 #[allow(non_snake_case)]
15156 fn test_P1_Add_P5() {
15157 type A = PInt<UInt<UTerm, B1>>;
15158 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
15159 type P6 = PInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
15160
15161 #[allow(non_camel_case_types)]
15162 type P1AddP5 = <<A as Add<B>>::Output as Same<P6>>::Output;
15163
15164 assert_eq!(<P1AddP5 as Integer>::to_i64(), <P6 as Integer>::to_i64());
15165 }
15166 #[test]
15167 #[allow(non_snake_case)]
15168 fn test_P1_Sub_P5() {
15169 type A = PInt<UInt<UTerm, B1>>;
15170 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
15171 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
15172
15173 #[allow(non_camel_case_types)]
15174 type P1SubP5 = <<A as Sub<B>>::Output as Same<N4>>::Output;
15175
15176 assert_eq!(<P1SubP5 as Integer>::to_i64(), <N4 as Integer>::to_i64());
15177 }
15178 #[test]
15179 #[allow(non_snake_case)]
15180 fn test_P1_Mul_P5() {
15181 type A = PInt<UInt<UTerm, B1>>;
15182 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
15183 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
15184
15185 #[allow(non_camel_case_types)]
15186 type P1MulP5 = <<A as Mul<B>>::Output as Same<P5>>::Output;
15187
15188 assert_eq!(<P1MulP5 as Integer>::to_i64(), <P5 as Integer>::to_i64());
15189 }
15190 #[test]
15191 #[allow(non_snake_case)]
15192 fn test_P1_Min_P5() {
15193 type A = PInt<UInt<UTerm, B1>>;
15194 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
15195 type P1 = PInt<UInt<UTerm, B1>>;
15196
15197 #[allow(non_camel_case_types)]
15198 type P1MinP5 = <<A as Min<B>>::Output as Same<P1>>::Output;
15199
15200 assert_eq!(<P1MinP5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
15201 }
15202 #[test]
15203 #[allow(non_snake_case)]
15204 fn test_P1_Max_P5() {
15205 type A = PInt<UInt<UTerm, B1>>;
15206 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
15207 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
15208
15209 #[allow(non_camel_case_types)]
15210 type P1MaxP5 = <<A as Max<B>>::Output as Same<P5>>::Output;
15211
15212 assert_eq!(<P1MaxP5 as Integer>::to_i64(), <P5 as Integer>::to_i64());
15213 }
15214 #[test]
15215 #[allow(non_snake_case)]
15216 fn test_P1_Gcd_P5() {
15217 type A = PInt<UInt<UTerm, B1>>;
15218 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
15219 type P1 = PInt<UInt<UTerm, B1>>;
15220
15221 #[allow(non_camel_case_types)]
15222 type P1GcdP5 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
15223
15224 assert_eq!(<P1GcdP5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
15225 }
15226 #[test]
15227 #[allow(non_snake_case)]
15228 fn test_P1_Div_P5() {
15229 type A = PInt<UInt<UTerm, B1>>;
15230 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
15231 type _0 = Z0;
15232
15233 #[allow(non_camel_case_types)]
15234 type P1DivP5 = <<A as Div<B>>::Output as Same<_0>>::Output;
15235
15236 assert_eq!(<P1DivP5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
15237 }
15238 #[test]
15239 #[allow(non_snake_case)]
15240 fn test_P1_Rem_P5() {
15241 type A = PInt<UInt<UTerm, B1>>;
15242 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
15243 type P1 = PInt<UInt<UTerm, B1>>;
15244
15245 #[allow(non_camel_case_types)]
15246 type P1RemP5 = <<A as Rem<B>>::Output as Same<P1>>::Output;
15247
15248 assert_eq!(<P1RemP5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
15249 }
15250 #[test]
15251 #[allow(non_snake_case)]
15252 fn test_P1_Pow_P5() {
15253 type A = PInt<UInt<UTerm, B1>>;
15254 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
15255 type P1 = PInt<UInt<UTerm, B1>>;
15256
15257 #[allow(non_camel_case_types)]
15258 type P1PowP5 = <<A as Pow<B>>::Output as Same<P1>>::Output;
15259
15260 assert_eq!(<P1PowP5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
15261 }
15262 #[test]
15263 #[allow(non_snake_case)]
15264 fn test_P1_Cmp_P5() {
15265 type A = PInt<UInt<UTerm, B1>>;
15266 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
15267
15268 #[allow(non_camel_case_types)]
15269 type P1CmpP5 = <A as Cmp<B>>::Output;
15270 assert_eq!(<P1CmpP5 as Ord>::to_ordering(), Ordering::Less);
15271 }
15272 #[test]
15273 #[allow(non_snake_case)]
15274 fn test_P2_Add_N5() {
15275 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15276 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
15277 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
15278
15279 #[allow(non_camel_case_types)]
15280 type P2AddN5 = <<A as Add<B>>::Output as Same<N3>>::Output;
15281
15282 assert_eq!(<P2AddN5 as Integer>::to_i64(), <N3 as Integer>::to_i64());
15283 }
15284 #[test]
15285 #[allow(non_snake_case)]
15286 fn test_P2_Sub_N5() {
15287 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15288 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
15289 type P7 = PInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>>;
15290
15291 #[allow(non_camel_case_types)]
15292 type P2SubN5 = <<A as Sub<B>>::Output as Same<P7>>::Output;
15293
15294 assert_eq!(<P2SubN5 as Integer>::to_i64(), <P7 as Integer>::to_i64());
15295 }
15296 #[test]
15297 #[allow(non_snake_case)]
15298 fn test_P2_Mul_N5() {
15299 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15300 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
15301 type N10 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>;
15302
15303 #[allow(non_camel_case_types)]
15304 type P2MulN5 = <<A as Mul<B>>::Output as Same<N10>>::Output;
15305
15306 assert_eq!(<P2MulN5 as Integer>::to_i64(), <N10 as Integer>::to_i64());
15307 }
15308 #[test]
15309 #[allow(non_snake_case)]
15310 fn test_P2_Min_N5() {
15311 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15312 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
15313 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
15314
15315 #[allow(non_camel_case_types)]
15316 type P2MinN5 = <<A as Min<B>>::Output as Same<N5>>::Output;
15317
15318 assert_eq!(<P2MinN5 as Integer>::to_i64(), <N5 as Integer>::to_i64());
15319 }
15320 #[test]
15321 #[allow(non_snake_case)]
15322 fn test_P2_Max_N5() {
15323 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15324 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
15325 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
15326
15327 #[allow(non_camel_case_types)]
15328 type P2MaxN5 = <<A as Max<B>>::Output as Same<P2>>::Output;
15329
15330 assert_eq!(<P2MaxN5 as Integer>::to_i64(), <P2 as Integer>::to_i64());
15331 }
15332 #[test]
15333 #[allow(non_snake_case)]
15334 fn test_P2_Gcd_N5() {
15335 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15336 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
15337 type P1 = PInt<UInt<UTerm, B1>>;
15338
15339 #[allow(non_camel_case_types)]
15340 type P2GcdN5 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
15341
15342 assert_eq!(<P2GcdN5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
15343 }
15344 #[test]
15345 #[allow(non_snake_case)]
15346 fn test_P2_Div_N5() {
15347 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15348 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
15349 type _0 = Z0;
15350
15351 #[allow(non_camel_case_types)]
15352 type P2DivN5 = <<A as Div<B>>::Output as Same<_0>>::Output;
15353
15354 assert_eq!(<P2DivN5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
15355 }
15356 #[test]
15357 #[allow(non_snake_case)]
15358 fn test_P2_Rem_N5() {
15359 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15360 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
15361 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
15362
15363 #[allow(non_camel_case_types)]
15364 type P2RemN5 = <<A as Rem<B>>::Output as Same<P2>>::Output;
15365
15366 assert_eq!(<P2RemN5 as Integer>::to_i64(), <P2 as Integer>::to_i64());
15367 }
15368 #[test]
15369 #[allow(non_snake_case)]
15370 fn test_P2_Cmp_N5() {
15371 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15372 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
15373
15374 #[allow(non_camel_case_types)]
15375 type P2CmpN5 = <A as Cmp<B>>::Output;
15376 assert_eq!(<P2CmpN5 as Ord>::to_ordering(), Ordering::Greater);
15377 }
15378 #[test]
15379 #[allow(non_snake_case)]
15380 fn test_P2_Add_N4() {
15381 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15382 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
15383 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
15384
15385 #[allow(non_camel_case_types)]
15386 type P2AddN4 = <<A as Add<B>>::Output as Same<N2>>::Output;
15387
15388 assert_eq!(<P2AddN4 as Integer>::to_i64(), <N2 as Integer>::to_i64());
15389 }
15390 #[test]
15391 #[allow(non_snake_case)]
15392 fn test_P2_Sub_N4() {
15393 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15394 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
15395 type P6 = PInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
15396
15397 #[allow(non_camel_case_types)]
15398 type P2SubN4 = <<A as Sub<B>>::Output as Same<P6>>::Output;
15399
15400 assert_eq!(<P2SubN4 as Integer>::to_i64(), <P6 as Integer>::to_i64());
15401 }
15402 #[test]
15403 #[allow(non_snake_case)]
15404 fn test_P2_Mul_N4() {
15405 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15406 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
15407 type N8 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>;
15408
15409 #[allow(non_camel_case_types)]
15410 type P2MulN4 = <<A as Mul<B>>::Output as Same<N8>>::Output;
15411
15412 assert_eq!(<P2MulN4 as Integer>::to_i64(), <N8 as Integer>::to_i64());
15413 }
15414 #[test]
15415 #[allow(non_snake_case)]
15416 fn test_P2_Min_N4() {
15417 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15418 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
15419 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
15420
15421 #[allow(non_camel_case_types)]
15422 type P2MinN4 = <<A as Min<B>>::Output as Same<N4>>::Output;
15423
15424 assert_eq!(<P2MinN4 as Integer>::to_i64(), <N4 as Integer>::to_i64());
15425 }
15426 #[test]
15427 #[allow(non_snake_case)]
15428 fn test_P2_Max_N4() {
15429 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15430 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
15431 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
15432
15433 #[allow(non_camel_case_types)]
15434 type P2MaxN4 = <<A as Max<B>>::Output as Same<P2>>::Output;
15435
15436 assert_eq!(<P2MaxN4 as Integer>::to_i64(), <P2 as Integer>::to_i64());
15437 }
15438 #[test]
15439 #[allow(non_snake_case)]
15440 fn test_P2_Gcd_N4() {
15441 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15442 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
15443 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
15444
15445 #[allow(non_camel_case_types)]
15446 type P2GcdN4 = <<A as Gcd<B>>::Output as Same<P2>>::Output;
15447
15448 assert_eq!(<P2GcdN4 as Integer>::to_i64(), <P2 as Integer>::to_i64());
15449 }
15450 #[test]
15451 #[allow(non_snake_case)]
15452 fn test_P2_Div_N4() {
15453 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15454 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
15455 type _0 = Z0;
15456
15457 #[allow(non_camel_case_types)]
15458 type P2DivN4 = <<A as Div<B>>::Output as Same<_0>>::Output;
15459
15460 assert_eq!(<P2DivN4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
15461 }
15462 #[test]
15463 #[allow(non_snake_case)]
15464 fn test_P2_Rem_N4() {
15465 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15466 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
15467 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
15468
15469 #[allow(non_camel_case_types)]
15470 type P2RemN4 = <<A as Rem<B>>::Output as Same<P2>>::Output;
15471
15472 assert_eq!(<P2RemN4 as Integer>::to_i64(), <P2 as Integer>::to_i64());
15473 }
15474 #[test]
15475 #[allow(non_snake_case)]
15476 fn test_P2_Cmp_N4() {
15477 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15478 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
15479
15480 #[allow(non_camel_case_types)]
15481 type P2CmpN4 = <A as Cmp<B>>::Output;
15482 assert_eq!(<P2CmpN4 as Ord>::to_ordering(), Ordering::Greater);
15483 }
15484 #[test]
15485 #[allow(non_snake_case)]
15486 fn test_P2_Add_N3() {
15487 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15488 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
15489 type N1 = NInt<UInt<UTerm, B1>>;
15490
15491 #[allow(non_camel_case_types)]
15492 type P2AddN3 = <<A as Add<B>>::Output as Same<N1>>::Output;
15493
15494 assert_eq!(<P2AddN3 as Integer>::to_i64(), <N1 as Integer>::to_i64());
15495 }
15496 #[test]
15497 #[allow(non_snake_case)]
15498 fn test_P2_Sub_N3() {
15499 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15500 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
15501 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
15502
15503 #[allow(non_camel_case_types)]
15504 type P2SubN3 = <<A as Sub<B>>::Output as Same<P5>>::Output;
15505
15506 assert_eq!(<P2SubN3 as Integer>::to_i64(), <P5 as Integer>::to_i64());
15507 }
15508 #[test]
15509 #[allow(non_snake_case)]
15510 fn test_P2_Mul_N3() {
15511 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15512 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
15513 type N6 = NInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
15514
15515 #[allow(non_camel_case_types)]
15516 type P2MulN3 = <<A as Mul<B>>::Output as Same<N6>>::Output;
15517
15518 assert_eq!(<P2MulN3 as Integer>::to_i64(), <N6 as Integer>::to_i64());
15519 }
15520 #[test]
15521 #[allow(non_snake_case)]
15522 fn test_P2_Min_N3() {
15523 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15524 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
15525 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
15526
15527 #[allow(non_camel_case_types)]
15528 type P2MinN3 = <<A as Min<B>>::Output as Same<N3>>::Output;
15529
15530 assert_eq!(<P2MinN3 as Integer>::to_i64(), <N3 as Integer>::to_i64());
15531 }
15532 #[test]
15533 #[allow(non_snake_case)]
15534 fn test_P2_Max_N3() {
15535 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15536 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
15537 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
15538
15539 #[allow(non_camel_case_types)]
15540 type P2MaxN3 = <<A as Max<B>>::Output as Same<P2>>::Output;
15541
15542 assert_eq!(<P2MaxN3 as Integer>::to_i64(), <P2 as Integer>::to_i64());
15543 }
15544 #[test]
15545 #[allow(non_snake_case)]
15546 fn test_P2_Gcd_N3() {
15547 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15548 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
15549 type P1 = PInt<UInt<UTerm, B1>>;
15550
15551 #[allow(non_camel_case_types)]
15552 type P2GcdN3 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
15553
15554 assert_eq!(<P2GcdN3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
15555 }
15556 #[test]
15557 #[allow(non_snake_case)]
15558 fn test_P2_Div_N3() {
15559 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15560 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
15561 type _0 = Z0;
15562
15563 #[allow(non_camel_case_types)]
15564 type P2DivN3 = <<A as Div<B>>::Output as Same<_0>>::Output;
15565
15566 assert_eq!(<P2DivN3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
15567 }
15568 #[test]
15569 #[allow(non_snake_case)]
15570 fn test_P2_Rem_N3() {
15571 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15572 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
15573 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
15574
15575 #[allow(non_camel_case_types)]
15576 type P2RemN3 = <<A as Rem<B>>::Output as Same<P2>>::Output;
15577
15578 assert_eq!(<P2RemN3 as Integer>::to_i64(), <P2 as Integer>::to_i64());
15579 }
15580 #[test]
15581 #[allow(non_snake_case)]
15582 fn test_P2_Cmp_N3() {
15583 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15584 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
15585
15586 #[allow(non_camel_case_types)]
15587 type P2CmpN3 = <A as Cmp<B>>::Output;
15588 assert_eq!(<P2CmpN3 as Ord>::to_ordering(), Ordering::Greater);
15589 }
15590 #[test]
15591 #[allow(non_snake_case)]
15592 fn test_P2_Add_N2() {
15593 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15594 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
15595 type _0 = Z0;
15596
15597 #[allow(non_camel_case_types)]
15598 type P2AddN2 = <<A as Add<B>>::Output as Same<_0>>::Output;
15599
15600 assert_eq!(<P2AddN2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
15601 }
15602 #[test]
15603 #[allow(non_snake_case)]
15604 fn test_P2_Sub_N2() {
15605 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15606 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
15607 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
15608
15609 #[allow(non_camel_case_types)]
15610 type P2SubN2 = <<A as Sub<B>>::Output as Same<P4>>::Output;
15611
15612 assert_eq!(<P2SubN2 as Integer>::to_i64(), <P4 as Integer>::to_i64());
15613 }
15614 #[test]
15615 #[allow(non_snake_case)]
15616 fn test_P2_Mul_N2() {
15617 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15618 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
15619 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
15620
15621 #[allow(non_camel_case_types)]
15622 type P2MulN2 = <<A as Mul<B>>::Output as Same<N4>>::Output;
15623
15624 assert_eq!(<P2MulN2 as Integer>::to_i64(), <N4 as Integer>::to_i64());
15625 }
15626 #[test]
15627 #[allow(non_snake_case)]
15628 fn test_P2_Min_N2() {
15629 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15630 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
15631 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
15632
15633 #[allow(non_camel_case_types)]
15634 type P2MinN2 = <<A as Min<B>>::Output as Same<N2>>::Output;
15635
15636 assert_eq!(<P2MinN2 as Integer>::to_i64(), <N2 as Integer>::to_i64());
15637 }
15638 #[test]
15639 #[allow(non_snake_case)]
15640 fn test_P2_Max_N2() {
15641 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15642 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
15643 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
15644
15645 #[allow(non_camel_case_types)]
15646 type P2MaxN2 = <<A as Max<B>>::Output as Same<P2>>::Output;
15647
15648 assert_eq!(<P2MaxN2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
15649 }
15650 #[test]
15651 #[allow(non_snake_case)]
15652 fn test_P2_Gcd_N2() {
15653 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15654 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
15655 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
15656
15657 #[allow(non_camel_case_types)]
15658 type P2GcdN2 = <<A as Gcd<B>>::Output as Same<P2>>::Output;
15659
15660 assert_eq!(<P2GcdN2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
15661 }
15662 #[test]
15663 #[allow(non_snake_case)]
15664 fn test_P2_Div_N2() {
15665 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15666 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
15667 type N1 = NInt<UInt<UTerm, B1>>;
15668
15669 #[allow(non_camel_case_types)]
15670 type P2DivN2 = <<A as Div<B>>::Output as Same<N1>>::Output;
15671
15672 assert_eq!(<P2DivN2 as Integer>::to_i64(), <N1 as Integer>::to_i64());
15673 }
15674 #[test]
15675 #[allow(non_snake_case)]
15676 fn test_P2_Rem_N2() {
15677 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15678 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
15679 type _0 = Z0;
15680
15681 #[allow(non_camel_case_types)]
15682 type P2RemN2 = <<A as Rem<B>>::Output as Same<_0>>::Output;
15683
15684 assert_eq!(<P2RemN2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
15685 }
15686 #[test]
15687 #[allow(non_snake_case)]
15688 fn test_P2_PartialDiv_N2() {
15689 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15690 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
15691 type N1 = NInt<UInt<UTerm, B1>>;
15692
15693 #[allow(non_camel_case_types)]
15694 type P2PartialDivN2 = <<A as PartialDiv<B>>::Output as Same<N1>>::Output;
15695
15696 assert_eq!(<P2PartialDivN2 as Integer>::to_i64(), <N1 as Integer>::to_i64());
15697 }
15698 #[test]
15699 #[allow(non_snake_case)]
15700 fn test_P2_Cmp_N2() {
15701 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15702 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
15703
15704 #[allow(non_camel_case_types)]
15705 type P2CmpN2 = <A as Cmp<B>>::Output;
15706 assert_eq!(<P2CmpN2 as Ord>::to_ordering(), Ordering::Greater);
15707 }
15708 #[test]
15709 #[allow(non_snake_case)]
15710 fn test_P2_Add_N1() {
15711 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15712 type B = NInt<UInt<UTerm, B1>>;
15713 type P1 = PInt<UInt<UTerm, B1>>;
15714
15715 #[allow(non_camel_case_types)]
15716 type P2AddN1 = <<A as Add<B>>::Output as Same<P1>>::Output;
15717
15718 assert_eq!(<P2AddN1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
15719 }
15720 #[test]
15721 #[allow(non_snake_case)]
15722 fn test_P2_Sub_N1() {
15723 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15724 type B = NInt<UInt<UTerm, B1>>;
15725 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
15726
15727 #[allow(non_camel_case_types)]
15728 type P2SubN1 = <<A as Sub<B>>::Output as Same<P3>>::Output;
15729
15730 assert_eq!(<P2SubN1 as Integer>::to_i64(), <P3 as Integer>::to_i64());
15731 }
15732 #[test]
15733 #[allow(non_snake_case)]
15734 fn test_P2_Mul_N1() {
15735 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15736 type B = NInt<UInt<UTerm, B1>>;
15737 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
15738
15739 #[allow(non_camel_case_types)]
15740 type P2MulN1 = <<A as Mul<B>>::Output as Same<N2>>::Output;
15741
15742 assert_eq!(<P2MulN1 as Integer>::to_i64(), <N2 as Integer>::to_i64());
15743 }
15744 #[test]
15745 #[allow(non_snake_case)]
15746 fn test_P2_Min_N1() {
15747 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15748 type B = NInt<UInt<UTerm, B1>>;
15749 type N1 = NInt<UInt<UTerm, B1>>;
15750
15751 #[allow(non_camel_case_types)]
15752 type P2MinN1 = <<A as Min<B>>::Output as Same<N1>>::Output;
15753
15754 assert_eq!(<P2MinN1 as Integer>::to_i64(), <N1 as Integer>::to_i64());
15755 }
15756 #[test]
15757 #[allow(non_snake_case)]
15758 fn test_P2_Max_N1() {
15759 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15760 type B = NInt<UInt<UTerm, B1>>;
15761 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
15762
15763 #[allow(non_camel_case_types)]
15764 type P2MaxN1 = <<A as Max<B>>::Output as Same<P2>>::Output;
15765
15766 assert_eq!(<P2MaxN1 as Integer>::to_i64(), <P2 as Integer>::to_i64());
15767 }
15768 #[test]
15769 #[allow(non_snake_case)]
15770 fn test_P2_Gcd_N1() {
15771 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15772 type B = NInt<UInt<UTerm, B1>>;
15773 type P1 = PInt<UInt<UTerm, B1>>;
15774
15775 #[allow(non_camel_case_types)]
15776 type P2GcdN1 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
15777
15778 assert_eq!(<P2GcdN1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
15779 }
15780 #[test]
15781 #[allow(non_snake_case)]
15782 fn test_P2_Div_N1() {
15783 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15784 type B = NInt<UInt<UTerm, B1>>;
15785 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
15786
15787 #[allow(non_camel_case_types)]
15788 type P2DivN1 = <<A as Div<B>>::Output as Same<N2>>::Output;
15789
15790 assert_eq!(<P2DivN1 as Integer>::to_i64(), <N2 as Integer>::to_i64());
15791 }
15792 #[test]
15793 #[allow(non_snake_case)]
15794 fn test_P2_Rem_N1() {
15795 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15796 type B = NInt<UInt<UTerm, B1>>;
15797 type _0 = Z0;
15798
15799 #[allow(non_camel_case_types)]
15800 type P2RemN1 = <<A as Rem<B>>::Output as Same<_0>>::Output;
15801
15802 assert_eq!(<P2RemN1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
15803 }
15804 #[test]
15805 #[allow(non_snake_case)]
15806 fn test_P2_PartialDiv_N1() {
15807 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15808 type B = NInt<UInt<UTerm, B1>>;
15809 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
15810
15811 #[allow(non_camel_case_types)]
15812 type P2PartialDivN1 = <<A as PartialDiv<B>>::Output as Same<N2>>::Output;
15813
15814 assert_eq!(<P2PartialDivN1 as Integer>::to_i64(), <N2 as Integer>::to_i64());
15815 }
15816 #[test]
15817 #[allow(non_snake_case)]
15818 fn test_P2_Cmp_N1() {
15819 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15820 type B = NInt<UInt<UTerm, B1>>;
15821
15822 #[allow(non_camel_case_types)]
15823 type P2CmpN1 = <A as Cmp<B>>::Output;
15824 assert_eq!(<P2CmpN1 as Ord>::to_ordering(), Ordering::Greater);
15825 }
15826 #[test]
15827 #[allow(non_snake_case)]
15828 fn test_P2_Add__0() {
15829 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15830 type B = Z0;
15831 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
15832
15833 #[allow(non_camel_case_types)]
15834 type P2Add_0 = <<A as Add<B>>::Output as Same<P2>>::Output;
15835
15836 assert_eq!(<P2Add_0 as Integer>::to_i64(), <P2 as Integer>::to_i64());
15837 }
15838 #[test]
15839 #[allow(non_snake_case)]
15840 fn test_P2_Sub__0() {
15841 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15842 type B = Z0;
15843 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
15844
15845 #[allow(non_camel_case_types)]
15846 type P2Sub_0 = <<A as Sub<B>>::Output as Same<P2>>::Output;
15847
15848 assert_eq!(<P2Sub_0 as Integer>::to_i64(), <P2 as Integer>::to_i64());
15849 }
15850 #[test]
15851 #[allow(non_snake_case)]
15852 fn test_P2_Mul__0() {
15853 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15854 type B = Z0;
15855 type _0 = Z0;
15856
15857 #[allow(non_camel_case_types)]
15858 type P2Mul_0 = <<A as Mul<B>>::Output as Same<_0>>::Output;
15859
15860 assert_eq!(<P2Mul_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
15861 }
15862 #[test]
15863 #[allow(non_snake_case)]
15864 fn test_P2_Min__0() {
15865 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15866 type B = Z0;
15867 type _0 = Z0;
15868
15869 #[allow(non_camel_case_types)]
15870 type P2Min_0 = <<A as Min<B>>::Output as Same<_0>>::Output;
15871
15872 assert_eq!(<P2Min_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
15873 }
15874 #[test]
15875 #[allow(non_snake_case)]
15876 fn test_P2_Max__0() {
15877 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15878 type B = Z0;
15879 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
15880
15881 #[allow(non_camel_case_types)]
15882 type P2Max_0 = <<A as Max<B>>::Output as Same<P2>>::Output;
15883
15884 assert_eq!(<P2Max_0 as Integer>::to_i64(), <P2 as Integer>::to_i64());
15885 }
15886 #[test]
15887 #[allow(non_snake_case)]
15888 fn test_P2_Gcd__0() {
15889 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15890 type B = Z0;
15891 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
15892
15893 #[allow(non_camel_case_types)]
15894 type P2Gcd_0 = <<A as Gcd<B>>::Output as Same<P2>>::Output;
15895
15896 assert_eq!(<P2Gcd_0 as Integer>::to_i64(), <P2 as Integer>::to_i64());
15897 }
15898 #[test]
15899 #[allow(non_snake_case)]
15900 fn test_P2_Pow__0() {
15901 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15902 type B = Z0;
15903 type P1 = PInt<UInt<UTerm, B1>>;
15904
15905 #[allow(non_camel_case_types)]
15906 type P2Pow_0 = <<A as Pow<B>>::Output as Same<P1>>::Output;
15907
15908 assert_eq!(<P2Pow_0 as Integer>::to_i64(), <P1 as Integer>::to_i64());
15909 }
15910 #[test]
15911 #[allow(non_snake_case)]
15912 fn test_P2_Cmp__0() {
15913 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15914 type B = Z0;
15915
15916 #[allow(non_camel_case_types)]
15917 type P2Cmp_0 = <A as Cmp<B>>::Output;
15918 assert_eq!(<P2Cmp_0 as Ord>::to_ordering(), Ordering::Greater);
15919 }
15920 #[test]
15921 #[allow(non_snake_case)]
15922 fn test_P2_Add_P1() {
15923 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15924 type B = PInt<UInt<UTerm, B1>>;
15925 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
15926
15927 #[allow(non_camel_case_types)]
15928 type P2AddP1 = <<A as Add<B>>::Output as Same<P3>>::Output;
15929
15930 assert_eq!(<P2AddP1 as Integer>::to_i64(), <P3 as Integer>::to_i64());
15931 }
15932 #[test]
15933 #[allow(non_snake_case)]
15934 fn test_P2_Sub_P1() {
15935 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15936 type B = PInt<UInt<UTerm, B1>>;
15937 type P1 = PInt<UInt<UTerm, B1>>;
15938
15939 #[allow(non_camel_case_types)]
15940 type P2SubP1 = <<A as Sub<B>>::Output as Same<P1>>::Output;
15941
15942 assert_eq!(<P2SubP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
15943 }
15944 #[test]
15945 #[allow(non_snake_case)]
15946 fn test_P2_Mul_P1() {
15947 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15948 type B = PInt<UInt<UTerm, B1>>;
15949 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
15950
15951 #[allow(non_camel_case_types)]
15952 type P2MulP1 = <<A as Mul<B>>::Output as Same<P2>>::Output;
15953
15954 assert_eq!(<P2MulP1 as Integer>::to_i64(), <P2 as Integer>::to_i64());
15955 }
15956 #[test]
15957 #[allow(non_snake_case)]
15958 fn test_P2_Min_P1() {
15959 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15960 type B = PInt<UInt<UTerm, B1>>;
15961 type P1 = PInt<UInt<UTerm, B1>>;
15962
15963 #[allow(non_camel_case_types)]
15964 type P2MinP1 = <<A as Min<B>>::Output as Same<P1>>::Output;
15965
15966 assert_eq!(<P2MinP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
15967 }
15968 #[test]
15969 #[allow(non_snake_case)]
15970 fn test_P2_Max_P1() {
15971 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15972 type B = PInt<UInt<UTerm, B1>>;
15973 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
15974
15975 #[allow(non_camel_case_types)]
15976 type P2MaxP1 = <<A as Max<B>>::Output as Same<P2>>::Output;
15977
15978 assert_eq!(<P2MaxP1 as Integer>::to_i64(), <P2 as Integer>::to_i64());
15979 }
15980 #[test]
15981 #[allow(non_snake_case)]
15982 fn test_P2_Gcd_P1() {
15983 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15984 type B = PInt<UInt<UTerm, B1>>;
15985 type P1 = PInt<UInt<UTerm, B1>>;
15986
15987 #[allow(non_camel_case_types)]
15988 type P2GcdP1 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
15989
15990 assert_eq!(<P2GcdP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
15991 }
15992 #[test]
15993 #[allow(non_snake_case)]
15994 fn test_P2_Div_P1() {
15995 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
15996 type B = PInt<UInt<UTerm, B1>>;
15997 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
15998
15999 #[allow(non_camel_case_types)]
16000 type P2DivP1 = <<A as Div<B>>::Output as Same<P2>>::Output;
16001
16002 assert_eq!(<P2DivP1 as Integer>::to_i64(), <P2 as Integer>::to_i64());
16003 }
16004 #[test]
16005 #[allow(non_snake_case)]
16006 fn test_P2_Rem_P1() {
16007 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16008 type B = PInt<UInt<UTerm, B1>>;
16009 type _0 = Z0;
16010
16011 #[allow(non_camel_case_types)]
16012 type P2RemP1 = <<A as Rem<B>>::Output as Same<_0>>::Output;
16013
16014 assert_eq!(<P2RemP1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
16015 }
16016 #[test]
16017 #[allow(non_snake_case)]
16018 fn test_P2_PartialDiv_P1() {
16019 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16020 type B = PInt<UInt<UTerm, B1>>;
16021 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
16022
16023 #[allow(non_camel_case_types)]
16024 type P2PartialDivP1 = <<A as PartialDiv<B>>::Output as Same<P2>>::Output;
16025
16026 assert_eq!(<P2PartialDivP1 as Integer>::to_i64(), <P2 as Integer>::to_i64());
16027 }
16028 #[test]
16029 #[allow(non_snake_case)]
16030 fn test_P2_Pow_P1() {
16031 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16032 type B = PInt<UInt<UTerm, B1>>;
16033 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
16034
16035 #[allow(non_camel_case_types)]
16036 type P2PowP1 = <<A as Pow<B>>::Output as Same<P2>>::Output;
16037
16038 assert_eq!(<P2PowP1 as Integer>::to_i64(), <P2 as Integer>::to_i64());
16039 }
16040 #[test]
16041 #[allow(non_snake_case)]
16042 fn test_P2_Cmp_P1() {
16043 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16044 type B = PInt<UInt<UTerm, B1>>;
16045
16046 #[allow(non_camel_case_types)]
16047 type P2CmpP1 = <A as Cmp<B>>::Output;
16048 assert_eq!(<P2CmpP1 as Ord>::to_ordering(), Ordering::Greater);
16049 }
16050 #[test]
16051 #[allow(non_snake_case)]
16052 fn test_P2_Add_P2() {
16053 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16054 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
16055 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
16056
16057 #[allow(non_camel_case_types)]
16058 type P2AddP2 = <<A as Add<B>>::Output as Same<P4>>::Output;
16059
16060 assert_eq!(<P2AddP2 as Integer>::to_i64(), <P4 as Integer>::to_i64());
16061 }
16062 #[test]
16063 #[allow(non_snake_case)]
16064 fn test_P2_Sub_P2() {
16065 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16066 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
16067 type _0 = Z0;
16068
16069 #[allow(non_camel_case_types)]
16070 type P2SubP2 = <<A as Sub<B>>::Output as Same<_0>>::Output;
16071
16072 assert_eq!(<P2SubP2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
16073 }
16074 #[test]
16075 #[allow(non_snake_case)]
16076 fn test_P2_Mul_P2() {
16077 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16078 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
16079 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
16080
16081 #[allow(non_camel_case_types)]
16082 type P2MulP2 = <<A as Mul<B>>::Output as Same<P4>>::Output;
16083
16084 assert_eq!(<P2MulP2 as Integer>::to_i64(), <P4 as Integer>::to_i64());
16085 }
16086 #[test]
16087 #[allow(non_snake_case)]
16088 fn test_P2_Min_P2() {
16089 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16090 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
16091 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
16092
16093 #[allow(non_camel_case_types)]
16094 type P2MinP2 = <<A as Min<B>>::Output as Same<P2>>::Output;
16095
16096 assert_eq!(<P2MinP2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
16097 }
16098 #[test]
16099 #[allow(non_snake_case)]
16100 fn test_P2_Max_P2() {
16101 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16102 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
16103 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
16104
16105 #[allow(non_camel_case_types)]
16106 type P2MaxP2 = <<A as Max<B>>::Output as Same<P2>>::Output;
16107
16108 assert_eq!(<P2MaxP2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
16109 }
16110 #[test]
16111 #[allow(non_snake_case)]
16112 fn test_P2_Gcd_P2() {
16113 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16114 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
16115 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
16116
16117 #[allow(non_camel_case_types)]
16118 type P2GcdP2 = <<A as Gcd<B>>::Output as Same<P2>>::Output;
16119
16120 assert_eq!(<P2GcdP2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
16121 }
16122 #[test]
16123 #[allow(non_snake_case)]
16124 fn test_P2_Div_P2() {
16125 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16126 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
16127 type P1 = PInt<UInt<UTerm, B1>>;
16128
16129 #[allow(non_camel_case_types)]
16130 type P2DivP2 = <<A as Div<B>>::Output as Same<P1>>::Output;
16131
16132 assert_eq!(<P2DivP2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
16133 }
16134 #[test]
16135 #[allow(non_snake_case)]
16136 fn test_P2_Rem_P2() {
16137 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16138 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
16139 type _0 = Z0;
16140
16141 #[allow(non_camel_case_types)]
16142 type P2RemP2 = <<A as Rem<B>>::Output as Same<_0>>::Output;
16143
16144 assert_eq!(<P2RemP2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
16145 }
16146 #[test]
16147 #[allow(non_snake_case)]
16148 fn test_P2_PartialDiv_P2() {
16149 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16150 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
16151 type P1 = PInt<UInt<UTerm, B1>>;
16152
16153 #[allow(non_camel_case_types)]
16154 type P2PartialDivP2 = <<A as PartialDiv<B>>::Output as Same<P1>>::Output;
16155
16156 assert_eq!(<P2PartialDivP2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
16157 }
16158 #[test]
16159 #[allow(non_snake_case)]
16160 fn test_P2_Pow_P2() {
16161 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16162 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
16163 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
16164
16165 #[allow(non_camel_case_types)]
16166 type P2PowP2 = <<A as Pow<B>>::Output as Same<P4>>::Output;
16167
16168 assert_eq!(<P2PowP2 as Integer>::to_i64(), <P4 as Integer>::to_i64());
16169 }
16170 #[test]
16171 #[allow(non_snake_case)]
16172 fn test_P2_Cmp_P2() {
16173 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16174 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
16175
16176 #[allow(non_camel_case_types)]
16177 type P2CmpP2 = <A as Cmp<B>>::Output;
16178 assert_eq!(<P2CmpP2 as Ord>::to_ordering(), Ordering::Equal);
16179 }
16180 #[test]
16181 #[allow(non_snake_case)]
16182 fn test_P2_Add_P3() {
16183 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16184 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
16185 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
16186
16187 #[allow(non_camel_case_types)]
16188 type P2AddP3 = <<A as Add<B>>::Output as Same<P5>>::Output;
16189
16190 assert_eq!(<P2AddP3 as Integer>::to_i64(), <P5 as Integer>::to_i64());
16191 }
16192 #[test]
16193 #[allow(non_snake_case)]
16194 fn test_P2_Sub_P3() {
16195 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16196 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
16197 type N1 = NInt<UInt<UTerm, B1>>;
16198
16199 #[allow(non_camel_case_types)]
16200 type P2SubP3 = <<A as Sub<B>>::Output as Same<N1>>::Output;
16201
16202 assert_eq!(<P2SubP3 as Integer>::to_i64(), <N1 as Integer>::to_i64());
16203 }
16204 #[test]
16205 #[allow(non_snake_case)]
16206 fn test_P2_Mul_P3() {
16207 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16208 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
16209 type P6 = PInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
16210
16211 #[allow(non_camel_case_types)]
16212 type P2MulP3 = <<A as Mul<B>>::Output as Same<P6>>::Output;
16213
16214 assert_eq!(<P2MulP3 as Integer>::to_i64(), <P6 as Integer>::to_i64());
16215 }
16216 #[test]
16217 #[allow(non_snake_case)]
16218 fn test_P2_Min_P3() {
16219 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16220 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
16221 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
16222
16223 #[allow(non_camel_case_types)]
16224 type P2MinP3 = <<A as Min<B>>::Output as Same<P2>>::Output;
16225
16226 assert_eq!(<P2MinP3 as Integer>::to_i64(), <P2 as Integer>::to_i64());
16227 }
16228 #[test]
16229 #[allow(non_snake_case)]
16230 fn test_P2_Max_P3() {
16231 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16232 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
16233 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
16234
16235 #[allow(non_camel_case_types)]
16236 type P2MaxP3 = <<A as Max<B>>::Output as Same<P3>>::Output;
16237
16238 assert_eq!(<P2MaxP3 as Integer>::to_i64(), <P3 as Integer>::to_i64());
16239 }
16240 #[test]
16241 #[allow(non_snake_case)]
16242 fn test_P2_Gcd_P3() {
16243 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16244 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
16245 type P1 = PInt<UInt<UTerm, B1>>;
16246
16247 #[allow(non_camel_case_types)]
16248 type P2GcdP3 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
16249
16250 assert_eq!(<P2GcdP3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
16251 }
16252 #[test]
16253 #[allow(non_snake_case)]
16254 fn test_P2_Div_P3() {
16255 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16256 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
16257 type _0 = Z0;
16258
16259 #[allow(non_camel_case_types)]
16260 type P2DivP3 = <<A as Div<B>>::Output as Same<_0>>::Output;
16261
16262 assert_eq!(<P2DivP3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
16263 }
16264 #[test]
16265 #[allow(non_snake_case)]
16266 fn test_P2_Rem_P3() {
16267 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16268 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
16269 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
16270
16271 #[allow(non_camel_case_types)]
16272 type P2RemP3 = <<A as Rem<B>>::Output as Same<P2>>::Output;
16273
16274 assert_eq!(<P2RemP3 as Integer>::to_i64(), <P2 as Integer>::to_i64());
16275 }
16276 #[test]
16277 #[allow(non_snake_case)]
16278 fn test_P2_Pow_P3() {
16279 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16280 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
16281 type P8 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>;
16282
16283 #[allow(non_camel_case_types)]
16284 type P2PowP3 = <<A as Pow<B>>::Output as Same<P8>>::Output;
16285
16286 assert_eq!(<P2PowP3 as Integer>::to_i64(), <P8 as Integer>::to_i64());
16287 }
16288 #[test]
16289 #[allow(non_snake_case)]
16290 fn test_P2_Cmp_P3() {
16291 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16292 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
16293
16294 #[allow(non_camel_case_types)]
16295 type P2CmpP3 = <A as Cmp<B>>::Output;
16296 assert_eq!(<P2CmpP3 as Ord>::to_ordering(), Ordering::Less);
16297 }
16298 #[test]
16299 #[allow(non_snake_case)]
16300 fn test_P2_Add_P4() {
16301 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16302 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
16303 type P6 = PInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
16304
16305 #[allow(non_camel_case_types)]
16306 type P2AddP4 = <<A as Add<B>>::Output as Same<P6>>::Output;
16307
16308 assert_eq!(<P2AddP4 as Integer>::to_i64(), <P6 as Integer>::to_i64());
16309 }
16310 #[test]
16311 #[allow(non_snake_case)]
16312 fn test_P2_Sub_P4() {
16313 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16314 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
16315 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
16316
16317 #[allow(non_camel_case_types)]
16318 type P2SubP4 = <<A as Sub<B>>::Output as Same<N2>>::Output;
16319
16320 assert_eq!(<P2SubP4 as Integer>::to_i64(), <N2 as Integer>::to_i64());
16321 }
16322 #[test]
16323 #[allow(non_snake_case)]
16324 fn test_P2_Mul_P4() {
16325 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16326 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
16327 type P8 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>;
16328
16329 #[allow(non_camel_case_types)]
16330 type P2MulP4 = <<A as Mul<B>>::Output as Same<P8>>::Output;
16331
16332 assert_eq!(<P2MulP4 as Integer>::to_i64(), <P8 as Integer>::to_i64());
16333 }
16334 #[test]
16335 #[allow(non_snake_case)]
16336 fn test_P2_Min_P4() {
16337 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16338 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
16339 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
16340
16341 #[allow(non_camel_case_types)]
16342 type P2MinP4 = <<A as Min<B>>::Output as Same<P2>>::Output;
16343
16344 assert_eq!(<P2MinP4 as Integer>::to_i64(), <P2 as Integer>::to_i64());
16345 }
16346 #[test]
16347 #[allow(non_snake_case)]
16348 fn test_P2_Max_P4() {
16349 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16350 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
16351 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
16352
16353 #[allow(non_camel_case_types)]
16354 type P2MaxP4 = <<A as Max<B>>::Output as Same<P4>>::Output;
16355
16356 assert_eq!(<P2MaxP4 as Integer>::to_i64(), <P4 as Integer>::to_i64());
16357 }
16358 #[test]
16359 #[allow(non_snake_case)]
16360 fn test_P2_Gcd_P4() {
16361 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16362 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
16363 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
16364
16365 #[allow(non_camel_case_types)]
16366 type P2GcdP4 = <<A as Gcd<B>>::Output as Same<P2>>::Output;
16367
16368 assert_eq!(<P2GcdP4 as Integer>::to_i64(), <P2 as Integer>::to_i64());
16369 }
16370 #[test]
16371 #[allow(non_snake_case)]
16372 fn test_P2_Div_P4() {
16373 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16374 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
16375 type _0 = Z0;
16376
16377 #[allow(non_camel_case_types)]
16378 type P2DivP4 = <<A as Div<B>>::Output as Same<_0>>::Output;
16379
16380 assert_eq!(<P2DivP4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
16381 }
16382 #[test]
16383 #[allow(non_snake_case)]
16384 fn test_P2_Rem_P4() {
16385 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16386 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
16387 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
16388
16389 #[allow(non_camel_case_types)]
16390 type P2RemP4 = <<A as Rem<B>>::Output as Same<P2>>::Output;
16391
16392 assert_eq!(<P2RemP4 as Integer>::to_i64(), <P2 as Integer>::to_i64());
16393 }
16394 #[test]
16395 #[allow(non_snake_case)]
16396 fn test_P2_Pow_P4() {
16397 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16398 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
16399 type P16 = PInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>>;
16400
16401 #[allow(non_camel_case_types)]
16402 type P2PowP4 = <<A as Pow<B>>::Output as Same<P16>>::Output;
16403
16404 assert_eq!(<P2PowP4 as Integer>::to_i64(), <P16 as Integer>::to_i64());
16405 }
16406 #[test]
16407 #[allow(non_snake_case)]
16408 fn test_P2_Cmp_P4() {
16409 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16410 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
16411
16412 #[allow(non_camel_case_types)]
16413 type P2CmpP4 = <A as Cmp<B>>::Output;
16414 assert_eq!(<P2CmpP4 as Ord>::to_ordering(), Ordering::Less);
16415 }
16416 #[test]
16417 #[allow(non_snake_case)]
16418 fn test_P2_Add_P5() {
16419 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16420 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
16421 type P7 = PInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>>;
16422
16423 #[allow(non_camel_case_types)]
16424 type P2AddP5 = <<A as Add<B>>::Output as Same<P7>>::Output;
16425
16426 assert_eq!(<P2AddP5 as Integer>::to_i64(), <P7 as Integer>::to_i64());
16427 }
16428 #[test]
16429 #[allow(non_snake_case)]
16430 fn test_P2_Sub_P5() {
16431 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16432 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
16433 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
16434
16435 #[allow(non_camel_case_types)]
16436 type P2SubP5 = <<A as Sub<B>>::Output as Same<N3>>::Output;
16437
16438 assert_eq!(<P2SubP5 as Integer>::to_i64(), <N3 as Integer>::to_i64());
16439 }
16440 #[test]
16441 #[allow(non_snake_case)]
16442 fn test_P2_Mul_P5() {
16443 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16444 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
16445 type P10 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>;
16446
16447 #[allow(non_camel_case_types)]
16448 type P2MulP5 = <<A as Mul<B>>::Output as Same<P10>>::Output;
16449
16450 assert_eq!(<P2MulP5 as Integer>::to_i64(), <P10 as Integer>::to_i64());
16451 }
16452 #[test]
16453 #[allow(non_snake_case)]
16454 fn test_P2_Min_P5() {
16455 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16456 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
16457 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
16458
16459 #[allow(non_camel_case_types)]
16460 type P2MinP5 = <<A as Min<B>>::Output as Same<P2>>::Output;
16461
16462 assert_eq!(<P2MinP5 as Integer>::to_i64(), <P2 as Integer>::to_i64());
16463 }
16464 #[test]
16465 #[allow(non_snake_case)]
16466 fn test_P2_Max_P5() {
16467 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16468 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
16469 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
16470
16471 #[allow(non_camel_case_types)]
16472 type P2MaxP5 = <<A as Max<B>>::Output as Same<P5>>::Output;
16473
16474 assert_eq!(<P2MaxP5 as Integer>::to_i64(), <P5 as Integer>::to_i64());
16475 }
16476 #[test]
16477 #[allow(non_snake_case)]
16478 fn test_P2_Gcd_P5() {
16479 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16480 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
16481 type P1 = PInt<UInt<UTerm, B1>>;
16482
16483 #[allow(non_camel_case_types)]
16484 type P2GcdP5 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
16485
16486 assert_eq!(<P2GcdP5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
16487 }
16488 #[test]
16489 #[allow(non_snake_case)]
16490 fn test_P2_Div_P5() {
16491 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16492 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
16493 type _0 = Z0;
16494
16495 #[allow(non_camel_case_types)]
16496 type P2DivP5 = <<A as Div<B>>::Output as Same<_0>>::Output;
16497
16498 assert_eq!(<P2DivP5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
16499 }
16500 #[test]
16501 #[allow(non_snake_case)]
16502 fn test_P2_Rem_P5() {
16503 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16504 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
16505 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
16506
16507 #[allow(non_camel_case_types)]
16508 type P2RemP5 = <<A as Rem<B>>::Output as Same<P2>>::Output;
16509
16510 assert_eq!(<P2RemP5 as Integer>::to_i64(), <P2 as Integer>::to_i64());
16511 }
16512 #[test]
16513 #[allow(non_snake_case)]
16514 fn test_P2_Pow_P5() {
16515 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16516 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
16517 type P32 = PInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>>;
16518
16519 #[allow(non_camel_case_types)]
16520 type P2PowP5 = <<A as Pow<B>>::Output as Same<P32>>::Output;
16521
16522 assert_eq!(<P2PowP5 as Integer>::to_i64(), <P32 as Integer>::to_i64());
16523 }
16524 #[test]
16525 #[allow(non_snake_case)]
16526 fn test_P2_Cmp_P5() {
16527 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
16528 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
16529
16530 #[allow(non_camel_case_types)]
16531 type P2CmpP5 = <A as Cmp<B>>::Output;
16532 assert_eq!(<P2CmpP5 as Ord>::to_ordering(), Ordering::Less);
16533 }
16534 #[test]
16535 #[allow(non_snake_case)]
16536 fn test_P3_Add_N5() {
16537 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16538 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
16539 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
16540
16541 #[allow(non_camel_case_types)]
16542 type P3AddN5 = <<A as Add<B>>::Output as Same<N2>>::Output;
16543
16544 assert_eq!(<P3AddN5 as Integer>::to_i64(), <N2 as Integer>::to_i64());
16545 }
16546 #[test]
16547 #[allow(non_snake_case)]
16548 fn test_P3_Sub_N5() {
16549 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16550 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
16551 type P8 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>;
16552
16553 #[allow(non_camel_case_types)]
16554 type P3SubN5 = <<A as Sub<B>>::Output as Same<P8>>::Output;
16555
16556 assert_eq!(<P3SubN5 as Integer>::to_i64(), <P8 as Integer>::to_i64());
16557 }
16558 #[test]
16559 #[allow(non_snake_case)]
16560 fn test_P3_Mul_N5() {
16561 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16562 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
16563 type N15 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>;
16564
16565 #[allow(non_camel_case_types)]
16566 type P3MulN5 = <<A as Mul<B>>::Output as Same<N15>>::Output;
16567
16568 assert_eq!(<P3MulN5 as Integer>::to_i64(), <N15 as Integer>::to_i64());
16569 }
16570 #[test]
16571 #[allow(non_snake_case)]
16572 fn test_P3_Min_N5() {
16573 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16574 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
16575 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
16576
16577 #[allow(non_camel_case_types)]
16578 type P3MinN5 = <<A as Min<B>>::Output as Same<N5>>::Output;
16579
16580 assert_eq!(<P3MinN5 as Integer>::to_i64(), <N5 as Integer>::to_i64());
16581 }
16582 #[test]
16583 #[allow(non_snake_case)]
16584 fn test_P3_Max_N5() {
16585 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16586 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
16587 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
16588
16589 #[allow(non_camel_case_types)]
16590 type P3MaxN5 = <<A as Max<B>>::Output as Same<P3>>::Output;
16591
16592 assert_eq!(<P3MaxN5 as Integer>::to_i64(), <P3 as Integer>::to_i64());
16593 }
16594 #[test]
16595 #[allow(non_snake_case)]
16596 fn test_P3_Gcd_N5() {
16597 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16598 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
16599 type P1 = PInt<UInt<UTerm, B1>>;
16600
16601 #[allow(non_camel_case_types)]
16602 type P3GcdN5 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
16603
16604 assert_eq!(<P3GcdN5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
16605 }
16606 #[test]
16607 #[allow(non_snake_case)]
16608 fn test_P3_Div_N5() {
16609 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16610 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
16611 type _0 = Z0;
16612
16613 #[allow(non_camel_case_types)]
16614 type P3DivN5 = <<A as Div<B>>::Output as Same<_0>>::Output;
16615
16616 assert_eq!(<P3DivN5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
16617 }
16618 #[test]
16619 #[allow(non_snake_case)]
16620 fn test_P3_Rem_N5() {
16621 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16622 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
16623 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
16624
16625 #[allow(non_camel_case_types)]
16626 type P3RemN5 = <<A as Rem<B>>::Output as Same<P3>>::Output;
16627
16628 assert_eq!(<P3RemN5 as Integer>::to_i64(), <P3 as Integer>::to_i64());
16629 }
16630 #[test]
16631 #[allow(non_snake_case)]
16632 fn test_P3_Cmp_N5() {
16633 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16634 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
16635
16636 #[allow(non_camel_case_types)]
16637 type P3CmpN5 = <A as Cmp<B>>::Output;
16638 assert_eq!(<P3CmpN5 as Ord>::to_ordering(), Ordering::Greater);
16639 }
16640 #[test]
16641 #[allow(non_snake_case)]
16642 fn test_P3_Add_N4() {
16643 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16644 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
16645 type N1 = NInt<UInt<UTerm, B1>>;
16646
16647 #[allow(non_camel_case_types)]
16648 type P3AddN4 = <<A as Add<B>>::Output as Same<N1>>::Output;
16649
16650 assert_eq!(<P3AddN4 as Integer>::to_i64(), <N1 as Integer>::to_i64());
16651 }
16652 #[test]
16653 #[allow(non_snake_case)]
16654 fn test_P3_Sub_N4() {
16655 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16656 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
16657 type P7 = PInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>>;
16658
16659 #[allow(non_camel_case_types)]
16660 type P3SubN4 = <<A as Sub<B>>::Output as Same<P7>>::Output;
16661
16662 assert_eq!(<P3SubN4 as Integer>::to_i64(), <P7 as Integer>::to_i64());
16663 }
16664 #[test]
16665 #[allow(non_snake_case)]
16666 fn test_P3_Mul_N4() {
16667 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16668 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
16669 type N12 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>>;
16670
16671 #[allow(non_camel_case_types)]
16672 type P3MulN4 = <<A as Mul<B>>::Output as Same<N12>>::Output;
16673
16674 assert_eq!(<P3MulN4 as Integer>::to_i64(), <N12 as Integer>::to_i64());
16675 }
16676 #[test]
16677 #[allow(non_snake_case)]
16678 fn test_P3_Min_N4() {
16679 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16680 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
16681 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
16682
16683 #[allow(non_camel_case_types)]
16684 type P3MinN4 = <<A as Min<B>>::Output as Same<N4>>::Output;
16685
16686 assert_eq!(<P3MinN4 as Integer>::to_i64(), <N4 as Integer>::to_i64());
16687 }
16688 #[test]
16689 #[allow(non_snake_case)]
16690 fn test_P3_Max_N4() {
16691 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16692 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
16693 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
16694
16695 #[allow(non_camel_case_types)]
16696 type P3MaxN4 = <<A as Max<B>>::Output as Same<P3>>::Output;
16697
16698 assert_eq!(<P3MaxN4 as Integer>::to_i64(), <P3 as Integer>::to_i64());
16699 }
16700 #[test]
16701 #[allow(non_snake_case)]
16702 fn test_P3_Gcd_N4() {
16703 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16704 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
16705 type P1 = PInt<UInt<UTerm, B1>>;
16706
16707 #[allow(non_camel_case_types)]
16708 type P3GcdN4 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
16709
16710 assert_eq!(<P3GcdN4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
16711 }
16712 #[test]
16713 #[allow(non_snake_case)]
16714 fn test_P3_Div_N4() {
16715 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16716 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
16717 type _0 = Z0;
16718
16719 #[allow(non_camel_case_types)]
16720 type P3DivN4 = <<A as Div<B>>::Output as Same<_0>>::Output;
16721
16722 assert_eq!(<P3DivN4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
16723 }
16724 #[test]
16725 #[allow(non_snake_case)]
16726 fn test_P3_Rem_N4() {
16727 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16728 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
16729 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
16730
16731 #[allow(non_camel_case_types)]
16732 type P3RemN4 = <<A as Rem<B>>::Output as Same<P3>>::Output;
16733
16734 assert_eq!(<P3RemN4 as Integer>::to_i64(), <P3 as Integer>::to_i64());
16735 }
16736 #[test]
16737 #[allow(non_snake_case)]
16738 fn test_P3_Cmp_N4() {
16739 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16740 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
16741
16742 #[allow(non_camel_case_types)]
16743 type P3CmpN4 = <A as Cmp<B>>::Output;
16744 assert_eq!(<P3CmpN4 as Ord>::to_ordering(), Ordering::Greater);
16745 }
16746 #[test]
16747 #[allow(non_snake_case)]
16748 fn test_P3_Add_N3() {
16749 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16750 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
16751 type _0 = Z0;
16752
16753 #[allow(non_camel_case_types)]
16754 type P3AddN3 = <<A as Add<B>>::Output as Same<_0>>::Output;
16755
16756 assert_eq!(<P3AddN3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
16757 }
16758 #[test]
16759 #[allow(non_snake_case)]
16760 fn test_P3_Sub_N3() {
16761 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16762 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
16763 type P6 = PInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
16764
16765 #[allow(non_camel_case_types)]
16766 type P3SubN3 = <<A as Sub<B>>::Output as Same<P6>>::Output;
16767
16768 assert_eq!(<P3SubN3 as Integer>::to_i64(), <P6 as Integer>::to_i64());
16769 }
16770 #[test]
16771 #[allow(non_snake_case)]
16772 fn test_P3_Mul_N3() {
16773 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16774 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
16775 type N9 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>>;
16776
16777 #[allow(non_camel_case_types)]
16778 type P3MulN3 = <<A as Mul<B>>::Output as Same<N9>>::Output;
16779
16780 assert_eq!(<P3MulN3 as Integer>::to_i64(), <N9 as Integer>::to_i64());
16781 }
16782 #[test]
16783 #[allow(non_snake_case)]
16784 fn test_P3_Min_N3() {
16785 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16786 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
16787 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
16788
16789 #[allow(non_camel_case_types)]
16790 type P3MinN3 = <<A as Min<B>>::Output as Same<N3>>::Output;
16791
16792 assert_eq!(<P3MinN3 as Integer>::to_i64(), <N3 as Integer>::to_i64());
16793 }
16794 #[test]
16795 #[allow(non_snake_case)]
16796 fn test_P3_Max_N3() {
16797 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16798 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
16799 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
16800
16801 #[allow(non_camel_case_types)]
16802 type P3MaxN3 = <<A as Max<B>>::Output as Same<P3>>::Output;
16803
16804 assert_eq!(<P3MaxN3 as Integer>::to_i64(), <P3 as Integer>::to_i64());
16805 }
16806 #[test]
16807 #[allow(non_snake_case)]
16808 fn test_P3_Gcd_N3() {
16809 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16810 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
16811 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
16812
16813 #[allow(non_camel_case_types)]
16814 type P3GcdN3 = <<A as Gcd<B>>::Output as Same<P3>>::Output;
16815
16816 assert_eq!(<P3GcdN3 as Integer>::to_i64(), <P3 as Integer>::to_i64());
16817 }
16818 #[test]
16819 #[allow(non_snake_case)]
16820 fn test_P3_Div_N3() {
16821 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16822 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
16823 type N1 = NInt<UInt<UTerm, B1>>;
16824
16825 #[allow(non_camel_case_types)]
16826 type P3DivN3 = <<A as Div<B>>::Output as Same<N1>>::Output;
16827
16828 assert_eq!(<P3DivN3 as Integer>::to_i64(), <N1 as Integer>::to_i64());
16829 }
16830 #[test]
16831 #[allow(non_snake_case)]
16832 fn test_P3_Rem_N3() {
16833 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16834 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
16835 type _0 = Z0;
16836
16837 #[allow(non_camel_case_types)]
16838 type P3RemN3 = <<A as Rem<B>>::Output as Same<_0>>::Output;
16839
16840 assert_eq!(<P3RemN3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
16841 }
16842 #[test]
16843 #[allow(non_snake_case)]
16844 fn test_P3_PartialDiv_N3() {
16845 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16846 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
16847 type N1 = NInt<UInt<UTerm, B1>>;
16848
16849 #[allow(non_camel_case_types)]
16850 type P3PartialDivN3 = <<A as PartialDiv<B>>::Output as Same<N1>>::Output;
16851
16852 assert_eq!(<P3PartialDivN3 as Integer>::to_i64(), <N1 as Integer>::to_i64());
16853 }
16854 #[test]
16855 #[allow(non_snake_case)]
16856 fn test_P3_Cmp_N3() {
16857 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16858 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
16859
16860 #[allow(non_camel_case_types)]
16861 type P3CmpN3 = <A as Cmp<B>>::Output;
16862 assert_eq!(<P3CmpN3 as Ord>::to_ordering(), Ordering::Greater);
16863 }
16864 #[test]
16865 #[allow(non_snake_case)]
16866 fn test_P3_Add_N2() {
16867 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16868 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
16869 type P1 = PInt<UInt<UTerm, B1>>;
16870
16871 #[allow(non_camel_case_types)]
16872 type P3AddN2 = <<A as Add<B>>::Output as Same<P1>>::Output;
16873
16874 assert_eq!(<P3AddN2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
16875 }
16876 #[test]
16877 #[allow(non_snake_case)]
16878 fn test_P3_Sub_N2() {
16879 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16880 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
16881 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
16882
16883 #[allow(non_camel_case_types)]
16884 type P3SubN2 = <<A as Sub<B>>::Output as Same<P5>>::Output;
16885
16886 assert_eq!(<P3SubN2 as Integer>::to_i64(), <P5 as Integer>::to_i64());
16887 }
16888 #[test]
16889 #[allow(non_snake_case)]
16890 fn test_P3_Mul_N2() {
16891 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16892 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
16893 type N6 = NInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
16894
16895 #[allow(non_camel_case_types)]
16896 type P3MulN2 = <<A as Mul<B>>::Output as Same<N6>>::Output;
16897
16898 assert_eq!(<P3MulN2 as Integer>::to_i64(), <N6 as Integer>::to_i64());
16899 }
16900 #[test]
16901 #[allow(non_snake_case)]
16902 fn test_P3_Min_N2() {
16903 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16904 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
16905 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
16906
16907 #[allow(non_camel_case_types)]
16908 type P3MinN2 = <<A as Min<B>>::Output as Same<N2>>::Output;
16909
16910 assert_eq!(<P3MinN2 as Integer>::to_i64(), <N2 as Integer>::to_i64());
16911 }
16912 #[test]
16913 #[allow(non_snake_case)]
16914 fn test_P3_Max_N2() {
16915 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16916 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
16917 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
16918
16919 #[allow(non_camel_case_types)]
16920 type P3MaxN2 = <<A as Max<B>>::Output as Same<P3>>::Output;
16921
16922 assert_eq!(<P3MaxN2 as Integer>::to_i64(), <P3 as Integer>::to_i64());
16923 }
16924 #[test]
16925 #[allow(non_snake_case)]
16926 fn test_P3_Gcd_N2() {
16927 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16928 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
16929 type P1 = PInt<UInt<UTerm, B1>>;
16930
16931 #[allow(non_camel_case_types)]
16932 type P3GcdN2 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
16933
16934 assert_eq!(<P3GcdN2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
16935 }
16936 #[test]
16937 #[allow(non_snake_case)]
16938 fn test_P3_Div_N2() {
16939 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16940 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
16941 type N1 = NInt<UInt<UTerm, B1>>;
16942
16943 #[allow(non_camel_case_types)]
16944 type P3DivN2 = <<A as Div<B>>::Output as Same<N1>>::Output;
16945
16946 assert_eq!(<P3DivN2 as Integer>::to_i64(), <N1 as Integer>::to_i64());
16947 }
16948 #[test]
16949 #[allow(non_snake_case)]
16950 fn test_P3_Rem_N2() {
16951 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16952 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
16953 type P1 = PInt<UInt<UTerm, B1>>;
16954
16955 #[allow(non_camel_case_types)]
16956 type P3RemN2 = <<A as Rem<B>>::Output as Same<P1>>::Output;
16957
16958 assert_eq!(<P3RemN2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
16959 }
16960 #[test]
16961 #[allow(non_snake_case)]
16962 fn test_P3_Cmp_N2() {
16963 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16964 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
16965
16966 #[allow(non_camel_case_types)]
16967 type P3CmpN2 = <A as Cmp<B>>::Output;
16968 assert_eq!(<P3CmpN2 as Ord>::to_ordering(), Ordering::Greater);
16969 }
16970 #[test]
16971 #[allow(non_snake_case)]
16972 fn test_P3_Add_N1() {
16973 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16974 type B = NInt<UInt<UTerm, B1>>;
16975 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
16976
16977 #[allow(non_camel_case_types)]
16978 type P3AddN1 = <<A as Add<B>>::Output as Same<P2>>::Output;
16979
16980 assert_eq!(<P3AddN1 as Integer>::to_i64(), <P2 as Integer>::to_i64());
16981 }
16982 #[test]
16983 #[allow(non_snake_case)]
16984 fn test_P3_Sub_N1() {
16985 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16986 type B = NInt<UInt<UTerm, B1>>;
16987 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
16988
16989 #[allow(non_camel_case_types)]
16990 type P3SubN1 = <<A as Sub<B>>::Output as Same<P4>>::Output;
16991
16992 assert_eq!(<P3SubN1 as Integer>::to_i64(), <P4 as Integer>::to_i64());
16993 }
16994 #[test]
16995 #[allow(non_snake_case)]
16996 fn test_P3_Mul_N1() {
16997 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
16998 type B = NInt<UInt<UTerm, B1>>;
16999 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
17000
17001 #[allow(non_camel_case_types)]
17002 type P3MulN1 = <<A as Mul<B>>::Output as Same<N3>>::Output;
17003
17004 assert_eq!(<P3MulN1 as Integer>::to_i64(), <N3 as Integer>::to_i64());
17005 }
17006 #[test]
17007 #[allow(non_snake_case)]
17008 fn test_P3_Min_N1() {
17009 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17010 type B = NInt<UInt<UTerm, B1>>;
17011 type N1 = NInt<UInt<UTerm, B1>>;
17012
17013 #[allow(non_camel_case_types)]
17014 type P3MinN1 = <<A as Min<B>>::Output as Same<N1>>::Output;
17015
17016 assert_eq!(<P3MinN1 as Integer>::to_i64(), <N1 as Integer>::to_i64());
17017 }
17018 #[test]
17019 #[allow(non_snake_case)]
17020 fn test_P3_Max_N1() {
17021 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17022 type B = NInt<UInt<UTerm, B1>>;
17023 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
17024
17025 #[allow(non_camel_case_types)]
17026 type P3MaxN1 = <<A as Max<B>>::Output as Same<P3>>::Output;
17027
17028 assert_eq!(<P3MaxN1 as Integer>::to_i64(), <P3 as Integer>::to_i64());
17029 }
17030 #[test]
17031 #[allow(non_snake_case)]
17032 fn test_P3_Gcd_N1() {
17033 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17034 type B = NInt<UInt<UTerm, B1>>;
17035 type P1 = PInt<UInt<UTerm, B1>>;
17036
17037 #[allow(non_camel_case_types)]
17038 type P3GcdN1 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
17039
17040 assert_eq!(<P3GcdN1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
17041 }
17042 #[test]
17043 #[allow(non_snake_case)]
17044 fn test_P3_Div_N1() {
17045 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17046 type B = NInt<UInt<UTerm, B1>>;
17047 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
17048
17049 #[allow(non_camel_case_types)]
17050 type P3DivN1 = <<A as Div<B>>::Output as Same<N3>>::Output;
17051
17052 assert_eq!(<P3DivN1 as Integer>::to_i64(), <N3 as Integer>::to_i64());
17053 }
17054 #[test]
17055 #[allow(non_snake_case)]
17056 fn test_P3_Rem_N1() {
17057 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17058 type B = NInt<UInt<UTerm, B1>>;
17059 type _0 = Z0;
17060
17061 #[allow(non_camel_case_types)]
17062 type P3RemN1 = <<A as Rem<B>>::Output as Same<_0>>::Output;
17063
17064 assert_eq!(<P3RemN1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
17065 }
17066 #[test]
17067 #[allow(non_snake_case)]
17068 fn test_P3_PartialDiv_N1() {
17069 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17070 type B = NInt<UInt<UTerm, B1>>;
17071 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
17072
17073 #[allow(non_camel_case_types)]
17074 type P3PartialDivN1 = <<A as PartialDiv<B>>::Output as Same<N3>>::Output;
17075
17076 assert_eq!(<P3PartialDivN1 as Integer>::to_i64(), <N3 as Integer>::to_i64());
17077 }
17078 #[test]
17079 #[allow(non_snake_case)]
17080 fn test_P3_Cmp_N1() {
17081 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17082 type B = NInt<UInt<UTerm, B1>>;
17083
17084 #[allow(non_camel_case_types)]
17085 type P3CmpN1 = <A as Cmp<B>>::Output;
17086 assert_eq!(<P3CmpN1 as Ord>::to_ordering(), Ordering::Greater);
17087 }
17088 #[test]
17089 #[allow(non_snake_case)]
17090 fn test_P3_Add__0() {
17091 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17092 type B = Z0;
17093 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
17094
17095 #[allow(non_camel_case_types)]
17096 type P3Add_0 = <<A as Add<B>>::Output as Same<P3>>::Output;
17097
17098 assert_eq!(<P3Add_0 as Integer>::to_i64(), <P3 as Integer>::to_i64());
17099 }
17100 #[test]
17101 #[allow(non_snake_case)]
17102 fn test_P3_Sub__0() {
17103 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17104 type B = Z0;
17105 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
17106
17107 #[allow(non_camel_case_types)]
17108 type P3Sub_0 = <<A as Sub<B>>::Output as Same<P3>>::Output;
17109
17110 assert_eq!(<P3Sub_0 as Integer>::to_i64(), <P3 as Integer>::to_i64());
17111 }
17112 #[test]
17113 #[allow(non_snake_case)]
17114 fn test_P3_Mul__0() {
17115 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17116 type B = Z0;
17117 type _0 = Z0;
17118
17119 #[allow(non_camel_case_types)]
17120 type P3Mul_0 = <<A as Mul<B>>::Output as Same<_0>>::Output;
17121
17122 assert_eq!(<P3Mul_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
17123 }
17124 #[test]
17125 #[allow(non_snake_case)]
17126 fn test_P3_Min__0() {
17127 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17128 type B = Z0;
17129 type _0 = Z0;
17130
17131 #[allow(non_camel_case_types)]
17132 type P3Min_0 = <<A as Min<B>>::Output as Same<_0>>::Output;
17133
17134 assert_eq!(<P3Min_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
17135 }
17136 #[test]
17137 #[allow(non_snake_case)]
17138 fn test_P3_Max__0() {
17139 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17140 type B = Z0;
17141 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
17142
17143 #[allow(non_camel_case_types)]
17144 type P3Max_0 = <<A as Max<B>>::Output as Same<P3>>::Output;
17145
17146 assert_eq!(<P3Max_0 as Integer>::to_i64(), <P3 as Integer>::to_i64());
17147 }
17148 #[test]
17149 #[allow(non_snake_case)]
17150 fn test_P3_Gcd__0() {
17151 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17152 type B = Z0;
17153 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
17154
17155 #[allow(non_camel_case_types)]
17156 type P3Gcd_0 = <<A as Gcd<B>>::Output as Same<P3>>::Output;
17157
17158 assert_eq!(<P3Gcd_0 as Integer>::to_i64(), <P3 as Integer>::to_i64());
17159 }
17160 #[test]
17161 #[allow(non_snake_case)]
17162 fn test_P3_Pow__0() {
17163 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17164 type B = Z0;
17165 type P1 = PInt<UInt<UTerm, B1>>;
17166
17167 #[allow(non_camel_case_types)]
17168 type P3Pow_0 = <<A as Pow<B>>::Output as Same<P1>>::Output;
17169
17170 assert_eq!(<P3Pow_0 as Integer>::to_i64(), <P1 as Integer>::to_i64());
17171 }
17172 #[test]
17173 #[allow(non_snake_case)]
17174 fn test_P3_Cmp__0() {
17175 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17176 type B = Z0;
17177
17178 #[allow(non_camel_case_types)]
17179 type P3Cmp_0 = <A as Cmp<B>>::Output;
17180 assert_eq!(<P3Cmp_0 as Ord>::to_ordering(), Ordering::Greater);
17181 }
17182 #[test]
17183 #[allow(non_snake_case)]
17184 fn test_P3_Add_P1() {
17185 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17186 type B = PInt<UInt<UTerm, B1>>;
17187 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17188
17189 #[allow(non_camel_case_types)]
17190 type P3AddP1 = <<A as Add<B>>::Output as Same<P4>>::Output;
17191
17192 assert_eq!(<P3AddP1 as Integer>::to_i64(), <P4 as Integer>::to_i64());
17193 }
17194 #[test]
17195 #[allow(non_snake_case)]
17196 fn test_P3_Sub_P1() {
17197 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17198 type B = PInt<UInt<UTerm, B1>>;
17199 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
17200
17201 #[allow(non_camel_case_types)]
17202 type P3SubP1 = <<A as Sub<B>>::Output as Same<P2>>::Output;
17203
17204 assert_eq!(<P3SubP1 as Integer>::to_i64(), <P2 as Integer>::to_i64());
17205 }
17206 #[test]
17207 #[allow(non_snake_case)]
17208 fn test_P3_Mul_P1() {
17209 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17210 type B = PInt<UInt<UTerm, B1>>;
17211 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
17212
17213 #[allow(non_camel_case_types)]
17214 type P3MulP1 = <<A as Mul<B>>::Output as Same<P3>>::Output;
17215
17216 assert_eq!(<P3MulP1 as Integer>::to_i64(), <P3 as Integer>::to_i64());
17217 }
17218 #[test]
17219 #[allow(non_snake_case)]
17220 fn test_P3_Min_P1() {
17221 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17222 type B = PInt<UInt<UTerm, B1>>;
17223 type P1 = PInt<UInt<UTerm, B1>>;
17224
17225 #[allow(non_camel_case_types)]
17226 type P3MinP1 = <<A as Min<B>>::Output as Same<P1>>::Output;
17227
17228 assert_eq!(<P3MinP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
17229 }
17230 #[test]
17231 #[allow(non_snake_case)]
17232 fn test_P3_Max_P1() {
17233 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17234 type B = PInt<UInt<UTerm, B1>>;
17235 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
17236
17237 #[allow(non_camel_case_types)]
17238 type P3MaxP1 = <<A as Max<B>>::Output as Same<P3>>::Output;
17239
17240 assert_eq!(<P3MaxP1 as Integer>::to_i64(), <P3 as Integer>::to_i64());
17241 }
17242 #[test]
17243 #[allow(non_snake_case)]
17244 fn test_P3_Gcd_P1() {
17245 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17246 type B = PInt<UInt<UTerm, B1>>;
17247 type P1 = PInt<UInt<UTerm, B1>>;
17248
17249 #[allow(non_camel_case_types)]
17250 type P3GcdP1 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
17251
17252 assert_eq!(<P3GcdP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
17253 }
17254 #[test]
17255 #[allow(non_snake_case)]
17256 fn test_P3_Div_P1() {
17257 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17258 type B = PInt<UInt<UTerm, B1>>;
17259 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
17260
17261 #[allow(non_camel_case_types)]
17262 type P3DivP1 = <<A as Div<B>>::Output as Same<P3>>::Output;
17263
17264 assert_eq!(<P3DivP1 as Integer>::to_i64(), <P3 as Integer>::to_i64());
17265 }
17266 #[test]
17267 #[allow(non_snake_case)]
17268 fn test_P3_Rem_P1() {
17269 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17270 type B = PInt<UInt<UTerm, B1>>;
17271 type _0 = Z0;
17272
17273 #[allow(non_camel_case_types)]
17274 type P3RemP1 = <<A as Rem<B>>::Output as Same<_0>>::Output;
17275
17276 assert_eq!(<P3RemP1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
17277 }
17278 #[test]
17279 #[allow(non_snake_case)]
17280 fn test_P3_PartialDiv_P1() {
17281 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17282 type B = PInt<UInt<UTerm, B1>>;
17283 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
17284
17285 #[allow(non_camel_case_types)]
17286 type P3PartialDivP1 = <<A as PartialDiv<B>>::Output as Same<P3>>::Output;
17287
17288 assert_eq!(<P3PartialDivP1 as Integer>::to_i64(), <P3 as Integer>::to_i64());
17289 }
17290 #[test]
17291 #[allow(non_snake_case)]
17292 fn test_P3_Pow_P1() {
17293 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17294 type B = PInt<UInt<UTerm, B1>>;
17295 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
17296
17297 #[allow(non_camel_case_types)]
17298 type P3PowP1 = <<A as Pow<B>>::Output as Same<P3>>::Output;
17299
17300 assert_eq!(<P3PowP1 as Integer>::to_i64(), <P3 as Integer>::to_i64());
17301 }
17302 #[test]
17303 #[allow(non_snake_case)]
17304 fn test_P3_Cmp_P1() {
17305 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17306 type B = PInt<UInt<UTerm, B1>>;
17307
17308 #[allow(non_camel_case_types)]
17309 type P3CmpP1 = <A as Cmp<B>>::Output;
17310 assert_eq!(<P3CmpP1 as Ord>::to_ordering(), Ordering::Greater);
17311 }
17312 #[test]
17313 #[allow(non_snake_case)]
17314 fn test_P3_Add_P2() {
17315 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17316 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
17317 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
17318
17319 #[allow(non_camel_case_types)]
17320 type P3AddP2 = <<A as Add<B>>::Output as Same<P5>>::Output;
17321
17322 assert_eq!(<P3AddP2 as Integer>::to_i64(), <P5 as Integer>::to_i64());
17323 }
17324 #[test]
17325 #[allow(non_snake_case)]
17326 fn test_P3_Sub_P2() {
17327 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17328 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
17329 type P1 = PInt<UInt<UTerm, B1>>;
17330
17331 #[allow(non_camel_case_types)]
17332 type P3SubP2 = <<A as Sub<B>>::Output as Same<P1>>::Output;
17333
17334 assert_eq!(<P3SubP2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
17335 }
17336 #[test]
17337 #[allow(non_snake_case)]
17338 fn test_P3_Mul_P2() {
17339 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17340 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
17341 type P6 = PInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
17342
17343 #[allow(non_camel_case_types)]
17344 type P3MulP2 = <<A as Mul<B>>::Output as Same<P6>>::Output;
17345
17346 assert_eq!(<P3MulP2 as Integer>::to_i64(), <P6 as Integer>::to_i64());
17347 }
17348 #[test]
17349 #[allow(non_snake_case)]
17350 fn test_P3_Min_P2() {
17351 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17352 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
17353 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
17354
17355 #[allow(non_camel_case_types)]
17356 type P3MinP2 = <<A as Min<B>>::Output as Same<P2>>::Output;
17357
17358 assert_eq!(<P3MinP2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
17359 }
17360 #[test]
17361 #[allow(non_snake_case)]
17362 fn test_P3_Max_P2() {
17363 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17364 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
17365 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
17366
17367 #[allow(non_camel_case_types)]
17368 type P3MaxP2 = <<A as Max<B>>::Output as Same<P3>>::Output;
17369
17370 assert_eq!(<P3MaxP2 as Integer>::to_i64(), <P3 as Integer>::to_i64());
17371 }
17372 #[test]
17373 #[allow(non_snake_case)]
17374 fn test_P3_Gcd_P2() {
17375 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17376 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
17377 type P1 = PInt<UInt<UTerm, B1>>;
17378
17379 #[allow(non_camel_case_types)]
17380 type P3GcdP2 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
17381
17382 assert_eq!(<P3GcdP2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
17383 }
17384 #[test]
17385 #[allow(non_snake_case)]
17386 fn test_P3_Div_P2() {
17387 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17388 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
17389 type P1 = PInt<UInt<UTerm, B1>>;
17390
17391 #[allow(non_camel_case_types)]
17392 type P3DivP2 = <<A as Div<B>>::Output as Same<P1>>::Output;
17393
17394 assert_eq!(<P3DivP2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
17395 }
17396 #[test]
17397 #[allow(non_snake_case)]
17398 fn test_P3_Rem_P2() {
17399 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17400 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
17401 type P1 = PInt<UInt<UTerm, B1>>;
17402
17403 #[allow(non_camel_case_types)]
17404 type P3RemP2 = <<A as Rem<B>>::Output as Same<P1>>::Output;
17405
17406 assert_eq!(<P3RemP2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
17407 }
17408 #[test]
17409 #[allow(non_snake_case)]
17410 fn test_P3_Pow_P2() {
17411 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17412 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
17413 type P9 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>>;
17414
17415 #[allow(non_camel_case_types)]
17416 type P3PowP2 = <<A as Pow<B>>::Output as Same<P9>>::Output;
17417
17418 assert_eq!(<P3PowP2 as Integer>::to_i64(), <P9 as Integer>::to_i64());
17419 }
17420 #[test]
17421 #[allow(non_snake_case)]
17422 fn test_P3_Cmp_P2() {
17423 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17424 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
17425
17426 #[allow(non_camel_case_types)]
17427 type P3CmpP2 = <A as Cmp<B>>::Output;
17428 assert_eq!(<P3CmpP2 as Ord>::to_ordering(), Ordering::Greater);
17429 }
17430 #[test]
17431 #[allow(non_snake_case)]
17432 fn test_P3_Add_P3() {
17433 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17434 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
17435 type P6 = PInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
17436
17437 #[allow(non_camel_case_types)]
17438 type P3AddP3 = <<A as Add<B>>::Output as Same<P6>>::Output;
17439
17440 assert_eq!(<P3AddP3 as Integer>::to_i64(), <P6 as Integer>::to_i64());
17441 }
17442 #[test]
17443 #[allow(non_snake_case)]
17444 fn test_P3_Sub_P3() {
17445 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17446 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
17447 type _0 = Z0;
17448
17449 #[allow(non_camel_case_types)]
17450 type P3SubP3 = <<A as Sub<B>>::Output as Same<_0>>::Output;
17451
17452 assert_eq!(<P3SubP3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
17453 }
17454 #[test]
17455 #[allow(non_snake_case)]
17456 fn test_P3_Mul_P3() {
17457 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17458 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
17459 type P9 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>>;
17460
17461 #[allow(non_camel_case_types)]
17462 type P3MulP3 = <<A as Mul<B>>::Output as Same<P9>>::Output;
17463
17464 assert_eq!(<P3MulP3 as Integer>::to_i64(), <P9 as Integer>::to_i64());
17465 }
17466 #[test]
17467 #[allow(non_snake_case)]
17468 fn test_P3_Min_P3() {
17469 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17470 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
17471 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
17472
17473 #[allow(non_camel_case_types)]
17474 type P3MinP3 = <<A as Min<B>>::Output as Same<P3>>::Output;
17475
17476 assert_eq!(<P3MinP3 as Integer>::to_i64(), <P3 as Integer>::to_i64());
17477 }
17478 #[test]
17479 #[allow(non_snake_case)]
17480 fn test_P3_Max_P3() {
17481 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17482 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
17483 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
17484
17485 #[allow(non_camel_case_types)]
17486 type P3MaxP3 = <<A as Max<B>>::Output as Same<P3>>::Output;
17487
17488 assert_eq!(<P3MaxP3 as Integer>::to_i64(), <P3 as Integer>::to_i64());
17489 }
17490 #[test]
17491 #[allow(non_snake_case)]
17492 fn test_P3_Gcd_P3() {
17493 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17494 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
17495 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
17496
17497 #[allow(non_camel_case_types)]
17498 type P3GcdP3 = <<A as Gcd<B>>::Output as Same<P3>>::Output;
17499
17500 assert_eq!(<P3GcdP3 as Integer>::to_i64(), <P3 as Integer>::to_i64());
17501 }
17502 #[test]
17503 #[allow(non_snake_case)]
17504 fn test_P3_Div_P3() {
17505 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17506 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
17507 type P1 = PInt<UInt<UTerm, B1>>;
17508
17509 #[allow(non_camel_case_types)]
17510 type P3DivP3 = <<A as Div<B>>::Output as Same<P1>>::Output;
17511
17512 assert_eq!(<P3DivP3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
17513 }
17514 #[test]
17515 #[allow(non_snake_case)]
17516 fn test_P3_Rem_P3() {
17517 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17518 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
17519 type _0 = Z0;
17520
17521 #[allow(non_camel_case_types)]
17522 type P3RemP3 = <<A as Rem<B>>::Output as Same<_0>>::Output;
17523
17524 assert_eq!(<P3RemP3 as Integer>::to_i64(), <_0 as Integer>::to_i64());
17525 }
17526 #[test]
17527 #[allow(non_snake_case)]
17528 fn test_P3_PartialDiv_P3() {
17529 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17530 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
17531 type P1 = PInt<UInt<UTerm, B1>>;
17532
17533 #[allow(non_camel_case_types)]
17534 type P3PartialDivP3 = <<A as PartialDiv<B>>::Output as Same<P1>>::Output;
17535
17536 assert_eq!(<P3PartialDivP3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
17537 }
17538 #[test]
17539 #[allow(non_snake_case)]
17540 fn test_P3_Pow_P3() {
17541 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17542 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
17543 type P27 = PInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B1>, B1>>;
17544
17545 #[allow(non_camel_case_types)]
17546 type P3PowP3 = <<A as Pow<B>>::Output as Same<P27>>::Output;
17547
17548 assert_eq!(<P3PowP3 as Integer>::to_i64(), <P27 as Integer>::to_i64());
17549 }
17550 #[test]
17551 #[allow(non_snake_case)]
17552 fn test_P3_Cmp_P3() {
17553 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17554 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
17555
17556 #[allow(non_camel_case_types)]
17557 type P3CmpP3 = <A as Cmp<B>>::Output;
17558 assert_eq!(<P3CmpP3 as Ord>::to_ordering(), Ordering::Equal);
17559 }
17560 #[test]
17561 #[allow(non_snake_case)]
17562 fn test_P3_Add_P4() {
17563 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17564 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17565 type P7 = PInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>>;
17566
17567 #[allow(non_camel_case_types)]
17568 type P3AddP4 = <<A as Add<B>>::Output as Same<P7>>::Output;
17569
17570 assert_eq!(<P3AddP4 as Integer>::to_i64(), <P7 as Integer>::to_i64());
17571 }
17572 #[test]
17573 #[allow(non_snake_case)]
17574 fn test_P3_Sub_P4() {
17575 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17576 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17577 type N1 = NInt<UInt<UTerm, B1>>;
17578
17579 #[allow(non_camel_case_types)]
17580 type P3SubP4 = <<A as Sub<B>>::Output as Same<N1>>::Output;
17581
17582 assert_eq!(<P3SubP4 as Integer>::to_i64(), <N1 as Integer>::to_i64());
17583 }
17584 #[test]
17585 #[allow(non_snake_case)]
17586 fn test_P3_Mul_P4() {
17587 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17588 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17589 type P12 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>>;
17590
17591 #[allow(non_camel_case_types)]
17592 type P3MulP4 = <<A as Mul<B>>::Output as Same<P12>>::Output;
17593
17594 assert_eq!(<P3MulP4 as Integer>::to_i64(), <P12 as Integer>::to_i64());
17595 }
17596 #[test]
17597 #[allow(non_snake_case)]
17598 fn test_P3_Min_P4() {
17599 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17600 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17601 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
17602
17603 #[allow(non_camel_case_types)]
17604 type P3MinP4 = <<A as Min<B>>::Output as Same<P3>>::Output;
17605
17606 assert_eq!(<P3MinP4 as Integer>::to_i64(), <P3 as Integer>::to_i64());
17607 }
17608 #[test]
17609 #[allow(non_snake_case)]
17610 fn test_P3_Max_P4() {
17611 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17612 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17613 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17614
17615 #[allow(non_camel_case_types)]
17616 type P3MaxP4 = <<A as Max<B>>::Output as Same<P4>>::Output;
17617
17618 assert_eq!(<P3MaxP4 as Integer>::to_i64(), <P4 as Integer>::to_i64());
17619 }
17620 #[test]
17621 #[allow(non_snake_case)]
17622 fn test_P3_Gcd_P4() {
17623 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17624 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17625 type P1 = PInt<UInt<UTerm, B1>>;
17626
17627 #[allow(non_camel_case_types)]
17628 type P3GcdP4 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
17629
17630 assert_eq!(<P3GcdP4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
17631 }
17632 #[test]
17633 #[allow(non_snake_case)]
17634 fn test_P3_Div_P4() {
17635 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17636 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17637 type _0 = Z0;
17638
17639 #[allow(non_camel_case_types)]
17640 type P3DivP4 = <<A as Div<B>>::Output as Same<_0>>::Output;
17641
17642 assert_eq!(<P3DivP4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
17643 }
17644 #[test]
17645 #[allow(non_snake_case)]
17646 fn test_P3_Rem_P4() {
17647 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17648 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17649 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
17650
17651 #[allow(non_camel_case_types)]
17652 type P3RemP4 = <<A as Rem<B>>::Output as Same<P3>>::Output;
17653
17654 assert_eq!(<P3RemP4 as Integer>::to_i64(), <P3 as Integer>::to_i64());
17655 }
17656 #[test]
17657 #[allow(non_snake_case)]
17658 fn test_P3_Pow_P4() {
17659 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17660 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17661 type P81 = PInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>, B0>, B1>>;
17662
17663 #[allow(non_camel_case_types)]
17664 type P3PowP4 = <<A as Pow<B>>::Output as Same<P81>>::Output;
17665
17666 assert_eq!(<P3PowP4 as Integer>::to_i64(), <P81 as Integer>::to_i64());
17667 }
17668 #[test]
17669 #[allow(non_snake_case)]
17670 fn test_P3_Cmp_P4() {
17671 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17672 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17673
17674 #[allow(non_camel_case_types)]
17675 type P3CmpP4 = <A as Cmp<B>>::Output;
17676 assert_eq!(<P3CmpP4 as Ord>::to_ordering(), Ordering::Less);
17677 }
17678 #[test]
17679 #[allow(non_snake_case)]
17680 fn test_P3_Add_P5() {
17681 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17682 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
17683 type P8 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>;
17684
17685 #[allow(non_camel_case_types)]
17686 type P3AddP5 = <<A as Add<B>>::Output as Same<P8>>::Output;
17687
17688 assert_eq!(<P3AddP5 as Integer>::to_i64(), <P8 as Integer>::to_i64());
17689 }
17690 #[test]
17691 #[allow(non_snake_case)]
17692 fn test_P3_Sub_P5() {
17693 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17694 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
17695 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
17696
17697 #[allow(non_camel_case_types)]
17698 type P3SubP5 = <<A as Sub<B>>::Output as Same<N2>>::Output;
17699
17700 assert_eq!(<P3SubP5 as Integer>::to_i64(), <N2 as Integer>::to_i64());
17701 }
17702 #[test]
17703 #[allow(non_snake_case)]
17704 fn test_P3_Mul_P5() {
17705 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17706 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
17707 type P15 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>;
17708
17709 #[allow(non_camel_case_types)]
17710 type P3MulP5 = <<A as Mul<B>>::Output as Same<P15>>::Output;
17711
17712 assert_eq!(<P3MulP5 as Integer>::to_i64(), <P15 as Integer>::to_i64());
17713 }
17714 #[test]
17715 #[allow(non_snake_case)]
17716 fn test_P3_Min_P5() {
17717 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17718 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
17719 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
17720
17721 #[allow(non_camel_case_types)]
17722 type P3MinP5 = <<A as Min<B>>::Output as Same<P3>>::Output;
17723
17724 assert_eq!(<P3MinP5 as Integer>::to_i64(), <P3 as Integer>::to_i64());
17725 }
17726 #[test]
17727 #[allow(non_snake_case)]
17728 fn test_P3_Max_P5() {
17729 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17730 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
17731 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
17732
17733 #[allow(non_camel_case_types)]
17734 type P3MaxP5 = <<A as Max<B>>::Output as Same<P5>>::Output;
17735
17736 assert_eq!(<P3MaxP5 as Integer>::to_i64(), <P5 as Integer>::to_i64());
17737 }
17738 #[test]
17739 #[allow(non_snake_case)]
17740 fn test_P3_Gcd_P5() {
17741 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17742 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
17743 type P1 = PInt<UInt<UTerm, B1>>;
17744
17745 #[allow(non_camel_case_types)]
17746 type P3GcdP5 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
17747
17748 assert_eq!(<P3GcdP5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
17749 }
17750 #[test]
17751 #[allow(non_snake_case)]
17752 fn test_P3_Div_P5() {
17753 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17754 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
17755 type _0 = Z0;
17756
17757 #[allow(non_camel_case_types)]
17758 type P3DivP5 = <<A as Div<B>>::Output as Same<_0>>::Output;
17759
17760 assert_eq!(<P3DivP5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
17761 }
17762 #[test]
17763 #[allow(non_snake_case)]
17764 fn test_P3_Rem_P5() {
17765 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17766 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
17767 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
17768
17769 #[allow(non_camel_case_types)]
17770 type P3RemP5 = <<A as Rem<B>>::Output as Same<P3>>::Output;
17771
17772 assert_eq!(<P3RemP5 as Integer>::to_i64(), <P3 as Integer>::to_i64());
17773 }
17774 #[test]
17775 #[allow(non_snake_case)]
17776 fn test_P3_Pow_P5() {
17777 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17778 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
17779 type P243 = PInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B0>, B0>, B1>, B1>>;
17780
17781 #[allow(non_camel_case_types)]
17782 type P3PowP5 = <<A as Pow<B>>::Output as Same<P243>>::Output;
17783
17784 assert_eq!(<P3PowP5 as Integer>::to_i64(), <P243 as Integer>::to_i64());
17785 }
17786 #[test]
17787 #[allow(non_snake_case)]
17788 fn test_P3_Cmp_P5() {
17789 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
17790 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
17791
17792 #[allow(non_camel_case_types)]
17793 type P3CmpP5 = <A as Cmp<B>>::Output;
17794 assert_eq!(<P3CmpP5 as Ord>::to_ordering(), Ordering::Less);
17795 }
17796 #[test]
17797 #[allow(non_snake_case)]
17798 fn test_P4_Add_N5() {
17799 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17800 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
17801 type N1 = NInt<UInt<UTerm, B1>>;
17802
17803 #[allow(non_camel_case_types)]
17804 type P4AddN5 = <<A as Add<B>>::Output as Same<N1>>::Output;
17805
17806 assert_eq!(<P4AddN5 as Integer>::to_i64(), <N1 as Integer>::to_i64());
17807 }
17808 #[test]
17809 #[allow(non_snake_case)]
17810 fn test_P4_Sub_N5() {
17811 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17812 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
17813 type P9 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>>;
17814
17815 #[allow(non_camel_case_types)]
17816 type P4SubN5 = <<A as Sub<B>>::Output as Same<P9>>::Output;
17817
17818 assert_eq!(<P4SubN5 as Integer>::to_i64(), <P9 as Integer>::to_i64());
17819 }
17820 #[test]
17821 #[allow(non_snake_case)]
17822 fn test_P4_Mul_N5() {
17823 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17824 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
17825 type N20 = NInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>>;
17826
17827 #[allow(non_camel_case_types)]
17828 type P4MulN5 = <<A as Mul<B>>::Output as Same<N20>>::Output;
17829
17830 assert_eq!(<P4MulN5 as Integer>::to_i64(), <N20 as Integer>::to_i64());
17831 }
17832 #[test]
17833 #[allow(non_snake_case)]
17834 fn test_P4_Min_N5() {
17835 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17836 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
17837 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
17838
17839 #[allow(non_camel_case_types)]
17840 type P4MinN5 = <<A as Min<B>>::Output as Same<N5>>::Output;
17841
17842 assert_eq!(<P4MinN5 as Integer>::to_i64(), <N5 as Integer>::to_i64());
17843 }
17844 #[test]
17845 #[allow(non_snake_case)]
17846 fn test_P4_Max_N5() {
17847 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17848 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
17849 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17850
17851 #[allow(non_camel_case_types)]
17852 type P4MaxN5 = <<A as Max<B>>::Output as Same<P4>>::Output;
17853
17854 assert_eq!(<P4MaxN5 as Integer>::to_i64(), <P4 as Integer>::to_i64());
17855 }
17856 #[test]
17857 #[allow(non_snake_case)]
17858 fn test_P4_Gcd_N5() {
17859 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17860 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
17861 type P1 = PInt<UInt<UTerm, B1>>;
17862
17863 #[allow(non_camel_case_types)]
17864 type P4GcdN5 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
17865
17866 assert_eq!(<P4GcdN5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
17867 }
17868 #[test]
17869 #[allow(non_snake_case)]
17870 fn test_P4_Div_N5() {
17871 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17872 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
17873 type _0 = Z0;
17874
17875 #[allow(non_camel_case_types)]
17876 type P4DivN5 = <<A as Div<B>>::Output as Same<_0>>::Output;
17877
17878 assert_eq!(<P4DivN5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
17879 }
17880 #[test]
17881 #[allow(non_snake_case)]
17882 fn test_P4_Rem_N5() {
17883 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17884 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
17885 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17886
17887 #[allow(non_camel_case_types)]
17888 type P4RemN5 = <<A as Rem<B>>::Output as Same<P4>>::Output;
17889
17890 assert_eq!(<P4RemN5 as Integer>::to_i64(), <P4 as Integer>::to_i64());
17891 }
17892 #[test]
17893 #[allow(non_snake_case)]
17894 fn test_P4_Cmp_N5() {
17895 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17896 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
17897
17898 #[allow(non_camel_case_types)]
17899 type P4CmpN5 = <A as Cmp<B>>::Output;
17900 assert_eq!(<P4CmpN5 as Ord>::to_ordering(), Ordering::Greater);
17901 }
17902 #[test]
17903 #[allow(non_snake_case)]
17904 fn test_P4_Add_N4() {
17905 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17906 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17907 type _0 = Z0;
17908
17909 #[allow(non_camel_case_types)]
17910 type P4AddN4 = <<A as Add<B>>::Output as Same<_0>>::Output;
17911
17912 assert_eq!(<P4AddN4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
17913 }
17914 #[test]
17915 #[allow(non_snake_case)]
17916 fn test_P4_Sub_N4() {
17917 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17918 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17919 type P8 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>;
17920
17921 #[allow(non_camel_case_types)]
17922 type P4SubN4 = <<A as Sub<B>>::Output as Same<P8>>::Output;
17923
17924 assert_eq!(<P4SubN4 as Integer>::to_i64(), <P8 as Integer>::to_i64());
17925 }
17926 #[test]
17927 #[allow(non_snake_case)]
17928 fn test_P4_Mul_N4() {
17929 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17930 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17931 type N16 = NInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>>;
17932
17933 #[allow(non_camel_case_types)]
17934 type P4MulN4 = <<A as Mul<B>>::Output as Same<N16>>::Output;
17935
17936 assert_eq!(<P4MulN4 as Integer>::to_i64(), <N16 as Integer>::to_i64());
17937 }
17938 #[test]
17939 #[allow(non_snake_case)]
17940 fn test_P4_Min_N4() {
17941 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17942 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17943 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17944
17945 #[allow(non_camel_case_types)]
17946 type P4MinN4 = <<A as Min<B>>::Output as Same<N4>>::Output;
17947
17948 assert_eq!(<P4MinN4 as Integer>::to_i64(), <N4 as Integer>::to_i64());
17949 }
17950 #[test]
17951 #[allow(non_snake_case)]
17952 fn test_P4_Max_N4() {
17953 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17954 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17955 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17956
17957 #[allow(non_camel_case_types)]
17958 type P4MaxN4 = <<A as Max<B>>::Output as Same<P4>>::Output;
17959
17960 assert_eq!(<P4MaxN4 as Integer>::to_i64(), <P4 as Integer>::to_i64());
17961 }
17962 #[test]
17963 #[allow(non_snake_case)]
17964 fn test_P4_Gcd_N4() {
17965 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17966 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17967 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17968
17969 #[allow(non_camel_case_types)]
17970 type P4GcdN4 = <<A as Gcd<B>>::Output as Same<P4>>::Output;
17971
17972 assert_eq!(<P4GcdN4 as Integer>::to_i64(), <P4 as Integer>::to_i64());
17973 }
17974 #[test]
17975 #[allow(non_snake_case)]
17976 fn test_P4_Div_N4() {
17977 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17978 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17979 type N1 = NInt<UInt<UTerm, B1>>;
17980
17981 #[allow(non_camel_case_types)]
17982 type P4DivN4 = <<A as Div<B>>::Output as Same<N1>>::Output;
17983
17984 assert_eq!(<P4DivN4 as Integer>::to_i64(), <N1 as Integer>::to_i64());
17985 }
17986 #[test]
17987 #[allow(non_snake_case)]
17988 fn test_P4_Rem_N4() {
17989 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17990 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
17991 type _0 = Z0;
17992
17993 #[allow(non_camel_case_types)]
17994 type P4RemN4 = <<A as Rem<B>>::Output as Same<_0>>::Output;
17995
17996 assert_eq!(<P4RemN4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
17997 }
17998 #[test]
17999 #[allow(non_snake_case)]
18000 fn test_P4_PartialDiv_N4() {
18001 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18002 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18003 type N1 = NInt<UInt<UTerm, B1>>;
18004
18005 #[allow(non_camel_case_types)]
18006 type P4PartialDivN4 = <<A as PartialDiv<B>>::Output as Same<N1>>::Output;
18007
18008 assert_eq!(<P4PartialDivN4 as Integer>::to_i64(), <N1 as Integer>::to_i64());
18009 }
18010 #[test]
18011 #[allow(non_snake_case)]
18012 fn test_P4_Cmp_N4() {
18013 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18014 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18015
18016 #[allow(non_camel_case_types)]
18017 type P4CmpN4 = <A as Cmp<B>>::Output;
18018 assert_eq!(<P4CmpN4 as Ord>::to_ordering(), Ordering::Greater);
18019 }
18020 #[test]
18021 #[allow(non_snake_case)]
18022 fn test_P4_Add_N3() {
18023 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18024 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
18025 type P1 = PInt<UInt<UTerm, B1>>;
18026
18027 #[allow(non_camel_case_types)]
18028 type P4AddN3 = <<A as Add<B>>::Output as Same<P1>>::Output;
18029
18030 assert_eq!(<P4AddN3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
18031 }
18032 #[test]
18033 #[allow(non_snake_case)]
18034 fn test_P4_Sub_N3() {
18035 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18036 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
18037 type P7 = PInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>>;
18038
18039 #[allow(non_camel_case_types)]
18040 type P4SubN3 = <<A as Sub<B>>::Output as Same<P7>>::Output;
18041
18042 assert_eq!(<P4SubN3 as Integer>::to_i64(), <P7 as Integer>::to_i64());
18043 }
18044 #[test]
18045 #[allow(non_snake_case)]
18046 fn test_P4_Mul_N3() {
18047 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18048 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
18049 type N12 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>>;
18050
18051 #[allow(non_camel_case_types)]
18052 type P4MulN3 = <<A as Mul<B>>::Output as Same<N12>>::Output;
18053
18054 assert_eq!(<P4MulN3 as Integer>::to_i64(), <N12 as Integer>::to_i64());
18055 }
18056 #[test]
18057 #[allow(non_snake_case)]
18058 fn test_P4_Min_N3() {
18059 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18060 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
18061 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
18062
18063 #[allow(non_camel_case_types)]
18064 type P4MinN3 = <<A as Min<B>>::Output as Same<N3>>::Output;
18065
18066 assert_eq!(<P4MinN3 as Integer>::to_i64(), <N3 as Integer>::to_i64());
18067 }
18068 #[test]
18069 #[allow(non_snake_case)]
18070 fn test_P4_Max_N3() {
18071 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18072 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
18073 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18074
18075 #[allow(non_camel_case_types)]
18076 type P4MaxN3 = <<A as Max<B>>::Output as Same<P4>>::Output;
18077
18078 assert_eq!(<P4MaxN3 as Integer>::to_i64(), <P4 as Integer>::to_i64());
18079 }
18080 #[test]
18081 #[allow(non_snake_case)]
18082 fn test_P4_Gcd_N3() {
18083 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18084 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
18085 type P1 = PInt<UInt<UTerm, B1>>;
18086
18087 #[allow(non_camel_case_types)]
18088 type P4GcdN3 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
18089
18090 assert_eq!(<P4GcdN3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
18091 }
18092 #[test]
18093 #[allow(non_snake_case)]
18094 fn test_P4_Div_N3() {
18095 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18096 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
18097 type N1 = NInt<UInt<UTerm, B1>>;
18098
18099 #[allow(non_camel_case_types)]
18100 type P4DivN3 = <<A as Div<B>>::Output as Same<N1>>::Output;
18101
18102 assert_eq!(<P4DivN3 as Integer>::to_i64(), <N1 as Integer>::to_i64());
18103 }
18104 #[test]
18105 #[allow(non_snake_case)]
18106 fn test_P4_Rem_N3() {
18107 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18108 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
18109 type P1 = PInt<UInt<UTerm, B1>>;
18110
18111 #[allow(non_camel_case_types)]
18112 type P4RemN3 = <<A as Rem<B>>::Output as Same<P1>>::Output;
18113
18114 assert_eq!(<P4RemN3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
18115 }
18116 #[test]
18117 #[allow(non_snake_case)]
18118 fn test_P4_Cmp_N3() {
18119 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18120 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
18121
18122 #[allow(non_camel_case_types)]
18123 type P4CmpN3 = <A as Cmp<B>>::Output;
18124 assert_eq!(<P4CmpN3 as Ord>::to_ordering(), Ordering::Greater);
18125 }
18126 #[test]
18127 #[allow(non_snake_case)]
18128 fn test_P4_Add_N2() {
18129 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18130 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
18131 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
18132
18133 #[allow(non_camel_case_types)]
18134 type P4AddN2 = <<A as Add<B>>::Output as Same<P2>>::Output;
18135
18136 assert_eq!(<P4AddN2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
18137 }
18138 #[test]
18139 #[allow(non_snake_case)]
18140 fn test_P4_Sub_N2() {
18141 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18142 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
18143 type P6 = PInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
18144
18145 #[allow(non_camel_case_types)]
18146 type P4SubN2 = <<A as Sub<B>>::Output as Same<P6>>::Output;
18147
18148 assert_eq!(<P4SubN2 as Integer>::to_i64(), <P6 as Integer>::to_i64());
18149 }
18150 #[test]
18151 #[allow(non_snake_case)]
18152 fn test_P4_Mul_N2() {
18153 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18154 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
18155 type N8 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>;
18156
18157 #[allow(non_camel_case_types)]
18158 type P4MulN2 = <<A as Mul<B>>::Output as Same<N8>>::Output;
18159
18160 assert_eq!(<P4MulN2 as Integer>::to_i64(), <N8 as Integer>::to_i64());
18161 }
18162 #[test]
18163 #[allow(non_snake_case)]
18164 fn test_P4_Min_N2() {
18165 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18166 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
18167 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
18168
18169 #[allow(non_camel_case_types)]
18170 type P4MinN2 = <<A as Min<B>>::Output as Same<N2>>::Output;
18171
18172 assert_eq!(<P4MinN2 as Integer>::to_i64(), <N2 as Integer>::to_i64());
18173 }
18174 #[test]
18175 #[allow(non_snake_case)]
18176 fn test_P4_Max_N2() {
18177 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18178 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
18179 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18180
18181 #[allow(non_camel_case_types)]
18182 type P4MaxN2 = <<A as Max<B>>::Output as Same<P4>>::Output;
18183
18184 assert_eq!(<P4MaxN2 as Integer>::to_i64(), <P4 as Integer>::to_i64());
18185 }
18186 #[test]
18187 #[allow(non_snake_case)]
18188 fn test_P4_Gcd_N2() {
18189 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18190 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
18191 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
18192
18193 #[allow(non_camel_case_types)]
18194 type P4GcdN2 = <<A as Gcd<B>>::Output as Same<P2>>::Output;
18195
18196 assert_eq!(<P4GcdN2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
18197 }
18198 #[test]
18199 #[allow(non_snake_case)]
18200 fn test_P4_Div_N2() {
18201 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18202 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
18203 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
18204
18205 #[allow(non_camel_case_types)]
18206 type P4DivN2 = <<A as Div<B>>::Output as Same<N2>>::Output;
18207
18208 assert_eq!(<P4DivN2 as Integer>::to_i64(), <N2 as Integer>::to_i64());
18209 }
18210 #[test]
18211 #[allow(non_snake_case)]
18212 fn test_P4_Rem_N2() {
18213 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18214 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
18215 type _0 = Z0;
18216
18217 #[allow(non_camel_case_types)]
18218 type P4RemN2 = <<A as Rem<B>>::Output as Same<_0>>::Output;
18219
18220 assert_eq!(<P4RemN2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
18221 }
18222 #[test]
18223 #[allow(non_snake_case)]
18224 fn test_P4_PartialDiv_N2() {
18225 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18226 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
18227 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
18228
18229 #[allow(non_camel_case_types)]
18230 type P4PartialDivN2 = <<A as PartialDiv<B>>::Output as Same<N2>>::Output;
18231
18232 assert_eq!(<P4PartialDivN2 as Integer>::to_i64(), <N2 as Integer>::to_i64());
18233 }
18234 #[test]
18235 #[allow(non_snake_case)]
18236 fn test_P4_Cmp_N2() {
18237 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18238 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
18239
18240 #[allow(non_camel_case_types)]
18241 type P4CmpN2 = <A as Cmp<B>>::Output;
18242 assert_eq!(<P4CmpN2 as Ord>::to_ordering(), Ordering::Greater);
18243 }
18244 #[test]
18245 #[allow(non_snake_case)]
18246 fn test_P4_Add_N1() {
18247 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18248 type B = NInt<UInt<UTerm, B1>>;
18249 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
18250
18251 #[allow(non_camel_case_types)]
18252 type P4AddN1 = <<A as Add<B>>::Output as Same<P3>>::Output;
18253
18254 assert_eq!(<P4AddN1 as Integer>::to_i64(), <P3 as Integer>::to_i64());
18255 }
18256 #[test]
18257 #[allow(non_snake_case)]
18258 fn test_P4_Sub_N1() {
18259 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18260 type B = NInt<UInt<UTerm, B1>>;
18261 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
18262
18263 #[allow(non_camel_case_types)]
18264 type P4SubN1 = <<A as Sub<B>>::Output as Same<P5>>::Output;
18265
18266 assert_eq!(<P4SubN1 as Integer>::to_i64(), <P5 as Integer>::to_i64());
18267 }
18268 #[test]
18269 #[allow(non_snake_case)]
18270 fn test_P4_Mul_N1() {
18271 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18272 type B = NInt<UInt<UTerm, B1>>;
18273 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18274
18275 #[allow(non_camel_case_types)]
18276 type P4MulN1 = <<A as Mul<B>>::Output as Same<N4>>::Output;
18277
18278 assert_eq!(<P4MulN1 as Integer>::to_i64(), <N4 as Integer>::to_i64());
18279 }
18280 #[test]
18281 #[allow(non_snake_case)]
18282 fn test_P4_Min_N1() {
18283 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18284 type B = NInt<UInt<UTerm, B1>>;
18285 type N1 = NInt<UInt<UTerm, B1>>;
18286
18287 #[allow(non_camel_case_types)]
18288 type P4MinN1 = <<A as Min<B>>::Output as Same<N1>>::Output;
18289
18290 assert_eq!(<P4MinN1 as Integer>::to_i64(), <N1 as Integer>::to_i64());
18291 }
18292 #[test]
18293 #[allow(non_snake_case)]
18294 fn test_P4_Max_N1() {
18295 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18296 type B = NInt<UInt<UTerm, B1>>;
18297 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18298
18299 #[allow(non_camel_case_types)]
18300 type P4MaxN1 = <<A as Max<B>>::Output as Same<P4>>::Output;
18301
18302 assert_eq!(<P4MaxN1 as Integer>::to_i64(), <P4 as Integer>::to_i64());
18303 }
18304 #[test]
18305 #[allow(non_snake_case)]
18306 fn test_P4_Gcd_N1() {
18307 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18308 type B = NInt<UInt<UTerm, B1>>;
18309 type P1 = PInt<UInt<UTerm, B1>>;
18310
18311 #[allow(non_camel_case_types)]
18312 type P4GcdN1 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
18313
18314 assert_eq!(<P4GcdN1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
18315 }
18316 #[test]
18317 #[allow(non_snake_case)]
18318 fn test_P4_Div_N1() {
18319 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18320 type B = NInt<UInt<UTerm, B1>>;
18321 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18322
18323 #[allow(non_camel_case_types)]
18324 type P4DivN1 = <<A as Div<B>>::Output as Same<N4>>::Output;
18325
18326 assert_eq!(<P4DivN1 as Integer>::to_i64(), <N4 as Integer>::to_i64());
18327 }
18328 #[test]
18329 #[allow(non_snake_case)]
18330 fn test_P4_Rem_N1() {
18331 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18332 type B = NInt<UInt<UTerm, B1>>;
18333 type _0 = Z0;
18334
18335 #[allow(non_camel_case_types)]
18336 type P4RemN1 = <<A as Rem<B>>::Output as Same<_0>>::Output;
18337
18338 assert_eq!(<P4RemN1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
18339 }
18340 #[test]
18341 #[allow(non_snake_case)]
18342 fn test_P4_PartialDiv_N1() {
18343 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18344 type B = NInt<UInt<UTerm, B1>>;
18345 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18346
18347 #[allow(non_camel_case_types)]
18348 type P4PartialDivN1 = <<A as PartialDiv<B>>::Output as Same<N4>>::Output;
18349
18350 assert_eq!(<P4PartialDivN1 as Integer>::to_i64(), <N4 as Integer>::to_i64());
18351 }
18352 #[test]
18353 #[allow(non_snake_case)]
18354 fn test_P4_Cmp_N1() {
18355 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18356 type B = NInt<UInt<UTerm, B1>>;
18357
18358 #[allow(non_camel_case_types)]
18359 type P4CmpN1 = <A as Cmp<B>>::Output;
18360 assert_eq!(<P4CmpN1 as Ord>::to_ordering(), Ordering::Greater);
18361 }
18362 #[test]
18363 #[allow(non_snake_case)]
18364 fn test_P4_Add__0() {
18365 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18366 type B = Z0;
18367 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18368
18369 #[allow(non_camel_case_types)]
18370 type P4Add_0 = <<A as Add<B>>::Output as Same<P4>>::Output;
18371
18372 assert_eq!(<P4Add_0 as Integer>::to_i64(), <P4 as Integer>::to_i64());
18373 }
18374 #[test]
18375 #[allow(non_snake_case)]
18376 fn test_P4_Sub__0() {
18377 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18378 type B = Z0;
18379 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18380
18381 #[allow(non_camel_case_types)]
18382 type P4Sub_0 = <<A as Sub<B>>::Output as Same<P4>>::Output;
18383
18384 assert_eq!(<P4Sub_0 as Integer>::to_i64(), <P4 as Integer>::to_i64());
18385 }
18386 #[test]
18387 #[allow(non_snake_case)]
18388 fn test_P4_Mul__0() {
18389 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18390 type B = Z0;
18391 type _0 = Z0;
18392
18393 #[allow(non_camel_case_types)]
18394 type P4Mul_0 = <<A as Mul<B>>::Output as Same<_0>>::Output;
18395
18396 assert_eq!(<P4Mul_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
18397 }
18398 #[test]
18399 #[allow(non_snake_case)]
18400 fn test_P4_Min__0() {
18401 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18402 type B = Z0;
18403 type _0 = Z0;
18404
18405 #[allow(non_camel_case_types)]
18406 type P4Min_0 = <<A as Min<B>>::Output as Same<_0>>::Output;
18407
18408 assert_eq!(<P4Min_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
18409 }
18410 #[test]
18411 #[allow(non_snake_case)]
18412 fn test_P4_Max__0() {
18413 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18414 type B = Z0;
18415 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18416
18417 #[allow(non_camel_case_types)]
18418 type P4Max_0 = <<A as Max<B>>::Output as Same<P4>>::Output;
18419
18420 assert_eq!(<P4Max_0 as Integer>::to_i64(), <P4 as Integer>::to_i64());
18421 }
18422 #[test]
18423 #[allow(non_snake_case)]
18424 fn test_P4_Gcd__0() {
18425 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18426 type B = Z0;
18427 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18428
18429 #[allow(non_camel_case_types)]
18430 type P4Gcd_0 = <<A as Gcd<B>>::Output as Same<P4>>::Output;
18431
18432 assert_eq!(<P4Gcd_0 as Integer>::to_i64(), <P4 as Integer>::to_i64());
18433 }
18434 #[test]
18435 #[allow(non_snake_case)]
18436 fn test_P4_Pow__0() {
18437 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18438 type B = Z0;
18439 type P1 = PInt<UInt<UTerm, B1>>;
18440
18441 #[allow(non_camel_case_types)]
18442 type P4Pow_0 = <<A as Pow<B>>::Output as Same<P1>>::Output;
18443
18444 assert_eq!(<P4Pow_0 as Integer>::to_i64(), <P1 as Integer>::to_i64());
18445 }
18446 #[test]
18447 #[allow(non_snake_case)]
18448 fn test_P4_Cmp__0() {
18449 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18450 type B = Z0;
18451
18452 #[allow(non_camel_case_types)]
18453 type P4Cmp_0 = <A as Cmp<B>>::Output;
18454 assert_eq!(<P4Cmp_0 as Ord>::to_ordering(), Ordering::Greater);
18455 }
18456 #[test]
18457 #[allow(non_snake_case)]
18458 fn test_P4_Add_P1() {
18459 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18460 type B = PInt<UInt<UTerm, B1>>;
18461 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
18462
18463 #[allow(non_camel_case_types)]
18464 type P4AddP1 = <<A as Add<B>>::Output as Same<P5>>::Output;
18465
18466 assert_eq!(<P4AddP1 as Integer>::to_i64(), <P5 as Integer>::to_i64());
18467 }
18468 #[test]
18469 #[allow(non_snake_case)]
18470 fn test_P4_Sub_P1() {
18471 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18472 type B = PInt<UInt<UTerm, B1>>;
18473 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
18474
18475 #[allow(non_camel_case_types)]
18476 type P4SubP1 = <<A as Sub<B>>::Output as Same<P3>>::Output;
18477
18478 assert_eq!(<P4SubP1 as Integer>::to_i64(), <P3 as Integer>::to_i64());
18479 }
18480 #[test]
18481 #[allow(non_snake_case)]
18482 fn test_P4_Mul_P1() {
18483 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18484 type B = PInt<UInt<UTerm, B1>>;
18485 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18486
18487 #[allow(non_camel_case_types)]
18488 type P4MulP1 = <<A as Mul<B>>::Output as Same<P4>>::Output;
18489
18490 assert_eq!(<P4MulP1 as Integer>::to_i64(), <P4 as Integer>::to_i64());
18491 }
18492 #[test]
18493 #[allow(non_snake_case)]
18494 fn test_P4_Min_P1() {
18495 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18496 type B = PInt<UInt<UTerm, B1>>;
18497 type P1 = PInt<UInt<UTerm, B1>>;
18498
18499 #[allow(non_camel_case_types)]
18500 type P4MinP1 = <<A as Min<B>>::Output as Same<P1>>::Output;
18501
18502 assert_eq!(<P4MinP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
18503 }
18504 #[test]
18505 #[allow(non_snake_case)]
18506 fn test_P4_Max_P1() {
18507 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18508 type B = PInt<UInt<UTerm, B1>>;
18509 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18510
18511 #[allow(non_camel_case_types)]
18512 type P4MaxP1 = <<A as Max<B>>::Output as Same<P4>>::Output;
18513
18514 assert_eq!(<P4MaxP1 as Integer>::to_i64(), <P4 as Integer>::to_i64());
18515 }
18516 #[test]
18517 #[allow(non_snake_case)]
18518 fn test_P4_Gcd_P1() {
18519 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18520 type B = PInt<UInt<UTerm, B1>>;
18521 type P1 = PInt<UInt<UTerm, B1>>;
18522
18523 #[allow(non_camel_case_types)]
18524 type P4GcdP1 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
18525
18526 assert_eq!(<P4GcdP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
18527 }
18528 #[test]
18529 #[allow(non_snake_case)]
18530 fn test_P4_Div_P1() {
18531 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18532 type B = PInt<UInt<UTerm, B1>>;
18533 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18534
18535 #[allow(non_camel_case_types)]
18536 type P4DivP1 = <<A as Div<B>>::Output as Same<P4>>::Output;
18537
18538 assert_eq!(<P4DivP1 as Integer>::to_i64(), <P4 as Integer>::to_i64());
18539 }
18540 #[test]
18541 #[allow(non_snake_case)]
18542 fn test_P4_Rem_P1() {
18543 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18544 type B = PInt<UInt<UTerm, B1>>;
18545 type _0 = Z0;
18546
18547 #[allow(non_camel_case_types)]
18548 type P4RemP1 = <<A as Rem<B>>::Output as Same<_0>>::Output;
18549
18550 assert_eq!(<P4RemP1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
18551 }
18552 #[test]
18553 #[allow(non_snake_case)]
18554 fn test_P4_PartialDiv_P1() {
18555 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18556 type B = PInt<UInt<UTerm, B1>>;
18557 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18558
18559 #[allow(non_camel_case_types)]
18560 type P4PartialDivP1 = <<A as PartialDiv<B>>::Output as Same<P4>>::Output;
18561
18562 assert_eq!(<P4PartialDivP1 as Integer>::to_i64(), <P4 as Integer>::to_i64());
18563 }
18564 #[test]
18565 #[allow(non_snake_case)]
18566 fn test_P4_Pow_P1() {
18567 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18568 type B = PInt<UInt<UTerm, B1>>;
18569 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18570
18571 #[allow(non_camel_case_types)]
18572 type P4PowP1 = <<A as Pow<B>>::Output as Same<P4>>::Output;
18573
18574 assert_eq!(<P4PowP1 as Integer>::to_i64(), <P4 as Integer>::to_i64());
18575 }
18576 #[test]
18577 #[allow(non_snake_case)]
18578 fn test_P4_Cmp_P1() {
18579 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18580 type B = PInt<UInt<UTerm, B1>>;
18581
18582 #[allow(non_camel_case_types)]
18583 type P4CmpP1 = <A as Cmp<B>>::Output;
18584 assert_eq!(<P4CmpP1 as Ord>::to_ordering(), Ordering::Greater);
18585 }
18586 #[test]
18587 #[allow(non_snake_case)]
18588 fn test_P4_Add_P2() {
18589 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18590 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
18591 type P6 = PInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
18592
18593 #[allow(non_camel_case_types)]
18594 type P4AddP2 = <<A as Add<B>>::Output as Same<P6>>::Output;
18595
18596 assert_eq!(<P4AddP2 as Integer>::to_i64(), <P6 as Integer>::to_i64());
18597 }
18598 #[test]
18599 #[allow(non_snake_case)]
18600 fn test_P4_Sub_P2() {
18601 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18602 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
18603 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
18604
18605 #[allow(non_camel_case_types)]
18606 type P4SubP2 = <<A as Sub<B>>::Output as Same<P2>>::Output;
18607
18608 assert_eq!(<P4SubP2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
18609 }
18610 #[test]
18611 #[allow(non_snake_case)]
18612 fn test_P4_Mul_P2() {
18613 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18614 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
18615 type P8 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>;
18616
18617 #[allow(non_camel_case_types)]
18618 type P4MulP2 = <<A as Mul<B>>::Output as Same<P8>>::Output;
18619
18620 assert_eq!(<P4MulP2 as Integer>::to_i64(), <P8 as Integer>::to_i64());
18621 }
18622 #[test]
18623 #[allow(non_snake_case)]
18624 fn test_P4_Min_P2() {
18625 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18626 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
18627 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
18628
18629 #[allow(non_camel_case_types)]
18630 type P4MinP2 = <<A as Min<B>>::Output as Same<P2>>::Output;
18631
18632 assert_eq!(<P4MinP2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
18633 }
18634 #[test]
18635 #[allow(non_snake_case)]
18636 fn test_P4_Max_P2() {
18637 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18638 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
18639 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18640
18641 #[allow(non_camel_case_types)]
18642 type P4MaxP2 = <<A as Max<B>>::Output as Same<P4>>::Output;
18643
18644 assert_eq!(<P4MaxP2 as Integer>::to_i64(), <P4 as Integer>::to_i64());
18645 }
18646 #[test]
18647 #[allow(non_snake_case)]
18648 fn test_P4_Gcd_P2() {
18649 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18650 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
18651 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
18652
18653 #[allow(non_camel_case_types)]
18654 type P4GcdP2 = <<A as Gcd<B>>::Output as Same<P2>>::Output;
18655
18656 assert_eq!(<P4GcdP2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
18657 }
18658 #[test]
18659 #[allow(non_snake_case)]
18660 fn test_P4_Div_P2() {
18661 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18662 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
18663 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
18664
18665 #[allow(non_camel_case_types)]
18666 type P4DivP2 = <<A as Div<B>>::Output as Same<P2>>::Output;
18667
18668 assert_eq!(<P4DivP2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
18669 }
18670 #[test]
18671 #[allow(non_snake_case)]
18672 fn test_P4_Rem_P2() {
18673 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18674 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
18675 type _0 = Z0;
18676
18677 #[allow(non_camel_case_types)]
18678 type P4RemP2 = <<A as Rem<B>>::Output as Same<_0>>::Output;
18679
18680 assert_eq!(<P4RemP2 as Integer>::to_i64(), <_0 as Integer>::to_i64());
18681 }
18682 #[test]
18683 #[allow(non_snake_case)]
18684 fn test_P4_PartialDiv_P2() {
18685 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18686 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
18687 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
18688
18689 #[allow(non_camel_case_types)]
18690 type P4PartialDivP2 = <<A as PartialDiv<B>>::Output as Same<P2>>::Output;
18691
18692 assert_eq!(<P4PartialDivP2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
18693 }
18694 #[test]
18695 #[allow(non_snake_case)]
18696 fn test_P4_Pow_P2() {
18697 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18698 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
18699 type P16 = PInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>>;
18700
18701 #[allow(non_camel_case_types)]
18702 type P4PowP2 = <<A as Pow<B>>::Output as Same<P16>>::Output;
18703
18704 assert_eq!(<P4PowP2 as Integer>::to_i64(), <P16 as Integer>::to_i64());
18705 }
18706 #[test]
18707 #[allow(non_snake_case)]
18708 fn test_P4_Cmp_P2() {
18709 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18710 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
18711
18712 #[allow(non_camel_case_types)]
18713 type P4CmpP2 = <A as Cmp<B>>::Output;
18714 assert_eq!(<P4CmpP2 as Ord>::to_ordering(), Ordering::Greater);
18715 }
18716 #[test]
18717 #[allow(non_snake_case)]
18718 fn test_P4_Add_P3() {
18719 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18720 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
18721 type P7 = PInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>>;
18722
18723 #[allow(non_camel_case_types)]
18724 type P4AddP3 = <<A as Add<B>>::Output as Same<P7>>::Output;
18725
18726 assert_eq!(<P4AddP3 as Integer>::to_i64(), <P7 as Integer>::to_i64());
18727 }
18728 #[test]
18729 #[allow(non_snake_case)]
18730 fn test_P4_Sub_P3() {
18731 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18732 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
18733 type P1 = PInt<UInt<UTerm, B1>>;
18734
18735 #[allow(non_camel_case_types)]
18736 type P4SubP3 = <<A as Sub<B>>::Output as Same<P1>>::Output;
18737
18738 assert_eq!(<P4SubP3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
18739 }
18740 #[test]
18741 #[allow(non_snake_case)]
18742 fn test_P4_Mul_P3() {
18743 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18744 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
18745 type P12 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>>;
18746
18747 #[allow(non_camel_case_types)]
18748 type P4MulP3 = <<A as Mul<B>>::Output as Same<P12>>::Output;
18749
18750 assert_eq!(<P4MulP3 as Integer>::to_i64(), <P12 as Integer>::to_i64());
18751 }
18752 #[test]
18753 #[allow(non_snake_case)]
18754 fn test_P4_Min_P3() {
18755 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18756 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
18757 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
18758
18759 #[allow(non_camel_case_types)]
18760 type P4MinP3 = <<A as Min<B>>::Output as Same<P3>>::Output;
18761
18762 assert_eq!(<P4MinP3 as Integer>::to_i64(), <P3 as Integer>::to_i64());
18763 }
18764 #[test]
18765 #[allow(non_snake_case)]
18766 fn test_P4_Max_P3() {
18767 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18768 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
18769 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18770
18771 #[allow(non_camel_case_types)]
18772 type P4MaxP3 = <<A as Max<B>>::Output as Same<P4>>::Output;
18773
18774 assert_eq!(<P4MaxP3 as Integer>::to_i64(), <P4 as Integer>::to_i64());
18775 }
18776 #[test]
18777 #[allow(non_snake_case)]
18778 fn test_P4_Gcd_P3() {
18779 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18780 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
18781 type P1 = PInt<UInt<UTerm, B1>>;
18782
18783 #[allow(non_camel_case_types)]
18784 type P4GcdP3 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
18785
18786 assert_eq!(<P4GcdP3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
18787 }
18788 #[test]
18789 #[allow(non_snake_case)]
18790 fn test_P4_Div_P3() {
18791 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18792 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
18793 type P1 = PInt<UInt<UTerm, B1>>;
18794
18795 #[allow(non_camel_case_types)]
18796 type P4DivP3 = <<A as Div<B>>::Output as Same<P1>>::Output;
18797
18798 assert_eq!(<P4DivP3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
18799 }
18800 #[test]
18801 #[allow(non_snake_case)]
18802 fn test_P4_Rem_P3() {
18803 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18804 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
18805 type P1 = PInt<UInt<UTerm, B1>>;
18806
18807 #[allow(non_camel_case_types)]
18808 type P4RemP3 = <<A as Rem<B>>::Output as Same<P1>>::Output;
18809
18810 assert_eq!(<P4RemP3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
18811 }
18812 #[test]
18813 #[allow(non_snake_case)]
18814 fn test_P4_Pow_P3() {
18815 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18816 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
18817 type P64 = PInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>>;
18818
18819 #[allow(non_camel_case_types)]
18820 type P4PowP3 = <<A as Pow<B>>::Output as Same<P64>>::Output;
18821
18822 assert_eq!(<P4PowP3 as Integer>::to_i64(), <P64 as Integer>::to_i64());
18823 }
18824 #[test]
18825 #[allow(non_snake_case)]
18826 fn test_P4_Cmp_P3() {
18827 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18828 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
18829
18830 #[allow(non_camel_case_types)]
18831 type P4CmpP3 = <A as Cmp<B>>::Output;
18832 assert_eq!(<P4CmpP3 as Ord>::to_ordering(), Ordering::Greater);
18833 }
18834 #[test]
18835 #[allow(non_snake_case)]
18836 fn test_P4_Add_P4() {
18837 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18838 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18839 type P8 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>;
18840
18841 #[allow(non_camel_case_types)]
18842 type P4AddP4 = <<A as Add<B>>::Output as Same<P8>>::Output;
18843
18844 assert_eq!(<P4AddP4 as Integer>::to_i64(), <P8 as Integer>::to_i64());
18845 }
18846 #[test]
18847 #[allow(non_snake_case)]
18848 fn test_P4_Sub_P4() {
18849 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18850 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18851 type _0 = Z0;
18852
18853 #[allow(non_camel_case_types)]
18854 type P4SubP4 = <<A as Sub<B>>::Output as Same<_0>>::Output;
18855
18856 assert_eq!(<P4SubP4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
18857 }
18858 #[test]
18859 #[allow(non_snake_case)]
18860 fn test_P4_Mul_P4() {
18861 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18862 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18863 type P16 = PInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>>;
18864
18865 #[allow(non_camel_case_types)]
18866 type P4MulP4 = <<A as Mul<B>>::Output as Same<P16>>::Output;
18867
18868 assert_eq!(<P4MulP4 as Integer>::to_i64(), <P16 as Integer>::to_i64());
18869 }
18870 #[test]
18871 #[allow(non_snake_case)]
18872 fn test_P4_Min_P4() {
18873 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18874 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18875 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18876
18877 #[allow(non_camel_case_types)]
18878 type P4MinP4 = <<A as Min<B>>::Output as Same<P4>>::Output;
18879
18880 assert_eq!(<P4MinP4 as Integer>::to_i64(), <P4 as Integer>::to_i64());
18881 }
18882 #[test]
18883 #[allow(non_snake_case)]
18884 fn test_P4_Max_P4() {
18885 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18886 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18887 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18888
18889 #[allow(non_camel_case_types)]
18890 type P4MaxP4 = <<A as Max<B>>::Output as Same<P4>>::Output;
18891
18892 assert_eq!(<P4MaxP4 as Integer>::to_i64(), <P4 as Integer>::to_i64());
18893 }
18894 #[test]
18895 #[allow(non_snake_case)]
18896 fn test_P4_Gcd_P4() {
18897 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18898 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18899 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18900
18901 #[allow(non_camel_case_types)]
18902 type P4GcdP4 = <<A as Gcd<B>>::Output as Same<P4>>::Output;
18903
18904 assert_eq!(<P4GcdP4 as Integer>::to_i64(), <P4 as Integer>::to_i64());
18905 }
18906 #[test]
18907 #[allow(non_snake_case)]
18908 fn test_P4_Div_P4() {
18909 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18910 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18911 type P1 = PInt<UInt<UTerm, B1>>;
18912
18913 #[allow(non_camel_case_types)]
18914 type P4DivP4 = <<A as Div<B>>::Output as Same<P1>>::Output;
18915
18916 assert_eq!(<P4DivP4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
18917 }
18918 #[test]
18919 #[allow(non_snake_case)]
18920 fn test_P4_Rem_P4() {
18921 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18922 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18923 type _0 = Z0;
18924
18925 #[allow(non_camel_case_types)]
18926 type P4RemP4 = <<A as Rem<B>>::Output as Same<_0>>::Output;
18927
18928 assert_eq!(<P4RemP4 as Integer>::to_i64(), <_0 as Integer>::to_i64());
18929 }
18930 #[test]
18931 #[allow(non_snake_case)]
18932 fn test_P4_PartialDiv_P4() {
18933 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18934 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18935 type P1 = PInt<UInt<UTerm, B1>>;
18936
18937 #[allow(non_camel_case_types)]
18938 type P4PartialDivP4 = <<A as PartialDiv<B>>::Output as Same<P1>>::Output;
18939
18940 assert_eq!(<P4PartialDivP4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
18941 }
18942 #[test]
18943 #[allow(non_snake_case)]
18944 fn test_P4_Pow_P4() {
18945 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18946 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18947 type P256 = PInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>;
18948
18949 #[allow(non_camel_case_types)]
18950 type P4PowP4 = <<A as Pow<B>>::Output as Same<P256>>::Output;
18951
18952 assert_eq!(<P4PowP4 as Integer>::to_i64(), <P256 as Integer>::to_i64());
18953 }
18954 #[test]
18955 #[allow(non_snake_case)]
18956 fn test_P4_Cmp_P4() {
18957 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18958 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18959
18960 #[allow(non_camel_case_types)]
18961 type P4CmpP4 = <A as Cmp<B>>::Output;
18962 assert_eq!(<P4CmpP4 as Ord>::to_ordering(), Ordering::Equal);
18963 }
18964 #[test]
18965 #[allow(non_snake_case)]
18966 fn test_P4_Add_P5() {
18967 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18968 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
18969 type P9 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>>;
18970
18971 #[allow(non_camel_case_types)]
18972 type P4AddP5 = <<A as Add<B>>::Output as Same<P9>>::Output;
18973
18974 assert_eq!(<P4AddP5 as Integer>::to_i64(), <P9 as Integer>::to_i64());
18975 }
18976 #[test]
18977 #[allow(non_snake_case)]
18978 fn test_P4_Sub_P5() {
18979 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18980 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
18981 type N1 = NInt<UInt<UTerm, B1>>;
18982
18983 #[allow(non_camel_case_types)]
18984 type P4SubP5 = <<A as Sub<B>>::Output as Same<N1>>::Output;
18985
18986 assert_eq!(<P4SubP5 as Integer>::to_i64(), <N1 as Integer>::to_i64());
18987 }
18988 #[test]
18989 #[allow(non_snake_case)]
18990 fn test_P4_Mul_P5() {
18991 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
18992 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
18993 type P20 = PInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>>;
18994
18995 #[allow(non_camel_case_types)]
18996 type P4MulP5 = <<A as Mul<B>>::Output as Same<P20>>::Output;
18997
18998 assert_eq!(<P4MulP5 as Integer>::to_i64(), <P20 as Integer>::to_i64());
18999 }
19000 #[test]
19001 #[allow(non_snake_case)]
19002 fn test_P4_Min_P5() {
19003 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
19004 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19005 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
19006
19007 #[allow(non_camel_case_types)]
19008 type P4MinP5 = <<A as Min<B>>::Output as Same<P4>>::Output;
19009
19010 assert_eq!(<P4MinP5 as Integer>::to_i64(), <P4 as Integer>::to_i64());
19011 }
19012 #[test]
19013 #[allow(non_snake_case)]
19014 fn test_P4_Max_P5() {
19015 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
19016 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19017 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19018
19019 #[allow(non_camel_case_types)]
19020 type P4MaxP5 = <<A as Max<B>>::Output as Same<P5>>::Output;
19021
19022 assert_eq!(<P4MaxP5 as Integer>::to_i64(), <P5 as Integer>::to_i64());
19023 }
19024 #[test]
19025 #[allow(non_snake_case)]
19026 fn test_P4_Gcd_P5() {
19027 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
19028 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19029 type P1 = PInt<UInt<UTerm, B1>>;
19030
19031 #[allow(non_camel_case_types)]
19032 type P4GcdP5 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
19033
19034 assert_eq!(<P4GcdP5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
19035 }
19036 #[test]
19037 #[allow(non_snake_case)]
19038 fn test_P4_Div_P5() {
19039 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
19040 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19041 type _0 = Z0;
19042
19043 #[allow(non_camel_case_types)]
19044 type P4DivP5 = <<A as Div<B>>::Output as Same<_0>>::Output;
19045
19046 assert_eq!(<P4DivP5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
19047 }
19048 #[test]
19049 #[allow(non_snake_case)]
19050 fn test_P4_Rem_P5() {
19051 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
19052 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19053 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
19054
19055 #[allow(non_camel_case_types)]
19056 type P4RemP5 = <<A as Rem<B>>::Output as Same<P4>>::Output;
19057
19058 assert_eq!(<P4RemP5 as Integer>::to_i64(), <P4 as Integer>::to_i64());
19059 }
19060 #[test]
19061 #[allow(non_snake_case)]
19062 fn test_P4_Pow_P5() {
19063 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
19064 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19065 type P1024 = PInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>, B0>>;
19066
19067 #[allow(non_camel_case_types)]
19068 type P4PowP5 = <<A as Pow<B>>::Output as Same<P1024>>::Output;
19069
19070 assert_eq!(<P4PowP5 as Integer>::to_i64(), <P1024 as Integer>::to_i64());
19071 }
19072 #[test]
19073 #[allow(non_snake_case)]
19074 fn test_P4_Cmp_P5() {
19075 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
19076 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19077
19078 #[allow(non_camel_case_types)]
19079 type P4CmpP5 = <A as Cmp<B>>::Output;
19080 assert_eq!(<P4CmpP5 as Ord>::to_ordering(), Ordering::Less);
19081 }
19082 #[test]
19083 #[allow(non_snake_case)]
19084 fn test_P5_Add_N5() {
19085 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19086 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19087 type _0 = Z0;
19088
19089 #[allow(non_camel_case_types)]
19090 type P5AddN5 = <<A as Add<B>>::Output as Same<_0>>::Output;
19091
19092 assert_eq!(<P5AddN5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
19093 }
19094 #[test]
19095 #[allow(non_snake_case)]
19096 fn test_P5_Sub_N5() {
19097 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19098 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19099 type P10 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>;
19100
19101 #[allow(non_camel_case_types)]
19102 type P5SubN5 = <<A as Sub<B>>::Output as Same<P10>>::Output;
19103
19104 assert_eq!(<P5SubN5 as Integer>::to_i64(), <P10 as Integer>::to_i64());
19105 }
19106 #[test]
19107 #[allow(non_snake_case)]
19108 fn test_P5_Mul_N5() {
19109 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19110 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19111 type N25 = NInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>>;
19112
19113 #[allow(non_camel_case_types)]
19114 type P5MulN5 = <<A as Mul<B>>::Output as Same<N25>>::Output;
19115
19116 assert_eq!(<P5MulN5 as Integer>::to_i64(), <N25 as Integer>::to_i64());
19117 }
19118 #[test]
19119 #[allow(non_snake_case)]
19120 fn test_P5_Min_N5() {
19121 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19122 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19123 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19124
19125 #[allow(non_camel_case_types)]
19126 type P5MinN5 = <<A as Min<B>>::Output as Same<N5>>::Output;
19127
19128 assert_eq!(<P5MinN5 as Integer>::to_i64(), <N5 as Integer>::to_i64());
19129 }
19130 #[test]
19131 #[allow(non_snake_case)]
19132 fn test_P5_Max_N5() {
19133 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19134 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19135 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19136
19137 #[allow(non_camel_case_types)]
19138 type P5MaxN5 = <<A as Max<B>>::Output as Same<P5>>::Output;
19139
19140 assert_eq!(<P5MaxN5 as Integer>::to_i64(), <P5 as Integer>::to_i64());
19141 }
19142 #[test]
19143 #[allow(non_snake_case)]
19144 fn test_P5_Gcd_N5() {
19145 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19146 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19147 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19148
19149 #[allow(non_camel_case_types)]
19150 type P5GcdN5 = <<A as Gcd<B>>::Output as Same<P5>>::Output;
19151
19152 assert_eq!(<P5GcdN5 as Integer>::to_i64(), <P5 as Integer>::to_i64());
19153 }
19154 #[test]
19155 #[allow(non_snake_case)]
19156 fn test_P5_Div_N5() {
19157 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19158 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19159 type N1 = NInt<UInt<UTerm, B1>>;
19160
19161 #[allow(non_camel_case_types)]
19162 type P5DivN5 = <<A as Div<B>>::Output as Same<N1>>::Output;
19163
19164 assert_eq!(<P5DivN5 as Integer>::to_i64(), <N1 as Integer>::to_i64());
19165 }
19166 #[test]
19167 #[allow(non_snake_case)]
19168 fn test_P5_Rem_N5() {
19169 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19170 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19171 type _0 = Z0;
19172
19173 #[allow(non_camel_case_types)]
19174 type P5RemN5 = <<A as Rem<B>>::Output as Same<_0>>::Output;
19175
19176 assert_eq!(<P5RemN5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
19177 }
19178 #[test]
19179 #[allow(non_snake_case)]
19180 fn test_P5_PartialDiv_N5() {
19181 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19182 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19183 type N1 = NInt<UInt<UTerm, B1>>;
19184
19185 #[allow(non_camel_case_types)]
19186 type P5PartialDivN5 = <<A as PartialDiv<B>>::Output as Same<N1>>::Output;
19187
19188 assert_eq!(<P5PartialDivN5 as Integer>::to_i64(), <N1 as Integer>::to_i64());
19189 }
19190 #[test]
19191 #[allow(non_snake_case)]
19192 fn test_P5_Cmp_N5() {
19193 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19194 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19195
19196 #[allow(non_camel_case_types)]
19197 type P5CmpN5 = <A as Cmp<B>>::Output;
19198 assert_eq!(<P5CmpN5 as Ord>::to_ordering(), Ordering::Greater);
19199 }
19200 #[test]
19201 #[allow(non_snake_case)]
19202 fn test_P5_Add_N4() {
19203 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19204 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
19205 type P1 = PInt<UInt<UTerm, B1>>;
19206
19207 #[allow(non_camel_case_types)]
19208 type P5AddN4 = <<A as Add<B>>::Output as Same<P1>>::Output;
19209
19210 assert_eq!(<P5AddN4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
19211 }
19212 #[test]
19213 #[allow(non_snake_case)]
19214 fn test_P5_Sub_N4() {
19215 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19216 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
19217 type P9 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>>;
19218
19219 #[allow(non_camel_case_types)]
19220 type P5SubN4 = <<A as Sub<B>>::Output as Same<P9>>::Output;
19221
19222 assert_eq!(<P5SubN4 as Integer>::to_i64(), <P9 as Integer>::to_i64());
19223 }
19224 #[test]
19225 #[allow(non_snake_case)]
19226 fn test_P5_Mul_N4() {
19227 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19228 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
19229 type N20 = NInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>>;
19230
19231 #[allow(non_camel_case_types)]
19232 type P5MulN4 = <<A as Mul<B>>::Output as Same<N20>>::Output;
19233
19234 assert_eq!(<P5MulN4 as Integer>::to_i64(), <N20 as Integer>::to_i64());
19235 }
19236 #[test]
19237 #[allow(non_snake_case)]
19238 fn test_P5_Min_N4() {
19239 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19240 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
19241 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
19242
19243 #[allow(non_camel_case_types)]
19244 type P5MinN4 = <<A as Min<B>>::Output as Same<N4>>::Output;
19245
19246 assert_eq!(<P5MinN4 as Integer>::to_i64(), <N4 as Integer>::to_i64());
19247 }
19248 #[test]
19249 #[allow(non_snake_case)]
19250 fn test_P5_Max_N4() {
19251 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19252 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
19253 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19254
19255 #[allow(non_camel_case_types)]
19256 type P5MaxN4 = <<A as Max<B>>::Output as Same<P5>>::Output;
19257
19258 assert_eq!(<P5MaxN4 as Integer>::to_i64(), <P5 as Integer>::to_i64());
19259 }
19260 #[test]
19261 #[allow(non_snake_case)]
19262 fn test_P5_Gcd_N4() {
19263 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19264 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
19265 type P1 = PInt<UInt<UTerm, B1>>;
19266
19267 #[allow(non_camel_case_types)]
19268 type P5GcdN4 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
19269
19270 assert_eq!(<P5GcdN4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
19271 }
19272 #[test]
19273 #[allow(non_snake_case)]
19274 fn test_P5_Div_N4() {
19275 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19276 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
19277 type N1 = NInt<UInt<UTerm, B1>>;
19278
19279 #[allow(non_camel_case_types)]
19280 type P5DivN4 = <<A as Div<B>>::Output as Same<N1>>::Output;
19281
19282 assert_eq!(<P5DivN4 as Integer>::to_i64(), <N1 as Integer>::to_i64());
19283 }
19284 #[test]
19285 #[allow(non_snake_case)]
19286 fn test_P5_Rem_N4() {
19287 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19288 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
19289 type P1 = PInt<UInt<UTerm, B1>>;
19290
19291 #[allow(non_camel_case_types)]
19292 type P5RemN4 = <<A as Rem<B>>::Output as Same<P1>>::Output;
19293
19294 assert_eq!(<P5RemN4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
19295 }
19296 #[test]
19297 #[allow(non_snake_case)]
19298 fn test_P5_Cmp_N4() {
19299 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19300 type B = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
19301
19302 #[allow(non_camel_case_types)]
19303 type P5CmpN4 = <A as Cmp<B>>::Output;
19304 assert_eq!(<P5CmpN4 as Ord>::to_ordering(), Ordering::Greater);
19305 }
19306 #[test]
19307 #[allow(non_snake_case)]
19308 fn test_P5_Add_N3() {
19309 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19310 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
19311 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
19312
19313 #[allow(non_camel_case_types)]
19314 type P5AddN3 = <<A as Add<B>>::Output as Same<P2>>::Output;
19315
19316 assert_eq!(<P5AddN3 as Integer>::to_i64(), <P2 as Integer>::to_i64());
19317 }
19318 #[test]
19319 #[allow(non_snake_case)]
19320 fn test_P5_Sub_N3() {
19321 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19322 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
19323 type P8 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>;
19324
19325 #[allow(non_camel_case_types)]
19326 type P5SubN3 = <<A as Sub<B>>::Output as Same<P8>>::Output;
19327
19328 assert_eq!(<P5SubN3 as Integer>::to_i64(), <P8 as Integer>::to_i64());
19329 }
19330 #[test]
19331 #[allow(non_snake_case)]
19332 fn test_P5_Mul_N3() {
19333 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19334 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
19335 type N15 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>;
19336
19337 #[allow(non_camel_case_types)]
19338 type P5MulN3 = <<A as Mul<B>>::Output as Same<N15>>::Output;
19339
19340 assert_eq!(<P5MulN3 as Integer>::to_i64(), <N15 as Integer>::to_i64());
19341 }
19342 #[test]
19343 #[allow(non_snake_case)]
19344 fn test_P5_Min_N3() {
19345 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19346 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
19347 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
19348
19349 #[allow(non_camel_case_types)]
19350 type P5MinN3 = <<A as Min<B>>::Output as Same<N3>>::Output;
19351
19352 assert_eq!(<P5MinN3 as Integer>::to_i64(), <N3 as Integer>::to_i64());
19353 }
19354 #[test]
19355 #[allow(non_snake_case)]
19356 fn test_P5_Max_N3() {
19357 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19358 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
19359 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19360
19361 #[allow(non_camel_case_types)]
19362 type P5MaxN3 = <<A as Max<B>>::Output as Same<P5>>::Output;
19363
19364 assert_eq!(<P5MaxN3 as Integer>::to_i64(), <P5 as Integer>::to_i64());
19365 }
19366 #[test]
19367 #[allow(non_snake_case)]
19368 fn test_P5_Gcd_N3() {
19369 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19370 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
19371 type P1 = PInt<UInt<UTerm, B1>>;
19372
19373 #[allow(non_camel_case_types)]
19374 type P5GcdN3 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
19375
19376 assert_eq!(<P5GcdN3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
19377 }
19378 #[test]
19379 #[allow(non_snake_case)]
19380 fn test_P5_Div_N3() {
19381 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19382 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
19383 type N1 = NInt<UInt<UTerm, B1>>;
19384
19385 #[allow(non_camel_case_types)]
19386 type P5DivN3 = <<A as Div<B>>::Output as Same<N1>>::Output;
19387
19388 assert_eq!(<P5DivN3 as Integer>::to_i64(), <N1 as Integer>::to_i64());
19389 }
19390 #[test]
19391 #[allow(non_snake_case)]
19392 fn test_P5_Rem_N3() {
19393 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19394 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
19395 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
19396
19397 #[allow(non_camel_case_types)]
19398 type P5RemN3 = <<A as Rem<B>>::Output as Same<P2>>::Output;
19399
19400 assert_eq!(<P5RemN3 as Integer>::to_i64(), <P2 as Integer>::to_i64());
19401 }
19402 #[test]
19403 #[allow(non_snake_case)]
19404 fn test_P5_Cmp_N3() {
19405 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19406 type B = NInt<UInt<UInt<UTerm, B1>, B1>>;
19407
19408 #[allow(non_camel_case_types)]
19409 type P5CmpN3 = <A as Cmp<B>>::Output;
19410 assert_eq!(<P5CmpN3 as Ord>::to_ordering(), Ordering::Greater);
19411 }
19412 #[test]
19413 #[allow(non_snake_case)]
19414 fn test_P5_Add_N2() {
19415 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19416 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
19417 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
19418
19419 #[allow(non_camel_case_types)]
19420 type P5AddN2 = <<A as Add<B>>::Output as Same<P3>>::Output;
19421
19422 assert_eq!(<P5AddN2 as Integer>::to_i64(), <P3 as Integer>::to_i64());
19423 }
19424 #[test]
19425 #[allow(non_snake_case)]
19426 fn test_P5_Sub_N2() {
19427 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19428 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
19429 type P7 = PInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>>;
19430
19431 #[allow(non_camel_case_types)]
19432 type P5SubN2 = <<A as Sub<B>>::Output as Same<P7>>::Output;
19433
19434 assert_eq!(<P5SubN2 as Integer>::to_i64(), <P7 as Integer>::to_i64());
19435 }
19436 #[test]
19437 #[allow(non_snake_case)]
19438 fn test_P5_Mul_N2() {
19439 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19440 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
19441 type N10 = NInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>;
19442
19443 #[allow(non_camel_case_types)]
19444 type P5MulN2 = <<A as Mul<B>>::Output as Same<N10>>::Output;
19445
19446 assert_eq!(<P5MulN2 as Integer>::to_i64(), <N10 as Integer>::to_i64());
19447 }
19448 #[test]
19449 #[allow(non_snake_case)]
19450 fn test_P5_Min_N2() {
19451 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19452 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
19453 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
19454
19455 #[allow(non_camel_case_types)]
19456 type P5MinN2 = <<A as Min<B>>::Output as Same<N2>>::Output;
19457
19458 assert_eq!(<P5MinN2 as Integer>::to_i64(), <N2 as Integer>::to_i64());
19459 }
19460 #[test]
19461 #[allow(non_snake_case)]
19462 fn test_P5_Max_N2() {
19463 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19464 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
19465 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19466
19467 #[allow(non_camel_case_types)]
19468 type P5MaxN2 = <<A as Max<B>>::Output as Same<P5>>::Output;
19469
19470 assert_eq!(<P5MaxN2 as Integer>::to_i64(), <P5 as Integer>::to_i64());
19471 }
19472 #[test]
19473 #[allow(non_snake_case)]
19474 fn test_P5_Gcd_N2() {
19475 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19476 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
19477 type P1 = PInt<UInt<UTerm, B1>>;
19478
19479 #[allow(non_camel_case_types)]
19480 type P5GcdN2 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
19481
19482 assert_eq!(<P5GcdN2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
19483 }
19484 #[test]
19485 #[allow(non_snake_case)]
19486 fn test_P5_Div_N2() {
19487 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19488 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
19489 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
19490
19491 #[allow(non_camel_case_types)]
19492 type P5DivN2 = <<A as Div<B>>::Output as Same<N2>>::Output;
19493
19494 assert_eq!(<P5DivN2 as Integer>::to_i64(), <N2 as Integer>::to_i64());
19495 }
19496 #[test]
19497 #[allow(non_snake_case)]
19498 fn test_P5_Rem_N2() {
19499 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19500 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
19501 type P1 = PInt<UInt<UTerm, B1>>;
19502
19503 #[allow(non_camel_case_types)]
19504 type P5RemN2 = <<A as Rem<B>>::Output as Same<P1>>::Output;
19505
19506 assert_eq!(<P5RemN2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
19507 }
19508 #[test]
19509 #[allow(non_snake_case)]
19510 fn test_P5_Cmp_N2() {
19511 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19512 type B = NInt<UInt<UInt<UTerm, B1>, B0>>;
19513
19514 #[allow(non_camel_case_types)]
19515 type P5CmpN2 = <A as Cmp<B>>::Output;
19516 assert_eq!(<P5CmpN2 as Ord>::to_ordering(), Ordering::Greater);
19517 }
19518 #[test]
19519 #[allow(non_snake_case)]
19520 fn test_P5_Add_N1() {
19521 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19522 type B = NInt<UInt<UTerm, B1>>;
19523 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
19524
19525 #[allow(non_camel_case_types)]
19526 type P5AddN1 = <<A as Add<B>>::Output as Same<P4>>::Output;
19527
19528 assert_eq!(<P5AddN1 as Integer>::to_i64(), <P4 as Integer>::to_i64());
19529 }
19530 #[test]
19531 #[allow(non_snake_case)]
19532 fn test_P5_Sub_N1() {
19533 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19534 type B = NInt<UInt<UTerm, B1>>;
19535 type P6 = PInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
19536
19537 #[allow(non_camel_case_types)]
19538 type P5SubN1 = <<A as Sub<B>>::Output as Same<P6>>::Output;
19539
19540 assert_eq!(<P5SubN1 as Integer>::to_i64(), <P6 as Integer>::to_i64());
19541 }
19542 #[test]
19543 #[allow(non_snake_case)]
19544 fn test_P5_Mul_N1() {
19545 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19546 type B = NInt<UInt<UTerm, B1>>;
19547 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19548
19549 #[allow(non_camel_case_types)]
19550 type P5MulN1 = <<A as Mul<B>>::Output as Same<N5>>::Output;
19551
19552 assert_eq!(<P5MulN1 as Integer>::to_i64(), <N5 as Integer>::to_i64());
19553 }
19554 #[test]
19555 #[allow(non_snake_case)]
19556 fn test_P5_Min_N1() {
19557 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19558 type B = NInt<UInt<UTerm, B1>>;
19559 type N1 = NInt<UInt<UTerm, B1>>;
19560
19561 #[allow(non_camel_case_types)]
19562 type P5MinN1 = <<A as Min<B>>::Output as Same<N1>>::Output;
19563
19564 assert_eq!(<P5MinN1 as Integer>::to_i64(), <N1 as Integer>::to_i64());
19565 }
19566 #[test]
19567 #[allow(non_snake_case)]
19568 fn test_P5_Max_N1() {
19569 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19570 type B = NInt<UInt<UTerm, B1>>;
19571 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19572
19573 #[allow(non_camel_case_types)]
19574 type P5MaxN1 = <<A as Max<B>>::Output as Same<P5>>::Output;
19575
19576 assert_eq!(<P5MaxN1 as Integer>::to_i64(), <P5 as Integer>::to_i64());
19577 }
19578 #[test]
19579 #[allow(non_snake_case)]
19580 fn test_P5_Gcd_N1() {
19581 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19582 type B = NInt<UInt<UTerm, B1>>;
19583 type P1 = PInt<UInt<UTerm, B1>>;
19584
19585 #[allow(non_camel_case_types)]
19586 type P5GcdN1 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
19587
19588 assert_eq!(<P5GcdN1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
19589 }
19590 #[test]
19591 #[allow(non_snake_case)]
19592 fn test_P5_Div_N1() {
19593 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19594 type B = NInt<UInt<UTerm, B1>>;
19595 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19596
19597 #[allow(non_camel_case_types)]
19598 type P5DivN1 = <<A as Div<B>>::Output as Same<N5>>::Output;
19599
19600 assert_eq!(<P5DivN1 as Integer>::to_i64(), <N5 as Integer>::to_i64());
19601 }
19602 #[test]
19603 #[allow(non_snake_case)]
19604 fn test_P5_Rem_N1() {
19605 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19606 type B = NInt<UInt<UTerm, B1>>;
19607 type _0 = Z0;
19608
19609 #[allow(non_camel_case_types)]
19610 type P5RemN1 = <<A as Rem<B>>::Output as Same<_0>>::Output;
19611
19612 assert_eq!(<P5RemN1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
19613 }
19614 #[test]
19615 #[allow(non_snake_case)]
19616 fn test_P5_PartialDiv_N1() {
19617 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19618 type B = NInt<UInt<UTerm, B1>>;
19619 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19620
19621 #[allow(non_camel_case_types)]
19622 type P5PartialDivN1 = <<A as PartialDiv<B>>::Output as Same<N5>>::Output;
19623
19624 assert_eq!(<P5PartialDivN1 as Integer>::to_i64(), <N5 as Integer>::to_i64());
19625 }
19626 #[test]
19627 #[allow(non_snake_case)]
19628 fn test_P5_Cmp_N1() {
19629 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19630 type B = NInt<UInt<UTerm, B1>>;
19631
19632 #[allow(non_camel_case_types)]
19633 type P5CmpN1 = <A as Cmp<B>>::Output;
19634 assert_eq!(<P5CmpN1 as Ord>::to_ordering(), Ordering::Greater);
19635 }
19636 #[test]
19637 #[allow(non_snake_case)]
19638 fn test_P5_Add__0() {
19639 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19640 type B = Z0;
19641 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19642
19643 #[allow(non_camel_case_types)]
19644 type P5Add_0 = <<A as Add<B>>::Output as Same<P5>>::Output;
19645
19646 assert_eq!(<P5Add_0 as Integer>::to_i64(), <P5 as Integer>::to_i64());
19647 }
19648 #[test]
19649 #[allow(non_snake_case)]
19650 fn test_P5_Sub__0() {
19651 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19652 type B = Z0;
19653 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19654
19655 #[allow(non_camel_case_types)]
19656 type P5Sub_0 = <<A as Sub<B>>::Output as Same<P5>>::Output;
19657
19658 assert_eq!(<P5Sub_0 as Integer>::to_i64(), <P5 as Integer>::to_i64());
19659 }
19660 #[test]
19661 #[allow(non_snake_case)]
19662 fn test_P5_Mul__0() {
19663 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19664 type B = Z0;
19665 type _0 = Z0;
19666
19667 #[allow(non_camel_case_types)]
19668 type P5Mul_0 = <<A as Mul<B>>::Output as Same<_0>>::Output;
19669
19670 assert_eq!(<P5Mul_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
19671 }
19672 #[test]
19673 #[allow(non_snake_case)]
19674 fn test_P5_Min__0() {
19675 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19676 type B = Z0;
19677 type _0 = Z0;
19678
19679 #[allow(non_camel_case_types)]
19680 type P5Min_0 = <<A as Min<B>>::Output as Same<_0>>::Output;
19681
19682 assert_eq!(<P5Min_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
19683 }
19684 #[test]
19685 #[allow(non_snake_case)]
19686 fn test_P5_Max__0() {
19687 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19688 type B = Z0;
19689 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19690
19691 #[allow(non_camel_case_types)]
19692 type P5Max_0 = <<A as Max<B>>::Output as Same<P5>>::Output;
19693
19694 assert_eq!(<P5Max_0 as Integer>::to_i64(), <P5 as Integer>::to_i64());
19695 }
19696 #[test]
19697 #[allow(non_snake_case)]
19698 fn test_P5_Gcd__0() {
19699 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19700 type B = Z0;
19701 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19702
19703 #[allow(non_camel_case_types)]
19704 type P5Gcd_0 = <<A as Gcd<B>>::Output as Same<P5>>::Output;
19705
19706 assert_eq!(<P5Gcd_0 as Integer>::to_i64(), <P5 as Integer>::to_i64());
19707 }
19708 #[test]
19709 #[allow(non_snake_case)]
19710 fn test_P5_Pow__0() {
19711 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19712 type B = Z0;
19713 type P1 = PInt<UInt<UTerm, B1>>;
19714
19715 #[allow(non_camel_case_types)]
19716 type P5Pow_0 = <<A as Pow<B>>::Output as Same<P1>>::Output;
19717
19718 assert_eq!(<P5Pow_0 as Integer>::to_i64(), <P1 as Integer>::to_i64());
19719 }
19720 #[test]
19721 #[allow(non_snake_case)]
19722 fn test_P5_Cmp__0() {
19723 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19724 type B = Z0;
19725
19726 #[allow(non_camel_case_types)]
19727 type P5Cmp_0 = <A as Cmp<B>>::Output;
19728 assert_eq!(<P5Cmp_0 as Ord>::to_ordering(), Ordering::Greater);
19729 }
19730 #[test]
19731 #[allow(non_snake_case)]
19732 fn test_P5_Add_P1() {
19733 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19734 type B = PInt<UInt<UTerm, B1>>;
19735 type P6 = PInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>>;
19736
19737 #[allow(non_camel_case_types)]
19738 type P5AddP1 = <<A as Add<B>>::Output as Same<P6>>::Output;
19739
19740 assert_eq!(<P5AddP1 as Integer>::to_i64(), <P6 as Integer>::to_i64());
19741 }
19742 #[test]
19743 #[allow(non_snake_case)]
19744 fn test_P5_Sub_P1() {
19745 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19746 type B = PInt<UInt<UTerm, B1>>;
19747 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
19748
19749 #[allow(non_camel_case_types)]
19750 type P5SubP1 = <<A as Sub<B>>::Output as Same<P4>>::Output;
19751
19752 assert_eq!(<P5SubP1 as Integer>::to_i64(), <P4 as Integer>::to_i64());
19753 }
19754 #[test]
19755 #[allow(non_snake_case)]
19756 fn test_P5_Mul_P1() {
19757 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19758 type B = PInt<UInt<UTerm, B1>>;
19759 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19760
19761 #[allow(non_camel_case_types)]
19762 type P5MulP1 = <<A as Mul<B>>::Output as Same<P5>>::Output;
19763
19764 assert_eq!(<P5MulP1 as Integer>::to_i64(), <P5 as Integer>::to_i64());
19765 }
19766 #[test]
19767 #[allow(non_snake_case)]
19768 fn test_P5_Min_P1() {
19769 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19770 type B = PInt<UInt<UTerm, B1>>;
19771 type P1 = PInt<UInt<UTerm, B1>>;
19772
19773 #[allow(non_camel_case_types)]
19774 type P5MinP1 = <<A as Min<B>>::Output as Same<P1>>::Output;
19775
19776 assert_eq!(<P5MinP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
19777 }
19778 #[test]
19779 #[allow(non_snake_case)]
19780 fn test_P5_Max_P1() {
19781 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19782 type B = PInt<UInt<UTerm, B1>>;
19783 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19784
19785 #[allow(non_camel_case_types)]
19786 type P5MaxP1 = <<A as Max<B>>::Output as Same<P5>>::Output;
19787
19788 assert_eq!(<P5MaxP1 as Integer>::to_i64(), <P5 as Integer>::to_i64());
19789 }
19790 #[test]
19791 #[allow(non_snake_case)]
19792 fn test_P5_Gcd_P1() {
19793 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19794 type B = PInt<UInt<UTerm, B1>>;
19795 type P1 = PInt<UInt<UTerm, B1>>;
19796
19797 #[allow(non_camel_case_types)]
19798 type P5GcdP1 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
19799
19800 assert_eq!(<P5GcdP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
19801 }
19802 #[test]
19803 #[allow(non_snake_case)]
19804 fn test_P5_Div_P1() {
19805 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19806 type B = PInt<UInt<UTerm, B1>>;
19807 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19808
19809 #[allow(non_camel_case_types)]
19810 type P5DivP1 = <<A as Div<B>>::Output as Same<P5>>::Output;
19811
19812 assert_eq!(<P5DivP1 as Integer>::to_i64(), <P5 as Integer>::to_i64());
19813 }
19814 #[test]
19815 #[allow(non_snake_case)]
19816 fn test_P5_Rem_P1() {
19817 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19818 type B = PInt<UInt<UTerm, B1>>;
19819 type _0 = Z0;
19820
19821 #[allow(non_camel_case_types)]
19822 type P5RemP1 = <<A as Rem<B>>::Output as Same<_0>>::Output;
19823
19824 assert_eq!(<P5RemP1 as Integer>::to_i64(), <_0 as Integer>::to_i64());
19825 }
19826 #[test]
19827 #[allow(non_snake_case)]
19828 fn test_P5_PartialDiv_P1() {
19829 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19830 type B = PInt<UInt<UTerm, B1>>;
19831 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19832
19833 #[allow(non_camel_case_types)]
19834 type P5PartialDivP1 = <<A as PartialDiv<B>>::Output as Same<P5>>::Output;
19835
19836 assert_eq!(<P5PartialDivP1 as Integer>::to_i64(), <P5 as Integer>::to_i64());
19837 }
19838 #[test]
19839 #[allow(non_snake_case)]
19840 fn test_P5_Pow_P1() {
19841 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19842 type B = PInt<UInt<UTerm, B1>>;
19843 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19844
19845 #[allow(non_camel_case_types)]
19846 type P5PowP1 = <<A as Pow<B>>::Output as Same<P5>>::Output;
19847
19848 assert_eq!(<P5PowP1 as Integer>::to_i64(), <P5 as Integer>::to_i64());
19849 }
19850 #[test]
19851 #[allow(non_snake_case)]
19852 fn test_P5_Cmp_P1() {
19853 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19854 type B = PInt<UInt<UTerm, B1>>;
19855
19856 #[allow(non_camel_case_types)]
19857 type P5CmpP1 = <A as Cmp<B>>::Output;
19858 assert_eq!(<P5CmpP1 as Ord>::to_ordering(), Ordering::Greater);
19859 }
19860 #[test]
19861 #[allow(non_snake_case)]
19862 fn test_P5_Add_P2() {
19863 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19864 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
19865 type P7 = PInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>>;
19866
19867 #[allow(non_camel_case_types)]
19868 type P5AddP2 = <<A as Add<B>>::Output as Same<P7>>::Output;
19869
19870 assert_eq!(<P5AddP2 as Integer>::to_i64(), <P7 as Integer>::to_i64());
19871 }
19872 #[test]
19873 #[allow(non_snake_case)]
19874 fn test_P5_Sub_P2() {
19875 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19876 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
19877 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
19878
19879 #[allow(non_camel_case_types)]
19880 type P5SubP2 = <<A as Sub<B>>::Output as Same<P3>>::Output;
19881
19882 assert_eq!(<P5SubP2 as Integer>::to_i64(), <P3 as Integer>::to_i64());
19883 }
19884 #[test]
19885 #[allow(non_snake_case)]
19886 fn test_P5_Mul_P2() {
19887 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19888 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
19889 type P10 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>;
19890
19891 #[allow(non_camel_case_types)]
19892 type P5MulP2 = <<A as Mul<B>>::Output as Same<P10>>::Output;
19893
19894 assert_eq!(<P5MulP2 as Integer>::to_i64(), <P10 as Integer>::to_i64());
19895 }
19896 #[test]
19897 #[allow(non_snake_case)]
19898 fn test_P5_Min_P2() {
19899 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19900 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
19901 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
19902
19903 #[allow(non_camel_case_types)]
19904 type P5MinP2 = <<A as Min<B>>::Output as Same<P2>>::Output;
19905
19906 assert_eq!(<P5MinP2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
19907 }
19908 #[test]
19909 #[allow(non_snake_case)]
19910 fn test_P5_Max_P2() {
19911 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19912 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
19913 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19914
19915 #[allow(non_camel_case_types)]
19916 type P5MaxP2 = <<A as Max<B>>::Output as Same<P5>>::Output;
19917
19918 assert_eq!(<P5MaxP2 as Integer>::to_i64(), <P5 as Integer>::to_i64());
19919 }
19920 #[test]
19921 #[allow(non_snake_case)]
19922 fn test_P5_Gcd_P2() {
19923 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19924 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
19925 type P1 = PInt<UInt<UTerm, B1>>;
19926
19927 #[allow(non_camel_case_types)]
19928 type P5GcdP2 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
19929
19930 assert_eq!(<P5GcdP2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
19931 }
19932 #[test]
19933 #[allow(non_snake_case)]
19934 fn test_P5_Div_P2() {
19935 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19936 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
19937 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
19938
19939 #[allow(non_camel_case_types)]
19940 type P5DivP2 = <<A as Div<B>>::Output as Same<P2>>::Output;
19941
19942 assert_eq!(<P5DivP2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
19943 }
19944 #[test]
19945 #[allow(non_snake_case)]
19946 fn test_P5_Rem_P2() {
19947 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19948 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
19949 type P1 = PInt<UInt<UTerm, B1>>;
19950
19951 #[allow(non_camel_case_types)]
19952 type P5RemP2 = <<A as Rem<B>>::Output as Same<P1>>::Output;
19953
19954 assert_eq!(<P5RemP2 as Integer>::to_i64(), <P1 as Integer>::to_i64());
19955 }
19956 #[test]
19957 #[allow(non_snake_case)]
19958 fn test_P5_Pow_P2() {
19959 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19960 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
19961 type P25 = PInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>>;
19962
19963 #[allow(non_camel_case_types)]
19964 type P5PowP2 = <<A as Pow<B>>::Output as Same<P25>>::Output;
19965
19966 assert_eq!(<P5PowP2 as Integer>::to_i64(), <P25 as Integer>::to_i64());
19967 }
19968 #[test]
19969 #[allow(non_snake_case)]
19970 fn test_P5_Cmp_P2() {
19971 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19972 type B = PInt<UInt<UInt<UTerm, B1>, B0>>;
19973
19974 #[allow(non_camel_case_types)]
19975 type P5CmpP2 = <A as Cmp<B>>::Output;
19976 assert_eq!(<P5CmpP2 as Ord>::to_ordering(), Ordering::Greater);
19977 }
19978 #[test]
19979 #[allow(non_snake_case)]
19980 fn test_P5_Add_P3() {
19981 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19982 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
19983 type P8 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B0>>;
19984
19985 #[allow(non_camel_case_types)]
19986 type P5AddP3 = <<A as Add<B>>::Output as Same<P8>>::Output;
19987
19988 assert_eq!(<P5AddP3 as Integer>::to_i64(), <P8 as Integer>::to_i64());
19989 }
19990 #[test]
19991 #[allow(non_snake_case)]
19992 fn test_P5_Sub_P3() {
19993 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
19994 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
19995 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
19996
19997 #[allow(non_camel_case_types)]
19998 type P5SubP3 = <<A as Sub<B>>::Output as Same<P2>>::Output;
19999
20000 assert_eq!(<P5SubP3 as Integer>::to_i64(), <P2 as Integer>::to_i64());
20001 }
20002 #[test]
20003 #[allow(non_snake_case)]
20004 fn test_P5_Mul_P3() {
20005 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20006 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
20007 type P15 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>>;
20008
20009 #[allow(non_camel_case_types)]
20010 type P5MulP3 = <<A as Mul<B>>::Output as Same<P15>>::Output;
20011
20012 assert_eq!(<P5MulP3 as Integer>::to_i64(), <P15 as Integer>::to_i64());
20013 }
20014 #[test]
20015 #[allow(non_snake_case)]
20016 fn test_P5_Min_P3() {
20017 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20018 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
20019 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
20020
20021 #[allow(non_camel_case_types)]
20022 type P5MinP3 = <<A as Min<B>>::Output as Same<P3>>::Output;
20023
20024 assert_eq!(<P5MinP3 as Integer>::to_i64(), <P3 as Integer>::to_i64());
20025 }
20026 #[test]
20027 #[allow(non_snake_case)]
20028 fn test_P5_Max_P3() {
20029 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20030 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
20031 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20032
20033 #[allow(non_camel_case_types)]
20034 type P5MaxP3 = <<A as Max<B>>::Output as Same<P5>>::Output;
20035
20036 assert_eq!(<P5MaxP3 as Integer>::to_i64(), <P5 as Integer>::to_i64());
20037 }
20038 #[test]
20039 #[allow(non_snake_case)]
20040 fn test_P5_Gcd_P3() {
20041 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20042 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
20043 type P1 = PInt<UInt<UTerm, B1>>;
20044
20045 #[allow(non_camel_case_types)]
20046 type P5GcdP3 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
20047
20048 assert_eq!(<P5GcdP3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
20049 }
20050 #[test]
20051 #[allow(non_snake_case)]
20052 fn test_P5_Div_P3() {
20053 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20054 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
20055 type P1 = PInt<UInt<UTerm, B1>>;
20056
20057 #[allow(non_camel_case_types)]
20058 type P5DivP3 = <<A as Div<B>>::Output as Same<P1>>::Output;
20059
20060 assert_eq!(<P5DivP3 as Integer>::to_i64(), <P1 as Integer>::to_i64());
20061 }
20062 #[test]
20063 #[allow(non_snake_case)]
20064 fn test_P5_Rem_P3() {
20065 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20066 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
20067 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
20068
20069 #[allow(non_camel_case_types)]
20070 type P5RemP3 = <<A as Rem<B>>::Output as Same<P2>>::Output;
20071
20072 assert_eq!(<P5RemP3 as Integer>::to_i64(), <P2 as Integer>::to_i64());
20073 }
20074 #[test]
20075 #[allow(non_snake_case)]
20076 fn test_P5_Pow_P3() {
20077 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20078 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
20079 type P125 = PInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B1>, B1>, B1>, B0>, B1>>;
20080
20081 #[allow(non_camel_case_types)]
20082 type P5PowP3 = <<A as Pow<B>>::Output as Same<P125>>::Output;
20083
20084 assert_eq!(<P5PowP3 as Integer>::to_i64(), <P125 as Integer>::to_i64());
20085 }
20086 #[test]
20087 #[allow(non_snake_case)]
20088 fn test_P5_Cmp_P3() {
20089 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20090 type B = PInt<UInt<UInt<UTerm, B1>, B1>>;
20091
20092 #[allow(non_camel_case_types)]
20093 type P5CmpP3 = <A as Cmp<B>>::Output;
20094 assert_eq!(<P5CmpP3 as Ord>::to_ordering(), Ordering::Greater);
20095 }
20096 #[test]
20097 #[allow(non_snake_case)]
20098 fn test_P5_Add_P4() {
20099 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20100 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
20101 type P9 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>>;
20102
20103 #[allow(non_camel_case_types)]
20104 type P5AddP4 = <<A as Add<B>>::Output as Same<P9>>::Output;
20105
20106 assert_eq!(<P5AddP4 as Integer>::to_i64(), <P9 as Integer>::to_i64());
20107 }
20108 #[test]
20109 #[allow(non_snake_case)]
20110 fn test_P5_Sub_P4() {
20111 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20112 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
20113 type P1 = PInt<UInt<UTerm, B1>>;
20114
20115 #[allow(non_camel_case_types)]
20116 type P5SubP4 = <<A as Sub<B>>::Output as Same<P1>>::Output;
20117
20118 assert_eq!(<P5SubP4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
20119 }
20120 #[test]
20121 #[allow(non_snake_case)]
20122 fn test_P5_Mul_P4() {
20123 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20124 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
20125 type P20 = PInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>, B0>>;
20126
20127 #[allow(non_camel_case_types)]
20128 type P5MulP4 = <<A as Mul<B>>::Output as Same<P20>>::Output;
20129
20130 assert_eq!(<P5MulP4 as Integer>::to_i64(), <P20 as Integer>::to_i64());
20131 }
20132 #[test]
20133 #[allow(non_snake_case)]
20134 fn test_P5_Min_P4() {
20135 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20136 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
20137 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
20138
20139 #[allow(non_camel_case_types)]
20140 type P5MinP4 = <<A as Min<B>>::Output as Same<P4>>::Output;
20141
20142 assert_eq!(<P5MinP4 as Integer>::to_i64(), <P4 as Integer>::to_i64());
20143 }
20144 #[test]
20145 #[allow(non_snake_case)]
20146 fn test_P5_Max_P4() {
20147 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20148 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
20149 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20150
20151 #[allow(non_camel_case_types)]
20152 type P5MaxP4 = <<A as Max<B>>::Output as Same<P5>>::Output;
20153
20154 assert_eq!(<P5MaxP4 as Integer>::to_i64(), <P5 as Integer>::to_i64());
20155 }
20156 #[test]
20157 #[allow(non_snake_case)]
20158 fn test_P5_Gcd_P4() {
20159 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20160 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
20161 type P1 = PInt<UInt<UTerm, B1>>;
20162
20163 #[allow(non_camel_case_types)]
20164 type P5GcdP4 = <<A as Gcd<B>>::Output as Same<P1>>::Output;
20165
20166 assert_eq!(<P5GcdP4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
20167 }
20168 #[test]
20169 #[allow(non_snake_case)]
20170 fn test_P5_Div_P4() {
20171 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20172 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
20173 type P1 = PInt<UInt<UTerm, B1>>;
20174
20175 #[allow(non_camel_case_types)]
20176 type P5DivP4 = <<A as Div<B>>::Output as Same<P1>>::Output;
20177
20178 assert_eq!(<P5DivP4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
20179 }
20180 #[test]
20181 #[allow(non_snake_case)]
20182 fn test_P5_Rem_P4() {
20183 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20184 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
20185 type P1 = PInt<UInt<UTerm, B1>>;
20186
20187 #[allow(non_camel_case_types)]
20188 type P5RemP4 = <<A as Rem<B>>::Output as Same<P1>>::Output;
20189
20190 assert_eq!(<P5RemP4 as Integer>::to_i64(), <P1 as Integer>::to_i64());
20191 }
20192 #[test]
20193 #[allow(non_snake_case)]
20194 fn test_P5_Pow_P4() {
20195 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20196 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
20197 type P625 = PInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>, B1>, B1>, B0>, B0>, B0>, B1>>;
20198
20199 #[allow(non_camel_case_types)]
20200 type P5PowP4 = <<A as Pow<B>>::Output as Same<P625>>::Output;
20201
20202 assert_eq!(<P5PowP4 as Integer>::to_i64(), <P625 as Integer>::to_i64());
20203 }
20204 #[test]
20205 #[allow(non_snake_case)]
20206 fn test_P5_Cmp_P4() {
20207 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20208 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
20209
20210 #[allow(non_camel_case_types)]
20211 type P5CmpP4 = <A as Cmp<B>>::Output;
20212 assert_eq!(<P5CmpP4 as Ord>::to_ordering(), Ordering::Greater);
20213 }
20214 #[test]
20215 #[allow(non_snake_case)]
20216 fn test_P5_Add_P5() {
20217 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20218 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20219 type P10 = PInt<UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>, B0>>;
20220
20221 #[allow(non_camel_case_types)]
20222 type P5AddP5 = <<A as Add<B>>::Output as Same<P10>>::Output;
20223
20224 assert_eq!(<P5AddP5 as Integer>::to_i64(), <P10 as Integer>::to_i64());
20225 }
20226 #[test]
20227 #[allow(non_snake_case)]
20228 fn test_P5_Sub_P5() {
20229 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20230 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20231 type _0 = Z0;
20232
20233 #[allow(non_camel_case_types)]
20234 type P5SubP5 = <<A as Sub<B>>::Output as Same<_0>>::Output;
20235
20236 assert_eq!(<P5SubP5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
20237 }
20238 #[test]
20239 #[allow(non_snake_case)]
20240 fn test_P5_Mul_P5() {
20241 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20242 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20243 type P25 = PInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B1>>;
20244
20245 #[allow(non_camel_case_types)]
20246 type P5MulP5 = <<A as Mul<B>>::Output as Same<P25>>::Output;
20247
20248 assert_eq!(<P5MulP5 as Integer>::to_i64(), <P25 as Integer>::to_i64());
20249 }
20250 #[test]
20251 #[allow(non_snake_case)]
20252 fn test_P5_Min_P5() {
20253 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20254 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20255 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20256
20257 #[allow(non_camel_case_types)]
20258 type P5MinP5 = <<A as Min<B>>::Output as Same<P5>>::Output;
20259
20260 assert_eq!(<P5MinP5 as Integer>::to_i64(), <P5 as Integer>::to_i64());
20261 }
20262 #[test]
20263 #[allow(non_snake_case)]
20264 fn test_P5_Max_P5() {
20265 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20266 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20267 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20268
20269 #[allow(non_camel_case_types)]
20270 type P5MaxP5 = <<A as Max<B>>::Output as Same<P5>>::Output;
20271
20272 assert_eq!(<P5MaxP5 as Integer>::to_i64(), <P5 as Integer>::to_i64());
20273 }
20274 #[test]
20275 #[allow(non_snake_case)]
20276 fn test_P5_Gcd_P5() {
20277 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20278 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20279 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20280
20281 #[allow(non_camel_case_types)]
20282 type P5GcdP5 = <<A as Gcd<B>>::Output as Same<P5>>::Output;
20283
20284 assert_eq!(<P5GcdP5 as Integer>::to_i64(), <P5 as Integer>::to_i64());
20285 }
20286 #[test]
20287 #[allow(non_snake_case)]
20288 fn test_P5_Div_P5() {
20289 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20290 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20291 type P1 = PInt<UInt<UTerm, B1>>;
20292
20293 #[allow(non_camel_case_types)]
20294 type P5DivP5 = <<A as Div<B>>::Output as Same<P1>>::Output;
20295
20296 assert_eq!(<P5DivP5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
20297 }
20298 #[test]
20299 #[allow(non_snake_case)]
20300 fn test_P5_Rem_P5() {
20301 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20302 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20303 type _0 = Z0;
20304
20305 #[allow(non_camel_case_types)]
20306 type P5RemP5 = <<A as Rem<B>>::Output as Same<_0>>::Output;
20307
20308 assert_eq!(<P5RemP5 as Integer>::to_i64(), <_0 as Integer>::to_i64());
20309 }
20310 #[test]
20311 #[allow(non_snake_case)]
20312 fn test_P5_PartialDiv_P5() {
20313 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20314 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20315 type P1 = PInt<UInt<UTerm, B1>>;
20316
20317 #[allow(non_camel_case_types)]
20318 type P5PartialDivP5 = <<A as PartialDiv<B>>::Output as Same<P1>>::Output;
20319
20320 assert_eq!(<P5PartialDivP5 as Integer>::to_i64(), <P1 as Integer>::to_i64());
20321 }
20322 #[test]
20323 #[allow(non_snake_case)]
20324 fn test_P5_Pow_P5() {
20325 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20326 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20327 type P3125 = PInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UInt<UTerm, B1>, B1>, B0>, B0>, B0>, B0>, B1>, B1>, B0>, B1>, B0>, B1>>;
20328
20329 #[allow(non_camel_case_types)]
20330 type P5PowP5 = <<A as Pow<B>>::Output as Same<P3125>>::Output;
20331
20332 assert_eq!(<P5PowP5 as Integer>::to_i64(), <P3125 as Integer>::to_i64());
20333 }
20334 #[test]
20335 #[allow(non_snake_case)]
20336 fn test_P5_Cmp_P5() {
20337 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20338 type B = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20339
20340 #[allow(non_camel_case_types)]
20341 type P5CmpP5 = <A as Cmp<B>>::Output;
20342 assert_eq!(<P5CmpP5 as Ord>::to_ordering(), Ordering::Equal);
20343 }
20344 #[test]
20345 #[allow(non_snake_case)]
20346 fn test_N5_Neg() {
20347 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20348 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20349
20350 #[allow(non_camel_case_types)]
20351 type NegN5 = <<A as Neg>::Output as Same<P5>>::Output;
20352 assert_eq!(<NegN5 as Integer>::to_i64(), <P5 as Integer>::to_i64());
20353 }
20354 #[test]
20355 #[allow(non_snake_case)]
20356 fn test_N5_Abs() {
20357 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20358 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20359
20360 #[allow(non_camel_case_types)]
20361 type AbsN5 = <<A as Abs>::Output as Same<P5>>::Output;
20362 assert_eq!(<AbsN5 as Integer>::to_i64(), <P5 as Integer>::to_i64());
20363 }
20364 #[test]
20365 #[allow(non_snake_case)]
20366 fn test_N4_Neg() {
20367 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
20368 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
20369
20370 #[allow(non_camel_case_types)]
20371 type NegN4 = <<A as Neg>::Output as Same<P4>>::Output;
20372 assert_eq!(<NegN4 as Integer>::to_i64(), <P4 as Integer>::to_i64());
20373 }
20374 #[test]
20375 #[allow(non_snake_case)]
20376 fn test_N4_Abs() {
20377 type A = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
20378 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
20379
20380 #[allow(non_camel_case_types)]
20381 type AbsN4 = <<A as Abs>::Output as Same<P4>>::Output;
20382 assert_eq!(<AbsN4 as Integer>::to_i64(), <P4 as Integer>::to_i64());
20383 }
20384 #[test]
20385 #[allow(non_snake_case)]
20386 fn test_N3_Neg() {
20387 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
20388 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
20389
20390 #[allow(non_camel_case_types)]
20391 type NegN3 = <<A as Neg>::Output as Same<P3>>::Output;
20392 assert_eq!(<NegN3 as Integer>::to_i64(), <P3 as Integer>::to_i64());
20393 }
20394 #[test]
20395 #[allow(non_snake_case)]
20396 fn test_N3_Abs() {
20397 type A = NInt<UInt<UInt<UTerm, B1>, B1>>;
20398 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
20399
20400 #[allow(non_camel_case_types)]
20401 type AbsN3 = <<A as Abs>::Output as Same<P3>>::Output;
20402 assert_eq!(<AbsN3 as Integer>::to_i64(), <P3 as Integer>::to_i64());
20403 }
20404 #[test]
20405 #[allow(non_snake_case)]
20406 fn test_N2_Neg() {
20407 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
20408 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
20409
20410 #[allow(non_camel_case_types)]
20411 type NegN2 = <<A as Neg>::Output as Same<P2>>::Output;
20412 assert_eq!(<NegN2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
20413 }
20414 #[test]
20415 #[allow(non_snake_case)]
20416 fn test_N2_Abs() {
20417 type A = NInt<UInt<UInt<UTerm, B1>, B0>>;
20418 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
20419
20420 #[allow(non_camel_case_types)]
20421 type AbsN2 = <<A as Abs>::Output as Same<P2>>::Output;
20422 assert_eq!(<AbsN2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
20423 }
20424 #[test]
20425 #[allow(non_snake_case)]
20426 fn test_N1_Neg() {
20427 type A = NInt<UInt<UTerm, B1>>;
20428 type P1 = PInt<UInt<UTerm, B1>>;
20429
20430 #[allow(non_camel_case_types)]
20431 type NegN1 = <<A as Neg>::Output as Same<P1>>::Output;
20432 assert_eq!(<NegN1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
20433 }
20434 #[test]
20435 #[allow(non_snake_case)]
20436 fn test_N1_Abs() {
20437 type A = NInt<UInt<UTerm, B1>>;
20438 type P1 = PInt<UInt<UTerm, B1>>;
20439
20440 #[allow(non_camel_case_types)]
20441 type AbsN1 = <<A as Abs>::Output as Same<P1>>::Output;
20442 assert_eq!(<AbsN1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
20443 }
20444 #[test]
20445 #[allow(non_snake_case)]
20446 fn test__0_Neg() {
20447 type A = Z0;
20448 type _0 = Z0;
20449
20450 #[allow(non_camel_case_types)]
20451 type Neg_0 = <<A as Neg>::Output as Same<_0>>::Output;
20452 assert_eq!(<Neg_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
20453 }
20454 #[test]
20455 #[allow(non_snake_case)]
20456 fn test__0_Abs() {
20457 type A = Z0;
20458 type _0 = Z0;
20459
20460 #[allow(non_camel_case_types)]
20461 type Abs_0 = <<A as Abs>::Output as Same<_0>>::Output;
20462 assert_eq!(<Abs_0 as Integer>::to_i64(), <_0 as Integer>::to_i64());
20463 }
20464 #[test]
20465 #[allow(non_snake_case)]
20466 fn test_P1_Neg() {
20467 type A = PInt<UInt<UTerm, B1>>;
20468 type N1 = NInt<UInt<UTerm, B1>>;
20469
20470 #[allow(non_camel_case_types)]
20471 type NegP1 = <<A as Neg>::Output as Same<N1>>::Output;
20472 assert_eq!(<NegP1 as Integer>::to_i64(), <N1 as Integer>::to_i64());
20473 }
20474 #[test]
20475 #[allow(non_snake_case)]
20476 fn test_P1_Abs() {
20477 type A = PInt<UInt<UTerm, B1>>;
20478 type P1 = PInt<UInt<UTerm, B1>>;
20479
20480 #[allow(non_camel_case_types)]
20481 type AbsP1 = <<A as Abs>::Output as Same<P1>>::Output;
20482 assert_eq!(<AbsP1 as Integer>::to_i64(), <P1 as Integer>::to_i64());
20483 }
20484 #[test]
20485 #[allow(non_snake_case)]
20486 fn test_P2_Neg() {
20487 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
20488 type N2 = NInt<UInt<UInt<UTerm, B1>, B0>>;
20489
20490 #[allow(non_camel_case_types)]
20491 type NegP2 = <<A as Neg>::Output as Same<N2>>::Output;
20492 assert_eq!(<NegP2 as Integer>::to_i64(), <N2 as Integer>::to_i64());
20493 }
20494 #[test]
20495 #[allow(non_snake_case)]
20496 fn test_P2_Abs() {
20497 type A = PInt<UInt<UInt<UTerm, B1>, B0>>;
20498 type P2 = PInt<UInt<UInt<UTerm, B1>, B0>>;
20499
20500 #[allow(non_camel_case_types)]
20501 type AbsP2 = <<A as Abs>::Output as Same<P2>>::Output;
20502 assert_eq!(<AbsP2 as Integer>::to_i64(), <P2 as Integer>::to_i64());
20503 }
20504 #[test]
20505 #[allow(non_snake_case)]
20506 fn test_P3_Neg() {
20507 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
20508 type N3 = NInt<UInt<UInt<UTerm, B1>, B1>>;
20509
20510 #[allow(non_camel_case_types)]
20511 type NegP3 = <<A as Neg>::Output as Same<N3>>::Output;
20512 assert_eq!(<NegP3 as Integer>::to_i64(), <N3 as Integer>::to_i64());
20513 }
20514 #[test]
20515 #[allow(non_snake_case)]
20516 fn test_P3_Abs() {
20517 type A = PInt<UInt<UInt<UTerm, B1>, B1>>;
20518 type P3 = PInt<UInt<UInt<UTerm, B1>, B1>>;
20519
20520 #[allow(non_camel_case_types)]
20521 type AbsP3 = <<A as Abs>::Output as Same<P3>>::Output;
20522 assert_eq!(<AbsP3 as Integer>::to_i64(), <P3 as Integer>::to_i64());
20523 }
20524 #[test]
20525 #[allow(non_snake_case)]
20526 fn test_P4_Neg() {
20527 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
20528 type N4 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
20529
20530 #[allow(non_camel_case_types)]
20531 type NegP4 = <<A as Neg>::Output as Same<N4>>::Output;
20532 assert_eq!(<NegP4 as Integer>::to_i64(), <N4 as Integer>::to_i64());
20533 }
20534 #[test]
20535 #[allow(non_snake_case)]
20536 fn test_P4_Abs() {
20537 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
20538 type P4 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>>;
20539
20540 #[allow(non_camel_case_types)]
20541 type AbsP4 = <<A as Abs>::Output as Same<P4>>::Output;
20542 assert_eq!(<AbsP4 as Integer>::to_i64(), <P4 as Integer>::to_i64());
20543 }
20544 #[test]
20545 #[allow(non_snake_case)]
20546 fn test_P5_Neg() {
20547 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20548 type N5 = NInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20549
20550 #[allow(non_camel_case_types)]
20551 type NegP5 = <<A as Neg>::Output as Same<N5>>::Output;
20552 assert_eq!(<NegP5 as Integer>::to_i64(), <N5 as Integer>::to_i64());
20553 }
20554 #[test]
20555 #[allow(non_snake_case)]
20556 fn test_P5_Abs() {
20557 type A = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20558 type P5 = PInt<UInt<UInt<UInt<UTerm, B1>, B0>, B1>>;
20559
20560 #[allow(non_camel_case_types)]
20561 type AbsP5 = <<A as Abs>::Output as Same<P5>>::Output;
20562 assert_eq!(<AbsP5 as Integer>::to_i64(), <P5 as Integer>::to_i64());
20563 }