0x65784d6f23de30a17122e96c0f0986c378ed6947

deployer: unknown relevance score: 0 status: partially_identified bytecode: 14163 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 pausedd;
    bytes32 store_u;
    bytes32 store_r;
    uint256 public ethAvailableToWithdraw;
    bytes32 pauseda;
    bytes32 store_b;
    bool public paused;
    bytes32 pausedg;
    bytes32 store_c;
    bytes32 store_e;
    bytes32 pausede;
    uint256 store_f;
    bytes32 store_l;
    address store_h;
    bytes32 store_s;
    bytes32 pausedf;
    bytes32 store_i;
    mapping(bytes32 => bytes32) storage_map_n;
    address pausedi;
    bytes32 store_v;
    address public owner;
    bytes32 store_d;
    bytes32 pausedc;
    bytes public auctionConfig;
    bytes32 store_z;
    mapping(bytes32 => bytes32) storage_map_g;
    bytes32 store_w;
    mapping(bytes32 => bytes32) storage_map_t;
    bytes32 store_q;
    uint256 store_j;
    bytes32 pausedj;
    bytes32 store_y;
    bytes32 store_x;
    bytes32 pausedb;
    bytes32 pausedh;
    bytes32 store_o;
    
    event AuctionBatchBid(uint256[], address, bool, uint256[], bool[], uint256);
    event PreMint(uint256[]);
    event Transfer(address, address, uint256);
    event Paused(address);
    event AuctionBid(uint256, address, uint256, bool);
    event Unpaused(address);
    event AuctionExtended(uint256, uint256);
    event Withdraw(uint256);
    event OwnershipTransferred(address, address);
    
    /// @custom:selector    0x91b6145b
    /// @custom:signature   setReservePriceOverrides(uint256[] arg0, uint256[] arg1) public pure
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function setReservePriceOverrides(uint256[] arg0, uint256[] arg1) public pure {
        require(!arg0 > 0xffffffffffffffff);
        require(!(arg0) > 0xffffffffffffffff);
        require(!arg1 > 0xffffffffffffffff);
    }
    
    /// @custom:selector    0x998831e5
    /// @custom:signature   bidOnSingleApe(uint256 arg0) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function bidOnSingleApe(uint256 arg0) public payable {
        require(arg0 == arg0);
        require(!(bytes1(paused)), "Pausable: paused");
        require(store_b - 0x02, "ReentrancyGuard: reentrant call");
        store_b = 0x02;
        require(arg0 < 0x2710, "Bid failed");
        require(!((store_c) & (store_d > (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / (store_c)))), "Bid failed");
        require(0x64, "Bid failed");
        require(!(store_c > (~((store_c * store_d) / 0x64))), "Bid failed");
        require(!(store_e > 0), "Bid failed");
        require(!(store_f), "Bid failed");
        require(!(msg.value > (store_c + ((store_c * store_d) / 0x64))), "Bid failed");
        uint256 var_e = arg0;
        require(!(!address(storage_map_g[var_e])), "Bid failed");
        require(!(!address(storage_map_g[var_e])), "Bid failed");
        require(!(address(storage_map_g[var_e])), "Bid failed");
        require(0, "Bid failed");
        store_b = 0x01;
        require(0 - (store_e));
        require(!address(store_h));
        uint256 var_a = 0;
        uint256 var_h = var_h + 0x20;
        require(!0 > var_h.length);
        (bool success, bytes memory ret0) = address(store_h).transfer(store_f);
        require(ret0.length == 0);
        require(address(store_i).code.length);
        (bool success, bytes memory ret0) = address(store_i).{ value: store_f }deposit(); // call
        uint256 var_c = address(store_h);
        (bool success, bytes memory ret0) = address(store_i).{ value: var_a ether }Unresolved_a9059cbb(var_c); // call
        var_h = var_h + (uint248(ret0.length + 0x1f));
        require(!(((var_h + ret0.length) - var_h) < 0x20), "Bid failed");
        require(var_h.length == var_h.length, "Bid failed");
        store_f = msg.value;
        store_h = msg.sender | (uint96(store_h));
        require(!(store_j < block.timestamp), "Bid failed");
        require(!((store_j - block.timestamp) < auctionConfig), "Bid failed");
        require(!(block.timestamp > ~(auctionConfig)), "Bid failed");
        store_j = block.timestamp + auctionConfig;
        emit AuctionExtended(arg0, block.timestamp + auctionConfig);
        emit AuctionBid(arg0, address(store_h), store_f, ((store_j - block.timestamp) < auctionConfig));
        require(0x01, "Bid failed");
        store_b = 0x01;
        if (!store_j) {
            if (!block.timestamp < (store_l)) {
                if (block.timestamp < (store_l)) {
                    require(!store_j);
                    require(!block.timestamp < (store_l));
                    store_f = msg.value;
                    store_h = msg.sender | (uint96(store_h));
                    require(block.timestamp < (store_l));
                    require(0 - (store_e));
                    require(!(store_j) < block.timestamp);
                    var_e = arg0;
                    require(!(store_j - block.timestamp) < auctionConfig);
                    require(!block.timestamp > ~(auctionConfig));
                    require(address(storage_map_g[var_e]));
                    require(!store_j);
                    require(!block.timestamp < (store_l));
                    require(block.timestamp < (store_l));
                }
            }
            require(0 - (store_e));
        }
    }
    
    /// @custom:selector    0x660d016d
    /// @custom:signature   Unresolved_660d016d(uint256 arg0, uint256 arg1, uint256 arg2) public pure
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function Unresolved_660d016d(uint256 arg0, uint256 arg1, uint256 arg2) public pure {
        require(!arg0 > 0xffffffffffffffff);
        require(!((var_a + 0x0100) > 0xffffffffffffffff) | ((var_a + 0x0100) < var_a));
        uint256 var_a = var_a + 0x0100;
        require(arg0 == (address(arg0)));
        require(!(arg0 + 0x20) > 0xffffffffffffffff);
        require(!(arg0 + (arg0 + 0x20)) > 0xffffffffffffffff);
        require(!((var_a + (uint248((0x20 + (arg0 + (arg0 + 0x20) + 0x1f)) + 0x1f))) > 0xffffffffffffffff) | ((var_a + (uint248((0x20 + (arg0 + (arg0 + 0x20) + 0x1f)) + 0x1f))) < var_a));
        var_a = var_a + (uint248((0x20 + (arg0 + (arg0 + 0x20) + 0x1f)) + 0x1f));
        require(!(arg0 + 0x40) > 0xffffffffffffffff);
    }
    
    /// @custom:selector    0x095ea7b3
    /// @custom:signature   Unresolved_095ea7b3(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_095ea7b3(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
    
    /// @custom:selector    0xf1adad37
    /// @custom:signature   reservePriceOverrides(uint256 arg0) public view returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function reservePriceOverrides(uint256 arg0) public view returns (uint256) {
        require(arg0 == arg0);
        uint256 var_b = arg0;
        return storage_map_n[var_b];
    }
    
    /// @custom:selector    0xa9be1191
    /// @custom:signature   Unresolved_a9be1191(uint256 arg0) public pure
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_a9be1191(uint256 arg0) public pure {
        require(!((var_a + 0xa0) > 0xffffffffffffffff) | ((var_a + 0xa0) < var_a));
        require(arg0 == arg0);
    }
    
    /// @custom:selector    0x3ccfd60b
    /// @custom:signature   withdraw() public
    function withdraw() public {
        require(tx.origin == msg.sender, "No contracts");
        require(ethAvailableToWithdraw);
        emit Withdraw(ethAvailableToWithdraw);
        ethAvailableToWithdraw = 0;
        uint256 var_e = var_e + 0x20;
        require(!0 > var_e.length);
        (bool success, bytes memory ret0) = address(store_o).transfer(ethAvailableToWithdraw);
        require(ret0.length == 0);
        require(address(store_i).code.length);
        (bool success, bytes memory ret0) = address(store_i).{ value: ethAvailableToWithdraw }deposit(); // call
        address var_c = address(store_o);
        (bool success, bytes memory ret0) = address(store_i).{ value: ethAvailableToWithdraw ether }Unresolved_a9059cbb(var_c); // call
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!((var_e + ret0.length) - var_e) < 0x20);
        require(var_e.length == var_e.length);
    }
    
    /// @custom:selector    0x3f4ba83a
    /// @custom:signature   unpause() public
    function unpause() public {
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        require(bytes1(paused), "Pausable: not paused");
        paused = uint248(paused);
        emit Unpaused(address(msg.sender));
    }
    
    /// @custom:selector    0x01ffc9a7
    /// @custom:signature   Unresolved_01ffc9a7(uint32 arg0) public pure returns (bool)
    /// @param              arg0 ["uint32", "bytes4", "int32"]
    function Unresolved_01ffc9a7(uint32 arg0) public pure returns (bool) {
        require(arg0 == (uint32(arg0)));
        require(0x80ac58cd00000000000000000000000000000000000000000000000000000000 == (uint32(arg0)));
        require(0x80ac58cd00000000000000000000000000000000000000000000000000000000 == (uint32(arg0)));
        return !(!0x80ac58cd00000000000000000000000000000000000000000000000000000000 == (uint32(arg0)));
        return !(!(uint32(arg0)) == 0x01ffc9a700000000000000000000000000000000000000000000000000000000);
    }
    
    /// @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   Unresolved_c87b56dd(uint256 arg0) public view
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_c87b56dd(uint256 arg0) public view {
        require(arg0 == arg0);
        if (0 - arg0) {
            if (!arg0) {
                if (0x01) {
                    require(0 - arg0);
                    require(!arg0);
                    uint256 var_d = var_d + 0x20;
                    require(0x01);
                    require(0x0a);
                    require(!0 > 0xffffffffffffffff);
                    require(!0);
                    require(!arg0);
                    require(!0 < 0x01);
                    require(0x0a);
                    require(!0x30 > (~(arg0 % 0x0a)));
                    require(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff < var_d.length);
                    require(0x0a);
                    require(bytes1(store_q) - ((store_q / 0x02) < 0x20));
                    require(!bytes1(store_q));
                    require(bytes1(store_q) == 0x01);
                }
                require(!0 < (store_q / 0x02));
            }
        }
    }
    
    /// @custom:selector    0x2e993611
    /// @custom:signature   settleAuction(uint256 arg0) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function settleAuction(uint256 arg0) public {
        require(arg0 == arg0);
        require(store_b - 0x02, "ReentrancyGuard: reentrant call");
        store_b = 0x02;
        require(!(bytes1(paused)), "Pausable: paused");
        require(arg0 < 0x2710, "Auction already settled");
        uint256 var_e = arg0;
        require(!(address(storage_map_g[var_e])), "Auction already settled");
        require(0 - (var_q), "Auction hasn't completed");
        require(!(block.timestamp < (var_r)), "Auction hasn't completed");
        require(address(var_s), "ERC721: token already minted");
        var_e = arg0;
        require(!(address(storage_map_g[var_e])), "ERC721: token already minted");
        var_e = address(var_s);
        require(!(storage_map_g[var_e] > 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe), "ERC721: mint to the zero address");
    }
    
    /// @custom:selector    0xa22cb465
    /// @custom:signature   Unresolved_a22cb465(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_a22cb465(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
    
    /// @custom:selector    0x6352211e
    /// @custom:signature   Unresolved_6352211e(uint256 arg0) public view returns (address)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_6352211e(uint256 arg0) public view returns (address) {
        require(arg0 == arg0);
        uint256 var_a = arg0;
        require(address(storage_map_t[var_a]), "ERC721: invalid token ID");
        return address(storage_map_t[var_a]);
    }
    
    /// @custom:selector    0x06fdde03
    /// @custom:signature   Unresolved_06fdde03() public view returns (string memory)
    function Unresolved_06fdde03() public view returns (string memory) {
        if (store_u) {
            if (store_u - ((store_u / 0x02) < 0x20)) {
                uint256 var_c = var_c + (0x20 + (((0x1f + (store_u / 0x02)) / 0x20) * 0x20));
                if (store_u) {
                    if (store_u - ((store_u / 0x02) < 0x20)) {
                        if (!store_u / 0x02) {
                            if (0x1f < (store_u / 0x02)) {
                                var_a = 0x01;
                                if ((0x20 + var_c) + (store_u / 0x02) > (0x20 + (0x20 + var_c))) {
                                    if (!0 > var_c.length) {
                                        return abi.encodePacked(0x20, var_c.length);
                                        return abi.encodePacked(0x20, var_c.length);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0x95d89b41
    /// @custom:signature   Unresolved_95d89b41() public view returns (string memory)
    function Unresolved_95d89b41() public view returns (string memory) {
        if (store_y) {
            if (store_y - ((store_y / 0x02) < 0x20)) {
                uint256 var_c = var_c + (0x20 + (((0x1f + (store_y / 0x02)) / 0x20) * 0x20));
                if (store_y) {
                    if (store_y - ((store_y / 0x02) < 0x20)) {
                        if (!store_y / 0x02) {
                            if (0x1f < (store_y / 0x02)) {
                                var_a = 0x02;
                                if ((0x20 + var_c) + (store_y / 0x02) > (0x20 + (0x20 + var_c))) {
                                    if (!0 > var_c.length) {
                                        return abi.encodePacked(0x20, var_c.length);
                                        return abi.encodePacked(0x20, var_c.length);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0xe361c5a8
    /// @custom:signature   reservePrice(uint256 arg0) public view returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function reservePrice(uint256 arg0) public view returns (uint256) {
        require(arg0 == arg0);
        uint256 var_a = arg0;
        require(storage_map_t[var_a]);
        var_a = arg0;
        return storage_map_t[var_a];
        return store_v;
    }
    
    /// @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   Unresolved_081812fc(uint256 arg0) public view returns (address)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_081812fc(uint256 arg0) public view returns (address) {
        require(arg0 == arg0);
        uint256 var_a = arg0;
        require(address(storage_map_t[var_a]), "ERC721: invalid token ID");
        var_a = arg0;
        return address(storage_map_t[var_a]);
    }
    
    /// @custom:selector    0xcd1d894c
    /// @custom:signature   contractConfig() public view
    function contractConfig() public view {
        if (store_z) {
            if (store_z - ((store_z / 0x02) < 0x20)) {
                uint256 var_c = var_c + (0x20 + (((0x1f + (store_z / 0x02)) / 0x20) * 0x20));
                if (store_z) {
                    if (store_z - ((store_z / 0x02) < 0x20)) {
                        if (!store_z / 0x02) {
                            if (0x1f < (store_z / 0x02)) {
                                var_a = 0xc360;
                                if ((0x20 + var_c) + (store_z / 0x02) > (0x20 + (0x20 + var_c))) {
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    /// @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    0x70a08231
    /// @custom:signature   Unresolved_70a08231(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_70a08231(address arg0) public view returns (uint256) {
        require(arg0 == (address(arg0)));
        require(address(arg0), "ERC721: address zero is not a valid owner");
        address var_a = address(arg0);
        return storage_map_t[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(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        require(address(arg0), "Ownable: new owner is the zero address");
        owner = (address(arg0)) | (uint96(owner));
        emit OwnershipTransferred(address(owner), address(arg0));
    }
    
    /// @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    0x4f558e79
    /// @custom:signature   exists(uint256 arg0) public view returns (bool)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function exists(uint256 arg0) public view returns (bool) {
        require(arg0 == arg0);
        uint256 var_a = arg0;
        return !(!address(storage_map_t[var_a]));
    }
    
    /// @custom:selector    0x48f300fe
    /// @custom:signature   Unresolved_48f300fe(uint256 arg0, uint256 arg1) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_48f300fe(uint256 arg0, uint256 arg1) public {
        require(!arg0 > 0xffffffffffffffff);
        require(!(arg0) > 0xffffffffffffffff);
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        require(!(0 < (arg0)), "Can't premint after auction has started");
        require(0 < (arg0), "Can't premint after auction has started");
        require((0 + (arg0 + 0x20)) < 0x2710, "Can't premint after auction has started");
        require(!(pausedc), "Can't premint after auction has started");
        require(0 < (arg0), "ERC721: token already minted");
        require(address(pausedf / 0x01000000000000000000000000), "ERC721: token already minted");
        uint256 var_e = (0 + (arg0 + 0x20));
        require(!(address(storage_map_g[var_e])), "ERC721: token already minted");
        var_e = address(pausedf / 0x01000000000000000000000000);
        require(!(storage_map_g[var_e] > 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe), "ERC721: mint to the zero address");
        var_e = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        storage_map_g[var_e] = storage_map_g[var_e] + 0x01;
        var_e = (0 + (arg0 + 0x20));
        storage_map_g[var_e] = (address(pausedf / 0x01000000000000000000000000)) | (uint96(storage_map_g[var_e]));
        emit Transfer(0, address(pausedf / 0x01000000000000000000000000), (0 + (arg0 + 0x20)));
        require(0x01, "ERC721: mint to the zero address");
        require(!(arg0) > 0x07ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        emit PreMint(0x20, (arg0));
    }
    
    /// @custom:selector    0x571a26a0
    /// @custom:signature   auctions(uint256 arg0) public view returns (bytes memory)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function auctions(uint256 arg0) public view returns (bytes memory) {
        require(arg0 == arg0);
        require(arg0 < 0x2710);
        return abi.encodePacked(store_r, store_f, store_s, store_j, address(store_h));
    }
    
    /// @custom:selector    0x8456cb59
    /// @custom:signature   pause() public
    function pause() public {
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        require(!(bytes1(paused)), "Pausable: paused");
        paused = 0x01 | (uint248(paused));
        emit Paused(address(msg.sender));
    }
    
    /// @custom:selector    0x05ea9519
    /// @custom:signature   Unresolved_05ea9519(uint256 arg0, uint256 arg1) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_05ea9519(uint256 arg0, uint256 arg1) public {
        require(!arg0 > 0xffffffffffffffff);
        require(!(arg0) > 0xffffffffffffffff);
        require(!(bytes1(paused)), "ReentrancyGuard: reentrant call");
        require(store_b - 0x02, "ReentrancyGuard: reentrant call");
        store_b = 0x02;
        require(!(arg0) > 0xffffffffffffffff);
        require(!arg0);
        require(!(arg0) > 0xffffffffffffffff);
        require(!arg0);
        require(!0 < (arg0));
        require(0 < (arg0));
        require((0 + (arg0 + 0x20)) < 0x2710);
        require(!(pausedg) & (store_d > (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / (pausedg))));
        require(0x64);
        require(!(pausedg) > (~((pausedg * store_d) / 0x64)));
        require(!(pausedh) > 0);
        require(!pausedb);
        require(!0 > (pausedg + ((pausedg * store_d) / 0x64)));
        uint256 var_e = (0 + (arg0 + 0x20));
        require(address(storage_map_g[var_e]));
        require(address(storage_map_g[var_e]));
        require(!address(storage_map_g[var_e]));
        require(!0);
        require(!msg.value < 0);
        require(0x01);
        require(0 - (pausedh));
        require(!address(pausedi));
        uint256 var_k = 0;
        var_g = var_g + 0x20;
        require(!0 > var_g.length);
        (bool success, bytes memory ret0) = address(pausedi).transfer(pausedb);
        require(ret0.length == 0);
        require(address(store_i).code.length);
        (bool success, bytes memory ret0) = address(store_i).{ value: pausedb }deposit(); // call
        uint256 var_m = address(pausedi);
        (bool success, bytes memory ret0) = address(store_i).{ value: var_k ether }Unresolved_a9059cbb(var_m); // call
        var_g = var_g + (uint248(ret0.length + 0x1f));
        require(!((var_g + ret0.length) - var_g) < 0x20);
        require(var_g.length == var_g.length);
        pausedb = 0;
        pausedi = msg.sender | (uint96(pausedi));
        require(!(pausedd) < block.timestamp);
        require(!(pausedd - block.timestamp) < auctionConfig);
        require(!block.timestamp > ~(auctionConfig));
        pausedd = block.timestamp + auctionConfig;
        emit AuctionExtended((0 + (arg0 + 0x20)), block.timestamp + auctionConfig);
        emit AuctionBid((0 + (arg0 + 0x20)), address(pausedi), pausedb, ((pausedd - block.timestamp) < auctionConfig));
        require(!0x01);
        if (!pausedd) {
            if (!block.timestamp < (pausedj)) {
                if (block.timestamp < (pausedj)) {
                    require(!pausedd);
                    require(!block.timestamp < (pausedj));
                    pausedb = 0;
                    pausedi = msg.sender | (uint96(pausedi));
                    require(block.timestamp < (pausedj));
                    require(0 - (pausedh));
                    require(!(pausedd) < block.timestamp);
                    var_e = (0 + (arg0 + 0x20));
                    require(!(pausedd - block.timestamp) < auctionConfig);
                    require(!block.timestamp > ~(auctionConfig));
                    require(address(storage_map_g[var_e]));
                    require(!pausedd);
                    require(!block.timestamp < (pausedj));
                    require(block.timestamp < (pausedj));
                }
            }
            require(0 - (pausedh));
        }
        require(0);
        require(!(arg0) > 0x07ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        var_r = msg.data[36:36];
        emit AuctionBatchBid(keccak256(var_r), address(msg.sender), 0, (var_g + 0xa0) - var_g, (0x20 + (var_g + 0xa0)) - var_g, 0, var_g.length, var_g.length);
        store_b = 0x01;
    }
    
    /// @custom:selector    0x715018a6
    /// @custom:signature   renounceOwnership() public
    function renounceOwnership() public {
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        owner = 0 | (uint96(owner));
        emit OwnershipTransferred(address(owner), 0);
    }
}

ABI

[
  {
    "type": "function",
    "name": "Unresolved_01ffc9a7",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint32"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_05ea9519",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "Unresolved_06fdde03",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_081812fc",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_095ea7b3",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "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_48f300fe",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "Unresolved_6352211e",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_660d016d",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_70a08231",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_95d89b41",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_a22cb465",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_a9be1191",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_b88d4fde",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_c87b56dd",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_e985e9c5",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "auctionConfig",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "auctions",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "bidOnSingleApe",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "contractConfig",
    "inputs": [],
    "outputs": [],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "ethAvailableToWithdraw",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "exists",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "owner",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "pause",
    "inputs": [],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "paused",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "renounceOwnership",
    "inputs": [],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "reservePrice",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "reservePriceOverrides",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "setReservePriceOverrides",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256[]"
      },
      {
        "name": "arg1",
        "type": "uint256[]"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "settleAuction",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "transferOwnership",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "unpause",
    "inputs": [],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "withdraw",
    "inputs": [],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "event",
    "name": "AuctionBatchBid",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256[]",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg2",
        "type": "bool",
        "indexed": false
      },
      {
        "name": "arg3",
        "type": "uint256[]",
        "indexed": false
      },
      {
        "name": "arg4",
        "type": "bool[]",
        "indexed": false
      },
      {
        "name": "arg5",
        "type": "uint256",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "AuctionBid",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg2",
        "type": "uint256",
        "indexed": false
      },
      {
        "name": "arg3",
        "type": "bool",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "AuctionExtended",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "uint256",
        "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": "Paused",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "PreMint",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256[]",
        "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
  },
  {
    "type": "event",
    "name": "Unpaused",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Withdraw",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256",
        "indexed": false
      }
    ],
    "anonymous": false
  }
]

UNKNOWN SELECTORS (13)

0x0a85bd01unknown
0xf1adad37unknown
0x80ac58cdunknown
0xe361c5a8unknown
0x5b5e139funknown
0x72657373unknown
0xcd1d894cunknown
0x48f300feunknown
0xa9be1191unknown
0x0d0e30dbunknown
0x91b6145bunknown
0x05ea9519unknown
0x660d016dunknown
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)