ERC-721
Overview
Max Total Supply
27,216 MOONIE
Holders
20,860
Market
Volume (24H)
N/A
Min Price (24H)
N/A
Max Price (24H)
N/A
Other Info
Token Contract
Balance
1 MOONIELoading...
Loading
Loading...
Loading
Loading...
Loading
Contract Name:
MoonieNFT
Compiler Version
v0.8.4+commit.c7e474f2
Contract Source Code (Solidity)
/** *Submitted for verification at polygonscan.com on 2021-08-28 */ // Sources flattened with hardhat v2.4.3 https://hardhat.org // File @openzeppelin/contracts/utils/introspection/[email protected] // SPDX-License-Identifier: MIT pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } // File @openzeppelin/contracts/token/ERC721/[email protected] pragma solidity ^0.8.0; /** * @dev Required interface of an ERC721 compliant contract. */ interface IERC721 is IERC165 { /** * @dev Emitted when `tokenId` token is transferred from `from` to `to`. */ event Transfer(address indexed from, address indexed to, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token. */ event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId); /** * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets. */ event ApprovalForAll(address indexed owner, address indexed operator, bool approved); /** * @dev Returns the number of tokens in ``owner``'s account. */ function balanceOf(address owner) external view returns (uint256 balance); /** * @dev Returns the owner of the `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function ownerOf(uint256 tokenId) external view returns (address owner); /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Transfers `tokenId` token from `from` to `to`. * * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * * Emits a {Transfer} event. */ function transferFrom( address from, address to, uint256 tokenId ) external; /** * @dev Gives permission to `to` to transfer `tokenId` token to another account. * The approval is cleared when the token is transferred. * * Only a single account can be approved at a time, so approving the zero address clears previous approvals. * * Requirements: * * - The caller must own the token or be an approved operator. * - `tokenId` must exist. * * Emits an {Approval} event. */ function approve(address to, uint256 tokenId) external; /** * @dev Returns the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @dev Approve or remove `operator` as an operator for the caller. * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller. * * Requirements: * * - The `operator` cannot be the caller. * * Emits an {ApprovalForAll} event. */ function setApprovalForAll(address operator, bool _approved) external; /** * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`. * * See {setApprovalForAll} */ function isApprovedForAll(address owner, address operator) external view returns (bool); /** * @dev Safely transfers `tokenId` token from `from` to `to`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes calldata data ) external; } // File contracts/common/IERC721Mintable.sol pragma solidity 0.8.4; interface IERC721Mintable is IERC721 { function mint(address user, uint256 tokenId, string memory tokenURI) external; function exists(uint256 tokenId) external view returns (bool); } // File @openzeppelin/contracts/token/ERC721/[email protected] pragma solidity ^0.8.0; /** * @title ERC721 token receiver interface * @dev Interface for any contract that wants to support safeTransfers * from ERC721 asset contracts. */ interface IERC721Receiver { /** * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom} * by `operator` from `from`, this function is called. * * It must return its Solidity selector to confirm the token transfer. * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted. * * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`. */ function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); } // File @openzeppelin/contracts/token/ERC721/extensions/[email protected] pragma solidity ^0.8.0; /** * @title ERC-721 Non-Fungible Token Standard, optional metadata extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Metadata is IERC721 { /** * @dev Returns the token collection name. */ function name() external view returns (string memory); /** * @dev Returns the token collection symbol. */ function symbol() external view returns (string memory); /** * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token. */ function tokenURI(uint256 tokenId) external view returns (string memory); } // File @openzeppelin/contracts/utils/[email protected] pragma solidity ^0.8.0; /** * @dev Collection of functions related to the address type */ library Address { /** * @dev Returns true if `account` is a contract. * * [IMPORTANT] * ==== * It is unsafe to assume that an address for which this function returns * false is an externally-owned account (EOA) and not a contract. * * Among others, `isContract` will return false for the following * types of addresses: * * - an externally-owned account * - a contract in construction * - an address where a contract will be created * - an address where a contract lived, but was destroyed * ==== */ function isContract(address account) internal view returns (bool) { // This method relies on extcodesize, which returns 0 for contracts in // construction, since the code is only stored at the end of the // constructor execution. uint256 size; assembly { size := extcodesize(account) } return size > 0; } /** * @dev Replacement for Solidity's `transfer`: sends `amount` wei to * `recipient`, forwarding all available gas and reverting on errors. * * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost * of certain opcodes, possibly making contracts go over the 2300 gas limit * imposed by `transfer`, making them unable to receive funds via * `transfer`. {sendValue} removes this limitation. * * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more]. * * IMPORTANT: because control is transferred to `recipient`, care must be * taken to not create reentrancy vulnerabilities. Consider using * {ReentrancyGuard} or the * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern]. */ function sendValue(address payable recipient, uint256 amount) internal { require(address(this).balance >= amount, "Address: insufficient balance"); (bool success, ) = recipient.call{value: amount}(""); require(success, "Address: unable to send value, recipient may have reverted"); } /** * @dev Performs a Solidity function call using a low level `call`. A * plain `call` is an unsafe replacement for a function call: use this * function instead. * * If `target` reverts with a revert reason, it is bubbled up by this * function (like regular Solidity function calls). * * Returns the raw returned data. To convert to the expected return value, * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`]. * * Requirements: * * - `target` must be a contract. * - calling `target` with `data` must not revert. * * _Available since v3.1._ */ function functionCall(address target, bytes memory data) internal returns (bytes memory) { return functionCall(target, data, "Address: low-level call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with * `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { return functionCallWithValue(target, data, 0, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but also transferring `value` wei to `target`. * * Requirements: * * - the calling contract must have an ETH balance of at least `value`. * - the called Solidity function must be `payable`. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value ) internal returns (bytes memory) { return functionCallWithValue(target, data, value, "Address: low-level call with value failed"); } /** * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but * with `errorMessage` as a fallback revert reason when `target` reverts. * * _Available since v3.1._ */ function functionCallWithValue( address target, bytes memory data, uint256 value, string memory errorMessage ) internal returns (bytes memory) { require(address(this).balance >= value, "Address: insufficient balance for call"); require(isContract(target), "Address: call to non-contract"); (bool success, bytes memory returndata) = target.call{value: value}(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) { return functionStaticCall(target, data, "Address: low-level static call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a static call. * * _Available since v3.3._ */ function functionStaticCall( address target, bytes memory data, string memory errorMessage ) internal view returns (bytes memory) { require(isContract(target), "Address: static call to non-contract"); (bool success, bytes memory returndata) = target.staticcall(data); return _verifyCallResult(success, returndata, errorMessage); } /** * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) { return functionDelegateCall(target, data, "Address: low-level delegate call failed"); } /** * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`], * but performing a delegate call. * * _Available since v3.4._ */ function functionDelegateCall( address target, bytes memory data, string memory errorMessage ) internal returns (bytes memory) { require(isContract(target), "Address: delegate call to non-contract"); (bool success, bytes memory returndata) = target.delegatecall(data); return _verifyCallResult(success, returndata, errorMessage); } function _verifyCallResult( bool success, bytes memory returndata, string memory errorMessage ) private pure returns (bytes memory) { if (success) { return returndata; } else { // Look for revert reason and bubble it up if present if (returndata.length > 0) { // The easiest way to bubble the revert reason is using memory via assembly assembly { let returndata_size := mload(returndata) revert(add(32, returndata), returndata_size) } } else { revert(errorMessage); } } } } // File @openzeppelin/contracts/utils/[email protected] pragma solidity ^0.8.0; /* * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } // File @openzeppelin/contracts/utils/[email protected] pragma solidity ^0.8.0; /** * @dev String operations. */ library Strings { bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef"; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { // Inspired by OraclizeAPI's implementation - MIT licence // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol if (value == 0) { return "0"; } uint256 temp = value; uint256 digits; while (temp != 0) { digits++; temp /= 10; } bytes memory buffer = new bytes(digits); while (value != 0) { digits -= 1; buffer[digits] = bytes1(uint8(48 + uint256(value % 10))); value /= 10; } return string(buffer); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { if (value == 0) { return "0x00"; } uint256 temp = value; uint256 length = 0; while (temp != 0) { length++; temp >>= 8; } return toHexString(value, length); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _HEX_SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } } // File @openzeppelin/contracts/utils/introspection/[email protected] pragma solidity ^0.8.0; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } } // File @openzeppelin/contracts/token/ERC721/[email protected] pragma solidity ^0.8.0; /** * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including * the Metadata extension, but not including the Enumerable extension, which is available separately as * {ERC721Enumerable}. */ contract ERC721 is Context, ERC165, IERC721, IERC721Metadata { using Address for address; using Strings for uint256; // Token name string private _name; // Token symbol string private _symbol; // Mapping from token ID to owner address mapping(uint256 => address) private _owners; // Mapping owner address to token count mapping(address => uint256) private _balances; // Mapping from token ID to approved address mapping(uint256 => address) private _tokenApprovals; // Mapping from owner to operator approvals mapping(address => mapping(address => bool)) private _operatorApprovals; /** * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection. */ constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC165, IERC165) returns (bool) { return interfaceId == type(IERC721).interfaceId || interfaceId == type(IERC721Metadata).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view virtual override returns (uint256) { require(owner != address(0), "ERC721: balance query for the zero address"); return _balances[owner]; } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view virtual override returns (address) { address owner = _owners[tokenId]; require(owner != address(0), "ERC721: owner query for nonexistent token"); return owner; } /** * @dev See {IERC721Metadata-name}. */ function name() public view virtual override returns (string memory) { return _name; } /** * @dev See {IERC721Metadata-symbol}. */ function symbol() public view virtual override returns (string memory) { return _symbol; } /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token"); string memory baseURI = _baseURI(); return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : ""; } /** * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each * token will be the concatenation of the `baseURI` and the `tokenId`. Empty * by default, can be overriden in child contracts. */ function _baseURI() internal view virtual returns (string memory) { return ""; } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public virtual override { address owner = ERC721.ownerOf(tokenId); require(to != owner, "ERC721: approval to current owner"); require( _msgSender() == owner || isApprovedForAll(owner, _msgSender()), "ERC721: approve caller is not owner nor approved for all" ); _approve(to, tokenId); } /** * @dev See {IERC721-getApproved}. */ function getApproved(uint256 tokenId) public view virtual override returns (address) { require(_exists(tokenId), "ERC721: approved query for nonexistent token"); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll(address operator, bool approved) public virtual override { require(operator != _msgSender(), "ERC721: approve to caller"); _operatorApprovals[_msgSender()][operator] = approved; emit ApprovalForAll(_msgSender(), operator, approved); } /** * @dev See {IERC721-isApprovedForAll}. */ function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) { return _operatorApprovals[owner][operator]; } /** * @dev See {IERC721-transferFrom}. */ function transferFrom( address from, address to, uint256 tokenId ) public virtual override { //solhint-disable-next-line max-line-length require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved"); _transfer(from, to, tokenId); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId ) public virtual override { safeTransferFrom(from, to, tokenId, ""); } /** * @dev See {IERC721-safeTransferFrom}. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes memory _data ) public virtual override { require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved"); _safeTransfer(from, to, tokenId, _data); } /** * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients * are aware of the ERC721 protocol to prevent tokens from being forever locked. * * `_data` is additional data, it has no specified format and it is sent in call to `to`. * * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g. * implement alternative mechanisms to perform token transfer, such as signature-based. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeTransfer( address from, address to, uint256 tokenId, bytes memory _data ) internal virtual { _transfer(from, to, tokenId); require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer"); } /** * @dev Returns whether `tokenId` exists. * * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}. * * Tokens start existing when they are minted (`_mint`), * and stop existing when they are burned (`_burn`). */ function _exists(uint256 tokenId) internal view virtual returns (bool) { return _owners[tokenId] != address(0); } /** * @dev Returns whether `spender` is allowed to manage `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) { require(_exists(tokenId), "ERC721: operator query for nonexistent token"); address owner = ERC721.ownerOf(tokenId); return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender)); } /** * @dev Safely mints `tokenId` and transfers it to `to`. * * Requirements: * * - `tokenId` must not exist. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function _safeMint(address to, uint256 tokenId) internal virtual { _safeMint(to, tokenId, ""); } /** * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is * forwarded in {IERC721Receiver-onERC721Received} to contract recipients. */ function _safeMint( address to, uint256 tokenId, bytes memory _data ) internal virtual { _mint(to, tokenId); require( _checkOnERC721Received(address(0), to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer" ); } /** * @dev Mints `tokenId` and transfers it to `to`. * * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible * * Requirements: * * - `tokenId` must not exist. * - `to` cannot be the zero address. * * Emits a {Transfer} event. */ function _mint(address to, uint256 tokenId) internal virtual { require(to != address(0), "ERC721: mint to the zero address"); require(!_exists(tokenId), "ERC721: token already minted"); _beforeTokenTransfer(address(0), to, tokenId); _balances[to] += 1; _owners[tokenId] = to; emit Transfer(address(0), to, tokenId); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * * Requirements: * * - `tokenId` must exist. * * Emits a {Transfer} event. */ function _burn(uint256 tokenId) internal virtual { address owner = ERC721.ownerOf(tokenId); _beforeTokenTransfer(owner, address(0), tokenId); // Clear approvals _approve(address(0), tokenId); _balances[owner] -= 1; delete _owners[tokenId]; emit Transfer(owner, address(0), tokenId); } /** * @dev Transfers `tokenId` from `from` to `to`. * As opposed to {transferFrom}, this imposes no restrictions on msg.sender. * * Requirements: * * - `to` cannot be the zero address. * - `tokenId` token must be owned by `from`. * * Emits a {Transfer} event. */ function _transfer( address from, address to, uint256 tokenId ) internal virtual { require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own"); require(to != address(0), "ERC721: transfer to the zero address"); _beforeTokenTransfer(from, to, tokenId); // Clear approvals from the previous owner _approve(address(0), tokenId); _balances[from] -= 1; _balances[to] += 1; _owners[tokenId] = to; emit Transfer(from, to, tokenId); } /** * @dev Approve `to` to operate on `tokenId` * * Emits a {Approval} event. */ function _approve(address to, uint256 tokenId) internal virtual { _tokenApprovals[tokenId] = to; emit Approval(ERC721.ownerOf(tokenId), to, tokenId); } /** * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address. * The call is not executed if the target address is not a contract. * * @param from address representing the previous owner of the given token ID * @param to target address that will receive the tokens * @param tokenId uint256 ID of the token to be transferred * @param _data bytes optional data to send along with the call * @return bool whether the call correctly returned the expected magic value */ function _checkOnERC721Received( address from, address to, uint256 tokenId, bytes memory _data ) private returns (bool) { if (to.isContract()) { try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) { return retval == IERC721Receiver(to).onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert("ERC721: transfer to non ERC721Receiver implementer"); } else { assembly { revert(add(32, reason), mload(reason)) } } } } else { return true; } } /** * @dev Hook that is called before any token transfer. This includes minting * and burning. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be * transferred to `to`. * - When `from` is zero, `tokenId` will be minted for `to`. * - When `to` is zero, ``from``'s `tokenId` will be burned. * - `from` and `to` are never both zero. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 tokenId ) internal virtual {} } // File @openzeppelin/contracts/token/ERC721/extensions/[email protected] pragma solidity ^0.8.0; /** * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension * @dev See https://eips.ethereum.org/EIPS/eip-721 */ interface IERC721Enumerable is IERC721 { /** * @dev Returns the total amount of tokens stored by the contract. */ function totalSupply() external view returns (uint256); /** * @dev Returns a token ID owned by `owner` at a given `index` of its token list. * Use along with {balanceOf} to enumerate all of ``owner``'s tokens. */ function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId); /** * @dev Returns a token ID at a given `index` of all the tokens stored by the contract. * Use along with {totalSupply} to enumerate all tokens. */ function tokenByIndex(uint256 index) external view returns (uint256); } // File @openzeppelin/contracts/token/ERC721/extensions/[email protected] pragma solidity ^0.8.0; /** * @dev This implements an optional extension of {ERC721} defined in the EIP that adds * enumerability of all the token ids in the contract as well as all token ids owned by each * account. */ abstract contract ERC721Enumerable is ERC721, IERC721Enumerable { // Mapping from owner to list of owned token IDs mapping(address => mapping(uint256 => uint256)) private _ownedTokens; // Mapping from token ID to index of the owner tokens list mapping(uint256 => uint256) private _ownedTokensIndex; // Array with all token ids, used for enumeration uint256[] private _allTokens; // Mapping from token id to position in the allTokens array mapping(uint256 => uint256) private _allTokensIndex; /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC721) returns (bool) { return interfaceId == type(IERC721Enumerable).interfaceId || super.supportsInterface(interfaceId); } /** * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}. */ function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) { require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds"); return _ownedTokens[owner][index]; } /** * @dev See {IERC721Enumerable-totalSupply}. */ function totalSupply() public view virtual override returns (uint256) { return _allTokens.length; } /** * @dev See {IERC721Enumerable-tokenByIndex}. */ function tokenByIndex(uint256 index) public view virtual override returns (uint256) { require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds"); return _allTokens[index]; } /** * @dev Hook that is called before any token transfer. This includes minting * and burning. * * Calling conditions: * * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be * transferred to `to`. * - When `from` is zero, `tokenId` will be minted for `to`. * - When `to` is zero, ``from``'s `tokenId` will be burned. * - `from` cannot be the zero address. * - `to` cannot be the zero address. * * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks]. */ function _beforeTokenTransfer( address from, address to, uint256 tokenId ) internal virtual override { super._beforeTokenTransfer(from, to, tokenId); if (from == address(0)) { _addTokenToAllTokensEnumeration(tokenId); } else if (from != to) { _removeTokenFromOwnerEnumeration(from, tokenId); } if (to == address(0)) { _removeTokenFromAllTokensEnumeration(tokenId); } else if (to != from) { _addTokenToOwnerEnumeration(to, tokenId); } } /** * @dev Private function to add a token to this extension's ownership-tracking data structures. * @param to address representing the new owner of the given token ID * @param tokenId uint256 ID of the token to be added to the tokens list of the given address */ function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private { uint256 length = ERC721.balanceOf(to); _ownedTokens[to][length] = tokenId; _ownedTokensIndex[tokenId] = length; } /** * @dev Private function to add a token to this extension's token tracking data structures. * @param tokenId uint256 ID of the token to be added to the tokens list */ function _addTokenToAllTokensEnumeration(uint256 tokenId) private { _allTokensIndex[tokenId] = _allTokens.length; _allTokens.push(tokenId); } /** * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for * gas optimizations e.g. when performing a transfer operation (avoiding double writes). * This has O(1) time complexity, but alters the order of the _ownedTokens array. * @param from address representing the previous owner of the given token ID * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address */ function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private { // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and // then delete the last slot (swap and pop). uint256 lastTokenIndex = ERC721.balanceOf(from) - 1; uint256 tokenIndex = _ownedTokensIndex[tokenId]; // When the token to delete is the last token, the swap operation is unnecessary if (tokenIndex != lastTokenIndex) { uint256 lastTokenId = _ownedTokens[from][lastTokenIndex]; _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index } // This also deletes the contents at the last position of the array delete _ownedTokensIndex[tokenId]; delete _ownedTokens[from][lastTokenIndex]; } /** * @dev Private function to remove a token from this extension's token tracking data structures. * This has O(1) time complexity, but alters the order of the _allTokens array. * @param tokenId uint256 ID of the token to be removed from the tokens list */ function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private { // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and // then delete the last slot (swap and pop). uint256 lastTokenIndex = _allTokens.length - 1; uint256 tokenIndex = _allTokensIndex[tokenId]; // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding // an 'if' statement (like in _removeTokenFromOwnerEnumeration) uint256 lastTokenId = _allTokens[lastTokenIndex]; _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index // This also deletes the contents at the last position of the array delete _allTokensIndex[tokenId]; _allTokens.pop(); } } // File @openzeppelin/contracts/token/ERC721/extensions/[email protected] pragma solidity ^0.8.0; /** * @title ERC721 Burnable Token * @dev ERC721 Token that can be irreversibly burned (destroyed). */ abstract contract ERC721Burnable is Context, ERC721 { /** * @dev Burns `tokenId`. See {ERC721-_burn}. * * Requirements: * * - The caller must own `tokenId` or be an approved operator. */ function burn(uint256 tokenId) public virtual { //solhint-disable-next-line max-line-length require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721Burnable: caller is not owner nor approved"); _burn(tokenId); } } // File @openzeppelin/contracts/token/ERC721/extensions/[email protected] pragma solidity ^0.8.0; /** * @dev ERC721 token with storage based token URI management. */ abstract contract ERC721URIStorage is ERC721 { using Strings for uint256; // Optional mapping for token URIs mapping(uint256 => string) private _tokenURIs; /** * @dev See {IERC721Metadata-tokenURI}. */ function tokenURI(uint256 tokenId) public view virtual override returns (string memory) { require(_exists(tokenId), "ERC721URIStorage: URI query for nonexistent token"); string memory _tokenURI = _tokenURIs[tokenId]; string memory base = _baseURI(); // If there is no base URI, return the token URI. if (bytes(base).length == 0) { return _tokenURI; } // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked). if (bytes(_tokenURI).length > 0) { return string(abi.encodePacked(base, _tokenURI)); } return super.tokenURI(tokenId); } /** * @dev Sets `_tokenURI` as the tokenURI of `tokenId`. * * Requirements: * * - `tokenId` must exist. */ function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual { require(_exists(tokenId), "ERC721URIStorage: URI set of nonexistent token"); _tokenURIs[tokenId] = _tokenURI; } /** * @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 override { super._burn(tokenId); if (bytes(_tokenURIs[tokenId]).length != 0) { delete _tokenURIs[tokenId]; } } } // File @openzeppelin/contracts/access/[email protected] pragma solidity ^0.8.0; /** * @dev External interface of AccessControl declared to support ERC165 detection. */ interface IAccessControl { function hasRole(bytes32 role, address account) external view returns (bool); function getRoleAdmin(bytes32 role) external view returns (bytes32); function grantRole(bytes32 role, address account) external; function revokeRole(bytes32 role, address account) external; 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 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 {_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 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]{20}) is missing role (0x[0-9a-f]{32})$/ * * _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]{20}) is missing role (0x[0-9a-f]{32})$/ */ 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 { emit RoleAdminChanged(role, getRoleAdmin(role), adminRole); _roles[role].adminRole = 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()); } } } // File contracts/common/AccessControlMixin.sol pragma solidity 0.8.4; contract AccessControlMixin is AccessControl { string private _revertMsg; function _setupContractId(string memory contractId) internal { _revertMsg = string(abi.encodePacked(contractId, ": INSUFFICIENT_PERMISSIONS")); } modifier only(bytes32 role) { require( hasRole(role, _msgSender()), _revertMsg ); _; } } // File @openzeppelin/contracts/utils/math/[email protected] pragma solidity ^0.8.0; // CAUTION // This version of SafeMath should only be used with Solidity 0.8 or later, // because it relies on the compiler's built in overflow checks. /** * @dev Wrappers over Solidity's arithmetic operations. * * NOTE: `SafeMath` is no longer needed starting with Solidity 0.8. The compiler * now has built in overflow checking. */ library SafeMath { /** * @dev Returns the addition of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { uint256 c = a + b; if (c < a) return (false, 0); return (true, c); } } /** * @dev Returns the substraction of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b > a) return (false, 0); return (true, a - b); } } /** * @dev Returns the multiplication of two unsigned integers, with an overflow flag. * * _Available since v3.4._ */ function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { // Gas optimization: this is cheaper than requiring 'a' not being zero, but the // benefit is lost if 'b' is also tested. // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522 if (a == 0) return (true, 0); uint256 c = a * b; if (c / a != b) return (false, 0); return (true, c); } } /** * @dev Returns the division of two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a / b); } } /** * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag. * * _Available since v3.4._ */ function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) { unchecked { if (b == 0) return (false, 0); return (true, a % b); } } /** * @dev Returns the addition of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `+` operator. * * Requirements: * * - Addition cannot overflow. */ function add(uint256 a, uint256 b) internal pure returns (uint256) { return a + b; } /** * @dev Returns the subtraction of two unsigned integers, reverting on * overflow (when the result is negative). * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub(uint256 a, uint256 b) internal pure returns (uint256) { return a - b; } /** * @dev Returns the multiplication of two unsigned integers, reverting on * overflow. * * Counterpart to Solidity's `*` operator. * * Requirements: * * - Multiplication cannot overflow. */ function mul(uint256 a, uint256 b) internal pure returns (uint256) { return a * b; } /** * @dev Returns the integer division of two unsigned integers, reverting on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. * * Requirements: * * - The divisor cannot be zero. */ function div(uint256 a, uint256 b) internal pure returns (uint256) { return a / b; } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting when dividing by zero. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod(uint256 a, uint256 b) internal pure returns (uint256) { return a % b; } /** * @dev Returns the subtraction of two unsigned integers, reverting with custom message on * overflow (when the result is negative). * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {trySub}. * * Counterpart to Solidity's `-` operator. * * Requirements: * * - Subtraction cannot overflow. */ function sub( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b <= a, errorMessage); return a - b; } } /** * @dev Returns the integer division of two unsigned integers, reverting with custom message on * division by zero. The result is rounded towards zero. * * Counterpart to Solidity's `/` operator. Note: this function uses a * `revert` opcode (which leaves remaining gas untouched) while Solidity * uses an invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function div( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a / b; } } /** * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo), * reverting with custom message when dividing by zero. * * CAUTION: This function is deprecated because it requires allocating memory for the error * message unnecessarily. For custom revert reasons use {tryMod}. * * Counterpart to Solidity's `%` operator. This function uses a `revert` * opcode (which leaves remaining gas untouched) while Solidity uses an * invalid opcode to revert (consuming all remaining gas). * * Requirements: * * - The divisor cannot be zero. */ function mod( uint256 a, uint256 b, string memory errorMessage ) internal pure returns (uint256) { unchecked { require(b > 0, errorMessage); return a % b; } } } // File @openzeppelin/contracts-upgradeable/proxy/utils/[email protected] pragma solidity ^0.8.0; /** * @dev This is a base contract to aid in writing upgradeable contracts, or any kind of contract that will be deployed * behind a proxy. Since a proxied contract can't have a constructor, it's common to move constructor logic to an * external initializer function, usually called `initialize`. It then becomes necessary to protect this initializer * function so it can only be called once. The {initializer} modifier provided by this contract will have this effect. * * TIP: To avoid leaving the proxy in an uninitialized state, the initializer function should be called as early as * possible by providing the encoded function call as the `_data` argument to {ERC1967Proxy-constructor}. * * CAUTION: When used with inheritance, manual care must be taken to not invoke a parent initializer twice, or to ensure * that all initializers are idempotent. This is not verified automatically as constructors are by Solidity. */ abstract contract Initializable { /** * @dev Indicates that the contract has been initialized. */ bool private _initialized; /** * @dev Indicates that the contract is in the process of being initialized. */ bool private _initializing; /** * @dev Modifier to protect an initializer function from being invoked twice. */ modifier initializer() { require(_initializing || !_initialized, "Initializable: contract is already initialized"); bool isTopLevelCall = !_initializing; if (isTopLevelCall) { _initializing = true; _initialized = true; } _; if (isTopLevelCall) { _initializing = false; } } } // File contracts/common/EIP712Base.sol pragma solidity 0.8.4; contract EIP712Base is Initializable { struct EIP712Domain { string name; string version; address verifyingContract; bytes32 salt; } string constant public ERC712_VERSION = "1"; bytes32 internal constant EIP712_DOMAIN_TYPEHASH = keccak256( bytes( "EIP712Domain(string name,string version,address verifyingContract,bytes32 salt)" ) ); bytes32 internal domainSeperator; // supposed to be called once while initializing. // one of the contractsa that inherits this contract follows proxy pattern // so it is not possible to do this in a constructor function _initializeEIP712( string memory name ) internal initializer { _setDomainSeperator(name); } function _setDomainSeperator(string memory name) internal { domainSeperator = keccak256( abi.encode( EIP712_DOMAIN_TYPEHASH, keccak256(bytes(name)), keccak256(bytes(ERC712_VERSION)), address(this), bytes32(getChainId()) ) ); } function getDomainSeperator() public view returns (bytes32) { return domainSeperator; } function getChainId() public view returns (uint256) { uint256 id; assembly { id := chainid() } return id; } /** * Accept message hash and returns hash message in EIP712 compatible form * So that it can be used to recover signer from signature signed using EIP712 formatted data * https://eips.ethereum.org/EIPS/eip-712 * "\\x19" makes the encoding deterministic * "\\x01" is the version byte to make it compatible to EIP-191 */ function toTypedMessageHash(bytes32 messageHash) internal view returns (bytes32) { return keccak256( abi.encodePacked("\x19\x01", getDomainSeperator(), messageHash) ); } } // File contracts/common/NativeMetaTransaction.sol pragma solidity 0.8.4; contract NativeMetaTransaction is EIP712Base { using SafeMath for uint256; bytes32 private constant META_TRANSACTION_TYPEHASH = keccak256( bytes( "MetaTransaction(uint256 nonce,address from,bytes functionSignature)" ) ); event MetaTransactionExecuted( address userAddress, address relayerAddress, bytes functionSignature ); mapping(address => uint256) nonces; /* * Meta transaction structure. * No point of including value field here as if user is doing value transfer then he has the funds to pay for gas * He should call the desired function directly in that case. */ struct MetaTransaction { uint256 nonce; address from; bytes functionSignature; } function executeMetaTransaction( address userAddress, bytes memory functionSignature, bytes32 sigR, bytes32 sigS, uint8 sigV ) public payable returns (bytes memory) { MetaTransaction memory metaTx = MetaTransaction({ nonce: nonces[userAddress], from: userAddress, functionSignature: functionSignature }); require( verify(userAddress, metaTx, sigR, sigS, sigV), "Signer and signature do not match" ); // increase nonce for user (to avoid re-use) nonces[userAddress] = nonces[userAddress].add(1); emit MetaTransactionExecuted( userAddress, msg.sender, functionSignature ); // Append userAddress and relayer address at the end to extract it from calling context (bool success, bytes memory returnData) = address(this).call( abi.encodePacked(functionSignature, userAddress) ); require(success, "Function call not successful"); return returnData; } function hashMetaTransaction(MetaTransaction memory metaTx) internal pure returns (bytes32) { return keccak256( abi.encode( META_TRANSACTION_TYPEHASH, metaTx.nonce, metaTx.from, keccak256(metaTx.functionSignature) ) ); } function getNonce(address user) public view returns (uint256 nonce) { nonce = nonces[user]; } function verify( address signer, MetaTransaction memory metaTx, bytes32 sigR, bytes32 sigS, uint8 sigV ) internal view returns (bool) { require(signer != address(0), "NativeMetaTransaction: INVALID_SIGNER"); return signer == ecrecover( toTypedMessageHash(hashMetaTransaction(metaTx)), sigV, sigR, sigS ); } } // File contracts/common/ContextMixin.sol pragma solidity 0.8.4; abstract contract ContextMixin { function msgSender() internal view returns (address sender) { if (msg.sender == address(this)) { bytes memory array = msg.data; uint256 index = msg.data.length; assembly { // Load the 32 bytes word from memory with the address on the lower 20 bytes, and mask those. sender := and( mload(add(array, index)), 0xffffffffffffffffffffffffffffffffffffffff ) } } else { sender = msg.sender; } return sender; } } // File contracts/common/ProxyRegistry.sol pragma solidity 0.8.4; contract OwnableDelegateProxy {} contract ProxyRegistry { mapping(address => OwnableDelegateProxy) public proxies; } // File contracts/common/tunnel/FxBaseChildTunnel.sol pragma solidity ^0.8.0; // IFxMessageProcessor represents interface to process message interface IFxMessageProcessor { function processMessageFromRoot(uint256 stateId, address rootMessageSender, bytes calldata data) external; } /** * @notice Mock child tunnel contract to receive and send message from L2 */ abstract contract FxBaseChildTunnel is IFxMessageProcessor{ // MessageTunnel on L1 will get data from this event event MessageSent(bytes message); // fx child address public fxChild; // fx root tunnel address public fxRootTunnel; constructor(address _fxChild) { fxChild = _fxChild; } // Sender must be fxRootTunnel in case of ERC20 tunnel modifier validateSender(address sender) { require(sender == fxRootTunnel, "FxBaseChildTunnel: INVALID_SENDER_FROM_ROOT"); _; } // set fxRootTunnel if not set already function setFxRootTunnel(address _fxRootTunnel) external { require(fxRootTunnel == address(0x0), "FxBaseChildTunnel: ROOT_TUNNEL_ALREADY_SET"); fxRootTunnel = _fxRootTunnel; } function processMessageFromRoot(uint256 stateId, address rootMessageSender, bytes calldata data) external override { require(msg.sender == fxChild, "FxBaseChildTunnel: INVALID_SENDER"); _processMessageFromRoot(stateId, rootMessageSender, data); } /** * @notice Emit message that can be received on Root Tunnel * @dev Call the internal function when need to emit message * @param message bytes message that will be sent to Root Tunnel * some message examples - * abi.encode(tokenId); * abi.encode(tokenId, tokenMetadata); * abi.encode(messageType, messageData); */ function _sendMessageToRoot(bytes memory message) internal { emit MessageSent(message); } /** * @notice Process message received from Root Tunnel * @dev function needs to be implemented to handle message as per requirement * This is called by onStateReceive function. * Since it is called via a system call, any event will not be emitted during its execution. * @param stateId unique state id * @param sender root message sender * @param message bytes message that was sent from Root Tunnel */ function _processMessageFromRoot(uint256 stateId, address sender, bytes memory message) virtual internal; } // File contracts/matic/MoonieNFT.sol pragma solidity 0.8.4; contract MoonieNFT is IERC721Mintable, ERC721Burnable, ERC721Enumerable, ERC721URIStorage, AccessControlMixin, NativeMetaTransaction, ContextMixin, FxBaseChildTunnel { // STATE CONSTANTS bytes32 public constant MINTER_ROLE = keccak256("MINTER_ROLE"); // STATE VARIABLES address private _proxyRegistryAddress; uint256 private _latestStateId; // EVENTS event TransferToEthereum(address indexed owner, uint256 indexed tokenId); event ReceivedFromEthereum(address indexed owner, uint256 indexed tokenId); event Burned(uint256 indexed tokenId); // CONSTRUCTOR constructor( string memory name_, string memory symbol_, address proxyRegistryAddress_, address fxChild ) ERC721(name_, symbol_) FxBaseChildTunnel(fxChild) { _setupContractId("MoonieNFT"); _setupRole(DEFAULT_ADMIN_ROLE, _msgSender()); _initializeEIP712(name_); _proxyRegistryAddress = proxyRegistryAddress_; } // VIEWS function tokenURI(uint256 tokenId) public view virtual override(ERC721, ERC721URIStorage) returns (string memory) { return super.tokenURI(tokenId); } function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, AccessControl, ERC721, ERC721Enumerable) returns (bool) { return super.supportsInterface(interfaceId); } /** * Override isApprovedForAll to whitelist user's OpenSea proxy accounts to enable gas-less listings. */ function isApprovedForAll(address owner, address operator) override(IERC721, ERC721) public view returns (bool) { // Whitelist OpenSea proxy contract for easy trading. ProxyRegistry proxyRegistry = ProxyRegistry(_proxyRegistryAddress); if (address(proxyRegistry.proxies(owner)) == operator) { return true; } return super.isApprovedForAll(owner, operator); } // EXTERNAL FUNCTIONS /** * @notice Example function to handle minting tokens on matic chain * @dev Minting can be done as per requirement, * This implementation allows only admin to mint tokens but it can be changed as per requirement * Should verify if token is withdrawn by checking `withdrawnTokens` mapping * @param user user for whom tokens are being minted * @param tokenId tokenId to mint */ function mint(address user, uint256 tokenId, string memory tokenURI_) external override only(MINTER_ROLE) { _mint(user, tokenId); _setTokenURI(tokenId, tokenURI_); } function exists(uint256 tokenId) external view override returns (bool) { return _exists(tokenId); } function transferToEthereum(uint256 tokenId) external { require(_isApprovedOrOwner(_msgSender(), tokenId), "MoonieNFT: caller is not owner nor approved"); _sendMessageToRoot(abi.encode(_msgSender(), tokenId, _stripBaseURI(tokenId))); _burn(tokenId); emit TransferToEthereum(_msgSender(), tokenId); } function setProxyRegistryAddress(address proxyRegistryAddress) external only(DEFAULT_ADMIN_ROLE) { _proxyRegistryAddress = proxyRegistryAddress; } // INTERNAL FUNCTIONS function _burn(uint256 tokenId) internal virtual override(ERC721, ERC721URIStorage) { emit Burned(tokenId); super._burn(tokenId); } // This is to support Native meta transactions // never use msg.sender directly, use _msgSender() instead function _msgSender() internal override view returns (address) { return ContextMixin.msgSender(); } function _beforeTokenTransfer( address from, address to, uint256 tokenId ) internal virtual override(ERC721, ERC721Enumerable) { super._beforeTokenTransfer(from, to, tokenId); } function _baseURI() internal view virtual override returns (string memory) { return "ipfs://"; } function _stripBaseURI(uint256 tokenId) internal view returns (string memory) { bytes memory uri = bytes(tokenURI(tokenId)); uint256 uriLength = uri.length; bytes memory strippedUri = new bytes(uriLength - 7); for (uint256 i = 7; i < uriLength; i++) { strippedUri[i - 7] = uri[i]; } return string(strippedUri); } function _processMessageFromRoot(uint256 stateId, address sender, bytes memory data) internal override validateSender(sender) { _latestStateId = stateId; (address owner, uint256 tokenId, string memory tokenUri) = abi.decode(data, (address, uint256, string)); _mint(owner, tokenId); _setTokenURI(tokenId, tokenUri); emit ReceivedFromEthereum(owner, tokenId); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[{"internalType":"string","name":"name_","type":"string"},{"internalType":"string","name":"symbol_","type":"string"},{"internalType":"address","name":"proxyRegistryAddress_","type":"address"},{"internalType":"address","name":"fxChild","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":"uint256","name":"tokenId","type":"uint256"}],"name":"Burned","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"bytes","name":"message","type":"bytes"}],"name":"MessageSent","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"userAddress","type":"address"},{"indexed":false,"internalType":"address","name":"relayerAddress","type":"address"},{"indexed":false,"internalType":"bytes","name":"functionSignature","type":"bytes"}],"name":"MetaTransactionExecuted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ReceivedFromEthereum","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"previousAdminRole","type":"bytes32"},{"indexed":true,"internalType":"bytes32","name":"newAdminRole","type":"bytes32"}],"name":"RoleAdminChanged","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleGranted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"bytes32","name":"role","type":"bytes32"},{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"RoleRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"TransferToEthereum","type":"event"},{"inputs":[],"name":"DEFAULT_ADMIN_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"ERC712_VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"MINTER_ROLE","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"userAddress","type":"address"},{"internalType":"bytes","name":"functionSignature","type":"bytes"},{"internalType":"bytes32","name":"sigR","type":"bytes32"},{"internalType":"bytes32","name":"sigS","type":"bytes32"},{"internalType":"uint8","name":"sigV","type":"uint8"}],"name":"executeMetaTransaction","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"exists","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"fxChild","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"fxRootTunnel","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getChainId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDomainSeperator","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getNonce","outputs":[{"internalType":"uint256","name":"nonce","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"}],"name":"getRoleAdmin","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"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":"user","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"string","name":"tokenURI_","type":"string"}],"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":"uint256","name":"stateId","type":"uint256"},{"internalType":"address","name":"rootMessageSender","type":"address"},{"internalType":"bytes","name":"data","type":"bytes"}],"name":"processMessageFromRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"renounceRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"role","type":"bytes32"},{"internalType":"address","name":"account","type":"address"}],"name":"revokeRole","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_fxRootTunnel","type":"address"}],"name":"setFxRootTunnel","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"proxyRegistryAddress","type":"address"}],"name":"setProxyRegistryAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferToEthereum","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
60806040523480156200001157600080fd5b5060405162004caf38038062004caf833981016040819052620000349162000523565b80848481600090805190602001906200004f929190620003d1565b50805162000065906001906020840190620003d1565b5050601080546001600160a01b0319166001600160a01b03939093169290921790915550604080518082019091526009815268135bdbdb9a5953919560ba1b6020820152620000b490620000ff565b620000ca6000620000c46200013c565b62000158565b620000d58462000164565b50601280546001600160a01b0319166001600160a01b039290921691909117905550620006789050565b80604051602001620001129190620005af565b604051602081830303815290604052600c908051906020019062000138929190620003d1565b5050565b6000620001536200022a60201b62001ac51760201c565b905090565b62000138828262000289565b600d54610100900460ff16806200017e5750600d5460ff16155b620001e65760405162461bcd60e51b815260206004820152602e60248201527f496e697469616c697a61626c653a20636f6e747261637420697320616c72656160448201526d191e481a5b9a5d1a585b1a5e995960921b606482015260840160405180910390fd5b600d54610100900460ff161580156200020957600d805461ffff19166101011790555b62000214826200032f565b80156200013857600d805461ff00191690555050565b6000333014156200028357600080368080601f0160208091040260200160405190810160405280939291908181526020018383808284376000920191909152505050503601516001600160a01b03169150620002869050565b50335b90565b6000828152600b602090815260408083206001600160a01b038516845290915290205460ff1662000138576000828152600b602090815260408083206001600160a01b03851684529091529020805460ff19166001179055620002eb6200013c565b6001600160a01b0316816001600160a01b0316837f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d60405160405180910390a45050565b6040518060800160405280604f815260200162004c60604f9139805160209182012082519282019290922060408051808201825260018152603160f81b90840152805180840194909452838101919091527fc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc660608401523060808401524660a0808501919091528151808503909101815260c090930190528151910120600e55565b828054620003df9062000625565b90600052602060002090601f0160209004810192826200040357600085556200044e565b82601f106200041e57805160ff19168380011785556200044e565b828001600101855582156200044e579182015b828111156200044e57825182559160200191906001019062000431565b506200045c92915062000460565b5090565b5b808211156200045c576000815560010162000461565b80516001600160a01b03811681146200048f57600080fd5b919050565b600082601f830112620004a5578081fd5b81516001600160401b0380821115620004c257620004c262000662565b604051601f8301601f19908116603f01168101908282118183101715620004ed57620004ed62000662565b8160405283815286602085880101111562000506578485fd5b62000519846020830160208901620005f2565b9695505050505050565b6000806000806080858703121562000539578384fd5b84516001600160401b038082111562000550578586fd5b6200055e8883890162000494565b9550602087015191508082111562000574578485fd5b50620005838782880162000494565b935050620005946040860162000477565b9150620005a46060860162000477565b905092959194509250565b60008251620005c3818460208701620005f2565b7f3a20494e53554646494349454e545f5045524d495353494f4e53000000000000920191825250601a01919050565b60005b838110156200060f578181015183820152602001620005f5565b838111156200061f576000848401525b50505050565b600181811c908216806200063a57607f821691505b602082108114156200065c57634e487b7160e01b600052602260045260246000fd5b50919050565b634e487b7160e01b600052604160045260246000fd5b6145d880620006886000396000f3fe60806040526004361061026a5760003560e01c80634f558e7911610153578063a217fddf116100cb578063d3fc98641161007f578063d547741f11610064578063d547741f1461076e578063e4d8781e1461078e578063e985e9c5146107ae57600080fd5b8063d3fc98641461071a578063d53913931461073a57600080fd5b8063b88d4fde116100b0578063b88d4fde146106ba578063c87b56dd146106da578063d26ea6c0146106fa57600080fd5b8063a217fddf14610685578063a22cb4651461069a57600080fd5b80637f1e9cb01161012257806391d148541161010757806391d14854146105fd57806395d89b41146106505780639a7c4b711461066557600080fd5b80637f1e9cb0146105b057806388837094146105dd57600080fd5b80634f558e79146105305780634f6ccce7146105505780636352211e1461057057806370a082311461059057600080fd5b8063248a9ca3116101e65780633408e470116101b557806342842e0e1161019a57806342842e0e146104c357806342966c68146104e3578063450d11f01461050357600080fd5b80633408e4701461049057806336568abe146104a357600080fd5b8063248a9ca3146103dd5780632d0335ab1461040d5780632f2ff15d146104505780632f745c591461047057600080fd5b80630c53c51c1161023d57806318160ddd1161022257806318160ddd1461038957806320379ee5146103a857806323b872dd146103bd57600080fd5b80630c53c51c1461032d5780630f7e59701461034057600080fd5b806301ffc9a71461026f57806306fdde03146102a4578063081812fc146102c6578063095ea7b31461030b575b600080fd5b34801561027b57600080fd5b5061028f61028a366004613e83565b6107ce565b60405190151581526020015b60405180910390f35b3480156102b057600080fd5b506102b96107df565b60405161029b919061417b565b3480156102d257600080fd5b506102e66102e1366004613e47565b610871565b60405173ffffffffffffffffffffffffffffffffffffffff909116815260200161029b565b34801561031757600080fd5b5061032b610326366004613db2565b610950565b005b6102b961033b366004613d37565b610afc565b34801561034c57600080fd5b506102b96040518060400160405280600181526020017f310000000000000000000000000000000000000000000000000000000000000081525081565b34801561039557600080fd5b506008545b60405190815260200161029b565b3480156103b457600080fd5b50600e5461039a565b3480156103c957600080fd5b5061032b6103d8366004613c5c565b610d88565b3480156103e957600080fd5b5061039a6103f8366004613e47565b6000908152600b602052604090206001015490565b34801561041957600080fd5b5061039a610428366004613b76565b73ffffffffffffffffffffffffffffffffffffffff166000908152600f602052604090205490565b34801561045c57600080fd5b5061032b61046b366004613e5f565b610e30565b34801561047c57600080fd5b5061039a61048b366004613db2565b610e5d565b34801561049c57600080fd5b504661039a565b3480156104af57600080fd5b5061032b6104be366004613e5f565b610f2c565b3480156104cf57600080fd5b5061032b6104de366004613c5c565b610ffc565b3480156104ef57600080fd5b5061032b6104fe366004613e47565b611017565b34801561050f57600080fd5b506010546102e69073ffffffffffffffffffffffffffffffffffffffff1681565b34801561053c57600080fd5b5061028f61054b366004613e47565b6110ba565b34801561055c57600080fd5b5061039a61056b366004613e47565b6110e6565b34801561057c57600080fd5b506102e661058b366004613e47565b6111cb565b34801561059c57600080fd5b5061039a6105ab366004613b76565b61127d565b3480156105bc57600080fd5b506011546102e69073ffffffffffffffffffffffffffffffffffffffff1681565b3480156105e957600080fd5b5061032b6105f8366004613b76565b61134b565b34801561060957600080fd5b5061028f610618366004613e5f565b6000918252600b6020908152604080842073ffffffffffffffffffffffffffffffffffffffff93909316845291905290205460ff1690565b34801561065c57600080fd5b506102b9611438565b34801561067157600080fd5b5061032b610680366004613ed7565b611447565b34801561069157600080fd5b5061039a600081565b3480156106a657600080fd5b5061032b6106b5366004613d06565b611535565b3480156106c657600080fd5b5061032b6106d5366004613c9c565b6116a3565b3480156106e657600080fd5b506102b96106f5366004613e47565b61174c565b34801561070657600080fd5b5061032b610715366004613b76565b611757565b34801561072657600080fd5b5061032b610735366004613ddd565b6117e8565b34801561074657600080fd5b5061039a7f9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a681565b34801561077a57600080fd5b5061032b610789366004613e5f565b611864565b34801561079a57600080fd5b5061032b6107a9366004613e47565b61188c565b3480156107ba57600080fd5b5061028f6107c9366004613c24565b6119b5565b60006107d982611b2f565b92915050565b6060600080546107ee906143e1565b80601f016020809104026020016040519081016040528092919081815260200182805461081a906143e1565b80156108675780601f1061083c57610100808354040283529160200191610867565b820191906000526020600020905b81548152906001019060200180831161084a57829003601f168201915b5050505050905090565b60008181526002602052604081205473ffffffffffffffffffffffffffffffffffffffff16610927576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602c60248201527f4552433732313a20617070726f76656420717565727920666f72206e6f6e657860448201527f697374656e7420746f6b656e000000000000000000000000000000000000000060648201526084015b60405180910390fd5b5060009081526004602052604090205473ffffffffffffffffffffffffffffffffffffffff1690565b600061095b826111cb565b90508073ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161415610a19576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602160248201527f4552433732313a20617070726f76616c20746f2063757272656e74206f776e6560448201527f7200000000000000000000000000000000000000000000000000000000000000606482015260840161091e565b8073ffffffffffffffffffffffffffffffffffffffff16610a38611b85565b73ffffffffffffffffffffffffffffffffffffffff161480610a615750610a61816107c9611b85565b610aed576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603860248201527f4552433732313a20617070726f76652063616c6c6572206973206e6f74206f7760448201527f6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000606482015260840161091e565b610af78383611b94565b505050565b604080516060818101835273ffffffffffffffffffffffffffffffffffffffff88166000818152600f602090815290859020548452830152918101869052610b478782878787611c34565b610bd3576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602160248201527f5369676e657220616e64207369676e617475726520646f206e6f74206d61746360448201527f6800000000000000000000000000000000000000000000000000000000000000606482015260840161091e565b73ffffffffffffffffffffffffffffffffffffffff87166000908152600f6020526040902054610c04906001611d7d565b73ffffffffffffffffffffffffffffffffffffffff88166000908152600f60205260409081902091909155517f5845892132946850460bff5a0083f71031bc5bf9aadcd40f1de79423eac9b10b90610c6190899033908a906140bb565b60405180910390a16000803073ffffffffffffffffffffffffffffffffffffffff16888a604051602001610c96929190613fc1565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe081840301815290829052610cce91613fa5565b6000604051808303816000865af19150503d8060008114610d0b576040519150601f19603f3d011682016040523d82523d6000602084013e610d10565b606091505b509150915081610d7c576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601c60248201527f46756e6374696f6e2063616c6c206e6f74207375636365737366756c00000000604482015260640161091e565b98975050505050505050565b610d99610d93611b85565b82611d90565b610e25576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603160248201527f4552433732313a207472616e736665722063616c6c6572206973206e6f74206f60448201527f776e6572206e6f7220617070726f766564000000000000000000000000000000606482015260840161091e565b610af7838383611ecb565b6000828152600b6020526040902060010154610e5381610e4e611b85565b61213d565b610af7838361220f565b6000610e688361127d565b8210610ef6576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602b60248201527f455243373231456e756d657261626c653a206f776e657220696e646578206f7560448201527f74206f6620626f756e6473000000000000000000000000000000000000000000606482015260840161091e565b5073ffffffffffffffffffffffffffffffffffffffff919091166000908152600660209081526040808320938352929052205490565b610f34611b85565b73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff1614610fee576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602f60248201527f416363657373436f6e74726f6c3a2063616e206f6e6c792072656e6f756e636560448201527f20726f6c657320666f722073656c660000000000000000000000000000000000606482015260840161091e565b610ff88282612304565b5050565b610af7838383604051806020016040528060008152506116a3565b611022610d93611b85565b6110ae576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603060248201527f4552433732314275726e61626c653a2063616c6c6572206973206e6f74206f7760448201527f6e6572206e6f7220617070726f76656400000000000000000000000000000000606482015260840161091e565b6110b7816123f7565b50565b60008181526002602052604081205473ffffffffffffffffffffffffffffffffffffffff1615156107d9565b60006110f160085490565b821061117f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602c60248201527f455243373231456e756d657261626c653a20676c6f62616c20696e646578206f60448201527f7574206f6620626f756e64730000000000000000000000000000000000000000606482015260840161091e565b600882815481106111b9577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b90600052602060002001549050919050565b60008181526002602052604081205473ffffffffffffffffffffffffffffffffffffffff16806107d9576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602960248201527f4552433732313a206f776e657220717565727920666f72206e6f6e657869737460448201527f656e7420746f6b656e0000000000000000000000000000000000000000000000606482015260840161091e565b600073ffffffffffffffffffffffffffffffffffffffff8216611322576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f4552433732313a2062616c616e636520717565727920666f7220746865207a6560448201527f726f206164647265737300000000000000000000000000000000000000000000606482015260840161091e565b5073ffffffffffffffffffffffffffffffffffffffff1660009081526003602052604090205490565b60115473ffffffffffffffffffffffffffffffffffffffff16156113f1576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602a60248201527f4678426173654368696c6454756e6e656c3a20524f4f545f54554e4e454c5f4160448201527f4c52454144595f53455400000000000000000000000000000000000000000000606482015260840161091e565b601180547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff92909216919091179055565b6060600180546107ee906143e1565b60105473ffffffffffffffffffffffffffffffffffffffff1633146114ee576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602160248201527f4678426173654368696c6454756e6e656c3a20494e56414c49445f53454e444560448201527f5200000000000000000000000000000000000000000000000000000000000000606482015260840161091e565b61152f848484848080601f01602080910402602001604051908101604052809392919081815260200183838082843760009201919091525061242b92505050565b50505050565b61153d611b85565b73ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614156115d2576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601960248201527f4552433732313a20617070726f766520746f2063616c6c657200000000000000604482015260640161091e565b80600560006115df611b85565b73ffffffffffffffffffffffffffffffffffffffff90811682526020808301939093526040918201600090812091871680825291909352912080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00169215159290921790915561164e611b85565b73ffffffffffffffffffffffffffffffffffffffff167f17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c3183604051611697911515815260200190565b60405180910390a35050565b6116b46116ae611b85565b83611d90565b611740576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603160248201527f4552433732313a207472616e736665722063616c6c6572206973206e6f74206f60448201527f776e6572206e6f7220617070726f766564000000000000000000000000000000606482015260840161091e565b61152f8484848461255d565b60606107d982612600565b600061176581610618611b85565b600c9061179f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161091e919061418e565b5050601280547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff92909216919091179055565b7f9f2df0fed2c77648de5860a4cc508cd0818c85b8b8a1ab4ceeef8d981c8956a661181581610618611b85565b600c9061184f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260040161091e919061418e565b5061185a84846127d7565b61152f83836129a5565b6000828152600b602052604090206001015461188281610e4e611b85565b610af78383612304565b611897610d93611b85565b611923576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602b60248201527f4d6f6f6e69654e46543a2063616c6c6572206973206e6f74206f776e6572206e60448201527f6f7220617070726f766564000000000000000000000000000000000000000000606482015260840161091e565b61195e61192e611b85565b8261193884612a75565b60405160200161194a93929190614146565b604051602081830303815290604052612bf8565b611967816123f7565b80611970611b85565b73ffffffffffffffffffffffffffffffffffffffff167f578f4090c2b6e14e72b4937a3e22177e331db6a46ea9e2a577c9a8f3f52706dc60405160405180910390a350565b6012546040517fc455279100000000000000000000000000000000000000000000000000000000815273ffffffffffffffffffffffffffffffffffffffff848116600483015260009281169190841690829063c45527919060240160206040518083038186803b158015611a2857600080fd5b505afa158015611a3c573d6000803e3d6000fd5b505050506040513d601f19601f82011682018060405250810190611a609190613ebb565b73ffffffffffffffffffffffffffffffffffffffff161415611a865760019150506107d9565b73ffffffffffffffffffffffffffffffffffffffff80851660009081526005602090815260408083209387168352929052205460ff165b949350505050565b600033301415611b2957600080368080601f01602080910402602001604051908101604052809392919081815260200183838082843760009201919091525050505036015173ffffffffffffffffffffffffffffffffffffffff169150611b2c9050565b50335b90565b60007fffffffff0000000000000000000000000000000000000000000000000000000082167f7965db0b0000000000000000000000000000000000000000000000000000000014806107d957506107d982612c32565b6000611b8f611ac5565b905090565b600081815260046020526040902080547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff84169081179091558190611bee826111cb565b73ffffffffffffffffffffffffffffffffffffffff167f8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b92560405160405180910390a45050565b600073ffffffffffffffffffffffffffffffffffffffff8616611cd9576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602560248201527f4e61746976654d6574615472616e73616374696f6e3a20494e56414c49445f5360448201527f49474e4552000000000000000000000000000000000000000000000000000000606482015260840161091e565b6001611cec611ce787612c88565b612d12565b6040805160008152602081018083529290925260ff851690820152606081018690526080810185905260a0016020604051602081039080840390855afa158015611d3a573d6000803e3d6000fd5b5050506020604051035173ffffffffffffffffffffffffffffffffffffffff168673ffffffffffffffffffffffffffffffffffffffff1614905095945050505050565b6000611d898284614300565b9392505050565b60008181526002602052604081205473ffffffffffffffffffffffffffffffffffffffff16611e41576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602c60248201527f4552433732313a206f70657261746f7220717565727920666f72206e6f6e657860448201527f697374656e7420746f6b656e0000000000000000000000000000000000000000606482015260840161091e565b6000611e4c836111cb565b90508073ffffffffffffffffffffffffffffffffffffffff168473ffffffffffffffffffffffffffffffffffffffff161480611ebb57508373ffffffffffffffffffffffffffffffffffffffff16611ea384610871565b73ffffffffffffffffffffffffffffffffffffffff16145b80611abd5750611abd81856119b5565b8273ffffffffffffffffffffffffffffffffffffffff16611eeb826111cb565b73ffffffffffffffffffffffffffffffffffffffff1614611f8e576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602960248201527f4552433732313a207472616e73666572206f6620746f6b656e2074686174206960448201527f73206e6f74206f776e0000000000000000000000000000000000000000000000606482015260840161091e565b73ffffffffffffffffffffffffffffffffffffffff8216612030576040517f08c379a0000000000000000000000000000000000000000000000000000000008152602060048201526024808201527f4552433732313a207472616e7366657220746f20746865207a65726f2061646460448201527f7265737300000000000000000000000000000000000000000000000000000000606482015260840161091e565b61203b838383612d5d565b612046600082611b94565b73ffffffffffffffffffffffffffffffffffffffff8316600090815260036020526040812080546001929061207c908490614369565b909155505073ffffffffffffffffffffffffffffffffffffffff821660009081526003602052604081208054600192906120b7908490614300565b909155505060008181526002602052604080822080547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff86811691821790925591518493918716917fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef91a4505050565b6000828152600b6020908152604080832073ffffffffffffffffffffffffffffffffffffffff8516845290915290205460ff16610ff8576121958173ffffffffffffffffffffffffffffffffffffffff166014612d68565b6121a0836020612d68565b6040516020016121b192919061403a565b604080517fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0818403018152908290527f08c379a000000000000000000000000000000000000000000000000000000000825261091e9160040161417b565b6000828152600b6020908152604080832073ffffffffffffffffffffffffffffffffffffffff8516845290915290205460ff16610ff8576000828152600b6020908152604080832073ffffffffffffffffffffffffffffffffffffffff85168452909152902080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff001660011790556122a6611b85565b73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16837f2f8788117e7eff1d82e926ec794901d17c78024a50270940304540a733656f0d60405160405180910390a45050565b6000828152600b6020908152604080832073ffffffffffffffffffffffffffffffffffffffff8516845290915290205460ff1615610ff8576000828152600b6020908152604080832073ffffffffffffffffffffffffffffffffffffffff85168452909152902080547fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00169055612399611b85565b73ffffffffffffffffffffffffffffffffffffffff168173ffffffffffffffffffffffffffffffffffffffff16837ff6391f5c32d9c69d2a47ea670b442974b53935d1edc7fd64eb21e047a839171b60405160405180910390a45050565b60405181907fd83c63197e8e676d80ab0122beba9a9d20f3828839e9a1d6fe81d242e9cd7e6e90600090a26110b78161306e565b601154829073ffffffffffffffffffffffffffffffffffffffff8083169116146124d7576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602b60248201527f4678426173654368696c6454756e6e656c3a20494e56414c49445f53454e444560448201527f525f46524f4d5f524f4f54000000000000000000000000000000000000000000606482015260840161091e565b836013819055506000806000848060200190518101906124f79190613b92565b92509250925061250783836127d7565b61251182826129a5565b604051829073ffffffffffffffffffffffffffffffffffffffff8516907f655215f8718b4280092de4b3251cee2f201c36e8ba2c54e523baa8ad0c9293b290600090a350505050505050565b612568848484611ecb565b612574848484846130ae565b61152f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603260248201527f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560448201527f63656976657220696d706c656d656e7465720000000000000000000000000000606482015260840161091e565b60008181526002602052604090205460609073ffffffffffffffffffffffffffffffffffffffff166126b4576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603160248201527f45524337323155524953746f726167653a2055524920717565727920666f722060448201527f6e6f6e6578697374656e7420746f6b656e000000000000000000000000000000606482015260840161091e565b6000828152600a6020526040812080546126cd906143e1565b80601f01602080910402602001604051908101604052809291908181526020018280546126f9906143e1565b80156127465780601f1061271b57610100808354040283529160200191612746565b820191906000526020600020905b81548152906001019060200180831161272957829003601f168201915b50505050509050600061278960408051808201909152600781527f697066733a2f2f00000000000000000000000000000000000000000000000000602082015290565b905080516000141561279c575092915050565b8151156127ce5780826040516020016127b692919061400b565b60405160208183030381529060405292505050919050565b611abd8461329b565b73ffffffffffffffffffffffffffffffffffffffff8216612854576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f4552433732313a206d696e7420746f20746865207a65726f2061646472657373604482015260640161091e565b60008181526002602052604090205473ffffffffffffffffffffffffffffffffffffffff16156128e0576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152601c60248201527f4552433732313a20746f6b656e20616c7265616479206d696e74656400000000604482015260640161091e565b6128ec60008383612d5d565b73ffffffffffffffffffffffffffffffffffffffff82166000908152600360205260408120805460019290612922908490614300565b909155505060008181526002602052604080822080547fffffffffffffffffffffffff00000000000000000000000000000000000000001673ffffffffffffffffffffffffffffffffffffffff861690811790915590518392907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908290a45050565b60008281526002602052604090205473ffffffffffffffffffffffffffffffffffffffff16612a56576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602e60248201527f45524337323155524953746f726167653a2055524920736574206f66206e6f6e60448201527f6578697374656e7420746f6b656e000000000000000000000000000000000000606482015260840161091e565b6000828152600a602090815260409091208251610af792840190613a4a565b60606000612a828361174c565b80519091506000612a94600783614369565b67ffffffffffffffff811115612ad3577f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6040519080825280601f01601f191660200182016040528015612afd576020820181803683370190505b50905060075b82811015612bef57838181518110612b44577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b01602001517fff000000000000000000000000000000000000000000000000000000000000001682612b77600784614369565b81518110612bae577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a90535080612be781614435565b915050612b03565b50949350505050565b7f8c5261668696ce22758910d05bab8f186d6eb247ceac2af2e82c7dc17669b03681604051612c27919061417b565b60405180910390a150565b60007fffffffff0000000000000000000000000000000000000000000000000000000082167f780e9d630000000000000000000000000000000000000000000000000000000014806107d957506107d9826133dc565b60006040518060800160405280604381526020016145606043913980516020918201208351848301516040808701518051908601209051612cf59501938452602084019290925273ffffffffffffffffffffffffffffffffffffffff166040830152606082015260800190565b604051602081830303815290604052805190602001209050919050565b6000612d1d600e5490565b6040517f19010000000000000000000000000000000000000000000000000000000000006020820152602281019190915260428101839052606201612cf5565b610af78383836134bf565b60606000612d7783600261432c565b612d82906002614300565b67ffffffffffffffff811115612dc1577f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6040519080825280601f01601f191660200182016040528015612deb576020820181803683370190505b5090507f300000000000000000000000000000000000000000000000000000000000000081600081518110612e49577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a9053507f780000000000000000000000000000000000000000000000000000000000000081600181518110612ed3577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a9053506000612f0f84600261432c565b612f1a906001614300565b90505b6001811115613005577f303132333435363738396162636465660000000000000000000000000000000085600f1660108110612f82577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b1a60f81b828281518110612fbf577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a90535060049490941c93612ffe816143ac565b9050612f1d565b508315611d89576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820181905260248201527f537472696e67733a20686578206c656e67746820696e73756666696369656e74604482015260640161091e565b613077816135c5565b6000818152600a602052604090208054613090906143e1565b1590506110b7576000818152600a602052604081206110b791613ace565b600073ffffffffffffffffffffffffffffffffffffffff84163b15613290578373ffffffffffffffffffffffffffffffffffffffff1663150b7a026130f1611b85565b8786866040518563ffffffff1660e01b815260040161311394939291906140fd565b602060405180830381600087803b15801561312d57600080fd5b505af192505050801561317b575060408051601f3d9081017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016820190925261317891810190613e9f565b60015b613245573d8080156131a9576040519150601f19603f3d011682016040523d82523d6000602084013e6131ae565b606091505b50805161323d576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152603260248201527f4552433732313a207472616e7366657220746f206e6f6e20455243373231526560448201527f63656976657220696d706c656d656e7465720000000000000000000000000000606482015260840161091e565b805181602001fd5b7fffffffff00000000000000000000000000000000000000000000000000000000167f150b7a0200000000000000000000000000000000000000000000000000000000149050611abd565b506001949350505050565b60008181526002602052604090205460609073ffffffffffffffffffffffffffffffffffffffff1661334f576040517f08c379a000000000000000000000000000000000000000000000000000000000815260206004820152602f60248201527f4552433732314d657461646174613a2055524920717565727920666f72206e6f60448201527f6e6578697374656e7420746f6b656e0000000000000000000000000000000000606482015260840161091e565b600061338b60408051808201909152600781527f697066733a2f2f00000000000000000000000000000000000000000000000000602082015290565b905060008151116133ab5760405180602001604052806000815250611d89565b806133b58461369e565b6040516020016133c692919061400b565b6040516020818303038152906040529392505050565b60007fffffffff0000000000000000000000000000000000000000000000000000000082167f80ac58cd00000000000000000000000000000000000000000000000000000000148061346f57507fffffffff0000000000000000000000000000000000000000000000000000000082167f5b5e139f00000000000000000000000000000000000000000000000000000000145b806107d957507f01ffc9a7000000000000000000000000000000000000000000000000000000007fffffffff000000000000000000000000000000000000000000000000000000008316146107d9565b73ffffffffffffffffffffffffffffffffffffffff83166135275761352281600880546000838152600960205260408120829055600182018355919091527ff3f7a9fe364faab93b216da50a3214154f22a0a2b415b23a84c8169e8b636ee30155565b613564565b8173ffffffffffffffffffffffffffffffffffffffff168373ffffffffffffffffffffffffffffffffffffffff161461356457613564838261381e565b73ffffffffffffffffffffffffffffffffffffffff821661358857610af7816138d5565b8273ffffffffffffffffffffffffffffffffffffffff168273ffffffffffffffffffffffffffffffffffffffff1614610af757610af782826139f9565b60006135d0826111cb565b90506135de81600084612d5d565b6135e9600083611b94565b73ffffffffffffffffffffffffffffffffffffffff8116600090815260036020526040812080546001929061361f908490614369565b909155505060008281526002602052604080822080547fffffffffffffffffffffffff00000000000000000000000000000000000000001690555183919073ffffffffffffffffffffffffffffffffffffffff8416907fddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef908390a45050565b6060816136de57505060408051808201909152600181527f3000000000000000000000000000000000000000000000000000000000000000602082015290565b8160005b811561370857806136f281614435565b91506137019050600a83614318565b91506136e2565b60008167ffffffffffffffff81111561374a577f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b6040519080825280601f01601f191660200182016040528015613774576020820181803683370190505b5090505b8415611abd57613789600183614369565b9150613796600a8661446e565b6137a1906030614300565b60f81b8183815181106137dd577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b60200101907effffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff1916908160001a905350613817600a86614318565b9450613778565b6000600161382b8461127d565b6138359190614369565b6000838152600760205260409020549091508082146138955773ffffffffffffffffffffffffffffffffffffffff841660009081526006602090815260408083208584528252808320548484528184208190558352600790915290208190555b50600091825260076020908152604080842084905573ffffffffffffffffffffffffffffffffffffffff9094168352600681528383209183525290812055565b6008546000906138e790600190614369565b60008381526009602052604081205460088054939450909284908110613936577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b90600052602060002001549050806008838154811061397e577f4e487b7100000000000000000000000000000000000000000000000000000000600052603260045260246000fd5b60009182526020808320909101929092558281526009909152604080822084905585825281205560088054806139dd577f4e487b7100000000000000000000000000000000000000000000000000000000600052603160045260246000fd5b6001900381819060005260206000200160009055905550505050565b6000613a048361127d565b73ffffffffffffffffffffffffffffffffffffffff9093166000908152600660209081526040808320868452825280832085905593825260079052919091209190915550565b828054613a56906143e1565b90600052602060002090601f016020900481019282613a785760008555613abe565b82601f10613a9157805160ff1916838001178555613abe565b82800160010185558215613abe579182015b82811115613abe578251825591602001919060010190613aa3565b50613aca929150613b04565b5090565b508054613ada906143e1565b6000825580601f10613aea575050565b601f0160209004906000526020600020908101906110b791905b5b80821115613aca5760008155600101613b05565b6000613b2c613b27846142ba565b61426b565b9050828152838383011115613b4057600080fd5b828260208301376000602084830101529392505050565b600082601f830112613b67578081fd5b611d8983833560208501613b19565b600060208284031215613b87578081fd5b8135611d898161450f565b600080600060608486031215613ba6578182fd5b8351613bb18161450f565b60208501516040860151919450925067ffffffffffffffff811115613bd4578182fd5b8401601f81018613613be4578182fd5b8051613bf2613b27826142ba565b818152876020838501011115613c06578384fd5b613c17826020830160208601614380565b8093505050509250925092565b60008060408385031215613c36578182fd5b8235613c418161450f565b91506020830135613c518161450f565b809150509250929050565b600080600060608486031215613c70578283fd5b8335613c7b8161450f565b92506020840135613c8b8161450f565b929592945050506040919091013590565b60008060008060808587031215613cb1578081fd5b8435613cbc8161450f565b93506020850135613ccc8161450f565b925060408501359150606085013567ffffffffffffffff811115613cee578182fd5b613cfa87828801613b57565b91505092959194509250565b60008060408385031215613d18578182fd5b8235613d238161450f565b915060208301358015158114613c51578182fd5b600080600080600060a08688031215613d4e578081fd5b8535613d598161450f565b9450602086013567ffffffffffffffff811115613d74578182fd5b613d8088828901613b57565b9450506040860135925060608601359150608086013560ff81168114613da4578182fd5b809150509295509295909350565b60008060408385031215613dc4578182fd5b8235613dcf8161450f565b946020939093013593505050565b600080600060608486031215613df1578081fd5b8335613dfc8161450f565b925060208401359150604084013567ffffffffffffffff811115613e1e578182fd5b8401601f81018613613e2e578182fd5b613e3d86823560208401613b19565b9150509250925092565b600060208284031215613e58578081fd5b5035919050565b60008060408385031215613e71578182fd5b823591506020830135613c518161450f565b600060208284031215613e94578081fd5b8135611d8981614531565b600060208284031215613eb0578081fd5b8151611d8981614531565b600060208284031215613ecc578081fd5b8151611d898161450f565b60008060008060608587031215613eec578182fd5b843593506020850135613efe8161450f565b9250604085013567ffffffffffffffff80821115613f1a578384fd5b818701915087601f830112613f2d578384fd5b813581811115613f3b578485fd5b886020828501011115613f4c578485fd5b95989497505060200194505050565b60008151808452613f73816020860160208601614380565b601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0169290920160200192915050565b60008251613fb7818460208701614380565b9190910192915050565b60008351613fd3818460208801614380565b60609390931b7fffffffffffffffffffffffffffffffffffffffff000000000000000000000000169190920190815260140192915050565b6000835161401d818460208801614380565b835190830190614031818360208801614380565b01949350505050565b7f416363657373436f6e74726f6c3a206163636f756e7420000000000000000000815260008351614072816017850160208801614380565b7f206973206d697373696e6720726f6c652000000000000000000000000000000060179184019182015283516140af816028840160208801614380565b01602801949350505050565b600073ffffffffffffffffffffffffffffffffffffffff8086168352808516602084015250606060408301526140f46060830184613f5b565b95945050505050565b600073ffffffffffffffffffffffffffffffffffffffff80871683528086166020840152508360408301526080606083015261413c6080830184613f5b565b9695505050505050565b73ffffffffffffffffffffffffffffffffffffffff841681528260208201526060604082015260006140f46060830184613f5b565b602081526000611d896020830184613f5b565b6000602080835281845483600182811c9150808316806141af57607f831692505b8583108114156141e6577f4e487b710000000000000000000000000000000000000000000000000000000087526022600452602487fd5b87860183815260200181801561420357600181146142325761425c565b7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0086168252878201965061425c565b60008b815260209020895b868110156142565781548482015290850190890161423d565b83019750505b50949998505050505050505050565b604051601f82017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe016810167ffffffffffffffff811182821017156142b2576142b26144e0565b604052919050565b600067ffffffffffffffff8211156142d4576142d46144e0565b50601f017fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe01660200190565b6000821982111561431357614313614482565b500190565b600082614327576143276144b1565b500490565b6000817fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff048311821515161561436457614364614482565b500290565b60008282101561437b5761437b614482565b500390565b60005b8381101561439b578181015183820152602001614383565b8381111561152f5750506000910152565b6000816143bb576143bb614482565b507fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0190565b600181811c908216806143f557607f821691505b6020821081141561442f577f4e487b7100000000000000000000000000000000000000000000000000000000600052602260045260246000fd5b50919050565b60007fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff82141561446757614467614482565b5060010190565b60008261447d5761447d6144b1565b500690565b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601160045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052601260045260246000fd5b7f4e487b7100000000000000000000000000000000000000000000000000000000600052604160045260246000fd5b73ffffffffffffffffffffffffffffffffffffffff811681146110b757600080fd5b7fffffffff00000000000000000000000000000000000000000000000000000000811681146110b757600080fdfe4d6574615472616e73616374696f6e2875696e74323536206e6f6e63652c616464726573732066726f6d2c62797465732066756e6374696f6e5369676e617475726529a2646970667358221220eca433c18818c6cec55812eba635e1b23d40ee97e4ff382110fcf83c212363ba64736f6c63430008040033454950373132446f6d61696e28737472696e67206e616d652c737472696e672076657273696f6e2c6164647265737320766572696679696e67436f6e74726163742c627974657333322073616c7429000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008397259c983751daf40400790063935a11afa28a00000000000000000000000000000000000000000000000000000000000000094d6f6f6e69654e4654000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000064d4f4f4e49450000000000000000000000000000000000000000000000000000
Deployed Bytecode
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
Constructor Arguments (ABI-Encoded and is the last bytes of the Contract Creation Code above)
000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000000000000000000000000000000008397259c983751daf40400790063935a11afa28a00000000000000000000000000000000000000000000000000000000000000094d6f6f6e69654e4654000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000064d4f4f4e49450000000000000000000000000000000000000000000000000000
-----Decoded View---------------
Arg [0] : name_ (string): MoonieNFT
Arg [1] : symbol_ (string): MOONIE
Arg [2] : proxyRegistryAddress_ (address): 0x0000000000000000000000000000000000000000
Arg [3] : fxChild (address): 0x8397259c983751DAf40400790063935a11afa28a
-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000000
Arg [3] : 0000000000000000000000008397259c983751daf40400790063935a11afa28a
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000009
Arg [5] : 4d6f6f6e69654e46540000000000000000000000000000000000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000006
Arg [7] : 4d4f4f4e49450000000000000000000000000000000000000000000000000000
Deployed Bytecode Sourcemap
70534:5047:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;71787:252;;;;;;;;;;-1:-1:-1;71787:252:0;;;;;:::i;:::-;;:::i;:::-;;;12471:14:1;;12464:22;12446:41;;12434:2;12419:18;71787:252:0;;;;;;;;21812:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;23371:221::-;;;;;;;;;;-1:-1:-1;23371:221:0;;;;;:::i;:::-;;:::i;:::-;;;10877:42:1;10865:55;;;10847:74;;10835:2;10820:18;23371:221:0;10802:125:1;22894:411:0;;;;;;;;;;-1:-1:-1;22894:411:0;;;;;:::i;:::-;;:::i;:::-;;64774:1142;;;;;;:::i;:::-;;:::i;61960:43::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;35567:113;;;;;;;;;;-1:-1:-1;35655:10:0;:17;35567:113;;;12644:25:1;;;12632:2;12617:18;35567:113:0;12599:76:1;62970:101:0;;;;;;;;;;-1:-1:-1;63048:15:0;;62970:101;;24261:339;;;;;;;;;;-1:-1:-1;24261:339:0;;;;;:::i;:::-;;:::i;49253:123::-;;;;;;;;;;-1:-1:-1;49253:123:0;;;;;:::i;:::-;49319:7;49346:12;;;:6;:12;;;;;:22;;;;49253:123;66342:107;;;;;;;;;;-1:-1:-1;66342:107:0;;;;;:::i;:::-;66429:12;;66395:13;66429:12;;;:6;:12;;;;;;;66342:107;49638:147;;;;;;;;;;-1:-1:-1;49638:147:0;;;;;:::i;:::-;;:::i;35235:256::-;;;;;;;;;;-1:-1:-1;35235:256:0;;;;;:::i;:::-;;:::i;63079:161::-;;;;;;;;;;-1:-1:-1;63193:9:0;63079:161;;50686:218;;;;;;;;;;-1:-1:-1;50686:218:0;;;;;:::i;:::-;;:::i;24671:185::-;;;;;;;;;;-1:-1:-1;24671:185:0;;;;;:::i;:::-;;:::i;41538:245::-;;;;;;;;;;-1:-1:-1;41538:245:0;;;;;:::i;:::-;;:::i;68474:22::-;;;;;;;;;;-1:-1:-1;68474:22:0;;;;;;;;73293:113;;;;;;;;;;-1:-1:-1;73293:113:0;;;;;:::i;:::-;;:::i;35757:233::-;;;;;;;;;;-1:-1:-1;35757:233:0;;;;;:::i;:::-;;:::i;21506:239::-;;;;;;;;;;-1:-1:-1;21506:239:0;;;;;:::i;:::-;;:::i;21236:208::-;;;;;;;;;;-1:-1:-1;21236:208:0;;;;;:::i;:::-;;:::i;68528:27::-;;;;;;;;;;-1:-1:-1;68528:27:0;;;;;;;;68900:198;;;;;;;;;;-1:-1:-1;68900:198:0;;;;;:::i;:::-;;:::i;48138:139::-;;;;;;;;;;-1:-1:-1;48138:139:0;;;;;:::i;:::-;48216:4;48240:12;;;:6;:12;;;;;;;;:29;;;;;;;;;;;;;;;;48138:139;21981:104;;;;;;;;;;;;;:::i;69106:269::-;;;;;;;;;;-1:-1:-1;69106:269:0;;;;;:::i;:::-;;:::i;46116:49::-;;;;;;;;;;-1:-1:-1;46116:49:0;46161:4;46116:49;;23664:295;;;;;;;;;;-1:-1:-1;23664:295:0;;;;;:::i;:::-;;:::i;24927:328::-;;;;;;;;;;-1:-1:-1;24927:328:0;;;;;:::i;:::-;;:::i;71616:163::-;;;;;;;;;;-1:-1:-1;71616:163:0;;;;;:::i;:::-;;:::i;73762:160::-;;;;;;;;;;-1:-1:-1;73762:160:0;;;;;:::i;:::-;;:::i;73096:189::-;;;;;;;;;;-1:-1:-1;73096:189:0;;;;;:::i;:::-;;:::i;70776:62::-;;;;;;;;;;;;70814:24;70776:62;;50030:149;;;;;;;;;;-1:-1:-1;50030:149:0;;;;;:::i;:::-;;:::i;73414:340::-;;;;;;;;;;-1:-1:-1;73414:340:0;;;;;:::i;:::-;;:::i;72171:463::-;;;;;;;;;;-1:-1:-1;72171:463:0;;;;;:::i;:::-;;:::i;71787:252::-;71967:4;71995:36;72019:11;71995:23;:36::i;:::-;71988:43;71787:252;-1:-1:-1;;71787:252:0:o;21812:100::-;21866:13;21899:5;21892:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;21812:100;:::o;23371:221::-;23447:7;26854:16;;;:7;:16;;;;;;:30;:16;23467:73;;;;;;;22228:2:1;23467:73:0;;;22210:21:1;22267:2;22247:18;;;22240:30;22306:34;22286:18;;;22279:62;22377:14;22357:18;;;22350:42;22409:19;;23467:73:0;;;;;;;;;-1:-1:-1;23560:24:0;;;;:15;:24;;;;;;;;;23371:221::o;22894:411::-;22975:13;22991:23;23006:7;22991:14;:23::i;:::-;22975:39;;23039:5;23033:11;;:2;:11;;;;23025:57;;;;;;;23869:2:1;23025:57:0;;;23851:21:1;23908:2;23888:18;;;23881:30;23947:34;23927:18;;;23920:62;24018:3;23998:18;;;23991:31;24039:19;;23025:57:0;23841:223:1;23025:57:0;23133:5;23117:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;23142:37;23159:5;23166:12;:10;:12::i;23142:37::-;23095:168;;;;;;;19788:2:1;23095:168:0;;;19770:21:1;19827:2;19807:18;;;19800:30;19866:34;19846:18;;;19839:62;19937:26;19917:18;;;19910:54;19981:19;;23095:168:0;19760:246:1;23095:168:0;23276:21;23285:2;23289:7;23276:8;:21::i;:::-;22894:411;;;:::o;64774:1142::-;65032:152;;;64975:12;65032:152;;;;;65070:19;;;65000:29;65070:19;;;:6;:19;;;;;;;;;65032:152;;;;;;;;;;;65219:45;65077:11;65032:152;65247:4;65253;65259;65219:6;:45::i;:::-;65197:128;;;;;;;23051:2:1;65197:128:0;;;23033:21:1;23090:2;23070:18;;;23063:30;23129:34;23109:18;;;23102:62;23200:3;23180:18;;;23173:31;23221:19;;65197:128:0;23023:223:1;65197:128:0;65414:19;;;;;;;:6;:19;;;;;;:26;;65438:1;65414:23;:26::i;:::-;65392:19;;;;;;;:6;:19;;;;;;;:48;;;;65458:117;;;;;65399:11;;65522:10;;65547:17;;65458:117;:::i;:::-;;;;;;;;65686:12;65700:23;65735:4;65727:18;;65777:17;65796:11;65760:48;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;65727:92;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65685:134;;;;65838:7;65830:48;;;;;;;17496:2:1;65830:48:0;;;17478:21:1;17535:2;17515:18;;;17508:30;17574;17554:18;;;17547:58;17622:18;;65830:48:0;17468:178:1;65830:48:0;65898:10;64774:1142;-1:-1:-1;;;;;;;;64774:1142:0:o;24261:339::-;24456:41;24475:12;:10;:12::i;:::-;24489:7;24456:18;:41::i;:::-;24448:103;;;;;;;24271:2:1;24448:103:0;;;24253:21:1;24310:2;24290:18;;;24283:30;24349:34;24329:18;;;24322:62;24420:19;24400:18;;;24393:47;24457:19;;24448:103:0;24243:239:1;24448:103:0;24564:28;24574:4;24580:2;24584:7;24564:9;:28::i;49638:147::-;49319:7;49346:12;;;:6;:12;;;;;:22;;;47720:30;47731:4;47737:12;:10;:12::i;:::-;47720:10;:30::i;:::-;49752:25:::1;49763:4;49769:7;49752:10;:25::i;35235:256::-:0;35332:7;35368:23;35385:5;35368:16;:23::i;:::-;35360:5;:31;35352:87;;;;;;;16665:2:1;35352:87:0;;;16647:21:1;16704:2;16684:18;;;16677:30;16743:34;16723:18;;;16716:62;16814:13;16794:18;;;16787:41;16845:19;;35352:87:0;16637:233:1;35352:87:0;-1:-1:-1;35457:19:0;;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;35235:256::o;50686:218::-;50793:12;:10;:12::i;:::-;50782:23;;:7;:23;;;50774:83;;;;;;;26342:2:1;50774:83:0;;;26324:21:1;26381:2;26361:18;;;26354:30;26420:34;26400:18;;;26393:62;26491:17;26471:18;;;26464:45;26526:19;;50774:83:0;26314:237:1;50774:83:0;50870:26;50882:4;50888:7;50870:11;:26::i;:::-;50686:218;;:::o;24671:185::-;24809:39;24826:4;24832:2;24836:7;24809:39;;;;;;;;;;;;:16;:39::i;41538:245::-;41656:41;41675:12;:10;:12::i;41656:41::-;41648:102;;;;;;;25514:2:1;41648:102:0;;;25496:21:1;25553:2;25533:18;;;25526:30;25592:34;25572:18;;;25565:62;25663:18;25643;;;25636:46;25699:19;;41648:102:0;25486:238:1;41648:102:0;41761:14;41767:7;41761:5;:14::i;:::-;41538:245;:::o;73293:113::-;73358:4;26854:16;;;:7;:16;;;;;;:30;:16;:30;;73382:16;26765:127;35757:233;35832:7;35868:30;35655:10;:17;;35567:113;35868:30;35860:5;:38;35852:95;;;;;;;24689:2:1;35852:95:0;;;24671:21:1;24728:2;24708:18;;;24701:30;24767:34;24747:18;;;24740:62;24838:14;24818:18;;;24811:42;24870:19;;35852:95:0;24661:234:1;35852:95:0;35965:10;35976:5;35965:17;;;;;;;;;;;;;;;;;;;;;;;;35958:24;;35757:233;;;:::o;21506:239::-;21578:7;21614:16;;;:7;:16;;;;;;;;21649:19;21641:73;;;;;;;20624:2:1;21641:73:0;;;20606:21:1;20663:2;20643:18;;;20636:30;20702:34;20682:18;;;20675:62;20773:11;20753:18;;;20746:39;20802:19;;21641:73:0;20596:231:1;21236:208:0;21308:7;21336:19;;;21328:74;;;;;;;20213:2:1;21328:74:0;;;20195:21:1;20252:2;20232:18;;;20225:30;20291:34;20271:18;;;20264:62;20362:12;20342:18;;;20335:40;20392:19;;21328:74:0;20185:232:1;21328:74:0;-1:-1:-1;21420:16:0;;;;;;:9;:16;;;;;;;21236:208::o;68900:198::-;68976:12;;:28;:12;:28;68968:83;;;;;;;25931:2:1;68968:83:0;;;25913:21:1;25970:2;25950:18;;;25943:30;26009:34;25989:18;;;25982:62;26080:12;26060:18;;;26053:40;26110:19;;68968:83:0;25903:232:1;68968:83:0;69062:12;:28;;;;;;;;;;;;;;;68900:198::o;21981:104::-;22037:13;22070:7;22063:14;;;;;:::i;69106:269::-;69254:7;;;;69240:10;:21;69232:67;;;;;;;15490:2:1;69232:67:0;;;15472:21:1;15529:2;15509:18;;;15502:30;15568:34;15548:18;;;15541:62;15639:3;15619:18;;;15612:31;15660:19;;69232:67:0;15462:223:1;69232:67:0;69310:57;69334:7;69343:17;69362:4;;69310:57;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;69310:23:0;;-1:-1:-1;;;69310:57:0:i;:::-;69106:269;;;;:::o;23664:295::-;23779:12;:10;:12::i;:::-;23767:24;;:8;:24;;;;23759:62;;;;;;;18615:2:1;23759:62:0;;;18597:21:1;18654:2;18634:18;;;18627:30;18693:27;18673:18;;;18666:55;18738:18;;23759:62:0;18587:175:1;23759:62:0;23879:8;23834:18;:32;23853:12;:10;:12::i;:::-;23834:32;;;;;;;;;;;;;;;;;;-1:-1:-1;23834:32:0;;;:42;;;;;;;;;;;;:53;;;;;;;;;;;;;;23918:12;:10;:12::i;:::-;23903:48;;;23942:8;23903:48;;;;12471:14:1;12464:22;12446:41;;12434:2;12419:18;;12401:92;23903:48:0;;;;;;;;23664:295;;:::o;24927:328::-;25102:41;25121:12;:10;:12::i;:::-;25135:7;25102:18;:41::i;:::-;25094:103;;;;;;;24271:2:1;25094:103:0;;;24253:21:1;24310:2;24290:18;;;24283:30;24349:34;24329:18;;;24322:62;24420:19;24400:18;;;24393:47;24457:19;;25094:103:0;24243:239:1;25094:103:0;25208:39;25222:4;25228:2;25232:7;25241:5;25208:13;:39::i;71616:163::-;71715:13;71748:23;71763:7;71748:14;:23::i;73762:160::-;46161:4;52801:27;46161:4;52815:12;:10;:12::i;52801:27::-;52843:10;52779:85;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;73870:21:0::1;:44:::0;;;::::1;;::::0;;;::::1;::::0;;;::::1;::::0;;73762:160::o;73096:189::-;70814:24;52801:27;52809:4;52815:12;:10;:12::i;52801:27::-;52843:10;52779:85;;;;;;;;;;;;;;:::i;:::-;;73214:20:::1;73220:4;73226:7;73214:5;:20::i;:::-;73245:32;73258:7;73267:9;73245:12;:32::i;50030:149::-:0;49319:7;49346:12;;;:6;:12;;;;;:22;;;47720:30;47731:4;47737:12;:10;:12::i;47720:30::-;50145:26:::1;50157:4;50163:7;50145:11;:26::i;73414:340::-:0;73487:41;73506:12;:10;:12::i;73487:41::-;73479:97;;;;;;;25102:2:1;73479:97:0;;;25084:21:1;25141:2;25121:18;;;25114:30;25180:34;25160:18;;;25153:62;25251:13;25231:18;;;25224:41;25282:19;;73479:97:0;25074:233:1;73479:97:0;73587:77;73617:12;:10;:12::i;:::-;73631:7;73640:22;73654:7;73640:13;:22::i;:::-;73606:57;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;73587:18;:77::i;:::-;73675:14;73681:7;73675:5;:14::i;:::-;73738:7;73724:12;:10;:12::i;:::-;73705:41;;;;;;;;;;;;73414:340;:::o;72171:463::-;72442:21;;72487:28;;;;;72442:21;10865:55:1;;;72487:28:0;;;10847:74:1;72313:4:0;;72442:21;;;72479:49;;;;72442:21;;72487;;10820:18:1;;72487:28:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;72479:49;;;72475:93;;;72552:4;72545:11;;;;;72475:93;24151:25;;;;24127:4;24151:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;72587:39;72580:46;72171:463;-1:-1:-1;;;;72171:463:0:o;67063:633::-;67134:14;67170:10;67192:4;67170:27;67166:499;;;67214:18;67235:8;;67214:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;67274:8:0;67485:17;67479:24;67526:42;67453:134;;-1:-1:-1;67313:289:0;;-1:-1:-1;67313:289:0;;-1:-1:-1;67643:10:0;67166:499;67063:633;:::o;47842:204::-;47927:4;47951:47;;;47966:32;47951:47;;:87;;;48002:36;48026:11;48002:23;:36::i;74237:154::-;74327:7;74359:24;:22;:24::i;:::-;74352:31;;74237:154;:::o;30747:174::-;30822:24;;;;:15;:24;;;;;:29;;;;;;;;;;;;;:24;;30876:23;30822:24;30876:14;:23::i;:::-;30867:46;;;;;;;;;;;;30747:174;;:::o;66457:486::-;66635:4;66660:20;;;66652:70;;;;;;;19382:2:1;66652:70:0;;;19364:21:1;19421:2;19401:18;;;19394:30;19460:34;19440:18;;;19433:62;19531:7;19511:18;;;19504:35;19556:19;;66652:70:0;19354:227:1;66652:70:0;66776:159;66804:47;66823:27;66843:6;66823:19;:27::i;:::-;66804:18;:47::i;:::-;66776:159;;;;;;;;;;;;13352:25:1;;;;13425:4;13413:17;;13393:18;;;13386:45;13447:18;;;13440:34;;;13490:18;;;13483:34;;;13324:19;;66776:159:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;66753:182;;:6;:182;;;66733:202;;66457:486;;;;;;;:::o;55691:98::-;55749:7;55776:5;55780:1;55776;:5;:::i;:::-;55769:12;55691:98;-1:-1:-1;;;55691:98:0:o;27059:348::-;27152:4;26854:16;;;:7;:16;;;;;;:30;:16;27169:73;;;;;;;18969:2:1;27169:73:0;;;18951:21:1;19008:2;18988:18;;;18981:30;19047:34;19027:18;;;19020:62;19118:14;19098:18;;;19091:42;19150:19;;27169:73:0;18941:234:1;27169:73:0;27253:13;27269:23;27284:7;27269:14;:23::i;:::-;27253:39;;27322:5;27311:16;;:7;:16;;;:51;;;;27355:7;27331:31;;:20;27343:7;27331:11;:20::i;:::-;:31;;;27311:51;:87;;;;27366:32;27383:5;27390:7;27366:16;:32::i;30051:578::-;30210:4;30183:31;;:23;30198:7;30183:14;:23::i;:::-;:31;;;30175:85;;;;;;;22641:2:1;30175:85:0;;;22623:21:1;22680:2;22660:18;;;22653:30;22719:34;22699:18;;;22692:62;22790:11;22770:18;;;22763:39;22819:19;;30175:85:0;22613:231:1;30175:85:0;30279:16;;;30271:65;;;;;;;18210:2:1;30271:65:0;;;18192:21:1;18249:2;18229:18;;;18222:30;18288:34;18268:18;;;18261:62;18359:6;18339:18;;;18332:34;18383:19;;30271:65:0;18182:226:1;30271:65:0;30349:39;30370:4;30376:2;30380:7;30349:20;:39::i;:::-;30453:29;30470:1;30474:7;30453:8;:29::i;:::-;30495:15;;;;;;;:9;:15;;;;;:20;;30514:1;;30495:15;:20;;30514:1;;30495:20;:::i;:::-;;;;-1:-1:-1;;30526:13:0;;;;;;;:9;:13;;;;;:18;;30543:1;;30526:13;:18;;30543:1;;30526:18;:::i;:::-;;;;-1:-1:-1;;30555:16:0;;;;:7;:16;;;;;;:21;;;;;;;;;;;;;;30594:27;;30555:16;;30594:27;;;;;;;30051:578;;;:::o;48567:497::-;48216:4;48240:12;;;:6;:12;;;;;;;;:29;;;;;;;;;;;;;48643:414;;48836:41;48864:7;48836:41;;48874:2;48836:19;:41::i;:::-;48950:38;48978:4;48985:2;48950:19;:38::i;:::-;48741:270;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;48687:358;;;;;;;;:::i;51934:229::-;48216:4;48240:12;;;:6;:12;;;;;;;;:29;;;;;;;;;;;;;52004:152;;52048:12;;;;:6;:12;;;;;;;;:29;;;;;;;;;;:36;;;;52080:4;52048:36;;;52131:12;:10;:12::i;:::-;52104:40;;52122:7;52104:40;;52116:4;52104:40;;;;;;;;;;51934:229;;:::o;52171:230::-;48216:4;48240:12;;;:6;:12;;;;;;;;:29;;;;;;;;;;;;;52242:152;;;52317:5;52285:12;;;:6;:12;;;;;;;;:29;;;;;;;;;;:37;;;;;;52369:12;:10;:12::i;:::-;52342:40;;52360:7;52342:40;;52354:4;52342:40;;;;;;;;;;52171:230;;:::o;73959:154::-;74059:15;;74066:7;;74059:15;;;;;74085:20;74097:7;74085:11;:20::i;75140:436::-;68768:12;;75285:6;;68768:12;68758:22;;;68768:12;;68758:22;68750:78;;;;;;;16253:2:1;68750:78:0;;;16235:21:1;16292:2;16272:18;;;16265:30;16331:34;16311:18;;;16304:62;16402:13;16382:18;;;16375:41;16433:19;;68750:78:0;16225:233:1;68750:78:0;75321:7:::1;75304:14;:24;;;;75340:13;75355:15:::0;75372:22:::1;75409:4;75398:44;;;;;;;;;;;;:::i;:::-;75339:103;;;;;;75453:21;75459:5;75466:7;75453:5;:21::i;:::-;75485:31;75498:7;75507:8;75485:12;:31::i;:::-;75532:36;::::0;75560:7;;75532:36:::1;::::0;::::1;::::0;::::1;::::0;;;::::1;68839:1;;;75140:436:::0;;;;:::o;26137:315::-;26294:28;26304:4;26310:2;26314:7;26294:9;:28::i;:::-;26341:48;26364:4;26370:2;26374:7;26383:5;26341:22;:48::i;:::-;26333:111;;;;;;;17077:2:1;26333:111:0;;;17059:21:1;17116:2;17096:18;;;17089:30;17155:34;17135:18;;;17128:62;17226:20;17206:18;;;17199:48;17264:19;;26333:111:0;17049:240:1;42226:679:0;26830:4;26854:16;;;:7;:16;;;;;;42299:13;;26854:30;:16;42325:78;;;;;;;21810:2:1;42325:78:0;;;21792:21:1;21849:2;21829:18;;;21822:30;21888:34;21868:18;;;21861:62;21959:19;21939:18;;;21932:47;21996:19;;42325:78:0;21782:239:1;42325:78:0;42416:23;42442:19;;;:10;:19;;;;;42416:45;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42472:18;42493:10;74716:16;;;;;;;;;;;;;;;;;;74630:110;42493:10;42472:31;;42585:4;42579:18;42601:1;42579:23;42575:72;;;-1:-1:-1;42626:9:0;42226:679;-1:-1:-1;;42226:679:0:o;42575:72::-;42751:23;;:27;42747:108;;42826:4;42832:9;42809:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;42795:48;;;;42226:679;;;:::o;42747:108::-;42874:23;42889:7;42874:14;:23::i;28743:382::-;28823:16;;;28815:61;;;;;;;21449:2:1;28815:61:0;;;21431:21:1;;;21468:18;;;21461:30;21527:34;21507:18;;;21500:62;21579:18;;28815:61:0;21421:182:1;28815:61:0;26830:4;26854:16;;;:7;:16;;;;;;:30;:16;:30;28887:58;;;;;;;17853:2:1;28887:58:0;;;17835:21:1;17892:2;17872:18;;;17865:30;17931;17911:18;;;17904:58;17979:18;;28887:58:0;17825:178:1;28887:58:0;28958:45;28987:1;28991:2;28995:7;28958:20;:45::i;:::-;29016:13;;;;;;;:9;:13;;;;;:18;;29033:1;;29016:13;:18;;29033:1;;29016:18;:::i;:::-;;;;-1:-1:-1;;29045:16:0;;;;:7;:16;;;;;;:21;;;;;;;;;;;;;29084:33;;29045:16;;;29084:33;;29045:16;;29084:33;28743:382;;:::o;43061:217::-;26830:4;26854:16;;;:7;:16;;;;;;:30;:16;43153:75;;;;;;;21034:2:1;43153:75:0;;;21016:21:1;21073:2;21053:18;;;21046:30;21112:34;21092:18;;;21085:62;21183:16;21163:18;;;21156:44;21217:19;;43153:75:0;21006:236:1;43153:75:0;43239:19;;;;:10;:19;;;;;;;;:31;;;;;;;;:::i;74748:384::-;74811:13;74837:16;74862:17;74871:7;74862:8;:17::i;:::-;74911:10;;74837:43;;-1:-1:-1;74891:17:0;74969:13;74981:1;74911:10;74969:13;:::i;:::-;74959:24;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;74959:24:0;-1:-1:-1;74932:51:0;-1:-1:-1;75011:1:0;74994:94;75018:9;75014:1;:13;74994:94;;;75070:3;75074:1;75070:6;;;;;;;;;;;;;;;;;;;;;;75049:11;75061:5;75065:1;75061;:5;:::i;:::-;75049:18;;;;;;;;;;;;;;;;;;;:27;;;;;;;;;;-1:-1:-1;75029:3:0;;;;:::i;:::-;;;;74994:94;;;-1:-1:-1;75112:11:0;74748:384;-1:-1:-1;;;;74748:384:0:o;69759:103::-;69834:20;69846:7;69834:20;;;;;;:::i;:::-;;;;;;;;69759:103;:::o;34927:224::-;35029:4;35053:50;;;35068:35;35053:50;;:90;;;35107:36;35131:11;35107:23;:36::i;65924:410::-;66034:7;64118:100;;;;;;;;;;;;;;;;;64098:127;;;;;;;66188:12;;66223:11;;;;66267:24;;;;;66257:35;;;;;;66107:204;;;;;12911:25:1;;;12967:2;12952:18;;12945:34;;;;13027:42;13015:55;13010:2;12995:18;;12988:83;13102:2;13087:18;;13080:34;12898:3;12883:19;;12865:255;66107:204:0;;;;;;;;;;;;;66079:247;;;;;;66059:267;;65924:410;;;:::o;63609:258::-;63708:7;63810:20;63048:15;;;62970:101;63810:20;63781:63;;9731:66:1;63781:63:0;;;9719:79:1;9814:11;;;9807:27;;;;9850:12;;;9843:28;;;9887:12;;63781:63:0;9709:196:1;74399:223:0;74569:45;74596:4;74602:2;74606:7;74569:26;:45::i;18103:451::-;18178:13;18204:19;18236:10;18240:6;18236:1;:10;:::i;:::-;:14;;18249:1;18236:14;:::i;:::-;18226:25;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;18226:25:0;;18204:47;;18262:15;:6;18269:1;18262:9;;;;;;;;;;;;;;;;;;;:15;;;;;;;;;;;18288;:6;18295:1;18288:9;;;;;;;;;;;;;;;;;;;:15;;;;;;;;;;-1:-1:-1;18319:9:0;18331:10;18335:6;18331:1;:10;:::i;:::-;:14;;18344:1;18331:14;:::i;:::-;18319:26;;18314:135;18351:1;18347;:5;18314:135;;;18386:12;18399:5;18407:3;18399:11;18386:25;;;;;;;;;;;;;;;;;;18374:6;18381:1;18374:9;;;;;;;;;;;;;;;;;;;:37;;;;;;;;;;-1:-1:-1;18436:1:0;18426:11;;;;;18354:3;;;:::i;:::-;;;18314:135;;;-1:-1:-1;18467:10:0;;18459:55;;;;;;;15892:2:1;18459:55:0;;;15874:21:1;;;15911:18;;;15904:30;15970:34;15950:18;;;15943:62;16022:18;;18459:55:0;15864:182:1;43507:206:0;43576:20;43588:7;43576:11;:20::i;:::-;43619:19;;;;:10;:19;;;;;43613:33;;;;;:::i;:::-;:38;;-1:-1:-1;43609:97:0;;43675:19;;;;:10;:19;;;;;43668:26;;;:::i;31486:803::-;31641:4;31662:13;;;8846:20;8894:8;31658:624;;31714:2;31698:36;;;31735:12;:10;:12::i;:::-;31749:4;31755:7;31764:5;31698:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;31698:72:0;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;31694:533;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;31944:13:0;;31940:272;;31987:60;;;;;17077:2:1;31987:60:0;;;17059:21:1;17116:2;17096:18;;;17089:30;17155:34;17135:18;;;17128:62;17226:20;17206:18;;;17199:48;17264:19;;31987:60:0;17049:240:1;31940:272:0;32162:6;32156:13;32147:6;32143:2;32139:15;32132:38;31694:533;31821:55;;31831:45;31821:55;;-1:-1:-1;31814:62:0;;31658:624;-1:-1:-1;32266:4:0;31486:803;;;;;;:::o;22156:334::-;26830:4;26854:16;;;:7;:16;;;;;;22229:13;;26854:30;:16;22255:76;;;;;;;23453:2:1;22255:76:0;;;23435:21:1;23492:2;23472:18;;;23465:30;23531:34;23511:18;;;23504:62;23602:17;23582:18;;;23575:45;23637:19;;22255:76:0;23425:237:1;22255:76:0;22344:21;22368:10;74716:16;;;;;;;;;;;;;;;;;;74630:110;22368:10;22344:34;;22420:1;22402:7;22396:21;:25;:86;;;;;;;;;;;;;;;;;22448:7;22457:18;:7;:16;:18::i;:::-;22431:45;;;;;;;;;:::i;:::-;;;;;;;;;;;;;22389:93;22156:334;-1:-1:-1;;;22156:334:0:o;20867:305::-;20969:4;21006:40;;;21021:25;21006:40;;:105;;-1:-1:-1;21063:48:0;;;21078:33;21063:48;21006:105;:158;;;-1:-1:-1;19489:25:0;19474:40;;;;21128:36;19365:157;36603:589;36809:18;;;36805:187;;36844:40;36876:7;38019:10;:17;;37992:24;;;;:15;:24;;;;;:44;;;38047:24;;;;;;;;;;;;37915:164;36844:40;36805:187;;;36914:2;36906:10;;:4;:10;;;36902:90;;36933:47;36966:4;36972:7;36933:32;:47::i;:::-;37006:16;;;37002:183;;37039:45;37076:7;37039:36;:45::i;37002:183::-;37112:4;37106:10;;:2;:10;;;37102:83;;37133:40;37161:2;37165:7;37133:27;:40::i;29354:360::-;29414:13;29430:23;29445:7;29430:14;:23::i;:::-;29414:39;;29466:48;29487:5;29502:1;29506:7;29466:20;:48::i;:::-;29555:29;29572:1;29576:7;29555:8;:29::i;:::-;29597:16;;;;;;;:9;:16;;;;;:21;;29617:1;;29597:16;:21;;29617:1;;29597:21;:::i;:::-;;;;-1:-1:-1;;29636:16:0;;;;:7;:16;;;;;;29629:23;;;;;;29670:36;29644:7;;29636:16;29629:23;29670:36;;;;;29636:16;;29670:36;29354:360;;:::o;16802:723::-;16858:13;17079:10;17075:53;;-1:-1:-1;;17106:10:0;;;;;;;;;;;;;;;;;;16802:723::o;17075:53::-;17153:5;17138:12;17194:78;17201:9;;17194:78;;17227:8;;;;:::i;:::-;;-1:-1:-1;17250:10:0;;-1:-1:-1;17258:2:0;17250:10;;:::i;:::-;;;17194:78;;;17282:19;17314:6;17304:17;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;17304:17:0;;17282:39;;17332:154;17339:10;;17332:154;;17366:11;17376:1;17366:11;;:::i;:::-;;-1:-1:-1;17435:10:0;17443:2;17435:5;:10;:::i;:::-;17422:24;;:2;:24;:::i;:::-;17409:39;;17392:6;17399;17392:14;;;;;;;;;;;;;;;;;;;:56;;;;;;;;;;-1:-1:-1;17463:11:0;17472:2;17463:11;;:::i;:::-;;;17332:154;;38706:988;38972:22;39022:1;38997:22;39014:4;38997:16;:22::i;:::-;:26;;;;:::i;:::-;39034:18;39055:26;;;:17;:26;;;;;;38972:51;;-1:-1:-1;39188:28:0;;;39184:328;;39255:18;;;39233:19;39255:18;;;:12;:18;;;;;;;;:34;;;;;;;;;39306:30;;;;;;:44;;;39423:30;;:17;:30;;;;;:43;;;39184:328;-1:-1:-1;39608:26:0;;;;:17;:26;;;;;;;;39601:33;;;39652:18;;;;;;:12;:18;;;;;:34;;;;;;;39645:41;38706:988::o;39989:1079::-;40267:10;:17;40242:22;;40267:21;;40287:1;;40267:21;:::i;:::-;40299:18;40320:24;;;:15;:24;;;;;;40693:10;:26;;40242:46;;-1:-1:-1;40320:24:0;;40242:46;;40693:26;;;;;;;;;;;;;;;;;;;;;;40671:48;;40757:11;40732:10;40743;40732:22;;;;;;;;;;;;;;;;;;;;;;;;;;;:36;;;;40837:28;;;:15;:28;;;;;;;:41;;;41009:24;;;;;41002:31;41044:10;:16;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39989:1079;;;;:::o;37493:221::-;37578:14;37595:20;37612:2;37595:16;:20::i;:::-;37626:16;;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;37671:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;37493:221:0:o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;:::i;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14:336:1;78:5;107:52;123:35;151:6;123:35;:::i;:::-;107:52;:::i;:::-;98:61;;182:6;175:5;168:21;222:3;213:6;208:3;204:16;201:25;198:2;;;239:1;236;229:12;198:2;288:6;283:3;276:4;269:5;265:16;252:43;342:1;335:4;326:6;319:5;315:18;311:29;304:40;88:262;;;;;:::o;355:228::-;397:5;450:3;443:4;435:6;431:17;427:27;417:2;;472:5;465;458:20;417:2;498:79;573:3;564:6;551:20;544:4;536:6;532:17;498:79;:::i;588:257::-;647:6;700:2;688:9;679:7;675:23;671:32;668:2;;;721:6;713;706:22;668:2;765:9;752:23;784:31;809:5;784:31;:::i;850:872::-;956:6;964;972;1025:2;1013:9;1004:7;1000:23;996:32;993:2;;;1046:6;1038;1031:22;993:2;1083:9;1077:16;1102:31;1127:5;1102:31;:::i;:::-;1197:2;1182:18;;1176:25;1245:2;1230:18;;1224:25;1152:5;;-1:-1:-1;1176:25:1;-1:-1:-1;1272:18:1;1261:30;;1258:2;;;1309:6;1301;1294:22;1258:2;1337:22;;1390:4;1382:13;;1378:27;-1:-1:-1;1368:2:1;;1424:6;1416;1409:22;1368:2;1458;1452:9;1483:48;1499:31;1527:2;1499:31;:::i;1483:48::-;1554:2;1547:5;1540:17;1594:7;1589:2;1584;1580;1576:11;1572:20;1569:33;1566:2;;;1620:6;1612;1605:22;1566:2;1638:54;1689:2;1684;1677:5;1673:14;1668:2;1664;1660:11;1638:54;:::i;:::-;1711:5;1701:15;;;;;983:739;;;;;:::o;1727:398::-;1795:6;1803;1856:2;1844:9;1835:7;1831:23;1827:32;1824:2;;;1877:6;1869;1862:22;1824:2;1921:9;1908:23;1940:31;1965:5;1940:31;:::i;:::-;1990:5;-1:-1:-1;2047:2:1;2032:18;;2019:32;2060:33;2019:32;2060:33;:::i;:::-;2112:7;2102:17;;;1814:311;;;;;:::o;2130:466::-;2207:6;2215;2223;2276:2;2264:9;2255:7;2251:23;2247:32;2244:2;;;2297:6;2289;2282:22;2244:2;2341:9;2328:23;2360:31;2385:5;2360:31;:::i;:::-;2410:5;-1:-1:-1;2467:2:1;2452:18;;2439:32;2480:33;2439:32;2480:33;:::i;:::-;2234:362;;2532:7;;-1:-1:-1;;;2586:2:1;2571:18;;;;2558:32;;2234:362::o;2601:685::-;2696:6;2704;2712;2720;2773:3;2761:9;2752:7;2748:23;2744:33;2741:2;;;2795:6;2787;2780:22;2741:2;2839:9;2826:23;2858:31;2883:5;2858:31;:::i;:::-;2908:5;-1:-1:-1;2965:2:1;2950:18;;2937:32;2978:33;2937:32;2978:33;:::i;:::-;3030:7;-1:-1:-1;3084:2:1;3069:18;;3056:32;;-1:-1:-1;3139:2:1;3124:18;;3111:32;3166:18;3155:30;;3152:2;;;3203:6;3195;3188:22;3152:2;3231:49;3272:7;3263:6;3252:9;3248:22;3231:49;:::i;:::-;3221:59;;;2731:555;;;;;;;:::o;3291:436::-;3356:6;3364;3417:2;3405:9;3396:7;3392:23;3388:32;3385:2;;;3438:6;3430;3423:22;3385:2;3482:9;3469:23;3501:31;3526:5;3501:31;:::i;:::-;3551:5;-1:-1:-1;3608:2:1;3593:18;;3580:32;3650:15;;3643:23;3631:36;;3621:2;;3686:6;3678;3671:22;3732:788;3834:6;3842;3850;3858;3866;3919:3;3907:9;3898:7;3894:23;3890:33;3887:2;;;3941:6;3933;3926:22;3887:2;3985:9;3972:23;4004:31;4029:5;4004:31;:::i;:::-;4054:5;-1:-1:-1;4110:2:1;4095:18;;4082:32;4137:18;4126:30;;4123:2;;;4174:6;4166;4159:22;4123:2;4202:49;4243:7;4234:6;4223:9;4219:22;4202:49;:::i;:::-;4192:59;;;4298:2;4287:9;4283:18;4270:32;4260:42;;4349:2;4338:9;4334:18;4321:32;4311:42;;4405:3;4394:9;4390:19;4377:33;4454:4;4445:7;4441:18;4432:7;4429:31;4419:2;;4479:6;4471;4464:22;4419:2;4507:7;4497:17;;;3877:643;;;;;;;;:::o;4525:325::-;4593:6;4601;4654:2;4642:9;4633:7;4629:23;4625:32;4622:2;;;4675:6;4667;4660:22;4622:2;4719:9;4706:23;4738:31;4763:5;4738:31;:::i;:::-;4788:5;4840:2;4825:18;;;;4812:32;;-1:-1:-1;;;4612:238:1:o;4855:683::-;4942:6;4950;4958;5011:2;4999:9;4990:7;4986:23;4982:32;4979:2;;;5032:6;5024;5017:22;4979:2;5076:9;5063:23;5095:31;5120:5;5095:31;:::i;:::-;5145:5;-1:-1:-1;5197:2:1;5182:18;;5169:32;;-1:-1:-1;5252:2:1;5237:18;;5224:32;5279:18;5268:30;;5265:2;;;5316:6;5308;5301:22;5265:2;5344:22;;5397:4;5389:13;;5385:27;-1:-1:-1;5375:2:1;;5431:6;5423;5416:22;5375:2;5459:73;5524:7;5519:2;5506:16;5501:2;5497;5493:11;5459:73;:::i;:::-;5449:83;;;4969:569;;;;;:::o;5543:190::-;5602:6;5655:2;5643:9;5634:7;5630:23;5626:32;5623:2;;;5676:6;5668;5661:22;5623:2;-1:-1:-1;5704:23:1;;5613:120;-1:-1:-1;5613:120:1:o;5738:325::-;5806:6;5814;5867:2;5855:9;5846:7;5842:23;5838:32;5835:2;;;5888:6;5880;5873:22;5835:2;5929:9;5916:23;5906:33;;5989:2;5978:9;5974:18;5961:32;6002:31;6027:5;6002:31;:::i;6068:255::-;6126:6;6179:2;6167:9;6158:7;6154:23;6150:32;6147:2;;;6200:6;6192;6185:22;6147:2;6244:9;6231:23;6263:30;6287:5;6263:30;:::i;6328:259::-;6397:6;6450:2;6438:9;6429:7;6425:23;6421:32;6418:2;;;6471:6;6463;6456:22;6418:2;6508:9;6502:16;6527:30;6551:5;6527:30;:::i;6592:290::-;6691:6;6744:2;6732:9;6723:7;6719:23;6715:32;6712:2;;;6765:6;6757;6750:22;6712:2;6802:9;6796:16;6821:31;6846:5;6821:31;:::i;7082:844::-;7170:6;7178;7186;7194;7247:2;7235:9;7226:7;7222:23;7218:32;7215:2;;;7268:6;7260;7253:22;7215:2;7309:9;7296:23;7286:33;;7369:2;7358:9;7354:18;7341:32;7382:31;7407:5;7382:31;:::i;:::-;7432:5;-1:-1:-1;7488:2:1;7473:18;;7460:32;7511:18;7541:14;;;7538:2;;;7573:6;7565;7558:22;7538:2;7616:6;7605:9;7601:22;7591:32;;7661:7;7654:4;7650:2;7646:13;7642:27;7632:2;;7688:6;7680;7673:22;7632:2;7733;7720:16;7759:2;7751:6;7748:14;7745:2;;;7780:6;7772;7765:22;7745:2;7830:7;7825:2;7816:6;7812:2;7808:15;7804:24;7801:37;7798:2;;;7856:6;7848;7841:22;7798:2;7205:721;;;;-1:-1:-1;;7892:2:1;7884:11;;-1:-1:-1;;;7205:721:1:o;7931:316::-;7972:3;8010:5;8004:12;8037:6;8032:3;8025:19;8053:63;8109:6;8102:4;8097:3;8093:14;8086:4;8079:5;8075:16;8053:63;:::i;:::-;8161:2;8149:15;8166:66;8145:88;8136:98;;;;8236:4;8132:109;;7980:267;-1:-1:-1;;7980:267:1:o;8252:274::-;8381:3;8419:6;8413:13;8435:53;8481:6;8476:3;8469:4;8461:6;8457:17;8435:53;:::i;:::-;8504:16;;;;;8389:137;-1:-1:-1;;8389:137:1:o;8531:450::-;8688:3;8726:6;8720:13;8742:53;8788:6;8783:3;8776:4;8768:6;8764:17;8742:53;:::i;:::-;8864:2;8860:15;;;;8877:66;8856:88;8817:16;;;;8842:103;;;8972:2;8961:14;;8696:285;-1:-1:-1;;8696:285:1:o;8986:470::-;9165:3;9203:6;9197:13;9219:53;9265:6;9260:3;9253:4;9245:6;9241:17;9219:53;:::i;:::-;9335:13;;9294:16;;;;9357:57;9335:13;9294:16;9391:4;9379:17;;9357:57;:::i;:::-;9430:20;;9173:283;-1:-1:-1;;;;9173:283:1:o;9910:786::-;10321:25;10316:3;10309:38;10291:3;10376:6;10370:13;10392:62;10447:6;10442:2;10437:3;10433:12;10426:4;10418:6;10414:17;10392:62;:::i;:::-;10518:19;10513:2;10473:16;;;10505:11;;;10498:40;10563:13;;10585:63;10563:13;10634:2;10626:11;;10619:4;10607:17;;10585:63;:::i;:::-;10668:17;10687:2;10664:26;;10299:397;-1:-1:-1;;;;10299:397:1:o;10932:438::-;11098:4;11127:42;11208:2;11200:6;11196:15;11185:9;11178:34;11260:2;11252:6;11248:15;11243:2;11232:9;11228:18;11221:43;;11300:2;11295;11284:9;11280:18;11273:30;11320:44;11360:2;11349:9;11345:18;11337:6;11320:44;:::i;:::-;11312:52;11107:263;-1:-1:-1;;;;;11107:263:1:o;11375:511::-;11569:4;11598:42;11679:2;11671:6;11667:15;11656:9;11649:34;11731:2;11723:6;11719:15;11714:2;11703:9;11699:18;11692:43;;11771:6;11766:2;11755:9;11751:18;11744:34;11814:3;11809:2;11798:9;11794:18;11787:31;11835:45;11875:3;11864:9;11860:19;11852:6;11835:45;:::i;:::-;11827:53;11578:308;-1:-1:-1;;;;;;11578:308:1:o;11891:410::-;12108:42;12100:6;12096:55;12085:9;12078:74;12188:6;12183:2;12172:9;12168:18;12161:34;12231:2;12226;12215:9;12211:18;12204:30;12059:4;12251:44;12291:2;12280:9;12276:18;12268:6;12251:44;:::i;13528:217::-;13675:2;13664:9;13657:21;13638:4;13695:44;13735:2;13724:9;13720:18;13712:6;13695:44;:::i;13974:1309::-;14083:4;14112:2;14141;14130:9;14123:21;14164:4;14200:6;14194:13;14230:4;14253:1;14281:9;14277:2;14273:18;14263:28;;14341:2;14330:9;14326:18;14363;14353:2;;14407:4;14399:6;14395:17;14385:27;;14353:2;14460;14452:6;14449:14;14429:18;14426:38;14423:2;;;14500:77;14494:4;14487:91;14601:4;14598:1;14591:15;14632:4;14626;14619:18;14423:2;14702:18;;;27545:19;;;27597:4;27588:14;14745:18;14772:158;;;;14944:1;14939:318;;;;14738:519;;14772:158;14820:66;14809:9;14805:82;14800:3;14793:95;14917:2;14912:3;14908:12;14901:19;;14772:158;;14939:318;27374:4;27393:17;;;27443:4;27427:21;;15034:4;15051:165;15065:6;15062:1;15059:13;15051:165;;;15143:14;;15130:11;;;15123:35;15186:16;;;;15080:10;;15051:165;;;15236:11;;;-1:-1:-1;;14738:519:1;-1:-1:-1;15274:3:1;;14092:1191;-1:-1:-1;;;;;;;;;14092:1191:1:o;26738:334::-;26809:2;26803:9;26865:2;26855:13;;26870:66;26851:86;26839:99;;26968:18;26953:34;;26989:22;;;26950:62;26947:2;;;27015:18;;:::i;:::-;27051:2;27044:22;26783:289;;-1:-1:-1;26783:289:1:o;27077:245::-;27125:4;27158:18;27150:6;27147:30;27144:2;;;27180:18;;:::i;:::-;-1:-1:-1;27237:2:1;27225:15;27242:66;27221:88;27311:4;27217:99;;27134:188::o;27613:128::-;27653:3;27684:1;27680:6;27677:1;27674:13;27671:2;;;27690:18;;:::i;:::-;-1:-1:-1;27726:9:1;;27661:80::o;27746:120::-;27786:1;27812;27802:2;;27817:18;;:::i;:::-;-1:-1:-1;27851:9:1;;27792:74::o;27871:228::-;27911:7;28037:1;27969:66;27965:74;27962:1;27959:81;27954:1;27947:9;27940:17;27936:105;27933:2;;;28044:18;;:::i;:::-;-1:-1:-1;28084:9:1;;27923:176::o;28104:125::-;28144:4;28172:1;28169;28166:8;28163:2;;;28177:18;;:::i;:::-;-1:-1:-1;28214:9:1;;28153:76::o;28234:258::-;28306:1;28316:113;28330:6;28327:1;28324:13;28316:113;;;28406:11;;;28400:18;28387:11;;;28380:39;28352:2;28345:10;28316:113;;;28447:6;28444:1;28441:13;28438:2;;;-1:-1:-1;;28482:1:1;28464:16;;28457:27;28287:205::o;28497:196::-;28536:3;28564:5;28554:2;;28573:18;;:::i;:::-;-1:-1:-1;28620:66:1;28609:78;;28544:149::o;28698:437::-;28777:1;28773:12;;;;28820;;;28841:2;;28895:4;28887:6;28883:17;28873:27;;28841:2;28948;28940:6;28937:14;28917:18;28914:38;28911:2;;;28985:77;28982:1;28975:88;29086:4;29083:1;29076:15;29114:4;29111:1;29104:15;28911:2;;28753:382;;;:::o;29140:195::-;29179:3;29210:66;29203:5;29200:77;29197:2;;;29280:18;;:::i;:::-;-1:-1:-1;29327:1:1;29316:13;;29187:148::o;29340:112::-;29372:1;29398;29388:2;;29403:18;;:::i;:::-;-1:-1:-1;29437:9:1;;29378:74::o;29457:184::-;29509:77;29506:1;29499:88;29606:4;29603:1;29596:15;29630:4;29627:1;29620:15;29646:184;29698:77;29695:1;29688:88;29795:4;29792:1;29785:15;29819:4;29816:1;29809:15;29835:184;29887:77;29884:1;29877:88;29984:4;29981:1;29974:15;30008:4;30005:1;29998:15;30024:154;30110:42;30103:5;30099:54;30092:5;30089:65;30079:2;;30168:1;30165;30158:12;30183:177;30268:66;30261:5;30257:78;30250:5;30247:89;30237:2;;30350:1;30347;30340:12
Swarm Source
ipfs://eca433c18818c6cec55812eba635e1b23d40ee97e4ff382110fcf83c212363ba
Loading...
Loading
[ Download: CSV Export ]
[ Download: CSV Export ]
A token is a representation of an on-chain or off-chain asset. The token page shows information such as price, total supply, holders, transfers and social links. Learn more about this page in our Knowledge Base.