Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;

/* ========== External Interfaces ========== */
import "@indexed-finance/uniswap-v2-oracle/contracts/interfaces/IIndexedUniswapV2Oracle.sol";
import "@openzeppelin/contracts/token/ERC20/IERC20.sol";

/* ========== External Libraries ========== */
import "@openzeppelin/contracts/math/SafeMath.sol";
import { SafeERC20 } from "@openzeppelin/contracts/token/ERC20/SafeERC20.sol";

/* ========== Internal Interfaces ========== */
import "./interfaces/IPoolInitializer.sol";


/**
 * @title SigmaPoolInitializerV1
 * @author d1ll0n
 * @dev Contract that acquires the initial balances for an index pool.
 *
 * This uses a short-term UniSwap price oracle to determine the ether
 * value of tokens sent to the contract. When users contribute tokens,
 * they are credited for the moving average ether value of said tokens.
 * When all the tokens needed are acquired, the index pool will be
 * initialized and this contract will receive the initial token supply (100).
 *
 * Once the contract receives the index pool tokens, users can claim their
 * share of the tokens proportional to their credited contribution value.
 */
contract SigmaPoolInitializerV1 is IPoolInitializer {
  using SafeMath for uint256;
  using SafeERC20 for IERC20;

/* ==========  Constants  ========== */

  uint32 internal constant SHORT_TWAP_MIN_TIME_ELAPSED = 20 minutes;
  uint32 internal constant SHORT_TWAP_MAX_TIME_ELAPSED = 2 days;
  uint256 internal constant TOKENS_MINTED = 1e20;

  IIndexedUniswapV2Oracle public immutable oracle;

/* ==========  Events  ========== */

  event TokensContributed(
    address from,
    address token,
    uint256 amount,
    uint256 credit
  );

  event TokensClaimed(address account, uint256 tokens);

/* ==========  Storage  ========== */
  // Token amounts to purchase
  mapping(address => uint256) internal _remainingDesiredAmounts;
  // Value contributed in ether
  mapping(address => uint256) internal _credits;
  address[] internal _tokens;

  // Address of the pool controller
  address public controller;
  // Total value in ether contributed to the pool, computed at the time
  // of receipt.
  uint256 internal _totalCredit;
  // Whether all the desired tokens have been received.
  bool internal _finished;
  address internal _poolAddress;
  bool internal _mutex;

/* ==========  Modifiers  ========== */

  modifier _lock_ {
    require(!_mutex, "ERR_REENTRY");
    _mutex = true;
    _;
    _mutex = false;
  }

  modifier _finished_ {
    require(_finished, "ERR_NOT_FINISHED");
    _;
  }

  modifier _not_finished_ {
    require(!_finished, "ERR_FINISHED");
    _;
  }

/* ==========  Constructor  ========== */

  constructor(IIndexedUniswapV2Oracle oracle_) public {
    oracle = oracle_;
  }

/* ==========  Start & Finish Functions  ========== */

  /**
   * @dev Sets up the pre-deployment pool.
   *
   * @param controller_ Address of the pool controller
   * @param poolAddress Address of the pool this pre-deployment pool is for
   * @param tokens Array of desired tokens
   * @param amounts Desired amounts of the corresponding `tokens`
   */
  function initialize(
    address controller_,
    address poolAddress,
    address[] calldata tokens,
    uint256[] calldata amounts
  )
    external
    override
  {
    require(_poolAddress == address(0), "ERR_INITIALIZED");
    _poolAddress = poolAddress;
    controller = controller_;
    uint256 len = tokens.length;
    require(amounts.length == len, "ERR_ARR_LEN");
    _tokens = tokens;
    for (uint256 i = 0; i < len; i++) {
      _remainingDesiredAmounts[tokens[i]] = amounts[i];
    }
  }

  /**
   * @dev Finishes the pre-deployment pool and triggers pool initialization.
   *
   * Note: The desired amounts of all tokens must be 0.
  */
  function finish()
    external
    override
    _lock_
    _not_finished_
  {
    uint256 len = _tokens.length;
    address controller_ = controller;
    address[] memory tokens = new address[](len);
    uint256[] memory balances = new uint256[](len);
    for (uint256 i = 0; i < len; i++) {
      address token = _tokens[i];
      tokens[i] = token;
      uint256 balance = IERC20(token).balanceOf(address(this));
      balances[i] = balance;
      IERC20(token).safeApprove(_poolAddress, balance);
      require(
        _remainingDesiredAmounts[token] == 0,
        "ERR_PENDING_TOKENS"
      );
    }
    PoolController(controller_).finishPreparedIndexPool(
      _poolAddress,
      tokens,
      balances
    );
    _finished = true;
  }

/* ==========  Pool Token Claims  ========== */

  /**
   * @dev Claims the tokens owed to `msg.sender` based on their proportion
   * of the total credits.
  */
  function claimTokens() external override _lock_ _finished_ {
    _claimTokens(msg.sender);
  }

  /**
   * @dev Claims the tokens owed to `account` based on their proportion
   * of the total credits.
  */
  function claimTokens(address account) external override _lock_ _finished_ {
    _claimTokens(account);
  }

  /**
   * @dev Claims the tokens owed to `account` based on their proportion
   * of the total credits.
  */
  function claimTokens(address[] calldata accounts) external override _lock_ _finished_ {
    for (uint256 i = 0; i < accounts.length; i++) {
      _claimTokens(accounts[i]);
    }
  }

/* ==========  Contribution  ========== */

  /**
   * @dev Contribute up to `amountIn` of `token` to the pool for credit.
   * The caller will be credited for the average weth value of the provided
   * tokens.
   *
   * Caller must receive at least `minimumCredit` to not revert.
   *
   * If `amountIn` is greater than the desired amount of `token`, the
   * desired amount will be used instead.
   */
  function contributeTokens(
    address token,
    uint256 amountIn,
    uint256 minimumCredit
  )
    external
    override
    _lock_
    _not_finished_
    returns (uint256 credit)
  {
    uint256 desiredAmount = _remainingDesiredAmounts[token];
    require(desiredAmount > 0, "ERR_NOT_NEEDED");
    if (amountIn > desiredAmount) {
      amountIn = desiredAmount;
    }
    credit = oracle.computeAverageEthForTokens(
      token,
      amountIn,
      SHORT_TWAP_MIN_TIME_ELAPSED,
      SHORT_TWAP_MAX_TIME_ELAPSED
    );
    require(credit > 0 && amountIn > 0, "ERR_ZERO_AMOUNT");
    require(credit >= minimumCredit, "ERR_MIN_CREDIT");
    IERC20(token).safeTransferFrom(msg.sender, address(this), amountIn);
    _remainingDesiredAmounts[token] = desiredAmount.sub(amountIn);
    _credits[msg.sender] = _credits[msg.sender].add(credit);
    _totalCredit = _totalCredit.add(credit);
    emit TokensContributed(msg.sender, token, amountIn, credit);
  }

  /**
   * @dev Contribute maximum values from `amountsIn` of the corresponding
   * tokens in `tokens` to the pool for credit.
   *
   * The caller will be credited for the average weth value of the provided
   * tokens.
   *
   * Caller must receive at least `minimumCredit` to not revert.
   *
   * If any input amount is greater than the desired amount of the corresponding
   * token, the desired amount will be used instead.
   */
  function contributeTokens(
    address[] calldata tokens,
    uint256[] calldata amountsIn,
    uint256 minimumCredit
  )
    external
    override
    _lock_
    _not_finished_
    returns (uint256 credit)
  {
    uint256 len = tokens.length;
    require(amountsIn.length == len, "ERR_ARR_LEN");
    credit = 0;
    for (uint256 i = 0; i < len; i++) {
      address token = tokens[i];
      uint256 amountIn = amountsIn[i];
      uint256 desiredAmount = _remainingDesiredAmounts[token];
      require(desiredAmount > 0, "ERR_NOT_NEEDED");
      if (amountIn > desiredAmount) {
        amountIn = desiredAmount;
      }
      uint256 creditOut = oracle.computeAverageEthForTokens(
        token,
        amountIn,
        SHORT_TWAP_MIN_TIME_ELAPSED,
        SHORT_TWAP_MAX_TIME_ELAPSED
      );
      require(creditOut > 0 && amountIn > 0, "ERR_ZERO_AMOUNT");
      IERC20(token).safeTransferFrom(msg.sender, address(this), amountIn);
      _remainingDesiredAmounts[token] = desiredAmount.sub(amountIn);
      credit = credit.add(creditOut);
      emit TokensContributed(msg.sender, token, amountIn, creditOut);
    }
    require(credit >= minimumCredit, "ERR_MIN_CREDIT");
    _credits[msg.sender] = _credits[msg.sender].add(credit);
    _totalCredit = _totalCredit.add(credit);
  }

/* ==========  Price Actions  ========== */

  /**
   * @dev Updates the prices of all tokens.
   */
  function updatePrices() external override {
    oracle.updatePrices(_tokens);
  }

/* ==========  Status Queries  ========== */

  /**
   * @dev Returns whether the pool has been initialized.
   */
  function isFinished() external view override returns (bool) {
    return _finished;
  }

/* ==========  Status Queries  ========== */

  /**
   * @dev Returns the total value credited for token contributions.
   */
  function getTotalCredit() external view override returns (uint256) {
    return _totalCredit;
  }

  /**
   * @dev Returns the amount of credit owed to `account`.
   */
  function getCreditOf(address account)
    external
    view
    override
    returns (uint256)
  {
    return _credits[account];
  }

/* ==========  Token Queries  ========== */

  function getDesiredTokens()
    external
    view
    override
    returns (address[] memory tokens)
  {
    tokens = _tokens;
  }

  function getDesiredAmount(address token)
    external
    view
    override
    returns (uint256)
  {
    return _remainingDesiredAmounts[token];
  }

  function getDesiredAmounts(address[] calldata tokens)
    external
    view
    override
    returns (uint256[] memory amounts)
  {
    amounts = new uint256[](tokens.length);
    for (uint256 i = 0; i < tokens.length; i++) {
      amounts[i] = _remainingDesiredAmounts[tokens[i]];
    }
  }

/* ==========  External Price Queries ========== */
  /**
   * @dev Get the amount of WETH the contract will credit a user
   * for providing `amountIn` of `token`.
   *
   * Note: If `amountIn` is greater than the desired amount of
   * `token`, this will calculate the output using the desired
   * amount instead of `amountIn`.
   */
  function getCreditForTokens(address token, uint256 amountIn)
    external
    view
    override
    returns (uint144 amountOut)
  {
    uint256 desiredAmount = _remainingDesiredAmounts[token];
    require(desiredAmount > 0, "ERR_NOT_NEEDED");
    if (amountIn > desiredAmount) {
      amountIn = desiredAmount;
    }
    uint144 averageWethValue = oracle.computeAverageEthForTokens(
      token,
      amountIn,
      SHORT_TWAP_MIN_TIME_ELAPSED,
      SHORT_TWAP_MAX_TIME_ELAPSED
    );
    amountOut = averageWethValue;
  }

/* ==========  Internal Claims Functions  ========== */

  /**
   * @dev Claims pool tokens owed to `account` based on their
   * proportion of the total credit.
   * Note: Must be called in a function with the `_finished` modifier.
   * Note: Must be called in a function with the `_lock_` modifier.
   */
  function _claimTokens(address account) internal {
    uint256 credit = _credits[account];
    require(credit > 0, "ERR_NULL_CREDIT");
    uint256 amountOut = (TOKENS_MINTED.mul(credit)).div(_totalCredit);
    _credits[account] = 0;
    IERC20(_poolAddress).safeTransfer(account, amountOut);
    emit TokensClaimed(account, amountOut);
  }
}


