Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta

More Options

• Is this a proxy?
• Similar
• Submit Audit
• Compare

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

import "@openzeppelin/contracts-upgradeable/token/ERC20/ERC20Upgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/introspection/IERC165Upgradeable.sol";
import "../common/EssentialContract.sol";
import "../common/LibStrings.sol";
import "./IBridgedERC20.sol";
import "./LibBridgedToken.sol";

/// @title BridgedERC20
/// @notice An upgradeable ERC20 contract that represents tokens bridged from
/// another chain.
/// @custom:security-contact [email protected]
contract BridgedERC20 is
    EssentialContract,
    IBridgedERC20,
    IBridgedERC20Initializable,
    IBridgedERC20Migratable,
    IERC165Upgradeable,
    ERC20Upgradeable
{
    /// @dev Slot 1.
    address public srcToken;

    uint8 public __srcDecimals;

    /// @dev Slot 2.
    uint256 public srcChainId;

    /// @dev Slot 3.
    /// @notice The address of the contract to migrate tokens to or from.
    address public migratingAddress;

    /// @notice If true, signals migrating 'to', false if migrating 'from'.
    bool public migratingInbound;

    uint256[47] private __gap;

    /// @notice Emitted when the migration status is changed.
    /// @param addr The address migrating 'to' or 'from'.
    /// @param inbound If false then signals migrating 'from', true if migrating 'into'.
    event MigrationStatusChanged(address addr, bool inbound);

    /// @notice Emitted when tokens are migrated to the new bridged token.
    /// @param migratedTo The address of the bridged token.
    /// @param account The address of the account.
    /// @param amount The amount of tokens migrated.
    event MigratedTo(address indexed migratedTo, address indexed account, uint256 amount);

    /// @notice Emitted when tokens are migrated from the old bridged token.
    /// @param migratedFrom The address of the bridged token.
    /// @param account The address of the account.
    /// @param amount The amount of tokens migrated.
    event MigratedFrom(address indexed migratedFrom, address indexed account, uint256 amount);

    error BTOKEN_INVALID_PARAMS();
    error BTOKEN_INVALID_TO_ADDR();
    error BTOKEN_MINT_DISALLOWED();

    /// @inheritdoc IBridgedERC20Initializable
    function init(
        address _owner,
        address _addressManager,
        address _srcToken,
        uint256 _srcChainId,
        uint8 _decimals,
        string calldata _symbol,
        string calldata _name
    )
        external
        initializer
    {
        // Check if provided parameters are valid
        LibBridgedToken.validateInputs(_srcToken, _srcChainId);
        __Essential_init(_owner, _addressManager);
        __ERC20_init(_name, _symbol);

        // Set contract properties
        srcToken = _srcToken;
        srcChainId = _srcChainId;
        __srcDecimals = _decimals;
    }

    /// @inheritdoc IBridgedERC20Migratable
    function changeMigrationStatus(
        address _migratingAddress,
        bool _migratingInbound
    )
        external
        whenNotPaused
        onlyFromNamed(LibStrings.B_ERC20_VAULT)
        nonReentrant
    {
        if (_migratingAddress == migratingAddress && _migratingInbound == migratingInbound) {
            revert BTOKEN_INVALID_PARAMS();
        }

        migratingAddress = _migratingAddress;
        migratingInbound = _migratingInbound;
        emit MigrationStatusChanged(_migratingAddress, _migratingInbound);
    }

    /// @inheritdoc IBridgedERC20
    function mint(address _account, uint256 _amount) external whenNotPaused nonReentrant {
        // mint is disabled while migrating outbound.
        if (isMigratingOut()) revert BTOKEN_MINT_DISALLOWED();

        address _migratingAddress = migratingAddress;
        if (msg.sender == _migratingAddress) {
            // Inbound migration
            emit MigratedFrom(_migratingAddress, _account, _amount);
        } else {
            // Bridging from vault
            _authorizedMintBurn(msg.sender);
        }

        _mint(_account, _amount);
    }

    /// @inheritdoc IBridgedERC20
    function burn(uint256 _amount) external whenNotPaused nonReentrant {
        if (isMigratingOut()) {
            // Outbound migration
            address _migratingAddress = migratingAddress;
            emit MigratedTo(_migratingAddress, msg.sender, _amount);
            // Ask the new bridged token to mint token for the user.
            IBridgedERC20(_migratingAddress).mint(msg.sender, _amount);
        } else {
            // When user wants to burn tokens only during 'migrating out' phase is possible. If
            // ERC20Vault burns the tokens, that will go through the burn(amount) function.
            _authorizedMintBurn(msg.sender);
        }

        _burn(msg.sender, _amount);
    }

    /// @inheritdoc IBridgedERC20
    function canonical() external view returns (address, uint256) {
        return (srcToken, srcChainId);
    }

    /// @notice Gets the number of decimal places of the token.
    /// @return The number of decimal places of the token.
    function decimals() public view override returns (uint8) {
        return __srcDecimals;
    }

    function isMigratingOut() public view returns (bool) {
        return migratingAddress != address(0) && !migratingInbound;
    }

    function supportsInterface(bytes4 _interfaceId) public pure returns (bool) {
        return _interfaceId == type(IBridgedERC20).interfaceId
            || _interfaceId == type(IBridgedERC20Initializable).interfaceId
            || _interfaceId == type(IBridgedERC20Migratable).interfaceId
            || _interfaceId == type(IERC20Upgradeable).interfaceId
            || _interfaceId == type(IERC20MetadataUpgradeable).interfaceId
            || _interfaceId == type(IERC165Upgradeable).interfaceId;
    }

    function _beforeTokenTransfer(
        address _from,
        address _to,
        uint256 _amount
    )
        internal
        override
        whenNotPaused
    {
        LibBridgedToken.checkToAddress(_to);
        return super._beforeTokenTransfer(_from, _to, _amount);
    }

    function _authorizedMintBurn(address addr)
        private
        onlyFromOwnerOrNamed(LibStrings.B_ERC20_VAULT)
    { }
}

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

pragma solidity ^0.8.0;

import "./IERC20Upgradeable.sol";
import "./extensions/IERC20MetadataUpgradeable.sol";
import "../../utils/ContextUpgradeable.sol";
import {Initializable} from "../../proxy/utils/Initializable.sol";

