Token CRO Homes

Overview

TokenID:
1712

Transfers:
-

Loading
[ Download CSV Export  ] 
Loading
Loading

Click here to update the token ICO / general information
# Exchange Pair Price  24H Volume % Volume

Contract Source Code Verified (Exact Match)

Contract Name:
CROHOMES

Compiler Version
v0.8.13+commit.abaa5c0e

Optimization Enabled:
Yes with 200 runs

Other Settings:
default evmVersion, MIT license

Contract Source Code (Solidity)

/**
 *Submitted for verification at Etherscan.io on 2022-03-24
*/

// SPDX-License-Identifier: MIT
// File: CROHomes.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;

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

    string private baseURI;

    uint256 public MAX_SUPPLY;
    uint256 public price = 399 ether;
    uint256 public maxMintAmount = 10;
    uint256 public reserved;
    uint256 public maxMintPerTx = 10;
    
    bool public presaleActive = false;
    bool public saleActive = false;

    mapping (address => uint256) public whitelistedAddresses;
    mapping (address => uint256) public addressMintedBalance;
    mapping (uint256 => uint256) public homeSize;


    constructor(string memory name, string memory symbol, uint256 supply, uint256 _reserved) ERC721(name, symbol) {
        MAX_SUPPLY = supply;
        reserved = _reserved;
    }
    
    
    function mint(uint256 _amount) public payable {
        require(saleActive, "The Sale is paused");
        uint256 supply = totalSupply();
        require(_amount > 0 && _amount <= maxMintPerTx,     "Invalid purchase amount");
        require((supply + _amount) <= (MAX_SUPPLY - reserved),   "Purchase would exceed max supply of CRO Homes");
        require(price.mul(_amount) == msg.value,      "CRO value sent is not correct");

            if (presaleActive == true) {
                require(isWhitelisted(msg.sender), "user is not whitelisted");
                uint256 ownerMintedCount = addressMintedBalance[msg.sender];
                uint256 whitelistMaxMintAmount = whitelistedAddresses[msg.sender];
                require(
                    ownerMintedCount + _amount <= whitelistMaxMintAmount, 
                    "max NFT per address exceeded"
                );
            }
            else
            {
                require(
                    _amount <= maxMintAmount, 
                    "max mint amount per session exceeded"
                );
            }

            require(msg.value >= price * _amount, "insufficient funds");
        
        
        for(uint256 i; i < _amount; i++) {
        _safeMint(msg.sender, supply + i);
        addressMintedBalance[msg.sender]++;
        }
    }
    
    function mintReserved(address _to, uint256 _amount) public onlyOwner {
        require( _amount <= reserved, "Can't reserve more than set amount" );
        reserved -= _amount;
        uint256 supply = totalSupply();
        for(uint256 i; i < _amount; i++){
            _safeMint( _to, supply + i );
        }
    }

    function whitelistAddUsers(address[] calldata entries, uint256 maxMint) external onlyOwner {
        for(uint256 i = 0; i < entries.length; i++) {
            address entry = entries[i];
            require(entry != address(0), "NULL_ADDRESS");
            require(!isWhitelisted(entry), "DUPLICATE_ENTRY");

            whitelistedAddresses[entry] = maxMint;
        }
    }

    function whitelistAddUsersDupes(address[] calldata entries, uint256 maxMint) external onlyOwner {
        for(uint256 i = 0; i < entries.length; i++) {
            address entry = entries[i];
            require(entry != address(0), "NULL_ADDRESS");
            whitelistedAddresses[entry] = maxMint;
        }
    }

    function whitelistAddUsersSingle(address _entry, uint256 maxMint) external onlyOwner {
            address entry = _entry;
            require(entry != address(0), "NULL_ADDRESS");
            whitelistedAddresses[entry] = maxMint;
        
    }
    
    function isWhitelisted(address addr) public view returns (bool) {
        uint256 mintAmount = whitelistedAddresses[addr];

        if(mintAmount > 0) return true;

        return false;
    }

    function getMintAllocation(address addr) public view returns (uint256) {
        uint256 allocation = whitelistedAddresses[addr];

        return allocation;
    }

    function getMintedCount(address addr) public view returns (uint256) {
        uint256 mintedCount = addressMintedBalance[addr];

        return mintedCount;
    }

    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;
    }

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

    function setSize(uint256 tokenId, uint256 _homeSize) public onlyOwner{
        homeSize[tokenId] = _homeSize;
    }

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

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

    function withdraw() public onlyOwner {
        uint256 balance = address(this).balance;
        payable(msg.sender).transfer(balance);
    }

    function togglePresale() public onlyOwner {
        presaleActive = !presaleActive;
    }

    function toggleSale() public onlyOwner {
        saleActive = !saleActive;
    }
    
    function setMAXSUPPLY(uint256 newSupply) public onlyOwner {
        MAX_SUPPLY = newSupply;
    }
     
    function setPrice(uint256 newPrice) public onlyOwner {
        price = newPrice;
    }
    
    function setMintLimit(uint256 newMintLimit) public onlyOwner {
        maxMintPerTx = newMintLimit;
    }
    
    function setBaseURI(string memory uri) public onlyOwner {
        baseURI = uri;
    }
    
    function _baseURI() internal view override returns (string memory) {
        return baseURI;
    }
}

Contract Security Audit

Contract ABI

[{"inputs":[{"internalType":"string","name":"name","type":"string"},{"internalType":"string","name":"symbol","type":"string"},{"internalType":"uint256","name":"supply","type":"uint256"},{"internalType":"uint256","name":"_reserved","type":"uint256"}],"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":"MAX_SUPPLY","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"addressMintedBalance","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","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":"address","name":"addr","type":"address"}],"name":"getMintAllocation","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"addr","type":"address"}],"name":"getMintedCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"uint256","name":"","type":"uint256"}],"name":"homeSize","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":"address","name":"addr","type":"address"}],"name":"isWhitelisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMintAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxMintPerTx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_amount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"_to","type":"address"},{"internalType":"uint256","name":"_amount","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":"presaleActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":[],"name":"reserved","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":"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":[],"name":"saleActive","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","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":"uint256","name":"newSupply","type":"uint256"}],"name":"setMAXSUPPLY","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newMintLimit","type":"uint256"}],"name":"setMintLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"newPrice","type":"uint256"}],"name":"setPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"_homeSize","type":"uint256"}],"name":"setSize","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_homeSize","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":"togglePresale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"toggleSale","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"},{"inputs":[{"internalType":"address[]","name":"entries","type":"address[]"},{"internalType":"uint256","name":"maxMint","type":"uint256"}],"name":"whitelistAddUsers","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"entries","type":"address[]"},{"internalType":"uint256","name":"maxMint","type":"uint256"}],"name":"whitelistAddUsersDupes","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_entry","type":"address"},{"internalType":"uint256","name":"maxMint","type":"uint256"}],"name":"whitelistAddUsersSingle","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"whitelistedAddresses","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]

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

Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)

