Overview
TokenID
120
Total Transfers
-
Market
Onchain Market Cap
$0.00
Circulating Supply Market Cap
-
Other Info
Token Contract
Loading...
Loading
Loading...
Loading
Loading...
Loading
# | Exchange | Pair | Price | 24H Volume | % Volume |
---|
Contract Name:
GangzOfNewYork
Compiler Version
v0.8.20+commit.a1b79de6
Contract Source Code (Solidity)
/** *Submitted for verification at Etherscan.io on 2024-02-04 */ // SPDX-License-Identifier: MIT // File: @openzeppelin/contracts/utils/Strings.sol // OpenZeppelin Contracts v4.4.1 (utils/Strings.sol) pragma solidity ^0.8.0; /** * @dev String operations. */ library Strings { bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef"; /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function toString(uint256 value) internal pure returns (string memory) { // Inspired by OraclizeAPI's implementation - MIT licence // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol if (value == 0) { return "0"; } uint256 temp = value; uint256 digits; while (temp != 0) { digits++; temp /= 10; } bytes memory buffer = new bytes(digits); while (value != 0) { digits -= 1; buffer[digits] = bytes1(uint8(48 + uint256(value % 10))); value /= 10; } return string(buffer); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation. */ function toHexString(uint256 value) internal pure returns (string memory) { if (value == 0) { return "0x00"; } uint256 temp = value; uint256 length = 0; while (temp != 0) { length++; temp >>= 8; } return toHexString(value, length); } /** * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length. */ function toHexString(uint256 value, uint256 length) internal pure returns (string memory) { bytes memory buffer = new bytes(2 * length + 2); buffer[0] = "0"; buffer[1] = "x"; for (uint256 i = 2 * length + 1; i > 1; --i) { buffer[i] = _HEX_SYMBOLS[value & 0xf]; value >>= 4; } require(value == 0, "Strings: hex length insufficient"); return string(buffer); } } // File: @openzeppelin/contracts/security/ReentrancyGuard.sol // OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol) pragma solidity ^0.8.0; /** * @dev Contract module that helps prevent reentrant calls to a function. * * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier * available, which can be applied to functions to make sure there are no nested * (reentrant) calls to them. * * Note that because there is a single `nonReentrant` guard, functions marked as * `nonReentrant` may not call one another. This can be worked around by making * those functions `private`, and then adding `external` `nonReentrant` entry * points to them. * * TIP: If you would like to learn more about reentrancy and alternative ways * to protect against it, check out our blog post * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul]. */ abstract contract ReentrancyGuard { // Booleans are more expensive than uint256 or any type that takes up a full // word because each write operation emits an extra SLOAD to first read the // slot's contents, replace the bits taken up by the boolean, and then write // back. This is the compiler's defense against contract upgrades and // pointer aliasing, and it cannot be disabled. // The values being non-zero value makes deployment a bit more expensive, // but in exchange the refund on every call to nonReentrant will be lower in // amount. Since refunds are capped to a percentage of the total // transaction's gas, it is best to keep them low in cases like this one, to // increase the likelihood of the full refund coming into effect. uint256 private constant _NOT_ENTERED = 1; uint256 private constant _ENTERED = 2; uint256 private _status; constructor() { _status = _NOT_ENTERED; } /** * @dev Prevents a contract from calling itself, directly or indirectly. * Calling a `nonReentrant` function from another `nonReentrant` * function is not supported. It is possible to prevent this from happening * by making the `nonReentrant` function external, and making it call a * `private` function that does the actual work. */ modifier nonReentrant() { // On the first call to nonReentrant, _notEntered will be true require(_status != _ENTERED, "ReentrancyGuard: reentrant call"); // Any calls to nonReentrant after this point will fail _status = _ENTERED; _; // By storing the original value once again, a refund is triggered (see // https://eips.ethereum.org/EIPS/eip-2200) _status = _NOT_ENTERED; } } // File: @openzeppelin/contracts/utils/Context.sol // OpenZeppelin Contracts v4.4.1 (utils/Context.sol) pragma solidity ^0.8.0; /** * @dev Provides information about the current execution context, including the * sender of the transaction and its data. While these are generally available * via msg.sender and msg.data, they should not be accessed in such a direct * manner, since when dealing with meta-transactions the account sending and * paying for execution may not be the actual sender (as far as an application * is concerned). * * This contract is only required for intermediate, library-like contracts. */ abstract contract Context { function _msgSender() internal view virtual returns (address) { return msg.sender; } function _msgData() internal view virtual returns (bytes calldata) { return msg.data; } } // File: @openzeppelin/contracts/access/Ownable.sol // OpenZeppelin Contracts (last updated v4.7.0) (access/Ownable.sol) pragma solidity ^0.8.0; /** * @dev Contract module which provides a basic access control mechanism, where * there is an account (an owner) that can be granted exclusive access to * specific functions. * * By default, the owner account will be the one that deploys the contract. This * can later be changed with {transferOwnership}. * * This module is used through inheritance. It will make available the modifier * `onlyOwner`, which can be applied to your functions to restrict their use to * the owner. */ abstract contract Ownable is Context { address private _owner; event OwnershipTransferred(address indexed previousOwner, address indexed newOwner); /** * @dev Initializes the contract setting the deployer as the initial owner. */ constructor() { _transferOwnership(_msgSender()); } /** * @dev Throws if called by any account other than the owner. */ modifier onlyOwner() { _checkOwner(); _; } /** * @dev Returns the address of the current owner. */ function owner() public view virtual returns (address) { return _owner; } /** * @dev Throws if the sender is not the owner. */ function _checkOwner() internal view virtual { require(owner() == _msgSender(), "Ownable: caller is not the owner"); } /** * @dev Leaves the contract without owner. It will not be possible to call * `onlyOwner` functions anymore. Can only be called by the current owner. * * NOTE: Renouncing ownership will leave the contract without an owner, * thereby removing any functionality that is only available to the owner. */ function renounceOwnership() public virtual onlyOwner { _transferOwnership(address(0)); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Can only be called by the current owner. */ function transferOwnership(address newOwner) public virtual onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); _transferOwnership(newOwner); } /** * @dev Transfers ownership of the contract to a new account (`newOwner`). * Internal function without access restriction. */ function _transferOwnership(address newOwner) internal virtual { address oldOwner = _owner; _owner = newOwner; emit OwnershipTransferred(oldOwner, newOwner); } } // File: @openzeppelin/contracts/utils/introspection/IERC165.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol) pragma solidity ^0.8.0; /** * @dev Interface of the ERC165 standard, as defined in the * https://eips.ethereum.org/EIPS/eip-165[EIP]. * * Implementers can declare support of contract interfaces, which can then be * queried by others ({ERC165Checker}). * * For an implementation, see {ERC165}. */ interface IERC165 { /** * @dev Returns true if this contract implements the interface defined by * `interfaceId`. See the corresponding * https://eips.ethereum.org/EIPS/eip-165#how-interfaces-are-identified[EIP section] * to learn more about how these ids are created. * * This function call must use less than 30 000 gas. */ function supportsInterface(bytes4 interfaceId) external view returns (bool); } // File: @openzeppelin/contracts/utils/introspection/ERC165.sol // OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol) pragma solidity ^0.8.0; /** * @dev Implementation of the {IERC165} interface. * * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check * for the additional interface id that will be supported. For example: * * ```solidity * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { * return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId); * } * ``` * * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation. */ abstract contract ERC165 is IERC165 { /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) { return interfaceId == type(IERC165).interfaceId; } } // File: @openzeppelin/contracts/interfaces/IERC2981.sol // OpenZeppelin Contracts (last updated v4.6.0) (interfaces/IERC2981.sol) pragma solidity ^0.8.0; /** * @dev Interface for the NFT Royalty Standard. * * A standardized way to retrieve royalty payment information for non-fungible tokens (NFTs) to enable universal * support for royalty payments across all NFT marketplaces and ecosystem participants. * * _Available since v4.5._ */ interface IERC2981 is IERC165 { /** * @dev Returns how much royalty is owed and to whom, based on a sale price that may be denominated in any unit of * exchange. The royalty amount is denominated and should be paid in that same unit of exchange. */ function royaltyInfo(uint256 tokenId, uint256 salePrice) external view returns (address receiver, uint256 royaltyAmount); } // File: @openzeppelin/contracts/token/common/ERC2981.sol // OpenZeppelin Contracts (last updated v4.7.0) (token/common/ERC2981.sol) pragma solidity ^0.8.0; /** * @dev Implementation of the NFT Royalty Standard, a standardized way to retrieve royalty payment information. * * Royalty information can be specified globally for all token ids via {_setDefaultRoyalty}, and/or individually for * specific token ids via {_setTokenRoyalty}. The latter takes precedence over the first. * * Royalty is specified as a fraction of sale price. {_feeDenominator} is overridable but defaults to 10000, meaning the * fee is specified in basis points by default. * * IMPORTANT: ERC-2981 only specifies a way to signal royalty information and does not enforce its payment. See * https://eips.ethereum.org/EIPS/eip-2981#optional-royalty-payments[Rationale] in the EIP. Marketplaces are expected to * voluntarily pay royalties together with sales, but note that this standard is not yet widely supported. * * _Available since v4.5._ */ abstract contract ERC2981 is IERC2981, ERC165 { struct RoyaltyInfo { address receiver; uint96 royaltyFraction; } RoyaltyInfo private _defaultRoyaltyInfo; mapping(uint256 => RoyaltyInfo) private _tokenRoyaltyInfo; /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(IERC165, ERC165) returns (bool) { return interfaceId == type(IERC2981).interfaceId || super.supportsInterface(interfaceId); } /** * @inheritdoc IERC2981 */ function royaltyInfo(uint256 _tokenId, uint256 _salePrice) public view virtual override returns (address, uint256) { RoyaltyInfo memory royalty = _tokenRoyaltyInfo[_tokenId]; if (royalty.receiver == address(0)) { royalty = _defaultRoyaltyInfo; } uint256 royaltyAmount = (_salePrice * royalty.royaltyFraction) / _feeDenominator(); return (royalty.receiver, royaltyAmount); } /** * @dev The denominator with which to interpret the fee set in {_setTokenRoyalty} and {_setDefaultRoyalty} as a * fraction of the sale price. Defaults to 10000 so fees are expressed in basis points, but may be customized by an * override. */ function _feeDenominator() internal pure virtual returns (uint96) { return 10000; } /** * @dev Sets the royalty information that all ids in this contract will default to. * * Requirements: * * - `receiver` cannot be the zero address. * - `feeNumerator` cannot be greater than the fee denominator. */ function _setDefaultRoyalty(address receiver, uint96 feeNumerator) internal virtual { require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice"); require(receiver != address(0), "ERC2981: invalid receiver"); _defaultRoyaltyInfo = RoyaltyInfo(receiver, feeNumerator); } /** * @dev Removes default royalty information. */ function _deleteDefaultRoyalty() internal virtual { delete _defaultRoyaltyInfo; } /** * @dev Sets the royalty information for a specific token id, overriding the global default. * * Requirements: * * - `receiver` cannot be the zero address. * - `feeNumerator` cannot be greater than the fee denominator. */ function _setTokenRoyalty( uint256 tokenId, address receiver, uint96 feeNumerator ) internal virtual { require(feeNumerator <= _feeDenominator(), "ERC2981: royalty fee will exceed salePrice"); require(receiver != address(0), "ERC2981: Invalid parameters"); _tokenRoyaltyInfo[tokenId] = RoyaltyInfo(receiver, feeNumerator); } /** * @dev Resets royalty information for the token id back to the global default. */ function _resetTokenRoyalty(uint256 tokenId) internal virtual { delete _tokenRoyaltyInfo[tokenId]; } } // File: contracts/IOperatorFilterRegistry.sol pragma solidity ^0.8.13; interface IOperatorFilterRegistry { /** * @notice Returns true if operator is not filtered for a given token, either by address or codeHash. Also returns * true if supplied registrant address is not registered. */ function isOperatorAllowed(address registrant, address operator) external view returns (bool); /** * @notice Registers an address with the registry. May be called by address itself or by EIP-173 owner. */ function register(address registrant) external; /** * @notice Registers an address with the registry and "subscribes" to another address's filtered operators and codeHashes. */ function registerAndSubscribe(address registrant, address subscription) external; /** * @notice Registers an address with the registry and copies the filtered operators and codeHashes from another * address without subscribing. */ function registerAndCopyEntries(address registrant, address registrantToCopy) external; /** * @notice Unregisters an address with the registry and removes its subscription. May be called by address itself or by EIP-173 owner. * Note that this does not remove any filtered addresses or codeHashes. * Also note that any subscriptions to this registrant will still be active and follow the existing filtered addresses and codehashes. */ function unregister(address addr) external; /** * @notice Update an operator address for a registered address - when filtered is true, the operator is filtered. */ function updateOperator(address registrant, address operator, bool filtered) external; /** * @notice Update multiple operators for a registered address - when filtered is true, the operators will be filtered. Reverts on duplicates. */ function updateOperators(address registrant, address[] calldata operators, bool filtered) external; /** * @notice Update a codeHash for a registered address - when filtered is true, the codeHash is filtered. */ function updateCodeHash(address registrant, bytes32 codehash, bool filtered) external; /** * @notice Update multiple codeHashes for a registered address - when filtered is true, the codeHashes will be filtered. Reverts on duplicates. */ function updateCodeHashes(address registrant, bytes32[] calldata codeHashes, bool filtered) external; /** * @notice Subscribe an address to another registrant's filtered operators and codeHashes. Will remove previous * subscription if present. * Note that accounts with subscriptions may go on to subscribe to other accounts - in this case, * subscriptions will not be forwarded. Instead the former subscription's existing entries will still be * used. */ function subscribe(address registrant, address registrantToSubscribe) external; /** * @notice Unsubscribe an address from its current subscribed registrant, and optionally copy its filtered operators and codeHashes. */ function unsubscribe(address registrant, bool copyExistingEntries) external; /** * @notice Get the subscription address of a given registrant, if any. */ function subscriptionOf(address addr) external returns (address registrant); /** * @notice Get the set of addresses subscribed to a given registrant. * Note that order is not guaranteed as updates are made. */ function subscribers(address registrant) external returns (address[] memory); /** * @notice Get the subscriber at a given index in the set of addresses subscribed to a given registrant. * Note that order is not guaranteed as updates are made. */ function subscriberAt(address registrant, uint256 index) external returns (address); /** * @notice Copy filtered operators and codeHashes from a different registrantToCopy to addr. */ function copyEntriesOf(address registrant, address registrantToCopy) external; /** * @notice Returns true if operator is filtered by a given address or its subscription. */ function isOperatorFiltered(address registrant, address operator) external returns (bool); /** * @notice Returns true if the hash of an address's code is filtered by a given address or its subscription. */ function isCodeHashOfFiltered(address registrant, address operatorWithCode) external returns (bool); /** * @notice Returns true if a codeHash is filtered by a given address or its subscription. */ function isCodeHashFiltered(address registrant, bytes32 codeHash) external returns (bool); /** * @notice Returns a list of filtered operators for a given address or its subscription. */ function filteredOperators(address addr) external returns (address[] memory); /** * @notice Returns the set of filtered codeHashes for a given address or its subscription. * Note that order is not guaranteed as updates are made. */ function filteredCodeHashes(address addr) external returns (bytes32[] memory); /** * @notice Returns the filtered operator at the given index of the set of filtered operators for a given address or * its subscription. * Note that order is not guaranteed as updates are made. */ function filteredOperatorAt(address registrant, uint256 index) external returns (address); /** * @notice Returns the filtered codeHash at the given index of the list of filtered codeHashes for a given address or * its subscription. * Note that order is not guaranteed as updates are made. */ function filteredCodeHashAt(address registrant, uint256 index) external returns (bytes32); /** * @notice Returns true if an address has registered */ function isRegistered(address addr) external returns (bool); /** * @dev Convenience method to compute the code hash of an arbitrary contract */ function codeHashOf(address addr) external returns (bytes32); } // File: contracts/UpdatableOperatorFilterer.sol pragma solidity ^0.8.13; /** * @title UpdatableOperatorFilterer * @notice Abstract contract whose constructor automatically registers and optionally subscribes to or copies another * registrant's entries in the OperatorFilterRegistry. This contract allows the Owner to update the * OperatorFilterRegistry address via updateOperatorFilterRegistryAddress, including to the zero address, * which will bypass registry checks. * Note that OpenSea will still disable creator earnings enforcement if filtered operators begin fulfilling orders * on-chain, eg, if the registry is revoked or bypassed. * @dev This smart contract is meant to be inherited by token contracts so they can use the following: * - `onlyAllowedOperator` modifier for `transferFrom` and `safeTransferFrom` methods. * - `onlyAllowedOperatorApproval` modifier for `approve` and `setApprovalForAll` methods. */ abstract contract UpdatableOperatorFilterer { /// @dev Emitted when an operator is not allowed. error OperatorNotAllowed(address operator); /// @dev Emitted when someone other than the owner is trying to call an only owner function. error OnlyOwner(); event OperatorFilterRegistryAddressUpdated(address newRegistry); IOperatorFilterRegistry public operatorFilterRegistry; /// @dev The constructor that is called when the contract is being deployed. constructor(address _registry, address subscriptionOrRegistrantToCopy, bool subscribe) { IOperatorFilterRegistry registry = IOperatorFilterRegistry(_registry); operatorFilterRegistry = registry; // If an inheriting token contract is deployed to a network without the registry deployed, the modifier // will not revert, but the contract will need to be registered with the registry once it is deployed in // order for the modifier to filter addresses. if (address(registry).code.length > 0) { if (subscribe) { registry.registerAndSubscribe(address(this), subscriptionOrRegistrantToCopy); } else { if (subscriptionOrRegistrantToCopy != address(0)) { registry.registerAndCopyEntries(address(this), subscriptionOrRegistrantToCopy); } else { registry.register(address(this)); } } } } /** * @dev A helper function to check if the operator is allowed. */ modifier onlyAllowedOperator(address from) virtual { // Allow spending tokens from addresses with balance // Note that this still allows listings and marketplaces with escrow to transfer tokens if transferred // from an EOA. if (from != msg.sender) { _checkFilterOperator(msg.sender); } _; } /** * @dev A helper function to check if the operator approval is allowed. */ modifier onlyAllowedOperatorApproval(address operator) virtual { _checkFilterOperator(operator); _; } /** * @notice Update the address that the contract will make OperatorFilter checks against. When set to the zero * address, checks will be bypassed. OnlyOwner. */ function updateOperatorFilterRegistryAddress(address newRegistry) public virtual { if (msg.sender != owner()) { revert OnlyOwner(); } operatorFilterRegistry = IOperatorFilterRegistry(newRegistry); emit OperatorFilterRegistryAddressUpdated(newRegistry); } /** * @dev Assume the contract has an owner, but leave specific Ownable implementation up to inheriting contract. */ function owner() public view virtual returns (address); /** * @dev A helper function to check if the operator is allowed. */ function _checkFilterOperator(address operator) internal view virtual { IOperatorFilterRegistry registry = operatorFilterRegistry; // Check registry code length to facilitate testing in environments without a deployed registry. if (address(registry) != address(0) && address(registry).code.length > 0) { // under normal circumstances, this function will revert rather than return false, but inheriting contracts // may specify their own OperatorFilterRegistry implementations, which may behave differently if (!registry.isOperatorAllowed(address(this), operator)) { revert OperatorNotAllowed(operator); } } } } // File: contracts/RevokableOperatorFilterer.sol pragma solidity ^0.8.13; /** * @title RevokableOperatorFilterer * @notice This contract is meant to allow contracts to permanently skip OperatorFilterRegistry checks if desired. The * Registry itself has an "unregister" function, but if the contract is ownable, the owner can re-register at * any point. As implemented, this abstract contract allows the contract owner to permanently skip the * OperatorFilterRegistry checks by calling revokeOperatorFilterRegistry. Once done, the registry * address cannot be further updated. * Note that OpenSea will still disable creator earnings enforcement if filtered operators begin fulfilling orders * on-chain, eg, if the registry is revoked or bypassed. */ abstract contract RevokableOperatorFilterer is UpdatableOperatorFilterer { /// @dev Emitted when the registry has already been revoked. error RegistryHasBeenRevoked(); /// @dev Emitted when the initial registry address is attempted to be set to the zero address. error InitialRegistryAddressCannotBeZeroAddress(); event OperatorFilterRegistryRevoked(); bool public isOperatorFilterRegistryRevoked; /// @dev The constructor that is called when the contract is being deployed. constructor(address _registry, address subscriptionOrRegistrantToCopy, bool subscribe) UpdatableOperatorFilterer(_registry, subscriptionOrRegistrantToCopy, subscribe) { // don't allow creating a contract with a permanently revoked registry if (_registry == address(0)) { revert InitialRegistryAddressCannotBeZeroAddress(); } } /** * @notice Update the address that the contract will make OperatorFilter checks against. When set to the zero * address, checks will be permanently bypassed, and the address cannot be updated again. OnlyOwner. */ function updateOperatorFilterRegistryAddress(address newRegistry) public override { if (msg.sender != owner()) { revert OnlyOwner(); } // if registry has been revoked, do not allow further updates if (isOperatorFilterRegistryRevoked) { revert RegistryHasBeenRevoked(); } operatorFilterRegistry = IOperatorFilterRegistry(newRegistry); emit OperatorFilterRegistryAddressUpdated(newRegistry); } /** * @notice Revoke the OperatorFilterRegistry address, permanently bypassing checks. OnlyOwner. */ function revokeOperatorFilterRegistry() public { if (msg.sender != owner()) { revert OnlyOwner(); } // if registry has been revoked, do not allow further updates if (isOperatorFilterRegistryRevoked) { revert RegistryHasBeenRevoked(); } // set to zero address to bypass checks operatorFilterRegistry = IOperatorFilterRegistry(address(0)); isOperatorFilterRegistryRevoked = true; emit OperatorFilterRegistryRevoked(); } } // File: contracts/lib/Constants.sol pragma solidity ^0.8.13; address constant CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS = 0x000000000000AAeB6D7670E522A718067333cd4E; address constant CANONICAL_CORI_SUBSCRIPTION = 0x3cc6CddA760b79bAfa08dF41ECFA224f810dCeB6; // File: contracts/RevokableDefaultOperatorFilterer.sol pragma solidity ^0.8.13; /** * @title RevokableDefaultOperatorFilterer * @notice Inherits from RevokableOperatorFilterer and automatically subscribes to the default OpenSea subscription. * Note that OpenSea will disable creator earnings enforcement if filtered operators begin fulfilling orders * on-chain, eg, if the registry is revoked or bypassed. */ abstract contract RevokableDefaultOperatorFilterer is RevokableOperatorFilterer { /// @dev The constructor that is called when the contract is being deployed. constructor() RevokableOperatorFilterer(CANONICAL_OPERATOR_FILTER_REGISTRY_ADDRESS, CANONICAL_CORI_SUBSCRIPTION, true) {} } // File: contracts/IERC721A.sol // ERC721A Contracts v4.0.0 // Creator: Chiru Labs pragma solidity ^0.8.4; /** * @dev Interface of an ERC721A compliant contract. */ interface IERC721A { /** * The caller must own the token or be an approved operator. */ error ApprovalCallerNotOwnerNorApproved(); /** * The token does not exist. */ error ApprovalQueryForNonexistentToken(); /** * The caller cannot approve to their own address. */ error ApproveToCaller(); /** * The caller cannot approve to the current owner. */ error ApprovalToCurrentOwner(); /** * Cannot query the balance for the zero address. */ error BalanceQueryForZeroAddress(); /** * Cannot mint to the zero address. */ error MintToZeroAddress(); /** * The quantity of tokens minted must be more than zero. */ error MintZeroQuantity(); /** * The token does not exist. */ error OwnerQueryForNonexistentToken(); /** * The caller must own the token or be an approved operator. */ error TransferCallerNotOwnerNorApproved(); /** * The token must be owned by `from`. */ error TransferFromIncorrectOwner(); /** * Cannot safely transfer to a contract that does not implement the ERC721Receiver interface. */ error TransferToNonERC721ReceiverImplementer(); /** * Cannot transfer to the zero address. */ error TransferToZeroAddress(); /** * The token does not exist. */ error URIQueryForNonexistentToken(); struct TokenOwnership { // The address of the owner. address addr; // Keeps track of the start time of ownership with minimal overhead for tokenomics. uint64 startTimestamp; // Whether the token has been burned. bool burned; } /** * @dev Returns the total amount of tokens stored by the contract. * * Burned tokens are calculated here, use `_totalMinted()` if you want to count just minted tokens. */ function totalSupply() external view returns (uint256); // ============================== // 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); // ============================== // IERC721 // ============================== /** * @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`. * * Requirements: * * - `from` cannot be the zero address. * - `to` cannot be the zero address. * - `tokenId` token must exist and be owned by `from`. * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}. * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer. * * Emits a {Transfer} event. */ function safeTransferFrom( address from, address to, uint256 tokenId, bytes calldata data ) external; /** * @dev 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 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 the account approved for `tokenId` token. * * Requirements: * * - `tokenId` must exist. */ function getApproved(uint256 tokenId) external view returns (address operator); /** * @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); // ============================== // IERC721Metadata // ============================== /** * @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: contracts/ERC721A.sol // ERC721A Contracts v4.0.0 // Creator: Chiru Labs pragma solidity ^0.8.4; /** * @dev ERC721 token receiver interface. */ interface ERC721A__IERC721Receiver { function onERC721Received( address operator, address from, uint256 tokenId, bytes calldata data ) external returns (bytes4); } /** * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including * the Metadata extension. Built to optimize for lower gas during batch mints. * * Assumes serials are sequentially minted starting at _startTokenId() (defaults to 0, e.g. 0, 1, 2, 3..). * * Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply. * * Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256). */ contract ERC721A is IERC721A { // Mask of an entry in packed address data. uint256 private constant BITMASK_ADDRESS_DATA_ENTRY = (1 << 64) - 1; // The bit position of `numberMinted` in packed address data. uint256 private constant BITPOS_NUMBER_MINTED = 64; // The bit position of `numberBurned` in packed address data. uint256 private constant BITPOS_NUMBER_BURNED = 128; // The bit position of `aux` in packed address data. uint256 private constant BITPOS_AUX = 192; // Mask of all 256 bits in packed address data except the 64 bits for `aux`. uint256 private constant BITMASK_AUX_COMPLEMENT = (1 << 192) - 1; // The bit position of `startTimestamp` in packed ownership. uint256 private constant BITPOS_START_TIMESTAMP = 160; // The bit mask of the `burned` bit in packed ownership. uint256 private constant BITMASK_BURNED = 1 << 224; // The bit position of the `nextInitialized` bit in packed ownership. uint256 private constant BITPOS_NEXT_INITIALIZED = 225; // The bit mask of the `nextInitialized` bit in packed ownership. uint256 private constant BITMASK_NEXT_INITIALIZED = 1 << 225; // The tokenId of the next token to be minted. uint256 private _currentIndex; // The number of tokens burned. uint256 private _burnCounter; // Token name string private _name; // Token symbol string private _symbol; // Mapping from token ID to ownership details // An empty struct value does not necessarily mean the token is unowned. // See `_packedOwnershipOf` implementation for details. // // Bits Layout: // - [0..159] `addr` // - [160..223] `startTimestamp` // - [224] `burned` // - [225] `nextInitialized` mapping(uint256 => uint256) private _packedOwnerships; // Mapping owner address to address data. // // Bits Layout: // - [0..63] `balance` // - [64..127] `numberMinted` // - [128..191] `numberBurned` // - [192..255] `aux` mapping(address => uint256) private _packedAddressData; // 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; constructor(string memory name_, string memory symbol_) { _name = name_; _symbol = symbol_; _currentIndex = _startTokenId(); } /** * @dev Returns the starting token ID. * To change the starting token ID, please override this function. */ function _startTokenId() internal view virtual returns (uint256) { return 1; } /** * @dev Returns the next token ID to be minted. */ function _nextTokenId() internal view returns (uint256) { return _currentIndex; } /** * @dev Returns the total number of tokens in existence. * Burned tokens will reduce the count. * To get the total number of tokens minted, please see `_totalMinted`. */ function totalSupply() public view override returns (uint256) { // Counter underflow is impossible as _burnCounter cannot be incremented // more than `_currentIndex - _startTokenId()` times. unchecked { return _currentIndex - _burnCounter - _startTokenId(); } } /** * @dev Returns the total amount of tokens minted in the contract. */ function _totalMinted() internal view returns (uint256) { // Counter underflow is impossible as _currentIndex does not decrement, // and it is initialized to `_startTokenId()` unchecked { return _currentIndex - _startTokenId(); } } /** * @dev Returns the total number of tokens burned. */ function _totalBurned() internal view returns (uint256) { return _burnCounter; } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface( bytes4 interfaceId ) public view virtual override returns (bool) { // The interface IDs are constants representing the first 4 bytes of the XOR of // all function selectors in the interface. See: https://eips.ethereum.org/EIPS/eip-165 // e.g. `bytes4(i.functionA.selector ^ i.functionB.selector ^ ...)` return interfaceId == 0x01ffc9a7 || // ERC165 interface ID for ERC165. interfaceId == 0x80ac58cd || // ERC165 interface ID for ERC721. interfaceId == 0x5b5e139f; // ERC165 interface ID for ERC721Metadata. } /** * @dev See {IERC721-balanceOf}. */ function balanceOf(address owner) public view override returns (uint256) { if (_addressToUint256(owner) == 0) revert BalanceQueryForZeroAddress(); return _packedAddressData[owner] & BITMASK_ADDRESS_DATA_ENTRY; } /** * Returns the number of tokens minted by `owner`. */ function _numberMinted(address owner) internal view returns (uint256) { return (_packedAddressData[owner] >> BITPOS_NUMBER_MINTED) & BITMASK_ADDRESS_DATA_ENTRY; } /** * Returns the number of tokens burned by or on behalf of `owner`. */ function _numberBurned(address owner) internal view returns (uint256) { return (_packedAddressData[owner] >> BITPOS_NUMBER_BURNED) & BITMASK_ADDRESS_DATA_ENTRY; } /** * Returns the auxillary data for `owner`. (e.g. number of whitelist mint slots used). */ function _getAux(address owner) internal view returns (uint64) { return uint64(_packedAddressData[owner] >> BITPOS_AUX); } /** * Sets the auxillary data for `owner`. (e.g. number of whitelist mint slots used). * If there are multiple variables, please pack them into a uint64. */ function _setAux(address owner, uint64 aux) internal { uint256 packed = _packedAddressData[owner]; uint256 auxCasted; assembly { // Cast aux without masking. auxCasted := aux } packed = (packed & BITMASK_AUX_COMPLEMENT) | (auxCasted << BITPOS_AUX); _packedAddressData[owner] = packed; } /** * Returns the packed ownership data of `tokenId`. */ function _packedOwnershipOf( uint256 tokenId ) private view returns (uint256) { uint256 curr = tokenId; unchecked { if (_startTokenId() <= curr) if (curr < _currentIndex) { uint256 packed = _packedOwnerships[curr]; // If not burned. if (packed & BITMASK_BURNED == 0) { // Invariant: // There will always be an ownership that has an address and is not burned // before an ownership that does not have an address and is not burned. // Hence, curr will not underflow. // // We can directly compare the packed value. // If the address is zero, packed is zero. while (packed == 0) { packed = _packedOwnerships[--curr]; } return packed; } } } revert OwnerQueryForNonexistentToken(); } /** * Returns the unpacked `TokenOwnership` struct from `packed`. */ function _unpackedOwnership( uint256 packed ) private pure returns (TokenOwnership memory ownership) { ownership.addr = address(uint160(packed)); ownership.startTimestamp = uint64(packed >> BITPOS_START_TIMESTAMP); ownership.burned = packed & BITMASK_BURNED != 0; } /** * Returns the unpacked `TokenOwnership` struct at `index`. */ function _ownershipAt( uint256 index ) internal view returns (TokenOwnership memory) { return _unpackedOwnership(_packedOwnerships[index]); } /** * @dev Initializes the ownership slot minted at `index` for efficiency purposes. */ function _initializeOwnershipAt(uint256 index) internal { if (_packedOwnerships[index] == 0) { _packedOwnerships[index] = _packedOwnershipOf(index); } } /** * Gas spent here starts off proportional to the maximum mint batch size. * It gradually moves to O(1) as tokens get transferred around in the collection over time. */ function _ownershipOf( uint256 tokenId ) internal view returns (TokenOwnership memory) { return _unpackedOwnership(_packedOwnershipOf(tokenId)); } /** * @dev See {IERC721-ownerOf}. */ function ownerOf(uint256 tokenId) public view override returns (address) { return address(uint160(_packedOwnershipOf(tokenId))); } /** * @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) { if (!_exists(tokenId)) revert URIQueryForNonexistentToken(); string memory baseURI = _baseURI(); return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, _toString(tokenId))) : ""; } /** * @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 Casts the address to uint256 without masking. */ function _addressToUint256( address value ) private pure returns (uint256 result) { assembly { result := value } } /** * @dev Casts the boolean to uint256 without branching. */ function _boolToUint256(bool value) private pure returns (uint256 result) { assembly { result := value } } /** * @dev See {IERC721-approve}. */ function approve(address to, uint256 tokenId) public override { address owner = address(uint160(_packedOwnershipOf(tokenId))); if (to == owner) revert ApprovalToCurrentOwner(); if (_msgSenderERC721A() != owner) if (!isApprovedForAll(owner, _msgSenderERC721A())) { revert ApprovalCallerNotOwnerNorApproved(); } _tokenApprovals[tokenId] = to; emit Approval(owner, to, tokenId); } /** * @dev See {IERC721-getApproved}. */ function getApproved( uint256 tokenId ) public view override returns (address) { if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken(); return _tokenApprovals[tokenId]; } /** * @dev See {IERC721-setApprovalForAll}. */ function setApprovalForAll( address operator, bool approved ) public virtual override { if (operator == _msgSenderERC721A()) revert ApproveToCaller(); _operatorApprovals[_msgSenderERC721A()][operator] = approved; emit ApprovalForAll(_msgSenderERC721A(), 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 { _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 { _transfer(from, to, tokenId); if (to.code.length != 0) if (!_checkContractOnERC721Received(from, to, tokenId, _data)) { revert TransferToNonERC721ReceiverImplementer(); } } /** * @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`), */ function _exists(uint256 tokenId) internal view returns (bool) { return _startTokenId() <= tokenId && tokenId < _currentIndex && // If within bounds, _packedOwnerships[tokenId] & BITMASK_BURNED == 0; // and not burned. } /** * @dev Equivalent to `_safeMint(to, quantity, '')`. */ function _safeMint(address to, uint256 quantity) internal { _safeMint(to, quantity, ""); } /** * @dev Safely mints `quantity` tokens and transfers them to `to`. * * Requirements: * * - If `to` refers to a smart contract, it must implement * {IERC721Receiver-onERC721Received}, which is called for each safe transfer. * - `quantity` must be greater than 0. * * Emits a {Transfer} event. */ function _safeMint( address to, uint256 quantity, bytes memory _data ) internal { uint256 startTokenId = _currentIndex; if (_addressToUint256(to) == 0) revert MintToZeroAddress(); if (quantity == 0) revert MintZeroQuantity(); _beforeTokenTransfers(address(0), to, startTokenId, quantity); // Overflows are incredibly unrealistic. // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1 // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1 unchecked { // Updates: // - `balance += quantity`. // - `numberMinted += quantity`. // // We can directly add to the balance and number minted. _packedAddressData[to] += quantity * ((1 << BITPOS_NUMBER_MINTED) | 1); // Updates: // - `address` to the owner. // - `startTimestamp` to the timestamp of minting. // - `burned` to `false`. // - `nextInitialized` to `quantity == 1`. _packedOwnerships[startTokenId] = _addressToUint256(to) | (block.timestamp << BITPOS_START_TIMESTAMP) | (_boolToUint256(quantity == 1) << BITPOS_NEXT_INITIALIZED); uint256 updatedIndex = startTokenId; uint256 end = updatedIndex + quantity; if (to.code.length != 0) { do { emit Transfer(address(0), to, updatedIndex); if ( !_checkContractOnERC721Received( address(0), to, updatedIndex++, _data ) ) { revert TransferToNonERC721ReceiverImplementer(); } } while (updatedIndex < end); // Reentrancy protection if (_currentIndex != startTokenId) revert(); } else { do { emit Transfer(address(0), to, updatedIndex++); } while (updatedIndex < end); } _currentIndex = updatedIndex; } _afterTokenTransfers(address(0), to, startTokenId, quantity); } /** * @dev Mints `quantity` tokens and transfers them to `to`. * * Requirements: * * - `to` cannot be the zero address. * - `quantity` must be greater than 0. * * Emits a {Transfer} event. */ function _mint(address to, uint256 quantity) internal { uint256 startTokenId = _currentIndex; if (_addressToUint256(to) == 0) revert MintToZeroAddress(); if (quantity == 0) revert MintZeroQuantity(); _beforeTokenTransfers(address(0), to, startTokenId, quantity); // Overflows are incredibly unrealistic. // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1 // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1 unchecked { // Updates: // - `balance += quantity`. // - `numberMinted += quantity`. // // We can directly add to the balance and number minted. _packedAddressData[to] += quantity * ((1 << BITPOS_NUMBER_MINTED) | 1); // Updates: // - `address` to the owner. // - `startTimestamp` to the timestamp of minting. // - `burned` to `false`. // - `nextInitialized` to `quantity == 1`. _packedOwnerships[startTokenId] = _addressToUint256(to) | (block.timestamp << BITPOS_START_TIMESTAMP) | (_boolToUint256(quantity == 1) << BITPOS_NEXT_INITIALIZED); uint256 updatedIndex = startTokenId; uint256 end = updatedIndex + quantity; do { emit Transfer(address(0), to, updatedIndex++); } while (updatedIndex < end); _currentIndex = updatedIndex; } _afterTokenTransfers(address(0), to, startTokenId, quantity); } /** * @dev Transfers `tokenId` from `from` to `to`. * * 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) private { uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId); if (address(uint160(prevOwnershipPacked)) != from) revert TransferFromIncorrectOwner(); address approvedAddress = _tokenApprovals[tokenId]; bool isApprovedOrOwner = (_msgSenderERC721A() == from || isApprovedForAll(from, _msgSenderERC721A()) || approvedAddress == _msgSenderERC721A()); if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved(); if (_addressToUint256(to) == 0) revert TransferToZeroAddress(); _beforeTokenTransfers(from, to, tokenId, 1); // Clear approvals from the previous owner. if (_addressToUint256(approvedAddress) != 0) { delete _tokenApprovals[tokenId]; } // Underflow of the sender's balance is impossible because we check for // ownership above and the recipient's balance can't realistically overflow. // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256. unchecked { // We can directly increment and decrement the balances. --_packedAddressData[from]; // Updates: `balance -= 1`. ++_packedAddressData[to]; // Updates: `balance += 1`. // Updates: // - `address` to the next owner. // - `startTimestamp` to the timestamp of transfering. // - `burned` to `false`. // - `nextInitialized` to `true`. _packedOwnerships[tokenId] = _addressToUint256(to) | (block.timestamp << BITPOS_START_TIMESTAMP) | BITMASK_NEXT_INITIALIZED; // If the next slot may not have been initialized (i.e. `nextInitialized == false`) . if (prevOwnershipPacked & BITMASK_NEXT_INITIALIZED == 0) { uint256 nextTokenId = tokenId + 1; // If the next slot's address is zero and not burned (i.e. packed value is zero). if (_packedOwnerships[nextTokenId] == 0) { // If the next slot is within bounds. if (nextTokenId != _currentIndex) { // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`. _packedOwnerships[nextTokenId] = prevOwnershipPacked; } } } } emit Transfer(from, to, tokenId); _afterTokenTransfers(from, to, tokenId, 1); } /** * @dev Equivalent to `_burn(tokenId, false)`. */ function _burn(uint256 tokenId) internal virtual { _burn(tokenId, false); } /** * @dev Destroys `tokenId`. * The approval is cleared when the token is burned. * * Requirements: * * - `tokenId` must exist. * * Emits a {Transfer} event. */ function _burn(uint256 tokenId, bool approvalCheck) internal virtual { uint256 prevOwnershipPacked = _packedOwnershipOf(tokenId); address from = address(uint160(prevOwnershipPacked)); address approvedAddress = _tokenApprovals[tokenId]; if (approvalCheck) { bool isApprovedOrOwner = (_msgSenderERC721A() == from || isApprovedForAll(from, _msgSenderERC721A()) || approvedAddress == _msgSenderERC721A()); if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved(); } _beforeTokenTransfers(from, address(0), tokenId, 1); // Clear approvals from the previous owner. if (_addressToUint256(approvedAddress) != 0) { delete _tokenApprovals[tokenId]; } // Underflow of the sender's balance is impossible because we check for // ownership above and the recipient's balance can't realistically overflow. // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256. unchecked { // Updates: // - `balance -= 1`. // - `numberBurned += 1`. // // We can directly decrement the balance, and increment the number burned. // This is equivalent to `packed -= 1; packed += 1 << BITPOS_NUMBER_BURNED;`. _packedAddressData[from] += (1 << BITPOS_NUMBER_BURNED) - 1; // Updates: // - `address` to the last owner. // - `startTimestamp` to the timestamp of burning. // - `burned` to `true`. // - `nextInitialized` to `true`. _packedOwnerships[tokenId] = _addressToUint256(from) | (block.timestamp << BITPOS_START_TIMESTAMP) | BITMASK_BURNED | BITMASK_NEXT_INITIALIZED; // If the next slot may not have been initialized (i.e. `nextInitialized == false`) . if (prevOwnershipPacked & BITMASK_NEXT_INITIALIZED == 0) { uint256 nextTokenId = tokenId + 1; // If the next slot's address is zero and not burned (i.e. packed value is zero). if (_packedOwnerships[nextTokenId] == 0) { // If the next slot is within bounds. if (nextTokenId != _currentIndex) { // Initialize the next slot to maintain correctness for `ownerOf(tokenId + 1)`. _packedOwnerships[nextTokenId] = prevOwnershipPacked; } } } } emit Transfer(from, address(0), tokenId); _afterTokenTransfers(from, address(0), tokenId, 1); // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times. unchecked { _burnCounter++; } } /** * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target 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 _checkContractOnERC721Received( address from, address to, uint256 tokenId, bytes memory _data ) private returns (bool) { try ERC721A__IERC721Receiver(to).onERC721Received( _msgSenderERC721A(), from, tokenId, _data ) returns (bytes4 retval) { return retval == ERC721A__IERC721Receiver(to).onERC721Received.selector; } catch (bytes memory reason) { if (reason.length == 0) { revert TransferToNonERC721ReceiverImplementer(); } else { assembly { revert(add(32, reason), mload(reason)) } } } } /** * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting. * And also called before burning one token. * * startTokenId - the first token id to be transferred * quantity - the amount to be transferred * * 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, `tokenId` will be burned by `from`. * - `from` and `to` are never both zero. */ function _beforeTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity ) internal virtual {} /** * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes * minting. * And also called after one token has been burned. * * startTokenId - the first token id to be transferred * quantity - the amount to be transferred * * Calling conditions: * * - When `from` and `to` are both non-zero, `from`'s `tokenId` has been * transferred to `to`. * - When `from` is zero, `tokenId` has been minted for `to`. * - When `to` is zero, `tokenId` has been burned by `from`. * - `from` and `to` are never both zero. */ function _afterTokenTransfers( address from, address to, uint256 startTokenId, uint256 quantity ) internal virtual {} /** * @dev Returns the message sender (defaults to `msg.sender`). * * If you are writing GSN compatible contracts, you need to override this function. */ function _msgSenderERC721A() internal view virtual returns (address) { return msg.sender; } /** * @dev Converts a `uint256` to its ASCII `string` decimal representation. */ function _toString( uint256 value ) internal pure returns (string memory ptr) { assembly { // The maximum value of a uint256 contains 78 digits (1 byte per digit), // but we allocate 128 bytes to keep the free memory pointer 32-byte word aliged. // We will need 1 32-byte word to store the length, // and 3 32-byte words to store a maximum of 78 digits. Total: 32 + 3 * 32 = 128. ptr := add(mload(0x40), 128) // Update the free memory pointer to allocate. mstore(0x40, ptr) // Cache the end of the memory to calculate the length later. let end := ptr // We write the string from the rightmost digit to the leftmost digit. // The following is essentially a do-while loop that also handles the zero case. // Costs a bit more than early returning for the zero case, // but cheaper in terms of deployment and overall runtime costs. for { // Initialize and perform the first pass without check. let temp := value // Move the pointer 1 byte leftwards to point to an empty character slot. ptr := sub(ptr, 1) // Write the character to the pointer. 48 is the ASCII index of '0'. mstore8(ptr, add(48, mod(temp, 10))) temp := div(temp, 10) } temp { // Keep dividing `temp` until zero. temp := div(temp, 10) } { // Body of the for loop. ptr := sub(ptr, 1) mstore8(ptr, add(48, mod(temp, 10))) } let length := sub(end, ptr) // Move the pointer 32 bytes leftwards to make room for the length. ptr := sub(ptr, 32) // Store the length. mstore(ptr, length) } } } // File: contracts/GangzOfNewYork.sol pragma solidity ^0.8.20; contract GangzOfNewYork is ERC721A, ERC2981, Ownable, RevokableDefaultOperatorFilterer, ReentrancyGuard { uint256 public maxSupply = 2222; uint256 public publicSupply = 1751; uint256 public limit = 6; uint256 public price = 0.05 ether; bool public mintEnabled; bool public revealed; string public hiddenURI; string public baseURI; mapping(address => bool) whitelistedWallets; mapping(address => uint256) mintedWallets; constructor() ERC721A("Gangz Of New York", "GONY") { setDefaultRoyalty(msg.sender, 1000); // 10% default royalty } function mint(uint256 numberOfTokens) external payable nonReentrant { uint256 amount = numberOfTokens * price; require(mintEnabled, "Mint Disabled"); require(whitelistedWallets[msg.sender], "Not Whitelisted"); require(totalSupply() + numberOfTokens <= publicSupply, "Sold Out"); require(mintedWallets[msg.sender] + numberOfTokens <= limit, "Too Many"); require(msg.value >= amount, "Not Enough Ether"); mintedWallets[msg.sender] += numberOfTokens; _mint(msg.sender, numberOfTokens); } function teamMint(address to, uint256 numberOfTokens) external onlyOwner nonReentrant { require(totalSupply() + numberOfTokens <= maxSupply, "Sold Out"); _mint(to, numberOfTokens); } function whitelistWallets(address[] memory walletAddresses) external onlyOwner { for (uint i = 0; i < walletAddresses.length; i++) { whitelistedWallets[walletAddresses[i]] = true; } } function unwhitelistWallets(address[] memory walletAddresses) external onlyOwner { for (uint i = 0; i < walletAddresses.length; i++) { whitelistedWallets[walletAddresses[i]] = false; } } function setMaxSupply(uint256 _maxSupply) external onlyOwner { maxSupply = _maxSupply; } function setPublicSupply(uint256 _publicSupply) external onlyOwner { publicSupply = _publicSupply; } function setLimit(uint256 _limit) external onlyOwner { limit = _limit; } function setPrice(uint256 _price) external onlyOwner { price = _price; } function toggleMinting() external onlyOwner { mintEnabled = !mintEnabled; } function toggleRevealed() external onlyOwner { revealed = !revealed; } function setHiddenURI(string calldata hiddenURI_) external onlyOwner { hiddenURI = hiddenURI_; } function setBaseURI(string calldata baseURI_) external onlyOwner { baseURI = baseURI_; } function _baseURI() internal view virtual override returns (string memory) { return baseURI; } function tokenURI(uint256 tokenId) public view override returns (string memory) { require(_exists(tokenId), "GONY Does Not Exist"); if (revealed) { return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, Strings.toString(tokenId))) : ""; } return hiddenURI; } function withdraw() external onlyOwner nonReentrant { (bool success, ) = msg.sender.call{value: address(this).balance}(""); require(success, "Withdraw Eth Failed"); } function getMintedAmount(address _address) public view returns (uint256) { return mintedWallets[_address]; } // ========================================================================= // ERC2891 // ========================================================================= function setDefaultRoyalty(address receiver, uint96 feeNumerator) public onlyOwner { _setDefaultRoyalty(receiver, feeNumerator); } function deleteDefaultRoyalty() public onlyOwner { _deleteDefaultRoyalty(); } /** * @dev See {IERC165-supportsInterface}. */ function supportsInterface(bytes4 interfaceId) public view virtual override(ERC721A, ERC2981) returns (bool) { return ERC721A.supportsInterface(interfaceId) || ERC2981.supportsInterface(interfaceId); } function owner() public view override(Ownable, UpdatableOperatorFilterer) returns (address) { return Ownable.owner(); } }
Contract Security Audit
- No Contract Security Audit Submitted- Submit Audit Here
[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"InitialRegistryAddressCannotBeZeroAddress","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"OnlyOwner","type":"error"},{"inputs":[{"internalType":"address","name":"operator","type":"address"}],"name":"OperatorNotAllowed","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"RegistryHasBeenRevoked","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"inputs":[],"name":"URIQueryForNonexistentToken","type":"error"},{"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":false,"internalType":"address","name":"newRegistry","type":"address"}],"name":"OperatorFilterRegistryAddressUpdated","type":"event"},{"anonymous":false,"inputs":[],"name":"OperatorFilterRegistryRevoked","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"deleteDefaultRoyalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_address","type":"address"}],"name":"getMintedAmount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"hiddenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"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":[],"name":"isOperatorFilterRegistryRevoked","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"limit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"numberOfTokens","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"operatorFilterRegistry","outputs":[{"internalType":"contract IOperatorFilterRegistry","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"price","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"revealed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"revokeOperatorFilterRegistry","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"},{"internalType":"uint256","name":"_salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI_","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"receiver","type":"address"},{"internalType":"uint96","name":"feeNumerator","type":"uint96"}],"name":"setDefaultRoyalty","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"hiddenURI_","type":"string"}],"name":"setHiddenURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_limit","type":"uint256"}],"name":"setLimit","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxSupply","type":"uint256"}],"name":"setMaxSupply","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_price","type":"uint256"}],"name":"setPrice","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_publicSupply","type":"uint256"}],"name":"setPublicSupply","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":"address","name":"to","type":"address"},{"internalType":"uint256","name":"numberOfTokens","type":"uint256"}],"name":"teamMint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"toggleMinting","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"toggleRevealed","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"walletAddresses","type":"address[]"}],"name":"unwhitelistWallets","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newRegistry","type":"address"}],"name":"updateOperatorFilterRegistryAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address[]","name":"walletAddresses","type":"address[]"}],"name":"whitelistWallets","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"}]
Contract Creation Code
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
Deployed Bytecode
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
Deployed Bytecode Sourcemap
70118:4382:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;74126:228;;;;;;;;;;-1:-1:-1;74126:228:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;74126:228:0;;;;;;;;73811:144;;;;;;;;;;-1:-1:-1;73811:144:0;;;;;:::i;:::-;;:::i;:::-;;48974:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;51121:220::-;;;;;;;;;;-1:-1:-1;51121:220:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;2246:32:1;;;2228:51;;2216:2;2201:18;51121:220:0;2082:203:1;50581:474:0;;;;;;;;;;-1:-1:-1;50581:474:0;;;;;:::i;:::-;;:::i;71749:222::-;;;;;;;;;;-1:-1:-1;71749:222:0;;;;;:::i;:::-;;:::i;42860:315::-;;;;;;;;;;-1:-1:-1;42467:1:0;43126:12;42913:7;43110:13;:28;-1:-1:-1;;43110:46:0;42860:315;;;4064:25:1;;;4052:2;4037:18;42860:315:0;3918:177:1;52073:170:0;;;;;;;;;;-1:-1:-1;52073:170:0;;;;;:::i;:::-;;:::i;72089:114::-;;;;;;;;;;-1:-1:-1;72089:114:0;;;;;:::i;:::-;;:::i;72211:86::-;;;;;;;;;;-1:-1:-1;72211:86:0;;;;;:::i;:::-;;:::i;13011:442::-;;;;;;;;;;-1:-1:-1;13011:442:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;4878:32:1;;;4860:51;;4942:2;4927:18;;4920:34;;;;4833:18;13011:442:0;4686:274:1;71522:219:0;;;;;;;;;;-1:-1:-1;71522:219:0;;;;;:::i;:::-;;:::i;73270:189::-;;;;;;;;;;;;;:::i;52314:185::-;;;;;;;;;;-1:-1:-1;52314:185:0;;;;;:::i;:::-;;:::i;70413:20::-;;;;;;;;;;-1:-1:-1;70413:20:0;;;;;;;;;;;72706:102;;;;;;;;;;-1:-1:-1;72706:102:0;;;;;:::i;:::-;;:::i;72496:84::-;;;;;;;;;;;;;:::i;70269:34::-;;;;;;;;;;;;;;;;29189:531;;;;;;;;;;;;;:::i;48763:144::-;;;;;;;;;;-1:-1:-1;48763:144:0;;;;;:::i;:::-;;:::i;73467:122::-;;;;;;;;;;-1:-1:-1;73467:122:0;;;;;:::i;:::-;-1:-1:-1;;;;;73558:23:0;73531:7;73558:23;;;:13;:23;;;;;;;73467:122;70470:21;;;;;;;;;;;;;:::i;71979:102::-;;;;;;;;;;-1:-1:-1;71979:102:0;;;;;:::i;:::-;;:::i;44501:234::-;;;;;;;;;;-1:-1:-1;44501:234:0;;;;;:::i;:::-;;:::i;7694:103::-;;;;;;;;;;;;;:::i;72399:89::-;;;;;;;;;;;;;:::i;70440:23::-;;;;;;;;;;;;;:::i;74362:133::-;;;;;;;;;;;;;:::i;72305:86::-;;;;;;;;;;-1:-1:-1;72305:86:0;;;;;:::i;:::-;;:::i;49143:104::-;;;;;;;;;;;;;:::i;70341:33::-;;;;;;;;;;;;;;;;70736:563;;;;;;:::i;:::-;;:::i;51413:333::-;;;;;;;;;;-1:-1:-1;51413:333:0;;;;;:::i;:::-;;:::i;70310:24::-;;;;;;;;;;;;;;;;73963:91;;;;;;;;;;;;;:::i;71307:207::-;;;;;;;;;;-1:-1:-1;71307:207:0;;;;;:::i;:::-;;:::i;23239:53::-;;;;;;;;;;-1:-1:-1;23239:53:0;;;;-1:-1:-1;;;;;23239:53:0;;;52570:396;;;;;;;;;;-1:-1:-1;52570:396:0;;;;;:::i;:::-;;:::i;28576:487::-;;;;;;;;;;-1:-1:-1;28576:487:0;;;;;:::i;:::-;;:::i;72588:110::-;;;;;;;;;;-1:-1:-1;72588:110:0;;;;;:::i;:::-;;:::i;72932:330::-;;;;;;;;;;-1:-1:-1;72932:330:0;;;;;:::i;:::-;;:::i;70383:23::-;;;;;;;;;;-1:-1:-1;70383:23:0;;;;;;;;70231:31;;;;;;;;;;;;;;;;51817:189;;;;;;;;;;-1:-1:-1;51817:189:0;;;;;:::i;:::-;;:::i;27802:43::-;;;;;;;;;;-1:-1:-1;27802:43:0;;;;-1:-1:-1;;;27802:43:0;;;;;;7952:201;;;;;;;;;;-1:-1:-1;7952:201:0;;;;;:::i;:::-;;:::i;74126:228::-;74229:4;74253:38;74279:11;74253:25;:38::i;:::-;:93;;;;74308:38;74334:11;74308:25;:38::i;:::-;74246:100;74126:228;-1:-1:-1;;74126:228:0:o;73811:144::-;6932:13;:11;:13::i;:::-;73905:42:::1;73924:8;73934:12;73905:18;:42::i;:::-;73811:144:::0;;:::o;48974:100::-;49028:13;49061:5;49054:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;48974:100;:::o;51121:220::-;51205:7;51230:16;51238:7;51230;:16::i;:::-;51225:64;;51255:34;;-1:-1:-1;;;51255:34:0;;;;;;;;;;;51225:64;-1:-1:-1;51309:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;51309:24:0;;51121:220::o;50581:474::-;50654:13;50686:27;50705:7;50686:18;:27::i;:::-;50654:61;;50736:5;-1:-1:-1;;;;;50730:11:0;:2;-1:-1:-1;;;;;50730:11:0;;50726:48;;50750:24;;-1:-1:-1;;;50750:24:0;;;;;;;;;;;50726:48;67928:10;-1:-1:-1;;;;;50791:28:0;;;50787:175;;50839:44;50856:5;67928:10;51817:189;:::i;50839:44::-;50834:128;;50911:35;;-1:-1:-1;;;50911:35:0;;;;;;;;;;;50834:128;50974:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;50974:29:0;-1:-1:-1;;;;;50974:29:0;;;;;;;;;51019:28;;50974:24;;51019:28;;;;;;;50643:412;50581:474;;:::o;71749:222::-;6932:13;:11;:13::i;:::-;71846:6:::1;71841:123;71862:15;:22;71858:1;:26;71841:123;;;71947:5;71906:18;:38;71925:15;71941:1;71925:18;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;;-1:-1:-1;;;;;71906:38:0::1;::::0;;;::::1;::::0;;;;;;-1:-1:-1;71906:38:0;:46;;-1:-1:-1;;71906:46:0::1;::::0;::::1;;::::0;;;::::1;::::0;;71886:3;::::1;::::0;::::1;:::i;:::-;;;;71841:123;;52073:170:::0;52207:28;52217:4;52223:2;52227:7;52207:9;:28::i;:::-;52073:170;;;:::o;72089:114::-;6932:13;:11;:13::i;:::-;72167:12:::1;:28:::0;72089:114::o;72211:86::-;6932:13;:11;:13::i;:::-;72275:5:::1;:14:::0;72211:86::o;13011:442::-;13108:7;13166:27;;;:17;:27;;;;;;;;13137:56;;;;;;;;;-1:-1:-1;;;;;13137:56:0;;;;;-1:-1:-1;;;13137:56:0;;;-1:-1:-1;;;;;13137:56:0;;;;;;;;13108:7;;13206:92;;-1:-1:-1;13257:29:0;;;;;;;;;13267:19;13257:29;-1:-1:-1;;;;;13257:29:0;;;;-1:-1:-1;;;13257:29:0;;-1:-1:-1;;;;;13257:29:0;;;;;13206:92;13348:23;;;;13310:21;;13819:5;;13335:36;;-1:-1:-1;;;;;13335:36:0;:10;:36;:::i;:::-;13334:58;;;;:::i;:::-;13413:16;;;;;-1:-1:-1;13011:442:0;;-1:-1:-1;;;;13011:442:0:o;71522:219::-;6932:13;:11;:13::i;:::-;71617:6:::1;71612:122;71633:15;:22;71629:1;:26;71612:122;;;71718:4;71677:18;:38;71696:15;71712:1;71696:18;;;;;;;;:::i;:::-;;::::0;;::::1;::::0;;;;;;;-1:-1:-1;;;;;71677:38:0::1;::::0;;;::::1;::::0;;;;;;-1:-1:-1;71677:38:0;:45;;-1:-1:-1;;71677:45:0::1;::::0;::::1;;::::0;;;::::1;::::0;;71657:3;::::1;::::0;::::1;:::i;:::-;;;;71612:122;;73270:189:::0;6932:13;:11;:13::i;:::-;3971:1:::1;4569:7;;:19:::0;4561:63:::1;;;;-1:-1:-1::0;;;4561:63:0::1;;;;;;;:::i;:::-;;;;;;;;;3971:1;4702:7;:18:::0;73352:49:::2;::::0;73334:12:::2;::::0;73352:10:::2;::::0;73375:21:::2;::::0;73334:12;73352:49;73334:12;73352:49;73375:21;73352:10;:49:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;73333:68;;;73420:7;73412:39;;;::::0;-1:-1:-1;;;73412:39:0;;9585:2:1;73412:39:0::2;::::0;::::2;9567:21:1::0;9624:2;9604:18;;;9597:30;-1:-1:-1;;;9643:18:1;;;9636:49;9702:18;;73412:39:0::2;9383:343:1::0;73412:39:0::2;-1:-1:-1::0;3927:1:0::1;4881:7;:22:::0;73270:189::o;52314:185::-;52452:39;52469:4;52475:2;52479:7;52452:39;;;;;;;;;;;;:16;:39::i;72706:102::-;6932:13;:11;:13::i;:::-;72782:7:::1;:18;72792:8:::0;;72782:7;:18:::1;:::i;72496:84::-:0;6932:13;:11;:13::i;:::-;72564:8:::1;::::0;;-1:-1:-1;;72552:20:0;::::1;72564:8;::::0;;;::::1;;;72563:9;72552:20:::0;;::::1;;::::0;;72496:84::o;29189:531::-;29265:7;:5;:7::i;:::-;-1:-1:-1;;;;;29251:21:0;:10;-1:-1:-1;;;;;29251:21:0;;29247:72;;29296:11;;-1:-1:-1;;;29296:11:0;;;;;;;;;;;29247:72;29404:31;;-1:-1:-1;;;29404:31:0;;;;29400:95;;;29459:24;;-1:-1:-1;;;29459:24:0;;;;;;;;;;;29400:95;29556:22;:60;;-1:-1:-1;;;;;;29627:38:0;-1:-1:-1;;;29627:38:0;;;29681:31;;;;29613:1;;29681:31;29189:531::o;48763:144::-;48827:7;48870:27;48889:7;48870:18;:27::i;70470:21::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;71979:102::-;6932:13;:11;:13::i;:::-;72051:9:::1;:22:::0;71979:102::o;44501:234::-;44565:7;44607:5;44617:1;44589:29;44585:70;;44627:28;;-1:-1:-1;;;44627:28:0;;;;;;;;;;;44585:70;-1:-1:-1;;;;;;44673:25:0;;;;;:18;:25;;;;;;39830:13;44673:54;;44501:234::o;7694:103::-;6932:13;:11;:13::i;:::-;7759:30:::1;7786:1;7759:18;:30::i;:::-;7694:103::o:0;72399:89::-;6932:13;:11;:13::i;:::-;72469:11:::1;::::0;;-1:-1:-1;;72454:26:0;::::1;72469:11;::::0;;::::1;72468:12;72454:26;::::0;;72399:89::o;70440:23::-;;;;;;;:::i;74362:133::-;74445:7;74472:15;7119:6;;-1:-1:-1;;;;;7119:6:0;;7046:87;74472:15;74465:22;;74362:133;:::o;72305:86::-;6932:13;:11;:13::i;:::-;72369:5:::1;:14:::0;72305:86::o;49143:104::-;49199:13;49232:7;49225:14;;;;;:::i;70736:563::-;3971:1;4569:7;;:19;4561:63;;;;-1:-1:-1;;;4561:63:0;;;;;;;:::i;:::-;3971:1;4702:7;:18;70849:5:::1;::::0;70815:14:::1;::::0;70832:22:::1;::::0;:14;:22:::1;:::i;:::-;70873:11;::::0;70815:39;;-1:-1:-1;70873:11:0::1;;70865:37;;;::::0;-1:-1:-1;;;70865:37:0;;11991:2:1;70865:37:0::1;::::0;::::1;11973:21:1::0;12030:2;12010:18;;;12003:30;-1:-1:-1;;;12049:18:1;;;12042:43;12102:18;;70865:37:0::1;11789:337:1::0;70865:37:0::1;70940:10;70921:30;::::0;;;:18:::1;:30;::::0;;;;;::::1;;70913:58;;;::::0;-1:-1:-1;;;70913:58:0;;12333:2:1;70913:58:0::1;::::0;::::1;12315:21:1::0;12372:2;12352:18;;;12345:30;-1:-1:-1;;;12391:18:1;;;12384:45;12446:18;;70913:58:0::1;12131:339:1::0;70913:58:0::1;71024:12;::::0;42467:1;43126:12;42913:7;43110:13;71006:14;;43110:28;;-1:-1:-1;;43110:46:0;70990:30:::1;;;;:::i;:::-;:46;;70982:67;;;::::0;-1:-1:-1;;;70982:67:0;;12807:2:1;70982:67:0::1;::::0;::::1;12789:21:1::0;12846:1;12826:18;;;12819:29;-1:-1:-1;;;12864:18:1;;;12857:38;12912:18;;70982:67:0::1;12605:331:1::0;70982:67:0::1;71114:5;::::0;71082:10:::1;71068:25;::::0;;;:13:::1;:25;::::0;;;;;:42:::1;::::0;71096:14;;71068:42:::1;:::i;:::-;:51;;71060:72;;;::::0;-1:-1:-1;;;71060:72:0;;13143:2:1;71060:72:0::1;::::0;::::1;13125:21:1::0;13182:1;13162:18;;;13155:29;-1:-1:-1;;;13200:18:1;;;13193:38;13248:18;;71060:72:0::1;12941:331:1::0;71060:72:0::1;71164:6;71151:9;:19;;71143:48;;;::::0;-1:-1:-1;;;71143:48:0;;13479:2:1;71143:48:0::1;::::0;::::1;13461:21:1::0;13518:2;13498:18;;;13491:30;-1:-1:-1;;;13537:18:1;;;13530:46;13593:18;;71143:48:0::1;13277:340:1::0;71143:48:0::1;71218:10;71204:25;::::0;;;:13:::1;:25;::::0;;;;:43;;71233:14;;71204:25;:43:::1;::::0;71233:14;;71204:43:::1;:::i;:::-;::::0;;;-1:-1:-1;71258:33:0::1;::::0;-1:-1:-1;71264:10:0::1;71276:14:::0;71258:5:::1;:33::i;:::-;-1:-1:-1::0;;3927:1:0;4881:7;:22;70736:563::o;51413:333::-;67928:10;-1:-1:-1;;;;;51537:31:0;;;51533:61;;51577:17;;-1:-1:-1;;;51577:17:0;;;;;;;;;;;51533:61;67928:10;51607:39;;;;:18;:39;;;;;;;;-1:-1:-1;;;;;51607:49:0;;;;;;;;;;;;:60;;-1:-1:-1;;51607:60:0;;;;;;;;;;51683:55;;540:41:1;;;51607:49:0;;67928:10;51683:55;;513:18:1;51683:55:0;;;;;;;51413:333;;:::o;73963:91::-;6932:13;:11;:13::i;:::-;74023:23:::1;14579:19:::0;;14572:26;14511:95;71307:207;6932:13;:11;:13::i;:::-;3971:1:::1;4569:7;;:19:::0;4561:63:::1;;;;-1:-1:-1::0;;;4561:63:0::1;;;;;;;:::i;:::-;3971:1;4702:7;:18:::0;71446:9:::2;::::0;42467:1;43126:12;42913:7;43110:13;71428:14;;43110:28;;-1:-1:-1;;43110:46:0;71412:30:::2;;;;:::i;:::-;:43;;71404:64;;;::::0;-1:-1:-1;;;71404:64:0;;12807:2:1;71404:64:0::2;::::0;::::2;12789:21:1::0;12846:1;12826:18;;;12819:29;-1:-1:-1;;;12864:18:1;;;12857:38;12912:18;;71404:64:0::2;12605:331:1::0;71404:64:0::2;71481:25;71487:2;71491:14;71481:5;:25::i;52570:396::-:0;52737:28;52747:4;52753:2;52757:7;52737:9;:28::i;:::-;-1:-1:-1;;;;;52780:14:0;;;:19;52776:183;;52819:56;52850:4;52856:2;52860:7;52869:5;52819:30;:56::i;:::-;52814:145;;52903:40;;-1:-1:-1;;;52903:40:0;;;;;;;;;;;52814:145;52570:396;;;;:::o;28576:487::-;28687:7;:5;:7::i;:::-;-1:-1:-1;;;;;28673:21:0;:10;-1:-1:-1;;;;;28673:21:0;;28669:72;;28718:11;;-1:-1:-1;;;28718:11:0;;;;;;;;;;;28669:72;28826:31;;-1:-1:-1;;;28826:31:0;;;;28822:95;;;28881:24;;-1:-1:-1;;;28881:24:0;;;;;;;;;;;28822:95;28929:22;:61;;-1:-1:-1;;;;;;28929:61:0;-1:-1:-1;;;;;28929:61:0;;;;;;;;29006:49;;2228:51:1;;;29006:49:0;;2216:2:1;2201:18;29006:49:0;;;;;;;28576:487;:::o;72588:110::-;6932:13;:11;:13::i;:::-;72668:9:::1;:22;72680:10:::0;;72668:9;:22:::1;:::i;72932:330::-:0;72997:13;73031:16;73039:7;73031;:16::i;:::-;73023:48;;;;-1:-1:-1;;;73023:48:0;;13824:2:1;73023:48:0;;;13806:21:1;13863:2;13843:18;;;13836:30;-1:-1:-1;;;13882:18:1;;;13875:49;13941:18;;73023:48:0;13622:343:1;73023:48:0;73088:8;;;;;;;73084:142;;;73126:7;73120:21;;;;;:::i;:::-;;;73145:1;73120:26;:94;;;;;;;;;;;;;;;;;73173:7;73182:25;73199:7;73182:16;:25::i;:::-;73156:52;;;;;;;;;:::i;:::-;;;;;;;;;;;;;73113:101;72932:330;-1:-1:-1;;72932:330:0:o;73084:142::-;73245:9;73238:16;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;72932:330;;;:::o;51817:189::-;-1:-1:-1;;;;;51963:25:0;;;51939:4;51963:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;51817:189::o;7952:201::-;6932:13;:11;:13::i;:::-;-1:-1:-1;;;;;8041:22:0;::::1;8033:73;;;::::0;-1:-1:-1;;;8033:73:0;;15197:2:1;8033:73:0::1;::::0;::::1;15179:21:1::0;15236:2;15216:18;;;15209:30;15275:34;15255:18;;;15248:62;-1:-1:-1;;;15326:18:1;;;15319:36;15372:19;;8033:73:0::1;14995:402:1::0;8033:73:0::1;8117:28;8136:8;8117:18;:28::i;:::-;7952:201:::0;:::o;43806:631::-;43907:4;-1:-1:-1;;;;;;;;;44207:25:0;;;;:102;;-1:-1:-1;;;;;;;;;;44284:25:0;;;44207:102;:179;;;-1:-1:-1;;;;;;;;44361:25:0;-1:-1:-1;;;44361:25:0;;43806:631::o;12741:215::-;12843:4;-1:-1:-1;;;;;;12867:41:0;;-1:-1:-1;;;12867:41:0;;:81;;-1:-1:-1;;;;;;;;;;10402:40:0;;;12912:36;10293:157;7211:132;67928:10;7275:7;:5;:7::i;:::-;-1:-1:-1;;;;;7275:23:0;;7267:68;;;;-1:-1:-1;;;7267:68:0;;15604:2:1;7267:68:0;;;15586:21:1;;;15623:18;;;15616:30;15682:34;15662:18;;;15655:62;15734:18;;7267:68:0;15402:356:1;14103:332:0;13819:5;-1:-1:-1;;;;;14206:33:0;;;;14198:88;;;;-1:-1:-1;;;14198:88:0;;15965:2:1;14198:88:0;;;15947:21:1;16004:2;15984:18;;;15977:30;16043:34;16023:18;;;16016:62;-1:-1:-1;;;16094:18:1;;;16087:40;16144:19;;14198:88:0;15763:406:1;14198:88:0;-1:-1:-1;;;;;14305:22:0;;14297:60;;;;-1:-1:-1;;;14297:60:0;;16376:2:1;14297:60:0;;;16358:21:1;16415:2;16395:18;;;16388:30;16454:27;16434:18;;;16427:55;16499:18;;14297:60:0;16174:349:1;14297:60:0;14392:35;;;;;;;;;-1:-1:-1;;;;;14392:35:0;;;;;;-1:-1:-1;;;;;14392:35:0;;;;;;;;;;-1:-1:-1;;;14370:57:0;;;;:19;:57;14103:332::o;53221:273::-;53278:4;53334:7;42467:1;53315:26;;:66;;;;;53368:13;;53358:7;:23;53315:66;:152;;;;-1:-1:-1;;53419:26:0;;;;:17;:26;;;;;;-1:-1:-1;;;53419:43:0;:48;;53221:273::o;46214:1145::-;46297:7;46332;;42467:1;46381:23;46377:915;;46434:13;;46427:4;:20;46423:869;;;46472:14;46489:23;;;:17;:23;;;;;;;-1:-1:-1;;;46578:23:0;;:28;;46574:699;;47097:113;47104:6;47114:1;47104:11;47097:113;;-1:-1:-1;;;47175:6:0;47157:25;;;;:17;:25;;;;;;47097:113;;;47243:6;46214:1145;-1:-1:-1;;;46214:1145:0:o;46574:699::-;46449:843;46423:869;47320:31;;-1:-1:-1;;;47320:31:0;;;;;;;;;;;58739:2633;58820:27;58850;58869:7;58850:18;:27::i;:::-;58820:57;;58935:4;-1:-1:-1;;;;;58894:45:0;58910:19;-1:-1:-1;;;;;58894:45:0;;58890:99;;58961:28;;-1:-1:-1;;;58961:28:0;;;;;;;;;;;58890:99;59002:23;59028:24;;;:15;:24;;;;;;-1:-1:-1;;;;;59028:24:0;;;;59002:23;59091:27;;67928:10;59091:27;;:87;;-1:-1:-1;59135:43:0;59152:4;67928:10;51817:189;:::i;59135:43::-;59091:142;;;-1:-1:-1;;;;;;59195:38:0;;67928:10;59195:38;59091:142;59065:169;;59252:17;59247:66;;59278:35;;-1:-1:-1;;;59278:35:0;;;;;;;;;;;59247:66;59346:2;59353:1;59328:26;59324:62;;59363:23;;-1:-1:-1;;;59363:23:0;;;;;;;;;;;59324:62;59530:15;59512:39;59508:103;;59575:24;;;;:15;:24;;;;;59568:31;;-1:-1:-1;;;;;;59568:31:0;;;59508:103;-1:-1:-1;;;;;59978:24:0;;;;;;;:18;:24;;;;;;;;59976:26;;-1:-1:-1;;59976:26:0;;;60047:22;;;;;;;;60045:24;;-1:-1:-1;60045:24:0;;;60340:26;;;:17;:26;;;;;-1:-1:-1;;;60428:15:0;40484:3;60428:41;60386:84;;:128;;60340:174;;;60634:46;;:51;;60630:626;;60738:1;60728:11;;60706:19;60861:30;;;:17;:30;;;;;;:35;;60857:384;;60999:13;;60984:11;:28;60980:242;;61146:30;;;;:17;:30;;;;;:52;;;60980:242;60687:569;60630:626;61303:7;61299:2;-1:-1:-1;;;;;61284:27:0;61293:4;-1:-1:-1;;;;;61284:27:0;;;;;;;;;;;61322:42;58809:2563;;;58739:2633;;;:::o;8313:191::-;8406:6;;;-1:-1:-1;;;;;8423:17:0;;;-1:-1:-1;;;;;;8423:17:0;;;;;;;8456:40;;8406:6;;;8423:17;8406:6;;8456:40;;8387:16;;8456:40;8376:128;8313:191;:::o;56785:1700::-;56850:20;56873:13;56919:2;56926:1;56901:26;56897:58;;56936:19;;-1:-1:-1;;;56936:19:0;;;;;;;;;;;56897:58;56970:8;56982:1;56970:13;56966:44;;56992:18;;-1:-1:-1;;;56992:18:0;;;;;;;;;;;56966:44;-1:-1:-1;;;;;57559:22:0;;;;;;:18;:22;;;;39967:2;57559:22;;;:104;;57631:31;57602:61;;57559:104;;;57906:31;;;:17;:31;;;;;57999:15;40484:3;57999:41;57957:84;;-1:-1:-1;58077:13:0;;40743:3;58062:56;57957:162;57906:213;;:31;58200:23;;;58240:111;58267:40;;58292:14;;;;;-1:-1:-1;;;;;58267:40:0;;;58284:1;;58267:40;;58284:1;;58267:40;58346:3;58331:12;:18;58240:111;;-1:-1:-1;58367:13:0;:28;52073:170;;;:::o;65195:831::-;65392:171;;-1:-1:-1;;;65392:171:0;;65358:4;;-1:-1:-1;;;;;65392:45:0;;;;;:171;;67928:10;;65494:4;;65517:7;;65543:5;;65392:171;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;65392:171:0;;;;;;;;-1:-1:-1;;65392:171:0;;;;;;;;;;;;:::i;:::-;;;65375:644;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;65777:6;:13;65794:1;65777:18;65773:235;;65823:40;;-1:-1:-1;;;65823:40:0;;;;;;;;;;;65773:235;65966:6;65960:13;65951:6;65947:2;65943:15;65936:38;65375:644;-1:-1:-1;;;;;;65636:81:0;-1:-1:-1;;;65636:81:0;;-1:-1:-1;65375:644:0;65195:831;;;;;;:::o;400:723::-;456:13;677:5;686:1;677:10;673:53;;-1:-1:-1;;704:10:0;;;;;;;;;;;;-1:-1:-1;;;704:10:0;;;;;400:723::o;673:53::-;751:5;736:12;792:78;799:9;;792:78;;825:8;;;;:::i;:::-;;-1:-1:-1;848:10:0;;-1:-1:-1;856:2:0;848:10;;:::i;:::-;;;792:78;;;880:19;912:6;902:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;902:17:0;;880:39;;930:154;937:10;;930:154;;964:11;974:1;964:11;;:::i;:::-;;-1:-1:-1;1033:10:0;1041:2;1033:5;:10;:::i;:::-;1020:24;;:2;:24;:::i;:::-;1007:39;;990:6;997;990:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;990:56:0;;;;;;;;-1:-1:-1;1061:11:0;1070:2;1061:11;;:::i;:::-;;;930:154;;14:131:1;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:173::-;660:20;;-1:-1:-1;;;;;709:31:1;;699:42;;689:70;;755:1;752;745:12;689:70;592:173;;;:::o;770:366::-;837:6;845;898:2;886:9;877:7;873:23;869:32;866:52;;;914:1;911;904:12;866:52;937:29;956:9;937:29;:::i;:::-;927:39;;1016:2;1005:9;1001:18;988:32;-1:-1:-1;;;;;1053:5:1;1049:38;1042:5;1039:49;1029:77;;1102:1;1099;1092:12;1029:77;1125:5;1115:15;;;770:366;;;;;:::o;1141:250::-;1226:1;1236:113;1250:6;1247:1;1244:13;1236:113;;;1326:11;;;1320:18;1307:11;;;1300:39;1272:2;1265:10;1236:113;;;-1:-1:-1;;1383:1:1;1365:16;;1358:27;1141:250::o;1396:271::-;1438:3;1476:5;1470:12;1503:6;1498:3;1491:19;1519:76;1588:6;1581:4;1576:3;1572:14;1565:4;1558:5;1554:16;1519:76;:::i;:::-;1649:2;1628:15;-1:-1:-1;;1624:29:1;1615:39;;;;1656:4;1611:50;;1396:271;-1:-1:-1;;1396:271:1:o;1672:220::-;1821:2;1810:9;1803:21;1784:4;1841:45;1882:2;1871:9;1867:18;1859:6;1841:45;:::i;1897:180::-;1956:6;2009:2;1997:9;1988:7;1984:23;1980:32;1977:52;;;2025:1;2022;2015:12;1977:52;-1:-1:-1;2048:23:1;;1897:180;-1:-1:-1;1897:180:1:o;2290:254::-;2358:6;2366;2419:2;2407:9;2398:7;2394:23;2390:32;2387:52;;;2435:1;2432;2425:12;2387:52;2458:29;2477:9;2458:29;:::i;:::-;2448:39;2534:2;2519:18;;;;2506:32;;-1:-1:-1;;;2290:254:1:o;2549:127::-;2610:10;2605:3;2601:20;2598:1;2591:31;2641:4;2638:1;2631:15;2665:4;2662:1;2655:15;2681:275;2752:2;2746:9;2817:2;2798:13;;-1:-1:-1;;2794:27:1;2782:40;;2852:18;2837:34;;2873:22;;;2834:62;2831:88;;;2899:18;;:::i;:::-;2935:2;2928:22;2681:275;;-1:-1:-1;2681:275:1:o;2961:952::-;3045:6;3076:2;3119;3107:9;3098:7;3094:23;3090:32;3087:52;;;3135:1;3132;3125:12;3087:52;3175:9;3162:23;3204:18;3245:2;3237:6;3234:14;3231:34;;;3261:1;3258;3251:12;3231:34;3299:6;3288:9;3284:22;3274:32;;3344:7;3337:4;3333:2;3329:13;3325:27;3315:55;;3366:1;3363;3356:12;3315:55;3402:2;3389:16;3424:2;3420;3417:10;3414:36;;;3430:18;;:::i;:::-;3476:2;3473:1;3469:10;3459:20;;3499:28;3523:2;3519;3515:11;3499:28;:::i;:::-;3561:15;;;3631:11;;;3627:20;;;3592:12;;;;3659:19;;;3656:39;;;3691:1;3688;3681:12;3656:39;3715:11;;;;3735:148;3751:6;3746:3;3743:15;3735:148;;;3817:23;3836:3;3817:23;:::i;:::-;3805:36;;3768:12;;;;3861;;;;3735:148;;;3902:5;2961:952;-1:-1:-1;;;;;;;;2961:952:1:o;4100:328::-;4177:6;4185;4193;4246:2;4234:9;4225:7;4221:23;4217:32;4214:52;;;4262:1;4259;4252:12;4214:52;4285:29;4304:9;4285:29;:::i;:::-;4275:39;;4333:38;4367:2;4356:9;4352:18;4333:38;:::i;:::-;4323:48;;4418:2;4407:9;4403:18;4390:32;4380:42;;4100:328;;;;;:::o;4433:248::-;4501:6;4509;4562:2;4550:9;4541:7;4537:23;4533:32;4530:52;;;4578:1;4575;4568:12;4530:52;-1:-1:-1;;4601:23:1;;;4671:2;4656:18;;;4643:32;;-1:-1:-1;4433:248:1:o;4965:592::-;5036:6;5044;5097:2;5085:9;5076:7;5072:23;5068:32;5065:52;;;5113:1;5110;5103:12;5065:52;5153:9;5140:23;5182:18;5223:2;5215:6;5212:14;5209:34;;;5239:1;5236;5229:12;5209:34;5277:6;5266:9;5262:22;5252:32;;5322:7;5315:4;5311:2;5307:13;5303:27;5293:55;;5344:1;5341;5334:12;5293:55;5384:2;5371:16;5410:2;5402:6;5399:14;5396:34;;;5426:1;5423;5416:12;5396:34;5471:7;5466:2;5457:6;5453:2;5449:15;5445:24;5442:37;5439:57;;;5492:1;5489;5482:12;5439:57;5523:2;5515:11;;;;;5545:6;;-1:-1:-1;4965:592:1;;-1:-1:-1;;;;4965:592:1:o;5562:186::-;5621:6;5674:2;5662:9;5653:7;5649:23;5645:32;5642:52;;;5690:1;5687;5680:12;5642:52;5713:29;5732:9;5713:29;:::i;5753:347::-;5818:6;5826;5879:2;5867:9;5858:7;5854:23;5850:32;5847:52;;;5895:1;5892;5885:12;5847:52;5918:29;5937:9;5918:29;:::i;:::-;5908:39;;5997:2;5986:9;5982:18;5969:32;6044:5;6037:13;6030:21;6023:5;6020:32;6010:60;;6066:1;6063;6056:12;6344:980;6439:6;6447;6455;6463;6516:3;6504:9;6495:7;6491:23;6487:33;6484:53;;;6533:1;6530;6523:12;6484:53;6556:29;6575:9;6556:29;:::i;:::-;6546:39;;6604:2;6625:38;6659:2;6648:9;6644:18;6625:38;:::i;:::-;6615:48;;6710:2;6699:9;6695:18;6682:32;6672:42;;6765:2;6754:9;6750:18;6737:32;6788:18;6829:2;6821:6;6818:14;6815:34;;;6845:1;6842;6835:12;6815:34;6883:6;6872:9;6868:22;6858:32;;6928:7;6921:4;6917:2;6913:13;6909:27;6899:55;;6950:1;6947;6940:12;6899:55;6986:2;6973:16;7008:2;7004;7001:10;6998:36;;;7014:18;;:::i;:::-;7056:53;7099:2;7080:13;;-1:-1:-1;;7076:27:1;7072:36;;7056:53;:::i;:::-;7043:66;;7132:2;7125:5;7118:17;7172:7;7167:2;7162;7158;7154:11;7150:20;7147:33;7144:53;;;7193:1;7190;7183:12;7144:53;7248:2;7243;7239;7235:11;7230:2;7223:5;7219:14;7206:45;7292:1;7287:2;7282;7275:5;7271:14;7267:23;7260:34;;7313:5;7303:15;;;;;6344:980;;;;;;;:::o;7329:260::-;7397:6;7405;7458:2;7446:9;7437:7;7433:23;7429:32;7426:52;;;7474:1;7471;7464:12;7426:52;7497:29;7516:9;7497:29;:::i;:::-;7487:39;;7545:38;7579:2;7568:9;7564:18;7545:38;:::i;:::-;7535:48;;7329:260;;;;;:::o;7594:380::-;7673:1;7669:12;;;;7716;;;7737:61;;7791:4;7783:6;7779:17;7769:27;;7737:61;7844:2;7836:6;7833:14;7813:18;7810:38;7807:161;;7890:10;7885:3;7881:20;7878:1;7871:31;7925:4;7922:1;7915:15;7953:4;7950:1;7943:15;7807:161;;7594:380;;;:::o;7979:127::-;8040:10;8035:3;8031:20;8028:1;8021:31;8071:4;8068:1;8061:15;8095:4;8092:1;8085:15;8111:127;8172:10;8167:3;8163:20;8160:1;8153:31;8203:4;8200:1;8193:15;8227:4;8224:1;8217:15;8243:135;8282:3;8303:17;;;8300:43;;8323:18;;:::i;:::-;-1:-1:-1;8370:1:1;8359:13;;8243:135::o;8383:168::-;8456:9;;;8487;;8504:15;;;8498:22;;8484:37;8474:71;;8525:18;;:::i;8556:127::-;8617:10;8612:3;8608:20;8605:1;8598:31;8648:4;8645:1;8638:15;8672:4;8669:1;8662:15;8688:120;8728:1;8754;8744:35;;8759:18;;:::i;:::-;-1:-1:-1;8793:9:1;;8688:120::o;8813:355::-;9015:2;8997:21;;;9054:2;9034:18;;;9027:30;9093:33;9088:2;9073:18;;9066:61;9159:2;9144:18;;8813:355::o;9857:545::-;9959:2;9954:3;9951:11;9948:448;;;9995:1;10020:5;10016:2;10009:17;10065:4;10061:2;10051:19;10135:2;10123:10;10119:19;10116:1;10112:27;10106:4;10102:38;10171:4;10159:10;10156:20;10153:47;;;-1:-1:-1;10194:4:1;10153:47;10249:2;10244:3;10240:12;10237:1;10233:20;10227:4;10223:31;10213:41;;10304:82;10322:2;10315:5;10312:13;10304:82;;;10367:17;;;10348:1;10337:13;10304:82;;10578:1206;10702:18;10697:3;10694:27;10691:53;;;10724:18;;:::i;:::-;10753:94;10843:3;10803:38;10835:4;10829:11;10803:38;:::i;:::-;10797:4;10753:94;:::i;:::-;10873:1;10898:2;10893:3;10890:11;10915:1;10910:616;;;;11570:1;11587:3;11584:93;;;-1:-1:-1;11643:19:1;;;11630:33;11584:93;-1:-1:-1;;10535:1:1;10531:11;;;10527:24;10523:29;10513:40;10559:1;10555:11;;;10510:57;11690:78;;10883:895;;10910:616;9804:1;9797:14;;;9841:4;9828:18;;-1:-1:-1;;10946:17:1;;;11047:9;11069:229;11083:7;11080:1;11077:14;11069:229;;;11172:19;;;11159:33;11144:49;;11279:4;11264:20;;;;11232:1;11220:14;;;;11099:12;11069:229;;;11073:3;11326;11317:7;11314:16;11311:159;;;11450:1;11446:6;11440:3;11434;11431:1;11427:11;11423:21;11419:34;11415:39;11402:9;11397:3;11393:19;11380:33;11376:79;11368:6;11361:95;11311:159;;;11513:1;11507:3;11504:1;11500:11;11496:19;11490:4;11483:33;10883:895;;;10578:1206;;;:::o;12475:125::-;12540:9;;;12561:10;;;12558:36;;;12574:18;;:::i;13970:1020::-;14146:3;14175:1;14208:6;14202:13;14238:36;14264:9;14238:36;:::i;:::-;14293:1;14310:18;;;14337:133;;;;14484:1;14479:356;;;;14303:532;;14337:133;-1:-1:-1;;14370:24:1;;14358:37;;14443:14;;14436:22;14424:35;;14415:45;;;-1:-1:-1;14337:133:1;;14479:356;14510:6;14507:1;14500:17;14540:4;14585:2;14582:1;14572:16;14610:1;14624:165;14638:6;14635:1;14632:13;14624:165;;;14716:14;;14703:11;;;14696:35;14759:16;;;;14653:10;;14624:165;;;14628:3;;;14818:6;14813:3;14809:16;14802:23;;14303:532;;;;;14866:6;14860:13;14882:68;14941:8;14936:3;14929:4;14921:6;14917:17;14882:68;:::i;:::-;14966:18;;13970:1020;-1:-1:-1;;;;13970:1020:1:o;16528:489::-;-1:-1:-1;;;;;16797:15:1;;;16779:34;;16849:15;;16844:2;16829:18;;16822:43;16896:2;16881:18;;16874:34;;;16944:3;16939:2;16924:18;;16917:31;;;16722:4;;16965:46;;16991:19;;16983:6;16965:46;:::i;:::-;16957:54;16528:489;-1:-1:-1;;;;;;16528:489:1:o;17022:249::-;17091:6;17144:2;17132:9;17123:7;17119:23;17115:32;17112:52;;;17160:1;17157;17150:12;17112:52;17192:9;17186:16;17211:30;17235:5;17211:30;:::i;17276:128::-;17343:9;;;17364:11;;;17361:37;;;17378:18;;:::i;17409:112::-;17441:1;17467;17457:35;;17472:18;;:::i;:::-;-1:-1:-1;17506:9:1;;17409:112::o
Swarm Source
ipfs://705d1cabf4f9bc044941ac575730698c92fc61bf5df64c268f5bd895d0ac6ec2
Loading...
Loading
Loading...
Loading
[ 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.