/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.openzeppelin.com/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * The default value of {decimals} is 18. To change this, you should override
 * this function so it returns a different value.
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20Upgradeable is Initializable, ContextUpgradeable, IERC20Upgradeable, IERC20MetadataUpgradeable {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => 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.
     */
    function __ERC20_init(string memory name_, string memory symbol_) internal onlyInitializing {
        __ERC20_init_unchained(name_, symbol_);
    }

    function __ERC20_init_unchained(string memory name_, string memory symbol_) internal onlyInitializing {
        _name = name_;
        _symbol = symbol_;
    }

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

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override 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 override returns (uint8) {
        return 18;
    }

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override 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 `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

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

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` 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 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        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 `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(address from, address to, uint256 amount) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `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.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(address from, address to, uint256 amount) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
            // Overflow not possible: the sum of all balances is capped by totalSupply, and the sum is preserved by
            // decrementing then incrementing.
            _balances[to] += amount;
        }

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        unchecked {
            // Overflow not possible: balance + amount is at most totalSupply + amount, which is checked above.
            _balances[account] += amount;
        }
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
            // Overflow not possible: amount <= accountBalance <= totalSupply.
            _totalSupply -= amount;
        }

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` 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.
     */
    function _approve(address owner, address spender, uint256 amount) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

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

    /**
     * @dev Hook that is called before any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * will be transferred to `to`.
     * - when `from` is zero, `amount` tokens will be minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual {}

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(address from, address to, uint256 amount) internal virtual {}

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

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

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

import "@openzeppelin/contracts/proxy/utils/UUPSUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/access/Ownable2StepUpgradeable.sol";
import "./AddressResolver.sol";
import "../libs/LibNetwork.sol";

/// @title EssentialContract
/// @custom:security-contact [email protected]
abstract contract EssentialContract is UUPSUpgradeable, Ownable2StepUpgradeable, AddressResolver {
    uint8 private constant _FALSE = 1;

    uint8 private constant _TRUE = 2;

    /// @dev The slot in transient storage of the reentry lock.
    /// This is the result of keccak256("ownerUUPS.reentry_slot") plus 1. The addition aims to
    /// prevent hash collisions with slots defined in EIP-1967, where slots are derived by
    /// keccak256("something") - 1, and with slots in SignalService, calculated directly with
    /// keccak256("something").
    bytes32 private constant _REENTRY_SLOT =
        0xa5054f728453d3dbe953bdc43e4d0cb97e662ea32d7958190f3dc2da31d9721b;

    /// @dev Slot 1.
    uint8 private __reentry;
    uint8 private __paused;
    uint64 public lastUnpausedAt;

    uint256[49] private __gap;

    /// @notice Emitted when the contract is paused.
    /// @param account The account that paused the contract.
    event Paused(address account);

    /// @notice Emitted when the contract is unpaused.
    /// @param account The account that unpaused the contract.
    event Unpaused(address account);

    error INVALID_PAUSE_STATUS();
    error FUNC_NOT_IMPLEMENTED();
    error REENTRANT_CALL();
    error ZERO_ADDRESS();
    error ZERO_VALUE();

    /// @dev Modifier that ensures the caller is the owner or resolved address of a given name.
    /// @param _name The name to check against.
    modifier onlyFromOwnerOrNamed(bytes32 _name) {
        if (msg.sender != owner() && msg.sender != resolve(_name, true)) revert RESOLVER_DENIED();
        _;
    }

    modifier notImplemented() {
        revert FUNC_NOT_IMPLEMENTED();
        _;
    }

    modifier nonReentrant() {
        if (_loadReentryLock() == _TRUE) revert REENTRANT_CALL();
        _storeReentryLock(_TRUE);
        _;
        _storeReentryLock(_FALSE);
    }

    modifier whenPaused() {
        if (!paused()) revert INVALID_PAUSE_STATUS();
        _;
    }

    modifier whenNotPaused() {
        if (paused()) revert INVALID_PAUSE_STATUS();
        _;
    }

    modifier nonZeroAddr(address _addr) {
        if (_addr == address(0)) revert ZERO_ADDRESS();
        _;
    }

    modifier nonZeroValue(bytes32 _value) {
        if (_value == 0) revert ZERO_VALUE();
        _;
    }

    /// @custom:oz-upgrades-unsafe-allow constructor
    constructor() {
        _disableInitializers();
    }

    /// @notice Pauses the contract.
    function pause() public virtual {
        _pause();
        // We call the authorize function here to avoid:
        // Warning (5740): Unreachable code.
        _authorizePause(msg.sender, true);
    }

    /// @notice Unpauses the contract.
    function unpause() public virtual {
        _unpause();
        // We call the authorize function here to avoid:
        // Warning (5740): Unreachable code.
        _authorizePause(msg.sender, false);
    }

    function impl() public view returns (address) {
        return _getImplementation();
    }

    /// @notice Returns true if the contract is paused, and false otherwise.
    /// @return true if paused, false otherwise.
    function paused() public view returns (bool) {
        return __paused == _TRUE;
    }

    function inNonReentrant() public view returns (bool) {
        return _loadReentryLock() == _TRUE;
    }

    /// @notice Initializes the contract.
    /// @param _owner The owner of this contract. msg.sender will be used if this value is zero.
    /// @param _addressManager The address of the {AddressManager} contract.
    function __Essential_init(
        address _owner,
        address _addressManager
    )
        internal
        nonZeroAddr(_addressManager)
    {
        __Essential_init(_owner);
        __AddressResolver_init(_addressManager);
    }

    function __Essential_init(address _owner) internal virtual onlyInitializing {
        __Context_init();
        _transferOwnership(_owner == address(0) ? msg.sender : _owner);
        __paused = _FALSE;
    }

    function _pause() internal whenNotPaused {
        __paused = _TRUE;
        emit Paused(msg.sender);
    }

    function _unpause() internal whenPaused {
        __paused = _FALSE;
        lastUnpausedAt = uint64(block.timestamp);
        emit Unpaused(msg.sender);
    }

    function _authorizeUpgrade(address) internal virtual override onlyOwner { }

    function _authorizePause(address, bool) internal virtual onlyOwner { }

    // Stores the reentry lock
    function _storeReentryLock(uint8 _reentry) internal virtual {
        if (LibNetwork.isDencunSupported(block.chainid)) {
            assembly {
                tstore(_REENTRY_SLOT, _reentry)
            }
        } else {
            __reentry = _reentry;
        }
    }

    // Loads the reentry lock
    function _loadReentryLock() internal view virtual returns (uint8 reentry_) {
        if (LibNetwork.isDencunSupported(block.chainid)) {
            assembly {
                reentry_ := tload(_REENTRY_SLOT)
            }
        } else {
            reentry_ = __reentry;
        }
    }
}

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

/// @title LibStrings
/// @custom:security-contact [email protected]
library LibStrings {
    bytes32 internal constant B_ASSIGNMENT_HOOK = bytes32("assignment_hook");
    bytes32 internal constant B_AUTOMATA_DCAP_ATTESTATION = bytes32("automata_dcap_attestation");
    bytes32 internal constant B_BRIDGE = bytes32("bridge");
    bytes32 internal constant B_BRIDGE_WATCHDOG = bytes32("bridge_watchdog");
    bytes32 internal constant B_BRIDGED_ERC1155 = bytes32("bridged_erc1155");
    bytes32 internal constant B_BRIDGED_ERC20 = bytes32("bridged_erc20");
    bytes32 internal constant B_BRIDGED_ERC721 = bytes32("bridged_erc721");
    bytes32 internal constant B_CHAIN_WATCHDOG = bytes32("chain_watchdog");
    bytes32 internal constant B_ERC1155_VAULT = bytes32("erc1155_vault");
    bytes32 internal constant B_ERC20_VAULT = bytes32("erc20_vault");
    bytes32 internal constant B_ERC721_VAULT = bytes32("erc721_vault");
    bytes32 internal constant B_PROPOSER = bytes32("proposer");
    bytes32 internal constant B_PROPOSER_ONE = bytes32("proposer_one");
    bytes32 internal constant B_PROVER_ASSIGNMENT = bytes32("PROVER_ASSIGNMENT");
    bytes32 internal constant B_PROVER_SET = bytes32("prover_set");
    bytes32 internal constant B_QUOTA_MANAGER = bytes32("quota_manager");
    bytes32 internal constant B_SGX_WATCHDOG = bytes32("sgx_watchdog");
    bytes32 internal constant B_SIGNAL_SERVICE = bytes32("signal_service");
    bytes32 internal constant B_TAIKO = bytes32("taiko");
    bytes32 internal constant B_TAIKO_TOKEN = bytes32("taiko_token");
    bytes32 internal constant B_TIER_GUARDIAN = bytes32("tier_guardian");
    bytes32 internal constant B_TIER_GUARDIAN_MINORITY = bytes32("tier_guardian_minority");
    bytes32 internal constant B_TIER_PROVIDER = bytes32("tier_provider");
    bytes32 internal constant B_TIER_SGX = bytes32("tier_sgx");
    bytes32 internal constant B_TIER_SGX_ZKVM = bytes32("tier_sgx_zkvm");
    bytes32 internal constant B_WITHDRAWER = bytes32("withdrawer");
    bytes32 internal constant H_RETURN_LIVENESS_BOND = keccak256("RETURN_LIVENESS_BOND");
    bytes32 internal constant H_SIGNAL_ROOT = keccak256("SIGNAL_ROOT");
    bytes32 internal constant H_STATE_ROOT = keccak256("STATE_ROOT");
}

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

/// @title IBridgedERC20
/// @notice Interface for all bridged tokens.
/// @dev To facilitate compatibility with third-party bridged tokens, such as USDC's native
/// standard, it's necessary to implement an intermediary adapter contract which should conform to
/// this interface, enabling effective interaction with third-party contracts.
/// @custom:security-contact [email protected]
interface IBridgedERC20 {
    /// @notice Mints `amount` tokens and assigns them to the `account` address.
    /// @param _account The account to receive the minted tokens.
    /// @param _amount The amount of tokens to mint.
    function mint(address _account, uint256 _amount) external;

    /// @notice Burns tokens from msg.sender. This is only allowed if:
    /// - 1) tokens are migrating out to a new bridged token
    /// - 2) The token is burned by ERC20Vault to bridge back to the canonical chain.
    /// @param _amount The amount of tokens to burn.
    function burn(uint256 _amount) external;

    /// @notice Gets the canonical token's address and chain ID.
    /// @return The canonical token's address.
    /// @return The canonical token's chain ID.
    function canonical() external view returns (address, uint256);
}

/// @title IBridgedERC20Migratable
/// @custom:security-contact [email protected]
interface IBridgedERC20Migratable {
    /// @notice Starts or stops migration to/from a specified contract.
    /// @param _addr The address migrating 'to' or 'from'.
    /// @param _inbound If false then signals migrating 'from', true if migrating 'into'.
    function changeMigrationStatus(address _addr, bool _inbound) external;
}

/// @title IBridgedERC20Initializable
/// @custom:security-contact [email protected]
interface IBridgedERC20Initializable {
    /// @notice Initializes the contract.
    /// @param _owner The owner of this contract. msg.sender will be used if this value is zero.
    /// @param _addressManager The address of the {AddressManager} contract.
    /// @param _srcToken The source token address.
    /// @param _srcChainId The source chain ID.
    /// @param _decimals The number of decimal places of the source token.
    /// @param _symbol The symbol of the token.
    /// @param _name The name of the token.
    function init(
        address _owner,
        address _addressManager,
        address _srcToken,
        uint256 _srcChainId,
        uint8 _decimals,
        string calldata _symbol,
        string calldata _name
    )
        external;
}

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

import "@openzeppelin/contracts/utils/Strings.sol";

/// @title LibBridgedToken
/// @custom:security-contact [email protected]
library LibBridgedToken {
    error BTOKEN_INVALID_PARAMS();
    error BTOKEN_INVALID_TO_ADDR();

    function validateInputs(address _srcToken, uint256 _srcChainId) internal view {
        if (_srcToken == address(0) || _srcChainId == 0 || _srcChainId == block.chainid) {
            revert BTOKEN_INVALID_PARAMS();
        }
    }

    function checkToAddress(address _to) internal view {
        if (_to == address(this)) revert BTOKEN_INVALID_TO_ADDR();
    }

    function buildURI(
        address _srcToken,
        uint256 _srcChainId,
        string memory _extraParams
    )
        internal
        pure
        returns (string memory)
    {
        // Creates a base URI in the format specified by EIP-681:
        // https://eips.ethereum.org/EIPS/eip-681
        return string(
            abi.encodePacked(
                "ethereum:",
                Strings.toHexString(uint160(_srcToken), 20),
                "@",
                Strings.toString(_srcChainId),
                "/tokenURI?uint256=",
                _extraParams
            )
        );
    }
}

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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20Upgradeable {
    /**
     * @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 amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

    /**
     * @dev Returns the remaining number of tokens that `spender` will be
     * allowed to spend on behalf of `owner` through {transferFrom}. This is
     * zero by default.
     *
     * This value changes when {approve} or {transferFrom} are called.
     */
    function allowance(address owner, address spender) external view returns (uint256);

    /**
     * @dev Sets `amount` as the allowance of `spender` over the caller's tokens.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * IMPORTANT: Beware that changing an allowance with this method brings the risk
     * that someone may use both the old and the new allowance by unfortunate
     * transaction ordering. One possible solution to mitigate this race
     * condition is to first reduce the spender's allowance to 0 and set the
     * desired value afterwards:
     * https://github.com/ethereum/EIPs/issues/20#issuecomment-263524729
     *
     * Emits an {Approval} event.
     */
    function approve(address spender, uint256 amount) external returns (bool);

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;

import "../IERC20Upgradeable.sol";

/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20MetadataUpgradeable is IERC20Upgradeable {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

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

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

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

pragma solidity ^0.8.0;
import {Initializable} from "../proxy/utils/Initializable.sol";

/**
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract ContextUpgradeable is Initializable {
    function __Context_init() internal onlyInitializing {
    }

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/Initializable.sol)

pragma solidity ^0.8.2;

import "../../utils/AddressUpgradeable.sol";

/**
 * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed
 * behind a proxy. Since proxied contracts do not make use of a constructor, it's common to move constructor logic to an
 * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer
 * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect.
 *
 * The initialization functions use a version number. Once a version number is used, it is consumed and cannot be
 * reused. This mechanism prevents re-execution of each "step" but allows the creation of new initialization steps in
 * case an upgrade adds a module that needs to be initialized.
 *
 * For example:
 *
 * [.hljs-theme-light.nopadding]
 * ```solidity
 * contract MyToken is ERC20Upgradeable {
 *     function initialize() initializer public {
 *         __ERC20_init("MyToken", "MTK");
 *     }
 * }
 *
 * contract MyTokenV2 is MyToken, ERC20PermitUpgradeable {
 *     function initializeV2() reinitializer(2) public {
 *         __ERC20Permit_init("MyToken");
 *     }
 * }
 * ```
 *
 * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as
 * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}.
 *
 * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure
 * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity.
 *
 * [CAUTION]
 * ====
 * Avoid leaving a contract uninitialized.
 *
 * An uninitialized contract can be taken over by an attacker. This applies to both a proxy and its implementation
 * contract, which may impact the proxy. To prevent the implementation contract from being used, you should invoke
 * the {_disableInitializers} function in the constructor to automatically lock it when it is deployed:
 *
 * [.hljs-theme-light.nopadding]
 * ```
 * /// @custom:oz-upgrades-unsafe-allow constructor
 * constructor() {
 *     _disableInitializers();
 * }
 * ```
 * ====
 */
abstract contract Initializable {
    /**
     * @dev Indicates that the contract has been initialized.
     * @custom:oz-retyped-from bool
     */
    uint8 private _initialized;

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

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/utils/UUPSUpgradeable.sol)

pragma solidity ^0.8.0;

import "../../interfaces/draft-IERC1822.sol";
import "../ERC1967/ERC1967Upgrade.sol";

/**
 * @dev An upgradeability mechanism designed for UUPS proxies. The functions included here can perform an upgrade of an
 * {ERC1967Proxy}, when this contract is set as the implementation behind such a proxy.
 *
 * A security mechanism ensures that an upgrade does not turn off upgradeability accidentally, although this risk is
 * reinstated if the upgrade retains upgradeability but removes the security mechanism, e.g. by replacing
 * `UUPSUpgradeable` with a custom implementation of upgrades.
 *
 * The {_authorizeUpgrade} function must be overridden to include access restriction to the upgrade mechanism.
 *
 * _Available since v4.1._
 */
abstract contract UUPSUpgradeable is IERC1822Proxiable, ERC1967Upgrade {
    /// @custom:oz-upgrades-unsafe-allow state-variable-immutable state-variable-assignment
    address private immutable __self = address(this);

    /**
     * @dev Check that the execution is being performed through a delegatecall call and that the execution context is
     * a proxy contract with an implementation (as defined in ERC1967) pointing to self. This should only be the case
     * for UUPS and transparent proxies that are using the current contract as their implementation. Execution of a
     * function through ERC1167 minimal proxies (clones) would not normally pass this test, but is not guaranteed to
     * fail.
     */
    modifier onlyProxy() {
        require(address(this) != __self, "Function must be called through delegatecall");
        require(_getImplementation() == __self, "Function must be called through active proxy");
        _;
    }

    /**
     * @dev Check that the execution is not being performed through a delegate call. This allows a function to be
     * callable on the implementing contract but not through proxies.
     */
    modifier notDelegated() {
        require(address(this) == __self, "UUPSUpgradeable: must not be called through delegatecall");
        _;
    }

    /**
     * @dev Implementation of the ERC1822 {proxiableUUID} function. This returns the storage slot used by the
     * implementation. It is used to validate the implementation's compatibility when performing an upgrade.
     *
     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
     * function revert if invoked through a proxy. This is guaranteed by the `notDelegated` modifier.
     */
    function proxiableUUID() external view virtual override notDelegated returns (bytes32) {
        return _IMPLEMENTATION_SLOT;
    }

    /**
     * @dev Upgrade the implementation of the proxy to `newImplementation`.
     *
     * Calls {_authorizeUpgrade}.
     *
     * Emits an {Upgraded} event.
     *
     * @custom:oz-upgrades-unsafe-allow-reachable delegatecall
     */
    function upgradeTo(address newImplementation) public virtual onlyProxy {
        _authorizeUpgrade(newImplementation);
        _upgradeToAndCallUUPS(newImplementation, new bytes(0), false);
    }

    /**
     * @dev Upgrade the implementation of the proxy to `newImplementation`, and subsequently execute the function call
     * encoded in `data`.
     *
     * Calls {_authorizeUpgrade}.
     *
     * Emits an {Upgraded} event.
     *
     * @custom:oz-upgrades-unsafe-allow-reachable delegatecall
     */
    function upgradeToAndCall(address newImplementation, bytes memory data) public payable virtual onlyProxy {
        _authorizeUpgrade(newImplementation);
        _upgradeToAndCallUUPS(newImplementation, data, true);
    }

    /**
     * @dev Function that should revert when `msg.sender` is not authorized to upgrade the contract. Called by
     * {upgradeTo} and {upgradeToAndCall}.
     *
     * Normally, this function will use an xref:access.adoc[access control] modifier such as {Ownable-onlyOwner}.
     *
     * ```solidity
     * function _authorizeUpgrade(address) internal override onlyOwner {}
     * ```
     */
    function _authorizeUpgrade(address newImplementation) internal virtual;
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable2Step.sol)

pragma solidity ^0.8.0;

import "./OwnableUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";

/**
 * @dev Contract module which provides access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership} and {acceptOwnership}.
 *
 * This module is used through inheritance. It will make available all functions
 * from parent (Ownable).
 */
abstract contract Ownable2StepUpgradeable is Initializable, OwnableUpgradeable {
    address private _pendingOwner;

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

    function __Ownable2Step_init() internal onlyInitializing {
        __Ownable_init_unchained();
    }

    function __Ownable2Step_init_unchained() internal onlyInitializing {
    }
    /**
     * @dev Returns the address of the pending owner.
     */
    function pendingOwner() public view virtual returns (address) {
        return _pendingOwner;
    }

    /**
     * @dev Starts the ownership transfer of the contract to a new account. Replaces the pending transfer if there is one.
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual override onlyOwner {
        _pendingOwner = newOwner;
        emit OwnershipTransferStarted(owner(), newOwner);
    }

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`) and deletes any pending owner.
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual override {
        delete _pendingOwner;
        super._transferOwnership(newOwner);
    }

    /**
     * @dev The new owner accepts the ownership transfer.
     */
    function acceptOwnership() public virtual {
        address sender = _msgSender();
        require(pendingOwner() == sender, "Ownable2Step: caller is not the new owner");
        _transferOwnership(sender);
    }

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

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

import "@openzeppelin/contracts-upgradeable/proxy/utils/Initializable.sol";
import "./IAddressManager.sol";
import "./IAddressResolver.sol";

/// @title AddressResolver
/// @notice See the documentation in {IAddressResolver}.
/// @custom:security-contact [email protected]
abstract contract AddressResolver is IAddressResolver, Initializable {
    /// @notice Address of the AddressManager.
    address public addressManager;
    uint256[49] private __gap;

    error RESOLVER_DENIED();
    error RESOLVER_INVALID_MANAGER();
    error RESOLVER_UNEXPECTED_CHAINID();
    error RESOLVER_ZERO_ADDR(uint64 chainId, bytes32 name);

    /// @dev Modifier that ensures the caller is the resolved address of a given
    /// name.
    /// @param _name The name to check against.
    modifier onlyFromNamed(bytes32 _name) {
        if (msg.sender != resolve(_name, true)) revert RESOLVER_DENIED();
        _;
    }

    /// @dev Modifier that ensures the caller is a resolved address to either _name1 or _name2
    /// name.
    /// @param _name1 The first name to check against.
    /// @param _name2 The second name to check against.
    modifier onlyFromNamedEither(bytes32 _name1, bytes32 _name2) {
        if (msg.sender != resolve(_name1, true) && msg.sender != resolve(_name2, true)) {
            revert RESOLVER_DENIED();
        }
        _;
    }

    /// @custom:oz-upgrades-unsafe-allow constructor
    constructor() {
        _disableInitializers();
    }

    /// @inheritdoc IAddressResolver
    function resolve(
        bytes32 _name,
        bool _allowZeroAddress
    )
        public
        view
        virtual
        returns (address payable)
    {
        return _resolve(uint64(block.chainid), _name, _allowZeroAddress);
    }

    /// @inheritdoc IAddressResolver
    function resolve(
        uint64 _chainId,
        bytes32 _name,
        bool _allowZeroAddress
    )
        public
        view
        virtual
        returns (address payable)
    {
        return _resolve(_chainId, _name, _allowZeroAddress);
    }

    /// @dev Initialization method for setting up AddressManager reference.
    /// @param _addressManager Address of the AddressManager.
    function __AddressResolver_init(address _addressManager) internal virtual onlyInitializing {
        if (block.chainid > type(uint64).max) {
            revert RESOLVER_UNEXPECTED_CHAINID();
        }
        addressManager = _addressManager;
    }

    /// @dev Helper method to resolve name-to-address.
    /// @param _chainId The chainId of interest.
    /// @param _name Name whose address is to be resolved.
    /// @param _allowZeroAddress If set to true, does not throw if the resolved
    /// address is `address(0)`.
    /// @return addr_ Address associated with the given name on the specified
    /// chain.
    function _resolve(
        uint64 _chainId,
        bytes32 _name,
        bool _allowZeroAddress
    )
        private
        view
        returns (address payable addr_)
    {
        address _addressManager = addressManager;
        if (_addressManager == address(0)) revert RESOLVER_INVALID_MANAGER();

        addr_ = payable(IAddressManager(_addressManager).getAddress(_chainId, _name));

        if (!_allowZeroAddress && addr_ == address(0)) {
            revert RESOLVER_ZERO_ADDR(_chainId, _name);
        }
    }
}

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

