Token

All In One Out (AIOO)

ERC-721

Overview

Max Total Supply

3,000 AIOO

Holders

964

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xa92e4af91827cf200b670b261027357fb0f6158e

Filtered by Token Holder

0xdCE0F3Dc0730C8B09aa90D2FE9079AED2AB97070

*努力打图狗换个朋克.eth

Balance

23 AIOO

0xdCE0F3Dc0730C8B09aa90D2FE9079AED2AB97070

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

AIOO

Compiler Version

v0.8.15+commit.e14f2714

Optimization Enabled:

No with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

/**
 *Submitted for verification at Etherscan.io on 2022-06-23
*/

// SPDX-License-Identifier: MIT

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: ECDSA.sol


// OpenZeppelin Contracts v4.4.1 (utils/cryptography/ECDSA.sol)

pragma solidity ^0.8.0;


/**
 * @dev Elliptic Curve Digital Signature Algorithm (ECDSA) operations.
 *
 * These functions can be used to verify that a message was signed by the holder
 * of the private keys of a given address.
 */
library ECDSA {
    enum RecoverError {
        NoError,
        InvalidSignature,
        InvalidSignatureLength,
        InvalidSignatureS,
        InvalidSignatureV
    }

    function _throwError(RecoverError error) private pure {
        if (error == RecoverError.NoError) {
            return; // no error: do nothing
        } else if (error == RecoverError.InvalidSignature) {
            revert("ECDSA: invalid signature");
        } else if (error == RecoverError.InvalidSignatureLength) {
            revert("ECDSA: invalid signature length");
        } else if (error == RecoverError.InvalidSignatureS) {
            revert("ECDSA: invalid signature 's' value");
        } else if (error == RecoverError.InvalidSignatureV) {
            revert("ECDSA: invalid signature 'v' value");
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature` or error string. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     *
     * Documentation for signature generation:
     * - with https://web3js.readthedocs.io/en/v1.3.4/web3-eth-accounts.html#sign[Web3.js]
     * - with https://docs.ethers.io/v5/api/signer/#Signer-signMessage[ethers]
     *
     * _Available since v4.3._
     */
    function tryRecover(bytes32 hash, bytes memory signature) internal pure returns (address, RecoverError) {
        // Check the signature length
        // - case 65: r,s,v signature (standard)
        // - case 64: r,vs signature (cf https://eips.ethereum.org/EIPS/eip-2098) _Available since v4.1._
        if (signature.length == 65) {
            bytes32 r;
            bytes32 s;
            uint8 v;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                s := mload(add(signature, 0x40))
                v := byte(0, mload(add(signature, 0x60)))
            }
            return tryRecover(hash, v, r, s);
        } else if (signature.length == 64) {
            bytes32 r;
            bytes32 vs;
            // ecrecover takes the signature parameters, and the only way to get them
            // currently is to use assembly.
            assembly {
                r := mload(add(signature, 0x20))
                vs := mload(add(signature, 0x40))
            }
            return tryRecover(hash, r, vs);
        } else {
            return (address(0), RecoverError.InvalidSignatureLength);
        }
    }

    /**
     * @dev Returns the address that signed a hashed message (`hash`) with
     * `signature`. This address can then be used for verification purposes.
     *
     * The `ecrecover` EVM opcode allows for malleable (non-unique) signatures:
     * this function rejects them by requiring the `s` value to be in the lower
     * half order, and the `v` value to be either 27 or 28.
     *
     * IMPORTANT: `hash` _must_ be the result of a hash operation for the
     * verification to be secure: it is possible to craft signatures that
     * recover to arbitrary addresses for non-hashed data. A safe way to ensure
     * this is by receiving a hash of the original message (which may otherwise
     * be too long), and then calling {toEthSignedMessageHash} on it.
     */
    function recover(bytes32 hash, bytes memory signature) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, signature);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `r` and `vs` short-signature fields separately.
     *
     * See https://eips.ethereum.org/EIPS/eip-2098[EIP-2098 short signatures]
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address, RecoverError) {
        bytes32 s = vs & bytes32(0x7fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        uint8 v = uint8((uint256(vs) >> 255) + 27);
        return tryRecover(hash, v, r, s);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `r and `vs` short-signature fields separately.
     *
     * _Available since v4.2._
     */
    function recover(
        bytes32 hash,
        bytes32 r,
        bytes32 vs
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, r, vs);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Overload of {ECDSA-tryRecover} that receives the `v`,
     * `r` and `s` signature fields separately.
     *
     * _Available since v4.3._
     */
    function tryRecover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address, RecoverError) {
        // EIP-2 still allows signature malleability for ecrecover(). Remove this possibility and make the signature
        // unique. Appendix F in the Ethereum Yellow paper (https://ethereum.github.io/yellowpaper/paper.pdf), defines
        // the valid range for s in (301): 0 < s < secp256k1n ÷ 2 + 1, and for v in (302): v ∈ {27, 28}. Most
        // signatures from current libraries generate a unique signature with an s-value in the lower half order.
        //
        // If your library generates malleable signatures, such as s-values in the upper range, calculate a new s-value
        // with 0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141 - s1 and flip v from 27 to 28 or
        // vice versa. If your library also generates signatures with 0/1 for v instead 27/28, add 27 to v to accept
        // these malleable signatures as well.
        if (uint256(s) > 0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF5D576E7357A4501DDFE92F46681B20A0) {
            return (address(0), RecoverError.InvalidSignatureS);
        }
        if (v != 27 && v != 28) {
            return (address(0), RecoverError.InvalidSignatureV);
        }

        // If the signature is valid (and not malleable), return the signer address
        address signer = ecrecover(hash, v, r, s);
        if (signer == address(0)) {
            return (address(0), RecoverError.InvalidSignature);
        }

        return (signer, RecoverError.NoError);
    }

    /**
     * @dev Overload of {ECDSA-recover} that receives the `v`,
     * `r` and `s` signature fields separately.
     */
    function recover(
        bytes32 hash,
        uint8 v,
        bytes32 r,
        bytes32 s
    ) internal pure returns (address) {
        (address recovered, RecoverError error) = tryRecover(hash, v, r, s);
        _throwError(error);
        return recovered;
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from a `hash`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes32 hash) internal pure returns (bytes32) {
        // 32 is the length in bytes of hash,
        // enforced by the type signature above
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n32", hash));
    }

    /**
     * @dev Returns an Ethereum Signed Message, created from `s`. This
     * produces hash corresponding to the one signed with the
     * https://eth.wiki/json-rpc/API#eth_sign[`eth_sign`]
     * JSON-RPC method as part of EIP-191.
     *
     * See {recover}.
     */
    function toEthSignedMessageHash(bytes memory s) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19Ethereum Signed Message:\n", Strings.toString(s.length), s));
    }

    /**
     * @dev Returns an Ethereum Signed Typed Data, created from a
     * `domainSeparator` and a `structHash`. This produces hash corresponding
     * to the one signed with the
     * https://eips.ethereum.org/EIPS/eip-712[`eth_signTypedData`]
     * JSON-RPC method as part of EIP-712.
     *
     * See {recover}.
     */
    function toTypedDataHash(bytes32 domainSeparator, bytes32 structHash) internal pure returns (bytes32) {
        return keccak256(abi.encodePacked("\x19\x01", domainSeparator, structHash));
    }
}
// File: 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: Ownable.sol



pragma solidity ^0.8.0;


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

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

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

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

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

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

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

    function _setOwner(address newOwner) private {
        address oldOwner = _owner;
        _owner = newOwner;
        emit OwnershipTransferred(oldOwner, newOwner);
    }
}
// File: Address.sol



pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    function _verifyCallResult(
        bool success,
        bytes memory returndata,
        string memory errorMessage
    ) private 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: Payment.sol


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

pragma solidity ^0.8.0;



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

    uint256 private _totalShares;
    uint256 private _totalReleased;

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

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

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

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

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

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


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

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


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

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

        uint256 totalReceived = address(this).balance + totalReleased();
        uint256 payment = _pendingPayment(account, totalReceived, released(account));

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

        _released[account] += payment;
        _totalReleased += payment;

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


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

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

        _payees.push(account);
        _shares[account] = shares_;
        _totalShares = _totalShares + shares_;
        emit PayeeAdded(account, shares_);
    }
}
// File: 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: 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: 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: 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: IERC721Enumerable.sol



