Token NinJa

/**
 *Submitted for verification at Etherscan.io on 2022-01-21
*/

// SPDX-License-Identifier: GPL-3.0



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






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





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

    /**
     * @dev Tool to verifies that a low level call was successful, and revert if it wasn't, either by bubbling the
     * revert reason using the provided one.
     *
     * _Available since v4.3._
     */
    function verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) internal pure returns (bytes memory) {
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

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





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





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

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

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

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

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





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





/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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





library TransferHelper {
    /// @notice Transfers tokens from the targeted address to the given destination
    /// @notice Errors with 'STF' if transfer fails
    /// @param token The contract address of the token to be transferred
    /// @param from The originating address from which the tokens will be transferred
    /// @param to The destination address of the transfer
    /// @param value The amount to be transferred
    function safeTransferFrom(
        address token,
        address from,
        address to,
        uint256 value
    ) internal {
        (bool success, bytes memory data) = token.call(
            abi.encodeWithSelector(
                IERC20.transferFrom.selector,
                from,
                to,
                value
            )
        );
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            "STF"
        );
    }

    /// @notice Transfers tokens from msg.sender to a recipient
    /// @dev Errors with ST if transfer fails
    /// @param token The contract address of the token which will be transferred
    /// @param to The recipient of the transfer
    /// @param value The value of the transfer
    function safeTransfer(
        address token,
        address to,
        uint256 value
    ) internal {
        (bool success, bytes memory data) = token.call(
            abi.encodeWithSelector(IERC20.transfer.selector, to, value)
        );
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            "ST"
        );
    }

    /// @notice Approves the stipulated contract to spend the given allowance in the given token
    /// @dev Errors with 'SA' if transfer fails
    /// @param token The contract address of the token to be approved
    /// @param to The target of the approval
    /// @param value The amount of the given token the target will be allowed to spend
    function safeApprove(
        address token,
        address to,
        uint256 value
    ) internal {
        (bool success, bytes memory data) = token.call(
            abi.encodeWithSelector(IERC20.approve.selector, to, value)
        );
        require(
            success && (data.length == 0 || abi.decode(data, (bool))),
            "SA"
        );
    }

    /// @notice Transfers ETH to the recipient address
    /// @dev Fails with `STE`
    /// @param to The destination of the transfer
    /// @param value The value to be transferred
    function safeTransferETH(address to, uint256 value) internal {
        (bool success, ) = to.call{value: value}(new bytes(0));
        require(success, "STE");
    }
}




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

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

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

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

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

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

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

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






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

    mapping(bytes32 => RoleData) private _roles;

    bytes32 public constant DEFAULT_ADMIN_ROLE = 0x00;

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

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

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

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

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

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

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

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

        _revokeRole(role, account);
    }

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

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

    function _grantRole(bytes32 role, address account) private {
        if (!hasRole(role, account)) {
            _roles[role].members[account] = true;
            emit RoleGranted(role, account, _msgSender());
        }
    }

    function _revokeRole(bytes32 role, address account) private {
        if (hasRole(role, account)) {
            _roles[role].members[account] = false;
            emit RoleRevoked(role, account, _msgSender());
        }
    }
}



pragma solidity ^0.8.0;


contract Ninja is ERC721Burnable, AccessControl, ReentrancyGuard {
    using Counters for Counters.Counter;

    bytes32 public constant AIRDROP_MINTER_ROLE =
        keccak256("AIRDROP_MINTER_ROLE");
    bytes32 public constant EXTRA_MINTER_ROLE = keccak256("EXTRA_MINTER_ROLE");
    bytes32 public constant ADMIN_ROLE = keccak256("ADMIN_ROLE");

    string private _baseTokenURI;
    Counters.Counter private _counter;

    address public USDT;

    uint256 public salePrice = 50 * 10**6;
    uint256 public saleStartTime = 0;

    uint256 public saleCount = 20000;
    uint256 public soldCount = 0;

    uint256 public airdropCount = 20000;
    uint256 public airdroppedCount = 0;

    mapping(uint256 => uint256) public tokenType;

    event SaleStart(uint256 time);
    event TokenType(uint256 token, uint256 _type);

    constructor(address usdt) ERC721("NinJa", "NinJa") {
        USDT = usdt;
        _setupRole(AIRDROP_MINTER_ROLE, msg.sender);
        _setupRole(EXTRA_MINTER_ROLE, msg.sender);
        _setupRole(ADMIN_ROLE, msg.sender);
        _setRoleAdmin(ADMIN_ROLE, ADMIN_ROLE);
        _setRoleAdmin(AIRDROP_MINTER_ROLE, ADMIN_ROLE);
        _setRoleAdmin(EXTRA_MINTER_ROLE, ADMIN_ROLE);
    }

    receive() external payable {
        require(false, "R");
    }

    function startSale(uint256 startTime) public onlyRole(ADMIN_ROLE) {
        require(saleStartTime == 0, "SS");
        saleStartTime = startTime;
        emit SaleStart(saleStartTime);
    }

    function setBaseURI(string calldata newBaseTokenURI)
        public
        onlyRole(ADMIN_ROLE)
    {
        _baseTokenURI = newBaseTokenURI;
    }

    function saleMint(address to, uint256 count) public {
        require(saleStartTime > 0 && block.timestamp >= saleStartTime, "PM:0");
        require(count >= 1 && count <= 200, "PM:2");
        require(soldCount + count <= saleCount, "PM:3");
        TransferHelper.safeTransferFrom(
            USDT,
            msg.sender,
            address(this),
            salePrice * count
        );
        soldCount += count;
        for (uint256 i = 0; i < count; i++) {
            _mintTo(to);
            _recordTokenType(0);
        }
    }

    function airdropMint(address to, uint256 count)
        public
        onlyRole(AIRDROP_MINTER_ROLE)
    {
        require(count >= 1 && count <= 200, "ADM:1");
        require(airdroppedCount + count <= airdropCount, "ADM:2");
        airdroppedCount += count;
        for (uint256 i = 0; i < count; i++) {
            _mintTo(to);
            _recordTokenType(1);
        }
    }

    function mint(address to) public onlyRole(EXTRA_MINTER_ROLE) {
        _mintTo(to);
        _recordTokenType(2);
    }

    function batchMint(address[] memory receivers) public {
        require(receivers.length >= 1 && receivers.length <= 200, "BM");
        for (uint256 i = 0; i < receivers.length; i++) {
            mint(receivers[i]);
        }
    }

    function batchBurn(uint256[] memory tokenIds) public {
        require(tokenIds.length >= 1 && tokenIds.length <= 200, "BB");
        for (uint256 i = 0; i < tokenIds.length; i++) {
            burn(tokenIds[i]);
        }
    }

    function withdraw(address to) public onlyRole(ADMIN_ROLE) {
        TransferHelper.safeTransfer(
            USDT,
            to,
            IERC20(USDT).balanceOf(address(this))
        );
    }

    function counterCurrent() public view returns (uint256) {
        return _counter.current();
    }

    function _mintTo(address to) internal nonReentrant {
        _counter.increment();
        _mint(to, counterCurrent());
    }

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

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

    function _recordTokenType(uint256 _type) internal {
        tokenType[counterCurrent()] = _type;
        emit TokenType(counterCurrent(), _type);
    }

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

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[{"internalType":"address","name":"usdt","type":"address"}],"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":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"time","type":"uint256"}],"name":"SaleStart","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"uint256","name":"token","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"_type","type":"uint256"}],"name":"TokenType","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":"ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"AIRDROP_MINTER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"EXTRA_MINTER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"USDT","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"airdropCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"count","type":"uint256"}],"name":"airdropMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"airdroppedCount","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":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"batchBurn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"receivers","type":"address[]"}],"name":"batchMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"counterCurrent","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":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"grantRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"hasRole","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"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":"to","type":"address"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"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":"saleCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"count","type":"uint256"}],"name":"saleMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"salePrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"saleStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":"newBaseTokenURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"soldCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"startTime","type":"uint256"}],"name":"startSale","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"tokenType","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":[{"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":"to","type":"address"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"stateMutability":"payable","type":"receive"}]

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

