Contract 0x5bf946d5d72d5f6dbe02be9118f37cf394315d1a 1

/**
 *Submitted for verification at Arbiscan on 2022-04-22
*/

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

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

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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


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


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


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

pragma solidity ^0.8.0;

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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC165 standard, as defined in the
 * https://eips.ethereum.org/EIPS/eip-165[EIP].
 *
 * Implementers can declare support of contract interfaces, which can then be
 * queried by others ({ERC165Checker}).
 *
 * For an implementation, see {ERC165}.
 */
interface IERC165 {
    /**
     * @dev Returns true if this contract implements the interface defined by
     * `interfaceId`. See the corresponding
     * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section]
     * to learn more about how these ids are created.
     *
     * This function call must use less than 30 000 gas.
     */
    function supportsInterface(bytes4 interfaceId) external view returns (bool);
}


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


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

pragma solidity ^0.8.0;

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


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


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

pragma solidity ^0.8.0;




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

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

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


pragma solidity 0.8.7;

abstract contract Control is AccessControl {
    bytes32 public constant SHOGUN_OWNER_ROLE = keccak256("SHOGUN_OWNER_ROLE");

    modifier onlyOwner() {
        require(hasRole(SHOGUN_OWNER_ROLE, _msgSender()), "MinterControl: not a SHOGUN_OWNER_ROLE");
        _;
    }

    constructor() {
        _setRoleAdmin(SHOGUN_OWNER_ROLE, SHOGUN_OWNER_ROLE);
        _setupRole(SHOGUN_OWNER_ROLE, _msgSender());
    }

    function grantOwner(address _owner) external {
        grantRole(SHOGUN_OWNER_ROLE, _owner);
    }

    function isOwner(address _owner) public view returns (bool) {
        return hasRole(SHOGUN_OWNER_ROLE, _owner);
    }
}


// File contracts/ClansClasses/Clans.sol


pragma solidity 0.8.7;

contract Clans is Control {

    mapping(uint256 => string) public shogunClan;
    mapping(string => uint256) public clanMembers;

    event JoinClan(uint256 tokenId, string clan);
    event LeaveClan(uint256 tokenId, string clan);

    function testStr(string memory str) public pure returns (bool) {
      bytes memory b = bytes(str);
      if (b.length <= 2) return true;
      return false;
    }

    function setShogunClan(uint256 tokenId, string memory clan) external onlyOwner {
          require(testStr(shogunClan[tokenId]), "Cannot assign clan, remove clan first");
          shogunClan[tokenId] = clan;
          clanMembers[clan]++;
          emit JoinClan(tokenId, clan);
    }

    function removeShogunClan(uint256 tokenId) external onlyOwner {
        require(!testStr(shogunClan[tokenId]), "Cannot remove clan, no clan assigned");
        clanMembers[shogunClan[tokenId]]--;
        emit LeaveClan(tokenId, shogunClan[tokenId]);
        shogunClan[tokenId] = "na";
    }

    function checkShogunClan(uint256 tokenId) public view returns (string memory) {
        return shogunClan[tokenId];
    }

    function checkClanMembers(string memory clan) public view returns (uint256) {
        return clanMembers[clan];
    }
}


// File contracts/ClansClasses/Classes.sol


pragma solidity 0.8.7;

contract Classes is Control {

    mapping(uint256 => string) public shogunClass;
    mapping(string => uint256) public classMembers;

    event JoinClass(uint256 tokenId, string class);
    event LeaveClass(uint256 tokenId, string class);

    function testStr(string memory str) public pure returns (bool) {
      bytes memory b = bytes(str);
      if (b.length <= 2) return true;
      return false;
    }

    function setShogunClass(uint256 tokenId, string memory class) external onlyOwner {
          require(testStr(shogunClass[tokenId]), "Cannot assign class, remove class first");
          shogunClass[tokenId] = class;
          classMembers[class]++;
          emit JoinClass(tokenId, class);
    }

    function removeShogunClass(uint256 tokenId) external onlyOwner {
        require(!testStr(shogunClass[tokenId]), "Cannot remove class, no class assigned");
        classMembers[shogunClass[tokenId]]--;
        shogunClass[tokenId] = "na";
        emit LeaveClass(tokenId, shogunClass[tokenId]);
    }

    function checkShogunClass(uint256 tokenId) public view returns (string memory) {
        return shogunClass[tokenId];
    }

    function checkClassMembers(string memory class) public view returns (uint256) {
        return classMembers[class];
    }
}


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


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

pragma solidity ^0.8.0;

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

pragma solidity ^0.8.0;

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

pragma solidity ^0.8.0;

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

pragma solidity ^0.8.0;

