Contract 0x37d9D2C6035b744849C15F1BFEE8F268a20fCBd8

/**
 *Submitted for verification at Arbiscan on 2022-01-24
*/

// Sources flattened with hardhat v2.8.3 https://hardhat.org

// File deps/@openzeppelin/contracts-upgradeable/token/ERC20/IERC20Upgradeable.sol

// SPDX-License-Identifier: MIT

pragma solidity ^0.6.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20Upgradeable {
    /**
     * @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
    );
}


// File deps/@openzeppelin/contracts-upgradeable/math/SafeMathUpgradeable.sol

pragma solidity ^0.6.0;

/**
 * @dev Wrappers over Solidity's arithmetic operations with added overflow
 * checks.
 *
 * Arithmetic operations in Solidity wrap on overflow. This can easily result
 * in bugs, because programmers usually assume that an overflow raises an
 * error, which is the standard behavior in high level programming languages.
 * `SafeMath` restores this intuition by reverting the transaction when an
 * operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeMathUpgradeable {
    /**
     * @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;
    }
}


// File deps/@openzeppelin/contracts-upgradeable/math/MathUpgradeable.sol

pragma solidity ^0.6.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library MathUpgradeable {
    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return a >= b ? a : b;
    }

    /**
     * @dev Returns the smallest of two numbers.
     */
    function min(uint256 a, uint256 b) internal pure returns (uint256) {
        return a < b ? a : b;
    }

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow, so we distribute
        return (a / 2) + (b / 2) + (((a % 2) + (b % 2)) / 2);
    }
}


// File deps/@openzeppelin/contracts-upgradeable/utils/AddressUpgradeable.sol

pragma solidity ^0.6.2;

/**
 * @dev Collection of functions related to the address type
 */
library AddressUpgradeable {
    /**
     * @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);
            }
        }
    }
}


// File deps/@openzeppelin/contracts-upgradeable/token/ERC20/SafeERC20Upgradeable.sol

pragma solidity ^0.6.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 SafeERC20Upgradeable {
    using SafeMathUpgradeable for uint256;
    using AddressUpgradeable for address;

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

    function safeTransferFrom(
        IERC20Upgradeable 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(
        IERC20Upgradeable token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(
            token,
            abi.encodeWithSelector(token.approve.selector, spender, value)
        );
    }

    function safeIncreaseAllowance(
        IERC20Upgradeable 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(
        IERC20Upgradeable 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(IERC20Upgradeable token, bytes memory data)
        private
    {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

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


// File interfaces/badger/IController.sol

pragma solidity >=0.5.0 <0.8.0;

interface IController {
    function withdraw(address, uint256) external;

    function strategies(address) external view returns (address);

    function balanceOf(address) external view returns (uint256);

    function earn(address, uint256) external;

    function want(address) external view returns (address);

    function rewards() external view returns (address);

    function vaults(address) external view returns (address);
}


// File deps/@openzeppelin/contracts-upgradeable/proxy/Initializable.sol

pragma solidity >=0.4.24 <0.7.0;

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {UpgradeableProxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     */
    bool private _initialized;

    /**
     * @dev Indicates that the contract is in the process of being initialized.
     */
    bool private _initializing;

    /**
     * @dev Modifier to protect an initializer function from being invoked twice.
     */
    modifier initializer() {
        require(
            _initializing || _isConstructor() || !_initialized,
            "Initializable: contract is already initialized"
        );

        bool isTopLevelCall = !_initializing;
        if (isTopLevelCall) {
            _initializing = true;
            _initialized = true;
        }

        _;

        if (isTopLevelCall) {
            _initializing = false;
        }
    }

    /// @dev Returns true if and only if the function is running in the constructor
    function _isConstructor() private view returns (bool) {
        // extcodesize checks the size of the code stored in an address, and
        // address returns the current address. Since the code is still not
        // deployed when running a constructor, any checks on its code size will
        // yield zero, making it an effective way to detect if a contract is
        // under construction or not.
        address self = address(this);
        uint256 cs;
        // solhint-disable-next-line no-inline-assembly
        assembly {
            cs := extcodesize(self)
        }
        return cs == 0;
    }
}


// File deps/@openzeppelin/contracts-upgradeable/GSN/ContextUpgradeable.sol

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 ContextUpgradeable is Initializable {
    function __Context_init() internal initializer {
        __Context_init_unchained();
    }

    function __Context_init_unchained() internal initializer {}

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

    uint256[50] private __gap;
}


// File deps/@openzeppelin/contracts-upgradeable/utils/PausableUpgradeable.sol

pragma solidity ^0.6.0;


