Contract Source Code (Solidity Standard Json-Input format)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

import "@openzeppelin/contracts-upgradeable/access/AccessControlEnumerableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20BurnableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/token/ERC20/extensions/ERC20PausableUpgradeable.sol";
import "@openzeppelin/contracts-upgradeable/utils/cryptography/draft-EIP712Upgradeable.sol";

contract ERC20MintablePauseableUpgradeable is
    ERC20PausableUpgradeable,
    ERC20BurnableUpgradeable,
    EIP712Upgradeable,
    AccessControlEnumerableUpgradeable
{
    uint256 private _cap;
    address public implementation;
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    mapping(address => bool) private blackList;
    // keccak256("Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)");
    bytes32 public constant PERMIT_TYPEHASH =
        0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9;
    mapping(address => uint256) public nonces;

    function initialize(
        string memory name,
        string memory symbol,
        uint256 initialSupply,
        address admin
    ) public initializer {
        __ERC20_init(name, symbol);
        __EIP712_init("PermitToken", "1.0");
        _setupRole(DEFAULT_ADMIN_ROLE, admin);
        _setupRole(MINTER_ROLE, admin);
        _mint(admin, initialSupply);
    }

    modifier onlyAdmin() {
        require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "forbidden");
        _;
    }

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal override(ERC20Upgradeable, ERC20PausableUpgradeable) {
        require(!blackList[from], "forbidden");
        super._beforeTokenTransfer(from, to, amount);
    }

    function setBlackList(address account) public onlyAdmin {
        blackList[account] = !blackList[account];
    }

    function getBlackList(
        address account
    ) public view onlyAdmin returns (bool) {
        return blackList[account];
    }

    function mint(address to, uint256 amount) public virtual {
        require(
            hasRole(MINTER_ROLE, _msgSender()),
            "ERC20PresetMinterPauser: must have minter role to mint"
        );
        if (_cap > 0) {
            require(
                totalSupply() + amount <= _cap,
                "ERC20Capped: cap exceeded"
            );
        }
        _mint(to, amount);
    }

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

    function unpause() public onlyAdmin {
        _unpause();
    }

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        bytes memory signature
    ) public {
        // hash调用方法和参数
        bytes32 structHash = keccak256(
            abi.encode(
                PERMIT_TYPEHASH,
                owner,
                spender,
                value,
                nonces[owner]++,
                deadline
            )
        );
        // 结构化hash
        bytes32 hash = _hashTypedDataV4(structHash);
        // 还原签名人
        address signer = ECDSAUpgradeable.recover(hash, signature);
        require(owner == signer, "Permit: invalid signature");
        _approve(owner, spender, value);
    }

    /**
     * @dev Returns the cap on the token's total supply.
     */
    function cap() public view virtual returns (uint256) {
        return _cap;
    }

    function setCap(uint256 cap_) external onlyAdmin {
        _cap = cap_;
    }
}

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

pragma solidity ^0.8.0;

import "./IAccessControlEnumerableUpgradeable.sol";
import "./AccessControlUpgradeable.sol";
import "../utils/structs/EnumerableSetUpgradeable.sol";
import "../proxy/utils/Initializable.sol";

/**
 * @dev Extension of {AccessControl} that allows enumerating the members of each role.
 */
abstract contract AccessControlEnumerableUpgradeable is Initializable, IAccessControlEnumerableUpgradeable, AccessControlUpgradeable {
    function __AccessControlEnumerable_init() internal onlyInitializing {
    }

    function __AccessControlEnumerable_init_unchained() internal onlyInitializing {
    }
    using EnumerableSetUpgradeable for EnumerableSetUpgradeable.AddressSet;

    mapping(bytes32 => EnumerableSetUpgradeable.AddressSet) private _roleMembers;

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

    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index) public view virtual override returns (address) {
        return _roleMembers[role].at(index);
    }

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) public view virtual override returns (uint256) {
        return _roleMembers[role].length();
    }

    /**
     * @dev Overload {_grantRole} to track enumerable memberships
     */
    function _grantRole(bytes32 role, address account) internal virtual override {
        super._grantRole(role, account);
        _roleMembers[role].add(account);
    }

    /**
     * @dev Overload {_revokeRole} to track enumerable memberships
     */
    function _revokeRole(bytes32 role, address account) internal virtual override {
        super._revokeRole(role, account);
        _roleMembers[role].remove(account);
    }

    /**
     * @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
// OpenZeppelin Contracts (last updated v4.9.0) (access/AccessControl.sol)

pragma solidity ^0.8.0;

import "./IAccessControlUpgradeable.sol";
import "../utils/ContextUpgradeable.sol";
import "../utils/StringsUpgradeable.sol";
import "../utils/introspection/ERC165Upgradeable.sol";
import "../proxy/utils/Initializable.sol";

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

    function __AccessControl_init_unchained() internal onlyInitializing {
    }
    struct RoleData {
        mapping(address => bool) members;
        bytes32 adminRole;
    }

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

    /**
     * @dev Modifier that checks that an account has a specific role. Reverts
     * with a standardized message including the required role.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     *
     * _Available since v4.1._
     */
    modifier onlyRole(bytes32 role) {
        _checkRole(role);
        _;
    }

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

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

    /**
     * @dev Revert with a standard message if `_msgSender()` is missing `role`.
     * Overriding this function changes the behavior of the {onlyRole} modifier.
     *
     * Format of the revert message is described in {_checkRole}.
     *
     * _Available since v4.6._
     */
    function _checkRole(bytes32 role) internal view virtual {
        _checkRole(role, _msgSender());
    }

    /**
     * @dev Revert with a standard message if `account` is missing `role`.
     *
     * The format of the revert reason is given by the following regular expression:
     *
     *  /^AccessControl: account (0x[0-9a-f]{40}) is missing role (0x[0-9a-f]{64})$/
     */
    function _checkRole(bytes32 role, address account) internal view virtual {
        if (!hasRole(role, account)) {
            revert(
                string(
                    abi.encodePacked(
                        "AccessControl: account ",
                        StringsUpgradeable.toHexString(account),
                        " is missing role ",
                        StringsUpgradeable.toHexString(uint256(role), 32)
                    )
                )
            );
        }
    }

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

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

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

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

        _revokeRole(role, account);
    }

    /**
     * @dev Grants `role` to `account`.
     *
     * If `account` had not been already granted `role`, emits a {RoleGranted}
     * event. Note that unlike {grantRole}, this function doesn't perform any
     * checks on the calling account.
     *
     * May emit a {RoleGranted} event.
     *
     * [WARNING]
     * ====
     * This function should only be called from the constructor when setting
     * up the initial roles for the system.
     *
     * Using this function in any other way is effectively circumventing the admin
     * system imposed by {AccessControl}.
     * ====
     *
     * NOTE: This function is deprecated in favor of {_grantRole}.
     */
    function _setupRole(bytes32 role, address account) internal virtual {
        _grantRole(role, account);
    }

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

    /**
     * @dev Grants `role` to `account`.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleGranted} event.
     */
    function _grantRole(bytes32 role, address account) internal virtual {
        if (!hasRole(role, account)) {
            _roles[role].members[account] = true;
            emit RoleGranted(role, account, _msgSender());
        }
    }

    /**
     * @dev Revokes `role` from `account`.
     *
     * Internal function without access restriction.
     *
     * May emit a {RoleRevoked} event.
     */
    function _revokeRole(bytes32 role, address account) internal virtual {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }

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

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/IAccessControlEnumerable.sol)

pragma solidity ^0.8.0;

import "./IAccessControlUpgradeable.sol";

/**
 * @dev External interface of AccessControlEnumerable declared to support ERC165 detection.
 */
interface IAccessControlEnumerableUpgradeable is IAccessControlUpgradeable {
    /**
     * @dev Returns one of the accounts that have `role`. `index` must be a
     * value between 0 and {getRoleMemberCount}, non-inclusive.
     *
     * Role bearers are not sorted in any particular way, and their ordering may
     * change at any point.
     *
     * WARNING: When using {getRoleMember} and {getRoleMemberCount}, make sure
     * you perform all queries on the same block. See the following
     * https://forum.openzeppelin.com/t/iterating-over-elements-on-enumerableset-in-openzeppelin-contracts/2296[forum post]
     * for more information.
     */
    function getRoleMember(bytes32 role, uint256 index) external view returns (address);

    /**
     * @dev Returns the number of accounts that have `role`. Can be used
     * together with {getRoleMember} to enumerate all bearers of a role.
     */
    function getRoleMemberCount(bytes32 role) external view returns (uint256);
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)

pragma solidity ^0.8.0;

