Token

f-1 Anastasis - Act3 (f-1 AA3)

ERC-721

Overview

Max Total Supply

0 f-1 AA3

Holders

Market

Volume (24H)

N/A

Min Price (24H)

N/A

Max Price (24H)

N/A

Other Info

Token Contract

0xd6d0c1a49e83df2f4cb6b711ba915a8f05bc04f9

Filtered by Token Holder

0x090c984Cc693b991D7CbaeDdB43CB75f13FE5f2c

omegad.eth

Balance

1 f-1 AA3

0x090c984Cc693b991D7CbaeDdB43CB75f13FE5f2c

Click here to update the token information / general information

#	Exchange	Pair	Price	24H Volume	% Volume

Contract Source Code Verified (Exact Match)

Contract Name:

Anastasis_Act3

Compiler Version

v0.8.17+commit.8df45f5f

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-10-02
*/

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


// OpenZeppelin Contracts (last updated v4.7.0) (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.
 *
 * [WARNING]
 * ====
 *  Trying to delete such a structure from storage will likely result in data corruption, rendering the structure unusable.
 *  See https://github.com/ethereum/solidity/pull/11843[ethereum/solidity#11843] for more info.
 *
 *  In order to clean an EnumerableSet, you can either remove all elements one by one or create a fresh instance using an array of EnumerableSet.
 * ====
 */
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;

        /// @solidity memory-safe-assembly
        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;

        /// @solidity memory-safe-assembly
        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/utils/Strings.sol


// OpenZeppelin Contracts (last updated v4.7.0) (utils/Strings.sol)

pragma solidity ^0.8.0;

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

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

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

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

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

    /**
     * @dev Converts an `address` with fixed length of 20 bytes to its not checksummed ASCII `string` hexadecimal representation.
     */
    function toHexString(address addr) internal pure returns (string memory) {
        return toHexString(uint256(uint160(addr)), _ADDRESS_LENGTH);
    }
}

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


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

pragma solidity ^0.8.0;

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

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

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


