Contract Source Code (Solidity Multiple files format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Similar
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity 0.8.27;

import "./ERC4626.sol";
import "./ERC20.sol";
import "./IERC20.sol";

/// @dev send konk tokens to this contract to redistribute them to stakers
/// @dev treasury MUST stake a significant amount first to avoid future share/tokenAmount slippage (1 konk)
/// @dev send tokens to this contract to instantly share them

contract KONKStaking is ERC4626 {
    constructor(IERC20 konkToken) 
        ERC4626(konkToken) 
        ERC20("Staked KONK", "stKONK") 
    {}

    function totalAssets() public view override returns (uint256) {
        return IERC20(asset()).balanceOf(address(this));
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.27;

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

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

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

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

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

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        if (address(this).balance < value) {
            revert AddressInsufficientBalance(address(this));
        }
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata);
    }

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

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

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

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

    /**
     * @dev Reverts with returndata if present. Otherwise reverts with {FailedInnerCall}.
     */
    function _revert(bytes memory returndata) private pure {
        // Look for revert reason and bubble it up if present
        if (returndata.length > 0) {
            // The easiest way to bubble the revert reason is using memory via assembly
            /// @solidity memory-safe-assembly
            assembly {
                let returndata_size := mload(returndata)
                revert(add(32, returndata), returndata_size)
            }
        } else {
            revert FailedInnerCall();
        }
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.27;

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
pragma solidity 0.8.27;

import "./IERC20.sol";
import "./IERC20Metadata.sol";
import "./Context.sol";
import "./IERC20Errors.sol";

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}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * 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:
     * ```
     * 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
pragma solidity 0.8.27;

import "./ERC20.sol";
import "./IERC4626.sol";
import "./SafeERC20.sol";
import "./Math.sol";

abstract contract ERC4626 is ERC20, IERC4626 {
    using Math for uint256;

    IERC20 private immutable _asset;
    uint8 private immutable _underlyingDecimals;

    /**
     * @dev Attempted to deposit more assets than the max amount for `receiver`.
     */
    error ERC4626ExceededMaxDeposit(address receiver, uint256 assets, uint256 max);

    /**
     * @dev Attempted to mint more shares than the max amount for `receiver`.
     */
    error ERC4626ExceededMaxMint(address receiver, uint256 shares, uint256 max);

    /**
     * @dev Attempted to withdraw more assets than the max amount for `receiver`.
     */
    error ERC4626ExceededMaxWithdraw(address owner, uint256 assets, uint256 max);

    /**
     * @dev Attempted to redeem more shares than the max amount for `receiver`.
     */
    error ERC4626ExceededMaxRedeem(address owner, uint256 shares, uint256 max);

    /**
     * @dev Set the underlying asset contract. This must be an ERC20-compatible contract (ERC20 or ERC777).
     */
    constructor(IERC20 asset_) {
        (bool success, uint8 assetDecimals) = _tryGetAssetDecimals(asset_);
        _underlyingDecimals = success ? assetDecimals : 18;
        _asset = asset_;
    }

    /**
     * @dev Attempts to fetch the asset decimals. A return value of false indicates that the attempt failed in some way.
     */
    function _tryGetAssetDecimals(IERC20 asset_) private view returns (bool, uint8) {
        (bool success, bytes memory encodedDecimals) = address(asset_).staticcall(
            abi.encodeCall(IERC20Metadata.decimals, ())
        );
        if (success && encodedDecimals.length >= 32) {
            uint256 returnedDecimals = abi.decode(encodedDecimals, (uint256));
            if (returnedDecimals <= type(uint8).max) {
                return (true, uint8(returnedDecimals));
            }
        }
        return (false, 0);
    }

    /**
     * @dev Decimals are computed by adding the decimal offset on top of the underlying asset's decimals. This
     * "original" value is cached during construction of the vault contract. If this read operation fails (e.g., the
     * asset has not been created yet), a default of 18 is used to represent the underlying asset's decimals.
     *
     * See {IERC20Metadata-decimals}.
     */
    function decimals() public view virtual override(IERC20Metadata, ERC20) returns (uint8) {
        return _underlyingDecimals + _decimalsOffset();
    }

    /** @dev See {IERC4626-asset}. */
    function asset() public view virtual returns (address) {
        return address(_asset);
    }

    /** @dev See {IERC4626-totalAssets}. */
    function totalAssets() public view virtual returns (uint256) {
        return _asset.balanceOf(address(this));
    }

    /** @dev See {IERC4626-convertToShares}. */
    function convertToShares(uint256 assets) public view virtual returns (uint256) {
        return _convertToShares(assets, Math.Rounding.Floor);
    }

    /** @dev See {IERC4626-convertToAssets}. */
    function convertToAssets(uint256 shares) public view virtual returns (uint256) {
        return _convertToAssets(shares, Math.Rounding.Floor);
    }

    /** @dev See {IERC4626-maxDeposit}. */
    function maxDeposit(address) public view virtual returns (uint256) {
        return type(uint256).max;
    }

    /** @dev See {IERC4626-maxMint}. */
    function maxMint(address) public view virtual returns (uint256) {
        return type(uint256).max;
    }

    /** @dev See {IERC4626-maxWithdraw}. */
    function maxWithdraw(address owner) public view virtual returns (uint256) {
        return _convertToAssets(balanceOf(owner), Math.Rounding.Floor);
    }

    /** @dev See {IERC4626-maxRedeem}. */
    function maxRedeem(address owner) public view virtual returns (uint256) {
        return balanceOf(owner);
    }

    /** @dev See {IERC4626-previewDeposit}. */
    function previewDeposit(uint256 assets) public view virtual returns (uint256) {
        return _convertToShares(assets, Math.Rounding.Floor);
    }

    /** @dev See {IERC4626-previewMint}. */
    function previewMint(uint256 shares) public view virtual returns (uint256) {
        return _convertToAssets(shares, Math.Rounding.Ceil);
    }

    /** @dev See {IERC4626-previewWithdraw}. */
    function previewWithdraw(uint256 assets) public view virtual returns (uint256) {
        return _convertToShares(assets, Math.Rounding.Ceil);
    }

    /** @dev See {IERC4626-previewRedeem}. */
    function previewRedeem(uint256 shares) public view virtual returns (uint256) {
        return _convertToAssets(shares, Math.Rounding.Floor);
    }

    /** @dev See {IERC4626-deposit}. */
    function deposit(uint256 assets, address receiver) public virtual returns (uint256) {
        uint256 maxAssets = maxDeposit(receiver);
        if (assets > maxAssets) {
            revert ERC4626ExceededMaxDeposit(receiver, assets, maxAssets);
        }

        uint256 shares = previewDeposit(assets);
        _deposit(_msgSender(), receiver, assets, shares);

        return shares;
    }

    /** @dev See {IERC4626-mint}.
     *
     * As opposed to {deposit}, minting is allowed even if the vault is in a state where the price of a share is zero.
     * In this case, the shares will be minted without requiring any assets to be deposited.
     */
    function mint(uint256 shares, address receiver) public virtual returns (uint256) {
        uint256 maxShares = maxMint(receiver);
        if (shares > maxShares) {
            revert ERC4626ExceededMaxMint(receiver, shares, maxShares);
        }

        uint256 assets = previewMint(shares);
        _deposit(_msgSender(), receiver, assets, shares);

        return assets;
    }

    /** @dev See {IERC4626-withdraw}. */
    function withdraw(uint256 assets, address receiver, address owner) public virtual returns (uint256) {
        uint256 maxAssets = maxWithdraw(owner);
        if (assets > maxAssets) {
            revert ERC4626ExceededMaxWithdraw(owner, assets, maxAssets);
        }

        uint256 shares = previewWithdraw(assets);
        _withdraw(_msgSender(), receiver, owner, assets, shares);

        return shares;
    }

    /** @dev See {IERC4626-redeem}. */
    function redeem(uint256 shares, address receiver, address owner) public virtual returns (uint256) {
        uint256 maxShares = maxRedeem(owner);
        if (shares > maxShares) {
            revert ERC4626ExceededMaxRedeem(owner, shares, maxShares);
        }

        uint256 assets = previewRedeem(shares);
        _withdraw(_msgSender(), receiver, owner, assets, shares);

        return assets;
    }

    /**
     * @dev Internal conversion function (from assets to shares) with support for rounding direction.
     */
    function _convertToShares(uint256 assets, Math.Rounding rounding) internal view virtual returns (uint256) {
        return assets.mulDiv(totalSupply() + 10 ** _decimalsOffset(), totalAssets() + 1, rounding);
    }

    /**
     * @dev Internal conversion function (from shares to assets) with support for rounding direction.
     */
    function _convertToAssets(uint256 shares, Math.Rounding rounding) internal view virtual returns (uint256) {
        return shares.mulDiv(totalAssets() + 1, totalSupply() + 10 ** _decimalsOffset(), rounding);
    }

    /**
     * @dev Deposit/mint common workflow.
     */
    function _deposit(address caller, address receiver, uint256 assets, uint256 shares) internal virtual {
        // If _asset is ERC777, `transferFrom` can trigger a reentrancy BEFORE the transfer happens through the
        // `tokensToSend` hook. On the other hand, the `tokenReceived` hook, that is triggered after the transfer,
        // calls the vault, which is assumed not malicious.
        //
        // Conclusion: we need to do the transfer before we mint so that any reentrancy would happen before the
        // assets are transferred and before the shares are minted, which is a valid state.
        // slither-disable-next-line reentrancy-no-eth
        SafeERC20.safeTransferFrom(_asset, caller, address(this), assets);
        _mint(receiver, shares);

        emit Deposit(caller, receiver, assets, shares);
    }

    /**
     * @dev Withdraw/redeem common workflow.
     */
    function _withdraw(
        address caller,
        address receiver,
        address owner,
        uint256 assets,
        uint256 shares
    ) internal virtual {
        if (caller != owner) {
            _spendAllowance(owner, caller, shares);
        }

        // If _asset is ERC777, `transfer` can trigger a reentrancy AFTER the transfer happens through the
        // `tokensReceived` hook. On the other hand, the `tokensToSend` hook, that is triggered before the transfer,
        // calls the vault, which is assumed not malicious.
        //
        // Conclusion: we need to do the transfer after the burn so that any reentrancy would happen after the
        // shares are burned and after the assets are transferred, which is a valid state.
        _burn(owner, shares);
        SafeERC20.safeTransfer(_asset, receiver, assets);

        emit Withdraw(caller, receiver, owner, assets, shares);
    }

    function _decimalsOffset() internal view virtual returns (uint8) {
        return 0;
    }
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.27;

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
pragma solidity 0.8.27;

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

// SPDX-License-Identifier: MIT
pragma solidity 0.8.27;

import "./IERC20.sol";

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
pragma solidity 0.8.27;

import "./IERC20.sol";
import "./IERC20Metadata.sol";

interface IERC4626 is IERC20, IERC20Metadata {
    event Deposit(address indexed sender, address indexed owner, uint256 assets, uint256 shares);

    event Withdraw(
        address indexed sender,
        address indexed receiver,
        address indexed owner,
        uint256 assets,
        uint256 shares
    );

    /**
     * @dev Returns the address of the underlying token used for the Vault for accounting, depositing, and withdrawing.
     *
     * - MUST be an ERC-20 token contract.
     * - MUST NOT revert.
     */
    function asset() external view returns (address assetTokenAddress);

    /**
     * @dev Returns the total amount of the underlying asset that is “managed” by Vault.
     *
     * - SHOULD include any compounding that occurs from yield.
     * - MUST be inclusive of any fees that are charged against assets in the Vault.
     * - MUST NOT revert.
     */
    function totalAssets() external view returns (uint256 totalManagedAssets);

    /**
     * @dev Returns the amount of shares that the Vault would exchange for the amount of assets provided, in an ideal
     * scenario where all the conditions are met.
     *
     * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.
     * - MUST NOT show any variations depending on the caller.
     * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
     * - MUST NOT revert.
     *
     * NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the
     * “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and
     * from.
     */
    function convertToShares(uint256 assets) external view returns (uint256 shares);

    /**
     * @dev Returns the amount of assets that the Vault would exchange for the amount of shares provided, in an ideal
     * scenario where all the conditions are met.
     *
     * - MUST NOT be inclusive of any fees that are charged against assets in the Vault.
     * - MUST NOT show any variations depending on the caller.
     * - MUST NOT reflect slippage or other on-chain conditions, when performing the actual exchange.
     * - MUST NOT revert.
     *
     * NOTE: This calculation MAY NOT reflect the “per-user” price-per-share, and instead should reflect the
     * “average-user’s” price-per-share, meaning what the average user should expect to see when exchanging to and
     * from.
     */
    function convertToAssets(uint256 shares) external view returns (uint256 assets);

    /**
     * @dev Returns the maximum amount of the underlying asset that can be deposited into the Vault for the receiver,
     * through a deposit call.
     *
     * - MUST return a limited value if receiver is subject to some deposit limit.
     * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of assets that may be deposited.
     * - MUST NOT revert.
     */
    function maxDeposit(address receiver) external view returns (uint256 maxAssets);

    /**
     * @dev Allows an on-chain or off-chain user to simulate the effects of their deposit at the current block, given
     * current on-chain conditions.
     *
     * - MUST return as close to and no more than the exact amount of Vault shares that would be minted in a deposit
     *   call in the same transaction. I.e. deposit should return the same or more shares as previewDeposit if called
     *   in the same transaction.
     * - MUST NOT account for deposit limits like those returned from maxDeposit and should always act as though the
     *   deposit would be accepted, regardless if the user has enough tokens approved, etc.
     * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
     * - MUST NOT revert.
     *
     * NOTE: any unfavorable discrepancy between convertToShares and previewDeposit SHOULD be considered slippage in
     * share price or some other type of condition, meaning the depositor will lose assets by depositing.
     */
    function previewDeposit(uint256 assets) external view returns (uint256 shares);

    /**
     * @dev Mints shares Vault shares to receiver by depositing exactly amount of underlying tokens.
     *
     * - MUST emit the Deposit event.
     * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
     *   deposit execution, and are accounted for during deposit.
     * - MUST revert if all of assets cannot be deposited (due to deposit limit being reached, slippage, the user not
     *   approving enough underlying tokens to the Vault contract, etc).
     *
     * NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
     */
    function deposit(uint256 assets, address receiver) external returns (uint256 shares);

    /**
     * @dev Returns the maximum amount of the Vault shares that can be minted for the receiver, through a mint call.
     * - MUST return a limited value if receiver is subject to some mint limit.
     * - MUST return 2 ** 256 - 1 if there is no limit on the maximum amount of shares that may be minted.
     * - MUST NOT revert.
     */
    function maxMint(address receiver) external view returns (uint256 maxShares);

    /**
     * @dev Allows an on-chain or off-chain user to simulate the effects of their mint at the current block, given
     * current on-chain conditions.
     *
     * - MUST return as close to and no fewer than the exact amount of assets that would be deposited in a mint call
     *   in the same transaction. I.e. mint should return the same or fewer assets as previewMint if called in the
     *   same transaction.
     * - MUST NOT account for mint limits like those returned from maxMint and should always act as though the mint
     *   would be accepted, regardless if the user has enough tokens approved, etc.
     * - MUST be inclusive of deposit fees. Integrators should be aware of the existence of deposit fees.
     * - MUST NOT revert.
     *
     * NOTE: any unfavorable discrepancy between convertToAssets and previewMint SHOULD be considered slippage in
     * share price or some other type of condition, meaning the depositor will lose assets by minting.
     */
    function previewMint(uint256 shares) external view returns (uint256 assets);

    /**
     * @dev Mints exactly shares Vault shares to receiver by depositing amount of underlying tokens.
     *
     * - MUST emit the Deposit event.
     * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the mint
     *   execution, and are accounted for during mint.
     * - MUST revert if all of shares cannot be minted (due to deposit limit being reached, slippage, the user not
     *   approving enough underlying tokens to the Vault contract, etc).
     *
     * NOTE: most implementations will require pre-approval of the Vault with the Vault’s underlying asset token.
     */
    function mint(uint256 shares, address receiver) external returns (uint256 assets);

    /**
     * @dev Returns the maximum amount of the underlying asset that can be withdrawn from the owner balance in the
     * Vault, through a withdraw call.
     *
     * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.
     * - MUST NOT revert.
     */
    function maxWithdraw(address owner) external view returns (uint256 maxAssets);

    /**
     * @dev Allows an on-chain or off-chain user to simulate the effects of their withdrawal at the current block,
     * given current on-chain conditions.
     *
     * - MUST return as close to and no fewer than the exact amount of Vault shares that would be burned in a withdraw
     *   call in the same transaction. I.e. withdraw should return the same or fewer shares as previewWithdraw if
     *   called
     *   in the same transaction.
     * - MUST NOT account for withdrawal limits like those returned from maxWithdraw and should always act as though
     *   the withdrawal would be accepted, regardless if the user has enough shares, etc.
     * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
     * - MUST NOT revert.
     *
     * NOTE: any unfavorable discrepancy between convertToShares and previewWithdraw SHOULD be considered slippage in
     * share price or some other type of condition, meaning the depositor will lose assets by depositing.
     */
    function previewWithdraw(uint256 assets) external view returns (uint256 shares);

    /**
     * @dev Burns shares from owner and sends exactly assets of underlying tokens to receiver.
     *
     * - MUST emit the Withdraw event.
     * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
     *   withdraw execution, and are accounted for during withdraw.
     * - MUST revert if all of assets cannot be withdrawn (due to withdrawal limit being reached, slippage, the owner
     *   not having enough shares, etc).
     *
     * Note that some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
     * Those methods should be performed separately.
     */
    function withdraw(uint256 assets, address receiver, address owner) external returns (uint256 shares);

    /**
     * @dev Returns the maximum amount of Vault shares that can be redeemed from the owner balance in the Vault,
     * through a redeem call.
     *
     * - MUST return a limited value if owner is subject to some withdrawal limit or timelock.
     * - MUST return balanceOf(owner) if owner is not subject to any withdrawal limit or timelock.
     * - MUST NOT revert.
     */
    function maxRedeem(address owner) external view returns (uint256 maxShares);

    /**
     * @dev Allows an on-chain or off-chain user to simulate the effects of their redeemption at the current block,
     * given current on-chain conditions.
     *
     * - MUST return as close to and no more than the exact amount of assets that would be withdrawn in a redeem call
     *   in the same transaction. I.e. redeem should return the same or more assets as previewRedeem if called in the
     *   same transaction.
     * - MUST NOT account for redemption limits like those returned from maxRedeem and should always act as though the
     *   redemption would be accepted, regardless if the user has enough shares, etc.
     * - MUST be inclusive of withdrawal fees. Integrators should be aware of the existence of withdrawal fees.
     * - MUST NOT revert.
     *
     * NOTE: any unfavorable discrepancy between convertToAssets and previewRedeem SHOULD be considered slippage in
     * share price or some other type of condition, meaning the depositor will lose assets by redeeming.
     */
    function previewRedeem(uint256 shares) external view returns (uint256 assets);

    /**
     * @dev Burns exactly shares from owner and sends assets of underlying tokens to receiver.
     *
     * - MUST emit the Withdraw event.
     * - MAY support an additional flow in which the underlying tokens are owned by the Vault contract before the
     *   redeem execution, and are accounted for during redeem.
     * - MUST revert if all of shares cannot be redeemed (due to withdrawal limit being reached, slippage, the owner
     *   not having enough shares, etc).
     *
     * NOTE: some implementations will require pre-requesting to the Vault before a withdrawal may be performed.
     * Those methods should be performed separately.
     */
    function redeem(uint256 shares, address receiver, address owner) external returns (uint256 assets);
}

// SPDX-License-Identifier: MIT
pragma solidity 0.8.27;

library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    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 overflow flag.
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

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

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        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 division by zero flag.
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

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

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

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

    /**
     * @dev Returns the average of two numbers. The result is rounded towards
     * zero.
     */
    function average(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b) / 2 can overflow.
        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.
            return a / b;
        }

        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

    /**
     * @notice Calculates floor(x * y / denominator) with full precision. Throws if result overflows a uint256 or
     * denominator == 0.
     * @dev 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^256 and mod 2^256 - 1, then use
            // use the Chinese Remainder Theorem to reconstruct the 512 bit result. The result is stored in two 256
            // variables such that product = prod1 * 2^256 + 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^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

            ///////////////////////////////////////////////
            // 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^256 / 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^256. Now that denominator is an odd number, it has an inverse modulo 2^256 such
            // that denominator * inv = 1 mod 2^256. Compute the inverse by starting with a seed that is correct for
            // four bits. That is, denominator * inv = 1 mod 2^4.
            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^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

            // 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^256. Since the preconditions guarantee that the outcome is
            // less than 2^256, 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;
        }
    }

    /**
     * @notice 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) {
        uint256 result = mulDiv(x, y, denominator);
        if (unsignedRoundsUp(rounding) && mulmod(x, y, denominator) > 0) {
            result += 1;
        }
        return result;
    }

    /**
     * @dev Returns the square root of a number. If the number is not a perfect square, the value is rounded
     * towards zero.
     *
     * Inspired by Henry S. Warren, Jr.'s "Hacker's Delight" (Chapter 11).
     */
    function sqrt(uint256 a) internal pure returns (uint256) {
        if (a == 0) {
            return 0;
        }

        // For our first guess, we get the biggest power of 2 which is smaller than the square root of the target.
        //
        // We know that the "msb" (most significant bit) of our target number `a` is a power of 2 such that we have
        // `msb(a) <= a < 2*msb(a)`. This value can be written `msb(a)=2**k` with `k=log2(a)`.
        //
        // This can be rewritten `2**log2(a) <= a < 2**(log2(a) + 1)`
        // → `sqrt(2**k) <= sqrt(a) < sqrt(2**(k+1))`
        // → `2**(k/2) <= sqrt(a) < 2**((k+1)/2) <= 2**(k/2 + 1)`
        //
        // Consequently, `2**(log2(a) / 2)` is a good first approximation of `sqrt(a)` with at least 1 correct bit.
        uint256 result = 1 << (log2(a) >> 1);

        // At this point `result` is an estimation with one bit of precision. We know the true value is a uint128,
        // since it is the square root of a uint256. Newton's method converges quadratically (precision doubles at
        // every iteration). We thus need at most 7 iteration to turn our partial result with one bit of precision
        // into the expected uint128 result.
        unchecked {
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            result = (result + a / result) >> 1;
            return min(result, a / result);
        }
    }

    /**
     * @notice 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 + (unsignedRoundsUp(rounding) && result * result < a ? 1 : 0);
        }
    }

    /**
     * @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;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 128;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 64;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 32;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 16;
            }
            if (value >> 8 > 0) {
                value >>= 8;
                result += 8;
            }
            if (value >> 4 > 0) {
                value >>= 4;
                result += 4;
            }
            if (value >> 2 > 0) {
                value >>= 2;
                result += 2;
            }
            if (value >> 1 > 0) {
                result += 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 + (unsignedRoundsUp(rounding) && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @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 + (unsignedRoundsUp(rounding) && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @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;
        unchecked {
            if (value >> 128 > 0) {
                value >>= 128;
                result += 16;
            }
            if (value >> 64 > 0) {
                value >>= 64;
                result += 8;
            }
            if (value >> 32 > 0) {
                value >>= 32;
                result += 4;
            }
            if (value >> 16 > 0) {
                value >>= 16;
                result += 2;
            }
            if (value >> 8 > 0) {
                result += 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 + (unsignedRoundsUp(rounding) && 1 << (result << 3) < value ? 1 : 0);
        }
    }

    /**
     * @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: MIT
pragma solidity 0.8.27;

import "./IERC20.sol";
import "./Address.sol";

library SafeERC20 {
    using Address for address;

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     *
     * This is a variant of {_callOptionalReturn} that silents catches all reverts and returns a bool instead.
     */
    function _callOptionalReturnBool(IERC20 token, bytes memory data) private returns (bool) {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We cannot use {Address-functionCall} here since this should return false
        // and not revert is the subcall reverts.

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract IERC20","name":"konkToken","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[{"internalType":"address","name":"target","type":"address"}],"name":"AddressEmptyCode","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"AddressInsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"allowance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientAllowance","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"},{"internalType":"uint256","name":"needed","type":"uint256"}],"name":"ERC20InsufficientBalance","type":"error"},{"inputs":[{"internalType":"address","name":"approver","type":"address"}],"name":"ERC20InvalidApprover","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"}],"name":"ERC20InvalidReceiver","type":"error"},{"inputs":[{"internalType":"address","name":"sender","type":"address"}],"name":"ERC20InvalidSender","type":"error"},{"inputs":[{"internalType":"address","name":"spender","type":"address"}],"name":"ERC20InvalidSpender","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"uint256","name":"max","type":"uint256"}],"name":"ERC4626ExceededMaxDeposit","type":"error"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"uint256","name":"max","type":"uint256"}],"name":"ERC4626ExceededMaxMint","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"uint256","name":"max","type":"uint256"}],"name":"ERC4626ExceededMaxRedeem","type":"error"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"uint256","name":"max","type":"uint256"}],"name":"ERC4626ExceededMaxWithdraw","type":"error"},{"inputs":[],"name":"FailedInnerCall","type":"error"},{"inputs":[],"name":"MathOverflowedMulDiv","type":"error"},{"inputs":[{"internalType":"address","name":"token","type":"address"}],"name":"SafeERC20FailedOperation","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"spender","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"assets","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"Deposit","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"value","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"sender","type":"address"},{"indexed":true,"internalType":"address","name":"receiver","type":"address"},{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":false,"internalType":"uint256","name":"assets","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"Withdraw","type":"event"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"}],"name":"allowance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"asset","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"name":"convertToAssets","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"name":"convertToShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"}],"name":"deposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"maxDeposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"maxMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"maxRedeem","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"maxWithdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"}],"name":"mint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"name":"previewDeposit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"name":"previewMint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"}],"name":"previewRedeem","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"}],"name":"previewWithdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"shares","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"redeem","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalAssets","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transfer","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"assets","type":"uint256"},{"internalType":"address","name":"receiver","type":"address"},{"internalType":"address","name":"owner","type":"address"}],"name":"withdraw","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"nonpayable","type":"function"}]

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

0000000000000000000000002b9712190ce9570c1ca860d55b1623bd88bf96ff

-----Decoded View---------------
Arg [0] : konkToken (address): 0x2b9712190Ce9570C1CA860D55B1623Bd88BF96fF

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 0000000000000000000000002b9712190ce9570c1ca860d55b1623bd88bf96ff

384:286:8:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;539:128;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;870:91:2;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3232:150:3;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3163:190:2;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4533:149:3;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1972:99:2;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3931:249;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2501:153:3;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2701:96;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3434:110;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4737:148;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4934:402;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2134:118:2;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;5610:390:3;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1080:95:2;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2457:182;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4331:145:3;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6050:423;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;6521:415;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3593:107;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3025:150;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3753:155;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3959:114;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2702:142:2;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4129:149:3;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;539:128:8;592:7;626;:5;:7::i;:::-;619:25;;;653:4;619:40;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;612:47;;539:128;:::o;870:91:2:-;915:13;948:5;941:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;870:91;:::o;3232:150:3:-;3302:7;3329:45;3346:6;3354:19;3329:16;:45::i;:::-;3322:52;;3232:150;;;:::o;3163:190:2:-;3236:4;3253:13;3269:12;:10;:12::i;:::-;3253:28;;3292:31;3301:5;3308:7;3317:5;3292:8;:31::i;:::-;3341:4;3334:11;;;3163:190;;;;:::o;4533:149:3:-;4603:7;4630:44;4647:6;4655:18;4630:16;:44::i;:::-;4623:51;;4533:149;;;:::o;1972:99:2:-;2024:7;2051:12;;2044:19;;1972:99;:::o;3931:249::-;4018:4;4035:15;4053:12;:10;:12::i;:::-;4035:30;;4076:37;4092:4;4098:7;4107:5;4076:15;:37::i;:::-;4124:26;4134:4;4140:2;4144:5;4124:9;:26::i;:::-;4168:4;4161:11;;;3931:249;;;;;:::o;2501:153:3:-;2582:5;2629:17;:15;:17::i;:::-;2607:19;:39;;;;:::i;:::-;2600:46;;2501:153;:::o;2701:96::-;2747:7;2782:6;2767:22;;2701:96;:::o;3434:110::-;3492:7;3519:17;3512:24;;3434:110;;;:::o;4737:148::-;4805:7;4832:45;4849:6;4857:19;4832:16;:45::i;:::-;4825:52;;4737:148;;;:::o;4934:402::-;5009:7;5029:17;5049:20;5060:8;5049:10;:20::i;:::-;5029:40;;5093:9;5084:6;:18;5080:112;;;5152:8;5162:6;5170:9;5126:54;;;;;;;;;;;;;:::i;:::-;;;;;;;;5080:112;5204:14;5221:22;5236:6;5221:14;:22::i;:::-;5204:39;;5254:48;5263:12;:10;:12::i;:::-;5277:8;5287:6;5295;5254:8;:48::i;:::-;5322:6;5315:13;;;;4934:402;;;;:::o;2134:118:2:-;2199:7;2226:9;:18;2236:7;2226:18;;;;;;;;;;;;;;;;2219:25;;2134:118;;;:::o;5610:390:3:-;5682:7;5702:17;5722;5730:8;5722:7;:17::i;:::-;5702:37;;5763:9;5754:6;:18;5750:109;;;5819:8;5829:6;5837:9;5796:51;;;;;;;;;;;;;:::i;:::-;;;;;;;;5750:109;5871:14;5888:19;5900:6;5888:11;:19::i;:::-;5871:36;;5918:48;5927:12;:10;:12::i;:::-;5941:8;5951:6;5959;5918:8;:48::i;:::-;5986:6;5979:13;;;;5610:390;;;;:::o;1080:95:2:-;1127:13;1160:7;1153:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1080:95;:::o;2457:182::-;2526:4;2543:13;2559:12;:10;:12::i;:::-;2543:28;;2582:27;2592:5;2599:2;2603:5;2582:9;:27::i;:::-;2627:4;2620:11;;;2457:182;;;;:::o;4331:145:3:-;4397:7;4424:44;4441:6;4449:18;4424:16;:44::i;:::-;4417:51;;4331:145;;;:::o;6050:423::-;6141:7;6161:17;6181:18;6193:5;6181:11;:18::i;:::-;6161:38;;6223:9;6214:6;:18;6210:110;;;6283:5;6290:6;6298:9;6256:52;;;;;;;;;;;;;:::i;:::-;;;;;;;;6210:110;6332:14;6349:23;6365:6;6349:15;:23::i;:::-;6332:40;;6383:56;6393:12;:10;:12::i;:::-;6407:8;6417:5;6424:6;6432;6383:9;:56::i;:::-;6459:6;6452:13;;;;6050:423;;;;;:::o;6521:415::-;6610:7;6630:17;6650:16;6660:5;6650:9;:16::i;:::-;6630:36;;6690:9;6681:6;:18;6677:108;;;6748:5;6755:6;6763:9;6723:50;;;;;;;;;;;;;:::i;:::-;;;;;;;;6677:108;6797:14;6814:21;6828:6;6814:13;:21::i;:::-;6797:38;;6846:56;6856:12;:10;:12::i;:::-;6870:8;6880:5;6887:6;6895;6846:9;:56::i;:::-;6922:6;6915:13;;;;6521:415;;;;;:::o;3593:107::-;3648:7;3675:17;3668:24;;3593:107;;;:::o;3025:150::-;3095:7;3122:45;3139:6;3147:19;3122:16;:45::i;:::-;3115:52;;3025:150;;;:::o;3753:155::-;3818:7;3845:55;3862:16;3872:5;3862:9;:16::i;:::-;3880:19;3845:16;:55::i;:::-;3838:62;;3753:155;;;:::o;3959:114::-;4022:7;4049:16;4059:5;4049:9;:16::i;:::-;4042:23;;3959:114;;;:::o;2702:142:2:-;2782:7;2809:11;:18;2821:5;2809:18;;;;;;;;;;;;;;;:27;2828:7;2809:27;;;;;;;;;;;;;;;;2802:34;;2702:142;;;;:::o;4129:149:3:-;4198:7;4225:45;4242:6;4250:19;4225:16;:45::i;:::-;4218:52;;4129:149;;;:::o;7409:215::-;7506:7;7533:83;7563:1;7547:13;:11;:13::i;:::-;:17;;;;:::i;:::-;7588;:15;:17::i;:::-;7582:2;:23;;;;:::i;:::-;7566:13;:11;:13::i;:::-;:39;;;;:::i;:::-;7607:8;7533:6;:13;;:83;;;;;;:::i;:::-;7526:90;;7409:215;;;;:::o;93:98:1:-;146:7;173:10;166:17;;93:98;:::o;7990:130:2:-;8075:37;8084:5;8091:7;8100:5;8107:4;8075:8;:37::i;:::-;7990:130;;;:::o;7065:215:3:-;7162:7;7189:83;7225:17;:15;:17::i;:::-;7219:2;:23;;;;:::i;:::-;7203:13;:11;:13::i;:::-;:39;;;;:::i;:::-;7260:1;7244:13;:11;:13::i;:::-;:17;;;;:::i;:::-;7263:8;7189:6;:13;;:83;;;;;;:::i;:::-;7182:90;;7065:215;;;;:::o;9706:487:2:-;9806:24;9833:25;9843:5;9850:7;9833:9;:25::i;:::-;9806:52;;9893:17;9873:16;:37;9869:317;;9950:5;9931:16;:24;9927:132;;;10010:7;10019:16;10037:5;9983:60;;;;;;;;;;;;;:::i;:::-;;;;;;;;9927:132;10102:57;10111:5;10118:7;10146:5;10127:16;:24;10153:5;10102:8;:57::i;:::-;9869:317;9795:398;9706:487;;;:::o;4565:308::-;4665:1;4649:18;;:4;:18;;;4645:88;;4718:1;4691:30;;;;;;;;;;;:::i;:::-;;;;;;;;4645:88;4761:1;4747:16;;:2;:16;;;4743:88;;4816:1;4787:32;;;;;;;;;;;:::i;:::-;;;;;;;;4743:88;4841:24;4849:4;4855:2;4859:5;4841:7;:24::i;:::-;4565:308;;;:::o;9550:92:3:-;9608:5;9633:1;9626:8;;9550:92;:::o;7693:842::-;8369:65;8396:6;8404;8420:4;8427:6;8369:26;:65::i;:::-;8445:23;8451:8;8461:6;8445:5;:23::i;:::-;8502:8;8486:41;;8494:6;8486:41;;;8512:6;8520;8486:41;;;;;;;:::i;:::-;;;;;;;;7693:842;;;;:::o;8607:935::-;8801:5;8791:15;;:6;:15;;;8787:86;;8823:38;8839:5;8846:6;8854;8823:15;:38::i;:::-;8787:86;9388:20;9394:5;9401:6;9388:5;:20::i;:::-;9419:48;9442:6;9450:8;9460:6;9419:22;:48::i;:::-;9512:5;9485:49;;9502:8;9485:49;;9494:6;9485:49;;;9519:6;9527;9485:49;;;;;;;:::i;:::-;;;;;;;;8607:935;;;;;:::o;8106:308:9:-;8207:7;8227:14;8244:25;8251:1;8254;8257:11;8244:6;:25::i;:::-;8227:42;;8284:26;8301:8;8284:16;:26::i;:::-;:59;;;;;8342:1;8327:11;8314:25;;;;;:::i;:::-;;8324:1;8321;8314:25;:29;8284:59;8280:103;;;8370:1;8360:11;;;;;:::i;:::-;;;8280:103;8400:6;8393:13;;;8106:308;;;;;;:::o;8971:443:2:-;9101:1;9084:19;;:5;:19;;;9080:91;;9156:1;9127:32;;;;;;;;;;;:::i;:::-;;;;;;;;9080:91;9204:1;9185:21;;:7;:21;;;9181:92;;9258:1;9230:31;;;;;;;;;;;:::i;:::-;;;;;;;;9181:92;9313:5;9283:11;:18;9295:5;9283:18;;;;;;;;;;;;;;;:27;9302:7;9283:27;;;;;;;;;;;;;;;:35;;;;9333:9;9329:78;;;9380:7;9364:31;;9373:5;9364:31;;;9389:5;9364:31;;;;;;:::i;:::-;;;;;;;;9329:78;8971:443;;;;:::o;5197:1135::-;5303:1;5287:18;;:4;:18;;;5283:552;;5441:5;5425:12;;:21;;;;;;;:::i;:::-;;;;;;;;5283:552;;;5479:19;5501:9;:15;5511:4;5501:15;;;;;;;;;;;;;;;;5479:37;;5549:5;5535:11;:19;5531:117;;;5607:4;5613:11;5626:5;5582:50;;;;;;;;;;;;;:::i;:::-;;;;;;;;5531:117;5803:5;5789:11;:19;5771:9;:15;5781:4;5771:15;;;;;;;;;;;;;;;:37;;;;5464:371;5283:552;5865:1;5851:16;;:2;:16;;;5847:435;;6033:5;6017:12;;:21;;;;;;;;;;;5847:435;;;6250:5;6233:9;:13;6243:2;6233:13;;;;;;;;;;;;;;;;:22;;;;;;;;;;;5847:435;6314:2;6299:25;;6308:4;6299:25;;;6318:5;6299:25;;;;;;:::i;:::-;;;;;;;;5197:1135;;;:::o;1087:190:10:-;1188:81;1208:5;1230;:18;;;1251:4;1257:2;1261:5;1215:53;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1188:19;:81::i;:::-;1087:190;;;;:::o;6685:213:2:-;6775:1;6756:21;;:7;:21;;;6752:93;;6830:1;6801:32;;;;;;;;;;;:::i;:::-;;;;;;;;6752:93;6855:35;6871:1;6875:7;6884:5;6855:7;:35::i;:::-;6685:213;;:::o;7226:211::-;7316:1;7297:21;;:7;:21;;;7293:91;;7369:1;7342:30;;;;;;;;;;;:::i;:::-;;;;;;;;7293:91;7394:35;7402:7;7419:1;7423:5;7394:7;:35::i;:::-;7226:211;;:::o;680:162:10:-;763:71;783:5;805;:14;;;822:2;826:5;790:43;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;763:19;:71::i;:::-;680:162;;;:::o;3774:4195:9:-;3856:14;4208:13;4228:1;4224;:5;4208:21;;4289:13;4416:1;4412:6;4409:1;4406;4399:20;4473:5;4469:2;4466:13;4458:5;4454:2;4450:14;4446:34;4437:43;;4370:125;4588:1;4579:5;:10;4575:373;;4921:11;4913:5;:19;;;;;:::i;:::-;;;4906:26;;;;;;4575:373;5072:5;5057:11;:20;5053:90;;5105:22;;;;;;;;;;;;;;5053:90;5405:17;5543:11;5540:1;5537;5530:25;5517:38;;5674:5;5663:9;5660:20;5653:5;5649:32;5640:41;;5719:9;5712:5;5708:21;5699:30;;5953:12;5987:11;5983:1;:15;5968:11;:31;5953:46;;6122:4;6109:11;6105:22;6090:37;;6217:4;6210:5;6206:16;6197:25;;6377:1;6370:4;6363;6360:1;6356:12;6352:23;6348:31;6340:39;;6480:4;6472:5;:12;6463:21;;;;6807:15;6845:1;6830:11;6826:1;:15;6825:21;6807:39;;7096:7;7082:11;:21;7078:1;:25;7067:36;;;;7166:7;7152:11;:21;7148:1;:25;7137:36;;;;7237:7;7223:11;:21;7219:1;:25;7208:36;;;;7308:7;7294:11;:21;7290:1;:25;7279:36;;;;7379:7;7365:11;:21;7361:1;:25;7350:36;;;;7451:7;7437:11;:21;7433:1;:25;7422:36;;;;7915:7;7907:5;:15;7898:24;;7937:13;;;;;3774:4195;;;;;;:::o;15253:124::-;15321:4;15368:1;15363;15351:8;15345:15;;;;;;;;:::i;:::-;;:19;;;;:::i;:::-;:24;;;15338:31;;15253:124;;;:::o;3491:638:10:-;3915:23;3941:33;3969:4;3949:5;3941:27;;;;:33;;;;:::i;:::-;3915:59;;4010:1;3989:10;:17;:22;;:57;;;;;4027:10;4016:30;;;;;;;;;;;;:::i;:::-;4015:31;3989:57;3985:137;;;4103:5;4070:40;;;;;;;;;;;:::i;:::-;;;;;;;;3985:137;3561:568;3491:638;;:::o;2631:153:0:-;2706:12;2738:38;2760:6;2768:4;2774:1;2738:21;:38::i;:::-;2731:45;;2631:153;;;;:::o;3119:398::-;3218:12;3271:5;3247:21;:29;3243:110;;;3335:4;3300:41;;;;;;;;;;;:::i;:::-;;;;;;;;3243:110;3364:12;3378:23;3405:6;:11;;3424:5;3431:4;3405:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;3363:73;;;;3454:55;3481:6;3489:7;3498:10;3454:26;:55::i;:::-;3447:62;;;;3119:398;;;;;:::o;4595:597::-;4743:12;4773:7;4768:417;;4797:19;4805:10;4797:7;:19::i;:::-;4768:417;;;5046:1;5025:10;:17;:22;:49;;;;;5073:1;5051:6;:18;;;:23;5025:49;5021:121;;;5119:6;5102:24;;;;;;;;;;;:::i;:::-;;;;;;;;5021:121;5163:10;5156:17;;;;4768:417;4595:597;;;;;;:::o;5745:528::-;5898:1;5878:10;:17;:21;5874:392;;;6110:10;6104:17;6167:15;6154:10;6150:2;6146:19;6139:44;5874:392;6237:17;;;;;;;;;;;;;;7:77:11;44:7;73:5;62:16;;7:77;;;:::o;90:118::-;177:24;195:5;177:24;:::i;:::-;172:3;165:37;90:118;;:::o;214:222::-;307:4;345:2;334:9;330:18;322:26;;358:71;426:1;415:9;411:17;402:6;358:71;:::i;:::-;214:222;;;;:::o;442:99::-;494:6;528:5;522:12;512:22;;442:99;;;:::o;547:169::-;631:11;665:6;660:3;653:19;705:4;700:3;696:14;681:29;;547:169;;;;:::o;722:139::-;811:6;806:3;801;795:23;852:1;843:6;838:3;834:16;827:27;722:139;;;:::o;867:102::-;908:6;959:2;955:7;950:2;943:5;939:14;935:28;925:38;;867:102;;;:::o;975:377::-;1063:3;1091:39;1124:5;1091:39;:::i;:::-;1146:71;1210:6;1205:3;1146:71;:::i;:::-;1139:78;;1226:65;1284:6;1279:3;1272:4;1265:5;1261:16;1226:65;:::i;:::-;1316:29;1338:6;1316:29;:::i;:::-;1311:3;1307:39;1300:46;;1067:285;975:377;;;;:::o;1358:313::-;1471:4;1509:2;1498:9;1494:18;1486:26;;1558:9;1552:4;1548:20;1544:1;1533:9;1529:17;1522:47;1586:78;1659:4;1650:6;1586:78;:::i;:::-;1578:86;;1358:313;;;;:::o;1758:117::-;1867:1;1864;1857:12;2004:122;2077:24;2095:5;2077:24;:::i;:::-;2070:5;2067:35;2057:63;;2116:1;2113;2106:12;2057:63;2004:122;:::o;2132:139::-;2178:5;2216:6;2203:20;2194:29;;2232:33;2259:5;2232:33;:::i;:::-;2132:139;;;;:::o;2277:329::-;2336:6;2385:2;2373:9;2364:7;2360:23;2356:32;2353:119;;;2391:79;;:::i;:::-;2353:119;2511:1;2536:53;2581:7;2572:6;2561:9;2557:22;2536:53;:::i;:::-;2526:63;;2482:117;2277:329;;;;:::o;2612:126::-;2649:7;2689:42;2682:5;2678:54;2667:65;;2612:126;;;:::o;2744:96::-;2781:7;2810:24;2828:5;2810:24;:::i;:::-;2799:35;;2744:96;;;:::o;2846:122::-;2919:24;2937:5;2919:24;:::i;:::-;2912:5;2909:35;2899:63;;2958:1;2955;2948:12;2899:63;2846:122;:::o;2974:139::-;3020:5;3058:6;3045:20;3036:29;;3074:33;3101:5;3074:33;:::i;:::-;2974:139;;;;:::o;3119:474::-;3187:6;3195;3244:2;3232:9;3223:7;3219:23;3215:32;3212:119;;;3250:79;;:::i;:::-;3212:119;3370:1;3395:53;3440:7;3431:6;3420:9;3416:22;3395:53;:::i;:::-;3385:63;;3341:117;3497:2;3523:53;3568:7;3559:6;3548:9;3544:22;3523:53;:::i;:::-;3513:63;;3468:118;3119:474;;;;;:::o;3599:90::-;3633:7;3676:5;3669:13;3662:21;3651:32;;3599:90;;;:::o;3695:109::-;3776:21;3791:5;3776:21;:::i;:::-;3771:3;3764:34;3695:109;;:::o;3810:210::-;3897:4;3935:2;3924:9;3920:18;3912:26;;3948:65;4010:1;3999:9;3995:17;3986:6;3948:65;:::i;:::-;3810:210;;;;:::o;4026:619::-;4103:6;4111;4119;4168:2;4156:9;4147:7;4143:23;4139:32;4136:119;;;4174:79;;:::i;:::-;4136:119;4294:1;4319:53;4364:7;4355:6;4344:9;4340:22;4319:53;:::i;:::-;4309:63;;4265:117;4421:2;4447:53;4492:7;4483:6;4472:9;4468:22;4447:53;:::i;:::-;4437:63;;4392:118;4549:2;4575:53;4620:7;4611:6;4600:9;4596:22;4575:53;:::i;:::-;4565:63;;4520:118;4026:619;;;;;:::o;4651:86::-;4686:7;4726:4;4719:5;4715:16;4704:27;;4651:86;;;:::o;4743:112::-;4826:22;4842:5;4826:22;:::i;:::-;4821:3;4814:35;4743:112;;:::o;4861:214::-;4950:4;4988:2;4977:9;4973:18;4965:26;;5001:67;5065:1;5054:9;5050:17;5041:6;5001:67;:::i;:::-;4861:214;;;;:::o;5081:118::-;5168:24;5186:5;5168:24;:::i;:::-;5163:3;5156:37;5081:118;;:::o;5205:222::-;5298:4;5336:2;5325:9;5321:18;5313:26;;5349:71;5417:1;5406:9;5402:17;5393:6;5349:71;:::i;:::-;5205:222;;;;:::o;5433:329::-;5492:6;5541:2;5529:9;5520:7;5516:23;5512:32;5509:119;;;5547:79;;:::i;:::-;5509:119;5667:1;5692:53;5737:7;5728:6;5717:9;5713:22;5692:53;:::i;:::-;5682:63;;5638:117;5433:329;;;;:::o;5768:474::-;5836:6;5844;5893:2;5881:9;5872:7;5868:23;5864:32;5861:119;;;5899:79;;:::i;:::-;5861:119;6019:1;6044:53;6089:7;6080:6;6069:9;6065:22;6044:53;:::i;:::-;6034:63;;5990:117;6146:2;6172:53;6217:7;6208:6;6197:9;6193:22;6172:53;:::i;:::-;6162:63;;6117:118;5768:474;;;;;:::o;6248:619::-;6325:6;6333;6341;6390:2;6378:9;6369:7;6365:23;6361:32;6358:119;;;6396:79;;:::i;:::-;6358:119;6516:1;6541:53;6586:7;6577:6;6566:9;6562:22;6541:53;:::i;:::-;6531:63;;6487:117;6643:2;6669:53;6714:7;6705:6;6694:9;6690:22;6669:53;:::i;:::-;6659:63;;6614:118;6771:2;6797:53;6842:7;6833:6;6822:9;6818:22;6797:53;:::i;:::-;6787:63;;6742:118;6248:619;;;;;:::o;6873:474::-;6941:6;6949;6998:2;6986:9;6977:7;6973:23;6969:32;6966:119;;;7004:79;;:::i;:::-;6966:119;7124:1;7149:53;7194:7;7185:6;7174:9;7170:22;7149:53;:::i;:::-;7139:63;;7095:117;7251:2;7277:53;7322:7;7313:6;7302:9;7298:22;7277:53;:::i;:::-;7267:63;;7222:118;6873:474;;;;;:::o;7353:143::-;7410:5;7441:6;7435:13;7426:22;;7457:33;7484:5;7457:33;:::i;:::-;7353:143;;;;:::o;7502:351::-;7572:6;7621:2;7609:9;7600:7;7596:23;7592:32;7589:119;;;7627:79;;:::i;:::-;7589:119;7747:1;7772:64;7828:7;7819:6;7808:9;7804:22;7772:64;:::i;:::-;7762:74;;7718:128;7502:351;;;;:::o;7859:180::-;7907:77;7904:1;7897:88;8004:4;8001:1;7994:15;8028:4;8025:1;8018:15;8045:320;8089:6;8126:1;8120:4;8116:12;8106:22;;8173:1;8167:4;8163:12;8194:18;8184:81;;8250:4;8242:6;8238:17;8228:27;;8184:81;8312:2;8304:6;8301:14;8281:18;8278:38;8275:84;;8331:18;;:::i;:::-;8275:84;8096:269;8045:320;;;:::o;8371:180::-;8419:77;8416:1;8409:88;8516:4;8513:1;8506:15;8540:4;8537:1;8530:15;8557:188;8595:3;8614:18;8630:1;8614:18;:::i;:::-;8609:23;;8646:18;8662:1;8646:18;:::i;:::-;8641:23;;8687:1;8684;8680:9;8673:16;;8710:4;8705:3;8702:13;8699:39;;;8718:18;;:::i;:::-;8699:39;8557:188;;;;:::o;8751:442::-;8900:4;8938:2;8927:9;8923:18;8915:26;;8951:71;9019:1;9008:9;9004:17;8995:6;8951:71;:::i;:::-;9032:72;9100:2;9089:9;9085:18;9076:6;9032:72;:::i;:::-;9114;9182:2;9171:9;9167:18;9158:6;9114:72;:::i;:::-;8751:442;;;;;;:::o;9199:191::-;9239:3;9258:20;9276:1;9258:20;:::i;:::-;9253:25;;9292:20;9310:1;9292:20;:::i;:::-;9287:25;;9335:1;9332;9328:9;9321:16;;9356:3;9353:1;9350:10;9347:36;;;9363:18;;:::i;:::-;9347:36;9199:191;;;;:::o;9396:102::-;9438:8;9485:5;9482:1;9478:13;9457:34;;9396:102;;;:::o;9504:848::-;9565:5;9572:4;9596:6;9587:15;;9620:5;9611:14;;9634:712;9655:1;9645:8;9642:15;9634:712;;;9750:4;9745:3;9741:14;9735:4;9732:24;9729:50;;;9759:18;;:::i;:::-;9729:50;9809:1;9799:8;9795:16;9792:451;;;10224:4;10217:5;10213:16;10204:25;;9792:451;10274:4;10268;10264:15;10256:23;;10304:32;10327:8;10304:32;:::i;:::-;10292:44;;9634:712;;;9504:848;;;;;;;:::o;10358:1073::-;10412:5;10603:8;10593:40;;10624:1;10615:10;;10626:5;;10593:40;10652:4;10642:36;;10669:1;10660:10;;10671:5;;10642:36;10738:4;10786:1;10781:27;;;;10822:1;10817:191;;;;10731:277;;10781:27;10799:1;10790:10;;10801:5;;;10817:191;10862:3;10852:8;10849:17;10846:43;;;10869:18;;:::i;:::-;10846:43;10918:8;10915:1;10911:16;10902:25;;10953:3;10946:5;10943:14;10940:40;;;10960:18;;:::i;:::-;10940:40;10993:5;;;10731:277;;11117:2;11107:8;11104:16;11098:3;11092:4;11089:13;11085:36;11067:2;11057:8;11054:16;11049:2;11043:4;11040:12;11036:35;11020:111;11017:246;;;11173:8;11167:4;11163:19;11154:28;;11208:3;11201:5;11198:14;11195:40;;;11215:18;;:::i;:::-;11195:40;11248:5;;11017:246;11288:42;11326:3;11316:8;11310:4;11307:1;11288:42;:::i;:::-;11273:57;;;;11362:4;11357:3;11353:14;11346:5;11343:25;11340:51;;;11371:18;;:::i;:::-;11340:51;11420:4;11413:5;11409:16;11400:25;;10358:1073;;;;;;:::o;11437:281::-;11495:5;11519:23;11537:4;11519:23;:::i;:::-;11511:31;;11563:25;11579:8;11563:25;:::i;:::-;11551:37;;11607:104;11644:66;11634:8;11628:4;11607:104;:::i;:::-;11598:113;;11437:281;;;;:::o;11724:332::-;11845:4;11883:2;11872:9;11868:18;11860:26;;11896:71;11964:1;11953:9;11949:17;11940:6;11896:71;:::i;:::-;11977:72;12045:2;12034:9;12030:18;12021:6;11977:72;:::i;:::-;11724:332;;;;;:::o;12062:180::-;12110:77;12107:1;12100:88;12207:4;12204:1;12197:15;12231:4;12228:1;12221:15;12248:442;12397:4;12435:2;12424:9;12420:18;12412:26;;12448:71;12516:1;12505:9;12501:17;12492:6;12448:71;:::i;:::-;12529:72;12597:2;12586:9;12582:18;12573:6;12529:72;:::i;:::-;12611;12679:2;12668:9;12664:18;12655:6;12611:72;:::i;:::-;12248:442;;;;;;:::o;12696:332::-;12817:4;12855:2;12844:9;12840:18;12832:26;;12868:71;12936:1;12925:9;12921:17;12912:6;12868:71;:::i;:::-;12949:72;13017:2;13006:9;13002:18;12993:6;12949:72;:::i;:::-;12696:332;;;;;:::o;13034:180::-;13082:77;13079:1;13072:88;13179:4;13176:1;13169:15;13203:4;13200:1;13193:15;13220:170;13250:1;13267:18;13283:1;13267:18;:::i;:::-;13262:23;;13299:18;13315:1;13299:18;:::i;:::-;13294:23;;13336:1;13326:35;;13341:18;;:::i;:::-;13326:35;13382:1;13379;13375:9;13370:14;;13220:170;;;;:::o;13396:116::-;13466:21;13481:5;13466:21;:::i;:::-;13459:5;13456:32;13446:60;;13502:1;13499;13492:12;13446:60;13396:116;:::o;13518:137::-;13572:5;13603:6;13597:13;13588:22;;13619:30;13643:5;13619:30;:::i;:::-;13518:137;;;;:::o;13661:345::-;13728:6;13777:2;13765:9;13756:7;13752:23;13748:32;13745:119;;;13783:79;;:::i;:::-;13745:119;13903:1;13928:61;13981:7;13972:6;13961:9;13957:22;13928:61;:::i;:::-;13918:71;;13874:125;13661:345;;;;:::o;14012:98::-;14063:6;14097:5;14091:12;14081:22;;14012:98;;;:::o;14116:147::-;14217:11;14254:3;14239:18;;14116:147;;;;:::o;14269:386::-;14373:3;14401:38;14433:5;14401:38;:::i;:::-;14455:88;14536:6;14531:3;14455:88;:::i;:::-;14448:95;;14552:65;14610:6;14605:3;14598:4;14591:5;14587:16;14552:65;:::i;:::-;14642:6;14637:3;14633:16;14626:23;;14377:278;14269:386;;;;:::o;14661:271::-;14791:3;14813:93;14902:3;14893:6;14813:93;:::i;:::-;14806:100;;14923:3;14916:10;;14661:271;;;;:::o

ipfs://be0e604872094cf473f8982c5b85ddf5b49f2a802aa3a6a84adb5326ff186a8b