/**
 * @dev External interface of AccessControl declared to support ERC165 detection.
 */
interface IAccessControlUpgradeable {
    /**
     * @dev Emitted when `newAdminRole` is set as ``role``'s admin role, replacing `previousAdminRole`
     *
     * `DEFAULT_ADMIN_ROLE` is the starting admin for all roles, despite
     * {RoleAdminChanged} not being emitted signaling this.
     *
     * _Available since v3.1._
     */
    event RoleAdminChanged(bytes32 indexed role, bytes32 indexed previousAdminRole, bytes32 indexed newAdminRole);

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, an admin role
     * bearer except when using {AccessControl-_setupRole}.
     */
    event RoleGranted(bytes32 indexed role, address indexed account, address indexed sender);

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

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

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

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

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

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

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

pragma solidity ^0.8.0;

interface IERC5267Upgradeable {
    /**
     * @dev MAY be emitted to signal that the domain could have changed.
     */
    event EIP712DomainChanged();

    /**
     * @dev returns the fields and values that describe the domain separator used by this contract for EIP-712
     * signature.
     */
    function eip712Domain()
        external
        view
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        );
}

// 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.7.0) (security/Pausable.sol)

pragma solidity ^0.8.0;

import "../utils/ContextUpgradeable.sol";
import "../proxy/utils/Initializable.sol";

/**
 * @dev Contract module which allows children to implement an emergency stop
 * mechanism that can be triggered by an authorized account.
 *
 * This module is used through inheritance. It will make available the
 * modifiers `whenNotPaused` and `whenPaused`, which can be applied to
 * the functions of your contract. Note that they will not be pausable by
 * simply including this module, only once the modifiers are put in place.
 */
