0x31385d3520bced94f77aae104b406994d8f2168c

deployer: unknown relevance score: 10 status: identified bytecode: 18017 bytes

DECOMPILED SOLIDITY (Heimdall)

// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

/// @title            Decompiled Contract
/// @author           Jonathan Becker <jonathan@jbecker.dev>
/// @custom:version   heimdall-rs v0.9.2
///
/// @notice           This contract was decompiled using the heimdall-rs decompiler.
///                     It was generated directly by tracing the EVM opcodes from this contract.
///                     As a result, it may not compile or even be valid solidity code.
///                     Despite this, it should be obvious what each function does. Overall
///                     logic should have been preserved throughout decompiling.
///
/// @custom:github    You can find the open-source decompiler here:
///                       https://heimdall.rs

contract DecompiledContract {
    uint256 public constant MAX_BASTARDS = 11305;
    
    bool public hasSaleStarted;
    mapping(bytes32 => bytes32) storage_map_f;
    mapping(bytes32 => bytes32) storage_map_o;
    mapping(bytes32 => bytes32) storage_map_h;
    bytes32 store_m;
    uint256 store_n;
    bytes32 store_j;
    uint256 public totalSupply;
    mapping(bytes32 => bytes32) storage_map_k;
    mapping(bytes32 => bytes32) storage_map_i;
    mapping(bytes32 => bytes32) storage_map_b;
    address storage_map_l[(0x02 * (storage_map_k[var_g] - 0x01)) + keccak256(var_g)];
    uint256 store_g;
    mapping(bytes32 => bytes32) storage_map_e;
    mapping(bytes32 => bytes32) storage_map_l;
    mapping(bytes32 => bytes32) storage_map_c;
    
    event Approval(address, address, uint256);
    event Transfer(address, address, uint256);
    event ApprovalForAll(address, address, bool);
    event OwnershipTransferred(address, address);
    
    /// @custom:selector    0x095ea7b3
    /// @custom:signature   approve(address arg0, uint256 arg1) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function approve(address arg0, uint256 arg1) public {
        require(arg0 == (address(arg0)));
        require(arg1 == arg1);
        uint256 var_d = arg1 << 0;
        require(!(storage_map_b[var_d] == 0), "");
        require(!(storage_map_b[var_d] < 0x01), "");
        require((storage_map_b[var_d] - 0x01) < totalSupply, "");
        var_d = 0x02;
        require(!(address(arg0) == (address(storage_map_c[(0x02 * (storage_map_b[var_d] - 0x01)) + keccak256(var_d)] >> 0))), "");
        require(address(msg.sender) == (address(storage_map_c[(0x02 * (storage_map_b[var_d] - 0x01)) + keccak256(var_d)] >> 0)), "");
        var_d = address(msg.sender);
        require(bytes1(storage_map_b[var_d] / 0x01), "");
        var_d = arg1;
        storage_map_b[var_d] = (address(arg0) * 0x01) | (uint96(storage_map_b[var_d]));
        var_a = 0x60 + var_a;
        var_d = arg1 << 0;
        require(!(storage_map_b[var_d] == 0), "");
        require(!(storage_map_b[var_d] < 0x01), "");
        require((storage_map_b[var_d] - 0x01) < totalSupply, "");
        var_d = 0x02;
        emit Approval(address(storage_map_c[(0x02 * (storage_map_b[var_d] - 0x01)) + keccak256(var_d)] >> 0), address(arg0), arg1);
        var_d = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(!(0 > var_a.length), "");
        require(address(msg.sender) == (address(storage_map_c[(0x02 * (storage_map_b[var_d] - 0x01)) + keccak256(var_d)] >> 0)), "ERC721: approve caller is not owner nor approved for all");
    }
    
    /// @custom:selector    0x715018a6
    /// @custom:signature   renounceOwnership() public
    function renounceOwnership() public {
        require(address(hasSaleStarted / 0x01) == (address(msg.sender)), "Ownable: caller is not the owner");
        emit OwnershipTransferred(address(hasSaleStarted / 0x01), 0);
        hasSaleStarted = 0 | (uint96(hasSaleStarted));
    }
    
    /// @custom:selector    0x2f745c59
    /// @custom:signature   tokenOfOwnerByIndex(address arg0, uint256 arg1) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function tokenOfOwnerByIndex(address arg0, uint256 arg1) public view returns (uint256) {
        require(arg0 == (address(arg0)));
        require(arg1 == arg1);
        address var_a = address(arg0);
        require(storage_map_e[0 + keccak256(var_a)] > arg1, "EnumerableSet: index out of bounds");
        require(arg1 < (storage_map_e[0 + keccak256(var_a)]), "EnumerableSet: index out of bounds");
        var_a = 0 + (0 + keccak256(var_a));
        return (storage_map_f[var_a]) >> 0;
    }
    
    /// @custom:selector    0x55f804b3
    /// @custom:signature   Unresolved_55f804b3(uint256 arg0) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_55f804b3(uint256 arg0) public {
        require(!arg0 > 0xffffffffffffffff);
        require(!(arg0 > 0xffffffffffffffff), "Ownable: caller is not the owner");
        require(!(((var_c + (uint248(((arg0 + 0x1f) + 0x20) + 0x1f))) > 0xffffffffffffffff) | ((var_c + (uint248(((arg0 + 0x1f) + 0x20) + 0x1f))) < var_c)), "Ownable: caller is not the owner");
        uint256 var_c = var_c + (uint248(((arg0 + 0x1f) + 0x20) + 0x1f));
        require(address(hasSaleStarted / 0x01) == (address(msg.sender)), "Ownable: caller is not the owner");
        require(bytes1(store_g));
        require(!(bytes1(store_g)) == ((store_g / 0x02) < 0x20));
        var_a = 0x09;
        require(var_c.length);
        require(0x1f < var_c.length);
        store_g = 0x01 + (var_c.length + var_c.length);
        require(!var_c.length);
        require(!((0x20 + var_c) + var_c.length) > (0x20 + var_c));
        require(!(keccak256(var_a) + ((0x1f + (store_g / 0x02)) / 0x20)) > keccak256(var_a));
    }
    
    /// @custom:selector    0x01ffc9a7
    /// @custom:signature   supportsInterface(bytes4 arg0) public view returns (bool)
    /// @param              arg0 ["uint32", "bytes4", "int32"]
    function supportsInterface(bytes4 arg0) public view returns (bool) {
        require(arg0 == (uint32(arg0)));
        uint32 var_a = uint32(arg0);
        return !(!bytes1(storage_map_h[var_a] / 0x01));
    }
    
    /// @custom:selector    0xe985e9c5
    /// @custom:signature   Unresolved_e985e9c5(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_e985e9c5(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
    
    /// @custom:selector    0xc87b56dd
    /// @custom:signature   tokenURI(uint256 arg0) public view
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function tokenURI(uint256 arg0) public view {
        require(arg0 == arg0);
        uint256 var_a = arg0 << 0;
        if (!storage_map_h[var_a] == 0) {
            var_a = arg0;
            require(!(storage_map_h[var_a] == 0), "ERC721Metadata: URI query for nonexistent token");
            require(bytes1(storage_map_h[var_a]), "ERC721Metadata: URI query for nonexistent token");
            var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
            uint256 var_d = var_d + (0x20 + (((0x1f + (storage_map_h[var_a] / 0x02)) / 0x20) * 0x20));
            require(!(bytes1(storage_map_h[var_a]) == ((storage_map_h[var_a] / 0x02) < 0x20)), "ERC721Metadata: URI query for nonexistent token");
            require(bytes1(storage_map_h[var_a]), "ERC721Metadata: URI query for nonexistent token");
            var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
            require(!(bytes1(storage_map_h[var_a]) == ((storage_map_h[var_a] / 0x02) < 0x20)), "ERC721Metadata: URI query for nonexistent token");
            require(!(storage_map_h[var_a] / 0x02), "ERC721Metadata: URI query for nonexistent token");
            var_a = keccak256(var_a);
            require(0x1f < (storage_map_h[var_a] / 0x02), "ERC721Metadata: URI query for nonexistent token");
        }
    }
    
    /// @custom:selector    0x2808c92c
    /// @custom:signature   pauseDrop() public
    function pauseDrop() public {
        require(address(hasSaleStarted / 0x01) == (address(msg.sender)), "Ownable: caller is not the owner");
        hasSaleStarted = (0 * 0x010000000000000000000000000000000000000000) | (uint248(hasSaleStarted));
    }
    
    /// @custom:selector    0xa22cb465
    /// @custom:signature   Unresolved_a22cb465(address arg0, uint256 arg1) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_a22cb465(address arg0, uint256 arg1) public {
        require(arg0 == (address(arg0)));
        require(arg1 == arg1);
        require(!(address(arg0) == (address(msg.sender))), "ERC721: approve to caller");
        var_a = address(arg0);
        storage_map_h[var_a] = (arg1 * 0x01) | (uint248(storage_map_h[var_a]));
        emit ApprovalForAll(address(msg.sender), address(arg0), arg1);
    }
    
    /// @custom:selector    0x6352211e
    /// @custom:signature   ownerOf(uint256 arg0) public view returns (address)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function ownerOf(uint256 arg0) public view returns (address) {
        require(arg0 == arg0);
        uint256 var_a = 0x60 + var_a;
        uint256 var_d = arg0 << 0;
        require(!(storage_map_b[var_d] == 0), "");
        require(!(storage_map_b[var_d] < 0x01), "");
        require((storage_map_b[var_d] - 0x01) < totalSupply, "");
        var_d = 0x02;
        return address(storage_map_c[(0x02 * (storage_map_b[var_d] - 0x01)) + keccak256(var_d)] >> 0);
        require(!(0 > var_a.length), "");
    }
    
    /// @custom:selector    0x4f6ccce7
    /// @custom:signature   tokenByIndex(uint256 arg0) public view returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function tokenByIndex(uint256 arg0) public view returns (uint256) {
        require(arg0 == arg0);
        require(totalSupply > arg0, "EnumerableMap: index out of bounds");
        require(arg0 < totalSupply, "EnumerableMap: index out of bounds");
        var_a = 0x02;
        return (storage_map_i[(0x02 * arg0) + keccak256(var_a)]) >> 0;
    }
    
    /// @custom:selector    0x06fdde03
    /// @custom:signature   name() public view returns (string memory)
    function name() public view returns (string memory) {
        if (store_j) {
            if (!(store_j) == ((store_j / 0x02) < 0x20)) {
                uint256 var_c = var_c + (0x20 + (((0x1f + (store_j / 0x02)) / 0x20) * 0x20));
                if (store_j) {
                    if (!(store_j) == ((store_j / 0x02) < 0x20)) {
                        if (!store_j / 0x02) {
                            if (0x1f < (store_j / 0x02)) {
                                var_a = 0x06;
                                if ((0x20 + var_c) + (store_j / 0x02) > (0x20 + (0x20 + var_c))) {
                                    if (!0 > var_c.length) {
                                        return abi.encodePacked((var_c + 0x20) - var_c, var_c.length);
                                        return abi.encodePacked((var_c + 0x20) - var_c, var_c.length);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0x6863c4f4
    /// @custom:signature   adoptBASTARD(uint256 arg0) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function adoptBASTARD(uint256 arg0) public payable {
        require(arg0 == arg0);
        require(totalSupply < 0x2c29, "Sale has already ended");
        require(!(arg0 > 0), "You can adopt minimum 1, maximum 20 bastards");
        require(!(arg0 > 0x14), "You can adopt minimum 1, maximum 20 bastards");
        require(!(totalSupply > (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff - arg0)), "Exceeds MAX_BASTARDS");
        require(!((totalSupply + arg0) > 0x2c29), "Exceeds MAX_BASTARDS");
        require((bytes1(hasSaleStarted / 0x010000000000000000000000000000000000000000)) == 0x01, "Sale has already ended");
        require(totalSupply < 0x2c29, "Sale has already ended");
        require(!(totalSupply == 0x2c28), "Ether value sent is below the price");
        require(!(0x8ac7230489e80000 & (arg0 > 0x01d83c94fb6d2ac34a5663d3c7a0d865ca3c4ca40e0ea7cfe9)), "Ether value sent is below the price");
        require(!(msg.value < (0x8ac7230489e80000 * arg0)), "Ether value sent is below the price");
        require(!(0 < arg0), "ERC721: token already minted");
        uint256 var_c = 0x20 + var_c;
        require(!(address(msg.sender) == 0), "ERC721: token already minted");
        bytes32 var_g = totalSupply << 0;
        require(!(!storage_map_k[var_g] == 0), "ERC721: token already minted");
        var_g = totalSupply << 0;
        require(!(storage_map_k[var_g] == 0), "ERC721: transfer to non ERC721Receiver implementer");
        var_g = totalSupply << 0;
        require(!(storage_map_k[var_g] == 0), "ERC721: transfer to non ERC721Receiver implementer");
        require(!(storage_map_k[var_g] < 0x01), "ERC721: transfer to non ERC721Receiver implementer");
        require((storage_map_k[var_g] - 0x01) < totalSupply, "ERC721: transfer to non ERC721Receiver implementer");
        var_g = 0x02;
        storage_map_l[(0x02 * (storage_map_k[var_g] - 0x01)) + keccak256(var_g)] = (address(msg.sender)) << 0;
        emit Transfer(0, address(msg.sender), totalSupply);
        require(!(address(msg.sender).code.length > 0), "ERC721: transfer to non ERC721Receiver implementer");
        require(0x01, "ERC721: transfer to non ERC721Receiver implementer");
        require(!0 == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        var_d = address(msg.sender);
        require(!0 > var_c.length);
        uint256 var_m = 0;
        require(address(msg.sender).code.length);
        (bool success, bytes memory ret0) = address(msg.sender).{ value: var_m ether }Unresolved_150b7a02(var_d); // call
        require(ret0.length == 0);
        require(!var_n == 0);
        var_c = var_c + (uint248(ret0.length + 0x3f));
        require(!(var_c.length == 0), "ERC721: transfer to non ERC721Receiver implementer");
        var_c = var_c + (uint248(ret0.length + 0x1f));
        require(!((var_c + ret0.length) - var_c) < 0x20);
        require(var_p == (uint32(var_p)));
        require(0x01);
        require(ret0.length == 0);
        require(!var_n == 0);
        var_c = var_c + (uint248(ret0.length + 0x3f));
        require(!(var_c.length == 0), "ERC721: transfer to non ERC721Receiver implementer");
        require(totalSupply < 0x2c24, "Sale hasn't started");
        require(totalSupply < 0x2af8, "Sale hasn't started");
        require(totalSupply < 0x2710, "Sale hasn't started");
        require(totalSupply < 0x1388, "Sale hasn't started");
        require(0x64, "Sale hasn't started");
        require(!((totalSupply / 0x64) & (0x1717b72f0a4000 > (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / (totalSupply / 0x64)))), "Sale hasn't started");
        require(arg0 > 0, "You can adopt minimum 1, maximum 20 bastards");
    }
    
    /// @custom:selector    0x95d89b41
    /// @custom:signature   symbol() public view returns (string memory)
    function symbol() public view returns (string memory) {
        if (store_m) {
            if (!(store_m) == ((store_m / 0x02) < 0x20)) {
                uint256 var_c = var_c + (0x20 + (((0x1f + (store_m / 0x02)) / 0x20) * 0x20));
                if (store_m) {
                    if (!(store_m) == ((store_m / 0x02) < 0x20)) {
                        if (!store_m / 0x02) {
                            if (0x1f < (store_m / 0x02)) {
                                var_a = 0x07;
                                if ((0x20 + var_c) + (store_m / 0x02) > (0x20 + (0x20 + var_c))) {
                                    if (!0 > var_c.length) {
                                        return abi.encodePacked((var_c + 0x20) - var_c, var_c.length);
                                        return abi.encodePacked((var_c + 0x20) - var_c, var_c.length);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0x50d7c72d
    /// @custom:signature   calculatePriceTest(uint256 arg0) public pure returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function calculatePriceTest(uint256 arg0) public pure returns (uint256) {
        require(arg0 == arg0);
        require(arg0 < 0x2c29, "Sale has already ended");
        if (!arg0 == 0x2c28) {
            return 0x8ac7230489e80000;
            require(!arg0 == 0x2c28);
            return 0x29a2241af62c0000;
            require(arg0 < 0x2c24);
            require(arg0 < 0x2af8);
            require(!arg0 < 0x2af8);
            require(0x32);
            require(!((arg0 - 0x2af8) / 0x32) & (0x2386f26fc10000 > (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / ((arg0 - 0x2af8) / 0x32))));
            return 0x0bda0479ae2f0000 + (((arg0 - 0x2af8) / 0x32) * 0x2386f26fc10000);
            require(!0x0bda0479ae2f0000 > (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff - (((arg0 - 0x2af8) / 0x32) * 0x2386f26fc10000)));
            require(arg0 < 0x2710);
        }
    }
    
    /// @custom:selector    0xb88d4fde
    /// @custom:signature   Unresolved_b88d4fde(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_b88d4fde(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
    
    /// @custom:selector    0x081812fc
    /// @custom:signature   getApproved(uint256 arg0) public view returns (address)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function getApproved(uint256 arg0) public view returns (address) {
        require(arg0 == arg0);
        uint256 var_a = arg0 << 0;
        require(!(storage_map_h[var_a] == 0), "ERC721: approved query for nonexistent token");
        var_a = arg0;
        return address(storage_map_h[var_a] / 0x01);
    }
    
    /// @custom:selector    0x853828b6
    /// @custom:signature   withdrawAll() public payable
    function withdrawAll() public payable {
        require(address(hasSaleStarted / 0x01) == (address(msg.sender)), "Ownable: caller is not the owner");
        (bool success, bytes memory ret0) = address(msg.sender).transfer(address(this).balance);
    }
    
    /// @custom:selector    0x42842e0e
    /// @custom:signature   Unresolved_42842e0e(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_42842e0e(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
    
    /// @custom:selector    0x10969523
    /// @custom:signature   Unresolved_10969523(uint256 arg0) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_10969523(uint256 arg0) public {
        require(!arg0 > 0xffffffffffffffff);
        require(!(arg0 > 0xffffffffffffffff), "Ownable: caller is not the owner");
        require(!(((var_c + (uint248(((arg0 + 0x1f) + 0x20) + 0x1f))) > 0xffffffffffffffff) | ((var_c + (uint248(((arg0 + 0x1f) + 0x20) + 0x1f))) < var_c)), "Ownable: caller is not the owner");
        uint256 var_c = var_c + (uint248(((arg0 + 0x1f) + 0x20) + 0x1f));
        require(address(hasSaleStarted / 0x01) == (address(msg.sender)), "Ownable: caller is not the owner");
        require(bytes1(store_n));
        require(!(bytes1(store_n)) == ((store_n / 0x02) < 0x20));
        var_a = 0x0b;
        require(var_c.length);
        require(0x1f < var_c.length);
        store_n = 0x01 + (var_c.length + var_c.length);
        require(!var_c.length);
        require(!((0x20 + var_c) + var_c.length) > (0x20 + var_c));
        require(!(keccak256(var_a) + ((0x1f + (store_n / 0x02)) / 0x20)) > keccak256(var_a));
    }
    
    /// @custom:selector    0xf2fde38b
    /// @custom:signature   transferOwnership(address arg0) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function transferOwnership(address arg0) public {
        require(arg0 == (address(arg0)));
        require(address(hasSaleStarted / 0x01) == (address(msg.sender)), "Ownable: caller is not the owner");
        require(!(address(arg0) == 0), "Ownable: new owner is the zero address");
        emit OwnershipTransferred(address(hasSaleStarted / 0x01), address(arg0));
        hasSaleStarted = (address(arg0) * 0x01) | (uint96(hasSaleStarted));
    }
    
    /// @custom:selector    0x70a08231
    /// @custom:signature   balanceOf(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function balanceOf(address arg0) public view returns (uint256) {
        require(arg0 == (address(arg0)));
        require(!(address(arg0) == 0), "ERC721: balance query for the zero address");
        address var_a = address(arg0);
        return storage_map_e[0 + keccak256(var_a)];
    }
    
    /// @custom:selector    0x6c0360eb
    /// @custom:signature   baseURI() public view returns (bytes memory)
    function baseURI() public view returns (bytes memory) {
        if (store_g) {
            if (!(store_g) == ((store_g / 0x02) < 0x20)) {
                uint256 var_c = var_c + (0x20 + (((0x1f + (store_g / 0x02)) / 0x20) * 0x20));
                if (store_g) {
                    if (!(store_g) == ((store_g / 0x02) < 0x20)) {
                        if (!store_g / 0x02) {
                            if (0x1f < (store_g / 0x02)) {
                                var_a = 0x09;
                                if ((0x20 + var_c) + (store_g / 0x02) > (0x20 + (0x20 + var_c))) {
                                    if (!0 > var_c.length) {
                                        return abi.encodePacked((var_c + 0x20) - var_c, var_c.length);
                                        return abi.encodePacked((var_c + 0x20) - var_c, var_c.length);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0x23b872dd
    /// @custom:signature   Unresolved_23b872dd(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_23b872dd(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
    
    /// @custom:selector    0x8462151c
    /// @custom:signature   tokensOfOwner(address arg0) public view returns (bytes memory)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function tokensOfOwner(address arg0) public view returns (bytes memory) {
        require(arg0 == (address(arg0)));
        require(!(address(arg0) == 0), "EnumerableSet: index out of bounds");
        address var_a = address(arg0);
        require(!(storage_map_e[0 + keccak256(var_a)] == 0), "EnumerableSet: index out of bounds");
        require(!(storage_map_e[0 + keccak256(var_a)] > 0xffffffffffffffff), "EnumerableSet: index out of bounds");
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        address var_e = var_e + (0x20 + (0x20 * (storage_map_e[0 + keccak256(var_a)])));
        require(!(storage_map_e[0 + keccak256(var_a)]), "EnumerableSet: index out of bounds");
        require(!(0 < (storage_map_e[0 + keccak256(var_a)])), "EnumerableSet: index out of bounds");
        var_a = address(arg0);
        require(storage_map_e[0 + keccak256(var_a)] > 0, "EnumerableSet: index out of bounds");
        require(0 < (storage_map_e[0 + keccak256(var_a)]), "EnumerableSet: index out of bounds");
        var_a = 0 + (0 + keccak256(var_a));
        require(!(0 == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), "EnumerableSet: index out of bounds");
        return abi.encodePacked((var_e + 0x20) - var_e, var_e.length);
        if (!0 > 0xffffffffffffffff) {
            var_e = var_e + 0x20;
            require(!(0 > 0xffffffffffffffff), "ERC721: balance query for the zero address");
        }
    }
    
    /// @custom:selector    0xf0c9dc60
    /// @custom:signature   METADATA_PROVENANCE_HASH() public view returns (bytes memory)
    function METADATA_PROVENANCE_HASH() public view returns (bytes memory) {
        if (store_n) {
            if (!(store_n) == ((store_n / 0x02) < 0x20)) {
                uint256 var_c = var_c + (0x20 + (((0x1f + (store_n / 0x02)) / 0x20) * 0x20));
                if (store_n) {
                    if (!(store_n) == ((store_n / 0x02) < 0x20)) {
                        if (!store_n / 0x02) {
                            if (0x1f < (store_n / 0x02)) {
                                var_a = 0x0b;
                                if ((0x20 + var_c) + (store_n / 0x02) > (0x20 + (0x20 + var_c))) {
                                    if (!0 > var_c.length) {
                                        return abi.encodePacked((var_c + 0x20) - var_c, var_c.length);
                                        return abi.encodePacked((var_c + 0x20) - var_c, var_c.length);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0x34d84c7b
    /// @custom:signature   startDrop() public
    function startDrop() public {
        require(address(hasSaleStarted / 0x01) == (address(msg.sender)), "Ownable: caller is not the owner");
        hasSaleStarted = (0x01 * 0x010000000000000000000000000000000000000000) | (uint248(hasSaleStarted));
    }
}

ABI

[
  {
    "type": "function",
    "name": "MAX_BASTARDS",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "METADATA_PROVENANCE_HASH",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_10969523",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "Unresolved_23b872dd",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_42842e0e",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_55f804b3",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "Unresolved_a22cb465",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "Unresolved_b88d4fde",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_e985e9c5",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "adoptBASTARD",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "approve",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "balanceOf",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "baseURI",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "calculatePrice",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "calculatePriceTest",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "getApproved",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "hasSaleStarted",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "name",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "owner",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "ownerOf",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "pauseDrop",
    "inputs": [],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "renounceOwnership",
    "inputs": [],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "startDrop",
    "inputs": [],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "supportsInterface",
    "inputs": [
      {
        "name": "arg0",
        "type": "bytes4"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "symbol",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "tokenByIndex",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "tokenOfOwnerByIndex",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "tokenURI",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "tokensOfOwner",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "totalSupply",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "transferOwnership",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "withdrawAll",
    "inputs": [],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "event",
    "name": "Approval",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg2",
        "type": "uint256",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "ApprovalForAll",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg2",
        "type": "bool",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "OwnershipTransferred",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Transfer",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg2",
        "type": "uint256",
        "indexed": false
      }
    ],
    "anonymous": false
  }
]

UNKNOWN SELECTORS (0)

(none -- all recognized)
These selectors are not yet in the research database — they are being investigated and will be added as known functions once identified. They are also marked in red in the decompiled Solidity above.

KNOWN CLUSTER ADDRESSES IN THIS BYTECODE (0)

(none)