Token

MDMA (MD)

Feature Tip: Add private address tag to any address under My Name Tag !

ERC-721

Overview

Max Total Supply

2,000 MD

Holders

724

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xac2d0b4f1114123686a0e276434c198e8dd33f91

Filtered by Token Holder

0x1f455832E75555Cd848958eFA5e85f10899463D2

aheyyeha.eth

Balance

3 MD

0x1f455832e75555cd848958efa5e85f10899463d2

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

MDMA

Compiler Version

v0.8.7+commit.e28d00a7

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2022-08-15
*/

// SPDX-License-Identifier: MIT
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol
//AE THER 

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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/security/ReentrancyGuard.sol


// OpenZeppelin Contracts v4.4.1 (security/ReentrancyGuard.sol)

pragma solidity ^0.8.0;

/**
 * @dev Contract module that helps prevent reentrant calls to a function.
 *
 * Inheriting from `ReentrancyGuard` will make the {nonReentrant} modifier
 * available, which can be applied to functions to make sure there are no nested
 * (reentrant) calls to them.
 *
 * Note that because there is a single `nonReentrant` guard, functions marked as
 * `nonReentrant` may not call one another. This can be worked around by making
 * those functions `private`, and then adding `external` `nonReentrant` entry
 * points to them.
 *
 * TIP: If you would like to learn more about reentrancy and alternative ways
 * to protect against it, check out our blog post
 * https://blog.openzeppelin.com/reentrancy-after-istanbul/[Reentrancy After Istanbul].
 */
abstract contract ReentrancyGuard {
    // Booleans are more expensive than uint256 or any type that takes up a full
    // word because each write operation emits an extra SLOAD to first read the
    // slot's contents, replace the bits taken up by the boolean, and then write
    // back. This is the compiler's defense against contract upgrades and
    // pointer aliasing, and it cannot be disabled.

    // The values being non-zero value makes deployment a bit more expensive,
    // but in exchange the refund on every call to nonReentrant will be lower in
    // amount. Since refunds are capped to a percentage of the total
    // transaction's gas, it is best to keep them low in cases like this one, to
    // increase the likelihood of the full refund coming into effect.
    uint256 private constant _NOT_ENTERED = 1;
    uint256 private constant _ENTERED = 2;

    uint256 private _status;

    constructor() {
        _status = _NOT_ENTERED;
    }

    /**
     * @dev Prevents a contract from calling itself, directly or indirectly.
     * Calling a `nonReentrant` function from another `nonReentrant`
     * function is not supported. It is possible to prevent this from happening
     * by making the `nonReentrant` function external, and making it call a
     * `private` function that does the actual work.
     */
    modifier nonReentrant() {
        // On the first call to nonReentrant, _notEntered will be true
        require(_status != _ENTERED, "ReentrancyGuard: reentrant call");

        // Any calls to nonReentrant after this point will fail
        _status = _ENTERED;

        _;

        // By storing the original value once again, a refund is triggered (see
        // https://eips.ethereum.org/EIPS/eip-2200)
        _status = _NOT_ENTERED;
    }
}

// File: @openzeppelin/contracts/utils/cryptography/MerkleProof.sol


// OpenZeppelin Contracts (last updated v4.5.0) (utils/cryptography/MerkleProof.sol)

pragma solidity ^0.8.0;

/**
 * @dev These functions deal with verification of Merkle Trees proofs.
 *
 * The proofs can be generated using the JavaScript library
 * https://github.com/miguelmota/merkletreejs[merkletreejs].
 * Note: the hashing algorithm should be keccak256 and pair sorting should be enabled.
 *
 * See `test/utils/cryptography/MerkleProof.test.js` for some examples.
 */
library MerkleProof {
    /**
     * @dev Returns true if a `leaf` can be proved to be a part of a Merkle tree
     * defined by `root`. For this, a `proof` must be provided, containing
     * sibling hashes on the branch from the leaf to the root of the tree. Each
     * pair of leaves and each pair of pre-images are assumed to be sorted.
     */
    function verify(
        bytes32[] memory proof,
        bytes32 root,
        bytes32 leaf
    ) internal pure returns (bool) {
        return processProof(proof, leaf) == root;
    }

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

    function _efficientHash(bytes32 a, bytes32 b) private pure returns (bytes32 value) {
        assembly {
            mstore(0x00, a)
            mstore(0x20, b)
            value := keccak256(0x00, 0x40)
        }
    }
}

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


// OpenZeppelin Contracts v4.4.1 (utils/Strings.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

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


// OpenZeppelin Contracts v4.4.1 (utils/Context.sol)

pragma solidity ^0.8.0;

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

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

// File: @openzeppelin/contracts/access/Ownable.sol


// OpenZeppelin Contracts v4.4.1 (access/Ownable.sol)

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

    /**
     * @dev Transfers ownership of the contract to a new account (`newOwner`).
     * Internal function without access restriction.
     */
    function _transferOwnership(address newOwner) internal virtual {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
} 

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


// OpenZeppelin Contracts (last updated v4.5.0) (utils/Address.sol)

pragma solidity ^0.8.1;

/**
 * @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
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC20/utils/SafeERC20.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/utils/SafeERC20.sol)

pragma solidity ^0.8.0;



/**
 * @title SafeERC20
 * @dev Wrappers around ERC20 operations that throw on failure (when the token
 * contract returns false). Tokens that return no value (and instead revert or
 * throw on failure) are also supported, non-reverting calls are assumed to be
 * successful.
 * To use this library you can add a `using SafeERC20 for IERC20;` statement to your contract,
 * which allows you to call the safe operations as `token.safeTransfer(...)`, etc.
 */
library SafeERC20 {
    using Address for address;

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/finance/PaymentSplitter.sol


// OpenZeppelin Contracts v4.4.1 (finance/PaymentSplitter.sol)


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


// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721Receiver.sol)

pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/utils/introspection/IERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/IERC165.sol)

pragma solidity ^0.8.0;

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

// File: @openzeppelin/contracts/utils/introspection/ERC165.sol


// OpenZeppelin Contracts v4.4.1 (utils/introspection/ERC165.sol)

pragma solidity ^0.8.0;


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

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


// OpenZeppelin Contracts v4.4.1 (token/ERC721/IERC721.sol)

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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

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

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

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


// OpenZeppelin Contracts (last updated v4.5.0) (token/ERC721/extensions/IERC721Enumerable.sol)

pragma solidity ^0.8.0;


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

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

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

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


// OpenZeppelin Contracts v4.4.1 (token/ERC721/extensions/IERC721Metadata.sol)

pragma solidity ^0.8.0;


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

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

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

// File: erc721a/contracts/ERC721A.sol


// Creator: Chiru Labs

pragma solidity ^0.8.4;









error ApprovalCallerNotOwnerNorApproved();
error ApprovalQueryForNonexistentToken();
error ApproveToCaller();
error ApprovalToCurrentOwner();
error BalanceQueryForZeroAddress();
error MintedQueryForZeroAddress();
error BurnedQueryForZeroAddress();
error AuxQueryForZeroAddress();
error MintToZeroAddress();
error MintZeroQuantity();
error OwnerIndexOutOfBounds();
error OwnerQueryForNonexistentToken();
error TokenIndexOutOfBounds();
error TransferCallerNotOwnerNorApproved();
error TransferFromIncorrectOwner();
error TransferToNonERC721ReceiverImplementer();
error TransferToZeroAddress();
error URIQueryForNonexistentToken();

/**
 * @dev Implementation of https://eips.ethereum.org/EIPS/eip-721[ERC721] Non-Fungible Token Standard, including
 * the Metadata extension. Built to optimize for lower gas during batch mints.
 *
 * Assumes serials are sequentially minted starting at _startTokenId() (defaults to 0, e.g. 0, 1, 2, 3..).
 *
 * Assumes that an owner cannot have more than 2**64 - 1 (max value of uint64) of supply.
 *
 * Assumes that the maximum token id cannot exceed 2**256 - 1 (max value of uint256).
 */