pragma solidity ^0.8.0;


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

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

    /**
     * @dev Returns a token ID at a given `index` of all the tokens stored by the contract.
     * Use along with {totalSupply} to enumerate all tokens.
     */
    function tokenByIndex(uint256 index) external view returns (uint256);
}
// File: 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.sol


pragma solidity ^0.8.0;









contract ERC721A is Context, ERC165, IERC721, IERC721Metadata, IERC721Enumerable {
    using Address for address;
    using Strings for uint256;

    struct TokenOwnership {
        address addr;
        uint64 startTimestamp;
    }

    struct AddressData {
        uint128 balance;
        uint128 numberMinted;
    }

    uint256 internal currentIndex;

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

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

    /**
     * @dev See {IERC721Enumerable-tokenByIndex}.
     */
    function tokenByIndex(uint256 index) public view override returns (uint256) {
        require(index < totalSupply(), 'ERC721A: global index out of bounds');
        return index;
    }

    /**
     * @dev See {IERC721Enumerable-tokenOfOwnerByIndex}.
     * This read function is O(totalSupply). If calling from a separate contract, be sure to test gas first.
     * It may also degrade with extremely large collection sizes (e.g >> 10000), test for your use case.
     */
    function tokenOfOwnerByIndex(address owner, uint256 index) public view override returns (uint256) {
        require(index < balanceOf(owner), 'ERC721A: owner index out of bounds');
        uint256 numMintedSoFar = totalSupply();
        uint256 tokenIdsIdx;
        address currOwnershipAddr;

        // Counter overflow is impossible as the loop breaks when uint256 i is equal to another uint256 numMintedSoFar.
        unchecked {
            for (uint256 i; i < numMintedSoFar; i++) {
                TokenOwnership memory ownership = _ownerships[i];
                if (ownership.addr != address(0)) {
                    currOwnershipAddr = ownership.addr;
                }
                if (currOwnershipAddr == owner) {
                    if (tokenIdsIdx == index) {
                        return i;
                    }
                    tokenIdsIdx++;
                }
            }
        }

        revert('ERC721A: unable to get token of owner by index');
    }

    /**
     * @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 ||
            interfaceId == type(IERC721Enumerable).interfaceId ||
            super.supportsInterface(interfaceId);
    }

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

    function _numberMinted(address owner) internal view returns (uint256) {
        require(owner != address(0), 'ERC721A: number minted query for the zero address');
        return uint256(_addressData[owner].numberMinted);
    }

    /**
     * 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) {
        require(_exists(tokenId), 'ERC721A: owner query for nonexistent token');

        unchecked {
            for (uint256 curr = tokenId; curr >= 0; curr--) {
                TokenOwnership memory ownership = _ownerships[curr];
                if (ownership.addr != address(0)) {
                    return ownership;
                }
            }
        }

        revert('ERC721A: unable to determine the owner of token');
    }

    /**
     * @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) {
        require(_exists(tokenId), 'ERC721Metadata: URI query for nonexistent token');

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

    /**
     * @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);
        require(to != owner, 'ERC721A: approval to current owner');

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

        _approve(to, tokenId, owner);
    }

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

        return _tokenApprovals[tokenId];
    }

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

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

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

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

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

    /**
     * @dev See {IERC721-safeTransferFrom}.
     */
    function safeTransferFrom(
        address from,
        address to,
        uint256 tokenId,
        bytes memory _data
    ) public override {
        _transfer(from, to, tokenId);
        require(
            _checkOnERC721Received(from, to, tokenId, _data),
            'ERC721A: transfer to non ERC721Receiver implementer'
        );
    }

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

    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;
        require(to != address(0), 'ERC721A: mint to the zero address');
        require(quantity != 0, 'ERC721A: quantity must be greater than 0');

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

        // Overflows are incredibly unrealistic.
        // balance or numberMinted overflow if current value of either + quantity > 3.4e38 (2**128) - 1
        // updatedIndex overflows if currentIndex + quantity > 1.56e77 (2**256) - 1
        unchecked {
            _addressData[to].balance += uint128(quantity);
            _addressData[to].numberMinted += uint128(quantity);

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

            uint256 updatedIndex = startTokenId;

            for (uint256 i; i < quantity; i++) {
                emit Transfer(address(0), to, updatedIndex);
                if (safe) {
                    require(
                        _checkOnERC721Received(address(0), to, updatedIndex, _data),
                        'ERC721A: transfer to non ERC721Receiver implementer'
                    );
                }

                updatedIndex++;
            }

            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 ||
            getApproved(tokenId) == _msgSender() ||
            isApprovedForAll(prevOwnership.addr, _msgSender()));

        require(isApprovedOrOwner, 'ERC721A: transfer caller is not owner nor approved');

        require(prevOwnership.addr == from, 'ERC721A: transfer from incorrect owner');
        require(to != address(0), 'ERC721A: transfer to the zero address');

        _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)) {
                if (_exists(nextTokenId)) {
                    _ownerships[nextTokenId].addr = prevOwnership.addr;
                    _ownerships[nextTokenId].startTimestamp = prevOwnership.startTimestamp;
                }
            }
        }

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

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

    /**
     * @dev Hook that is called before a set of serially-ordered token ids are about to be transferred. This includes minting.
     *
     * 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`.
     */
    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.
     *
     * 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` and `to` are never both zero.
     */
    function _afterTokenTransfers(
        address from,
        address to,
        uint256 startTokenId,
        uint256 quantity
    ) internal virtual {}
}

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

pragma solidity ^0.8.2;

contract AIOO is ERC721A, Ownable, ReentrancyGuard {  
    using Strings for uint256;
    string public _basuri = "ipfs://Qmcqig4ftA4XMWfE18FoijwNEkQ6XPv3miK77LaBxBTzW4/";
    bool public pause = false;
    uint256 public Citizens = 3000;
    uint256 public maxmint = 3; 
    mapping(address => uint256) public howmanyowned;
   
	constructor() ERC721A("All In One Out", "AIOO") {}

    function _baseURI() internal view virtual override returns (string memory) {
        return _basuri;
    }


 	function mintCitizen() external nonReentrant {
  	    uint256 Totalsupply = totalSupply();
        require(pause);
        require(Totalsupply + maxmint <= Citizens);
        require(msg.sender == tx.origin);
    	require(howmanyowned[msg.sender] < maxmint);
        _safeMint(msg.sender, maxmint);
        howmanyowned[msg.sender] += maxmint;
    }


    function pausemint(bool _stop) external onlyOwner {
        pause = _stop;
    }

    function changebasur(string memory _basur) external onlyOwner {
        _basuri = _basur;
    }


}

Contract Security Audit

No Contract Security Audit Submitted- Submit Audit Here

Contract ABI

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"Citizens","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_basuri","outputs":[{"internalType":"string","name":"","type":"string"}],"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":[{"internalType":"string","name":"_basur","type":"string"}],"name":"changebasur","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"","type":"address"}],"name":"howmanyowned","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"maxmint","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"mintCitizen","outputs":[],"stateMutability":"nonpayable","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":"pause","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"bool","name":"_stop","type":"bool"}],"name":"pausemint","outputs":[],"stateMutability":"nonpayable","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":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"uint256","name":"index","type":"uint256"}],"name":"tokenOfOwnerByIndex","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"totalSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

56209:1073:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;40357:372;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42243:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43814:214;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;43335:413;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;38614:100;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44690:162;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;57088:82;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;39278:1007;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44923:177;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;57178:97;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;38791:187;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42052:124;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;40793:221;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;13944:94;;;:::i;:::-;;56491:47;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56388:25;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56457:26;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56301:80;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;13293:87;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42412:104;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;44100:288;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;45171:355;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;56420:30;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42587:344;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56721:357;;;:::i;:::-;;44459:164;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;14193:192;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;40357:372;40459:4;40511:25;40496:40;;;:11;:40;;;;:105;;;;40568:33;40553:48;;;:11;:48;;;;40496:105;:172;;;;40633:35;40618:50;;;:11;:50;;;;40496:172;:225;;;;40685:36;40709:11;40685:23;:36::i;:::-;40496:225;40476:245;;40357:372;;;:::o;42243:100::-;42297:13;42330:5;42323:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42243:100;:::o;43814:214::-;43882:7;43910:16;43918:7;43910;:16::i;:::-;43902:74;;;;;;;;;;;;:::i;:::-;;;;;;;;;43996:15;:24;44012:7;43996:24;;;;;;;;;;;;;;;;;;;;;43989:31;;43814:214;;;:::o;43335:413::-;43408:13;43424:24;43440:7;43424:15;:24::i;:::-;43408:40;;43473:5;43467:11;;:2;:11;;;43459:58;;;;;;;;;;;;:::i;:::-;;;;;;;;;43568:5;43552:21;;:12;:10;:12::i;:::-;:21;;;:62;;;;43577:37;43594:5;43601:12;:10;:12::i;:::-;43577:16;:37::i;:::-;43552:62;43530:169;;;;;;;;;;;;:::i;:::-;;;;;;;;;43712:28;43721:2;43725:7;43734:5;43712:8;:28::i;:::-;43397:351;43335:413;;:::o;38614:100::-;38667:7;38694:12;;38687:19;;38614:100;:::o;44690:162::-;44816:28;44826:4;44832:2;44836:7;44816:9;:28::i;:::-;44690:162;;;:::o;57088:82::-;13524:12;:10;:12::i;:::-;13513:23;;:7;:5;:7::i;:::-;:23;;;13505:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;57157:5:::1;57149;;:13;;;;;;;;;;;;;;;;;;57088:82:::0;:::o;39278:1007::-;39367:7;39403:16;39413:5;39403:9;:16::i;:::-;39395:5;:24;39387:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;39469:22;39494:13;:11;:13::i;:::-;39469:38;;39518:19;39548:25;39737:9;39732:466;39752:14;39748:1;:18;39732:466;;;39792:31;39826:11;:14;39838:1;39826:14;;;;;;;;;;;39792:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;39889:1;39863:28;;:9;:14;;;:28;;;39859:111;;39936:9;:14;;;39916:34;;39859:111;40013:5;39992:26;;:17;:26;;;39988:195;;40062:5;40047:11;:20;40043:85;;40103:1;40096:8;;;;;;;;;40043:85;40150:13;;;;;;;39988:195;39773:425;39768:3;;;;;;;39732:466;;;;40221:56;;;;;;;;;;:::i;:::-;;;;;;;;39278:1007;;;;;:::o;44923:177::-;45053:39;45070:4;45076:2;45080:7;45053:39;;;;;;;;;;;;:16;:39::i;:::-;44923:177;;;:::o;57178:97::-;13524:12;:10;:12::i;:::-;13513:23;;:7;:5;:7::i;:::-;:23;;;13505:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;57261:6:::1;57251:7;:16;;;;;;:::i;:::-;;57178:97:::0;:::o;38791:187::-;38858:7;38894:13;:11;:13::i;:::-;38886:5;:21;38878:69;;;;;;;;;;;;:::i;:::-;;;;;;;;;38965:5;38958:12;;38791:187;;;:::o;42052:124::-;42116:7;42143:20;42155:7;42143:11;:20::i;:::-;:25;;;42136:32;;42052:124;;;:::o;40793:221::-;40857:7;40902:1;40885:19;;:5;:19;;;40877:75;;;;;;;;;;;;:::i;:::-;;;;;;;;;40978:12;:19;40991:5;40978:19;;;;;;;;;;;;;;;:27;;;;;;;;;;;;40970:36;;40963:43;;40793:221;;;:::o;13944:94::-;13524:12;:10;:12::i;:::-;13513:23;;:7;:5;:7::i;:::-;:23;;;13505:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;14009:21:::1;14027:1;14009:9;:21::i;:::-;13944:94::o:0;56491:47::-;;;;;;;;;;;;;;;;;:::o;56388:25::-;;;;;;;;;;;;;:::o;56457:26::-;;;;:::o;56301:80::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;13293:87::-;13339:7;13366:6;;;;;;;;;;;13359:13;;13293:87;:::o;42412:104::-;42468:13;42501:7;42494:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42412:104;:::o;44100:288::-;44207:12;:10;:12::i;:::-;44195:24;;:8;:24;;;44187:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;44308:8;44263:18;:32;44282:12;:10;:12::i;:::-;44263:32;;;;;;;;;;;;;;;:42;44296:8;44263:42;;;;;;;;;;;;;;;;:53;;;;;;;;;;;;;;;;;;44361:8;44332:48;;44347:12;:10;:12::i;:::-;44332:48;;;44371:8;44332:48;;;;;;:::i;:::-;;;;;;;;44100:288;;:::o;45171:355::-;45330:28;45340:4;45346:2;45350:7;45330:9;:28::i;:::-;45391:48;45414:4;45420:2;45424:7;45433:5;45391:22;:48::i;:::-;45369:149;;;;;;;;;;;;:::i;:::-;;;;;;;;;45171:355;;;;:::o;56420:30::-;;;;:::o;42587:344::-;42660:13;42694:16;42702:7;42694;:16::i;:::-;42686:76;;;;;;;;;;;;:::i;:::-;;;;;;;;;42775:21;42799:10;:8;:10::i;:::-;42775:34;;42852:1;42833:7;42827:21;:26;:96;;;;;;;;;;;;;;;;;42880:7;42889:18;:7;:16;:18::i;:::-;42863:54;;;;;;;;;:::i;:::-;;;;;;;;;;;;;42827:96;42820:103;;;42587:344;;;:::o;56721:357::-;55235:1;55833:7;;:19;55825:63;;;;;;;;;;;;:::i;:::-;;;;;;;;;55235:1;55966:7;:18;;;;56776:19:::1;56798:13;:11;:13::i;:::-;56776:35;;56830:5;;;;;;;;;;;56822:14;;;::::0;::::1;;56880:8;;56869:7;;56855:11;:21;;;;:::i;:::-;:33;;56847:42;;;::::0;::::1;;56922:9;56908:23;;:10;:23;;;56900:32;;;::::0;::::1;;56975:7;;56948:12;:24;56961:10;56948:24;;;;;;;;;;;;;;;;:34;56940:43;;;::::0;::::1;;56994:30;57004:10;57016:7;;56994:9;:30::i;:::-;57063:7;;57035:12;:24;57048:10;57035:24;;;;;;;;;;;;;;;;:35;;;;;;;:::i;:::-;;;;;;;;56766:312;55191:1:::0;56145:7;:22;;;;56721:357::o;44459:164::-;44556:4;44580:18;:25;44599:5;44580:25;;;;;;;;;;;;;;;:35;44606:8;44580:35;;;;;;;;;;;;;;;;;;;;;;;;;44573:42;;44459:164;;;;:::o;14193:192::-;13524:12;:10;:12::i;:::-;13513:23;;:7;:5;:7::i;:::-;:23;;;13505:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;14302:1:::1;14282:22;;:8;:22;;::::0;14274:73:::1;;;;;;;;;;;;:::i;:::-;;;;;;;;;14358:19;14368:8;14358:9;:19::i;:::-;14193:192:::0;:::o;30745:157::-;30830:4;30869:25;30854:40;;;:11;:40;;;;30847:47;;30745:157;;;:::o;45781:111::-;45838:4;45872:12;;45862:7;:22;45855:29;;45781:111;;;:::o;12114:98::-;12167:7;12194:10;12187:17;;12114:98;:::o;50701:196::-;50843:2;50816:15;:24;50832:7;50816:24;;;;;;;;;;;;:29;;;;;;;;;;;;;;;;;;50881:7;50877:2;50861:28;;50870:5;50861:28;;;;;;;;;;;;50701:196;;;:::o;48581:2002::-;48696:35;48734:20;48746:7;48734:11;:20::i;:::-;48696:58;;48767:22;48809:13;:18;;;48793:34;;:12;:10;:12::i;:::-;:34;;;:87;;;;48868:12;:10;:12::i;:::-;48844:36;;:20;48856:7;48844:11;:20::i;:::-;:36;;;48793:87;:154;;;;48897:50;48914:13;:18;;;48934:12;:10;:12::i;:::-;48897:16;:50::i;:::-;48793:154;48767:181;;48969:17;48961:80;;;;;;;;;;;;:::i;:::-;;;;;;;;;49084:4;49062:26;;:13;:18;;;:26;;;49054:77;;;;;;;;;;;;:::i;:::-;;;;;;;;;49164:1;49150:16;;:2;:16;;;49142:66;;;;;;;;;;;;:::i;:::-;;;;;;;;;49221:43;49243:4;49249:2;49253:7;49262:1;49221:21;:43::i;:::-;49329:49;49346:1;49350:7;49359:13;:18;;;49329:8;:49::i;:::-;49704:1;49674:12;:18;49687:4;49674:18;;;;;;;;;;;;;;;:26;;;:31;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49748:1;49720:12;:16;49733:2;49720:16;;;;;;;;;;;;;;;:24;;;:29;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49794:2;49766:11;:20;49778:7;49766:20;;;;;;;;;;;:25;;;:30;;;;;;;;;;;;;;;;;;49856:15;49811:11;:20;49823:7;49811:20;;;;;;;;;;;:35;;;:61;;;;;;;;;;;;;;;;;;50124:19;50156:1;50146:7;:11;50124:33;;50217:1;50176:43;;:11;:24;50188:11;50176:24;;;;;;;;;;;:29;;;;;;;;;;;;:43;;;50172:295;;50244:20;50252:11;50244:7;:20::i;:::-;50240:212;;;50321:13;:18;;;50289:11;:24;50301:11;50289:24;;;;;;;;;;;:29;;;:50;;;;;;;;;;;;;;;;;;50404:13;:28;;;50362:11;:24;50374:11;50362:24;;;;;;;;;;;:39;;;:70;;;;;;;;;;;;;;;;;;50240:212;50172:295;49649:829;50514:7;50510:2;50495:27;;50504:4;50495:27;;;;;;;;;;;;50533:42;50554:4;50560:2;50564:7;50573:1;50533:20;:42::i;:::-;48685:1898;;48581:2002;;;:::o;41453:537::-;41514:21;;:::i;:::-;41556:16;41564:7;41556;:16::i;:::-;41548:71;;;;;;;;;;;;:::i;:::-;;;;;;;;;41662:12;41677:7;41662:22;;41657:245;41694:1;41686:4;:9;41657:245;;41724:31;41758:11;:17;41770:4;41758:17;;;;;;;;;;;41724:51;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;41824:1;41798:28;;:9;:14;;;:28;;;41794:93;;41858:9;41851:16;;;;;;41794:93;41705:197;41697:6;;;;;;;;41657:245;;;;41925:57;;;;;;;;;;:::i;:::-;;;;;;;;41453:537;;;;:::o;14393:173::-;14449:16;14468:6;;;;;;;;;;;14449:25;;14494:8;14485:6;;:17;;;;;;;;;;;;;;;;;;14549:8;14518:40;;14539:8;14518:40;;;;;;;;;;;;14438:128;14393:173;:::o;51462:804::-;51617:4;51638:15;:2;:13;;;:15::i;:::-;51634:625;;;51690:2;51674:36;;;51711:12;:10;:12::i;:::-;51725:4;51731:7;51740:5;51674:72;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;51670:534;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;51937:1;51920:6;:13;:18;51916:273;;51963:61;;;;;;;;;;:::i;:::-;;;;;;;;51916:273;52139:6;52133:13;52124:6;52120:2;52116:15;52109:38;51670:534;51807:45;;;51797:55;;;:6;:55;;;;51790:62;;;;;51634:625;52243:4;52236:11;;51462:804;;;;;;;:::o;56605:108::-;56665:13;56698:7;56691:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56605:108;:::o;288:723::-;344:13;574:1;565:5;:10;561:53;;592:10;;;;;;;;;;;;;;;;;;;;;561:53;624:12;639:5;624:20;;655:14;680:78;695:1;687:4;:9;680:78;;713:8;;;;;:::i;:::-;;;;744:2;736:10;;;;;:::i;:::-;;;680:78;;;768:19;800:6;790:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;768:39;;818:154;834:1;825:5;:10;818:154;;862:1;852:11;;;;;:::i;:::-;;;929:2;921:5;:10;;;;:::i;:::-;908:2;:24;;;;:::i;:::-;895:39;;878:6;885;878:14;;;;;;;;:::i;:::-;;;;;:56;;;;;;;;;;;958:2;949:11;;;;;:::i;:::-;;;818:154;;;996:6;982:21;;;;;288:723;;;;:::o;45900:104::-;45969:27;45979:2;45983:8;45969:27;;;;;;;;;;;;:9;:27::i;:::-;45900:104;;:::o;52754:159::-;;;;;:::o;53325:158::-;;;;;:::o;15307:387::-;15367:4;15575:12;15642:7;15630:20;15622:28;;15685:1;15678:4;:8;15671:15;;;15307:387;;;:::o;46367:163::-;46490:32;46496:2;46500:8;46510:5;46517:4;46490:5;:32::i;:::-;46367:163;;;:::o;46789:1538::-;46928:20;46951:12;;46928:35;;46996:1;46982:16;;:2;:16;;;46974:62;;;;;;;;;;;;:::i;:::-;;;;;;;;;47067:1;47055:8;:13;47047:66;;;;;;;;;;;;:::i;:::-;;;;;;;;;47126:61;47156:1;47160:2;47164:12;47178:8;47126:21;:61::i;:::-;47501:8;47465:12;:16;47478:2;47465:16;;;;;;;;;;;;;;;:24;;;:45;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47566:8;47525:12;:16;47538:2;47525:16;;;;;;;;;;;;;;;:29;;;:50;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;47625:2;47592:11;:25;47604:12;47592:25;;;;;;;;;;;:30;;;:35;;;;;;;;;;;;;;;;;;47692:15;47642:11;:25;47654:12;47642:25;;;;;;;;;;;:40;;;:66;;;;;;;;;;;;;;;;;;47725:20;47748:12;47725:35;;47782:9;47777:415;47797:8;47793:1;:12;47777:415;;;47861:12;47857:2;47836:38;;47853:1;47836:38;;;;;;;;;;;;47897:4;47893:249;;;47960:59;47991:1;47995:2;47999:12;48013:5;47960:22;:59::i;:::-;47926:196;;;;;;;;;;;;:::i;:::-;;;;;;;;;47893:249;48162:14;;;;;;;47807:3;;;;;;;47777:415;;;;48223:12;48208;:27;;;;47440:807;48259:60;48288:1;48292:2;48296:12;48310:8;48259:20;:60::i;:::-;46917:1410;46789:1538;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;;;:::o;7:75:1:-;40:6;73:2;67:9;57:19;;7:75;:::o;88:117::-;197:1;194;187:12;211:117;320:1;317;310:12;334:149;370:7;410:66;403:5;399:78;388:89;;334:149;;;:::o;489:120::-;561:23;578:5;561:23;:::i;:::-;554:5;551:34;541:62;;599:1;596;589:12;541:62;489:120;:::o;615:137::-;660:5;698:6;685:20;676:29;;714:32;740:5;714:32;:::i;:::-;615:137;;;;:::o;758:327::-;816:6;865:2;853:9;844:7;840:23;836:32;833:119;;;871:79;;:::i;:::-;833:119;991:1;1016:52;1060:7;1051:6;1040:9;1036:22;1016:52;:::i;:::-;1006:62;;962:116;758:327;;;;:::o;1091:90::-;1125:7;1168:5;1161:13;1154:21;1143:32;;1091:90;;;:::o;1187:109::-;1268:21;1283:5;1268:21;:::i;:::-;1263:3;1256:34;1187:109;;:::o;1302:210::-;1389:4;1427:2;1416:9;1412:18;1404:26;;1440:65;1502:1;1491:9;1487:17;1478:6;1440:65;:::i;:::-;1302:210;;;;:::o;1518:99::-;1570:6;1604:5;1598:12;1588:22;;1518:99;;;:::o;1623:169::-;1707:11;1741:6;1736:3;1729:19;1781:4;1776:3;1772:14;1757:29;;1623:169;;;;:::o;1798:307::-;1866:1;1876:113;1890:6;1887:1;1884:13;1876:113;;;1975:1;1970:3;1966:11;1960:18;1956:1;1951:3;1947:11;1940:39;1912:2;1909:1;1905:10;1900:15;;1876:113;;;2007:6;2004:1;2001:13;1998:101;;;2087:1;2078:6;2073:3;2069:16;2062:27;1998:101;1847:258;1798:307;;;:::o;2111:102::-;2152:6;2203:2;2199:7;2194:2;2187:5;2183:14;2179:28;2169:38;;2111:102;;;:::o;2219:364::-;2307:3;2335:39;2368:5;2335:39;:::i;:::-;2390:71;2454:6;2449:3;2390:71;:::i;:::-;2383:78;;2470:52;2515:6;2510:3;2503:4;2496:5;2492:16;2470:52;:::i;:::-;2547:29;2569:6;2547:29;:::i;:::-;2542:3;2538:39;2531:46;;2311:272;2219:364;;;;:::o;2589:313::-;2702:4;2740:2;2729:9;2725:18;2717:26;;2789:9;2783:4;2779:20;2775:1;2764:9;2760:17;2753:47;2817:78;2890:4;2881:6;2817:78;:::i;:::-;2809:86;;2589:313;;;;:::o;2908:77::-;2945:7;2974:5;2963:16;;2908:77;;;:::o;2991:122::-;3064:24;3082:5;3064:24;:::i;:::-;3057:5;3054:35;3044:63;;3103:1;3100;3093:12;3044:63;2991:122;:::o;3119:139::-;3165:5;3203:6;3190:20;3181:29;;3219:33;3246:5;3219:33;:::i;:::-;3119:139;;;;:::o;3264:329::-;3323:6;3372:2;3360:9;3351:7;3347:23;3343:32;3340:119;;;3378:79;;:::i;:::-;3340:119;3498:1;3523:53;3568:7;3559:6;3548:9;3544:22;3523:53;:::i;:::-;3513:63;;3469:117;3264:329;;;;:::o;3599:126::-;3636:7;3676:42;3669:5;3665:54;3654:65;;3599:126;;;:::o;3731:96::-;3768:7;3797:24;3815:5;3797:24;:::i;:::-;3786:35;;3731:96;;;:::o;3833:118::-;3920:24;3938:5;3920:24;:::i;:::-;3915:3;3908:37;3833:118;;:::o;3957:222::-;4050:4;4088:2;4077:9;4073:18;4065:26;;4101:71;4169:1;4158:9;4154:17;4145:6;4101:71;:::i;:::-;3957:222;;;;:::o;4185:122::-;4258:24;4276:5;4258:24;:::i;:::-;4251:5;4248:35;4238:63;;4297:1;4294;4287:12;4238:63;4185:122;:::o;4313:139::-;4359:5;4397:6;4384:20;4375:29;;4413:33;4440:5;4413:33;:::i;:::-;4313:139;;;;:::o;4458:474::-;4526:6;4534;4583:2;4571:9;4562:7;4558:23;4554:32;4551:119;;;4589:79;;:::i;:::-;4551:119;4709:1;4734:53;4779:7;4770:6;4759:9;4755:22;4734:53;:::i;:::-;4724:63;;4680:117;4836:2;4862:53;4907:7;4898:6;4887:9;4883:22;4862:53;:::i;:::-;4852:63;;4807:118;4458:474;;;;;:::o;4938:118::-;5025:24;5043:5;5025:24;:::i;:::-;5020:3;5013:37;4938:118;;:::o;5062:222::-;5155:4;5193:2;5182:9;5178:18;5170:26;;5206:71;5274:1;5263:9;5259:17;5250:6;5206:71;:::i;:::-;5062:222;;;;:::o;5290:619::-;5367:6;5375;5383;5432:2;5420:9;5411:7;5407:23;5403:32;5400:119;;;5438:79;;:::i;:::-;5400:119;5558:1;5583:53;5628:7;5619:6;5608:9;5604:22;5583:53;:::i;:::-;5573:63;;5529:117;5685:2;5711:53;5756:7;5747:6;5736:9;5732:22;5711:53;:::i;:::-;5701:63;;5656:118;5813:2;5839:53;5884:7;5875:6;5864:9;5860:22;5839:53;:::i;:::-;5829:63;;5784:118;5290:619;;;;;:::o;5915:116::-;5985:21;6000:5;5985:21;:::i;:::-;5978:5;5975:32;5965:60;;6021:1;6018;6011:12;5965:60;5915:116;:::o;6037:133::-;6080:5;6118:6;6105:20;6096:29;;6134:30;6158:5;6134:30;:::i;:::-;6037:133;;;;:::o;6176:323::-;6232:6;6281:2;6269:9;6260:7;6256:23;6252:32;6249:119;;;6287:79;;:::i;:::-;6249:119;6407:1;6432:50;6474:7;6465:6;6454:9;6450:22;6432:50;:::i;:::-;6422:60;;6378:114;6176:323;;;;:::o;6505:117::-;6614:1;6611;6604:12;6628:117;6737:1;6734;6727:12;6751:180;6799:77;6796:1;6789:88;6896:4;6893:1;6886:15;6920:4;6917:1;6910:15;6937:281;7020:27;7042:4;7020:27;:::i;:::-;7012:6;7008:40;7150:6;7138:10;7135:22;7114:18;7102:10;7099:34;7096:62;7093:88;;;7161:18;;:::i;:::-;7093:88;7201:10;7197:2;7190:22;6980:238;6937:281;;:::o;7224:129::-;7258:6;7285:20;;:::i;:::-;7275:30;;7314:33;7342:4;7334:6;7314:33;:::i;:::-;7224:129;;;:::o;7359:308::-;7421:4;7511:18;7503:6;7500:30;7497:56;;;7533:18;;:::i;:::-;7497:56;7571:29;7593:6;7571:29;:::i;:::-;7563:37;;7655:4;7649;7645:15;7637:23;;7359:308;;;:::o;7673:154::-;7757:6;7752:3;7747;7734:30;7819:1;7810:6;7805:3;7801:16;7794:27;7673:154;;;:::o;7833:412::-;7911:5;7936:66;7952:49;7994:6;7952:49;:::i;:::-;7936:66;:::i;:::-;7927:75;;8025:6;8018:5;8011:21;8063:4;8056:5;8052:16;8101:3;8092:6;8087:3;8083:16;8080:25;8077:112;;;8108:79;;:::i;:::-;8077:112;8198:41;8232:6;8227:3;8222;8198:41;:::i;:::-;7917:328;7833:412;;;;;:::o;8265:340::-;8321:5;8370:3;8363:4;8355:6;8351:17;8347:27;8337:122;;8378:79;;:::i;:::-;8337:122;8495:6;8482:20;8520:79;8595:3;8587:6;8580:4;8572:6;8568:17;8520:79;:::i;:::-;8511:88;;8327:278;8265:340;;;;:::o;8611:509::-;8680:6;8729:2;8717:9;8708:7;8704:23;8700:32;8697:119;;;8735:79;;:::i;:::-;8697:119;8883:1;8872:9;8868:17;8855:31;8913:18;8905:6;8902:30;8899:117;;;8935:79;;:::i;:::-;8899:117;9040:63;9095:7;9086:6;9075:9;9071:22;9040:63;:::i;:::-;9030:73;;8826:287;8611:509;;;;:::o;9126:329::-;9185:6;9234:2;9222:9;9213:7;9209:23;9205:32;9202:119;;;9240:79;;:::i;:::-;9202:119;9360:1;9385:53;9430:7;9421:6;9410:9;9406:22;9385:53;:::i;:::-;9375:63;;9331:117;9126:329;;;;:::o;9461:468::-;9526:6;9534;9583:2;9571:9;9562:7;9558:23;9554:32;9551:119;;;9589:79;;:::i;:::-;9551:119;9709:1;9734:53;9779:7;9770:6;9759:9;9755:22;9734:53;:::i;:::-;9724:63;;9680:117;9836:2;9862:50;9904:7;9895:6;9884:9;9880:22;9862:50;:::i;:::-;9852:60;;9807:115;9461:468;;;;;:::o;9935:307::-;9996:4;10086:18;10078:6;10075:30;10072:56;;;10108:18;;:::i;:::-;10072:56;10146:29;10168:6;10146:29;:::i;:::-;10138:37;;10230:4;10224;10220:15;10212:23;;9935:307;;;:::o;10248:410::-;10325:5;10350:65;10366:48;10407:6;10366:48;:::i;:::-;10350:65;:::i;:::-;10341:74;;10438:6;10431:5;10424:21;10476:4;10469:5;10465:16;10514:3;10505:6;10500:3;10496:16;10493:25;10490:112;;;10521:79;;:::i;:::-;10490:112;10611:41;10645:6;10640:3;10635;10611:41;:::i;:::-;10331:327;10248:410;;;;;:::o;10677:338::-;10732:5;10781:3;10774:4;10766:6;10762:17;10758:27;10748:122;;10789:79;;:::i;:::-;10748:122;10906:6;10893:20;10931:78;11005:3;10997:6;10990:4;10982:6;10978:17;10931:78;:::i;:::-;10922:87;;10738:277;10677:338;;;;:::o;11021:943::-;11116:6;11124;11132;11140;11189:3;11177:9;11168:7;11164:23;11160:33;11157:120;;;11196:79;;:::i;:::-;11157:120;11316:1;11341:53;11386:7;11377:6;11366:9;11362:22;11341:53;:::i;:::-;11331:63;;11287:117;11443:2;11469:53;11514:7;11505:6;11494:9;11490:22;11469:53;:::i;:::-;11459:63;;11414:118;11571:2;11597:53;11642:7;11633:6;11622:9;11618:22;11597:53;:::i;:::-;11587:63;;11542:118;11727:2;11716:9;11712:18;11699:32;11758:18;11750:6;11747:30;11744:117;;;11780:79;;:::i;:::-;11744:117;11885:62;11939:7;11930:6;11919:9;11915:22;11885:62;:::i;:::-;11875:72;;11670:287;11021:943;;;;;;;:::o;11970:474::-;12038:6;12046;12095:2;12083:9;12074:7;12070:23;12066:32;12063:119;;;12101:79;;:::i;:::-;12063:119;12221:1;12246:53;12291:7;12282:6;12271:9;12267:22;12246:53;:::i;:::-;12236:63;;12192:117;12348:2;12374:53;12419:7;12410:6;12399:9;12395:22;12374:53;:::i;:::-;12364:63;;12319:118;11970:474;;;;;:::o;12450:180::-;12498:77;12495:1;12488:88;12595:4;12592:1;12585:15;12619:4;12616:1;12609:15;12636:320;12680:6;12717:1;12711:4;12707:12;12697:22;;12764:1;12758:4;12754:12;12785:18;12775:81;;12841:4;12833:6;12829:17;12819:27;;12775:81;12903:2;12895:6;12892:14;12872:18;12869:38;12866:84;;12922:18;;:::i;:::-;12866:84;12687:269;12636:320;;;:::o;12962:232::-;13102:34;13098:1;13090:6;13086:14;13079:58;13171:15;13166:2;13158:6;13154:15;13147:40;12962:232;:::o;13200:366::-;13342:3;13363:67;13427:2;13422:3;13363:67;:::i;:::-;13356:74;;13439:93;13528:3;13439:93;:::i;:::-;13557:2;13552:3;13548:12;13541:19;;13200:366;;;:::o;13572:419::-;13738:4;13776:2;13765:9;13761:18;13753:26;;13825:9;13819:4;13815:20;13811:1;13800:9;13796:17;13789:47;13853:131;13979:4;13853:131;:::i;:::-;13845:139;;13572:419;;;:::o;13997:221::-;14137:34;14133:1;14125:6;14121:14;14114:58;14206:4;14201:2;14193:6;14189:15;14182:29;13997:221;:::o;14224:366::-;14366:3;14387:67;14451:2;14446:3;14387:67;:::i;:::-;14380:74;;14463:93;14552:3;14463:93;:::i;:::-;14581:2;14576:3;14572:12;14565:19;;14224:366;;;:::o;14596:419::-;14762:4;14800:2;14789:9;14785:18;14777:26;;14849:9;14843:4;14839:20;14835:1;14824:9;14820:17;14813:47;14877:131;15003:4;14877:131;:::i;:::-;14869:139;;14596:419;;;:::o;15021:244::-;15161:34;15157:1;15149:6;15145:14;15138:58;15230:27;15225:2;15217:6;15213:15;15206:52;15021:244;:::o;15271:366::-;15413:3;15434:67;15498:2;15493:3;15434:67;:::i;:::-;15427:74;;15510:93;15599:3;15510:93;:::i;:::-;15628:2;15623:3;15619:12;15612:19;;15271:366;;;:::o;15643:419::-;15809:4;15847:2;15836:9;15832:18;15824:26;;15896:9;15890:4;15886:20;15882:1;15871:9;15867:17;15860:47;15924:131;16050:4;15924:131;:::i;:::-;15916:139;;15643:419;;;:::o;16068:182::-;16208:34;16204:1;16196:6;16192:14;16185:58;16068:182;:::o;16256:366::-;16398:3;16419:67;16483:2;16478:3;16419:67;:::i;:::-;16412:74;;16495:93;16584:3;16495:93;:::i;:::-;16613:2;16608:3;16604:12;16597:19;;16256:366;;;:::o;16628:419::-;16794:4;16832:2;16821:9;16817:18;16809:26;;16881:9;16875:4;16871:20;16867:1;16856:9;16852:17;16845:47;16909:131;17035:4;16909:131;:::i;:::-;16901:139;;16628:419;;;:::o;17053:221::-;17193:34;17189:1;17181:6;17177:14;17170:58;17262:4;17257:2;17249:6;17245:15;17238:29;17053:221;:::o;17280:366::-;17422:3;17443:67;17507:2;17502:3;17443:67;:::i;:::-;17436:74;;17519:93;17608:3;17519:93;:::i;:::-;17637:2;17632:3;17628:12;17621:19;;17280:366;;;:::o;17652:419::-;17818:4;17856:2;17845:9;17841:18;17833:26;;17905:9;17899:4;17895:20;17891:1;17880:9;17876:17;17869:47;17933:131;18059:4;17933:131;:::i;:::-;17925:139;;17652:419;;;:::o;18077:233::-;18217:34;18213:1;18205:6;18201:14;18194:58;18286:16;18281:2;18273:6;18269:15;18262:41;18077:233;:::o;18316:366::-;18458:3;18479:67;18543:2;18538:3;18479:67;:::i;:::-;18472:74;;18555:93;18644:3;18555:93;:::i;:::-;18673:2;18668:3;18664:12;18657:19;;18316:366;;;:::o;18688:419::-;18854:4;18892:2;18881:9;18877:18;18869:26;;18941:9;18935:4;18931:20;18927:1;18916:9;18912:17;18905:47;18969:131;19095:4;18969:131;:::i;:::-;18961:139;;18688:419;;;:::o;19113:141::-;19162:4;19185:3;19177:11;;19208:3;19205:1;19198:14;19242:4;19239:1;19229:18;19221:26;;19113:141;;;:::o;19260:93::-;19297:6;19344:2;19339;19332:5;19328:14;19324:23;19314:33;;19260:93;;;:::o;19359:107::-;19403:8;19453:5;19447:4;19443:16;19422:37;;19359:107;;;;:::o;19472:393::-;19541:6;19591:1;19579:10;19575:18;19614:97;19644:66;19633:9;19614:97;:::i;:::-;19732:39;19762:8;19751:9;19732:39;:::i;:::-;19720:51;;19804:4;19800:9;19793:5;19789:21;19780:30;;19853:4;19843:8;19839:19;19832:5;19829:30;19819:40;;19548:317;;19472:393;;;;;:::o;19871:60::-;19899:3;19920:5;19913:12;;19871:60;;;:::o;19937:142::-;19987:9;20020:53;20038:34;20047:24;20065:5;20047:24;:::i;:::-;20038:34;:::i;:::-;20020:53;:::i;:::-;20007:66;;19937:142;;;:::o;20085:75::-;20128:3;20149:5;20142:12;;20085:75;;;:::o;20166:269::-;20276:39;20307:7;20276:39;:::i;:::-;20337:91;20386:41;20410:16;20386:41;:::i;:::-;20378:6;20371:4;20365:11;20337:91;:::i;:::-;20331:4;20324:105;20242:193;20166:269;;;:::o;20441:73::-;20486:3;20441:73;:::o;20520:189::-;20597:32;;:::i;:::-;20638:65;20696:6;20688;20682:4;20638:65;:::i;:::-;20573:136;20520:189;;:::o;20715:186::-;20775:120;20792:3;20785:5;20782:14;20775:120;;;20846:39;20883:1;20876:5;20846:39;:::i;:::-;20819:1;20812:5;20808:13;20799:22;;20775:120;;;20715:186;;:::o;20907:543::-;21008:2;21003:3;21000:11;20997:446;;;21042:38;21074:5;21042:38;:::i;:::-;21126:29;21144:10;21126:29;:::i;:::-;21116:8;21112:44;21309:2;21297:10;21294:18;21291:49;;;21330:8;21315:23;;21291:49;21353:80;21409:22;21427:3;21409:22;:::i;:::-;21399:8;21395:37;21382:11;21353:80;:::i;:::-;21012:431;;20997:446;20907:543;;;:::o;21456:117::-;21510:8;21560:5;21554:4;21550:16;21529:37;;21456:117;;;;:::o;21579:169::-;21623:6;21656:51;21704:1;21700:6;21692:5;21689:1;21685:13;21656:51;:::i;:::-;21652:56;21737:4;21731;21727:15;21717:25;;21630:118;21579:169;;;;:::o;21753:295::-;21829:4;21975:29;22000:3;21994:4;21975:29;:::i;:::-;21967:37;;22037:3;22034:1;22030:11;22024:4;22021:21;22013:29;;21753:295;;;;:::o;22053:1395::-;22170:37;22203:3;22170:37;:::i;:::-;22272:18;22264:6;22261:30;22258:56;;;22294:18;;:::i;:::-;22258:56;22338:38;22370:4;22364:11;22338:38;:::i;:::-;22423:67;22483:6;22475;22469:4;22423:67;:::i;:::-;22517:1;22541:4;22528:17;;22573:2;22565:6;22562:14;22590:1;22585:618;;;;23247:1;23264:6;23261:77;;;23313:9;23308:3;23304:19;23298:26;23289:35;;23261:77;23364:67;23424:6;23417:5;23364:67;:::i;:::-;23358:4;23351:81;23220:222;22555:887;;22585:618;22637:4;22633:9;22625:6;22621:22;22671:37;22703:4;22671:37;:::i;:::-;22730:1;22744:208;22758:7;22755:1;22752:14;22744:208;;;22837:9;22832:3;22828:19;22822:26;22814:6;22807:42;22888:1;22880:6;22876:14;22866:24;;22935:2;22924:9;22920:18;22907:31;;22781:4;22778:1;22774:12;22769:17;;22744:208;;;22980:6;22971:7;22968:19;22965:179;;;23038:9;23033:3;23029:19;23023:26;23081:48;23123:4;23115:6;23111:17;23100:9;23081:48;:::i;:::-;23073:6;23066:64;22988:156;22965:179;23190:1;23186;23178:6;23174:14;23170:22;23164:4;23157:36;22592:611;;;22555:887;;22145:1303;;;22053:1395;;:::o;23454:222::-;23594:34;23590:1;23582:6;23578:14;23571:58;23663:5;23658:2;23650:6;23646:15;23639:30;23454:222;:::o;23682:366::-;23824:3;23845:67;23909:2;23904:3;23845:67;:::i;:::-;23838:74;;23921:93;24010:3;23921:93;:::i;:::-;24039:2;24034:3;24030:12;24023:19;;23682:366;;;:::o;24054:419::-;24220:4;24258:2;24247:9;24243:18;24235:26;;24307:9;24301:4;24297:20;24293:1;24282:9;24278:17;24271:47;24335:131;24461:4;24335:131;:::i;:::-;24327:139;;24054:419;;;:::o;24479:230::-;24619:34;24615:1;24607:6;24603:14;24596:58;24688:13;24683:2;24675:6;24671:15;24664:38;24479:230;:::o;24715:366::-;24857:3;24878:67;24942:2;24937:3;24878:67;:::i;:::-;24871:74;;24954:93;25043:3;24954:93;:::i;:::-;25072:2;25067:3;25063:12;25056:19;;24715:366;;;:::o;25087:419::-;25253:4;25291:2;25280:9;25276:18;25268:26;;25340:9;25334:4;25330:20;25326:1;25315:9;25311:17;25304:47;25368:131;25494:4;25368:131;:::i;:::-;25360:139;;25087:419;;;:::o;25512:176::-;25652:28;25648:1;25640:6;25636:14;25629:52;25512:176;:::o;25694:366::-;25836:3;25857:67;25921:2;25916:3;25857:67;:::i;:::-;25850:74;;25933:93;26022:3;25933:93;:::i;:::-;26051:2;26046:3;26042:12;26035:19;;25694:366;;;:::o;26066:419::-;26232:4;26270:2;26259:9;26255:18;26247:26;;26319:9;26313:4;26309:20;26305:1;26294:9;26290:17;26283:47;26347:131;26473:4;26347:131;:::i;:::-;26339:139;;26066:419;;;:::o;26491:238::-;26631:34;26627:1;26619:6;26615:14;26608:58;26700:21;26695:2;26687:6;26683:15;26676:46;26491:238;:::o;26735:366::-;26877:3;26898:67;26962:2;26957:3;26898:67;:::i;:::-;26891:74;;26974:93;27063:3;26974:93;:::i;:::-;27092:2;27087:3;27083:12;27076:19;;26735:366;;;:::o;27107:419::-;27273:4;27311:2;27300:9;27296:18;27288:26;;27360:9;27354:4;27350:20;27346:1;27335:9;27331:17;27324:47;27388:131;27514:4;27388:131;:::i;:::-;27380:139;;27107:419;;;:::o;27532:234::-;27672:34;27668:1;27660:6;27656:14;27649:58;27741:17;27736:2;27728:6;27724:15;27717:42;27532:234;:::o;27772:366::-;27914:3;27935:67;27999:2;27994:3;27935:67;:::i;:::-;27928:74;;28011:93;28100:3;28011:93;:::i;:::-;28129:2;28124:3;28120:12;28113:19;;27772:366;;;:::o;28144:419::-;28310:4;28348:2;28337:9;28333:18;28325:26;;28397:9;28391:4;28387:20;28383:1;28372:9;28368:17;28361:47;28425:131;28551:4;28425:131;:::i;:::-;28417:139;;28144:419;;;:::o;28569:148::-;28671:11;28708:3;28693:18;;28569:148;;;;:::o;28723:377::-;28829:3;28857:39;28890:5;28857:39;:::i;:::-;28912:89;28994:6;28989:3;28912:89;:::i;:::-;28905:96;;29010:52;29055:6;29050:3;29043:4;29036:5;29032:16;29010:52;:::i;:::-;29087:6;29082:3;29078:16;29071:23;;28833:267;28723:377;;;;:::o;29106:155::-;29246:7;29242:1;29234:6;29230:14;29223:31;29106:155;:::o;29267:400::-;29427:3;29448:84;29530:1;29525:3;29448:84;:::i;:::-;29441:91;;29541:93;29630:3;29541:93;:::i;:::-;29659:1;29654:3;29650:11;29643:18;;29267:400;;;:::o;29673:701::-;29954:3;29976:95;30067:3;30058:6;29976:95;:::i;:::-;29969:102;;30088:95;30179:3;30170:6;30088:95;:::i;:::-;30081:102;;30200:148;30344:3;30200:148;:::i;:::-;30193:155;;30365:3;30358:10;;29673:701;;;;;:::o;30380:181::-;30520:33;30516:1;30508:6;30504:14;30497:57;30380:181;:::o;30567:366::-;30709:3;30730:67;30794:2;30789:3;30730:67;:::i;:::-;30723:74;;30806:93;30895:3;30806:93;:::i;:::-;30924:2;30919:3;30915:12;30908:19;;30567:366;;;:::o;30939:419::-;31105:4;31143:2;31132:9;31128:18;31120:26;;31192:9;31186:4;31182:20;31178:1;31167:9;31163:17;31156:47;31220:131;31346:4;31220:131;:::i;:::-;31212:139;;30939:419;;;:::o;31364:180::-;31412:77;31409:1;31402:88;31509:4;31506:1;31499:15;31533:4;31530:1;31523:15;31550:305;31590:3;31609:20;31627:1;31609:20;:::i;:::-;31604:25;;31643:20;31661:1;31643:20;:::i;:::-;31638:25;;31797:1;31729:66;31725:74;31722:1;31719:81;31716:107;;;31803:18;;:::i;:::-;31716:107;31847:1;31844;31840:9;31833:16;;31550:305;;;;:::o;31861:225::-;32001:34;31997:1;31989:6;31985:14;31978:58;32070:8;32065:2;32057:6;32053:15;32046:33;31861:225;:::o;32092:366::-;32234:3;32255:67;32319:2;32314:3;32255:67;:::i;:::-;32248:74;;32331:93;32420:3;32331:93;:::i;:::-;32449:2;32444:3;32440:12;32433:19;;32092:366;;;:::o;32464:419::-;32630:4;32668:2;32657:9;32653:18;32645:26;;32717:9;32711:4;32707:20;32703:1;32692:9;32688:17;32681:47;32745:131;32871:4;32745:131;:::i;:::-;32737:139;;32464:419;;;:::o;32889:237::-;33029:34;33025:1;33017:6;33013:14;33006:58;33098:20;33093:2;33085:6;33081:15;33074:45;32889:237;:::o;33132:366::-;33274:3;33295:67;33359:2;33354:3;33295:67;:::i;:::-;33288:74;;33371:93;33460:3;33371:93;:::i;:::-;33489:2;33484:3;33480:12;33473:19;;33132:366;;;:::o;33504:419::-;33670:4;33708:2;33697:9;33693:18;33685:26;;33757:9;33751:4;33747:20;33743:1;33732:9;33728:17;33721:47;33785:131;33911:4;33785:131;:::i;:::-;33777:139;;33504:419;;;:::o;33929:225::-;34069:34;34065:1;34057:6;34053:14;34046:58;34138:8;34133:2;34125:6;34121:15;34114:33;33929:225;:::o;34160:366::-;34302:3;34323:67;34387:2;34382:3;34323:67;:::i;:::-;34316:74;;34399:93;34488:3;34399:93;:::i;:::-;34517:2;34512:3;34508:12;34501:19;;34160:366;;;:::o;34532:419::-;34698:4;34736:2;34725:9;34721:18;34713:26;;34785:9;34779:4;34775:20;34771:1;34760:9;34756:17;34749:47;34813:131;34939:4;34813:131;:::i;:::-;34805:139;;34532:419;;;:::o;34957:224::-;35097:34;35093:1;35085:6;35081:14;35074:58;35166:7;35161:2;35153:6;35149:15;35142:32;34957:224;:::o;35187:366::-;35329:3;35350:67;35414:2;35409:3;35350:67;:::i;:::-;35343:74;;35426:93;35515:3;35426:93;:::i;:::-;35544:2;35539:3;35535:12;35528:19;;35187:366;;;:::o;35559:419::-;35725:4;35763:2;35752:9;35748:18;35740:26;;35812:9;35806:4;35802:20;35798:1;35787:9;35783:17;35776:47;35840:131;35966:4;35840:131;:::i;:::-;35832:139;;35559:419;;;:::o;35984:229::-;36124:34;36120:1;36112:6;36108:14;36101:58;36193:12;36188:2;36180:6;36176:15;36169:37;35984:229;:::o;36219:366::-;36361:3;36382:67;36446:2;36441:3;36382:67;:::i;:::-;36375:74;;36458:93;36547:3;36458:93;:::i;:::-;36576:2;36571:3;36567:12;36560:19;;36219:366;;;:::o;36591:419::-;36757:4;36795:2;36784:9;36780:18;36772:26;;36844:9;36838:4;36834:20;36830:1;36819:9;36815:17;36808:47;36872:131;36998:4;36872:131;:::i;:::-;36864:139;;36591:419;;;:::o;37016:234::-;37156:34;37152:1;37144:6;37140:14;37133:58;37225:17;37220:2;37212:6;37208:15;37201:42;37016:234;:::o;37256:366::-;37398:3;37419:67;37483:2;37478:3;37419:67;:::i;:::-;37412:74;;37495:93;37584:3;37495:93;:::i;:::-;37613:2;37608:3;37604:12;37597:19;;37256:366;;;:::o;37628:419::-;37794:4;37832:2;37821:9;37817:18;37809:26;;37881:9;37875:4;37871:20;37867:1;37856:9;37852:17;37845:47;37909:131;38035:4;37909:131;:::i;:::-;37901:139;;37628:419;;;:::o;38053:98::-;38104:6;38138:5;38132:12;38122:22;;38053:98;;;:::o;38157:168::-;38240:11;38274:6;38269:3;38262:19;38314:4;38309:3;38305:14;38290:29;;38157:168;;;;:::o;38331:360::-;38417:3;38445:38;38477:5;38445:38;:::i;:::-;38499:70;38562:6;38557:3;38499:70;:::i;:::-;38492:77;;38578:52;38623:6;38618:3;38611:4;38604:5;38600:16;38578:52;:::i;:::-;38655:29;38677:6;38655:29;:::i;:::-;38650:3;38646:39;38639:46;;38421:270;38331:360;;;;:::o;38697:640::-;38892:4;38930:3;38919:9;38915:19;38907:27;;38944:71;39012:1;39001:9;38997:17;38988:6;38944:71;:::i;:::-;39025:72;39093:2;39082:9;39078:18;39069:6;39025:72;:::i;:::-;39107;39175:2;39164:9;39160:18;39151:6;39107:72;:::i;:::-;39226:9;39220:4;39216:20;39211:2;39200:9;39196:18;39189:48;39254:76;39325:4;39316:6;39254:76;:::i;:::-;39246:84;;38697:640;;;;;;;:::o;39343:141::-;39399:5;39430:6;39424:13;39415:22;;39446:32;39472:5;39446:32;:::i;:::-;39343:141;;;;:::o;39490:349::-;39559:6;39608:2;39596:9;39587:7;39583:23;39579:32;39576:119;;;39614:79;;:::i;:::-;39576:119;39734:1;39759:63;39814:7;39805:6;39794:9;39790:22;39759:63;:::i;:::-;39749:73;;39705:127;39490:349;;;;:::o;39845:233::-;39884:3;39907:24;39925:5;39907:24;:::i;:::-;39898:33;;39953:66;39946:5;39943:77;39940:103;;40023:18;;:::i;:::-;39940:103;40070:1;40063:5;40059:13;40052:20;;39845:233;;;:::o;40084:180::-;40132:77;40129:1;40122:88;40229:4;40226:1;40219:15;40253:4;40250:1;40243:15;40270:185;40310:1;40327:20;40345:1;40327:20;:::i;:::-;40322:25;;40361:20;40379:1;40361:20;:::i;:::-;40356:25;;40400:1;40390:35;;40405:18;;:::i;:::-;40390:35;40447:1;40444;40440:9;40435:14;;40270:185;;;;:::o;40461:191::-;40501:4;40521:20;40539:1;40521:20;:::i;:::-;40516:25;;40555:20;40573:1;40555:20;:::i;:::-;40550:25;;40594:1;40591;40588:8;40585:34;;;40599:18;;:::i;:::-;40585:34;40644:1;40641;40637:9;40629:17;;40461:191;;;;:::o;40658:176::-;40690:1;40707:20;40725:1;40707:20;:::i;:::-;40702:25;;40741:20;40759:1;40741:20;:::i;:::-;40736:25;;40780:1;40770:35;;40785:18;;:::i;:::-;40770:35;40826:1;40823;40819:9;40814:14;;40658:176;;;;:::o;40840:180::-;40888:77;40885:1;40878:88;40985:4;40982:1;40975:15;41009:4;41006:1;40999:15;41026:220;41166:34;41162:1;41154:6;41150:14;41143:58;41235:3;41230:2;41222:6;41218:15;41211:28;41026:220;:::o;41252:366::-;41394:3;41415:67;41479:2;41474:3;41415:67;:::i;:::-;41408:74;;41491:93;41580:3;41491:93;:::i;:::-;41609:2;41604:3;41600:12;41593:19;;41252:366;;;:::o;41624:419::-;41790:4;41828:2;41817:9;41813:18;41805:26;;41877:9;41871:4;41867:20;41863:1;41852:9;41848:17;41841:47;41905:131;42031:4;41905:131;:::i;:::-;41897:139;;41624:419;;;:::o;42049:227::-;42189:34;42185:1;42177:6;42173:14;42166:58;42258:10;42253:2;42245:6;42241:15;42234:35;42049:227;:::o;42282:366::-;42424:3;42445:67;42509:2;42504:3;42445:67;:::i;:::-;42438:74;;42521:93;42610:3;42521:93;:::i;:::-;42639:2;42634:3;42630:12;42623:19;;42282:366;;;:::o;42654:419::-;42820:4;42858:2;42847:9;42843:18;42835:26;;42907:9;42901:4;42897:20;42893:1;42882:9;42878:17;42871:47;42935:131;43061:4;42935:131;:::i;:::-;42927:139;;42654:419;;;:::o

Swarm Source

ipfs://23a576ecfa57279c28ef589b41c61d2be5ee5b9a88bb1c2565e2819ce0ee8064

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