Token

Pegasus NFT (Pegasus NFT)

ERC-721

Overview

Max Total Supply

571 Pegasus NFT

Holders

249

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xd15a09b0679c45f3facd7bab22b676028dacff21

Filtered by Token Holder

0x6BaFDA2192811B823fc3D4A2078E0A7024E9f73B

Balance

3 Pegasus NFT

0x6BaFDA2192811B823fc3D4A2078E0A7024E9f73B

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

PegasusNFT

Compiler Version

v0.8.9+commit.e5eed63a

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2022-10-27
*/

/**
 *  SPDX-License-Identifier: MIT
*/
pragma solidity ^0.8.7;

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

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

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


/**
 * @dev ERC721 token receiver interface.
 */
interface ERC721A__IERC721Receiver {
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}


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

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

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

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

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

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

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

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

/*
 * @dev Provides information about the current execution context, including the
 * sender of the transaction and its data. While these are generally available
 * via msg.sender and msg.data, they should not be accessed in such a direct
 * manner, since when dealing with meta-transactions the account sending and
 * paying for execution may not be the actual sender (as far as an application
 * is concerned).
 *
 * This contract is only required for intermediate, library-like contracts.
 */
abstract contract Context {
    function _msgSender() internal view virtual returns (address) {
        return msg.sender;
    }

    function _msgData() internal view virtual returns (bytes calldata) {
        return msg.data;
    }
}


/**
 * @dev Contract module which provides a basic access control mechanism, where
 * there is an account (an owner) that can be granted exclusive access to
 * specific functions.
 *
 * By default, the owner account will be the one that deploys the contract. This
 * can later be changed with {transferOwnership}.
 *
 * This module is used through inheritance. It will make available the modifier
 * `onlyOwner`, which can be applied to your functions to restrict their use to
 * the owner.
 */
abstract contract Ownable is Context {
    address private _owner;

    event OwnershipTransferred(address indexed previousOwner, address indexed newOwner);

    /**
     * @dev Initializes the contract setting the deployer as the initial owner.
     */
    constructor() {
        _transferOwnership(_msgSender());
    }

    /**
     * @dev Returns the address of the current owner.
     */
    function owner() public view virtual returns (address) {
        return _owner;
    }

    /**
     * @dev Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        require(owner() == _msgSender(), "Ownable: caller is not the owner");
        _;
    }

    /**
     * @dev Leaves the contract without owner. It will not be possible to call
     * `onlyOwner` functions anymore. Can only be called by the current owner.
     *
     * NOTE: Renouncing ownership will leave the contract without an owner,
     * thereby removing any functionality that is only available to the owner.
     */
    function renounceOwnership() public virtual onlyOwner {
        _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);
    }
}

contract SignatureVerifiable{
    
    using SafeMath for uint256;
    
    bytes32 public constant DOMAIN_TYPEHASH =keccak256(
      abi.encodePacked(
        "EIP712Domain(",
        "string name,",
        "string version,",
        "uint256 chainId,",
        "address verifyingContract",
        ")"
      )
    );

    
    bytes32 public constant DOMAIN_NAME = keccak256("PegasusNFT");
    bytes32 public constant DOMAIN_VERSION = keccak256("1");
    bytes32 public DOMAIN_SEPARATOR;
    address public verifyAddress;
    
    function getChainId() public view returns (uint256 id) {
        // no-inline-assembly
        assembly {
          id := chainid()
        }
    }

   /**
   * @notice Recover the signatory from a signature
   * @param hash bytes32
   * @param v uint8
   * @param r bytes32
   * @param s bytes32
   */
    function getSignatory(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
      ) internal view returns (address) {
        bytes32 digest =
          keccak256(abi.encodePacked("\x19\x01", DOMAIN_SEPARATOR, hash));
        address signatory = ecrecover(digest, v, r, s);
        // Ensure the signatory is not null
        require(signatory != address(0), "INVALID_SIG");
        return signatory;
    }
}

