Token

Contract Source Code (Solidity)

IDE

• Blockscan IDE
• 🤖 Code ReaderBeta
• Remix IDE

Outline

library SafeMath    - function tryAdd(uint256 a, uint256 b)    - function trySub(uint256 a, uint256 b)    - function tryMul(uint256 a, uint256 b)    - function tryDiv(uint256 a, uint256 b)    - function tryMod(uint256 a, uint256 b)    - function add(uint256 a, uint256 b)    - function sub(uint256 a, uint256 b)    - function mul(uint256 a, uint256 b)    - function div(uint256 a, uint256 b)    - function mod(uint256 a, uint256 b)    - function sub(    - function div(    - function mod( library Counters    - function current(Counter storage coun ...    - function increment(Counter storage co ...    - function decrement(Counter storage co ...    - function reset(Counter storage counte ... library Strings    - function toString(uint256 value)    - function toHexString(uint256 value)    - function toHexString(uint256 value, u ...    - function _msgSender()    - function _msgData()    - function owner()    - function renounceOwnership()    - function transferOwnership(address ne ...    - function _transferOwnership(address n ... library Address    - function isContract(address account)    - function sendValue(address payable re ...    - function functionCall(address target, ...    - function functionCall(    - function functionCallWithValue(    - function functionCallWithValue(    - function functionStaticCall(address t ...    - function functionStaticCall(    - function functionDelegateCall(address ...    - function functionDelegateCall(    - function verifyCallResult( interface IERC721Receiver    - function onERC721Received( interface IERC165    - function supportsInterface(bytes4 int ...    - function supportsInterface(bytes4 int ... interface IERC721 is IERC165    - function balanceOf(address owner)    - function ownerOf(uint256 tokenId)    - function safeTransferFrom(    - function transferFrom(    - function approve(address to, uint256 ...    - function getApproved(uint256 tokenId)    - function setApprovalForAll(address op ...    - function isApprovedForAll(address own ...    - function safeTransferFrom( interface IERC721Metadata is IERC721    - function name()    - function symbol()    - function tokenURI(uint256 tokenId)  contract ERC721 is Context, ERC165 ...    - function supportsInterface(bytes4 int ...    - function balanceOf(address owner)    - function ownerOf(uint256 tokenId)    - function name()    - function symbol()    - function tokenURI(uint256 tokenId)    - function _baseURI()    - function approve(address to, uint256 ...    - function getApproved(uint256 tokenId)    - function setApprovalForAll(address op ...    - function isApprovedForAll(address own ...    - function transferFrom(    - function safeTransferFrom(    - function safeTransferFrom(    - function _safeTransfer(    - function _exists(uint256 tokenId)    - function _isApprovedOrOwner(address s ...    - function _safeMint(address to, uint25 ...    - function _safeMint(    - function _mint(address to, uint256 to ...    - function _burn(uint256 tokenId)    - function _transfer(    - function _approve(address to, uint256 ...    - function _setApprovalForAll(    - function _checkOnERC721Received(    - function _beforeTokenTransfer(    - function tokenURI(uint256 tokenId)    - function _setTokenURI(uint256 tokenId ...    - function _burn(uint256 tokenId)  contract El_Mundo_De_Alamo is ERC7 ... *    - function mintUniqueWork(    - function getNextTokenId()    - function _mintUniqueWork(    - function _beforeTokenTransfer(    - function _burn(uint256 tokenId)    - function _baseURI()    - function tokenURI(uint256 tokenId)    - function supportsInterface(bytes4 int ...

More Options

• Similar
• Sol2Uml
• Submit Audit
• Compare

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

// File: @openzeppelin/contracts/utils/math/SafeMath.sol


// OpenZeppelin Contracts v4.4.1 (utils/math/SafeMath.sol)

pragma solidity ^0.8.0;

// CAUTION
// This version of SafeMath should only be used with Solidity 0.8 or later,
// because it relies on the compiler's built in overflow checks.

/**
 * @dev Wrappers over Solidity's arithmetic operations.
 *
 * NOTE: `SafeMath` is generally not needed starting with Solidity 0.8, since the compiler
 * now has built in overflow checking.
 */
library SafeMath {
    /**
     * @dev Returns the addition of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryAdd(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            uint256 c = a + b;
            if (c < a) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the substraction of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function trySub(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b > a) return (false, 0);
            return (true, a - b);
        }
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, with an overflow flag.
     *
     * _Available since v3.4._
     */
    function tryMul(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            // Gas optimization: this is cheaper than requiring 'a' not being zero, but the
            // benefit is lost if 'b' is also tested.
            // See: https://github.com/OpenZeppelin/openzeppelin-contracts/pull/522
            if (a == 0) return (true, 0);
            uint256 c = a * b;
            if (c / a != b) return (false, 0);
            return (true, c);
        }
    }

    /**
     * @dev Returns the division of two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryDiv(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a / b);
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers, with a division by zero flag.
     *
     * _Available since v3.4._
     */
    function tryMod(uint256 a, uint256 b) internal pure returns (bool, uint256) {
        unchecked {
            if (b == 0) return (false, 0);
            return (true, a % b);
        }
    }

    /**
     * @dev Returns the addition of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `+` operator.
     *
     * Requirements:
     *
     * - Addition cannot overflow.
     */
    function add(uint256 a, uint256 b) internal pure returns (uint256) {
        return a + b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting on
     * overflow (when the result is negative).
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(uint256 a, uint256 b) internal pure returns (uint256) {
        return a - b;
    }

    /**
     * @dev Returns the multiplication of two unsigned integers, reverting on
     * overflow.
     *
     * Counterpart to Solidity's `*` operator.
     *
     * Requirements:
     *
     * - Multiplication cannot overflow.
     */
    function mul(uint256 a, uint256 b) internal pure returns (uint256) {
        return a * b;
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator.
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(uint256 a, uint256 b) internal pure returns (uint256) {
        return a / b;
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting when dividing by zero.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(uint256 a, uint256 b) internal pure returns (uint256) {
        return a % b;
    }

    /**
     * @dev Returns the subtraction of two unsigned integers, reverting with custom message on
     * overflow (when the result is negative).
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {trySub}.
     *
     * Counterpart to Solidity's `-` operator.
     *
     * Requirements:
     *
     * - Subtraction cannot overflow.
     */
    function sub(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b <= a, errorMessage);
            return a - b;
        }
    }

    /**
     * @dev Returns the integer division of two unsigned integers, reverting with custom message on
     * division by zero. The result is rounded towards zero.
     *
     * Counterpart to Solidity's `/` operator. Note: this function uses a
     * `revert` opcode (which leaves remaining gas untouched) while Solidity
     * uses an invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function div(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a / b;
        }
    }

    /**
     * @dev Returns the remainder of dividing two unsigned integers. (unsigned integer modulo),
     * reverting with custom message when dividing by zero.
     *
     * CAUTION: This function is deprecated because it requires allocating memory for the error
     * message unnecessarily. For custom revert reasons use {tryMod}.
     *
     * Counterpart to Solidity's `%` operator. This function uses a `revert`
     * opcode (which leaves remaining gas untouched) while Solidity uses an
     * invalid opcode to revert (consuming all remaining gas).
     *
     * Requirements:
     *
     * - The divisor cannot be zero.
     */
    function mod(
        uint256 a,
        uint256 b,
        string memory errorMessage
    ) internal pure returns (uint256) {
        unchecked {
            require(b > 0, errorMessage);
            return a % b;
        }
    }
}

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


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

pragma solidity ^0.8.0;

/**
 * @title Counters
 * @author Matt Condon (@shrugs)
 * @dev Provides counters that can only be incremented, decremented or reset. This can be used e.g. to track the number
 * of elements in a mapping, issuing ERC721 ids, or counting request ids.
 *
 * Include with `using Counters for Counters.Counter;`
 */
library Counters {
    struct Counter {
        // This variable should never be directly accessed by users of the library: interactions must be restricted to
        // the library's function. As of Solidity v0.5.2, this cannot be enforced, though there is a proposal to add
        // this feature: see https://github.com/ethereum/solidity/issues/4637
        uint256 _value; // default: 0
    }

    function current(Counter storage counter) internal view returns (uint256) {
        return counter._value;
    }

    function increment(Counter storage counter) internal {
        unchecked {
            counter._value += 1;
        }
    }

    function decrement(Counter storage counter) internal {
        uint256 value = counter._value;
        require(value > 0, "Counter: decrement overflow");
        unchecked {
            counter._value = value - 1;
        }
    }

    function reset(Counter storage counter) internal {
        counter._value = 0;
    }
}

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


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

pragma solidity ^0.8.0;

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

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

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

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

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

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


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

pragma solidity ^0.8.0;

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

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

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


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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


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

pragma solidity ^0.8.0;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    /**
     * @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: @openzeppelin/contracts/utils/introspection/ERC165.sol


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

pragma solidity ^0.8.0;


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

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


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

pragma solidity ^0.8.0;


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

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

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

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

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

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

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

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

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

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

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

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

// File: @openzeppelin/contracts/token/ERC721/extensions/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 v4.4.1 (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);
    }

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

    /**
     * @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 of token that is not own");
        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);
    }

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

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


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

pragma solidity ^0.8.0;


/**
 * @dev ERC721 token with storage based token URI management.
 */
abstract contract ERC721URIStorage is ERC721 {
    using Strings for uint256;

    // Optional mapping for token URIs
    mapping(uint256 => string) private _tokenURIs;

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

        string memory _tokenURI = _tokenURIs[tokenId];
        string memory base = _baseURI();

        // If there is no base URI, return the token URI.
        if (bytes(base).length == 0) {
            return _tokenURI;
        }
        // If both are set, concatenate the baseURI and tokenURI (via abi.encodePacked).
        if (bytes(_tokenURI).length > 0) {
            return string(abi.encodePacked(base, _tokenURI));
        }

        return super.tokenURI(tokenId);
    }

    /**
     * @dev Sets `_tokenURI` as the tokenURI of `tokenId`.
     *
     * Requirements:
     *
     * - `tokenId` must exist.
     */
    function _setTokenURI(uint256 tokenId, string memory _tokenURI) internal virtual {
        require(_exists(tokenId), "ERC721URIStorage: URI set of nonexistent token");
        _tokenURIs[tokenId] = _tokenURI;
    }

    /**
     * @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 override {
        super._burn(tokenId);

        if (bytes(_tokenURIs[tokenId]).length != 0) {
            delete _tokenURIs[tokenId];
        }
    }
}

// File: contracts/ElMundoDeAlamo.sol

//                                                                                                                                                  
//,------.                              ,---.  ,--.                                        ,--.  ,--.  ,--.         ,--.                              
//|  .---',--.--. ,---. ,--,--,--.     /  O  \ |  | ,--,--.,--,--,--. ,---.     ,--.   ,--.`--',-'  '-.|  ,---.     |  |    ,---.,--.  ,--.,---.      
//|  `--, |  .--'| .-. ||        |    |  .-.  ||  |' ,-.  ||        || .-. |    |  |.'.|  |,--.'-.  .-'|  .-.  |    |  |   | .-. |\  `'  /| .-. :     
//|  |`   |  |   ' '-' '|  |  |  |    |  | |  ||  |\ '-'  ||  |  |  |' '-' '    |   .'.   ||  |  |  |  |  | |  |    |  '--.' '-' ' \    / \   --.,--. 
//`--'    `--'    `---' `--`--`--'    `--' `--'`--' `--`--'`--`--`--' `---'     '--'   '--'`--'  `--'  `--' `--'    `-----' `---'   `--'   `----''-,/

pragma solidity ^0.8.9;






contract El_Mundo_De_Alamo is ERC721, Ownable {  
     using SafeMath for uint256;
     using Strings for uint256;
   
    // Freeze OS Metadata to make artwork irrevocable
    event PermanentURI(string _value, uint256 indexed _id);

    using Counters for Counters.Counter;

    Counters.Counter private _tokenIdCounter;
    string private _baseURIextended;
    uint256 private _MAX_UniqueWork = 2000000;
    mapping(uint256 => string) private tokenURIs;

    constructor() ERC721("El Mundo De Alamo", "Alamo") {
    
    }

    function mintUniqueWork(
        address to,
        string memory _tokenURI
    ) public onlyOwner {
    
        uint256 tokenId = getNextTokenId();
        require(
            tokenId < _MAX_UniqueWork,
            "Maximum number of unique artworks exceeded"
        );

        _mintUniqueWork(to, tokenId, _tokenURI);
        _tokenIdCounter.increment();
    }

    function getNextTokenId() public view returns (uint256) {
        return _tokenIdCounter.current() + 1;
    }

    function _mintUniqueWork(
        address to,
        uint256 tokenId,
        string memory _tokenURI
    ) internal {
        _safeMint(to, tokenId);
        tokenURIs[tokenId] =  _tokenURI;
        emit PermanentURI(tokenURI(tokenId), tokenId);
    }

    function _beforeTokenTransfer(
        address from,
        address to,
        uint256 tokenId
    ) internal override(ERC721) {
        super._beforeTokenTransfer(from, to, tokenId);
    }

    function _burn(uint256 tokenId)
        internal
        override(ERC721)
    {
        super._burn(tokenId);
    }

    function _baseURI() internal view override returns (string memory uri){
        uri = "ipfs://";
    }

    function tokenURI(uint256 tokenId)
        public
        view
        override(ERC721)
        returns (string memory)
    {
        require(_exists(tokenId), "URI query for nonexistent token");

        string memory _tokenURI = tokenURIs[tokenId];
        string memory base = _baseURI();
        return string(abi.encodePacked(base, _tokenURI));
    }


    function supportsInterface(bytes4 interfaceId)
        public
        view
        override(ERC721)
        returns (bool)
    {
        return
            super.supportsInterface(interfaceId);
    }
}

• No Contract Security Audit Submitted- Submit Audit Here

[{"inputs":[],"stateMutability":"nonpayable","type":"constructor"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"approved","type":"address"},{"indexed":true,"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"Approval","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"owner","type":"address"},{"indexed":true,"internalType":"address","name":"operator","type":"address"},{"indexed":false,"internalType":"bool","name":"approved","type":"bool"}],"name":"ApprovalForAll","type":"event"},{"anonymous":false,"inputs":[{"indexed":true,"internalType":"address","name":"previousOwner","type":"address"},{"indexed":true,"internalType":"address","name":"newOwner","type":"address"}],"name":"OwnershipTransferred","type":"event"},{"anonymous":false,"inputs":[{"indexed":false,"internalType":"string","name":"_value","type":"string"},{"indexed":true,"internalType":"uint256","name":"_id","type":"uint256"}],"name":"PermanentURI","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":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"approve","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"}],"name":"balanceOf","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"getApproved","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"getNextTokenId","outputs":[{"internalType":"uint256","name":"","type":"uint256"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"owner","type":"address"},{"internalType":"address","name":"operator","type":"address"}],"name":"isApprovedForAll","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"address","name":"to","type":"address"},{"internalType":"string","name":"_tokenURI","type":"string"}],"name":"mintUniqueWork","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[],"name":"name","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"owner","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"ownerOf","outputs":[{"internalType":"address","name":"","type":"address"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"renounceOwnership","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"from","type":"address"},{"internalType":"address","name":"to","type":"address"},{"internalType":"uint256","name":"tokenId","type":"uint256"},{"internalType":"bytes","name":"_data","type":"bytes"}],"name":"safeTransferFrom","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"address","name":"operator","type":"address"},{"internalType":"bool","name":"approved","type":"bool"}],"name":"setApprovalForAll","outputs":[],"stateMutability":"nonpayable","type":"function"},{"inputs":[{"internalType":"bytes4","name":"interfaceId","type":"bytes4"}],"name":"supportsInterface","outputs":[{"internalType":"bool","name":"","type":"bool"}],"stateMutability":"view","type":"function"},{"inputs":[],"name":"symbol","outputs":[{"internalType":"string","name":"","type":"string"}],"stateMutability":"view","type":"function"},{"inputs":[{"internalType":"uint256","name":"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"}]

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

47668:2355:0:-:0;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49813:207;;;;;;:::i;:::-;;:::i;:::-;;;565:14:1;;558:22;540:41;;528:2;513:18;49813:207:0;;;;;;;;33179:100;;;:::i;:::-;;;;;;;:::i;34738:221::-;;;;;;:::i;:::-;;:::i;:::-;;;-1:-1:-1;;;;;1692:32:1;;;1674:51;;1662:2;1647:18;34738:221:0;1528:203:1;34261:411:0;;;;;;:::i;:::-;;:::i;:::-;;35488:339;;;;;;:::i;:::-;;:::i;35898:185::-;;;;;;:::i;:::-;;:::i;32873:239::-;;;;;;:::i;:::-;;:::i;32603:208::-;;;;;;:::i;:::-;;:::i;:::-;;;2843:25:1;;;2831:2;2816:18;32603:208:0;2697:177:1;13222:103:0;;;:::i;12571:87::-;12644:6;;-1:-1:-1;;;;;12644:6:0;12571:87;;33348:104;;;:::i;35031:155::-;;;;;;:::i;:::-;;:::i;36154:328::-;;;;;;:::i;:::-;;:::i;49437:366::-;;;;;;:::i;:::-;;:::i;48216:380::-;;;;;;:::i;:::-;;:::i;48604:111::-;;;:::i;35257:164::-;;;;;;:::i;:::-;-1:-1:-1;;;;;35378:25:0;;;35354:4;35378:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;;;35257:164;13480:201;;;;;;:::i;:::-;;:::i;49813:207::-;49934:4;49976:36;50000:11;49976:23;:36::i;:::-;49956:56;49813:207;-1:-1:-1;;49813:207:0:o;33179:100::-;33233:13;33266:5;33259:12;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;33179:100;:::o;34738:221::-;34814:7;38081:16;;;:7;:16;;;;;;-1:-1:-1;;;;;38081:16:0;34834:73;;;;-1:-1:-1;;;34834:73:0;;6051:2:1;34834:73:0;;;6033:21:1;6090:2;6070:18;;;6063:30;6129:34;6109:18;;;6102:62;-1:-1:-1;;;6180:18:1;;;6173:42;6232:19;;34834:73:0;;;;;;;;;-1:-1:-1;34927:24:0;;;;:15;:24;;;;;;-1:-1:-1;;;;;34927:24:0;;34738:221::o;34261:411::-;34342:13;34358:23;34373:7;34358:14;:23::i;:::-;34342:39;;34406:5;-1:-1:-1;;;;;34400:11:0;:2;-1:-1:-1;;;;;34400:11:0;;;34392:57;;;;-1:-1:-1;;;34392:57:0;;6464:2:1;34392:57:0;;;6446:21:1;6503:2;6483:18;;;6476:30;6542:34;6522:18;;;6515:62;-1:-1:-1;;;6593:18:1;;;6586:31;6634:19;;34392:57:0;6262:397:1;34392:57:0;11375:10;-1:-1:-1;;;;;34484:21:0;;;;:62;;-1:-1:-1;34509:37:0;34526:5;11375:10;35257:164;:::i;34509:37::-;34462:168;;;;-1:-1:-1;;;34462:168:0;;6866:2:1;34462:168:0;;;6848:21:1;6905:2;6885:18;;;6878:30;6944:34;6924:18;;;6917:62;7015:26;6995:18;;;6988:54;7059:19;;34462:168:0;6664:420:1;34462:168:0;34643:21;34652:2;34656:7;34643:8;:21::i;:::-;34331:341;34261:411;;:::o;35488:339::-;35683:41;11375:10;35716:7;35683:18;:41::i;:::-;35675:103;;;;-1:-1:-1;;;35675:103:0;;;;;;;:::i;:::-;35791:28;35801:4;35807:2;35811:7;35791:9;:28::i;35898:185::-;36036:39;36053:4;36059:2;36063:7;36036:39;;;;;;;;;;;;:16;:39::i;32873:239::-;32945:7;32981:16;;;:7;:16;;;;;;-1:-1:-1;;;;;32981:16:0;33016:19;33008:73;;;;-1:-1:-1;;;33008:73:0;;7709:2:1;33008:73:0;;;7691:21:1;7748:2;7728:18;;;7721:30;7787:34;7767:18;;;7760:62;-1:-1:-1;;;7838:18:1;;;7831:39;7887:19;;33008:73:0;7507:405:1;32603:208:0;32675:7;-1:-1:-1;;;;;32703:19:0;;32695:74;;;;-1:-1:-1;;;32695:74:0;;8119:2:1;32695:74:0;;;8101:21:1;8158:2;8138:18;;;8131:30;8197:34;8177:18;;;8170:62;-1:-1:-1;;;8248:18:1;;;8241:40;8298:19;;32695:74:0;7917:406:1;32695:74:0;-1:-1:-1;;;;;;32787:16:0;;;;;:9;:16;;;;;;;32603:208::o;13222:103::-;12644:6;;-1:-1:-1;;;;;12644:6:0;11375:10;12791:23;12783:68;;;;-1:-1:-1;;;12783:68:0;;;;;;;:::i;:::-;13287:30:::1;13314:1;13287:18;:30::i;:::-;13222:103::o:0;33348:104::-;33404:13;33437:7;33430:14;;;;;:::i;35031:155::-;35126:52;11375:10;35159:8;35169;35126:18;:52::i;:::-;35031:155;;:::o;36154:328::-;36329:41;11375:10;36362:7;36329:18;:41::i;:::-;36321:103;;;;-1:-1:-1;;;36321:103:0;;;;;;;:::i;:::-;36435:39;36449:4;36455:2;36459:7;36468:5;36435:13;:39::i;:::-;36154:328;;;;:::o;49437:366::-;38057:4;38081:16;;;:7;:16;;;;;;49546:13;;-1:-1:-1;;;;;38081:16:0;49577:60;;;;-1:-1:-1;;;49577:60:0;;8891:2:1;49577:60:0;;;8873:21:1;8930:2;8910:18;;;8903:30;8969:33;8949:18;;;8942:61;9020:18;;49577:60:0;8689:355:1;49577:60:0;49650:23;49676:18;;;:9;:18;;;;;49650:44;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;49705:18;49726:10;49406:15;;;;;;;;;;;;-1:-1:-1;;;49406:15:0;;;;;49325:104;49726:10;49705:31;;49778:4;49784:9;49761:33;;;;;;;;;:::i;:::-;;;;;;;;;;;;;49747:48;;;;49437:366;;;:::o;48216:380::-;12644:6;;-1:-1:-1;;;;;12644:6:0;11375:10;12791:23;12783:68;;;;-1:-1:-1;;;12783:68:0;;;;;;;:::i;:::-;48336:15:::1;48354:16;:14;:16::i;:::-;48336:34;;48413:15;;48403:7;:25;48381:117;;;::::0;-1:-1:-1;;;48381:117:0;;9726:2:1;48381:117:0::1;::::0;::::1;9708:21:1::0;9765:2;9745:18;;;9738:30;9804:34;9784:18;;;9777:62;-1:-1:-1;;;9855:18:1;;;9848:40;9905:19;;48381:117:0::1;9524:406:1::0;48381:117:0::1;48511:39;48527:2;48531:7;48540:9;48511:15;:39::i;:::-;48561:27;:15;8110:19:::0;;8128:1;8110:19;;;8021:127;48604:111;48651:7;48678:25;:15;7991:14;;7899:114;48678:25;:29;;48706:1;48678:29;:::i;:::-;48671:36;;48604:111;:::o;13480:201::-;12644:6;;-1:-1:-1;;;;;12644:6:0;11375:10;12791:23;12783:68;;;;-1:-1:-1;;;12783:68:0;;;;;;;:::i;:::-;-1:-1:-1;;;;;13569:22:0;::::1;13561:73;;;::::0;-1:-1:-1;;;13561:73:0;;10402:2:1;13561:73:0::1;::::0;::::1;10384:21:1::0;10441:2;10421:18;;;10414:30;10480:34;10460:18;;;10453:62;-1:-1:-1;;;10531:18:1;;;10524:36;10577:19;;13561:73:0::1;10200:402:1::0;13561:73:0::1;13645:28;13664:8;13645:18;:28::i;:::-;13480:201:::0;:::o;32234:305::-;32336:4;-1:-1:-1;;;;;;32373:40:0;;-1:-1:-1;;;32373:40:0;;:105;;-1:-1:-1;;;;;;;32430:48:0;;-1:-1:-1;;;32430:48:0;32373:105;:158;;;-1:-1:-1;;;;;;;;;;25112:40:0;;;32495:36;25003:157;41974:174;42049:24;;;;:15;:24;;;;;:29;;-1:-1:-1;;;;;;42049:29:0;-1:-1:-1;;;;;42049:29:0;;;;;;;;:24;;42103:23;42049:24;42103:14;:23::i;:::-;-1:-1:-1;;;;;42094:46:0;;;;;;;;;;;41974:174;;:::o;38286:348::-;38379:4;38081:16;;;:7;:16;;;;;;-1:-1:-1;;;;;38081:16:0;38396:73;;;;-1:-1:-1;;;38396:73:0;;10809:2:1;38396:73:0;;;10791:21:1;10848:2;10828:18;;;10821:30;10887:34;10867:18;;;10860:62;-1:-1:-1;;;10938:18:1;;;10931:42;10990:19;;38396:73:0;10607:408:1;38396:73:0;38480:13;38496:23;38511:7;38496:14;:23::i;:::-;38480:39;;38549:5;-1:-1:-1;;;;;38538:16:0;:7;-1:-1:-1;;;;;38538:16:0;;:51;;;;38582:7;-1:-1:-1;;;;;38558:31:0;:20;38570:7;38558:11;:20::i;:::-;-1:-1:-1;;;;;38558:31:0;;38538:51;:87;;;-1:-1:-1;;;;;;35378:25:0;;;35354:4;35378:25;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;38593:32;38530:96;38286:348;-1:-1:-1;;;;38286:348:0:o;41278:578::-;41437:4;-1:-1:-1;;;;;41410:31:0;:23;41425:7;41410:14;:23::i;:::-;-1:-1:-1;;;;;41410:31:0;;41402:85;;;;-1:-1:-1;;;41402:85:0;;11222:2:1;41402:85:0;;;11204:21:1;11261:2;11241:18;;;11234:30;11300:34;11280:18;;;11273:62;-1:-1:-1;;;11351:18:1;;;11344:39;11400:19;;41402:85:0;11020:405:1;41402:85:0;-1:-1:-1;;;;;41506:16:0;;41498:65;;;;-1:-1:-1;;;41498:65:0;;11632:2:1;41498:65:0;;;11614:21:1;11671:2;11651:18;;;11644:30;11710:34;11690:18;;;11683:62;-1:-1:-1;;;11761:18:1;;;11754:34;11805:19;;41498:65:0;11430:400:1;41498:65:0;41680:29;41697:1;41701:7;41680:8;:29::i;:::-;-1:-1:-1;;;;;41722:15:0;;;;;;:9;:15;;;;;:20;;41741:1;;41722:15;:20;;41741:1;;41722:20;:::i;:::-;;;;-1:-1:-1;;;;;;;41753:13:0;;;;;;:9;:13;;;;;:18;;41770:1;;41753:13;:18;;41770:1;;41753:18;:::i;:::-;;;;-1:-1:-1;;41782:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;41782:21:0;-1:-1:-1;;;;;41782:21:0;;;;;;;;;41821:27;;41782:16;;41821:27;;;;;;;41278:578;;;:::o;13841:191::-;13934:6;;;-1:-1:-1;;;;;13951:17:0;;;-1:-1:-1;;;;;;13951:17:0;;;;;;;13984:40;;13934:6;;;13951:17;13934:6;;13984:40;;13915:16;;13984:40;13904:128;13841:191;:::o;42290:315::-;42445:8;-1:-1:-1;;;;;42436:17:0;:5;-1:-1:-1;;;;;42436:17:0;;;42428:55;;;;-1:-1:-1;;;42428:55:0;;12167:2:1;42428:55:0;;;12149:21:1;12206:2;12186:18;;;12179:30;12245:27;12225:18;;;12218:55;12290:18;;42428:55:0;11965:349:1;42428:55:0;-1:-1:-1;;;;;42494:25:0;;;;;;;:18;:25;;;;;;;;:35;;;;;;;;;;;;;:46;;-1:-1:-1;;42494:46:0;;;;;;;;;;42556:41;;540::1;;;42556::0;;513:18:1;42556:41:0;;;;;;;42290:315;;;:::o;37364:::-;37521:28;37531:4;37537:2;37541:7;37521:9;:28::i;:::-;37568:48;37591:4;37597:2;37601:7;37610:5;37568:22;:48::i;:::-;37560:111;;;;-1:-1:-1;;;37560:111:0;;;;;;;:::i;48723:261::-;48856:22;48866:2;48870:7;48856:9;:22::i;:::-;48889:18;;;;:9;:18;;;;;;;;:31;;;;;;;;:::i;:::-;;48968:7;48936:40;48949:17;48958:7;48949:8;:17::i;:::-;48936:40;;;;;;:::i;:::-;;;;;;;;48723:261;;;:::o;43170:799::-;43325:4;-1:-1:-1;;;;;43346:13:0;;15182:20;15230:8;43342:620;;43382:72;;-1:-1:-1;;;43382:72:0;;-1:-1:-1;;;;;43382:36:0;;;;;:72;;11375:10;;43433:4;;43439:7;;43448:5;;43382:72;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;-1:-1:-1;43382:72:0;;;;;;;;-1:-1:-1;;43382:72:0;;;;;;;;;;;;:::i;:::-;;;43378:529;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;-1:-1:-1;43624:13:0;;43620:272;;43667:60;;-1:-1:-1;;;43667:60:0;;;;;;;:::i;43620:272::-;43842:6;43836:13;43827:6;43823:2;43819:15;43812:38;43378:529;-1:-1:-1;;;;;;43505:51:0;-1:-1:-1;;;43505:51:0;;-1:-1:-1;43498:58:0;;43342:620;-1:-1:-1;43946:4:0;43170:799;;;;;;:::o;38976:110::-;39052:26;39062:2;39066:7;39052:26;;;;;;;;;;;;39443:18;39449:2;39453:7;39443:5;:18::i;:::-;39494:54;39525:1;39529:2;39533:7;39542:5;39494:22;:54::i;:::-;39472:154;;;;-1:-1:-1;;;39472:154:0;;;;;;;:::i;39970:382::-;-1:-1:-1;;;;;40050:16:0;;40042:61;;;;-1:-1:-1;;;40042:61:0;;13688:2:1;40042:61:0;;;13670:21:1;;;13707:18;;;13700:30;13766:34;13746:18;;;13739:62;13818:18;;40042:61:0;13486:356:1;40042:61:0;38057:4;38081:16;;;:7;:16;;;;;;-1:-1:-1;;;;;38081:16:0;:30;40114:58;;;;-1:-1:-1;;;40114:58:0;;14049:2:1;40114:58:0;;;14031:21:1;14088:2;14068:18;;;14061:30;14127;14107:18;;;14100:58;14175:18;;40114:58:0;13847:352:1;40114:58:0;-1:-1:-1;;;;;40243:13:0;;;;;;:9;:13;;;;;:18;;40260:1;;40243:13;:18;;40260:1;;40243:18;:::i;:::-;;;;-1:-1:-1;;40272:16:0;;;;:7;:16;;;;;;:21;;-1:-1:-1;;;;;;40272:21:0;-1:-1:-1;;;;;40272:21:0;;;;;;;;40311:33;;40272:16;;;40311:33;;40272:16;;40311:33;39970:382;;:::o;-1:-1:-1:-;;;;;;;:::i;:::-;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;:::i;:::-;;;:::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;:::-;384:5;150:245;-1:-1:-1;;;150:245:1:o;592:258::-;664:1;674:113;688:6;685:1;682:13;674:113;;;764:11;;;758:18;745:11;;;738:39;710:2;703:10;674:113;;;805:6;802:1;799:13;796:48;;;-1:-1:-1;;840:1:1;822:16;;815:27;592:258::o;855:::-;897:3;935:5;929:12;962:6;957:3;950:19;978:63;1034:6;1027:4;1022:3;1018:14;1011:4;1004:5;1000:16;978:63;:::i;:::-;1095:2;1074:15;-1:-1:-1;;1070:29:1;1061:39;;;;1102:4;1057:50;;855:258;-1:-1:-1;;855:258:1:o;1118:220::-;1267:2;1256:9;1249:21;1230:4;1287:45;1328:2;1317:9;1313:18;1305:6;1287:45;:::i;1343:180::-;1402:6;1455:2;1443:9;1434:7;1430:23;1426:32;1423:52;;;1471:1;1468;1461:12;1423:52;-1:-1:-1;1494:23:1;;1343:180;-1:-1:-1;1343:180:1:o;1736:173::-;1804:20;;-1:-1:-1;;;;;1853:31:1;;1843:42;;1833:70;;1899:1;1896;1889:12;1833:70;1736:173;;;:::o;1914:254::-;1982:6;1990;2043:2;2031:9;2022:7;2018:23;2014:32;2011:52;;;2059:1;2056;2049:12;2011:52;2082:29;2101:9;2082:29;:::i;:::-;2072:39;2158:2;2143:18;;;;2130:32;;-1:-1:-1;;;1914:254:1:o;2173:328::-;2250:6;2258;2266;2319:2;2307:9;2298:7;2294:23;2290:32;2287:52;;;2335:1;2332;2325:12;2287:52;2358:29;2377:9;2358:29;:::i;:::-;2348:39;;2406:38;2440:2;2429:9;2425:18;2406:38;:::i;:::-;2396:48;;2491:2;2480:9;2476:18;2463:32;2453:42;;2173:328;;;;;:::o;2506:186::-;2565:6;2618:2;2606:9;2597:7;2593:23;2589:32;2586:52;;;2634:1;2631;2624:12;2586:52;2657:29;2676:9;2657:29;:::i;2879:347::-;2944:6;2952;3005:2;2993:9;2984:7;2980:23;2976:32;2973:52;;;3021:1;3018;3011:12;2973:52;3044:29;3063:9;3044:29;:::i;:::-;3034:39;;3123:2;3112:9;3108:18;3095:32;3170:5;3163:13;3156:21;3149:5;3146:32;3136:60;;3192:1;3189;3182:12;3136:60;3215:5;3205:15;;;2879:347;;;;;:::o;3231:127::-;3292:10;3287:3;3283:20;3280:1;3273:31;3323:4;3320:1;3313:15;3347:4;3344:1;3337:15;3363:631;3427:5;3457:18;3498:2;3490:6;3487:14;3484:40;;;3504:18;;:::i;:::-;3579:2;3573:9;3547:2;3633:15;;-1:-1:-1;;3629:24:1;;;3655:2;3625:33;3621:42;3609:55;;;3679:18;;;3699:22;;;3676:46;3673:72;;;3725:18;;:::i;:::-;3765:10;3761:2;3754:22;3794:6;3785:15;;3824:6;3816;3809:22;3864:3;3855:6;3850:3;3846:16;3843:25;3840:45;;;3881:1;3878;3871:12;3840:45;3931:6;3926:3;3919:4;3911:6;3907:17;3894:44;3986:1;3979:4;3970:6;3962;3958:19;3954:30;3947:41;;;;3363:631;;;;;:::o;3999:666::-;4094:6;4102;4110;4118;4171:3;4159:9;4150:7;4146:23;4142:33;4139:53;;;4188:1;4185;4178:12;4139:53;4211:29;4230:9;4211:29;:::i;:::-;4201:39;;4259:38;4293:2;4282:9;4278:18;4259:38;:::i;:::-;4249:48;;4344:2;4333:9;4329:18;4316:32;4306:42;;4399:2;4388:9;4384:18;4371:32;4426:18;4418:6;4415:30;4412:50;;;4458:1;4455;4448:12;4412:50;4481:22;;4534:4;4526:13;;4522:27;-1:-1:-1;4512:55:1;;4563:1;4560;4553:12;4512:55;4586:73;4651:7;4646:2;4633:16;4628:2;4624;4620:11;4586:73;:::i;:::-;4576:83;;;3999:666;;;;;;;:::o;4670:524::-;4748:6;4756;4809:2;4797:9;4788:7;4784:23;4780:32;4777:52;;;4825:1;4822;4815:12;4777:52;4848:29;4867:9;4848:29;:::i;:::-;4838:39;;4928:2;4917:9;4913:18;4900:32;4955:18;4947:6;4944:30;4941:50;;;4987:1;4984;4977:12;4941:50;5010:22;;5063:4;5055:13;;5051:27;-1:-1:-1;5041:55:1;;5092:1;5089;5082:12;5041:55;5115:73;5180:7;5175:2;5162:16;5157:2;5153;5149:11;5115:73;:::i;:::-;5105:83;;;4670:524;;;;;:::o;5199:260::-;5267:6;5275;5328:2;5316:9;5307:7;5303:23;5299:32;5296:52;;;5344:1;5341;5334:12;5296:52;5367:29;5386:9;5367:29;:::i;:::-;5357:39;;5415:38;5449:2;5438:9;5434:18;5415:38;:::i;:::-;5405:48;;5199:260;;;;;:::o;5464:380::-;5543:1;5539:12;;;;5586;;;5607:61;;5661:4;5653:6;5649:17;5639:27;;5607:61;5714:2;5706:6;5703:14;5683:18;5680:38;5677:161;;;5760:10;5755:3;5751:20;5748:1;5741:31;5795:4;5792:1;5785:15;5823:4;5820:1;5813:15;5677:161;;5464:380;;;:::o;7089:413::-;7291:2;7273:21;;;7330:2;7310:18;;;7303:30;7369:34;7364:2;7349:18;;7342:62;-1:-1:-1;;;7435:2:1;7420:18;;7413:47;7492:3;7477:19;;7089:413::o;8328:356::-;8530:2;8512:21;;;8549:18;;;8542:30;8608:34;8603:2;8588:18;;8581:62;8675:2;8660:18;;8328:356::o;9049:470::-;9228:3;9266:6;9260:13;9282:53;9328:6;9323:3;9316:4;9308:6;9304:17;9282:53;:::i;:::-;9398:13;;9357:16;;;;9420:57;9398:13;9357:16;9454:4;9442:17;;9420:57;:::i;:::-;9493:20;;9049:470;-1:-1:-1;;;;9049:470:1:o;9935:127::-;9996:10;9991:3;9987:20;9984:1;9977:31;10027:4;10024:1;10017:15;10051:4;10048:1;10041:15;10067:128;10107:3;10138:1;10134:6;10131:1;10128:13;10125:39;;;10144:18;;:::i;:::-;-1:-1:-1;10180:9:1;;10067:128::o;11835:125::-;11875:4;11903:1;11900;11897:8;11894:34;;;11908:18;;:::i;:::-;-1:-1:-1;11945:9:1;;11835:125::o;12319:414::-;12521:2;12503:21;;;12560:2;12540:18;;;12533:30;12599:34;12594:2;12579:18;;12572:62;-1:-1:-1;;;12665:2:1;12650:18;;12643:48;12723:3;12708:19;;12319:414::o;12738:489::-;-1:-1:-1;;;;;13007:15:1;;;12989:34;;13059:15;;13054:2;13039:18;;13032:43;13106:2;13091:18;;13084:34;;;13154:3;13149:2;13134:18;;13127:31;;;12932:4;;13175:46;;13201:19;;13193:6;13175:46;:::i;:::-;13167:54;12738:489;-1:-1:-1;;;;;;12738:489:1:o;13232:249::-;13301:6;13354:2;13342:9;13333:7;13329:23;13325:32;13322:52;;;13370:1;13367;13360:12;13322:52;13402:9;13396:16;13421:30;13445:5;13421:30;:::i

ipfs://9fec2bf45adf3d9a616cb1a117fb2c6653b4cb79b0866939990ffa0fb7b02257