Token

ERC-20: Alpha Azaza (Azaza)

ERC-721

Overview

Max Total Supply

349 Azaza

Holders

294

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xc4b79183fc5eda5aaa794e9324ccaa6035f7aabe

Filtered by Token Holder

0x1ee993a70bF0Bd859cA5Ab7a078a8ef31Aa1242b

bytenet.eth

Balance

1 Azaza

0x1ee993a70bf0bd859ca5ab7a078a8ef31aa1242b

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

Azaza

Compiler Version

v0.8.7+commit.e28d00a7

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-04
*/

// SPDX-License-Identifier: MIT

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

// File: @openzeppelin/contracts/token/ERC721/IERC721.sol
pragma solidity ^0.8.0;
/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables `approved` to manage the `tokenId` token.
     */
    event Approval(address indexed owner, address indexed approved, uint256 indexed tokenId);

    /**
     * @dev Emitted when `owner` enables or disables (`approved`) `operator` to manage all of its assets.
     */
    event ApprovalForAll(address indexed owner, address indexed operator, bool approved);

    /**
     * @dev Returns the number of tokens in ``owner``'s account.
     */
    function balanceOf(address owner) external view returns (uint256 balance);

    /**
     * @dev Returns the owner of the `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function ownerOf(uint256 tokenId) external view returns (address owner);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be have been allowed to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;
    
    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

    /**
     * @dev Gives permission to `to` to transfer `tokenId` token to another account.
     * The approval is cleared when the token is transferred.
     *
     * Only a single account can be approved at a time, so approving the zero address clears previous approvals.
     *
     * Requirements:
     *
     * - The caller must own the token or be an approved operator.
     * - `tokenId` must exist.
     *
     * Emits an {Approval} event.
     */
    function approve(address to, uint256 tokenId) external;

    /**
     * @dev Returns the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

    /**
     * @dev Approve or remove `operator` as an operator for the caller.
     * Operators can call {transferFrom} or {safeTransferFrom} for any token owned by the caller.
     *
     * Requirements:
     *
     * - The `operator` cannot be the caller.
     *
     * Emits an {ApprovalForAll} event.
     */
    function setApprovalForAll(address operator, bool _approved) external;

    /**
     * @dev Returns if the `operator` is allowed to manage all of the assets of `owner`.
     *
     * See {setApprovalForAll}
     */
    function isApprovedForAll(address owner, address operator) external view returns (bool);

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes calldata data
    ) external;
}


// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Enumerable.sol
pragma solidity ^0.8.0;
/**
 * @title ERC-721 Non-Fungible Token Standard, optional enumeration extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Enumerable is IERC721 {
    /**
     * @dev Returns the total amount of tokens stored by the contract.
     */
    function totalSupply() external view returns (uint256);

    /**
     * @dev Returns a token ID owned by `owner` at a given `index` of its token list.
     * Use along with {balanceOf} to enumerate all of ``owner``'s tokens.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) external view returns (uint256 tokenId);

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}


// File: @openzeppelin/contracts/utils/introspection/ERC165.sol
pragma solidity ^0.8.0;
/**
 * @dev Implementation of the {IERC165} interface.
 *
 * Contracts that want to implement ERC165 should inherit from this contract and override {supportsInterface} to check
 * for the additional interface id that will be supported. For example:
 *
 * ```solidity
 * function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
 *     return interfaceId == type(MyInterface).interfaceId || super.supportsInterface(interfaceId);
 * }
 * ```
 *
 * Alternatively, {ERC165Storage} provides an easier to use but more expensive implementation.
 */
abstract contract ERC165 is IERC165 {
    /**
     * @dev See {IERC165-supportsInterface}.
     */
    function supportsInterface(bytes4 interfaceId) public view virtual override returns (bool) {
        return interfaceId == type(IERC165).interfaceId;
    }
}

// File: @openzeppelin/contracts/utils/Strings.sol



pragma solidity ^0.8.0;

/**
 * @dev String operations.
 */
