Token

NewDayTomorrow (NDTMRW)

ERC-721

Overview

Max Total Supply

460 NDTMRW

Holders

321

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x326e4987bf4f8086fbe7a2fd8cf7b6f4711c613f

Filtered by Token Holder

0x83E13C8D51e8E3814b4Cd74DB8b4e3A5d2867DdC

Balance

2 NDTMRW

0x83e13c8d51e8e3814b4cd74db8b4e3a5d2867ddc

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

MnemosNFT

Compiler Version

v0.8.4+commit.c7e474f2

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2021-12-06
*/

pragma solidity ^0.8.0;


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


/**
 * @dev Required interface of an ERC721 compliant contract.
 */
interface IERC721 is IERC165 {
    /**
     * @dev Emitted when `tokenId` token is transferred from `from` to `to`.
     */
    event Transfer(address indexed from, address indexed to, uint256 indexed tokenId);

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

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

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

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

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

    /**
     * @dev Transfers `tokenId` token from `from` to `to`.
     *
     * WARNING: Usage of this method is discouraged, use {safeTransferFrom} whenever possible.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     * - If the caller is not `from`, it must be approved to move this token by either {approve} or {setApprovalForAll}.
     *
     * Emits a {Transfer} event.
     */
    function transferFrom(
        address from,
        address to,
        uint256 tokenId
    ) external;

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

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

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

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

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


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


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

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

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


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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

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


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

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

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

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

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


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


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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

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

        _transfer(from, to, tokenId);
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _beforeTokenTransfer(from, to, tokenId);

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

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

        emit Transfer(from, to, tokenId);
    }

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

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

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


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


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


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


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

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

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

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

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

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

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

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

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

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

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

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

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


abstract contract ContextMixin {
    function msgSender()
        internal
        view
        returns (address payable sender)
    {
        if (msg.sender == address(this)) {
            bytes memory array = msg.data;
            uint256 index = msg.data.length;
            assembly {
                // Load the 32 bytes word from memory with the address on the lower 20 bytes, and mask those.
                sender := and(
                    mload(add(array, index)),
                    0xffffffffffffffffffffffffffffffffffffffff
                )
            }
        } else {
            sender = payable(msg.sender);
        }
        return sender;
    }
}

contract Initializable {
    bool inited = false;

    modifier initializer() {
        require(!inited, "already inited");
        _;
        inited = true;
    }
}

contract EIP712Base is Initializable {
    struct EIP712Domain {
        string name;
        string version;
        address verifyingContract;
        bytes32 salt;
    }

    string constant public ERC712_VERSION = "1";

    bytes32 internal constant EIP712_DOMAIN_TYPEHASH = keccak256(
        bytes(
            "EIP712Domain(string name,string version,address verifyingContract,bytes32 salt)"
        )
    );
    bytes32 internal domainSeperator;

    // supposed to be called once while initializing.
    // one of the contracts that inherits this contract follows proxy pattern
    // so it is not possible to do this in a constructor
    function _initializeEIP712(
        string memory name
    )
        internal
        initializer
    {
        _setDomainSeperator(name);
    }

    function _setDomainSeperator(string memory name) internal {
        domainSeperator = keccak256(
            abi.encode(
                EIP712_DOMAIN_TYPEHASH,
                keccak256(bytes(name)),
                keccak256(bytes(ERC712_VERSION)),
                address(this),
                bytes32(getChainId())
            )
        );
    }

    function getDomainSeperator() public view returns (bytes32) {
        return domainSeperator;
    }

    function getChainId() public view returns (uint256) {
        uint256 id;
        assembly {
            id := chainid()
        }
        return id;
    }

    /**
     * Accept message hash and returns hash message in EIP712 compatible form
     * So that it can be used to recover signer from signature signed using EIP712 formatted data
     * https://eips.ethereum.org/EIPS/eip-712
     * "\\x19" makes the encoding deterministic
     * "\\x01" is the version byte to make it compatible to EIP-191
     */
    function toTypedMessageHash(bytes32 messageHash)
        internal
        view
        returns (bytes32)
    {
        return
            keccak256(
                abi.encodePacked("\x19\x01", getDomainSeperator(), messageHash)
            );
    }
}


contract NativeMetaTransaction is EIP712Base {
    using SafeMath for uint256;
    bytes32 private constant META_TRANSACTION_TYPEHASH = keccak256(
        bytes(
            "MetaTransaction(uint256 nonce,address from,bytes functionSignature)"
        )
    );
    event MetaTransactionExecuted(
        address userAddress,
        address payable relayerAddress,
        bytes functionSignature
    );
    mapping(address => uint256) nonces;

    /*
     * Meta transaction structure.
     * No point of including value field here as if user is doing value transfer then he has the funds to pay for gas
     * He should call the desired function directly in that case.
     */
    struct MetaTransaction {
        uint256 nonce;
        address from;
        bytes functionSignature;
    }

    function executeMetaTransaction(
        address userAddress,
        bytes memory functionSignature,
        bytes32 sigR,
        bytes32 sigS,
        uint8 sigV
    ) public payable returns (bytes memory) {
        MetaTransaction memory metaTx = MetaTransaction({
            nonce: nonces[userAddress],
            from: userAddress,
            functionSignature: functionSignature
        });

        require(
            verify(userAddress, metaTx, sigR, sigS, sigV),
            "Signer and signature do not match"
        );

        // increase nonce for user (to avoid re-use)
        nonces[userAddress] = nonces[userAddress].add(1);

        emit MetaTransactionExecuted(
            userAddress,
            payable(msg.sender),
            functionSignature
        );

        // Append userAddress and relayer address at the end to extract it from calling context
        (bool success, bytes memory returnData) = address(this).call(
            abi.encodePacked(functionSignature, userAddress)
        );
        require(success, "Function call not successful");

        return returnData;
    }

    function hashMetaTransaction(MetaTransaction memory metaTx)
        internal
        pure
        returns (bytes32)
    {
        return
            keccak256(
                abi.encode(
                    META_TRANSACTION_TYPEHASH,
                    metaTx.nonce,
                    metaTx.from,
                    keccak256(metaTx.functionSignature)
                )
            );
    }

    function getNonce(address user) public view returns (uint256 nonce) {
        nonce = nonces[user];
    }

    function verify(
        address signer,
        MetaTransaction memory metaTx,
        bytes32 sigR,
        bytes32 sigS,
        uint8 sigV
    ) internal view returns (bool) {
        require(signer != address(0), "NativeMetaTransaction: INVALID_SIGNER");
        return
            signer ==
            ecrecover(
                toTypedMessageHash(hashMetaTransaction(metaTx)),
                sigV,
                sigR,
                sigS
            );
    }
}


contract OwnableDelegateProxy {}

contract ProxyRegistry {
    mapping(address => OwnableDelegateProxy) public proxies;
}

interface AAA is IERC721Enumerable { }

/**
 * @title MnemosNFT
 * Based on ERC721Tradable - ERC721 contract that whitelists a trading address,
 * and has mint, and limited claim, functionality.
 */
