Token

blackhole (bh)

ERC-721

Overview

Max Total Supply

0 bh

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0x6d84b2ba0cc68d23f7f24afe78efd833511e0947

Filtered by Token Holder

0x9c0031FE523E9F080b51Bb18920c7Be46d173046

Balance

1 bh

0x9c0031fe523e9f080b51bb18920c7be46d173046

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

blackhole

Compiler Version

v0.8.13+commit.abaa5c0e

Optimization Enabled:

Yes with 200 runs

Other Settings:

default evmVersion, MIT license

Contract Source Code (Solidity)

IDE

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

// SPDX-License-Identifier: MIT
// File: @openzeppelin/contracts/utils/structs/EnumerableSet.sol


// OpenZeppelin Contracts v4.4.1 (utils/structs/EnumerableSet.sol)

pragma solidity ^0.8.0;

/**
 * @dev Library for managing
 * https://en.wikipedia.org/wiki/Set_(abstract_data_type)[sets] of primitive
 * types.
 *
 * Sets have the following properties:
 *
 * - Elements are added, removed, and checked for existence in constant time
 * (O(1)).
 * - Elements are enumerated in O(n). No guarantees are made on the ordering.
 *
 * ```
 * contract Example {
 *     // Add the library methods
 *     using EnumerableSet for EnumerableSet.AddressSet;
 *
 *     // Declare a set state variable
 *     EnumerableSet.AddressSet private mySet;
 * }
 * ```
 *
 * As of v3.3.0, sets of type `bytes32` (`Bytes32Set`), `address` (`AddressSet`)
 * and `uint256` (`UintSet`) are supported.
 */
