Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

/**
 *Submitted for verification at Etherscan.io on 2022-04-08
*/

// Sources flattened with hardhat v2.8.4 https://hardhat.org

// File @openzeppelin/contracts/utils/[email protected]

// SPDX-License-Identifier: MIT
// 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/[email protected]


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



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

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

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

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

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

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

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

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


// File @openzeppelin/contracts/access/[email protected]


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



/**
 * @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/access/[email protected]


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



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

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


// File @openzeppelin/contracts/utils/[email protected]


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



/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @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] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}


// File @openzeppelin/contracts/utils/introspection/[email protected]


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



/**
 * @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/[email protected]


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



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


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






/**
 * @dev Contract module that allows children to implement role-based access
 * control mechanisms. This is a lightweight version that doesn't allow enumerating role
 * members except through off-chain means by accessing the contract event logs. Some
 * applications may benefit from on-chain enumerability, for those cases see
 * {AccessControlEnumerable}.
 *
 * Roles are referred to by their `bytes32` identifier. These should be exposed
 * in the external API and be unique. The best way to achieve this is by
 * using `public constant` hash digests:
 *
 * ```
 * 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, _msgSender());
        _;
    }

    /**
     * @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 `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(uint160(account), 20),
                        " 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.
     */
    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.
     */
    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`.
     */
    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.
     *
     * [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.
     */
    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.
     */
    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/structs/[email protected]


// OpenZeppelin Contracts v4.4.1 (utils/structs/EnumerableSet.sol)



/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

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

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

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

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

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

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

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

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

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

            return true;
        } else {
            return false;
        }
    }

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

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

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

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

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

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

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

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

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

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

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

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

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

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

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

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

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

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

        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

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

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

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

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

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

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

        assembly {
            result := store
        }

        return result;
    }
}


// File @openzeppelin/contracts/access/[email protected]


// OpenZeppelin Contracts (last updated v4.5.0) (access/AccessControlEnumerable.sol)





/**
 * @dev Extension of {AccessControl} that allows enumerating the members of each role.
 */
abstract contract AccessControlEnumerable is IAccessControlEnumerable, AccessControl {
    using EnumerableSet for EnumerableSet.AddressSet;

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

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

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

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

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

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


// File @openzeppelin/contracts/token/ERC20/[email protected]


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



/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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);

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


// File @openzeppelin/contracts/token/ERC721/[email protected]


// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol)



/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;
}


// File @openzeppelin/contracts/token/ERC721/[email protected]


// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721Receiver.sol)



/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}


// File @openzeppelin/contracts/token/ERC721/extensions/[email protected]


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)



/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}


// File @openzeppelin/contracts/utils/[email protected]


// OpenZeppelin Contracts (last updated v4.5.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 functionCall(target, data, "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");
        require(isContract(target), "Address: call to non-contract");

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(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) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(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) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason 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 {
            // 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

                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}


// File @openzeppelin/contracts/token/ERC721/[email protected]


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/ERC721.sol)









/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC721: owner query for nonexistent token");
        return owner;
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not owner nor approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(from, to, tokenId, _data);
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _owners[tokenId] != address(0);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, _data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);

        _afterTokenTransfer(address(0), to, tokenId);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[owner] -= 1;
        delete _owners[tokenId];

        emit Transfer(owner, address(0), tokenId);

        _afterTokenTransfer(owner, address(0), tokenId);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer from incorrect owner");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits a {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

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

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


// File @openzeppelin/contracts/token/ERC721/extensions/[email protected]


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)



/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}


// File @openzeppelin/contracts/token/ERC721/extensions/[email protected]


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/ERC721Enumerable.sol)




/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

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

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

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

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
        return _allTokens[index];
    }

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

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }
}


// File @openzeppelin/contracts/token/ERC721/extensions/[email protected]


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/ERC721Burnable.sol)




/**
 * @title ERC721 Burnable Token
 * @dev ERC721 Token that can be irreversibly burned (destroyed).
 */
abstract contract ERC721Burnable is Context, ERC721 {
    /**
     * @dev Burns `tokenId`. See {ERC721-_burn}.
     *
     * Requirements:
     *
     * - The caller must own `tokenId` or be an approved operator.
     */
    function burn(uint256 tokenId) public virtual {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721Burnable: caller is not owner nor approved");
        _burn(tokenId);
    }
}


// File @openzeppelin/contracts/security/[email protected]


// OpenZeppelin Contracts v4.4.1 (security/Pausable.sol)



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

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

    bool private _paused;

    /**
     * @dev Initializes the contract in unpaused state.
     */
    constructor() {
        _paused = false;
    }

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

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

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

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

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


// File @openzeppelin/contracts/token/ERC721/extensions/[email protected]


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/ERC721Pausable.sol)




/**
 * @dev ERC721 token with pausable token transfers, minting and burning.
 *
 * Useful for scenarios such as preventing trades until the end of an evaluation
 * period, or having an emergency switch for freezing all token transfers in the
 * event of a large bug.
 */
abstract contract ERC721Pausable is ERC721, Pausable {
    /**
     * @dev See {ERC721-_beforeTokenTransfer}.
     *
     * Requirements:
     *
     * - the contract must not be paused.
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, tokenId);

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


// File @openzeppelin/contracts/interfaces/[email protected]


// OpenZeppelin Contracts v4.4.1 (interfaces/IERC165.sol)




// File @openzeppelin/contracts/interfaces/[email protected]


// OpenZeppelin Contracts (last updated v4.5.0) (interfaces/IERC2981.sol)



/**
 * @dev Interface for the NFT Royalty Standard.
 *
 * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal
 * support for royalty payments across all NFT marketplaces and ecosystem participants.
 *
 * _Available since v4.5._
 */
interface IERC2981 is IERC165 {
    /**
     * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of
     * exchange. The royalty amount is denominated and should be payed in that same unit of exchange.
     */
    function royaltyInfo(uint256 tokenId, uint256 salePrice)
        external
        view
        returns (address receiver, uint256 royaltyAmount);
}


// File @openzeppelin/contracts/token/common/[email protected]


// OpenZeppelin Contracts (last updated v4.5.0) (token/common/ERC2981.sol)




/**
 * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information.
 *
 * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for
 * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first.
 *
 * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the
 * fee is specified in basis points by default.
 *
 * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See
 * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to
 * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported.
 *
 * _Available since v4.5._
 */
abstract contract ERC2981 is IERC2981, ERC165 {
    struct RoyaltyInfo {
        address receiver;
        uint96 royaltyFraction;
    }

    RoyaltyInfo private _defaultRoyaltyInfo;
    mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo;

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

    /**
     * @inheritdoc IERC2981
     */
    function royaltyInfo(uint256 _tokenId, uint256 _salePrice)
        external
        view
        virtual
        override
        returns (address, uint256)
    {
        RoyaltyInfo memory royalty = _tokenRoyaltyInfo[_tokenId];

        if (royalty.receiver == address(0)) {
            royalty = _defaultRoyaltyInfo;
        }

        uint256 royaltyAmount = (_salePrice * royalty.royaltyFraction) / _feeDenominator();

        return (royalty.receiver, royaltyAmount);
    }

    /**
     * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a
     * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an
     * override.
     */
    function _feeDenominator() internal pure virtual returns (uint96) {
        return 10000;
    }

    /**
     * @dev Sets the royalty information that all ids in this contract will default to.
     *
     * Requirements:
     *
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual {
        require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
        require(receiver != address(0), "ERC2981: invalid receiver");

        _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Removes default royalty information.
     */
    function _deleteDefaultRoyalty() internal virtual {
        delete _defaultRoyaltyInfo;
    }

    /**
     * @dev Sets the royalty information for a specific token id, overriding the global default.
     *
     * Requirements:
     *
     * - `tokenId` must be already minted.
     * - `receiver` cannot be the zero address.
     * - `feeNumerator` cannot be greater than the fee denominator.
     */
    function _setTokenRoyalty(
        uint256 tokenId,
        address receiver,
        uint96 feeNumerator
    ) internal virtual {
        require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice");
        require(receiver != address(0), "ERC2981: Invalid parameters");

        _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator);
    }

    /**
     * @dev Resets royalty information for the token id back to the global default.
     */
    function _resetTokenRoyalty(uint256 tokenId) internal virtual {
        delete _tokenRoyaltyInfo[tokenId];
    }
}


// File contracts/utils/Base64.sol




/// [MIT License]
/// @title Base64
/// @notice Provides a function for encoding some bytes in base64
/// @author Brecht Devos <[email protected]>
library Base64 {
    bytes internal constant TABLE =
        "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";

    /// @notice Encodes some bytes to the base64 representation
    function encode(bytes memory data) internal pure returns (string memory) {
        uint256 len = data.length;
        if (len == 0) return "";

        // multiply by 4/3 rounded up
        uint256 encodedLen = 4 * ((len + 2) / 3);

        // Add some extra buffer at the end
        bytes memory result = new bytes(encodedLen + 32);

        bytes memory table = TABLE;

        assembly {
            let tablePtr := add(table, 1)
            let resultPtr := add(result, 32)

            for {
                let i := 0
            } lt(i, len) {

            } {
                i := add(i, 3)
                let input := and(mload(add(data, i)), 0xffffff)

                let out := mload(add(tablePtr, and(shr(18, input), 0x3F)))
                out := shl(8, out)
                out := add(
                    out,
                    and(mload(add(tablePtr, and(shr(12, input), 0x3F))), 0xFF)
                )
                out := shl(8, out)
                out := add(
                    out,
                    and(mload(add(tablePtr, and(shr(6, input), 0x3F))), 0xFF)
                )
                out := shl(8, out)
                out := add(
                    out,
                    and(mload(add(tablePtr, and(input, 0x3F))), 0xFF)
                )
                out := shl(224, out)

                mstore(resultPtr, out)

                resultPtr := add(resultPtr, 4)
            }

            switch mod(len, 3)
            case 1 {
                mstore(sub(resultPtr, 2), shl(240, 0x3d3d))
            }
            case 2 {
                mstore(sub(resultPtr, 1), shl(248, 0x3d))
            }

            mstore(result, encodedLen)
        }

        return string(result);
    }
}


// File contracts/Bansho.sol



/*
 * Bansho.sol
 * @nuko973663
 */

pragma solidity ^0.8.4;
contract Bansho is ERC721Enumerable ,ERC721Burnable , ERC2981, ERC721Pausable, Ownable, AccessControlEnumerable {
    using Strings for uint256;

    mapping(uint256=>string) private _metadata;
    bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE");
    bytes32 public constant PAUSER_ROLE = keccak256("PAUSER_ROLE");

    struct DataStorage {
        uint32 chainId;
        address contractAddress;
    }

    DataStorage[] _dataStorage;
 
    constructor(string memory name_, string memory symbol_) ERC721(name_, symbol_) {
        _setupRole(DEFAULT_ADMIN_ROLE, _msgSender());
        _setupRole(MINTER_ROLE, _msgSender());
        _setupRole(PAUSER_ROLE, _msgSender());
        _setDefaultRoyalty(_msgSender(), 1000);
    }
    
    function tokenURI(uint256 tokenId_) public view override returns (string memory) {
        require(_exists(tokenId_), "ERC721Metadata: URI query for nonexistent token");
        
        bytes memory json = abi.encodePacked(_metadata[tokenId_]);
        return string(abi.encodePacked("data:application/json;base64,", Base64.encode(json)));
    }

    function bulkmint(address[] memory to_, uint256[] memory tokenId_) public {
        require(hasRole(MINTER_ROLE, _msgSender()), "must have minter role");
        require(to_.length == tokenId_.length, "length must be same");
        for(uint256 i; i < to_.length; i++){
            _safeMint(to_[i], tokenId_[i]);
        }
    }

    function addDataStorage(uint32 chainId_, address addr_) public {
        require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "must have admin role");
        DataStorage memory ds;
        ds.chainId = chainId_;
        ds.contractAddress = addr_;
        _dataStorage.push(ds);
    }

    function dataStorage() public view onlyOwner returns (DataStorage[] memory){
        return _dataStorage;
    }

    function setMetadataBulk(uint256[] memory tokenId_, string[] memory metadata_) public {
        require(hasRole(MINTER_ROLE, _msgSender()), "must have minter role");
        require(tokenId_.length == metadata_.length, "length must be same");
        for(uint256 i; i < tokenId_.length; i++){
             _metadata[tokenId_[i]] = metadata_[i];
        }
    }

    function setDefaultRoyalty(address receiver_, uint96 feeNumerator_) public{
        require(hasRole(DEFAULT_ADMIN_ROLE, _msgSender()), "must have admin role");
        _setDefaultRoyalty(receiver_, feeNumerator_);
    }

    function pause() public virtual {
        require(hasRole(PAUSER_ROLE, _msgSender()), "must have pauser role to pause");
        _pause();
    }

    function unpause() public virtual {
        require(hasRole(PAUSER_ROLE, _msgSender()), "must have pauser role to pause");
        _unpause();
    }

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual override(ERC721, ERC721Enumerable, ERC721Pausable) {
        super._beforeTokenTransfer(from, to, tokenId);
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override(ERC721, ERC721Enumerable, ERC2981, AccessControlEnumerable)
        returns (bool)
    {
        return super.supportsInterface(interfaceId);
    }

}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Paused","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"account","type":"address"}],"name":"Unpaused","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINTER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PAUSER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint32","name":"chainId_","type":"uint32"},{"internalType":"address","name":"addr_","type":"address"}],"name":"addDataStorage","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"to_","type":"address[]"},{"internalType":"uint256[]","name":"tokenId_","type":"uint256[]"}],"name":"bulkmint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"dataStorage","outputs":[{"components":[{"internalType":"uint32","name":"chainId","type":"uint32"},{"internalType":"address","name":"contractAddress","type":"address"}],"internalType":"struct Bansho.DataStorage[]","name":"","type":"tuple[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"getRoleMember","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleMemberCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"receiver_","type":"address"},{"internalType":"uint96","name":"feeNumerator_","type":"uint96"}],"name":"setDefaultRoyalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenId_","type":"uint256[]"},{"internalType":"string[]","name":"metadata_","type":"string[]"}],"name":"setMetadataBulk","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId_","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unpause","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

0x608060405234801561001057600080fd5b506004361061023d5760003560e01c8063715018a61161013b578063b88d4fde116100b8578063d547741f1161007c578063d547741f14610501578063d81a306714610514578063e63ab1e914610527578063e985e9c51461054e578063f2fde38b1461058a57600080fd5b8063b88d4fde1461048e578063c87b56dd146104a1578063ca15c873146104b4578063d2017291146104c7578063d5391393146104da57600080fd5b806391d14854116100ff57806391d148541461044557806395d89b4114610458578063a217fddf14610460578063a22cb46514610468578063a76190be1461047b57600080fd5b8063715018a6146103f75780638456cb59146103ff5780638870455f146104075780638da5cb5b1461041c5780639010d07c1461043257600080fd5b80632f2ff15d116101c957806342966c681161018d57806342966c68146103a05780634f6ccce7146103b35780635c975abb146103c65780636352211e146103d157806370a08231146103e457600080fd5b80632f2ff15d1461034c5780632f745c591461035f57806336568abe146103725780633f4ba83a1461038557806342842e0e1461038d57600080fd5b8063095ea7b311610210578063095ea7b3146102bf57806318160ddd146102d257806323b872dd146102e4578063248a9ca3146102f75780632a55205a1461031a57600080fd5b806301ffc9a71461024257806304634d8d1461026a57806306fdde031461027f578063081812fc14610294575b600080fd5b61025561025036600461281b565b61059d565b60405190151581526020015b60405180910390f35b61027d610278366004612854565b6105ae565b005b61028761060f565b60405161026191906128ef565b6102a76102a2366004612902565b6106a1565b6040516001600160a01b039091168152602001610261565b61027d6102cd36600461291b565b610736565b6008545b604051908152602001610261565b61027d6102f2366004612945565b61084b565b6102d6610305366004612902565b6000908152600d602052604090206001015490565b61032d610328366004612981565b61087d565b604080516001600160a01b039093168352602083019190915201610261565b61027d61035a3660046129a3565b610929565b6102d661036d36600461291b565b61094f565b61027d6103803660046129a3565b6109e5565b61027d610a5f565b61027d61039b366004612945565b610adf565b61027d6103ae366004612902565b610afa565b6102d66103c1366004612902565b610b74565b600c5460ff16610255565b6102a76103df366004612902565b610c07565b6102d66103f23660046129cf565b610c7e565b61027d610d05565b61027d610d3f565b61040f610dbd565b60405161026191906129ea565b600c5461010090046001600160a01b03166102a7565b6102a7610440366004612981565b610e68565b6102556104533660046129a3565b610e87565b610287610eb2565b6102d6600081565b61027d610476366004612a48565b610ec1565b61027d610489366004612a79565b610ecc565b61027d61049c366004612b4d565b610f9b565b6102876104af366004612902565b610fd3565b6102d66104c2366004612902565b6110b0565b61027d6104d5366004612c58565b6110c7565b6102d67f9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a681565b61027d61050f3660046129a3565b6111d6565b61027d610522366004612d18565b6111fc565b6102d67f65d7a28e3265b37a6474929f336521b332c1681b933f6cb9f3376673440d862a81565b61025561055c366004612e03565b6001600160a01b03918216600090815260056020908152604080832093909416825291909152205460ff1690565b61027d6105983660046129cf565b611329565b60006105a882611462565b92915050565b6105b9600033610e87565b6106015760405162461bcd60e51b81526020600482015260146024820152736d75737420686176652061646d696e20726f6c6560601b60448201526064015b60405180910390fd5b61060b8282611487565b5050565b60606000805461061e90612e1f565b80601f016020809104026020016040519081016040528092919081815260200182805461064a90612e1f565b80156106975780601f1061066c57610100808354040283529160200191610697565b820191906000526020600020905b81548152906001019060200180831161067a57829003601f168201915b5050505050905090565b6000818152600260205260408120546001600160a01b031661071a5760405162461bcd60e51b815260206004820152602c60248201527f4552433732313a20617070726f76656420717565727920666f72206e6f6e657860448201526b34b9ba32b73a103a37b5b2b760a11b60648201526084016105f8565b506000908152600460205260409020546001600160a01b031690565b600061074182610c07565b9050806001600160a01b0316836001600160a01b0316036107ae5760405162461bcd60e51b815260206004820152602160248201527f4552433732313a20617070726f76616c20746f2063757272656e74206f776e656044820152603960f91b60648201526084016105f8565b336001600160a01b03821614806107ca57506107ca813361055c565b61083c5760405162461bcd60e51b815260206004820152603860248201527f4552433732313a20617070726f76652063616c6c6572206973206e6f74206f7760448201527f6e6572206e6f7220617070726f76656420666f7220616c6c000000000000000060648201526084016105f8565b6108468383611584565b505050565b610856335b826115f2565b6108725760405162461bcd60e51b81526004016105f890612e59565b6108468383836116e9565b6000828152600b602090815260408083208151808301909252546001600160a01b038116808352600160a01b9091046001600160601b03169282019290925282916108f2575060408051808201909152600a546001600160a01b0381168252600160a01b90046001600160601b031660208201525b602081015160009061271090610911906001600160601b031687612ec0565b61091b9190612edf565b915196919550909350505050565b6000828152600d60205260409020600101546109458133611890565b61084683836118f4565b600061095a83610c7e565b82106109bc5760405162461bcd60e51b815260206004820152602b60248201527f455243373231456e756d657261626c653a206f776e657220696e646578206f7560448201526a74206f6620626f756e647360a81b60648201526084016105f8565b506001600160a01b03919091166000908152600660209081526040808320938352929052205490565b6001600160a01b0381163314610a555760405162461bcd60e51b815260206004820152602f60248201527f416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e636560448201526e103937b632b9903337b91039b2b63360891b60648201526084016105f8565b61060b8282611916565b610a897f65d7a28e3265b37a6474929f336521b332c1681b933f6cb9f3376673440d862a33610e87565b610ad55760405162461bcd60e51b815260206004820152601e60248201527f6d75737420686176652070617573657220726f6c6520746f207061757365000060448201526064016105f8565b610add611938565b565b61084683838360405180602001604052806000815250610f9b565b610b0333610850565b610b685760405162461bcd60e51b815260206004820152603060248201527f4552433732314275726e61626c653a2063616c6c6572206973206e6f74206f7760448201526f1b995c881b9bdc88185c1c1c9bdd995960821b60648201526084016105f8565b610b71816119cb565b50565b6000610b7f60085490565b8210610be25760405162461bcd60e51b815260206004820152602c60248201527f455243373231456e756d657261626c653a20676c6f62616c20696e646578206f60448201526b7574206f6620626f756e647360a01b60648201526084016105f8565b60088281548110610bf557610bf5612f01565b90600052602060002001549050919050565b6000818152600260205260408120546001600160a01b0316806105a85760405162461bcd60e51b815260206004820152602960248201527f4552433732313a206f776e657220717565727920666f72206e6f6e657869737460448201526832b73a103a37b5b2b760b91b60648201526084016105f8565b60006001600160a01b038216610ce95760405162461bcd60e51b815260206004820152602a60248201527f4552433732313a2062616c616e636520717565727920666f7220746865207a65604482015269726f206164647265737360b01b60648201526084016105f8565b506001600160a01b031660009081526003602052604090205490565b600c546001600160a01b03610100909104163314610d355760405162461bcd60e51b81526004016105f890612f17565b610add6000611a72565b610d697f65d7a28e3265b37a6474929f336521b332c1681b933f6cb9f3376673440d862a33610e87565b610db55760405162461bcd60e51b815260206004820152601e60248201527f6d75737420686176652070617573657220726f6c6520746f207061757365000060448201526064016105f8565b610add611acc565b600c546060906001600160a01b03610100909104163314610df05760405162461bcd60e51b81526004016105f890612f17565b6010805480602002602001604051908101604052809291908181526020016000905b82821015610e5f576000848152602090819020604080518082019091529084015463ffffffff8116825264010000000090046001600160a01b031681830152825260019092019101610e12565b50505050905090565b6000828152600e60205260408120610e809083611b47565b9392505050565b6000918252600d602090815260408084206001600160a01b0393909316845291905290205460ff1690565b60606001805461061e90612e1f565b61060b338383611b53565b610ed7600033610e87565b610f1a5760405162461bcd60e51b81526020600482015260146024820152736d75737420686176652061646d696e20726f6c6560601b60448201526064016105f8565b6040805180820190915263ffffffff92831681526001600160a01b03918216602082019081526010805460018101825560009190915291517f1b6847dc741a1b0cd08d278845f9d819d87b734759afb55fe2de5cb82a9ae67290920180549151929094166001600160c01b0319909116176401000000009190921602179055565b610fa533836115f2565b610fc15760405162461bcd60e51b81526004016105f890612e59565b610fcd84848484611c21565b50505050565b6000818152600260205260409020546060906001600160a01b03166110525760405162461bcd60e51b815260206004820152602f60248201527f4552433732314d657461646174613a2055524920717565727920666f72206e6f60448201526e3732bc34b9ba32b73a103a37b5b2b760891b60648201526084016105f8565b6000828152600f60209081526040808320905161106f9201612f4c565b604051602081830303815290604052905061108981611c54565b6040516020016110999190612fe7565b604051602081830303815290604052915050919050565b6000818152600e602052604081206105a890611dbe565b6110f17f9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a633610e87565b6111355760405162461bcd60e51b81526020600482015260156024820152746d7573742068617665206d696e74657220726f6c6560581b60448201526064016105f8565b805182511461117c5760405162461bcd60e51b81526020600482015260136024820152726c656e677468206d7573742062652073616d6560681b60448201526064016105f8565b60005b8251811015610846576111c483828151811061119d5761119d612f01565b60200260200101518383815181106111b7576111b7612f01565b6020026020010151611dc8565b806111ce8161302c565b91505061117f565b6000828152600d60205260409020600101546111f28133611890565b6108468383611916565b6112267f9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a633610e87565b61126a5760405162461bcd60e51b81526020600482015260156024820152746d7573742068617665206d696e74657220726f6c6560581b60448201526064016105f8565b80518251146112b15760405162461bcd60e51b81526020600482015260136024820152726c656e677468206d7573742062652073616d6560681b60448201526064016105f8565b60005b8251811015610846578181815181106112cf576112cf612f01565b6020026020010151600f60008584815181106112ed576112ed612f01565b60200260200101518152602001908152602001600020908051906020019061131692919061276c565b50806113218161302c565b9150506112b4565b600c546001600160a01b036101009091041633146113595760405162461bcd60e51b81526004016105f890612f17565b6001600160a01b0381166113be5760405162461bcd60e51b815260206004820152602660248201527f4f776e61626c653a206e6577206f776e657220697320746865207a65726f206160448201526564647265737360d01b60648201526084016105f8565b610b7181611a72565b6113d18282610e87565b61060b576000828152600d602090815260408083206001600160a01b03851684529091529020805460ff191660011790556114093390565b6001600160a01b0316816001600160a01b0316837f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d60405160405180910390a45050565b6000610e80836001600160a01b038416611de2565b60006001600160e01b03198216635a05180f60e01b14806105a857506105a882611e31565b6127106001600160601b03821611156114f55760405162461bcd60e51b815260206004820152602a60248201527f455243323938313a20726f79616c7479206665652077696c6c206578636565646044820152692073616c65507269636560b01b60648201526084016105f8565b6001600160a01b03821661154b5760405162461bcd60e51b815260206004820152601960248201527f455243323938313a20696e76616c69642072656365697665720000000000000060448201526064016105f8565b604080518082019091526001600160a01b039092168083526001600160601b039091166020909201829052600160a01b90910217600a55565b600081815260046020526040902080546001600160a01b0319166001600160a01b03841690811790915581906115b982610c07565b6001600160a01b03167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45050565b6000818152600260205260408120546001600160a01b031661166b5760405162461bcd60e51b815260206004820152602c60248201527f4552433732313a206f70657261746f7220717565727920666f72206e6f6e657860448201526b34b9ba32b73a103a37b5b2b760a11b60648201526084016105f8565b600061167683610c07565b9050806001600160a01b0316846001600160a01b031614806116b15750836001600160a01b03166116a6846106a1565b6001600160a01b0316145b806116e157506001600160a01b0380821660009081526005602090815260408083209388168352929052205460ff165b949350505050565b826001600160a01b03166116fc82610c07565b6001600160a01b0316146117605760405162461bcd60e51b815260206004820152602560248201527f4552433732313a207472616e736665722066726f6d20696e636f72726563742060448201526437bbb732b960d91b60648201526084016105f8565b6001600160a01b0382166117c25760405162461bcd60e51b8152602060048201526024808201527f4552433732313a207472616e7366657220746f20746865207a65726f206164646044820152637265737360e01b60648201526084016105f8565b6117cd838383611e56565b6117d8600082611584565b6001600160a01b0383166000908152600360205260408120805460019290611801908490613045565b90915550506001600160a01b038216600090815260036020526040812080546001929061182f90849061305c565b909155505060008181526002602052604080822080546001600160a01b0319166001600160a01b0386811691821790925591518493918716917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef91a4505050565b61189a8282610e87565b61060b576118b2816001600160a01b03166014611e61565b6118bd836020611e61565b6040516020016118ce929190613074565b60408051601f198184030181529082905262461bcd60e51b82526105f8916004016128ef565b6118fe82826113c7565b6000828152600e60205260409020610846908261144d565b6119208282611ffd565b6000828152600e602052604090206108469082612064565b600c5460ff166119815760405162461bcd60e51b815260206004820152601460248201527314185d5cd8589b194e881b9bdd081c185d5cd95960621b60448201526064016105f8565b600c805460ff191690557f5db9ee0a495bf2e6ff9c91a7834c1ba4fdd244a5e8aa4e537bd38aeae4b073aa335b6040516001600160a01b03909116815260200160405180910390a1565b60006119d682610c07565b90506119e481600084611e56565b6119ef600083611584565b6001600160a01b0381166000908152600360205260408120805460019290611a18908490613045565b909155505060008281526002602052604080822080546001600160a01b0319169055518391906001600160a01b038416907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908390a45050565b600c80546001600160a01b03838116610100818102610100600160a81b031985161790945560405193909204169182907f8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e090600090a35050565b600c5460ff1615611b125760405162461bcd60e51b815260206004820152601060248201526f14185d5cd8589b194e881c185d5cd95960821b60448201526064016105f8565b600c805460ff191660011790557f62e78cea01bee320cd4e420270b5ea74000d11b0c9f74754ebdbfc544b05a2586119ae3390565b6000610e808383612079565b816001600160a01b0316836001600160a01b031603611bb45760405162461bcd60e51b815260206004820152601960248201527f4552433732313a20617070726f766520746f2063616c6c65720000000000000060448201526064016105f8565b6001600160a01b03838116600081815260056020908152604080832094871680845294825291829020805460ff191686151590811790915591519182527f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31910160405180910390a3505050565b611c2c8484846116e9565b611c38848484846120a3565b610fcd5760405162461bcd60e51b81526004016105f8906130e9565b80516060906000819003611c78575050604080516020810190915260008152919050565b60006003611c8783600261305c565b611c919190612edf565b611c9c906004612ec0565b90506000611cab82602061305c565b67ffffffffffffffff811115611cc357611cc3612aae565b6040519080825280601f01601f191660200182016040528015611ced576020820181803683370190505b50905060006040518060600160405280604081526020016131c3604091399050600181016020830160005b86811015611d79576003818a01810151603f601282901c8116860151600c83901c8216870151600684901c831688015192909316870151600891821b60ff94851601821b92841692909201901b91160160e01b835260049092019101611d18565b506003860660018114611d935760028114611da457611db0565b613d3d60f01b600119830152611db0565b603d60f81b6000198301525b505050918152949350505050565b60006105a8825490565b61060b8282604051806020016040528060008152506121a4565b6000818152600183016020526040812054611e29575081546001818101845560008481526020808220909301849055845484825282860190935260409020919091556105a8565b5060006105a8565b60006001600160e01b03198216637965db0b60e01b14806105a857506105a8826121d7565b6108468383836121fc565b60606000611e70836002612ec0565b611e7b90600261305c565b67ffffffffffffffff811115611e9357611e93612aae565b6040519080825280601f01601f191660200182016040528015611ebd576020820181803683370190505b509050600360fc1b81600081518110611ed857611ed8612f01565b60200101906001600160f81b031916908160001a905350600f60fb1b81600181518110611f0757611f07612f01565b60200101906001600160f81b031916908160001a9053506000611f2b846002612ec0565b611f3690600161305c565b90505b6001811115611fae576f181899199a1a9b1b9c1cb0b131b232b360811b85600f1660108110611f6a57611f6a612f01565b1a60f81b828281518110611f8057611f80612f01565b60200101906001600160f81b031916908160001a90535060049490941c93611fa78161313b565b9050611f39565b508315610e805760405162461bcd60e51b815260206004820181905260248201527f537472696e67733a20686578206c656e67746820696e73756666696369656e7460448201526064016105f8565b6120078282610e87565b1561060b576000828152600d602090815260408083206001600160a01b0385168085529252808320805460ff1916905551339285917ff6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b9190a45050565b6000610e80836001600160a01b03841661226e565b600082600001828154811061209057612090612f01565b9060005260206000200154905092915050565b60006001600160a01b0384163b1561219957604051630a85bd0160e11b81526001600160a01b0385169063150b7a02906120e7903390899088908890600401613152565b6020604051808303816000875af1925050508015612122575060408051601f3d908101601f1916820190925261211f9181019061318f565b60015b61217f573d808015612150576040519150601f19603f3d011682016040523d82523d6000602084013e612155565b606091505b5080516000036121775760405162461bcd60e51b81526004016105f8906130e9565b805181602001fd5b6001600160e01b031916630a85bd0160e11b1490506116e1565b506001949350505050565b6121ae8383612361565b6121bb60008484846120a3565b6108465760405162461bcd60e51b81526004016105f8906130e9565b60006001600160e01b0319821663152a902d60e11b14806105a857506105a8826124af565b6122078383836124d4565b600c5460ff16156108465760405162461bcd60e51b815260206004820152602b60248201527f4552433732315061757361626c653a20746f6b656e207472616e73666572207760448201526a1a1a5b19481c185d5cd95960aa1b60648201526084016105f8565b60008181526001830160205260408120548015612357576000612292600183613045565b85549091506000906122a690600190613045565b905081811461230b5760008660000182815481106122c6576122c6612f01565b90600052602060002001549050808760000184815481106122e9576122e9612f01565b6000918252602080832090910192909255918252600188019052604090208390555b855486908061231c5761231c6131ac565b6001900381819060005260206000200160009055905585600101600086815260200190815260200160002060009055600193505050506105a8565b60009150506105a8565b6001600160a01b0382166123b75760405162461bcd60e51b815260206004820181905260248201527f4552433732313a206d696e7420746f20746865207a65726f206164647265737360448201526064016105f8565b6000818152600260205260409020546001600160a01b03161561241c5760405162461bcd60e51b815260206004820152601c60248201527f4552433732313a20746f6b656e20616c7265616479206d696e7465640000000060448201526064016105f8565b61242860008383611e56565b6001600160a01b038216600090815260036020526040812080546001929061245190849061305c565b909155505060008181526002602052604080822080546001600160a01b0319166001600160a01b03861690811790915590518392907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a45050565b60006001600160e01b0319821663780e9d6360e01b14806105a857506105a88261258c565b6001600160a01b03831661252f5761252a81600880546000838152600960205260408120829055600182018355919091527ff3f7a9fe364faab93b216da50a3214154f22a0a2b415b23a84c8169e8b636ee30155565b612552565b816001600160a01b0316836001600160a01b0316146125525761255283826125dc565b6001600160a01b0382166125695761084681612679565b826001600160a01b0316826001600160a01b031614610846576108468282612728565b60006001600160e01b031982166380ac58cd60e01b14806125bd57506001600160e01b03198216635b5e139f60e01b145b806105a857506301ffc9a760e01b6001600160e01b03198316146105a8565b600060016125e984610c7e565b6125f39190613045565b600083815260076020526040902054909150808214612646576001600160a01b03841660009081526006602090815260408083208584528252808320548484528184208190558352600790915290208190555b5060009182526007602090815260408084208490556001600160a01b039094168352600681528383209183525290812055565b60085460009061268b90600190613045565b600083815260096020526040812054600880549394509092849081106126b3576126b3612f01565b9060005260206000200154905080600883815481106126d4576126d4612f01565b600091825260208083209091019290925582815260099091526040808220849055858252812055600880548061270c5761270c6131ac565b6001900381819060005260206000200160009055905550505050565b600061273383610c7e565b6001600160a01b039093166000908152600660209081526040808320868452825280832085905593825260079052919091209190915550565b82805461277890612e1f565b90600052602060002090601f01602090048101928261279a57600085556127e0565b82601f106127b357805160ff19168380011785556127e0565b828001600101855582156127e0579182015b828111156127e05782518255916020019190600101906127c5565b506127ec9291506127f0565b5090565b5b808211156127ec57600081556001016127f1565b6001600160e01b031981168114610b7157600080fd5b60006020828403121561282d57600080fd5b8135610e8081612805565b80356001600160a01b038116811461284f57600080fd5b919050565b6000806040838503121561286757600080fd5b61287083612838565b915060208301356001600160601b038116811461288c57600080fd5b809150509250929050565b60005b838110156128b257818101518382015260200161289a565b83811115610fcd5750506000910152565b600081518084526128db816020860160208601612897565b601f01601f19169290920160200192915050565b602081526000610e8060208301846128c3565b60006020828403121561291457600080fd5b5035919050565b6000806040838503121561292e57600080fd5b61293783612838565b946020939093013593505050565b60008060006060848603121561295a57600080fd5b61296384612838565b925061297160208501612838565b9150604084013590509250925092565b6000806040838503121561299457600080fd5b50508035926020909101359150565b600080604083850312156129b657600080fd5b823591506129c660208401612838565b90509250929050565b6000602082840312156129e157600080fd5b610e8082612838565b602080825282518282018190526000919060409081850190868401855b82811015612a3b578151805163ffffffff1685528601516001600160a01b0316868501529284019290850190600101612a07565b5091979650505050505050565b60008060408385031215612a5b57600080fd5b612a6483612838565b91506020830135801515811461288c57600080fd5b60008060408385031215612a8c57600080fd5b823563ffffffff81168114612aa057600080fd5b91506129c660208401612838565b634e487b7160e01b600052604160045260246000fd5b604051601f8201601f1916810167ffffffffffffffff81118282101715612aed57612aed612aae565b604052919050565b600067ffffffffffffffff831115612b0f57612b0f612aae565b612b22601f8401601f1916602001612ac4565b9050828152838383011115612b3657600080fd5b828260208301376000602084830101529392505050565b60008060008060808587031215612b6357600080fd5b612b6c85612838565b9350612b7a60208601612838565b925060408501359150606085013567ffffffffffffffff811115612b9d57600080fd5b8501601f81018713612bae57600080fd5b612bbd87823560208401612af5565b91505092959194509250565b600067ffffffffffffffff821115612be357612be3612aae565b5060051b60200190565b600082601f830112612bfe57600080fd5b81356020612c13612c0e83612bc9565b612ac4565b82815260059290921b84018101918181019086841115612c3257600080fd5b8286015b84811015612c4d5780358352918301918301612c36565b509695505050505050565b60008060408385031215612c6b57600080fd5b823567ffffffffffffffff80821115612c8357600080fd5b818501915085601f830112612c9757600080fd5b81356020612ca7612c0e83612bc9565b82815260059290921b84018101918181019089841115612cc657600080fd5b948201945b83861015612ceb57612cdc86612838565b82529482019490820190612ccb565b96505086013592505080821115612d0157600080fd5b50612d0e85828601612bed565b9150509250929050565b6000806040808486031215612d2c57600080fd5b833567ffffffffffffffff80821115612d4457600080fd5b612d5087838801612bed565b9450602091508186013581811115612d6757600080fd5b8601601f81018813612d7857600080fd5b8035612d86612c0e82612bc9565b81815260059190911b8201840190848101908a831115612da557600080fd5b8584015b83811015612df157803586811115612dc15760008081fd5b8501603f81018d13612dd35760008081fd5b612de38d898301358b8401612af5565b845250918601918601612da9565b50809750505050505050509250929050565b60008060408385031215612e1657600080fd5b612aa083612838565b600181811c90821680612e3357607f821691505b602082108103612e5357634e487b7160e01b600052602260045260246000fd5b50919050565b60208082526031908201527f4552433732313a207472616e736665722063616c6c6572206973206e6f74206f6040820152701ddb995c881b9bdc88185c1c1c9bdd9959607a1b606082015260800190565b634e487b7160e01b600052601160045260246000fd5b6000816000190483118215151615612eda57612eda612eaa565b500290565b600082612efc57634e487b7160e01b600052601260045260246000fd5b500490565b634e487b7160e01b600052603260045260246000fd5b6020808252818101527f4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572604082015260600190565b600080835481600182811c915080831680612f6857607f831692505b60208084108203612f8757634e487b7160e01b86526022600452602486fd5b818015612f9b5760018114612fac57612fd9565b60ff19861689528489019650612fd9565b60008a81526020902060005b86811015612fd15781548b820152908501908301612fb8565b505084890196505b509498975050505050505050565b7f646174613a6170706c69636174696f6e2f6a736f6e3b6261736536342c00000081526000825161301f81601d850160208701612897565b91909101601d0192915050565b60006001820161303e5761303e612eaa565b5060010190565b60008282101561305757613057612eaa565b500390565b6000821982111561306f5761306f612eaa565b500190565b7f416363657373436f6e74726f6c3a206163636f756e74200000000000000000008152600083516130ac816017850160208801612897565b7001034b99036b4b9b9b4b733903937b6329607d1b60179184019182015283516130dd816028840160208801612897565b01602801949350505050565b60208082526032908201527f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560408201527131b2b4bb32b91034b6b83632b6b2b73a32b960711b606082015260800190565b60008161314a5761314a612eaa565b506000190190565b6001600160a01b0385811682528416602082015260408101839052608060608201819052600090613185908301846128c3565b9695505050505050565b6000602082840312156131a157600080fd5b8151610e8081612805565b634e487b7160e01b600052603160045260246000fdfe4142434445464748494a4b4c4d4e4f505152535455565758595a6162636465666768696a6b6c6d6e6f707172737475767778797a303132333435363738392b2fa264697066735822122000ee9c14e08404138573e361d28ee712981801d753b1084c8fcd0490b41a36ca64736f6c634300080d0033

00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000e42616e73686f202d204c494748540000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000004424e534800000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name_ (string): Bansho - LIGHT
Arg [1] : symbol_ (string): BNSH

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [2] : 000000000000000000000000000000000000000000000000000000000000000e
Arg [3] : 42616e73686f202d204c49474854000000000000000000000000000000000000
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [5] : 424e534800000000000000000000000000000000000000000000000000000000

86619:3324:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;89675:263;;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;89675:263:0;;;;;;;;88884:222;;;;;;:::i;:::-;;:::i;:::-;;54678:100;;;:::i;:::-;;;;;;;:::i;56237:221::-;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;2241:32:1;;;2223:51;;2211:2;2196:18;56237:221:0;2077:203:1;55760:411:0;;;;;;:::i;:::-;;:::i;69544:113::-;69632:10;:17;69544:113;;;2690:25:1;;;2678:2;2663:18;69544:113:0;2544:177:1;56987:339:0;;;;;;:::i;:::-;;:::i;15810:131::-;;;;;;:::i;:::-;15884:7;15911:12;;;:6;:12;;;;;:22;;;;15810:131;81722:494;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;3871:32:1;;;3853:51;;3935:2;3920:18;;3913:34;;;;3826:18;81722:494:0;3679:274:1;16203:147:0;;;;;;:::i;:::-;;:::i;69212:256::-;;;;;;:::i;:::-;;:::i;17251:218::-;;;;;;:::i;:::-;;:::i;89269:151::-;;;:::i;57397:185::-;;;;;;:::i;:::-;;:::i;75571:245::-;;;;;;:::i;:::-;;:::i;69734:233::-;;;;;;:::i;:::-;;:::i;76938:86::-;77009:7;;;;76938:86;;54372:239;;;;;;:::i;:::-;;:::i;54102:208::-;;;;;;:::i;:::-;;:::i;2690:103::-;;;:::i;89114:147::-;;;:::i;88389:113::-;;;:::i;:::-;;;;;;;:::i;2039:87::-;2112:6;;;;;-1:-1:-1;;;;;2112:6:0;2039:87;;33305:153;;;;;;:::i;:::-;;:::i;14679:147::-;;;;;;:::i;:::-;;:::i;54847:104::-;;;:::i;13770:49::-;;13815:4;13770:49;;56530:155;;;;;;:::i;:::-;;:::i;88092:289::-;;;;;;:::i;:::-;;:::i;57653:328::-;;;;;;:::i;:::-;;:::i;87390:351::-;;;;;;:::i;:::-;;:::i;33632:142::-;;;;;;:::i;:::-;;:::i;87749:335::-;;;;;;:::i;:::-;;:::i;86821:62::-;;86859:24;86821:62;;16595:149;;;;;;:::i;:::-;;:::i;88510:366::-;;;;;;:::i;:::-;;:::i;86890:62::-;;86928:24;86890:62;;56756:164;;;;;;:::i;:::-;-1:-1:-1;;;;;56877:25:0;;;56853:4;56877:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;56756:164;2948:201;;;;;;:::i;:::-;;:::i;89675:263::-;89865:4;89894:36;89918:11;89894:23;:36::i;:::-;89887:43;89675:263;-1:-1:-1;;89675:263:0:o;88884:222::-;88977:41;13815:4;860:10;14679:147;:::i;88977:41::-;88969:74;;;;-1:-1:-1;;;88969:74:0;;11768:2:1;88969:74:0;;;11750:21:1;11807:2;11787:18;;;11780:30;-1:-1:-1;;;11826:18:1;;;11819:50;11886:18;;88969:74:0;;;;;;;;;89054:44;89073:9;89084:13;89054:18;:44::i;:::-;88884:222;;:::o;54678:100::-;54732:13;54765:5;54758:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;54678:100;:::o;56237:221::-;56313:7;59580:16;;;:7;:16;;;;;;-1:-1:-1;;;;;59580:16:0;56333:73;;;;-1:-1:-1;;;56333:73:0;;12502:2:1;56333:73:0;;;12484:21:1;12541:2;12521:18;;;12514:30;12580:34;12560:18;;;12553:62;-1:-1:-1;;;12631:18:1;;;12624:42;12683:19;;56333:73:0;12300:408:1;56333:73:0;-1:-1:-1;56426:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;56426:24:0;;56237:221::o;55760:411::-;55841:13;55857:23;55872:7;55857:14;:23::i;:::-;55841:39;;55905:5;-1:-1:-1;;;;;55899:11:0;:2;-1:-1:-1;;;;;55899:11:0;;55891:57;;;;-1:-1:-1;;;55891:57:0;;12915:2:1;55891:57:0;;;12897:21:1;12954:2;12934:18;;;12927:30;12993:34;12973:18;;;12966:62;-1:-1:-1;;;13044:18:1;;;13037:31;13085:19;;55891:57:0;12713:397:1;55891:57:0;860:10;-1:-1:-1;;;;;55983:21:0;;;;:62;;-1:-1:-1;56008:37:0;56025:5;860:10;56756:164;:::i;56008:37::-;55961:168;;;;-1:-1:-1;;;55961:168:0;;13317:2:1;55961:168:0;;;13299:21:1;13356:2;13336:18;;;13329:30;13395:34;13375:18;;;13368:62;13466:26;13446:18;;;13439:54;13510:19;;55961:168:0;13115:420:1;55961:168:0;56142:21;56151:2;56155:7;56142:8;:21::i;:::-;55830:341;55760:411;;:::o;56987:339::-;57182:41;860:10;57201:12;57215:7;57182:18;:41::i;:::-;57174:103;;;;-1:-1:-1;;;57174:103:0;;;;;;;:::i;:::-;57290:28;57300:4;57306:2;57310:7;57290:9;:28::i;81722:494::-;81866:7;81929:27;;;:17;:27;;;;;;;;81900:56;;;;;;;;;-1:-1:-1;;;;;81900:56:0;;;;;-1:-1:-1;;;81900:56:0;;;-1:-1:-1;;;;;81900:56:0;;;;;;;;81866:7;;81969:92;;-1:-1:-1;82020:29:0;;;;;;;;;82030:19;82020:29;-1:-1:-1;;;;;82020:29:0;;;;-1:-1:-1;;;82020:29:0;;-1:-1:-1;;;;;82020:29:0;;;;;81969:92;82111:23;;;;82073:21;;82582:5;;82098:36;;-1:-1:-1;;;;;82098:36:0;:10;:36;:::i;:::-;82097:58;;;;:::i;:::-;82176:16;;;;;-1:-1:-1;81722:494:0;;-1:-1:-1;;;;81722:494:0:o;16203:147::-;15884:7;15911:12;;;:6;:12;;;;;:22;;;14261:30;14272:4;860:10;14261;:30::i;:::-;16317:25:::1;16328:4;16334:7;16317:10;:25::i;69212:256::-:0;69309:7;69345:23;69362:5;69345:16;:23::i;:::-;69337:5;:31;69329:87;;;;-1:-1:-1;;;69329:87:0;;14687:2:1;69329:87:0;;;14669:21:1;14726:2;14706:18;;;14699:30;14765:34;14745:18;;;14738:62;-1:-1:-1;;;14816:18:1;;;14809:41;14867:19;;69329:87:0;14485:407:1;69329:87:0;-1:-1:-1;;;;;;69434:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;69212:256::o;17251:218::-;-1:-1:-1;;;;;17347:23:0;;860:10;17347:23;17339:83;;;;-1:-1:-1;;;17339:83:0;;15099:2:1;17339:83:0;;;15081:21:1;15138:2;15118:18;;;15111:30;15177:34;15157:18;;;15150:62;-1:-1:-1;;;15228:18:1;;;15221:45;15283:19;;17339:83:0;14897:411:1;17339:83:0;17435:26;17447:4;17453:7;17435:11;:26::i;89269:151::-;89322:34;86928:24;860:10;14679:147;:::i;89322:34::-;89314:77;;;;-1:-1:-1;;;89314:77:0;;15515:2:1;89314:77:0;;;15497:21:1;15554:2;15534:18;;;15527:30;15593:32;15573:18;;;15566:60;15643:18;;89314:77:0;15313:354:1;89314:77:0;89402:10;:8;:10::i;:::-;89269:151::o;57397:185::-;57535:39;57552:4;57558:2;57562:7;57535:39;;;;;;;;;;;;:16;:39::i;75571:245::-;75689:41;860:10;75708:12;780:98;75689:41;75681:102;;;;-1:-1:-1;;;75681:102:0;;15874:2:1;75681:102:0;;;15856:21:1;15913:2;15893:18;;;15886:30;15952:34;15932:18;;;15925:62;-1:-1:-1;;;16003:18:1;;;15996:46;16059:19;;75681:102:0;15672:412:1;75681:102:0;75794:14;75800:7;75794:5;:14::i;:::-;75571:245;:::o;69734:233::-;69809:7;69845:30;69632:10;:17;;69544:113;69845:30;69837:5;:38;69829:95;;;;-1:-1:-1;;;69829:95:0;;16291:2:1;69829:95:0;;;16273:21:1;16330:2;16310:18;;;16303:30;16369:34;16349:18;;;16342:62;-1:-1:-1;;;16420:18:1;;;16413:42;16472:19;;69829:95:0;16089:408:1;69829:95:0;69942:10;69953:5;69942:17;;;;;;;;:::i;:::-;;;;;;;;;69935:24;;69734:233;;;:::o;54372:239::-;54444:7;54480:16;;;:7;:16;;;;;;-1:-1:-1;;;;;54480:16:0;;54507:73;;;;-1:-1:-1;;;54507:73:0;;16836:2:1;54507:73:0;;;16818:21:1;16875:2;16855:18;;;16848:30;16914:34;16894:18;;;16887:62;-1:-1:-1;;;16965:18:1;;;16958:39;17014:19;;54507:73:0;16634:405:1;54102:208:0;54174:7;-1:-1:-1;;;;;54202:19:0;;54194:74;;;;-1:-1:-1;;;54194:74:0;;17246:2:1;54194:74:0;;;17228:21:1;17285:2;17265:18;;;17258:30;17324:34;17304:18;;;17297:62;-1:-1:-1;;;17375:18:1;;;17368:40;17425:19;;54194:74:0;17044:406:1;54194:74:0;-1:-1:-1;;;;;;54286:16:0;;;;;:9;:16;;;;;;;54102:208::o;2690:103::-;2112:6;;-1:-1:-1;;;;;2112:6:0;;;;;860:10;2259:23;2251:68;;;;-1:-1:-1;;;2251:68:0;;;;;;;:::i;:::-;2755:30:::1;2782:1;2755:18;:30::i;89114:147::-:0;89165:34;86928:24;860:10;14679:147;:::i;89165:34::-;89157:77;;;;-1:-1:-1;;;89157:77:0;;15515:2:1;89157:77:0;;;15497:21:1;15554:2;15534:18;;;15527:30;15593:32;15573:18;;;15566:60;15643:18;;89157:77:0;15313:354:1;89157:77:0;89245:8;:6;:8::i;88389:113::-;2112:6;;88443:20;;-1:-1:-1;;;;;2112:6:0;;;;;860:10;2259:23;2251:68;;;;-1:-1:-1;;;2251:68:0;;;;;;;:::i;:::-;88482:12:::1;88475:19;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;;;::::1;::::0;;;;::::1;::::0;;;;::::1;::::0;;;;;::::1;::::0;::::1;::::0;::::1;::::0;;;;::::1;-1:-1:-1::0;;;;;88475:19:0::1;::::0;;::::1;::::0;;;;;;::::1;::::0;::::1;;;;;;;;;;88389:113:::0;:::o;33305:153::-;33395:7;33422:18;;;:12;:18;;;;;:28;;33444:5;33422:21;:28::i;:::-;33415:35;33305:153;-1:-1:-1;;;33305:153:0:o;14679:147::-;14765:4;14789:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;14789:29:0;;;;;;;;;;;;;;;14679:147::o;54847:104::-;54903:13;54936:7;54929:14;;;;;:::i;56530:155::-;56625:52;860:10;56658:8;56668;56625:18;:52::i;88092:289::-;88174:41;13815:4;860:10;14679:147;:::i;88174:41::-;88166:74;;;;-1:-1:-1;;;88166:74:0;;11768:2:1;88166:74:0;;;11750:21:1;11807:2;11787:18;;;11780:30;-1:-1:-1;;;11826:18:1;;;11819:50;11886:18;;88166:74:0;11566:344:1;88166:74:0;-1:-1:-1;;;;;;;;;88283:21:0;;;;;;-1:-1:-1;;;;;88315:26:0;;;-1:-1:-1;;;88315:26:0;;;88352:12;:21;;;;;;;-1:-1:-1;88352:21:0;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;88352:21:0;;;;;;;;;;;;;88092:289::o;57653:328::-;57828:41;860:10;57861:7;57828:18;:41::i;:::-;57820:103;;;;-1:-1:-1;;;57820:103:0;;;;;;;:::i;:::-;57934:39;57948:4;57954:2;57958:7;57967:5;57934:13;:39::i;:::-;57653:328;;;;:::o;87390:351::-;59556:4;59580:16;;;:7;:16;;;;;;87456:13;;-1:-1:-1;;;;;59580:16:0;87482:77;;;;-1:-1:-1;;;87482:77:0;;18018:2:1;87482:77:0;;;18000:21:1;18057:2;18037:18;;;18030:30;18096:34;18076:18;;;18069:62;-1:-1:-1;;;18147:18:1;;;18140:45;18202:19;;87482:77:0;17816:411:1;87482:77:0;87580:17;87617:19;;;:9;:19;;;;;;;;87600:37;;;;;;:::i;:::-;;;;;;;;;;;;;87580:57;;87712:19;87726:4;87712:13;:19::i;:::-;87662:70;;;;;;;;:::i;:::-;;;;;;;;;;;;;87648:85;;;87390:351;;;:::o;33632:142::-;33712:7;33739:18;;;:12;:18;;;;;:27;;:25;:27::i;87749:335::-;87842:34;86859:24;860:10;14679:147;:::i;87842:34::-;87834:68;;;;-1:-1:-1;;;87834:68:0;;20117:2:1;87834:68:0;;;20099:21:1;20156:2;20136:18;;;20129:30;-1:-1:-1;;;20175:18:1;;;20168:51;20236:18;;87834:68:0;19915:345:1;87834:68:0;87935:8;:15;87921:3;:10;:29;87913:61;;;;-1:-1:-1;;;87913:61:0;;20467:2:1;87913:61:0;;;20449:21:1;20506:2;20486:18;;;20479:30;-1:-1:-1;;;20525:18:1;;;20518:49;20584:18;;87913:61:0;20265:343:1;87913:61:0;87989:9;87985:92;88004:3;:10;88000:1;:14;87985:92;;;88035:30;88045:3;88049:1;88045:6;;;;;;;;:::i;:::-;;;;;;;88053:8;88062:1;88053:11;;;;;;;;:::i;:::-;;;;;;;88035:9;:30::i;:::-;88016:3;;;;:::i;:::-;;;;87985:92;;16595:149;15884:7;15911:12;;;:6;:12;;;;;:22;;;14261:30;14272:4;860:10;14261;:30::i;:::-;16710:26:::1;16722:4;16728:7;16710:11;:26::i;88510:366::-:0;88615:34;86859:24;860:10;14679:147;:::i;88615:34::-;88607:68;;;;-1:-1:-1;;;88607:68:0;;20117:2:1;88607:68:0;;;20099:21:1;20156:2;20136:18;;;20129:30;-1:-1:-1;;;20175:18:1;;;20168:51;20236:18;;88607:68:0;19915:345:1;88607:68:0;88713:9;:16;88694:8;:15;:35;88686:67;;;;-1:-1:-1;;;88686:67:0;;20467:2:1;88686:67:0;;;20449:21:1;20506:2;20486:18;;;20479:30;-1:-1:-1;;;20525:18:1;;;20518:49;20584:18;;88686:67:0;20265:343:1;88686:67:0;88768:9;88764:105;88783:8;:15;88779:1;:19;88764:105;;;88845:9;88855:1;88845:12;;;;;;;;:::i;:::-;;;;;;;88820:9;:22;88830:8;88839:1;88830:11;;;;;;;;:::i;:::-;;;;;;;88820:22;;;;;;;;;;;:37;;;;;;;;;;;;:::i;:::-;-1:-1:-1;88800:3:0;;;;:::i;:::-;;;;88764:105;;2948:201;2112:6;;-1:-1:-1;;;;;2112:6:0;;;;;860:10;2259:23;2251:68;;;;-1:-1:-1;;;2251:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;3037:22:0;::::1;3029:73;;;::::0;-1:-1:-1;;;3029:73:0;;20955:2:1;3029:73:0::1;::::0;::::1;20937:21:1::0;20994:2;20974:18;;;20967:30;21033:34;21013:18;;;21006:62;-1:-1:-1;;;21084:18:1;;;21077:36;21130:19;;3029:73:0::1;20753:402:1::0;3029:73:0::1;3113:28;3132:8;3113:18;:28::i;18752:238::-:0;18836:22;18844:4;18850:7;18836;:22::i;:::-;18831:152;;18875:12;;;;:6;:12;;;;;;;;-1:-1:-1;;;;;18875:29:0;;;;;;;;;:36;;-1:-1:-1;;18875:36:0;18907:4;18875:36;;;18958:12;860:10;;780:98;18958:12;-1:-1:-1;;;;;18931:40:0;18949:7;-1:-1:-1;;;;;18931:40:0;18943:4;18931:40;;;;;;;;;;18752:238;;:::o;27225:152::-;27295:4;27319:50;27324:3;-1:-1:-1;;;;;27344:23:0;;27319:4;:50::i;32492:214::-;32577:4;-1:-1:-1;;;;;;32601:57:0;;-1:-1:-1;;;32601:57:0;;:97;;;32662:36;32686:11;32662:23;:36::i;82866:332::-;82582:5;-1:-1:-1;;;;;82969:33:0;;;;82961:88;;;;-1:-1:-1;;;82961:88:0;;21362:2:1;82961:88:0;;;21344:21:1;21401:2;21381:18;;;21374:30;21440:34;21420:18;;;21413:62;-1:-1:-1;;;21491:18:1;;;21484:40;21541:19;;82961:88:0;21160:406:1;82961:88:0;-1:-1:-1;;;;;83068:22:0;;83060:60;;;;-1:-1:-1;;;83060:60:0;;21773:2:1;83060:60:0;;;21755:21:1;21812:2;21792:18;;;21785:30;21851:27;21831:18;;;21824:55;21896:18;;83060:60:0;21571:349:1;83060:60:0;83155:35;;;;;;;;;-1:-1:-1;;;;;83155:35:0;;;;;;-1:-1:-1;;;;;83155:35:0;;;;;;;;;;-1:-1:-1;;;83133:57:0;;;;:19;:57;82866:332::o;63637:174::-;63712:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;63712:29:0;-1:-1:-1;;;;;63712:29:0;;;;;;;;:24;;63766:23;63712:24;63766:14;:23::i;:::-;-1:-1:-1;;;;;63757:46:0;;;;;;;;;;;63637:174;;:::o;59785:348::-;59878:4;59580:16;;;:7;:16;;;;;;-1:-1:-1;;;;;59580:16:0;59895:73;;;;-1:-1:-1;;;59895:73:0;;22127:2:1;59895:73:0;;;22109:21:1;22166:2;22146:18;;;22139:30;22205:34;22185:18;;;22178:62;-1:-1:-1;;;22256:18:1;;;22249:42;22308:19;;59895:73:0;21925:408:1;59895:73:0;59979:13;59995:23;60010:7;59995:14;:23::i;:::-;59979:39;;60048:5;-1:-1:-1;;;;;60037:16:0;:7;-1:-1:-1;;;;;60037:16:0;;:51;;;;60081:7;-1:-1:-1;;;;;60057:31:0;:20;60069:7;60057:11;:20::i;:::-;-1:-1:-1;;;;;60057:31:0;;60037:51;:87;;;-1:-1:-1;;;;;;56877:25:0;;;56853:4;56877:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;60092:32;60029:96;59785:348;-1:-1:-1;;;;59785:348:0:o;62894:625::-;63053:4;-1:-1:-1;;;;;63026:31:0;:23;63041:7;63026:14;:23::i;:::-;-1:-1:-1;;;;;63026:31:0;;63018:81;;;;-1:-1:-1;;;63018:81:0;;22540:2:1;63018:81:0;;;22522:21:1;22579:2;22559:18;;;22552:30;22618:34;22598:18;;;22591:62;-1:-1:-1;;;22669:18:1;;;22662:35;22714:19;;63018:81:0;22338:401:1;63018:81:0;-1:-1:-1;;;;;63118:16:0;;63110:65;;;;-1:-1:-1;;;63110:65:0;;22946:2:1;63110:65:0;;;22928:21:1;22985:2;22965:18;;;22958:30;23024:34;23004:18;;;22997:62;-1:-1:-1;;;23075:18:1;;;23068:34;23119:19;;63110:65:0;22744:400:1;63110:65:0;63188:39;63209:4;63215:2;63219:7;63188:20;:39::i;:::-;63292:29;63309:1;63313:7;63292:8;:29::i;:::-;-1:-1:-1;;;;;63334:15:0;;;;;;:9;:15;;;;;:20;;63353:1;;63334:15;:20;;63353:1;;63334:20;:::i;:::-;;;;-1:-1:-1;;;;;;;63365:13:0;;;;;;:9;:13;;;;;:18;;63382:1;;63365:13;:18;;63382:1;;63365:18;:::i;:::-;;;;-1:-1:-1;;63394:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;63394:21:0;-1:-1:-1;;;;;63394:21:0;;;;;;;;;63433:27;;63394:16;;63433:27;;;;;;;55830:341;55760:411;;:::o;15116:505::-;15205:22;15213:4;15219:7;15205;:22::i;:::-;15200:414;;15393:41;15421:7;-1:-1:-1;;;;;15393:41:0;15431:2;15393:19;:41::i;:::-;15507:38;15535:4;15542:2;15507:19;:38::i;:::-;15298:270;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;15298:270:0;;;;;;;;;;-1:-1:-1;;;15244:358:0;;;;;;;:::i;33867:169::-;33955:31;33972:4;33978:7;33955:16;:31::i;:::-;33997:18;;;;:12;:18;;;;;:31;;34020:7;33997:22;:31::i;34130:174::-;34219:32;34237:4;34243:7;34219:17;:32::i;:::-;34262:18;;;;:12;:18;;;;;:34;;34288:7;34262:25;:34::i;77997:120::-;77009:7;;;;77533:41;;;;-1:-1:-1;;;77533:41:0;;24405:2:1;77533:41:0;;;24387:21:1;24444:2;24424:18;;;24417:30;-1:-1:-1;;;24463:18:1;;;24456:50;24523:18;;77533:41:0;24203:344:1;77533:41:0;78056:7:::1;:15:::0;;-1:-1:-1;;78056:15:0::1;::::0;;78087:22:::1;860:10:::0;78096:12:::1;78087:22;::::0;-1:-1:-1;;;;;2241:32:1;;;2223:51;;2211:2;2196:18;78087:22:0::1;;;;;;;77997:120::o:0;62137:420::-;62197:13;62213:23;62228:7;62213:14;:23::i;:::-;62197:39;;62249:48;62270:5;62285:1;62289:7;62249:20;:48::i;:::-;62338:29;62355:1;62359:7;62338:8;:29::i;:::-;-1:-1:-1;;;;;62380:16:0;;;;;;:9;:16;;;;;:21;;62400:1;;62380:16;:21;;62400:1;;62380:21;:::i;:::-;;;;-1:-1:-1;;62419:16:0;;;;:7;:16;;;;;;62412:23;;-1:-1:-1;;;;;;62412:23:0;;;62453:36;62427:7;;62419:16;-1:-1:-1;;;;;62453:36:0;;;;;62419:16;;62453:36;88884:222;;:::o;3309:191::-;3402:6;;;-1:-1:-1;;;;;3419:17:0;;;3402:6;3419:17;;;-1:-1:-1;;;;;;3419:17:0;;;;;;3452:40;;3402:6;;;;;;;;3452:40;;3383:16;;3452:40;3372:128;3309:191;:::o;77738:118::-;77009:7;;;;77263:9;77255:38;;;;-1:-1:-1;;;77255:38:0;;24754:2:1;77255:38:0;;;24736:21:1;24793:2;24773:18;;;24766:30;-1:-1:-1;;;24812:18:1;;;24805:46;24868:18;;77255:38:0;24552:340:1;77255:38:0;77798:7:::1;:14:::0;;-1:-1:-1;;77798:14:0::1;77808:4;77798:14;::::0;;77828:20:::1;77835:12;860:10:::0;;780:98;28521:158;28595:7;28646:22;28650:3;28662:5;28646:3;:22::i;63953:315::-;64108:8;-1:-1:-1;;;;;64099:17:0;:5;-1:-1:-1;;;;;64099:17:0;;64091:55;;;;-1:-1:-1;;;64091:55:0;;25099:2:1;64091:55:0;;;25081:21:1;25138:2;25118:18;;;25111:30;25177:27;25157:18;;;25150:55;25222:18;;64091:55:0;24897:349:1;64091:55:0;-1:-1:-1;;;;;64157:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;64157:46:0;;;;;;;;;;64219:41;;540::1;;;64219::0;;513:18:1;64219:41:0;;;;;;;63953:315;;;:::o;58863:::-;59020:28;59030:4;59036:2;59040:7;59020:9;:28::i;:::-;59067:48;59090:4;59096:2;59100:7;59109:5;59067:22;:48::i;:::-;59059:111;;;;-1:-1:-1;;;59059:111:0;;;;;;;:::i;84717:1790::-;84815:11;;84775:13;;84801:11;84841:8;;;84837:23;;-1:-1:-1;;84851:9:0;;;;;;;;;-1:-1:-1;84851:9:0;;;84717:1790;-1:-1:-1;84717:1790:0:o;84837:23::-;84912:18;84950:1;84939:7;:3;84945:1;84939:7;:::i;:::-;84938:13;;;;:::i;:::-;84933:19;;:1;:19;:::i;:::-;84912:40;-1:-1:-1;85010:19:0;85042:15;84912:40;85055:2;85042:15;:::i;:::-;85032:26;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;85032:26:0;;85010:48;;85071:18;85092:5;;;;;;;;;;;;;;;;;85071:26;;85161:1;85154:5;85150:13;85206:2;85198:6;85194:15;85257:1;85225:960;85280:3;85277:1;85274:10;85225:960;;;85335:1;85378:12;;;;;85372:19;85473:4;85461:2;85457:14;;;;;85439:40;;85433:47;85625:2;85621:14;;;85617:25;;85603:40;;85597:47;85815:1;85811:13;;;85807:24;;85793:39;;85787:46;85996:16;;;;85982:31;;85976:38;85509:1;85505:11;;;85646:4;85593:58;;;85541:129;85695:11;;85783:57;;;85731:128;;;;85884:11;;85972:49;;85920:120;86069:3;86065:13;86098:22;;86168:1;86153:17;;;;85328:9;85225:960;;;85229:44;86217:1;86212:3;86208:11;86238:1;86233:84;;;;86336:1;86331:82;;;;86201:212;;86233:84;-1:-1:-1;;;;;86266:17:0;;86259:43;86233:84;;86331:82;-1:-1:-1;;;;;86364:17:0;;86357:41;86201:212;-1:-1:-1;;;86429:26:0;;;86436:6;84717:1790;-1:-1:-1;;;;84717:1790:0:o;28050:117::-;28113:7;28140:19;28148:3;23534:18;;23451:109;60475:110;60551:26;60561:2;60565:7;60551:26;;;;;;;;;;;;:9;:26::i;21140:414::-;21203:4;23333:19;;;:12;;;:19;;;;;;21220:327;;-1:-1:-1;21263:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;21446:18;;21424:19;;;:12;;;:19;;;;;;:40;;;;21479:11;;21220:327;-1:-1:-1;21530:5:0;21523:12;;14383:204;14468:4;-1:-1:-1;;;;;;14492:47:0;;-1:-1:-1;;;14492:47:0;;:87;;;14543:36;14567:11;14543:23;:36::i;89428:239::-;89614:45;89641:4;89647:2;89651:7;89614:26;:45::i;9437:451::-;9512:13;9538:19;9570:10;9574:6;9570:1;:10;:::i;:::-;:14;;9583:1;9570:14;:::i;:::-;9560:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;9560:25:0;;9538:47;;-1:-1:-1;;;9596:6:0;9603:1;9596:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;9596:15:0;;;;;;;;;-1:-1:-1;;;9622:6:0;9629:1;9622:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;9622:15:0;;;;;;;;-1:-1:-1;9653:9:0;9665:10;9669:6;9665:1;:10;:::i;:::-;:14;;9678:1;9665:14;:::i;:::-;9653:26;;9648:135;9685:1;9681;:5;9648:135;;;-1:-1:-1;;;9733:5:0;9741:3;9733:11;9720:25;;;;;;;:::i;:::-;;;;9708:6;9715:1;9708:9;;;;;;;;:::i;:::-;;;;:37;-1:-1:-1;;;;;9708:37:0;;;;;;;;-1:-1:-1;9770:1:0;9760:11;;;;;9688:3;;;:::i;:::-;;;9648:135;;;-1:-1:-1;9801:10:0;;9793:55;;;;-1:-1:-1;;;9793:55:0;;26013:2:1;9793:55:0;;;25995:21:1;;;26032:18;;;26025:30;26091:34;26071:18;;;26064:62;26143:18;;9793:55:0;25811:356:1;19122:239:0;19206:22;19214:4;19220:7;19206;:22::i;:::-;19202:152;;;19277:5;19245:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;19245:29:0;;;;;;;;;;:37;;-1:-1:-1;;19245:37:0;;;19302:40;860:10;;19245:12;;19302:40;;19277:5;19302:40;19122:239;;:::o;27553:158::-;27626:4;27650:53;27658:3;-1:-1:-1;;;;;27678:23:0;;27650:7;:53::i;23914:120::-;23981:7;24008:3;:11;;24020:5;24008:18;;;;;;;;:::i;:::-;;;;;;;;;24001:25;;23914:120;;;;:::o;64833:799::-;64988:4;-1:-1:-1;;;;;65009:13:0;;45368:19;:23;65005:620;;65045:72;;-1:-1:-1;;;65045:72:0;;-1:-1:-1;;;;;65045:36:0;;;;;:72;;860:10;;65096:4;;65102:7;;65111:5;;65045:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65045:72:0;;;;;;;;-1:-1:-1;;65045:72:0;;;;;;;;;;;;:::i;:::-;;;65041:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65287:6;:13;65304:1;65287:18;65283:272;;65330:60;;-1:-1:-1;;;65330:60:0;;;;;;;:::i;65283:272::-;65505:6;65499:13;65490:6;65486:2;65482:15;65475:38;65041:529;-1:-1:-1;;;;;;65168:51:0;-1:-1:-1;;;65168:51:0;;-1:-1:-1;65161:58:0;;65005:620;-1:-1:-1;65609:4:0;64833:799;;;;;;:::o;60812:321::-;60942:18;60948:2;60952:7;60942:5;:18::i;:::-;60993:54;61024:1;61028:2;61032:7;61041:5;60993:22;:54::i;:::-;60971:154;;;;-1:-1:-1;;;60971:154:0;;;;;;;:::i;81452:215::-;81554:4;-1:-1:-1;;;;;;81578:41:0;;-1:-1:-1;;;81578:41:0;;:81;;;81623:36;81647:11;81623:23;:36::i;78785:275::-;78929:45;78956:4;78962:2;78966:7;78929:26;:45::i;:::-;77009:7;;;;78995:9;78987:65;;;;-1:-1:-1;;;78987:65:0;;27122:2:1;78987:65:0;;;27104:21:1;27161:2;27141:18;;;27134:30;27200:34;27180:18;;;27173:62;-1:-1:-1;;;27251:18:1;;;27244:41;27302:19;;78987:65:0;26920:407:1;21730:1420:0;21796:4;21935:19;;;:12;;;:19;;;;;;21971:15;;21967:1176;;22346:21;22370:14;22383:1;22370:10;:14;:::i;:::-;22419:18;;22346:38;;-1:-1:-1;22399:17:0;;22419:22;;22440:1;;22419:22;:::i;:::-;22399:42;;22475:13;22462:9;:26;22458:405;;22509:17;22529:3;:11;;22541:9;22529:22;;;;;;;;:::i;:::-;;;;;;;;;22509:42;;22683:9;22654:3;:11;;22666:13;22654:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;22768:23;;;:12;;;:23;;;;;:36;;;22458:405;22944:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;23039:3;:12;;:19;23052:5;23039:19;;;;;;;;;;;23032:26;;;23082:4;23075:11;;;;;;;21967:1176;23126:5;23119:12;;;;;61469:439;-1:-1:-1;;;;;61549:16:0;;61541:61;;;;-1:-1:-1;;;61541:61:0;;27666:2:1;61541:61:0;;;27648:21:1;;;27685:18;;;27678:30;27744:34;27724:18;;;27717:62;27796:18;;61541:61:0;27464:356:1;61541:61:0;59556:4;59580:16;;;:7;:16;;;;;;-1:-1:-1;;;;;59580:16:0;:30;61613:58;;;;-1:-1:-1;;;61613:58:0;;28027:2:1;61613:58:0;;;28009:21:1;28066:2;28046:18;;;28039:30;28105;28085:18;;;28078:58;28153:18;;61613:58:0;27825:352:1;61613:58:0;61684:45;61713:1;61717:2;61721:7;61684:20;:45::i;:::-;-1:-1:-1;;;;;61742:13:0;;;;;;:9;:13;;;;;:18;;61759:1;;61742:13;:18;;61759:1;;61742:18;:::i;:::-;;;;-1:-1:-1;;61771:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;61771:21:0;-1:-1:-1;;;;;61771:21:0;;;;;;;;61810:33;;61771:16;;;61810:33;;61771:16;;61810:33;88884:222;;:::o;68904:224::-;69006:4;-1:-1:-1;;;;;;69030:50:0;;-1:-1:-1;;;69030:50:0;;:90;;;69084:36;69108:11;69084:23;:36::i;70580:589::-;-1:-1:-1;;;;;70786:18:0;;70782:187;;70821:40;70853:7;71996:10;:17;;71969:24;;;;:15;:24;;;;;:44;;;72024:24;;;;;;;;;;;;71892:164;70821:40;70782:187;;;70891:2;-1:-1:-1;;;;;70883:10:0;:4;-1:-1:-1;;;;;70883:10:0;;70879:90;;70910:47;70943:4;70949:7;70910:32;:47::i;:::-;-1:-1:-1;;;;;70983:16:0;;70979:183;;71016:45;71053:7;71016:36;:45::i;70979:183::-;71089:4;-1:-1:-1;;;;;71083:10:0;:2;-1:-1:-1;;;;;71083:10:0;;71079:83;;71110:40;71138:2;71142:7;71110:27;:40::i;53733:305::-;53835:4;-1:-1:-1;;;;;;53872:40:0;;-1:-1:-1;;;53872:40:0;;:105;;-1:-1:-1;;;;;;;53929:48:0;;-1:-1:-1;;;53929:48:0;53872:105;:158;;;-1:-1:-1;;;;;;;;;;11754:40:0;;;53994:36;11645:157;72683:988;72949:22;72999:1;72974:22;72991:4;72974:16;:22::i;:::-;:26;;;;:::i;:::-;73011:18;73032:26;;;:17;:26;;;;;;72949:51;;-1:-1:-1;73165:28:0;;;73161:328;;-1:-1:-1;;;;;73232:18:0;;73210:19;73232:18;;;:12;:18;;;;;;;;:34;;;;;;;;;73283:30;;;;;;:44;;;73400:30;;:17;:30;;;;;:43;;;73161:328;-1:-1:-1;73585:26:0;;;;:17;:26;;;;;;;;73578:33;;;-1:-1:-1;;;;;73629:18:0;;;;;:12;:18;;;;;:34;;;;;;;73622:41;72683:988::o;73966:1079::-;74244:10;:17;74219:22;;74244:21;;74264:1;;74244:21;:::i;:::-;74276:18;74297:24;;;:15;:24;;;;;;74670:10;:26;;74219:46;;-1:-1:-1;74297:24:0;;74219:46;;74670:26;;;;;;:::i;:::-;;;;;;;;;74648:48;;74734:11;74709:10;74720;74709:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;74814:28;;;:15;:28;;;;;;;:41;;;74986:24;;;;;74979:31;75021:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;74037:1008;;;73966:1079;:::o;71470:221::-;71555:14;71572:20;71589:2;71572:16;:20::i;:::-;-1:-1:-1;;;;;71603:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;71648:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;71470:221:0:o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:131:1;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:173::-;660:20;;-1:-1:-1;;;;;709:31:1;;699:42;;689:70;;755:1;752;745:12;689:70;592:173;;;:::o;770:366::-;837:6;845;898:2;886:9;877:7;873:23;869:32;866:52;;;914:1;911;904:12;866:52;937:29;956:9;937:29;:::i;:::-;927:39;;1016:2;1005:9;1001:18;988:32;-1:-1:-1;;;;;1053:5:1;1049:38;1042:5;1039:49;1029:77;;1102:1;1099;1092:12;1029:77;1125:5;1115:15;;;770:366;;;;;:::o;1141:258::-;1213:1;1223:113;1237:6;1234:1;1231:13;1223:113;;;1313:11;;;1307:18;1294:11;;;1287:39;1259:2;1252:10;1223:113;;;1354:6;1351:1;1348:13;1345:48;;;-1:-1:-1;;1389:1:1;1371:16;;1364:27;1141:258::o;1404:::-;1446:3;1484:5;1478:12;1511:6;1506:3;1499:19;1527:63;1583:6;1576:4;1571:3;1567:14;1560:4;1553:5;1549:16;1527:63;:::i;:::-;1644:2;1623:15;-1:-1:-1;;1619:29:1;1610:39;;;;1651:4;1606:50;;1404:258;-1:-1:-1;;1404:258:1:o;1667:220::-;1816:2;1805:9;1798:21;1779:4;1836:45;1877:2;1866:9;1862:18;1854:6;1836:45;:::i;1892:180::-;1951:6;2004:2;1992:9;1983:7;1979:23;1975:32;1972:52;;;2020:1;2017;2010:12;1972:52;-1:-1:-1;2043:23:1;;1892:180;-1:-1:-1;1892:180:1:o;2285:254::-;2353:6;2361;2414:2;2402:9;2393:7;2389:23;2385:32;2382:52;;;2430:1;2427;2420:12;2382:52;2453:29;2472:9;2453:29;:::i;:::-;2443:39;2529:2;2514:18;;;;2501:32;;-1:-1:-1;;;2285:254:1:o;2726:328::-;2803:6;2811;2819;2872:2;2860:9;2851:7;2847:23;2843:32;2840:52;;;2888:1;2885;2878:12;2840:52;2911:29;2930:9;2911:29;:::i;:::-;2901:39;;2959:38;2993:2;2982:9;2978:18;2959:38;:::i;:::-;2949:48;;3044:2;3033:9;3029:18;3016:32;3006:42;;2726:328;;;;;:::o;3426:248::-;3494:6;3502;3555:2;3543:9;3534:7;3530:23;3526:32;3523:52;;;3571:1;3568;3561:12;3523:52;-1:-1:-1;;3594:23:1;;;3664:2;3649:18;;;3636:32;;-1:-1:-1;3426:248:1:o;3958:254::-;4026:6;4034;4087:2;4075:9;4066:7;4062:23;4058:32;4055:52;;;4103:1;4100;4093:12;4055:52;4139:9;4126:23;4116:33;;4168:38;4202:2;4191:9;4187:18;4168:38;:::i;:::-;4158:48;;3958:254;;;;;:::o;4217:186::-;4276:6;4329:2;4317:9;4308:7;4304:23;4300:32;4297:52;;;4345:1;4342;4335:12;4297:52;4368:29;4387:9;4368:29;:::i;4408:839::-;4637:2;4689:21;;;4759:13;;4662:18;;;4781:22;;;4608:4;;4637:2;4822;;4840:18;;;;4881:15;;;4608:4;4924:297;4938:6;4935:1;4932:13;4924:297;;;4997:13;;5039:9;;5050:10;5035:26;5023:39;;5106:11;;5100:18;-1:-1:-1;;;;;5096:44:1;5082:12;;;5075:66;5161:12;;;;5196:15;;;;5137:1;4953:9;4924:297;;;-1:-1:-1;5238:3:1;;4408:839;-1:-1:-1;;;;;;;4408:839:1:o;5505:347::-;5570:6;5578;5631:2;5619:9;5610:7;5606:23;5602:32;5599:52;;;5647:1;5644;5637:12;5599:52;5670:29;5689:9;5670:29;:::i;:::-;5660:39;;5749:2;5738:9;5734:18;5721:32;5796:5;5789:13;5782:21;5775:5;5772:32;5762:60;;5818:1;5815;5808:12;5857:350;5924:6;5932;5985:2;5973:9;5964:7;5960:23;5956:32;5953:52;;;6001:1;5998;5991:12;5953:52;6040:9;6027:23;6090:10;6083:5;6079:22;6072:5;6069:33;6059:61;;6116:1;6113;6106:12;6059:61;6139:5;-1:-1:-1;6163:38:1;6197:2;6182:18;;6163:38;:::i;6212:127::-;6273:10;6268:3;6264:20;6261:1;6254:31;6304:4;6301:1;6294:15;6328:4;6325:1;6318:15;6344:275;6415:2;6409:9;6480:2;6461:13;;-1:-1:-1;;6457:27:1;6445:40;;6515:18;6500:34;;6536:22;;;6497:62;6494:88;;;6562:18;;:::i;:::-;6598:2;6591:22;6344:275;;-1:-1:-1;6344:275:1:o;6624:406::-;6688:5;6722:18;6714:6;6711:30;6708:56;;;6744:18;;:::i;:::-;6782:57;6827:2;6806:15;;-1:-1:-1;;6802:29:1;6833:4;6798:40;6782:57;:::i;:::-;6773:66;;6862:6;6855:5;6848:21;6902:3;6893:6;6888:3;6884:16;6881:25;6878:45;;;6919:1;6916;6909:12;6878:45;6968:6;6963:3;6956:4;6949:5;6945:16;6932:43;7022:1;7015:4;7006:6;6999:5;6995:18;6991:29;6984:40;6624:406;;;;;:::o;7035:666::-;7130:6;7138;7146;7154;7207:3;7195:9;7186:7;7182:23;7178:33;7175:53;;;7224:1;7221;7214:12;7175:53;7247:29;7266:9;7247:29;:::i;:::-;7237:39;;7295:38;7329:2;7318:9;7314:18;7295:38;:::i;:::-;7285:48;;7380:2;7369:9;7365:18;7352:32;7342:42;;7435:2;7424:9;7420:18;7407:32;7462:18;7454:6;7451:30;7448:50;;;7494:1;7491;7484:12;7448:50;7517:22;;7570:4;7562:13;;7558:27;-1:-1:-1;7548:55:1;;7599:1;7596;7589:12;7548:55;7622:73;7687:7;7682:2;7669:16;7664:2;7660;7656:11;7622:73;:::i;:::-;7612:83;;;7035:666;;;;;;;:::o;7706:183::-;7766:4;7799:18;7791:6;7788:30;7785:56;;;7821:18;;:::i;:::-;-1:-1:-1;7866:1:1;7862:14;7878:4;7858:25;;7706:183::o;7894:662::-;7948:5;8001:3;7994:4;7986:6;7982:17;7978:27;7968:55;;8019:1;8016;8009:12;7968:55;8055:6;8042:20;8081:4;8105:60;8121:43;8161:2;8121:43;:::i;:::-;8105:60;:::i;:::-;8199:15;;;8285:1;8281:10;;;;8269:23;;8265:32;;;8230:12;;;;8309:15;;;8306:35;;;8337:1;8334;8327:12;8306:35;8373:2;8365:6;8361:15;8385:142;8401:6;8396:3;8393:15;8385:142;;;8467:17;;8455:30;;8505:12;;;;8418;;8385:142;;;-1:-1:-1;8545:5:1;7894:662;-1:-1:-1;;;;;;7894:662:1:o;8561:1146::-;8679:6;8687;8740:2;8728:9;8719:7;8715:23;8711:32;8708:52;;;8756:1;8753;8746:12;8708:52;8796:9;8783:23;8825:18;8866:2;8858:6;8855:14;8852:34;;;8882:1;8879;8872:12;8852:34;8920:6;8909:9;8905:22;8895:32;;8965:7;8958:4;8954:2;8950:13;8946:27;8936:55;;8987:1;8984;8977:12;8936:55;9023:2;9010:16;9045:4;9069:60;9085:43;9125:2;9085:43;:::i;9069:60::-;9163:15;;;9245:1;9241:10;;;;9233:19;;9229:28;;;9194:12;;;;9269:19;;;9266:39;;;9301:1;9298;9291:12;9266:39;9325:11;;;;9345:148;9361:6;9356:3;9353:15;9345:148;;;9427:23;9446:3;9427:23;:::i;:::-;9415:36;;9378:12;;;;9471;;;;9345:148;;;9512:5;-1:-1:-1;;9555:18:1;;9542:32;;-1:-1:-1;;9586:16:1;;;9583:36;;;9615:1;9612;9605:12;9583:36;;9638:63;9693:7;9682:8;9671:9;9667:24;9638:63;:::i;:::-;9628:73;;;8561:1146;;;;;:::o;9712:1584::-;9840:6;9848;9879:2;9922;9910:9;9901:7;9897:23;9893:32;9890:52;;;9938:1;9935;9928:12;9890:52;9978:9;9965:23;10007:18;10048:2;10040:6;10037:14;10034:34;;;10064:1;10061;10054:12;10034:34;10087:61;10140:7;10131:6;10120:9;10116:22;10087:61;:::i;:::-;10077:71;;10167:2;10157:12;;10222:2;10211:9;10207:18;10194:32;10251:2;10241:8;10238:16;10235:36;;;10267:1;10264;10257:12;10235:36;10290:24;;10345:4;10337:13;;10333:27;-1:-1:-1;10323:55:1;;10374:1;10371;10364:12;10323:55;10410:2;10397:16;10433:60;10449:43;10489:2;10449:43;:::i;10433:60::-;10527:15;;;10609:1;10605:10;;;;10597:19;;10593:28;;;10558:12;;;;10633:19;;;10630:39;;;10665:1;10662;10655:12;10630:39;10697:2;10693;10689:11;10709:557;10725:6;10720:3;10717:15;10709:557;;;10811:3;10798:17;10847:2;10834:11;10831:19;10828:109;;;10891:1;10920:2;10916;10909:14;10828:109;10960:20;;11015:2;11007:11;;11003:25;-1:-1:-1;10993:123:1;;11070:1;11099:2;11095;11088:14;10993:123;11141:82;11215:7;11209:2;11205;11201:11;11188:25;11183:2;11179;11175:11;11141:82;:::i;:::-;11129:95;;-1:-1:-1;11244:12:1;;;;10742;;10709:557;;;10713:3;11285:5;11275:15;;;;;;;;;9712:1584;;;;;:::o;11301:260::-;11369:6;11377;11430:2;11418:9;11409:7;11405:23;11401:32;11398:52;;;11446:1;11443;11436:12;11398:52;11469:29;11488:9;11469:29;:::i;11915:380::-;11994:1;11990:12;;;;12037;;;12058:61;;12112:4;12104:6;12100:17;12090:27;;12058:61;12165:2;12157:6;12154:14;12134:18;12131:38;12128:161;;12211:10;12206:3;12202:20;12199:1;12192:31;12246:4;12243:1;12236:15;12274:4;12271:1;12264:15;12128:161;;11915:380;;;:::o;13540:413::-;13742:2;13724:21;;;13781:2;13761:18;;;13754:30;13820:34;13815:2;13800:18;;13793:62;-1:-1:-1;;;13886:2:1;13871:18;;13864:47;13943:3;13928:19;;13540:413::o;13958:127::-;14019:10;14014:3;14010:20;14007:1;14000:31;14050:4;14047:1;14040:15;14074:4;14071:1;14064:15;14090:168;14130:7;14196:1;14192;14188:6;14184:14;14181:1;14178:21;14173:1;14166:9;14159:17;14155:45;14152:71;;;14203:18;;:::i;:::-;-1:-1:-1;14243:9:1;;14090:168::o;14263:217::-;14303:1;14329;14319:132;;14373:10;14368:3;14364:20;14361:1;14354:31;14408:4;14405:1;14398:15;14436:4;14433:1;14426:15;14319:132;-1:-1:-1;14465:9:1;;14263:217::o;16502:127::-;16563:10;16558:3;16554:20;16551:1;16544:31;16594:4;16591:1;16584:15;16618:4;16615:1;16608:15;17455:356;17657:2;17639:21;;;17676:18;;;17669:30;17735:34;17730:2;17715:18;;17708:62;17802:2;17787:18;;17455:356::o;18358:1099::-;18486:3;18515:1;18548:6;18542:13;18578:3;18600:1;18628:9;18624:2;18620:18;18610:28;;18688:2;18677:9;18673:18;18710;18700:61;;18754:4;18746:6;18742:17;18732:27;;18700:61;18780:2;18828;18820:6;18817:14;18797:18;18794:38;18791:165;;-1:-1:-1;;;18855:33:1;;18911:4;18908:1;18901:15;18941:4;18862:3;18929:17;18791:165;18972:18;18999:104;;;;19117:1;19112:320;;;;18965:467;;18999:104;-1:-1:-1;;19032:24:1;;19020:37;;19077:16;;;;-1:-1:-1;18999:104:1;;19112:320;18305:1;18298:14;;;18342:4;18329:18;;19207:1;19221:165;19235:6;19232:1;19229:13;19221:165;;;19313:14;;19300:11;;;19293:35;19356:16;;;;19250:10;;19221:165;;;19225:3;;19415:6;19410:3;19406:16;19399:23;;18965:467;-1:-1:-1;19448:3:1;;18358:1099;-1:-1:-1;;;;;;;;18358:1099:1:o;19462:448::-;19724:31;19719:3;19712:44;19694:3;19785:6;19779:13;19801:62;19856:6;19851:2;19846:3;19842:12;19835:4;19827:6;19823:17;19801:62;:::i;:::-;19883:16;;;;19901:2;19879:25;;19462:448;-1:-1:-1;;19462:448:1:o;20613:135::-;20652:3;20673:17;;;20670:43;;20693:18;;:::i;:::-;-1:-1:-1;20740:1:1;20729:13;;20613:135::o;23149:125::-;23189:4;23217:1;23214;23211:8;23208:34;;;23222:18;;:::i;:::-;-1:-1:-1;23259:9:1;;23149:125::o;23279:128::-;23319:3;23350:1;23346:6;23343:1;23340:13;23337:39;;;23356:18;;:::i;:::-;-1:-1:-1;23392:9:1;;23279:128::o;23412:786::-;23823:25;23818:3;23811:38;23793:3;23878:6;23872:13;23894:62;23949:6;23944:2;23939:3;23935:12;23928:4;23920:6;23916:17;23894:62;:::i;:::-;-1:-1:-1;;;24015:2:1;23975:16;;;24007:11;;;24000:40;24065:13;;24087:63;24065:13;24136:2;24128:11;;24121:4;24109:17;;24087:63;:::i;:::-;24170:17;24189:2;24166:26;;23412:786;-1:-1:-1;;;;23412:786:1:o;25251:414::-;25453:2;25435:21;;;25492:2;25472:18;;;25465:30;25531:34;25526:2;25511:18;;25504:62;-1:-1:-1;;;25597:2:1;25582:18;;25575:48;25655:3;25640:19;;25251:414::o;25670:136::-;25709:3;25737:5;25727:39;;25746:18;;:::i;:::-;-1:-1:-1;;;25782:18:1;;25670:136::o;26172:489::-;-1:-1:-1;;;;;26441:15:1;;;26423:34;;26493:15;;26488:2;26473:18;;26466:43;26540:2;26525:18;;26518:34;;;26588:3;26583:2;26568:18;;26561:31;;;26366:4;;26609:46;;26635:19;;26627:6;26609:46;:::i;:::-;26601:54;26172:489;-1:-1:-1;;;;;;26172:489:1:o;26666:249::-;26735:6;26788:2;26776:9;26767:7;26763:23;26759:32;26756:52;;;26804:1;26801;26794:12;26756:52;26836:9;26830:16;26855:30;26879:5;26855:30;:::i;27332:127::-;27393:10;27388:3;27384:20;27381:1;27374:31;27424:4;27421:1;27414:15;27448:4;27445:1;27438:15

ipfs://00ee9c14e08404138573e361d28ee712981801d753b1084c8fcd0490b41a36ca