000000000000000000000000c2132d05d31c914a87c6611c10748aeb04b58e8f

-----Decoded View---------------
Arg [0] : usdt (address): 0xc2132d05d31c914a87c6611c10748aeb04b58e8f

-----Encoded View---------------
1 Constructor Arguments found :
Arg [0] : 000000000000000000000000c2132d05d31c914a87c6611c10748aeb04b58e8f

52012:4339:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53304:19;;-1:-1:-1;;;53304:19:0;;20566:2:1;53304:19:0;;;20548:21:1;20605:1;20585:18;;;20578:29;-1:-1:-1;;;20623:18:1;;;20616:31;20664:18;;53304:19:0;;;;;;;;;52012:4339;;;;;56122:226;;;;;;;;;;-1:-1:-1;56122:226:0;;;;;:::i;:::-;;:::i;:::-;;;9866:14:1;;9859:22;9841:41;;9829:2;9814:18;56122:226:0;;;;;;;;20839:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;22398:221::-;;;;;;;;;;-1:-1:-1;22398:221:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;8505:32:1;;;8487:51;;8475:2;8460:18;22398:221:0;8341:203:1;21921:411:0;;;;;;;;;;-1:-1:-1;21921:411:0;;;;;:::i;:::-;;:::i;53339:194::-;;;;;;;;;;-1:-1:-1;53339:194:0;;;;;:::i;:::-;;:::i;52521:32::-;;;;;;;;;;;;;;;;;;;10039:25:1;;;10027:2;10012:18;52521:32:0;9893:177:1;54268:392:0;;;;;;;;;;-1:-1:-1;54268:392:0;;;;;:::i;:::-;;:::i;23288:339::-;;;;;;;;;;-1:-1:-1;23288:339:0;;;;;:::i;:::-;;:::i;48768:123::-;;;;;;;;;;-1:-1:-1;48768:123:0;;;;;:::i;:::-;48834:7;48861:12;;;:6;:12;;;;;:22;;;;48768:123;49153:147;;;;;;;;;;-1:-1:-1;49153:147:0;;;;;:::i;:::-;;:::i;52128:87::-;;;;;;;;;;;;52183:32;52128:87;;50201:218;;;;;;;;;;-1:-1:-1;50201:218:0;;;;;:::i;:::-;;:::i;52601:28::-;;;;;;;;;;;;;;;;23698:185;;;;;;;;;;-1:-1:-1;23698:185:0;;;;;:::i;:::-;;:::i;32370:245::-;;;;;;;;;;-1:-1:-1;32370:245:0;;;;;:::i;:::-;;:::i;53703:557::-;;;;;;;;;;-1:-1:-1;53703:557:0;;;;;:::i;:::-;;:::i;52680:34::-;;;;;;;;;;;;;;;;55284:203;;;;;;;;;;-1:-1:-1;55284:203:0;;;;;:::i;:::-;;:::i;53541:154::-;;;;;;;;;;-1:-1:-1;53541:154:0;;;;;:::i;:::-;;:::i;20533:239::-;;;;;;;;;;-1:-1:-1;20533:239:0;;;;;:::i;:::-;;:::i;54668:121::-;;;;;;;;;;-1:-1:-1;54668:121:0;;;;;:::i;:::-;;:::i;55739:91::-;;;;;;;;;;;;;:::i;20263:208::-;;;;;;;;;;-1:-1:-1;20263:208:0;;;;;:::i;:::-;;:::i;52303:60::-;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;52303:60:0;;47653:139;;;;;;;;;;-1:-1:-1;47653:139:0;;;;;:::i;:::-;;:::i;21008:104::-;;;;;;;;;;;;;:::i;52562:32::-;;;;;;;;;;;;;;;;46744:49;;;;;;;;;;-1:-1:-1;46744:49:0;46789:4;46744:49;;22691:295;;;;;;;;;;-1:-1:-1;22691:295:0;;;;;:::i;:::-;;:::i;23954:328::-;;;;;;;;;;-1:-1:-1;23954:328:0;;;;;:::i;:::-;;:::i;52222:74::-;;;;;;;;;;;;52266:30;52222:74;;55495:100;;;;;;;;;;;;;:::i;52449:19::-;;;;;;;;;;-1:-1:-1;52449:19:0;;;;-1:-1:-1;;;;;52449:19:0;;;21183:334;;;;;;;;;;-1:-1:-1;21183:334:0;;;;;:::i;:::-;;:::i;49545:149::-;;;;;;;;;;-1:-1:-1;49545:149:0;;;;;:::i;:::-;;:::i;54797:238::-;;;;;;;;;;-1:-1:-1;54797:238:0;;;;;:::i;:::-;;:::i;55043:233::-;;;;;;;;;;-1:-1:-1;55043:233:0;;;;;:::i;:::-;;:::i;52723:44::-;;;;;;;;;;-1:-1:-1;52723:44:0;;;;;:::i;:::-;;;;;;;;;;;;;;52638:35;;;;;;;;;;;;;;;;23057:164;;;;;;;;;;-1:-1:-1;23057:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;23178:25:0;;;23154:4;23178:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;23057:164;52477:37;;;;;;;;;;;;;;;;56122:226;56275:4;56304:36;56328:11;56304:23;:36::i;:::-;56297:43;56122:226;-1:-1:-1;;56122:226:0:o;20839:100::-;20893:13;20926:5;20919:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20839:100;:::o;22398:221::-;22474:7;25881:16;;;:7;:16;;;;;;-1:-1:-1;;;;;25881:16:0;22494:73;;;;-1:-1:-1;;;22494:73:0;;16736:2:1;22494:73:0;;;16718:21:1;16775:2;16755:18;;;16748:30;16814:34;16794:18;;;16787:62;-1:-1:-1;;;16865:18:1;;;16858:42;16917:19;;22494:73:0;16534:408:1;22494:73:0;-1:-1:-1;22587:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;22587:24:0;;22398:221::o;21921:411::-;22002:13;22018:23;22033:7;22018:14;:23::i;:::-;22002:39;;22066:5;-1:-1:-1;;;;;22060:11:0;:2;-1:-1:-1;;;;;22060:11:0;;;22052:57;;;;-1:-1:-1;;;22052:57:0;;18969:2:1;22052:57:0;;;18951:21:1;19008:2;18988:18;;;18981:30;19047:34;19027:18;;;19020:62;-1:-1:-1;;;19098:18:1;;;19091:31;19139:19;;22052:57:0;18767:397:1;22052:57:0;15658:10;-1:-1:-1;;;;;22144:21:0;;;;:62;;-1:-1:-1;22169:37:0;22186:5;15658:10;23057:164;:::i;22169:37::-;22122:168;;;;-1:-1:-1;;;22122:168:0;;13475:2:1;22122:168:0;;;13457:21:1;13514:2;13494:18;;;13487:30;13553:34;13533:18;;;13526:62;13624:26;13604:18;;;13597:54;13668:19;;22122:168:0;13273:420:1;22122:168:0;22303:21;22312:2;22316:7;22303:8;:21::i;:::-;21991:341;21921:411;;:::o;53339:194::-;-1:-1:-1;;;;;;;;;;;47235:30:0;52340:23;15658:10;47235;:30::i;:::-;53424:13:::1;::::0;:18;53416:33:::1;;;::::0;-1:-1:-1;;;53416:33:0;;15053:2:1;53416:33:0::1;::::0;::::1;15035:21:1::0;15092:1;15072:18;;;15065:29;-1:-1:-1;;;15110:18:1;;;15103:32;15152:18;;53416:33:0::1;14851:325:1::0;53416:33:0::1;53460:13;:25:::0;;;53501:24:::1;::::0;10039:25:1;;;53501:24:0::1;::::0;10027:2:1;10012:18;53501:24:0::1;;;;;;;53339:194:::0;;:::o;54268:392::-;52183:32;47235:30;52183:32;15658:10;47235;:30::i;:::-;54404:1:::1;54395:5;:10;;:26;;;;;54418:3;54409:5;:12;;54395:26;54387:44;;;::::0;-1:-1:-1;;;54387:44:0;;18306:2:1;54387:44:0::1;::::0;::::1;18288:21:1::0;18345:1;18325:18;;;18318:29;-1:-1:-1;;;18363:18:1;;;18356:35;18408:18;;54387:44:0::1;18104:328:1::0;54387:44:0::1;54477:12;;54468:5;54450:15;;:23;;;;:::i;:::-;:39;;54442:57;;;::::0;-1:-1:-1;;;54442:57:0;;13142:2:1;54442:57:0::1;::::0;::::1;13124:21:1::0;13181:1;13161:18;;;13154:29;-1:-1:-1;;;13199:18:1;;;13192:35;13244:18;;54442:57:0::1;12940:328:1::0;54442:57:0::1;54529:5;54510:15;;:24;;;;;;;:::i;:::-;::::0;;;-1:-1:-1;54550:9:0::1;::::0;-1:-1:-1;54545:108:0::1;54569:5;54565:1;:9;54545:108;;;54596:11;54604:2;54596:7;:11::i;:::-;54622:19;54639:1;54622:16;:19::i;:::-;54576:3:::0;::::1;::::0;::::1;:::i;:::-;;;;54545:108;;;;54268:392:::0;;;:::o;23288:339::-;23483:41;15658:10;23502:12;23516:7;23483:18;:41::i;:::-;23475:103;;;;-1:-1:-1;;;23475:103:0;;;;;;;:::i;:::-;23591:28;23601:4;23607:2;23611:7;23591:9;:28::i;49153:147::-;48834:7;48861:12;;;:6;:12;;;;;:22;;;47235:30;47246:4;15658:10;47235;:30::i;:::-;49267:25:::1;49278:4;49284:7;49267:10;:25::i;50201:218::-:0;-1:-1:-1;;;;;50297:23:0;;15658:10;50297:23;50289:83;;;;-1:-1:-1;;;50289:83:0;;20895:2:1;50289:83:0;;;20877:21:1;20934:2;20914:18;;;20907:30;20973:34;20953:18;;;20946:62;-1:-1:-1;;;21024:18:1;;;21017:45;21079:19;;50289:83:0;20693:411:1;50289:83:0;50385:26;50397:4;50403:7;50385:11;:26::i;:::-;50201:218;;:::o;23698:185::-;23836:39;23853:4;23859:2;23863:7;23836:39;;;;;;;;;;;;:16;:39::i;32370:245::-;32488:41;15658:10;32507:12;15578:98;32488:41;32480:102;;;;-1:-1:-1;;;32480:102:0;;20149:2:1;32480:102:0;;;20131:21:1;20188:2;20168:18;;;20161:30;20227:34;20207:18;;;20200:62;-1:-1:-1;;;20278:18:1;;;20271:46;20334:19;;32480:102:0;19947:412:1;32480:102:0;32593:14;32599:7;32593:5;:14::i;:::-;32370:245;:::o;53703:557::-;53790:1;53774:13;;:17;:53;;;;;53814:13;;53795:15;:32;;53774:53;53766:70;;;;-1:-1:-1;;;53766:70:0;;;;;;16074:2:1;16056:21;;;16113:1;16093:18;;;16086:29;-1:-1:-1;;;16146:2:1;16131:18;;16124:34;16190:2;16175:18;;15872:327;53766:70:0;53864:1;53855:5;:10;;:26;;;;;53878:3;53869:5;:12;;53855:26;53847:43;;;;-1:-1:-1;;;53847:43:0;;;;;;10862:2:1;10844:21;;;10901:1;10881:18;;;10874:29;-1:-1:-1;;;10934:2:1;10919:18;;10912:34;10978:2;10963:18;;10660:327;53847:43:0;53930:9;;53921:5;53909:9;;:17;;;;:::i;:::-;:30;;53901:47;;;;-1:-1:-1;;;53901:47:0;;;;;;14721:2:1;14703:21;;;14760:1;14740:18;;;14733:29;-1:-1:-1;;;14793:2:1;14778:18;;14771:34;14837:2;14822:18;;14519:327;53901:47:0;54005:4;;54077:9;;53959:146;;-1:-1:-1;;;;;54005:4:0;;54024:10;;54057:4;;54077:17;;54089:5;;54077:17;:::i;:::-;53959:31;:146::i;:::-;54129:5;54116:9;;:18;;;;;;;:::i;:::-;;;;-1:-1:-1;54150:9:0;;-1:-1:-1;54145:108:0;54169:5;54165:1;:9;54145:108;;;54196:11;54204:2;54196:7;:11::i;:::-;54222:19;54239:1;54222:16;:19::i;:::-;54176:3;;;;:::i;:::-;;;;54145:108;;55284:203;-1:-1:-1;;;;;;;;;;;47235:30:0;52340:23;15658:10;47235;:30::i;:::-;55395:4:::1;::::0;55431:37:::1;::::0;-1:-1:-1;;;55431:37:0;;55462:4:::1;55431:37;::::0;::::1;8487:51:1::0;55353:126:0::1;::::0;-1:-1:-1;;;;;55395:4:0::1;::::0;55414:2;;55395:4;;55431:22:::1;::::0;8460:18:1;;55431:37:0::1;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;55353:27;:126::i;53541:154::-:0;-1:-1:-1;;;;;;;;;;;47235:30:0;52340:23;15658:10;47235;:30::i;:::-;53656:31:::1;:13;53672:15:::0;;53656:31:::1;:::i;20533:239::-:0;20605:7;20641:16;;;:7;:16;;;;;;-1:-1:-1;;;;;20641:16:0;20676:19;20668:73;;;;-1:-1:-1;;;20668:73:0;;14311:2:1;20668:73:0;;;14293:21:1;14350:2;14330:18;;;14323:30;14389:34;14369:18;;;14362:62;-1:-1:-1;;;14440:18:1;;;14433:39;14489:19;;20668:73:0;14109:405:1;54668:121:0;52266:30;47235;52266;15658:10;47235;:30::i;:::-;54740:11:::1;54748:2;54740:7;:11::i;:::-;54762:19;54779:1;54762:16;:19::i;55739:91::-:0;55779:13;55812:10;:8;:10::i;:::-;55805:17;;55739:91;:::o;20263:208::-;20335:7;-1:-1:-1;;;;;20363:19:0;;20355:74;;;;-1:-1:-1;;;20355:74:0;;13900:2:1;20355:74:0;;;13882:21:1;13939:2;13919:18;;;13912:30;13978:34;13958:18;;;13951:62;-1:-1:-1;;;14029:18:1;;;14022:40;14079:19;;20355:74:0;13698:406:1;20355:74:0;-1:-1:-1;;;;;;20447:16:0;;;;;:9;:16;;;;;;;20263:208::o;47653:139::-;47731:4;47755:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;47755:29:0;;;;;;;;;;;;;;;47653:139::o;21008:104::-;21064:13;21097:7;21090:14;;;;;:::i;22691:295::-;-1:-1:-1;;;;;22794:24:0;;15658:10;22794:24;;22786:62;;;;-1:-1:-1;;;22786:62:0;;12375:2:1;22786:62:0;;;12357:21:1;12414:2;12394:18;;;12387:30;12453:27;12433:18;;;12426:55;12498:18;;22786:62:0;12173:349:1;22786:62:0;15658:10;22861:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;22861:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;22861:53:0;;;;;;;;;;22930:48;;9841:41:1;;;22861:42:0;;15658:10;22930:48;;9814:18:1;22930:48:0;;;;;;;22691:295;;:::o;23954:328::-;24129:41;15658:10;24162:7;24129:18;:41::i;:::-;24121:103;;;;-1:-1:-1;;;24121:103:0;;;;;;;:::i;:::-;24235:39;24249:4;24255:2;24259:7;24268:5;24235:13;:39::i;55495:100::-;55542:7;55569:18;:8;33453:14;;33361:114;21183:334;25857:4;25881:16;;;:7;:16;;;;;;21256:13;;-1:-1:-1;;;;;25881:16:0;21282:76;;;;-1:-1:-1;;;21282:76:0;;17890:2:1;21282:76:0;;;17872:21:1;17929:2;17909:18;;;17902:30;17968:34;17948:18;;;17941:62;-1:-1:-1;;;18019:18:1;;;18012:45;18074:19;;21282:76:0;17688:411:1;21282:76:0;21371:21;21395:10;:8;:10::i;:::-;21371:34;;21447:1;21429:7;21423:21;:25;:86;;;;;;;;;;;;;;;;;21475:7;21484:18;:7;:16;:18::i;:::-;21458:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;21423:86;21416:93;21183:334;-1:-1:-1;;;21183:334:0:o;49545:149::-;48834:7;48861:12;;;:6;:12;;;;;:22;;;47235:30;47246:4;15658:10;47235;:30::i;:::-;49660:26:::1;49672:4;49678:7;49660:11;:26::i;54797:238::-:0;54890:1;54870:9;:16;:21;;:48;;;;;54915:3;54895:9;:16;:23;;54870:48;54862:63;;;;-1:-1:-1;;;54862:63:0;;18639:2:1;54862:63:0;;;18621:21:1;18678:1;18658:18;;;18651:29;-1:-1:-1;;;18696:18:1;;;18689:32;18738:18;;54862:63:0;18437:325:1;54862:63:0;54941:9;54936:92;54960:9;:16;54956:1;:20;54936:92;;;54998:18;55003:9;55013:1;55003:12;;;;;;;;:::i;:::-;;;;;;;54998:4;:18::i;:::-;54978:3;;;;:::i;:::-;;;;54936:92;;55043:233;55134:1;55115:8;:15;:20;;:46;;;;;55158:3;55139:8;:15;:22;;55115:46;55107:61;;;;-1:-1:-1;;;55107:61:0;;15383:2:1;55107:61:0;;;15365:21:1;15422:1;15402:18;;;15395:29;-1:-1:-1;;;15440:18:1;;;15433:32;15482:18;;55107:61:0;15181:325:1;55107:61:0;55184:9;55179:90;55203:8;:15;55199:1;:19;55179:90;;;55240:17;55245:8;55254:1;55245:11;;;;;;;;:::i;:::-;;;;;;;55240:4;:17::i;:::-;55220:3;;;;:::i;:::-;;;;55179:90;;47357:204;47442:4;-1:-1:-1;;;;;;47466:47:0;;-1:-1:-1;;;47466:47:0;;:87;;;47517:36;47541:11;47517:23;:36::i;29774:174::-;29849:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;29849:29:0;-1:-1:-1;;;;;29849:29:0;;;;;;;;:24;;29903:23;29849:24;29903:14;:23::i;:::-;-1:-1:-1;;;;;29894:46:0;;;;;;;;;;;29774:174;;:::o;48082:497::-;48163:22;48171:4;48177:7;48163;:22::i;:::-;48158:414;;48351:41;48379:7;-1:-1:-1;;;;;48351:41:0;48389:2;48351:19;:41::i;:::-;48465:38;48493:4;48500:2;48465:19;:38::i;:::-;48256:270;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;48256:270:0;;;;;;;;;;-1:-1:-1;;;48202:358:0;;;;;;;:::i;55603:128::-;35613:1;36209:7;;:19;;36201:63;;;;-1:-1:-1;;;36201:63:0;;19789:2:1;36201:63:0;;;19771:21:1;19828:2;19808:18;;;19801:30;19867:33;19847:18;;;19840:61;19918:18;;36201:63:0;19587:355:1;36201:63:0;35613:1;36342:7;:18;55665:20:::1;:8;33572:19:::0;;33590:1;33572:19;;;33483:127;55665:20:::1;55696:27;55702:2;55706:16;:14;:16::i;:::-;55696:5;:27::i;:::-;-1:-1:-1::0;35569:1:0;36521:7;:22;55603:128::o;55960:154::-;56051:5;56021:9;:27;56031:16;:14;:16::i;:::-;56021:27;;;;;;;;;;;-1:-1:-1;56021:27:0;:35;56072:34;56082:16;:14;:16::i;:::-;56072:34;;;21465:25:1;;;21521:2;21506:18;;21499:34;;;21438:18;56072:34:0;;;;;;;55960:154;:::o;26086:348::-;26179:4;25881:16;;;:7;:16;;;;;;-1:-1:-1;;;;;25881:16:0;26196:73;;;;-1:-1:-1;;;26196:73:0;;12729:2:1;26196:73:0;;;12711:21:1;12768:2;12748:18;;;12741:30;12807:34;12787:18;;;12780:62;-1:-1:-1;;;12858:18:1;;;12851:42;12910:19;;26196:73:0;12527:408:1;26196:73:0;26280:13;26296:23;26311:7;26296:14;:23::i;:::-;26280:39;;26349:5;-1:-1:-1;;;;;26338:16:0;:7;-1:-1:-1;;;;;26338:16:0;;:51;;;;26382:7;-1:-1:-1;;;;;26358:31:0;:20;26370:7;26358:11;:20::i;:::-;-1:-1:-1;;;;;26358:31:0;;26338:51;:87;;;-1:-1:-1;;;;;;23178:25:0;;;23154:4;23178:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;26393:32;26330:96;26086:348;-1:-1:-1;;;;26086:348:0:o;29078:578::-;29237:4;-1:-1:-1;;;;;29210:31:0;:23;29225:7;29210:14;:23::i;:::-;-1:-1:-1;;;;;29210:31:0;;29202:85;;;;-1:-1:-1;;;29202:85:0;;17149:2:1;29202:85:0;;;17131:21:1;17188:2;17168:18;;;17161:30;17227:34;17207:18;;;17200:62;-1:-1:-1;;;17278:18:1;;;17271:39;17327:19;;29202:85:0;16947:405:1;29202:85:0;-1:-1:-1;;;;;29306:16:0;;29298:65;;;;-1:-1:-1;;;29298:65:0;;11970:2:1;29298:65:0;;;11952:21:1;12009:2;11989:18;;;11982:30;12048:34;12028:18;;;12021:62;-1:-1:-1;;;12099:18:1;;;12092:34;12143:19;;29298:65:0;11768:400:1;29298:65:0;29480:29;29497:1;29501:7;29480:8;:29::i;:::-;-1:-1:-1;;;;;29522:15:0;;;;;;:9;:15;;;;;:20;;29541:1;;29522:15;:20;;29541:1;;29522:20;:::i;:::-;;;;-1:-1:-1;;;;;;;29553:13:0;;;;;;:9;:13;;;;;:18;;29570:1;;29553:13;:18;;29570:1;;29553:18;:::i;:::-;;;;-1:-1:-1;;29582:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;29582:21:0;-1:-1:-1;;;;;29582:21:0;;;;;;;;;29621:27;;29582:16;;29621:27;;;;;;;29078:578;;;:::o;51505:229::-;51580:22;51588:4;51594:7;51580;:22::i;:::-;51575:152;;51619:12;;;;:6;:12;;;;;;;;-1:-1:-1;;;;;51619:29:0;;;;;;;;;:36;;-1:-1:-1;;51619:36:0;51651:4;51619:36;;;51702:12;15658:10;;15578:98;51702:12;-1:-1:-1;;;;;51675:40:0;51693:7;-1:-1:-1;;;;;51675:40:0;51687:4;51675:40;;;;;;;;;;51505:229;;:::o;51742:230::-;51817:22;51825:4;51831:7;51817;:22::i;:::-;51813:152;;;51888:5;51856:12;;;:6;:12;;;;;;;;-1:-1:-1;;;;;51856:29:0;;;;;;;;;;:37;;-1:-1:-1;;51856:37:0;;;51913:40;15658:10;;51856:12;;51913:40;;51888:5;51913:40;51742:230;;:::o;28381:360::-;28441:13;28457:23;28472:7;28457:14;:23::i;:::-;28441:39;;28582:29;28599:1;28603:7;28582:8;:29::i;:::-;-1:-1:-1;;;;;28624:16:0;;;;;;:9;:16;;;;;:21;;28644:1;;28624:16;:21;;28644:1;;28624:21;:::i;:::-;;;;-1:-1:-1;;28663:16:0;;;;:7;:16;;;;;;28656:23;;-1:-1:-1;;;;;;28656:23:0;;;28697:36;28671:7;;28663:16;-1:-1:-1;;;;;28697:36:0;;;;;28663:16;;28697:36;28430:311;28381:360;:::o;39760:498::-;39966:152;;;-1:-1:-1;;;;;8807:15:1;;;39966:152:0;;;8789:34:1;8859:15;;;8839:18;;;8832:43;8891:18;;;;8884:34;;;39966:152:0;;;;;;;;;;8724:18:1;;;;39966:152:0;;;;;;;-1:-1:-1;;;;;39966:152:0;-1:-1:-1;;;39966:152:0;;;39941:188;;-1:-1:-1;;;;39941:10:0;;;;:188;;39966:152;39941:188;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39905:224;;;;40162:7;:57;;;;-1:-1:-1;40174:11:0;;:16;;:44;;;40205:4;40194:24;;;;;;;;;;;;:::i;:::-;40140:110;;;;-1:-1:-1;;;40140:110:0;;17559:2:1;40140:110:0;;;17541:21:1;17598:1;17578:18;;;17571:29;-1:-1:-1;;;17616:18:1;;;17609:33;17659:18;;40140:110:0;17357:326:1;40140:110:0;39894:364;;39760:498;;;;:::o;40557:377::-;40736:59;;;-1:-1:-1;;;;;9614:32:1;;;40736:59:0;;;9596:51:1;9663:18;;;;9656:34;;;40736:59:0;;;;;;;;;;9569:18:1;;;;40736:59:0;;;;;;;-1:-1:-1;;;;;40736:59:0;-1:-1:-1;;;40736:59:0;;;40711:95;;-1:-1:-1;;;;40711:10:0;;;;:95;;40736:59;40711:95;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40675:131;;;;40839:7;:57;;;;-1:-1:-1;40851:11:0;;:16;;:44;;;40882:4;40871:24;;;;;;;;;;;;:::i;:::-;40817:109;;;;-1:-1:-1;;;40817:109:0;;16406:2:1;40817:109:0;;;16388:21:1;16445:1;16425:18;;;16418:29;-1:-1:-1;;;16463:18:1;;;16456:32;16505:18;;40817:109:0;16204:325:1;40817:109:0;40664:270;;40557:377;;;:::o;55838:114::-;55898:13;55931;55924:20;;;;;:::i;25164:315::-;25321:28;25331:4;25337:2;25341:7;25321:9;:28::i;:::-;25368:48;25391:4;25397:2;25401:7;25410:5;25368:22;:48::i;:::-;25360:111;;;;-1:-1:-1;;;25360:111:0;;;;;;;:::i;16026:723::-;16082:13;16303:10;16299:53;;-1:-1:-1;;16330:10:0;;;;;;;;;;;;-1:-1:-1;;;16330:10:0;;;;;16026:723::o;16299:53::-;16377:5;16362:12;16418:78;16425:9;;16418:78;;16451:8;;;;:::i;:::-;;-1:-1:-1;16474:10:0;;-1:-1:-1;16482:2:0;16474:10;;:::i;:::-;;;16418:78;;;16506:19;16538:6;16528:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;16528:17:0;;16506:39;;16556:154;16563:10;;16556:154;;16590:11;16600:1;16590:11;;:::i;:::-;;-1:-1:-1;16659:10:0;16667:2;16659:5;:10;:::i;:::-;16646:24;;:2;:24;:::i;:::-;16633:39;;16616:6;16623;16616:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;16616:56:0;;;;;;;;-1:-1:-1;16687:11:0;16696:2;16687:11;;:::i;:::-;;;16556:154;;19894:305;19996:4;-1:-1:-1;;;;;;20033:40:0;;-1:-1:-1;;;20033:40:0;;:105;;-1:-1:-1;;;;;;;20090:48:0;;-1:-1:-1;;;20090:48:0;20033:105;:158;;;-1:-1:-1;;;;;;;;;;18602:40:0;;;20155:36;18493:157;17327:451;17402:13;17428:19;17460:10;17464:6;17460:1;:10;:::i;:::-;:14;;17473:1;17460:14;:::i;:::-;17450:25;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;17450:25:0;;17428:47;;-1:-1:-1;;;17486:6:0;17493:1;17486:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;17486:15:0;;;;;;;;;-1:-1:-1;;;17512:6:0;17519:1;17512:9;;;;;;;;:::i;:::-;;;;:15;-1:-1:-1;;;;;17512:15:0;;;;;;;;-1:-1:-1;17543:9:0;17555:10;17559:6;17555:1;:10;:::i;:::-;:14;;17568:1;17555:14;:::i;:::-;17543:26;;17538:135;17575:1;17571;:5;17538:135;;;-1:-1:-1;;;17623:5:0;17631:3;17623:11;17610:25;;;;;;;:::i;:::-;;;;17598:6;17605:1;17598:9;;;;;;;;:::i;:::-;;;;:37;-1:-1:-1;;;;;17598:37:0;;;;;;;;-1:-1:-1;17660:1:0;17650:11;;;;;17578:3;;;:::i;:::-;;;17538:135;;;-1:-1:-1;17691:10:0;;17683:55;;;;-1:-1:-1;;;17683:55:0;;10501:2:1;17683:55:0;;;10483:21:1;;;10520:18;;;10513:30;10579:34;10559:18;;;10552:62;10631:18;;17683:55:0;10299:356:1;27770:382:0;-1:-1:-1;;;;;27850:16:0;;27842:61;;;;-1:-1:-1;;;27842:61:0;;15713:2:1;27842:61:0;;;15695:21:1;;;15732:18;;;15725:30;15791:34;15771:18;;;15764:62;15843:18;;27842:61:0;15511:356:1;27842:61:0;25857:4;25881:16;;;:7;:16;;;;;;-1:-1:-1;;;;;25881:16:0;:30;27914:58;;;;-1:-1:-1;;;27914:58:0;;11613:2:1;27914:58:0;;;11595:21:1;11652:2;11632:18;;;11625:30;11691;11671:18;;;11664:58;11739:18;;27914:58:0;11411:352:1;27914:58:0;-1:-1:-1;;;;;28043:13:0;;;;;;:9;:13;;;;;:18;;28060:1;;28043:13;:18;;28060:1;;28043:18;:::i;:::-;;;;-1:-1:-1;;28072:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;28072:21:0;-1:-1:-1;;;;;28072:21:0;;;;;;;;28111:33;;28072:16;;;28111:33;;28072:16;;28111:33;27770:382;;:::o;30513:799::-;30668:4;-1:-1:-1;;;;;30689:13:0;;8022:20;8070:8;30685:620;;30725:72;;-1:-1:-1;;;30725:72:0;;-1:-1:-1;;;;;30725:36:0;;;;;:72;;15658:10;;30776:4;;30782:7;;30791:5;;30725:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;30725:72:0;;;;;;;;-1:-1:-1;;30725:72:0;;;;;;;;;;;;:::i;:::-;;;30721:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;30967:13:0;;30963:272;;31010:60;;-1:-1:-1;;;31010:60:0;;;;;;;:::i;30963:272::-;31185:6;31179:13;31170:6;31166:2;31162:15;31155:38;30721:529;-1:-1:-1;;;;;;30848:51:0;-1:-1:-1;;;30848:51:0;;-1:-1:-1;30841:58:0;;30685:620;-1:-1:-1;31289:4:0;30513:799;;;;;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:173:1;82:20;;-1:-1:-1;;;;;131:31:1;;121:42;;111:70;;177:1;174;167:12;111:70;14:173;;;:::o;192:186::-;251:6;304:2;292:9;283:7;279:23;275:32;272:52;;;320:1;317;310:12;272:52;343:29;362:9;343:29;:::i;383:260::-;451:6;459;512:2;500:9;491:7;487:23;483:32;480:52;;;528:1;525;518:12;480:52;551:29;570:9;551:29;:::i;:::-;541:39;;599:38;633:2;622:9;618:18;599:38;:::i;:::-;589:48;;383:260;;;;;:::o;648:328::-;725:6;733;741;794:2;782:9;773:7;769:23;765:32;762:52;;;810:1;807;800:12;762:52;833:29;852:9;833:29;:::i;:::-;823:39;;881:38;915:2;904:9;900:18;881:38;:::i;:::-;871:48;;966:2;955:9;951:18;938:32;928:42;;648:328;;;;;:::o;981:980::-;1076:6;1084;1092;1100;1153:3;1141:9;1132:7;1128:23;1124:33;1121:53;;;1170:1;1167;1160:12;1121:53;1193:29;1212:9;1193:29;:::i;:::-;1183:39;;1241:2;1262:38;1296:2;1285:9;1281:18;1262:38;:::i;:::-;1252:48;;1347:2;1336:9;1332:18;1319:32;1309:42;;1402:2;1391:9;1387:18;1374:32;1425:18;1466:2;1458:6;1455:14;1452:34;;;1482:1;1479;1472:12;1452:34;1520:6;1509:9;1505:22;1495:32;;1565:7;1558:4;1554:2;1550:13;1546:27;1536:55;;1587:1;1584;1577:12;1536:55;1623:2;1610:16;1645:2;1641;1638:10;1635:36;;;1651:18;;:::i;:::-;1693:53;1736:2;1717:13;;-1:-1:-1;;1713:27:1;1709:36;;1693:53;:::i;:::-;1680:66;;1769:2;1762:5;1755:17;1809:7;1804:2;1799;1795;1791:11;1787:20;1784:33;1781:53;;;1830:1;1827;1820:12;1781:53;1885:2;1880;1876;1872:11;1867:2;1860:5;1856:14;1843:45;1929:1;1924:2;1919;1912:5;1908:14;1904:23;1897:34;;1950:5;1940:15;;;;;981:980;;;;;;;:::o;1966:315::-;2031:6;2039;2092:2;2080:9;2071:7;2067:23;2063:32;2060:52;;;2108:1;2105;2098:12;2060:52;2131:29;2150:9;2131:29;:::i;:::-;2121:39;;2210:2;2199:9;2195:18;2182:32;2223:28;2245:5;2223:28;:::i;:::-;2270:5;2260:15;;;1966:315;;;;;:::o;2286:254::-;2354:6;2362;2415:2;2403:9;2394:7;2390:23;2386:32;2383:52;;;2431:1;2428;2421:12;2383:52;2454:29;2473:9;2454:29;:::i;:::-;2444:39;2530:2;2515:18;;;;2502:32;;-1:-1:-1;;;2286:254:1:o;2545:908::-;2629:6;2660:2;2703;2691:9;2682:7;2678:23;2674:32;2671:52;;;2719:1;2716;2709:12;2671:52;2759:9;2746:23;2792:18;2784:6;2781:30;2778:50;;;2824:1;2821;2814:12;2778:50;2847:22;;2900:4;2892:13;;2888:27;-1:-1:-1;2878:55:1;;2929:1;2926;2919:12;2878:55;2965:2;2952:16;2988:60;3004:43;3044:2;3004:43;:::i;:::-;2988:60;:::i;:::-;3070:3;3094:2;3089:3;3082:15;3122:2;3117:3;3113:12;3106:19;;3153:2;3149;3145:11;3201:7;3196:2;3190;3187:1;3183:10;3179:2;3175:19;3171:28;3168:41;3165:61;;;3222:1;3219;3212:12;3165:61;3244:1;3235:10;;3254:169;3268:2;3265:1;3262:9;3254:169;;;3325:23;3344:3;3325:23;:::i;:::-;3313:36;;3286:1;3279:9;;;;;3369:12;;;;3401;;3254:169;;;-1:-1:-1;3442:5:1;2545:908;-1:-1:-1;;;;;;;2545:908:1:o;3458:902::-;3542:6;3573:2;3616;3604:9;3595:7;3591:23;3587:32;3584:52;;;3632:1;3629;3622:12;3584:52;3672:9;3659:23;3705:18;3697:6;3694:30;3691:50;;;3737:1;3734;3727:12;3691:50;3760:22;;3813:4;3805:13;;3801:27;-1:-1:-1;3791:55:1;;3842:1;3839;3832:12;3791:55;3878:2;3865:16;3901:60;3917:43;3957:2;3917:43;:::i;3901:60::-;3983:3;4007:2;4002:3;3995:15;4035:2;4030:3;4026:12;4019:19;;4066:2;4062;4058:11;4114:7;4109:2;4103;4100:1;4096:10;4092:2;4088:19;4084:28;4081:41;4078:61;;;4135:1;4132;4125:12;4078:61;4157:1;4148:10;;4167:163;4181:2;4178:1;4175:9;4167:163;;;4238:17;;4226:30;;4199:1;4192:9;;;;;4276:12;;;;4308;;4167:163;;4365:245;4432:6;4485:2;4473:9;4464:7;4460:23;4456:32;4453:52;;;4501:1;4498;4491:12;4453:52;4533:9;4527:16;4552:28;4574:5;4552:28;:::i;4615:180::-;4674:6;4727:2;4715:9;4706:7;4702:23;4698:32;4695:52;;;4743:1;4740;4733:12;4695:52;-1:-1:-1;4766:23:1;;4615:180;-1:-1:-1;4615:180:1:o;4800:254::-;4868:6;4876;4929:2;4917:9;4908:7;4904:23;4900:32;4897:52;;;4945:1;4942;4935:12;4897:52;4981:9;4968:23;4958:33;;5010:38;5044:2;5033:9;5029:18;5010:38;:::i;5059:245::-;5117:6;5170:2;5158:9;5149:7;5145:23;5141:32;5138:52;;;5186:1;5183;5176:12;5138:52;5225:9;5212:23;5244:30;5268:5;5244:30;:::i;5309:249::-;5378:6;5431:2;5419:9;5410:7;5406:23;5402:32;5399:52;;;5447:1;5444;5437:12;5399:52;5479:9;5473:16;5498:30;5522:5;5498:30;:::i;5563:592::-;5634:6;5642;5695:2;5683:9;5674:7;5670:23;5666:32;5663:52;;;5711:1;5708;5701:12;5663:52;5751:9;5738:23;5780:18;5821:2;5813:6;5810:14;5807:34;;;5837:1;5834;5827:12;5807:34;5875:6;5864:9;5860:22;5850:32;;5920:7;5913:4;5909:2;5905:13;5901:27;5891:55;;5942:1;5939;5932:12;5891:55;5982:2;5969:16;6008:2;6000:6;5997:14;5994:34;;;6024:1;6021;6014:12;5994:34;6069:7;6064:2;6055:6;6051:2;6047:15;6043:24;6040:37;6037:57;;;6090:1;6087;6080:12;6037:57;6121:2;6113:11;;;;;6143:6;;-1:-1:-1;5563:592:1;;-1:-1:-1;;;;5563:592:1:o;6345:184::-;6415:6;6468:2;6456:9;6447:7;6443:23;6439:32;6436:52;;;6484:1;6481;6474:12;6436:52;-1:-1:-1;6507:16:1;;6345:184;-1:-1:-1;6345:184:1:o;6534:257::-;6575:3;6613:5;6607:12;6640:6;6635:3;6628:19;6656:63;6712:6;6705:4;6700:3;6696:14;6689:4;6682:5;6678:16;6656:63;:::i;:::-;6773:2;6752:15;-1:-1:-1;;6748:29:1;6739:39;;;;6780:4;6735:50;;6534:257;-1:-1:-1;;6534:257:1:o;6796:274::-;6925:3;6963:6;6957:13;6979:53;7025:6;7020:3;7013:4;7005:6;7001:17;6979:53;:::i;:::-;7048:16;;;;;6796:274;-1:-1:-1;;6796:274:1:o;7075:470::-;7254:3;7292:6;7286:13;7308:53;7354:6;7349:3;7342:4;7334:6;7330:17;7308:53;:::i;:::-;7424:13;;7383:16;;;;7446:57;7424:13;7383:16;7480:4;7468:17;;7446:57;:::i;:::-;7519:20;;7075:470;-1:-1:-1;;;;7075:470:1:o;7550:786::-;7961:25;7956:3;7949:38;7931:3;8016:6;8010:13;8032:62;8087:6;8082:2;8077:3;8073:12;8066:4;8058:6;8054:17;8032:62;:::i;:::-;-1:-1:-1;;;8153:2:1;8113:16;;;8145:11;;;8138:40;8203:13;;8225:63;8203:13;8274:2;8266:11;;8259:4;8247:17;;8225:63;:::i;:::-;8308:17;8327:2;8304:26;;7550:786;-1:-1:-1;;;;7550:786:1:o;8929:488::-;-1:-1:-1;;;;;9198:15:1;;;9180:34;;9250:15;;9245:2;9230:18;;9223:43;9297:2;9282:18;;9275:34;;;9345:3;9340:2;9325:18;;9318:31;;;9123:4;;9366:45;;9391:19;;9383:6;9366:45;:::i;:::-;9358:53;8929:488;-1:-1:-1;;;;;;8929:488:1:o;10075:219::-;10224:2;10213:9;10206:21;10187:4;10244:44;10284:2;10273:9;10269:18;10261:6;10244:44;:::i;10992:414::-;11194:2;11176:21;;;11233:2;11213:18;;;11206:30;11272:34;11267:2;11252:18;;11245:62;-1:-1:-1;;;11338:2:1;11323:18;;11316:48;11396:3;11381:19;;10992:414::o;19169:413::-;19371:2;19353:21;;;19410:2;19390:18;;;19383:30;19449:34;19444:2;19429:18;;19422:62;-1:-1:-1;;;19515:2:1;19500:18;;19493:47;19572:3;19557:19;;19169:413::o;21544:275::-;21615:2;21609:9;21680:2;21661:13;;-1:-1:-1;;21657:27:1;21645:40;;21715:18;21700:34;;21736:22;;;21697:62;21694:88;;;21762:18;;:::i;:::-;21798:2;21791:22;21544:275;;-1:-1:-1;21544:275:1:o;21824:183::-;21884:4;21917:18;21909:6;21906:30;21903:56;;;21939:18;;:::i;:::-;-1:-1:-1;21984:1:1;21980:14;21996:4;21976:25;;21824:183::o;22012:128::-;22052:3;22083:1;22079:6;22076:1;22073:13;22070:39;;;22089:18;;:::i;:::-;-1:-1:-1;22125:9:1;;22012:128::o;22145:120::-;22185:1;22211;22201:35;;22216:18;;:::i;:::-;-1:-1:-1;22250:9:1;;22145:120::o;22270:168::-;22310:7;22376:1;22372;22368:6;22364:14;22361:1;22358:21;22353:1;22346:9;22339:17;22335:45;22332:71;;;22383:18;;:::i;:::-;-1:-1:-1;22423:9:1;;22270:168::o;22443:125::-;22483:4;22511:1;22508;22505:8;22502:34;;;22516:18;;:::i;:::-;-1:-1:-1;22553:9:1;;22443:125::o;22573:258::-;22645:1;22655:113;22669:6;22666:1;22663:13;22655:113;;;22745:11;;;22739:18;22726:11;;;22719:39;22691:2;22684:10;22655:113;;;22786:6;22783:1;22780:13;22777:48;;;-1:-1:-1;;22821:1:1;22803:16;;22796:27;22573:258::o;22836:136::-;22875:3;22903:5;22893:39;;22912:18;;:::i;:::-;-1:-1:-1;;;22948:18:1;;22836:136::o;22977:380::-;23056:1;23052:12;;;;23099;;;23120:61;;23174:4;23166:6;23162:17;23152:27;;23120:61;23227:2;23219:6;23216:14;23196:18;23193:38;23190:161;;;23273:10;23268:3;23264:20;23261:1;23254:31;23308:4;23305:1;23298:15;23336:4;23333:1;23326:15;23190:161;;22977:380;;;:::o;23362:135::-;23401:3;-1:-1:-1;;23422:17:1;;23419:43;;;23442:18;;:::i;:::-;-1:-1:-1;23489:1:1;23478:13;;23362:135::o;23502:112::-;23534:1;23560;23550:35;;23565:18;;:::i;:::-;-1:-1:-1;23599:9:1;;23502:112::o;23619:127::-;23680:10;23675:3;23671:20;23668:1;23661:31;23711:4;23708:1;23701:15;23735:4;23732:1;23725:15;23751:127;23812:10;23807:3;23803:20;23800:1;23793:31;23843:4;23840:1;23833:15;23867:4;23864:1;23857:15;23883:127;23944:10;23939:3;23935:20;23932:1;23925:31;23975:4;23972:1;23965:15;23999:4;23996:1;23989:15;24015:127;24076:10;24071:3;24067:20;24064:1;24057:31;24107:4;24104:1;24097:15;24131:4;24128:1;24121:15;24147:118;24233:5;24226:13;24219:21;24212:5;24209:32;24199:60;;24255:1;24252;24245:12;24270:131;-1:-1:-1;;;;;;24344:32:1;;24334:43;;24324:71;;24391:1;24388;24381:12

ipfs://eca4408f43d931969046264193d54b09791bd06e698f20a1bfba437ad2b212ff