library EnumerableSet {
    // To implement this library for multiple types with as little code
    // repetition as possible, we write it in terms of a generic Set type with
    // bytes32 values.
    // The Set implementation uses private functions, and user-facing
    // implementations (such as AddressSet) are just wrappers around the
    // underlying Set.
    // This means that we can only create new EnumerableSets for types that fit
    // in bytes32.

    struct Set {
        // Storage of set values
        bytes32[] _values;
        // Position of the value in the `values` array, plus 1 because index 0
        // means a value is not in the set.
        mapping(bytes32 => uint256) _indexes;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function _add(Set storage set, bytes32 value) private returns (bool) {
        if (!_contains(set, value)) {
            set._values.push(value);
            // The value is stored at length-1, but we add 1 to all indexes
            // and use 0 as a sentinel value
            set._indexes[value] = set._values.length;
            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function _remove(Set storage set, bytes32 value) private returns (bool) {
        // We read and store the value's index to prevent multiple reads from the same storage slot
        uint256 valueIndex = set._indexes[value];

        if (valueIndex != 0) {
            // Equivalent to contains(set, value)
            // To delete an element from the _values array in O(1), we swap the element to delete with the last one in
            // the array, and then remove the last element (sometimes called as 'swap and pop').
            // This modifies the order of the array, as noted in {at}.

            uint256 toDeleteIndex = valueIndex - 1;
            uint256 lastIndex = set._values.length - 1;

            if (lastIndex != toDeleteIndex) {
                bytes32 lastvalue = set._values[lastIndex];

                // Move the last value to the index where the value to delete is
                set._values[toDeleteIndex] = lastvalue;
                // Update the index for the moved value
                set._indexes[lastvalue] = valueIndex; // Replace lastvalue's index to valueIndex
            }

            // Delete the slot where the moved value was stored
            set._values.pop();

            // Delete the index for the deleted slot
            delete set._indexes[value];

            return true;
        } else {
            return false;
        }
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function _contains(Set storage set, bytes32 value) private view returns (bool) {
        return set._indexes[value] != 0;
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function _length(Set storage set) private view returns (uint256) {
        return set._values.length;
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function _at(Set storage set, uint256 index) private view returns (bytes32) {
        return set._values[index];
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function _values(Set storage set) private view returns (bytes32[] memory) {
        return set._values;
    }

    // Bytes32Set

    struct Bytes32Set {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _add(set._inner, value);
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(Bytes32Set storage set, bytes32 value) internal returns (bool) {
        return _remove(set._inner, value);
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(Bytes32Set storage set, bytes32 value) internal view returns (bool) {
        return _contains(set._inner, value);
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(Bytes32Set storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(Bytes32Set storage set, uint256 index) internal view returns (bytes32) {
        return _at(set._inner, index);
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(Bytes32Set storage set) internal view returns (bytes32[] memory) {
        return _values(set._inner);
    }

    // AddressSet

    struct AddressSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(AddressSet storage set, address value) internal returns (bool) {
        return _add(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(AddressSet storage set, address value) internal returns (bool) {
        return _remove(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(AddressSet storage set, address value) internal view returns (bool) {
        return _contains(set._inner, bytes32(uint256(uint160(value))));
    }

    /**
     * @dev Returns the number of values in the set. O(1).
     */
    function length(AddressSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(AddressSet storage set, uint256 index) internal view returns (address) {
        return address(uint160(uint256(_at(set._inner, index))));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(AddressSet storage set) internal view returns (address[] memory) {
        bytes32[] memory store = _values(set._inner);
        address[] memory result;

        assembly {
            result := store
        }

        return result;
    }

    // UintSet

    struct UintSet {
        Set _inner;
    }

    /**
     * @dev Add a value to a set. O(1).
     *
     * Returns true if the value was added to the set, that is if it was not
     * already present.
     */
    function add(UintSet storage set, uint256 value) internal returns (bool) {
        return _add(set._inner, bytes32(value));
    }

    /**
     * @dev Removes a value from a set. O(1).
     *
     * Returns true if the value was removed from the set, that is if it was
     * present.
     */
    function remove(UintSet storage set, uint256 value) internal returns (bool) {
        return _remove(set._inner, bytes32(value));
    }

    /**
     * @dev Returns true if the value is in the set. O(1).
     */
    function contains(UintSet storage set, uint256 value) internal view returns (bool) {
        return _contains(set._inner, bytes32(value));
    }

    /**
     * @dev Returns the number of values on the set. O(1).
     */
    function length(UintSet storage set) internal view returns (uint256) {
        return _length(set._inner);
    }

    /**
     * @dev Returns the value stored at position `index` in the set. O(1).
     *
     * Note that there are no guarantees on the ordering of values inside the
     * array, and it may change when more values are added or removed.
     *
     * Requirements:
     *
     * - `index` must be strictly less than {length}.
     */
    function at(UintSet storage set, uint256 index) internal view returns (uint256) {
        return uint256(_at(set._inner, index));
    }

    /**
     * @dev Return the entire set in an array
     *
     * WARNING: This operation will copy the entire storage to memory, which can be quite expensive. This is designed
     * to mostly be used by view accessors that are queried without any gas fees. Developers should keep in mind that
     * this function has an unbounded cost, and using it as part of a state-changing function may render the function
     * uncallable if the set grows to a point where copying to memory consumes too much gas to fit in a block.
     */
    function values(UintSet storage set) internal view returns (uint256[] memory) {
        bytes32[] memory store = _values(set._inner);
        uint256[] memory result;

        assembly {
            result := store
        }

        return result;
    }
}

// File: @manifoldxyz/royalty-registry-solidity/contracts/specs/IEIP2981.sol



pragma solidity ^0.8.0;

/**
 * EIP-2981
 */
interface IEIP2981 {
    /**
     * bytes4(keccak256("royaltyInfo(uint256,uint256)")) == 0x2a55205a
     *
     * => 0x2a55205a = 0x2a55205a
     */
    function royaltyInfo(uint256 tokenId, uint256 value) external view returns (address, uint256);
}
// File: @openzeppelin/contracts/token/ERC20/IERC20.sol


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

pragma solidity ^0.8.0;

/**
 * @dev Interface of the ERC20 standard as defined in the EIP.
 */
interface IERC20 {
    /**
     * @dev Emitted when `value` tokens are moved from one account (`from`) to
     * another (`to`).
     *
     * Note that `value` may be zero.
     */
    event Transfer(address indexed from, address indexed to, uint256 value);

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

    /**
     * @dev Returns the amount of tokens in existence.
     */
    function totalSupply() external view returns (uint256);

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC20/extensions/IERC20Metadata.sol


// OpenZeppelin Contracts v4.4.1 (token/ERC20/extensions/IERC20Metadata.sol)

pragma solidity ^0.8.0;


/**
 * @dev Interface for the optional metadata functions from the ERC20 standard.
 *
 * _Available since v4.1._
 */
interface IERC20Metadata is IERC20 {
    /**
     * @dev Returns the name of the token.
     */
    function name() external view returns (string memory);

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

    /**
     * @dev Returns the decimals places of the token.
     */
    function decimals() external view returns (uint8);
}

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


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

pragma solidity ^0.8.0;

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

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

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

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

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

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


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

pragma solidity ^0.8.0;

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

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

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


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

pragma solidity ^0.8.0;




/**
 * @dev Implementation of the {IERC20} interface.
 *
 * This implementation is agnostic to the way tokens are created. This means
 * that a supply mechanism has to be added in a derived contract using {_mint}.
 * For a generic mechanism see {ERC20PresetMinterPauser}.
 *
 * TIP: For a detailed writeup see our guide
 * https://forum.zeppelin.solutions/t/how-to-implement-erc20-supply-mechanisms/226[How
 * to implement supply mechanisms].
 *
 * We have followed general OpenZeppelin Contracts guidelines: functions revert
 * instead returning `false` on failure. This behavior is nonetheless
 * conventional and does not conflict with the expectations of ERC20
 * applications.
 *
 * Additionally, an {Approval} event is emitted on calls to {transferFrom}.
 * This allows applications to reconstruct the allowance for all accounts just
 * by listening to said events. Other implementations of the EIP may not emit
 * these events, as it isn't required by the specification.
 *
 * Finally, the non-standard {decreaseAllowance} and {increaseAllowance}
 * functions have been added to mitigate the well-known issues around setting
 * allowances. See {IERC20-approve}.
 */
contract ERC20 is Context, IERC20, IERC20Metadata {
    mapping(address => uint256) private _balances;

    mapping(address => mapping(address => uint256)) private _allowances;

    uint256 private _totalSupply;

    string private _name;
    string private _symbol;

    /**
     * @dev Sets the values for {name} and {symbol}.
     *
     * The default value of {decimals} is 18. To select a different value for
     * {decimals} you should overload it.
     *
     * All two of these values are immutable: they can only be set once during
     * construction.
     */
    constructor(string memory name_, string memory symbol_) {
        _name = name_;
        _symbol = symbol_;
    }

    /**
     * @dev Returns the name of the token.
     */
    function name() public view virtual override returns (string memory) {
        return _name;
    }

    /**
     * @dev Returns the symbol of the token, usually a shorter version of the
     * name.
     */
    function symbol() public view virtual override returns (string memory) {
        return _symbol;
    }

    /**
     * @dev Returns the number of decimals used to get its user representation.
     * For example, if `decimals` equals `2`, a balance of `505` tokens should
     * be displayed to a user as `5.05` (`505 / 10 ** 2`).
     *
     * Tokens usually opt for a value of 18, imitating the relationship between
     * Ether and Wei. This is the value {ERC20} uses, unless this function is
     * overridden;
     *
     * NOTE: This information is only used for _display_ purposes: it in
     * no way affects any of the arithmetic of the contract, including
     * {IERC20-balanceOf} and {IERC20-transfer}.
     */
    function decimals() public view virtual override returns (uint8) {
        return 18;
    }

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

    /**
     * @dev See {IERC20-balanceOf}.
     */
    function balanceOf(address account) public view virtual override returns (uint256) {
        return _balances[account];
    }

    /**
     * @dev See {IERC20-transfer}.
     *
     * Requirements:
     *
     * - `to` cannot be the zero address.
     * - the caller must have a balance of at least `amount`.
     */
    function transfer(address to, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _transfer(owner, to, amount);
        return true;
    }

    /**
     * @dev See {IERC20-allowance}.
     */
    function allowance(address owner, address spender) public view virtual override returns (uint256) {
        return _allowances[owner][spender];
    }

    /**
     * @dev See {IERC20-approve}.
     *
     * NOTE: If `amount` is the maximum `uint256`, the allowance is not updated on
     * `transferFrom`. This is semantically equivalent to an infinite approval.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function approve(address spender, uint256 amount) public virtual override returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, amount);
        return true;
    }

    /**
     * @dev See {IERC20-transferFrom}.
     *
     * Emits an {Approval} event indicating the updated allowance. This is not
     * required by the EIP. See the note at the beginning of {ERC20}.
     *
     * NOTE: Does not update the allowance if the current allowance
     * is the maximum `uint256`.
     *
     * Requirements:
     *
     * - `from` and `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     * - the caller must have allowance for ``from``'s tokens of at least
     * `amount`.
     */
    function transferFrom(
        address from,
        address to,
        uint256 amount
    ) public virtual override returns (bool) {
        address spender = _msgSender();
        _spendAllowance(from, spender, amount);
        _transfer(from, to, amount);
        return true;
    }

    /**
     * @dev Atomically increases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     */
    function increaseAllowance(address spender, uint256 addedValue) public virtual returns (bool) {
        address owner = _msgSender();
        _approve(owner, spender, allowance(owner, spender) + addedValue);
        return true;
    }

    /**
     * @dev Atomically decreases the allowance granted to `spender` by the caller.
     *
     * This is an alternative to {approve} that can be used as a mitigation for
     * problems described in {IERC20-approve}.
     *
     * Emits an {Approval} event indicating the updated allowance.
     *
     * Requirements:
     *
     * - `spender` cannot be the zero address.
     * - `spender` must have allowance for the caller of at least
     * `subtractedValue`.
     */
    function decreaseAllowance(address spender, uint256 subtractedValue) public virtual returns (bool) {
        address owner = _msgSender();
        uint256 currentAllowance = allowance(owner, spender);
        require(currentAllowance >= subtractedValue, "ERC20: decreased allowance below zero");
        unchecked {
            _approve(owner, spender, currentAllowance - subtractedValue);
        }

        return true;
    }

    /**
     * @dev Moves `amount` of tokens from `sender` to `recipient`.
     *
     * This internal function is equivalent to {transfer}, and can be used to
     * e.g. implement automatic token fees, slashing mechanisms, etc.
     *
     * Emits a {Transfer} event.
     *
     * Requirements:
     *
     * - `from` cannot be the zero address.
     * - `to` cannot be the zero address.
     * - `from` must have a balance of at least `amount`.
     */
    function _transfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {
        require(from != address(0), "ERC20: transfer from the zero address");
        require(to != address(0), "ERC20: transfer to the zero address");

        _beforeTokenTransfer(from, to, amount);

        uint256 fromBalance = _balances[from];
        require(fromBalance >= amount, "ERC20: transfer amount exceeds balance");
        unchecked {
            _balances[from] = fromBalance - amount;
        }
        _balances[to] += amount;

        emit Transfer(from, to, amount);

        _afterTokenTransfer(from, to, amount);
    }

    /** @dev Creates `amount` tokens and assigns them to `account`, increasing
     * the total supply.
     *
     * Emits a {Transfer} event with `from` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     */
    function _mint(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: mint to the zero address");

        _beforeTokenTransfer(address(0), account, amount);

        _totalSupply += amount;
        _balances[account] += amount;
        emit Transfer(address(0), account, amount);

        _afterTokenTransfer(address(0), account, amount);
    }

    /**
     * @dev Destroys `amount` tokens from `account`, reducing the
     * total supply.
     *
     * Emits a {Transfer} event with `to` set to the zero address.
     *
     * Requirements:
     *
     * - `account` cannot be the zero address.
     * - `account` must have at least `amount` tokens.
     */
    function _burn(address account, uint256 amount) internal virtual {
        require(account != address(0), "ERC20: burn from the zero address");

        _beforeTokenTransfer(account, address(0), amount);

        uint256 accountBalance = _balances[account];
        require(accountBalance >= amount, "ERC20: burn amount exceeds balance");
        unchecked {
            _balances[account] = accountBalance - amount;
        }
        _totalSupply -= amount;

        emit Transfer(account, address(0), amount);

        _afterTokenTransfer(account, address(0), amount);
    }

    /**
     * @dev Sets `amount` as the allowance of `spender` over the `owner` s tokens.
     *
     * This internal function is equivalent to `approve`, and can be used to
     * e.g. set automatic allowances for certain subsystems, etc.
     *
     * Emits an {Approval} event.
     *
     * Requirements:
     *
     * - `owner` cannot be the zero address.
     * - `spender` cannot be the zero address.
     */
    function _approve(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        require(owner != address(0), "ERC20: approve from the zero address");
        require(spender != address(0), "ERC20: approve to the zero address");

        _allowances[owner][spender] = amount;
        emit Approval(owner, spender, amount);
    }

    /**
     * @dev Updates `owner` s allowance for `spender` based on spent `amount`.
     *
     * Does not update the allowance amount in case of infinite allowance.
     * Revert if not enough allowance is available.
     *
     * Might emit an {Approval} event.
     */
    function _spendAllowance(
        address owner,
        address spender,
        uint256 amount
    ) internal virtual {
        uint256 currentAllowance = allowance(owner, spender);
        if (currentAllowance != type(uint256).max) {
            require(currentAllowance >= amount, "ERC20: insufficient allowance");
            unchecked {
                _approve(owner, spender, currentAllowance - amount);
            }
        }
    }

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

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero, `amount` of ``from``'s tokens
     * has been transferred to `to`.
     * - when `from` is zero, `amount` tokens have been minted for `to`.
     * - when `to` is zero, `amount` of ``from``'s tokens have been burned.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 amount
    ) internal virtual {}
}

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


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.1;

/**
 * @dev Collection of functions related to the address type
 */
library Address {
    /**
     * @dev Returns true if `account` is a contract.
     *
     * [IMPORTANT]
     * ====
     * It is unsafe to assume that an address for which this function returns
     * false is an externally-owned account (EOA) and not a contract.
     *
     * Among others, `isContract` will return false for the following
     * types of addresses:
     *
     *  - an externally-owned account
     *  - a contract in construction
     *  - an address where a contract will be created
     *  - an address where a contract lived, but was destroyed
     * ====
     *
     * [IMPORTANT]
     * ====
     * You shouldn't rely on `isContract` to protect against flash loan attacks!
     *
     * Preventing calls from contracts is highly discouraged. It breaks composability, breaks support for smart wallets
     * like Gnosis Safe, and does not provide security since it can be circumvented by calling from a contract
     * constructor.
     * ====
     */
    function isContract(address account) internal view returns (bool) {
        // This method relies on extcodesize/address.code.length, which returns 0
        // for contracts in construction, since the code is only stored at the end
        // of the constructor execution.

        return account.code.length > 0;
    }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.0;

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

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


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

pragma solidity ^0.8.0;

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

// File: @manifoldxyz/libraries-solidity/contracts/access/IAdminControl.sol



pragma solidity ^0.8.0;

/// @author: manifold.xyz


/**
 * @dev Interface for admin control
 */
interface IAdminControl is IERC165 {

    event AdminApproved(address indexed account, address indexed sender);
    event AdminRevoked(address indexed account, address indexed sender);

    /**
     * @dev gets address of all admins
     */
    function getAdmins() external view returns (address[] memory);

    /**
     * @dev add an admin.  Can only be called by contract owner.
     */
    function approveAdmin(address admin) external;

    /**
     * @dev remove an admin.  Can only be called by contract owner.
     */
    function revokeAdmin(address admin) external;

    /**
     * @dev checks whether or not given address is an admin
     * Returns True if they are
     */
    function isAdmin(address admin) external view returns (bool);

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


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

pragma solidity ^0.8.0;


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

// File: @manifoldxyz/libraries-solidity/contracts/access/AdminControl.sol



pragma solidity ^0.8.0;

// @author: manifold.xyz





abstract contract AdminControl is Ownable, IAdminControl, ERC165 {
    using EnumerableSet for EnumerableSet.AddressSet;

    // Track registered admins
    EnumerableSet.AddressSet private _admins;

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

    /**
     * @dev Only allows approved admins to call the specified function
     */
    modifier adminRequired() {
        require(owner() == msg.sender || _admins.contains(msg.sender), "AdminControl: Must be owner or admin");
        _;
    }   

    /**
     * @dev See {IAdminControl-getAdmins}.
     */
    function getAdmins() external view override returns (address[] memory admins) {
        admins = new address[](_admins.length());
        for (uint i = 0; i < _admins.length(); i++) {
            admins[i] = _admins.at(i);
        }
        return admins;
    }

    /**
     * @dev See {IAdminControl-approveAdmin}.
     */
    function approveAdmin(address admin) external override onlyOwner {
        if (!_admins.contains(admin)) {
            emit AdminApproved(admin, msg.sender);
            _admins.add(admin);
        }
    }

    /**
     * @dev See {IAdminControl-revokeAdmin}.
     */
    function revokeAdmin(address admin) external override onlyOwner {
        if (_admins.contains(admin)) {
            emit AdminRevoked(admin, msg.sender);
            _admins.remove(admin);
        }
    }

    /**
     * @dev See {IAdminControl-isAdmin}.
     */
    function isAdmin(address admin) public override view returns (bool) {
        return (owner() == admin || _admins.contains(admin));
    }

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


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.0;


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

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

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

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


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

pragma solidity ^0.8.0;








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

    // Token name
    string private _name;

    // Token symbol
    string private _symbol;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        _approve(to, tokenId);
    }

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

        return _tokenApprovals[tokenId];
    }

    /**
     * @dev See {IERC721-setApprovalForAll}.
     */
    function setApprovalForAll(address operator, bool approved) public virtual override {
        _setApprovalForAll(_msgSender(), operator, approved);
    }

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

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

        _transfer(from, to, tokenId);
    }

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

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

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

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

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

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

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

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

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

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

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

        _afterTokenTransfer(address(0), to, tokenId);
    }

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

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

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

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

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

        _afterTokenTransfer(owner, address(0), tokenId);
    }

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

        _beforeTokenTransfer(from, to, tokenId);

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

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

        emit Transfer(from, to, tokenId);

        _afterTokenTransfer(from, to, tokenId);
    }

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

    /**
     * @dev Approve `operator` to operate on all of `owner` tokens
     *
     * Emits a {ApprovalForAll} event.
     */
    function _setApprovalForAll(
        address owner,
        address operator,
        bool approved
    ) internal virtual {
        require(owner != operator, "ERC721: approve to caller");
        _operatorApprovals[owner][operator] = approved;
        emit ApprovalForAll(owner, operator, approved);
    }

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

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

    /**
     * @dev Hook that is called after any transfer of tokens. This includes
     * minting and burning.
     *
     * Calling conditions:
     *
     * - when `from` and `to` are both non-zero.
     * - `from` and `to` are never both zero.
     *
     * To learn more about hooks, head to xref:ROOT:extending-contracts.adoc#using-hooks[Using Hooks].
     */
    function _afterTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal virtual {}
}

// File: contracts/ShootingStar.sol



pragma solidity >= 0.8.13;





contract ShootingStar is ERC721, AdminControl {

    mapping (uint256 => string ) public _uris;
    mapping (uint256 => address ) public _holders;
    address payable private _royalties_recipient;
    uint256 private _royaltyAmount; //in % 
    constructor () ERC721("ShootingStar", "ShS") {
        _royalties_recipient = payable(msg.sender);
        _royaltyAmount = 10;
    }

    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override(ERC721, AdminControl)
        returns (bool)
    {
        return
        AdminControl.supportsInterface(interfaceId) ||
        ERC721.supportsInterface(interfaceId) ||
        interfaceId == type(IEIP2981).interfaceId ||
        super.supportsInterface(interfaceId);
    }

    function transferNFT(uint256 tokenId, address holder) public adminRequired{
        _holders[tokenId] = holder;
    }

    function getHolder(uint256 tokenId)view external returns(address){
        return _holders[tokenId];
    }

    function mint(address to, uint256 tokenId, address holder) external adminRequired{
        _safeMint(to, tokenId, "");
        transferNFT(tokenId, holder);
    }

    function setURI(
        uint256 tokenId,
        string calldata updatedURI
    ) external adminRequired{
        _uris[tokenId] = updatedURI;
    }

    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        return _uris[tokenId];
    }

    function ownerOf(uint256 tokenId) public view virtual override returns (address) {
        require(_holders[tokenId] != address(0), "ERC721: invalid token ID");
        return _holders[tokenId];
    }

    function burn(uint256 tokenId) public {
        _burn(tokenId);
    }

    function setRoyalties(address payable _recipient, uint256 _royaltyPerCent) external adminRequired {
        _royalties_recipient = _recipient;
        _royaltyAmount = _royaltyPerCent;
    }

    function royaltyInfo(uint256 salePrice) external view returns (address, uint256) {
        if(_royalties_recipient != address(0)){
            return (_royalties_recipient, (salePrice * _royaltyAmount) / 100 );
        }
        return (address(0), 0);
    }

    function withdraw(address recipient) external adminRequired {
        payable(recipient).transfer(address(this).balance);
    }

}
// File: contracts/BH.sol


pragma solidity >= 0.8.13;




contract BH is ERC20, AdminControl{

  uint256 public _universalGravitationalConstant = 6674;
  uint256 public _totalNFTSupply;
  uint256  public _shootingStarId;

  uint256[] public _contractVolumes;
  address[] public _contractAdresses;

  address public  _liveContract;
  address public _shootingStar;
  address public _shootingStarAddress;

  bool _shootingStarActivated;

  mapping(address => uint256) _contractIds;
  mapping(address => bool) _contractMinted;
  mapping (address => uint256) _transactionNumber;

  constructor () ERC20("Blackhole", "BH"){
    // Set values in index 0 of the arrays to not have a a contract with id 0
    // Prevents any issues with default values in _contractIds mapping
    _contractAdresses.push(address(0));
    _contractVolumes.push(0);
    _totalNFTSupply = 0;
  }

  function getMintQuantity(uint256 dropVolume)internal view returns(uint256 _mintQuantity){
    uint256 mintQuantity =  _universalGravitationalConstant * dropVolume/(_totalNFTSupply) * 10 ** 18;
    return mintQuantity;
  }

  function registerDrop (address contractAddress, uint256 contractVolume) external adminRequired{
    _contractAdresses.push(contractAddress);
    _contractVolumes.push(contractVolume);
    _contractIds[contractAddress] = _contractAdresses.length - 1;
    _totalNFTSupply = _totalNFTSupply + contractVolume;
  }

  function editDrop (uint256 contractId, address contractAddress, uint256 contractVolume) external adminRequired{
    require(contractId > 0, "Contract not registered");
    require(_contractAdresses[contractId]  != address(0),  "Contract not  registered");
    require(_contractMinted[_contractAdresses[contractId]]==false, "Cannot edit a contract that was already mined");
    uint256 oldDropVolume  =  _contractVolumes[contractId];
    _contractAdresses[contractId] = contractAddress;
    _contractVolumes.push(contractVolume);
    _totalNFTSupply = _totalNFTSupply - oldDropVolume + contractVolume;
  }

  function setLiveContract(address contractAddress) external adminRequired{
    require(_contractIds[contractAddress]>0,"Contract not registered");
    _liveContract = contractAddress;
  }

  function  getContractId(address contractAddress)external view returns(uint256 id){
    return _contractIds[contractAddress]; 
  }
  
  function mint(address recipient, uint256 amountOfNFTsMinted) external returns(uint256 amountMinted){
    require(msg.sender == _liveContract, "Contract not allowed to mint");
    uint256 contractId = _contractIds[_liveContract];
    uint256 amount =  getMintQuantity(_contractVolumes[contractId]);
    uint256 quantity =  amount * amountOfNFTsMinted;
    _mint(recipient, quantity);
    return quantity;
  }

  function airdrop(address[] calldata recipients, uint256[] calldata amountOfNFTsMinted)external adminRequired{
    require(recipients.length == amountOfNFTsMinted.length, "Invalid data");
    uint256 contractId = _contractIds[_liveContract];
    uint256 amount =  getMintQuantity(_contractVolumes[contractId]);
    for(uint256 i = 0; i < recipients.length; i++){
      _mint(recipients[i],  amount * amountOfNFTsMinted[i]);
    }
  }

  function burn(uint256 amount)external{
    _burn(msg.sender, amount);
  }

  function setShootingStarAddress(address ShootingStarAddress) external adminRequired{
      _shootingStarAddress = ShootingStarAddress;
  }

  function activateShootingStar(uint256 shootingStarId) external adminRequired{
      _shootingStarId = shootingStarId;
      _shootingStarActivated = true;
  }

  function _afterTokenTransfer(
    address from,
    address to,
    uint256 amount
  ) internal override {
    address originalStar = _shootingStar;
    // Track the number of the transactions
    // Mints and burn are not transactions
    if(from != address(0) && from != _liveContract) { 
      _transactionNumber[from] += 1;
      if(_shootingStar == address(0)){
        _shootingStar = from;
      }else{
        // With the same number of transactions, the initiator of the transaction will have priority
        if(_transactionNumber[from] > _transactionNumber[_shootingStar]){
          _shootingStar = from;
        }
      }
    }
    if(to != address(0) && to != _liveContract){
      _transactionNumber[to] += 1;
      if(_transactionNumber[to] > _transactionNumber[_shootingStar]){
        _shootingStar = from;
      }
    }
    if(_shootingStarActivated && _shootingStar != originalStar){
      ShootingStar(_shootingStarAddress).transferNFT(_shootingStarId, _shootingStar);
    }
  }
  
}
// File: contracts/blackhole.sol



pragma solidity >= 0.8.13;






contract blackhole is ERC721, AdminControl {
    
    uint256 public _ethPrice = 0.1*10**18; //0.1 ETH
    uint256 private _royaltyAmount; //in % 
    uint256 private _stage1BalanceRequirement = 1 * 10 ** 18;
    uint256 private _stage2BalanceRequirement = 10000 * 10 ** 18;
    uint256 private _stage3BalanceRequirement = 20000 * 10 ** 18;
    uint256 private _nextTokenId = 1;

    mapping (uint256 => uint256) _tokenForms;

    string[] _uris;

    mapping (uint256 => uint256) public _BHBalances;

    mapping (uint256 => uint256) public _stage3TokenIds; // mapping form to tokenId

    bool public _mintOpened;
    bool public  _shootingStarMinted;

    address public _BHAddress;
    address payable  private _royalties_recipient;
    address private _signer;

    event Stag3Activated  (uint256 tokenId);
    
    constructor () ERC721("blackhole","bh") {
        _royalties_recipient = payable(msg.sender);
        _royaltyAmount = 10;

    } 

    function supportsInterface(bytes4 interfaceId)
        public
        view
        virtual
        override(ERC721, AdminControl)
        returns (bool)
    {
        return
        AdminControl.supportsInterface(interfaceId) ||
        ERC721.supportsInterface(interfaceId) ||
        interfaceId == type(IEIP2981).interfaceId ||
        super.supportsInterface(interfaceId);
    }

    function mintAllowed(uint8 v, bytes32 r, bytes32 s)internal view returns(bool){
        return(
            _signer ==
                ecrecover(
                    keccak256(
                        abi.encodePacked(
                            "\x19Ethereum Signed Message:\n32",
                            keccak256(
                                abi.encodePacked(
                                    msg.sender,
                                    address(this),
                                    _mintOpened
                                )
                            )
                        )
                    )
                , v, r, s)
        );
    }

    function setBHAddress(address BHAddress) external adminRequired{
        _BHAddress = BHAddress;
    }

    function setSigner (address signer) external adminRequired{
        _signer = signer;
    }

    function publicMint(
        uint256 tokenForm,
        uint8 v,
        bytes32 r, 
        bytes32 s
    ) external payable{
        require(mintAllowed( v, r, s), "Mint not allowed");
        require(msg.value >= _ethPrice, "Insufficent funds sent");
        require(tokenForm >= 1 && tokenForm <= 3, "Invalid token form");
        payable(_royalties_recipient).transfer(_ethPrice);
        _mint(msg.sender , _nextTokenId);
        _tokenForms[_nextTokenId] = tokenForm;
        _BHBalances[_nextTokenId] = BH(_BHAddress).mint(address(this), 1);
        _nextTokenId += 1;
    }

    function adminMint(
        uint256 tokenForm,
        address account
    ) external adminRequired{
        _mint(account ,_nextTokenId);
        _tokenForms[_nextTokenId] = tokenForm;
        _BHBalances[_nextTokenId] = BH(_BHAddress).mint(account, 1);
        _nextTokenId += 1;
    }


    function getBHBalance(uint256 tokenId) view public returns(uint256 blalance){
        return(_BHBalances[tokenId]);
    }

    function toggleMintState()external adminRequired{
        _mintOpened = !_mintOpened;
    }

    function updateURIs(string [] calldata uris) public adminRequired{
        delete _uris;
        for(uint256 i=0; i < uris.length; i++){
            _uris.push(uris[i]);
        }
    }

    function tokenURI(uint256 tokenId) public view override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
        uint256 tokenStage;
        tokenStage = _BHBalances[tokenId] < _stage1BalanceRequirement ? 0 : _BHBalances[tokenId] < _stage2BalanceRequirement ? 3 : _BHBalances[tokenId] < _stage3BalanceRequirement ? 6 : 9;
        return(_uris[ _tokenForms[tokenId] + tokenStage - 1]);
    }

    function burn(uint256 tokenId) public {
        require(ownerOf(tokenId)== msg.sender, "You can only burn your own tokens");
        _burn(tokenId);
    }

    function setRoyalties(address payable _recipient, uint256 _royaltyPerCent) external adminRequired {
        _royalties_recipient = _recipient;
        _royaltyAmount = _royaltyPerCent;
    }

    function royaltyInfo(uint256 salePrice) external view returns (address, uint256) {
        if(_royalties_recipient != address(0)){
            return (_royalties_recipient, (salePrice * _royaltyAmount) / 100 );
        }
        return (address(0), 0);
    }

    function depositBH(uint256 tokenId, uint256 quantity) external{
        require(quantity > 0, "Invalid quantity of BH to deposit");
        require(ownerOf(tokenId)==msg.sender,"You can only deposit BH to a token you own");
        uint256 tokenBalance = getBHBalance(tokenId);
        if(tokenBalance + quantity >= _stage3BalanceRequirement){
            require(_stage3TokenIds[_tokenForms[tokenId]] == 0, "There is already a stage 3 token for that form");
            _stage3TokenIds[_tokenForms[tokenId]] = tokenId;
            emit Stag3Activated(tokenId);
        }
        BH(_BHAddress).transferFrom(msg.sender, address(this), quantity);
        _BHBalances[tokenId] += quantity;
    }
    
    function withdrawBH(uint256 tokenId,uint256 quantity) external{
        require(quantity > 0, "Invalid quantity of BH to withdraw");
        require(ownerOf(tokenId)==msg.sender,"You can only withdraw BH from the token you own");
        require(_BHBalances[tokenId] >= quantity, "Not enough BH to withdraw");
        uint256 tokenBalance = getBHBalance(tokenId);
        if( _stage3TokenIds[_tokenForms[tokenId]] == tokenId && (tokenBalance - quantity) < _stage3BalanceRequirement){
            _stage3TokenIds[_tokenForms[tokenId]] = 0;
        }
        BH(_BHAddress).transfer(msg.sender, quantity);
        _BHBalances[tokenId] -= quantity;
    }

    function withdraw(address recipient) external adminRequired {
        payable(recipient).transfer(address(this).balance);
    }

}

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":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"AdminApproved","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"account","type":"address"},{"indexed":true,"internalType":"address","name":"sender","type":"address"}],"name":"AdminRevoked","type":"event"},{"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":false,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Stag3Activated","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[],"name":"_BHAddress","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"_BHBalances","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_ethPrice","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_mintOpened","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_shootingStarMinted","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"_stage3TokenIds","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenForm","type":"uint256"},{"internalType":"address","name":"account","type":"address"}],"name":"adminMint","outputs":[],"stateMutability":"nonpayable","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":"admin","type":"address"}],"name":"approveAdmin","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":"uint256","name":"tokenId","type":"uint256"}],"name":"burn","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"depositBH","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"getAdmins","outputs":[{"internalType":"address[]","name":"admins","type":"address[]"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getBHBalance","outputs":[{"internalType":"uint256","name":"blalance","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"admin","type":"address"}],"name":"isAdmin","outputs":[{"internalType":"bool","name":"","type":"bool"}],"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":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenForm","type":"uint256"},{"internalType":"uint8","name":"v","type":"uint8"},{"internalType":"bytes32","name":"r","type":"bytes32"},{"internalType":"bytes32","name":"s","type":"bytes32"}],"name":"publicMint","outputs":[],"stateMutability":"payable","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"admin","type":"address"}],"name":"revokeAdmin","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"salePrice","type":"uint256"}],"name":"royaltyInfo","outputs":[{"internalType":"address","name":"","type":"address"},{"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":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"BHAddress","type":"address"}],"name":"setBHAddress","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address payable","name":"_recipient","type":"address"},{"internalType":"uint256","name":"_royaltyPerCent","type":"uint256"}],"name":"setRoyalties","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"signer","type":"address"}],"name":"setSigner","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":[],"name":"toggleMintState","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string[]","name":"uris","type":"string[]"}],"name":"updateURIs","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"withdraw","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"uint256","name":"quantity","type":"uint256"}],"name":"withdrawBH","outputs":[],"stateMutability":"nonpayable","type":"function"}]