contract ERC721A is Context, ERC165, IERC721, IERC721Metadata {
    using Address for address;
    using Strings for uint256;

    // Compiler will pack this into a single 256bit word.
    struct TokenOwnership {
        // The address of the owner.
        address addr;
        // Keeps track of the start time of ownership with minimal overhead for tokenomics.
        uint64 startTimestamp;
        // Whether the token has been burned.
        bool burned;
    }

    // Compiler will pack this into a single 256bit word.
    struct AddressData {
        // Realistically, 2**64-1 is more than enough.
        uint64 balance;
        // Keeps track of mint count with minimal overhead for tokenomics.
        uint64 numberMinted;
        // Keeps track of burn count with minimal overhead for tokenomics.
        uint64 numberBurned;
        // For miscellaneous variable(s) pertaining to the address
        // (e.g. number of whitelist mint slots used).
        // If there are multiple variables, please pack them into a uint64.
        uint64 aux;
    }

    // The tokenId of the next token to be minted.
    uint256 internal _currentIndex;

    // The number of tokens burned.
    uint256 internal _burnCounter;

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

    // Mapping from token ID to ownership details
    // An empty struct value does not necessarily mean the token is unowned. See ownershipOf implementation for details.
    mapping(uint256 => TokenOwnership) internal _ownerships;

    // Mapping owner address to address data
    mapping(address => AddressData) private _addressData;

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

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

    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
        _currentIndex = _startTokenId();
    }

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

    /**
     * @dev See {IERC721Enumerable-totalSupply}.
     * @dev Burned tokens are calculated here, use _totalMinted() if you want to count just minted tokens.
     */
    function totalSupply() public view returns (uint256) {
        // Counter underflow is impossible as _burnCounter cannot be incremented
        // more than _currentIndex - _startTokenId() times
        unchecked {
            return _currentIndex - _burnCounter - _startTokenId();
        }
    }

    /**
     * Returns the total amount of tokens minted in the contract.
     */
    function _totalMinted() internal view returns (uint256) {
        // Counter underflow is impossible as _currentIndex does not decrement,
        // and it is initialized to _startTokenId()
        unchecked {
            return _currentIndex - _startTokenId();
        }
    }

    /**
     * @dev 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 override returns (uint256) {
        if (owner == address(0)) revert BalanceQueryForZeroAddress();
        return uint256(_addressData[owner].balance);
    }

    /**
     * Returns the number of tokens minted by `owner`.
     */
    function _numberMinted(address owner) internal view returns (uint256) {
        if (owner == address(0)) revert MintedQueryForZeroAddress();
        return uint256(_addressData[owner].numberMinted);
    }

    /**
     * Returns the number of tokens burned by or on behalf of `owner`.
     */
    function _numberBurned(address owner) internal view returns (uint256) {
        if (owner == address(0)) revert BurnedQueryForZeroAddress();
        return uint256(_addressData[owner].numberBurned);
    }

    /**
     * Returns the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     */
    function _getAux(address owner) internal view returns (uint64) {
        if (owner == address(0)) revert AuxQueryForZeroAddress();
        return _addressData[owner].aux;
    }

    /**
     * Sets the auxillary data for `owner`. (e.g. number of whitelist mint slots used).
     * If there are multiple variables, please pack them into a uint64.
     */
    function _setAux(address owner, uint64 aux) internal {
        if (owner == address(0)) revert AuxQueryForZeroAddress();
        _addressData[owner].aux = aux;
    }

    /**
     * Gas spent here starts off proportional to the maximum mint batch size.
     * It gradually moves to O(1) as tokens get transferred around in the collection over time.
     */
    function ownershipOf(uint256 tokenId) internal view returns (TokenOwnership memory) {
        uint256 curr = tokenId;

        unchecked {
            if (_startTokenId() <= curr && curr < _currentIndex) {
                TokenOwnership memory ownership = _ownerships[curr];
                if (!ownership.burned) {
                    if (ownership.addr != address(0)) {
                        return ownership;
                    }
                    // Invariant:
                    // There will always be an ownership that has an address and is not burned
                    // before an ownership that does not have an address and is not burned.
                    // Hence, curr will not underflow.
                    while (true) {
                        curr--;
                        ownership = _ownerships[curr];
                        if (ownership.addr != address(0)) {
                            return ownership;
                        }
                    }
                }
            }
        }
        revert OwnerQueryForNonexistentToken();
    }

    /**
     * @dev See {IERC721-ownerOf}.
     */
    function ownerOf(uint256 tokenId) public view override returns (address) {
        return ownershipOf(tokenId).addr;
    }

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

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

    /**
     * @dev See {IERC721Metadata-tokenURI}.
     */
    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        if (!_exists(tokenId)) revert URIQueryForNonexistentToken();

        string memory baseURI = _baseURI();
        return bytes(baseURI).length != 0 ? string(abi.encodePacked(baseURI, 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 override {
        address owner = ERC721A.ownerOf(tokenId);
        if (to == owner) revert ApprovalToCurrentOwner();

        if (_msgSender() != owner && !isApprovedForAll(owner, _msgSender())) {
            revert ApprovalCallerNotOwnerNorApproved();
        }

        _approve(to, tokenId, owner);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view override returns (address) {
        if (!_exists(tokenId)) revert ApprovalQueryForNonexistentToken();

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public override {
        if (operator == _msgSender()) revert ApproveToCaller();

        _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 {
        _transfer(from, to, tokenId);
    }

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId
    ) public virtual override {
        safeTransferFrom(from, to, tokenId, '');
    }
    
    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public virtual override {
        _transfer(from, to, tokenId);
        if (to.isContract() && !_checkContractOnERC721Received(from, to, tokenId, _data)) {
            revert TransferToNonERC721ReceiverImplementer();
        }
    }

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

    function _safeMint(address to, uint256 quantity) internal {
        _safeMint(to, quantity, '');
    }

    /**
     * @dev Safely mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - If `to` refers to a smart contract, it must implement {IERC721Receiver-onERC721Received}, which is called for each safe transfer.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _safeMint(
        address to,
        uint256 quantity,
        bytes memory _data
    ) internal {
        _mint(to, quantity, _data, true);
    }

    /**
     * @dev Mints `quantity` tokens and transfers them to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `quantity` must be greater than 0.
     *
     * Emits a {Transfer} event.
     */
    function _mint(
        address to,
        uint256 quantity,
        bytes memory _data,
        bool safe
    ) internal {
        uint256 startTokenId = _currentIndex;
        if (to == address(0)) revert MintToZeroAddress();
        if (quantity == 0) revert MintZeroQuantity();

        _beforeTokenTransfers(address(0), to, startTokenId, quantity);

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 1.8e19 (2**64) - 1
        // updatedIndex overflows if _currentIndex + quantity > 1.2e77 (2**256) - 1
        unchecked {
            _addressData[to].balance += uint64(quantity);
            _addressData[to].numberMinted += uint64(quantity);

            _ownerships[startTokenId].addr = to;
            _ownerships[startTokenId].startTimestamp = uint64(block.timestamp);

            uint256 updatedIndex = startTokenId;
            uint256 end = updatedIndex + quantity;

            if (safe && to.isContract()) {
                do {
                    emit Transfer(address(0), to, updatedIndex);
                    if (!_checkContractOnERC721Received(address(0), to, updatedIndex++, _data)) {
                        revert TransferToNonERC721ReceiverImplementer();
                    }
                } while (updatedIndex != end);
                // Reentrancy protection
                if (_currentIndex != startTokenId) revert();
            } else {
                do {
                    emit Transfer(address(0), to, updatedIndex++);
                } while (updatedIndex != end);
            }
            _currentIndex = updatedIndex;
        }
        _afterTokenTransfers(address(0), to, startTokenId, quantity);
    }
 
    /**
     * @dev Transfers `tokenId` from `from` to `to`.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - `tokenId` token must be owned by `from`.
     *
     * Emits a {Transfer} event.
     */
    function _transfer(
        address from,
        address to,
        uint256 tokenId
    ) private {
        TokenOwnership memory prevOwnership = ownershipOf(tokenId);

        bool isApprovedOrOwner = (_msgSender() == prevOwnership.addr ||
            isApprovedForAll(prevOwnership.addr, _msgSender()) ||
            getApproved(tokenId) == _msgSender());

        if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();
        if (prevOwnership.addr != from) revert TransferFromIncorrectOwner();
        if (to == address(0)) revert TransferToZeroAddress();

        _beforeTokenTransfers(from, to, tokenId, 1);

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

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            _addressData[from].balance -= 1;
            _addressData[to].balance += 1;

            _ownerships[tokenId].addr = to;
            _ownerships[tokenId].startTimestamp = uint64(block.timestamp);

            // If the ownership slot of tokenId+1 is not explicitly set, that means the transfer initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            if (_ownerships[nextTokenId].addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId < _currentIndex) {
                    _ownerships[nextTokenId].addr = prevOwnership.addr;
                    _ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

        emit Transfer(from, to, tokenId);
        _afterTokenTransfers(from, to, tokenId, 1);
    }

    /**
     * @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 {
        TokenOwnership memory prevOwnership = ownershipOf(tokenId);

        _beforeTokenTransfers(prevOwnership.addr, address(0), tokenId, 1);

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

        // Underflow of the sender's balance is impossible because we check for
        // ownership above and the recipient's balance can't realistically overflow.
        // Counter overflow is incredibly unrealistic as tokenId would have to be 2**256.
        unchecked {
            _addressData[prevOwnership.addr].balance -= 1;
            _addressData[prevOwnership.addr].numberBurned += 1;

            // Keep track of who burned the token, and the timestamp of burning.
            _ownerships[tokenId].addr = prevOwnership.addr;
            _ownerships[tokenId].startTimestamp = uint64(block.timestamp);
            _ownerships[tokenId].burned = true;

            // If the ownership slot of tokenId+1 is not explicitly set, that means the burn initiator owns it.
            // Set the slot of tokenId+1 explicitly in storage to maintain correctness for ownerOf(tokenId+1) calls.
            uint256 nextTokenId = tokenId + 1;
            if (_ownerships[nextTokenId].addr == address(0)) {
                // This will suffice for checking _exists(nextTokenId),
                // as a burned slot cannot contain the zero address.
                if (nextTokenId < _currentIndex) {
                    _ownerships[nextTokenId].addr = prevOwnership.addr;
                    _ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

        emit Transfer(prevOwnership.addr, address(0), tokenId);
        _afterTokenTransfers(prevOwnership.addr, address(0), tokenId, 1);

        // Overflow not possible, as _burnCounter cannot be exceed _currentIndex times.
        unchecked {
            _burnCounter++;
        }
    }

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

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

    /**
     * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
     * And also called before burning one token.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` will be
     * transferred to `to`.
     * - When `from` is zero, `tokenId` will be minted for `to`.
     * - When `to` is zero, `tokenId` will be burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _beforeTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}

    /**
     * @dev Hook that is called after a set of serially-ordered token ids have been transferred. This includes
     * minting.
     * And also called after one token has been burned.
     *
     * startTokenId - the first token id to be transferred
     * quantity - the amount to be transferred
     *
     * Calling conditions:
     *
     * - When `from` and `to` are both non-zero, `from`'s `tokenId` has been
     * transferred to `to`.
     * - When `from` is zero, `tokenId` has been minted for `to`.
     * - When `to` is zero, `tokenId` has been burned by `from`.
     * - `from` and `to` are never both zero.
     */
    function _afterTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}
}

// File: erc721a/contracts/extensions/ERC721ABurnable.sol


// Creator: Chiru Labs

pragma solidity ^0.8.4;



/**
 * @title ERC721A Burnable Token
 * @dev ERC721A Token that can be irreversibly burned (destroyed).
 */
abstract contract ERC721ABurnable is Context, ERC721A {

    /**
     * @dev Burns `tokenId`. See {ERC721A-_burn}.
     *
     * Requirements:
     *
     * - The caller must own `tokenId` or be an approved operator.
     */
    function burn(uint256 tokenId) public virtual {
        TokenOwnership memory prevOwnership = ownershipOf(tokenId);

        bool isApprovedOrOwner = (_msgSender() == prevOwnership.addr ||
            isApprovedForAll(prevOwnership.addr, _msgSender()) ||
            getApproved(tokenId) == _msgSender());

        if (!isApprovedOrOwner) revert TransferCallerNotOwnerNorApproved();

        _burn(tokenId);
    }
}
// File: contracts/MDMA.sol


pragma solidity ^0.8.4;




//AE THER   

contract MDMA is ERC721A, Ownable, ReentrancyGuard , ERC721ABurnable {

  using Strings for uint256;
  uint256 public constant  maxSupply = 3333; 
  bytes32 public merkleRoot;
  string public  baseUri; 
  

  string public extension;
  uint256 public cost = 9900000000000000 ;  

  uint256 public maxperaddress = 2; 
 
  bool public publicEnabled = false;
  bool public whitelistMintEnabled = false;
  
  //mapping ID=>address => number of minted nfts  
  mapping(address => uint256) public addresstxs;
  
  constructor(
    string memory _Name,
    string memory _Symbol,
	uint256 _maxperaddress,
	bytes32 _merkleRoot,
 
    string memory _extension
  
  ) ERC721A(_Name, _Symbol) {
	// deploy the contract with the PWL parameters
    
	maxperaddress = _maxperaddress;
   
    extension = _extension;  
    merkleRoot = _merkleRoot;
  
	
  }
  //Modifiers
  //resets the amount of nft bought from whitelisted suer if the phase changes
      function _startTokenId() internal pure override returns (uint256){
    return 1;
  }

  //sets the maximum supply of nft that can be minted per phase 
  modifier mintCompliance(uint256 _mintAmount) {
    require(_totalMinted() + _mintAmount <= maxSupply, 'Max supply in this phase exceeded');  
    
    _;
  }
  //enough funds to buy NFTS
 

  function Presalemint(uint256 _mintAmount, bytes32[] calldata _merkleProof) public payable nonReentrant mintCompliance(_mintAmount)  {
    // Verify whitelist requirements dont allow mints when public sale starts
    require(addresstxs[msg.sender] + _mintAmount <= maxperaddress, "max per address exceeded ");
    require(whitelistMintEnabled, "Not in presale phase"); 
    //verify not that minting is not paused
    
    require(MerkleProof.verify(_merkleProof, merkleRoot, keccak256(abi.encodePacked(msg.sender))), 'Invalid proof!');
    // minting
    addresstxs[msg.sender] += _mintAmount;
    _safeMint(msg.sender, _mintAmount);
    
  
    
  }



   function publicMint(uint256 _mintAmount) public payable nonReentrant mintCompliance(_mintAmount)  {
    // Verify whitelist requirements dont allow mints when public sale starts
    require(_mintAmount > 0 , "invalid mint amount");
    require(msg.value >= cost * _mintAmount , "not enough price " );
   require(publicEnabled  , 'Still In paused phase'); 
    
    _safeMint(msg.sender, _mintAmount);
    
  
    
  }
  //Normal minting allows minting on public sale satisfyign the necessary conditions
 

  
  
  function Airdrop(uint256[] memory  _mintAmount, address[] memory   _receivers) public nonReentrant  onlyOwner {
       require(_mintAmount.length == _receivers.length, "Arrays need to be equal and respective");
    for(uint i = 0; i < _mintAmount.length;) {
        require(_totalMinted() + _mintAmount[i] <= maxSupply, 'Max supply exceeded!');
          _safeMint(_receivers[i], _mintAmount[i]);
          unchecked{i++;}
      }
  }

 // get multiple ids that a owner owns  excluding burned tokens  this function is for future off or on chain data gathering 
  function walletOfOwner(address _owner) public view returns (uint256[] memory) {
    uint256 ownerTokenCount = balanceOf(_owner);
    uint256[] memory ownedTokenIds = new uint256[](ownerTokenCount);
    uint256 currentTokenId = _startTokenId();
    uint256 ownedTokenIndex = 0;
    address latestOwnerAddress;
    while (ownedTokenIndex < ownerTokenCount && currentTokenId <= _totalMinted() ) {
      TokenOwnership memory ownership = _ownerships[currentTokenId]; 
      if (!ownership.burned && ownership.addr != address(0)) {
        latestOwnerAddress = ownership.addr; 
      }
      if (latestOwnerAddress == _owner &&  !ownership.burned )  {
        ownedTokenIds[ownedTokenIndex] = currentTokenId;
        ownedTokenIndex++;
      }
      currentTokenId++;
    }
    return ownedTokenIds;
  }

  function tokenURI(uint256 _tokenId) public view override returns (string memory) {
    require(_exists(_tokenId), 'ERC721Metadata: URI query for nonexistent token');
   
    return bytes(baseUri).length > 0 ? string(abi.encodePacked(baseUri, _tokenId.toString(), extension)) : '';
  }

// SETTERS DONE BY OWNER ONLY

 function setWLphase(uint256 _maxperaddress, bytes32 _merkleRoot) public onlyOwner {
setMaxPerAddress( _maxperaddress);
setMerkleRoot(_merkleRoot);
 }
  

     
  function setCost(uint256 _cost) public onlyOwner nonReentrant {
    cost = _cost;
  } 

  function setMaxPerAddress(uint256 _maxperaddress) public onlyOwner nonReentrant {
	maxperaddress = _maxperaddress;
  }
  
 

  function setUri(string memory _uri) public onlyOwner nonReentrant {
    baseUri = _uri;
  }
  // should be set before any minting starts 
  function setpublicEnabled (bool choice) public onlyOwner nonReentrant { 
    publicEnabled = choice;
  }
 
  function setwlEnabled(bool choice) public onlyOwner nonReentrant { 
    whitelistMintEnabled = choice;
  }
 
  function setMerkleRoot(bytes32 _merkleRoot) public onlyOwner nonReentrant {
    merkleRoot = _merkleRoot;
  }

 
 
     // release address based on shares.
   function withdrawEth() external onlyOwner nonReentrant {
    (bool success, ) = msg.sender.call{value: address(this).balance}("");
    require(success, "Transfer failed.");
  }
}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[{"internalType":"string","name":"_Name","type":"string"},{"internalType":"string","name":"_Symbol","type":"string"},{"internalType":"uint256","name":"_maxperaddress","type":"uint256"},{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"},{"internalType":"string","name":"_extension","type":"string"}],"stateMutability":"nonpayable","type":"constructor"},{"inputs":[],"name":"ApprovalCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"ApprovalQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"ApprovalToCurrentOwner","type":"error"},{"inputs":[],"name":"ApproveToCaller","type":"error"},{"inputs":[],"name":"BalanceQueryForZeroAddress","type":"error"},{"inputs":[],"name":"MintToZeroAddress","type":"error"},{"inputs":[],"name":"MintZeroQuantity","type":"error"},{"inputs":[],"name":"OwnerQueryForNonexistentToken","type":"error"},{"inputs":[],"name":"TransferCallerNotOwnerNorApproved","type":"error"},{"inputs":[],"name":"TransferFromIncorrectOwner","type":"error"},{"inputs":[],"name":"TransferToNonERC721ReceiverImplementer","type":"error"},{"inputs":[],"name":"TransferToZeroAddress","type":"error"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"uint256[]","name":"_mintAmount","type":"uint256[]"},{"internalType":"address[]","name":"_receivers","type":"address[]"}],"name":"Airdrop","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"},{"internalType":"bytes32[]","name":"_merkleProof","type":"bytes32[]"}],"name":"Presalemint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"addresstxs","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":"baseUri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"cost","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"extension","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxperaddress","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"merkleRoot","outputs":[{"internalType":"bytes32","name":"","type":"bytes32"}],"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":[],"name":"publicEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_mintAmount","type":"uint256"}],"name":"publicMint","outputs":[],"stateMutability":"payable","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":"uint256","name":"_cost","type":"uint256"}],"name":"setCost","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxperaddress","type":"uint256"}],"name":"setMaxPerAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"setMerkleRoot","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"_uri","type":"string"}],"name":"setUri","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"_maxperaddress","type":"uint256"},{"internalType":"bytes32","name":"_merkleRoot","type":"bytes32"}],"name":"setWLphase","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"choice","type":"bool"}],"name":"setpublicEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bool","name":"choice","type":"bool"}],"name":"setwlEnabled","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"_tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"_owner","type":"address"}],"name":"walletOfOwner","outputs":[{"internalType":"uint256[]","name":"","type":"uint256[]"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"whitelistMintEnabled","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"withdrawEth","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

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

00000000000000000000000000000000000000000000000000000000000000a000000000000000000000000000000000000000000000000000000000000000e00000000000000000000000000000000000000000000000000000000000000002aecf516c6067a69fbf6f850cac03111c51809e81ca01383e3e0f341fcb3f1327000000000000000000000000000000000000000000000000000000000000012000000000000000000000000000000000000000000000000000000000000000044d444d410000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000024d4400000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000052e6a736f6e000000000000000000000000000000000000000000000000000000

-----Decoded View---------------
Arg [0] : _Name (string): MDMA
Arg [1] : _Symbol (string): MD
Arg [2] : _maxperaddress (uint256): 2
Arg [3] : _merkleRoot (bytes32): 0xaecf516c6067a69fbf6f850cac03111c51809e81ca01383e3e0f341fcb3f1327
Arg [4] : _extension (string): .json

-----Encoded View---------------
11 Constructor Arguments found :
Arg [0] : 00000000000000000000000000000000000000000000000000000000000000a0
Arg [1] : 00000000000000000000000000000000000000000000000000000000000000e0
Arg [2] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [3] : aecf516c6067a69fbf6f850cac03111c51809e81ca01383e3e0f341fcb3f1327
Arg [4] : 0000000000000000000000000000000000000000000000000000000000000120
Arg [5] : 0000000000000000000000000000000000000000000000000000000000000004
Arg [6] : 4d444d4100000000000000000000000000000000000000000000000000000000
Arg [7] : 0000000000000000000000000000000000000000000000000000000000000002
Arg [8] : 4d44000000000000000000000000000000000000000000000000000000000000
Arg [9] : 0000000000000000000000000000000000000000000000000000000000000005
Arg [10] : 2e6a736f6e000000000000000000000000000000000000000000000000000000

Deployed Bytecode Sourcemap

58919:5380:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40471:305;;;;;;;;;;-1:-1:-1;40471:305:0;;;;;:::i;:::-;;:::i;:::-;;;10689:14:1;;10682:22;10664:41;;10652:2;10637:18;40471:305:0;;;;;;;;43856:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;45359:204::-;;;;;;;;;;-1:-1:-1;45359:204:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;9350:32:1;;;9332:51;;9320:2;9305:18;45359:204:0;9186:203:1;44922:371:0;;;;;;;;;;-1:-1:-1;44922:371:0;;;;;:::i;:::-;;:::i;:::-;;59164:38;;;;;;;;;;;;;;;;;;;10862:25:1;;;10850:2;10835:18;59164:38:0;10716:177:1;39720:303:0;;;;;;;;;;-1:-1:-1;59979:1:0;39974:12;39764:7;39958:13;:28;-1:-1:-1;;39958:46:0;39720:303;;46216:170;;;;;;;;;;-1:-1:-1;46216:170:0;;;;;:::i;:::-;;:::i;59212:32::-;;;;;;;;;;;;;;;;59136:23;;;;;;;;;;;;;:::i;60932:427::-;;;;;;:::i;:::-;;:::i;59072:25::-;;;;;;;;;;;;;;;;46457:185;;;;;;;;;;-1:-1:-1;46457:185:0;;;;;:::i;:::-;;:::i;58409:423::-;;;;;;;;;;-1:-1:-1;58409:423:0;;;;;:::i;:::-;;:::i;62035:816::-;;;;;;;;;;-1:-1:-1;62035:816:0;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;63352:87::-;;;;;;;;;;-1:-1:-1;63352:87:0;;;;;:::i;:::-;;:::i;60258:663::-;;;;;;:::i;:::-;;:::i;43665:124::-;;;;;;;;;;-1:-1:-1;43665:124:0;;;;;:::i;:::-;;:::i;59291:40::-;;;;;;;;;;-1:-1:-1;59291:40:0;;;;;;;;;;;40840:206;;;;;;;;;;-1:-1:-1;40840:206:0;;;;;:::i;:::-;;:::i;12801:103::-;;;;;;;;;;;;;:::i;63446:120::-;;;;;;;;;;-1:-1:-1;63446:120:0;;;;;:::i;:::-;;:::i;63951:111::-;;;;;;;;;;-1:-1:-1;63951:111:0;;;;;:::i;:::-;;:::i;12150:87::-;;;;;;;;;;-1:-1:-1;12223:6:0;;-1:-1:-1;;;;;12223:6:0;12150:87;;44025:104;;;;;;;;;;;;;:::i;59102:22::-;;;;;;;;;;;;;:::i;59253:33::-;;;;;;;;;;-1:-1:-1;59253:33:0;;;;;;;;63579:93;;;;;;;;;;-1:-1:-1;63579:93:0;;;;;:::i;:::-;;:::i;64117:179::-;;;;;;;;;;;;;:::i;45635:279::-;;;;;;;;;;-1:-1:-1;45635:279:0;;;;;:::i;:::-;;:::i;46717:369::-;;;;;;;;;;-1:-1:-1;46717:369:0;;;;;:::i;:::-;;:::i;63183:152::-;;;;;;;;;;-1:-1:-1;63183:152:0;;;;;:::i;:::-;;:::i;62857:288::-;;;;;;;;;;-1:-1:-1;62857:288:0;;;;;:::i;:::-;;:::i;63723:106::-;;;;;;;;;;-1:-1:-1;63723:106:0;;;;;:::i;:::-;;:::i;59025:41::-;;;;;;;;;;;;59062:4;59025:41;;63836:108;;;;;;;;;;-1:-1:-1;63836:108:0;;;;;:::i;:::-;;:::i;61462:441::-;;;;;;;;;;-1:-1:-1;61462:441:0;;;;;:::i;:::-;;:::i;45985:164::-;;;;;;;;;;-1:-1:-1;45985:164:0;;;;;:::i;:::-;-1:-1:-1;;;;;46106:25:0;;;46082:4;46106:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;45985:164;13059:201;;;;;;;;;;-1:-1:-1;13059:201:0;;;;;:::i;:::-;;:::i;59392:45::-;;;;;;;;;;-1:-1:-1;59392:45:0;;;;;:::i;:::-;;;;;;;;;;;;;;40471:305;40573:4;-1:-1:-1;;;;;;40610:40:0;;-1:-1:-1;;;40610:40:0;;:105;;-1:-1:-1;;;;;;;40667:48:0;;-1:-1:-1;;;40667:48:0;40610:105;:158;;;-1:-1:-1;;;;;;;;;;29171:40:0;;;40732:36;40590:178;40471:305;-1:-1:-1;;40471:305:0:o;43856:100::-;43910:13;43943:5;43936:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;43856:100;:::o;45359:204::-;45427:7;45452:16;45460:7;45452;:16::i;:::-;45447:64;;45477:34;;-1:-1:-1;;;45477:34:0;;;;;;;;;;;45447:64;-1:-1:-1;45531:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;45531:24:0;;45359:204::o;44922:371::-;44995:13;45011:24;45027:7;45011:15;:24::i;:::-;44995:40;;45056:5;-1:-1:-1;;;;;45050:11:0;:2;-1:-1:-1;;;;;45050:11:0;;45046:48;;;45070:24;;-1:-1:-1;;;45070:24:0;;;;;;;;;;;45046:48;10954:10;-1:-1:-1;;;;;45111:21:0;;;;;;:63;;-1:-1:-1;45137:37:0;45154:5;10954:10;45985:164;:::i;45137:37::-;45136:38;45111:63;45107:138;;;45198:35;;-1:-1:-1;;;45198:35:0;;;;;;;;;;;45107:138;45257:28;45266:2;45270:7;45279:5;45257:8;:28::i;:::-;44984:309;44922:371;;:::o;46216:170::-;46350:28;46360:4;46366:2;46370:7;46350:9;:28::i;59136:23::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;60932:427::-;4735:1;5333:7;;:19;;5325:63;;;;-1:-1:-1;;;5325:63:0;;;;;;;:::i;:::-;;;;;;;;;4735:1;5466:7;:18;61016:11;59062:4:::1;61016:11:::0;60118:14:::1;40163:7:::0;40349:13;-1:-1:-1;;40349:31:0;;40116:283;60118:14:::1;:28;;;;:::i;:::-;:41;;60110:87;;;;-1:-1:-1::0;;;60110:87:0::1;;;;;;;:::i;:::-;61138:1:::2;61124:11;:15;61116:48;;;::::0;-1:-1:-1;;;61116:48:0;;11673:2:1;61116:48:0::2;::::0;::::2;11655:21:1::0;11712:2;11692:18;;;11685:30;-1:-1:-1;;;11731:18:1;;;11724:49;11790:18;;61116:48:0::2;11471:343:1::0;61116:48:0::2;61199:11;61192:4;;:18;;;;:::i;:::-;61179:9;:31;;61171:63;;;::::0;-1:-1:-1;;;61171:63:0;;16115:2:1;61171:63:0::2;::::0;::::2;16097:21:1::0;16154:2;16134:18;;;16127:30;-1:-1:-1;;;16173:18:1;;;16166:47;16230:18;;61171:63:0::2;15913:341:1::0;61171:63:0::2;61248:13;::::0;::::2;;61240:49;;;::::0;-1:-1:-1;;;61240:49:0;;15405:2:1;61240:49:0::2;::::0;::::2;15387:21:1::0;15444:2;15424:18;;;15417:30;-1:-1:-1;;;15463:18:1;;;15456:51;15524:18;;61240:49:0::2;15203:345:1::0;61240:49:0::2;61303:34;61313:10;61325:11;61303:9;:34::i;:::-;-1:-1:-1::0;;4691:1:0;5645:7;:22;60932:427::o;46457:185::-;46595:39;46612:4;46618:2;46622:7;46595:39;;;;;;;;;;;;:16;:39::i;58409:423::-;58466:35;58504:20;58516:7;58504:11;:20::i;:::-;58579:18;;58466:58;;-1:-1:-1;58537:22:0;;-1:-1:-1;;;;;58563:34:0;10954:10;-1:-1:-1;;;;;58563:34:0;;:101;;;-1:-1:-1;58631:18:0;;58614:50;;10954:10;45985:164;:::i;58614:50::-;58563:154;;;-1:-1:-1;10954:10:0;58681:20;58693:7;58681:11;:20::i;:::-;-1:-1:-1;;;;;58681:36:0;;58563:154;58537:181;;58736:17;58731:66;;58762:35;;-1:-1:-1;;;58762:35:0;;;;;;;;;;;58731:66;58810:14;58816:7;58810:5;:14::i;62035:816::-;62095:16;62120:23;62146:17;62156:6;62146:9;:17::i;:::-;62120:43;;62170:30;62217:15;-1:-1:-1;;;;;62203:30:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;62203:30:0;-1:-1:-1;62170:63:0;-1:-1:-1;59979:1:0;62240:22;;62354:465;62379:15;62361;:33;:69;;;;-1:-1:-1;40163:7:0;40349:13;-1:-1:-1;;40349:31:0;62398:14;:32;;62361:69;62354:465;;;62442:31;62476:27;;;:11;:27;;;;;;;;;62442:61;;;;;;;;;-1:-1:-1;;;;;62442:61:0;;;;-1:-1:-1;;;62442:61:0;;-1:-1:-1;;;;;62442:61:0;;;;;;;;-1:-1:-1;;;62442:61:0;;;;;;;;;;;;;;;;62517:49;;-1:-1:-1;62538:14:0;;-1:-1:-1;;;;;62538:28:0;;;62517:49;62513:112;;;62600:14;;;-1:-1:-1;62513:112:0;62659:6;-1:-1:-1;;;;;62637:28:0;:18;-1:-1:-1;;;;;62637:28:0;;:50;;;;;62671:9;:16;;;62670:17;62637:50;62633:154;;;62735:14;62702:13;62716:15;62702:30;;;;;;;;:::i;:::-;;;;;;;;;;:47;62760:17;;;;:::i;:::-;;;;62633:154;62795:16;;;;:::i;:::-;;;;62433:386;62354:465;;;-1:-1:-1;62832:13:0;;62035:816;-1:-1:-1;;;;;62035:816:0:o;63352:87::-;12223:6;;-1:-1:-1;;;;;12223:6:0;10954:10;12370:23;12362:68;;;;-1:-1:-1;;;12362:68:0;;;;;;;:::i;:::-;4735:1:::1;5333:7;;:19;;5325:63;;;;-1:-1:-1::0;;;5325:63:0::1;;;;;;;:::i;:::-;63421:4:::2;:12:::0;4691:1:::1;5466:7;5645:22:::0;63352:87::o;60258:663::-;4735:1;5333:7;;:19;;5325:63;;;;-1:-1:-1;;;5325:63:0;;;;;;;:::i;:::-;4735:1;5466:7;:18;60376:11;59062:4:::1;60376:11:::0;60118:14:::1;40163:7:::0;40349:13;-1:-1:-1;;40349:31:0;;40116:283;60118:14:::1;:28;;;;:::i;:::-;:41;;60110:87;;;;-1:-1:-1::0;;;60110:87:0::1;;;;;;;:::i;:::-;60524:13:::2;::::0;60495:10:::2;60484:22;::::0;;;:10:::2;:22;::::0;;;;;:36:::2;::::0;60509:11;;60484:36:::2;:::i;:::-;:53;;60476:91;;;::::0;-1:-1:-1;;;60476:91:0;;13178:2:1;60476:91:0::2;::::0;::::2;13160:21:1::0;13217:2;13197:18;;;13190:30;13256:27;13236:18;;;13229:55;13301:18;;60476:91:0::2;12976:349:1::0;60476:91:0::2;60582:20;::::0;::::2;::::0;::::2;;;60574:53;;;::::0;-1:-1:-1;;;60574:53:0;;11324:2:1;60574:53:0::2;::::0;::::2;11306:21:1::0;11363:2;11343:18;;;11336:30;-1:-1:-1;;;11382:18:1;;;11375:50;11442:18;;60574:53:0::2;11122:344:1::0;60574:53:0::2;60694:85;60713:12;;60694:85;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::2;::::0;;;;-1:-1:-1;;60727:10:0::2;::::0;60749:28:::2;::::0;-1:-1:-1;;60766:10:0::2;8430:2:1::0;8426:15;8422:53;60749:28:0::2;::::0;::::2;8410:66:1::0;60727:10:0;;-1:-1:-1;8492:12:1;;;-1:-1:-1;60749:28:0::2;;;;;;;;;;;;60739:39;;;;;;60694:18;:85::i;:::-;60686:112;;;::::0;-1:-1:-1;;;60686:112:0;;12021:2:1;60686:112:0::2;::::0;::::2;12003:21:1::0;12060:2;12040:18;;;12033:30;-1:-1:-1;;;12079:18:1;;;12072:44;12133:18;;60686:112:0::2;11819:338:1::0;60686:112:0::2;60832:10;60821:22;::::0;;;:10:::2;:22;::::0;;;;:37;;60847:11;;60821:22;:37:::2;::::0;60847:11;;60821:37:::2;:::i;:::-;::::0;;;-1:-1:-1;60865:34:0::2;::::0;-1:-1:-1;60875:10:0::2;60887:11:::0;60865:9:::2;:34::i;:::-;-1:-1:-1::0;;4691:1:0;5645:7;:22;-1:-1:-1;;60258:663:0:o;43665:124::-;43729:7;43756:20;43768:7;43756:11;:20::i;:::-;:25;;43665:124;-1:-1:-1;;43665:124:0:o;40840:206::-;40904:7;-1:-1:-1;;;;;40928:19:0;;40924:60;;40956:28;;-1:-1:-1;;;40956:28:0;;;;;;;;;;;40924:60;-1:-1:-1;;;;;;41010:19:0;;;;;:12;:19;;;;;:27;-1:-1:-1;;;;;41010:27:0;;40840:206::o;12801:103::-;12223:6;;-1:-1:-1;;;;;12223:6:0;10954:10;12370:23;12362:68;;;;-1:-1:-1;;;12362:68:0;;;;;;;:::i;:::-;12866:30:::1;12893:1;12866:18;:30::i;:::-;12801:103::o:0;63446:120::-;12223:6;;-1:-1:-1;;;;;12223:6:0;10954:10;12370:23;12362:68;;;;-1:-1:-1;;;12362:68:0;;;;;;;:::i;:::-;4735:1:::1;5333:7;;:19;;5325:63;;;;-1:-1:-1::0;;;5325:63:0::1;;;;;;;:::i;:::-;63530:13:::2;:30:::0;4691:1:::1;5466:7;5645:22:::0;63446:120::o;63951:111::-;12223:6;;-1:-1:-1;;;;;12223:6:0;10954:10;12370:23;12362:68;;;;-1:-1:-1;;;12362:68:0;;;;;;;:::i;:::-;4735:1:::1;5333:7;;:19;;5325:63;;;;-1:-1:-1::0;;;5325:63:0::1;;;;;;;:::i;:::-;64032:10:::2;:24:::0;4691:1:::1;5466:7;5645:22:::0;63951:111::o;44025:104::-;44081:13;44114:7;44107:14;;;;;:::i;59102:22::-;;;;;;;:::i;63579:93::-;12223:6;;-1:-1:-1;;;;;12223:6:0;10954:10;12370:23;12362:68;;;;-1:-1:-1;;;12362:68:0;;;;;;;:::i;:::-;4735:1:::1;5333:7;;:19;;5325:63;;;;-1:-1:-1::0;;;5325:63:0::1;;;;;;;:::i;:::-;4735:1;5466:7;:18:::0;63652:14;;::::2;::::0;:7:::2;::::0;:14:::2;::::0;::::2;::::0;::::2;:::i;64117:179::-:0;12223:6;;-1:-1:-1;;;;;12223:6:0;10954:10;12370:23;12362:68;;;;-1:-1:-1;;;12362:68:0;;;;;;;:::i;:::-;4735:1:::1;5333:7;;:19;;5325:63;;;;-1:-1:-1::0;;;5325:63:0::1;;;;;;;:::i;:::-;4735:1;5466:7;:18:::0;64198:49:::2;::::0;64180:12:::2;::::0;64198:10:::2;::::0;64221:21:::2;::::0;64180:12;64198:49;64180:12;64198:49;64221:21;64198:10;:49:::2;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;64179:68;;;64262:7;64254:36;;;::::0;-1:-1:-1;;;64254:36:0;;15060:2:1;64254:36:0::2;::::0;::::2;15042:21:1::0;15099:2;15079:18;;;15072:30;-1:-1:-1;;;15118:18:1;;;15111:46;15174:18;;64254:36:0::2;14858:340:1::0;64254:36:0::2;-1:-1:-1::0;4691:1:0::1;5645:7;:22:::0;64117:179::o;45635:279::-;-1:-1:-1;;;;;45726:24:0;;10954:10;45726:24;45722:54;;;45759:17;;-1:-1:-1;;;45759:17:0;;;;;;;;;;;45722:54;10954:10;45789:32;;;;:18;:32;;;;;;;;-1:-1:-1;;;;;45789:42:0;;;;;;;;;;;;:53;;-1:-1:-1;;45789:53:0;;;;;;;;;;45858:48;;10664:41:1;;;45789:42:0;;10954:10;45858:48;;10637:18:1;45858:48:0;;;;;;;45635:279;;:::o;46717:369::-;46884:28;46894:4;46900:2;46904:7;46884:9;:28::i;:::-;-1:-1:-1;;;;;46927:13:0;;15147:19;:23;;46927:76;;;;;46947:56;46978:4;46984:2;46988:7;46997:5;46947:30;:56::i;:::-;46946:57;46927:76;46923:156;;;47027:40;;-1:-1:-1;;;47027:40:0;;;;;;;;;;;46923:156;46717:369;;;;:::o;63183:152::-;12223:6;;-1:-1:-1;;;;;12223:6:0;10954:10;12370:23;12362:68;;;;-1:-1:-1;;;12362:68:0;;;;;;;:::i;:::-;63268:33:::1;63286:14;63268:16;:33::i;:::-;63304:26;63318:11;63304:13;:26::i;:::-;63183:152:::0;;:::o;62857:288::-;62923:13;62953:17;62961:8;62953:7;:17::i;:::-;62945:77;;;;-1:-1:-1;;;62945:77:0;;14295:2:1;62945:77:0;;;14277:21:1;14334:2;14314:18;;;14307:30;14373:34;14353:18;;;14346:62;-1:-1:-1;;;14424:18:1;;;14417:45;14479:19;;62945:77:0;14093:411:1;62945:77:0;63065:1;63047:7;63041:21;;;;;:::i;:::-;;;:25;:98;;;;;;;;;;;;;;;;;63093:7;63102:19;:8;:17;:19::i;:::-;63123:9;63076:57;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;63034:105;62857:288;-1:-1:-1;;62857:288:0:o;63723:106::-;12223:6;;-1:-1:-1;;;;;12223:6:0;10954:10;12370:23;12362:68;;;;-1:-1:-1;;;12362:68:0;;;;;;;:::i;:::-;4735:1:::1;5333:7;;:19;;5325:63;;;;-1:-1:-1::0;;;5325:63:0::1;;;;;;;:::i;:::-;63801:13:::2;:22:::0;;-1:-1:-1;;63801:22:0::2;::::0;::::2;;::::0;;;::::2;::::0;;-1:-1:-1;5466:7:0::1;5645:22:::0;63723:106::o;63836:108::-;12223:6;;-1:-1:-1;;;;;12223:6:0;10954:10;12370:23;12362:68;;;;-1:-1:-1;;;12362:68:0;;;;;;;:::i;:::-;4735:1:::1;5333:7;;:19;;5325:63;;;;-1:-1:-1::0;;;5325:63:0::1;;;;;;;:::i;:::-;63909:20:::2;:29:::0;;;::::2;;;;-1:-1:-1::0;;63909:29:0;;::::2;::::0;;;::::2;::::0;;:20:::2;5466:7:::1;5645:22:::0;63836:108::o;61462:441::-;4735:1;5333:7;;:19;;5325:63;;;;-1:-1:-1;;;5325:63:0;;;;;;;:::i;:::-;4735:1;5466:7;:18;12223:6;;-1:-1:-1;;;;;12223:6:0;10954:10;12370:23:::1;12362:68;;;;-1:-1:-1::0;;;12362:68:0::1;;;;;;;:::i;:::-;61612:10:::2;:17;61590:11;:18;:39;61582:90;;;::::0;-1:-1:-1;;;61582:90:0;;12771:2:1;61582:90:0::2;::::0;::::2;12753:21:1::0;12810:2;12790:18;;;12783:30;12849:34;12829:18;;;12822:62;-1:-1:-1;;;12900:18:1;;;12893:36;12946:19;;61582:90:0::2;12569:402:1::0;61582:90:0::2;61683:6;61679:219;61699:11;:18;61695:1;:22;61679:219;;;59062:4;61756:11;61768:1;61756:14;;;;;;;;:::i;:::-;;;;;;;61739;40163:7:::0;40349:13;-1:-1:-1;;40349:31:0;;40116:283;61739:14:::2;:31;;;;:::i;:::-;:44;;61731:77;;;::::0;-1:-1:-1;;;61731:77:0;;14711:2:1;61731:77:0::2;::::0;::::2;14693:21:1::0;14750:2;14730:18;;;14723:30;-1:-1:-1;;;14769:18:1;;;14762:50;14829:18;;61731:77:0::2;14509:344:1::0;61731:77:0::2;61821:40;61831:10;61842:1;61831:13;;;;;;;;:::i;:::-;;;;;;;61846:11;61858:1;61846:14;;;;;;;;:::i;:::-;;;;;;;61821:9;:40::i;:::-;61884:3;;61679:219;;;-1:-1:-1::0;;4691:1:0;5645:7;:22;-1:-1:-1;61462:441:0:o;13059:201::-;12223:6;;-1:-1:-1;;;;;12223:6:0;10954:10;12370:23;12362:68;;;;-1:-1:-1;;;12362:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;13148:22:0;::::1;13140:73;;;::::0;-1:-1:-1;;;13140:73:0;;12364:2:1;13140:73:0::1;::::0;::::1;12346:21:1::0;12403:2;12383:18;;;12376:30;12442:34;12422:18;;;12415:62;-1:-1:-1;;;12493:18:1;;;12486:36;12539:19;;13140:73:0::1;12162:402:1::0;13140:73:0::1;13224:28;13243:8;13224:18;:28::i;:::-;13059:201:::0;:::o;47341:187::-;47398:4;47441:7;59979:1;47422:26;;:53;;;;;47462:13;;47452:7;:23;47422:53;:98;;;;-1:-1:-1;;47493:20:0;;;;:11;:20;;;;;:27;-1:-1:-1;;;47493:27:0;;;;47492:28;;47341:187::o;54953:196::-;55068:24;;;;:15;:24;;;;;;:29;;-1:-1:-1;;;;;;55068:29:0;-1:-1:-1;;;;;55068:29:0;;;;;;;;;55113:28;;55068:24;;55113:28;;;;;;;54953:196;;;:::o;50455:2112::-;50570:35;50608:20;50620:7;50608:11;:20::i;:::-;50683:18;;50570:58;;-1:-1:-1;50641:22:0;;-1:-1:-1;;;;;50667:34:0;10954:10;-1:-1:-1;;;;;50667:34:0;;:101;;;-1:-1:-1;50735:18:0;;50718:50;;10954:10;45985:164;:::i;50718:50::-;50667:154;;;-1:-1:-1;10954:10:0;50785:20;50797:7;50785:11;:20::i;:::-;-1:-1:-1;;;;;50785:36:0;;50667:154;50641:181;;50840:17;50835:66;;50866:35;;-1:-1:-1;;;50866:35:0;;;;;;;;;;;50835:66;50938:4;-1:-1:-1;;;;;50916:26:0;:13;:18;;;-1:-1:-1;;;;;50916:26:0;;50912:67;;50951:28;;-1:-1:-1;;;50951:28:0;;;;;;;;;;;50912:67;-1:-1:-1;;;;;50994:16:0;;50990:52;;51019:23;;-1:-1:-1;;;51019:23:0;;;;;;;;;;;50990:52;51163:49;51180:1;51184:7;51193:13;:18;;;51163:8;:49::i;:::-;-1:-1:-1;;;;;51508:18:0;;;;;;;:12;:18;;;;;;;;:31;;-1:-1:-1;;51508:31:0;;;-1:-1:-1;;;;;51508:31:0;;;-1:-1:-1;;51508:31:0;;;;;;;51554:16;;;;;;;;;:29;;;;;;;;-1:-1:-1;51554:29:0;;;;;;;;;;;51600:20;;;:11;:20;;;;;;:30;;-1:-1:-1;;;;;;51645:61:0;;;;-1:-1:-1;;;51690:15:0;51645:61;;;;;;;;;;;51980:11;;;52010:24;;;;;:29;51980:11;;52010:29;52006:445;;52235:13;;52221:11;:27;52217:219;;;52305:18;;;52273:24;;;:11;:24;;;;;;;;:50;;52388:28;;;;-1:-1:-1;;;;;52346:70:0;-1:-1:-1;;;52346:70:0;-1:-1:-1;;;;;;52346:70:0;;;-1:-1:-1;;;;;52273:50:0;;;52346:70;;;;;;;52217:219;51483:979;52498:7;52494:2;-1:-1:-1;;;;;52479:27:0;52488:4;-1:-1:-1;;;;;52479:27:0;-1:-1:-1;;;;;;;;;;;52479:27:0;;;;;;;;;52517:42;50559:2008;;50455:2112;;;:::o;47536:104::-;47605:27;47615:2;47619:8;47605:27;;;;;;;;;;;;:9;:27::i;42495:1108::-;-1:-1:-1;;;;;;;;;;;;;;;;;;;;;;;;;42605:7:0;;59979:1;42654:23;;:47;;;;;42688:13;;42681:4;:20;42654:47;42650:886;;;42722:31;42756:17;;;:11;:17;;;;;;;;;42722:51;;;;;;;;;-1:-1:-1;;;;;42722:51:0;;;;-1:-1:-1;;;42722:51:0;;-1:-1:-1;;;;;42722:51:0;;;;;;;;-1:-1:-1;;;42722:51:0;;;;;;;;;;;;;;42792:729;;42842:14;;-1:-1:-1;;;;;42842:28:0;;42838:101;;42906:9;42495:1108;-1:-1:-1;;;42495:1108:0:o;42838:101::-;-1:-1:-1;;;43281:6:0;43326:17;;;;:11;:17;;;;;;;;;43314:29;;;;;;;;;-1:-1:-1;;;;;43314:29:0;;;;;-1:-1:-1;;;43314:29:0;;-1:-1:-1;;;;;43314:29:0;;;;;;;;-1:-1:-1;;;43314:29:0;;;;;;;;;;;;;43374:28;43370:109;;43442:9;42495:1108;-1:-1:-1;;;42495:1108:0:o;43370:109::-;43241:261;;;42703:833;42650:886;43564:31;;-1:-1:-1;;;43564:31:0;;;;;;;;;;;52796:2039;52856:35;52894:20;52906:7;52894:11;:20::i;:::-;52856:58;-1:-1:-1;53057:49:0;53074:1;53078:7;53087:13;:18;;;53057:8;:49::i;:::-;53415:18;;-1:-1:-1;;;;;53402:32:0;;;;;;;:12;:32;;;;;;;;:45;;-1:-1:-1;;53402:45:0;;-1:-1:-1;;;;;53402:45:0;;;-1:-1:-1;;53402:45:0;;;;;;;53475:18;;53462:32;;;;;;;:50;;-1:-1:-1;;;;53462:50:0;;-1:-1:-1;;;53462:50:0;;;;;;-1:-1:-1;53462:50:0;;;;;;;;;;;;53639:18;;53611:20;;;:11;:20;;;;;;:46;;-1:-1:-1;;;53611:46:0;;;-1:-1:-1;;;;;;53672:61:0;;;;-1:-1:-1;;;53717:15:0;53672:61;;;;;;;;;;;-1:-1:-1;;;;53748:34:0;;;;;;;54052:11;;;54082:24;;;;;:29;54052:11;;54082:29;54078:445;;54307:13;;54293:11;:27;54289:219;;;54377:18;;;54345:24;;;:11;:24;;;;;;;;:50;;54460:28;;;;-1:-1:-1;;;;;54418:70:0;-1:-1:-1;;;54418:70:0;-1:-1:-1;;;;;;54418:70:0;;;-1:-1:-1;;;;;54345:50:0;;;54418:70;;;;;;;54289:219;-1:-1:-1;54560:18:0;;54551:49;;54592:7;;54588:1;;-1:-1:-1;;;;;54551:49:0;;;;-1:-1:-1;;;;;;;;;;;54551:49:0;54588:1;;54551:49;-1:-1:-1;;54802:12:0;:14;;;;;;52796:2039::o;6605:190::-;6730:4;6783;6754:25;6767:5;6774:4;6754:12;:25::i;:::-;:33;;6605:190;-1:-1:-1;;;;6605:190:0:o;13420:191::-;13513:6;;;-1:-1:-1;;;;;13530:17:0;;;-1:-1:-1;;;;;;13530:17:0;;;;;;;13563:40;;13513:6;;;13530:17;13513:6;;13563:40;;13494:16;;13563:40;13483:128;13420:191;:::o;55641:667::-;55825:72;;-1:-1:-1;;;55825:72:0;;55804:4;;-1:-1:-1;;;;;55825:36:0;;;;;:72;;10954:10;;55876:4;;55882:7;;55891:5;;55825:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;55825:72:0;;;;;;;;-1:-1:-1;;55825:72:0;;;;;;;;;;;;:::i;:::-;;;55821:480;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;56059:13:0;;56055:235;;56105:40;;-1:-1:-1;;;56105:40:0;;;;;;;;;;;56055:235;56248:6;56242:13;56233:6;56229:2;56225:15;56218:38;55821:480;-1:-1:-1;;;;;;55944:55:0;-1:-1:-1;;;55944:55:0;;-1:-1:-1;55821:480:0;55641:667;;;;;;:::o;8436:723::-;8492:13;8713:10;8709:53;;-1:-1:-1;;8740:10:0;;;;;;;;;;;;-1:-1:-1;;;8740:10:0;;;;;8436:723::o;8709:53::-;8787:5;8772:12;8828:78;8835:9;;8828:78;;8861:8;;;;:::i;:::-;;-1:-1:-1;8884:10:0;;-1:-1:-1;8892:2:0;8884:10;;:::i;:::-;;;8828:78;;;8916:19;8948:6;-1:-1:-1;;;;;8938:17:0;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;8938:17:0;;8916:39;;8966:154;8973:10;;8966:154;;9000:11;9010:1;9000:11;;:::i;:::-;;-1:-1:-1;9069:10:0;9077:2;9069:5;:10;:::i;:::-;9056:24;;:2;:24;:::i;:::-;9043:39;;9026:6;9033;9026:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;9026:56:0;;;;;;;;-1:-1:-1;9097:11:0;9106:2;9097:11;;:::i;:::-;;;8966:154;;48003:163;48126:32;48132:2;48136:8;48146:5;48153:4;48126:5;:32::i;7157:675::-;7240:7;7283:4;7240:7;7298:497;7322:5;:12;7318:1;:16;7298:497;;;7356:20;7379:5;7385:1;7379:8;;;;;;;;:::i;:::-;;;;;;;7356:31;;7422:12;7406;:28;7402:382;;7908:13;7958:15;;;7994:4;7987:15;;;8041:4;8025:21;;7534:57;;7402:382;;;7908:13;7958:15;;;7994:4;7987:15;;;8041:4;8025:21;;7711:57;;7402:382;-1:-1:-1;7336:3:0;;;;:::i;:::-;;;;7298:497;;;-1:-1:-1;7812:12:0;7157:675;-1:-1:-1;;;7157:675:0:o;48425:1775::-;48564:20;48587:13;-1:-1:-1;;;;;48615:16:0;;48611:48;;48640:19;;-1:-1:-1;;;48640:19:0;;;;;;;;;;;48611:48;48674:13;48670:44;;48696:18;;-1:-1:-1;;;48696:18:0;;;;;;;;;;;48670:44;-1:-1:-1;;;;;49065:16:0;;;;;;:12;:16;;;;;;;;:44;;-1:-1:-1;;49124:49:0;;-1:-1:-1;;;;;49065:44:0;;;;;;;49124:49;;;;-1:-1:-1;;49065:44:0;;;;;;49124:49;;;;;;;;;;;;;;;;49190:25;;;:11;:25;;;;;;:35;;-1:-1:-1;;;;;;49240:66:0;;;;-1:-1:-1;;;49290:15:0;49240:66;;;;;;;;;;49190:25;49387:23;;;49431:4;:23;;;;-1:-1:-1;;;;;;49439:13:0;;15147:19;:23;;49439:15;49427:641;;;49475:314;49506:38;;49531:12;;-1:-1:-1;;;;;49506:38:0;;;49523:1;;-1:-1:-1;;;;;;;;;;;49506:38:0;49523:1;;49506:38;49572:69;49611:1;49615:2;49619:14;;;;;;49635:5;49572:30;:69::i;:::-;49567:174;;49677:40;;-1:-1:-1;;;49677:40:0;;;;;;;;;;;49567:174;49784:3;49768:12;:19;;49475:314;;49870:12;49853:13;;:29;49849:43;;49884:8;;;49849:43;49427:641;;;49933:120;49964:40;;49989:14;;;;;-1:-1:-1;;;;;49964:40:0;;;49981:1;;-1:-1:-1;;;;;;;;;;;49964:40:0;49981:1;;49964:40;50048:3;50032:12;:19;;49933:120;;49427:641;-1:-1:-1;50082:13:0;:28;50132:60;46717:369;-1:-1:-1;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;14:406:1;78:5;-1:-1:-1;;;;;104:6:1;101:30;98:56;;;134:18;;:::i;:::-;172:57;217:2;196:15;;-1:-1:-1;;192:29:1;223:4;188:40;172:57;:::i;:::-;163:66;;252:6;245:5;238:21;292:3;283:6;278:3;274:16;271:25;268:45;;;309:1;306;299:12;268:45;358:6;353:3;346:4;339:5;335:16;322:43;412:1;405:4;396:6;389:5;385:18;381:29;374:40;14:406;;;;;:::o;425:173::-;493:20;;-1:-1:-1;;;;;542:31:1;;532:42;;522:70;;588:1;585;578:12;522:70;425:173;;;:::o;603:679::-;657:5;710:3;703:4;695:6;691:17;687:27;677:55;;728:1;725;718:12;677:55;764:6;751:20;790:4;814:60;830:43;870:2;830:43;:::i;:::-;814:60;:::i;:::-;896:3;920:2;915:3;908:15;948:2;943:3;939:12;932:19;;983:2;975:6;971:15;1035:3;1030:2;1024;1021:1;1017:10;1009:6;1005:23;1001:32;998:41;995:61;;;1052:1;1049;1042:12;995:61;1074:1;1084:169;1098:2;1095:1;1092:9;1084:169;;;1155:23;1174:3;1155:23;:::i;:::-;1143:36;;1199:12;;;;1231;;;;1116:1;1109:9;1084:169;;;-1:-1:-1;1271:5:1;;603:679;-1:-1:-1;;;;;;;603:679:1:o;1287:160::-;1352:20;;1408:13;;1401:21;1391:32;;1381:60;;1437:1;1434;1427:12;1452:186;1511:6;1564:2;1552:9;1543:7;1539:23;1535:32;1532:52;;;1580:1;1577;1570:12;1532:52;1603:29;1622:9;1603:29;:::i;:::-;1593:39;1452:186;-1:-1:-1;;;1452:186:1:o;1643:260::-;1711:6;1719;1772:2;1760:9;1751:7;1747:23;1743:32;1740:52;;;1788:1;1785;1778:12;1740:52;1811:29;1830:9;1811:29;:::i;:::-;1801:39;;1859:38;1893:2;1882:9;1878:18;1859:38;:::i;:::-;1849:48;;1643:260;;;;;:::o;1908:328::-;1985:6;1993;2001;2054:2;2042:9;2033:7;2029:23;2025:32;2022:52;;;2070:1;2067;2060:12;2022:52;2093:29;2112:9;2093:29;:::i;:::-;2083:39;;2141:38;2175:2;2164:9;2160:18;2141:38;:::i;:::-;2131:48;;2226:2;2215:9;2211:18;2198:32;2188:42;;1908:328;;;;;:::o;2241:666::-;2336:6;2344;2352;2360;2413:3;2401:9;2392:7;2388:23;2384:33;2381:53;;;2430:1;2427;2420:12;2381:53;2453:29;2472:9;2453:29;:::i;:::-;2443:39;;2501:38;2535:2;2524:9;2520:18;2501:38;:::i;:::-;2491:48;;2586:2;2575:9;2571:18;2558:32;2548:42;;2641:2;2630:9;2626:18;2613:32;-1:-1:-1;;;;;2660:6:1;2657:30;2654:50;;;2700:1;2697;2690:12;2654:50;2723:22;;2776:4;2768:13;;2764:27;-1:-1:-1;2754:55:1;;2805:1;2802;2795:12;2754:55;2828:73;2893:7;2888:2;2875:16;2870:2;2866;2862:11;2828:73;:::i;:::-;2818:83;;;2241:666;;;;;;;:::o;2912:254::-;2977:6;2985;3038:2;3026:9;3017:7;3013:23;3009:32;3006:52;;;3054:1;3051;3044:12;3006:52;3077:29;3096:9;3077:29;:::i;:::-;3067:39;;3125:35;3156:2;3145:9;3141:18;3125:35;:::i;3171:254::-;3239:6;3247;3300:2;3288:9;3279:7;3275:23;3271:32;3268:52;;;3316:1;3313;3306:12;3268:52;3339:29;3358:9;3339:29;:::i;:::-;3329:39;3415:2;3400:18;;;;3387:32;;-1:-1:-1;;;3171:254:1:o;3430:1151::-;3548:6;3556;3609:2;3597:9;3588:7;3584:23;3580:32;3577:52;;;3625:1;3622;3615:12;3577:52;3665:9;3652:23;-1:-1:-1;;;;;3735:2:1;3727:6;3724:14;3721:34;;;3751:1;3748;3741:12;3721:34;3789:6;3778:9;3774:22;3764:32;;3834:7;3827:4;3823:2;3819:13;3815:27;3805:55;;3856:1;3853;3846:12;3805:55;3892:2;3879:16;3914:4;3938:60;3954:43;3994:2;3954:43;:::i;3938:60::-;4020:3;4044:2;4039:3;4032:15;4072:2;4067:3;4063:12;4056:19;;4103:2;4099;4095:11;4151:7;4146:2;4140;4137:1;4133:10;4129:2;4125:19;4121:28;4118:41;4115:61;;;4172:1;4169;4162:12;4115:61;4194:1;4185:10;;4204:163;4218:2;4215:1;4212:9;4204:163;;;4275:17;;4263:30;;4236:1;4229:9;;;;;4313:12;;;;4345;;4204:163;;;-1:-1:-1;4386:5:1;-1:-1:-1;;4429:18:1;;4416:32;;-1:-1:-1;;4460:16:1;;;4457:36;;;4489:1;4486;4479:12;4457:36;;4512:63;4567:7;4556:8;4545:9;4541:24;4512:63;:::i;:::-;4502:73;;;3430:1151;;;;;:::o;4586:180::-;4642:6;4695:2;4683:9;4674:7;4670:23;4666:32;4663:52;;;4711:1;4708;4701:12;4663:52;4734:26;4750:9;4734:26;:::i;4771:180::-;4830:6;4883:2;4871:9;4862:7;4858:23;4854:32;4851:52;;;4899:1;4896;4889:12;4851:52;-1:-1:-1;4922:23:1;;4771:180;-1:-1:-1;4771:180:1:o;4956:245::-;5014:6;5067:2;5055:9;5046:7;5042:23;5038:32;5035:52;;;5083:1;5080;5073:12;5035:52;5122:9;5109:23;5141:30;5165:5;5141:30;:::i;5206:249::-;5275:6;5328:2;5316:9;5307:7;5303:23;5299:32;5296:52;;;5344:1;5341;5334:12;5296:52;5376:9;5370:16;5395:30;5419:5;5395:30;:::i;5460:450::-;5529:6;5582:2;5570:9;5561:7;5557:23;5553:32;5550:52;;;5598:1;5595;5588:12;5550:52;5638:9;5625:23;-1:-1:-1;;;;;5663:6:1;5660:30;5657:50;;;5703:1;5700;5693:12;5657:50;5726:22;;5779:4;5771:13;;5767:27;-1:-1:-1;5757:55:1;;5808:1;5805;5798:12;5757:55;5831:73;5896:7;5891:2;5878:16;5873:2;5869;5865:11;5831:73;:::i;6100:683::-;6195:6;6203;6211;6264:2;6252:9;6243:7;6239:23;6235:32;6232:52;;;6280:1;6277;6270:12;6232:52;6316:9;6303:23;6293:33;;6377:2;6366:9;6362:18;6349:32;-1:-1:-1;;;;;6441:2:1;6433:6;6430:14;6427:34;;;6457:1;6454;6447:12;6427:34;6495:6;6484:9;6480:22;6470:32;;6540:7;6533:4;6529:2;6525:13;6521:27;6511:55;;6562:1;6559;6552:12;6511:55;6602:2;6589:16;6628:2;6620:6;6617:14;6614:34;;;6644:1;6641;6634:12;6614:34;6697:7;6692:2;6682:6;6679:1;6675:14;6671:2;6667:23;6663:32;6660:45;6657:65;;;6718:1;6715;6708:12;6657:65;6749:2;6745;6741:11;6731:21;;6771:6;6761:16;;;;;6100:683;;;;;:::o;6788:248::-;6856:6;6864;6917:2;6905:9;6896:7;6892:23;6888:32;6885:52;;;6933:1;6930;6923:12;6885:52;-1:-1:-1;;6956:23:1;;;7026:2;7011:18;;;6998:32;;-1:-1:-1;6788:248:1:o;7041:257::-;7082:3;7120:5;7114:12;7147:6;7142:3;7135:19;7163:63;7219:6;7212:4;7207:3;7203:14;7196:4;7189:5;7185:16;7163:63;:::i;:::-;7280:2;7259:15;-1:-1:-1;;7255:29:1;7246:39;;;;7287:4;7242:50;;7041:257;-1:-1:-1;;7041:257:1:o;7303:973::-;7388:12;;7353:3;;7443:1;7463:18;;;;7516;;;;7543:61;;7597:4;7589:6;7585:17;7575:27;;7543:61;7623:2;7671;7663:6;7660:14;7640:18;7637:38;7634:161;;;7717:10;7712:3;7708:20;7705:1;7698:31;7752:4;7749:1;7742:15;7780:4;7777:1;7770:15;7634:161;7811:18;7838:104;;;;7956:1;7951:319;;;;7804:466;;7838:104;-1:-1:-1;;7871:24:1;;7859:37;;7916:16;;;;-1:-1:-1;7838:104:1;;7951:319;16982:1;16975:14;;;17019:4;17006:18;;8045:1;8059:165;8073:6;8070:1;8067:13;8059:165;;;8151:14;;8138:11;;;8131:35;8194:16;;;;8088:10;;8059:165;;;8063:3;;8253:6;8248:3;8244:16;8237:23;;7804:466;;;;;;;7303:973;;;;:::o;8515:456::-;8736:3;8764:38;8798:3;8790:6;8764:38;:::i;:::-;8831:6;8825:13;8847:52;8892:6;8888:2;8881:4;8873:6;8869:17;8847:52;:::i;:::-;8915:50;8957:6;8953:2;8949:15;8941:6;8915:50;:::i;:::-;8908:57;8515:456;-1:-1:-1;;;;;;;8515:456:1:o;9394:488::-;-1:-1:-1;;;;;9663:15:1;;;9645:34;;9715:15;;9710:2;9695:18;;9688:43;9762:2;9747:18;;9740:34;;;9810:3;9805:2;9790:18;;9783:31;;;9588:4;;9831:45;;9856:19;;9848:6;9831:45;:::i;:::-;9823:53;9394:488;-1:-1:-1;;;;;;9394:488:1:o;9887:632::-;10058:2;10110:21;;;10180:13;;10083:18;;;10202:22;;;10029:4;;10058:2;10281:15;;;;10255:2;10240:18;;;10029:4;10324:169;10338:6;10335:1;10332:13;10324:169;;;10399:13;;10387:26;;10468:15;;;;10433:12;;;;10360:1;10353:9;10324:169;;;-1:-1:-1;10510:3:1;;9887:632;-1:-1:-1;;;;;;9887:632:1:o;10898:219::-;11047:2;11036:9;11029:21;11010:4;11067:44;11107:2;11096:9;11092:18;11084:6;11067:44;:::i;13330:397::-;13532:2;13514:21;;;13571:2;13551:18;;;13544:30;13610:34;13605:2;13590:18;;13583:62;-1:-1:-1;;;13676:2:1;13661:18;;13654:31;13717:3;13702:19;;13330:397::o;13732:356::-;13934:2;13916:21;;;13953:18;;;13946:30;14012:34;14007:2;13992:18;;13985:62;14079:2;14064:18;;13732:356::o;15553:355::-;15755:2;15737:21;;;15794:2;15774:18;;;15767:30;15833:33;15828:2;15813:18;;15806:61;15899:2;15884:18;;15553:355::o;16441:275::-;16512:2;16506:9;16577:2;16558:13;;-1:-1:-1;;16554:27:1;16542:40;;-1:-1:-1;;;;;16597:34:1;;16633:22;;;16594:62;16591:88;;;16659:18;;:::i;:::-;16695:2;16688:22;16441:275;;-1:-1:-1;16441:275:1:o;16721:183::-;16781:4;-1:-1:-1;;;;;16806:6:1;16803:30;16800:56;;;16836:18;;:::i;:::-;-1:-1:-1;16881:1:1;16877:14;16893:4;16873:25;;16721:183::o;17035:128::-;17075:3;17106:1;17102:6;17099:1;17096:13;17093:39;;;17112:18;;:::i;:::-;-1:-1:-1;17148:9:1;;17035:128::o;17168:120::-;17208:1;17234;17224:35;;17239:18;;:::i;:::-;-1:-1:-1;17273:9:1;;17168:120::o;17293:168::-;17333:7;17399:1;17395;17391:6;17387:14;17384:1;17381:21;17376:1;17369:9;17362:17;17358:45;17355:71;;;17406:18;;:::i;:::-;-1:-1:-1;17446:9:1;;17293:168::o;17466:125::-;17506:4;17534:1;17531;17528:8;17525:34;;;17539:18;;:::i;:::-;-1:-1:-1;17576:9:1;;17466:125::o;17596:258::-;17668:1;17678:113;17692:6;17689:1;17686:13;17678:113;;;17768:11;;;17762:18;17749:11;;;17742:39;17714:2;17707:10;17678:113;;;17809:6;17806:1;17803:13;17800:48;;;-1:-1:-1;;17844:1:1;17826:16;;17819:27;17596:258::o;17859:380::-;17938:1;17934:12;;;;17981;;;18002:61;;18056:4;18048:6;18044:17;18034:27;;18002:61;18109:2;18101:6;18098:14;18078:18;18075:38;18072:161;;;18155:10;18150:3;18146:20;18143:1;18136:31;18190:4;18187:1;18180:15;18218:4;18215:1;18208:15;18072:161;;17859:380;;;:::o;18244:135::-;18283:3;-1:-1:-1;;18304:17:1;;18301:43;;;18324:18;;:::i;:::-;-1:-1:-1;18371:1:1;18360:13;;18244:135::o;18384:112::-;18416:1;18442;18432:35;;18447:18;;:::i;:::-;-1:-1:-1;18481:9:1;;18384:112::o;18501:127::-;18562:10;18557:3;18553:20;18550:1;18543:31;18593:4;18590:1;18583:15;18617:4;18614:1;18607:15;18633:127;18694:10;18689:3;18685:20;18682:1;18675:31;18725:4;18722:1;18715:15;18749:4;18746:1;18739:15;18765:127;18826:10;18821:3;18817:20;18814:1;18807:31;18857:4;18854:1;18847:15;18881:4;18878:1;18871:15;18897:127;18958:10;18953:3;18949:20;18946:1;18939:31;18989:4;18986:1;18979:15;19013:4;19010:1;19003:15;19029:131;-1:-1:-1;;;;;;19103:32:1;;19093:43;;19083:71;;19150:1;19147;19140:12

Swarm Source

ipfs://00b517e71cc2432123fe2f118bf793fe0e1da600385e7b2ff3bf1a4ec77db0a1

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