contract MnemosNFT is
    ContextMixin,
    ERC721,
    ERC721Enumerable,
    NativeMetaTransaction,
    Ownable
{
    using SafeMath for uint256;

    address immutable proxyRegistryAddress;
    uint256 public immutable NFTLimit = 999;
    uint256 public immutable redemptionBuyLimit = 261;
    uint256 public immutable PRICE = 0.08 ether;
    uint256 public boughtCount = 0;
    uint256 private _currentTokenId = 0;
    address payable private payee;

    uint256 immutable public redemptionStartTimestamp = 1638831600; //Mon 6th Dec 2021, 18:00 GMT-5
    uint256 immutable public redemptionEndTimestamp = 1639436400; //Mon 13th Dec 2021, 18:00 GMT-5

    AAA[] aaa721s; //recognised
    AAA[] aaa721sNonEnumerable; //non-enumerable

    //recognised AAA contract, to id, to true/false if redeemed
    mapping(AAA => mapping(uint256 => bool)) public isRedeemed;


    struct TokenSet {
        address aaaAddress;
        uint256[] tokenIds;
        bool[] redeemed;
    }

    constructor(
        AAA[] memory aaaAddresses,
        AAA[] memory aaaAddressesNonEnumerable,
        string memory _name,
        string memory _symbol,
        address _proxyRegistryAddress
    ) ERC721(_name, _symbol) {
        proxyRegistryAddress = _proxyRegistryAddress;
        _initializeEIP712(_name);
        aaa721s = aaaAddresses;
        aaa721sNonEnumerable = aaaAddressesNonEnumerable;
        payee = payable(_msgSender());
    }

    function isDuringRedemption() public view returns (bool) {
        return (
            (block.timestamp >= redemptionStartTimestamp) &&
            (block.timestamp < redemptionEndTimestamp)
        );
    }

    /**
     * Convenience function to return all AAA tokens+ids of an address,
     * including if already redeemed.
     * NB: cannot check non-enumerable NFTs
     */
    function tokensForAddress(
        address holder
    ) public view returns (
        TokenSet[] memory
    ) {
        TokenSet[] memory tokensOwned = new TokenSet[](aaa721s.length);
        for (uint256 i=0; i < aaa721s.length; i++) {
            AAA aaa = aaa721s[i];
            uint256 aaaBalance = aaa.balanceOf(holder);
            TokenSet memory tokenSet;
            tokenSet.aaaAddress = address(aaa);
            tokenSet.tokenIds = new uint256[](aaaBalance);
            tokenSet.redeemed = new bool[](aaaBalance);
            for (uint256 j=0; j<aaaBalance; j++) {
                uint256 tokenId = aaa.tokenOfOwnerByIndex(
                    holder,
                    j
                );
                tokenSet.tokenIds[j] = tokenId;
                tokenSet.redeemed[j] = isRedeemed[aaa][tokenId];
            }
            tokensOwned[i] = tokenSet;
        }
        return tokensOwned;
    }

    /**
     * @return redeemer the address of who can successfully redeem this token.
     * @dev fails if given contract is not a recognised AAA NFT, or
     * token doesn't exist.
     * otherwise returns 0 if already redeemed
     */
    function tokenRedeemer(
        AAA tokenContract,
        uint256 tokenId
    ) public view returns (address redeemer) {
        bool isAAA = false;
        for (uint256 i=0; i<aaa721s.length; i++) {
            if (aaa721s[i] == tokenContract) {
                isAAA = true;
                break;
            }
        }
        for (uint256 i=0; i<aaa721sNonEnumerable.length; i++) {
            if (aaa721sNonEnumerable[i] == tokenContract) {
                isAAA = true;
                break;
            }
        }
        require(isAAA, "MnemosNFT: given token not recognised");
        redeemer = address(0);
        if (isRedeemed[tokenContract][tokenId] == false) {
            redeemer = tokenContract.ownerOf(tokenId);
        }
    }

    /**
     * 
     */
    function redeem(
        AAA[] calldata tokenContracts,
        uint256[] calldata tokenIds
    ) public {
        require(isDuringRedemption(), "MnemosNFT: not during redemption period");

        uint256 length = tokenContracts.length;
        require(tokenIds.length == length, "MnemosNFT: array length mismatch");

        uint256 redeemed = 0;

        for (uint256 i=0; i<length; i++) {
            AAA tokenContract = tokenContracts[i];
            uint256 tokenId = tokenIds[i];
            if (tokenRedeemer(tokenContract, tokenId) == _msgSender()) {
                redeemed++;
                isRedeemed[tokenContract][tokenId] = true;
            }
        }

        // mint tokens to redeemer
        mintAmount(_msgSender(), redeemed);
    }

    /**
     * 
     */
    function buy(uint256 amountToBuy) public payable {
        require(block.timestamp >= redemptionStartTimestamp, "MnemosNFT: Sale not started");
        require(amountToBuy < NFTLimit, "MnemosNFT: can only try buy up to supply");
        if (isDuringRedemption()) {
            require(
                boughtCount < redemptionBuyLimit,
                "MnemosNFT: redemption allocation exhausted"
            );
            require(
                boughtCount + amountToBuy <= redemptionBuyLimit,
                "MnemosNFT: supply limited during redemption"
            );
        }
        uint256 cost = amountToBuy * PRICE;
        require(msg.value == cost, "MnemosNFT: incorrect ethers for purchase");
        require(payee.send(cost), "MnemosNFT: payee must take payment");

        // mint tokens to buyer
        mintAmount(_msgSender(), amountToBuy);
        // update bought count
        boughtCount += amountToBuy;
    }

    function setPayeeAddress(
        address payable newPayee
    ) public onlyOwner {
        payee = newPayee;
    }

    function mintAmount(
        address _to,
        uint256 _amount
    ) private {
        require(
            _currentTokenId < NFTLimit,
            "MnemosNFT: all tokens minted"
        );
        require (
            _currentTokenId + _amount <= NFTLimit,
            "MnemosNFT: can only mint to limit"
        );

        for (uint256 i = 0; i < _amount; i++) {
            uint256 newTokenId = _getNextTokenId();
            _mint(_to, newTokenId);
            _incrementTokenId();
        }
    }


    /**
     * @dev Mints a token to an address with a tokenURI.
     * @param _to address of the future owner of the token
     */
    function mintTo(address _to) private {
        uint256 newTokenId = _getNextTokenId();
        _mint(_to, newTokenId);
        _incrementTokenId();
    }

    /**
     * @dev calculates the next token ID based on value of _currentTokenId
     * @return uint256 for the next token ID
     */
    function _getNextTokenId() private view returns (uint256) {
        return _currentTokenId.add(1);
    }

    /**
     * @dev increments the value of _currentTokenId
     */
    function _incrementTokenId() private {
        _currentTokenId++;
    }

    function baseTokenURI() public pure returns (string memory) {
        return "https://futureart.mypinata.cloud/ipfs/QmcpYo3QUYrwopLW1V71xRDfAVV7BXXgx6GruQN4VfeEaj/";
    }

    function tokenURI(uint256 _tokenId) override public pure returns (string memory) {
        return string(abi.encodePacked(baseTokenURI(), Strings.toString(_tokenId)));
    }

    /**
     * Override isApprovedForAll to whitelist user's OpenSea proxy accounts to enable gas-less listings.
     */
    function isApprovedForAll(address tokenOwner, address operator)
        override
        public
        view
        returns (bool)
    {
        // Whitelist OpenSea proxy contract for easy trading.
        ProxyRegistry proxyRegistry = ProxyRegistry(proxyRegistryAddress);
        if (address(proxyRegistry.proxies(tokenOwner)) == operator) {
            return true;
        }

        return super.isApprovedForAll(tokenOwner, operator);
    }

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


    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual override(ERC721Enumerable, ERC721) {
        super._beforeTokenTransfer(from, to, tokenId);
    }

    /**
     * This is used instead of msg.sender as transactions won't be sent by the original token owner, but by OpenSea.
     */
    function _msgSender()
        internal
        override
        view
        returns (address sender)
    {
        return ContextMixin.msgSender();
    }

}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"contract AAA[]","name":"aaaAddresses","type":"address[]"},{"internalType":"contract AAA[]","name":"aaaAddressesNonEnumerable","type":"address[]"},{"internalType":"string","name":"_name","type":"string"},{"internalType":"string","name":"_symbol","type":"string"},{"internalType":"address","name":"_proxyRegistryAddress","type":"address"}],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"address","name":"userAddress","type":"address"},{"indexed":false,"internalType":"address payable","name":"relayerAddress","type":"address"},{"indexed":false,"internalType":"bytes","name":"functionSignature","type":"bytes"}],"name":"MetaTransactionExecuted","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"ERC712_VERSION","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"NFTLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"PRICE","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"baseTokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[],"name":"boughtCount","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"amountToBuy","type":"uint256"}],"name":"buy","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"userAddress","type":"address"},{"internalType":"bytes","name":"functionSignature","type":"bytes"},{"internalType":"bytes32","name":"sigR","type":"bytes32"},{"internalType":"bytes32","name":"sigS","type":"bytes32"},{"internalType":"uint8","name":"sigV","type":"uint8"}],"name":"executeMetaTransaction","outputs":[{"internalType":"bytes","name":"","type":"bytes"}],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getChainId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getDomainSeperator","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"user","type":"address"}],"name":"getNonce","outputs":[{"internalType":"uint256","name":"nonce","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"tokenOwner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"isDuringRedemption","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract AAA","name":"","type":"address"},{"internalType":"uint256","name":"","type":"uint256"}],"name":"isRedeemed","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"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":"contract AAA[]","name":"tokenContracts","type":"address[]"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"}],"name":"redeem","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"redemptionBuyLimit","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"redemptionEndTimestamp","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"redemptionStartTimestamp","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":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"newPayee","type":"address"}],"name":"setPayeeAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"contract AAA","name":"tokenContract","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenRedeemer","outputs":[{"internalType":"address","name":"redeemer","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"pure","type":"function"},{"inputs":[{"internalType":"address","name":"holder","type":"address"}],"name":"tokensForAddress","outputs":[{"components":[{"internalType":"address","name":"aaaAddress","type":"address"},{"internalType":"uint256[]","name":"tokenIds","type":"uint256[]"},{"internalType":"bool[]","name":"redeemed","type":"bool[]"}],"internalType":"struct MnemosNFT.TokenSet[]","name":"","type":"tuple[]"}],"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"}]

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)

