0x3819f64f282bf135d62168c1e513280daf905e06

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 decimals = 9;
    
    bytes32 store_d;
    mapping(bytes32 => bytes32) storage_map_f;
    address public hsim;
    bytes32 store_k;
    mapping(bytes32 => bytes32) storage_map_h;
    mapping(bytes32 => bytes32) storage_map_g;
    bytes32 store_j;
    uint256 public unresolved_18160ddd;
    mapping(bytes32 => bytes32) storage_map_b;
    bytes32 store_e;
    mapping(bytes32 => bytes32) storage_map_m;
    bytes32 store_l;
    uint256 public loanedSupply;
    mapping(bytes32 => bytes32) storage_map_n;
    mapping(bytes32 => bytes32) storage_map_c;
    
    event Event_8c5be1e5();
    event Transfer(address, address, uint256);
    
    /// @custom:selector    0x095ea7b3
    /// @custom:signature   Unresolved_095ea7b3(address arg0, uint256 arg1) public payable returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_095ea7b3(address arg0, uint256 arg1) public payable returns (bool) {
        require(arg0 == (address(arg0)));
        require(address(msg.sender), "ERC20: approve to the zero address");
        require(address(arg0), "ERC20: approve to the zero address");
        var_a = address(arg0);
        storage_map_b[var_a] = arg1;
        emit Event_8c5be1e5(address(msg.sender), address(arg0), arg1);
        return 0x01;
    }
    
    /// @custom:selector    0xd240a93a
    /// @custom:signature   proofOfBenevolence(uint256 arg0) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function proofOfBenevolence(uint256 arg0) public payable {
        require(!(block.timestamp < 0x62196d80), "HDRN: Contract not yet active");
        var_d = var_d;
        uint256 var_f = 0xa0 + var_f;
        require(!(block.timestamp < 0x62196d80), "HDRN: Insufficient balance to facilitate PoB");
        require(0x015180, "HDRN: Insufficient balance to facilitate PoB");
        uint256 var_d = (block.timestamp - 0x62196d80) / 0x015180;
        require(uint32(storage_map_c[var_d] / 0x01000000000000000000000000000000000000000000000000000000), "HDRN: Insufficient balance to facilitate PoB");
        var_d = msg.sender;
        require(!(arg0 > storage_map_c[var_d]), "HDRN: Insufficient balance to facilitate PoB");
        var_d = address(this);
        require(!(storage_map_c[var_d] < arg0), "HDRN: Burn amount exceeds allowance");
        require(!(var_r > ~(arg0)), "ERC20: burn amount exceeds balance");
        var_d = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        storage_map_c[var_d] = (uint248(address(uint72(var_f.length) | (uint112(storage_map_c[var_d])) | (0x01000000000000000000 * (uint72(var_s)))) | (uint224(0x01000000000000000000000000000000000000 * (uint72(var_t)))) | (0x01000000000000000000000000000000000000000000000000000000 * (uint32(var_u))))) | (0x0100000000000000000000000000000000000000000000000000000000000000 * (bytes1(var_v)));
        require(address(msg.sender), "ERC20: burn amount exceeds balance");
        require(address(this), "ERC20: burn amount exceeds balance");
        var_d = address(this);
        storage_map_c[var_d] = storage_map_c[var_d] - arg0;
        emit Event_8c5be1e5(address(msg.sender), address(this), storage_map_c[var_d] - arg0);
        require(address(msg.sender), "ERC20: burn amount exceeds balance");
        var_d = address(msg.sender);
        require(!(storage_map_c[var_d] < arg0), "ERC20: burn amount exceeds balance");
        var_d = address(msg.sender);
        storage_map_c[var_d] = storage_map_c[var_d] - arg0;
        require(!(unresolved_18160ddd < arg0), "ERC20: burn from the zero address");
        unresolved_18160ddd = unresolved_18160ddd - arg0;
        emit Transfer(address(msg.sender), 0, arg0);
    }
    
    /// @custom:selector    0x10d9d349
    /// @custom:signature   Unresolved_10d9d349(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_10d9d349(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
    
    /// @custom:selector    0xa9059cbb
    /// @custom:signature   transfer(address arg0, uint256 arg1) public payable returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function transfer(address arg0, uint256 arg1) public payable returns (bool) {
        require(arg0 == (address(arg0)));
        require(address(msg.sender), "ERC20: transfer amount exceeds balance");
        require(address(arg0), "ERC20: transfer amount exceeds balance");
        address var_a = address(msg.sender);
        require(!(storage_map_b[var_a] < arg1), "ERC20: transfer amount exceeds balance");
        var_a = address(msg.sender);
        storage_map_b[var_a] = storage_map_b[var_a] - arg1;
        var_a = address(arg0);
        require(!(storage_map_b[var_a] > ~(arg1)), "ERC20: transfer to the zero address");
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        storage_map_b[var_a] = storage_map_b[var_a] + arg1;
        emit Transfer(address(msg.sender), address(arg0), arg1);
        return 0x01;
    }
    
    /// @custom:selector    0x975fe3ca
    /// @custom:signature   mintInstanced(uint256 arg0, address arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function mintInstanced(uint256 arg0, address arg1) public payable {
        require(arg1 == (address(arg1)));
        require(!(block.timestamp < 0x62196d80), "HDRN: Contract not yet active");
        var_d = var_d;
        require(!block.timestamp < 0x62196d80);
        require(0x015180);
        uint256 var_d = (block.timestamp - 0x62196d80) / 0x015180;
        require(uint32(storage_map_c[var_d] / 0x01000000000000000000000000000000000000000000000000000000));
        address var_n = msg.sender;
        require(address(store_d).code.length);
        (bool success, bytes memory ret0) = address(store_d).Unresolved_f2b29141(var_n); // staticcall
        var_f = var_f + (uint248(ret0.length + 0x1f));
        require(!(((var_f + ret0.length) - var_f) < 0x20), "HDRN: HSI index address mismatch");
        require(var_f.length == (address(var_f.length)), "HDRN: HSI index address mismatch");
        require(address(arg1) == (address(var_f.length)), "HDRN: HSI index address mismatch");
        var_d = var_d;
        var_f = var_f + 0x0180;
        require(address(arg1).code.length);
        (bool success, bytes memory ret0) = address(arg1).share(); // staticcall
        require(!block.timestamp < store_e);
        require(0x015180);
    }
    
    /// @custom:selector    0x7fedcdf9
    /// @custom:signature   Unresolved_7fedcdf9(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_7fedcdf9(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
    
    /// @custom:selector    0xa457c2d7
    /// @custom:signature   decreaseAllowance(address arg0, uint256 arg1) public payable returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function decreaseAllowance(address arg0, uint256 arg1) public payable returns (bool) {
        require(arg0 == (address(arg0)));
        var_a = address(arg0);
        require(!(storage_map_b[var_a] < arg1), "ERC20: decreased allowance below zero");
        require(address(msg.sender), "ERC20: approve to the zero address");
        require(address(arg0), "ERC20: approve to the zero address");
        var_a = address(arg0);
        storage_map_b[var_a] = storage_map_b[var_a] - arg1;
        emit Event_8c5be1e5(address(msg.sender), address(arg0), storage_map_b[var_a] - arg1);
        return 0x01;
    }
    
    /// @custom:selector    0x1823b7dd
    /// @custom:signature   liquidationList(uint256 arg0) public view returns (bool)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function liquidationList(uint256 arg0) public view returns (bool) {
        uint256 var_b = arg0;
        return abi.encodePacked(storage_map_f[var_b], address(storage_map_g[var_b]), uint96(storage_map_g[var_b] / 0x010000000000000000000000000000000000000000), address(storage_map_h[var_b]), uint88(storage_map_h[var_b] / 0x010000000000000000000000000000000000000000), (bytes1(storage_map_h[var_b] / 0x0100000000000000000000000000000000000000000000000000000000000000)));
    }
    
    /// @custom:selector    0x8523c745
    /// @custom:signature   Unresolved_8523c745(uint256 arg0, address arg1) public pure
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_8523c745(uint256 arg0, address arg1) public pure {
        require(arg1 == (address(arg1)));
    }
    
    /// @custom:selector    0xdd62ed3e
    /// @custom:signature   Unresolved_dd62ed3e(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_dd62ed3e(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
    
    /// @custom:selector    0x06fdde03
    /// @custom:signature   Unresolved_06fdde03() public view returns (string memory)
    function Unresolved_06fdde03() public view returns (string memory) {
        if (store_j) {
            if (!(store_j) == ((store_j >> 0x01) < 0x20)) {
                uint256 var_c = var_c + (0x20 + (((0x1f + (store_j >> 0x01)) / 0x20) * 0x20));
                if (store_j) {
                    if (!(store_j) == ((store_j >> 0x01) < 0x20)) {
                        if (!store_j >> 0x01) {
                            if (0x1f < (store_j >> 0x01)) {
                                var_a = 0x03;
                                if ((0x20 + var_c) + (store_j >> 0x01) > (0x20 + (0x20 + var_c))) {
                                    if (!0 > var_c.length) {
                                        return abi.encodePacked(0x20, var_c.length);
                                        return abi.encodePacked(0x20, var_c.length);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0xf812b9a4
    /// @custom:signature   mintNative(uint256 arg0, uint40 arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint40", "bytes5", "int40"]
    function mintNative(uint256 arg0, uint40 arg1) public payable {
        require(arg1 == (uint40(arg1)));
        require(!(block.timestamp < 0x62196d80), "HDRN: Contract not yet active");
        var_d = var_d;
        require(!block.timestamp < 0x62196d80);
        require(0x015180);
        uint256 var_d = (block.timestamp - 0x62196d80) / 0x015180;
        require(uint32(storage_map_c[var_d] / 0x01000000000000000000000000000000000000000000000000000000));
        address var_u = msg.sender;
        require(address(store_k).code.length);
        (bool success, bytes memory ret0) = address(store_k).Unresolved_2607443b(var_u); // staticcall
        require(!block.timestamp < store_e);
        require(0x015180);
    }
    
    /// @custom:selector    0xb488dbc6
    /// @custom:signature   claimNative(uint256 arg0, uint40 arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint40", "bytes5", "int40"]
    function claimNative(uint256 arg0, uint40 arg1) public payable {
        require(arg1 == (uint40(arg1)));
        require(!(block.timestamp < 0x62196d80), "HDRN: Contract not yet active");
        var_d = var_d;
        address var_n = msg.sender;
        require(address(store_k).code.length);
        (bool success, bytes memory ret0) = address(store_k).Unresolved_2607443b(var_n); // staticcall
    }
    
    /// @custom:selector    0x39509351
    /// @custom:signature   increaseAllowance(address arg0, uint256 arg1) public payable returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function increaseAllowance(address arg0, uint256 arg1) public payable returns (bool) {
        require(arg0 == (address(arg0)));
        var_a = address(arg0);
        require(!(storage_map_b[var_a] > ~(arg1)), "ERC20: approve to the zero address");
        require(address(msg.sender), "ERC20: approve to the zero address");
        require(address(arg0), "ERC20: approve to the zero address");
        var_a = address(arg0);
        storage_map_b[var_a] = storage_map_b[var_a] + arg1;
        emit Event_8c5be1e5(address(msg.sender), address(arg0), storage_map_b[var_a] + arg1);
        return 0x01;
    }
    
    /// @custom:selector    0x95d89b41
    /// @custom:signature   Unresolved_95d89b41() public view returns (string memory)
    function Unresolved_95d89b41() public view returns (string memory) {
        if (store_l) {
            if (!(store_l) == ((store_l >> 0x01) < 0x20)) {
                uint256 var_c = var_c + (0x20 + (((0x1f + (store_l >> 0x01)) / 0x20) * 0x20));
                if (store_l) {
                    if (!(store_l) == ((store_l >> 0x01) < 0x20)) {
                        if (!store_l >> 0x01) {
                            if (0x1f < (store_l >> 0x01)) {
                                var_a = 0x04;
                                if ((0x20 + var_c) + (store_l >> 0x01) > (0x20 + (0x20 + var_c))) {
                                    if (!0 > var_c.length) {
                                        return abi.encodePacked(0x20, var_c.length);
                                        return abi.encodePacked(0x20, var_c.length);
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0x2f52ca36
    /// @custom:signature   loanInstanced(uint256 arg0, address arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function loanInstanced(uint256 arg0, address arg1) public payable {
        require(arg1 == (address(arg1)));
        require(!(block.timestamp < 0x62196d80), "HDRN: Contract not yet active");
        var_d = var_d;
        require(!block.timestamp < 0x62196d80);
        require(0x015180);
        uint256 var_d = (block.timestamp - 0x62196d80) / 0x015180;
        require(uint32(storage_map_c[var_d] / 0x01000000000000000000000000000000000000000000000000000000));
        address var_n = msg.sender;
        require(address(store_d).code.length);
        (bool success, bytes memory ret0) = address(store_d).Unresolved_f2b29141(var_n); // staticcall
        var_f = var_f + (uint248(ret0.length + 0x1f));
        require(!(((var_f + ret0.length) - var_f) < 0x20), "HDRN: HSI index address mismatch");
        require(var_f.length == (address(var_f.length)), "HDRN: HSI index address mismatch");
        require(address(arg1) == (address(var_f.length)), "HDRN: HSI index address mismatch");
        var_d = var_d;
        var_f = var_f + 0x0180;
        require(address(arg1).code.length);
        (bool success, bytes memory ret0) = address(arg1).share(); // staticcall
        require(!block.timestamp < store_e);
        require(0x015180);
    }
    
    /// @custom:selector    0x6144a2d8
    /// @custom:signature   dailyDataList(uint256 arg0) public view returns (bytes memory)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function dailyDataList(uint256 arg0) public view returns (bytes memory) {
        uint256 var_b = arg0;
        return abi.encodePacked(uint72(storage_map_f[var_b]), uint72(storage_map_f[var_b] / 0x01000000000000000000), uint72(storage_map_f[var_b] / 0x01000000000000000000000000000000000000), uint32(storage_map_f[var_b] / 0x01000000000000000000000000000000000000000000000000000000), bytes1(storage_map_f[var_b] / 0x0100000000000000000000000000000000000000000000000000000000000000));
    }
    
    /// @custom:selector    0x61c2acc3
    /// @custom:signature   loanLiquidateBid(uint256 arg0, uint256 arg1) public view
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function loanLiquidateBid(uint256 arg0, uint256 arg1) public view {
        require(!(block.timestamp < 0x62196d80), "HDRN: Contract not yet active");
        var_d = var_d;
        uint256 var_f = var_f + 0xc0;
        uint256 var_d = arg0;
        require(0x01 == (var_m), "HDRN: Insufficient balance to facilitate liquidation");
        var_d = msg.sender;
        require(!(arg1 > storage_map_c[var_d]), "HDRN: Insufficient balance to facilitate liquidation");
        require(arg1 > (var_s), "HDRN: Cannot bid on expired liquidation");
        require(!(var_f.length > (~(var_t))), "HDRN: Cannot bid on expired liquidation");
        require(!(block.timestamp < (var_f.length + (var_t))), "HDRN: Cannot bid on expired liquidation");
        require(!((block.timestamp - (var_f.length + (var_t))) > 0x015180), "HDRN: Cannot bid on expired liquidation");
    }
    
    /// @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    0x70a08231
    /// @custom:signature   Unresolved_70a08231(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_70a08231(address arg0) public view returns (uint256) {
        require(arg0 == (address(arg0)));
        address var_a = address(arg0);
        return storage_map_b[var_a];
    }
    
    /// @custom:selector    0x0fa7609e
    /// @custom:signature   loanPayment(uint256 arg0, address arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function loanPayment(uint256 arg0, address arg1) public payable {
        require(arg1 == (address(arg1)));
        require(!(block.timestamp < 0x62196d80), "HDRN: Contract not yet active");
        var_d = var_d;
        require(!block.timestamp < 0x62196d80);
        require(0x015180);
        uint256 var_d = (block.timestamp - 0x62196d80) / 0x015180;
        require(uint32(storage_map_c[var_d] / 0x01000000000000000000000000000000000000000000000000000000));
        address var_n = msg.sender;
        require(address(store_d).code.length);
        (bool success, bytes memory ret0) = address(store_d).Unresolved_f2b29141(var_n); // staticcall
        var_f = var_f + (uint248(ret0.length + 0x1f));
        require(!(((var_f + ret0.length) - var_f) < 0x20), "HDRN: HSI index address mismatch");
        require(var_f.length == (address(var_f.length)), "HDRN: HSI index address mismatch");
        require(address(arg1) == (address(var_f.length)), "HDRN: HSI index address mismatch");
        var_d = var_d;
        var_f = var_f + 0x0180;
        require(address(arg1).code.length);
        (bool success, bytes memory ret0) = address(arg1).share(); // staticcall
        require(!block.timestamp < store_e);
        require(0x015180);
    }
    
    /// @custom:selector    0xd4029727
    /// @custom:signature   shareList(uint256 arg0) public view returns (bool)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function shareList(uint256 arg0) public view returns (bool) {
        uint256 var_b = arg0;
        uint256 var_c = var_c + 0x80;
        return abi.encodePacked(uint40(var_c.length), uint72(var_v), uint16(var_w), uint16(var_x), uint16(storage_map_g[var_b]), bytes1(storage_map_g[var_b] / 0x010000), uint16(storage_map_g[var_b] / 0x01000000), uint16(storage_map_g[var_b] / 0x010000000000), uint32(storage_map_g[var_b] / 0x0100000000000000), bytes1(storage_map_g[var_b] / 0x010000000000000000000000), (bytes1(storage_map_g[var_b] / 0x01000000000000000000000000)));
    }
    
    /// @custom:selector    0xddeb2406
    /// @custom:signature   loanLiquidateExit(uint256 arg0, uint256 arg1) public view
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function loanLiquidateExit(uint256 arg0, uint256 arg1) public view {
        require(!(block.timestamp < 0x62196d80), "HDRN: Contract not yet active");
        var_d = var_d;
        require(!(block.timestamp < 0x62196d80), "HDRN: Cannot exit on invalid liquidation");
        require(0x015180, "HDRN: Cannot exit on invalid liquidation");
        uint256 var_d = (block.timestamp - 0x62196d80) / 0x015180;
        require(uint32(storage_map_c[var_d] / 0x01000000000000000000000000000000000000000000000000000000), "HDRN: Cannot exit on invalid liquidation");
        var_d = arg1;
        var_f = var_f + 0xc0;
        require(0x01 == (var_s), "HDRN: Cannot exit on invalid liquidation");
        require(!(var_f.length > (~(var_t))), "HDRN: Cannot exit on invalid liquidation");
        require(!block.timestamp < store_e);
        require(0x015180);
    }
    
    /// @custom:selector    0x5f169f5b
    /// @custom:signature   loanPayoff(uint256 arg0, address arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function loanPayoff(uint256 arg0, address arg1) public payable {
        require(arg1 == (address(arg1)));
        require(!(block.timestamp < 0x62196d80), "HDRN: Contract not yet active");
        var_d = var_d;
        require(!block.timestamp < 0x62196d80);
        require(0x015180);
        uint256 var_d = (block.timestamp - 0x62196d80) / 0x015180;
        require(uint32(storage_map_c[var_d] / 0x01000000000000000000000000000000000000000000000000000000));
        address var_n = msg.sender;
        require(address(store_d).code.length);
        (bool success, bytes memory ret0) = address(store_d).Unresolved_f2b29141(var_n); // staticcall
        var_f = var_f + (uint248(ret0.length + 0x1f));
        require(!(((var_f + ret0.length) - var_f) < 0x20), "HDRN: HSI index address mismatch");
        require(var_f.length == (address(var_f.length)), "HDRN: HSI index address mismatch");
        require(address(arg1) == (address(var_f.length)), "HDRN: HSI index address mismatch");
        var_d = var_d;
        var_f = var_f + 0x0180;
        require(address(arg1).code.length);
        (bool success, bytes memory ret0) = address(arg1).share(); // staticcall
        require(!block.timestamp < store_e);
        require(0x015180);
    }
    
    /// @custom:selector    0x5c9302c9
    /// @custom:signature   currentDay() public view returns (uint256)
    function currentDay() public view returns (uint256) {
        if (!block.timestamp < 0x62196d80) {
            if (0x015180) {
                return (block.timestamp - 0x62196d80) / 0x015180;
            }
        }
    }
    
    /// @custom:selector    0x451df11b
    /// @custom:signature   Unresolved_451df11b(address arg0) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_451df11b(address arg0) public pure {
        require(arg0 == (address(arg0)));
    }
}

ABI

[
  {
    "type": "function",
    "name": "Unresolved_06fdde03",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_095ea7b3",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_10d9d349",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_18160ddd",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_23b872dd",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_451df11b",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_70a08231",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_7fedcdf9",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_8523c745",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_95d89b41",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_dd62ed3e",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "claimNative",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint40"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "currentDay",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "dailyDataList",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "decimals",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "decreaseAllowance",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "hsim",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "increaseAllowance",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "liquidationList",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "loanInstanced",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "loanLiquidateBid",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "loanLiquidateExit",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "loanPayment",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "loanPayoff",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "loanedSupply",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "mintInstanced",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "mintNative",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint40"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "proofOfBenevolence",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "shareList",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "transfer",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "event",
    "name": "Event_8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Transfer",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg2",
        "type": "uint256",
        "indexed": false
      }
    ],
    "anonymous": false
  }
]

UNKNOWN SELECTORS (7)

KNOWN CLUSTER ADDRESSES IN THIS BYTECODE (0)