interface PoolController {
  function finishPreparedIndexPool(
    address poolAddress,
    address[] calldata tokens,
    uint256[] calldata balances
  ) external;
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.0;


interface IPoolInitializer {
/* ========== Events ========== */

  event TokensContributed(
    address from,
    address token,
    uint256 amount,
    uint256 credit
  );

/* ========== Mutative ========== */

  function initialize(
    address controller,
    address poolAddress,
    address[] calldata tokens,
    uint256[] calldata amounts
  ) external;

  function finish() external;

  function claimTokens() external;

  function claimTokens(address account) external;

  function claimTokens(address[] calldata accounts) external;

  function contributeTokens(
    address token,
    uint256 amountIn,
    uint256 minimumCredit
  ) external returns (uint256);

  function contributeTokens(
    address[] calldata tokens,
    uint256[] calldata amountsIn,
    uint256 minimumCredit
  ) external returns (uint256);

  function updatePrices() external;

/* ========== Views ========== */

  function isFinished() external view returns (bool);

  function getTotalCredit() external view returns (uint256);

  function getCreditOf(address account) external view returns (uint256);

  function getDesiredTokens() external view returns (address[] memory);

  function getDesiredAmount(address token) external view returns (uint256);

  function getDesiredAmounts(address[] calldata tokens) external view returns (uint256[] memory);

  function getCreditForTokens(address token, uint256 amountIn) external view returns (uint144);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;

/* ==========  Libraries  ========== */
import "../lib/PriceLibrary.sol";
import "../lib/FixedPoint.sol";


interface IIndexedUniswapV2Oracle {
/* ==========  Mutative Functions  ========== */

  function updatePrice(address token) external returns (bool);

  function updatePrices(address[] calldata tokens) external returns (bool[] memory);

/* ==========  Meta Price Queries  ========== */

  function hasPriceObservationInWindow(address token, uint256 priceKey) external view returns (bool);

  function getPriceObservationInWindow(
    address token, uint256 priceKey
  ) external view returns (PriceLibrary.PriceObservation memory);

  function getPriceObservationsInRange(
    address token, uint256 timeFrom, uint256 timeTo
  ) external view returns (PriceLibrary.PriceObservation[] memory prices);

/* ==========  Price Update Queries  ========== */

  function canUpdatePrice(address token) external view returns (bool);

  function canUpdatePrices(address[] calldata tokens) external view returns (bool[] memory);

/* ==========  Price Queries: Singular  ========== */

  function computeTwoWayAveragePrice(
    address token, uint256 minTimeElapsed, uint256 maxTimeElapsed
  ) external view returns (PriceLibrary.TwoWayAveragePrice memory);

  function computeAverageTokenPrice(
    address token, uint256 minTimeElapsed, uint256 maxTimeElapsed
  ) external view returns (FixedPoint.uq112x112 memory);

  function computeAverageEthPrice(
    address token, uint256 minTimeElapsed, uint256 maxTimeElapsed
  ) external view returns (FixedPoint.uq112x112 memory);

/* ==========  Price Queries: Multiple  ========== */

  function computeTwoWayAveragePrices(
    address[] calldata tokens,
    uint256 minTimeElapsed,
    uint256 maxTimeElapsed
  ) external view returns (PriceLibrary.TwoWayAveragePrice[] memory);

  function computeAverageTokenPrices(
    address[] calldata tokens,
    uint256 minTimeElapsed,
    uint256 maxTimeElapsed
  ) external view returns (FixedPoint.uq112x112[] memory);

  function computeAverageEthPrices(
    address[] calldata tokens,
    uint256 minTimeElapsed,
    uint256 maxTimeElapsed
  ) external view returns (FixedPoint.uq112x112[] memory);

/* ==========  Value Queries: Singular  ========== */

  function computeAverageEthForTokens(
    address token,
    uint256 tokenAmount,
    uint256 minTimeElapsed,
    uint256 maxTimeElapsed
  ) external view returns (uint144);

  function computeAverageTokensForEth(
    address token,
    uint256 wethAmount,
    uint256 minTimeElapsed,
    uint256 maxTimeElapsed
  ) external view returns (uint144);

/* ==========  Value Queries: Multiple  ========== */

  function computeAverageEthForTokens(
    address[] calldata tokens,
    uint256[] calldata tokenAmounts,
    uint256 minTimeElapsed,
    uint256 maxTimeElapsed
  ) external view returns (uint144[] memory);

