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