Contract

0xc3a4fdcba79DB04b4C3e352b1C467B3Ba909D84A

Source Code

Overview

S Balance

0 S

S Value

$0.00

More Info

Private Name Tags

Add

ContractCreator

0x982F264c...593A515ad at txn 0x5e82a5820c51fed0ab8c95108827fe1ece808b34df08727f63c9b3f6d5369343

Multichain Info

$10.34 (Multichain Portfolio)

	Transaction Hash	Method	Block		From		To
There are no matching entries Please try again later

Parent Transaction Hash	Block		From		To

View All Internal Transactions

Contract Source Code Verified (Exact Match)

Contract Name:

StrategyIchi

Compiler Version

v0.8.23+commit.f704f362

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at SonicScan.org on 2025-01-17
*/

// SPDX-License-Identifier: MIT
// File: contracts/BIFI/strategies/Ichi/Ichi.sol


pragma solidity ^0.8.0;

interface IchiVault {
    function token0() external view returns (address);
    function token1() external view returns (address);
    function deposit(uint deposit0, uint deposit1, address to) external returns (uint shares);
}

// File: contracts/BIFI/interfaces/common/IRewardPool.sol


pragma solidity >=0.6.0 <0.9.0;

interface IRewardPool {
    function deposit(uint256 amount) external;
    function stake(uint256 amount) external;
    function withdraw(uint256 amount) external;
    function earned(address account) external view returns (uint256);
    function getReward() external;
    function getReward(address account) external;
    function getRewards() external;
    function collectReward() external;
    function balanceOf(address account) external view returns (uint256);
    function stakingToken() external view returns (address);
    function rewardsToken() external view returns (address);
    function emergency() external view returns (bool);
    function emergencyWithdraw() external;
}

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

// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @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
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 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://consensys.net/diligence/blog/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.8.0/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");

        (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 functionCallWithValue(target, data, 0, "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");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and revert (either by bubbling
     * the revert reason or using the provided one) in case of unsuccessful call or if target was not a contract.
     *
     * _Available since v4.8._
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        if (success) {
            if (returndata.length == 0) {
                // only check isContract if the call was successful and the return data is empty
                // otherwise we already know that it was a contract
                require(isContract(target), "Address: call to non-contract");
            }
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason or using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            _revert(returndata, errorMessage);
        }
    }

    function _revert(bytes memory returndata, string memory errorMessage) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert(errorMessage);
        }
    }
}

// File: @openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol

// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)

pragma solidity ^0.8.2;

/**
 * @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 proxied contracts do not make use of 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.
 *
 * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
 * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
 * case an upgrade adds a module that needs to be initialized.
 *
 * For example:
 *
 * [.hljs-theme-light.nopadding]
 * ```solidity
 * contract MyToken is ERC20Upgradeable {
 *     function initialize() initializer public {
 *         __ERC20_init("MyToken", "MTK");
 *     }
 * }
 *
 * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
 *     function initializeV2() reinitializer(2) public {
 *         __ERC20Permit_init("MyToken");
 *     }
 * }
 * ```
 *
 * 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 {ERC1967Proxy-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.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
 * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() {
 *     _disableInitializers();
 * }
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     * @custom:oz-retyped-from bool
     */
    uint8 private _initialized;

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

    /**
     * @dev Triggered when the contract has been initialized or reinitialized.
     */
    event Initialized(uint8 version);

    /**
     * @dev A modifier that defines a protected initializer function that can be invoked at most once. In its scope,
     * `onlyInitializing` functions can be used to initialize parent contracts.
     *
     * Similar to `reinitializer(1)`, except that functions marked with `initializer` can be nested in the context of a
     * constructor.
     *
     * Emits an {Initialized} event.
     */
    modifier initializer() {
        bool isTopLevelCall = !_initializing;
        require(
            (isTopLevelCall && _initialized < 1) || (!AddressUpgradeable.isContract(address(this)) && _initialized == 1),
            "Initializable: contract is already initialized"
        );
        _initialized = 1;
        if (isTopLevelCall) {
            _initializing = true;
        }
        _;
        if (isTopLevelCall) {
            _initializing = false;
            emit Initialized(1);
        }
    }

    /**
     * @dev A modifier that defines a protected reinitializer function that can be invoked at most once, and only if the
     * contract hasn't been initialized to a greater version before. In its scope, `onlyInitializing` functions can be
     * used to initialize parent contracts.
     *
     * A reinitializer may be used after the original initialization step. This is essential to configure modules that
     * are added through upgrades and that require initialization.
     *
     * When `version` is 1, this modifier is similar to `initializer`, except that functions marked with `reinitializer`
     * cannot be nested. If one is invoked in the context of another, execution will revert.
     *
     * Note that versions can jump in increments greater than 1; this implies that if multiple reinitializers coexist in
     * a contract, executing them in the right order is up to the developer or operator.
     *
     * WARNING: setting the version to 255 will prevent any future reinitialization.
     *
     * Emits an {Initialized} event.
     */
    modifier reinitializer(uint8 version) {
        require(!_initializing && _initialized < version, "Initializable: contract is already initialized");
        _initialized = version;
        _initializing = true;
        _;
        _initializing = false;
        emit Initialized(version);
    }

    /**
     * @dev Modifier to protect an initialization function so that it can only be invoked by functions with the
     * {initializer} and {reinitializer} modifiers, directly or indirectly.
     */
    modifier onlyInitializing() {
        require(_initializing, "Initializable: contract is not initializing");
        _;
    }

    /**
     * @dev Locks the contract, preventing any future reinitialization. This cannot be part of an initializer call.
     * Calling this in the constructor of a contract will prevent that contract from being initialized or reinitialized
     * to any version. It is recommended to use this to lock implementation contracts that are designed to be called
     * through proxies.
     *
     * Emits an {Initialized} event the first time it is successfully executed.
     */
    function _disableInitializers() internal virtual {
        require(!_initializing, "Initializable: contract is initializing");
        if (_initialized != type(uint8).max) {
            _initialized = type(uint8).max;
            emit Initialized(type(uint8).max);
        }
    }

    /**
     * @dev Returns the highest version that has been initialized. See {reinitializer}.
     */
    function _getInitializedVersion() internal view returns (uint8) {
        return _initialized;
    }

    /**
     * @dev Returns `true` if the contract is currently initializing. See {onlyInitializing}.
     */
    function _isInitializing() internal view returns (bool) {
        return _initializing;
    }
}

// File: @openzeppelin/contracts-upgradeable/utils/ContextUpgradeable.sol

// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with 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 onlyInitializing {
    }

    function __Context_init_unchained() internal onlyInitializing {
    }
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[50] private __gap;
}

// File: @openzeppelin/contracts-upgradeable/access/OwnableUpgradeable.sol

// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;


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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    function __Ownable_init() internal onlyInitializing {
        __Ownable_init_unchained();
    }

    function __Ownable_init_unchained() internal onlyInitializing {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
    }

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

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[49] private __gap;
}

// File: @openzeppelin/contracts-upgradeable/security/PausableUpgradeable.sol

// OpenZeppelin Contracts (last updated v4.7.0) (security/Pausable.sol)

pragma solidity ^0.8.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.
 */
abstract 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 onlyInitializing {
        __Pausable_init_unchained();
    }

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

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

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

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

    /**
     * @dev Throws if the contract is paused.
     */
    function _requireNotPaused() internal view virtual {
        require(!paused(), "Pausable: paused");
    }

    /**
     * @dev Throws if the contract is not paused.
     */
    function _requirePaused() internal view virtual {
        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());
    }

    /**
     * @dev This empty reserved space is put in place to allow future versions to add new
     * variables without shifting down storage in the inheritance chain.
     * See https://docs.openzeppelin.com/contracts/4.x/upgradeable#storage_gaps
     */
    uint256[49] private __gap;
}

// File: @openzeppelin-5/contracts/token/ERC20/IERC20.sol

// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

    /**
     * @dev Returns the value of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

// File: @openzeppelin-5/contracts/token/ERC20/extensions/IERC20Permit.sol

// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/extensions/IERC20Permit.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 *
 * ==== Security Considerations
 *
 * There are two important considerations concerning the use of `permit`. The first is that a valid permit signature
 * expresses an allowance, and it should not be assumed to convey additional meaning. In particular, it should not be
 * considered as an intention to spend the allowance in any specific way. The second is that because permits have
 * built-in replay protection and can be submitted by anyone, they can be frontrun. A protocol that uses permits should
 * take this into consideration and allow a `permit` call to fail. Combining these two aspects, a pattern that may be
 * generally recommended is:
 *
 * ```solidity
 * function doThingWithPermit(..., uint256 value, uint256 deadline, uint8 v, bytes32 r, bytes32 s) public {
 *     try token.permit(msg.sender, address(this), value, deadline, v, r, s) {} catch {}
 *     doThing(..., value);
 * }
 *
 * function doThing(..., uint256 value) public {
 *     token.safeTransferFrom(msg.sender, address(this), value);
 *     ...
 * }
 * ```
 *
 * Observe that: 1) `msg.sender` is used as the owner, leaving no ambiguity as to the signer intent, and 2) the use of
 * `try/catch` allows the permit to fail and makes the code tolerant to frontrunning. (See also
 * {SafeERC20-safeTransferFrom}).
 *
 * Additionally, note that smart contract wallets (such as Argent or Safe) are not able to produce permit signatures, so
 * contracts should have entry points that don't rely on permit.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     *
     * CAUTION: See Security Considerations above.
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// File: @openzeppelin-5/contracts/utils/Address.sol

// OpenZeppelin Contracts (last updated v5.0.0) (utils/Address.sol)

pragma solidity ^0.8.20;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev The ETH balance of the account is not enough to perform the operation.
     */
    error AddressInsufficientBalance(address account);

    /**
     * @dev There's no code at `target` (it is not a contract).
     */
    error AddressEmptyCode(address target);

    /**
     * @dev A call to an address target failed. The target may have reverted.
     */
    error FailedInnerCall();

    /**
     * @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://consensys.net/diligence/blog/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.8.20/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        if (address(this).balance < amount) {
            revert AddressInsufficientBalance(address(this));
        }

        (bool success, ) = recipient.call{value: amount}("");
        if (!success) {
            revert FailedInnerCall();
        }
    }

    /**
     * @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 or custom error, it is bubbled
     * up by this function (like regular Solidity function calls). However, if
     * the call reverted with no returned reason, this function reverts with a
     * {FailedInnerCall} error.
     *
     * 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.
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0);
    }

    /**
     * @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`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

    /**
     * @dev Tool to verify that a low level call to smart-contract was successful, and reverts if the target
     * was not a contract or bubbling up the revert reason (falling back to {FailedInnerCall}) in case of an
     * unsuccessful call.
     */
    function verifyCallResultFromTarget(
        address target,
        bool success,
        bytes memory returndata
    ) internal view returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            // only check if target is a contract if the call was successful and the return data is empty
            // otherwise we already know that it was a contract
            if (returndata.length == 0 && target.code.length == 0) {
                revert AddressEmptyCode(target);
            }
            return returndata;
        }
    }

    /**
     * @dev Tool to verify that a low level call was successful, and reverts if it wasn't, either by bubbling the
     * revert reason or with a default {FailedInnerCall} error.
     */
    function verifyCallResult(bool success, bytes memory returndata) internal pure returns (bytes memory) {
        if (!success) {
            _revert(returndata);
        } else {
            return returndata;
        }
    }

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // 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
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert FailedInnerCall();
        }
    }
}

// File: @openzeppelin-5/contracts/token/ERC20/utils/SafeERC20.sol