00000000000000000000000000000000000000000000000000000000000000a00000000000000000000000000000000000000000000000000000000000000120000000000000000000000000000000000000000000000000000000000000018000000000000000000000000000000000000000000000000000000000000001c0000000000000000000000000a5409ec958c83c3f309868babaca7c86dcb077c10000000000000000000000000000000000000000000000000000000000000003000000000000000000000000d66c2e22c9f89aad07cd5cf2b0649d13002dbca4000000000000000000000000df405ccccbc07f70d36d46dfcbc7ed61c4178d87000000000000000000000000e11780916d8416eddaaa773ac8f75c401e0e7adf0000000000000000000000000000000000000000000000000000000000000002000000000000000000000000175480ca73a514921e6a618aee25ef5b8688eec60000000000000000000000004e1c9422446110bd8555fce323f118cd3e5b7fd5000000000000000000000000000000000000000000000000000000000000000e4e6577446179546f6d6f72726f7700000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000064e44544d52570000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : aaaAddresses (address[]): 0xd66C2e22c9F89aAd07cd5cf2B0649d13002dBca4,0xdf405CcCCBC07f70D36d46dfCBc7ED61c4178d87,0xE11780916D8416EdDAAa773AC8F75c401E0E7ADF
Arg [1] : aaaAddressesNonEnumerable (address[]): 0x175480CA73A514921e6a618AEE25EF5B8688EeC6,0x4e1C9422446110Bd8555Fce323f118cD3E5B7FD5
Arg [2] : _name (string): NewDayTomorrow
Arg [3] : _symbol (string): NDTMRW
Arg [4] : _proxyRegistryAddress (address): 0xa5409ec958C83C3f309868babACA7c86DCB077c1

-----Encoded View---------------
16 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [1] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000180
Arg [3] : 00000000000000000000000000000000000000000000000000000000000001c0
Arg [4] : 000000000000000000000000a5409ec958c83c3f309868babaca7c86dcb077c1
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000003
Arg [6] : 000000000000000000000000d66c2e22c9f89aad07cd5cf2b0649d13002dbca4
Arg [7] : 000000000000000000000000df405ccccbc07f70d36d46dfcbc7ed61c4178d87
Arg [8] : 000000000000000000000000e11780916d8416eddaaa773ac8f75c401e0e7adf
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [10] : 000000000000000000000000175480ca73a514921e6a618aee25ef5b8688eec6
Arg [11] : 0000000000000000000000004e1c9422446110bd8555fce323f118cd3e5b7fd5
Arg [12] : 000000000000000000000000000000000000000000000000000000000000000e
Arg [13] : 4e6577446179546f6d6f72726f77000000000000000000000000000000000000
Arg [14] : 0000000000000000000000000000000000000000000000000000000000000006
Arg [15] : 4e44544d52570000000000000000000000000000000000000000000000000000

Deployed Bytecode Sourcemap

