Token

Post-It Degens (PID)

ERC-721

Overview

Max Total Supply

539 PID

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xb966c0cd7aacbe48df7f0758b90ac63d6359d810

Filtered by Token Holder

0xc9BCA9AaA2D7608F4632A2b36657D9cB258b65C5

Balance

1 PID

0xc9bca9aaa2d7608f4632a2b36657d9cb258b65c5

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.7+commit.e28d00a7

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-08-21
*/

// 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://QmQFoD8zpc3cCqk1A2S2eAKzToUxodn6ypjvRBkxmxNm8x/";
    bool public pause = false;
    uint256 public Degens = 6969;
    uint256 public maxmint = 5; 
    uint256 public mintrate = 0.0005 ether;
    mapping(address => uint256) public howmanyowned;
   
	constructor() ERC721A("Post-It Degens", "PID") {}

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


 	function mint(uint256 quantity) external payable {
  	    uint256 Totalsupply = totalSupply();
        require(pause);
        require(Totalsupply + maxmint <= Degens);
        require(msg.sender == tx.origin);
    	require(howmanyowned[msg.sender] < maxmint);
        require(msg.value >= (mintrate * quantity), "Not enough ETH");
        _safeMint(msg.sender, quantity);
        howmanyowned[msg.sender] += maxmint;
    }

    function AYBABTU(uint256 quantity) external onlyOwner {
  	    uint256 Totalsupply = totalSupply();
        require(Totalsupply + maxmint <= Degens);
        require(msg.sender == tx.origin);
        
        _safeMint(msg.sender, quantity);
    
    }


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

    function changebasur(string memory _basur) external onlyOwner {
        _basuri = _basur;
    }
function withdraw() external payable onlyOwner{
    payable(owner()).transfer(address(this).balance);
}

