0xf6f8db0aba00007681f8faf16a0fda1c9b030b11

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 {
    string public constant name = "ProveX";
    string public constant symbol = "PRVX";
    uint256 public constant decimals = 18;
    
    mapping(bytes32 => bytes32) storage_map_a;
    uint256 public totalSupply;
    bytes32 store_d;
    mapping(bytes32 => bytes32) storage_map_f;
    bytes32 store_e;
    mapping(bytes32 => bytes32) storage_map_c;
    
    event Approval(address, address, uint256);
    error AuthorizationNotYetValid(uint256, uint256);
    event AuthorizationUsed(address, bytes32);
    event Transfer(address, address, uint256);
    event AuthorizationCanceled(address, bytes32);
    
    /// @custom:selector    0x095ea7b3
    /// @custom:signature   approve(address arg0, uint256 arg1) public payable returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function approve(address arg0, uint256 arg1) public payable returns (uint256) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg0 - (address(arg0)));
        require(!(address(msg.sender)), CustomError_94280d62());
        require(!(address(arg0)), CustomError_94280d62());
        var_a = address(arg0);
        storage_map_a[var_a] = arg1;
        emit Approval(address(msg.sender), address(arg0), arg1);
        return 0x01;
    }
    
    /// @custom:selector    0x88b7ab63
    /// @custom:signature   Unresolved_88b7ab63(address arg0, address arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5, uint256 arg6) public view
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    /// @param              arg6 ["uint256", "bytes32", "int256"]
    function Unresolved_88b7ab63(address arg0, address arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5, uint256 arg6) public view {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0xe0);
        require(arg0 - (address(arg0)));
        require(arg1 - (address(arg1)));
        require(arg6 > 0xffffffffffffffff);
        require(arg6 > 0xffffffffffffffff, CustomError_1c5939f3());
        require(((var_c + (uint248((0x20 + (0x1f + (arg6))) + 0x1f))) > 0xffffffffffffffff) | ((var_c + (uint248((0x20 + (0x1f + (arg6))) + 0x1f))) < var_c), CustomError_1c5939f3());
        require(msg.sender - (address(arg1)), CustomError_1c5939f3());
        require(!(block.timestamp > arg3), CustomError_498ff9a2());
        require(!(block.timestamp < arg4), CustomError_d309466d());
        var_a = arg5;
        require(bytes1(storage_map_a[var_a]), CustomError_d309466d());
    }
    
    /// @custom:selector    0xa9059cbb
    /// @custom:signature   transfer(address arg0, uint256 arg1) public payable returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function transfer(address arg0, uint256 arg1) public payable returns (uint256) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg0 - (address(arg0)));
        require(!(address(msg.sender)), CustomError_e450d38c());
        require(!(address(arg0)), CustomError_e450d38c());
        require(block.timestamp < 0x69b5fea5, CustomError_e450d38c());
        require(address(arg0).code.length, CustomError_e450d38c());
        require(address(arg0).code.length, CustomError_e450d38c());
        require(address(arg0).code.length, CustomError_e450d38c());
        address var_a = address(msg.sender);
        require(storage_map_a[var_a] < arg1, CustomError_e450d38c());
        var_a = address(msg.sender);
        storage_map_a[var_a] = storage_map_a[var_a] - arg1;
        var_a = address(arg0);
        storage_map_a[var_a] = storage_map_a[var_a] + arg1;
        emit Transfer(address(msg.sender), address(arg0), arg1);
        return 0x01;
        var_d = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).Unresolved_5cee8c69(var_d); // staticcall
        require(0x20 > ret0.length);
        require(((var_g + 0x20) > 0xffffffffffffffff) | ((var_g + 0x20) < var_g));
        uint256 var_g = var_g + 0x20;
        require(((var_g + 0x20) - var_g) < 0x20);
        require(var_g.length - var_g.length, CustomError_0f7f82fa());
        require(!var_g.length, CustomError_0f7f82fa());
        var_d = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        var_e = address(msg.sender);
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).Unresolved_5cee8c69(var_d, var_e); // staticcall
        require(0x20 > ret0.length);
        require(((var_g + 0x20) > 0xffffffffffffffff) | ((var_g + 0x20) < var_g));
        var_g = var_g + 0x20;
        require(((var_g + 0x20) - var_g) < 0x20);
        require(var_g.length - var_g.length);
        require(!var_g.length);
        var_e = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).Unresolved_5cee8c69(var_e); // staticcall
        if (0x20 > ret0.length) {
        }
        if (block.timestamp < 0x69b5fea5) {
        }
    }
    
    /// @custom:selector    0x7ecebe00
    /// @custom:signature   nonces(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function nonces(address arg0) public view returns (uint256) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(arg0 - (address(arg0)));
        address var_a = address(arg0);
        return storage_map_a[var_a];
    }
    
    /// @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(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(arg0 - (uint32(arg0)));
        require(!(uint32(arg0)) == 0xb0202a1100000000000000000000000000000000000000000000000000000000);
        require(!(uint32(arg0)) == 0xb0202a1100000000000000000000000000000000000000000000000000000000);
        require(!(uint32(arg0)) == 0xb0202a1100000000000000000000000000000000000000000000000000000000);
        require(!(uint32(arg0)) == 0xb0202a1100000000000000000000000000000000000000000000000000000000);
        return !(!(uint32(arg0)) == 0xb0202a1100000000000000000000000000000000000000000000000000000000);
        return !(!0x47be82f600000000000000000000000000000000000000000000000000000000 == (uint32(arg0)));
    }
    
    /// @custom:selector    0xd8fbe994
    /// @custom:signature   transferFromAndCall(address arg0, address arg1, uint256 arg2) public payable returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function transferFromAndCall(address arg0, address arg1, uint256 arg2) public payable returns (uint256) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x60);
        require(arg0 - (address(arg0)));
        require(arg1 - (address(arg1)));
        require(((var_a + 0x20) > 0xffffffffffffffff) | ((var_a + 0x20) < var_a), CustomError_e450d38c());
        uint256 var_a = var_a + 0x20;
        var_b = address(msg.sender);
        require(storage_map_c[var_b] < 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, CustomError_e450d38c());
        require(!(address(arg0)), CustomError_e450d38c());
        require(!(address(arg1)), CustomError_e450d38c());
        require(block.timestamp < 0x69b5fea5, CustomError_e450d38c());
        require(address(arg1).code.length, CustomError_e450d38c());
        require(address(arg1).code.length, CustomError_e450d38c());
        require(address(arg1).code.length, CustomError_e450d38c());
        var_b = address(arg0);
        require(storage_map_c[var_b] < arg2, CustomError_e450d38c());
        var_b = address(arg0);
        storage_map_c[var_b] = storage_map_c[var_b] - arg2;
        var_b = address(arg1);
        storage_map_c[var_b] = storage_map_c[var_b] + arg2;
        emit Transfer(address(arg0), address(arg1), arg2);
        require(!address(arg1).code.length, CustomError_8a96cd9c());
        var_g = address(msg.sender);
        (bool success, bytes memory ret0) = address(arg1).Unresolved_88a7ca5c(var_g); // call
        require(!ret0.length);
        require(var_m);
        require(ret0.length > 0xffffffffffffffff, CustomError_8a96cd9c());
        require(((var_a + (uint248((0x20 + (0x1f + ret0.length)) + 0x1f))) > 0xffffffffffffffff) | ((var_a + (uint248((0x20 + (0x1f + ret0.length)) + 0x1f))) < var_a), CustomError_8a96cd9c());
        var_a = var_a + (uint248((0x20 + (0x1f + ret0.length)) + 0x1f));
        require(var_a.length, CustomError_8a96cd9c());
        require(0x775835a400000000000000000000000000000000000000000000000000000000, CustomError_8a96cd9c());
        return 0x01;
        if (0x20 > ret0.length) {
        }
        var_g = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        var_h = address(arg1);
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).Unresolved_5cee8c69(var_g, var_h); // staticcall
        require(0x20 > ret0.length);
        require(((var_a + 0x20) > 0xffffffffffffffff) | ((var_a + 0x20) < var_a));
        var_a = var_a + 0x20;
        require(((var_a + 0x20) - var_a) < 0x20);
        require(var_a.length - var_a.length, CustomError_0f7f82fa());
        require(!var_a.length, CustomError_0f7f82fa());
        var_g = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        var_h = address(arg0);
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).isListed(var_g, var_h); // staticcall
        require(0x20 > ret0.length);
        require(((var_a + 0x20) > 0xffffffffffffffff) | ((var_a + 0x20) < var_a));
        var_b = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        var_a = var_a + 0x20;
        require(((var_a + 0x20) - var_a) < 0x20);
        require(var_a.length - var_a.length);
        require(!var_a.length);
        var_h = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        var_i = address(arg1);
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).Unresolved_5cee8c69(var_h, var_i); // staticcall
        if (0x20 > ret0.length) {
        }
        if (block.timestamp < 0x69b5fea5) {
        }
        require(storage_map_c[var_b] < arg2, CustomError_fb8f41b2());
        require(!(address(arg0)), CustomError_94280d62());
        require(!(address(msg.sender)), CustomError_94280d62());
    }
    
    /// @custom:selector    0xc1d34b89
    /// @custom:signature   Unresolved_c1d34b89(address arg0, address arg1, uint256 arg2, uint256 arg3) public payable returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    function Unresolved_c1d34b89(address arg0, address arg1, uint256 arg2, uint256 arg3) public payable returns (uint256) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x80);
        require(arg0 - (address(arg0)));
        require(arg1 - (address(arg1)));
        require(arg3 > 0xffffffffffffffff);
        require(arg3 > 0xffffffffffffffff, CustomError_e450d38c());
        require(((var_c + (uint248((0x20 + (0x1f + (arg3))) + 0x1f))) > 0xffffffffffffffff) | ((var_c + (uint248((0x20 + (0x1f + (arg3))) + 0x1f))) < var_c), CustomError_e450d38c());
        uint256 var_c = var_c + (uint248((0x20 + (0x1f + (arg3))) + 0x1f));
        var_a = address(msg.sender);
        require(storage_map_a[var_a] < 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, CustomError_e450d38c());
        require(!(address(arg0)), CustomError_e450d38c());
        require(!(address(arg1)), CustomError_e450d38c());
        require(block.timestamp < 0x69b5fea5, CustomError_e450d38c());
        require(address(arg1).code.length, CustomError_e450d38c());
        require(address(arg1).code.length, CustomError_e450d38c());
        require(address(arg1).code.length, CustomError_e450d38c());
        var_a = address(arg0);
        require(storage_map_a[var_a] < arg2, CustomError_e450d38c());
        var_a = address(arg0);
        storage_map_a[var_a] = storage_map_a[var_a] - arg2;
        var_a = address(arg1);
        storage_map_a[var_a] = storage_map_a[var_a] + arg2;
        emit Transfer(address(arg0), address(arg1), arg2);
        require(!address(arg1).code.length, CustomError_8a96cd9c());
        var_h = address(msg.sender);
        (bool success, bytes memory ret0) = address(arg1).Unresolved_88a7ca5c(var_h); // call
        require(!ret0.length);
        require(var_n);
        require(0x775835a400000000000000000000000000000000000000000000000000000000, CustomError_8a96cd9c());
        return 0x01;
        if (0x20 > ret0.length) {
        }
        var_h = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).Unresolved_5cee8c69(var_h); // staticcall
        require(0x20 > ret0.length);
        require(((var_c + 0x20) > 0xffffffffffffffff) | ((var_c + 0x20) < var_c));
        var_c = var_c + 0x20;
        require(((var_c + 0x20) - var_c) < 0x20);
        require(var_c.length - var_c.length, CustomError_0f7f82fa());
        require(!var_c.length, CustomError_0f7f82fa());
        var_h = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        var_i = address(arg0);
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).Unresolved_5cee8c69(var_h, var_i); // staticcall
        require(0x20 > ret0.length);
        require(((var_c + 0x20) > 0xffffffffffffffff) | ((var_c + 0x20) < var_c));
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        var_c = var_c + 0x20;
        require(((var_c + 0x20) - var_c) < 0x20);
        require(var_c.length - var_c.length);
        require(!var_c.length);
        var_i = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).Unresolved_5cee8c69(var_i); // staticcall
        if (0x20 > ret0.length) {
        }
        if (block.timestamp < 0x69b5fea5) {
        }
        require(storage_map_a[var_a] < arg2, CustomError_fb8f41b2());
        require(!(address(arg0)), CustomError_94280d62());
        require(!(address(msg.sender)), CustomError_94280d62());
    }
    
    /// @custom:selector    0xd505accf
    /// @custom:signature   permit(address arg0, address arg1, uint256 arg2, uint256 arg3, uint8 arg4, bytes32 arg5, bytes32 arg6) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["bool", "uint8", "bytes1", "int8"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    /// @param              arg6 ["uint256", "bytes32", "int256"]
    function permit(address arg0, address arg1, uint256 arg2, uint256 arg3, uint8 arg4, bytes32 arg5, bytes32 arg6) public payable {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0xe0);
        require(arg0 - (address(arg0)));
        require(arg1 - (address(arg1)));
        require(arg4 - (bytes1(arg4)));
        require(block.timestamp > arg3, CustomError_4b800e46());
        address var_a = address(arg0);
        storage_map_a[var_a] = storage_map_a[var_a] + 0x01;
        require(((var_j + 0xe0) > 0xffffffffffffffff) | ((var_j + 0xe0) < var_j), CustomError_4b800e46());
        uint256 var_j = var_j + 0xe0;
        require(0xf6f8db0aba00007681f8faf16a0fda1c9b030b11 == address(this), CustomError_4b800e46());
        require(!(block.chainid == 0x0171), CustomError_4b800e46());
        require(arg6 > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0, CustomError_4b800e46());
        require(!(0x03 < 0x04), CustomError_4b800e46());
        require(0x03, CustomError_4b800e46());
        require(0 - (address(arg0)), CustomError_4b800e46());
        require(!(address(arg0)), CustomError_94280d62());
        require(!(address(arg1)), CustomError_94280d62());
        var_a = address(arg1);
        address var_b = keccak256(var_a);
        storage_map_a[var_a] = arg2;
        emit Approval(address(arg0), address(arg1), arg2);
        require(0x02, CustomError_f645eedf());
        require(0x01, CustomError_fce698f7());
        require(0x03 == 0x03, CustomError_d78bce0c());
        address var_a = ecrecover(keccak256(var_r), bytes1(arg4), arg5, arg6);
        require(!var_b);
        if (!address(var_a)) {
        }
        if (((var_j + 0xc0) > 0xffffffffffffffff) | ((var_j + 0xc0) < var_j)) {
            var_j = var_j + 0xc0;
            require(((var_j + 0xc0) > 0xffffffffffffffff) | ((var_j + 0xc0) < var_j), CustomError_62791302());
        }
    }
    
    /// @custom:selector    0x3177029f
    /// @custom:signature   approveAndCall(address arg0, uint256 arg1) public payable returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function approveAndCall(address arg0, uint256 arg1) public payable returns (bool) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg0 - (address(arg0)));
        require(((var_a + 0x20) > 0xffffffffffffffff) | ((var_a + 0x20) < var_a), CustomError_deb6d3ed());
        uint256 var_a = var_a + 0x20;
        require(!(address(msg.sender)), CustomError_deb6d3ed());
        require(!(address(arg0)), CustomError_deb6d3ed());
        var_b = address(arg0);
        storage_map_c[var_b] = arg1;
        emit Approval(address(msg.sender), address(arg0), arg1);
        require(!address(arg0).code.length, CustomError_deb6d3ed());
        var_g = msg.sender;
        (bool success, bytes memory ret0) = address(arg0).Unresolved_7b04a2d0(var_g); // call
        require(!ret0.length);
        require(var_l);
        require(ret0.length > 0xffffffffffffffff, CustomError_deb6d3ed());
        require(((var_a + (uint248((0x20 + (0x1f + ret0.length)) + 0x1f))) > 0xffffffffffffffff) | ((var_a + (uint248((0x20 + (0x1f + ret0.length)) + 0x1f))) < var_a), CustomError_deb6d3ed());
        var_a = var_a + (uint248((0x20 + (0x1f + ret0.length)) + 0x1f));
        require(var_a.length, CustomError_deb6d3ed());
        require(0x84fb5d3000000000000000000000000000000000000000000000000000000000, CustomError_deb6d3ed());
        return 0x01;
        if (0x20 > ret0.length) {
        }
    }
    
    /// @custom:selector    0xdd62ed3e
    /// @custom:signature   allowance(address arg0, address arg1) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function allowance(address arg0, address arg1) public view returns (uint256) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg0 - (address(arg0)));
        require(arg1 - (address(arg1)));
        var_a = address(arg1);
        return storage_map_a[var_a];
    }
    
    /// @custom:selector    0x84b0196e
    /// @custom:signature   eip712Domain() public view
    function eip712Domain() public view {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0);
        require(0x50726f7665580000000000000000000000000000000000000000000000000006 == 0xff, CustomError_b3512b0c());
        require(!(bytes1(store_d)), CustomError_b3512b0c());
        require(bytes1(store_d) == ((store_d >> 0x01) < 0x20), CustomError_b3512b0c());
        require(!(bytes1(store_d)), CustomError_b3512b0c());
        require(0x01 == (bytes1(store_d)), CustomError_b3512b0c());
        require(0 < (store_d >> 0x01), CustomError_b3512b0c());
        require(((var_d + (uint248((((var_d + 0) + 0x20) - var_d) + 0x1f))) > 0xffffffffffffffff) | ((var_d + (uint248((((var_d + 0) + 0x20) - var_d) + 0x1f))) < var_d), CustomError_b3512b0c());
        uint248 var_d = var_d + (uint248((((var_d + 0) + 0x20) - var_d) + 0x1f));
        require(0x3100000000000000000000000000000000000000000000000000000000000001 == 0xff, CustomError_b3512b0c());
        require(!(bytes1(store_e)), CustomError_b3512b0c());
        require(bytes1(store_e) == ((store_e >> 0x01) < 0x20), CustomError_b3512b0c());
        require(!(bytes1(store_e)), CustomError_b3512b0c());
        require(0x01 == (bytes1(store_e)), CustomError_b3512b0c());
        require(0 < (store_e >> 0x01), CustomError_b3512b0c());
        require(((var_d + (uint248((((var_d + 0) + 0x20) - var_d) + 0x1f))) > 0xffffffffffffffff) | ((var_d + (uint248((((var_d + 0) + 0x20) - var_d) + 0x1f))) < var_d), CustomError_b3512b0c());
        var_d = var_d + (uint248((((var_d + 0) + 0x20) - var_d) + 0x1f));
        require(((var_d + 0x20) > 0xffffffffffffffff) | ((var_d + 0x20) < var_d), CustomError_b3512b0c());
        var_d = var_d + 0x20;
        require(((var_d + (uint248((0 - var_d) + 0x1f))) > 0xffffffffffffffff) | ((var_d + (uint248((0 - var_d) + 0x1f))) < var_d), CustomError_b3512b0c());
        require(0x01 > 0x1f, CustomError_b3512b0c());
        require(((var_d + 0x40) > 0xffffffffffffffff) | ((var_d + 0x40) < var_d), CustomError_b3512b0c());
        require(0x06 > 0x1f, CustomError_b3512b0c());
    }
    
    /// @custom:selector    0xef55bec6
    /// @custom:signature   receiveWithAuthorization(address arg0, address arg1, uint256 arg2, uint256 arg3, uint256 arg4, bytes32 arg5, uint8 arg6, bytes32 arg7, bytes32 arg8) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    /// @param              arg6 ["bool", "uint8", "bytes1", "int8"]
    /// @param              arg7 ["uint256", "bytes32", "int256"]
    /// @param              arg8 ["uint256", "bytes32", "int256"]
    function receiveWithAuthorization(address arg0, address arg1, uint256 arg2, uint256 arg3, uint256 arg4, bytes32 arg5, uint8 arg6, bytes32 arg7, bytes32 arg8) public payable {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x0120);
        require(arg0 - (address(arg0)));
        require(arg1 - (address(arg1)));
        require(arg6 - (bytes1(arg6)));
        require(msg.sender - (address(arg1)), CustomError_1c5939f3());
        require(!(block.timestamp > arg3), CustomError_498ff9a2());
        require(!(block.timestamp < arg4), CustomError_d309466d());
        var_d = arg5;
        require(bytes1(storage_map_f[var_d]), CustomError_d309466d());
        require(((var_m + (uint248((((var_m + 0x20) + 0xe0) - var_m) + 0x1f))) > 0xffffffffffffffff) | ((var_m + (uint248((((var_m + 0x20) + 0xe0) - var_m) + 0x1f))) < var_m), CustomError_8baa579f());
        uint248 var_m = var_m + (uint248((((var_m + 0x20) + 0xe0) - var_m) + 0x1f));
        require(0xf6f8db0aba00007681f8faf16a0fda1c9b030b11 == address(this), CustomError_8baa579f());
        require(!(block.chainid == 0x0171), CustomError_8baa579f());
        require(arg8 > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0, CustomError_8baa579f());
        require(!(0x03 < 0x04), CustomError_8baa579f());
        require(0x03, CustomError_8baa579f());
        require(0 - (address(arg0)), CustomError_8baa579f());
        var_d = arg5;
        storage_map_f[var_d] = 0x01 | (uint248(storage_map_f[var_d]));
        emit AuthorizationUsed(address(arg0), arg5);
        require(!(address(arg0)), CustomError_e450d38c());
        require(!(address(arg1)), CustomError_e450d38c());
        require(block.timestamp < 0x69b5fea5, CustomError_e450d38c());
        require(address(arg1).code.length, CustomError_e450d38c());
        require(address(arg1).code.length, CustomError_e450d38c());
        require(address(arg1).code.length, CustomError_e450d38c());
        var_d = address(arg0);
        require(storage_map_f[var_d] < arg2, CustomError_e450d38c());
        var_d = address(arg0);
        var_e = 0;
        storage_map_f[var_d] = storage_map_f[var_d] - arg2;
        var_d = address(arg1);
        storage_map_f[var_d] = storage_map_f[var_d] + arg2;
        emit Transfer(address(arg0), address(arg1), arg2);
        var_s = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).Unresolved_5cee8c69(var_s); // staticcall
        if (0x20 > ret0.length) {
        }
        var_s = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).Unresolved_5cee8c69(var_s); // staticcall
        if (0x20 > ret0.length) {
        }
        require(block.timestamp < 0x69b5fea5, CustomError_0f7f82fa());
        require(block.timestamp < 0x69b5fea5, CustomError_0f7f82fa());
        require(block.timestamp < 0x69b5fea5, CustomError_0f7f82fa());
        require(0x02, CustomError_f645eedf());
        require(0x01, CustomError_fce698f7());
        require(0x03 == 0x03, CustomError_d78bce0c());
        address var_d = ecrecover(keccak256(var_v), bytes1(arg6), arg7, arg8);
        require(!var_e);
        if (!address(var_d)) {
        }
        if (((var_m + 0xc0) > 0xffffffffffffffff) | ((var_m + 0xc0) < var_m)) {
            var_m = var_m + 0xc0;
            require(((var_m + 0xc0) > 0xffffffffffffffff) | ((var_m + 0xc0) < var_m), CustomError_b3fcd33e());
        }
    }
    
    /// @custom:selector    0xb7b72899
    /// @custom:signature   Unresolved_b7b72899(address arg0, uint256 arg1, uint256 arg2) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function Unresolved_b7b72899(address arg0, uint256 arg1, uint256 arg2) public payable {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x60);
        require(arg0 - (address(arg0)));
        require(arg2 > 0xffffffffffffffff);
        require(arg2 > 0xffffffffffffffff, CustomError_d309466d());
        require(((var_c + (uint248((0x20 + (0x1f + (arg2))) + 0x1f))) > 0xffffffffffffffff) | ((var_c + (uint248((0x20 + (0x1f + (arg2))) + 0x1f))) < var_c), CustomError_d309466d());
        uint256 var_c = var_c + (uint248((0x20 + (0x1f + (arg2))) + 0x1f));
        var_e = msg.data[36:36];
        var_a = arg1;
        require(bytes1(storage_map_a[var_a]), CustomError_d309466d());
        require(((var_c + 0x80) > 0xffffffffffffffff) | ((var_c + 0x80) < var_c), CustomError_8baa579f());
        var_c = var_c + 0x80;
        require(0xf6f8db0aba00007681f8faf16a0fda1c9b030b11 == address(this), CustomError_8baa579f());
        require(!(block.chainid == 0x0171), CustomError_8baa579f());
        require(address(arg0).code.length, CustomError_8baa579f());
        require(var_c.length - 0x41, CustomError_8baa579f());
        require(var_p > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0, CustomError_8baa579f());
        require(!(0x03 < 0x04), CustomError_8baa579f());
        require(!0x03, CustomError_8baa579f());
        require(!(address(arg0) == 0), CustomError_8baa579f());
        var_a = arg1;
        storage_map_a[var_a] = (uint248(storage_map_a[var_a])) | 0x01;
        emit AuthorizationCanceled(address(arg0), arg1);
        require(0x03, CustomError_8baa579f());
        var_a = arg1;
        var_g = keccak256(var_a);
        storage_map_a[var_a] = (uint248(storage_map_a[var_a])) | 0x01;
        emit AuthorizationCanceled(address(arg0), arg1);
        address var_a = ecrecover(keccak256(var_q), bytes1(var_s), var_e, var_p);
        require(!var_g);
        if (!address(var_a)) {
        }
        if (((var_c + 0xc0) > 0xffffffffffffffff) | ((var_c + 0xc0) < var_c)) {
            var_c = var_c + 0xc0;
            require(((var_c + 0xc0) > 0xffffffffffffffff) | ((var_c + 0xc0) < var_c));
        }
    }
    
    /// @custom:selector    0x79cc6790
    /// @custom:signature   burnFrom(address arg0, uint256 arg1) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function burnFrom(address arg0, uint256 arg1) public payable {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x40);
        require(arg0 - (address(arg0)));
        var_a = address(msg.sender);
        require(storage_map_a[var_a] < 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, CustomError_e450d38c());
        require(!(address(arg0)), CustomError_e450d38c());
        require(block.timestamp < 0x69b5fea5, CustomError_e450d38c());
        require(address(0).code.length, CustomError_e450d38c());
        require(address(0).code.length, CustomError_e450d38c());
        require(address(0).code.length, CustomError_e450d38c());
        var_a = address(arg0);
        require(storage_map_a[var_a] < arg1, CustomError_e450d38c());
        var_a = address(arg0);
        storage_map_a[var_a] = storage_map_a[var_a] - arg1;
        totalSupply = totalSupply - arg1;
        emit Transfer(address(arg0), 0, arg1);
        var_d = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).Unresolved_5cee8c69(var_d); // staticcall
        require(0x20 > ret0.length);
        require(((var_g + 0x20) > 0xffffffffffffffff) | ((var_g + 0x20) < var_g));
        uint256 var_g = var_g + 0x20;
        require(((var_g + 0x20) - var_g) < 0x20);
        require(var_g.length - var_g.length, CustomError_0f7f82fa());
        require(!var_g.length, CustomError_0f7f82fa());
        var_d = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        var_e = address(arg0);
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).Unresolved_5cee8c69(var_d, var_e); // staticcall
        require(0x20 > ret0.length);
        require(((var_g + 0x20) > 0xffffffffffffffff) | ((var_g + 0x20) < var_g));
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        var_g = var_g + 0x20;
        require(((var_g + 0x20) - var_g) < 0x20);
        require(var_g.length - var_g.length);
        require(!var_g.length);
        var_e = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).Unresolved_5cee8c69(var_e); // staticcall
        if (0x20 > ret0.length) {
        }
        if (block.timestamp < 0x69b5fea5) {
        }
        require(storage_map_a[var_a] < arg1, CustomError_fb8f41b2());
        require(!(address(arg0)), CustomError_94280d62());
        require(!(address(msg.sender)), CustomError_94280d62());
    }
    
    /// @custom:selector    0x23b872dd
    /// @custom:signature   transferFrom(address arg0, address arg1, uint256 arg2) public payable returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function transferFrom(address arg0, address arg1, uint256 arg2) public payable returns (uint256) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x60);
        require(arg0 - (address(arg0)));
        require(arg1 - (address(arg1)));
        var_a = address(msg.sender);
        require(storage_map_a[var_a] < 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, CustomError_e450d38c());
        require(!(address(arg0)), CustomError_e450d38c());
        require(!(address(arg1)), CustomError_e450d38c());
        require(block.timestamp < 0x69b5fea5, CustomError_e450d38c());
        require(address(arg1).code.length, CustomError_e450d38c());
        require(address(arg1).code.length, CustomError_e450d38c());
        require(address(arg1).code.length, CustomError_e450d38c());
        var_a = address(arg0);
        require(storage_map_a[var_a] < arg2, CustomError_e450d38c());
        var_a = address(arg0);
        storage_map_a[var_a] = storage_map_a[var_a] - arg2;
        var_a = address(arg1);
        storage_map_a[var_a] = storage_map_a[var_a] + arg2;
        emit Transfer(address(arg0), address(arg1), arg2);
        return 0x01;
        var_d = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).Unresolved_5cee8c69(var_d); // staticcall
        require(0x20 > ret0.length);
        require(((var_g + 0x20) > 0xffffffffffffffff) | ((var_g + 0x20) < var_g));
        uint256 var_g = var_g + 0x20;
        require(((var_g + 0x20) - var_g) < 0x20);
        require(var_g.length - var_g.length, CustomError_0f7f82fa());
        require(!var_g.length, CustomError_0f7f82fa());
        var_d = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        var_e = address(arg0);
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).Unresolved_5cee8c69(var_d, var_e); // staticcall
        require(0x20 > ret0.length);
        require(((var_g + 0x20) > 0xffffffffffffffff) | ((var_g + 0x20) < var_g));
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        var_g = var_g + 0x20;
        require(((var_g + 0x20) - var_g) < 0x20);
        require(var_g.length - var_g.length);
        require(!var_g.length);
        var_e = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).Unresolved_5cee8c69(var_e); // staticcall
        if (0x20 > ret0.length) {
        }
        if (block.timestamp < 0x69b5fea5) {
        }
        require(storage_map_a[var_a] < arg2, CustomError_fb8f41b2());
        require(!(address(arg0)), CustomError_94280d62());
        require(!(address(msg.sender)), CustomError_94280d62());
    }
    
    /// @custom:selector    0x3644e515
    /// @custom:signature   fopwCDKKK() public view returns (uint256)
    function fopwCDKKK() public view returns (uint256) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0);
        if (0xf6f8db0aba00007681f8faf16a0fda1c9b030b11 == address(this)) {
            if (!block.chainid == 0x0171) {
                return 0xa4733fec5080648f56a330af587b39b47fda3e04d831895c27dab6511e759323;
                if (((var_g + 0xc0) > 0xffffffffffffffff) | ((var_g + 0xc0) < var_g)) {
                    return keccak256(var_k);
                }
            }
        }
    }
    
    /// @custom:selector    0x70a08231
    /// @custom:signature   balanceOf(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function balanceOf(address arg0) public view returns (uint256) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(arg0 - (address(arg0)));
        address var_a = address(arg0);
        return storage_map_a[var_a];
    }
    
    /// @custom:selector    0x1296ee62
    /// @custom:signature   transferAndCall(address arg0, uint256 arg1) public payable returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function transferAndCall(address arg0, uint256 arg1) public payable returns (uint256) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg0 - (address(arg0)));
        require(((var_a + 0x20) > 0xffffffffffffffff) | ((var_a + 0x20) < var_a), CustomError_e450d38c());
        uint256 var_a = var_a + 0x20;
        require(!(address(msg.sender)), CustomError_e450d38c());
        require(!(address(arg0)), CustomError_e450d38c());
        require(block.timestamp < 0x69b5fea5, CustomError_e450d38c());
        require(address(arg0).code.length, CustomError_e450d38c());
        require(address(arg0).code.length, CustomError_e450d38c());
        require(address(arg0).code.length, CustomError_e450d38c());
        address var_b = address(msg.sender);
        require(storage_map_c[var_b] < arg1, CustomError_e450d38c());
        var_b = address(msg.sender);
        storage_map_c[var_b] = storage_map_c[var_b] - arg1;
        var_b = address(arg0);
        storage_map_c[var_b] = storage_map_c[var_b] + arg1;
        emit Transfer(address(msg.sender), address(arg0), arg1);
        require(!address(arg0).code.length, CustomError_8a96cd9c());
        var_g = address(msg.sender);
        (bool success, bytes memory ret0) = address(arg0).Unresolved_88a7ca5c(var_g); // call
        require(!ret0.length);
        require(var_m);
        require(ret0.length > 0xffffffffffffffff, CustomError_8a96cd9c());
        require(((var_a + (uint248((0x20 + (0x1f + ret0.length)) + 0x1f))) > 0xffffffffffffffff) | ((var_a + (uint248((0x20 + (0x1f + ret0.length)) + 0x1f))) < var_a), CustomError_8a96cd9c());
        var_a = var_a + (uint248((0x20 + (0x1f + ret0.length)) + 0x1f));
        require(var_a.length, CustomError_8a96cd9c());
        require(0x775835a400000000000000000000000000000000000000000000000000000000, CustomError_8a96cd9c());
        return 0x01;
        if (0x20 > ret0.length) {
        }
        var_g = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        var_h = address(arg0);
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).Unresolved_5cee8c69(var_g, var_h); // staticcall
        require(0x20 > ret0.length);
        require(((var_a + 0x20) > 0xffffffffffffffff) | ((var_a + 0x20) < var_a));
        var_a = var_a + 0x20;
        require(((var_a + 0x20) - var_a) < 0x20);
        require(var_a.length - var_a.length, CustomError_0f7f82fa());
        require(!var_a.length, CustomError_0f7f82fa());
        var_g = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        var_h = address(msg.sender);
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).isListed(var_g, var_h); // staticcall
        require(0x20 > ret0.length);
        require(((var_a + 0x20) > 0xffffffffffffffff) | ((var_a + 0x20) < var_a));
        var_a = var_a + 0x20;
        require(((var_a + 0x20) - var_a) < 0x20);
        require(var_a.length - var_a.length);
        require(!var_a.length);
        var_h = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        var_i = address(arg0);
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).Unresolved_5cee8c69(var_h, var_i); // staticcall
        if (0x20 > ret0.length) {
        }
        if (block.timestamp < 0x69b5fea5) {
        }
    }
    
    /// @custom:selector    0xe3ee160e
    /// @custom:signature   transferWithAuthorization(address arg0, address arg1, uint256 arg2, uint256 arg3, uint256 arg4, bytes32 arg5, uint8 arg6, bytes32 arg7, bytes32 arg8) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    /// @param              arg6 ["bool", "uint8", "bytes1", "int8"]
    /// @param              arg7 ["uint256", "bytes32", "int256"]
    /// @param              arg8 ["uint256", "bytes32", "int256"]
    function transferWithAuthorization(address arg0, address arg1, uint256 arg2, uint256 arg3, uint256 arg4, bytes32 arg5, uint8 arg6, bytes32 arg7, bytes32 arg8) public payable {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x0120);
        require(arg0 - (address(arg0)));
        require(arg1 - (address(arg1)));
        require(arg6 - (bytes1(arg6)));
        require(!(block.timestamp > arg3), CustomError_498ff9a2());
        require(!(block.timestamp < arg4), CustomError_d309466d());
        var_d = arg5;
        require(bytes1(storage_map_f[var_d]), CustomError_d309466d());
        require(((var_m + (uint248((((var_m + 0x20) + 0xe0) - var_m) + 0x1f))) > 0xffffffffffffffff) | ((var_m + (uint248((((var_m + 0x20) + 0xe0) - var_m) + 0x1f))) < var_m), CustomError_8baa579f());
        uint248 var_m = var_m + (uint248((((var_m + 0x20) + 0xe0) - var_m) + 0x1f));
        require(0xf6f8db0aba00007681f8faf16a0fda1c9b030b11 == address(this), CustomError_8baa579f());
        require(!(block.chainid == 0x0171), CustomError_8baa579f());
        require(arg8 > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0, CustomError_8baa579f());
        require(!(0x03 < 0x04), CustomError_8baa579f());
        require(0x03, CustomError_8baa579f());
        require(0 - (address(arg0)), CustomError_8baa579f());
        var_d = arg5;
        storage_map_f[var_d] = 0x01 | (uint248(storage_map_f[var_d]));
        emit AuthorizationUsed(address(arg0), arg5);
        require(!(address(arg0)), CustomError_e450d38c());
        require(!(address(arg1)), CustomError_e450d38c());
        require(block.timestamp < 0x69b5fea5, CustomError_e450d38c());
        require(address(arg1).code.length, CustomError_e450d38c());
        require(address(arg1).code.length, CustomError_e450d38c());
        require(address(arg1).code.length, CustomError_e450d38c());
        var_d = address(arg0);
        require(storage_map_f[var_d] < arg2, CustomError_e450d38c());
        var_d = address(arg0);
        var_e = 0;
        storage_map_f[var_d] = storage_map_f[var_d] - arg2;
        var_d = address(arg1);
        storage_map_f[var_d] = storage_map_f[var_d] + arg2;
        emit Transfer(address(arg0), address(arg1), arg2);
        var_s = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).Unresolved_5cee8c69(var_s); // staticcall
        if (0x20 > ret0.length) {
        }
        var_s = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).Unresolved_5cee8c69(var_s); // staticcall
        if (0x20 > ret0.length) {
        }
        require(block.timestamp < 0x69b5fea5, CustomError_0f7f82fa());
        require(block.timestamp < 0x69b5fea5, CustomError_0f7f82fa());
        require(block.timestamp < 0x69b5fea5, CustomError_0f7f82fa());
        require(0x02, CustomError_f645eedf());
        require(0x01, CustomError_fce698f7());
        require(0x03 == 0x03, CustomError_d78bce0c());
        address var_d = ecrecover(keccak256(var_v), bytes1(arg6), arg7, arg8);
        require(!var_e);
        if (!address(var_d)) {
        }
        if (((var_m + 0xc0) > 0xffffffffffffffff) | ((var_m + 0xc0) < var_m)) {
            var_m = var_m + 0xc0;
            require(((var_m + 0xc0) > 0xffffffffffffffff) | ((var_m + 0xc0) < var_m), CustomError_b3fcd33e());
        }
    }
    
    /// @custom:selector    0xcf092995
    /// @custom:signature   Unresolved_cf092995(address arg0, address arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5, uint256 arg6) public view
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    /// @param              arg6 ["uint256", "bytes32", "int256"]
    function Unresolved_cf092995(address arg0, address arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5, uint256 arg6) public view {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0xe0);
        require(arg0 - (address(arg0)));
        require(arg1 - (address(arg1)));
        require(arg6 > 0xffffffffffffffff);
        require(arg6 > 0xffffffffffffffff, CustomError_498ff9a2());
        require(((var_c + (uint248((0x20 + (0x1f + (arg6))) + 0x1f))) > 0xffffffffffffffff) | ((var_c + (uint248((0x20 + (0x1f + (arg6))) + 0x1f))) < var_c), CustomError_498ff9a2());
        require(!(block.timestamp > arg3), CustomError_498ff9a2());
        require(!(block.timestamp < arg4), CustomError_d309466d());
        var_a = arg5;
        require(bytes1(storage_map_a[var_a]), CustomError_d309466d());
    }
    
    /// @custom:selector    0x42966c68
    /// @custom:signature   burn(uint256 arg0) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function burn(uint256 arg0) public payable {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20, CustomError_e450d38c());
        require(!(address(msg.sender)), CustomError_e450d38c());
        require(block.timestamp < 0x69b5fea5, CustomError_e450d38c());
        require(address(0).code.length, CustomError_e450d38c());
        require(address(0).code.length, CustomError_e450d38c());
        require(address(0).code.length, CustomError_e450d38c());
        address var_a = address(msg.sender);
        require(storage_map_a[var_a] < arg0, CustomError_e450d38c());
        var_a = address(msg.sender);
        storage_map_a[var_a] = storage_map_a[var_a] - arg0;
        totalSupply = totalSupply - arg0;
        emit Transfer(address(msg.sender), 0, arg0);
        var_d = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).Unresolved_5cee8c69(var_d); // staticcall
        require(0x20 > ret0.length);
        require(((var_g + 0x20) > 0xffffffffffffffff) | ((var_g + 0x20) < var_g));
        uint256 var_g = var_g + 0x20;
        require(((var_g + 0x20) - var_g) < 0x20);
        require(var_g.length - var_g.length, CustomError_0f7f82fa());
        require(!var_g.length, CustomError_0f7f82fa());
        var_d = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        var_e = address(msg.sender);
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).Unresolved_5cee8c69(var_d, var_e); // staticcall
        require(0x20 > ret0.length);
        require(((var_g + 0x20) > 0xffffffffffffffff) | ((var_g + 0x20) < var_g));
        var_g = var_g + 0x20;
        require(((var_g + 0x20) - var_g) < 0x20);
        require(var_g.length - var_g.length);
        require(!var_g.length);
        var_e = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).Unresolved_5cee8c69(var_e); // staticcall
        if (0x20 > ret0.length) {
        }
        if (block.timestamp < 0x69b5fea5) {
        }
    }
    
    /// @custom:selector    0xe94a0102
    /// @custom:signature   authorizationState(address arg0, bytes32 arg1) public view returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function authorizationState(address arg0, bytes32 arg1) public view returns (bool) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg0 - (address(arg0)));
        var_a = arg1;
        return !(!bytes1(storage_map_a[var_a]));
    }
    
    /// @custom:selector    0x4000aea0
    /// @custom:signature   Unresolved_4000aea0(address arg0, uint256 arg1, uint256 arg2) public payable returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function Unresolved_4000aea0(address arg0, uint256 arg1, uint256 arg2) public payable returns (uint256) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x60);
        require(arg0 - (address(arg0)));
        require(arg2 > 0xffffffffffffffff);
        require(arg2 > 0xffffffffffffffff, CustomError_e450d38c());
        require(((var_c + (uint248((0x20 + (0x1f + (arg2))) + 0x1f))) > 0xffffffffffffffff) | ((var_c + (uint248((0x20 + (0x1f + (arg2))) + 0x1f))) < var_c), CustomError_e450d38c());
        uint256 var_c = var_c + (uint248((0x20 + (0x1f + (arg2))) + 0x1f));
        require(!(address(msg.sender)), CustomError_e450d38c());
        require(!(address(arg0)), CustomError_e450d38c());
        require(block.timestamp < 0x69b5fea5, CustomError_e450d38c());
        require(address(arg0).code.length, CustomError_e450d38c());
        require(address(arg0).code.length, CustomError_e450d38c());
        require(address(arg0).code.length, CustomError_e450d38c());
        address var_a = address(msg.sender);
        require(storage_map_a[var_a] < arg1, CustomError_e450d38c());
        var_a = address(msg.sender);
        storage_map_a[var_a] = storage_map_a[var_a] - arg1;
        var_a = address(arg0);
        storage_map_a[var_a] = storage_map_a[var_a] + arg1;
        emit Transfer(address(msg.sender), address(arg0), arg1);
        require(!address(arg0).code.length, CustomError_8a96cd9c());
        var_h = address(msg.sender);
        (bool success, bytes memory ret0) = address(arg0).Unresolved_88a7ca5c(var_h); // call
        require(!ret0.length);
        require(var_n);
        require(0x775835a400000000000000000000000000000000000000000000000000000000, CustomError_8a96cd9c());
        return 0x01;
        if (0x20 > ret0.length) {
        }
        var_h = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).Unresolved_5cee8c69(var_h); // staticcall
        require(0x20 > ret0.length);
        require(((var_c + 0x20) > 0xffffffffffffffff) | ((var_c + 0x20) < var_c));
        var_c = var_c + 0x20;
        require(((var_c + 0x20) - var_c) < 0x20);
        require(var_c.length - var_c.length, CustomError_0f7f82fa());
        require(!var_c.length, CustomError_0f7f82fa());
        var_h = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        var_i = address(msg.sender);
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).Unresolved_5cee8c69(var_h, var_i); // staticcall
        require(0x20 > ret0.length);
        require(((var_c + 0x20) > 0xffffffffffffffff) | ((var_c + 0x20) < var_c));
        var_c = var_c + 0x20;
        require(((var_c + 0x20) - var_c) < 0x20);
        require(var_c.length - var_c.length);
        require(!var_c.length);
        var_i = 0x8bd31a08510c1295ade1a4efe321a8910ae4345ed5dcdd9fd635267266fc6eaf;
        (bool success, bytes memory ret0) = address(0xea5ae90a082927a65dd247fc1df490710cc01c49).Unresolved_5cee8c69(var_i); // staticcall
        if (0x20 > ret0.length) {
        }
        if (block.timestamp < 0x69b5fea5) {
        }
    }
    
    /// @custom:selector    0xcae9ca51
    /// @custom:signature   Unresolved_cae9ca51(address arg0, uint256 arg1, uint256 arg2) public payable returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function Unresolved_cae9ca51(address arg0, uint256 arg1, uint256 arg2) public payable returns (bool) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x60);
        require(arg0 - (address(arg0)));
        require(arg2 > 0xffffffffffffffff);
        require(arg2 > 0xffffffffffffffff, CustomError_deb6d3ed());
        require(((var_c + (uint248((0x20 + (0x1f + (arg2))) + 0x1f))) > 0xffffffffffffffff) | ((var_c + (uint248((0x20 + (0x1f + (arg2))) + 0x1f))) < var_c), CustomError_deb6d3ed());
        uint256 var_c = var_c + (uint248((0x20 + (0x1f + (arg2))) + 0x1f));
        require(!(address(msg.sender)), CustomError_deb6d3ed());
        require(!(address(arg0)), CustomError_deb6d3ed());
        var_a = address(arg0);
        storage_map_a[var_a] = arg1;
        emit Approval(address(msg.sender), address(arg0), arg1);
        require(!address(arg0).code.length, CustomError_deb6d3ed());
        var_h = msg.sender;
        (bool success, bytes memory ret0) = address(arg0).Unresolved_7b04a2d0(var_h); // call
        require(!ret0.length);
        require(var_m);
        require(0x84fb5d3000000000000000000000000000000000000000000000000000000000, CustomError_deb6d3ed());
        return 0x01;
        if (0x20 > ret0.length) {
        }
    }
    
    /// @custom:selector    0x5a049a70
    /// @custom:signature   cancelAuthorization(address arg0, bytes32 arg1, uint8 arg2, bytes32 arg3, bytes32 arg4) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["bool", "uint8", "bytes1", "int8"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    function cancelAuthorization(address arg0, bytes32 arg1, uint8 arg2, bytes32 arg3, bytes32 arg4) public payable {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0xa0);
        require(arg0 - (address(arg0)));
        require(arg2 - (bytes1(arg2)));
        var_a = arg1;
        require(bytes1(storage_map_a[var_a]), CustomError_d309466d());
        require(((var_i + 0x80) > 0xffffffffffffffff) | ((var_i + 0x80) < var_i), CustomError_8baa579f());
        uint256 var_i = var_i + 0x80;
        require(0xf6f8db0aba00007681f8faf16a0fda1c9b030b11 == address(this), CustomError_8baa579f());
        require(!(block.chainid == 0x0171), CustomError_8baa579f());
        require(arg4 > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0, CustomError_8baa579f());
        require(!(0x03 < 0x04), CustomError_8baa579f());
        require(0x03, CustomError_8baa579f());
        require(0 - (address(arg0)), CustomError_8baa579f());
        var_a = arg1;
        var_b = keccak256(var_a);
        storage_map_a[var_a] = (uint248(storage_map_a[var_a])) | 0x01;
        emit AuthorizationCanceled(address(arg0), arg1);
        require(0x02, CustomError_f645eedf());
        require(0x01, CustomError_fce698f7());
        require(0x03 == 0x03, CustomError_d78bce0c());
        address var_a = ecrecover(keccak256(var_p), bytes1(arg2), arg3, arg4);
        require(!var_b);
        if (!address(var_a)) {
        }
        if (((var_i + 0xc0) > 0xffffffffffffffff) | ((var_i + 0xc0) < var_i)) {
            var_i = var_i + 0xc0;
            require(((var_i + 0xc0) > 0xffffffffffffffff) | ((var_i + 0xc0) < var_i));
        }
    }
}