/// @title LibNetwork
library LibNetwork {
    uint256 internal constant MAINNET = 1;
    uint256 internal constant ROPSTEN = 2;
    uint256 internal constant RINKEBY = 4;
    uint256 internal constant GOERLI = 5;
    uint256 internal constant KOVAN = 42;
    uint256 internal constant HOLESKY = 17_000;
    uint256 internal constant SEPOLIA = 11_155_111;

    uint64 internal constant TAIKO = 167_000;

    /// @dev Checks if the chain ID represents an Ethereum testnet.
    /// @param _chainId The chain ID.
    /// @return true if the chain ID represents an Ethereum testnet, false otherwise.
    function isEthereumTestnet(uint256 _chainId) internal pure returns (bool) {
        return _chainId == LibNetwork.ROPSTEN || _chainId == LibNetwork.RINKEBY
            || _chainId == LibNetwork.GOERLI || _chainId == LibNetwork.KOVAN
            || _chainId == LibNetwork.HOLESKY || _chainId == LibNetwork.SEPOLIA;
    }

    /// @dev Checks if the chain ID represents an Ethereum testnet or the Etheruem mainnet.
    /// @param _chainId The chain ID.
    /// @return true if the chain ID represents an Ethereum testnet or the Etheruem mainnet, false
    /// otherwise.
    function isEthereumMainnetOrTestnet(uint256 _chainId) internal pure returns (bool) {
        return _chainId == LibNetwork.MAINNET || isEthereumTestnet(_chainId);
    }

    /// @dev Checks if the chain ID represents the Taiko L2 mainnet.
    /// @param _chainId The chain ID.
    /// @return true if the chain ID represents the Taiko L2 mainnet.
    function isTaikoMainnet(uint256 _chainId) internal pure returns (bool) {
        return _chainId == TAIKO;
    }

    /// @dev Checks if the chain ID represents an internal Taiko devnet's base layer.
    /// @param _chainId The chain ID.
    /// @return true if the chain ID represents an internal Taiko devnet's base layer, false
    /// otherwise.
    function isTaikoDevnet(uint256 _chainId) internal pure returns (bool) {
        return _chainId >= 32_300 && _chainId <= 32_400;
    }

    /// @dev Checks if the chain supports Dencun hardfork. Note that this check doesn't need to be
    /// exhaustive.
    /// @param _chainId The chain ID.
    /// @return true if the chain supports Dencun hardfork, false otherwise.
    function isDencunSupported(uint256 _chainId) internal pure returns (bool) {
        return _chainId == LibNetwork.MAINNET || _chainId == LibNetwork.HOLESKY
            || _chainId == LibNetwork.SEPOLIA || isTaikoDevnet(_chainId);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

import "./math/Math.sol";
import "./math/SignedMath.sol";

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _SYMBOLS = "0123456789abcdef";
    uint8 private constant _ADDRESS_LENGTH = 20;

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        unchecked {
            uint256 length = Math.log10(value) + 1;
            string memory buffer = new string(length);
            uint256 ptr;
            /// @solidity memory-safe-assembly
            assembly {
                ptr := add(buffer, add(32, length))
            }
            while (true) {
                ptr--;
                /// @solidity memory-safe-assembly
                assembly {
                    mstore8(ptr, byte(mod(value, 10), _SYMBOLS))
                }
                value /= 10;
                if (value == 0) break;
            }
            return buffer;
        }
    }

    /**
     * @dev Converts a `int256` to its ASCII `string` decimal representation.
     */
    function toString(int256 value) internal pure returns (string memory) {
        return string(abi.encodePacked(value < 0 ? "-" : "", toString(SignedMath.abs(value))));
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        unchecked {
            return toHexString(value, Math.log256(value) + 1);
        }
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }

    /**
     * @dev Returns true if the two strings are equal.
     */
    function equal(string memory a, string memory b) internal pure returns (bool) {
        return keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library AddressUpgradeable {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

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

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/draft-IERC1822.sol)

pragma solidity ^0.8.0;

/**
 * @dev ERC1822: Universal Upgradeable Proxy Standard (UUPS) documents a method for upgradeability through a simplified
 * proxy whose upgrades are fully controlled by the current implementation.
 */
interface IERC1822Proxiable {
    /**
     * @dev Returns the storage slot that the proxiable contract assumes is being used to store the implementation
     * address.
     *
     * IMPORTANT: A proxy pointing at a proxiable contract should not be considered proxiable itself, because this risks
     * bricking a proxy that upgrades to it, by delegating to itself until out of gas. Thus it is critical that this
     * function revert if invoked through a proxy.
     */
    function proxiableUUID() external view returns (bytes32);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (proxy/ERC1967/ERC1967Upgrade.sol)

pragma solidity ^0.8.2;

import "../beacon/IBeacon.sol";
import "../../interfaces/IERC1967.sol";
import "../../interfaces/draft-IERC1822.sol";
import "../../utils/Address.sol";
import "../../utils/StorageSlot.sol";

/**
 * @dev This abstract contract provides getters and event emitting update functions for
 * https://eips.ethereum.org/EIPS/eip-1967[EIP1967] slots.
 *
 * _Available since v4.1._
 */
abstract contract ERC1967Upgrade is IERC1967 {
    // This is the keccak-256 hash of "eip1967.proxy.rollback" subtracted by 1
    bytes32 private constant _ROLLBACK_SLOT = 0x4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd9143;

    /**
     * @dev Storage slot with the address of the current implementation.
     * This is the keccak-256 hash of "eip1967.proxy.implementation" subtracted by 1, and is
     * validated in the constructor.
     */
    bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;

    /**
     * @dev Returns the current implementation address.
     */
    function _getImplementation() internal view returns (address) {
        return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 implementation slot.
     */
    function _setImplementation(address newImplementation) private {
        require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
        StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
    }

    /**
     * @dev Perform implementation upgrade
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeTo(address newImplementation) internal {
        _setImplementation(newImplementation);
        emit Upgraded(newImplementation);
    }

    /**
     * @dev Perform implementation upgrade with additional setup call.
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeToAndCall(address newImplementation, bytes memory data, bool forceCall) internal {
        _upgradeTo(newImplementation);
        if (data.length > 0 || forceCall) {
            Address.functionDelegateCall(newImplementation, data);
        }
    }

    /**
     * @dev Perform implementation upgrade with security checks for UUPS proxies, and additional setup call.
     *
     * Emits an {Upgraded} event.
     */
    function _upgradeToAndCallUUPS(address newImplementation, bytes memory data, bool forceCall) internal {
        // Upgrades from old implementations will perform a rollback test. This test requires the new
        // implementation to upgrade back to the old, non-ERC1822 compliant, implementation. Removing
        // this special case will break upgrade paths from old UUPS implementation to new ones.
        if (StorageSlot.getBooleanSlot(_ROLLBACK_SLOT).value) {
            _setImplementation(newImplementation);
        } else {
            try IERC1822Proxiable(newImplementation).proxiableUUID() returns (bytes32 slot) {
                require(slot == _IMPLEMENTATION_SLOT, "ERC1967Upgrade: unsupported proxiableUUID");
            } catch {
                revert("ERC1967Upgrade: new implementation is not UUPS");
            }
            _upgradeToAndCall(newImplementation, data, forceCall);
        }
    }

    /**
     * @dev Storage slot with the admin of the contract.
     * This is the keccak-256 hash of "eip1967.proxy.admin" subtracted by 1, and is
     * validated in the constructor.
     */
    bytes32 internal constant _ADMIN_SLOT = 0xb53127684a568b3173ae13b9f8a6016e243e63b6e8ee1178d6a717850b5d6103;

    /**
     * @dev Returns the current admin.
     */
    function _getAdmin() internal view returns (address) {
        return StorageSlot.getAddressSlot(_ADMIN_SLOT).value;
    }

    /**
     * @dev Stores a new address in the EIP1967 admin slot.
     */
    function _setAdmin(address newAdmin) private {
        require(newAdmin != address(0), "ERC1967: new admin is the zero address");
        StorageSlot.getAddressSlot(_ADMIN_SLOT).value = newAdmin;
    }

    /**
     * @dev Changes the admin of the proxy.
     *
     * Emits an {AdminChanged} event.
     */
    function _changeAdmin(address newAdmin) internal {
        emit AdminChanged(_getAdmin(), newAdmin);
        _setAdmin(newAdmin);
    }

    /**
     * @dev The storage slot of the UpgradeableBeacon contract which defines the implementation for this proxy.
     * This is bytes32(uint256(keccak256('eip1967.proxy.beacon')) - 1)) and is validated in the constructor.
     */
    bytes32 internal constant _BEACON_SLOT = 0xa3f0ad74e5423aebfd80d3ef4346578335a9a72aeaee59ff6cb3582b35133d50;

    /**
     * @dev Returns the current beacon.
     */
    function _getBeacon() internal view returns (address) {
        return StorageSlot.getAddressSlot(_BEACON_SLOT).value;
    }

    /**
     * @dev Stores a new beacon in the EIP1967 beacon slot.
     */
    function _setBeacon(address newBeacon) private {
        require(Address.isContract(newBeacon), "ERC1967: new beacon is not a contract");
        require(
            Address.isContract(IBeacon(newBeacon).implementation()),
            "ERC1967: beacon implementation is not a contract"
        );
        StorageSlot.getAddressSlot(_BEACON_SLOT).value = newBeacon;
    }

    /**
     * @dev Perform beacon upgrade with additional setup call. Note: This upgrades the address of the beacon, it does
     * not upgrade the implementation contained in the beacon (see {UpgradeableBeacon-_setImplementation} for that).
     *
     * Emits a {BeaconUpgraded} event.
     */
    function _upgradeBeaconToAndCall(address newBeacon, bytes memory data, bool forceCall) internal {
        _setBeacon(newBeacon);
        emit BeaconUpgraded(newBeacon);
        if (data.length > 0 || forceCall) {
            Address.functionDelegateCall(IBeacon(newBeacon).implementation(), data);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (access/Ownable.sol)

pragma solidity ^0.8.0;

import "../utils/ContextUpgradeable.sol";
import {Initializable} from "../proxy/utils/Initializable.sol";

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

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

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

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

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

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

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

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

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

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

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

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

/// @title IAddressManager
/// @notice Manages a mapping of (chainId, name) pairs to Ethereum addresses.
/// @custom:security-contact [email protected]
interface IAddressManager {
    /// @notice Gets the address mapped to a specific chainId-name pair.
    /// @dev Note that in production, this method shall be a pure function
    /// without any storage access.
    /// @param _chainId The chainId for which the address needs to be fetched.
    /// @param _name The name for which the address needs to be fetched.
    /// @return Address associated with the chainId-name pair.
    function getAddress(uint64 _chainId, bytes32 _name) external view returns (address);
}

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

/// @title IAddressResolver
/// @notice This contract acts as a bridge for name-to-address resolution.
/// It delegates the resolution to the AddressManager. By separating the logic,
/// we can maintain flexibility in address management without affecting the
/// resolving process.
/// @dev Note that the address manager should be changed using upgradability, there
/// is no setAddressManager() function to guarantee atomicity across all
/// contracts that are resolvers.
/// @custom:security-contact [email protected]
interface IAddressResolver {
    /// @notice Resolves a name to its address deployed on this chain.
    /// @param _name Name whose address is to be resolved.
    /// @param _allowZeroAddress If set to true, does not throw if the resolved
    /// address is `address(0)`.
    /// @return Address associated with the given name.
    function resolve(
        bytes32 _name,
        bool _allowZeroAddress
    )
        external
        view
        returns (address payable);

    /// @notice Resolves a name to its address deployed on a specified chain.
    /// @param _chainId The chainId of interest.
    /// @param _name Name whose address is to be resolved.
    /// @param _allowZeroAddress If set to true, does not throw if the resolved
    /// address is `address(0)`.
    /// @return Address associated with the given name on the specified
    /// chain.
    function resolve(
        uint64 _chainId,
        bytes32 _name,
        bool _allowZeroAddress
    )
        external
        view
        returns (address payable);
}

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

pragma solidity ^0.8.0;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    enum Rounding {
        Down, // Toward negative infinity
        Up, // Toward infinity
        Zero // Toward zero
    }

    /**
     * @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 up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (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; // Least significant 256 bits of the product
            uint256 prod1; // Most significant 256 bits of the product
            assembly {
                let mm := mulmod(x, y, not(0))
                prod0 := mul(x, y)
                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.
            require(denominator > prod1, "Math: mulDiv overflow");

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

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

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

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

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            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 (rounding == Rounding.Up && 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 down.
     *
     * 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 + (rounding == Rounding.Up && result * result < a ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 2, rounded down, of a positive value.
     * 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 + (rounding == Rounding.Up && 1 << result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 10, rounded down, of a positive value.
     * 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 + (rounding == Rounding.Up && 10 ** result < value ? 1 : 0);
        }
    }

    /**
     * @dev Return the log in base 256, rounded down, of a positive value.
     * 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 + (rounding == Rounding.Up && 1 << (result << 3) < value ? 1 : 0);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.0;

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

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

    /**
     * @dev Returns the average of two signed numbers without overflow.
     * The result is rounded towards zero.
     */
    function average(int256 a, int256 b) internal pure returns (int256) {
        // Formula from the book "Hacker's Delight"
        int256 x = (a & b) + ((a ^ b) >> 1);
        return x + (int256(uint256(x) >> 255) & (a ^ b));
    }

    /**
     * @dev Returns the absolute unsigned value of a signed value.
     */
    function abs(int256 n) internal pure returns (uint256) {
        unchecked {
            // must be unchecked in order to support `n = type(int256).min`
            return uint256(n >= 0 ? n : -n);
        }
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (proxy/beacon/IBeacon.sol)

pragma solidity ^0.8.0;

/**
 * @dev This is the interface that {BeaconProxy} expects of its beacon.
 */
interface IBeacon {
    /**
     * @dev Must return an address that can be used as a delegate call target.
     *
     * {BeaconProxy} will check that this address is a contract.
     */
    function implementation() external view returns (address);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (interfaces/IERC1967.sol)

pragma solidity ^0.8.0;

/**
 * @dev ERC-1967: Proxy Storage Slots. This interface contains the events defined in the ERC.
 *
 * _Available since v4.8.3._
 */
interface IERC1967 {
    /**
     * @dev Emitted when the implementation is upgraded.
     */
    event Upgraded(address indexed implementation);

    /**
     * @dev Emitted when the admin account has changed.
     */
    event AdminChanged(address previousAdmin, address newAdmin);

    /**
     * @dev Emitted when the beacon is changed.
     */
    event BeaconUpgraded(address indexed beacon);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     *
     * Furthermore, `isContract` will also return true if the target contract within
     * the same transaction is already scheduled for destruction by `SELFDESTRUCT`,
     * which only has an effect at the end of a transaction.
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

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

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

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

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        return functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(
        address target,
        bytes memory data,
        uint256 value,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResultFromTarget(target, success, returndata, errorMessage);
    }

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

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

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

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

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

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

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v4.9.0) (utils/StorageSlot.sol)
// This file was procedurally generated from scripts/generate/templates/StorageSlot.js.

pragma solidity ^0.8.0;

/**
 * @dev Library for reading and writing primitive types to specific storage slots.
 *
 * Storage slots are often used to avoid storage conflict when dealing with upgradeable contracts.
 * This library helps with reading and writing to such slots without the need for inline assembly.
 *
 * The functions in this library return Slot structs that contain a `value` member that can be used to read or write.
 *
 * Example usage to set ERC1967 implementation slot:
 * ```solidity
 * contract ERC1967 {
 *     bytes32 internal constant _IMPLEMENTATION_SLOT = 0x360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc;
 *
 *     function _getImplementation() internal view returns (address) {
 *         return StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value;
 *     }
 *
 *     function _setImplementation(address newImplementation) internal {
 *         require(Address.isContract(newImplementation), "ERC1967: new implementation is not a contract");
 *         StorageSlot.getAddressSlot(_IMPLEMENTATION_SLOT).value = newImplementation;
 *     }
 * }
 * ```
 *
 * _Available since v4.1 for `address`, `bool`, `bytes32`, `uint256`._
 * _Available since v4.9 for `string`, `bytes`._
 */
library StorageSlot {
    struct AddressSlot {
        address value;
    }

    struct BooleanSlot {
        bool value;
    }

    struct Bytes32Slot {
        bytes32 value;
    }

    struct Uint256Slot {
        uint256 value;
    }

    struct StringSlot {
        string value;
    }

    struct BytesSlot {
        bytes value;
    }

    /**
     * @dev Returns an `AddressSlot` with member `value` located at `slot`.
     */
    function getAddressSlot(bytes32 slot) internal pure returns (AddressSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BooleanSlot` with member `value` located at `slot`.
     */
    function getBooleanSlot(bytes32 slot) internal pure returns (BooleanSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Bytes32Slot` with member `value` located at `slot`.
     */
    function getBytes32Slot(bytes32 slot) internal pure returns (Bytes32Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `Uint256Slot` with member `value` located at `slot`.
     */
    function getUint256Slot(bytes32 slot) internal pure returns (Uint256Slot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` with member `value` located at `slot`.
     */
    function getStringSlot(bytes32 slot) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `StringSlot` representation of the string storage pointer `store`.
     */
    function getStringSlot(string storage store) internal pure returns (StringSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` with member `value` located at `slot`.
     */
    function getBytesSlot(bytes32 slot) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := slot
        }
    }

    /**
     * @dev Returns an `BytesSlot` representation of the bytes storage pointer `store`.
     */
    function getBytesSlot(bytes storage store) internal pure returns (BytesSlot storage r) {
        /// @solidity memory-safe-assembly
        assembly {
            r.slot := store.slot
        }
    }
}

{
  "remappings": [
    "@openzeppelin/contracts-upgradeable/=node_modules/@openzeppelin/contracts-upgradeable/",
    "@openzeppelin/contracts/=node_modules/@openzeppelin/contracts/",
    "solady/=node_modules/solady/",
    "forge-std/=node_modules/forge-std/",
    "ds-test/=node_modules/ds-test/src/",
    "p256-verifier/=node_modules/p256-verifier/"
  ],
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "metadata": {
    "useLiteralContent": false,
    "bytecodeHash": "ipfs",
    "appendCBOR": true
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  },
  "evmVersion": "cancun",
  "viaIR": false,
  "libraries": {}
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"name":"BTOKEN_INVALID_PARAMS","type":"error"},{"inputs":[],"name":"BTOKEN_INVALID_PARAMS","type":"error"},{"inputs":[],"name":"BTOKEN_INVALID_TO_ADDR","type":"error"},{"inputs":[],"name":"BTOKEN_INVALID_TO_ADDR","type":"error"},{"inputs":[],"name":"BTOKEN_MINT_DISALLOWED","type":"error"},{"inputs":[],"name":"FUNC_NOT_IMPLEMENTED","type":"error"},{"inputs":[],"name":"INVALID_PAUSE_STATUS","type":"error"},{"inputs":[],"name":"REENTRANT_CALL","type":"error"},{"inputs":[],"name":"RESOLVER_DENIED","type":"error"},{"inputs":[],"name":"RESOLVER_INVALID_MANAGER","type":"error"},{"inputs":[],"name":"RESOLVER_UNEXPECTED_CHAINID","type":"error"},{"inputs":[{"internalType":"uint64","name":"chainId","type":"uint64"},{"internalType":"bytes32","name":"name","type":"bytes32"}],"name":"RESOLVER_ZERO_ADDR","type":"error"},{"inputs":[],"name":"ZERO_ADDRESS","type":"error"},{"inputs":[],"name":"ZERO_VALUE","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"previousAdmin","type":"address"},{"indexed":false,"internalType":"address","name":"newAdmin","type":"address"}],"name":"AdminChanged","type":"event"},{"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":"beacon","type":"address"}],"name":"BeaconUpgraded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"migratedFrom","type":"address"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"MigratedFrom","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"migratedTo","type":"address"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"MigratedTo","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"addr","type":"address"},{"indexed":false,"internalType":"bool","name":"inbound","type":"bool"}],"name":"MigrationStatusChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferStarted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":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":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"implementation","type":"address"}],"name":"Upgraded","type":"event"},{"inputs":[],"name":"__srcDecimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"acceptOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"addressManager","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"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":"amount","type":"uint256"}],"name":"approve","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","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":"_amount","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"canonical","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_migratingAddress","type":"address"},{"internalType":"bool","name":"_migratingInbound","type":"bool"}],"name":"changeMigrationStatus","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"subtractedValue","type":"uint256"}],"name":"decreaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"impl","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"inNonReentrant","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"addedValue","type":"uint256"}],"name":"increaseAllowance","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"},{"internalType":"address","name":"_addressManager","type":"address"},{"internalType":"address","name":"_srcToken","type":"address"},{"internalType":"uint256","name":"_srcChainId","type":"uint256"},{"internalType":"uint8","name":"_decimals","type":"uint8"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"string","name":"_name","type":"string"}],"name":"init","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"isMigratingOut","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"lastUnpausedAt","outputs":[{"internalType":"uint64","name":"","type":"uint64"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"migratingAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"migratingInbound","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"},{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pendingOwner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"proxiableUUID","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint64","name":"_chainId","type":"uint64"},{"internalType":"bytes32","name":"_name","type":"bytes32"},{"internalType":"bool","name":"_allowZeroAddress","type":"bool"}],"name":"resolve","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_name","type":"bytes32"},{"internalType":"bool","name":"_allowZeroAddress","type":"bool"}],"name":"resolve","outputs":[{"internalType":"address payable","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"srcChainId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"srcToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"_interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"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":"amount","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":"amount","type":"uint256"}],"name":"transferFrom","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"}],"name":"upgradeTo","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newImplementation","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"upgradeToAndCall","outputs":[],"stateMutability":"payable","type":"function"}]

