Contract

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

• interface IERC165
•    - function supportsInterface(bytes4 int ...
•    - function supportsInterface(bytes4 int ...
• library Math
•    - function max(uint256 a, uint256 b)
•    - function min(uint256 a, uint256 b)
•    - function average(uint256 a, uint256 b ...
•    - function ceilDiv(uint256 a, uint256 b ...
•    - function mulDiv(
•    - function mulDiv(
•    - function sqrt(uint256 a)
•    - function sqrt(uint256 a, Rounding rou ...
•    - function log2(uint256 value)
•    - function log2(uint256 value, Rounding ...
•    - function log10(uint256 value)
•    - function log10(uint256 value, Roundin ...
•    - function log256(uint256 value)
•    - function log256(uint256 value, Roundi ...
• library Strings
•    - function toString(uint256 value)
•    - function toHexString(uint256 value)
•    - function toHexString(uint256 value, u ...
•    - function toHexString(address addr)
• interface IAccessControl
•    - function hasRole(bytes32 role, addres ...
•    - function getRoleAdmin(bytes32 role)
•    - function grantRole(bytes32 role, addr ...
•    - function revokeRole(bytes32 role, add ...
•    - function renounceRole(bytes32 role, a ...
•    - function _msgSender()
•    - function _msgData()
•    - function supportsInterface(bytes4 int ...
•    - function hasRole(bytes32 role, addres ...
•    - function _checkRole(bytes32 role)
•    - function _checkRole(bytes32 role, add ...
•    - function getRoleAdmin(bytes32 role)
•    - function grantRole(bytes32 role, addr ...
•    - function revokeRole(bytes32 role, add ...
•    - function renounceRole(bytes32 role, a ...
•    - function _setupRole(bytes32 role, add ...
•    - function _setRoleAdmin(bytes32 role, ...
•    - function _grantRole(bytes32 role, add ...
•    - function _revokeRole(bytes32 role, ad ...
• library Address
•    - function isContract(address account)
•    - function sendValue(address payable re ...
•    - function functionCall(address target, ...
•    - function functionCall(
•    - function functionCallWithValue(
•    - function functionCallWithValue(
•    - function functionStaticCall(address t ...
•    - function functionStaticCall(
•    - function functionDelegateCall(address ...
•    - function functionDelegateCall(
•    - function verifyCallResultFromTarget(
•    - function verifyCallResult(
•    - function _revert(bytes memory returnd ...
• interface IERC20Permit
•    - function permit(
•    - function nonces(address owner)
•    - function DOMAIN_SEPARATOR()
• interface IERC20
•    - function totalSupply()
•    - function balanceOf(address account)
•    - function transfer(address to, uint256 ...
•    - function allowance(address owner, add ...
•    - function approve(address spender, uin ...
•    - function transferFrom(
• library SafeERC20
•    - function safeTransfer(
•    - function safeTransferFrom(
•    - function safeApprove(
•    - function safeIncreaseAllowance(
•    - function safeDecreaseAllowance(
•    - function safePermit(
•    - function _callOptionalReturn(IERC20 t ...
•  contract PaymentSplitter is Contex ...
•    - function totalShares()
•    - function totalReleased()
•    - function totalReleased(IERC20 token)
•    - function shares(address account)
•    - function released(address account)
•    - function released(IERC20 token, addre ...
•    - function payee(uint256 index)
•    - function releasable(address account)
•    - function releasable(IERC20 token, add ...
•    - function release(address payable acco ...
•    - function release(IERC20 token, addres ...
•    - function _pendingPayment(
•    - function _addPayee(address account, u ...
•  contract Treasury is PaymentSplitt ... *
•    - function releaseEth(address payable _ ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-11-30
*/

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface 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);
}

// File: @openzeppelin/contracts/utils/introspection/ERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;


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

// File: @openzeppelin/contracts/utils/math/Math.sol


// OpenZeppelin Contracts (last updated v4.8.0) (utils/math/Math.sol)

pragma solidity ^0.8.0;

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

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

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

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

    /**
     * @dev Returns the ceiling of the division of two numbers.
     *
     * This differs from standard division with `/` in that it rounds up instead
     * of rounding down.
     */
    function ceilDiv(uint256 a, uint256 b) internal pure returns (uint256) {
        // (a + b - 1) / b can overflow on addition, so we distribute.
        return a == 0 ? 0 : (a - 1) / b + 1;
    }

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

            // Handle non-overflow cases, 256 by 256 division.
            if (prod1 == 0) {
                return prod0 / denominator;
            }

            // Make sure the result is less than 2^256. Also prevents denominator == 0.
            require(denominator > prod1);

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

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

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

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

            // Does not overflow because the denominator cannot be zero at this stage in the function.
            uint256 twos = denominator & (~denominator + 1);
            assembly {
                // Divide denominator by twos.
                denominator := div(denominator, twos)

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/utils/Strings.sol


// OpenZeppelin Contracts (last updated v4.8.0) (utils/Strings.sol)

pragma solidity ^0.8.0;


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

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

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

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

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

// File: @openzeppelin/contracts/access/IAccessControl.sol


// OpenZeppelin Contracts v4.4.1 (access/IAccessControl.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/utils/Context.sol


// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

/**
 * @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;
    }
}

// File: @openzeppelin/contracts/access/AccessControl.sol


// OpenZeppelin Contracts (last updated v4.8.0) (access/AccessControl.sol)

pragma solidity ^0.8.0;





/**
 * @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:
 *
 * ```
 * 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}:
 *
 * ```
 * 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.
 */
abstract contract AccessControl is Context, IAccessControl, ERC165 {
    struct RoleData {
        mapping(address => bool) members;
        bytes32 adminRole;
    }

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

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

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

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

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

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

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

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

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

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

        _revokeRole(role, account);
    }

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

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

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

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

// File: @openzeppelin/contracts/utils/Address.sol


// OpenZeppelin Contracts (last updated v4.8.0) (utils/Address.sol)

pragma solidity ^0.8.1;

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

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC20/extensions/draft-IERC20Permit.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

    /**
     * @dev Emitted when the allowance of a `spender` for an `owner` is set by
     * a call to {approve}. `value` is the new allowance.
     */
    event Approval(address indexed owner, address indexed spender, uint256 value);

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol


// OpenZeppelin Contracts (last updated v4.8.0) (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;




/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

    function safeTransfer(
        IERC20 token,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(
        IERC20 token,
        address from,
        address to,
        uint256 value
    ) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        require(
            (value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        uint256 newAllowance = token.allowance(address(this), spender) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(
        IERC20 token,
        address spender,
        uint256 value
    ) internal {
        unchecked {
            uint256 oldAllowance = token.allowance(address(this), spender);
            require(oldAllowance >= value, "SafeERC20: decreased allowance below zero");
            uint256 newAllowance = oldAllowance - value;
            _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
        }
    }

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

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

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) {
            // Return data is optional
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

// File: @openzeppelin/contracts/finance/PaymentSplitter.sol


// OpenZeppelin Contracts (last updated v4.8.0) (finance/PaymentSplitter.sol)

pragma solidity ^0.8.0;




/**
 * @title PaymentSplitter
 * @dev This contract allows to split Ether payments among a group of accounts. The sender does not need to be aware
 * that the Ether will be split in this way, since it is handled transparently by the contract.
 *
 * The split can be in equal parts or in any other arbitrary proportion. The way this is specified is by assigning each
 * account to a number of shares. Of all the Ether that this contract receives, each account will then be able to claim
 * an amount proportional to the percentage of total shares they were assigned. The distribution of shares is set at the
 * time of contract deployment and can't be updated thereafter.
 *
 * `PaymentSplitter` follows a _pull payment_ model. This means that payments are not automatically forwarded to the
 * accounts but kept in this contract, and the actual transfer is triggered as a separate step by calling the {release}
 * function.
 *
 * NOTE: This contract assumes that ERC20 tokens will behave similarly to native tokens (Ether). Rebasing tokens, and
 * tokens that apply fees during transfers, are likely to not be supported as expected. If in doubt, we encourage you
 * to run tests before sending real value to this contract.
 */
contract PaymentSplitter is Context {
    event PayeeAdded(address account, uint256 shares);
    event PaymentReleased(address to, uint256 amount);
    event ERC20PaymentReleased(IERC20 indexed token, address to, uint256 amount);
    event PaymentReceived(address from, uint256 amount);

    uint256 private _totalShares;
    uint256 private _totalReleased;

    mapping(address => uint256) private _shares;
    mapping(address => uint256) private _released;
    address[] private _payees;

    mapping(IERC20 => uint256) private _erc20TotalReleased;
    mapping(IERC20 => mapping(address => uint256)) private _erc20Released;

    /**
     * @dev Creates an instance of `PaymentSplitter` where each account in `payees` is assigned the number of shares at
     * the matching position in the `shares` array.
     *
     * All addresses in `payees` must be non-zero. Both arrays must have the same non-zero length, and there must be no
     * duplicates in `payees`.
     */
    constructor(address[] memory payees, uint256[] memory shares_) payable {
        require(payees.length == shares_.length, "PaymentSplitter: payees and shares length mismatch");
        require(payees.length > 0, "PaymentSplitter: no payees");

        for (uint256 i = 0; i < payees.length; i++) {
            _addPayee(payees[i], shares_[i]);
        }
    }

    /**
     * @dev The Ether received will be logged with {PaymentReceived} events. Note that these events are not fully
     * reliable: it's possible for a contract to receive Ether without triggering this function. This only affects the
     * reliability of the events, and not the actual splitting of Ether.
     *
     * To learn more about this see the Solidity documentation for
     * https://solidity.readthedocs.io/en/latest/contracts.html#fallback-function[fallback
     * functions].
     */
    receive() external payable virtual {
        emit PaymentReceived(_msgSender(), msg.value);
    }

    /**
     * @dev Getter for the total shares held by payees.
     */
    function totalShares() public view returns (uint256) {
        return _totalShares;
    }

    /**
     * @dev Getter for the total amount of Ether already released.
     */
    function totalReleased() public view returns (uint256) {
        return _totalReleased;
    }

    /**
     * @dev Getter for the total amount of `token` already released. `token` should be the address of an IERC20
     * contract.
     */
    function totalReleased(IERC20 token) public view returns (uint256) {
        return _erc20TotalReleased[token];
    }

    /**
     * @dev Getter for the amount of shares held by an account.
     */
    function shares(address account) public view returns (uint256) {
        return _shares[account];
    }

    /**
     * @dev Getter for the amount of Ether already released to a payee.
     */
    function released(address account) public view returns (uint256) {
        return _released[account];
    }

    /**
     * @dev Getter for the amount of `token` tokens already released to a payee. `token` should be the address of an
     * IERC20 contract.
     */
    function released(IERC20 token, address account) public view returns (uint256) {
        return _erc20Released[token][account];
    }

    /**
     * @dev Getter for the address of the payee number `index`.
     */
    function payee(uint256 index) public view returns (address) {
        return _payees[index];
    }

    /**
     * @dev Getter for the amount of payee's releasable Ether.
     */
    function releasable(address account) public view returns (uint256) {
        uint256 totalReceived = address(this).balance + totalReleased();
        return _pendingPayment(account, totalReceived, released(account));
    }

    /**
     * @dev Getter for the amount of payee's releasable `token` tokens. `token` should be the address of an
     * IERC20 contract.
     */
    function releasable(IERC20 token, address account) public view returns (uint256) {
        uint256 totalReceived = token.balanceOf(address(this)) + totalReleased(token);
        return _pendingPayment(account, totalReceived, released(token, account));
    }

    /**
     * @dev Triggers a transfer to `account` of the amount of Ether they are owed, according to their percentage of the
     * total shares and their previous withdrawals.
     */
    function release(address payable account) public virtual {
        require(_shares[account] > 0, "PaymentSplitter: account has no shares");

        uint256 payment = releasable(account);

        require(payment != 0, "PaymentSplitter: account is not due payment");

        // _totalReleased is the sum of all values in _released.
        // If "_totalReleased += payment" does not overflow, then "_released[account] += payment" cannot overflow.
        _totalReleased += payment;
        unchecked {
            _released[account] += payment;
        }

        Address.sendValue(account, payment);
        emit PaymentReleased(account, payment);
    }

    /**
     * @dev Triggers a transfer to `account` of the amount of `token` tokens they are owed, according to their
     * percentage of the total shares and their previous withdrawals. `token` must be the address of an IERC20
     * contract.
     */
    function release(IERC20 token, address account) public virtual {
        require(_shares[account] > 0, "PaymentSplitter: account has no shares");

        uint256 payment = releasable(token, account);

        require(payment != 0, "PaymentSplitter: account is not due payment");

        // _erc20TotalReleased[token] is the sum of all values in _erc20Released[token].
        // If "_erc20TotalReleased[token] += payment" does not overflow, then "_erc20Released[token][account] += payment"
        // cannot overflow.
        _erc20TotalReleased[token] += payment;
        unchecked {
            _erc20Released[token][account] += payment;
        }

        SafeERC20.safeTransfer(token, account, payment);
        emit ERC20PaymentReleased(token, account, payment);
    }

    /**
     * @dev internal logic for computing the pending payment of an `account` given the token historical balances and
     * already released amounts.
     */
    function _pendingPayment(
        address account,
        uint256 totalReceived,
        uint256 alreadyReleased
    ) private view returns (uint256) {
        return (totalReceived * _shares[account]) / _totalShares - alreadyReleased;
    }

    /**
     * @dev Add a new payee to the contract.
     * @param account The address of the payee to add.
     * @param shares_ The number of shares owned by the payee.
     */
    function _addPayee(address account, uint256 shares_) private {
        require(account != address(0), "PaymentSplitter: account is the zero address");
        require(shares_ > 0, "PaymentSplitter: shares are 0");
        require(_shares[account] == 0, "PaymentSplitter: account already has shares");

        _payees.push(account);
        _shares[account] = shares_;
        _totalShares = _totalShares + shares_;
        emit PayeeAdded(account, shares_);
    }
}

// File: contracts/Treasury.sol


pragma solidity ^0.8.17;



contract Treasury is PaymentSplitter, AccessControl {
  constructor(
    address[] memory _accounts,
    uint256[] memory _allocation,
    address[] memory _admins
  ) PaymentSplitter(_accounts, _allocation) {
    _grantRole(DEFAULT_ADMIN_ROLE, msg.sender);
    for (uint256 i = 0; i < _admins.length; i++) {
      _grantRole(DEFAULT_ADMIN_ROLE, _admins[i]);
    }
  }

  function releaseEth(address payable _payee) external onlyRole(DEFAULT_ADMIN_ROLE) {
    release(_payee);
  }

  receive() external payable override(PaymentSplitter) {
    emit PaymentReceived(_msgSender(), msg.value);
  }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address[]","name":"_accounts","type":"address[]"},{"internalType":"uint256[]","name":"_allocation","type":"uint256[]"},{"internalType":"address[]","name":"_admins","type":"address[]"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract IERC20","name":"token","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ERC20PaymentReleased","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"PayeeAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PaymentReceived","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PaymentReleased","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":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"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":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"payee","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"releasable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"releasable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address payable","name":"account","type":"address"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"_payee","type":"address"}],"name":"releaseEth","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"released","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"released","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"shares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"totalReleased","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalReleased","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

0x6080604052600436106101185760003560e01c80638b83209b116100a0578063c45ac05011610064578063c45ac05014610432578063ce7c2ac21461046f578063d547741f146104ac578063d79779b2146104d5578063e33b7de3146105125761015f565b80638b83209b1461031357806391d14854146103505780639852595c1461038d578063a217fddf146103ca578063a3f8eace146103f55761015f565b806336568abe116100e757806336568abe146102305780633a98ef3914610259578063406072a91461028457806348b75044146102c15780636ca708c4146102ea5761015f565b806301ffc9a71461016457806319165587146101a1578063248a9ca3146101ca5780632f2ff15d146102075761015f565b3661015f577f6ef95f06320e7a25a04a175ca677b7052bdd97131872c2192525a629f51be77061014661053d565b34604051610155929190611766565b60405180910390a1005b600080fd5b34801561017057600080fd5b5061018b600480360381019061018691906117ec565b610545565b6040516101989190611834565b60405180910390f35b3480156101ad57600080fd5b506101c860048036038101906101c3919061188d565b6105bf565b005b3480156101d657600080fd5b506101f160048036038101906101ec91906118f0565b61073e565b6040516101fe919061192c565b60405180910390f35b34801561021357600080fd5b5061022e60048036038101906102299190611973565b61075e565b005b34801561023c57600080fd5b5061025760048036038101906102529190611973565b61077f565b005b34801561026557600080fd5b5061026e610802565b60405161027b91906119b3565b60405180910390f35b34801561029057600080fd5b506102ab60048036038101906102a69190611a0c565b61080b565b6040516102b891906119b3565b60405180910390f35b3480156102cd57600080fd5b506102e860048036038101906102e39190611a0c565b610892565b005b3480156102f657600080fd5b50610311600480360381019061030c919061188d565b610aa5565b005b34801561031f57600080fd5b5061033a60048036038101906103359190611a78565b610abf565b6040516103479190611aa5565b60405180910390f35b34801561035c57600080fd5b5061037760048036038101906103729190611973565b610b07565b6040516103849190611834565b60405180910390f35b34801561039957600080fd5b506103b460048036038101906103af9190611ac0565b610b72565b6040516103c191906119b3565b60405180910390f35b3480156103d657600080fd5b506103df610bbb565b6040516103ec919061192c565b60405180910390f35b34801561040157600080fd5b5061041c60048036038101906104179190611ac0565b610bc2565b60405161042991906119b3565b60405180910390f35b34801561043e57600080fd5b5061045960048036038101906104549190611a0c565b610bf5565b60405161046691906119b3565b60405180910390f35b34801561047b57600080fd5b5061049660048036038101906104919190611ac0565b610ca4565b6040516104a391906119b3565b60405180910390f35b3480156104b857600080fd5b506104d360048036038101906104ce9190611973565b610ced565b005b3480156104e157600080fd5b506104fc60048036038101906104f79190611aed565b610d0e565b60405161050991906119b3565b60405180910390f35b34801561051e57600080fd5b50610527610d57565b60405161053491906119b3565b60405180910390f35b600033905090565b60007f7965db0b000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff191614806105b857506105b782610d61565b5b9050919050565b6000600260008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000205411610641576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161063890611b9d565b60405180910390fd5b600061064c82610bc2565b905060008103610691576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161068890611c2f565b60405180910390fd5b80600160008282546106a39190611c7e565b9250508190555080600360008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020600082825401925050819055506107018282610dcb565b7fdf20fd1e76bc69d672e4814fafb2c449bba3a5369d8359adf9e05e6fde87b0568282604051610732929190611d11565b60405180910390a15050565b600060076000838152602001908152602001600020600101549050919050565b6107678261073e565b61077081610ebf565b61077a8383610ed3565b505050565b61078761053d565b73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16146107f4576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016107eb90611dac565b60405180910390fd5b6107fe8282610fb4565b5050565b60008054905090565b6000600660008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002054905092915050565b6000600260008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff1681526020019081526020016000205411610914576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161090b90611b9d565b60405180910390fd5b60006109208383610bf5565b905060008103610965576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161095c90611c2f565b60405180910390fd5b80600560008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008282546109b49190611c7e565b9250508190555080600660008573ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008473ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060008282540192505081905550610a50838383611096565b8273ffffffffffffffffffffffffffffffffffffffff167f3be5b7a71e84ed12875d241991c70855ac5817d847039e17a9d895c1ceb0f18a8383604051610a98929190611766565b60405180910390a2505050565b6000801b610ab281610ebf565b610abb826105bf565b5050565b600060048281548110610ad557610ad4611dcc565b5b9060005260206000200160009054906101000a900473ffffffffffffffffffffffffffffffffffffffff169050919050565b60006007600084815260200190815260200160002060000160008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060009054906101000a900460ff16905092915050565b6000600360008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b6000801b81565b600080610bcd610d57565b47610bd89190611c7e565b9050610bed8382610be886610b72565b61111c565b915050919050565b600080610c0184610d0e565b8473ffffffffffffffffffffffffffffffffffffffff166370a08231306040518263ffffffff1660e01b8152600401610c3a9190611aa5565b602060405180830381865afa158015610c57573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190610c7b9190611e10565b610c859190611c7e565b9050610c9b8382610c96878761080b565b61111c565b91505092915050565b6000600260008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b610cf68261073e565b610cff81610ebf565b610d098383610fb4565b505050565b6000600560008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020549050919050565b6000600154905090565b60007f01ffc9a7000000000000000000000000000000000000000000000000000000007bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916827bffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916149050919050565b80471015610e0e576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610e0590611e89565b60405180910390fd5b60008273ffffffffffffffffffffffffffffffffffffffff1682604051610e3490611eda565b60006040518083038185875af1925050503d8060008114610e71576040519150601f19603f3d011682016040523d82523d6000602084013e610e76565b606091505b5050905080610eba576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401610eb190611f61565b60405180910390fd5b505050565b610ed081610ecb61053d565b61118a565b50565b610edd8282610b07565b610fb05760016007600084815260200190815260200160002060000160008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff021916908315150217905550610f5561053d565b73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16837f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d60405160405180910390a45b5050565b610fbe8282610b07565b156110925760006007600084815260200190815260200160002060000160008373ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff16815260200190815260200160002060006101000a81548160ff02191690831515021790555061103761053d565b73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16837ff6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b60405160405180910390a45b5050565b6111178363a9059cbb60e01b84846040516024016110b5929190611766565b604051602081830303815290604052907bffffffffffffffffffffffffffffffffffffffffffffffffffffffff19166020820180517bffffffffffffffffffffffffffffffffffffffffffffffffffffffff838183161783525050505061120f565b505050565b600081600054600260008773ffffffffffffffffffffffffffffffffffffffff1673ffffffffffffffffffffffffffffffffffffffff168152602001908152602001600020548561116d9190611f81565b6111779190611ff2565b6111819190612023565b90509392505050565b6111948282610b07565b61120b576111a1816112d6565b6111af8360001c6020611303565b6040516020016111c0929190612160565b6040516020818303038152906040526040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161120291906121e4565b60405180910390fd5b5050565b6000611271826040518060400160405280602081526020017f5361666545524332303a206c6f772d6c6576656c2063616c6c206661696c65648152508573ffffffffffffffffffffffffffffffffffffffff1661153f9092919063ffffffff16565b90506000815111156112d157808060200190518101906112919190612232565b6112d0576040517f08c379a00000000000000000000000000000000000000000000000000000000081526004016112c7906122d1565b60405180910390fd5b5b505050565b60606112fc8273ffffffffffffffffffffffffffffffffffffffff16601460ff16611303565b9050919050565b6060600060028360026113169190611f81565b6113209190611c7e565b67ffffffffffffffff811115611339576113386122f1565b5b6040519080825280601f01601f19166020018201604052801561136b5781602001600182028036833780820191505090505b5090507f3000000000000000000000000000000000000000000000000000000000000000816000815181106113a3576113a2611dcc565b5b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a9053507f78000000000000000000000000000000000000000000000000000000000000008160018151811061140757611406611dcc565b5b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a905350600060018460026114479190611f81565b6114519190611c7e565b90505b60018111156114f1577f3031323334353637383961626364656600000000000000000000000000000000600f86166010811061149357611492611dcc565b5b1a60f81b8282815181106114aa576114a9611dcc565b5b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a905350600485901c9450806114ea90612320565b9050611454565b5060008414611535576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161152c90612395565b60405180910390fd5b8091505092915050565b606061154e8484600085611557565b90509392505050565b60608247101561159c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161159390612427565b60405180910390fd5b6000808673ffffffffffffffffffffffffffffffffffffffff1685876040516115c59190612483565b60006040518083038185875af1925050503d8060008114611602576040519150601f19603f3d011682016040523d82523d6000602084013e611607565b606091505b509150915061161887838387611624565b92505050949350505050565b6060831561168657600083510361167e5761163e85611699565b61167d576040517f08c379a0000000000000000000000000000000000000000000000000000000008152600401611674906124e6565b60405180910390fd5b5b829050611691565b61169083836116bc565b5b949350505050565b6000808273ffffffffffffffffffffffffffffffffffffffff163b119050919050565b6000825111156116cf5781518083602001fd5b806040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161170391906121e4565b60405180910390fd5b600073ffffffffffffffffffffffffffffffffffffffff82169050919050565b60006117378261170c565b9050919050565b6117478161172c565b82525050565b6000819050919050565b6117608161174d565b82525050565b600060408201905061177b600083018561173e565b6117886020830184611757565b9392505050565b600080fd5b60007fffffffff0000000000000000000000000000000000000000000000000000000082169050919050565b6117c981611794565b81146117d457600080fd5b50565b6000813590506117e6816117c0565b92915050565b6000602082840312156118025761180161178f565b5b6000611810848285016117d7565b91505092915050565b60008115159050919050565b61182e81611819565b82525050565b60006020820190506118496000830184611825565b92915050565b600061185a8261170c565b9050919050565b61186a8161184f565b811461187557600080fd5b50565b60008135905061188781611861565b92915050565b6000602082840312156118a3576118a261178f565b5b60006118b184828501611878565b91505092915050565b6000819050919050565b6118cd816118ba565b81146118d857600080fd5b50565b6000813590506118ea816118c4565b92915050565b6000602082840312156119065761190561178f565b5b6000611914848285016118db565b91505092915050565b611926816118ba565b82525050565b6000602082019050611941600083018461191d565b92915050565b6119508161172c565b811461195b57600080fd5b50565b60008135905061196d81611947565b92915050565b6000806040838503121561198a5761198961178f565b5b6000611998858286016118db565b92505060206119a98582860161195e565b9150509250929050565b60006020820190506119c86000830184611757565b92915050565b60006119d98261172c565b9050919050565b6119e9816119ce565b81146119f457600080fd5b50565b600081359050611a06816119e0565b92915050565b60008060408385031215611a2357611a2261178f565b5b6000611a31858286016119f7565b9250506020611a428582860161195e565b9150509250929050565b611a558161174d565b8114611a6057600080fd5b50565b600081359050611a7281611a4c565b92915050565b600060208284031215611a8e57611a8d61178f565b5b6000611a9c84828501611a63565b91505092915050565b6000602082019050611aba600083018461173e565b92915050565b600060208284031215611ad657611ad561178f565b5b6000611ae48482850161195e565b91505092915050565b600060208284031215611b0357611b0261178f565b5b6000611b11848285016119f7565b91505092915050565b600082825260208201905092915050565b7f5061796d656e7453706c69747465723a206163636f756e7420686173206e6f2060008201527f7368617265730000000000000000000000000000000000000000000000000000602082015250565b6000611b87602683611b1a565b9150611b9282611b2b565b604082019050919050565b60006020820190508181036000830152611bb681611b7a565b9050919050565b7f5061796d656e7453706c69747465723a206163636f756e74206973206e6f742060008201527f647565207061796d656e74000000000000000000000000000000000000000000602082015250565b6000611c19602b83611b1a565b9150611c2482611bbd565b604082019050919050565b60006020820190508181036000830152611c4881611c0c565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b6000611c898261174d565b9150611c948361174d565b9250828201905080821115611cac57611cab611c4f565b5b92915050565b6000819050919050565b6000611cd7611cd2611ccd8461170c565b611cb2565b61170c565b9050919050565b6000611ce982611cbc565b9050919050565b6000611cfb82611cde565b9050919050565b611d0b81611cf0565b82525050565b6000604082019050611d266000830185611d02565b611d336020830184611757565b9392505050565b7f416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e636560008201527f20726f6c657320666f722073656c660000000000000000000000000000000000602082015250565b6000611d96602f83611b1a565b9150611da182611d3a565b604082019050919050565b60006020820190508181036000830152611dc581611d89565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b600081519050611e0a81611a4c565b92915050565b600060208284031215611e2657611e2561178f565b5b6000611e3484828501611dfb565b91505092915050565b7f416464726573733a20696e73756666696369656e742062616c616e6365000000600082015250565b6000611e73601d83611b1a565b9150611e7e82611e3d565b602082019050919050565b60006020820190508181036000830152611ea281611e66565b9050919050565b600081905092915050565b50565b6000611ec4600083611ea9565b9150611ecf82611eb4565b600082019050919050565b6000611ee582611eb7565b9150819050919050565b7f416464726573733a20756e61626c6520746f2073656e642076616c75652c207260008201527f6563697069656e74206d61792068617665207265766572746564000000000000602082015250565b6000611f4b603a83611b1a565b9150611f5682611eef565b604082019050919050565b60006020820190508181036000830152611f7a81611f3e565b9050919050565b6000611f8c8261174d565b9150611f978361174d565b9250828202611fa58161174d565b91508282048414831517611fbc57611fbb611c4f565b5b5092915050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b6000611ffd8261174d565b91506120088361174d565b92508261201857612017611fc3565b5b828204905092915050565b600061202e8261174d565b91506120398361174d565b925082820390508181111561205157612050611c4f565b5b92915050565b600081905092915050565b7f416363657373436f6e74726f6c3a206163636f756e7420000000000000000000600082015250565b6000612098601783612057565b91506120a382612062565b601782019050919050565b600081519050919050565b60005b838110156120d75780820151818401526020810190506120bc565b60008484015250505050565b60006120ee826120ae565b6120f88185612057565b93506121088185602086016120b9565b80840191505092915050565b7f206973206d697373696e6720726f6c6520000000000000000000000000000000600082015250565b600061214a601183612057565b915061215582612114565b601182019050919050565b600061216b8261208b565b915061217782856120e3565b91506121828261213d565b915061218e82846120e3565b91508190509392505050565b6000601f19601f8301169050919050565b60006121b6826120ae565b6121c08185611b1a565b93506121d08185602086016120b9565b6121d98161219a565b840191505092915050565b600060208201905081810360008301526121fe81846121ab565b905092915050565b61220f81611819565b811461221a57600080fd5b50565b60008151905061222c81612206565b92915050565b6000602082840312156122485761224761178f565b5b60006122568482850161221d565b91505092915050565b7f5361666545524332303a204552433230206f7065726174696f6e20646964206e60008201527f6f74207375636365656400000000000000000000000000000000000000000000602082015250565b60006122bb602a83611b1a565b91506122c68261225f565b604082019050919050565b600060208201905081810360008301526122ea816122ae565b9050919050565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b600061232b8261174d565b91506000820361233e5761233d611c4f565b5b600182039050919050565b7f537472696e67733a20686578206c656e67746820696e73756666696369656e74600082015250565b600061237f602083611b1a565b915061238a82612349565b602082019050919050565b600060208201905081810360008301526123ae81612372565b9050919050565b7f416464726573733a20696e73756666696369656e742062616c616e636520666f60008201527f722063616c6c0000000000000000000000000000000000000000000000000000602082015250565b6000612411602683611b1a565b915061241c826123b5565b604082019050919050565b6000602082019050818103600083015261244081612404565b9050919050565b600081519050919050565b600061245d82612447565b6124678185611ea9565b93506124778185602086016120b9565b80840191505092915050565b600061248f8284612452565b915081905092915050565b7f416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000600082015250565b60006124d0601d83611b1a565b91506124db8261249a565b602082019050919050565b600060208201905081810360008301526124ff816124c3565b905091905056fea264697066735822122091a783784d4b434db296431a91bff791f260445375822b9d7545acc732478d8b64736f6c63430008110033

000000000000000000000000000000000000000000000000000000000000006000000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000000200000000000000000000000008f950816358f4306b70fb319e4f35c592d1b8a8000000000000000000000000a57ec3a618b6969a6b1fec2ef4bf54b2afc5ca300000000000000000000000000000000000000000000000000000000000000002000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000000010000000000000000000000000000000000000000000000000000000000000002000000000000000000000000d523545b49076807094c0718f5eba00c0ae72fd6000000000000000000000000befaff31e713bb898ea26e30df8aa1f4b0b818b9

-----Decoded View---------------
Arg [0] : _accounts (address[]): 0x08f950816358F4306B70fB319E4F35c592d1B8a8,0xA57ec3a618b6969a6B1fEc2eF4BF54B2AfC5ca30
Arg [1] : _allocation (uint256[]): 1,1
Arg [2] : _admins (address[]): 0xd523545B49076807094C0718F5eBa00C0aE72fD6,0xBEfaFF31e713Bb898ea26e30dF8aA1f4B0b818b9

-----Encoded View---------------
12 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000060
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [4] : 00000000000000000000000008f950816358f4306b70fb319e4f35c592d1b8a8
Arg [5] : 000000000000000000000000a57ec3a618b6969a6b1fec2ef4bf54b2afc5ca30
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000001
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [10] : 000000000000000000000000d523545b49076807094c0718f5eba00c0ae72fd6
Arg [11] : 000000000000000000000000befaff31e713bb898ea26e30df8aa1f4b0b818b9

57285:614:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57850:40;57866:12;:10;:12::i;:::-;57880:9;57850:40;;;;;;;:::i;:::-;;;;;;;;57285:614;;;;;23656:204;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;54387:671;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;25479:131;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;25920:147;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;27064:218;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;51997:91;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53126:135;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;55326:792;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;57669:110;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;53352:100;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;23952:147;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52848:109;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;23057:49;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53542:225;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;53927:260;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52644:105;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;26360:149;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;52434:119;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;52182:95;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;20865:98;20918:7;20945:10;20938:17;;20865:98;:::o;23656:204::-;23741:4;23780:32;23765:47;;;:11;:47;;;;:87;;;;23816:36;23840:11;23816:23;:36::i;:::-;23765:87;23758:94;;23656:204;;;:::o;54387:671::-;54482:1;54463:7;:16;54471:7;54463:16;;;;;;;;;;;;;;;;:20;54455:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;54539:15;54557:19;54568:7;54557:10;:19::i;:::-;54539:37;;54608:1;54597:7;:12;54589:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;54870:7;54852:14;;:25;;;;;;;:::i;:::-;;;;;;;;54935:7;54913:9;:18;54923:7;54913:18;;;;;;;;;;;;;;;;:29;;;;;;;;;;;54966:35;54984:7;54993;54966:17;:35::i;:::-;55017:33;55033:7;55042;55017:33;;;;;;;:::i;:::-;;;;;;;;54444:614;54387:671;:::o;25479:131::-;25553:7;25580:6;:12;25587:4;25580:12;;;;;;;;;;;:22;;;25573:29;;25479:131;;;:::o;25920:147::-;26003:18;26016:4;26003:12;:18::i;:::-;23548:16;23559:4;23548:10;:16::i;:::-;26034:25:::1;26045:4;26051:7;26034:10;:25::i;:::-;25920:147:::0;;;:::o;27064:218::-;27171:12;:10;:12::i;:::-;27160:23;;:7;:23;;;27152:83;;;;;;;;;;;;:::i;:::-;;;;;;;;;27248:26;27260:4;27266:7;27248:11;:26::i;:::-;27064:218;;:::o;51997:91::-;52041:7;52068:12;;52061:19;;51997:91;:::o;53126:135::-;53196:7;53223:14;:21;53238:5;53223:21;;;;;;;;;;;;;;;:30;53245:7;53223:30;;;;;;;;;;;;;;;;53216:37;;53126:135;;;;:::o;55326:792::-;55427:1;55408:7;:16;55416:7;55408:16;;;;;;;;;;;;;;;;:20;55400:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;55484:15;55502:26;55513:5;55520:7;55502:10;:26::i;:::-;55484:44;;55560:1;55549:7;:12;55541:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;55894:7;55864:19;:26;55884:5;55864:26;;;;;;;;;;;;;;;;:37;;;;;;;:::i;:::-;;;;;;;;55971:7;55937:14;:21;55952:5;55937:21;;;;;;;;;;;;;;;:30;55959:7;55937:30;;;;;;;;;;;;;;;;:41;;;;;;;;;;;56002:47;56025:5;56032:7;56041;56002:22;:47::i;:::-;56086:5;56065:45;;;56093:7;56102;56065:45;;;;;;;:::i;:::-;;;;;;;;55389:729;55326:792;;:::o;57669:110::-;23102:4;57731:18;;23548:16;23559:4;23548:10;:16::i;:::-;57758:15:::1;57766:6;57758:7;:15::i;:::-;57669:110:::0;;:::o;53352:100::-;53403:7;53430;53438:5;53430:14;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;53423:21;;53352:100;;;:::o;23952:147::-;24038:4;24062:6;:12;24069:4;24062:12;;;;;;;;;;;:20;;:29;24083:7;24062:29;;;;;;;;;;;;;;;;;;;;;;;;;24055:36;;23952:147;;;;:::o;52848:109::-;52904:7;52931:9;:18;52941:7;52931:18;;;;;;;;;;;;;;;;52924:25;;52848:109;;;:::o;23057:49::-;23102:4;23057:49;;;:::o;53542:225::-;53600:7;53620:21;53668:15;:13;:15::i;:::-;53644:21;:39;;;;:::i;:::-;53620:63;;53701:58;53717:7;53726:13;53741:17;53750:7;53741:8;:17::i;:::-;53701:15;:58::i;:::-;53694:65;;;53542:225;;;:::o;53927:260::-;53999:7;54019:21;54076:20;54090:5;54076:13;:20::i;:::-;54043:5;:15;;;54067:4;54043:30;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:53;;;;:::i;:::-;54019:77;;54114:65;54130:7;54139:13;54154:24;54163:5;54170:7;54154:8;:24::i;:::-;54114:15;:65::i;:::-;54107:72;;;53927:260;;;;:::o;52644:105::-;52698:7;52725;:16;52733:7;52725:16;;;;;;;;;;;;;;;;52718:23;;52644:105;;;:::o;26360:149::-;26444:18;26457:4;26444:12;:18::i;:::-;23548:16;23559:4;23548:10;:16::i;:::-;26475:26:::1;26487:4;26493:7;26475:11;:26::i;:::-;26360:149:::0;;;:::o;52434:119::-;52492:7;52519:19;:26;52539:5;52519:26;;;;;;;;;;;;;;;;52512:33;;52434:119;;;:::o;52182:95::-;52228:7;52255:14;;52248:21;;52182:95;:::o;1782:157::-;1867:4;1906:25;1891:40;;;:11;:40;;;;1884:47;;1782:157;;;:::o;31819:317::-;31934:6;31909:21;:31;;31901:73;;;;;;;;;;;;:::i;:::-;;;;;;;;;31988:12;32006:9;:14;;32028:6;32006:33;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;31987:52;;;32058:7;32050:78;;;;;;;;;;;;:::i;:::-;;;;;;;;;31890:246;31819:317;;:::o;24403:105::-;24470:30;24481:4;24487:12;:10;:12::i;:::-;24470:10;:30::i;:::-;24403:105;:::o;28661:238::-;28745:22;28753:4;28759:7;28745;:22::i;:::-;28740:152;;28816:4;28784:6;:12;28791:4;28784:12;;;;;;;;;;;:20;;:29;28805:7;28784:29;;;;;;;;;;;;;;;;:36;;;;;;;;;;;;;;;;;;28867:12;:10;:12::i;:::-;28840:40;;28858:7;28840:40;;28852:4;28840:40;;;;;;;;;;28740:152;28661:238;;:::o;29079:239::-;29163:22;29171:4;29177:7;29163;:22::i;:::-;29159:152;;;29234:5;29202:6;:12;29209:4;29202:12;;;;;;;;;;;:20;;:29;29223:7;29202:29;;;;;;;;;;;;;;;;:37;;;;;;;;;;;;;;;;;;29286:12;:10;:12::i;:::-;29259:40;;29277:7;29259:40;;29271:4;29259:40;;;;;;;;;;29159:152;29079:239;;:::o;44711:211::-;44828:86;44848:5;44878:23;;;44903:2;44907:5;44855:58;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;44828:19;:86::i;:::-;44711:211;;;:::o;56296:248::-;56442:7;56521:15;56506:12;;56486:7;:16;56494:7;56486:16;;;;;;;;;;;;;;;;56470:13;:32;;;;:::i;:::-;56469:49;;;;:::i;:::-;:67;;;;:::i;:::-;56462:74;;56296:248;;;;;:::o;24798:492::-;24887:22;24895:4;24901:7;24887;:22::i;:::-;24882:401;;25075:28;25095:7;25075:19;:28::i;:::-;25176:38;25204:4;25196:13;;25211:2;25176:19;:38::i;:::-;24980:257;;;;;;;;;:::i;:::-;;;;;;;;;;;;;24926:345;;;;;;;;;;;:::i;:::-;;;;;;;;24882:401;24798:492;;:::o;47778:716::-;48202:23;48228:69;48256:4;48228:69;;;;;;;;;;;;;;;;;48236:5;48228:27;;;;:69;;;;;:::i;:::-;48202:95;;48332:1;48312:10;:17;:21;48308:179;;;48409:10;48398:30;;;;;;;;;;;;:::i;:::-;48390:85;;;;;;;;;;;;:::i;:::-;;;;;;;;;48308:179;47848:646;47778:716;;:::o;16987:151::-;17045:13;17078:52;17106:4;17090:22;;15142:2;17078:52;;:11;:52::i;:::-;17071:59;;16987:151;;;:::o;16383:447::-;16458:13;16484:19;16529:1;16520:6;16516:1;:10;;;;:::i;:::-;:14;;;;:::i;:::-;16506:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;16484:47;;16542:15;:6;16549:1;16542:9;;;;;;;;:::i;:::-;;;;;:15;;;;;;;;;;;16568;:6;16575:1;16568:9;;;;;;;;:::i;:::-;;;;;:15;;;;;;;;;;;16599:9;16624:1;16615:6;16611:1;:10;;;;:::i;:::-;:14;;;;:::i;:::-;16599:26;;16594:131;16631:1;16627;:5;16594:131;;;16666:8;16683:3;16675:5;:11;16666:21;;;;;;;:::i;:::-;;;;;16654:6;16661:1;16654:9;;;;;;;;:::i;:::-;;;;;:33;;;;;;;;;;;16712:1;16702:11;;;;;16634:3;;;;:::i;:::-;;;16594:131;;;;16752:1;16743:5;:10;16735:55;;;;;;;;;;;;:::i;:::-;;;;;;;;;16815:6;16801:21;;;16383:447;;;;:::o;33315:229::-;33452:12;33484:52;33506:6;33514:4;33520:1;33523:12;33484:21;:52::i;:::-;33477:59;;33315:229;;;;;:::o;34435:455::-;34605:12;34663:5;34638:21;:30;;34630:81;;;;;;;;;;;;:::i;:::-;;;;;;;;;34723:12;34737:23;34764:6;:11;;34783:5;34790:4;34764:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;34722:73;;;;34813:69;34840:6;34848:7;34857:10;34869:12;34813:26;:69::i;:::-;34806:76;;;;34435:455;;;;;;:::o;37008:644::-;37193:12;37222:7;37218:427;;;37271:1;37250:10;:17;:22;37246:290;;37468:18;37479:6;37468:10;:18::i;:::-;37460:60;;;;;;;;;;;;:::i;:::-;;;;;;;;;37246:290;37557:10;37550:17;;;;37218:427;37600:33;37608:10;37620:12;37600:7;:33::i;:::-;37008:644;;;;;;;:::o;30558:326::-;30618:4;30875:1;30853:7;:19;;;:23;30846:30;;30558:326;;;:::o;38194:552::-;38375:1;38355:10;:17;:21;38351:388;;;38587:10;38581:17;38644:15;38631:10;38627:2;38623:19;38616:44;38351:388;38714:12;38707:20;;;;;;;;;;;:::i;:::-;;;;;;;;7:126:1;44:7;84:42;77:5;73:54;62:65;;7:126;;;:::o;139:96::-;176:7;205:24;223:5;205:24;:::i;:::-;194:35;;139:96;;;:::o;241:118::-;328:24;346:5;328:24;:::i;:::-;323:3;316:37;241:118;;:::o;365:77::-;402:7;431:5;420:16;;365:77;;;:::o;448:118::-;535:24;553:5;535:24;:::i;:::-;530:3;523:37;448:118;;:::o;572:332::-;693:4;731:2;720:9;716:18;708:26;;744:71;812:1;801:9;797:17;788:6;744:71;:::i;:::-;825:72;893:2;882:9;878:18;869:6;825:72;:::i;:::-;572:332;;;;;:::o;991:117::-;1100:1;1097;1090:12;1237:149;1273:7;1313:66;1306:5;1302:78;1291:89;;1237:149;;;:::o;1392:120::-;1464:23;1481:5;1464:23;:::i;:::-;1457:5;1454:34;1444:62;;1502:1;1499;1492:12;1444:62;1392:120;:::o;1518:137::-;1563:5;1601:6;1588:20;1579:29;;1617:32;1643:5;1617:32;:::i;:::-;1518:137;;;;:::o;1661:327::-;1719:6;1768:2;1756:9;1747:7;1743:23;1739:32;1736:119;;;1774:79;;:::i;:::-;1736:119;1894:1;1919:52;1963:7;1954:6;1943:9;1939:22;1919:52;:::i;:::-;1909:62;;1865:116;1661:327;;;;:::o;1994:90::-;2028:7;2071:5;2064:13;2057:21;2046:32;;1994:90;;;:::o;2090:109::-;2171:21;2186:5;2171:21;:::i;:::-;2166:3;2159:34;2090:109;;:::o;2205:210::-;2292:4;2330:2;2319:9;2315:18;2307:26;;2343:65;2405:1;2394:9;2390:17;2381:6;2343:65;:::i;:::-;2205:210;;;;:::o;2421:104::-;2466:7;2495:24;2513:5;2495:24;:::i;:::-;2484:35;;2421:104;;;:::o;2531:138::-;2612:32;2638:5;2612:32;:::i;:::-;2605:5;2602:43;2592:71;;2659:1;2656;2649:12;2592:71;2531:138;:::o;2675:155::-;2729:5;2767:6;2754:20;2745:29;;2783:41;2818:5;2783:41;:::i;:::-;2675:155;;;;:::o;2836:345::-;2903:6;2952:2;2940:9;2931:7;2927:23;2923:32;2920:119;;;2958:79;;:::i;:::-;2920:119;3078:1;3103:61;3156:7;3147:6;3136:9;3132:22;3103:61;:::i;:::-;3093:71;;3049:125;2836:345;;;;:::o;3187:77::-;3224:7;3253:5;3242:16;;3187:77;;;:::o;3270:122::-;3343:24;3361:5;3343:24;:::i;:::-;3336:5;3333:35;3323:63;;3382:1;3379;3372:12;3323:63;3270:122;:::o;3398:139::-;3444:5;3482:6;3469:20;3460:29;;3498:33;3525:5;3498:33;:::i;:::-;3398:139;;;;:::o;3543:329::-;3602:6;3651:2;3639:9;3630:7;3626:23;3622:32;3619:119;;;3657:79;;:::i;:::-;3619:119;3777:1;3802:53;3847:7;3838:6;3827:9;3823:22;3802:53;:::i;:::-;3792:63;;3748:117;3543:329;;;;:::o;3878:118::-;3965:24;3983:5;3965:24;:::i;:::-;3960:3;3953:37;3878:118;;:::o;4002:222::-;4095:4;4133:2;4122:9;4118:18;4110:26;;4146:71;4214:1;4203:9;4199:17;4190:6;4146:71;:::i;:::-;4002:222;;;;:::o;4230:122::-;4303:24;4321:5;4303:24;:::i;:::-;4296:5;4293:35;4283:63;;4342:1;4339;4332:12;4283:63;4230:122;:::o;4358:139::-;4404:5;4442:6;4429:20;4420:29;;4458:33;4485:5;4458:33;:::i;:::-;4358:139;;;;:::o;4503:474::-;4571:6;4579;4628:2;4616:9;4607:7;4603:23;4599:32;4596:119;;;4634:79;;:::i;:::-;4596:119;4754:1;4779:53;4824:7;4815:6;4804:9;4800:22;4779:53;:::i;:::-;4769:63;;4725:117;4881:2;4907:53;4952:7;4943:6;4932:9;4928:22;4907:53;:::i;:::-;4897:63;;4852:118;4503:474;;;;;:::o;4983:222::-;5076:4;5114:2;5103:9;5099:18;5091:26;;5127:71;5195:1;5184:9;5180:17;5171:6;5127:71;:::i;:::-;4983:222;;;;:::o;5211:111::-;5263:7;5292:24;5310:5;5292:24;:::i;:::-;5281:35;;5211:111;;;:::o;5328:152::-;5416:39;5449:5;5416:39;:::i;:::-;5409:5;5406:50;5396:78;;5470:1;5467;5460:12;5396:78;5328:152;:::o;5486:169::-;5547:5;5585:6;5572:20;5563:29;;5601:48;5643:5;5601:48;:::i;:::-;5486:169;;;;:::o;5661:504::-;5744:6;5752;5801:2;5789:9;5780:7;5776:23;5772:32;5769:119;;;5807:79;;:::i;:::-;5769:119;5927:1;5952:68;6012:7;6003:6;5992:9;5988:22;5952:68;:::i;:::-;5942:78;;5898:132;6069:2;6095:53;6140:7;6131:6;6120:9;6116:22;6095:53;:::i;:::-;6085:63;;6040:118;5661:504;;;;;:::o;6171:122::-;6244:24;6262:5;6244:24;:::i;:::-;6237:5;6234:35;6224:63;;6283:1;6280;6273:12;6224:63;6171:122;:::o;6299:139::-;6345:5;6383:6;6370:20;6361:29;;6399:33;6426:5;6399:33;:::i;:::-;6299:139;;;;:::o;6444:329::-;6503:6;6552:2;6540:9;6531:7;6527:23;6523:32;6520:119;;;6558:79;;:::i;:::-;6520:119;6678:1;6703:53;6748:7;6739:6;6728:9;6724:22;6703:53;:::i;:::-;6693:63;;6649:117;6444:329;;;;:::o;6779:222::-;6872:4;6910:2;6899:9;6895:18;6887:26;;6923:71;6991:1;6980:9;6976:17;6967:6;6923:71;:::i;:::-;6779:222;;;;:::o;7007:329::-;7066:6;7115:2;7103:9;7094:7;7090:23;7086:32;7083:119;;;7121:79;;:::i;:::-;7083:119;7241:1;7266:53;7311:7;7302:6;7291:9;7287:22;7266:53;:::i;:::-;7256:63;;7212:117;7007:329;;;;:::o;7342:359::-;7416:6;7465:2;7453:9;7444:7;7440:23;7436:32;7433:119;;;7471:79;;:::i;:::-;7433:119;7591:1;7616:68;7676:7;7667:6;7656:9;7652:22;7616:68;:::i;:::-;7606:78;;7562:132;7342:359;;;;:::o;7707:169::-;7791:11;7825:6;7820:3;7813:19;7865:4;7860:3;7856:14;7841:29;;7707:169;;;;:::o;7882:225::-;8022:34;8018:1;8010:6;8006:14;7999:58;8091:8;8086:2;8078:6;8074:15;8067:33;7882:225;:::o;8113:366::-;8255:3;8276:67;8340:2;8335:3;8276:67;:::i;:::-;8269:74;;8352:93;8441:3;8352:93;:::i;:::-;8470:2;8465:3;8461:12;8454:19;;8113:366;;;:::o;8485:419::-;8651:4;8689:2;8678:9;8674:18;8666:26;;8738:9;8732:4;8728:20;8724:1;8713:9;8709:17;8702:47;8766:131;8892:4;8766:131;:::i;:::-;8758:139;;8485:419;;;:::o;8910:230::-;9050:34;9046:1;9038:6;9034:14;9027:58;9119:13;9114:2;9106:6;9102:15;9095:38;8910:230;:::o;9146:366::-;9288:3;9309:67;9373:2;9368:3;9309:67;:::i;:::-;9302:74;;9385:93;9474:3;9385:93;:::i;:::-;9503:2;9498:3;9494:12;9487:19;;9146:366;;;:::o;9518:419::-;9684:4;9722:2;9711:9;9707:18;9699:26;;9771:9;9765:4;9761:20;9757:1;9746:9;9742:17;9735:47;9799:131;9925:4;9799:131;:::i;:::-;9791:139;;9518:419;;;:::o;9943:180::-;9991:77;9988:1;9981:88;10088:4;10085:1;10078:15;10112:4;10109:1;10102:15;10129:191;10169:3;10188:20;10206:1;10188:20;:::i;:::-;10183:25;;10222:20;10240:1;10222:20;:::i;:::-;10217:25;;10265:1;10262;10258:9;10251:16;;10286:3;10283:1;10280:10;10277:36;;;10293:18;;:::i;:::-;10277:36;10129:191;;;;:::o;10326:60::-;10354:3;10375:5;10368:12;;10326:60;;;:::o;10392:142::-;10442:9;10475:53;10493:34;10502:24;10520:5;10502:24;:::i;:::-;10493:34;:::i;:::-;10475:53;:::i;:::-;10462:66;;10392:142;;;:::o;10540:126::-;10590:9;10623:37;10654:5;10623:37;:::i;:::-;10610:50;;10540:126;;;:::o;10672:134::-;10730:9;10763:37;10794:5;10763:37;:::i;:::-;10750:50;;10672:134;;;:::o;10812:147::-;10907:45;10946:5;10907:45;:::i;:::-;10902:3;10895:58;10812:147;;:::o;10965:348::-;11094:4;11132:2;11121:9;11117:18;11109:26;;11145:79;11221:1;11210:9;11206:17;11197:6;11145:79;:::i;:::-;11234:72;11302:2;11291:9;11287:18;11278:6;11234:72;:::i;:::-;10965:348;;;;;:::o;11319:234::-;11459:34;11455:1;11447:6;11443:14;11436:58;11528:17;11523:2;11515:6;11511:15;11504:42;11319:234;:::o;11559:366::-;11701:3;11722:67;11786:2;11781:3;11722:67;:::i;:::-;11715:74;;11798:93;11887:3;11798:93;:::i;:::-;11916:2;11911:3;11907:12;11900:19;;11559:366;;;:::o;11931:419::-;12097:4;12135:2;12124:9;12120:18;12112:26;;12184:9;12178:4;12174:20;12170:1;12159:9;12155:17;12148:47;12212:131;12338:4;12212:131;:::i;:::-;12204:139;;11931:419;;;:::o;12356:180::-;12404:77;12401:1;12394:88;12501:4;12498:1;12491:15;12525:4;12522:1;12515:15;12542:143;12599:5;12630:6;12624:13;12615:22;;12646:33;12673:5;12646:33;:::i;:::-;12542:143;;;;:::o;12691:351::-;12761:6;12810:2;12798:9;12789:7;12785:23;12781:32;12778:119;;;12816:79;;:::i;:::-;12778:119;12936:1;12961:64;13017:7;13008:6;12997:9;12993:22;12961:64;:::i;:::-;12951:74;;12907:128;12691:351;;;;:::o;13048:179::-;13188:31;13184:1;13176:6;13172:14;13165:55;13048:179;:::o;13233:366::-;13375:3;13396:67;13460:2;13455:3;13396:67;:::i;:::-;13389:74;;13472:93;13561:3;13472:93;:::i;:::-;13590:2;13585:3;13581:12;13574:19;;13233:366;;;:::o;13605:419::-;13771:4;13809:2;13798:9;13794:18;13786:26;;13858:9;13852:4;13848:20;13844:1;13833:9;13829:17;13822:47;13886:131;14012:4;13886:131;:::i;:::-;13878:139;;13605:419;;;:::o;14030:147::-;14131:11;14168:3;14153:18;;14030:147;;;;:::o;14183:114::-;;:::o;14303:398::-;14462:3;14483:83;14564:1;14559:3;14483:83;:::i;:::-;14476:90;;14575:93;14664:3;14575:93;:::i;:::-;14693:1;14688:3;14684:11;14677:18;;14303:398;;;:::o;14707:379::-;14891:3;14913:147;15056:3;14913:147;:::i;:::-;14906:154;;15077:3;15070:10;;14707:379;;;:::o;15092:245::-;15232:34;15228:1;15220:6;15216:14;15209:58;15301:28;15296:2;15288:6;15284:15;15277:53;15092:245;:::o;15343:366::-;15485:3;15506:67;15570:2;15565:3;15506:67;:::i;:::-;15499:74;;15582:93;15671:3;15582:93;:::i;:::-;15700:2;15695:3;15691:12;15684:19;;15343:366;;;:::o;15715:419::-;15881:4;15919:2;15908:9;15904:18;15896:26;;15968:9;15962:4;15958:20;15954:1;15943:9;15939:17;15932:47;15996:131;16122:4;15996:131;:::i;:::-;15988:139;;15715:419;;;:::o;16140:410::-;16180:7;16203:20;16221:1;16203:20;:::i;:::-;16198:25;;16237:20;16255:1;16237:20;:::i;:::-;16232:25;;16292:1;16289;16285:9;16314:30;16332:11;16314:30;:::i;:::-;16303:41;;16493:1;16484:7;16480:15;16477:1;16474:22;16454:1;16447:9;16427:83;16404:139;;16523:18;;:::i;:::-;16404:139;16188:362;16140:410;;;;:::o;16556:180::-;16604:77;16601:1;16594:88;16701:4;16698:1;16691:15;16725:4;16722:1;16715:15;16742:185;16782:1;16799:20;16817:1;16799:20;:::i;:::-;16794:25;;16833:20;16851:1;16833:20;:::i;:::-;16828:25;;16872:1;16862:35;;16877:18;;:::i;:::-;16862:35;16919:1;16916;16912:9;16907:14;;16742:185;;;;:::o;16933:194::-;16973:4;16993:20;17011:1;16993:20;:::i;:::-;16988:25;;17027:20;17045:1;17027:20;:::i;:::-;17022:25;;17071:1;17068;17064:9;17056:17;;17095:1;17089:4;17086:11;17083:37;;;17100:18;;:::i;:::-;17083:37;16933:194;;;;:::o;17133:148::-;17235:11;17272:3;17257:18;;17133:148;;;;:::o;17287:173::-;17427:25;17423:1;17415:6;17411:14;17404:49;17287:173;:::o;17466:402::-;17626:3;17647:85;17729:2;17724:3;17647:85;:::i;:::-;17640:92;;17741:93;17830:3;17741:93;:::i;:::-;17859:2;17854:3;17850:12;17843:19;;17466:402;;;:::o;17874:99::-;17926:6;17960:5;17954:12;17944:22;;17874:99;;;:::o;17979:246::-;18060:1;18070:113;18084:6;18081:1;18078:13;18070:113;;;18169:1;18164:3;18160:11;18154:18;18150:1;18145:3;18141:11;18134:39;18106:2;18103:1;18099:10;18094:15;;18070:113;;;18217:1;18208:6;18203:3;18199:16;18192:27;18041:184;17979:246;;;:::o;18231:390::-;18337:3;18365:39;18398:5;18365:39;:::i;:::-;18420:89;18502:6;18497:3;18420:89;:::i;:::-;18413:96;;18518:65;18576:6;18571:3;18564:4;18557:5;18553:16;18518:65;:::i;:::-;18608:6;18603:3;18599:16;18592:23;;18341:280;18231:390;;;;:::o;18627:167::-;18767:19;18763:1;18755:6;18751:14;18744:43;18627:167;:::o;18800:402::-;18960:3;18981:85;19063:2;19058:3;18981:85;:::i;:::-;18974:92;;19075:93;19164:3;19075:93;:::i;:::-;19193:2;19188:3;19184:12;19177:19;;18800:402;;;:::o;19208:967::-;19590:3;19612:148;19756:3;19612:148;:::i;:::-;19605:155;;19777:95;19868:3;19859:6;19777:95;:::i;:::-;19770:102;;19889:148;20033:3;19889:148;:::i;:::-;19882:155;;20054:95;20145:3;20136:6;20054:95;:::i;:::-;20047:102;;20166:3;20159:10;;19208:967;;;;;:::o;20181:102::-;20222:6;20273:2;20269:7;20264:2;20257:5;20253:14;20249:28;20239:38;;20181:102;;;:::o;20289:377::-;20377:3;20405:39;20438:5;20405:39;:::i;:::-;20460:71;20524:6;20519:3;20460:71;:::i;:::-;20453:78;;20540:65;20598:6;20593:3;20586:4;20579:5;20575:16;20540:65;:::i;:::-;20630:29;20652:6;20630:29;:::i;:::-;20625:3;20621:39;20614:46;;20381:285;20289:377;;;;:::o;20672:313::-;20785:4;20823:2;20812:9;20808:18;20800:26;;20872:9;20866:4;20862:20;20858:1;20847:9;20843:17;20836:47;20900:78;20973:4;20964:6;20900:78;:::i;:::-;20892:86;;20672:313;;;;:::o;20991:116::-;21061:21;21076:5;21061:21;:::i;:::-;21054:5;21051:32;21041:60;;21097:1;21094;21087:12;21041:60;20991:116;:::o;21113:137::-;21167:5;21198:6;21192:13;21183:22;;21214:30;21238:5;21214:30;:::i;:::-;21113:137;;;;:::o;21256:345::-;21323:6;21372:2;21360:9;21351:7;21347:23;21343:32;21340:119;;;21378:79;;:::i;:::-;21340:119;21498:1;21523:61;21576:7;21567:6;21556:9;21552:22;21523:61;:::i;:::-;21513:71;;21469:125;21256:345;;;;:::o;21607:229::-;21747:34;21743:1;21735:6;21731:14;21724:58;21816:12;21811:2;21803:6;21799:15;21792:37;21607:229;:::o;21842:366::-;21984:3;22005:67;22069:2;22064:3;22005:67;:::i;:::-;21998:74;;22081:93;22170:3;22081:93;:::i;:::-;22199:2;22194:3;22190:12;22183:19;;21842:366;;;:::o;22214:419::-;22380:4;22418:2;22407:9;22403:18;22395:26;;22467:9;22461:4;22457:20;22453:1;22442:9;22438:17;22431:47;22495:131;22621:4;22495:131;:::i;:::-;22487:139;;22214:419;;;:::o;22639:180::-;22687:77;22684:1;22677:88;22784:4;22781:1;22774:15;22808:4;22805:1;22798:15;22825:171;22864:3;22887:24;22905:5;22887:24;:::i;:::-;22878:33;;22933:4;22926:5;22923:15;22920:41;;22941:18;;:::i;:::-;22920:41;22988:1;22981:5;22977:13;22970:20;;22825:171;;;:::o;23002:182::-;23142:34;23138:1;23130:6;23126:14;23119:58;23002:182;:::o;23190:366::-;23332:3;23353:67;23417:2;23412:3;23353:67;:::i;:::-;23346:74;;23429:93;23518:3;23429:93;:::i;:::-;23547:2;23542:3;23538:12;23531:19;;23190:366;;;:::o;23562:419::-;23728:4;23766:2;23755:9;23751:18;23743:26;;23815:9;23809:4;23805:20;23801:1;23790:9;23786:17;23779:47;23843:131;23969:4;23843:131;:::i;:::-;23835:139;;23562:419;;;:::o;23987:225::-;24127:34;24123:1;24115:6;24111:14;24104:58;24196:8;24191:2;24183:6;24179:15;24172:33;23987:225;:::o;24218:366::-;24360:3;24381:67;24445:2;24440:3;24381:67;:::i;:::-;24374:74;;24457:93;24546:3;24457:93;:::i;:::-;24575:2;24570:3;24566:12;24559:19;;24218:366;;;:::o;24590:419::-;24756:4;24794:2;24783:9;24779:18;24771:26;;24843:9;24837:4;24833:20;24829:1;24818:9;24814:17;24807:47;24871:131;24997:4;24871:131;:::i;:::-;24863:139;;24590:419;;;:::o;25015:98::-;25066:6;25100:5;25094:12;25084:22;;25015:98;;;:::o;25119:386::-;25223:3;25251:38;25283:5;25251:38;:::i;:::-;25305:88;25386:6;25381:3;25305:88;:::i;:::-;25298:95;;25402:65;25460:6;25455:3;25448:4;25441:5;25437:16;25402:65;:::i;:::-;25492:6;25487:3;25483:16;25476:23;;25227:278;25119:386;;;;:::o;25511:271::-;25641:3;25663:93;25752:3;25743:6;25663:93;:::i;:::-;25656:100;;25773:3;25766:10;;25511:271;;;;:::o;25788:179::-;25928:31;25924:1;25916:6;25912:14;25905:55;25788:179;:::o;25973:366::-;26115:3;26136:67;26200:2;26195:3;26136:67;:::i;:::-;26129:74;;26212:93;26301:3;26212:93;:::i;:::-;26330:2;26325:3;26321:12;26314:19;;25973:366;;;:::o;26345:419::-;26511:4;26549:2;26538:9;26534:18;26526:26;;26598:9;26592:4;26588:20;26584:1;26573:9;26569:17;26562:47;26626:131;26752:4;26626:131;:::i;:::-;26618:139;;26345:419;;;:::o

ipfs://91a783784d4b434db296431a91bff791f260445375822b9d7545acc732478d8b