library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies in extcodesize, which returns 0 for contracts in
        // construction, since the code is only stored at the end of the
        // constructor execution.

        uint256 size;
        // solhint-disable-next-line no-inline-assembly
        assembly { size := extcodesize(account) }
        return size > 0;
    }

    /**
     * @dev Replacement for Solidity's `transfer`: sends `amount` wei to
     * `recipient`, forwarding all available gas and reverting on errors.
     *
     * https://eips.ethereum.org/EIPS/eip-1884[EIP1884] increases the gas cost
     * of certain opcodes, possibly making contracts go over the 2300 gas limit
     * imposed by `transfer`, making them unable to receive funds via
     * `transfer`. {sendValue} removes this limitation.
     *
     * https://diligence.consensys.net/posts/2019/09/stop-using-soliditys-transfer-now/[Learn more].
     *
     * IMPORTANT: because control is transferred to `recipient`, care must be
     * taken to not create reentrancy vulnerabilities. Consider using
     * {ReentrancyGuard} or the
     * https://solidity.readthedocs.io/en/v0.5.11/security-considerations.html#use-the-checks-effects-interactions-pattern[checks-effects-interactions pattern].
     */
    function sendValue(address payable recipient, uint256 amount) internal {
        require(address(this).balance >= amount, "Address: insufficient balance");

        // solhint-disable-next-line avoid-low-level-calls, avoid-call-value
        (bool success, ) = recipient.call{ value: amount }("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

    /**
     * @dev Performs a Solidity function call using a low level `call`. A
     * plain`call` is an unsafe replacement for a function call: use this
     * function instead.
     *
     * If `target` reverts with a revert reason, it is bubbled up by this
     * function (like regular Solidity function calls).
     *
     * Returns the raw returned data. To convert to the expected return value,
     * use https://solidity.readthedocs.io/en/latest/units-and-global-variables.html?highlight=abi.decode#abi-encoding-and-decoding-functions[`abi.decode`].
     *
     * Requirements:
     *
     * - `target` must be a contract.
     * - calling `target` with `data` must not revert.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data) internal returns (bytes memory) {
      return functionCall(target, data, "Address: low-level call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`], but with
     * `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCall(address target, bytes memory data, string memory errorMessage) internal returns (bytes memory) {
        return _functionCallWithValue(target, data, 0, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but also transferring `value` wei to `target`.
     *
     * Requirements:
     *
     * - the calling contract must have an ETH balance of at least `value`.
     * - the called Solidity function must be `payable`.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value) internal returns (bytes memory) {
        return functionCallWithValue(target, data, value, "Address: low-level call with value failed");
    }

    /**
     * @dev Same as {xref-Address-functionCallWithValue-address-bytes-uint256-}[`functionCallWithValue`], but
     * with `errorMessage` as a fallback revert reason when `target` reverts.
     *
     * _Available since v3.1._
     */
    function functionCallWithValue(address target, bytes memory data, uint256 value, string memory errorMessage) internal returns (bytes memory) {
        require(address(this).balance >= value, "Address: insufficient balance for call");
        return _functionCallWithValue(target, data, value, errorMessage);
    }

    function _functionCallWithValue(address target, bytes memory data, uint256 weiValue, string memory errorMessage) private returns (bytes memory) {
        require(isContract(target), "Address: call to non-contract");

        // solhint-disable-next-line avoid-low-level-calls
        (bool success, bytes memory returndata) = target.call{ value: weiValue }(data);
        if (success) {
            return returndata;
        } else {
            // Look for revert reason and bubble it up if present
            if (returndata.length > 0) {
                // The easiest way to bubble the revert reason is using memory via assembly

                // solhint-disable-next-line no-inline-assembly
                assembly {
                    let returndata_size := mload(returndata)
                    revert(add(32, returndata), returndata_size)
                }
            } else {
                revert(errorMessage);
            }
        }
    }
}

library SafeERC20 {
    using SafeMath for uint256;
    using Address for address;

    function safeTransfer(IERC20 token, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transfer.selector, to, value));
    }

    function safeTransferFrom(IERC20 token, address from, address to, uint256 value) internal {
        _callOptionalReturn(token, abi.encodeWithSelector(token.transferFrom.selector, from, to, value));
    }

    /**
     * @dev Deprecated. This function has issues similar to the ones found in
     * {IERC20-approve}, and its usage is discouraged.
     *
     * Whenever possible, use {safeIncreaseAllowance} and
     * {safeDecreaseAllowance} instead.
     */
    function safeApprove(IERC20 token, address spender, uint256 value) internal {
        // safeApprove should only be called when setting an initial allowance,
        // or when resetting it to zero. To increase and decrease it, use
        // 'safeIncreaseAllowance' and 'safeDecreaseAllowance'
        // solhint-disable-next-line max-line-length
        require((value == 0) || (token.allowance(address(this), spender) == 0),
            "SafeERC20: approve from non-zero to non-zero allowance"
        );
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, value));
    }

    function safeIncreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).add(value);
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    function safeDecreaseAllowance(IERC20 token, address spender, uint256 value) internal {
        uint256 newAllowance = token.allowance(address(this), spender).sub(value, "SafeERC20: decreased allowance below zero");
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

    /**
     * @dev Imitates a Solidity high-level call (i.e. a regular function call to a contract), relaxing the requirement
     * on the return value: the return value is optional (but if data is returned, it must not be false).
     * @param token The token targeted by the call.
     * @param data The call data (encoded using abi.encode or one of its variants).
     */
    function _callOptionalReturn(IERC20 token, bytes memory data) private {
        // We need to perform a low level call here, to bypass Solidity's return data size checking mechanism, since
        // we're implementing it ourselves. We use {Address.functionCall} to perform this call, which verifies that
        // the target address contains contract code and also asserts for success in the low-level call.

        bytes memory returndata = address(token).functionCall(data, "SafeERC20: low-level call failed");
        if (returndata.length > 0) { // Return data is optional
            // solhint-disable-next-line max-line-length
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

abstract contract NFTLogic{
    function isLegal(uint256 batch,uint256 startTime,address userAddress,uint256 quantity) external view virtual returns (bool);
    function addBatchUserBuyQuantity(uint256 batch,address userAddress,uint256 quantity) public virtual;
}

/**
 * @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 PegasusNFT is IERC721A,Ownable,SignatureVerifiable {

    using SafeMath for uint256; 
    using SafeERC20 for IERC20;

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

    uint256 private _maxSupply;

    uint256 public currentBatch = 0;
    uint256 public currentStartTime;
    address public logicAddress;

    //baseURI prefix
    string private _baseURI = "";

    string private _blindURI = "";

    mapping(address=>uint256) public userMintTotal;

    mapping(uint256 => NFTInfo) public nftInfoLs;

    struct NFTInfo{
        uint256 tokenId;
        uint256 batch;
        uint256 price;
    }

    event NFTMintEvent(
        uint256 tokenId,
        uint256 tag,
        uint256 batch,
        uint256 price,
        address owner
    );

    constructor(string memory __name,string memory __symbol,uint256 __maxSupply,address _verifyAddress) {
        _currentIndex = _startTokenId();
        _name = __name;
        _symbol = __symbol;
        _maxSupply = __maxSupply;
        verifyAddress = _verifyAddress;

        uint256 currentChainId = getChainId();
        DOMAIN_SEPARATOR = keccak256(
          abi.encode(
            DOMAIN_TYPEHASH,
            DOMAIN_NAME,
            DOMAIN_VERSION,
            currentChainId,
            this
          )
        );
    }

    function verifyMint(address sender,uint256 mintCount,uint256 mintPrice,uint8 v,uint256 _r,uint256 _s) internal view returns(bool){
        bytes32 r = bytes32(_r);
        bytes32 s = bytes32(_s);        
        bytes32 hash = keccak256(
            abi.encode(
              keccak256(abi.encodePacked("mint(address sender,uint256 mintCount,uint256 mintPrice)")),
              sender,mintCount,mintPrice
            )
        );
        if(getSignatory(hash,v,r,s) == verifyAddress){
            return true;
        }
        else{
            return false;
        }
    }

    function mint(address sender,uint256 mintCount,uint256 mintPrice,uint8 v,uint256 _r,uint256 _s) public payable{
        require(verifyMint(sender,mintCount,mintPrice,v,_r,_s),"invalid sign.");
        require(msg.sender==tx.origin,"human only."); 
        require(msg.sender==sender,"invalid sender."); 
        require(msg.value==mintPrice,"invalid mintPrice."); 
        require(currentBatch > 0,"not started.");
        require(mintCount > 0 ,"invalid mintCount.");
        require(totalSupply().add(mintCount)<=_maxSupply,"Sale would exceed max supply.");
        require(NFTLogic(logicAddress).isLegal(currentBatch,currentStartTime,msg.sender,mintCount),"fail.");
        uint256 price = mintPrice.div(mintCount);
        _safeMint(msg.sender,mintCount,price,0);
        userMintTotal[msg.sender] = userMintTotal[msg.sender].add(mintCount);
        NFTLogic(logicAddress).addBatchUserBuyQuantity(currentBatch,msg.sender,mintCount);
    }
    
    function setVerifyAddress(address _addr) public onlyOwner{
        verifyAddress = _addr;
    }
    
    function setCurrentBatch(uint256 _currentBatch) public onlyOwner{
        currentBatch =_currentBatch;
        currentStartTime = block.timestamp;
    }

    function withdrawERC20(address token,address recipient,uint256 amount) public onlyOwner{
        IERC20(token).safeTransfer(recipient,amount);
    }
    
    function withdrawETH(address recipient,uint256 balance) external onlyOwner {
        require(recipient != address(0),"from the zero address");
        require(address(this).balance > balance,"invalid balance.");
        (bool success, ) = payable(recipient).call{
            value: balance
        }("");
        require(success, "TRANSFER_FAILED");
    }

    function setBaseURI(string memory baseURI_) public onlyOwner{
        _baseURI = baseURI_;
    }

    function setBlindURI(string memory blindURI_) public onlyOwner{
        _blindURI = blindURI_;
    }

    function airdrop(address[] calldata userAddressLs,uint256 quantity) public onlyOwner{
        uint256 total = totalSupply().add((quantity.mul(userAddressLs.length)));
        require(total <= _maxSupply,"Insufficient quantity");
        for (uint256 i; i < userAddressLs.length; i++) {
            _safeMint(userAddressLs[i],quantity,0,1);
        }
    }

    function setLogicAddress(address _logicAddress) public onlyOwner {
        logicAddress = _logicAddress;
    }

    /**
     * @dev Returns the starting token ID.
     * To change the starting token ID, please override this function.
     */
    function _startTokenId() internal view virtual returns (uint256) {
        return 0;
    }

    /**
     * @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) {
        unchecked {
            return _currentIndex - _startTokenId();
        }
    }

    function maxSupply() public view returns (uint256){
        return _maxSupply;
    }

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

    /**
     * @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 auxiliary 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 auxiliary 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();
        return bytes(_baseURI).length > 0 ? string(abi.encodePacked(_baseURI, _toString(tokenId))) : _blindURI;
    }

    /**
     * @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 (_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,uint256 price,uint256 tag) internal {
        _safeMint(to, quantity, '',price,tag);
    }
    
    /**
     * @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 for each mint.
     */
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data,
        uint256 price,
        uint256 tag
    ) internal {
        _mint(to, quantity,price,tag);

        unchecked {
            if (to.code.length != 0) {
                uint256 end = _currentIndex;
                uint256 index = end - quantity;
                do {
                    if (!_checkContractOnERC721Received(address(0), to, index++, _data)) {
                        revert TransferToNonERC721ReceiverImplementer();
                    }
                } while (index < end);
                // Reentrancy protection.
                if (_currentIndex != end) revert();
            }
        }
    }

    /**
     * @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 for each mint.
     */
    function _mint(address to, uint256 quantity,uint256 price,uint256 tag) 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 offset;
            do {
                uint256 mintIndex = startTokenId + offset++;
                nftInfoLs[mintIndex] = NFTInfo(mintIndex,currentBatch,price);
                emit Transfer(address(0), to, mintIndex);
                emit NFTMintEvent(mintIndex,tag,currentBatch, price,to);
            } while (offset < quantity);

            _currentIndex = startTokenId + quantity;
        }
        _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)
        }
    }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"__name","type":"string"},{"internalType":"string","name":"__symbol","type":"string"},{"internalType":"uint256","name":"__maxSupply","type":"uint256"},{"internalType":"address","name":"_verifyAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","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":"uint256","name":"tokenId","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"tag","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"batch","type":"uint256"},{"indexed":false,"internalType":"uint256","name":"price","type":"uint256"},{"indexed":false,"internalType":"address","name":"owner","type":"address"}],"name":"NFTMintEvent","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"DOMAIN_NAME","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DOMAIN_SEPARATOR","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DOMAIN_TYPEHASH","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"DOMAIN_VERSION","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address[]","name":"userAddressLs","type":"address[]"},{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"airdrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentBatch","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"currentStartTime","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getChainId","outputs":[{"internalType":"uint256","name":"id","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"logicAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"sender","type":"address"},{"internalType":"uint256","name":"mintCount","type":"uint256"},{"internalType":"uint256","name":"mintPrice","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"uint256","name":"_r","type":"uint256"},{"internalType":"uint256","name":"_s","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"nftInfoLs","outputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"batch","type":"uint256"},{"internalType":"uint256","name":"price","type":"uint256"}],"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":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"baseURI_","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"blindURI_","type":"string"}],"name":"setBlindURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_currentBatch","type":"uint256"}],"name":"setCurrentBatch","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_logicAddress","type":"address"}],"name":"setLogicAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_addr","type":"address"}],"name":"setVerifyAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"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":"","type":"address"}],"name":"userMintTotal","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"verifyAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"token","type":"address"},{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"amount","type":"uint256"}],"name":"withdrawERC20","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"},{"internalType":"uint256","name":"balance","type":"uint256"}],"name":"withdrawETH","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

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

