Contract

Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT

// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity ^0.7.3;

import "./IERC20.sol";

import "./ABDKMath64x64.sol";
import "./IAssimilator.sol";
import "./IOracle.sol";

contract UsdcToUsdAssimilator is IAssimilator {
    using ABDKMath64x64 for int128;
    using ABDKMath64x64 for uint256;

    IOracle private constant oracle = IOracle(0x8fFfFfd4AfB6115b954Bd326cbe7B4BA576818f6);
    IERC20 private constant usdc = IERC20(0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48);

    // solhint-disable-next-line
    constructor() {}

    // solhint-disable-next-line
    function getRate() public view override returns (uint256) {
        return uint256(oracle.latestAnswer());
    }

    function intakeRawAndGetBalance(uint256 _amount) external override returns (int128 amount_, int128 balance_) {
        bool _success = usdc.transferFrom(msg.sender, address(this), _amount);

        require(_success, "Curve/USDC-transfer-from-failed");

        uint256 _balance = usdc.balanceOf(address(this));

        uint256 _rate = getRate();

        balance_ = ((_balance * _rate) / 1e8).divu(1e6);

        amount_ = ((_amount * _rate) / 1e8).divu(1e6);
    }

    function intakeRaw(uint256 _amount) external override returns (int128 amount_) {
        bool _success = usdc.transferFrom(msg.sender, address(this), _amount);

        require(_success, "Curve/USDC-transfer-from-failed");

        uint256 _rate = getRate();

        amount_ = ((_amount * _rate) / 1e8).divu(1e6);
    }

    function intakeNumeraire(int128 _amount) external override returns (uint256 amount_) {
        uint256 _rate = getRate();

        amount_ = (_amount.mulu(1e6) * 1e8) / _rate;

        bool _success = usdc.transferFrom(msg.sender, address(this), amount_);

        require(_success, "Curve/USDC-transfer-from-failed");
    }

    function intakeNumeraireLPRatio(
        uint256,
        uint256,
        address,
        int128 _amount
    ) external override returns (uint256 amount_) {
        amount_ = _amount.mulu(1e6);

        bool _success = usdc.transferFrom(msg.sender, address(this), amount_);

        require(_success, "Curve/USDC-transfer-from-failed");
    }

    function outputRawAndGetBalance(address _dst, uint256 _amount)
        external
        override
        returns (int128 amount_, int128 balance_)
    {
        uint256 _rate = getRate();

        uint256 _usdcAmount = ((_amount * _rate) / 1e8);

        bool _success = usdc.transfer(_dst, _usdcAmount);

        require(_success, "Curve/USDC-transfer-failed");

        uint256 _balance = usdc.balanceOf(address(this));

        amount_ = _usdcAmount.divu(1e6);

        balance_ = ((_balance * _rate) / 1e8).divu(1e6);
    }

    function outputRaw(address _dst, uint256 _amount) external override returns (int128 amount_) {
        uint256 _rate = getRate();

        uint256 _usdcAmount = (_amount * _rate) / 1e8;

        bool _success = usdc.transfer(_dst, _usdcAmount);

        require(_success, "Curve/USDC-transfer-failed");

        amount_ = _usdcAmount.divu(1e6);
    }

    function outputNumeraire(address _dst, int128 _amount) external override returns (uint256 amount_) {
        uint256 _rate = getRate();

        amount_ = (_amount.mulu(1e6) * 1e8) / _rate;

        bool _success = usdc.transfer(_dst, amount_);

        require(_success, "Curve/USDC-transfer-failed");
    }

    function viewRawAmount(int128 _amount) external view override returns (uint256 amount_) {
        uint256 _rate = getRate();

        amount_ = (_amount.mulu(1e6) * 1e8) / _rate;
    }

    function viewRawAmountLPRatio(
        uint256,
        uint256,
        address,
        int128 _amount
    ) external pure override returns (uint256 amount_) {
        amount_ = _amount.mulu(1e6);
    }

    function viewNumeraireAmount(uint256 _amount) external view override returns (int128 amount_) {
        uint256 _rate = getRate();

        amount_ = ((_amount * _rate) / 1e8).divu(1e6);
    }

    function viewNumeraireBalance(address _addr) public view override returns (int128 balance_) {
        uint256 _rate = getRate();

        uint256 _balance = usdc.balanceOf(_addr);

        if (_balance <= 0) return ABDKMath64x64.fromUInt(0);

        balance_ = ((_balance * _rate) / 1e8).divu(1e6);
    }

    // views the numeraire value of the current balance of the reserve wrt to USD
    // since this is already the USD assimlator, the ratio is just 1
    function viewNumeraireBalanceLPRatio(
        uint256,
        uint256,
        address _addr
    ) external view override returns (int128 balance_) {
        uint256 _balance = usdc.balanceOf(_addr);

        return _balance.divu(1e6);
    }

    function viewNumeraireAmountAndBalance(address _addr, uint256 _amount)
        external
        view
        override
        returns (int128 amount_, int128 balance_)
    {
        uint256 _rate = getRate();

        amount_ = ((_amount * _rate) / 1e8).divu(1e6);

        uint256 _balance = usdc.balanceOf(_addr);

        balance_ = ((_balance * _rate) / 1e8).divu(1e6);
    }
}

