Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

/**
 *Submitted for verification at fraxscan.com on 2024-05-01
*/

// SPDX-License-Identifier: MIT
// 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/interfaces/convex/IConvex.sol


pragma solidity >=0.6.0 <0.9.0;

interface IConvexBooster {
    function deposit(uint256 pid, uint256 amount, bool stake) external returns (bool);
    function earmarkRewards(uint256 _pid) external;
    function poolInfo(uint256 pid) external view returns (
        address lptoken,
        address token,
        address gauge,
        address crvRewards,
        address stash,
        bool shutdown
    );
}

interface IConvexBoosterL2 {
    function deposit(uint256 _pid, uint256 _amount) external returns (bool);
    function poolInfo(uint256 pid) external view returns (
        address lptoken, //the curve lp token
        address gauge, //the curve gauge
        address rewards, //the main reward/staking contract
        bool shutdown, //is this pool shutdown?
        address factory //a reference to the curve factory used to create this pool (needed for minting crv)
    );
}

interface IConvexRewardPool {
    function balanceOf(address account) external view returns (uint256);
    function earned(address account) external view returns (uint256);
    function periodFinish() external view returns (uint256);
    function getReward() external;
    function getReward(address _account, bool _claimExtras) external;
    function getReward(address _account) external;
    function withdrawAndUnwrap(uint256 _amount, bool claim) external;
    function withdrawAllAndUnwrap(bool claim) external;

    // L2 interface
    function withdraw(uint256 _amount, bool _claim) external;
    function emergencyWithdraw(uint256 _amount) external;
}

// File: contracts/BIFI/interfaces/curve/ICrvMinter.sol


pragma solidity >=0.6.0;

interface ICrvMinter {
    function mint(address _gauge) external;
}

// File: contracts/BIFI/interfaces/curve/IRewardsGauge.sol


pragma solidity >=0.6.0 <0.9.0;

interface IRewardsGauge {
    function balanceOf(address account) external view returns (uint256);
    function claimable_reward(address _addr, address _token) external view returns (uint256);
    function claim_rewards(address _addr) external;
    function deposit(uint256 _value) external;
    function withdraw(uint256 _value) external;
    function reward_contract() external view returns (address);
}

// 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);

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

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

pragma solidity ^0.8.0;

interface IStrategyFactory {
    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/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 calldata _addresses, address[] calldata _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 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 {
        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 onlyManager {
        pause();
        _emergencyWithdraw();
    }

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

    function unpause() external 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 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/Curve/StrategyCurveConvexFraxtalFactory.sol


pragma solidity ^0.8.0;





// Curve L2 strategy switchable between Curve and Convex
contract StrategyCurveConvexFraxtalFactory is BaseAllToNativeFactoryStrat {
    using SafeERC20 for IERC20;

    // this `pid` means we using Curve gauge and not Convex rewardPool
    uint constant public NO_PID = 42069;

    IConvexBoosterL2 public constant booster = IConvexBoosterL2(0xd3327cb05a8E0095A543D582b5B3Ce3e19270389);
    ICrvMinter public constant minter = ICrvMinter(0xeF672bD94913CB6f1d2812a6e18c1fFdEd8eFf5c);

    address public gauge; // curve gauge
    address public rewardPool; // convex base reward pool
    uint public pid; // convex booster poolId

    bool public isCrvMintable; // if CRV can be minted via Minter (gauge is added to Controller)
    bool public isCurveRewardsClaimable; // if extra rewards in curve gauge should be claimed

    function initialize(
        address _gauge,
        uint _pid,
        address[] calldata _rewards,
        address delegationRegistry,
        address initialDelegate,
        Addresses calldata _addresses
    ) public initializer {
        gauge = _gauge;
        pid = _pid;

        if (_rewards.length > 1) {
            isCurveRewardsClaimable = true;
        }
        if (_pid != NO_PID) {
            (,,rewardPool,,) = booster.poolInfo(_pid);
        } else {
            isCrvMintable = true;
        }
        __BaseStrategy_init(_addresses, _rewards);
        setHarvestOnDeposit(true);

        if (delegationRegistry != address(0)) {
            bool res;
            (res,) = delegationRegistry.call(abi.encodeWithSignature("setDelegationForSelf(address)", initialDelegate));
            (res,) = delegationRegistry.call(abi.encodeWithSignature("disableSelfManagingDelegations()"));
        }
    }

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

    function balanceOfPool() public view override returns (uint) {
        if (rewardPool != address(0)) {
            return IConvexRewardPool(rewardPool).balanceOf(address(this));
        } else {
            return IRewardsGauge(gauge).balanceOf(address(this));
        }
    }

    function _deposit(uint amount) internal override {
        if (rewardPool != address(0)) {
            IERC20(want).forceApprove(address(booster), amount);
            booster.deposit(pid, amount);
        } else {
            IERC20(want).forceApprove(gauge, amount);
            IRewardsGauge(gauge).deposit(amount);
        }
    }

    function _withdraw(uint amount) internal override {
        if (amount > 0) {
            if (rewardPool != address(0)) {
                IConvexRewardPool(rewardPool).withdraw(amount, false);
            } else {
                IRewardsGauge(gauge).withdraw(amount);
            }
        }
    }

    function _emergencyWithdraw() internal override {
        uint amount = balanceOfPool();
        if (amount > 0) {
            if (rewardPool != address(0)) {
                IConvexRewardPool(rewardPool).emergencyWithdraw(amount);
            } else {
                IRewardsGauge(gauge).withdraw(amount);
            }
        }
    }

    function _claim() internal override {
        if (rewardPool != address(0)) {
            IConvexRewardPool(rewardPool).getReward(address(this));
        } else {
            if (isCrvMintable) minter.mint(gauge);
            if (isCurveRewardsClaimable) IRewardsGauge(gauge).claim_rewards(address(this));
        }
    }

    function _verifyRewardToken(address token) internal view override {
        require(token != gauge, "!gauge");
        require(token != rewardPool, "!rewardPool");
    }

    function setConvexPid(uint _pid) external onlyOwner {
        _withdraw(balanceOfPool());
        if (_pid != NO_PID) {
            (,,rewardPool,,) = booster.poolInfo(_pid);
        } else {
            rewardPool = address(0);
        }
        pid = _pid;
        deposit();
    }

    function setCrvMintable(bool _isCrvMintable) external onlyManager {
        isCrvMintable = _isCrvMintable;
    }

    function setCurveRewardsClaimable(bool _isCurveRewardsClaimable) external onlyManager {
        isCurveRewardsClaimable = _isCurveRewardsClaimable;
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"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":[],"name":"NO_PID","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"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":"booster","outputs":[{"internalType":"contract IConvexBoosterL2","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"callReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":"address","name":"","type":"address"}],"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":"uint256","name":"_pid","type":"uint256"},{"internalType":"address[]","name":"_rewards","type":"address[]"},{"internalType":"address","name":"delegationRegistry","type":"address"},{"internalType":"address","name":"initialDelegate","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":"isCrvMintable","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isCurveRewardsClaimable","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"keeper","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"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":[{"internalType":"address","name":"","type":"address"}],"name":"minAmounts","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"minter","outputs":[{"internalType":"contract ICrvMinter","name":"","type":"address"}],"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":[],"name":"pid","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[],"name":"rewardPool","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","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":"uint256","name":"_pid","type":"uint256"}],"name":"setConvexPid","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_isCrvMintable","type":"bool"}],"name":"setCrvMintable","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"_isCurveRewardsClaimable","type":"bool"}],"name":"setCurveRewardsClaimable","outputs":[],"stateMutability":"nonpayable","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"}]

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

