Contract Source Code (Solidity)

IDE

• Blockscan IDE

Outline

•    - function approve(address spender, uin ...
•    - function transfer(address to, uint256 ...
•    - function transferFrom(
•    - function permit(
•    - function DOMAIN_SEPARATOR()
•    - function computeDomainSeparator()
•    - function _mint(address to, uint256 am ...
•    - function _burn(address from, uint256 ...
• library SafeTransferLib
•    - function safeTransferETH(address to, ...
•    - function safeTransferFrom(
•    - function safeTransfer(
•    - function safeApprove(
• library RescueFundsLib
•    - function rescueFunds(
•    - function owner()
•    - function nominee()
•    - function nominateOwner(address nomine ...
•    - function claimOwner()
•    - function _claimOwner(address claimer_ ...
•    - function _checkRole(bytes32 role_, ad ...
•    - function grantRole(
•    - function revokeRole(
•    - function _grantRole(bytes32 role_, ad ...
•    - function _revokeRole(bytes32 role_, a ...
•    - function hasRole(
•    - function _hasRole(
•    - function rescueFunds(
•  contract Faucet is RescueBase *
•    - function getTokens(address receiver_, ...

More Options

• Similar
• Compare

/**
 *Submitted for verification at sepolia-optimism.etherscan.io on 2024-04-16
*/

pragma solidity 0.8.13;

/// @notice Modern and gas efficient ERC20 + EIP-2612 implementation.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/tokens/ERC20.sol)
/// @author Modified from Uniswap (https://github.com/Uniswap/uniswap-v2-core/blob/master/contracts/UniswapV2ERC20.sol)
/// @dev Do not manually set balances without updating totalSupply, as the sum of all user balances must not exceed it.
abstract contract ERC20 {
    /*//////////////////////////////////////////////////////////////
                                 EVENTS
    //////////////////////////////////////////////////////////////*/

    event Transfer(address indexed from, address indexed to, uint256 amount);

    event Approval(address indexed owner, address indexed spender, uint256 amount);

    /*//////////////////////////////////////////////////////////////
                            METADATA STORAGE
    //////////////////////////////////////////////////////////////*/

    string public name;

    string public symbol;

    uint8 public immutable decimals;

    /*//////////////////////////////////////////////////////////////
                              ERC20 STORAGE
    //////////////////////////////////////////////////////////////*/

    uint256 public totalSupply;

    mapping(address => uint256) public balanceOf;

    mapping(address => mapping(address => uint256)) public allowance;

    /*//////////////////////////////////////////////////////////////
                            EIP-2612 STORAGE
    //////////////////////////////////////////////////////////////*/

    uint256 internal immutable INITIAL_CHAIN_ID;

    bytes32 internal immutable INITIAL_DOMAIN_SEPARATOR;

    mapping(address => uint256) public nonces;

    /*//////////////////////////////////////////////////////////////
                               CONSTRUCTOR
    //////////////////////////////////////////////////////////////*/

    constructor(
        string memory _name,
        string memory _symbol,
        uint8 _decimals
    ) {
        name = _name;
        symbol = _symbol;
        decimals = _decimals;

        INITIAL_CHAIN_ID = block.chainid;
        INITIAL_DOMAIN_SEPARATOR = computeDomainSeparator();
    }

    /*//////////////////////////////////////////////////////////////
                               ERC20 LOGIC
    //////////////////////////////////////////////////////////////*/

    function approve(address spender, uint256 amount) public virtual returns (bool) {
        allowance[msg.sender][spender] = amount;

        emit Approval(msg.sender, spender, amount);

        return true;
    }

    function transfer(address to, uint256 amount) public virtual returns (bool) {
        balanceOf[msg.sender] -= amount;

        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            balanceOf[to] += amount;
        }

        emit Transfer(msg.sender, to, amount);

        return true;
    }

    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual returns (bool) {
        uint256 allowed = allowance[from][msg.sender]; // Saves gas for limited approvals.

        if (allowed != type(uint256).max) allowance[from][msg.sender] = allowed - amount;

        balanceOf[from] -= amount;

        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            balanceOf[to] += amount;
        }

        emit Transfer(from, to, amount);

        return true;
    }

    /*//////////////////////////////////////////////////////////////
                             EIP-2612 LOGIC
    //////////////////////////////////////////////////////////////*/

    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) public virtual {
        require(deadline >= block.timestamp, "PERMIT_DEADLINE_EXPIRED");

        // Unchecked because the only math done is incrementing
        // the owner's nonce which cannot realistically overflow.
        unchecked {
            address recoveredAddress = ecrecover(
                keccak256(
                    abi.encodePacked(
                        "\x19\x01",
                        DOMAIN_SEPARATOR(),
                        keccak256(
                            abi.encode(
                                keccak256(
                                    "Permit(address owner,address spender,uint256 value,uint256 nonce,uint256 deadline)"
                                ),
                                owner,
                                spender,
                                value,
                                nonces[owner]++,
                                deadline
                            )
                        )
                    )
                ),
                v,
                r,
                s
            );

            require(recoveredAddress != address(0) && recoveredAddress == owner, "INVALID_SIGNER");

            allowance[recoveredAddress][spender] = value;
        }

        emit Approval(owner, spender, value);
    }

    function DOMAIN_SEPARATOR() public view virtual returns (bytes32) {
        return block.chainid == INITIAL_CHAIN_ID ? INITIAL_DOMAIN_SEPARATOR : computeDomainSeparator();
    }

    function computeDomainSeparator() internal view virtual returns (bytes32) {
        return
            keccak256(
                abi.encode(
                    keccak256("EIP712Domain(string name,string version,uint256 chainId,address verifyingContract)"),
                    keccak256(bytes(name)),
                    keccak256("1"),
                    block.chainid,
                    address(this)
                )
            );
    }

    /*//////////////////////////////////////////////////////////////
                        INTERNAL MINT/BURN LOGIC
    //////////////////////////////////////////////////////////////*/

    function _mint(address to, uint256 amount) internal virtual {
        totalSupply += amount;

        // Cannot overflow because the sum of all user
        // balances can't exceed the max uint256 value.
        unchecked {
            balanceOf[to] += amount;
        }

        emit Transfer(address(0), to, amount);
    }

    function _burn(address from, uint256 amount) internal virtual {
        balanceOf[from] -= amount;

        // Cannot underflow because a user's balance
        // will never be larger than the total supply.
        unchecked {
            totalSupply -= amount;
        }

        emit Transfer(from, address(0), amount);
    }
}

/// @notice Safe ETH and ERC20 transfer library that gracefully handles missing return values.
/// @author Solmate (https://github.com/transmissions11/solmate/blob/main/src/utils/SafeTransferLib.sol)
/// @dev Use with caution! Some functions in this library knowingly create dirty bits at the destination of the free memory pointer.
/// @dev Note that none of the functions in this library check that a token has code at all! That responsibility is delegated to the caller.
library SafeTransferLib {
    /*//////////////////////////////////////////////////////////////
                             ETH OPERATIONS
    //////////////////////////////////////////////////////////////*/

    function safeTransferETH(address to, uint256 amount) internal {
        bool success;

        /// @solidity memory-safe-assembly
        assembly {
            // Transfer the ETH and store if it succeeded or not.
            success := call(gas(), to, amount, 0, 0, 0, 0)
        }

        require(success, "ETH_TRANSFER_FAILED");
    }

    /*//////////////////////////////////////////////////////////////
                            ERC20 OPERATIONS
    //////////////////////////////////////////////////////////////*/

    function safeTransferFrom(
        ERC20 token,
        address from,
        address to,
        uint256 amount
    ) internal {
        bool success;

        /// @solidity memory-safe-assembly
        assembly {
            // Get a pointer to some free memory.
            let freeMemoryPointer := mload(0x40)

            // Write the abi-encoded calldata into memory, beginning with the function selector.
            mstore(freeMemoryPointer, 0x23b872dd00000000000000000000000000000000000000000000000000000000)
            mstore(add(freeMemoryPointer, 4), and(from, 0xffffffffffffffffffffffffffffffffffffffff)) // Append and mask the "from" argument.
            mstore(add(freeMemoryPointer, 36), and(to, 0xffffffffffffffffffffffffffffffffffffffff)) // Append and mask the "to" argument.
            mstore(add(freeMemoryPointer, 68), amount) // Append the "amount" argument. Masking not required as it's a full 32 byte type.

            success := and(
                // Set success to whether the call reverted, if not we check it either
                // returned exactly 1 (can't just be non-zero data), or had no return data.
                or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
                // We use 100 because the length of our calldata totals up like so: 4 + 32 * 3.
                // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space.
                // Counterintuitively, this call must be positioned second to the or() call in the
                // surrounding and() call or else returndatasize() will be zero during the computation.
                call(gas(), token, 0, freeMemoryPointer, 100, 0, 32)
            )
        }

        require(success, "TRANSFER_FROM_FAILED");
    }

    function safeTransfer(
        ERC20 token,
        address to,
        uint256 amount
    ) internal {
        bool success;

        /// @solidity memory-safe-assembly
        assembly {
            // Get a pointer to some free memory.
            let freeMemoryPointer := mload(0x40)

            // Write the abi-encoded calldata into memory, beginning with the function selector.
            mstore(freeMemoryPointer, 0xa9059cbb00000000000000000000000000000000000000000000000000000000)
            mstore(add(freeMemoryPointer, 4), and(to, 0xffffffffffffffffffffffffffffffffffffffff)) // Append and mask the "to" argument.
            mstore(add(freeMemoryPointer, 36), amount) // Append the "amount" argument. Masking not required as it's a full 32 byte type.

            success := and(
                // Set success to whether the call reverted, if not we check it either
                // returned exactly 1 (can't just be non-zero data), or had no return data.
                or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
                // We use 68 because the length of our calldata totals up like so: 4 + 32 * 2.
                // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space.
                // Counterintuitively, this call must be positioned second to the or() call in the
                // surrounding and() call or else returndatasize() will be zero during the computation.
                call(gas(), token, 0, freeMemoryPointer, 68, 0, 32)
            )
        }

        require(success, "TRANSFER_FAILED");
    }

    function safeApprove(
        ERC20 token,
        address to,
        uint256 amount
    ) internal {
        bool success;

        /// @solidity memory-safe-assembly
        assembly {
            // Get a pointer to some free memory.
            let freeMemoryPointer := mload(0x40)

            // Write the abi-encoded calldata into memory, beginning with the function selector.
            mstore(freeMemoryPointer, 0x095ea7b300000000000000000000000000000000000000000000000000000000)
            mstore(add(freeMemoryPointer, 4), and(to, 0xffffffffffffffffffffffffffffffffffffffff)) // Append and mask the "to" argument.
            mstore(add(freeMemoryPointer, 36), amount) // Append the "amount" argument. Masking not required as it's a full 32 byte type.

            success := and(
                // Set success to whether the call reverted, if not we check it either
                // returned exactly 1 (can't just be non-zero data), or had no return data.
                or(and(eq(mload(0), 1), gt(returndatasize(), 31)), iszero(returndatasize())),
                // We use 68 because the length of our calldata totals up like so: 4 + 32 * 2.
                // We use 0 and 32 to copy up to 32 bytes of return data into the scratch space.
                // Counterintuitively, this call must be positioned second to the or() call in the
                // surrounding and() call or else returndatasize() will be zero during the computation.
                call(gas(), token, 0, freeMemoryPointer, 68, 0, 32)
            )
        }

        require(success, "APPROVE_FAILED");
    }
}

error ZeroAddress();

/**
 * @title RescueFundsLib
 * @dev A library that provides a function to rescue funds from a contract.
 */

library RescueFundsLib {
    /**
     * @dev The address used to identify ETH.
     */
    address public constant ETH_ADDRESS =
        address(0xEeeeeEeeeEeEeeEeEeEeeEEEeeeeEeeeeeeeEEeE);

    /**
     * @dev thrown when the given token address don't have any code
     */
    error InvalidTokenAddress();

    /**
     * @dev Rescues funds from a contract.
     * @param token_ The address of the token contract.
     * @param rescueTo_ The address of the user.
     * @param amount_ The amount of tokens to be rescued.
     */
    function rescueFunds(
        address token_,
        address rescueTo_,
        uint256 amount_
    ) internal {
        if (rescueTo_ == address(0)) revert ZeroAddress();

        if (token_ == ETH_ADDRESS) {
            SafeTransferLib.safeTransferETH(rescueTo_, amount_);
        } else {
            if (token_.code.length == 0) revert InvalidTokenAddress();
            SafeTransferLib.safeTransfer(ERC20(token_), rescueTo_, amount_);
        }
    }
}

/**
 * @title Ownable
 * @dev The Ownable contract provides a simple way to manage ownership of a contract
 * and allows for ownership to be transferred to a nominated address.
 */
abstract contract Ownable {
    address private _owner;
    address private _nominee;

    event OwnerNominated(address indexed nominee);
    event OwnerClaimed(address indexed claimer);

    error OnlyOwner();
    error OnlyNominee();

    /**
     * @dev Sets the contract's owner to the address that is passed to the constructor.
     */
    constructor(address owner_) {
        _claimOwner(owner_);
    }

    /**
     * @dev Modifier that restricts access to only the contract's owner.
     * Throws an error if the caller is not the owner.
     */
    modifier onlyOwner() {
        if (msg.sender != _owner) revert OnlyOwner();
        _;
    }

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

    /**
     * @dev Returns the current nominee for ownership of the contract.
     */
    function nominee() external view returns (address) {
        return _nominee;
    }

    /**
     * @dev Allows the current owner to nominate a new owner for the contract.
     * Throws an error if the caller is not the owner.
     * Emits an `OwnerNominated` event with the address of the nominee.
     */
    function nominateOwner(address nominee_) external {
        if (msg.sender != _owner) revert OnlyOwner();
        _nominee = nominee_;
        emit OwnerNominated(_nominee);
    }

    /**
     * @dev Allows the nominated owner to claim ownership of the contract.
     * Throws an error if the caller is not the nominee.
     * Sets the nominated owner as the new owner of the contract.
     * Emits an `OwnerClaimed` event with the address of the new owner.
     */
    function claimOwner() external {
        if (msg.sender != _nominee) revert OnlyNominee();
        _claimOwner(msg.sender);
    }

    /**
     * @dev Internal function that sets the owner of the contract to the specified address
     * and sets the nominee to address(0).
     */
    function _claimOwner(address claimer_) internal {
        _owner = claimer_;
        _nominee = address(0);
        emit OwnerClaimed(claimer_);
    }
}

/**
 * @title AccessControl
 * @dev This abstract contract implements access control mechanism based on roles.
 * Each role can have one or more addresses associated with it, which are granted
 * permission to execute functions with the onlyRole modifier.
 */
abstract contract AccessControl is Ownable {
    /**
     * @dev A mapping of roles to a mapping of addresses to boolean values indicating whether or not they have the role.
     */
    mapping(bytes32 => mapping(address => bool)) private _permits;

    /**
     * @dev Emitted when a role is granted to an address.
     */
    event RoleGranted(bytes32 indexed role, address indexed grantee);

    /**
     * @dev Emitted when a role is revoked from an address.
     */
    event RoleRevoked(bytes32 indexed role, address indexed revokee);

    /**
     * @dev Error message thrown when an address does not have permission to execute a function with onlyRole modifier.
     */
    error NoPermit(bytes32 role);

    /**
     * @dev Constructor that sets the owner of the contract.
     */
    constructor(address owner_) Ownable(owner_) {}

    /**
     * @dev Modifier that restricts access to addresses having roles
     * Throws an error if the caller do not have permit
     */
    modifier onlyRole(bytes32 role) {
        if (!_permits[role][msg.sender]) revert NoPermit(role);
        _;
    }

    /**
     * @dev Checks and reverts if an address do not have a specific role.
     * @param role_ The role to check.
     * @param address_ The address to check.
     */
    function _checkRole(bytes32 role_, address address_) internal virtual {
        if (!_hasRole(role_, address_)) revert NoPermit(role_);
    }

    /**
     * @dev Grants a role to a given address.
     * @param role_ The role to grant.
     * @param grantee_ The address to grant the role to.
     * Emits a RoleGranted event.
     * Can only be called by the owner of the contract.
     */
    function grantRole(
        bytes32 role_,
        address grantee_
    ) external virtual onlyOwner {
        _grantRole(role_, grantee_);
    }

    /**
     * @dev Revokes a role from a given address.
     * @param role_ The role to revoke.
     * @param revokee_ The address to revoke the role from.
     * Emits a RoleRevoked event.
     * Can only be called by the owner of the contract.
     */
    function revokeRole(
        bytes32 role_,
        address revokee_
    ) external virtual onlyOwner {
        _revokeRole(role_, revokee_);
    }

    /**
     * @dev Internal function to grant a role to a given address.
     * @param role_ The role to grant.
     * @param grantee_ The address to grant the role to.
     * Emits a RoleGranted event.
     */
    function _grantRole(bytes32 role_, address grantee_) internal {
        _permits[role_][grantee_] = true;
        emit RoleGranted(role_, grantee_);
    }

    /**
     * @dev Internal function to revoke a role from a given address.
     * @param role_ The role to revoke.
     * @param revokee_ The address to revoke the role from.
     * Emits a RoleRevoked event.
     */
    function _revokeRole(bytes32 role_, address revokee_) internal {
        _permits[role_][revokee_] = false;
        emit RoleRevoked(role_, revokee_);
    }

    /**
     * @dev Checks whether an address has a specific role.
     * @param role_ The role to check.
     * @param address_ The address to check.
     * @return A boolean value indicating whether or not the address has the role.
     */
    function hasRole(
        bytes32 role_,
        address address_
    ) external view returns (bool) {
        return _hasRole(role_, address_);
    }

    function _hasRole(
        bytes32 role_,
        address address_
    ) internal view returns (bool) {
        return _permits[role_][address_];
    }
}

/**
 * @title Base contract for super token and vault
 * @notice It contains relevant execution payload storages.
 * @dev This contract implements Socket's IPlug to enable message bridging and IMessageBridge
 * to support any type of message bridge.
 */
abstract contract RescueBase is AccessControl {
    bytes32 constant RESCUE_ROLE = keccak256("RESCUE_ROLE");

    /**
     * @notice Rescues funds from the contract if they are locked by mistake.
     * @param token_ The address of the token contract.
     * @param rescueTo_ The address where rescued tokens need to be sent.
     * @param amount_ The amount of tokens to be rescued.
     */
    function rescueFunds(
        address token_,
        address rescueTo_,
        uint256 amount_
    ) external onlyRole(RESCUE_ROLE) {
        RescueFundsLib.rescueFunds(token_, rescueTo_, amount_);
    }
}

contract Faucet is RescueBase {
    using SafeTransferLib for ERC20;

    constructor() AccessControl(msg.sender) {
        _grantRole(RESCUE_ROLE, msg.sender);
    }

    function getTokens(address receiver_, address[] calldata tokens_) external {
        for (uint256 i = 0; i < tokens_.length; i++) {
            ERC20 token = ERC20(tokens_[i]);
            uint256 amount = 10**token.decimals() * 1000;
            token.safeTransfer(receiver_, amount);
        }
    }
}

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"InvalidTokenAddress","type":"error"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"NoPermit","type":"error"},{"inputs":[],"name":"OnlyNominee","type":"error"},{"inputs":[],"name":"OnlyOwner","type":"error"},{"inputs":[],"name":"ZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"claimer","type":"address"}],"name":"OwnerClaimed","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"nominee","type":"address"}],"name":"OwnerNominated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"grantee","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"revokee","type":"address"}],"name":"RoleRevoked","type":"event"},{"inputs":[],"name":"claimOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"receiver_","type":"address"},{"internalType":"address[]","name":"tokens_","type":"address[]"}],"name":"getTokens","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role_","type":"bytes32"},{"internalType":"address","name":"grantee_","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role_","type":"bytes32"},{"internalType":"address","name":"address_","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"nominee_","type":"address"}],"name":"nominateOwner","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"nominee","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token_","type":"address"},{"internalType":"address","name":"rescueTo_","type":"address"},{"internalType":"uint256","name":"amount_","type":"uint256"}],"name":"rescueFunds","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role_","type":"bytes32"},{"internalType":"address","name":"revokee_","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

21680:489:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21859:307;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;15617:85;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;18868:150;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;16420:132;;;:::i;:::-;;15937:183;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;21462:211;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;15438:81;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;20471:155;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;19288:152;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;21859:307;21950:9;21945:214;21969:7;;:14;;21965:1;:18;21945:214;;;22005:11;22025:7;;22033:1;22025:10;;;;;;;:::i;:::-;;;;;;;;;;;;;;;:::i;:::-;22005:31;;22051:14;22091:4;22072:5;:14;;;:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;22068:2;:20;;;;:::i;:::-;:27;;;;:::i;:::-;22051:44;;22110:37;22129:9;22140:6;22110:5;:18;;;;:37;;;;;:::i;:::-;21990:169;;21985:3;;;;;:::i;:::-;;;;21945:214;;;;21859:307;;;:::o;15617:85::-;15659:7;15686:8;;;;;;;;;;;15679:15;;15617:85;:::o;18868:150::-;15310:6;;;;;;;;;;15296:20;;:10;:20;;;15292:44;;15325:11;;;;;;;;;;;;;;15292:44;18983:27:::1;18994:5;19001:8;18983:10;:27::i;:::-;18868:150:::0;;:::o;16420:132::-;16480:8;;;;;;;;;;;16466:22;;:10;:22;;;16462:48;;16497:13;;;;;;;;;;;;;;16462:48;16521:23;16533:10;16521:11;:23::i;:::-;16420:132::o;15937:183::-;16016:6;;;;;;;;;;16002:20;;:10;:20;;;15998:44;;16031:11;;;;;;;;;;;;;;15998:44;16064:8;16053;;:19;;;;;;;;;;;;;;;;;;16103:8;;;;;;;;;;;16088:24;;;;;;;;;;;;15937:183;:::o;21462:211::-;21141:24;18206:8;:14;18215:4;18206:14;;;;;;;;;;;:26;18221:10;18206:26;;;;;;;;;;;;;;;;;;;;;;;;;18201:54;;18250:4;18241:14;;;;;;;;;;;:::i;:::-;;;;;;;;18201:54;21611::::1;21638:6;21646:9;21657:7;21611:26;:54::i;:::-;21462:211:::0;;;;:::o;15438:81::-;15478:7;15505:6;;;;;;;;;;;15498:13;;15438:81;:::o;20471:155::-;20569:4;20593:25;20602:5;20609:8;20593;:25::i;:::-;20586:32;;20471:155;;;;:::o;19288:152::-;15310:6;;;;;;;;;;15296:20;;:10;:20;;;15292:44;;15325:11;;;;;;;;;;;;;;15292:44;19404:28:::1;19416:5;19423:8;19404:11;:28::i;:::-;19288:152:::0;;:::o;10039:1637::-;10156:12;10331:4;10325:11;10476:66;10457:17;10450:93;10599:42;10595:2;10591:51;10587:1;10568:17;10564:25;10557:86;10730:6;10725:2;10706:17;10702:26;10695:42;11592:2;11589:1;11585:2;11566:17;11563:1;11556:5;11549;11544:51;11108:16;11101:24;11095:2;11077:16;11074:24;11070:1;11066;11060:8;11057:15;11053:46;11050:76;10847:763;10836:774;;10234:1387;11641:7;11633:35;;;;;;;;;;;;:::i;:::-;;;;;;;;;10145:1531;10039:1637;;;:::o;19666:157::-;19767:4;19739:8;:15;19748:5;19739:15;;;;;;;;;;;:25;19755:8;19739:25;;;;;;;;;;;;;;;;:32;;;;;;;;;;;;;;;;;;19806:8;19787:28;;19799:5;19787:28;;;;;;;;;;19666:157;;:::o;16714:154::-;16782:8;16773:6;;:17;;;;;;;;;;;;;;;;;;16820:1;16801:8;;:21;;;;;;;;;;;;;;;;;;16851:8;16838:22;;;;;;;;;;;;16714:154;:::o;14018:469::-;14170:1;14149:23;;:9;:23;;;14145:49;;14181:13;;;;;;;;;;;;;;14145:49;13615:42;14211:21;;:6;:21;;;14207:273;;14249:51;14281:9;14292:7;14249:31;:51::i;:::-;14207:273;;;14359:1;14337:6;:18;;;:23;14333:57;;14369:21;;;;;;;;;;;;;;14333:57;14405:63;14440:6;14449:9;14460:7;14405:28;:63::i;:::-;14207:273;14018:469;;;:::o;20634:156::-;20733:4;20757:8;:15;20766:5;20757:15;;;;;;;;;;;:25;20773:8;20757:25;;;;;;;;;;;;;;;;;;;;;;;;;20750:32;;20634:156;;;;:::o;20056:159::-;20158:5;20130:8;:15;20139:5;20130:15;;;;;;;;;;;:25;20146:8;20130:25;;;;;;;;;;;;;;;;:33;;;;;;;;;;;;;;;;;;20198:8;20179:28;;20191:5;20179:28;;;;;;;;;;20056:159;;:::o;7672:349::-;7745:12;7949:1;7946;7943;7940;7932:6;7928:2;7921:5;7916:35;7905:46;;7982:7;7974:39;;;;;;;;;;;;:::i;:::-;;;;;;;;;7734:287;7672:349;;:::o;88:117:1:-;197:1;194;187:12;211:117;320:1;317;310:12;334:126;371:7;411:42;404:5;400:54;389:65;;334:126;;;:::o;466:96::-;503:7;532:24;550:5;532:24;:::i;:::-;521:35;;466:96;;;:::o;568:122::-;641:24;659:5;641:24;:::i;:::-;634:5;631:35;621:63;;680:1;677;670:12;621:63;568:122;:::o;696:139::-;742:5;780:6;767:20;758:29;;796:33;823:5;796:33;:::i;:::-;696:139;;;;:::o;841:117::-;950:1;947;940:12;964:117;1073:1;1070;1063:12;1087:117;1196:1;1193;1186:12;1227:568;1300:8;1310:6;1360:3;1353:4;1345:6;1341:17;1337:27;1327:122;;1368:79;;:::i;:::-;1327:122;1481:6;1468:20;1458:30;;1511:18;1503:6;1500:30;1497:117;;;1533:79;;:::i;:::-;1497:117;1647:4;1639:6;1635:17;1623:29;;1701:3;1693:4;1685:6;1681:17;1671:8;1667:32;1664:41;1661:128;;;1708:79;;:::i;:::-;1661:128;1227:568;;;;;:::o;1801:704::-;1896:6;1904;1912;1961:2;1949:9;1940:7;1936:23;1932:32;1929:119;;;1967:79;;:::i;:::-;1929:119;2087:1;2112:53;2157:7;2148:6;2137:9;2133:22;2112:53;:::i;:::-;2102:63;;2058:117;2242:2;2231:9;2227:18;2214:32;2273:18;2265:6;2262:30;2259:117;;;2295:79;;:::i;:::-;2259:117;2408:80;2480:7;2471:6;2460:9;2456:22;2408:80;:::i;:::-;2390:98;;;;2185:313;1801:704;;;;;:::o;2511:118::-;2598:24;2616:5;2598:24;:::i;:::-;2593:3;2586:37;2511:118;;:::o;2635:222::-;2728:4;2766:2;2755:9;2751:18;2743:26;;2779:71;2847:1;2836:9;2832:17;2823:6;2779:71;:::i;:::-;2635:222;;;;:::o;2863:77::-;2900:7;2929:5;2918:16;;2863:77;;;:::o;2946:122::-;3019:24;3037:5;3019:24;:::i;:::-;3012:5;3009:35;2999:63;;3058:1;3055;3048:12;2999:63;2946:122;:::o;3074:139::-;3120:5;3158:6;3145:20;3136:29;;3174:33;3201:5;3174:33;:::i;:::-;3074:139;;;;:::o;3219:474::-;3287:6;3295;3344:2;3332:9;3323:7;3319:23;3315:32;3312:119;;;3350:79;;:::i;:::-;3312:119;3470:1;3495:53;3540:7;3531:6;3520:9;3516:22;3495:53;:::i;:::-;3485:63;;3441:117;3597:2;3623:53;3668:7;3659:6;3648:9;3644:22;3623:53;:::i;:::-;3613:63;;3568:118;3219:474;;;;;:::o;3699:329::-;3758:6;3807:2;3795:9;3786:7;3782:23;3778:32;3775:119;;;3813:79;;:::i;:::-;3775:119;3933:1;3958:53;4003:7;3994:6;3983:9;3979:22;3958:53;:::i;:::-;3948:63;;3904:117;3699:329;;;;:::o;4034:77::-;4071:7;4100:5;4089:16;;4034:77;;;:::o;4117:122::-;4190:24;4208:5;4190:24;:::i;:::-;4183:5;4180:35;4170:63;;4229:1;4226;4219:12;4170:63;4117:122;:::o;4245:139::-;4291:5;4329:6;4316:20;4307:29;;4345:33;4372:5;4345:33;:::i;:::-;4245:139;;;;:::o;4390:619::-;4467:6;4475;4483;4532:2;4520:9;4511:7;4507:23;4503:32;4500:119;;;4538:79;;:::i;:::-;4500:119;4658:1;4683:53;4728:7;4719:6;4708:9;4704:22;4683:53;:::i;:::-;4673:63;;4629:117;4785:2;4811:53;4856:7;4847:6;4836:9;4832:22;4811:53;:::i;:::-;4801:63;;4756:118;4913:2;4939:53;4984:7;4975:6;4964:9;4960:22;4939:53;:::i;:::-;4929:63;;4884:118;4390:619;;;;;:::o;5015:90::-;5049:7;5092:5;5085:13;5078:21;5067:32;;5015:90;;;:::o;5111:109::-;5192:21;5207:5;5192:21;:::i;:::-;5187:3;5180:34;5111:109;;:::o;5226:210::-;5313:4;5351:2;5340:9;5336:18;5328:26;;5364:65;5426:1;5415:9;5411:17;5402:6;5364:65;:::i;:::-;5226:210;;;;:::o;5442:180::-;5490:77;5487:1;5480:88;5587:4;5584:1;5577:15;5611:4;5608:1;5601:15;5628:86;5663:7;5703:4;5696:5;5692:16;5681:27;;5628:86;;;:::o;5720:118::-;5791:22;5807:5;5791:22;:::i;:::-;5784:5;5781:33;5771:61;;5828:1;5825;5818:12;5771:61;5720:118;:::o;5844:139::-;5899:5;5930:6;5924:13;5915:22;;5946:31;5971:5;5946:31;:::i;:::-;5844:139;;;;:::o;5989:347::-;6057:6;6106:2;6094:9;6085:7;6081:23;6077:32;6074:119;;;6112:79;;:::i;:::-;6074:119;6232:1;6257:62;6311:7;6302:6;6291:9;6287:22;6257:62;:::i;:::-;6247:72;;6203:126;5989:347;;;;:::o;6342:180::-;6390:77;6387:1;6380:88;6487:4;6484:1;6477:15;6511:4;6508:1;6501:15;6528:102;6570:8;6617:5;6614:1;6610:13;6589:34;;6528:102;;;:::o;6636:848::-;6697:5;6704:4;6728:6;6719:15;;6752:5;6743:14;;6766:712;6787:1;6777:8;6774:15;6766:712;;;6882:4;6877:3;6873:14;6867:4;6864:24;6861:50;;;6891:18;;:::i;:::-;6861:50;6941:1;6931:8;6927:16;6924:451;;;7356:4;7349:5;7345:16;7336:25;;6924:451;7406:4;7400;7396:15;7388:23;;7436:32;7459:8;7436:32;:::i;:::-;7424:44;;6766:712;;;6636:848;;;;;;;:::o;7490:1073::-;7544:5;7735:8;7725:40;;7756:1;7747:10;;7758:5;;7725:40;7784:4;7774:36;;7801:1;7792:10;;7803:5;;7774:36;7870:4;7918:1;7913:27;;;;7954:1;7949:191;;;;7863:277;;7913:27;7931:1;7922:10;;7933:5;;;7949:191;7994:3;7984:8;7981:17;7978:43;;;8001:18;;:::i;:::-;7978:43;8050:8;8047:1;8043:16;8034:25;;8085:3;8078:5;8075:14;8072:40;;;8092:18;;:::i;:::-;8072:40;8125:5;;;7863:277;;8249:2;8239:8;8236:16;8230:3;8224:4;8221:13;8217:36;8199:2;8189:8;8186:16;8181:2;8175:4;8172:12;8168:35;8152:111;8149:246;;;8305:8;8299:4;8295:19;8286:28;;8340:3;8333:5;8330:14;8327:40;;;8347:18;;:::i;:::-;8327:40;8380:5;;8149:246;8420:42;8458:3;8448:8;8442:4;8439:1;8420:42;:::i;:::-;8405:57;;;;8494:4;8489:3;8485:14;8478:5;8475:25;8472:51;;;8503:18;;:::i;:::-;8472:51;8552:4;8545:5;8541:16;8532:25;;7490:1073;;;;;;:::o;8569:281::-;8627:5;8651:23;8669:4;8651:23;:::i;:::-;8643:31;;8695:25;8711:8;8695:25;:::i;:::-;8683:37;;8739:104;8776:66;8766:8;8760:4;8739:104;:::i;:::-;8730:113;;8569:281;;;;:::o;8856:348::-;8896:7;8919:20;8937:1;8919:20;:::i;:::-;8914:25;;8953:20;8971:1;8953:20;:::i;:::-;8948:25;;9141:1;9073:66;9069:74;9066:1;9063:81;9058:1;9051:9;9044:17;9040:105;9037:131;;;9148:18;;:::i;:::-;9037:131;9196:1;9193;9189:9;9178:20;;8856:348;;;;:::o;9210:233::-;9249:3;9272:24;9290:5;9272:24;:::i;:::-;9263:33;;9318:66;9311:5;9308:77;9305:103;;9388:18;;:::i;:::-;9305:103;9435:1;9428:5;9424:13;9417:20;;9210:233;;;:::o;9449:118::-;9536:24;9554:5;9536:24;:::i;:::-;9531:3;9524:37;9449:118;;:::o;9573:222::-;9666:4;9704:2;9693:9;9689:18;9681:26;;9717:71;9785:1;9774:9;9770:17;9761:6;9717:71;:::i;:::-;9573:222;;;;:::o;9801:169::-;9885:11;9919:6;9914:3;9907:19;9959:4;9954:3;9950:14;9935:29;;9801:169;;;;:::o;9976:165::-;10116:17;10112:1;10104:6;10100:14;10093:41;9976:165;:::o;10147:366::-;10289:3;10310:67;10374:2;10369:3;10310:67;:::i;:::-;10303:74;;10386:93;10475:3;10386:93;:::i;:::-;10504:2;10499:3;10495:12;10488:19;;10147:366;;;:::o;10519:419::-;10685:4;10723:2;10712:9;10708:18;10700:26;;10772:9;10766:4;10762:20;10758:1;10747:9;10743:17;10736:47;10800:131;10926:4;10800:131;:::i;:::-;10792:139;;10519:419;;;:::o;10944:169::-;11084:21;11080:1;11072:6;11068:14;11061:45;10944:169;:::o;11119:366::-;11261:3;11282:67;11346:2;11341:3;11282:67;:::i;:::-;11275:74;;11358:93;11447:3;11358:93;:::i;:::-;11476:2;11471:3;11467:12;11460:19;;11119:366;;;:::o;11491:419::-;11657:4;11695:2;11684:9;11680:18;11672:26;;11744:9;11738:4;11734:20;11730:1;11719:9;11715:17;11708:47;11772:131;11898:4;11772:131;:::i;:::-;11764:139;;11491:419;;;:::o

ipfs://5e0c13abe9d58cfb85151fce3fad03309b28c084d37966ea4f48fb146abdebf4