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.25;

/**
 * This contract is a programmatic delegate for the ENS DAO. It allows anyone
 * who has been given access to it to "veto" an executable vote by voting No on
 * it, using all the votes delegated to this contract.
 *
 * In order to be given access, delegates must agree to a pledge to only use
 * this veto power to prevent a governance attack against the DAO, or to veto a
 * vote that would violate the ENS constitution. The full pledge can be found here:
 *
 * https://ens.mypinata.cloud/ipfs/QmbCNmTtMgjVXsqirZRy8tZbq3zh92g1g6PE3V4QGpNJ1b
 */

import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v4.9/contracts/governance/IGovernor.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v5.0/contracts/access/AccessControl.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v5.0/contracts/utils/cryptography/SignatureChecker.sol";
import "https://github.com/ensdomains/ens-contracts/blob/21736916300b26cb8ea1802dbf6c9ff054adaeab/contracts/reverseRegistrar/ReverseClaimer.sol";
import "https://github.com/OpenZeppelin/openzeppelin-contracts/blob/release-v5.0/contracts/utils/cryptography/MessageHashUtils.sol";

contract Veto is AccessControl, ReverseClaimer {
    IGovernor public governor;
    string public pledge;
    bytes32 public constant VETO_CANDIDATE_ROLE = keccak256("VETO_CANDIDATE_ROLE");
    bytes32 public constant VETO_ROLE = keccak256("VETO_ROLE");

    enum VoteType {
        Against,
        For,
        Abstain
    }
    
    error InvalidSignature();
    error AccessDenied();

    event NewGovernor(address governor);

    /**
     * @dev Constructor
     * @param ens The ENS registry, used to set the reverse record for this contract.
     * @param _governor The OZ governor contract to target.
     * @param _pledge The pledge that veto candidates must sign to gain access.
     */
    constructor(ENS ens, address _governor, string memory _pledge) ReverseClaimer(ens, msg.sender) {
        governor = IGovernor(_governor);
        emit NewGovernor(_governor);
        _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
        pledge = _pledge;
    }

    /**
     * @dev Updates the governor address.
     * @param _governor The address of the new governor contract.
     */
    function setGovernor(address _governor) external onlyRole(DEFAULT_ADMIN_ROLE) {
        governor = IGovernor(_governor);
        emit NewGovernor(_governor);        
    }

    /**
     * @dev Enables a candidate to accept veto power by signing the pledge.
     * @param signature A signature over the message in `pledge`.
     */
    function enableVeto(bytes memory signature) external onlyRole(VETO_CANDIDATE_ROLE) {
        if(!SignatureChecker.isValidSignatureNow(msg.sender, MessageHashUtils.toEthSignedMessageHash(bytes(pledge)), signature)) {
            revert InvalidSignature();
        }
        _grantRole(VETO_ROLE, msg.sender);
        _revokeRole(VETO_CANDIDATE_ROLE, msg.sender);
    }

    /**
     * @dev Enables a vetoer to veto the specified proposal.
     * @param proposalId The proposal ID of the proposal to veto.
     */
    function castVote(uint256 proposalId) public virtual onlyRole(VETO_ROLE) returns (uint256 balance) {
        return governor.castVote(proposalId, uint8(VoteType.Against));
    }

    /**
     * @dev Enables a vetoer to veto the specified proposal.
     * @param proposalId The proposal ID of the proposal to veto.
     * @param reason An explanation of why the vote is being vetoed.
     */
    function castVoteWithReason(
        uint256 proposalId,
        string calldata reason
    ) public virtual onlyRole(VETO_ROLE) returns (uint256 balance) {
        return governor.castVoteWithReason(proposalId, uint8(VoteType.Against), reason);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/MessageHashUtils.sol)

pragma solidity ^0.8.20;

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

/**
 * @dev Signature message hash utilities for producing digests to be consumed by {ECDSA} recovery or signing.
 *
 * The library provides methods for generating a hash of a message that conforms to the
 * https://eips.ethereum.org/EIPS/eip-191[EIP 191] and https://eips.ethereum.org/EIPS/eip-712[EIP 712]
 * specifications.
 */
library MessageHashUtils {
    /**
     * @dev Returns the keccak256 digest of an EIP-191 signed data with version
     * `0x45` (`personal_sign` messages).
     *
     * The digest is calculated by prefixing a bytes32 `messageHash` with
     * `"\x19Ethereum Signed Message:\n32"` and hashing the result. It corresponds with the
     * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.
     *
     * NOTE: The `messageHash` parameter is intended to be the result of hashing a raw message with
     * keccak256, although any bytes32 value can be safely used because the final digest will
     * be re-hashed.
     *
     * See {ECDSA-recover}.
     */
    function toEthSignedMessageHash(bytes32 messageHash) internal pure returns (bytes32 digest) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, "\x19Ethereum Signed Message:\n32") // 32 is the bytes-length of messageHash
            mstore(0x1c, messageHash) // 0x1c (28) is the length of the prefix
            digest := keccak256(0x00, 0x3c) // 0x3c is the length of the prefix (0x1c) + messageHash (0x20)
        }
    }

    /**
     * @dev Returns the keccak256 digest of an EIP-191 signed data with version
     * `0x45` (`personal_sign` messages).
     *
     * The digest is calculated by prefixing an arbitrary `message` with
     * `"\x19Ethereum Signed Message:\n" + len(message)` and hashing the result. It corresponds with the
     * hash signed when using the https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`] JSON-RPC method.
     *
     * See {ECDSA-recover}.
     */
    function toEthSignedMessageHash(bytes memory message) internal pure returns (bytes32) {
        return
            keccak256(bytes.concat("\x19Ethereum Signed Message:\n", bytes(Strings.toString(message.length)), message));
    }

    /**
     * @dev Returns the keccak256 digest of an EIP-191 signed data with version
     * `0x00` (data with intended validator).
     *
     * The digest is calculated by prefixing an arbitrary `data` with `"\x19\x00"` and the intended
     * `validator` address. Then hashing the result.
     *
     * See {ECDSA-recover}.
     */
    function toDataWithIntendedValidatorHash(address validator, bytes memory data) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked(hex"19_00", validator, data));
    }

    /**
     * @dev Returns the keccak256 digest of an EIP-712 typed data (EIP-191 version `0x01`).
     *
     * The digest is calculated from a `domainSeparator` and a `structHash`, by prefixing them with
     * `\x19\x01` and hashing the result. It corresponds to the hash signed by the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`] JSON-RPC method as part of EIP-712.
     *
     * See {ECDSA-recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32 digest) {
        /// @solidity memory-safe-assembly
        assembly {
            let ptr := mload(0x40)
            mstore(ptr, hex"19_01")
            mstore(add(ptr, 0x02), domainSeparator)
            mstore(add(ptr, 0x22), structHash)
            digest := keccak256(ptr, 0x42)
        }
    }
}

//SPDX-License-Identifier: MIT
pragma solidity >=0.8.17 <0.9.0;

import {ENS} from "../registry/ENS.sol";
import {IReverseRegistrar} from "../reverseRegistrar/IReverseRegistrar.sol";

contract ReverseClaimer {
    bytes32 constant ADDR_REVERSE_NODE =
        0x91d1777781884d03a6757a803996e38de2a42967fb37eeaca72729271025a9e2;

    constructor(ENS ens, address claimant) {
        IReverseRegistrar reverseRegistrar = IReverseRegistrar(
            ens.owner(ADDR_REVERSE_NODE)
        );
        reverseRegistrar.claim(claimant);
    }
}

// SPDX-License-Identifier: MIT
// OpenZeppelin Contracts (last updated v5.0.0) (utils/cryptography/SignatureChecker.sol)

pragma solidity ^0.8.20;

import {ECDSA} from "./ECDSA.sol";
import {IERC1271} from "../../interfaces/IERC1271.sol";

/**
 * @dev Signature verification helper that can be used instead of `ECDSA.recover` to seamlessly support both ECDSA
 * signatures from externally owned accounts (EOAs) as well as ERC1271 signatures from smart contract wallets like
 * Argent and Safe Wallet (previously Gnosis Safe).
 */