// SPDX-License-Identifier: BSD-4-Clause
/*
 * ABDK Math 64.64 Smart Contract Library.  Copyright © 2019 by ABDK Consulting.
 * Author: Mikhail Vladimirov <[email protected]>
 */
pragma solidity ^0.7.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) {
    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) {
    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) {
    require (x <= 0x7FFFFFFFFFFFFFFF);
    return int128 (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) {
    require (x >= 0);
    return uint64 (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) {
    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) {
    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) {
    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) {
    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) {
    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) {
    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) {
    if (y == 0) return 0;

    require (x >= 0);

    uint256 lo = (uint256 (x) * (y & 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF)) >> 64;
    uint256 hi = uint256 (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) {
    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) {
    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) {
    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) {
    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) {
    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) {
    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) {
    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) {
    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) {
    uint256 absoluteResult;
    bool negativeResult = false;
    if (x >= 0) {
      absoluteResult = powu (uint256 (x) << 63, y);
    } else {
      // We rely on overflow behavior here
      absoluteResult = powu (uint256 (uint128 (-x)) << 63, y);
      negativeResult = y & 1 > 0;
    }

    absoluteResult >>= 63;

    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 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) {
    require (x >= 0);
    return int128 (sqrtu (uint256 (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) {
    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 (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) {
    require (x > 0);

    return int128 (
        uint256 (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) {
    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 (63 - (x >> 64));
    require (result <= uint256 (MAX_64x64));

    return int128 (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) {
    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) {
    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 x^y assuming 0^0 is 1, where x is unsigned 129.127 fixed point
   * number and y is unsigned 256-bit integer number.  Revert on overflow.
   *
   * @param x unsigned 129.127-bit fixed point number
   * @param y uint256 value
   * @return unsigned 129.127-bit fixed point number
   */
  function powu (uint256 x, uint256 y) private pure returns (uint256) {
    if (y == 0) return 0x80000000000000000000000000000000;
    else if (x == 0) return 0;
    else {
      int256 msb = 0;
      uint256 xc = x;
      if (xc >= 0x100000000000000000000000000000000) { xc >>= 128; msb += 128; }
      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 xe = msb - 127;
      if (xe > 0) x >>= uint256 (xe);
      else x <<= uint256 (-xe);

      uint256 result = 0x80000000000000000000000000000000;
      int256 re = 0;

      while (y > 0) {
        if (y & 1 > 0) {
          result = result * x;
          y -= 1;
          re += xe;
          if (result >=
            0x8000000000000000000000000000000000000000000000000000000000000000) {
            result >>= 128;
            re += 1;
          } else result >>= 127;
          if (re < -127) return 0; // Underflow
          require (re < 128); // Overflow
        } else {
          x = x * x;
          y >>= 1;
          xe <<= 1;
          if (x >=
            0x8000000000000000000000000000000000000000000000000000000000000000) {
            x >>= 128;
            xe += 1;
          } else x >>= 127;
          if (xe < -127) return 0; // Underflow
          require (xe < 128); // Overflow
        }
      }

      if (re > 0) result <<= uint256 (re);
      else if (re < 0) result >>= uint256 (-re);

      return 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) {
    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);
    }
  }
}

// SPDX-License-Identifier: MIT

// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity ^0.7.3;

interface IAssimilator {
    function getRate() external view returns (uint256);

    function intakeRaw(uint256 amount) external returns (int128);

    function intakeRawAndGetBalance(uint256 amount) external returns (int128, int128);

    function intakeNumeraire(int128 amount) external returns (uint256);

    function intakeNumeraireLPRatio(
        uint256,
        uint256,
        address,
        int128
    ) external returns (uint256);

    function outputRaw(address dst, uint256 amount) external returns (int128);

    function outputRawAndGetBalance(address dst, uint256 amount) external returns (int128, int128);

    function outputNumeraire(address dst, int128 amount) external returns (uint256);

    function viewRawAmount(int128) external view returns (uint256);

    function viewRawAmountLPRatio(
        uint256,
        uint256,
        address,
        int128
    ) external view returns (uint256);

    function viewNumeraireAmount(uint256) external view returns (int128);

    function viewNumeraireBalanceLPRatio(
        uint256,
        uint256,
        address
    ) external view returns (int128);

    function viewNumeraireBalance(address) external view returns (int128);

    function viewNumeraireAmountAndBalance(address, uint256) external view returns (int128, int128);
}

// SPDX-License-Identifier: MIT

pragma solidity >=0.6.0 <0.8.0;

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

// SPDX-License-Identifier: MIT

// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.

// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.

// You should have received a copy of the GNU General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

pragma solidity ^0.7.3;

interface IOracle {
    function acceptOwnership() external;

    function accessController() external view returns (address);

    function aggregator() external view returns (address);

    function confirmAggregator(address _aggregator) external;

    function decimals() external view returns (uint8);

    function description() external view returns (string memory);

    function getAnswer(uint256 _roundId) external view returns (int256);

    function getRoundData(uint80 _roundId)
        external
        view
        returns (
            uint80 roundId,
            int256 answer,
            uint256 startedAt,
            uint256 updatedAt,
            uint80 answeredInRound
        );

    function getTimestamp(uint256 _roundId) external view returns (uint256);

    function latestAnswer() external view returns (int256);

    function latestRound() external view returns (uint256);

    function latestRoundData()
        external
        view
        returns (
            uint80 roundId,
            int256 answer,
            uint256 startedAt,
            uint256 updatedAt,
            uint80 answeredInRound
        );

    function latestTimestamp() external view returns (uint256);

    function owner() external view returns (address);

    function phaseAggregators(uint16) external view returns (address);

    function phaseId() external view returns (uint16);

    function proposeAggregator(address _aggregator) external;

    function proposedAggregator() external view returns (address);

    function proposedGetRoundData(uint80 _roundId)
        external
        view
        returns (
            uint80 roundId,
            int256 answer,
            uint256 startedAt,
            uint256 updatedAt,
            uint80 answeredInRound
        );

    function proposedLatestRoundData()
        external
        view
        returns (
            uint80 roundId,
            int256 answer,
            uint256 startedAt,
            uint256 updatedAt,
            uint80 answeredInRound
        );

    function setController(address _accessController) external;

    function transferOwnership(address _to) external;

    function version() external view returns (uint256);
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"getRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"int128","name":"_amount","type":"int128"}],"name":"intakeNumeraire","outputs":[{"internalType":"uint256","name":"amount_","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"},{"internalType":"int128","name":"_amount","type":"int128"}],"name":"intakeNumeraireLPRatio","outputs":[{"internalType":"uint256","name":"amount_","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"intakeRaw","outputs":[{"internalType":"int128","name":"amount_","type":"int128"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"intakeRawAndGetBalance","outputs":[{"internalType":"int128","name":"amount_","type":"int128"},{"internalType":"int128","name":"balance_","type":"int128"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_dst","type":"address"},{"internalType":"int128","name":"_amount","type":"int128"}],"name":"outputNumeraire","outputs":[{"internalType":"uint256","name":"amount_","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_dst","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"outputRaw","outputs":[{"internalType":"int128","name":"amount_","type":"int128"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_dst","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"outputRawAndGetBalance","outputs":[{"internalType":"int128","name":"amount_","type":"int128"},{"internalType":"int128","name":"balance_","type":"int128"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"viewNumeraireAmount","outputs":[{"internalType":"int128","name":"amount_","type":"int128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"viewNumeraireAmountAndBalance","outputs":[{"internalType":"int128","name":"amount_","type":"int128"},{"internalType":"int128","name":"balance_","type":"int128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"viewNumeraireBalance","outputs":[{"internalType":"int128","name":"balance_","type":"int128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"_addr","type":"address"}],"name":"viewNumeraireBalanceLPRatio","outputs":[{"internalType":"int128","name":"balance_","type":"int128"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"int128","name":"_amount","type":"int128"}],"name":"viewRawAmount","outputs":[{"internalType":"uint256","name":"amount_","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"uint256","name":"","type":"uint256"},{"internalType":"address","name":"","type":"address"},{"internalType":"int128","name":"_amount","type":"int128"}],"name":"viewRawAmountLPRatio","outputs":[{"internalType":"uint256","name":"amount_","type":"uint256"}],"stateMutability":"pure","type":"function"}]

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

809:4882:4:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4192:204;;;;;;;;;;;;;;;;-1:-1:-1;4192:204:4;;;;;;;;-1:-1:-1;;;;;4192:204:4;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;2119:324;;;;;;;;;;;;;;;;-1:-1:-1;2119:324:4;;;;:::i;5062:242::-;;;;;;;;;;;;;;;;-1:-1:-1;5062:242:4;;;;;;;;;;;-1:-1:-1;;;;;5062:242:4;;:::i;:::-;;;;;;;;;;;;;;;;;;;;5310:379;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;5310:379:4;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2799:527;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;2799:527:4;;;;;;;;:::i;1202:112::-;;;:::i;4002:184::-;;;;;;;;;;;;;;;;-1:-1:-1;4002:184:4;;;;:::i;3688:308::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;3688:308:4;;;;;;;;;;:::i;1320:467::-;;;;;;;;;;;;;;;;-1:-1:-1;1320:467:4;;:::i;4600:305::-;;;;;;;;;;;;;;;;-1:-1:-1;4600:305:4;-1:-1:-1;;;;;4600:305:4;;:::i;2449:344::-;;;;;;;;;;;;;;;;-1:-1:-1;2449:344:4;;;;;;;;-1:-1:-1;;;;;2449:344:4;;;;;;;;;;;;:::i;3332:350::-;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;3332:350:4;;;;;;;;:::i;4402:192::-;;;;;;;;;;;;;;;;-1:-1:-1;4402:192:4;;:::i;1793:320::-;;;;;;;;;;;;;;;;-1:-1:-1;1793:320:4;;:::i;4192:204::-;4335:15;4372:17;:12;;;;4385:3;4372:12;:17::i;:::-;4362:27;4192:204;-1:-1:-1;;;;;4192:204:4:o;2119:324::-;2187:15;2214:13;2230:9;:7;:9::i;:::-;2214:25;-1:-1:-1;2214:25:4;2261:17;:12;;;;2274:3;2261:12;:17::i;:::-;2281:3;2261:23;2260:33;;;;;2320:53;;;-1:-1:-1;;;2320:53:4;;2338:10;2320:53;;;;2358:4;2320:53;;;;2260:33;;;;2320:53;;;;;;;;2260:33;;-1:-1:-1;2304:13:4;;1064:42;;2320:17;;:53;;;;;;;;;;;;;;;2304:13;1064:42;2320:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2320:53:4;;-1:-1:-1;2320:53:4;2384:52;;;;;-1:-1:-1;;;2384:52:4;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2384:52:4;;;;;;;;;;;;;;;2119:324;;;;;:::o;5062:242::-;5194:15;5221:16;1064:42;-1:-1:-1;;;;;5240:14:4;;5255:5;5240:21;;;;;;;;;;;;;-1:-1:-1;;;;;5240:21:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;5240:21:4;;-1:-1:-1;5279:18:4;5240:21;5293:3;5279:13;:18::i;5310:379::-;5445:14;5461:15;5492:13;5508:9;:7;:9::i;:::-;5492:25;-1:-1:-1;5538:35:4;5569:3;5559;5540:15;;;5539:23;;;5538:30;:35::i;:::-;5528:45;;5584:16;1064:42;-1:-1:-1;;;;;5603:14:4;;5618:5;5603:21;;;;;;;;;;;;;-1:-1:-1;;;;;5603:21:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;5603:21:4;;-1:-1:-1;5646:36:4;5678:3;5668;5648:16;;;5647:24;;5646:36;5635:47;;5310:379;;;;;;;:::o;2799:527::-;2913:14;2929:15;2960:13;2976:9;:7;:9::i;:::-;2960:25;-1:-1:-1;2996:19:4;3039:3;3020:15;;;3019:23;2996:47;;3054:13;1064:42;-1:-1:-1;;;;;3070:13:4;;3084:4;3090:11;3070:32;;;;;;;;;;;;;-1:-1:-1;;;;;3070:32:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3070:32:4;;-1:-1:-1;3070:32:4;3113:47;;;;;-1:-1:-1;;;3113:47:4;;;;;;;;;;;;-1:-1:-1;;;3113:47:4;;;;;;;;;;;;;;;3190:29;;;-1:-1:-1;;;3190:29:4;;3213:4;3190:29;;;;;;3171:16;;1064:42;;3190:14;;:29;;;;;;;;;;;;;;;1064:42;3190:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3190:29:4;;-1:-1:-1;3240:21:4;:11;3257:3;3240:16;:21::i;:::-;3230:31;-1:-1:-1;3283:36:4;3315:3;3305;3285:16;;;3284:24;;3283:36;3272:47;;2799:527;;;;;;;;;:::o;1202:112::-;1251:7;977:42;-1:-1:-1;;;;;1285:19:4;;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1285:21:4;;-1:-1:-1;1202:112:4;:::o;4002:184::-;4073:15;4100:13;4116:9;:7;:9::i;:::-;4100:25;-1:-1:-1;4100:25:4;4147:17;:12;;;;4160:3;4147:12;:17::i;:::-;4167:3;4147:23;4146:33;;;;;;;4002:184;-1:-1:-1;;;4002:184:4:o;3688:308::-;3770:15;3797:13;3813:9;:7;:9::i;:::-;3797:25;-1:-1:-1;3797:25:4;3844:17;:12;;;;3857:3;3844:12;:17::i;:::-;3864:3;3844:23;3843:33;;;;;;3833:43;;3887:13;1064:42;-1:-1:-1;;;;;3903:13:4;;3917:4;3923:7;3903:28;;;;;;;;;;;;;-1:-1:-1;;;;;3903:28:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3903:28:4;;-1:-1:-1;3903:28:4;3942:47;;;;;-1:-1:-1;;;3942:47:4;;;;;;;;;;;;-1:-1:-1;;;3942:47:4;;;;;;;;;;;;;;;3688:308;;;;;;:::o;1320:467::-;1455:53;;;-1:-1:-1;;;1455:53:4;;1473:10;1455:53;;;;1493:4;1455:53;;;;;;;;;;;;1396:14;;;;;;1064:42;;1455:17;;:53;;;;;;;;;;;;;;;1396:14;1064:42;1455:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1455:53:4;;-1:-1:-1;1455:53:4;1519:52;;;;;-1:-1:-1;;;1519:52:4;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1519:52:4;;;;;;;;;;;;;;;1601:29;;;-1:-1:-1;;;1601:29:4;;1624:4;1601:29;;;;;;1582:16;;1064:42;;1601:14;;:29;;;;;;;;;;;;;;;1064:42;1601:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1601:29:4;;-1:-1:-1;1641:13:4;1657:9;:7;:9::i;:::-;1641:25;-1:-1:-1;1688:36:4;1720:3;1710;1690:16;;;1689:24;;1688:36;1677:47;-1:-1:-1;1745:35:4;1776:3;1766;1747:15;;;1746:23;;1745:35;1735:45;;1320:467;;;;;;:::o;4600:305::-;4675:15;4702:13;4718:9;:7;:9::i;:::-;4702:25;;4738:16;1064:42;-1:-1:-1;;;;;4757:14:4;;4772:5;4757:21;;;;;;;;;;;;;-1:-1:-1;;;;;4757:21:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;4757:21:4;;-1:-1:-1;4793:13:4;4789:51;;4815:25;4838:1;4815:22;:25::i;:::-;4808:32;;;;;;4789:51;4862:36;4894:3;4884;4864:16;;;4863:24;;4862:36;4851:47;;4600:305;;;;;;:::o;2449:344::-;2589:15;2626:17;:12;;;;2639:3;2626:12;:17::i;:::-;2670:53;;;-1:-1:-1;;;2670:53:4;;2688:10;2670:53;;;;2708:4;2670:53;;;;;;;;;;;;2616:27;;-1:-1:-1;2654:13:4;;1064:42;;2670:17;;:53;;;;;;;;;;;;;;2654:13;1064:42;2670:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2670:53:4;;-1:-1:-1;2670:53:4;2734:52;;;;;-1:-1:-1;;;2734:52:4;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2734:52:4;;;;;;;;;;;;;;;2449:344;;;;;;;:::o;3332:350::-;3409:14;3435:13;3451:9;:7;:9::i;:::-;3435:25;-1:-1:-1;3471:19:4;3513:3;3494:15;;;3493:23;3471:45;;3527:13;1064:42;-1:-1:-1;;;;;3543:13:4;;3557:4;3563:11;3543:32;;;;;;;;;;;;;-1:-1:-1;;;;;3543:32:4;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3543:32:4;;-1:-1:-1;3543:32:4;3586:47;;;;;-1:-1:-1;;;3586:47:4;;;;;;;;;;;;-1:-1:-1;;;3586:47:4;;;;;;;;;;;;;;;3654:21;:11;3671:3;3654:16;:21::i;:::-;3644:31;3332:350;-1:-1:-1;;;;;;3332:350:4:o;4402:192::-;4480:14;4506:13;4522:9;:7;:9::i;:::-;4506:25;-1:-1:-1;4552:35:4;4583:3;4573;4554:15;;;4553:23;;4552:35;4542:45;4402:192;-1:-1:-1;;;4402:192:4:o;1793:320::-;1898:53;;;-1:-1:-1;;;1898:53:4;;1916:10;1898:53;;;;1936:4;1898:53;;;;;;;;;;;;1856:14;;;;1064:42;;1898:17;;:53;;;;;;;;;;;;;;1856:14;1064:42;1898:53;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;1898:53:4;;-1:-1:-1;1898:53:4;1962:52;;;;;-1:-1:-1;;;1962:52:4;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;1962:52:4;;;;;;;;;;;;;;;2025:13;2041:9;:7;:9::i;:::-;2025:25;-1:-1:-1;2071:35:4;2102:3;2092;2073:15;;;2072:23;;5938:455:0;5997:7;6016:6;6012:20;;-1:-1:-1;6031:1:0;6024:8;;6012:20;6053:1;6048;:6;;;;6039:16;;;;;;6076:11;;;;-1:-1:-1;;;;;6091:38:0;;6076:54;;6135:2;6075:62;;6176:3;6171:8;;;6156:24;-1:-1:-1;;;;;6196:56:0;;;6187:66;;;;;;6266:2;6259:9;6296:71;;6284:83;;;6275:93;;;;;;6381:7;;-1:-1:-1;5938:455:0;;;;;:::o;8214:203::-;8274:6;8297;8288:16;;;;;;8310:14;8327:12;8334:1;8337;8327:5;:12::i;:::-;8310:29;-1:-1:-1;958:34:0;-1:-1:-1;;;;;8354:29:0;;;;8345:39;;;;;1908:134;1961:6;1989:18;1984:1;:23;;1975:33;;;;;;-1:-1:-1;2034:2:0;2029:7;;1908:134::o;20427:1218::-;20487:7;20511:6;20502:16;;;;;;20525:14;-1:-1:-1;;;;;20550:1:0;:55;20546:1005;;20634:1;20628:2;20623:1;:7;;20622:13;;;;;;20613:22;;20546:1005;;;20668:3;20692:8;;;20718:11;20712:17;;20708:48;;20740:2;20744:9;;;;20733;20708:48;20773:7;20767:2;:13;20763:44;;20791:2;20795:9;;;;20784;20763:44;20824:5;20818:2;:11;20814:40;;20840:1;20843:8;;;;20833;20814:40;20871:4;20865:2;:10;20861:39;;20886:1;20889:8;;;;20879;20861:39;20917:3;20911:2;:9;20907:38;;20931:1;20934:8;;;;20924;20907:38;20962:3;20956:2;:9;20952:23;;20974:1;20967:8;;;;20952:23;21061:3;21055;:9;21050:1;21046;:5;:18;;21068:1;21045:24;21037:3;21031;:9;21026:1;:14;;21025:45;;;;;;21016:54;;-1:-1:-1;;;;;21087:6:0;:44;;21078:54;;;;;;21169:3;21164:8;;;21154:19;;-1:-1:-1;;;;;21204:38:0;;21194:49;;21270:3;21265:8;;;21299:2;21294:7;;;21314;;;21310:20;;;21329:1;21323:7;;;;21310:20;21402:3;21396:9;;;;21338:8;;21417:7;;;21413:20;;;21432:1;21426:7;;;;21413:20;21441:8;;;21515:3;21509:9;;;21503:15;;21495:24;;;;21543:1;21538:2;:6;;;;;;21528:16;;;;20546:1005;;;;;;;-1:-1:-1;;;;;21566:6:0;:44;;21557:54;;;;

ipfs://fcd6b00b36523405ba8a47bd9351ba3ba40c8e095259f8bc5aa112aebac2758a