0x9251dec8df720c2adf3b6f46d968107cbbadf4d4

DECOMPILED SOLIDITY (Heimdall) VERIFY

// 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 maxSupply = 7331;
    
    mapping(bytes32 => bytes32) storage_map_c;
    mapping(bytes32 => bytes32) storage_map_f;
    uint256 public maxPerAllowList;
    bytes32 store_u;
    bytes32 store_m;
    mapping(bytes32 => bytes32) storage_map_s;
    bytes32 store_n;
    uint256 unresolved_18160ddda;
    mapping(bytes32 => bytes32) storage_map_j;
    bytes32 store_b;
    uint256 public unresolved_18160ddd;
    mapping(bytes32 => bytes32) storage_map_i;
    bool public isContractSealed;
    uint256 public publicMintPrice;
    bytes32 store_g;
    bytes32 store_h;
    bool public isOperatorFilterEnabled;
    mapping(bytes32 => bytes32) storage_map_x;
    bytes32 unresolved_18160dddf;
    bool public isAllowListActive;
    address public owner;
    bool public isPublicMintActive;
    uint256 store_k;
    uint256 public allowListPrice;
    bytes32 store_w;
    mapping(bytes32 => bytes32) storage_map_r;
    bytes32 store_q;
    uint256 store_y;
    mapping(bytes32 => bytes32) storage_map_p;
    uint256 public maxPerAddress;
    mapping(bytes32 => bytes32) storage_map_ag;
    bytes32 unresolved_18160dddb;
    bytes32 unresolved_18160dddh;
    bytes32 store_o;
    
    event Event_8c5be1e5();
    error MintZeroQuantity();
    event Transfer(address, address, uint256);
    event Event_17307eab();
    event OwnershipTransferred(address, address);
    
    /// @custom:selector    0x095ea7b3
    /// @custom:signature   Unresolved_095ea7b3(address arg0, uint256 arg1) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_095ea7b3(address arg0, uint256 arg1) public payable {
        require(arg0 == (address(arg0)));
        require(!(arg1 < unresolved_18160ddd), CustomError_df2d9b42());
        uint256 var_a = arg1;
        require(0 - (bytes1(storage_map_c[var_a])), CustomError_df2d9b42());
        require(0 - storage_map_c[var_a], CustomError_cfb3b942());
        require(address(storage_map_c[var_a]) == msg.sender, CustomError_cfb3b942());
        var_a = address(msg.sender);
        require(bytes1(storage_map_c[var_a]), CustomError_cfb3b942());
        var_a = arg1;
        storage_map_c[var_a] = (address(arg0)) | (uint96(storage_map_c[var_a]));
        emit Event_8c5be1e5(address(storage_map_c[var_a]), address(arg0), arg1);
        var_a = arg1;
        storage_map_c[var_a] = (address(arg0)) | (uint96(storage_map_c[var_a]));
        emit Event_8c5be1e5(address(storage_map_c[var_a]), address(arg0), arg1);
        var_a = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + arg1;
        if (0 - storage_map_c[var_a]) {
            var_a = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + arg1);
            if (0 - storage_map_c[var_a]) {
                var_a = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + arg1));
                if (0 - storage_map_c[var_a]) {
                }
            }
        }
    }
    
    /// @custom:selector    0xb4568066
    /// @custom:signature   Unresolved_b4568066(uint256 arg0, uint256 arg1, uint256 arg2) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function Unresolved_b4568066(uint256 arg0, uint256 arg1, uint256 arg2) public {
        require(!arg0 > 0xffffffffffffffff);
        require(!(arg0) > 0xffffffffffffffff);
        require(!((var_c + (uint248((0x20 + (arg0 << 0x05)) + 0x1f))) < var_c) | ((var_c + (uint248((0x20 + (arg0 << 0x05)) + 0x1f))) > 0xffffffffffffffff));
        uint256 var_c = var_c + (uint248((0x20 + (arg0 << 0x05)) + 0x1f));
        require(!((0x04 + arg0) + 0x20) < (0x20 + ((0x04 + arg0) + (arg0 << 0x05))));
        require(!(arg0 + 0x20) > 0xffffffffffffffff);
        require(!((var_c + 0x40) < var_c) | ((var_c + 0x40) > 0xffffffffffffffff));
        var_c = var_c + 0x40;
        require(!(arg0 + (arg0 + 0x20) + 0x20) > 0xffffffffffffffff);
        require(!(arg0 + (arg0 + 0x20) + (arg0 + (arg0 + 0x20) + 0x20) + 0x20) > 0xffffffffffffffff);
        require(!((var_c + (uint248((0x20 + ((arg0 + (arg0 + 0x20) + (arg0 + (arg0 + 0x20) + 0x20) + 0x20) << 0x05)) + 0x1f))) < var_c) | ((var_c + (uint248((0x20 + ((arg0 + (arg0 + 0x20) + (arg0 + (arg0 + 0x20) + 0x20) + 0x20) << 0x05)) + 0x1f))) > 0xffffffffffffffff));
        var_c = var_c + (uint248((0x20 + ((arg0 + (arg0 + 0x20) + (arg0 + (arg0 + 0x20) + 0x20) + 0x20) << 0x05)) + 0x1f));
        require(!(((0x04 + arg0) + (arg0 + 0x20) + (arg0 + (arg0 + 0x20) + 0x20) + 0x20) + 0x20) < (0x20 + (((0x04 + arg0) + (arg0 + 0x20) + (arg0 + (arg0 + 0x20) + 0x20) + 0x20) + ((arg0 + (arg0 + 0x20) + (arg0 + (arg0 + 0x20) + 0x20) + 0x20) << 0x05))));
        require(!(arg0 + (arg0 + 0x20) + 0x40) > 0xffffffffffffffff);
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        require(!(bytes1(isContractSealed)), "Contract is sealed");
        var_c = 0x40 + var_c;
        if (0 < (var_j)) {
            require(0 < (var_j));
            require(0x01 < (var_j));
            require(0 < (var_p));
            var_a = var_q;
            storage_map_c[var_a] = 0x02;
            var_a = keccak256(var_a);
            require(0x01 < (var_p));
            require(!0x02);
            require(!(keccak256(var_a) + storage_map_c[var_a]) > keccak256(var_a));
            var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
            require(0x01);
            storage_map_c[var_a] = var_c.length;
            require(!(var_c + 0x40) > var_c);
            storage_map_f[var_a] = var_r;
            require(!(var_c + 0x40) > (0x20 + var_c));
        }
    }
    
    /// @custom:selector    0x3ccfd60b
    /// @custom:signature   withdraw() public
    function withdraw() public {
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        require(store_g - 0x02, "ReentrancyGuard: reentrant call");
        store_g = 0x02;
        require(!(0x2710 < 0xfa), "Address: insufficient balance");
        require(!(address(this).balance & (0x2616 > (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / address(this).balance))), "Address: insufficient balance");
        require(0x2710, "Address: insufficient balance");
        require(!(address(this).balance < ((address(this).balance * 0x2616) / 0x2710)), "Address: insufficient balance");
        require(!(address(this).balance < (address(this).balance - ((address(this).balance * 0x2616) / 0x2710))), "Address: insufficient balance");
        (bool success, bytes memory ret0) = address(0xea208da933c43857683c04bc76e3fd331d7bfdf7).transfer(address(this).balance - ((address(this).balance * 0x2616) / 0x2710));
        require(ret0.length == 0, "Address: unable to send value, recipient may have reverted");
        require(!store_h, "Address: insufficient balance");
        require(!(0 < store_h), "Address: insufficient balance");
        require(0 < store_h, "Address: insufficient balance");
        var_e = 0x28;
        require(!(0 > (~(storage_map_i[0 + keccak256(var_e)]))), "Address: insufficient balance");
        require(0 < store_h, "Address: insufficient balance");
        require(0 < store_h, "Address: insufficient balance");
        var_e = 0x28;
        require(!(0x2710 < (storage_map_i[0 + keccak256(var_e)])), "Address: insufficient balance");
        var_e = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(!(((address(this).balance * 0x2616) / 0x2710) & ((0x2710 - (storage_map_i[0 + keccak256(var_e)])) > (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / ((address(this).balance * 0x2616) / 0x2710)))), "Address: insufficient balance");
        require(0x2710, "Address: insufficient balance");
        var_e = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(!(((address(this).balance * 0x2616) / 0x2710) < (((address(this).balance * 0x2616) / 0x2710) * (0x2710 - (storage_map_i[0 + keccak256(var_e)])) / 0x2710)), "Address: insufficient balance");
        var_e = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(!(address(this).balance < (((address(this).balance * 0x2616) / 0x2710) - (((address(this).balance * 0x2616) / 0x2710) * (0x2710 - (storage_map_i[0 + keccak256(var_e)])) / 0x2710))), "Address: insufficient balance");
        (bool success, bytes memory ret0) = address(storage_map_j[0 + keccak256(var_e)] / 0x01).transfer(((address(this).balance * 0x2616) / 0x2710) - (((address(this).balance * 0x2616) / 0x2710) * (0x2710 - (storage_map_i[0 + keccak256(var_e)])) / 0x2710));
        require(ret0.length == 0, "Address: unable to send value, recipient may have reverted");
        if (0x01) {
        }
    }
    
    /// @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((0x20 + (arg0 + 0x1f)) + 0x1f))) < var_c) | ((var_c + (uint248((0x20 + (arg0 + 0x1f)) + 0x1f))) > 0xffffffffffffffff)), "Ownable: caller is not the owner");
        uint256 var_c = var_c + (uint248((0x20 + (arg0 + 0x1f)) + 0x1f));
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        require(bytes1(store_k));
        require(bytes1(store_k) - ((store_k >> 0x01) < 0x20));
        var_a = 0x2c;
        require(var_c.length);
        require(0x1f < var_c.length);
        store_k = 0x01 + (var_c.length + var_c.length);
        require(!var_c.length);
        require(!((var_c + 0x20) + var_c.length) > (var_c + 0x20));
        require(!(keccak256(var_a) + ((0x1f + (store_k >> 0x01)) / 0x20)) > keccak256(var_a));
    }
    
    /// @custom:selector    0xda9e40ea
    /// @custom:signature   toggleOperatorFilter() public
    function toggleOperatorFilter() public {
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        isOperatorFilterEnabled = (!bytes1(isOperatorFilterEnabled)) | (uint248(isOperatorFilterEnabled));
    }
    
    /// @custom:selector    0xe8a3d485
    /// @custom:signature   contractURI() public view
    function contractURI() public view {
        uint256 var_a = var_a + 0xa0;
        if (store_m / 0x0a) {
            if (store_n) {
                if (store_n - ((store_n >> 0x01) < 0x20)) {
                    if (!store_n) {
                        if (store_n == 0x01) {
                            if (!0 < (store_n >> 0x01)) {
                                if (store_o) {
                                    if (store_o - ((store_o >> 0x01) < 0x20)) {
                                        if (!store_o) {
                                            if (store_o == 0x01) {
                                                if (!0 < (store_o >> 0x01)) {
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    /// @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(uint32(arg0) == 0x01ffc9a700000000000000000000000000000000000000000000000000000000);
        require(uint32(arg0) == 0x01ffc9a700000000000000000000000000000000000000000000000000000000);
        return !(!(uint32(arg0)) == 0x01ffc9a700000000000000000000000000000000000000000000000000000000);
        return !(!0x5b5e139f00000000000000000000000000000000000000000000000000000000 == (uint32(arg0)));
    }
    
    /// @custom:selector    0x66e33870
    /// @custom:signature   Unresolved_66e33870(uint256 arg0) public view returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_66e33870(uint256 arg0) public view returns (uint256) {
        require(!arg0 > 0xffffffffffffffff);
        if (!(arg0) > 0xffffffffffffffff) {
            require(!(arg0 > 0xffffffffffffffff), CustomError_626f756e());
            var_c = 0x40 + var_c;
            require(!(((var_c + (uint248((0x20 + (arg0 + 0x1f)) + 0x1f))) < var_c) | ((var_c + (uint248((0x20 + (arg0 + 0x1f)) + 0x1f))) > 0xffffffffffffffff)), CustomError_626f756e());
            require(!(var_j > ~(var_c.length)), CustomError_626f756e());
            require(!((var_j + var_c.length) > (var_k + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc0)), CustomError_626f756e());
            require(!((var_c + 0x20) < ((var_c + 0x20) + var_c.length)), CustomError_626f756e());
            require(!(0 < 0x06), CustomError_626f756e());
            require(!(0 < (var_j)), CustomError_626f756e());
            return ;
            return ;
            require(!(0 > (var_j)), CustomError_626f756e());
            require(!(0x03 & (0 > 0x5555555555555555555555555555555555555555555555555555555555555555)), CustomError_626f756e());
            require(!(0x03 & (0 > 0x5555555555555555555555555555555555555555555555555555555555555555)), CustomError_626f756e());
            require(!(0x03 > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), CustomError_626f756e());
            require(!(0x03 < 0), CustomError_626f756e());
            require(!(0x03 > 0xffffffffffffffff), CustomError_626f756e());
            require(!0x03, CustomError_626f756e());
            var_a = 0;
            require(!(0 < 0x03), CustomError_626f756e());
            require(0 - (bytes1(storage_map_p[var_a])), CustomError_626f756e());
            var_c = 0x40 + var_c;
            require(!0, CustomError_626f756e());
            require(!(var_j > ~(var_c.length)), CustomError_626f756e());
            require(!((var_j + var_c.length) > (var_k + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc0)), CustomError_626f756e());
            require(!((var_c + 0x20) < ((var_c + 0x20) + var_c.length)), CustomError_626f756e());
            var_a = 0;
            var_o = keccak256(var_a);
            require(0 < store_q, CustomError_626f756e());
            require(bytes1(storage_map_r[var_a]), CustomError_626f756e());
            var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
            require(bytes1(storage_map_r[var_a]) - ((storage_map_r[var_a] >> 0x01) < 0x20), CustomError_626f756e());
            require(!(bytes1(storage_map_r[var_a])), CustomError_626f756e());
            var_a = var_o + 0;
            require(bytes1(storage_map_r[var_a]) == 0x01, CustomError_626f756e());
            require(!(0 < (storage_map_r[var_a] >> 0x01)), CustomError_626f756e());
            require(bytes1(storage_map_c[var_a]), CustomError_626f756e());
            var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
            require(bytes1(storage_map_c[var_a]) - ((storage_map_c[var_a] >> 0x01) < 0x20), CustomError_626f756e());
            require(!(bytes1(storage_map_c[var_a])), CustomError_626f756e());
            var_a = keccak256(var_a);
            require(bytes1(storage_map_c[var_a]) == 0x01, CustomError_626f756e());
        }
        var_c = 0x02;
        require(!(var_j > ~(var_c.length)), CustomError_626f756e());
        if ((var_y >> 0xf8) < 0x30) {
            require((var_y >> 0xf8) < 0x30, CustomError_626f756e());
            require(!(!(var_y >> 0xf8) > 0x39), CustomError_626f756e());
            require(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01, CustomError_626f756e());
            require(!(0 & (0x0a > 0)), CustomError_626f756e());
            require(!(bytes1(var_y >> 0xf8) < 0x30), CustomError_626f756e());
            require(!(0 > (0xff - (bytes1((var_y >> 0xf8) - 0x30)))), CustomError_626f756e());
            require(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff01, CustomError_626f756e());
        }
        require(!(0 < 0), CustomError_626f756e());
        require(0x01, CustomError_626f756e());
    }
    
    /// @custom:selector    0x09dbabca
    /// @custom:signature   traitData(uint256 arg0, uint256 arg1) public view returns (bytes memory)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function traitData(uint256 arg0, uint256 arg1) public view returns (bytes memory) {
        uint256 var_a = arg0;
        require(arg1 < storage_map_c[var_a], CustomError_2c4a89fa());
        var_a = keccak256(var_a);
        require(0 - (address(storage_map_s[var_a]).code.length), CustomError_2c4a89fa());
        uint256 var_c = var_c + 0x20;
        require(!(0 > var_c.length), CustomError_2c4a89fa());
        return abi.encodePacked(0x20, var_c.length);
        return abi.encodePacked(0x20, var_c.length);
        require(!(0x01 > (address(storage_map_s[var_a]).code.length)), CustomError_2c4a89fa());
        require(!(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff < 0x01), CustomError_2c4a89fa());
        require((address(storage_map_s[var_a]).code.length - 0x01) < 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe);
        var_c = var_c + 0x20;
    }
    
    /// @custom:selector    0x7bddd65b
    /// @custom:signature   setMaxPerAddress(uint256 arg0) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function setMaxPerAddress(uint256 arg0) public {
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        maxPerAddress = arg0;
    }
    
    /// @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);
        var_a = address(arg0);
        storage_map_c[var_a] = arg1 | (uint248(storage_map_c[var_a]));
        emit Event_17307eab(msg.sender, address(arg0), arg1);
    }
    
    /// @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 < unresolved_18160ddd), CustomError_df2d9b42());
        uint256 var_a = arg0;
        require(0 - (bytes1(storage_map_c[var_a])), CustomError_df2d9b42());
        require(0 - storage_map_c[var_a], CustomError_df2d9b42());
        return address(storage_map_c[var_a]);
        var_a = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + arg0;
        require(0 - storage_map_c[var_a], CustomError_df2d9b42());
        return address(storage_map_c[var_a]);
        var_a = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + arg0);
        require(0 - storage_map_c[var_a], CustomError_df2d9b42());
        return address(storage_map_c[var_a]);
        var_a = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + arg0));
        require(0 - storage_map_c[var_a], CustomError_df2d9b42());
        return address(storage_map_c[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 >> 0x01) < 0x20)) {
                uint256 var_c = var_c + (0x20 + (((0x1f + (store_u >> 0x01)) / 0x20) * 0x20));
                if (store_u) {
                    if (store_u - ((store_u >> 0x01) < 0x20)) {
                        if (!store_u >> 0x01) {
                            if (0x1f < (store_u >> 0x01)) {
                                var_a = 0x02;
                                if ((0x20 + var_c) + (store_u >> 0x01) > (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_w) {
            if (store_w - ((store_w >> 0x01) < 0x20)) {
                uint256 var_c = var_c + (0x20 + (((0x1f + (store_w >> 0x01)) / 0x20) * 0x20));
                if (store_w) {
                    if (store_w - ((store_w >> 0x01) < 0x20)) {
                        if (!store_w >> 0x01) {
                            if (0x1f < (store_w >> 0x01)) {
                                var_a = 0x03;
                                if ((0x20 + var_c) + (store_w >> 0x01) > (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    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    0x876171dc
    /// @custom:signature   withdrawRecipients(uint256 arg0) public view
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function withdrawRecipients(uint256 arg0) public view {
        if (arg0 < store_h) {
            var_a = 0x28;
            require(arg0 < store_h);
            require(bytes1(storage_map_x[(0x04 * arg0) + keccak256(var_a)]));
            var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
            require(bytes1(storage_map_x[(0x04 * arg0) + keccak256(var_a)]) - ((storage_map_x[(0x04 * arg0) + keccak256(var_a)] >> 0x01) < 0x20));
            require(bytes1(storage_map_x[(0x04 * arg0) + keccak256(var_a)]));
            var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
            require(bytes1(storage_map_x[(0x04 * arg0) + keccak256(var_a)]) - ((storage_map_x[(0x04 * arg0) + keccak256(var_a)] >> 0x01) < 0x20));
            require(!(storage_map_x[(0x04 * arg0) + keccak256(var_a)]) >> 0x01);
            uint256 var_a = 0 + ((0x04 * arg0) + keccak256(var_a));
            require(0x1f < (storage_map_x[(0x04 * arg0) + keccak256(var_a)] >> 0x01));
        }
    }
    
    /// @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 < unresolved_18160ddd), CustomError_cf4700e4());
        uint256 var_a = arg0;
        require(!(bytes1(storage_map_c[var_a])), CustomError_cf4700e4());
        var_a = arg0;
        return address(storage_map_c[var_a]);
        require(arg0 < unresolved_18160ddd, CustomError_cf4700e4());
        var_a = arg0;
        return address(storage_map_c[var_a]);
    }
    
    /// @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    0x89ce3074
    /// @custom:signature   Unresolved_89ce3074(uint256 arg0) public view
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_89ce3074(uint256 arg0) public view {
        require(!arg0 > 0xffffffffffffffff);
        if (!(arg0) > 0xffffffffffffffff) {
            require(!(arg0 > 0xffffffffffffffff), CustomError_626f756e());
            var_e = msg.data[36:36];
            var_c = 0xc0 + var_c;
            require(!(((var_c + (uint248((0x20 + (arg0 + 0x1f)) + 0x1f))) < var_c) | ((var_c + (uint248((0x20 + (arg0 + 0x1f)) + 0x1f))) > 0xffffffffffffffff)), CustomError_626f756e());
            require(!(var_e > ~(var_c.length)), CustomError_626f756e());
            require(!((var_e + var_c.length) > (var_j + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc0)), CustomError_626f756e());
            require(!((var_c + 0x20) < ((var_c + 0x20) + var_c.length)), CustomError_626f756e());
            require(bytes1(store_y), CustomError_626f756e());
            require(bytes1(store_y) - ((store_y >> 0x01) < 0x20), CustomError_626f756e());
            require(!(bytes1(store_y)), CustomError_626f756e());
            require(bytes1(store_y) == 0x01, CustomError_626f756e());
        }
        var_c = 0x16;
        require(!(var_e > ~(var_c.length)), CustomError_626f756e());
    }
    
    /// @custom:selector    0x70a08231
    /// @custom:signature   Unresolved_70a08231(address arg0) public view returns (uint64)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_70a08231(address arg0) public view returns (uint64) {
        require(arg0 == (address(arg0)));
        require(address(arg0), CustomError_8f4eb604());
        address var_a = address(arg0);
        return uint64(storage_map_c[var_a]);
    }
    
    /// @custom:selector    0x180c2cc0
    /// @custom:signature   Unresolved_180c2cc0(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_180c2cc0(uint256 arg0, uint256 arg1, uint256 arg2) public pure {
        require(!arg2 > 0xffffffffffffffff);
        require(!((var_a + 0xc0) < var_a) | ((var_a + 0xc0) > 0xffffffffffffffff));
        uint256 var_a = var_a + 0xc0;
        require(!(arg2) > 0xffffffffffffffff);
        require(!(arg2 + (arg2)) > 0xffffffffffffffff);
        require(!((var_a + (uint248((0x20 + (arg2 + (arg2) + 0x1f)) + 0x1f))) < var_a) | ((var_a + (uint248((0x20 + (arg2 + (arg2) + 0x1f)) + 0x1f))) > 0xffffffffffffffff));
        var_a = var_a + (uint248((0x20 + (arg2 + (arg2) + 0x1f)) + 0x1f));
        require(!(arg2 + 0x20) > 0xffffffffffffffff);
    }
    
    /// @custom:selector    0xb32c5680
    /// @custom:signature   onAllowList(address arg0, bytes32[] arg1) public view returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function onAllowList(address arg0, bytes32[] arg1) public view returns (bool) {
        require(arg0 == (address(arg0)));
        require(!arg1 > 0xffffffffffffffff);
        require(!(arg1) > 0xffffffffffffffff);
        uint256 var_a = var_a + (0x20 + (0x20 * (arg1)));
        var_c = msg.data[36:36];
        require(keccak256(var_c) < (var_c));
        require(0x01);
        require(0x01);
        return !(!(keccak256(var_c)) == unresolved_18160ddda);
    }
    
    /// @custom:selector    0x97d194d7
    /// @custom:signature   Unresolved_97d194d7(uint256 arg0, uint256 arg1, uint256 arg2) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function Unresolved_97d194d7(uint256 arg0, uint256 arg1, uint256 arg2) public {
        require(!arg1 > 0xffffffffffffffff);
        require(!(arg1) > 0xffffffffffffffff);
        require(!((var_c + (uint248((0x20 + (arg1 << 0x05)) + 0x1f))) < var_c) | ((var_c + (uint248((0x20 + (arg1 << 0x05)) + 0x1f))) > 0xffffffffffffffff));
        uint256 var_c = var_c + (uint248((0x20 + (arg1 << 0x05)) + 0x1f));
        require(!((0x04 + arg1) + 0x20) < (0x20 + ((0x04 + arg1) + (arg1 << 0x05))));
        require(!(arg1 + 0x20) > 0xffffffffffffffff);
        require(!((var_c + 0xc0) < var_c) | ((var_c + 0xc0) > 0xffffffffffffffff));
        var_c = var_c + 0xc0;
        require(!(arg1 + (arg1 + 0x20) + 0x20) > 0xffffffffffffffff);
        require(!((arg1 + (arg1 + 0x20) + 0x20) + (arg1 + (arg1 + 0x20) + 0x20)) > 0xffffffffffffffff);
        require(!((var_c + (uint248((0x20 + ((arg1 + (arg1 + 0x20) + 0x20) + (arg1 + (arg1 + 0x20) + 0x20) + 0x1f)) + 0x1f))) < var_c) | ((var_c + (uint248((0x20 + ((arg1 + (arg1 + 0x20) + 0x20) + (arg1 + (arg1 + 0x20) + 0x20) + 0x1f)) + 0x1f))) > 0xffffffffffffffff));
        var_c = var_c + (uint248((0x20 + ((arg1 + (arg1 + 0x20) + 0x20) + (arg1 + (arg1 + 0x20) + 0x20) + 0x1f)) + 0x1f));
        require(!((arg1 + (arg1 + 0x20) + 0x20) + 0x20) > 0xffffffffffffffff);
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        require(!(bytes1(isContractSealed)), "Contract is sealed");
        require(arg0 < 0x06, "Traits size does not match tiers for this index");
        require(unresolved_18160dddb == var_c.length, "Traits size does not match tiers for this index");
        if (!var_c.length > 0xffffffffffffffff) {
            var_c = var_c + (0x20 + (0x20 * var_c.length));
            require(!(var_c.length > 0xffffffffffffffff), CustomError_08d4abb6());
            require(!var_c.length, CustomError_08d4abb6());
            require(!(var_n), CustomError_08d4abb6());
            var_c = 0x60 + var_c;
            var_a = 0;
            require(var_w < var_c.length, CustomError_08d4abb6());
            require(bytes1(storage_map_c[var_a]), CustomError_08d4abb6());
            var_a = keccak256(var_a);
            require(bytes1(storage_map_c[var_a]) - ((storage_map_c[var_a] >> 0x01) < 0x20), CustomError_08d4abb6());
            require(var_x, CustomError_08d4abb6());
            storage_map_c[var_a] = 0x01 + (var_x + var_x);
            require(0x1f < var_x, CustomError_08d4abb6());
            require(!var_x, CustomError_08d4abb6());
            require(!(((0x20 + var_c.length) + var_y) > (0x20 + var_c.length)), CustomError_08d4abb6());
        }
        require(!(0 < (var_z)), CustomError_08d4abb6());
        require(!(0 > (var_z)), CustomError_08d4abb6());
        var_c = 0x01 + (var_ab + (0x20 + var_c));
        require(!(0 > var_c.length), CustomError_08d4abb6());
        var_c = 0x0e + (var_c.length + (0x20 + var_c));
        assembly { addr := create(0, var_c + 0x20, var_c.length) }
        require(address(240), CustomError_08d4abb6());
        if (!0x20 > var_c.length) {
        }
        var_a = arg0;
        storage_map_c[var_a] = var_c.length;
        if (!var_c.length) {
            require(!var_c.length);
        }
    }
    
    /// @custom:selector    0x6df9fa88
    /// @custom:signature   setAllowListPrice(uint256 arg0) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function setAllowListPrice(uint256 arg0) public {
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        allowListPrice = arg0;
    }
    
    /// @custom:selector    0x8fb4e8a9
    /// @custom:signature   toggleAllowListMint() public
    function toggleAllowListMint() public {
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        isAllowListActive = (!bytes1(isAllowListActive)) | (uint248(isAllowListActive));
    }
    
    /// @custom:selector    0x7cb64759
    /// @custom:signature   setMerkleRoot(bytes32 arg0) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function setMerkleRoot(bytes32 arg0) public {
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        unresolved_18160ddda = arg0;
    }
    
    /// @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);
    }
    
    /// @custom:selector    0x4ca1a0f2
    /// @custom:signature   setMaxPerAllowList(uint256 arg0) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function setMaxPerAllowList(uint256 arg0) public {
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        unresolved_18160dddd = arg0;
    }
    
    /// @custom:selector    0x68bd580e
    /// @custom:signature   sealContract() public
    function sealContract() public {
        require(!(bytes1(isContractSealed)), "Contract is sealed");
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        isContractSealed = 0x01 | (uint248(isContractSealed));
    }
    
    /// @custom:selector    0xdbe9875f
    /// @custom:signature   Unresolved_dbe9875f(uint256 arg0, uint256 arg1) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_dbe9875f(uint256 arg0, uint256 arg1) public {
        require(arg1 == arg1);
        require(!(arg0 < unresolved_18160ddd), CustomError_df2d9b42());
        uint256 var_a = arg0;
        require(0 - (bytes1(storage_map_c[var_a])), CustomError_df2d9b42());
        require(0 - storage_map_c[var_a], "Only the token owner can set the render method");
        require(address(msg.sender) == (address(storage_map_c[var_a])), "Only the token owner can set the render method");
        var_a = arg0;
        storage_map_c[var_a] = arg1 | (uint248(storage_map_c[var_a]));
        var_a = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + arg0;
        if (0 - storage_map_c[var_a]) {
            var_a = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + arg0);
            if (0 - storage_map_c[var_a]) {
                var_a = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + arg0));
                if (0 - storage_map_c[var_a]) {
                }
            }
        }
    }
    
    /// @custom:selector    0xfd6b3cf5
    /// @custom:signature   reRollDuplicate(uint256 arg0, uint256 arg1) public view
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function reRollDuplicate(uint256 arg0, uint256 arg1) public view {
        require(!(bytes1(isContractSealed)), "Invalid token");
        require(!(arg0 < unresolved_18160ddd), "Invalid token");
        uint256 var_a = arg0;
        require(!(bytes1(storage_map_c[var_a])), "Invalid token");
        require(!(0x04 & (0x06 > 0x3fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)), "Invalid token");
        require(0x1ca3, "Invalid token");
        require(!(0 < 0x06), "Invalid token");
        require(!(arg1 < unresolved_18160ddd), "Invalid token");
        var_a = arg1;
        require(!(bytes1(storage_map_c[var_a])), "Invalid token");
        require(!(0x04 & (0x06 > 0x3fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)), "All tokens must be duplicates");
        var_h = var_h + 0xe0;
        var_k = msg.data[4:196];
        require(0x1ca3, "All tokens must be duplicates");
        require(!(0 < 0x06), "All tokens must be duplicates");
        require(!(0 < (var_k)), "All tokens must be duplicates");
        require(!(0 > (var_k)), "All tokens must be duplicates");
        var_h = (var_v) + (0x20 + var_h);
        require(!(0 < (var_k)), "All tokens must be duplicates");
        require(!(0 > (var_k)), "All tokens must be duplicates");
        require(keccak256(var_x) == (keccak256(var_x)), "All tokens must be duplicates");
        require(arg0 > arg1, CustomError_df2d9b42());
        require(address(msg.sender) == (address(owner)), CustomError_df2d9b42());
        require(!(arg0 < unresolved_18160ddd), CustomError_df2d9b42());
        var_a = arg0;
        require(0 - (bytes1(storage_map_c[var_a])), CustomError_df2d9b42());
        require(0 - storage_map_c[var_a], "Only the token owner or contract owner can re-roll");
        require(address(msg.sender) == (address(storage_map_c[var_a])), "Only the token owner or contract owner can re-roll");
        var_a = arg0;
        if (0 - storage_map_c[var_a]) {
            if (!0x01 > ~(arg0)) {
                var_a = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + arg0;
                if (0 - storage_map_c[var_a]) {
                    var_a = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + arg0);
                    if (0 - storage_map_c[var_a]) {
                        require(!(0x01 > ~(arg0)), CustomError_df2d9b42());
                    }
                }
            }
        }
        if (address(msg.sender) == (address(owner))) {
            require(address(msg.sender) == (address(owner)), "DynamicBuffer: Appending out of bounds.");
        }
        require(!(var_x < 0x0a), "DynamicBuffer: Appending out of bounds.");
        require(!(var_x < 0x64), "DynamicBuffer: Appending out of bounds.");
        require(!(var_x > 0x03e7), "DynamicBuffer: Appending out of bounds.");
        var_h = 0x40 + var_h;
        require(!(var_k > ~(var_h.length)), "DynamicBuffer: Appending out of bounds.");
        require(!((var_k + var_h.length) > (var_ac + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc0)), "DynamicBuffer: Appending out of bounds.");
        if (!(var_h + 0x20) < ((var_h + 0x20) + var_h.length)) {
            if (0x01) {
                require(!((var_h + 0x20) < ((var_h + 0x20) + var_h.length)), CustomError_df2d9b42());
            }
            var_h = var_h + 0xa0;
            require(0x01, CustomError_df2d9b42());
        }
        require(0 - (var_x), CustomError_df2d9b42());
        var_a = var_x;
        require(!storage_map_c[var_a], CustomError_df2d9b42());
        var_a = var_x;
        require(0x01 < storage_map_c[var_a], CustomError_df2d9b42());
        var_a = var_x;
        require(storage_map_c[var_a], CustomError_df2d9b42());
        var_a = keccak256(var_a);
        require(storage_map_r[var_a] < var_h.length, CustomError_df2d9b42());
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        var_a = var_x;
        require(storage_map_c[var_a], CustomError_df2d9b42());
        var_a = keccak256(var_a);
        require(storage_map_r[var_a] < var_h.length, CustomError_df2d9b42());
        require(0x01, CustomError_df2d9b42());
        require(!(arg1 < unresolved_18160ddd), CustomError_df2d9b42());
        var_a = arg1;
        require(0 - (bytes1(storage_map_c[var_a])), CustomError_df2d9b42());
        if (0 - storage_map_c[var_a]) {
            if (0 - (uint24(var_am))) {
                if (0 < 0x0f) {
                    var_a = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + arg1;
                    if (0 - storage_map_c[var_a]) {
                        require(0 - (uint24(var_am)), CustomError_df2d9b42());
                        require(0 < 0x0f, CustomError_df2d9b42());
                    }
                }
            }
        }
        require(arg1 < unresolved_18160ddd, "Invalid token");
    }
    
    /// @custom:selector    0x621a1f74
    /// @custom:signature   tokenIdToHash(uint256 arg0) public view returns (bytes memory)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function tokenIdToHash(uint256 arg0) public view returns (bytes memory) {
        require(!(arg0 < unresolved_18160ddd), "Invalid token");
        uint256 var_a = arg0;
        require(!(bytes1(storage_map_c[var_a])), "Invalid token");
        require(!(0x04 & (0x06 > 0x3fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)), "DynamicBuffer: Appending out of bounds.");
        var_k = msg.data[4:196];
        require(0x1ca3, "DynamicBuffer: Appending out of bounds.");
        require(!(0 < 0x06), "DynamicBuffer: Appending out of bounds.");
        require(!(0 < (var_k)), "DynamicBuffer: Appending out of bounds.");
        require(!(0 > (var_k)), "DynamicBuffer: Appending out of bounds.");
        return abi.encodePacked(0x20, var_k);
        return abi.encodePacked(0x20, var_k);
        require(!(var_p < 0x0a), "DynamicBuffer: Appending out of bounds.");
        require(!(var_p < 0x64), "DynamicBuffer: Appending out of bounds.");
        require(!(var_p > 0x03e7), "DynamicBuffer: Appending out of bounds.");
        var_h = 0x40 + var_h;
        require(!(var_k > ~(var_h.length)), "DynamicBuffer: Appending out of bounds.");
        require(!((var_k + var_h.length) > (var_q + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc0)), "DynamicBuffer: Appending out of bounds.");
        if (!(var_h + 0x20) < ((var_h + 0x20) + var_h.length)) {
            if (0x01) {
                require(!((var_h + 0x20) < ((var_h + 0x20) + var_h.length)), CustomError_df2d9b42());
            }
            var_h = var_h + 0xa0;
            require(0x01, CustomError_df2d9b42());
        }
        require(0 - (var_p), CustomError_df2d9b42());
        var_a = var_p;
        require(!storage_map_c[var_a], CustomError_df2d9b42());
        var_a = var_p;
        require(0x01 < storage_map_c[var_a], CustomError_df2d9b42());
        var_a = var_p;
        require(storage_map_c[var_a], CustomError_df2d9b42());
        var_a = keccak256(var_a);
        require(storage_map_r[var_a] < var_h.length, CustomError_df2d9b42());
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        var_a = var_p;
        require(storage_map_c[var_a], CustomError_df2d9b42());
        var_a = keccak256(var_a);
        require(storage_map_r[var_a] < var_h.length, CustomError_df2d9b42());
        require(0x01, CustomError_df2d9b42());
        require(!(arg0 < unresolved_18160ddd), CustomError_df2d9b42());
        var_a = arg0;
        require(0 - (bytes1(storage_map_c[var_a])), CustomError_df2d9b42());
        if (0 - storage_map_c[var_a]) {
            if (0 - (uint24(var_ae))) {
                if (0 < 0x0f) {
                    var_a = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + arg0;
                    if (0 - storage_map_c[var_a]) {
                        require(0 - (uint24(var_ae)), CustomError_df2d9b42());
                        require(0 < 0x0f, CustomError_df2d9b42());
                    }
                }
            }
        }
        require(arg0 < unresolved_18160ddd, "Invalid token");
    }
    
    /// @custom:selector    0xdc9867ce
    /// @custom:signature   getLinkedTraits(uint256 arg0, uint256 arg1) public view returns (bytes memory)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function getLinkedTraits(uint256 arg0, uint256 arg1) public view returns (bytes memory) {
        var_a = arg1;
        uint256 var_c = 0x20 + (var_c + (0x20 * storage_map_c[var_a]));
        require(!storage_map_c[var_a]);
        var_a = keccak256(var_a);
        require((var_c + 0x20) + (0x20 * storage_map_c[var_a]) > (0x20 + (var_c + 0x20)));
        return abi.encodePacked(0x20, var_c.length);
    }
    
    /// @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 < unresolved_18160ddd), "Invalid token");
        uint256 var_a = arg0;
        require(!(bytes1(storage_map_c[var_a])), "Invalid token");
        require(unresolved_18160dddf, "Invalid token");
        require(!(arg0 < unresolved_18160ddd), "Invalid token");
        var_a = arg0;
        require(!(bytes1(storage_map_c[var_a])), "Invalid token");
        if (!(0x04) & (0x06 > 0x3fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) {
            var_k = msg.data[4:196];
            if (0x1ca3) {
                require(!(0x04 & (0x06 > 0x3fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)), CustomError_626f756e());
                var_h = 0x40 + var_h;
                require(0x1ca3, CustomError_626f756e());
                require(!(0 < 0x06), CustomError_626f756e());
                require(!(var_q > ~(var_h.length)), CustomError_626f756e());
                var_h = var_h + 0xa0;
                require(!((var_q + var_h.length) > (var_t + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc0)), CustomError_626f756e());
                require(!((var_h + 0x20) < ((var_h + 0x20) + var_h.length)), CustomError_626f756e());
                require(arg0 / 0x0a, CustomError_626f756e());
                require(!(0 < (var_w)), CustomError_626f756e());
                require(!(0 > (var_w)), CustomError_626f756e());
                require(bytes1(store_o), CustomError_626f756e());
                require(bytes1(store_o) - ((store_o >> 0x01) < 0x20), CustomError_626f756e());
                require(!(bytes1(store_o)), CustomError_626f756e());
            }
            var_h = 0x02;
            require(bytes1(store_o) == 0x01, CustomError_626f756e());
            require(!(var_q > ~(var_h.length)), CustomError_626f756e());
            require(!(0x20 < (var_w)), CustomError_626f756e());
        }
        require(!(var_q < 0x0a), "DynamicBuffer: Appending out of bounds.");
        require(!(var_q < 0x64), "DynamicBuffer: Appending out of bounds.");
        require(!(var_q > 0x03e7), "DynamicBuffer: Appending out of bounds.");
        var_h = 0x40 + var_h;
        require(!(var_k > ~(var_h.length)), "DynamicBuffer: Appending out of bounds.");
        require(!((var_k + var_h.length) > (var_af + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc0)), "DynamicBuffer: Appending out of bounds.");
        if (!(var_h + 0x20) < ((var_h + 0x20) + var_h.length)) {
            if (0x01) {
                require(!((var_h + 0x20) < ((var_h + 0x20) + var_h.length)), CustomError_df2d9b42());
            }
            var_h = var_h + 0xa0;
            require(0x01, CustomError_df2d9b42());
        }
        require(0 - (var_q), CustomError_df2d9b42());
        var_a = var_q;
        require(!storage_map_c[var_a], CustomError_df2d9b42());
        var_a = var_q;
        require(0x01 < storage_map_c[var_a], CustomError_df2d9b42());
        var_a = var_q;
        require(storage_map_c[var_a], CustomError_df2d9b42());
        var_a = keccak256(var_a);
        require(storage_map_r[var_a] < var_h.length, CustomError_df2d9b42());
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        var_a = var_q;
        require(storage_map_c[var_a], CustomError_df2d9b42());
        var_a = keccak256(var_a);
        require(storage_map_r[var_a] < var_h.length, CustomError_df2d9b42());
        require(0x01, CustomError_df2d9b42());
        require(!(arg0 < unresolved_18160ddd), CustomError_df2d9b42());
        var_a = arg0;
        require(0 - (bytes1(storage_map_c[var_a])), CustomError_df2d9b42());
        if (0 - storage_map_c[var_a]) {
            if (0 - (uint24(var_au))) {
                if (0 < 0x0f) {
                    var_a = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + arg0;
                    if (0 - storage_map_c[var_a]) {
                        require(0 - (uint24(var_au)), CustomError_df2d9b42());
                        require(0 < 0x0f, CustomError_df2d9b42());
                    }
                }
            }
        }
        require(arg0 < unresolved_18160ddd, "Invalid token");
        require(arg0 < unresolved_18160ddd, "Invalid token");
    }
    
    /// @custom:selector    0xba41b0c6
    /// @custom:signature   mint(uint256 arg0, bytes32[] arg1) public payable returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function mint(uint256 arg0, bytes32[] arg1) public payable returns (uint256) {
        require(!arg1 > 0xffffffffffffffff);
        require(!(arg1) > 0xffffffffffffffff);
        require(store_g - 0x02, "Minting is not active");
        store_g = 0x02;
        require(!(unresolved_18160ddd < 0x1ca3), "Minting is not active");
        require(unresolved_18160ddd < 0x1ca3, "Minting is not active");
        require(!(!bytes1(unresolved_18160dddc)), "Minting is not active");
        require(!(!bytes1(unresolved_18160dddc)), "Minting is not active");
        require(!(unresolved_18160ddd < 0x1ca3), "Minting is not active");
        require(unresolved_18160ddd < 0x1ca3, "Minting is not active");
        require(arg0, "All tokens are gone");
        require(!(unresolved_18160ddd > ~(arg0)), "All tokens are gone");
        require(!((unresolved_18160ddd + arg0) > 0x1ca3), "All tokens are gone");
        require(!(bytes1(unresolved_18160dddc)), "EOAs only");
        require(msg.sender == (address(owner)), "EOAs only");
        require(tx.origin == msg.sender, "EOAs only");
        require(0x14, CustomError_b562e8dd());
        require(0x14, CustomError_b562e8dd());
        require(!(0 < (arg0 / 0x14)), CustomError_b562e8dd());
        require(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec, CustomError_b562e8dd());
        address var_e = address(msg.sender);
        storage_map_ag[var_e] = 0x140000000000000014 + storage_map_ag[var_e];
        require(!0, CustomError_2e076300());
        var_e = unresolved_18160ddd;
        storage_map_ag[var_e] = (address(msg.sender)) | ((block.timestamp << 0xa0) | (((0x14 == 0x01) << 0xe1) | 0));
        emit Transfer(0, address(msg.sender), unresolved_18160ddd);
        require((unresolved_18160ddd + 0x01) == (unresolved_18160ddd + 0x14), CustomError_2e076300());
        require(0 - (address(msg.sender)), CustomError_2e076300());
        unresolved_18160ddd = unresolved_18160ddd + 0x14;
        require(0x01, CustomError_2e076300());
        require(!(arg0 % 0x14), "Invalid token count");
        store_g = 0x01;
        return unresolved_18160ddd;
        require(bytes1(unresolved_18160dddc), "Minting is not active");
        require(bytes1(unresolved_18160dddc), "Minting is not active");
        require(bytes1(unresolved_18160dddc), "Minting is not active");
        if (isAllowListActive) {
        }
        uint256 var_h = var_h + (0x20 + (0x20 * (arg1)));
        var_i = msg.data[36:36];
        require(keccak256(var_i) < (var_i), "Not on allow list");
        require(0x01, "Not on allow list");
        require(0x01, "Not on allow list");
        require(keccak256(var_i) == unresolved_18160ddda, "Not on allow list");
        if (msg.sender == (address(owner))) {
        }
    }
    
    /// @custom:selector    0x3cca2420
    /// @custom:signature   contractData() public view
    function contractData() public view {
        if (store_n) {
            if (store_n - ((store_n >> 0x01) < 0x20)) {
                uint256 var_c = var_c + (0x20 + (((0x1f + (store_n >> 0x01)) / 0x20) * 0x20));
                if (store_n) {
                    if (store_n - ((store_n >> 0x01) < 0x20)) {
                        if (!store_n >> 0x01) {
                            if (0x1f < (store_n >> 0x01)) {
                                var_a = 0x32;
                                if ((0x20 + var_c) + (store_n >> 0x01) > (0x20 + (0x20 + var_c))) {
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0x4047638d
    /// @custom:signature   togglePublicMint() public
    function togglePublicMint() public {
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        unresolved_18160dddc = (!bytes1(unresolved_18160dddc)) | (uint248(unresolved_18160dddc));
    }
    
    /// @custom:selector    0xea84b59b
    /// @custom:signature   traitDetails(uint256 arg0, uint256 arg1) public view
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function traitDetails(uint256 arg0, uint256 arg1) public view {
        var_e = arg1;
        if (storage_map_ag[var_e]) {
            require(bytes1(storage_map_ag[var_e]));
            var_e = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
            require(bytes1(storage_map_ag[var_e]) - ((storage_map_ag[var_e] >> 0x01) < 0x20));
            require(bytes1(storage_map_ag[var_e]));
            var_e = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
            require(bytes1(storage_map_ag[var_e]) - ((storage_map_ag[var_e] >> 0x01) < 0x20));
            require(!storage_map_ag[var_e] >> 0x01);
            var_e = keccak256(var_e);
            require(0x1f < (storage_map_ag[var_e] >> 0x01));
        }
    }
    
    /// @custom:selector    0x0f3debbe
    /// @custom:signature   Unresolved_0f3debbe(uint256 arg0, uint256 arg1) public pure
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_0f3debbe(uint256 arg0, uint256 arg1) public pure {
        require(!arg0 > 0xffffffffffffffff);
        require(!((var_a + 0xe0) < var_a) | ((var_a + 0xe0) > 0xffffffffffffffff));
        uint256 var_a = var_a + 0xe0;
        require(!(arg0) > 0xffffffffffffffff);
        require(!(arg0 + (arg0)) > 0xffffffffffffffff);
        require(!((var_a + (uint248((0x20 + (arg0 + (arg0) + 0x1f)) + 0x1f))) < var_a) | ((var_a + (uint248((0x20 + (arg0 + (arg0) + 0x1f)) + 0x1f))) > 0xffffffffffffffff));
        var_a = var_a + (uint248((0x20 + (arg0 + (arg0) + 0x1f)) + 0x1f));
        require(!(arg0 + 0x20) > 0xffffffffffffffff);
    }
    
    /// @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    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    0x6c0360eb
    /// @custom:signature   Unresolved_6c0360eb() public view returns (bytes memory)
    function Unresolved_6c0360eb() public view returns (bytes memory) {
        if (store_k) {
            if (store_k - ((store_k >> 0x01) < 0x20)) {
                uint256 var_c = var_c + (0x20 + (((0x1f + (store_k >> 0x01)) / 0x20) * 0x20));
                if (store_k) {
                    if (store_k - ((store_k >> 0x01) < 0x20)) {
                        if (!store_k >> 0x01) {
                            if (0x1f < (store_k >> 0x01)) {
                                var_a = 0x2c;
                                if ((0x20 + var_c) + (store_k >> 0x01) > (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    0xbc63f02e
    /// @custom:signature   airdrop(uint256 arg0, address arg1) public payable returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function airdrop(uint256 arg0, address arg1) public payable returns (uint256) {
        require(arg1 == (address(arg1)));
        require(store_g - 0x02, "Minting is not active");
        store_g = 0x02;
        require(!(unresolved_18160ddd < 0x1ca3), "Minting is not active");
        require(unresolved_18160ddd < 0x1ca3, "Minting is not active");
        require(bytes1(unresolved_18160dddc), "Public minting is not active");
        require(msg.sender == (address(owner)), "Public minting is not active");
        require(!(unresolved_18160ddd < 0x1ca3), "Minting is not active");
        require(unresolved_18160ddd < 0x1ca3, "Minting is not active");
        require(arg0, "All tokens are gone");
        require(!(unresolved_18160ddd > ~(arg0)), "All tokens are gone");
        require(!((unresolved_18160ddd + arg0) > 0x1ca3), "All tokens are gone");
        require(!(bytes1(unresolved_18160dddc)), CustomError_b562e8dd());
        require(0x14, CustomError_b562e8dd());
        require(0x14, CustomError_b562e8dd());
        require(!(0 < (arg0 / 0x14)), CustomError_b562e8dd());
        require(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec, CustomError_b562e8dd());
        address var_e = address(arg1);
        storage_map_ag[var_e] = 0x140000000000000014 + storage_map_ag[var_e];
        require(!0, CustomError_2e076300());
        var_e = unresolved_18160ddd;
        storage_map_ag[var_e] = (address(arg1)) | ((block.timestamp << 0xa0) | (((0x14 == 0x01) << 0xe1) | 0));
        emit Transfer(0, address(arg1), unresolved_18160ddd);
        require((unresolved_18160ddd + 0x01) == (unresolved_18160ddd + 0x14), CustomError_2e076300());
        require(0 - (address(arg1)), CustomError_2e076300());
        unresolved_18160ddd = unresolved_18160ddd + 0x14;
        require(0x01, CustomError_2e076300());
        require(!(arg0 % 0x14), "EOAs only");
        store_g = 0x01;
        return unresolved_18160ddd;
        require(msg.sender == (address(owner)), "EOAs only");
        require(tx.origin == msg.sender, "EOAs only");
        if (unresolved_18160dddc) {
            require(bytes1(unresolved_18160dddc), "ReentrancyGuard: reentrant call");
        }
    }
    
    /// @custom:selector    0xc11feac1
    /// @custom:signature   tokenIdToSVG(uint256 arg0) public view
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function tokenIdToSVG(uint256 arg0) public view {
        require(!(arg0 < unresolved_18160ddd), "Invalid token");
        uint256 var_a = arg0;
        require(!(bytes1(storage_map_c[var_a])), "Invalid token");
        if (!(0x04) & (0x06 > 0x3fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) {
            var_k = msg.data[4:196];
            require(!(0x04 & (0x06 > 0x3fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)), CustomError_626f756e());
            require(0x1ca3, CustomError_626f756e());
            var_h = 0xc0 + var_h;
            var_p = this.code[23401:23530];
            require(!(0 < 0x06), CustomError_626f756e());
            require(!(var_k > ~(var_h.length)), CustomError_626f756e());
            require(!((var_k + var_h.length) > (var_q + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc0)), CustomError_626f756e());
            require(!((var_h + 0x20) < ((var_h + 0x20) + var_h.length)), CustomError_626f756e());
            require(bytes1(store_y), CustomError_626f756e());
            require(bytes1(store_y) - ((store_y >> 0x01) < 0x20), CustomError_626f756e());
            require(!(bytes1(store_y)), CustomError_626f756e());
            require(bytes1(store_y) == 0x01, CustomError_626f756e());
        }
        var_h = 0x16;
        require(!(var_k > ~(var_h.length)), CustomError_626f756e());
        require(!(var_p < 0x0a), "DynamicBuffer: Appending out of bounds.");
        require(!(var_p < 0x64), "DynamicBuffer: Appending out of bounds.");
        require(!(var_p > 0x03e7), "DynamicBuffer: Appending out of bounds.");
        var_h = 0x40 + var_h;
        require(!(var_k > ~(var_h.length)), "DynamicBuffer: Appending out of bounds.");
        require(!((var_k + var_h.length) > (var_q + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc0)), "DynamicBuffer: Appending out of bounds.");
        if (!(var_h + 0x20) < ((var_h + 0x20) + var_h.length)) {
            if (0x01) {
                require(!((var_h + 0x20) < ((var_h + 0x20) + var_h.length)), CustomError_df2d9b42());
            }
            var_h = var_h + 0xa0;
            require(0x01, CustomError_df2d9b42());
        }
        require(0 - (var_p), CustomError_df2d9b42());
        var_a = var_p;
        require(!storage_map_c[var_a], CustomError_df2d9b42());
        var_a = var_p;
        require(0x01 < storage_map_c[var_a], CustomError_df2d9b42());
        var_a = var_p;
        require(storage_map_c[var_a], CustomError_df2d9b42());
        var_a = keccak256(var_a);
        require(storage_map_r[var_a] < var_h.length, CustomError_df2d9b42());
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        var_a = var_p;
        require(storage_map_c[var_a], CustomError_df2d9b42());
        var_a = keccak256(var_a);
        require(storage_map_r[var_a] < var_h.length, CustomError_df2d9b42());
        require(0x01, CustomError_df2d9b42());
        require(!(arg0 < unresolved_18160ddd), CustomError_df2d9b42());
        var_a = arg0;
        require(0 - (bytes1(storage_map_c[var_a])), CustomError_df2d9b42());
        if (0 - storage_map_c[var_a]) {
            if (0 - (uint24(var_ak))) {
                if (0 < 0x0f) {
                    var_a = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + arg0;
                    if (0 - storage_map_c[var_a]) {
                        require(0 - (uint24(var_ak)), CustomError_df2d9b42());
                        require(0 < 0x0f, CustomError_df2d9b42());
                    }
                }
            }
        }
        require(arg0 < unresolved_18160ddd, "Invalid token");
    }
    
    /// @custom:selector    0x4920154b
    /// @custom:signature   toggleWrapSVG() public
    function toggleWrapSVG() public {
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        unresolved_18160dddh = (!bytes1(unresolved_18160dddh)) | (uint248(unresolved_18160dddh));
    }
    
    /// @custom:selector    0x6190e1da
    /// @custom:signature   Unresolved_6190e1da(uint256 arg0) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_6190e1da(uint256 arg0) public {
        require(!arg0 > 0xffffffffffffffff);
        require(!(arg0 > 0xffffffffffffffff), "Ownable: caller is not the owner");
        require(!(((var_c + (uint248((0x20 + (arg0 + 0x1f)) + 0x1f))) < var_c) | ((var_c + (uint248((0x20 + (arg0 + 0x1f)) + 0x1f))) > 0xffffffffffffffff)), "Ownable: caller is not the owner");
        uint256 var_c = var_c + (uint248((0x20 + (arg0 + 0x1f)) + 0x1f));
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        require(!(bytes1(isContractSealed)), "Contract is sealed");
        require(bytes1(store_y), "Contract is sealed");
        require(bytes1(store_y) - ((store_y >> 0x01) < 0x20), "Contract is sealed");
        var_a = 0x26;
        require(var_c.length, "Contract is sealed");
        require(0x1f < var_c.length, "Contract is sealed");
        store_y = 0x01 + (var_c.length + var_c.length);
        require(!var_c.length, "Contract is sealed");
        require(!(((var_c + 0x20) + var_c.length) > (var_c + 0x20)), "Contract is sealed");
        require(!(keccak256(var_a) + ((0x1f + (store_y >> 0x01)) / 0x20) > keccak256(var_a)), "Contract is sealed");
    }
    
    /// @custom:selector    0x6cced73a
    /// @custom:signature   tokensAreDuplicates(uint256 arg0, uint256 arg1) public view returns (bool)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function tokensAreDuplicates(uint256 arg0, uint256 arg1) public view returns (bool) {
        require(!(arg0 < unresolved_18160ddd), "Invalid token");
        uint256 var_a = arg0;
        require(!(bytes1(storage_map_c[var_a])), "Invalid token");
        require(!(0x04 & (0x06 > 0x3fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)), "Invalid token");
        require(0x1ca3, "Invalid token");
        require(!(0 < 0x06), "Invalid token");
        require(!(arg1 < unresolved_18160ddd), "Invalid token");
        var_a = arg1;
        require(!(bytes1(storage_map_c[var_a])), "Invalid token");
        require(!(0x04 & (0x06 > 0x3fffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)), "DynamicBuffer: Appending out of bounds.");
        var_h = var_h + 0xe0;
        var_k = msg.data[4:196];
        require(0x1ca3, "DynamicBuffer: Appending out of bounds.");
        require(!(0 < 0x06), "DynamicBuffer: Appending out of bounds.");
        require(!(0 < (var_k)), "DynamicBuffer: Appending out of bounds.");
        require(!(0 > (var_k)), "DynamicBuffer: Appending out of bounds.");
        var_h = (var_v) + (0x20 + var_h);
        require(!(0 < (var_k)), "DynamicBuffer: Appending out of bounds.");
        require(!(0 > (var_k)), "DynamicBuffer: Appending out of bounds.");
        var_h = (var_v) + (0x20 + var_h);
        return !(!(keccak256(var_x)) == (keccak256(var_x)));
        return !(!(keccak256(var_x)) == (keccak256(var_x)));
        require(!(var_x < 0x0a), "DynamicBuffer: Appending out of bounds.");
        require(!(var_x < 0x64), "DynamicBuffer: Appending out of bounds.");
        require(!(var_x > 0x03e7), "DynamicBuffer: Appending out of bounds.");
        var_h = 0x40 + var_h;
        require(!(var_k > ~(var_h.length)), "DynamicBuffer: Appending out of bounds.");
        require(!((var_k + var_h.length) > (var_y + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc0)), "DynamicBuffer: Appending out of bounds.");
        if (!(var_h + 0x20) < ((var_h + 0x20) + var_h.length)) {
            if (0x01) {
                require(!((var_h + 0x20) < ((var_h + 0x20) + var_h.length)), CustomError_df2d9b42());
            }
            var_h = var_h + 0xa0;
            require(0x01, CustomError_df2d9b42());
        }
        require(0 - (var_x), CustomError_df2d9b42());
        var_a = var_x;
        require(!storage_map_c[var_a], CustomError_df2d9b42());
        var_a = var_x;
        require(0x01 < storage_map_c[var_a], CustomError_df2d9b42());
        var_a = var_x;
        require(storage_map_c[var_a], CustomError_df2d9b42());
        var_a = keccak256(var_a);
        require(storage_map_r[var_a] < var_h.length, CustomError_df2d9b42());
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        var_a = var_x;
        require(storage_map_c[var_a], CustomError_df2d9b42());
        var_a = keccak256(var_a);
        require(storage_map_r[var_a] < var_h.length, CustomError_df2d9b42());
        require(0x01, CustomError_df2d9b42());
        require(!(arg1 < unresolved_18160ddd), CustomError_df2d9b42());
        var_a = arg1;
        require(0 - (bytes1(storage_map_c[var_a])), CustomError_df2d9b42());
        if (0 - storage_map_c[var_a]) {
            if (0 - (uint24(var_am))) {
                if (0 < 0x0f) {
                    var_a = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + arg1;
                    if (0 - storage_map_c[var_a]) {
                        require(0 - (uint24(var_am)), CustomError_df2d9b42());
                        require(0 < 0x0f, CustomError_df2d9b42());
                    }
                }
            }
        }
        require(arg1 < unresolved_18160ddd, "Invalid token");
    }
}