608060405260043610610233575f3560e01c806370a0823111610129578063a77f1516116100a8578063dd62ed3e1161006d578063dd62ed3e14610684578063e07baba6146106a3578063e30c3978146106e2578063f12506c1146106ff578063f2fde38b14610713575f80fd5b8063a77f1516146105e7578063a86f9d9e14610608578063a9059cbb14610627578063b8f2e0c514610646578063bb86ef9314610665575f80fd5b80638456cb59116100ee5780638456cb591461056f5780638abf6077146105835780638da5cb5b1461059757806395d89b41146105b4578063a457c2d7146105c8575f80fd5b806370a08231146104d3578063715018a61461050757806379ba50971461051b5780637cf8ed0d1461052f5780637e4746341461054f575f80fd5b806339509351116101b557806342966c681161017a57806342966c681461045757806349d12605146104765780634f1ef2861461048c57806352d1902d1461049f5780635c975abb146104b3575f80fd5b806339509351146103af5780633ab76e9f146103ce5780633eb6b8cf146104055780633f4ba83a1461042457806340c10f1914610438575f80fd5b806323b872dd116101fb57806323b872dd146102ea57806326afaadd146103095780633075db561461034d578063313ce567146103615780633659cfe61461038e575f80fd5b806301ffc9a71461023757806306fdde031461026b578063095ea7b31461028c5780630ae74548146102ab57806318160ddd146102cc575b5f80fd5b348015610242575f80fd5b5061025661025136600461222e565b610732565b60405190151581526020015b60405180910390f35b348015610276575f80fd5b5061027f6107d4565b6040516102629190612277565b348015610297575f80fd5b506102566102a63660046122bd565b610864565b3480156102b6575f80fd5b5061012f5461025690600160a01b900460ff1681565b3480156102d7575f80fd5b5060fd545b604051908152602001610262565b3480156102f5575f80fd5b506102566103043660046122e7565b61087b565b348015610314575f80fd5b5061032e61012d5461012e546001600160a01b0390911691565b604080516001600160a01b039093168352602083019190915201610262565b348015610358575f80fd5b5061025661089e565b34801561036c575f80fd5b5061012d54600160a01b900460ff165b60405160ff9091168152602001610262565b348015610399575f80fd5b506103ad6103a8366004612325565b6108b2565b005b3480156103ba575f80fd5b506102566103c93660046122bd565b610982565b3480156103d9575f80fd5b506097546103ed906001600160a01b031681565b6040516001600160a01b039091168152602001610262565b348015610410575f80fd5b506103ed61041f366004612354565b6109a3565b34801561042f575f80fd5b506103ad6109b7565b348015610443575f80fd5b506103ad6104523660046122bd565b6109cb565b348015610462575f80fd5b506103ad61047136600461239b565b610ae1565b348015610481575f80fd5b506102dc61012e5481565b6103ad61049a3660046123c6565b610c1a565b3480156104aa575f80fd5b506102dc610ccf565b3480156104be575f80fd5b5061025660c954610100900460ff1660021490565b3480156104de575f80fd5b506102dc6104ed366004612325565b6001600160a01b03165f90815260fb602052604090205490565b348015610512575f80fd5b506103ad610d80565b348015610526575f80fd5b506103ad610d91565b34801561053a575f80fd5b5061012d546103ed906001600160a01b031681565b34801561055a575f80fd5b5061012f546103ed906001600160a01b031681565b34801561057a575f80fd5b506103ad610e08565b34801561058e575f80fd5b506103ed610e1b565b3480156105a2575f80fd5b506033546001600160a01b03166103ed565b3480156105bf575f80fd5b5061027f610e29565b3480156105d3575f80fd5b506102566105e23660046122bd565b610e38565b3480156105f2575f80fd5b5061012d5461037c90600160a01b900460ff1681565b348015610613575f80fd5b506103ed610622366004612484565b610eb2565b348015610632575f80fd5b506102566106413660046122bd565b610ec5565b348015610651575f80fd5b506103ad6106603660046124ae565b610ed2565b348015610670575f80fd5b506103ad61067f36600461251d565b61104b565b34801561068f575f80fd5b506102dc61069e3660046125e0565b61120b565b3480156106ae575f80fd5b5060c9546106c99062010000900467ffffffffffffffff1681565b60405167ffffffffffffffff9091168152602001610262565b3480156106ed575f80fd5b506065546001600160a01b03166103ed565b34801561070a575f80fd5b50610256611235565b34801561071e575f80fd5b506103ad61072d366004612325565b611260565b5f6001600160e01b0319821663093e326b60e21b148061076257506001600160e01b0319821663bb86ef9360e01b145b8061077d57506001600160e01b0319821663b8f2e0c560e01b145b8061079857506001600160e01b031982166336372b0760e01b145b806107b357506001600160e01b0319821663a219a02560e01b145b806107ce57506001600160e01b031982166301ffc9a760e01b145b92915050565b606060fe80546107e390612617565b80601f016020809104026020016040519081016040528092919081815260200182805461080f90612617565b801561085a5780601f106108315761010080835404028352916020019161085a565b820191905f5260205f20905b81548152906001019060200180831161083d57829003601f168201915b5050505050905090565b5f336108718185856112d1565b5060019392505050565b5f336108888582856113f4565b61089385858561146c565b506001949350505050565b5f60026108a9611620565b60ff1614905090565b6001600160a01b037f00000000000000000000000001670000000000000000000000000000000100961630036109035760405162461bcd60e51b81526004016108fa9061264f565b60405180910390fd5b7f00000000000000000000000001670000000000000000000000000000000100966001600160a01b031661093561165f565b6001600160a01b03161461095b5760405162461bcd60e51b81526004016108fa9061269b565b6109648161167a565b604080515f8082526020820190925261097f91839190611682565b50565b5f33610871818585610994838361120b565b61099e91906126e7565b6112d1565b5f6109af8484846117ec565b949350505050565b6109bf6118df565b6109c9335f611970565b565b6109df60c954610100900460ff1660021490565b156109fd5760405163bae6e2a960e01b815260040160405180910390fd5b6002610a07611620565b60ff1603610a285760405163dfc60d8560e01b815260040160405180910390fd5b610a326002611978565b610a3a611235565b15610a585760405163270bf77560e01b815260040160405180910390fd5b61012f546001600160a01b031633819003610abf57826001600160a01b0316816001600160a01b03167fe502aa3e015149f4b76a0b2b5394e3100903c4af27c3ddc98385395d3f55252684604051610ab291815260200190565b60405180910390a3610ac8565b610ac8336119c0565b610ad28383611a3c565b50610add6001611978565b5050565b610af560c954610100900460ff1660021490565b15610b135760405163bae6e2a960e01b815260040160405180910390fd5b6002610b1d611620565b60ff1603610b3e5760405163dfc60d8560e01b815260040160405180910390fd5b610b486002611978565b610b50611235565b15610bfd5761012f546040518281526001600160a01b0390911690339082907f638edf84937fb2534b47cac985ea84d6ea4f4076315b56ea1c784d26b87e2bcb9060200160405180910390a36040516340c10f1960e01b8152336004820152602481018390526001600160a01b038216906340c10f19906044015f604051808303815f87803b158015610be1575f80fd5b505af1158015610bf3573d5f803e3d5ffd5b5050505050610c06565b610c06336119c0565b610c103382611b06565b61097f6001611978565b6001600160a01b037f0000000000000000000000000167000000000000000000000000000000010096163003610c625760405162461bcd60e51b81526004016108fa9061264f565b7f00000000000000000000000001670000000000000000000000000000000100966001600160a01b0316610c9461165f565b6001600160a01b031614610cba5760405162461bcd60e51b81526004016108fa9061269b565b610cc38261167a565b610add82826001611682565b5f306001600160a01b037f00000000000000000000000001670000000000000000000000000000000100961614610d6e5760405162461bcd60e51b815260206004820152603860248201527f555550535570677261646561626c653a206d757374206e6f742062652063616c60448201527f6c6564207468726f7567682064656c656761746563616c6c000000000000000060648201526084016108fa565b505f805160206128aa83398151915290565b610d88611c43565b6109c95f611c9d565b60655433906001600160a01b03168114610dff5760405162461bcd60e51b815260206004820152602960248201527f4f776e61626c6532537465703a2063616c6c6572206973206e6f7420746865206044820152683732bb9037bbb732b960b91b60648201526084016108fa565b61097f81611c9d565b610e10611cb6565b6109c9336001611970565b5f610e2461165f565b905090565b606060ff80546107e390612617565b5f3381610e45828661120b565b905083811015610ea55760405162461bcd60e51b815260206004820152602560248201527f45524332303a2064656372656173656420616c6c6f77616e63652062656c6f77604482015264207a65726f60d81b60648201526084016108fa565b61089382868684036112d1565b5f610ebe4684846117ec565b9392505050565b5f3361087181858561146c565b610ee660c954610100900460ff1660021490565b15610f045760405163bae6e2a960e01b815260040160405180910390fd5b6a195c98cc8c17dd985d5b1d60aa1b610f1e816001610eb2565b6001600160a01b0316336001600160a01b031614610f4f57604051630d85cccf60e11b815260040160405180910390fd5b6002610f59611620565b60ff1603610f7a5760405163dfc60d8560e01b815260040160405180910390fd5b610f846002611978565b61012f546001600160a01b038481169116148015610fb5575061012f60149054906101000a900460ff161515821515145b15610fd35760405163c118d2f360e01b815260040160405180910390fd5b61012f80546001600160a01b0385166001600160a81b03199091168117600160a01b851515908102919091179092556040805191825260208201929092527fa6b6f959792843a48d9d03d13595f2de7c86ae0ce12ef0fa759dd911b205e565910160405180910390a16110466001611978565b505050565b5f54610100900460ff161580801561106957505f54600160ff909116105b806110825750303b15801561108257505f5460ff166001145b6110e55760405162461bcd60e51b815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201526d191e481a5b9a5d1a585b1a5e995960921b60648201526084016108fa565b5f805460ff191660011790558015611106575f805461ff0019166101001790555b6111108888611d27565b61111a8a8a611d63565b61118b83838080601f0160208091040260200160405190810160405280939291908181526020018383808284375f9201919091525050604080516020601f8b0181900481028201810190925289815292508991508890819084018382808284375f92019190915250611d9d92505050565b61012d805461012e89905560ff8816600160a01b026001600160a81b03199091166001600160a01b038b161717905580156111ff575f805461ff0019169055604051600181527f7f26b83ff96e1f2b6a682f133852f6798a09c465da95921460cefb38474024989060200160405180910390a15b50505050505050505050565b6001600160a01b039182165f90815260fc6020908152604080832093909416825291909152205490565b61012f545f906001600160a01b031615801590610e2457505061012f54600160a01b900460ff161590565b611268611c43565b606580546001600160a01b0383166001600160a01b031990911681179091556112996033546001600160a01b031690565b6001600160a01b03167f38d16b8cac22d99fc7c124b9cd0de2d3fa1faef420bfe791d8c362d765e2270060405160405180910390a350565b6001600160a01b0383166113335760405162461bcd60e51b8152602060048201526024808201527f45524332303a20617070726f76652066726f6d20746865207a65726f206164646044820152637265737360e01b60648201526084016108fa565b6001600160a01b0382166113945760405162461bcd60e51b815260206004820152602260248201527f45524332303a20617070726f766520746f20746865207a65726f206164647265604482015261737360f01b60648201526084016108fa565b6001600160a01b038381165f81815260fc602090815260408083209487168084529482529182902085905590518481527f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925910160405180910390a3505050565b5f6113ff848461120b565b90505f19811461146657818110156114595760405162461bcd60e51b815260206004820152601d60248201527f45524332303a20696e73756666696369656e7420616c6c6f77616e636500000060448201526064016108fa565b61146684848484036112d1565b50505050565b6001600160a01b0383166114d05760405162461bcd60e51b815260206004820152602560248201527f45524332303a207472616e736665722066726f6d20746865207a65726f206164604482015264647265737360d81b60648201526084016108fa565b6001600160a01b0382166115325760405162461bcd60e51b815260206004820152602360248201527f45524332303a207472616e7366657220746f20746865207a65726f206164647260448201526265737360e81b60648201526084016108fa565b61153d838383611dcd565b6001600160a01b0383165f90815260fb6020526040902054818110156115b45760405162461bcd60e51b815260206004820152602660248201527f45524332303a207472616e7366657220616d6f756e7420657863656564732062604482015265616c616e636560d01b60648201526084016108fa565b6001600160a01b038085165f81815260fb602052604080822086860390559286168082529083902080548601905591517fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef906116139086815260200190565b60405180910390a3611466565b5f61162a46611e08565b1561165557507fa5054f728453d3dbe953bdc43e4d0cb97e662ea32d7958190f3dc2da31d9721b5c90565b5060c95460ff1690565b5f805160206128aa833981519152546001600160a01b031690565b61097f611c43565b7f4910fdfa16fed3260ed0e7147f7cc6da11a60208b5b9406d12a635614ffd91435460ff16156116b55761104683611e35565b826001600160a01b03166352d1902d6040518163ffffffff1660e01b8152600401602060405180830381865afa92505050801561170f575060408051601f3d908101601f1916820190925261170c91810190612706565b60015b6117725760405162461bcd60e51b815260206004820152602e60248201527f45524331393637557067726164653a206e657720696d706c656d656e7461746960448201526d6f6e206973206e6f74205555505360901b60648201526084016108fa565b5f805160206128aa83398151915281146117e05760405162461bcd60e51b815260206004820152602960248201527f45524331393637557067726164653a20756e737570706f727465642070726f786044820152681a58589b195555525160ba1b60648201526084016108fa565b50611046838383611ed0565b6097545f906001600160a01b03168061181857604051638ed88b2560e01b815260040160405180910390fd5b604051630a3dc4f360e21b815267ffffffffffffffff86166004820152602481018590526001600160a01b038216906328f713cc90604401602060405180830381865afa15801561186b573d5f803e3d5ffd5b505050506040513d601f19601f8201168201806040525081019061188f919061271d565b9150821580156118a657506001600160a01b038216155b156118d757604051632b0d65db60e01b815267ffffffffffffffff86166004820152602481018590526044016108fa565b509392505050565b6118f360c954610100900460ff1660021490565b6119105760405163bae6e2a960e01b815260040160405180910390fd5b60c9805461010069ffffffffffffffffff0019909116620100004267ffffffffffffffff1602171790556040513381527f5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa906020015b60405180910390a1565b610add611c43565b61198146611e08565b156119ac57807fa5054f728453d3dbe953bdc43e4d0cb97e662ea32d7958190f3dc2da31d9721b5d50565b60c9805460ff831660ff1990911617905550565b6a195c98cc8c17dd985d5b1d60aa1b6119e16033546001600160a01b031690565b6001600160a01b0316336001600160a01b031614158015611a1e5750611a08816001610eb2565b6001600160a01b0316336001600160a01b031614155b15610add57604051630d85cccf60e11b815260040160405180910390fd5b6001600160a01b038216611a925760405162461bcd60e51b815260206004820152601f60248201527f45524332303a206d696e7420746f20746865207a65726f20616464726573730060448201526064016108fa565b611a9d5f8383611dcd565b8060fd5f828254611aae91906126e7565b90915550506001600160a01b0382165f81815260fb60209081526040808320805486019055518481527fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a35050565b6001600160a01b038216611b665760405162461bcd60e51b815260206004820152602160248201527f45524332303a206275726e2066726f6d20746865207a65726f206164647265736044820152607360f81b60648201526084016108fa565b611b71825f83611dcd565b6001600160a01b0382165f90815260fb602052604090205481811015611be45760405162461bcd60e51b815260206004820152602260248201527f45524332303a206275726e20616d6f756e7420657863656564732062616c616e604482015261636560f01b60648201526084016108fa565b6001600160a01b0383165f81815260fb60209081526040808320868603905560fd80548790039055518581529192917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef910160405180910390a3505050565b6033546001600160a01b031633146109c95760405162461bcd60e51b815260206004820181905260248201527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e657260448201526064016108fa565b606580546001600160a01b031916905561097f81611ef4565b611cca60c954610100900460ff1660021490565b15611ce85760405163bae6e2a960e01b815260040160405180910390fd5b60c9805461ff0019166102001790556040513381527f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a25890602001611966565b6001600160a01b0382161580611d3b575080155b80611d4557504681145b15610add5760405163c118d2f360e01b815260040160405180910390fd5b806001600160a01b038116611d8b5760405163538ba4f960e01b815260040160405180910390fd5b611d9483611f45565b61104682611fa3565b5f54610100900460ff16611dc35760405162461bcd60e51b81526004016108fa90612738565b610add8282612014565b611de160c954610100900460ff1660021490565b15611dff5760405163bae6e2a960e01b815260040160405180910390fd5b61104682612053565b5f6001821480611e19575061426882145b80611e26575062aa36a782145b806107ce57506107ce8261207c565b6001600160a01b0381163b611ea25760405162461bcd60e51b815260206004820152602d60248201527f455243313936373a206e657720696d706c656d656e746174696f6e206973206e60448201526c1bdd08184818dbdb9d1c9858dd609a1b60648201526084016108fa565b5f805160206128aa83398151915280546001600160a01b0319166001600160a01b0392909216919091179055565b611ed983612093565b5f82511180611ee55750805b156110465761146683836120d2565b603380546001600160a01b038381166001600160a01b0319831681179093556040519116919082907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0905f90a35050565b5f54610100900460ff16611f6b5760405162461bcd60e51b81526004016108fa90612738565b611f736120f7565b611f916001600160a01b03821615611f8b5781611c9d565b33611c9d565b5060c9805461ff001916610100179055565b5f54610100900460ff16611fc95760405162461bcd60e51b81526004016108fa90612738565b67ffffffffffffffff461115611ff25760405163a12e8fa960e01b815260040160405180910390fd5b609780546001600160a01b0319166001600160a01b0392909216919091179055565b5f54610100900460ff1661203a5760405162461bcd60e51b81526004016108fa90612738565b60fe61204683826127ce565b5060ff61104682826127ce565b306001600160a01b0382160361097f57604051630c292c9d60e21b815260040160405180910390fd5b5f617e2c82101580156107ce575050617e90101590565b61209c81611e35565b6040516001600160a01b038216907fbc7cd75a20ee27fd9adebab32041f755214dbc6bffa90cc0225b39da2e5c2d3b905f90a250565b6060610ebe83836040518060600160405280602781526020016128ca6027913961211d565b5f54610100900460ff166109c95760405162461bcd60e51b81526004016108fa90612738565b60605f80856001600160a01b031685604051612139919061288e565b5f60405180830381855af49150503d805f8114612171576040519150601f19603f3d011682016040523d82523d5f602084013e612176565b606091505b509150915061218786838387612191565b9695505050505050565b606083156121ff5782515f036121f8576001600160a01b0385163b6121f85760405162461bcd60e51b815260206004820152601d60248201527f416464726573733a2063616c6c20746f206e6f6e2d636f6e747261637400000060448201526064016108fa565b50816109af565b6109af83838151156122145781518083602001fd5b8060405162461bcd60e51b81526004016108fa9190612277565b5f6020828403121561223e575f80fd5b81356001600160e01b031981168114610ebe575f80fd5b5f5b8381101561226f578181015183820152602001612257565b50505f910152565b602081525f8251806020840152612295816040850160208701612255565b601f01601f19169190910160400192915050565b6001600160a01b038116811461097f575f80fd5b5f80604083850312156122ce575f80fd5b82356122d9816122a9565b946020939093013593505050565b5f805f606084860312156122f9575f80fd5b8335612304816122a9565b92506020840135612314816122a9565b929592945050506040919091013590565b5f60208284031215612335575f80fd5b8135610ebe816122a9565b8035801515811461234f575f80fd5b919050565b5f805f60608486031215612366575f80fd5b833567ffffffffffffffff8116811461237d575f80fd5b92506020840135915061239260408501612340565b90509250925092565b5f602082840312156123ab575f80fd5b5035919050565b634e487b7160e01b5f52604160045260245ffd5b5f80604083850312156123d7575f80fd5b82356123e2816122a9565b9150602083013567ffffffffffffffff808211156123fe575f80fd5b818501915085601f830112612411575f80fd5b813581811115612423576124236123b2565b604051601f8201601f19908116603f0116810190838211818310171561244b5761244b6123b2565b81604052828152886020848701011115612463575f80fd5b826020860160208301375f6020848301015280955050505050509250929050565b5f8060408385031215612495575f80fd5b823591506124a560208401612340565b90509250929050565b5f80604083850312156124bf575f80fd5b82356124ca816122a9565b91506124a560208401612340565b5f8083601f8401126124e8575f80fd5b50813567ffffffffffffffff8111156124ff575f80fd5b602083019150836020828501011115612516575f80fd5b9250929050565b5f805f805f805f805f60e08a8c031215612535575f80fd5b8935612540816122a9565b985060208a0135612550816122a9565b975060408a0135612560816122a9565b965060608a0135955060808a013560ff8116811461257c575f80fd5b945060a08a013567ffffffffffffffff80821115612598575f80fd5b6125a48d838e016124d8565b909650945060c08c01359150808211156125bc575f80fd5b506125c98c828d016124d8565b915080935050809150509295985092959850929598565b5f80604083850312156125f1575f80fd5b82356125fc816122a9565b9150602083013561260c816122a9565b809150509250929050565b600181811c9082168061262b57607f821691505b60208210810361264957634e487b7160e01b5f52602260045260245ffd5b50919050565b6020808252602c908201527f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060408201526b19195b1959d85d1958d85b1b60a21b606082015260800190565b6020808252602c908201527f46756e6374696f6e206d7573742062652063616c6c6564207468726f7567682060408201526b6163746976652070726f787960a01b606082015260800190565b808201808211156107ce57634e487b7160e01b5f52601160045260245ffd5b5f60208284031215612716575f80fd5b5051919050565b5f6020828403121561272d575f80fd5b8151610ebe816122a9565b6020808252602b908201527f496e697469616c697a61626c653a20636f6e7472616374206973206e6f74206960408201526a6e697469616c697a696e6760a81b606082015260800190565b601f82111561104657805f5260205f20601f840160051c810160208510156127a85750805b601f840160051c820191505b818110156127c7575f81556001016127b4565b5050505050565b815167ffffffffffffffff8111156127e8576127e86123b2565b6127fc816127f68454612617565b84612783565b602080601f83116001811461282f575f84156128185750858301515b5f19600386901b1c1916600185901b178555612886565b5f85815260208120601f198616915b8281101561285d5788860151825594840194600190910190840161283e565b508582101561287a57878501515f19600388901b60f8161c191681555b505060018460011b0185555b505050505050565b5f825161289f818460208701612255565b919091019291505056fe360894a13ba1a3210667c828492db98dca3e2076cc3735a920a3ca505d382bbc416464726573733a206c6f772d6c6576656c2064656c65676174652063616c6c206661696c6564a2646970667358221220e71efa9d5f866b742d3a26addbacfbfd103eaf91f295f46862cb9770e13bc53764736f6c63430008180033

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