library Strings {
    bytes16 private constant _HEX_SYMBOLS = "0123456789abcdef";

    /**
     * @dev Converts a `uint256` to its ASCII `string` decimal representation.
     */
    function toString(uint256 value) internal pure returns (string memory) {
        // Inspired by OraclizeAPI's implementation - MIT licence
        // https://github.com/oraclize/ethereum-api/blob/b42146b063c7d6ee1358846c198246239e9360e8/oraclizeAPI_0.4.25.sol

        if (value == 0) {
            return "0";
        }
        uint256 temp = value;
        uint256 digits;
        while (temp != 0) {
            digits++;
            temp /= 10;
        }
        bytes memory buffer = new bytes(digits);
        while (value != 0) {
            digits -= 1;
            buffer[digits] = bytes1(uint8(48 + uint256(value % 10)));
            value /= 10;
        }
        return string(buffer);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation.
     */
    function toHexString(uint256 value) internal pure returns (string memory) {
        if (value == 0) {
            return "0x00";
        }
        uint256 temp = value;
        uint256 length = 0;
        while (temp != 0) {
            length++;
            temp >>= 8;
        }
        return toHexString(value, length);
    }

    /**
     * @dev Converts a `uint256` to its ASCII `string` hexadecimal representation with fixed length.
     */
    function toHexString(uint256 value, uint256 length) internal pure returns (string memory) {
        bytes memory buffer = new bytes(2 * length + 2);
        buffer[0] = "0";
        buffer[1] = "x";
        for (uint256 i = 2 * length + 1; i > 1; --i) {
            buffer[i] = _HEX_SYMBOLS[value & 0xf];
            value >>= 4;
        }
        require(value == 0, "Strings: hex length insufficient");
        return string(buffer);
    }
}

// File: @openzeppelin/contracts/utils/Address.sol



pragma solidity ^0.8.0;

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

        uint256 size;
        assembly {
            size := extcodesize(account)
        }
        return size > 0;
    }

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

        (bool success, ) = recipient.call{value: amount}("");
        require(success, "Address: unable to send value, recipient may have reverted");
    }

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

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

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

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

        (bool success, bytes memory returndata) = target.call{value: value}(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(address target, bytes memory data) internal view returns (bytes memory) {
        return functionStaticCall(target, data, "Address: low-level static call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a static call.
     *
     * _Available since v3.3._
     */
    function functionStaticCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal view returns (bytes memory) {
        require(isContract(target), "Address: static call to non-contract");

        (bool success, bytes memory returndata) = target.staticcall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(address target, bytes memory data) internal returns (bytes memory) {
        return functionDelegateCall(target, data, "Address: low-level delegate call failed");
    }

    /**
     * @dev Same as {xref-Address-functionCall-address-bytes-string-}[`functionCall`],
     * but performing a delegate call.
     *
     * _Available since v3.4._
     */
    function functionDelegateCall(
        address target,
        bytes memory data,
        string memory errorMessage
    ) internal returns (bytes memory) {
        require(isContract(target), "Address: delegate call to non-contract");

        (bool success, bytes memory returndata) = target.delegatecall(data);
        return verifyCallResult(success, returndata, errorMessage);
    }

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

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

// File: @openzeppelin/contracts/token/ERC721/extensions/IERC721Metadata.sol



pragma solidity ^0.8.0;


/**
 * @title ERC-721 Non-Fungible Token Standard, optional metadata extension
 * @dev See https://eips.ethereum.org/EIPS/eip-721
 */
interface IERC721Metadata is IERC721 {
    /**
     * @dev Returns the token collection name.
     */
    function name() external view returns (string memory);

    /**
     * @dev Returns the token collection symbol.
     */
    function symbol() external view returns (string memory);

    /**
     * @dev Returns the Uniform Resource Identifier (URI) for `tokenId` token.
     */
    function tokenURI(uint256 tokenId) external view returns (string memory);
}

// File: @openzeppelin/contracts/token/ERC721/IERC721Receiver.sol



pragma solidity ^0.8.0;

/**
 * @title ERC721 token receiver interface
 * @dev Interface for any contract that wants to support safeTransfers
 * from ERC721 asset contracts.
 */
interface IERC721Receiver {
    /**
     * @dev Whenever an {IERC721} `tokenId` token is transferred to this contract via {IERC721-safeTransferFrom}
     * by `operator` from `from`, this function is called.
     *
     * It must return its Solidity selector to confirm the token transfer.
     * If any other value is returned or the interface is not implemented by the recipient, the transfer will be reverted.
     *
     * The selector can be obtained in Solidity with `IERC721.onERC721Received.selector`.
     */
    function onERC721Received(
        address operator,
        address from,
        uint256 tokenId,
        bytes calldata data
    ) external returns (bytes4);
}

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

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


// File: @openzeppelin/contracts/token/ERC721/ERC721.sol
pragma solidity ^0.8.0;
/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension, but not including the Enumerable extension, which is available separately as
 * {ERC721Enumerable}.
 */
contract ERC721 is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to owner address
    mapping(uint256 => address) private _owners;

    // Mapping owner address to token count
    mapping(address => uint256) private _balances;

    // Mapping from token ID to approved address
    mapping(uint256 => address) private _tokenApprovals;

    // Mapping from owner to operator approvals
    mapping(address => mapping(address => bool)) private _operatorApprovals;

    /**
     * @dev Initializes the contract by setting a `name` and a `symbol` to the token collection.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

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

    /**
     * @dev See {IERC721-balanceOf}.
     */
    function balanceOf(address owner) public view virtual override returns (uint256) {
        require(owner != address(0), "ERC721: balance query for the zero address");
        return _balances[owner];
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        address owner = _owners[tokenId];
        require(owner != address(0), "ERC721: owner query for nonexistent token");
        return owner;
    }

    /**
     * @dev See {IERC721Metadata-name}.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev See {IERC721Metadata-symbol}.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");

        string memory baseURI = _baseURI();
        return bytes(baseURI).length > 0 ? string(abi.encodePacked(baseURI, tokenId.toString())) : "";
    }

    /**
     * @dev Base URI for computing {tokenURI}. If set, the resulting URI for each
     * token will be the concatenation of the `baseURI` and the `tokenId`. Empty
     * by default, can be overriden in child contracts.
     */
    function _baseURI() internal view virtual returns (string memory) {
        return "";
    }

    /**
     * @dev See {IERC721-approve}.
     */
    function approve(address to, uint256 tokenId) public virtual override {
        address owner = ERC721.ownerOf(tokenId);
        require(to != owner, "ERC721: approval to current owner");

        require(
            _msgSender() == owner || isApprovedForAll(owner, _msgSender()),
            "ERC721: approve caller is not owner nor approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        require(_exists(tokenId), "ERC721: approved query for nonexistent token");

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        require(operator != _msgSender(), "ERC721: approve to caller");

        _operatorApprovals[_msgSender()][operator] = approved;
        emit ApprovalForAll(_msgSender(), operator, approved);
    }

    /**
     * @dev See {IERC721-isApprovedForAll}.
     */
    function isApprovedForAll(address owner, address operator) public view virtual override returns (bool) {
        return _operatorApprovals[owner][operator];
    }

    /**
     * @dev See {IERC721-transferFrom}.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        //solhint-disable-next-line max-line-length
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");

        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        safeTransferFrom(from, to, tokenId, "");
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        require(_isApprovedOrOwner(_msgSender(), tokenId), "ERC721: transfer caller is not owner nor approved");
        _safeTransfer(from, to, tokenId, _data);
    }

    /**
     * @dev Safely transfers `tokenId` token from `from` to `to`, checking first that contract recipients
     * are aware of the ERC721 protocol to prevent tokens from being forever locked.
     *
     * `_data` is additional data, it has no specified format and it is sent in call to `to`.
     *
     * This internal function is equivalent to {safeTransferFrom}, and can be used to e.g.
     * implement alternative mechanisms to perform token transfer, such as signature-based.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must exist and be owned by `from`.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeTransfer(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _transfer(from, to, tokenId);
        require(_checkOnERC721Received(from, to, tokenId, _data), "ERC721: transfer to non ERC721Receiver implementer");
    }

    /**
     * @dev Returns whether `tokenId` exists.
     *
     * Tokens can be managed by their owner or approved accounts via {approve} or {setApprovalForAll}.
     *
     * Tokens start existing when they are minted (`_mint`),
     * and stop existing when they are burned (`_burn`).
     */
    function _exists(uint256 tokenId) internal view virtual returns (bool) {
        return _owners[tokenId] != address(0);
    }

    /**
     * @dev Returns whether `spender` is allowed to manage `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _isApprovedOrOwner(address spender, uint256 tokenId) internal view virtual returns (bool) {
        require(_exists(tokenId), "ERC721: operator query for nonexistent token");
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || getApproved(tokenId) == spender || isApprovedForAll(owner, spender));
    }

    /**
     * @dev Safely mints `tokenId` and transfers it to `to`.
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called upon a safe transfer.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(address to, uint256 tokenId) internal virtual {
        _safeMint(to, tokenId, "");
    }

    /**
     * @dev Same as {xref-ERC721-_safeMint-address-uint256-}[`_safeMint`], with an additional `data` parameter which is
     * forwarded in {IERC721Receiver-onERC721Received} to contract recipients.
     */
    function _safeMint(
        address to,
        uint256 tokenId,
        bytes memory _data
    ) internal virtual {
        _mint(to, tokenId);
        require(
            _checkOnERC721Received(address(0), to, tokenId, _data),
            "ERC721: transfer to non ERC721Receiver implementer"
        );
    }

    /**
     * @dev Mints `tokenId` and transfers it to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {_safeMint} whenever possible
     *
     * Requirements:
     *
     * - `tokenId` must not exist.
     * - `to` cannot be the zero address.
     *
     * Emits a {Transfer} event.
     */
    function _mint(address to, uint256 tokenId) internal virtual {
        require(to != address(0), "ERC721: mint to the zero address");
        require(!_exists(tokenId), "ERC721: token already minted");

        _beforeTokenTransfer(address(0), to, tokenId);

        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(address(0), to, tokenId);
    }

    /**
     * @dev Destroys `tokenId`.
     * The approval is cleared when the token is burned.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     *
     * Emits a {Transfer} event.
     */
    function _burn(uint256 tokenId) internal virtual {
        address owner = ERC721.ownerOf(tokenId);

        _beforeTokenTransfer(owner, address(0), tokenId);

        // Clear approvals
        _approve(address(0), tokenId);

        _balances[owner] -= 1;
        delete _owners[tokenId];

        emit Transfer(owner, address(0), tokenId);
    }

    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *  As opposed to {transferFrom}, this imposes no restrictions on msg.sender.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {
        require(ERC721.ownerOf(tokenId) == from, "ERC721: transfer of token that is not own");
        require(to != address(0), "ERC721: transfer to the zero address");

        _beforeTokenTransfer(from, to, tokenId);

        // Clear approvals from the previous owner
        _approve(address(0), tokenId);

        _balances[from] -= 1;
        _balances[to] += 1;
        _owners[tokenId] = to;

        emit Transfer(from, to, tokenId);
    }

    /**
     * @dev Approve `to` to operate on `tokenId`
     *
     * Emits a {Approval} event.
     */
    function _approve(address to, uint256 tokenId) internal virtual {
        _tokenApprovals[tokenId] = to;
        emit Approval(ERC721.ownerOf(tokenId), to, tokenId);
    }

    /**
     * @dev Internal function to invoke {IERC721Receiver-onERC721Received} on a target address.
     * The call is not executed if the target address is not a contract.
     *
     * @param from address representing the previous owner of the given token ID
     * @param to target address that will receive the tokens
     * @param tokenId uint256 ID of the token to be transferred
     * @param _data bytes optional data to send along with the call
     * @return bool whether the call correctly returned the expected magic value
     */
    function _checkOnERC721Received(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) private returns (bool) {
        if (to.isContract()) {
            try IERC721Receiver(to).onERC721Received(_msgSender(), from, tokenId, _data) returns (bytes4 retval) {
                return retval == IERC721Receiver.onERC721Received.selector;
            } catch (bytes memory reason) {
                if (reason.length == 0) {
                    revert("ERC721: transfer to non ERC721Receiver implementer");
                } else {
                    assembly {
                        revert(add(32, reason), mload(reason))
                    }
                }
            }
        } else {
            return true;
        }
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` will be burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}
}

// File: @openzeppelin/contracts/token/ERC721/extensions/ERC721Enumerable.sol



pragma solidity ^0.8.0;



/**
 * @dev This implements an optional extension of {ERC721} defined in the EIP that adds
 * enumerability of all the token ids in the contract as well as all token ids owned by each
 * account.
 */
abstract contract ERC721Enumerable is ERC721, IERC721Enumerable {
    // Mapping from owner to list of owned token IDs
    mapping(address => mapping(uint256 => uint256)) private _ownedTokens;

    // Mapping from token ID to index of the owner tokens list
    mapping(uint256 => uint256) private _ownedTokensIndex;

    // Array with all token ids, used for enumeration
    uint256[] private _allTokens;

    // Mapping from token id to position in the allTokens array
    mapping(uint256 => uint256) private _allTokensIndex;

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

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721.balanceOf(owner), "ERC721Enumerable: owner index out of bounds");
        return _ownedTokens[owner][index];
    }

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     */
    function totalSupply() public view virtual override returns (uint256) {
        return _allTokens.length;
    }

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view virtual override returns (uint256) {
        require(index < ERC721Enumerable.totalSupply(), "ERC721Enumerable: global index out of bounds");
        return _allTokens[index];
    }

    /**
     * @dev Hook that is called before any token transfer. This includes minting
     * and burning.
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, ``from``'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, ``from``'s `tokenId` will be burned.
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual override {
        super._beforeTokenTransfer(from, to, tokenId);

        if (from == address(0)) {
            _addTokenToAllTokensEnumeration(tokenId);
        } else if (from != to) {
            _removeTokenFromOwnerEnumeration(from, tokenId);
        }
        if (to == address(0)) {
            _removeTokenFromAllTokensEnumeration(tokenId);
        } else if (to != from) {
            _addTokenToOwnerEnumeration(to, tokenId);
        }
    }

    /**
     * @dev Private function to add a token to this extension's ownership-tracking data structures.
     * @param to address representing the new owner of the given token ID
     * @param tokenId uint256 ID of the token to be added to the tokens list of the given address
     */
    function _addTokenToOwnerEnumeration(address to, uint256 tokenId) private {
        uint256 length = ERC721.balanceOf(to);
        _ownedTokens[to][length] = tokenId;
        _ownedTokensIndex[tokenId] = length;
    }

    /**
     * @dev Private function to add a token to this extension's token tracking data structures.
     * @param tokenId uint256 ID of the token to be added to the tokens list
     */
    function _addTokenToAllTokensEnumeration(uint256 tokenId) private {
        _allTokensIndex[tokenId] = _allTokens.length;
        _allTokens.push(tokenId);
    }

    /**
     * @dev Private function to remove a token from this extension's ownership-tracking data structures. Note that
     * while the token is not assigned a new owner, the `_ownedTokensIndex` mapping is _not_ updated: this allows for
     * gas optimizations e.g. when performing a transfer operation (avoiding double writes).
     * This has O(1) time complexity, but alters the order of the _ownedTokens array.
     * @param from address representing the previous owner of the given token ID
     * @param tokenId uint256 ID of the token to be removed from the tokens list of the given address
     */
    function _removeTokenFromOwnerEnumeration(address from, uint256 tokenId) private {
        // To prevent a gap in from's tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = ERC721.balanceOf(from) - 1;
        uint256 tokenIndex = _ownedTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary
        if (tokenIndex != lastTokenIndex) {
            uint256 lastTokenId = _ownedTokens[from][lastTokenIndex];

            _ownedTokens[from][tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
            _ownedTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index
        }

        // This also deletes the contents at the last position of the array
        delete _ownedTokensIndex[tokenId];
        delete _ownedTokens[from][lastTokenIndex];
    }

    /**
     * @dev Private function to remove a token from this extension's token tracking data structures.
     * This has O(1) time complexity, but alters the order of the _allTokens array.
     * @param tokenId uint256 ID of the token to be removed from the tokens list
     */
    function _removeTokenFromAllTokensEnumeration(uint256 tokenId) private {
        // To prevent a gap in the tokens array, we store the last token in the index of the token to delete, and
        // then delete the last slot (swap and pop).

        uint256 lastTokenIndex = _allTokens.length - 1;
        uint256 tokenIndex = _allTokensIndex[tokenId];

        // When the token to delete is the last token, the swap operation is unnecessary. However, since this occurs so
        // rarely (when the last minted token is burnt) that we still do the swap here to avoid the gas cost of adding
        // an 'if' statement (like in _removeTokenFromOwnerEnumeration)
        uint256 lastTokenId = _allTokens[lastTokenIndex];

        _allTokens[tokenIndex] = lastTokenId; // Move the last token to the slot of the to-delete token
        _allTokensIndex[lastTokenId] = tokenIndex; // Update the moved token's index

        // This also deletes the contents at the last position of the array
        delete _allTokensIndex[tokenId];
        _allTokens.pop();
    }
}


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

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

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

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

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

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Can only be called by the current owner.
     */
    function transferOwnership(address newOwner) public virtual onlyOwner {
        require(newOwner != address(0), "Ownable: new owner is the zero address");
        _setOwner(newOwner);
    }

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Tree proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 *
 * WARNING: You should avoid using leaf values that are 64 bytes long prior to
 * hashing, or use a hash function other than keccak256 for hashing leaves.
 * This is because the concatenation of a sorted pair of internal nodes in
 * the merkle tree could be reinterpreted as a leaf value.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

    /**
     * @dev Calldata version of {verify}
     *
     * _Available since v4.7._
     */
    function verifyCalldata(
        bytes32[] calldata proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProofCalldata(proof, leaf) == root;
    }

    /**
     * @dev Returns the rebuilt hash obtained by traversing a Merkle tree up
     * from `leaf` using `proof`. A `proof` is valid if and only if the rebuilt
     * hash matches the root of the tree. When processing the proof, the pairs
     * of leafs & pre-images are assumed to be sorted.
     *
     * _Available since v4.4._
     */
    function processProof(bytes32[] memory proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Calldata version of {processProof}
     *
     * _Available since v4.7._
     */
    function processProofCalldata(bytes32[] calldata proof, bytes32 leaf) internal pure returns (bytes32) {
        bytes32 computedHash = leaf;
        for (uint256 i = 0; i < proof.length; i++) {
            computedHash = _hashPair(computedHash, proof[i]);
        }
        return computedHash;
    }

    /**
     * @dev Returns true if the `leaves` can be proved to be a part of a Merkle tree defined by
     * `root`, according to `proof` and `proofFlags` as described in {processMultiProof}.
     *
     * _Available since v4.7._
     */
    function multiProofVerify(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProof(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Calldata version of {multiProofVerify}
     *
     * _Available since v4.7._
     */
    function multiProofVerifyCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32 root,
        bytes32[] memory leaves
    ) internal pure returns (bool) {
        return processMultiProofCalldata(proof, proofFlags, leaves) == root;
    }

    /**
     * @dev Returns the root of a tree reconstructed from `leaves` and the sibling nodes in `proof`,
     * consuming from one or the other at each step according to the instructions given by
     * `proofFlags`.
     *
     * _Available since v4.7._
     */
    function processMultiProof(
        bytes32[] memory proof,
        bool[] memory proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    /**
     * @dev Calldata version of {processMultiProof}
     *
     * _Available since v4.7._
     */
    function processMultiProofCalldata(
        bytes32[] calldata proof,
        bool[] calldata proofFlags,
        bytes32[] memory leaves
    ) internal pure returns (bytes32 merkleRoot) {
        // This function rebuild the root hash by traversing the tree up from the leaves. The root is rebuilt by
        // consuming and producing values on a queue. The queue starts with the `leaves` array, then goes onto the
        // `hashes` array. At the end of the process, the last hash in the `hashes` array should contain the root of
        // the merkle tree.
        uint256 leavesLen = leaves.length;
        uint256 totalHashes = proofFlags.length;

        // Check proof validity.
        require(leavesLen + proof.length - 1 == totalHashes, "MerkleProof: invalid multiproof");

        // The xxxPos values are "pointers" to the next value to consume in each array. All accesses are done using
        // `xxx[xxxPos++]`, which return the current value and increment the pointer, thus mimicking a queue's "pop".
        bytes32[] memory hashes = new bytes32[](totalHashes);
        uint256 leafPos = 0;
        uint256 hashPos = 0;
        uint256 proofPos = 0;
        // At each step, we compute the next hash using two values:
        // - a value from the "main queue". If not all leaves have been consumed, we get the next leaf, otherwise we
        //   get the next hash.
        // - depending on the flag, either another value for the "main queue" (merging branches) or an element from the
        //   `proof` array.
        for (uint256 i = 0; i < totalHashes; i++) {
            bytes32 a = leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++];
            bytes32 b = proofFlags[i] ? leafPos < leavesLen ? leaves[leafPos++] : hashes[hashPos++] : proof[proofPos++];
            hashes[i] = _hashPair(a, b);
        }

        if (totalHashes > 0) {
            return hashes[totalHashes - 1];
        } else if (leavesLen > 0) {
            return leaves[0];
        } else {
            return proof[0];
        }
    }

    function _hashPair(bytes32 a, bytes32 b) private pure returns (bytes32) {
        return a < b ? _efficientHash(a, b) : _efficientHash(b, a);
    }

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        /// @solidity memory-safe-assembly
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/draft-IERC20Permit.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 Permit extension allowing approvals to be made via signatures, as defined in
 * https://eips.ethereum.org/EIPS/eip-2612[EIP-2612].
 *
 * Adds the {permit} method, which can be used to change an account's ERC20 allowance (see {IERC20-allowance}) by
 * presenting a message signed by the account. By not relying on {IERC20-approve}, the token holder account doesn't
 * need to send a transaction, and thus is not required to hold Ether at all.
 */
interface IERC20Permit {
    /**
     * @dev Sets `value` as the allowance of `spender` over ``owner``'s tokens,
     * given ``owner``'s signed approval.
     *
     * IMPORTANT: The same issues {IERC20-approve} has related to transaction
     * ordering also apply here.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `deadline` must be a timestamp in the future.
     * - `v`, `r` and `s` must be a valid `secp256k1` signature from `owner`
     * over the EIP712-formatted function arguments.
     * - the signature must use ``owner``'s current nonce (see {nonces}).
     *
     * For more information on the signature format, see the
     * https://eips.ethereum.org/EIPS/eip-2612#specification[relevant EIP
     * section].
     */
    function permit(
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) external;

    /**
     * @dev Returns the current nonce for `owner`. This value must be
     * included whenever a signature is generated for {permit}.
     *
     * Every successful call to {permit} increases ``owner``'s nonce by one. This
     * prevents a signature from being used multiple times.
     */
    function nonces(address owner) external view returns (uint256);

    /**
     * @dev Returns the domain separator used in the encoding of the signature for {permit}, as defined by {EIP712}.
     */
    // solhint-disable-next-line func-name-mixedcase
    function DOMAIN_SEPARATOR() external view returns (bytes32);
}

// OpenZeppelin Contracts (last updated v4.6.0) (token/ERC20/IERC20.sol)

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @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 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 `to`.
     *
     * Returns a boolean value indicating whether the operation succeeded.
     *
     * Emits a {Transfer} event.
     */
    function transfer(address to, 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 `from` to `to` 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 from,
        address to,
        uint256 amount
    ) external returns (bool);
}

// OpenZeppelin Contracts (last updated v4.7.0) (token/ERC20/utils/SafeERC20.sol)
pragma solidity ^0.8.0;
/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    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'
        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) + value;
        _callOptionalReturn(token, abi.encodeWithSelector(token.approve.selector, spender, newAllowance));
    }

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

    function safePermit(
        IERC20Permit token,
        address owner,
        address spender,
        uint256 value,
        uint256 deadline,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal {
        uint256 nonceBefore = token.nonces(owner);
        token.permit(owner, spender, value, deadline, v, r, s);
        uint256 nonceAfter = token.nonces(owner);
        require(nonceAfter == nonceBefore + 1, "SafeERC20: permit did not succeed");
    }

    /**
     * @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
            require(abi.decode(returndata, (bool)), "SafeERC20: ERC20 operation did not succeed");
        }
    }
}

pragma solidity ^0.8.0;
/**
 * @title PaymentSplitter
 * @dev This contract allows to split Ether payments among a group of accounts. The sender does not need to be aware
 * that the Ether will be split in this way, since it is handled transparently by the contract.
 *
 * The split can be in equal parts or in any other arbitrary proportion. The way this is specified is by assigning each
 * account to a number of shares. Of all the Ether that this contract receives, each account will then be able to claim
 * an amount proportional to the percentage of total shares they were assigned. The distribution of shares is set at the
 * time of contract deployment and can't be updated thereafter.
 *
 * `PaymentSplitter` follows a _pull payment_ model. This means that payments are not automatically forwarded to the
 * accounts but kept in this contract, and the actual transfer is triggered as a separate step by calling the {release}
 * function.
 *
 * NOTE: This contract assumes that ERC20 tokens will behave similarly to native tokens (Ether). Rebasing tokens, and
 * tokens that apply fees during transfers, are likely to not be supported as expected. If in doubt, we encourage you
 * to run tests before sending real value to this contract.
 */
contract PaymentSplitter is Context {
    event PayeeAdded(address account, uint256 shares);
    event PaymentReleased(address to, uint256 amount);
    event ERC20PaymentReleased(IERC20 indexed token, address to, uint256 amount);
    event PaymentReceived(address from, uint256 amount);

    uint256 private _totalShares;
    uint256 private _totalReleased;

    mapping(address => uint256) private _shares;
    mapping(address => uint256) private _released;
    address[] private _payees;

    mapping(IERC20 => uint256) private _erc20TotalReleased;
    mapping(IERC20 => mapping(address => uint256)) private _erc20Released;

    /**
     * @dev Creates an instance of `PaymentSplitter` where each account in `payees` is assigned the number of shares at
     * the matching position in the `shares` array.
     *
     * All addresses in `payees` must be non-zero. Both arrays must have the same non-zero length, and there must be no
     * duplicates in `payees`.
     */
    constructor(address[] memory payees, uint256[] memory shares_) payable {
        require(payees.length == shares_.length, "PaymentSplitter: payees and shares length mismatch");
        require(payees.length > 0, "PaymentSplitter: no payees");

        for (uint256 i = 0; i < payees.length; i++) {
            _addPayee(payees[i], shares_[i]);
        }
    }

    /**
     * @dev The Ether received will be logged with {PaymentReceived} events. Note that these events are not fully
     * reliable: it's possible for a contract to receive Ether without triggering this function. This only affects the
     * reliability of the events, and not the actual splitting of Ether.
     *
     * To learn more about this see the Solidity documentation for
     * https://solidity.readthedocs.io/en/latest/contracts.html#fallback-function[fallback
     * functions].
     */
    receive() external payable virtual {
        emit PaymentReceived(_msgSender(), msg.value);
    }

    /**
     * @dev Getter for the total shares held by payees.
     */
    function totalShares() public view returns (uint256) {
        return _totalShares;
    }

    /**
     * @dev Getter for the total amount of Ether already released.
     */
    function totalReleased() public view returns (uint256) {
        return _totalReleased;
    }

    /**
     * @dev Getter for the total amount of `token` already released. `token` should be the address of an IERC20
     * contract.
     */
    function totalReleased(IERC20 token) public view returns (uint256) {
        return _erc20TotalReleased[token];
    }

    /**
     * @dev Getter for the amount of shares held by an account.
     */
    function shares(address account) public view returns (uint256) {
        return _shares[account];
    }

    /**
     * @dev Getter for the amount of Ether already released to a payee.
     */
    function released(address account) public view returns (uint256) {
        return _released[account];
    }

    /**
     * @dev Getter for the amount of `token` tokens already released to a payee. `token` should be the address of an
     * IERC20 contract.
     */
    function released(IERC20 token, address account) public view returns (uint256) {
        return _erc20Released[token][account];
    }

    /**
     * @dev Getter for the address of the payee number `index`.
     */
    function payee(uint256 index) public view returns (address) {
        return _payees[index];
    }

    /**
     * @dev Getter for the amount of payee's releasable Ether.
     */
    function releasable(address account) public view returns (uint256) {
        uint256 totalReceived = address(this).balance + totalReleased();
        return _pendingPayment(account, totalReceived, released(account));
    }

    /**
     * @dev Getter for the amount of payee's releasable `token` tokens. `token` should be the address of an
     * IERC20 contract.
     */
    function releasable(IERC20 token, address account) public view returns (uint256) {
        uint256 totalReceived = token.balanceOf(address(this)) + totalReleased(token);
        return _pendingPayment(account, totalReceived, released(token, account));
    }

    /**
     * @dev Triggers a transfer to `account` of the amount of Ether they are owed, according to their percentage of the
     * total shares and their previous withdrawals.
     */
    function release(address payable account) public virtual {
        require(_shares[account] > 0, "PaymentSplitter: account has no shares");

        uint256 payment = releasable(account);

        require(payment != 0, "PaymentSplitter: account is not due payment");

        // _totalReleased is the sum of all values in _released.
        // If "_totalReleased += payment" does not overflow, then "_released[account] += payment" cannot overflow.
        _totalReleased += payment;
        unchecked {
            _released[account] += payment;
        }

        Address.sendValue(account, payment);
        emit PaymentReleased(account, payment);
    }

    /**
     * @dev Triggers a transfer to `account` of the amount of `token` tokens they are owed, according to their
     * percentage of the total shares and their previous withdrawals. `token` must be the address of an IERC20
     * contract.
     */
    function release(IERC20 token, address account) public virtual {
        require(_shares[account] > 0, "PaymentSplitter: account has no shares");

        uint256 payment = releasable(token, account);

        require(payment != 0, "PaymentSplitter: account is not due payment");

        // _erc20TotalReleased[token] is the sum of all values in _erc20Released[token].
        // If "_erc20TotalReleased[token] += payment" does not overflow, then "_erc20Released[token][account] += payment"
        // cannot overflow.
        _erc20TotalReleased[token] += payment;
        unchecked {
            _erc20Released[token][account] += payment;
        }

        SafeERC20.safeTransfer(token, account, payment);
        emit ERC20PaymentReleased(token, account, payment);
    }

    /**
     * @dev internal logic for computing the pending payment of an `account` given the token historical balances and
     * already released amounts.
     */
    function _pendingPayment(
        address account,
        uint256 totalReceived,
        uint256 alreadyReleased
    ) private view returns (uint256) {
        return (totalReceived * _shares[account]) / _totalShares - alreadyReleased;
    }

    /**
     * @dev Add a new payee to the contract.
     * @param account The address of the payee to add.
     * @param shares_ The number of shares owned by the payee.
     */
    function _addPayee(address account, uint256 shares_) private {
        require(account != address(0), "PaymentSplitter: account is the zero address");
        require(shares_ > 0, "PaymentSplitter: shares are 0");
        require(_shares[account] == 0, "PaymentSplitter: account already has shares");

        _payees.push(account);
        _shares[account] = shares_;
        _totalShares = _totalShares + shares_;
        emit PayeeAdded(account, shares_);
    }
}

pragma solidity >=0.7.0 <0.9.0;

contract Azaza is ERC721Enumerable, Ownable, PaymentSplitter {
  using Strings for uint256;

  string baseURI;
  uint256 public cost = 0.05 ether;
  uint256 public maxSupply = 555;
  uint public maxFree = 0;
  uint public wlMaxPerTx = 1;
  uint public wlMaxPerWallet = 1;
  uint public publicMaxPerTx = 1;
  uint public publicMaxPerWallet = 1;
  uint public totalFree = 0;
  mapping (address => uint) internal wlMintWallet;
  mapping (address => uint) internal publicMintWallet;
  bool public paused;
  bytes32 public merkleRoot;
   mapping (address => bool) public claimedMint;
  enum Step {
    Before,
    WhitelistSale,
    PublicSale,
    SoldOut,
    Reveal
  }

    uint256 private _teamLength;

    address[] private _team = [
        0xe3E5608D7e4594313c71ef0D2BF0F8F500869f79
    ];

    uint256[] private _teamShares = [1000];

  Step public sellingStep;
  constructor(
    string memory _name,
    string memory _symbol,
    string memory _baseURI,
    bytes32 _merkleRoot
  ) ERC721(_name, _symbol) PaymentSplitter(_team, _teamShares) {
    baseURI = _baseURI;
    merkleRoot = _merkleRoot;
    _teamLength = _team.length;
  }

  // public
  function mint(uint256 _mintAmount) public payable {
    require(!paused, "Contract paused.");
    require(sellingStep == Step.PublicSale, "Public sale is not running");
    require(_mintAmount > 0, "You can't mint less than 1 NFT.");
    require(_mintAmount <= publicMaxPerTx, "You can't mint more than 5 NFT in one transaction.");
    uint supply = totalSupply();
    require(supply + _mintAmount <= maxSupply, "Max supply exceeded.");

    if (msg.sender != owner()) {
        require(msg.value >= cost * _mintAmount, "Sorry you did not send enough ether");
        if(publicMaxPerWallet != 0) {
            require(publicMintWallet[msg.sender] + _mintAmount <= publicMaxPerWallet, "Max per wallet exceeded");
            publicMintWallet[msg.sender] += _mintAmount;
        }
    }

    for (uint256 i = 1; i <= _mintAmount; i++) {
      _safeMint(msg.sender, supply + i);
    }
  }

  function whitelistMint(uint _mintAmount, bytes32[] calldata _proof) public payable {
    require(!paused, "Contract paused.");
    require(sellingStep == Step.WhitelistSale, "Whitelist sale is not running.");
    require(isWhitelisted(msg.sender, _proof), "You're not whitelisted.");
    require(_mintAmount > 0, "You can't mint less than 1 NFT.");
    require(_mintAmount <= wlMaxPerTx, "You can't mint more than limit in one transaction.");
    uint supply = totalSupply();
    require(supply + _mintAmount <= maxSupply, "Max supply exceeded.");

    if (msg.sender != owner()) {
        if(totalFree + 1 <= maxFree) {
            if (!claimedMint[msg.sender]) {
                require(msg.value >= cost * _mintAmount - cost, "Sorry you did not send enough ether");
                claimedMint[msg.sender] = true;
		    totalFree += 1;
            } else {
                require(msg.value >= cost * _mintAmount, "Sorry you did not send enough ether");
            }
        } else {
                require(msg.value >= cost * _mintAmount, "Sorry you did not send enough ether");
        }
        if(wlMaxPerWallet != 0) {
            require(wlMintWallet[msg.sender] + _mintAmount <= wlMaxPerWallet, "Max per wallet exceeded");
            wlMintWallet[msg.sender] += _mintAmount;
        }
    }

    for (uint256 i = 1; i <= _mintAmount; i++) {
      _safeMint(msg.sender, supply + i);
    }
  }

  function walletOfOwner(address _owner)
    public
    view
    returns (uint256[] memory)
  {
    uint256 ownerTokenCount = balanceOf(_owner);
    uint256[] memory tokenIds = new uint256[](ownerTokenCount);
    for (uint256 i; i < ownerTokenCount; i++) {
      tokenIds[i] = tokenOfOwnerByIndex(_owner, i);
    }
    return tokenIds;
  }

    /**
     * @notice Get the token URI of an NFT by his ID
     *
     * @param _tokenId The ID of the NFT you want to have the URI of the metadatas
     *
     * @return string Token URI of an NFT by his ID
     */
    function tokenURI(uint256 _tokenId)
        public
        view
        virtual
        override
        returns (string memory)
    {
        require(_exists(_tokenId), "URI query for nonexistent token");

        return string(abi.encodePacked(baseURI, _tokenId.toString(), ".json"));
    }
  
  function setCost(uint256 _newCost) public onlyOwner {
    cost = _newCost;
  }

  function setBaseURI(string memory _newBaseURI) public onlyOwner {
    baseURI = _newBaseURI;
  }
  function pause(bool _state) public onlyOwner {
    paused = _state;
  }

      /**
     * @notice Change the step of the sale
     *
     * @param _step The new step of the sale
     */
    function setStep(uint256 _step) external onlyOwner {
        sellingStep = Step(_step);
    }

    function setMaxFree(uint256 _maxfree) public onlyOwner {
        maxFree = _maxfree;
    }

    function setWlMaxPerTx(uint _wlMaxPerTx) public onlyOwner {
        wlMaxPerTx = _wlMaxPerTx;
    }

    function setWlMaxPerWallet(uint _wlMaxPerWallet) public onlyOwner {
        wlMaxPerWallet = _wlMaxPerWallet;
    }

    function setPublicMaxPerTx(uint _publicMaxPerTx) public onlyOwner {
        publicMaxPerTx = _publicMaxPerTx;
    }

    function setPublicMaxPerWallet(uint _publicMaxPerWallet) public onlyOwner {
        wlMaxPerWallet = _publicMaxPerWallet;
    }

    function getMintInfos(address _account) external view returns(uint[11] memory) {
        uint[11] memory infos = [wlMaxPerTx, wlMaxPerWallet, wlMintWallet[_account], publicMaxPerTx, publicMaxPerWallet, publicMintWallet[_account], claimedMint[_account] ? 1 : 0, totalSupply(), maxFree, uint(sellingStep), totalFree];
        return infos;
    }

      /**
     * @notice Change the merkle root
     *
     * @param _merkleRoot The new merkle root
     */
    function setMerkleRoot(bytes32 _merkleRoot) external onlyOwner {
        merkleRoot = _merkleRoot;
    }

    /**
     * @notice Hash an address
     *
     * @param _account The address to be hashed
     *
     * @return bytes32 The hashed address
     */
    function leaf(address _account) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked(_account));
    }

    /**
     * @notice Returns true if a leaf can be proved to be a part of a merkle tree defined by root
     *
     * @param _leaf The leaf
     * @param _proof The Merkle Proof
     *
     * @return bool return true if a leaf can be proved to be a part of a merkle tree defined by root, false othewise
     */
    function _verify(bytes32 _leaf, bytes32[] memory _proof)
        internal
        view
        returns (bool)
    {
        return MerkleProof.verify(_proof, merkleRoot, _leaf);
    }

    /**
     * @notice Check if an address is whitelisted or not
     *
     * @param _account The account checked
     * @param _proof The Merkle Proof
     *
     * @return bool return true if an address is whitelisted, false otherwise
     */
    function isWhitelisted(address _account, bytes32[] calldata _proof)
        public
        view
        returns (bool)
    {
        return _verify(leaf(_account), _proof);
    }

        /**
     * @notice Release the gains on every accounts
     */
    function releaseAll() external {
        for (uint256 i = 0; i < _teamLength; i++) {
            release(payable(payee(i)));
        }
    }
}

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":"string","name":"_baseURI","type":"string"},{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"contract IERC20","name":"token","type":"address"},{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"ERC20PaymentReleased","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":false,"internalType":"address","name":"account","type":"address"},{"indexed":false,"internalType":"uint256","name":"shares","type":"uint256"}],"name":"PayeeAdded","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"from","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PaymentReceived","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"to","type":"address"},{"indexed":false,"internalType":"uint256","name":"amount","type":"uint256"}],"name":"PaymentReleased","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"claimedMint","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"cost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"}],"name":"getMintInfos","outputs":[{"internalType":"uint256[11]","name":"","type":"uint256[11]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"_account","type":"address"},{"internalType":"bytes32[]","name":"_proof","type":"bytes32[]"}],"name":"isWhitelisted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxFree","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"_state","type":"bool"}],"name":"pause","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"paused","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"payee","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicMaxPerTx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"publicMaxPerWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"releasable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"releasable","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address payable","name":"account","type":"address"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"release","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"releaseAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"},{"internalType":"address","name":"account","type":"address"}],"name":"released","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"released","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"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":[],"name":"sellingStep","outputs":[{"internalType":"enum Azaza.Step","name":"","type":"uint8"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_newBaseURI","type":"string"}],"name":"setBaseURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_newCost","type":"uint256"}],"name":"setCost","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxfree","type":"uint256"}],"name":"setMaxFree","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_publicMaxPerTx","type":"uint256"}],"name":"setPublicMaxPerTx","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_publicMaxPerWallet","type":"uint256"}],"name":"setPublicMaxPerWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_step","type":"uint256"}],"name":"setStep","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_wlMaxPerTx","type":"uint256"}],"name":"setWlMaxPerTx","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_wlMaxPerWallet","type":"uint256"}],"name":"setWlMaxPerWallet","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"account","type":"address"}],"name":"shares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalFree","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract IERC20","name":"token","type":"address"}],"name":"totalReleased","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalReleased","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalShares","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"walletOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"},{"internalType":"bytes32[]","name":"_proof","type":"bytes32[]"}],"name":"whitelistMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"wlMaxPerTx","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"wlMaxPerWallet","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"stateMutability":"payable","type":"receive"}]

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)

000000000000000000000000000000000000000000000000000000000000008000000000000000000000000000000000000000000000000000000000000000c000000000000000000000000000000000000000000000000000000000000001008bdb9e0b4a9d7762b8141173ee26733a46874ea827c3269387ebcdd6a1361630000000000000000000000000000000000000000000000000000000000000000b416c70686120417a617a610000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005417a617a61000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000005168747470733a2f2f676174657761792e70696e6174612e636c6f75642f697066732f516d57396a6172455831766648656f445a4e6f456e696d6d45647452386e4c5667426a6b634d6e3546774a5a6b532f000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _name (string): Alpha Azaza
Arg [1] : _symbol (string): Azaza
Arg [2] : _baseURI (string): https://gateway.pinata.cloud/ipfs/QmW9jarEX1vfHeoDZNoEnimmEdtR8nLVgBjkcMn5FwJZkS/
Arg [3] : _merkleRoot (bytes32): 0x8bdb9e0b4a9d7762b8141173ee26733a46874ea827c3269387ebcdd6a1361630

-----Encoded View---------------
12 Constructor Arguments found :
Arg [0] : 0000000000000000000000000000000000000000000000000000000000000080
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000c0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000100
Arg [3] : 8bdb9e0b4a9d7762b8141173ee26733a46874ea827c3269387ebcdd6a1361630
Arg [4] : 000000000000000000000000000000000000000000000000000000000000000b
Arg [5] : 416c70686120417a617a61000000000000000000000000000000000000000000
Arg [6] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [7] : 417a617a61000000000000000000000000000000000000000000000000000000
Arg [8] : 0000000000000000000000000000000000000000000000000000000000000051
Arg [9] : 68747470733a2f2f676174657761792e70696e6174612e636c6f75642f697066
Arg [10] : 732f516d57396a6172455831766648656f445a4e6f456e696d6d45647452386e
Arg [11] : 4c5667426a6b634d6e3546774a5a6b532f000000000000000000000000000000

Deployed Bytecode Sourcemap

69766:7588:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64381:40;20167:10;64381:40;;;-1:-1:-1;;;;;10686:32:1;;;10668:51;;64411:9:0;10750:2:1;10735:18;;10728:34;10641:18;64381:40:0;;;;;;;69766:7588;;;;;34666:224;;;;;;;;;;-1:-1:-1;34666:224:0;;;;;:::i;:::-;;:::i;:::-;;;12860:14:1;;12853:22;12835:41;;12823:2;12808:18;34666:224:0;;;;;;;;74396:73;;;;;;;;;;-1:-1:-1;74396:73:0;;;;;:::i;:::-;;:::i;:::-;;70014:30;;;;;;;;;;;;;;;;;;;13033:25:1;;;13021:2;13006:18;70014:30:0;12887:177:1;22558:100:0;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;24117:221::-;;;;;;;;;;-1:-1:-1;24117:221:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;10442:32:1;;;10424:51;;10412:2;10397:18;24117:221:0;10278:203:1;23640:411:0;;;;;;;;;;-1:-1:-1;23640:411:0;;;;;:::i;:::-;;:::i;69883:32::-;;;;;;;;;;;;;;;;75032:117;;;;;;;;;;-1:-1:-1;75032:117:0;;;;;:::i;:::-;;:::i;35306:113::-;;;;;;;;;;-1:-1:-1;35394:10:0;:17;35306:113;;66902:671;;;;;;;;;;-1:-1:-1;66902:671:0;;;;;:::i;:::-;;:::i;25007:339::-;;;;;;;;;;-1:-1:-1;25007:339:0;;;;;:::i;:::-;;:::i;70284:25::-;;;;;;;;;;;;;;;;34974:256;;;;;;;;;;-1:-1:-1;34974:256:0;;;;;:::i;:::-;;:::i;70123:25::-;;;;;;;;;;;;;;;;74798:101;;;;;;;;;;-1:-1:-1;74798:101:0;;;;;:::i;:::-;;:::i;64512:91::-;;;;;;;;;;-1:-1:-1;64583:12:0;;64512:91;;65641:135;;;;;;;;;;-1:-1:-1;65641:135:0;;;;;:::i;:::-;-1:-1:-1;;;;;65738:21:0;;;65711:7;65738:21;;;:14;:21;;;;;;;;:30;;;;;;;;;;;;;65641:135;25417:185;;;;;;;;;;-1:-1:-1;25417:185:0;;;;;:::i;:::-;;:::i;73317:348::-;;;;;;;;;;-1:-1:-1;73317:348:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;74208:80::-;;;;;;;;;;-1:-1:-1;74208:80:0;;;;;:::i;:::-;;:::i;69955:23::-;;;;;;;;;;;;;;;;67841:792;;;;;;;;;;-1:-1:-1;67841:792:0;;;;;:::i;:::-;;:::i;35496:233::-;;;;;;;;;;-1:-1:-1;35496:233:0;;;;;:::i;:::-;;:::i;74294:98::-;;;;;;;;;;-1:-1:-1;74294:98:0;;;;;:::i;:::-;;:::i;76941:184::-;;;;;;;;;;-1:-1:-1;76941:184:0;;;;;:::i;:::-;;:::i;77207:144::-;;;;;;;;;;;;;:::i;70261:18::-;;;;;;;;;;-1:-1:-1;70261:18:0;;;;;;;;22252:239;;;;;;;;;;-1:-1:-1;22252:239:0;;;;;:::i;:::-;;:::i;70315:44::-;;;;;;;;;;-1:-1:-1;70315:44:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;21982:208;;;;;;;;;;-1:-1:-1;21982:208:0;;;;;:::i;:::-;;:::i;42455:94::-;;;;;;;;;;;;;:::i;75762:106::-;;;;;;;;;;-1:-1:-1;75762:106:0;;;;;:::i;:::-;;:::i;65867:100::-;;;;;;;;;;-1:-1:-1;65867:100:0;;;;;:::i;:::-;;:::i;41804:87::-;;;;;;;;;;-1:-1:-1;41877:6:0;;-1:-1:-1;;;;;41877:6:0;41804:87;;22727:104;;;;;;;;;;;;;:::i;65363:109::-;;;;;;;;;;-1:-1:-1;65363:109:0;;;;;:::i;:::-;-1:-1:-1;;;;;65446:18:0;65419:7;65446:18;;;:9;:18;;;;;;;65363:109;70967:904;;;;;;:::i;:::-;;:::i;24410:295::-;;;;;;;;;;-1:-1:-1;24410:295:0;;;;;:::i;:::-;;:::i;66057:225::-;;;;;;;;;;-1:-1:-1;66057:225:0;;;;;:::i;:::-;;:::i;70084:34::-;;;;;;;;;;;;;;;;25673:328;;;;;;;;;;-1:-1:-1;25673:328:0;;;;;:::i;:::-;;:::i;75294:346::-;;;;;;;;;;-1:-1:-1;75294:346:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;74907:117::-;;;;;;;;;;-1:-1:-1;74907:117:0;;;;;:::i;:::-;;:::i;66442:260::-;;;;;;;;;;-1:-1:-1;66442:260:0;;;;;:::i;:::-;;:::i;73898:302::-;;;;;;;;;;-1:-1:-1;73898:302:0;;;;;:::i;:::-;;:::i;70640:23::-;;;;;;;;;;-1:-1:-1;70640:23:0;;;;;;;;;;;;;;;:::i;65159:105::-;;;;;;;;;;-1:-1:-1;65159:105:0;;;;;:::i;:::-;-1:-1:-1;;;;;65240:16:0;65213:7;65240:16;;;:7;:16;;;;;;;65159:105;71877:1434;;;;;;:::i;:::-;;:::i;69920:30::-;;;;;;;;;;;;;;;;74698:92;;;;;;;;;;-1:-1:-1;74698:92:0;;;;;:::i;:::-;;:::i;64949:119::-;;;;;;;;;;-1:-1:-1;64949:119:0;;;;;:::i;:::-;-1:-1:-1;;;;;65034:26:0;65007:7;65034:26;;;:19;:26;;;;;;;64949:119;64697:95;;;;;;;;;;-1:-1:-1;64770:14:0;;64697:95;;24776:164;;;;;;;;;;-1:-1:-1;24776:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;24897:25:0;;;24873:4;24897:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;24776:164;70049:30;;;;;;;;;;;;;;;;42704:192;;;;;;;;;;-1:-1:-1;42704:192:0;;;;;:::i;:::-;;:::i;69983:26::-;;;;;;;;;;;;;;;;74595:95;;;;;;;;;;-1:-1:-1;74595:95:0;;;;;:::i;:::-;;:::i;34666:224::-;34768:4;-1:-1:-1;;;;;;34792:50:0;;-1:-1:-1;;;34792:50:0;;:90;;;34846:36;34870:11;34846:23;:36::i;:::-;34785:97;34666:224;-1:-1:-1;;34666:224:0:o;74396:73::-;41877:6;;-1:-1:-1;;;;;41877:6:0;20167:10;42024:23;42016:68;;;;-1:-1:-1;;;42016:68:0;;;;;;;:::i;:::-;;;;;;;;;74448:6:::1;:15:::0;;-1:-1:-1;;74448:15:0::1;::::0;::::1;;::::0;;;::::1;::::0;;74396:73::o;22558:100::-;22612:13;22645:5;22638:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;22558:100;:::o;24117:221::-;24193:7;27600:16;;;:7;:16;;;;;;-1:-1:-1;;;;;27600:16:0;24213:73;;;;-1:-1:-1;;;24213:73:0;;22002:2:1;24213:73:0;;;21984:21:1;22041:2;22021:18;;;22014:30;22080:34;22060:18;;;22053:62;-1:-1:-1;;;22131:18:1;;;22124:42;22183:19;;24213:73:0;21800:408:1;24213:73:0;-1:-1:-1;24306:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;24306:24:0;;24117:221::o;23640:411::-;23721:13;23737:23;23752:7;23737:14;:23::i;:::-;23721:39;;23785:5;-1:-1:-1;;;;;23779:11:0;:2;-1:-1:-1;;;;;23779:11:0;;;23771:57;;;;-1:-1:-1;;;23771:57:0;;24383:2:1;23771:57:0;;;24365:21:1;24422:2;24402:18;;;24395:30;24461:34;24441:18;;;24434:62;-1:-1:-1;;;24512:18:1;;;24505:31;24553:19;;23771:57:0;24181:397:1;23771:57:0;20167:10;-1:-1:-1;;;;;23863:21:0;;;;:62;;-1:-1:-1;23888:37:0;23905:5;20167:10;24776:164;:::i;23888:37::-;23841:168;;;;-1:-1:-1;;;23841:168:0;;19683:2:1;23841:168:0;;;19665:21:1;19722:2;19702:18;;;19695:30;19761:34;19741:18;;;19734:62;19832:26;19812:18;;;19805:54;19876:19;;23841:168:0;19481:420:1;23841:168:0;24022:21;24031:2;24035:7;24022:8;:21::i;:::-;23710:341;23640:411;;:::o;75032:117::-;41877:6;;-1:-1:-1;;;;;41877:6:0;20167:10;42024:23;42016:68;;;;-1:-1:-1;;;42016:68:0;;;;;;;:::i;:::-;75109:14:::1;:32:::0;75032:117::o;66902:671::-;-1:-1:-1;;;;;66978:16:0;;66997:1;66978:16;;;:7;:16;;;;;;66970:71;;;;-1:-1:-1;;;66970:71:0;;;;;;;:::i;:::-;67054:15;67072:19;67083:7;67072:10;:19::i;:::-;67054:37;-1:-1:-1;67112:12:0;67104:68;;;;-1:-1:-1;;;67104:68:0;;;;;;;:::i;:::-;67385:7;67367:14;;:25;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;;;;67428:18:0;;;;;;:9;:18;;;;;:29;;;;;;67481:35;67438:7;67450;67481:17;:35::i;:::-;67532:33;;;-1:-1:-1;;;;;10686:32:1;;10668:51;;10750:2;10735:18;;10728:34;;;67532:33:0;;10641:18:1;67532:33:0;;;;;;;66959:614;66902:671;:::o;25007:339::-;25202:41;20167:10;25235:7;25202:18;:41::i;:::-;25194:103;;;;-1:-1:-1;;;25194:103:0;;;;;;;:::i;:::-;25310:28;25320:4;25326:2;25330:7;25310:9;:28::i;34974:256::-;35071:7;35107:23;35124:5;35107:16;:23::i;:::-;35099:5;:31;35091:87;;;;-1:-1:-1;;;35091:87:0;;14208:2:1;35091:87:0;;;14190:21:1;14247:2;14227:18;;;14220:30;14286:34;14266:18;;;14259:62;-1:-1:-1;;;14337:18:1;;;14330:41;14388:19;;35091:87:0;14006:407:1;35091:87:0;-1:-1:-1;;;;;;35196:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;34974:256::o;74798:101::-;41877:6;;-1:-1:-1;;;;;41877:6:0;20167:10;42024:23;42016:68;;;;-1:-1:-1;;;42016:68:0;;;;;;;:::i;:::-;74867:10:::1;:24:::0;74798:101::o;25417:185::-;25555:39;25572:4;25578:2;25582:7;25555:39;;;;;;;;;;;;:16;:39::i;73317:348::-;73392:16;73420:23;73446:17;73456:6;73446:9;:17::i;:::-;73420:43;;73470:25;73512:15;73498:30;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;73498:30:0;;73470:58;;73540:9;73535:103;73555:15;73551:1;:19;73535:103;;;73600:30;73620:6;73628:1;73600:19;:30::i;:::-;73586:8;73595:1;73586:11;;;;;;;;:::i;:::-;;;;;;;;;;:44;73572:3;;;;:::i;:::-;;;;73535:103;;;-1:-1:-1;73651:8:0;73317:348;-1:-1:-1;;;73317:348:0:o;74208:80::-;41877:6;;-1:-1:-1;;;;;41877:6:0;20167:10;42024:23;42016:68;;;;-1:-1:-1;;;42016:68:0;;;;;;;:::i;:::-;74267:4:::1;:15:::0;74208:80::o;67841:792::-;-1:-1:-1;;;;;67923:16:0;;67942:1;67923:16;;;:7;:16;;;;;;67915:71;;;;-1:-1:-1;;;67915:71:0;;;;;;;:::i;:::-;67999:15;68017:26;68028:5;68035:7;68017:10;:26::i;:::-;67999:44;-1:-1:-1;68064:12:0;68056:68;;;;-1:-1:-1;;;68056:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;68379:26:0;;;;;;:19;:26;;;;;:37;;68409:7;;68379:26;:37;;68409:7;;68379:37;:::i;:::-;;;;-1:-1:-1;;;;;;;68452:21:0;;;;;;;:14;:21;;;;;;;;:30;;;;;;;;;:41;;;;;;68517:47;68467:5;68474:7;68486;68517:22;:47::i;:::-;68580:45;;;-1:-1:-1;;;;;10686:32:1;;;10668:51;;10750:2;10735:18;;10728:34;;;68580:45:0;;;;;10641:18:1;68580:45:0;;;;;;;67904:729;67841:792;;:::o;35496:233::-;35571:7;35607:30;35394:10;:17;;35306:113;35607:30;35599:5;:38;35591:95;;;;-1:-1:-1;;;35591:95:0;;26320:2:1;35591:95:0;;;26302:21:1;26359:2;26339:18;;;26332:30;26398:34;26378:18;;;26371:62;-1:-1:-1;;;26449:18:1;;;26442:42;26501:19;;35591:95:0;26118:408:1;35591:95:0;35704:10;35715:5;35704:17;;;;;;;;:::i;:::-;;;;;;;;;35697:24;;35496:233;;;:::o;74294:98::-;41877:6;;-1:-1:-1;;;;;41877:6:0;20167:10;42024:23;42016:68;;;;-1:-1:-1;;;42016:68:0;;;;;;;:::i;:::-;74365:21;;::::1;::::0;:7:::1;::::0;:21:::1;::::0;::::1;::::0;::::1;:::i;:::-;;74294:98:::0;:::o;76941:184::-;77057:4;77086:31;77094:14;77099:8;76126:26;;-1:-1:-1;;8399:2:1;8395:15;;;8391:53;76126:26:0;;;8379:66:1;76089:7:0;;8461:12:1;;76126:26:0;;;;;;;;;;;;76116:37;;;;;;76109:44;;76034:127;;;;77094:14;77110:6;;77086:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;77086:7:0;;-1:-1:-1;;;77086:31:0:i;:::-;77079:38;;76941:184;;;;;;:::o;77207:144::-;77254:9;77249:95;77273:11;;77269:1;:15;77249:95;;;77306:26;77322:8;77328:1;77322:5;:8::i;77306:26::-;77286:3;;;;:::i;:::-;;;;77249:95;;;;77207:144::o;22252:239::-;22324:7;22360:16;;;:7;:16;;;;;;-1:-1:-1;;;;;22360:16:0;22395:19;22387:73;;;;-1:-1:-1;;;22387:73:0;;20519:2:1;22387:73:0;;;20501:21:1;20558:2;20538:18;;;20531:30;20597:34;20577:18;;;20570:62;-1:-1:-1;;;20648:18:1;;;20641:39;20697:19;;22387:73:0;20317:405:1;21982:208:0;22054:7;-1:-1:-1;;;;;22082:19:0;;22074:74;;;;-1:-1:-1;;;22074:74:0;;20108:2:1;22074:74:0;;;20090:21:1;20147:2;20127:18;;;20120:30;20186:34;20166:18;;;20159:62;-1:-1:-1;;;20237:18:1;;;20230:40;20287:19;;22074:74:0;19906:406:1;22074:74:0;-1:-1:-1;;;;;;22166:16:0;;;;;:9;:16;;;;;;;21982:208::o;42455:94::-;41877:6;;-1:-1:-1;;;;;41877:6:0;20167:10;42024:23;42016:68;;;;-1:-1:-1;;;42016:68:0;;;;;;;:::i;:::-;42520:21:::1;42538:1;42520:9;:21::i;:::-;42455:94::o:0;75762:106::-;41877:6;;-1:-1:-1;;;;;41877:6:0;20167:10;42024:23;42016:68;;;;-1:-1:-1;;;42016:68:0;;;;;;;:::i;:::-;75836:10:::1;:24:::0;75762:106::o;65867:100::-;65918:7;65945;65953:5;65945:14;;;;;;;;:::i;:::-;;;;;;;;;;;-1:-1:-1;;;;;65945:14:0;;65867:100;-1:-1:-1;;65867:100:0:o;22727:104::-;22783:13;22816:7;22809:14;;;;;:::i;70967:904::-;71033:6;;;;71032:7;71024:36;;;;-1:-1:-1;;;71024:36:0;;17396:2:1;71024:36:0;;;17378:21:1;17435:2;17415:18;;;17408:30;-1:-1:-1;;;17454:18:1;;;17447:46;17510:18;;71024:36:0;17194:340:1;71024:36:0;71090:15;71075:11;;;;:30;;;;;;;;:::i;:::-;;71067:69;;;;-1:-1:-1;;;71067:69:0;;24785:2:1;71067:69:0;;;24767:21:1;24824:2;24804:18;;;24797:30;24863:28;24843:18;;;24836:56;24909:18;;71067:69:0;24583:350:1;71067:69:0;71165:1;71151:11;:15;71143:59;;;;-1:-1:-1;;;71143:59:0;;21642:2:1;71143:59:0;;;21624:21:1;21681:2;21661:18;;;21654:30;21720:33;21700:18;;;21693:61;21771:18;;71143:59:0;21440:355:1;71143:59:0;71232:14;;71217:11;:29;;71209:92;;;;-1:-1:-1;;;71209:92:0;;23545:2:1;71209:92:0;;;23527:21:1;23584:2;23564:18;;;23557:30;23623:34;23603:18;;;23596:62;-1:-1:-1;;;23674:18:1;;;23667:48;23732:19;;71209:92:0;23343:414:1;71209:92:0;71308:11;71322:13;35394:10;:17;;35306:113;71322:13;71374:9;;71308:27;;-1:-1:-1;71350:20:0;71359:11;71308:27;71350:20;:::i;:::-;:33;;71342:66;;;;-1:-1:-1;;;71342:66:0;;27144:2:1;71342:66:0;;;27126:21:1;27183:2;27163:18;;;27156:30;-1:-1:-1;;;27202:18:1;;;27195:50;27262:18;;71342:66:0;26942:344:1;71342:66:0;41877:6;;-1:-1:-1;;;;;41877:6:0;71421:10;:21;71417:348;;71483:11;71476:4;;:18;;;;:::i;:::-;71463:9;:31;;71455:79;;;;-1:-1:-1;;;71455:79:0;;;;;;;:::i;:::-;71548:18;;:23;71545:213;;71642:18;;71613:10;71596:28;;;;:16;:28;;;;;;:42;;71627:11;;71596:42;:::i;:::-;:64;;71588:100;;;;-1:-1:-1;;;71588:100:0;;20929:2:1;71588:100:0;;;20911:21:1;20968:2;20948:18;;;20941:30;-1:-1:-1;;;20987:18:1;;;20980:53;21050:18;;71588:100:0;20727:347:1;71588:100:0;71720:10;71703:28;;;;:16;:28;;;;;:43;;71735:11;;71703:28;:43;;71735:11;;71703:43;:::i;:::-;;;;-1:-1:-1;;71545:213:0;71790:1;71773:93;71798:11;71793:1;:16;71773:93;;71825:33;71835:10;71847;71856:1;71847:6;:10;:::i;:::-;71825:9;:33::i;:::-;71811:3;;;;:::i;:::-;;;;71773:93;;24410:295;-1:-1:-1;;;;;24513:24:0;;20167:10;24513:24;;24505:62;;;;-1:-1:-1;;;24505:62:0;;16615:2:1;24505:62:0;;;16597:21:1;16654:2;16634:18;;;16627:30;16693:27;16673:18;;;16666:55;16738:18;;24505:62:0;16413:349:1;24505:62:0;20167:10;24580:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;24580:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;24580:53:0;;;;;;;;;;24649:48;;12835:41:1;;;24580:42:0;;20167:10;24649:48;;12808:18:1;24649:48:0;;;;;;;24410:295;;:::o;66057:225::-;66115:7;66135:21;66183:15;64770:14;;;64697:95;66183:15;66159:39;;:21;:39;:::i;:::-;66135:63;;66216:58;66232:7;66241:13;66256:17;66265:7;-1:-1:-1;;;;;65446:18:0;65419:7;65446:18;;;:9;:18;;;;;;;65363:109;66256:17;66216:15;:58::i;25673:328::-;25848:41;20167:10;25881:7;25848:18;:41::i;:::-;25840:103;;;;-1:-1:-1;;;25840:103:0;;;;;;;:::i;:::-;25954:39;25968:4;25974:2;25978:7;25987:5;25954:13;:39::i;:::-;25673:328;;;;:::o;75294:346::-;75356:15;;:::i;:::-;75384:225;;;;;;;;75409:10;;75384:225;;75421:14;;75384:225;;;;;;;;-1:-1:-1;;;;;75437:22:0;;75384:21;75437:22;;;:12;:22;;;;;;75384:225;;;;75461:14;;75384:225;;;;75477:18;;75384:225;;;;75497:26;;;:16;:26;;;;;;75384:225;;;;75525:21;;;:11;:21;;;;;;;75384:225;;;;75525:21;;:29;;75553:1;75525:29;;;75549:1;75525:29;75384:225;;;;;;75556:13;35394:10;:17;;35306:113;75556:13;75384:225;;75571:7;;75384:225;;;;75585:11;;75384:225;;;;;75585:11;;75580:17;;;;;;;;:::i;:::-;75384:225;;75599:9;;75384:225;;;;;;75294:346;-1:-1:-1;;;75294:346:0:o;74907:117::-;41877:6;;-1:-1:-1;;;;;41877:6:0;20167:10;42024:23;42016:68;;;;-1:-1:-1;;;42016:68:0;;;;;;;:::i;:::-;74984:14:::1;:32:::0;74907:117::o;66442:260::-;-1:-1:-1;;;;;65034:26:0;;66514:7;65034:26;;;:19;:26;;;;;;66514:7;;66558:30;;-1:-1:-1;;;66558:30:0;;66582:4;66558:30;;;10424:51:1;-1:-1:-1;;;;;66558:15:0;;;;;10397:18:1;;66558:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;:53;;;;:::i;:::-;-1:-1:-1;;;;;65738:21:0;;;65711:7;65738:21;;;:14;:21;;;;;;;;:30;;;;;;;;;;66534:77;;-1:-1:-1;66629:65:0;;66645:7;;66534:77;;66216:15;:58::i;66629:65::-;66622:72;66442:260;-1:-1:-1;;;;66442:260:0:o;73898:302::-;27576:4;27600:16;;;:7;:16;;;;;;74017:13;;-1:-1:-1;;;;;27600:16:0;74048:61;;;;-1:-1:-1;;;74048:61:0;;13848:2:1;74048:61:0;;;13830:21:1;13887:2;13867:18;;;13860:30;13926:33;13906:18;;;13899:61;13977:18;;74048:61:0;13646:355:1;74048:61:0;74153:7;74162:19;:8;:17;:19::i;:::-;74136:55;;;;;;;;;:::i;:::-;;;;;;;;;;;;;74122:70;;73898:302;;;:::o;71877:1434::-;71976:6;;;;71975:7;71967:36;;;;-1:-1:-1;;;71967:36:0;;17396:2:1;71967:36:0;;;17378:21:1;17435:2;17415:18;;;17408:30;-1:-1:-1;;;17454:18:1;;;17447:46;17510:18;;71967:36:0;17194:340:1;71967:36:0;72033:18;72018:11;;;;:33;;;;;;;;:::i;:::-;;72010:76;;;;-1:-1:-1;;;72010:76:0;;22415:2:1;72010:76:0;;;22397:21:1;22454:2;22434:18;;;22427:30;22493:32;22473:18;;;22466:60;22543:18;;72010:76:0;22213:354:1;72010:76:0;72101:33;72115:10;72127:6;;72101:13;:33::i;:::-;72093:69;;;;-1:-1:-1;;;72093:69:0;;19331:2:1;72093:69:0;;;19313:21:1;19370:2;19350:18;;;19343:30;19409:25;19389:18;;;19382:53;19452:18;;72093:69:0;19129:347:1;72093:69:0;72191:1;72177:11;:15;72169:59;;;;-1:-1:-1;;;72169:59:0;;21642:2:1;72169:59:0;;;21624:21:1;21681:2;21661:18;;;21654:30;21720:33;21700:18;;;21693:61;21771:18;;72169:59:0;21440:355:1;72169:59:0;72258:10;;72243:11;:25;;72235:88;;;;-1:-1:-1;;;72235:88:0;;23964:2:1;72235:88:0;;;23946:21:1;24003:2;23983:18;;;23976:30;24042:34;24022:18;;;24015:62;-1:-1:-1;;;24093:18:1;;;24086:48;24151:19;;72235:88:0;23762:414:1;72235:88:0;72330:11;72344:13;35394:10;:17;;35306:113;72344:13;72396:9;;72330:27;;-1:-1:-1;72372:20:0;72381:11;72330:27;72372:20;:::i;:::-;:33;;72364:66;;;;-1:-1:-1;;;72364:66:0;;27144:2:1;72364:66:0;;;27126:21:1;27183:2;27163:18;;;27156:30;-1:-1:-1;;;27202:18:1;;;27195:50;27262:18;;72364:66:0;26942:344:1;72364:66:0;41877:6;;-1:-1:-1;;;;;41877:6:0;72443:10;:21;72439:766;;72497:7;;72480:9;;:13;;72492:1;72480:13;:::i;:::-;:24;72477:514;;72538:10;72526:23;;;;:11;:23;;;;;;;;72521:343;;72612:4;;72591:18;72598:11;72612:4;72591:18;:::i;:::-;:25;;;;:::i;:::-;72578:9;:38;;72570:86;;;;-1:-1:-1;;;72570:86:0;;;;;;;:::i;:::-;72687:10;72675:23;;;;:11;:23;;;;;:30;;-1:-1:-1;;72675:30:0;72701:4;72675:30;;;;;;72714:9;:14;;72701:4;;72714:9;;:14;;72701:4;;72714:14;:::i;:::-;;;;-1:-1:-1;72477:514:0;;-1:-1:-1;72477:514:0;72521:343;72797:11;72790:4;;:18;;;;:::i;:::-;72777:9;:31;;72769:79;;;;-1:-1:-1;;;72769:79:0;;;;;;;:::i;:::-;72477:514;;;72928:11;72921:4;;:18;;;;:::i;:::-;72908:9;:31;;72900:79;;;;-1:-1:-1;;;72900:79:0;;;;;;;:::i;:::-;73004:14;;:19;73001:197;;73090:14;;73061:10;73048:24;;;;:12;:24;;;;;;:38;;73075:11;;73048:38;:::i;:::-;:56;;73040:92;;;;-1:-1:-1;;;73040:92:0;;20929:2:1;73040:92:0;;;20911:21:1;20968:2;20948:18;;;20941:30;-1:-1:-1;;;20987:18:1;;;20980:53;21050:18;;73040:92:0;20727:347:1;73040:92:0;73160:10;73147:24;;;;:12;:24;;;;;:39;;73175:11;;73147:24;:39;;73175:11;;73147:39;:::i;:::-;;;;-1:-1:-1;;73001:197:0;73230:1;73213:93;73238:11;73233:1;:16;73213:93;;73265:33;73275:10;73287;73296:1;73287:6;:10;:::i;73265:33::-;73251:3;;;;:::i;:::-;;;;73213:93;;;;71960:1351;71877:1434;;;:::o;74698:92::-;41877:6;;-1:-1:-1;;;;;41877:6:0;20167:10;42024:23;42016:68;;;;-1:-1:-1;;;42016:68:0;;;;;;;:::i;:::-;74764:7:::1;:18:::0;74698:92::o;42704:192::-;41877:6;;-1:-1:-1;;;;;41877:6:0;20167:10;42024:23;42016:68;;;;-1:-1:-1;;;42016:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;42793:22:0;::::1;42785:73;;;::::0;-1:-1:-1;;;42785:73:0;;15039:2:1;42785:73:0::1;::::0;::::1;15021:21:1::0;15078:2;15058:18;;;15051:30;15117:34;15097:18;;;15090:62;-1:-1:-1;;;15168:18:1;;;15161:36;15214:19;;42785:73:0::1;14837:402:1::0;42785:73:0::1;42869:19;42879:8;42869:9;:19::i;74595:95::-:0;41877:6;;-1:-1:-1;;;;;41877:6:0;20167:10;42024:23;42016:68;;;;-1:-1:-1;;;42016:68:0;;;;;;;:::i;:::-;74676:5:::1;74671:11;;;;;;;;:::i;:::-;74657;:25:::0;;-1:-1:-1;;74657:25:0::1;::::0;;::::1;::::0;::::1;;;;;;:::i;:::-;;;;;;74595:95:::0;:::o;21613:305::-;21715:4;-1:-1:-1;;;;;;21752:40:0;;-1:-1:-1;;;21752:40:0;;:105;;-1:-1:-1;;;;;;;21809:48:0;;-1:-1:-1;;;21809:48:0;21752:105;:158;;;-1:-1:-1;;;;;;;;;;7553:40:0;;;21874:36;7444:157;31493:174;31568:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;31568:29:0;-1:-1:-1;;;;;31568:29:0;;;;;;;;:24;;31622:23;31568:24;31622:14;:23::i;:::-;-1:-1:-1;;;;;31613:46:0;;;;;;;;;;;31493:174;;:::o;11766:317::-;11881:6;11856:21;:31;;11848:73;;;;-1:-1:-1;;;11848:73:0;;17741:2:1;11848:73:0;;;17723:21:1;17780:2;17760:18;;;17753:30;17819:31;17799:18;;;17792:59;17868:18;;11848:73:0;17539:353:1;11848:73:0;11935:12;11953:9;-1:-1:-1;;;;;11953:14:0;11975:6;11953:33;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;11934:52;;;12005:7;11997:78;;;;-1:-1:-1;;;11997:78:0;;16969:2:1;11997:78:0;;;16951:21:1;17008:2;16988:18;;;16981:30;17047:34;17027:18;;;17020:62;17118:28;17098:18;;;17091:56;17164:19;;11997:78:0;16767:422:1;27805:348:0;27898:4;27600:16;;;:7;:16;;;;;;-1:-1:-1;;;;;27600:16:0;27915:73;;;;-1:-1:-1;;;27915:73:0;;18506:2:1;27915:73:0;;;18488:21:1;18545:2;18525:18;;;18518:30;18584:34;18564:18;;;18557:62;-1:-1:-1;;;18635:18:1;;;18628:42;18687:19;;27915:73:0;18304:408:1;27915:73:0;27999:13;28015:23;28030:7;28015:14;:23::i;:::-;27999:39;;28068:5;-1:-1:-1;;;;;28057:16:0;:7;-1:-1:-1;;;;;28057:16:0;;:51;;;;28101:7;-1:-1:-1;;;;;28077:31:0;:20;28089:7;28077:11;:20::i;:::-;-1:-1:-1;;;;;28077:31:0;;28057:51;:87;;;-1:-1:-1;;;;;;24897:25:0;;;24873:4;24897:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;28112:32;24776:164;30797:578;30956:4;-1:-1:-1;;;;;30929:31:0;:23;30944:7;30929:14;:23::i;:::-;-1:-1:-1;;;;;30929:31:0;;30921:85;;;;-1:-1:-1;;;30921:85:0;;23135:2:1;30921:85:0;;;23117:21:1;23174:2;23154:18;;;23147:30;23213:34;23193:18;;;23186:62;-1:-1:-1;;;23264:18:1;;;23257:39;23313:19;;30921:85:0;22933:405:1;30921:85:0;-1:-1:-1;;;;;31025:16:0;;31017:65;;;;-1:-1:-1;;;31017:65:0;;16210:2:1;31017:65:0;;;16192:21:1;16249:2;16229:18;;;16222:30;16288:34;16268:18;;;16261:62;-1:-1:-1;;;16339:18:1;;;16332:34;16383:19;;31017:65:0;16008:400:1;31017:65:0;31095:39;31116:4;31122:2;31126:7;31095:20;:39::i;:::-;31199:29;31216:1;31220:7;31199:8;:29::i;:::-;-1:-1:-1;;;;;31241:15:0;;;;;;:9;:15;;;;;:20;;31260:1;;31241:15;:20;;31260:1;;31241:20;:::i;:::-;;;;-1:-1:-1;;;;;;;31272:13:0;;;;;;:9;:13;;;;;:18;;31289:1;;31272:13;:18;;31289:1;;31272:18;:::i;:::-;;;;-1:-1:-1;;31301:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;31301:21:0;-1:-1:-1;;;;;31301:21:0;;;;;;;;;31340:27;;31301:16;;31340:27;;;;;;;30797:578;;;:::o;57381:211::-;57525:58;;;-1:-1:-1;;;;;10686:32:1;;57525:58:0;;;10668:51:1;10735:18;;;;10728:34;;;57525:58:0;;;;;;;;;;10641:18:1;;;;57525:58:0;;;;;;;;-1:-1:-1;;;;;57525:58:0;-1:-1:-1;;;57525:58:0;;;57498:86;;57518:5;;57498:19;:86::i;76490:189::-;76597:4;76626:45;76645:6;76653:10;;76665:5;76626:18;:45::i;42904:173::-;42979:6;;;-1:-1:-1;;;;;42996:17:0;;;-1:-1:-1;;;;;;42996:17:0;;;;;;;43029:40;;42979:6;;;42996:17;42979:6;;43029:40;;42960:16;;43029:40;42949:128;42904:173;:::o;28495:110::-;28571:26;28581:2;28585:7;28571:26;;;;;;;;;;;;:9;:26::i;68811:248::-;69021:12;;-1:-1:-1;;;;;69001:16:0;;68957:7;69001:16;;;:7;:16;;;;;;68957:7;;69036:15;;68985:32;;:13;:32;:::i;:::-;68984:49;;;;:::i;:::-;:67;;;;:::i;26883:315::-;27040:28;27050:4;27056:2;27060:7;27040:9;:28::i;:::-;27087:48;27110:4;27116:2;27120:7;27129:5;27087:22;:48::i;:::-;27079:111;;;;-1:-1:-1;;;27079:111:0;;;;;;;:::i;7919:723::-;7975:13;8196:10;8192:53;;-1:-1:-1;;8223:10:0;;;;;;;;;;;;-1:-1:-1;;;8223:10:0;;;;;7919:723::o;8192:53::-;8270:5;8255:12;8311:78;8318:9;;8311:78;;8344:8;;;;:::i;:::-;;-1:-1:-1;8367:10:0;;-1:-1:-1;8375:2:0;8367:10;;:::i;:::-;;;8311:78;;;8399:19;8431:6;8421:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8421:17:0;;8399:39;;8449:154;8456:10;;8449:154;;8483:11;8493:1;8483:11;;:::i;:::-;;-1:-1:-1;8552:10:0;8560:2;8552:5;:10;:::i;:::-;8539:24;;:2;:24;:::i;:::-;8526:39;;8509:6;8516;8509:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;8509:56:0;;;;;;;;-1:-1:-1;8580:11:0;8589:2;8580:11;;:::i;:::-;;;8449:154;;36342:589;-1:-1:-1;;;;;36548:18:0;;36544:187;;36583:40;36615:7;37758:10;:17;;37731:24;;;;:15;:24;;;;;:44;;;37786:24;;;;;;;;;;;;37654:164;36583:40;36544:187;;;36653:2;-1:-1:-1;;;;;36645:10:0;:4;-1:-1:-1;;;;;36645:10:0;;36641:90;;36672:47;36705:4;36711:7;36672:32;:47::i;:::-;-1:-1:-1;;;;;36745:16:0;;36741:183;;36778:45;36815:7;36778:36;:45::i;36741:183::-;36851:4;-1:-1:-1;;;;;36845:10:0;:2;-1:-1:-1;;;;;36845:10:0;;36841:83;;36872:40;36900:2;36904:7;36872:27;:40::i;60448:716::-;60872:23;60898:69;60926:4;60898:69;;;;;;;;;;;;;;;;;60906:5;-1:-1:-1;;;;;60898:27:0;;;:69;;;;;:::i;:::-;60982:17;;60872:95;;-1:-1:-1;60982:21:0;60978:179;;61079:10;61068:30;;;;;;;;;;;;:::i;:::-;61060:85;;;;-1:-1:-1;;;61060:85:0;;26733:2:1;61060:85:0;;;26715:21:1;26772:2;26752:18;;;26745:30;26811:34;26791:18;;;26784:62;-1:-1:-1;;;26862:18:1;;;26855:40;26912:19;;61060:85:0;26531:406:1;44142:190:0;44267:4;44320;44291:25;44304:5;44311:4;44291:12;:25::i;:::-;:33;;44142:190;-1:-1:-1;;;;44142:190:0:o;28832:321::-;28962:18;28968:2;28972:7;28962:5;:18::i;:::-;29013:54;29044:1;29048:2;29052:7;29061:5;29013:22;:54::i;:::-;28991:154;;;;-1:-1:-1;;;28991:154:0;;;;;;;:::i;32232:799::-;32387:4;-1:-1:-1;;;;;32408:13:0;;10767:20;10815:8;32404:620;;32444:72;;-1:-1:-1;;;32444:72:0;;-1:-1:-1;;;;;32444:36:0;;;;;:72;;20167:10;;32495:4;;32501:7;;32510:5;;32444:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;32444:72:0;;;;;;;;-1:-1:-1;;32444:72:0;;;;;;;;;;;;:::i;:::-;;;32440:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;32686:13:0;;32682:272;;32729:60;;-1:-1:-1;;;32729:60:0;;;;;;;:::i;32682:272::-;32904:6;32898:13;32889:6;32885:2;32881:15;32874:38;32440:529;-1:-1:-1;;;;;;32567:51:0;-1:-1:-1;;;32567:51:0;;-1:-1:-1;32560:58:0;;32404:620;-1:-1:-1;33008:4:0;32232:799;;;;;;:::o;38445:988::-;38711:22;38761:1;38736:22;38753:4;38736:16;:22::i;:::-;:26;;;;:::i;:::-;38773:18;38794:26;;;:17;:26;;;;;;38711:51;;-1:-1:-1;38927:28:0;;;38923:328;;-1:-1:-1;;;;;38994:18:0;;38972:19;38994:18;;;:12;:18;;;;;;;;:34;;;;;;;;;39045:30;;;;;;:44;;;39162:30;;:17;:30;;;;;:43;;;38923:328;-1:-1:-1;39347:26:0;;;;:17;:26;;;;;;;;39340:33;;;-1:-1:-1;;;;;39391:18:0;;;;;:12;:18;;;;;:34;;;;;;;39384:41;38445:988::o;39728:1079::-;40006:10;:17;39981:22;;40006:21;;40026:1;;40006:21;:::i;:::-;40038:18;40059:24;;;:15;:24;;;;;;40432:10;:26;;39981:46;;-1:-1:-1;40059:24:0;;39981:46;;40432:26;;;;;;:::i;:::-;;;;;;;;;40410:48;;40496:11;40471:10;40482;40471:22;;;;;;;;:::i;:::-;;;;;;;;;;;;:36;;;;40576:28;;;:15;:28;;;;;;;:41;;;40748:24;;;;;40741:31;40783:10;:16;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;39799:1008;;;39728:1079;:::o;37232:221::-;37317:14;37334:20;37351:2;37334:16;:20::i;:::-;-1:-1:-1;;;;;37365:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;37410:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;37232:221:0:o;13250:229::-;13387:12;13419:52;13441:6;13449:4;13455:1;13458:12;13419:21;:52::i;45009:296::-;45092:7;45135:4;45092:7;45150:118;45174:5;:12;45170:1;:16;45150:118;;;45223:33;45233:12;45247:5;45253:1;45247:8;;;;;;;;:::i;:::-;;;;;;;45223:9;:33::i;:::-;45208:48;-1:-1:-1;45188:3:0;;;;:::i;:::-;;;;45150:118;;29489:382;-1:-1:-1;;;;;29569:16:0;;29561:61;;;;-1:-1:-1;;;29561:61:0;;21281:2:1;29561:61:0;;;21263:21:1;;;21300:18;;;21293:30;21359:34;21339:18;;;21332:62;21411:18;;29561:61:0;21079:356:1;29561:61:0;27576:4;27600:16;;;:7;:16;;;;;;-1:-1:-1;;;;;27600:16:0;:30;29633:58;;;;-1:-1:-1;;;29633:58:0;;15446:2:1;29633:58:0;;;15428:21:1;15485:2;15465:18;;;15458:30;15524;15504:18;;;15497:58;15572:18;;29633:58:0;15244:352:1;29633:58:0;29704:45;29733:1;29737:2;29741:7;29704:20;:45::i;:::-;-1:-1:-1;;;;;29762:13:0;;;;;;:9;:13;;;;;:18;;29779:1;;29762:13;:18;;29779:1;;29762:18;:::i;:::-;;;;-1:-1:-1;;29791:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;29791:21:0;-1:-1:-1;;;;;29791:21:0;;;;;;;;29830:33;;29791:16;;;29830:33;;29791:16;;29830:33;29489:382;;:::o;14370:510::-;14540:12;14598:5;14573:21;:30;;14565:81;;;;-1:-1:-1;;;14565:81:0;;18099:2:1;14565:81:0;;;18081:21:1;18138:2;18118:18;;;18111:30;18177:34;18157:18;;;18150:62;-1:-1:-1;;;18228:18:1;;;18221:36;18274:19;;14565:81:0;17897:402:1;14565:81:0;10767:20;;14657:60;;;;-1:-1:-1;;;14657:60:0;;25558:2:1;14657:60:0;;;25540:21:1;25597:2;25577:18;;;25570:30;25636:31;25616:18;;;25609:59;25685:18;;14657:60:0;25356:353:1;14657:60:0;14731:12;14745:23;14772:6;-1:-1:-1;;;;;14772:11:0;14791:5;14798:4;14772:31;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;14730:73;;;;14821:51;14838:7;14847:10;14859:12;14821:16;:51::i;:::-;14814:58;14370:510;-1:-1:-1;;;;;;;14370:510:0:o;51216:149::-;51279:7;51310:1;51306;:5;:51;;51441:13;51535:15;;;51571:4;51564:15;;;51618:4;51602:21;;51306:51;;;51441:13;51535:15;;;51571:4;51564:15;;;51618:4;51602:21;;51314:20;51373:268;17056:712;17206:12;17235:7;17231:530;;;-1:-1:-1;17266:10:0;17259:17;;17231:530;17380:17;;:21;17376:374;;17578:10;17572:17;17639:15;17626:10;17622:2;17618:19;17611:44;17376:374;17721:12;17714:20;;-1:-1:-1;;;17714:20:0;;;;;;;;:::i;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;14:631:1;78:5;108:18;149:2;141:6;138:14;135:40;;;155:18;;:::i;:::-;230:2;224:9;198:2;284:15;;-1:-1:-1;;280:24:1;;;306:2;276:33;272:42;260:55;;;330:18;;;350:22;;;327:46;324:72;;;376:18;;:::i;:::-;416:10;412:2;405:22;445:6;436:15;;475:6;467;460:22;515:3;506:6;501:3;497:16;494:25;491:45;;;532:1;529;522:12;491:45;582:6;577:3;570:4;562:6;558:17;545:44;637:1;630:4;621:6;613;609:19;605:30;598:41;;;;14:631;;;;;:::o;650:367::-;713:8;723:6;777:3;770:4;762:6;758:17;754:27;744:55;;795:1;792;785:12;744:55;-1:-1:-1;818:20:1;;861:18;850:30;;847:50;;;893:1;890;883:12;847:50;930:4;922:6;918:17;906:29;;990:3;983:4;973:6;970:1;966:14;958:6;954:27;950:38;947:47;944:67;;;1007:1;1004;997:12;944:67;650:367;;;;;:::o;1022:247::-;1081:6;1134:2;1122:9;1113:7;1109:23;1105:32;1102:52;;;1150:1;1147;1140:12;1102:52;1189:9;1176:23;1208:31;1233:5;1208:31;:::i;1534:388::-;1602:6;1610;1663:2;1651:9;1642:7;1638:23;1634:32;1631:52;;;1679:1;1676;1669:12;1631:52;1718:9;1705:23;1737:31;1762:5;1737:31;:::i;:::-;1787:5;-1:-1:-1;1844:2:1;1829:18;;1816:32;1857:33;1816:32;1857:33;:::i;:::-;1909:7;1899:17;;;1534:388;;;;;:::o;1927:456::-;2004:6;2012;2020;2073:2;2061:9;2052:7;2048:23;2044:32;2041:52;;;2089:1;2086;2079:12;2041:52;2128:9;2115:23;2147:31;2172:5;2147:31;:::i;:::-;2197:5;-1:-1:-1;2254:2:1;2239:18;;2226:32;2267:33;2226:32;2267:33;:::i;:::-;1927:456;;2319:7;;-1:-1:-1;;;2373:2:1;2358:18;;;;2345:32;;1927:456::o;2388:794::-;2483:6;2491;2499;2507;2560:3;2548:9;2539:7;2535:23;2531:33;2528:53;;;2577:1;2574;2567:12;2528:53;2616:9;2603:23;2635:31;2660:5;2635:31;:::i;:::-;2685:5;-1:-1:-1;2742:2:1;2727:18;;2714:32;2755:33;2714:32;2755:33;:::i;:::-;2807:7;-1:-1:-1;2861:2:1;2846:18;;2833:32;;-1:-1:-1;2916:2:1;2901:18;;2888:32;2943:18;2932:30;;2929:50;;;2975:1;2972;2965:12;2929:50;2998:22;;3051:4;3043:13;;3039:27;-1:-1:-1;3029:55:1;;3080:1;3077;3070:12;3029:55;3103:73;3168:7;3163:2;3150:16;3145:2;3141;3137:11;3103:73;:::i;:::-;3093:83;;;2388:794;;;;;;;:::o;3187:572::-;3282:6;3290;3298;3351:2;3339:9;3330:7;3326:23;3322:32;3319:52;;;3367:1;3364;3357:12;3319:52;3406:9;3393:23;3425:31;3450:5;3425:31;:::i;:::-;3475:5;-1:-1:-1;3531:2:1;3516:18;;3503:32;3558:18;3547:30;;3544:50;;;3590:1;3587;3580:12;3544:50;3629:70;3691:7;3682:6;3671:9;3667:22;3629:70;:::i;:::-;3187:572;;3718:8;;-1:-1:-1;3603:96:1;;-1:-1:-1;;;;3187:572:1:o;3764:382::-;3829:6;3837;3890:2;3878:9;3869:7;3865:23;3861:32;3858:52;;;3906:1;3903;3896:12;3858:52;3945:9;3932:23;3964:31;3989:5;3964:31;:::i;:::-;4014:5;-1:-1:-1;4071:2:1;4056:18;;4043:32;4084:30;4043:32;4084:30;:::i;4151:315::-;4219:6;4227;4280:2;4268:9;4259:7;4255:23;4251:32;4248:52;;;4296:1;4293;4286:12;4248:52;4335:9;4322:23;4354:31;4379:5;4354:31;:::i;:::-;4404:5;4456:2;4441:18;;;;4428:32;;-1:-1:-1;;;4151:315:1:o;4471:241::-;4527:6;4580:2;4568:9;4559:7;4555:23;4551:32;4548:52;;;4596:1;4593;4586:12;4548:52;4635:9;4622:23;4654:28;4676:5;4654:28;:::i;4717:245::-;4784:6;4837:2;4825:9;4816:7;4812:23;4808:32;4805:52;;;4853:1;4850;4843:12;4805:52;4885:9;4879:16;4904:28;4926:5;4904:28;:::i;4967:180::-;5026:6;5079:2;5067:9;5058:7;5054:23;5050:32;5047:52;;;5095:1;5092;5085:12;5047:52;-1:-1:-1;5118:23:1;;4967:180;-1:-1:-1;4967:180:1:o;5152:245::-;5210:6;5263:2;5251:9;5242:7;5238:23;5234:32;5231:52;;;5279:1;5276;5269:12;5231:52;5318:9;5305:23;5337:30;5361:5;5337:30;:::i;5402:249::-;5471:6;5524:2;5512:9;5503:7;5499:23;5495:32;5492:52;;;5540:1;5537;5530:12;5492:52;5572:9;5566:16;5591:30;5615:5;5591:30;:::i;6331:450::-;6400:6;6453:2;6441:9;6432:7;6428:23;6424:32;6421:52;;;6469:1;6466;6459:12;6421:52;6509:9;6496:23;6542:18;6534:6;6531:30;6528:50;;;6574:1;6571;6564:12;6528:50;6597:22;;6650:4;6642:13;;6638:27;-1:-1:-1;6628:55:1;;6679:1;6676;6669:12;6628:55;6702:73;6767:7;6762:2;6749:16;6744:2;6740;6736:11;6702:73;:::i;6971:184::-;7041:6;7094:2;7082:9;7073:7;7069:23;7065:32;7062:52;;;7110:1;7107;7100:12;7062:52;-1:-1:-1;7133:16:1;;6971:184;-1:-1:-1;6971:184:1:o;7160:505::-;7255:6;7263;7271;7324:2;7312:9;7303:7;7299:23;7295:32;7292:52;;;7340:1;7337;7330:12;7292:52;7376:9;7363:23;7353:33;;7437:2;7426:9;7422:18;7409:32;7464:18;7456:6;7453:30;7450:50;;;7496:1;7493;7486:12;7670:268;7722:3;7760:5;7754:12;7787:6;7782:3;7775:19;7803:63;7859:6;7852:4;7847:3;7843:14;7836:4;7829:5;7825:16;7803:63;:::i;:::-;7920:2;7899:15;-1:-1:-1;;7895:29:1;7886:39;;;;7927:4;7882:50;;7670:268;-1:-1:-1;;7670:268:1:o;7943:184::-;7984:3;8022:5;8016:12;8037:52;8082:6;8077:3;8070:4;8063:5;8059:16;8037:52;:::i;:::-;8105:16;;;;;7943:184;-1:-1:-1;;7943:184:1:o;8484:274::-;8613:3;8651:6;8645:13;8667:53;8713:6;8708:3;8701:4;8693:6;8689:17;8667:53;:::i;:::-;8736:16;;;;;8484:274;-1:-1:-1;;8484:274:1:o;8763:1300::-;9040:3;9069:1;9102:6;9096:13;9132:3;9154:1;9182:9;9178:2;9174:18;9164:28;;9242:2;9231:9;9227:18;9264;9254:61;;9308:4;9300:6;9296:17;9286:27;;9254:61;9334:2;9382;9374:6;9371:14;9351:18;9348:38;9345:165;;;-1:-1:-1;;;9409:33:1;;9465:4;9462:1;9455:15;9495:4;9416:3;9483:17;9345:165;9526:18;9553:104;;;;9671:1;9666:320;;;;9519:467;;9553:104;-1:-1:-1;;9586:24:1;;9574:37;;9631:16;;;;-1:-1:-1;9553:104:1;;9666:320;27546:1;27539:14;;;27583:4;27570:18;;9761:1;9775:165;9789:6;9786:1;9783:13;9775:165;;;9867:14;;9854:11;;;9847:35;9910:16;;;;9804:10;;9775:165;;;9779:3;;9969:6;9964:3;9960:16;9953:23;;9519:467;;;;;;;10002:55;10027:29;10052:3;10044:6;10027:29;:::i;:::-;-1:-1:-1;;;8192:20:1;;8237:1;8228:11;;8132:113;10002:55;9995:62;8763:1300;-1:-1:-1;;;;;8763:1300:1:o;10773:499::-;-1:-1:-1;;;;;11042:15:1;;;11024:34;;11094:15;;11089:2;11074:18;;11067:43;11141:2;11126:18;;11119:34;;;11189:3;11184:2;11169:18;;11162:31;;;10967:4;;11210:56;;11246:19;;11238:6;11210:56;:::i;:::-;11202:64;10773:499;-1:-1:-1;;;;;;10773:499:1:o;11556:497::-;11738:3;11723:19;;11727:9;11819:6;11696:4;11853:194;11867:4;11864:1;11861:11;11853:194;;;11926:13;;11914:26;;11963:4;11987:12;;;;12022:15;;;;11887:1;11880:9;11853:194;;;11857:3;;;11556:497;;;;:::o;12058:632::-;12229:2;12281:21;;;12351:13;;12254:18;;;12373:22;;;12200:4;;12229:2;12452:15;;;;12426:2;12411:18;;;12200:4;12495:169;12509:6;12506:1;12503:13;12495:169;;;12570:13;;12558:26;;12639:15;;;;12604:12;;;;12531:1;12524:9;12495:169;;;-1:-1:-1;12681:3:1;;12058:632;-1:-1:-1;;;;;;12058:632:1:o;13069:337::-;13210:2;13195:18;;13243:1;13232:13;;13222:144;;13288:10;13283:3;13279:20;13276:1;13269:31;13323:4;13320:1;13313:15;13351:4;13348:1;13341:15;13222:144;13375:25;;;13069:337;:::o;13411:230::-;13560:2;13549:9;13542:21;13523:4;13580:55;13631:2;13620:9;13616:18;13608:6;13580:55;:::i;14418:414::-;14620:2;14602:21;;;14659:2;14639:18;;;14632:30;14698:34;14693:2;14678:18;;14671:62;-1:-1:-1;;;14764:2:1;14749:18;;14742:48;14822:3;14807:19;;14418:414::o;15601:402::-;15803:2;15785:21;;;15842:2;15822:18;;;15815:30;15881:34;15876:2;15861:18;;15854:62;-1:-1:-1;;;15947:2:1;15932:18;;15925:36;15993:3;15978:19;;15601:402::o;18717:407::-;18919:2;18901:21;;;18958:2;18938:18;;;18931:30;18997:34;18992:2;18977:18;;18970:62;-1:-1:-1;;;19063:2:1;19048:18;;19041:41;19114:3;19099:19;;18717:407::o;22572:356::-;22774:2;22756:21;;;22793:18;;;22786:30;22852:34;22847:2;22832:18;;22825:62;22919:2;22904:18;;22572:356::o;24938:413::-;25140:2;25122:21;;;25179:2;25159:18;;;25152:30;25218:34;25213:2;25198:18;;25191:62;-1:-1:-1;;;25284:2:1;25269:18;;25262:47;25341:3;25326:19;;24938:413::o;25714:399::-;25916:2;25898:21;;;25955:2;25935:18;;;25928:30;25994:34;25989:2;25974:18;;25967:62;-1:-1:-1;;;26060:2:1;26045:18;;26038:33;26103:3;26088:19;;25714:399::o;27599:128::-;27639:3;27670:1;27666:6;27663:1;27660:13;27657:39;;;27676:18;;:::i;:::-;-1:-1:-1;27712:9:1;;27599:128::o;27732:120::-;27772:1;27798;27788:35;;27803:18;;:::i;:::-;-1:-1:-1;27837:9:1;;27732:120::o;27857:168::-;27897:7;27963:1;27959;27955:6;27951:14;27948:1;27945:21;27940:1;27933:9;27926:17;27922:45;27919:71;;;27970:18;;:::i;:::-;-1:-1:-1;28010:9:1;;27857:168::o;28030:125::-;28070:4;28098:1;28095;28092:8;28089:34;;;28103:18;;:::i;:::-;-1:-1:-1;28140:9:1;;28030:125::o;28160:258::-;28232:1;28242:113;28256:6;28253:1;28250:13;28242:113;;;28332:11;;;28326:18;28313:11;;;28306:39;28278:2;28271:10;28242:113;;;28373:6;28370:1;28367:13;28364:48;;;-1:-1:-1;;28408:1:1;28390:16;;28383:27;28160:258::o;28423:380::-;28502:1;28498:12;;;;28545;;;28566:61;;28620:4;28612:6;28608:17;28598:27;;28566:61;28673:2;28665:6;28662:14;28642:18;28639:38;28636:161;;;28719:10;28714:3;28710:20;28707:1;28700:31;28754:4;28751:1;28744:15;28782:4;28779:1;28772:15;28636:161;;28423:380;;;:::o;28808:135::-;28847:3;-1:-1:-1;;28868:17:1;;28865:43;;;28888:18;;:::i;:::-;-1:-1:-1;28935:1:1;28924:13;;28808:135::o;28948:112::-;28980:1;29006;28996:35;;29011:18;;:::i;:::-;-1:-1:-1;29045:9:1;;28948:112::o;29065:127::-;29126:10;29121:3;29117:20;29114:1;29107:31;29157:4;29154:1;29147:15;29181:4;29178:1;29171:15;29197:127;29258:10;29253:3;29249:20;29246:1;29239:31;29289:4;29286:1;29279:15;29313:4;29310:1;29303:15;29329:127;29390:10;29385:3;29381:20;29378:1;29371:31;29421:4;29418:1;29411:15;29445:4;29442:1;29435:15;29461:127;29522:10;29517:3;29513:20;29510:1;29503:31;29553:4;29550:1;29543:15;29577:4;29574:1;29567:15;29593:127;29654:10;29649:3;29645:20;29642:1;29635:31;29685:4;29682:1;29675:15;29709:4;29706:1;29699:15;29725:127;29786:10;29781:3;29777:20;29774:1;29767:31;29817:4;29814:1;29807:15;29841:4;29838:1;29831:15;29857:131;-1:-1:-1;;;;;29932:31:1;;29922:42;;29912:70;;29978:1;29975;29968:12;29993:118;30079:5;30072:13;30065:21;30058:5;30055:32;30045:60;;30101:1;30098;30091:12;30116:131;-1:-1:-1;;;;;;30190:32:1;;30180:43;;30170:71;;30237:1;30234;30227:12

Swarm Source

ipfs://66075256fb859792af79004502dfb7a2a4814fdea7e88af74e181f8b792bf26e

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