Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.26;

import {AccessControl} from "@openzeppelin/contracts/access/AccessControl.sol";
import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {Math} from "@openzeppelin/contracts/utils/math/Math.sol";
import {TransferHelper} from "@uniswap/v3-periphery/contracts/libraries/TransferHelper.sol";

import {Token} from "./Token.sol";
import {OracleConfigurator} from "./oracle/OracleConfigurator.sol";

import "./Errors.sol";

contract StoneBeraVault is AccessControl {
    using Math for uint256;

    bytes32 public constant VAULT_OPERATOR_ROLE =
        keccak256("VAULT_OPERATOR_ROLE");
    bytes32 public constant ASSETS_MANAGEMENT_ROLE =
        keccak256("ASSETS_MANAGEMENT_ROLE");

    uint256 public constant D18 = 1e18;
    uint256 public constant D6 = 1e6;

    Token public immutable lpToken;
    ERC20 public immutable withdrawToken;

    OracleConfigurator public immutable oracleConfigurator;

    address[] public underlyingAssets;

    mapping(address => bool) public isUnderlyingAssets;
    mapping(address => RedeemRequest) public redeemRequests;
    mapping(uint256 => uint256) public roundPricePerShare;
    mapping(uint256 => uint256) public withdrawTokenPrice;
    mapping(address => bool) public depositPaused;

    mapping(address => uint256) public feeRate;

    uint256 public latestRoundID;
    uint256 public cap;
    uint256 public assetsBorrowed;

    uint256 public redeemableAmountInPast; // calculated as withdrawToken
    uint256 public requestingSharesInPast; // calculated as share
    uint256 public requestingSharesInRound; // calculated as share

    address public feeRecipient;

    struct RedeemRequest {
        uint256 requestRound;
        uint256 requestShares;
    }

    event Deposit(
        address indexed caller,
        address indexed owner,
        address indexed asset,
        uint256 amount,
        uint256 shares
    );
    event RedeemRequested(address indexed owner, uint256 shares, uint256 round);
    event RedeemCancelled(address indexed owner, uint256 shares, uint256 round);
    event RedeemClaimed(address indexed owner, uint256 amount);
    event RollToNextRound(
        uint256 round,
        uint256 share,
        uint256 withdrawTokenAmount,
        uint256 sharePrice,
        uint256 withdrawTokenPrice
    );
    event FeeCharged(address recipient, uint256 fee);
    event SetCap(uint256 oldValue, uint256 newValue);
    event SetDepositPause(address indexed asset, bool flag);
    event SetFeeRate(address indexed asset, uint256 feeRate);
    event SetFeeRecipient(address oldValue, address newValue);
    event AddUnderlyingAsset(address indexed asset);
    event RemoveUnderlyingAsset(address indexed asset);
    event AssetsWithdrawn(address indexed asset, uint256 amount, uint256 value);
    event AssetsRepaid(address indexed asset, uint256 amount, uint256 value);

    constructor(
        address _lpToken,
        address _withdrawToken,
        address _oracleConfigurator,
        uint256 _cap
    ) {
        if (
            _lpToken == address(0) ||
            _withdrawToken == address(0) ||
            _oracleConfigurator == address(0)
        ) revert ZeroAddress();

        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);

        lpToken = Token(_lpToken);
        withdrawToken = Token(_withdrawToken);
        cap = _cap;

        oracleConfigurator = OracleConfigurator(_oracleConfigurator);

        if (oracleConfigurator.oracles(address(_withdrawToken)) == address(0))
            revert InvalidOracle();
    }

    function deposit(
        address _asset,
        uint256 _amount,
        address _receiver
    ) public returns (uint256 shares) {
        if (depositPaused[_asset]) revert DepositPaused();
        if ((shares = previewDeposit(_asset, _amount)) == 0)
            revert ZeroShares();

        if (lpToken.totalSupply() + shares > cap) revert DepositCapped();

        TransferHelper.safeTransferFrom(
            _asset,
            msg.sender,
            address(this),
            _amount
        );

        uint256 fee;
        uint256 rate = feeRate[_asset];
        if (rate != 0) {
            fee = shares.mulDiv(rate, D6);
        }

        if (fee == 0) {
            lpToken.mint(_receiver, shares);
        } else {
            shares -= fee;
            lpToken.mint(_receiver, shares);
            lpToken.mint(feeRecipient, fee);

            emit FeeCharged(feeRecipient, fee);
        }

        emit Deposit(msg.sender, _receiver, _asset, _amount, shares);
    }

    function mint(
        address _asset,
        uint256 _shares,
        address _receiver
    ) external returns (uint256 assets) {
        if (depositPaused[_asset]) revert DepositPaused();
        if (_shares == 0) revert ZeroShares();
        if (lpToken.totalSupply() + _shares > cap) revert DepositCapped();

        assets = previewMint(_asset, _shares);

        TransferHelper.safeTransferFrom(
            _asset,
            msg.sender,
            address(this),
            assets
        );

        uint256 fee;
        uint256 rate = feeRate[_asset];
        if (rate != 0) {
            fee = _shares.mulDiv(rate, D6);
        }

        if (fee == 0) {
            lpToken.mint(_receiver, _shares);
        } else {
            _shares -= fee;
            lpToken.mint(_receiver, _shares);
            lpToken.mint(feeRecipient, fee);

            emit FeeCharged(feeRecipient, fee);
        }

        emit Deposit(msg.sender, _receiver, _asset, assets, _shares);
    }

    function requestRedeem(uint256 _shares) external {
        if (_shares == 0) revert ZeroShares();
        if (_shares > lpToken.balanceOf(msg.sender))
            revert InsufficientBalance();

        TransferHelper.safeTransferFrom(
            address(lpToken),
            msg.sender,
            address(this),
            _shares
        );

        RedeemRequest storage redeemRequest = redeemRequests[msg.sender];

        if (
            redeemRequest.requestShares > 0 &&
            redeemRequest.requestRound < latestRoundID
        ) {
            claimRedeemRequest();
        }

        if (redeemRequest.requestRound == latestRoundID) {
            redeemRequest.requestShares += _shares;
        } else {
            redeemRequest.requestRound = latestRoundID;
            redeemRequest.requestShares = _shares;
        }
        requestingSharesInRound += _shares;

        emit RedeemRequested(msg.sender, _shares, latestRoundID);
    }

    function cancelRequest() external {
        if (pendingRedeemRequest() == 0) revert NoRequestingShares();

        RedeemRequest storage redeemRequest = redeemRequests[msg.sender];

        uint256 requestingShares = redeemRequest.requestShares;
        redeemRequest.requestShares = 0;

        requestingSharesInRound -= requestingShares;

        TransferHelper.safeTransfer(
            address(lpToken),
            msg.sender,
            requestingShares
        );

        emit RedeemCancelled(msg.sender, requestingShares, latestRoundID);
    }

    function claimRedeemRequest() public {
        RedeemRequest storage redeemRequest = redeemRequests[msg.sender];
        uint256 requestShares = redeemRequest.requestShares;

        uint256 claimable;
        uint256 round = redeemRequest.requestRound;
        if (round < latestRoundID && redeemRequest.requestShares != 0) {
            claimable = redeemRequest.requestShares.mulDiv(
                roundPricePerShare[round],
                withdrawTokenPrice[round],
                Math.Rounding.Floor
            );
        } else {
            revert NoClaimableRedeem();
        }

        lpToken.burn(address(this), requestShares);

        redeemRequest.requestShares = 0;

        redeemableAmountInPast -= claimable;
        requestingSharesInPast -= requestShares;

        if (claimable > 0)
            TransferHelper.safeTransfer(
                address(withdrawToken),
                msg.sender,
                claimable
            );

        emit RedeemClaimed(msg.sender, claimable);
    }

    function pendingRedeemRequest() public view returns (uint256 shares) {
        RedeemRequest memory redeemRequest = redeemRequests[msg.sender];

        return
            redeemRequest.requestRound == latestRoundID
                ? redeemRequest.requestShares
                : 0;
    }

    function claimableRedeemRequest() external view returns (uint256 assets) {
        RedeemRequest memory redeemRequest = redeemRequests[msg.sender];

        uint256 round = redeemRequest.requestRound;
        if (round < latestRoundID && redeemRequest.requestShares != 0) {
            assets = redeemRequest.requestShares.mulDiv(
                roundPricePerShare[round],
                withdrawTokenPrice[round],
                Math.Rounding.Floor
            );
        }
    }

    function totalAssets() public view returns (uint256 totalManagedAssets) {
        uint256 length = underlyingAssets.length;
        uint256 i;

        address _this = address(this);

        for (i; i < length; i++) {
            address tokenAddr = underlyingAssets[i];
            ERC20 token = ERC20(tokenAddr);
            uint256 balance = token.balanceOf(_this);

            if (balance != 0) {
                uint256 price = oracleConfigurator.getPrice(tokenAddr);
                uint256 value = price.mulDiv(balance, D18, Math.Rounding.Floor);

                totalManagedAssets += value;
            }
        }
        totalManagedAssets += assetsBorrowed;
    }

    function activeAssets() public view returns (uint256 assets) {
        uint256 price = oracleConfigurator.getPrice(address(withdrawToken));
        uint256 reservedValue = redeemableAmountInPast.mulDiv(
            price,
            D18,
            Math.Rounding.Floor
        );

        return totalAssets() - reservedValue;
    }

    function activeShares() public view returns (uint256 shares) {
        return lpToken.totalSupply() - requestingSharesInPast;
    }

    function convertToShares(
        uint256 _assets
    ) public view returns (uint256 shares) {
        uint256 supply = lpToken.totalSupply();

        return
            supply == 0
                ? _assets
                : _assets.mulDiv(
                    activeShares(),
                    activeAssets(),
                    Math.Rounding.Floor
                );
    }

    function convertToAssets(
        uint256 _shares
    ) public view returns (uint256 assets) {
        uint256 supply = lpToken.totalSupply();

        return
            supply == 0
                ? _shares
                : _shares.mulDiv(
                    activeAssets(),
                    activeShares(),
                    Math.Rounding.Floor
                );
    }

    function previewDeposit(
        address _asset,
        uint256 _amount
    ) public view returns (uint256 shares) {
        if (!isUnderlyingAssets[_asset]) revert InvalidAsset();

        uint256 price = oracleConfigurator.getPrice(_asset);
        uint256 value = _amount.mulDiv(price, D18, Math.Rounding.Floor);

        return convertToShares(value);
    }

    function previewMint(
        address _asset,
        uint256 _shares
    ) public view returns (uint256 assets) {
        if (!isUnderlyingAssets[_asset]) revert InvalidAsset();

        uint256 price = oracleConfigurator.getPrice(_asset);
        uint256 amount = _shares.mulDiv(D18, price, Math.Rounding.Ceil);
        uint256 supply = lpToken.totalSupply();

        return
            supply == 0
                ? amount
                : amount.mulDiv(
                    activeAssets(),
                    activeShares(),
                    Math.Rounding.Ceil
                );
    }

    function getRate() public view returns (uint256 rate) {
        return activeAssets().mulDiv(D18, activeShares(), Math.Rounding.Floor);
    }

    function getUnderlyings()
        external
        view
        returns (address[] memory underlyings)
    {
        return underlyingAssets;
    }

    function rollToNextRound() external onlyRole(VAULT_OPERATOR_ROLE) {
        uint256 price = oracleConfigurator.getPrice(address(withdrawToken));
        uint256 rate = getRate();

        uint256 requestingShares = requestingSharesInRound;
        uint256 withdrawTokenAmount = requestingShares.mulDiv(
            rate,
            price,
            Math.Rounding.Ceil
        );

        if (
            withdrawToken.balanceOf(address(this)) <
            redeemableAmountInPast + withdrawTokenAmount
        ) revert InsufficientBalance();

        redeemableAmountInPast += withdrawTokenAmount;
        requestingSharesInPast += requestingShares;
        requestingSharesInRound = 0;

        roundPricePerShare[latestRoundID] = rate;
        withdrawTokenPrice[latestRoundID] = price;

        emit RollToNextRound(
            latestRoundID,
            requestingShares,
            withdrawTokenAmount,
            rate,
            price
        );
        latestRoundID++;
    }

    function withdrawAssets(
        address _asset,
        uint256 _amount
    ) external onlyRole(ASSETS_MANAGEMENT_ROLE) {
        if (!isUnderlyingAssets[_asset]) revert InvalidAsset();

        uint256 balance = ERC20(_asset).balanceOf(address(this));
        if (balance < _amount) revert InsufficientBalance();

        if (
            _asset == address(withdrawToken) &&
            balance < redeemableAmountInPast + _amount
        ) revert InsufficientBalance();

        uint256 price = oracleConfigurator.getPrice(_asset);
        uint256 value = _amount.mulDiv(price, D18, Math.Rounding.Ceil);

        assetsBorrowed += value;

        TransferHelper.safeTransfer(_asset, msg.sender, _amount);

        emit AssetsWithdrawn(_asset, _amount, value);
    }

    function repayAssets(
        address _asset,
        uint256 _amount
    ) external onlyRole(ASSETS_MANAGEMENT_ROLE) {
        if (!isUnderlyingAssets[_asset]) revert InvalidAsset();

        TransferHelper.safeTransferFrom(
            _asset,
            msg.sender,
            address(this),
            _amount
        );

        uint256 price = oracleConfigurator.getPrice(_asset);
        uint256 value = _amount.mulDiv(price, D18, Math.Rounding.Floor);

        if (value > assetsBorrowed) {
            assetsBorrowed = 0;
        } else {
            assetsBorrowed -= value;
        }

        emit AssetsRepaid(_asset, _amount, value);
    }

    function setCap(uint256 _cap) external onlyRole(VAULT_OPERATOR_ROLE) {
        emit SetCap(cap, _cap);
        cap = _cap;
    }

    function addUnderlyingAsset(
        address _asset
    ) external onlyRole(VAULT_OPERATOR_ROLE) {
        if (_asset == address(0) || isUnderlyingAssets[_asset])
            revert InvalidAsset();
        if (oracleConfigurator.oracles(_asset) == address(0))
            revert InvalidOracle();

        isUnderlyingAssets[_asset] = true;
        underlyingAssets.push(_asset);

        emit AddUnderlyingAsset(_asset);
    }

    function removeUnderlyingAsset(
        address _asset
    ) external onlyRole(VAULT_OPERATOR_ROLE) {
        if (!isUnderlyingAssets[_asset]) revert InvalidAsset();

        address[] memory assets = underlyingAssets;

        uint256 length = assets.length;
        uint256 i;
        for (i; i < length; i++) {
            if (assets[i] == _asset) {
                underlyingAssets[i] = underlyingAssets[length - 1];
                underlyingAssets.pop();
                break;
            }
        }
        isUnderlyingAssets[_asset] = false;

        emit RemoveUnderlyingAsset(_asset);
    }

    function setDepositPause(
        address _token,
        bool _pause
    ) external onlyRole(VAULT_OPERATOR_ROLE) {
        depositPaused[_token] = _pause;
        emit SetDepositPause(_token, _pause);
    }

    function setFeeRate(
        address _token,
        uint256 _feeRate
    ) external onlyRole(VAULT_OPERATOR_ROLE) {
        if (feeRecipient == address(0)) revert NoFeeRecipient();
        if (!isUnderlyingAssets[_token]) revert InvalidAsset();
        if (_feeRate > D6) revert InvalidFeeRate();

        feeRate[_token] = _feeRate;

        emit SetFeeRate(_token, _feeRate);
    }

    function setFeeRecipient(
        address _feeRecipient
    ) external onlyRole(VAULT_OPERATOR_ROLE) {
        if (_feeRecipient == address(0)) revert ZeroAddress();

        emit SetFeeRecipient(feeRecipient, _feeRecipient);
        feeRecipient = _feeRecipient;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (access/AccessControl.sol)

pragma solidity ^0.8.20;

import {IAccessControl} from "./IAccessControl.sol";
import {Context} from "../utils/Context.sol";
import {ERC165} from "../utils/introspection/ERC165.sol";

/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```solidity
 * bytes32 public constant MY_ROLE = keccak256("MY_ROLE");
 * ```
 *
 * Roles can be used to represent a set of permissions. To restrict access to a
 * function call, use {hasRole}:
 *
 * ```solidity
 * function foo() public {
 *     require(hasRole(MY_ROLE, msg.sender));
 *     ...
 * }
 * ```
 *
 * Roles can be granted and revoked dynamically via the {grantRole} and
 * {revokeRole} functions. Each role has an associated admin role, and only
 * accounts that have a role's admin role can call {grantRole} and {revokeRole}.
 *
 * By default, the admin role for all roles is `DEFAULT_ADMIN_ROLE`, which means
 * that only accounts with this role will be able to grant or revoke other
 * roles. More complex role relationships can be created by using
 * {_setRoleAdmin}.
 *
 * WARNING: The `DEFAULT_ADMIN_ROLE` is also its own admin: it has permission to
 * grant and revoke this role. Extra precautions should be taken to secure
 * accounts that have been granted it. We recommend using {AccessControlDefaultAdminRules}
 * to enforce additional security measures for this role.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address account => bool) hasRole;
        bytes32 adminRole;
    }

    mapping(bytes32 role => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with an {AccessControlUnauthorizedAccount} error including the required role.
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role);
        _;
    }

    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IAccessControl).interfaceId || super.supportsInterface(interfaceId);
    }

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) public view virtual returns (bool) {
        return _roles[role].hasRole[account];
    }

    /**
     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `_msgSender()`
     * is missing `role`. Overriding this function changes the behavior of the {onlyRole} modifier.
     */
    function _checkRole(bytes32 role) internal view virtual {
        _checkRole(role, _msgSender());
    }

    /**
     * @dev Reverts with an {AccessControlUnauthorizedAccount} error if `account`
     * is missing `role`.
     */
    function _checkRole(bytes32 role, address account) internal view virtual {
        if (!hasRole(role, account)) {
            revert AccessControlUnauthorizedAccount(account, role);
        }
    }

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) public view virtual returns (bytes32) {
        return _roles[role].adminRole;
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleGranted} event.
     */
    function grantRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {
        _grantRole(role, account);
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     *
     * May emit a {RoleRevoked} event.
     */
    function revokeRole(bytes32 role, address account) public virtual onlyRole(getRoleAdmin(role)) {
        _revokeRole(role, account);
    }

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been revoked `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `callerConfirmation`.
     *
     * May emit a {RoleRevoked} event.
     */
    function renounceRole(bytes32 role, address callerConfirmation) public virtual {
        if (callerConfirmation != _msgSender()) {
            revert AccessControlBadConfirmation();
        }

        _revokeRole(role, callerConfirmation);
    }

    /**
     * @dev Sets `adminRole` as ``role``'s admin role.
     *
     * Emits a {RoleAdminChanged} event.
     */
    function _setRoleAdmin(bytes32 role, bytes32 adminRole) internal virtual {
        bytes32 previousAdminRole = getRoleAdmin(role);
        _roles[role].adminRole = adminRole;
        emit RoleAdminChanged(role, previousAdminRole, adminRole);
    }

    /**
     * @dev Attempts to grant `role` to `account` and returns a boolean indicating if `role` was granted.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleGranted} event.
     */
    function _grantRole(bytes32 role, address account) internal virtual returns (bool) {
        if (!hasRole(role, account)) {
            _roles[role].hasRole[account] = true;
            emit RoleGranted(role, account, _msgSender());
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Attempts to revoke `role` to `account` and returns a boolean indicating if `role` was revoked.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleRevoked} event.
     */
    function _revokeRole(bytes32 role, address account) internal virtual returns (bool) {
        if (hasRole(role, account)) {
            _roles[role].hasRole[account] = false;
            emit RoleRevoked(role, account, _msgSender());
            return true;
        } else {
            return false;
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/ERC20.sol)

pragma solidity ^0.8.20;

import {IERC20} from "./IERC20.sol";
import {IERC20Metadata} from "./extensions/IERC20Metadata.sol";
import {Context} from "../../utils/Context.sol";
import {IERC20Errors} from "../../interfaces/draft-IERC6093.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC-20
 * applications.
 */
abstract contract ERC20 is Context, IERC20, IERC20Metadata, IERC20Errors {
    mapping(address account => uint256) private _balances;

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

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

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

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

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

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

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

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

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `value` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 value) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, value);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Skips emitting an {Approval} event indicating an allowance update. This is not
     * required by the ERC. See {xref-ERC20-_approve-address-address-uint256-bool-}[_approve].
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `value`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `value`.
     */
    function transferFrom(address from, address to, uint256 value) public virtual returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, value);
        _transfer(from, to, value);
        return true;
    }

    /**
     * @dev Moves a `value` amount of tokens from `from` to `to`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _transfer(address from, address to, uint256 value) internal {
        if (from == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        if (to == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(from, to, value);
    }

    /**
     * @dev Transfers a `value` amount of tokens from `from` to `to`, or alternatively mints (or burns) if `from`
     * (or `to`) is the zero address. All customizations to transfers, mints, and burns should be done by overriding
     * this function.
     *
     * Emits a {Transfer} event.
     */
    function _update(address from, address to, uint256 value) internal virtual {
        if (from == address(0)) {
            // Overflow check required: The rest of the code assumes that totalSupply never overflows
            _totalSupply += value;
        } else {
            uint256 fromBalance = _balances[from];
            if (fromBalance < value) {
                revert ERC20InsufficientBalance(from, fromBalance, value);
            }
            unchecked {
                // Overflow not possible: value <= fromBalance <= totalSupply.
                _balances[from] = fromBalance - value;
            }
        }

        if (to == address(0)) {
            unchecked {
                // Overflow not possible: value <= totalSupply or value <= fromBalance <= totalSupply.
                _totalSupply -= value;
            }
        } else {
            unchecked {
                // Overflow not possible: balance + value is at most totalSupply, which we know fits into a uint256.
                _balances[to] += value;
            }
        }

        emit Transfer(from, to, value);
    }

    /**
     * @dev Creates a `value` amount of tokens and assigns them to `account`, by transferring it from address(0).
     * Relies on the `_update` mechanism
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead.
     */
    function _mint(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidReceiver(address(0));
        }
        _update(address(0), account, value);
    }

    /**
     * @dev Destroys a `value` amount of tokens from `account`, lowering the total supply.
     * Relies on the `_update` mechanism.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * NOTE: This function is not virtual, {_update} should be overridden instead
     */
    function _burn(address account, uint256 value) internal {
        if (account == address(0)) {
            revert ERC20InvalidSender(address(0));
        }
        _update(account, address(0), value);
    }

    /**
     * @dev Sets `value` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     *
     * Overrides to this logic should be done to the variant with an additional `bool emitEvent` argument.
     */
    function _approve(address owner, address spender, uint256 value) internal {
        _approve(owner, spender, value, true);
    }

    /**
     * @dev Variant of {_approve} with an optional flag to enable or disable the {Approval} event.
     *
     * By default (when calling {_approve}) the flag is set to true. On the other hand, approval changes made by
     * `_spendAllowance` during the `transferFrom` operation set the flag to false. This saves gas by not emitting any
     * `Approval` event during `transferFrom` operations.
     *
     * Anyone who wishes to continue emitting `Approval` events on the`transferFrom` operation can force the flag to
     * true using the following override:
     *
     * ```solidity
     * function _approve(address owner, address spender, uint256 value, bool) internal virtual override {
     *     super._approve(owner, spender, value, true);
     * }
     * ```
     *
     * Requirements are the same as {_approve}.
     */
    function _approve(address owner, address spender, uint256 value, bool emitEvent) internal virtual {
        if (owner == address(0)) {
            revert ERC20InvalidApprover(address(0));
        }
        if (spender == address(0)) {
            revert ERC20InvalidSpender(address(0));
        }
        _allowances[owner][spender] = value;
        if (emitEvent) {
            emit Approval(owner, spender, value);
        }
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `value`.
     *
     * Does not update the allowance value in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Does not emit an {Approval} event.
     */
    function _spendAllowance(address owner, address spender, uint256 value) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            if (currentAllowance < value) {
                revert ERC20InsufficientAllowance(spender, currentAllowance, value);
            }
            unchecked {
                _approve(owner, spender, currentAllowance - value, false);
            }
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/Math.sol)

pragma solidity ^0.8.20;

import {Panic} from "../Panic.sol";
import {SafeCast} from "./SafeCast.sol";

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

    /**
     * @dev Returns the addition of two unsigned integers, with an success flag (no overflow).
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, with an success flag (no overflow).
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an success flag (no overflow).
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a success flag (no division by zero).
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a success flag (no division by zero).
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool success, uint256 result) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Branchless ternary evaluation for `a ? b : c`. Gas costs are constant.
     *
     * IMPORTANT: This function may reduce bytecode size and consume less gas when used standalone.
     * However, the compiler may optimize Solidity ternary operations (i.e. `a ? b : c`) to only compute
     * one branch when needed, making this function more expensive.
     */
    function ternary(bool condition, uint256 a, uint256 b) internal pure returns (uint256) {
        unchecked {
            // branchless ternary works because:
            // b ^ (a ^ b) == a
            // b ^ 0 == b
            return b ^ ((a ^ b) * SafeCast.toUint(condition));
        }
    }

    /**
     * @dev Returns the largest of two numbers.
     */
    function max(uint256 a, uint256 b) internal pure returns (uint256) {
        return ternary(a > b, a, b);
    }

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

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

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds towards infinity instead
     * of rounding towards zero.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        if (b == 0) {
            // Guarantee the same behavior as in a regular Solidity division.
            Panic.panic(Panic.DIVISION_BY_ZERO);
        }

        // The following calculation ensures accurate ceiling division without overflow.
        // Since a is non-zero, (a - 1) / b will not overflow.
        // The largest possible result occurs when (a - 1) / b is type(uint256).max,
        // but the largest value we can obtain is type(uint256).max - 1, which happens
        // when a = type(uint256).max and b = 1.
        unchecked {
            return SafeCast.toUint(a > 0) * ((a - 1) / b + 1);
        }
    }

    /**
     * @dev Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
     * denominator == 0.
     *
     * Original credit to Remco Bloemen under MIT license (https://xn--2-umb.com/21/muldiv) with further edits by
     * Uniswap Labs also under MIT license.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator) internal pure returns (uint256 result) {
        unchecked {
            // 512-bit multiply [prod1 prod0] = x * y. Compute the product mod 2²⁵⁶ and mod 2²⁵⁶ - 1, then use
            // the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2²⁵⁶ + prod0.
            uint256 prod0 = x * y; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod1 := sub(sub(mm, prod0), lt(mm, prod0))
            }

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                // Solidity will revert if denominator == 0, unlike the div opcode on its own.
                // The surrounding unchecked block does not change this fact.
                // See https://docs.soliditylang.org/en/latest/control-structures.html#checked-or-unchecked-arithmetic.
                return prod0 / denominator;
            }

            // Make sure the result is less than 2²⁵⁶. Also prevents denominator == 0.
            if (denominator <= prod1) {
                Panic.panic(ternary(denominator == 0, Panic.DIVISION_BY_ZERO, Panic.UNDER_OVERFLOW));
            }

            ///////////////////////////////////////////////
            // 512 by 256 division.
            ///////////////////////////////////////////////

            // Make division exact by subtracting the remainder from [prod1 prod0].
            uint256 remainder;
            assembly {
                // Compute remainder using mulmod.
                remainder := mulmod(x, y, denominator)

                // Subtract 256 bit number from 512 bit number.
                prod1 := sub(prod1, gt(remainder, prod0))
                prod0 := sub(prod0, remainder)
            }

            // Factor powers of two out of denominator and compute largest power of two divisor of denominator.
            // Always >= 1. See https://cs.stackexchange.com/q/138556/92363.

            uint256 twos = denominator & (0 - denominator);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

                // Divide [prod1 prod0] by twos.
                prod0 := div(prod0, twos)

                // Flip twos such that it is 2²⁵⁶ / twos. If twos is zero, then it becomes one.
                twos := add(div(sub(0, twos), twos), 1)
            }

            // Shift in bits from prod1 into prod0.
            prod0 |= prod1 * twos;

            // Invert denominator mod 2²⁵⁶. Now that denominator is an odd number, it has an inverse modulo 2²⁵⁶ such
            // that denominator * inv ≡ 1 mod 2²⁵⁶. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv ≡ 1 mod 2⁴.
            uint256 inverse = (3 * denominator) ^ 2;

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
            // works in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2⁸
            inverse *= 2 - denominator * inverse; // inverse mod 2¹⁶
            inverse *= 2 - denominator * inverse; // inverse mod 2³²
            inverse *= 2 - denominator * inverse; // inverse mod 2⁶⁴
            inverse *= 2 - denominator * inverse; // inverse mod 2¹²⁸
            inverse *= 2 - denominator * inverse; // inverse mod 2²⁵⁶

            // Because the division is now exact we can divide by multiplying with the modular inverse of denominator.
            // This will give us the correct result modulo 2²⁵⁶. Since the preconditions guarantee that the outcome is
            // less than 2²⁵⁶, this is the final result. We don't need to compute the high bits of the result and prod1
            // is no longer required.
            result = prod0 * inverse;
            return result;
        }
    }

    /**
     * @dev Calculates x * y / denominator with full precision, following the selected rounding direction.
     */
    function mulDiv(uint256 x, uint256 y, uint256 denominator, Rounding rounding) internal pure returns (uint256) {
        return mulDiv(x, y, denominator) + SafeCast.toUint(unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0);
    }

    /**
     * @dev Calculate the modular multiplicative inverse of a number in Z/nZ.
     *
     * If n is a prime, then Z/nZ is a field. In that case all elements are inversible, except 0.
     * If n is not a prime, then Z/nZ is not a field, and some elements might not be inversible.
     *
     * If the input value is not inversible, 0 is returned.
     *
     * NOTE: If you know for sure that n is (big) a prime, it may be cheaper to use Fermat's little theorem and get the
     * inverse using `Math.modExp(a, n - 2, n)`. See {invModPrime}.
     */
    function invMod(uint256 a, uint256 n) internal pure returns (uint256) {
        unchecked {
            if (n == 0) return 0;

            // The inverse modulo is calculated using the Extended Euclidean Algorithm (iterative version)
            // Used to compute integers x and y such that: ax + ny = gcd(a, n).
            // When the gcd is 1, then the inverse of a modulo n exists and it's x.
            // ax + ny = 1
            // ax = 1 + (-y)n
            // ax ≡ 1 (mod n) # x is the inverse of a modulo n

            // If the remainder is 0 the gcd is n right away.
            uint256 remainder = a % n;
            uint256 gcd = n;

            // Therefore the initial coefficients are:
            // ax + ny = gcd(a, n) = n
            // 0a + 1n = n
            int256 x = 0;
            int256 y = 1;

            while (remainder != 0) {
                uint256 quotient = gcd / remainder;

                (gcd, remainder) = (
                    // The old remainder is the next gcd to try.
                    remainder,
                    // Compute the next remainder.
                    // Can't overflow given that (a % gcd) * (gcd // (a % gcd)) <= gcd
                    // where gcd is at most n (capped to type(uint256).max)
                    gcd - remainder * quotient
                );

                (x, y) = (
                    // Increment the coefficient of a.
                    y,
                    // Decrement the coefficient of n.
                    // Can overflow, but the result is casted to uint256 so that the
                    // next value of y is "wrapped around" to a value between 0 and n - 1.
                    x - y * int256(quotient)
                );
            }

            if (gcd != 1) return 0; // No inverse exists.
            return ternary(x < 0, n - uint256(-x), uint256(x)); // Wrap the result if it's negative.
        }
    }

    /**
     * @dev Variant of {invMod}. More efficient, but only works if `p` is known to be a prime greater than `2`.
     *
     * From https://en.wikipedia.org/wiki/Fermat%27s_little_theorem[Fermat's little theorem], we know that if p is
     * prime, then `a**(p-1) ≡ 1 mod p`. As a consequence, we have `a * a**(p-2) ≡ 1 mod p`, which means that
     * `a**(p-2)` is the modular multiplicative inverse of a in Fp.
     *
     * NOTE: this function does NOT check that `p` is a prime greater than `2`.
     */
    function invModPrime(uint256 a, uint256 p) internal view returns (uint256) {
        unchecked {
            return Math.modExp(a, p - 2, p);
        }
    }

    /**
     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m)
     *
     * Requirements:
     * - modulus can't be zero
     * - underlying staticcall to precompile must succeed
     *
     * IMPORTANT: The result is only valid if the underlying call succeeds. When using this function, make
     * sure the chain you're using it on supports the precompiled contract for modular exponentiation
     * at address 0x05 as specified in https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise,
     * the underlying function will succeed given the lack of a revert, but the result may be incorrectly
     * interpreted as 0.
     */
    function modExp(uint256 b, uint256 e, uint256 m) internal view returns (uint256) {
        (bool success, uint256 result) = tryModExp(b, e, m);
        if (!success) {
            Panic.panic(Panic.DIVISION_BY_ZERO);
        }
        return result;
    }

    /**
     * @dev Returns the modular exponentiation of the specified base, exponent and modulus (b ** e % m).
     * It includes a success flag indicating if the operation succeeded. Operation will be marked as failed if trying
     * to operate modulo 0 or if the underlying precompile reverted.
     *
     * IMPORTANT: The result is only valid if the success flag is true. When using this function, make sure the chain
     * you're using it on supports the precompiled contract for modular exponentiation at address 0x05 as specified in
     * https://eips.ethereum.org/EIPS/eip-198[EIP-198]. Otherwise, the underlying function will succeed given the lack
     * of a revert, but the result may be incorrectly interpreted as 0.
     */
    function tryModExp(uint256 b, uint256 e, uint256 m) internal view returns (bool success, uint256 result) {
        if (m == 0) return (false, 0);
        assembly ("memory-safe") {
            let ptr := mload(0x40)
            // | Offset    | Content    | Content (Hex)                                                      |
            // |-----------|------------|--------------------------------------------------------------------|
            // | 0x00:0x1f | size of b  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
            // | 0x20:0x3f | size of e  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
            // | 0x40:0x5f | size of m  | 0x0000000000000000000000000000000000000000000000000000000000000020 |
            // | 0x60:0x7f | value of b | 0x<.............................................................b> |
            // | 0x80:0x9f | value of e | 0x<.............................................................e> |
            // | 0xa0:0xbf | value of m | 0x<.............................................................m> |
            mstore(ptr, 0x20)
            mstore(add(ptr, 0x20), 0x20)
            mstore(add(ptr, 0x40), 0x20)
            mstore(add(ptr, 0x60), b)
            mstore(add(ptr, 0x80), e)
            mstore(add(ptr, 0xa0), m)

            // Given the result < m, it's guaranteed to fit in 32 bytes,
            // so we can use the memory scratch space located at offset 0.
            success := staticcall(gas(), 0x05, ptr, 0xc0, 0x00, 0x20)
            result := mload(0x00)
        }
    }

    /**
     * @dev Variant of {modExp} that supports inputs of arbitrary length.
     */
    function modExp(bytes memory b, bytes memory e, bytes memory m) internal view returns (bytes memory) {
        (bool success, bytes memory result) = tryModExp(b, e, m);
        if (!success) {
            Panic.panic(Panic.DIVISION_BY_ZERO);
        }
        return result;
    }

    /**
     * @dev Variant of {tryModExp} that supports inputs of arbitrary length.
     */
    function tryModExp(
        bytes memory b,
        bytes memory e,
        bytes memory m
    ) internal view returns (bool success, bytes memory result) {
        if (_zeroBytes(m)) return (false, new bytes(0));

        uint256 mLen = m.length;

        // Encode call args in result and move the free memory pointer
        result = abi.encodePacked(b.length, e.length, mLen, b, e, m);

        assembly ("memory-safe") {
            let dataPtr := add(result, 0x20)
            // Write result on top of args to avoid allocating extra memory.
            success := staticcall(gas(), 0x05, dataPtr, mload(result), dataPtr, mLen)
            // Overwrite the length.
            // result.length > returndatasize() is guaranteed because returndatasize() == m.length
            mstore(result, mLen)
            // Set the memory pointer after the returned data.
            mstore(0x40, add(dataPtr, mLen))
        }
    }

    /**
     * @dev Returns whether the provided byte array is zero.
     */
    function _zeroBytes(bytes memory byteArray) private pure returns (bool) {
        for (uint256 i = 0; i < byteArray.length; ++i) {
            if (byteArray[i] != 0) {
                return false;
            }
        }
        return true;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * This method is based on Newton's method for computing square roots; the algorithm is restricted to only
     * using integer operations.
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        unchecked {
            // Take care of easy edge cases when a == 0 or a == 1
            if (a <= 1) {
                return a;
            }

            // In this function, we use Newton's method to get a root of `f(x) := x² - a`. It involves building a
            // sequence x_n that converges toward sqrt(a). For each iteration x_n, we also define the error between
            // the current value as `ε_n = | x_n - sqrt(a) |`.
            //
            // For our first estimation, we consider `e` the smallest power of 2 which is bigger than the square root
            // of the target. (i.e. `2**(e-1) ≤ sqrt(a) < 2**e`). We know that `e ≤ 128` because `(2¹²⁸)² = 2²⁵⁶` is
            // bigger than any uint256.
            //
            // By noticing that
            // `2**(e-1) ≤ sqrt(a) < 2**e → (2**(e-1))² ≤ a < (2**e)² → 2**(2*e-2) ≤ a < 2**(2*e)`
            // we can deduce that `e - 1` is `log2(a) / 2`. We can thus compute `x_n = 2**(e-1)` using a method similar
            // to the msb function.
            uint256 aa = a;
            uint256 xn = 1;

            if (aa >= (1 << 128)) {
                aa >>= 128;
                xn <<= 64;
            }
            if (aa >= (1 << 64)) {
                aa >>= 64;
                xn <<= 32;
            }
            if (aa >= (1 << 32)) {
                aa >>= 32;
                xn <<= 16;
            }
            if (aa >= (1 << 16)) {
                aa >>= 16;
                xn <<= 8;
            }
            if (aa >= (1 << 8)) {
                aa >>= 8;
                xn <<= 4;
            }
            if (aa >= (1 << 4)) {
                aa >>= 4;
                xn <<= 2;
            }
            if (aa >= (1 << 2)) {
                xn <<= 1;
            }

            // We now have x_n such that `x_n = 2**(e-1) ≤ sqrt(a) < 2**e = 2 * x_n`. This implies ε_n ≤ 2**(e-1).
            //
            // We can refine our estimation by noticing that the middle of that interval minimizes the error.
            // If we move x_n to equal 2**(e-1) + 2**(e-2), then we reduce the error to ε_n ≤ 2**(e-2).
            // This is going to be our x_0 (and ε_0)
            xn = (3 * xn) >> 1; // ε_0 := | x_0 - sqrt(a) | ≤ 2**(e-2)

            // From here, Newton's method give us:
            // x_{n+1} = (x_n + a / x_n) / 2
            //
            // One should note that:
            // x_{n+1}² - a = ((x_n + a / x_n) / 2)² - a
            //              = ((x_n² + a) / (2 * x_n))² - a
            //              = (x_n⁴ + 2 * a * x_n² + a²) / (4 * x_n²) - a
            //              = (x_n⁴ + 2 * a * x_n² + a² - 4 * a * x_n²) / (4 * x_n²)
            //              = (x_n⁴ - 2 * a * x_n² + a²) / (4 * x_n²)
            //              = (x_n² - a)² / (2 * x_n)²
            //              = ((x_n² - a) / (2 * x_n))²
            //              ≥ 0
            // Which proves that for all n ≥ 1, sqrt(a) ≤ x_n
            //
            // This gives us the proof of quadratic convergence of the sequence:
            // ε_{n+1} = | x_{n+1} - sqrt(a) |
            //         = | (x_n + a / x_n) / 2 - sqrt(a) |
            //         = | (x_n² + a - 2*x_n*sqrt(a)) / (2 * x_n) |
            //         = | (x_n - sqrt(a))² / (2 * x_n) |
            //         = | ε_n² / (2 * x_n) |
            //         = ε_n² / | (2 * x_n) |
            //
            // For the first iteration, we have a special case where x_0 is known:
            // ε_1 = ε_0² / | (2 * x_0) |
            //     ≤ (2**(e-2))² / (2 * (2**(e-1) + 2**(e-2)))
            //     ≤ 2**(2*e-4) / (3 * 2**(e-1))
            //     ≤ 2**(e-3) / 3
            //     ≤ 2**(e-3-log2(3))
            //     ≤ 2**(e-4.5)
            //
            // For the following iterations, we use the fact that, 2**(e-1) ≤ sqrt(a) ≤ x_n:
            // ε_{n+1} = ε_n² / | (2 * x_n) |
            //         ≤ (2**(e-k))² / (2 * 2**(e-1))
            //         ≤ 2**(2*e-2*k) / 2**e
            //         ≤ 2**(e-2*k)
            xn = (xn + a / xn) >> 1; // ε_1 := | x_1 - sqrt(a) | ≤ 2**(e-4.5)  -- special case, see above
            xn = (xn + a / xn) >> 1; // ε_2 := | x_2 - sqrt(a) | ≤ 2**(e-9)    -- general case with k = 4.5
            xn = (xn + a / xn) >> 1; // ε_3 := | x_3 - sqrt(a) | ≤ 2**(e-18)   -- general case with k = 9
            xn = (xn + a / xn) >> 1; // ε_4 := | x_4 - sqrt(a) | ≤ 2**(e-36)   -- general case with k = 18
            xn = (xn + a / xn) >> 1; // ε_5 := | x_5 - sqrt(a) | ≤ 2**(e-72)   -- general case with k = 36
            xn = (xn + a / xn) >> 1; // ε_6 := | x_6 - sqrt(a) | ≤ 2**(e-144)  -- general case with k = 72

            // Because e ≤ 128 (as discussed during the first estimation phase), we know have reached a precision
            // ε_6 ≤ 2**(e-144) < 1. Given we're operating on integers, then we can ensure that xn is now either
            // sqrt(a) or sqrt(a) + 1.
            return xn - SafeCast.toUint(xn > a / xn);
        }
    }

    /**
     * @dev Calculates sqrt(a), following the selected rounding direction.
     */
    function sqrt(uint256 a, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = sqrt(a);
            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && result * result < a);
        }
    }

    /**
     * @dev Return the log in base 2 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log2(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        uint256 exp;
        unchecked {
            exp = 128 * SafeCast.toUint(value > (1 << 128) - 1);
            value >>= exp;
            result += exp;

            exp = 64 * SafeCast.toUint(value > (1 << 64) - 1);
            value >>= exp;
            result += exp;

            exp = 32 * SafeCast.toUint(value > (1 << 32) - 1);
            value >>= exp;
            result += exp;

            exp = 16 * SafeCast.toUint(value > (1 << 16) - 1);
            value >>= exp;
            result += exp;

            exp = 8 * SafeCast.toUint(value > (1 << 8) - 1);
            value >>= exp;
            result += exp;

            exp = 4 * SafeCast.toUint(value > (1 << 4) - 1);
            value >>= exp;
            result += exp;

            exp = 2 * SafeCast.toUint(value > (1 << 2) - 1);
            value >>= exp;
            result += exp;

            result += SafeCast.toUint(value > 1);
        }
        return result;
    }

    /**
     * @dev Return the log in base 2, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log2(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log2(value);
            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << result < value);
        }
    }

    /**
     * @dev Return the log in base 10 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     */
    function log10(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        unchecked {
            if (value >= 10 ** 64) {
                value /= 10 ** 64;
                result += 64;
            }
            if (value >= 10 ** 32) {
                value /= 10 ** 32;
                result += 32;
            }
            if (value >= 10 ** 16) {
                value /= 10 ** 16;
                result += 16;
            }
            if (value >= 10 ** 8) {
                value /= 10 ** 8;
                result += 8;
            }
            if (value >= 10 ** 4) {
                value /= 10 ** 4;
                result += 4;
            }
            if (value >= 10 ** 2) {
                value /= 10 ** 2;
                result += 2;
            }
            if (value >= 10 ** 1) {
                result += 1;
            }
        }
        return result;
    }

    /**
     * @dev Return the log in base 10, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log10(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log10(value);
            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 10 ** result < value);
        }
    }

    /**
     * @dev Return the log in base 256 of a positive value rounded towards zero.
     * Returns 0 if given 0.
     *
     * Adding one to the result gives the number of pairs of hex symbols needed to represent `value` as a hex string.
     */
    function log256(uint256 value) internal pure returns (uint256) {
        uint256 result = 0;
        uint256 isGt;
        unchecked {
            isGt = SafeCast.toUint(value > (1 << 128) - 1);
            value >>= isGt * 128;
            result += isGt * 16;

            isGt = SafeCast.toUint(value > (1 << 64) - 1);
            value >>= isGt * 64;
            result += isGt * 8;

            isGt = SafeCast.toUint(value > (1 << 32) - 1);
            value >>= isGt * 32;
            result += isGt * 4;

            isGt = SafeCast.toUint(value > (1 << 16) - 1);
            value >>= isGt * 16;
            result += isGt * 2;

            result += SafeCast.toUint(value > (1 << 8) - 1);
        }
        return result;
    }

    /**
     * @dev Return the log in base 256, following the selected rounding direction, of a positive value.
     * Returns 0 if given 0.
     */
    function log256(uint256 value, Rounding rounding) internal pure returns (uint256) {
        unchecked {
            uint256 result = log256(value);
            return result + SafeCast.toUint(unsignedRoundsUp(rounding) && 1 << (result << 3) < value);
        }
    }

    /**
     * @dev Returns whether a provided rounding mode is considered rounding up for unsigned integers.
     */
    function unsignedRoundsUp(Rounding rounding) internal pure returns (bool) {
        return uint8(rounding) % 2 == 1;
    }
}

// SPDX-License-Identifier: GPL-2.0-or-later
pragma solidity >=0.6.0;

import '@openzeppelin/contracts/token/ERC20/IERC20.sol';

library TransferHelper {
    /// @notice Transfers tokens from the targeted address to the given destination
    /// @notice Errors with 'STF' if transfer fails
    /// @param token The contract address of the token to be transferred
    /// @param from The originating address from which the tokens will be transferred
    /// @param to The destination address of the transfer
    /// @param value The amount to be transferred
    function safeTransferFrom(
        address token,
        address from,
        address to,
        uint256 value
    ) internal {
        (bool success, bytes memory data) =
            token.call(abi.encodeWithSelector(IERC20.transferFrom.selector, from, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'STF');
    }

    /// @notice Transfers tokens from msg.sender to a recipient
    /// @dev Errors with ST if transfer fails
    /// @param token The contract address of the token which will be transferred
    /// @param to The recipient of the transfer
    /// @param value The value of the transfer
    function safeTransfer(
        address token,
        address to,
        uint256 value
    ) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.transfer.selector, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'ST');
    }

    /// @notice Approves the stipulated contract to spend the given allowance in the given token
    /// @dev Errors with 'SA' if transfer fails
    /// @param token The contract address of the token to be approved
    /// @param to The target of the approval
    /// @param value The amount of the given token the target will be allowed to spend
    function safeApprove(
        address token,
        address to,
        uint256 value
    ) internal {
        (bool success, bytes memory data) = token.call(abi.encodeWithSelector(IERC20.approve.selector, to, value));
        require(success && (data.length == 0 || abi.decode(data, (bool))), 'SA');
    }

    /// @notice Transfers ETH to the recipient address
    /// @dev Fails with `STE`
    /// @param to The destination of the transfer
    /// @param value The value to be transferred
    function safeTransferETH(address to, uint256 value) internal {
        (bool success, ) = to.call{value: value}(new bytes(0));
        require(success, 'STE');
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.26;

import {ERC20} from "@openzeppelin/contracts/token/ERC20/ERC20.sol";
import {AccessControl} from "@openzeppelin/contracts/access/AccessControl.sol";

contract Token is ERC20, AccessControl {
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    bytes32 public constant BURNER_ROLE = keccak256("BURNER_ROLE");

    constructor(
        string memory _name,
        string memory _symbol
    ) ERC20(_name, _symbol) {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
    }

    function mint(address _to, uint256 _amount) external onlyRole(MINTER_ROLE) {
        _mint(_to, _amount);
    }

    function burn(
        address _from,
        uint256 _amount
    ) external onlyRole(BURNER_ROLE) {
        _burn(_from, _amount);
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.26;

import {AccessControl} from "@openzeppelin/contracts/access/AccessControl.sol";

import {Oracle} from "./Oracle.sol";
import "../Errors.sol";

contract OracleConfigurator is AccessControl {
    bytes32 public constant ORACLE_MANAGER_ROLE =
        keccak256("ORACLE_MANAGER_ROLE");

    mapping(address => address) public oracles;

    event OracleUpdated(address oldOracle, address newOracle);

    constructor() {
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
    }

    function updateOracle(
        address _token,
        address _oracle
    ) external onlyRole(ORACLE_MANAGER_ROLE) {
        if (_token == address(0)) revert InvalidToken();
        if (_oracle == address(0)) revert InvalidOracle();

        emit OracleUpdated(oracles[_token], _oracle);

        oracles[_token] = _oracle;
    }

    function getPrice(address _token) external view returns (uint256 price) {
        address oracle = oracles[_token];

        if (_token == address(0) || oracle == address(0)) revert InvalidToken();

        price = Oracle(oracle).getPrice();
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.26;

error InvalidToken();

error InvalidAsset();

error InsufficientBalance();

error InvalidOracle();

error InvalidPrice();

error InvalidArrayLength();

error DepositCapped();

error DepositPaused();

error ZeroShares();

error NoRequestingShares();

error NoClaimableRedeem();

error ZeroAddress();

error InvalidRequest();

error InvalidRequestToken();

error CannotRemove();

error InvalidDecimals();

error InvalidFeeRate();

error NoFeeRecipient();

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (access/IAccessControl.sol)

pragma solidity ^0.8.20;

/**
 * @dev External interface of AccessControl declared to support ERC-165 detection.
 */
interface IAccessControl {
    /**
     * @dev The `account` is missing a role.
     */
    error AccessControlUnauthorizedAccount(address account, bytes32 neededRole);

    /**
     * @dev The caller of a function is not the expected one.
     *
     * NOTE: Don't confuse with {AccessControlUnauthorizedAccount}.
     */
    error AccessControlBadConfirmation();

    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call. This account bears the admin role (for the granted role).
     * Expected in cases where the role was granted using the internal {AccessControl-_grantRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Emitted when `account` is revoked `role`.
     *
     * `sender` is the account that originated the contract call:
     *   - if using `revokeRole`, it is the admin role bearer
     *   - if using `renounceRole`, it is the role bearer (i.e. `account`)
     */
    event RoleRevoked(bytes32 indexed role, address indexed account, address indexed sender);

    /**
     * @dev Returns `true` if `account` has been granted `role`.
     */
    function hasRole(bytes32 role, address account) external view returns (bool);

    /**
     * @dev Returns the admin role that controls `role`. See {grantRole} and
     * {revokeRole}.
     *
     * To change a role's admin, use {AccessControl-_setRoleAdmin}.
     */
    function getRoleAdmin(bytes32 role) external view returns (bytes32);

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function grantRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from `account`.
     *
     * If `account` had been granted `role`, emits a {RoleRevoked} event.
     *
     * Requirements:
     *
     * - the caller must have ``role``'s admin role.
     */
    function revokeRole(bytes32 role, address account) external;

    /**
     * @dev Revokes `role` from the calling account.
     *
     * Roles are often managed via {grantRole} and {revokeRole}: this function's
     * purpose is to provide a mechanism for accounts to lose their privileges
     * if they are compromised (such as when a trusted device is misplaced).
     *
     * If the calling account had been granted `role`, emits a {RoleRevoked}
     * event.
     *
     * Requirements:
     *
     * - the caller must be `callerConfirmation`.
     */
    function renounceRole(bytes32 role, address callerConfirmation) external;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.1) (utils/Context.sol)

pragma solidity ^0.8.20;

/**
 * @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 Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

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

    function _contextSuffixLength() internal view virtual returns (uint256) {
        return 0;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/ERC165.sol)

pragma solidity ^0.8.20;

import {IERC165} from "./IERC165.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC-165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-20 standard as defined in the ERC.
 */
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);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.20;

import {IERC20} from "../IERC20.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC-20 standard.
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the symbol of the token.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (interfaces/draft-IERC6093.sol)
pragma solidity ^0.8.20;

/**
 * @dev Standard ERC-20 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-20 tokens.
 */
interface IERC20Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientBalance(address sender, uint256 balance, uint256 needed);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC20InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC20InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `spender`’s `allowance`. Used in transfers.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     * @param allowance Amount of tokens a `spender` is allowed to operate with.
     * @param needed Minimum amount required to perform a transfer.
     */
    error ERC20InsufficientAllowance(address spender, uint256 allowance, uint256 needed);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC20InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `spender` to be approved. Used in approvals.
     * @param spender Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC20InvalidSpender(address spender);
}

/**
 * @dev Standard ERC-721 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-721 tokens.
 */
interface IERC721Errors {
    /**
     * @dev Indicates that an address can't be an owner. For example, `address(0)` is a forbidden owner in ERC-20.
     * Used in balance queries.
     * @param owner Address of the current owner of a token.
     */
    error ERC721InvalidOwner(address owner);

    /**
     * @dev Indicates a `tokenId` whose `owner` is the zero address.
     * @param tokenId Identifier number of a token.
     */
    error ERC721NonexistentToken(uint256 tokenId);

    /**
     * @dev Indicates an error related to the ownership over a particular token. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param tokenId Identifier number of a token.
     * @param owner Address of the current owner of a token.
     */
    error ERC721IncorrectOwner(address sender, uint256 tokenId, address owner);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC721InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC721InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param tokenId Identifier number of a token.
     */
    error ERC721InsufficientApproval(address operator, uint256 tokenId);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC721InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC721InvalidOperator(address operator);
}

/**
 * @dev Standard ERC-1155 Errors
 * Interface of the https://eips.ethereum.org/EIPS/eip-6093[ERC-6093] custom errors for ERC-1155 tokens.
 */
interface IERC1155Errors {
    /**
     * @dev Indicates an error related to the current `balance` of a `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     * @param balance Current balance for the interacting account.
     * @param needed Minimum amount required to perform a transfer.
     * @param tokenId Identifier number of a token.
     */
    error ERC1155InsufficientBalance(address sender, uint256 balance, uint256 needed, uint256 tokenId);

    /**
     * @dev Indicates a failure with the token `sender`. Used in transfers.
     * @param sender Address whose tokens are being transferred.
     */
    error ERC1155InvalidSender(address sender);

    /**
     * @dev Indicates a failure with the token `receiver`. Used in transfers.
     * @param receiver Address to which tokens are being transferred.
     */
    error ERC1155InvalidReceiver(address receiver);

    /**
     * @dev Indicates a failure with the `operator`’s approval. Used in transfers.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     * @param owner Address of the current owner of a token.
     */
    error ERC1155MissingApprovalForAll(address operator, address owner);

    /**
     * @dev Indicates a failure with the `approver` of a token to be approved. Used in approvals.
     * @param approver Address initiating an approval operation.
     */
    error ERC1155InvalidApprover(address approver);

    /**
     * @dev Indicates a failure with the `operator` to be approved. Used in approvals.
     * @param operator Address that may be allowed to operate on tokens without being their owner.
     */
    error ERC1155InvalidOperator(address operator);

    /**
     * @dev Indicates an array length mismatch between ids and values in a safeBatchTransferFrom operation.
     * Used in batch transfers.
     * @param idsLength Length of the array of token identifiers
     * @param valuesLength Length of the array of token amounts
     */
    error ERC1155InvalidArrayLength(uint256 idsLength, uint256 valuesLength);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/Panic.sol)

