Contract 0x29da4ff649d39510f633cd804b860858c333e5ad

/**
 *Submitted for verification at Arbiscan on 2023-03-16
*/

// SPDX-License-Identifier: MIT

pragma solidity 0.8.0;

 /**
  * Smart contract library of mathematical functions operating with signed
  * 64.64-bit fixed point numbers.  Signed 64.64-bit fixed point number is
  * basically a simple fraction whose numerator is signed 128-bit integer and
  * denominator is 2^64.  As long as denominator is always the same, there is no
  * need to store it, thus in Solidity signed 64.64-bit fixed point numbers are
  * represented by int128 type holding only the numerator.
  */
 library ABDKMath64x64 {
     /*
      * Minimum value signed 64.64-bit fixed point number may have.
      */
     int128 private constant MIN_64x64 = -0x80000000000000000000000000000000;
 
     /*
      * Maximum value signed 64.64-bit fixed point number may have.
      */
     int128 private constant MAX_64x64 = 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF;
 
     /**
      * Convert signed 256-bit integer number into signed 64.64-bit fixed point
      * number.  Revert on overflow.
      *
      * @param x signed 256-bit integer number
      * @return signed 64.64-bit fixed point number
      */
     function fromInt(int256 x) internal pure returns (int128) {
         unchecked {
             require(x >= -0x8000000000000000 && x <= 0x7FFFFFFFFFFFFFFF);
             return int128(x << 64);
         }
     }
 
     /**
      * Convert signed 64.64 fixed point number into signed 64-bit integer number
      * rounding down.
      *
      * @param x signed 64.64-bit fixed point number
      * @return signed 64-bit integer number
      */
     function toInt(int128 x) internal pure returns (int64) {
         unchecked {
             return int64(x >> 64);
         }
     }
 
     /**
      * Convert unsigned 256-bit integer number into signed 64.64-bit fixed point
      * number.  Revert on overflow.
      *
      * @param x unsigned 256-bit integer number
      * @return signed 64.64-bit fixed point number
      */
     function fromUInt(uint256 x) internal pure returns (int128) {
         unchecked {
             require(x <= 0x7FFFFFFFFFFFFFFF);
             return int128(int256(x << 64));
         }
     }
 
     /**
      * Convert signed 64.64 fixed point number into unsigned 64-bit integer
      * number rounding down.  Revert on underflow.
      *
      * @param x signed 64.64-bit fixed point number
      * @return unsigned 64-bit integer number
      */
     function toUInt(int128 x) internal pure returns (uint64) {
         unchecked {
             require(x >= 0);
             return uint64(uint128(x >> 64));
         }
     }
 
     /**
      * Convert signed 128.128 fixed point number into signed 64.64-bit fixed point
      * number rounding down.  Revert on overflow.
      *
      * @param x signed 128.128-bin fixed point number
      * @return signed 64.64-bit fixed point number
      */
     function from128x128(int256 x) internal pure returns (int128) {
         unchecked {
             int256 result = x >> 64;
             require(result >= MIN_64x64 && result <= MAX_64x64);
             return int128(result);
         }
     }
 
     /**
      * Convert signed 64.64 fixed point number into signed 128.128 fixed point
      * number.
      *
      * @param x signed 64.64-bit fixed point number
      * @return signed 128.128 fixed point number
      */
     function to128x128(int128 x) internal pure returns (int256) {
         unchecked {
             return int256(x) << 64;
         }
     }
 
     /**
      * Calculate x + y.  Revert on overflow.
      *
      * @param x signed 64.64-bit fixed point number
      * @param y signed 64.64-bit fixed point number
      * @return signed 64.64-bit fixed point number
      */
     function add(int128 x, int128 y) internal pure returns (int128) {
         unchecked {
             int256 result = int256(x) + y;
             require(result >= MIN_64x64 && result <= MAX_64x64);
             return int128(result);
         }
     }
 
     /**
      * Calculate x - y.  Revert on overflow.
      *
      * @param x signed 64.64-bit fixed point number
      * @param y signed 64.64-bit fixed point number
      * @return signed 64.64-bit fixed point number
      */
     function sub(int128 x, int128 y) internal pure returns (int128) {
         unchecked {
             int256 result = int256(x) - y;
             require(result >= MIN_64x64 && result <= MAX_64x64);
             return int128(result);
         }
     }
 
     /**
      * Calculate x * y rounding down.  Revert on overflow.
      *
      * @param x signed 64.64-bit fixed point number
      * @param y signed 64.64-bit fixed point number
      * @return signed 64.64-bit fixed point number
      */
     function mul(int128 x, int128 y) internal pure returns (int128) {
         unchecked {
             int256 result = (int256(x) * y) >> 64;
             require(result >= MIN_64x64 && result <= MAX_64x64);
             return int128(result);
         }
     }
 
     /**
      * Calculate x * y rounding towards zero, where x is signed 64.64 fixed point
      * number and y is signed 256-bit integer number.  Revert on overflow.
      *
      * @param x signed 64.64 fixed point number
      * @param y signed 256-bit integer number
      * @return signed 256-bit integer number
      */
     function muli(int128 x, int256 y) internal pure returns (int256) {
         unchecked {
             if (x == MIN_64x64) {
                 require(
                     y >= -0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF &&
                         y <= 0x1000000000000000000000000000000000000000000000000
                 );
                 return -y << 63;
             } else {
                 bool negativeResult = false;
                 if (x < 0) {
                     x = -x;
                     negativeResult = true;
                 }
                 if (y < 0) {
                     y = -y; // We rely on overflow behavior here
                     negativeResult = !negativeResult;
                 }
                 uint256 absoluteResult = mulu(x, uint256(y));
                 if (negativeResult) {
                     require(
                         absoluteResult <=
                             0x8000000000000000000000000000000000000000000000000000000000000000
                     );
                     return -int256(absoluteResult); // We rely on overflow behavior here
                 } else {
                     require(
                         absoluteResult <=
                             0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF
                     );
                     return int256(absoluteResult);
                 }
             }
         }
     }
 
     /**
      * Calculate x * y rounding down, where x is signed 64.64 fixed point number
      * and y is unsigned 256-bit integer number.  Revert on overflow.
      *
      * @param x signed 64.64 fixed point number
      * @param y unsigned 256-bit integer number
      * @return unsigned 256-bit integer number
      */
     function mulu(int128 x, uint256 y) internal pure returns (uint256) {
         unchecked {
             if (y == 0) return 0;
 
             require(x >= 0);
 
             uint256 lo = (uint256(int256(x)) *
                 (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)) >> 64;
             uint256 hi = uint256(int256(x)) * (y >> 128);
 
             require(hi <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
             hi <<= 64;
 
             require(
                 hi <=
                     0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF -
                         lo
             );
             return hi + lo;
         }
     }
 
     /**
      * Calculate x / y rounding towards zero.  Revert on overflow or when y is
      * zero.
      *
      * @param x signed 64.64-bit fixed point number
      * @param y signed 64.64-bit fixed point number
      * @return signed 64.64-bit fixed point number
      */
     function div(int128 x, int128 y) internal pure returns (int128) {
         unchecked {
             require(y != 0);
             int256 result = (int256(x) << 64) / y;
             require(result >= MIN_64x64 && result <= MAX_64x64);
             return int128(result);
         }
     }
 
     /**
      * Calculate x / y rounding towards zero, where x and y are signed 256-bit
      * integer numbers.  Revert on overflow or when y is zero.
      *
      * @param x signed 256-bit integer number
      * @param y signed 256-bit integer number
      * @return signed 64.64-bit fixed point number
      */
     function divi(int256 x, int256 y) internal pure returns (int128) {
         unchecked {
             require(y != 0);
 
             bool negativeResult = false;
             if (x < 0) {
                 x = -x; // We rely on overflow behavior here
                 negativeResult = true;
             }
             if (y < 0) {
                 y = -y; // We rely on overflow behavior here
                 negativeResult = !negativeResult;
             }
             uint128 absoluteResult = divuu(uint256(x), uint256(y));
             if (negativeResult) {
                 require(absoluteResult <= 0x80000000000000000000000000000000);
                 return -int128(absoluteResult); // We rely on overflow behavior here
             } else {
                 require(absoluteResult <= 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
                 return int128(absoluteResult); // We rely on overflow behavior here
             }
         }
     }
 
     /**
      * Calculate x / y rounding towards zero, where x and y are unsigned 256-bit
      * integer numbers.  Revert on overflow or when y is zero.
      *
      * @param x unsigned 256-bit integer number
      * @param y unsigned 256-bit integer number
      * @return signed 64.64-bit fixed point number
      */
     function divu(uint256 x, uint256 y) internal pure returns (int128) {
         unchecked {
             require(y != 0);
             uint128 result = divuu(x, y);
             require(result <= uint128(MAX_64x64));
             return int128(result);
         }
     }
 
     /**
      * Calculate -x.  Revert on overflow.
      *
      * @param x signed 64.64-bit fixed point number
      * @return signed 64.64-bit fixed point number
      */
     function neg(int128 x) internal pure returns (int128) {
         unchecked {
             require(x != MIN_64x64);
             return -x;
         }
     }
 
     /**
      * Calculate |x|.  Revert on overflow.
      *
      * @param x signed 64.64-bit fixed point number
      * @return signed 64.64-bit fixed point number
      */
     function abs(int128 x) internal pure returns (int128) {
         unchecked {
             require(x != MIN_64x64);
             return x < 0 ? -x : x;
         }
     }
 
     /**
      * Calculate 1 / x rounding towards zero.  Revert on overflow or when x is
      * zero.
      *
      * @param x signed 64.64-bit fixed point number
      * @return signed 64.64-bit fixed point number
      */
     function inv(int128 x) internal pure returns (int128) {
         unchecked {
             require(x != 0);
             int256 result = int256(0x100000000000000000000000000000000) / x;
             require(result >= MIN_64x64 && result <= MAX_64x64);
             return int128(result);
         }
     }
 
     /**
      * Calculate arithmetics average of x and y, i.e. (x + y) / 2 rounding down.
      *
      * @param x signed 64.64-bit fixed point number
      * @param y signed 64.64-bit fixed point number
      * @return signed 64.64-bit fixed point number
      */
     function avg(int128 x, int128 y) internal pure returns (int128) {
         unchecked {
             return int128((int256(x) + int256(y)) >> 1);
         }
     }
 
     /**
      * Calculate geometric average of x and y, i.e. sqrt (x * y) rounding down.
      * Revert on overflow or in case x * y is negative.
      *
      * @param x signed 64.64-bit fixed point number
      * @param y signed 64.64-bit fixed point number
      * @return signed 64.64-bit fixed point number
      */
     function gavg(int128 x, int128 y) internal pure returns (int128) {
         unchecked {
             int256 m = int256(x) * int256(y);
             require(m >= 0);
             require(
                 m <
                     0x4000000000000000000000000000000000000000000000000000000000000000
             );
             return int128(sqrtu(uint256(m)));
         }
     }
 
     /**
      * Calculate x^y assuming 0^0 is 1, where x is signed 64.64 fixed point number
      * and y is unsigned 256-bit integer number.  Revert on overflow.
      *
      * @param x signed 64.64-bit fixed point number
      * @param y uint256 value
      * @return signed 64.64-bit fixed point number
      */
     function pow(int128 x, uint256 y) internal pure returns (int128) {
         unchecked {
             bool negative = x < 0 && y & 1 == 1;
 
             uint256 absX = uint128(x < 0 ? -x : x);
             uint256 absResult;
             absResult = 0x100000000000000000000000000000000;
 
             if (absX <= 0x10000000000000000) {
                 absX <<= 63;
                 while (y != 0) {
                     if (y & 0x1 != 0) {
                         absResult = (absResult * absX) >> 127;
                     }
                     absX = (absX * absX) >> 127;
 
                     if (y & 0x2 != 0) {
                         absResult = (absResult * absX) >> 127;
                     }
                     absX = (absX * absX) >> 127;
 
                     if (y & 0x4 != 0) {
                         absResult = (absResult * absX) >> 127;
                     }
                     absX = (absX * absX) >> 127;
 
                     if (y & 0x8 != 0) {
                         absResult = (absResult * absX) >> 127;
                     }
                     absX = (absX * absX) >> 127;
 
                     y >>= 4;
                 }
 
                 absResult >>= 64;
             } else {
                 uint256 absXShift = 63;
                 if (absX < 0x1000000000000000000000000) {
                     absX <<= 32;
                     absXShift -= 32;
                 }
                 if (absX < 0x10000000000000000000000000000) {
                     absX <<= 16;
                     absXShift -= 16;
                 }
                 if (absX < 0x1000000000000000000000000000000) {
                     absX <<= 8;
                     absXShift -= 8;
                 }
                 if (absX < 0x10000000000000000000000000000000) {
                     absX <<= 4;
                     absXShift -= 4;
                 }
                 if (absX < 0x40000000000000000000000000000000) {
                     absX <<= 2;
                     absXShift -= 2;
                 }
                 if (absX < 0x80000000000000000000000000000000) {
                     absX <<= 1;
                     absXShift -= 1;
                 }
 
                 uint256 resultShift = 0;
                 while (y != 0) {
                     require(absXShift < 64);
 
                     if (y & 0x1 != 0) {
                         absResult = (absResult * absX) >> 127;
                         resultShift += absXShift;
                         if (absResult > 0x100000000000000000000000000000000) {
                             absResult >>= 1;
                             resultShift += 1;
                         }
                     }
                     absX = (absX * absX) >> 127;
                     absXShift <<= 1;
                     if (absX >= 0x100000000000000000000000000000000) {
                         absX >>= 1;
                         absXShift += 1;
                     }
 
                     y >>= 1;
                 }
 
                 require(resultShift < 64);
                 absResult >>= 64 - resultShift;
             }
             int256 result = negative ? -int256(absResult) : int256(absResult);
             require(result >= MIN_64x64 && result <= MAX_64x64);
             return int128(result);
         }
     }
 
     /**
      * Calculate sqrt (x) rounding down.  Revert if x < 0.
      *
      * @param x signed 64.64-bit fixed point number
      * @return signed 64.64-bit fixed point number
      */
     function sqrt(int128 x) internal pure returns (int128) {
         unchecked {
             require(x >= 0);
             return int128(sqrtu(uint256(int256(x)) << 64));
         }
     }
 
     /**
      * Calculate binary logarithm of x.  Revert if x <= 0.
      *
      * @param x signed 64.64-bit fixed point number
      * @return signed 64.64-bit fixed point number
      */
     function log_2(int128 x) internal pure returns (int128) {
         unchecked {
             require(x > 0);
 
             int256 msb = 0;
             int256 xc = x;
             if (xc >= 0x10000000000000000) {
                 xc >>= 64;
                 msb += 64;
             }
             if (xc >= 0x100000000) {
                 xc >>= 32;
                 msb += 32;
             }
             if (xc >= 0x10000) {
                 xc >>= 16;
                 msb += 16;
             }
             if (xc >= 0x100) {
                 xc >>= 8;
                 msb += 8;
             }
             if (xc >= 0x10) {
                 xc >>= 4;
                 msb += 4;
             }
             if (xc >= 0x4) {
                 xc >>= 2;
                 msb += 2;
             }
             if (xc >= 0x2) msb += 1; // No need to shift xc anymore
 
             int256 result = (msb - 64) << 64;
             uint256 ux = uint256(int256(x)) << uint256(127 - msb);
             for (int256 bit = 0x8000000000000000; bit > 0; bit >>= 1) {
                 ux *= ux;
                 uint256 b = ux >> 255;
                 ux >>= 127 + b;
                 result += bit * int256(b);
             }
 
             return int128(result);
         }
     }
 
     /**
      * Calculate natural logarithm of x.  Revert if x <= 0.
      *
      * @param x signed 64.64-bit fixed point number
      * @return signed 64.64-bit fixed point number
      */
     function ln(int128 x) internal pure returns (int128) {
         unchecked {
             require(x > 0);
 
             return
                 int128(
                     int256(
                         (uint256(int256(log_2(x))) *
                             0xB17217F7D1CF79ABC9E3B39803F2F6AF) >> 128
                     )
                 );
         }
     }
 
     /**
      * Calculate binary exponent of x.  Revert on overflow.
      *
      * @param x signed 64.64-bit fixed point number
      * @return signed 64.64-bit fixed point number
      */
     function exp_2(int128 x) internal pure returns (int128) {
         unchecked {
             require(x < 0x400000000000000000); // Overflow
 
             if (x < -0x400000000000000000) return 0; // Underflow
 
             uint256 result = 0x80000000000000000000000000000000;
 
             if (x & 0x8000000000000000 > 0)
                 result = (result * 0x16A09E667F3BCC908B2FB1366EA957D3E) >> 128;
             if (x & 0x4000000000000000 > 0)
                 result = (result * 0x1306FE0A31B7152DE8D5A46305C85EDEC) >> 128;
             if (x & 0x2000000000000000 > 0)
                 result = (result * 0x1172B83C7D517ADCDF7C8C50EB14A791F) >> 128;
             if (x & 0x1000000000000000 > 0)
                 result = (result * 0x10B5586CF9890F6298B92B71842A98363) >> 128;
             if (x & 0x800000000000000 > 0)
                 result = (result * 0x1059B0D31585743AE7C548EB68CA417FD) >> 128;
             if (x & 0x400000000000000 > 0)
                 result = (result * 0x102C9A3E778060EE6F7CACA4F7A29BDE8) >> 128;
             if (x & 0x200000000000000 > 0)
                 result = (result * 0x10163DA9FB33356D84A66AE336DCDFA3F) >> 128;
             if (x & 0x100000000000000 > 0)
                 result = (result * 0x100B1AFA5ABCBED6129AB13EC11DC9543) >> 128;
             if (x & 0x80000000000000 > 0)
                 result = (result * 0x10058C86DA1C09EA1FF19D294CF2F679B) >> 128;
             if (x & 0x40000000000000 > 0)
                 result = (result * 0x1002C605E2E8CEC506D21BFC89A23A00F) >> 128;
             if (x & 0x20000000000000 > 0)
                 result = (result * 0x100162F3904051FA128BCA9C55C31E5DF) >> 128;
             if (x & 0x10000000000000 > 0)
                 result = (result * 0x1000B175EFFDC76BA38E31671CA939725) >> 128;
             if (x & 0x8000000000000 > 0)
                 result = (result * 0x100058BA01FB9F96D6CACD4B180917C3D) >> 128;
             if (x & 0x4000000000000 > 0)
                 result = (result * 0x10002C5CC37DA9491D0985C348C68E7B3) >> 128;
             if (x & 0x2000000000000 > 0)
                 result = (result * 0x1000162E525EE054754457D5995292026) >> 128;
             if (x & 0x1000000000000 > 0)
                 result = (result * 0x10000B17255775C040618BF4A4ADE83FC) >> 128;
             if (x & 0x800000000000 > 0)
                 result = (result * 0x1000058B91B5BC9AE2EED81E9B7D4CFAB) >> 128;
             if (x & 0x400000000000 > 0)
                 result = (result * 0x100002C5C89D5EC6CA4D7C8ACC017B7C9) >> 128;
             if (x & 0x200000000000 > 0)
                 result = (result * 0x10000162E43F4F831060E02D839A9D16D) >> 128;
             if (x & 0x100000000000 > 0)
                 result = (result * 0x100000B1721BCFC99D9F890EA06911763) >> 128;
             if (x & 0x80000000000 > 0)
                 result = (result * 0x10000058B90CF1E6D97F9CA14DBCC1628) >> 128;
             if (x & 0x40000000000 > 0)
                 result = (result * 0x1000002C5C863B73F016468F6BAC5CA2B) >> 128;
             if (x & 0x20000000000 > 0)
                 result = (result * 0x100000162E430E5A18F6119E3C02282A5) >> 128;
             if (x & 0x10000000000 > 0)
                 result = (result * 0x1000000B1721835514B86E6D96EFD1BFE) >> 128;
             if (x & 0x8000000000 > 0)
                 result = (result * 0x100000058B90C0B48C6BE5DF846C5B2EF) >> 128;
             if (x & 0x4000000000 > 0)
                 result = (result * 0x10000002C5C8601CC6B9E94213C72737A) >> 128;
             if (x & 0x2000000000 > 0)
                 result = (result * 0x1000000162E42FFF037DF38AA2B219F06) >> 128;
             if (x & 0x1000000000 > 0)
                 result = (result * 0x10000000B17217FBA9C739AA5819F44F9) >> 128;
             if (x & 0x800000000 > 0)
                 result = (result * 0x1000000058B90BFCDEE5ACD3C1CEDC823) >> 128;
             if (x & 0x400000000 > 0)
                 result = (result * 0x100000002C5C85FE31F35A6A30DA1BE50) >> 128;
             if (x & 0x200000000 > 0)
                 result = (result * 0x10000000162E42FF0999CE3541B9FFFCF) >> 128;
             if (x & 0x100000000 > 0)
                 result = (result * 0x100000000B17217F80F4EF5AADDA45554) >> 128;
             if (x & 0x80000000 > 0)
                 result = (result * 0x10000000058B90BFBF8479BD5A81B51AD) >> 128;
             if (x & 0x40000000 > 0)
                 result = (result * 0x1000000002C5C85FDF84BD62AE30A74CC) >> 128;
             if (x & 0x20000000 > 0)
                 result = (result * 0x100000000162E42FEFB2FED257559BDAA) >> 128;
             if (x & 0x10000000 > 0)
                 result = (result * 0x1000000000B17217F7D5A7716BBA4A9AE) >> 128;
             if (x & 0x8000000 > 0)
                 result = (result * 0x100000000058B90BFBE9DDBAC5E109CCE) >> 128;
             if (x & 0x4000000 > 0)
                 result = (result * 0x10000000002C5C85FDF4B15DE6F17EB0D) >> 128;
             if (x & 0x2000000 > 0)
                 result = (result * 0x1000000000162E42FEFA494F1478FDE05) >> 128;
             if (x & 0x1000000 > 0)
                 result = (result * 0x10000000000B17217F7D20CF927C8E94C) >> 128;
             if (x & 0x800000 > 0)
                 result = (result * 0x1000000000058B90BFBE8F71CB4E4B33D) >> 128;
             if (x & 0x400000 > 0)
                 result = (result * 0x100000000002C5C85FDF477B662B26945) >> 128;
             if (x & 0x200000 > 0)
                 result = (result * 0x10000000000162E42FEFA3AE53369388C) >> 128;
             if (x & 0x100000 > 0)
                 result = (result * 0x100000000000B17217F7D1D351A389D40) >> 128;
             if (x & 0x80000 > 0)
                 result = (result * 0x10000000000058B90BFBE8E8B2D3D4EDE) >> 128;
             if (x & 0x40000 > 0)
                 result = (result * 0x1000000000002C5C85FDF4741BEA6E77E) >> 128;
             if (x & 0x20000 > 0)
                 result = (result * 0x100000000000162E42FEFA39FE95583C2) >> 128;
             if (x & 0x10000 > 0)
                 result = (result * 0x1000000000000B17217F7D1CFB72B45E1) >> 128;
             if (x & 0x8000 > 0)
                 result = (result * 0x100000000000058B90BFBE8E7CC35C3F0) >> 128;
             if (x & 0x4000 > 0)
                 result = (result * 0x10000000000002C5C85FDF473E242EA38) >> 128;
             if (x & 0x2000 > 0)
                 result = (result * 0x1000000000000162E42FEFA39F02B772C) >> 128;
             if (x & 0x1000 > 0)
                 result = (result * 0x10000000000000B17217F7D1CF7D83C1A) >> 128;
             if (x & 0x800 > 0)
                 result = (result * 0x1000000000000058B90BFBE8E7BDCBE2E) >> 128;
             if (x & 0x400 > 0)
                 result = (result * 0x100000000000002C5C85FDF473DEA871F) >> 128;
             if (x & 0x200 > 0)
                 result = (result * 0x10000000000000162E42FEFA39EF44D91) >> 128;
             if (x & 0x100 > 0)
                 result = (result * 0x100000000000000B17217F7D1CF79E949) >> 128;
             if (x & 0x80 > 0)
                 result = (result * 0x10000000000000058B90BFBE8E7BCE544) >> 128;
             if (x & 0x40 > 0)
                 result = (result * 0x1000000000000002C5C85FDF473DE6ECA) >> 128;
             if (x & 0x20 > 0)
                 result = (result * 0x100000000000000162E42FEFA39EF366F) >> 128;
             if (x & 0x10 > 0)
                 result = (result * 0x1000000000000000B17217F7D1CF79AFA) >> 128;
             if (x & 0x8 > 0)
                 result = (result * 0x100000000000000058B90BFBE8E7BCD6D) >> 128;
             if (x & 0x4 > 0)
                 result = (result * 0x10000000000000002C5C85FDF473DE6B2) >> 128;
             if (x & 0x2 > 0)
                 result = (result * 0x1000000000000000162E42FEFA39EF358) >> 128;
             if (x & 0x1 > 0)
                 result = (result * 0x10000000000000000B17217F7D1CF79AB) >> 128;
 
             result >>= uint256(int256(63 - (x >> 64)));
             require(result <= uint256(int256(MAX_64x64)));
 
             return int128(int256(result));
         }
     }
 
     /**
      * Calculate natural exponent of x.  Revert on overflow.
      *
      * @param x signed 64.64-bit fixed point number
      * @return signed 64.64-bit fixed point number
      */
     function exp(int128 x) internal pure returns (int128) {
         unchecked {
             require(x < 0x400000000000000000); // Overflow
 
             if (x < -0x400000000000000000) return 0; // Underflow
 
             return
                 exp_2(
                     int128(
                         (int256(x) * 0x171547652B82FE1777D0FFDA0D23A7D12) >> 128
                     )
                 );
         }
     }
 
     /**
      * Calculate x / y rounding towards zero, where x and y are unsigned 256-bit
      * integer numbers.  Revert on overflow or when y is zero.
      *
      * @param x unsigned 256-bit integer number
      * @param y unsigned 256-bit integer number
      * @return unsigned 64.64-bit fixed point number
      */
     function divuu(uint256 x, uint256 y) private pure returns (uint128) {
         unchecked {
             require(y != 0);
 
             uint256 result;
 
             if (x <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)
                 result = (x << 64) / y;
             else {
                 uint256 msb = 192;
                 uint256 xc = x >> 192;
                 if (xc >= 0x100000000) {
                     xc >>= 32;
                     msb += 32;
                 }
                 if (xc >= 0x10000) {
                     xc >>= 16;
                     msb += 16;
                 }
                 if (xc >= 0x100) {
                     xc >>= 8;
                     msb += 8;
                 }
                 if (xc >= 0x10) {
                     xc >>= 4;
                     msb += 4;
                 }
                 if (xc >= 0x4) {
                     xc >>= 2;
                     msb += 2;
                 }
                 if (xc >= 0x2) msb += 1; // No need to shift xc anymore
 
                 result = (x << (255 - msb)) / (((y - 1) >> (msb - 191)) + 1);
                 require(result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
 
                 uint256 hi = result * (y >> 128);
                 uint256 lo = result * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
 
                 uint256 xh = x >> 192;
                 uint256 xl = x << 64;
 
                 if (xl < lo) xh -= 1;
                 xl -= lo; // We rely on overflow behavior here
                 lo = hi << 128;
                 if (xl < lo) xh -= 1;
                 xl -= lo; // We rely on overflow behavior here
 
                 assert(xh == hi >> 128);
 
                 result += xl / y;
             }
 
             require(result <= 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF);
             return uint128(result);
         }
     }
 
     /**
      * Calculate sqrt (x) rounding down, where x is unsigned 256-bit integer
      * number.
      *
      * @param x unsigned 256-bit integer number
      * @return unsigned 128-bit integer number
      */
     function sqrtu(uint256 x) private pure returns (uint128) {
         unchecked {
             if (x == 0) return 0;
             else {
                 uint256 xx = x;
                 uint256 r = 1;
                 if (xx >= 0x100000000000000000000000000000000) {
                     xx >>= 128;
                     r <<= 64;
                 }
                 if (xx >= 0x10000000000000000) {
                     xx >>= 64;
                     r <<= 32;
                 }
                 if (xx >= 0x100000000) {
                     xx >>= 32;
                     r <<= 16;
                 }
                 if (xx >= 0x10000) {
                     xx >>= 16;
                     r <<= 8;
                 }
                 if (xx >= 0x100) {
                     xx >>= 8;
                     r <<= 4;
                 }
                 if (xx >= 0x10) {
                     xx >>= 4;
                     r <<= 2;
                 }
                 if (xx >= 0x8) {
                     r <<= 1;
                 }
                 r = (r + x / r) >> 1;
                 r = (r + x / r) >> 1;
                 r = (r + x / r) >> 1;
                 r = (r + x / r) >> 1;
                 r = (r + x / r) >> 1;
                 r = (r + x / r) >> 1;
                 r = (r + x / r) >> 1; // Seven iterations should be enough
                 uint256 r1 = x / r;
                 return uint128(r < r1 ? r : r1);
             }
         }
     }
 }
/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns the amount of tokens owned by `account`.
     */
    function balanceOf(address account) external view returns (uint256);

    /**
     * @dev Moves `amount` tokens from the caller's account to `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

    /**
     * @dev Moves `amount` tokens from `sender` to `recipient` using the
     * allowance mechanism. `amount` is then deducted from the caller's
     * allowance.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(address sender, address recipient, uint256 amount) external returns (bool);

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);
}

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        uint256 c = a + b;
        if (c < a) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b > a) return (false, 0);
        return (true, a - b);
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) return (true, 0);
        uint256 c = a * b;
        if (c / a != b) return (false, 0);
        return (true, c);
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a / b);
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        if (b == 0) return (false, 0);
        return (true, a % b);
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");
        return c;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b <= a, "SafeMath: subtraction overflow");
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        if (a == 0) return 0;
        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");
        return c;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: division by zero");
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        require(b > 0, "SafeMath: modulo by zero");
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b <= a, errorMessage);
        return a - b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryDiv}.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        return a % b;
    }
}

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data, string memory errorMessage) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

interface IUniswapPair {
    event Sync(uint112 reserve0, uint112 reserve1);

    function sync() external;
}

interface IRoseToken {
    function mint(address to, uint256 amount) external;

    function rebase(
        uint256 epoch,
        uint256 indexDelta,
        bool positive
    ) external returns (uint256);

    function totalSupply() external view returns (uint256);

    function transferUnderlying(address to, uint256 value)
        external
        returns (bool);

    function fragmentToRose(uint256 value) external view returns (uint256);

    function roseToFragment(uint256 rose) external view returns (uint256);

    function balanceOfUnderlying(address who) external view returns (uint256);
}

interface IReferral {
    /**
     * @dev Record referral.
     */
     function recordReferral(address user, address referrer) external;

     /**
      * @dev Record referral commission.
      */
     function recordReferralCommission(address referrer, uint256 commission) external;
 
     /**
      * @dev Get the referrer address that referred the user.
      */
     function getReferrer(address user) external view returns (address);
}

// Note that this pool has no minter key of ROSE (rewards).
// Instead, the governance will call ROSE distributeReward method and send reward to this pool at the beginning.
contract RoseGenesisRewardPool {
    using SafeMath for uint256;
    using SafeERC20 for IERC20;
    using SafeERC20 for IRoseToken;

    // governance
    address public operator;

    // Info of each user.
    struct UserInfo {
        uint256 amount; // How many tokens the user has provided.
        uint256 rewardDebt; // Reward debt. See explanation below.
    }

    // Info of each pool.
    struct PoolInfo {
        IERC20 token; // Address of LP token contract.
        uint256 allocPoint; // How many allocation points assigned to this pool. ROSE to distribute.
        uint256 lastRewardTime; // Last time that ROSE distribution occurs.
        uint256 accRosePerShare; // Accumulated ROSE per share, times 1e18. See below.
        bool isStarted; // if lastRewardBlock has passed
        uint256 depositFeeBP; // deposit fee
    }

    IReferral public referral;
    uint256 public referralCommissionRate = 20; // 2%

    IRoseToken public rose;
    // ROSE LP address
    IUniswapPair public roseLp;

    // Compound ratio which is 0.00008% per second = 7% per day (will be used to decrease supply)
    uint256 public compoundRatio = 8e11;
    // last rebase timestamp
    uint256 public lastRebaseTime;

    // Info of each pool.
    PoolInfo[] public poolInfo;

    // Info of each user that stakes LP tokens.
    mapping(uint256 => mapping(address => UserInfo)) public userInfo;

    // Total allocation points. Must be the sum of all allocation points in all pools.
    uint256 public totalAllocPoint = 0;

    // The time when ROSE mining starts.
    uint256 public poolStartTime;

    // The time when ROSE mining ends.
    uint256 public poolEndTime;

    uint256 public rosePerSecond = 0.11574074074 ether; // 20000 ROSE / (2day * 60min * 60s)
    uint256 public runningTime = 2 days; // 2 days
    uint256 public constant TOTAL_REWARDS = 20000 ether;
    address public feeWallet;

    event Deposit(address indexed user, uint256 indexed pid, uint256 amount);
    event Withdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event EmergencyWithdraw(address indexed user, uint256 indexed pid, uint256 amount);
    event RewardPaid(address indexed user, uint256 amount);
    event ReferralCommissionPaid(address indexed user, address indexed referrer, uint256 commissionAmount);

    constructor(
        IRoseToken _rose,
        uint256 _poolStartTime,
        IUniswapPair _roseLp,
        IReferral _referral
    ) {
        require(block.timestamp < _poolStartTime, "late");
        require(address(_rose) != address(0), "wrong rose address");
        rose = _rose;
        poolStartTime = _poolStartTime;
        poolEndTime = poolStartTime + runningTime;
        operator = msg.sender;
        feeWallet = msg.sender;
        roseLp = _roseLp;
        lastRebaseTime = poolStartTime;
        referral = _referral;
    }

    function pow(int128 x, uint256 n) public pure returns (int128 r) {
        r = ABDKMath64x64.fromUInt(1);
        while (n > 0) {
            if (n % 2 == 1) {
                r = ABDKMath64x64.mul(r, x);
                n -= 1;
            } else {
                x = ABDKMath64x64.mul(x, x);
                n /= 2;
            }
        }
    }

    function compound(
        uint256 principal,
        uint256 ratio,
        uint256 n
    ) public pure returns (uint256) {
        return
            ABDKMath64x64.mulu(
                pow(
                    ABDKMath64x64.add(
                        ABDKMath64x64.fromUInt(1),
                        ABDKMath64x64.divu(ratio, 10**18)
                    ),
                    n
                ),
                principal
            );
    }

    function poolLength() external view returns (uint256) {
        return poolInfo.length;
    }

    modifier onlyOperator() {
        require(operator == msg.sender, "RoseGenesisPool: caller is not the operator");
        _;
    }

    function checkPoolDuplicate(IERC20 _token) internal view {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            require(poolInfo[pid].token != _token, "RoseGenesisPool: existing pool?");
        }
    }

    // Add a new token to the pool. Can only be called by the owner.
    function add(
        uint256 _allocPoint,
        IERC20 _token,
        bool _withUpdate,
        uint256 _lastRewardTime,
        uint256 _depositFeeBP
    ) public onlyOperator {
        require(address(_token) != address(rose), "Deposit token can't be Rose");
        require(_depositFeeBP <= 10, "10 is 1%");
        checkPoolDuplicate(_token);
        if (_withUpdate) {
            massUpdatePools();
        }
        if (block.timestamp < poolStartTime) {
            // chef is sleeping
            if (_lastRewardTime == 0) {
                _lastRewardTime = poolStartTime;
            } else {
                if (_lastRewardTime < poolStartTime) {
                    _lastRewardTime = poolStartTime;
                }
            }
        } else {
            // chef is cooking
            if (_lastRewardTime == 0 || _lastRewardTime < block.timestamp) {
                _lastRewardTime = block.timestamp;
            }
        }
        bool _isStarted = (_lastRewardTime <= poolStartTime) || (_lastRewardTime <= block.timestamp);
        poolInfo.push(PoolInfo({token: _token, allocPoint: _allocPoint, lastRewardTime: _lastRewardTime, accRosePerShare: 0, isStarted: _isStarted, depositFeeBP: _depositFeeBP}));
        if (_isStarted) {
            totalAllocPoint = totalAllocPoint.add(_allocPoint);
        }
    }

    // Update the given pool's ROSE allocation point. Can only be called by the owner.
    function set(uint256 _pid, uint256 _allocPoint) public onlyOperator {
        massUpdatePools();
        PoolInfo storage pool = poolInfo[_pid];
        if (pool.isStarted) {
            totalAllocPoint = totalAllocPoint.sub(pool.allocPoint).add(_allocPoint);
        }
        pool.allocPoint = _allocPoint;
    }

    // Return accumulate rewards over the given _from to _to block.
    function getGeneratedReward(uint256 _fromTime, uint256 _toTime) public view returns (uint256) {
        if (_fromTime >= _toTime) return 0;
        if (_toTime >= poolEndTime) {
            if (_fromTime >= poolEndTime) return 0;
            if (_fromTime <= poolStartTime) return poolEndTime.sub(poolStartTime).mul(rosePerSecond);
            return poolEndTime.sub(_fromTime).mul(rosePerSecond);
        } else {
            if (_toTime <= poolStartTime) return 0;
            if (_fromTime <= poolStartTime) return _toTime.sub(poolStartTime).mul(rosePerSecond);
            return _toTime.sub(_fromTime).mul(rosePerSecond);
        }
    }

    // View function to see pending ROSE on frontend.
    function pendingRose(uint256 _pid, address _user) external view returns (uint256) {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_user];
        uint256 accRosePerShare = pool.accRosePerShare;
        uint256 tokenSupply = pool.token.balanceOf(address(this));
        if (block.timestamp > pool.lastRewardTime && tokenSupply != 0) {
            uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
            uint256 _roseReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
            accRosePerShare = accRosePerShare.add(_roseReward.mul(1e18).div(tokenSupply));
        }
        return user.amount.mul(accRosePerShare).div(1e18).sub(user.rewardDebt);
    }

    // Update reward variables for all pools. Be careful of gas spending!
    function massUpdatePools() public {
        uint256 length = poolInfo.length;
        for (uint256 pid = 0; pid < length; ++pid) {
            updatePool(pid);
        }
    }

    // Update reward variables of the given pool to be up-to-date.
    function updatePool(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        if (block.timestamp <= pool.lastRewardTime) {
            return;
        }
        uint256 tokenSupply = pool.token.balanceOf(address(this));
        if (tokenSupply == 0) {
            pool.lastRewardTime = block.timestamp;
            return;
        }
        if (!pool.isStarted) {
            pool.isStarted = true;
            totalAllocPoint = totalAllocPoint.add(pool.allocPoint);
        }
        if (totalAllocPoint > 0) {
            uint256 _generatedReward = getGeneratedReward(pool.lastRewardTime, block.timestamp);
            uint256 _roseReward = _generatedReward.mul(pool.allocPoint).div(totalAllocPoint);
            pool.accRosePerShare = pool.accRosePerShare.add(_roseReward.mul(1e18).div(tokenSupply));
        }
        pool.lastRewardTime = block.timestamp;
    }

    // Deposit LP tokens.
    function deposit(uint256 _pid, uint256 _amount, address _referrer) public {
        address _sender = msg.sender;
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_sender];
        updatePool(_pid);
        if (_amount > 0 && address(referral) != address(0) && _referrer != address(0) && _referrer != msg.sender) {
            referral.recordReferral(msg.sender, _referrer);
        }
        if (user.amount > 0) {
            claim(_pid);
        }
        if (_amount > 0) {
            pool.token.safeTransferFrom(_sender, address(this), _amount);
            if (pool.depositFeeBP != 0) {
                uint256 fee = _amount.mul(pool.depositFeeBP).div(1000);
                pool.token.safeTransfer(feeWallet, fee);
                _amount = _amount.sub(fee);
            }
            user.amount = user.amount.add(_amount);
        }
        user.rewardDebt = user.amount.mul(pool.accRosePerShare).div(1e18);
        emit Deposit(_sender, _pid, _amount);
    }

    // Withdraw LP tokens.
    function withdraw(uint256 _pid, uint256 _amount) public {
        address _sender = msg.sender;
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_sender];
        require(user.amount >= _amount, "withdraw: not good");
        updatePool(_pid);
        claim(_pid);
        if (_amount > 0) {
            user.amount = user.amount.sub(_amount);
            pool.token.safeTransfer(_sender, _amount);
        }
        user.rewardDebt = user.amount.mul(pool.accRosePerShare).div(1e18);
        emit Withdraw(_sender, _pid, _amount);
    }


    // claim and debase ROSE
    function claim(uint256 _pid) internal {
        address _sender = msg.sender;
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][_sender];
        uint256 _pending = user.amount.mul(pool.accRosePerShare).div(1e18).sub(user.rewardDebt);
        if (_pending > 0) {
            rose.mint(_sender, _pending);
            payReferralCommission(_sender, _pending);
            emit RewardPaid(_sender, _pending);
            if (lastRebaseTime != block.timestamp && block.timestamp < poolEndTime) {
                rose.rebase(
                    block.timestamp,
                    compound(1e18, compoundRatio, block.timestamp - lastRebaseTime) - 1e18,
                    false
                );
                lastRebaseTime = block.timestamp;
                roseLp.sync();
            }
        }
    }

    // Withdraw without caring about rewards. EMERGENCY ONLY.
    function emergencyWithdraw(uint256 _pid) public {
        PoolInfo storage pool = poolInfo[_pid];
        UserInfo storage user = userInfo[_pid][msg.sender];
        uint256 _amount = user.amount;
        user.amount = 0;
        user.rewardDebt = 0;
        pool.token.safeTransfer(msg.sender, _amount);
        emit EmergencyWithdraw(msg.sender, _pid, _amount);
    }

    function setOperator(address _operator) external onlyOperator {
        operator = _operator;
    }

    function setFeeWallet(address _feeWallet) external {
        require(msg.sender == feeWallet, "!feeWallet");
        require(_feeWallet != address(0), "zero");
        feeWallet = _feeWallet;
    }

    // Set referral contract address
    function setReferral(IReferral _referral) public onlyOperator {
        require(address(_referral) != address(0), "can't set 0 address");
        referral = _referral;
    }

    // Update referral commission rate by the operator
    function setReferralCommissionRate(uint256 _referralCommissionRate) public onlyOperator {
        require(_referralCommissionRate <= 1000, "max is 100%");
        referralCommissionRate = _referralCommissionRate;
    }

    // Pay referral commission to the referrer who referred this user.
    function payReferralCommission(address _user, uint256 _pending) internal {
        if (address(referral) != address(0) && referralCommissionRate > 0) {
            address referrer = referral.getReferrer(_user);
            uint256 commissionAmount = _pending.mul(referralCommissionRate).div(1000);

            if (referrer != address(0) && commissionAmount > 0) {
                rose.mint(referrer, commissionAmount);
                referral.recordReferralCommission(referrer, commissionAmount);
                emit ReferralCommissionPaid(_user, referrer, commissionAmount);
            }
        }
    }
}