library SignatureChecker {
    /**
     * @dev Checks if a signature is valid for a given signer and data hash. If the signer is a smart contract, the
     * signature is validated against that smart contract using ERC1271, otherwise it's validated using `ECDSA.recover`.
     *
     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus
     * change through time. It could return true at block N and false at block N+1 (or the opposite).
     */
    function isValidSignatureNow(address signer, bytes32 hash, bytes memory signature) internal view returns (bool) {
        (address recovered, ECDSA.RecoverError error, ) = ECDSA.tryRecover(hash, signature);
        return
            (error == ECDSA.RecoverError.NoError && recovered == signer) ||
            isValidERC1271SignatureNow(signer, hash, signature);
    }

    /**
     * @dev Checks if a signature is valid for a given signer and data hash. The signature is validated
     * against the signer smart contract using ERC1271.
     *
     * NOTE: Unlike ECDSA signatures, contract signatures are revocable, and the outcome of this function can thus
     * change through time. It could return true at block N and false at block N+1 (or the opposite).
     */
    function isValidERC1271SignatureNow(
        address signer,
        bytes32 hash,
        bytes memory signature
    ) internal view returns (bool) {
        (bool success, bytes memory result) = signer.staticcall(
            abi.encodeCall(IERC1271.isValidSignature, (hash, signature))
        );
        return (success &&
            result.length >= 32 &&
            abi.decode(result, (bytes32)) == bytes32(IERC1271.isValidSignature.selector));
    }
}

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

pragma solidity ^0.8.20;

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

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

    mapping(bytes32 role => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

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

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

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

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

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

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

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

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

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

        _revokeRole(role, callerConfirmation);
    }

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

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

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

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

pragma solidity ^0.8.20;

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

/**
 * @dev Interface of the {Governor} core.
 */
interface IGovernor is IERC165, IERC6372 {
    enum ProposalState {
        Pending,
        Active,
        Canceled,
        Defeated,
        Succeeded,
        Queued,
        Expired,
        Executed
    }

    /**
     * @dev Empty proposal or a mismatch between the parameters length for a proposal call.
     */
    error GovernorInvalidProposalLength(uint256 targets, uint256 calldatas, uint256 values);

    /**
     * @dev The vote was already cast.
     */
    error GovernorAlreadyCastVote(address voter);

    /**
     * @dev Token deposits are disabled in this contract.
     */
    error GovernorDisabledDeposit();

    /**
     * @dev The `account` is not a proposer.
     */
    error GovernorOnlyProposer(address account);

    /**
     * @dev The `account` is not the governance executor.
     */
    error GovernorOnlyExecutor(address account);

    /**
     * @dev The `proposalId` doesn't exist.
     */
    error GovernorNonexistentProposal(uint256 proposalId);

    /**
     * @dev The current state of a proposal is not the required for performing an operation.
     * The `expectedStates` is a bitmap with the bits enabled for each ProposalState enum position
     * counting from right to left.
     *
     * NOTE: If `expectedState` is `bytes32(0)`, the proposal is expected to not be in any state (i.e. not exist).
     * This is the case when a proposal that is expected to be unset is already initiated (the proposal is duplicated).
     *
     * See {Governor-_encodeStateBitmap}.
     */
    error GovernorUnexpectedProposalState(uint256 proposalId, ProposalState current, bytes32 expectedStates);

    /**
     * @dev The voting period set is not a valid period.
     */
    error GovernorInvalidVotingPeriod(uint256 votingPeriod);

    /**
     * @dev The `proposer` does not have the required votes to create a proposal.
     */
    error GovernorInsufficientProposerVotes(address proposer, uint256 votes, uint256 threshold);

    /**
     * @dev The `proposer` is not allowed to create a proposal.
     */
    error GovernorRestrictedProposer(address proposer);

    /**
     * @dev The vote type used is not valid for the corresponding counting module.
     */
    error GovernorInvalidVoteType();

    /**
     * @dev Queue operation is not implemented for this governor. Execute should be called directly.
     */
    error GovernorQueueNotImplemented();

    /**
     * @dev The proposal hasn't been queued yet.
     */
    error GovernorNotQueuedProposal(uint256 proposalId);

    /**
     * @dev The proposal has already been queued.
     */
    error GovernorAlreadyQueuedProposal(uint256 proposalId);

    /**
     * @dev The provided signature is not valid for the expected `voter`.
     * If the `voter` is a contract, the signature is not valid using {IERC1271-isValidSignature}.
     */
    error GovernorInvalidSignature(address voter);

    /**
     * @dev Emitted when a proposal is created.
     */
    event ProposalCreated(
        uint256 proposalId,
        address proposer,
        address[] targets,
        uint256[] values,
        string[] signatures,
        bytes[] calldatas,
        uint256 voteStart,
        uint256 voteEnd,
        string description
    );

    /**
     * @dev Emitted when a proposal is queued.
     */
    event ProposalQueued(uint256 proposalId, uint256 etaSeconds);

    /**
     * @dev Emitted when a proposal is executed.
     */
    event ProposalExecuted(uint256 proposalId);

    /**
     * @dev Emitted when a proposal is canceled.
     */
    event ProposalCanceled(uint256 proposalId);

    /**
     * @dev Emitted when a vote is cast without params.
     *
     * Note: `support` values should be seen as buckets. Their interpretation depends on the voting module used.
     */
    event VoteCast(address indexed voter, uint256 proposalId, uint8 support, uint256 weight, string reason);

    /**
     * @dev Emitted when a vote is cast with params.
     *
     * Note: `support` values should be seen as buckets. Their interpretation depends on the voting module used.
     * `params` are additional encoded parameters. Their interpepretation also depends on the voting module used.
     */
    event VoteCastWithParams(
        address indexed voter,
        uint256 proposalId,
        uint8 support,
        uint256 weight,
        string reason,
        bytes params
    );

    /**
     * @notice module:core
     * @dev Name of the governor instance (used in building the ERC712 domain separator).
     */
    function name() external view returns (string memory);

    /**
     * @notice module:core
     * @dev Version of the governor instance (used in building the ERC712 domain separator). Default: "1"
     */
    function version() external view returns (string memory);

    /**
     * @notice module:voting
     * @dev A description of the possible `support` values for {castVote} and the way these votes are counted, meant to
     * be consumed by UIs to show correct vote options and interpret the results. The string is a URL-encoded sequence of
     * key-value pairs that each describe one aspect, for example `support=bravo&quorum=for,abstain`.
     *
     * There are 2 standard keys: `support` and `quorum`.
     *
     * - `support=bravo` refers to the vote options 0 = Against, 1 = For, 2 = Abstain, as in `GovernorBravo`.
     * - `quorum=bravo` means that only For votes are counted towards quorum.
     * - `quorum=for,abstain` means that both For and Abstain votes are counted towards quorum.
     *
     * If a counting module makes use of encoded `params`, it should  include this under a `params` key with a unique
     * name that describes the behavior. For example:
     *
     * - `params=fractional` might refer to a scheme where votes are divided fractionally between for/against/abstain.
     * - `params=erc721` might refer to a scheme where specific NFTs are delegated to vote.
     *
     * NOTE: The string can be decoded by the standard
     * https://developer.mozilla.org/en-US/docs/Web/API/URLSearchParams[`URLSearchParams`]
     * JavaScript class.
     */
    // solhint-disable-next-line func-name-mixedcase
    function COUNTING_MODE() external view returns (string memory);