55199:8698:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;63175:179;;;;;;;;;;-1:-1:-1;63175:179:0;;;;;:::i;:::-;;:::i;:::-;;;13312:14:1;;13305:22;13287:41;;13275:2;13260:18;63175:179:0;;;;;;;;20802:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;22361:221::-;;;;;;;;;;-1:-1:-1;22361:221:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;10199:32:1;;;10181:51;;10169:2;10154:18;22361:221:0;10136:102:1;21884:411:0;;;;;;;;;;-1:-1:-1;21884:411:0;;;;;:::i;:::-;;:::i;:::-;;52677:1151;;;;;;:::i;:::-;;:::i;49940:43::-;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;49940:43:0;;;;;55557:30;;;;;;;;;;;;;;;;;;;13485:25:1;;;13473:2;13458:18;55557:30:0;13440:76:1;34314:113:0;;;;;;;;;;-1:-1:-1;34402:10:0;:17;34314:113;;50949:101;;;;;;;;;;-1:-1:-1;51027:15:0;;50949:101;;23251:339;;;;;;;;;;-1:-1:-1;23251:339:0;;;;;:::i;:::-;;:::i;55775:60::-;;;;;;;;;;;;;;;54254:107;;;;;;;;;;-1:-1:-1;54254:107:0;;;;;:::i;:::-;-1:-1:-1;;;;;54341:12:0;54307:13;54341:12;;;:6;:12;;;;;;;54254:107;33982:256;;;;;;;;;;-1:-1:-1;33982:256:0;;;;;:::i;:::-;;:::i;51058:161::-;;;;;;;;;;-1:-1:-1;51172:9:0;51058:161;;60851:119;;;;;;;;;;-1:-1:-1;60851:119:0;;;;;:::i;:::-;;:::i;23661:185::-;;;;;;;;;;-1:-1:-1;23661:185:0;;;;;:::i;:::-;;:::i;34504:233::-;;;;;;;;;;-1:-1:-1;34504:233:0;;;;;:::i;:::-;;:::i;55405:39::-;;;;;;;;;;;;;;;59075:778;;;;;;;;;;-1:-1:-1;59075:778:0;;;;;:::i;:::-;;:::i;57075:940::-;;;;;;;;;;-1:-1:-1;57075:940:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;20496:239::-;;;;;;;;;;-1:-1:-1;20496:239:0;;;;;:::i;:::-;;:::i;20226:208::-;;;;;;;;;;-1:-1:-1;20226:208:0;;;;;:::i;:::-;;:::i;41385:94::-;;;;;;;;;;;;;:::i;55674:62::-;;;;;;;;;;;;;;;56679:213;;;;;;;;;;;;;:::i;55507:43::-;;;;;;;;;;;;;;;40734:87;;;;;;;;;;-1:-1:-1;40807:6:0;;-1:-1:-1;;;;;40807:6:0;40734:87;;55451:49;;;;;;;;;;;;;;;20971:104;;;;;;;;;;;;;:::i;22654:295::-;;;;;;;;;;-1:-1:-1;22654:295:0;;;;;:::i;:::-;;:::i;23917:328::-;;;;;;;;;;-1:-1:-1;23917:328:0;;;;;:::i;:::-;;:::i;62400:175::-;;;;;;;;;;-1:-1:-1;62400:175:0;;;;;:::i;:::-;;:::i;56027:58::-;;;;;;;;;;-1:-1:-1;56027:58:0;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;62219:173;;;;;;;;;;;;;:::i;59888:955::-;;;;;;:::i;:::-;;:::i;58267:773::-;;;;;;;;;;-1:-1:-1;58267:773:0;;;;;:::i;:::-;;:::i;62707:460::-;;;;;;;;;;-1:-1:-1;62707:460:0;;;;;:::i;:::-;;:::i;41634:192::-;;;;;;;;;;-1:-1:-1;41634:192:0;;;;;:::i;:::-;;:::i;63175:179::-;63286:4;63310:36;63334:11;63310:23;:36::i;:::-;63303:43;63175:179;-1:-1:-1;;63175:179:0:o;20802:100::-;20856:13;20889:5;20882:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;20802:100;:::o;22361:221::-;22437:7;25844:16;;;:7;:16;;;;;;-1:-1:-1;;;;;25844:16:0;22457:73;;;;-1:-1:-1;;;22457:73:0;;22890:2:1;22457:73:0;;;22872:21:1;22929:2;22909:18;;;22902:30;22968:34;22948:18;;;22941:62;-1:-1:-1;;;23019:18:1;;;23012:42;23071:19;;22457:73:0;;;;;;;;;-1:-1:-1;22550:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;22550:24:0;;22361:221::o;21884:411::-;21965:13;21981:23;21996:7;21981:14;:23::i;:::-;21965:39;;22029:5;-1:-1:-1;;;;;22023:11:0;:2;-1:-1:-1;;;;;22023:11:0;;;22015:57;;;;-1:-1:-1;;;22015:57:0;;25291:2:1;22015:57:0;;;25273:21:1;25330:2;25310:18;;;25303:30;25369:34;25349:18;;;25342:62;-1:-1:-1;;;25420:18:1;;;25413:31;25461:19;;22015:57:0;25263:223:1;22015:57:0;22123:5;-1:-1:-1;;;;;22107:21:0;:12;:10;:12::i;:::-;-1:-1:-1;;;;;22107:21:0;;:62;;;;22132:37;22149:5;22156:12;:10;:12::i;22132:37::-;22085:168;;;;-1:-1:-1;;;22085:168:0;;20117:2:1;22085:168:0;;;20099:21:1;20156:2;20136:18;;;20129:30;20195:34;20175:18;;;20168:62;20266:26;20246:18;;;20239:54;20310:19;;22085:168:0;20089:246:1;22085:168:0;22266:21;22275:2;22279:7;22266:8;:21::i;:::-;21884:411;;;:::o;52677:1151::-;52935:152;;;52878:12;52935:152;;;;;-1:-1:-1;;;;;52973:19:0;;52903:29;52973:19;;;:6;:19;;;;;;;;;52935:152;;;;;;;;;;;53122:45;52980:11;52935:152;53150:4;53156;53162;53122:6;:45::i;:::-;53100:128;;;;-1:-1:-1;;;53100:128:0;;24483:2:1;53100:128:0;;;24465:21:1;24522:2;24502:18;;;24495:30;24561:34;24541:18;;;24534:62;-1:-1:-1;;;24612:18:1;;;24605:31;24653:19;;53100:128:0;24455:223:1;53100:128:0;-1:-1:-1;;;;;53317:19:0;;;;;;:6;:19;;;;;;:26;;53341:1;53317:23;:26::i;:::-;-1:-1:-1;;;;;53295:19:0;;;;;;:6;:19;;;;;;;:48;;;;53361:126;;;;;53302:11;;53433:10;;53459:17;;53361:126;:::i;:::-;;;;;;;;53598:12;53612:23;53647:4;-1:-1:-1;;;;;53639:18:0;53689:17;53708:11;53672:48;;;;;;;;;:::i;:::-;;;;-1:-1:-1;;53672:48:0;;;;;;;;;;53639:92;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;53597:134;;;;53750:7;53742:48;;;;-1:-1:-1;;;53742:48:0;;17005:2:1;53742:48:0;;;16987:21:1;17044:2;17024:18;;;17017:30;17083;17063:18;;;17056:58;17131:18;;53742:48:0;16977:178:1;53742:48:0;53810:10;52677:1151;-1:-1:-1;;;;;;;;52677:1151:0:o;23251:339::-;23446:41;23465:12;:10;:12::i;:::-;23479:7;23446:18;:41::i;:::-;23438:103;;;;-1:-1:-1;;;23438:103:0;;;;;;;:::i;:::-;23554:28;23564:4;23570:2;23574:7;23554:9;:28::i;33982:256::-;34079:7;34115:23;34132:5;34115:16;:23::i;:::-;34107:5;:31;34099:87;;;;-1:-1:-1;;;34099:87:0;;15355:2:1;34099:87:0;;;15337:21:1;15394:2;15374:18;;;15367:30;15433:34;15413:18;;;15406:62;-1:-1:-1;;;15484:18:1;;;15477:41;15535:19;;34099:87:0;15327:233:1;34099:87:0;-1:-1:-1;;;;;;34204:19:0;;;;;;;;:12;:19;;;;;;;;:26;;;;;;;;;33982:256::o;60851:119::-;40965:12;:10;:12::i;:::-;-1:-1:-1;;;;;40954:23:0;:7;40807:6;;-1:-1:-1;;;;;40807:6:0;;40734:87;40954:7;-1:-1:-1;;;;;40954:23:0;;40946:68;;;;-1:-1:-1;;;40946:68:0;;;;;;;:::i;:::-;60946:5:::1;:16:::0;;-1:-1:-1;;;;;;60946:16:0::1;-1:-1:-1::0;;;;;60946:16:0;;;::::1;::::0;;;::::1;::::0;;60851:119::o;23661:185::-;23799:39;23816:4;23822:2;23826:7;23799:39;;;;;;;;;;;;:16;:39::i;34504:233::-;34579:7;34615:30;34402:10;:17;;34314:113;34615:30;34607:5;:38;34599:95;;;;-1:-1:-1;;;34599:95:0;;26514:2:1;34599:95:0;;;26496:21:1;26553:2;26533:18;;;26526:30;26592:34;26572:18;;;26565:62;-1:-1:-1;;;26643:18:1;;;26636:42;26695:19;;34599:95:0;26486:234:1;34599:95:0;34712:10;34723:5;34712:17;;;;;;-1:-1:-1;;;34712:17:0;;;;;;;;;;;;;;;;;34705:24;;34504:233;;;:::o;59075:778::-;59202:20;:18;:20::i;:::-;59194:72;;;;-1:-1:-1;;;59194:72:0;;21355:2:1;59194:72:0;;;21337:21:1;21394:2;21374:18;;;21367:30;21433:34;21413:18;;;21406:62;-1:-1:-1;;;21484:18:1;;;21477:37;21531:19;;59194:72:0;21327:229:1;59194:72:0;59296:14;59336:25;;;59328:70;;;;-1:-1:-1;;;59328:70:0;;14994:2:1;59328:70:0;;;14976:21:1;;;15013:18;;;15006:30;15072:34;15052:18;;;15045:62;15124:18;;59328:70:0;14966:182:1;59328:70:0;59411:16;59449:9;59444:319;59464:6;59462:1;:8;59444:319;;;59492:17;59512:14;;59527:1;59512:17;;;;;-1:-1:-1;;;59512:17:0;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;59492:37;;59544:15;59562:8;;59571:1;59562:11;;;;;-1:-1:-1;;;59562:11:0;;;;;;;;;;;;;;;59544:29;;59633:12;:10;:12::i;:::-;-1:-1:-1;;;;;59592:53:0;:37;59606:13;59621:7;59592:13;:37::i;:::-;-1:-1:-1;;;;;59592:53:0;;59588:164;;;59666:10;;;;:::i;:::-;-1:-1:-1;;;;;59695:25:0;;;;;;:10;:25;;;;;;;;:34;;;;;;;;:41;;-1:-1:-1;;59695:41:0;59732:4;59695:41;;;59666:10;-1:-1:-1;;59588:164:0;59444:319;;59472:3;;;;;:::i;:::-;;;;59444:319;;;;59811:34;59822:12;:10;:12::i;:::-;59836:8;59811:10;:34::i;:::-;59075:778;;;;;;:::o;57075:940::-;57247:7;:14;57164:17;;57200:29;;57232:30;;;;;;-1:-1:-1;;;57232:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57232:30:0;;;;;;;;;;;;;;;;;57200:62;;57278:9;57273:706;57295:7;:14;57291:18;;57273:706;;;57331:7;57341;57349:1;57341:10;;;;;;-1:-1:-1;;;57341:10:0;;;;;;;;;;;;;;;;;;57387:21;;-1:-1:-1;;;57387:21:0;;-1:-1:-1;;;;;10199:32:1;;;57387:21:0;;;10181:51:1;57341:10:0;;;;-1:-1:-1;57341:10:0;;57387:13;;10154:18:1;;57387:21:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57366:42;;57423:24;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57423:24:0;-1:-1:-1;;;;;57462:34:0;;;;57545:10;57531:25;;;;;;-1:-1:-1;;;57531:25:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;57531:25:0;-1:-1:-1;57511:17:0;;;:45;57602:10;57591:22;;;;;;-1:-1:-1;;;57591:22:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;57591:22:0;-1:-1:-1;57571:17:0;;;:42;57633:9;57628:300;57648:10;57646:1;:12;57628:300;;;57702:95;;-1:-1:-1;;;57702:95:0;;-1:-1:-1;;;;;11364:32:1;;;57702:95:0;;;11346:51:1;11413:18;;;11406:34;;;57684:15:0;;57702:23;;;;;;11319:18:1;;57702:95:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;57684:113;;57839:7;57816:8;:17;;;57834:1;57816:20;;;;;;-1:-1:-1;;;57816:20:0;;;;;;;;;;;;;;;;;;;:30;;;;-1:-1:-1;;;;;57888:15:0;;;;;;:10;:15;;;;;;:24;;;;;;;;;;57865:17;;;;:20;;57888:24;;;;;57883:1;;57865:20;;;;-1:-1:-1;;;57865:20:0;;;;;;;;;:47;;;:20;;;;;;;;;;;:47;-1:-1:-1;57660:3:0;;;;:::i;:::-;;;;57628:300;;;;57959:8;57942:11;57954:1;57942:14;;;;;;-1:-1:-1;;;57942:14:0;;;;;;;;;;;;;;:25;;;;57273:706;;;57311:3;;;;;:::i;:::-;;;;57273:706;;;-1:-1:-1;57996:11:0;57075:940;-1:-1:-1;;57075:940:0:o;20496:239::-;20568:7;20604:16;;;:7;:16;;;;;;-1:-1:-1;;;;;20604:16:0;20639:19;20631:73;;;;-1:-1:-1;;;20631:73:0;;21763:2:1;20631:73:0;;;21745:21:1;21802:2;21782:18;;;21775:30;21841:34;21821:18;;;21814:62;-1:-1:-1;;;21892:18:1;;;21885:39;21941:19;;20631:73:0;21735:231:1;20226:208:0;20298:7;-1:-1:-1;;;;;20326:19:0;;20318:74;;;;-1:-1:-1;;;20318:74:0;;20944:2:1;20318:74:0;;;20926:21:1;20983:2;20963:18;;;20956:30;21022:34;21002:18;;;20995:62;-1:-1:-1;;;21073:18:1;;;21066:40;21123:19;;20318:74:0;20916:232:1;20318:74:0;-1:-1:-1;;;;;;20410:16:0;;;;;:9;:16;;;;;;;20226:208::o;41385:94::-;40965:12;:10;:12::i;:::-;-1:-1:-1;;;;;40954:23:0;:7;40807:6;;-1:-1:-1;;;;;40807:6:0;;40734:87;40954:7;-1:-1:-1;;;;;40954:23:0;;40946:68;;;;-1:-1:-1;;;40946:68:0;;;;;;;:::i;:::-;41450:21:::1;41468:1;41450:9;:21::i;:::-;41385:94::o:0;56679:213::-;56730:4;56789:24;56770:15;:43;;56769:104;;;;;56850:22;56832:15;:40;56769:104;56747:137;;56679:213;:::o;20971:104::-;21027:13;21060:7;21053:14;;;;;:::i;22654:295::-;22769:12;:10;:12::i;:::-;-1:-1:-1;;;;;22757:24:0;:8;-1:-1:-1;;;;;22757:24:0;;;22749:62;;;;-1:-1:-1;;;22749:62:0;;18533:2:1;22749:62:0;;;18515:21:1;18572:2;18552:18;;;18545:30;18611:27;18591:18;;;18584:55;18656:18;;22749:62:0;18505:175:1;22749:62:0;22869:8;22824:18;:32;22843:12;:10;:12::i;:::-;-1:-1:-1;;;;;22824:32:0;;;;;;;;;;;;;;;;;-1:-1:-1;22824:32:0;;;:42;;;;;;;;;;;;:53;;-1:-1:-1;;22824:53:0;;;;;;;;;;;22908:12;:10;:12::i;:::-;-1:-1:-1;;;;;22893:48:0;;22932:8;22893:48;;;;13312:14:1;13305:22;13287:41;;13275:2;13260:18;;13242:92;22893:48:0;;;;;;;;22654:295;;:::o;23917:328::-;24092:41;24111:12;:10;:12::i;:::-;24125:7;24092:18;:41::i;:::-;24084:103;;;;-1:-1:-1;;;24084:103:0;;;;;;;:::i;:::-;24198:39;24212:4;24218:2;24222:7;24231:5;24198:13;:39::i;:::-;23917:328;;;;:::o;62400:175::-;62466:13;62523:14;:12;:14::i;:::-;62539:26;62556:8;62539:16;:26::i;:::-;62506:60;;;;;;;;;:::i;:::-;;;;;;;;;;;;;62492:75;;62400:175;;;:::o;62219:173::-;62264:13;62290:94;;;;;;;;;;;;;;;;;;;62219:173;:::o;59888:955::-;59975:24;59956:15;:43;;59948:83;;;;-1:-1:-1;;;59948:83:0;;22534:2:1;59948:83:0;;;22516:21:1;22573:2;22553:18;;;22546:30;22612:29;22592:18;;;22585:57;22659:18;;59948:83:0;22506:177:1;59948:83:0;60064:8;60050:11;:22;60042:75;;;;-1:-1:-1;;;60042:75:0;;23303:2:1;60042:75:0;;;23285:21:1;23342:2;23322:18;;;23315:30;23381:34;23361:18;;;23354:62;-1:-1:-1;;;23432:18:1;;;23425:38;23480:19;;60042:75:0;23275:230:1;60042:75:0;60132:20;:18;:20::i;:::-;60128:356;;;60209:18;60195:11;;:32;60169:136;;;;-1:-1:-1;;;60169:136:0;;18887:2:1;60169:136:0;;;18869:21:1;18926:2;18906:18;;;18899:30;18965:34;18945:18;;;18938:62;-1:-1:-1;;;19016:18:1;;;19009:40;19066:19;;60169:136:0;18859:232:1;60169:136:0;60375:18;60360:11;60346;;:25;;;;:::i;:::-;:47;;60320:152;;;;-1:-1:-1;;;60320:152:0;;15767:2:1;60320:152:0;;;15749:21:1;15806:2;15786:18;;;15779:30;15845:34;15825:18;;;15818:62;-1:-1:-1;;;15896:18:1;;;15889:41;15947:19;;60320:152:0;15739:233:1;60320:152:0;60494:12;60509:19;60523:5;60509:11;:19;:::i;:::-;60494:34;;60560:4;60547:9;:17;60539:70;;;;-1:-1:-1;;;60539:70:0;;17719:2:1;60539:70:0;;;17701:21:1;17758:2;17738:18;;;17731:30;17797:34;17777:18;;;17770:62;-1:-1:-1;;;17848:18:1;;;17841:38;17896:19;;60539:70:0;17691:230:1;60539:70:0;60628:5;;:16;;-1:-1:-1;;;;;60628:5:0;;;;:16;;;;;60639:4;;60628:5;:16;:5;:16;60639:4;60628:5;:16;;;;;;;60620:63;;;;-1:-1:-1;;;60620:63:0;;25693:2:1;60620:63:0;;;25675:21:1;25732:2;25712:18;;;25705:30;25771:34;25751:18;;;25744:62;-1:-1:-1;;;25822:18:1;;;25815:32;25864:19;;60620:63:0;25665:224:1;60620:63:0;60729:37;60740:12;:10;:12::i;:::-;60754:11;60729:10;:37::i;:::-;60824:11;60809;;:26;;;;;;;:::i;:::-;;;;-1:-1:-1;;;;59888:955:0:o;58267:773::-;58372:16;;;58430:171;58450:7;:14;58448:16;;58430:171;;;58504:13;-1:-1:-1;;;;;58490:27:0;:7;58498:1;58490:10;;;;;;-1:-1:-1;;;58490:10:0;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;58490:10:0;:27;58486:104;;;58546:4;58538:12;;58569:5;;58486:104;58466:3;;;;:::i;:::-;;;;58430:171;;;;58616:9;58611:197;58631:20;:27;58629:29;;58611:197;;;58711:13;-1:-1:-1;;;;;58684:40:0;:20;58705:1;58684:23;;;;;;-1:-1:-1;;;58684:23:0;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;58684:23:0;:40;58680:117;;;58753:4;58745:12;;58776:5;;58680:117;58660:3;;;;:::i;:::-;;;;58611:197;;;;58826:5;58818:55;;;;-1:-1:-1;;;58818:55:0;;24885:2:1;58818:55:0;;;24867:21:1;24924:2;24904:18;;;24897:30;24963:34;24943:18;;;24936:62;-1:-1:-1;;;25014:18:1;;;25007:35;25059:19;;58818:55:0;24857:227:1;58818:55:0;-1:-1:-1;;;;;58920:25:0;;58903:1;58920:25;;;:10;:25;;;;;;;;:34;;;;;;;;;58903:1;;-1:-1:-1;58920:34:0;;58916:117;;58991:30;;-1:-1:-1;;;58991:30:0;;;;;13485:25:1;;;-1:-1:-1;;;;;58991:21:0;;;;;13458:18:1;;58991:30:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;58980:41;58267:773;-1:-1:-1;;;;58267:773:0:o;62707:460::-;63010:33;;-1:-1:-1;;;63010:33:0;;-1:-1:-1;;;;;10199:32:1;;;63010:33:0;;;10181:51:1;62837:4:0;;62966:20;;63002:54;;;;63010:21;;;;;;10154:18:1;;63010:33:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;;;;;63002:54:0;;62998:98;;;63080:4;63073:11;;;;;62998:98;-1:-1:-1;;;;;23141:25:0;;;23117:4;23141:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;63115:44;23020:164;41634:192;40965:12;:10;:12::i;:::-;-1:-1:-1;;;;;40954:23:0;:7;40807:6;;-1:-1:-1;;;;;40807:6:0;;40734:87;40954:7;-1:-1:-1;;;;;40954:23:0;;40946:68;;;;-1:-1:-1;;;40946:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;41723:22:0;::::1;41715:73;;;::::0;-1:-1:-1;;;41715:73:0;;16598:2:1;41715:73:0::1;::::0;::::1;16580:21:1::0;16637:2;16617:18;;;16610:30;16676:34;16656:18;;;16649:62;-1:-1:-1;;;16727:18:1;;;16720:36;16773:19;;41715:73:0::1;16570:228:1::0;41715:73:0::1;41799:19;41809:8;41799:9;:19::i;:::-;41634:192:::0;:::o;48920:650::-;48991:22;49035:10;49057:4;49035:27;49031:508;;;49079:18;49100:8;;49079:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;49139:8:0;49350:17;49344:24;-1:-1:-1;;;;;49318:134:0;;-1:-1:-1;49178:289:0;;-1:-1:-1;49178:289:0;;-1:-1:-1;49516:10:0;49031:508;48920:650;:::o;33674:224::-;33776:4;-1:-1:-1;;;;;;33800:50:0;;-1:-1:-1;;;33800:50:0;;:90;;;33854:36;33878:11;33854:23;:36::i;63731:161::-;63821:14;63860:24;:22;:24::i;29737:174::-;29812:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;29812:29:0;-1:-1:-1;;;;;29812:29:0;;;;;;;;:24;;29866:23;29812:24;29866:14;:23::i;:::-;-1:-1:-1;;;;;29857:46:0;;;;;;;;;;;29737:174;;:::o;54369:486::-;54547:4;-1:-1:-1;;;;;54572:20:0;;54564:70;;;;-1:-1:-1;;;54564:70:0;;19711:2:1;54564:70:0;;;19693:21:1;19750:2;19730:18;;;19723:30;19789:34;19769:18;;;19762:62;-1:-1:-1;;;19840:18:1;;;19833:35;19885:19;;54564:70:0;19683:227:1;54564:70:0;54688:159;54716:47;54735:27;54755:6;54735:19;:27::i;:::-;54716:18;:47::i;:::-;54688:159;;;;;;;;;;;;14170:25:1;;;;14243:4;14231:17;;14211:18;;;14204:45;14265:18;;;14258:34;;;14308:18;;;14301:34;;;14142:19;;54688:159:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;;;;54665:182:0;:6;-1:-1:-1;;;;;54665:182:0;;54645:202;;54369:486;;;;;;;:::o;44715:98::-;44773:7;44800:5;44804:1;44800;:5;:::i;:::-;44793:12;44715:98;-1:-1:-1;;;44715:98:0:o;26049:348::-;26142:4;25844:16;;;:7;:16;;;;;;-1:-1:-1;;;;;25844:16:0;26159:73;;;;-1:-1:-1;;;26159:73:0;;19298:2:1;26159:73:0;;;19280:21:1;19337:2;19317:18;;;19310:30;19376:34;19356:18;;;19349:62;-1:-1:-1;;;19427:18:1;;;19420:42;19479:19;;26159:73:0;19270:234:1;26159:73:0;26243:13;26259:23;26274:7;26259:14;:23::i;:::-;26243:39;;26312:5;-1:-1:-1;;;;;26301:16:0;:7;-1:-1:-1;;;;;26301:16:0;;:51;;;;26345:7;-1:-1:-1;;;;;26321:31:0;:20;26333:7;26321:11;:20::i;:::-;-1:-1:-1;;;;;26321:31:0;;26301:51;:87;;;;26356:32;26373:5;26380:7;26356:16;:32::i;29041:578::-;29200:4;-1:-1:-1;;;;;29173:31:0;:23;29188:7;29173:14;:23::i;:::-;-1:-1:-1;;;;;29173:31:0;;29165:85;;;;-1:-1:-1;;;29165:85:0;;24073:2:1;29165:85:0;;;24055:21:1;24112:2;24092:18;;;24085:30;24151:34;24131:18;;;24124:62;-1:-1:-1;;;24202:18:1;;;24195:39;24251:19;;29165:85:0;24045:231:1;29165:85:0;-1:-1:-1;;;;;29269:16:0;;29261:65;;;;-1:-1:-1;;;29261:65:0;;18128:2:1;29261:65:0;;;18110:21:1;18167:2;18147:18;;;18140:30;18206:34;18186:18;;;18179:62;-1:-1:-1;;;18257:18:1;;;18250:34;18301:19;;29261:65:0;18100:226:1;29261:65:0;29339:39;29360:4;29366:2;29370:7;29339:20;:39::i;:::-;29443:29;29460:1;29464:7;29443:8;:29::i;:::-;-1:-1:-1;;;;;29485:15:0;;;;;;:9;:15;;;;;:20;;29504:1;;29485:15;:20;;29504:1;;29485:20;:::i;:::-;;;;-1:-1:-1;;;;;;;29516:13:0;;;;;;:9;:13;;;;;:18;;29533:1;;29516:13;:18;;29533:1;;29516:18;:::i;:::-;;;;-1:-1:-1;;29545:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;29545:21:0;-1:-1:-1;;;;;29545:21:0;;;;;;;;;29584:27;;29545:16;;29584:27;;;;;;;29041:578;;;:::o;60978:524::-;61112:8;61094:15;;:26;61072:104;;;;-1:-1:-1;;;61072:104:0;;26927:2:1;61072:104:0;;;26909:21:1;26966:2;26946:18;;;26939:30;27005;26985:18;;;26978:58;27053:18;;61072:104:0;26899:178:1;61072:104:0;61239:8;61228:7;61210:15;;:25;;;;:::i;:::-;:37;;61187:121;;;;-1:-1:-1;;;61187:121:0;;20542:2:1;61187:121:0;;;20524:21:1;20581:2;20561:18;;;20554:30;20620:34;20600:18;;;20593:62;-1:-1:-1;;;20671:18:1;;;20664:31;20712:19;;61187:121:0;20514:223:1;61187:121:0;61326:9;61321:174;61345:7;61341:1;:11;61321:174;;;61374:18;61395:17;:15;:17::i;:::-;61374:38;;61427:22;61433:3;61438:10;61427:5;:22::i;:::-;61464:19;:17;:19::i;:::-;-1:-1:-1;61354:3:0;;;;:::i;:::-;;;;61321:174;;41834:173;41909:6;;;-1:-1:-1;;;;;41926:17:0;;;-1:-1:-1;;;;;;41926:17:0;;;;;;;41959:40;;41909:6;;;41926:17;41909:6;;41959:40;;41890:16;;41959:40;41834:173;;:::o;25127:315::-;25284:28;25294:4;25300:2;25304:7;25284:9;:28::i;:::-;25331:48;25354:4;25360:2;25364:7;25373:5;25331:22;:48::i;:::-;25323:111;;;;-1:-1:-1;;;25323:111:0;;;;;;;:::i;16005:723::-;16061:13;16282:10;16278:53;;-1:-1:-1;;16309:10:0;;;;;;;;;;;;-1:-1:-1;;;16309:10:0;;;;;16005:723::o;16278:53::-;16356:5;16341:12;16397:78;16404:9;;16397:78;;16430:8;;;;:::i;:::-;;-1:-1:-1;16453:10:0;;-1:-1:-1;16461:2:0;16453:10;;:::i;:::-;;;16397:78;;;16485:19;16517:6;16507:17;;;;;;-1:-1:-1;;;16507:17:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;16507:17:0;;16485:39;;16535:154;16542:10;;16535:154;;16569:11;16579:1;16569:11;;:::i;:::-;;-1:-1:-1;16638:10:0;16646:2;16638:5;:10;:::i;:::-;16625:24;;:2;:24;:::i;:::-;16612:39;;16595:6;16602;16595:14;;;;;;-1:-1:-1;;;16595:14:0;;;;;;;;;;;;:56;-1:-1:-1;;;;;16595:56:0;;;;;;;;-1:-1:-1;16666:11:0;16675:2;16666:11;;:::i;:::-;;;16535:154;;19857:305;19959:4;-1:-1:-1;;;;;;19996:40:0;;-1:-1:-1;;;19996:40:0;;:105;;-1:-1:-1;;;;;;;20053:48:0;;-1:-1:-1;;;20053:48:0;19996:105;:158;;;-1:-1:-1;;;;;;;;;;18573:40:0;;;20118:36;18464:157;53836:410;53946:7;52013:100;;;;;;;;;;;;;;;;;51993:127;;;;;;;54100:12;;54135:11;;;;54179:24;;;;;54169:35;;;;;;54019:204;;;;;13752:25:1;;;13808:2;13793:18;;13786:34;;;;-1:-1:-1;;;;;13856:32:1;13851:2;13836:18;;13829:60;13920:2;13905:18;;13898:34;13739:3;13724:19;;13706:232;54019:204:0;;;;;;;;;;;;;53991:247;;;;;;53971:267;;53836:410;;;:::o;51588:258::-;51687:7;51789:20;51027:15;;;50949:101;51789:20;51760:63;;-1:-1:-1;;;51760:63:0;;;9896:27:1;9939:11;;;9932:27;;;;9975:12;;;9968:28;;;10012:12;;51760:63:0;9886:144:1;63364:223:0;63534:45;63561:4;63567:2;63571:7;63534:26;:45::i;61953:106::-;62029:15;;62002:7;;62029:22;;62049:1;62029:19;:22::i;27733:382::-;-1:-1:-1;;;;;27813:16:0;;27805:61;;;;-1:-1:-1;;;27805:61:0;;22173:2:1;27805:61:0;;;22155:21:1;;;22192:18;;;22185:30;22251:34;22231:18;;;22224:62;22303:18;;27805:61:0;22145:182:1;27805:61:0;25820:4;25844:16;;;:7;:16;;;;;;-1:-1:-1;;;;;25844:16:0;:30;27877:58;;;;-1:-1:-1;;;27877:58:0;;17362:2:1;27877:58:0;;;17344:21:1;17401:2;17381:18;;;17374:30;17440;17420:18;;;17413:58;17488:18;;27877:58:0;17334:178:1;27877:58:0;27948:45;27977:1;27981:2;27985:7;27948:20;:45::i;:::-;-1:-1:-1;;;;;28006:13:0;;;;;;:9;:13;;;;;:18;;28023:1;;28006:13;:18;;28023:1;;28006:18;:::i;:::-;;;;-1:-1:-1;;28035:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;28035:21:0;-1:-1:-1;;;;;28035:21:0;;;;;;;;28074:33;;28035:16;;;28074:33;;28035:16;;28074:33;27733:382;;:::o;62138:73::-;62186:15;:17;;;:15;:17;;;:::i;:::-;;;;;;62138:73::o;30476:799::-;30631:4;-1:-1:-1;;;;;30652:13:0;;8013:20;8061:8;30648:620;;30704:2;-1:-1:-1;;;;;30688:36:0;;30725:12;:10;:12::i;:::-;30739:4;30745:7;30754:5;30688:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;30688:72:0;;;;;;;;-1:-1:-1;;30688:72:0;;;;;;;;;;;;:::i;:::-;;;30684:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;30930:13:0;;30926:272;;30973:60;;-1:-1:-1;;;30973:60:0;;;;;;;:::i;30926:272::-;31148:6;31142:13;31133:6;31129:2;31125:15;31118:38;30684:529;-1:-1:-1;;;;;;30811:51:0;-1:-1:-1;;;30811:51:0;;-1:-1:-1;30804:58:0;;30648:620;-1:-1:-1;31252:4:0;30476:799;;;;;;:::o;35350:589::-;-1:-1:-1;;;;;35556:18:0;;35552:187;;35591:40;35623:7;36766:10;:17;;36739:24;;;;:15;:24;;;;;:44;;;36794:24;;;;;;;;;;;;36662:164;35591:40;35552:187;;;35661:2;-1:-1:-1;;;;;35653:10:0;:4;-1:-1:-1;;;;;35653:10:0;;35649:90;;35680:47;35713:4;35719:7;35680:32;:47::i;:::-;-1:-1:-1;;;;;35753:16:0;;35749:183;;35786:45;35823:7;35786:36;:45::i;35749:183::-;35859:4;-1:-1:-1;;;;;35853:10:0;:2;-1:-1:-1;;;;;35853:10:0;;35849:83;;35880:40;35908:2;35912:7;35880:27;:40::i;37453:988::-;37719:22;37769:1;37744:22;37761:4;37744:16;:22::i;:::-;:26;;;;:::i;:::-;37781:18;37802:26;;;:17;:26;;;;;;37719:51;;-1:-1:-1;37935:28:0;;;37931:328;;-1:-1:-1;;;;;38002:18:0;;37980:19;38002:18;;;:12;:18;;;;;;;;:34;;;;;;;;;38053:30;;;;;;:44;;;38170:30;;:17;:30;;;;;:43;;;37931:328;-1:-1:-1;38355:26:0;;;;:17;:26;;;;;;;;38348:33;;;-1:-1:-1;;;;;38399:18:0;;;;;:12;:18;;;;;:34;;;;;;;38392:41;37453:988::o;38736:1079::-;39014:10;:17;38989:22;;39014:21;;39034:1;;39014:21;:::i;:::-;39046:18;39067:24;;;:15;:24;;;;;;39440:10;:26;;38989:46;;-1:-1:-1;39067:24:0;;38989:46;;39440:26;;;;-1:-1:-1;;;39440:26:0;;;;;;;;;;;;;;;;;39418:48;;39504:11;39479:10;39490;39479:22;;;;;;-1:-1:-1;;;39479:22:0;;;;;;;;;;;;;;;;;;;;:36;;;;39584:28;;;:15;:28;;;;;;;:41;;;39756:24;;;;;39749:31;39791:10;:16;;;;;-1:-1:-1;;;39791:16:0;;;;;;;;;;;;;;;;;;;;;;;;;;38736:1079;;;;:::o;36240:221::-;36325:14;36342:20;36359:2;36342:16;:20::i;:::-;-1:-1:-1;;;;;36373:16:0;;;;;;;:12;:16;;;;;;;;:24;;;;;;;;:34;;;36418:26;;;:17;:26;;;;;;:35;;;;-1:-1:-1;36240:221:0:o;14:400:1:-;82:8;92:6;146:3;139:4;131:6;127:17;123:27;113:2;;171:8;161;154:26;113:2;-1:-1:-1;201:20:1;;244:18;233:30;;230:2;;;283:8;273;266:26;230:2;327:4;319:6;315:17;303:29;;387:3;380:4;370:6;367:1;363:14;355:6;351:27;347:38;344:47;341:2;;;404:1;401;394:12;341:2;103:311;;;;;:::o;419:738::-;461:5;514:3;507:4;499:6;495:17;491:27;481:2;;536:5;529;522:20;481:2;576:6;563:20;602:18;639:2;635;632:10;629:2;;;645:18;;:::i;:::-;720:2;714:9;688:2;774:13;;-1:-1:-1;;770:22:1;;;794:2;766:31;762:40;750:53;;;818:18;;;838:22;;;815:46;812:2;;;864:18;;:::i;:::-;904:10;900:2;893:22;939:2;931:6;924:18;985:3;978:4;973:2;965:6;961:15;957:26;954:35;951:2;;;1006:5;999;992:20;951:2;1074;1067:4;1059:6;1055:17;1048:4;1040:6;1036:17;1023:54;1097:15;;;1114:4;1093:26;1086:41;;;;-1:-1:-1;1101:6:1;471:686;-1:-1:-1;;;471:686:1:o;1162:257::-;1221:6;1274:2;1262:9;1253:7;1249:23;1245:32;1242:2;;;1295:6;1287;1280:22;1242:2;1339:9;1326:23;1358:31;1383:5;1358:31;:::i;1424:261::-;1494:6;1547:2;1535:9;1526:7;1522:23;1518:32;1515:2;;;1568:6;1560;1553:22;1515:2;1605:9;1599:16;1624:31;1649:5;1624:31;:::i;1960:398::-;2028:6;2036;2089:2;2077:9;2068:7;2064:23;2060:32;2057:2;;;2110:6;2102;2095:22;2057:2;2154:9;2141:23;2173:31;2198:5;2173:31;:::i;:::-;2223:5;-1:-1:-1;2280:2:1;2265:18;;2252:32;2293:33;2252:32;2293:33;:::i;:::-;2345:7;2335:17;;;2047:311;;;;;:::o;2363:466::-;2440:6;2448;2456;2509:2;2497:9;2488:7;2484:23;2480:32;2477:2;;;2530:6;2522;2515:22;2477:2;2574:9;2561:23;2593:31;2618:5;2593:31;:::i;:::-;2643:5;-1:-1:-1;2700:2:1;2685:18;;2672:32;2713:33;2672:32;2713:33;:::i;:::-;2467:362;;2765:7;;-1:-1:-1;;;2819:2:1;2804:18;;;;2791:32;;2467:362::o;2834:685::-;2929:6;2937;2945;2953;3006:3;2994:9;2985:7;2981:23;2977:33;2974:2;;;3028:6;3020;3013:22;2974:2;3072:9;3059:23;3091:31;3116:5;3091:31;:::i;:::-;3141:5;-1:-1:-1;3198:2:1;3183:18;;3170:32;3211:33;3170:32;3211:33;:::i;:::-;3263:7;-1:-1:-1;3317:2:1;3302:18;;3289:32;;-1:-1:-1;3372:2:1;3357:18;;3344:32;3399:18;3388:30;;3385:2;;;3436:6;3428;3421:22;3385:2;3464:49;3505:7;3496:6;3485:9;3481:22;3464:49;:::i;:::-;3454:59;;;2964:555;;;;;;;:::o;3524:436::-;3589:6;3597;3650:2;3638:9;3629:7;3625:23;3621:32;3618:2;;;3671:6;3663;3656:22;3618:2;3715:9;3702:23;3734:31;3759:5;3734:31;:::i;:::-;3784:5;-1:-1:-1;3841:2:1;3826:18;;3813:32;3883:15;;3876:23;3864:36;;3854:2;;3919:6;3911;3904:22;3965:788;4067:6;4075;4083;4091;4099;4152:3;4140:9;4131:7;4127:23;4123:33;4120:2;;;4174:6;4166;4159:22;4120:2;4218:9;4205:23;4237:31;4262:5;4237:31;:::i;:::-;4287:5;-1:-1:-1;4343:2:1;4328:18;;4315:32;4370:18;4359:30;;4356:2;;;4407:6;4399;4392:22;4356:2;4435:49;4476:7;4467:6;4456:9;4452:22;4435:49;:::i;:::-;4425:59;;;4531:2;4520:9;4516:18;4503:32;4493:42;;4582:2;4571:9;4567:18;4554:32;4544:42;;4638:3;4627:9;4623:19;4610:33;4687:4;4678:7;4674:18;4665:7;4662:31;4652:2;;4712:6;4704;4697:22;4652:2;4740:7;4730:17;;;4110:643;;;;;;;;:::o;4758:325::-;4826:6;4834;4887:2;4875:9;4866:7;4862:23;4858:32;4855:2;;;4908:6;4900;4893:22;4855:2;4952:9;4939:23;4971:31;4996:5;4971:31;:::i;:::-;5021:5;5073:2;5058:18;;;;5045:32;;-1:-1:-1;;;4845:238:1:o;5088:825::-;5222:6;5230;5238;5246;5299:2;5287:9;5278:7;5274:23;5270:32;5267:2;;;5320:6;5312;5305:22;5267:2;5365:9;5352:23;5394:18;5435:2;5427:6;5424:14;5421:2;;;5456:6;5448;5441:22;5421:2;5500:75;5567:7;5558:6;5547:9;5543:22;5500:75;:::i;:::-;5594:8;;-1:-1:-1;5474:101:1;-1:-1:-1;5682:2:1;5667:18;;5654:32;;-1:-1:-1;5698:16:1;;;5695:2;;;5732:6;5724;5717:22;5695:2;;5776:77;5845:7;5834:8;5823:9;5819:24;5776:77;:::i;:::-;5257:656;;;;-1:-1:-1;5872:8:1;-1:-1:-1;;;;5257:656:1:o;5918:255::-;5976:6;6029:2;6017:9;6008:7;6004:23;6000:32;5997:2;;;6050:6;6042;6035:22;5997:2;6094:9;6081:23;6113:30;6137:5;6113:30;:::i;6178:259::-;6247:6;6300:2;6288:9;6279:7;6275:23;6271:32;6268:2;;;6321:6;6313;6306:22;6268:2;6358:9;6352:16;6377:30;6401:5;6377:30;:::i;7353:190::-;7412:6;7465:2;7453:9;7444:7;7440:23;7436:32;7433:2;;;7486:6;7478;7471:22;7433:2;-1:-1:-1;7514:23:1;;7423:120;-1:-1:-1;7423:120:1:o;7548:194::-;7618:6;7671:2;7659:9;7650:7;7646:23;7642:32;7639:2;;;7692:6;7684;7677:22;7639:2;-1:-1:-1;7720:16:1;;7629:113;-1:-1:-1;7629:113:1:o;7747:450::-;7797:3;7835:5;7829:12;7862:6;7857:3;7850:19;7888:4;7917:2;7912:3;7908:12;7901:19;;7954:2;7947:5;7943:14;7975:3;7987:185;8001:6;7998:1;7995:13;7987:185;;;8076:13;;8069:21;8062:29;8050:42;;8112:12;;;;8147:15;;;;8023:1;8016:9;7987:185;;;-1:-1:-1;8188:3:1;;7805:392;-1:-1:-1;;;;;7805:392:1:o;8202:257::-;8243:3;8281:5;8275:12;8308:6;8303:3;8296:19;8324:63;8380:6;8373:4;8368:3;8364:14;8357:4;8350:5;8346:16;8324:63;:::i;:::-;8441:2;8420:15;-1:-1:-1;;8416:29:1;8407:39;;;;8448:4;8403:50;;8251:208;-1:-1:-1;;8251:208:1:o;8464:274::-;8593:3;8631:6;8625:13;8647:53;8693:6;8688:3;8681:4;8673:6;8669:17;8647:53;:::i;:::-;8716:16;;;;;8601:137;-1:-1:-1;;8601:137:1:o;8743:415::-;8900:3;8938:6;8932:13;8954:53;9000:6;8995:3;8988:4;8980:6;8976:17;8954:53;:::i;:::-;9076:2;9072:15;;;;-1:-1:-1;;9068:53:1;9029:16;;;;9054:68;;;9149:2;9138:14;;8908:250;-1:-1:-1;;8908:250:1:o;9163:470::-;9342:3;9380:6;9374:13;9396:53;9442:6;9437:3;9430:4;9422:6;9418:17;9396:53;:::i;:::-;9512:13;;9471:16;;;;9534:57;9512:13;9471:16;9568:4;9556:17;;9534:57;:::i;:::-;9607:20;;9350:283;-1:-1:-1;;;;9350:283:1:o;10243:431::-;-1:-1:-1;;;;;10500:15:1;;;10482:34;;10552:15;;10547:2;10532:18;;10525:43;10604:2;10599;10584:18;;10577:30;;;10425:4;;10624:44;;10649:18;;10641:6;10624:44;:::i;:::-;10616:52;10434:240;-1:-1:-1;;;;;10434:240:1:o;10679:488::-;-1:-1:-1;;;;;10948:15:1;;;10930:34;;11000:15;;10995:2;10980:18;;10973:43;11047:2;11032:18;;11025:34;;;11095:3;11090:2;11075:18;;11068:31;;;10873:4;;11116:45;;11141:19;;11133:6;11116:45;:::i;:::-;11108:53;10882:285;-1:-1:-1;;;;;;10882:285:1:o;11451:1691::-;11645:4;11674:2;11714;11703:9;11699:18;11744:2;11733:9;11726:21;11767:6;11802;11796:13;11833:6;11825;11818:22;11859:2;11849:12;;11892:2;11881:9;11877:18;11870:25;;11954:2;11944:6;11941:1;11937:14;11926:9;11922:30;11918:39;11992:2;11984:6;11980:15;12013:4;12026:1087;12040:6;12037:1;12034:13;12026:1087;;;12105:22;;;-1:-1:-1;;12101:36:1;12089:49;;12161:13;;12275:9;;-1:-1:-1;;;;;12271:35:1;12256:51;;12346:11;;;12340:18;12197:4;12378:15;;;12371:27;;;12459:19;;12228:15;;;12491:24;;;12549:3;12537:16;;;12582:21;;;12627:4;;12644:209;12660:8;12655:3;12652:17;12644:209;;;12737:15;;12723:30;;12779:14;;;;12822:17;;;;12688:1;12679:11;;;;;12644:209;;;-1:-1:-1;;;12894:11:1;;;12888:18;12943;;;12926:15;;;12919:43;12888:18;12985:48;12947:5;12888:18;12985:48;:::i;:::-;13091:12;;;;12975:58;-1:-1:-1;;;13056:15:1;;;;12062:1;12055:9;12026:1087;;;-1:-1:-1;13130:6:1;;11654:1488;-1:-1:-1;;;;;;;;11654:1488:1:o;14346:217::-;14493:2;14482:9;14475:21;14456:4;14513:44;14553:2;14542:9;14538:18;14530:6;14513:44;:::i;15977:414::-;16179:2;16161:21;;;16218:2;16198:18;;;16191:30;16257:34;16252:2;16237:18;;16230:62;-1:-1:-1;;;16323:2:1;16308:18;;16301:48;16381:3;16366:19;;16151:240::o;23510:356::-;23712:2;23694:21;;;23731:18;;;23724:30;23790:34;23785:2;23770:18;;23763:62;23857:2;23842:18;;23684:182::o;25894:413::-;26096:2;26078:21;;;26135:2;26115:18;;;26108:30;26174:34;26169:2;26154:18;;26147:62;-1:-1:-1;;;26240:2:1;26225:18;;26218:47;26297:3;26282:19;;26068:239::o;27264:128::-;27304:3;27335:1;27331:6;27328:1;27325:13;27322:2;;;27341:18;;:::i;:::-;-1:-1:-1;27377:9:1;;27312:80::o;27397:120::-;27437:1;27463;27453:2;;27468:18;;:::i;:::-;-1:-1:-1;27502:9:1;;27443:74::o;27522:168::-;27562:7;27628:1;27624;27620:6;27616:14;27613:1;27610:21;27605:1;27598:9;27591:17;27587:45;27584:2;;;27635:18;;:::i;:::-;-1:-1:-1;27675:9:1;;27574:116::o;27695:125::-;27735:4;27763:1;27760;27757:8;27754:2;;;27768:18;;:::i;:::-;-1:-1:-1;27805:9:1;;27744:76::o;27825:258::-;27897:1;27907:113;27921:6;27918:1;27915:13;27907:113;;;27997:11;;;27991:18;27978:11;;;27971:39;27943:2;27936:10;27907:113;;;28038:6;28035:1;28032:13;28029:2;;;-1:-1:-1;;28073:1:1;28055:16;;28048:27;27878:205::o;28088:380::-;28167:1;28163:12;;;;28210;;;28231:2;;28285:4;28277:6;28273:17;28263:27;;28231:2;28338;28330:6;28327:14;28307:18;28304:38;28301:2;;;28384:10;28379:3;28375:20;28372:1;28365:31;28419:4;28416:1;28409:15;28447:4;28444:1;28437:15;28301:2;;28143:325;;;:::o;28473:135::-;28512:3;-1:-1:-1;;28533:17:1;;28530:2;;;28553:18;;:::i;:::-;-1:-1:-1;28600:1:1;28589:13;;28520:88::o;28613:112::-;28645:1;28671;28661:2;;28676:18;;:::i;:::-;-1:-1:-1;28710:9:1;;28651:74::o;28730:127::-;28791:10;28786:3;28782:20;28779:1;28772:31;28822:4;28819:1;28812:15;28846:4;28843:1;28836:15;28862:127;28923:10;28918:3;28914:20;28911:1;28904:31;28954:4;28951:1;28944:15;28978:4;28975:1;28968:15;28994:127;29055:10;29050:3;29046:20;29043:1;29036:31;29086:4;29083:1;29076:15;29110:4;29107:1;29100:15;29126:131;-1:-1:-1;;;;;29201:31:1;;29191:42;;29181:2;;29247:1;29244;29237:12;29262:131;-1:-1:-1;;;;;;29336:32:1;;29326:43;;29316:2;;29383:1;29380;29373:12

Swarm Source

ipfs://566ba060a19aec8d8960d7ccba997fa0164a1bf7e31542b1bf9f9b70213ea95f

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