// OpenZeppelin Contracts (last updated v5.0.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.20;



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

    /**
     * @dev An operation with an ERC20 token failed.
     */
    error SafeERC20FailedOperation(address token);

    /**
     * @dev Indicates a failed `decreaseAllowance` request.
     */
    error SafeERC20FailedDecreaseAllowance(address spender, uint256 currentAllowance, uint256 requestedDecrease);

    /**
     * @dev Transfer `value` amount of `token` from the calling contract to `to`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transfer, (to, value)));
    }

    /**
     * @dev Transfer `value` amount of `token` from `from` to `to`, spending the approval given by `from` to the
     * calling contract. If `token` returns no value, non-reverting calls are assumed to be successful.
     */
    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeCall(token.transferFrom, (from, to, value)));
    }

    /**
     * @dev Increase the calling contract's allowance toward `spender` by `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful.
     */
    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 oldAllowance = token.allowance(address(this), spender);
        forceApprove(token, spender, oldAllowance + value);
    }

    /**
     * @dev Decrease the calling contract's allowance toward `spender` by `requestedDecrease`. If `token` returns no
     * value, non-reverting calls are assumed to be successful.
     */
    function safeDecreaseAllowance(IERC20 token, address spender, uint256 requestedDecrease) internal {
        unchecked {
            uint256 currentAllowance = token.allowance(address(this), spender);
            if (currentAllowance < requestedDecrease) {
                revert SafeERC20FailedDecreaseAllowance(spender, currentAllowance, requestedDecrease);
            }
            forceApprove(token, spender, currentAllowance - requestedDecrease);
        }
    }

    /**
     * @dev Set the calling contract's allowance toward `spender` to `value`. If `token` returns no value,
     * non-reverting calls are assumed to be successful. Meant to be used with tokens that require the approval
     * to be set to zero before setting it to a non-zero value, such as USDT.
     */
    function forceApprove(IERC20 token, address spender, uint256 value) internal {
        bytes memory approvalCall = abi.encodeCall(token.approve, (spender, value));

        if (!_callOptionalReturnBool(token, approvalCall)) {
            _callOptionalReturn(token, abi.encodeCall(token.approve, (spender, 0)));
            _callOptionalReturn(token, approvalCall);
        }
    }

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

        bytes memory returndata = address(token).functionCall(data);
        if (returndata.length != 0 && !abi.decode(returndata, (bool))) {
            revert SafeERC20FailedOperation(address(token));
        }
    }

    /**
     * @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).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // 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 cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

        (bool success, bytes memory returndata) = address(token).call(data);
        return success && (returndata.length == 0 || abi.decode(returndata, (bool))) && address(token).code.length > 0;
    }
}

// File: contracts/BIFI/interfaces/beefy/IBeefySwapper.sol


pragma solidity ^0.8.0;

interface IBeefySwapper {
    function swap(
        address fromToken,
        address toToken,
        uint256 amountIn
    ) external returns (uint256 amountOut);

    function swap(
        address fromToken,
        address toToken,
        uint256 amountIn,
        uint256 minAmountOut
    ) external returns (uint256 amountOut);

    function getAmountOut(
        address _fromToken,
        address _toToken,
        uint256 _amountIn
    ) external view returns (uint256 amountOut);

    function swapInfo(
        address _fromToken,
        address _toToken
    ) external view returns (
        address router,
        bytes calldata data,
        uint256 amountIndex,
        uint256 minIndex,
        int8 minAmountSign
    );

    struct SwapInfo {
        address router;
        bytes data;
        uint256 amountIndex;
        uint256 minIndex;
        int8 minAmountSign;
    }
}

interface ISimplifiedSwapInfo {
    function swapInfo(address _fromToken, address _toToken) external view returns (address router, bytes calldata data);
}

// File: contracts/BIFI/interfaces/beefy/IStrategyFactory.sol

pragma solidity ^0.8.0;

interface IStrategyFactory {
    function createStrategy(string calldata _strategyName) external returns (address);
    function native() external view returns (address);
    function keeper() external view returns (address);
    function beefyFeeRecipient() external view returns (address);
    function beefyFeeConfig() external view returns (address);
    function globalPause() external view returns (bool);
    function strategyPause(string calldata stratName) external view returns (bool);
}

// File: contracts/BIFI/interfaces/common/IFeeConfig.sol


pragma solidity ^0.8.0;

interface IFeeConfig {
    struct FeeCategory {
        uint256 total;
        uint256 beefy;
        uint256 call;
        uint256 strategist;
        string label;
        bool active;
    }
    struct AllFees {
        FeeCategory performance;
        uint256 deposit;
        uint256 withdraw;
    }
    function getFees(address strategy) external view returns (FeeCategory memory);
    function stratFeeId(address strategy) external view returns (uint256);
    function setStratFeeId(uint256 feeId) external;
}

// File: contracts/BIFI/interfaces/common/IWrappedNative.sol


pragma solidity >=0.6.0 <0.9.0;

interface IWrappedNative {
    function deposit() external payable;
    function withdraw(uint256 wad) external;
}

// File: contracts/BIFI/strategies/Common/BaseAllToNativeFactoryStrat.sol


pragma solidity ^0.8.20;







abstract contract BaseAllToNativeFactoryStrat is OwnableUpgradeable, PausableUpgradeable {
    using SafeERC20 for IERC20;

    struct Addresses {
        address want;
        address depositToken;
        address factory;
        address vault;
        address swapper;
        address strategist;
    }

    address[] public rewards;
    mapping(address => uint) public minAmounts; // tokens minimum amount to be swapped

    IStrategyFactory public factory;
    address public vault;
    address public swapper;
    address public strategist;

    address public want;
    address public native;
    address public depositToken;
    uint256 public lastHarvest;
    uint256 public totalLocked;
    uint256 public lockDuration;
    bool public harvestOnDeposit;

    uint256 constant DIVISOR = 1 ether;

    event StratHarvest(address indexed harvester, uint256 wantHarvested, uint256 tvl);
    event Deposit(uint256 tvl);
    event Withdraw(uint256 tvl);
    event ChargedFees(uint256 callFees, uint256 beefyFees, uint256 strategistFees);
    event SetVault(address vault);
    event SetSwapper(address swapper);
    event SetStrategist(address strategist);

    error StrategyPaused();
    error NotManager();

    modifier ifNotPaused() {
        if (paused() || factory.globalPause() || factory.strategyPause(stratName())) revert StrategyPaused();
        _;
    }

    modifier onlyManager() {
        _checkManager();
        _;
    }

    function _checkManager() internal view {
        if (msg.sender != owner() && msg.sender != keeper()) revert NotManager();
    }

    function __BaseStrategy_init(Addresses memory _addresses, address[] memory _rewards) internal onlyInitializing {
        __Ownable_init();
        __Pausable_init();
        want = _addresses.want;
        factory = IStrategyFactory(_addresses.factory);
        vault = _addresses.vault;
        swapper = _addresses.swapper;
        strategist = _addresses.strategist;
        native = factory.native();

        for (uint i; i < _rewards.length; i++) {
            addReward(_rewards[i]);
        }
        setDepositToken(_addresses.depositToken);

        lockDuration = 1 days;
    }

    function stratName() public view virtual returns (string memory);

    function balanceOfPool() public view virtual returns (uint);

    function _deposit(uint amount) internal virtual;

    function _withdraw(uint amount) internal virtual;

    function _emergencyWithdraw() internal virtual;

    function _claim() internal virtual;

    function _verifyRewardToken(address token) internal view virtual;

    // puts the funds to work
    function deposit() public ifNotPaused {
        uint256 wantBal = balanceOfWant();
        if (wantBal > 0) {
            _deposit(wantBal);
            emit Deposit(balanceOf());
        }
    }

    function withdraw(uint256 _amount) external {
        require(msg.sender == vault, "!vault");

        uint256 wantBal = balanceOfWant();

        if (wantBal < _amount) {
            _withdraw(_amount - wantBal);
            wantBal = balanceOfWant();
        }

        if (wantBal > _amount) {
            wantBal = _amount;
        }

        IERC20(want).safeTransfer(vault, wantBal);

        emit Withdraw(balanceOf());
    }

    function beforeDeposit() external virtual {
        if (harvestOnDeposit) {
            require(msg.sender == vault, "!vault");
            _harvest(tx.origin, true);
        }
    }

    function claim() external virtual {
        _claim();
    }

    function harvest() external virtual {
        _harvest(tx.origin, false);
    }

    function harvest(address callFeeRecipient) external virtual {
        _harvest(callFeeRecipient, false);
    }

    // compounds earnings and charges performance fee
    function _harvest(address callFeeRecipient, bool onDeposit) internal ifNotPaused {
        _claim();
        _swapRewardsToNative();
        uint256 nativeBal = IERC20(native).balanceOf(address(this));
        if (nativeBal > minAmounts[native]) {
            _chargeFees(callFeeRecipient);

            _swapNativeToWant();
            uint256 wantHarvested = balanceOfWant();
            totalLocked = wantHarvested + lockedProfit();
            lastHarvest = block.timestamp;

            if (!onDeposit) {
                deposit();
            }

            emit StratHarvest(msg.sender, wantHarvested, balanceOf());
        }
    }

    function _swapRewardsToNative() internal virtual {
        for (uint i; i < rewards.length; ++i) {
            address token = rewards[i];
            if (token == address(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE)) {
                IWrappedNative(native).deposit{value: address(this).balance}();
            } else {
                uint amount = IERC20(token).balanceOf(address(this));
                if (amount > minAmounts[token]) {
                    _swap(token, native, amount);
                }
            }
        }
    }

    // performance fees
    function _chargeFees(address callFeeRecipient) internal {
        IFeeConfig.FeeCategory memory fees = beefyFeeConfig().getFees(address(this));
        uint256 nativeBal = IERC20(native).balanceOf(address(this)) * fees.total / DIVISOR;

        uint256 callFeeAmount = nativeBal * fees.call / DIVISOR;
        IERC20(native).safeTransfer(callFeeRecipient, callFeeAmount);

        uint256 beefyFeeAmount = nativeBal * fees.beefy / DIVISOR;
        IERC20(native).safeTransfer(beefyFeeRecipient(), beefyFeeAmount);

        uint256 strategistFeeAmount = nativeBal * fees.strategist / DIVISOR;
        IERC20(native).safeTransfer(strategist, strategistFeeAmount);

        emit ChargedFees(callFeeAmount, beefyFeeAmount, strategistFeeAmount);
    }

    function _swapNativeToWant() internal virtual {
        if (depositToken == address(0)) {
            _swap(native, want);
        } else {
            if (depositToken != native) {
                _swap(native, depositToken);
            }
            _swap(depositToken, want);
        }
    }

    function _swap(address tokenFrom, address tokenTo) internal {
        uint bal = IERC20(tokenFrom).balanceOf(address(this));
        _swap(tokenFrom, tokenTo, bal);
    }

    function _swap(address tokenFrom, address tokenTo, uint amount) internal {
        if (tokenFrom != tokenTo) {
            IERC20(tokenFrom).forceApprove(swapper, amount);
            IBeefySwapper(swapper).swap(tokenFrom, tokenTo, amount);
        }
    }

    function rewardsLength() external view returns (uint) {
        return rewards.length;
    }

    function addReward(address _token) public onlyManager {
        require(_token != want, "!want");
        require(_token != native, "!native");
        _verifyRewardToken(_token);
        rewards.push(_token);
    }

    function removeReward(uint i) external onlyManager {
        rewards[i] = rewards[rewards.length - 1];
        rewards.pop();
    }

    function resetRewards() external onlyManager {
        delete rewards;
    }

    function setRewardMinAmount(address token, uint minAmount) external onlyManager {
        minAmounts[token] = minAmount;
    }

    function setDepositToken(address token) public onlyManager {
        if (token == address(0)) {
            depositToken = address(0);
            return;
        }
        require(token != want, "!want");
        _verifyRewardToken(token);
        depositToken = token;
    }

    function lockedProfit() public view returns (uint256) {
        if (lockDuration == 0) return 0;
        uint256 elapsed = block.timestamp - lastHarvest;
        uint256 remaining = elapsed < lockDuration ? lockDuration - elapsed : 0;
        return totalLocked * remaining / lockDuration;
    }

    // calculate the total underlaying 'want' held by the strat.
    function balanceOf() public view returns (uint256) {
        return balanceOfWant() + balanceOfPool() - lockedProfit();
    }

    // it calculates how much 'want' this contract holds.
    function balanceOfWant() public view returns (uint256) {
        return IERC20(want).balanceOf(address(this));
    }

    function setHarvestOnDeposit(bool _harvestOnDeposit) public onlyManager {
        harvestOnDeposit = _harvestOnDeposit;
        if (harvestOnDeposit) {
            lockDuration = 0;
        } else {
            lockDuration = 1 days;
        }
    }

    function setLockDuration(uint _duration) external onlyManager {
        lockDuration = _duration;
    }

    function rewardsAvailable() external view virtual returns (uint) {
        return 0;
    }

    function callReward() external view virtual returns (uint) {
        return 0;
    }

    function depositFee() public view virtual returns (uint) {
        return 0;
    }

    function withdrawFee() public view virtual returns (uint) {
        return 0;
    }

    // called as part of strat migration. Sends all the available funds back to the vault.
    function retireStrat() external {
        require(msg.sender == vault, "!vault");
        _emergencyWithdraw();
        IERC20(want).transfer(vault, balanceOfWant());
    }

    // pauses deposits and withdraws all funds from third party systems.
    function panic() public virtual onlyManager {
        pause();
        _emergencyWithdraw();
    }

    function pause() public virtual onlyManager {
        _pause();
    }

    function unpause() external virtual onlyManager {
        _unpause();
        deposit();
    }

    function keeper() public view returns (address) {
        return factory.keeper();
    }

    function beefyFeeConfig() public view returns (IFeeConfig) {
        return IFeeConfig(factory.beefyFeeConfig());
    }

    function beefyFeeRecipient() public view returns (address) {
        return factory.beefyFeeRecipient();
    }

    function getAllFees() external view returns (IFeeConfig.AllFees memory) {
        return IFeeConfig.AllFees(beefyFeeConfig().getFees(address(this)), depositFee(), withdrawFee());
    }

    function setVault(address _vault) external onlyOwner {
        vault = _vault;
        emit SetVault(_vault);
    }

    function setSwapper(address _swapper) external onlyOwner {
        swapper = _swapper;
        emit SetSwapper(_swapper);
    }

    function setStrategist(address _strategist) external {
        require(msg.sender == strategist, "!strategist");
        strategist = _strategist;
        emit SetStrategist(_strategist);
    }

    receive () payable external {}

    uint256[49] private __gap;
}

// File: contracts/BIFI/strategies/Ichi/StrategyIchi.sol

pragma solidity ^0.8.0;



contract StrategyIchi is BaseAllToNativeFactoryStrat {
    using SafeERC20 for IERC20;

    IRewardPool public gauge;
    address public lpToken0;
    address public lpToken1;

    function initialize(
        address _gauge,
        bool _harvestOnDeposit,
        address[] calldata _rewards,
        Addresses calldata _addresses
    ) public initializer {
        __BaseStrategy_init(_addresses, _rewards);
        gauge = IRewardPool(_gauge);
        if (_harvestOnDeposit) setHarvestOnDeposit(true);

        lpToken0 = IchiVault(want).token0();
        lpToken1 = IchiVault(want).token1();
    }

    function stratName() public pure override returns (string memory) {
        return "Ichi";
    }

    function balanceOfPool() public view override returns (uint) {
        return gauge.balanceOf(address(this));
    }

    function _deposit(uint amount) internal override {
        IERC20(want).forceApprove(address(gauge), amount);
        gauge.deposit(amount);
    }

    function _withdraw(uint amount) internal override {
        if (amount > 0) {
            gauge.withdraw(amount);
        }
    }

    function _emergencyWithdraw() internal override {
        uint amount = balanceOfPool();
        if (amount > 0) {
            if (gauge.emergency()) gauge.emergencyWithdraw();
            else gauge.withdraw(amount);
        }
    }

    function _claim() internal override {
        gauge.getReward();
    }

    function _verifyRewardToken(address token) internal view override {}

    function _swapNativeToWant() internal override {
        if (depositToken != native) {
            _swap(native, depositToken);
        }
        uint depositBal = IERC20(depositToken).balanceOf(address(this));

        uint amount0 = depositToken == lpToken0 ? depositBal : 0;
        uint amount1 = depositToken == lpToken1 ? depositBal : 0;

        IERC20(depositToken).forceApprove(want, depositBal);
        IchiVault(want).deposit(amount0, amount1, address(this));
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[],"name":"NotManager","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"inputs":[],"name":"StrategyPaused","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"callFees","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"beefyFees","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"strategistFees","type":"uint256"}],"name":"ChargedFees","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tvl","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"strategist","type":"address"}],"name":"SetStrategist","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"swapper","type":"address"}],"name":"SetSwapper","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"vault","type":"address"}],"name":"SetVault","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"harvester","type":"address"},{"indexed":false,"internalType":"uint256","name":"wantHarvested","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"tvl","type":"uint256"}],"name":"StratHarvest","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"tvl","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[{"internalType":"address","name":"_token","type":"address"}],"name":"addReward","outputs":[],"stateMutability":"nonpayable","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":"beefyFeeConfig","outputs":[{"internalType":"contract IFeeConfig","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"beefyFeeRecipient","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"beforeDeposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"callReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claim","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"deposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"depositFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"depositToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"factory","outputs":[{"internalType":"contract IStrategyFactory","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"gauge","outputs":[{"internalType":"contract IRewardPool","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getAllFees","outputs":[{"components":[{"components":[{"internalType":"uint256","name":"total","type":"uint256"},{"internalType":"uint256","name":"beefy","type":"uint256"},{"internalType":"uint256","name":"call","type":"uint256"},{"internalType":"uint256","name":"strategist","type":"uint256"},{"internalType":"string","name":"label","type":"string"},{"internalType":"bool","name":"active","type":"bool"}],"internalType":"struct IFeeConfig.FeeCategory","name":"performance","type":"tuple"},{"internalType":"uint256","name":"deposit","type":"uint256"},{"internalType":"uint256","name":"withdraw","type":"uint256"}],"internalType":"struct IFeeConfig.AllFees","name":"","type":"tuple"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"callFeeRecipient","type":"address"}],"name":"harvest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"harvest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"harvestOnDeposit","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_gauge","type":"address"},{"internalType":"bool","name":"_harvestOnDeposit","type":"bool"},{"internalType":"address[]","name":"_rewards","type":"address[]"},{"components":[{"internalType":"address","name":"want","type":"address"},{"internalType":"address","name":"depositToken","type":"address"},{"internalType":"address","name":"factory","type":"address"},{"internalType":"address","name":"vault","type":"address"},{"internalType":"address","name":"swapper","type":"address"},{"internalType":"address","name":"strategist","type":"address"}],"internalType":"struct BaseAllToNativeFactoryStrat.Addresses","name":"_addresses","type":"tuple"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"keeper","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastHarvest","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lockedProfit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lpToken0","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lpToken1","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"minAmounts","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"native","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"panic","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"i","type":"uint256"}],"name":"removeReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"resetRewards","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"retireStrat","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"rewards","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardsAvailable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"rewardsLength","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"setDepositToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_harvestOnDeposit","type":"bool"}],"name":"setHarvestOnDeposit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_duration","type":"uint256"}],"name":"setLockDuration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"uint256","name":"minAmount","type":"uint256"}],"name":"setRewardMinAmount","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_strategist","type":"address"}],"name":"setStrategist","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_swapper","type":"address"}],"name":"setSwapper","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_vault","type":"address"}],"name":"setVault","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"stratName","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"strategist","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"swapper","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalLocked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"vault","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","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":"withdrawFee","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

608060405234801561000f575f80fd5b50612e5b8061001d5f395ff3fe608060405260043610610344575f3560e01c8063877562b6116101bd578063c1a3d44c116100f2578063e7a7250a11610092578063f2fde38b1161006d578063f2fde38b14610872578063f301af4214610891578063fb617787146108b0578063fbfa77cf146108c4575f80fd5b8063e7a7250a146105c0578063e941fa78146105c0578063f1a392da1461085d575f80fd5b8063c7b9d530116100cd578063c7b9d530146107ec578063c89039c51461080b578063d0e30db01461082a578063d97d1c3b1461083e575f80fd5b8063c1a3d44c1461079a578063c45a0155146107ae578063c553173f146107cd575f80fd5b80639c9b2e211161015d578063aced166111610138578063aced16611461073d578063ad29f5da14610751578063b20feaaf14610765578063bbb356d514610786575f80fd5b80639c9b2e21146106e0578063a6f19c84146106ff578063a7e9ca821461071e575f80fd5b80638e145459116101985780638e1454591461068257806397fd323d146105c05780639c5e52d5146106965780639c82f2a4146106c1575f80fd5b8063877562b61461062d5780638912cb8b1461064c5780638da5cb5b14610665575f80fd5b80634700d305116102935780635c975abb116102335780636817031b1161020e5780636817031b146105d2578063715018a6146105f1578063722713f7146106055780638456cb5914610619575f80fd5b80635c975abb1461057e5780635ee167c0146105a157806367a52793146105c0575f80fd5b80634eb665af1161026e5780634eb665af146105155780635064010a146105345780635689141214610555578063573fef0a1461056a575f80fd5b80634700d305146104d95780634746fb55146104ed5780634e71d92d14610501575f80fd5b80631f1fcd51116102fe5780632e1a7d4d116102d95780632e1a7d4d1461047e5780633f4ba83a1461049d57806344b81396146104b15780634641257d146104c5575f80fd5b80631f1fcd51146104215780631fe4a686146104405780632b3297f91461045f575f80fd5b8063045544431461034f5780630c4ed799146103775780630e5c011e146103985780630e8fbb5a146103b757806311588086146103d657806311b0b42d146103ea575f80fd5b3661034b57005b5f80fd5b34801561035a575f80fd5b5061036460a25481565b6040519081526020015b60405180910390f35b348015610382575f80fd5b506103966103913660046128b3565b6108e3565b005b3480156103a3575f80fd5b506103966103b23660046128b3565b610976565b3480156103c2575f80fd5b506103966103d13660046128db565b610980565b3480156103e1575f80fd5b506103646109b2565b3480156103f5575f80fd5b50609e54610409906001600160a01b031681565b6040516001600160a01b03909116815260200161036e565b34801561042c575f80fd5b50609d54610409906001600160a01b031681565b34801561044b575f80fd5b50609c54610409906001600160a01b031681565b34801561046a575f80fd5b50609b54610409906001600160a01b031681565b348015610489575f80fd5b506103966104983660046128f6565b610a22565b3480156104a8575f80fd5b50610396610ae2565b3480156104bc575f80fd5b50610364610afc565b3480156104d0575f80fd5b50610396610b5e565b3480156104e4575f80fd5b50610396610b68565b3480156104f8575f80fd5b50610409610b80565b34801561050c575f80fd5b50610396610beb565b348015610520575f80fd5b5061039661052f3660046128f6565b610bf3565b34801561053f575f80fd5b50610548610c00565b60405161036e919061295a565b348015610560575f80fd5b5061036460a15481565b348015610575575f80fd5b50610396610c1e565b348015610589575f80fd5b5060655460ff165b604051901515815260200161036e565b3480156105ac575f80fd5b5060d654610409906001600160a01b031681565b3480156105cb575f80fd5b505f610364565b3480156105dd575f80fd5b506103966105ec3660046128b3565b610c5e565b3480156105fc575f80fd5b50610396610cbb565b348015610610575f80fd5b50610364610ccc565b348015610624575f80fd5b50610396610cf9565b348015610638575f80fd5b5060d754610409906001600160a01b031681565b348015610657575f80fd5b5060a3546105919060ff1681565b348015610670575f80fd5b506033546001600160a01b0316610409565b34801561068d575f80fd5b50610409610d09565b3480156106a1575f80fd5b506103646106b03660046128b3565b60986020525f908152604090205481565b3480156106cc575f80fd5b506103966106db3660046128b3565b610d50565b3480156106eb575f80fd5b506103966106fa3660046128b3565b610da6565b34801561070a575f80fd5b5060d554610409906001600160a01b031681565b348015610729575f80fd5b5061039661073836600461296c565b610e8d565b348015610748575f80fd5b50610409610eb0565b34801561075c575f80fd5b50610396610ef7565b348015610770575f80fd5b50610779610f0a565b60405161036e9190612996565b348015610791575f80fd5b50609754610364565b3480156107a5575f80fd5b50610364610fa2565b3480156107b9575f80fd5b50609954610409906001600160a01b031681565b3480156107d8575f80fd5b506103966107e73660046128f6565b610fd2565b3480156107f7575f80fd5b506103966108063660046128b3565b611084565b348015610816575f80fd5b50609f54610409906001600160a01b031681565b348015610835575f80fd5b5061039661111a565b348015610849575f80fd5b50610396610858366004612a12565b611283565b348015610868575f80fd5b5061036460a05481565b34801561087d575f80fd5b5061039661088c3660046128b3565b611515565b34801561089c575f80fd5b506104096108ab3660046128f6565b61158b565b3480156108bb575f80fd5b506103966115b3565b3480156108cf575f80fd5b50609a54610409906001600160a01b031681565b6108eb611672565b6001600160a01b03811661090c57609f80546001600160a01b031916905550565b609d546001600160a01b03908116908216036109575760405162461bcd60e51b8152602060048201526005602482015264085dd85b9d60da1b60448201526064015b60405180910390fd5b609f80546001600160a01b0319166001600160a01b0383161790555b50565b610973815f6116c4565b610988611672565b60a3805460ff191682151590811790915560ff16156109a8575f60a25550565b6201518060a25550565b60d5546040516370a0823160e01b81523060048201525f916001600160a01b0316906370a08231906024015b602060405180830381865afa1580156109f9573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610a1d9190612ac2565b905090565b609a546001600160a01b03163314610a4c5760405162461bcd60e51b815260040161094e90612ad9565b5f610a55610fa2565b905081811015610a7c57610a71610a6c8284612b0d565b611906565b610a79610fa2565b90505b81811115610a875750805b609a54609d54610aa4916001600160a01b03918216911683611969565b7f5b6b431d4476a211bb7d41c20d1aab9ae2321deee0d20be3d9fc9b1093fa6e3d610acd610ccc565b60405190815260200160405180910390a15050565b610aea611672565b610af26119c8565b610afa61111a565b565b5f60a2545f03610b0b57505f90565b5f60a05442610b1a9190612b0d565b90505f60a2548210610b2c575f610b3a565b8160a254610b3a9190612b0d565b905060a2548160a154610b4d9190612b20565b610b579190612b37565b9250505090565b610afa325f6116c4565b610b70611672565b610b78610cf9565b610afa611a1a565b60995460408051634746fb5560e01b815290515f926001600160a01b031691634746fb559160048083019260209291908290030181865afa158015610bc7573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190610a1d9190612b56565b610afa611b21565b610bfb611672565b60a255565b6040805180820190915260048152634963686960e01b602082015290565b60a35460ff1615610afa57609a546001600160a01b03163314610c535760405162461bcd60e51b815260040161094e90612ad9565b610afa3260016116c4565b610c66611b85565b609a80546001600160a01b0319166001600160a01b0383169081179091556040519081527fd459c7242e23d490831b5676a611c4342d899d28f342d89ae80793e56a930f30906020015b60405180910390a150565b610cc3611b85565b610afa5f611bdf565b5f610cd5610afc565b610cdd6109b2565b610ce5610fa2565b610cef9190612b71565b610a1d9190612b0d565b610d01611672565b610afa611c30565b60995460408051638e14545960e01b815290515f926001600160a01b031691638e1454599160048083019260209291908290030181865afa158015610bc7573d5f803e3d5ffd5b610d58611b85565b609b80546001600160a01b0319166001600160a01b0383169081179091556040519081527f211f06c051495b535b79192c1a4531d819d569657ff4bd16daa8e9e5e6ed2bfd90602001610cb0565b610dae611672565b609d546001600160a01b0390811690821603610df45760405162461bcd60e51b8152602060048201526005602482015264085dd85b9d60da1b604482015260640161094e565b609e546001600160a01b0390811690821603610e3c5760405162461bcd60e51b8152602060048201526007602482015266216e617469766560c81b604482015260640161094e565b609780546001810182555f919091527f354a83ed9988f79f6038d4c7a7dadbad8af32f4ad6df893e0e5807a1b1944ff90180546001600160a01b0319166001600160a01b0392909216919091179055565b610e95611672565b6001600160a01b039091165f90815260986020526040902055565b6099546040805163aced166160e01b815290515f926001600160a01b03169163aced16619160048083019260209291908290030181865afa158015610bc7573d5f803e3d5ffd5b610eff611672565b610afa60975f612819565b610f12612834565b6040518060600160405280610f25610b80565b604051639af608c960e01b81523060048201526001600160a01b039190911690639af608c9906024015f60405180830381865afa158015610f68573d5f803e3d5ffd5b505050506040513d5f823e601f3d908101601f19168201604052610f8f9190810190612c02565b81526020015f81526020015f9052919050565b609d546040516370a0823160e01b81523060048201525f916001600160a01b0316906370a08231906024016109de565b610fda611672565b60978054610fea90600190612b0d565b81548110610ffa57610ffa612cf1565b5f91825260209091200154609780546001600160a01b03909216918390811061102557611025612cf1565b905f5260205f20015f6101000a8154816001600160a01b0302191690836001600160a01b03160217905550609780548061106157611061612d05565b5f8281526020902081015f1990810180546001600160a01b031916905501905550565b609c546001600160a01b031633146110cc5760405162461bcd60e51b815260206004820152600b60248201526a085cdd1c985d1959da5cdd60aa1b604482015260640161094e565b609c80546001600160a01b0319166001600160a01b0383169081179091556040519081527f46d58e3fa07bf19b1d27240f0e286b27e9f7c1b0d88933333fe833b60eec541290602001610cb0565b60655460ff168061119a575060995f9054906101000a90046001600160a01b03166001600160a01b031663f12d54d86040518163ffffffff1660e01b8152600401602060405180830381865afa158015611176573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061119a9190612d19565b8061121457506099546001600160a01b031663de73a5946111b9610c00565b6040518263ffffffff1660e01b81526004016111d5919061295a565b602060405180830381865afa1580156111f0573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906112149190612d19565b156112325760405163e628b94960e01b815260040160405180910390fd5b5f61123b610fa2565b905080156109735761124c81611c6d565b7f4d6ce1e535dbade1c23defba91e23b8f791ce5edc0cc320257a2b364e4e38426611275610ccc565b604051908152602001610cb0565b5f54610100900460ff16158080156112a157505f54600160ff909116105b806112ba5750303b1580156112ba57505f5460ff166001145b61131d5760405162461bcd60e51b815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201526d191e481a5b9a5d1a585b1a5e995960921b606482015260840161094e565b5f805460ff19166001179055801561133e575f805461ff0019166101001790555b61138861135036849003840184612d34565b8585808060200260200160405190810160405280939291908181526020018383602002808284375f92019190915250611cbb92505050565b60d580546001600160a01b0319166001600160a01b03881617905584156113b3576113b36001610980565b609d5f9054906101000a90046001600160a01b03166001600160a01b0316630dfe16816040518163ffffffff1660e01b8152600401602060405180830381865afa158015611403573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906114279190612b56565b60d680546001600160a01b0319166001600160a01b03928316179055609d546040805163d21220a760e01b81529051919092169163d21220a79160048083019260209291908290030181865afa158015611483573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906114a79190612b56565b60d780546001600160a01b0319166001600160a01b0392909216919091179055801561150d575f805461ff0019169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb3847402498906020015b60405180910390a15b505050505050565b61151d611b85565b6001600160a01b0381166115825760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b606482015260840161094e565b61097381611bdf565b6097818154811061159a575f80fd5b5f918252602090912001546001600160a01b0316905081565b609a546001600160a01b031633146115dd5760405162461bcd60e51b815260040161094e90612ad9565b6115e5611a1a565b609d54609a546001600160a01b039182169163a9059cbb9116611606610fa2565b6040516001600160e01b031960e085901b1681526001600160a01b03909216600483015260248201526044016020604051808303815f875af115801561164e573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906109739190612d19565b6033546001600160a01b031633148015906116a65750611690610eb0565b6001600160a01b0316336001600160a01b031614155b15610afa5760405163607e454560e11b815260040160405180910390fd5b60655460ff1680611744575060995f9054906101000a90046001600160a01b03166001600160a01b031663f12d54d86040518163ffffffff1660e01b8152600401602060405180830381865afa158015611720573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906117449190612d19565b806117be57506099546001600160a01b031663de73a594611763610c00565b6040518263ffffffff1660e01b815260040161177f919061295a565b602060405180830381865afa15801561179a573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906117be9190612d19565b156117dc5760405163e628b94960e01b815260040160405180910390fd5b6117e4611b21565b6117ec611e2c565b609e546040516370a0823160e01b81523060048201525f916001600160a01b0316906370a0823190602401602060405180830381865afa158015611832573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906118569190612ac2565b609e546001600160a01b03165f908152609860205260409020549091508111156119015761188383611f94565b61188b61219b565b5f611894610fa2565b905061189e610afc565b6118a89082612b71565b60a1554260a055826118bc576118bc61111a565b337f9bc239f1724cacfb88cb1d66a2dc437467699b68a8c90d7b63110cf4b6f92410826118e7610ccc565b6040805192835260208301919091520160405180910390a2505b505050565b80156109735760d554604051632e1a7d4d60e01b8152600481018390526001600160a01b0390911690632e1a7d4d906024015b5f604051808303815f87803b158015611950575f80fd5b505af1158015611962573d5f803e3d5ffd5b5050505050565b6040516001600160a01b0383811660248301526044820183905261190191859182169063a9059cbb906064015b604051602081830303815290604052915060e01b6020820180516001600160e01b03838183161783525050505061231d565b6119d061237e565b6065805460ff191690557f5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa335b6040516001600160a01b03909116815260200160405180910390a1565b5f611a236109b2565b905080156109735760d55f9054906101000a90046001600160a01b03166001600160a01b031663caa6fea46040518163ffffffff1660e01b8152600401602060405180830381865afa158015611a7b573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611a9f9190612d19565b15611af05760d55f9054906101000a90046001600160a01b03166001600160a01b031663db2e21bc6040518163ffffffff1660e01b81526004015f604051808303815f87803b158015611950575f80fd5b60d554604051632e1a7d4d60e01b8152600481018390526001600160a01b0390911690632e1a7d4d90602401611939565b60d55f9054906101000a90046001600160a01b03166001600160a01b0316633d18b9126040518163ffffffff1660e01b81526004015f604051808303815f87803b158015611b6d575f80fd5b505af1158015611b7f573d5f803e3d5ffd5b50505050565b6033546001600160a01b03163314610afa5760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604482015260640161094e565b603380546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0905f90a35050565b611c386123c7565b6065805460ff191660011790557f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a2586119fd3390565b60d554609d54611c8a916001600160a01b0391821691168361240d565b60d55460405163b6b55f2560e01b8152600481018390526001600160a01b039091169063b6b55f2590602401611939565b5f54610100900460ff16611ce15760405162461bcd60e51b815260040161094e90612dbf565b611ce961249c565b611cf16124ca565b8151609d80546001600160a01b03199081166001600160a01b039384161790915560408085015160998054841691851691821790556060860151609a805485169186169190911790556080860151609b8054851691861691909117905560a0860151609c805490941694169390931790915580516311b0b42d60e01b815290516311b0b42d916004818101926020929091908290030181865afa158015611d9a573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611dbe9190612b56565b609e80546001600160a01b0319166001600160a01b03929092169190911790555f5b8151811015611e1357611e0b828281518110611dfe57611dfe612cf1565b6020026020010151610da6565b600101611de0565b50611e2182602001516108e3565b50506201518060a255565b5f5b609754811015610973575f60978281548110611e4c57611e4c612cf1565b5f918252602090912001546001600160a01b0316905073eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeed198101611ee757609e5f9054906101000a90046001600160a01b03166001600160a01b031663d0e30db0476040518263ffffffff1660e01b81526004015f604051808303818588803b158015611ecb575f80fd5b505af1158015611edd573d5f803e3d5ffd5b5050505050611f8b565b6040516370a0823160e01b81523060048201525f906001600160a01b038316906370a0823190602401602060405180830381865afa158015611f2b573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611f4f9190612ac2565b6001600160a01b0383165f90815260986020526040902054909150811115611f8957609e54611f899083906001600160a01b0316836124f8565b505b50600101611e2e565b5f611f9d610b80565b604051639af608c960e01b81523060048201526001600160a01b039190911690639af608c9906024015f60405180830381865afa158015611fe0573d5f803e3d5ffd5b505050506040513d5f823e601f3d908101601f191682016040526120079190810190612c02565b8051609e546040516370a0823160e01b81523060048201529293505f92670de0b6b3a764000092916001600160a01b0316906370a0823190602401602060405180830381865afa15801561205d573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906120819190612ac2565b61208b9190612b20565b6120959190612b37565b90505f670de0b6b3a76400008360400151836120b19190612b20565b6120bb9190612b37565b609e549091506120d5906001600160a01b03168583611969565b5f670de0b6b3a76400008460200151846120ef9190612b20565b6120f99190612b37565b9050612119612106610d09565b609e546001600160a01b03169083611969565b5f670de0b6b3a76400008560600151856121339190612b20565b61213d9190612b37565b609c54609e5491925061215d916001600160a01b03908116911683611969565b60408051848152602081018490529081018290527fd255b592c7f268a73e534da5219a60ff911b4cf6daae21c7d20527dd657bd99a90606001611504565b609e54609f546001600160a01b039081169116146121cf57609e54609f546121cf916001600160a01b03908116911661256c565b609f546040516370a0823160e01b81523060048201525f916001600160a01b0316906370a0823190602401602060405180830381865afa158015612215573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906122399190612ac2565b60d654609f549192505f916001600160a01b0390811691161461225c575f61225e565b815b60d754609f549192505f916001600160a01b03908116911614612281575f612283565b825b609d54609f549192506122a3916001600160a01b0390811691168561240d565b609d54604051638dbdbe6d60e01b815260048101849052602481018390523060448201526001600160a01b0390911690638dbdbe6d906064015b6020604051808303815f875af11580156122f9573d5f803e3d5ffd5b505050506040513d601f19601f82011682018060405250810190611b7f9190612ac2565b5f6123316001600160a01b038416836125e1565b905080515f141580156123555750808060200190518101906123539190612d19565b155b1561190157604051635274afe760e01b81526001600160a01b038416600482015260240161094e565b60655460ff16610afa5760405162461bcd60e51b815260206004820152601460248201527314185d5cd8589b194e881b9bdd081c185d5cd95960621b604482015260640161094e565b60655460ff1615610afa5760405162461bcd60e51b815260206004820152601060248201526f14185d5cd8589b194e881c185d5cd95960821b604482015260640161094e565b604080516001600160a01b038416602482015260448082018490528251808303909101815260649091019091526020810180516001600160e01b031663095ea7b360e01b17905261245e84826125f7565b611b7f576040516001600160a01b0384811660248301525f604483015261249291869182169063095ea7b390606401611996565b611b7f848261231d565b5f54610100900460ff166124c25760405162461bcd60e51b815260040161094e90612dbf565b610afa612698565b5f54610100900460ff166124f05760405162461bcd60e51b815260040161094e90612dbf565b610afa6126c7565b816001600160a01b0316836001600160a01b03161461190157609b5461252b906001600160a01b0385811691168361240d565b609b54604051630df791e560e41b81526001600160a01b0385811660048301528481166024830152604482018490529091169063df791e50906064016122dd565b6040516370a0823160e01b81523060048201525f906001600160a01b038416906370a0823190602401602060405180830381865afa1580156125b0573d5f803e3d5ffd5b505050506040513d601f19601f820116820180604052508101906125d49190612ac2565b90506119018383836124f8565b60606125ee83835f6126f9565b90505b92915050565b5f805f846001600160a01b0316846040516126129190612e0a565b5f604051808303815f865af19150503d805f811461264b576040519150601f19603f3d011682016040523d82523d5f602084013e612650565b606091505b509150915081801561267a57508051158061267a57508080602001905181019061267a9190612d19565b801561268f57505f856001600160a01b03163b115b95945050505050565b5f54610100900460ff166126be5760405162461bcd60e51b815260040161094e90612dbf565b610afa33611bdf565b5f54610100900460ff166126ed5760405162461bcd60e51b815260040161094e90612dbf565b6065805460ff19169055565b60608147101561271e5760405163cd78605960e01b815230600482015260240161094e565b5f80856001600160a01b031684866040516127399190612e0a565b5f6040518083038185875af1925050503d805f8114612773576040519150601f19603f3d011682016040523d82523d5f602084013e612778565b606091505b5091509150612788868383612794565b925050505b9392505050565b6060826127a9576127a4826127f0565b61278d565b81511580156127c057506001600160a01b0384163b155b156127e957604051639996b31560e01b81526001600160a01b038516600482015260240161094e565b508061278d565b8051156128005780518082602001fd5b604051630a12f52160e11b815260040160405180910390fd5b5080545f8255905f5260205f20908101906109739190612887565b60405180606001604052806128756040518060c001604052805f81526020015f81526020015f81526020015f8152602001606081526020015f151581525090565b81526020015f81526020015f81525090565b5b8082111561289b575f8155600101612888565b5090565b6001600160a01b0381168114610973575f80fd5b5f602082840312156128c3575f80fd5b813561278d8161289f565b8015158114610973575f80fd5b5f602082840312156128eb575f80fd5b813561278d816128ce565b5f60208284031215612906575f80fd5b5035919050565b5f5b8381101561292757818101518382015260200161290f565b50505f910152565b5f815180845261294681602086016020860161290d565b601f01601f19169290920160200192915050565b602081525f6125ee602083018461292f565b5f806040838503121561297d575f80fd5b82356129888161289f565b946020939093013593505050565b602081525f82516060602084015280516080840152602081015160a0840152604081015160c0840152606081015160e0840152608081015160c06101008501526129e461014085018261292f565b905060a082015115156101208501526020850151604085015260408501516060850152809250505092915050565b5f805f805f858703610120811215612a28575f80fd5b8635612a338161289f565b95506020870135612a43816128ce565b9450604087013567ffffffffffffffff80821115612a5f575f80fd5b818901915089601f830112612a72575f80fd5b813581811115612a80575f80fd5b8a60208260051b8501011115612a94575f80fd5b60209290920195509093505060c0605f1982011215612ab1575f80fd5b506060860190509295509295909350565b5f60208284031215612ad2575f80fd5b5051919050565b602080825260069082015265085d985d5b1d60d21b604082015260600190565b634e487b7160e01b5f52601160045260245ffd5b818103818111156125f1576125f1612af9565b80820281158282048414176125f1576125f1612af9565b5f82612b5157634e487b7160e01b5f52601260045260245ffd5b500490565b5f60208284031215612b66575f80fd5b815161278d8161289f565b808201808211156125f1576125f1612af9565b634e487b7160e01b5f52604160045260245ffd5b60405160c0810167ffffffffffffffff81118282101715612bbb57612bbb612b84565b60405290565b604051601f8201601f1916810167ffffffffffffffff81118282101715612bea57612bea612b84565b604052919050565b8051612bfd816128ce565b919050565b5f6020808385031215612c13575f80fd5b825167ffffffffffffffff80821115612c2a575f80fd5b9084019060c08287031215612c3d575f80fd5b612c45612b98565b8251815283830151848201526040830151604082015260608301516060820152608083015182811115612c76575f80fd5b8301601f81018813612c86575f80fd5b805183811115612c9857612c98612b84565b612caa601f8201601f19168701612bc1565b93508084528886828401011115612cbf575f80fd5b612cce8187860188850161290d565b5050816080820152612ce260a08401612bf2565b60a08201529695505050505050565b634e487b7160e01b5f52603260045260245ffd5b634e487b7160e01b5f52603160045260245ffd5b5f60208284031215612d29575f80fd5b815161278d816128ce565b5f60c08284031215612d44575f80fd5b612d4c612b98565b8235612d578161289f565b81526020830135612d678161289f565b60208201526040830135612d7a8161289f565b60408201526060830135612d8d8161289f565b60608201526080830135612da08161289f565b608082015260a0830135612db38161289f565b60a08201529392505050565b6020808252602b908201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960408201526a6e697469616c697a696e6760a81b606082015260800190565b5f8251612e1b81846020870161290d565b919091019291505056fea2646970667358221220085b0d9fc99433ed2a9d09ff7bd470df49b6c1177fdc399545bf14ca1baf98fd64736f6c63430008170033

Deployed Bytecode

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

Deployed Bytecode Sourcemap

58113:2052:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47913:27;;;;;;;;;;;;;;;;;;;160:25:1;;;148:2;133:18;47913:27:0;;;;;;;;54556:284;;;;;;;;;;-1:-1:-1;54556:284:0;;;;;:::i;:::-;;:::i;:::-;;50911:112;;;;;;;;;;-1:-1:-1;50911:112:0;;;;;:::i;:::-;;:::i;55542:256::-;;;;;;;;;;-1:-1:-1;55542:256:0;;;;;:::i;:::-;;:::i;58848:117::-;;;;;;;;;;;;;:::i;47785:21::-;;;;;;;;;;-1:-1:-1;47785:21:0;;;;-1:-1:-1;;;;;47785:21:0;;;;;;-1:-1:-1;;;;;1117:32:1;;;1099:51;;1087:2;1072:18;47785:21:0;953:203:1;47759:19:0;;;;;;;;;;-1:-1:-1;47759:19:0;;;;-1:-1:-1;;;;;47759:19:0;;;47725:25;;;;;;;;;;-1:-1:-1;47725:25:0;;;;-1:-1:-1;;;;;47725:25:0;;;47696:22;;;;;;;;;;-1:-1:-1;47696:22:0;;;;-1:-1:-1;;;;;47696:22:0;;;50101:449;;;;;;;;;;-1:-1:-1;50101:449:0;;;;;:::i;:::-;;:::i;56836:97::-;;;;;;;;;;;;;:::i;54848:300::-;;;;;;;;;;;;;:::i;50822:81::-;;;;;;;;;;;;;:::i;56648:101::-;;;;;;;;;;;;;:::i;57039:121::-;;;;;;;;;;;;;:::i;50753:61::-;;;;;;;;;;;;;:::i;55806:105::-;;;;;;;;;;-1:-1:-1;55806:105:0;;;;;:::i;:::-;;:::i;58742:98::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;47880:26::-;;;;;;;;;;;;;;;;50558:187;;;;;;;;;;;;;:::i;24098:86::-;;;;;;;;;;-1:-1:-1;24169:7:0;;;;24098:86;;;2494:14:1;;2487:22;2469:41;;2457:2;2442:18;24098:86:0;2329:187:1;58239:23:0;;;;;;;;;;-1:-1:-1;58239:23:0;;;;-1:-1:-1;;;;;58239:23:0;;;56113:84;;;;;;;;;;-1:-1:-1;56164:4:0;56113:84;;57482:118;;;;;;;;;;-1:-1:-1;57482:118:0;;;;;:::i;:::-;;:::i;21096:103::-;;;;;;;;;;;;;:::i;55222:127::-;;;;;;;;;;;;;:::i;56757:71::-;;;;;;;;;;;;;:::i;58269:23::-;;;;;;;;;;-1:-1:-1;58269:23:0;;;;-1:-1:-1;;;;;58269:23:0;;;47947:28;;;;;;;;;;-1:-1:-1;47947:28:0;;;;;;;;20455:87;;;;;;;;;;-1:-1:-1;20528:6:0;;-1:-1:-1;;;;;20528:6:0;20455:87;;57168:112;;;;;;;;;;;;;:::i;47541:42::-;;;;;;;;;;-1:-1:-1;47541:42:0;;;;;:::i;:::-;;;;;;;;;;;;;;57608:130;;;;;;;;;;-1:-1:-1;57608:130:0;;;;;:::i;:::-;;:::i;53964:220::-;;;;;;;;;;-1:-1:-1;53964:220:0;;;;;:::i;:::-;;:::i;58208:24::-;;;;;;;;;;-1:-1:-1;58208:24:0;;;;-1:-1:-1;;;;;58208:24:0;;;54420:128;;;;;;;;;;-1:-1:-1;54420:128:0;;;;;:::i;:::-;;:::i;56941:90::-;;;;;;;;;;;;;:::i;54334:78::-;;;;;;;;;;;;;:::i;57288:186::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;53862:94::-;;;;;;;;;;-1:-1:-1;53934:7:0;:14;53862:94;;55416:118;;;;;;;;;;;;;:::i;47631:31::-;;;;;;;;;;-1:-1:-1;47631:31:0;;;;-1:-1:-1;;;;;47631:31:0;;;54192:134;;;;;;;;;;-1:-1:-1;54192:134:0;;;;;:::i;:::-;;:::i;57746:197::-;;;;;;;;;;-1:-1:-1;57746:197:0;;;;;:::i;:::-;;:::i;47813:27::-;;;;;;;;;;-1:-1:-1;47813:27:0;;;;-1:-1:-1;;;;;47813:27:0;;;49892:201;;;;;;;;;;;;;:::i;58301:433::-;;;;;;;;;;-1:-1:-1;58301:433:0;;;;;:::i;:::-;;:::i;47847:26::-;;;;;;;;;;;;;;;;21354:201;;;;;;;;;;-1:-1:-1;21354:201:0;;;;;:::i;:::-;;:::i;47510:24::-;;;;;;;;;;-1:-1:-1;47510:24:0;;;;;:::i;:::-;;:::i;56390:176::-;;;;;;;;;;;;;:::i;47669:20::-;;;;;;;;;;-1:-1:-1;47669:20:0;;;;-1:-1:-1;;;;;47669:20:0;;;54556:284;48643:15;:13;:15::i;:::-;-1:-1:-1;;;;;54630:19:0;::::1;54626:98;;54666:12;:25:::0;;-1:-1:-1;;;;;;54666:25:0::1;::::0;;54556:284;:::o;54626:98::-:1;54751:4;::::0;-1:-1:-1;;;;;54751:4:0;;::::1;54742:13:::0;;::::1;::::0;54734:31:::1;;;::::0;-1:-1:-1;;;54734:31:0;;5497:2:1;54734:31:0::1;::::0;::::1;5479:21:1::0;5536:1;5516:18;;;5509:29;-1:-1:-1;;;5554:18:1;;;5547:35;5599:18;;54734:31:0::1;;;;;;;;;54812:12;:20:::0;;-1:-1:-1;;;;;;54812:20:0::1;-1:-1:-1::0;;;;;54812:20:0;::::1;;::::0;;48669:1:::1;54556:284:::0;:::o;50911:112::-;50982:33;50991:16;51009:5;50982:8;:33::i;55542:256::-;48643:15;:13;:15::i;:::-;55625:16:::1;:36:::0;;-1:-1:-1;;55625:36:0::1;::::0;::::1;;::::0;;::::1;::::0;;;::::1;55676:16:::0;55672:119:::1;;;55724:1;55709:12;:16:::0;54556:284;:::o;55672:119::-:1;55773:6;55758:12;:21:::0;55542:256;:::o;58848:117::-;58927:5;;:30;;-1:-1:-1;;;58927:30:0;;58951:4;58927:30;;;1099:51:1;58903:4:0;;-1:-1:-1;;;;;58927:5:0;;:15;;1072:18:1;;58927:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;58920:37;;58848:117;:::o;50101:449::-;50178:5;;-1:-1:-1;;;;;50178:5:0;50164:10;:19;50156:38;;;;-1:-1:-1;;;50156:38:0;;;;;;;:::i;:::-;50207:15;50225;:13;:15::i;:::-;50207:33;;50267:7;50257;:17;50253:118;;;50291:28;50301:17;50311:7;50301;:17;:::i;:::-;50291:9;:28::i;:::-;50344:15;:13;:15::i;:::-;50334:25;;50253:118;50397:7;50387;:17;50383:67;;;-1:-1:-1;50431:7:0;50383:67;50488:5;;50469:4;;50462:41;;-1:-1:-1;;;;;50469:4:0;;;;50488:5;50495:7;50462:25;:41::i;:::-;50521:21;50530:11;:9;:11::i;:::-;50521:21;;160:25:1;;;148:2;133:18;50521:21:0;;;;;;;50145:405;50101:449;:::o;56836:97::-;48643:15;:13;:15::i;:::-;56895:10:::1;:8;:10::i;:::-;56916:9;:7;:9::i;:::-;56836:97::o:0;54848:300::-;54893:7;54917:12;;54933:1;54917:17;54913:31;;-1:-1:-1;54943:1:0;;54848:300::o;54913:31::-;54955:15;54991:11;;54973:15;:29;;;;:::i;:::-;54955:47;;55013:17;55043:12;;55033:7;:22;:51;;55083:1;55033:51;;;55073:7;55058:12;;:22;;;;:::i;:::-;55013:71;;55128:12;;55116:9;55102:11;;:23;;;;:::i;:::-;:38;;;;:::i;:::-;55095:45;;;;54848:300;:::o;50822:81::-;50869:26;50878:9;50889:5;50869:8;:26::i;56648:101::-;48643:15;:13;:15::i;:::-;56703:7:::1;:5;:7::i;:::-;56721:20;:18;:20::i;57039:121::-:0;57127:7;;:24;;;-1:-1:-1;;;57127:24:0;;;;57086:10;;-1:-1:-1;;;;;57127:7:0;;:22;;:24;;;;;;;;;;;;;;:7;:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;50753:61::-;50798:8;:6;:8::i;55806:105::-;48643:15;:13;:15::i;:::-;55879:12:::1;:24:::0;55806:105::o;58742:98::-;58819:13;;;;;;;;;;;;-1:-1:-1;;;58819:13:0;;;;;58742:98::o;50558:187::-;50615:16;;;;50611:127;;;50670:5;;-1:-1:-1;;;;;50670:5:0;50656:10;:19;50648:38;;;;-1:-1:-1;;;50648:38:0;;;;;;;:::i;:::-;50701:25;50710:9;50721:4;50701:8;:25::i;57482:118::-;20341:13;:11;:13::i;:::-;57546:5:::1;:14:::0;;-1:-1:-1;;;;;;57546:14:0::1;-1:-1:-1::0;;;;;57546:14:0;::::1;::::0;;::::1;::::0;;;57576:16:::1;::::0;1099:51:1;;;57576:16:0::1;::::0;1087:2:1;1072:18;57576:16:0::1;;;;;;;;57482:118:::0;:::o;21096:103::-;20341:13;:11;:13::i;:::-;21161:30:::1;21188:1;21161:18;:30::i;55222:127::-:0;55264:7;55327:14;:12;:14::i;:::-;55309:15;:13;:15::i;:::-;55291;:13;:15::i;:::-;:33;;;;:::i;:::-;:50;;;;:::i;56757:71::-;48643:15;:13;:15::i;:::-;56812:8:::1;:6;:8::i;57168:112::-:0;57245:7;;:27;;;-1:-1:-1;;;57245:27:0;;;;57218:7;;-1:-1:-1;;;;;57245:7:0;;:25;;:27;;;;;;;;;;;;;;:7;:27;;;;;;;;;;;;;;57608:130;20341:13;:11;:13::i;:::-;57676:7:::1;:18:::0;;-1:-1:-1;;;;;;57676:18:0::1;-1:-1:-1::0;;;;;57676:18:0;::::1;::::0;;::::1;::::0;;;57710:20:::1;::::0;1099:51:1;;;57710:20:0::1;::::0;1087:2:1;1072:18;57710:20:0::1;953:203:1::0;53964:220:0;48643:15;:13;:15::i;:::-;54047:4:::1;::::0;-1:-1:-1;;;;;54047:4:0;;::::1;54037:14:::0;;::::1;::::0;54029:32:::1;;;::::0;-1:-1:-1;;;54029:32:0;;5497:2:1;54029:32:0::1;::::0;::::1;5479:21:1::0;5536:1;5516:18;;;5509:29;-1:-1:-1;;;5554:18:1;;;5547:35;5599:18;;54029:32:0::1;5295:328:1::0;54029:32:0::1;54090:6;::::0;-1:-1:-1;;;;;54090:6:0;;::::1;54080:16:::0;;::::1;::::0;54072:36:::1;;;::::0;-1:-1:-1;;;54072:36:0;;7399:2:1;54072:36:0::1;::::0;::::1;7381:21:1::0;7438:1;7418:18;;;7411:29;-1:-1:-1;;;7456:18:1;;;7449:37;7503:18;;54072:36:0::1;7197:330:1::0;54072:36:0::1;54156:7;:20:::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;54156:20:0;;;;;::::1;::::0;;-1:-1:-1;;;;;;54156:20:0::1;-1:-1:-1::0;;;;;54156:20:0;;;::::1;::::0;;;::::1;::::0;;53964:220::o;54420:128::-;48643:15;:13;:15::i;:::-;-1:-1:-1;;;;;54511:17:0;;::::1;;::::0;;;:10:::1;:17;::::0;;;;:29;54420:128::o;56941:90::-;57007:7;;:16;;;-1:-1:-1;;;57007:16:0;;;;56980:7;;-1:-1:-1;;;;;57007:7:0;;:14;;:16;;;;;;;;;;;;;;:7;:16;;;;;;;;;;;;;;54334:78;48643:15;:13;:15::i;:::-;54390:14:::1;54397:7;;54390:14;:::i;57288:186::-:0;57333:25;;:::i;:::-;57378:88;;;;;;;;57397:16;:14;:16::i;:::-;:39;;-1:-1:-1;;;57397:39:0;;57430:4;57397:39;;;1099:51:1;-1:-1:-1;;;;;57397:24:0;;;;;;;1072:18:1;;57397:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;57397:39:0;;;;;;;;;;;;:::i;:::-;57378:88;;;;56164:4;57378:88;;;;56164:4;57378:88;;57371:95;57288:186;-1:-1:-1;57288:186:0:o;55416:118::-;55496:4;;55489:37;;-1:-1:-1;;;55489:37:0;;55520:4;55489:37;;;1099:51:1;55462:7:0;;-1:-1:-1;;;;;55496:4:0;;55489:22;;1072:18:1;;55489:37:0;953:203:1;54192:134:0;48643:15;:13;:15::i;:::-;54267:7:::1;54275:14:::0;;:18:::1;::::0;54292:1:::1;::::0;54275:18:::1;:::i;:::-;54267:27;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;54254:7:::1;:10:::0;;-1:-1:-1;;;;;54267:27:0;;::::1;::::0;54262:1;;54254:10;::::1;;;;;:::i;:::-;;;;;;;;;:40;;;;;-1:-1:-1::0;;;;;54254:40:0::1;;;;;-1:-1:-1::0;;;;;54254:40:0::1;;;;;;54305:7;:13;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;;-1:-1:-1;;54305:13:0;;;;;-1:-1:-1;;;;;;54305:13:0::1;::::0;;;;;-1:-1:-1;54192:134:0:o;57746:197::-;57832:10;;-1:-1:-1;;;;;57832:10:0;57818;:24;57810:48;;;;-1:-1:-1;;;57810:48:0;;10093:2:1;57810:48:0;;;10075:21:1;10132:2;10112:18;;;10105:30;-1:-1:-1;;;10151:18:1;;;10144:41;10202:18;;57810:48:0;9891:335:1;57810:48:0;57869:10;:24;;-1:-1:-1;;;;;;57869:24:0;-1:-1:-1;;;;;57869:24:0;;;;;;;;57909:26;;1099:51:1;;;57909:26:0;;1087:2:1;1072:18;57909:26:0;953:203:1;49892:201:0;24169:7;;;;48485:33;;;;48497:7;;;;;;;;;-1:-1:-1;;;;;48497:7:0;-1:-1:-1;;;;;48497:19:0;;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;48485:71;;;-1:-1:-1;48522:7:0;;-1:-1:-1;;;;;48522:7:0;:21;48544:11;:9;:11::i;:::-;48522:34;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;48481:100;;;48565:16;;-1:-1:-1;;;48565:16:0;;;;;;;;;;;48481:100;49941:15:::1;49959;:13;:15::i;:::-;49941:33:::0;-1:-1:-1;49989:11:0;;49985:101:::1;;50017:17;50026:7;50017:8;:17::i;:::-;50054:20;50062:11;:9;:11::i;:::-;50054:20;::::0;160:25:1;;;148:2;133:18;50054:20:0::1;14:177:1::0;58301:433:0;14179:19;14202:13;;;;;;14201:14;;14249:34;;;;-1:-1:-1;14267:12:0;;14282:1;14267:12;;;;:16;14249:34;14248:108;;;-1:-1:-1;14328:4:0;2955:19;:23;;;14289:66;;-1:-1:-1;14338:12:0;;;;;:17;14289:66;14226:204;;;;-1:-1:-1;;;14226:204:0;;10683:2:1;14226:204:0;;;10665:21:1;10722:2;10702:18;;;10695:30;10761:34;10741:18;;;10734:62;-1:-1:-1;;;10812:18:1;;;10805:44;10866:19;;14226:204:0;10481:410:1;14226:204:0;14441:12;:16;;-1:-1:-1;;14441:16:0;14456:1;14441:16;;;14468:67;;;;14503:13;:20;;-1:-1:-1;;14503:20:0;;;;;14468:67;58494:41:::1;;;::::0;;::::1;::::0;::::1;58514:10:::0;58494:41:::1;:::i;:::-;58526:8;;58494:41;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;58494:19:0::1;::::0;-1:-1:-1;;;58494:41:0:i:1;:::-;58546:5;:27:::0;;-1:-1:-1;;;;;;58546:27:0::1;-1:-1:-1::0;;;;;58546:27:0;::::1;;::::0;;58584:48;::::1;;;58607:25;58627:4;58607:19;:25::i;:::-;58666:4;;;;;;;;;-1:-1:-1::0;;;;;58666:4:0::1;-1:-1:-1::0;;;;;58656:22:0::1;;:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;58645:8;:35:::0;;-1:-1:-1;;;;;;58645:35:0::1;-1:-1:-1::0;;;;;58645:35:0;;::::1;;::::0;;58712:4:::1;::::0;58702:24:::1;::::0;;-1:-1:-1;;;58702:24:0;;;;58712:4;;;::::1;::::0;58702:22:::1;::::0;:24:::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;58712:4;58702:24:::1;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;58691:8;:35:::0;;-1:-1:-1;;;;;;58691:35:0::1;-1:-1:-1::0;;;;;58691:35:0;;;::::1;::::0;;;::::1;::::0;;14557:102;;;;14608:5;14592:21;;-1:-1:-1;;14592:21:0;;;14633:14;;-1:-1:-1;12101:36:1;;14633:14:0;;12089:2:1;12074:18;14633:14:0;;;;;;;;14557:102;14168:498;58301:433;;;;;:::o;21354:201::-;20341:13;:11;:13::i;:::-;-1:-1:-1;;;;;21443:22:0;::::1;21435:73;;;::::0;-1:-1:-1;;;21435:73:0;;12350:2:1;21435:73:0::1;::::0;::::1;12332:21:1::0;12389:2;12369:18;;;12362:30;12428:34;12408:18;;;12401:62;-1:-1:-1;;;12479:18:1;;;12472:36;12525:19;;21435:73:0::1;12148:402:1::0;21435:73:0::1;21519:28;21538:8;21519:18;:28::i;47510:24::-:0;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;47510:24:0;;-1:-1:-1;47510:24:0;:::o;56390:176::-;56455:5;;-1:-1:-1;;;;;56455:5:0;56441:10;:19;56433:38;;;;-1:-1:-1;;;56433:38:0;;;;;;;:::i;:::-;56482:20;:18;:20::i;:::-;56520:4;;56535:5;;-1:-1:-1;;;;;56520:4:0;;;;56513:21;;56535:5;56542:15;:13;:15::i;:::-;56513:45;;-1:-1:-1;;;;;;56513:45:0;;;;;;;-1:-1:-1;;;;;12747:32:1;;;56513:45:0;;;12729:51:1;12796:18;;;12789:34;12702:18;;56513:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;48686:130::-;20528:6;;-1:-1:-1;;;;;20528:6:0;48740:10;:21;;;;:47;;;48779:8;:6;:8::i;:::-;-1:-1:-1;;;;;48765:22:0;:10;-1:-1:-1;;;;;48765:22:0;;;48740:47;48736:72;;;48796:12;;-1:-1:-1;;;48796:12:0;;;;;;;;;;;51086:656;24169:7;;;;48485:33;;;;48497:7;;;;;;;;;-1:-1:-1;;;;;48497:7:0;-1:-1:-1;;;;;48497:19:0;;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;48485:71;;;-1:-1:-1;48522:7:0;;-1:-1:-1;;;;;48522:7:0;:21;48544:11;:9;:11::i;:::-;48522:34;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;48481:100;;;48565:16;;-1:-1:-1;;;48565:16:0;;;;;;;;;;;48481:100;51178:8:::1;:6;:8::i;:::-;51197:22;:20;:22::i;:::-;51257:6;::::0;51250:39:::1;::::0;-1:-1:-1;;;51250:39:0;;51283:4:::1;51250:39;::::0;::::1;1099:51:1::0;51230:17:0::1;::::0;-1:-1:-1;;;;;51257:6:0::1;::::0;51250:24:::1;::::0;1072:18:1;;51250:39:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;51327:6;::::0;-1:-1:-1;;;;;51327:6:0::1;51316:18;::::0;;;:10:::1;:18;::::0;;;;;51230:59;;-1:-1:-1;51304:30:0;::::1;51300:435;;;51351:29;51363:16;51351:11;:29::i;:::-;51397:19;:17;:19::i;:::-;51431:21;51455:15;:13;:15::i;:::-;51431:39;;51515:14;:12;:14::i;:::-;51499:30;::::0;:13;:30:::1;:::i;:::-;51485:11;:44:::0;51558:15:::1;51544:11;:29:::0;51595:9;51590:60:::1;;51625:9;:7;:9::i;:::-;51684:10;51671:52;51696:13:::0;51711:11:::1;:9;:11::i;:::-;51671:52;::::0;;13008:25:1;;;13064:2;13049:18;;13042:34;;;;12981:18;51671:52:0::1;;;;;;;51336:399;51300:435;51167:575;51086:656:::0;;:::o;59130:133::-;59195:10;;59191:65;;59222:5;;:22;;-1:-1:-1;;;59222:22:0;;;;;160:25:1;;;-1:-1:-1;;;;;59222:5:0;;;;:14;;133:18:1;;59222:22:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59130:133;:::o;39875:162::-;39985:43;;-1:-1:-1;;;;;12747:32:1;;;39985:43:0;;;12729:51:1;12796:18;;;12789:34;;;39958:71:0;;39978:5;;40000:14;;;;;12702:18:1;;39985:43:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;39985:43:0;;;;;;;;;;;39958:19;:71::i;24953:120::-;23962:16;:14;:16::i;:::-;25012:7:::1;:15:::0;;-1:-1:-1;;25012:15:0::1;::::0;;25043:22:::1;18577:10:::0;25052:12:::1;25043:22;::::0;-1:-1:-1;;;;;1117:32:1;;;1099:51;;1087:2;1072:18;25043:22:0::1;;;;;;;24953:120::o:0;59271:239::-;59330:11;59344:15;:13;:15::i;:::-;59330:29;-1:-1:-1;59374:10:0;;59370:133;;59405:5;;;;;;;;;-1:-1:-1;;;;;59405:5:0;-1:-1:-1;;;;;59405:15:0;;:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;59401:90;;;59424:5;;;;;;;;;-1:-1:-1;;;;;59424:5:0;-1:-1:-1;;;;;59424:23:0;;:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59401:90;59469:5;;:22;;-1:-1:-1;;;59469:22:0;;;;;160:25:1;;;-1:-1:-1;;;;;59469:5:0;;;;:14;;133:18:1;;59469:22:0;14:177:1;59518:72:0;59565:5;;;;;;;;;-1:-1:-1;;;;;59565:5:0;-1:-1:-1;;;;;59565:15:0;;:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;59518:72::o;20620:132::-;20528:6;;-1:-1:-1;;;;;20528:6:0;18577:10;20684:23;20676:68;;;;-1:-1:-1;;;20676:68:0;;13289:2:1;20676:68:0;;;13271:21:1;;;13308:18;;;13301:30;13367:34;13347:18;;;13340:62;13419:18;;20676:68:0;13087:356:1;21715:191:0;21808:6;;;-1:-1:-1;;;;;21825:17:0;;;-1:-1:-1;;;;;;21825:17:0;;;;;;;21858:40;;21808:6;;;21825:17;21808:6;;21858:40;;21789:16;;21858:40;21778:128;21715:191;:::o;24694:118::-;23703:19;:17;:19::i;:::-;24754:7:::1;:14:::0;;-1:-1:-1;;24754:14:0::1;24764:4;24754:14;::::0;;24784:20:::1;24791:12;18577:10:::0;;18497:98;58973:149;59067:5;;59040:4;;59033:49;;-1:-1:-1;;;;;59040:4:0;;;;59067:5;59075:6;59033:25;:49::i;:::-;59093:5;;:21;;-1:-1:-1;;;59093:21:0;;;;;160:25:1;;;-1:-1:-1;;;;;59093:5:0;;;;:13;;133:18:1;;59093:21:0;14:177:1;48824:604:0;16322:13;;;;;;;16314:69;;;;-1:-1:-1;;;16314:69:0;;;;;;;:::i;:::-;48946:16:::1;:14;:16::i;:::-;48973:17;:15;:17::i;:::-;49008:15:::0;;49001:4:::1;:22:::0;;-1:-1:-1;;;;;;49001:22:0;;::::1;-1:-1:-1::0;;;;;49001:22:0;;::::1;;::::0;;;49061:18:::1;::::0;;::::1;::::0;49034:7:::1;:46:::0;;;::::1;::::0;;::::1;::::0;;::::1;::::0;;49099:16:::1;::::0;::::1;::::0;49091:5:::1;:24:::0;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;49136:18:::1;::::0;::::1;::::0;49126:7:::1;:28:::0;;;::::1;::::0;;::::1;::::0;;;::::1;::::0;;49178:21:::1;::::0;::::1;::::0;49165:10:::1;:34:::0;;;;::::1;::::0;::::1;::::0;;;::::1;::::0;;;49219:16;;-1:-1:-1;;;49219:16:0;;;;:14:::1;::::0;-1:-1:-1;49219:16:0;;::::1;::::0;::::1;::::0;;;;;;;;;49034:46;49219:16:::1;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;49210:6;:25:::0;;-1:-1:-1;;;;;;49210:25:0::1;-1:-1:-1::0;;;;;49210:25:0;;;::::1;::::0;;;::::1;::::0;;-1:-1:-1;49248:88:0::1;49265:8;:15;49261:1;:19;49248:88;;;49302:22;49312:8;49321:1;49312:11;;;;;;;;:::i;:::-;;;;;;;49302:9;:22::i;:::-;49282:3;;49248:88;;;;49346:40;49362:10;:23;;;49346:15;:40::i;:::-;-1:-1:-1::0;;49414:6:0::1;49399:12;:21:::0;48824:604::o;51750:549::-;51815:6;51810:482;51827:7;:14;51823:18;;51810:482;;;51863:13;51879:7;51887:1;51879:10;;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;;;;51879:10:0;;-1:-1:-1;;;51908:60:0;;51904:377;;52004:6;;;;;;;;;-1:-1:-1;;;;;52004:6:0;-1:-1:-1;;;;;51989:30:0;;52027:21;51989:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51904:377;;;52106:38;;-1:-1:-1;;;52106:38:0;;52138:4;52106:38;;;1099:51:1;52092:11:0;;-1:-1:-1;;;;;52106:23:0;;;;;1072:18:1;;52106:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;52176:17:0;;;;;;:10;:17;;;;;;52092:52;;-1:-1:-1;52167:26:0;;52163:103;;;52231:6;;52218:28;;52224:5;;-1:-1:-1;;;;;52231:6:0;52239;52218:5;:28::i;:::-;52073:208;51904:377;-1:-1:-1;51843:3:0;;51810:482;;52332:760;52399:34;52436:16;:14;:16::i;:::-;:39;;-1:-1:-1;;;52436:39:0;;52469:4;52436:39;;;1099:51:1;-1:-1:-1;;;;;52436:24:0;;;;;;;1072:18:1;;52436:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;52436:39:0;;;;;;;;;;;;:::i;:::-;52548:10;;52513:6;;52506:39;;-1:-1:-1;;;52506:39:0;;52539:4;52506:39;;;1099:51:1;52548:10:0;;-1:-1:-1;52486:17:0;;48011:7;;52548:10;-1:-1:-1;;;;;52513:6:0;;52506:24;;1072:18:1;;52506:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:52;;;;:::i;:::-;:62;;;;:::i;:::-;52486:82;;52581:21;48011:7;52617:4;:9;;;52605;:21;;;;:::i;:::-;:31;;;;:::i;:::-;52654:6;;52581:55;;-1:-1:-1;52647:60:0;;-1:-1:-1;;;;;52654:6:0;52675:16;52581:55;52647:27;:60::i;:::-;52720:22;48011:7;52757:4;:10;;;52745:9;:22;;;;:::i;:::-;:32;;;;:::i;:::-;52720:57;;52788:64;52816:19;:17;:19::i;:::-;52795:6;;-1:-1:-1;;;;;52795:6:0;;52837:14;52788:27;:64::i;:::-;52865:27;48011:7;52907:4;:15;;;52895:9;:27;;;;:::i;:::-;:37;;;;:::i;:::-;52971:10;;52950:6;;52865:67;;-1:-1:-1;52943:60:0;;-1:-1:-1;;;;;52950:6:0;;;;52971:10;52865:67;52943:27;:60::i;:::-;53021:63;;;14062:25:1;;;14118:2;14103:18;;14096:34;;;14146:18;;;14139:34;;;53021:63:0;;14050:2:1;14035:18;53021:63:0;13860:319:1;59674:488:0;59752:6;;59736:12;;-1:-1:-1;;;;;59736:12:0;;;59752:6;;59736:22;59732:82;;59781:6;;59789:12;;59775:27;;-1:-1:-1;;;;;59781:6:0;;;;59789:12;59775:5;:27::i;:::-;59849:12;;59842:45;;-1:-1:-1;;;59842:45:0;;59881:4;59842:45;;;1099:51:1;59824:15:0;;-1:-1:-1;;;;;59849:12:0;;59842:30;;1072:18:1;;59842:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;59931:8;;59915:12;;59824:63;;-1:-1:-1;59900:12:0;;-1:-1:-1;;;;;59915:12:0;;;59931:8;;59915:24;:41;;59955:1;59915:41;;;59942:10;59915:41;59998:8;;59982:12;;59900:56;;-1:-1:-1;59967:12:0;;-1:-1:-1;;;;;59982:12:0;;;59998:8;;59982:24;:41;;60022:1;59982:41;;;60009:10;59982:41;60070:4;;60043:12;;59967:56;;-1:-1:-1;60036:51:0;;-1:-1:-1;;;;;60043:12:0;;;;60070:4;60076:10;60036:33;:51::i;:::-;60108:4;;60098:56;;-1:-1:-1;;;60098:56:0;;;;;14386:25:1;;;14427:18;;;14420:34;;;60148:4:0;14470:18:1;;;14463:60;-1:-1:-1;;;;;60108:4:0;;;;60098:23;;14359:18:1;;60098:56:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;42686:638::-;43110:23;43136:33;-1:-1:-1;;;;;43136:27:0;;43164:4;43136:27;:33::i;:::-;43110:59;;43184:10;:17;43205:1;43184:22;;:57;;;;;43222:10;43211:30;;;;;;;;;;;;:::i;:::-;43210:31;43184:57;43180:137;;;43265:40;;-1:-1:-1;;;43265:40:0;;-1:-1:-1;;;;;1117:32:1;;43265:40:0;;;1099:51:1;1072:18;;43265:40:0;953:203:1;24442:108:0;24169:7;;;;24501:41;;;;-1:-1:-1;;;24501:41:0;;14736:2:1;24501:41:0;;;14718:21:1;14775:2;14755:18;;;14748:30;-1:-1:-1;;;14794:18:1;;;14787:50;14854:18;;24501:41:0;14534:344:1;24257:108:0;24169:7;;;;24327:9;24319:38;;;;-1:-1:-1;;;24319:38:0;;15085:2:1;24319:38:0;;;15067:21:1;15124:2;15104:18;;;15097:30;-1:-1:-1;;;15143:18:1;;;15136:46;15199:18;;24319:38:0;14883:340:1;41908:387:0;42024:47;;;-1:-1:-1;;;;;12747:32:1;;42024:47:0;;;12729:51:1;12796:18;;;;12789:34;;;42024:47:0;;;;;;;;;;12702:18:1;;;;42024:47:0;;;;;;;;-1:-1:-1;;;;;42024:47:0;-1:-1:-1;;;42024:47:0;;;42089:44;42039:13;42024:47;42089:23;:44::i;:::-;42084:204;;42177:43;;-1:-1:-1;;;;;12747:32:1;;;42177:43:0;;;12729:51:1;42217:1:0;12796:18:1;;;12789:34;42150:71:0;;42170:5;;42192:13;;;;;12702:18:1;;42177:43:0;12555:274:1;42150:71:0;42236:40;42256:5;42263:12;42236:19;:40::i;19998:97::-;16322:13;;;;;;;16314:69;;;;-1:-1:-1;;;16314:69:0;;;;;;;:::i;:::-;20061:26:::1;:24;:26::i;23268:99::-:0;16322:13;;;;;;;16314:69;;;;-1:-1:-1;;;16314:69:0;;;;;;;:::i;:::-;23332:27:::1;:25;:27::i;53593:261::-:0;53694:7;-1:-1:-1;;;;;53681:20:0;:9;-1:-1:-1;;;;;53681:20:0;;53677:170;;53749:7;;53718:47;;-1:-1:-1;;;;;53718:30:0;;;;53749:7;53758:6;53718:30;:47::i;:::-;53794:7;;53780:55;;-1:-1:-1;;;53780:55:0;;-1:-1:-1;;;;;15773:15:1;;;53780:55:0;;;15755:34:1;15825:15;;;15805:18;;;15798:43;15857:18;;;15850:34;;;53794:7:0;;;;53780:27;;15690:18:1;;53780:55:0;15515:375:1;53412:173:0;53494:42;;-1:-1:-1;;;53494:42:0;;53530:4;53494:42;;;1099:51:1;53483:8:0;;-1:-1:-1;;;;;53494:27:0;;;;;1072:18:1;;53494:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;53483:53;;53547:30;53553:9;53564:7;53573:3;53547:5;:30::i;35003:153::-;35078:12;35110:38;35132:6;35140:4;35146:1;35110:21;:38::i;:::-;35103:45;;35003:153;;;;;:::o;43835:585::-;43918:4;44225:12;44239:23;44274:5;-1:-1:-1;;;;;44266:19:0;44286:4;44266:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44224:67;;;;44309:7;:69;;;;-1:-1:-1;44321:17:0;;:22;;:56;;;44358:10;44347:30;;;;;;;;;;;;:::i;:::-;44309:103;;;;;44411:1;44390:5;-1:-1:-1;;;;;44382:26:0;;:30;44309:103;44302:110;43835:585;-1:-1:-1;;;;;43835:585:0:o;20103:113::-;16322:13;;;;;;;16314:69;;;;-1:-1:-1;;;16314:69:0;;;;;;;:::i;:::-;20176:32:::1;18577:10:::0;20176:18:::1;:32::i;23375:97::-:0;16322:13;;;;;;;16314:69;;;;-1:-1:-1;;;16314:69:0;;;;;;;:::i;:::-;23449:7:::1;:15:::0;;-1:-1:-1;;23449:15:0::1;::::0;;23375:97::o;35491:398::-;35590:12;35643:5;35619:21;:29;35615:110;;;35672:41;;-1:-1:-1;;;35672:41:0;;35707:4;35672:41;;;1099:51:1;1072:18;;35672:41:0;953:203:1;35615:110:0;35736:12;35750:23;35777:6;-1:-1:-1;;;;;35777:11:0;35796:5;35803:4;35777:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35735:73;;;;35826:55;35853:6;35861:7;35870:10;35826:26;:55::i;:::-;35819:62;;;;35491:398;;;;;;:::o;36967:597::-;37115:12;37145:7;37140:417;;37169:19;37177:10;37169:7;:19::i;:::-;37140:417;;;37397:17;;:22;:49;;;;-1:-1:-1;;;;;;37423:18:0;;;:23;37397:49;37393:121;;;37474:24;;-1:-1:-1;;;37474:24:0;;-1:-1:-1;;;;;1117:32:1;;37474:24:0;;;1099:51:1;1072:18;;37474:24:0;953:203:1;37393:121:0;-1:-1:-1;37535:10:0;37528:17;;38117:528;38250:17;;:21;38246:392;;38482:10;38476:17;38539:15;38526:10;38522:2;38518:19;38511:44;38246:392;38609:17;;-1:-1:-1;;;38609:17:0;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;:::o;196:131:1:-;-1:-1:-1;;;;;271:31:1;;261:42;;251:70;;317:1;314;307:12;332:247;391:6;444:2;432:9;423:7;419:23;415:32;412:52;;;460:1;457;450:12;412:52;499:9;486:23;518:31;543:5;518:31;:::i;584:118::-;670:5;663:13;656:21;649:5;646:32;636:60;;692:1;689;682:12;707:241;763:6;816:2;804:9;795:7;791:23;787:32;784:52;;;832:1;829;822:12;784:52;871:9;858:23;890:28;912:5;890:28;:::i;1161:180::-;1220:6;1273:2;1261:9;1252:7;1248:23;1244:32;1241:52;;;1289:1;1286;1279:12;1241:52;-1:-1:-1;1312:23:1;;1161:180;-1:-1:-1;1161:180:1:o;1573:250::-;1658:1;1668:113;1682:6;1679:1;1676:13;1668:113;;;1758:11;;;1752:18;1739:11;;;1732:39;1704:2;1697:10;1668:113;;;-1:-1:-1;;1815:1:1;1797:16;;1790:27;1573:250::o;1828:271::-;1870:3;1908:5;1902:12;1935:6;1930:3;1923:19;1951:76;2020:6;2013:4;2008:3;2004:14;1997:4;1990:5;1986:16;1951:76;:::i;:::-;2081:2;2060:15;-1:-1:-1;;2056:29:1;2047:39;;;;2088:4;2043:50;;1828:271;-1:-1:-1;;1828:271:1:o;2104:220::-;2253:2;2242:9;2235:21;2216:4;2273:45;2314:2;2303:9;2299:18;2291:6;2273:45;:::i;2747:315::-;2815:6;2823;2876:2;2864:9;2855:7;2851:23;2847:32;2844:52;;;2892:1;2889;2882:12;2844:52;2931:9;2918:23;2950:31;2975:5;2950:31;:::i;:::-;3000:5;3052:2;3037:18;;;;3024:32;;-1:-1:-1;;;2747:315:1:o;3067:940::-;3246:2;3235:9;3228:21;3209:4;3284:6;3278:13;3327:4;3322:2;3311:9;3307:18;3300:32;3375:12;3369:19;3363:3;3352:9;3348:19;3341:48;3450:2;3436:12;3432:21;3426:28;3420:3;3409:9;3405:19;3398:57;3517:4;3503:12;3499:23;3493:30;3486:4;3475:9;3471:20;3464:60;3585:4;3571:12;3567:23;3561:30;3555:3;3544:9;3540:19;3533:59;3647:3;3633:12;3629:22;3623:29;3689:4;3683:3;3672:9;3668:19;3661:33;3717:54;3766:3;3755:9;3751:19;3735:14;3717:54;:::i;:::-;3703:68;;3846:3;3832:12;3828:22;3822:29;3815:37;3808:45;3802:3;3791:9;3787:19;3780:74;3910:2;3902:6;3898:15;3892:22;3885:4;3874:9;3870:20;3863:52;3971:4;3963:6;3959:17;3953:24;3946:4;3935:9;3931:20;3924:54;3995:6;3987:14;;;;3067:940;;;;:::o;4245:1045::-;4384:6;4392;4400;4408;4416;4460:9;4451:7;4447:23;4490:3;4486:2;4482:12;4479:32;;;4507:1;4504;4497:12;4479:32;4546:9;4533:23;4565:31;4590:5;4565:31;:::i;:::-;4615:5;-1:-1:-1;4672:2:1;4657:18;;4644:32;4685:30;4644:32;4685:30;:::i;:::-;4734:7;-1:-1:-1;4792:2:1;4777:18;;4764:32;4815:18;4845:14;;;4842:34;;;4872:1;4869;4862:12;4842:34;4910:6;4899:9;4895:22;4885:32;;4955:7;4948:4;4944:2;4940:13;4936:27;4926:55;;4977:1;4974;4967:12;4926:55;5017:2;5004:16;5043:2;5035:6;5032:14;5029:34;;;5059:1;5056;5049:12;5029:34;5112:7;5107:2;5097:6;5094:1;5090:14;5086:2;5082:23;5078:32;5075:45;5072:65;;;5133:1;5130;5123:12;5072:65;5164:2;5156:11;;;;;-1:-1:-1;5186:6:1;;-1:-1:-1;;5226:3:1;-1:-1:-1;;5208:16:1;;5204:26;5201:46;;;5243:1;5240;5233:12;5201:46;;5281:2;5270:9;5266:18;5256:28;;4245:1045;;;;;;;;:::o;5628:184::-;5698:6;5751:2;5739:9;5730:7;5726:23;5722:32;5719:52;;;5767:1;5764;5757:12;5719:52;-1:-1:-1;5790:16:1;;5628:184;-1:-1:-1;5628:184:1:o;5817:329::-;6019:2;6001:21;;;6058:1;6038:18;;;6031:29;-1:-1:-1;;;6091:2:1;6076:18;;6069:36;6137:2;6122:18;;5817:329::o;6151:127::-;6212:10;6207:3;6203:20;6200:1;6193:31;6243:4;6240:1;6233:15;6267:4;6264:1;6257:15;6283:128;6350:9;;;6371:11;;;6368:37;;;6385:18;;:::i;6416:168::-;6489:9;;;6520;;6537:15;;;6531:22;;6517:37;6507:71;;6558:18;;:::i;6589:217::-;6629:1;6655;6645:132;;6699:10;6694:3;6690:20;6687:1;6680:31;6734:4;6731:1;6724:15;6762:4;6759:1;6752:15;6645:132;-1:-1:-1;6791:9:1;;6589:217::o;6811:251::-;6881:6;6934:2;6922:9;6913:7;6909:23;6905:32;6902:52;;;6950:1;6947;6940:12;6902:52;6982:9;6976:16;7001:31;7026:5;7001:31;:::i;7067:125::-;7132:9;;;7153:10;;;7150:36;;;7166:18;;:::i;7532:127::-;7593:10;7588:3;7584:20;7581:1;7574:31;7624:4;7621:1;7614:15;7648:4;7645:1;7638:15;7664:253;7736:2;7730:9;7778:4;7766:17;;7813:18;7798:34;;7834:22;;;7795:62;7792:88;;;7860:18;;:::i;:::-;7896:2;7889:22;7664:253;:::o;7922:275::-;7993:2;7987:9;8058:2;8039:13;;-1:-1:-1;;8035:27:1;8023:40;;8093:18;8078:34;;8114:22;;;8075:62;8072:88;;;8140:18;;:::i;:::-;8176:2;8169:22;7922:275;;-1:-1:-1;7922:275:1:o;8202:132::-;8278:13;;8300:28;8278:13;8300:28;:::i;:::-;8202:132;;;:::o;8339:1283::-;8438:6;8469:2;8512;8500:9;8491:7;8487:23;8483:32;8480:52;;;8528:1;8525;8518:12;8480:52;8561:9;8555:16;8590:18;8631:2;8623:6;8620:14;8617:34;;;8647:1;8644;8637:12;8617:34;8670:22;;;;8726:4;8708:16;;;8704:27;8701:47;;;8744:1;8741;8734:12;8701:47;8770:22;;:::i;:::-;8821:2;8815:9;8808:5;8801:24;8871:2;8867;8863:11;8857:18;8852:2;8845:5;8841:14;8834:42;8922:2;8918;8914:11;8908:18;8903:2;8896:5;8892:14;8885:42;8973:2;8969;8965:11;8959:18;8954:2;8947:5;8943:14;8936:42;9017:3;9013:2;9009:12;9003:19;9047:2;9037:8;9034:16;9031:36;;;9063:1;9060;9053:12;9031:36;9086:17;;9134:4;9126:13;;9122:27;-1:-1:-1;9112:55:1;;9163:1;9160;9153:12;9112:55;9192:2;9186:9;9214:2;9210;9207:10;9204:36;;;9220:18;;:::i;:::-;9262:53;9305:2;9286:13;;-1:-1:-1;;9282:27:1;9278:36;;9262:53;:::i;:::-;9249:66;;9338:2;9331:5;9324:17;9378:7;9373:2;9368;9364;9360:11;9356:20;9353:33;9350:53;;;9399:1;9396;9389:12;9350:53;9412:67;9476:2;9471;9464:5;9460:14;9455:2;9451;9447:11;9412:67;:::i;:::-;;;9512:5;9506:3;9499:5;9495:15;9488:30;9551:40;9586:3;9582:2;9578:12;9551:40;:::i;:::-;9545:3;9534:15;;9527:65;9538:5;8339:1283;-1:-1:-1;;;;;;8339:1283:1:o;9627:127::-;9688:10;9683:3;9679:20;9676:1;9669:31;9719:4;9716:1;9709:15;9743:4;9740:1;9733:15;9759:127;9820:10;9815:3;9811:20;9808:1;9801:31;9851:4;9848:1;9841:15;9875:4;9872:1;9865:15;10231:245;10298:6;10351:2;10339:9;10330:7;10326:23;10322:32;10319:52;;;10367:1;10364;10357:12;10319:52;10399:9;10393:16;10418:28;10440:5;10418:28;:::i;10896:1048::-;10982:6;11035:3;11023:9;11014:7;11010:23;11006:33;11003:53;;;11052:1;11049;11042:12;11003:53;11078:22;;:::i;:::-;11137:9;11124:23;11156:33;11181:7;11156:33;:::i;:::-;11198:22;;11272:2;11257:18;;11244:32;11285:33;11244:32;11285:33;:::i;:::-;11345:2;11334:14;;11327:31;11410:2;11395:18;;11382:32;11423:33;11382:32;11423:33;:::i;:::-;11483:2;11472:14;;11465:31;11548:2;11533:18;;11520:32;11561:33;11520:32;11561:33;:::i;:::-;11621:2;11610:14;;11603:31;11686:3;11671:19;;11658:33;11700;11658;11700;:::i;:::-;11760:3;11749:15;;11742:32;11826:3;11811:19;;11798:33;11840;11798;11840;:::i;:::-;11900:3;11889:15;;11882:32;11893:5;10896:1048;-1:-1:-1;;;10896:1048:1:o;13448:407::-;13650:2;13632:21;;;13689:2;13669:18;;;13662:30;13728:34;13723:2;13708:18;;13701:62;-1:-1:-1;;;13794:2:1;13779:18;;13772:41;13845:3;13830:19;;13448:407::o;15895:287::-;16024:3;16062:6;16056:13;16078:66;16137:6;16132:3;16125:4;16117:6;16113:17;16078:66;:::i;:::-;16160:16;;;;;15895:287;-1:-1:-1;;15895:287:1:o

Swarm Source

ipfs://085b0d9fc99433ed2a9d09ff7bd470df49b6c1177fdc399545bf14ca1baf98fd

Block		Transaction	Gas Used	Reward

view all blocks produced

Block		Uncle Number	Difficulty	Gas Used	Reward

View All Uncles

Validator Index	Block		Amount

View All Withdrawals

Transaction Hash	Block		Value	Eth2 PubKey	Valid

View All Deposits

Multichain Portfolio | 30 Chains

Display all chains •

Last updated: less than 1 sec ago

Chain	Token	Portfolio %	Price	Amount	Value
GLMR	StellaSwap (STELLA)	100.00%	$0.050724	203.8173	$10.34

A contract address hosts a smart contract, which is a set of code stored on the blockchain that runs when predetermined conditions are met. Learn more about addresses in our Knowledge Base.

Tools & Services