Contract Creation Code

Decompile Bytecode Switch to Opcodes View

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

Deployed Bytecode

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

Deployed Bytecode Sourcemap

77048:6265:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;78037:394;;;;;;;;;;-1:-1:-1;78037:394:0;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;78037:394:0;;;;;;;;57607:100;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;77104:37::-;;;;;;;;;;;;;;;;;;;1440:25:1;;;1428:2;1413:18;77104:37:0;1294:177:1;59166:221:0;;;;;;;;;;-1:-1:-1;59166:221:0;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1825:32:1;;;1807:51;;1795:2;1780:18;59166:221:0;1661:203:1;58689:411:0;;;;;;;;;;-1:-1:-1;58689:411:0;;;;;:::i;:::-;;:::i;:::-;;79956:295;;;;;;;;;;-1:-1:-1;79956:295:0;;;;;:::i;:::-;;:::i;77656:23::-;;;;;;;;;;-1:-1:-1;77656:23:0;;;;;;;;59916:339;;;;;;;;;;-1:-1:-1;59916:339:0;;;;;:::i;:::-;;:::i;49434:139::-;;;;;;;;;;-1:-1:-1;49434:139:0;;;;;:::i;:::-;;:::i;49156:210::-;;;;;;;;;;-1:-1:-1;49156:210:0;;;;;:::i;:::-;;:::i;48534:267::-;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;60326:185::-;;;;;;;;;;-1:-1:-1;60326:185:0;;;;;:::i;:::-;;:::i;81157:157::-;;;;;;;;;;-1:-1:-1;81157:157:0;;;;;:::i;:::-;;:::i;80392:93::-;;;;;;;;;;;;;:::i;83179:129::-;;;;;;;;;;-1:-1:-1;83179:129:0;;;;;:::i;:::-;;:::i;79352:596::-;;;;;;:::i;:::-;;:::i;81794:704::-;;;;;;;;;;-1:-1:-1;81794:704:0;;;;;:::i;:::-;;:::i;57301:239::-;;;;;;;;;;-1:-1:-1;57301:239:0;;;;;:::i;:::-;;:::i;79251:93::-;;;;;;;;;;-1:-1:-1;79251:93:0;;;;;:::i;:::-;;:::i;48874:210::-;;;;;;;;;;-1:-1:-1;48874:210:0;;;;;:::i;:::-;;:::i;57031:208::-;;;;;;;;;;-1:-1:-1;57031:208:0;;;;;:::i;:::-;;:::i;34287:103::-;;;;;;;;;;;;;:::i;77513:47::-;;;;;;;;;;-1:-1:-1;77513:47:0;;;;;:::i;:::-;;;;;;;;;;;;;;77569:51;;;;;;;;;;-1:-1:-1;77569:51:0;;;;;:::i;:::-;;;;;;;;;;;;;;81322:193;;;;;;;;;;-1:-1:-1;81322:193:0;;;;;:::i;:::-;;:::i;33636:87::-;;;;;;;;;;-1:-1:-1;33682:7:0;33709:6;-1:-1:-1;;;;;33709:6:0;33636:87;;57776:104;;;;;;;;;;;;;:::i;59459:155::-;;;;;;;;;;-1:-1:-1;59459:155:0;;;;;:::i;:::-;;:::i;80261:123::-;;;;;;;;;;-1:-1:-1;80261:123:0;;;;;:::i;:::-;80320:16;80355:20;;;:11;:20;;;;;;;80261:123;82510:661;;;;;;;;;;-1:-1:-1;82510:661:0;;;;;:::i;:::-;;:::i;77686:32::-;;;;;;;;;;-1:-1:-1;77686:32:0;;;;;;;;;;;80493:190;;;;;;;;;;-1:-1:-1;80493:190:0;;;;;:::i;:::-;;:::i;60582:328::-;;;;;;;;;;-1:-1:-1;60582:328:0;;;;;:::i;:::-;;:::i;77727:25::-;;;;;;;;;;-1:-1:-1;77727:25:0;;;;;;;-1:-1:-1;;;;;77727:25:0;;;80691:458;;;;;;;;;;-1:-1:-1;80691:458:0;;;;;:::i;:::-;;:::i;81523:263::-;;;;;;;;;;-1:-1:-1;81523:263:0;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;7818:32:1;;;7800:51;;7882:2;7867:18;;7860:34;;;;7773:18;81523:263:0;7626:274:1;79139:104:0;;;;;;;;;;-1:-1:-1;79139:104:0;;;;;:::i;:::-;;:::i;59685:164::-;;;;;;;;;;-1:-1:-1;59685:164:0;;;;;:::i;:::-;;:::i;34545:201::-;;;;;;;;;;-1:-1:-1;34545:201:0;;;;;:::i;:::-;;:::i;78037:394::-;78189:4;78227:43;78258:11;78227:30;:43::i;:::-;:93;;;;78283:37;78308:11;78283:24;:37::i;:::-;78227:147;;;-1:-1:-1;;;;;;;78333:41:0;;-1:-1:-1;;;78333:41:0;78227:147;:196;;;;78387:36;78411:11;78387:23;:36::i;:::-;78211:212;78037:394;-1:-1:-1;;78037:394:0:o;57607:100::-;57661:13;57694:5;57687:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;57607:100;:::o;59166:221::-;59242:7;62509:16;;;:7;:16;;;;;;-1:-1:-1;;;;;62509:16:0;59262:73;;;;-1:-1:-1;;;59262:73:0;;8885:2:1;59262:73:0;;;8867:21:1;8924:2;8904:18;;;8897:30;8963:34;8943:18;;;8936:62;-1:-1:-1;;;9014:18:1;;;9007:42;9066:19;;59262:73:0;;;;;;;;;-1:-1:-1;59355:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;59355:24:0;;59166:221::o;58689:411::-;58770:13;58786:23;58801:7;58786:14;:23::i;:::-;58770:39;;58834:5;-1:-1:-1;;;;;58828:11:0;:2;-1:-1:-1;;;;;58828:11:0;;58820:57;;;;-1:-1:-1;;;58820:57:0;;9298:2:1;58820:57:0;;;9280:21:1;9337:2;9317:18;;;9310:30;9376:34;9356:18;;;9349:62;-1:-1:-1;;;9427:18:1;;;9420:31;9468:19;;58820:57:0;9096:397:1;58820:57:0;19499:10;-1:-1:-1;;;;;58912:21:0;;;;:62;;-1:-1:-1;58937:37:0;58954:5;19499:10;59685:164;:::i;58937:37::-;58890:168;;;;-1:-1:-1;;;58890:168:0;;9700:2:1;58890:168:0;;;9682:21:1;9739:2;9719:18;;;9712:30;9778:34;9758:18;;;9751:62;9849:26;9829:18;;;9822:54;9893:19;;58890:168:0;9498:420:1;58890:168:0;59071:21;59080:2;59084:7;59071:8;:21::i;:::-;58759:341;58689:411;;:::o;79956:295::-;48358:10;48347:7;33682;33709:6;-1:-1:-1;;;;;33709:6:0;;33636:87;48347:7;-1:-1:-1;;;;;48347:21:0;;:53;;;-1:-1:-1;48372:28:0;:7;48389:10;48372:16;:28::i;:::-;48339:102;;;;-1:-1:-1;;;48339:102:0;;;;;;;:::i;:::-;80069:28:::1;80075:7;80084:12;;80069:5;:28::i;:::-;80120:12;::::0;80108:25:::1;::::0;;;:11:::1;:25;::::0;;;;;;:37;;;80187:10:::1;::::0;80184:31;;-1:-1:-1;;;80184:31:0;;-1:-1:-1;;;;;7818:32:1;;;80184:31:0::1;::::0;::::1;7800:51:1::0;80213:1:0::1;7867:18:1::0;;;7860:34;80187:10:0;;;::::1;::::0;;::::1;::::0;80184:19:::1;::::0;7773:18:1;;80184:31:0::1;;;;;;;;;;;;;;;;;;::::0;::::1;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;80168:12;::::0;;80156:25:::1;::::0;;;:11:::1;:25;::::0;;;;:59;;;;80226:17;;80242:1:::1;::::0;80156:25;80226:17:::1;::::0;80242:1;;80226:17:::1;:::i;:::-;::::0;;;-1:-1:-1;;;;79956:295:0:o;59916:339::-;60111:41;19499:10;60144:7;60111:18;:41::i;:::-;60103:103;;;;-1:-1:-1;;;60103:103:0;;;;;;;:::i;:::-;60219:28;60229:4;60235:2;60239:7;60219:9;:28::i;49434:139::-;49496:4;49532:5;-1:-1:-1;;;;;49521:16:0;:7;33682;33709:6;-1:-1:-1;;;;;33709:6:0;;33636:87;49521:7;-1:-1:-1;;;;;49521:16:0;;:43;;;-1:-1:-1;49541:23:0;:7;49558:5;49541:16;:23::i;49156:210::-;33682:7;33709:6;-1:-1:-1;;;;;33709:6:0;19499:10;33856:23;33848:68;;;;-1:-1:-1;;;33848:68:0;;;;;;;:::i;:::-;49235:23:::1;:7;49252:5:::0;49235:16:::1;:23::i;:::-;49231:128;;;49280:31;::::0;49300:10:::1;::::0;-1:-1:-1;;;;;49280:31:0;::::1;::::0;::::1;::::0;;;::::1;49326:21;:7;49341:5:::0;49326:14:::1;:21::i;:::-;;49231:128;49156:210:::0;:::o;48534:267::-;48587:23;48646:16;:7;:14;:16::i;:::-;48632:31;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;48632:31:0;;48623:40;;48679:6;48674:96;48695:16;:7;:14;:16::i;:::-;48691:1;:20;48674:96;;;48745:13;:7;48756:1;48745:10;:13::i;:::-;48733:6;48740:1;48733:9;;;;;;;;:::i;:::-;-1:-1:-1;;;;;48733:25:0;;;:9;;;;;;;;;;;:25;48713:3;;;;:::i;:::-;;;;48674:96;;;;48534:267;:::o;60326:185::-;60464:39;60481:4;60487:2;60491:7;60464:39;;;;;;;;;;;;:16;:39::i;81157:157::-;81233:10;81214:16;81222:7;81214;:16::i;:::-;-1:-1:-1;;;;;81214:29:0;;81206:75;;;;-1:-1:-1;;;81206:75:0;;12322:2:1;81206:75:0;;;12304:21:1;12361:2;12341:18;;;12334:30;12400:34;12380:18;;;12373:62;-1:-1:-1;;;12451:18:1;;;12444:31;12492:19;;81206:75:0;12120:397:1;81206:75:0;81292:14;81298:7;81292:5;:14::i;80392:93::-;48358:10;48347:7;33682;33709:6;-1:-1:-1;;;;;33709:6:0;;33636:87;48347:7;-1:-1:-1;;;;;48347:21:0;;:53;;;-1:-1:-1;48372:28:0;:7;48389:10;48372:16;:28::i;:::-;48339:102;;;;-1:-1:-1;;;48339:102:0;;;;;;;:::i;:::-;80466:11:::1;::::0;;-1:-1:-1;;80451:26:0;::::1;80466:11;::::0;;::::1;80465:12;80451:26;::::0;;80392:93::o;83179:129::-;48358:10;48347:7;33682;33709:6;-1:-1:-1;;;;;33709:6:0;;33636:87;48347:7;-1:-1:-1;;;;;48347:21:0;;:53;;;-1:-1:-1;48372:28:0;:7;48389:10;48372:16;:28::i;:::-;48339:102;;;;-1:-1:-1;;;48339:102:0;;;;;;;:::i;:::-;83250:50:::1;::::0;-1:-1:-1;;;;;83250:27:0;::::1;::::0;83278:21:::1;83250:50:::0;::::1;;;::::0;::::1;::::0;;;83278:21;83250:27;:50;::::1;;;;;;;;;;;;;::::0;::::1;;;;79352:596:::0;79501:21;79514:1;79517;79520;79501:11;:21::i;:::-;79493:50;;;;-1:-1:-1;;;79493:50:0;;12724:2:1;79493:50:0;;;12706:21:1;12763:2;12743:18;;;12736:30;-1:-1:-1;;;12782:18:1;;;12775:46;12838:18;;79493:50:0;12522:340:1;79493:50:0;79575:9;;79562;:22;;79554:57;;;;-1:-1:-1;;;79554:57:0;;13069:2:1;79554:57:0;;;13051:21:1;13108:2;13088:18;;;13081:30;-1:-1:-1;;;13127:18:1;;;13120:52;13189:18;;79554:57:0;12867:346:1;79554:57:0;79643:1;79630:9;:14;;:32;;;;;79661:1;79648:9;:14;;79630:32;79622:63;;;;-1:-1:-1;;;79622:63:0;;13420:2:1;79622:63:0;;;13402:21:1;13459:2;13439:18;;;13432:30;-1:-1:-1;;;13478:18:1;;;13471:48;13536:18;;79622:63:0;13218:342:1;79622:63:0;79704:20;;79735:9;;79696:49;;-1:-1:-1;;;;;79704:20:0;;;;79696:49;;;;;79735:9;79704:20;79696:49;79704:20;79696:49;79735:9;79704:20;79696:49;;;;;;;;;;;;;;;;;;;;;79756:32;79762:10;79775:12;;79756:5;:32::i;:::-;79811:12;;79799:25;;;;:11;:25;;;;;;;:37;;;79878:10;;79875:37;;-1:-1:-1;;;79875:37:0;;79903:4;79875:37;;;7800:51:1;79910:1:0;7867:18:1;;;7860:34;79878:10:0;;;;-1:-1:-1;;;;;79878:10:0;;79875:19;;7773:18:1;;79875:37:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;79859:12;;;79847:25;;;;:11;:25;;;;;:65;;;;79923:17;;79939:1;;79847:25;79923:17;;79939:1;;79923:17;:::i;:::-;;;;-1:-1:-1;;;;;;79352:596:0:o;81794:704::-;81886:1;81875:8;:12;81867:58;;;;-1:-1:-1;;;81867:58:0;;13767:2:1;81867:58:0;;;13749:21:1;13806:2;13786:18;;;13779:30;13845:34;13825:18;;;13818:62;-1:-1:-1;;;13896:18:1;;;13889:31;13937:19;;81867:58:0;13565:397:1;81867:58:0;81962:10;81944:16;81952:7;81944;:16::i;:::-;-1:-1:-1;;;;;81944:28:0;;81936:82;;;;-1:-1:-1;;;81936:82:0;;14169:2:1;81936:82:0;;;14151:21:1;14208:2;14188:18;;;14181:30;14247:34;14227:18;;;14220:62;-1:-1:-1;;;14298:18:1;;;14291:40;14348:19;;81936:82:0;13967:406:1;81936:82:0;82029:20;80355;;;:11;:20;;;;;;82114:25;;82087:23;82102:8;80355:20;82087:23;:::i;:::-;:52;82084:289;;82163:37;82179:20;;;:11;:20;;;;;;;;;82163:37;;:15;:37;;;;;;:42;82155:101;;;;-1:-1:-1;;;82155:101:0;;14580:2:1;82155:101:0;;;14562:21:1;14619:2;14599:18;;;14592:30;14658:34;14638:18;;;14631:62;-1:-1:-1;;;14709:18:1;;;14702:44;14763:19;;82155:101:0;14378:410:1;82155:101:0;82271:37;82287:20;;;:11;:20;;;;;;;;;82271:37;;:15;:37;;;;;;:47;;;82338:23;;1440:25:1;;;82338:23:0;;1413:18:1;82338:23:0;;;;;;;82084:289;82386:10;;82383:64;;-1:-1:-1;;;82383:64:0;;82411:10;82383:64;;;15033:34:1;82431:4:0;15083:18:1;;;15076:43;15135:18;;;15128:34;;;82386:10:0;;;;-1:-1:-1;;;;;82386:10:0;;82383:27;;14968:18:1;;82383:64:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;82458:20:0;;;;:11;:20;;;;;:32;;82482:8;;82458:20;:32;;82482:8;;82458:32;:::i;:::-;;;;-1:-1:-1;;;;;81794:704:0:o;57301:239::-;57373:7;57409:16;;;:7;:16;;;;;;-1:-1:-1;;;;;57409:16:0;;57436:73;;;;-1:-1:-1;;;57436:73:0;;15625:2:1;57436:73:0;;;15607:21:1;15664:2;15644:18;;;15637:30;15703:34;15683:18;;;15676:62;-1:-1:-1;;;15754:18:1;;;15747:39;15803:19;;57436:73:0;15423:405:1;79251:93:0;48358:10;48347:7;33682;33709:6;-1:-1:-1;;;;;33709:6:0;;33636:87;48347:7;-1:-1:-1;;;;;48347:21:0;;:53;;;-1:-1:-1;48372:28:0;:7;48389:10;48372:16;:28::i;:::-;48339:102;;;;-1:-1:-1;;;48339:102:0;;;;;;;:::i;:::-;79320:7:::1;:16:::0;;-1:-1:-1;;;;;;79320:16:0::1;-1:-1:-1::0;;;;;79320:16:0;;;::::1;::::0;;;::::1;::::0;;79251:93::o;48874:210::-;33682:7;33709:6;-1:-1:-1;;;;;33709:6:0;19499:10;33856:23;33848:68;;;;-1:-1:-1;;;33848:68:0;;;;;;;:::i;:::-;48955:23:::1;:7;48972:5:::0;48955:16:::1;:23::i;:::-;48950:127;;49000:32;::::0;49021:10:::1;::::0;-1:-1:-1;;;;;49000:32:0;::::1;::::0;::::1;::::0;;;::::1;49047:18;:7;49059:5:::0;49047:11:::1;:18::i;57031:208::-:0;57103:7;-1:-1:-1;;;;;57131:19:0;;57123:74;;;;-1:-1:-1;;;57123:74:0;;16035:2:1;57123:74:0;;;16017:21:1;16074:2;16054:18;;;16047:30;16113:34;16093:18;;;16086:62;-1:-1:-1;;;16164:18:1;;;16157:40;16214:19;;57123:74:0;15833:406:1;57123:74:0;-1:-1:-1;;;;;;57215:16:0;;;;;:9;:16;;;;;;;57031:208::o;34287:103::-;33682:7;33709:6;-1:-1:-1;;;;;33709:6:0;19499:10;33856:23;33848:68;;;;-1:-1:-1;;;33848:68:0;;;;;;;:::i;:::-;34352:30:::1;34379:1;34352:18;:30::i;:::-;34287:103::o:0;81322:193::-;48358:10;48347:7;33682;33709:6;-1:-1:-1;;;;;33709:6:0;;33636:87;48347:7;-1:-1:-1;;;;;48347:21:0;;:53;;;-1:-1:-1;48372:28:0;:7;48389:10;48372:16;:28::i;:::-;48339:102;;;;-1:-1:-1;;;48339:102:0;;;;;;;:::i;:::-;81431:20:::1;:33:::0;;-1:-1:-1;;;;;;81431:33:0::1;-1:-1:-1::0;;;;;81431:33:0;;;::::1;::::0;;;::::1;::::0;;;81475:14:::1;:32:::0;81322:193::o;57776:104::-;57832:13;57865:7;57858:14;;;;;:::i;59459:155::-;59554:52;19499:10;59587:8;59597;59554:18;:52::i;82510:661::-;82602:1;82591:8;:12;82583:59;;;;-1:-1:-1;;;82583:59:0;;16446:2:1;82583:59:0;;;16428:21:1;16485:2;16465:18;;;16458:30;16524:34;16504:18;;;16497:62;-1:-1:-1;;;16575:18:1;;;16568:32;16617:19;;82583:59:0;16244:398:1;82583:59:0;82679:10;82661:16;82669:7;82661;:16::i;:::-;-1:-1:-1;;;;;82661:28:0;;82653:87;;;;-1:-1:-1;;;82653:87:0;;16849:2:1;82653:87:0;;;16831:21:1;16888:2;16868:18;;;16861:30;16927:34;16907:18;;;16900:62;-1:-1:-1;;;16978:18:1;;;16971:45;17033:19;;82653:87:0;16647:411:1;82653:87:0;82759:20;;;;:11;:20;;;;;;:32;-1:-1:-1;82759:32:0;82751:70;;;;-1:-1:-1;;;82751:70:0;;17265:2:1;82751:70:0;;;17247:21:1;17304:2;17284:18;;;17277:30;17343:27;17323:18;;;17316:55;17388:18;;82751:70:0;17063:349:1;82751:70:0;82832:20;80355;;;:11;:20;;;;;;;;;82907:11;:20;;;;;;82891:37;;:15;:37;;;;;;;:48;;:105;;;;-1:-1:-1;82971:25:0;;82944:23;82959:8;82944:12;:23;:::i;:::-;82943:53;82891:105;82887:178;;;83052:1;83028:20;;;:11;:20;;;;;;;;;83012:37;;:15;:37;;;;;:41;82887:178;83078:10;;83075:45;;-1:-1:-1;;;83075:45:0;;83099:10;83075:45;;;7800:51:1;7867:18;;;7860:34;;;83078:10:0;;;;-1:-1:-1;;;;;83078:10:0;;83075:23;;7773:18:1;;83075:45:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;-1:-1:-1;83131:20:0;;;;:11;:20;;;;;:32;;83155:8;;83131:20;:32;;83155:8;;83131:32;:::i;80493:190::-;48358:10;48347:7;33682;33709:6;-1:-1:-1;;;;;33709:6:0;;33636:87;48347:7;-1:-1:-1;;;;;48347:21:0;;:53;;;-1:-1:-1;48372:28:0;:7;48389:10;48372:16;:28::i;:::-;48339:102;;;;-1:-1:-1;;;48339:102:0;;;;;;;:::i;:::-;80569:12:::1;80576:5;;80569:12;:::i;:::-;80596:9;80592:84;80609:15:::0;;::::1;80592:84;;;80645:5;80656:4;;80661:1;80656:7;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;80645:19:::0;;::::1;::::0;::::1;::::0;;-1:-1:-1;80645:19:0;;;::::1;::::0;;;::::1;::::0;::::1;::::0;;::::1;:::i;:::-;-1:-1:-1::0;80626:3:0;::::1;::::0;::::1;:::i;:::-;;;;80592:84;;60582:328:::0;60757:41;19499:10;60790:7;60757:18;:41::i;:::-;60749:103;;;;-1:-1:-1;;;60749:103:0;;;;;;;:::i;:::-;60863:39;60877:4;60883:2;60887:7;60896:5;60863:13;:39::i;:::-;60582:328;;;;:::o;80691:458::-;62485:4;62509:16;;;:7;:16;;;;;;80756:13;;-1:-1:-1;;;;;62509:16:0;80782:76;;;;-1:-1:-1;;;80782:76:0;;18276:2:1;80782:76:0;;;18258:21:1;18315:2;18295:18;;;18288:30;18354:34;18334:18;;;18327:62;-1:-1:-1;;;18405:18:1;;;18398:45;18460:19;;80782:76:0;18074:411:1;80782:76:0;80934:25;;80869:18;80911:20;;;:11;:20;;;;;;80869:18;;-1:-1:-1;80911:166:0;;80989:25;;80966:20;;;;:11;:20;;;;;;:48;:111;;81044:25;;81021:20;;;;:11;:20;;;;;;:48;:56;;81076:1;80911:166;;81021:56;81072:1;80911:166;;80966:111;81017:1;80911:166;;;80962:1;80911:166;80898:179;;;;81095:5;81138:1;81125:10;81102:11;:20;81114:7;81102:20;;;;;;;;;;;;:33;;;;:::i;:::-;:37;;;;:::i;:::-;81095:45;;;;;;;;:::i;:::-;;;;;;;;81088:53;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;80691:458;;;:::o;81523:263::-;81618:20;;81586:7;;;;-1:-1:-1;;;;;81618:20:0;:34;81615:131;;81676:20;;81711:14;;-1:-1:-1;;;;;81676:20:0;;;;81729:3;;81699:26;;:9;:26;:::i;:::-;81698:34;;;;:::i;:::-;81668:66;;;;81523:263;;;:::o;81615:131::-;-1:-1:-1;81772:1:0;;;;-1:-1:-1;81523:263:0;-1:-1:-1;81523:263:0:o;79139:104::-;48358:10;48347:7;33682;33709:6;-1:-1:-1;;;;;33709:6:0;;33636:87;48347:7;-1:-1:-1;;;;;48347:21:0;;:53;;;-1:-1:-1;48372:28:0;:7;48389:10;48372:16;:28::i;:::-;48339:102;;;;-1:-1:-1;;;48339:102:0;;;;;;;:::i;:::-;79213:10:::1;:22:::0;;-1:-1:-1;;;;;79213:22:0;;::::1;::::0;::::1;-1:-1:-1::0;;;;;;79213:22:0;;::::1;::::0;;;::::1;::::0;;79139:104::o;59685:164::-;-1:-1:-1;;;;;59806:25:0;;;59782:4;59806:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;59685:164::o;34545:201::-;33682:7;33709:6;-1:-1:-1;;;;;33709:6:0;19499:10;33856:23;33848:68;;;;-1:-1:-1;;;33848:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;34634:22:0;::::1;34626:73;;;::::0;-1:-1:-1;;;34626:73:0;;19087:2:1;34626:73:0::1;::::0;::::1;19069:21:1::0;19126:2;19106:18;;;19099:30;19165:34;19145:18;;;19138:62;-1:-1:-1;;;19216:18:1;;;19209:36;19262:19;;34626:73:0::1;18885:402:1::0;34626:73:0::1;34710:28;34729:8;34710:18;:28::i;47972:233::-:0;48074:4;-1:-1:-1;;;;;;48098:46:0;;-1:-1:-1;;;48098:46:0;;:99;;;48161:36;48185:11;56662:305;56764:4;-1:-1:-1;;;;;;56801:40:0;;-1:-1:-1;;;56801:40:0;;:105;;-1:-1:-1;;;;;;;56858:48:0;;-1:-1:-1;;;56858:48:0;56801:105;:158;;;-1:-1:-1;;;;;;;;;;47498:40:0;;;56923:36;47389:157;66566:174;66641:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;66641:29:0;-1:-1:-1;;;;;66641:29:0;;;;;;;;:24;;66695:23;66641:24;66695:14;:23::i;:::-;-1:-1:-1;;;;;66686:46:0;;;;;;;;;;;66566:174;;:::o;8477:167::-;-1:-1:-1;;;;;8611:23:0;;8557:4;4013:19;;;:12;;;:19;;;;;;:24;;8581:55;8574:62;8477:167;-1:-1:-1;;;8477:167:0:o;64398:439::-;-1:-1:-1;;;;;64478:16:0;;64470:61;;;;-1:-1:-1;;;64470:61:0;;19494:2:1;64470:61:0;;;19476:21:1;;;19513:18;;;19506:30;19572:34;19552:18;;;19545:62;19624:18;;64470:61:0;19292:356:1;64470:61:0;62485:4;62509:16;;;:7;:16;;;;;;-1:-1:-1;;;;;62509:16:0;:30;64542:58;;;;-1:-1:-1;;;64542:58:0;;19855:2:1;64542:58:0;;;19837:21:1;19894:2;19874:18;;;19867:30;19933;19913:18;;;19906:58;19981:18;;64542:58:0;19653:352:1;64542:58:0;-1:-1:-1;;;;;64671:13:0;;;;;;:9;:13;;;;;:18;;64688:1;;64671:13;:18;;64688:1;;64671:18;:::i;:::-;;;;-1:-1:-1;;64700:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;64700:21:0;-1:-1:-1;;;;;64700:21:0;;;;;;;;64739:33;;64700:16;;;64739:33;;64700:16;;64739:33;64785:44;58689:411;62714:348;62807:4;62509:16;;;:7;:16;;;;;;-1:-1:-1;;;;;62509:16:0;62824:73;;;;-1:-1:-1;;;62824:73:0;;20212:2:1;62824:73:0;;;20194:21:1;20251:2;20231:18;;;20224:30;20290:34;20270:18;;;20263:62;-1:-1:-1;;;20341:18:1;;;20334:42;20393:19;;62824:73:0;20010:408:1;62824:73:0;62908:13;62924:23;62939:7;62924:14;:23::i;:::-;62908:39;;62977:5;-1:-1:-1;;;;;62966:16:0;:7;-1:-1:-1;;;;;62966:16:0;;:51;;;;63010:7;-1:-1:-1;;;;;62986:31:0;:20;62998:7;62986:11;:20::i;:::-;-1:-1:-1;;;;;62986:31:0;;62966:51;:87;;;;63021:32;63038:5;63045:7;63021:16;:32::i;:::-;62958:96;62714:348;-1:-1:-1;;;;62714:348:0:o;65823:625::-;65982:4;-1:-1:-1;;;;;65955:31:0;:23;65970:7;65955:14;:23::i;:::-;-1:-1:-1;;;;;65955:31:0;;65947:81;;;;-1:-1:-1;;;65947:81:0;;20625:2:1;65947:81:0;;;20607:21:1;20664:2;20644:18;;;20637:30;20703:34;20683:18;;;20676:62;-1:-1:-1;;;20754:18:1;;;20747:35;20799:19;;65947:81:0;20423:401:1;65947:81:0;-1:-1:-1;;;;;66047:16:0;;66039:65;;;;-1:-1:-1;;;66039:65:0;;21031:2:1;66039:65:0;;;21013:21:1;21070:2;21050:18;;;21043:30;21109:34;21089:18;;;21082:62;-1:-1:-1;;;21160:18:1;;;21153:34;21204:19;;66039:65:0;20829:400:1;66039:65:0;66221:29;66238:1;66242:7;66221:8;:29::i;:::-;-1:-1:-1;;;;;66263:15:0;;;;;;:9;:15;;;;;:20;;66282:1;;66263:15;:20;;66282:1;;66263:20;:::i;:::-;;;;-1:-1:-1;;;;;;;66294:13:0;;;;;;:9;:13;;;;;:18;;66311:1;;66294:13;:18;;66311:1;;66294:18;:::i;:::-;;;;-1:-1:-1;;66323:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;66323:21:0;-1:-1:-1;;;;;66323:21:0;;;;;;;;;66362:27;;66323:16;;66362:27;;;;;;;58759:341;58689:411;;:::o;8233:158::-;8306:4;8330:53;8338:3;-1:-1:-1;;;;;8358:23:0;;8330:7;:53::i;8730:117::-;8793:7;8820:19;8828:3;4214:18;;4131:109;9201:158;9275:7;9326:22;9330:3;9342:5;9326:3;:22::i;65066:420::-;65126:13;65142:23;65157:7;65142:14;:23::i;:::-;65126:39;;65267:29;65284:1;65288:7;65267:8;:29::i;:::-;-1:-1:-1;;;;;65309:16:0;;;;;;:9;:16;;;;;:21;;65329:1;;65309:16;:21;;65329:1;;65309:21;:::i;:::-;;;;-1:-1:-1;;65348:16:0;;;;:7;:16;;;;;;65341:23;;-1:-1:-1;;;;;;65341:23:0;;;65382:36;65356:7;;65348:16;-1:-1:-1;;;;;65382:36:0;;;;;65348:16;;65382:36;65431:47;58689:411;78439:692;78957:11;;78801:202;;-1:-1:-1;;78856:10:0;21483:2:1;21479:15;;;21475:24;;78801:202:0;;;21463:37:1;78913:4:0;21534:15:1;;21530:24;21516:12;;;21509:46;78957:11:0;;;;21601:14:1;21594:22;21589:3;21585:32;21571:12;;;21564:54;78512:4:0;;78577:535;;21634:12:1;;78801:202:0;;;-1:-1:-1;;78801:202:0;;;;;;;;;;78757:277;;78801:202;78757:277;;;;21899:66:1;78645:416:0;;;21887:79:1;;;;21982:12;;;21975:28;22019:12;;78645:416:0;;;-1:-1:-1;;78645:416:0;;;;;;;;;78609:475;;78645:416;78609:475;;;;78577:535;;;;;;;;;22269:25:1;22342:4;22330:17;;22310:18;;;22303:45;22364:18;;;22357:34;;;22407:18;;;22400:34;;;22241:19;;78577:535:0;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;;78577:535:0;;-1:-1:-1;;78577:535:0;;78549:7;;-1:-1:-1;;;;;78549:563:0;;;:7;;:563;;78439:692;-1:-1:-1;;;;;78439:692:0:o;7905:152::-;7975:4;7999:50;8004:3;-1:-1:-1;;;;;8024:23:0;;7999:4;:50::i;34906:191::-;34980:16;34999:6;;-1:-1:-1;;;;;35016:17:0;;;-1:-1:-1;;;;;;35016:17:0;;;;;;35049:40;;34999:6;;;;;;;35049:40;;34980:16;35049:40;34969:128;34906:191;:::o;66882:315::-;67037:8;-1:-1:-1;;;;;67028:17:0;:5;-1:-1:-1;;;;;67028:17:0;;67020:55;;;;-1:-1:-1;;;67020:55:0;;22647:2:1;67020:55:0;;;22629:21:1;22686:2;22666:18;;;22659:30;22725:27;22705:18;;;22698:55;22770:18;;67020:55:0;22445:349:1;67020:55:0;-1:-1:-1;;;;;67086:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;67086:46:0;;;;;;;;;;67148:41;;540::1;;;67148::0;;513:18:1;67148:41:0;;;;;;;66882:315;;;:::o;61792:::-;61949:28;61959:4;61965:2;61969:7;61949:9;:28::i;:::-;61996:48;62019:4;62025:2;62029:7;62038:5;61996:22;:48::i;:::-;61988:111;;;;-1:-1:-1;;;61988:111:0;;;;;;;:::i;2410:1420::-;2476:4;2615:19;;;:12;;;:19;;;;;;2651:15;;2647:1176;;3026:21;3050:14;3063:1;3050:10;:14;:::i;:::-;3099:18;;3026:38;;-1:-1:-1;3079:17:0;;3099:22;;3120:1;;3099:22;:::i;:::-;3079:42;;3155:13;3142:9;:26;3138:405;;3189:17;3209:3;:11;;3221:9;3209:22;;;;;;;;:::i;:::-;;;;;;;;;3189:42;;3363:9;3334:3;:11;;3346:13;3334:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;3448:23;;;:12;;;:23;;;;;:36;;;3138:405;3624:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;3719:3;:12;;:19;3732:5;3719:19;;;;;;;;;;;3712:26;;;3762:4;3755:11;;;;;;;2647:1176;3806:5;3799:12;;;;;4594:120;4661:7;4688:3;:11;;4700:5;4688:18;;;;;;;;:::i;:::-;;;;;;;;;4681:25;;4594:120;;;;:::o;1820:414::-;1883:4;4013:19;;;:12;;;:19;;;;;;1900:327;;-1:-1:-1;1943:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;2126:18;;2104:19;;;:12;;;:19;;;;;;:40;;;;2159:11;;1900:327;-1:-1:-1;2210:5:0;2203:12;;67762:799;67917:4;-1:-1:-1;;;;;67938:13:0;;36632:19;:23;67934:620;;67974:72;;-1:-1:-1;;;67974:72:0;;-1:-1:-1;;;;;67974:36:0;;;;;:72;;19499:10;;68025:4;;68031:7;;68040:5;;67974:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;67974:72:0;;;;;;;;-1:-1:-1;;67974:72:0;;;;;;;;;;;;:::i;:::-;;;67970:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;68216:6;:13;68233:1;68216:18;68212:272;;68259:60;;-1:-1:-1;;;68259:60:0;;;;;;;:::i;68212:272::-;68434:6;68428:13;68419:6;68415:2;68411:15;68404:38;67970:529;-1:-1:-1;;;;;;68097:51:0;-1:-1:-1;;;68097:51:0;;-1:-1:-1;68090:58:0;;67934:620;-1:-1:-1;68538:4:0;67762:799;;;;;;:::o;-1:-1:-1:-;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;:::o;:::-;;;;;;;;;;;;;;;;;;;;:::i;14:131:1:-;-1:-1:-1;;;;;;88:32:1;;78:43;;68:71;;135:1;132;125:12;150:245;208:6;261:2;249:9;240:7;236:23;232:32;229:52;;;277:1;274;267:12;229:52;316:9;303:23;335:30;359:5;335:30;:::i;592:472::-;634:3;672:5;666:12;699:6;694:3;687:19;724:1;734:162;748:6;745:1;742:13;734:162;;;810:4;866:13;;;862:22;;856:29;838:11;;;834:20;;827:59;763:12;734:162;;;914:6;911:1;908:13;905:87;;;980:1;973:4;964:6;959:3;955:16;951:27;944:38;905:87;-1:-1:-1;1046:2:1;1025:15;-1:-1:-1;;1021:29:1;1012:39;;;;1053:4;1008:50;;592:472;-1:-1:-1;;592:472:1:o;1069:220::-;1218:2;1207:9;1200:21;1181:4;1238:45;1279:2;1268:9;1264:18;1256:6;1238:45;:::i;1476:180::-;1535:6;1588:2;1576:9;1567:7;1563:23;1559:32;1556:52;;;1604:1;1601;1594:12;1556:52;-1:-1:-1;1627:23:1;;1476:180;-1:-1:-1;1476:180:1:o;1869:131::-;-1:-1:-1;;;;;1944:31:1;;1934:42;;1924:70;;1990:1;1987;1980:12;2005:315;2073:6;2081;2134:2;2122:9;2113:7;2109:23;2105:32;2102:52;;;2150:1;2147;2140:12;2102:52;2189:9;2176:23;2208:31;2233:5;2208:31;:::i;:::-;2258:5;2310:2;2295:18;;;;2282:32;;-1:-1:-1;;;2005:315:1:o;2325:::-;2393:6;2401;2454:2;2442:9;2433:7;2429:23;2425:32;2422:52;;;2470:1;2467;2460:12;2422:52;2506:9;2493:23;2483:33;;2566:2;2555:9;2551:18;2538:32;2579:31;2604:5;2579:31;:::i;:::-;2629:5;2619:15;;;2325:315;;;;;:::o;2645:456::-;2722:6;2730;2738;2791:2;2779:9;2770:7;2766:23;2762:32;2759:52;;;2807:1;2804;2797:12;2759:52;2846:9;2833:23;2865:31;2890:5;2865:31;:::i;:::-;2915:5;-1:-1:-1;2972:2:1;2957:18;;2944:32;2985:33;2944:32;2985:33;:::i;:::-;2645:456;;3037:7;;-1:-1:-1;;;3091:2:1;3076:18;;;;3063:32;;2645:456::o;3106:247::-;3165:6;3218:2;3206:9;3197:7;3193:23;3189:32;3186:52;;;3234:1;3231;3224:12;3186:52;3273:9;3260:23;3292:31;3317:5;3292:31;:::i;3358:658::-;3529:2;3581:21;;;3651:13;;3554:18;;;3673:22;;;3500:4;;3529:2;3752:15;;;;3726:2;3711:18;;;3500:4;3795:195;3809:6;3806:1;3803:13;3795:195;;;3874:13;;-1:-1:-1;;;;;3870:39:1;3858:52;;3965:15;;;;3930:12;;;;3906:1;3824:9;3795:195;;;-1:-1:-1;4007:3:1;;3358:658;-1:-1:-1;;;;;;3358:658:1:o;4021:474::-;4105:6;4113;4121;4129;4182:3;4170:9;4161:7;4157:23;4153:33;4150:53;;;4199:1;4196;4189:12;4150:53;4235:9;4222:23;4212:33;;4295:2;4284:9;4280:18;4267:32;4339:4;4332:5;4328:16;4321:5;4318:27;4308:55;;4359:1;4356;4349:12;4308:55;4021:474;;4382:5;;-1:-1:-1;;;;4434:2:1;4419:18;;4406:32;;4485:2;4470:18;4457:32;;4021:474::o;4500:248::-;4568:6;4576;4629:2;4617:9;4608:7;4604:23;4600:32;4597:52;;;4645:1;4642;4635:12;4597:52;-1:-1:-1;;4668:23:1;;;4738:2;4723:18;;;4710:32;;-1:-1:-1;4500:248:1:o;5081:118::-;5167:5;5160:13;5153:21;5146:5;5143:32;5133:60;;5189:1;5186;5179:12;5204:382;5269:6;5277;5330:2;5318:9;5309:7;5305:23;5301:32;5298:52;;;5346:1;5343;5336:12;5298:52;5385:9;5372:23;5404:31;5429:5;5404:31;:::i;:::-;5454:5;-1:-1:-1;5511:2:1;5496:18;;5483:32;5524:30;5483:32;5524:30;:::i;5591:627::-;5689:6;5697;5750:2;5738:9;5729:7;5725:23;5721:32;5718:52;;;5766:1;5763;5756:12;5718:52;5806:9;5793:23;5835:18;5876:2;5868:6;5865:14;5862:34;;;5892:1;5889;5882:12;5862:34;5930:6;5919:9;5915:22;5905:32;;5975:7;5968:4;5964:2;5960:13;5956:27;5946:55;;5997:1;5994;5987:12;5946:55;6037:2;6024:16;6063:2;6055:6;6052:14;6049:34;;;6079:1;6076;6069:12;6049:34;6132:7;6127:2;6117:6;6114:1;6110:14;6106:2;6102:23;6098:32;6095:45;6092:65;;;6153:1;6150;6143:12;6092:65;6184:2;6176:11;;;;;6206:6;;-1:-1:-1;5591:627:1;;-1:-1:-1;;;;5591:627:1:o;6223:127::-;6284:10;6279:3;6275:20;6272:1;6265:31;6315:4;6312:1;6305:15;6339:4;6336:1;6329:15;6355:1266;6450:6;6458;6466;6474;6527:3;6515:9;6506:7;6502:23;6498:33;6495:53;;;6544:1;6541;6534:12;6495:53;6583:9;6570:23;6602:31;6627:5;6602:31;:::i;:::-;6652:5;-1:-1:-1;6709:2:1;6694:18;;6681:32;6722:33;6681:32;6722:33;:::i;:::-;6774:7;-1:-1:-1;6828:2:1;6813:18;;6800:32;;-1:-1:-1;6883:2:1;6868:18;;6855:32;6906:18;6936:14;;;6933:34;;;6963:1;6960;6953:12;6933:34;7001:6;6990:9;6986:22;6976:32;;7046:7;7039:4;7035:2;7031:13;7027:27;7017:55;;7068:1;7065;7058:12;7017:55;7104:2;7091:16;7126:2;7122;7119:10;7116:36;;;7132:18;;:::i;:::-;7207:2;7201:9;7175:2;7261:13;;-1:-1:-1;;7257:22:1;;;7281:2;7253:31;7249:40;7237:53;;;7305:18;;;7325:22;;;7302:46;7299:72;;;7351:18;;:::i;:::-;7391:10;7387:2;7380:22;7426:2;7418:6;7411:18;7466:7;7461:2;7456;7452;7448:11;7444:20;7441:33;7438:53;;;7487:1;7484;7477:12;7438:53;7543:2;7538;7534;7530:11;7525:2;7517:6;7513:15;7500:46;7588:1;7583:2;7578;7570:6;7566:15;7562:24;7555:35;7609:6;7599:16;;;;;;;6355:1266;;;;;;;:::o;7905:388::-;7973:6;7981;8034:2;8022:9;8013:7;8009:23;8005:32;8002:52;;;8050:1;8047;8040:12;8002:52;8089:9;8076:23;8108:31;8133:5;8108:31;:::i;:::-;8158:5;-1:-1:-1;8215:2:1;8200:18;;8187:32;8228:33;8187:32;8228:33;:::i;8298:380::-;8377:1;8373:12;;;;8420;;;8441:61;;8495:4;8487:6;8483:17;8473:27;;8441:61;8548:2;8540:6;8537:14;8517:18;8514:38;8511:161;;8594:10;8589:3;8585:20;8582:1;8575:31;8629:4;8626:1;8619:15;8657:4;8654:1;8647:15;8511:161;;8298:380;;;:::o;9923:400::-;10125:2;10107:21;;;10164:2;10144:18;;;10137:30;10203:34;10198:2;10183:18;;10176:62;-1:-1:-1;;;10269:2:1;10254:18;;10247:34;10313:3;10298:19;;9923:400::o;10615:184::-;10685:6;10738:2;10726:9;10717:7;10713:23;10709:32;10706:52;;;10754:1;10751;10744:12;10706:52;-1:-1:-1;10777:16:1;;10615:184;-1:-1:-1;10615:184:1:o;10804:127::-;10865:10;10860:3;10856:20;10853:1;10846:31;10896:4;10893:1;10886:15;10920:4;10917:1;10910:15;10936:128;10976:3;11007:1;11003:6;11000:1;10997:13;10994:39;;;11013:18;;:::i;:::-;-1:-1:-1;11049:9:1;;10936:128::o;11069:413::-;11271:2;11253:21;;;11310:2;11290:18;;;11283:30;11349:34;11344:2;11329:18;;11322:62;-1:-1:-1;;;11415:2:1;11400:18;;11393:47;11472:3;11457:19;;11069:413::o;11487:356::-;11689:2;11671:21;;;11708:18;;;11701:30;11767:34;11762:2;11747:18;;11740:62;11834:2;11819:18;;11487:356::o;11848:127::-;11909:10;11904:3;11900:20;11897:1;11890:31;11940:4;11937:1;11930:15;11964:4;11961:1;11954:15;11980:135;12019:3;12040:17;;;12037:43;;12060:18;;:::i;:::-;-1:-1:-1;12107:1:1;12096:13;;11980:135::o;15173:245::-;15240:6;15293:2;15281:9;15272:7;15268:23;15264:32;15261:52;;;15309:1;15306;15299:12;15261:52;15341:9;15335:16;15360:28;15382:5;15360:28;:::i;17417:125::-;17457:4;17485:1;17482;17479:8;17476:34;;;17490:18;;:::i;:::-;-1:-1:-1;17527:9:1;;17417:125::o;17547:522::-;17625:4;17631:6;17691:11;17678:25;17785:2;17781:7;17770:8;17754:14;17750:29;17746:43;17726:18;17722:68;17712:96;;17804:1;17801;17794:12;17712:96;17831:33;;17883:20;;;-1:-1:-1;17926:18:1;17915:30;;17912:50;;;17958:1;17955;17948:12;17912:50;17991:4;17979:17;;-1:-1:-1;18022:14:1;18018:27;;;18008:38;;18005:58;;;18059:1;18056;18049:12;18005:58;17547:522;;;;;:::o;18490:168::-;18530:7;18596:1;18592;18588:6;18584:14;18581:1;18578:21;18573:1;18566:9;18559:17;18555:45;18552:71;;;18603:18;;:::i;:::-;-1:-1:-1;18643:9:1;;18490:168::o;18663:217::-;18703:1;18729;18719:132;;18773:10;18768:3;18764:20;18761:1;18754:31;18808:4;18805:1;18798:15;18836:4;18833:1;18826:15;18719:132;-1:-1:-1;18865:9:1;;18663:217::o;22799:414::-;23001:2;22983:21;;;23040:2;23020:18;;;23013:30;23079:34;23074:2;23059:18;;23052:62;-1:-1:-1;;;23145:2:1;23130:18;;23123:48;23203:3;23188:19;;22799:414::o;23218:127::-;23279:10;23274:3;23270:20;23267:1;23260:31;23310:4;23307:1;23300:15;23334:4;23331:1;23324:15;23350:489;-1:-1:-1;;;;;23619:15:1;;;23601:34;;23671:15;;23666:2;23651:18;;23644:43;23718:2;23703:18;;23696:34;;;23766:3;23761:2;23746:18;;23739:31;;;23544:4;;23787:46;;23813:19;;23805:6;23787:46;:::i;:::-;23779:54;23350:489;-1:-1:-1;;;;;;23350:489:1:o;23844:249::-;23913:6;23966:2;23954:9;23945:7;23941:23;23937:32;23934:52;;;23982:1;23979;23972:12;23934:52;24014:9;24008:16;24033:30;24057:5;24033:30;:::i

Swarm Source

ipfs://c8883502a8a95f5165668efc4fa35c9e07d032ce5dd163c78a8081f6eb329eb2

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