    /**
     * @notice module:core
     * @dev Hashing function used to (re)build the proposal id from the proposal details..
     */
    function hashProposal(
        address[] memory targets,
        uint256[] memory values,
        bytes[] memory calldatas,
        bytes32 descriptionHash
    ) external pure returns (uint256);

    /**
     * @notice module:core
     * @dev Current state of a proposal, following Compound's convention
     */
    function state(uint256 proposalId) external view returns (ProposalState);

    /**
     * @notice module:core
     * @dev The number of votes required in order for a voter to become a proposer.
     */
    function proposalThreshold() external view returns (uint256);

    /**
     * @notice module:core
     * @dev Timepoint used to retrieve user's votes and quorum. If using block number (as per Compound's Comp), the
     * snapshot is performed at the end of this block. Hence, voting for this proposal starts at the beginning of the
     * following block.
     */
    function proposalSnapshot(uint256 proposalId) external view returns (uint256);

    /**
     * @notice module:core
     * @dev Timepoint at which votes close. If using block number, votes close at the end of this block, so it is
     * possible to cast a vote during this block.
     */
    function proposalDeadline(uint256 proposalId) external view returns (uint256);

    /**
     * @notice module:core
     * @dev The account that created a proposal.
     */
    function proposalProposer(uint256 proposalId) external view returns (address);

    /**
     * @notice module:core
     * @dev The time when a queued proposal becomes executable ("ETA"). Unlike {proposalSnapshot} and
     * {proposalDeadline}, this doesn't use the governor clock, and instead relies on the executor's clock which may be
     * different. In most cases this will be a timestamp.
     */
    function proposalEta(uint256 proposalId) external view returns (uint256);

    /**
     * @notice module:core
     * @dev Whether a proposal needs to be queued before execution.
     */
    function proposalNeedsQueuing(uint256 proposalId) external view returns (bool);

    /**
     * @notice module:user-config
     * @dev Delay, between the proposal is created and the vote starts. The unit this duration is expressed in depends
     * on the clock (see EIP-6372) this contract uses.
     *
     * This can be increased to leave time for users to buy voting power, or delegate it, before the voting of a
     * proposal starts.
     *
     * NOTE: While this interface returns a uint256, timepoints are stored as uint48 following the ERC-6372 clock type.
     * Consequently this value must fit in a uint48 (when added to the current clock). See {IERC6372-clock}.
     */
    function votingDelay() external view returns (uint256);

    /**
     * @notice module:user-config
     * @dev Delay between the vote start and vote end. The unit this duration is expressed in depends on the clock
     * (see EIP-6372) this contract uses.
     *
     * NOTE: The {votingDelay} can delay the start of the vote. This must be considered when setting the voting
     * duration compared to the voting delay.
     *
     * NOTE: This value is stored when the proposal is submitted so that possible changes to the value do not affect
     * proposals that have already been submitted. The type used to save it is a uint32. Consequently, while this
     * interface returns a uint256, the value it returns should fit in a uint32.
     */
    function votingPeriod() external view returns (uint256);

    /**
     * @notice module:user-config
     * @dev Minimum number of cast voted required for a proposal to be successful.
     *
     * NOTE: The `timepoint` parameter corresponds to the snapshot used for counting vote. This allows to scale the
     * quorum depending on values such as the totalSupply of a token at this timepoint (see {ERC20Votes}).
     */
    function quorum(uint256 timepoint) external view returns (uint256);

    /**
     * @notice module:reputation
     * @dev Voting power of an `account` at a specific `timepoint`.
     *
     * Note: this can be implemented in a number of ways, for example by reading the delegated balance from one (or
     * multiple), {ERC20Votes} tokens.
     */
    function getVotes(address account, uint256 timepoint) external view returns (uint256);

    /**
     * @notice module:reputation
     * @dev Voting power of an `account` at a specific `timepoint` given additional encoded parameters.
     */
    function getVotesWithParams(
        address account,
        uint256 timepoint,
        bytes memory params
    ) external view returns (uint256);

    /**
     * @notice module:voting
     * @dev Returns whether `account` has cast a vote on `proposalId`.
     */
    function hasVoted(uint256 proposalId, address account) external view returns (bool);

    /**
     * @dev Create a new proposal. Vote start after a delay specified by {IGovernor-votingDelay} and lasts for a
     * duration specified by {IGovernor-votingPeriod}.
     *
     * Emits a {ProposalCreated} event.
     */
    function propose(
        address[] memory targets,
        uint256[] memory values,
        bytes[] memory calldatas,
        string memory description
    ) external returns (uint256 proposalId);

    /**
     * @dev Queue a proposal. Some governors require this step to be performed before execution can happen. If queuing
     * is not necessary, this function may revert.
     * Queuing a proposal requires the quorum to be reached, the vote to be successful, and the deadline to be reached.
     *
     * Emits a {ProposalQueued} event.
     */
    function queue(
        address[] memory targets,
        uint256[] memory values,
        bytes[] memory calldatas,
        bytes32 descriptionHash
    ) external returns (uint256 proposalId);

    /**
     * @dev Execute a successful proposal. This requires the quorum to be reached, the vote to be successful, and the
     * deadline to be reached. Depending on the governor it might also be required that the proposal was queued and
     * that some delay passed.
     *
     * Emits a {ProposalExecuted} event.
     *
     * NOTE: Some modules can modify the requirements for execution, for example by adding an additional timelock.
     */
    function execute(
        address[] memory targets,
        uint256[] memory values,
        bytes[] memory calldatas,
        bytes32 descriptionHash
    ) external payable returns (uint256 proposalId);

    /**
     * @dev Cancel a proposal. A proposal is cancellable by the proposer, but only while it is Pending state, i.e.
     * before the vote starts.
     *
     * Emits a {ProposalCanceled} event.
     */
    function cancel(
        address[] memory targets,
        uint256[] memory values,
        bytes[] memory calldatas,
        bytes32 descriptionHash
    ) external returns (uint256 proposalId);

    /**
     * @dev Cast a vote
     *
     * Emits a {VoteCast} event.
     */
    function castVote(uint256 proposalId, uint8 support) external returns (uint256 balance);

    /**
     * @dev Cast a vote with a reason
     *
     * Emits a {VoteCast} event.
     */
    function castVoteWithReason(
        uint256 proposalId,
        uint8 support,
        string calldata reason
    ) external returns (uint256 balance);

    /**
     * @dev Cast a vote with a reason and additional encoded parameters
     *
     * Emits a {VoteCast} or {VoteCastWithParams} event depending on the length of params.
     */
    function castVoteWithReasonAndParams(
        uint256 proposalId,
        uint8 support,
        string calldata reason,
        bytes memory params
    ) external returns (uint256 balance);

