Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

•    - function getSupportAddresses(address ...
•    - function _msgSender()
•    - function _msgData()
• 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 ...
• 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 _functionCallWithValue(addre ...
• 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, ...
•  contract ERC20 is Context, IERC20
•    - function name()
•    - function symbol()
•    - function decimals()
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address recipient, ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(address sender, ...
•    - function increaseAllowance(address sp ...
•    - function decreaseAllowance(address sp ...
•    - function _transfer(address sender, ad ...
•    - function _mint(address account, uint2 ...
•    - function _burn(address account, uint2 ...
•    - function _approve(address owner, addr ...
•    - function _setupDecimals(uint8 decimal ...
•    - function _beforeTokenTransfer(address ...
•  contract PoolToken is ERC20 *
•    - function setPoolManager(address _newM ...
•    - function mint(address account, uint a ...
•    - function burn(address account, uint25 ...
•    - function getExpectedReturn(
•    - function swap(
•  contract PoolFactoryProxy is Token ...
•    - function setImplementation(address _n ...
•  contract PoolFactory is TokenManag ...
•    - function setPoolProxyAddress(address ...
•    - function newStablePool()
•    - function newBTCPool()
•    - function setBestBoost(address _newBes ...
•    - function mint(address to, uint amount ...
•    - function burn(address from, uint amou ...
•  contract Deposit2Tokens
•    - function add_liquidity(uint256[2] mem ...
•    - function remove_liquidity_one_coin(ui ...
•  contract Deposit3Tokens
•    - function add_liquidity(uint256[3] mem ...
•    - function remove_liquidity_one_coin(ui ...
•    - function add_liquidity(uint[4] memory ...
•    - function remove_liquidity(uint256 _am ...
•    - function remove_liquidity_one_coin(ui ...
•    - function deposit(uint256 _value)
•    - function withdraw(uint256 _value)
•    - function mint(address gauge_addr)
•  contract PoolProxy is TokenManager
•    - function implementation()
•  contract Pool is TokenManager
•    - function deposit(address tokenAddress ...
•    - function _btcDeposit(address poolAddr ...
•    - function claimReward(address _deposit ...
•    - function exit(address _depositAddress ...
•    - function withdrawTokenFromContract(ad ...
•    - function _ethDeposit(address poolAddr ...
•    - function depositLPTokens(address lpTo ...
•    - function _deposit(address _depositPoo ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2020-09-14
*/

abstract contract TokenManager {
    
    address constant COMPOUND_DEPOSIT_ADDRESS = 0xeB21209ae4C2c9FF2a86ACA31E123764A3B6Bc06;
    address constant Y_DEPOSIT_ADDRESS      = 0xbBC81d23Ea2c3ec7e56D39296F0cbB648873a5d3;
    address constant BUSD_DEPOSIT_ADDRESS   = 0xb6c057591E073249F2D9D88Ba59a46CFC9B59EdB;
    address constant PAX_DEPOSIT_ADDRESS    = 0xA50cCc70b6a011CffDdf45057E39679379187287;
    address constant REN_DEPOSIT_ADDRESS    = 0x93054188d876f558f4a66B2EF1d97d16eDf0895B;
    address constant SBTC_DEPOSIT_ADDRESS   = 0x7fC77b5c7614E1533320Ea6DDc2Eb61fa00A9714;
    address constant HBTC_DEPOSIT_ADDRESS   = 0x4CA9b3063Ec5866A4B82E437059D2C43d1be596F;
    
    address constant SWERVE_DEPOSIT_ADDRESS     = 0x329239599afB305DA0A2eC69c58F8a6697F9F88d;


    address constant COMPOUND_TOKEN_ADDRESS     = 0x845838DF265Dcd2c412A1Dc9e959c7d08537f8a2;
    address constant Y_TOKEN_ADDRESS        = 0xdF5e0e81Dff6FAF3A7e52BA697820c5e32D806A8;
    address constant BUSD_TOKEN_ADDRESS         = 0x3B3Ac5386837Dc563660FB6a0937DFAa5924333B;
    address constant PAX_TOKEN_ADDRESS      = 0xD905e2eaeBe188fc92179b6350807D8bd91Db0D8;
    address constant REN_TOKEN_ADDRESS      = 0x49849C98ae39Fff122806C06791Fa73784FB3675;
    address constant SBTC_TOKEN_ADDRESS         = 0x075b1bb99792c9E1041bA13afEf80C91a1e70fB3;
    address constant HBTC_TOKEN_ADDRESS         = 0xb19059ebb43466C323583928285a49f558E572Fd;
    address constant SRW_TOKEN_ADDRESS      = 0x77C6E4a580c0dCE4E5c7a17d0bc077188a83A059;
    

    address constant COMPOUND_GAUGE_ADDRESS     = 0x7ca5b0a2910B33e9759DC7dDB0413949071D7575;
    address constant Y_GAUGE_ADDRESS        = 0xFA712EE4788C042e2B7BB55E6cb8ec569C4530c1;
    address constant BUSD_GAUGE_ADDRESS         = 0x69Fb7c45726cfE2baDeE8317005d3F94bE838840;
    address constant PAX_GAUGE_ADDRESS      = 0x64E3C23bfc40722d3B649844055F1D51c1ac041d;
    address constant REN_GAUGE_ADDRESS      = 0xB1F2cdeC61db658F091671F5f199635aEF202CAC;
    address constant SBTC_GAUGE_ADDRESS         = 0x705350c4BcD35c9441419DdD5d2f097d7a55410F;
    address constant SWERVE_GAUGE_ADDRESS   = 0xb4d0C929cD3A1FbDc6d57E7D3315cF0C4d6B4bFa;
    address constant HBTC_GAUGE_ADDRESS         = 0x4c18E409Dc8619bFb6a1cB56D114C3f592E0aE79;

    address constant CRV_TOKEN_MINTER_ADDRESS   = 0xd061D61a4d941c39E5453435B6345Dc261C2fcE0;
    address constant SWERVE_TOKEN_MINTER_ADDRESS = 0x2c988c3974AD7E604E276AE0294a7228DEf67974;
    
    address constant CRV_TOKEN_ADDRESS      = 0xD533a949740bb3306d119CC777fa900bA034cd52;
    address constant SWERVE_TOKEN_ADDRESS   = 0xB8BAa0e4287890a5F79863aB62b7F175ceCbD433;
    

    address constant VOTING_ESCROW          = 0x5f3b5DfEb7B28CDbD7FAba78963EE202a494e2A2;
    
    address constant EXCHANGE_CONTRACT  = 0xC586BeF4a0992C495Cf22e1aeEE4E446CECDee0E;
    address constant ETH_ADDRESS        = 0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE;
    address constant DAI_ADDRESS        = 0x6B175474E89094C44Da98b954EedeAC495271d0F;
    address constant WBTC_ADDRESS        = 0x2260FAC5E5542a773Aa44fBCfeDf7C193bc2C599;
    
    address constant USDC_ADDRESS        = 0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48;
    address constant USDT_ADDRESS        = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
    address constant TUSD_ADDRESS        = 0x0000000000085d4780B73119b644AE5ecd22b376;
    
    mapping(address => address[]) public supportAddresses;
    
    function getSupportAddresses(address _depositAddress) public view returns(address[] memory){
        return supportAddresses[_depositAddress];
    }
    
    
    constructor() public {
        
        supportAddresses[COMPOUND_DEPOSIT_ADDRESS].push(COMPOUND_TOKEN_ADDRESS);
        supportAddresses[COMPOUND_DEPOSIT_ADDRESS].push(COMPOUND_GAUGE_ADDRESS);
        
        supportAddresses[Y_DEPOSIT_ADDRESS].push(Y_TOKEN_ADDRESS);
        supportAddresses[Y_DEPOSIT_ADDRESS].push(Y_GAUGE_ADDRESS);
        
        supportAddresses[BUSD_DEPOSIT_ADDRESS].push(BUSD_TOKEN_ADDRESS);
        supportAddresses[BUSD_DEPOSIT_ADDRESS].push(BUSD_GAUGE_ADDRESS);
        
        supportAddresses[PAX_DEPOSIT_ADDRESS].push(PAX_TOKEN_ADDRESS);
        supportAddresses[PAX_DEPOSIT_ADDRESS].push(PAX_GAUGE_ADDRESS);
        
        supportAddresses[REN_DEPOSIT_ADDRESS].push(REN_TOKEN_ADDRESS);
        supportAddresses[REN_DEPOSIT_ADDRESS].push(REN_GAUGE_ADDRESS);
        
        supportAddresses[SBTC_DEPOSIT_ADDRESS].push(SBTC_TOKEN_ADDRESS);
        supportAddresses[SBTC_DEPOSIT_ADDRESS].push(SBTC_GAUGE_ADDRESS);
        
        supportAddresses[HBTC_DEPOSIT_ADDRESS].push(HBTC_TOKEN_ADDRESS);
        supportAddresses[HBTC_DEPOSIT_ADDRESS].push(HBTC_GAUGE_ADDRESS);
        
        supportAddresses[SWERVE_DEPOSIT_ADDRESS].push(SRW_TOKEN_ADDRESS);
        supportAddresses[SWERVE_DEPOSIT_ADDRESS].push(SWERVE_GAUGE_ADDRESS);
        
    }
}

pragma solidity ^0.6.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; // silence state mutability warning without generating bytecode - see https://github.com/ethereum/solidity/issues/2691
        return msg.data;
    }
}

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

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

        return c;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin guidelines: functions revert instead
 * of returning `false` on failure. This behavior is nonetheless conventional
 * and does not conflict with the expectations of ERC20 applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20 {
    using SafeMath for uint256;
    using Address for address;

    mapping (address => uint256) private _balances;

    mapping (address => mapping (address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;
    uint8 private _decimals;

    /**
     * @dev Sets the values for {name} and {symbol}, initializes {decimals} with
     * a default value of 18.
     *
     * To select a different value for {decimals}, use {_setupDecimals}.
     *
     * All three of these values are immutable: they can only be set once during
     * construction.
     */
    constructor (string memory name, string memory symbol) public {
        _name = name;
        _symbol = symbol;
        _decimals = 18;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5,05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless {_setupDecimals} is
     * called.
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view returns (uint8) {
        return _decimals;
    }

    /**
     * @dev See {IERC20-totalSupply}.
     */
    function totalSupply() public view override returns (uint256) {
        return _totalSupply;
    }

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `recipient` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(_msgSender(), recipient, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        _approve(_msgSender(), spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20};
     *
     * Requirements:
     * - `sender` and `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     * - the caller must have allowance for ``sender``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address sender, address recipient, uint256 amount) public virtual override returns (bool) {
        _transfer(sender, recipient, amount);
        _approve(sender, _msgSender(), _allowances[sender][_msgSender()].sub(amount, "ERC20: transfer amount exceeds allowance"));
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].add(addedValue));
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        _approve(_msgSender(), spender, _allowances[_msgSender()][spender].sub(subtractedValue, "ERC20: decreased allowance below zero"));
        return true;
    }

    /**
     * @dev Moves tokens `amount` from `sender` to `recipient`.
     *
     * This is internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `sender` cannot be the zero address.
     * - `recipient` cannot be the zero address.
     * - `sender` must have a balance of at least `amount`.
     */
    function _transfer(address sender, address recipient, uint256 amount) internal virtual {
        require(sender != address(0), "ERC20: transfer from the zero address");
        require(recipient != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(sender, recipient, amount);

        _balances[sender] = _balances[sender].sub(amount, "ERC20: transfer amount exceeds balance");
        _balances[recipient] = _balances[recipient].add(amount);
        emit Transfer(sender, recipient, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements
     *
     * - `to` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply = _totalSupply.add(amount);
        _balances[account] = _balances[account].add(amount);
        emit Transfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        _balances[account] = _balances[account].sub(amount, "ERC20: burn amount exceeds balance");
        _totalSupply = _totalSupply.sub(amount);
        emit Transfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Sets {decimals} to a value other than the default one of 18.
     *
     * WARNING: This function should only be called from the constructor. Most
     * applications that interact with token contracts will not expect
     * {decimals} to ever change, and may work incorrectly if it does.
     */
    function _setupDecimals(uint8 decimals_) internal {
        _decimals = decimals_;
    }

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be to transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual { }
}

contract PoolToken is ERC20 {
    address public owner;
    address public poolManager;
    
    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }
    
    constructor() public ERC20("fDai", "fDai") {
        owner = msg.sender;
    }
    
    function setPoolManager(address _newManagerAddress) public onlyOwner {
        poolManager = _newManagerAddress;
    }
    
    function mint(address account, uint amount) public {
        require(msg.sender == poolManager);
        _mint(account, amount);
    }
    
    function burn(address account, uint256 amount) public {
        require(msg.sender == poolManager);
         _burn(account, amount);
    }
}

abstract contract IOneSplitView {
    // disableFlags = FLAG_DISABLE_UNISWAP + FLAG_DISABLE_KYBER + ...
    uint256 public constant FLAG_DISABLE_UNISWAP = 0x01;
    uint256 public constant FLAG_DISABLE_KYBER = 0x02;
    uint256 public constant FLAG_ENABLE_KYBER_UNISWAP_RESERVE = 0x100000000; // Turned off by default
    uint256 public constant FLAG_ENABLE_KYBER_OASIS_RESERVE = 0x200000000; // Turned off by default
    uint256 public constant FLAG_ENABLE_KYBER_BANCOR_RESERVE = 0x400000000; // Turned off by default
    uint256 public constant FLAG_DISABLE_BANCOR = 0x04;
    uint256 public constant FLAG_DISABLE_OASIS = 0x08;
    uint256 public constant FLAG_DISABLE_COMPOUND = 0x10;
    uint256 public constant FLAG_DISABLE_FULCRUM = 0x20;
    uint256 public constant FLAG_DISABLE_CHAI = 0x40;
    uint256 public constant FLAG_DISABLE_AAVE = 0x80;
    uint256 public constant FLAG_DISABLE_SMART_TOKEN = 0x100;
    uint256 public constant FLAG_ENABLE_MULTI_PATH_ETH = 0x200; // Turned off by default
    uint256 public constant FLAG_DISABLE_BDAI = 0x400;
    uint256 public constant FLAG_DISABLE_IEARN = 0x800;
    uint256 public constant FLAG_DISABLE_CURVE_COMPOUND = 0x1000;
    uint256 public constant FLAG_DISABLE_CURVE_USDT = 0x2000;
    uint256 public constant FLAG_DISABLE_CURVE_Y = 0x4000;
    uint256 public constant FLAG_DISABLE_CURVE_BINANCE = 0x8000;
    uint256 public constant FLAG_ENABLE_MULTI_PATH_DAI = 0x10000; // Turned off by default
    uint256 public constant FLAG_ENABLE_MULTI_PATH_USDC = 0x20000; // Turned off by default
    uint256 public constant FLAG_DISABLE_CURVE_SYNTHETIX = 0x40000;
    uint256 public constant FLAG_DISABLE_WETH = 0x80000;
    uint256 public constant FLAG_ENABLE_UNISWAP_COMPOUND = 0x100000; // Works only with FLAG_ENABLE_MULTI_PATH_ETH

    function getExpectedReturn(
        IERC20 fromToken,
        IERC20 toToken,
        uint256 amount,
        uint256 parts,
        uint256 disableFlags
    )
        virtual
        public
        view
        returns(
            uint256 returnAmount,
            uint256[] memory distribution
        );
}


abstract contract IOneSplit is IOneSplitView {
    function swap(
        IERC20 fromToken,
        IERC20 toToken,
        uint256 amount,
        uint256 minReturn,
        uint256[] memory distribution,
        uint256 disableFlags
    ) virtual public payable;
}

contract PoolFactoryProxy is TokenManager {
    address public owner;
    address public implementation;
    
    address public poolTokenAddress;
    address public poolTokenBTCAddress;
    address public poolProxy;
    
    mapping (address => address) public usersStablePools;
    mapping (address => address) public usersBTCPools;
    uint public totalBalance;
    
    mapping(bool => address) public bestBoost;
    
    
    constructor(address _poolProxyAddress, address _poolTokenAddress, address _poolTokenBTCAddress, address _impl) public {
        implementation = _impl;
        poolProxy = _poolProxyAddress;
        poolTokenAddress = _poolTokenAddress;
        poolTokenBTCAddress = _poolTokenBTCAddress;
        owner = msg.sender;
    }

    function setImplementation(address _newImpl) public {
        require(msg.sender == owner);

        implementation = _newImpl;
    }
   
    fallback() virtual external {
        address impl = implementation;
        assembly {
            let ptr := mload(0x40)
 
            // (1) copy incoming call data
            calldatacopy(ptr, 0, calldatasize())
 
             // (2) forward call to logic contract
            let result := delegatecall(gas(), impl, ptr, calldatasize(), 0, 0)
            let size := returndatasize()
 
            // (3) retrieve return data
            returndatacopy(ptr, 0, size)
 
            // (4) forward return data back to caller
            switch result
            case 0 { revert(ptr, size) }
            default { return(ptr, size) }
        }   
    }
}

contract PoolFactory is TokenManager {
    address public owner;

    address public poolTokenAddress;
    address public poolTokenBTCAddress;
    address public poolProxy;
    
    mapping (address => address) public usersStablePools;
    mapping (address => address) public usersBTCPools;
    uint public totalBalance;
    
    mapping(bool => address) public bestBoost;
    
    event NewPool(address indexed poolAddress, address indexed sender, bool isBTC);

    modifier poolOnly(address userAddress) {
        require(msg.sender == usersStablePools[userAddress] || msg.sender == usersBTCPools[userAddress]);
        _;
    }
    
    
    function setPoolProxyAddress(address _newProxy) public {
        require(msg.sender == owner);
        poolProxy = _newProxy;
    }
    
    function newStablePool() public {
        require(usersStablePools[msg.sender] == address(0), "pool already created");
        PoolProxy pool = new PoolProxy(msg.sender, false);
        usersStablePools[msg.sender] = address(pool);
        
        emit NewPool(address(pool), msg.sender, false);
    }
    
    function newBTCPool() public {
        require(usersBTCPools[msg.sender] == address(0), "pool already created");
        PoolProxy pool = new PoolProxy(msg.sender, true);
        usersBTCPools[msg.sender] = address(pool);
        
        emit NewPool(address(pool), msg.sender, true);
    }

    function setBestBoost(address _newBestBoost, address _newBestBoostBTC) public {
        require(msg.sender == owner);
        bestBoost[false] = _newBestBoost;
        bestBoost[true] = _newBestBoostBTC;
    }
    
    function mint(address to, uint amount, bool isBTCPool) public poolOnly(to) {
        if(isBTCPool) {
            PoolToken(poolTokenBTCAddress).mint(to, amount);
        } else {
            PoolToken(poolTokenAddress).mint(to, amount);
        }
        
    }
    
    function burn(address from, uint amount, bool isBTCPool) public poolOnly(from) {
        if(isBTCPool) {
            PoolToken(poolTokenBTCAddress).burn(from, amount);
        } else {
            PoolToken(poolTokenAddress).burn(from, amount);
        }
    }
}

contract Deposit2Tokens {
    function add_liquidity(uint256[2] memory uamounts, uint256 min_mint_amount) public{}
    
    function remove_liquidity_one_coin(uint256 _token_amount, int128 i, uint256 min_uamount, bool donate_dust) public{}
    uint[100000000000000000000000000000] public period_timestamp;
}

contract Deposit3Tokens {
    function add_liquidity(uint256[3] memory uamounts, uint256 min_mint_amount) public{}
    function remove_liquidity_one_coin(uint256 _token_amount, int128 i, uint256 min_uamount) public{}
    uint[100000000000000000000000000000] public period_timestamp;
}

abstract contract Deposit4Tokens {
    function add_liquidity(uint[4] memory uamounts, uint256 min_mint_amount) virtual public;
    function remove_liquidity(uint256 _amount, uint256[4] memory min_amounts) public{}
    function remove_liquidity_one_coin(uint256 _token_amount, int128 i, uint256 min_uamount, bool donate_dust) virtual public;
    uint[100000000000000000000000000000] public period_timestamp;
}

abstract contract IGauge {
  function deposit(uint256 _value) virtual public;
  function withdraw(uint256 _value) virtual public;

  mapping(address => uint) public balanceOf;
}


abstract contract TokenMinter {
    function mint(address gauge_addr) virtual public;
}

contract PoolProxy is TokenManager {
    
    address public owner;
    address public poolFactoryAddress;
    bool public isBTCPool;

    constructor(address _owner, bool _isBTCPool) public {
        poolFactoryAddress = msg.sender;
        owner = _owner;
        isBTCPool = _isBTCPool;
    }

    fallback() external payable {
        address impl = implementation();
        assembly {
            let ptr := mload(0x40)
 
            // (1) copy incoming call data
            calldatacopy(ptr, 0, calldatasize())
 
             // (2) forward call to logic contract
            let result := delegatecall(gas(), impl, ptr, calldatasize(), 0, 0)
            let size := returndatasize()
 
            // (3) retrieve return data
            returndatacopy(ptr, 0, size)
 
            // (4) forward return data back to caller
            switch result
            case 0 { revert(ptr, size) }
            default { return(ptr, size) }
        }   
    }

    function implementation() public view returns(address) {
        return PoolFactory(poolFactoryAddress).poolProxy();
    }
}

contract Pool is TokenManager {
    
    address public owner;
    address public poolFactoryAddress;
    bool public isBTCPool;
    
    modifier onlyOwner() {
        require (msg.sender == owner); 
        _; 
    }

    function deposit(address tokenAddress, uint amount) public payable {
        
        address poolAddress = PoolFactory(poolFactoryAddress).bestBoost(isBTCPool);
       
        if (isBTCPool) {
            _btcDeposit(poolAddress, tokenAddress, amount);
            return;
        }
        
        
        if (msg.value > 0) {
            _ethDeposit(poolAddress);
            return;
        }
        
        uint _amount = amount;
        uint[] memory _distribution;

        IERC20(tokenAddress).transferFrom(msg.sender, address(this), amount);

        if (tokenAddress != DAI_ADDRESS) {
            IERC20(tokenAddress).approve(EXCHANGE_CONTRACT, amount);
            (_amount, _distribution) = IOneSplit(EXCHANGE_CONTRACT).getExpectedReturn(IERC20(tokenAddress), IERC20(DAI_ADDRESS), amount, 100, 0);
            IOneSplit(EXCHANGE_CONTRACT).swap(IERC20(tokenAddress), IERC20(DAI_ADDRESS), amount, _amount, _distribution, 0);
        }

        
        (address lpTokenAddress, address gaugeAddress) = _deposit(poolAddress, _amount);
        
        PoolFactory(poolFactoryAddress).mint(msg.sender, IERC20(lpTokenAddress).balanceOf(address(this)), isBTCPool);

        depositLPTokens(lpTokenAddress, gaugeAddress, IERC20(lpTokenAddress).balanceOf(address(this)));
        
        
    }
    
    function _btcDeposit(address poolAddress, address tokenAddress, uint amount) internal {
        uint _amount;
        uint[] memory _distribution;
            
        if (msg.value > 0) {
            (_amount, _distribution) = IOneSplit(EXCHANGE_CONTRACT).getExpectedReturn(IERC20(ETH_ADDRESS), IERC20(WBTC_ADDRESS), msg.value, 100, 0);
            IOneSplit(EXCHANGE_CONTRACT).swap.value(msg.value)(IERC20(ETH_ADDRESS), IERC20(WBTC_ADDRESS), msg.value, _amount, _distribution, 0);

            uint wBTCamount = IERC20(WBTC_ADDRESS).balanceOf(address(this));
            
            (address lpTokenAddress, address gaugeAddress) = _deposit(poolAddress, _amount);
            
            uint lpAmount = IERC20(lpTokenAddress).balanceOf(address(this));
            
            
            PoolFactory(poolFactoryAddress).mint(msg.sender, IERC20(lpTokenAddress).balanceOf(address(this)), isBTCPool);
            depositLPTokens(lpTokenAddress, gaugeAddress, IERC20(lpTokenAddress).balanceOf(address(this)));
        }
        
        IERC20(tokenAddress).transferFrom(msg.sender, address(this), amount);

        if (tokenAddress != WBTC_ADDRESS) {
            IERC20(tokenAddress).approve(EXCHANGE_CONTRACT, amount);
            (_amount, _distribution) = IOneSplit(EXCHANGE_CONTRACT).getExpectedReturn(IERC20(tokenAddress), IERC20(WBTC_ADDRESS), amount, 100, 0);
            IOneSplit(EXCHANGE_CONTRACT).swap(IERC20(tokenAddress), IERC20(WBTC_ADDRESS), amount, _amount, _distribution, 0);
        }

        (address lpTokenAddress, address gaugeAddress) = _deposit(poolAddress, _amount);
        
        
        PoolFactory(poolFactoryAddress).mint(msg.sender, IERC20(lpTokenAddress).balanceOf(address(this)), isBTCPool);
        depositLPTokens(lpTokenAddress, gaugeAddress, IERC20(lpTokenAddress).balanceOf(address(this)));
    }

    function claimReward(address _depositAddress, bool isHarvest) public onlyOwner {
        
        address[] memory supAddresses = getSupportAddresses(_depositAddress); 
        if (supAddresses[1] == SWERVE_GAUGE_ADDRESS) {
            TokenMinter(SWERVE_TOKEN_MINTER_ADDRESS).mint(supAddresses[1]);
        } else {
            TokenMinter(CRV_TOKEN_MINTER_ADDRESS).mint(supAddresses[1]);
        }
        
        
        uint swerveTokenBalance = IERC20(SWERVE_TOKEN_ADDRESS).balanceOf(address(this));
        uint crvTokenBalance = IERC20(CRV_TOKEN_ADDRESS).balanceOf(address(this));
        
        if (isHarvest) {
            uint _amount;
            uint[] memory _distribution;
            
            if (swerveTokenBalance > 0) {
                IERC20(SWERVE_TOKEN_ADDRESS).approve(EXCHANGE_CONTRACT, swerveTokenBalance);
                (_amount, _distribution) = IOneSplit(EXCHANGE_CONTRACT).getExpectedReturn(IERC20(SWERVE_TOKEN_ADDRESS), IERC20(DAI_ADDRESS), swerveTokenBalance, 100, 0);
                IOneSplit(EXCHANGE_CONTRACT).swap(IERC20(SWERVE_TOKEN_ADDRESS), IERC20(DAI_ADDRESS), swerveTokenBalance, _amount, _distribution, 0);
            }
            
            if (crvTokenBalance > 0) {
                IERC20(CRV_TOKEN_ADDRESS).approve(EXCHANGE_CONTRACT, crvTokenBalance);
                (_amount, _distribution) = IOneSplit(EXCHANGE_CONTRACT).getExpectedReturn(IERC20(CRV_TOKEN_ADDRESS), IERC20(DAI_ADDRESS), crvTokenBalance, 100, 0);
                IOneSplit(EXCHANGE_CONTRACT).swap(IERC20(CRV_TOKEN_ADDRESS), IERC20(DAI_ADDRESS), crvTokenBalance, _amount, _distribution, 0);
            }
            
            uint daiBalance = IERC20(DAI_ADDRESS).balanceOf(address(this));
            
            if(daiBalance > 0) {
                IERC20(DAI_ADDRESS).transfer(msg.sender, daiBalance);
            }
            
            return;
        }
        
        
        if(swerveTokenBalance > 0) {
            IERC20(SWERVE_TOKEN_ADDRESS).transfer(msg.sender, swerveTokenBalance);
        }
        
        if(crvTokenBalance > 0) {
            IERC20(CRV_TOKEN_ADDRESS).transfer(msg.sender, crvTokenBalance);
        }
    }

    function exit(address _depositAddress, uint value) public onlyOwner {
        claimReward(_depositAddress, false);
       
            
        address[] memory supAddresses = getSupportAddresses(_depositAddress);
          
        require(IGauge(supAddresses[1]).balanceOf(address(this)) > 0);
        
        IGauge(supAddresses[1]).withdraw(IGauge(supAddresses[1]).balanceOf(address(this)));
        
        uint bal = IERC20(supAddresses[0]).balanceOf(address(this));
        
        require(bal > 0);
        
        PoolFactory(poolFactoryAddress).burn(msg.sender, bal, isBTCPool);
            
        IERC20(supAddresses[0]).approve(_depositAddress, bal);
        if (!isBTCPool) {
          if (_depositAddress == SWERVE_DEPOSIT_ADDRESS) {
              uint[4] memory buf;
              Deposit4Tokens(_depositAddress).remove_liquidity(bal, buf);
          } else {
                Deposit2Tokens(_depositAddress).remove_liquidity_one_coin(bal, 0, 1, true);
          }
        } else {
            Deposit3Tokens(_depositAddress).remove_liquidity_one_coin(bal, 1, 1);
           
        }
        
        if (!isBTCPool) {
            if(IERC20(DAI_ADDRESS).balanceOf(address(this)) > 0) {
                IERC20(DAI_ADDRESS).transfer(msg.sender, IERC20(DAI_ADDRESS).balanceOf(address(this)));
            }
            
            if(IERC20(USDC_ADDRESS).balanceOf(address(this)) > 0) {
                IERC20(USDC_ADDRESS).transfer(msg.sender, IERC20(USDC_ADDRESS).balanceOf(address(this)));
            }
            
            // if(IERC20(USDT_ADDRESS).balanceOf(address(this)) > 0) {
            //     IERC20(USDT_ADDRESS).transfer(msg.sender, IERC20(USDT_ADDRESS).balanceOf(address(this)));
            // }
            
            if(IERC20(TUSD_ADDRESS).balanceOf(address(this)) > 0) {
                IERC20(TUSD_ADDRESS).transfer(msg.sender, IERC20(TUSD_ADDRESS).balanceOf(address(this)));
            }
        } else {
            IERC20(WBTC_ADDRESS).transfer(msg.sender, IERC20(WBTC_ADDRESS).balanceOf(address(this)));
        }
        
    }

    function withdrawTokenFromContract(address tokenAddress, uint amount) public onlyOwner {
        IERC20(tokenAddress).transfer(msg.sender, amount);
    }
    
    function _ethDeposit(address poolAddress) private {
        uint _amount;
        uint[] memory _distribution;

        (_amount, _distribution) = IOneSplit(EXCHANGE_CONTRACT).getExpectedReturn(IERC20(ETH_ADDRESS), IERC20(DAI_ADDRESS), msg.value, 100, 0);
        IOneSplit(EXCHANGE_CONTRACT).swap.value(msg.value)(IERC20(ETH_ADDRESS), IERC20(DAI_ADDRESS), msg.value, _amount, _distribution, 0);

        (address lpTokenAddress, address gaugeAddress) = _deposit(poolAddress, _amount);
        
        
        PoolFactory(poolFactoryAddress).mint(msg.sender, IERC20(lpTokenAddress).balanceOf(address(this)), isBTCPool);
        depositLPTokens(lpTokenAddress, gaugeAddress, IERC20(lpTokenAddress).balanceOf(address(this)));
    }
    
    function depositLPTokens(address lpTokenAddress, address gaugeAddress, uint value) internal {
        IERC20(lpTokenAddress).approve(gaugeAddress, value);
        IGauge(gaugeAddress).deposit(value);
    }

    function _deposit(address _depositPool, uint amount) internal returns(address, address) {
        IERC20(DAI_ADDRESS).approve(_depositPool, amount);

        if(_depositPool == COMPOUND_DEPOSIT_ADDRESS) {
            uint[2] memory uamounts;
            uamounts[0] = amount;
            Deposit2Tokens(_depositPool).add_liquidity(uamounts, 0);
            return (COMPOUND_TOKEN_ADDRESS, COMPOUND_GAUGE_ADDRESS);
        }
        
        if(_depositPool == Y_DEPOSIT_ADDRESS) {
            uint[4] memory uamounts;
            uamounts[0] = amount;
            Deposit4Tokens(_depositPool).add_liquidity(uamounts, 0);
            return (Y_TOKEN_ADDRESS, Y_GAUGE_ADDRESS);
        }

        if(_depositPool == BUSD_DEPOSIT_ADDRESS) {
            uint[4] memory uamounts;
            uamounts[0] = amount;
            Deposit4Tokens(_depositPool).add_liquidity(uamounts, 0);
            return (BUSD_TOKEN_ADDRESS, BUSD_GAUGE_ADDRESS);
        }

        if(_depositPool == PAX_DEPOSIT_ADDRESS) {
            uint[4] memory uamounts;
            uamounts[0] = amount;
            Deposit4Tokens(_depositPool).add_liquidity(uamounts, 0);
            return (PAX_TOKEN_ADDRESS, PAX_GAUGE_ADDRESS);
        } 

        if(_depositPool == REN_DEPOSIT_ADDRESS) {
            IERC20(WBTC_ADDRESS).approve(_depositPool, amount);
            uint[2] memory uamounts;
            uamounts[1] = amount;
            Deposit2Tokens(_depositPool).add_liquidity(uamounts, 0);
            return (REN_TOKEN_ADDRESS, REN_GAUGE_ADDRESS);
        } 

        if(_depositPool == SBTC_DEPOSIT_ADDRESS) {
            IERC20(WBTC_ADDRESS).approve(_depositPool, amount);
            uint[3] memory uamounts;
            uamounts[1] = amount;
            Deposit3Tokens(_depositPool).add_liquidity(uamounts, 0);
            return (SBTC_TOKEN_ADDRESS, SBTC_GAUGE_ADDRESS);
        }
        
        if(_depositPool == HBTC_DEPOSIT_ADDRESS) {
            IERC20(WBTC_ADDRESS).approve(_depositPool, amount);
            uint[2] memory uamounts;
            uamounts[1] = amount;
            Deposit2Tokens(_depositPool).add_liquidity(uamounts, 0);
            return (HBTC_TOKEN_ADDRESS, HBTC_GAUGE_ADDRESS);
        }

        if(_depositPool == SWERVE_DEPOSIT_ADDRESS) {
            uint[4] memory uamounts;
            uamounts[0] = amount;
            Deposit4Tokens(_depositPool).add_liquidity(uamounts, 0);
            return (SRW_TOKEN_ADDRESS, SWERVE_GAUGE_ADDRESS);
        }
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"poolManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_newManagerAddress","type":"address"}],"name":"setPoolManager","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"}]

60806040523480156200001157600080fd5b506040518060400160405280600481526020017f66446169000000000000000000000000000000000000000000000000000000008152506040518060400160405280600481526020017f664461690000000000000000000000000000000000000000000000000000000081525081600390805190602001906200009692919062000115565b508060049080519060200190620000af92919062000115565b506012600560006101000a81548160ff021916908360ff160217905550505033600560016101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff160217905550620001bb565b828054600181600116156101000203166002900490600052602060002090601f016020900481019282601f106200015857805160ff191683800117855562000189565b8280016001018555821562000189579182015b82811115620001885782518255916020019190600101906200016b565b5b5090506200019891906200019c565b5090565b5b80821115620001b75760008160009055506001016200019d565b5090565b61185580620001cb6000396000f3fe608060405234801561001057600080fd5b50600436106101005760003560e01c80637aef671511610097578063a457c2d711610066578063a457c2d714610502578063a9059cbb14610566578063dc4c90d3146105ca578063dd62ed3e146105fe57610100565b80637aef6715146103b95780638da5cb5b146103fd57806395d89b41146104315780639dc29fac146104b457610100565b8063313ce567116100d3578063313ce5671461028e57806339509351146102af57806340c10f191461031357806370a082311461036157610100565b806306fdde0314610105578063095ea7b31461018857806318160ddd146101ec57806323b872dd1461020a575b600080fd5b61010d610676565b6040518080602001828103825283818151815260200191508051906020019080838360005b8381101561014d578082015181840152602081019050610132565b50505050905090810190601f16801561017a5780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b6101d46004803603604081101561019e57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919080359060200190929190505050610718565b60405180821515815260200191505060405180910390f35b6101f4610736565b6040518082815260200191505060405180910390f35b6102766004803603606081101561022057600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190803573ffffffffffffffffffffffffffffffffffffffff16906020019092919080359060200190929190505050610740565b60405180821515815260200191505060405180910390f35b610296610819565b604051808260ff16815260200191505060405180910390f35b6102fb600480360360408110156102c557600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919080359060200190929190505050610830565b60405180821515815260200191505060405180910390f35b61035f6004803603604081101561032957600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190803590602001909291905050506108e3565b005b6103a36004803603602081101561037757600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919050505061094b565b6040518082815260200191505060405180910390f35b6103fb600480360360208110156103cf57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050610993565b005b610405610a31565b604051808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b610439610a57565b6040518080602001828103825283818151815260200191508051906020019080838360005b8381101561047957808201518184015260208101905061045e565b50505050905090810190601f1680156104a65780820380516001836020036101000a031916815260200191505b509250505060405180910390f35b610500600480360360408110156104ca57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919080359060200190929190505050610af9565b005b61054e6004803603604081101561051857600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919080359060200190929190505050610b61565b60405180821515815260200191505060405180910390f35b6105b26004803603604081101561057c57600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff16906020019092919080359060200190929190505050610c2e565b60405180821515815260200191505060405180910390f35b6105d2610c4c565b604051808273ffffffffffffffffffffffffffffffffffffffff16815260200191505060405180910390f35b6106606004803603604081101561061457600080fd5b81019080803573ffffffffffffffffffffffffffffffffffffffff169060200190929190803573ffffffffffffffffffffffffffffffffffffffff169060200190929190505050610c72565b6040518082815260200191505060405180910390f35b606060038054600181600116156101000203166002900480601f01602080910402602001604051908101604052809291908181526020018280546001816001161561010002031660029004801561070e5780601f106106e35761010080835404028352916020019161070e565b820191906000526020600020905b8154815290600101906020018083116106f157829003601f168201915b5050505050905090565b600061072c610725610cf9565b8484610d01565b6001905092915050565b6000600254905090565b600061074d848484610ef8565b61080e84610759610cf9565b6108098560405180606001604052806028815260200161176960289139600160008b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006107bf610cf9565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020546111b99092919063ffffffff16565b610d01565b600190509392505050565b6000600560009054906101000a900460ff16905090565b60006108d961083d610cf9565b846108d4856001600061084e610cf9565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008973ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000205461127990919063ffffffff16565b610d01565b6001905092915050565b600660009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff161461093d57600080fd5b6109478282611301565b5050565b60008060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b600560019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff16146109ed57600080fd5b80600660006101000a81548173ffffffffffffffffffffffffffffffffffffffff021916908373ffffffffffffffffffffffffffffffffffffffff16021790555050565b600560019054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b606060048054600181600116156101000203166002900480601f016020809104026020016040519081016040528092919081815260200182805460018160011615610100020316600290048015610aef5780601f10610ac457610100808354040283529160200191610aef565b820191906000526020600020905b815481529060010190602001808311610ad257829003601f168201915b5050505050905090565b600660009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff163373ffffffffffffffffffffffffffffffffffffffff1614610b5357600080fd5b610b5d82826114c8565b5050565b6000610c24610b6e610cf9565b84610c1f856040518060600160405280602581526020016117fb6025913960016000610b98610cf9565b73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008a73ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020546111b99092919063ffffffff16565b610d01565b6001905092915050565b6000610c42610c3b610cf9565b8484610ef8565b6001905092915050565b600660009054906101000a900473ffffffffffffffffffffffffffffffffffffffff1681565b6000600160008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905092915050565b600033905090565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415610d87576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260248152602001806117d76024913960400191505060405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415610e0d576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260228152602001806117216022913960400191505060405180910390fd5b80600160008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925836040518082815260200191505060405180910390a3505050565b600073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415610f7e576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260258152602001806117b26025913960400191505060405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff161415611004576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260238152602001806116dc6023913960400191505060405180910390fd5b61100f83838361168c565b61107a81604051806060016040528060268152602001611743602691396000808773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020546111b99092919063ffffffff16565b6000808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000208190555061110d816000808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000205461127990919063ffffffff16565b6000808473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef836040518082815260200191505060405180910390a3505050565b6000838311158290611266576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825283818151815260200191508051906020019080838360005b8381101561122b578082015181840152602081019050611210565b50505050905090810190601f1680156112585780820380516001836020036101000a031916815260200191505b509250505060405180910390fd5b5060008385039050809150509392505050565b6000808284019050838110156112f7576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601b8152602001807f536166654d6174683a206164646974696f6e206f766572666c6f77000000000081525060200191505060405180910390fd5b8091505092915050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614156113a4576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040180806020018281038252601f8152602001807f45524332303a206d696e7420746f20746865207a65726f20616464726573730081525060200191505060405180910390fd5b6113b06000838361168c565b6113c58160025461127990919063ffffffff16565b60028190555061141c816000808573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000205461127990919063ffffffff16565b6000808473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020819055508173ffffffffffffffffffffffffffffffffffffffff16600073ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef836040518082815260200191505060405180910390a35050565b600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff16141561154e576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004018080602001828103825260218152602001806117916021913960400191505060405180910390fd5b61155a8260008361168c565b6115c5816040518060600160405280602281526020016116ff602291396000808673ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020546111b99092919063ffffffff16565b6000808473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000208190555061161c8160025461169190919063ffffffff16565b600281905550600073ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff167fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef836040518082815260200191505060405180910390a35050565b505050565b60006116d383836040518060400160405280601e81526020017f536166654d6174683a207375627472616374696f6e206f766572666c6f7700008152506111b9565b90509291505056fe45524332303a207472616e7366657220746f20746865207a65726f206164647265737345524332303a206275726e20616d6f756e7420657863656564732062616c616e636545524332303a20617070726f766520746f20746865207a65726f206164647265737345524332303a207472616e7366657220616d6f756e7420657863656564732062616c616e636545524332303a207472616e7366657220616d6f756e74206578636565647320616c6c6f77616e636545524332303a206275726e2066726f6d20746865207a65726f206164647265737345524332303a207472616e736665722066726f6d20746865207a65726f206164647265737345524332303a20617070726f76652066726f6d20746865207a65726f206164647265737345524332303a2064656372656173656420616c6c6f77616e63652062656c6f77207a65726fa2646970667358221220dc073b6cf122829dad99817c66daee1bbd2c9260b617df4eee727a5088e8956664736f6c634300060c0033

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

30747:708:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21932:83;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;24038:169;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;23007:100;;;:::i;:::-;;;;;;;;;;;;;;;;;;;24681:321;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;22859:83;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;25411:218;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;31162:137;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;23170:119;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;31030:120;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;30782:20;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;22134:87;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31311:141;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;26132:269;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;23502:175;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;30809:26;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;23740:151;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;21932:83;21969:13;22002:5;21995:12;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21932:83;:::o;24038:169::-;24121:4;24138:39;24147:12;:10;:12::i;:::-;24161:7;24170:6;24138:8;:39::i;:::-;24195:4;24188:11;;24038:169;;;;:::o;23007:100::-;23060:7;23087:12;;23080:19;;23007:100;:::o;24681:321::-;24787:4;24804:36;24814:6;24822:9;24833:6;24804:9;:36::i;:::-;24851:121;24860:6;24868:12;:10;:12::i;:::-;24882:89;24920:6;24882:89;;;;;;;;;;;;;;;;;:11;:19;24894:6;24882:19;;;;;;;;;;;;;;;:33;24902:12;:10;:12::i;:::-;24882:33;;;;;;;;;;;;;;;;:37;;:89;;;;;:::i;:::-;24851:8;:121::i;:::-;24990:4;24983:11;;24681:321;;;;;:::o;22859:83::-;22900:5;22925:9;;;;;;;;;;;22918:16;;22859:83;:::o;25411:218::-;25499:4;25516:83;25525:12;:10;:12::i;:::-;25539:7;25548:50;25587:10;25548:11;:25;25560:12;:10;:12::i;:::-;25548:25;;;;;;;;;;;;;;;:34;25574:7;25548:34;;;;;;;;;;;;;;;;:38;;:50;;;;:::i;:::-;25516:8;:83::i;:::-;25617:4;25610:11;;25411:218;;;;:::o;31162:137::-;31246:11;;;;;;;;;;;31232:25;;:10;:25;;;31224:34;;;;;;31269:22;31275:7;31284:6;31269:5;:22::i;:::-;31162:137;;:::o;23170:119::-;23236:7;23263:9;:18;23273:7;23263:18;;;;;;;;;;;;;;;;23256:25;;23170:119;;;:::o;31030:120::-;30900:5;;;;;;;;;;;30886:19;;:10;:19;;;30878:28;;;;;;31124:18:::1;31110:11;;:32;;;;;;;;;;;;;;;;;;31030:120:::0;:::o;30782:20::-;;;;;;;;;;;;;:::o;22134:87::-;22173:13;22206:7;22199:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22134:87;:::o;31311:141::-;31398:11;;;;;;;;;;;31384:25;;:10;:25;;;31376:34;;;;;;31422:22;31428:7;31437:6;31422:5;:22::i;:::-;31311:141;;:::o;26132:269::-;26225:4;26242:129;26251:12;:10;:12::i;:::-;26265:7;26274:96;26313:15;26274:96;;;;;;;;;;;;;;;;;:11;:25;26286:12;:10;:12::i;:::-;26274:25;;;;;;;;;;;;;;;:34;26300:7;26274:34;;;;;;;;;;;;;;;;:38;;:96;;;;;:::i;:::-;26242:8;:129::i;:::-;26389:4;26382:11;;26132:269;;;;:::o;23502:175::-;23588:4;23605:42;23615:12;:10;:12::i;:::-;23629:9;23640:6;23605:9;:42::i;:::-;23665:4;23658:11;;23502:175;;;;:::o;30809:26::-;;;;;;;;;;;;;:::o;23740:151::-;23829:7;23856:11;:18;23868:5;23856:18;;;;;;;;;;;;;;;:27;23875:7;23856:27;;;;;;;;;;;;;;;;23849:34;;23740:151;;;;:::o;5510:106::-;5563:15;5598:10;5591:17;;5510:106;:::o;29277:346::-;29396:1;29379:19;;:5;:19;;;;29371:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29477:1;29458:21;;:7;:21;;;;29450:68;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;29561:6;29531:11;:18;29543:5;29531:18;;;;;;;;;;;;;;;:27;29550:7;29531:27;;;;;;;;;;;;;;;:36;;;;29599:7;29583:32;;29592:5;29583:32;;;29608:6;29583:32;;;;;;;;;;;;;;;;;;29277:346;;;:::o;26891:539::-;27015:1;26997:20;;:6;:20;;;;26989:70;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27099:1;27078:23;;:9;:23;;;;27070:71;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27154:47;27175:6;27183:9;27194:6;27154:20;:47::i;:::-;27234:71;27256:6;27234:71;;;;;;;;;;;;;;;;;:9;:17;27244:6;27234:17;;;;;;;;;;;;;;;;:21;;:71;;;;;:::i;:::-;27214:9;:17;27224:6;27214:17;;;;;;;;;;;;;;;:91;;;;27339:32;27364:6;27339:9;:20;27349:9;27339:20;;;;;;;;;;;;;;;;:24;;:32;;;;:::i;:::-;27316:9;:20;27326:9;27316:20;;;;;;;;;;;;;;;:55;;;;27404:9;27387:35;;27396:6;27387:35;;;27415:6;27387:35;;;;;;;;;;;;;;;;;;26891:539;;;:::o;7607:192::-;7693:7;7726:1;7721;:6;;7729:12;7713:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7753:9;7769:1;7765;:5;7753:17;;7790:1;7783:8;;;7607:192;;;;;:::o;6704:181::-;6762:7;6782:9;6798:1;6794;:5;6782:17;;6823:1;6818;:6;;6810:46;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6876:1;6869:8;;;6704:181;;;;:::o;27711:378::-;27814:1;27795:21;;:7;:21;;;;27787:65;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27865:49;27894:1;27898:7;27907:6;27865:20;:49::i;:::-;27942:24;27959:6;27942:12;;:16;;:24;;;;:::i;:::-;27927:12;:39;;;;27998:30;28021:6;27998:9;:18;28008:7;27998:18;;;;;;;;;;;;;;;;:22;;:30;;;;:::i;:::-;27977:9;:18;27987:7;27977:18;;;;;;;;;;;;;;;:51;;;;28065:7;28044:37;;28061:1;28044:37;;;28074:6;28044:37;;;;;;;;;;;;;;;;;;27711:378;;:::o;28421:418::-;28524:1;28505:21;;:7;:21;;;;28497:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;28577:49;28598:7;28615:1;28619:6;28577:20;:49::i;:::-;28660:68;28683:6;28660:68;;;;;;;;;;;;;;;;;:9;:18;28670:7;28660:18;;;;;;;;;;;;;;;;:22;;:68;;;;;:::i;:::-;28639:9;:18;28649:7;28639:18;;;;;;;;;;;;;;;:89;;;;28754:24;28771:6;28754:12;;:16;;:24;;;;:::i;:::-;28739:12;:39;;;;28820:1;28794:37;;28803:7;28794:37;;;28824:6;28794:37;;;;;;;;;;;;;;;;;;28421:418;;:::o;30648:92::-;;;;:::o;7168:136::-;7226:7;7253:43;7257:1;7260;7253:43;;;;;;;;;;;;;;;;;:3;:43::i;:::-;7246:50;;7168:136;;;;:::o

ipfs://dc073b6cf122829dad99817c66daee1bbd2c9260b617df4eee727a5088e89566