000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c00000000000000000000000000000000000000000000000000000000000000d050000000000000000000000000000000000000000000000000000000000000035000000000000000000000000000000000000000000000000000000000000000943524f20486f6d65730000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000543484f4d45000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : name (string): CRO Homes
Arg [1] : symbol (string): CHOME
Arg [2] : supply (uint256): 3333
Arg [3] : _reserved (uint256): 53

-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000d05
Arg [3] : 0000000000000000000000000000000000000000000000000000000000000035
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000009
Arg [5] : 43524f20486f6d65730000000000000000000000000000000000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [7] : 43484f4d45000000000000000000000000000000000000000000000000000000


Deployed ByteCode Sourcemap

50372:5814:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55652:99;;;;;;;;;;-1:-1:-1;55652:99:0;;;;;:::i;:::-;;:::i;:::-;;38257:224;;;;;;;;;;-1:-1:-1;38257:224:0;;;;;:::i;:::-;;:::i;:::-;;;750:14:1;;743:22;725:41;;713:2;698:18;38257:224:0;;;;;;;;55163:137;;;;;;;;;;-1:-1:-1;55163:137:0;;;;;:::i;:::-;55220:7;55254:17;;;:8;:17;;;;;;;55163:137;;;;923:25:1;;;911:2;896:18;55163:137:0;777:177:1;50789:56:0;;;;;;;;;;-1:-1:-1;50789:56:0;;;;;:::i;:::-;;;;;;;;;;;;;;25385:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;26944:221::-;;;;;;;;;;-1:-1:-1;26944:221:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;2243:32:1;;;2225:51;;2213:2;2198:18;26944:221:0;2079:203:1;26467:411:0;;;;;;;;;;-1:-1:-1;26467:411:0;;;;;:::i;:::-;;:::i;38897:113::-;;;;;;;;;;-1:-1:-1;38985:10:0;:17;38897:113;;50852:56;;;;;;;;;;-1:-1:-1;50852:56:0;;;;;:::i;:::-;;;;;;;;;;;;;;50595:33;;;;;;;;;;;;;;;;27834:339;;;;;;;;;;-1:-1:-1;27834:339:0;;;;;:::i;:::-;;:::i;38565:256::-;;;;;;;;;;-1:-1:-1;38565:256:0;;;;;:::i;:::-;;:::i;50524:25::-;;;;;;;;;;;;;;;;54957:198;;;;;;;;;;-1:-1:-1;54957:198:0;;;;;:::i;:::-;;:::i;54832:117::-;;;;;;;;;;-1:-1:-1;54832:117:0;;;;;:::i;:::-;;:::i;55459:91::-;;;;;;;;;;;;;:::i;53853:198::-;;;;;;;;;;-1:-1:-1;53853:198:0;;;;;:::i;:::-;;:::i;55308:143::-;;;;;;;;;;;;;:::i;28244:185::-;;;;;;;;;;-1:-1:-1;28244:185:0;;;;;:::i;:::-;;:::i;54408:341::-;;;;;;;;;;-1:-1:-1;54408:341:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;39087:233::-;;;;;;;;;;-1:-1:-1;39087:233:0;;;;;:::i;:::-;;:::i;50710:33::-;;;;;;;;;;-1:-1:-1;50710:33:0;;;;;;;;55983:88;;;;;;;;;;-1:-1:-1;55983:88:0;;;;;:::i;:::-;;:::i;25079:239::-;;;;;;;;;;-1:-1:-1;25079:239:0;;;;;:::i;:::-;;:::i;50750:30::-;;;;;;;;;;-1:-1:-1;50750:30:0;;;;;;;;;;;24809:208;;;;;;;;;;-1:-1:-1;24809:208:0;;;;;:::i;:::-;;:::i;9845:94::-;;;;;;;;;;;;;:::i;50915:44::-;;;;;;;;;;-1:-1:-1;50915:44:0;;;;;:::i;:::-;;;;;;;;;;;;;;55558:82;;;;;;;;;;;;;:::i;52537:324::-;;;;;;;;;;-1:-1:-1;52537:324:0;;;;;:::i;:::-;;:::i;54059:167::-;;;;;;;;;;-1:-1:-1;54059:167:0;;;;;:::i;:::-;-1:-1:-1;;;;;54162:26:0;54121:7;54162:26;;;:20;:26;;;;;;;54059:167;9194:87;;;;;;;;;;-1:-1:-1;9267:6:0;;-1:-1:-1;;;;;9267:6:0;9194:87;;55764:88;;;;;;;;;;-1:-1:-1;55764:88:0;;;;;:::i;:::-;;:::i;25554:104::-;;;;;;;;;;;;;:::i;54234:166::-;;;;;;;;;;-1:-1:-1;54234:166:0;;;;;:::i;:::-;-1:-1:-1;;;;;54335:26:0;54293:7;54335:26;;;:20;:26;;;;;;;54234:166;53590:251;;;;;;;;;;-1:-1:-1;53590:251:0;;;;;:::i;:::-;;:::i;55864:107::-;;;;;;;;;;-1:-1:-1;55864:107:0;;;;;:::i;:::-;;:::i;50556:32::-;;;;;;;;;;;;;;;;51167:1358;;;;;;:::i;:::-;;:::i;27237:295::-;;;;;;;;;;-1:-1:-1;27237:295:0;;;;;:::i;:::-;;:::i;28500:328::-;;;;;;;;;;-1:-1:-1;28500:328:0;;;;;:::i;:::-;;:::i;25729:334::-;;;;;;;;;;-1:-1:-1;25729:334:0;;;;;:::i;:::-;;:::i;52869:383::-;;;;;;;;;;-1:-1:-1;52869:383:0;;;;;:::i;:::-;;:::i;50665:32::-;;;;;;;;;;;;;;;;53260:322;;;;;;;;;;-1:-1:-1;53260:322:0;;;;;:::i;:::-;;:::i;27603:164::-;;;;;;;;;;-1:-1:-1;27603:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;27724:25:0;;;27700:4;27724:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;27603:164;10094:192;;;;;;;;;;-1:-1:-1;10094:192:0;;;;;:::i;:::-;;:::i;50635:23::-;;;;;;;;;;;;;;;;55652:99;9267:6;;-1:-1:-1;;;;;9267:6:0;8150:10;9414:23;9406:68;;;;-1:-1:-1;;;9406:68:0;;;;;;;:::i;:::-;;;;;;;;;55721:10:::1;:22:::0;55652:99::o;38257:224::-;38359:4;-1:-1:-1;;;;;;38383:50:0;;-1:-1:-1;;;38383:50:0;;:90;;;38437:36;38461:11;38437:23;:36::i;:::-;38376:97;38257:224;-1:-1:-1;;38257:224:0:o;25385:100::-;25439:13;25472:5;25465:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;25385:100;:::o;26944:221::-;27020:7;30427:16;;;:7;:16;;;;;;-1:-1:-1;;;;;30427:16:0;27040:73;;;;-1:-1:-1;;;27040:73:0;;8999:2:1;27040:73:0;;;8981:21:1;9038:2;9018:18;;;9011:30;9077:34;9057:18;;;9050:62;-1:-1:-1;;;9128:18:1;;;9121:42;9180:19;;27040:73:0;8797:408:1;27040:73:0;-1:-1:-1;27133:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;27133:24:0;;26944:221::o;26467:411::-;26548:13;26564:23;26579:7;26564:14;:23::i;:::-;26548:39;;26612:5;-1:-1:-1;;;;;26606:11:0;:2;-1:-1:-1;;;;;26606:11:0;;26598:57;;;;-1:-1:-1;;;26598:57:0;;9412:2:1;26598:57:0;;;9394:21:1;9451:2;9431:18;;;9424:30;9490:34;9470:18;;;9463:62;-1:-1:-1;;;9541:18:1;;;9534:31;9582:19;;26598:57:0;9210:397:1;26598:57:0;8150:10;-1:-1:-1;;;;;26690:21:0;;;;:62;;-1:-1:-1;26715:37:0;26732:5;8150:10;27603:164;:::i;26715:37::-;26668:168;;;;-1:-1:-1;;;26668:168:0;;9814:2:1;26668:168:0;;;9796:21:1;9853:2;9833:18;;;9826:30;9892:34;9872:18;;;9865:62;9963:26;9943:18;;;9936:54;10007:19;;26668:168:0;9612:420:1;26668:168:0;26849:21;26858:2;26862:7;26849:8;:21::i;:::-;26537:341;26467:411;;:::o;27834:339::-;28029:41;8150:10;28062:7;28029:18;:41::i;:::-;28021:103;;;;-1:-1:-1;;;28021:103:0;;;;;;;:::i;:::-;28137:28;28147:4;28153:2;28157:7;28137:9;:28::i;38565:256::-;38662:7;38698:23;38715:5;38698:16;:23::i;:::-;38690:5;:31;38682:87;;;;-1:-1:-1;;;38682:87:0;;10657:2:1;38682:87:0;;;10639:21:1;10696:2;10676:18;;;10669:30;10735:34;10715:18;;;10708:62;-1:-1:-1;;;10786:18:1;;;10779:41;10837:19;;38682:87:0;10455:407:1;38682:87:0;-1:-1:-1;;;;;;38787:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;38565:256::o;54957:198::-;9267:6;;-1:-1:-1;;;;;9267:6:0;8150:10;9414:23;9406:68;;;;-1:-1:-1;;;9406:68:0;;;;;;;:::i;:::-;55056:9:::1;55052:96;55075:7;:14;55071:1;:18;55052:96;;;55129:9;55106:8;:20;55115:7;55123:1;55115:10;;;;;;;;:::i;:::-;;;;;;;55106:20;;;;;;;;;;;:32;;;;55091:3;;;;;:::i;:::-;;;;55052:96;;54832:117:::0;9267:6;;-1:-1:-1;;;;;9267:6:0;8150:10;9414:23;9406:68;;;;-1:-1:-1;;;9406:68:0;;;;;;;:::i;:::-;54912:17:::1;::::0;;;:8:::1;:17;::::0;;;;;:29;54832:117::o;55459:91::-;9267:6;;-1:-1:-1;;;;;9267:6:0;8150:10;9414:23;9406:68;;;;-1:-1:-1;;;9406:68:0;;;;;;;:::i;:::-;55529:13:::1;::::0;;-1:-1:-1;;55512:30:0;::::1;55529:13;::::0;;::::1;55528:14;55512:30;::::0;;55459:91::o;53853:198::-;-1:-1:-1;;;;;53949:26:0;;53911:4;53949:26;;;:20;:26;;;;;;53991:14;;53988:30;;-1:-1:-1;54014:4:0;;53853:198;-1:-1:-1;;53853:198:0:o;53988:30::-;-1:-1:-1;54038:5:0;;53853:198;-1:-1:-1;;53853:198:0:o;55308:143::-;9267:6;;-1:-1:-1;;;;;9267:6:0;8150:10;9414:23;9406:68;;;;-1:-1:-1;;;9406:68:0;;;;;;;:::i;:::-;55406:37:::1;::::0;55374:21:::1;::::0;55414:10:::1;::::0;55406:37;::::1;;;::::0;55374:21;;55356:15:::1;55406:37:::0;55356:15;55406:37;55374:21;55414:10;55406:37;::::1;;;;;;;;;;;;;::::0;::::1;;;;;;55345:106;55308:143::o:0;28244:185::-;28382:39;28399:4;28405:2;28409:7;28382:39;;;;;;;;;;;;:16;:39::i;54408:341::-;54468:16;54497:18;54518:16;54528:5;54518:9;:16::i;:::-;54497:37;;54547:25;54589:10;54575:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;54575:25:0;;54547:53;;54615:9;54611:105;54630:10;54626:1;:14;54611:105;;;54675:29;54695:5;54702:1;54675:19;:29::i;:::-;54661:8;54670:1;54661:11;;;;;;;;:::i;:::-;;;;;;;;;;:43;54642:3;;;;:::i;:::-;;;;54611:105;;;-1:-1:-1;54733:8:0;54408:341;-1:-1:-1;;;54408:341:0:o;39087:233::-;39162:7;39198:30;38985:10;:17;;38897:113;39198:30;39190:5;:38;39182:95;;;;-1:-1:-1;;;39182:95:0;;11473:2:1;39182:95:0;;;11455:21:1;11512:2;11492:18;;;11485:30;11551:34;11531:18;;;11524:62;-1:-1:-1;;;11602:18:1;;;11595:42;11654:19;;39182:95:0;11271:408:1;39182:95:0;39295:10;39306:5;39295:17;;;;;;;;:::i;:::-;;;;;;;;;39288:24;;39087:233;;;:::o;55983:88::-;9267:6;;-1:-1:-1;;;;;9267:6:0;8150:10;9414:23;9406:68;;;;-1:-1:-1;;;9406:68:0;;;;;;;:::i;:::-;56050:13;;::::1;::::0;:7:::1;::::0;:13:::1;::::0;::::1;::::0;::::1;:::i;25079:239::-:0;25151:7;25187:16;;;:7;:16;;;;;;-1:-1:-1;;;;;25187:16:0;;25214:73;;;;-1:-1:-1;;;25214:73:0;;11886:2:1;25214:73:0;;;11868:21:1;11925:2;11905:18;;;11898:30;11964:34;11944:18;;;11937:62;-1:-1:-1;;;12015:18:1;;;12008:39;12064:19;;25214:73:0;11684:405:1;24809:208:0;24881:7;-1:-1:-1;;;;;24909:19:0;;24901:74;;;;-1:-1:-1;;;24901:74:0;;12296:2:1;24901:74:0;;;12278:21:1;12335:2;12315:18;;;12308:30;12374:34;12354:18;;;12347:62;-1:-1:-1;;;12425:18:1;;;12418:40;12475:19;;24901:74:0;12094:406:1;24901:74:0;-1:-1:-1;;;;;;24993:16:0;;;;;:9;:16;;;;;;;24809:208::o;9845:94::-;9267:6;;-1:-1:-1;;;;;9267:6:0;8150:10;9414:23;9406:68;;;;-1:-1:-1;;;9406:68:0;;;;;;;:::i;:::-;9910:21:::1;9928:1;9910:9;:21::i;:::-;9845:94::o:0;55558:82::-;9267:6;;-1:-1:-1;;;;;9267:6:0;8150:10;9414:23;9406:68;;;;-1:-1:-1;;;9406:68:0;;;;;;;:::i;:::-;55622:10:::1;::::0;;-1:-1:-1;;55608:24:0;::::1;55622:10;::::0;;;::::1;;;55621:11;55608:24:::0;;::::1;;::::0;;55558:82::o;52537:324::-;9267:6;;-1:-1:-1;;;;;9267:6:0;8150:10;9414:23;9406:68;;;;-1:-1:-1;;;9406:68:0;;;;;;;:::i;:::-;52637:8:::1;;52626:7;:19;;52617:68;;;::::0;-1:-1:-1;;;52617:68:0;;12707:2:1;52617:68:0::1;::::0;::::1;12689:21:1::0;12746:2;12726:18;;;12719:30;12785:34;12765:18;;;12758:62;-1:-1:-1;;;12836:18:1;;;12829:32;12878:19;;52617:68:0::1;12505:398:1::0;52617:68:0::1;52708:7;52696:8;;:19;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;;38985:10:0;:17;52771:9:::1;52767:87;52786:7;52782:1;:11;52767:87;;;52814:28;52825:3:::0;52830:10:::1;52839:1:::0;52830:6;:10:::1;:::i;:::-;52814:9;:28::i;:::-;52795:3:::0;::::1;::::0;::::1;:::i;:::-;;;;52767:87;;;;52606:255;52537:324:::0;;:::o;55764:88::-;9267:6;;-1:-1:-1;;;;;9267:6:0;8150:10;9414:23;9406:68;;;;-1:-1:-1;;;9406:68:0;;;;;;;:::i;:::-;55828:5:::1;:16:::0;55764:88::o;25554:104::-;25610:13;25643:7;25636:14;;;;;:::i;53590:251::-;9267:6;;-1:-1:-1;;;;;9267:6:0;8150:10;9414:23;9406:68;;;;-1:-1:-1;;;9406:68:0;;;;;;;:::i;:::-;53706:6;-1:-1:-1;;;;;53735:19:0;::::1;53727:44;;;;-1:-1:-1::0;;;53727:44:0::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;53786:27:0::1;;::::0;;;:20:::1;:27;::::0;;;;:37;-1:-1:-1;53590:251:0:o;55864:107::-;9267:6;;-1:-1:-1;;;;;9267:6:0;8150:10;9414:23;9406:68;;;;-1:-1:-1;;;9406:68:0;;;;;;;:::i;:::-;55936:12:::1;:27:::0;55864:107::o;51167:1358::-;51232:10;;;;;;;51224:41;;;;-1:-1:-1;;;51224:41:0;;13714:2:1;51224:41:0;;;13696:21:1;13753:2;13733:18;;;13726:30;-1:-1:-1;;;13772:18:1;;;13765:48;13830:18;;51224:41:0;13512:342:1;51224:41:0;51276:14;51293:13;38985:10;:17;;38897:113;51293:13;51276:30;;51335:1;51325:7;:11;:38;;;;;51351:12;;51340:7;:23;;51325:38;51317:78;;;;-1:-1:-1;;;51317:78:0;;14061:2:1;51317:78:0;;;14043:21:1;14100:2;14080:18;;;14073:30;14139:25;14119:18;;;14112:53;14182:18;;51317:78:0;13859:347:1;51317:78:0;51450:8;;51437:10;;:21;;;;:::i;:::-;51415:16;51424:7;51415:6;:16;:::i;:::-;51414:45;;51406:105;;;;-1:-1:-1;;;51406:105:0;;14413:2:1;51406:105:0;;;14395:21:1;14452:2;14432:18;;;14425:30;14491:34;14471:18;;;14464:62;-1:-1:-1;;;14542:18:1;;;14535:43;14595:19;;51406:105:0;14211:409:1;51406:105:0;51530:5;;51552:9;;51530:18;;51540:7;51530:9;:18::i;:::-;:31;51522:78;;;;-1:-1:-1;;;51522:78:0;;14827:2:1;51522:78:0;;;14809:21:1;14866:2;14846:18;;;14839:30;14905:31;14885:18;;;14878:59;14954:18;;51522:78:0;14625:353:1;51522:78:0;51621:13;;;;:21;;:13;:21;51617:661;;51671:25;51685:10;51671:13;:25::i;:::-;51663:61;;;;-1:-1:-1;;;51663:61:0;;15185:2:1;51663:61:0;;;15167:21:1;15224:2;15204:18;;;15197:30;15263:25;15243:18;;;15236:53;15306:18;;51663:61:0;14983:347:1;51663:61:0;51791:10;51743:24;51770:32;;;:20;:32;;;;;;;;;51854:20;:32;;;;;;;;51935:26;51954:7;51770:32;51935:26;:::i;:::-;:52;;51905:155;;;;-1:-1:-1;;;51905:155:0;;15537:2:1;51905:155:0;;;15519:21:1;15576:2;15556:18;;;15549:30;15615;15595:18;;;15588:58;15663:18;;51905:155:0;15335:352:1;51905:155:0;51644:432;;51617:661;;;52168:13;;52157:7;:24;;52127:135;;;;-1:-1:-1;;;52127:135:0;;15894:2:1;52127:135:0;;;15876:21:1;15933:2;15913:18;;;15906:30;15972:34;15952:18;;;15945:62;-1:-1:-1;;;16023:18:1;;;16016:34;16067:19;;52127:135:0;15692:400:1;52127:135:0;52323:7;52315:5;;:15;;;;:::i;:::-;52302:9;:28;;52294:59;;;;-1:-1:-1;;;52294:59:0;;16472:2:1;52294:59:0;;;16454:21:1;16511:2;16491:18;;;16484:30;-1:-1:-1;;;16530:18:1;;;16523:48;16588:18;;52294:59:0;16270:342:1;52294:59:0;52388:9;52384:134;52403:7;52399:1;:11;52384:134;;;52428:33;52438:10;52450;52459:1;52450:6;:10;:::i;52428:33::-;52493:10;52472:32;;;;:20;:32;;;;;:34;;;;;;:::i;:::-;;;;;;52412:3;;;;;:::i;:::-;;;;52384:134;;27237:295;8150:10;-1:-1:-1;;;;;27340:24:0;;;27332:62;;;;-1:-1:-1;;;27332:62:0;;16819:2:1;27332:62:0;;;16801:21:1;16858:2;16838:18;;;16831:30;16897:27;16877:18;;;16870:55;16942:18;;27332:62:0;16617:349:1;27332:62:0;8150:10;27407:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;27407:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;27407:53:0;;;;;;;;;;27476:48;;725:41:1;;;27407:42:0;;8150:10;27476:48;;698:18:1;27476:48:0;;;;;;;27237:295;;:::o;28500:328::-;28675:41;8150:10;28708:7;28675:18;:41::i;:::-;28667:103;;;;-1:-1:-1;;;28667:103:0;;;;;;;:::i;:::-;28781:39;28795:4;28801:2;28805:7;28814:5;28781:13;:39::i;25729:334::-;30403:4;30427:16;;;:7;:16;;;;;;25802:13;;-1:-1:-1;;;;;30427:16:0;25828:76;;;;-1:-1:-1;;;25828:76:0;;17173:2:1;25828:76:0;;;17155:21:1;17212:2;17192:18;;;17185:30;17251:34;17231:18;;;17224:62;-1:-1:-1;;;17302:18:1;;;17295:45;17357:19;;25828:76:0;16971:411:1;25828:76:0;25917:21;25941:10;:8;:10::i;:::-;25917:34;;25993:1;25975:7;25969:21;:25;:86;;;;;;;;;;;;;;;;;26021:7;26030:18;:7;:16;:18::i;:::-;26004:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;25969:86;25962:93;25729:334;-1:-1:-1;;;25729:334:0:o;52869:383::-;9267:6;;-1:-1:-1;;;;;9267:6:0;8150:10;9414:23;9406:68;;;;-1:-1:-1;;;9406:68:0;;;;;;;:::i;:::-;52975:9:::1;52971:274;52990:18:::0;;::::1;52971:274;;;53030:13;53046:7;;53054:1;53046:10;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;53030:26:::0;-1:-1:-1;;;;;;53079:19:0;::::1;53071:44;;;;-1:-1:-1::0;;;53071:44:0::1;;;;;;;:::i;:::-;53139:20;53153:5;53139:13;:20::i;:::-;53138:21;53130:49;;;::::0;-1:-1:-1;;;53130:49:0;;18064:2:1;53130:49:0::1;::::0;::::1;18046:21:1::0;18103:2;18083:18;;;18076:30;-1:-1:-1;;;18122:18:1;;;18115:45;18177:18;;53130:49:0::1;17862:339:1::0;53130:49:0::1;-1:-1:-1::0;;;;;53196:27:0::1;;::::0;;;:20:::1;:27;::::0;;;;:37;;;53010:3;::::1;::::0;::::1;:::i;:::-;;;;52971:274;;53260:322:::0;9267:6;;-1:-1:-1;;;;;9267:6:0;8150:10;9414:23;9406:68;;;;-1:-1:-1;;;9406:68:0;;;;;;;:::i;:::-;53371:9:::1;53367:208;53386:18:::0;;::::1;53367:208;;;53426:13;53442:7;;53450:1;53442:10;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;53426:26:::0;-1:-1:-1;;;;;;53475:19:0;::::1;53467:44;;;;-1:-1:-1::0;;;53467:44:0::1;;;;;;;:::i;:::-;-1:-1:-1::0;;;;;53526:27:0::1;;::::0;;;:20:::1;:27;::::0;;;;:37;;;53406:3;::::1;::::0;::::1;:::i;:::-;;;;53367:208;;10094:192:::0;9267:6;;-1:-1:-1;;;;;9267:6:0;8150:10;9414:23;9406:68;;;;-1:-1:-1;;;9406:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;10183:22:0;::::1;10175:73;;;::::0;-1:-1:-1;;;10175:73:0;;18408:2:1;10175:73:0::1;::::0;::::1;18390:21:1::0;18447:2;18427:18;;;18420:30;18486:34;18466:18;;;18459:62;-1:-1:-1;;;18537:18:1;;;18530:36;18583:19;;10175:73:0::1;18206:402:1::0;10175:73:0::1;10259:19;10269:8;10259:9;:19::i;:::-;10094:192:::0;:::o;24440:305::-;24542:4;-1:-1:-1;;;;;;24579:40:0;;-1:-1:-1;;;24579:40:0;;:105;;-1:-1:-1;;;;;;;24636:48:0;;-1:-1:-1;;;24636:48:0;24579:105;:158;;;-1:-1:-1;;;;;;;;;;23158:40:0;;;24701:36;23049:157;34320:174;34395:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;34395:29:0;-1:-1:-1;;;;;34395:29:0;;;;;;;;:24;;34449:23;34395:24;34449:14;:23::i;:::-;-1:-1:-1;;;;;34440:46:0;;;;;;;;;;;34320:174;;:::o;30632:348::-;30725:4;30427:16;;;:7;:16;;;;;;-1:-1:-1;;;;;30427:16:0;30742:73;;;;-1:-1:-1;;;30742:73:0;;18815:2:1;30742:73:0;;;18797:21:1;18854:2;18834:18;;;18827:30;18893:34;18873:18;;;18866:62;-1:-1:-1;;;18944:18:1;;;18937:42;18996:19;;30742:73:0;18613:408:1;30742:73:0;30826:13;30842:23;30857:7;30842:14;:23::i;:::-;30826:39;;30895:5;-1:-1:-1;;;;;30884:16:0;:7;-1:-1:-1;;;;;30884:16:0;;:51;;;;30928:7;-1:-1:-1;;;;;30904:31:0;:20;30916:7;30904:11;:20::i;:::-;-1:-1:-1;;;;;30904:31:0;;30884:51;:87;;;-1:-1:-1;;;;;;27724:25:0;;;27700:4;27724:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;30939:32;30876:96;30632:348;-1:-1:-1;;;;30632:348:0:o;33624:578::-;33783:4;-1:-1:-1;;;;;33756:31:0;:23;33771:7;33756:14;:23::i;:::-;-1:-1:-1;;;;;33756:31:0;;33748:85;;;;-1:-1:-1;;;33748:85:0;;19228:2:1;33748:85:0;;;19210:21:1;19267:2;19247:18;;;19240:30;19306:34;19286:18;;;19279:62;-1:-1:-1;;;19357:18:1;;;19350:39;19406:19;;33748:85:0;19026:405:1;33748:85:0;-1:-1:-1;;;;;33852:16:0;;33844:65;;;;-1:-1:-1;;;33844:65:0;;19638:2:1;33844:65:0;;;19620:21:1;19677:2;19657:18;;;19650:30;19716:34;19696:18;;;19689:62;-1:-1:-1;;;19767:18:1;;;19760:34;19811:19;;33844:65:0;19436:400:1;33844:65:0;33922:39;33943:4;33949:2;33953:7;33922:20;:39::i;:::-;34026:29;34043:1;34047:7;34026:8;:29::i;:::-;-1:-1:-1;;;;;34068:15:0;;;;;;:9;:15;;;;;:20;;34087:1;;34068:15;:20;;34087:1;;34068:20;:::i;:::-;;;;-1:-1:-1;;;;;;;34099:13:0;;;;;;:9;:13;;;;;:18;;34116:1;;34099:13;:18;;34116:1;;34099:18;:::i;:::-;;;;-1:-1:-1;;34128:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;34128:21:0;-1:-1:-1;;;;;34128:21:0;;;;;;;;;34167:27;;34128:16;;34167:27;;;;;;;33624:578;;;:::o;10294:173::-;10369:6;;;-1:-1:-1;;;;;10386:17:0;;;-1:-1:-1;;;;;;10386:17:0;;;;;;;10419:40;;10369:6;;;10386:17;10369:6;;10419:40;;10350:16;;10419:40;10339:128;10294:173;:::o;31322:110::-;31398:26;31408:2;31412:7;31398:26;;;;;;;;;;;;:9;:26::i;47871:98::-;47929:7;47956:5;47960:1;47956;:5;:::i;29710:315::-;29867:28;29877:4;29883:2;29887:7;29867:9;:28::i;:::-;29914:48;29937:4;29943:2;29947:7;29956:5;29914:22;:48::i;:::-;29906:111;;;;-1:-1:-1;;;29906:111:0;;;;;;;:::i;56083:100::-;56135:13;56168:7;56161:14;;;;;:::i;5772:723::-;5828:13;6049:5;6058:1;6049:10;6045:53;;-1:-1:-1;;6076:10:0;;;;;;;;;;;;-1:-1:-1;;;6076:10:0;;;;;5772:723::o;6045:53::-;6123:5;6108:12;6164:78;6171:9;;6164:78;;6197:8;;;;:::i;:::-;;-1:-1:-1;6220:10:0;;-1:-1:-1;6228:2:0;6220:10;;:::i;:::-;;;6164:78;;;6252:19;6284:6;6274:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;6274:17:0;;6252:39;;6302:154;6309:10;;6302:154;;6336:11;6346:1;6336:11;;:::i;:::-;;-1:-1:-1;6405:10:0;6413:2;6405:5;:10;:::i;:::-;6392:24;;:2;:24;:::i;:::-;6379:39;;6362:6;6369;6362:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;6362:56:0;;;;;;;;-1:-1:-1;6433:11:0;6442:2;6433:11;;:::i;:::-;;;6302:154;;39933:589;-1:-1:-1;;;;;40139:18:0;;40135:187;;40174:40;40206:7;41349:10;:17;;41322:24;;;;:15;:24;;;;;:44;;;41377:24;;;;;;;;;;;;41245:164;40174:40;40135:187;;;40244:2;-1:-1:-1;;;;;40236:10:0;:4;-1:-1:-1;;;;;40236:10:0;;40232:90;;40263:47;40296:4;40302:7;40263:32;:47::i;:::-;-1:-1:-1;;;;;40336:16:0;;40332:183;;40369:45;40406:7;40369:36;:45::i;40332:183::-;40442:4;-1:-1:-1;;;;;40436:10:0;:2;-1:-1:-1;;;;;40436:10:0;;40432:83;;40463:40;40491:2;40495:7;40463:27;:40::i;31659:321::-;31789:18;31795:2;31799:7;31789:5;:18::i;:::-;31840:54;31871:1;31875:2;31879:7;31888:5;31840:22;:54::i;:::-;31818:154;;;;-1:-1:-1;;;31818:154:0;;;;;;;:::i;35059:803::-;35214:4;-1:-1:-1;;;;;35235:13:0;;15556:20;15604:8;35231:624;;35271:72;;-1:-1:-1;;;35271:72:0;;-1:-1:-1;;;;;35271:36:0;;;;;:72;;8150:10;;35322:4;;35328:7;;35337:5;;35271:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;35271:72:0;;;;;;;;-1:-1:-1;;35271:72:0;;;;;;;;;;;;:::i;:::-;;;35267:533;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35517:6;:13;35534:1;35517:18;35513:272;;35560:60;;-1:-1:-1;;;35560:60:0;;;;;;;:::i;35513:272::-;35735:6;35729:13;35720:6;35716:2;35712:15;35705:38;35267:533;-1:-1:-1;;;;;;35394:55:0;-1:-1:-1;;;35394:55:0;;-1:-1:-1;35387:62:0;;35231:624;-1:-1:-1;35839:4:0;35059:803;;;;;;:::o;42036:988::-;42302:22;42352:1;42327:22;42344:4;42327:16;:22::i;:::-;:26;;;;:::i;:::-;42364:18;42385:26;;;:17;:26;;;;;;42302:51;;-1:-1:-1;42518:28:0;;;42514:328;;-1:-1:-1;;;;;42585:18:0;;42563:19;42585:18;;;:12;:18;;;;;;;;:34;;;;;;;;;42636:30;;;;;;:44;;;42753:30;;:17;:30;;;;;:43;;;42514:328;-1:-1:-1;42938:26:0;;;;:17;:26;;;;;;;;42931:33;;;-1:-1:-1;;;;;42982:18:0;;;;;:12;:18;;;;;:34;;;;;;;42975:41;42036:988::o;43319:1079::-;43597:10;:17;43572:22;;43597:21;;43617:1;;43597:21;:::i;:::-;43629:18;43650:24;;;:15;:24;;;;;;44023:10;:26;;43572:46;;-1:-1:-1;43650:24:0;;43572:46;;44023:26;;;;;;:::i;:::-;;;;;;;;;44001:48;;44087:11;44062:10;44073;44062:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;44167:28;;;:15;:28;;;;;;;:41;;;44339:24;;;;;44332:31;44374:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;43390:1008;;;43319:1079;:::o;40823:221::-;40908:14;40925:20;40942:2;40925:16;:20::i;:::-;-1:-1:-1;;;;;40956:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;41001:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;40823:221:0:o;32316:382::-;-1:-1:-1;;;;;32396:16:0;;32388:61;;;;-1:-1:-1;;;32388:61:0;;21716:2:1;32388:61:0;;;21698:21:1;;;21735:18;;;21728:30;21794:34;21774:18;;;21767:62;21846:18;;32388:61:0;21514:356:1;32388:61:0;30403:4;30427:16;;;:7;:16;;;;;;-1:-1:-1;;;;;30427:16:0;:30;32460:58;;;;-1:-1:-1;;;32460:58:0;;22077:2:1;32460:58:0;;;22059:21:1;22116:2;22096:18;;;22089:30;22155;22135:18;;;22128:58;22203:18;;32460:58:0;21875:352:1;32460:58:0;32531:45;32560:1;32564:2;32568:7;32531:20;:45::i;:::-;-1:-1:-1;;;;;32589:13:0;;;;;;:9;:13;;;;;:18;;32606:1;;32589:13;:18;;32606:1;;32589:18;:::i;:::-;;;;-1:-1:-1;;32618:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;32618:21:0;-1:-1:-1;;;;;32618:21:0;;;;;;;;32657:33;;32618:16;;;32657:33;;32618:16;;32657:33;32316:382;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:180:1;73:6;126:2;114:9;105:7;101:23;97:32;94:52;;;142:1;139;132:12;94:52;-1:-1:-1;165:23:1;;14:180;-1:-1:-1;14:180:1:o;199:131::-;-1:-1:-1;;;;;;273:32:1;;263:43;;253:71;;320:1;317;310:12;335:245;393:6;446:2;434:9;425:7;421:23;417:32;414:52;;;462:1;459;452:12;414:52;501:9;488:23;520:30;544:5;520:30;:::i;959:173::-;1027:20;;-1:-1:-1;;;;;1076:31:1;;1066:42;;1056:70;;1122:1;1119;1112:12;1056:70;959:173;;;:::o;1137:186::-;1196:6;1249:2;1237:9;1228:7;1224:23;1220:32;1217:52;;;1265:1;1262;1255:12;1217:52;1288:29;1307:9;1288:29;:::i;1328:258::-;1400:1;1410:113;1424:6;1421:1;1418:13;1410:113;;;1500:11;;;1494:18;1481:11;;;1474:39;1446:2;1439:10;1410:113;;;1541:6;1538:1;1535:13;1532:48;;;-1:-1:-1;;1576:1:1;1558:16;;1551:27;1328:258::o;1591:::-;1633:3;1671:5;1665:12;1698:6;1693:3;1686:19;1714:63;1770:6;1763:4;1758:3;1754:14;1747:4;1740:5;1736:16;1714:63;:::i;:::-;1831:2;1810:15;-1:-1:-1;;1806:29:1;1797:39;;;;1838:4;1793:50;;1591:258;-1:-1:-1;;1591:258:1:o;1854:220::-;2003:2;1992:9;1985:21;1966:4;2023:45;2064:2;2053:9;2049:18;2041:6;2023:45;:::i;2287:254::-;2355:6;2363;2416:2;2404:9;2395:7;2391:23;2387:32;2384:52;;;2432:1;2429;2422:12;2384:52;2455:29;2474:9;2455:29;:::i;:::-;2445:39;2531:2;2516:18;;;;2503:32;;-1:-1:-1;;;2287:254:1:o;2546:328::-;2623:6;2631;2639;2692:2;2680:9;2671:7;2667:23;2663:32;2660:52;;;2708:1;2705;2698:12;2660:52;2731:29;2750:9;2731:29;:::i;:::-;2721:39;;2779:38;2813:2;2802:9;2798:18;2779:38;:::i;:::-;2769:48;;2864:2;2853:9;2849:18;2836:32;2826:42;;2546:328;;;;;:::o;2879:127::-;2940:10;2935:3;2931:20;2928:1;2921:31;2971:4;2968:1;2961:15;2995:4;2992:1;2985:15;3011:275;3082:2;3076:9;3147:2;3128:13;;-1:-1:-1;;3124:27:1;3112:40;;3182:18;3167:34;;3203:22;;;3164:62;3161:88;;;3229:18;;:::i;:::-;3265:2;3258:22;3011:275;;-1:-1:-1;3011:275:1:o;3291:1014::-;3384:6;3392;3445:2;3433:9;3424:7;3420:23;3416:32;3413:52;;;3461:1;3458;3451:12;3413:52;3497:9;3484:23;3474:33;;3526:2;3579;3568:9;3564:18;3551:32;3602:18;3643:2;3635:6;3632:14;3629:34;;;3659:1;3656;3649:12;3629:34;3697:6;3686:9;3682:22;3672:32;;3742:7;3735:4;3731:2;3727:13;3723:27;3713:55;;3764:1;3761;3754:12;3713:55;3800:2;3787:16;3822:2;3818;3815:10;3812:36;;;3828:18;;:::i;:::-;3874:2;3871:1;3867:10;3857:20;;3897:28;3921:2;3917;3913:11;3897:28;:::i;:::-;3959:15;;;4029:11;;;4025:20;;;3990:12;;;;4057:19;;;4054:39;;;4089:1;4086;4079:12;4054:39;4113:11;;;;4133:142;4149:6;4144:3;4141:15;4133:142;;;4215:17;;4203:30;;4166:12;;;;4253;;;;4133:142;;;4294:5;4284:15;;;;;;;;3291:1014;;;;;:::o;4310:248::-;4378:6;4386;4439:2;4427:9;4418:7;4414:23;4410:32;4407:52;;;4455:1;4452;4445:12;4407:52;-1:-1:-1;;4478:23:1;;;4548:2;4533:18;;;4520:32;;-1:-1:-1;4310:248:1:o;4563:632::-;4734:2;4786:21;;;4856:13;;4759:18;;;4878:22;;;4705:4;;4734:2;4957:15;;;;4931:2;4916:18;;;4705:4;5000:169;5014:6;5011:1;5008:13;5000:169;;;5075:13;;5063:26;;5144:15;;;;5109:12;;;;5036:1;5029:9;5000:169;;;-1:-1:-1;5186:3:1;;4563:632;-1:-1:-1;;;;;;4563:632:1:o;5200:407::-;5265:5;5299:18;5291:6;5288:30;5285:56;;;5321:18;;:::i;:::-;5359:57;5404:2;5383:15;;-1:-1:-1;;5379:29:1;5410:4;5375:40;5359:57;:::i;:::-;5350:66;;5439:6;5432:5;5425:21;5479:3;5470:6;5465:3;5461:16;5458:25;5455:45;;;5496:1;5493;5486:12;5455:45;5545:6;5540:3;5533:4;5526:5;5522:16;5509:43;5599:1;5592:4;5583:6;5576:5;5572:18;5568:29;5561:40;5200:407;;;;;:::o;5612:451::-;5681:6;5734:2;5722:9;5713:7;5709:23;5705:32;5702:52;;;5750:1;5747;5740:12;5702:52;5790:9;5777:23;5823:18;5815:6;5812:30;5809:50;;;5855:1;5852;5845:12;5809:50;5878:22;;5931:4;5923:13;;5919:27;-1:-1:-1;5909:55:1;;5960:1;5957;5950:12;5909:55;5983:74;6049:7;6044:2;6031:16;6026:2;6022;6018:11;5983:74;:::i;6068:347::-;6133:6;6141;6194:2;6182:9;6173:7;6169:23;6165:32;6162:52;;;6210:1;6207;6200:12;6162:52;6233:29;6252:9;6233:29;:::i;:::-;6223:39;;6312:2;6301:9;6297:18;6284:32;6359:5;6352:13;6345:21;6338:5;6335:32;6325:60;;6381:1;6378;6371:12;6325:60;6404:5;6394:15;;;6068:347;;;;;:::o;6420:667::-;6515:6;6523;6531;6539;6592:3;6580:9;6571:7;6567:23;6563:33;6560:53;;;6609:1;6606;6599:12;6560:53;6632:29;6651:9;6632:29;:::i;:::-;6622:39;;6680:38;6714:2;6703:9;6699:18;6680:38;:::i;:::-;6670:48;;6765:2;6754:9;6750:18;6737:32;6727:42;;6820:2;6809:9;6805:18;6792:32;6847:18;6839:6;6836:30;6833:50;;;6879:1;6876;6869:12;6833:50;6902:22;;6955:4;6947:13;;6943:27;-1:-1:-1;6933:55:1;;6984:1;6981;6974:12;6933:55;7007:74;7073:7;7068:2;7055:16;7050:2;7046;7042:11;7007:74;:::i;:::-;6997:84;;;6420:667;;;;;;;:::o;7092:689::-;7187:6;7195;7203;7256:2;7244:9;7235:7;7231:23;7227:32;7224:52;;;7272:1;7269;7262:12;7224:52;7312:9;7299:23;7341:18;7382:2;7374:6;7371:14;7368:34;;;7398:1;7395;7388:12;7368:34;7436:6;7425:9;7421:22;7411:32;;7481:7;7474:4;7470:2;7466:13;7462:27;7452:55;;7503:1;7500;7493:12;7452:55;7543:2;7530:16;7569:2;7561:6;7558:14;7555:34;;;7585:1;7582;7575:12;7555:34;7640:7;7633:4;7623:6;7620:1;7616:14;7612:2;7608:23;7604:34;7601:47;7598:67;;;7661:1;7658;7651:12;7598:67;7692:4;7684:13;;;;7716:6;;-1:-1:-1;7754:20:1;;;;7741:34;;7092:689;-1:-1:-1;;;;7092:689:1:o;7786:260::-;7854:6;7862;7915:2;7903:9;7894:7;7890:23;7886:32;7883:52;;;7931:1;7928;7921:12;7883:52;7954:29;7973:9;7954:29;:::i;:::-;7944:39;;8002:38;8036:2;8025:9;8021:18;8002:38;:::i;:::-;7992:48;;7786:260;;;;;:::o;8051:356::-;8253:2;8235:21;;;8272:18;;;8265:30;8331:34;8326:2;8311:18;;8304:62;8398:2;8383:18;;8051:356::o;8412:380::-;8491:1;8487:12;;;;8534;;;8555:61;;8609:4;8601:6;8597:17;8587:27;;8555:61;8662:2;8654:6;8651:14;8631:18;8628:38;8625:161;;8708:10;8703:3;8699:20;8696:1;8689:31;8743:4;8740:1;8733:15;8771:4;8768:1;8761:15;8625:161;;8412:380;;;:::o;10037:413::-;10239:2;10221:21;;;10278:2;10258:18;;;10251:30;10317:34;10312:2;10297:18;;10290:62;-1:-1:-1;;;10383:2:1;10368:18;;10361:47;10440:3;10425:19;;10037:413::o;10867:127::-;10928:10;10923:3;10919:20;10916:1;10909:31;10959:4;10956:1;10949:15;10983:4;10980:1;10973:15;10999:127;11060:10;11055:3;11051:20;11048:1;11041:31;11091:4;11088:1;11081:15;11115:4;11112:1;11105:15;11131:135;11170:3;11191:17;;;11188:43;;11211:18;;:::i;:::-;-1:-1:-1;11258:1:1;11247:13;;11131:135::o;12908:125::-;12948:4;12976:1;12973;12970:8;12967:34;;;12981:18;;:::i;:::-;-1:-1:-1;13018:9:1;;12908:125::o;13038:128::-;13078:3;13109:1;13105:6;13102:1;13099:13;13096:39;;;13115:18;;:::i;:::-;-1:-1:-1;13151:9:1;;13038:128::o;13171:336::-;13373:2;13355:21;;;13412:2;13392:18;;;13385:30;-1:-1:-1;;;13446:2:1;13431:18;;13424:42;13498:2;13483:18;;13171:336::o;16097:168::-;16137:7;16203:1;16199;16195:6;16191:14;16188:1;16185:21;16180:1;16173:9;16166:17;16162:45;16159:71;;;16210:18;;:::i;:::-;-1:-1:-1;16250:9:1;;16097:168::o;17387:470::-;17566:3;17604:6;17598:13;17620:53;17666:6;17661:3;17654:4;17646:6;17642:17;17620:53;:::i;:::-;17736:13;;17695:16;;;;17758:57;17736:13;17695:16;17792:4;17780:17;;17758:57;:::i;:::-;17831:20;;17387:470;-1:-1:-1;;;;17387:470:1:o;19841:414::-;20043:2;20025:21;;;20082:2;20062:18;;;20055:30;20121:34;20116:2;20101:18;;20094:62;-1:-1:-1;;;20187:2:1;20172:18;;20165:48;20245:3;20230:19;;19841:414::o;20260:127::-;20321:10;20316:3;20312:20;20309:1;20302:31;20352:4;20349:1;20342:15;20376:4;20373:1;20366:15;20392:120;20432:1;20458;20448:35;;20463:18;;:::i;:::-;-1:-1:-1;20497:9:1;;20392:120::o;20517:112::-;20549:1;20575;20565:35;;20580:18;;:::i;:::-;-1:-1:-1;20614:9:1;;20517:112::o;20634:489::-;-1:-1:-1;;;;;20903:15:1;;;20885:34;;20955:15;;20950:2;20935:18;;20928:43;21002:2;20987:18;;20980:34;;;21050:3;21045:2;21030:18;;21023:31;;;20828:4;;21071:46;;21097:19;;21089:6;21071:46;:::i;:::-;21063:54;20634:489;-1:-1:-1;;;;;;20634:489:1:o;21128:249::-;21197:6;21250:2;21238:9;21229:7;21225:23;21221:32;21218:52;;;21266:1;21263;21256:12;21218:52;21298:9;21292:16;21317:30;21341:5;21317:30;:::i;21382:127::-;21443:10;21438:3;21434:20;21431:1;21424:31;21474:4;21471:1;21464:15;21498:4;21495:1;21488:15

Swarm Source

ipfs://9f8a629226a969c03ecc533b53561abcd469e010228caf35ad77c8ab0bbbaa05
Loading