58560:4261:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48613:27;;;;;;;;;;;;;;;;;;;160:25:1;;;148:2;133:18;48613:27:0;;;;;;;;58902:90;;;;;;;;;;;;58949:42;58902:90;;;;;-1:-1:-1;;;;;378:32:1;;;360:51;;348:2;333:18;58902:90:0;196:221:1;55135:284:0;;;;;;;;;;-1:-1:-1;55135:284:0;;;;;:::i;:::-;;:::i;:::-;;51546:112;;;;;;;;;;-1:-1:-1;51546:112:0;;;;;:::i;:::-;;:::i;56121:256::-;;;;;;;;;;-1:-1:-1;56121:256:0;;;;;:::i;:::-;;:::i;60414:282::-;;;;;;;;;;;;;:::i;48485:21::-;;;;;;;;;;-1:-1:-1;48485:21:0;;;;-1:-1:-1;;;;;48485:21:0;;;48459:19;;;;;;;;;;-1:-1:-1;48459:19:0;;;;-1:-1:-1;;;;;48459:19:0;;;48425:25;;;;;;;;;;-1:-1:-1;48425:25:0;;;;-1:-1:-1;;;;;48425:25:0;;;48396:22;;;;;;;;;;-1:-1:-1;48396:22:0;;;;-1:-1:-1;;;;;48396:22:0;;;50805:449;;;;;;;;;;-1:-1:-1;50805:449:0;;;;;:::i;:::-;;:::i;59151:25::-;;;;;;;;;;-1:-1:-1;59151:25:0;;;;;;;;;;;1876:14:1;;1869:22;1851:41;;1839:2;1824:18;59151:25:0;1711:187:1;57399:89:0;;;;;;;;;;;;;:::i;55427:300::-;;;;;;;;;;;;;:::i;51457:81::-;;;;;;;;;;;;;:::i;57227:93::-;;;;;;;;;;;;;:::i;57594:121::-;;;;;;;;;;;;;:::i;59346:942::-;;;;;;;;;;-1:-1:-1;59346:942:0;;;;;:::i;:::-;;:::i;56385:105::-;;;;;;;;;;-1:-1:-1;56385:105:0;;;;;:::i;:::-;;:::i;60296:110::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;48580:26::-;;;;;;;;;;;;;;;;51262:187;;;;;;;;;;;;;:::i;25528:86::-;;;;;;;;;;-1:-1:-1;25599:7:0;;;;25528:86;;59043:25;;;;;;;;;;-1:-1:-1;59043:25:0;;;;-1:-1:-1;;;;;59043:25:0;;;56692:84;;;;;;;;;;-1:-1:-1;56743:4:0;56692:84;;57843:118;;;;;;;;;;-1:-1:-1;57843:118:0;;;;;:::i;:::-;;:::i;59249:35::-;;;;;;;;;;-1:-1:-1;59249:35:0;;;;;;;;;;;22526:103;;;;;;;;;;;;;:::i;55801:127::-;;;;;;;;;;;;;:::i;57328:63::-;;;;;;;;;;;;;:::i;48647:28::-;;;;;;;;;;-1:-1:-1;48647:28:0;;;;;;;;21885:87;;;;;;;;;;-1:-1:-1;21958:6:0;;-1:-1:-1;;;;;21958:6:0;21885:87;;57723:112;;;;;;;;;;;;;:::i;48241:42::-;;;;;;;;;;-1:-1:-1;48241:42:0;;;;;:::i;:::-;;;;;;;;;;;;;;57969:130;;;;;;;;;;-1:-1:-1;57969:130:0;;;;;:::i;:::-;;:::i;54543:220::-;;;;;;;;;;-1:-1:-1;54543:220:0;;;;;:::i;:::-;;:::i;59001:20::-;;;;;;;;;;-1:-1:-1;59001:20:0;;;;-1:-1:-1;;;;;59001:20:0;;;54999:128;;;;;;;;;;-1:-1:-1;54999:128:0;;;;;:::i;:::-;;:::i;57496:90::-;;;;;;;;;;;;;:::i;54913:78::-;;;;;;;;;;;;;:::i;62661:155::-;;;;;;;;;;-1:-1:-1;62661:155:0;;;;;:::i;:::-;;:::i;54441:94::-;;;;;;;;;;-1:-1:-1;54513:7:0;:14;54441:94;;55995:118;;;;;;;;;;;;;:::i;58748:35::-;;;;;;;;;;;;58778:5;58748:35;;48331:31;;;;;;;;;;-1:-1:-1;48331:31:0;;;;-1:-1:-1;;;;;48331:31:0;;;54771:134;;;;;;;;;;-1:-1:-1;54771:134:0;;;;;:::i;:::-;;:::i;58792:103::-;;;;;;;;;;;;58852:42;58792:103;;58107:197;;;;;;;;;;-1:-1:-1;58107:197:0;;;;;:::i;:::-;;:::i;48513:27::-;;;;;;;;;;-1:-1:-1;48513:27:0;;;;-1:-1:-1;;;;;48513:27:0;;;50596:201;;;;;;;;;;;;;:::i;62538:115::-;;;;;;;;;;-1:-1:-1;62538:115:0;;;;;:::i;:::-;;:::i;59102:15::-;;;;;;;;;;;;;;;;48547:26;;;;;;;;;;;;;;;;22784:201;;;;;;;;;;-1:-1:-1;22784:201:0;;;;;:::i;:::-;;:::i;48210:24::-;;;;;;;;;;-1:-1:-1;48210:24:0;;;;;:::i;:::-;;:::i;62238:292::-;;;;;;;;;;-1:-1:-1;62238:292:0;;;;;:::i;:::-;;:::i;56969:176::-;;;;;;;;;;;;;:::i;48369:20::-;;;;;;;;;;-1:-1:-1;48369:20:0;;;;-1:-1:-1;;;;;48369:20:0;;;55135:284;49343:15;:13;:15::i;:::-;-1:-1:-1;;;;;55209:19:0;::::1;55205:98;;55245:12;:25:::0;;-1:-1:-1;;;;;;55245:25:0::1;::::0;;55135:284;:::o;55205:98::-:1;55330:4;::::0;-1:-1:-1;;;;;55330:4:0;;::::1;55321:13:::0;;::::1;::::0;55313:31:::1;;;::::0;-1:-1:-1;;;55313:31:0;;5039:2:1;55313:31:0::1;::::0;::::1;5021:21:1::0;5078:1;5058:18;;;5051:29;-1:-1:-1;;;5096:18:1;;;5089:35;5141:18;;55313:31:0::1;;;;;;;;;55355:25;55374:5;55355:18;:25::i;:::-;55391:12;:20:::0;;-1:-1:-1;;;;;;55391:20:0::1;-1:-1:-1::0;;;;;55391:20:0;::::1;;::::0;;49369:1:::1;55135:284:::0;:::o;51546:112::-;51617:33;51626:16;51644:5;51617:8;:33::i;56121:256::-;49343:15;:13;:15::i;:::-;56204:16:::1;:36:::0;;-1:-1:-1;;56204:36:0::1;::::0;::::1;;::::0;;::::1;::::0;;;::::1;56255:16:::0;56251:119:::1;;;56303:1;56288:12;:16:::0;55135:284;:::o;56251:119::-:1;56352:6;56337:12;:21:::0;56121:256;:::o;60414:282::-;60490:10;;60469:4;;-1:-1:-1;;;;;60490:10:0;:24;60486:203;;60556:10;;60538:54;;-1:-1:-1;;;60538:54:0;;60586:4;60538:54;;;360:51:1;-1:-1:-1;;;;;60556:10:0;;;;60538:39;;333:18:1;;60538:54:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;60531:61;;60414:282;:::o;60486:203::-;60646:5;;60632:45;;-1:-1:-1;;;60632:45:0;;60671:4;60632:45;;;360:51:1;-1:-1:-1;;;;;60646:5:0;;;;60632:30;;333:18:1;;60632:45:0;196:221:1;50805:449:0;50882:5;;-1:-1:-1;;;;;50882:5:0;50868:10;:19;50860:38;;;;-1:-1:-1;;;50860:38:0;;;;;;;:::i;:::-;50911:15;50929;:13;:15::i;:::-;50911:33;;50971:7;50961;:17;50957:118;;;50995:28;51005:17;51015:7;51005;:17;:::i;:::-;50995:9;:28::i;:::-;51048:15;:13;:15::i;:::-;51038:25;;50957:118;51101:7;51091;:17;51087:67;;;-1:-1:-1;51135:7:0;51087:67;51192:5;;51173:4;;51166:41;;-1:-1:-1;;;;;51173:4:0;;;;51192:5;51199:7;51166:25;:41::i;:::-;51225:21;51234:11;:9;:11::i;:::-;51225:21;;160:25:1;;;148:2;133:18;51225:21:0;;;;;;;50849:405;50805:449;:::o;57399:89::-;49343:15;:13;:15::i;:::-;57450:10:::1;:8;:10::i;:::-;57471:9;:7;:9::i;:::-;57399:89::o:0;55427:300::-;55472:7;55496:12;;55512:1;55496:17;55492:31;;-1:-1:-1;55522:1:0;;55427:300::o;55492:31::-;55534:15;55570:11;;55552:15;:29;;;;:::i;:::-;55534:47;;55592:17;55622:12;;55612:7;:22;:51;;55662:1;55612:51;;;55652:7;55637:12;;:22;;;;:::i;:::-;55592:71;;55707:12;;55695:9;55681:11;;:23;;;;:::i;:::-;:38;;;;:::i;:::-;55674:45;;;;55427:300;:::o;51457:81::-;51504:26;51513:9;51524:5;51504:8;:26::i;57227:93::-;49343:15;:13;:15::i;:::-;57274:7:::1;:5;:7::i;:::-;57292:20;:18;:20::i;57594:121::-:0;57682:7;;:24;;;-1:-1:-1;;;57682:24:0;;;;57641:10;;-1:-1:-1;;;;;57682:7:0;;:22;;:24;;;;;;;;;;;;;;:7;:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;59346:942::-;15609:19;15632:13;;;;;;15631:14;;15679:34;;;;-1:-1:-1;15697:12:0;;15712:1;15697:12;;;;:16;15679:34;15678:108;;;-1:-1:-1;15758:4:0;4385:19;:23;;;15719:66;;-1:-1:-1;15768:12:0;;;;;:17;15719:66;15656:204;;;;-1:-1:-1;;;15656:204:0;;6811:2:1;15656:204:0;;;6793:21:1;6850:2;6830:18;;;6823:30;6889:34;6869:18;;;6862:62;-1:-1:-1;;;6940:18:1;;;6933:44;6994:19;;15656:204:0;6609:410:1;15656:204:0;15871:12;:16;;-1:-1:-1;;15871:16:0;15886:1;15871:16;;;15898:67;;;;15933:13;:20;;-1:-1:-1;;15933:20:0;;;;;15898:67;59597:5:::1;:14:::0;;-1:-1:-1;;;;;;59597:14:0::1;-1:-1:-1::0;;;;;59597:14:0;::::1;;::::0;;59622:3:::1;:10:::0;;;-1:-1:-1;59649:19:0;::::1;59645:82;;;59685:23;:30:::0;;-1:-1:-1;;59685:30:0::1;;;::::0;;59645:82:::1;58778:5;59741:4;:14;59737:141;;59791:22;::::0;-1:-1:-1;;;59791:22:0;;::::1;::::0;::::1;160:25:1::0;;;58852:42:0::1;::::0;59791:16:::1;::::0;133:18:1;;59791:22:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;59775:10:0::1;59772:41:::0;;-1:-1:-1;;;;;;59772:41:0::1;-1:-1:-1::0;;;;;59772:41:0;;;::::1;::::0;;;::::1;::::0;;-1:-1:-1;59737:141:0::1;::::0;-1:-1:-1;59737:141:0::1;;59846:13;:20:::0;;-1:-1:-1;;59846:20:0::1;59862:4;59846:20;::::0;;59737:141:::1;59888:41;59908:10;59920:8;;59888:19;:41::i;:::-;59940:25;59960:4;59940:19;:25::i;:::-;-1:-1:-1::0;;;;;59982:32:0;::::1;::::0;59978:303:::1;;60087:73;::::0;-1:-1:-1;;;;;378:32:1;;;60087:73:0::1;::::0;::::1;360:51:1::0;60031:8:0::1;::::0;60063:23;;::::1;::::0;333:18:1;;60087:73:0::1;::::0;;-1:-1:-1;;60087:73:0;;::::1;::::0;;;;;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;60087:73:0::1;-1:-1:-1::0;;;60087:73:0::1;::::0;;60063:98;::::1;::::0;60087:73;60063:98:::1;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;60209:59:0::1;::::0;;;;;::::1;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;;;;;60209:59:0::1;-1:-1:-1::0;;;60209:59:0::1;::::0;;60185:84;;60054:107;;-1:-1:-1;;;;;;60185:23:0;::::1;::::0;:84:::1;::::0;60209:59;60185:84:::1;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1::0;;;;59978:303:0::1;15991:14:::0;15987:102;;;16038:5;16022:21;;-1:-1:-1;;16022:21:0;;;16063:14;;-1:-1:-1;8393:36:1;;16063:14:0;;8381:2:1;8366:18;16063:14:0;;;;;;;15987:102;15598:498;59346:942;;;;;;;:::o;56385:105::-;49343:15;:13;:15::i;:::-;56458:12:::1;:24:::0;56385:105::o;60296:110::-;60373:25;;;;;;;;;;;;-1:-1:-1;;;60373:25:0;;;;;60296:110::o;51262:187::-;51319:16;;;;51315:127;;;51374:5;;-1:-1:-1;;;;;51374:5:0;51360:10;:19;51352:38;;;;-1:-1:-1;;;51352:38:0;;;;;;;:::i;:::-;51405:25;51414:9;51425:4;51405:8;:25::i;57843:118::-;21771:13;:11;:13::i;:::-;57907:5:::1;:14:::0;;-1:-1:-1;;;;;;57907:14:0::1;-1:-1:-1::0;;;;;57907:14:0;::::1;::::0;;::::1;::::0;;;57937:16:::1;::::0;360:51:1;;;57937:16:0::1;::::0;348:2:1;333:18;57937:16:0::1;;;;;;;;57843:118:::0;:::o;22526:103::-;21771:13;:11;:13::i;:::-;22591:30:::1;22618:1;22591:18;:30::i;55801:127::-:0;55843:7;55906:14;:12;:14::i;:::-;55888:15;:13;:15::i;:::-;55870;:13;:15::i;:::-;:33;;;;:::i;:::-;:50;;;;:::i;57328:63::-;49343:15;:13;:15::i;:::-;57375:8:::1;:6;:8::i;57723:112::-:0;57800:7;;:27;;;-1:-1:-1;;;57800:27:0;;;;57773:7;;-1:-1:-1;;;;;57800:7:0;;:25;;:27;;;;;;;;;;;;;;:7;:27;;;;;;;;;;;;;;57969:130;21771:13;:11;:13::i;:::-;58037:7:::1;:18:::0;;-1:-1:-1;;;;;;58037:18:0::1;-1:-1:-1::0;;;;;58037:18:0;::::1;::::0;;::::1;::::0;;;58071:20:::1;::::0;360:51:1;;;58071:20:0::1;::::0;348:2:1;333:18;58071:20:0::1;196:221:1::0;54543:220:0;49343:15;:13;:15::i;:::-;54626:4:::1;::::0;-1:-1:-1;;;;;54626:4:0;;::::1;54616:14:::0;;::::1;::::0;54608:32:::1;;;::::0;-1:-1:-1;;;54608:32:0;;5039:2:1;54608:32:0::1;::::0;::::1;5021:21:1::0;5078:1;5058:18;;;5051:29;-1:-1:-1;;;5096:18:1;;;5089:35;5141:18;;54608:32:0::1;4837:328:1::0;54608:32:0::1;54669:6;::::0;-1:-1:-1;;;;;54669:6:0;;::::1;54659:16:::0;;::::1;::::0;54651:36:::1;;;::::0;-1:-1:-1;;;54651:36:0;;8772:2:1;54651:36:0::1;::::0;::::1;8754:21:1::0;8811:1;8791:18;;;8784:29;-1:-1:-1;;;8829:18:1;;;8822:37;8876:18;;54651:36:0::1;8570:330:1::0;54651:36:0::1;54698:26;54717:6;54698:18;:26::i;:::-;54735:7;:20:::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;54735:20:0;;;;;::::1;::::0;;-1:-1:-1;;;;;;54735:20:0::1;-1:-1:-1::0;;;;;54735:20:0;;;::::1;::::0;;;::::1;::::0;;54543:220::o;54999:128::-;49343:15;:13;:15::i;:::-;-1:-1:-1;;;;;55090:17:0;;::::1;;::::0;;;:10:::1;:17;::::0;;;;:29;54999:128::o;57496:90::-;57562:7;;:16;;;-1:-1:-1;;;57562:16:0;;;;57535:7;;-1:-1:-1;;;;;57562:7:0;;:14;;:16;;;;;;;;;;;;;;:7;:16;;;;;;;;;;;;;;54913:78;49343:15;:13;:15::i;:::-;54969:14:::1;54976:7;;54969:14;:::i;62661:155::-:0;49343:15;:13;:15::i;:::-;62758:23:::1;:50:::0;;;::::1;;;;-1:-1:-1::0;;62758:50:0;;::::1;::::0;;;::::1;::::0;;62661:155::o;55995:118::-;56075:4;;56068:37;;-1:-1:-1;;;56068:37:0;;56099:4;56068:37;;;360:51:1;56041:7:0;;-1:-1:-1;;;;;56075:4:0;;56068:22;;333:18:1;;56068:37:0;196:221:1;54771:134:0;49343:15;:13;:15::i;:::-;54846:7:::1;54854:14:::0;;:18:::1;::::0;54871:1:::1;::::0;54854:18:::1;:::i;:::-;54846:27;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;54833:7:::1;:10:::0;;-1:-1:-1;;;;;54846:27:0;;::::1;::::0;54841:1;;54833:10;::::1;;;;;:::i;:::-;;;;;;;;;:40;;;;;-1:-1:-1::0;;;;;54833:40:0::1;;;;;-1:-1:-1::0;;;;;54833:40:0::1;;;;;;54884:7;:13;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;;-1:-1:-1;;54884:13:0;;;;;-1:-1:-1;;;;;;54884:13:0::1;::::0;;;;;-1:-1:-1;54771:134:0:o;58107:197::-;58193:10;;-1:-1:-1;;;;;58193:10:0;58179;:24;58171:48;;;;-1:-1:-1;;;58171:48:0;;9371:2:1;58171:48:0;;;9353:21:1;9410:2;9390:18;;;9383:30;-1:-1:-1;;;9429:18:1;;;9422:41;9480:18;;58171:48:0;9169:335:1;58171:48:0;58230:10;:24;;-1:-1:-1;;;;;;58230:24:0;-1:-1:-1;;;;;58230:24:0;;;;;;;;58270:26;;360:51:1;;;58270:26:0;;348:2:1;333:18;58270:26:0;196:221:1;50596:201:0;25599:7;;;;49185:33;;;;49197:7;;;;;;;;;-1:-1:-1;;;;;49197:7:0;-1:-1:-1;;;;;49197:19:0;;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;49185:71;;;-1:-1:-1;49222:7:0;;-1:-1:-1;;;;;49222:7:0;:21;49244:11;:9;:11::i;:::-;49222:34;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;49181:100;;;49265:16;;-1:-1:-1;;;49265:16:0;;;;;;;;;;;49181:100;50645:15:::1;50663;:13;:15::i;:::-;50645:33:::0;-1:-1:-1;50693:11:0;;50689:101:::1;;50721:17;50730:7;50721:8;:17::i;:::-;50758:20;50766:11;:9;:11::i;:::-;50758:20;::::0;160:25:1;;;148:2;133:18;50758:20:0::1;14:177:1::0;62538:115:0;49343:15;:13;:15::i;:::-;62615:13:::1;:30:::0;;-1:-1:-1;;62615:30:0::1;::::0;::::1;;::::0;;;::::1;::::0;;62538:115::o;22784:201::-;21771:13;:11;:13::i;:::-;-1:-1:-1;;;;;22873:22:0;::::1;22865:73;;;::::0;-1:-1:-1;;;22865:73:0;;9961:2:1;22865:73:0::1;::::0;::::1;9943:21:1::0;10000:2;9980:18;;;9973:30;10039:34;10019:18;;;10012:62;-1:-1:-1;;;10090:18:1;;;10083:36;10136:19;;22865:73:0::1;9759:402:1::0;22865:73:0::1;22949:28;22968:8;22949:18;:28::i;48210:24::-:0;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;48210:24:0;;-1:-1:-1;48210:24:0;:::o;62238:292::-;21771:13;:11;:13::i;:::-;62301:26:::1;62311:15;:13;:15::i;62301:26::-;58778:5;62342:4;:14;62338:144;;62392:22;::::0;-1:-1:-1;;;62392:22:0;;::::1;::::0;::::1;160:25:1::0;;;58852:42:0::1;::::0;62392:16:::1;::::0;133:18:1;;62392:22:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;62376:10:0::1;62373:41:::0;;-1:-1:-1;;;;;;62373:41:0::1;-1:-1:-1::0;;;;;62373:41:0;;;::::1;::::0;;;::::1;::::0;;-1:-1:-1;62338:144:0::1;::::0;-1:-1:-1;62338:144:0::1;;62447:10;:23:::0;;-1:-1:-1;;;;;;62447:23:0::1;::::0;;62338:144:::1;62492:3;:10:::0;;;62513:9:::1;:7;:9::i;56969:176::-:0;57034:5;;-1:-1:-1;;;;;57034:5:0;57020:10;:19;57012:38;;;;-1:-1:-1;;;57012:38:0;;;;;;;:::i;:::-;57061:20;:18;:20::i;:::-;57099:4;;57114:5;;-1:-1:-1;;;;;57099:4:0;;;;57092:21;;57114:5;57121:15;:13;:15::i;:::-;57092:45;;-1:-1:-1;;;;;;57092:45:0;;;;;;;-1:-1:-1;;;;;10358:32:1;;;57092:45:0;;;10340:51:1;10407:18;;;10400:34;10313:18;;57092:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;49386:130::-;21958:6;;-1:-1:-1;;;;;21958:6:0;49440:10;:21;;;;:47;;;49479:8;:6;:8::i;:::-;-1:-1:-1;;;;;49465:22:0;:10;-1:-1:-1;;;;;49465:22:0;;;49440:47;49436:72;;;49496:12;;-1:-1:-1;;;49496:12:0;;;;;;;;;;;62058:172;62152:5;;-1:-1:-1;;;;;62152:5:0;;;62143:14;;;;62135:33;;;;-1:-1:-1;;;62135:33:0;;10647:2:1;62135:33:0;;;10629:21:1;10686:1;10666:18;;;10659:29;-1:-1:-1;;;10704:18:1;;;10697:36;10750:18;;62135:33:0;10445:329:1;62135:33:0;62196:10;;-1:-1:-1;;;;;62196:10:0;;;62187:19;;;;62179:43;;;;-1:-1:-1;;;62179:43:0;;10981:2:1;62179:43:0;;;10963:21:1;11020:2;11000:18;;;10993:30;-1:-1:-1;;;11039:18:1;;;11032:41;11090:18;;62179:43:0;10779:335:1;51721:656:0;25599:7;;;;49185:33;;;;49197:7;;;;;;;;;-1:-1:-1;;;;;49197:7:0;-1:-1:-1;;;;;49197:19:0;;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;49185:71;;;-1:-1:-1;49222:7:0;;-1:-1:-1;;;;;49222:7:0;:21;49244:11;:9;:11::i;:::-;49222:34;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;49181:100;;;49265:16;;-1:-1:-1;;;49265:16:0;;;;;;;;;;;49181:100;51813:8:::1;:6;:8::i;:::-;51832:22;:20;:22::i;:::-;51892:6;::::0;51885:39:::1;::::0;-1:-1:-1;;;51885:39:0;;51918:4:::1;51885:39;::::0;::::1;360:51:1::0;51865:17:0::1;::::0;-1:-1:-1;;;;;51892:6:0::1;::::0;51885:24:::1;::::0;333:18:1;;51885:39:0::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;51962:6;::::0;-1:-1:-1;;;;;51962:6:0::1;51951:18;::::0;;;:10:::1;:18;::::0;;;;;51865:59;;-1:-1:-1;51939:30:0;::::1;51935:435;;;51986:29;51998:16;51986:11;:29::i;:::-;52032:19;:17;:19::i;:::-;52066:21;52090:15;:13;:15::i;:::-;52066:39;;52150:14;:12;:14::i;:::-;52134:30;::::0;:13;:30:::1;:::i;:::-;52120:11;:44:::0;52193:15:::1;52179:11;:29:::0;52230:9;52225:60:::1;;52260:9;:7;:9::i;:::-;52319:10;52306:52;52331:13:::0;52346:11:::1;:9;:11::i;:::-;52306:52;::::0;;11293:25:1;;;11349:2;11334:18;;11327:34;;;;11266:18;52306:52:0::1;;;;;;;51971:399;51935:435;51802:575;51721:656:::0;;:::o;61054:306::-;61119:10;;61115:238;;61150:10;;-1:-1:-1;;;;;61150:10:0;:24;61146:196;;61213:10;;61195:53;;-1:-1:-1;;;61195:53:0;;;;;11540:25:1;;;61213:10:0;11581:18:1;;;11574:50;-1:-1:-1;;;;;61213:10:0;;;;61195:38;;11513:18:1;;61195:53:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55135:284;:::o;61146:196::-;61303:5;;61289:37;;-1:-1:-1;;;61289:37:0;;;;;160:25:1;;;-1:-1:-1;;;;;61303:5:0;;;;61289:29;;133:18:1;;61289:37:0;14:177:1;41305:162:0;41415:43;;-1:-1:-1;;;;;10358:32:1;;;41415:43:0;;;10340:51:1;10407:18;;;10400:34;;;41388:71:0;;41408:5;;41430:14;;;;;10313:18:1;;41415:43:0;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;41415:43:0;;;;;;;;;;;41388:19;:71::i;26383:120::-;25392:16;:14;:16::i;:::-;26442:7:::1;:15:::0;;-1:-1:-1;;26442:15:0::1;::::0;;26473:22:::1;20007:10:::0;26482:12:::1;26473:22;::::0;-1:-1:-1;;;;;378:32:1;;;360:51;;348:2;333:18;26473:22:0::1;;;;;;;26383:120::o:0;61368:346::-;61427:11;61441:15;:13;:15::i;:::-;61427:29;-1:-1:-1;61471:10:0;;61467:240;;61502:10;;-1:-1:-1;;;;;61502:10:0;:24;61498:198;;61565:10;;61547:55;;-1:-1:-1;;;61547:55:0;;;;;160:25:1;;;-1:-1:-1;;;;;61565:10:0;;;;61547:47;;133:18:1;;61547:55:0;14:177:1;49524:608:0;17752:13;;;;;;;17744:69;;;;-1:-1:-1;;;17744:69:0;;;;;;;:::i;:::-;49650:16:::1;:14;:16::i;:::-;49677:17;:15;:17::i;:::-;49712:15;;::::0;::::1;:10:::0;:15:::1;:::i;:::-;49705:4;:22:::0;;-1:-1:-1;;;;;;49705:22:0::1;-1:-1:-1::0;;;;;49705:22:0;;;::::1;::::0;;;::::1;::::0;;49765:18:::1;::::0;;;::::1;::::0;::::1;;:::i;:::-;49738:7;:46:::0;;-1:-1:-1;;;;;;49738:46:0::1;-1:-1:-1::0;;;;;49738:46:0;;;::::1;::::0;;;::::1;::::0;;49803:16:::1;::::0;;;::::1;::::0;::::1;;:::i;:::-;49795:5;:24:::0;;-1:-1:-1;;;;;;49795:24:0::1;-1:-1:-1::0;;;;;49795:24:0;;;::::1;::::0;;;::::1;::::0;;49840:18:::1;::::0;;;::::1;::::0;::::1;;:::i;:::-;49830:7;:28:::0;;-1:-1:-1;;;;;;49830:28:0::1;-1:-1:-1::0;;;;;49830:28:0;;;::::1;::::0;;;::::1;::::0;;49882:21:::1;::::0;;;::::1;::::0;::::1;;:::i;:::-;49869:10;:34:::0;;-1:-1:-1;;;;;;49869:34:0::1;-1:-1:-1::0;;;;;49869:34:0;;::::1;;::::0;;49923:7:::1;::::0;:16:::1;::::0;;-1:-1:-1;;;49923:16:0;;;;:7;;;::::1;::::0;:14:::1;::::0;:16:::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;:7;:16:::1;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;49914:6;:25:::0;;-1:-1:-1;;;;;;49914:25:0::1;-1:-1:-1::0;;;;;49914:25:0;;;::::1;::::0;;;::::1;::::0;;-1:-1:-1;49952:88:0::1;49965:19:::0;;::::1;49952:88;;;50006:22;50016:8;;50025:1;50016:11;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;50006:22::-;49986:3;;49952:88;;;-1:-1:-1::0;50050:40:0::1;50066:23;::::0;;;::::1;::::0;::::1;;:::i;50050:40::-;-1:-1:-1::0;;50118:6:0::1;50103:12;:21:::0;-1:-1:-1;49524:608:0:o;22050:132::-;21958:6;;-1:-1:-1;;;;;21958:6:0;20007:10;22114:23;22106:68;;;;-1:-1:-1;;;22106:68:0;;12249:2:1;22106:68:0;;;12231:21:1;;;12268:18;;;12261:30;12327:34;12307:18;;;12300:62;12379:18;;22106:68:0;12047:356:1;23145:191:0;23238:6;;;-1:-1:-1;;;;;23255:17:0;;;-1:-1:-1;;;;;;23255:17:0;;;;;;;23288:40;;23238:6;;;23255:17;23238:6;;23288:40;;23219:16;;23288:40;23208:128;23145:191;:::o;26124:118::-;25133:19;:17;:19::i;:::-;26184:7:::1;:14:::0;;-1:-1:-1;;26184:14:0::1;26194:4;26184:14;::::0;;26214:20:::1;26221:12;20007:10:::0;;19927:98;60704:342;60768:10;;-1:-1:-1;;;;;60768:10:0;:24;60764:275;;60816:4;;60809:51;;-1:-1:-1;;;;;60816:4:0;58852:42;60853:6;60809:25;:51::i;:::-;60891:3;;60875:28;;-1:-1:-1;;;60875:28:0;;;;;11293:25:1;;;;11334:18;;;11327:34;;;58852:42:0;;60875:15;;11266:18:1;;60875:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;55135:284;:::o;60764:275::-;60962:5;;60943:4;;60936:40;;-1:-1:-1;;;;;60943:4:0;;;;60962:5;60969:6;60936:25;:40::i;:::-;61005:5;;60991:36;;-1:-1:-1;;;60991:36:0;;;;;160:25:1;;;-1:-1:-1;;;;;61005:5:0;;;;60991:28;;133:18:1;;60991:36:0;14:177:1;61722:328:0;61773:10;;-1:-1:-1;;;;;61773:10:0;:24;61769:274;;61832:10;;61814:54;;-1:-1:-1;;;61814:54:0;;61862:4;61814:54;;;360:51:1;-1:-1:-1;;;;;61832:10:0;;;;61814:39;;333:18:1;;61814:54:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57399:89::o;61769:274::-;61905:13;;;;61901:37;;;61932:5;;61920:18;;-1:-1:-1;;;61920:18:0;;-1:-1:-1;;;;;61932:5:0;;;61920:18;;;360:51:1;58949:42:0;;61920:11;;333:18:1;;61920::0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;61901:37;61957:23;;;;;;;61953:78;;;61996:5;;61982:49;;-1:-1:-1;;;61982:49:0;;62025:4;61982:49;;;360:51:1;-1:-1:-1;;;;;61996:5:0;;;;61982:34;;333:18:1;;61982:49:0;196:221:1;52385:549:0;52450:6;52445:482;52462:7;:14;52458:18;;52445:482;;;52498:13;52514:7;52522:1;52514:10;;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;;;;52514:10:0;;-1:-1:-1;;;52543:60:0;;52539:377;;52639:6;;;;;;;;;-1:-1:-1;;;;;52639:6:0;-1:-1:-1;;;;;52624:30:0;;52662:21;52624:62;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52539:377;;;52741:38;;-1:-1:-1;;;52741:38:0;;52773:4;52741:38;;;360:51:1;52727:11:0;;-1:-1:-1;;;;;52741:23:0;;;;;333:18:1;;52741:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;52811:17:0;;;;;;:10;:17;;;;;;52727:52;;-1:-1:-1;52802:26:0;;52798:103;;;52866:6;;52853:28;;52859:5;;-1:-1:-1;;;;;52866:6:0;52874;52853:5;:28::i;:::-;52708:208;52539:377;-1:-1:-1;52478:3:0;;52445:482;;52967:760;53034:34;53071:16;:14;:16::i;:::-;:39;;-1:-1:-1;;;53071:39:0;;53104:4;53071:39;;;360:51:1;-1:-1:-1;;;;;53071:24:0;;;;;;;333:18:1;;53071:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;53071:39:0;;;;;;;;;;;;:::i;:::-;53183:10;;53148:6;;53141:39;;-1:-1:-1;;;53141:39:0;;53174:4;53141:39;;;360:51:1;53183:10:0;;-1:-1:-1;53121:17:0;;48711:7;;53183:10;-1:-1:-1;;;;;53148:6:0;;53141:24;;333:18:1;;53141:39:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:52;;;;:::i;:::-;:62;;;;:::i;:::-;53121:82;;53216:21;48711:7;53252:4;:9;;;53240;:21;;;;:::i;:::-;:31;;;;:::i;:::-;53289:6;;53216:55;;-1:-1:-1;53282:60:0;;-1:-1:-1;;;;;53289:6:0;53310:16;53216:55;53282:27;:60::i;:::-;53355:22;48711:7;53392:4;:10;;;53380:9;:22;;;;:::i;:::-;:32;;;;:::i;:::-;53355:57;;53423:64;53451:19;:17;:19::i;:::-;53430:6;;-1:-1:-1;;;;;53430:6:0;;53472:14;53423:27;:64::i;:::-;53500:27;48711:7;53542:4;:15;;;53530:9;:27;;;;:::i;:::-;:37;;;;:::i;:::-;53606:10;;53585:6;;53500:67;;-1:-1:-1;53578:60:0;;-1:-1:-1;;;;;53585:6:0;;;;53606:10;53500:67;53578:27;:60::i;:::-;53656:63;;;14568:25:1;;;14624:2;14609:18;;14602:34;;;14652:18;;;14645:34;;;53656:63:0;;14556:2:1;14541:18;53656:63:0;;;;;;;53023:704;;;;;52967:760;:::o;53735:304::-;53796:12;;-1:-1:-1;;;;;53796:12:0;53792:240;;53845:6;;53853:4;;53839:19;;-1:-1:-1;;;;;53845:6:0;;;;53853:4;53839:5;:19::i;53792:240::-;53911:6;;53895:12;;-1:-1:-1;;;;;53895:12:0;;;53911:6;;53895:22;53891:90;;53944:6;;53952:12;;53938:27;;-1:-1:-1;;;;;53944:6:0;;;;53952:12;53938:5;:27::i;:::-;54001:12;;54015:4;;53995:25;;-1:-1:-1;;;;;54001:12:0;;;;54015:4;53995:5;:25::i;44116:638::-;44540:23;44566:33;-1:-1:-1;;;;;44566:27:0;;44594:4;44566:27;:33::i;:::-;44540:59;;44614:10;:17;44635:1;44614:22;;:57;;;;;44652:10;44641:30;;;;;;;;;;;;:::i;:::-;44640:31;44614:57;44610:137;;;44695:40;;-1:-1:-1;;;44695:40:0;;-1:-1:-1;;;;;378:32:1;;44695:40:0;;;360:51:1;333:18;;44695:40:0;196:221:1;25872:108:0;25599:7;;;;25931:41;;;;-1:-1:-1;;;25931:41:0;;14892:2:1;25931:41:0;;;14874:21:1;14931:2;14911:18;;;14904:30;-1:-1:-1;;;14950:18:1;;;14943:50;15010:18;;25931:41:0;14690:344:1;21428:97:0;17752:13;;;;;;;17744:69;;;;-1:-1:-1;;;17744:69:0;;;;;;;:::i;:::-;21491:26:::1;:24;:26::i;24698:99::-:0;17752:13;;;;;;;17744:69;;;;-1:-1:-1;;;17744:69:0;;;;;;;:::i;:::-;24762:27:::1;:25;:27::i;25687:108::-:0;25599:7;;;;25757:9;25749:38;;;;-1:-1:-1;;;25749:38:0;;15241:2:1;25749:38:0;;;15223:21:1;15280:2;15260:18;;;15253:30;-1:-1:-1;;;15299:18:1;;;15292:46;15355:18;;25749:38:0;15039:340:1;43338:387:0;43454:47;;;-1:-1:-1;;;;;10358:32:1;;43454:47:0;;;10340:51:1;10407:18;;;;10400:34;;;43454:47:0;;;;;;;;;;10313:18:1;;;;43454:47:0;;;;;;;;-1:-1:-1;;;;;43454:47:0;-1:-1:-1;;;43454:47:0;;;43519:44;43469:13;43454:47;43519:23;:44::i;:::-;43514:204;;43607:43;;-1:-1:-1;;;;;10358:32:1;;;43607:43:0;;;10340:51:1;43647:1:0;10407:18:1;;;10400:34;43580:71:0;;43600:5;;43622:13;;;;;10313:18:1;;43607:43:0;10166:274:1;43580:71:0;43666:40;43686:5;43693:12;43666:19;:40::i;54228:205::-;54343:7;;54312:47;;-1:-1:-1;;;;;54312:30:0;;;;54343:7;54352:6;54312:30;:47::i;:::-;54384:7;;54370:55;;-1:-1:-1;;;54370:55:0;;-1:-1:-1;;;;;15929:15:1;;;54370:55:0;;;15911:34:1;15981:15;;;15961:18;;;15954:43;16013:18;;;16006:34;;;54384:7:0;;;;54370:27;;15846:18:1;;54370:55:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;54047:173::-;54129:42;;-1:-1:-1;;;54129:42:0;;54165:4;54129:42;;;360:51:1;54118:8:0;;-1:-1:-1;;;;;54129:27:0;;;;;333:18:1;;54129:42:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;54118:53;;54182:30;54188:9;54199:7;54208:3;54182:5;:30::i;36433:153::-;36508:12;36540:38;36562:6;36570:4;36576:1;36540:21;:38::i;:::-;36533:45;;36433:153;;;;;:::o;21533:113::-;17752:13;;;;;;;17744:69;;;;-1:-1:-1;;;17744:69:0;;;;;;;:::i;:::-;21606:32:::1;20007:10:::0;21606:18:::1;:32::i;24805:97::-:0;17752:13;;;;;;;17744:69;;;;-1:-1:-1;;;17744:69:0;;;;;;;:::i;:::-;24879:7:::1;:15:::0;;-1:-1:-1;;24879:15:0::1;::::0;;24805:97::o;45265:585::-;45348:4;45655:12;45669:23;45704:5;-1:-1:-1;;;;;45696:19:0;45716:4;45696:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45654:67;;;;45739:7;:69;;;;-1:-1:-1;45751:17:0;;:22;;:56;;;45788:10;45777:30;;;;;;;;;;;;:::i;:::-;45739:103;;;;;45841:1;45820:5;-1:-1:-1;;;;;45812:26:0;;:30;45739:103;45732:110;45265:585;-1:-1:-1;;;;;45265:585:0:o;36921:398::-;37020:12;37073:5;37049:21;:29;37045:110;;;37102:41;;-1:-1:-1;;;37102:41:0;;37137:4;37102:41;;;360:51:1;333:18;;37102:41:0;196:221:1;37045:110:0;37166:12;37180:23;37207:6;-1:-1:-1;;;;;37207:11:0;37226:5;37233:4;37207:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37165:73;;;;37256:55;37283:6;37291:7;37300:10;37256:26;:55::i;:::-;37249:62;;;;36921:398;;;;;;:::o;38397:597::-;38545:12;38575:7;38570:417;;38599:19;38607:10;38599:7;:19::i;:::-;38570:417;;;38827:17;;:22;:49;;;;-1:-1:-1;;;;;;38853:18:0;;;:23;38827:49;38823:121;;;38904:24;;-1:-1:-1;;;38904:24:0;;-1:-1:-1;;;;;378:32:1;;38904:24:0;;;360:51:1;333:18;;38904:24:0;196:221:1;38823:121:0;-1:-1:-1;38965:10:0;38958:17;;39547:528;39680:17;;:21;39676:392;;39912:10;39906:17;39969:15;39956:10;39952:2;39948:19;39941:44;39676:392;40039:17;;-1:-1:-1;;;40039:17:0;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;422:131:1:-;-1:-1:-1;;;;;497:31:1;;487:42;;477:70;;543:1;540;533:12;558:134;626:20;;655:31;626:20;655:31;:::i;:::-;558:134;;;:::o;697:247::-;756:6;809:2;797:9;788:7;784:23;780:32;777:52;;;825:1;822;815:12;777:52;864:9;851:23;883:31;908:5;883:31;:::i;949:118::-;1035:5;1028:13;1021:21;1014:5;1011:32;1001:60;;1057:1;1054;1047:12;1072:241;1128:6;1181:2;1169:9;1160:7;1156:23;1152:32;1149:52;;;1197:1;1194;1187:12;1149:52;1236:9;1223:23;1255:28;1277:5;1255:28;:::i;1526:180::-;1585:6;1638:2;1626:9;1617:7;1613:23;1609:32;1606:52;;;1654:1;1651;1644:12;1606:52;-1:-1:-1;1677:23:1;;1526:180;-1:-1:-1;1526:180:1:o;2130:158::-;2192:5;2237:3;2228:6;2223:3;2219:16;2215:26;2212:46;;;2254:1;2251;2244:12;2212:46;-1:-1:-1;2276:6:1;2130:158;-1:-1:-1;2130:158:1:o;2293:1099::-;2453:6;2461;2469;2477;2485;2493;2501;2554:3;2542:9;2533:7;2529:23;2525:33;2522:53;;;2571:1;2568;2561:12;2522:53;2610:9;2597:23;2629:31;2654:5;2629:31;:::i;:::-;2679:5;-1:-1:-1;2731:2:1;2716:18;;2703:32;;-1:-1:-1;2786:2:1;2771:18;;2758:32;2809:18;2839:14;;;2836:34;;;2866:1;2863;2856:12;2836:34;2904:6;2893:9;2889:22;2879:32;;2949:7;2942:4;2938:2;2934:13;2930:27;2920:55;;2971:1;2968;2961:12;2920:55;3011:2;2998:16;3037:2;3029:6;3026:14;3023:34;;;3053:1;3050;3043:12;3023:34;3106:7;3101:2;3091:6;3088:1;3084:14;3080:2;3076:23;3072:32;3069:45;3066:65;;;3127:1;3124;3117:12;3066:65;3158:2;3154;3150:11;3140:21;;3180:6;3170:16;;;;;3205:38;3239:2;3228:9;3224:18;3205:38;:::i;:::-;3195:48;;3262:39;3296:3;3285:9;3281:19;3262:39;:::i;:::-;3252:49;;3320:66;3378:7;3372:3;3361:9;3357:19;3320:66;:::i;:::-;3310:76;;2293:1099;;;;;;;;;;:::o;3397:250::-;3482:1;3492:113;3506:6;3503:1;3500:13;3492:113;;;3582:11;;;3576:18;3563:11;;;3556:39;3528:2;3521:10;3492:113;;;-1:-1:-1;;3639:1:1;3621:16;;3614:27;3397:250::o;3652:396::-;3801:2;3790:9;3783:21;3764:4;3833:6;3827:13;3876:6;3871:2;3860:9;3856:18;3849:34;3892:79;3964:6;3959:2;3948:9;3944:18;3939:2;3931:6;3927:15;3892:79;:::i;:::-;4032:2;4011:15;-1:-1:-1;;4007:29:1;3992:45;;;;4039:2;3988:54;;3652:396;-1:-1:-1;;3652:396:1:o;4053:315::-;4121:6;4129;4182:2;4170:9;4161:7;4157:23;4153:32;4150:52;;;4198:1;4195;4188:12;4150:52;4237:9;4224:23;4256:31;4281:5;4256:31;:::i;:::-;4306:5;4358:2;4343:18;;;;4330:32;;-1:-1:-1;;;4053:315:1:o;5170:184::-;5240:6;5293:2;5281:9;5272:7;5268:23;5264:32;5261:52;;;5309:1;5306;5299:12;5261:52;-1:-1:-1;5332:16:1;;5170:184;-1:-1:-1;5170:184:1:o;5359:329::-;5561:2;5543:21;;;5600:1;5580:18;;;5573:29;-1:-1:-1;;;5633:2:1;5618:18;;5611:36;5679:2;5664:18;;5359:329::o;5693:127::-;5754:10;5749:3;5745:20;5742:1;5735:31;5785:4;5782:1;5775:15;5809:4;5806:1;5799:15;5825:128;5892:9;;;5913:11;;;5910:37;;;5927:18;;:::i;5958:168::-;6031:9;;;6062;;6079:15;;;6073:22;;6059:37;6049:71;;6100:18;;:::i;6131:217::-;6171:1;6197;6187:132;;6241:10;6236:3;6232:20;6229:1;6222:31;6276:4;6273:1;6266:15;6304:4;6301:1;6294:15;6187:132;-1:-1:-1;6333:9:1;;6131:217::o;6353:251::-;6423:6;6476:2;6464:9;6455:7;6451:23;6447:32;6444:52;;;6492:1;6489;6482:12;6444:52;6524:9;6518:16;6543:31;6568:5;6543:31;:::i;7024:132::-;7100:13;;7122:28;7100:13;7122:28;:::i;7161:783::-;7264:6;7272;7280;7288;7296;7349:3;7337:9;7328:7;7324:23;7320:33;7317:53;;;7366:1;7363;7356:12;7317:53;7398:9;7392:16;7417:31;7442:5;7417:31;:::i;:::-;7517:2;7502:18;;7496:25;7467:5;;-1:-1:-1;7530:33:1;7496:25;7530:33;:::i;:::-;7634:2;7619:18;;7613:25;7582:7;;-1:-1:-1;7647:33:1;7613:25;7647:33;:::i;:::-;7751:2;7736:18;;7730:25;7699:7;;-1:-1:-1;7764:30:1;7730:25;7764:30;:::i;:::-;7865:3;7850:19;;7844:26;7813:7;;-1:-1:-1;7879:33:1;7844:26;7879:33;:::i;:::-;7931:7;7921:17;;;7161:783;;;;;;;;:::o;7949:287::-;8078:3;8116:6;8110:13;8132:66;8191:6;8186:3;8179:4;8171:6;8167:17;8132:66;:::i;:::-;8214:16;;;;;7949:287;-1:-1:-1;;7949:287:1:o;8440:125::-;8505:9;;;8526:10;;;8523:36;;;8539:18;;:::i;8905:127::-;8966:10;8961:3;8957:20;8954:1;8947:31;8997:4;8994:1;8987:15;9021:4;9018:1;9011:15;9037:127;9098:10;9093:3;9089:20;9086:1;9079:31;9129:4;9126:1;9119:15;9153:4;9150:1;9143:15;9509:245;9576:6;9629:2;9617:9;9608:7;9604:23;9600:32;9597:52;;;9645:1;9642;9635:12;9597:52;9677:9;9671:16;9696:28;9718:5;9696:28;:::i;11635:407::-;11837:2;11819:21;;;11876:2;11856:18;;;11849:30;11915:34;11910:2;11895:18;;11888:62;-1:-1:-1;;;11981:2:1;11966:18;;11959:41;12032:3;12017:19;;11635:407::o;12408:127::-;12469:10;12464:3;12460:20;12457:1;12450:31;12500:4;12497:1;12490:15;12524:4;12521:1;12514:15;12540:253;12612:2;12606:9;12654:4;12642:17;;12689:18;12674:34;;12710:22;;;12671:62;12668:88;;;12736:18;;:::i;:::-;12772:2;12765:22;12540:253;:::o;12798:275::-;12869:2;12863:9;12934:2;12915:13;;-1:-1:-1;;12911:27:1;12899:40;;12969:18;12954:34;;12990:22;;;12951:62;12948:88;;;13016:18;;:::i;:::-;13052:2;13045:22;12798:275;;-1:-1:-1;12798:275:1:o;13078:1283::-;13177:6;13208:2;13251;13239:9;13230:7;13226:23;13222:32;13219:52;;;13267:1;13264;13257:12;13219:52;13300:9;13294:16;13329:18;13370:2;13362:6;13359:14;13356:34;;;13386:1;13383;13376:12;13356:34;13409:22;;;;13465:4;13447:16;;;13443:27;13440:47;;;13483:1;13480;13473:12;13440:47;13509:22;;:::i;:::-;13560:2;13554:9;13547:5;13540:24;13610:2;13606;13602:11;13596:18;13591:2;13584:5;13580:14;13573:42;13661:2;13657;13653:11;13647:18;13642:2;13635:5;13631:14;13624:42;13712:2;13708;13704:11;13698:18;13693:2;13686:5;13682:14;13675:42;13756:3;13752:2;13748:12;13742:19;13786:2;13776:8;13773:16;13770:36;;;13802:1;13799;13792:12;13770:36;13825:17;;13873:4;13865:13;;13861:27;-1:-1:-1;13851:55:1;;13902:1;13899;13892:12;13851:55;13931:2;13925:9;13953:2;13949;13946:10;13943:36;;;13959:18;;:::i;:::-;14001:53;14044:2;14025:13;;-1:-1:-1;;14021:27:1;14017:36;;14001:53;:::i;:::-;13988:66;;14077:2;14070:5;14063:17;14117:7;14112:2;14107;14103;14099:11;14095:20;14092:33;14089:53;;;14138:1;14135;14128:12;14089:53;14151:67;14215:2;14210;14203:5;14199:14;14194:2;14190;14186:11;14151:67;:::i;:::-;;;14251:5;14245:3;14238:5;14234:15;14227:30;14290:40;14325:3;14321:2;14317:12;14290:40;:::i;:::-;14284:3;14273:15;;14266:65;14277:5;13078:1283;-1:-1:-1;;;;;;13078:1283:1:o

ipfs://5c3e31844154840181420b96330812168a90b05fde30b019eefb2576bcdcd8fc