0xd774557b647330c91bf44cfeab205095f7e6c367

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 shareholderAddress = 1442372147011193394376310094730868957489656079372;
    uint256 public constant MAX_TOKENS_PER_PURCHASE = 10;
    uint256 public constant DEFAULT_ADMIN_ROLE = 0;
    uint256 public constant SUPPORT_ROLE = 98004723066652866835523930881156781081683319332295575154267376734294213944891;
    uint256 public constant MAX_SUPPLY = 20000;
    
    bool public operatorFilteringEnabled;
    uint256 public finalPrice;
    bytes32 store_p;
    uint256 public duration;
    uint256 public startTime;
    bytes32 store_r;
    mapping(bytes32 => bytes32) storage_map_h;
    address public snapshotContract;
    uint256 public timeStepSeconds;
    uint256 public merkleRoot;
    uint256 public priceStep;
    mapping(bytes32 => bytes32) storage_map_t;
    mapping(bytes32 => bytes32) storage_map_j;
    bytes32 store_b;
    uint256 public totalSupply;
    uint256 public startPrice;
    uint256 store_f;
    address public owner;
    bool public allowListActive;
    bytes32 store_s;
    uint256 store_i;
    bool public auctionActive;
    mapping(bytes32 => bytes32) storage_map_c;
    
    event AllowListClaimMint(address, address, uint256);
    error TransferToNonERC721ReceiverImplementer();
    event Transfer(address, address, uint256);
    event RoleRevoked(bytes32, address, address);
    event Claimed(address, uint256);
    event RoleGranted(bytes32, address, address);
    event DutchAuctionEnd(uint256);
    event Approval(address, address, uint256);
    event MerkleRootChanged(bytes32);
    event DutchAuctionStart(uint256, uint256);
    event ApprovalForAll(address, address, bool);
    event OwnershipTransferred(address, address);
    
    /// @custom:selector    0x095ea7b3
    /// @custom:signature   approve(address arg0, uint256 arg1) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function approve(address arg0, uint256 arg1) public payable {
        require(arg0 == (address(arg0)));
        require(address(arg0) == 0x1e0049783f008a0085193e00003d00cd54003c71, CustomError_df2d9b42());
        require(!(arg1 < totalSupply), 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 Approval(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 Approval(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]) {
                }
            }
        }
        require(!bytes1(operatorFilteringEnabled));
        (bool success, bytes memory ret0) = address(0xaaeb6d7670e522a718067333cd4e).Unresolved_(var_f); // staticcall
    }
    
    /// @custom:selector    0x0f7309e8
    /// @custom:signature   provenance() public view returns (bytes memory)
    function provenance() public view returns (bytes memory) {
        if (store_f) {
            if (store_f - ((store_f >> 0x01) < 0x20)) {
                uint256 var_c = var_c + (0x20 + (((0x1f + (store_f >> 0x01)) / 0x20) * 0x20));
                if (store_f) {
                    if (store_f - ((store_f >> 0x01) < 0x20)) {
                        if (!store_f >> 0x01) {
                            if (0x1f < (store_f >> 0x01)) {
                                var_a = 0x17;
                                if ((0x20 + var_c) + (store_f >> 0x01) > (0x20 + (0x20 + var_c))) {
                                    return abi.encodePacked(0x20, var_c.length);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0x3ccfd60b
    /// @custom:signature   withdraw() public
    function withdraw() public {
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        (bool success, bytes memory ret0) = address(0xfca634387cd89128116b80e04c6352a4e7c5a40c).transfer(address(this).balance);
        require(ret0.length == 0, CustomError_750b219c());
    }
    
    /// @custom:selector    0xc23dc68f
    /// @custom:signature   explicitOwnershipOf(uint256 arg0) public view returns (bool)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function explicitOwnershipOf(uint256 arg0) public view returns (bool) {
        require(arg0 < totalSupply, CustomError_df2d9b42());
        uint256 var_n = arg0;
        var_a = var_a + 0x80;
        require(!(var_t), CustomError_df2d9b42());
        return abi.encodePacked(address(var_a.length), uint64(var_ab), !(!var_ac), uint24(var_ad));
        require(!(arg0 < totalSupply), CustomError_df2d9b42());
        var_n = arg0;
        require(0 - (bytes1(storage_map_h[var_n])), CustomError_df2d9b42());
        require(0 - storage_map_h[var_n], CustomError_df2d9b42());
        var_a = var_a + 0x80;
        return abi.encodePacked(address(var_a.length), uint64(var_ab), !(!var_ac), uint24(var_ad));
        var_n = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + arg0;
        require(0 - storage_map_h[var_n], CustomError_df2d9b42());
        var_a = var_a + 0x80;
        return abi.encodePacked(address(var_a.length), uint64(var_ab), !(!var_ac), uint24(var_ad));
        var_n = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + arg0);
        require(0 - storage_map_h[var_n], CustomError_df2d9b42());
        var_a = var_a + 0x80;
        return abi.encodePacked(address(var_a.length), uint64(var_ab), !(!var_ac), uint24(var_ad));
        var_n = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + arg0));
        require(0 - storage_map_h[var_n], CustomError_df2d9b42());
        var_a = var_a + 0x80;
        return abi.encodePacked(address(var_a.length), uint64(var_ab), !(!var_ac), uint24(var_ad));
        return abi.encodePacked(address(var_a.length), uint64(var_ab), !(!var_ac), uint24(var_ad));
    }
    
    /// @custom:selector    0x91d14854
    /// @custom:signature   hasRole(bytes32 arg0, address arg1) public view returns (bool)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function hasRole(bytes32 arg0, address arg1) public view returns (bool) {
        require(arg1 == (address(arg1)));
        var_a = address(arg1);
        return !(!bytes1(storage_map_c[var_a]));
    }
    
    /// @custom:selector    0x55f804b3
    /// @custom:signature   Unresolved_55f804b3(uint256 arg0, uint0 arg1) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint0", "bytes0", "int0"]
    function Unresolved_55f804b3(uint256 arg0, uint0 arg1) public {
        require(!arg0 > 0xffffffffffffffff);
        require(!(arg0) > 0xffffffffffffffff);
        address var_a = address(msg.sender);
        require(bytes1(storage_map_c[var_a]), "Strings: hex length insufficient");
        require(!(arg0 > 0xffffffffffffffff), "Strings: hex length insufficient");
        require(bytes1(store_i), "Strings: hex length insufficient");
        require(bytes1(store_i) - ((store_i >> 0x01) < 0x20), "Strings: hex length insufficient");
        require(!((store_i >> 0x01) > 0x1f), "Strings: hex length insufficient");
        var_a = 0x18;
        require(!(arg0 < 0x20), "Strings: hex length insufficient");
        require(!(keccak256(var_a) + ((arg0 + 0x1f) >> 0x05) < (keccak256(var_a) + (((store_i >> 0x01) + 0x1f) >> 0x05))), "Strings: hex length insufficient");
        require((arg0 > 0x1f) == 0x01, "Strings: hex length insufficient");
        var_a = 0x18;
        require(!(0 < (uint248(arg0))), "Strings: hex length insufficient");
        require(!(uint248(arg0) < (arg0)), "Strings: hex length insufficient");
        storage_map_c[var_a] = ((0x20 + (arg0)) + 0) & (~(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> (bytes1(arg0 << 0x03))));
        store_i = (arg0 << 0x01) + 0x01;
        store_i = (arg0 << 0x01) + 0x01;
        require(!(arg0), "Strings: hex length insufficient");
        store_i = (arg0 << 0x01) | (~(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> (arg0 << 0x03)) & (0 + (0x20 + (arg0))));
        store_i = (arg0 << 0x01) | (~(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> (arg0 << 0x03)) & (0));
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x02 > 0x2a), "Strings: hex length insufficient");
        require(!(0x2a > 0xffffffffffffffff), "Strings: hex length insufficient");
        uint256 var_e = var_e + 0x60;
        require(!0x2a, "Strings: hex length insufficient");
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x01 > 0x29), "Strings: hex length insufficient");
        require(!(0x29 > 0x01), "Strings: hex length insufficient");
        require(!(address(msg.sender)), "Strings: hex length insufficient");
        require(bytes1(address(msg.sender)) < 0x10);
        require(0x29 < var_e.length);
        require(0x29);
    }
    
    /// @custom:selector    0xd547741f
    /// @custom:signature   revokeRole(bytes32 arg0, address arg1) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function revokeRole(bytes32 arg0, address arg1) public {
        require(arg1 == (address(arg1)));
        var_a = address(msg.sender);
        require(bytes1(storage_map_c[var_a]), "Strings: hex length insufficient");
        var_a = address(arg1);
        require(!(bytes1(storage_map_c[var_a])), "Strings: hex length insufficient");
        var_a = address(arg1);
        storage_map_c[var_a] = uint248(storage_map_c[var_a]);
        emit RoleRevoked(arg0, address(arg1), msg.sender);
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x02 > 0x2a), "Strings: hex length insufficient");
        require(!(0x2a > 0xffffffffffffffff), "Strings: hex length insufficient");
        uint256 var_e = var_e + 0x60;
        require(!0x2a, "Strings: hex length insufficient");
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x01 > 0x29), "Strings: hex length insufficient");
        require(!(0x29 > 0x01), "Strings: hex length insufficient");
        require(!(address(msg.sender)), "Strings: hex length insufficient");
        require(bytes1(address(msg.sender)) < 0x10);
        require(0x29 < var_e.length);
        require(0x29);
    }
    
    /// @custom:selector    0x01ffc9a7
    /// @custom:signature   supportsInterface(bytes4 arg0) public pure returns (bool)
    /// @param              arg0 ["uint32", "bytes4", "int32"]
    function supportsInterface(bytes4 arg0) public pure returns (bool) {
        require(arg0 == (uint32(arg0)));
        if (uint32(arg0) == 0x01ffc9a700000000000000000000000000000000000000000000000000000000) {
            if (uint32(arg0) == 0x01ffc9a700000000000000000000000000000000000000000000000000000000) {
                require(uint32(arg0) == 0x01ffc9a700000000000000000000000000000000000000000000000000000000);
                require(uint32(arg0) == 0x01ffc9a700000000000000000000000000000000000000000000000000000000);
                return !(!(uint32(arg0)) == 0x01ffc9a700000000000000000000000000000000000000000000000000000000);
                require(uint32(arg0) == 0x01ffc9a700000000000000000000000000000000000000000000000000000000);
                return !(!0x7965db0b00000000000000000000000000000000000000000000000000000000 == (uint32(arg0)));
                return !(!(uint32(arg0)) == 0x01ffc9a700000000000000000000000000000000000000000000000000000000);
                require(uint32(arg0) == 0x01ffc9a700000000000000000000000000000000000000000000000000000000);
                require(0x2a55205a00000000000000000000000000000000000000000000000000000000 == (uint32(arg0)));
            }
        }
    }
    
    /// @custom:selector    0xbdb7806b
    /// @custom:signature   Unresolved_bdb7806b(address arg0, uint224 arg1, uint256 arg2, uint256 arg3) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint224", "bytes28", "int224"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    function Unresolved_bdb7806b(address arg0, uint224 arg1, uint256 arg2, uint256 arg3) public {
        require(arg0 == (address(arg0)));
        require(!arg3 > 0xffffffffffffffff);
        require(!(arg3) > 0xffffffffffffffff);
        require(bytes1(allowListActive / 0x0100000000), CustomError_8f0c6ebf());
        require(!(totalSupply > (arg1 + totalSupply)), CustomError_8f0c6ebf());
        require(!((arg1 + totalSupply) > 0x4e20), CustomError_8f0c6ebf());
        require(!address(arg0));
        require(msg.sender == (address(arg0)));
        address var_d = msg.sender;
        (bool success, bytes memory ret0) = address(0x76a84fef008cdabe6409d2fe638b).{ value: 0 ether }Unresolved_90c9a2d0(var_d); // call
        uint256 var_g = var_g + (uint248(ret0.length + 0x1f));
        require(!(((var_g + ret0.length) - var_g) < 0x20), CustomError_b4244fa8());
        require(var_g.length == var_g.length, CustomError_b4244fa8());
        require(var_g.length, CustomError_b4244fa8());
        address var_a = address(arg0);
        require(uint32(allowListActive) - (uint32(storage_map_c[var_a] / 0x0100000000000000000000000000000000000000000000000000000000)), CustomError_651884e6());
        require(!(0 > (arg1 + 0)), CustomError_651884e6());
        require(!((arg1 + 0) > arg2), CustomError_651884e6());
        var_g = var_g + (0x20 + (0x20 * (arg3)));
        var_l = msg.data[36:36];
        require(keccak256(var_l) < (var_l));
        require(0x01);
        require(0x01);
        require(keccak256(var_l) == merkleRoot);
        var_a = address(arg0);
        require(uint32(storage_map_c[var_a] / 0x0100000000000000000000000000000000000000000000000000000000) == (uint32(allowListActive)));
        storage_map_c[var_a] = (uint224(arg1)) | (uint32(0x0100000000000000000000000000000000000000000000000000000000 * (allowListActive)));
        emit Claimed(address(arg0), arg1);
        var_g = 0x20 + var_g;
        require(0 - arg1);
        var_a = address(msg.sender);
        storage_map_c[var_a] = (arg1 * 0x010000000000000001) + storage_map_c[var_a];
        var_a = totalSupply;
        storage_map_c[var_a] = (address(msg.sender)) | ((block.timestamp << 0xa0) | ((arg1 == 0x01) << 0xe1));
        emit Transfer(0, address(msg.sender), totalSupply);
        require((totalSupply + 0x01) == (arg1 + totalSupply));
        require(0 - (address(msg.sender)));
        totalSupply = arg1 + totalSupply;
        require(!address(msg.sender).code.length);
        emit AllowListClaimMint(msg.sender, address(arg0), arg1);
        address var_r = address(msg.sender);
        uint256 var_s = 0;
        (bool success, bytes memory ret0) = address(msg.sender).{ value: var_s ether }Unresolved_150b7a02(var_r); // call
        require(!ret0.length);
        require(0 - var_x);
        var_g = var_g + (uint248(ret0.length + 0x3f));
        require(0 - var_g.length, CustomError_d1a57ed6());
        var_g = var_g + (uint248(ret0.length + 0x1f));
        require(!((var_g + ret0.length) - var_g) < 0x20);
        require(var_g.length == (uint32(var_g.length)));
        require(0x01);
        require(!ret0.length);
        require(0 - var_x);
        var_g = var_g + (uint248(ret0.length + 0x3f));
        require(0 - var_g.length, CustomError_d1a57ed6());
        require(0x150b7a0200000000000000000000000000000000000000000000000000000000 == (uint32(var_g.length)), CustomError_d1a57ed6());
        require((0x01 + (totalSupply - arg1)) < totalSupply);
        require(totalSupply == totalSupply);
        emit AllowListClaimMint(msg.sender, address(arg0), arg1);
        require(!(uint224(arg1) + (uint224(storage_map_c[var_a])) > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff), CustomError_60cea48b());
        var_a = address(msg.sender);
        if (uint32(allowListActive) - (uint32(storage_map_c[var_a] / 0x0100000000000000000000000000000000000000000000000000000000))) {
        }
    }
    
    /// @custom:selector    0x2f2ff15d
    /// @custom:signature   grantRole(bytes32 arg0, address arg1) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function grantRole(bytes32 arg0, address arg1) public {
        require(arg1 == (address(arg1)));
        var_a = address(msg.sender);
        require(bytes1(storage_map_c[var_a]), "Strings: hex length insufficient");
        var_a = address(arg1);
        require(bytes1(storage_map_c[var_a]), "Strings: hex length insufficient");
        var_a = address(arg1);
        storage_map_c[var_a] = 0x01 | (uint248(storage_map_c[var_a]));
        emit RoleGranted(arg0, address(arg1), address(msg.sender));
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x02 > 0x2a), "Strings: hex length insufficient");
        require(!(0x2a > 0xffffffffffffffff), "Strings: hex length insufficient");
        uint256 var_e = var_e + 0x60;
        require(!0x2a, "Strings: hex length insufficient");
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x01 > 0x29), "Strings: hex length insufficient");
        require(!(0x29 > 0x01), "Strings: hex length insufficient");
        require(!(address(msg.sender)), "Strings: hex length insufficient");
        require(bytes1(address(msg.sender)) < 0x10);
        require(0x29 < var_e.length);
        require(0x29);
    }
    
    /// @custom:selector    0xffe630b5
    /// @custom:signature   Unresolved_ffe630b5(uint256 arg0, uint0 arg1) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint0", "bytes0", "int0"]
    function Unresolved_ffe630b5(uint256 arg0, uint0 arg1) public {
        require(!arg0 > 0xffffffffffffffff);
        require(!(arg0) > 0xffffffffffffffff);
        address var_a = address(msg.sender);
        require(bytes1(storage_map_c[var_a]), "Strings: hex length insufficient");
        require(!(arg0 > 0xffffffffffffffff), "Strings: hex length insufficient");
        require(bytes1(store_f), "Strings: hex length insufficient");
        require(bytes1(store_f) - ((store_f >> 0x01) < 0x20), "Strings: hex length insufficient");
        require(!((store_f >> 0x01) > 0x1f), "Strings: hex length insufficient");
        var_a = 0x17;
        require(!(arg0 < 0x20), "Strings: hex length insufficient");
        require(!(keccak256(var_a) + ((arg0 + 0x1f) >> 0x05) < (keccak256(var_a) + (((store_f >> 0x01) + 0x1f) >> 0x05))), "Strings: hex length insufficient");
        require((arg0 > 0x1f) == 0x01, "Strings: hex length insufficient");
        var_a = 0x17;
        require(!(0 < (uint248(arg0))), "Strings: hex length insufficient");
        require(!(uint248(arg0) < (arg0)), "Strings: hex length insufficient");
        storage_map_c[var_a] = ((0x20 + (arg0)) + 0) & (~(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> (bytes1(arg0 << 0x03))));
        store_f = (arg0 << 0x01) + 0x01;
        store_f = (arg0 << 0x01) + 0x01;
        require(!(arg0), "Strings: hex length insufficient");
        store_f = (arg0 << 0x01) | (~(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> (arg0 << 0x03)) & (0 + (0x20 + (arg0))));
        store_f = (arg0 << 0x01) | (~(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> (arg0 << 0x03)) & (0));
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x02 > 0x2a), "Strings: hex length insufficient");
        require(!(0x2a > 0xffffffffffffffff), "Strings: hex length insufficient");
        uint256 var_e = var_e + 0x60;
        require(!0x2a, "Strings: hex length insufficient");
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x01 > 0x29), "Strings: hex length insufficient");
        require(!(0x29 > 0x01), "Strings: hex length insufficient");
        require(!(address(msg.sender)), "Strings: hex length insufficient");
        require(bytes1(address(msg.sender)) < 0x10);
        require(0x29 < var_e.length);
        require(0x29);
    }
    
    /// @custom:selector    0xa22cb465
    /// @custom:signature   Unresolved_a22cb465(address arg0, uint256 arg1) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_a22cb465(address arg0, uint256 arg1) public {
        require(arg0 == (address(arg0)));
        require(arg1 == arg1);
        require(address(arg0) == 0x1e0049783f008a0085193e00003d00cd54003c71);
        var_a = address(arg0);
        storage_map_c[var_a] = arg1 | (uint248(storage_map_c[var_a]));
        uint256 var_c = arg1;
        emit ApprovalForAll(msg.sender, address(arg0), arg1);
        require(!bytes1(operatorFilteringEnabled));
        (bool success, bytes memory ret0) = address(0xaaeb6d7670e522a718067333cd4e).Unresolved_(var_f); // staticcall
        var_a = address(arg0);
        storage_map_c[var_a] = var_c | (uint248(storage_map_c[var_a]));
        var_c = arg1;
        emit ApprovalForAll(msg.sender, address(arg0), arg1);
        var_a = address(arg0);
        storage_map_c[var_a] = var_c | (uint248(storage_map_c[var_a]));
        emit ApprovalForAll(msg.sender, address(arg0), arg1);
    }
    
    /// @custom:selector    0x8c0e05a5
    /// @custom:signature   onAllowListC(address arg0, uint256 arg1, uint256 arg2, bytes32[] arg3) public view returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    function onAllowListC(address arg0, uint256 arg1, uint256 arg2, bytes32[] arg3) public view returns (bool) {
        require(arg0 == (address(arg0)));
        require(!arg3 > 0xffffffffffffffff);
        require(!(arg3) > 0xffffffffffffffff);
        require(!((var_c + (uint248(((arg3 << 0x05) + 0x20) + 0x1f))) < var_c) | ((var_c + (uint248(((arg3 << 0x05) + 0x20) + 0x1f))) > 0xffffffffffffffff));
        uint256 var_c = var_c + (uint248(((arg3 << 0x05) + 0x20) + 0x1f));
        require(!((0x04 + arg3) + 0x20) < (0x20 + ((arg3 << 0x05) + (0x04 + arg3))));
        require(keccak256(var_i) < (var_i));
        require(0x01);
        require(0x01);
        return !(!(keccak256(var_i)) == merkleRoot);
    }
    
    /// @custom:selector    0x6352211e
    /// @custom:signature   ownerOf(uint256 arg0) public view returns (address)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function ownerOf(uint256 arg0) public view returns (address) {
        require(!(arg0 < totalSupply), 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   name() public view returns (string memory)
    function name() public view returns (string memory) {
        if (store_p) {
            if (store_p - ((store_p >> 0x01) < 0x20)) {
                uint256 var_c = var_c + (0x20 + (((0x1f + (store_p >> 0x01)) / 0x20) * 0x20));
                if (store_p) {
                    if (store_p - ((store_p >> 0x01) < 0x20)) {
                        if (!store_p >> 0x01) {
                            if (0x1f < (store_p >> 0x01)) {
                                var_a = 0x09;
                                if ((0x20 + var_c) + (store_p >> 0x01) > (0x20 + (0x20 + var_c))) {
                                    return abi.encodePacked(0x20, var_c.length);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0x95d89b41
    /// @custom:signature   symbol() public view returns (string memory)
    function symbol() public view returns (string memory) {
        if (store_r) {
            if (store_r - ((store_r >> 0x01) < 0x20)) {
                uint256 var_c = var_c + (0x20 + (((0x1f + (store_r >> 0x01)) / 0x20) * 0x20));
                if (store_r) {
                    if (store_r - ((store_r >> 0x01) < 0x20)) {
                        if (!store_r >> 0x01) {
                            if (0x1f < (store_r >> 0x01)) {
                                var_a = 0x0a;
                                if ((0x20 + var_c) + (store_r >> 0x01) > (0x20 + (0x20 + var_c))) {
                                    return abi.encodePacked(0x20, var_c.length);
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0xb88d4fde
    /// @custom:signature   Unresolved_b88d4fde(address arg0, address arg1, uint256 arg2, uint256 arg3) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    function Unresolved_b88d4fde(address arg0, address arg1, uint256 arg2, uint256 arg3) public payable {
        require(arg0 == (address(arg0)));
        require(arg1 == (address(arg1)));
        require(!arg3 > 0xffffffffffffffff);
        require(!(arg3 > 0xffffffffffffffff), CustomError_df2d9b42());
        require(!(((var_c + (uint248((0x20 + (arg3 + 0x1f)) + 0x1f))) < var_c) | ((var_c + (uint248((0x20 + (arg3 + 0x1f)) + 0x1f))) > 0xffffffffffffffff)), CustomError_df2d9b42());
        uint256 var_c = var_c + (uint248((0x20 + (arg3 + 0x1f)) + 0x1f));
        require(msg.sender == (address(arg0)), CustomError_df2d9b42());
        require(msg.sender == 0x1e0049783f008a0085193e00003d00cd54003c71, CustomError_df2d9b42());
        require(msg.sender == (address(arg0)), CustomError_df2d9b42());
        require(msg.sender == 0x1e0049783f008a0085193e00003d00cd54003c71, CustomError_df2d9b42());
        require(!(arg2 < totalSupply), CustomError_df2d9b42());
        uint256 var_a = arg2;
        require(0 - (bytes1(storage_map_c[var_a])), CustomError_df2d9b42());
        require(0 - storage_map_c[var_a], CustomError_a1148100());
        require(address(storage_map_c[var_a]) == (address(arg0)), CustomError_a1148100());
        var_a = arg2;
        require((msg.sender == (address(arg0))) | (storage_map_c[var_a] == msg.sender));
        var_a = address(msg.sender);
        require(bytes1(storage_map_c[var_a]));
        require(address(arg1));
        require(!storage_map_c[var_a]);
        storage_map_c[var_a] = 0;
        var_a = address(arg0);
        storage_map_c[var_a] = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + storage_map_c[var_a];
        var_a = address(arg1);
        storage_map_c[var_a] = 0x01 + storage_map_c[var_a];
        var_a = arg2;
        storage_map_c[var_a] = 0x0200000000000000000000000000000000000000000000000000000000 | ((block.timestamp << 0xa0) | (address(arg1)));
        require(0 - (bytes1(storage_map_c[var_a])));
        emit Transfer(address(arg0), address(arg1), arg2);
        require(!address(arg1).code.length);
        address var_h = address(msg.sender);
        uint256 var_j = arg2;
        uint256 var_m = 0;
        (bool success, bytes memory ret0) = address(arg1).{ value: var_m ether }Unresolved_150b7a02(var_h); // call
        require(!ret0.length);
        require(0 - var_n);
        var_c = var_c + (uint248(ret0.length + 0x3f));
        require(0 - var_c.length, CustomError_d1a57ed6());
        var_c = var_c + (uint248(ret0.length + 0x1f));
        require(!((var_c + ret0.length) - var_c) < 0x20);
        require(var_c.length == (uint32(var_c.length)));
        require(0x01);
        require(!ret0.length);
        require(0 - var_n);
        var_c = var_c + (uint248(ret0.length + 0x3f));
        require(0 - var_c.length, CustomError_d1a57ed6());
        require(0x150b7a0200000000000000000000000000000000000000000000000000000000 == (uint32(var_c.length)), CustomError_d1a57ed6());
        var_a = var_j + 0x01;
        if (0 - storage_map_c[var_a]) {
            require(0 - storage_map_c[var_a], CustomError_ea553b34());
        }
        var_a = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + arg2;
        if (0 - storage_map_c[var_a]) {
            var_a = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + arg2);
            if (0 - storage_map_c[var_a]) {
                var_a = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + arg2));
                if (0 - storage_map_c[var_a]) {
                }
            }
        }
        require(!bytes1(operatorFilteringEnabled));
        (bool success, bytes memory ret0) = address(0xaaeb6d7670e522a718067333cd4e).Unresolved_(var_t); // staticcall
        if (!operatorFilteringEnabled) {
        }
    }
    
    /// @custom:selector    0x081812fc
    /// @custom:signature   getApproved(uint256 arg0) public view returns (address)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function getApproved(uint256 arg0) public view returns (address) {
        require(!(arg0 < totalSupply), 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 < totalSupply, CustomError_cf4700e4());
        var_a = arg0;
        return address(storage_map_c[var_a]);
    }
    
    /// @custom:selector    0x04634d8d
    /// @custom:signature   setDefaultRoyalty(address arg0, uint96 arg1) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint96", "bytes12", "int96"]
    function setDefaultRoyalty(address arg0, uint96 arg1) public {
        require(arg0 == (address(arg0)));
        require(arg1 == (uint96(arg1)));
        address var_a = address(msg.sender);
        require(bytes1(storage_map_c[var_a]), "ERC2981: royalty fee will exceed salePrice");
        require(!(uint96(arg1) > 0x2710), "ERC2981: royalty fee will exceed salePrice");
        require(address(arg0), "ERC2981: invalid receiver");
        store_s = (uint96(arg1) * 0x010000000000000000000000000000000000000000) | (address(arg0));
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x02 > 0x2a), "Strings: hex length insufficient");
        require(!(0x2a > 0xffffffffffffffff), "Strings: hex length insufficient");
        var_h = var_h + 0x60;
        require(!0x2a, "Strings: hex length insufficient");
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x01 > 0x29), "Strings: hex length insufficient");
        require(!(0x29 > 0x01), "Strings: hex length insufficient");
        require(!(address(msg.sender)), "Strings: hex length insufficient");
        require(bytes1(address(msg.sender)) < 0x10);
        require(0x29 < var_h.length);
        require(0x29);
    }
    
    /// @custom:selector    0x36568abe
    /// @custom:signature   renounceRole(bytes32 arg0, address arg1) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function renounceRole(bytes32 arg0, address arg1) public {
        require(arg1 == (address(arg1)));
        require(msg.sender == (address(arg1)), "AccessControl: can only renounce roles for self");
        var_f = address(arg1);
        require(!bytes1(storage_map_t[var_f]));
        var_f = address(arg1);
        storage_map_t[var_f] = uint248(storage_map_t[var_f]);
        emit RoleRevoked(arg0, address(arg1), msg.sender);
    }
    
    /// @custom:selector    0x70a08231
    /// @custom:signature   balanceOf(address arg0) public view returns (uint64)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function balanceOf(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    0xb7c0b8e8
    /// @custom:signature   Unresolved_b7c0b8e8(uint256 arg0) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_b7c0b8e8(uint256 arg0) public {
        require(arg0 == arg0);
        require(msg.sender == (address(owner)), "Ownable: caller is not the owner");
        operatorFilteringEnabled = arg0 | (uint248(operatorFilteringEnabled));
    }
    
    /// @custom:selector    0x2a55205a
    /// @custom:signature   royaltyInfo(uint256 arg0, uint256 arg1) public view returns (bytes memory)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function royaltyInfo(uint256 arg0, uint256 arg1) public view returns (bytes memory) {
        uint256 var_a = arg0;
        uint256 var_c = 0x40 + var_c;
        require(address(storage_map_c[var_a]));
        require(uint96(var_f) == ((uint96(var_f) * arg1) / arg1) | !arg1);
        require(0x2710);
        return abi.encodePacked(address(var_c.length), (uint96(var_j) * arg1) / 0x2710);
    }
    
    /// @custom:selector    0xe6e8bfde
    /// @custom:signature   resumeDutchAuction() public
    function resumeDutchAuction() public {
        address var_a = address(msg.sender);
        require(bytes1(storage_map_c[var_a]), CustomError_c2ef4081());
        require(!(bytes1(allowListActive / 0x0100000000)), CustomError_c2ef4081());
        require(0 - startTime, CustomError_0a8ab09e());
        require(!(bytes1(auctionActive)), CustomError_0a8ab09e());
        auctionActive = 0x01 | (uint248(auctionActive));
        emit DutchAuctionStart(startTime, duration);
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x02 > 0x2a), "Strings: hex length insufficient");
        require(!(0x2a > 0xffffffffffffffff), "Strings: hex length insufficient");
        uint256 var_e = var_e + 0x60;
        require(!0x2a, "Strings: hex length insufficient");
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x01 > 0x29), "Strings: hex length insufficient");
        require(!(0x29 > 0x01), "Strings: hex length insufficient");
        require(!(address(msg.sender)), "Strings: hex length insufficient");
        if (address(msg.sender) < 0x10) {
            if (0x29 < var_e.length) {
                if (0x29) {
                }
            }
        }
    }
    
    /// @custom:selector    0x3e4f10b8
    /// @custom:signature   stopDutchAuction() public
    function stopDutchAuction() public {
        address var_a = address(msg.sender);
        require(bytes1(storage_map_c[var_a]), CustomError_481163ec());
        require(bytes1(auctionActive), CustomError_481163ec());
        auctionActive = uint248(auctionActive);
        emit DutchAuctionEnd(block.timestamp);
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x02 > 0x2a), "Strings: hex length insufficient");
        require(!(0x2a > 0xffffffffffffffff), "Strings: hex length insufficient");
        uint256 var_e = var_e + 0x60;
        require(!0x2a, "Strings: hex length insufficient");
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x01 > 0x29), "Strings: hex length insufficient");
        require(!(0x29 > 0x01), "Strings: hex length insufficient");
        require(!(address(msg.sender)), "Strings: hex length insufficient");
        if (address(msg.sender) < 0x10) {
            if (0x29 < var_e.length) {
                if (0x29) {
                }
            }
        }
    }
    
    /// @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    0xaa1b103f
    /// @custom:signature   deleteDefaultRoyalty() public
    function deleteDefaultRoyalty() public {
        address var_a = address(msg.sender);
        require(bytes1(storage_map_c[var_a]), "Strings: hex length insufficient");
        store_s = 0;
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x02 > 0x2a), "Strings: hex length insufficient");
        require(!(0x2a > 0xffffffffffffffff), "Strings: hex length insufficient");
        uint256 var_e = var_e + 0x60;
        require(!0x2a, "Strings: hex length insufficient");
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x01 > 0x29), "Strings: hex length insufficient");
        require(!(0x29 > 0x01), "Strings: hex length insufficient");
        require(!(address(msg.sender)), "Strings: hex length insufficient");
        if (address(msg.sender) < 0x10) {
            if (0x29 < var_e.length) {
                if (0x29) {
                }
            }
        }
    }
    
    /// @custom:selector    0x2f658038
    /// @custom:signature   mintDutch(uint256 arg0) public view
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function mintDutch(uint256 arg0) public view {
        require(bytes1(auctionActive), CustomError_8f0c6ebf());
        require(!(totalSupply > (arg0 + totalSupply)), CustomError_8f0c6ebf());
        require(!((arg0 + totalSupply) > 0x4e20), CustomError_8f0c6ebf());
        require(tx.origin == msg.sender, CustomError_e0531007());
        require(!(arg0 > 0x0a), CustomError_cd194ce0());
        require(startTime > 0, CustomError_481163ec());
        require(!((block.timestamp - startTime) > block.timestamp), CustomError_481163ec());
        require((block.timestamp - startTime) < duration, CustomError_481163ec());
        require(timeStepSeconds, CustomError_481163ec());
        require((priceStep == ((priceStep * ((block.timestamp - startTime) / timeStepSeconds)) / ((block.timestamp - startTime) / timeStepSeconds))) | (!(block.timestamp - startTime) / timeStepSeconds), CustomError_481163ec());
        require(!((startPrice - (priceStep * ((block.timestamp - startTime) / timeStepSeconds))) > startPrice), CustomError_481163ec());
    }
    
    /// @custom:selector    0x861ba6f0
    /// @custom:signature   onAllowListB(address arg0, uint256 arg1, bytes32[] arg2) public view returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function onAllowListB(address arg0, uint256 arg1, bytes32[] arg2) public view returns (bool) {
        require(arg0 == (address(arg0)));
        require(!arg2 > 0xffffffffffffffff);
        require(!(arg2) > 0xffffffffffffffff);
        require(!((var_c + (uint248(((arg2 << 0x05) + 0x20) + 0x1f))) < var_c) | ((var_c + (uint248(((arg2 << 0x05) + 0x20) + 0x1f))) > 0xffffffffffffffff));
        uint256 var_c = var_c + (uint248(((arg2 << 0x05) + 0x20) + 0x1f));
        require(!((0x04 + arg2) + 0x20) < (0x20 + ((arg2 << 0x05) + (0x04 + arg2))));
        require(keccak256(var_h) < (var_h));
        require(0x01);
        require(0x01);
        return !(!(keccak256(var_h)) == merkleRoot);
    }
    
    /// @custom:selector    0x5944c753
    /// @custom:signature   setTokenRoyalty(uint256 arg0, address arg1, uint96 arg2) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint96", "bytes12", "int96"]
    function setTokenRoyalty(uint256 arg0, address arg1, uint96 arg2) public {
        require(arg1 == (address(arg1)));
        require(arg2 == (uint96(arg2)));
        address var_a = address(msg.sender);
        require(bytes1(storage_map_c[var_a]), "ERC2981: royalty fee will exceed salePrice");
        require(!(uint96(arg2) > 0x2710), "ERC2981: royalty fee will exceed salePrice");
        require(address(arg1), "ERC2981: Invalid parameters");
        uint256 var_h = 0x40 + var_h;
        var_a = arg0;
        storage_map_c[var_a] = (address(var_h.length)) | (0x010000000000000000000000000000000000000000 * (uint96(var_j)));
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x02 > 0x2a), "Strings: hex length insufficient");
        require(!(0x2a > 0xffffffffffffffff), "Strings: hex length insufficient");
        var_h = var_h + 0x60;
        require(!0x2a, "Strings: hex length insufficient");
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x01 > 0x29), "Strings: hex length insufficient");
        require(!(0x29 > 0x01), "Strings: hex length insufficient");
        require(!(address(msg.sender)), "Strings: hex length insufficient");
        require(bytes1(address(msg.sender)) < 0x10);
        require(0x29 < var_h.length);
        require(0x29);
    }
    
    /// @custom:selector    0x089b820e
    /// @custom:signature   setAllowListPreserveBalances(bytes32 arg0) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function setAllowListPreserveBalances(bytes32 arg0) public {
        address var_a = address(msg.sender);
        require(bytes1(storage_map_c[var_a]), CustomError_c2ef4081());
        require(!(bytes1(allowListActive / 0x0100000000)), CustomError_c2ef4081());
        merkleRoot = arg0;
        require(0x01, "Strings: hex length insufficient");
        require(!((0x01 + (uint32(allowListActive))) > 0xffffffff), "Strings: hex length insufficient");
        allowListActive = (uint32(0x01 + (allowListActive)) * 0x01) | (uint224(allowListActive));
        emit MerkleRootChanged(merkleRoot);
        emit MerkleRootChanged(merkleRoot);
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x02 > 0x2a), "Strings: hex length insufficient");
        require(!(0x2a > 0xffffffffffffffff), "Strings: hex length insufficient");
        uint256 var_e = var_e + 0x60;
        require(!0x2a, "Strings: hex length insufficient");
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x01 > 0x29), "Strings: hex length insufficient");
        require(!(0x29 > 0x01), "Strings: hex length insufficient");
        require(!(address(msg.sender)), "Strings: hex length insufficient");
        require(bytes1(address(msg.sender)) < 0x10);
        require(0x29 < var_e.length);
        require(0x29);
    }
    
    /// @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    0x85b61001
    /// @custom:signature   createDutchAuction(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    function createDutchAuction(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3) public {
        address var_a = address(msg.sender);
        require(bytes1(storage_map_c[var_a]), CustomError_0a8ab09e());
        require(!(bytes1(auctionActive)), CustomError_0a8ab09e());
        require(arg0 < arg1, CustomError_8496243f());
        require(!(arg0 < arg1), CustomError_8496243f());
        startPrice = arg0;
        finalPrice = arg1;
        priceStep = arg2;
        timeStepSeconds = arg3;
        require(!(arg0 - arg1) > arg0);
        require(!arg0 - arg1);
        require(!((arg0 - arg1) - 0x01) > (arg0 - arg1));
        require(arg2);
        require(!0x01 > ((((arg0 - arg1) - 0x01) / arg2) + 0x01));
        require((arg3 == ((arg3 * ((((arg0 - arg1) - 0x01) / arg2) + 0x01)) / ((((arg0 - arg1) - 0x01) / arg2) + 0x01))) | (!(((arg0 - arg1) - 0x01) / arg2) + 0x01));
        duration = timeStepSeconds * ((((arg0 - arg1) - 0x01) / arg2) + 0x01);
        require((0x14 == 0x14) | !0x02);
    }
    
    /// @custom:selector    0x248a9ca3
    /// @custom:signature   getRoleAdmin(bytes32 arg0) public view returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function getRoleAdmin(bytes32 arg0) public view returns (uint256) {
        uint256 var_a = arg0;
        return storage_map_j[var_a];
    }
    
    /// @custom:selector    0x3a73c58d
    /// @custom:signature   Unresolved_3a73c58d(uint256 arg0) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_3a73c58d(uint256 arg0) public {
        require(arg0 == arg0);
        address var_a = address(msg.sender);
        require(bytes1(storage_map_c[var_a]), CustomError_0a8ab09e());
        require(!(bytes1(auctionActive)), CustomError_0a8ab09e());
        require(address(snapshotContract), CustomError_9f8a28f2());
        require(merkleRoot, CustomError_9f8a28f2());
        allowListActive = (arg0 * 0x0100000000) | (uint248(allowListActive));
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x02 > 0x2a), "Strings: hex length insufficient");
        require(!(0x2a > 0xffffffffffffffff), "Strings: hex length insufficient");
        uint256 var_e = var_e + 0x60;
        require(!0x2a, "Strings: hex length insufficient");
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x01 > 0x29), "Strings: hex length insufficient");
        require(!(0x29 > 0x01), "Strings: hex length insufficient");
        require(!(address(msg.sender)), "Strings: hex length insufficient");
        require(bytes1(address(msg.sender)) < 0x10);
        require(0x29 < var_e.length);
        require(0x29);
    }
    
    /// @custom:selector    0xe985e9c5
    /// @custom:signature   Unresolved_e985e9c5(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_e985e9c5(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
    
    /// @custom:selector    0xc87b56dd
    /// @custom:signature   tokenURI(uint256 arg0) public view
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function tokenURI(uint256 arg0) public view {
        require(!(arg0 < totalSupply), CustomError_a14c4b50());
        uint256 var_a = arg0;
        require(!(bytes1(storage_map_c[var_a])), CustomError_a14c4b50());
        if (store_i) {
            require(bytes1(store_i), CustomError_a14c4b50());
            uint256 var_e = var_e + (0x20 + (((0x1f + (store_i >> 0x01)) / 0x20) * 0x20));
            require(bytes1(store_i) - ((store_i >> 0x01) < 0x20), CustomError_a14c4b50());
            require(bytes1(store_i), CustomError_a14c4b50());
            require(bytes1(store_i) - ((store_i >> 0x01) < 0x20), CustomError_a14c4b50());
            require(!(store_i >> 0x01), CustomError_a14c4b50());
            var_a = 0x18;
            require(0x1f < (store_i >> 0x01), CustomError_a14c4b50());
            require((0x20 + var_e) + (store_i >> 0x01) > (0x20 + (0x20 + var_e)), CustomError_a14c4b50());
            var_e = var_e + 0xa0;
            require(0 - var_e.length, CustomError_a14c4b50());
            require(arg0 / 0x0a, CustomError_a14c4b50());
            require(!(0 < (var_l)), CustomError_a14c4b50());
        }
        require(arg0 < totalSupply, CustomError_a14c4b50());
    }
    
    /// @custom:selector    0x8a616bc0
    /// @custom:signature   resetTokenRoyalty(uint256 arg0) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function resetTokenRoyalty(uint256 arg0) public {
        address var_a = address(msg.sender);
        require(bytes1(storage_map_c[var_a]), "Strings: hex length insufficient");
        var_a = arg0;
        storage_map_c[var_a] = 0;
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x02 > 0x2a), "Strings: hex length insufficient");
        require(!(0x2a > 0xffffffffffffffff), "Strings: hex length insufficient");
        uint256 var_e = var_e + 0x60;
        require(!0x2a, "Strings: hex length insufficient");
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x01 > 0x29), "Strings: hex length insufficient");
        require(!(0x29 > 0x01), "Strings: hex length insufficient");
        require(!(address(msg.sender)), "Strings: hex length insufficient");
        require(bytes1(address(msg.sender)) < 0x10);
        require(0x29 < var_e.length);
        require(0x29);
    }
    
    /// @custom:selector    0xb45ba718
    /// @custom:signature   startDutchAuction() public
    function startDutchAuction() public {
        address var_a = address(msg.sender);
        require(bytes1(storage_map_c[var_a]), CustomError_c2ef4081());
        require(!(bytes1(allowListActive / 0x0100000000)), CustomError_c2ef4081());
        require(!(bytes1(auctionActive)), CustomError_0a8ab09e());
        require(0 - duration, CustomError_8496243f());
        startTime = block.timestamp;
        auctionActive = 0x01 | (uint248(auctionActive));
        emit DutchAuctionStart(block.timestamp, duration);
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x02 > 0x2a), "Strings: hex length insufficient");
        require(!(0x2a > 0xffffffffffffffff), "Strings: hex length insufficient");
        uint256 var_e = var_e + 0x60;
        require(!0x2a, "Strings: hex length insufficient");
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x01 > 0x29), "Strings: hex length insufficient");
        require(!(0x29 > 0x01), "Strings: hex length insufficient");
        require(!(address(msg.sender)), "Strings: hex length insufficient");
        if (address(msg.sender) < 0x10) {
            if (0x29 < var_e.length) {
                if (0x29) {
                }
            }
        }
    }
    
    /// @custom:selector    0x5ea1ef52
    /// @custom:signature   getAllowListMinted(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function getAllowListMinted(address arg0) public view returns (uint256) {
        require(arg0 == (address(arg0)));
        address var_a = address(arg0);
        uint256 var_c = 0x40 + var_c;
        require(uint32(allowListActive) - (uint32(storage_map_c[var_a] / 0x0100000000000000000000000000000000000000000000000000000000)));
        return 0;
        return uint224(var_c.length);
    }
    
    /// @custom:selector    0x99a2557a
    /// @custom:signature   tokensOfOwnerIn(address arg0, uint256 arg1, uint256 arg2) public view returns (bytes memory)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function tokensOfOwnerIn(address arg0, uint256 arg1, uint256 arg2) public view returns (bytes memory) {
        require(arg0 == (address(arg0)));
        if (arg1 < arg2) {
            if (!arg2 > totalSupply) {
                if (address(arg0)) {
                    address var_a = address(arg0);
                    if (!arg1 < totalSupply) {
                        if (!(totalSupply - arg1) < (uint64(storage_map_c[var_a]))) {
                            if (!(totalSupply - arg1) > 0xffffffffffffffff) {
                                require(arg1 < arg2, CustomError_df2d9b42());
                                require(!(arg2 > totalSupply), CustomError_df2d9b42());
                                require(address(arg0), CustomError_df2d9b42());
                                var_a = arg1;
                                require(!(arg1 < totalSupply), CustomError_df2d9b42());
                                require(!((totalSupply - arg1) < (uint64(storage_map_c[var_a]))), CustomError_df2d9b42());
                                require(!((totalSupply - arg1) > 0xffffffffffffffff), CustomError_df2d9b42());
                                require(!(totalSupply - arg1), CustomError_df2d9b42());
                                var_a = arg1;
                                var_e = var_e + 0x80;
                                require(0 - (totalSupply - arg1), CustomError_df2d9b42());
                                require(arg1 < totalSupply, CustomError_df2d9b42());
                                require(!(var_ae), CustomError_df2d9b42());
                                return abi.encodePacked(0x20, var_e.length);
                                require(var_ae, CustomError_df2d9b42());
                            }
                        }
                        require(var_ae, CustomError_df2d9b42());
                        require(!(!(0x01 + arg1) == totalSupply), CustomError_df2d9b42());
                        require(!(address(var_e.length)), CustomError_df2d9b42());
                        require(address(var_e.length) - (address(arg0)), CustomError_df2d9b42());
                    }
                    require(!(!(0x01 + arg1) == totalSupply), CustomError_df2d9b42());
                }
                require(!(!(0x01 + arg1) == totalSupply), CustomError_df2d9b42());
            }
        }
        require(!(arg1 < totalSupply), CustomError_df2d9b42());
        var_a = arg1;
        require(0 - (bytes1(storage_map_c[var_a])), CustomError_df2d9b42());
        if (0 - storage_map_c[var_a]) {
            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]) {
                    }
                }
            }
        }
        require(address(arg0), CustomError_8f4eb604());
    }
    
    /// @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    0x84584d07
    /// @custom:signature   setAllowList(bytes32 arg0) public
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function setAllowList(bytes32 arg0) public {
        address var_a = address(msg.sender);
        require(bytes1(storage_map_c[var_a]), CustomError_c2ef4081());
        require(!(bytes1(allowListActive / 0x0100000000)), CustomError_c2ef4081());
        merkleRoot = arg0;
        require(0, "Strings: hex length insufficient");
        emit MerkleRootChanged(merkleRoot);
        require(!((0x01 + (uint32(allowListActive))) > 0xffffffff), "Strings: hex length insufficient");
        allowListActive = (uint32(0x01 + (allowListActive)) * 0x01) | (uint224(allowListActive));
        emit MerkleRootChanged(merkleRoot);
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x02 > 0x2a), "Strings: hex length insufficient");
        require(!(0x2a > 0xffffffffffffffff), "Strings: hex length insufficient");
        uint256 var_e = var_e + 0x60;
        require(!0x2a, "Strings: hex length insufficient");
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x01 > 0x29), "Strings: hex length insufficient");
        require(!(0x29 > 0x01), "Strings: hex length insufficient");
        require(!(address(msg.sender)), "Strings: hex length insufficient");
        require(bytes1(address(msg.sender)) < 0x10);
        require(0x29 < var_e.length);
        require(0x29);
    }
    
    /// @custom:selector    0x627804af
    /// @custom:signature   devMint(address arg0, uint256 arg1) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function devMint(address arg0, uint256 arg1) public {
        require(arg0 == (address(arg0)));
        require(!(totalSupply > (arg1 + totalSupply)), CustomError_8f0c6ebf());
        require(!((arg1 + totalSupply) > 0x4e20), CustomError_8f0c6ebf());
        address var_a = address(msg.sender);
        require(bytes1(storage_map_c[var_a]));
        uint256 var_e = 0x20 + var_e;
        uint256 var_c = 0;
        require(0 - arg1);
        var_a = address(arg0);
        storage_map_c[var_a] = (arg1 * 0x010000000000000001) + storage_map_c[var_a];
        var_a = totalSupply;
        storage_map_c[var_a] = (address(arg0)) | ((block.timestamp << 0xa0) | ((arg1 == 0x01) << 0xe1));
        emit Transfer(0, address(arg0), totalSupply);
        require((totalSupply + 0x01) == (arg1 + totalSupply));
        require(0 - (address(arg0)));
        totalSupply = arg1 + totalSupply;
        require(!address(arg0).code.length);
        address var_g = address(msg.sender);
        (bool success, bytes memory ret0) = address(arg0).{ value: var_c ether }Unresolved_150b7a02(var_g); // call
        require(!ret0.length);
        require(0 - var_m);
        var_e = var_e + (uint248(ret0.length + 0x3f));
        require(0 - var_e.length, CustomError_d1a57ed6());
        var_e = var_e + (uint248(ret0.length + 0x1f));
        require(!((var_e + ret0.length) - var_e) < 0x20);
        require(var_e.length == (uint32(var_e.length)));
        require(0x01);
        require(!ret0.length);
        require(0 - var_m);
        var_e = var_e + (uint248(ret0.length + 0x3f));
        require(0 - var_e.length, CustomError_d1a57ed6());
        require(0x150b7a0200000000000000000000000000000000000000000000000000000000 == (uint32(var_e.length)), CustomError_d1a57ed6());
        require((0x01 + (totalSupply - arg1)) < totalSupply);
        require(totalSupply == totalSupply);
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x02 > 0x2a), "Strings: hex length insufficient");
        require(!(0x2a > 0xffffffffffffffff), "Strings: hex length insufficient");
        var_e = var_e + 0x60;
        require(!0x2a, "Strings: hex length insufficient");
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x01 > 0x29), "Strings: hex length insufficient");
        require(!(0x29 > 0x01), "Strings: hex length insufficient");
        require(!(address(msg.sender)), "Strings: hex length insufficient");
        require(bytes1(address(msg.sender)) < 0x10);
        require(0x29 < var_e.length);
        require(0x29);
    }
    
    /// @custom:selector    0x5bbb2177
    /// @custom:signature   Unresolved_5bbb2177(uint256 arg0, uint256 arg1) public view returns (bytes memory)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_5bbb2177(uint256 arg0, uint256 arg1) public view returns (bytes memory) {
        require(!arg0 > 0xffffffffffffffff);
        require(!(arg0) > 0xffffffffffffffff);
        require(!(arg0 > 0xffffffffffffffff), CustomError_df2d9b42());
        require(!(arg0), CustomError_df2d9b42());
        var_d = var_d + 0x80;
        require(arg0 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, CustomError_df2d9b42());
        require(0 == (arg0), CustomError_df2d9b42());
        require(0 < (arg0), CustomError_df2d9b42());
        require((0 + (arg0 + 0x20)) < totalSupply, CustomError_df2d9b42());
        uint256 var_a = (0 + (arg0 + 0x20));
        var_d = var_d + 0x80;
        require(!(var_z), CustomError_df2d9b42());
        require(0x01 == (arg0), CustomError_df2d9b42());
        return abi.encodePacked(0x20, var_d.length);
        require(!((0 + (arg0 + 0x20)) < totalSupply), CustomError_df2d9b42());
        var_a = (0 + (arg0 + 0x20));
        require(0 - (bytes1(storage_map_c[var_a])), CustomError_df2d9b42());
        if (0 - storage_map_c[var_a]) {
            var_a = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0 + (arg0 + 0x20));
            if (0 - storage_map_c[var_a]) {
                var_a = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0 + (arg0 + 0x20)));
                if (0 - storage_map_c[var_a]) {
                    var_a = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0 + (arg0 + 0x20))));
                    if (0 - storage_map_c[var_a]) {
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0x71e84f24
    /// @custom:signature   setSnapshotContract(address arg0) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function setSnapshotContract(address arg0) public {
        require(arg0 == (address(arg0)));
        address var_a = address(msg.sender);
        require(bytes1(storage_map_c[var_a]), CustomError_84744201());
        require(address(arg0), CustomError_84744201());
        snapshotContract = (address(arg0)) | (uint96(snapshotContract));
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x02 > 0x2a), "Strings: hex length insufficient");
        require(!(0x2a > 0xffffffffffffffff), "Strings: hex length insufficient");
        uint256 var_e = var_e + 0x60;
        require(!0x2a, "Strings: hex length insufficient");
        require((0x14 == 0x14) | !0x02, "Strings: hex length insufficient");
        require(!(0x01 > 0x29), "Strings: hex length insufficient");
        require(!(0x29 > 0x01), "Strings: hex length insufficient");
        require(!(address(msg.sender)), "Strings: hex length insufficient");
        require(bytes1(address(msg.sender)) < 0x10);
        require(0x29 < var_e.length);
        require(0x29);
    }
    
    /// @custom:selector    0x8462151c
    /// @custom:signature   tokensOfOwner(address arg0) public view returns (bytes memory)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function tokensOfOwner(address arg0) public view returns (bytes memory) {
        require(arg0 == (address(arg0)));
        if (address(arg0)) {
            address var_a = address(arg0);
            if (!(uint64(storage_map_c[var_a])) > 0xffffffffffffffff) {
                var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
                require(address(arg0), CustomError_8f4eb604());
                require(!(uint64(storage_map_c[var_a]) > 0xffffffffffffffff), CustomError_8f4eb604());
                var_a = 0;
                var_e = var_e + 0x80;
                require(!(uint64(storage_map_c[var_a])), CustomError_8f4eb604());
                require(var_s, CustomError_8f4eb604());
                return abi.encodePacked(0x20, var_e.length);
                require(0 == (uint64(storage_map_c[var_a])), CustomError_8f4eb604());
                require(!(address(var_e.length)), CustomError_8f4eb604());
                require(address(var_e.length) - (address(arg0)), CustomError_8f4eb604());
            }
            require(0 == (uint64(storage_map_c[var_a])), CustomError_8f4eb604());
        }
    }
    
    /// @custom:selector    0x418479a6
    /// @custom:signature   onAllowListA(address arg0, bytes32[] arg1) public view returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function onAllowListA(address arg0, bytes32[] arg1) public view returns (bool) {
        require(arg0 == (address(arg0)));
        require(!arg1 > 0xffffffffffffffff);
        require(!(arg1) > 0xffffffffffffffff);
        require(!((var_c + (uint248(((arg1 << 0x05) + 0x20) + 0x1f))) < var_c) | ((var_c + (uint248(((arg1 << 0x05) + 0x20) + 0x1f))) > 0xffffffffffffffff));
        uint256 var_c = var_c + (uint248(((arg1 << 0x05) + 0x20) + 0x1f));
        require(!((0x04 + arg1) + 0x20) < (0x20 + ((arg1 << 0x05) + (0x04 + arg1))));
        require(keccak256(var_g) < (var_g));
        require(0x01);
        require(0x01);
        return !(!(keccak256(var_g)) == merkleRoot);
    }
}