pragma solidity ^0.8.20;

/**
 * @dev Helper library for emitting standardized panic codes.
 *
 * ```solidity
 * contract Example {
 *      using Panic for uint256;
 *
 *      // Use any of the declared internal constants
 *      function foo() { Panic.GENERIC.panic(); }
 *
 *      // Alternatively
 *      function foo() { Panic.panic(Panic.GENERIC); }
 * }
 * ```
 *
 * Follows the list from https://github.com/ethereum/solidity/blob/v0.8.24/libsolutil/ErrorCodes.h[libsolutil].
 *
 * _Available since v5.1._
 */
// slither-disable-next-line unused-state
library Panic {
    /// @dev generic / unspecified error
    uint256 internal constant GENERIC = 0x00;
    /// @dev used by the assert() builtin
    uint256 internal constant ASSERT = 0x01;
    /// @dev arithmetic underflow or overflow
    uint256 internal constant UNDER_OVERFLOW = 0x11;
    /// @dev division or modulo by zero
    uint256 internal constant DIVISION_BY_ZERO = 0x12;
    /// @dev enum conversion error
    uint256 internal constant ENUM_CONVERSION_ERROR = 0x21;
    /// @dev invalid encoding in storage
    uint256 internal constant STORAGE_ENCODING_ERROR = 0x22;
    /// @dev empty array pop
    uint256 internal constant EMPTY_ARRAY_POP = 0x31;
    /// @dev array out of bounds access
    uint256 internal constant ARRAY_OUT_OF_BOUNDS = 0x32;
    /// @dev resource error (too large allocation or too large array)
    uint256 internal constant RESOURCE_ERROR = 0x41;
    /// @dev calling invalid internal function
    uint256 internal constant INVALID_INTERNAL_FUNCTION = 0x51;

    /// @dev Reverts with a panic code. Recommended to use with
    /// the internal constants with predefined codes.
    function panic(uint256 code) internal pure {
        assembly ("memory-safe") {
            mstore(0x00, 0x4e487b71)
            mstore(0x20, code)
            revert(0x1c, 0x24)
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/math/SafeCast.sol)
// This file was procedurally generated from scripts/generate/templates/SafeCast.js.

pragma solidity ^0.8.20;

/**
 * @dev Wrappers over Solidity's uintXX/intXX/bool casting operators with added overflow
 * checks.
 *
 * Downcasting from uint256/int256 in Solidity does not revert on overflow. This can
 * easily result in undesired exploitation or bugs, since developers usually
 * assume that overflows raise errors. `SafeCast` restores this intuition by
 * reverting the transaction when such an operation overflows.
 *
 * Using this library instead of the unchecked operations eliminates an entire
 * class of bugs, so it's recommended to use it always.
 */
library SafeCast {
    /**
     * @dev Value doesn't fit in an uint of `bits` size.
     */
    error SafeCastOverflowedUintDowncast(uint8 bits, uint256 value);

    /**
     * @dev An int value doesn't fit in an uint of `bits` size.
     */
    error SafeCastOverflowedIntToUint(int256 value);

    /**
     * @dev Value doesn't fit in an int of `bits` size.
     */
    error SafeCastOverflowedIntDowncast(uint8 bits, int256 value);

    /**
     * @dev An uint value doesn't fit in an int of `bits` size.
     */
    error SafeCastOverflowedUintToInt(uint256 value);

    /**
     * @dev Returns the downcasted uint248 from uint256, reverting on
     * overflow (when the input is greater than largest uint248).
     *
     * Counterpart to Solidity's `uint248` operator.
     *
     * Requirements:
     *
     * - input must fit into 248 bits
     */
    function toUint248(uint256 value) internal pure returns (uint248) {
        if (value > type(uint248).max) {
            revert SafeCastOverflowedUintDowncast(248, value);
        }
        return uint248(value);
    }

    /**
     * @dev Returns the downcasted uint240 from uint256, reverting on
     * overflow (when the input is greater than largest uint240).
     *
     * Counterpart to Solidity's `uint240` operator.
     *
     * Requirements:
     *
     * - input must fit into 240 bits
     */
    function toUint240(uint256 value) internal pure returns (uint240) {
        if (value > type(uint240).max) {
            revert SafeCastOverflowedUintDowncast(240, value);
        }
        return uint240(value);
    }

    /**
     * @dev Returns the downcasted uint232 from uint256, reverting on
     * overflow (when the input is greater than largest uint232).
     *
     * Counterpart to Solidity's `uint232` operator.
     *
     * Requirements:
     *
     * - input must fit into 232 bits
     */
    function toUint232(uint256 value) internal pure returns (uint232) {
        if (value > type(uint232).max) {
            revert SafeCastOverflowedUintDowncast(232, value);
        }
        return uint232(value);
    }

    /**
     * @dev Returns the downcasted uint224 from uint256, reverting on
     * overflow (when the input is greater than largest uint224).
     *
     * Counterpart to Solidity's `uint224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     */
    function toUint224(uint256 value) internal pure returns (uint224) {
        if (value > type(uint224).max) {
            revert SafeCastOverflowedUintDowncast(224, value);
        }
        return uint224(value);
    }

    /**
     * @dev Returns the downcasted uint216 from uint256, reverting on
     * overflow (when the input is greater than largest uint216).
     *
     * Counterpart to Solidity's `uint216` operator.
     *
     * Requirements:
     *
     * - input must fit into 216 bits
     */
    function toUint216(uint256 value) internal pure returns (uint216) {
        if (value > type(uint216).max) {
            revert SafeCastOverflowedUintDowncast(216, value);
        }
        return uint216(value);
    }

    /**
     * @dev Returns the downcasted uint208 from uint256, reverting on
     * overflow (when the input is greater than largest uint208).
     *
     * Counterpart to Solidity's `uint208` operator.
     *
     * Requirements:
     *
     * - input must fit into 208 bits
     */
    function toUint208(uint256 value) internal pure returns (uint208) {
        if (value > type(uint208).max) {
            revert SafeCastOverflowedUintDowncast(208, value);
        }
        return uint208(value);
    }

    /**
     * @dev Returns the downcasted uint200 from uint256, reverting on
     * overflow (when the input is greater than largest uint200).
     *
     * Counterpart to Solidity's `uint200` operator.
     *
     * Requirements:
     *
     * - input must fit into 200 bits
     */
    function toUint200(uint256 value) internal pure returns (uint200) {
        if (value > type(uint200).max) {
            revert SafeCastOverflowedUintDowncast(200, value);
        }
        return uint200(value);
    }

    /**
     * @dev Returns the downcasted uint192 from uint256, reverting on
     * overflow (when the input is greater than largest uint192).
     *
     * Counterpart to Solidity's `uint192` operator.
     *
     * Requirements:
     *
     * - input must fit into 192 bits
     */
    function toUint192(uint256 value) internal pure returns (uint192) {
        if (value > type(uint192).max) {
            revert SafeCastOverflowedUintDowncast(192, value);
        }
        return uint192(value);
    }

    /**
     * @dev Returns the downcasted uint184 from uint256, reverting on
     * overflow (when the input is greater than largest uint184).
     *
     * Counterpart to Solidity's `uint184` operator.
     *
     * Requirements:
     *
     * - input must fit into 184 bits
     */
    function toUint184(uint256 value) internal pure returns (uint184) {
        if (value > type(uint184).max) {
            revert SafeCastOverflowedUintDowncast(184, value);
        }
        return uint184(value);
    }

    /**
     * @dev Returns the downcasted uint176 from uint256, reverting on
     * overflow (when the input is greater than largest uint176).
     *
     * Counterpart to Solidity's `uint176` operator.
     *
     * Requirements:
     *
     * - input must fit into 176 bits
     */
    function toUint176(uint256 value) internal pure returns (uint176) {
        if (value > type(uint176).max) {
            revert SafeCastOverflowedUintDowncast(176, value);
        }
        return uint176(value);
    }

    /**
     * @dev Returns the downcasted uint168 from uint256, reverting on
     * overflow (when the input is greater than largest uint168).
     *
     * Counterpart to Solidity's `uint168` operator.
     *
     * Requirements:
     *
     * - input must fit into 168 bits
     */
    function toUint168(uint256 value) internal pure returns (uint168) {
        if (value > type(uint168).max) {
            revert SafeCastOverflowedUintDowncast(168, value);
        }
        return uint168(value);
    }

    /**
     * @dev Returns the downcasted uint160 from uint256, reverting on
     * overflow (when the input is greater than largest uint160).
     *
     * Counterpart to Solidity's `uint160` operator.
     *
     * Requirements:
     *
     * - input must fit into 160 bits
     */
    function toUint160(uint256 value) internal pure returns (uint160) {
        if (value > type(uint160).max) {
            revert SafeCastOverflowedUintDowncast(160, value);
        }
        return uint160(value);
    }

    /**
     * @dev Returns the downcasted uint152 from uint256, reverting on
     * overflow (when the input is greater than largest uint152).
     *
     * Counterpart to Solidity's `uint152` operator.
     *
     * Requirements:
     *
     * - input must fit into 152 bits
     */
    function toUint152(uint256 value) internal pure returns (uint152) {
        if (value > type(uint152).max) {
            revert SafeCastOverflowedUintDowncast(152, value);
        }
        return uint152(value);
    }

    /**
     * @dev Returns the downcasted uint144 from uint256, reverting on
     * overflow (when the input is greater than largest uint144).
     *
     * Counterpart to Solidity's `uint144` operator.
     *
     * Requirements:
     *
     * - input must fit into 144 bits
     */
    function toUint144(uint256 value) internal pure returns (uint144) {
        if (value > type(uint144).max) {
            revert SafeCastOverflowedUintDowncast(144, value);
        }
        return uint144(value);
    }

    /**
     * @dev Returns the downcasted uint136 from uint256, reverting on
     * overflow (when the input is greater than largest uint136).
     *
     * Counterpart to Solidity's `uint136` operator.
     *
     * Requirements:
     *
     * - input must fit into 136 bits
     */
    function toUint136(uint256 value) internal pure returns (uint136) {
        if (value > type(uint136).max) {
            revert SafeCastOverflowedUintDowncast(136, value);
        }
        return uint136(value);
    }

    /**
     * @dev Returns the downcasted uint128 from uint256, reverting on
     * overflow (when the input is greater than largest uint128).
     *
     * Counterpart to Solidity's `uint128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     */
    function toUint128(uint256 value) internal pure returns (uint128) {
        if (value > type(uint128).max) {
            revert SafeCastOverflowedUintDowncast(128, value);
        }
        return uint128(value);
    }

    /**
     * @dev Returns the downcasted uint120 from uint256, reverting on
     * overflow (when the input is greater than largest uint120).
     *
     * Counterpart to Solidity's `uint120` operator.
     *
     * Requirements:
     *
     * - input must fit into 120 bits
     */
    function toUint120(uint256 value) internal pure returns (uint120) {
        if (value > type(uint120).max) {
            revert SafeCastOverflowedUintDowncast(120, value);
        }
        return uint120(value);
    }

    /**
     * @dev Returns the downcasted uint112 from uint256, reverting on
     * overflow (when the input is greater than largest uint112).
     *
     * Counterpart to Solidity's `uint112` operator.
     *
     * Requirements:
     *
     * - input must fit into 112 bits
     */
    function toUint112(uint256 value) internal pure returns (uint112) {
        if (value > type(uint112).max) {
            revert SafeCastOverflowedUintDowncast(112, value);
        }
        return uint112(value);
    }

    /**
     * @dev Returns the downcasted uint104 from uint256, reverting on
     * overflow (when the input is greater than largest uint104).
     *
     * Counterpart to Solidity's `uint104` operator.
     *
     * Requirements:
     *
     * - input must fit into 104 bits
     */
    function toUint104(uint256 value) internal pure returns (uint104) {
        if (value > type(uint104).max) {
            revert SafeCastOverflowedUintDowncast(104, value);
        }
        return uint104(value);
    }

    /**
     * @dev Returns the downcasted uint96 from uint256, reverting on
     * overflow (when the input is greater than largest uint96).
     *
     * Counterpart to Solidity's `uint96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     */
    function toUint96(uint256 value) internal pure returns (uint96) {
        if (value > type(uint96).max) {
            revert SafeCastOverflowedUintDowncast(96, value);
        }
        return uint96(value);
    }

    /**
     * @dev Returns the downcasted uint88 from uint256, reverting on
     * overflow (when the input is greater than largest uint88).
     *
     * Counterpart to Solidity's `uint88` operator.
     *
     * Requirements:
     *
     * - input must fit into 88 bits
     */
    function toUint88(uint256 value) internal pure returns (uint88) {
        if (value > type(uint88).max) {
            revert SafeCastOverflowedUintDowncast(88, value);
        }
        return uint88(value);
    }

    /**
     * @dev Returns the downcasted uint80 from uint256, reverting on
     * overflow (when the input is greater than largest uint80).
     *
     * Counterpart to Solidity's `uint80` operator.
     *
     * Requirements:
     *
     * - input must fit into 80 bits
     */
    function toUint80(uint256 value) internal pure returns (uint80) {
        if (value > type(uint80).max) {
            revert SafeCastOverflowedUintDowncast(80, value);
        }
        return uint80(value);
    }

    /**
     * @dev Returns the downcasted uint72 from uint256, reverting on
     * overflow (when the input is greater than largest uint72).
     *
     * Counterpart to Solidity's `uint72` operator.
     *
     * Requirements:
     *
     * - input must fit into 72 bits
     */
    function toUint72(uint256 value) internal pure returns (uint72) {
        if (value > type(uint72).max) {
            revert SafeCastOverflowedUintDowncast(72, value);
        }
        return uint72(value);
    }

    /**
     * @dev Returns the downcasted uint64 from uint256, reverting on
     * overflow (when the input is greater than largest uint64).
     *
     * Counterpart to Solidity's `uint64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     */
    function toUint64(uint256 value) internal pure returns (uint64) {
        if (value > type(uint64).max) {
            revert SafeCastOverflowedUintDowncast(64, value);
        }
        return uint64(value);
    }

    /**
     * @dev Returns the downcasted uint56 from uint256, reverting on
     * overflow (when the input is greater than largest uint56).
     *
     * Counterpart to Solidity's `uint56` operator.
     *
     * Requirements:
     *
     * - input must fit into 56 bits
     */
    function toUint56(uint256 value) internal pure returns (uint56) {
        if (value > type(uint56).max) {
            revert SafeCastOverflowedUintDowncast(56, value);
        }
        return uint56(value);
    }

    /**
     * @dev Returns the downcasted uint48 from uint256, reverting on
     * overflow (when the input is greater than largest uint48).
     *
     * Counterpart to Solidity's `uint48` operator.
     *
     * Requirements:
     *
     * - input must fit into 48 bits
     */
    function toUint48(uint256 value) internal pure returns (uint48) {
        if (value > type(uint48).max) {
            revert SafeCastOverflowedUintDowncast(48, value);
        }
        return uint48(value);
    }

    /**
     * @dev Returns the downcasted uint40 from uint256, reverting on
     * overflow (when the input is greater than largest uint40).
     *
     * Counterpart to Solidity's `uint40` operator.
     *
     * Requirements:
     *
     * - input must fit into 40 bits
     */
    function toUint40(uint256 value) internal pure returns (uint40) {
        if (value > type(uint40).max) {
            revert SafeCastOverflowedUintDowncast(40, value);
        }
        return uint40(value);
    }

    /**
     * @dev Returns the downcasted uint32 from uint256, reverting on
     * overflow (when the input is greater than largest uint32).
     *
     * Counterpart to Solidity's `uint32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     */
    function toUint32(uint256 value) internal pure returns (uint32) {
        if (value > type(uint32).max) {
            revert SafeCastOverflowedUintDowncast(32, value);
        }
        return uint32(value);
    }

    /**
     * @dev Returns the downcasted uint24 from uint256, reverting on
     * overflow (when the input is greater than largest uint24).
     *
     * Counterpart to Solidity's `uint24` operator.
     *
     * Requirements:
     *
     * - input must fit into 24 bits
     */
    function toUint24(uint256 value) internal pure returns (uint24) {
        if (value > type(uint24).max) {
            revert SafeCastOverflowedUintDowncast(24, value);
        }
        return uint24(value);
    }

    /**
     * @dev Returns the downcasted uint16 from uint256, reverting on
     * overflow (when the input is greater than largest uint16).
     *
     * Counterpart to Solidity's `uint16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     */
    function toUint16(uint256 value) internal pure returns (uint16) {
        if (value > type(uint16).max) {
            revert SafeCastOverflowedUintDowncast(16, value);
        }
        return uint16(value);
    }

    /**
     * @dev Returns the downcasted uint8 from uint256, reverting on
     * overflow (when the input is greater than largest uint8).
     *
     * Counterpart to Solidity's `uint8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits
     */
    function toUint8(uint256 value) internal pure returns (uint8) {
        if (value > type(uint8).max) {
            revert SafeCastOverflowedUintDowncast(8, value);
        }
        return uint8(value);
    }

    /**
     * @dev Converts a signed int256 into an unsigned uint256.
     *
     * Requirements:
     *
     * - input must be greater than or equal to 0.
     */
    function toUint256(int256 value) internal pure returns (uint256) {
        if (value < 0) {
            revert SafeCastOverflowedIntToUint(value);
        }
        return uint256(value);
    }

    /**
     * @dev Returns the downcasted int248 from int256, reverting on
     * overflow (when the input is less than smallest int248 or
     * greater than largest int248).
     *
     * Counterpart to Solidity's `int248` operator.
     *
     * Requirements:
     *
     * - input must fit into 248 bits
     */
    function toInt248(int256 value) internal pure returns (int248 downcasted) {
        downcasted = int248(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(248, value);
        }
    }

    /**
     * @dev Returns the downcasted int240 from int256, reverting on
     * overflow (when the input is less than smallest int240 or
     * greater than largest int240).
     *
     * Counterpart to Solidity's `int240` operator.
     *
     * Requirements:
     *
     * - input must fit into 240 bits
     */
    function toInt240(int256 value) internal pure returns (int240 downcasted) {
        downcasted = int240(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(240, value);
        }
    }

    /**
     * @dev Returns the downcasted int232 from int256, reverting on
     * overflow (when the input is less than smallest int232 or
     * greater than largest int232).
     *
     * Counterpart to Solidity's `int232` operator.
     *
     * Requirements:
     *
     * - input must fit into 232 bits
     */
    function toInt232(int256 value) internal pure returns (int232 downcasted) {
        downcasted = int232(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(232, value);
        }
    }

    /**
     * @dev Returns the downcasted int224 from int256, reverting on
     * overflow (when the input is less than smallest int224 or
     * greater than largest int224).
     *
     * Counterpart to Solidity's `int224` operator.
     *
     * Requirements:
     *
     * - input must fit into 224 bits
     */
    function toInt224(int256 value) internal pure returns (int224 downcasted) {
        downcasted = int224(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(224, value);
        }
    }

    /**
     * @dev Returns the downcasted int216 from int256, reverting on
     * overflow (when the input is less than smallest int216 or
     * greater than largest int216).
     *
     * Counterpart to Solidity's `int216` operator.
     *
     * Requirements:
     *
     * - input must fit into 216 bits
     */
    function toInt216(int256 value) internal pure returns (int216 downcasted) {
        downcasted = int216(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(216, value);
        }
    }

    /**
     * @dev Returns the downcasted int208 from int256, reverting on
     * overflow (when the input is less than smallest int208 or
     * greater than largest int208).
     *
     * Counterpart to Solidity's `int208` operator.
     *
     * Requirements:
     *
     * - input must fit into 208 bits
     */
    function toInt208(int256 value) internal pure returns (int208 downcasted) {
        downcasted = int208(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(208, value);
        }
    }

    /**
     * @dev Returns the downcasted int200 from int256, reverting on
     * overflow (when the input is less than smallest int200 or
     * greater than largest int200).
     *
     * Counterpart to Solidity's `int200` operator.
     *
     * Requirements:
     *
     * - input must fit into 200 bits
     */
    function toInt200(int256 value) internal pure returns (int200 downcasted) {
        downcasted = int200(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(200, value);
        }
    }

    /**
     * @dev Returns the downcasted int192 from int256, reverting on
     * overflow (when the input is less than smallest int192 or
     * greater than largest int192).
     *
     * Counterpart to Solidity's `int192` operator.
     *
     * Requirements:
     *
     * - input must fit into 192 bits
     */
    function toInt192(int256 value) internal pure returns (int192 downcasted) {
        downcasted = int192(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(192, value);
        }
    }

    /**
     * @dev Returns the downcasted int184 from int256, reverting on
     * overflow (when the input is less than smallest int184 or
     * greater than largest int184).
     *
     * Counterpart to Solidity's `int184` operator.
     *
     * Requirements:
     *
     * - input must fit into 184 bits
     */
    function toInt184(int256 value) internal pure returns (int184 downcasted) {
        downcasted = int184(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(184, value);
        }
    }

    /**
     * @dev Returns the downcasted int176 from int256, reverting on
     * overflow (when the input is less than smallest int176 or
     * greater than largest int176).
     *
     * Counterpart to Solidity's `int176` operator.
     *
     * Requirements:
     *
     * - input must fit into 176 bits
     */
    function toInt176(int256 value) internal pure returns (int176 downcasted) {
        downcasted = int176(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(176, value);
        }
    }

    /**
     * @dev Returns the downcasted int168 from int256, reverting on
     * overflow (when the input is less than smallest int168 or
     * greater than largest int168).
     *
     * Counterpart to Solidity's `int168` operator.
     *
     * Requirements:
     *
     * - input must fit into 168 bits
     */
    function toInt168(int256 value) internal pure returns (int168 downcasted) {
        downcasted = int168(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(168, value);
        }
    }

    /**
     * @dev Returns the downcasted int160 from int256, reverting on
     * overflow (when the input is less than smallest int160 or
     * greater than largest int160).
     *
     * Counterpart to Solidity's `int160` operator.
     *
     * Requirements:
     *
     * - input must fit into 160 bits
     */
    function toInt160(int256 value) internal pure returns (int160 downcasted) {
        downcasted = int160(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(160, value);
        }
    }

    /**
     * @dev Returns the downcasted int152 from int256, reverting on
     * overflow (when the input is less than smallest int152 or
     * greater than largest int152).
     *
     * Counterpart to Solidity's `int152` operator.
     *
     * Requirements:
     *
     * - input must fit into 152 bits
     */
    function toInt152(int256 value) internal pure returns (int152 downcasted) {
        downcasted = int152(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(152, value);
        }
    }

    /**
     * @dev Returns the downcasted int144 from int256, reverting on
     * overflow (when the input is less than smallest int144 or
     * greater than largest int144).
     *
     * Counterpart to Solidity's `int144` operator.
     *
     * Requirements:
     *
     * - input must fit into 144 bits
     */
    function toInt144(int256 value) internal pure returns (int144 downcasted) {
        downcasted = int144(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(144, value);
        }
    }

    /**
     * @dev Returns the downcasted int136 from int256, reverting on
     * overflow (when the input is less than smallest int136 or
     * greater than largest int136).
     *
     * Counterpart to Solidity's `int136` operator.
     *
     * Requirements:
     *
     * - input must fit into 136 bits
     */
    function toInt136(int256 value) internal pure returns (int136 downcasted) {
        downcasted = int136(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(136, value);
        }
    }

    /**
     * @dev Returns the downcasted int128 from int256, reverting on
     * overflow (when the input is less than smallest int128 or
     * greater than largest int128).
     *
     * Counterpart to Solidity's `int128` operator.
     *
     * Requirements:
     *
     * - input must fit into 128 bits
     */
    function toInt128(int256 value) internal pure returns (int128 downcasted) {
        downcasted = int128(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(128, value);
        }
    }

    /**
     * @dev Returns the downcasted int120 from int256, reverting on
     * overflow (when the input is less than smallest int120 or
     * greater than largest int120).
     *
     * Counterpart to Solidity's `int120` operator.
     *
     * Requirements:
     *
     * - input must fit into 120 bits
     */
    function toInt120(int256 value) internal pure returns (int120 downcasted) {
        downcasted = int120(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(120, value);
        }
    }

    /**
     * @dev Returns the downcasted int112 from int256, reverting on
     * overflow (when the input is less than smallest int112 or
     * greater than largest int112).
     *
     * Counterpart to Solidity's `int112` operator.
     *
     * Requirements:
     *
     * - input must fit into 112 bits
     */
    function toInt112(int256 value) internal pure returns (int112 downcasted) {
        downcasted = int112(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(112, value);
        }
    }

    /**
     * @dev Returns the downcasted int104 from int256, reverting on
     * overflow (when the input is less than smallest int104 or
     * greater than largest int104).
     *
     * Counterpart to Solidity's `int104` operator.
     *
     * Requirements:
     *
     * - input must fit into 104 bits
     */
    function toInt104(int256 value) internal pure returns (int104 downcasted) {
        downcasted = int104(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(104, value);
        }
    }

    /**
     * @dev Returns the downcasted int96 from int256, reverting on
     * overflow (when the input is less than smallest int96 or
     * greater than largest int96).
     *
     * Counterpart to Solidity's `int96` operator.
     *
     * Requirements:
     *
     * - input must fit into 96 bits
     */
    function toInt96(int256 value) internal pure returns (int96 downcasted) {
        downcasted = int96(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(96, value);
        }
    }

    /**
     * @dev Returns the downcasted int88 from int256, reverting on
     * overflow (when the input is less than smallest int88 or
     * greater than largest int88).
     *
     * Counterpart to Solidity's `int88` operator.
     *
     * Requirements:
     *
     * - input must fit into 88 bits
     */
    function toInt88(int256 value) internal pure returns (int88 downcasted) {
        downcasted = int88(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(88, value);
        }
    }

    /**
     * @dev Returns the downcasted int80 from int256, reverting on
     * overflow (when the input is less than smallest int80 or
     * greater than largest int80).
     *
     * Counterpart to Solidity's `int80` operator.
     *
     * Requirements:
     *
     * - input must fit into 80 bits
     */
    function toInt80(int256 value) internal pure returns (int80 downcasted) {
        downcasted = int80(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(80, value);
        }
    }

    /**
     * @dev Returns the downcasted int72 from int256, reverting on
     * overflow (when the input is less than smallest int72 or
     * greater than largest int72).
     *
     * Counterpart to Solidity's `int72` operator.
     *
     * Requirements:
     *
     * - input must fit into 72 bits
     */
    function toInt72(int256 value) internal pure returns (int72 downcasted) {
        downcasted = int72(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(72, value);
        }
    }

    /**
     * @dev Returns the downcasted int64 from int256, reverting on
     * overflow (when the input is less than smallest int64 or
     * greater than largest int64).
     *
     * Counterpart to Solidity's `int64` operator.
     *
     * Requirements:
     *
     * - input must fit into 64 bits
     */
    function toInt64(int256 value) internal pure returns (int64 downcasted) {
        downcasted = int64(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(64, value);
        }
    }

    /**
     * @dev Returns the downcasted int56 from int256, reverting on
     * overflow (when the input is less than smallest int56 or
     * greater than largest int56).
     *
     * Counterpart to Solidity's `int56` operator.
     *
     * Requirements:
     *
     * - input must fit into 56 bits
     */
    function toInt56(int256 value) internal pure returns (int56 downcasted) {
        downcasted = int56(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(56, value);
        }
    }

    /**
     * @dev Returns the downcasted int48 from int256, reverting on
     * overflow (when the input is less than smallest int48 or
     * greater than largest int48).
     *
     * Counterpart to Solidity's `int48` operator.
     *
     * Requirements:
     *
     * - input must fit into 48 bits
     */
    function toInt48(int256 value) internal pure returns (int48 downcasted) {
        downcasted = int48(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(48, value);
        }
    }

    /**
     * @dev Returns the downcasted int40 from int256, reverting on
     * overflow (when the input is less than smallest int40 or
     * greater than largest int40).
     *
     * Counterpart to Solidity's `int40` operator.
     *
     * Requirements:
     *
     * - input must fit into 40 bits
     */
    function toInt40(int256 value) internal pure returns (int40 downcasted) {
        downcasted = int40(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(40, value);
        }
    }

    /**
     * @dev Returns the downcasted int32 from int256, reverting on
     * overflow (when the input is less than smallest int32 or
     * greater than largest int32).
     *
     * Counterpart to Solidity's `int32` operator.
     *
     * Requirements:
     *
     * - input must fit into 32 bits
     */
    function toInt32(int256 value) internal pure returns (int32 downcasted) {
        downcasted = int32(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(32, value);
        }
    }

    /**
     * @dev Returns the downcasted int24 from int256, reverting on
     * overflow (when the input is less than smallest int24 or
     * greater than largest int24).
     *
     * Counterpart to Solidity's `int24` operator.
     *
     * Requirements:
     *
     * - input must fit into 24 bits
     */
    function toInt24(int256 value) internal pure returns (int24 downcasted) {
        downcasted = int24(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(24, value);
        }
    }

    /**
     * @dev Returns the downcasted int16 from int256, reverting on
     * overflow (when the input is less than smallest int16 or
     * greater than largest int16).
     *
     * Counterpart to Solidity's `int16` operator.
     *
     * Requirements:
     *
     * - input must fit into 16 bits
     */
    function toInt16(int256 value) internal pure returns (int16 downcasted) {
        downcasted = int16(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(16, value);
        }
    }

    /**
     * @dev Returns the downcasted int8 from int256, reverting on
     * overflow (when the input is less than smallest int8 or
     * greater than largest int8).
     *
     * Counterpart to Solidity's `int8` operator.
     *
     * Requirements:
     *
     * - input must fit into 8 bits
     */
    function toInt8(int256 value) internal pure returns (int8 downcasted) {
        downcasted = int8(value);
        if (downcasted != value) {
            revert SafeCastOverflowedIntDowncast(8, value);
        }
    }

    /**
     * @dev Converts an unsigned uint256 into a signed int256.
     *
     * Requirements:
     *
     * - input must be less than or equal to maxInt256.
     */
    function toInt256(uint256 value) internal pure returns (int256) {
        // Note: Unsafe cast below is okay because `type(int256).max` is guaranteed to be positive
        if (value > uint256(type(int256).max)) {
            revert SafeCastOverflowedUintToInt(value);
        }
        return int256(value);
    }

    /**
     * @dev Cast a boolean (false or true) to a uint256 (0 or 1) with no jump.
     */
    function toUint(bool b) internal pure returns (uint256 u) {
        assembly ("memory-safe") {
            u := iszero(iszero(b))
        }
    }
}

// SPDX-License-Identifier: BUSL-1.1
pragma solidity 0.8.26;

abstract contract Oracle {
    address public immutable token;

    string public name;

    constructor(address _token, string memory _name) {
        token = _token;
        name = _name;
    }

    function getPrice() external view virtual returns (uint256 price) {}
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.1.0) (utils/introspection/IERC165.sol)

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC-165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[ERC].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[ERC section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}

{
  "remappings": [
    "@uniswap/v3-periphery/contracts/=lib/v3-periphery/contracts/",
    "@openzeppelin/contracts/=lib/openzeppelin-contracts/contracts/",
    "ds-test/=lib/openzeppelin-contracts/lib/forge-std/lib/ds-test/src/",
    "erc4626-tests/=lib/openzeppelin-contracts/lib/erc4626-tests/",
    "forge-std/=lib/forge-std/src/",
    "halmos-cheatcodes/=lib/openzeppelin-contracts/lib/halmos-cheatcodes/src/",
    "openzeppelin-contracts/=lib/openzeppelin-contracts/",
    "v3-periphery/=lib/v3-periphery/contracts/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "evmVersion": "shanghai",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"_lpToken","type":"address"},{"internalType":"address","name":"_withdrawToken","type":"address"},{"internalType":"address","name":"_oracleConfigurator","type":"address"},{"internalType":"uint256","name":"_cap","type":"uint256"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AccessControlBadConfirmation","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bytes32","name":"neededRole","type":"bytes32"}],"name":"AccessControlUnauthorizedAccount","type":"error"},{"inputs":[],"name":"DepositCapped","type":"error"},{"inputs":[],"name":"DepositPaused","type":"error"},{"inputs":[],"name":"InsufficientBalance","type":"error"},{"inputs":[],"name":"InvalidAsset","type":"error"},{"inputs":[],"name":"InvalidFeeRate","type":"error"},{"inputs":[],"name":"InvalidOracle","type":"error"},{"inputs":[],"name":"NoClaimableRedeem","type":"error"},{"inputs":[],"name":"NoFeeRecipient","type":"error"},{"inputs":[],"name":"NoRequestingShares","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"inputs":[],"name":"ZeroShares","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"asset","type":"address"}],"name":"AddUnderlyingAsset","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"asset","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"AssetsRepaid","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"asset","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"AssetsWithdrawn","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"caller","type":"address"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"asset","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"recipient","type":"address"},{"indexed":false,"internalType":"uint256","name":"fee","type":"uint256"}],"name":"FeeCharged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"round","type":"uint256"}],"name":"RedeemCancelled","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"RedeemClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"round","type":"uint256"}],"name":"RedeemRequested","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"asset","type":"address"}],"name":"RemoveUnderlyingAsset","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"round","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"share","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"withdrawTokenAmount","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"sharePrice","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"withdrawTokenPrice","type":"uint256"}],"name":"RollToNextRound","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"oldValue","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"newValue","type":"uint256"}],"name":"SetCap","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"asset","type":"address"},{"indexed":false,"internalType":"bool","name":"flag","type":"bool"}],"name":"SetDepositPause","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"asset","type":"address"},{"indexed":false,"internalType":"uint256","name":"feeRate","type":"uint256"}],"name":"SetFeeRate","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"oldValue","type":"address"},{"indexed":false,"internalType":"address","name":"newValue","type":"address"}],"name":"SetFeeRecipient","type":"event"},{"inputs":[],"name":"ASSETS_MANAGEMENT_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"D18","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"D6","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VAULT_OPERATOR_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"activeAssets","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"activeShares","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_asset","type":"address"}],"name":"addUnderlyingAsset","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"assetsBorrowed","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cancelRequest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"claimRedeemRequest","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"claimableRedeemRequest","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_shares","type":"uint256"}],"name":"convertToAssets","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_assets","type":"uint256"}],"name":"convertToShares","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_asset","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"},{"internalType":"address","name":"_receiver","type":"address"}],"name":"deposit","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"depositPaused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"feeRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"feeRecipient","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getRate","outputs":[{"internalType":"uint256","name":"rate","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getUnderlyings","outputs":[{"internalType":"address[]","name":"underlyings","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"isUnderlyingAssets","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"latestRoundID","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lpToken","outputs":[{"internalType":"contract Token","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_asset","type":"address"},{"internalType":"uint256","name":"_shares","type":"uint256"},{"internalType":"address","name":"_receiver","type":"address"}],"name":"mint","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"oracleConfigurator","outputs":[{"internalType":"contract OracleConfigurator","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingRedeemRequest","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_asset","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"previewDeposit","outputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_asset","type":"address"},{"internalType":"uint256","name":"_shares","type":"uint256"}],"name":"previewMint","outputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"redeemRequests","outputs":[{"internalType":"uint256","name":"requestRound","type":"uint256"},{"internalType":"uint256","name":"requestShares","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"redeemableAmountInPast","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_asset","type":"address"}],"name":"removeUnderlyingAsset","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"callerConfirmation","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_asset","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"repayAssets","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_shares","type":"uint256"}],"name":"requestRedeem","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"requestingSharesInPast","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"requestingSharesInRound","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rollToNextRound","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"roundPricePerShare","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_cap","type":"uint256"}],"name":"setCap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"bool","name":"_pause","type":"bool"}],"name":"setDepositPause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_token","type":"address"},{"internalType":"uint256","name":"_feeRate","type":"uint256"}],"name":"setFeeRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_feeRecipient","type":"address"}],"name":"setFeeRecipient","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAssets","outputs":[{"internalType":"uint256","name":"totalManagedAssets","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"underlyingAssets","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_asset","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"withdrawAssets","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdrawToken","outputs":[{"internalType":"contract ERC20","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"withdrawTokenPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

00000000000000000000000097ad75064b20fb2b2447fed4fa953bf7f007a7060000000000000000000000007122985656e38bdc0302db86685bb972b145bd3c0000000000000000000000008636dd05027ec8ba84fa8c982951bbb61dcfef6c00000000000000000000000000000000000000000000d3c21bcecceda1000000

-----Decoded View---------------
Arg [0] : _lpToken (address): 0x97Ad75064b20fb2B2447feD4fa953bF7F007a706
Arg [1] : _withdrawToken (address): 0x7122985656e38BDC0302Db86685bb972b145bD3C
Arg [2] : _oracleConfigurator (address): 0x8636dD05027eC8bA84fA8c982951BbB61DcfEF6c
Arg [3] : _cap (uint256): 1000000000000000000000000

-----Encoded View---------------
4 Constructor Arguments found :
Arg [0] : 00000000000000000000000097ad75064b20fb2b2447fed4fa953bf7f007a706
Arg [1] : 0000000000000000000000007122985656e38bdc0302db86685bb972b145bd3c
Arg [2] : 0000000000000000000000008636dd05027ec8ba84fa8c982951bbb61dcfef6c
Arg [3] : 00000000000000000000000000000000000000000000d3c21bcecceda1000000

499:16082:14:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;8902:677;;;:::i;:::-;;;160:25:18;;;148:2;133:18;8902:677:14;;;;;;;;2565:202:0;;;;;;:::i;:::-;;:::i;:::-;;;652:14:18;;645:22;627:41;;615:2;600:18;2565:202:0;487:187:18;10447:379:14;;;;;;:::i;:::-;;:::i;4582:987::-;;;;;;:::i;:::-;;:::i;1201:53::-;;;;;;:::i;:::-;;;;;;;;;;;;;;8413:483;;;:::i;15098:602::-;;;;;;:::i;:::-;;:::i;:::-;;9585:334;;;:::i;3810:120:0:-;;;;;;:::i;:::-;3875:7;3901:12;;;;;;;;;;:22;;;;3810:120;15706:208:14;;;;;;:::i;:::-;;:::i;1455:37::-;;;;;;4226:136:0;;;;;;:::i;:::-;;:::i;13871:655:14:-;;;;;;:::i;:::-;;:::i;1395:18::-;;;;;;5328:245:0;;;;;;:::i;:::-;;:::i;985:33:14:-;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;3642:32:18;;;3624:51;;3612:2;3597:18;985:33:14;3478:203:18;1595:38:14;;;;;;1663:27;;;;;-1:-1:-1;;;;;1663:27:14;;;14532:128;;;;;;:::i;:::-;;:::i;1260:45::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;12101:991;;;:::i;845:30::-;;;;;11801:141;;;:::i;1419:29::-;;;;;;7097:1016;;;:::i;924:54::-;;;;;6537:554;;;:::i;8119:288::-;;;:::i;1142:53::-;;;;;;:::i;:::-;;;;;;;;;;;;;;1081:55;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;4317:25:18;;;4373:2;4358:18;;4351:34;;;;4290:18;1081:55:14;4143:248:18;1529:37:14;;;;;;2854:136:0;;;;;;:::i;:::-;;:::i;15920:384:14:-;;;;;;:::i;:::-;;:::i;806:32::-;;835:3;806:32;;2187:49:0;;2232:4;2187:49;;5575:956:14;;;;;;:::i;:::-;;:::i;10832:362::-;;;;;;:::i;:::-;;:::i;575:86::-;;-1:-1:-1;;;;;;;;;;;575:86:14;;9925:131;;;:::i;1025:50::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;10062:379;;;;;;:::i;:::-;;:::i;14666:426::-;;;;;;:::i;:::-;;:::i;881:36::-;;;;;1312:42;;;;;;:::i;:::-;;;;;;;;;;;;;;11200:595;;;;;;:::i;:::-;;:::i;4642:138:0:-;;;;;;:::i;:::-;;:::i;766:34:14:-;;796:4;766:34;;16310:269;;;;;;:::i;:::-;;:::i;13098:767::-;;;;;;:::i;:::-;;:::i;3592:984::-;;;;;;:::i;:::-;;:::i;11948:147::-;;;:::i;:::-;;;;;;;:::i;667:92::-;;724:35;667:92;;1361:28;;;;;;8902:677;9001:16;:23;8946:26;;;9078:4;9094:433;9106:6;9102:1;:10;9094:433;;;9133:17;9153:16;9170:1;9153:19;;;;;;;;:::i;:::-;;;;;;;;;;9248:22;;-1:-1:-1;;;9248:22:14;;-1:-1:-1;;;;;3642:32:18;;;9248:22:14;;;3624:51:18;9153:19:14;;;;-1:-1:-1;9153:19:14;;;;;9248:15;;3597:18:18;;9248:22:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9230:40;-1:-1:-1;9289:12:14;;9285:232;;9337:38;;-1:-1:-1;;;9337:38:14;;-1:-1:-1;;;;;3642:32:18;;;9337:38:14;;;3624:51:18;9321:13:14;;9337:18;:27;;;;;;3597:18:18;;9337:38:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9321:54;-1:-1:-1;9393:13:14;9409:47;9321:54;9422:7;796:4;9393:13;9409:12;:47::i;:::-;9393:63;-1:-1:-1;9475:27:14;9393:63;9475:27;;:::i;:::-;;;9303:214;;9285:232;-1:-1:-1;;9114:3:14;;;;;-1:-1:-1;9094:433:14;;;9558:14;;9536:36;;;;:::i;:::-;;;8974:605;;;8902:677;:::o;2565:202:0:-;2650:4;-1:-1:-1;;;;;;2673:47:0;;-1:-1:-1;;;2673:47:0;;:87;;-1:-1:-1;;;;;;;;;;862:40:8;;;2724:36:0;2666:94;2565:202;-1:-1:-1;;2565:202:0:o;10447:379:14:-;10524:14;10550;10567:7;-1:-1:-1;;;;;10567:19:14;;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;10550:38;-1:-1:-1;10618:11:14;;:201;;10674:145;10710:14;:12;:14::i;:::-;10746;:12;:14::i;:::-;10674:7;;:145;10782:19;10674:14;:145::i;:::-;10618:201;;;10648:7;10618:201;10599:220;10447:379;-1:-1:-1;;;10447:379:14:o;4582:987::-;-1:-1:-1;;;;;4726:21:14;;4696:14;4726:21;;;:13;:21;;;;;;;;4722:49;;;4756:15;;-1:-1:-1;;;4756:15:14;;;;;;;;;;;4722:49;4785:7;4796:1;4785:12;4781:37;;4806:12;;-1:-1:-1;;;4806:12:14;;;;;;;;;;;4781:37;4866:3;;4856:7;4832;-1:-1:-1;;;;;4832:19:14;;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:31;;;;:::i;:::-;:37;4828:65;;;4878:15;;-1:-1:-1;;;4878:15:14;;;;;;;;;;;4828:65;4913:28;4925:6;4933:7;4913:11;:28::i;:::-;4904:37;;4952:132;4997:6;5017:10;5049:4;5068:6;4952:31;:132::i;:::-;-1:-1:-1;;;;;5131:15:14;;5095:11;5131:15;;;:7;:15;;;;;;5160:9;;5156:70;;5191:24;:7;5206:4;835:3;5191:14;:24::i;:::-;5185:30;;5156:70;5240:3;5247:1;5240:8;5236:256;;5264:32;;-1:-1:-1;;;5264:32:14;;-1:-1:-1;;;;;5264:7:14;:12;;;;:32;;5277:9;;5288:7;;5264:32;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5236:256;;;5327:14;5338:3;5327:14;;:::i;:::-;5355:32;;-1:-1:-1;;;5355:32:14;;5327:14;;-1:-1:-1;;;;;;5355:7:14;:12;;;;:32;;5368:9;;5327:14;;5355:32;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;5414:12:14;;5401:31;;-1:-1:-1;;;5401:31:14;;-1:-1:-1;;;;;5401:7:14;:12;;;-1:-1:-1;5401:12:14;;-1:-1:-1;5401:31:14;;5414:12;;5428:3;;5401:31;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;5463:12:14;;5452:29;;;;-1:-1:-1;5452:29:14;;-1:-1:-1;;;;;;5463:12:14;;;;5477:3;;5452:29;:::i;:::-;;;;;;;;5236:256;5507:55;;;4317:25:18;;;4373:2;4358:18;;4351:34;;;-1:-1:-1;;;;;5507:55:14;;;;;;;;5515:10;;5507:55;;4290:18:18;5507:55:14;;;;;;;;4712:857;;4582:987;;;;;:::o;8413:483::-;8548:10;8470:14;8533:26;;;:14;:26;;;;;;;;8496:63;;;;;;;;;;;;;;;;;;;;;;;;;8634:13;;8496:63;;;8626:21;;:57;;;;-1:-1:-1;8651:27:14;;;;:32;;8626:57;8622:268;;;8760:25;;;;:18;:25;;;;;;;;;8803:18;:25;;;;;;8708:27;;;;:171;;:27;;8803:25;8708:34;:171::i;:::-;8699:180;;8622:268;8486:410;;8413:483;:::o;15098:602::-;-1:-1:-1;;;;;;;;;;;2464:16:0;2475:4;2464:10;:16::i;:::-;-1:-1:-1;;;;;15213:26:14;::::1;;::::0;;;:18:::1;:26;::::0;;;;;::::1;;15208:54;;15248:14;;-1:-1:-1::0;;;15248:14:14::1;;;;;;;;;;;15208:54;15273:23;15299:16;15273:42;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;;-1:-1:-1;;;;;15273:42:14::1;::::0;;;;;::::1;::::0;::::1;;::::0;;::::1;;;;-1:-1:-1::0;;15343:13:14;;15273:42;;-1:-1:-1;15326:14:14::1;::::0;-1:-1:-1;;;15385:220:14::1;15397:6;15393:1;:10;15385:220;;;15441:6;-1:-1:-1::0;;;;;15428:19:14::1;:6;15435:1;15428:9;;;;;;;;:::i;:::-;;;;;;;-1:-1:-1::0;;;;;15428:19:14::1;::::0;15424:171:::1;;15489:16;15506:10;15489:16:::0;15506:6;:10:::1;:::i;:::-;15489:28;;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;::::1;::::0;;15467:19;;-1:-1:-1;;;;;15489:28:14;;::::1;::::0;15484:1;;15467:19;::::1;;;;;:::i;:::-;;;;;;;;;:50;;;;;-1:-1:-1::0;;;;;15467:50:14::1;;;;;-1:-1:-1::0;;;;;15467:50:14::1;;;;;;15535:16;:22;;;;;;;:::i;:::-;;::::0;;;::::1;::::0;;;;-1:-1:-1;;15535:22:14;;;;;-1:-1:-1;;;;;;15535:22:14::1;::::0;;;;;15575:5:::1;;15424:171;15405:3;;15385:220;;;-1:-1:-1::0;;;;;15614:26:14;::::1;15643:5;15614:26:::0;;;:18:::1;:26;::::0;;;;;:34;;-1:-1:-1;;15614:34:14::1;::::0;;15664:29;::::1;::::0;15643:5;15664:29:::1;15198:502;;;15098:602:::0;;:::o;9585:334::-;9672:51;;-1:-1:-1;;;9672:51:14;;-1:-1:-1;;;;;9708:13:14;3642:32:18;;9672:51:14;;;3624::18;-1:-1:-1;;;;9672:18:14;:27;;;;3597:18:18;;9672:51:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;9757:22;;9656:67;;-1:-1:-1;9733:21:14;;9757:108;;9656:67;796:4;9733:21;9757:29;:108::i;:::-;9733:132;;9899:13;9883;:11;:13::i;:::-;:29;;;;:::i;15706:208::-;-1:-1:-1;;;;;;;;;;;2464:16:0;2475:4;2464:10;:16::i;:::-;-1:-1:-1;;;;;15831:21:14;::::1;;::::0;;;:13:::1;:21;::::0;;;;;;;;:30;;-1:-1:-1;;15831:30:14::1;::::0;::::1;;::::0;;::::1;::::0;;;15876:31;;627:41:18;;;15876:31:14::1;::::0;600:18:18;15876:31:14::1;;;;;;;;15706:208:::0;;;:::o;4226:136:0:-;3875:7;3901:12;;;;;;;;;;:22;;;2464:16;2475:4;2464:10;:16::i;:::-;4330:25:::1;4341:4;4347:7;4330:10;:25::i;:::-;;4226:136:::0;;;:::o;13871:655:14:-;724:35;2464:16:0;2475:4;2464:10;:16::i;:::-;-1:-1:-1;;;;;14004:26:14;::::1;;::::0;;;:18:::1;:26;::::0;;;;;::::1;;13999:54;;14039:14;;-1:-1:-1::0;;;14039:14:14::1;;;;;;;;;;;13999:54;14064:133;14109:6;14129:10;14161:4;14180:7;14064:31;:133::i;:::-;14224:35;::::0;-1:-1:-1;;;14224:35:14;;-1:-1:-1;;;;;3642:32:18;;;14224:35:14::1;::::0;::::1;3624:51:18::0;14208:13:14::1;::::0;14224:18:::1;:27:::0;;::::1;::::0;::::1;::::0;3597:18:18;;14224:35:14::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;14208:51:::0;-1:-1:-1;14269:13:14::1;14285:47;:7:::0;14208:51;796:4:::1;14269:13:::0;14285:14:::1;:47::i;:::-;14269:63;;14355:14;;14347:5;:22;14343:125;;;14402:1;14385:14;:18:::0;14343:125:::1;;;14452:5;14434:14;;:23;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;14343:125:14::1;14483:36;::::0;;4317:25:18;;;4373:2;4358:18;;4351:34;;;-1:-1:-1;;;;;14483:36:14;::::1;::::0;::::1;::::0;4290:18:18;14483:36:14::1;;;;;;;13989:537;;13871:655:::0;;;:::o;5328:245:0:-;-1:-1:-1;;;;;5421:34:0;;735:10:6;5421:34:0;5417:102;;5478:30;;-1:-1:-1;;;5478:30:0;;;;;;;;;;;5417:102;5529:37;5541:4;5547:18;5529:11;:37::i;:::-;;5328:245;;:::o;985:33:14:-;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;985:33:14;;-1:-1:-1;985:33:14;:::o;14532:128::-;-1:-1:-1;;;;;;;;;;;2464:16:0;2475:4;2464:10;:16::i;:::-;14623:3:14::1;::::0;14616:17:::1;::::0;;4317:25:18;;;4373:2;4358:18;;4351:34;;;14616:17:14::1;::::0;4290:18:18;14616:17:14::1;;;;;;;-1:-1:-1::0;14643:3:14::1;:10:::0;14532:128::o;12101:991::-;-1:-1:-1;;;;;;;;;;;2464:16:0;2475:4;2464:10;:16::i;:::-;12193:51:14::1;::::0;-1:-1:-1;;;12193:51:14;;-1:-1:-1;;;;;12229:13:14::1;3642:32:18::0;;12193:51:14::1;::::0;::::1;3624::18::0;-1:-1:-1;;12193:18:14::1;:27:::0;;::::1;::::0;::::1;::::0;3597:18:18;;12193:51:14::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;12177:67;;12254:12;12269:9;:7;:9::i;:::-;12316:23;::::0;12254:24;;-1:-1:-1;12289:24:14::1;12379:102;12316:23:::0;12254:24;12434:5;12453:18:::1;12379:23;:102::i;:::-;12349:132;;12587:19;12562:22;;:44;;;;:::i;:::-;12509:38;::::0;-1:-1:-1;;;12509:38:14;;12541:4:::1;12509:38;::::0;::::1;3624:51:18::0;12509:13:14::1;-1:-1:-1::0;;;;;12509:23:14::1;::::0;::::1;::::0;3597:18:18;;12509:38:14::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:97;12492:153;;;12624:21;;-1:-1:-1::0;;;12624:21:14::1;;;;;;;;;;;12492:153;12682:19;12656:22;;:45;;;;;;;:::i;:::-;;;;;;;;12737:16;12711:22;;:42;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;12789:1:14::1;12763:23;:27:::0;;;12820:13:::1;::::0;;12801:33;;:18:::1;:33;::::0;;;;;;;:40;;;12870:13;;12851:33;;:18:::1;:33:::0;;;;;;:41;;;12937:13;;12908:152;;6646:25:18;;;6687:18;;;6680:34;;;6730:18;;;6723:34;;;6788:2;6773:18;;6766:34;;;6831:3;6816:19;;6809:35;;;12908:152:14::1;::::0;6633:3:18;6618:19;12908:152:14::1;;;;;;;13070:13;:15:::0;;;:13:::1;:15;::::0;::::1;:::i;:::-;;;;;;12167:925;;;;12101:991:::0;:::o;11801:141::-;11841:12;11872:63;796:4;11899:14;:12;:14::i;:::-;11915:19;11872:14;:12;:14::i;:::-;:21;:63;;:21;:63::i;:::-;11865:70;;11801:141;:::o;7097:1016::-;7197:10;7144:35;7182:26;;;:14;:26;;;;;7242:27;;;;7323:26;;7371:13;;7182:26;;7242:27;;7363:21;;:57;;;;-1:-1:-1;7388:27:14;;;;:32;;7363:57;7359:328;;;7500:25;;;;:18;:25;;;;;;;;;7543:18;:25;;;;;;7448:27;;;;:171;;:27;;7500:25;7543;7448:34;:171::i;:::-;7436:183;;7359:328;;;7657:19;;-1:-1:-1;;;7657:19:14;;;;;;;;;;;7359:328;7697:42;;-1:-1:-1;;;7697:42:14;;-1:-1:-1;;;;;7697:7:14;:12;;;;:42;;7718:4;;7725:13;;7697:42;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7780:1;7750:13;:27;;:31;;;;7818:9;7792:22;;:35;;;;;;;:::i;:::-;;;;;;;;7863:13;7837:22;;:39;;;;;;;:::i;:::-;;;;-1:-1:-1;;7891:13:14;;7887:167;;7918:136;7971:13;8003:10;8031:9;7918:27;:136::i;:::-;8070:36;;160:25:18;;;8084:10:14;;8070:36;;148:2:18;133:18;8070:36:14;;;;;;;7134:979;;;;7097:1016::o;6537:554::-;6585:22;:20;:22::i;:::-;6611:1;6585:27;6581:60;;6621:20;;-1:-1:-1;;;6621:20:14;;;;;;;;;;;6581:60;6705:10;6652:35;6690:26;;;:14;:26;;;;;6754:27;;;;;6791:31;;;;6833:23;:43;;6690:26;;6754:27;;;;6652:35;6833:43;;6754:27;;6833:43;:::i;:::-;;;;-1:-1:-1;6887:121:14;;-1:-1:-1;6936:7:14;6958:10;6982:16;6887:27;:121::i;:::-;7070:13;;7024:60;;7040:10;;7024:60;;;;7052:16;4317:25:18;;4373:2;4358:18;;4351:34;4305:2;4290:18;;4143:248;7024:60:14;;;;;;;;6571:520;;6537:554::o;8119:288::-;8250:10;8172:14;8235:26;;;:14;:26;;;;;;;;8198:63;;;;;;;;;;;;;;;;;;;;;;;;;8321:13;;8198:63;;8291:43;:109;;8399:1;8291:109;;;8353:13;:27;;;8291:109;8272:128;;;8119:288;:::o;2854:136:0:-;2931:4;2954:12;;;;;;;;;;;-1:-1:-1;;;;;2954:29:0;;;;;;;;;;;;;;;2854:136::o;15920:384:14:-;-1:-1:-1;;;;;;;;;;;2464:16:0;2475:4;2464:10;:16::i;:::-;16049:12:14::1;::::0;-1:-1:-1;;;;;16049:12:14::1;16045:55;;16084:16;;-1:-1:-1::0;;;16084:16:14::1;;;;;;;;;;;16045:55;-1:-1:-1::0;;;;;16115:26:14;::::1;;::::0;;;:18:::1;:26;::::0;;;;;::::1;;16110:54;;16150:14;;-1:-1:-1::0;;;16150:14:14::1;;;;;;;;;;;16110:54;835:3;16178:8;:13;16174:42;;;16200:16;;-1:-1:-1::0;;;16200:16:14::1;;;;;;;;;;;16174:42;-1:-1:-1::0;;;;;16227:15:14;::::1;;::::0;;;:7:::1;:15;::::0;;;;;;:26;;;16269:28;::::1;::::0;::::1;::::0;16245:8;160:25:18;;148:2;133:18;;14:177;5575:956:14;5638:7;5649:1;5638:12;5634:37;;5659:12;;-1:-1:-1;;;5659:12:14;;;;;;;;;;;5634:37;5695:29;;-1:-1:-1;;;5695:29:14;;5713:10;5695:29;;;3624:51:18;5695:7:14;-1:-1:-1;;;;;5695:17:14;;;;3597:18:18;;5695:29:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;5685:7;:39;5681:85;;;5745:21;;-1:-1:-1;;;5745:21:14;;;;;;;;;;;5681:85;5777:143;5830:7;5852:10;5884:4;5903:7;5777:31;:143::i;:::-;5984:10;5931:35;5969:26;;;:14;:26;;;;;6023:27;;;;:31;;;;:89;;-1:-1:-1;6099:13:14;;6070:26;;:42;6023:89;6006:162;;;6137:20;:18;:20::i;:::-;6212:13;;6182:26;;:43;6178:236;;6272:7;6241:13;:27;;;:38;;;;;;;:::i;:::-;;;;-1:-1:-1;6178:236:14;;-1:-1:-1;6178:236:14;;6339:13;;6310:42;;6366:27;;;:37;;;6178:236;6450:7;6423:23;;:34;;;;;;;:::i;:::-;;;;-1:-1:-1;;6510:13:14;;6473:51;;6489:10;;6473:51;;;;6501:7;4317:25:18;;4373:2;4358:18;;4351:34;4305:2;4290:18;;4143:248;10832:362:14;-1:-1:-1;;;;;10963:26:14;;10932:14;10963:26;;;:18;:26;;;;;;;;10958:54;;10998:14;;-1:-1:-1;;;10998:14:14;;;;;;;;;;;10958:54;11039:35;;-1:-1:-1;;;11039:35:14;;-1:-1:-1;;;;;3642:32:18;;;11039:35:14;;;3624:51:18;11023:13:14;;11039:18;:27;;;;;;3597:18:18;;11039:35:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;11023:51;-1:-1:-1;11084:13:14;11100:47;:7;11023:51;796:4;11084:13;11100:14;:47::i;:::-;11084:63;;11165:22;11181:5;11165:15;:22::i;:::-;11158:29;10832:362;-1:-1:-1;;;;;10832:362:14:o;9925:131::-;9970:14;10027:22;;10003:7;-1:-1:-1;;;;;10003:19:14;;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:46;;;;:::i;10062:379::-;10139:14;10165;10182:7;-1:-1:-1;;;;;10182:19:14;;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;10165:38;-1:-1:-1;10233:11:14;;:201;;10289:145;10325:14;:12;:14::i;:::-;10361;:12;:14::i;14666:426::-;-1:-1:-1;;;;;;;;;;;2464:16:0;2475:4;2464:10;:16::i;:::-;-1:-1:-1;;;;;14777:20:14;::::1;::::0;;:50:::1;;-1:-1:-1::0;;;;;;14801:26:14;::::1;;::::0;;;:18:::1;:26;::::0;;;;;::::1;;14777:50;14773:89;;;14848:14;;-1:-1:-1::0;;;14848:14:14::1;;;;;;;;;;;14773:89;14876:34;::::0;-1:-1:-1;;;14876:34:14;;-1:-1:-1;;;;;3642:32:18;;;14876:34:14::1;::::0;::::1;3624:51:18::0;-1:-1:-1;;14876:18:14::1;:26:::0;;::::1;::::0;::::1;::::0;3597:18:18;;14876:34:14::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;14876:48:14::1;::::0;14872:88:::1;;14945:15;;-1:-1:-1::0;;;14945:15:14::1;;;;;;;;;;;14872:88;-1:-1:-1::0;;;;;14971:26:14;::::1;;::::0;;;:18:::1;:26;::::0;;;;;:33;;-1:-1:-1;;14971:33:14::1;15000:4;14971:33:::0;;::::1;::::0;;;15014:29;;;;::::1;::::0;;;;;;::::1;::::0;;-1:-1:-1;;;;;;15014:29:14::1;::::0;::::1;::::0;;15059:26;::::1;::::0;14971;15059::::1;14666:426:::0;;:::o;11200:595::-;-1:-1:-1;;;;;11328:26:14;;11297:14;11328:26;;;:18;:26;;;;;;;;11323:54;;11363:14;;-1:-1:-1;;;11363:14:14;;;;;;;;;;;11323:54;11404:35;;-1:-1:-1;;;11404:35:14;;-1:-1:-1;;;;;3642:32:18;;;11404:35:14;;;3624:51:18;11388:13:14;;11404:18;:27;;;;;;3597:18:18;;11404:35:14;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;11388:51;-1:-1:-1;11449:14:14;11466:46;:7;796:4;11388:51;11493:18;11466:14;:46::i;:::-;11449:63;;11522:14;11539:7;-1:-1:-1;;;;;11539:19:14;;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;11522:38;-1:-1:-1;11590:11:14;;:198;;11645:143;11680:14;:12;:14::i;:::-;11716;:12;:14::i;:::-;11645:6;;:143;11752:18;11645:13;:143::i;:::-;11590:198;;;11620:6;11590:198;11571:217;11200:595;-1:-1:-1;;;;;;11200:595:14:o;4642:138:0:-;3875:7;3901:12;;;;;;;;;;:22;;;2464:16;2475:4;2464:10;:16::i;:::-;4747:26:::1;4759:4;4765:7;4747:11;:26::i;16310:269:14:-:0;-1:-1:-1;;;;;;;;;;;2464:16:0;2475:4;2464:10;:16::i;:::-;-1:-1:-1;;;;;16425:27:14;::::1;16421:53;;16461:13;;-1:-1:-1::0;;;16461:13:14::1;;;;;;;;;;;16421:53;16506:12;::::0;16490:44:::1;::::0;;-1:-1:-1;;;;;16506:12:14;;::::1;7425:51:18::0;;7512:32;;;7507:2;7492:18;;7485:60;16490:44:14::1;::::0;7398:18:18;16490:44:14::1;;;;;;;-1:-1:-1::0;16544:12:14::1;:28:::0;;-1:-1:-1;;;;;;16544:28:14::1;-1:-1:-1::0;;;;;16544:28:14;;;::::1;::::0;;;::::1;::::0;;16310:269::o;13098:767::-;724:35;2464:16:0;2475:4;2464:10;:16::i;:::-;-1:-1:-1;;;;;13234:26:14;::::1;;::::0;;;:18:::1;:26;::::0;;;;;::::1;;13229:54;;13269:14;;-1:-1:-1::0;;;13269:14:14::1;;;;;;;;;;;13229:54;13312:38;::::0;-1:-1:-1;;;13312:38:14;;13344:4:::1;13312:38;::::0;::::1;3624:51:18::0;13294:15:14::1;::::0;-1:-1:-1;;;;;13312:23:14;::::1;::::0;::::1;::::0;3597:18:18;;13312:38:14::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;13294:56;;13374:7;13364;:17;13360:51;;;13390:21;;-1:-1:-1::0;;;13390:21:14::1;;;;;;;;;;;13360:51;13457:13;-1:-1:-1::0;;;;;13439:32:14::1;:6;-1:-1:-1::0;;;;;13439:32:14::1;;:90;;;;;13522:7;13497:22;;:32;;;;:::i;:::-;13487:7;:42;13439:90;13422:146;;;13547:21;;-1:-1:-1::0;;;13547:21:14::1;;;;;;;;;;;13422:146;13595:35;::::0;-1:-1:-1;;;13595:35:14;;-1:-1:-1;;;;;3642:32:18;;;13595:35:14::1;::::0;::::1;3624:51:18::0;13579:13:14::1;::::0;13595:18:::1;:27:::0;;::::1;::::0;::::1;::::0;3597:18:18;;13595:35:14::1;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;13579:51:::0;-1:-1:-1;13640:13:14::1;13656:46;:7:::0;13579:51;796:4:::1;13683:18;13656:14;:46::i;:::-;13640:62;;13731:5;13713:14;;:23;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;13747:56:14::1;::::0;-1:-1:-1;13775:6:14;13783:10:::1;13795:7:::0;13747:27:::1;:56::i;:::-;13819:39;::::0;;4317:25:18;;;4373:2;4358:18;;4351:34;;;-1:-1:-1;;;;;13819:39:14;::::1;::::0;::::1;::::0;4290:18:18;13819:39:14::1;;;;;;;13219:646;;;13098:767:::0;;;:::o;3592:984::-;-1:-1:-1;;;;;3737:21:14;;3707:14;3737:21;;;:13;:21;;;;;;;;3733:49;;;3767:15;;-1:-1:-1;;;3767:15:14;;;;;;;;;;;3733:49;3806:31;3821:6;3829:7;3806:14;:31::i;:::-;3797:40;;;3842:1;3796:47;3792:84;;3864:12;;-1:-1:-1;;;3864:12:14;;;;;;;;;;;3792:84;3924:3;;3915:6;3891:7;-1:-1:-1;;;;;3891:19:14;;:21;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:30;;;;:::i;:::-;:36;3887:64;;;3936:15;;-1:-1:-1;;;3936:15:14;;;;;;;;;;;3887:64;3962:133;4007:6;4027:10;4059:4;4078:7;3962:31;:133::i;:::-;-1:-1:-1;;;;;4142:15:14;;4106:11;4142:15;;;:7;:15;;;;;;4171:9;;4167:69;;4202:23;:6;4216:4;835:3;4202:13;:23::i;:::-;4196:29;;4167:69;4250:3;4257:1;4250:8;4246:253;;4274:31;;-1:-1:-1;;;4274:31:14;;-1:-1:-1;;;;;4274:7:14;:12;;;;:31;;4287:9;;4298:6;;4274:31;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4246:253;;;4336:13;4346:3;4336:13;;:::i;:::-;4363:31;;-1:-1:-1;;;4363:31:14;;4336:13;;-1:-1:-1;;;;;;4363:7:14;:12;;;;:31;;4376:9;;4336:13;;4363:31;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4421:12:14;;4408:31;;-1:-1:-1;;;4408:31:14;;-1:-1:-1;;;;;4408:7:14;:12;;;-1:-1:-1;4408:12:14;;-1:-1:-1;4408:31:14;;4421:12;;4435:3;;4408:31;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;4470:12:14;;4459:29;;;;-1:-1:-1;4459:29:14;;-1:-1:-1;;;;;;4470:12:14;;;;4484:3;;4459:29;:::i;:::-;;;;;;;;4246:253;4514:55;;;4317:25:18;;;4373:2;4358:18;;4351:34;;;-1:-1:-1;;;;;4514:55:14;;;;;;;;4522:10;;4514:55;;4290:18:18;4514:55:14;4143:248:18;11948:147:14;12021:28;12072:16;12065:23;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;12065:23:14;;;;;;;;;;;;;;;;;;;;;;;11948:147;:::o;9351:238:10:-;9452:7;9506:76;9522:26;9539:8;9522:16;:26::i;:::-;:59;;;;;9580:1;9565:11;9552:25;;;;;:::i;:::-;9562:1;9559;9552:25;:29;9522:59;34914:9:11;34907:17;;34795:145;9506:76:10;9478:25;9485:1;9488;9491:11;9478:6;:25::i;:::-;:104;;;;:::i;561:358:12:-;759:69;;;-1:-1:-1;;;;;7908:32:18;;;759:69:12;;;7890:51:18;7977:32;;;7957:18;;;7950:60;8026:18;;;;8019:34;;;759:69:12;;;;;;;;;;7863:18:18;;;;759:69:12;;;;;;;-1:-1:-1;;;;;759:69:12;-1:-1:-1;;;759:69:12;;;748:81;;-1:-1:-1;;;;748:10:12;;;;:81;;759:69;748:81;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;700:129;;;;847:7;:57;;;;-1:-1:-1;859:11:12;;:16;;:44;;;890:4;879:24;;;;;;;;;;;;:::i;:::-;839:73;;;;-1:-1:-1;;;839:73:12;;8933:2:18;839:73:12;;;8915:21:18;8972:1;8952:18;;;8945:29;-1:-1:-1;;;8990:18:18;;;8983:33;9033:18;;839:73:12;;;;;;;;;690:229;;561:358;;;;:::o;4996:4226:10:-;5078:14;5449:5;;;5078:14;-1:-1:-1;;5453:1:10;5449;5621:20;5694:5;5690:2;5687:13;5679:5;5675:2;5671:14;5667:34;5658:43;;;5796:5;5805:1;5796:10;5792:368;;6134:11;6126:5;:19;;;;;:::i;:::-;;6119:26;;;;;;5792:368;6285:5;6270:11;:20;6266:143;;6310:84;3066:5;6330:16;;3065:36;940:4:7;3060:42:10;6310:11;:84::i;:::-;6664:17;6799:11;6796:1;6793;6786:25;7199:12;7229:15;;;7214:31;;7348:22;;;;;8094:1;8075;:15;;8074:21;;8327;;;8323:25;;8312:36;8397:21;;;8393:25;;8382:36;8469:21;;;8465:25;;8454:36;8540:21;;;8536:25;;8525:36;8613:21;;;8609:25;;8598:36;8687:21;;;8683:25;;;8672:36;7597:12;;;;7593:23;;;7618:1;7589:31;6913:20;;;6902:32;;;7709:12;;;;6960:21;;;;7446:16;;;;7700:21;;;;9163:15;;;;;-1:-1:-1;;4996:4226:10;;;;;:::o;3199:103:0:-;3265:30;3276:4;735:10:6;3265::0;:30::i;:::-;3199:103;:::o;6179:316::-;6256:4;6277:22;6285:4;6291:7;6277;:22::i;:::-;6272:217;;6315:6;:12;;;;;;;;;;;-1:-1:-1;;;;;6315:29:0;;;;;;;;;:36;;-1:-1:-1;;6315:36:0;6347:4;6315:36;;;6397:12;735:10:6;;656:96;6397:12:0;-1:-1:-1;;;;;6370:40:0;6388:7;-1:-1:-1;;;;;6370:40:0;6382:4;6370:40;;;;;;;;;;-1:-1:-1;6431:4:0;6424:11;;6272:217;-1:-1:-1;6473:5:0;6466:12;;6730:317;6808:4;6828:22;6836:4;6842:7;6828;:22::i;:::-;6824:217;;;6898:5;6866:12;;;;;;;;;;;-1:-1:-1;;;;;6866:29:0;;;;;;;;;;:37;;-1:-1:-1;;6866:37:0;;;6922:40;735:10:6;;6866:12:0;;6922:40;;6898:5;6922:40;-1:-1:-1;6983:4:0;6976:11;;1211:309:12;1325:12;1339:17;1360:5;-1:-1:-1;;;;;1360:10:12;1394:24;;;1420:2;1424:5;1371:59;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;1371:59:12;;;;;;;;;;;;;;-1:-1:-1;;;;;1371:59:12;-1:-1:-1;;;;;;1371:59:12;;;;;;;;;;1360:71;;;;1371:59;1360:71;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1324:107;;;;1449:7;:57;;;;-1:-1:-1;1461:11:12;;:16;;:44;;;1492:4;1481:24;;;;;;;;;;;;:::i;:::-;1441:72;;;;-1:-1:-1;;;1441:72:12;;9264:2:18;1441:72:12;;;9246:21:18;9303:1;9283:18;;;9276:29;-1:-1:-1;;;9321:18:18;;;9314:32;9363:18;;1441:72:12;9062:325:18;1441:72:12;1314:206;;1211:309;;;:::o;28183:122:10:-;28251:4;28292:1;28280:8;28274:15;;;;;;;;:::i;:::-;:19;;;;:::i;:::-;:24;;28297:1;28274:24;28267:31;;28183:122;;;:::o;1776:194:7:-;1881:10;1875:4;1868:24;1918:4;1912;1905:18;1949:4;1943;1936:18;3432:197:0;3520:22;3528:4;3534:7;3520;:22::i;:::-;3515:108;;3598:7;3607:4;3565:47;;-1:-1:-1;;;3565:47:0;;;;;;;;;:::i;3515:108::-;3432:197;;:::o;196:286:18:-;254:6;307:2;295:9;286:7;282:23;278:32;275:52;;;323:1;320;313:12;275:52;349:23;;-1:-1:-1;;;;;;401:32:18;;391:43;;381:71;;448:1;445;438:12;679:226;738:6;791:2;779:9;770:7;766:23;762:32;759:52;;;807:1;804;797:12;759:52;-1:-1:-1;852:23:18;;679:226;-1:-1:-1;679:226:18:o;910:131::-;-1:-1:-1;;;;;985:31:18;;975:42;;965:70;;1031:1;1028;1021:12;1046:508;1123:6;1131;1139;1192:2;1180:9;1171:7;1167:23;1163:32;1160:52;;;1208:1;1205;1198:12;1160:52;1247:9;1234:23;1266:31;1291:5;1266:31;:::i;:::-;1316:5;-1:-1:-1;1394:2:18;1379:18;;1366:32;;-1:-1:-1;1476:2:18;1461:18;;1448:32;1489:33;1448:32;1489:33;:::i;:::-;1541:7;1531:17;;;1046:508;;;;;:::o;1559:247::-;1618:6;1671:2;1659:9;1650:7;1646:23;1642:32;1639:52;;;1687:1;1684;1677:12;1639:52;1726:9;1713:23;1745:31;1770:5;1745:31;:::i;2224:118::-;2310:5;2303:13;2296:21;2289:5;2286:32;2276:60;;2332:1;2329;2322:12;2347:382;2412:6;2420;2473:2;2461:9;2452:7;2448:23;2444:32;2441:52;;;2489:1;2486;2479:12;2441:52;2528:9;2515:23;2547:31;2572:5;2547:31;:::i;:::-;2597:5;-1:-1:-1;2654:2:18;2639:18;;2626:32;2667:30;2626:32;2667:30;:::i;:::-;2716:7;2706:17;;;2347:382;;;;;:::o;2734:367::-;2802:6;2810;2863:2;2851:9;2842:7;2838:23;2834:32;2831:52;;;2879:1;2876;2869:12;2831:52;2924:23;;;-1:-1:-1;3023:2:18;3008:18;;2995:32;3036:33;2995:32;3036:33;:::i;3106:367::-;3174:6;3182;3235:2;3223:9;3214:7;3210:23;3206:32;3203:52;;;3251:1;3248;3241:12;3203:52;3290:9;3277:23;3309:31;3334:5;3309:31;:::i;:::-;3359:5;3437:2;3422:18;;;;3409:32;;-1:-1:-1;;;3106:367:18:o;4618:637::-;4808:2;4820:21;;;4890:13;;4793:18;;;4912:22;;;4760:4;;4991:15;;;4965:2;4950:18;;;4760:4;5034:195;5048:6;5045:1;5042:13;5034:195;;;5113:13;;-1:-1:-1;;;;;5109:39:18;5097:52;;5178:2;5204:15;;;;5169:12;;;;5145:1;5063:9;5034:195;;;-1:-1:-1;5246:3:18;;4618:637;-1:-1:-1;;;;;4618:637:18:o;5260:127::-;5321:10;5316:3;5312:20;5309:1;5302:31;5352:4;5349:1;5342:15;5376:4;5373:1;5366:15;5392:184;5462:6;5515:2;5503:9;5494:7;5490:23;5486:32;5483:52;;;5531:1;5528;5521:12;5483:52;-1:-1:-1;5554:16:18;;5392:184;-1:-1:-1;5392:184:18:o;5581:127::-;5642:10;5637:3;5633:20;5630:1;5623:31;5673:4;5670:1;5663:15;5697:4;5694:1;5687:15;5713:125;5778:9;;;5799:10;;;5796:36;;;5812:18;;:::i;5843:274::-;-1:-1:-1;;;;;6035:32:18;;;;6017:51;;6099:2;6084:18;;6077:34;6005:2;5990:18;;5843:274::o;6122:128::-;6189:9;;;6210:11;;;6207:37;;;6224:18;;:::i;6255:127::-;6316:10;6311:3;6307:20;6304:1;6297:31;6347:4;6344:1;6337:15;6371:4;6368:1;6361:15;6855:135;6894:3;6915:17;;;6912:43;;6935:18;;:::i;:::-;-1:-1:-1;6982:1:18;6971:13;;6855:135::o;6995:251::-;7065:6;7118:2;7106:9;7097:7;7093:23;7089:32;7086:52;;;7134:1;7131;7124:12;7086:52;7166:9;7160:16;7185:31;7210:5;7185:31;:::i;7556:127::-;7617:10;7612:3;7608:20;7605:1;7598:31;7648:4;7645:1;7638:15;7672:4;7669:1;7662:15;8064:412;8193:3;8231:6;8225:13;8256:1;8266:129;8280:6;8277:1;8274:13;8266:129;;;8378:4;8362:14;;;8358:25;;8352:32;8339:11;;;8332:53;8295:12;8266:129;;;-1:-1:-1;8450:1:18;8414:16;;8439:13;;;-1:-1:-1;8414:16:18;8064:412;-1:-1:-1;8064:412:18:o;8481:245::-;8548:6;8601:2;8589:9;8580:7;8576:23;8572:32;8569:52;;;8617:1;8614;8607:12;8569:52;8649:9;8643:16;8668:28;8690:5;8668:28;:::i;9392:127::-;9453:10;9448:3;9444:20;9441:1;9434:31;9484:4;9481:1;9474:15;9508:4;9505:1;9498:15;9524:254;9554:1;9588:4;9585:1;9581:12;9612:3;9602:134;;9658:10;9653:3;9649:20;9646:1;9639:31;9693:4;9690:1;9683:15;9721:4;9718:1;9711:15;9602:134;9768:3;9761:4;9758:1;9754:12;9750:22;9745:27;;;9524:254;;;;:::o

ipfs://2a93cbdaab869f662a1e1b2c2d9b2c422a2a0b5524363a0eb07417bcc5bbc106