function setMintRate(uint256 _mintRate) public onlyOwner
{
mintrate = _mintRate;
}

}

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":[{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"AYBABTU","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"Degens","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":[{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"mint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"mintrate","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"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":"uint256","name":"_mintRate","type":"uint256"}],"name":"setMintRate","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"},{"inputs":[],"name":"withdraw","outputs":[],"stateMutability":"payable","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:1651: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;:::-;;57472:82;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;39278:1007;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57661:105;;;:::i;:::-;;44923:177;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;57562:97;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;38791:187;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42052:124;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57203:259;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;40793:221;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;13944:94;;;;;;;;;;;;;:::i;:::-;;56534:47;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56388:25;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56455:26;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56301:80;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;13293:87;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;42412:104;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56763:432;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;44100:288;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;45171:355;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;42587:344;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56489:38;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;57770:85;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;44459:164;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;56420:28;;;;;;;;;;;;;:::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;57472:82::-;13524:12;:10;:12::i;:::-;13513:23;;:7;:5;:7::i;:::-;:23;;;13505:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;57541:5:::1;57533;;:13;;;;;;;;;;;;;;;;;;57472: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;57661:105::-;13524:12;:10;:12::i;:::-;13513:23;;:7;:5;:7::i;:::-;:23;;;13505:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;57722:7:::1;:5;:7::i;:::-;57714:25;;:48;57740:21;57714:48;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;57661:105::o:0;44923:177::-;45053:39;45070:4;45076:2;45080:7;45053:39;;;;;;;;;;;;:16;:39::i;:::-;44923:177;;;:::o;57562:97::-;13524:12;:10;:12::i;:::-;13513:23;;:7;:5;:7::i;:::-;:23;;;13505:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;57645:6:::1;57635:7;:16;;;;;;;;;;;;:::i;:::-;;57562: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;57203:259::-;13524:12;:10;:12::i;:::-;13513:23;;:7;:5;:7::i;:::-;:23;;;13505:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;57267:19:::1;57289:13;:11;:13::i;:::-;57267:35;;57346:6;;57335:7;;57321:11;:21;;;;:::i;:::-;:31;;57313:40;;;::::0;::::1;;57386:9;57372:23;;:10;:23;;;57364:32;;;::::0;::::1;;57417:31;57427:10;57439:8;57417:9;:31::i;:::-;57257:205;57203:259:::0;:::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;56534:47::-;;;;;;;;;;;;;;;;;:::o;56388:25::-;;;;;;;;;;;;;:::o;56455: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;56763:432::-;56822:19;56844:13;:11;:13::i;:::-;56822:35;;56876:5;;;;;;;;;;;56868:14;;;;;;56926:6;;56915:7;;56901:11;:21;;;;:::i;:::-;:31;;56893:40;;;;;;56966:9;56952:23;;:10;:23;;;56944:32;;;;;;57019:7;;56992:12;:24;57005:10;56992:24;;;;;;;;;;;;;;;;:34;56984:43;;;;;;57071:8;57060;;:19;;;;:::i;:::-;57046:9;:34;;57038:61;;;;;;;;;;;;:::i;:::-;;;;;;;;;57110:31;57120:10;57132:8;57110:9;:31::i;:::-;57180:7;;57152:12;:24;57165:10;57152:24;;;;;;;;;;;;;;;;:35;;;;;;;:::i;:::-;;;;;;;;56812:383;56763:432;:::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;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;56489:38::-;;;;:::o;57770:85::-;13524:12;:10;:12::i;:::-;13513:23;;:7;:5;:7::i;:::-;:23;;;13505:68;;;;;;;;;;;;:::i;:::-;;;;;;;;;57842:9:::1;57831:8;:20;;;;57770:85:::0;:::o;44459:164::-;44556:4;44580:18;:25;44599:5;44580:25;;;;;;;;;;;;;;;:35;44606:8;44580:35;;;;;;;;;;;;;;;;;;;;;;;;;44573:42;;44459:164;;;;:::o;56420:28::-;;;;:::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;;;;14274:73;;;;;;;;;;;;:::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;45900:104::-;45969:27;45979:2;45983:8;45969:27;;;;;;;;;;;;:9;:27::i;:::-;45900:104;;:::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;56647:108::-;56707:13;56740:7;56733:14;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;56647: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;52754:159::-;;;;;:::o;53325:158::-;;;;;:::o;46367:163::-;46490:32;46496:2;46500:8;46510:5;46517:4;46490:5;:32::i;:::-;46367:163;;;:::o;15307:387::-;15367:4;15575:12;15642:7;15630:20;15622:28;;15685:1;15678:4;:8;15671:15;;;15307:387;;;:::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:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;;:::o;7:410:1:-;84:5;109:65;125:48;166:6;125:48;:::i;:::-;109:65;:::i;:::-;100:74;;197:6;190:5;183:21;235:4;228:5;224:16;273:3;264:6;259:3;255:16;252:25;249:112;;;280:79;;:::i;:::-;249:112;370:41;404:6;399:3;394;370:41;:::i;:::-;90:327;7:410;;;;;:::o;423:412::-;501:5;526:66;542:49;584:6;542:49;:::i;:::-;526:66;:::i;:::-;517:75;;615:6;608:5;601:21;653:4;646:5;642:16;691:3;682:6;677:3;673:16;670:25;667:112;;;698:79;;:::i;:::-;667:112;788:41;822:6;817:3;812;788:41;:::i;:::-;507:328;423:412;;;;;:::o;841:139::-;887:5;925:6;912:20;903:29;;941:33;968:5;941:33;:::i;:::-;841:139;;;;:::o;986:133::-;1029:5;1067:6;1054:20;1045:29;;1083:30;1107:5;1083:30;:::i;:::-;986:133;;;;:::o;1125:137::-;1170:5;1208:6;1195:20;1186:29;;1224:32;1250:5;1224:32;:::i;:::-;1125:137;;;;:::o;1268:141::-;1324:5;1355:6;1349:13;1340:22;;1371:32;1397:5;1371:32;:::i;:::-;1268:141;;;;:::o;1428:338::-;1483:5;1532:3;1525:4;1517:6;1513:17;1509:27;1499:122;;1540:79;;:::i;:::-;1499:122;1657:6;1644:20;1682:78;1756:3;1748:6;1741:4;1733:6;1729:17;1682:78;:::i;:::-;1673:87;;1489:277;1428:338;;;;:::o;1786:340::-;1842:5;1891:3;1884:4;1876:6;1872:17;1868:27;1858:122;;1899:79;;:::i;:::-;1858:122;2016:6;2003:20;2041:79;2116:3;2108:6;2101:4;2093:6;2089:17;2041:79;:::i;:::-;2032:88;;1848:278;1786:340;;;;:::o;2132:139::-;2178:5;2216:6;2203:20;2194:29;;2232:33;2259:5;2232:33;:::i;:::-;2132:139;;;;:::o;2277:329::-;2336:6;2385:2;2373:9;2364:7;2360:23;2356:32;2353:119;;;2391:79;;:::i;:::-;2353:119;2511:1;2536:53;2581:7;2572:6;2561:9;2557:22;2536:53;:::i;:::-;2526:63;;2482:117;2277:329;;;;:::o;2612:474::-;2680:6;2688;2737:2;2725:9;2716:7;2712:23;2708:32;2705:119;;;2743:79;;:::i;:::-;2705:119;2863:1;2888:53;2933:7;2924:6;2913:9;2909:22;2888:53;:::i;:::-;2878:63;;2834:117;2990:2;3016:53;3061:7;3052:6;3041:9;3037:22;3016:53;:::i;:::-;3006:63;;2961:118;2612:474;;;;;:::o;3092:619::-;3169:6;3177;3185;3234:2;3222:9;3213:7;3209:23;3205:32;3202:119;;;3240:79;;:::i;:::-;3202:119;3360:1;3385:53;3430:7;3421:6;3410:9;3406:22;3385:53;:::i;:::-;3375:63;;3331:117;3487:2;3513:53;3558:7;3549:6;3538:9;3534:22;3513:53;:::i;:::-;3503:63;;3458:118;3615:2;3641:53;3686:7;3677:6;3666:9;3662:22;3641:53;:::i;:::-;3631:63;;3586:118;3092:619;;;;;:::o;3717:943::-;3812:6;3820;3828;3836;3885:3;3873:9;3864:7;3860:23;3856:33;3853:120;;;3892:79;;:::i;:::-;3853:120;4012:1;4037:53;4082:7;4073:6;4062:9;4058:22;4037:53;:::i;:::-;4027:63;;3983:117;4139:2;4165:53;4210:7;4201:6;4190:9;4186:22;4165:53;:::i;:::-;4155:63;;4110:118;4267:2;4293:53;4338:7;4329:6;4318:9;4314:22;4293:53;:::i;:::-;4283:63;;4238:118;4423:2;4412:9;4408:18;4395:32;4454:18;4446:6;4443:30;4440:117;;;4476:79;;:::i;:::-;4440:117;4581:62;4635:7;4626:6;4615:9;4611:22;4581:62;:::i;:::-;4571:72;;4366:287;3717:943;;;;;;;:::o;4666:468::-;4731:6;4739;4788:2;4776:9;4767:7;4763:23;4759:32;4756:119;;;4794:79;;:::i;:::-;4756:119;4914:1;4939:53;4984:7;4975:6;4964:9;4960:22;4939:53;:::i;:::-;4929:63;;4885:117;5041:2;5067:50;5109:7;5100:6;5089:9;5085:22;5067:50;:::i;:::-;5057:60;;5012:115;4666:468;;;;;:::o;5140:474::-;5208:6;5216;5265:2;5253:9;5244:7;5240:23;5236:32;5233:119;;;5271:79;;:::i;:::-;5233:119;5391:1;5416:53;5461:7;5452:6;5441:9;5437:22;5416:53;:::i;:::-;5406:63;;5362:117;5518:2;5544:53;5589:7;5580:6;5569:9;5565:22;5544:53;:::i;:::-;5534:63;;5489:118;5140:474;;;;;:::o;5620:323::-;5676:6;5725:2;5713:9;5704:7;5700:23;5696:32;5693:119;;;5731:79;;:::i;:::-;5693:119;5851:1;5876:50;5918:7;5909:6;5898:9;5894:22;5876:50;:::i;:::-;5866:60;;5822:114;5620:323;;;;:::o;5949:327::-;6007:6;6056:2;6044:9;6035:7;6031:23;6027:32;6024:119;;;6062:79;;:::i;:::-;6024:119;6182:1;6207:52;6251:7;6242:6;6231:9;6227:22;6207:52;:::i;:::-;6197:62;;6153:116;5949:327;;;;:::o;6282:349::-;6351:6;6400:2;6388:9;6379:7;6375:23;6371:32;6368:119;;;6406:79;;:::i;:::-;6368:119;6526:1;6551:63;6606:7;6597:6;6586:9;6582:22;6551:63;:::i;:::-;6541:73;;6497:127;6282:349;;;;:::o;6637:509::-;6706:6;6755:2;6743:9;6734:7;6730:23;6726:32;6723:119;;;6761:79;;:::i;:::-;6723:119;6909:1;6898:9;6894:17;6881:31;6939:18;6931:6;6928:30;6925:117;;;6961:79;;:::i;:::-;6925:117;7066:63;7121:7;7112:6;7101:9;7097:22;7066:63;:::i;:::-;7056:73;;6852:287;6637:509;;;;:::o;7152:329::-;7211:6;7260:2;7248:9;7239:7;7235:23;7231:32;7228:119;;;7266:79;;:::i;:::-;7228:119;7386:1;7411:53;7456:7;7447:6;7436:9;7432:22;7411:53;:::i;:::-;7401:63;;7357:117;7152:329;;;;:::o;7487:118::-;7574:24;7592:5;7574:24;:::i;:::-;7569:3;7562:37;7487:118;;:::o;7611:109::-;7692:21;7707:5;7692:21;:::i;:::-;7687:3;7680:34;7611:109;;:::o;7726:360::-;7812:3;7840:38;7872:5;7840:38;:::i;:::-;7894:70;7957:6;7952:3;7894:70;:::i;:::-;7887:77;;7973:52;8018:6;8013:3;8006:4;7999:5;7995:16;7973:52;:::i;:::-;8050:29;8072:6;8050:29;:::i;:::-;8045:3;8041:39;8034:46;;7816:270;7726:360;;;;:::o;8092:364::-;8180:3;8208:39;8241:5;8208:39;:::i;:::-;8263:71;8327:6;8322:3;8263:71;:::i;:::-;8256:78;;8343:52;8388:6;8383:3;8376:4;8369:5;8365:16;8343:52;:::i;:::-;8420:29;8442:6;8420:29;:::i;:::-;8415:3;8411:39;8404:46;;8184:272;8092:364;;;;:::o;8462:377::-;8568:3;8596:39;8629:5;8596:39;:::i;:::-;8651:89;8733:6;8728:3;8651:89;:::i;:::-;8644:96;;8749:52;8794:6;8789:3;8782:4;8775:5;8771:16;8749:52;:::i;:::-;8826:6;8821:3;8817:16;8810:23;;8572:267;8462:377;;;;:::o;8845:366::-;8987:3;9008:67;9072:2;9067:3;9008:67;:::i;:::-;9001:74;;9084:93;9173:3;9084:93;:::i;:::-;9202:2;9197:3;9193:12;9186:19;;8845:366;;;:::o;9217:::-;9359:3;9380:67;9444:2;9439:3;9380:67;:::i;:::-;9373:74;;9456:93;9545:3;9456:93;:::i;:::-;9574:2;9569:3;9565:12;9558:19;;9217:366;;;:::o;9589:::-;9731:3;9752:67;9816:2;9811:3;9752:67;:::i;:::-;9745:74;;9828:93;9917:3;9828:93;:::i;:::-;9946:2;9941:3;9937:12;9930:19;;9589:366;;;:::o;9961:::-;10103:3;10124:67;10188:2;10183:3;10124:67;:::i;:::-;10117:74;;10200:93;10289:3;10200:93;:::i;:::-;10318:2;10313:3;10309:12;10302:19;;9961:366;;;:::o;10333:::-;10475:3;10496:67;10560:2;10555:3;10496:67;:::i;:::-;10489:74;;10572:93;10661:3;10572:93;:::i;:::-;10690:2;10685:3;10681:12;10674:19;;10333:366;;;:::o;10705:::-;10847:3;10868:67;10932:2;10927:3;10868:67;:::i;:::-;10861:74;;10944:93;11033:3;10944:93;:::i;:::-;11062:2;11057:3;11053:12;11046:19;;10705:366;;;:::o;11077:::-;11219:3;11240:67;11304:2;11299:3;11240:67;:::i;:::-;11233:74;;11316:93;11405:3;11316:93;:::i;:::-;11434:2;11429:3;11425:12;11418:19;;11077:366;;;:::o;11449:::-;11591:3;11612:67;11676:2;11671:3;11612:67;:::i;:::-;11605:74;;11688:93;11777:3;11688:93;:::i;:::-;11806:2;11801:3;11797:12;11790:19;;11449:366;;;:::o;11821:::-;11963:3;11984:67;12048:2;12043:3;11984:67;:::i;:::-;11977:74;;12060:93;12149:3;12060:93;:::i;:::-;12178:2;12173:3;12169:12;12162:19;;11821:366;;;:::o;12193:400::-;12353:3;12374:84;12456:1;12451:3;12374:84;:::i;:::-;12367:91;;12467:93;12556:3;12467:93;:::i;:::-;12585:1;12580:3;12576:11;12569:18;;12193:400;;;:::o;12599:366::-;12741:3;12762:67;12826:2;12821:3;12762:67;:::i;:::-;12755:74;;12838:93;12927:3;12838:93;:::i;:::-;12956:2;12951:3;12947:12;12940:19;;12599:366;;;:::o;12971:::-;13113:3;13134:67;13198:2;13193:3;13134:67;:::i;:::-;13127:74;;13210:93;13299:3;13210:93;:::i;:::-;13328:2;13323:3;13319:12;13312:19;;12971:366;;;:::o;13343:::-;13485:3;13506:67;13570:2;13565:3;13506:67;:::i;:::-;13499:74;;13582:93;13671:3;13582:93;:::i;:::-;13700:2;13695:3;13691:12;13684:19;;13343:366;;;:::o;13715:::-;13857:3;13878:67;13942:2;13937:3;13878:67;:::i;:::-;13871:74;;13954:93;14043:3;13954:93;:::i;:::-;14072:2;14067:3;14063:12;14056:19;;13715:366;;;:::o;14087:::-;14229:3;14250:67;14314:2;14309:3;14250:67;:::i;:::-;14243:74;;14326:93;14415:3;14326:93;:::i;:::-;14444:2;14439:3;14435:12;14428:19;;14087:366;;;:::o;14459:::-;14601:3;14622:67;14686:2;14681:3;14622:67;:::i;:::-;14615:74;;14698:93;14787:3;14698:93;:::i;:::-;14816:2;14811:3;14807:12;14800:19;;14459:366;;;:::o;14831:::-;14973:3;14994:67;15058:2;15053:3;14994:67;:::i;:::-;14987:74;;15070:93;15159:3;15070:93;:::i;:::-;15188:2;15183:3;15179:12;15172:19;;14831:366;;;:::o;15203:::-;15345:3;15366:67;15430:2;15425:3;15366:67;:::i;:::-;15359:74;;15442:93;15531:3;15442:93;:::i;:::-;15560:2;15555:3;15551:12;15544:19;;15203:366;;;:::o;15575:::-;15717:3;15738:67;15802:2;15797:3;15738:67;:::i;:::-;15731:74;;15814:93;15903:3;15814:93;:::i;:::-;15932:2;15927:3;15923:12;15916:19;;15575:366;;;:::o;15947:::-;16089:3;16110:67;16174:2;16169:3;16110:67;:::i;:::-;16103:74;;16186:93;16275:3;16186:93;:::i;:::-;16304:2;16299:3;16295:12;16288:19;;15947:366;;;:::o;16319:::-;16461:3;16482:67;16546:2;16541:3;16482:67;:::i;:::-;16475:74;;16558:93;16647:3;16558:93;:::i;:::-;16676:2;16671:3;16667:12;16660:19;;16319:366;;;:::o;16691:118::-;16778:24;16796:5;16778:24;:::i;:::-;16773:3;16766:37;16691:118;;:::o;16815:701::-;17096:3;17118:95;17209:3;17200:6;17118:95;:::i;:::-;17111:102;;17230:95;17321:3;17312:6;17230:95;:::i;:::-;17223:102;;17342:148;17486:3;17342:148;:::i;:::-;17335:155;;17507:3;17500:10;;16815:701;;;;;:::o;17522:222::-;17615:4;17653:2;17642:9;17638:18;17630:26;;17666:71;17734:1;17723:9;17719:17;17710:6;17666:71;:::i;:::-;17522:222;;;;:::o;17750:640::-;17945:4;17983:3;17972:9;17968:19;17960:27;;17997:71;18065:1;18054:9;18050:17;18041:6;17997:71;:::i;:::-;18078:72;18146:2;18135:9;18131:18;18122:6;18078:72;:::i;:::-;18160;18228:2;18217:9;18213:18;18204:6;18160:72;:::i;:::-;18279:9;18273:4;18269:20;18264:2;18253:9;18249:18;18242:48;18307:76;18378:4;18369:6;18307:76;:::i;:::-;18299:84;;17750:640;;;;;;;:::o;18396:210::-;18483:4;18521:2;18510:9;18506:18;18498:26;;18534:65;18596:1;18585:9;18581:17;18572:6;18534:65;:::i;:::-;18396:210;;;;:::o;18612:313::-;18725:4;18763:2;18752:9;18748:18;18740:26;;18812:9;18806:4;18802:20;18798:1;18787:9;18783:17;18776:47;18840:78;18913:4;18904:6;18840:78;:::i;:::-;18832:86;;18612:313;;;;:::o;18931:419::-;19097:4;19135:2;19124:9;19120:18;19112:26;;19184:9;19178:4;19174:20;19170:1;19159:9;19155:17;19148:47;19212:131;19338:4;19212:131;:::i;:::-;19204:139;;18931:419;;;:::o;19356:::-;19522:4;19560:2;19549:9;19545:18;19537:26;;19609:9;19603:4;19599:20;19595:1;19584:9;19580:17;19573:47;19637:131;19763:4;19637:131;:::i;:::-;19629:139;;19356:419;;;:::o;19781:::-;19947:4;19985:2;19974:9;19970:18;19962:26;;20034:9;20028:4;20024:20;20020:1;20009:9;20005:17;19998:47;20062:131;20188:4;20062:131;:::i;:::-;20054:139;;19781:419;;;:::o;20206:::-;20372:4;20410:2;20399:9;20395:18;20387:26;;20459:9;20453:4;20449:20;20445:1;20434:9;20430:17;20423:47;20487:131;20613:4;20487:131;:::i;:::-;20479:139;;20206:419;;;:::o;20631:::-;20797:4;20835:2;20824:9;20820:18;20812:26;;20884:9;20878:4;20874:20;20870:1;20859:9;20855:17;20848:47;20912:131;21038:4;20912:131;:::i;:::-;20904:139;;20631:419;;;:::o;21056:::-;21222:4;21260:2;21249:9;21245:18;21237:26;;21309:9;21303:4;21299:20;21295:1;21284:9;21280:17;21273:47;21337:131;21463:4;21337:131;:::i;:::-;21329:139;;21056:419;;;:::o;21481:::-;21647:4;21685:2;21674:9;21670:18;21662:26;;21734:9;21728:4;21724:20;21720:1;21709:9;21705:17;21698:47;21762:131;21888:4;21762:131;:::i;:::-;21754:139;;21481:419;;;:::o;21906:::-;22072:4;22110:2;22099:9;22095:18;22087:26;;22159:9;22153:4;22149:20;22145:1;22134:9;22130:17;22123:47;22187:131;22313:4;22187:131;:::i;:::-;22179:139;;21906:419;;;:::o;22331:::-;22497:4;22535:2;22524:9;22520:18;22512:26;;22584:9;22578:4;22574:20;22570:1;22559:9;22555:17;22548:47;22612:131;22738:4;22612:131;:::i;:::-;22604:139;;22331:419;;;:::o;22756:::-;22922:4;22960:2;22949:9;22945:18;22937:26;;23009:9;23003:4;22999:20;22995:1;22984:9;22980:17;22973:47;23037:131;23163:4;23037:131;:::i;:::-;23029:139;;22756:419;;;:::o;23181:::-;23347:4;23385:2;23374:9;23370:18;23362:26;;23434:9;23428:4;23424:20;23420:1;23409:9;23405:17;23398:47;23462:131;23588:4;23462:131;:::i;:::-;23454:139;;23181:419;;;:::o;23606:::-;23772:4;23810:2;23799:9;23795:18;23787:26;;23859:9;23853:4;23849:20;23845:1;23834:9;23830:17;23823:47;23887:131;24013:4;23887:131;:::i;:::-;23879:139;;23606:419;;;:::o;24031:::-;24197:4;24235:2;24224:9;24220:18;24212:26;;24284:9;24278:4;24274:20;24270:1;24259:9;24255:17;24248:47;24312:131;24438:4;24312:131;:::i;:::-;24304:139;;24031:419;;;:::o;24456:::-;24622:4;24660:2;24649:9;24645:18;24637:26;;24709:9;24703:4;24699:20;24695:1;24684:9;24680:17;24673:47;24737:131;24863:4;24737:131;:::i;:::-;24729:139;;24456:419;;;:::o;24881:::-;25047:4;25085:2;25074:9;25070:18;25062:26;;25134:9;25128:4;25124:20;25120:1;25109:9;25105:17;25098:47;25162:131;25288:4;25162:131;:::i;:::-;25154:139;;24881:419;;;:::o;25306:::-;25472:4;25510:2;25499:9;25495:18;25487:26;;25559:9;25553:4;25549:20;25545:1;25534:9;25530:17;25523:47;25587:131;25713:4;25587:131;:::i;:::-;25579:139;;25306:419;;;:::o;25731:::-;25897:4;25935:2;25924:9;25920:18;25912:26;;25984:9;25978:4;25974:20;25970:1;25959:9;25955:17;25948:47;26012:131;26138:4;26012:131;:::i;:::-;26004:139;;25731:419;;;:::o;26156:::-;26322:4;26360:2;26349:9;26345:18;26337:26;;26409:9;26403:4;26399:20;26395:1;26384:9;26380:17;26373:47;26437:131;26563:4;26437:131;:::i;:::-;26429:139;;26156:419;;;:::o;26581:::-;26747:4;26785:2;26774:9;26770:18;26762:26;;26834:9;26828:4;26824:20;26820:1;26809:9;26805:17;26798:47;26862:131;26988:4;26862:131;:::i;:::-;26854:139;;26581:419;;;:::o;27006:::-;27172:4;27210:2;27199:9;27195:18;27187:26;;27259:9;27253:4;27249:20;27245:1;27234:9;27230:17;27223:47;27287:131;27413:4;27287:131;:::i;:::-;27279:139;;27006:419;;;:::o;27431:222::-;27524:4;27562:2;27551:9;27547:18;27539:26;;27575:71;27643:1;27632:9;27628:17;27619:6;27575:71;:::i;:::-;27431:222;;;;:::o;27659:129::-;27693:6;27720:20;;:::i;:::-;27710:30;;27749:33;27777:4;27769:6;27749:33;:::i;:::-;27659:129;;;:::o;27794:75::-;27827:6;27860:2;27854:9;27844:19;;27794:75;:::o;27875:307::-;27936:4;28026:18;28018:6;28015:30;28012:56;;;28048:18;;:::i;:::-;28012:56;28086:29;28108:6;28086:29;:::i;:::-;28078:37;;28170:4;28164;28160:15;28152:23;;27875:307;;;:::o;28188:308::-;28250:4;28340:18;28332:6;28329:30;28326:56;;;28362:18;;:::i;:::-;28326:56;28400:29;28422:6;28400:29;:::i;:::-;28392:37;;28484:4;28478;28474:15;28466:23;;28188:308;;;:::o;28502:98::-;28553:6;28587:5;28581:12;28571:22;;28502:98;;;:::o;28606:99::-;28658:6;28692:5;28686:12;28676:22;;28606:99;;;:::o;28711:168::-;28794:11;28828:6;28823:3;28816:19;28868:4;28863:3;28859:14;28844:29;;28711:168;;;;:::o;28885:169::-;28969:11;29003:6;28998:3;28991:19;29043:4;29038:3;29034:14;29019:29;;28885:169;;;;:::o;29060:148::-;29162:11;29199:3;29184:18;;29060:148;;;;:::o;29214:305::-;29254:3;29273:20;29291:1;29273:20;:::i;:::-;29268:25;;29307:20;29325:1;29307:20;:::i;:::-;29302:25;;29461:1;29393:66;29389:74;29386:1;29383:81;29380:107;;;29467:18;;:::i;:::-;29380:107;29511:1;29508;29504:9;29497:16;;29214:305;;;;:::o;29525:185::-;29565:1;29582:20;29600:1;29582:20;:::i;:::-;29577:25;;29616:20;29634:1;29616:20;:::i;:::-;29611:25;;29655:1;29645:35;;29660:18;;:::i;:::-;29645:35;29702:1;29699;29695:9;29690:14;;29525:185;;;;:::o;29716:348::-;29756:7;29779:20;29797:1;29779:20;:::i;:::-;29774:25;;29813:20;29831:1;29813:20;:::i;:::-;29808:25;;30001:1;29933:66;29929:74;29926:1;29923:81;29918:1;29911:9;29904:17;29900:105;29897:131;;;30008:18;;:::i;:::-;29897:131;30056:1;30053;30049:9;30038:20;;29716:348;;;;:::o;30070:191::-;30110:4;30130:20;30148:1;30130:20;:::i;:::-;30125:25;;30164:20;30182:1;30164:20;:::i;:::-;30159:25;;30203:1;30200;30197:8;30194:34;;;30208:18;;:::i;:::-;30194:34;30253:1;30250;30246:9;30238:17;;30070:191;;;;:::o;30267:96::-;30304:7;30333:24;30351:5;30333:24;:::i;:::-;30322:35;;30267:96;;;:::o;30369:90::-;30403:7;30446:5;30439:13;30432:21;30421:32;;30369:90;;;:::o;30465:149::-;30501:7;30541:66;30534:5;30530:78;30519:89;;30465:149;;;:::o;30620:126::-;30657:7;30697:42;30690:5;30686:54;30675:65;;30620:126;;;:::o;30752:77::-;30789:7;30818:5;30807:16;;30752:77;;;:::o;30835:154::-;30919:6;30914:3;30909;30896:30;30981:1;30972:6;30967:3;30963:16;30956:27;30835:154;;;:::o;30995:307::-;31063:1;31073:113;31087:6;31084:1;31081:13;31073:113;;;31172:1;31167:3;31163:11;31157:18;31153:1;31148:3;31144:11;31137:39;31109:2;31106:1;31102:10;31097:15;;31073:113;;;31204:6;31201:1;31198:13;31195:101;;;31284:1;31275:6;31270:3;31266:16;31259:27;31195:101;31044:258;30995:307;;;:::o;31308:320::-;31352:6;31389:1;31383:4;31379:12;31369:22;;31436:1;31430:4;31426:12;31457:18;31447:81;;31513:4;31505:6;31501:17;31491:27;;31447:81;31575:2;31567:6;31564:14;31544:18;31541:38;31538:84;;;31594:18;;:::i;:::-;31538:84;31359:269;31308:320;;;:::o;31634:281::-;31717:27;31739:4;31717:27;:::i;:::-;31709:6;31705:40;31847:6;31835:10;31832:22;31811:18;31799:10;31796:34;31793:62;31790:88;;;31858:18;;:::i;:::-;31790:88;31898:10;31894:2;31887:22;31677:238;31634:281;;:::o;31921:233::-;31960:3;31983:24;32001:5;31983:24;:::i;:::-;31974:33;;32029:66;32022:5;32019:77;32016:103;;;32099:18;;:::i;:::-;32016:103;32146:1;32139:5;32135:13;32128:20;;31921:233;;;:::o;32160:176::-;32192:1;32209:20;32227:1;32209:20;:::i;:::-;32204:25;;32243:20;32261:1;32243:20;:::i;:::-;32238:25;;32282:1;32272:35;;32287:18;;:::i;:::-;32272:35;32328:1;32325;32321:9;32316:14;;32160:176;;;;:::o;32342:180::-;32390:77;32387:1;32380:88;32487:4;32484:1;32477:15;32511:4;32508:1;32501:15;32528:180;32576:77;32573:1;32566:88;32673:4;32670:1;32663:15;32697:4;32694:1;32687:15;32714:180;32762:77;32759:1;32752:88;32859:4;32856:1;32849:15;32883:4;32880:1;32873:15;32900:180;32948:77;32945:1;32938:88;33045:4;33042:1;33035:15;33069:4;33066:1;33059:15;33086:180;33134:77;33131:1;33124:88;33231:4;33228:1;33221:15;33255:4;33252:1;33245:15;33272:117;33381:1;33378;33371:12;33395:117;33504:1;33501;33494:12;33518:117;33627:1;33624;33617:12;33641:117;33750:1;33747;33740:12;33764:102;33805:6;33856:2;33852:7;33847:2;33840:5;33836:14;33832:28;33822:38;;33764:102;;;:::o;33872:221::-;34012:34;34008:1;34000:6;33996:14;33989:58;34081:4;34076:2;34068:6;34064:15;34057:29;33872:221;:::o;34099:225::-;34239:34;34235:1;34227:6;34223:14;34216:58;34308:8;34303:2;34295:6;34291:15;34284:33;34099:225;:::o;34330:229::-;34470:34;34466:1;34458:6;34454:14;34447:58;34539:12;34534:2;34526:6;34522:15;34515:37;34330:229;:::o;34565:222::-;34705:34;34701:1;34693:6;34689:14;34682:58;34774:5;34769:2;34761:6;34757:15;34750:30;34565:222;:::o;34793:224::-;34933:34;34929:1;34921:6;34917:14;34910:58;35002:7;34997:2;34989:6;34985:15;34978:32;34793:224;:::o;35023:244::-;35163:34;35159:1;35151:6;35147:14;35140:58;35232:27;35227:2;35219:6;35215:15;35208:52;35023:244;:::o;35273:230::-;35413:34;35409:1;35401:6;35397:14;35390:58;35482:13;35477:2;35469:6;35465:15;35458:38;35273:230;:::o;35509:225::-;35649:34;35645:1;35637:6;35633:14;35626:58;35718:8;35713:2;35705:6;35701:15;35694:33;35509:225;:::o;35740:164::-;35880:16;35876:1;35868:6;35864:14;35857:40;35740:164;:::o;35910:155::-;36050:7;36046:1;36038:6;36034:14;36027:31;35910:155;:::o;36071:182::-;36211:34;36207:1;36199:6;36195:14;36188:58;36071:182;:::o;36259:234::-;36399:34;36395:1;36387:6;36383:14;36376:58;36468:17;36463:2;36455:6;36451:15;36444:42;36259:234;:::o;36499:176::-;36639:28;36635:1;36627:6;36623:14;36616:52;36499:176;:::o;36681:237::-;36821:34;36817:1;36809:6;36805:14;36798:58;36890:20;36885:2;36877:6;36873:15;36866:45;36681:237;:::o;36924:221::-;37064:34;37060:1;37052:6;37048:14;37041:58;37133:4;37128:2;37120:6;37116:15;37109:29;36924:221;:::o;37151:238::-;37291:34;37287:1;37279:6;37275:14;37268:58;37360:21;37355:2;37347:6;37343:15;37336:46;37151:238;:::o;37395:220::-;37535:34;37531:1;37523:6;37519:14;37512:58;37604:3;37599:2;37591:6;37587:15;37580:28;37395:220;:::o;37621:227::-;37761:34;37757:1;37749:6;37745:14;37738:58;37830:10;37825:2;37817:6;37813:15;37806:35;37621:227;:::o;37854:233::-;37994:34;37990:1;37982:6;37978:14;37971:58;38063:16;38058:2;38050:6;38046:15;38039:41;37854:233;:::o;38093:234::-;38233:34;38229:1;38221:6;38217:14;38210:58;38302:17;38297:2;38289:6;38285:15;38278:42;38093:234;:::o;38333:232::-;38473:34;38469:1;38461:6;38457:14;38450:58;38542:15;38537:2;38529:6;38525:15;38518:40;38333:232;:::o;38571:122::-;38644:24;38662:5;38644:24;:::i;:::-;38637:5;38634:35;38624:63;;38683:1;38680;38673:12;38624:63;38571:122;:::o;38699:116::-;38769:21;38784:5;38769:21;:::i;:::-;38762:5;38759:32;38749:60;;38805:1;38802;38795:12;38749:60;38699:116;:::o;38821:120::-;38893:23;38910:5;38893:23;:::i;:::-;38886:5;38883:34;38873:62;;38931:1;38928;38921:12;38873:62;38821:120;:::o;38947:122::-;39020:24;39038:5;39020:24;:::i;:::-;39013:5;39010:35;39000:63;;39059:1;39056;39049:12;39000:63;38947:122;:::o

Swarm Source

ipfs://9cbc14f51ae8086373a882067ae35fbd9c48648fec0c2eee24ee3bd495094b5e

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