    /**
     * @dev Cast a vote using the voter's signature, including ERC-1271 signature support.
     *
     * Emits a {VoteCast} event.
     */
    function castVoteBySig(
        uint256 proposalId,
        uint8 support,
        address voter,
        bytes memory signature
    ) external returns (uint256 balance);

    /**
     * @dev Cast a vote with a reason and additional encoded parameters using the voter's signature,
     * including ERC-1271 signature support.
     *
     * Emits a {VoteCast} or {VoteCastWithParams} event depending on the length of params.
     */
    function castVoteWithReasonAndParamsBySig(
        uint256 proposalId,
        uint8 support,
        address voter,
        string calldata reason,
        bytes memory params,
        bytes memory signature
    ) external returns (uint256 balance);
}

pragma solidity >=0.8.4;

interface IReverseRegistrar {
    function setDefaultResolver(address resolver) external;

    function claim(address owner) external returns (bytes32);

    function claimForAddr(
        address addr,
        address owner,
        address resolver
    ) external returns (bytes32);

    function claimWithResolver(
        address owner,
        address resolver
    ) external returns (bytes32);

    function setName(string memory name) external returns (bytes32);

    function setNameForAddr(
        address addr,
        address owner,
        address resolver,
        string memory name
    ) external returns (bytes32);

    function node(address addr) external pure returns (bytes32);
}

pragma solidity >=0.8.4;

interface ENS {
    // Logged when the owner of a node assigns a new owner to a subnode.
    event NewOwner(bytes32 indexed node, bytes32 indexed label, address owner);

    // Logged when the owner of a node transfers ownership to a new account.
    event Transfer(bytes32 indexed node, address owner);

    // Logged when the resolver for a node changes.
    event NewResolver(bytes32 indexed node, address resolver);

    // Logged when the TTL of a node changes
    event NewTTL(bytes32 indexed node, uint64 ttl);

    // Logged when an operator is added or removed.
    event ApprovalForAll(
        address indexed owner,
        address indexed operator,
        bool approved
    );

    function setRecord(
        bytes32 node,
        address owner,
        address resolver,
        uint64 ttl
    ) external;

    function setSubnodeRecord(
        bytes32 node,
        bytes32 label,
        address owner,
        address resolver,
        uint64 ttl
    ) external;

    function setSubnodeOwner(
        bytes32 node,
        bytes32 label,
        address owner
    ) external returns (bytes32);

    function setResolver(bytes32 node, address resolver) external;

    function setOwner(bytes32 node, address owner) external;

    function setTTL(bytes32 node, uint64 ttl) external;

    function setApprovalForAll(address operator, bool approved) external;

    function owner(bytes32 node) external view returns (address);

    function resolver(bytes32 node) external view returns (address);

    function ttl(bytes32 node) external view returns (uint64);

    function recordExists(bytes32 node) external view returns (bool);

    function isApprovedForAll(
        address owner,
        address operator
    ) external view returns (bool);
}

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

pragma solidity ^0.8.20;

/**
 * @dev Interface of the ERC1271 standard signature validation method for
 * contracts as defined in https://eips.ethereum.org/EIPS/eip-1271[ERC-1271].
 */
interface IERC1271 {
    /**
     * @dev Should return whether the signature provided is valid for the provided data
     * @param hash      Hash of the data to be signed
     * @param signature Signature byte array associated with _data
     */
    function isValidSignature(bytes32 hash, bytes memory signature) external view returns (bytes4 magicValue);
}

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

pragma solidity ^0.8.20;

/**
 * @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 ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS
    }

    /**
     * @dev The signature derives the `address(0)`.
     */
    error ECDSAInvalidSignature();

    /**
     * @dev The signature has an invalid length.
     */
    error ECDSAInvalidSignatureLength(uint256 length);

    /**
     * @dev The signature has an S value that is in the upper half order.
     */
    error ECDSAInvalidSignatureS(bytes32 s);

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with `signature` or an error. This will not
     * return address(0) without also returning an error description. Errors are documented using an enum (error type)
     * and a bytes32 providing additional information about the error.
     *
     * If no error is returned, then the address can be used for verification purposes.
     *
     * The `ecrecover` EVM precompile 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 {MessageHashUtils-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]
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError, bytes32) {
        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, bytes32(signature.length));
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM precompile 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 {MessageHashUtils-toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, signature);
        _throwError(error, errorArg);
        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]
     */
    function tryRecover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address, RecoverError, bytes32) {
        unchecked {
            bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
            // We do not check for an overflow here since the shift operation results in 0 or 1.
            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.
     */
    function recover(bytes32 hash, bytes32 r, bytes32 vs) internal pure returns (address) {
        (address recovered, RecoverError error, bytes32 errorArg) = tryRecover(hash, r, vs);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError, bytes32) {
        // 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, s);
        }

        // 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, bytes32(0));
        }

        return (signer, RecoverError.NoError, bytes32(0));
    }

    /**
     * @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, bytes32 errorArg) = tryRecover(hash, v, r, s);
        _throwError(error, errorArg);
        return recovered;
    }

    /**
     * @dev Optionally reverts with the corresponding custom error according to the `error` argument provided.
     */
    function _throwError(RecoverError error, bytes32 errorArg) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert ECDSAInvalidSignature();
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert ECDSAInvalidSignatureLength(uint256(errorArg));
        } else if (error == RecoverError.InvalidSignatureS) {
            revert ECDSAInvalidSignatureS(errorArg);
        }
    }
}

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

pragma solidity ^0.8.20;

import {Math} from "./math/Math.sol";
import {SignedMath} from "./math/SignedMath.sol";

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

    /**
     * @dev The `value` string doesn't fit in the specified `length`.
     */
    error StringsInsufficientHexLength(uint256 value, uint256 length);

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

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

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

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        uint256 localValue = value;
        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] = HEX_DIGITS[localValue & 0xf];
            localValue >>= 4;
        }
        if (localValue != 0) {
            revert StringsInsufficientHexLength(value, length);
        }
        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 bytes(a).length == bytes(b).length && keccak256(bytes(a)) == keccak256(bytes(b));
    }
}

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

pragma solidity ^0.8.20;

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

