Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• library ABDKMath64x64
•    - function fromInt (int256 x)
•    - function toInt (int128 x)
•    - function fromUInt (uint256 x)
•    - function toUInt (int128 x)
•    - function from128x128 (int256 x)
•    - function to128x128 (int128 x)
•    - function add (int128 x, int128 y)
•    - function sub (int128 x, int128 y)
•    - function mul (int128 x, int128 y)
•    - function muli (int128 x, int256 y)
•    - function mulu (int128 x, uint256 y)
•    - function div (int128 x, int128 y)
•    - function divi (int256 x, int256 y)
•    - function divu (uint256 x, uint256 y)
•    - function neg (int128 x)
•    - function abs (int128 x)
•    - function inv (int128 x)
•    - function avg (int128 x, int128 y)
•    - function gavg (int128 x, int128 y)
•    - function pow (int128 x, uint256 y)
•    - function sqrt (int128 x)
•    - function log_2 (int128 x)
•    - function ln (int128 x)
•    - function exp_2 (int128 x)
•    - function exp (int128 x)
•    - function divuu (uint256 x, uint256 y)
•    - function sqrtu (uint256 x)
• library Math
•    - function min(uint256 a, uint256 b)
•    - function max(uint256 a, uint256 b)
•    - function logX64(uint256 x)
•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function _checkOwner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
•    - function _transferOwnership(address n ...
• interface IMintingRewards
•    - function addMinting(address user, uin ...
•    - function endMinting(address user)
•    - function distribute()
•    - function withdraw()
•    - function emergency()
• interface IMaxTerm
•    - function getCurrentMaxTerm()
•  contract MintingRewards is Ownable ... *
•    - function _calculateWithdrawReward(
•    - function _calculateDistributeReward()
•    - function calculateWithdrawReward(
•    - function calculateDistributeReward()
•    - function getMinterInfo(
•    - function addMinting(
•    - function distribute()
•    - function withdraw()
•    - function endMinting(address user)
•    - function emergency()
•    - function setup(address _kanProxy)

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2023-12-02
*/

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.10;

/*
 * ABDK Math 64.64 Smart Contract Library.  Copyright © 2019 by ABDK Consulting.
 * Author: Mikhail Vladimirov <[email protected]>
 */

/**
 * 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);
      }
    }
  }
}

library Math {
    function min(uint256 a, uint256 b) external pure returns (uint256) {
        if (a > b) return b;
        return a;
    }

    function max(uint256 a, uint256 b) external pure returns (uint256) {
        if (a > b) return a;
        return b;
    }

    function logX64(uint256 x) external pure returns (int128) {
        return ABDKMath64x64.log_2(ABDKMath64x64.fromUInt(x));
    }
}

// OpenZeppelin Contracts (last updated v5.0.0) (access/Ownable.sol)

// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}

/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * The initial owner is set to the address provided by the deployer. This can
 * later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    /**
     * @dev The caller account is not authorized to perform an operation.
     */
    error OwnableUnauthorizedAccount(address account);

    /**
     * @dev The owner is not a valid owner account. (eg. `address(0)`)
     */
    error OwnableInvalidOwner(address owner);

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the address provided by the deployer as the initial owner.
     */
    constructor(address initialOwner) {
        if (initialOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(initialOwner);
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        if (owner() != _msgSender()) {
            revert OwnableUnauthorizedAccount(_msgSender());
        }
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby disabling any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _transferOwnership(address(0));
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        if (newOwner == address(0)) {
            revert OwnableInvalidOwner(address(0));
        }
        _transferOwnership(newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

interface IMintingRewards {
    event PaymentReceived(address from, uint256 amount);
    
    event MintingAdded(address indexed user, uint256 amount, uint256 termSec);

    event Withdrew(address indexed user, uint256 amount);

    event Emergencied(uint256 amount);

    function addMinting(address user, uint256 amount, uint256 termSec) external;

    function endMinting(address user) external;

    function distribute() external;

    function withdraw() external;
    
    function emergency() external;
}

interface IMaxTerm {
    function getCurrentMaxTerm() external view returns (uint256);
}

contract MintingRewards is Ownable, IMintingRewards {
    using Math for uint256;
    using ABDKMath64x64 for int128;
    using ABDKMath64x64 for uint256;

    struct MinterInfo {
        uint256 ethInvested;
        uint256 rewardEndTimestamp;
        uint256 rewardDebt;
    }

    address public kanProxy;

    uint256 public accReward;
    uint256 public totalEthInvested;
    uint256 public lastRewardTimestamp;
    uint256 public rewardPool;

    bool public inited;

    uint256 public constant REWARD_INTERVAL = 24 hours;

    uint256 constant PENALTY_INCREMENT_PERCENT = 20;
    uint256 constant MAX_PENALTY_PERCENT = 100;

    mapping(address => MinterInfo) public minters;

    uint256 public constant multiplier = 1_000_000_000_000;

    uint256 private _lock;

    constructor() payable Ownable(msg.sender) {
        lastRewardTimestamp = block.timestamp;
    }

    modifier nonReentrant() {
        require(_lock == 0, "ReentrancyGuard: reentrant call");
        _lock = 1;
        _;
        _lock = 0;
    }

    receive() external payable {
        rewardPool += msg.value;
        emit PaymentReceived(msg.sender, msg.value);
    }

    modifier onlyKANProxy() {
        require(inited, "Not initialized");
        require(
            msg.sender == kanProxy,
            "Only the KANProxy can call this function"
        );
        _;
    }

    function _calculateWithdrawReward(
        MinterInfo memory minter
    ) internal view returns (uint256) {
        if (minter.ethInvested == 0) {
            return 0;
        }
        uint256 rewardDebt = (minter.ethInvested * accReward) / multiplier;
        if (rewardDebt <= minter.rewardDebt) {
            return 0;
        }
        uint256 pending = rewardDebt - minter.rewardDebt;
        if (block.timestamp > minter.rewardEndTimestamp + 1 days) {
            uint256 daysOverdue = (block.timestamp -
                minter.rewardEndTimestamp) / 1 days;
            uint256 penaltyPercent = daysOverdue * PENALTY_INCREMENT_PERCENT;
            if (penaltyPercent > MAX_PENALTY_PERCENT) {
                penaltyPercent = MAX_PENALTY_PERCENT;
            }
            uint256 penalty = (pending * penaltyPercent) / 100;
            if (penalty >= pending) {
                return 0;
            }
            return pending - penalty;
        }
        return pending;
    }

    function _calculateDistributeReward() internal view returns (uint256) {
        uint256 maxTermSec = IMaxTerm(kanProxy).getCurrentMaxTerm(); // 获取最大期限
        uint256 rewardAmount = (rewardPool * 3_600 * 24 * 3) / maxTermSec;
        return rewardAmount;
    }

    function calculateWithdrawReward(
        address user
    ) external view returns (uint256) {
        MinterInfo memory minter = minters[user];
        return _calculateWithdrawReward(minter);
    }

    function calculateDistributeReward() external view returns (uint256) {
        return _calculateDistributeReward();
    }

    function getMinterInfo(
        address user
    ) external view returns (MinterInfo memory) {
        return minters[user];
    }

    function addMinting(
        address user,
        uint256 amount,
        uint256 termSec
    ) external override onlyKANProxy {
        require(inited, "Not initialized");
        require(amount > 0, "Amount must be greater than 0");

        MinterInfo memory minter = minters[user];
        uint256 rewardDebt = (minter.ethInvested * accReward) / multiplier;
        uint256 pending = rewardDebt > minter.rewardDebt
            ? (rewardDebt - minter.rewardDebt)
            : 0;

        totalEthInvested += amount;
        minter.ethInvested += amount;
        minter.rewardEndTimestamp = block.timestamp + termSec;
        minter.rewardDebt = (minter.ethInvested * accReward) / multiplier;
        minters[user] = minter;
        emit MintingAdded(user, amount, termSec);

        if (pending > 0) {
            payable(_msgSender()).transfer(pending);
            emit Withdrew(_msgSender(), pending);
        }
    }

    function distribute() external override {
        require(inited, "Not initialized");
        require(
            block.timestamp >= lastRewardTimestamp + REWARD_INTERVAL,
            "Minting Reward interval has not passed"
        );

        uint256 rewardAmount = _calculateDistributeReward();
        if (rewardAmount > rewardPool) {
            rewardAmount = rewardPool;
        }
        accReward += (rewardAmount * multiplier) / totalEthInvested;
        rewardPool -= rewardAmount;
        lastRewardTimestamp = block.timestamp;
    }

    function withdraw() external override nonReentrant {
        MinterInfo memory minter = minters[_msgSender()];
        require(minter.ethInvested > 0, "No staked amount");
        uint256 pending = _calculateWithdrawReward(minter);
        minter.rewardDebt = (minter.ethInvested * accReward) / multiplier;
        if (block.timestamp > minter.rewardEndTimestamp) {
            totalEthInvested -= minter.ethInvested;
            minter.ethInvested = 0;
        }
        minters[_msgSender()] = minter;
        if (pending > 0) {
            payable(_msgSender()).transfer(pending);
            emit Withdrew(_msgSender(), pending);
        }
    }

    function endMinting(address user) external override onlyKANProxy {
        MinterInfo memory minter = minters[user];
        if (minter.ethInvested > 0) {
            uint256 pending = _calculateWithdrawReward(minter);
            minter.rewardDebt = (minter.ethInvested * accReward) / multiplier;
            totalEthInvested -= minter.ethInvested;
            minter.ethInvested = 0;
            minters[user] = minter;
            if (pending > 0) {
                payable(user).transfer(pending);
                emit Withdrew(user, pending);
            }
        }
    }

    function emergency() external onlyOwner {
        uint256 balance = address(this).balance;
        require(balance > 0, "No ETH to withdraw");
        rewardPool = 0;
        payable(owner()).transfer(balance);
        emit Emergencied(balance);
    }

    function setup(address _kanProxy) external onlyOwner {
        kanProxy = _kanProxy;
        inited = true;
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"payable","type":"constructor"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"OwnableInvalidOwner","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"OwnableUnauthorizedAccount","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Emergencied","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"termSec","type":"uint256"}],"name":"MintingAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PaymentReceived","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"Withdrew","type":"event"},{"inputs":[],"name":"REWARD_INTERVAL","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"accReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"},{"internalType":"uint256","name":"termSec","type":"uint256"}],"name":"addMinting","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"calculateDistributeReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"calculateWithdrawReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"distribute","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"emergency","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"endMinting","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getMinterInfo","outputs":[{"components":[{"internalType":"uint256","name":"ethInvested","type":"uint256"},{"internalType":"uint256","name":"rewardEndTimestamp","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"}],"internalType":"struct MintingRewards.MinterInfo","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"inited","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"kanProxy","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastRewardTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"minters","outputs":[{"internalType":"uint256","name":"ethInvested","type":"uint256"},{"internalType":"uint256","name":"rewardEndTimestamp","type":"uint256"},{"internalType":"uint256","name":"rewardDebt","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"multiplier","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardPool","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_kanProxy","type":"address"}],"name":"setup","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"totalEthInvested","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

31252:6391:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;32376:9;32362:10;;:23;;;;;;;:::i;:::-;;;;;;;;32401:38;32417:10;32429:9;32401:38;;;;;;;:::i;:::-;;;;;;;;31252:6391;;;;;31968:54;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;35990:663;;;;;;;;;;;;;:::i;:::-;;31723:18;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;31579:24;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;31750:50;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;31610:31;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;31689:25;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;37524:116;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;29788:103;;;;;;;;;;;;;:::i;:::-;;34464:950;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;29113:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;34191:123;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;36661:590;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;37259:257;;;;;;;;;;;;;:::i;:::-;;31547:23;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;35422:560;;;;;;;;;;;;;:::i;:::-;;34322:134;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;30046:220;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;31914:45;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;;;:::i;:::-;;;;;;;;31648:34;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;33979:204;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;31968:54;32005:17;31968:54;:::o;35990:663::-;32219:1;32210:5;;:10;32202:54;;;;;;;;;;;;:::i;:::-;;;;;;;;;32275:1;32267:5;:9;;;;36052:24:::1;36079:7;:21;36087:12;:10;:12::i;:::-;36079:21;;;;;;;;;;;;;;;36052:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;36140:1;36119:6;:18;;;:22;36111:51;;;;;;;;;;;;:::i;:::-;;;;;;;;;36173:15;36191:32;36216:6;36191:24;:32::i;:::-;36173:50;;32005:17;36276:9;;36255:6;:18;;;:30;;;;:::i;:::-;36254:45;;;;:::i;:::-;36234:6;:17;;:65;;;::::0;::::1;36332:6;:25;;;36314:15;:43;36310:151;;;36394:6;:18;;;36374:16;;:38;;;;;;;:::i;:::-;;;;;;;;36448:1;36427:6;:18;;:22;;;::::0;::::1;36310:151;36495:6;36471:7;:21;36479:12;:10;:12::i;:::-;36471:21;;;;;;;;;;;;;;;:30;;;;;;;;;;;;;;;;;;;;;;;;;;;36526:1;36516:7;:11;36512:134;;;36552:12;:10;:12::i;:::-;36544:30;;:39;36575:7;36544:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;36612:12;:10;:12::i;:::-;36603:31;;;36626:7;36603:31;;;;;;:::i;:::-;;;;;;;;36512:134;36041:612;;32307:1:::0;32299:5;:9;;;;35990:663::o;31723:18::-;;;;;;;;;;;;;:::o;31579:24::-;;;;:::o;31750:50::-;31792:8;31750:50;:::o;31610:31::-;;;;:::o;31689:25::-;;;;:::o;37524:116::-;28999:13;:11;:13::i;:::-;37599:9:::1;37588:8;;:20;;;;;;;;;;;;;;;;;;37628:4;37619:6;;:13;;;;;;;;;;;;;;;;;;37524:116:::0;:::o;29788:103::-;28999:13;:11;:13::i;:::-;29853:30:::1;29880:1;29853:18;:30::i;:::-;29788:103::o:0;34464:950::-;32498:6;;;;;;;;;;;32490:34;;;;;;;;;;;;:::i;:::-;;;;;;;;;32571:8;;;;;;;;;;;32557:22;;:10;:22;;;32535:112;;;;;;;;;;;;:::i;:::-;;;;;;;;;34615:6:::1;;;;;;;;;;;34607:34;;;;;;;;;;;;:::i;:::-;;;;;;;;;34669:1;34660:6;:10;34652:52;;;;;;;;;;;;:::i;:::-;;;;;;;;;34717:24;34744:7;:13;34752:4;34744:13;;;;;;;;;;;;;;;34717:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;34768:18;32005:17;34811:9;;34790:6;:18;;;:30;;;;:::i;:::-;34789:45;;;;:::i;:::-;34768:66;;34845:15;34876:6;:17;;;34863:10;:30;:95;;34957:1;34863:95;;;34923:6;:17;;;34910:10;:30;;;;:::i;:::-;34863:95;34845:113;;34991:6;34971:16;;:26;;;;;;;:::i;:::-;;;;;;;;35030:6;35008;:18;;:28;;;;;;;:::i;:::-;;;;;;::::0;::::1;35093:7;35075:15;:25;;;;:::i;:::-;35047:6;:25;;:53;;;::::0;::::1;32005:17;35153:9;;35132:6;:18;;;:30;;;;:::i;:::-;35131:45;;;;:::i;:::-;35111:6;:17;;:65;;;::::0;::::1;35203:6;35187:7;:13;35195:4;35187:13;;;;;;;;;;;;;;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;35238:4;35225:35;;;35244:6;35252:7;35225:35;;;;;;;:::i;:::-;;;;;;;;35287:1;35277:7;:11;35273:134;;;35313:12;:10;:12::i;:::-;35305:30;;:39;35336:7;35305:39;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;35373:12;:10;:12::i;:::-;35364:31;;;35387:7;35364:31;;;;;;:::i;:::-;;;;;;;;35273:134;34596:818;;;34464:950:::0;;;:::o;29113:87::-;29159:7;29186:6;;;;;;;;;;;29179:13;;29113:87;:::o;34191:123::-;34251:7;34278:28;:26;:28::i;:::-;34271:35;;34191:123;:::o;36661:590::-;32498:6;;;;;;;;;;;32490:34;;;;;;;;;;;;:::i;:::-;;;;;;;;;32571:8;;;;;;;;;;;32557:22;;:10;:22;;;32535:112;;;;;;;;;;;;:::i;:::-;;;;;;;;;36737:24:::1;36764:7;:13;36772:4;36764:13;;;;;;;;;;;;;;;36737:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;36813:1;36792:6;:18;;;:22;36788:456;;;36831:15;36849:32;36874:6;36849:24;:32::i;:::-;36831:50;;32005:17;36938:9;;36917:6;:18;;;:30;;;;:::i;:::-;36916:45;;;;:::i;:::-;36896:6;:17;;:65;;;::::0;::::1;36996:6;:18;;;36976:16;;:38;;;;;;;:::i;:::-;;;;;;;;37050:1;37029:6;:18;;:22;;;::::0;::::1;37082:6;37066:7;:13;37074:4;37066:13;;;;;;;;;;;;;;;:22;;;;;;;;;;;;;;;;;;;;;;;;;;;37117:1;37107:7;:11;37103:130;;;37147:4;37139:22;;:31;37162:7;37139:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;37203:4;37194:23;;;37209:7;37194:23;;;;;;:::i;:::-;;;;;;;;37103:130;36816:428;36788:456;36726:525;36661:590:::0;:::o;37259:257::-;28999:13;:11;:13::i;:::-;37310:15:::1;37328:21;37310:39;;37378:1;37368:7;:11;37360:42;;;;;;;;;;;;:::i;:::-;;;;;;;;;37426:1;37413:10;:14;;;;37446:7;:5;:7::i;:::-;37438:25;;:34;37464:7;37438:34;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;37488:20;37500:7;37488:20;;;;;;:::i;:::-;;;;;;;;37299:217;37259:257::o:0;31547:23::-;;;;;;;;;;;;;:::o;35422:560::-;35481:6;;;;;;;;;;;35473:34;;;;;;;;;;;;:::i;:::-;;;;;;;;;31792:8;35559:19;;:37;;;;:::i;:::-;35540:15;:56;;35518:144;;;;;;;;;;;;:::i;:::-;;;;;;;;;35675:20;35698:28;:26;:28::i;:::-;35675:51;;35756:10;;35741:12;:25;35737:83;;;35798:10;;35783:25;;35737:83;35873:16;;32005:17;35844:12;:25;;;;:::i;:::-;35843:46;;;;:::i;:::-;35830:9;;:59;;;;;;;:::i;:::-;;;;;;;;35914:12;35900:10;;:26;;;;;;;:::i;:::-;;;;;;;;35959:15;35937:19;:37;;;;35462:520;35422:560::o;34322:134::-;34398:17;;:::i;:::-;34435:7;:13;34443:4;34435:13;;;;;;;;;;;;;;;34428:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34322:134;;;:::o;30046:220::-;28999:13;:11;:13::i;:::-;30151:1:::1;30131:22;;:8;:22;;;30127:93;;;30205:1;30177:31;;;;;;;;;;;:::i;:::-;;;;;;;;30127:93;30230:28;30249:8;30230:18;:28::i;:::-;30046:220:::0;:::o;31914:45::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;31648:34::-;;;;:::o;33979:204::-;34065:7;34085:24;34112:7;:13;34120:4;34112:13;;;;;;;;;;;;;;;34085:40;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34143:32;34168:6;34143:24;:32::i;:::-;34136:39;;;33979:204;;;:::o;27388:98::-;27441:7;27468:10;27461:17;;27388:98;:::o;32675:1012::-;32774:7;32820:1;32798:6;:18;;;:23;32794:64;;;32845:1;32838:8;;;;32794:64;32868:18;32005:17;32911:9;;32890:6;:18;;;:30;;;;:::i;:::-;32889:45;;;;:::i;:::-;32868:66;;32963:6;:17;;;32949:10;:31;32945:72;;33004:1;32997:8;;;;;32945:72;33027:15;33058:6;:17;;;33045:10;:30;;;;:::i;:::-;33027:48;;33136:6;33108;:25;;;:34;;;;:::i;:::-;33090:15;:52;33086:569;;;33159:19;33246:6;33217;:25;;;33182:15;:60;;;;:::i;:::-;33181:71;;;;:::i;:::-;33159:93;;33267:22;31854:2;33292:11;:39;;;;:::i;:::-;33267:64;;31902:3;33350:14;:36;33346:113;;;31902:3;33407:36;;33346:113;33473:15;33520:3;33502:14;33492:7;:24;;;;:::i;:::-;33491:32;;;;:::i;:::-;33473:50;;33553:7;33542;:18;33538:67;;33588:1;33581:8;;;;;;;;;33538:67;33636:7;33626;:17;;;;:::i;:::-;33619:24;;;;;;;;;33086:569;33672:7;33665:14;;;;32675:1012;;;;:::o;29278:166::-;29349:12;:10;:12::i;:::-;29338:23;;:7;:5;:7::i;:::-;:23;;;29334:103;;29412:12;:10;:12::i;:::-;29385:40;;;;;;;;;;;:::i;:::-;;;;;;;;29334:103;29278:166::o;30426:191::-;30500:16;30519:6;;;;;;;;;;;30500:25;;30545:8;30536:6;;:17;;;;;;;;;;;;;;;;;;30600:8;30569:40;;30590:8;30569:40;;;;;;;;;;;;30489:128;30426:191;:::o;33695:276::-;33756:7;33776:18;33806:8;;;;;;;;;;;33797:36;;;:38;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;33776:59;;33868:20;33923:10;33918:1;33913:2;33905:5;33892:10;;:18;;;;:::i;:::-;:23;;;;:::i;:::-;:27;;;;:::i;:::-;33891:42;;;;:::i;:::-;33868:65;;33951:12;33944:19;;;;33695:276;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;:::o;7:77:1:-;44:7;73:5;62:16;;7:77;;;:::o;90:180::-;138:77;135:1;128:88;235:4;232:1;225:15;259:4;256:1;249:15;276:305;316:3;335:20;353:1;335:20;:::i;:::-;330:25;;369:20;387:1;369:20;:::i;:::-;364:25;;523:1;455:66;451:74;448:1;445:81;442:107;;;529:18;;:::i;:::-;442:107;573:1;570;566:9;559:16;;276:305;;;;:::o;587:126::-;624:7;664:42;657:5;653:54;642:65;;587:126;;;:::o;719:96::-;756:7;785:24;803:5;785:24;:::i;:::-;774:35;;719:96;;;:::o;821:118::-;908:24;926:5;908:24;:::i;:::-;903:3;896:37;821:118;;:::o;945:::-;1032:24;1050:5;1032:24;:::i;:::-;1027:3;1020:37;945:118;;:::o;1069:332::-;1190:4;1228:2;1217:9;1213:18;1205:26;;1241:71;1309:1;1298:9;1294:17;1285:6;1241:71;:::i;:::-;1322:72;1390:2;1379:9;1375:18;1366:6;1322:72;:::i;:::-;1069:332;;;;;:::o;1407:222::-;1500:4;1538:2;1527:9;1523:18;1515:26;;1551:71;1619:1;1608:9;1604:17;1595:6;1551:71;:::i;:::-;1407:222;;;;:::o;1635:90::-;1669:7;1712:5;1705:13;1698:21;1687:32;;1635:90;;;:::o;1731:109::-;1812:21;1827:5;1812:21;:::i;:::-;1807:3;1800:34;1731:109;;:::o;1846:210::-;1933:4;1971:2;1960:9;1956:18;1948:26;;1984:65;2046:1;2035:9;2031:17;2022:6;1984:65;:::i;:::-;1846:210;;;;:::o;2143:117::-;2252:1;2249;2242:12;2389:122;2462:24;2480:5;2462:24;:::i;:::-;2455:5;2452:35;2442:63;;2501:1;2498;2491:12;2442:63;2389:122;:::o;2517:139::-;2563:5;2601:6;2588:20;2579:29;;2617:33;2644:5;2617:33;:::i;:::-;2517:139;;;;:::o;2662:329::-;2721:6;2770:2;2758:9;2749:7;2745:23;2741:32;2738:119;;;2776:79;;:::i;:::-;2738:119;2896:1;2921:53;2966:7;2957:6;2946:9;2942:22;2921:53;:::i;:::-;2911:63;;2867:117;2662:329;;;;:::o;2997:122::-;3070:24;3088:5;3070:24;:::i;:::-;3063:5;3060:35;3050:63;;3109:1;3106;3099:12;3050:63;2997:122;:::o;3125:139::-;3171:5;3209:6;3196:20;3187:29;;3225:33;3252:5;3225:33;:::i;:::-;3125:139;;;;:::o;3270:619::-;3347:6;3355;3363;3412:2;3400:9;3391:7;3387:23;3383:32;3380:119;;;3418:79;;:::i;:::-;3380:119;3538:1;3563:53;3608:7;3599:6;3588:9;3584:22;3563:53;:::i;:::-;3553:63;;3509:117;3665:2;3691:53;3736:7;3727:6;3716:9;3712:22;3691:53;:::i;:::-;3681:63;;3636:118;3793:2;3819:53;3864:7;3855:6;3844:9;3840:22;3819:53;:::i;:::-;3809:63;;3764:118;3270:619;;;;;:::o;3895:222::-;3988:4;4026:2;4015:9;4011:18;4003:26;;4039:71;4107:1;4096:9;4092:17;4083:6;4039:71;:::i;:::-;3895:222;;;;:::o;4123:108::-;4200:24;4218:5;4200:24;:::i;:::-;4195:3;4188:37;4123:108;;:::o;4313:714::-;4466:4;4461:3;4457:14;4560:4;4553:5;4549:16;4543:23;4579:63;4636:4;4631:3;4627:14;4613:12;4579:63;:::i;:::-;4481:171;4748:4;4741:5;4737:16;4731:23;4767:63;4824:4;4819:3;4815:14;4801:12;4767:63;:::i;:::-;4662:178;4928:4;4921:5;4917:16;4911:23;4947:63;5004:4;4999:3;4995:14;4981:12;4947:63;:::i;:::-;4850:170;4435:592;4313:714;;:::o;5033:334::-;5182:4;5220:2;5209:9;5205:18;5197:26;;5233:127;5357:1;5346:9;5342:17;5333:6;5233:127;:::i;:::-;5033:334;;;;:::o;5373:442::-;5522:4;5560:2;5549:9;5545:18;5537:26;;5573:71;5641:1;5630:9;5626:17;5617:6;5573:71;:::i;:::-;5654:72;5722:2;5711:9;5707:18;5698:6;5654:72;:::i;:::-;5736;5804:2;5793:9;5789:18;5780:6;5736:72;:::i;:::-;5373:442;;;;;;:::o;5821:169::-;5905:11;5939:6;5934:3;5927:19;5979:4;5974:3;5970:14;5955:29;;5821:169;;;;:::o;5996:181::-;6136:33;6132:1;6124:6;6120:14;6113:57;5996:181;:::o;6183:366::-;6325:3;6346:67;6410:2;6405:3;6346:67;:::i;:::-;6339:74;;6422:93;6511:3;6422:93;:::i;:::-;6540:2;6535:3;6531:12;6524:19;;6183:366;;;:::o;6555:419::-;6721:4;6759:2;6748:9;6744:18;6736:26;;6808:9;6802:4;6798:20;6794:1;6783:9;6779:17;6772:47;6836:131;6962:4;6836:131;:::i;:::-;6828:139;;6555:419;;;:::o;6980:166::-;7120:18;7116:1;7108:6;7104:14;7097:42;6980:166;:::o;7152:366::-;7294:3;7315:67;7379:2;7374:3;7315:67;:::i;:::-;7308:74;;7391:93;7480:3;7391:93;:::i;:::-;7509:2;7504:3;7500:12;7493:19;;7152:366;;;:::o;7524:419::-;7690:4;7728:2;7717:9;7713:18;7705:26;;7777:9;7771:4;7767:20;7763:1;7752:9;7748:17;7741:47;7805:131;7931:4;7805:131;:::i;:::-;7797:139;;7524:419;;;:::o;7949:348::-;7989:7;8012:20;8030:1;8012:20;:::i;:::-;8007:25;;8046:20;8064:1;8046:20;:::i;:::-;8041:25;;8234:1;8166:66;8162:74;8159:1;8156:81;8151:1;8144:9;8137:17;8133:105;8130:131;;;8241:18;;:::i;:::-;8130:131;8289:1;8286;8282:9;8271:20;;7949:348;;;;:::o;8303:180::-;8351:77;8348:1;8341:88;8448:4;8445:1;8438:15;8472:4;8469:1;8462:15;8489:185;8529:1;8546:20;8564:1;8546:20;:::i;:::-;8541:25;;8580:20;8598:1;8580:20;:::i;:::-;8575:25;;8619:1;8609:35;;8624:18;;:::i;:::-;8609:35;8666:1;8663;8659:9;8654:14;;8489:185;;;;:::o;8680:191::-;8720:4;8740:20;8758:1;8740:20;:::i;:::-;8735:25;;8774:20;8792:1;8774:20;:::i;:::-;8769:25;;8813:1;8810;8807:8;8804:34;;;8818:18;;:::i;:::-;8804:34;8863:1;8860;8856:9;8848:17;;8680:191;;;;:::o;8877:165::-;9017:17;9013:1;9005:6;9001:14;8994:41;8877:165;:::o;9048:366::-;9190:3;9211:67;9275:2;9270:3;9211:67;:::i;:::-;9204:74;;9287:93;9376:3;9287:93;:::i;:::-;9405:2;9400:3;9396:12;9389:19;;9048:366;;;:::o;9420:419::-;9586:4;9624:2;9613:9;9609:18;9601:26;;9673:9;9667:4;9663:20;9659:1;9648:9;9644:17;9637:47;9701:131;9827:4;9701:131;:::i;:::-;9693:139;;9420:419;;;:::o;9845:227::-;9985:34;9981:1;9973:6;9969:14;9962:58;10054:10;10049:2;10041:6;10037:15;10030:35;9845:227;:::o;10078:366::-;10220:3;10241:67;10305:2;10300:3;10241:67;:::i;:::-;10234:74;;10317:93;10406:3;10317:93;:::i;:::-;10435:2;10430:3;10426:12;10419:19;;10078:366;;;:::o;10450:419::-;10616:4;10654:2;10643:9;10639:18;10631:26;;10703:9;10697:4;10693:20;10689:1;10678:9;10674:17;10667:47;10731:131;10857:4;10731:131;:::i;:::-;10723:139;;10450:419;;;:::o;10875:179::-;11015:31;11011:1;11003:6;10999:14;10992:55;10875:179;:::o;11060:366::-;11202:3;11223:67;11287:2;11282:3;11223:67;:::i;:::-;11216:74;;11299:93;11388:3;11299:93;:::i;:::-;11417:2;11412:3;11408:12;11401:19;;11060:366;;;:::o;11432:419::-;11598:4;11636:2;11625:9;11621:18;11613:26;;11685:9;11679:4;11675:20;11671:1;11660:9;11656:17;11649:47;11713:131;11839:4;11713:131;:::i;:::-;11705:139;;11432:419;;;:::o;11857:332::-;11978:4;12016:2;12005:9;12001:18;11993:26;;12029:71;12097:1;12086:9;12082:17;12073:6;12029:71;:::i;:::-;12110:72;12178:2;12167:9;12163:18;12154:6;12110:72;:::i;:::-;11857:332;;;;;:::o;12195:168::-;12335:20;12331:1;12323:6;12319:14;12312:44;12195:168;:::o;12369:366::-;12511:3;12532:67;12596:2;12591:3;12532:67;:::i;:::-;12525:74;;12608:93;12697:3;12608:93;:::i;:::-;12726:2;12721:3;12717:12;12710:19;;12369:366;;;:::o;12741:419::-;12907:4;12945:2;12934:9;12930:18;12922:26;;12994:9;12988:4;12984:20;12980:1;12969:9;12965:17;12958:47;13022:131;13148:4;13022:131;:::i;:::-;13014:139;;12741:419;;;:::o;13166:225::-;13306:34;13302:1;13294:6;13290:14;13283:58;13375:8;13370:2;13362:6;13358:15;13351:33;13166:225;:::o;13397:366::-;13539:3;13560:67;13624:2;13619:3;13560:67;:::i;:::-;13553:74;;13636:93;13725:3;13636:93;:::i;:::-;13754:2;13749:3;13745:12;13738:19;;13397:366;;;:::o;13769:419::-;13935:4;13973:2;13962:9;13958:18;13950:26;;14022:9;14016:4;14012:20;14008:1;13997:9;13993:17;13986:47;14050:131;14176:4;14050:131;:::i;:::-;14042:139;;13769:419;;;:::o;14194:143::-;14251:5;14282:6;14276:13;14267:22;;14298:33;14325:5;14298:33;:::i;:::-;14194:143;;;;:::o;14343:351::-;14413:6;14462:2;14450:9;14441:7;14437:23;14433:32;14430:119;;;14468:79;;:::i;:::-;14430:119;14588:1;14613:64;14669:7;14660:6;14649:9;14645:22;14613:64;:::i;:::-;14603:74;;14559:128;14343:351;;;;:::o

ipfs://b6537e2e906e7ffc170d00e120d349329a5f3b6ad4c34c3d78d465b74112ea41