// OpenZeppelin Contracts (last updated v4.7.0) (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 Throws if called by any account other than the owner.
     */
    modifier onlyOwner() {
        _checkOwner();
        _;
    }

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

    /**
     * @dev Throws if the sender is not the owner.
     */
    function _checkOwner() internal view virtual {
        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.7.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
                /// @solidity memory-safe-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 (last updated v4.6.0) (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 `IERC721Receiver.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 (last updated v4.7.0) (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`.
     *
     * 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;

    /**
     * @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 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 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 the account approved for `tokenId` token.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function getApproved(uint256 tokenId) external view returns (address operator);

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

// 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.7.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: address zero is not a valid owner");
        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: invalid token ID");
        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) {
        _requireMinted(tokenId);

        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 overridden 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 token owner nor approved for all"
        );

        _approve(to, tokenId);
    }

    /**
     * @dev See {IERC721-getApproved}.
     */
    function getApproved(uint256 tokenId) public view virtual override returns (address) {
        _requireMinted(tokenId);

        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: caller is not token 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: caller is not token 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) {
        address owner = ERC721.ownerOf(tokenId);
        return (spender == owner || isApprovedForAll(owner, spender) || getApproved(tokenId) == 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 an {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 an {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 Reverts if the `tokenId` has not been minted yet.
     */
    function _requireMinted(uint256 tokenId) internal view virtual {
        require(_exists(tokenId), "ERC721: invalid token ID");
    }

    /**
     * @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 {
                    /// @solidity memory-safe-assembly
                    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/AnastasisAct3.sol



pragma solidity >= 0.8.13;





contract Anastasis_Act3 is ERC721, AdminControl {
    
    address payable  private _royalties_recipient;
    uint256 private _royaltyAmount; //in % 
    uint256 public _editionNumber = 33;
    uint256 public _tokenId = 1;
    uint256[] public _availableURIs;
    uint256 public _maxSupply;
    uint256 public _saURI;
    string public _uri;
    
    mapping (uint256 => uint256) _stock;
    mapping(uint256 => uint256) public _tokenURIs;
    
    constructor () ERC721("f-1 Anastasis - Act3", "f-1 AA3") {
        _availableURIs = [1,2,3,4,5,6,7,8];
        _saURI = _availableURIs.length;
        for(uint256 i = 1; i <= _availableURIs.length; i++){
            _stock[i] = _editionNumber;
        }
        _maxSupply = _availableURIs.length * _editionNumber;
        _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 mint( 
        address to
    ) external adminRequired{
        require(_tokenId <= _maxSupply, "Max supply reached");
        _mint(to, _tokenId);
        uint256 uri = getURI();
        _tokenURIs[_tokenId] = uri;
        _tokenId += 1;
    }

    function getURI()internal returns(uint256){
        uint256 rnd = getPseudoRandomNumber(_availableURIs.length, msg.sender);
        uint256 uri = _availableURIs[rnd];
        if(_stock[uri] == 1){
            removeToken(rnd);
        }
        _stock[uri] -= 1;   
        if(uri == _saURI){
            uri = _saURI + _stock[uri];
        }
        require(uri>0,'invalid URI');
        return uri;
    }

    function removeToken(uint index) public{
        if(_availableURIs.length>1){
        _availableURIs[index] = _availableURIs[_availableURIs.length - 1];
        }
        _availableURIs.pop();
    }

    function getPseudoRandomNumber(uint256 length, address account) public view returns (uint256){    
        uint256 rnd = uint256(keccak256(abi.encodePacked(block.difficulty, block.timestamp, _tokenId, length, msg.sender, account))) % length;
        return rnd % length;
    }

    function burn(uint256 tokenId) public {
        address owner = ERC721.ownerOf(tokenId);
        require(msg.sender == owner, "Owner only");
        _burn(tokenId);
    }

    function setURI(
        string calldata updatedURI
    ) external adminRequired{
        _uri = updatedURI;
    }

    function tokenURI(uint256 tokenId) public view virtual override returns (string memory) {
        require(_exists(tokenId), "ERC721Metadata: URI query for nonexistent token");
        return string(abi.encodePacked(_uri, Strings.toString(_tokenURIs[tokenId]), ".json"));
    }

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

}

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":true,"internalType":"address","name":"from","type":"address"},{"indexed":true,"internalType":"address","name":"to","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Transfer","type":"event"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"_availableURIs","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_editionNumber","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_maxSupply","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_saURI","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_tokenId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"","type":"uint256"}],"name":"_tokenURIs","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"_uri","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"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":[],"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":"length","type":"uint256"},{"internalType":"address","name":"account","type":"address"}],"name":"getPseudoRandomNumber","outputs":[{"internalType":"uint256","name":"","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":[{"internalType":"address","name":"to","type":"address"}],"name":"mint","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"index","type":"uint256"}],"name":"removeToken","outputs":[],"stateMutability":"nonpayable","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 payable","name":"_recipient","type":"address"},{"internalType":"uint256","name":"_royaltyPerCent","type":"uint256"}],"name":"setRoyalties","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"string","name":"updatedURI","type":"string"}],"name":"setURI","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"tokenURI","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"transferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"newOwner","type":"address"}],"name":"transferOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"recipient","type":"address"}],"name":"withdraw","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

54511:3676:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;55391:394;;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;55391:394:0;;;;;;;;57168:118;;;;;;:::i;:::-;;:::i;:::-;;42174:100;;;:::i;:::-;;;;;;;:::i;43687:171::-;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;2294:32:1;;;2276:51;;2264:2;2249:18;43687:171:0;2130:203:1;43204:417:0;;;;;;:::i;:::-;;:::i;54915:45::-;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;2940:25:1;;;2928:2;2913:18;54915:45:0;2794:177:1;54842:18:0;;;:::i;54669:34::-;;;;;;54814:21;;;;;;54782:25;;;;;;44387:336;;;;;;:::i;:::-;;:::i;54710:27::-;;;;;;34007:139;;;;;;:::i;:::-;;:::i;33729:210::-;;;;;;:::i;:::-;;:::i;33107:267::-;;;:::i;:::-;;;;;;;:::i;56488:203::-;;;;;;:::i;:::-;;:::i;44794:185::-;;;;;;:::i;:::-;;:::i;56986:174::-;;;;;;:::i;:::-;;:::i;58053:129::-;;;;;;:::i;:::-;;:::i;41885:222::-;;;;;;:::i;:::-;;:::i;55793:261::-;;;;;;:::i;:::-;;:::i;33447:210::-;;;;;;:::i;:::-;;:::i;41616:207::-;;;;;;:::i;:::-;;:::i;18787:103::-;;;:::i;57581:193::-;;;;;;:::i;:::-;;:::i;18139:87::-;18185:7;18212:6;-1:-1:-1;;;;;18212:6:0;18139:87;;42343:104;;;:::i;43930:155::-;;;;;;:::i;:::-;;:::i;54744:31::-;;;;;;:::i;:::-;;:::i;45050:323::-;;;;;;:::i;:::-;;:::i;56699:279::-;;;;;;:::i;:::-;;:::i;57294:::-;;;;;;:::i;:::-;;:::i;57782:263::-;;;;;;:::i;:::-;;:::i;:::-;;;;-1:-1:-1;;;;;7016:32:1;;;6998:51;;7080:2;7065:18;;7058:34;;;;6971:18;57782:263:0;6824:274:1;44156:164:0;;;;;;:::i;:::-;-1:-1:-1;;;;;44277:25:0;;;44253:4;44277:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;44156:164;19045:201;;;;;;:::i;:::-;;:::i;55391:394::-;55543:4;55581:43;55612:11;55581:30;:43::i;:::-;:93;;;;55637:37;55662:11;55637:24;:37::i;:::-;55581:147;;;-1:-1:-1;;;;;;;55687:41:0;;-1:-1:-1;;;55687:41:0;55581:147;:196;;;;55741:36;55765:11;55741:23;:36::i;:::-;55565:212;55391:394;-1:-1:-1;;55391:394:0:o;57168:118::-;32931:10;32920:7;18185;18212:6;-1:-1:-1;;;;;18212:6:0;;18139:87;32920:7;-1:-1:-1;;;;;32920:21:0;;:53;;;-1:-1:-1;32945:28:0;:7;32962:10;32945:16;:28::i;:::-;32912:102;;;;-1:-1:-1;;;32912:102:0;;;;;;;:::i;:::-;;;;;;;;;57261:4:::1;:17;57268:10:::0;;57261:4;:17:::1;:::i;:::-;;57168:118:::0;;:::o;42174:100::-;42228:13;42261:5;42254:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;42174:100;:::o;43687:171::-;43763:7;43783:23;43798:7;43783:14;:23::i;:::-;-1:-1:-1;43826:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;43826:24:0;;43687:171::o;43204:417::-;43285:13;43301:23;43316:7;43301:14;:23::i;:::-;43285:39;;43349:5;-1:-1:-1;;;;;43343:11:0;:2;-1:-1:-1;;;;;43343:11:0;;43335:57;;;;-1:-1:-1;;;43335:57:0;;10546:2:1;43335:57:0;;;10528:21:1;10585:2;10565:18;;;10558:30;10624:34;10604:18;;;10597:62;-1:-1:-1;;;10675:18:1;;;10668:31;10716:19;;43335:57:0;10344:397:1;43335:57:0;16770:10;-1:-1:-1;;;;;43427:21:0;;;;:62;;-1:-1:-1;43452:37:0;43469:5;16770:10;44156:164;:::i;43452:37::-;43405:174;;;;-1:-1:-1;;;43405:174:0;;10948:2:1;43405:174:0;;;10930:21:1;10987:2;10967:18;;;10960:30;11026:34;11006:18;;;10999:62;11097:32;11077:18;;;11070:60;11147:19;;43405:174:0;10746:426:1;43405:174:0;43592:21;43601:2;43605:7;43592:8;:21::i;54842:18::-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::o;44387:336::-;44582:41;16770:10;44615:7;44582:18;:41::i;:::-;44574:100;;;;-1:-1:-1;;;44574:100:0;;;;;;;:::i;:::-;44687:28;44697:4;44703:2;44707:7;44687:9;:28::i;34007:139::-;34069:4;34105:5;-1:-1:-1;;;;;34094:16:0;:7;18185;18212:6;-1:-1:-1;;;;;18212:6:0;;18139:87;34094:7;-1:-1:-1;;;;;34094:16:0;;:43;;;-1:-1:-1;34114:23:0;:7;34131:5;34114:16;:23::i;33729:210::-;18025:13;:11;:13::i;:::-;33808:23:::1;:7;33825:5:::0;33808:16:::1;:23::i;:::-;33804:128;;;33853:31;::::0;33873:10:::1;::::0;-1:-1:-1;;;;;33853:31:0;::::1;::::0;::::1;::::0;;;::::1;33899:21;:7;33914:5:::0;33899:14:::1;:21::i;:::-;;33804:128;33729:210:::0;:::o;33107:267::-;33160:23;33219:16;:7;:14;:16::i;:::-;33205:31;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;33205:31:0;;33196:40;;33252:6;33247:96;33268:16;:7;:14;:16::i;:::-;33264:1;:20;33247:96;;;33318:13;:7;33329:1;33318:10;:13::i;:::-;33306:6;33313:1;33306:9;;;;;;;;:::i;:::-;-1:-1:-1;;;;;33306:25:0;;;:9;;;;;;;;;;;:25;33286:3;;;;:::i;:::-;;;;33247:96;;;;33107:267;:::o;56488:203::-;56541:14;:21;56563:1;-1:-1:-1;56538:115:0;;;56600:14;56615:21;;:25;;56639:1;;56615:25;:::i;:::-;56600:41;;;;;;;;:::i;:::-;;;;;;;;;56576:14;56591:5;56576:21;;;;;;;;:::i;:::-;;;;;;;;;;:65;56538:115;56663:14;:20;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;56488:203;:::o;44794:185::-;44932:39;44949:4;44955:2;44959:7;44932:39;;;;;;;;;;;;:16;:39::i;56986:174::-;57035:13;57051:23;57066:7;57051:14;:23::i;:::-;57035:39;-1:-1:-1;57093:10:0;-1:-1:-1;;;;;57093:19:0;;;57085:42;;;;-1:-1:-1;;;57085:42:0;;12463:2:1;57085:42:0;;;12445:21:1;12502:2;12482:18;;;12475:30;-1:-1:-1;;;12521:18:1;;;12514:40;12571:18;;57085:42:0;12261:334:1;57085:42:0;57138:14;57144:7;57138:5;:14::i;58053:129::-;32931:10;32920:7;18185;18212:6;-1:-1:-1;;;;;18212:6:0;;18139:87;32920:7;-1:-1:-1;;;;;32920:21:0;;:53;;;-1:-1:-1;32945:28:0;:7;32962:10;32945:16;:28::i;:::-;32912:102;;;;-1:-1:-1;;;32912:102:0;;;;;;;:::i;:::-;58124:50:::1;::::0;-1:-1:-1;;;;;58124:27:0;::::1;::::0;58152:21:::1;58124:50:::0;::::1;;;::::0;::::1;::::0;;;58152:21;58124:27;:50;::::1;;;;;;;;;;;;;::::0;::::1;;;;41885:222:::0;41957:7;41993:16;;;:7;:16;;;;;;-1:-1:-1;;;;;41993:16:0;;42020:56;;;;-1:-1:-1;;;42020:56:0;;12802:2:1;42020:56:0;;;12784:21:1;12841:2;12821:18;;;12814:30;-1:-1:-1;;;12860:18:1;;;12853:54;12924:18;;42020:56:0;12600:348:1;55793:261:0;32931:10;32920:7;18185;18212:6;-1:-1:-1;;;;;18212:6:0;;18139:87;32920:7;-1:-1:-1;;;;;32920:21:0;;:53;;;-1:-1:-1;32945:28:0;:7;32962:10;32945:16;:28::i;:::-;32912:102;;;;-1:-1:-1;;;32912:102:0;;;;;;;:::i;:::-;55889:10:::1;;55877:8;;:22;;55869:53;;;::::0;-1:-1:-1;;;55869:53:0;;13155:2:1;55869:53:0::1;::::0;::::1;13137:21:1::0;13194:2;13174:18;;;13167:30;-1:-1:-1;;;13213:18:1;;;13206:48;13271:18;;55869:53:0::1;12953:342:1::0;55869:53:0::1;55933:19;55939:2;55943:8;;55933:5;:19::i;:::-;55963:11;55977:8;:6;:8::i;:::-;56007;::::0;;55996:20:::1;::::0;;;:10:::1;:20;::::0;;;;:26;;;56033:13;;55963:22;;-1:-1:-1;56045:1:0::1;::::0;56033:13:::1;::::0;56045:1;;56033:13:::1;:::i;:::-;::::0;;;-1:-1:-1;;;;55793:261:0:o;33447:210::-;18025:13;:11;:13::i;:::-;33528:23:::1;:7;33545:5:::0;33528:16:::1;:23::i;:::-;33523:127;;33573:32;::::0;33594:10:::1;::::0;-1:-1:-1;;;;;33573:32:0;::::1;::::0;::::1;::::0;;;::::1;33620:18;:7;33632:5:::0;33620:11:::1;:18::i;41616:207::-:0;41688:7;-1:-1:-1;;;;;41716:19:0;;41708:73;;;;-1:-1:-1;;;41708:73:0;;13632:2:1;41708:73:0;;;13614:21:1;13671:2;13651:18;;;13644:30;13710:34;13690:18;;;13683:62;-1:-1:-1;;;13761:18:1;;;13754:39;13810:19;;41708:73:0;13430:405:1;41708:73:0;-1:-1:-1;;;;;;41799:16:0;;;;;:9;:16;;;;;;;41616:207::o;18787:103::-;18025:13;:11;:13::i;:::-;18852:30:::1;18879:1;18852:18;:30::i;:::-;18787:103::o:0;57581:193::-;32931:10;32920:7;18185;18212:6;-1:-1:-1;;;;;18212:6:0;;18139:87;32920:7;-1:-1:-1;;;;;32920:21:0;;:53;;;-1:-1:-1;32945:28:0;:7;32962:10;32945:16;:28::i;:::-;32912:102;;;;-1:-1:-1;;;32912:102:0;;;;;;;:::i;:::-;57690:20:::1;:33:::0;;-1:-1:-1;;;;;;57690:33:0::1;-1:-1:-1::0;;;;;57690:33:0;;;::::1;::::0;;;::::1;::::0;;;57734:14:::1;:32:::0;57581:193::o;42343:104::-;42399:13;42432:7;42425:14;;;;;:::i;43930:155::-;44025:52;16770:10;44058:8;44068;44025:18;:52::i;54744:31::-;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;54744:31:0;:::o;45050:323::-;45224:41;16770:10;45257:7;45224:18;:41::i;:::-;45216:100;;;;-1:-1:-1;;;45216:100:0;;;;;;;:::i;:::-;45327:38;45341:4;45347:2;45351:7;45360:4;45327:13;:38::i;:::-;45050:323;;;;:::o;56699:279::-;56891:8;;56839:90;;;56856:16;56839:90;;;14109:19:1;56874:15:0;14144:12:1;;;14137:28;;;;14181:12;;;;14174:28;;;;14218:12;;;14211:28;;;-1:-1:-1;;56909:10:0;14324:15:1;;14320:24;;14305:13;;;14298:47;14380:15;;;;14376:24;;;14361:13;;;14354:47;56784:7:0;;;;56934:6;;14417:13:1;;56839:90:0;;;;;;;;;;;;56829:101;;;;;;56821:110;;:119;;;;:::i;:::-;56807:133;-1:-1:-1;56958:12:0;56964:6;56807:133;56958:12;:::i;:::-;56951:19;56699:279;-1:-1:-1;;;;56699:279:0:o;57294:::-;46945:4;46969:16;;;:7;:16;;;;;;57367:13;;-1:-1:-1;;;;;46969:16:0;57393:76;;;;-1:-1:-1;;;57393:76:0;;14892:2:1;57393:76:0;;;14874:21:1;14931:2;14911:18;;;14904:30;14970:34;14950:18;;;14943:62;-1:-1:-1;;;15021:18:1;;;15014:45;15076:19;;57393:76:0;14690:411:1;57393:76:0;57534:19;;;;:10;:19;;;;;;57511:4;;57517:37;;:16;:37::i;:::-;57494:70;;;;;;;;;:::i;:::-;;;;;;;;;;;;;57480:85;;57294:279;;;:::o;57782:263::-;57877:20;;57845:7;;;;-1:-1:-1;;;;;57877:20:0;:34;57874:131;;57935:20;;57970:14;;-1:-1:-1;;;;;57935:20:0;;;;57988:3;;57958:26;;:9;:26;:::i;:::-;57957:34;;;;:::i;:::-;57927:66;;;;57782:263;;;:::o;57874:131::-;-1:-1:-1;58031:1:0;;;;-1:-1:-1;57782:263:0;-1:-1:-1;57782:263:0:o;19045:201::-;18025:13;:11;:13::i;:::-;-1:-1:-1;;;;;19134:22:0;::::1;19126:73;;;::::0;-1:-1:-1;;;19126:73:0;;16798:2:1;19126:73:0::1;::::0;::::1;16780:21:1::0;16837:2;16817:18;;;16810:30;16876:34;16856:18;;;16849:62;-1:-1:-1;;;16927:18:1;;;16920:36;16973:19;;19126:73:0::1;16596:402:1::0;19126:73:0::1;19210:28;19229:8;19210:18;:28::i;32545:233::-:0;32647:4;-1:-1:-1;;;;;;32671:46:0;;-1:-1:-1;;;32671:46:0;;:99;;;32734:36;32758:11;41247:305;41349:4;-1:-1:-1;;;;;;41386:40:0;;-1:-1:-1;;;41386:40:0;;:105;;-1:-1:-1;;;;;;;41443:48:0;;-1:-1:-1;;;41443:48:0;41386:105;:158;;;-1:-1:-1;;;;;;;;;;32071:40:0;;;41508:36;31962:157;8901:167;-1:-1:-1;;;;;9035:23:0;;8981:4;4437:19;;;:12;;;:19;;;;;;:24;;9005:55;8998:62;8901:167;-1:-1:-1;;;8901:167:0:o;51662:135::-;46945:4;46969:16;;;:7;:16;;;;;;-1:-1:-1;;;;;46969:16:0;51736:53;;;;-1:-1:-1;;;51736:53:0;;12802:2:1;51736:53:0;;;12784:21:1;12841:2;12821:18;;;12814:30;-1:-1:-1;;;12860:18:1;;;12853:54;12924:18;;51736:53:0;12600:348:1;50941:174:0;51016:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;51016:29:0;-1:-1:-1;;;;;51016:29:0;;;;;;;;:24;;51070:23;51016:24;51070:14;:23::i;:::-;-1:-1:-1;;;;;51061:46:0;;;;;;;;;;;50941:174;;:::o;47174:264::-;47267:4;47284:13;47300:23;47315:7;47300:14;:23::i;:::-;47284:39;;47353:5;-1:-1:-1;;;;;47342:16:0;:7;-1:-1:-1;;;;;47342:16:0;;:52;;;-1:-1:-1;;;;;;44277:25:0;;;44253:4;44277:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;47362:32;47342:87;;;;47422:7;-1:-1:-1;;;;;47398:31:0;:20;47410:7;47398:11;:20::i;:::-;-1:-1:-1;;;;;47398:31:0;;;47174:264;-1:-1:-1;;;;47174:264:0:o;50197:625::-;50356:4;-1:-1:-1;;;;;50329:31:0;:23;50344:7;50329:14;:23::i;:::-;-1:-1:-1;;;;;50329:31:0;;50321:81;;;;-1:-1:-1;;;50321:81:0;;17205:2:1;50321:81:0;;;17187:21:1;17244:2;17224:18;;;17217:30;17283:34;17263:18;;;17256:62;-1:-1:-1;;;17334:18:1;;;17327:35;17379:19;;50321:81:0;17003:401:1;50321:81:0;-1:-1:-1;;;;;50421:16:0;;50413:65;;;;-1:-1:-1;;;50413:65:0;;17611:2:1;50413:65:0;;;17593:21:1;17650:2;17630:18;;;17623:30;17689:34;17669:18;;;17662:62;-1:-1:-1;;;17740:18:1;;;17733:34;17784:19;;50413:65:0;17409:400:1;50413:65:0;50595:29;50612:1;50616:7;50595:8;:29::i;:::-;-1:-1:-1;;;;;50637:15:0;;;;;;:9;:15;;;;;:20;;50656:1;;50637:15;:20;;50656:1;;50637:20;:::i;:::-;;;;-1:-1:-1;;;;;;;50668:13:0;;;;;;:9;:13;;;;;:18;;50685:1;;50668:13;:18;;50685:1;;50668:18;:::i;:::-;;;;-1:-1:-1;;50697:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;50697:21:0;-1:-1:-1;;;;;50697:21:0;;;;;;;;;50736:27;;50697:16;;50736:27;;;;;;;57261:17:::1;57168:118:::0;;:::o;18304:132::-;18185:7;18212:6;-1:-1:-1;;;;;18212:6:0;16770:10;18368:23;18360:68;;;;-1:-1:-1;;;18360:68:0;;18016:2:1;18360:68:0;;;17998:21:1;;;18035:18;;;18028:30;18094:34;18074:18;;;18067:62;18146:18;;18360:68:0;17814:356:1;8657:158:0;8730:4;8754:53;8762:3;-1:-1:-1;;;;;8782:23:0;;8754:7;:53::i;9154:117::-;9217:7;9244:19;9252:3;4638:18;;4555:109;9625:158;9699:7;9750:22;9754:3;9766:5;9750:3;:22::i;49440:420::-;49500:13;49516:23;49531:7;49516:14;:23::i;:::-;49500:39;;49641:29;49658:1;49662:7;49641:8;:29::i;:::-;-1:-1:-1;;;;;49683:16:0;;;;;;:9;:16;;;;;:21;;49703:1;;49683:16;:21;;49703:1;;49683:21;:::i;:::-;;;;-1:-1:-1;;49722:16:0;;;;:7;:16;;;;;;49715:23;;-1:-1:-1;;;;;;49715:23:0;;;49756:36;49730:7;;49722:16;-1:-1:-1;;;;;49756:36:0;;;;;49722:16;;49756:36;49805:47;57168:118;48772:439;-1:-1:-1;;;;;48852:16:0;;48844:61;;;;-1:-1:-1;;;48844:61:0;;18377:2:1;48844:61:0;;;18359:21:1;;;18396:18;;;18389:30;18455:34;18435:18;;;18428:62;18507:18;;48844:61:0;18175:356:1;48844:61:0;46945:4;46969:16;;;:7;:16;;;;;;-1:-1:-1;;;;;46969:16:0;:30;48916:58;;;;-1:-1:-1;;;48916:58:0;;18738:2:1;48916:58:0;;;18720:21:1;18777:2;18757:18;;;18750:30;18816;18796:18;;;18789:58;18864:18;;48916:58:0;18536:352:1;48916:58:0;-1:-1:-1;;;;;49045:13:0;;;;;;:9;:13;;;;;:18;;49062:1;;49045:13;:18;;49062:1;;49045:18;:::i;:::-;;;;-1:-1:-1;;49074:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;49074:21:0;-1:-1:-1;;;;;49074:21:0;;;;;;;;49113:33;;49074:16;;;49113:33;;49074:16;;49113:33;49159:44;57168:118;56062:418;56096:7;56115:11;56129:56;56151:14;:21;;;;56174:10;56129:21;:56::i;:::-;56115:70;;56196:11;56210:14;56225:3;56210:19;;;;;;;;:::i;:::-;;;;;;;;;56196:33;;56243:6;:11;56250:3;56243:11;;;;;;;;;;;;56258:1;56243:16;56240:63;;56275:16;56287:3;56275:11;:16::i;:::-;56313:11;;;;:6;:11;;;;;:16;;56328:1;;56313:11;:16;;56328:1;;56313:16;:::i;:::-;;;;-1:-1:-1;;56353:6:0;;56346:13;;56343:70;;56390:11;;;;:6;:11;;;;;;56381:6;;:20;;56390:11;56381:20;:::i;:::-;56375:26;;56343:70;56435:1;56431:3;:5;56423:28;;;;-1:-1:-1;;;56423:28:0;;19095:2:1;56423:28:0;;;19077:21:1;19134:2;19114:18;;;19107:30;-1:-1:-1;;;19153:18:1;;;19146:41;19204:18;;56423:28:0;18893:335:1;8329:152:0;8399:4;8423:50;8428:3;-1:-1:-1;;;;;8448:23:0;;8423:4;:50::i;19406:191::-;19480:16;19499:6;;-1:-1:-1;;;;;19516:17:0;;;-1:-1:-1;;;;;;19516:17:0;;;;;;19549:40;;19499:6;;;;;;;19549:40;;19480:16;19549:40;19469:128;19406:191;:::o;51258:315::-;51413:8;-1:-1:-1;;;;;51404:17:0;:5;-1:-1:-1;;;;;51404:17:0;;51396:55;;;;-1:-1:-1;;;51396:55:0;;19435:2:1;51396:55:0;;;19417:21:1;19474:2;19454:18;;;19447:30;19513:27;19493:18;;;19486:55;19558:18;;51396:55:0;19233:349:1;51396:55:0;-1:-1:-1;;;;;51462:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;51462:46:0;;;;;;;;;;51524:41;;540::1;;;51524::0;;513:18:1;51524:41:0;;;;;;;51258:315;;;:::o;46254:313::-;46410:28;46420:4;46426:2;46430:7;46410:9;:28::i;:::-;46457:47;46480:4;46486:2;46490:7;46499:4;46457:22;:47::i;:::-;46449:110;;;;-1:-1:-1;;;46449:110:0;;;;;;;:::i;13944:723::-;14000:13;14221:5;14230:1;14221:10;14217:53;;-1:-1:-1;;14248:10:0;;;;;;;;;;;;-1:-1:-1;;;14248:10:0;;;;;13944:723::o;14217:53::-;14295:5;14280:12;14336:78;14343:9;;14336:78;;14369:8;;;;:::i;:::-;;-1:-1:-1;14392:10:0;;-1:-1:-1;14400:2:0;14392:10;;:::i;:::-;;;14336:78;;;14424:19;14456:6;14446:17;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;14446:17:0;;14424:39;;14474:154;14481:10;;14474:154;;14508:11;14518:1;14508:11;;:::i;:::-;;-1:-1:-1;14577:10:0;14585:2;14577:5;:10;:::i;:::-;14564:24;;:2;:24;:::i;:::-;14551:39;;14534:6;14541;14534:14;;;;;;;;:::i;:::-;;;;:56;-1:-1:-1;;;;;14534:56:0;;;;;;;;-1:-1:-1;14605:11:0;14614:2;14605:11;;:::i;:::-;;;14474:154;;2834:1420;2900:4;3039:19;;;:12;;;:19;;;;;;3075:15;;3071:1176;;3450:21;3474:14;3487:1;3474:10;:14;:::i;:::-;3523:18;;3450:38;;-1:-1:-1;3503:17:0;;3523:22;;3544:1;;3523:22;:::i;:::-;3503:42;;3579:13;3566:9;:26;3562:405;;3613:17;3633:3;:11;;3645:9;3633:22;;;;;;;;:::i;:::-;;;;;;;;;3613:42;;3787:9;3758:3;:11;;3770:13;3758:26;;;;;;;;:::i;:::-;;;;;;;;;;;;:38;;;;3872:23;;;:12;;;:23;;;;;:36;;;3562:405;4048:17;;:3;;:17;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;4143:3;:12;;:19;4156:5;4143:19;;;;;;;;;;;4136:26;;;4186:4;4179:11;;;;;;;3071:1176;4230:5;4223:12;;;;;5018:120;5085:7;5112:3;:11;;5124:5;5112:18;;;;;;;;:::i;:::-;;;;;;;;;5105:25;;5018:120;;;;:::o;2244:414::-;2307:4;4437:19;;;:12;;;:19;;;;;;2324:327;;-1:-1:-1;2367:23:0;;;;;;;;:11;:23;;;;;;;;;;;;;2550:18;;2528:19;;;:12;;;:19;;;;;;:40;;;;2583:11;;2324:327;-1:-1:-1;2634:5:0;2627:12;;52361:853;52515:4;-1:-1:-1;;;;;52536:13:0;;21132:19;:23;52532:675;;52572:71;;-1:-1:-1;;;52572:71:0;;-1:-1:-1;;;;;52572:36:0;;;;;:71;;16770:10;;52623:4;;52629:7;;52638:4;;52572:71;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;52572:71:0;;;;;;;;-1:-1:-1;;52572:71:0;;;;;;;;;;;;:::i;:::-;;;52568:584;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;52813:6;:13;52830:1;52813:18;52809:328;;52856:60;;-1:-1:-1;;;52856:60:0;;;;;;;:::i;52809:328::-;53087:6;53081:13;53072:6;53068:2;53064:15;53057:38;52568:584;-1:-1:-1;;;;;;52694:51:0;-1:-1:-1;;;52694:51:0;;-1:-1:-1;52687:58:0;;52532:675;-1:-1:-1;53191:4:0;52361:853;;;;;;:::o;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:592::-;663:6;671;724:2;712:9;703:7;699:23;695:32;692:52;;;740:1;737;730:12;692:52;780:9;767:23;809:18;850:2;842:6;839:14;836:34;;;866:1;863;856:12;836:34;904:6;893:9;889:22;879:32;;949:7;942:4;938:2;934:13;930:27;920:55;;971:1;968;961:12;920:55;1011:2;998:16;1037:2;1029:6;1026:14;1023:34;;;1053:1;1050;1043:12;1023:34;1098:7;1093:2;1084:6;1080:2;1076:15;1072:24;1069:37;1066:57;;;1119:1;1116;1109:12;1066:57;1150:2;1142:11;;;;;1172:6;;-1:-1:-1;592:592:1;;-1:-1:-1;;;;592:592:1:o;1189:250::-;1274:1;1284:113;1298:6;1295:1;1292:13;1284:113;;;1374:11;;;1368:18;1355:11;;;1348:39;1320:2;1313:10;1284:113;;;-1:-1:-1;;1431:1:1;1413:16;;1406:27;1189:250::o;1444:271::-;1486:3;1524:5;1518:12;1551:6;1546:3;1539:19;1567:76;1636:6;1629:4;1624:3;1620:14;1613:4;1606:5;1602:16;1567:76;:::i;:::-;1697:2;1676:15;-1:-1:-1;;1672:29:1;1663:39;;;;1704:4;1659:50;;1444:271;-1:-1:-1;;1444:271:1:o;1720:220::-;1869:2;1858:9;1851:21;1832:4;1889:45;1930:2;1919:9;1915:18;1907:6;1889:45;:::i;1945:180::-;2004:6;2057:2;2045:9;2036:7;2032:23;2028:32;2025:52;;;2073:1;2070;2063:12;2025:52;-1:-1:-1;2096:23:1;;1945:180;-1:-1:-1;1945:180:1:o;2338:131::-;-1:-1:-1;;;;;2413:31:1;;2403:42;;2393:70;;2459:1;2456;2449:12;2474:315;2542:6;2550;2603:2;2591:9;2582:7;2578:23;2574:32;2571:52;;;2619:1;2616;2609:12;2571:52;2658:9;2645:23;2677:31;2702:5;2677:31;:::i;:::-;2727:5;2779:2;2764:18;;;;2751:32;;-1:-1:-1;;;2474:315:1:o;2976:456::-;3053:6;3061;3069;3122:2;3110:9;3101:7;3097:23;3093:32;3090:52;;;3138:1;3135;3128:12;3090:52;3177:9;3164:23;3196:31;3221:5;3196:31;:::i;:::-;3246:5;-1:-1:-1;3303:2:1;3288:18;;3275:32;3316:33;3275:32;3316:33;:::i;:::-;2976:456;;3368:7;;-1:-1:-1;;;3422:2:1;3407:18;;;;3394:32;;2976:456::o;3437:247::-;3496:6;3549:2;3537:9;3528:7;3524:23;3520:32;3517:52;;;3565:1;3562;3555:12;3517:52;3604:9;3591:23;3623:31;3648:5;3623:31;:::i;3689:658::-;3860:2;3912:21;;;3982:13;;3885:18;;;4004:22;;;3831:4;;3860:2;4083:15;;;;4057:2;4042:18;;;3831:4;4126:195;4140:6;4137:1;4134:13;4126:195;;;4205:13;;-1:-1:-1;;;;;4201:39:1;4189:52;;4296:15;;;;4261:12;;;;4237:1;4155:9;4126:195;;;-1:-1:-1;4338:3:1;;3689:658;-1:-1:-1;;;;;;3689:658:1:o;4680:416::-;4745:6;4753;4806:2;4794:9;4785:7;4781:23;4777:32;4774:52;;;4822:1;4819;4812:12;4774:52;4861:9;4848:23;4880:31;4905:5;4880:31;:::i;:::-;4930:5;-1:-1:-1;4987:2:1;4972:18;;4959:32;5029:15;;5022:23;5010:36;;5000:64;;5060:1;5057;5050:12;5000:64;5083:7;5073:17;;;4680:416;;;;;:::o;5101:127::-;5162:10;5157:3;5153:20;5150:1;5143:31;5193:4;5190:1;5183:15;5217:4;5214:1;5207:15;5233:1266;5328:6;5336;5344;5352;5405:3;5393:9;5384:7;5380:23;5376:33;5373:53;;;5422:1;5419;5412:12;5373:53;5461:9;5448:23;5480:31;5505:5;5480:31;:::i;:::-;5530:5;-1:-1:-1;5587:2:1;5572:18;;5559:32;5600:33;5559:32;5600:33;:::i;:::-;5652:7;-1:-1:-1;5706:2:1;5691:18;;5678:32;;-1:-1:-1;5761:2:1;5746:18;;5733:32;5784:18;5814:14;;;5811:34;;;5841:1;5838;5831:12;5811:34;5879:6;5868:9;5864:22;5854:32;;5924:7;5917:4;5913:2;5909:13;5905:27;5895:55;;5946:1;5943;5936:12;5895:55;5982:2;5969:16;6004:2;6000;5997:10;5994:36;;;6010:18;;:::i;:::-;6085:2;6079:9;6053:2;6139:13;;-1:-1:-1;;6135:22:1;;;6159:2;6131:31;6127:40;6115:53;;;6183:18;;;6203:22;;;6180:46;6177:72;;;6229:18;;:::i;:::-;6269:10;6265:2;6258:22;6304:2;6296:6;6289:18;6344:7;6339:2;6334;6330;6326:11;6322:20;6319:33;6316:53;;;6365:1;6362;6355:12;6316:53;6421:2;6416;6412;6408:11;6403:2;6395:6;6391:15;6378:46;6466:1;6461:2;6456;6448:6;6444:15;6440:24;6433:35;6487:6;6477:16;;;;;;;5233:1266;;;;;;;:::o;6504:315::-;6572:6;6580;6633:2;6621:9;6612:7;6608:23;6604:32;6601:52;;;6649:1;6646;6639:12;6601:52;6685:9;6672:23;6662:33;;6745:2;6734:9;6730:18;6717:32;6758:31;6783:5;6758:31;:::i;7103:388::-;7171:6;7179;7232:2;7220:9;7211:7;7207:23;7203:32;7200:52;;;7248:1;7245;7238:12;7200:52;7287:9;7274:23;7306:31;7331:5;7306:31;:::i;:::-;7356:5;-1:-1:-1;7413:2:1;7398:18;;7385:32;7426:33;7385:32;7426:33;:::i;7496:400::-;7698:2;7680:21;;;7737:2;7717:18;;;7710:30;7776:34;7771:2;7756:18;;7749:62;-1:-1:-1;;;7842:2:1;7827:18;;7820:34;7886:3;7871:19;;7496:400::o;7901:380::-;7980:1;7976:12;;;;8023;;;8044:61;;8098:4;8090:6;8086:17;8076:27;;8044:61;8151:2;8143:6;8140:14;8120:18;8117:38;8114:161;;8197:10;8192:3;8188:20;8185:1;8178:31;8232:4;8229:1;8222:15;8260:4;8257:1;8250:15;8114:161;;7901:380;;;:::o;8412:545::-;8514:2;8509:3;8506:11;8503:448;;;8550:1;8575:5;8571:2;8564:17;8620:4;8616:2;8606:19;8690:2;8678:10;8674:19;8671:1;8667:27;8661:4;8657:38;8726:4;8714:10;8711:20;8708:47;;;-1:-1:-1;8749:4:1;8708:47;8804:2;8799:3;8795:12;8792:1;8788:20;8782:4;8778:31;8768:41;;8859:82;8877:2;8870:5;8867:13;8859:82;;;8922:17;;;8903:1;8892:13;8859:82;;;8863:3;;;8412:545;;;:::o;9133:1206::-;9257:18;9252:3;9249:27;9246:53;;;9279:18;;:::i;:::-;9308:94;9398:3;9358:38;9390:4;9384:11;9358:38;:::i;:::-;9352:4;9308:94;:::i;:::-;9428:1;9453:2;9448:3;9445:11;9470:1;9465:616;;;;10125:1;10142:3;10139:93;;;-1:-1:-1;10198:19:1;;;10185:33;10139:93;-1:-1:-1;;9090:1:1;9086:11;;;9082:24;9078:29;9068:40;9114:1;9110:11;;;9065:57;10245:78;;9438:895;;9465:616;8359:1;8352:14;;;8396:4;8383:18;;-1:-1:-1;;9501:17:1;;;9602:9;9624:229;9638:7;9635:1;9632:14;9624:229;;;9727:19;;;9714:33;9699:49;;9834:4;9819:20;;;;9787:1;9775:14;;;;9654:12;9624:229;;;9628:3;9881;9872:7;9869:16;9866:159;;;10005:1;10001:6;9995:3;9989;9986:1;9982:11;9978:21;9974:34;9970:39;9957:9;9952:3;9948:19;9935:33;9931:79;9923:6;9916:95;9866:159;;;10068:1;10062:3;10059:1;10055:11;10051:19;10045:4;10038:33;9438:895;;;9133:1206;;;:::o;11177:410::-;11379:2;11361:21;;;11418:2;11398:18;;;11391:30;11457:34;11452:2;11437:18;;11430:62;-1:-1:-1;;;11523:2:1;11508:18;;11501:44;11577:3;11562:19;;11177:410::o;11592:127::-;11653:10;11648:3;11644:20;11641:1;11634:31;11684:4;11681:1;11674:15;11708:4;11705:1;11698:15;11724:127;11785:10;11780:3;11776:20;11773:1;11766:31;11816:4;11813:1;11806:15;11840:4;11837:1;11830:15;11856:135;11895:3;11916:17;;;11913:43;;11936:18;;:::i;:::-;-1:-1:-1;11983:1:1;11972:13;;11856:135::o;11996:128::-;12063:9;;;12084:11;;;12081:37;;;12098:18;;:::i;12129:127::-;12190:10;12185:3;12181:20;12178:1;12171:31;12221:4;12218:1;12211:15;12245:4;12242:1;12235:15;13300:125;13365:9;;;13386:10;;;13383:36;;;13399:18;;:::i;14441:127::-;14502:10;14497:3;14493:20;14490:1;14483:31;14533:4;14530:1;14523:15;14557:4;14554:1;14547:15;14573:112;14605:1;14631;14621:35;;14636:18;;:::i;:::-;-1:-1:-1;14670:9:1;;14573:112::o;15106:1187::-;15383:3;15412:1;15445:6;15439:13;15475:36;15501:9;15475:36;:::i;:::-;15530:1;15547:18;;;15574:133;;;;15721:1;15716:356;;;;15540:532;;15574:133;-1:-1:-1;;15607:24:1;;15595:37;;15680:14;;15673:22;15661:35;;15652:45;;;-1:-1:-1;15574:133:1;;15716:356;15747:6;15744:1;15737:17;15777:4;15822:2;15819:1;15809:16;15847:1;15861:165;15875:6;15872:1;15869:13;15861:165;;;15953:14;;15940:11;;;15933:35;15996:16;;;;15890:10;;15861:165;;;15865:3;;;16055:6;16050:3;16046:16;16039:23;;15540:532;;;;;16103:6;16097:13;16119:68;16178:8;16173:3;16166:4;16158:6;16154:17;16119:68;:::i;:::-;-1:-1:-1;;;16209:18:1;;16236:22;;;16285:1;16274:13;;15106:1187;-1:-1:-1;;;;15106:1187:1:o;16298:168::-;16371:9;;;16402;;16419:15;;;16413:22;;16399:37;16389:71;;16440:18;;:::i;16471:120::-;16511:1;16537;16527:35;;16542:18;;:::i;:::-;-1:-1:-1;16576:9:1;;16471:120::o;19587:414::-;19789:2;19771:21;;;19828:2;19808:18;;;19801:30;19867:34;19862:2;19847:18;;19840:62;-1:-1:-1;;;19933:2:1;19918:18;;19911:48;19991:3;19976:19;;19587:414::o;20006:489::-;-1:-1:-1;;;;;20275:15:1;;;20257:34;;20327:15;;20322:2;20307:18;;20300:43;20374:2;20359:18;;20352:34;;;20422:3;20417:2;20402:18;;20395:31;;;20200:4;;20443:46;;20469:19;;20461:6;20443:46;:::i;:::-;20435:54;20006:489;-1:-1:-1;;;;;;20006:489:1:o;20500:249::-;20569:6;20622:2;20610:9;20601:7;20597:23;20593:32;20590:52;;;20638:1;20635;20628:12;20590:52;20670:9;20664:16;20689:30;20713:5;20689:30;:::i

Swarm Source

ipfs://3acdae5bb3c04cd3b242b685f26766e5cb69b7450bea59be2dbf1d81d08bb609

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