/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement 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);
 * }
 * ```
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

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

pragma solidity ^0.8.20;

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

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

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

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

pragma solidity ^0.8.20;

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

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

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

    /**
     * @dev Emitted when `account` is granted `role`.
     *
     * `sender` is the account that originated the contract call, 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 `callerConfirmation`.
     */
    function renounceRole(bytes32 role, address callerConfirmation) external;
}

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

pragma solidity ^0.8.20;

interface IERC6372 {
    /**
     * @dev Clock used for flagging checkpoints. Can be overridden to implement timestamp based checkpoints (and voting).
     */
    function clock() external view returns (uint48);

    /**
     * @dev Description of the clock
     */
    // solhint-disable-next-line func-name-mixedcase
    function CLOCK_MODE() external view returns (string memory);
}

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

pragma solidity ^0.8.20;

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

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

pragma solidity ^0.8.20;

/**
 * @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 IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[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 v5.0.0) (utils/math/SignedMath.sol)

pragma solidity ^0.8.20;

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

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

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

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

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

pragma solidity ^0.8.20;

/**
 * @dev Standard math utilities missing in the Solidity language.
 */
library Math {
    /**
     * @dev Muldiv operation overflow.
     */
    error MathOverflowedMulDiv();

    enum Rounding {
        Floor, // Toward negative infinity
        Ceil, // Toward positive infinity
        Trunc, // Toward zero
        Expand // Away from zero
    }

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

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

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

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

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

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

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

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

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

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

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

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

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            if (denominator <= prod1) {
                revert MathOverflowedMulDiv();
            }

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

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

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

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

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

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

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

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

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

            // Use the Newton-Raphson iteration to improve the precision. Thanks to Hensel's lifting lemma, this also
            // works in modular arithmetic, doubling the correct bits in each step.
            inverse *= 2 - denominator * inverse; // inverse mod 2^8
            inverse *= 2 - denominator * inverse; // inverse mod 2^16
            inverse *= 2 - denominator * inverse; // inverse mod 2^32
            inverse *= 2 - denominator * inverse; // inverse mod 2^64
            inverse *= 2 - denominator * inverse; // inverse mod 2^128
            inverse *= 2 - denominator * inverse; // inverse mod 2^256

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

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

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

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

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

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

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

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

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

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

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

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

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

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

pragma solidity ^0.8.20;

/**
 * @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 IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[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);
}

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"contract ENS","name":"ens","type":"address"},{"internalType":"address","name":"_governor","type":"address"},{"internalType":"string","name":"_pledge","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"AccessControlBadConfirmation","type":"error"},{"inputs":[{"internalType":"address","name":"account","type":"address"},{"internalType":"bytes32","name":"neededRole","type":"bytes32"}],"name":"AccessControlUnauthorizedAccount","type":"error"},{"inputs":[],"name":"AccessDenied","type":"error"},{"inputs":[],"name":"InvalidSignature","type":"error"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"governor","type":"address"}],"name":"NewGovernor","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"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VETO_CANDIDATE_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"VETO_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"proposalId","type":"uint256"}],"name":"castVote","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"proposalId","type":"uint256"},{"internalType":"string","name":"reason","type":"string"}],"name":"castVoteWithReason","outputs":[{"internalType":"uint256","name":"balance","type":"uint256"}],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes","name":"signature","type":"bytes"}],"name":"enableVeto","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"governor","outputs":[{"internalType":"contract IGovernor","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pledge","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"callerConfirmation","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":"_governor","type":"address"}],"name":"setGovernor","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"}]

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

00000000000000000000000000000000000c2e074ec69a0dfb2997ba6c7d2e1e000000000000000000000000323a76393544d5ecca80cd6ef2a560c6a395b7e300000000000000000000000000000000000000000000000000000000000000600000000000000000000000000000000000000000000000000000000000000082492068657265627920616772656520746f20757365207468697320636f6e747261637420696e206163636f7264616e636520776974682074686520706c6564676520666f756e6420617420495046532043494420516d62434e6d54744d676a5658737169725a527938745a6271337a6839326731673650453356345147704e4a3162000000000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : ens (address): 0x00000000000C2E074eC69A0dFb2997BA6C7d2e1e
Arg [1] : _governor (address): 0x323A76393544d5ecca80cd6ef2A560C6a395b7E3
Arg [2] : _pledge (string): I hereby agree to use this contract in accordance with the pledge found at IPFS CID QmbCNmTtMgjVXsqirZRy8tZbq3zh92g1g6PE3V4QGpNJ1b

-----Encoded View---------------
9 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000c2e074ec69a0dfb2997ba6c7d2e1e
Arg [1] : 000000000000000000000000323a76393544d5ecca80cd6ef2a560c6a395b7e3
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000082
Arg [4] : 492068657265627920616772656520746f20757365207468697320636f6e7472
Arg [5] : 61637420696e206163636f7264616e636520776974682074686520706c656467
Arg [6] : 6520666f756e6420617420495046532043494420516d62434e6d54744d676a56
Arg [7] : 58737169725a527938745a6271337a6839326731673650453356345147704e4a
Arg [8] : 3162000000000000000000000000000000000000000000000000000000000000

1257:2588:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2565:202:5;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1310:25:0;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3592:251;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;3810:120:5;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;4226:136;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;5328:245;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;3197:177:0;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2681:367;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;1341:20;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2854:136:5;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1367:78:0;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;1451:58;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2187:49:5;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;2346:171:0;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;4642:138:5;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;2565:202;2650:4;2688:32;2673:47;;;:11;:47;;;;:87;;;;2724:36;2748:11;2724:23;:36::i;:::-;2673:87;2666:94;;2565:202;;;:::o;1310:25:0:-;;;;;;;;;;;;;:::o;3592:251::-;3730:15;1487:22;2464:16:5;2475:4;2464:10;:16::i;:::-;3764:8:0::1;;;;;;;;;;;:27;;;3792:10;3810:16;3804:23;;;;;;;;:::i;:::-;;3829:6;;3764:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3757:79;;3592:251:::0;;;;;;:::o;3810:120:5:-;3875:7;3901:6;:12;3908:4;3901:12;;;;;;;;;;;:22;;;3894:29;;3810:120;;;:::o;4226:136::-;4300:18;4313:4;4300:12;:18::i;:::-;2464:16;2475:4;2464:10;:16::i;:::-;4330:25:::1;4341:4;4347:7;4330:10;:25::i;:::-;;4226:136:::0;;;:::o;5328:245::-;5443:12;:10;:12::i;:::-;5421:34;;:18;:34;;;5417:102;;5478:30;;;;;;;;;;;;;;5417:102;5529:37;5541:4;5547:18;5529:11;:37::i;:::-;;5328:245;;:::o;3197:177:0:-;3279:15;1487:22;2464:16:5;2475:4;2464:10;:16::i;:::-;3313:8:0::1;;;;;;;;;;;:17;;;3331:10;3349:16;3343:23;;;;;;;;:::i;:::-;;3313:54;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;3306:61;;3197:177:::0;;;;:::o;2681:367::-;1413:32;2464:16:5;2475:4;2464:10;:16::i;:::-;2778:115:0::1;2815:10;2827:54;2873:6;2827:54;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:39;:54::i;:::-;2883:9;2778:36;:115::i;:::-;2774:171;;2916:18;;;;;;;;;;;;;;2774:171;2954:33;1487:22;2976:10;2954;:33::i;:::-;;2997:44;1413:32;3030:10;2997:11;:44::i;:::-;;2681:367:::0;;:::o;1341:20::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;2854:136:5:-;2931:4;2954:6;:12;2961:4;2954:12;;;;;;;;;;;:20;;:29;2975:7;2954:29;;;;;;;;;;;;;;;;;;;;;;;;;2947:36;;2854:136;;;;:::o;1367:78:0:-;1413:32;1367:78;:::o;1451:58::-;1487:22;1451:58;:::o;2187:49:5:-;2232:4;2187:49;;;:::o;2346:171:0:-;2232:4:5;2404:18:0;;2464:16:5;2475:4;2464:10;:16::i;:::-;2455:9:0::1;2434:8;;:31;;;;;;;;;;;;;;;;;;2480:22;2492:9;2480:22;;;;;;:::i;:::-;;;;;;;;2346:171:::0;;:::o;4642:138:5:-;4717:18;4730:4;4717:12;:18::i;:::-;2464:16;2475:4;2464:10;:16::i;:::-;4747:26:::1;4759:4;4765:7;4747:11;:26::i;:::-;;4642:138:::0;;;:::o;762:146:13:-;838:4;876:25;861:40;;;:11;:40;;;;854:47;;762:146;;;:::o;3199:103:5:-;3265:30;3276:4;3282:12;:10;:12::i;:::-;3265:10;:30::i;:::-;3199:103;:::o;6179:316::-;6256:4;6277:22;6285:4;6291:7;6277;:22::i;:::-;6272:217;;6347:4;6315:6;:12;6322:4;6315:12;;;;;;;;;;;:20;;:29;6336:7;6315:29;;;;;;;;;;;;;;;;:36;;;;;;;;;;;;;;;;;;6397:12;:10;:12::i;:::-;6370:40;;6388:7;6370:40;;6382:4;6370:40;;;;;;;;;;6431:4;6424:11;;;;6272:217;6473:5;6466:12;;6179:316;;;;;:::o;656:96:8:-;709:7;735:10;728:17;;656:96;:::o;6730:317:5:-;6808:4;6828:22;6836:4;6842:7;6828;:22::i;:::-;6824:217;;;6898:5;6866:6;:12;6873:4;6866:12;;;;;;;;;;;:20;;:29;6887:7;6866:29;;;;;;;;;;;;;;;;:37;;;;;;;;;;;;;;;;;;6949:12;:10;:12::i;:::-;6922:40;;6940:7;6922:40;;6934:4;6922:40;;;;;;;;;;6983:4;6976:11;;;;6824:217;7025:5;7018:12;;6730:317;;;;;:::o;2148:229:11:-;2225:7;2326:32;2343:7;:14;2326:16;:32::i;:::-;2361:7;2273:96;;;;;;;;;:::i;:::-;;;;;;;;;;;;;2263:107;;;;;;2244:126;;2148:229;;;:::o;1039:368:12:-;1145:4;1162:17;1181:24;1211:33;1228:4;1234:9;1211:16;:33::i;:::-;1161:83;;;;;1283:26;1274:35;;;;;;;;:::i;:::-;;:5;:35;;;;;;;;:::i;:::-;;;:58;;;;;1326:6;1313:19;;:9;:19;;;1274:58;1273:127;;;;1349:51;1376:6;1384:4;1390:9;1349:26;:51::i;:::-;1273:127;1254:146;;;;1039:368;;;;;:::o;3432:197:5:-;3520:22;3528:4;3534:7;3520;:22::i;:::-;3515:108;;3598:7;3607:4;3565:47;;;;;;;;;;;;:::i;:::-;;;;;;;;3515:108;3432:197;;:::o;637:698:9:-;693:13;742:14;779:1;759:17;770:5;759:10;:17::i;:::-;:21;742:38;;794:20;828:6;817:18;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;794:41;;849:11;975:6;971:2;967:15;959:6;955:28;948:35;;1010:282;1017:4;1010:282;;;1041:5;;;;;;;;1180:10;1175:2;1168:5;1164:14;1159:32;1154:3;1146:46;1236:2;1227:11;;;;;;:::i;:::-;;;;;1269:1;1260:5;:10;1010:282;1256:21;1010:282;1312:6;1305:13;;;;;637:698;;;:::o;2129:766:10:-;2210:7;2219:12;2233:7;2276:2;2256:9;:16;:22;2252:637;;2294:9;2317;2340:7;2592:4;2581:9;2577:20;2571:27;2566:32;;2641:4;2630:9;2626:20;2620:27;2615:32;;2698:4;2687:9;2683:20;2677:27;2674:1;2669:36;2664:41;;2739:25;2750:4;2756:1;2759;2762;2739:10;:25::i;:::-;2732:32;;;;;;;;;;;2252:637;2811:1;2815:35;2860:9;:16;2852:25;;2795:83;;;;;;2129:766;;;;;;:::o;1813:458:12:-;1956:4;1973:12;1987:19;2010:6;:17;;2084:4;2090:9;2041:60;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;2010:101;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;1972:139;;;;2129:7;:42;;;;;2169:2;2152:6;:13;:19;;2129:42;:134;;;;;2228:34;;;2220:43;;;2198:6;2187:29;;;;;;;;;;;;:::i;:::-;:76;2129:134;2121:143;;;;1813:458;;;;;:::o;12214:916:15:-;12267:7;12286:14;12303:1;12286:18;;12351:8;12342:5;:17;12338:103;;12388:8;12379:17;;;;;;:::i;:::-;;;;;12424:2;12414:12;;;;12338:103;12467:8;12458:5;:17;12454:103;;12504:8;12495:17;;;;;;:::i;:::-;;;;;12540:2;12530:12;;;;12454:103;12583:8;12574:5;:17;12570:103;;12620:8;12611:17;;;;;;:::i;:::-;;;;;12656:2;12646:12;;;;12570:103;12699:7;12690:5;:16;12686:100;;12735:7;12726:16;;;;;;:::i;:::-;;;;;12770:1;12760:11;;;;12686:100;12812:7;12803:5;:16;12799:100;;12848:7;12839:16;;;;;;:::i;:::-;;;;;12883:1;12873:11;;;;12799:100;12925:7;12916:5;:16;12912:100;;12961:7;12952:16;;;;;;:::i;:::-;;;;;12996:1;12986:11;;;;12912:100;13038:7;13029:5;:16;13025:66;;13075:1;13065:11;;;;13025:66;13117:6;13110:13;;;12214:916;;;:::o;5140:1530:10:-;5266:7;5275:12;5289:7;6199:66;6194:1;6186:10;;:79;6182:164;;;6297:1;6301:30;6333:1;6281:54;;;;;;;;6182:164;6440:14;6457:24;6467:4;6473:1;6476;6479;6457:24;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6440:41;;6513:1;6495:20;;:6;:20;;;6491:113;;6547:1;6551:29;6590:1;6582:10;;6531:62;;;;;;;;;6491:113;6622:6;6630:20;6660:1;6652:10;;6614:49;;;;;;;5140:1530;;;;;;;;;:::o;7:75:20:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:149;370:7;410:66;403:5;399:78;388:89;;334:149;;;:::o;489:120::-;561:23;578:5;561:23;:::i;:::-;554:5;551:34;541:62;;599:1;596;589:12;541:62;489:120;:::o;615:137::-;660:5;698:6;685:20;676:29;;714:32;740:5;714:32;:::i;:::-;615:137;;;;:::o;758:327::-;816:6;865:2;853:9;844:7;840:23;836:32;833:119;;;871:79;;:::i;:::-;833:119;991:1;1016:52;1060:7;1051:6;1040:9;1036:22;1016:52;:::i;:::-;1006:62;;962:116;758:327;;;;:::o;1091:90::-;1125:7;1168:5;1161:13;1154:21;1143:32;;1091:90;;;:::o;1187:109::-;1268:21;1283:5;1268:21;:::i;:::-;1263:3;1256:34;1187:109;;:::o;1302:210::-;1389:4;1427:2;1416:9;1412:18;1404:26;;1440:65;1502:1;1491:9;1487:17;1478:6;1440:65;:::i;:::-;1302:210;;;;:::o;1518:126::-;1555:7;1595:42;1588:5;1584:54;1573:65;;1518:126;;;:::o;1650:60::-;1678:3;1699:5;1692:12;;1650:60;;;:::o;1716:142::-;1766:9;1799:53;1817:34;1826:24;1844:5;1826:24;:::i;:::-;1817:34;:::i;:::-;1799:53;:::i;:::-;1786:66;;1716:142;;;:::o;1864:126::-;1914:9;1947:37;1978:5;1947:37;:::i;:::-;1934:50;;1864:126;;;:::o;1996:143::-;2063:9;2096:37;2127:5;2096:37;:::i;:::-;2083:50;;1996:143;;;:::o;2145:165::-;2249:54;2297:5;2249:54;:::i;:::-;2244:3;2237:67;2145:165;;:::o;2316:256::-;2426:4;2464:2;2453:9;2449:18;2441:26;;2477:88;2562:1;2551:9;2547:17;2538:6;2477:88;:::i;:::-;2316:256;;;;:::o;2578:77::-;2615:7;2644:5;2633:16;;2578:77;;;:::o;2661:122::-;2734:24;2752:5;2734:24;:::i;:::-;2727:5;2724:35;2714:63;;2773:1;2770;2763:12;2714:63;2661:122;:::o;2789:139::-;2835:5;2873:6;2860:20;2851:29;;2889:33;2916:5;2889:33;:::i;:::-;2789:139;;;;:::o;2934:117::-;3043:1;3040;3033:12;3057:117;3166:1;3163;3156:12;3180:117;3289:1;3286;3279:12;3317:553;3375:8;3385:6;3435:3;3428:4;3420:6;3416:17;3412:27;3402:122;;3443:79;;:::i;:::-;3402:122;3556:6;3543:20;3533:30;;3586:18;3578:6;3575:30;3572:117;;;3608:79;;:::i;:::-;3572:117;3722:4;3714:6;3710:17;3698:29;;3776:3;3768:4;3760:6;3756:17;3746:8;3742:32;3739:41;3736:128;;;3783:79;;:::i;:::-;3736:128;3317:553;;;;;:::o;3876:674::-;3956:6;3964;3972;4021:2;4009:9;4000:7;3996:23;3992:32;3989:119;;;4027:79;;:::i;:::-;3989:119;4147:1;4172:53;4217:7;4208:6;4197:9;4193:22;4172:53;:::i;:::-;4162:63;;4118:117;4302:2;4291:9;4287:18;4274:32;4333:18;4325:6;4322:30;4319:117;;;4355:79;;:::i;:::-;4319:117;4468:65;4525:7;4516:6;4505:9;4501:22;4468:65;:::i;:::-;4450:83;;;;4245:298;3876:674;;;;;:::o;4556:118::-;4643:24;4661:5;4643:24;:::i;:::-;4638:3;4631:37;4556:118;;:::o;4680:222::-;4773:4;4811:2;4800:9;4796:18;4788:26;;4824:71;4892:1;4881:9;4877:17;4868:6;4824:71;:::i;:::-;4680:222;;;;:::o;4908:77::-;4945:7;4974:5;4963:16;;4908:77;;;:::o;4991:122::-;5064:24;5082:5;5064:24;:::i;:::-;5057:5;5054:35;5044:63;;5103:1;5100;5093:12;5044:63;4991:122;:::o;5119:139::-;5165:5;5203:6;5190:20;5181:29;;5219:33;5246:5;5219:33;:::i;:::-;5119:139;;;;:::o;5264:329::-;5323:6;5372:2;5360:9;5351:7;5347:23;5343:32;5340:119;;;5378:79;;:::i;:::-;5340:119;5498:1;5523:53;5568:7;5559:6;5548:9;5544:22;5523:53;:::i;:::-;5513:63;;5469:117;5264:329;;;;:::o;5599:118::-;5686:24;5704:5;5686:24;:::i;:::-;5681:3;5674:37;5599:118;;:::o;5723:222::-;5816:4;5854:2;5843:9;5839:18;5831:26;;5867:71;5935:1;5924:9;5920:17;5911:6;5867:71;:::i;:::-;5723:222;;;;:::o;5951:96::-;5988:7;6017:24;6035:5;6017:24;:::i;:::-;6006:35;;5951:96;;;:::o;6053:122::-;6126:24;6144:5;6126:24;:::i;:::-;6119:5;6116:35;6106:63;;6165:1;6162;6155:12;6106:63;6053:122;:::o;6181:139::-;6227:5;6265:6;6252:20;6243:29;;6281:33;6308:5;6281:33;:::i;:::-;6181:139;;;;:::o;6326:474::-;6394:6;6402;6451:2;6439:9;6430:7;6426:23;6422:32;6419:119;;;6457:79;;:::i;:::-;6419:119;6577:1;6602:53;6647:7;6638:6;6627:9;6623:22;6602:53;:::i;:::-;6592:63;;6548:117;6704:2;6730:53;6775:7;6766:6;6755:9;6751:22;6730:53;:::i;:::-;6720:63;;6675:118;6326:474;;;;;:::o;6806:329::-;6865:6;6914:2;6902:9;6893:7;6889:23;6885:32;6882:119;;;6920:79;;:::i;:::-;6882:119;7040:1;7065:53;7110:7;7101:6;7090:9;7086:22;7065:53;:::i;:::-;7055:63;;7011:117;6806:329;;;;:::o;7141:117::-;7250:1;7247;7240:12;7264:102;7305:6;7356:2;7352:7;7347:2;7340:5;7336:14;7332:28;7322:38;;7264:102;;;:::o;7372:180::-;7420:77;7417:1;7410:88;7517:4;7514:1;7507:15;7541:4;7538:1;7531:15;7558:281;7641:27;7663:4;7641:27;:::i;:::-;7633:6;7629:40;7771:6;7759:10;7756:22;7735:18;7723:10;7720:34;7717:62;7714:88;;;7782:18;;:::i;:::-;7714:88;7822:10;7818:2;7811:22;7601:238;7558:281;;:::o;7845:129::-;7879:6;7906:20;;:::i;:::-;7896:30;;7935:33;7963:4;7955:6;7935:33;:::i;:::-;7845:129;;;:::o;7980:307::-;8041:4;8131:18;8123:6;8120:30;8117:56;;;8153:18;;:::i;:::-;8117:56;8191:29;8213:6;8191:29;:::i;:::-;8183:37;;8275:4;8269;8265:15;8257:23;;7980:307;;;:::o;8293:148::-;8391:6;8386:3;8381;8368:30;8432:1;8423:6;8418:3;8414:16;8407:27;8293:148;;;:::o;8447:423::-;8524:5;8549:65;8565:48;8606:6;8565:48;:::i;:::-;8549:65;:::i;:::-;8540:74;;8637:6;8630:5;8623:21;8675:4;8668:5;8664:16;8713:3;8704:6;8699:3;8695:16;8692:25;8689:112;;;8720:79;;:::i;:::-;8689:112;8810:54;8857:6;8852:3;8847;8810:54;:::i;:::-;8530:340;8447:423;;;;;:::o;8889:338::-;8944:5;8993:3;8986:4;8978:6;8974:17;8970:27;8960:122;;9001:79;;:::i;:::-;8960:122;9118:6;9105:20;9143:78;9217:3;9209:6;9202:4;9194:6;9190:17;9143:78;:::i;:::-;9134:87;;8950:277;8889:338;;;;:::o;9233:507::-;9301:6;9350:2;9338:9;9329:7;9325:23;9321:32;9318:119;;;9356:79;;:::i;:::-;9318:119;9504:1;9493:9;9489:17;9476:31;9534:18;9526:6;9523:30;9520:117;;;9556:79;;:::i;:::-;9520:117;9661:62;9715:7;9706:6;9695:9;9691:22;9661:62;:::i;:::-;9651:72;;9447:286;9233:507;;;;:::o;9746:99::-;9798:6;9832:5;9826:12;9816:22;;9746:99;;;:::o;9851:169::-;9935:11;9969:6;9964:3;9957:19;10009:4;10004:3;10000:14;9985:29;;9851:169;;;;:::o;10026:139::-;10115:6;10110:3;10105;10099:23;10156:1;10147:6;10142:3;10138:16;10131:27;10026:139;;;:::o;10171:377::-;10259:3;10287:39;10320:5;10287:39;:::i;:::-;10342:71;10406:6;10401:3;10342:71;:::i;:::-;10335:78;;10422:65;10480:6;10475:3;10468:4;10461:5;10457:16;10422:65;:::i;:::-;10512:29;10534:6;10512:29;:::i;:::-;10507:3;10503:39;10496:46;;10263:285;10171:377;;;;:::o;10554:313::-;10667:4;10705:2;10694:9;10690:18;10682:26;;10754:9;10748:4;10744:20;10740:1;10729:9;10725:17;10718:47;10782:78;10855:4;10846:6;10782:78;:::i;:::-;10774:86;;10554:313;;;;:::o;10873:329::-;10932:6;10981:2;10969:9;10960:7;10956:23;10952:32;10949:119;;;10987:79;;:::i;:::-;10949:119;11107:1;11132:53;11177:7;11168:6;11157:9;11153:22;11132:53;:::i;:::-;11122:63;;11078:117;10873:329;;;;:::o;11208:180::-;11256:77;11253:1;11246:88;11353:4;11350:1;11343:15;11377:4;11374:1;11367:15;11394:86;11429:7;11469:4;11462:5;11458:16;11447:27;;11394:86;;;:::o;11486:112::-;11569:22;11585:5;11569:22;:::i;:::-;11564:3;11557:35;11486:112;;:::o;11628:317::-;11726:3;11747:71;11811:6;11806:3;11747:71;:::i;:::-;11740:78;;11828:56;11877:6;11872:3;11865:5;11828:56;:::i;:::-;11909:29;11931:6;11909:29;:::i;:::-;11904:3;11900:39;11893:46;;11628:317;;;;;:::o;11951:545::-;12126:4;12164:2;12153:9;12149:18;12141:26;;12177:71;12245:1;12234:9;12230:17;12221:6;12177:71;:::i;:::-;12258:68;12322:2;12311:9;12307:18;12298:6;12258:68;:::i;:::-;12373:9;12367:4;12363:20;12358:2;12347:9;12343:18;12336:48;12401:88;12484:4;12475:6;12467;12401:88;:::i;:::-;12393:96;;11951:545;;;;;;;:::o;12502:143::-;12559:5;12590:6;12584:13;12575:22;;12606:33;12633:5;12606:33;:::i;:::-;12502:143;;;;:::o;12651:351::-;12721:6;12770:2;12758:9;12749:7;12745:23;12741:32;12738:119;;;12776:79;;:::i;:::-;12738:119;12896:1;12921:64;12977:7;12968:6;12957:9;12953:22;12921:64;:::i;:::-;12911:74;;12867:128;12651:351;;;;:::o;13008:324::-;13125:4;13163:2;13152:9;13148:18;13140:26;;13176:71;13244:1;13233:9;13229:17;13220:6;13176:71;:::i;:::-;13257:68;13321:2;13310:9;13306:18;13297:6;13257:68;:::i;:::-;13008:324;;;;;:::o;13338:180::-;13386:77;13383:1;13376:88;13483:4;13480:1;13473:15;13507:4;13504:1;13497:15;13524:320;13568:6;13605:1;13599:4;13595:12;13585:22;;13652:1;13646:4;13642:12;13673:18;13663:81;;13729:4;13721:6;13717:17;13707:27;;13663:81;13791:2;13783:6;13780:14;13760:18;13757:38;13754:84;;13810:18;;:::i;:::-;13754:84;13575:269;13524:320;;;:::o;13850:118::-;13937:24;13955:5;13937:24;:::i;:::-;13932:3;13925:37;13850:118;;:::o;13974:222::-;14067:4;14105:2;14094:9;14090:18;14082:26;;14118:71;14186:1;14175:9;14171:17;14162:6;14118:71;:::i;:::-;13974:222;;;;:::o;14202:242::-;14371:66;14366:3;14359:79;14202:242;:::o;14450:98::-;14501:6;14535:5;14529:12;14519:22;;14450:98;;;:::o;14554:147::-;14655:11;14692:3;14677:18;;14554:147;;;;:::o;14707:386::-;14811:3;14839:38;14871:5;14839:38;:::i;:::-;14893:88;14974:6;14969:3;14893:88;:::i;:::-;14886:95;;14990:65;15048:6;15043:3;15036:4;15029:5;15025:16;14990:65;:::i;:::-;15080:6;15075:3;15071:16;15064:23;;14815:278;14707:386;;;;:::o;15099:694::-;15366:3;15381:138;15515:3;15381:138;:::i;:::-;15544:2;15539:3;15535:12;15528:19;;15564:93;15653:3;15644:6;15564:93;:::i;:::-;15557:100;;15674:93;15763:3;15754:6;15674:93;:::i;:::-;15667:100;;15784:3;15777:10;;15099:694;;;;;:::o;15799:332::-;15920:4;15958:2;15947:9;15943:18;15935:26;;15971:71;16039:1;16028:9;16024:17;16015:6;15971:71;:::i;:::-;16052:72;16120:2;16109:9;16105:18;16096:6;16052:72;:::i;:::-;15799:332;;;;;:::o;16137:180::-;16185:77;16182:1;16175:88;16282:4;16279:1;16272:15;16306:4;16303:1;16296:15;16323:168;16406:11;16440:6;16435:3;16428:19;16480:4;16475:3;16471:14;16456:29;;16323:168;;;;:::o;16497:373::-;16583:3;16611:38;16643:5;16611:38;:::i;:::-;16665:70;16728:6;16723:3;16665:70;:::i;:::-;16658:77;;16744:65;16802:6;16797:3;16790:4;16783:5;16779:16;16744:65;:::i;:::-;16834:29;16856:6;16834:29;:::i;:::-;16829:3;16825:39;16818:46;;16587:283;16497:373;;;;:::o;16876:419::-;17015:4;17053:2;17042:9;17038:18;17030:26;;17066:71;17134:1;17123:9;17119:17;17110:6;17066:71;:::i;:::-;17184:9;17178:4;17174:20;17169:2;17158:9;17154:18;17147:48;17212:76;17283:4;17274:6;17212:76;:::i;:::-;17204:84;;16876:419;;;;;:::o;17301:271::-;17431:3;17453:93;17542:3;17533:6;17453:93;:::i;:::-;17446:100;;17563:3;17556:10;;17301:271;;;;:::o;17578:143::-;17635:5;17666:6;17660:13;17651:22;;17682:33;17709:5;17682:33;:::i;:::-;17578:143;;;;:::o;17727:351::-;17797:6;17846:2;17834:9;17825:7;17821:23;17817:32;17814:119;;;17852:79;;:::i;:::-;17814:119;17972:1;17997:64;18053:7;18044:6;18033:9;18029:22;17997:64;:::i;:::-;17987:74;;17943:128;17727:351;;;;:::o;18084:545::-;18257:4;18295:3;18284:9;18280:19;18272:27;;18309:71;18377:1;18366:9;18362:17;18353:6;18309:71;:::i;:::-;18390:68;18454:2;18443:9;18439:18;18430:6;18390:68;:::i;:::-;18468:72;18536:2;18525:9;18521:18;18512:6;18468:72;:::i;:::-;18550;18618:2;18607:9;18603:18;18594:6;18550:72;:::i;:::-;18084:545;;;;;;;:::o

ipfs://aac955e6cee280fcbb00e11eb1c6d06cab96a52ec827e4d864667ab41555d891