Line data Source code
1 : // Copyright (c) 2021-2023 Made to Order Software Corp. All Rights Reserved
2 : //
3 : // https://snapwebsites.org/project/snapdev
4 : // contact@m2osw.com
5 : //
6 : // This program is free software: you can redistribute it and/or modify
7 : // it under the terms of the GNU General Public License as published by
8 : // the Free Software Foundation, either version 3 of the License, or
9 : // (at your option) any later version.
10 : //
11 : // This program is distributed in the hope that it will be useful,
12 : // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 : // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 : // GNU General Public License for more details.
15 : //
16 : // You should have received a copy of the GNU General Public License
17 : // along with this program. If not, see <https://www.gnu.org/licenses/>.
18 :
19 : /** \file
20 : * \brief Verify the various __int128 extension functions.
21 : *
22 : * This file implements tests to verify:
23 : *
24 : * * support printing out 128 bit numbers
25 : * * support of 128 bit literals
26 : * * support of 128 bit powers
27 : */
28 :
29 : // self
30 : //
31 : #include "catch_main.h"
32 :
33 :
34 :
35 : // snapdev lib
36 : //
37 : #include <snapdev/ostream_int128.h>
38 : #include <snapdev/int128_literal.h>
39 : #include <snapdev/math.h>
40 :
41 :
42 : // last include
43 : //
44 : #include <snapdev/poison.h>
45 :
46 :
47 : // __int128 is not ISO C++ yet
48 : #pragma GCC diagnostic ignored "-Wpedantic"
49 :
50 :
51 5 : CATCH_TEST_CASE("ostream_int128", "[ostream][int128]")
52 : {
53 5 : CATCH_START_SECTION("ostream_int128: small numbers (-10 to +10)")
54 : {
55 22 : for(int i(-10); i <= 10; ++i)
56 : {
57 21 : __int128 l(i);
58 :
59 : // decimal
60 : {
61 21 : std::stringstream v;
62 21 : v << l;
63 21 : CATCH_REQUIRE(v.str() == std::to_string(i));
64 21 : }
65 : {
66 21 : std::stringstream v;
67 21 : v << std::showpos << l;
68 21 : CATCH_REQUIRE(v.str() == (i >= 0 ? "+" : "") + std::to_string(i));
69 21 : }
70 :
71 : // hexadecimal
72 : {
73 21 : std::stringstream v, e;
74 21 : v << std::hex << l;
75 21 : e << (i < 0 ? "ffffffffffffffffffffffff" : "") << std::hex << i;
76 21 : CATCH_REQUIRE(v.str() == e.str());
77 21 : }
78 : {
79 21 : std::stringstream v, e;
80 21 : v << std::showpos << std::hex << l;
81 21 : e << (i < 0 ? "ffffffffffffffffffffffff" : "") << std::hex << i;
82 21 : CATCH_REQUIRE(v.str() == e.str());
83 21 : }
84 : {
85 21 : std::stringstream v, e;
86 21 : v << std::hex << std::uppercase << l;
87 21 : e << (i < 0 ? "FFFFFFFFFFFFFFFFFFFFFFFF" : "") << std::hex << std::uppercase << i;
88 21 : CATCH_REQUIRE(v.str() == e.str());
89 21 : }
90 : {
91 21 : std::stringstream v, e;
92 21 : v << std::hex << std::showbase << l;
93 21 : e << (i < 0 ? "0xffffffffffffffffffffffff" : "0x") << std::hex << i;
94 21 : CATCH_REQUIRE(v.str() == (i == 0 ? "0" : e.str()));
95 21 : }
96 : {
97 21 : std::stringstream v, e;
98 21 : v << std::hex << std::showbase << std::uppercase << std::showpos << l;
99 21 : e << (i < 0 ? "0XFFFFFFFFFFFFFFFFFFFFFFFF" : "0X") << std::hex << std::uppercase << i;
100 21 : CATCH_REQUIRE(v.str() == (i == 0 ? "0" : e.str()));
101 21 : }
102 :
103 : // octal
104 : {
105 21 : std::stringstream v, e;
106 21 : v << std::oct << l;
107 21 : e << (i < 0 ? "37777777777777777777777777777777" : "") << std::oct << (i & 0x1FFFFFFFF);
108 21 : CATCH_REQUIRE(v.str() == e.str());
109 21 : }
110 : {
111 21 : std::stringstream v, e;
112 21 : v << std::oct << std::showbase << l;
113 21 : e << (i < 0 ? "037777777777777777777777777777777" : "0") << std::oct << (i & 0x1FFFFFFFF);
114 21 : CATCH_REQUIRE(v.str() == (i == 0 ? "0" : e.str()));
115 21 : }
116 : {
117 21 : std::stringstream v, e;
118 21 : v << std::oct << std::showpos << std::showbase << l;
119 21 : e << (i < 0 ? "037777777777777777777777777777777" : "0") << std::oct << (i & 0x1FFFFFFFF);
120 21 : CATCH_REQUIRE(v.str() == (i == 0 ? "0" : e.str()));
121 21 : }
122 : }
123 : }
124 5 : CATCH_END_SECTION()
125 :
126 5 : CATCH_START_SECTION("ostream_int128: positive numbers")
127 : {
128 1001 : for(int i(0); i < 1000; ++i)
129 : {
130 1000 : std::int32_t v((rand() & 0x7FFFFFFF));
131 1000 : __int128 l(v);
132 1000 : std::stringstream ss;
133 1000 : ss << l;
134 1000 : CATCH_REQUIRE(ss.str() == std::to_string(v));
135 1000 : }
136 : }
137 5 : CATCH_END_SECTION()
138 :
139 5 : CATCH_START_SECTION("ostream_int128: negative numbers")
140 : {
141 1001 : for(int i(0); i < 1000; ++i)
142 : {
143 1000 : std::int32_t v(-(rand() & 0x7FFFFFFF));
144 1000 : __int128 l(v);
145 1000 : std::stringstream ss;
146 1000 : ss << l;
147 1000 : CATCH_REQUIRE(ss.str() == std::to_string(v));
148 1000 : }
149 : }
150 5 : CATCH_END_SECTION()
151 :
152 5 : CATCH_START_SECTION("ostream_int128: most positive number")
153 : {
154 1 : unsigned __int128 l(0);
155 1 : l = ~l;
156 : {
157 1 : std::stringstream ss;
158 1 : ss << l;
159 1 : CATCH_REQUIRE(ss.str() == "340282366920938463463374607431768211455");
160 1 : }
161 : {
162 1 : std::stringstream ss;
163 1 : ss << std::hex << l;
164 1 : CATCH_REQUIRE(ss.str() == "ffffffffffffffffffffffffffffffff");
165 1 : }
166 : {
167 1 : std::stringstream ss;
168 1 : ss << std::hex << std::uppercase << l;
169 1 : CATCH_REQUIRE(ss.str() == "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
170 1 : }
171 : {
172 1 : std::stringstream ss;
173 1 : ss << std::hex << std::showbase << l;
174 1 : CATCH_REQUIRE(ss.str() == "0xffffffffffffffffffffffffffffffff");
175 1 : }
176 : {
177 1 : std::stringstream ss;
178 1 : ss << std::hex << std::uppercase << std::showbase << l;
179 1 : CATCH_REQUIRE(ss.str() == "0XFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF");
180 1 : }
181 : }
182 5 : CATCH_END_SECTION()
183 :
184 5 : CATCH_START_SECTION("ostream_int128: most negative number")
185 : {
186 1 : __int128 l(1);
187 1 : l <<= 127;
188 : {
189 1 : std::stringstream ss;
190 1 : ss << l;
191 1 : CATCH_REQUIRE(ss.str() == "-170141183460469231731687303715884105728");
192 1 : }
193 : {
194 1 : std::stringstream ss;
195 1 : ss << std::hex << l;
196 1 : CATCH_REQUIRE(ss.str() == "80000000000000000000000000000000");
197 1 : }
198 : }
199 5 : CATCH_END_SECTION()
200 5 : }
201 :
202 :
203 3 : CATCH_TEST_CASE("int128_literal", "[literal][int128]")
204 : {
205 3 : CATCH_START_SECTION("int128_literal: zero and powers of two")
206 : {
207 : using namespace snapdev::literals;
208 :
209 1 : __int128 m0(0_int128);
210 1 : CATCH_REQUIRE(m0 == 0);
211 :
212 1 : __int128 v(1);
213 : {
214 1 : __int128 l(1_int128);
215 1 : CATCH_REQUIRE(l == v);
216 : }
217 : {
218 1 : __int128 l("1"_int128);
219 1 : CATCH_REQUIRE(l == v);
220 : }
221 1 : v <<= 1;
222 : {
223 1 : __int128 l(2_int128);
224 1 : CATCH_REQUIRE(l == v);
225 : }
226 : {
227 1 : __int128 l("2"_int128);
228 1 : CATCH_REQUIRE(l == v);
229 : }
230 1 : v <<= 1;
231 : {
232 1 : __int128 l(4_int128);
233 1 : CATCH_REQUIRE(l == v);
234 : }
235 : {
236 1 : __int128 l("4"_int128);
237 1 : CATCH_REQUIRE(l == v);
238 : }
239 1 : v <<= 1;
240 : {
241 1 : __int128 l(8_int128);
242 1 : CATCH_REQUIRE(l == v);
243 : }
244 : {
245 1 : __int128 l("8"_int128);
246 1 : CATCH_REQUIRE(l == v);
247 : }
248 1 : v <<= 1;
249 : {
250 1 : __int128 l(16_int128);
251 1 : CATCH_REQUIRE(l == v);
252 : }
253 : {
254 1 : __int128 l("16"_int128);
255 1 : CATCH_REQUIRE(l == v);
256 : }
257 1 : v <<= 1;
258 : {
259 1 : __int128 l(32_int128);
260 1 : CATCH_REQUIRE(l == v);
261 : }
262 : {
263 1 : __int128 l("32"_int128);
264 1 : CATCH_REQUIRE(l == v);
265 : }
266 1 : v <<= 1;
267 : {
268 1 : __int128 l(64_int128);
269 1 : CATCH_REQUIRE(l == v);
270 : }
271 : {
272 1 : __int128 l("64"_int128);
273 1 : CATCH_REQUIRE(l == v);
274 : }
275 1 : v <<= 1;
276 : {
277 1 : __int128 l(128_int128);
278 1 : CATCH_REQUIRE(l == v);
279 : }
280 : {
281 1 : __int128 l("128"_int128);
282 1 : CATCH_REQUIRE(l == v);
283 : }
284 1 : v <<= 1;
285 : {
286 1 : __int128 l(256_int128);
287 1 : CATCH_REQUIRE(l == v);
288 : }
289 : {
290 1 : __int128 l("256"_int128);
291 1 : CATCH_REQUIRE(l == v);
292 : }
293 1 : v <<= 1;
294 : {
295 1 : __int128 l(512_int128);
296 1 : CATCH_REQUIRE(l == v);
297 : }
298 : {
299 1 : __int128 l("512"_int128);
300 1 : CATCH_REQUIRE(l == v);
301 : }
302 1 : v <<= 1;
303 : {
304 1 : __int128 l(1024_int128);
305 1 : CATCH_REQUIRE(l == v);
306 : }
307 : {
308 1 : __int128 l("1024"_int128);
309 1 : CATCH_REQUIRE(l == v);
310 : }
311 1 : v <<= 1;
312 : {
313 1 : __int128 l(2048_int128);
314 1 : CATCH_REQUIRE(l == v);
315 : }
316 : {
317 1 : __int128 l("2048"_int128);
318 1 : CATCH_REQUIRE(l == v);
319 : }
320 1 : v <<= 1;
321 : {
322 1 : __int128 l(4096_int128);
323 1 : CATCH_REQUIRE(l == v);
324 : }
325 : {
326 1 : __int128 l("4096"_int128);
327 1 : CATCH_REQUIRE(l == v);
328 : }
329 1 : v <<= 1;
330 : {
331 1 : __int128 l(8192_int128);
332 1 : CATCH_REQUIRE(l == v);
333 : }
334 : {
335 1 : __int128 l("8192"_int128);
336 1 : CATCH_REQUIRE(l == v);
337 : }
338 1 : v <<= 1;
339 : {
340 1 : __int128 l(16384_int128);
341 1 : CATCH_REQUIRE(l == v);
342 : }
343 : {
344 1 : __int128 l("16384"_int128);
345 1 : CATCH_REQUIRE(l == v);
346 : }
347 1 : v <<= 1;
348 : {
349 1 : __int128 l(32768_int128);
350 1 : CATCH_REQUIRE(l == v);
351 : }
352 : {
353 1 : __int128 l("32768"_int128);
354 1 : CATCH_REQUIRE(l == v);
355 : }
356 1 : v <<= 1;
357 : {
358 1 : __int128 l(65536_int128);
359 1 : CATCH_REQUIRE(l == v);
360 : }
361 : {
362 1 : __int128 l("65536"_int128);
363 1 : CATCH_REQUIRE(l == v);
364 : }
365 1 : v <<= 1;
366 : {
367 1 : __int128 l(131072_int128);
368 1 : CATCH_REQUIRE(l == v);
369 : }
370 : {
371 1 : __int128 l("131072"_int128);
372 1 : CATCH_REQUIRE(l == v);
373 : }
374 1 : v <<= 1;
375 : {
376 1 : __int128 l(262144_int128);
377 1 : CATCH_REQUIRE(l == v);
378 : }
379 : {
380 1 : __int128 l("262144"_int128);
381 1 : CATCH_REQUIRE(l == v);
382 : }
383 1 : v <<= 1;
384 : {
385 1 : __int128 l(524288_int128);
386 1 : CATCH_REQUIRE(l == v);
387 : }
388 : {
389 1 : __int128 l("524288"_int128);
390 1 : CATCH_REQUIRE(l == v);
391 : }
392 1 : v <<= 1;
393 : {
394 1 : __int128 l(1048576_int128);
395 1 : CATCH_REQUIRE(l == v);
396 : }
397 : {
398 1 : __int128 l("1048576"_int128);
399 1 : CATCH_REQUIRE(l == v);
400 : }
401 1 : v <<= 1;
402 : {
403 1 : __int128 l(2097152_int128);
404 1 : CATCH_REQUIRE(l == v);
405 : }
406 : {
407 1 : __int128 l("2097152"_int128);
408 1 : CATCH_REQUIRE(l == v);
409 : }
410 1 : v <<= 1;
411 : {
412 1 : __int128 l(4194304_int128);
413 1 : CATCH_REQUIRE(l == v);
414 : }
415 : {
416 1 : __int128 l("4194304"_int128);
417 1 : CATCH_REQUIRE(l == v);
418 : }
419 1 : v <<= 1;
420 : {
421 1 : __int128 l(8388608_int128);
422 1 : CATCH_REQUIRE(l == v);
423 : }
424 : {
425 1 : __int128 l("8388608"_int128);
426 1 : CATCH_REQUIRE(l == v);
427 : }
428 1 : v <<= 1;
429 : {
430 1 : __int128 l(16777216_int128);
431 1 : CATCH_REQUIRE(l == v);
432 : }
433 : {
434 1 : __int128 l("16777216"_int128);
435 1 : CATCH_REQUIRE(l == v);
436 : }
437 1 : v <<= 1;
438 : {
439 1 : __int128 l(33554432_int128);
440 1 : CATCH_REQUIRE(l == v);
441 : }
442 : {
443 1 : __int128 l("33554432"_int128);
444 1 : CATCH_REQUIRE(l == v);
445 : }
446 1 : v <<= 1;
447 : {
448 1 : __int128 l(67108864_int128);
449 1 : CATCH_REQUIRE(l == v);
450 : }
451 : {
452 1 : __int128 l("67108864"_int128);
453 1 : CATCH_REQUIRE(l == v);
454 : }
455 1 : v <<= 1;
456 : {
457 1 : __int128 l(134217728_int128);
458 1 : CATCH_REQUIRE(l == v);
459 : }
460 : {
461 1 : __int128 l("134217728"_int128);
462 1 : CATCH_REQUIRE(l == v);
463 : }
464 1 : v <<= 1;
465 : {
466 1 : __int128 l(268435456_int128);
467 1 : CATCH_REQUIRE(l == v);
468 : }
469 : {
470 1 : __int128 l("268435456"_int128);
471 1 : CATCH_REQUIRE(l == v);
472 : }
473 1 : v <<= 1;
474 : {
475 1 : __int128 l(536870912_int128);
476 1 : CATCH_REQUIRE(l == v);
477 : }
478 : {
479 1 : __int128 l("536870912"_int128);
480 1 : CATCH_REQUIRE(l == v);
481 : }
482 1 : v <<= 1;
483 : {
484 1 : __int128 l(1073741824_int128);
485 1 : CATCH_REQUIRE(l == v);
486 : }
487 : {
488 1 : __int128 l("1073741824"_int128);
489 1 : CATCH_REQUIRE(l == v);
490 : }
491 1 : v <<= 1;
492 : {
493 1 : __int128 l(2147483648_int128);
494 1 : CATCH_REQUIRE(l == v);
495 : }
496 : {
497 1 : __int128 l("2147483648"_int128);
498 1 : CATCH_REQUIRE(l == v);
499 : }
500 1 : v <<= 1;
501 : {
502 1 : __int128 l(4294967296_int128);
503 1 : CATCH_REQUIRE(l == v);
504 : }
505 : {
506 1 : __int128 l("4294967296"_int128);
507 1 : CATCH_REQUIRE(l == v);
508 : }
509 1 : v <<= 1;
510 : {
511 1 : __int128 l(8589934592_int128);
512 1 : CATCH_REQUIRE(l == v);
513 : }
514 : {
515 1 : __int128 l("8589934592"_int128);
516 1 : CATCH_REQUIRE(l == v);
517 : }
518 1 : v <<= 1;
519 : {
520 1 : __int128 l(17179869184_int128);
521 1 : CATCH_REQUIRE(l == v);
522 : }
523 : {
524 1 : __int128 l("17179869184"_int128);
525 1 : CATCH_REQUIRE(l == v);
526 : }
527 1 : v <<= 1;
528 : {
529 1 : __int128 l(34359738368_int128);
530 1 : CATCH_REQUIRE(l == v);
531 : }
532 : {
533 1 : __int128 l("34359738368"_int128);
534 1 : CATCH_REQUIRE(l == v);
535 : }
536 1 : v <<= 1;
537 : {
538 1 : __int128 l(68719476736_int128);
539 1 : CATCH_REQUIRE(l == v);
540 : }
541 : {
542 1 : __int128 l("68719476736"_int128);
543 1 : CATCH_REQUIRE(l == v);
544 : }
545 1 : v <<= 1;
546 : {
547 1 : __int128 l(137438953472_int128);
548 1 : CATCH_REQUIRE(l == v);
549 : }
550 : {
551 1 : __int128 l("137438953472"_int128);
552 1 : CATCH_REQUIRE(l == v);
553 : }
554 1 : v <<= 1;
555 : {
556 1 : __int128 l(274877906944_int128);
557 1 : CATCH_REQUIRE(l == v);
558 : }
559 : {
560 1 : __int128 l("274877906944"_int128);
561 1 : CATCH_REQUIRE(l == v);
562 : }
563 1 : v <<= 1;
564 : {
565 1 : __int128 l(549755813888_int128);
566 1 : CATCH_REQUIRE(l == v);
567 : }
568 : {
569 1 : __int128 l("549755813888"_int128);
570 1 : CATCH_REQUIRE(l == v);
571 : }
572 1 : v <<= 1;
573 : {
574 1 : __int128 l(1099511627776_int128);
575 1 : CATCH_REQUIRE(l == v);
576 : }
577 : {
578 1 : __int128 l("1099511627776"_int128);
579 1 : CATCH_REQUIRE(l == v);
580 : }
581 1 : v <<= 1;
582 : {
583 1 : __int128 l(2199023255552_int128);
584 1 : CATCH_REQUIRE(l == v);
585 : }
586 : {
587 1 : __int128 l("2199023255552"_int128);
588 1 : CATCH_REQUIRE(l == v);
589 : }
590 1 : v <<= 1;
591 : {
592 1 : __int128 l(4398046511104_int128);
593 1 : CATCH_REQUIRE(l == v);
594 : }
595 : {
596 1 : __int128 l("4398046511104"_int128);
597 1 : CATCH_REQUIRE(l == v);
598 : }
599 1 : v <<= 1;
600 : {
601 1 : __int128 l(8796093022208_int128);
602 1 : CATCH_REQUIRE(l == v);
603 : }
604 : {
605 1 : __int128 l("8796093022208"_int128);
606 1 : CATCH_REQUIRE(l == v);
607 : }
608 1 : v <<= 1;
609 : {
610 1 : __int128 l(17592186044416_int128);
611 1 : CATCH_REQUIRE(l == v);
612 : }
613 : {
614 1 : __int128 l("17592186044416"_int128);
615 1 : CATCH_REQUIRE(l == v);
616 : }
617 1 : v <<= 1;
618 : {
619 1 : __int128 l(35184372088832_int128);
620 1 : CATCH_REQUIRE(l == v);
621 : }
622 : {
623 1 : __int128 l("35184372088832"_int128);
624 1 : CATCH_REQUIRE(l == v);
625 : }
626 1 : v <<= 1;
627 : {
628 1 : __int128 l(70368744177664_int128);
629 1 : CATCH_REQUIRE(l == v);
630 : }
631 : {
632 1 : __int128 l("70368744177664"_int128);
633 1 : CATCH_REQUIRE(l == v);
634 : }
635 1 : v <<= 1;
636 : {
637 1 : __int128 l(140737488355328_int128);
638 1 : CATCH_REQUIRE(l == v);
639 : }
640 : {
641 1 : __int128 l("140737488355328"_int128);
642 1 : CATCH_REQUIRE(l == v);
643 : }
644 1 : v <<= 1;
645 : {
646 1 : __int128 l(281474976710656_int128);
647 1 : CATCH_REQUIRE(l == v);
648 : }
649 : {
650 1 : __int128 l("281474976710656"_int128);
651 1 : CATCH_REQUIRE(l == v);
652 : }
653 1 : v <<= 1;
654 : {
655 1 : __int128 l(562949953421312_int128);
656 1 : CATCH_REQUIRE(l == v);
657 : }
658 : {
659 1 : __int128 l("562949953421312"_int128);
660 1 : CATCH_REQUIRE(l == v);
661 : }
662 1 : v <<= 1;
663 : {
664 1 : __int128 l(1125899906842624_int128);
665 1 : CATCH_REQUIRE(l == v);
666 : }
667 : {
668 1 : __int128 l("1125899906842624"_int128);
669 1 : CATCH_REQUIRE(l == v);
670 : }
671 1 : v <<= 1;
672 : {
673 1 : __int128 l(2251799813685248_int128);
674 1 : CATCH_REQUIRE(l == v);
675 : }
676 : {
677 1 : __int128 l("2251799813685248"_int128);
678 1 : CATCH_REQUIRE(l == v);
679 : }
680 1 : v <<= 1;
681 : {
682 1 : __int128 l(4503599627370496_int128);
683 1 : CATCH_REQUIRE(l == v);
684 : }
685 : {
686 1 : __int128 l("4503599627370496"_int128);
687 1 : CATCH_REQUIRE(l == v);
688 : }
689 1 : v <<= 1;
690 : {
691 1 : __int128 l(9007199254740992_int128);
692 1 : CATCH_REQUIRE(l == v);
693 : }
694 : {
695 1 : __int128 l("9007199254740992"_int128);
696 1 : CATCH_REQUIRE(l == v);
697 : }
698 1 : v <<= 1;
699 : {
700 1 : __int128 l(18014398509481984_int128);
701 1 : CATCH_REQUIRE(l == v);
702 : }
703 : {
704 1 : __int128 l("18014398509481984"_int128);
705 1 : CATCH_REQUIRE(l == v);
706 : }
707 1 : v <<= 1;
708 : {
709 1 : __int128 l(36028797018963968_int128);
710 1 : CATCH_REQUIRE(l == v);
711 : }
712 : {
713 1 : __int128 l("36028797018963968"_int128);
714 1 : CATCH_REQUIRE(l == v);
715 : }
716 1 : v <<= 1;
717 : {
718 1 : __int128 l(72057594037927936_int128);
719 1 : CATCH_REQUIRE(l == v);
720 : }
721 : {
722 1 : __int128 l("72057594037927936"_int128);
723 1 : CATCH_REQUIRE(l == v);
724 : }
725 1 : v <<= 1;
726 : {
727 1 : __int128 l(144115188075855872_int128);
728 1 : CATCH_REQUIRE(l == v);
729 : }
730 : {
731 1 : __int128 l("144115188075855872"_int128);
732 1 : CATCH_REQUIRE(l == v);
733 : }
734 1 : v <<= 1;
735 : {
736 1 : __int128 l(288230376151711744_int128);
737 1 : CATCH_REQUIRE(l == v);
738 : }
739 : {
740 1 : __int128 l("288230376151711744"_int128);
741 1 : CATCH_REQUIRE(l == v);
742 : }
743 1 : v <<= 1;
744 : {
745 1 : __int128 l(576460752303423488_int128);
746 1 : CATCH_REQUIRE(l == v);
747 : }
748 : {
749 1 : __int128 l("576460752303423488"_int128);
750 1 : CATCH_REQUIRE(l == v);
751 : }
752 1 : v <<= 1;
753 : {
754 1 : __int128 l(1152921504606846976_int128);
755 1 : CATCH_REQUIRE(l == v);
756 : }
757 : {
758 1 : __int128 l("1152921504606846976"_int128);
759 1 : CATCH_REQUIRE(l == v);
760 : }
761 1 : v <<= 1;
762 : {
763 1 : __int128 l(2305843009213693952_int128);
764 1 : CATCH_REQUIRE(l == v);
765 : }
766 : {
767 1 : __int128 l("2305843009213693952"_int128);
768 1 : CATCH_REQUIRE(l == v);
769 : }
770 1 : v <<= 1;
771 : {
772 1 : __int128 l(4611686018427387904_int128);
773 1 : CATCH_REQUIRE(l == v);
774 : }
775 : {
776 1 : __int128 l("4611686018427387904"_int128);
777 1 : CATCH_REQUIRE(l == v);
778 : }
779 1 : v <<= 1;
780 : {
781 1 : __int128 l(9223372036854775808_int128);
782 1 : CATCH_REQUIRE(l == v);
783 : }
784 : {
785 1 : __int128 l("9223372036854775808"_int128);
786 1 : CATCH_REQUIRE(l == v);
787 : }
788 1 : v <<= 1;
789 : {
790 1 : __int128 l(18446744073709551616_int128);
791 1 : CATCH_REQUIRE(l == v);
792 : }
793 : {
794 1 : __int128 l("18446744073709551616"_int128);
795 1 : CATCH_REQUIRE(l == v);
796 : }
797 1 : v <<= 1;
798 : {
799 1 : __int128 l(36893488147419103232_int128);
800 1 : CATCH_REQUIRE(l == v);
801 : }
802 : {
803 1 : __int128 l("36893488147419103232"_int128);
804 1 : CATCH_REQUIRE(l == v);
805 : }
806 1 : v <<= 1;
807 : {
808 1 : __int128 l(73786976294838206464_int128);
809 1 : CATCH_REQUIRE(l == v);
810 : }
811 : {
812 1 : __int128 l("73786976294838206464"_int128);
813 1 : CATCH_REQUIRE(l == v);
814 : }
815 1 : v <<= 1;
816 : {
817 1 : __int128 l(147573952589676412928_int128);
818 1 : CATCH_REQUIRE(l == v);
819 : }
820 : {
821 1 : __int128 l("147573952589676412928"_int128);
822 1 : CATCH_REQUIRE(l == v);
823 : }
824 1 : v <<= 1;
825 : {
826 1 : __int128 l(295147905179352825856_int128);
827 1 : CATCH_REQUIRE(l == v);
828 : }
829 : {
830 1 : __int128 l("295147905179352825856"_int128);
831 1 : CATCH_REQUIRE(l == v);
832 : }
833 1 : v <<= 1;
834 : {
835 1 : __int128 l(590295810358705651712_int128);
836 1 : CATCH_REQUIRE(l == v);
837 : }
838 : {
839 1 : __int128 l("590295810358705651712"_int128);
840 1 : CATCH_REQUIRE(l == v);
841 : }
842 1 : v <<= 1;
843 : {
844 1 : __int128 l(1180591620717411303424_int128);
845 1 : CATCH_REQUIRE(l == v);
846 : }
847 : {
848 1 : __int128 l("1180591620717411303424"_int128);
849 1 : CATCH_REQUIRE(l == v);
850 : }
851 1 : v <<= 1;
852 : {
853 1 : __int128 l(2361183241434822606848_int128);
854 1 : CATCH_REQUIRE(l == v);
855 : }
856 : {
857 1 : __int128 l("2361183241434822606848"_int128);
858 1 : CATCH_REQUIRE(l == v);
859 : }
860 1 : v <<= 1;
861 : {
862 1 : __int128 l(4722366482869645213696_int128);
863 1 : CATCH_REQUIRE(l == v);
864 : }
865 : {
866 1 : __int128 l("4722366482869645213696"_int128);
867 1 : CATCH_REQUIRE(l == v);
868 : }
869 1 : v <<= 1;
870 : {
871 1 : __int128 l(9444732965739290427392_int128);
872 1 : CATCH_REQUIRE(l == v);
873 : }
874 : {
875 1 : __int128 l("9444732965739290427392"_int128);
876 1 : CATCH_REQUIRE(l == v);
877 : }
878 1 : v <<= 1;
879 : {
880 1 : __int128 l(18889465931478580854784_int128);
881 1 : CATCH_REQUIRE(l == v);
882 : }
883 : {
884 1 : __int128 l("18889465931478580854784"_int128);
885 1 : CATCH_REQUIRE(l == v);
886 : }
887 1 : v <<= 1;
888 : {
889 1 : __int128 l(37778931862957161709568_int128);
890 1 : CATCH_REQUIRE(l == v);
891 : }
892 : {
893 1 : __int128 l("37778931862957161709568"_int128);
894 1 : CATCH_REQUIRE(l == v);
895 : }
896 1 : v <<= 1;
897 : {
898 1 : __int128 l(75557863725914323419136_int128);
899 1 : CATCH_REQUIRE(l == v);
900 : }
901 : {
902 1 : __int128 l("75557863725914323419136"_int128);
903 1 : CATCH_REQUIRE(l == v);
904 : }
905 1 : v <<= 1;
906 : {
907 1 : __int128 l(151115727451828646838272_int128);
908 1 : CATCH_REQUIRE(l == v);
909 : }
910 : {
911 1 : __int128 l("151115727451828646838272"_int128);
912 1 : CATCH_REQUIRE(l == v);
913 : }
914 1 : v <<= 1;
915 : {
916 1 : __int128 l(302231454903657293676544_int128);
917 1 : CATCH_REQUIRE(l == v);
918 : }
919 : {
920 1 : __int128 l("302231454903657293676544"_int128);
921 1 : CATCH_REQUIRE(l == v);
922 : }
923 1 : v <<= 1;
924 : {
925 1 : __int128 l(604462909807314587353088_int128);
926 1 : CATCH_REQUIRE(l == v);
927 : }
928 : {
929 1 : __int128 l("604462909807314587353088"_int128);
930 1 : CATCH_REQUIRE(l == v);
931 : }
932 1 : v <<= 1;
933 : {
934 1 : __int128 l(1208925819614629174706176_int128);
935 1 : CATCH_REQUIRE(l == v);
936 : }
937 : {
938 1 : __int128 l("1208925819614629174706176"_int128);
939 1 : CATCH_REQUIRE(l == v);
940 : }
941 1 : v <<= 1;
942 : {
943 1 : __int128 l(2417851639229258349412352_int128);
944 1 : CATCH_REQUIRE(l == v);
945 : }
946 : {
947 1 : __int128 l("2417851639229258349412352"_int128);
948 1 : CATCH_REQUIRE(l == v);
949 : }
950 1 : v <<= 1;
951 : {
952 1 : __int128 l(4835703278458516698824704_int128);
953 1 : CATCH_REQUIRE(l == v);
954 : }
955 : {
956 1 : __int128 l("4835703278458516698824704"_int128);
957 1 : CATCH_REQUIRE(l == v);
958 : }
959 1 : v <<= 1;
960 : {
961 1 : __int128 l(9671406556917033397649408_int128);
962 1 : CATCH_REQUIRE(l == v);
963 : }
964 : {
965 1 : __int128 l("9671406556917033397649408"_int128);
966 1 : CATCH_REQUIRE(l == v);
967 : }
968 1 : v <<= 1;
969 : {
970 1 : __int128 l(19342813113834066795298816_int128);
971 1 : CATCH_REQUIRE(l == v);
972 : }
973 : {
974 1 : __int128 l("19342813113834066795298816"_int128);
975 1 : CATCH_REQUIRE(l == v);
976 : }
977 1 : v <<= 1;
978 : {
979 1 : __int128 l(38685626227668133590597632_int128);
980 1 : CATCH_REQUIRE(l == v);
981 : }
982 : {
983 1 : __int128 l("38685626227668133590597632"_int128);
984 1 : CATCH_REQUIRE(l == v);
985 : }
986 1 : v <<= 1;
987 : {
988 1 : __int128 l(77371252455336267181195264_int128);
989 1 : CATCH_REQUIRE(l == v);
990 : }
991 : {
992 1 : __int128 l("77371252455336267181195264"_int128);
993 1 : CATCH_REQUIRE(l == v);
994 : }
995 1 : v <<= 1;
996 : {
997 1 : __int128 l(154742504910672534362390528_int128);
998 1 : CATCH_REQUIRE(l == v);
999 : }
1000 : {
1001 1 : __int128 l("154742504910672534362390528"_int128);
1002 1 : CATCH_REQUIRE(l == v);
1003 : }
1004 1 : v <<= 1;
1005 : {
1006 1 : __int128 l(309485009821345068724781056_int128);
1007 1 : CATCH_REQUIRE(l == v);
1008 : }
1009 : {
1010 1 : __int128 l("309485009821345068724781056"_int128);
1011 1 : CATCH_REQUIRE(l == v);
1012 : }
1013 1 : v <<= 1;
1014 : {
1015 1 : __int128 l(618970019642690137449562112_int128);
1016 1 : CATCH_REQUIRE(l == v);
1017 : }
1018 : {
1019 1 : __int128 l("618970019642690137449562112"_int128);
1020 1 : CATCH_REQUIRE(l == v);
1021 : }
1022 1 : v <<= 1;
1023 : {
1024 1 : __int128 l(1237940039285380274899124224_int128);
1025 1 : CATCH_REQUIRE(l == v);
1026 : }
1027 : {
1028 1 : __int128 l("1237940039285380274899124224"_int128);
1029 1 : CATCH_REQUIRE(l == v);
1030 : }
1031 1 : v <<= 1;
1032 : {
1033 1 : __int128 l(2475880078570760549798248448_int128);
1034 1 : CATCH_REQUIRE(l == v);
1035 : }
1036 : {
1037 1 : __int128 l("2475880078570760549798248448"_int128);
1038 1 : CATCH_REQUIRE(l == v);
1039 : }
1040 1 : v <<= 1;
1041 : {
1042 1 : __int128 l(4951760157141521099596496896_int128);
1043 1 : CATCH_REQUIRE(l == v);
1044 : }
1045 : {
1046 1 : __int128 l("4951760157141521099596496896"_int128);
1047 1 : CATCH_REQUIRE(l == v);
1048 : }
1049 1 : v <<= 1;
1050 : {
1051 1 : __int128 l(9903520314283042199192993792_int128);
1052 1 : CATCH_REQUIRE(l == v);
1053 : }
1054 : {
1055 1 : __int128 l("9903520314283042199192993792"_int128);
1056 1 : CATCH_REQUIRE(l == v);
1057 : }
1058 1 : v <<= 1;
1059 : {
1060 1 : __int128 l(19807040628566084398385987584_int128);
1061 1 : CATCH_REQUIRE(l == v);
1062 : }
1063 : {
1064 1 : __int128 l("19807040628566084398385987584"_int128);
1065 1 : CATCH_REQUIRE(l == v);
1066 : }
1067 1 : v <<= 1;
1068 : {
1069 1 : __int128 l(39614081257132168796771975168_int128);
1070 1 : CATCH_REQUIRE(l == v);
1071 : }
1072 : {
1073 1 : __int128 l("39614081257132168796771975168"_int128);
1074 1 : CATCH_REQUIRE(l == v);
1075 : }
1076 1 : v <<= 1;
1077 : {
1078 1 : __int128 l(79228162514264337593543950336_int128);
1079 1 : CATCH_REQUIRE(l == v);
1080 : }
1081 : {
1082 1 : __int128 l("79228162514264337593543950336"_int128);
1083 1 : CATCH_REQUIRE(l == v);
1084 : }
1085 1 : v <<= 1;
1086 : {
1087 1 : __int128 l(158456325028528675187087900672_int128);
1088 1 : CATCH_REQUIRE(l == v);
1089 : }
1090 : {
1091 1 : __int128 l("158456325028528675187087900672"_int128);
1092 1 : CATCH_REQUIRE(l == v);
1093 : }
1094 1 : v <<= 1;
1095 : {
1096 1 : __int128 l(316912650057057350374175801344_int128);
1097 1 : CATCH_REQUIRE(l == v);
1098 : }
1099 : {
1100 1 : __int128 l("316912650057057350374175801344"_int128);
1101 1 : CATCH_REQUIRE(l == v);
1102 : }
1103 1 : v <<= 1;
1104 : {
1105 1 : __int128 l(633825300114114700748351602688_int128);
1106 1 : CATCH_REQUIRE(l == v);
1107 : }
1108 : {
1109 1 : __int128 l("633825300114114700748351602688"_int128);
1110 1 : CATCH_REQUIRE(l == v);
1111 : }
1112 1 : v <<= 1;
1113 : {
1114 1 : __int128 l(1267650600228229401496703205376_int128);
1115 1 : CATCH_REQUIRE(l == v);
1116 : }
1117 : {
1118 1 : __int128 l("1267650600228229401496703205376"_int128);
1119 1 : CATCH_REQUIRE(l == v);
1120 : }
1121 1 : v <<= 1;
1122 : {
1123 1 : __int128 l(2535301200456458802993406410752_int128);
1124 1 : CATCH_REQUIRE(l == v);
1125 : }
1126 : {
1127 1 : __int128 l("2535301200456458802993406410752"_int128);
1128 1 : CATCH_REQUIRE(l == v);
1129 : }
1130 1 : v <<= 1;
1131 : {
1132 1 : __int128 l(5070602400912917605986812821504_int128);
1133 1 : CATCH_REQUIRE(l == v);
1134 : }
1135 : {
1136 1 : __int128 l("5070602400912917605986812821504"_int128);
1137 1 : CATCH_REQUIRE(l == v);
1138 : }
1139 1 : v <<= 1;
1140 : {
1141 1 : __int128 l(10141204801825835211973625643008_int128);
1142 1 : CATCH_REQUIRE(l == v);
1143 : }
1144 : {
1145 1 : __int128 l("10141204801825835211973625643008"_int128);
1146 1 : CATCH_REQUIRE(l == v);
1147 : }
1148 1 : v <<= 1;
1149 : {
1150 1 : __int128 l(20282409603651670423947251286016_int128);
1151 1 : CATCH_REQUIRE(l == v);
1152 : }
1153 : {
1154 1 : __int128 l("20282409603651670423947251286016"_int128);
1155 1 : CATCH_REQUIRE(l == v);
1156 : }
1157 1 : v <<= 1;
1158 : {
1159 1 : __int128 l(40564819207303340847894502572032_int128);
1160 1 : CATCH_REQUIRE(l == v);
1161 : }
1162 : {
1163 1 : __int128 l("40564819207303340847894502572032"_int128);
1164 1 : CATCH_REQUIRE(l == v);
1165 : }
1166 1 : v <<= 1;
1167 : {
1168 1 : __int128 l(81129638414606681695789005144064_int128);
1169 1 : CATCH_REQUIRE(l == v);
1170 : }
1171 : {
1172 1 : __int128 l("81129638414606681695789005144064"_int128);
1173 1 : CATCH_REQUIRE(l == v);
1174 : }
1175 1 : v <<= 1;
1176 : {
1177 1 : __int128 l(162259276829213363391578010288128_int128);
1178 1 : CATCH_REQUIRE(l == v);
1179 : }
1180 : {
1181 1 : __int128 l("162259276829213363391578010288128"_int128);
1182 1 : CATCH_REQUIRE(l == v);
1183 : }
1184 1 : v <<= 1;
1185 : {
1186 1 : __int128 l(324518553658426726783156020576256_int128);
1187 1 : CATCH_REQUIRE(l == v);
1188 : }
1189 : {
1190 1 : __int128 l("324518553658426726783156020576256"_int128);
1191 1 : CATCH_REQUIRE(l == v);
1192 : }
1193 1 : v <<= 1;
1194 : {
1195 1 : __int128 l(649037107316853453566312041152512_int128);
1196 1 : CATCH_REQUIRE(l == v);
1197 : }
1198 : {
1199 1 : __int128 l("649037107316853453566312041152512"_int128);
1200 1 : CATCH_REQUIRE(l == v);
1201 : }
1202 1 : v <<= 1;
1203 : {
1204 1 : __int128 l(1298074214633706907132624082305024_int128);
1205 1 : CATCH_REQUIRE(l == v);
1206 : }
1207 : {
1208 1 : __int128 l("1298074214633706907132624082305024"_int128);
1209 1 : CATCH_REQUIRE(l == v);
1210 : }
1211 1 : v <<= 1;
1212 : {
1213 1 : __int128 l(2596148429267413814265248164610048_int128);
1214 1 : CATCH_REQUIRE(l == v);
1215 : }
1216 : {
1217 1 : __int128 l("2596148429267413814265248164610048"_int128);
1218 1 : CATCH_REQUIRE(l == v);
1219 : }
1220 1 : v <<= 1;
1221 : {
1222 1 : __int128 l(5192296858534827628530496329220096_int128);
1223 1 : CATCH_REQUIRE(l == v);
1224 : }
1225 : {
1226 1 : __int128 l("5192296858534827628530496329220096"_int128);
1227 1 : CATCH_REQUIRE(l == v);
1228 : }
1229 1 : v <<= 1;
1230 : {
1231 1 : __int128 l(10384593717069655257060992658440192_int128);
1232 1 : CATCH_REQUIRE(l == v);
1233 : }
1234 : {
1235 1 : __int128 l("10384593717069655257060992658440192"_int128);
1236 1 : CATCH_REQUIRE(l == v);
1237 : }
1238 1 : v <<= 1;
1239 : {
1240 1 : __int128 l(20769187434139310514121985316880384_int128);
1241 1 : CATCH_REQUIRE(l == v);
1242 : }
1243 : {
1244 1 : __int128 l("20769187434139310514121985316880384"_int128);
1245 1 : CATCH_REQUIRE(l == v);
1246 : }
1247 1 : v <<= 1;
1248 : {
1249 1 : __int128 l(41538374868278621028243970633760768_int128);
1250 1 : CATCH_REQUIRE(l == v);
1251 : }
1252 : {
1253 1 : __int128 l("41538374868278621028243970633760768"_int128);
1254 1 : CATCH_REQUIRE(l == v);
1255 : }
1256 1 : v <<= 1;
1257 : {
1258 1 : __int128 l(83076749736557242056487941267521536_int128);
1259 1 : CATCH_REQUIRE(l == v);
1260 : }
1261 : {
1262 1 : __int128 l("83076749736557242056487941267521536"_int128);
1263 1 : CATCH_REQUIRE(l == v);
1264 : }
1265 1 : v <<= 1;
1266 : {
1267 1 : __int128 l(166153499473114484112975882535043072_int128);
1268 1 : CATCH_REQUIRE(l == v);
1269 : }
1270 : {
1271 1 : __int128 l("166153499473114484112975882535043072"_int128);
1272 1 : CATCH_REQUIRE(l == v);
1273 : }
1274 1 : v <<= 1;
1275 : {
1276 1 : __int128 l(332306998946228968225951765070086144_int128);
1277 1 : CATCH_REQUIRE(l == v);
1278 : }
1279 : {
1280 1 : __int128 l("332306998946228968225951765070086144"_int128);
1281 1 : CATCH_REQUIRE(l == v);
1282 : }
1283 1 : v <<= 1;
1284 : {
1285 1 : __int128 l(664613997892457936451903530140172288_int128);
1286 1 : CATCH_REQUIRE(l == v);
1287 : }
1288 : {
1289 1 : __int128 l("664613997892457936451903530140172288"_int128);
1290 1 : CATCH_REQUIRE(l == v);
1291 : }
1292 1 : v <<= 1;
1293 : {
1294 1 : __int128 l(1329227995784915872903807060280344576_int128);
1295 1 : CATCH_REQUIRE(l == v);
1296 : }
1297 : {
1298 1 : __int128 l("1329227995784915872903807060280344576"_int128);
1299 1 : CATCH_REQUIRE(l == v);
1300 : }
1301 1 : v <<= 1;
1302 : {
1303 1 : __int128 l(2658455991569831745807614120560689152_int128);
1304 1 : CATCH_REQUIRE(l == v);
1305 : }
1306 : {
1307 1 : __int128 l("2658455991569831745807614120560689152"_int128);
1308 1 : CATCH_REQUIRE(l == v);
1309 : }
1310 1 : v <<= 1;
1311 : {
1312 1 : __int128 l(5316911983139663491615228241121378304_int128);
1313 1 : CATCH_REQUIRE(l == v);
1314 : }
1315 : {
1316 1 : __int128 l("5316911983139663491615228241121378304"_int128);
1317 1 : CATCH_REQUIRE(l == v);
1318 : }
1319 1 : v <<= 1;
1320 : {
1321 1 : __int128 l(10633823966279326983230456482242756608_int128);
1322 1 : CATCH_REQUIRE(l == v);
1323 : }
1324 : {
1325 1 : __int128 l("10633823966279326983230456482242756608"_int128);
1326 1 : CATCH_REQUIRE(l == v);
1327 : }
1328 1 : v <<= 1;
1329 : {
1330 1 : __int128 l(21267647932558653966460912964485513216_int128);
1331 1 : CATCH_REQUIRE(l == v);
1332 : }
1333 : {
1334 1 : __int128 l("21267647932558653966460912964485513216"_int128);
1335 1 : CATCH_REQUIRE(l == v);
1336 : }
1337 1 : v <<= 1;
1338 : {
1339 1 : __int128 l(42535295865117307932921825928971026432_int128);
1340 1 : CATCH_REQUIRE(l == v);
1341 : }
1342 : {
1343 1 : __int128 l("42535295865117307932921825928971026432"_int128);
1344 1 : CATCH_REQUIRE(l == v);
1345 : }
1346 1 : v <<= 1;
1347 : {
1348 1 : __int128 l(85070591730234615865843651857942052864_int128);
1349 1 : CATCH_REQUIRE(l == v);
1350 : }
1351 : {
1352 1 : __int128 l("85070591730234615865843651857942052864"_int128);
1353 1 : CATCH_REQUIRE(l == v);
1354 : }
1355 : }
1356 3 : CATCH_END_SECTION()
1357 :
1358 3 : CATCH_START_SECTION("uint128_literal: unsigned zero and powers of two")
1359 : {
1360 : using namespace snapdev::literals;
1361 :
1362 1 : unsigned __int128 m0(0_uint128);
1363 1 : CATCH_REQUIRE(m0 == 0);
1364 :
1365 1 : unsigned __int128 v(1);
1366 : {
1367 1 : unsigned __int128 l(1_uint128);
1368 1 : CATCH_REQUIRE(l == v);
1369 : }
1370 : {
1371 1 : unsigned __int128 l("1"_uint128);
1372 1 : CATCH_REQUIRE(l == v);
1373 : }
1374 1 : v <<= 1;
1375 : {
1376 1 : unsigned __int128 l(2_uint128);
1377 1 : CATCH_REQUIRE(l == v);
1378 : }
1379 : {
1380 1 : unsigned __int128 l("2"_uint128);
1381 1 : CATCH_REQUIRE(l == v);
1382 : }
1383 1 : v <<= 1;
1384 : {
1385 1 : unsigned __int128 l(4_uint128);
1386 1 : CATCH_REQUIRE(l == v);
1387 : }
1388 : {
1389 1 : unsigned __int128 l("4"_uint128);
1390 1 : CATCH_REQUIRE(l == v);
1391 : }
1392 1 : v <<= 1;
1393 : {
1394 1 : unsigned __int128 l(8_uint128);
1395 1 : CATCH_REQUIRE(l == v);
1396 : }
1397 : {
1398 1 : unsigned __int128 l("8"_uint128);
1399 1 : CATCH_REQUIRE(l == v);
1400 : }
1401 1 : v <<= 1;
1402 : {
1403 1 : unsigned __int128 l(16_uint128);
1404 1 : CATCH_REQUIRE(l == v);
1405 : }
1406 : {
1407 1 : unsigned __int128 l("16"_uint128);
1408 1 : CATCH_REQUIRE(l == v);
1409 : }
1410 1 : v <<= 1;
1411 : {
1412 1 : unsigned __int128 l(32_uint128);
1413 1 : CATCH_REQUIRE(l == v);
1414 : }
1415 : {
1416 1 : unsigned __int128 l("32"_uint128);
1417 1 : CATCH_REQUIRE(l == v);
1418 : }
1419 1 : v <<= 1;
1420 : {
1421 1 : unsigned __int128 l(64_uint128);
1422 1 : CATCH_REQUIRE(l == v);
1423 : }
1424 : {
1425 1 : unsigned __int128 l("64"_uint128);
1426 1 : CATCH_REQUIRE(l == v);
1427 : }
1428 1 : v <<= 1;
1429 : {
1430 1 : unsigned __int128 l(128_uint128);
1431 1 : CATCH_REQUIRE(l == v);
1432 : }
1433 : {
1434 1 : unsigned __int128 l("128"_uint128);
1435 1 : CATCH_REQUIRE(l == v);
1436 : }
1437 1 : v <<= 1;
1438 : {
1439 1 : unsigned __int128 l(256_uint128);
1440 1 : CATCH_REQUIRE(l == v);
1441 : }
1442 : {
1443 1 : unsigned __int128 l("256"_uint128);
1444 1 : CATCH_REQUIRE(l == v);
1445 : }
1446 1 : v <<= 1;
1447 : {
1448 1 : unsigned __int128 l(512_uint128);
1449 1 : CATCH_REQUIRE(l == v);
1450 : }
1451 : {
1452 1 : unsigned __int128 l("512"_uint128);
1453 1 : CATCH_REQUIRE(l == v);
1454 : }
1455 1 : v <<= 1;
1456 : {
1457 1 : unsigned __int128 l(1024_uint128);
1458 1 : CATCH_REQUIRE(l == v);
1459 : }
1460 : {
1461 1 : unsigned __int128 l("1024"_uint128);
1462 1 : CATCH_REQUIRE(l == v);
1463 : }
1464 1 : v <<= 1;
1465 : {
1466 1 : unsigned __int128 l(2048_uint128);
1467 1 : CATCH_REQUIRE(l == v);
1468 : }
1469 : {
1470 1 : unsigned __int128 l("2048"_uint128);
1471 1 : CATCH_REQUIRE(l == v);
1472 : }
1473 1 : v <<= 1;
1474 : {
1475 1 : unsigned __int128 l(4096_uint128);
1476 1 : CATCH_REQUIRE(l == v);
1477 : }
1478 : {
1479 1 : unsigned __int128 l("4096"_uint128);
1480 1 : CATCH_REQUIRE(l == v);
1481 : }
1482 1 : v <<= 1;
1483 : {
1484 1 : unsigned __int128 l(8192_uint128);
1485 1 : CATCH_REQUIRE(l == v);
1486 : }
1487 : {
1488 1 : unsigned __int128 l("8192"_uint128);
1489 1 : CATCH_REQUIRE(l == v);
1490 : }
1491 1 : v <<= 1;
1492 : {
1493 1 : unsigned __int128 l(16384_uint128);
1494 1 : CATCH_REQUIRE(l == v);
1495 : }
1496 : {
1497 1 : unsigned __int128 l("16384"_uint128);
1498 1 : CATCH_REQUIRE(l == v);
1499 : }
1500 1 : v <<= 1;
1501 : {
1502 1 : unsigned __int128 l(32768_uint128);
1503 1 : CATCH_REQUIRE(l == v);
1504 : }
1505 : {
1506 1 : unsigned __int128 l("32768"_uint128);
1507 1 : CATCH_REQUIRE(l == v);
1508 : }
1509 1 : v <<= 1;
1510 : {
1511 1 : unsigned __int128 l(65536_uint128);
1512 1 : CATCH_REQUIRE(l == v);
1513 : }
1514 : {
1515 1 : unsigned __int128 l("65536"_uint128);
1516 1 : CATCH_REQUIRE(l == v);
1517 : }
1518 1 : v <<= 1;
1519 : {
1520 1 : unsigned __int128 l(131072_uint128);
1521 1 : CATCH_REQUIRE(l == v);
1522 : }
1523 : {
1524 1 : unsigned __int128 l("131072"_uint128);
1525 1 : CATCH_REQUIRE(l == v);
1526 : }
1527 1 : v <<= 1;
1528 : {
1529 1 : unsigned __int128 l(262144_uint128);
1530 1 : CATCH_REQUIRE(l == v);
1531 : }
1532 : {
1533 1 : unsigned __int128 l("262144"_uint128);
1534 1 : CATCH_REQUIRE(l == v);
1535 : }
1536 1 : v <<= 1;
1537 : {
1538 1 : unsigned __int128 l(524288_uint128);
1539 1 : CATCH_REQUIRE(l == v);
1540 : }
1541 : {
1542 1 : unsigned __int128 l("524288"_uint128);
1543 1 : CATCH_REQUIRE(l == v);
1544 : }
1545 1 : v <<= 1;
1546 : {
1547 1 : unsigned __int128 l(1048576_uint128);
1548 1 : CATCH_REQUIRE(l == v);
1549 : }
1550 : {
1551 1 : unsigned __int128 l("1048576"_uint128);
1552 1 : CATCH_REQUIRE(l == v);
1553 : }
1554 1 : v <<= 1;
1555 : {
1556 1 : unsigned __int128 l(2097152_uint128);
1557 1 : CATCH_REQUIRE(l == v);
1558 : }
1559 : {
1560 1 : unsigned __int128 l("2097152"_uint128);
1561 1 : CATCH_REQUIRE(l == v);
1562 : }
1563 1 : v <<= 1;
1564 : {
1565 1 : unsigned __int128 l(4194304_uint128);
1566 1 : CATCH_REQUIRE(l == v);
1567 : }
1568 : {
1569 1 : unsigned __int128 l("4194304"_uint128);
1570 1 : CATCH_REQUIRE(l == v);
1571 : }
1572 1 : v <<= 1;
1573 : {
1574 1 : unsigned __int128 l(8388608_uint128);
1575 1 : CATCH_REQUIRE(l == v);
1576 : }
1577 : {
1578 1 : unsigned __int128 l("8388608"_uint128);
1579 1 : CATCH_REQUIRE(l == v);
1580 : }
1581 1 : v <<= 1;
1582 : {
1583 1 : unsigned __int128 l(16777216_uint128);
1584 1 : CATCH_REQUIRE(l == v);
1585 : }
1586 : {
1587 1 : unsigned __int128 l("16777216"_uint128);
1588 1 : CATCH_REQUIRE(l == v);
1589 : }
1590 1 : v <<= 1;
1591 : {
1592 1 : unsigned __int128 l(33554432_uint128);
1593 1 : CATCH_REQUIRE(l == v);
1594 : }
1595 : {
1596 1 : unsigned __int128 l("33554432"_uint128);
1597 1 : CATCH_REQUIRE(l == v);
1598 : }
1599 1 : v <<= 1;
1600 : {
1601 1 : unsigned __int128 l(67108864_uint128);
1602 1 : CATCH_REQUIRE(l == v);
1603 : }
1604 : {
1605 1 : unsigned __int128 l("67108864"_uint128);
1606 1 : CATCH_REQUIRE(l == v);
1607 : }
1608 1 : v <<= 1;
1609 : {
1610 1 : unsigned __int128 l(134217728_uint128);
1611 1 : CATCH_REQUIRE(l == v);
1612 : }
1613 : {
1614 1 : unsigned __int128 l("134217728"_uint128);
1615 1 : CATCH_REQUIRE(l == v);
1616 : }
1617 1 : v <<= 1;
1618 : {
1619 1 : unsigned __int128 l(268435456_uint128);
1620 1 : CATCH_REQUIRE(l == v);
1621 : }
1622 : {
1623 1 : unsigned __int128 l("268435456"_uint128);
1624 1 : CATCH_REQUIRE(l == v);
1625 : }
1626 1 : v <<= 1;
1627 : {
1628 1 : unsigned __int128 l(536870912_uint128);
1629 1 : CATCH_REQUIRE(l == v);
1630 : }
1631 : {
1632 1 : unsigned __int128 l("536870912"_uint128);
1633 1 : CATCH_REQUIRE(l == v);
1634 : }
1635 1 : v <<= 1;
1636 : {
1637 1 : unsigned __int128 l(1073741824_uint128);
1638 1 : CATCH_REQUIRE(l == v);
1639 : }
1640 : {
1641 1 : unsigned __int128 l("1073741824"_uint128);
1642 1 : CATCH_REQUIRE(l == v);
1643 : }
1644 1 : v <<= 1;
1645 : {
1646 1 : unsigned __int128 l(2147483648_uint128);
1647 1 : CATCH_REQUIRE(l == v);
1648 : }
1649 : {
1650 1 : unsigned __int128 l("2147483648"_uint128);
1651 1 : CATCH_REQUIRE(l == v);
1652 : }
1653 1 : v <<= 1;
1654 : {
1655 1 : unsigned __int128 l(4294967296_uint128);
1656 1 : CATCH_REQUIRE(l == v);
1657 : }
1658 : {
1659 1 : unsigned __int128 l("4294967296"_uint128);
1660 1 : CATCH_REQUIRE(l == v);
1661 : }
1662 1 : v <<= 1;
1663 : {
1664 1 : unsigned __int128 l(8589934592_uint128);
1665 1 : CATCH_REQUIRE(l == v);
1666 : }
1667 : {
1668 1 : unsigned __int128 l("8589934592"_uint128);
1669 1 : CATCH_REQUIRE(l == v);
1670 : }
1671 1 : v <<= 1;
1672 : {
1673 1 : unsigned __int128 l(17179869184_uint128);
1674 1 : CATCH_REQUIRE(l == v);
1675 : }
1676 : {
1677 1 : unsigned __int128 l("17179869184"_uint128);
1678 1 : CATCH_REQUIRE(l == v);
1679 : }
1680 1 : v <<= 1;
1681 : {
1682 1 : unsigned __int128 l(34359738368_uint128);
1683 1 : CATCH_REQUIRE(l == v);
1684 : }
1685 : {
1686 1 : unsigned __int128 l("34359738368"_uint128);
1687 1 : CATCH_REQUIRE(l == v);
1688 : }
1689 1 : v <<= 1;
1690 : {
1691 1 : unsigned __int128 l(68719476736_uint128);
1692 1 : CATCH_REQUIRE(l == v);
1693 : }
1694 : {
1695 1 : unsigned __int128 l("68719476736"_uint128);
1696 1 : CATCH_REQUIRE(l == v);
1697 : }
1698 1 : v <<= 1;
1699 : {
1700 1 : unsigned __int128 l(137438953472_uint128);
1701 1 : CATCH_REQUIRE(l == v);
1702 : }
1703 : {
1704 1 : unsigned __int128 l("137438953472"_uint128);
1705 1 : CATCH_REQUIRE(l == v);
1706 : }
1707 1 : v <<= 1;
1708 : {
1709 1 : unsigned __int128 l(274877906944_uint128);
1710 1 : CATCH_REQUIRE(l == v);
1711 : }
1712 : {
1713 1 : unsigned __int128 l("274877906944"_uint128);
1714 1 : CATCH_REQUIRE(l == v);
1715 : }
1716 1 : v <<= 1;
1717 : {
1718 1 : unsigned __int128 l(549755813888_uint128);
1719 1 : CATCH_REQUIRE(l == v);
1720 : }
1721 : {
1722 1 : unsigned __int128 l("549755813888"_uint128);
1723 1 : CATCH_REQUIRE(l == v);
1724 : }
1725 1 : v <<= 1;
1726 : {
1727 1 : unsigned __int128 l(1099511627776_uint128);
1728 1 : CATCH_REQUIRE(l == v);
1729 : }
1730 : {
1731 1 : unsigned __int128 l("1099511627776"_uint128);
1732 1 : CATCH_REQUIRE(l == v);
1733 : }
1734 1 : v <<= 1;
1735 : {
1736 1 : unsigned __int128 l(2199023255552_uint128);
1737 1 : CATCH_REQUIRE(l == v);
1738 : }
1739 : {
1740 1 : unsigned __int128 l("2199023255552"_uint128);
1741 1 : CATCH_REQUIRE(l == v);
1742 : }
1743 1 : v <<= 1;
1744 : {
1745 1 : unsigned __int128 l(4398046511104_uint128);
1746 1 : CATCH_REQUIRE(l == v);
1747 : }
1748 : {
1749 1 : unsigned __int128 l("4398046511104"_uint128);
1750 1 : CATCH_REQUIRE(l == v);
1751 : }
1752 1 : v <<= 1;
1753 : {
1754 1 : unsigned __int128 l(8796093022208_uint128);
1755 1 : CATCH_REQUIRE(l == v);
1756 : }
1757 : {
1758 1 : unsigned __int128 l("8796093022208"_uint128);
1759 1 : CATCH_REQUIRE(l == v);
1760 : }
1761 1 : v <<= 1;
1762 : {
1763 1 : unsigned __int128 l(17592186044416_uint128);
1764 1 : CATCH_REQUIRE(l == v);
1765 : }
1766 : {
1767 1 : unsigned __int128 l("17592186044416"_uint128);
1768 1 : CATCH_REQUIRE(l == v);
1769 : }
1770 1 : v <<= 1;
1771 : {
1772 1 : unsigned __int128 l(35184372088832_uint128);
1773 1 : CATCH_REQUIRE(l == v);
1774 : }
1775 : {
1776 1 : unsigned __int128 l("35184372088832"_uint128);
1777 1 : CATCH_REQUIRE(l == v);
1778 : }
1779 1 : v <<= 1;
1780 : {
1781 1 : unsigned __int128 l(70368744177664_uint128);
1782 1 : CATCH_REQUIRE(l == v);
1783 : }
1784 : {
1785 1 : unsigned __int128 l("70368744177664"_uint128);
1786 1 : CATCH_REQUIRE(l == v);
1787 : }
1788 1 : v <<= 1;
1789 : {
1790 1 : unsigned __int128 l(140737488355328_uint128);
1791 1 : CATCH_REQUIRE(l == v);
1792 : }
1793 : {
1794 1 : unsigned __int128 l("140737488355328"_uint128);
1795 1 : CATCH_REQUIRE(l == v);
1796 : }
1797 1 : v <<= 1;
1798 : {
1799 1 : unsigned __int128 l(281474976710656_uint128);
1800 1 : CATCH_REQUIRE(l == v);
1801 : }
1802 : {
1803 1 : unsigned __int128 l("281474976710656"_uint128);
1804 1 : CATCH_REQUIRE(l == v);
1805 : }
1806 1 : v <<= 1;
1807 : {
1808 1 : unsigned __int128 l(562949953421312_uint128);
1809 1 : CATCH_REQUIRE(l == v);
1810 : }
1811 : {
1812 1 : unsigned __int128 l("562949953421312"_uint128);
1813 1 : CATCH_REQUIRE(l == v);
1814 : }
1815 1 : v <<= 1;
1816 : {
1817 1 : unsigned __int128 l(1125899906842624_uint128);
1818 1 : CATCH_REQUIRE(l == v);
1819 : }
1820 : {
1821 1 : unsigned __int128 l("1125899906842624"_uint128);
1822 1 : CATCH_REQUIRE(l == v);
1823 : }
1824 1 : v <<= 1;
1825 : {
1826 1 : unsigned __int128 l(2251799813685248_uint128);
1827 1 : CATCH_REQUIRE(l == v);
1828 : }
1829 : {
1830 1 : unsigned __int128 l("2251799813685248"_uint128);
1831 1 : CATCH_REQUIRE(l == v);
1832 : }
1833 1 : v <<= 1;
1834 : {
1835 1 : unsigned __int128 l(4503599627370496_uint128);
1836 1 : CATCH_REQUIRE(l == v);
1837 : }
1838 : {
1839 1 : unsigned __int128 l("4503599627370496"_uint128);
1840 1 : CATCH_REQUIRE(l == v);
1841 : }
1842 1 : v <<= 1;
1843 : {
1844 1 : unsigned __int128 l(9007199254740992_uint128);
1845 1 : CATCH_REQUIRE(l == v);
1846 : }
1847 : {
1848 1 : unsigned __int128 l("9007199254740992"_uint128);
1849 1 : CATCH_REQUIRE(l == v);
1850 : }
1851 1 : v <<= 1;
1852 : {
1853 1 : unsigned __int128 l(18014398509481984_uint128);
1854 1 : CATCH_REQUIRE(l == v);
1855 : }
1856 : {
1857 1 : unsigned __int128 l("18014398509481984"_uint128);
1858 1 : CATCH_REQUIRE(l == v);
1859 : }
1860 1 : v <<= 1;
1861 : {
1862 1 : unsigned __int128 l(36028797018963968_uint128);
1863 1 : CATCH_REQUIRE(l == v);
1864 : }
1865 : {
1866 1 : unsigned __int128 l("36028797018963968"_uint128);
1867 1 : CATCH_REQUIRE(l == v);
1868 : }
1869 1 : v <<= 1;
1870 : {
1871 1 : unsigned __int128 l(72057594037927936_uint128);
1872 1 : CATCH_REQUIRE(l == v);
1873 : }
1874 : {
1875 1 : unsigned __int128 l("72057594037927936"_uint128);
1876 1 : CATCH_REQUIRE(l == v);
1877 : }
1878 1 : v <<= 1;
1879 : {
1880 1 : unsigned __int128 l(144115188075855872_uint128);
1881 1 : CATCH_REQUIRE(l == v);
1882 : }
1883 : {
1884 1 : unsigned __int128 l("144115188075855872"_uint128);
1885 1 : CATCH_REQUIRE(l == v);
1886 : }
1887 1 : v <<= 1;
1888 : {
1889 1 : unsigned __int128 l(288230376151711744_uint128);
1890 1 : CATCH_REQUIRE(l == v);
1891 : }
1892 : {
1893 1 : unsigned __int128 l("288230376151711744"_uint128);
1894 1 : CATCH_REQUIRE(l == v);
1895 : }
1896 1 : v <<= 1;
1897 : {
1898 1 : unsigned __int128 l(576460752303423488_uint128);
1899 1 : CATCH_REQUIRE(l == v);
1900 : }
1901 : {
1902 1 : unsigned __int128 l("576460752303423488"_uint128);
1903 1 : CATCH_REQUIRE(l == v);
1904 : }
1905 1 : v <<= 1;
1906 : {
1907 1 : unsigned __int128 l(1152921504606846976_uint128);
1908 1 : CATCH_REQUIRE(l == v);
1909 : }
1910 : {
1911 1 : unsigned __int128 l("1152921504606846976"_uint128);
1912 1 : CATCH_REQUIRE(l == v);
1913 : }
1914 1 : v <<= 1;
1915 : {
1916 1 : unsigned __int128 l(2305843009213693952_uint128);
1917 1 : CATCH_REQUIRE(l == v);
1918 : }
1919 : {
1920 1 : unsigned __int128 l("2305843009213693952"_uint128);
1921 1 : CATCH_REQUIRE(l == v);
1922 : }
1923 1 : v <<= 1;
1924 : {
1925 1 : unsigned __int128 l(4611686018427387904_uint128);
1926 1 : CATCH_REQUIRE(l == v);
1927 : }
1928 : {
1929 1 : unsigned __int128 l("4611686018427387904"_uint128);
1930 1 : CATCH_REQUIRE(l == v);
1931 : }
1932 1 : v <<= 1;
1933 : {
1934 1 : unsigned __int128 l(9223372036854775808_uint128);
1935 1 : CATCH_REQUIRE(l == v);
1936 : }
1937 : {
1938 1 : unsigned __int128 l("9223372036854775808"_uint128);
1939 1 : CATCH_REQUIRE(l == v);
1940 : }
1941 1 : v <<= 1;
1942 : {
1943 1 : unsigned __int128 l(18446744073709551616_uint128);
1944 1 : CATCH_REQUIRE(l == v);
1945 : }
1946 : {
1947 1 : unsigned __int128 l("18446744073709551616"_uint128);
1948 1 : CATCH_REQUIRE(l == v);
1949 : }
1950 1 : v <<= 1;
1951 : {
1952 1 : unsigned __int128 l(36893488147419103232_uint128);
1953 1 : CATCH_REQUIRE(l == v);
1954 : }
1955 : {
1956 1 : unsigned __int128 l("36893488147419103232"_uint128);
1957 1 : CATCH_REQUIRE(l == v);
1958 : }
1959 1 : v <<= 1;
1960 : {
1961 1 : unsigned __int128 l(73786976294838206464_uint128);
1962 1 : CATCH_REQUIRE(l == v);
1963 : }
1964 : {
1965 1 : unsigned __int128 l("73786976294838206464"_uint128);
1966 1 : CATCH_REQUIRE(l == v);
1967 : }
1968 1 : v <<= 1;
1969 : {
1970 1 : unsigned __int128 l(147573952589676412928_uint128);
1971 1 : CATCH_REQUIRE(l == v);
1972 : }
1973 : {
1974 1 : unsigned __int128 l("147573952589676412928"_uint128);
1975 1 : CATCH_REQUIRE(l == v);
1976 : }
1977 1 : v <<= 1;
1978 : {
1979 1 : unsigned __int128 l(295147905179352825856_uint128);
1980 1 : CATCH_REQUIRE(l == v);
1981 : }
1982 : {
1983 1 : unsigned __int128 l("295147905179352825856"_uint128);
1984 1 : CATCH_REQUIRE(l == v);
1985 : }
1986 1 : v <<= 1;
1987 : {
1988 1 : unsigned __int128 l(590295810358705651712_uint128);
1989 1 : CATCH_REQUIRE(l == v);
1990 : }
1991 : {
1992 1 : unsigned __int128 l("590295810358705651712"_uint128);
1993 1 : CATCH_REQUIRE(l == v);
1994 : }
1995 1 : v <<= 1;
1996 : {
1997 1 : unsigned __int128 l(1180591620717411303424_uint128);
1998 1 : CATCH_REQUIRE(l == v);
1999 : }
2000 : {
2001 1 : unsigned __int128 l("1180591620717411303424"_uint128);
2002 1 : CATCH_REQUIRE(l == v);
2003 : }
2004 1 : v <<= 1;
2005 : {
2006 1 : unsigned __int128 l(2361183241434822606848_uint128);
2007 1 : CATCH_REQUIRE(l == v);
2008 : }
2009 : {
2010 1 : unsigned __int128 l("2361183241434822606848"_uint128);
2011 1 : CATCH_REQUIRE(l == v);
2012 : }
2013 1 : v <<= 1;
2014 : {
2015 1 : unsigned __int128 l(4722366482869645213696_uint128);
2016 1 : CATCH_REQUIRE(l == v);
2017 : }
2018 : {
2019 1 : unsigned __int128 l("4722366482869645213696"_uint128);
2020 1 : CATCH_REQUIRE(l == v);
2021 : }
2022 1 : v <<= 1;
2023 : {
2024 1 : unsigned __int128 l(9444732965739290427392_uint128);
2025 1 : CATCH_REQUIRE(l == v);
2026 : }
2027 : {
2028 1 : unsigned __int128 l("9444732965739290427392"_uint128);
2029 1 : CATCH_REQUIRE(l == v);
2030 : }
2031 1 : v <<= 1;
2032 : {
2033 1 : unsigned __int128 l(18889465931478580854784_uint128);
2034 1 : CATCH_REQUIRE(l == v);
2035 : }
2036 : {
2037 1 : unsigned __int128 l("18889465931478580854784"_uint128);
2038 1 : CATCH_REQUIRE(l == v);
2039 : }
2040 1 : v <<= 1;
2041 : {
2042 1 : unsigned __int128 l(37778931862957161709568_uint128);
2043 1 : CATCH_REQUIRE(l == v);
2044 : }
2045 : {
2046 1 : unsigned __int128 l("37778931862957161709568"_uint128);
2047 1 : CATCH_REQUIRE(l == v);
2048 : }
2049 1 : v <<= 1;
2050 : {
2051 1 : unsigned __int128 l(75557863725914323419136_uint128);
2052 1 : CATCH_REQUIRE(l == v);
2053 : }
2054 : {
2055 1 : unsigned __int128 l("75557863725914323419136"_uint128);
2056 1 : CATCH_REQUIRE(l == v);
2057 : }
2058 1 : v <<= 1;
2059 : {
2060 1 : unsigned __int128 l(151115727451828646838272_uint128);
2061 1 : CATCH_REQUIRE(l == v);
2062 : }
2063 : {
2064 1 : unsigned __int128 l("151115727451828646838272"_uint128);
2065 1 : CATCH_REQUIRE(l == v);
2066 : }
2067 1 : v <<= 1;
2068 : {
2069 1 : unsigned __int128 l(302231454903657293676544_uint128);
2070 1 : CATCH_REQUIRE(l == v);
2071 : }
2072 : {
2073 1 : unsigned __int128 l("302231454903657293676544"_uint128);
2074 1 : CATCH_REQUIRE(l == v);
2075 : }
2076 1 : v <<= 1;
2077 : {
2078 1 : unsigned __int128 l(604462909807314587353088_uint128);
2079 1 : CATCH_REQUIRE(l == v);
2080 : }
2081 : {
2082 1 : unsigned __int128 l("604462909807314587353088"_uint128);
2083 1 : CATCH_REQUIRE(l == v);
2084 : }
2085 1 : v <<= 1;
2086 : {
2087 1 : unsigned __int128 l(1208925819614629174706176_uint128);
2088 1 : CATCH_REQUIRE(l == v);
2089 : }
2090 : {
2091 1 : unsigned __int128 l("1208925819614629174706176"_uint128);
2092 1 : CATCH_REQUIRE(l == v);
2093 : }
2094 1 : v <<= 1;
2095 : {
2096 1 : unsigned __int128 l(2417851639229258349412352_uint128);
2097 1 : CATCH_REQUIRE(l == v);
2098 : }
2099 : {
2100 1 : unsigned __int128 l("2417851639229258349412352"_uint128);
2101 1 : CATCH_REQUIRE(l == v);
2102 : }
2103 1 : v <<= 1;
2104 : {
2105 1 : unsigned __int128 l(4835703278458516698824704_uint128);
2106 1 : CATCH_REQUIRE(l == v);
2107 : }
2108 : {
2109 1 : unsigned __int128 l("4835703278458516698824704"_uint128);
2110 1 : CATCH_REQUIRE(l == v);
2111 : }
2112 1 : v <<= 1;
2113 : {
2114 1 : unsigned __int128 l(9671406556917033397649408_uint128);
2115 1 : CATCH_REQUIRE(l == v);
2116 : }
2117 : {
2118 1 : unsigned __int128 l("9671406556917033397649408"_uint128);
2119 1 : CATCH_REQUIRE(l == v);
2120 : }
2121 1 : v <<= 1;
2122 : {
2123 1 : unsigned __int128 l(19342813113834066795298816_uint128);
2124 1 : CATCH_REQUIRE(l == v);
2125 : }
2126 : {
2127 1 : unsigned __int128 l("19342813113834066795298816"_uint128);
2128 1 : CATCH_REQUIRE(l == v);
2129 : }
2130 1 : v <<= 1;
2131 : {
2132 1 : unsigned __int128 l(38685626227668133590597632_uint128);
2133 1 : CATCH_REQUIRE(l == v);
2134 : }
2135 : {
2136 1 : unsigned __int128 l("38685626227668133590597632"_uint128);
2137 1 : CATCH_REQUIRE(l == v);
2138 : }
2139 1 : v <<= 1;
2140 : {
2141 1 : unsigned __int128 l(77371252455336267181195264_uint128);
2142 1 : CATCH_REQUIRE(l == v);
2143 : }
2144 : {
2145 1 : unsigned __int128 l("77371252455336267181195264"_uint128);
2146 1 : CATCH_REQUIRE(l == v);
2147 : }
2148 1 : v <<= 1;
2149 : {
2150 1 : unsigned __int128 l(154742504910672534362390528_uint128);
2151 1 : CATCH_REQUIRE(l == v);
2152 : }
2153 : {
2154 1 : unsigned __int128 l("154742504910672534362390528"_uint128);
2155 1 : CATCH_REQUIRE(l == v);
2156 : }
2157 1 : v <<= 1;
2158 : {
2159 1 : unsigned __int128 l(309485009821345068724781056_uint128);
2160 1 : CATCH_REQUIRE(l == v);
2161 : }
2162 : {
2163 1 : unsigned __int128 l("309485009821345068724781056"_uint128);
2164 1 : CATCH_REQUIRE(l == v);
2165 : }
2166 1 : v <<= 1;
2167 : {
2168 1 : unsigned __int128 l(618970019642690137449562112_uint128);
2169 1 : CATCH_REQUIRE(l == v);
2170 : }
2171 : {
2172 1 : unsigned __int128 l("618970019642690137449562112"_uint128);
2173 1 : CATCH_REQUIRE(l == v);
2174 : }
2175 1 : v <<= 1;
2176 : {
2177 1 : unsigned __int128 l(1237940039285380274899124224_uint128);
2178 1 : CATCH_REQUIRE(l == v);
2179 : }
2180 : {
2181 1 : unsigned __int128 l("1237940039285380274899124224"_uint128);
2182 1 : CATCH_REQUIRE(l == v);
2183 : }
2184 1 : v <<= 1;
2185 : {
2186 1 : unsigned __int128 l(2475880078570760549798248448_uint128);
2187 1 : CATCH_REQUIRE(l == v);
2188 : }
2189 : {
2190 1 : unsigned __int128 l("2475880078570760549798248448"_uint128);
2191 1 : CATCH_REQUIRE(l == v);
2192 : }
2193 1 : v <<= 1;
2194 : {
2195 1 : unsigned __int128 l(4951760157141521099596496896_uint128);
2196 1 : CATCH_REQUIRE(l == v);
2197 : }
2198 : {
2199 1 : unsigned __int128 l("4951760157141521099596496896"_uint128);
2200 1 : CATCH_REQUIRE(l == v);
2201 : }
2202 1 : v <<= 1;
2203 : {
2204 1 : unsigned __int128 l(9903520314283042199192993792_uint128);
2205 1 : CATCH_REQUIRE(l == v);
2206 : }
2207 : {
2208 1 : unsigned __int128 l("9903520314283042199192993792"_uint128);
2209 1 : CATCH_REQUIRE(l == v);
2210 : }
2211 1 : v <<= 1;
2212 : {
2213 1 : unsigned __int128 l(19807040628566084398385987584_uint128);
2214 1 : CATCH_REQUIRE(l == v);
2215 : }
2216 : {
2217 1 : unsigned __int128 l("19807040628566084398385987584"_uint128);
2218 1 : CATCH_REQUIRE(l == v);
2219 : }
2220 1 : v <<= 1;
2221 : {
2222 1 : unsigned __int128 l(39614081257132168796771975168_uint128);
2223 1 : CATCH_REQUIRE(l == v);
2224 : }
2225 : {
2226 1 : unsigned __int128 l("39614081257132168796771975168"_uint128);
2227 1 : CATCH_REQUIRE(l == v);
2228 : }
2229 1 : v <<= 1;
2230 : {
2231 1 : unsigned __int128 l(79228162514264337593543950336_uint128);
2232 1 : CATCH_REQUIRE(l == v);
2233 : }
2234 : {
2235 1 : unsigned __int128 l("79228162514264337593543950336"_uint128);
2236 1 : CATCH_REQUIRE(l == v);
2237 : }
2238 1 : v <<= 1;
2239 : {
2240 1 : unsigned __int128 l(158456325028528675187087900672_uint128);
2241 1 : CATCH_REQUIRE(l == v);
2242 : }
2243 : {
2244 1 : unsigned __int128 l("158456325028528675187087900672"_uint128);
2245 1 : CATCH_REQUIRE(l == v);
2246 : }
2247 1 : v <<= 1;
2248 : {
2249 1 : unsigned __int128 l(316912650057057350374175801344_uint128);
2250 1 : CATCH_REQUIRE(l == v);
2251 : }
2252 : {
2253 1 : unsigned __int128 l("316912650057057350374175801344"_uint128);
2254 1 : CATCH_REQUIRE(l == v);
2255 : }
2256 1 : v <<= 1;
2257 : {
2258 1 : unsigned __int128 l(633825300114114700748351602688_uint128);
2259 1 : CATCH_REQUIRE(l == v);
2260 : }
2261 : {
2262 1 : unsigned __int128 l("633825300114114700748351602688"_uint128);
2263 1 : CATCH_REQUIRE(l == v);
2264 : }
2265 1 : v <<= 1;
2266 : {
2267 1 : unsigned __int128 l(1267650600228229401496703205376_uint128);
2268 1 : CATCH_REQUIRE(l == v);
2269 : }
2270 : {
2271 1 : unsigned __int128 l("1267650600228229401496703205376"_uint128);
2272 1 : CATCH_REQUIRE(l == v);
2273 : }
2274 1 : v <<= 1;
2275 : {
2276 1 : unsigned __int128 l(2535301200456458802993406410752_uint128);
2277 1 : CATCH_REQUIRE(l == v);
2278 : }
2279 : {
2280 1 : unsigned __int128 l("2535301200456458802993406410752"_uint128);
2281 1 : CATCH_REQUIRE(l == v);
2282 : }
2283 1 : v <<= 1;
2284 : {
2285 1 : unsigned __int128 l(5070602400912917605986812821504_uint128);
2286 1 : CATCH_REQUIRE(l == v);
2287 : }
2288 : {
2289 1 : unsigned __int128 l("5070602400912917605986812821504"_uint128);
2290 1 : CATCH_REQUIRE(l == v);
2291 : }
2292 1 : v <<= 1;
2293 : {
2294 1 : unsigned __int128 l(10141204801825835211973625643008_uint128);
2295 1 : CATCH_REQUIRE(l == v);
2296 : }
2297 : {
2298 1 : unsigned __int128 l("10141204801825835211973625643008"_uint128);
2299 1 : CATCH_REQUIRE(l == v);
2300 : }
2301 1 : v <<= 1;
2302 : {
2303 1 : unsigned __int128 l(20282409603651670423947251286016_uint128);
2304 1 : CATCH_REQUIRE(l == v);
2305 : }
2306 : {
2307 1 : unsigned __int128 l("20282409603651670423947251286016"_uint128);
2308 1 : CATCH_REQUIRE(l == v);
2309 : }
2310 1 : v <<= 1;
2311 : {
2312 1 : unsigned __int128 l(40564819207303340847894502572032_uint128);
2313 1 : CATCH_REQUIRE(l == v);
2314 : }
2315 : {
2316 1 : unsigned __int128 l("40564819207303340847894502572032"_uint128);
2317 1 : CATCH_REQUIRE(l == v);
2318 : }
2319 1 : v <<= 1;
2320 : {
2321 1 : unsigned __int128 l(81129638414606681695789005144064_uint128);
2322 1 : CATCH_REQUIRE(l == v);
2323 : }
2324 : {
2325 1 : unsigned __int128 l("81129638414606681695789005144064"_uint128);
2326 1 : CATCH_REQUIRE(l == v);
2327 : }
2328 1 : v <<= 1;
2329 : {
2330 1 : unsigned __int128 l(162259276829213363391578010288128_uint128);
2331 1 : CATCH_REQUIRE(l == v);
2332 : }
2333 : {
2334 1 : unsigned __int128 l("162259276829213363391578010288128"_uint128);
2335 1 : CATCH_REQUIRE(l == v);
2336 : }
2337 1 : v <<= 1;
2338 : {
2339 1 : unsigned __int128 l(324518553658426726783156020576256_uint128);
2340 1 : CATCH_REQUIRE(l == v);
2341 : }
2342 : {
2343 1 : unsigned __int128 l("324518553658426726783156020576256"_uint128);
2344 1 : CATCH_REQUIRE(l == v);
2345 : }
2346 1 : v <<= 1;
2347 : {
2348 1 : unsigned __int128 l(649037107316853453566312041152512_uint128);
2349 1 : CATCH_REQUIRE(l == v);
2350 : }
2351 : {
2352 1 : unsigned __int128 l("649037107316853453566312041152512"_uint128);
2353 1 : CATCH_REQUIRE(l == v);
2354 : }
2355 1 : v <<= 1;
2356 : {
2357 1 : unsigned __int128 l(1298074214633706907132624082305024_uint128);
2358 1 : CATCH_REQUIRE(l == v);
2359 : }
2360 : {
2361 1 : unsigned __int128 l("1298074214633706907132624082305024"_uint128);
2362 1 : CATCH_REQUIRE(l == v);
2363 : }
2364 1 : v <<= 1;
2365 : {
2366 1 : unsigned __int128 l(2596148429267413814265248164610048_uint128);
2367 1 : CATCH_REQUIRE(l == v);
2368 : }
2369 : {
2370 1 : unsigned __int128 l("2596148429267413814265248164610048"_uint128);
2371 1 : CATCH_REQUIRE(l == v);
2372 : }
2373 1 : v <<= 1;
2374 : {
2375 1 : unsigned __int128 l(5192296858534827628530496329220096_uint128);
2376 1 : CATCH_REQUIRE(l == v);
2377 : }
2378 : {
2379 1 : unsigned __int128 l("5192296858534827628530496329220096"_uint128);
2380 1 : CATCH_REQUIRE(l == v);
2381 : }
2382 1 : v <<= 1;
2383 : {
2384 1 : unsigned __int128 l(10384593717069655257060992658440192_uint128);
2385 1 : CATCH_REQUIRE(l == v);
2386 : }
2387 : {
2388 1 : unsigned __int128 l("10384593717069655257060992658440192"_uint128);
2389 1 : CATCH_REQUIRE(l == v);
2390 : }
2391 1 : v <<= 1;
2392 : {
2393 1 : unsigned __int128 l(20769187434139310514121985316880384_uint128);
2394 1 : CATCH_REQUIRE(l == v);
2395 : }
2396 : {
2397 1 : unsigned __int128 l("20769187434139310514121985316880384"_uint128);
2398 1 : CATCH_REQUIRE(l == v);
2399 : }
2400 1 : v <<= 1;
2401 : {
2402 1 : unsigned __int128 l(41538374868278621028243970633760768_uint128);
2403 1 : CATCH_REQUIRE(l == v);
2404 : }
2405 : {
2406 1 : unsigned __int128 l("41538374868278621028243970633760768"_uint128);
2407 1 : CATCH_REQUIRE(l == v);
2408 : }
2409 1 : v <<= 1;
2410 : {
2411 1 : unsigned __int128 l(83076749736557242056487941267521536_uint128);
2412 1 : CATCH_REQUIRE(l == v);
2413 : }
2414 : {
2415 1 : unsigned __int128 l("83076749736557242056487941267521536"_uint128);
2416 1 : CATCH_REQUIRE(l == v);
2417 : }
2418 1 : v <<= 1;
2419 : {
2420 1 : unsigned __int128 l(166153499473114484112975882535043072_uint128);
2421 1 : CATCH_REQUIRE(l == v);
2422 : }
2423 : {
2424 1 : unsigned __int128 l("166153499473114484112975882535043072"_uint128);
2425 1 : CATCH_REQUIRE(l == v);
2426 : }
2427 1 : v <<= 1;
2428 : {
2429 1 : unsigned __int128 l(332306998946228968225951765070086144_uint128);
2430 1 : CATCH_REQUIRE(l == v);
2431 : }
2432 : {
2433 1 : unsigned __int128 l("332306998946228968225951765070086144"_uint128);
2434 1 : CATCH_REQUIRE(l == v);
2435 : }
2436 1 : v <<= 1;
2437 : {
2438 1 : unsigned __int128 l(664613997892457936451903530140172288_uint128);
2439 1 : CATCH_REQUIRE(l == v);
2440 : }
2441 : {
2442 1 : unsigned __int128 l("664613997892457936451903530140172288"_uint128);
2443 1 : CATCH_REQUIRE(l == v);
2444 : }
2445 1 : v <<= 1;
2446 : {
2447 1 : unsigned __int128 l(1329227995784915872903807060280344576_uint128);
2448 1 : CATCH_REQUIRE(l == v);
2449 : }
2450 : {
2451 1 : unsigned __int128 l("1329227995784915872903807060280344576"_uint128);
2452 1 : CATCH_REQUIRE(l == v);
2453 : }
2454 1 : v <<= 1;
2455 : {
2456 1 : unsigned __int128 l(2658455991569831745807614120560689152_uint128);
2457 1 : CATCH_REQUIRE(l == v);
2458 : }
2459 : {
2460 1 : unsigned __int128 l("2658455991569831745807614120560689152"_uint128);
2461 1 : CATCH_REQUIRE(l == v);
2462 : }
2463 1 : v <<= 1;
2464 : {
2465 1 : unsigned __int128 l(5316911983139663491615228241121378304_uint128);
2466 1 : CATCH_REQUIRE(l == v);
2467 : }
2468 : {
2469 1 : unsigned __int128 l("5316911983139663491615228241121378304"_uint128);
2470 1 : CATCH_REQUIRE(l == v);
2471 : }
2472 1 : v <<= 1;
2473 : {
2474 1 : unsigned __int128 l(10633823966279326983230456482242756608_uint128);
2475 1 : CATCH_REQUIRE(l == v);
2476 : }
2477 : {
2478 1 : unsigned __int128 l("10633823966279326983230456482242756608"_uint128);
2479 1 : CATCH_REQUIRE(l == v);
2480 : }
2481 1 : v <<= 1;
2482 : {
2483 1 : unsigned __int128 l(21267647932558653966460912964485513216_uint128);
2484 1 : CATCH_REQUIRE(l == v);
2485 : }
2486 : {
2487 1 : unsigned __int128 l("21267647932558653966460912964485513216"_uint128);
2488 1 : CATCH_REQUIRE(l == v);
2489 : }
2490 1 : v <<= 1;
2491 : {
2492 1 : unsigned __int128 l(42535295865117307932921825928971026432_uint128);
2493 1 : CATCH_REQUIRE(l == v);
2494 : }
2495 : {
2496 1 : unsigned __int128 l("42535295865117307932921825928971026432"_uint128);
2497 1 : CATCH_REQUIRE(l == v);
2498 : }
2499 1 : v <<= 1;
2500 : {
2501 1 : unsigned __int128 l(85070591730234615865843651857942052864_uint128);
2502 1 : CATCH_REQUIRE(l == v);
2503 : }
2504 : {
2505 1 : unsigned __int128 l("85070591730234615865843651857942052864"_uint128);
2506 1 : CATCH_REQUIRE(l == v);
2507 : }
2508 : }
2509 3 : CATCH_END_SECTION()
2510 :
2511 3 : CATCH_START_SECTION("[u]int128_literal: large numbers in decimal, hexadecimal, octal and binary")
2512 : {
2513 : using namespace snapdev::literals;
2514 :
2515 : // test a negative decimal number of 128 bits
2516 : // (the minus is arithmetic in the compiler, not part of the literal)
2517 : {
2518 1 : __int128 const top(0x1485B9AD5F387C22);
2519 1 : __int128 const bottom(0x1A94732C11DA7DAF);
2520 1 : __int128 const v((top << 64UL) | bottom);
2521 1 : __int128 l(-27278901379601602040904188621408075183_int128);
2522 1 : CATCH_REQUIRE(l == -v);
2523 1 : __int128 s(-"27278901379601602040904188621408075183"_int128);
2524 1 : CATCH_REQUIRE(s == -v);
2525 : }
2526 :
2527 : // test an hexadecimal number of 128 bits
2528 : {
2529 1 : unsigned __int128 const top(0xFA83B93D5C387C22);
2530 1 : unsigned __int128 const bottom(0x1A94C329111A73AF);
2531 1 : unsigned __int128 const v((top << 64UL) | bottom);
2532 1 : unsigned __int128 l(0xFA83B93D5C387c221A94C329111a73AF_uint128);
2533 1 : CATCH_REQUIRE(l == v);
2534 1 : unsigned __int128 s("0xFA83B93D5C387c221A94C329111a73AF"_uint128);
2535 1 : CATCH_REQUIRE(s == v);
2536 : }
2537 :
2538 : // test an octal number of 126 bits
2539 : {
2540 1 : unsigned __int128 const top(0352035623653416076042); // this is only 63 bits (21 digits each representing 3 bits)
2541 1 : unsigned __int128 const bottom(0152246062442106471657);
2542 1 : unsigned __int128 const v((top << 63UL) | bottom);
2543 1 : unsigned __int128 l(0352035623653416076042152246062442106471657_uint128);
2544 1 : CATCH_REQUIRE(l == v);
2545 1 : unsigned __int128 s("0352035623653416076042152246062442106471657"_uint128);
2546 1 : CATCH_REQUIRE(s == v);
2547 : }
2548 :
2549 : // test a binary number of 126 bits
2550 : {
2551 1 : unsigned __int128 const top(0352535624657416076142); // this is only 63 bits (21 digits each representing 3 bits)
2552 1 : unsigned __int128 const bottom(0132245062742106471635);
2553 1 : unsigned __int128 const v((top << 63UL) | bottom);
2554 1 : unsigned __int128 l(0b11101010101011101110010100110101111100001110000111110001100010001011010010100101000110010111100010001000110100111001110011101_uint128);
2555 1 : CATCH_REQUIRE(l == v);
2556 1 : unsigned __int128 s("0b11101010101011101110010100110101111100001110000111110001100010001011010010100101000110010111100010001000110100111001110011101"_uint128);
2557 1 : CATCH_REQUIRE(s == v);
2558 : }
2559 : }
2560 3 : CATCH_END_SECTION()
2561 3 : }
2562 :
2563 :
2564 5 : CATCH_TEST_CASE("int128_powers", "[math][int128]")
2565 : {
2566 5 : CATCH_START_SECTION("int128: 2^n with n from 0 to 127")
2567 : {
2568 : using namespace snapdev::literals;
2569 :
2570 1 : __int128 v(1);
2571 129 : for(int p(0); p < 128; ++p, v *= 2)
2572 : {
2573 128 : CATCH_REQUIRE(snapdev::pow(2_int128, p) == v);
2574 : }
2575 : }
2576 5 : CATCH_END_SECTION()
2577 :
2578 5 : CATCH_START_SECTION("uint128: 2^n with n from 0 to 127")
2579 : {
2580 : using namespace snapdev::literals;
2581 :
2582 1 : unsigned __int128 v(1);
2583 129 : for(int p(0); p < 128; ++p, v *= 2)
2584 : {
2585 128 : CATCH_REQUIRE(snapdev::pow(2_uint128, p) == v);
2586 : }
2587 : }
2588 5 : CATCH_END_SECTION()
2589 :
2590 5 : CATCH_START_SECTION("[u]int128: n^0 where n is a random number")
2591 : {
2592 : using namespace snapdev::literals;
2593 :
2594 11 : for(int repeat(0); repeat < 10; ++repeat)
2595 : {
2596 10 : unsigned __int128 u(0_uint128);
2597 170 : for(int p(0); p < 16; ++p)
2598 : {
2599 160 : u <<= 8;
2600 160 : u |= rand() & 0x00FF;
2601 : }
2602 10 : CATCH_REQUIRE(snapdev::pow(u, 0) == 1);
2603 :
2604 10 : __int128 v(0_uint128);
2605 170 : for(int p(0); p < 16; ++p)
2606 : {
2607 160 : v <<= 8;
2608 160 : v |= rand() & 0x00FF;
2609 : }
2610 10 : if((repeat & 1) == 0 && v > 0)
2611 : {
2612 : // make sure the value is negative at times
2613 : //
2614 2 : v = -v;
2615 : }
2616 10 : CATCH_REQUIRE(snapdev::pow(v, 0) == 1);
2617 : }
2618 : }
2619 5 : CATCH_END_SECTION()
2620 :
2621 5 : CATCH_START_SECTION("int128: 1^n with n < 0")
2622 : {
2623 : using namespace snapdev::literals;
2624 :
2625 129 : for(int p(-128); p < 0; ++p)
2626 : {
2627 128 : CATCH_REQUIRE(snapdev::pow(1_int128, p) == 1);
2628 128 : CATCH_REQUIRE(snapdev::pow(1_uint128, p) == 1);
2629 :
2630 : // for any other number, it becomes 0
2631 : //
2632 128 : CATCH_REQUIRE(snapdev::pow(2_int128, p) == 0);
2633 128 : CATCH_REQUIRE(snapdev::pow(2_uint128, p) == 0);
2634 128 : CATCH_REQUIRE(snapdev::pow(3_int128, p) == 0);
2635 128 : CATCH_REQUIRE(snapdev::pow(3_uint128, p) == 0);
2636 128 : CATCH_REQUIRE(snapdev::pow(4_int128, p) == 0);
2637 128 : CATCH_REQUIRE(snapdev::pow(4_uint128, p) == 0);
2638 128 : CATCH_REQUIRE(snapdev::pow(5_int128, p) == 0);
2639 128 : CATCH_REQUIRE(snapdev::pow(5_uint128, p) == 0);
2640 : }
2641 : }
2642 5 : CATCH_END_SECTION()
2643 :
2644 5 : CATCH_START_SECTION("int128: -1^n with n < 0")
2645 : {
2646 : using namespace snapdev::literals;
2647 :
2648 129 : for(int p(-128); p < 0; ++p)
2649 : {
2650 128 : if((p & 1) == 0)
2651 : {
2652 64 : CATCH_REQUIRE(snapdev::pow(-1_int128, p) == 1);
2653 : }
2654 : else
2655 : {
2656 64 : CATCH_REQUIRE(snapdev::pow(-1_int128, p) == -1);
2657 : }
2658 :
2659 : // for any other number, it becomes 0
2660 : //
2661 128 : CATCH_REQUIRE(snapdev::pow(-2_int128, p) == 0);
2662 128 : CATCH_REQUIRE(snapdev::pow(-3_int128, p) == 0);
2663 128 : CATCH_REQUIRE(snapdev::pow(-4_int128, p) == 0);
2664 128 : CATCH_REQUIRE(snapdev::pow(-5_int128, p) == 0);
2665 : }
2666 : }
2667 5 : CATCH_END_SECTION()
2668 5 : }
2669 :
2670 :
2671 :
2672 : // vim: ts=4 sw=4 et
|