/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
contract PausableUpgradeable is Initializable, ContextUpgradeable {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    function __Pausable_init() internal initializer {
        __Context_init_unchained();
        __Pausable_init_unchained();
    }

    function __Pausable_init_unchained() internal initializer {
        _paused = false;
    }

    /**
     * @dev Returns true if the contract is paused, and false otherwise.
     */
    function paused() public view returns (bool) {
        return _paused;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is not paused.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    modifier whenNotPaused() {
        require(!_paused, "Pausable: paused");
        _;
    }

    /**
     * @dev Modifier to make a function callable only when the contract is paused.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    modifier whenPaused() {
        require(_paused, "Pausable: not paused");
        _;
    }

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }

    uint256[49] private __gap;
}


// File interfaces/uniswap/IUniswapRouterV2.sol

pragma solidity >=0.5.0 <0.8.0;

interface IUniswapRouterV2 {
    function factory() external view returns (address);

    function addLiquidity(
        address tokenA,
        address tokenB,
        uint256 amountADesired,
        uint256 amountBDesired,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    )
        external
        returns (
            uint256 amountA,
            uint256 amountB,
            uint256 liquidity
        );

    function addLiquidityETH(
        address token,
        uint256 amountTokenDesired,
        uint256 amountTokenMin,
        uint256 amountETHMin,
        address to,
        uint256 deadline
    )
        external
        payable
        returns (
            uint256 amountToken,
            uint256 amountETH,
            uint256 liquidity
        );

    function removeLiquidity(
        address tokenA,
        address tokenB,
        uint256 liquidity,
        uint256 amountAMin,
        uint256 amountBMin,
        address to,
        uint256 deadline
    ) external returns (uint256 amountA, uint256 amountB);

    function getAmountsOut(uint256 amountIn, address[] calldata path)
        external
        view
        returns (uint256[] memory amounts);

    function getAmountsIn(uint256 amountOut, address[] calldata path)
        external
        view
        returns (uint256[] memory amounts);

    function swapETHForExactTokens(
        uint256 amountOut,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

    function swapExactETHForTokens(
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external payable returns (uint256[] memory amounts);

    function swapExactTokensForETH(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapTokensForExactETH(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapExactTokensForTokens(
        uint256 amountIn,
        uint256 amountOutMin,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);

    function swapTokensForExactTokens(
        uint256 amountOut,
        uint256 amountInMax,
        address[] calldata path,
        address to,
        uint256 deadline
    ) external returns (uint256[] memory amounts);
}


// File interfaces/badger/IStrategy.sol

pragma solidity >=0.5.0 <0.8.0;

interface IStrategy {
    function want() external view returns (address);

    function deposit() external;

    // NOTE: must exclude any tokens used in the yield
    // Controller role - withdraw should return to Controller
    function withdrawOther(address) external returns (uint256 balance);

    // Controller | Vault role - withdraw should always return to Vault
    function withdraw(uint256) external;

    // Controller | Vault role - withdraw should always return to Vault
    function withdrawAll() external returns (uint256);

    function balanceOf() external view returns (uint256);

    function getName() external pure returns (string memory);

    function setStrategist(address _strategist) external;

    function setWithdrawalFee(uint256 _withdrawalFee) external;

    function setPerformanceFeeStrategist(uint256 _performanceFeeStrategist)
        external;

    function setPerformanceFeeGovernance(uint256 _performanceFeeGovernance)
        external;

    function setGovernance(address _governance) external;

    function setController(address _controller) external;

    function tend() external;

    function harvest() external;
}


// File deps/SettAccessControl.sol

pragma solidity ^0.6.11;

/*
    Common base for permissioned roles throughout Sett ecosystem
*/
contract SettAccessControl is Initializable {
    address public governance;
    address public strategist;
    address public keeper;

    // ===== MODIFIERS =====
    function _onlyGovernance() internal view {
        require(msg.sender == governance, "onlyGovernance");
    }

    function _onlyGovernanceOrStrategist() internal view {
        require(
            msg.sender == strategist || msg.sender == governance,
            "onlyGovernanceOrStrategist"
        );
    }

    function _onlyAuthorizedActors() internal view {
        require(
            msg.sender == keeper || msg.sender == governance,
            "onlyAuthorizedActors"
        );
    }

    // ===== PERMISSIONED ACTIONS =====

    /// @notice Change strategist address
    /// @notice Can only be changed by governance itself
    function setStrategist(address _strategist) external {
        _onlyGovernance();
        strategist = _strategist;
    }

    /// @notice Change keeper address
    /// @notice Can only be changed by governance itself
    function setKeeper(address _keeper) external {
        _onlyGovernance();
        keeper = _keeper;
    }

    /// @notice Change governance address
    /// @notice Can only be changed by governance itself
    function setGovernance(address _governance) public {
        _onlyGovernance();
        governance = _governance;
    }

    uint256[50] private __gap;
}


// File deps/BaseStrategy.sol

pragma solidity ^0.6.11;










/*
    ===== Badger Base Strategy =====
    Common base class for all Sett strategies

    Changelog
    V1.1
    - Verify amount unrolled from strategy positions on withdraw() is within a threshold relative to the requested amount as a sanity check
    - Add version number which is displayed with baseStrategyVersion(). If a strategy does not implement this function, it can be assumed to be 1.0

    V1.2
    - Remove idle want handling from base withdraw() function. This should be handled as the strategy sees fit in _withdrawSome()
*/
abstract contract BaseStrategy is PausableUpgradeable, SettAccessControl {
    using SafeERC20Upgradeable for IERC20Upgradeable;
    using AddressUpgradeable for address;
    using SafeMathUpgradeable for uint256;

    // Standardized harvest event for UI
    event Harvest(uint256 harvested, uint256 indexed blockNumber);

    address public want; // Want: Curve.fi renBTC/wBTC (crvRenWBTC) LP token

    uint256 public performanceFeeGovernance;
    uint256 public performanceFeeStrategist;
    uint256 public withdrawalFee;

    uint256 public constant MAX_FEE = 10000;
    address public constant uniswap =
        0x7a250d5630B4cF539739dF2C5dAcb4c659F2488D; // Uniswap Dex

    address public controller;
    address public guardian;

    uint256 public withdrawalMaxDeviationThreshold;

    function __BaseStrategy_init(
        address _governance,
        address _strategist,
        address _controller,
        address _keeper,
        address _guardian
    ) public initializer whenNotPaused {
        __Pausable_init();
        governance = _governance;
        strategist = _strategist;
        keeper = _keeper;
        controller = _controller;
        guardian = _guardian;
        withdrawalMaxDeviationThreshold = 50;
    }

    // ===== Modifiers =====

    function _onlyController() internal view {
        require(msg.sender == controller, "onlyController");
    }

    function _onlyAuthorizedActorsOrController() internal view {
        require(
            msg.sender == keeper ||
                msg.sender == governance ||
                msg.sender == controller,
            "onlyAuthorizedActorsOrController"
        );
    }

    function _onlyAuthorizedPausers() internal view {
        require(
            msg.sender == guardian || msg.sender == governance,
            "onlyPausers"
        );
    }

    /// ===== View Functions =====
    function baseStrategyVersion() public view returns (string memory) {
        return "1.2";
    }

    /// @notice Get the balance of want held idle in the Strategy
    function balanceOfWant() public view returns (uint256) {
        return IERC20Upgradeable(want).balanceOf(address(this));
    }

    /// @notice Get the total balance of want realized in the strategy, whether idle or active in Strategy positions.
    function balanceOf() public view virtual returns (uint256) {
        return balanceOfWant().add(balanceOfPool());
    }

    function isTendable() public view virtual returns (bool) {
        return false;
    }

    /// ===== Permissioned Actions: Governance =====

    function setGuardian(address _guardian) external {
        _onlyGovernance();
        guardian = _guardian;
    }

    function setWithdrawalFee(uint256 _withdrawalFee) external {
        _onlyGovernance();
        require(
            _withdrawalFee <= MAX_FEE,
            "base-strategy/excessive-withdrawal-fee"
        );
        withdrawalFee = _withdrawalFee;
    }

    function setPerformanceFeeStrategist(uint256 _performanceFeeStrategist)
        external
    {
        _onlyGovernance();
        require(
            _performanceFeeStrategist <= MAX_FEE,
            "base-strategy/excessive-strategist-performance-fee"
        );
        performanceFeeStrategist = _performanceFeeStrategist;
    }

    function setPerformanceFeeGovernance(uint256 _performanceFeeGovernance)
        external
    {
        _onlyGovernance();
        require(
            _performanceFeeGovernance <= MAX_FEE,
            "base-strategy/excessive-governance-performance-fee"
        );
        performanceFeeGovernance = _performanceFeeGovernance;
    }

    function setController(address _controller) external {
        _onlyGovernance();
        controller = _controller;
    }

    function setWithdrawalMaxDeviationThreshold(uint256 _threshold) external {
        _onlyGovernance();
        require(
            _threshold <= MAX_FEE,
            "base-strategy/excessive-max-deviation-threshold"
        );
        withdrawalMaxDeviationThreshold = _threshold;
    }

    function deposit() public virtual whenNotPaused {
        _onlyAuthorizedActorsOrController();
        uint256 _want = IERC20Upgradeable(want).balanceOf(address(this));
        if (_want > 0) {
            _deposit(_want);
        }
        _postDeposit();
    }

    // ===== Permissioned Actions: Controller =====

    /// @notice Controller-only function to Withdraw partial funds, normally used with a vault withdrawal
    function withdrawAll()
        external
        virtual
        whenNotPaused
        returns (uint256 balance)
    {
        _onlyController();

        _withdrawAll();

        _transferToVault(IERC20Upgradeable(want).balanceOf(address(this)));
    }

    /// @notice Withdraw partial funds from the strategy, unrolling from strategy positions as necessary
    /// @notice Processes withdrawal fee if present
    /// @dev If it fails to recover sufficient funds (defined by withdrawalMaxDeviationThreshold), the withdrawal should fail so that this unexpected behavior can be investigated
    function withdraw(uint256 _amount) external virtual whenNotPaused {
        _onlyController();

        // Withdraw from strategy positions, typically taking from any idle want first.
        _withdrawSome(_amount);
        uint256 _postWithdraw =
            IERC20Upgradeable(want).balanceOf(address(this));

        // Sanity check: Ensure we were able to retrieve sufficent want from strategy positions
        // If we end up with less than the amount requested, make sure it does not deviate beyond a maximum threshold
        if (_postWithdraw < _amount) {
            uint256 diff = _diff(_amount, _postWithdraw);

            // Require that difference between expected and actual values is less than the deviation threshold percentage
            require(
                diff <=
                    _amount.mul(withdrawalMaxDeviationThreshold).div(MAX_FEE),
                "base-strategy/withdraw-exceed-max-deviation-threshold"
            );
        }

        // Return the amount actually withdrawn if less than amount requested
        uint256 _toWithdraw = MathUpgradeable.min(_postWithdraw, _amount);

        // Process withdrawal fee
        uint256 _fee = _processWithdrawalFee(_toWithdraw);

        // Transfer remaining to Vault to handle withdrawal
        _transferToVault(_toWithdraw.sub(_fee));
    }

    // NOTE: must exclude any tokens used in the yield
    // Controller role - withdraw should return to Controller
    function withdrawOther(address _asset)
        external
        virtual
        whenNotPaused
        returns (uint256 balance)
    {
        _onlyController();
        _onlyNotProtectedTokens(_asset);

        balance = IERC20Upgradeable(_asset).balanceOf(address(this));
        IERC20Upgradeable(_asset).safeTransfer(controller, balance);
    }

    /// ===== Permissioned Actions: Authoized Contract Pausers =====

    function pause() external {
        _onlyAuthorizedPausers();
        _pause();
    }

    function unpause() external {
        _onlyGovernance();
        _unpause();
    }

    /// ===== Internal Helper Functions =====

    /// @notice If withdrawal fee is active, take the appropriate amount from the given value and transfer to rewards recipient
    /// @return The withdrawal fee that was taken
    function _processWithdrawalFee(uint256 _amount) internal returns (uint256) {
        if (withdrawalFee == 0) {
            return 0;
        }

        uint256 fee = _amount.mul(withdrawalFee).div(MAX_FEE);
        IERC20Upgradeable(want).safeTransfer(
            IController(controller).rewards(),
            fee
        );
        return fee;
    }

    /// @dev Helper function to process an arbitrary fee
    /// @dev If the fee is active, transfers a given portion in basis points of the specified value to the recipient
    /// @return The fee that was taken
    function _processFee(
        address token,
        uint256 amount,
        uint256 feeBps,
        address recipient
    ) internal returns (uint256) {
        if (feeBps == 0) {
            return 0;
        }
        uint256 fee = amount.mul(feeBps).div(MAX_FEE);
        IERC20Upgradeable(token).safeTransfer(recipient, fee);
        return fee;
    }

    /// @dev Reset approval and approve exact amount
    function _safeApproveHelper(
        address token,
        address recipient,
        uint256 amount
    ) internal {
        IERC20Upgradeable(token).safeApprove(recipient, 0);
        IERC20Upgradeable(token).safeApprove(recipient, amount);
    }

    function _transferToVault(uint256 _amount) internal {
        address _vault = IController(controller).vaults(address(want));
        require(_vault != address(0), "!vault"); // additional protection so we don't burn the funds
        IERC20Upgradeable(want).safeTransfer(_vault, _amount);
    }

    /// @notice Swap specified balance of given token on Uniswap with given path
    function _swap(
        address startToken,
        uint256 balance,
        address[] memory path
    ) internal {
        _safeApproveHelper(startToken, uniswap, balance);
        IUniswapRouterV2(uniswap).swapExactTokensForTokens(
            balance,
            0,
            path,
            address(this),
            now
        );
    }

    function _swapEthIn(uint256 balance, address[] memory path) internal {
        IUniswapRouterV2(uniswap).swapExactETHForTokens{value: balance}(
            0,
            path,
            address(this),
            now
        );
    }

    function _swapEthOut(
        address startToken,
        uint256 balance,
        address[] memory path
    ) internal {
        _safeApproveHelper(startToken, uniswap, balance);
        IUniswapRouterV2(uniswap).swapExactTokensForETH(
            balance,
            0,
            path,
            address(this),
            now
        );
    }

    /// @notice Add liquidity to uniswap for specified token pair, utilizing the maximum balance possible
    function _add_max_liquidity_uniswap(address token0, address token1)
        internal
        virtual
    {
        uint256 _token0Balance =
            IERC20Upgradeable(token0).balanceOf(address(this));
        uint256 _token1Balance =
            IERC20Upgradeable(token1).balanceOf(address(this));

        _safeApproveHelper(token0, uniswap, _token0Balance);
        _safeApproveHelper(token1, uniswap, _token1Balance);

        IUniswapRouterV2(uniswap).addLiquidity(
            token0,
            token1,
            _token0Balance,
            _token1Balance,
            0,
            0,
            address(this),
            block.timestamp
        );
    }

    /// @notice Utility function to diff two numbers, expects higher value in first position
    function _diff(uint256 a, uint256 b) internal pure returns (uint256) {
        require(a >= b, "diff/expected-higher-number-in-first-position");
        return a.sub(b);
    }

    // ===== Abstract Functions: To be implemented by specific Strategies =====

    /// @dev Internal deposit logic to be implemented by Stratgies
    function _deposit(uint256 _amount) internal virtual;

    function _postDeposit() internal virtual {
        //no-op by default
    }

    /// @notice Specify tokens used in yield process, should not be available to withdraw via withdrawOther()
    function _onlyNotProtectedTokens(address _asset) internal virtual;

    function getProtectedTokens()
        external
        view
        virtual
        returns (address[] memory);

    /// @dev Internal logic for strategy migration. Should exit positions as efficiently as possible
    function _withdrawAll() internal virtual;

    /// @dev Internal logic for partial withdrawals. Should exit positions as efficiently as possible.
    /// @dev The withdraw() function shell automatically uses idle want in the strategy before attempting to withdraw more using this
    function _withdrawSome(uint256 _amount) internal virtual returns (uint256);

    /// @dev Realize returns from positions
    /// @dev Returns can be reinvested into positions, or distributed in another fashion
    /// @dev Performance fees should also be implemented in this function
    /// @dev Override function stub is removed as each strategy can have it's own return signature for STATICCALL
    // function harvest() external virtual;

    /// @dev User-friendly name for this strategy for purposes of convenient reading
    function getName() external pure virtual returns (string memory);

    /// @dev Balance of want currently held in strategy positions
    function balanceOfPool() public view virtual returns (uint256);

    uint256[49] private __gap;
}


// File interfaces/swapr/IERC20StakingRewardsDistribution.sol

pragma solidity ^0.6.11;
pragma experimental ABIEncoderV2;

interface IERC20StakingRewardsDistribution {
    /// @dev BalanceOf
    function stakedTokensOf(address) external view returns (uint256 balance);

    /// @dev deposit amount
    function stake(uint256 _amount) external;

    /// @dev withdraw some
    function withdraw(uint256 _amount) external;

    /// @dev get all rewards until now
    function claimAll(address _recipient) external;

    /// @dev Withdraw all and get rewards too
    function exit(address _recipient) external;

    /// @dev Timestamp when staking is enabled
    function startingTimestamp() external view returns (uint256);

    function claimableRewards(address _account)
        external
        view
        returns (uint256[] memory);
}


// File contracts/MyStrategy.sol

pragma solidity ^0.6.11;





contract MyStrategy is BaseStrategy {
    using SafeERC20Upgradeable for IERC20Upgradeable;
    using AddressUpgradeable for address;
    using SafeMathUpgradeable for uint256;

    // address public want // Inherited from BaseStrategy, the token the strategy wants, swaps into and tries to grow
    address public lpComponent; // Token we provide liquidity with
    address public reward; // Token we farm and swap to want

    address public constant WETH = 0x82aF49447D8a07e3bd95BD0d56f35241523fBab1;

    IUniswapRouterV2 public constant DX_SWAP_ROUTER =
        IUniswapRouterV2(0x530476d5583724A89c8841eB6Da76E7Af4C0F17E);

    // Set in initialize, can be changed by governance via setStakingContract
    address public stakingContract;
    bool public autocompoundOnWithdrawAll; // Should we swap rewards to want in withdrawAll? // False by default

    // Used to signal to the Badger Tree that rewards where sent to it
    event TreeDistribution(
        address indexed token,
        uint256 amount,
        uint256 indexed blockNumber,
        uint256 timestamp
    );

    function initialize(
        address _governance,
        address _strategist,
        address _controller,
        address _keeper,
        address _guardian,
        address[3] memory _wantConfig,
        uint256[3] memory _feeConfig
    ) public initializer {
        __BaseStrategy_init(
            _governance,
            _strategist,
            _controller,
            _keeper,
            _guardian
        );
        /// @dev Add config here
        want = _wantConfig[0];
        lpComponent = _wantConfig[1];
        reward = _wantConfig[2];

        performanceFeeGovernance = _feeConfig[0];
        performanceFeeStrategist = _feeConfig[1];
        withdrawalFee = _feeConfig[2];

        stakingContract = 0xe2A7CF0DEB83F2BC2FD15133a02A24B9981f2c17; // Current deployment was lacking this

        /// @dev do one off approvals here
        // Approvals for swaps and LP
        IERC20Upgradeable(reward).safeApprove(
            address(DX_SWAP_ROUTER),
            type(uint256).max
        );
        IERC20Upgradeable(WETH).safeApprove(
            address(DX_SWAP_ROUTER),
            type(uint256).max
        );

        // Approval for deposit
        IERC20Upgradeable(want).safeApprove(stakingContract, type(uint256).max);
    }

    /// @dev Governance Set new stakingContract Function
    /// @notice this method is "safe" only if governance is a timelock
    function setStakingContract(address newStakingAddress) external {
        _onlyGovernance();

        require(newStakingAddress != address(0));

        if (stakingContract != address(0)) {
            if (balanceOfPool() > 0) {
                // Withdraw from old stakingContract
                _withdrawAll();
            }
            IERC20Upgradeable(want).safeApprove(stakingContract, 0);
        }

        // Set new stakingContract
        stakingContract = newStakingAddress;

        // Add approvals to new stakingContract
        IERC20Upgradeable(want).safeApprove(stakingContract, type(uint256).max);

        uint256 balanceOfWant = balanceOfWant();
        if (balanceOfWant > 0) {
            // Deposit all in new stakingContract
            _deposit(balanceOfWant);
        }
    }

    function setAutocompoundOnWithdrawAll(bool newAutocompoundOnWithdrawAll)
        public
    {
        _onlyGovernance();
        autocompoundOnWithdrawAll = newAutocompoundOnWithdrawAll;
    }

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

    // @dev Specify the name of the strategy
    function getName() external pure override returns (string memory) {
        return "Arbitrum-swapr-SWAPR-WETH";
    }

    // @dev Specify the version of the Strategy, for upgrades
    function version() external pure returns (string memory) {
        return "1.0";
    }

    /// @dev Balance of want currently held in strategy positions
    function balanceOfPool() public view override returns (uint256) {
        return
            IERC20StakingRewardsDistribution(stakingContract).stakedTokensOf(
                address(this)
            );
    }

    /// @dev Returns true if this strategy requires tending
    function isTendable() public view override returns (bool) {
        return true;
    }

    // @dev These are the tokens that cannot be moved except by the vault
    function getProtectedTokens()
        public
        view
        override
        returns (address[] memory)
    {
        address[] memory protectedTokens = new address[](4);
        protectedTokens[0] = want;
        protectedTokens[1] = lpComponent;
        protectedTokens[2] = reward;
        protectedTokens[3] = WETH;
        // protectedTokens[2] = SWAPR; // SWAPR == Reward
        return protectedTokens;
    }

    /// ===== Internal Core Implementations =====

    /// @dev security check to avoid moving tokens that would cause a rugpull, edit based on strat
    function _onlyNotProtectedTokens(address _asset) internal override {
        address[] memory protectedTokens = getProtectedTokens();

        for (uint256 x = 0; x < protectedTokens.length; x++) {
            require(
                address(protectedTokens[x]) != _asset,
                "Asset is protected"
            );
        }
    }

    /// @dev invest the amount of want
    /// @notice When this function is called, the controller has already sent want to this
    /// @notice Just get the current balance and then invest accordingly
    function _deposit(uint256 _amount) internal override {
        // NOTE: This reverts if emission has ended, just change the staking contract then
        IERC20StakingRewardsDistribution(stakingContract).stake(_amount);
    }

    /// @dev utility function to withdraw everything for migration
    function _withdrawAll() internal override {
        IERC20StakingRewardsDistribution _stakingContract =
            IERC20StakingRewardsDistribution(stakingContract);

        uint256[] memory rewards =
            _stakingContract.claimableRewards(address(this));
        for (uint256 i; i < rewards.length; i++) {
            if (rewards[i] > 0) {
                // Withdraws all and claims rewards
                _stakingContract.exit(address(this));
                // False by default
                if (autocompoundOnWithdrawAll) {
                    // Swap rewards into want
                    _swapRewardsToWant();
                }
                return;
            }
        }
        // Withdraws all without claiming rewards
        _stakingContract.withdraw(
            _stakingContract.stakedTokensOf(address(this))
        );
    }

    /// @dev withdraw the specified amount of want, liquidate from lpComponent to want, paying off any necessary debt for the conversion
    function _withdrawSome(uint256 _amount)
        internal
        override
        returns (uint256)
    {
        // Due to rounding errors on the Controller, the amount may be slightly higher than the available amount in edge cases.
        uint256 wantBalance = balanceOfWant();

        if (wantBalance < _amount) {
            uint256 toWithdraw = _amount.sub(balanceOfWant());

            uint256 poolBalance = balanceOfPool();
            if (poolBalance < toWithdraw) {
                IERC20StakingRewardsDistribution(stakingContract).withdraw(
                    poolBalance
                );
            } else {
                IERC20StakingRewardsDistribution(stakingContract).withdraw(
                    toWithdraw
                );
            }
        }

        return MathUpgradeable.min(_amount, balanceOfWant());
    }

    /// @dev Harvest from strategy mechanics, realizing increase in underlying position
    function harvest() external whenNotPaused returns (uint256 harvested) {
        _onlyAuthorizedActors();

        uint256 _before = IERC20Upgradeable(want).balanceOf(address(this));

        // Claim rewards
        IERC20StakingRewardsDistribution(stakingContract).claimAll(
            address(this)
        );

        // Swap to want
        _swapRewardsToWant();

        harvested = IERC20Upgradeable(want).balanceOf(address(this)).sub(
            _before
        );

        /// @notice Keep this in so you get paid!
        (uint256 governancePerformanceFee, uint256 strategistPerformanceFee) =
            _processRewardsFees(harvested, want);

        /// @dev Harvest event that every strategy MUST have, see BaseStrategy
        emit Harvest(harvested, block.number);

        /// @dev Harvest must return the amount of want increased
        return harvested;
    }

    /// @dev Swap 50% reward = SWAPR into WETH, then LP
    function _swapRewardsToWant() internal {
        uint256 toSwap = IERC20Upgradeable(reward).balanceOf(address(this));

        if (toSwap == 0) {
            return;
        }
        address[] memory path = new address[](2);
        path[0] = reward;
        path[1] = WETH;

        // Swap 50% swapr for WETH
        DX_SWAP_ROUTER.swapExactTokensForTokens(
            toSwap.mul(50).div(100),
            0,
            path,
            address(this),
            now
        );

        // Now that we have Swapr and WETH, lp for more want
        DX_SWAP_ROUTER.addLiquidity(
            reward,
            WETH,
            IERC20Upgradeable(reward).balanceOf(address(this)),
            IERC20Upgradeable(WETH).balanceOf(address(this)),
            0,
            0,
            address(this),
            now
        );
    }

    /// @dev If any want is uninvested, let's invest here
    function tend() external whenNotPaused {
        _onlyAuthorizedActors();
        uint256 balanceOfWant = balanceOfWant();
        if (balanceOfWant > 0) {
            // NOTE: This will revert if staking has ended, just change to next staking contract
            _deposit(balanceOfWant);
        }
    }

    /// ===== Internal Helper Functions =====

    /// @dev used to manage the governance and strategist fee on earned rewards, make sure to use it to get paid!
    function _processRewardsFees(uint256 _amount, address _token)
        internal
        returns (uint256 governanceRewardsFee, uint256 strategistRewardsFee)
    {
        governanceRewardsFee = _processFee(
            _token,
            _amount,
            performanceFeeGovernance,
            IController(controller).rewards()
        );

        strategistRewardsFee = _processFee(
            _token,
            _amount,
            performanceFeeStrategist,
            strategist
        );
    }
}

[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"harvested","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"blockNumber","type":"uint256"}],"name":"Harvest","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"token","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":true,"internalType":"uint256","name":"blockNumber","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"timestamp","type":"uint256"}],"name":"TreeDistribution","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"DX_SWAP_ROUTER","outputs":[{"internalType":"contract IUniswapRouterV2","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MAX_FEE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"WETH","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_governance","type":"address"},{"internalType":"address","name":"_strategist","type":"address"},{"internalType":"address","name":"_controller","type":"address"},{"internalType":"address","name":"_keeper","type":"address"},{"internalType":"address","name":"_guardian","type":"address"}],"name":"__BaseStrategy_init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"autocompoundOnWithdrawAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"balanceOfPool","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"balanceOfWant","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseStrategyVersion","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"controller","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getName","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"getProtectedTokens","outputs":[{"internalType":"address[]","name":"","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"governance","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"guardian","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"harvest","outputs":[{"internalType":"uint256","name":"harvested","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_governance","type":"address"},{"internalType":"address","name":"_strategist","type":"address"},{"internalType":"address","name":"_controller","type":"address"},{"internalType":"address","name":"_keeper","type":"address"},{"internalType":"address","name":"_guardian","type":"address"},{"internalType":"address[3]","name":"_wantConfig","type":"address[3]"},{"internalType":"uint256[3]","name":"_feeConfig","type":"uint256[3]"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"isTendable","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"keeper","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lpComponent","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"performanceFeeGovernance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"performanceFeeStrategist","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"reward","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"newAutocompoundOnWithdrawAll","type":"bool"}],"name":"setAutocompoundOnWithdrawAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_controller","type":"address"}],"name":"setController","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_governance","type":"address"}],"name":"setGovernance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_guardian","type":"address"}],"name":"setGuardian","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_keeper","type":"address"}],"name":"setKeeper","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_performanceFeeGovernance","type":"uint256"}],"name":"setPerformanceFeeGovernance","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_performanceFeeStrategist","type":"uint256"}],"name":"setPerformanceFeeStrategist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newStakingAddress","type":"address"}],"name":"setStakingContract","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_strategist","type":"address"}],"name":"setStrategist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_withdrawalFee","type":"uint256"}],"name":"setWithdrawalFee","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_threshold","type":"uint256"}],"name":"setWithdrawalMaxDeviationThreshold","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stakingContract","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"strategist","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"tend","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"uniswap","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"version","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"want","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawAll","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_asset","type":"address"}],"name":"withdrawOther","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawalFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawalMaxDeviationThreshold","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

