Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•    - function _msgSender()
•    - function _msgData()
•    - function owner()
•    - function renounceOwnership()
•    - function transferOwnership(address ne ...
• library SafeMath
•    - function add(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b)
•    - function sub(uint256 a, uint256 b, st ...
•    - function mul(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b)
•    - function div(uint256 a, uint256 b, st ...
•    - function mod(uint256 a, uint256 b)
•    - function mod(uint256 a, uint256 b, st ...
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(address target, ...
•    - function functionCallWithValue(addres ...
•    - function functionCallWithValue(addres ...
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(address t ...
•    - function _verifyCallResult(bool succe ...
• library SafeERC20
•    - function safeTransfer(IERC20 token, a ...
•    - function safeTransferFrom(IERC20 toke ...
•    - function safeApprove(IERC20 token, ad ...
•    - function safeIncreaseAllowance(IERC20 ...
•    - function safeDecreaseAllowance(IERC20 ...
•    - function _callOptionalReturn(IERC20 t ...
•  contract Constants
• interface IToken
•    - function factor()
•    - function factor(uint256 totalAssets)
•    - function mint(
•    - function burn(
•    - function burnAll(address account)
•    - function totalAssets()
•    - function getPricePerShare()
•    - function getShareAssets(uint256 share ...
•    - function getAssets(address account)
• interface IVault
•    - function withdraw(uint256 amount)
•    - function withdraw(uint256 amount, add ...
•    - function withdrawByStrategyOrder(
•    - function withdrawByStrategyIndex(
•    - function deposit(uint256 amount)
•    - function updateStrategyRatio(uint256[ ...
•    - function totalAssets()
•    - function getStrategiesLength()
•    - function strategyHarvestTrigger(uint2 ...
•    - function strategyHarvest(uint256 inde ...
•    - function getStrategyAssets(uint256 in ...
•    - function token()
•    - function vault()
•    - function investTrigger()
•    - function invest()
•  contract FixedStablecoins is Const ...
•    - function underlyingTokens()
•    - function getToken(uint256 index)
•    - function decimals()
•    - function getDecimal(uint256 index)
•  contract FixedGTokens
•    - function gTokens(bool _pwrd)
•  contract FixedVaults is Constants
•    - function getVault(uint256 index)
•    - function vaults()
• interface IController
•    - function stablecoins()
•    - function vaults()
•    - function underlyingVaults(uint256 i)
•    - function curveVault()
•    - function pnl()
•    - function insurance()
•    - function lifeGuard()
•    - function buoy()
•    - function reward()
•    - function isValidBigFish(
•    - function withdrawHandler()
•    - function emergencyHandler()
•    - function depositHandler()
•    - function totalAssets()
•    - function gTokenTotalAssets()
•    - function eoaOnly(address sender)
•    - function getSkimPercent()
•    - function gToken(bool _pwrd)
•    - function emergencyState()
•    - function deadCoin()
•    - function distributeStrategyGainLoss(u ...
•    - function burnGToken(
•    - function mintGToken(
•    - function getUserAssets(bool pwrd, add ...
•    - function referrals(address account)
•    - function addReferral(address account, ...
•    - function getStrategiesTargetRatio()
•    - function withdrawalFee(bool pwrd)
•    - function validGTokenDecrease(uint256 ...
• interface IPausable
•    - function paused()
•  contract Controllable is Ownable
•    - function ctrlPaused()
•    - function setController(address newCon ...
•    - function _controller()
•    - function _pausable()
• interface IBuoy
•    - function safetyCheck()
•    - function updateRatios()
•    - function updateRatiosWithTolerance(ui ...
•    - function lpToUsd(uint256 inAmount)
•    - function usdToLp(uint256 inAmount)
•    - function stableToUsd(uint256[3] calld ...
•    - function stableToLp(uint256[3] callda ...
•    - function singleStableFromLp(uint256 i ...
•    - function getVirtualPrice()
•    - function singleStableFromUsd(uint256 ...
•    - function singleStableToUsd(uint256 in ...
• interface IEmergencyHandler
•    - function emergencyWithdrawal(
•    - function emergencyWithdrawAll(
• interface IInsurance
•    - function calculateDepositDeltasOnAllV ...
•    - function rebalanceTrigger()
•    - function rebalance()
•    - function calcSkim()
•    - function rebalanceForWithdraw(uint256 ...
•    - function getDelta(uint256 withdrawUsd ...
•    - function getVaultDeltaForDeposit(uint ...
•    - function sortVaultsByDelta(bool bigFi ...
•    - function getStrategiesTargetRatio(uin ...
•    - function setUnderlyingTokenPercents(u ...
• interface ILifeGuard
•    - function assets(uint256 i)
•    - function totalAssets()
•    - function getAssets()
•    - function totalAssetsUsd()
•    - function availableUsd()
•    - function availableLP()
•    - function depositStable(bool rebalance ...
•    - function investToCurveVault()
•    - function distributeCurveVault(uint256 ...
•    - function deposit()
•    - function withdrawSingleByLiquidity(
•    - function withdrawSingleByExchange(
•    - function invest(uint256 whaleDepositA ...
•    - function getBuoy()
•    - function investSingle(
•    - function investToCurveVaultTrigger()
• interface IWithdrawHandler
•    - function withdrawByLPToken(
•    - function withdrawByStablecoin(
•    - function withdrawAllSingle(
•    - function withdrawAllBalanced(bool pwr ...
•  contract WithdrawHandler is Contro ... *
•    - function setDependencies()
•    - function withdrawByLPToken(
•    - function withdrawByStablecoin(
•    - function withdrawAllSingle(
•    - function withdrawAllBalanced(bool pwr ...
•    - function getVaultDeltas(uint256 amoun ...
•    - function withdrawalFee(bool pwrd)
•    - function _withdrawAllSingleFromAccoun ...
•    - function _withdraw(WithdrawParameter ...
•    - function _withdrawSingle(
•    - function _withdrawBalanced(
•    - function _prepareForWithdrawalSingle(

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2021-07-17
*/

// SPDX-License-Identifier: AGPLv3
pragma solidity >=0.6.0 <0.8.0;

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

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

pragma solidity >=0.6.0 <0.8.0;

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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor () internal {
        address msgSender = _msgSender();
        _owner = msgSender;
        emit OwnershipTransferred(address(0), msgSender);
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(_owner == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(_owner, newOwner);
        _owner = newOwner;
    }
}

pragma solidity >=0.6.0 <0.8.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) {
        
        
        
        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;
        

        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;
    }
}

pragma solidity >=0.6.0 <0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https:
     *
     * 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);
}

pragma solidity >=0.6.2 <0.8.0;

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

        uint256 size;
        
        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:
     * 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:
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https:
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        
        (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:
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

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

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

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

        
        (bool success, bytes memory returndata) = target.call{ value: value }(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

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

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

        
        (bool success, bytes memory returndata) = target.staticcall(data);
        return _verifyCallResult(success, returndata, errorMessage);
    }

    function _verifyCallResult(bool success, bytes memory returndata, string memory errorMessage) private pure returns(bytes memory) {
        if (success) {
            return returndata;
        } else {
            
            if (returndata.length > 0) {
                

                
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

pragma solidity >=0.6.0 <0.8.0;

/**
 * @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 {
        
        
        
        
        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 {
        
        
        

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

pragma solidity >=0.6.0 <0.7.0;

contract Constants {
    uint8 public constant N_COINS = 3;
    uint8 public constant DEFAULT_DECIMALS = 18; 
    uint256 public constant DEFAULT_DECIMALS_FACTOR = uint256(10)**DEFAULT_DECIMALS;
    uint8 public constant CHAINLINK_PRICE_DECIMALS = 8;
    uint256 public constant CHAINLINK_PRICE_DECIMAL_FACTOR = uint256(10)**CHAINLINK_PRICE_DECIMALS;
    uint8 public constant PERCENTAGE_DECIMALS = 4;
    uint256 public constant PERCENTAGE_DECIMAL_FACTOR = uint256(10)**PERCENTAGE_DECIMALS;
    uint256 public constant CURVE_RATIO_DECIMALS = 6;
    uint256 public constant CURVE_RATIO_DECIMALS_FACTOR = uint256(10)**CURVE_RATIO_DECIMALS;
}

pragma solidity >=0.6.0 <0.7.0;

interface IToken {
    function factor() external view returns (uint256);

    function factor(uint256 totalAssets) external view returns (uint256);

    function mint(
        address account,
        uint256 _factor,
        uint256 amount
    ) external;

    function burn(
        address account,
        uint256 _factor,
        uint256 amount
    ) external;

    function burnAll(address account) external;

    function totalAssets() external view returns (uint256);

    function getPricePerShare() external view returns (uint256);

    function getShareAssets(uint256 shares) external view returns (uint256);

    function getAssets(address account) external view returns (uint256);
}

pragma solidity >=0.6.0 <0.7.0;

interface IVault {
    function withdraw(uint256 amount) external;

    function withdraw(uint256 amount, address recipient) external;

    function withdrawByStrategyOrder(
        uint256 amount,
        address recipient,
        bool reversed
    ) external;

    function withdrawByStrategyIndex(
        uint256 amount,
        address recipient,
        uint256 strategyIndex
    ) external;

    function deposit(uint256 amount) external;

    function updateStrategyRatio(uint256[] calldata strategyRetios) external;

    function totalAssets() external view returns (uint256);

    function getStrategiesLength() external view returns (uint256);

    function strategyHarvestTrigger(uint256 index, uint256 callCost) external view returns (bool);

    function strategyHarvest(uint256 index) external returns (bool);

    function getStrategyAssets(uint256 index) external view returns (uint256);

    function token() external view returns (address);

    function vault() external view returns (address);

    function investTrigger() external view returns (bool);

    function invest() external;
}

pragma solidity >=0.6.0 <0.7.0;

contract FixedStablecoins is Constants {
    address public immutable DAI; 
    address public immutable USDC; 
    address public immutable USDT; 

    uint256 public immutable DAI_DECIMALS; 
    uint256 public immutable USDC_DECIMALS; 
    uint256 public immutable USDT_DECIMALS; 

    constructor(address[N_COINS] memory _tokens, uint256[N_COINS] memory _decimals) public {
        DAI = _tokens[0];
        USDC = _tokens[1];
        USDT = _tokens[2];
        DAI_DECIMALS = _decimals[0];
        USDC_DECIMALS = _decimals[1];
        USDT_DECIMALS = _decimals[2];
    }

    function underlyingTokens() internal view returns (address[N_COINS] memory tokens) {
        tokens[0] = DAI;
        tokens[1] = USDC;
        tokens[2] = USDT;
    }

    function getToken(uint256 index) internal view returns (address) {
        if (index == 0) {
            return DAI;
        } else if (index == 1) {
            return USDC;
        } else {
            return USDT;
        }
    }

    function decimals() internal view returns (uint256[N_COINS] memory _decimals) {
        _decimals[0] = DAI_DECIMALS;
        _decimals[1] = USDC_DECIMALS;
        _decimals[2] = USDT_DECIMALS;
    }

    function getDecimal(uint256 index) internal view returns (uint256) {
        if (index == 0) {
            return DAI_DECIMALS;
        } else if (index == 1) {
            return USDC_DECIMALS;
        } else {
            return USDT_DECIMALS;
        }
    }
}

contract FixedGTokens {
    IToken public immutable pwrd;
    IToken public immutable gvt;

    constructor(address _pwrd, address _gvt) public {
        pwrd = IToken(_pwrd);
        gvt = IToken(_gvt);
    }

    function gTokens(bool _pwrd) internal view returns (IToken) {
        if (_pwrd) {
            return pwrd;
        } else {
            return gvt;
        }
    }
}

contract FixedVaults is Constants {
    address public immutable DAI_VAULT;
    address public immutable USDC_VAULT;
    address public immutable USDT_VAULT;

    constructor(address[N_COINS] memory _vaults) public {
        DAI_VAULT = _vaults[0];
        USDC_VAULT = _vaults[1];
        USDT_VAULT = _vaults[2];
    }

    function getVault(uint256 index) internal view returns (address) {
        if (index == 0) {
            return DAI_VAULT;
        } else if (index == 1) {
            return USDC_VAULT;
        } else {
            return USDT_VAULT;
        }
    }

    function vaults() internal view returns (address[N_COINS] memory _vaults) {
        _vaults[0] = DAI_VAULT;
        _vaults[1] = USDC_VAULT;
        _vaults[2] = USDT_VAULT;
    }
}

pragma solidity >=0.6.0 <0.7.0;

interface IController {
    function stablecoins() external view returns (address[3] memory);

    function vaults() external view returns (address[3] memory);

    function underlyingVaults(uint256 i) external view returns (address vault);

    function curveVault() external view returns (address);

    function pnl() external view returns (address);

    function insurance() external view returns (address);

    function lifeGuard() external view returns (address);

    function buoy() external view returns (address);

    function reward() external view returns (address);

    function isValidBigFish(
        bool pwrd,
        bool deposit,
        uint256 amount
    ) external view returns (bool);

    function withdrawHandler() external view returns (address);

    function emergencyHandler() external view returns (address);

    function depositHandler() external view returns (address);

    function totalAssets() external view returns (uint256);

    function gTokenTotalAssets() external view returns (uint256);

    function eoaOnly(address sender) external;

    function getSkimPercent() external view returns (uint256);

    function gToken(bool _pwrd) external view returns (address);

    function emergencyState() external view returns (bool);

    function deadCoin() external view returns (uint256);

    function distributeStrategyGainLoss(uint256 gain, uint256 loss) external;

    function burnGToken(
        bool pwrd,
        bool all,
        address account,
        uint256 amount,
        uint256 bonus
    ) external;

    function mintGToken(
        bool pwrd,
        address account,
        uint256 amount
    ) external;

    function getUserAssets(bool pwrd, address account) external view returns (uint256 deductUsd);

    function referrals(address account) external view returns (address);

    function addReferral(address account, address referral) external;

    function getStrategiesTargetRatio() external view returns (uint256[] memory);

    function withdrawalFee(bool pwrd) external view returns (uint256);

    function validGTokenDecrease(uint256 amount) external view returns (bool);
}

pragma solidity >=0.6.0 <0.7.0;

interface IPausable {
    function paused() external view returns (bool);
}

pragma solidity >=0.6.0 <0.7.0;

contract Controllable is Ownable {
    address public controller;

    event ChangeController(address indexed oldController, address indexed newController);

    modifier whenNotPaused() {
        require(!_pausable().paused(), "Pausable: paused");
        _;
    }

    modifier whenPaused() {
        require(_pausable().paused(), "Pausable: not paused");
        _;
    }

    function ctrlPaused() public view returns (bool) {
        return _pausable().paused();
    }

    function setController(address newController) external onlyOwner {
        require(newController != address(0), "setController: !0x");
        address oldController = controller;
        controller = newController;
        emit ChangeController(oldController, newController);
    }

    function _controller() internal view returns (IController) {
        require(controller != address(0), "Controller not set");
        return IController(controller);
    }

    function _pausable() internal view returns (IPausable) {
        require(controller != address(0), "Controller not set");
        return IPausable(controller);
    }
}

pragma solidity >=0.6.0 <0.7.0;

interface IBuoy {
    function safetyCheck() external view returns (bool);

    function updateRatios() external returns (bool);

    function updateRatiosWithTolerance(uint256 tolerance) external returns (bool);

    function lpToUsd(uint256 inAmount) external view returns (uint256);

    function usdToLp(uint256 inAmount) external view returns (uint256);

    function stableToUsd(uint256[3] calldata inAmount, bool deposit) external view returns (uint256);

    function stableToLp(uint256[3] calldata inAmount, bool deposit) external view returns (uint256);

    function singleStableFromLp(uint256 inAmount, int128 i) external view returns (uint256);

    function getVirtualPrice() external view returns (uint256);

    function singleStableFromUsd(uint256 inAmount, int128 i) external view returns (uint256);

    function singleStableToUsd(uint256 inAmount, uint256 i) external view returns (uint256);
}

pragma solidity >=0.6.0 <0.7.0;

interface IEmergencyHandler {
    function emergencyWithdrawal(
        address user,
        bool pwrd,
        uint256 inAmount,
        uint256 minAmounts
    ) external;

    function emergencyWithdrawAll(
        address user,
        bool pwrd,
        uint256 minAmounts
    ) external;
}

pragma solidity >=0.6.0 <0.7.0;

interface IInsurance {
    function calculateDepositDeltasOnAllVaults() external view returns (uint256[3] memory);

    function rebalanceTrigger() external view returns (bool sysNeedRebalance);

    function rebalance() external;

    function calcSkim() external view returns (uint256);

    function rebalanceForWithdraw(uint256 withdrawUsd, bool pwrd) external returns (bool);

    function getDelta(uint256 withdrawUsd) external view returns (uint256[3] memory delta);

    function getVaultDeltaForDeposit(uint256 amount) external view returns (uint256[3] memory, uint256);

    function sortVaultsByDelta(bool bigFirst) external view returns (uint256[3] memory vaultIndexes);

    function getStrategiesTargetRatio(uint256 utilRatio) external view returns (uint256[] memory);

    function setUnderlyingTokenPercents(uint256[3] calldata percents) external;
}

pragma solidity >=0.6.0 <0.7.0;

interface ILifeGuard {
    function assets(uint256 i) external view returns (uint256);

    function totalAssets() external view returns (uint256);

    function getAssets() external view returns (uint256[3] memory);

    function totalAssetsUsd() external view returns (uint256);

    function availableUsd() external view returns (uint256 dollar);

    function availableLP() external view returns (uint256);

    function depositStable(bool rebalance) external returns (uint256);

    function investToCurveVault() external;

    function distributeCurveVault(uint256 amount, uint256[3] memory delta) external returns (uint256[3] memory);

    function deposit() external returns (uint256 usdAmount);

    function withdrawSingleByLiquidity(
        uint256 i,
        uint256 minAmount,
        address recipient
    ) external returns (uint256 usdAmount, uint256 amount);

    function withdrawSingleByExchange(
        uint256 i,
        uint256 minAmount,
        address recipient
    ) external returns (uint256 usdAmount, uint256 amount);

    function invest(uint256 whaleDepositAmount, uint256[3] calldata delta) external returns (uint256 dollarAmount);

    function getBuoy() external view returns (address);

    function investSingle(
        uint256[3] calldata inAmounts,
        uint256 i,
        uint256 j
    ) external returns (uint256 dollarAmount);

    function investToCurveVaultTrigger() external view returns (bool _invest);
}

pragma solidity >=0.6.0 <0.7.0;

interface IWithdrawHandler {
    function withdrawByLPToken(
        bool pwrd,
        uint256 lpAmount,
        uint256[3] calldata minAmounts
    ) external;

    function withdrawByStablecoin(
        bool pwrd,
        uint256 index,
        uint256 lpAmount,
        uint256 minAmount
    ) external;

    function withdrawAllSingle(
        bool pwrd,
        uint256 index,
        uint256 minAmount
    ) external;

    function withdrawAllBalanced(bool pwrd, uint256[3] calldata minAmounts) external;
}

pragma solidity >=0.6.0 <0.7.0;

contract WithdrawHandler is Controllable, FixedStablecoins, FixedVaults, IWithdrawHandler {
    using SafeERC20 for IERC20;
    using SafeMath for uint256;
    IController public ctrl;
    ILifeGuard public lg;
    IBuoy public buoy;
    IInsurance public insurance;
    IEmergencyHandler public emergencyHandler;

    event LogNewDependencies(
        address controller,
        address lifeguard,
        address buoy,
        address insurance,
        address emergencyHandler
    );
    event LogNewWithdrawal(
        address indexed user,
        address indexed referral,
        bool pwrd,
        bool balanced,
        bool all,
        uint256 deductUsd,
        uint256 returnUsd,
        uint256 lpAmount,
        uint256[N_COINS] tokenAmounts
    );

    
    struct WithdrawParameter {
        address account;
        bool pwrd;
        bool balanced;
        bool all;
        uint256 index;
        uint256[N_COINS] minAmounts;
        uint256 lpAmount;
    }

    constructor(
        address[N_COINS] memory _vaults,
        address[N_COINS] memory _tokens,
        uint256[N_COINS] memory _decimals
    ) public FixedStablecoins(_tokens, _decimals) FixedVaults(_vaults) {}

    function setDependencies() external onlyOwner {
        ctrl = _controller();
        lg = ILifeGuard(ctrl.lifeGuard());
        buoy = IBuoy(lg.getBuoy());
        insurance = IInsurance(ctrl.insurance());
        emergencyHandler = IEmergencyHandler(ctrl.emergencyHandler());
        emit LogNewDependencies(
            address(ctrl),
            address(lg),
            address(buoy),
            address(insurance),
            address(emergencyHandler)
        );
    }

    function withdrawByLPToken(
        bool pwrd,
        uint256 lpAmount,
        uint256[N_COINS] calldata minAmounts
    ) external override {
        require(!ctrl.emergencyState(), "withdrawByLPToken: emergencyState");
        require(lpAmount > 0, "!minAmount");
        WithdrawParameter memory parameters = WithdrawParameter(
            msg.sender,
            pwrd,
            true,
            false,
            N_COINS,
            minAmounts,
            lpAmount
        );
        _withdraw(parameters);
    }

    function withdrawByStablecoin(
        bool pwrd,
        uint256 index,
        uint256 lpAmount,
        uint256 minAmount
    ) external override {
        if (ctrl.emergencyState()) {
            emergencyHandler.emergencyWithdrawal(msg.sender, pwrd, lpAmount, minAmount);
        } else {
            require(index < N_COINS, "!withdrawByStablecoin: invalid index");
            require(lpAmount > 0, "!lpAmount");
            uint256[N_COINS] memory minAmounts;
            minAmounts[index] = minAmount;
            WithdrawParameter memory parameters = WithdrawParameter(
                msg.sender,
                pwrd,
                false,
                false,
                index,
                minAmounts,
                lpAmount
            );
            _withdraw(parameters);
        }
    }

    function withdrawAllSingle(
        bool pwrd,
        uint256 index,
        uint256 minAmount
    ) external override {
        if (ctrl.emergencyState()) {
            emergencyHandler.emergencyWithdrawAll(msg.sender, pwrd, minAmount);
        } else {
            _withdrawAllSingleFromAccount(msg.sender, pwrd, index, minAmount);
        }
    }

    function withdrawAllBalanced(bool pwrd, uint256[N_COINS] calldata minAmounts) external override {
        require(!ctrl.emergencyState(), "withdrawByLPToken: emergencyState");
        WithdrawParameter memory parameters = WithdrawParameter(msg.sender, pwrd, true, true, N_COINS, minAmounts, 0);
        _withdraw(parameters);
    }

    function getVaultDeltas(uint256 amount) external view returns (uint256[N_COINS] memory tokenAmounts) {
        uint256[N_COINS] memory delta = insurance.getDelta(buoy.lpToUsd(amount));
        for (uint256 i; i < N_COINS; i++) {
            uint256 withdraw = amount.mul(delta[i]).div(PERCENTAGE_DECIMAL_FACTOR);
            if (withdraw > 0) tokenAmounts[i] = buoy.singleStableFromLp(withdraw, int128(i));
        }
    }

    function withdrawalFee(bool pwrd) public view returns (uint256) {
        return ctrl.withdrawalFee(pwrd);
    }

    function _withdrawAllSingleFromAccount(
        address account,
        bool pwrd,
        uint256 index,
        uint256 minAmount
    ) private {
        require(index < N_COINS, "!withdrawAllSingleFromAccount: invalid index");
        uint256[N_COINS] memory minAmounts;
        minAmounts[index] = minAmount;
        WithdrawParameter memory parameters = WithdrawParameter(account, pwrd, false, true, index, minAmounts, 0);
        _withdraw(parameters);
    }

    function _withdraw(WithdrawParameter memory parameters) private {
        IController _ctrl = ctrl;
        IBuoy _buoy = buoy;
        _ctrl.eoaOnly(msg.sender);
        require(_buoy.safetyCheck(), "!safetyCheck");

        uint256 deductUsd;
        uint256 returnUsd;
        uint256 lpAmountFee;
        uint256[N_COINS] memory tokenAmounts;
        
        uint256 virtualPrice = _buoy.getVirtualPrice();
        if (parameters.all) {
            deductUsd = _ctrl.getUserAssets(parameters.pwrd, parameters.account);
            returnUsd = deductUsd.sub(deductUsd.mul(withdrawalFee(parameters.pwrd)).div(PERCENTAGE_DECIMAL_FACTOR));
            lpAmountFee = returnUsd.mul(DEFAULT_DECIMALS_FACTOR).div(virtualPrice);
            
        } else {
            uint256 userAssets = _ctrl.getUserAssets(parameters.pwrd, parameters.account);
            uint256 lpAmount = parameters.lpAmount;
            uint256 fee = lpAmount.mul(withdrawalFee(parameters.pwrd)).div(PERCENTAGE_DECIMAL_FACTOR);
            lpAmountFee = lpAmount.sub(fee);
            returnUsd = lpAmountFee.mul(virtualPrice).div(DEFAULT_DECIMALS_FACTOR);
            deductUsd = lpAmount.mul(virtualPrice).div(DEFAULT_DECIMALS_FACTOR);
            require(deductUsd <= userAssets, "!withdraw: not enough balance");
        }
        uint256 hodlerBonus = deductUsd.sub(returnUsd);

        bool whale = _ctrl.isValidBigFish(parameters.pwrd, false, returnUsd);

        
        if (parameters.balanced) {
            (returnUsd, tokenAmounts) = _withdrawBalanced(
                parameters.account,
                parameters.pwrd,
                lpAmountFee,
                parameters.minAmounts,
                returnUsd
            );
            
        } else {
            (returnUsd, tokenAmounts[parameters.index]) = _withdrawSingle(
                parameters.account,
                parameters.pwrd,
                lpAmountFee,
                parameters.minAmounts[parameters.index],
                parameters.index,
                returnUsd,
                whale
            );
        }

        _ctrl.burnGToken(parameters.pwrd, parameters.all, parameters.account, deductUsd, hodlerBonus);

        emit LogNewWithdrawal(
            parameters.account,
            _ctrl.referrals(parameters.account),
            parameters.pwrd,
            parameters.balanced,
            parameters.all,
            deductUsd,
            returnUsd,
            lpAmountFee,
            tokenAmounts
        );
    }

    function _withdrawSingle(
        address account,
        bool pwrd,
        uint256 lpAmount,
        uint256 minAmount,
        uint256 index,
        uint256 withdrawUsd,
        bool whale
    ) private returns (uint256 dollarAmount, uint256 tokenAmount) {
        dollarAmount = withdrawUsd;
        
        if (whale) {
            (dollarAmount, tokenAmount) = _prepareForWithdrawalSingle(account, pwrd, index, minAmount, withdrawUsd);
        } else {
            
            IVault adapter = IVault(getVault(index));
            tokenAmount = buoy.singleStableFromLp(lpAmount, int128(index));
            adapter.withdrawByStrategyOrder(tokenAmount, account, pwrd);
        }
        require(tokenAmount >= minAmount, "!withdrawSingle: !minAmount");
    }

    function _withdrawBalanced(
        address account,
        bool pwrd,
        uint256 lpAmount,
        uint256[N_COINS] memory minAmounts,
        uint256 withdrawUsd
    ) private returns (uint256 dollarAmount, uint256[N_COINS] memory tokenAmounts) {
        IBuoy _buoy = buoy;
        uint256[N_COINS] memory delta = insurance.getDelta(withdrawUsd);
        address[N_COINS] memory _vaults = vaults();
        for (uint256 i; i < N_COINS; i++) {
            uint256 withdraw = lpAmount.mul(delta[i]).div(PERCENTAGE_DECIMAL_FACTOR);
            if (withdraw > 0) {
                tokenAmounts[i] = buoy.singleStableFromLp(withdraw, int128(i));
                require(tokenAmounts[i] >= minAmounts[i], "!withdrawBalanced: !minAmount");
                IVault adapter = IVault(_vaults[i]);
                require(tokenAmounts[i] <= adapter.totalAssets(), "_withdrawBalanced: !adapterBalance");
                adapter.withdrawByStrategyOrder(tokenAmounts[i], account, pwrd);
            }
        }
        dollarAmount = buoy.stableToUsd(tokenAmounts, false);
    }

    function _prepareForWithdrawalSingle(
        address account,
        bool pwrd,
        uint256 index,
        uint256 minAmount,
        uint256 withdrawUsd
    ) private returns (uint256 dollarAmount, uint256 amount) {
        bool curve = insurance.rebalanceForWithdraw(withdrawUsd, pwrd);
        ILifeGuard _lg = lg;
        if (curve) {
            _lg.depositStable(false);
            (dollarAmount, amount) = _lg.withdrawSingleByLiquidity(index, minAmount, account);
        } else {
            (dollarAmount, amount) = _lg.withdrawSingleByExchange(index, minAmount, account);
        }
        require(minAmount <= amount, "!prepareForWithdrawalSingle: !minAmount");
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address[3]","name":"_vaults","type":"address[3]"},{"internalType":"address[3]","name":"_tokens","type":"address[3]"},{"internalType":"uint256[3]","name":"_decimals","type":"uint256[3]"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"oldController","type":"address"},{"indexed":true,"internalType":"address","name":"newController","type":"address"}],"name":"ChangeController","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"controller","type":"address"},{"indexed":false,"internalType":"address","name":"lifeguard","type":"address"},{"indexed":false,"internalType":"address","name":"buoy","type":"address"},{"indexed":false,"internalType":"address","name":"insurance","type":"address"},{"indexed":false,"internalType":"address","name":"emergencyHandler","type":"address"}],"name":"LogNewDependencies","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"user","type":"address"},{"indexed":true,"internalType":"address","name":"referral","type":"address"},{"indexed":false,"internalType":"bool","name":"pwrd","type":"bool"},{"indexed":false,"internalType":"bool","name":"balanced","type":"bool"},{"indexed":false,"internalType":"bool","name":"all","type":"bool"},{"indexed":false,"internalType":"uint256","name":"deductUsd","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"returnUsd","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"lpAmount","type":"uint256"},{"indexed":false,"internalType":"uint256[3]","name":"tokenAmounts","type":"uint256[3]"}],"name":"LogNewWithdrawal","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"inputs":[],"name":"CHAINLINK_PRICE_DECIMALS","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"CHAINLINK_PRICE_DECIMAL_FACTOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"CURVE_RATIO_DECIMALS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"CURVE_RATIO_DECIMALS_FACTOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DAI","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DAI_DECIMALS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DAI_VAULT","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFAULT_DECIMALS","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFAULT_DECIMALS_FACTOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"N_COINS","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERCENTAGE_DECIMALS","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERCENTAGE_DECIMAL_FACTOR","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"USDC","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"USDC_DECIMALS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"USDC_VAULT","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"USDT","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"USDT_DECIMALS","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"USDT_VAULT","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"buoy","outputs":[{"internalType":"contract IBuoy","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"controller","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ctrl","outputs":[{"internalType":"contract IController","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ctrlPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"emergencyHandler","outputs":[{"internalType":"contract IEmergencyHandler","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"getVaultDeltas","outputs":[{"internalType":"uint256[3]","name":"tokenAmounts","type":"uint256[3]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"insurance","outputs":[{"internalType":"contract IInsurance","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lg","outputs":[{"internalType":"contract ILifeGuard","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newController","type":"address"}],"name":"setController","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"setDependencies","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"pwrd","type":"bool"},{"internalType":"uint256[3]","name":"minAmounts","type":"uint256[3]"}],"name":"withdrawAllBalanced","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"pwrd","type":"bool"},{"internalType":"uint256","name":"index","type":"uint256"},{"internalType":"uint256","name":"minAmount","type":"uint256"}],"name":"withdrawAllSingle","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"pwrd","type":"bool"},{"internalType":"uint256","name":"lpAmount","type":"uint256"},{"internalType":"uint256[3]","name":"minAmounts","type":"uint256[3]"}],"name":"withdrawByLPToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"pwrd","type":"bool"},{"internalType":"uint256","name":"index","type":"uint256"},{"internalType":"uint256","name":"lpAmount","type":"uint256"},{"internalType":"uint256","name":"minAmount","type":"uint256"}],"name":"withdrawByStablecoin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"pwrd","type":"bool"}],"name":"withdrawalFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

6101a060405234801561001157600080fd5b5060405162002aa738038062002aa7833981810160405261012081101561003757600080fd5b506060810160c08201828282600061004d610107565b600080546001600160a01b0319166001600160a01b0383169081178255604051929350917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908290a35081516001600160601b0319606091821b8116608052602080850151831b821660a052604094850151831b821660c052835160e052838101516101005292840151610120528451821b81166101405291840151811b821661016052929091015190911b16610180525061010b915050565b3390565b60805160601c60a05160601c60c05160601c60e05161010051610120516101405160601c6101605160601c6101805160601c612904620001a36000398061126c5280612421528061272752508061134d52806123f952806127005250806112f152806123d452806126d052508061137152508061129f525080610f065250806112c8525080610f2a52508061131552506129046000f3fe608060405234801561001057600080fd5b506004361061021c5760003560e01c80639793869b11610125578063e088c67c116100ad578063eba643891161007c578063eba643891461047f578063ef2cfd1a14610487578063f06d00411461048f578063f2fde38b14610497578063f77c4791146104bd5761021c565b8063e088c67c1461045f578063e0bab4c414610467578063e963f18f1461046f578063ea0d5c52146104775761021c565b8063b1cbf3ad116100f4578063b1cbf3ad14610437578063c1419def1461043f578063c5008f4614610447578063c54e44eb1461044f578063e0501ecf146104575761021c565b80639793869b146103ee578063a432729b1461041f578063ae70b98a14610427578063b14e12841461042f5761021c565b80636f923e73116101a857806389a302711161017757806389a30271146103a857806389cf3204146103b05780638da5cb5b146103b857806390706425146103c057806392eefe9b146103c85761021c565b80636f923e7314610388578063715018a6146103905780637f185162146103985780637ffc945c146103a05761021c565b806342f37c75116101ef57806342f37c75146102a157806350d3deaf146102c557806366b7d9f4146102e45780636a12a3c4146103085780636a4a34581461035d5761021c565b80630c33bc5d1461022157806319e409931461024d578063250108f6146102695780632935775014610283575b600080fd5b61024b600480360360a081101561023757600080fd5b5080351515906020810135906040016104c5565b005b610255610634565b604080519115158252519081900360200190f35b6102716106a7565b60408051918252519081900360200190f35b61028b6106ae565b6040805160ff9092168252519081900360200190f35b6102a96106b3565b604080516001600160a01b039092168252519081900360200190f35b610271600480360360208110156102db57600080fd5b503515156106c2565b61024b600480360360808110156102fa57600080fd5b508035151590602001610743565b6103256004803603602081101561031e57600080fd5b5035610880565b6040518082606080838360005b8381101561034a578181015183820152602001610332565b5050505090500191505060405180910390f35b61024b6004803603606081101561037357600080fd5b50803515159060208101359060400135610a69565b61028b610b6c565b61024b610b71565b61024b610c13565b610271610f04565b6102a9610f28565b6102a9610f4c565b6102a9610f5b565b61028b610f6a565b61024b600480360360208110156103de57600080fd5b50356001600160a01b0316610f6f565b61024b6004803603608081101561040457600080fd5b50803515159060208101359060408101359060600135611069565b6102a9611255565b610271611264565b6102a961126a565b6102a961128e565b61027161129d565b61028b6112c1565b6102a96112c6565b6102716112ea565b6102a96112ef565b6102a9611313565b610271611337565b61027161133f565b6102a961134b565b61027161136f565b6102a9611393565b61024b600480360360208110156104ad57600080fd5b50356001600160a01b03166113a2565b6102a961149a565b600260009054906101000a90046001600160a01b03166001600160a01b031663f8a338a56040518163ffffffff1660e01b815260040160206040518083038186803b15801561051357600080fd5b505afa158015610527573d6000803e3d6000fd5b505050506040513d602081101561053d57600080fd5b50511561057b5760405162461bcd60e51b81526004018080602001828103825260218152602001806128ae6021913960400191505060405180910390fd5b600082116105bd576040805162461bcd60e51b815260206004820152600a602482015269085b5a5b905b5bdd5b9d60b21b604482015290519081900360640190fd5b6105c561274b565b6040805160e081018252338152851515602082015260018183015260006060808301919091526003608083018190528351808301909452919260a08401929091869190839083908082843760009201919091525050508152602001849052905061062e816114a9565b50505050565b600061063e611b3e565b6001600160a01b0316635c975abb6040518163ffffffff1660e01b815260040160206040518083038186803b15801561067657600080fd5b505afa15801561068a573d6000803e3d6000fd5b505050506040513d60208110156106a057600080fd5b5051905090565b620f424081565b600381565b6002546001600160a01b031681565b600254604080516350d3deaf60e01b8152831515600482015290516000926001600160a01b0316916350d3deaf916024808301926020929190829003018186803b15801561070f57600080fd5b505afa158015610723573d6000803e3d6000fd5b505050506040513d602081101561073957600080fd5b505190505b919050565b600260009054906101000a90046001600160a01b03166001600160a01b031663f8a338a56040518163ffffffff1660e01b815260040160206040518083038186803b15801561079157600080fd5b505afa1580156107a5573d6000803e3d6000fd5b505050506040513d60208110156107bb57600080fd5b5051156107f95760405162461bcd60e51b81526004018080602001828103825260218152602001806128ae6021913960400191505060405180910390fd5b61080161274b565b6040518060e00160405280336001600160a01b031681526020018415158152602001600115158152602001600115158152602001600360ff16815260200183600380602002604051908101604052809291908260036020028082843760009201829052509284525050602090910152905061087b816114a9565b505050565b61088861278f565b61089061278f565b600554600480546040805162f9bd7360e21b8152928301879052516001600160a01b03938416936356322586939216916303e6f5cc916024808301926020929190829003018186803b1580156108e557600080fd5b505afa1580156108f9573d6000803e3d6000fd5b505050506040513d602081101561090f57600080fd5b5051604080516001600160e01b031960e085901b1681526004810192909252516024808301926060929190829003018186803b15801561094e57600080fd5b505afa158015610962573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250606081101561098757600080fd5b50905060005b6003811015610a625760006109bf6127106109b98585600381106109ad57fe5b60200201518890611ba3565b90611c05565b90508015610a5957600480546040805163ae35980f60e01b8152928301849052600f85900b6024840152516001600160a01b039091169163ae35980f916044808301926020929190829003018186803b158015610a1b57600080fd5b505afa158015610a2f573d6000803e3d6000fd5b505050506040513d6020811015610a4557600080fd5b5051848360038110610a5357fe5b60200201525b5060010161098d565b5050919050565b600260009054906101000a90046001600160a01b03166001600160a01b031663f8a338a56040518163ffffffff1660e01b815260040160206040518083038186803b158015610ab757600080fd5b505afa158015610acb573d6000803e3d6000fd5b505050506040513d6020811015610ae157600080fd5b505115610b60576006546040805163183a1ec760e01b815233600482015285151560248201526044810184905290516001600160a01b039092169163183a1ec79160648082019260009290919082900301818387803b158015610b4357600080fd5b505af1158015610b57573d6000803e3d6000fd5b5050505061087b565b61087b33848484611c47565b600881565b610b79611cf8565b6000546001600160a01b03908116911614610bc9576040805162461bcd60e51b81526020600482018190526024820152600080516020612867833981519152604482015290519081900360640190fd5b600080546040516001600160a01b03909116907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0908390a3600080546001600160a01b0319169055565b610c1b611cf8565b6000546001600160a01b03908116911614610c6b576040805162461bcd60e51b81526020600482018190526024820152600080516020612867833981519152604482015290519081900360640190fd5b610c73611b3e565b600280546001600160a01b0319166001600160a01b03928316179081905560408051631673f39960e31b81529051919092169163b39f9cc8916004808301926020929190829003018186803b158015610ccb57600080fd5b505afa158015610cdf573d6000803e3d6000fd5b505050506040513d6020811015610cf557600080fd5b5051600380546001600160a01b0319166001600160a01b0392831617908190556040805163522b5b8160e11b81529051919092169163a456b702916004808301926020929190829003018186803b158015610d4f57600080fd5b505afa158015610d63573d6000803e3d6000fd5b505050506040513d6020811015610d7957600080fd5b5051600480546001600160a01b0319166001600160a01b0392831617815560025460408051632273cc8160e21b8152905191909316926389cf32049281810192602092909190829003018186803b158015610dd357600080fd5b505afa158015610de7573d6000803e3d6000fd5b505050506040513d6020811015610dfd57600080fd5b5051600580546001600160a01b0319166001600160a01b039283161790556002546040805163f06d004160e01b81529051919092169163f06d0041916004808301926020929190829003018186803b158015610e5857600080fd5b505afa158015610e6c573d6000803e3d6000fd5b505050506040513d6020811015610e8257600080fd5b5051600680546001600160a01b0319166001600160a01b03928316179081905560025460035460045460055460408051948716855292861660208501529085168383015284166060830152919092166080830152517fe564df9b62508f6c2ff6a6fa5b82ea1a0f5b19087d9043593928a264dc872d9c9160a0908290030190a1565b7f000000000000000000000000000000000000000000000000000000000000000081565b7f000000000000000000000000000000000000000000000000000000000000000081565b6005546001600160a01b031681565b6000546001600160a01b031690565b600481565b610f77611cf8565b6000546001600160a01b03908116911614610fc7576040805162461bcd60e51b81526020600482018190526024820152600080516020612867833981519152604482015290519081900360640190fd5b6001600160a01b038116611017576040805162461bcd60e51b81526020600482015260126024820152710e6cae886dedce8e4ded8d8cae474404260f60731b604482015290519081900360640190fd5b600180546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f7bd9aab74fc8b860dff8328bda449632993abb9bd61340154740618a3debeb8990600090a35050565b600260009054906101000a90046001600160a01b03166001600160a01b031663f8a338a56040518163ffffffff1660e01b815260040160206040518083038186803b1580156110b757600080fd5b505afa1580156110cb573d6000803e3d6000fd5b505050506040513d60208110156110e157600080fd5b505115611167576006546040805163e16fdeab60e01b81523360048201528615156024820152604481018590526064810184905290516001600160a01b039092169163e16fdeab9160848082019260009290919082900301818387803b15801561114a57600080fd5b505af115801561115e573d6000803e3d6000fd5b5050505061062e565b600383106111a65760405162461bcd60e51b81526004018080602001828103825260248152602001806127d46024913960400191505060405180910390fd5b600082116111e7576040805162461bcd60e51b8152602060048201526009602482015268085b1c105b5bdd5b9d60ba1b604482015290519081900360640190fd5b6111ef61278f565b818185600381106111fc57fe5b602002015261120961274b565b506040805160e0810182523381528615156020820152600091810182905260608101919091526080810185905260a0810182905260c0810184905261124d816114a9565b505050505050565b6003546001600160a01b031681565b61271081565b7f000000000000000000000000000000000000000000000000000000000000000081565b6004546001600160a01b031681565b7f000000000000000000000000000000000000000000000000000000000000000081565b601281565b7f000000000000000000000000000000000000000000000000000000000000000081565b600681565b7f000000000000000000000000000000000000000000000000000000000000000081565b7f000000000000000000000000000000000000000000000000000000000000000081565b6305f5e10081565b670de0b6b3a764000081565b7f000000000000000000000000000000000000000000000000000000000000000081565b7f000000000000000000000000000000000000000000000000000000000000000081565b6006546001600160a01b031681565b6113aa611cf8565b6000546001600160a01b039081169116146113fa576040805162461bcd60e51b81526020600482018190526024820152600080516020612867833981519152604482015290519081900360640190fd5b6001600160a01b03811661143f5760405162461bcd60e51b81526004018080602001828103825260268152602001806127ae6026913960400191505060405180910390fd5b600080546040516001600160a01b03808516939216917f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e091a3600080546001600160a01b0319166001600160a01b0392909216919091179055565b6001546001600160a01b031681565b60025460048054604080516351107b0560e11b81523393810193909352516001600160a01b039384169390911691839163a220f60a9160248082019260009290919082900301818387803b15801561150057600080fd5b505af1158015611514573d6000803e3d6000fd5b50505050806001600160a01b031663aff1d8e56040518163ffffffff1660e01b815260040160206040518083038186803b15801561155157600080fd5b505afa158015611565573d6000803e3d6000fd5b505050506040513d602081101561157b57600080fd5b50516115bd576040805162461bcd60e51b815260206004820152600c60248201526b21736166657479436865636b60a01b604482015290519081900360640190fd5b60008060006115ca61278f565b6000856001600160a01b031663e25aa5fa6040518163ffffffff1660e01b815260040160206040518083038186803b15801561160557600080fd5b505afa158015611619573d6000803e3d6000fd5b505050506040513d602081101561162f57600080fd5b505160608901519091501561170c5760208089015189516040805163c3709e5b60e01b815292151560048401526001600160a01b03918216602484015251908a169263c3709e5b9260448082019391829003018186803b15801561169257600080fd5b505afa1580156116a6573d6000803e3d6000fd5b505050506040513d60208110156116bc57600080fd5b505160208901519095506116ed906116e690612710906109b9906116df906106c2565b8990611ba3565b8690611cfc565b9350611705816109b986670de0b6b3a7640000611ba3565b9250611854565b60208089015189516040805163c3709e5b60e01b815292151560048401526001600160a01b03918216602484015251600093918b169263c3709e5b926044808301939192829003018186803b15801561176457600080fd5b505afa158015611778573d6000803e3d6000fd5b505050506040513d602081101561178e57600080fd5b505160c08a015160208b0151919250906000906117bd90612710906109b9906117b6906106c2565b8590611ba3565b90506117c98282611cfc565b95506117e1670de0b6b3a76400006109b98887611ba3565b96506117f9670de0b6b3a76400006109b98487611ba3565b975082881115611850576040805162461bcd60e51b815260206004820152601d60248201527f2177697468647261773a206e6f7420656e6f7567682062616c616e6365000000604482015290519081900360640190fd5b5050505b60006118608686611cfc565b6020808b015160408051634094685960e01b81529115156004830152600060248301819052604483018a90529051939450926001600160a01b038c169263409468599260648082019391829003018186803b1580156118be57600080fd5b505afa1580156118d2573d6000803e3d6000fd5b505050506040513d60208110156118e857600080fd5b505160408b01519091501561191a576119108a600001518b60200151878d60a001518a611d3e565b9096509350611965565b61194d8a600001518b60200151878d60a001518e608001516003811061193c57fe5b60200201518e608001518b87612141565b858c608001516003811061195d57fe5b602002015295505b60208a015160608b01518b51604080516378a8847760e01b8152931515600485015291151560248401526001600160a01b039081166044840152606483018a9052608483018590529051908b16916378a884779160a480830192600092919082900301818387803b1580156119d957600080fd5b505af11580156119ed573d6000803e3d6000fd5b50505050886001600160a01b0316639ca423b38b600001516040518263ffffffff1660e01b815260040180826001600160a01b0316815260200191505060206040518083038186803b158015611a4257600080fd5b505afa158015611a56573d6000803e3d6000fd5b505050506040513d6020811015611a6c57600080fd5b81019080805190602001909291905050506001600160a01b03168a600001516001600160a01b03167f64801196bdd255d4dd88bfd3e78324c2d63634b67e53e04166db348f7cd964908c602001518d604001518e606001518c8c8c8c6040518088151581526020018715158152602001861515815260200185815260200184815260200183815260200182600360200280838360005b83811015611b1a578181015183820152602001611b02565b5050505090500197505050505050505060405180910390a350505050505050505050565b6001546000906001600160a01b0316611b93576040805162461bcd60e51b815260206004820152601260248201527110dbdb9d1c9bdb1b195c881b9bdd081cd95d60721b604482015290519081900360640190fd5b506001546001600160a01b031690565b600082611bb257506000611bff565b82820282848281611bbf57fe5b0414611bfc5760405162461bcd60e51b81526004018080602001828103825260218152602001806128466021913960400191505060405180910390fd5b90505b92915050565b6000611bfc83836040518060400160405280601a81526020017f536166654d6174683a206469766973696f6e206279207a65726f0000000000008152506122c6565b60038210611c865760405162461bcd60e51b815260040180806020018281038252602c8152602001806127f8602c913960400191505060405180910390fd5b611c8e61278f565b81818460038110611c9b57fe5b6020020152611ca861274b565b6040518060e00160405280876001600160a01b0316815260200186151581526020016000151581526020016001151581526020018581526020018381526020016000815250905061124d816114a9565b3390565b6000611bfc83836040518060400160405280601e81526020017f536166654d6174683a207375627472616374696f6e206f766572666c6f770000815250612368565b6000611d4861278f565b6004546001600160a01b0316611d5c61278f565b60055460408051632b1912c360e11b81526004810188905290516001600160a01b0390921691635632258691602480820192606092909190829003018186803b158015611da857600080fd5b505afa158015611dbc573d6000803e3d6000fd5b505050506040513d601f19601f820116820180604052506060811015611de157600080fd5b509050611dec61278f565b611df46123c2565b905060005b600381101561208f576000611e256127106109b9868560038110611e1957fe5b60200201518d90611ba3565b9050801561208657600480546040805163ae35980f60e01b8152928301849052600f85900b6024840152516001600160a01b039091169163ae35980f916044808301926020929190829003018186803b158015611e8157600080fd5b505afa158015611e95573d6000803e3d6000fd5b505050506040513d6020811015611eab57600080fd5b5051868360038110611eb957fe5b6020020152888260038110611eca57fe5b6020020151868360038110611edb57fe5b60200201511015611f33576040805162461bcd60e51b815260206004820152601d60248201527f21776974686472617742616c616e6365643a20216d696e416d6f756e74000000604482015290519081900360640190fd5b6000838360038110611f4157fe5b60200201519050806001600160a01b03166301e1d1146040518163ffffffff1660e01b815260040160206040518083038186803b158015611f8157600080fd5b505afa158015611f95573d6000803e3d6000fd5b505050506040513d6020811015611fab57600080fd5b5051878460038110611fb957fe5b60200201511115611ffb5760405162461bcd60e51b81526004018080602001828103825260228152602001806128246022913960400191505060405180910390fd5b806001600160a01b031663c0936b9488856003811061201657fe5b60200201518f8f6040518463ffffffff1660e01b815260040180848152602001836001600160a01b0316815260200182151581526020019350505050600060405180830381600087803b15801561206c57600080fd5b505af1158015612080573d6000803e3d6000fd5b50505050505b50600101611df9565b506004805460405163538ef7e160e01b81526001600160a01b039091169163538ef7e19187916000910180836060808383875b838110156120da5781810151838201526020016120c2565b5050505090500182151581526020019250505060206040518083038186803b15801561210557600080fd5b505afa158015612119573d6000803e3d6000fd5b505050506040513d602081101561212f57600080fd5b50519a93995092975050505050505050565b8160008215612161576121578989878988612449565b9092509050612265565b600061216c866126c6565b600480546040805163ae35980f60e01b81529283018c9052600f8a900b6024840152519293506001600160a01b03169163ae35980f91604480820192602092909190829003018186803b1580156121c257600080fd5b505afa1580156121d6573d6000803e3d6000fd5b505050506040513d60208110156121ec57600080fd5b505160408051633024dae560e21b8152600481018390526001600160a01b038d811660248301528c1515604483015291519294509083169163c0936b949160648082019260009290919082900301818387803b15801561224b57600080fd5b505af115801561225f573d6000803e3d6000fd5b50505050505b858110156122ba576040805162461bcd60e51b815260206004820152601b60248201527f21776974686472617753696e676c653a20216d696e416d6f756e740000000000604482015290519081900360640190fd5b97509795505050505050565b600081836123525760405162461bcd60e51b81526004018080602001828103825283818151815260200191508051906020019080838360005b838110156123175781810151838201526020016122ff565b50505050905090810190601f1680156123445780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b50600083858161235e57fe5b0495945050505050565b600081848411156123ba5760405162461bcd60e51b81526020600482018181528351602484015283519092839260449091019190850190808383600083156123175781810151838201526020016122ff565b505050900390565b6123ca61278f565b6001600160a01b037f0000000000000000000000000000000000000000000000000000000000000000811682527f0000000000000000000000000000000000000000000000000000000000000000811660208301527f000000000000000000000000000000000000000000000000000000000000000016604082015290565b60055460408051637901cc0960e01b81526004810184905286151560248201529051600092839283926001600160a01b0390921691637901cc099160448082019260209290919082900301818787803b1580156124a557600080fd5b505af11580156124b9573d6000803e3d6000fd5b505050506040513d60208110156124cf57600080fd5b50516003549091506001600160a01b031681156125ed57806001600160a01b031663e2e5b1dd60006040518263ffffffff1660e01b8152600401808215158152602001915050602060405180830381600087803b15801561252f57600080fd5b505af1158015612543573d6000803e3d6000fd5b505050506040513d602081101561255957600080fd5b505060408051630e7708b360e41b815260048101899052602481018890526001600160a01b038b8116604483015282519084169263e7708b3092606480820193918290030181600087803b1580156125b057600080fd5b505af11580156125c4573d6000803e3d6000fd5b505050506040513d60408110156125da57600080fd5b508051602090910151909450925061267b565b60408051633630fa0560e21b815260048101899052602481018890526001600160a01b038b8116604483015282519084169263d8c3e81492606480820193918290030181600087803b15801561264257600080fd5b505af1158015612656573d6000803e3d6000fd5b505050506040513d604081101561266c57600080fd5b50805160209091015190945092505b828611156126ba5760405162461bcd60e51b81526004018080602001828103825260278152602001806128876027913960400191505060405180910390fd5b50509550959350505050565b6000816126f457507f000000000000000000000000000000000000000000000000000000000000000061073e565b816001141561272457507f000000000000000000000000000000000000000000000000000000000000000061073e565b507f000000000000000000000000000000000000000000000000000000000000000061073e565b6040805160e08101825260008082526020820181905291810182905260608101829052608081019190915260a0810161278261278f565b8152602001600081525090565b6040518060600160405280600390602082028036833750919291505056fe4f776e61626c653a206e6577206f776e657220697320746865207a65726f20616464726573732177697468647261774279537461626c65636f696e3a20696e76616c696420696e646578217769746864726177416c6c53696e676c6546726f6d4163636f756e743a20696e76616c696420696e6465785f776974686472617742616c616e6365643a20216164617074657242616c616e6365536166654d6174683a206d756c7469706c69636174696f6e206f766572666c6f774f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e65722170726570617265466f725769746864726177616c53696e676c653a20216d696e416d6f756e74776974686472617742794c50546f6b656e3a20656d657267656e63795374617465a2646970667358221220229f92a98b66903cf030a2b54c405da7a831cac89b1b486d9780de8e2da8511364736f6c634300060c0033000000000000000000000000277947d84a2ec370a636683799351acef97fec600000000000000000000000009b2688da7d80641f6e46a76889ea7f8b597717240000000000000000000000006419cb544878e8c4faa5eaf22d59d4a96e5f12fa0000000000000000000000006b175474e89094c44da98b954eedeac495271d0f000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec70000000000000000000000000000000000000000000000000de0b6b3a764000000000000000000000000000000000000000000000000000000000000000f424000000000000000000000000000000000000000000000000000000000000f4240

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

000000000000000000000000277947d84a2ec370a636683799351acef97fec600000000000000000000000009b2688da7d80641f6e46a76889ea7f8b597717240000000000000000000000006419cb544878e8c4faa5eaf22d59d4a96e5f12fa0000000000000000000000006b175474e89094c44da98b954eedeac495271d0f000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec70000000000000000000000000000000000000000000000000de0b6b3a764000000000000000000000000000000000000000000000000000000000000000f424000000000000000000000000000000000000000000000000000000000000f4240

-----Decoded View---------------
Arg [0] : _vaults (address[3]): 0x277947D84A2Ec370a636683799351acef97fec60,0x9B2688DA7d80641F6E46A76889EA7F8B59771724,0x6419Cb544878E8C4faA5EaF22D59d4A96E5F12FA
Arg [1] : _tokens (address[3]): 0x6B175474E89094C44Da98b954EedeAC495271d0F,0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48,0xdAC17F958D2ee523a2206206994597C13D831ec7
Arg [2] : _decimals (uint256[3]): 1000000000000000000,1000000,1000000

-----Encoded View---------------
9 Constructor Arguments found :
Arg [0] : 000000000000000000000000277947d84a2ec370a636683799351acef97fec60
Arg [1] : 0000000000000000000000009b2688da7d80641f6e46a76889ea7f8b59771724
Arg [2] : 0000000000000000000000006419cb544878e8c4faa5eaf22d59d4a96e5f12fa
Arg [3] : 0000000000000000000000006b175474e89094c44da98b954eedeac495271d0f
Arg [4] : 000000000000000000000000a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48
Arg [5] : 000000000000000000000000dac17f958d2ee523a2206206994597c13d831ec7
Arg [6] : 0000000000000000000000000000000000000000000000000de0b6b3a7640000
Arg [7] : 00000000000000000000000000000000000000000000000000000000000f4240
Arg [8] : 00000000000000000000000000000000000000000000000000000000000f4240

33219:10071:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34962:541;;;;;;;;;;;;;;;;-1:-1:-1;34962:541:0;;;;;;;;;;;;;:::i;:::-;;28075:95;;;:::i;:::-;;;;;;;;;;;;;;;;;;20484:87;;;:::i;:::-;;;;;;;;;;;;;;;;19951:33;;;:::i;:::-;;;;;;;;;;;;;;;;;;;33382:23;;;:::i;:::-;;;;-1:-1:-1;;;;;33382:23:0;;;;;;;;;;;;;;37507:114;;;;;;;;;;;;;;;;-1:-1:-1;37507:114:0;;;;:::i;36728:335::-;;;;;;;;;;;;;;;;-1:-1:-1;36728:335:0;;;;;;;;:::i;37071:428::-;;;;;;;;;;;;;;;;-1:-1:-1;37071:428:0;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36360:360;;;;;;;;;;;;;;;;-1:-1:-1;36360:360:0;;;;;;;;;;;;;;:::i;20128:50::-;;;:::i;2544:148::-;;;:::i;34465:489::-;;;:::i;22720:37::-;;;:::i;22644:29::-;;;:::i;33463:27::-;;;:::i;1902:79::-;;;:::i;20286:45::-;;;:::i;28178:286::-;;;;;;;;;;;;;;;;-1:-1:-1;28178:286:0;-1:-1:-1;;;;;28178:286:0;;:::i;35511:841::-;;;;;;;;;;;;;;;;-1:-1:-1;35511:841:0;;;;;;;;;;;;;;;;;;;:::i;33412:20::-;;;:::i;20338:84::-;;;:::i;24599:35::-;;;:::i;33439:17::-;;;:::i;22765:38::-;;;:::i;19991:43::-;;;:::i;22681:29::-;;;:::i;20429:48::-;;;:::i;24516:34::-;;;:::i;22608:28::-;;;:::i;20185:94::-;;;:::i;20042:79::-;;;:::i;24557:35::-;;;:::i;22811:38::-;;;:::i;33497:41::-;;;:::i;2847:244::-;;;;;;;;;;;;;;;;-1:-1:-1;2847:244:0;-1:-1:-1;;;;;2847:244:0;;:::i;27720:25::-;;;:::i;34962:541::-;35128:4;;;;;;;;;-1:-1:-1;;;;;35128:4:0;-1:-1:-1;;;;;35128:19:0;;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;35128:21:0;35127:22;35119:68;;;;-1:-1:-1;;;35119:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35217:1;35206:8;:12;35198:35;;;;;-1:-1:-1;;;35198:35:0;;;;;;;;;;;;-1:-1:-1;;;35198:35:0;;;;;;;;;;;;;;;35244;;:::i;:::-;35282:181;;;;;;;;35314:10;35282:181;;;;;;;;;35358:4;35282:181;;;;-1:-1:-1;35282:181:0;;;;;;;;19983:1;35282:181;;;;;;;;;;;;;;;;;;;;;;35419:10;;19983:1;35282:181;;35419:10;;35282:181;35419:10;35282:181;;;;;;;;;-1:-1:-1;;;35282:181:0;;;;;;;35244:219;-1:-1:-1;35474:21:0;35244:219;35474:9;:21::i;:::-;34962:541;;;;:::o;28075:95::-;28118:4;28142:11;:9;:11::i;:::-;-1:-1:-1;;;;;28142:18:0;;:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;28142:20:0;;-1:-1:-1;28075:95:0;:::o;20484:87::-;20538:33;20484:87;:::o;19951:33::-;19983:1;19951:33;:::o;33382:23::-;;;-1:-1:-1;;;;;33382:23:0;;:::o;37507:114::-;37589:4;;:24;;;-1:-1:-1;;;37589:24:0;;;;;;;;;;;37562:7;;-1:-1:-1;;;;;37589:4:0;;:18;;:24;;;;;;;;;;;;;;:4;:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;37589:24:0;;-1:-1:-1;37507:114:0;;;;:::o;36728:335::-;36844:4;;;;;;;;;-1:-1:-1;;;;;36844:4:0;-1:-1:-1;;;;;36844:19:0;;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;36844:21:0;36843:22;36835:68;;;;-1:-1:-1;;;36835:68:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36914:35;;:::i;:::-;36952:71;;;;;;;;36970:10;-1:-1:-1;;;;;36952:71:0;;;;;36982:4;36952:71;;;;;;36988:4;36952:71;;;;;;36994:4;36952:71;;;;;;19983:1;36952:71;;;;;;37009:10;36952:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;36952:71:0;;;-1:-1:-1;;36952:71:0;;;;;36914:109;-1:-1:-1;37034:21:0;36914:109;37034:9;:21::i;:::-;36728:335;;;:::o;37071:428::-;37134:36;;:::i;:::-;37183:29;;:::i;:::-;37215:9;;37234:4;;;:20;;;-1:-1:-1;;;37234:20:0;;;;;;;;;-1:-1:-1;;;;;37215:9:0;;;;:18;;37234:4;;;:12;;:20;;;;;;;;;;;;;;:4;:20;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;37234:20:0;37215:40;;;-1:-1:-1;;;;;;37215:40:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;37215:40:0;-1:-1:-1;37271:9:0;37266:226;19983:1;37282:11;;37266:226;;;37315:16;37334:51;20390:32;37334:20;37345:5;37351:1;37345:8;;;;;;;;;;;37334:6;;:10;:20::i;:::-;:24;;:51::i;:::-;37315:70;-1:-1:-1;37404:12:0;;37400:80;;37436:4;;;:44;;;-1:-1:-1;;;37436:44:0;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;37436:4:0;;;;:23;;:44;;;;;;;;;;;;;;:4;:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;37436:44:0;37418:12;37431:1;37418:15;;;;;;;;;;:62;37400:80;-1:-1:-1;37295:3:0;;37266:226;;;;37071:428;;;;:::o;36360:360::-;36499:4;;;;;;;;;-1:-1:-1;;;;;36499:4:0;-1:-1:-1;;;;;36499:19:0;;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;36499:21:0;36495:218;;;36537:16;;:66;;;-1:-1:-1;;;36537:66:0;;36575:10;36537:66;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;36537:16:0;;;;:37;;:66;;;;;:16;;:66;;;;;;;;:16;;:66;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36495:218;;;36636:65;36666:10;36678:4;36684:5;36691:9;36636:29;:65::i;20128:50::-;20177:1;20128:50;:::o;2544:148::-;2124:12;:10;:12::i;:::-;2114:6;;-1:-1:-1;;;;;2114:6:0;;;:22;;;2106:67;;;;;-1:-1:-1;;;2106:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2106:67:0;;;;;;;;;;;;;;;2651:1:::1;2635:6:::0;;2614:40:::1;::::0;-1:-1:-1;;;;;2635:6:0;;::::1;::::0;2614:40:::1;::::0;2651:1;;2614:40:::1;2682:1;2665:19:::0;;-1:-1:-1;;;;;;2665:19:0::1;::::0;;2544:148::o;34465:489::-;2124:12;:10;:12::i;:::-;2114:6;;-1:-1:-1;;;;;2114:6:0;;;:22;;;2106:67;;;;;-1:-1:-1;;;2106:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2106:67:0;;;;;;;;;;;;;;;34529:13:::1;:11;:13::i;:::-;34522:4;:20:::0;;-1:-1:-1;;;;;;34522:20:0::1;-1:-1:-1::0;;;;;34522:20:0;;::::1;;::::0;;;;34569:16:::1;::::0;;-1:-1:-1;;;34569:16:0;;;;:4;;;::::1;::::0;:14:::1;::::0;:16:::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;:4;:16;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;34569:16:0;34553:2:::1;:33:::0;;-1:-1:-1;;;;;;34553:33:0::1;-1:-1:-1::0;;;;;34553:33:0;;::::1;;::::0;;;;34610:12:::1;::::0;;-1:-1:-1;;;34610:12:0;;;;:2;;;::::1;::::0;:10:::1;::::0;:12:::1;::::0;;::::1;::::0;34569:16:::1;::::0;34610:12;;;;;;;:2;:12;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;34610:12:0;34597:4:::1;:26:::0;;-1:-1:-1;;;;;;34597:26:0::1;-1:-1:-1::0;;;;;34597:26:0;;::::1;;::::0;;34657:4:::1;::::0;:16:::1;::::0;;-1:-1:-1;;;34657:16:0;;;;:4;;;::::1;::::0;:14:::1;::::0;:16;;::::1;::::0;34610:12:::1;::::0;34657:16;;;;;;;;:4;:16;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;34657:16:0;34634:9:::1;:40:::0;;-1:-1:-1;;;;;;34634:40:0::1;-1:-1:-1::0;;;;;34634:40:0;;::::1;;::::0;;34722:4:::1;::::0;:23:::1;::::0;;-1:-1:-1;;;34722:23:0;;;;:4;;;::::1;::::0;:21:::1;::::0;:23:::1;::::0;;::::1;::::0;34657:16:::1;::::0;34722:23;;;;;;;:4;:23;::::1;;::::0;::::1;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;::::0;::::1;;-1:-1:-1::0;34722:23:0;34685:16:::1;:61:::0;;-1:-1:-1;;;;;;34685:61:0::1;-1:-1:-1::0;;;;;34685:61:0;;::::1;;::::0;;;;34803:4:::1;::::0;34831:2:::1;::::0;34857:4:::1;::::0;34885:9:::1;::::0;34762:184:::1;::::0;;34803:4;;::::1;34762:184:::0;;34831:2;;::::1;34722:23;34762:184:::0;::::1;::::0;34857:4;;::::1;34762:184:::0;;;;34885:9;::::1;34762:184:::0;;;;34918:16;;;::::1;34762:184:::0;;;;;::::1;::::0;;;;;;;;::::1;34465:489::o:0;22720:37::-;;;:::o;22644:29::-;;;:::o;33463:27::-;;;-1:-1:-1;;;;;33463:27:0;;:::o;1902:79::-;1940:7;1967:6;-1:-1:-1;;;;;1967:6:0;1902:79;:::o;20286:45::-;20330:1;20286:45;:::o;28178:286::-;2124:12;:10;:12::i;:::-;2114:6;;-1:-1:-1;;;;;2114:6:0;;;:22;;;2106:67;;;;;-1:-1:-1;;;2106:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2106:67:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;28262:27:0;::::1;28254:58;;;::::0;;-1:-1:-1;;;28254:58:0;;::::1;;::::0;::::1;::::0;::::1;::::0;;;;-1:-1:-1;;;28254:58:0;;;;;;;;;;;;;::::1;;28347:10;::::0;;-1:-1:-1;;;;;28368:26:0;;::::1;-1:-1:-1::0;;;;;;28368:26:0;::::1;::::0;::::1;::::0;;;28410:46:::1;::::0;28347:10;::::1;::::0;28368:26;28347:10;;28410:46:::1;::::0;28323:21:::1;::::0;28410:46:::1;2184:1;28178:286:::0;:::o;35511:841::-;35680:4;;;;;;;;;-1:-1:-1;;;;;35680:4:0;-1:-1:-1;;;;;35680:19:0;;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;35680:21:0;35676:669;;;35718:16;;:75;;;-1:-1:-1;;;35718:75:0;;35755:10;35718:75;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;35718:16:0;;;;:36;;:75;;;;;:16;;:75;;;;;;;;:16;;:75;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35676:669;;;19983:1;35834:15;;35826:64;;;;-1:-1:-1;;;35826:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35924:1;35913:8;:12;35905:34;;;;;-1:-1:-1;;;35905:34:0;;;;;;;;;;;;-1:-1:-1;;;35905:34:0;;;;;;;;;;;;;;;35954;;:::i;:::-;36023:9;36003:10;36014:5;36003:17;;;;;;;;;;:29;36047:35;;:::i;:::-;-1:-1:-1;36085:212:0;;;;;;;;36121:10;36085:212;;;;;;;;;-1:-1:-1;36085:212:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36312:21;36085:212;36312:9;:21::i;:::-;35676:669;;35511:841;;;;:::o;33412:20::-;;;-1:-1:-1;;;;;33412:20:0;;:::o;20338:84::-;20390:32;20338:84;:::o;24599:35::-;;;:::o;33439:17::-;;;-1:-1:-1;;;;;33439:17:0;;:::o;22765:38::-;;;:::o;19991:43::-;20032:2;19991:43;:::o;22681:29::-;;;:::o;20429:48::-;20476:1;20429:48;:::o;24516:34::-;;;:::o;22608:28::-;;;:::o;20185:94::-;20242:37;20185:94;:::o;20042:79::-;20092:29;20042:79;:::o;24557:35::-;;;:::o;22811:38::-;;;:::o;33497:41::-;;;-1:-1:-1;;;;;33497:41:0;;:::o;2847:244::-;2124:12;:10;:12::i;:::-;2114:6;;-1:-1:-1;;;;;2114:6:0;;;:22;;;2106:67;;;;;-1:-1:-1;;;2106:67:0;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;2106:67:0;;;;;;;;;;;;;;;-1:-1:-1;;;;;2936:22:0;::::1;2928:73;;;;-1:-1:-1::0;;;2928:73:0::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3038:6;::::0;;3017:38:::1;::::0;-1:-1:-1;;;;;3017:38:0;;::::1;::::0;3038:6;::::1;::::0;3017:38:::1;::::0;::::1;3066:6;:17:::0;;-1:-1:-1;;;;;;3066:17:0::1;-1:-1:-1::0;;;;;3066:17:0;;;::::1;::::0;;;::::1;::::0;;2847:244::o;27720:25::-;;;-1:-1:-1;;;;;27720:25:0;;:::o;38113:2569::-;38208:4;;38237;;;38252:25;;;-1:-1:-1;;;38252:25:0;;38266:10;38252:25;;;;;;;;-1:-1:-1;;;;;38208:4:0;;;;38237;;;;38208;;38252:13;;:25;;;;;-1:-1:-1;;38252:25:0;;;;;;;;-1:-1:-1;38208:4:0;38252:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38296:5;-1:-1:-1;;;;;38296:17:0;;:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;38296:19:0;38288:44;;;;;-1:-1:-1;;;38288:44:0;;;;;;;;;;;;-1:-1:-1;;;38288:44:0;;;;;;;;;;;;;;;38345:17;38373;38401:19;38431:36;;:::i;:::-;38488:20;38511:5;-1:-1:-1;;;;;38511:21:0;;:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;38511:23:0;38549:14;;;;38511:23;;-1:-1:-1;38545:892:0;;;38612:15;;;;;38629:18;;38592:56;;;-1:-1:-1;;;38592:56:0;;;;;;;;;-1:-1:-1;;;;;38592:56:0;;;;;;;;:19;;;;;;:56;;;;;;;;;;;:19;:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;38592:56:0;;38717:15;;;38592:56;;-1:-1:-1;38675:91:0;;38689:76;;20390:32;;38689:45;;38703:30;;:13;:30::i;:::-;38689:9;;:13;:45::i;:76::-;38675:9;;:13;:91::i;:::-;38663:103;-1:-1:-1;38795:56:0;38838:12;38795:38;38663:103;20092:29;38795:13;:38::i;:56::-;38781:70;;38545:892;;;38939:15;;;;;38956:18;;38919:56;;;-1:-1:-1;;;38919:56:0;;;;;;;;;-1:-1:-1;;;;;38919:56:0;;;;;;;;38898:18;;38919:19;;;;;;:56;;;;;38939:15;;38919:56;;;;;:19;:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;38919:56:0;39009:19;;;;38919:56;39084:15;;;38919:56;;-1:-1:-1;39009:19:0;38990:16;;39057:75;;20390:32;;39057:44;;39070:30;;:13;:30::i;:::-;39057:8;;:12;:44::i;:75::-;39043:89;-1:-1:-1;39161:17:0;:8;39043:89;39161:12;:17::i;:::-;39147:31;-1:-1:-1;39205:58:0;20092:29;39205;39147:31;39221:12;39205:15;:29::i;:58::-;39193:70;-1:-1:-1;39290:55:0;20092:29;39290:26;:8;39303:12;39290;:26::i;:55::-;39278:67;;39381:10;39368:9;:23;;39360:65;;;;;-1:-1:-1;;;39360:65:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;38545:892;;;;39447:19;39469:24;:9;39483;39469:13;:24::i;:::-;39540:15;;;;;39519:55;;;-1:-1:-1;;;39519:55:0;;;;;;;;;39506:10;39519:55;;;;;;;;;;;;;;39447:46;;-1:-1:-1;39506:10:0;-1:-1:-1;;;;;39519:20:0;;;;;:55;;;;;;;;;;;:20;:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;39519:55:0;39601:19;;;;39519:55;;-1:-1:-1;39597:650:0;;;39665:201;39701:10;:18;;;39738:10;:15;;;39772:11;39802:10;:21;;;39842:9;39665:17;:201::i;:::-;39637:229;;-1:-1:-1;39637:229:0;-1:-1:-1;39597:650:0;;;39959:276;39993:10;:18;;;40030:10;:15;;;40064:11;40094:10;:21;;;40116:10;:16;;;40094:39;;;;;;;;;;;40152:10;:16;;;40187:9;40215:5;39959:15;:276::i;:::-;39925:12;39938:10;:16;;;39925:30;;;;;;;;;;39913:322;;-1:-1:-1;39597:650:0;40276:15;;;;40293:14;;;;40309:18;;40259:93;;;-1:-1:-1;;;40259:93:0;;;;;;;;;;;;;;;;-1:-1:-1;;;;;40259:93:0;;;;;;;;;;;;;;;;;;;;;:16;;;;;;:93;;;;;40309:18;;40259:93;;;;;;;40309:18;40259:16;:93;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40434:5;-1:-1:-1;;;;;40434:15:0;;40450:10;:18;;;40434:35;;;;;;;;;;;;;-1:-1:-1;;;;;40434:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;40370:304:0;40401:10;:18;;;-1:-1:-1;;;;;40370:304:0;;40484:10;:15;;;40514:10;:19;;;40548:10;:14;;;40577:9;40601;40625:11;40651:12;40370:304;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38113:2569;;;;;;;;;;:::o;28654:168::-;28728:10;;28698:9;;-1:-1:-1;;;;;28728:10:0;28720:55;;;;;-1:-1:-1;;;28720:55:0;;;;;;;;;;;;-1:-1:-1;;;28720:55:0;;;;;;;;;;;;;;;-1:-1:-1;28803:10:0;;-1:-1:-1;;;;;28803:10:0;28654:168;:::o;5327:280::-;5385:7;5439:6;5435:47;;-1:-1:-1;5469:1:0;5462:8;;5435:47;5506:5;;;5510:1;5506;:5;:1;5530:5;;;;;:10;5522:56;;;;-1:-1:-1;;;5522:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5598:1;-1:-1:-1;5327:280:0;;;;;:::o;6083:132::-;6141:7;6168:39;6172:1;6175;6168:39;;;;;;;;;;;;;;;;;:3;:39::i;37629:476::-;19983:1;37800:15;;37792:72;;;;-1:-1:-1;;;37792:72:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37875:34;;:::i;:::-;37940:9;37920:10;37931:5;37920:17;;;;;;;;;;:29;37960:35;;:::i;:::-;37998:67;;;;;;;;38016:7;-1:-1:-1;;;;;37998:67:0;;;;;38025:4;37998:67;;;;;;38031:5;37998:67;;;;;;38038:4;37998:67;;;;;;38044:5;37998:67;;;;38051:10;37998:67;;;;38063:1;37998:67;;;37960:105;;38076:21;38086:10;38076:9;:21::i;614:106::-;702:10;614:106;:::o;4437:136::-;4495:7;4522:43;4526:1;4529;4522:43;;;;;;;;;;;;;;;;;:3;:43::i;41485:1093::-;41684:20;41706:36;;:::i;:::-;41769:4;;-1:-1:-1;;;;;41769:4:0;41784:29;;:::i;:::-;41816:9;;:31;;;-1:-1:-1;;;41816:31:0;;;;;;;;;;-1:-1:-1;;;;;41816:9:0;;;;:18;;:31;;;;;;;;;;;;;;;:9;:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;41816:31:0;-1:-1:-1;41858:31:0;;:::i;:::-;41892:8;:6;:8::i;:::-;41858:42;;41916:9;41911:597;19983:1;41927:11;;41911:597;;;41960:16;41979:53;20390:32;41979:22;41992:5;41998:1;41992:8;;;;;;;;;;;41979;;:12;:22::i;:53::-;41960:72;-1:-1:-1;42051:12:0;;42047:450;;42102:4;;;:44;;;-1:-1:-1;;;42102:44:0;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;42102:4:0;;;;:23;;:44;;;;;;;;;;;;;;:4;:44;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;42102:44:0;42084:12;42097:1;42084:15;;;;;;;;;;:62;42192:10;42203:1;42192:13;;;;;;;;;;;42173:12;42186:1;42173:15;;;;;;;;;;;:32;;42165:74;;;;;-1:-1:-1;;;42165:74:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;42258:14;42282:7;42290:1;42282:10;;;;;;;;;;;42258:35;;42339:7;-1:-1:-1;;;;;42339:19:0;;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;42339:21:0;42320:12;42333:1;42320:15;;;;;;;;;;;:40;;42312:87;;;;-1:-1:-1;;;42312:87:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42418:7;-1:-1:-1;;;;;42418:31:0;;42450:12;42463:1;42450:15;;;;;;;;;;;42467:7;42476:4;42418:63;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;42418:63:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42047:450;;-1:-1:-1;41940:3:0;;41911:597;;;-1:-1:-1;42533:4:0;;;:37;;-1:-1:-1;;;42533:37:0;;-1:-1:-1;;;;;42533:4:0;;;;:16;;42550:12;;42533:4;;:37;;42550:12;42533:37;;;42550:12;42533:4;:37;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;42533:37:0;;41485:1093;;-1:-1:-1;41485:1093:0;;-1:-1:-1;;;;;;;;41485:1093:0:o;40690:787::-;40984:11;40915:20;41016:379;;;;41072:73;41100:7;41109:4;41115:5;41122:9;41133:11;41072:27;:73::i;:::-;41042:103;;-1:-1:-1;41042:103:0;-1:-1:-1;41016:379:0;;;41192:14;41216:15;41225:5;41216:8;:15::i;:::-;41261:4;;;:48;;;-1:-1:-1;;;41261:48:0;;;;;;;;;;;;;;;;;41192:40;;-1:-1:-1;;;;;;41261:4:0;;:23;;:48;;;;;;;;;;;;;;;:4;:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;41261:48:0;41324:59;;;-1:-1:-1;;;41324:59:0;;;;;;;;-1:-1:-1;;;;;41324:59:0;;;;;;;;;;;;;;;;41261:48;;-1:-1:-1;41324:31:0;;;;;;:59;;;;;-1:-1:-1;;41324:59:0;;;;;;;;-1:-1:-1;41324:31:0;:59;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41016:379;;41428:9;41413:11;:24;;41405:64;;;;;-1:-1:-1;;;41405:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;40690:787;;;;;;;;;;:::o;6711:201::-;6797:7;6832:12;6825:5;6817:28;;;;-1:-1:-1;;;6817:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6856:9;6872:1;6868;:5;;;;;;;6711:201;-1:-1:-1;;;;;6711:201:0:o;4876:192::-;4962:7;4998:12;4990:6;;;;4982:29;;;;-1:-1:-1;;;4982:29:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;5034:5:0;;;4876:192::o;25078:183::-;25119:31;;:::i;:::-;-1:-1:-1;;;;;25176:9:0;25163:22;;;;25209:10;25196:23;;25163:10;25196;;:23;25243:10;25230:23;:10;;;:23;25163:7;25078:183::o;42586:701::-;42837:9;;:49;;;-1:-1:-1;;;42837:49:0;;;;;;;;;;;;;;;;;42775:20;;;;;;-1:-1:-1;;;;;42837:9:0;;;;:30;;:49;;;;;;;;;;;;;;;42775:20;42837:9;:49;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;42837:49:0;42914:2;;42837:49;;-1:-1:-1;;;;;;42914:2:0;42927:271;;;;42953:3;-1:-1:-1;;;;;42953:17:0;;42971:5;42953:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;43017:56:0;;;-1:-1:-1;;;43017:56:0;;;;;;;;;;;;;;-1:-1:-1;;;;;43017:56:0;;;;;;;;;:29;;;;;;:56;;;;;;;;;;;-1:-1:-1;43017:29:0;:56;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;43017:56:0;;;;;;;;;-1:-1:-1;43017:56:0;-1:-1:-1;42927:271:0;;;43131:55;;;-1:-1:-1;;;43131:55:0;;;;;;;;;;;;;;-1:-1:-1;;;;;43131:55:0;;;;;;;;;:28;;;;;;:55;;;;;;;;;;;-1:-1:-1;43131:28:0;:55;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;43131:55:0;;;;;;;;;-1:-1:-1;43131:55:0;-1:-1:-1;42927:271:0;43229:6;43216:9;:19;;43208:71;;;;-1:-1:-1;;;43208:71:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42586:701;;;;;;;;;;:::o;24812:258::-;24868:7;24892:10;24888:175;;-1:-1:-1;24926:9:0;24919:16;;24888:175;24957:5;24966:1;24957:10;24953:110;;;-1:-1:-1;24991:10:0;24984:17;;24953:110;-1:-1:-1;25041:10:0;25034:17;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;:::o

ipfs://229f92a98b66903cf030a2b54c405da7a831cac89b1b486d9780de8e2da85113