000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000015b3000000000000000000000000c4d363ad775a6bb175af5660b46ef2e3601e73ef000000000000000000000000000000000000000000000000000000000000000b50656761737573204e4654000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000b50656761737573204e4654000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : __name (string): Pegasus NFT
Arg [1] : __symbol (string): Pegasus NFT
Arg [2] : __maxSupply (uint256): 5555
Arg [3] : _verifyAddress (address): 0xC4d363aD775a6bb175aF5660B46Ef2e3601E73EF

-----Encoded View---------------
8 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 00000000000000000000000000000000000000000000000000000000000015b3
Arg [3] : 000000000000000000000000c4d363ad775a6bb175af5660b46ef2e3601e73ef
Arg [4] : 000000000000000000000000000000000000000000000000000000000000000b
Arg [5] : 50656761737573204e4654000000000000000000000000000000000000000000
Arg [6] : 000000000000000000000000000000000000000000000000000000000000000b
Arg [7] : 50656761737573204e4654000000000000000000000000000000000000000000

Deployed Bytecode Sourcemap

32063:31937:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40131:615;;;;;;;;;;-1:-1:-1;40131:615:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;40131:615:0;;;;;;;;45167:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;46795:204::-;;;;;;;;;;-1:-1:-1;46795:204:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1714:32:1;;;1696:51;;1684:2;1669:18;46795:204:0;1550:203:1;46314:415:0;;;;;;;;;;-1:-1:-1;46314:415:0;;;;;:::i;:::-;;:::i;:::-;;34802:46;;;;;;;;;;-1:-1:-1;34802:46:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;2532:25:1;;;2520:2;2505:18;34802:46:0;2386:177:1;39412:155:0;;;;;;;;;;-1:-1:-1;39517:13:0;;39412:155;;20992:251;;;;;;;;;;;;21051:185;;-1:-1:-1;;;21051:185:0;;;8421:28:1;-1:-1:-1;;;8465:12:1;;;8458:36;-1:-1:-1;;;8510:12:1;;;8503:39;-1:-1:-1;;;8558:12:1;;;8551:40;8621:27;8607:12;;;8600:49;-1:-1:-1;;;8665:12:1;;;8658:25;8699:12;;21051:185:0;;;;;;;;;;;;21033:210;;;;;;20992:251;;47681:170;;;;;;;;;;-1:-1:-1;47681:170:0;;;;;:::i;:::-;;:::i;21467:152::-;;;;;;;;;;-1:-1:-1;21592:9:0;21467:152;;21388:31;;;;;;;;;;;;;;;;47922:185;;;;;;;;;;-1:-1:-1;47922:185:0;;;;;:::i;:::-;;:::i;37564:150::-;;;;;;;;;;-1:-1:-1;37564:150:0;;;;;:::i;:::-;;:::i;37726:363::-;;;;;;;;;;-1:-1:-1;37726:363:0;;;;;:::i;:::-;;:::i;38097:98::-;;;;;;;;;;-1:-1:-1;38097:98:0;;;;;:::i;:::-;;:::i;34857:44::-;;;;;;;;;;-1:-1:-1;34857:44:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4510:25:1;;;4566:2;4551:18;;4544:34;;;;4594:18;;;4587:34;4498:2;4483:18;34857:44:0;4308:319:1;44956:144:0;;;;;;;;;;-1:-1:-1;44956:144:0;;;;;:::i;:::-;;:::i;21426:28::-;;;;;;;;;;-1:-1:-1;21426:28:0;;;;-1:-1:-1;;;;;21426:28:0;;;40810:234;;;;;;;;;;-1:-1:-1;40810:234:0;;;;;:::i;:::-;;:::i;20095:103::-;;;;;;;;;;;;;:::i;34593:31::-;;;;;;;;;;;;;;;;21258:61;;;;;;;;;;;;21296:23;21258:61;;19444:87;;;;;;;;;;-1:-1:-1;19490:7:0;19517:6;-1:-1:-1;;;;;19517:6:0;19444:87;;37401:155;;;;;;;;;;-1:-1:-1;37401:155:0;;;;;:::i;:::-;;:::i;45336:104::-;;;;;;;;;;;;;:::i;34669:27::-;;;;;;;;;;-1:-1:-1;34669:27:0;;;;-1:-1:-1;;;;;34669:27:0;;;47071:308;;;;;;;;;;-1:-1:-1;47071:308:0;;;;;:::i;:::-;;:::i;34631:31::-;;;;;;;;;;;;;;;;21326:55;;;;;;;;;;;;21367:14;21326:55;;37292:97;;;;;;;;;;-1:-1:-1;37292:97:0;;;;;:::i;:::-;;:::i;48178:396::-;;;;;;;;;;-1:-1:-1;48178:396:0;;;;;:::i;:::-;;:::i;38203:102::-;;;;;;;;;;-1:-1:-1;38203:102:0;;;;;:::i;:::-;;:::i;38313:361::-;;;;;;;;;;-1:-1:-1;38313:361:0;;;;;:::i;:::-;;:::i;45511:279::-;;;;;;;;;;-1:-1:-1;45511:279:0;;;;;:::i;:::-;;:::i;39575:86::-;;;;;;;;;;-1:-1:-1;39643:10:0;;39575:86;;36325:955;;;;;;:::i;:::-;;:::i;47450:164::-;;;;;;;;;;-1:-1:-1;47450:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;47571:25:0;;;47547:4;47571:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;47450:164;20353:201;;;;;;;;;;-1:-1:-1;20353:201:0;;;;;:::i;:::-;;:::i;38682:112::-;;;;;;;;;;-1:-1:-1;38682:112:0;;;;;:::i;:::-;;:::i;40131:615::-;40216:4;-1:-1:-1;;;;;;;;;40516:25:0;;;;:102;;-1:-1:-1;;;;;;;;;;40593:25:0;;;40516:102;:179;;;-1:-1:-1;;;;;;;;;;40670:25:0;;;40516:179;40496:199;40131:615;-1:-1:-1;;40131:615:0:o;45167:100::-;45221:13;45254:5;45247:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45167:100;:::o;46795:204::-;46863:7;46888:16;46896:7;46888;:16::i;:::-;46883:64;;46913:34;;-1:-1:-1;;;46913:34:0;;;;;;;;;;;46883:64;-1:-1:-1;46967:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;46967:24:0;;46795:204::o;46314:415::-;46387:13;46419:27;46438:7;46419:18;:27::i;:::-;46387:61;-1:-1:-1;61913:10:0;-1:-1:-1;;;;;46465:28:0;;;46461:175;;46513:44;46530:5;61913:10;47450:164;:::i;46513:44::-;46508:128;;46585:35;;-1:-1:-1;;;46585:35:0;;;;;;;;;;;46508:128;46648:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;46648:29:0;-1:-1:-1;;;;;46648:29:0;;;;;;;;;46693:28;;46648:24;;46693:28;;;;;;;46376:353;46314:415;;:::o;47681:170::-;47815:28;47825:4;47831:2;47835:7;47815:9;:28::i;:::-;47681:170;;;:::o;47922:185::-;48060:39;48077:4;48083:2;48087:7;48060:39;;;;;;;;;;;;:16;:39::i;37564:150::-;19490:7;19517:6;-1:-1:-1;;;;;19517:6:0;61913:10;19664:23;19656:68;;;;-1:-1:-1;;;19656:68:0;;;;;;;:::i;:::-;;;;;;;;;37662:44:::1;-1:-1:-1::0;;;;;37662:26:0;::::1;37689:9:::0;37699:6;37662:26:::1;:44::i;37726:363::-:0;19490:7;19517:6;-1:-1:-1;;;;;19517:6:0;61913:10;19664:23;19656:68;;;;-1:-1:-1;;;19656:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;37820:23:0;::::1;37812:56;;;::::0;-1:-1:-1;;;37812:56:0;;9285:2:1;37812:56:0::1;::::0;::::1;9267:21:1::0;9324:2;9304:18;;;9297:30;-1:-1:-1;;;9343:18:1;;;9336:51;9404:18;;37812:56:0::1;9083:345:1::0;37812:56:0::1;37911:7;37887:21;:31;37879:59;;;::::0;-1:-1:-1;;;37879:59:0;;9635:2:1;37879:59:0::1;::::0;::::1;9617:21:1::0;9674:2;9654:18;;;9647:30;-1:-1:-1;;;9693:18:1;;;9686:46;9749:18;;37879:59:0::1;9433:340:1::0;37879:59:0::1;37950:12;37976:9;-1:-1:-1::0;;;;;37968:23:0::1;38013:7;37968:67;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;37949:86;;;38054:7;38046:35;;;::::0;-1:-1:-1;;;38046:35:0;;10190:2:1;38046:35:0::1;::::0;::::1;10172:21:1::0;10229:2;10209:18;;;10202:30;-1:-1:-1;;;10248:18:1;;;10241:45;10303:18;;38046:35:0::1;9988:339:1::0;38097:98:0;19490:7;19517:6;-1:-1:-1;;;;;19517:6:0;61913:10;19664:23;19656:68;;;;-1:-1:-1;;;19656:68:0;;;;;;;:::i;:::-;38168:19;;::::1;::::0;:8:::1;::::0;:19:::1;::::0;::::1;::::0;::::1;:::i;:::-;;38097:98:::0;:::o;44956:144::-;45020:7;45063:27;45082:7;45063:18;:27::i;40810:234::-;40874:7;40916:5;40894:70;;40936:28;;-1:-1:-1;;;40936:28:0;;;;;;;;;;;40894:70;-1:-1:-1;;;;;;40982:25:0;;;;;:18;:25;;;;;;32304:13;40982:54;;40810:234::o;20095:103::-;19490:7;19517:6;-1:-1:-1;;;;;19517:6:0;61913:10;19664:23;19656:68;;;;-1:-1:-1;;;19656:68:0;;;;;;;:::i;:::-;20160:30:::1;20187:1;20160:18;:30::i;:::-;20095:103::o:0;37401:155::-;19490:7;19517:6;-1:-1:-1;;;;;19517:6:0;61913:10;19664:23;19656:68;;;;-1:-1:-1;;;19656:68:0;;;;;;;:::i;:::-;37476:12:::1;:27:::0;37533:15:::1;37514:16;:34:::0;37401:155::o;45336:104::-;45392:13;45425:7;45418:14;;;;;:::i;47071:308::-;-1:-1:-1;;;;;47170:31:0;;61913:10;47170:31;47166:61;;;47210:17;;-1:-1:-1;;;47210:17:0;;;;;;;;;;;47166:61;61913:10;47240:39;;;;:18;:39;;;;;;;;-1:-1:-1;;;;;47240:49:0;;;;;;;;;;;;:60;;-1:-1:-1;;47240:60:0;;;;;;;;;;47316:55;;540:41:1;;;47240:49:0;;61913:10;47316:55;;513:18:1;47316:55:0;;;;;;;47071:308;;:::o;37292:97::-;19490:7;19517:6;-1:-1:-1;;;;;19517:6:0;61913:10;19664:23;19656:68;;;;-1:-1:-1;;;19656:68:0;;;;;;;:::i;:::-;37360:13:::1;:21:::0;;-1:-1:-1;;;;;;37360:21:0::1;-1:-1:-1::0;;;;;37360:21:0;;;::::1;::::0;;;::::1;::::0;;37292:97::o;48178:396::-;48345:28;48355:4;48361:2;48365:7;48345:9;:28::i;:::-;-1:-1:-1;;;;;48388:14:0;;;:19;48384:183;;48427:56;48458:4;48464:2;48468:7;48477:5;48427:30;:56::i;:::-;48422:145;;48511:40;;-1:-1:-1;;;48511:40:0;;;;;;;;;;;48422:145;48178:396;;;;:::o;38203:102::-;19490:7;19517:6;-1:-1:-1;;;;;19517:6:0;61913:10;19664:23;19656:68;;;;-1:-1:-1;;;19656:68:0;;;;;;;:::i;:::-;38276:21;;::::1;::::0;:9:::1;::::0;:21:::1;::::0;::::1;::::0;::::1;:::i;38313:361::-:0;19490:7;19517:6;-1:-1:-1;;;;;19517:6:0;61913:10;19664:23;19656:68;;;;-1:-1:-1;;;19656:68:0;;;;;;;:::i;:::-;38408:13:::1;38424:55;38443:34;:8:::0;38456:13;38443:12:::1;:34::i;:::-;39517:13:::0;;38424::::1;:17:::0;::::1;:55::i;:::-;38408:71;;38507:10;;38498:5;:19;;38490:52;;;::::0;-1:-1:-1;;;38490:52:0;;10534:2:1;38490:52:0::1;::::0;::::1;10516:21:1::0;10573:2;10553:18;;;10546:30;-1:-1:-1;;;10592:18:1;;;10585:51;10653:18;;38490:52:0::1;10332:345:1::0;38490:52:0::1;38558:9;38553:114;38569:24:::0;;::::1;38553:114;;;38615:40;38625:13;;38639:1;38625:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;:::i;:::-;38642:8;38651:1;38653;38615:9;:40::i;:::-;38595:3:::0;::::1;::::0;::::1;:::i;:::-;;;;38553:114;;;;38397:277;38313:361:::0;;;:::o;45511:279::-;45584:13;45615:16;45623:7;45615;:16::i;:::-;45610:59;;45640:29;;-1:-1:-1;;;45640:29:0;;;;;;;;;;;45610:59;45712:1;45693:8;45687:22;;;;;:::i;:::-;;;:26;:95;;45773:9;45687:95;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;45740:8;45750:18;45760:7;45750:9;:18::i;:::-;45723:46;;;;;;;;;:::i;:::-;;;;;;;;;;;;;45680:102;45511:279;-1:-1:-1;;45511:279:0:o;36325:955::-;36454:46;36465:6;36472:9;36482;36492:1;36494:2;36497;36454:10;:46::i;:::-;36446:71;;;;-1:-1:-1;;;36446:71:0;;12783:2:1;36446:71:0;;;12765:21:1;12822:2;12802:18;;;12795:30;-1:-1:-1;;;12841:18:1;;;12834:43;12894:18;;36446:71:0;12581:337:1;36446:71:0;36536:10;36548:9;36536:21;36528:44;;;;-1:-1:-1;;;36528:44:0;;13125:2:1;36528:44:0;;;13107:21:1;13164:2;13144:18;;;13137:30;-1:-1:-1;;;13183:18:1;;;13176:41;13234:18;;36528:44:0;12923:335:1;36528:44:0;36592:10;-1:-1:-1;;;;;36592:18:0;;;36584:45;;;;-1:-1:-1;;;36584:45:0;;13465:2:1;36584:45:0;;;13447:21:1;13504:2;13484:18;;;13477:30;-1:-1:-1;;;13523:18:1;;;13516:45;13578:18;;36584:45:0;13263:339:1;36584:45:0;36660:9;36649;:20;36641:50;;;;-1:-1:-1;;;36641:50:0;;13809:2:1;36641:50:0;;;13791:21:1;13848:2;13828:18;;;13821:30;-1:-1:-1;;;13867:18:1;;;13860:48;13925:18;;36641:50:0;13607:342:1;36641:50:0;36726:1;36711:12;;:16;36703:40;;;;-1:-1:-1;;;36703:40:0;;14156:2:1;36703:40:0;;;14138:21:1;14195:2;14175:18;;;14168:30;-1:-1:-1;;;14214:18:1;;;14207:42;14266:18;;36703:40:0;13954:336:1;36703:40:0;36774:1;36762:9;:13;36754:44;;;;-1:-1:-1;;;36754:44:0;;14497:2:1;36754:44:0;;;14479:21:1;14536:2;14516:18;;;14509:30;-1:-1:-1;;;14555:18:1;;;14548:48;14613:18;;36754:44:0;14295:342:1;36754:44:0;36847:10;;36817:28;36835:9;36817:13;39517;;;39412:155;36817:28;:40;;36809:81;;;;-1:-1:-1;;;36809:81:0;;14844:2:1;36809:81:0;;;14826:21:1;14883:2;14863:18;;;14856:30;14922:31;14902:18;;;14895:59;14971:18;;36809:81:0;14642:353:1;36809:81:0;36918:12;;36940;;36953:16;;36909:82;;-1:-1:-1;;;36909:82:0;;;;;15231:25:1;;;;15272:18;;;15265:34;36970:10:0;15315:18:1;;;15308:60;15384:18;;;15377:34;;;-1:-1:-1;;;;;36918:12:0;;;;36909:30;;15203:19:1;;36909:82:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;36901:99;;;;-1:-1:-1;;;36901:99:0;;15874:2:1;36901:99:0;;;15856:21:1;15913:1;15893:18;;;15886:29;-1:-1:-1;;;15931:18:1;;;15924:35;15976:18;;36901:99:0;15672:328:1;36901:99:0;37011:13;37027:24;:9;37041;37027:13;:24::i;:::-;37011:40;;37062:39;37072:10;37083:9;37093:5;37099:1;37062:9;:39::i;:::-;37154:10;37140:25;;;;:13;:25;;;;;;:40;;37170:9;37140:29;:40::i;:::-;37126:10;37112:25;;;;:13;:25;;;;;;;:68;;;;37200:12;;37238;;37191:81;;-1:-1:-1;;;37191:81:0;;;;;16207:25:1;;;;16248:18;;;16241:60;;;;16317:18;;;16310:34;;;-1:-1:-1;;;;;37200:12:0;;37191:46;;16180:18:1;;37191:81:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;36435:845;36325:955;;;;;;:::o;20353:201::-;19490:7;19517:6;-1:-1:-1;;;;;19517:6:0;61913:10;19664:23;19656:68;;;;-1:-1:-1;;;19656:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;20442:22:0;::::1;20434:73;;;::::0;-1:-1:-1;;;20434:73:0;;16557:2:1;20434:73:0::1;::::0;::::1;16539:21:1::0;16596:2;16576:18;;;16569:30;16635:34;16615:18;;;16608:62;-1:-1:-1;;;16686:18:1;;;16679:36;16732:19;;20434:73:0::1;16355:402:1::0;20434:73:0::1;20518:28;20537:8;20518:18;:28::i;:::-;20353:201:::0;:::o;38682:112::-;19490:7;19517:6;-1:-1:-1;;;;;19517:6:0;61913:10;19664:23;19656:68;;;;-1:-1:-1;;;19656:68:0;;;;;;;:::i;:::-;38758:12:::1;:28:::0;;-1:-1:-1;;;;;;38758:28:0::1;-1:-1:-1::0;;;;;38758:28:0;;;::::1;::::0;;;::::1;::::0;;38682:112::o;48829:273::-;48886:4;48976:13;;48966:7;:23;48923:152;;;;-1:-1:-1;;49027:26:0;;;;:17;:26;;;;;;-1:-1:-1;;;49027:43:0;:48;;48829:273::o;42471:1129::-;42538:7;42573;42675:13;;42668:4;:20;42664:869;;;42713:14;42730:23;;;:17;:23;;;;;;-1:-1:-1;;;42819:23:0;;42815:699;;43338:113;43345:11;43338:113;;-1:-1:-1;;;43416:6:0;43398:25;;;;:17;:25;;;;;;43338:113;;;43484:6;42471:1129;-1:-1:-1;;;42471:1129:0:o;42815:699::-;42690:843;42664:869;43561:31;;-1:-1:-1;;;43561:31:0;;;;;;;;;;;52818:2654;52933:27;52963;52982:7;52963:18;:27::i;:::-;52933:57;;53048:4;-1:-1:-1;;;;;53007:45:0;53023:19;-1:-1:-1;;;;;53007:45:0;;53003:86;;53061:28;;-1:-1:-1;;;53061:28:0;;;;;;;;;;;53003:86;53102:23;53128:24;;;:15;:24;;;;;;-1:-1:-1;;;;;53128:24:0;;;;53102:23;53191:27;;61913:10;53191:27;;:87;;-1:-1:-1;53235:43:0;53252:4;61913:10;47450:164;:::i;53235:43::-;53191:142;;;-1:-1:-1;;;;;;53295:38:0;;61913:10;53295:38;53191:142;53165:169;;53352:17;53347:66;;53378:35;;-1:-1:-1;;;53378:35:0;;;;;;;;;;;53347:66;53446:2;53424:62;;53463:23;;-1:-1:-1;;;53463:23:0;;;;;;;;;;;53424:62;53630:15;53612:39;53608:103;;53675:24;;;;:15;:24;;;;;53668:31;;-1:-1:-1;;;;;;53668:31:0;;;53608:103;-1:-1:-1;;;;;54078:24:0;;;;;;;:18;:24;;;;;;;;54076:26;;-1:-1:-1;;54076:26:0;;;54147:22;;;;;;;;54145:24;;-1:-1:-1;54145:24:0;;;54440:26;;;:17;:26;;;-1:-1:-1;;;54528:15:0;32958:3;54528:41;54486:84;;:128;;54440:174;;;54734:46;;54730:626;;54838:1;54828:11;;54806:19;54961:30;;;:17;:30;;;;;;54957:384;;55099:13;;55084:11;:28;55080:242;;55246:30;;;;:17;:30;;;;;:52;;;55080:242;54787:569;54730:626;55403:7;55399:2;-1:-1:-1;;;;;55384:27:0;55393:4;-1:-1:-1;;;;;55384:27:0;;;;;;;;;;;52922:2550;;;52818:2654;;;:::o;28219:177::-;28329:58;;;-1:-1:-1;;;;;16954:32:1;;28329:58:0;;;16936:51:1;17003:18;;;;16996:34;;;28329:58:0;;;;;;;;;;16909:18:1;;;;28329:58:0;;;;;;;;-1:-1:-1;;;;;28329:58:0;-1:-1:-1;;;28329:58:0;;;28302:86;;28322:5;;28302:19;:86::i;20714:191::-;20788:16;20807:6;;-1:-1:-1;;;;;20824:17:0;;;-1:-1:-1;;;;;;20824:17:0;;;;;;20857:40;;20807:6;;;;;;;20857:40;;20788:16;20857:40;20777:128;20714:191;:::o;59295:716::-;59479:88;;-1:-1:-1;;;59479:88:0;;59458:4;;-1:-1:-1;;;;;59479:45:0;;;;;:88;;61913:10;;59546:4;;59552:7;;59561:5;;59479:88;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59479:88:0;;;;;;;;-1:-1:-1;;59479:88:0;;;;;;;;;;;;:::i;:::-;;;59475:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;59762:13:0;;59758:235;;59808:40;;-1:-1:-1;;;59808:40:0;;;;;;;;;;;59758:235;59951:6;59945:13;59936:6;59932:2;59928:15;59921:38;59475:529;-1:-1:-1;;;;;;59638:64:0;-1:-1:-1;;;59638:64:0;;-1:-1:-1;59475:529:0;59295:716;;;;;;:::o;3509:98::-;3567:7;3594:5;3598:1;3594;:5;:::i;2771:98::-;2829:7;2856:5;2860:1;2856;:5;:::i;49186:140::-;49281:37;49291:2;49295:8;49281:37;;;;;;;;;;;;49308:5;49314:3;49281:9;:37::i;62037:1960::-;62506:4;62500:11;;62513:3;62496:21;;62591:17;;;;63287:11;;;63166:5;63419:2;63433;63423:13;;63415:22;63287:11;63402:36;63474:2;63464:13;;63058:697;63493:4;63058:697;;;63684:1;63679:3;63675:11;63668:18;;63735:2;63729:4;63725:13;63721:2;63717:22;63712:3;63704:36;63588:2;63578:13;;63058:697;;;-1:-1:-1;63785:13:0;;;-1:-1:-1;;63900:12:0;;;63960:19;;;63900:12;62037:1960;-1:-1:-1;62037:1960:0:o;35725:592::-;36017:76;;35849:4;;35885:2;;35919;;35849:4;;36017:76;;;;18320:34:1;18308:47;;18385:26;18380:2;18371:12;;18364:48;18437:2;18428:12;;18106:340;36017:76:0;;;;-1:-1:-1;;36017:76:0;;;;;;;;;36007:87;;36017:76;36007:87;;;;35980:172;;;18682:25:1;-1:-1:-1;;;;;18743:32:1;;18723:18;;;18716:60;18792:18;;;18785:34;;;18835:18;;;18828:34;;;18654:19;;35980:172:0;;;-1:-1:-1;;35980:172:0;;;;;;;;;35956:207;;35980:172;35956:207;;;;36205:13;;35956:207;;-1:-1:-1;;;;;;36205:13:0;36177:24;35956:207;36195:1;36197;36199;36177:12;:24::i;:::-;-1:-1:-1;;;;;36177:41:0;;36174:136;;;36241:4;36234:11;;;;;;;36174:136;36293:5;36286:12;;;;;35725:592;;;;;;;;;:::o;3908:98::-;3966:7;3993:5;3997:1;3993;:5;:::i;30524:761::-;30948:23;30974:69;31002:4;30974:69;;;;;;;;;;;;;;;;;30982:5;-1:-1:-1;;;;;30974:27:0;;;:69;;;;;:::i;:::-;31058:17;;30948:95;;-1:-1:-1;31058:21:0;31054:224;;31200:10;31189:30;;;;;;;;;;;;:::i;:::-;31181:85;;;;-1:-1:-1;;;31181:85:0;;19297:2:1;31181:85:0;;;19279:21:1;19336:2;19316:18;;;19309:30;19375:34;19355:18;;;19348:62;-1:-1:-1;;;19426:18:1;;;19419:40;19476:19;;31181:85:0;19095:406:1;49717:737:0;49886:29;49892:2;49896:8;49905:5;49911:3;49886:5;:29::i;:::-;-1:-1:-1;;;;;49957:14:0;;;:19;49953:483;;50011:13;;50059:14;;;50092:233;50123:62;50162:1;50166:2;50170:7;;;;;;50179:5;50123:30;:62::i;:::-;50118:167;;50221:40;;-1:-1:-1;;;50221:40:0;;;;;;;;;;;50118:167;50320:3;50312:5;:11;50092:233;;50407:3;50390:13;;:20;50386:34;;50412:8;;;50386:34;49978:458;;49717:737;;;;;:::o;21788:441::-;22010:16;;21981:52;;-1:-1:-1;;;21981:52:0;;;19764:27:1;19807:11;;;19800:27;;;;19843:12;;;19836:28;;;21923:7:0;;;;19880:12:1;;21981:52:0;;;-1:-1:-1;;21981:52:0;;;;;;;;;21971:63;;21981:52;21971:63;;;;22045:17;22065:26;;;;;;;;;20130:25:1;;;20203:4;20191:17;;20171:18;;;20164:45;;;;20225:18;;;20218:34;;;20268:18;;;20261:34;;;21971:63:0;;-1:-1:-1;22045:17:0;22065:26;;20102:19:1;;22065:26:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;22065:26:0;;-1:-1:-1;;22065:26:0;;;-1:-1:-1;;;;;;;22155:23:0;;22147:47;;;;-1:-1:-1;;;22147:47:0;;20508:2:1;22147:47:0;;;20490:21:1;20547:2;20527:18;;;20520:30;-1:-1:-1;;;20566:18:1;;;20559:41;20617:18;;22147:47:0;20306:335:1;25764:196:0;25867:12;25899:53;25922:6;25930:4;25936:1;25939:12;25899:22;:53::i;50727:1837::-;50841:13;;50887:2;50865:58;;50904:19;;-1:-1:-1;;;50904:19:0;;;;;;;;;;;50865:58;50938:13;50934:44;;50960:18;;-1:-1:-1;;;50960:18:0;;;;;;;;;;;50934:44;-1:-1:-1;;;;;51527:22:0;;;;;;:18;:22;;;;32441:2;51527:22;;;:70;;51565:31;51553:44;;51527:70;;;51840:31;;;:17;:31;;;;;51933:15;32958:3;51933:41;51891:84;;-1:-1:-1;52011:13:0;;33217:3;51996:56;51891:162;51840:213;;52099:320;52206:37;;;;;;;;52141:23;;;52206:37;;;52224:12;;52206:37;;;;;;;;;;;;;52121:17;52183:20;;;:9;:20;;;;;;:60;;;;;;52156:8;52183:60;;;;;;;;;;;;;;;;;52267:35;;52156:8;;;;;52141:23;;;-1:-1:-1;;;;;52267:35:0;;;;;52121:17;;52267:35;52353:12;;52326:50;;;20905:25:1;;;20961:2;20946:18;;20939:34;;;20989:18;;;20982:34;;;;21047:2;21032:18;;21025:34;;;-1:-1:-1;;;;;21096:32:1;;21090:3;21075:19;;21068:61;52326:50:0;;;;;;20892:3:1;52326:50:0;;;52102:290;52409:8;52400:6;:17;52099:320;;-1:-1:-1;52451:23:0;;;52435:13;:39;52496:60;48178:396;27141:979;27271:12;23213:20;;27296:60;;;;-1:-1:-1;;;27296:60:0;;21342:2:1;27296:60:0;;;21324:21:1;21381:2;21361:18;;;21354:30;21420:31;21400:18;;;21393:59;21469:18;;27296:60:0;21140:353:1;27296:60:0;27430:12;27444:23;27471:6;-1:-1:-1;;;;;27471:11:0;27491:8;27502:4;27471:36;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;27429:78;;;;27522:7;27518:595;;;27553:10;-1:-1:-1;27546:17:0;;-1:-1:-1;27546:17:0;27518:595;27667:17;;:21;27663:439;;27930:10;27924:17;27991:15;27978:10;27974:2;27970:19;27963:44;27663:439;28073:12;28066:20;;-1:-1:-1;;;28066:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:131:1;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:258::-;664:1;674:113;688:6;685:1;682:13;674:113;;;764:11;;;758:18;745:11;;;738:39;710:2;703:10;674:113;;;805:6;802:1;799:13;796:48;;;-1:-1:-1;;840:1:1;822:16;;815:27;592:258::o;855:269::-;908:3;946:5;940:12;973:6;968:3;961:19;989:63;1045:6;1038:4;1033:3;1029:14;1022:4;1015:5;1011:16;989:63;:::i;:::-;1106:2;1085:15;-1:-1:-1;;1081:29:1;1072:39;;;;1113:4;1068:50;;855:269;-1:-1:-1;;855:269:1:o;1129:231::-;1278:2;1267:9;1260:21;1241:4;1298:56;1350:2;1339:9;1335:18;1327:6;1298:56;:::i;1365:180::-;1424:6;1477:2;1465:9;1456:7;1452:23;1448:32;1445:52;;;1493:1;1490;1483:12;1445:52;-1:-1:-1;1516:23:1;;1365:180;-1:-1:-1;1365:180:1:o;1758:173::-;1826:20;;-1:-1:-1;;;;;1875:31:1;;1865:42;;1855:70;;1921:1;1918;1911:12;1855:70;1758:173;;;:::o;1936:254::-;2004:6;2012;2065:2;2053:9;2044:7;2040:23;2036:32;2033:52;;;2081:1;2078;2071:12;2033:52;2104:29;2123:9;2104:29;:::i;:::-;2094:39;2180:2;2165:18;;;;2152:32;;-1:-1:-1;;;1936:254:1:o;2195:186::-;2254:6;2307:2;2295:9;2286:7;2282:23;2278:32;2275:52;;;2323:1;2320;2313:12;2275:52;2346:29;2365:9;2346:29;:::i;2750:328::-;2827:6;2835;2843;2896:2;2884:9;2875:7;2871:23;2867:32;2864:52;;;2912:1;2909;2902:12;2864:52;2935:29;2954:9;2935:29;:::i;:::-;2925:39;;2983:38;3017:2;3006:9;3002:18;2983:38;:::i;:::-;2973:48;;3068:2;3057:9;3053:18;3040:32;3030:42;;2750:328;;;;;:::o;3083:127::-;3144:10;3139:3;3135:20;3132:1;3125:31;3175:4;3172:1;3165:15;3199:4;3196:1;3189:15;3215:632;3280:5;3310:18;3351:2;3343:6;3340:14;3337:40;;;3357:18;;:::i;:::-;3432:2;3426:9;3400:2;3486:15;;-1:-1:-1;;3482:24:1;;;3508:2;3478:33;3474:42;3462:55;;;3532:18;;;3552:22;;;3529:46;3526:72;;;3578:18;;:::i;:::-;3618:10;3614:2;3607:22;3647:6;3638:15;;3677:6;3669;3662:22;3717:3;3708:6;3703:3;3699:16;3696:25;3693:45;;;3734:1;3731;3724:12;3693:45;3784:6;3779:3;3772:4;3764:6;3760:17;3747:44;3839:1;3832:4;3823:6;3815;3811:19;3807:30;3800:41;;;;3215:632;;;;;:::o;3852:451::-;3921:6;3974:2;3962:9;3953:7;3949:23;3945:32;3942:52;;;3990:1;3987;3980:12;3942:52;4030:9;4017:23;4063:18;4055:6;4052:30;4049:50;;;4095:1;4092;4085:12;4049:50;4118:22;;4171:4;4163:13;;4159:27;-1:-1:-1;4149:55:1;;4200:1;4197;4190:12;4149:55;4223:74;4289:7;4284:2;4271:16;4266:2;4262;4258:11;4223:74;:::i;4632:118::-;4718:5;4711:13;4704:21;4697:5;4694:32;4684:60;;4740:1;4737;4730:12;4755:315;4820:6;4828;4881:2;4869:9;4860:7;4856:23;4852:32;4849:52;;;4897:1;4894;4887:12;4849:52;4920:29;4939:9;4920:29;:::i;:::-;4910:39;;4999:2;4988:9;4984:18;4971:32;5012:28;5034:5;5012:28;:::i;:::-;5059:5;5049:15;;;4755:315;;;;;:::o;5075:667::-;5170:6;5178;5186;5194;5247:3;5235:9;5226:7;5222:23;5218:33;5215:53;;;5264:1;5261;5254:12;5215:53;5287:29;5306:9;5287:29;:::i;:::-;5277:39;;5335:38;5369:2;5358:9;5354:18;5335:38;:::i;:::-;5325:48;;5420:2;5409:9;5405:18;5392:32;5382:42;;5475:2;5464:9;5460:18;5447:32;5502:18;5494:6;5491:30;5488:50;;;5534:1;5531;5524:12;5488:50;5557:22;;5610:4;5602:13;;5598:27;-1:-1:-1;5588:55:1;;5639:1;5636;5629:12;5588:55;5662:74;5728:7;5723:2;5710:16;5705:2;5701;5697:11;5662:74;:::i;:::-;5652:84;;;5075:667;;;;;;;:::o;5747:689::-;5842:6;5850;5858;5911:2;5899:9;5890:7;5886:23;5882:32;5879:52;;;5927:1;5924;5917:12;5879:52;5967:9;5954:23;5996:18;6037:2;6029:6;6026:14;6023:34;;;6053:1;6050;6043:12;6023:34;6091:6;6080:9;6076:22;6066:32;;6136:7;6129:4;6125:2;6121:13;6117:27;6107:55;;6158:1;6155;6148:12;6107:55;6198:2;6185:16;6224:2;6216:6;6213:14;6210:34;;;6240:1;6237;6230:12;6210:34;6295:7;6288:4;6278:6;6275:1;6271:14;6267:2;6263:23;6259:34;6256:47;6253:67;;;6316:1;6313;6306:12;6253:67;6347:4;6339:13;;;;6371:6;;-1:-1:-1;6409:20:1;;;;6396:34;;5747:689;-1:-1:-1;;;;5747:689:1:o;6441:618::-;6543:6;6551;6559;6567;6575;6583;6636:3;6624:9;6615:7;6611:23;6607:33;6604:53;;;6653:1;6650;6643:12;6604:53;6676:29;6695:9;6676:29;:::i;:::-;6666:39;;6752:2;6741:9;6737:18;6724:32;6714:42;;6803:2;6792:9;6788:18;6775:32;6765:42;;6857:2;6846:9;6842:18;6829:32;6901:4;6894:5;6890:16;6883:5;6880:27;6870:55;;6921:1;6918;6911:12;6870:55;6441:618;;;;-1:-1:-1;6441:618:1;;6996:3;6981:19;;6968:33;;7048:3;7033:19;;;7020:33;;-1:-1:-1;6441:618:1;-1:-1:-1;;6441:618:1:o;7064:260::-;7132:6;7140;7193:2;7181:9;7172:7;7168:23;7164:32;7161:52;;;7209:1;7206;7199:12;7161:52;7232:29;7251:9;7232:29;:::i;:::-;7222:39;;7280:38;7314:2;7303:9;7299:18;7280:38;:::i;:::-;7270:48;;7064:260;;;;;:::o;7329:380::-;7408:1;7404:12;;;;7451;;;7472:61;;7526:4;7518:6;7514:17;7504:27;;7472:61;7579:2;7571:6;7568:14;7548:18;7545:38;7542:161;;;7625:10;7620:3;7616:20;7613:1;7606:31;7660:4;7657:1;7650:15;7688:4;7685:1;7678:15;7542:161;;7329:380;;;:::o;8722:356::-;8924:2;8906:21;;;8943:18;;;8936:30;9002:34;8997:2;8982:18;;8975:62;9069:2;9054:18;;8722:356::o;10682:127::-;10743:10;10738:3;10734:20;10731:1;10724:31;10774:4;10771:1;10764:15;10798:4;10795:1;10788:15;10814:127;10875:10;10870:3;10866:20;10863:1;10856:31;10906:4;10903:1;10896:15;10930:4;10927:1;10920:15;10946:135;10985:3;-1:-1:-1;;11006:17:1;;11003:43;;;11026:18;;:::i;:::-;-1:-1:-1;11073:1:1;11062:13;;10946:135::o;11212:185::-;11254:3;11292:5;11286:12;11307:52;11352:6;11347:3;11340:4;11333:5;11329:16;11307:52;:::i;:::-;11375:16;;;;;11212:185;-1:-1:-1;;11212:185:1:o;11402:1174::-;11578:3;11607:1;11640:6;11634:13;11670:3;11692:1;11720:9;11716:2;11712:18;11702:28;;11780:2;11769:9;11765:18;11802;11792:61;;11846:4;11838:6;11834:17;11824:27;;11792:61;11872:2;11920;11912:6;11909:14;11889:18;11886:38;11883:165;;;-1:-1:-1;;;11947:33:1;;12003:4;12000:1;11993:15;12033:4;11954:3;12021:17;11883:165;12064:18;12091:104;;;;12209:1;12204:320;;;;12057:467;;12091:104;-1:-1:-1;;12124:24:1;;12112:37;;12169:16;;;;-1:-1:-1;12091:104:1;;12204:320;11159:1;11152:14;;;11196:4;11183:18;;12299:1;12313:165;12327:6;12324:1;12321:13;12313:165;;;12405:14;;12392:11;;;12385:35;12448:16;;;;12342:10;;12313:165;;;12317:3;;12507:6;12502:3;12498:16;12491:23;;12057:467;;;;;;;12540:30;12566:3;12558:6;12540:30;:::i;:::-;12533:37;11402:1174;-1:-1:-1;;;;;11402:1174:1:o;15422:245::-;15489:6;15542:2;15530:9;15521:7;15517:23;15513:32;15510:52;;;15558:1;15555;15548:12;15510:52;15590:9;15584:16;15609:28;15631:5;15609:28;:::i;17041:500::-;-1:-1:-1;;;;;17310:15:1;;;17292:34;;17362:15;;17357:2;17342:18;;17335:43;17409:2;17394:18;;17387:34;;;17457:3;17452:2;17437:18;;17430:31;;;17235:4;;17478:57;;17515:19;;17507:6;17478:57;:::i;17546:249::-;17615:6;17668:2;17656:9;17647:7;17643:23;17639:32;17636:52;;;17684:1;17681;17674:12;17636:52;17716:9;17710:16;17735:30;17759:5;17735:30;:::i;17800:168::-;17840:7;17906:1;17902;17898:6;17894:14;17891:1;17888:21;17883:1;17876:9;17869:17;17865:45;17862:71;;;17913:18;;:::i;:::-;-1:-1:-1;17953:9:1;;17800:168::o;17973:128::-;18013:3;18044:1;18040:6;18037:1;18034:13;18031:39;;;18050:18;;:::i;:::-;-1:-1:-1;18086:9:1;;17973:128::o;18873:217::-;18913:1;18939;18929:132;;18983:10;18978:3;18974:20;18971:1;18964:31;19018:4;19015:1;19008:15;19046:4;19043:1;19036:15;18929:132;-1:-1:-1;19075:9:1;;18873:217::o;21498:274::-;21627:3;21665:6;21659:13;21681:53;21727:6;21722:3;21715:4;21707:6;21703:17;21681:53;:::i;:::-;21750:16;;;;;21498:274;-1:-1:-1;;21498:274:1:o

Swarm Source

ipfs://ebb1ac7aab222360c961d3e8e610a6dec0dedadbdc186cca269beedf5ed94a8b

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.

Tools & Services