src/uint256.h

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