Contract 0x5f4e5c60955e71a5fd7ce31d366421262caa5fc7

/**
 *Submitted for verification at cronoscan.com on 2022-04-08
*/

// SPDX-License-Identifier: MIT
// File: CROHomesKeys.sol



pragma solidity ^0.8.7;

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

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

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

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

/**
 * @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() {
        _setOwner(_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 {
        _setOwner(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");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and make it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

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

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

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

    function _verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) private 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);
            }
        }
    }
}

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

/**
 * @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 {
        require(operator != _msgSender(), "ERC721: approve to caller");

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_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 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(to).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 {}
}

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

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

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

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

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

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

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

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message
     */
    function div(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     */
    function mod(uint256 a, uint256 b, string memory errorMessage) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}


pragma solidity ^0.8.0;

interface iHomes {
    function walletOfOwner(address owner) external view returns(uint256[] memory);
    function ownerOf(uint256 tokenId) external view returns (address owner);
}

interface iRent {
    function burn(address _from, uint256 _amount) external;
}

contract CROHOMESKEYS is ERC721Enumerable, Ownable {
    using SafeMath for uint256;
    using Address for address;

    iHomes public Homes;
    iRent public Rent;
    string private baseURI;
    bool public mintIsActive = false;
    uint256 public price = 9999;
    mapping (uint256 => uint256) public keySize;

    constructor(string memory name, string memory symbol) ERC721(name, symbol){}
    
    function mintReserved(address _to, uint256 _id) public onlyOwner {
            _safeMint( _to, _id);
    }

    function airdropKeys(address[] memory airdropList) public onlyOwner{
        for(uint256 X = 0; X < airdropList.length; X++){
        uint256[] memory _ids = Homes.walletOfOwner(airdropList[X]);
        for(uint256 i = 0; i < _ids.length; i++){
        require(!_exists(_ids[i]), "ERC721: token already minted");
        _safeMint(airdropList[X], _ids[i]);
        }
        }
    }

    function mint(uint256 _homeID) public payable{
        require(mintIsActive, "You can't mint Keys yet");
        require((Homes.ownerOf(_homeID)) == msg.sender);
        require(!_exists(_homeID), "ERC721: token already minted");
        Rent.burn(msg.sender, price);
        _safeMint(msg.sender, _homeID);
    }

    function setHome(address homeAddress) external onlyOwner {
        Homes = iHomes(homeAddress);
    }

    function setRent(address rentAddress) external onlyOwner {
        Rent = iRent(rentAddress);
    }

    // 0 = Small
    // 1 = Medium
    // 2 = Large
    // 3 = Penth

    function setSize(uint256 tokenId, uint256 _keySize) public onlyOwner{
        keySize[tokenId] = _keySize;
    }

    function setSizeMultiple(uint256 _keySize, uint256[] memory tokenId) public onlyOwner{
      for(uint256 i = 0; i < tokenId.length; i++){
        keySize[tokenId[i]] = _keySize;
      }
    }

    function getSize(uint256 tokenId) external view returns (uint256) {
       uint256 size = keySize[tokenId];
       return size;
    }

    function walletOfOwner(address owner) external view returns(uint256[] memory) {
        uint256 tokenCount = balanceOf(owner);

        uint256[] memory tokensId = new uint256[](tokenCount);
        for(uint256 i; i < tokenCount; i++){
            tokensId[i] = tokenOfOwnerByIndex(owner, i);
        }
        return tokensId;
    }
    
    function setBaseURI(string memory uri) public onlyOwner {
        baseURI = uri;
    }

    function setPrice(uint256 newPrice) public onlyOwner {
        price = newPrice;
    }

    function toggleMint() public onlyOwner {
        mintIsActive = !mintIsActive;
    }
    
    function _baseURI() internal view override returns (string memory) {
        return baseURI;
    }
}

[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"Homes","outputs":[{"internalType":"contract iHomes","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"Rent","outputs":[{"internalType":"contract iRent","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"airdropList","type":"address[]"}],"name":"airdropKeys","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getSize","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"keySize","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_homeID","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintIsActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_id","type":"uint256"}],"name":"mintReserved","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"price","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"uri","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"homeAddress","type":"address"}],"name":"setHome","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPrice","type":"uint256"}],"name":"setPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"rentAddress","type":"address"}],"name":"setRent","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"_keySize","type":"uint256"}],"name":"setSize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_keySize","type":"uint256"},{"internalType":"uint256[]","name":"tokenId","type":"uint256[]"}],"name":"setSizeMultiple","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"toggleMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"walletOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"}]

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

00000000000000000000000000000000000000000000000000000000000000400000000000000000000000000000000000000000000000000000000000000080000000000000000000000000000000000000000000000000000000000000000e43524f20486f6d6573204b657973000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000843484f4d454b4559000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name (string): CRO Homes Keys
Arg [1] : symbol (string): CHOMEKEY

-----Encoded View---------------
6 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000040
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [2] : 000000000000000000000000000000000000000000000000000000000000000e
Arg [3] : 43524f20486f6d6573204b657973000000000000000000000000000000000000
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000008
Arg [5] : 43484f4d454b4559000000000000000000000000000000000000000000000000