  function computeAverageTokensForEth(
    address[] calldata tokens,
    uint256[] calldata wethAmounts,
    uint256 minTimeElapsed,
    uint256 maxTimeElapsed
  ) external view returns (uint144[] memory);
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.0;
pragma experimental ABIEncoderV2;

/* ==========  Internal Libraries  ========== */
import "./FixedPoint.sol";
import "./UniswapV2OracleLibrary.sol";
import "./UniswapV2Library.sol";


library PriceLibrary {
  using FixedPoint for FixedPoint.uq112x112;
  using FixedPoint for FixedPoint.uq144x112;

/* ========= Structs ========= */

  struct PriceObservation {
    uint32 timestamp;
    uint224 priceCumulativeLast;
    uint224 ethPriceCumulativeLast;
  }

  /**
   * @dev Average prices for a token in terms of weth and weth in terms of the token.
   *
   * Note: The average weth price is not equivalent to the reciprocal of the average
   * token price. See the UniSwap whitepaper for more info.
   */
  struct TwoWayAveragePrice {
    uint224 priceAverage;
    uint224 ethPriceAverage;
  }

/* ========= View Functions ========= */

  function pairInitialized(
    address uniswapFactory,
    address token,
    address weth
  )
    internal
    view
    returns (bool)
  {
    address pair = UniswapV2Library.pairFor(uniswapFactory, token, weth);
    (uint112 reserve0, uint112 reserve1,) = IUniswapV2Pair(pair).getReserves();
    return reserve0 != 0 && reserve1 != 0;
  }

  function observePrice(
    address uniswapFactory,
    address tokenIn,
    address quoteToken
  )
    internal
    view
    returns (uint32 /* timestamp */, uint224 /* priceCumulativeLast */)
  {
    (address token0, address token1) = UniswapV2Library.sortTokens(tokenIn, quoteToken);
    address pair = UniswapV2Library.calculatePair(uniswapFactory, token0, token1);
    if (token0 == tokenIn) {
      (uint256 price0Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrice0(pair);
      return (blockTimestamp, uint224(price0Cumulative));
    } else {
      (uint256 price1Cumulative, uint32 blockTimestamp) = UniswapV2OracleLibrary.currentCumulativePrice1(pair);
      return (blockTimestamp, uint224(price1Cumulative));
    }
  }

  /**
   * @dev Query the current cumulative price of a token in terms of weth
   * and the current cumulative price of weth in terms of the token.
   */
  function observeTwoWayPrice(
    address uniswapFactory,
    address token,
    address weth
  ) internal view returns (PriceObservation memory) {
    (address token0, address token1) = UniswapV2Library.sortTokens(token, weth);
    address pair = UniswapV2Library.calculatePair(uniswapFactory, token0, token1);
    // Get the sorted token prices
    (
      uint256 price0Cumulative,
      uint256 price1Cumulative,
      uint32 blockTimestamp
    ) = UniswapV2OracleLibrary.currentCumulativePrices(pair);
    // Check which token is weth and which is the token,
    // then build the price observation.
    if (token0 == token) {
      return PriceObservation({
        timestamp: blockTimestamp,
        priceCumulativeLast: uint224(price0Cumulative),
        ethPriceCumulativeLast: uint224(price1Cumulative)
      });
    } else {
      return PriceObservation({
        timestamp: blockTimestamp,
        priceCumulativeLast: uint224(price1Cumulative),
        ethPriceCumulativeLast: uint224(price0Cumulative)
      });
    }
  }

/* ========= Utility Functions ========= */

  /**
   * @dev Computes the average price of a token in terms of weth
   * and the average price of weth in terms of a token using two
   * price observations.
   */
  function computeTwoWayAveragePrice(
    PriceObservation memory observation1,
    PriceObservation memory observation2
  ) internal pure returns (TwoWayAveragePrice memory) {
    uint32 timeElapsed = uint32(observation2.timestamp - observation1.timestamp);
    FixedPoint.uq112x112 memory priceAverage = UniswapV2OracleLibrary.computeAveragePrice(
      observation1.priceCumulativeLast,
      observation2.priceCumulativeLast,
      timeElapsed
    );
    FixedPoint.uq112x112 memory ethPriceAverage = UniswapV2OracleLibrary.computeAveragePrice(
      observation1.ethPriceCumulativeLast,
      observation2.ethPriceCumulativeLast,
      timeElapsed
    );
    return TwoWayAveragePrice({
      priceAverage: priceAverage._x,
      ethPriceAverage: ethPriceAverage._x
    });
  }

  function computeAveragePrice(
    uint32 timestampStart,
    uint224 priceCumulativeStart,
    uint32 timestampEnd,
    uint224 priceCumulativeEnd
  ) internal pure returns (FixedPoint.uq112x112 memory) {
    return UniswapV2OracleLibrary.computeAveragePrice(
      priceCumulativeStart,
      priceCumulativeEnd,
      uint32(timestampEnd - timestampStart)
    );
  }

  /**
   * @dev Computes the average price of the token the price observations
   * are for in terms of weth.
   */
  function computeAverageTokenPrice(
    PriceObservation memory observation1,
    PriceObservation memory observation2
  ) internal pure returns (FixedPoint.uq112x112 memory) {
    return UniswapV2OracleLibrary.computeAveragePrice(
      observation1.priceCumulativeLast,
      observation2.priceCumulativeLast,
      uint32(observation2.timestamp - observation1.timestamp)
    );
  }

  /**
   * @dev Computes the average price of weth in terms of the token
   * the price observations are for.
   */
  function computeAverageEthPrice(
    PriceObservation memory observation1,
    PriceObservation memory observation2
  ) internal pure returns (FixedPoint.uq112x112 memory) {
    return UniswapV2OracleLibrary.computeAveragePrice(
      observation1.ethPriceCumulativeLast,
      observation2.ethPriceCumulativeLast,
      uint32(observation2.timestamp - observation1.timestamp)
    );
  }

  /**
   * @dev Compute the average value in weth of `tokenAmount` of the
   * token that the average price values are for.
   */
  function computeAverageEthForTokens(
    TwoWayAveragePrice memory prices,
    uint256 tokenAmount
  ) internal pure returns (uint144) {
    return FixedPoint.uq112x112(prices.priceAverage).mul(tokenAmount).decode144();
  }

  /**
   * @dev Compute the average value of `wethAmount` weth in terms of
   * the token that the average price values are for.
   */
  function computeAverageTokensForEth(
    TwoWayAveragePrice memory prices,
    uint256 wethAmount
  ) internal pure returns (uint144) {
    return FixedPoint.uq112x112(prices.ethPriceAverage).mul(wethAmount).decode144();
  }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.0;


/************************************************************************************************
From https://github.com/Uniswap/uniswap-lib/blob/master/contracts/libraries/FixedPoint.sol

Copied from the github repository at commit hash 9642a0705fdaf36b477354a4167a8cd765250860.

Modifications:
- Removed `sqrt` function

Subject to the GPL-3.0 license
*************************************************************************************************/


// a library for handling binary fixed point numbers (https://en.wikipedia.org/wiki/Q_(number_format))
library FixedPoint {
  // range: [0, 2**112 - 1]
  // resolution: 1 / 2**112
  struct uq112x112 {
    uint224 _x;
  }

  // range: [0, 2**144 - 1]
  // resolution: 1 / 2**112
  struct uq144x112 {
    uint _x;
  }

  uint8 private constant RESOLUTION = 112;
  uint private constant Q112 = uint(1) << RESOLUTION;
  uint private constant Q224 = Q112 << RESOLUTION;

  // encode a uint112 as a UQ112x112
  function encode(uint112 x) internal pure returns (uq112x112 memory) {
    return uq112x112(uint224(x) << RESOLUTION);
  }

  // encodes a uint144 as a UQ144x112
  function encode144(uint144 x) internal pure returns (uq144x112 memory) {
    return uq144x112(uint256(x) << RESOLUTION);
  }

  // divide a UQ112x112 by a uint112, returning a UQ112x112
  function div(uq112x112 memory self, uint112 x) internal pure returns (uq112x112 memory) {
    require(x != 0, "FixedPoint: DIV_BY_ZERO");
    return uq112x112(self._x / uint224(x));
  }

  // multiply a UQ112x112 by a uint, returning a UQ144x112
  // reverts on overflow
  function mul(uq112x112 memory self, uint y) internal pure returns (uq144x112 memory) {
    uint z;
    require(
      y == 0 || (z = uint(self._x) * y) / y == uint(self._x),
      "FixedPoint: MULTIPLICATION_OVERFLOW"
    );
    return uq144x112(z);
  }

  // returns a UQ112x112 which represents the ratio of the numerator to the denominator
  // equivalent to encode(numerator).div(denominator)
  function fraction(uint112 numerator, uint112 denominator) internal pure returns (uq112x112 memory) {
    require(denominator > 0, "FixedPoint: DIV_BY_ZERO");
    return uq112x112((uint224(numerator) << RESOLUTION) / denominator);
  }

  // decode a UQ112x112 into a uint112 by truncating after the radix point
  function decode(uq112x112 memory self) internal pure returns (uint112) {
    return uint112(self._x >> RESOLUTION);
  }

  // decode a UQ144x112 into a uint144 by truncating after the radix point
  function decode144(uq144x112 memory self) internal pure returns (uint144) {
    return uint144(self._x >> RESOLUTION);
  }

  // take the reciprocal of a UQ112x112
  function reciprocal(uq112x112 memory self) internal pure returns (uq112x112 memory) {
    require(self._x != 0, "FixedPoint: ZERO_RECIPROCAL");
    return uq112x112(uint224(Q224 / self._x));
  }
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.0;

/* ==========  Internal Interfaces  ========== */
import "@uniswap/v2-core/contracts/interfaces/IUniswapV2Pair.sol";

/* ==========  Internal Libraries  ========== */
import "./FixedPoint.sol";


/************************************************************************************************
Originally from https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/libraries/UniswapV2OracleLibrary.sol

This source code has been modified from the original, which was copied from the github repository
at commit hash 6d03bede0a97c72323fa1c379ed3fdf7231d0b26.

Subject to the GPL-3.0 license
*************************************************************************************************/


// library with helper methods for oracles that are concerned with computing average prices
library UniswapV2OracleLibrary {
  using FixedPoint for *;

  // helper function that returns the current block timestamp within the range of uint32, i.e. [0, 2**32 - 1]
  function currentBlockTimestamp() internal view returns (uint32) {
    return uint32(block.timestamp % 2**32);
  }

  // produces the cumulative prices using counterfactuals to save gas and avoid a call to sync.
  function currentCumulativePrices(address pair)
    internal
    view
    returns (
      uint256 price0Cumulative,
      uint256 price1Cumulative,
      uint32 blockTimestamp
    )
  {
    blockTimestamp = currentBlockTimestamp();
    price0Cumulative = IUniswapV2Pair(pair).price0CumulativeLast();
    price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast();

    // if time has elapsed since the last update on the pair, mock the accumulated price values
    (
      uint112 reserve0,
      uint112 reserve1,
      uint32 blockTimestampLast
    ) = IUniswapV2Pair(pair).getReserves();
    require(
      reserve0 != 0 && reserve1 != 0,
      "UniswapV2OracleLibrary::currentCumulativePrices: Pair has no reserves."
    );
    if (blockTimestampLast != blockTimestamp) {
      // subtraction overflow is desired
      uint32 timeElapsed = blockTimestamp - blockTimestampLast;
      // addition overflow is desired
      // counterfactual
      price0Cumulative += (
        uint256(FixedPoint.fraction(reserve1, reserve0)._x) *
        timeElapsed
      );
      // counterfactual
      price1Cumulative += (
        uint256(FixedPoint.fraction(reserve0, reserve1)._x) *
        timeElapsed
      );
    }
  }

  // produces the cumulative price using counterfactuals to save gas and avoid a call to sync.
  // only gets the first price
  function currentCumulativePrice0(address pair)
    internal
    view
    returns (uint256 price0Cumulative, uint32 blockTimestamp)
  {
    blockTimestamp = currentBlockTimestamp();
    price0Cumulative = IUniswapV2Pair(pair).price0CumulativeLast();

    // if time has elapsed since the last update on the pair, mock the accumulated price values
    (
      uint112 reserve0,
      uint112 reserve1,
      uint32 blockTimestampLast
    ) = IUniswapV2Pair(pair).getReserves();
    require(
      reserve0 != 0 && reserve1 != 0,
      "UniswapV2OracleLibrary::currentCumulativePrice0: Pair has no reserves."
    );
    if (blockTimestampLast != blockTimestamp) {
      // subtraction overflow is desired
      uint32 timeElapsed = blockTimestamp - blockTimestampLast;
      // addition overflow is desired
      // counterfactual
      price0Cumulative += (
        uint256(FixedPoint.fraction(reserve1, reserve0)._x) *
        timeElapsed
      );
    }
  }

  // produces the cumulative price using counterfactuals to save gas and avoid a call to sync.
  // only gets the second price
  function currentCumulativePrice1(address pair)
    internal
    view
    returns (uint256 price1Cumulative, uint32 blockTimestamp)
  {
    blockTimestamp = currentBlockTimestamp();
    price1Cumulative = IUniswapV2Pair(pair).price1CumulativeLast();

    // if time has elapsed since the last update on the pair, mock the accumulated price values
    (
      uint112 reserve0,
      uint112 reserve1,
      uint32 blockTimestampLast
    ) = IUniswapV2Pair(pair).getReserves();
    require(
      reserve0 != 0 && reserve1 != 0,
      "UniswapV2OracleLibrary::currentCumulativePrice1: Pair has no reserves."
    );
    if (blockTimestampLast != blockTimestamp) {
      // subtraction overflow is desired
      uint32 timeElapsed = blockTimestamp - blockTimestampLast;
      // addition overflow is desired
      // counterfactual
      price1Cumulative += (
        uint256(FixedPoint.fraction(reserve0, reserve1)._x) *
        timeElapsed
      );
    }
  }

  function computeAveragePrice(
    uint224 priceCumulativeStart,
    uint224 priceCumulativeEnd,
    uint32 timeElapsed
  ) internal pure returns (FixedPoint.uq112x112 memory priceAverage) {
    // overflow is desired.
    priceAverage = FixedPoint.uq112x112(
      uint224((priceCumulativeEnd - priceCumulativeStart) / timeElapsed)
    );
  }
}

pragma solidity >=0.5.0;

interface IUniswapV2Pair {
    event Approval(address indexed owner, address indexed spender, uint value);
    event Transfer(address indexed from, address indexed to, uint value);

    function name() external pure returns (string memory);
    function symbol() external pure returns (string memory);
    function decimals() external pure returns (uint8);
    function totalSupply() external view returns (uint);
    function balanceOf(address owner) external view returns (uint);
    function allowance(address owner, address spender) external view returns (uint);

    function approve(address spender, uint value) external returns (bool);
    function transfer(address to, uint value) external returns (bool);
    function transferFrom(address from, address to, uint value) external returns (bool);

    function DOMAIN_SEPARATOR() external view returns (bytes32);
    function PERMIT_TYPEHASH() external pure returns (bytes32);
    function nonces(address owner) external view returns (uint);

    function permit(address owner, address spender, uint value, uint deadline, uint8 v, bytes32 r, bytes32 s) external;

    event Mint(address indexed sender, uint amount0, uint amount1);
    event Burn(address indexed sender, uint amount0, uint amount1, address indexed to);
    event Swap(
        address indexed sender,
        uint amount0In,
        uint amount1In,
        uint amount0Out,
        uint amount1Out,
        address indexed to
    );
    event Sync(uint112 reserve0, uint112 reserve1);

    function MINIMUM_LIQUIDITY() external pure returns (uint);
    function factory() external view returns (address);
    function token0() external view returns (address);
    function token1() external view returns (address);
    function getReserves() external view returns (uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast);
    function price0CumulativeLast() external view returns (uint);
    function price1CumulativeLast() external view returns (uint);
    function kLast() external view returns (uint);

    function mint(address to) external returns (uint liquidity);
    function burn(address to) external returns (uint amount0, uint amount1);
    function swap(uint amount0Out, uint amount1Out, address to, bytes calldata data) external;
    function skim(address to) external;
    function sync() external;

    function initialize(address, address) external;
}

// SPDX-License-Identifier: GPL-3.0
pragma solidity ^0.6.0;

/************************************************************************************************
Originally from https://github.com/Uniswap/uniswap-v2-periphery/blob/master/contracts/libraries/UniswapV2Library.sol

This source code has been modified from the original, which was copied from the github repository
at commit hash 87edfdcaf49ccc52591502993db4c8c08ea9eec0.

Subject to the GPL-3.0 license
*************************************************************************************************/


library UniswapV2Library {
  // returns sorted token addresses, used to handle return values from pairs sorted in this order
  function sortTokens(address tokenA, address tokenB)
    internal
    pure
    returns (address token0, address token1)
  {
    require(tokenA != tokenB, "UniswapV2Library: IDENTICAL_ADDRESSES");
    (token0, token1) = tokenA < tokenB ? (tokenA, tokenB) : (tokenB, tokenA);
    require(token0 != address(0), "UniswapV2Library: ZERO_ADDRESS");
  }

  function calculatePair(
    address factory,
    address token0,
    address token1
  ) internal pure returns (address pair) {
    pair = address(
      uint256(
        keccak256(
          abi.encodePacked(
            hex"ff",
            factory,
            keccak256(abi.encodePacked(token0, token1)),
            hex"96e8ac4277198ff8b6f785478aa9a39f403cb768dd02cbee326c3e7da348845f" // init code hash
          )
        )
      )
    );
  }

  // calculates the CREATE2 address for a pair without making any external calls
  function pairFor(
    address factory,
    address tokenA,
    address tokenB
  ) internal pure returns (address pair) {
    (address token0, address token1) = sortTokens(tokenA, tokenB);
    pair = calculatePair(factory, token0, token1);
  }
}

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.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

pragma solidity ^0.6.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        uint256 c = a + b;
        require(c >= a, "SafeMath: addition overflow");

        return c;
    }

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

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

        return c;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
        // benefit is lost if 'b' is also tested.
        // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
        if (a == 0) {
            return 0;
        }

        uint256 c = a * b;
        require(c / a == b, "SafeMath: multiplication overflow");

        return c;
    }

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

    /**
     * @dev Returns the integer division of two unsigned integers. Reverts with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        require(b > 0, errorMessage);
        uint256 c = a / b;
        // assert(a == b * c + a % b); // There is no case in which this doesn't hold

        return c;
    }

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

import "./IERC20.sol";
import "../../math/SafeMath.sol";
import "../../utils/Address.sol";

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.2;

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

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

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

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

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

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

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

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

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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

{
  "metadata": {
    "useLiteralContent": false
  },
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IIndexedUniswapV2Oracle","name":"oracle_","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"tokens","type":"uint256"}],"name":"TokensClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"credit","type":"uint256"}],"name":"TokensContributed","type":"event"},{"inputs":[],"name":"claimTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"claimTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"accounts","type":"address[]"}],"name":"claimTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"},{"internalType":"uint256","name":"minimumCredit","type":"uint256"}],"name":"contributeTokens","outputs":[{"internalType":"uint256","name":"credit","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"tokens","type":"address[]"},{"internalType":"uint256[]","name":"amountsIn","type":"uint256[]"},{"internalType":"uint256","name":"minimumCredit","type":"uint256"}],"name":"contributeTokens","outputs":[{"internalType":"uint256","name":"credit","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"controller","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"finish","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"amountIn","type":"uint256"}],"name":"getCreditForTokens","outputs":[{"internalType":"uint144","name":"amountOut","type":"uint144"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getCreditOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"getDesiredAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"tokens","type":"address[]"}],"name":"getDesiredAmounts","outputs":[{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDesiredTokens","outputs":[{"internalType":"address[]","name":"tokens","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getTotalCredit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"controller_","type":"address"},{"internalType":"address","name":"poolAddress","type":"address"},{"internalType":"address[]","name":"tokens","type":"address[]"},{"internalType":"uint256[]","name":"amounts","type":"uint256[]"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"isFinished","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"oracle","outputs":[{"internalType":"contract IIndexedUniswapV2Oracle","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"updatePrices","outputs":[],"stateMutability":"nonpayable","type":"function"}]

60a060405234801561001057600080fd5b50604051611f60380380611f6083398101604081905261002f91610044565b60601b6001600160601b031916608052610072565b600060208284031215610055578081fd5b81516001600160a01b038116811461006b578182fd5b9392505050565b60805160601c611ebd6100a36000398061037a52806105b0528061069b528061087a5280610a4f5250611ebd6000f3fe608060405234801561001057600080fd5b506004361061010b5760003560e01c80637dc0d1d0116100a2578063df8de3e711610071578063df8de3e71461020b578063ed3c66941461021e578063eef72a3c14610231578063f305760814610244578063f77c47911461024c5761010b565b80637dc0d1d0146101bb578063b40bd3c2146101d0578063c97ab30c146101f0578063d56b2889146102035761010b565b80634a1bc547116100de5780634a1bc547146101605780634a7f360c14610180578063636a2159146101935780637b352962146101a65761010b565b80631074fafb1461011057806327b978231461012e57806348c54b9d1461014e57806349dd126214610158575b600080fd5b610118610254565b6040516101259190611a6e565b60405180910390f35b61014161013c3660046116ef565b6102b6565b6040516101259190611e16565b610156610523565b005b610156610599565b61017361016e3660046116c5565b61063f565b6040516101259190611e02565b61014161018e366004611618565b610734565b6101416101a1366004611762565b61074f565b6101ae610a44565b6040516101259190611ae4565b6101c3610a4d565b604051610125919061196b565b6101e36101de366004611722565b610a71565b6040516101259190611ad1565b6101416101fe366004611618565b610b2d565b610156610b48565b610156610219366004611618565b610e1a565b61015661022c366004611633565b610e91565b61015661023f366004611722565b610f99565b610141611045565b6101c361104b565b606060028054806020026020016040519081016040528092919081815260200182805480156102ac57602002820191906000526020600020905b81546001600160a01b0316815260019091019060200180831161028e575b5050505050905090565b600554600090600160a81b900460ff16156102ec5760405162461bcd60e51b81526004016102e390611bfd565b60405180910390fd5b6005805460ff60a81b1916600160a81b179081905560ff16156103215760405162461bcd60e51b81526004016102e390611d3c565b6001600160a01b038416600090815260208190526040902054806103575760405162461bcd60e51b81526004016102e390611bd5565b80841115610363578093505b604051635fb6ec1760e11b81526001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000169063bf6dd82e906103ba90889088906104b0906202a30090600401611a3f565b60206040518083038186803b1580156103d257600080fd5b505afa1580156103e6573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061040a919061189e565b6001600160901b031691506000821180156104255750600084115b6104415760405162461bcd60e51b81526004016102e390611bac565b828210156104615760405162461bcd60e51b81526004016102e390611cb4565b6104766001600160a01b03861633308761105a565b61048081856110b8565b6001600160a01b038616600090815260208181526040808320939093553382526001905220546104b09083611103565b336000908152600160205260409020556004546104cd9083611103565b6004556040517fcb3c3418fea7cf628767ce27ce6984aca3ce5e4f5f5c892e856e3cb4c52c81639061050690339088908890879061197f565b60405180910390a1506005805460ff60a81b191690559392505050565b600554600160a81b900460ff161561054d5760405162461bcd60e51b81526004016102e390611bfd565b6005805460ff60a81b1916600160a81b179081905560ff166105815760405162461bcd60e51b81526004016102e390611b22565b61058a33611128565b6005805460ff60a81b19169055565b6040516303f294b760e51b81526001600160a01b037f00000000000000000000000000000000000000000000000000000000000000001690637e5296e0906105e690600290600401611a81565b600060405180830381600087803b15801561060057600080fd5b505af1158015610614573d6000803e3d6000fd5b505050506040513d6000823e601f3d908101601f1916820160405261063c91908101906117d3565b50565b6001600160a01b038216600090815260208190526040812054806106755760405162461bcd60e51b81526004016102e390611bd5565b80831115610681578092505b604051635fb6ec1760e11b81526000906001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000169063bf6dd82e906106db90889088906104b0906202a30090600401611a3f565b60206040518083038186803b1580156106f357600080fd5b505afa158015610707573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061072b919061189e565b95945050505050565b6001600160a01b031660009081526020819052604090205490565b600554600090600160a81b900460ff161561077c5760405162461bcd60e51b81526004016102e390611bfd565b6005805460ff60a81b1916600160a81b179081905560ff16156107b15760405162461bcd60e51b81526004016102e390611d3c565b848381146107d15760405162461bcd60e51b81526004016102e390611c8f565b6000915060005b818110156109d25760008888838181106107ee57fe5b90506020020160208101906108039190611618565b9050600087878481811061081357fe5b6001600160a01b0385166000908152602081815260409091205491029290920135925050806108545760405162461bcd60e51b81526004016102e390611bd5565b80821115610860578091505b604051635fb6ec1760e11b81526000906001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000169063bf6dd82e906108ba90879087906104b0906202a30090600401611a3f565b60206040518083038186803b1580156108d257600080fd5b505afa1580156108e6573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061090a919061189e565b6001600160901b031690506000811180156109255750600083115b6109415760405162461bcd60e51b81526004016102e390611bac565b6109566001600160a01b03851633308661105a565b61096082846110b8565b6001600160a01b0385166000908152602081905260409020556109838782611103565b96507fcb3c3418fea7cf628767ce27ce6984aca3ce5e4f5f5c892e856e3cb4c52c8163338585846040516109ba949392919061197f565b60405180910390a15050600190920191506107d89050565b50828210156109f35760405162461bcd60e51b81526004016102e390611cb4565b33600090815260016020526040902054610a0d9083611103565b33600090815260016020526040902055600454610a2a9083611103565b600455506005805460ff60a81b1916905595945050505050565b60055460ff1690565b7f000000000000000000000000000000000000000000000000000000000000000081565b60608167ffffffffffffffff81118015610a8a57600080fd5b50604051908082528060200260200182016040528015610ab4578160200160208202803683370190505b50905060005b82811015610b2657600080858584818110610ad157fe5b9050602002016020810190610ae69190611618565b6001600160a01b03166001600160a01b0316815260200190815260200160002054828281518110610b1357fe5b6020908102919091010152600101610aba565b5092915050565b6001600160a01b031660009081526001602052604090205490565b600554600160a81b900460ff1615610b725760405162461bcd60e51b81526004016102e390611bfd565b6005805460ff60a81b1916600160a81b179081905560ff1615610ba75760405162461bcd60e51b81526004016102e390611d3c565b6002546003546001600160a01b031660608267ffffffffffffffff81118015610bcf57600080fd5b50604051908082528060200260200182016040528015610bf9578160200160208202803683370190505b50905060608367ffffffffffffffff81118015610c1557600080fd5b50604051908082528060200260200182016040528015610c3f578160200160208202803683370190505b50905060005b84811015610d8f57600060028281548110610c5c57fe5b9060005260206000200160009054906101000a90046001600160a01b0316905080848381518110610c8957fe5b6001600160a01b0392831660209182029290920101526040516370a0823160e01b81526000918316906370a0823190610cc690309060040161196b565b60206040518083038186803b158015610cde57600080fd5b505afa158015610cf2573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610d1691906118c5565b905080848481518110610d2557fe5b6020908102919091010152600554610d4f906001600160a01b0384811691610100900416836111f0565b6001600160a01b03821660009081526020819052604090205415610d855760405162461bcd60e51b81526004016102e390611c63565b5050600101610c45565b50600554604051636a7a93ed60e01b81526001600160a01b0380861692636a7a93ed92610dcc9261010090920490911690869086906004016119e6565b600060405180830381600087803b158015610de657600080fd5b505af1158015610dfa573d6000803e3d6000fd5b50506005805460ff60a81b1960ff19909116600117169055505050505050565b600554600160a81b900460ff1615610e445760405162461bcd60e51b81526004016102e390611bfd565b6005805460ff60a81b1916600160a81b179081905560ff16610e785760405162461bcd60e51b81526004016102e390611b22565b610e8181611128565b506005805460ff60a81b19169055565b60055461010090046001600160a01b031615610ebf5760405162461bcd60e51b81526004016102e390611b83565b60058054610100600160a81b0319166101006001600160a01b038881169190910291909117909155600380546001600160a01b03191691881691909117905582818114610f1e5760405162461bcd60e51b81526004016102e390611c8f565b610f2a60028686611526565b5060005b81811015610f8f57838382818110610f4257fe5b90506020020135600080888885818110610f5857fe5b9050602002016020810190610f6d9190611618565b6001600160a01b03168152602081019190915260400160002055600101610f2e565b5050505050505050565b600554600160a81b900460ff1615610fc35760405162461bcd60e51b81526004016102e390611bfd565b6005805460ff60a81b1916600160a81b179081905560ff16610ff75760405162461bcd60e51b81526004016102e390611b22565b60005b818110156110335761102b83838381811061101157fe5b90506020020160208101906110269190611618565b611128565b600101610ffa565b50506005805460ff60a81b1916905550565b60045490565b6003546001600160a01b031681565b6110b2846323b872dd60e01b85858560405160240161107b939291906119c2565b60408051601f198184030181529190526020810180516001600160e01b03166001600160e01b0319909316929092179091526112b8565b50505050565b60006110fa83836040518060400160405280601e81526020017f536166654d6174683a207375627472616374696f6e206f766572666c6f770000815250611347565b90505b92915050565b6000828201838110156110fa5760405162461bcd60e51b81526004016102e390611b4c565b6001600160a01b0381166000908152600160205260409020548061115e5760405162461bcd60e51b81526004016102e390611cdc565b6004546000906111819061117b68056bc75e2d6310000085611373565b906113ad565b6001600160a01b038085166000908152600160205260408120556005549192506111b29161010090041684836113ef565b7f896e034966eaaf1adc54acc0f257056febbd300c9e47182cf761982cf1f5e43083826040516111e3929190611a26565b60405180910390a1505050565b8015806112785750604051636eb1769f60e11b81526001600160a01b0384169063dd62ed3e9061122690309086906004016119a8565b60206040518083038186803b15801561123e57600080fd5b505afa158015611252573d6000803e3d6000fd5b505050506040513d601f19601f8201168201806040525081019061127691906118c5565b155b6112945760405162461bcd60e51b81526004016102e390611dac565b6112b38363095ea7b360e01b848460405160240161107b929190611a26565b505050565b606061130d826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c6564815250856001600160a01b031661140e9092919063ffffffff16565b8051909150156112b3578080602001905181019061132b919061187e565b6112b35760405162461bcd60e51b81526004016102e390611d62565b6000818484111561136b5760405162461bcd60e51b81526004016102e39190611aef565b505050900390565b600082611382575060006110fd565b8282028284828161138f57fe5b04146110fa5760405162461bcd60e51b81526004016102e390611c22565b60006110fa83836040518060400160405280601a81526020017f536166654d6174683a206469766973696f6e206279207a65726f000000000000815250611425565b6112b38363a9059cbb60e01b848460405160240161107b929190611a26565b606061141d848460008561145c565b949350505050565b600081836114465760405162461bcd60e51b81526004016102e39190611aef565b50600083858161145257fe5b0495945050505050565b606061146785611520565b6114835760405162461bcd60e51b81526004016102e390611d05565b60006060866001600160a01b031685876040516114a0919061194f565b60006040518083038185875af1925050503d80600081146114dd576040519150601f19603f3d011682016040523d82523d6000602084013e6114e2565b606091505b509150915081156114f657915061141d9050565b8051156115065780518082602001fd5b8360405162461bcd60e51b81526004016102e39190611aef565b3b151590565b828054828255906000526020600020908101928215611579579160200282015b828111156115795781546001600160a01b0319166001600160a01b03843516178255602090920191600190910190611546565b50611585929150611589565b5090565b5b808211156115855780546001600160a01b031916815560010161158a565b80356001600160a01b03811681146110fd57600080fd5b60008083601f8401126115d0578182fd5b50813567ffffffffffffffff8111156115e7578182fd5b602083019150836020808302850101111561160157600080fd5b9250929050565b805180151581146110fd57600080fd5b600060208284031215611629578081fd5b6110fa83836115a8565b6000806000806000806080878903121561164b578182fd5b863561165681611e72565b9550602087013561166681611e72565b9450604087013567ffffffffffffffff80821115611682578384fd5b61168e8a838b016115bf565b909650945060608901359150808211156116a6578384fd5b506116b389828a016115bf565b979a9699509497509295939492505050565b600080604083850312156116d7578182fd5b6116e184846115a8565b946020939093013593505050565b600080600060608486031215611703578283fd5b61170d85856115a8565b95602085013595506040909401359392505050565b60008060208385031215611734578182fd5b823567ffffffffffffffff81111561174a578283fd5b611756858286016115bf565b90969095509350505050565b600080600080600060608688031215611779578081fd5b853567ffffffffffffffff80821115611790578283fd5b61179c89838a016115bf565b909750955060208801359150808211156117b4578283fd5b506117c1888289016115bf565b96999598509660400135949350505050565b600060208083850312156117e5578182fd5b825167ffffffffffffffff808211156117fc578384fd5b818501915085601f83011261180f578384fd5b81518181111561181d578485fd5b838102915061182d848301611e1f565b8181528481019084860184860187018a1015611847578788fd5b8795505b838610156118715761185d8a82611608565b83526001959095019491860191860161184b565b5098975050505050505050565b60006020828403121561188f578081fd5b815180151581146110fa578182fd5b6000602082840312156118af578081fd5b81516001600160901b03811681146110fa578182fd5b6000602082840312156118d6578081fd5b5051919050565b6000815180845260208085019450808401835b838110156119155781516001600160a01b0316875295820195908201906001016118f0565b509495945050505050565b6000815180845260208085019450808401835b8381101561191557815187529582019590820190600101611933565b60008251611961818460208701611e46565b9190910192915050565b6001600160a01b0391909116815260200190565b6001600160a01b0394851681529290931660208301526040820152606081019190915260800190565b6001600160a01b0392831681529116602082015260400190565b6001600160a01b039384168152919092166020820152604081019190915260600190565b6001600160a01b0384168152606060208201819052600090611a0a908301856118dd565b8281036040840152611a1c8185611920565b9695505050505050565b6001600160a01b03929092168252602082015260400190565b6001600160a01b03949094168452602084019290925263ffffffff908116604084015216606082015260800190565b6000602082526110fa60208301846118dd565b6020808252825482820181905260008481528281209092916040850190845b81811015611ac55783546001600160a01b031683526001938401939285019201611aa0565b50909695505050505050565b6000602082526110fa6020830184611920565b901515815260200190565b6000602082528251806020840152611b0e816040850160208701611e46565b601f01601f19169190910160400192915050565b60208082526010908201526f11549497d393d517d192539254d2115160821b604082015260600190565b6020808252601b908201527f536166654d6174683a206164646974696f6e206f766572666c6f770000000000604082015260600190565b6020808252600f908201526e11549497d253925512505312569151608a1b604082015260600190565b6020808252600f908201526e11549497d6915493d7d05353d55395608a1b604082015260600190565b6020808252600e908201526d11549497d393d517d3915151115160921b604082015260600190565b6020808252600b908201526a4552525f5245454e54525960a81b604082015260600190565b60208082526021908201527f536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f6040820152607760f81b606082015260800190565b6020808252601290820152714552525f50454e44494e475f544f4b454e5360701b604082015260600190565b6020808252600b908201526a22a9292fa0a9292fa622a760a91b604082015260600190565b6020808252600e908201526d11549497d3525397d0d49151125560921b604082015260600190565b6020808252600f908201526e11549497d395531317d0d491511255608a1b604082015260600190565b6020808252601d908201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000604082015260600190565b6020808252600c908201526b11549497d192539254d2115160a21b604082015260600190565b6020808252602a908201527f5361666545524332303a204552433230206f7065726174696f6e20646964206e6040820152691bdd081cdd58d8d9595960b21b606082015260800190565b60208082526036908201527f5361666545524332303a20617070726f76652066726f6d206e6f6e2d7a65726f60408201527520746f206e6f6e2d7a65726f20616c6c6f77616e636560501b606082015260800190565b6001600160901b0391909116815260200190565b90815260200190565b60405181810167ffffffffffffffff81118282101715611e3e57600080fd5b604052919050565b60005b83811015611e61578181015183820152602001611e49565b838111156110b25750506000910152565b6001600160a01b038116811461063c57600080fdfea2646970667358221220e3520d0bf6e7a682da5f0f912a2f067897e91df436e3457862ff872026b15fe964736f6c634300060c003300000000000000000000000095129751769f99cc39824a0793ef4933dd8bb74b

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

00000000000000000000000095129751769f99cc39824a0793ef4933dd8bb74b

-----Decoded View---------------
Arg [0] : oracle_ (address): 0x95129751769f99CC39824a0793eF4933DD8Bb74B

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 00000000000000000000000095129751769f99cc39824a0793ef4933dd8bb74b

1211:10195:10:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;9311:130;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5757:955;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;4738:94::-;;;:::i;:::-;;8542:81;;;:::i;10230:525::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;9445:149::-;;;;;;:::i;:::-;;:::i;7153:1284::-;;;;;;:::i;:::-;;:::i;8742:87::-;;;:::i;:::-;;;;;;;:::i;1554:47::-;;;:::i;:::-;;;;;;;:::i;9598:291::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;9130:132::-;;;;;;:::i;:::-;;:::i;3829:743::-;;;:::i;4946:106::-;;;;;;:::i;:::-;;:::i;3176:500::-;;;;;;:::i;:::-;;:::i;5166:182::-;;;;;;:::i;:::-;;:::i;8959:97::-;;;:::i;2092:25::-;;;:::i;9311:130::-;9387:23;9429:7;9420:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;9420:16:10;;;;;;;;;;;;;;;;;;;;;;;9311:130;:::o;5757:955::-;2456:6;;5924:14;;-1:-1:-1;;;2456:6:10;;;;2455:7;2447:31;;;;-1:-1:-1;;;2447:31:10;;;;;;;:::i;:::-;;;;;;;;;2484:6;:13;;-1:-1:-1;;;;2484:13:10;-1:-1:-1;;;2484:13:10;;;;;;2652:9:::1;2651:10;2643:35;;;;-1:-1:-1::0;;;2643:35:10::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;5972:31:10;::::2;5948:21;5972:31:::0;;;::::2;::::0;;;;;;;6017:17;6009:44:::2;;;;-1:-1:-1::0;;;6009:44:10::2;;;;;;;:::i;:::-;6074:13;6063:8;:24;6059:69;;;6108:13;6097:24;;6059:69;6142:138;::::0;-1:-1:-1;;;6142:138:10;;-1:-1:-1;;;;;6142:6:10::2;:33;::::0;::::2;::::0;:138:::2;::::0;6183:5;;6196:8;;1424:10:::2;::::0;1493:6:::2;::::0;6142:138:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;6133:147:10::2;;;6303:1;6294:6;:10;:26;;;;;6319:1;6308:8;:12;6294:26;6286:54;;;;-1:-1:-1::0;;;6286:54:10::2;;;;;;;:::i;:::-;6364:13;6354:6;:23;;6346:50;;;;-1:-1:-1::0;;;6346:50:10::2;;;;;;;:::i;:::-;6402:67;-1:-1:-1::0;;;;;6402:30:10;::::2;6433:10;6453:4;6460:8:::0;6402:30:::2;:67::i;:::-;6509:27;:13:::0;6527:8;6509:17:::2;:27::i;:::-;-1:-1:-1::0;;;;;6475:31:10;::::2;:24;:31:::0;;;::::2;::::0;;;;;;;:61;;;;6574:10:::2;6565:20:::0;;:8:::2;:20:::0;;;;:32:::2;::::0;6590:6;6565:24:::2;:32::i;:::-;6551:10;6542:20;::::0;;;:8:::2;:20;::::0;;;;:55;6618:12:::2;::::0;:24:::2;::::0;6635:6;6618:16:::2;:24::i;:::-;6603:12;:39:::0;6653:54:::2;::::0;::::2;::::0;::::2;::::0;6671:10:::2;::::0;6683:5;;6690:8;;6700:6;;6653:54:::2;:::i;:::-;;;;;;;;-1:-1:-1::0;2510:6:10;:14;;-1:-1:-1;;;;2510:14:10;;;5757:955;;-1:-1:-1;;;5757:955:10:o;4738:94::-;2456:6;;-1:-1:-1;;;2456:6:10;;;;2455:7;2447:31;;;;-1:-1:-1;;;2447:31:10;;;;;;;:::i;:::-;2484:6;:13;;-1:-1:-1;;;;2484:13:10;-1:-1:-1;;;2484:13:10;;;;;;2567:9:::1;2559:38;;;;-1:-1:-1::0;;;2559:38:10::1;;;;;;;:::i;:::-;4803:24:::2;4816:10;4803:12;:24::i;:::-;2510:6:::0;:14;;-1:-1:-1;;;;2510:14:10;;;4738:94::o;8542:81::-;8590:28;;-1:-1:-1;;;8590:28:10;;-1:-1:-1;;;;;8590:6:10;:19;;;;:28;;8610:7;;8590:28;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;8590:28:10;;;;;;;;;;;;:::i;:::-;;8542:81::o;10230:525::-;-1:-1:-1;;;;;10390:31:10;;10339:17;10390:31;;;;;;;;;;;10435:17;10427:44;;;;-1:-1:-1;;;10427:44:10;;;;;;;:::i;:::-;10492:13;10481:8;:24;10477:69;;;10526:13;10515:24;;10477:69;10578:138;;-1:-1:-1;;;10578:138:10;;10551:24;;-1:-1:-1;;;;;10578:6:10;:33;;;;:138;;10619:5;;10632:8;;1424:10;;1493:6;;10578:138;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;10551:165;10230:525;-1:-1:-1;;;;;10230:525:10:o;9445:149::-;-1:-1:-1;;;;;9558:31:10;9534:7;9558:31;;;;;;;;;;;;9445:149::o;7153:1284::-;2456:6;;7344:14;;-1:-1:-1;;;2456:6:10;;;;2455:7;2447:31;;;;-1:-1:-1;;;2447:31:10;;;;;;;:::i;:::-;2484:6;:13;;-1:-1:-1;;;;2484:13:10;-1:-1:-1;;;2484:13:10;;;;;;2652:9:::1;2651:10;2643:35;;;;-1:-1:-1::0;;;2643:35:10::1;;;;;;;:::i;:::-;7382:6:::0;7409:23;;::::2;7401:47;;;;-1:-1:-1::0;;;7401:47:10::2;;;;;;;:::i;:::-;7463:1;7454:10;;7475:9;7470:801;7494:3;7490:1;:7;7470:801;;;7512:13;7528:6;;7535:1;7528:9;;;;;;;;;;;;;;;;;;;;:::i;:::-;7512:25;;7545:16;7564:9;;7574:1;7564:12;;;;;;;-1:-1:-1::0;;;;;7608:31:10;::::2;7584:21;7608:31:::0;;;7564:12:::2;7608:31:::0;;;;;;;;7564:12;::::2;::::0;;;::::2;;::::0;-1:-1:-1;;7655:17:10;7647:44:::2;;;;-1:-1:-1::0;;;7647:44:10::2;;;;;;;:::i;:::-;7714:13;7703:8;:24;7699:73;;;7750:13;7739:24;;7699:73;7799:148;::::0;-1:-1:-1;;;7799:148:10;;7779:17:::2;::::0;-1:-1:-1;;;;;7799:6:10::2;:33;::::0;::::2;::::0;:148:::2;::::0;7842:5;;7857:8;;1424:10:::2;::::0;1493:6:::2;::::0;7799:148:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;7779:168:10::2;;;7975:1;7963:9;:13;:29;;;;;7991:1;7980:8;:12;7963:29;7955:57;;;;-1:-1:-1::0;;;7955:57:10::2;;;;;;;:::i;:::-;8020:67;-1:-1:-1::0;;;;;8020:30:10;::::2;8051:10;8071:4;8078:8:::0;8020:30:::2;:67::i;:::-;8129:27;:13:::0;8147:8;8129:17:::2;:27::i;:::-;-1:-1:-1::0;;;;;8095:31:10;::::2;:24;:31:::0;;;::::2;::::0;;;;;;:61;8173:21:::2;:6:::0;8184:9;8173:10:::2;:21::i;:::-;8164:30;;8207:57;8225:10;8237:5;8244:8;8254:9;8207:57;;;;;;;;;:::i;:::-;;;;;;;;-1:-1:-1::0;;7499:3:10::2;::::0;;::::2;::::0;-1:-1:-1;7470:801:10::2;::::0;-1:-1:-1;7470:801:10::2;;;8294:13;8284:6;:23;;8276:50;;;;-1:-1:-1::0;;;8276:50:10::2;;;;;;;:::i;:::-;8364:10;8355:20;::::0;;;:8:::2;:20;::::0;;;;;:32:::2;::::0;8380:6;8355:24:::2;:32::i;:::-;8341:10;8332:20;::::0;;;:8:::2;:20;::::0;;;;:55;8408:12:::2;::::0;:24:::2;::::0;8425:6;8408:16:::2;:24::i;:::-;8393:12;:39:::0;-1:-1:-1;2510:6:10;:14;;-1:-1:-1;;;;2510:14:10;;;7153:1284;;-1:-1:-1;;;;;7153:1284:10:o;8742:87::-;8815:9;;;;8742:87;:::o;1554:47::-;;;:::o;9598:291::-;9700:24;9758:6;9744:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;9744:28:10;;9734:38;;9783:9;9778:107;9798:17;;;9778:107;;;9843:24;:35;9868:6;;9875:1;9868:9;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;9843:35:10;-1:-1:-1;;;;;9843:35:10;;;;;;;;;;;;;9830:7;9838:1;9830:10;;;;;;;;;;;;;;;;;:48;9817:3;;9778:107;;;;9598:291;;;;:::o;9130:132::-;-1:-1:-1;;;;;9240:17:10;9216:7;9240:17;;;:8;:17;;;;;;;9130:132::o;3829:743::-;2456:6;;-1:-1:-1;;;2456:6:10;;;;2455:7;2447:31;;;;-1:-1:-1;;;2447:31:10;;;;;;;:::i;:::-;2484:6;:13;;-1:-1:-1;;;;2484:13:10;-1:-1:-1;;;2484:13:10;;;;;;2652:9:::1;2651:10;2643:35;;;;-1:-1:-1::0;;;2643:35:10::1;;;;;;;:::i;:::-;3925:7:::2;:14:::0;3967:10:::2;::::0;-1:-1:-1;;;;;3967:10:10::2;3983:23;3925:14:::0;4009:18:::2;::::0;::::2;::::0;::::2;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;-1:-1:-1;4009:18:10::2;;3983:44;;4033:25;4075:3;4061:18;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;-1:-1:-1;4061:18:10::2;;4033:46;;4090:9;4085:348;4109:3;4105:1;:7;4085:348;;;4127:13;4143:7;4151:1;4143:10;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;;;;4143:10:10::2;4127:26;;4173:5;4161:6;4168:1;4161:9;;;;;;;;-1:-1:-1::0;;;;;4161:17:10;;::::2;:9;::::0;;::::2;::::0;;;;;:17;4204:38:::2;::::0;-1:-1:-1;;;4204:38:10;;4186:15:::2;::::0;4204:23;::::2;::::0;::::2;::::0;:38:::2;::::0;4236:4:::2;::::0;4204:38:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;4186:56;;4264:7;4250:8;4259:1;4250:11;;;;;;;;;::::0;;::::2;::::0;;;;;:21;4305:12:::2;::::0;4279:48:::2;::::0;-1:-1:-1;;;;;4279:25:10;;::::2;::::0;4305:12:::2;::::0;::::2;;4319:7:::0;4279:25:::2;:48::i;:::-;-1:-1:-1::0;;;;;4352:31:10;::::2;:24;:31:::0;;;::::2;::::0;;;;;;;:36;4335:91:::2;;;;-1:-1:-1::0;;;4335:91:10::2;;;;;;;:::i;:::-;-1:-1:-1::0;;4114:3:10::2;;4085:348;;;-1:-1:-1::0;4497:12:10::2;::::0;4438:107:::2;::::0;-1:-1:-1;;;4438:107:10;;-1:-1:-1;;;;;4438:51:10;;::::2;::::0;::::2;::::0;:107:::2;::::0;4497:12:::2;::::0;;::::2;::::0;;::::2;::::0;4517:6;;4531:8;;4438:107:::2;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;-1:-1:-1::0;;4551:9:10::2;:16:::0;;-1:-1:-1;;;;;;4551:16:10;;::::2;4563:4;4551:16;2510:14:::0;;;-1:-1:-1;;;;;;3829:743:10:o;4946:106::-;2456:6;;-1:-1:-1;;;2456:6:10;;;;2455:7;2447:31;;;;-1:-1:-1;;;2447:31:10;;;;;;;:::i;:::-;2484:6;:13;;-1:-1:-1;;;;2484:13:10;-1:-1:-1;;;2484:13:10;;;;;;2567:9:::1;2559:38;;;;-1:-1:-1::0;;;2559:38:10::1;;;;;;;:::i;:::-;5026:21:::2;5039:7;5026:12;:21::i;:::-;-1:-1:-1::0;2510:6:10;:14;;-1:-1:-1;;;;2510:14:10;;;4946:106::o;3176:500::-;3355:12;;;;;-1:-1:-1;;;;;3355:12:10;:26;3347:54;;;;-1:-1:-1;;;3347:54:10;;;;;;;:::i;:::-;3407:12;:26;;-1:-1:-1;;;;;;3407:26:10;;-1:-1:-1;;;;;3407:26:10;;;;;;;;;;;;;;3439:10;:24;;-1:-1:-1;;;;;;3439:24:10;;;;;;;;;;3483:6;3510:21;;;3502:45;;;;-1:-1:-1;;;3502:45:10;;;;;;;:::i;:::-;3553:16;:7;3563:6;;3553:16;:::i;:::-;;3580:9;3575:97;3599:3;3595:1;:7;3575:97;;;3655:7;;3663:1;3655:10;;;;;;;;;;;;;3617:24;:35;3642:6;;3649:1;3642:9;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;3617:35:10;;;;;;;;;;;;-1:-1:-1;3617:35:10;:48;3604:3;;3575:97;;;;3176:500;;;;;;;:::o;5166:182::-;2456:6;;-1:-1:-1;;;2456:6:10;;;;2455:7;2447:31;;;;-1:-1:-1;;;2447:31:10;;;;;;;:::i;:::-;2484:6;:13;;-1:-1:-1;;;;2484:13:10;-1:-1:-1;;;2484:13:10;;;;;;2567:9:::1;2559:38;;;;-1:-1:-1::0;;;2559:38:10::1;;;;;;;:::i;:::-;5263:9:::2;5258:86;5278:19:::0;;::::2;5258:86;;;5312:25;5325:8;;5334:1;5325:11;;;;;;;;;;;;;;;;;;;;:::i;:::-;5312:12;:25::i;:::-;5299:3;;5258:86;;;-1:-1:-1::0;;2510:6:10;:14;;-1:-1:-1;;;;2510:14:10;;;-1:-1:-1;5166:182:10:o;8959:97::-;9039:12;;8959:97;:::o;2092:25::-;;;-1:-1:-1;;;;;2092:25:10;;:::o;877:203:7:-;977:96;997:5;1027:27;;;1056:4;1062:2;1066:5;1004:68;;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;1004:68:7;;;;;;;;;;;;;;-1:-1:-1;;;;;1004:68:7;-1:-1:-1;;;;;;1004:68:7;;;;;;;;;;977:19;:96::i;:::-;877:203;;;;:::o;1321:134:5:-;1379:7;1405:43;1409:1;1412;1405:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;1398:50;;1321:134;;;;;:::o;874:176::-;932:7;963:5;;;986:6;;;;978:46;;;;-1:-1:-1;;;978:46:5;;;;;;;:::i;11066:338:10:-;-1:-1:-1;;;;;11137:17:10;;11120:14;11137:17;;;:8;:17;;;;;;11168:10;11160:38;;;;-1:-1:-1;;;11160:38:10;;;;;;;:::i;:::-;11256:12;;11204:17;;11224:45;;11225:25;1545:4;11243:6;11225:17;:25::i;:::-;11224:31;;:45::i;:::-;-1:-1:-1;;;;;11275:17:10;;;11295:1;11275:17;;;:8;:17;;;;;:21;11309:12;;11204:65;;-1:-1:-1;11302:53:10;;11309:12;;;;11284:7;11204:65;11302:33;:53::i;:::-;11366:33;11380:7;11389:9;11366:33;;;;;;;:::i;:::-;;;;;;;;11066:338;;;:::o;1340:613:7:-;1705:10;;;1704:62;;-1:-1:-1;1721:39:7;;-1:-1:-1;;;1721:39:7;;-1:-1:-1;;;;;1721:15:7;;;;;:39;;1745:4;;1752:7;;1721:39;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;1704:62;1696:150;;;;-1:-1:-1;;;1696:150:7;;;;;;;:::i;:::-;1856:90;1876:5;1906:22;;;1930:7;1939:5;1883:62;;;;;;;;;:::i;1856:90::-;1340:613;;;:::o;2959:751::-;3378:23;3404:69;3432:4;3404:69;;;;;;;;;;;;;;;;;3412:5;-1:-1:-1;;;;;3404:27:7;;;:69;;;;;:::i;:::-;3487:17;;3378:95;;-1:-1:-1;3487:21:7;3483:221;;3627:10;3616:30;;;;;;;;;;;;:::i;:::-;3608:85;;;;-1:-1:-1;;;3608:85:7;;;;;;;:::i;1746:187:5:-;1832:7;1867:12;1859:6;;;;1851:29;;;;-1:-1:-1;;;1851:29:5;;;;;;;;:::i;:::-;-1:-1:-1;;;1902:5:5;;;1746:187::o;2180:459::-;2238:7;2479:6;2475:45;;-1:-1:-1;2508:1:5;2501:8;;2475:45;2542:5;;;2546:1;2542;:5;:1;2565:5;;;;;:10;2557:56;;;;-1:-1:-1;;;2557:56:5;;;;;;;:::i;3101:130::-;3159:7;3185:39;3189:1;3192;3185:39;;;;;;;;;;;;;;;;;:3;:39::i;696:175:7:-;778:86;798:5;828:23;;;853:2;857:5;805:58;;;;;;;;;:::i;3573:194:8:-;3676:12;3707:53;3730:6;3738:4;3744:1;3747:12;3707:22;:53::i;:::-;3700:60;3573:194;-1:-1:-1;;;;3573:194:8:o;3713:272:5:-;3799:7;3833:12;3826:5;3818:28;;;;-1:-1:-1;;;3818:28:5;;;;;;;;:::i;:::-;;3856:9;3872:1;3868;:5;;;;;;;3713:272;-1:-1:-1;;;;;3713:272:5:o;4920:958:8:-;5050:12;5082:18;5093:6;5082:10;:18::i;:::-;5074:60;;;;-1:-1:-1;;;5074:60:8;;;;;;;:::i;:::-;5205:12;5219:23;5246:6;-1:-1:-1;;;;;5246:11:8;5266:8;5277:4;5246:36;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5204:78;;;;5296:7;5292:580;;;5326:10;-1:-1:-1;5319:17:8;;-1:-1:-1;5319:17:8;5292:580;5437:17;;:21;5433:429;;5695:10;5689:17;5755:15;5742:10;5738:2;5734:19;5727:44;5644:145;5834:12;5827:20;;-1:-1:-1;;;5827:20:8;;;;;;;;:::i;718:413::-;1078:20;1116:8;;;718:413::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;5:130;72:20;;-1:-1;;;;;31331:54;;33705:35;;33695:2;;33754:1;;33744:12;160:352;;;290:3;283:4;275:6;271:17;267:27;257:2;;-1:-1;;298:12;257:2;-1:-1;328:20;;368:18;357:30;;354:2;;;-1:-1;;390:12;354:2;434:4;426:6;422:17;410:29;;485:3;434:4;;469:6;465:17;426:6;451:32;;448:41;445:2;;;502:1;;492:12;445:2;250:262;;;;;:::o;1634:128::-;1709:13;;31561;;31554:21;33826:32;;33816:2;;33872:1;;33862:12;2188:241;;2292:2;2280:9;2271:7;2267:23;2263:32;2260:2;;;-1:-1;;2298:12;2260:2;2360:53;2405:7;2381:22;2360:53;:::i;2436:929::-;;;;;;;2661:3;2649:9;2640:7;2636:23;2632:33;2629:2;;;-1:-1;;2668:12;2629:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;2720:63;-1:-1;2820:2;2859:22;;72:20;97:33;72:20;97:33;:::i;:::-;2828:63;-1:-1;2956:2;2941:18;;2928:32;2980:18;2969:30;;;2966:2;;;-1:-1;;3002:12;2966:2;3040:80;3112:7;3103:6;3092:9;3088:22;3040:80;:::i;:::-;3022:98;;-1:-1;3022:98;-1:-1;3185:2;3170:18;;3157:32;;-1:-1;3198:30;;;3195:2;;;-1:-1;;3231:12;3195:2;;3269:80;3341:7;3332:6;3321:9;3317:22;3269:80;:::i;:::-;2623:742;;;;-1:-1;2623:742;;-1:-1;2623:742;;3251:98;;2623:742;-1:-1;;;2623:742::o;3372:366::-;;;3493:2;3481:9;3472:7;3468:23;3464:32;3461:2;;;-1:-1;;3499:12;3461:2;3561:53;3606:7;3582:22;3561:53;:::i;:::-;3551:63;3651:2;3690:22;;;;1977:20;;-1:-1;;;3455:283::o;3745:491::-;;;;3883:2;3871:9;3862:7;3858:23;3854:32;3851:2;;;-1:-1;;3889:12;3851:2;3951:53;3996:7;3972:22;3951:53;:::i;:::-;3941:63;4041:2;4080:22;;1977:20;;-1:-1;4149:2;4188:22;;;1977:20;;3845:391;-1:-1;;;3845:391::o;4243:397::-;;;4382:2;4370:9;4361:7;4357:23;4353:32;4350:2;;;-1:-1;;4388:12;4350:2;4446:17;4433:31;4484:18;4476:6;4473:30;4470:2;;;-1:-1;;4506:12;4470:2;4544:80;4616:7;4607:6;4596:9;4592:22;4544:80;:::i;:::-;4526:98;;;;-1:-1;4344:296;-1:-1;;;;4344:296::o;4647:803::-;;;;;;4855:2;4843:9;4834:7;4830:23;4826:32;4823:2;;;-1:-1;;4861:12;4823:2;4919:17;4906:31;4957:18;;4949:6;4946:30;4943:2;;;-1:-1;;4979:12;4943:2;5017:80;5089:7;5080:6;5069:9;5065:22;5017:80;:::i;:::-;4999:98;;-1:-1;4999:98;-1:-1;5162:2;5147:18;;5134:32;;-1:-1;5175:30;;;5172:2;;;-1:-1;;5208:12;5172:2;;5246:80;5318:7;5309:6;5298:9;5294:22;5246:80;:::i;:::-;4817:633;;;;-1:-1;5228:98;5363:2;5402:22;1977:20;;4817:633;-1:-1;;;;4817:633::o;5457:386::-;;5594:2;;5582:9;5573:7;5569:23;5565:32;5562:2;;;-1:-1;;5600:12;5562:2;5651:17;5645:24;5689:18;;5681:6;5678:30;5675:2;;;-1:-1;;5711:12;5675:2;5810:6;5799:9;5795:22;;;660:3;653:4;645:6;641:17;637:27;627:2;;-1:-1;;668:12;627:2;708:6;702:13;5689:18;28866:6;28863:30;28860:2;;;-1:-1;;28896:12;28860:2;5594;28933:6;28929:17;;;730:77;5594:2;28929:17;28994:15;730:77;:::i;:::-;835:21;;;892:14;;;;867:17;;;972:27;;;;;969:36;-1:-1;966:2;;;-1:-1;;1008:12;966:2;-1:-1;1034:10;;1028:214;1053:6;1050:1;1047:13;1028:214;;;1133:45;1174:3;1162:10;1133:45;:::i;:::-;1121:58;;1075:1;1068:9;;;;;1193:14;;;;1221;;1028:214;;;-1:-1;5731:96;5556:287;-1:-1;;;;;;;;5556:287::o;5850:257::-;;5962:2;5950:9;5941:7;5937:23;5933:32;5930:2;;;-1:-1;;5968:12;5930:2;1715:6;1709:13;33851:5;31561:13;31554:21;33829:5;33826:32;33816:2;;-1:-1;;33862:12;6114:263;;6229:2;6217:9;6208:7;6204:23;6200:32;6197:2;;;-1:-1;;6235:12;6197:2;1853:6;1847:13;-1:-1;;;;;33975:5;31649:50;33950:5;33947:35;33937:2;;-1:-1;;33986:12;6384:263;;6499:2;6487:9;6478:7;6474:23;6470:32;6467:2;;;-1:-1;;6505:12;6467:2;-1:-1;2125:13;;6461:186;-1:-1;6461:186::o;7428:690::-;;7621:5;29625:12;30688:6;30683:3;30676:19;30725:4;;30720:3;30716:14;7633:93;;30725:4;7797:5;29141:14;-1:-1;7836:260;7861:6;7858:1;7855:13;7836:260;;;7922:13;;-1:-1;;;;;31331:54;7228:37;;6808:14;;;;30304;;;;31342:42;7876:9;7836:260;;;-1:-1;8102:10;;7552:566;-1:-1;;;;;7552:566::o;8905:690::-;;9098:5;29625:12;30688:6;30683:3;30676:19;30725:4;;30720:3;30716:14;9110:93;;30725:4;9274:5;29141:14;-1:-1;9313:260;9338:6;9335:1;9332:13;9313:260;;;9399:13;;15879:37;;6990:14;;;;30304;;;;9360:1;9353:9;9313:260;;16179:271;;9874:5;29625:12;9985:52;10030:6;10025:3;10018:4;10011:5;10007:16;9985:52;:::i;:::-;10049:16;;;;;16313:137;-1:-1;;16313:137::o;16457:222::-;-1:-1;;;;;31331:54;;;;7228:37;;16584:2;16569:18;;16555:124::o;16686:572::-;-1:-1;;;;;31331:54;;;7097:58;;31331:54;;;;17078:2;17063:18;;7228:37;17161:2;17146:18;;15879:37;17244:2;17229:18;;15879:37;;;;16905:3;16890:19;;16876:382::o;17265:333::-;-1:-1;;;;;31331:54;;;7228:37;;31331:54;;17584:2;17569:18;;7228:37;17420:2;17405:18;;17391:207::o;17605:444::-;-1:-1;;;;;31331:54;;;7228:37;;31331:54;;;;17952:2;17937:18;;7228:37;18035:2;18020:18;;15879:37;;;;17788:2;17773:18;;17759:290::o;18056:740::-;-1:-1;;;;;31331:54;;7228:37;;18339:2;18457;18442:18;;18435:48;;;18056:740;;18497:108;;18324:18;;18591:6;18497:108;:::i;:::-;18653:9;18647:4;18643:20;18638:2;18627:9;18623:18;18616:48;18678:108;18781:4;18772:6;18678:108;:::i;:::-;18670:116;18310:486;-1:-1;;;;;;18310:486::o;18803:333::-;-1:-1;;;;;31331:54;;;;7228:37;;19122:2;19107:18;;15879:37;18958:2;18943:18;;18929:207::o;19143:552::-;-1:-1;;;;;31331:54;;;;7228:37;;19517:2;19502:18;;15879:37;;;;31990:10;31979:22;;;19599:2;19584:18;;16118:49;31979:22;19681:2;19666:18;;16118:49;19352:3;19337:19;;19323:372::o;19702:370::-;;19879:2;19900:17;19893:47;19954:108;19879:2;19868:9;19864:18;20048:6;19954:108;:::i;20079:364::-;20253:2;20267:47;;;29772:12;;20238:18;;;30676:19;;;20079:364;29294:14;;;29323:18;;;20079:364;;20253:2;30716:14;;;;20079:364;8556:288;8581:6;8578:1;8575:13;8556:288;;;33407:11;;-1:-1;;;;;31331:54;7228:37;;31342:42;30416:14;;;;6808;;;;8596:9;8556:288;;;-1:-1;20320:113;;20224:219;-1:-1;;;;;;20224:219::o;20450:370::-;;20627:2;20648:17;20641:47;20702:108;20627:2;20616:9;20612:18;20796:6;20702:108;:::i;20827:210::-;31561:13;;31554:21;9668:34;;20948:2;20933:18;;20919:118::o;21335:310::-;;21482:2;21503:17;21496:47;10417:5;29625:12;30688:6;21482:2;21471:9;21467:18;30676:19;10511:52;10556:6;30716:14;21471:9;30716:14;21482:2;10537:5;10533:16;10511:52;:::i;:::-;33515:7;33499:14;-1:-1;;33495:28;10575:39;;;;30716:14;10575:39;;21453:192;-1:-1;;21453:192::o;21652:416::-;21852:2;21866:47;;;10851:2;21837:18;;;30676:19;-1:-1;;;30716:14;;;10867:39;10925:12;;;21823:245::o;22075:416::-;22275:2;22289:47;;;11176:2;22260:18;;;30676:19;11212:29;30716:14;;;11192:50;11261:12;;;22246:245::o;22498:416::-;22698:2;22712:47;;;11512:2;22683:18;;;30676:19;-1:-1;;;30716:14;;;11528:38;11585:12;;;22669:245::o;22921:416::-;23121:2;23135:47;;;11836:2;23106:18;;;30676:19;-1:-1;;;30716:14;;;11852:38;11909:12;;;23092:245::o;23344:416::-;23544:2;23558:47;;;12160:2;23529:18;;;30676:19;-1:-1;;;30716:14;;;12176:37;12232:12;;;23515:245::o;23767:416::-;23967:2;23981:47;;;12483:2;23952:18;;;30676:19;-1:-1;;;30716:14;;;12499:34;12552:12;;;23938:245::o;24190:416::-;24390:2;24404:47;;;12803:2;24375:18;;;30676:19;12839:34;30716:14;;;12819:55;-1:-1;;;12894:12;;;12887:25;12931:12;;;24361:245::o;24613:416::-;24813:2;24827:47;;;13182:2;24798:18;;;30676:19;-1:-1;;;30716:14;;;13198:41;13258:12;;;24784:245::o;25036:416::-;25236:2;25250:47;;;13509:2;25221:18;;;30676:19;-1:-1;;;30716:14;;;13525:34;13578:12;;;25207:245::o;25459:416::-;25659:2;25673:47;;;13829:2;25644:18;;;30676:19;-1:-1;;;30716:14;;;13845:37;13901:12;;;25630:245::o;25882:416::-;26082:2;26096:47;;;14152:2;26067:18;;;30676:19;-1:-1;;;30716:14;;;14168:38;14225:12;;;26053:245::o;26305:416::-;26505:2;26519:47;;;14476:2;26490:18;;;30676:19;14512:31;30716:14;;;14492:52;14563:12;;;26476:245::o;26728:416::-;26928:2;26942:47;;;14814:2;26913:18;;;30676:19;-1:-1;;;30716:14;;;14830:35;14884:12;;;26899:245::o;27151:416::-;27351:2;27365:47;;;15135:2;27336:18;;;30676:19;15171:34;30716:14;;;15151:55;-1:-1;;;15226:12;;;15219:34;15272:12;;;27322:245::o;27574:416::-;27774:2;27788:47;;;15523:2;27759:18;;;30676:19;15559:34;30716:14;;;15539:55;-1:-1;;;15614:12;;;15607:46;15672:12;;;27745:245::o;27997:222::-;-1:-1;;;;;31649:50;;;;15769:37;;28124:2;28109:18;;28095:124::o;28226:222::-;15879:37;;;28353:2;28338:18;;28324:124::o;28455:256::-;28517:2;28511:9;28543:17;;;28618:18;28603:34;;28639:22;;;28600:62;28597:2;;;28675:1;;28665:12;28597:2;28517;28684:22;28495:216;;-1:-1;28495:216::o;32842:268::-;32907:1;32914:101;32928:6;32925:1;32922:13;32914:101;;;32995:11;;;32989:18;32976:11;;;32969:39;32950:2;32943:10;32914:101;;;33030:6;33027:1;33024:13;33021:2;;;-1:-1;;32907:1;33077:16;;33070:27;32891:219::o;33646:117::-;-1:-1;;;;;31331:54;;33705:35;;33695:2;;33754:1;;33744:12

ipfs://e3520d0bf6e7a682da5f0f912a2f067897e91df436e3457862ff872026b15fe9