47860:10841:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51883:214;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;34244:39;;;:::i;51530:119::-;;;:::i;:::-;;;;;;;:::i;40532:358::-;;;;;;:::i;:::-;;:::i;34164:19::-;;;:::i;:::-;;;;;;;:::i;31830:25::-;;;:::i;48234:21::-;;;:::i;34419:85::-;;;:::i;39047:1358::-;;;;;;:::i;:::-;;:::i;:::-;;48624:37;;;:::i;:::-;;;;;;;:::i;34647:459::-;;;;;;:::i;:::-;;:::i;41066:85::-;;;:::i;57692:312::-;;;:::i;34560:23::-;;;:::i;55788:905::-;;;:::i;34290:39::-;;;:::i;51720:88::-;;;:::i;51241:197::-;;;;;;:::i;:::-;;:::i;31798:25::-;;;:::i;26240:78::-;;;:::i;48973:1295::-;;;;;;:::i;:::-;;:::i;36194:121::-;;;:::i;32814:108::-;;;;;;:::i;:::-;;:::i;52166:88::-;;;:::i;40970:::-;;;:::i;37216:341::-;;;;;;:::i;:::-;;:::i;38437:263::-;;;:::i;36475:116::-;;;;;;:::i;:::-;;:::i;34336:28::-;;;:::i;37565:124::-;;;;;;:::i;:::-;;:::i;48380:119::-;;;:::i;50406:827::-;;;;;;:::i;:::-;;:::i;33031:122::-;;;;;;:::i;:::-;;:::i;36599:260::-;;;;;;:::i;:::-;;:::i;31862:21::-;;;:::i;48298:73::-;;;:::i;34373:39::-;;;:::i;35938:129::-;;;:::i;32585:124::-;;;;;;:::i;:::-;;:::i;37998:269::-;;;:::i;37697:293::-;;;;;;:::i;:::-;;:::i;35765:98::-;;;:::i;48166:26::-;;;:::i;52337:434::-;;;:::i;:::-;;;;;;;:::i;48587:30::-;;;:::i;36867:341::-;;;;;;:::i;:::-;;:::i;34528:25::-;;;:::i;34592:46::-;;;:::i;51883:214::-;52011:15;;51978:111;;-1:-1:-1;;;51978:111:0;;51938:7;;-1:-1:-1;;;;;52011:15:0;;51978:64;;:111;;52069:4;;51978:111;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;51958:131;;51883:214;;:::o;34244:39::-;;;;:::o;51530:119::-;51607:34;;;;;;;;;;;;;;;;;51530:119;:::o;40532:358::-;26558:7;;40647:15;;26558:7;;26557:8;26549:37;;;;-1:-1:-1;;;26549:37:0;;;;;;;:::i;:::-;;;;;;;;;40680:17:::1;:15;:17::i;:::-;40708:31;40732:6;40708:23;:31::i;:::-;40762:50;::::0;-1:-1:-1;;;40762:50:0;;-1:-1:-1;;;;;40762:35:0;::::1;::::0;::::1;::::0;:50:::1;::::0;40806:4:::1;::::0;40762:50:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;40862:10;::::0;40752:60;;-1:-1:-1;40823:59:0::1;::::0;-1:-1:-1;;;;;40823:38:0;;::::1;::::0;40862:10:::1;40752:60:::0;40823:38:::1;:59::i;:::-;40532:358:::0;;;:::o;34164:19::-;;;-1:-1:-1;;;;;34164:19:0;;:::o;31830:25::-;;;-1:-1:-1;;;;;31830:25:0;;:::o;48234:21::-;;;-1:-1:-1;;;;;48234:21:0;;:::o;34419:85::-;34462:42;34419:85;:::o;39047:1358::-;26558:7;;;;26557:8;26549:37;;;;-1:-1:-1;;;26549:37:0;;;;;;;:::i;:::-;39124:17:::1;:15;:17::i;:::-;39243:22;39257:7;39243:13;:22::i;:::-;-1:-1:-1::0;39331:4:0::1;::::0;39313:48:::1;::::0;-1:-1:-1;;;39313:48:0;;39276:21:::1;::::0;-1:-1:-1;;;;;39331:4:0::1;::::0;39313:33:::1;::::0;:48:::1;::::0;39355:4:::1;::::0;39313:48:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;39276:85;;39610:7;39594:13;:23;39590:441;;;39634:12;39649:29;39655:7;39664:13;39649:5;:29::i;:::-;39634:44;;39873:57;34407:5;39873:44;39885:31;;39873:7;:11;;:44;;;;:::i;:::-;:48:::0;::::1;:57::i;:::-;39844:4;:86;;39818:201;;;;-1:-1:-1::0;;;39818:201:0::1;;;;;;;:::i;:::-;39590:441;;40122:19;40144:43;40164:13;40179:7;40144:19;:43::i;:::-;40122:65;;40235:12;40250:34;40272:11;40250:21;:34::i;:::-;40235:49:::0;-1:-1:-1;40358:39:0::1;40375:21;:11:::0;40235:49;40375:15:::1;:21::i;:::-;40358:16;:39::i;:::-;26597:1;;;39047:1358:::0;:::o;48624:37::-;;;-1:-1:-1;;;48624:37:0;;;;;:::o;34647:459::-;22587:13;;;;;;;;:33;;;22604:16;:14;:16::i;:::-;22587:50;;;-1:-1:-1;22625:12:0;;;;22624:13;22587:50;22565:146;;;;-1:-1:-1;;;22565:146:0;;;;;;;:::i;:::-;22724:19;22747:13;;;;;;22746:14;22771:101;;;;22806:13;:20;;-1:-1:-1;;;;22806:20:0;;;;;22841:19;22822:4;22841:19;;;22771:101;26558:7:::1;::::0;::::1;;26557:8;26549:37;;;;-1:-1:-1::0;;;26549:37:0::1;;;;;;;:::i;:::-;34871:17:::2;:15;:17::i;:::-;34899:10;:24:::0;;-1:-1:-1;;;;;;34899:24:0;;::::2;-1:-1:-1::0;;;;;34899:24:0;;::::2;::::0;;;::::2;::::0;;;34934:10:::2;:24:::0;;;::::2;::::0;;::::2;;::::0;;34969:6:::2;:16:::0;;;::::2;::::0;;::::2;;::::0;;34996:10:::2;:24:::0;;;::::2;::::0;;::::2;;::::0;;35031:8:::2;:20:::0;;;;::::2;::::0;;::::2;::::0;;;::::2;::::0;;35096:2:::2;35062:31;:36:::0;22898:68;;;;22949:5;22933:21;;-1:-1:-1;;22933:21:0;;;22898:68;34647:459;;;;;;:::o;41066:85::-;41105:17;:15;:17::i;:::-;41133:10;:8;:10::i;:::-;41066:85::o;57692:312::-;26558:7;;;;26557:8;26549:37;;;;-1:-1:-1;;;26549:37:0;;;;;;;:::i;:::-;57742:23:::1;:21;:23::i;:::-;57776:21;57800:15;:13;:15::i;:::-;57776:39:::0;-1:-1:-1;57830:17:0;;57826:171:::1;;57962:23;57971:13;57962:8;:23::i;:::-;26597:1;57692:312::o:0;34560:23::-;;;-1:-1:-1;;;;;34560:23:0;;:::o;55788:905::-;26558:7;;55839:17;;26558:7;;26557:8;26549:37;;;;-1:-1:-1;;;26549:37:0;;;;;;;:::i;:::-;55869:23:::1;:21;:23::i;:::-;55941:4;::::0;55923:48:::1;::::0;-1:-1:-1;;;55923:48:0;;55905:15:::1;::::0;-1:-1:-1;;;;;55941:4:0::1;::::0;55923:33:::1;::::0;:48:::1;::::0;55965:4:::1;::::0;55923:48:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;56043:15;::::0;56010:97:::1;::::0;-1:-1:-1;;;56010:97:0;;55905:66;;-1:-1:-1;;;;;;56043:15:0::1;::::0;56010:58:::1;::::0;:97:::1;::::0;56091:4:::1;::::0;56010:97:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;56145:20;:18;:20::i;:::-;56208:4;::::0;56190:48:::1;::::0;-1:-1:-1;;;56190:48:0;;:85:::1;::::0;56257:7;;-1:-1:-1;;;;;56208:4:0;;::::1;::::0;56190:33:::1;::::0;:48:::1;::::0;56232:4:::1;::::0;56190:48:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:52:::0;::::1;:85::i;:::-;56454:4;::::0;56178:97;;-1:-1:-1;56340:32:0::1;::::0;;;56423:36:::1;::::0;56178:97;;-1:-1:-1;;;;;56454:4:0::1;56423:19;:36::i;:::-;56339:120;;;;56576:12;56557:32;56565:9;56557:32;;;;;;:::i;:::-;;;;;;;;56669:16;;;55788:905:::0;:::o;34290:39::-;;;;:::o;51720:88::-;51788:12;;;;;;;;;;;;-1:-1:-1;;;51788:12:0;;;;51720:88;:::o;51241:197::-;51346:17;:15;:17::i;:::-;51374:25;:56;;;;;-1:-1:-1;;;51374:56:0;-1:-1:-1;;;;51374:56:0;;;;;;;;;51241:197::o;31798:25::-;;;-1:-1:-1;;;;;31798:25:0;;:::o;26240:78::-;26303:7;;;;26240:78;:::o;48973:1295::-;22587:13;;;;;;;;:33;;;22604:16;:14;:16::i;:::-;22587:50;;;-1:-1:-1;22625:12:0;;;;22624:13;22587:50;22565:146;;;;-1:-1:-1;;;22565:146:0;;;;;;;:::i;:::-;22724:19;22747:13;;;;;;22746:14;22771:101;;;;22806:13;:20;;-1:-1:-1;;;;22806:20:0;;;;;22841:19;22822:4;22841:19;;;22771:101;49253:154:::1;49287:11;49313;49339;49365:7;49387:9;49253:19;:154::i;:::-;49459:14:::0;;49452:4:::1;:21:::0;;-1:-1:-1;;;;;;49452:21:0;;::::1;-1:-1:-1::0;;;;;49452:21:0;;::::1;;::::0;;;49459:14:::1;49498::::0;;::::1;::::0;49484:11:::1;:28:::0;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;49532:14;;;::::1;::::0;49523:6:::1;:23:::0;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;;;49586:13;;49559:24:::1;:40:::0;49637:13;;::::1;::::0;49610:24:::1;:40:::0;49677:13;::::1;::::0;49661::::1;:29:::0;49703:15:::1;:60:::0;;;;::::1;49721:42;49703:60;::::0;;;49898:118:::1;::::0;49916:6:::1;48456:42;-1:-1:-1::0;;49898:37:0::1;:118::i;:::-;50027:116;48329:42;48456;-1:-1:-1::0;;50027:35:0::1;:116::i;:::-;50225:15;::::0;50207:4:::1;::::0;50189:71:::1;::::0;-1:-1:-1;;;;;50207:4:0;;::::1;::::0;50225:15:::1;-1:-1:-1::0;;50189:35:0::1;:71::i;:::-;22902:14:::0;22898:68;;;22949:5;22933:21;;-1:-1:-1;;22933:21:0;;;22898:68;48973:1295;;;;;;;;:::o;36194:121::-;36244:7;36271:36;36291:15;:13;:15::i;:::-;36271;:13;:15::i;:::-;:19;;:36::i;32814:108::-;32870:17;:15;:17::i;:::-;32898:6;:16;;-1:-1:-1;;;;;;32898:16:0;-1:-1:-1;;;;;32898:16:0;;;;;;;;;;32814:108::o;52166:88::-;52242:4;52166:88;:::o;40970:::-;41007:24;:22;:24::i;:::-;41042:8;:6;:8::i;37216:341::-;37322:17;:15;:17::i;:::-;34407:5;37372:25;:36;;37350:136;;;;-1:-1:-1;;;37350:136:0;;;;;;;:::i;:::-;37497:24;:52;37216:341::o;38437:263::-;26558:7;;38536:15;;26558:7;;26557:8;26549:37;;;;-1:-1:-1;;;26549:37:0;;;;;;;:::i;:::-;38569:17:::1;:15;:17::i;:::-;38599:14;:12;:14::i;:::-;38661:4;::::0;38643:48:::1;::::0;-1:-1:-1;;;38643:48:0;;38626:66:::1;::::0;-1:-1:-1;;;;;38661:4:0::1;::::0;38643:33:::1;::::0;:48:::1;::::0;38685:4:::1;::::0;38643:48:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;36475:116::-:0;36535:17;:15;:17::i;:::-;36563:8;:20;;-1:-1:-1;;;;;;36563:20:0;-1:-1:-1;;;;;36563:20:0;;;;;;;;;;36475:116::o;34336:28::-;;;;:::o;37565:124::-;37629:17;:15;:17::i;:::-;37657:10;:24;;-1:-1:-1;;;;;;37657:24:0;-1:-1:-1;;;;;37657:24:0;;;;;;;;;;37565:124::o;48380:119::-;48456:42;48380:119;:::o;50406:827::-;50481:17;:15;:17::i;:::-;-1:-1:-1;;;;;50519:31:0;;50511:40;;;;;;50568:15;;-1:-1:-1;;;;;50568:15:0;:29;50564:259;;50636:1;50618:15;:13;:15::i;:::-;:19;50614:128;;;50712:14;:12;:14::i;:::-;50792:15;;50774:4;;50756:55;;-1:-1:-1;;;;;50774:4:0;;;;50792:15;;50756:35;:55::i;:::-;50871:15;:35;;-1:-1:-1;;;;;;50871:35:0;-1:-1:-1;;;;;50871:35:0;;;;;;;;;;;50986:4;;50968:71;;50986:4;;;;51004:15;-1:-1:-1;;50968:35:0;:71::i;:::-;51052:21;51076:15;:13;:15::i;:::-;51052:39;-1:-1:-1;51106:17:0;;51102:124;;51191:23;51200:13;51191:8;:23::i;:::-;50406:827;;:::o;33031:122::-;33093:17;:15;:17::i;:::-;33121:10;:24;;-1:-1:-1;;;;;;33121:24:0;-1:-1:-1;;;;;33121:24:0;;;;;;;;;;33031:122::o;36599:260::-;36669:17;:15;:17::i;:::-;34407:5;36719:14;:25;;36697:113;;;;-1:-1:-1;;;36697:113:0;;;;;;;:::i;:::-;36821:13;:30;36599:260::o;31862:21::-;;;-1:-1:-1;;;;;31862:21:0;;:::o;48298:73::-;48329:42;48298:73;:::o;34373:39::-;34407:5;34373:39;:::o;35938:129::-;36029:4;;36011:48;;-1:-1:-1;;;36011:48:0;;35984:7;;-1:-1:-1;;;;;36029:4:0;;36011:33;;:48;;36053:4;;36011:48;;;:::i;32585:124::-;32649:17;:15;:17::i;:::-;32677:10;:24;;-1:-1:-1;;;;;;32677:24:0;-1:-1:-1;;;;;32677:24:0;;;;;;;;;;32585:124::o;37998:269::-;26558:7;;;;26557:8;26549:37;;;;-1:-1:-1;;;26549:37:0;;;;;;;:::i;:::-;38057:35:::1;:33;:35::i;:::-;38137:4;::::0;38119:48:::1;::::0;-1:-1:-1;;;38119:48:0;;38103:13:::1;::::0;-1:-1:-1;;;;;38137:4:0::1;::::0;38119:33:::1;::::0;:48:::1;::::0;38161:4:::1;::::0;38119:48:::1;;;:::i;:::-;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;38103:64:::0;-1:-1:-1;38182:9:0;;38178:57:::1;;38208:15;38217:5;38208:8;:15::i;:::-;38245:14;:12;:14::i;37697:293::-:0;37781:17;:15;:17::i;:::-;34407:5;37831:10;:21;;37809:118;;;;-1:-1:-1;;;37809:118:0;;;;;;;:::i;:::-;37938:31;:44;37697:293::o;35765:98::-;35843:12;;;;;;;;;;;;-1:-1:-1;;;35843:12:0;;;;35765:98;:::o;48166:26::-;;;-1:-1:-1;;;;;48166:26:0;;:::o;52337:434::-;52502:16;;;52516:1;52502:16;;;;;;;;;52433;;;;52502;;;;;;;;;-1:-1:-1;;52550:4:0;;52529:18;;;;-1:-1:-1;;;;;;52550:4:0;;52529:18;;-1:-1:-1;52550:4:0;;52529:18;;;;-1:-1:-1;;;;;52529:25:0;;;:18;;;;;;;;;:25;52586:11;;52565:18;;52586:11;;;52565:15;;52586:11;;52565:18;;;;;;-1:-1:-1;;;;;52565:32:0;;;:18;;;;;;;;;:32;52629:6;;52608:18;;52629:6;;;52608:15;;52624:1;;52608:18;;;;;;;;;;;:27;-1:-1:-1;;;;;52608:27:0;;;-1:-1:-1;;;;;52608:27:0;;;;;48329:42;52646:15;52662:1;52646:18;;;;;;;;-1:-1:-1;;;;;52646:25:0;;;:18;;;;;;;;;;;:25;52748:15;-1:-1:-1;52337:434:0;:::o;48587:30::-;;;-1:-1:-1;;;;;48587:30:0;;:::o;36867:341::-;36973:17;:15;:17::i;:::-;34407:5;37023:25;:36;;37001:136;;;;-1:-1:-1;;;37001:136:0;;;;;;;:::i;:::-;37148:24;:52;36867:341::o;34528:25::-;;;-1:-1:-1;;;;;34528:25:0;;:::o;34592:46::-;;;;:::o;35146:111::-;35220:10;;-1:-1:-1;;;;;35220:10:0;35206;:24;35198:51;;;;-1:-1:-1;;;35198:51:0;;;;;;;:::i;52932:350::-;53010:32;53045:20;:18;:20::i;:::-;53010:55;;53083:9;53078:197;53102:15;:22;53098:1;:26;53078:197;;;53203:6;-1:-1:-1;;;;;53172:37:0;53180:15;53196:1;53180:18;;;;;;;;;;;;;;-1:-1:-1;;;;;53172:37:0;;;53146:117;;;;-1:-1:-1;;;53146:117:0;;;;;;;:::i;:::-;53126:3;;53078:197;;;;52932:350;;:::o;16679:259::-;16807:123;16841:5;16884:23;;;16909:2;16913:5;16861:58;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;16861:58:0;;;;;;;;;;;;;;-1:-1:-1;;;;;16861:58:0;-1:-1:-1;;;;;;16861:58:0;;;;;;;;;;16807:19;:123::i;54823:868::-;54917:7;55071:19;55093:15;:13;:15::i;:::-;55071:37;;55139:7;55125:11;:21;55121:498;;;55163:18;55184:28;55196:15;:13;:15::i;:::-;55184:7;;:11;:28::i;:::-;55163:49;;55229:19;55251:15;:13;:15::i;:::-;55229:37;;55299:10;55285:11;:24;55281:327;;;55363:15;;55330:111;;-1:-1:-1;;;55330:111:0;;-1:-1:-1;;;;;55363:15:0;;;;55330:58;;:111;;55411:11;;55330:111;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55281:327;;;55515:15;;55482:110;;-1:-1:-1;;;55482:110:0;;-1:-1:-1;;;;;55515:15:0;;;;55482:58;;:110;;55563:10;;55482:110;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55281:327;55121:498;;;55638:45;55658:7;55667:15;:13;:15::i;:::-;55638:19;:45::i;:::-;55631:52;54823:868;-1:-1:-1;;;54823:868:0:o;44949:178::-;45009:7;45042:1;45037;:6;;45029:64;;;;-1:-1:-1;;;45029:64:0;;;;;;;:::i;:::-;45111:8;:1;45117;45111:5;:8::i;:::-;45104:15;;44949:178;;;;;:::o;5398:471::-;5456:7;5701:6;5697:47;;-1:-1:-1;5731:1:0;5724:8;;5697:47;5768:5;;;5772:1;5768;:5;:1;5792:5;;;;;:10;5784:56;;;;-1:-1:-1;;;5784:56:0;;;;;;;:::i;6345:132::-;6403:7;6430:39;6434:1;6437;6430:39;;;;;;;;;;;;;;;;;:3;:39::i;9036:106::-;9094:7;9125:1;9121;:5;:13;;9133:1;9121:13;;;-1:-1:-1;9129:1:0;;9036:106;-1:-1:-1;9036:106:0:o;41388:363::-;41454:7;41478:13;;41495:1;41478:18;41474:59;;;-1:-1:-1;41520:1:0;41513:8;;41474:59;41545:11;41559:39;34407:5;41559:26;41571:13;;41559:7;:11;;:26;;;;:::i;:39::-;41545:53;;41609:113;41672:10;;;;;;;;;-1:-1:-1;;;;;41672:10:0;-1:-1:-1;;;;;41660:31:0;;:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;41627:4;;-1:-1:-1;;;;;41627:4:0;;41708:3;41609:36;:113::i;4474:136::-;4532:7;4559:43;4563:1;4566;4559:43;;;;;;;;;;;;;;;;;:3;:43::i;42669:299::-;42761:10;;42788:4;;42749:45;;-1:-1:-1;;;42749:45:0;;42732:14;;-1:-1:-1;;;;;42761:10:0;;;;42749:30;;:45;;42788:4;;;;42749:45;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;42732:62;-1:-1:-1;;;;;;42813:20:0;;42805:39;;;;-1:-1:-1;;;42805:39:0;;;;;;;:::i;:::-;42925:4;;42907:53;;-1:-1:-1;;;;;42925:4:0;42944:6;42952:7;42907:36;:53::i;23066:626::-;23508:4;23632:17;23677:7;23066:626;:::o;25909:131::-;22587:13;;;;;;;;:33;;;22604:16;:14;:16::i;:::-;22587:50;;;-1:-1:-1;22625:12:0;;;;22624:13;22587:50;22565:146;;;;-1:-1:-1;;;22565:146:0;;;;;;;:::i;:::-;22724:19;22747:13;;;;;;22746:14;22771:101;;;;22806:13;:20;;-1:-1:-1;;;;22806:20:0;;;;;22841:19;22822:4;22841:19;;;22771:101;25968:26:::1;:24;:26::i;:::-;26005:27;:25;:27::i;:::-;22902:14:::0;22898:68;;;22949:5;22933:21;;-1:-1:-1;;22933:21:0;;;25909:131;:::o;31922:111::-;31996:10;;-1:-1:-1;;;;;31996:10:0;31982;:24;31974:51;;;;-1:-1:-1;;;31974:51:0;;;;;;;:::i;27289:120::-;26834:7;;;;26826:40;;;;-1:-1:-1;;;26826:40:0;;;;;;;:::i;:::-;27348:7:::1;:15:::0;;-1:-1:-1;;27348:15:0::1;::::0;;27379:22:::1;27388:12;:10;:12::i;:::-;27379:22;;;;;;:::i;:::-;;;;;;;;27289:120::o:0;32249:184::-;32343:6;;-1:-1:-1;;;;;32343:6:0;32329:10;:20;;:48;;-1:-1:-1;32367:10:0;;-1:-1:-1;;;;;32367:10:0;32353;:24;32329:48;32307:118;;;;-1:-1:-1;;;32307:118:0;;;;;;;:::i;53496:228::-;53685:15;;53652:64;;-1:-1:-1;;;53652:64:0;;-1:-1:-1;;;;;53685:15:0;;;;53652:55;;:64;;53708:7;;53652:64;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53496:228;:::o;56758:867::-;56843:6;;56825:50;;-1:-1:-1;;;56825:50:0;;56808:14;;-1:-1:-1;;;;;56843:6:0;;56825:35;;:50;;56869:4;;56825:50;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;56808:67;-1:-1:-1;56892:11:0;56888:50;;56920:7;;;56888:50;56972:16;;;56986:1;56972:16;;;56948:21;56972:16;;;;;56948:21;56972:16;;;;;;;;-1:-1:-1;;57009:6:0;;56999:7;;;;-1:-1:-1;;;;;;57009:6:0;;56999:7;;-1:-1:-1;57009:6:0;;56999:7;;;;;;;;;:16;-1:-1:-1;;;;;56999:16:0;;;-1:-1:-1;;;;;56999:16:0;;;;;48329:42;57026:4;57031:1;57026:7;;;;;;;;-1:-1:-1;;;;;57026:14:0;;;:7;;;;;;;;;;;:14;48456:42;57089:39;57143:23;57162:3;57143:14;:6;57154:2;57143:10;:14::i;:23::-;57181:1;57197:4;57224;57244:3;57089:169;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;57089:169:0;;;;;;;;;;;;:::i;:::-;-1:-1:-1;57375:6:0;;57415:50;;-1:-1:-1;;;57415:50:0;;48456:42;;57333:27;;-1:-1:-1;;;;;57375:6:0;;;;48329:42;;57375:6;;57415:35;;:50;;57459:4;;57415:50;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57480:48;;-1:-1:-1;;;57480:48:0;;48329:42;;57480:33;;:48;;57522:4;;57480:48;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57543:1;57559;57583:4;57603:3;57333:284;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;58176:522::-;58274:28;58304;58373:152;58399:6;58420:7;58442:24;;58493:10;;;;;;;;;-1:-1:-1;;;;;58493:10:0;-1:-1:-1;;;;;58481:31:0;;:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;58373:11;:152::i;:::-;58630:24;;58669:10;;58350:175;;-1:-1:-1;58561:129:0;;58587:6;;58608:7;;-1:-1:-1;;;;;58669:10:0;58561:11;:129::i;:::-;58538:152;;58176:522;;;;;:::o;17511:718::-;17940:10;;;17939:62;;-1:-1:-1;17956:39:0;;-1:-1:-1;;;17956:39:0;;-1:-1:-1;;;;;17956:15:0;;;;;:39;;17980:4;;17987:7;;17956:39;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;17939:62;17917:166;;;;-1:-1:-1;;;17917:166:0;;;;;;;:::i;:::-;18094:127;18128:5;18171:22;;;18195:7;18204:5;18148:62;;;;;;;;;:::i;4010:181::-;4068:7;4100:5;;;4124:6;;;;4116:46;;;;-1:-1:-1;;;4116:46:0;;;;;;;:::i;35543:178::-;35638:8;;-1:-1:-1;;;;;35638:8:0;35624:10;:22;;:50;;-1:-1:-1;35664:10:0;;-1:-1:-1;;;;;35664:10:0;35650;:24;35624:50;35602:111;;;;-1:-1:-1;;;35602:111:0;;;;;;;:::i;27030:118::-;26558:7;;;;26557:8;26549:37;;;;-1:-1:-1;;;26549:37:0;;;;;;;:::i;:::-;27090:7:::1;:14:::0;;-1:-1:-1;;27090:14:0::1;27100:4;27090:14;::::0;;27120:20:::1;27127:12;:10;:12::i;53800:877::-:0;53951:15;;54020:48;;-1:-1:-1;;;54020:48:0;;-1:-1:-1;;;;;53951:15:0;;;;53980:24;;53951:15;;54020:33;;:48;;54062:4;;54020:48;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;54020:48:0;;;;;;;;;;;;:::i;:::-;53980:88;;54084:9;54079:432;54099:7;:14;54095:1;:18;54079:432;;;54152:1;54139:7;54147:1;54139:10;;;;;;;;;;;;;;:14;54135:365;;;54227:36;;-1:-1:-1;;;54227:36:0;;-1:-1:-1;;;;;54227:21:0;;;;;:36;;54257:4;;54227:36;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;54323:25:0;;-1:-1:-1;;;54323:25:0;;;;54319:141;;-1:-1:-1;54319:141:0;;-1:-1:-1;54319:141:0;54420:20;:18;:20::i;:::-;54478:7;;;;;54135:365;54115:3;;54079:432;;;-1:-1:-1;54612:46:0;;-1:-1:-1;;;54612:46:0;;-1:-1:-1;;;;;54572:25:0;;;;;;;54612:31;;:46;;54652:4;;54612:46;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54572:97;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35265:270;35371:6;;-1:-1:-1;;;;;35371:6:0;35357:10;:20;;:65;;-1:-1:-1;35412:10:0;;-1:-1:-1;;;;;35412:10:0;35398;:24;35357:65;:110;;;-1:-1:-1;35457:10:0;;-1:-1:-1;;;;;35457:10:0;35443;:24;35357:110;35335:192;;;;-1:-1:-1;;;35335:192:0;;;;;;;:::i;19624:910::-;20073:23;20112:118;20158:4;20112:118;;;;;;;;;;;;;;;;;20120:5;-1:-1:-1;;;;;20112:27:0;;;:118;;;;;:::i;:::-;20245:17;;20073:157;;-1:-1:-1;20245:21:0;20241:286;;20418:10;20407:30;;;;;;;;;;;;:::i;:::-;20381:134;;;;-1:-1:-1;;;20381:134:0;;;;;;;:::i;6973:312::-;7093:7;7128:12;7121:5;7113:28;;;;-1:-1:-1;;;7113:28:0;;;;;;;;:::i;:::-;;7152:9;7168:1;7164;:5;;;;;;;6973:312;-1:-1:-1;;;;;6973:312:0:o;4913:226::-;5033:7;5069:12;5061:6;;;;5053:29;;;;-1:-1:-1;;;5053:29:0;;;;;;;;:::i;:::-;-1:-1:-1;;;5105:5:0;;;4913:226::o;24478:59::-;22587:13;;;;;;;;:33;;;22604:16;:14;:16::i;:::-;22587:50;;;-1:-1:-1;22625:12:0;;;;22624:13;22587:50;22565:146;;;;-1:-1:-1;;;22565:146:0;;;;;;;:::i;:::-;22724:19;22747:13;;;;;;22746:14;22771:101;;;;22806:13;:20;;-1:-1:-1;;;;22806:20:0;;;;;22841:19;22822:4;22841:19;;;22902:14;22898:68;;;22949:5;22933:21;;-1:-1:-1;;22933:21:0;;;24478:59;:::o;26048:92::-;22587:13;;;;;;;;:33;;;22604:16;:14;:16::i;:::-;22587:50;;;-1:-1:-1;22625:12:0;;;;22624:13;22587:50;22565:146;;;;-1:-1:-1;;;22565:146:0;;;;;;;:::i;:::-;22724:19;22747:13;;;;;;22746:14;22771:101;;;;22806:13;:20;;-1:-1:-1;;;;22806:20:0;;;;;22841:19;22822:4;22841:19;;;22771:101;26117:7:::1;:15:::0;;-1:-1:-1;;26117:15:0::1;::::0;;22898:68;;;;22949:5;22933:21;;-1:-1:-1;;22933:21:0;;;26048:92;:::o;24545:106::-;24633:10;24545:106;:::o;41975:368::-;42123:7;42147:11;42143:52;;-1:-1:-1;42182:1:0;42175:8;;42143:52;42205:11;42219:31;34407:5;42219:18;:6;42230;42219:10;:18::i;:31::-;42205:45;-1:-1:-1;42261:53:0;-1:-1:-1;;;;;42261:37:0;;42299:9;42205:45;42261:37;:53::i;:::-;42332:3;-1:-1:-1;41975:368:0;;;;;;;:::o;13304:230::-;13441:12;13473:53;13496:6;13504:4;13510:1;13513:12;15098;15131:18;15142:6;15131:10;:18::i;:::-;15123:60;;;;-1:-1:-1;;;15123:60:0;;;;;;;:::i;:::-;15257:12;15271:23;15311:6;-1:-1:-1;;;;;15311:11:0;15330:8;15340:4;15311:34;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;15256:89;;;;15360:7;15356:595;;;15391:10;-1:-1:-1;15384:17:0;;-1:-1:-1;15384:17:0;15356:595;15505:17;;:21;15501:439;;15768:10;15762:17;15829:15;15816:10;15812:2;15808:19;15801:44;15716:148;15911:12;15904:20;;-1:-1:-1;;;15904:20:0;;;;;;;;:::i;10267:444::-;10647:20;10695:8;;;10267:444::o;945:616:-1:-;;1060:3;1053:4;1045:6;1041:17;1037:27;1027:2;;-1:-1;;1068:12;1027:2;1121:78;31372:17;1121:78;:::i;:::-;1112:87;;1205:16;1264:17;1322:3;31372:17;1297:3;1293:27;1290:36;1287:2;;;1339:1;;1329:12;1287:2;1364:1;1349:206;1102:4;1371:1;1368:13;1349:206;;;2650:20;;1442:50;;31384:4;1506:14;;;;1534;;;;1396:1;1389:9;1349:206;;;1353:14;;;1020:541;;;;:::o;2861:241::-;;2965:2;2953:9;2944:7;2940:23;2936:32;2933:2;;;-1:-1;;2971:12;2933:2;85:6;72:20;97:33;124:5;97:33;:::i;3109:263::-;;3224:2;3212:9;3203:7;3199:23;3195:32;3192:2;;;-1:-1;;3230:12;3192:2;226:6;220:13;238:33;265:5;238:33;:::i;3379:743::-;;;;;;3551:3;3539:9;3530:7;3526:23;3522:33;3519:2;;;-1:-1;;3558:12;3519:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;3610:63;-1:-1;3710:2;3749:22;;72:20;97:33;72:20;97:33;:::i;:::-;3718:63;-1:-1;3818:2;3857:22;;72:20;97:33;72:20;97:33;:::i;:::-;3826:63;-1:-1;3926:2;3965:22;;72:20;97:33;72:20;97:33;:::i;:::-;3934:63;-1:-1;4034:3;4074:22;;72:20;97:33;72:20;97:33;:::i;:::-;4043:63;;;;3513:609;;;;;;;;:::o;4129:1087::-;;;;;;;;4381:3;4369:9;4360:7;4356:23;4352:33;4349:2;;;-1:-1;;4388:12;4349:2;85:6;72:20;97:33;124:5;97:33;:::i;:::-;4440:63;-1:-1;4540:2;4579:22;;;72:20;97:33;72:20;97:33;:::i;:::-;4548:63;-1:-1;4648:2;4687:22;;72:20;97:33;72:20;97:33;:::i;:::-;4656:63;-1:-1;4756:2;4795:22;;72:20;97:33;72:20;97:33;:::i;:::-;4764:63;-1:-1;4864:3;4904:22;;72:20;97:33;72:20;97:33;:::i;:::-;4873:63;-1:-1;398:17;;;394:27;-1:-1;384:2;;-1:-1;;425:12;384:2;478:78;4756:2;478:78;:::i;:::-;562:16;4973:3;5040:9;5036:22;650:27;5040:9;650:27;679:3;650:27;647:36;644:2;;;-1:-1;;686:12;644:2;-1:-1;706:206;459:4;728:1;725:13;706:206;;;85:6;72:20;97:33;124:5;97:33;:::i;:::-;799:50;;863:14;;;;891;;;;753:1;746:9;706:206;;;710:14;4982:86;;;5124:76;5192:7;5168:22;5124:76;:::i;:::-;5114:86;;;;;;;4343:873;;;;;;;;;;:::o;5223:392::-;;5363:2;;5351:9;5342:7;5338:23;5334:32;5331:2;;;-1:-1;;5369:12;5331:2;5420:17;5414:24;5458:18;5450:6;5447:30;5444:2;;;-1:-1;;5480:12;5444:2;5567:22;;1708:4;1696:17;;1692:27;-1:-1;1682:2;;-1:-1;;1723:12;1682:2;1763:6;1757:13;1785:80;1800:64;1857:6;1800:64;:::i;:::-;1785:80;:::i;:::-;1893:21;;;1950:14;;;;1925:17;;;2039;;;2030:27;;;;2027:36;-1:-1;2024:2;;;-1:-1;;2066:12;2024:2;-1:-1;2092:10;;2086:217;2111:6;2108:1;2105:13;2086:217;;;2798:13;;2179:61;;2133:1;2126:9;;;;;2254:14;;;;2282;;2086:217;;;-1:-1;5500:99;5325:290;-1:-1;;;;;;;5325:290::o;5622:235::-;;5723:2;5711:9;5702:7;5698:23;5694:32;5691:2;;;-1:-1;;5729:12;5691:2;2394:6;2381:20;2406:30;2430:5;2406:30;:::i;5864:257::-;;5976:2;5964:9;5955:7;5951:23;5947:32;5944:2;;;-1:-1;;5982:12;5944:2;2529:6;2523:13;2541:30;2565:5;2541:30;:::i;6128:241::-;;6232:2;6220:9;6211:7;6207:23;6203:32;6200:2;;;-1:-1;;6238:12;6200:2;-1:-1;2650:20;;6194:175;-1:-1;6194:175::o;6376:263::-;;6491:2;6479:9;6470:7;6466:23;6462:32;6459:2;;;-1:-1;;6497:12;6459:2;-1:-1;2798:13;;6453:186;-1:-1;6453:186::o;6646:535::-;;;;6795:2;6783:9;6774:7;6770:23;6766:32;6763:2;;;-1:-1;;6801:12;6763:2;2804:6;2798:13;6853:74;;6964:2;7018:9;7014:22;2798:13;6972:74;;7083:2;7137:9;7133:22;2798:13;7091:74;;6757:424;;;;;:::o;7780:690::-;;7973:5;32234:12;32778:6;32773:3;32766:19;32815:4;;32810:3;32806:14;7985:93;;32815:4;8149:5;32088:14;-1:-1;8188:260;8213:6;8210:1;8207:13;8188:260;;;8274:13;;-1:-1;;;;;33411:54;7580:37;;7342:14;;;;32621;;;;5458:18;8228:9;8188:260;;;-1:-1;8454:10;;7904:566;-1:-1;;;;;7904:566::o;17281:271::-;;8749:5;32234:12;8860:52;8905:6;8900:3;8893:4;8886:5;8882:16;8860:52;:::i;:::-;8924:16;;;;;17415:137;-1:-1;;17415:137::o;17559:222::-;-1:-1;;;;;33411:54;;;;7580:37;;17686:2;17671:18;;17657:124::o;18033:333::-;-1:-1;;;;;33411:54;;;7580:37;;33411:54;;18352:2;18337:18;;7580:37;18188:2;18173:18;;18159:207::o;18373:1036::-;-1:-1;;;;;33411:54;;;7580:37;;33411:54;;;18877:2;18862:18;;7580:37;18960:2;18945:18;;17232:37;;;;19043:2;19028:18;;17232:37;;;;19134:3;19119:19;;9214:58;;;;33422:42;19211:19;;9214:58;33411:54;;;19310:3;19295:19;;7580:37;19394:3;19379:19;;17232:37;;;;18712:3;18697:19;;18683:726::o;19416:333::-;-1:-1;;;;;33411:54;;;;7580:37;;19735:2;19720:18;;17232:37;19571:2;19556:18;;19542:207::o;19756:370::-;;19933:2;19954:17;19947:47;20008:108;19933:2;19922:9;19918:18;20102:6;20008:108;:::i;20133:210::-;33323:13;;33316:21;8543:34;;20254:2;20239:18;;20225:118::o;20629:310::-;;20776:2;20797:17;20790:47;9429:5;32234:12;32778:6;20776:2;20765:9;20761:18;32766:19;9523:52;9568:6;32806:14;20765:9;32806:14;20776:2;9549:5;9545:16;9523:52;:::i;:::-;34737:7;34721:14;-1:-1;;34717:28;9587:39;;;;32806:14;9587:39;;20747:192;-1:-1;;20747:192::o;20946:416::-;21146:2;21160:47;;;9863:2;21131:18;;;32766:19;-1:-1;;;32806:14;;;9879:43;9941:12;;;21117:245::o;21369:416::-;21569:2;21583:47;;;10192:2;21554:18;;;32766:19;10228:34;32806:14;;;10208:55;-1:-1;;;10283:12;;;10276:45;10340:12;;;21540:245::o;21792:416::-;21992:2;22006:47;;;10591:2;21977:18;;;32766:19;-1:-1;;;32806:14;;;10607:43;10669:12;;;21963:245::o;22215:416::-;22415:2;22429:47;;;10920:2;22400:18;;;32766:19;10956:34;32806:14;;;10936:55;-1:-1;;;11011:12;;;11004:37;11060:12;;;22386:245::o;22638:416::-;22838:2;22852:47;;;11311:2;22823:18;;;32766:19;11347:29;32806:14;;;11327:50;11396:12;;;22809:245::o;23061:416::-;23261:2;23275:47;;;11647:2;23246:18;;;32766:19;-1:-1;;;32806:14;;;11663:37;11719:12;;;23232:245::o;23484:416::-;23684:2;23698:47;;;23669:18;;;32766:19;12006:34;32806:14;;;11986:55;12060:12;;;23655:245::o;23907:416::-;24107:2;24121:47;;;12311:2;24092:18;;;32766:19;12347:34;32806:14;;;12327:55;-1:-1;;;12402:12;;;12395:42;12456:12;;;24078:245::o;24330:416::-;24530:2;24544:47;;;12707:2;24515:18;;;32766:19;12743:34;32806:14;;;12723:55;-1:-1;;;12798:12;;;12791:30;12840:12;;;24501:245::o;24753:416::-;24953:2;24967:47;;;13091:2;24938:18;;;32766:19;-1:-1;;;32806:14;;;13107:39;13165:12;;;24924:245::o;25176:416::-;25376:2;25390:47;;;13416:2;25361:18;;;32766:19;13452:34;32806:14;;;13432:55;-1:-1;;;13507:12;;;13500:38;13557:12;;;25347:245::o;25599:416::-;25799:2;25813:47;;;13808:2;25784:18;;;32766:19;-1:-1;;;32806:14;;;13824:41;13884:12;;;25770:245::o;26022:416::-;26222:2;26236:47;;;14135:2;26207:18;;;32766:19;14171:34;32806:14;;;14151:55;-1:-1;;;14226:12;;;14219:25;14263:12;;;26193:245::o;26445:416::-;26645:2;26659:47;;;14514:1;26630:18;;;32766:19;-1:-1;;;32806:14;;;14529:29;14577:12;;;26616:245::o;26868:416::-;27068:2;27082:47;;;14828:2;27053:18;;;32766:19;14864:34;32806:14;;;14844:55;-1:-1;;;14919:12;;;14912:39;14970:12;;;27039:245::o;27291:416::-;27491:2;27505:47;;;15221:2;27476:18;;;32766:19;-1:-1;;;32806:14;;;15237:34;15290:12;;;27462:245::o;27714:416::-;27914:2;27928:47;;;15541:2;27899:18;;;32766:19;15577:34;32806:14;;;15557:55;-1:-1;;;15632:12;;;15625:42;15686:12;;;27885:245::o;28137:416::-;28337:2;28351:47;;;15937:2;28322:18;;;32766:19;15973:31;32806:14;;;15953:52;16024:12;;;28308:245::o;28560:416::-;28760:2;28774:47;;;16275:2;28745:18;;;32766:19;16311:34;32806:14;;;16291:55;-1:-1;;;16366:12;;;16359:34;16412:12;;;28731:245::o;28983:416::-;29183:2;29197:47;;;16663:2;29168:18;;;32766:19;-1:-1;;;32806:14;;;16679:37;16735:12;;;29154:245::o;29406:416::-;29606:2;29620:47;;;16986:2;29591:18;;;32766:19;17022:34;32806:14;;;17002:55;-1:-1;;;17077:12;;;17070:46;17135:12;;;29577:245::o;29829:222::-;17232:37;;;29956:2;29941:18;;29927:124::o;30058:832::-;;17262:5;17239:3;17232:37;34097:24;30528:2;30517:9;30513:18;9214:58;30355:3;30565:2;30554:9;30550:18;30543:48;30605:108;30355:3;30344:9;30340:19;30699:6;30605:108;:::i;:::-;-1:-1;;;;;33411:54;;;;30792:2;30777:18;;7580:37;-1:-1;30875:3;30860:19;17232:37;30597:116;30326:564;-1:-1;;;30326:564::o;30897:256::-;30959:2;30953:9;30985:17;;;31060:18;31045:34;;31081:22;;;31042:62;31039:2;;;31117:1;;31107:12;31039:2;30959;31126:22;30937:216;;-1:-1;30937:216::o;31662:304::-;;31821:18;31813:6;31810:30;31807:2;;;-1:-1;;31843:12;31807:2;-1:-1;31888:4;31876:17;;;31941:15;;31744:222::o;34377:268::-;34442:1;34449:101;34463:6;34460:1;34457:13;34449:101;;;34530:11;;;34524:18;34511:11;;;34504:39;34485:2;34478:10;34449:101;;;34565:6;34562:1;34559:13;34556:2;;;-1:-1;;34442:1;34612:16;;34605:27;34426:219::o;34758:117::-;-1:-1;;;;;33411:54;;34817:35;;34807:2;;34866:1;;34856:12;34882:111;34963:5;33323:13;33316:21;34941:5;34938:32;34928:2;;34984:1;;34974:12

ipfs://186122bfc2952d2d17bb2ab7f7546dc21255323f6e029118944b34db80132de7