/**
 * @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
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 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 v4.4.1 (token/ERC721/ERC721.sol)

pragma solidity ^0.8.0;







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

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

    /**
     * @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 of token that is not own");
        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);
    }

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


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


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

pragma solidity ^0.8.0;

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

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

pragma solidity ^0.8.0;


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


// OpenZeppelin Contracts v4.4.1 (utils/math/Math.sol)

pragma solidity ^0.8.0;

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

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

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

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


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


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

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}


// File contracts/MinterControl.sol


pragma solidity 0.8.7;

abstract contract MinterControl is AccessControl {
    bytes32 public constant SHOGUN_OWNER_ROLE = keccak256("SHOGUN_OWNER_ROLE");
    bytes32 public constant SHOGUN_MINTER_ROLE = keccak256("SHOGUN_MINTER_ROLE");

    modifier onlyOwner() {
        require(hasRole(SHOGUN_OWNER_ROLE, _msgSender()), "MinterControl: not a SHOGUN_OWNER_ROLE");
        _;
    }

    modifier onlyMinter() {
        require(isMinter(_msgSender()), "MinterControl: not a SHOGUN_MINTER_ROLE");
        _;
    }

    constructor() {
        _setRoleAdmin(SHOGUN_OWNER_ROLE, SHOGUN_OWNER_ROLE);
        _setRoleAdmin(SHOGUN_MINTER_ROLE, SHOGUN_OWNER_ROLE);

        _setupRole(SHOGUN_OWNER_ROLE, _msgSender());
    }

    function grantMinter(address _minter) external {
        grantRole(SHOGUN_MINTER_ROLE, _minter);
    }

    function grantMinterMass(address[] memory minters) external {
      for(uint i = 0; i < minters.length; i++) {
          grantRole(SHOGUN_MINTER_ROLE, minters[i]);
      }
    }

    function removeMinter(address _minter) external {
      revokeRole(SHOGUN_MINTER_ROLE, _minter);
    }

    function isMinter(address _minter) public view returns (bool) {
        return hasRole(SHOGUN_MINTER_ROLE, _minter);
    }

    function grantOwner(address _owner) external {
        grantRole(SHOGUN_OWNER_ROLE, _owner);
    }

    function isOwner(address _owner) public view returns (bool) {
        return hasRole(SHOGUN_OWNER_ROLE, _owner);
    }
}


// File contracts/Shogun.sol


pragma solidity 0.8.7;





contract Shogun is MinterControl, ERC721Enumerable {
    using Strings for uint256;
    using Counters for Counters.Counter;

    uint256 private constant nftsNumber = 13422;
    uint256 private constant nftsWhitelistNumber = 10000;

    mapping(address => bool) internal wlMinted;

    mapping(uint256 => bool) internal frozenShogun;


    Counters.Counter private _tokenIdCounter;
    string public baseURI;

    event ShogunMint(address to, uint256 tokenId);

    constructor() ERC721("Shogun War", "Shogun") {
      _tokenIdCounter._value = 1;
    }

    function supportsInterface(bytes4 interfaceId) public view override(ERC721Enumerable, AccessControl) returns (bool) {
        return ERC721Enumerable.supportsInterface(interfaceId) || AccessControl.supportsInterface(interfaceId);
    }

    function safeMint(address to) public onlyOwner {
        _mint(to);
    }

    function mintReserves(address to) public onlyOwner {
      for(uint i = 10000; i < 13423; i++) {
        _mintReserve(to, i);
      }
    }

    function mintReserve(address to, uint256 tokenId) public onlyOwner {
      require(tokenId > nftsWhitelistNumber, "Tokens number to mint must exceed number of public tokens");
      _mintReserve(to, tokenId);
    }

    function mint() external onlyMinter {
        require(wlMinted[msg.sender] == false, "You already used your whitelist mint pass");
        require(balanceOf(msg.sender) < 1, "You can only mint 1 NFT per whitelisted address");
        _mint(msg.sender);
        wlMinted[msg.sender] = true;
    }

    function tokenURI(uint256 _tokenId) public view override returns (string memory) {
        require(_exists(_tokenId), "Shogun: URI query for nonexistent token");
        return bytes(baseURI).length > 0 ?
            string(abi.encodePacked(
                baseURI,
                _tokenId.toString()
            ))
            : "";
    }

    function _mintReserve(address _to, uint256 _tokenId) internal {
        emit ShogunMint(_to, _tokenId);
        _safeMint(_to, _tokenId);
    }

    function _mint(address _to) internal {
        uint256 _tokenId;
        _tokenId = _tokenIdCounter.current();
        require(_tokenIdCounter.current() <= nftsWhitelistNumber, "Token number to mint exceeds number of whitelist tokens");
        _tokenIdCounter.increment();
        emit ShogunMint(_to, _tokenId);
        _safeMint(_to, _tokenId);
    }

    function freezeTransfer(uint256 _tokenId) external onlyOwner {
      frozenShogun[_tokenId] = true;
    }

    function unfreezeTransfer(uint256 _tokenId) external onlyOwner {
      frozenShogun[_tokenId] = false;
    }

    function _beforeTokenTransfer(
        address _from,
        address _to,
        uint256 _tokenId
    ) internal override {
        super._beforeTokenTransfer(_from, _to, _tokenId);
        require(frozenShogun[_tokenId] == false, "Shogun: Shogun is still busy, finish your assignment before transferring.");
    }

    function _baseURI() internal view override returns (string memory) {
        return baseURI;
    }

    // ADMIN


    function setBaseURI(string memory _baseURItoSet) external onlyOwner {
        baseURI = _baseURItoSet;
    }
}


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


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

pragma solidity ^0.8.0;

/**
 * @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 contracts/TrainingGround.sol


pragma solidity 0.8.7;


contract TrainingGround is Ownable {

    // shogun training duration
    uint256 public constant trainingDuration = 30 days;

    // amount of shoguns training
    uint256 public shogunTraining;

    // shogun NFT
    Shogun public shogun;

    // training tracking
    mapping(uint256 => uint256) public timestampJoined;
    mapping(uint256 => uint256) public timestampFinished;

    // Shogun trained
    mapping(uint256 => bool) public shogunTrained;

    uint256[] public shogunsTrained;


    event JoinTraining(uint256 tokenId, uint256 timestampJoined, uint256 timestampFinished);
    event FinishTraining(uint256 tokenId);
    event ShogunSet(address shogun);

    modifier onlyShogunOwner(uint256 _tokenId) {
        require(shogun.ownerOf(_tokenId) == msg.sender, "Training: only owner can send to training");
        _;
    }

    modifier onlyUntrainedShogun(uint256 _tokenId) {
        require(shogunTrained[_tokenId] == false, "Training: Shogun already trained");
        _;
    }

    modifier atTraining(uint256 _tokenId, bool expectedAtTraining) {
        require(isAtTraining(_tokenId) == expectedAtTraining, "Training: wrong training attendance");
        _;
    }

    modifier updateTotalTraining(bool isJoining) {
        isJoining ? shogunTraining++ : shogunTraining--;
        _;
    }

    modifier isTrainingFinished(uint256 _tokenId) {
        require(block.timestamp > timestampFinished[_tokenId], "Training: Your shogun is not ready to leave training yet");
        _;
    }

    function totalTraining() public view returns (uint256) {
        return shogunTraining;
    }

    function trainingFinishedDate(uint256 _tokenId) public view returns (uint256) {
        return timestampFinished[_tokenId];
    }

    function isTrained(uint256 _tokenId) public view returns (bool) {
        return shogunTrained[_tokenId];
    }

    function isAtTraining(uint256 _tokenId) public view returns (bool) {
        return timestampJoined[_tokenId] > 0;
    }

    function getTrainedShoguns() public view returns (uint256[] memory) {
        return shogunsTrained;
    }

    function join(uint256 _tokenId)
        external
        onlyShogunOwner(_tokenId)
        atTraining(_tokenId, false)
        onlyUntrainedShogun(_tokenId)
        updateTotalTraining(true)
    {
        timestampJoined[_tokenId] = block.timestamp;
        timestampFinished[_tokenId] = block.timestamp + trainingDuration;
        shogun.freezeTransfer(_tokenId);
        emit JoinTraining(_tokenId, timestampJoined[_tokenId], timestampFinished[_tokenId]);
    }

    function drop(uint256 _tokenId)
        external
        onlyShogunOwner(_tokenId)
        atTraining(_tokenId, true)
        isTrainingFinished(_tokenId)
        updateTotalTraining(false)
    {
        shogun.unfreezeTransfer(_tokenId);
        shogunTrained[_tokenId] = true;
        timestampJoined[_tokenId] = 0;
        shogunsTrained.push(_tokenId);
        emit FinishTraining(_tokenId);
    }

    // ADMIN

    function setShogun(address _shogun) external onlyOwner {
        shogun = Shogun(_shogun);
        emit ShogunSet(_shogun);
    }

    function forceDrop(uint256 _tokenId)
        external
        onlyOwner
        updateTotalTraining(false)
    {
        shogun.unfreezeTransfer(_tokenId);
        shogunTrained[_tokenId] = true;
        timestampJoined[_tokenId] = 0;
        shogunsTrained.push(_tokenId);
        emit FinishTraining(_tokenId);
    }
}


// File contracts/Land.sol


pragma solidity 0.8.7;







contract Land is MinterControl, ERC721Enumerable {
    using Strings for uint256;
    using Counters for Counters.Counter;

    Counters.Counter private _tokenIdCounter;
    string public baseURI;
    uint256 public landMaxLevel;

    mapping(uint256 => bool) public landIssued;
    mapping(uint256 => uint256) public landLevels;
    mapping(uint256 => bool) internal landFrozen;

    TrainingGround public trainingGround;
    Shogun public shogun;

    event LandMint(address indexed to, uint256 tokenId);
    event TrainingGroundSet(address trainingGround);
    event ShogunSet(address shogun);

    event LandUpgrade(uint256 indexed tokenId, uint256 availableLevel);
    event LandMaxLevel(uint256 landMaxLevel);


    constructor() ERC721("Shogun War Land", "ShogunWarLand") {
      _tokenIdCounter._value = 1;
    }


    function supportsInterface(bytes4 interfaceId) public view override(ERC721Enumerable, AccessControl) returns (bool) {
        return ERC721Enumerable.supportsInterface(interfaceId) || AccessControl.supportsInterface(interfaceId);
    }

    function mint(uint256[] memory shogunIds) external {
        require(shogunIds.length > 0, "Must provide at least one Shogun Id");
        require(shogun.balanceOf(msg.sender) > 0, "Wallet address does not hold a Shogun");

        for(uint256 i = 0; i < shogunIds.length; i++) {
          require(shogun.ownerOf(shogunIds[i]) == msg.sender, "You do not own one of the shoguns");
          require(trainingGround.isTrained(shogunIds[i]), "Shogun not trained, cannot claim land");
          require(!landIssued[shogunIds[i]], "This shogun has already claimed their land");
          landIssued[shogunIds[i]] = true;
          _mint(msg.sender);
        }
    }

    function safeMint(address to) public onlyOwner {
        _mint(to);
    }

    function _mint(address _to) internal {
        uint256 _tokenId;
        _tokenId = _tokenIdCounter.current();
        _tokenIdCounter.increment();
        landLevels[_tokenId] = 1;
        _safeMint(_to, _tokenId);
        emit LandMint(_to, _tokenId);
    }


    function freezeTransfer(uint256 _tokenId) external onlyOwner {
      landFrozen[_tokenId] = true;
    }

    function unfreezeTransfer(uint256 _tokenId) external onlyOwner {
      landFrozen[_tokenId] = false;
    }

    function setLandLevel(uint256 _tokenId, uint256 level) external onlyOwner {
      landLevels[_tokenId] = level;
    }

    function landLevel(uint256 _tokenId) public view returns (uint256) {
        return landLevels[_tokenId];
    }

    function isLandIssued(uint256 _tokenId) public view returns (bool) {
        return landIssued[_tokenId];
    }

    function isLandFrozen(uint256 _tokenId) public view returns (bool) {
        return landFrozen[_tokenId];
    }

    function _beforeTokenTransfer(
        address _from,
        address _to,
        uint256 _tokenId
    ) internal override {
        super._beforeTokenTransfer(_from, _to, _tokenId);
        require(landFrozen[_tokenId] == false, "Land is still in use");
    }

    function tokenURI(uint256 _tokenId) public view override returns (string memory) { // set up api URL to return golden ticket metadata
        require(_exists(_tokenId), "URI query for nonexistent token");
        return bytes(baseURI).length > 0 ?
            string(abi.encodePacked(
                baseURI,
                _tokenId.toString()
            ))
            : "";
    }

    function _baseURI() internal view override returns (string memory) {
        return baseURI;
    }

    // ADMIN

    function setTrainingGround(address _trainingGround) external onlyOwner {
        trainingGround = TrainingGround(_trainingGround);
        emit TrainingGroundSet(_trainingGround);
    }

    function setShogun(address _shogun) external onlyOwner {
        shogun = Shogun(_shogun);
        emit ShogunSet(_shogun);
    }

    function setBaseURI(string memory _baseURItoSet) external onlyOwner {
        baseURI = _baseURItoSet;
    }

    function setMaxLevel(uint256 _landMaxLevel) external onlyOwner {
        landMaxLevel = _landMaxLevel;
        emit LandMaxLevel(_landMaxLevel);
    }
}


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


// OpenZeppelin Contracts v4.4.1 (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @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 `recipient`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address recipient, 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 `sender` to `recipient` 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 sender,
        address recipient,
        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 contracts/Staking/Staking.sol


pragma solidity 0.8.7;






contract Staking is Control {
    address public rewardToken;

    // reward rates
    uint256 public shogunDailyRewardRate;
    uint256 public landDailyRewardRate;

    // to-do make updatable
    uint256 public unstakeDuration;

    uint256 public totalShogunStaked;
    uint256 public totalLandStaked;

    uint256 public shogunUnstaking;

    // clans options + ronin
    string[] public clanOptions;

    Shogun public shogun;
    Land public land;
    TrainingGround public trainingGround;
    Classes public classes;
    Clans public clans;

    event ShogunSet(address shogun);
    event LandSet(address land);
    event ClassesSet(address classes);
    event ClansSet(address clans);
    event TrainingGroundSet(address trainingGround);

    event LandClanSet(uint256 token, string clan);

    event Stake(uint256 landId, uint256[] shogunIds);
    event StartUnstake(uint256 landId, uint256[] shogunIds);
    event Unstake(uint256 landId, uint256[] shogunIds);

    // tracking if a shogun is staked and what land it's staked to
    mapping(uint256 => bool) public shogunStaked;
    mapping(uint256 => uint256) public shogunStakedToLand;

    // tracking what land is staked + the clan of the land
    // track how many shogun are on a specific piece of land
    mapping(uint256 => bool) public landStaked;
    mapping(uint256 => string) public landClan;
    mapping(uint256 => uint256) public shogunOnLand;

    // land earned rewards + last updated time
    mapping(uint256 => uint256) public landEarnedReward;
    mapping(uint256 => uint256) public landEarnedRewardLastUpdated;

    // unstake tracking
    mapping(uint256 => uint256) public timestampUnstaked;
    mapping(uint256 => uint256) public timestampFinished;


    // -----------------------------------
    // ----Reward calculator functions----
    // -----------------------------------

    function addRewards(uint256 landId, uint256[] memory shogunIds) internal {
      // update currening earnings before adding shogun
      updateEarned(landId);

      // add the new shoguns on the land
      shogunOnLand[landId] += shogunIds.length;
    }

    function removeRewards(uint256 landId, uint256[] memory shogunIds) internal {
      // update currening earnings before adding shogun
      updateEarned(landId);

      // remove the shoguns on the land
      shogunOnLand[landId] -= shogunIds.length;
    }

    function updateEarned(uint256 landId) internal {
      if (landEarnedRewardLastUpdated[landId] == 0) {
        landEarnedRewardLastUpdated[landId] = block.timestamp;
      } else {
        // time staked since last earninings update
        uint256 timeStakedSeconds = block.timestamp - landEarnedRewardLastUpdated[landId];

        // calculate daily rewards
        uint256 shogunRewards = shogunOnLand[landId] * shogunDailyRewardRate;

        // PREVENT LAND FROM MAKING REWARDS WHEN SHOGUNONLAND == 0
        uint256 landRewards;

        if (shogunOnLand[landId] > 0) {
          landRewards = land.landLevel(landId) * landDailyRewardRate;
        } else {
          landRewards = 0;
        }

        uint256 dailyReward = shogunRewards + landRewards;

        // calculate rewards for time period
        uint256 unfriendlyNumber = dailyReward * 1e18;
        uint256 landRewardPerSecond = (unfriendlyNumber / 86400);
        uint256 newRewards = timeStakedSeconds * landRewardPerSecond;
        landEarnedRewardLastUpdated[landId] = block.timestamp;
        landEarnedReward[landId] = landEarnedReward[landId] + newRewards;
      }
    }

    // -----------------------------------
    // ----------Util functions----------
    // -----------------------------------

    function testStr(string memory str) public pure returns (bool) {
      bytes memory b = bytes(str);
      if (b.length <= 2) return true;
      return false;
    }

    function compareStrings(string memory a, string memory b) public pure returns (bool) {
      return (keccak256(abi.encodePacked((a))) == keccak256(abi.encodePacked((b))));
    }

    // -----------------------------------
    // ----------User functions----------
    // -----------------------------------

    function stake(uint256 landId, uint256[] memory shogunIds) external {
        require(land.ownerOf(landId) == msg.sender, "You do not own this Land");
        require(landStaked[landId], "Select a clan for the land before staking shogun");
        require(shogunIds.length > 0, "Must provide at least one Shogun Id");
        require(shogun.balanceOf(msg.sender) > 0, "Wallet address does not hold a Shogun");

        for(uint256 i = 0; i < shogunIds.length; i++) {
          // check if owned
          require(shogun.ownerOf(shogunIds[i]) == msg.sender, "You do not own one of the shoguns");

          // check if already staked
          require(!shogunStaked[shogunIds[i]], "One of the shoguns is already staked");

          // check if trained
          require(trainingGround.isTrained(shogunIds[i]), "One of the shoguns need to be trained before it can be staked");

          // check if they have a class
          require(!testStr(classes.checkShogunClass(shogunIds[i])), "One of the shoguns needs to join a class before it can be staked");

          // check if they have a clan and if it matches the land's clan
          if (testStr(clans.checkShogunClan(shogunIds[i]))) {
            require(compareStrings(landClan[landId], clanOptions[2]), "One of the shoguns is not in the same clan as the land");
          } else {
            require(compareStrings(clans.checkShogunClan(shogunIds[i]), landClan[landId]), "One of the shoguns is not in the same clan as the land");
          }

          // freezeeee
          shogun.freezeTransfer(shogunIds[i]);

          // set shogunId staked
          shogunStaked[shogunIds[i]] = true;

          // set shogunId as assigned to landId
          shogunStakedToLand[shogunIds[i]] = landId;

          // increase total staked counter
          totalShogunStaked++;
        }
        addRewards(landId, shogunIds);
        emit Stake(landId, shogunIds);
    }

    function totalUnstaking() public view returns (uint256) {
        return shogunUnstaking;
    }

    // shogun Id
    function unstakingFinishedDate(uint256 _tokenId) public view returns (uint256) {
        return timestampFinished[_tokenId];
    }

    // shogun Id
    function isUnstaked(uint256 _tokenId) public view returns (bool) {
        return timestampUnstaked[_tokenId] > 0;
    }

    function startUnstake(uint256 landId, uint256[] memory shogunIds) external {
        // check if land is already frozen
        // if not then freeze and increase counter
        require(land.ownerOf(landId) == msg.sender, "You do not own this Land");
        require(landStaked[landId], "This land is not staked");
        require(shogunIds.length > 0, "Must provide at least one Shogun Id");
        require(shogun.balanceOf(msg.sender) > 0, "Wallet address does not hold a Shogun");

        for(uint256 i = 0; i < shogunIds.length; i++) {
          require(shogun.ownerOf(shogunIds[i]) == msg.sender, "You do not own one of the shoguns");
          require(shogunStaked[shogunIds[i]], "One of the shoguns is not staked");
          require(isUnstaked(shogunIds[i]) == false, "Already unstaking");
          shogunUnstaking++;
          timestampUnstaked[shogunIds[i]] = block.timestamp;
          timestampFinished[shogunIds[i]] = block.timestamp + unstakeDuration;
        }
        removeRewards(landId, shogunIds);
        emit StartUnstake(landId, shogunIds);
    }

    function unstake(uint256 landId, uint256[] memory shogunIds) external {
        // check if land is already frozen
        // if not then freeze and increase counter
        require(land.ownerOf(landId) == msg.sender, "You do not own this Land");
        require(landStaked[landId], "This land is not staked");
        require(shogunIds.length > 0, "Must provide at least one Shogun Id");
        require(shogun.balanceOf(msg.sender) > 0, "Wallet address does not hold a Shogun");

        for(uint256 i = 0; i < shogunIds.length; i++) {
          require(shogun.ownerOf(shogunIds[i]) == msg.sender, "You do not own one of the shoguns");
          require(shogunStaked[shogunIds[i]], "One of the shoguns is not staked");

          require(isUnstaked(shogunIds[i]) == true, "Not unstaking");

          require(block.timestamp > timestampFinished[shogunIds[i]], "Your Shogun is not ready to be unstaked yet.");

          shogun.unfreezeTransfer(shogunIds[i]);
          shogunStaked[shogunIds[i]] = false;
          shogunStakedToLand[shogunIds[i]] = 0;
          totalShogunStaked--;
          timestampUnstaked[shogunIds[i]] = 0;
          shogunUnstaking--;
        }
        emit Unstake(landId, shogunIds);
    }

    function setLandClan(uint256 tokenId, uint256 clanId) external {
      require(!landStaked[tokenId], "Land already has clan");
      require(clanId < clanOptions.length, "Invalid clan ID");
      require(land.ownerOf(tokenId) == msg.sender, "You do not own this Land");
      land.freezeTransfer(tokenId);
      totalLandStaked++;
      landStaked[tokenId] = true;
      landClan[tokenId] = clanOptions[clanId];
      emit LandClanSet(tokenId, clanOptions[clanId]);
    }

    function unsetLandClan(uint256 tokenId) external {
      require(landStaked[tokenId], "Land has no clan");
      require(land.ownerOf(tokenId) == msg.sender, "You do not own this Land");
      require(shogunOnLand[tokenId] == 0, "Cannot remove clan from land while shogun are still staked");
      land.unfreezeTransfer(tokenId);
      totalLandStaked--;
      landStaked[tokenId] = false;
      landClan[tokenId] = "na";
      emit LandClanSet(tokenId, "na");
    }

    // -----------------------------------
    // ----------Reward functions---------
    // -----------------------------------

    function claimReward(uint256 landId) external  {
        require(land.ownerOf(landId) == msg.sender, "You do not own this Land");
        updateEarned(landId);
        uint256 rewardAmt = landEarnedReward[landId];
        landEarnedReward[landId] = 0;
        IERC20(rewardToken).transfer(msg.sender, rewardAmt);
    }

    function getLandDailyReward(uint256 landId) public view returns (uint256 dailyRewards) {
      // calculate daily rewards
      uint256 shogunRewards = shogunOnLand[landId] * shogunDailyRewardRate;

      // PREVENT LAND FROM MAKING REWARDS WHEN SHOGUNONLAND == 0
      uint256 landRewards;

      if (shogunOnLand[landId] > 0) {
        landRewards = land.landLevel(landId) * landDailyRewardRate;
      } else {
        landRewards = 0;
      }

      uint256 dailyReward = shogunRewards + landRewards;

      return dailyReward;
    }

    function getCurrentConfirmedRewards(uint256 landId) public view returns (uint256 reward) {
      return landEarnedReward[landId];
    }

    function getCurrentConfirmedRewardsLastUpdated(uint256 landId) public view returns (uint256 lastUpdated) {
      return landEarnedRewardLastUpdated[landId];
    }


    // -----------------------------------
    // ----------Admin functions----------
    // -----------------------------------

    // admin control
    function forceUnstake(uint256 landId, uint256[] memory shogunIds) external onlyOwner {
      for(uint256 i = 0; i < shogunIds.length; i++) {
        shogun.unfreezeTransfer(shogunIds[i]);
        shogunStaked[shogunIds[i]] = false;
        shogunStakedToLand[shogunIds[i]] = 0;
        totalShogunStaked--;
        timestampUnstaked[shogunIds[i]] = 0;
        shogunUnstaking--;
      }
      emit Unstake(landId, shogunIds);
    }

    // configs
    function setClanOptions(string[] memory _clanOptions) external onlyOwner {
        clanOptions = _clanOptions;
    }

    function setRewardToken(address tokenAddress) external onlyOwner {
        rewardToken = tokenAddress;
    }

    function setUnstakeDuration(uint256 duration) external onlyOwner {
        unstakeDuration = duration;
    }

    function setShogunDailyRewardRate(uint256 shogunDailyReward) external onlyOwner {
        shogunDailyRewardRate = shogunDailyReward;
    }

    function setLandDailyRewardRate(uint256 landDailyReward) external onlyOwner {
        landDailyRewardRate = landDailyReward;
    }

    // external contracts
    function setShogun(address _shogun) external onlyOwner {
        shogun = Shogun(_shogun);
        emit ShogunSet(_shogun);
    }

    function setLand(address _land) external onlyOwner {
        land = Land(_land);
        emit LandSet(_land);
    }

    function setTrainingGround(address _trainingGround) external onlyOwner {
        trainingGround = TrainingGround(_trainingGround);
        emit TrainingGroundSet(_trainingGround);
    }

    function setClasses(address _classes) external onlyOwner {
        classes = Classes(_classes);
        emit ClassesSet(_classes);
    }

    function setClans(address _clans) external onlyOwner {
        clans = Clans(_clans);
        emit ClansSet(_clans);
    }
}

[{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"clans","type":"address"}],"name":"ClansSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"classes","type":"address"}],"name":"ClassesSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"token","type":"uint256"},{"indexed":false,"internalType":"string","name":"clan","type":"string"}],"name":"LandClanSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"land","type":"address"}],"name":"LandSet","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":false,"internalType":"address","name":"shogun","type":"address"}],"name":"ShogunSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"landId","type":"uint256"},{"indexed":false,"internalType":"uint256[]","name":"shogunIds","type":"uint256[]"}],"name":"Stake","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"landId","type":"uint256"},{"indexed":false,"internalType":"uint256[]","name":"shogunIds","type":"uint256[]"}],"name":"StartUnstake","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"trainingGround","type":"address"}],"name":"TrainingGroundSet","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"landId","type":"uint256"},{"indexed":false,"internalType":"uint256[]","name":"shogunIds","type":"uint256[]"}],"name":"Unstake","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"SHOGUN_OWNER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"landId","type":"uint256"}],"name":"claimReward","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"clanOptions","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"clans","outputs":[{"internalType":"contract Clans","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"classes","outputs":[{"internalType":"contract Classes","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string","name":"a","type":"string"},{"internalType":"string","name":"b","type":"string"}],"name":"compareStrings","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"landId","type":"uint256"},{"internalType":"uint256[]","name":"shogunIds","type":"uint256[]"}],"name":"forceUnstake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"landId","type":"uint256"}],"name":"getCurrentConfirmedRewards","outputs":[{"internalType":"uint256","name":"reward","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"landId","type":"uint256"}],"name":"getCurrentConfirmedRewardsLastUpdated","outputs":[{"internalType":"uint256","name":"lastUpdated","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"landId","type":"uint256"}],"name":"getLandDailyReward","outputs":[{"internalType":"uint256","name":"dailyRewards","type":"uint256"}],"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":"address","name":"_owner","type":"address"}],"name":"grantOwner","outputs":[],"stateMutability":"nonpayable","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"}],"name":"isOwner","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"isUnstaked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"land","outputs":[{"internalType":"contract Land","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"landClan","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"landDailyRewardRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"landEarnedReward","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"landEarnedRewardLastUpdated","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"landStaked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"rewardToken","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"string[]","name":"_clanOptions","type":"string[]"}],"name":"setClanOptions","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_clans","type":"address"}],"name":"setClans","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_classes","type":"address"}],"name":"setClasses","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_land","type":"address"}],"name":"setLand","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"clanId","type":"uint256"}],"name":"setLandClan","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"landDailyReward","type":"uint256"}],"name":"setLandDailyRewardRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"tokenAddress","type":"address"}],"name":"setRewardToken","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_shogun","type":"address"}],"name":"setShogun","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"shogunDailyReward","type":"uint256"}],"name":"setShogunDailyRewardRate","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_trainingGround","type":"address"}],"name":"setTrainingGround","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"duration","type":"uint256"}],"name":"setUnstakeDuration","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"shogun","outputs":[{"internalType":"contract Shogun","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"shogunDailyRewardRate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"shogunOnLand","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"shogunStaked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"shogunStakedToLand","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"shogunUnstaking","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"landId","type":"uint256"},{"internalType":"uint256[]","name":"shogunIds","type":"uint256[]"}],"name":"stake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"landId","type":"uint256"},{"internalType":"uint256[]","name":"shogunIds","type":"uint256[]"}],"name":"startUnstake","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":[{"internalType":"string","name":"str","type":"string"}],"name":"testStr","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"timestampFinished","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"timestampUnstaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalLandStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalShogunStaked","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalUnstaking","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"trainingGround","outputs":[{"internalType":"contract TrainingGround","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"unsetLandClan","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"landId","type":"uint256"},{"internalType":"uint256[]","name":"shogunIds","type":"uint256[]"}],"name":"unstake","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"unstakeDuration","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"unstakingFinishedDate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"}]

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

77304:13354:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;10717:204;;;;;;:::i;:::-;;:::i;:::-;;;8015:14:1;;8008:22;7990:41;;7978:2;7963:18;10717:204:0;;;;;;;;88304:137;;;;;;:::i;:::-;88377:14;88409:24;;;:16;:24;;;;;;;88304:137;;;;8188:25:1;;;8176:2;8161:18;88304:137:0;8042:177:1;83547:97:0;83621:15;;83547:97;;78820:51;;;;;;:::i;:::-;;;;;;;;;;;;;;81579:1960;;;;;;:::i;:::-;;:::i;:::-;;77549:32;;;;;;12128:123;;;;;;:::i;:::-;12194:7;12221:12;;;;;;;;;;:22;;;;12128:123;78383:44;;;;;;:::i;:::-;;;;;;;;;;;;;;;;12513:147;;;;;;:::i;:::-;;:::i;16292:120::-;;;;;;:::i;:::-;;:::i;77825:22::-;;;;;-1:-1:-1;;;;;77825:22:0;;;;;;;;;;:::i;78434:53::-;;;;;;:::i;:::-;;;;;;;;;;;;;;13561:218;;;;;;:::i;:::-;;:::i;85057:1242::-;;;;;;:::i;:::-;;:::i;77854:18::-;;;;;-1:-1:-1;;;;;77854:18:0;;;15804:74;;-1:-1:-1;;;;;;;;;;;15804:74:0;;79033:52;;;;;;:::i;:::-;;;;;;;;;;;;;;81084:167;;;;;;:::i;:::-;;:::i;77438:34::-;;;;;;87744:552;;;;;;:::i;:::-;;:::i;89754:132::-;;;;;;:::i;:::-;;:::i;78716:47::-;;;;;;:::i;:::-;;;;;;;;;;;;;;77732:20;;;;;-1:-1:-1;;;;;77732:20:0;;;78974:52;;;;;;:::i;:::-;;;;;;;;;;;;;;89606:140;;;;;;:::i;:::-;;:::i;88449:164::-;;;;;;:::i;:::-;88533:19;88570:35;;;:27;:35;;;;;;;88449:164;89244:118;;;;;;:::i;:::-;;:::i;78667:42::-;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;77588:30::-;;;;;;90061:118;;;;;;:::i;:::-;;:::i;90187:188::-;;;;;;:::i;:::-;;:::i;78878:62::-;;;;;;:::i;:::-;;;;;;;;;;;;;;89370:110;;;;;;:::i;:::-;;:::i;77759:16::-;;;;;-1:-1:-1;;;;;77759:16:0;;;11013:139;;;;;;:::i;:::-;;:::i;77696:27::-;;;;;;:::i;:::-;;:::i;77627:30::-;;;;;;10104:49;;10149:4;10104:49;;77782:36;;;;;-1:-1:-1;;;;;77782:36:0;;;86307:480;;;;;;:::i;:::-;;:::i;87412:324::-;;;;;;:::i;:::-;;:::i;86795:475::-;;;;;;:::i;:::-;;:::i;89488:110::-;;;;;;:::i;:::-;;:::i;90383:139::-;;;;;;:::i;:::-;;:::i;81259:179::-;;;;;;:::i;:::-;;:::i;78618:42::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;77510:30;;;;;;83670:132;;;;;;:::i;:::-;83740:7;83767:27;;;:17;:27;;;;;;;83670:132;83958:1091;;;;;;:::i;:::-;;:::i;12905:149::-;;;;;;:::i;:::-;;:::i;88779:441::-;;;;;;:::i;:::-;;:::i;16184:100::-;;;;;;:::i;:::-;;:::i;77395:36::-;;;;;;83828:122;;;;;;:::i;:::-;83887:4;83911:27;;;:17;:27;;;;;;:31;;;83828:122;90530:125;;;;;;:::i;:::-;;:::i;89921:132::-;;;;;;:::i;:::-;;:::i;77339:26::-;;;;;-1:-1:-1;;;;;77339:26:0;;;10717:204;10802:4;-1:-1:-1;;;;;;10826:47:0;;-1:-1:-1;;;10826:47:0;;:87;;-1:-1:-1;;;;;;;;;;8080:40:0;;;10877:36;10819:94;10717:204;-1:-1:-1;;10717:204:0:o;81579:1960::-;81666:4;;:20;;-1:-1:-1;;;81666:20:0;;;;;8188:25:1;;;81690:10:0;;-1:-1:-1;;;;;81666:4:0;;:12;;8161:18:1;;81666:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;81666:34:0;;81658:71;;;;-1:-1:-1;;;81658:71:0;;;;;;;:::i;:::-;;;;;;;;;81748:18;;;;:10;:18;;;;;;;;81740:79;;;;-1:-1:-1;;;81740:79:0;;14124:2:1;81740:79:0;;;14106:21:1;14163:2;14143:18;;;14136:30;14202:34;14182:18;;;14175:62;-1:-1:-1;;;14253:18:1;;;14246:46;14309:19;;81740:79:0;13922:412:1;81740:79:0;81857:1;81838:9;:16;:20;81830:68;;;;-1:-1:-1;;;81830:68:0;;;;;;;:::i;:::-;81917:6;;:28;;-1:-1:-1;;;81917:28:0;;81948:1;;-1:-1:-1;;;;;81917:6:0;;:16;;:28;;81934:10;;81917:28;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:32;81909:82;;;;-1:-1:-1;;;81909:82:0;;;;;;;:::i;:::-;82008:9;82004:1448;82027:9;:16;82023:1;:20;82004:1448;;;82100:6;;82115:12;;82132:10;;-1:-1:-1;;;;;82100:6:0;;:14;;82115:9;;82125:1;;82115:12;;;;;;:::i;:::-;;;;;;;82100:28;;;;;;;;;;;;;8188:25:1;;8176:2;8161:18;;8042:177;82100:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;82100:42:0;;82092:88;;;;-1:-1:-1;;;82092:88:0;;;;;;;:::i;:::-;82242:12;:26;82255:9;82265:1;82255:12;;;;;;;;:::i;:::-;;;;;;;;;;;;82242:26;;;;;;;;;;-1:-1:-1;82242:26:0;;;;82241:27;82233:76;;;;-1:-1:-1;;;82233:76:0;;14971:2:1;82233:76:0;;;14953:21:1;15010:2;14990:18;;;14983:30;15049:34;15029:18;;;15022:62;-1:-1:-1;;;15100:18:1;;;15093:34;15144:19;;82233:76:0;14769:400:1;82233:76:0;82363:14;;82388:12;;-1:-1:-1;;;;;82363:14:0;;;;:24;;82388:9;;82398:1;;82388:12;;;;;;:::i;:::-;;;;;;;82363:38;;;;;;;;;;;;;8188:25:1;;8176:2;8161:18;;8042:177;82363:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;82355:112;;;;-1:-1:-1;;;82355:112:0;;14541:2:1;82355:112:0;;;14523:21:1;14580:2;14560:18;;;14553:30;14619:34;14599:18;;;14592:62;14690:31;14670:18;;;14663:59;14739:19;;82355:112:0;14339:425:1;82355:112:0;82540:7;;82565:12;;82532:47;;-1:-1:-1;;;;;82540:7:0;;:24;;82565:9;;82575:1;;82565:12;;;;;;:::i;:::-;;;;;;;82540:38;;;;;;;;;;;;;8188:25:1;;8176:2;8161:18;;8042:177;82540:38:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;82540:38:0;;;;;;;;;;;;:::i;82532:47::-;82531:48;82523:125;;;;;-1:-1:-1;;;82523:125:0;;13339:2:1;82523:125:0;;;13321:21:1;13358:18;;;13351:30;;;;13417:34;13397:18;;;13390:62;13488:34;13468:18;;;13461:62;13540:19;;82523:125:0;13137:428:1;82523:125:0;82749:5;;82771:12;;82741:44;;-1:-1:-1;;;;;82749:5:0;;:21;;82771:9;;82781:1;;82771:12;;;;;;:::i;82741:44::-;82737:365;;;82825:16;;;;:8;:16;;;;;82810:48;;;;82825:16;82810:48;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;82843:11;82855:1;82843:14;;;;;;;;:::i;:::-;;;;;;;;82810:48;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:14;:48::i;:::-;82802:115;;;;-1:-1:-1;;;82802:115:0;;;;;;;:::i;:::-;82737:365;;;82975:5;;82997:12;;82960:69;;-1:-1:-1;;;;;82975:5:0;;:21;;82997:9;;83007:1;;82997:12;;;;;;:::i;:::-;;;;;;;82975:35;;;;;;;;;;;;;8188:25:1;;8176:2;8161:18;;8042:177;82975:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;82975:35:0;;;;;;;;;;;;:::i;:::-;83012:16;;;;:8;:16;;;;;82960:69;;;;;:::i;:::-;82952:136;;;;-1:-1:-1;;;82952:136:0;;;;;;;:::i;:::-;83140:6;;83162:12;;-1:-1:-1;;;;;83140:6:0;;;;:21;;83162:9;;83172:1;;83162:12;;;;;;:::i;:::-;;;;;;;83140:35;;;;;;;;;;;;;8188:25:1;;8176:2;8161:18;;8042:177;83140:35:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;83253:4;83224:12;:26;83237:9;83247:1;83237:12;;;;;;;;:::i;:::-;;;;;;;83224:26;;;;;;;;;;;;:33;;;;;;;;;;;;;;;;;;83356:6;83321:18;:32;83340:9;83350:1;83340:12;;;;;;;;:::i;:::-;;;;;;;83321:32;;;;;;;;;;;:41;;;;83421:17;;:19;;;;;;;;;:::i;:::-;;;;;;82045:3;;;;;:::i;:::-;;;;82004:1448;;;;83462:29;83473:6;83481:9;83462:10;:29::i;:::-;83507:24;83513:6;83521:9;83507:24;;;;;;;:::i;:::-;;;;;;;;81579:1960;;:::o;12513:147::-;12194:7;12221:12;;;;;;;;;;:22;;;10595:30;10606:4;3909:10;10595;:30::i;:::-;12627:25:::1;12638:4;12644:7;12627:10;:25::i;:::-;12513:147:::0;;;:::o;16292:120::-;16346:4;16370:34;-1:-1:-1;;;;;;;;;;;16397:6:0;16370:7;:34::i;13561:218::-;-1:-1:-1;;;;;13657:23:0;;3909:10;13657:23;13649:83;;;;-1:-1:-1;;;13649:83:0;;16829:2:1;13649:83:0;;;16811:21:1;16868:2;16848:18;;;16841:30;16907:34;16887:18;;;16880:62;-1:-1:-1;;;16958:18:1;;;16951:45;17013:19;;13649:83:0;16627:411:1;13649:83:0;13745:26;13757:4;13763:7;13745:11;:26::i;:::-;13561:218;;:::o;85057:1242::-;85242:4;;:20;;-1:-1:-1;;;85242:20:0;;;;;8188:25:1;;;85266:10:0;;-1:-1:-1;;;;;85242:4:0;;:12;;8161:18:1;;85242:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;85242:34:0;;85234:71;;;;-1:-1:-1;;;85234:71:0;;;;;;;:::i;:::-;85324:18;;;;:10;:18;;;;;;;;85316:54;;;;-1:-1:-1;;;85316:54:0;;;;;;;:::i;:::-;85408:1;85389:9;:16;:20;85381:68;;;;-1:-1:-1;;;85381:68:0;;;;;;;:::i;:::-;85468:6;;:28;;-1:-1:-1;;;85468:28:0;;85499:1;;-1:-1:-1;;;;;85468:6:0;;:16;;:28;;85485:10;;85468:28;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:32;85460:82;;;;-1:-1:-1;;;85460:82:0;;;;;;;:::i;:::-;85559:9;85555:695;85578:9;:16;85574:1;:20;85555:695;;;85622:6;;85637:12;;85654:10;;-1:-1:-1;;;;;85622:6:0;;:14;;85637:9;;85647:1;;85637:12;;;;;;:::i;:::-;;;;;;;85622:28;;;;;;;;;;;;;8188:25:1;;8176:2;8161:18;;8042:177;85622:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;85622:42:0;;85614:88;;;;-1:-1:-1;;;85614:88:0;;;;;;;:::i;:::-;85723:12;:26;85736:9;85746:1;85736:12;;;;;;;;:::i;:::-;;;;;;;;;;;;85723:26;;;;;;;;;;-1:-1:-1;85723:26:0;;;;85715:71;;;;-1:-1:-1;;;85715:71:0;;;;;;;:::i;:::-;85809:24;85820:9;85830:1;85820:12;;;;;;;;:::i;:::-;;;;;;;83887:4;83911:27;;;:17;:27;;;;;;:31;;;83828:122;85809:24;:32;;85837:4;85809:32;85801:58;;;;-1:-1:-1;;;85801:58:0;;15376:2:1;85801:58:0;;;15358:21:1;15415:2;15395:18;;;15388:30;-1:-1:-1;;;15434:18:1;;;15427:43;15487:18;;85801:58:0;15174:337:1;85801:58:0;85900:17;:31;85918:9;85928:1;85918:12;;;;;;;;:::i;:::-;;;;;;;85900:31;;;;;;;;;;;;85882:15;:49;85874:106;;;;-1:-1:-1;;;85874:106:0;;12519:2:1;85874:106:0;;;12501:21:1;12558:2;12538:18;;;12531:30;12597:34;12577:18;;;12570:62;-1:-1:-1;;;12648:18:1;;;12641:42;12700:19;;85874:106:0;12317:408:1;85874:106:0;85995:6;;86019:12;;-1:-1:-1;;;;;85995:6:0;;;;:23;;86019:9;;86029:1;;86019:12;;;;;;:::i;:::-;;;;;;;85995:37;;;;;;;;;;;;;8188:25:1;;8176:2;8161:18;;8042:177;85995:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;86074:5;86045:12;:26;86058:9;86068:1;86058:12;;;;;;;;:::i;:::-;;;;;;;86045:26;;;;;;;;;;;;:34;;;;;;;;;;;;;;;;;;86127:1;86092:18;:32;86111:9;86121:1;86111:12;;;;;;;;:::i;:::-;;;;;;;86092:32;;;;;;;;;;;:36;;;;86141:17;;:19;;;;;;;;;:::i;:::-;;;;;;86207:1;86173:17;:31;86191:9;86201:1;86191:12;;;;;;;;:::i;:::-;;;;;;;86173:31;;;;;;;;;;;:35;;;;86221:15;;:17;;;;;;;;;:::i;:::-;;;;;;85596:3;;;;;:::i;:::-;;;;85555:695;;;;86265:26;86273:6;86281:9;86265:26;;;;;;;:::i;81084:167::-;81141:4;81156:14;81179:3;81156:27;;81208:1;81196;:8;:13;81192:30;;-1:-1:-1;81218:4:0;;81084:167;-1:-1:-1;;81084:167:0:o;81192:30::-;-1:-1:-1;81238:5:0;;81084:167;-1:-1:-1;;81084:167:0:o;87744:552::-;87921:21;;87809:20;87898;;;:12;:20;;;;;;87809;;;;87898:44;;87921:21;87898:44;:::i;:::-;88019:19;88053:20;;;:12;:20;;;;;;87874:68;;-1:-1:-1;88019:19:0;88053:24;88049:151;;88129:19;;88104:4;;:22;;-1:-1:-1;;;88104:22:0;;;;;8188:25:1;;;-1:-1:-1;;;;;88104:4:0;;;;:14;;8161:18:1;;88104:22:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;;;;:::i;:::-;88090:58;;88049:151;;;-1:-1:-1;88189:1:0;88049:151;88210:19;88232:27;88248:11;88232:13;:27;:::i;:::-;88210:49;87744:552;-1:-1:-1;;;;;87744:552:0:o;89754:132::-;15927:40;-1:-1:-1;;;;;;;;;;;3909:10:0;11013:139;:::i;15927:40::-;15919:91;;;;-1:-1:-1;;;15919:91:0;;;;;;;:::i;:::-;89841:19:::1;:37:::0;89754:132::o;89606:140::-;15927:40;-1:-1:-1;;;;;;;;;;;3909:10:0;11013:139;:::i;15927:40::-;15919:91;;;;-1:-1:-1;;;15919:91:0;;;;;;;:::i;:::-;89697:21:::1;:41:::0;89606:140::o;89244:118::-;15927:40;-1:-1:-1;;;;;;;;;;;3909:10:0;11013:139;:::i;15927:40::-;15919:91;;;;-1:-1:-1;;;15919:91:0;;;;;;;:::i;:::-;89328:26;;::::1;::::0;:11:::1;::::0;:26:::1;::::0;::::1;::::0;::::1;:::i;78667:42::-:0;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;90061:118::-;15927:40;-1:-1:-1;;;;;;;;;;;3909:10:0;11013:139;:::i;15927:40::-;15919:91;;;;-1:-1:-1;;;15919:91:0;;;;;;;:::i;:::-;90123:4:::1;:18:::0;;-1:-1:-1;;;;;;90123:18:0::1;-1:-1:-1::0;;;;;90123:18:0;::::1;;::::0;;90157:14:::1;::::0;::::1;::::0;::::1;::::0;90123:18;;90157:14:::1;:::i;:::-;;;;;;;;90061:118:::0;:::o;90187:188::-;15927:40;-1:-1:-1;;;;;;;;;;;3909:10:0;11013:139;:::i;15927:40::-;15919:91;;;;-1:-1:-1;;;15919:91:0;;;;;;;:::i;:::-;90269:14:::1;:48:::0;;-1:-1:-1;;;;;;90269:48:0::1;-1:-1:-1::0;;;;;90269:48:0;::::1;;::::0;;90333:34:::1;::::0;::::1;::::0;::::1;::::0;90269:48;;90333:34:::1;:::i;89370:110::-:0;15927:40;-1:-1:-1;;;;;;;;;;;3909:10:0;11013:139;:::i;15927:40::-;15919:91;;;;-1:-1:-1;;;15919:91:0;;;;;;;:::i;:::-;89446:11:::1;:26:::0;;-1:-1:-1;;;;;;89446:26:0::1;-1:-1:-1::0;;;;;89446:26:0;;;::::1;::::0;;;::::1;::::0;;89370:110::o;11013:139::-;11091:4;11115:12;;;;;;;;;;;-1:-1:-1;;;;;11115:29:0;;;;;;;;;;;;;;;11013:139::o;77696:27::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;86307:480::-;86388:19;;;;:10;:19;;;;;;;;86387:20;86379:54;;;;-1:-1:-1;;;86379:54:0;;11742:2:1;86379:54:0;;;11724:21:1;11781:2;11761:18;;;11754:30;-1:-1:-1;;;11800:18:1;;;11793:51;11861:18;;86379:54:0;11540:345:1;86379:54:0;86459:11;:18;86450:27;;86442:55;;;;-1:-1:-1;;;86442:55:0;;15718:2:1;86442:55:0;;;15700:21:1;15757:2;15737:18;;;15730:30;-1:-1:-1;;;15776:18:1;;;15769:45;15831:18;;86442:55:0;15516:339:1;86442:55:0;86514:4;;:21;;-1:-1:-1;;;86514:21:0;;;;;8188:25:1;;;86539:10:0;;-1:-1:-1;;;;;86514:4:0;;:12;;8161:18:1;;86514:21:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;86514:35:0;;86506:72;;;;-1:-1:-1;;;86506:72:0;;;;;;;:::i;:::-;86587:4;;:28;;-1:-1:-1;;;86587:28:0;;;;;8188:25:1;;;-1:-1:-1;;;;;86587:4:0;;;;:19;;8161:18:1;;86587:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;86624:15:0;:17;;;-1:-1:-1;86624:15:0;-1:-1:-1;86624:15:0;:17;;;:::i;:::-;;;;-1:-1:-1;;86650:19:0;;;;:10;:19;;;;;:26;;-1:-1:-1;;86650:26:0;86672:4;86650:26;;;86705:11;:19;;86717:6;;86705:19;;;;;;:::i;:::-;;;;;;;;;86685:17;;;:8;:17;;;;;;;86705:19;;86685:39;;;;;:::i;:::-;;;;;;:::i;:::-;;86738:41;86750:7;86759:11;86771:6;86759:19;;;;;;;;:::i;:::-;;;;;;;;86738:41;;;;;;;:::i;87412:324::-;87478:4;;:20;;-1:-1:-1;;;87478:20:0;;;;;8188:25:1;;;87502:10:0;;-1:-1:-1;;;;;87478:4:0;;:12;;8161:18:1;;87478:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;87478:34:0;;87470:71;;;;-1:-1:-1;;;87470:71:0;;;;;;;:::i;:::-;87552:20;87565:6;87552:12;:20::i;:::-;87583:17;87603:24;;;:16;:24;;;;;;;;87638:28;;;-1:-1:-1;87684:11:0;87677:51;;-1:-1:-1;;;87677:51:0;;87706:10;87677:51;;;7745::1;7812:18;;;7805:34;;;-1:-1:-1;;;;;87684:11:0;;;;87677:28;;7718:18:1;;87677:51:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;86795:475::-;86861:19;;;;:10;:19;;;;;;;;86853:48;;;;-1:-1:-1;;;86853:48:0;;11397:2:1;86853:48:0;;;11379:21:1;11436:2;11416:18;;;11409:30;-1:-1:-1;;;11455:18:1;;;11448:46;11511:18;;86853:48:0;11195:340:1;86853:48:0;86918:4;;:21;;-1:-1:-1;;;86918:21:0;;;;;8188:25:1;;;86943:10:0;;-1:-1:-1;;;;;86918:4:0;;:12;;8161:18:1;;86918:21:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;86918:35:0;;86910:72;;;;-1:-1:-1;;;86910:72:0;;;;;;;:::i;:::-;86999:21;;;;:12;:21;;;;;;:26;86991:97;;;;-1:-1:-1;;;86991:97:0;;12092:2:1;86991:97:0;;;12074:21:1;12131:2;12111:18;;;12104:30;12170:34;12150:18;;;12143:62;12241:28;12221:18;;;12214:56;12287:19;;86991:97:0;11890:422:1;86991:97:0;87097:4;;:30;;-1:-1:-1;;;87097:30:0;;;;;8188:25:1;;;-1:-1:-1;;;;;87097:4:0;;;;:21;;8161:18:1;;87097:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;87136:15:0;:17;;;-1:-1:-1;87136:15:0;-1:-1:-1;87136:15:0;:17;;;:::i;:::-;;;;-1:-1:-1;;87184:5:0;87162:19;;;:10;:19;;;;;;;;:27;;-1:-1:-1;;87162:27:0;;;87198:24;;;;;;;;;;-1:-1:-1;;;87198:24:0;;;;;;:17;;;:8;:17;;;;;:24;;;;:17;:24;;:::i;:::-;;87236:26;87248:7;87236:26;;;;20243:25:1;;20304:2;20299;20284:18;;20277:30;;;20343:1;20323:18;;;20316:29;-1:-1:-1;;;20376:2:1;20361:18;;20354:32;20418:3;20403:19;;20031:397;89488:110:0;15927:40;-1:-1:-1;;;;;;;;;;;3909:10:0;11013:139;:::i;15927:40::-;15919:91;;;;-1:-1:-1;;;15919:91:0;;;;;;;:::i;:::-;89564:15:::1;:26:::0;89488:110::o;90383:139::-;15927:40;-1:-1:-1;;;;;;;;;;;3909:10:0;11013:139;:::i;15927:40::-;15919:91;;;;-1:-1:-1;;;15919:91:0;;;;;;;:::i;:::-;90451:7:::1;:27:::0;;-1:-1:-1;;;;;;90451:27:0::1;-1:-1:-1::0;;;;;90451:27:0;::::1;;::::0;;90494:20:::1;::::0;::::1;::::0;::::1;::::0;90451:27;;90494:20:::1;:::i;81259:179::-:0;81338:4;81425:1;81407:21;;;;;;;;:::i;:::-;;;;;;;;;;;;;81397:32;;;;;;81389:1;81371:21;;;;;;;;:::i;:::-;;;;;;;;;;;;;81361:32;;;;;;:68;81353:77;;81259:179;;;;:::o;83958:1091::-;84148:4;;:20;;-1:-1:-1;;;84148:20:0;;;;;8188:25:1;;;84172:10:0;;-1:-1:-1;;;;;84148:4:0;;:12;;8161:18:1;;84148:20:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;84148:34:0;;84140:71;;;;-1:-1:-1;;;84140:71:0;;;;;;;:::i;:::-;84230:18;;;;:10;:18;;;;;;;;84222:54;;;;-1:-1:-1;;;84222:54:0;;;;;;;:::i;:::-;84314:1;84295:9;:16;:20;84287:68;;;;-1:-1:-1;;;84287:68:0;;;;;;;:::i;:::-;84374:6;;:28;;-1:-1:-1;;;84374:28:0;;84405:1;;-1:-1:-1;;;;;84374:6:0;;:16;;:28;;84391:10;;84374:28;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:32;84366:82;;;;-1:-1:-1;;;84366:82:0;;;;;;;:::i;:::-;84465:9;84461:491;84484:9;:16;84480:1;:20;84461:491;;;84528:6;;84543:12;;84560:10;;-1:-1:-1;;;;;84528:6:0;;:14;;84543:9;;84553:1;;84543:12;;;;;;:::i;:::-;;;;;;;84528:28;;;;;;;;;;;;;8188:25:1;;8176:2;8161:18;;8042:177;84528:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;84528:42:0;;84520:88;;;;-1:-1:-1;;;84520:88:0;;;;;;;:::i;:::-;84629:12;:26;84642:9;84652:1;84642:12;;;;;;;;:::i;:::-;;;;;;;;;;;;84629:26;;;;;;;;;;-1:-1:-1;84629:26:0;;;;84621:71;;;;-1:-1:-1;;;84621:71:0;;;;;;;:::i;:::-;84713:24;84724:9;84734:1;84724:12;;;;;;;;:::i;84713:24::-;:33;84705:63;;;;-1:-1:-1;;;84705:63:0;;10698:2:1;84705:63:0;;;10680:21:1;10737:2;10717:18;;;10710:30;-1:-1:-1;;;10756:18:1;;;10749:47;10813:18;;84705:63:0;10496:341:1;84705:63:0;84781:15;:17;;;:15;:17;;;:::i;:::-;;;;;;84845:15;84811:17;:31;84829:9;84839:1;84829:12;;;;;;;;:::i;:::-;;;;;;;84811:31;;;;;;;;;;;:49;;;;84925:15;;84907;:33;;;;:::i;:::-;84873:17;:31;84891:9;84901:1;84891:12;;;;;;;;:::i;:::-;;;;;;;84873:31;;;;;;;;;;;:67;;;;84502:3;;;;;:::i;:::-;;;;84461:491;;;;84962:32;84976:6;84984:9;84962:13;:32::i;:::-;85010:31;85023:6;85031:9;85010:31;;;;;;;:::i;12905:149::-;12194:7;12221:12;;;;;;;;;;:22;;;10595:30;10606:4;3909:10;10595;:30::i;:::-;13020:26:::1;13032:4;13038:7;13020:11;:26::i;88779:441::-:0;15927:40;-1:-1:-1;;;;;;;;;;;3909:10:0;11013:139;:::i;15927:40::-;15919:91;;;;-1:-1:-1;;;15919:91:0;;;;;;;:::i;:::-;88877:9:::1;88873:300;88896:9;:16;88892:1;:20;88873:300;;;88930:6;::::0;88954:12;;-1:-1:-1;;;;;88930:6:0;;::::1;::::0;:23:::1;::::0;88954:9;;88964:1;;88954:12;::::1;;;;;:::i;:::-;;;;;;;88930:37;;;;;;;;;;;;;8188:25:1::0;;8176:2;8161:18;;8042:177;88930:37:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;89007:5;88978:12;:26;88991:9;89001:1;88991:12;;;;;;;;:::i;:::-;;;;;;;88978:26;;;;;;;;;;;;:34;;;;;;;;;;;;;;;;;;89058:1;89023:18;:32;89042:9;89052:1;89042:12;;;;;;;;:::i;:::-;;;;;;;89023:32;;;;;;;;;;;:36;;;;89070:17;;:19;;;;;;;;;:::i;:::-;;;;;;89134:1;89100:17;:31;89118:9;89128:1;89118:12;;;;;;;;:::i;:::-;;;;;;;89100:31;;;;;;;;;;;:35;;;;89146:15;;:17;;;;;;;;;:::i;:::-;;;;;;88914:3;;;;;:::i;:::-;;;;88873:300;;16184:100:::0;16240:36;-1:-1:-1;;;;;;;;;;;16269:6:0;16240:9;:36::i;:::-;16184:100;:::o;90530:125::-;15927:40;-1:-1:-1;;;;;;;;;;;3909:10:0;11013:139;:::i;15927:40::-;15919:91;;;;-1:-1:-1;;;15919:91:0;;;;;;;:::i;:::-;90594:5:::1;:21:::0;;-1:-1:-1;;;;;;90594:21:0::1;-1:-1:-1::0;;;;;90594:21:0;::::1;;::::0;;90631:16:::1;::::0;::::1;::::0;::::1;::::0;90594:21;;90631:16:::1;:::i;89921:132::-:0;15927:40;-1:-1:-1;;;;;;;;;;;3909:10:0;11013:139;:::i;15927:40::-;15919:91;;;;-1:-1:-1;;;15919:91:0;;;;;;;:::i;:::-;89987:6:::1;:24:::0;;-1:-1:-1;;;;;;89987:24:0::1;-1:-1:-1::0;;;;;89987:24:0;::::1;;::::0;;90027:18:::1;::::0;::::1;::::0;::::1;::::0;89987:24;;90027:18:::1;:::i;79230:260::-:0;79369:20;79382:6;79369:12;:20::i;:::-;79466:16;;79442:20;;;;:12;:20;;;;;:40;;:20;;;:40;;79466:16;;79442:40;:::i;:::-;;;;-1:-1:-1;;;;79230:260:0:o;11442:497::-;11523:22;11531:4;11537:7;11523;:22::i;:::-;11518:414;;11711:41;11739:7;-1:-1:-1;;;;;11711:41:0;11749:2;11711:19;:41::i;:::-;11825:38;11853:4;11860:2;11825:19;:38::i;:::-;11616:270;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;11616:270:0;;;;;;;;;;-1:-1:-1;;;11562:358:0;;;;;;;:::i;15062:238::-;15146:22;15154:4;15160:7;15146;:22::i;:::-;15141:152;;15185:6;:12;;;;;;;;;;;-1:-1:-1;;;;;15185:29:0;;;;;;;;;:36;;-1:-1:-1;;15185:36:0;15217:4;15185:36;;;15268:12;3909:10;;3829:98;15268:12;-1:-1:-1;;;;;15241:40:0;15259:7;-1:-1:-1;;;;;15241:40:0;15253:4;15241:40;;;;;;;;;;15062:238;;:::o;15432:239::-;15516:22;15524:4;15530:7;15516;:22::i;:::-;15512:152;;;15587:5;15555:12;;;;;;;;;;;-1:-1:-1;;;;;15555:29:0;;;;;;;;;;:37;;-1:-1:-1;;15555:37:0;;;15612:40;3909:10;;15555:12;;15612:40;;15587:5;15612:40;15432:239;;:::o;79768:1175::-;79828:35;;;;:27;:35;;;;;;79824:1112;;79881:35;;;;:27;:35;;;;;79919:15;79881:53;;16184:100::o;79824:1112::-;80014:25;80060:35;;;:27;:35;;;;;;80042:53;;:15;:53;:::i;:::-;80191:21;;80144;80168:20;;;:12;:20;;;;;;80014:81;;-1:-1:-1;80144:21:0;80168:44;;80191:21;80168:44;:::i;:::-;80293:19;80329:20;;;:12;:20;;;;;;80144:68;;-1:-1:-1;80293:19:0;80329:24;80325:159;;80407:19;;80382:4;;:22;;-1:-1:-1;;;80382:22:0;;;;;8188:25:1;;;-1:-1:-1;;;;;80382:4:0;;;;:14;;8161:18:1;;80382:22:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:44;;;;:::i;:::-;80368:58;;80325:159;;;-1:-1:-1;80471:1:0;80325:159;80496:19;80518:27;80534:11;80518:13;:27;:::i;:::-;80496:49;-1:-1:-1;80604:24:0;80631:18;80496:49;80645:4;80631:18;:::i;:::-;80604:45;-1:-1:-1;80660:27:0;80691:24;80710:5;80604:45;80691:24;:::i;:::-;80660:56;-1:-1:-1;80727:18:0;80748:39;80660:56;80748:17;:39;:::i;:::-;80798:35;;;;:27;:35;;;;;;;;80836:15;80798:53;;80889:16;:24;;;;;;80727:60;;-1:-1:-1;80889:37:0;;80727:60;;80889:37;:::i;:::-;80862:24;;;;:16;:24;;;;;:64;-1:-1:-1;;;;;;;79768:1175:0;:::o;79498:262::-;79640:20;79653:6;79640:12;:20::i;:::-;79736:16;;79712:20;;;;:12;:20;;;;;:40;;:20;;;:40;;79736:16;;79712:40;:::i;5717:451::-;5792:13;5818:19;5850:10;5854:6;5850:1;:10;:::i;:::-;:14;;5863:1;5850:14;:::i;:::-;-1:-1:-1;;;;;5840:25:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;5840:25:0;;5818:47;;-1:-1:-1;;;5876:6:0;5883:1;5876:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;5876:15:0;;;;;;;;;-1:-1:-1;;;5902:6:0;5909:1;5902:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;5902:15:0;;;;;;;;-1:-1:-1;5933:9:0;5945:10;5949:6;5945:1;:10;:::i;:::-;:14;;5958:1;5945:14;:::i;:::-;5933:26;;5928:135;5965:1;5961;:5;5928:135;;;-1:-1:-1;;;6013:5:0;6021:3;6013:11;6000:25;;;;;;;:::i;:::-;;;;5988:6;5995:1;5988:9;;;;;;;;:::i;:::-;;;;:37;-1:-1:-1;;;;;5988:37:0;;;;;;;;-1:-1:-1;6050:1:0;6040:11;;;;;5968:3;;;:::i;:::-;;;5928:135;;;-1:-1:-1;6081:10:0;;6073:55;;;;-1:-1:-1;;;6073:55:0;;9933:2:1;6073:55:0;;;9915:21:1;;;9952:18;;;9945:30;10011:34;9991:18;;;9984:62;10063:18;;6073:55:0;9731:356:1;6073:55:0;6153:6;5717:451;-1:-1:-1;;;5717:451:0:o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;:::i;14:464:1:-;57:5;110:3;103:4;95:6;91:17;87:27;77:55;;128:1;125;118:12;77:55;164:6;151:20;195:49;211:32;240:2;211:32;:::i;:::-;195:49;:::i;:::-;269:2;260:7;253:19;315:3;308:4;303:2;295:6;291:15;287:26;284:35;281:55;;;332:1;329;322:12;281:55;397:2;390:4;382:6;378:17;371:4;362:7;358:18;345:55;445:1;420:16;;;438:4;416:27;409:38;;;;424:7;14:464;-1:-1:-1;;;14:464:1:o;483:247::-;542:6;595:2;583:9;574:7;570:23;566:32;563:52;;;611:1;608;601:12;563:52;650:9;637:23;669:31;694:5;669:31;:::i;735:251::-;805:6;858:2;846:9;837:7;833:23;829:32;826:52;;;874:1;871;864:12;826:52;906:9;900:16;925:31;950:5;925:31;:::i;991:1100::-;1085:6;1116:2;1159;1147:9;1138:7;1134:23;1130:32;1127:52;;;1175:1;1172;1165:12;1127:52;1215:9;1202:23;-1:-1:-1;;;;;1285:2:1;1277:6;1274:14;1271:34;;;1301:1;1298;1291:12;1271:34;1339:6;1328:9;1324:22;1314:32;;1384:7;1377:4;1373:2;1369:13;1365:27;1355:55;;1406:1;1403;1396:12;1355:55;1442:2;1429:16;1465:59;1481:42;1520:2;1481:42;:::i;1465:59::-;1546:3;1570:2;1565:3;1558:15;1598:2;1593:3;1589:12;1582:19;;1629:2;1625;1621:11;1677:7;1672:2;1666;1663:1;1659:10;1655:2;1651:19;1647:28;1644:41;1641:61;;;1698:1;1695;1688:12;1641:61;1720:1;1741;1751:310;1767:2;1762:3;1759:11;1751:310;;;1848:3;1835:17;1884:2;1871:11;1868:19;1865:39;;;1900:1;1897;1890:12;1865:39;1929:57;1978:7;1973:2;1959:11;1955:2;1951:20;1947:29;1929:57;:::i;:::-;1917:70;;-1:-1:-1;2007:12:1;;;;2039;;;;1789:1;1780:11;1751:310;;;-1:-1:-1;2080:5:1;;991:1100;-1:-1:-1;;;;;;;;;;991:1100:1:o;2096:277::-;2163:6;2216:2;2204:9;2195:7;2191:23;2187:32;2184:52;;;2232:1;2229;2222:12;2184:52;2264:9;2258:16;2317:5;2310:13;2303:21;2296:5;2293:32;2283:60;;2339:1;2336;2329:12;2378:180;2437:6;2490:2;2478:9;2469:7;2465:23;2461:32;2458:52;;;2506:1;2503;2496:12;2458:52;-1:-1:-1;2529:23:1;;2378:180;-1:-1:-1;2378:180:1:o;2563:315::-;2631:6;2639;2692:2;2680:9;2671:7;2667:23;2663:32;2660:52;;;2708:1;2705;2698:12;2660:52;2744:9;2731:23;2721:33;;2804:2;2793:9;2789:18;2776:32;2817:31;2842:5;2817:31;:::i;:::-;2867:5;2857:15;;;2563:315;;;;;:::o;2883:286::-;2941:6;2994:2;2982:9;2973:7;2969:23;2965:32;2962:52;;;3010:1;3007;3000:12;2962:52;3036:23;;-1:-1:-1;;;;;;3088:32:1;;3078:43;;3068:71;;3135:1;3132;3125:12;3174:322;3243:6;3296:2;3284:9;3275:7;3271:23;3267:32;3264:52;;;3312:1;3309;3302:12;3264:52;3352:9;3339:23;-1:-1:-1;;;;;3377:6:1;3374:30;3371:50;;;3417:1;3414;3407:12;3371:50;3440;3482:7;3473:6;3462:9;3458:22;3440:50;:::i;:::-;3430:60;3174:322;-1:-1:-1;;;;3174:322:1:o;3501:636::-;3581:6;3634:2;3622:9;3613:7;3609:23;3605:32;3602:52;;;3650:1;3647;3640:12;3602:52;3683:9;3677:16;-1:-1:-1;;;;;3708:6:1;3705:30;3702:50;;;3748:1;3745;3738:12;3702:50;3771:22;;3824:4;3816:13;;3812:27;-1:-1:-1;3802:55:1;;3853:1;3850;3843:12;3802:55;3882:2;3876:9;3907:49;3923:32;3952:2;3923:32;:::i;3907:49::-;3979:2;3972:5;3965:17;4019:7;4014:2;4009;4005;4001:11;3997:20;3994:33;3991:53;;;4040:1;4037;4030:12;3991:53;4053:54;4104:2;4099;4092:5;4088:14;4083:2;4079;4075:11;4053:54;:::i;4142:543::-;4230:6;4238;4291:2;4279:9;4270:7;4266:23;4262:32;4259:52;;;4307:1;4304;4297:12;4259:52;4347:9;4334:23;-1:-1:-1;;;;;4417:2:1;4409:6;4406:14;4403:34;;;4433:1;4430;4423:12;4403:34;4456:50;4498:7;4489:6;4478:9;4474:22;4456:50;:::i;:::-;4446:60;;4559:2;4548:9;4544:18;4531:32;4515:48;;4588:2;4578:8;4575:16;4572:36;;;4604:1;4601;4594:12;4572:36;;4627:52;4671:7;4660:8;4649:9;4645:24;4627:52;:::i;:::-;4617:62;;;4142:543;;;;;:::o;4875:184::-;4945:6;4998:2;4986:9;4977:7;4973:23;4969:32;4966:52;;;5014:1;5011;5004:12;4966:52;-1:-1:-1;5037:16:1;;4875:184;-1:-1:-1;4875:184:1:o;5064:969::-;5157:6;5165;5218:2;5206:9;5197:7;5193:23;5189:32;5186:52;;;5234:1;5231;5224:12;5186:52;5270:9;5257:23;5247:33;;5299:2;5352;5341:9;5337:18;5324:32;-1:-1:-1;;;;;5371:6:1;5368:30;5365:50;;;5411:1;5408;5401:12;5365:50;5434:22;;5487:4;5479:13;;5475:27;-1:-1:-1;5465:55:1;;5516:1;5513;5506:12;5465:55;5552:2;5539:16;5575:59;5591:42;5630:2;5591:42;:::i;5575:59::-;5656:3;5680:2;5675:3;5668:15;5708:2;5703:3;5699:12;5692:19;;5739:2;5735;5731:11;5787:7;5782:2;5776;5773:1;5769:10;5765:2;5761:19;5757:28;5754:41;5751:61;;;5808:1;5805;5798:12;5751:61;5830:1;5821:10;;5840:163;5854:2;5851:1;5848:9;5840:163;;;5911:17;;5899:30;;5872:1;5865:9;;;;;5949:12;;;;5981;;5840:163;;;5844:3;6022:5;6012:15;;;;;;;5064:969;;;;;:::o;6038:248::-;6106:6;6114;6167:2;6155:9;6146:7;6142:23;6138:32;6135:52;;;6183:1;6180;6173:12;6135:52;-1:-1:-1;;6206:23:1;;;6276:2;6261:18;;;6248:32;;-1:-1:-1;6038:248:1:o;6291:276::-;6422:3;6460:6;6454:13;6476:53;6522:6;6517:3;6510:4;6502:6;6498:17;6476:53;:::i;:::-;6545:16;;;;;6291:276;-1:-1:-1;;6291:276:1:o;6572:786::-;-1:-1:-1;;;6978:3:1;6971:38;6953:3;7038:6;7032:13;7054:62;7109:6;7104:2;7099:3;7095:12;7088:4;7080:6;7076:17;7054:62;:::i;:::-;-1:-1:-1;;;7175:2:1;7135:16;;;7167:11;;;7160:40;7225:13;;7247:63;7225:13;7296:2;7288:11;;7281:4;7269:17;;7247:63;:::i;:::-;7330:17;7349:2;7326:26;;6572:786;-1:-1:-1;;;;6572:786:1:o;7363:203::-;-1:-1:-1;;;;;7527:32:1;;;;7509:51;;7497:2;7482:18;;7363:203::o;9343:383::-;9492:2;9481:9;9474:21;9455:4;9524:6;9518:13;9567:6;9562:2;9551:9;9547:18;9540:34;9583:66;9642:6;9637:2;9626:9;9622:18;9617:2;9609:6;9605:15;9583:66;:::i;:::-;9710:2;9689:15;-1:-1:-1;;9685:29:1;9670:45;;;;9717:2;9666:54;;9343:383;-1:-1:-1;;9343:383:1:o;10092:399::-;10294:2;10276:21;;;10333:2;10313:18;;;10306:30;10372:34;10367:2;10352:18;;10345:62;-1:-1:-1;;;10438:2:1;10423:18;;10416:33;10481:3;10466:19;;10092:399::o;10842:348::-;11044:2;11026:21;;;11083:2;11063:18;;;11056:30;-1:-1:-1;;;11117:2:1;11102:18;;11095:54;11181:2;11166:18;;10842:348::o;12730:402::-;12932:2;12914:21;;;12971:2;12951:18;;;12944:30;13010:34;13005:2;12990:18;;12983:62;-1:-1:-1;;;13076:2:1;13061:18;;13054:36;13122:3;13107:19;;12730:402::o;13570:347::-;13772:2;13754:21;;;13811:2;13791:18;;;13784:30;-1:-1:-1;;;13845:2:1;13830:18;;13823:53;13908:2;13893:18;;13570:347::o;15860:356::-;16062:2;16044:21;;;16081:18;;;16074:30;16140:34;16135:2;16120:18;;16113:62;16207:2;16192:18;;15860:356::o;16221:401::-;16423:2;16405:21;;;16462:2;16442:18;;;16435:30;16501:34;16496:2;16481:18;;16474:62;-1:-1:-1;;;16567:2:1;16552:18;;16545:35;16612:3;16597:19;;16221:401::o;17043:418::-;17245:2;17227:21;;;17284:2;17264:18;;;17257:30;17323:34;17318:2;17303:18;;17296:62;-1:-1:-1;;;17389:2:1;17374:18;;17367:52;17451:3;17436:19;;17043:418::o;17466:397::-;17668:2;17650:21;;;17707:2;17687:18;;;17680:30;17746:34;17741:2;17726:18;;17719:62;-1:-1:-1;;;17812:2:1;17797:18;;17790:31;17853:3;17838:19;;17466:397::o;18050:703::-;18220:4;18268:2;18257:9;18253:18;18298:6;18287:9;18280:25;18324:2;18362;18357;18346:9;18342:18;18335:30;18385:6;18420;18414:13;18451:6;18443;18436:22;18489:2;18478:9;18474:18;18467:25;;18527:2;18519:6;18515:15;18501:29;;18548:1;18558:169;18572:6;18569:1;18566:13;18558:169;;;18633:13;;18621:26;;18702:15;;;;18667:12;;;;18594:1;18587:9;18558:169;;;-1:-1:-1;18744:3:1;;18050:703;-1:-1:-1;;;;;;;18050:703:1:o;18758:1268::-;18932:6;18921:9;18914:25;18895:4;18958:2;18996;18991;18980:9;18976:18;18969:30;19019:1;19052:6;19046:13;19082:3;19104:1;19132:9;19128:2;19124:18;19114:28;;19192:2;19181:9;19177:18;19214;19204:61;;19258:4;19250:6;19246:17;19236:27;;19204:61;19311:2;19303:6;19300:14;19280:18;19277:38;19274:165;;;-1:-1:-1;;;19338:33:1;;19394:4;19391:1;19384:15;19424:4;19345:3;19412:17;19274:165;19521:2;19506:18;;21316:19;;;21359:14;;;19549:18;19576:100;;;;19690:1;19685:315;;;;19542:458;;19576:100;-1:-1:-1;;19609:24:1;;19597:37;;19654:12;;;;-1:-1:-1;19576:100:1;;19685:315;21165:1;21158:14;;;21202:4;21189:18;;19780:1;19794:165;19808:6;19805:1;19802:13;19794:165;;;19886:14;;19873:11;;;19866:35;19929:16;;;;19823:10;;19794:165;;;19979:11;;;-1:-1:-1;;19542:458:1;-1:-1:-1;20017:3:1;;18758:1268;-1:-1:-1;;;;;;;;;;18758:1268:1:o;20433:275::-;20504:2;20498:9;20569:2;20550:13;;-1:-1:-1;;20546:27:1;20534:40;;-1:-1:-1;;;;;20589:34:1;;20625:22;;;20586:62;20583:88;;;20651:18;;:::i;:::-;20687:2;20680:22;20433:275;;-1:-1:-1;20433:275:1:o;20713:182::-;20772:4;-1:-1:-1;;;;;20797:6:1;20794:30;20791:56;;;20827:18;;:::i;:::-;-1:-1:-1;20872:1:1;20868:14;20884:4;20864:25;;20713:182::o;20900:187::-;20949:4;-1:-1:-1;;;;;20974:6:1;20971:30;20968:56;;;21004:18;;:::i;:::-;-1:-1:-1;21070:2:1;21049:15;-1:-1:-1;;21045:29:1;21076:4;21041:40;;20900:187::o;21384:128::-;21424:3;21455:1;21451:6;21448:1;21445:13;21442:39;;;21461:18;;:::i;:::-;-1:-1:-1;21497:9:1;;21384:128::o;21517:217::-;21557:1;21583;21573:132;;21627:10;21622:3;21618:20;21615:1;21608:31;21662:4;21659:1;21652:15;21690:4;21687:1;21680:15;21573:132;-1:-1:-1;21719:9:1;;21517:217::o;21739:168::-;21779:7;21845:1;21841;21837:6;21833:14;21830:1;21827:21;21822:1;21815:9;21808:17;21804:45;21801:71;;;21852:18;;:::i;:::-;-1:-1:-1;21892:9:1;;21739:168::o;21912:125::-;21952:4;21980:1;21977;21974:8;21971:34;;;21985:18;;:::i;:::-;-1:-1:-1;22022:9:1;;21912:125::o;22042:258::-;22114:1;22124:113;22138:6;22135:1;22132:13;22124:113;;;22214:11;;;22208:18;22195:11;;;22188:39;22160:2;22153:10;22124:113;;;22255:6;22252:1;22249:13;22246:48;;;22290:1;22281:6;22276:3;22272:16;22265:27;22246:48;;22042:258;;;:::o;22305:136::-;22344:3;22372:5;22362:39;;22381:18;;:::i;:::-;-1:-1:-1;;;22417:18:1;;22305:136::o;22446:380::-;22525:1;22521:12;;;;22568;;;22589:61;;22643:4;22635:6;22631:17;22621:27;;22589:61;22696:2;22688:6;22685:14;22665:18;22662:38;22659:161;;;22742:10;22737:3;22733:20;22730:1;22723:31;22777:4;22774:1;22767:15;22805:4;22802:1;22795:15;22659:161;;22446:380;;;:::o;22831:135::-;22870:3;-1:-1:-1;;22891:17:1;;22888:43;;;22911:18;;:::i;:::-;-1:-1:-1;22958:1:1;22947:13;;22831:135::o;22971:127::-;23032:10;23027:3;23023:20;23020:1;23013:31;23063:4;23060:1;23053:15;23087:4;23084:1;23077:15;23103:127;23164:10;23159:3;23155:20;23152:1;23145:31;23195:4;23192:1;23185:15;23219:4;23216:1;23209:15;23235:127;23296:10;23291:3;23287:20;23284:1;23277:31;23327:4;23324:1;23317:15;23351:4;23348:1;23341:15;23367:131;-1:-1:-1;;;;;23442:31:1;;23432:42;;23422:70;;23488:1;23485;23478:12

ipfs://642b83a7eeaaa8a2d408995609fec25107a861566d3208e575fd4ec44a82f90a