abstract contract PausableUpgradeable is Initializable, ContextUpgradeable {
    /**
     * @dev Emitted when the pause is triggered by `account`.
     */
    event Paused(address account);

    /**
     * @dev Emitted when the pause is lifted by `account`.
     */
    event Unpaused(address account);

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    function __Pausable_init() internal onlyInitializing {
        __Pausable_init_unchained();
    }

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

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

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

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

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

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

    /**
     * @dev Triggers stopped state.
     *
     * Requirements:
     *
     * - The contract must not be paused.
     */
    function _pause() internal virtual whenNotPaused {
        _paused = true;
        emit Paused(_msgSender());
    }

    /**
     * @dev Returns to normal state.
     *
     * Requirements:
     *
     * - The contract must be paused.
     */
    function _unpause() internal virtual whenPaused {
        _paused = false;
        emit Unpaused(_msgSender());
    }

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

// 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 "../../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 (last updated v4.5.0) (token/ERC20/extensions/ERC20Burnable.sol)

pragma solidity ^0.8.0;

import "../ERC20Upgradeable.sol";
import "../../../utils/ContextUpgradeable.sol";
import "../../../proxy/utils/Initializable.sol";

/**
 * @dev Extension of {ERC20} that allows token holders to destroy both their own
 * tokens and those that they have an allowance for, in a way that can be
 * recognized off-chain (via event analysis).
 */
abstract contract ERC20BurnableUpgradeable is Initializable, ContextUpgradeable, ERC20Upgradeable {
    function __ERC20Burnable_init() internal onlyInitializing {
    }

    function __ERC20Burnable_init_unchained() internal onlyInitializing {
    }
    /**
     * @dev Destroys `amount` tokens from the caller.
     *
     * See {ERC20-_burn}.
     */
    function burn(uint256 amount) public virtual {
        _burn(_msgSender(), amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, deducting from the caller's
     * allowance.
     *
     * See {ERC20-_burn} and {ERC20-allowance}.
     *
     * Requirements:
     *
     * - the caller must have allowance for ``accounts``'s tokens of at least
     * `amount`.
     */
    function burnFrom(address account, uint256 amount) public virtual {
        _spendAllowance(account, _msgSender(), amount);
        _burn(account, amount);
    }

    /**
     * @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) (token/ERC20/extensions/ERC20Pausable.sol)

pragma solidity ^0.8.0;

import "../ERC20Upgradeable.sol";
import "../../../security/PausableUpgradeable.sol";
import "../../../proxy/utils/Initializable.sol";

/**
 * @dev ERC20 token with pausable token transfers, minting and burning.
 *
 * Useful for scenarios such as preventing trades until the end of an evaluation
 * period, or having an emergency switch for freezing all token transfers in the
 * event of a large bug.
 *
 * IMPORTANT: This contract does not include public pause and unpause functions. In
 * addition to inheriting this contract, you must define both functions, invoking the
 * {Pausable-_pause} and {Pausable-_unpause} internal functions, with appropriate
 * access control, e.g. using {AccessControl} or {Ownable}. Not doing so will
 * make the contract unpausable.
 */
abstract contract ERC20PausableUpgradeable is Initializable, ERC20Upgradeable, PausableUpgradeable {
    function __ERC20Pausable_init() internal onlyInitializing {
        __Pausable_init_unchained();
    }

    function __ERC20Pausable_init_unchained() internal onlyInitializing {
    }
    /**
     * @dev See {ERC20-_beforeTokenTransfer}.
     *
     * Requirements:
     *
     * - the contract must not be paused.
     */
    function _beforeTokenTransfer(address from, address to, uint256 amount) internal virtual override {
        super._beforeTokenTransfer(from, to, amount);

        require(!paused(), "ERC20Pausable: token transfer while paused");
    }

    /**
     * @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 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.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 (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 v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;
import "../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;
    }

    /**
     * @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.8.0) (utils/cryptography/draft-EIP712.sol)

pragma solidity ^0.8.0;

// EIP-712 is Final as of 2022-08-11. This file is deprecated.

import "./EIP712Upgradeable.sol";

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

pragma solidity ^0.8.0;

import "../StringsUpgradeable.sol";

/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSAUpgradeable {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV // Deprecated in v4.8
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            /// @solidity memory-safe-assembly
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(bytes32 hash, uint8 v, bytes32 r, bytes32 s) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32 message) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, "\x19Ethereum Signed Message:\n32")
            mstore(0x1c, hash)
            message := keccak256(0x00, 0x3c)
        }
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", StringsUpgradeable.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 data) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, "\x19\x01")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            data := keccak256(ptr, 0x42)
        }
    }

    /**
     * @dev Returns an Ethereum Signed Data with intended validator, created from a
     * `validator` and `data` according to the version 0 of EIP-191.
     *
     * See {recover}.
     */
    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x00", validator, data));
    }
}

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

pragma solidity ^0.8.8;

import "./ECDSAUpgradeable.sol";
import "../../interfaces/IERC5267Upgradeable.sol";
import "../../proxy/utils/Initializable.sol";

/**
 * @dev https://eips.ethereum.org/EIPS/eip-712[EIP 712] is a standard for hashing and signing of typed structured data.
 *
 * The encoding specified in the EIP is very generic, and such a generic implementation in Solidity is not feasible,
 * thus this contract does not implement the encoding itself. Protocols need to implement the type-specific encoding
 * they need in their contracts using a combination of `abi.encode` and `keccak256`.
 *
 * This contract implements the EIP 712 domain separator ({_domainSeparatorV4}) that is used as part of the encoding
 * scheme, and the final step of the encoding to obtain the message digest that is then signed via ECDSA
 * ({_hashTypedDataV4}).
 *
 * The implementation of the domain separator was designed to be as efficient as possible while still properly updating
 * the chain id to protect against replay attacks on an eventual fork of the chain.
 *
 * NOTE: This contract implements the version of the encoding known as "v4", as implemented by the JSON RPC method
 * https://docs.metamask.io/guide/signing-data.html[`eth_signTypedDataV4` in MetaMask].
 *
 * NOTE: In the upgradeable version of this contract, the cached values will correspond to the address, and the domain
 * separator of the implementation contract. This will cause the `_domainSeparatorV4` function to always rebuild the
 * separator from the immutable values, which is cheaper than accessing a cached version in cold storage.
 *
 * _Available since v3.4._
 *
 * @custom:storage-size 52
 */
abstract contract EIP712Upgradeable is Initializable, IERC5267Upgradeable {
    bytes32 private constant _TYPE_HASH =
        keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)");

    /// @custom:oz-renamed-from _HASHED_NAME
    bytes32 private _hashedName;
    /// @custom:oz-renamed-from _HASHED_VERSION
    bytes32 private _hashedVersion;

    string private _name;
    string private _version;

    /**
     * @dev Initializes the domain separator and parameter caches.
     *
     * The meaning of `name` and `version` is specified in
     * https://eips.ethereum.org/EIPS/eip-712#definition-of-domainseparator[EIP 712]:
     *
     * - `name`: the user readable name of the signing domain, i.e. the name of the DApp or the protocol.
     * - `version`: the current major version of the signing domain.
     *
     * NOTE: These parameters cannot be changed except through a xref:learn::upgrading-smart-contracts.adoc[smart
     * contract upgrade].
     */
    function __EIP712_init(string memory name, string memory version) internal onlyInitializing {
        __EIP712_init_unchained(name, version);
    }

    function __EIP712_init_unchained(string memory name, string memory version) internal onlyInitializing {
        _name = name;
        _version = version;

        // Reset prior values in storage if upgrading
        _hashedName = 0;
        _hashedVersion = 0;
    }

    /**
     * @dev Returns the domain separator for the current chain.
     */
    function _domainSeparatorV4() internal view returns (bytes32) {
        return _buildDomainSeparator();
    }

    function _buildDomainSeparator() private view returns (bytes32) {
        return keccak256(abi.encode(_TYPE_HASH, _EIP712NameHash(), _EIP712VersionHash(), block.chainid, address(this)));
    }

    /**
     * @dev Given an already https://eips.ethereum.org/EIPS/eip-712#definition-of-hashstruct[hashed struct], this
     * function returns the hash of the fully encoded EIP712 message for this domain.
     *
     * This hash can be used together with {ECDSA-recover} to obtain the signer of a message. For example:
     *
     * ```solidity
     * bytes32 digest = _hashTypedDataV4(keccak256(abi.encode(
     *     keccak256("Mail(address to,string contents)"),
     *     mailTo,
     *     keccak256(bytes(mailContents))
     * )));
     * address signer = ECDSA.recover(digest, signature);
     * ```
     */
    function _hashTypedDataV4(bytes32 structHash) internal view virtual returns (bytes32) {
        return ECDSAUpgradeable.toTypedDataHash(_domainSeparatorV4(), structHash);
    }

    /**
     * @dev See {EIP-5267}.
     *
     * _Available since v4.9._
     */
    function eip712Domain()
        public
        view
        virtual
        override
        returns (
            bytes1 fields,
            string memory name,
            string memory version,
            uint256 chainId,
            address verifyingContract,
            bytes32 salt,
            uint256[] memory extensions
        )
    {
        // If the hashed name and version in storage are non-zero, the contract hasn't been properly initialized
        // and the EIP712 domain is not reliable, as it will be missing name and version.
        require(_hashedName == 0 && _hashedVersion == 0, "EIP712: Uninitialized");

        return (
            hex"0f", // 01111
            _EIP712Name(),
            _EIP712Version(),
            block.chainid,
            address(this),
            bytes32(0),
            new uint256[](0)
        );
    }

    /**
     * @dev The name parameter for the EIP712 domain.
     *
     * NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs
     * are a concern.
     */
    function _EIP712Name() internal virtual view returns (string memory) {
        return _name;
    }

    /**
     * @dev The version parameter for the EIP712 domain.
     *
     * NOTE: This function reads from storage by default, but can be redefined to return a constant value if gas costs
     * are a concern.
     */
    function _EIP712Version() internal virtual view returns (string memory) {
        return _version;
    }

    /**
     * @dev The hash of the name parameter for the EIP712 domain.
     *
     * NOTE: In previous versions this function was virtual. In this version you should override `_EIP712Name` instead.
     */
    function _EIP712NameHash() internal view returns (bytes32) {
        string memory name = _EIP712Name();
        if (bytes(name).length > 0) {
            return keccak256(bytes(name));
        } else {
            // If the name is empty, the contract may have been upgraded without initializing the new storage.
            // We return the name hash in storage if non-zero, otherwise we assume the name is empty by design.
            bytes32 hashedName = _hashedName;
            if (hashedName != 0) {
                return hashedName;
            } else {
                return keccak256("");
            }
        }
    }

    /**
     * @dev The hash of the version parameter for the EIP712 domain.
     *
     * NOTE: In previous versions this function was virtual. In this version you should override `_EIP712Version` instead.
     */
    function _EIP712VersionHash() internal view returns (bytes32) {
        string memory version = _EIP712Version();
        if (bytes(version).length > 0) {
            return keccak256(bytes(version));
        } else {
            // If the version is empty, the contract may have been upgraded without initializing the new storage.
            // We return the version hash in storage if non-zero, otherwise we assume the version is empty by design.
            bytes32 hashedVersion = _hashedVersion;
            if (hashedVersion != 0) {
                return hashedVersion;
            } else {
                return keccak256("");
            }
        }
    }

    /**
     * @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[48] private __gap;
}

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

pragma solidity ^0.8.0;

import "./IERC165Upgradeable.sol";
import "../../proxy/utils/Initializable.sol";

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165Upgradeable is Initializable, IERC165Upgradeable {
    function __ERC165_init() internal onlyInitializing {
    }

    function __ERC165_init_unchained() internal onlyInitializing {
    }
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165Upgradeable).interfaceId;
    }

    /**
     * @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 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
// 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 MathUpgradeable {
    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 SignedMathUpgradeable {
    /**
     * @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 (last updated v4.9.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

import "./math/MathUpgradeable.sol";
import "./math/SignedMathUpgradeable.sol";

/**
 * @dev String operations.
 */
library StringsUpgradeable {
    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 = MathUpgradeable.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(SignedMathUpgradeable.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, MathUpgradeable.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/structs/EnumerableSet.sol)
// This file was procedurally generated from scripts/generate/templates/EnumerableSet.js.

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```solidity
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 *
 * [WARNING]
 * ====
 * Trying to delete such a structure from storage will likely result in data corruption, rendering the structure
 * unusable.
 * See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 * In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an
 * array of EnumerableSet.
 * ====
 */
library EnumerableSetUpgradeable {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastValue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastValue;
                // Update the index for the moved value
                set._indexes[lastValue] = valueIndex; // Replace lastValue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        bytes32[] memory store = _values(set._inner);
        bytes32[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        /// @solidity memory-safe-assembly
        assembly {
            result := store
        }

        return result;
    }
}

{
  "optimizer": {
    "enabled": true,
    "runs": 200
  },
  "outputSelection": {
    "*": {
      "*": [
        "evm.bytecode",
        "evm.deployedBytecode",
        "abi"
      ]
    }
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"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":[],"name":"EIP712DomainChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint8","name":"version","type":"uint8"}],"name":"Initialized","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":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"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINTER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PERMIT_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"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":[{"internalType":"address","name":"account","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"burnFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cap","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"decimals","outputs":[{"internalType":"uint8","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"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":"eip712Domain","outputs":[{"internalType":"bytes1","name":"fields","type":"bytes1"},{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"version","type":"string"},{"internalType":"uint256","name":"chainId","type":"uint256"},{"internalType":"address","name":"verifyingContract","type":"address"},{"internalType":"bytes32","name":"salt","type":"bytes32"},{"internalType":"uint256[]","name":"extensions","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"getBlackList","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"implementation","outputs":[{"internalType":"address","name":"","type":"address"}],"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":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"uint256","name":"initialSupply","type":"uint256"},{"internalType":"address","name":"admin","type":"address"}],"name":"initialize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","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":[{"internalType":"address","name":"","type":"address"}],"name":"nonces","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"spender","type":"address"},{"internalType":"uint256","name":"value","type":"uint256"},{"internalType":"uint256","name":"deadline","type":"uint256"},{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"permit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"setBlackList","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"cap_","type":"uint256"}],"name":"setCap","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"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":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

439:3167:23:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;962:223:0;;;;;;:::i;:::-;;:::i;:::-;;;470:14:24;;463:22;445:41;;433:2;418:18;962:223:0;;;;;;;;2495:98:7;;;:::i;:::-;;;;;;;:::i;4781:197::-;;;;;;:::i;:::-;;:::i;3592:106::-;3679:12;;3592:106;;;1836:25:24;;;1824:2;1809:18;3592:106:7;1690:177:24;5540:256:7;;;;;;:::i;:::-;;:::i;4834:129:1:-;;;;;;:::i;:::-;4908:7;4934:12;;;:6;:12;;;;;:22;;;;4834:129;5259:145;;;;;;:::i;:::-;;:::i;:::-;;894:116:23;;944:66;894:116;;3441:91:7;;;3523:2;2973:36:24;;2961:2;2946:18;3441:91:7;2831:184:24;3440:81:23;3510:4;;3440:81;;6368:214:1;;;;;;:::i;:::-;;:::i;6191:234:7:-;;;;;;:::i;:::-;;:::i;2562:63:23:-;;;:::i;1955:132::-;;;;;;:::i;:::-;;:::i;2093:398::-;;;;;;:::i;:::-;;:::i;848:89:9:-;;;;;;:::i;:::-;;:::i;3527:77:23:-;;;;;;:::i;:::-;;:::i;639:29::-;;;;;-1:-1:-1;;;;;639:29:23;;;;;;-1:-1:-1;;;;;3560:32:24;;;3542:51;;3530:2;3515:18;639:29:23;3396:203:24;1858:84:6;1928:7;;;;1858:84;;3756:125:7;;;;;;:::i;:::-;-1:-1:-1;;;;;3856:18:7;3830:7;3856:18;;;:9;:18;;;;;;;3756:125;1836:113:23;;;;;;:::i;:::-;;:::i;1243:161:9:-;;;;;;:::i;:::-;;:::i;1016:41:23:-;;;;;;:::i;:::-;;;;;;;;;;;;;;2497:59;;;:::i;4500:861:16:-;;;:::i;:::-;;;;;;;;;;;;;:::i;1770:151:0:-;;;;;;:::i;:::-;;:::i;3329:145:1:-;;;;;;:::i;:::-;;:::i;2706:102:7:-;;;:::i;2631:730:23:-;;;;;;:::i;:::-;;:::i;2450:49:1:-;;2495:4;2450:49;;6912:427:7;;;;;;:::i;:::-;;:::i;4077:189::-;;;;;;:::i;:::-;;:::i;1064:369:23:-;;;;;;:::i;:::-;;:::i;2089:140:0:-;;;;;;:::i;:::-;;:::i;674:62:23:-;;712:24;674:62;;5684:147:1;;;;;;:::i;:::-;;:::i;4324:149:7:-;;;;;;:::i;:::-;;:::i;962:223:0:-;1047:4;-1:-1:-1;;;;;;1070:68:0;;-1:-1:-1;;;1070:68:0;;:108;;;1142:36;1166:11;1142:23;:36::i;:::-;1063:115;962:223;-1:-1:-1;;962:223:0:o;2495:98:7:-;2549:13;2581:5;2574:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2495:98;:::o;4781:197::-;4864:4;929:10:13;4918:32:7;929:10:13;4934:7:7;4943:6;4918:8;:32::i;:::-;-1:-1:-1;4967:4:7;;4781:197;-1:-1:-1;;;4781:197:7:o;5540:256::-;5637:4;929:10:13;5693:38:7;5709:4;929:10:13;5724:6:7;5693:15;:38::i;:::-;5741:27;5751:4;5757:2;5761:6;5741:9;:27::i;:::-;-1:-1:-1;5785:4:7;;5540:256;-1:-1:-1;;;;5540:256:7:o;5259:145:1:-;4908:7;4934:12;;;:6;:12;;;;;:22;;;2928:16;2939:4;2928:10;:16::i;:::-;5372:25:::1;5383:4;5389:7;5372:10;:25::i;:::-;5259:145:::0;;;:::o;6368:214::-;-1:-1:-1;;;;;6463:23:1;;929:10:13;6463:23:1;6455:83;;;;-1:-1:-1;;;6455:83:1;;8398:2:24;6455:83:1;;;8380:21:24;8437:2;8417:18;;;8410:30;8476:34;8456:18;;;8449:62;-1:-1:-1;;;8527:18:24;;;8520:45;8582:19;;6455:83:1;;;;;;;;;6549:26;6561:4;6567:7;6549:11;:26::i;:::-;6368:214;;:::o;6191:234:7:-;6279:4;929:10:13;6333:64:7;929:10:13;6349:7:7;6386:10;6358:25;929:10:13;6349:7:7;6358:9;:25::i;:::-;:38;;;;:::i;:::-;6333:8;:64::i;2562:63:23:-;1478:41;2495:4:1;929:10:13;3329:145:1;:::i;1478:41:23:-;1470:63;;;;-1:-1:-1;;;1470:63:23;;;;;;;:::i;:::-;2608:10:::1;:8;:10::i;:::-;2562:63::o:0;1955:132::-;2039:4;1478:41;2039:4;929:10:13;3329:145:1;:::i;1478:41:23:-;1470:63;;;;-1:-1:-1;;;1470:63:23;;;;;;;:::i;:::-;-1:-1:-1;;;;;;2062:18:23;::::1;;::::0;;;:9:::1;:18;::::0;;;;;::::1;;1543:1;1955:132:::0;;;:::o;2093:398::-;2181:34;712:24;929:10:13;3329:145:1;:::i;2181:34:23:-;2160:135;;;;-1:-1:-1;;;2160:135:23;;9413:2:24;2160:135:23;;;9395:21:24;9452:2;9432:18;;;9425:30;9491:34;9471:18;;;9464:62;-1:-1:-1;;;9542:18:24;;;9535:52;9604:19;;2160:135:23;9211:418:24;2160:135:23;2309:4;;:8;2305:153;;2384:4;;2374:6;2358:13;3679:12:7;;;3592:106;2358:13:23;:22;;;;:::i;:::-;:30;;2333:114;;;;-1:-1:-1;;;2333:114:23;;9836:2:24;2333:114:23;;;9818:21:24;9875:2;9855:18;;;9848:30;9914:27;9894:18;;;9887:55;9959:18;;2333:114:23;9634:349:24;2333:114:23;2467:17;2473:2;2477:6;2467:5;:17::i;848:89:9:-;903:27;929:10:13;923:6:9;903:5;:27::i;:::-;848:89;:::o;3527:77:23:-;1478:41;2495:4:1;929:10:13;3329:145:1;:::i;1478:41:23:-;1470:63;;;;-1:-1:-1;;;1470:63:23;;;;;;;:::i;:::-;3586:4:::1;:11:::0;3527:77::o;1836:113::-;1478:41;2495:4:1;929:10:13;3329:145:1;:::i;1478:41:23:-;1470:63;;;;-1:-1:-1;;;1470:63:23;;;;;;;:::i;:::-;-1:-1:-1;;;;;1924:18:23::1;;::::0;;;:9:::1;:18;::::0;;;;;;-1:-1:-1;;1902:40:23;::::1;1924:18;::::0;;::::1;1923:19;1902:40;::::0;;1836:113::o;1243:161:9:-;1319:46;1335:7;929:10:13;1358:6:9;1319:15;:46::i;:::-;1375:22;1381:7;1390:6;1375:5;:22::i;2497:59:23:-;1478:41;2495:4:1;929:10:13;3329:145:1;:::i;1478:41:23:-;1470:63;;;;-1:-1:-1;;;1470:63:23;;;;;;;:::i;:::-;2541:8:::1;:6;:8::i;4500:861:16:-:0;4615:13;4642:18;4674:21;4709:15;4738:25;4777:12;4803:27;5066:11;;5081:1;5066:16;;;:39;;;;-1:-1:-1;5086:14:16;;:19;5066:39;5058:73;;;;-1:-1:-1;;;5058:73:16;;10190:2:24;5058:73:16;;;10172:21:24;10229:2;10209:18;;;10202:30;-1:-1:-1;;;10248:18:24;;;10241:51;10309:18;;5058:73:16;9988:345:24;5058:73:16;5193:13;:11;:13::i;:::-;5220:16;:14;:16::i;:::-;5328;;;5312:1;5328:16;;;;;;;;;-1:-1:-1;;;5142:212:16;;;-1:-1:-1;5142:212:16;;-1:-1:-1;5250:13:16;;-1:-1:-1;5285:4:16;;-1:-1:-1;5312:1:16;-1:-1:-1;5328:16:16;-1:-1:-1;5142:212:16;-1:-1:-1;4500:861:16:o;1770:151:0:-;1860:7;1886:18;;;:12;:18;;;;;:28;;1908:5;1886:21;:28::i;:::-;1879:35;1770:151;-1:-1:-1;;;1770:151:0:o;3329:145:1:-;3415:4;3438:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;3438:29:1;;;;;;;;;;;;;;;3329:145::o;2706:102:7:-;2762:13;2794:7;2787:14;;;;;:::i;2631:730:23:-;-1:-1:-1;;;;;3012:13:23;;2836:18;3012:13;;;:6;:13;;;;;:15;;944:66;;2941:5;;2964:7;;2989:5;;3012:15;2836:18;3012:15;;;:::i;:::-;;;;-1:-1:-1;2880:187:23;;;;;;10765:25:24;;;;-1:-1:-1;;;;;10864:15:24;;;10844:18;;;10837:43;10916:15;;;;10896:18;;;10889:43;10948:18;;;10941:34;10991:19;;;10984:35;11035:19;;;11028:35;;;10737:19;;2880:187:23;;;;;;;;;;;;2857:220;;;;;;2836:241;;3112:12;3127:28;3144:10;3127:16;:28::i;:::-;3112:43;;3192:14;3209:41;3234:4;3240:9;3209:24;:41::i;:::-;3192:58;;3277:6;-1:-1:-1;;;;;3268:15:23;:5;-1:-1:-1;;;;;3268:15:23;;3260:53;;;;-1:-1:-1;;;3260:53:23;;11276:2:24;3260:53:23;;;11258:21:24;11315:2;11295:18;;;11288:30;11354:27;11334:18;;;11327:55;11399:18;;3260:53:23;11074:349:24;3260:53:23;3323:31;3332:5;3339:7;3348:5;3323:8;:31::i;:::-;2789:572;;;2631:730;;;;;:::o;6912:427:7:-;7005:4;929:10:13;7005:4:7;7086:25;929:10:13;7103:7:7;7086:9;:25::i;:::-;7059:52;;7149:15;7129:16;:35;;7121:85;;;;-1:-1:-1;;;7121:85:7;;11630:2:24;7121:85:7;;;11612:21:24;11669:2;11649:18;;;11642:30;11708:34;11688:18;;;11681:62;-1:-1:-1;;;11759:18:24;;;11752:35;11804:19;;7121:85:7;11428:401:24;7121:85:7;7240:60;7249:5;7256:7;7284:15;7265:16;:34;7240:8;:60::i;4077:189::-;4156:4;929:10:13;4210:28:7;929:10:13;4227:2:7;4231:6;4210:9;:28::i;1064:369:23:-;3279:19:5;3302:13;;;;;;3301:14;;3347:34;;;;-1:-1:-1;3365:12:5;;3380:1;3365:12;;;;:16;3347:34;3346:108;;;-1:-1:-1;3426:4:5;1713:19:12;:23;;;3387:66:5;;-1:-1:-1;3436:12:5;;;;;:17;3387:66;3325:201;;;;-1:-1:-1;;;3325:201:5;;12036:2:24;3325:201:5;;;12018:21:24;12075:2;12055:18;;;12048:30;12114:34;12094:18;;;12087:62;-1:-1:-1;;;12165:18:24;;;12158:44;12219:19;;3325:201:5;11834:410:24;3325:201:5;3536:12;:16;;-1:-1:-1;;3536:16:5;3551:1;3536:16;;;3562:65;;;;3596:13;:20;;-1:-1:-1;;3596:20:5;;;;;3562:65;1231:26:23::1;1244:4;1250:6;1231:12;:26::i;:::-;1267:35;;;;;;;;;;;;;;-1:-1:-1::0;;;1267:35:23::1;;::::0;::::1;;;;;;;;;;;;;-1:-1:-1::0;;;1267:35:23::1;;::::0;:13:::1;:35::i;:::-;1312:37;2495:4:1;1343:5:23::0;1312:10:::1;:37::i;:::-;1359:30;712:24;1383:5;1359:10;:30::i;:::-;1399:27;1405:5;1412:13;1399:5;:27::i;:::-;3651:14:5::0;3647:99;;;3697:5;3681:21;;-1:-1:-1;;3681:21:5;;;3721:14;;-1:-1:-1;2973:36:24;;3721:14:5;;2961:2:24;2946:18;3721:14:5;;;;;;;3647:99;3269:483;1064:369:23;;;;:::o;2089:140:0:-;2169:7;2195:18;;;:12;:18;;;;;:27;;:25;:27::i;5684:147:1:-;4908:7;4934:12;;;:6;:12;;;;;:22;;;2928:16;2939:4;2928:10;:16::i;:::-;5798:26:::1;5810:4;5816:7;5798:11;:26::i;4324:149:7:-:0;-1:-1:-1;;;;;4439:18:7;;;4413:7;4439:18;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;4324:149::o;3029:213:1:-;3114:4;-1:-1:-1;;;;;;3137:58:1;;-1:-1:-1;;;3137:58:1;;:98;;-1:-1:-1;;;;;;;;;;1168:51:18;;;3199:36:1;1060:166:18;10794:340:7;-1:-1:-1;;;;;10895:19:7;;10887:68;;;;-1:-1:-1;;;10887:68:7;;12650:2:24;10887:68:7;;;12632:21:24;12689:2;12669:18;;;12662:30;12728:34;12708:18;;;12701:62;-1:-1:-1;;;12779:18:24;;;12772:34;12823:19;;10887:68:7;12448:400:24;10887:68:7;-1:-1:-1;;;;;10973:21:7;;10965:68;;;;-1:-1:-1;;;10965:68:7;;13055:2:24;10965:68:7;;;13037:21:24;13094:2;13074:18;;;13067:30;13133:34;13113:18;;;13106:62;-1:-1:-1;;;13184:18:24;;;13177:32;13226:19;;10965:68:7;12853:398:24;10965:68:7;-1:-1:-1;;;;;11044:18:7;;;;;;;:11;:18;;;;;;;;:27;;;;;;;;;;;;;:36;;;11095:32;;1836:25:24;;;11095:32:7;;1809:18:24;11095:32:7;;;;;;;10794:340;;;:::o;11415:411::-;11515:24;11542:25;11552:5;11559:7;11542:9;:25::i;:::-;11515:52;;-1:-1:-1;;11581:16:7;:37;11577:243;;11662:6;11642:16;:26;;11634:68;;;;-1:-1:-1;;;11634:68:7;;13458:2:24;11634:68:7;;;13440:21:24;13497:2;13477:18;;;13470:30;13536:31;13516:18;;;13509:59;13585:18;;11634:68:7;13256:353:24;11634:68:7;11744:51;11753:5;11760:7;11788:6;11769:16;:25;11744:8;:51::i;:::-;11505:321;11415:411;;;:::o;7793:788::-;-1:-1:-1;;;;;7889:18:7;;7881:68;;;;-1:-1:-1;;;7881:68:7;;13816:2:24;7881:68:7;;;13798:21:24;13855:2;13835:18;;;13828:30;13894:34;13874:18;;;13867:62;-1:-1:-1;;;13945:18:24;;;13938:35;13990:19;;7881:68:7;13614:401:24;7881:68:7;-1:-1:-1;;;;;7967:16:7;;7959:64;;;;-1:-1:-1;;;7959:64:7;;14222:2:24;7959:64:7;;;14204:21:24;14261:2;14241:18;;;14234:30;14300:34;14280:18;;;14273:62;-1:-1:-1;;;14351:18:24;;;14344:33;14394:19;;7959:64:7;14020:399:24;7959:64:7;8034:38;8055:4;8061:2;8065:6;8034:20;:38::i;:::-;-1:-1:-1;;;;;8105:15:7;;8083:19;8105:15;;;:9;:15;;;;;;8138:21;;;;8130:72;;;;-1:-1:-1;;;8130:72:7;;14626:2:24;8130:72:7;;;14608:21:24;14665:2;14645:18;;;14638:30;14704:34;14684:18;;;14677:62;-1:-1:-1;;;14755:18:24;;;14748:36;14801:19;;8130:72:7;14424:402:24;8130:72:7;-1:-1:-1;;;;;8236:15:7;;;;;;;:9;:15;;;;;;8254:20;;;8236:38;;8451:13;;;;;;;;;;:23;;;;;;8500:26;;;;;;8268:6;1836:25:24;;1824:2;1809:18;;1690:177;8500:26:7;;;;;;;;8537:37;5259:145:1;3768:103;3834:30;3845:4;929:10:13;3834::1;:30::i;2317:166:0:-;2404:31;2421:4;2427:7;2404:16;:31::i;:::-;2445:18;;;;:12;:18;;;;;:31;;2468:7;2445:22;:31::i;2572:171::-;2660:32;2678:4;2684:7;2660:17;:32::i;:::-;2702:18;;;;:12;:18;;;;;:34;;2728:7;2702:25;:34::i;2676:117:6:-;1729:16;:14;:16::i;:::-;2734:7:::1;:15:::0;;-1:-1:-1;;2734:15:6::1;::::0;;2764:22:::1;929:10:13::0;2773:12:6::1;2764:22;::::0;-1:-1:-1;;;;;3560:32:24;;;3542:51;;3530:2;3515:18;2764:22:6::1;;;;;;;2676:117::o:0;8857:535:7:-;-1:-1:-1;;;;;8940:21:7;;8932:65;;;;-1:-1:-1;;;8932:65:7;;15033:2:24;8932:65:7;;;15015:21:24;15072:2;15052:18;;;15045:30;15111:33;15091:18;;;15084:61;15162:18;;8932:65:7;14831:355:24;8932:65:7;9008:49;9037:1;9041:7;9050:6;9008:20;:49::i;:::-;9084:6;9068:12;;:22;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;9236:18:7;;;;;;:9;:18;;;;;;;;:28;;;;;;9289:37;1836:25:24;;;9289:37:7;;1809:18:24;9289:37:7;;;;;;;6368:214:1;;:::o;9712:659:7:-;-1:-1:-1;;;;;9795:21:7;;9787:67;;;;-1:-1:-1;;;9787:67:7;;15393:2:24;9787:67:7;;;15375:21:24;15432:2;15412:18;;;15405:30;15471:34;15451:18;;;15444:62;-1:-1:-1;;;15522:18:24;;;15515:31;15563:19;;9787:67:7;15191:397:24;9787:67:7;9865:49;9886:7;9903:1;9907:6;9865:20;:49::i;:::-;-1:-1:-1;;;;;9950:18:7;;9925:22;9950:18;;;:9;:18;;;;;;9986:24;;;;9978:71;;;;-1:-1:-1;;;9978:71:7;;15795:2:24;9978:71:7;;;15777:21:24;15834:2;15814:18;;;15807:30;15873:34;15853:18;;;15846:62;-1:-1:-1;;;15924:18:24;;;15917:32;15966:19;;9978:71:7;15593:398:24;9978:71:7;-1:-1:-1;;;;;10083:18:7;;;;;;:9;:18;;;;;;;;10104:23;;;10083:44;;10220:12;:22;;;;;;;10268:37;1836:25:24;;;10083:18:7;;;10268:37;;1809:18:24;10268:37:7;;;;;;;5259:145:1;;;:::o;2429:115:6:-;1482:19;:17;:19::i;:::-;2488:7:::1;:14:::0;;-1:-1:-1;;2488:14:6::1;2498:4;2488:14;::::0;;2517:20:::1;2524:12;929:10:13::0;;850:96;5585:98:16;5639:13;5671:5;5664:12;;;;;:::i;5910:104::-;5967:13;5999:8;5992:15;;;;;:::i;9574:156:22:-;9648:7;9698:22;9702:3;9714:5;9698:3;:22::i;4236:176:16:-;4313:7;4339:66;4372:20;:18;:20::i;:::-;4394:10;8569:4:15;8563:11;-1:-1:-1;;;8587:23:15;;8639:4;8630:14;;8623:39;;;;8691:4;8682:14;;8675:34;8745:4;8730:20;;;8369:397;3683:227;3761:7;3781:17;3800:18;3822:27;3833:4;3839:9;3822:10;:27::i;:::-;3780:69;;;;3859:18;3871:5;3859:11;:18::i;:::-;-1:-1:-1;3894:9:15;3683:227;-1:-1:-1;;;3683:227:15:o;2118:147:7:-;5374:13:5;;;;;;;5366:69;;;;-1:-1:-1;;;5366:69:5;;;;;;;:::i;:::-;2220:38:7::1;2243:5;2250:7;2220:22;:38::i;2798:147:16:-:0;5374:13:5;;;;;;;5366:69;;;;-1:-1:-1;;;5366:69:5;;;;;;;:::i;:::-;2900:38:16::1;2924:4;2930:7;2900:23;:38::i;7267:110:1:-:0;7345:25;7356:4;7362:7;7345:10;:25::i;9117:115:22:-;9180:7;9206:19;9214:3;4556:18;;4474:107;1557:273:23;-1:-1:-1;;;;;1740:15:23;;;;;;:9;:15;;;;;;;;1739:16;1731:38;;;;-1:-1:-1;;;1731:38:23;;;;;;;:::i;:::-;1779:44;1806:4;1812:2;1816:6;1779:26;:44::i;4152:501:1:-;4240:22;4248:4;4254:7;4240;:22::i;:::-;4235:412;;4423:39;4454:7;4423:30;:39::i;:::-;4533:49;4572:4;4579:2;4533:30;:49::i;:::-;4330:274;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;4330:274:1;;;;;;;;;;-1:-1:-1;;;4278:358:1;;;;;;;:::i;7917:233::-;8000:22;8008:4;8014:7;8000;:22::i;:::-;7995:149;;8038:12;;;;:6;:12;;;;;;;;-1:-1:-1;;;;;8038:29:1;;;;;;;;;:36;;-1:-1:-1;;8038:36:1;8070:4;8038:36;;;8120:12;929:10:13;;850:96;8120:12:1;-1:-1:-1;;;;;8093:40:1;8111:7;-1:-1:-1;;;;;8093:40:1;8105:4;8093:40;;;;;;;;;;7917:233;;:::o;8316:150:22:-;8386:4;8409:50;8414:3;-1:-1:-1;;;;;8434:23:22;;8409:4;:50::i;8321:234:1:-;8404:22;8412:4;8418:7;8404;:22::i;:::-;8400:149;;;8474:5;8442:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;8442:29:1;;;;;;;;;;:37;;-1:-1:-1;;8442:37:1;;;8498:40;929:10:13;;8442:12:1;;8498:40;;8474:5;8498:40;8321:234;;:::o;8634:156:22:-;8707:4;8730:53;8738:3;-1:-1:-1;;;;;8758:23:22;;8730:7;:53::i;2188:106:6:-;1928:7;;;;2246:41;;;;-1:-1:-1;;;2246:41:6;;17427:2:24;2246:41:6;;;17409:21:24;17466:2;17446:18;;;17439:30;-1:-1:-1;;;17485:18:24;;;17478:50;17545:18;;2246:41:6;17225:344:24;2010:106:6;1928:7;;;;2079:9;2071:38;;;;-1:-1:-1;;;2071:38:6;;17776:2:24;2071:38:6;;;17758:21:24;17815:2;17795:18;;;17788:30;-1:-1:-1;;;17834:18:24;;;17827:46;17890:18;;2071:38:6;17574:340:24;4923:118:22;4990:7;5016:3;:11;;5028:5;5016:18;;;;;;;;:::i;:::-;;;;;;;;;5009:25;;4923:118;;;;:::o;3304:109:16:-;3357:7;3383:23;:21;:23::i;:::-;3376:30;;3304:109;:::o;2167:730:15:-;2248:7;2257:12;2285:9;:16;2305:2;2285:22;2281:610;;2621:4;2606:20;;2600:27;2670:4;2655:20;;2649:27;2727:4;2712:20;;2706:27;2323:9;2698:36;2768:25;2779:4;2698:36;2600:27;2649;2768:10;:25::i;:::-;2761:32;;;;;;;;;2281:610;-1:-1:-1;2840:1:15;;-1:-1:-1;2844:35:15;2281:610;2167:730;;;;;:::o;592:511::-;669:20;660:5;:29;;;;;;;;:::i;:::-;;656:441;;592:511;:::o;656:441::-;765:29;756:5;:38;;;;;;;;:::i;:::-;;752:345;;810:34;;-1:-1:-1;;;810:34:15;;18385:2:24;810:34:15;;;18367:21:24;18424:2;18404:18;;;18397:30;18463:26;18443:18;;;18436:54;18507:18;;810:34:15;18183:348:24;752:345:15;874:35;865:5;:44;;;;;;;;:::i;:::-;;861:236;;925:41;;-1:-1:-1;;;925:41:15;;18738:2:24;925:41:15;;;18720:21:24;18777:2;18757:18;;;18750:30;18816:33;18796:18;;;18789:61;18867:18;;925:41:15;18536:355:24;861:236:15;996:30;987:5;:39;;;;;;;;:::i;:::-;;983:114;;1042:44;;-1:-1:-1;;;1042:44:15;;19098:2:24;1042:44:15;;;19080:21:24;19137:2;19117:18;;;19110:30;19176:34;19156:18;;;19149:62;-1:-1:-1;;;19227:18:24;;;19220:32;19269:19;;1042:44:15;18896:398:24;2271:159:7;5374:13:5;;;;;;;5366:69;;;;-1:-1:-1;;;5366:69:5;;;;;;;:::i;:::-;2383:5:7::1;:13;2391:5:::0;2383;:13:::1;:::i;:::-;-1:-1:-1::0;2406:7:7::1;:17;2416:7:::0;2406;:17:::1;:::i;2951:267:16:-:0;5374:13:5;;;;;;;5366:69;;;;-1:-1:-1;;;5366:69:5;;;;;;;:::i;:::-;3063:5:16::1;:12;3071:4:::0;3063:5;:12:::1;:::i;:::-;-1:-1:-1::0;3085:8:16::1;:18;3096:7:::0;3085:8;:18:::1;:::i;:::-;-1:-1:-1::0;;3182:1:16::1;3168:11;:15:::0;;;3193:14:::1;:18:::0;-1:-1:-1;2951:267:16:o;1353:234:10:-;1928:7:6;;;;1524:9:10;1516:64;;;;-1:-1:-1;;;1516:64:10;;21705:2:24;1516:64:10;;;21687:21:24;21744:2;21724:18;;;21717:30;21783:34;21763:18;;;21756:62;-1:-1:-1;;;21834:18:24;;;21827:40;21884:19;;1516:64:10;21503:406:24;2473:149:14;2531:13;2563:52;-1:-1:-1;;;;;2575:22:14;;376:2;1884:437;1959:13;1984:19;2016:10;2020:6;2016:1;:10;:::i;:::-;:14;;2029:1;2016:14;:::i;:::-;2006:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;2006:25:14;;1984:47;;-1:-1:-1;;;2041:6:14;2048:1;2041:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;2041:15:14;;;;;;;;;-1:-1:-1;;;2066:6:14;2073:1;2066:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;2066:15:14;;;;;;;;-1:-1:-1;2096:9:14;2108:10;2112:6;2108:1;:10;:::i;:::-;:14;;2121:1;2108:14;:::i;:::-;2096:26;;2091:128;2128:1;2124;:5;2091:128;;;-1:-1:-1;;;2171:5:14;2179:3;2171:11;2162:21;;;;;;;:::i;:::-;;;;2150:6;2157:1;2150:9;;;;;;;;:::i;:::-;;;;:33;-1:-1:-1;;;;;2150:33:14;;;;;;;;-1:-1:-1;2207:1:14;2197:11;;;;;2131:3;;;:::i;:::-;;;2091:128;;;-1:-1:-1;2236:10:14;;2228:55;;;;-1:-1:-1;;;2228:55:14;;22430:2:24;2228:55:14;;;22412:21:24;;;22449:18;;;22442:30;22508:34;22488:18;;;22481:62;22560:18;;2228:55:14;22228:356:24;2225:404:22;2288:4;4362:19;;;:12;;;:19;;;;;;2304:319;;-1:-1:-1;2346:23:22;;;;;;;;:11;:23;;;;;;;;;;;;;2526:18;;2504:19;;;:12;;;:19;;;;;;:40;;;;2558:11;;2304:319;-1:-1:-1;2607:5:22;2600:12;;2797:1388;2863:4;3000:19;;;:12;;;:19;;;;;;3034:15;;3030:1149;;3403:21;3427:14;3440:1;3427:10;:14;:::i;:::-;3475:18;;3403:38;;-1:-1:-1;3455:17:22;;3475:22;;3496:1;;3475:22;:::i;:::-;3455:42;;3529:13;3516:9;:26;3512:398;;3562:17;3582:3;:11;;3594:9;3582:22;;;;;;;;:::i;:::-;;;;;;;;;3562:42;;3733:9;3704:3;:11;;3716:13;3704:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;3816:23;;;:12;;;:23;;;;;:36;;;3512:398;3988:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;4080:3;:12;;:19;4093:5;4080:19;;;;;;;;;;;4073:26;;;4121:4;4114:11;;;;;;;3030:1149;4163:5;4156:12;;;;;3419:192:16;3474:7;1913:95;3533:17;:15;:17::i;:::-;3552:20;:18;:20::i;:::-;3510:93;;;;;;23113:25:24;;;;23154:18;;23147:34;;;;23197:18;;;23190:34;3574:13:16;23240:18:24;;;23233:34;3597:4:16;23283:19:24;;;23276:61;23085:19;;3510:93:16;;;;;;;;;;;;3500:104;;;;;;3493:111;;3419:192;:::o;5031:1456:15:-;5119:7;;6043:66;6030:79;;6026:161;;;-1:-1:-1;6141:1:15;;-1:-1:-1;6145:30:15;6125:51;;6026:161;6298:24;;;6281:14;6298:24;;;;;;;;;23575:25:24;;;23648:4;23636:17;;23616:18;;;23609:45;;;;23670:18;;;23663:34;;;23713:18;;;23706:34;;;6298:24:15;;23547:19:24;;6298:24:15;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;6298:24:15;;-1:-1:-1;;6298:24:15;;;-1:-1:-1;;;;;;;6336:20:15;;6332:101;;6388:1;6392:29;6372:50;;;;;;;6332:101;6451:6;-1:-1:-1;6459:20:15;;-1:-1:-1;5031:1456:15;;;;;;;;:::o;6229:630:16:-;6279:7;6298:18;6319:13;:11;:13::i;:::-;6346:18;;6298:34;;-1:-1:-1;6346:22:16;6342:511;;6391:22;;;;;;;;6229:630;-1:-1:-1;6229:630:16:o;6342:511::-;6688:11;;6717:15;;6713:130;;6759:10;6229:630;-1:-1:-1;;6229:630:16:o;6713:130::-;6815:13;6808:20;;;;6229:630;:::o;7080:666::-;7133:7;7152:21;7176:16;:14;:16::i;:::-;7206:21;;7152:40;;-1:-1:-1;7206:25:16;7202:538;;7254:25;;;;;;;;7080:666;-1:-1:-1;7080:666:16:o;7202:538::-;7566:14;;7598:18;;7594:136;;7643:13;7080:666;-1:-1:-1;;7080:666:16:o;14:286:24:-;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:24;;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:24;721:16;;714:27;497:250::o;752:271::-;794:3;832:5;826:12;859:6;854:3;847:19;875:76;944:6;937:4;932:3;928:14;921:4;914:5;910:16;875:76;:::i;:::-;1005:2;984:15;-1:-1:-1;;980:29:24;971:39;;;;1012:4;967:50;;752:271;-1:-1:-1;;752:271:24:o;1028:220::-;1177:2;1166:9;1159:21;1140:4;1197:45;1238:2;1227:9;1223:18;1215:6;1197:45;:::i;1253:173::-;1321:20;;-1:-1:-1;;;;;1370:31:24;;1360:42;;1350:70;;1416:1;1413;1406:12;1431:254;1499:6;1507;1560:2;1548:9;1539:7;1535:23;1531:32;1528:52;;;1576:1;1573;1566:12;1528:52;1599:29;1618:9;1599:29;:::i;:::-;1589:39;1675:2;1660:18;;;;1647:32;;-1:-1:-1;;;1431:254:24:o;1872:328::-;1949:6;1957;1965;2018:2;2006:9;1997:7;1993:23;1989:32;1986:52;;;2034:1;2031;2024:12;1986:52;2057:29;2076:9;2057:29;:::i;:::-;2047:39;;2105:38;2139:2;2128:9;2124:18;2105:38;:::i;:::-;2095:48;;2190:2;2179:9;2175:18;2162:32;2152:42;;1872:328;;;;;:::o;2205:180::-;2264:6;2317:2;2305:9;2296:7;2292:23;2288:32;2285:52;;;2333:1;2330;2323:12;2285:52;-1:-1:-1;2356:23:24;;2205:180;-1:-1:-1;2205:180:24:o;2572:254::-;2640:6;2648;2701:2;2689:9;2680:7;2676:23;2672:32;2669:52;;;2717:1;2714;2707:12;2669:52;2753:9;2740:23;2730:33;;2782:38;2816:2;2805:9;2801:18;2782:38;:::i;:::-;2772:48;;2572:254;;;;;:::o;3020:186::-;3079:6;3132:2;3120:9;3111:7;3107:23;3103:32;3100:52;;;3148:1;3145;3138:12;3100:52;3171:29;3190:9;3171:29;:::i;3604:1259::-;4010:3;4005;4001:13;3993:6;3989:26;3978:9;3971:45;3952:4;4035:2;4073:3;4068:2;4057:9;4053:18;4046:31;4100:46;4141:3;4130:9;4126:19;4118:6;4100:46;:::i;:::-;4194:9;4186:6;4182:22;4177:2;4166:9;4162:18;4155:50;4228:33;4254:6;4246;4228:33;:::i;:::-;4292:2;4277:18;;4270:34;;;-1:-1:-1;;;;;4341:32:24;;4335:3;4320:19;;4313:61;4361:3;4390:19;;4383:35;;;4455:22;;;4449:3;4434:19;;4427:51;4527:13;;4549:22;;;4625:15;;;;-1:-1:-1;4587:15:24;;;;-1:-1:-1;4668:169:24;4682:6;4679:1;4676:13;4668:169;;;4743:13;;4731:26;;4812:15;;;;4777:12;;;;4704:1;4697:9;4668:169;;;-1:-1:-1;4854:3:24;;3604:1259;-1:-1:-1;;;;;;;;;;;;3604:1259:24:o;4868:248::-;4936:6;4944;4997:2;4985:9;4976:7;4972:23;4968:32;4965:52;;;5013:1;5010;5003:12;4965:52;-1:-1:-1;;5036:23:24;;;5106:2;5091:18;;;5078:32;;-1:-1:-1;4868:248:24:o;5121:127::-;5182:10;5177:3;5173:20;5170:1;5163:31;5213:4;5210:1;5203:15;5237:4;5234:1;5227:15;5253:631;5317:5;5347:18;5388:2;5380:6;5377:14;5374:40;;;5394:18;;:::i;:::-;5469:2;5463:9;5437:2;5523:15;;-1:-1:-1;;5519:24:24;;;5545:2;5515:33;5511:42;5499:55;;;5569:18;;;5589:22;;;5566:46;5563:72;;;5615:18;;:::i;:::-;5655:10;5651:2;5644:22;5684:6;5675:15;;5714:6;5706;5699:22;5754:3;5745:6;5740:3;5736:16;5733:25;5730:45;;;5771:1;5768;5761:12;5730:45;5821:6;5816:3;5809:4;5801:6;5797:17;5784:44;5876:1;5869:4;5860:6;5852;5848:19;5844:30;5837:41;;;;5253:631;;;;;:::o;5889:735::-;5993:6;6001;6009;6017;6025;6078:3;6066:9;6057:7;6053:23;6049:33;6046:53;;;6095:1;6092;6085:12;6046:53;6118:29;6137:9;6118:29;:::i;:::-;6108:39;;6166:38;6200:2;6189:9;6185:18;6166:38;:::i;:::-;6156:48;;6251:2;6240:9;6236:18;6223:32;6213:42;;6302:2;6291:9;6287:18;6274:32;6264:42;;6357:3;6346:9;6342:19;6329:33;6385:18;6377:6;6374:30;6371:50;;;6417:1;6414;6407:12;6371:50;6440:22;;6493:4;6485:13;;6481:27;-1:-1:-1;6471:55:24;;6522:1;6519;6512:12;6471:55;6545:73;6610:7;6605:2;6592:16;6587:2;6583;6579:11;6545:73;:::i;:::-;6535:83;;;5889:735;;;;;;;;:::o;6629:221::-;6672:5;6725:3;6718:4;6710:6;6706:17;6702:27;6692:55;;6743:1;6740;6733:12;6692:55;6765:79;6840:3;6831:6;6818:20;6811:4;6803:6;6799:17;6765:79;:::i;6855:686::-;6961:6;6969;6977;6985;7038:3;7026:9;7017:7;7013:23;7009:33;7006:53;;;7055:1;7052;7045:12;7006:53;7095:9;7082:23;7124:18;7165:2;7157:6;7154:14;7151:34;;;7181:1;7178;7171:12;7151:34;7204:50;7246:7;7237:6;7226:9;7222:22;7204:50;:::i;:::-;7194:60;;7307:2;7296:9;7292:18;7279:32;7263:48;;7336:2;7326:8;7323:16;7320:36;;;7352:1;7349;7342:12;7320:36;;7375:52;7419:7;7408:8;7397:9;7393:24;7375:52;:::i;:::-;7365:62;;;7474:2;7463:9;7459:18;7446:32;7436:42;;7497:38;7531:2;7520:9;7516:18;7497:38;:::i;:::-;7487:48;;6855:686;;;;;;;:::o;7546:260::-;7614:6;7622;7675:2;7663:9;7654:7;7650:23;7646:32;7643:52;;;7691:1;7688;7681:12;7643:52;7714:29;7733:9;7714:29;:::i;:::-;7704:39;;7762:38;7796:2;7785:9;7781:18;7762:38;:::i;7811:380::-;7890:1;7886:12;;;;7933;;;7954:61;;8008:4;8000:6;7996:17;7986:27;;7954:61;8061:2;8053:6;8050:14;8030:18;8027:38;8024:161;;8107:10;8102:3;8098:20;8095:1;8088:31;8142:4;8139:1;8132:15;8170:4;8167:1;8160:15;8024:161;;7811:380;;;:::o;8612:127::-;8673:10;8668:3;8664:20;8661:1;8654:31;8704:4;8701:1;8694:15;8728:4;8725:1;8718:15;8744:125;8809:9;;;8830:10;;;8827:36;;;8843:18;;:::i;8874:332::-;9076:2;9058:21;;;9115:1;9095:18;;;9088:29;-1:-1:-1;;;9148:2:24;9133:18;;9126:39;9197:2;9182:18;;8874:332::o;10338:135::-;10377:3;10398:17;;;10395:43;;10418:18;;:::i;:::-;-1:-1:-1;10465:1:24;10454:13;;10338:135::o;15996:407::-;16198:2;16180:21;;;16237:2;16217:18;;;16210:30;16276:34;16271:2;16256:18;;16249:62;-1:-1:-1;;;16342:2:24;16327:18;;16320:41;16393:3;16378:19;;15996:407::o;16408:812::-;16819:25;16814:3;16807:38;16789:3;16874:6;16868:13;16890:75;16958:6;16953:2;16948:3;16944:12;16937:4;16929:6;16925:17;16890:75;:::i;:::-;-1:-1:-1;;;17024:2:24;16984:16;;;17016:11;;;17009:40;17074:13;;17096:76;17074:13;17158:2;17150:11;;17143:4;17131:17;;17096:76;:::i;:::-;17192:17;17211:2;17188:26;;16408:812;-1:-1:-1;;;;16408:812:24:o;17919:127::-;17980:10;17975:3;17971:20;17968:1;17961:31;18011:4;18008:1;18001:15;18035:4;18032:1;18025:15;18051:127;18112:10;18107:3;18103:20;18100:1;18093:31;18143:4;18140:1;18133:15;18167:4;18164:1;18157:15;19425:545;19527:2;19522:3;19519:11;19516:448;;;19563:1;19588:5;19584:2;19577:17;19633:4;19629:2;19619:19;19703:2;19691:10;19687:19;19684:1;19680:27;19674:4;19670:38;19739:4;19727:10;19724:20;19721:47;;;-1:-1:-1;19762:4:24;19721:47;19817:2;19812:3;19808:12;19805:1;19801:20;19795:4;19791:31;19781:41;;19872:82;19890:2;19883:5;19880:13;19872:82;;;19935:17;;;19916:1;19905:13;19872:82;;;19876:3;;;19425:545;;;:::o;20146:1352::-;20272:3;20266:10;20299:18;20291:6;20288:30;20285:56;;;20321:18;;:::i;:::-;20350:97;20440:6;20400:38;20432:4;20426:11;20400:38;:::i;:::-;20394:4;20350:97;:::i;:::-;20502:4;;20566:2;20555:14;;20583:1;20578:663;;;;21285:1;21302:6;21299:89;;;-1:-1:-1;21354:19:24;;;21348:26;21299:89;-1:-1:-1;;20103:1:24;20099:11;;;20095:24;20091:29;20081:40;20127:1;20123:11;;;20078:57;21401:81;;20548:944;;20578:663;19372:1;19365:14;;;19409:4;19396:18;;-1:-1:-1;;20614:20:24;;;20732:236;20746:7;20743:1;20740:14;20732:236;;;20835:19;;;20829:26;20814:42;;20927:27;;;;20895:1;20883:14;;;;20762:19;;20732:236;;;20736:3;20996:6;20987:7;20984:19;20981:201;;;21057:19;;;21051:26;-1:-1:-1;;21140:1:24;21136:14;;;21152:3;21132:24;21128:37;21124:42;21109:58;21094:74;;20981:201;-1:-1:-1;;;;;21228:1:24;21212:14;;;21208:22;21195:36;;-1:-1:-1;20146:1352:24:o;21914:168::-;21987:9;;;22018;;22035:15;;;22029:22;;22015:37;22005:71;;22056:18;;:::i;22087:136::-;22126:3;22154:5;22144:39;;22163:18;;:::i;:::-;-1:-1:-1;;;22199:18:24;;22087:136::o;22589:128::-;22656:9;;;22677:11;;;22674:37;;;22691:18;;:::i;22722:127::-;22783:10;22778:3;22774:20;22771:1;22764:31;22814:4;22811:1;22804:15;22838:4;22835:1;22828:15

ipfs://716e94fbabb047a39386f5a937783585ac44dad8988a646da265fe5704c04dd5