1 // Copyright (c) 2009-2010 Satoshi Nakamoto
2 // Distributed under the MIT/X11 software license, see the accompanying
3 // file license.txt or http://www.opensource.org/licenses/mit-license.php.
7 #if defined(_MSC_VER) || defined(__BORLANDC__)
9 typedef unsigned __int64 uint64
;
11 typedef long long int64
;
12 typedef unsigned long long uint64
;
14 #if defined(_MSC_VER) && _MSC_VER < 1300
15 #define for if (false) ; else for
19 inline int Testuint256AdHoc(vector
<string
> vArg
);
23 // We have to keep a separate base class without constructors
24 // so the compiler will let us use it in a union
25 template<unsigned int BITS
>
29 enum { WIDTH
=BITS
/32 };
30 unsigned int pn
[WIDTH
];
33 bool operator!() const
35 for (int i
= 0; i
< WIDTH
; i
++)
41 const base_uint
operator~() const
44 for (int i
= 0; i
< WIDTH
; i
++)
49 const base_uint
operator-() const
52 for (int i
= 0; i
< WIDTH
; i
++)
59 base_uint
& operator=(uint64 b
)
61 pn
[0] = (unsigned int)b
;
62 pn
[1] = (unsigned int)(b
>> 32);
63 for (int i
= 2; i
< WIDTH
; i
++)
68 base_uint
& operator^=(const base_uint
& b
)
70 for (int i
= 0; i
< WIDTH
; i
++)
75 base_uint
& operator&=(const base_uint
& b
)
77 for (int i
= 0; i
< WIDTH
; i
++)
82 base_uint
& operator|=(const base_uint
& b
)
84 for (int i
= 0; i
< WIDTH
; i
++)
89 base_uint
& operator^=(uint64 b
)
91 pn
[0] ^= (unsigned int)b
;
92 pn
[1] ^= (unsigned int)(b
>> 32);
96 base_uint
& operator&=(uint64 b
)
98 pn
[0] &= (unsigned int)b
;
99 pn
[1] &= (unsigned int)(b
>> 32);
103 base_uint
& operator|=(uint64 b
)
105 pn
[0] |= (unsigned int)b
;
106 pn
[1] |= (unsigned int)(b
>> 32);
110 base_uint
& operator<<=(unsigned int shift
)
113 for (int i
= 0; i
< WIDTH
; i
++)
117 for (int i
= 0; i
< WIDTH
; i
++)
119 if (i
+k
+1 < WIDTH
&& shift
!= 0)
120 pn
[i
+k
+1] |= (a
.pn
[i
] >> (32-shift
));
122 pn
[i
+k
] |= (a
.pn
[i
] << shift
);
127 base_uint
& operator>>=(unsigned int shift
)
130 for (int i
= 0; i
< WIDTH
; i
++)
134 for (int i
= 0; i
< WIDTH
; i
++)
136 if (i
-k
-1 >= 0 && shift
!= 0)
137 pn
[i
-k
-1] |= (a
.pn
[i
] << (32-shift
));
139 pn
[i
-k
] |= (a
.pn
[i
] >> shift
);
144 base_uint
& operator+=(const base_uint
& b
)
147 for (int i
= 0; i
< WIDTH
; i
++)
149 uint64 n
= carry
+ pn
[i
] + b
.pn
[i
];
150 pn
[i
] = n
& 0xffffffff;
156 base_uint
& operator-=(const base_uint
& b
)
162 base_uint
& operator+=(uint64 b64
)
170 base_uint
& operator-=(uint64 b64
)
179 base_uint
& operator++()
183 while (++pn
[i
] == 0 && i
< WIDTH
-1)
188 const base_uint
operator++(int)
191 const base_uint ret
= *this;
196 base_uint
& operator--()
200 while (--pn
[i
] == -1 && i
< WIDTH
-1)
205 const base_uint
operator--(int)
208 const base_uint ret
= *this;
214 friend inline bool operator<(const base_uint
& a
, const base_uint
& b
)
216 for (int i
= base_uint::WIDTH
-1; i
>= 0; i
--)
218 if (a
.pn
[i
] < b
.pn
[i
])
220 else if (a
.pn
[i
] > b
.pn
[i
])
226 friend inline bool operator<=(const base_uint
& a
, const base_uint
& b
)
228 for (int i
= base_uint::WIDTH
-1; i
>= 0; i
--)
230 if (a
.pn
[i
] < b
.pn
[i
])
232 else if (a
.pn
[i
] > b
.pn
[i
])
238 friend inline bool operator>(const base_uint
& a
, const base_uint
& b
)
240 for (int i
= base_uint::WIDTH
-1; i
>= 0; i
--)
242 if (a
.pn
[i
] > b
.pn
[i
])
244 else if (a
.pn
[i
] < b
.pn
[i
])
250 friend inline bool operator>=(const base_uint
& a
, const base_uint
& b
)
252 for (int i
= base_uint::WIDTH
-1; i
>= 0; i
--)
254 if (a
.pn
[i
] > b
.pn
[i
])
256 else if (a
.pn
[i
] < b
.pn
[i
])
262 friend inline bool operator==(const base_uint
& a
, const base_uint
& b
)
264 for (int i
= 0; i
< base_uint::WIDTH
; i
++)
265 if (a
.pn
[i
] != b
.pn
[i
])
270 friend inline bool operator==(const base_uint
& a
, uint64 b
)
272 if (a
.pn
[0] != (unsigned int)b
)
274 if (a
.pn
[1] != (unsigned int)(b
>> 32))
276 for (int i
= 2; i
< base_uint::WIDTH
; i
++)
282 friend inline bool operator!=(const base_uint
& a
, const base_uint
& b
)
287 friend inline bool operator!=(const base_uint
& a
, uint64 b
)
294 std::string
GetHex() const
296 char psz
[sizeof(pn
)*2 + 1];
297 for (int i
= 0; i
< sizeof(pn
); i
++)
298 sprintf(psz
+ i
*2, "%02x", ((unsigned char*)pn
)[sizeof(pn
) - i
- 1]);
299 return string(psz
, psz
+ sizeof(pn
)*2);
302 void SetHex(const char* psz
)
304 for (int i
= 0; i
< WIDTH
; i
++)
307 // skip leading spaces
308 while (isspace(*psz
))
312 if (psz
[0] == '0' && tolower(psz
[1]) == 'x')
315 // hex string to uint
316 static char phexdigit
[256] = { 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,1,2,3,4,5,6,7,8,9,0,0,0,0,0,0, 0,0xa,0xb,0xc,0xd,0xe,0xf,0,0,0,0,0,0,0,0,0, 0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0, 0,0xa,0xb,0xc,0xd,0xe,0xf,0,0,0,0,0,0,0,0,0 };
317 const char* pbegin
= psz
;
318 while (phexdigit
[*psz
] || *psz
== '0')
321 unsigned char* p1
= (unsigned char*)pn
;
322 unsigned char* pend
= p1
+ WIDTH
* 4;
323 while (psz
>= pbegin
&& p1
< pend
)
325 *p1
= phexdigit
[(unsigned char)*psz
--];
328 *p1
|= (phexdigit
[(unsigned char)*psz
--] << 4);
334 void SetHex(const std::string
& str
)
339 std::string
ToString() const
344 unsigned char* begin()
346 return (unsigned char*)&pn
[0];
351 return (unsigned char*)&pn
[WIDTH
];
360 unsigned int GetSerializeSize(int nType
=0, int nVersion
=VERSION
) const
365 template<typename Stream
>
366 void Serialize(Stream
& s
, int nType
=0, int nVersion
=VERSION
) const
368 s
.write((char*)pn
, sizeof(pn
));
371 template<typename Stream
>
372 void Unserialize(Stream
& s
, int nType
=0, int nVersion
=VERSION
)
374 s
.read((char*)pn
, sizeof(pn
));
378 friend class uint160
;
379 friend class uint256
;
380 friend inline int Testuint256AdHoc(vector
<string
> vArg
);
383 typedef base_uint
<160> base_uint160
;
384 typedef base_uint
<256> base_uint256
;
389 // uint160 and uint256 could be implemented as templates, but to keep
390 // compile errors and debugging cleaner, they're copy and pasted.
395 //////////////////////////////////////////////////////////////////////////////
400 class uint160
: public base_uint160
403 typedef base_uint160 basetype
;
407 for (int i
= 0; i
< WIDTH
; i
++)
411 uint160(const basetype
& b
)
413 for (int i
= 0; i
< WIDTH
; i
++)
417 uint160
& operator=(const basetype
& b
)
419 for (int i
= 0; i
< WIDTH
; i
++)
426 pn
[0] = (unsigned int)b
;
427 pn
[1] = (unsigned int)(b
>> 32);
428 for (int i
= 2; i
< WIDTH
; i
++)
432 uint160
& operator=(uint64 b
)
434 pn
[0] = (unsigned int)b
;
435 pn
[1] = (unsigned int)(b
>> 32);
436 for (int i
= 2; i
< WIDTH
; i
++)
441 explicit uint160(const std::string
& str
)
446 explicit uint160(const std::vector
<unsigned char>& vch
)
448 if (vch
.size() == sizeof(pn
))
449 memcpy(pn
, &vch
[0], sizeof(pn
));
455 inline bool operator==(const uint160
& a
, uint64 b
) { return (base_uint160
)a
== b
; }
456 inline bool operator!=(const uint160
& a
, uint64 b
) { return (base_uint160
)a
!= b
; }
457 inline const uint160
operator<<(const base_uint160
& a
, unsigned int shift
) { return uint160(a
) <<= shift
; }
458 inline const uint160
operator>>(const base_uint160
& a
, unsigned int shift
) { return uint160(a
) >>= shift
; }
459 inline const uint160
operator<<(const uint160
& a
, unsigned int shift
) { return uint160(a
) <<= shift
; }
460 inline const uint160
operator>>(const uint160
& a
, unsigned int shift
) { return uint160(a
) >>= shift
; }
462 inline const uint160
operator^(const base_uint160
& a
, const base_uint160
& b
) { return uint160(a
) ^= b
; }
463 inline const uint160
operator&(const base_uint160
& a
, const base_uint160
& b
) { return uint160(a
) &= b
; }
464 inline const uint160
operator|(const base_uint160
& a
, const base_uint160
& b
) { return uint160(a
) |= b
; }
465 inline const uint160
operator+(const base_uint160
& a
, const base_uint160
& b
) { return uint160(a
) += b
; }
466 inline const uint160
operator-(const base_uint160
& a
, const base_uint160
& b
) { return uint160(a
) -= b
; }
468 inline bool operator<(const base_uint160
& a
, const uint160
& b
) { return (base_uint160
)a
< (base_uint160
)b
; }
469 inline bool operator<=(const base_uint160
& a
, const uint160
& b
) { return (base_uint160
)a
<= (base_uint160
)b
; }
470 inline bool operator>(const base_uint160
& a
, const uint160
& b
) { return (base_uint160
)a
> (base_uint160
)b
; }
471 inline bool operator>=(const base_uint160
& a
, const uint160
& b
) { return (base_uint160
)a
>= (base_uint160
)b
; }
472 inline bool operator==(const base_uint160
& a
, const uint160
& b
) { return (base_uint160
)a
== (base_uint160
)b
; }
473 inline bool operator!=(const base_uint160
& a
, const uint160
& b
) { return (base_uint160
)a
!= (base_uint160
)b
; }
474 inline const uint160
operator^(const base_uint160
& a
, const uint160
& b
) { return (base_uint160
)a
^ (base_uint160
)b
; }
475 inline const uint160
operator&(const base_uint160
& a
, const uint160
& b
) { return (base_uint160
)a
& (base_uint160
)b
; }
476 inline const uint160
operator|(const base_uint160
& a
, const uint160
& b
) { return (base_uint160
)a
| (base_uint160
)b
; }
477 inline const uint160
operator+(const base_uint160
& a
, const uint160
& b
) { return (base_uint160
)a
+ (base_uint160
)b
; }
478 inline const uint160
operator-(const base_uint160
& a
, const uint160
& b
) { return (base_uint160
)a
- (base_uint160
)b
; }
480 inline bool operator<(const uint160
& a
, const base_uint160
& b
) { return (base_uint160
)a
< (base_uint160
)b
; }
481 inline bool operator<=(const uint160
& a
, const base_uint160
& b
) { return (base_uint160
)a
<= (base_uint160
)b
; }
482 inline bool operator>(const uint160
& a
, const base_uint160
& b
) { return (base_uint160
)a
> (base_uint160
)b
; }
483 inline bool operator>=(const uint160
& a
, const base_uint160
& b
) { return (base_uint160
)a
>= (base_uint160
)b
; }
484 inline bool operator==(const uint160
& a
, const base_uint160
& b
) { return (base_uint160
)a
== (base_uint160
)b
; }
485 inline bool operator!=(const uint160
& a
, const base_uint160
& b
) { return (base_uint160
)a
!= (base_uint160
)b
; }
486 inline const uint160
operator^(const uint160
& a
, const base_uint160
& b
) { return (base_uint160
)a
^ (base_uint160
)b
; }
487 inline const uint160
operator&(const uint160
& a
, const base_uint160
& b
) { return (base_uint160
)a
& (base_uint160
)b
; }
488 inline const uint160
operator|(const uint160
& a
, const base_uint160
& b
) { return (base_uint160
)a
| (base_uint160
)b
; }
489 inline const uint160
operator+(const uint160
& a
, const base_uint160
& b
) { return (base_uint160
)a
+ (base_uint160
)b
; }
490 inline const uint160
operator-(const uint160
& a
, const base_uint160
& b
) { return (base_uint160
)a
- (base_uint160
)b
; }
492 inline bool operator<(const uint160
& a
, const uint160
& b
) { return (base_uint160
)a
< (base_uint160
)b
; }
493 inline bool operator<=(const uint160
& a
, const uint160
& b
) { return (base_uint160
)a
<= (base_uint160
)b
; }
494 inline bool operator>(const uint160
& a
, const uint160
& b
) { return (base_uint160
)a
> (base_uint160
)b
; }
495 inline bool operator>=(const uint160
& a
, const uint160
& b
) { return (base_uint160
)a
>= (base_uint160
)b
; }
496 inline bool operator==(const uint160
& a
, const uint160
& b
) { return (base_uint160
)a
== (base_uint160
)b
; }
497 inline bool operator!=(const uint160
& a
, const uint160
& b
) { return (base_uint160
)a
!= (base_uint160
)b
; }
498 inline const uint160
operator^(const uint160
& a
, const uint160
& b
) { return (base_uint160
)a
^ (base_uint160
)b
; }
499 inline const uint160
operator&(const uint160
& a
, const uint160
& b
) { return (base_uint160
)a
& (base_uint160
)b
; }
500 inline const uint160
operator|(const uint160
& a
, const uint160
& b
) { return (base_uint160
)a
| (base_uint160
)b
; }
501 inline const uint160
operator+(const uint160
& a
, const uint160
& b
) { return (base_uint160
)a
+ (base_uint160
)b
; }
502 inline const uint160
operator-(const uint160
& a
, const uint160
& b
) { return (base_uint160
)a
- (base_uint160
)b
; }
509 //////////////////////////////////////////////////////////////////////////////
514 class uint256
: public base_uint256
517 typedef base_uint256 basetype
;
521 for (int i
= 0; i
< WIDTH
; i
++)
525 uint256(const basetype
& b
)
527 for (int i
= 0; i
< WIDTH
; i
++)
531 uint256
& operator=(const basetype
& b
)
533 for (int i
= 0; i
< WIDTH
; i
++)
540 pn
[0] = (unsigned int)b
;
541 pn
[1] = (unsigned int)(b
>> 32);
542 for (int i
= 2; i
< WIDTH
; i
++)
546 uint256
& operator=(uint64 b
)
548 pn
[0] = (unsigned int)b
;
549 pn
[1] = (unsigned int)(b
>> 32);
550 for (int i
= 2; i
< WIDTH
; i
++)
555 explicit uint256(const std::string
& str
)
560 explicit uint256(const std::vector
<unsigned char>& vch
)
562 if (vch
.size() == sizeof(pn
))
563 memcpy(pn
, &vch
[0], sizeof(pn
));
569 inline bool operator==(const uint256
& a
, uint64 b
) { return (base_uint256
)a
== b
; }
570 inline bool operator!=(const uint256
& a
, uint64 b
) { return (base_uint256
)a
!= b
; }
571 inline const uint256
operator<<(const base_uint256
& a
, unsigned int shift
) { return uint256(a
) <<= shift
; }
572 inline const uint256
operator>>(const base_uint256
& a
, unsigned int shift
) { return uint256(a
) >>= shift
; }
573 inline const uint256
operator<<(const uint256
& a
, unsigned int shift
) { return uint256(a
) <<= shift
; }
574 inline const uint256
operator>>(const uint256
& a
, unsigned int shift
) { return uint256(a
) >>= shift
; }
576 inline const uint256
operator^(const base_uint256
& a
, const base_uint256
& b
) { return uint256(a
) ^= b
; }
577 inline const uint256
operator&(const base_uint256
& a
, const base_uint256
& b
) { return uint256(a
) &= b
; }
578 inline const uint256
operator|(const base_uint256
& a
, const base_uint256
& b
) { return uint256(a
) |= b
; }
579 inline const uint256
operator+(const base_uint256
& a
, const base_uint256
& b
) { return uint256(a
) += b
; }
580 inline const uint256
operator-(const base_uint256
& a
, const base_uint256
& b
) { return uint256(a
) -= b
; }
582 inline bool operator<(const base_uint256
& a
, const uint256
& b
) { return (base_uint256
)a
< (base_uint256
)b
; }
583 inline bool operator<=(const base_uint256
& a
, const uint256
& b
) { return (base_uint256
)a
<= (base_uint256
)b
; }
584 inline bool operator>(const base_uint256
& a
, const uint256
& b
) { return (base_uint256
)a
> (base_uint256
)b
; }
585 inline bool operator>=(const base_uint256
& a
, const uint256
& b
) { return (base_uint256
)a
>= (base_uint256
)b
; }
586 inline bool operator==(const base_uint256
& a
, const uint256
& b
) { return (base_uint256
)a
== (base_uint256
)b
; }
587 inline bool operator!=(const base_uint256
& a
, const uint256
& b
) { return (base_uint256
)a
!= (base_uint256
)b
; }
588 inline const uint256
operator^(const base_uint256
& a
, const uint256
& b
) { return (base_uint256
)a
^ (base_uint256
)b
; }
589 inline const uint256
operator&(const base_uint256
& a
, const uint256
& b
) { return (base_uint256
)a
& (base_uint256
)b
; }
590 inline const uint256
operator|(const base_uint256
& a
, const uint256
& b
) { return (base_uint256
)a
| (base_uint256
)b
; }
591 inline const uint256
operator+(const base_uint256
& a
, const uint256
& b
) { return (base_uint256
)a
+ (base_uint256
)b
; }
592 inline const uint256
operator-(const base_uint256
& a
, const uint256
& b
) { return (base_uint256
)a
- (base_uint256
)b
; }
594 inline bool operator<(const uint256
& a
, const base_uint256
& b
) { return (base_uint256
)a
< (base_uint256
)b
; }
595 inline bool operator<=(const uint256
& a
, const base_uint256
& b
) { return (base_uint256
)a
<= (base_uint256
)b
; }
596 inline bool operator>(const uint256
& a
, const base_uint256
& b
) { return (base_uint256
)a
> (base_uint256
)b
; }
597 inline bool operator>=(const uint256
& a
, const base_uint256
& b
) { return (base_uint256
)a
>= (base_uint256
)b
; }
598 inline bool operator==(const uint256
& a
, const base_uint256
& b
) { return (base_uint256
)a
== (base_uint256
)b
; }
599 inline bool operator!=(const uint256
& a
, const base_uint256
& b
) { return (base_uint256
)a
!= (base_uint256
)b
; }
600 inline const uint256
operator^(const uint256
& a
, const base_uint256
& b
) { return (base_uint256
)a
^ (base_uint256
)b
; }
601 inline const uint256
operator&(const uint256
& a
, const base_uint256
& b
) { return (base_uint256
)a
& (base_uint256
)b
; }
602 inline const uint256
operator|(const uint256
& a
, const base_uint256
& b
) { return (base_uint256
)a
| (base_uint256
)b
; }
603 inline const uint256
operator+(const uint256
& a
, const base_uint256
& b
) { return (base_uint256
)a
+ (base_uint256
)b
; }
604 inline const uint256
operator-(const uint256
& a
, const base_uint256
& b
) { return (base_uint256
)a
- (base_uint256
)b
; }
606 inline bool operator<(const uint256
& a
, const uint256
& b
) { return (base_uint256
)a
< (base_uint256
)b
; }
607 inline bool operator<=(const uint256
& a
, const uint256
& b
) { return (base_uint256
)a
<= (base_uint256
)b
; }
608 inline bool operator>(const uint256
& a
, const uint256
& b
) { return (base_uint256
)a
> (base_uint256
)b
; }
609 inline bool operator>=(const uint256
& a
, const uint256
& b
) { return (base_uint256
)a
>= (base_uint256
)b
; }
610 inline bool operator==(const uint256
& a
, const uint256
& b
) { return (base_uint256
)a
== (base_uint256
)b
; }
611 inline bool operator!=(const uint256
& a
, const uint256
& b
) { return (base_uint256
)a
!= (base_uint256
)b
; }
612 inline const uint256
operator^(const uint256
& a
, const uint256
& b
) { return (base_uint256
)a
^ (base_uint256
)b
; }
613 inline const uint256
operator&(const uint256
& a
, const uint256
& b
) { return (base_uint256
)a
& (base_uint256
)b
; }
614 inline const uint256
operator|(const uint256
& a
, const uint256
& b
) { return (base_uint256
)a
| (base_uint256
)b
; }
615 inline const uint256
operator+(const uint256
& a
, const uint256
& b
) { return (base_uint256
)a
+ (base_uint256
)b
; }
616 inline const uint256
operator-(const uint256
& a
, const uint256
& b
) { return (base_uint256
)a
- (base_uint256
)b
; }
629 inline int Testuint256AdHoc(vector
<string
> vArg
)
634 printf("%s\n", g
.ToString().c_str());
635 g
--; printf("g--\n");
636 printf("%s\n", g
.ToString().c_str());
637 g
--; printf("g--\n");
638 printf("%s\n", g
.ToString().c_str());
639 g
++; printf("g++\n");
640 printf("%s\n", g
.ToString().c_str());
641 g
++; printf("g++\n");
642 printf("%s\n", g
.ToString().c_str());
643 g
++; printf("g++\n");
644 printf("%s\n", g
.ToString().c_str());
645 g
++; printf("g++\n");
646 printf("%s\n", g
.ToString().c_str());
652 printf("%s\n", a
.ToString().c_str());
655 printf("b undefined\n");
656 printf("%s\n", b
.ToString().c_str());
661 printf("%s\n", a
.ToString().c_str());
666 printf("%s\n", a
.ToString().c_str());
674 printf("a %s\n", a
.ToString().c_str());
676 a
= a
| b
| (uint256
)0x1000;
679 printf("a %s\n", a
.ToString().c_str());
680 printf("b %s\n", b
.ToString().c_str());
685 printf("%s\n", a
.ToString().c_str());
687 printf("%s\n", a
.ToString().c_str());
689 printf("%s\n", a
.ToString().c_str());
691 printf("%s\n", a
.ToString().c_str());
693 printf("%s\n", a
.ToString().c_str());
696 printf("%s\n", a
.ToString().c_str());
698 printf("%s\n", a
.ToString().c_str());
700 printf("%s\n", a
.ToString().c_str());
702 printf("%s\n", d
.ToString().c_str());
703 printf("%s\n", a
.ToString().c_str());
705 printf("%s\n", a
.ToString().c_str());
707 printf("%s\n", a
.ToString().c_str());
711 printf("%s\n", d
.ToString().c_str());
712 for (int i
= uint256::WIDTH
-1; i
>= 0; i
--) printf("%08x", d
.pn
[i
]); printf("\n");
716 printf("%s\n", neg
.ToString().c_str());
719 uint256 e
= uint256("0xABCDEF123abcdef12345678909832180000011111111");
721 printf("%s\n", e
.ToString().c_str());
725 uint256 x1
= uint256("0xABCDEF123abcdef12345678909832180000011111111");
727 printf("%s\n", x1
.ToString().c_str());
728 for (int i
= 0; i
< 270; i
+= 4)
731 printf("%s\n", x2
.ToString().c_str());
735 printf("%s\n", x1
.ToString().c_str());
736 for (int i
= 0; i
< 270; i
+= 4)
740 printf("%s\n", x2
.ToString().c_str());
744 for (int i
= 0; i
< 100; i
++)
746 uint256 k
= (~uint256(0) >> i
);
747 printf("%s\n", k
.ToString().c_str());
750 for (int i
= 0; i
< 100; i
++)
752 uint256 k
= (~uint256(0) << i
);
753 printf("%s\n", k
.ToString().c_str());