[{"inputs":[{"internalType":"contract IRoseToken","name":"_rose","type":"address"},{"internalType":"uint256","name":"_poolStartTime","type":"uint256"},{"internalType":"contract IUniswapPair","name":"_roseLp","type":"address"},{"internalType":"contract IReferral","name":"_referral","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"EmergencyWithdraw","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"referrer","type":"address"},{"indexed":false,"internalType":"uint256","name":"commissionAmount","type":"uint256"}],"name":"ReferralCommissionPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RewardPaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"uint256","name":"pid","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[],"name":"TOTAL_REWARDS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_allocPoint","type":"uint256"},{"internalType":"contract IERC20","name":"_token","type":"address"},{"internalType":"bool","name":"_withUpdate","type":"bool"},{"internalType":"uint256","name":"_lastRewardTime","type":"uint256"},{"internalType":"uint256","name":"_depositFeeBP","type":"uint256"}],"name":"add","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"principal","type":"uint256"},{"internalType":"uint256","name":"ratio","type":"uint256"},{"internalType":"uint256","name":"n","type":"uint256"}],"name":"compound","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"compoundRatio","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"address","name":"_referrer","type":"address"}],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"emergencyWithdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"feeWallet","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_fromTime","type":"uint256"},{"internalType":"uint256","name":"_toTime","type":"uint256"}],"name":"getGeneratedReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastRebaseTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"massUpdatePools","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"operator","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"address","name":"_user","type":"address"}],"name":"pendingRose","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolEndTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"poolInfo","outputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"uint256","name":"allocPoint","type":"uint256"},{"internalType":"uint256","name":"lastRewardTime","type":"uint256"},{"internalType":"uint256","name":"accRosePerShare","type":"uint256"},{"internalType":"bool","name":"isStarted","type":"bool"},{"internalType":"uint256","name":"depositFeeBP","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"int128","name":"x","type":"int128"},{"internalType":"uint256","name":"n","type":"uint256"}],"name":"pow","outputs":[{"internalType":"int128","name":"r","type":"int128"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"referral","outputs":[{"internalType":"contract IReferral","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"referralCommissionRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rose","outputs":[{"internalType":"contract IRoseToken","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"roseLp","outputs":[{"internalType":"contract IUniswapPair","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rosePerSecond","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"runningTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_allocPoint","type":"uint256"}],"name":"set","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeWallet","type":"address"}],"name":"setFeeWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_operator","type":"address"}],"name":"setOperator","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IReferral","name":"_referral","type":"address"}],"name":"setReferral","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_referralCommissionRate","type":"uint256"}],"name":"setReferralCommissionRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalAllocPoint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"}],"name":"updatePool","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"}],"name":"userInfo","outputs":[{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_pid","type":"uint256"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

00000000000000000000000007d49375a3213ef25aaa47c97a2d23a754bb8f8a00000000000000000000000000000000000000000000000000000000641866e000000000000000000000000016084d8c82f2cebe5ca7967d5551805424526a68000000000000000000000000e6d3dca71257cbf2c04eefb0bd87eb1dd5396b84

-----Decoded View---------------
Arg [0] : _rose (address): 0x07d49375a3213ef25aaa47c97a2d23a754bb8f8a
Arg [1] : _poolStartTime (uint256): 1679320800
Arg [2] : _roseLp (address): 0x16084d8c82f2cebe5ca7967d5551805424526a68
Arg [3] : _referral (address): 0xe6d3dca71257cbf2c04eefb0bd87eb1dd5396b84

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 00000000000000000000000007d49375a3213ef25aaa47c97a2d23a754bb8f8a
Arg [1] : 00000000000000000000000000000000000000000000000000000000641866e0
Arg [2] : 00000000000000000000000016084d8c82f2cebe5ca7967d5551805424526a68
Arg [3] : 000000000000000000000000e6d3dca71257cbf2c04eefb0bd87eb1dd5396b84

55228:13562:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59022:95;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57103:51;;;:::i;56102:25::-;;;:::i;:::-;;;;;;;:::i;56515:26::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;;;;:::i;56760:34::-;;;:::i;56450:29::-;;;:::i;61069:321::-;;;;;;:::i;:::-;;:::i;:::-;;61467:653;;;;;;:::i;:::-;;:::i;56957:50::-;;;:::i;65309:595::-;;;;;;:::i;:::-;;:::i;63293:908::-;;;;;;:::i;:::-;;:::i;66885:377::-;;;;;;:::i;:::-;;:::i;55390:23::-;;;:::i;56845:28::-;;;:::i;59605:1368::-;;;;;;:::i;:::-;;:::i;63037:180::-;;;:::i;56922:26::-;;;:::i;64236:1037::-;;;;;;:::i;:::-;;:::i;67379:201::-;;;;;;:::i;:::-;;:::i;56599:64::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;:::i;57051:35::-;;;:::i;67626:176::-;;;;;;:::i;:::-;;:::i;58180:359::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;67270:101::-;;;;;;:::i;:::-;;:::i;56191:22::-;;;:::i;56378:35::-;;;:::i;56134:42::-;;;:::i;56244:26::-;;;:::i;67866:221::-;;;;;;:::i;:::-;;:::i;57161:24::-;;;:::i;58547:467::-;;;;;;:::i;:::-;;:::i;62183:771::-;;;;;;:::i;:::-;;:::i;59022:95::-;59094:8;:15;59022:95;:::o;57103:51::-;57143:11;57103:51;:::o;56102:25::-;;;-1:-1:-1;;;;;56102:25:0;;:::o;56515:26::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;56515:26:0;;;;-1:-1:-1;56515:26:0;;;;;;;;;;:::o;56760:34::-;;;;:::o;56450:29::-;;;;:::o;61069:321::-;59168:8;;-1:-1:-1;;;;;59168:8:0;59180:10;59168:22;59160:78;;;;-1:-1:-1;;;59160:78:0;;;;;;;:::i;:::-;;;;;;;;;61148:17:::1;:15;:17::i;:::-;61176:21;61200:8;61209:4;61200:14;;;;;;-1:-1:-1::0;;;61200:14:0::1;;;;;;;;;;::::0;;;::::1;::::0;;;::::1;::::0;;::::1;;61229;::::0;::::1;::::0;61200;;-1:-1:-1;61229:14:0::1;;61225:118;;;61278:53;61319:11;61278:36;61298:4;:15;;;61278;;:19;;:36;;;;:::i;:::-;:40:::0;::::1;:53::i;:::-;61260:15;:71:::0;61225:118:::1;61353:15;;:29:::0;-1:-1:-1;61069:321:0:o;61467:653::-;61552:7;61589;61576:9;:20;61572:34;;-1:-1:-1;61605:1:0;61598:8;;61572:34;61632:11;;61621:7;:22;61617:496;;61677:11;;61664:9;:24;61660:38;;-1:-1:-1;61697:1:0;61690:8;;61660:38;61730:13;;61717:9;:26;61713:88;;61752:49;61787:13;;61752:30;61768:13;;61752:11;;:15;;:30;;;;:::i;:::-;:34;;:49::i;:::-;61745:56;;;;61713:88;61823:45;61854:13;;61823:26;61839:9;61823:11;;:15;;:26;;;;:::i;61617:496::-;61916:13;;61905:7;:24;61901:38;;-1:-1:-1;61938:1:0;61931:8;;61901:38;61971:13;;61958:9;:26;61954:84;;61993:45;62024:13;;61993:26;62005:13;;61993:7;:11;;:26;;;;:::i;61954:84::-;62087:13;;62060:41;;:22;:7;62072:9;62060:11;:22::i;61617:496::-;61467:653;;;;:::o;56957:50::-;;;;:::o;65309:595::-;65376:15;65394:10;65376:28;;65415:21;65439:8;65448:4;65439:14;;;;;;-1:-1:-1;;;65439:14:0;;;;;;;;;;;;;;;;;65488;;;:8;:14;;;;;;-1:-1:-1;;;;;65488:23:0;;;;;;;;;65530:11;;65439:14;;;;;;;;-1:-1:-1;65530:22:0;-1:-1:-1;65530:22:0;65522:53;;;;-1:-1:-1;;;65522:53:0;;;;;;;:::i;:::-;65586:16;65597:4;65586:10;:16::i;:::-;65613:11;65619:4;65613:5;:11::i;:::-;65639;;65635:138;;65681:11;;:24;;65697:7;65681:15;:24::i;:::-;65667:38;;65720:10;;:41;;-1:-1:-1;;;;;65720:10:0;65744:7;65753;65720:23;:41::i;:::-;65817:20;;;;65801:11;;:47;;65843:4;;65801:37;;:15;:37::i;:::-;:41;;:47::i;:::-;65783:4;:15;;:65;;;;65882:4;65873:7;-1:-1:-1;;;;;65864:32:0;;65888:7;65864:32;;;;;;:::i;:::-;;;;;;;;65309:595;;;;;:::o;63293:908::-;63345:21;63369:8;63378:4;63369:14;;;;;;-1:-1:-1;;;63369:14:0;;;;;;;;;;;;;;;;;;;63345:38;;63417:4;:19;;;63398:15;:38;63394:77;;63453:7;;;63394:77;63503:10;;:35;;-1:-1:-1;;;63503:35:0;;63481:19;;-1:-1:-1;;;;;63503:10:0;;:20;;:35;;63532:4;;63503:35;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;63481:57;-1:-1:-1;63553:16:0;63549:107;;-1:-1:-1;63608:15:0;63586:19;;;;:37;63638:7;;63549:107;63671:14;;;;;;63666:138;;63702:14;;;:21;;-1:-1:-1;;63702:21:0;63719:4;63702:21;;;;;;63776:15;;;63756;;:36;;:19;:36::i;:::-;63738:15;:54;63666:138;63818:15;;:19;63814:332;;63854:24;63881:56;63900:4;:19;;;63921:15;63881:18;:56::i;:::-;63854:83;;63952:19;63974:58;64016:15;;63974:37;63995:4;:15;;;63974:16;:20;;:37;;;;:::i;:58::-;63952:80;-1:-1:-1;64070:64:0;64095:38;64121:11;64095:21;63952:80;64111:4;64095:15;:21::i;:38::-;64070:20;;;;;:24;:64::i;:::-;64047:20;;;:87;-1:-1:-1;;63814:332:0;-1:-1:-1;64178:15:0;64156:19;;;;:37;63293:908;;:::o;66885:377::-;66944:21;66968:8;66977:4;66968:14;;;;;;-1:-1:-1;;;66968:14:0;;;;;;;;;;;;;;;;;67017;;;:8;:14;;;;;;67032:10;67017:26;;;;;;;67072:11;;67094:15;;;-1:-1:-1;67120:15:0;;:19;;;;66968:14;;;;;67150:10;;66968:14;;-1:-1:-1;67017:26:0;;67072:11;67150:44;;-1:-1:-1;;;;;67150:10:0;;;;;67072:11;67150:23;:44::i;:::-;67240:4;67228:10;-1:-1:-1;;;;;67210:44:0;;67246:7;67210:44;;;;;;:::i;:::-;;;;;;;;66885:377;;;;:::o;55390:23::-;;;-1:-1:-1;;;;;55390:23:0;;:::o;56845:28::-;;;;:::o;59605:1368::-;59168:8;;-1:-1:-1;;;;;59168:8:0;59180:10;59168:22;59160:78;;;;-1:-1:-1;;;59160:78:0;;;;;;;:::i;:::-;59838:4:::1;::::0;-1:-1:-1;;;;;59811:32:0;;::::1;59838:4:::0;::::1;59811:32;;59803:72;;;;-1:-1:-1::0;;;59803:72:0::1;;;;;;;:::i;:::-;59911:2;59894:13;:19;;59886:40;;;;-1:-1:-1::0;;;59886:40:0::1;;;;;;;:::i;:::-;59937:26;59956:6;59937:18;:26::i;:::-;59978:11;59974:61;;;60006:17;:15;:17::i;:::-;60067:13;;60049:15;:31;60045:534;;;60134:20:::0;60130:243:::1;;60193:13;;60175:31;;60130:243;;;60269:13;;60251:15;:31;60247:111;;;60325:13;;60307:31;;60247:111;60045:534;;;60441:20:::0;;;:57:::1;;;60483:15;60465;:33;60441:57;60437:131;;;60537:15;60519:33;;60437:131;60589:15;60627:13;;60608:15;:32;;60607:74;;;;60665:15;60646;:34;;60607:74;60706:155;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;60706:155:0;;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;-1:-1:-1;60706:155:0;;;;;;;::::1;::::0;::::1;::::0;;;;;;;;;;;;60692:8:::1;:170:::0;;::::1;::::0;::::1;::::0;;;;;;;::::1;::::0;;::::1;::::0;;::::1;::::0;;-1:-1:-1;;;;;;60692:170:0::1;::::0;;;::::1;;::::0;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;60692:170:0::1;::::0;::::1;;::::0;;;::::1;::::0;;;;;;;;;60706:155;;-1:-1:-1;60873:93:0::1;;60922:15;::::0;:32:::1;::::0;60942:11;60922:19:::1;:32::i;:::-;60904:15;:50:::0;60873:93:::1;59249:1;59605:1368:::0;;;;;:::o;63037:180::-;63099:8;:15;63082:14;63125:85;63153:6;63147:3;:12;63125:85;;;63183:15;63194:3;63183:10;:15::i;:::-;63161:5;;;:::i;:::-;;;63125:85;;;;63037:180;:::o;56922:26::-;;;;:::o;64236:1037::-;64321:15;64339:10;64321:28;;64360:21;64384:8;64393:4;64384:14;;;;;;-1:-1:-1;;;64384:14:0;;;;;;;;;;;;;;;;;64433;;;:8;:14;;;;;;-1:-1:-1;;;;;64433:23:0;;;;;;;;;64384:14;;;;;;;;-1:-1:-1;64467:16:0;64442:4;64467:10;:16::i;:::-;64508:1;64498:7;:11;:46;;;;-1:-1:-1;64521:8:0;;-1:-1:-1;;;;;64521:8:0;64513:31;;64498:46;:73;;;;-1:-1:-1;;;;;;64548:23:0;;;;64498:73;:100;;;;-1:-1:-1;;;;;;64575:23:0;;64588:10;64575:23;;64498:100;64494:179;;;64615:8;;:46;;-1:-1:-1;;;64615:46:0;;-1:-1:-1;;;;;64615:8:0;;;;:23;;:46;;64639:10;;64651:9;;64615:46;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64494:179;64687:11;;:15;64683:59;;64719:11;64725:4;64719:5;:11::i;:::-;64756;;64752:391;;64784:10;;:60;;-1:-1:-1;;;;;64784:10:0;64812:7;64829:4;64836:7;64784:27;:60::i;:::-;64863:17;;;;:22;64859:220;;64906:11;64920:40;64955:4;64920:30;64932:4;:17;;;64920:7;:11;;:30;;;;:::i;:40::-;65003:9;;64979:10;;64906:54;;-1:-1:-1;64979:39:0;;-1:-1:-1;;;;;64979:10:0;;;;65003:9;64906:54;64979:23;:39::i;:::-;65047:16;:7;65059:3;65047:11;:16::i;:::-;65037:26;;64859:220;;65107:11;;:24;;65123:7;65107:15;:24::i;:::-;65093:38;;64752:391;65187:20;;;;65171:11;;:47;;65213:4;;65171:37;;:15;:37::i;:47::-;65153:4;:15;;:65;;;;65251:4;65242:7;-1:-1:-1;;;;;65234:31:0;;65257:7;65234:31;;;;;;:::i;:::-;;;;;;;;64236:1037;;;;;;:::o;67379:201::-;67463:9;;-1:-1:-1;;;;;67463:9:0;67449:10;:23;67441:46;;;;-1:-1:-1;;;67441:46:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;67506:24:0;;67498:41;;;;-1:-1:-1;;;67498:41:0;;;;;;;:::i;:::-;67550:9;:22;;-1:-1:-1;;;;;;67550:22:0;-1:-1:-1;;;;;67550:22:0;;;;;;;;;;67379:201::o;56599:64::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;57051:35::-;;;;:::o;67626:176::-;59168:8;;-1:-1:-1;;;;;59168:8:0;59180:10;59168:22;59160:78;;;;-1:-1:-1;;;59160:78:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;67707:32:0;::::1;67699:64;;;;-1:-1:-1::0;;;67699:64:0::1;;;;;;;:::i;:::-;67774:8;:20:::0;;-1:-1:-1;;;;;;67774:20:0::1;-1:-1:-1::0;;;;;67774:20:0;;;::::1;::::0;;;::::1;::::0;;67626:176::o;58180:359::-;58235:8;58260:25;58283:1;58260:22;:25::i;:::-;58256:29;;58296:236;58303:5;;58296:236;;58329:5;58333:1;58329;:5;:::i;:::-;58338:1;58329:10;58325:196;;;58364:23;58382:1;58385;58364:17;:23::i;:::-;58360:27;-1:-1:-1;58406:6:0;58411:1;58406:6;;:::i;:::-;;;58325:196;;;58457:23;58475:1;58478;58457:17;:23::i;:::-;58453:27;-1:-1:-1;58499:6:0;58504:1;58499:6;;:::i;:::-;;;58325:196;58296:236;;67270:101;59168:8;;-1:-1:-1;;;;;59168:8:0;59180:10;59168:22;59160:78;;;;-1:-1:-1;;;59160:78:0;;;;;;;:::i;:::-;67343:8:::1;:20:::0;;-1:-1:-1;;;;;;67343:20:0::1;-1:-1:-1::0;;;;;67343:20:0;;;::::1;::::0;;;::::1;::::0;;67270:101::o;56191:22::-;;;-1:-1:-1;;;;;56191:22:0;;:::o;56378:35::-;;;;:::o;56134:42::-;;;;:::o;56244:26::-;;;-1:-1:-1;;;;;56244:26:0;;:::o;67866:221::-;59168:8;;-1:-1:-1;;;;;59168:8:0;59180:10;59168:22;59160:78;;;;-1:-1:-1;;;59160:78:0;;;;;;;:::i;:::-;68000:4:::1;67973:23;:31;;67965:55;;;;-1:-1:-1::0;;;67965:55:0::1;;;;;;;:::i;:::-;68031:22;:48:::0;67866:221::o;57161:24::-;;;-1:-1:-1;;;;;57161:24:0;;:::o;58547:467::-;58665:7;58705:301;58742:221;58768:152;58812:25;58835:1;58812:22;:25::i;:::-;58864:33;58883:5;58890:6;58864:18;:33::i;:::-;58768:17;:152::i;:::-;58943:1;58742:3;:221::i;:::-;58982:9;58705:18;:301::i;:::-;58685:321;;58547:467;;;;;;:::o;62183:771::-;62256:7;62276:21;62300:8;62309:4;62300:14;;;;;;-1:-1:-1;;;62300:14:0;;;;;;;;;;;;;;;;;62349;;;:8;:14;;;;;;-1:-1:-1;;;;;62349:21:0;;;;;;;;;;62407:20;62300:14;;;;;;;62407:20;;;;62460:10;;:35;;-1:-1:-1;;;62460:35:0;;62300:14;;-1:-1:-1;62349:21:0;;62407:20;;62300:14;;62460:10;;:20;;:35;;62489:4;;62460:35;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;62438:57;;62528:4;:19;;;62510:15;:37;:57;;;;-1:-1:-1;62551:16:0;;;62510:57;62506:360;;;62584:24;62611:56;62630:4;:19;;;62651:15;62611:18;:56::i;:::-;62584:83;;62682:19;62704:58;62746:15;;62704:37;62725:4;:15;;;62704:16;:20;;:37;;;;:::i;:58::-;62682:80;-1:-1:-1;62795:59:0;62815:38;62841:11;62815:21;62682:80;62831:4;62815:15;:21::i;:38::-;62795:15;;:19;:59::i;:::-;62777:77;;62506:360;;;62883:63;62930:4;:15;;;62883:42;62920:4;62883:32;62899:15;62883:4;:11;;;:15;;:32;;;;:::i;:42::-;:46;;:63::i;:::-;62876:70;62183:771;-1:-1:-1;;;;;;;62183:771:0:o;38071:158::-;38129:7;38162:1;38157;:6;;38149:49;;;;-1:-1:-1;;;38149:49:0;;;;;;;:::i;:::-;38216:5;38220:1;38216;:5;:::i;37609:179::-;37667:7;;37699:5;37703:1;37699;:5;:::i;:::-;37687:17;;37728:1;37723;:6;;37715:46;;;;-1:-1:-1;;;37715:46:0;;;;;;;:::i;38488:220::-;38546:7;38570:6;38566:20;;-1:-1:-1;38585:1:0;38578:8;;38566:20;38597:9;38609:5;38613:1;38609;:5;:::i;:::-;38597:17;-1:-1:-1;38642:1:0;38633:5;38637:1;38597:17;38633:5;:::i;:::-;:10;38625:56;;;;-1:-1:-1;;;38625:56:0;;;;;;;:::i;65944:870::-;65993:15;66011:10;65993:28;;66032:21;66056:8;66065:4;66056:14;;;;;;-1:-1:-1;;;66056:14:0;;;;;;;;;;;;;;;;;66105;;;:8;:14;;;;;;-1:-1:-1;;;;;66105:23:0;;;;;;;;;;66210:15;;;;66174:20;66056:14;;;;;;;66174:20;;;;66158:11;;66056:14;;-1:-1:-1;66105:23:0;;66056:14;66158:68;;66210:15;66158:47;;66200:4;;66158:37;;:11;:15;:37::i;:68::-;66139:87;-1:-1:-1;66241:12:0;;66237:570;;66270:4;;:28;;-1:-1:-1;;;66270:28:0;;-1:-1:-1;;;;;66270:4:0;;;;:9;;:28;;66280:7;;66289:8;;66270:28;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66313:40;66335:7;66344:8;66313:21;:40::i;:::-;66384:7;-1:-1:-1;;;;;66373:29:0;;66393:8;66373:29;;;;;;:::i;:::-;;;;;;;;66439:15;66421:14;;:33;;:66;;;;;66476:11;;66458:15;:29;66421:66;66417:379;;;66508:4;;66595:13;;66628:14;;-1:-1:-1;;;;;66508:4:0;;;;:11;;66542:15;;66646:4;;66580:63;;66646:4;;66595:13;66610:32;;66542:15;66610:32;:::i;66580:63::-;:70;;;;:::i;:::-;66673:5;66508:189;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;66733:15:0;66716:14;:32;66767:6;;;:13;;;-1:-1:-1;;;;;;66767:13:0;;;;-1:-1:-1;;;;;66767:6:0;;;;:11;;:13;;;;:6;;:13;;;;;;:6;;:13;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66417:379;65944:870;;;;;:::o;50775:177::-;50858:86;50878:5;50908:23;;;50933:2;50937:5;50885:58;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;50885:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;50885:58:0;-1:-1:-1;;;;;;50885:58:0;;;;;;;;;;50858:19;:86::i;:::-;50775:177;;;:::o;39186:153::-;39244:7;39276:1;39272;:5;39264:44;;;;-1:-1:-1;;;39264:44:0;;;;;;;:::i;:::-;39326:5;39330:1;39326;:5;:::i;59266:261::-;59351:8;:15;59334:14;59377:143;59405:6;59399:3;:12;59377:143;;;59466:6;-1:-1:-1;;;;;59443:29:0;:8;59452:3;59443:13;;;;;;-1:-1:-1;;;59443:13:0;;;;;;;;;;;;;;;;;;;;;;:19;-1:-1:-1;;;;;59443:19:0;:29;;59435:73;;;;-1:-1:-1;;;59435:73:0;;;;;;;:::i;:::-;59413:5;;;:::i;:::-;;;59377:143;;50960:205;51061:96;51081:5;51111:27;;;51140:4;51146:2;51150:5;51088:68;;;;;;;;;;:::i;51061:96::-;50960:205;;;;:::o;2005:197::-;2057:6;2116:18;2111:1;:23;;2103:32;;;;;;-1:-1:-1;2177:2:0;2172:7;;2005:197::o;4835:264::-;4891:6;4954:13;:9;;;:13;;;;;4972:2;4953:21;-1:-1:-1;;;;;;4998:19:0;;;;;:42;;-1:-1:-1;;;;;;5021:19:0;;;4998:42;4990:51;;;;;10174:275;10233:6;10287;10279:15;;;;;;10310:14;10327:11;10333:1;10336;10327:5;:11::i;:::-;10310:28;-1:-1:-1;;;;;;;;;;;10362:28:0;;;;10354:37;;;;;3815:256;3871:6;3933:13;:9;;;:13;;;;;-1:-1:-1;;;;;;3970:19:0;;;;;:42;;-1:-1:-1;;;;;;3993:19:0;;;3962:51;;;;;7254:685;7312:7;7363:6;7359:20;;-1:-1:-1;7378:1:0;7371:8;;7359:20;7411:1;7406;:6;;;;7398:15;;;;;;7454:9;;;;-1:-1:-1;;;;;7486:38:0;;7446:79;;7530:2;7445:87;;7588:3;7583:8;;;7561:31;-1:-1:-1;;;;;7619:56:0;;;7611:65;;;;;;7699:2;7692:9;7775:97;;7747:125;;;7720:168;;;;;;7911:7;;7254:685;-1:-1:-1;;;7254:685:0:o;68167:620::-;68263:8;;-1:-1:-1;;;;;68263:8:0;68255:31;;;;:61;;;68315:1;68290:22;;:26;68255:61;68251:529;;;68352:8;;:27;;-1:-1:-1;;;68352:27:0;;68333:16;;-1:-1:-1;;;;;68352:8:0;;:20;;:27;;68373:5;;68352:27;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;68333:46;;68394:24;68421:46;68462:4;68421:36;68434:22;;68421:8;:12;;:36;;;;:::i;:46::-;68394:73;-1:-1:-1;;;;;;68488:22:0;;;;;;:46;;;68533:1;68514:16;:20;68488:46;68484:285;;;68555:4;;:37;;-1:-1:-1;;;68555:37:0;;-1:-1:-1;;;;;68555:4:0;;;;:9;;:37;;68565:8;;68575:16;;68555:37;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;68611:8:0;;:61;;-1:-1:-1;;;68611:61:0;;-1:-1:-1;;;;;68611:8:0;;;;-1:-1:-1;68611:33:0;;-1:-1:-1;68611:61:0;;68645:8;;68655:16;;68611:61;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68726:8;-1:-1:-1;;;;;68696:57:0;68719:5;-1:-1:-1;;;;;68696:57:0;;68736:16;68696:57;;;;;;:::i;53080:761::-;53504:23;53530:69;53558:4;53530:69;;;;;;;;;;;;;;;;;53538:5;-1:-1:-1;;;;;53530:27:0;;;:69;;;;;:::i;:::-;53614:17;;53504:95;;-1:-1:-1;53614:21:0;53610:224;;53756:10;53745:30;;;;;;;;;;;;:::i;:::-;53737:85;;;;-1:-1:-1;;;53737:85:0;;;;;;;:::i;28524:1917::-;28583:7;28638:6;28630:15;;;;;;28664:14;-1:-1:-1;;;;;28701:1:0;:55;28697:1614;;28797:1;28791:2;28786:1;:7;;28785:13;;;-1:-1:-1;;;28785:13:0;;;;;;;;;;28776:22;;28697:1614;;;28853:3;28889:8;;;28927:11;28921:17;;28917:110;;28971:2;28997:9;;;;28964;28917:110;29056:7;29050:2;:13;29046:106;;29096:2;29122:9;;;;29089;29046:106;29181:5;29175:2;:11;29171:102;;29219:1;29244:8;;;;29212;29171:102;29302:4;29296:2;:10;29292:101;;29339:1;29364:8;;;;29332;29292:101;29422:3;29416:2;:9;29412:100;;29458:1;29483:8;;;;29451;29412:100;29541:3;29535:2;:9;29531:23;;29553:1;29546:8;;;;29531:23;29658:3;29652;:9;29645:1;29641;:5;29640:22;;29666:1;29639:28;29630:3;29624;:9;29618:1;:16;;29617:51;;;-1:-1:-1;;;29617:51:0;;;;;;;;;;29608:60;;-1:-1:-1;;;;;29696:6:0;:44;;29688:53;;;;;;29792:3;29787:8;;;29777:19;;-1:-1:-1;;;;;29839:38:0;;29829:49;;29919:3;29914:8;;;29960:2;29955:7;;;29989;;;29985:20;;;30004:1;29998:7;;;;29985:20;30101:3;30095:9;;;;30025:8;;30128:7;;;30124:20;;;30143:1;30137:7;;;;30124:20;30164:8;;;30251:3;30245:9;;;30239:15;;30232:23;;-1:-1:-1;;;30232:23:0;;;;;;;;;30293:1;30288:2;:6;;;-1:-1:-1;;;30288:6:0;;;;;;;;;;30278:16;;;;28697:1614;;;;;;;-1:-1:-1;;;;;30337:6:0;:44;;30329:53;;;;;45875:195;45978:12;46010:52;46032:6;46040:4;46046:1;46049:12;45978;47179:18;47190:6;47179:10;:18::i;:::-;47171:60;;;;-1:-1:-1;;;47171:60:0;;;;;;;:::i;:::-;47305:12;47319:23;47346:6;-1:-1:-1;;;;;47346:11:0;47366:5;47374:4;47346:33;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47304:75;;;;47397:52;47415:7;47424:10;47436:12;47397:17;:52::i;42957:422::-;43324:20;43363:8;;;42957:422::o;49467:742::-;49582:12;49611:7;49607:595;;;-1:-1:-1;49642:10:0;49635:17;;49607:595;49756:17;;:21;49752:439;;50019:10;50013:17;50080:15;50067:10;50063:2;50059:19;50052:44;49967:148;50162:12;50155:20;;-1:-1:-1;;;50155:20:0;;;;;;;;:::i;14:259:1:-;;126:2;114:9;105:7;101:23;97:32;94:2;;;147:6;139;132:22;94:2;191:9;178:23;210:33;237:5;210:33;:::i;278:263::-;;401:2;389:9;380:7;376:23;372:32;369:2;;;422:6;414;407:22;369:2;459:9;453:16;478:33;505:5;478:33;:::i;546:257::-;;666:2;654:9;645:7;641:23;637:32;634:2;;;687:6;679;672:22;634:2;724:9;718:16;743:30;767:5;743:30;:::i;1090:363::-;;;1218:2;1206:9;1197:7;1193:23;1189:32;1186:2;;;1239:6;1231;1224:22;1186:2;1283:9;1270:23;1337:5;1333:2;1322:21;1315:5;1312:32;1302:2;;1363:6;1355;1348:22;1302:2;1391:5;1443:2;1428:18;;;;1415:32;;-1:-1:-1;;;1176:277:1:o;1458:190::-;;1570:2;1558:9;1549:7;1545:23;1541:32;1538:2;;;1591:6;1583;1576:22;1538:2;-1:-1:-1;1619:23:1;;1528:120;-1:-1:-1;1528:120:1:o;1653:194::-;;1776:2;1764:9;1755:7;1751:23;1747:32;1744:2;;;1797:6;1789;1782:22;1744:2;-1:-1:-1;1825:16:1;;1734:113;-1:-1:-1;1734:113:1:o;1852:327::-;;;1981:2;1969:9;1960:7;1956:23;1952:32;1949:2;;;2002:6;1994;1987:22;1949:2;2043:9;2030:23;2020:33;;2103:2;2092:9;2088:18;2075:32;2116:33;2143:5;2116:33;:::i;:::-;2168:5;2158:15;;;1939:240;;;;;:::o;2184:617::-;;;;;;2376:3;2364:9;2355:7;2351:23;2347:33;2344:2;;;2398:6;2390;2383:22;2344:2;2439:9;2426:23;2416:33;;2499:2;2488:9;2484:18;2471:32;2512:33;2539:5;2512:33;:::i;:::-;2564:5;-1:-1:-1;2621:2:1;2606:18;;2593:32;2634;2593;2634;:::i;:::-;2334:467;;;;-1:-1:-1;2685:7:1;;2739:2;2724:18;;2711:32;;-1:-1:-1;2790:3:1;2775:19;2762:33;;2334:467;-1:-1:-1;;2334:467:1:o;2806:258::-;;;2935:2;2923:9;2914:7;2910:23;2906:32;2903:2;;;2956:6;2948;2941:22;2903:2;-1:-1:-1;;2984:23:1;;;3054:2;3039:18;;;3026:32;;-1:-1:-1;2893:171:1:o;3069:395::-;;;;3215:2;3203:9;3194:7;3190:23;3186:32;3183:2;;;3236:6;3228;3221:22;3183:2;3277:9;3264:23;3254:33;;3334:2;3323:9;3319:18;3306:32;3296:42;;3388:2;3377:9;3373:18;3360:32;3401:33;3428:5;3401:33;:::i;:::-;3453:5;3443:15;;;3173:291;;;;;:::o;3469:326::-;;;;3615:2;3603:9;3594:7;3590:23;3586:32;3583:2;;;3636:6;3628;3621:22;3583:2;-1:-1:-1;;3664:23:1;;;3734:2;3719:18;;3706:32;;-1:-1:-1;3785:2:1;3770:18;;;3757:32;;3573:222;-1:-1:-1;3573:222:1:o;3800:274::-;;3967:6;3961:13;3983:53;4029:6;4024:3;4017:4;4009:6;4005:17;3983:53;:::i;:::-;4052:16;;;;;3937:137;-1:-1:-1;;3937:137:1:o;4079:203::-;-1:-1:-1;;;;;4243:32:1;;;;4225:51;;4213:2;4198:18;;4180:102::o;4287:304::-;-1:-1:-1;;;;;4517:15:1;;;4499:34;;4569:15;;4564:2;4549:18;;4542:43;4449:2;4434:18;;4416:175::o;4596:375::-;-1:-1:-1;;;;;4854:15:1;;;4836:34;;4906:15;;;;4901:2;4886:18;;4879:43;4953:2;4938:18;;4931:34;;;;4786:2;4771:18;;4753:218::o;4976:274::-;-1:-1:-1;;;;;5168:32:1;;;;5150:51;;5232:2;5217:18;;5210:34;5138:2;5123:18;;5105:145::o;5255:586::-;-1:-1:-1;;;;;5569:32:1;;;;5551:51;;5633:2;5618:18;;5611:34;;;;5676:2;5661:18;;5654:34;;;;5719:2;5704:18;;5697:34;5775:14;5768:22;5762:3;5747:19;;5740:51;5589:3;5807:19;;5800:35;5538:3;5523:19;;5505:336::o;6528:191::-;6701:2;6690:22;;;;6672:41;;6660:2;6645:18;;6627:92::o;6724:383::-;;6873:2;6862:9;6855:21;6905:6;6899:13;6948:6;6943:2;6932:9;6928:18;6921:34;6964:66;7023:6;7018:2;7007:9;7003:18;6998:2;6990:6;6986:15;6964:66;:::i;:::-;7091:2;7070:15;-1:-1:-1;;7066:29:1;7051:45;;;;7098:2;7047:54;;6845:262;-1:-1:-1;;6845:262:1:o;7112:327::-;7314:2;7296:21;;;7353:1;7333:18;;;7326:29;-1:-1:-1;;;7386:2:1;7371:18;;7364:34;7430:2;7415:18;;7286:153::o;7444:351::-;7646:2;7628:21;;;7685:2;7665:18;;;7658:30;7724:29;7719:2;7704:18;;7697:57;7786:2;7771:18;;7618:177::o;7800:355::-;8002:2;7984:21;;;8041:2;8021:18;;;8014:30;8080:33;8075:2;8060:18;;8053:61;8146:2;8131:18;;7974:181::o;8160:354::-;8362:2;8344:21;;;8401:2;8381:18;;;8374:30;8440:32;8435:2;8420:18;;8413:60;8505:2;8490:18;;8334:180::o;8926:350::-;9128:2;9110:21;;;9167:2;9147:18;;;9140:30;9206:28;9201:2;9186:18;;9179:56;9267:2;9252:18;;9100:176::o;9281:351::-;9483:2;9465:21;;;9522:2;9502:18;;;9495:30;9561:29;9556:2;9541:18;;9534:57;9623:2;9608:18;;9455:177::o;9637:331::-;9839:2;9821:21;;;9878:1;9858:18;;;9851:29;-1:-1:-1;;;9911:2:1;9896:18;;9889:38;9959:2;9944:18;;9811:157::o;9973:335::-;10175:2;10157:21;;;10214:2;10194:18;;;10187:30;-1:-1:-1;;;10248:2:1;10233:18;;10226:41;10299:2;10284:18;;10147:161::o;10313:343::-;10515:2;10497:21;;;10554:2;10534:18;;;10527:30;-1:-1:-1;;;10588:2:1;10573:18;;10566:49;10647:2;10632:18;;10487:169::o;10661:397::-;10863:2;10845:21;;;10902:2;10882:18;;;10875:30;10941:34;10936:2;10921:18;;10914:62;-1:-1:-1;;;11007:2:1;10992:18;;10985:31;11048:3;11033:19;;10835:223::o;11063:353::-;11265:2;11247:21;;;11304:2;11284:18;;;11277:30;11343:31;11338:2;11323:18;;11316:59;11407:2;11392:18;;11237:179::o;11421:342::-;11623:2;11605:21;;;11662:2;11642:18;;;11635:30;-1:-1:-1;;;11696:2:1;11681:18;;11674:48;11754:2;11739:18;;11595:168::o;11768:334::-;11970:2;11952:21;;;12009:2;11989:18;;;11982:30;-1:-1:-1;;;12043:2:1;12028:18;;12021:40;12093:2;12078:18;;11942:160::o;12107:407::-;12309:2;12291:21;;;12348:2;12328:18;;;12321:30;12387:34;12382:2;12367:18;;12360:62;-1:-1:-1;;;12453:2:1;12438:18;;12431:41;12504:3;12489:19;;12281:233::o;12519:406::-;12721:2;12703:21;;;12760:2;12740:18;;;12733:30;12799:34;12794:2;12779:18;;12772:62;-1:-1:-1;;;12865:2:1;12850:18;;12843:40;12915:3;12900:19;;12693:232::o;12930:177::-;13076:25;;;13064:2;13049:18;;13031:76::o;13112:248::-;13286:25;;;13342:2;13327:18;;13320:34;13274:2;13259:18;;13241:119::o;13365:329::-;13561:25;;;13617:2;13602:18;;13595:34;;;;13672:14;13665:22;13660:2;13645:18;;13638:50;13549:2;13534:18;;13516:178::o;13699:128::-;;13770:1;13766:6;13763:1;13760:13;13757:2;;;13776:18;;:::i;:::-;-1:-1:-1;13812:9:1;;13747:80::o;13832:120::-;;13898:1;13888:2;;13903:18;;:::i;:::-;-1:-1:-1;13937:9:1;;13878:74::o;13957:168::-;;14063:1;14059;14055:6;14051:14;14048:1;14045:21;14040:1;14033:9;14026:17;14022:45;14019:2;;;14070:18;;:::i;:::-;-1:-1:-1;14110:9:1;;14009:116::o;14130:125::-;;14198:1;14195;14192:8;14189:2;;;14203:18;;:::i;:::-;-1:-1:-1;14240:9:1;;14179:76::o;14260:258::-;14332:1;14342:113;14356:6;14353:1;14350:13;14342:113;;;14432:11;;;14426:18;14413:11;;;14406:39;14378:2;14371:10;14342:113;;;14473:6;14470:1;14467:13;14464:2;;;-1:-1:-1;;14508:1:1;14490:16;;14483:27;14313:205::o;14523:135::-;;-1:-1:-1;;14583:17:1;;14580:2;;;14603:18;;:::i;:::-;-1:-1:-1;14650:1:1;14639:13;;14570:88::o;14663:112::-;;14721:1;14711:2;;14726:18;;:::i;:::-;-1:-1:-1;14760:9:1;;14701:74::o;14780:127::-;14841:10;14836:3;14832:20;14829:1;14822:31;14872:4;14869:1;14862:15;14896:4;14893:1;14886:15;14912:127;14973:10;14968:3;14964:20;14961:1;14954:31;15004:4;15001:1;14994:15;15028:4;15025:1;15018:15;15044:133;-1:-1:-1;;;;;15121:31:1;;15111:42;;15101:2;;15167:1;15164;15157:12;15182:120;15270:5;15263:13;15256:21;15249:5;15246:32;15236:2;;15292:1;15289;15282:12

d17a4d247567d4d4c79a52f17967b6807321b4f24c46a36c5d9a70c5cb903e3f