src/uint256.h

   1 // Copyright (c) 2009-2010 Satoshi Nakamoto
   2 // Copyright (c) 2009-2013 The Bitcoin developers
   3 // Distributed under the MIT/X11 software license, see the accompanying
   4 // file COPYING or http://www.opensource.org/licenses/mit-license.php.
   5
   6 #ifndef BITCOIN_UINT256_H
   7 #define BITCOIN_UINT256_H
   8
   9 #include <stdint.h>
  10 #include <stdio.h>
  11 #include <string>
  12 #include <string.h>
  13 #include <vector>
  14
  15 extern const signed char p_util_hexdigit[256]; // defined in util.cpp
  16
  17 inline signed char HexDigit(char c)
  18 {
  19     return p_util_hexdigit[(unsigned char)c];
  20 }
  21
  22 /** Base class without constructors for uint256 and uint160.
  23  * This makes the compiler let you use it in a union.
  24  */
  25 template<unsigned int BITS>
  26 class base_uint
  27 {
  28 protected:
  29     enum { WIDTH=BITS/32 };
  30     uint32_t pn[WIDTH];
  31 public:
  32
  33     bool operator!() const
  34     {
  35         for (int i = 0; i < WIDTH; i++)
  36             if (pn[i] != 0)
  37                 return false;
  38         return true;
  39     }
  40
  41     const base_uint operator~() const
  42     {
  43         base_uint ret;
  44         for (int i = 0; i < WIDTH; i++)
  45             ret.pn[i] = ~pn[i];
  46         return ret;
  47     }
  48
  49     const base_uint operator-() const
  50     {
  51         base_uint ret;
  52         for (int i = 0; i < WIDTH; i++)
  53             ret.pn[i] = ~pn[i];
  54         ret++;
  55         return ret;
  56     }
  57
  58     double getdouble() const
  59     {
  60         double ret = 0.0;
  61         double fact = 1.0;
  62         for (int i = 0; i < WIDTH; i++) {
  63             ret += fact * pn[i];
  64             fact *= 4294967296.0;
  65         }
  66         return ret;
  67     }
  68
  69     base_uint& operator=(uint64_t b)
  70     {
  71         pn[0] = (unsigned int)b;
  72         pn[1] = (unsigned int)(b >> 32);
  73         for (int i = 2; i < WIDTH; i++)
  74             pn[i] = 0;
  75         return *this;
  76     }
  77
  78     base_uint& operator^=(const base_uint& b)
  79     {
  80         for (int i = 0; i < WIDTH; i++)
  81             pn[i] ^= b.pn[i];
  82         return *this;
  83     }
  84
  85     base_uint& operator&=(const base_uint& b)
  86     {
  87         for (int i = 0; i < WIDTH; i++)
  88             pn[i] &= b.pn[i];
  89         return *this;
  90     }
  91
  92     base_uint& operator|=(const base_uint& b)
  93     {
  94         for (int i = 0; i < WIDTH; i++)
  95             pn[i] |= b.pn[i];
  96         return *this;
  97     }
  98
  99     base_uint& operator^=(uint64_t b)
 100     {
 101         pn[0] ^= (unsigned int)b;
 102         pn[1] ^= (unsigned int)(b >> 32);
 103         return *this;
 104     }
 105
 106     base_uint& operator|=(uint64_t b)
 107     {
 108         pn[0] |= (unsigned int)b;
 109         pn[1] |= (unsigned int)(b >> 32);
 110         return *this;
 111     }
 112
 113     base_uint& operator<<=(unsigned int shift)
 114     {
 115         base_uint a(*this);
 116         for (int i = 0; i < WIDTH; i++)
 117             pn[i] = 0;
 118         int k = shift / 32;
 119         shift = shift % 32;
 120         for (int i = 0; i < WIDTH; i++)
 121         {
 122             if (i+k+1 < WIDTH && shift != 0)
 123                 pn[i+k+1] |= (a.pn[i] >> (32-shift));
 124             if (i+k < WIDTH)
 125                 pn[i+k] |= (a.pn[i] << shift);
 126         }
 127         return *this;
 128     }
 129
 130     base_uint& operator>>=(unsigned int shift)
 131     {
 132         base_uint a(*this);
 133         for (int i = 0; i < WIDTH; i++)
 134             pn[i] = 0;
 135         int k = shift / 32;
 136         shift = shift % 32;
 137         for (int i = 0; i < WIDTH; i++)
 138         {
 139             if (i-k-1 >= 0 && shift != 0)
 140                 pn[i-k-1] |= (a.pn[i] << (32-shift));
 141             if (i-k >= 0)
 142                 pn[i-k] |= (a.pn[i] >> shift);
 143         }
 144         return *this;
 145     }
 146
 147     base_uint& operator+=(const base_uint& b)
 148     {
 149         uint64_t carry = 0;
 150         for (int i = 0; i < WIDTH; i++)
 151         {
 152             uint64_t n = carry + pn[i] + b.pn[i];
 153             pn[i] = n & 0xffffffff;
 154             carry = n >> 32;
 155         }
 156         return *this;
 157     }
 158
 159     base_uint& operator-=(const base_uint& b)
 160     {
 161         *this += -b;
 162         return *this;
 163     }
 164
 165     base_uint& operator+=(uint64_t b64)
 166     {
 167         base_uint b;
 168         b = b64;
 169         *this += b;
 170         return *this;
 171     }
 172
 173     base_uint& operator-=(uint64_t b64)
 174     {
 175         base_uint b;
 176         b = b64;
 177         *this += -b;
 178         return *this;
 179     }
 180
 181
 182     base_uint& operator++()
 183     {
 184         // prefix operator
 185         int i = 0;
 186         while (++pn[i] == 0 && i < WIDTH-1)
 187             i++;
 188         return *this;
 189     }
 190
 191     const base_uint operator++(int)
 192     {
 193         // postfix operator
 194         const base_uint ret = *this;
 195         ++(*this);
 196         return ret;
 197     }
 198
 199     base_uint& operator--()
 200     {
 201         // prefix operator
 202         int i = 0;
 203         while (--pn[i] == (uint32_t)-1 && i < WIDTH-1)
 204             i++;
 205         return *this;
 206     }
 207
 208     const base_uint operator--(int)
 209     {
 210         // postfix operator
 211         const base_uint ret = *this;
 212         --(*this);
 213         return ret;
 214     }
 215
 216
 217     friend inline bool operator<(const base_uint& a, const base_uint& b)
 218     {
 219         for (int i = base_uint::WIDTH-1; i >= 0; i--)
 220         {
 221             if (a.pn[i] < b.pn[i])
 222                 return true;
 223             else if (a.pn[i] > b.pn[i])
 224                 return false;
 225         }
 226         return false;
 227     }
 228
 229     friend inline bool operator<=(const base_uint& a, const base_uint& b)
 230     {
 231         for (int i = base_uint::WIDTH-1; i >= 0; i--)
 232         {
 233             if (a.pn[i] < b.pn[i])
 234                 return true;
 235             else if (a.pn[i] > b.pn[i])
 236                 return false;
 237         }
 238         return true;
 239     }
 240
 241     friend inline bool operator>(const base_uint& a, const base_uint& b)
 242     {
 243         for (int i = base_uint::WIDTH-1; i >= 0; i--)
 244         {
 245             if (a.pn[i] > b.pn[i])
 246                 return true;
 247             else if (a.pn[i] < b.pn[i])
 248                 return false;
 249         }
 250         return false;
 251     }
 252
 253     friend inline bool operator>=(const base_uint& a, const base_uint& b)
 254     {
 255         for (int i = base_uint::WIDTH-1; i >= 0; i--)
 256         {
 257             if (a.pn[i] > b.pn[i])
 258                 return true;
 259             else if (a.pn[i] < b.pn[i])
 260                 return false;
 261         }
 262         return true;
 263     }
 264
 265     friend inline bool operator==(const base_uint& a, const base_uint& b)
 266     {
 267         for (int i = 0; i < base_uint::WIDTH; i++)
 268             if (a.pn[i] != b.pn[i])
 269                 return false;
 270         return true;
 271     }
 272
 273     friend inline bool operator==(const base_uint& a, uint64_t b)
 274     {
 275         if (a.pn[0] != (unsigned int)b)
 276             return false;
 277         if (a.pn[1] != (unsigned int)(b >> 32))
 278             return false;
 279         for (int i = 2; i < base_uint::WIDTH; i++)
 280             if (a.pn[i] != 0)
 281                 return false;
 282         return true;
 283     }
 284
 285     friend inline bool operator!=(const base_uint& a, const base_uint& b)
 286     {
 287         return (!(a == b));
 288     }
 289
 290     friend inline bool operator!=(const base_uint& a, uint64_t b)
 291     {
 292         return (!(a == b));
 293     }
 294
 295
 296
 297     std::string GetHex() const
 298     {
 299         char psz[sizeof(pn)*2 + 1];
 300         for (unsigned int i = 0; i < sizeof(pn); i++)
 301             sprintf(psz + i*2, "%02x", ((unsigned char*)pn)[sizeof(pn) - i - 1]);
 302         return std::string(psz, psz + sizeof(pn)*2);
 303     }
 304
 305     void SetHex(const char* psz)
 306     {
 307         memset(pn,0,sizeof(pn));
 308
 309         // skip leading spaces
 310         while (isspace(*psz))
 311             psz++;
 312
 313         // skip 0x
 314         if (psz[0] == '0' && tolower(psz[1]) == 'x')
 315             psz += 2;
 316
 317         // hex string to uint
 318         const char* pbegin = psz;
 319         while (::HexDigit(*psz) != -1)
 320             psz++;
 321         psz--;
 322         unsigned char* p1 = (unsigned char*)pn;
 323         unsigned char* pend = p1 + WIDTH * 4;
 324         while (psz >= pbegin && p1 < pend)
 325         {
 326             *p1 = ::HexDigit(*psz--);
 327             if (psz >= pbegin)
 328             {
 329                 *p1 |= ((unsigned char)::HexDigit(*psz--) << 4);
 330                 p1++;
 331             }
 332         }
 333     }
 334
 335     void SetHex(const std::string& str)
 336     {
 337         SetHex(str.c_str());
 338     }
 339
 340     std::string ToString() const
 341     {
 342         return (GetHex());
 343     }
 344
 345     unsigned char* begin()
 346     {
 347         return (unsigned char*)&pn[0];
 348     }
 349
 350     unsigned char* end()
 351     {
 352         return (unsigned char*)&pn[WIDTH];
 353     }
 354
 355     const unsigned char* begin() const
 356     {
 357         return (unsigned char*)&pn[0];
 358     }
 359
 360     const unsigned char* end() const
 361     {
 362         return (unsigned char*)&pn[WIDTH];
 363     }
 364
 365     unsigned int size() const
 366     {
 367         return sizeof(pn);
 368     }
 369
 370     uint64_t GetLow64() const
 371     {
 372         assert(WIDTH >= 2);
 373         return pn[0] | (uint64_t)pn[1] << 32;
 374     }
 375
 376 //    unsigned int GetSerializeSize(int nType=0, int nVersion=PROTOCOL_VERSION) const
 377     unsigned int GetSerializeSize(int nType, int nVersion) const
 378     {
 379         return sizeof(pn);
 380     }
 381
 382     template<typename Stream>
 383 //    void Serialize(Stream& s, int nType=0, int nVersion=PROTOCOL_VERSION) const
 384     void Serialize(Stream& s, int nType, int nVersion) const
 385     {
 386         s.write((char*)pn, sizeof(pn));
 387     }
 388
 389     template<typename Stream>
 390 //    void Unserialize(Stream& s, int nType=0, int nVersion=PROTOCOL_VERSION)
 391     void Unserialize(Stream& s, int nType, int nVersion)
 392     {
 393         s.read((char*)pn, sizeof(pn));
 394     }
 395
 396
 397     friend class uint160;
 398     friend class uint256;
 399 };
 400
 401 typedef base_uint<160> base_uint160;
 402 typedef base_uint<256> base_uint256;
 403
 404
 405
 406 //
 407 // uint160 and uint256 could be implemented as templates, but to keep
 408 // compile errors and debugging cleaner, they're copy and pasted.
 409 //
 410
 411
 412
 413 //////////////////////////////////////////////////////////////////////////////
 414 //
 415 // uint160
 416 //
 417
 418 /** 160-bit unsigned integer */
 419 class uint160 : public base_uint160
 420 {
 421 public:
 422     typedef base_uint160 basetype;
 423
 424     uint160()
 425     {
 426         for (int i = 0; i < WIDTH; i++)
 427             pn[i] = 0;
 428     }
 429
 430     uint160(const basetype& b)
 431     {
 432         for (int i = 0; i < WIDTH; i++)
 433             pn[i] = b.pn[i];
 434     }
 435
 436     uint160& operator=(const basetype& b)
 437     {
 438         for (int i = 0; i < WIDTH; i++)
 439             pn[i] = b.pn[i];
 440         return *this;
 441     }
 442
 443     uint160(uint64_t b)
 444     {
 445         pn[0] = (unsigned int)b;
 446         pn[1] = (unsigned int)(b >> 32);
 447         for (int i = 2; i < WIDTH; i++)
 448             pn[i] = 0;
 449     }
 450
 451     uint160& operator=(uint64_t b)
 452     {
 453         pn[0] = (unsigned int)b;
 454         pn[1] = (unsigned int)(b >> 32);
 455         for (int i = 2; i < WIDTH; i++)
 456             pn[i] = 0;
 457         return *this;
 458     }
 459
 460     explicit uint160(const std::string& str)
 461     {
 462         SetHex(str);
 463     }
 464
 465     explicit uint160(const std::vector<unsigned char>& vch)
 466     {
 467         if (vch.size() == sizeof(pn))
 468             memcpy(pn, &vch[0], sizeof(pn));
 469         else
 470             *this = 0;
 471     }
 472 };
 473
 474 inline bool operator==(const uint160& a, uint64_t b)                         { return (base_uint160)a == b; }
 475 inline bool operator!=(const uint160& a, uint64_t b)                         { return (base_uint160)a != b; }
 476 inline const uint160 operator<<(const base_uint160& a, unsigned int shift)   { return uint160(a) <<= shift; }
 477 inline const uint160 operator>>(const base_uint160& a, unsigned int shift)   { return uint160(a) >>= shift; }
 478 inline const uint160 operator<<(const uint160& a, unsigned int shift)        { return uint160(a) <<= shift; }
 479 inline const uint160 operator>>(const uint160& a, unsigned int shift)        { return uint160(a) >>= shift; }
 480
 481 inline const uint160 operator^(const base_uint160& a, const base_uint160& b) { return uint160(a) ^= b; }
 482 inline const uint160 operator&(const base_uint160& a, const base_uint160& b) { return uint160(a) &= b; }
 483 inline const uint160 operator|(const base_uint160& a, const base_uint160& b) { return uint160(a) |= b; }
 484 inline const uint160 operator+(const base_uint160& a, const base_uint160& b) { return uint160(a) += b; }
 485 inline const uint160 operator-(const base_uint160& a, const base_uint160& b) { return uint160(a) -= b; }
 486
 487 inline bool operator<(const base_uint160& a, const uint160& b)               { return (base_uint160)a <  (base_uint160)b; }
 488 inline bool operator<=(const base_uint160& a, const uint160& b)              { return (base_uint160)a <= (base_uint160)b; }
 489 inline bool operator>(const base_uint160& a, const uint160& b)               { return (base_uint160)a >  (base_uint160)b; }
 490 inline bool operator>=(const base_uint160& a, const uint160& b)              { return (base_uint160)a >= (base_uint160)b; }
 491 inline bool operator==(const base_uint160& a, const uint160& b)              { return (base_uint160)a == (base_uint160)b; }
 492 inline bool operator!=(const base_uint160& a, const uint160& b)              { return (base_uint160)a != (base_uint160)b; }
 493 inline const uint160 operator^(const base_uint160& a, const uint160& b)      { return (base_uint160)a ^  (base_uint160)b; }
 494 inline const uint160 operator&(const base_uint160& a, const uint160& b)      { return (base_uint160)a &  (base_uint160)b; }
 495 inline const uint160 operator|(const base_uint160& a, const uint160& b)      { return (base_uint160)a |  (base_uint160)b; }
 496 inline const uint160 operator+(const base_uint160& a, const uint160& b)      { return (base_uint160)a +  (base_uint160)b; }
 497 inline const uint160 operator-(const base_uint160& a, const uint160& b)      { return (base_uint160)a -  (base_uint160)b; }
 498
 499 inline bool operator<(const uint160& a, const base_uint160& b)               { return (base_uint160)a <  (base_uint160)b; }
 500 inline bool operator<=(const uint160& a, const base_uint160& b)              { return (base_uint160)a <= (base_uint160)b; }
 501 inline bool operator>(const uint160& a, const base_uint160& b)               { return (base_uint160)a >  (base_uint160)b; }
 502 inline bool operator>=(const uint160& a, const base_uint160& b)              { return (base_uint160)a >= (base_uint160)b; }
 503 inline bool operator==(const uint160& a, const base_uint160& b)              { return (base_uint160)a == (base_uint160)b; }
 504 inline bool operator!=(const uint160& a, const base_uint160& b)              { return (base_uint160)a != (base_uint160)b; }
 505 inline const uint160 operator^(const uint160& a, const base_uint160& b)      { return (base_uint160)a ^  (base_uint160)b; }
 506 inline const uint160 operator&(const uint160& a, const base_uint160& b)      { return (base_uint160)a &  (base_uint160)b; }
 507 inline const uint160 operator|(const uint160& a, const base_uint160& b)      { return (base_uint160)a |  (base_uint160)b; }
 508 inline const uint160 operator+(const uint160& a, const base_uint160& b)      { return (base_uint160)a +  (base_uint160)b; }
 509 inline const uint160 operator-(const uint160& a, const base_uint160& b)      { return (base_uint160)a -  (base_uint160)b; }
 510
 511 inline bool operator<(const uint160& a, const uint160& b)                    { return (base_uint160)a <  (base_uint160)b; }
 512 inline bool operator<=(const uint160& a, const uint160& b)                   { return (base_uint160)a <= (base_uint160)b; }
 513 inline bool operator>(const uint160& a, const uint160& b)                    { return (base_uint160)a >  (base_uint160)b; }
 514 inline bool operator>=(const uint160& a, const uint160& b)                   { return (base_uint160)a >= (base_uint160)b; }
 515 inline bool operator==(const uint160& a, const uint160& b)                   { return (base_uint160)a == (base_uint160)b; }
 516 inline bool operator!=(const uint160& a, const uint160& b)                   { return (base_uint160)a != (base_uint160)b; }
 517 inline const uint160 operator^(const uint160& a, const uint160& b)           { return (base_uint160)a ^  (base_uint160)b; }
 518 inline const uint160 operator&(const uint160& a, const uint160& b)           { return (base_uint160)a &  (base_uint160)b; }
 519 inline const uint160 operator|(const uint160& a, const uint160& b)           { return (base_uint160)a |  (base_uint160)b; }
 520 inline const uint160 operator+(const uint160& a, const uint160& b)           { return (base_uint160)a +  (base_uint160)b; }
 521 inline const uint160 operator-(const uint160& a, const uint160& b)           { return (base_uint160)a -  (base_uint160)b; }
 522
 523
 524
 525 //////////////////////////////////////////////////////////////////////////////
 526 //
 527 // uint256
 528 //
 529
 530 /** 256-bit unsigned integer */
 531 class uint256 : public base_uint256
 532 {
 533 public:
 534     typedef base_uint256 basetype;
 535
 536     uint256()
 537     {
 538         for (int i = 0; i < WIDTH; i++)
 539             pn[i] = 0;
 540     }
 541
 542     uint256(const basetype& b)
 543     {
 544         for (int i = 0; i < WIDTH; i++)
 545             pn[i] = b.pn[i];
 546     }
 547
 548     uint256& operator=(const basetype& b)
 549     {
 550         for (int i = 0; i < WIDTH; i++)
 551             pn[i] = b.pn[i];
 552         return *this;
 553     }
 554
 555     uint256(uint64_t b)
 556     {
 557         pn[0] = (unsigned int)b;
 558         pn[1] = (unsigned int)(b >> 32);
 559         for (int i = 2; i < WIDTH; i++)
 560             pn[i] = 0;
 561     }
 562
 563     uint256& operator=(uint64_t b)
 564     {
 565         pn[0] = (unsigned int)b;
 566         pn[1] = (unsigned int)(b >> 32);
 567         for (int i = 2; i < WIDTH; i++)
 568             pn[i] = 0;
 569         return *this;
 570     }
 571
 572     explicit uint256(const std::string& str)
 573     {
 574         SetHex(str);
 575     }
 576
 577     explicit uint256(const std::vector<unsigned char>& vch)
 578     {
 579         if (vch.size() == sizeof(pn))
 580             memcpy(pn, &vch[0], sizeof(pn));
 581         else
 582             *this = 0;
 583     }
 584 };
 585
 586 inline bool operator==(const uint256& a, uint64_t b)                          { return (base_uint256)a == b; }
 587 inline bool operator!=(const uint256& a, uint64_t b)                          { return (base_uint256)a != b; }
 588 inline const uint256 operator<<(const base_uint256& a, unsigned int shift)   { return uint256(a) <<= shift; }
 589 inline const uint256 operator>>(const base_uint256& a, unsigned int shift)   { return uint256(a) >>= shift; }
 590 inline const uint256 operator<<(const uint256& a, unsigned int shift)        { return uint256(a) <<= shift; }
 591 inline const uint256 operator>>(const uint256& a, unsigned int shift)        { return uint256(a) >>= shift; }
 592
 593 inline const uint256 operator^(const base_uint256& a, const base_uint256& b) { return uint256(a) ^= b; }
 594 inline const uint256 operator&(const base_uint256& a, const base_uint256& b) { return uint256(a) &= b; }
 595 inline const uint256 operator|(const base_uint256& a, const base_uint256& b) { return uint256(a) |= b; }
 596 inline const uint256 operator+(const base_uint256& a, const base_uint256& b) { return uint256(a) += b; }
 597 inline const uint256 operator-(const base_uint256& a, const base_uint256& b) { return uint256(a) -= b; }
 598
 599 inline bool operator<(const base_uint256& a, const uint256& b)          { return (base_uint256)a <  (base_uint256)b; }
 600 inline bool operator<=(const base_uint256& a, const uint256& b)         { return (base_uint256)a <= (base_uint256)b; }
 601 inline bool operator>(const base_uint256& a, const uint256& b)          { return (base_uint256)a >  (base_uint256)b; }
 602 inline bool operator>=(const base_uint256& a, const uint256& b)         { return (base_uint256)a >= (base_uint256)b; }
 603 inline bool operator==(const base_uint256& a, const uint256& b)         { return (base_uint256)a == (base_uint256)b; }
 604 inline bool operator!=(const base_uint256& a, const uint256& b)         { return (base_uint256)a != (base_uint256)b; }
 605 inline const uint256 operator^(const base_uint256& a, const uint256& b) { return (base_uint256)a ^  (base_uint256)b; }
 606 inline const uint256 operator&(const base_uint256& a, const uint256& b) { return (base_uint256)a &  (base_uint256)b; }
 607 inline const uint256 operator|(const base_uint256& a, const uint256& b) { return (base_uint256)a |  (base_uint256)b; }
 608 inline const uint256 operator+(const base_uint256& a, const uint256& b) { return (base_uint256)a +  (base_uint256)b; }
 609 inline const uint256 operator-(const base_uint256& a, const uint256& b) { return (base_uint256)a -  (base_uint256)b; }
 610
 611 inline bool operator<(const uint256& a, const base_uint256& b)          { return (base_uint256)a <  (base_uint256)b; }
 612 inline bool operator<=(const uint256& a, const base_uint256& b)         { return (base_uint256)a <= (base_uint256)b; }
 613 inline bool operator>(const uint256& a, const base_uint256& b)          { return (base_uint256)a >  (base_uint256)b; }
 614 inline bool operator>=(const uint256& a, const base_uint256& b)         { return (base_uint256)a >= (base_uint256)b; }
 615 inline bool operator==(const uint256& a, const base_uint256& b)         { return (base_uint256)a == (base_uint256)b; }
 616 inline bool operator!=(const uint256& a, const base_uint256& b)         { return (base_uint256)a != (base_uint256)b; }
 617 inline const uint256 operator^(const uint256& a, const base_uint256& b) { return (base_uint256)a ^  (base_uint256)b; }
 618 inline const uint256 operator&(const uint256& a, const base_uint256& b) { return (base_uint256)a &  (base_uint256)b; }
 619 inline const uint256 operator|(const uint256& a, const base_uint256& b) { return (base_uint256)a |  (base_uint256)b; }
 620 inline const uint256 operator+(const uint256& a, const base_uint256& b) { return (base_uint256)a +  (base_uint256)b; }
 621 inline const uint256 operator-(const uint256& a, const base_uint256& b) { return (base_uint256)a -  (base_uint256)b; }
 622
 623 inline bool operator<(const uint256& a, const uint256& b)               { return (base_uint256)a <  (base_uint256)b; }
 624 inline bool operator<=(const uint256& a, const uint256& b)              { return (base_uint256)a <= (base_uint256)b; }
 625 inline bool operator>(const uint256& a, const uint256& b)               { return (base_uint256)a >  (base_uint256)b; }
 626 inline bool operator>=(const uint256& a, const uint256& b)              { return (base_uint256)a >= (base_uint256)b; }
 627 inline bool operator==(const uint256& a, const uint256& b)              { return (base_uint256)a == (base_uint256)b; }
 628 inline bool operator!=(const uint256& a, const uint256& b)              { return (base_uint256)a != (base_uint256)b; }
 629 inline const uint256 operator^(const uint256& a, const uint256& b)      { return (base_uint256)a ^  (base_uint256)b; }
 630 inline const uint256 operator&(const uint256& a, const uint256& b)      { return (base_uint256)a &  (base_uint256)b; }
 631 inline const uint256 operator|(const uint256& a, const uint256& b)      { return (base_uint256)a |  (base_uint256)b; }
 632 inline const uint256 operator+(const uint256& a, const uint256& b)      { return (base_uint256)a +  (base_uint256)b; }
 633 inline const uint256 operator-(const uint256& a, const uint256& b)      { return (base_uint256)a -  (base_uint256)b; }
 634
 635 #endif