50648:2768:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;38261:224;;;;;;;;;;-1:-1:-1;38261:224:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;38261:224:0;;;;;;;;52526:136;;;;;;;;;;-1:-1:-1;52526:136:0;;;;;:::i;:::-;52583:7;52617:16;;;:7;:16;;;;;;;52526:136;;;;923:25:1;;;911:2;896:18;52526:136:0;777:177:1;25389:100:0;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;26948:221::-;;;;;;;;;;-1:-1:-1;26948:221:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1874:32:1;;;1856:51;;1844:2;1829:18;26948:221:0;1710:203:1;26471:411:0;;;;;;;;;;-1:-1:-1;26471:411:0;;;;;:::i;:::-;;:::i;:::-;;51181:390;;;;;;;;;;-1:-1:-1;51181:390:0;;;;;:::i;:::-;;:::i;38901:113::-;;;;;;;;;;-1:-1:-1;38989:10:0;:17;38901:113;;50799:17;;;;;;;;;;-1:-1:-1;50799:17:0;;;;-1:-1:-1;;;;;50799:17:0;;;50925:43;;;;;;;;;;-1:-1:-1;50925:43:0;;;;;:::i;:::-;;;;;;;;;;;;;;27838:339;;;;;;;;;;-1:-1:-1;27838:339:0;;;;;:::i;:::-;;:::i;38569:256::-;;;;;;;;;;-1:-1:-1;38569:256:0;;;;;:::i;:::-;;:::i;52323:195::-;;;;;;;;;;-1:-1:-1;52323:195:0;;;;;:::i;:::-;;:::i;52201:114::-;;;;;;;;;;-1:-1:-1;52201:114:0;;;;;:::i;:::-;;:::i;28248:185::-;;;;;;;;;;-1:-1:-1;28248:185:0;;;;;:::i;:::-;;:::i;52670:341::-;;;;;;;;;;-1:-1:-1;52670:341:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;50852:32::-;;;;;;;;;;-1:-1:-1;50852:32:0;;;;;;;;39091:233;;;;;;;;;;-1:-1:-1;39091:233:0;;;;;:::i;:::-;;:::i;53023:88::-;;;;;;;;;;-1:-1:-1;53023:88:0;;;;;:::i;:::-;;:::i;25083:239::-;;;;;;;;;;-1:-1:-1;25083:239:0;;;;;:::i;:::-;;:::i;51906:103::-;;;;;;;;;;-1:-1:-1;51906:103:0;;;;;:::i;:::-;;:::i;24813:208::-;;;;;;;;;;-1:-1:-1;24813:208:0;;;;;:::i;:::-;;:::i;9849:94::-;;;;;;;;;;;;;:::i;52017:101::-;;;;;;;;;;-1:-1:-1;52017:101:0;;;;;:::i;:::-;;:::i;51065:108::-;;;;;;;;;;-1:-1:-1;51065:108:0;;;;;:::i;:::-;;:::i;9198:87::-;;;;;;;;;;-1:-1:-1;9271:6:0;;-1:-1:-1;;;;;9271:6:0;9198:87;;53119:88;;;;;;;;;;-1:-1:-1;53119:88:0;;;;;:::i;:::-;;:::i;25558:104::-;;;;;;;;;;;;;:::i;50891:27::-;;;;;;;;;;;;;;;;51579:319;;;;;;:::i;:::-;;:::i;27241:295::-;;;;;;;;;;-1:-1:-1;27241:295:0;;;;;:::i;:::-;;:::i;28504:328::-;;;;;;;;;;-1:-1:-1;28504:328:0;;;;;:::i;:::-;;:::i;50773:19::-;;;;;;;;;;-1:-1:-1;50773:19:0;;;;-1:-1:-1;;;;;50773:19:0;;;25733:334;;;;;;;;;;-1:-1:-1;25733:334:0;;;;;:::i;:::-;;:::i;53215:86::-;;;;;;;;;;;;;:::i;27607:164::-;;;;;;;;;;-1:-1:-1;27607:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;27728:25:0;;;27704:4;27728:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;27607:164;10098:192;;;;;;;;;;-1:-1:-1;10098:192:0;;;;;:::i;:::-;;:::i;38261:224::-;38363:4;-1:-1:-1;;;;;;38387:50:0;;-1:-1:-1;;;38387:50:0;;:90;;;38441:36;38465:11;38441:23;:36::i;:::-;38380:97;38261:224;-1:-1:-1;;38261:224:0:o;25389:100::-;25443:13;25476:5;25469:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25389:100;:::o;26948:221::-;27024:7;27052:16;27060:7;27052;:16::i;:::-;27044:73;;;;-1:-1:-1;;;27044:73:0;;10026:2:1;27044:73:0;;;10008:21:1;10065:2;10045:18;;;10038:30;10104:34;10084:18;;;10077:62;-1:-1:-1;;;10155:18:1;;;10148:42;10207:19;;27044:73:0;;;;;;;;;-1:-1:-1;27137:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;27137:24:0;;26948:221::o;26471:411::-;26552:13;26568:23;26583:7;26568:14;:23::i;:::-;26552:39;;26616:5;-1:-1:-1;;;;;26610:11:0;:2;-1:-1:-1;;;;;26610:11:0;;26602:57;;;;-1:-1:-1;;;26602:57:0;;10439:2:1;26602:57:0;;;10421:21:1;10478:2;10458:18;;;10451:30;10517:34;10497:18;;;10490:62;-1:-1:-1;;;10568:18:1;;;10561:31;10609:19;;26602:57:0;10237:397:1;26602:57:0;8154:10;-1:-1:-1;;;;;26694:21:0;;;;:62;;-1:-1:-1;26719:37:0;26736:5;8154:10;27607:164;:::i;26719:37::-;26672:168;;;;-1:-1:-1;;;26672:168:0;;10841:2:1;26672:168:0;;;10823:21:1;10880:2;10860:18;;;10853:30;10919:34;10899:18;;;10892:62;10990:26;10970:18;;;10963:54;11034:19;;26672:168:0;10639:420:1;26672:168:0;26853:21;26862:2;26866:7;26853:8;:21::i;:::-;26541:341;26471:411;;:::o;51181:390::-;9271:6;;-1:-1:-1;;;;;9271:6:0;8154:10;9418:23;9410:68;;;;-1:-1:-1;;;9410:68:0;;;;;;;:::i;:::-;51263:9:::1;51259:305;51282:11;:18;51278:1;:22;51259:305;;;51341:5;::::0;51361:14;;51317:21:::1;::::0;-1:-1:-1;;;;;51341:5:0::1;::::0;:19:::1;::::0;51361:11;;51373:1;;51361:14;::::1;;;;;:::i;:::-;;;;;;;51341:35;;;;;;;;;;;;;;-1:-1:-1::0;;;;;1874:32:1;;;;1856:51;;1844:2;1829:18;;1710:203;51341:35:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;::::0;;::::1;-1:-1:-1::0;;51341:35:0::1;::::0;::::1;;::::0;::::1;::::0;;;::::1;::::0;::::1;:::i;:::-;51317:59;;51391:9;51387:166;51410:4;:11;51406:1;:15;51387:166;;;51447:16;51455:4;51460:1;51455:7;;;;;;;;:::i;:::-;;;;;;;51447;:16::i;:::-;51446:17;51438:58;;;;-1:-1:-1::0;;;51438:58:0::1;;;;;;;:::i;:::-;51507:34;51517:11;51529:1;51517:14;;;;;;;;:::i;:::-;;;;;;;51533:4;51538:1;51533:7;;;;;;;;:::i;:::-;;;;;;;51507:9;:34::i;:::-;51423:3:::0;::::1;::::0;::::1;:::i;:::-;;;;51387:166;;;;51306:258;51302:3;;;;;:::i;:::-;;;;51259:305;;;;51181:390:::0;:::o;27838:339::-;28033:41;8154:10;28066:7;28033:18;:41::i;:::-;28025:103;;;;-1:-1:-1;;;28025:103:0;;;;;;;:::i;:::-;28141:28;28151:4;28157:2;28161:7;28141:9;:28::i;38569:256::-;38666:7;38702:23;38719:5;38702:16;:23::i;:::-;38694:5;:31;38686:87;;;;-1:-1:-1;;;38686:87:0;;13692:2:1;38686:87:0;;;13674:21:1;13731:2;13711:18;;;13704:30;13770:34;13750:18;;;13743:62;-1:-1:-1;;;13821:18:1;;;13814:41;13872:19;;38686:87:0;13490:407:1;38686:87:0;-1:-1:-1;;;;;;38791:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;38569:256::o;52323:195::-;9271:6;;-1:-1:-1;;;;;9271:6:0;8154:10;9418:23;9410:68;;;;-1:-1:-1;;;9410:68:0;;;;;;;:::i;:::-;52421:9:::1;52417:94;52440:7;:14;52436:1;:18;52417:94;;;52493:8;52471:7;:19;52479:7;52487:1;52479:10;;;;;;;;:::i;:::-;;;;;;;52471:19;;;;;;;;;;;:30;;;;52456:3;;;;;:::i;:::-;;;;52417:94;;52201:114:::0;9271:6;;-1:-1:-1;;;;;9271:6:0;8154:10;9418:23;9410:68;;;;-1:-1:-1;;;9410:68:0;;;;;;;:::i;:::-;52280:16:::1;::::0;;;:7:::1;:16;::::0;;;;;:27;52201:114::o;28248:185::-;28386:39;28403:4;28409:2;28413:7;28386:39;;;;;;;;;;;;:16;:39::i;52670:341::-;52730:16;52759:18;52780:16;52790:5;52780:9;:16::i;:::-;52759:37;;52809:25;52851:10;52837:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;52837:25:0;;52809:53;;52877:9;52873:105;52892:10;52888:1;:14;52873:105;;;52937:29;52957:5;52964:1;52937:19;:29::i;:::-;52923:8;52932:1;52923:11;;;;;;;;:::i;:::-;;;;;;;;;;:43;52904:3;;;;:::i;:::-;;;;52873:105;;;-1:-1:-1;52995:8:0;52670:341;-1:-1:-1;;;52670:341:0:o;39091:233::-;39166:7;39202:30;38989:10;:17;;38901:113;39202:30;39194:5;:38;39186:95;;;;-1:-1:-1;;;39186:95:0;;14104:2:1;39186:95:0;;;14086:21:1;14143:2;14123:18;;;14116:30;14182:34;14162:18;;;14155:62;-1:-1:-1;;;14233:18:1;;;14226:42;14285:19;;39186:95:0;13902:408:1;39186:95:0;39299:10;39310:5;39299:17;;;;;;;;:::i;:::-;;;;;;;;;39292:24;;39091:233;;;:::o;53023:88::-;9271:6;;-1:-1:-1;;;;;9271:6:0;8154:10;9418:23;9410:68;;;;-1:-1:-1;;;9410:68:0;;;;;;;:::i;:::-;53090:13;;::::1;::::0;:7:::1;::::0;:13:::1;::::0;::::1;::::0;::::1;:::i;25083:239::-:0;25155:7;25191:16;;;:7;:16;;;;;;-1:-1:-1;;;;;25191:16:0;;25218:73;;;;-1:-1:-1;;;25218:73:0;;14517:2:1;25218:73:0;;;14499:21:1;14556:2;14536:18;;;14529:30;14595:34;14575:18;;;14568:62;-1:-1:-1;;;14646:18:1;;;14639:39;14695:19;;25218:73:0;14315:405:1;51906:103:0;9271:6;;-1:-1:-1;;;;;9271:6:0;8154:10;9418:23;9410:68;;;;-1:-1:-1;;;9410:68:0;;;;;;;:::i;:::-;51974:5:::1;:27:::0;;-1:-1:-1;;;;;;51974:27:0::1;-1:-1:-1::0;;;;;51974:27:0;;;::::1;::::0;;;::::1;::::0;;51906:103::o;24813:208::-;24885:7;-1:-1:-1;;;;;24913:19:0;;24905:74;;;;-1:-1:-1;;;24905:74:0;;14927:2:1;24905:74:0;;;14909:21:1;14966:2;14946:18;;;14939:30;15005:34;14985:18;;;14978:62;-1:-1:-1;;;15056:18:1;;;15049:40;15106:19;;24905:74:0;14725:406:1;24905:74:0;-1:-1:-1;;;;;;24997:16:0;;;;;:9;:16;;;;;;;24813:208::o;9849:94::-;9271:6;;-1:-1:-1;;;;;9271:6:0;8154:10;9418:23;9410:68;;;;-1:-1:-1;;;9410:68:0;;;;;;;:::i;:::-;9914:21:::1;9932:1;9914:9;:21::i;:::-;9849:94::o:0;52017:101::-;9271:6;;-1:-1:-1;;;;;9271:6:0;8154:10;9418:23;9410:68;;;;-1:-1:-1;;;9410:68:0;;;;;;;:::i;:::-;52085:4:::1;:25:::0;;-1:-1:-1;;;;;;52085:25:0::1;-1:-1:-1::0;;;;;52085:25:0;;;::::1;::::0;;;::::1;::::0;;52017:101::o;51065:108::-;9271:6;;-1:-1:-1;;;;;9271:6:0;8154:10;9418:23;9410:68;;;;-1:-1:-1;;;9410:68:0;;;;;;;:::i;:::-;51145:20:::1;51156:3;51161;51145:9;:20::i;53119:88::-:0;9271:6;;-1:-1:-1;;;;;9271:6:0;8154:10;9418:23;9410:68;;;;-1:-1:-1;;;9410:68:0;;;;;;;:::i;:::-;53183:5:::1;:16:::0;53119:88::o;25558:104::-;25614:13;25647:7;25640:14;;;;;:::i;51579:319::-;51643:12;;;;51635:48;;;;-1:-1:-1;;;51635:48:0;;15338:2:1;51635:48:0;;;15320:21:1;15377:2;15357:18;;;15350:30;15416:25;15396:18;;;15389:53;15459:18;;51635:48:0;15136:347:1;51635:48:0;51703:5;;:22;;-1:-1:-1;;;51703:22:0;;;;;923:25:1;;;51730:10:0;;-1:-1:-1;;;;;51703:5:0;;:13;;896:18:1;;51703:22:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;51702:38:0;;51694:47;;;;;;51761:16;51769:7;51761;:16::i;:::-;51760:17;51752:58;;;;-1:-1:-1;;;51752:58:0;;;;;;;:::i;:::-;51821:4;;51843:5;;51821:28;;-1:-1:-1;;;51821:28:0;;51831:10;51821:28;;;15918:51:1;15985:18;;;15978:34;;;;-1:-1:-1;;;;;51821:4:0;;;;:9;;15891:18:1;;51821:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51860:30;51870:10;51882:7;51860:9;:30::i;:::-;51579:319;:::o;27241:295::-;8154:10;-1:-1:-1;;;;;27344:24:0;;;27336:62;;;;-1:-1:-1;;;27336:62:0;;16225:2:1;27336:62:0;;;16207:21:1;16264:2;16244:18;;;16237:30;16303:27;16283:18;;;16276:55;16348:18;;27336:62:0;16023:349:1;27336:62:0;8154:10;27411:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;27411:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;27411:53:0;;;;;;;;;;27480:48;;540:41:1;;;27411:42:0;;8154:10;27480:48;;513:18:1;27480:48:0;;;;;;;27241:295;;:::o;28504:328::-;28679:41;8154:10;28712:7;28679:18;:41::i;:::-;28671:103;;;;-1:-1:-1;;;28671:103:0;;;;;;;:::i;:::-;28785:39;28799:4;28805:2;28809:7;28818:5;28785:13;:39::i;:::-;28504:328;;;;:::o;25733:334::-;25806:13;25840:16;25848:7;25840;:16::i;:::-;25832:76;;;;-1:-1:-1;;;25832:76:0;;16579:2:1;25832:76:0;;;16561:21:1;16618:2;16598:18;;;16591:30;16657:34;16637:18;;;16630:62;-1:-1:-1;;;16708:18:1;;;16701:45;16763:19;;25832:76:0;16377:411:1;25832:76:0;25921:21;25945:10;:8;:10::i;:::-;25921:34;;25997:1;25979:7;25973:21;:25;:86;;;;;;;;;;;;;;;;;26025:7;26034:18;:7;:16;:18::i;:::-;26008:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;25973:86;25966:93;25733:334;-1:-1:-1;;;25733:334:0:o;53215:86::-;9271:6;;-1:-1:-1;;;;;9271:6:0;8154:10;9418:23;9410:68;;;;-1:-1:-1;;;9410:68:0;;;;;;;:::i;:::-;53281:12:::1;::::0;;-1:-1:-1;;53265:28:0;::::1;53281:12;::::0;;::::1;53280:13;53265:28;::::0;;53215:86::o;10098:192::-;9271:6;;-1:-1:-1;;;;;9271:6:0;8154:10;9418:23;9410:68;;;;-1:-1:-1;;;9410:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;10187:22:0;::::1;10179:73;;;::::0;-1:-1:-1;;;10179:73:0;;17470:2:1;10179:73:0::1;::::0;::::1;17452:21:1::0;17509:2;17489:18;;;17482:30;17548:34;17528:18;;;17521:62;-1:-1:-1;;;17599:18:1;;;17592:36;17645:19;;10179:73:0::1;17268:402:1::0;10179:73:0::1;10263:19;10273:8;10263:9;:19::i;24444:305::-:0;24546:4;-1:-1:-1;;;;;;24583:40:0;;-1:-1:-1;;;24583:40:0;;:105;;-1:-1:-1;;;;;;;24640:48:0;;-1:-1:-1;;;24640:48:0;24583:105;:158;;;-1:-1:-1;;;;;;;;;;23162:40:0;;;24705:36;23053:157;30342:127;30407:4;30431:16;;;:7;:16;;;;;;-1:-1:-1;;;;;30431:16:0;:30;;;30342:127::o;34324:174::-;34399:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;34399:29:0;-1:-1:-1;;;;;34399:29:0;;;;;;;;:24;;34453:23;34399:24;34453:14;:23::i;:::-;-1:-1:-1;;;;;34444:46:0;;;;;;;;;;;34324:174;;:::o;31326:110::-;31402:26;31412:2;31416:7;31402:26;;;;;;;;;;;;:9;:26::i;30636:348::-;30729:4;30754:16;30762:7;30754;:16::i;:::-;30746:73;;;;-1:-1:-1;;;30746:73:0;;17877:2:1;30746:73:0;;;17859:21:1;17916:2;17896:18;;;17889:30;17955:34;17935:18;;;17928:62;-1:-1:-1;;;18006:18:1;;;17999:42;18058:19;;30746:73:0;17675:408:1;30746:73:0;30830:13;30846:23;30861:7;30846:14;:23::i;:::-;30830:39;;30899:5;-1:-1:-1;;;;;30888:16:0;:7;-1:-1:-1;;;;;30888:16:0;;:51;;;;30932:7;-1:-1:-1;;;;;30908:31:0;:20;30920:7;30908:11;:20::i;:::-;-1:-1:-1;;;;;30908:31:0;;30888:51;:87;;;-1:-1:-1;;;;;;27728:25:0;;;27704:4;27728:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;30943:32;30880:96;30636:348;-1:-1:-1;;;;30636:348:0:o;33628:578::-;33787:4;-1:-1:-1;;;;;33760:31:0;:23;33775:7;33760:14;:23::i;:::-;-1:-1:-1;;;;;33760:31:0;;33752:85;;;;-1:-1:-1;;;33752:85:0;;18290:2:1;33752:85:0;;;18272:21:1;18329:2;18309:18;;;18302:30;18368:34;18348:18;;;18341:62;-1:-1:-1;;;18419:18:1;;;18412:39;18468:19;;33752:85:0;18088:405:1;33752:85:0;-1:-1:-1;;;;;33856:16:0;;33848:65;;;;-1:-1:-1;;;33848:65:0;;18700:2:1;33848:65:0;;;18682:21:1;18739:2;18719:18;;;18712:30;18778:34;18758:18;;;18751:62;-1:-1:-1;;;18829:18:1;;;18822:34;18873:19;;33848:65:0;18498:400:1;33848:65:0;33926:39;33947:4;33953:2;33957:7;33926:20;:39::i;:::-;34030:29;34047:1;34051:7;34030:8;:29::i;:::-;-1:-1:-1;;;;;34072:15:0;;;;;;:9;:15;;;;;:20;;34091:1;;34072:15;:20;;34091:1;;34072:20;:::i;:::-;;;;-1:-1:-1;;;;;;;34103:13:0;;;;;;:9;:13;;;;;:18;;34120:1;;34103:13;:18;;34120:1;;34103:18;:::i;:::-;;;;-1:-1:-1;;34132:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;34132:21:0;-1:-1:-1;;;;;34132:21:0;;;;;;;;;34171:27;;34132:16;;34171:27;;;;;;;33628:578;;;:::o;10298:173::-;10373:6;;;-1:-1:-1;;;;;10390:17:0;;;-1:-1:-1;;;;;;10390:17:0;;;;;;;10423:40;;10373:6;;;10390:17;10373:6;;10423:40;;10354:16;;10423:40;10343:128;10298:173;:::o;29714:315::-;29871:28;29881:4;29887:2;29891:7;29871:9;:28::i;:::-;29918:48;29941:4;29947:2;29951:7;29960:5;29918:22;:48::i;:::-;29910:111;;;;-1:-1:-1;;;29910:111:0;;;;;;;:::i;53313:100::-;53365:13;53398:7;53391:14;;;;;:::i;5776:723::-;5832:13;6053:5;6062:1;6053:10;6049:53;;-1:-1:-1;;6080:10:0;;;;;;;;;;;;-1:-1:-1;;;6080:10:0;;;;;5776:723::o;6049:53::-;6127:5;6112:12;6168:78;6175:9;;6168:78;;6201:8;;;;:::i;:::-;;-1:-1:-1;6224:10:0;;-1:-1:-1;6232:2:0;6224:10;;:::i;:::-;;;6168:78;;;6256:19;6288:6;6278:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;6278:17:0;;6256:39;;6306:154;6313:10;;6306:154;;6340:11;6350:1;6340:11;;:::i;:::-;;-1:-1:-1;6409:10:0;6417:2;6409:5;:10;:::i;:::-;6396:24;;:2;:24;:::i;:::-;6383:39;;6366:6;6373;6366:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;6366:56:0;;;;;;;;-1:-1:-1;6437:11:0;6446:2;6437:11;;:::i;:::-;;;6306:154;;31663:321;31793:18;31799:2;31803:7;31793:5;:18::i;:::-;31844:54;31875:1;31879:2;31883:7;31892:5;31844:22;:54::i;:::-;31822:154;;;;-1:-1:-1;;;31822:154:0;;;;;;;:::i;39937:589::-;-1:-1:-1;;;;;40143:18:0;;40139:187;;40178:40;40210:7;41353:10;:17;;41326:24;;;;:15;:24;;;;;:44;;;41381:24;;;;;;;;;;;;41249:164;40178:40;40139:187;;;40248:2;-1:-1:-1;;;;;40240:10:0;:4;-1:-1:-1;;;;;40240:10:0;;40236:90;;40267:47;40300:4;40306:7;40267:32;:47::i;:::-;-1:-1:-1;;;;;40340:16:0;;40336:183;;40373:45;40410:7;40373:36;:45::i;40336:183::-;40446:4;-1:-1:-1;;;;;40440:10:0;:2;-1:-1:-1;;;;;40440:10:0;;40436:83;;40467:40;40495:2;40499:7;40467:27;:40::i;35063:803::-;35218:4;-1:-1:-1;;;;;35239:13:0;;15560:20;15608:8;35235:624;;35275:72;;-1:-1:-1;;;35275:72:0;;-1:-1:-1;;;;;35275:36:0;;;;;:72;;8154:10;;35326:4;;35332:7;;35341:5;;35275:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;35275:72:0;;;;;;;;-1:-1:-1;;35275:72:0;;;;;;;;;;;;:::i;:::-;;;35271:533;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35521:6;:13;35538:1;35521:18;35517:272;;35564:60;;-1:-1:-1;;;35564:60:0;;;;;;;:::i;35517:272::-;35739:6;35733:13;35724:6;35720:2;35716:15;35709:38;35271:533;-1:-1:-1;;;;;;35398:55:0;-1:-1:-1;;;35398:55:0;;-1:-1:-1;35391:62:0;;35235:624;-1:-1:-1;35843:4:0;35063:803;;;;;;:::o;32320:382::-;-1:-1:-1;;;;;32400:16:0;;32392:61;;;;-1:-1:-1;;;32392:61:0;;20909:2:1;32392:61:0;;;20891:21:1;;;20928:18;;;20921:30;20987:34;20967:18;;;20960:62;21039:18;;32392:61:0;20707:356:1;32392:61:0;32473:16;32481:7;32473;:16::i;:::-;32472:17;32464:58;;;;-1:-1:-1;;;32464:58:0;;;;;;;:::i;:::-;32535:45;32564:1;32568:2;32572:7;32535:20;:45::i;:::-;-1:-1:-1;;;;;32593:13:0;;;;;;:9;:13;;;;;:18;;32610:1;;32593:13;:18;;32610:1;;32593:18;:::i;:::-;;;;-1:-1:-1;;32622:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;32622:21:0;-1:-1:-1;;;;;32622:21:0;;;;;;;;32661:33;;32622:16;;;32661:33;;32622:16;;32661:33;32320:382;;:::o;42040:988::-;42306:22;42356:1;42331:22;42348:4;42331:16;:22::i;:::-;:26;;;;:::i;:::-;42368:18;42389:26;;;:17;:26;;;;;;42306:51;;-1:-1:-1;42522:28:0;;;42518:328;;-1:-1:-1;;;;;42589:18:0;;42567:19;42589:18;;;:12;:18;;;;;;;;:34;;;;;;;;;42640:30;;;;;;:44;;;42757:30;;:17;:30;;;;;:43;;;42518:328;-1:-1:-1;42942:26:0;;;;:17;:26;;;;;;;;42935:33;;;-1:-1:-1;;;;;42986:18:0;;;;;:12;:18;;;;;:34;;;;;;;42979:41;42040:988::o;43323:1079::-;43601:10;:17;43576:22;;43601:21;;43621:1;;43601:21;:::i;:::-;43633:18;43654:24;;;:15;:24;;;;;;44027:10;:26;;43576:46;;-1:-1:-1;43654:24:0;;43576:46;;44027:26;;;;;;:::i;:::-;;;;;;;;;44005:48;;44091:11;44066:10;44077;44066:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;44171:28;;;:15;:28;;;;;;;:41;;;44343:24;;;;;44336:31;44378:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;43394:1008;;;43323:1079;:::o;40827:221::-;40912:14;40929:20;40946:2;40929:16;:20::i;:::-;-1:-1:-1;;;;;40960:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;41005:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;40827:221:0:o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:131:1;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:180::-;651:6;704:2;692:9;683:7;679:23;675:32;672:52;;;720:1;717;710:12;672:52;-1:-1:-1;743:23:1;;592:180;-1:-1:-1;592:180:1:o;959:258::-;1031:1;1041:113;1055:6;1052:1;1049:13;1041:113;;;1131:11;;;1125:18;1112:11;;;1105:39;1077:2;1070:10;1041:113;;;1172:6;1169:1;1166:13;1163:48;;;-1:-1:-1;;1207:1:1;1189:16;;1182:27;959:258::o;1222:::-;1264:3;1302:5;1296:12;1329:6;1324:3;1317:19;1345:63;1401:6;1394:4;1389:3;1385:14;1378:4;1371:5;1367:16;1345:63;:::i;:::-;1462:2;1441:15;-1:-1:-1;;1437:29:1;1428:39;;;;1469:4;1424:50;;1222:258;-1:-1:-1;;1222:258:1:o;1485:220::-;1634:2;1623:9;1616:21;1597:4;1654:45;1695:2;1684:9;1680:18;1672:6;1654:45;:::i;1918:131::-;-1:-1:-1;;;;;1993:31:1;;1983:42;;1973:70;;2039:1;2036;2029:12;2054:315;2122:6;2130;2183:2;2171:9;2162:7;2158:23;2154:32;2151:52;;;2199:1;2196;2189:12;2151:52;2238:9;2225:23;2257:31;2282:5;2257:31;:::i;:::-;2307:5;2359:2;2344:18;;;;2331:32;;-1:-1:-1;;;2054:315:1:o;2374:127::-;2435:10;2430:3;2426:20;2423:1;2416:31;2466:4;2463:1;2456:15;2490:4;2487:1;2480:15;2506:275;2577:2;2571:9;2642:2;2623:13;;-1:-1:-1;;2619:27:1;2607:40;;2677:18;2662:34;;2698:22;;;2659:62;2656:88;;;2724:18;;:::i;:::-;2760:2;2753:22;2506:275;;-1:-1:-1;2506:275:1:o;2786:183::-;2846:4;2879:18;2871:6;2868:30;2865:56;;;2901:18;;:::i;:::-;-1:-1:-1;2946:1:1;2942:14;2958:4;2938:25;;2786:183::o;2974:966::-;3058:6;3089:2;3132;3120:9;3111:7;3107:23;3103:32;3100:52;;;3148:1;3145;3138:12;3100:52;3188:9;3175:23;3221:18;3213:6;3210:30;3207:50;;;3253:1;3250;3243:12;3207:50;3276:22;;3329:4;3321:13;;3317:27;-1:-1:-1;3307:55:1;;3358:1;3355;3348:12;3307:55;3394:2;3381:16;3417:60;3433:43;3473:2;3433:43;:::i;:::-;3417:60;:::i;:::-;3511:15;;;3593:1;3589:10;;;;3581:19;;3577:28;;;3542:12;;;;3617:19;;;3614:39;;;3649:1;3646;3639:12;3614:39;3673:11;;;;3693:217;3709:6;3704:3;3701:15;3693:217;;;3789:3;3776:17;3806:31;3831:5;3806:31;:::i;:::-;3850:18;;3726:12;;;;3888;;;;3693:217;;;3929:5;2974:966;-1:-1:-1;;;;;;;2974:966:1:o;4167:456::-;4244:6;4252;4260;4313:2;4301:9;4292:7;4288:23;4284:32;4281:52;;;4329:1;4326;4319:12;4281:52;4368:9;4355:23;4387:31;4412:5;4387:31;:::i;:::-;4437:5;-1:-1:-1;4494:2:1;4479:18;;4466:32;4507:33;4466:32;4507:33;:::i;:::-;4167:456;;4559:7;;-1:-1:-1;;;4613:2:1;4598:18;;;;4585:32;;4167:456::o;4628:959::-;4721:6;4729;4782:2;4770:9;4761:7;4757:23;4753:32;4750:52;;;4798:1;4795;4788:12;4750:52;4834:9;4821:23;4811:33;;4863:2;4916;4905:9;4901:18;4888:32;4943:18;4935:6;4932:30;4929:50;;;4975:1;4972;4965:12;4929:50;4998:22;;5051:4;5043:13;;5039:27;-1:-1:-1;5029:55:1;;5080:1;5077;5070:12;5029:55;5116:2;5103:16;5139:60;5155:43;5195:2;5155:43;:::i;5139:60::-;5233:15;;;5315:1;5311:10;;;;5303:19;;5299:28;;;5264:12;;;;5339:19;;;5336:39;;;5371:1;5368;5361:12;5336:39;5395:11;;;;5415:142;5431:6;5426:3;5423:15;5415:142;;;5497:17;;5485:30;;5448:12;;;;5535;;;;5415:142;;;5576:5;5566:15;;;;;;;4628:959;;;;;:::o;5592:248::-;5660:6;5668;5721:2;5709:9;5700:7;5696:23;5692:32;5689:52;;;5737:1;5734;5727:12;5689:52;-1:-1:-1;;5760:23:1;;;5830:2;5815:18;;;5802:32;;-1:-1:-1;5592:248:1:o;5845:247::-;5904:6;5957:2;5945:9;5936:7;5932:23;5928:32;5925:52;;;5973:1;5970;5963:12;5925:52;6012:9;5999:23;6031:31;6056:5;6031:31;:::i;6097:632::-;6268:2;6320:21;;;6390:13;;6293:18;;;6412:22;;;6239:4;;6268:2;6491:15;;;;6465:2;6450:18;;;6239:4;6534:169;6548:6;6545:1;6542:13;6534:169;;;6609:13;;6597:26;;6678:15;;;;6643:12;;;;6570:1;6563:9;6534:169;;;-1:-1:-1;6720:3:1;;6097:632;-1:-1:-1;;;;;;6097:632:1:o;6734:407::-;6799:5;6833:18;6825:6;6822:30;6819:56;;;6855:18;;:::i;:::-;6893:57;6938:2;6917:15;;-1:-1:-1;;6913:29:1;6944:4;6909:40;6893:57;:::i;:::-;6884:66;;6973:6;6966:5;6959:21;7013:3;7004:6;6999:3;6995:16;6992:25;6989:45;;;7030:1;7027;7020:12;6989:45;7079:6;7074:3;7067:4;7060:5;7056:16;7043:43;7133:1;7126:4;7117:6;7110:5;7106:18;7102:29;7095:40;6734:407;;;;;:::o;7146:451::-;7215:6;7268:2;7256:9;7247:7;7243:23;7239:32;7236:52;;;7284:1;7281;7274:12;7236:52;7324:9;7311:23;7357:18;7349:6;7346:30;7343:50;;;7389:1;7386;7379:12;7343:50;7412:22;;7465:4;7457:13;;7453:27;-1:-1:-1;7443:55:1;;7494:1;7491;7484:12;7443:55;7517:74;7583:7;7578:2;7565:16;7560:2;7556;7552:11;7517:74;:::i;7602:416::-;7667:6;7675;7728:2;7716:9;7707:7;7703:23;7699:32;7696:52;;;7744:1;7741;7734:12;7696:52;7783:9;7770:23;7802:31;7827:5;7802:31;:::i;:::-;7852:5;-1:-1:-1;7909:2:1;7894:18;;7881:32;7951:15;;7944:23;7932:36;;7922:64;;7982:1;7979;7972:12;7922:64;8005:7;7995:17;;;7602:416;;;;;:::o;8023:795::-;8118:6;8126;8134;8142;8195:3;8183:9;8174:7;8170:23;8166:33;8163:53;;;8212:1;8209;8202:12;8163:53;8251:9;8238:23;8270:31;8295:5;8270:31;:::i;:::-;8320:5;-1:-1:-1;8377:2:1;8362:18;;8349:32;8390:33;8349:32;8390:33;:::i;:::-;8442:7;-1:-1:-1;8496:2:1;8481:18;;8468:32;;-1:-1:-1;8551:2:1;8536:18;;8523:32;8578:18;8567:30;;8564:50;;;8610:1;8607;8600:12;8564:50;8633:22;;8686:4;8678:13;;8674:27;-1:-1:-1;8664:55:1;;8715:1;8712;8705:12;8664:55;8738:74;8804:7;8799:2;8786:16;8781:2;8777;8773:11;8738:74;:::i;:::-;8728:84;;;8023:795;;;;;;;:::o;9046:388::-;9114:6;9122;9175:2;9163:9;9154:7;9150:23;9146:32;9143:52;;;9191:1;9188;9181:12;9143:52;9230:9;9217:23;9249:31;9274:5;9249:31;:::i;:::-;9299:5;-1:-1:-1;9356:2:1;9341:18;;9328:32;9369:33;9328:32;9369:33;:::i;9439:380::-;9518:1;9514:12;;;;9561;;;9582:61;;9636:4;9628:6;9624:17;9614:27;;9582:61;9689:2;9681:6;9678:14;9658:18;9655:38;9652:161;;9735:10;9730:3;9726:20;9723:1;9716:31;9770:4;9767:1;9760:15;9798:4;9795:1;9788:15;9652:161;;9439:380;;;:::o;11064:356::-;11266:2;11248:21;;;11285:18;;;11278:30;11344:34;11339:2;11324:18;;11317:62;11411:2;11396:18;;11064:356::o;11425:127::-;11486:10;11481:3;11477:20;11474:1;11467:31;11517:4;11514:1;11507:15;11541:4;11538:1;11531:15;11557:881;11652:6;11683:2;11726;11714:9;11705:7;11701:23;11697:32;11694:52;;;11742:1;11739;11732:12;11694:52;11775:9;11769:16;11808:18;11800:6;11797:30;11794:50;;;11840:1;11837;11830:12;11794:50;11863:22;;11916:4;11908:13;;11904:27;-1:-1:-1;11894:55:1;;11945:1;11942;11935:12;11894:55;11974:2;11968:9;11997:60;12013:43;12053:2;12013:43;:::i;11997:60::-;12091:15;;;12173:1;12169:10;;;;12161:19;;12157:28;;;12122:12;;;;12197:19;;;12194:39;;;12229:1;12226;12219:12;12194:39;12253:11;;;;12273:135;12289:6;12284:3;12281:15;12273:135;;;12355:10;;12343:23;;12306:12;;;;12386;;;;12273:135;;12443:352;12645:2;12627:21;;;12684:2;12664:18;;;12657:30;12723;12718:2;12703:18;;12696:58;12786:2;12771:18;;12443:352::o;12800:127::-;12861:10;12856:3;12852:20;12849:1;12842:31;12892:4;12889:1;12882:15;12916:4;12913:1;12906:15;12932:135;12971:3;12992:17;;;12989:43;;13012:18;;:::i;:::-;-1:-1:-1;13059:1:1;13048:13;;12932:135::o;13072:413::-;13274:2;13256:21;;;13313:2;13293:18;;;13286:30;13352:34;13347:2;13332:18;;13325:62;-1:-1:-1;;;13418:2:1;13403:18;;13396:47;13475:3;13460:19;;13072:413::o;15488:251::-;15558:6;15611:2;15599:9;15590:7;15586:23;15582:32;15579:52;;;15627:1;15624;15617:12;15579:52;15659:9;15653:16;15678:31;15703:5;15678:31;:::i;16793:470::-;16972:3;17010:6;17004:13;17026:53;17072:6;17067:3;17060:4;17052:6;17048:17;17026:53;:::i;:::-;17142:13;;17101:16;;;;17164:57;17142:13;17101:16;17198:4;17186:17;;17164:57;:::i;:::-;17237:20;;16793:470;-1:-1:-1;;;;16793:470:1:o;18903:125::-;18943:4;18971:1;18968;18965:8;18962:34;;;18976:18;;:::i;:::-;-1:-1:-1;19013:9:1;;18903:125::o;19033:128::-;19073:3;19104:1;19100:6;19097:1;19094:13;19091:39;;;19110:18;;:::i;:::-;-1:-1:-1;19146:9:1;;19033:128::o;19166:414::-;19368:2;19350:21;;;19407:2;19387:18;;;19380:30;19446:34;19441:2;19426:18;;19419:62;-1:-1:-1;;;19512:2:1;19497:18;;19490:48;19570:3;19555:19;;19166:414::o;19585:127::-;19646:10;19641:3;19637:20;19634:1;19627:31;19677:4;19674:1;19667:15;19701:4;19698:1;19691:15;19717:120;19757:1;19783;19773:35;;19788:18;;:::i;:::-;-1:-1:-1;19822:9:1;;19717:120::o;19842:112::-;19874:1;19900;19890:35;;19905:18;;:::i;:::-;-1:-1:-1;19939:9:1;;19842:112::o;19959:489::-;-1:-1:-1;;;;;20228:15:1;;;20210:34;;20280:15;;20275:2;20260:18;;20253:43;20327:2;20312:18;;20305:34;;;20375:3;20370:2;20355:18;;20348:31;;;20153:4;;20396:46;;20422:19;;20414:6;20396:46;:::i;:::-;20388:54;19959:489;-1:-1:-1;;;;;;19959:489:1:o;20453:249::-;20522:6;20575:2;20563:9;20554:7;20550:23;20546:32;20543:52;;;20591:1;20588;20581:12;20543:52;20623:9;20617:16;20642:30;20666:5;20642:30;:::i;21068:127::-;21129:10;21124:3;21120:20;21117:1;21110:31;21160:4;21157:1;21150:15;21184:4;21181:1;21174:15

ipfs://90fddfd4ddeb69899ad7604bfc9588fc646c62a0019f963979fb514049e0474c