548:5822:6:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;5423:512;;;;;;;;;;-1:-1:-1;5423:512:6;;;;;:::i;:::-;;:::i;:::-;;;470:14:28;;463:22;445:41;;433:2;418:18;5423:512:6;;;;;;;;2516:98:12;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;4802:197::-;;;;;;;;;;-1:-1:-1;4802:197:12;;;;;:::i;:::-;;:::i;1094:28:6:-;;;;;;;;;;-1:-1:-1;1094:28:6;;;;-1:-1:-1;;;1094:28:6;;;;;;3613:106:12;;;;;;;;;;-1:-1:-1;3700:12:12;;3613:106;;;1755:25:28;;;1743:2;1728:18;3613:106:12;1609:177:28;5561:256:12;;;;;;;;;;-1:-1:-1;5561:256:12;;;;;:::i;:::-;;:::i;4938:110:6:-;;;;;;;;;;;;5019:8;;5029:10;;-1:-1:-1;;;;;5019:8:6;;;;4938:110;;;;;-1:-1:-1;;;;;2444:32:28;;;2426:51;;2508:2;2493:18;;2486:34;;;;2399:18;4938:110:6;2252:274:28;3672:106:1;;;;;;;;;;;;;:::i;5181:96:6:-;;;;;;;;;;-1:-1:-1;5256:13:6;;-1:-1:-1;;;5256:13:6;;;;5181:96;;;2703:4:28;2691:17;;;2673:36;;2661:2;2646:18;5181:96:6;2531:184:28;3143:195:22;;;;;;;;;;-1:-1:-1;3143:195:22;;;;;:::i;:::-;;:::i;:::-;;6212:234:12;;;;;;;;;;-1:-1:-1;6212:234:12;;;;;:::i;:::-;;:::i;465:29:0:-;;;;;;;;;;-1:-1:-1;465:29:0;;;;-1:-1:-1;;;;;465:29:0;;;;;;-1:-1:-1;;;;;3136:32:28;;;3118:51;;3106:2;3091:18;465:29:0;2972:203:28;1902:264:0;;;;;;;;;;-1:-1:-1;1902:264:0;;;;;:::i;:::-;;:::i;3128:212:1:-;;;;;;;;;;;;;:::i;3564:569:6:-;;;;;;;;;;-1:-1:-1;3564:569:6;;;;;:::i;:::-;;:::i;4176:719::-;;;;;;;;;;-1:-1:-1;4176:719:6;;;;;:::i;:::-;;:::i;846:25::-;;;;;;;;;;;;;;;;3657:220:22;;;;;;:::i;:::-;;:::i;2762:131::-;;;;;;;;;;;;;:::i;3576:88:1:-;;;;;;;;;;;;3639:8;;;;;:17;:8;534:1;3639:17;;3576:88;3777:125:12;;;;;;;;;;-1:-1:-1;3777:125:12;;;;;:::i;:::-;-1:-1:-1;;;;;3877:18:12;3851:7;3877:18;;;:9;:18;;;;;;;3777:125;2085:101:10;;;;;;;;;;;;;:::i;2031:212:9:-;;;;;;;;;;;;;:::i;757:23:6:-;;;;;;;;;;-1:-1:-1;757:23:6;;;;-1:-1:-1;;;;;757:23:6;;;977:31;;;;;;;;;;-1:-1:-1;977:31:6;;;;-1:-1:-1;;;;;977:31:6;;;2873:207:1;;;;;;;;;;;;;:::i;3348:92::-;;;;;;;;;;;;;:::i;1462:85:10:-;;;;;;;;;;-1:-1:-1;1534:6:10;;-1:-1:-1;;;;;1534:6:10;1462:85;;2727:102:12;;;;;;;;;;;;;:::i;6933:427::-;;;;;;;;;;-1:-1:-1;6933:427:12;;;;;:::i;:::-;;:::i;789:26:6:-;;;;;;;;;;-1:-1:-1;789:26:6;;;;-1:-1:-1;;;789:26:6;;;;;;1605:251:0;;;;;;;;;;-1:-1:-1;1605:251:0;;;;;:::i;:::-;;:::i;4098:189:12:-;;;;;;;;;;-1:-1:-1;4098:189:12;;;;;:::i;:::-;;:::i;2966:555:6:-;;;;;;;;;;-1:-1:-1;2966:555:6;;;;;:::i;:::-;;:::i;2284:629::-;;;;;;;;;;-1:-1:-1;2284:629:6;;;;;:::i;:::-;;:::i;4345:149:12:-;;;;;;;;;;-1:-1:-1;4345:149:12;;;;;:::i;:::-;;:::i;1131:28:1:-;;;;;;;;;;-1:-1:-1;1131:28:1;;;;;;;;;;;;;;8427:18:28;8415:31;;;8397:50;;8385:2;8370:18;1131:28:1;8253:200:28;1144:99:9;;;;;;;;;;-1:-1:-1;1223:13:9;;-1:-1:-1;;;;;1223:13:9;1144:99;;5285:130:6;;;;;;;;;;;;;:::i;1436:178:9:-;;;;;;;;;;-1:-1:-1;1436:178:9;;;;;:::i;:::-;;:::i;5423:512:6:-;5492:4;-1:-1:-1;;;;;;5516:47:6;;-1:-1:-1;;;5516:47:6;;:124;;-1:-1:-1;;;;;;;5580:60:6;;-1:-1:-1;;;5580:60:6;5516:124;:198;;;-1:-1:-1;;;;;;;5657:57:6;;-1:-1:-1;;;5657:57:6;5516:198;:266;;;-1:-1:-1;;;;;;;5731:51:6;;-1:-1:-1;;;5731:51:6;5516:266;:342;;;-1:-1:-1;;;;;;;5799:59:6;;-1:-1:-1;;;5799:59:6;5516:342;:411;;;-1:-1:-1;;;;;;;5875:52:6;;-1:-1:-1;;;5875:52:6;5516:411;5509:418;5423:512;-1:-1:-1;;5423:512:6:o;2516:98:12:-;2570:13;2602:5;2595:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2516:98;:::o;4802:197::-;4885:4;965:10:16;4939:32:12;965:10:16;4955:7:12;4964:6;4939:8;:32::i;:::-;-1:-1:-1;4988:4:12;;4802:197;-1:-1:-1;;;4802:197:12:o;5561:256::-;5658:4;965:10:16;5714:38:12;5730:4;965:10:16;5745:6:12;5714:15;:38::i;:::-;5762:27;5772:4;5778:2;5782:6;5762:9;:27::i;:::-;-1:-1:-1;5806:4:12;;5561:256;-1:-1:-1;;;;5561:256:12:o;3672:106:1:-;3719:4;534:1;3743:18;:16;:18::i;:::-;:27;;;3736:34;;3672:106;:::o;3143:195:22:-;-1:-1:-1;;;;;1654:6:22;1637:23;1645:4;1637:23;1629:80;;;;-1:-1:-1;;;1629:80:22;;;;;;;:::i;:::-;;;;;;;;;1751:6;-1:-1:-1;;;;;1727:30:22;:20;:18;:20::i;:::-;-1:-1:-1;;;;;1727:30:22;;1719:87;;;;-1:-1:-1;;;1719:87:22;;;;;;;:::i;:::-;3224:36:::1;3242:17;3224;:36::i;:::-;3311:12;::::0;;3321:1:::1;3311:12:::0;;;::::1;::::0;::::1;::::0;;;3270:61:::1;::::0;3292:17;;3311:12;3270:21:::1;:61::i;:::-;3143:195:::0;:::o;6212:234:12:-;6300:4;965:10:16;6354:64:12;965:10:16;6370:7:12;6407:10;6379:25;965:10:16;6370:7:12;6379:9;:25::i;:::-;:38;;;;:::i;:::-;6354:8;:64::i;1902:264:0:-;2074:15;2114:44;2123:8;2133:5;2140:17;2114:8;:44::i;:::-;2107:51;1902:264;-1:-1:-1;;;;1902:264:0:o;3128:212:1:-;3173:10;:8;:10::i;:::-;3298:34;3314:10;3326:5;3298:15;:34::i;:::-;3128:212::o;3564:569:6:-;2417:8:1;3639;;;;;:17;:8;534:1;3639:17;;3576:88;2417:8;2413:43;;;2434:22;;-1:-1:-1;;;2434:22:1;;;;;;;;;;;2413:43;534:1:::1;2121:18;:16;:18::i;:::-;:27;;::::0;2117:56:::1;;2157:16;;-1:-1:-1::0;;;2157:16:1::1;;;;;;;;;;;2117:56;2184:24;534:1;2184:17;:24::i;:::-;3719:16:6::2;:14;:16::i;:::-;3715:53;;;3744:24;;-1:-1:-1::0;;;3744:24:6::2;;;;;;;;;;;3715:53;3809:16;::::0;-1:-1:-1;;;;;3809:16:6::2;3840:10;:31:::0;;;3836:253:::2;;3959:8;-1:-1:-1::0;;;;;3927:50:6::2;3940:17;-1:-1:-1::0;;;;;3927:50:6::2;;3969:7;3927:50;;;;1755:25:28::0;;1743:2;1728:18;;1609:177;3927:50:6::2;;;;;;;;3836:253;;;4046:31;4066:10;4046:19;:31::i;:::-;4101:24;4107:8;4117:7;4101:5;:24::i;:::-;3649:484;2231:25:1::1;493:1;2231:17;:25::i;:::-;3564:569:6::0;;:::o;4176:719::-;2417:8:1;3639;;;;;:17;:8;534:1;3639:17;;3576:88;2417:8;2413:43;;;2434:22;;-1:-1:-1;;;2434:22:1;;;;;;;;;;;2413:43;534:1:::1;2121:18;:16;:18::i;:::-;:27;;::::0;2117:56:::1;;2157:16;;-1:-1:-1::0;;;2157:16:1::1;;;;;;;;;;;2117:56;2184:24;534:1;2184:17;:24::i;:::-;4258:16:6::2;:14;:16::i;:::-;4254:595;;;4354:16;::::0;4390:50:::2;::::0;1755:25:28;;;-1:-1:-1;;;;;4354:16:6;;::::2;::::0;4420:10:::2;::::0;4354:16;;4390:50:::2;::::0;1743:2:28;1728:18;4390:50:6::2;;;;;;;4525:58;::::0;-1:-1:-1;;;4525:58:6;;4563:10:::2;4525:58;::::0;::::2;2426:51:28::0;2493:18;;;2486:34;;;-1:-1:-1;;;;;4525:37:6;::::2;::::0;::::2;::::0;2399:18:28;;4525:58:6::2;;;;;;;;;;;;;;;;;::::0;::::2;;;;;;;;;;;;::::0;::::2;;;;;;;;;4276:319;4254:595;;;4806:31;4826:10;4806:19;:31::i;:::-;4861:26;4867:10;4879:7;4861:5;:26::i;:::-;2231:25:1::1;493:1;2231:17;:25::i;3657:220:22:-:0;-1:-1:-1;;;;;1654:6:22;1637:23;1645:4;1637:23;1629:80;;;;-1:-1:-1;;;1629:80:22;;;;;;;:::i;:::-;1751:6;-1:-1:-1;;;;;1727:30:22;:20;:18;:20::i;:::-;-1:-1:-1;;;;;1727:30:22;;1719:87;;;;-1:-1:-1;;;1719:87:22;;;;;;;:::i;:::-;3772:36:::1;3790:17;3772;:36::i;:::-;3818:52;3840:17;3859:4;3865;3818:21;:52::i;2762:131::-:0;2840:7;2080:4;-1:-1:-1;;;;;2089:6:22;2072:23;;2064:92;;;;-1:-1:-1;;;2064:92:22;;10098:2:28;2064:92:22;;;10080:21:28;10137:2;10117:18;;;10110:30;10176:34;10156:18;;;10149:62;10247:26;10227:18;;;10220:54;10291:19;;2064:92:22;9896:420:28;2064:92:22;-1:-1:-1;;;;;;;;;;;;2762:131:22;:::o;2085:101:10:-;1355:13;:11;:13::i;:::-;2149:30:::1;2176:1;2149:18;:30::i;2031:212:9:-:0;1223:13;;965:10:16;;-1:-1:-1;;;;;1223:13:9;2130:24;;2122:78;;;;-1:-1:-1;;;2122:78:9;;10523:2:28;2122:78:9;;;10505:21:28;10562:2;10542:18;;;10535:30;10601:34;10581:18;;;10574:62;-1:-1:-1;;;10652:18:28;;;10645:39;10701:19;;2122:78:9;10321:405:28;2122:78:9;2210:26;2229:6;2210:18;:26::i;2873:207:1:-;2916:8;:6;:8::i;:::-;3039:33;3055:10;3067:4;3039:15;:33::i;3348:92::-;3385:7;3412:20;:18;:20::i;:::-;3405:27;;3348:92;:::o;2727:102:12:-;2783:13;2815:7;2808:14;;;;;:::i;6933:427::-;7026:4;965:10:16;7026:4:12;7107:25;965:10:16;7124:7:12;7107:9;:25::i;:::-;7080:52;;7170:15;7150:16;:35;;7142:85;;;;-1:-1:-1;;;7142:85:12;;10933:2:28;7142:85:12;;;10915:21:28;10972:2;10952:18;;;10945:30;11011:34;10991:18;;;10984:62;-1:-1:-1;;;11062:18:28;;;11055:35;11107:19;;7142:85:12;10731:401:28;7142:85:12;7261:60;7270:5;7277:7;7305:15;7286:16;:34;7261:8;:60::i;1605:251:0:-;1751:15;1791:57;1807:13;1823:5;1830:17;1791:8;:57::i;:::-;1784:64;1605:251;-1:-1:-1;;;1605:251:0:o;4098:189:12:-;4177:4;965:10:16;4231:28:12;965:10:16;4248:2:12;4252:6;4231:9;:28::i;2966:555:6:-;2417:8:1;3639;;;;;:17;:8;534:1;3639:17;;3576:88;2417:8;2413:43;;;2434:22;;-1:-1:-1;;;2434:22:1;;;;;;;;;;;2413:43;-1:-1:-1;;;922:20:0::1;930:5;937:4;922:7;:20::i;:::-;-1:-1:-1::0;;;;;908:34:0::1;:10;-1:-1:-1::0;;;;;908:34:0::1;;904:64;;951:17;;-1:-1:-1::0;;;951:17:0::1;;;;;;;;;;;904:64;534:1:1::2;2121:18;:16;:18::i;:::-;:27;;::::0;2117:56:::2;;2157:16;;-1:-1:-1::0;;;2157:16:1::2;;;;;;;;;;;2117:56;2184:24;534:1;2184:17;:24::i;:::-;3226:16:6::3;::::0;-1:-1:-1;;;;;3205:37:6;;::::3;3226:16:::0;::::3;3205:37;:78:::0;::::3;;;;3267:16;;;;;;;;;;;3246:37;;:17;:37;;;3205:78;3201:141;;;3307:23;;-1:-1:-1::0;;;3307:23:6::3;;;;;;;;;;;3201:141;3354:16;:36:::0;;-1:-1:-1;;;;;3354:36:6;::::3;-1:-1:-1::0;;;;;;3401:36:6;;;;;-1:-1:-1;;;3401:36:6;::::3;;::::0;;::::3;::::0;;;::::3;::::0;;;3453:60:::3;::::0;;11305:51:28;;;11387:2;11372:18;;11365:50;;;;3453:60:6::3;::::0;11278:18:28;3453:60:6::3;;;;;;;2231:25:1::2;493:1;2231:17;:25::i;:::-;2467:1:::1;2966:555:6::0;;:::o;2284:629::-;3279:19:11;3302:13;;;;;;3301:14;;3347:34;;;;-1:-1:-1;3365:12:11;;3380:1;3365:12;;;;:16;3347:34;3346:108;;;-1:-1:-1;3426:4:11;1713:19:15;:23;;;3387:66:11;;-1:-1:-1;3436:12:11;;;;;:17;3387:66;3325:201;;;;-1:-1:-1;;;3325:201:11;;11628:2:28;3325:201:11;;;11610:21:28;11667:2;11647:18;;;11640:30;11706:34;11686:18;;;11679:62;-1:-1:-1;;;11757:18:28;;;11750:44;11811:19;;3325:201:11;11426:410:28;3325:201:11;3536:12;:16;;-1:-1:-1;;3536:16:11;3551:1;3536:16;;;3562:65;;;;3596:13;:20;;-1:-1:-1;;3596:20:11;;;;;3562:65;2620:54:6::1;2651:9;2662:11;2620:30;:54::i;:::-;2685:41;2702:6;2710:15;2685:16;:41::i;:::-;2737:28;2750:5;;2737:28;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;::::0;;;;-1:-1:-1;;2737:28:6::1;::::0;;::::1;;::::0;::::1;::::0;;::::1;::::0;::::1;::::0;;;;;;;;;;;-1:-1:-1;2757:7:6;;-1:-1:-1;2757:7:6;;;;2737:28;::::1;2757:7:::0;;;;2737:28;::::1;;::::0;::::1;::::0;;;;-1:-1:-1;2737:12:6::1;::::0;-1:-1:-1;;;2737:28:6:i:1;:::-;2814:8;:20:::0;;2845:10:::1;:24:::0;;;2880:25:::1;::::0;::::1;-1:-1:-1::0;;;2880:25:6::1;-1:-1:-1::0;;;;;;2880:25:6;;;-1:-1:-1;;;;;2814:20:6;::::1;2880:25:::0;::::1;::::0;;3647:99:11;;;;3697:5;3681:21;;-1:-1:-1;;3681:21:11;;;3721:14;;-1:-1:-1;2673:36:28;;3721:14:11;;2661:2:28;2646:18;3721:14:11;;;;;;;3647:99;3269:483;2284:629:6;;;;;;;;;:::o;4345:149:12:-;-1:-1:-1;;;;;4460:18:12;;;4434:7;4460:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;4345:149::o;5285:130:6:-;5356:16;;5332:4;;-1:-1:-1;;;;;5356:16:6;:30;;;;:51;;-1:-1:-1;;5391:16:6;;-1:-1:-1;;;5391:16:6;;;;5390:17;;5285:130::o;1436:178:9:-;1355:13:10;:11;:13::i;:::-;1525::9::1;:24:::0;;-1:-1:-1;;;;;1525:24:9;::::1;-1:-1:-1::0;;;;;;1525:24:9;;::::1;::::0;::::1;::::0;;;1589:7:::1;1534:6:10::0;;-1:-1:-1;;;;;1534:6:10;;1462:85;1589:7:9::1;-1:-1:-1::0;;;;;1564:43:9::1;;;;;;;;;;;1436:178:::0;:::o;10815:340:12:-;-1:-1:-1;;;;;10916:19:12;;10908:68;;;;-1:-1:-1;;;10908:68:12;;12242:2:28;10908:68:12;;;12224:21:28;12281:2;12261:18;;;12254:30;12320:34;12300:18;;;12293:62;-1:-1:-1;;;12371:18:28;;;12364:34;12415:19;;10908:68:12;12040:400:28;10908:68:12;-1:-1:-1;;;;;10994:21:12;;10986:68;;;;-1:-1:-1;;;10986:68:12;;12647:2:28;10986:68:12;;;12629:21:28;12686:2;12666:18;;;12659:30;12725:34;12705:18;;;12698:62;-1:-1:-1;;;12776:18:28;;;12769:32;12818:19;;10986:68:12;12445:398:28;10986:68:12;-1:-1:-1;;;;;11065:18:12;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;11116:32;;1755:25:28;;;11116:32:12;;1728:18:28;11116:32:12;;;;;;;10815:340;;;:::o;11436:411::-;11536:24;11563:25;11573:5;11580:7;11563:9;:25::i;:::-;11536:52;;-1:-1:-1;;11602:16:12;:37;11598:243;;11683:6;11663:16;:26;;11655:68;;;;-1:-1:-1;;;11655:68:12;;13050:2:28;11655:68:12;;;13032:21:28;13089:2;13069:18;;;13062:30;13128:31;13108:18;;;13101:59;13177:18;;11655:68:12;12848:353:28;11655:68:12;11765:51;11774:5;11781:7;11809:6;11790:16;:25;11765:8;:51::i;:::-;11526:321;11436:411;;;:::o;7814:788::-;-1:-1:-1;;;;;7910:18:12;;7902:68;;;;-1:-1:-1;;;7902:68:12;;13408:2:28;7902:68:12;;;13390:21:28;13447:2;13427:18;;;13420:30;13486:34;13466:18;;;13459:62;-1:-1:-1;;;13537:18:28;;;13530:35;13582:19;;7902:68:12;13206:401:28;7902:68:12;-1:-1:-1;;;;;7988:16:12;;7980:64;;;;-1:-1:-1;;;7980:64:12;;13814:2:28;7980:64:12;;;13796:21:28;13853:2;13833:18;;;13826:30;13892:34;13872:18;;;13865:62;-1:-1:-1;;;13943:18:28;;;13936:33;13986:19;;7980:64:12;13612:399:28;7980:64:12;8055:38;8076:4;8082:2;8086:6;8055:20;:38::i;:::-;-1:-1:-1;;;;;8126:15:12;;8104:19;8126:15;;;:9;:15;;;;;;8159:21;;;;8151:72;;;;-1:-1:-1;;;8151:72:12;;14218:2:28;8151:72:12;;;14200:21:28;14257:2;14237:18;;;14230:30;14296:34;14276:18;;;14269:62;-1:-1:-1;;;14347:18:28;;;14340:36;14393:19;;8151:72:12;14016:402:28;8151:72:12;-1:-1:-1;;;;;8257:15:12;;;;;;;:9;:15;;;;;;8275:20;;;8257:38;;8472:13;;;;;;;;;;:23;;;;;;8521:26;;;;;;8289:6;1755:25:28;;1743:2;1728:18;;1609:177;8521:26:12;;;;;;;;8558:37;2966:555:6;5280:296:1;5339:14;5370:43;5399:13;5370:28;:43::i;:::-;5366:203;;;-1:-1:-1;5476:13:1;5470:20;2762:131:22;:::o;5366:203:1:-;-1:-1:-1;5548:9:1;;;;5280:296;:::o;1175:140:20:-;-1:-1:-1;;;;;;;;;;;1254:54:20;-1:-1:-1;;;;;1254:54:20;;1175:140::o;4768:75:1:-;1355:13:10;:11;:13::i;2494:922:20:-;689:66;2910:48;;;2906:504;;;2974:37;2993:17;2974:18;:37::i;2906:504::-;3064:17;-1:-1:-1;;;;;3046:50:20;;:52;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;3046:52:20;;;;;;;;-1:-1:-1;;3046:52:20;;;;;;;;;;;;:::i;:::-;;;3042:291;;3262:56;;-1:-1:-1;;;3262:56:20;;14814:2:28;3262:56:20;;;14796:21:28;14853:2;14833:18;;;14826:30;14892:34;14872:18;;;14865:62;-1:-1:-1;;;14943:18:28;;;14936:44;14997:19;;3262:56:20;14612:410:28;3042:291:20;-1:-1:-1;;;;;;;;;;;3148:28:20;;3140:82;;;;-1:-1:-1;;;3140:82:20;;15229:2:28;3140:82:20;;;15211:21:28;15268:2;15248:18;;;15241:30;15307:34;15287:18;;;15280:62;-1:-1:-1;;;15358:18:28;;;15351:39;15407:19;;3140:82:20;15027:405:28;3140:82:20;3099:138;3346:53;3364:17;3383:4;3389:9;3346:17;:53::i;2951:541:0:-;3173:14;;3108:21;;-1:-1:-1;;;;;3173:14:0;;3198:68;;3240:26;;-1:-1:-1;;;3240:26:0;;;;;;;;;;;3198:68;3295:60;;-1:-1:-1;;;3295:60:0;;15639:18:28;15627:31;;3295:60:0;;;15609:50:28;15675:18;;;15668:34;;;-1:-1:-1;;;;;3295:43:0;;;;;15582:18:28;;3295:60:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3279:77;;3374:17;3373:18;:41;;;;-1:-1:-1;;;;;;3395:19:0;;;3373:41;3369:116;;;3438:35;;-1:-1:-1;;;3438:35:0;;15639:18:28;15627:31;;3438:35:0;;;15609:50:28;15675:18;;;15668:34;;;15582:18;;3438:35:0;15437:271:28;3369:116:0;3136:356;2951:541;;;;;:::o;4597:163:1:-;2310:8;3639;;;;;:17;:8;534:1;3639:17;;3576:88;2310:8;2305:44;;2327:22;;-1:-1:-1;;;2327:22:1;;;;;;;;;;;2305:44;4648:8:::1;:17:::0;;::::1;-1:-1:-1::0;;4676:40:1;;;;4700:15:::1;4676:40;;;::::0;;;;4732:20:::1;::::0;4741:10:::1;3118:51:28::0;;4732:20:1::1;::::0;3106:2:28;3091:18;4732:20:1::1;;;;;;;;4597:163::o:0;4851:70::-;1355:13:10;:11;:13::i;4961:280:1:-;5036:43;5065:13;5036:28;:43::i;:::-;5032:202;;;5146:8;5131:13;5124:31;3143:195:22;:::o;5032:202:1:-;5202:9;:20;;;;;-1:-1:-1;;5202:20:1;;;;;;4961:280;:::o;6243:124:6:-;-1:-1:-1;;;1889:7:1;1534:6:10;;-1:-1:-1;;;;;1534:6:10;;1462:85;1889:7:1;-1:-1:-1;;;;;1875:21:1;:10;-1:-1:-1;;;;;1875:21:1;;;:59;;;;;1914:20;1922:5;1929:4;1914:7;:20::i;:::-;-1:-1:-1;;;;;1900:34:1;:10;-1:-1:-1;;;;;1900:34:1;;;1875:59;1871:89;;;1943:17;;-1:-1:-1;;;1943:17:1;;;;;;;;;;;8878:535:12;-1:-1:-1;;;;;8961:21:12;;8953:65;;;;-1:-1:-1;;;8953:65:12;;16171:2:28;8953:65:12;;;16153:21:28;16210:2;16190:18;;;16183:30;16249:33;16229:18;;;16222:61;16300:18;;8953:65:12;15969:355:28;8953:65:12;9029:49;9058:1;9062:7;9071:6;9029:20;:49::i;:::-;9105:6;9089:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;9257:18:12;;;;;;:9;:18;;;;;;;;:28;;;;;;9310:37;1755:25:28;;;9310:37:12;;1728:18:28;9310:37:12;;;;;;;3564:569:6;;:::o;9733:659:12:-;-1:-1:-1;;;;;9816:21:12;;9808:67;;;;-1:-1:-1;;;9808:67:12;;16531:2:28;9808:67:12;;;16513:21:28;16570:2;16550:18;;;16543:30;16609:34;16589:18;;;16582:62;-1:-1:-1;;;16660:18:28;;;16653:31;16701:19;;9808:67:12;16329:397:28;9808:67:12;9886:49;9907:7;9924:1;9928:6;9886:20;:49::i;:::-;-1:-1:-1;;;;;9971:18:12;;9946:22;9971:18;;;:9;:18;;;;;;10007:24;;;;9999:71;;;;-1:-1:-1;;;9999:71:12;;16933:2:28;9999:71:12;;;16915:21:28;16972:2;16952:18;;;16945:30;17011:34;16991:18;;;16984:62;-1:-1:-1;;;17062:18:28;;;17055:32;17104:19;;9999:71:12;16731:398:28;9999:71:12;-1:-1:-1;;;;;10104:18:12;;;;;;:9;:18;;;;;;;;10125:23;;;10104:44;;10241:12;:22;;;;;;;10289:37;1755:25:28;;;10104:18:12;;;10289:37;;1728:18:28;10289:37:12;;;;;;;2467:1:1::1;2966:555:6::0;;:::o;1620:130:10:-;1534:6;;-1:-1:-1;;;;;1534:6:10;965:10:16;1683:23:10;1675:68;;;;-1:-1:-1;;;1675:68:10;;17336:2:28;1675:68:10;;;17318:21:28;;;17355:18;;;17348:30;17414:34;17394:18;;;17387:62;17466:18;;1675:68:10;17134:356:28;1798:153:9;1887:13;1880:20;;-1:-1:-1;;;;;;1880:20:9;;;1910:34;1935:8;1910:24;:34::i;4479:110:1:-;2417:8;3639;;;;;:17;:8;534:1;3639:17;;3576:88;2417:8;2413:43;;;2434:22;;-1:-1:-1;;;2434:22:1;;;;;;;;;;;2413:43;4531:8:::1;:16:::0;;-1:-1:-1;;4531:16:1::1;::::0;::::1;::::0;;4563:18:::1;::::0;4570:10:::1;3118:51:28::0;;4563:18:1::1;::::0;3106:2:28;3091:18;4563::1::1;2972:203:28::0;298:234:8;-1:-1:-1;;;;;391:23:8;;;;:43;;-1:-1:-1;418:16:8;;391:43;:75;;;;453:13;438:11;:28;391:75;387:138;;;490:23;;-1:-1:-1;;;490:23:8;;;;;;;;;;;4005:246:1;4136:15;-1:-1:-1;;;;;2535:19:1;;2531:46;;2563:14;;-1:-1:-1;;;2563:14:1;;;;;;;;;;;2531:46;4169:24:::1;4186:6;4169:16;:24::i;:::-;4204:39;4227:15;4204:22;:39::i;2139:147:12:-:0;5374:13:11;;;;;;;5366:69;;;;-1:-1:-1;;;5366:69:11;;;;;;;:::i;:::-;2241:38:12::1;2264:5;2271:7;2241:22;:38::i;5943:292:6:-:0;2417:8:1;3639;;;;;:17;:8;534:1;3639:17;;3576:88;2417:8;2413:43;;;2434:22;;-1:-1:-1;;;2434:22:1;;;;;;;;;;;2413:43;6127:35:6::1;6158:3;6127:30;:35::i;2360:238:5:-:0;2428:4;145:1;2452:8;:30;:64;;;;363:6;2486:8;:30;2452:64;:111;;;;412:10;2533:8;:30;2452:111;:138;;;;2567:23;2581:8;2567:13;:23::i;1406:259:20:-;-1:-1:-1;;;;;1713:19:15;;;1479:95:20;;;;-1:-1:-1;;;1479:95:20;;18109:2:28;1479:95:20;;;18091:21:28;18148:2;18128:18;;;18121:30;18187:34;18167:18;;;18160:62;-1:-1:-1;;;18238:18:28;;;18231:43;18291:19;;1479:95:20;17907:409:28;1479:95:20;-1:-1:-1;;;;;;;;;;;1584:74:20;;-1:-1:-1;;;;;;1584:74:20;-1:-1:-1;;;;;1584:74:20;;;;;;;;;;1406:259::o;2057:265::-;2165:29;2176:17;2165:10;:29::i;:::-;2222:1;2208:4;:11;:15;:28;;;;2227:9;2208:28;2204:112;;;2252:53;2281:17;2300:4;2252:28;:53::i;2687:187:10:-;2779:6;;;-1:-1:-1;;;;;2795:17:10;;;-1:-1:-1;;;;;;2795:17:10;;;;;;;2827:40;;2779:6;;;2795:17;2779:6;;2827:40;;2760:16;;2827:40;2750:124;2687:187;:::o;4259:212:1:-;5374:13:11;;;;;;;5366:69;;;;-1:-1:-1;;;5366:69:11;;;;;;;:::i;:::-;4346:16:1::1;:14;:16::i;:::-;4373:62;-1:-1:-1::0;;;;;4392:20:1;::::1;::::0;:42:::1;;4428:6;4373:18;:62::i;4392:42::-;4415:10;4373:18;:62::i;:::-;-1:-1:-1::0;4446:8:1::1;:17:::0;;-1:-1:-1;;4446:17:1::1;;;::::0;;4259:212::o;2314:253:0:-;5374:13:11;;;;;;;5366:69;;;;-1:-1:-1;;;5366:69:11;;;;;;;:::i;:::-;2436:16:0::1;2420:13;:32;2416:101;;;2476:29;;-1:-1:-1::0;;;2476:29:0::1;;;;;;;;;;;2416:101;2527:14;:32:::0;;-1:-1:-1;;;;;;2527:32:0::1;-1:-1:-1::0;;;;;2527:32:0;;;::::1;::::0;;;::::1;::::0;;2314:253::o;2292:159:12:-;5374:13:11;;;;;;;5366:69;;;;-1:-1:-1;;;5366:69:11;;;;;;;:::i;:::-;2404:5:12::1;:13;2412:5:::0;2404;:13:::1;:::i;:::-;-1:-1:-1::0;2427:7:12::1;:17;2437:7:::0;2427;:17:::1;:::i;540:127:8:-:0;621:4;-1:-1:-1;;;;;606:20:8;;;602:57;;635:24;;-1:-1:-1;;;635:24:8;;;;;;;;;;;1978:136:5;2042:4;2078:6;2066:8;:18;;:40;;;;-1:-1:-1;;2100:6:5;-1:-1:-1;2088:18:5;;1978:136::o;1771:152:20:-;1837:37;1856:17;1837:18;:37::i;:::-;1889:27;;-1:-1:-1;;;;;1889:27:20;;;;;;;;1771:152;:::o;6674:198:23:-;6757:12;6788:77;6809:6;6817:4;6788:77;;;;;;;;;;;;;;;;;:20;:77::i;747:59:16:-;5374:13:11;;;;;;;5366:69;;;;-1:-1:-1;;;5366:69:11;;;;;;;:::i;7058:325:23:-;7199:12;7224;7238:23;7265:6;-1:-1:-1;;;;;7265:19:23;7285:4;7265:25;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;7223:67;;;;7307:69;7334:6;7342:7;7351:10;7363:12;7307:26;:69::i;:::-;7300:76;7058:325;-1:-1:-1;;;;;;7058:325:23:o;7671:628::-;7851:12;7879:7;7875:418;;;7906:10;:17;7927:1;7906:22;7902:286;;-1:-1:-1;;;;;1713:19:15;;;8113:60:23;;;;-1:-1:-1;;;8113:60:23;;20985:2:28;8113:60:23;;;20967:21:28;21024:2;21004:18;;;20997:30;21063:31;21043:18;;;21036:59;21112:18;;8113:60:23;20783:353:28;8113:60:23;-1:-1:-1;8208:10:23;8201:17;;7875:418;8249:33;8257:10;8269:12;8980:17;;:21;8976:379;;9208:10;9202:17;9264:15;9251:10;9247:2;9243:19;9236:44;8976:379;9331:12;9324:20;;-1:-1:-1;;;9324:20:23;;;;;;;;:::i;14:286:28:-;72:6;125:2;113:9;104:7;100:23;96:32;93:52;;;141:1;138;131:12;93:52;167:23;;-1:-1:-1;;;;;;219:32:28;;209:43;;199:71;;266:1;263;256:12;497:250;582:1;592:113;606:6;603:1;600:13;592:113;;;682:11;;;676:18;663:11;;;656:39;628:2;621:10;592:113;;;-1:-1:-1;;739:1:28;721:16;;714:27;497:250::o;752:396::-;901:2;890:9;883:21;864:4;933:6;927:13;976:6;971:2;960:9;956:18;949:34;992:79;1064:6;1059:2;1048:9;1044:18;1039:2;1031:6;1027:15;992:79;:::i;:::-;1132:2;1111:15;-1:-1:-1;;1107:29:28;1092:45;;;;1139:2;1088:54;;752:396;-1:-1:-1;;752:396:28:o;1153:131::-;-1:-1:-1;;;;;1228:31:28;;1218:42;;1208:70;;1274:1;1271;1264:12;1289:315;1357:6;1365;1418:2;1406:9;1397:7;1393:23;1389:32;1386:52;;;1434:1;1431;1424:12;1386:52;1473:9;1460:23;1492:31;1517:5;1492:31;:::i;:::-;1542:5;1594:2;1579:18;;;;1566:32;;-1:-1:-1;;;1289:315:28:o;1791:456::-;1868:6;1876;1884;1937:2;1925:9;1916:7;1912:23;1908:32;1905:52;;;1953:1;1950;1943:12;1905:52;1992:9;1979:23;2011:31;2036:5;2011:31;:::i;:::-;2061:5;-1:-1:-1;2118:2:28;2103:18;;2090:32;2131:33;2090:32;2131:33;:::i;:::-;1791:456;;2183:7;;-1:-1:-1;;;2237:2:28;2222:18;;;;2209:32;;1791:456::o;2720:247::-;2779:6;2832:2;2820:9;2811:7;2807:23;2803:32;2800:52;;;2848:1;2845;2838:12;2800:52;2887:9;2874:23;2906:31;2931:5;2906:31;:::i;3180:160::-;3245:20;;3301:13;;3294:21;3284:32;;3274:60;;3330:1;3327;3320:12;3274:60;3180:160;;;:::o;3345:420::-;3418:6;3426;3434;3487:2;3475:9;3466:7;3462:23;3458:32;3455:52;;;3503:1;3500;3493:12;3455:52;3542:9;3529:23;3592:18;3585:5;3581:30;3574:5;3571:41;3561:69;;3626:1;3623;3616:12;3561:69;3649:5;-1:-1:-1;3701:2:28;3686:18;;3673:32;;-1:-1:-1;3724:35:28;3755:2;3740:18;;3724:35;:::i;:::-;3714:45;;3345:420;;;;;:::o;3994:180::-;4053:6;4106:2;4094:9;4085:7;4081:23;4077:32;4074:52;;;4122:1;4119;4112:12;4074:52;-1:-1:-1;4145:23:28;;3994:180;-1:-1:-1;3994:180:28:o;4179:127::-;4240:10;4235:3;4231:20;4228:1;4221:31;4271:4;4268:1;4261:15;4295:4;4292:1;4285:15;4311:1056;4388:6;4396;4449:2;4437:9;4428:7;4424:23;4420:32;4417:52;;;4465:1;4462;4455:12;4417:52;4504:9;4491:23;4523:31;4548:5;4523:31;:::i;:::-;4573:5;-1:-1:-1;4629:2:28;4614:18;;4601:32;4652:18;4682:14;;;4679:34;;;4709:1;4706;4699:12;4679:34;4747:6;4736:9;4732:22;4722:32;;4792:7;4785:4;4781:2;4777:13;4773:27;4763:55;;4814:1;4811;4804:12;4763:55;4850:2;4837:16;4872:2;4868;4865:10;4862:36;;;4878:18;;:::i;:::-;4953:2;4947:9;4921:2;5007:13;;-1:-1:-1;;5003:22:28;;;5027:2;4999:31;4995:40;4983:53;;;5051:18;;;5071:22;;;5048:46;5045:72;;;5097:18;;:::i;:::-;5137:10;5133:2;5126:22;5172:2;5164:6;5157:18;5212:7;5207:2;5202;5198;5194:11;5190:20;5187:33;5184:53;;;5233:1;5230;5223:12;5184:53;5289:2;5284;5280;5276:11;5271:2;5263:6;5259:15;5246:46;5334:1;5329:2;5324;5316:6;5312:15;5308:24;5301:35;5355:6;5345:16;;;;;;;4311:1056;;;;;:::o;5554:248::-;5619:6;5627;5680:2;5668:9;5659:7;5655:23;5651:32;5648:52;;;5696:1;5693;5686:12;5648:52;5732:9;5719:23;5709:33;;5761:35;5792:2;5781:9;5777:18;5761:35;:::i;:::-;5751:45;;5554:248;;;;;:::o;5807:315::-;5872:6;5880;5933:2;5921:9;5912:7;5908:23;5904:32;5901:52;;;5949:1;5946;5939:12;5901:52;5988:9;5975:23;6007:31;6032:5;6007:31;:::i;:::-;6057:5;-1:-1:-1;6081:35:28;6112:2;6097:18;;6081:35;:::i;6127:348::-;6179:8;6189:6;6243:3;6236:4;6228:6;6224:17;6220:27;6210:55;;6261:1;6258;6251:12;6210:55;-1:-1:-1;6284:20:28;;6327:18;6316:30;;6313:50;;;6359:1;6356;6349:12;6313:50;6396:4;6388:6;6384:17;6372:29;;6448:3;6441:4;6432:6;6424;6420:19;6416:30;6413:39;6410:59;;;6465:1;6462;6455:12;6410:59;6127:348;;;;;:::o;6480:1375::-;6615:6;6623;6631;6639;6647;6655;6663;6671;6679;6732:3;6720:9;6711:7;6707:23;6703:33;6700:53;;;6749:1;6746;6739:12;6700:53;6788:9;6775:23;6807:31;6832:5;6807:31;:::i;:::-;6857:5;-1:-1:-1;6914:2:28;6899:18;;6886:32;6927:33;6886:32;6927:33;:::i;:::-;6979:7;-1:-1:-1;7038:2:28;7023:18;;7010:32;7051:33;7010:32;7051:33;:::i;:::-;7103:7;-1:-1:-1;7157:2:28;7142:18;;7129:32;;-1:-1:-1;7213:3:28;7198:19;;7185:33;7262:4;7249:18;;7237:31;;7227:59;;7282:1;7279;7272:12;7227:59;7305:7;-1:-1:-1;7363:3:28;7348:19;;7335:33;7387:18;7417:14;;;7414:34;;;7444:1;7441;7434:12;7414:34;7483:59;7534:7;7525:6;7514:9;7510:22;7483:59;:::i;:::-;7561:8;;-1:-1:-1;7457:85:28;-1:-1:-1;7649:3:28;7634:19;;7621:33;;-1:-1:-1;7666:16:28;;;7663:36;;;7695:1;7692;7685:12;7663:36;;7734:61;7787:7;7776:8;7765:9;7761:24;7734:61;:::i;:::-;7708:87;;7814:8;7804:18;;;7841:8;7831:18;;;6480:1375;;;;;;;;;;;:::o;7860:388::-;7928:6;7936;7989:2;7977:9;7968:7;7964:23;7960:32;7957:52;;;8005:1;8002;7995:12;7957:52;8044:9;8031:23;8063:31;8088:5;8063:31;:::i;:::-;8113:5;-1:-1:-1;8170:2:28;8155:18;;8142:32;8183:33;8142:32;8183:33;:::i;:::-;8235:7;8225:17;;;7860:388;;;;;:::o;8458:380::-;8537:1;8533:12;;;;8580;;;8601:61;;8655:4;8647:6;8643:17;8633:27;;8601:61;8708:2;8700:6;8697:14;8677:18;8674:38;8671:161;;8754:10;8749:3;8745:20;8742:1;8735:31;8789:4;8786:1;8779:15;8817:4;8814:1;8807:15;8671:161;;8458:380;;;:::o;8843:408::-;9045:2;9027:21;;;9084:2;9064:18;;;9057:30;9123:34;9118:2;9103:18;;9096:62;-1:-1:-1;;;9189:2:28;9174:18;;9167:42;9241:3;9226:19;;8843:408::o;9256:::-;9458:2;9440:21;;;9497:2;9477:18;;;9470:30;9536:34;9531:2;9516:18;;9509:62;-1:-1:-1;;;9602:2:28;9587:18;;9580:42;9654:3;9639:19;;9256:408::o;9669:222::-;9734:9;;;9755:10;;;9752:133;;;9807:10;9802:3;9798:20;9795:1;9788:31;9842:4;9839:1;9832:15;9870:4;9867:1;9860:15;14423:184;14493:6;14546:2;14534:9;14525:7;14521:23;14517:32;14514:52;;;14562:1;14559;14552:12;14514:52;-1:-1:-1;14585:16:28;;14423:184;-1:-1:-1;14423:184:28:o;15713:251::-;15783:6;15836:2;15824:9;15815:7;15811:23;15807:32;15804:52;;;15852:1;15849;15842:12;15804:52;15884:9;15878:16;15903:31;15928:5;15903:31;:::i;17495:407::-;17697:2;17679:21;;;17736:2;17716:18;;;17709:30;17775:34;17770:2;17755:18;;17748:62;-1:-1:-1;;;17841:2:28;17826:18;;17819:41;17892:3;17877:19;;17495:407::o;18447:518::-;18549:2;18544:3;18541:11;18538:421;;;18585:5;18582:1;18575:16;18629:4;18626:1;18616:18;18699:2;18687:10;18683:19;18680:1;18676:27;18670:4;18666:38;18735:4;18723:10;18720:20;18717:47;;;-1:-1:-1;18758:4:28;18717:47;18813:2;18808:3;18804:12;18801:1;18797:20;18791:4;18787:31;18777:41;;18868:81;18886:2;18879:5;18876:13;18868:81;;;18945:1;18931:16;;18912:1;18901:13;18868:81;;;18872:3;;18447:518;;;:::o;19141:1345::-;19267:3;19261:10;19294:18;19286:6;19283:30;19280:56;;;19316:18;;:::i;:::-;19345:97;19435:6;19395:38;19427:4;19421:11;19395:38;:::i;:::-;19389:4;19345:97;:::i;:::-;19497:4;;19554:2;19543:14;;19571:1;19566:663;;;;20273:1;20290:6;20287:89;;;-1:-1:-1;20342:19:28;;;20336:26;20287:89;-1:-1:-1;;19098:1:28;19094:11;;;19090:24;19086:29;19076:40;19122:1;19118:11;;;19073:57;20389:81;;19536:944;;19566:663;18394:1;18387:14;;;18431:4;18418:18;;-1:-1:-1;;19602:20:28;;;19720:236;19734:7;19731:1;19728:14;19720:236;;;19823:19;;;19817:26;19802:42;;19915:27;;;;19883:1;19871:14;;;;19750:19;;19720:236;;;19724:3;19984:6;19975:7;19972:19;19969:201;;;20045:19;;;20039:26;-1:-1:-1;;20128:1:28;20124:14;;;20140:3;20120:24;20116:37;20112:42;20097:58;20082:74;;19969:201;;;20216:1;20207:6;20204:1;20200:14;20196:22;20190:4;20183:36;19536:944;;;;;19141:1345;;:::o;20491:287::-;20620:3;20658:6;20652:13;20674:66;20733:6;20728:3;20721:4;20713:6;20709:17;20674:66;:::i;:::-;20756:16;;;;;20491:287;-1:-1:-1;;20491:287:28:o

ipfs://e71efa9d5f866b742d3a26addbacfbfd103eaf91f295f46862cb9770e13bc537