0x21e354da5d929a4da55428f6bfd71ed9ffd5001f

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 {
    bool public constant borrowerWhitelistActive = 0xBool(false);
    uint256 public constant DEPLOYER_ADDRESS = 321321499095009505475595166621667840212393921426;
    uint256 public constant maturityDate = 0;
    bytes public constant version = 000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000;
    uint256 public constant maxLTV = 75000;
    uint256 public constant CIRCUIT_BREAKER_ADDRESS = 1445453966560485522097192270123750727561417038732;
    uint256 public constant dirtyLiquidationFee = 9000;
    bytes public constant getConstants = 00000000000000000000000000000000000000000000000000000000000186a000000000000000000000000000000000000000000000000000000000000186a000000000000000000000000000000000000000000000000000000000000186a000000000000000000000000000000000000000000000000000000000000186a00000000000000000000000000000000000000000000000000de0b6b3a764000000000000000000000000000000000000000000000000000000000000096ea8860000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000c350;
    uint256 public constant cleanLiquidationFee = 10000;
    uint256 public constant rateContract = 138800944016059222541570430171990665162927501921;
    uint256 public constant oracleMultiply = 0;
    uint256 public constant FRAXLEND_WHITELIST_ADDRESS = 100176723251370481401639724365315472405336105806;
    uint256 public constant oracleNormalization = 1;
    bool public constant lenderWhitelistActive = 0xBool(false);
    bytes public constant getImmutableUint256 = 000000000000000000000000000000000000000000000000000000000000000100000000000000000000000000000000000000000000000000000000000124f8000000000000000000000000000000000000000000000000000000000000271000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000;
    uint256 public constant decimals = 18;
    uint256 public constant asset = 760669128607807243603077257990330222174652447134;
    uint256 public constant COMPTROLLER_ADDRESS = 128496964318227596949246131945916258461513075211;
    uint256 public constant collateralContract = 983329190930135433410733727600637031439446827919;
    bool public constant getImmutableAddressBool = 0xBool(true);
    uint256 public constant penaltyRate = 0;
    
    bytes public addInterest;
    bytes public exchangeRateInfo;
    mapping(bytes32 => bytes32) storage_map_a;
    mapping(bytes32 => bytes32) storage_map_g;
    bytes32 store_m;
    bytes32 store_n;
    mapping(bytes32 => bytes32) storage_map_j;
    uint256 public totalSupply;
    bytes32 store_c;
    bytes public totalBorrow;
    address public owner;
    uint256 public maxOracleDelay;
    address public TIME_LOCK_ADDRESS;
    bytes public getPairAccounting;
    uint256 store_o;
    
    event ChangeFee(uint32);
    event Transfer(address, address, uint256);
    event Paused(address);
    event SetTimeLock(address, address);
    event Unpaused(address);
    event Deposit(address, address, uint256, uint256);
    event UpdateExchangeRate(uint256);
    event Approval(address, address, uint256);
    event UpdateRate(uint256, uint256, uint256, uint256);
    error OnlyTimeLock();
    event SetSwapper(address, bool);
    event SetMaxOracleDelay(uint256, uint256);
    event OwnershipTransferred(address, address);
    
    /// @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)), "ERC20: approve to the zero address");
        require(!(address(arg0)), "ERC20: approve to the zero address");
        var_a = address(arg0);
        storage_map_a[var_a] = arg1;
        emit Approval(address(msg.sender), address(arg0), arg1);
        return 0x01;
    }
    
    /// @custom:selector    0x3f2617cb
    /// @custom:signature   Unresolved_3f2617cb(address arg0, uint256 arg1) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_3f2617cb(address arg0, uint256 arg1) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg0 - (address(arg0)));
        require(arg1 - arg1);
        require(msg.sender - (address(owner)), "Ownable: caller is not the owner");
        address var_e = address(arg0);
        storage_map_g[var_e] = (bytes1(arg1)) | (uint248(storage_map_g[var_e]));
        emit SetSwapper(address(arg0), arg1);
    }
    
    /// @custom:selector    0xd41ddc96
    /// @custom:signature   removeCollateral(uint256 arg0, address arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function removeCollateral(uint256 arg0, address arg1) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg1 - (address(arg1)));
        require(store_c == 0x02);
        store_c = 0x02;
        require(((var_a + 0xa0) > 0xffffffffffffffff) | ((var_a + 0xa0) < var_a));
        uint256 var_a = var_a + 0xa0;
        require(block.timestamp == (uint64(addInterest >> 0x40)));
        address var_b = msg.sender;
        require(storage_map_j[var_b]);
        require(((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a));
        var_a = var_a + 0x40;
        require(block.timestamp == (uint32(exchangeRateInfo)));
        var_b = address(msg.sender);
        require((storage_map_j[var_b] - arg0) > storage_map_j[var_b]);
        require(0);
        (bool success, bytes memory ret0) = address(0).latestRoundData(); // staticcall
        require(!(0 > 0), CustomError_57b0e210());
        require((block.timestamp - 0) > block.timestamp, CustomError_57b0e210());
        require((block.timestamp - 0) > maxOracleDelay, CustomError_57b0e210());
        require(0, CustomError_57b0e210());
        require(0x27942afe4ecb7f9945168094e0749cac749ac97b, CustomError_57b0e210());
        require(!0x01, CustomError_57b0e210());
        require(0 > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff, CustomError_57b0e210());
        (bool success, bytes memory ret0) = address(0x27942afe4ecb7f9945168094e0749cac749ac97b).latestRoundData(); // staticcall
        require(!(0 > 0), CustomError_8ab6676c());
        require(0xa0 > ret0.length);
        require(((var_a + 0xa0) > 0xffffffffffffffff) | ((var_a + 0xa0) < var_a));
        var_a = var_a + 0xa0;
        require(((var_a + 0xa0) - var_a) < 0xa0);
        require(var_a.length - (uint80(var_a.length)));
        require(var_n - (uint80(var_n)));
        require(0xa0 > ret0.length);
        require(((var_a + 0xa0) > 0xffffffffffffffff) | ((var_a + 0xa0) < var_a));
        var_a = var_a + 0xa0;
        require(((var_a + 0xa0) - var_a) < 0xa0);
        require(0x27942afe4ecb7f9945168094e0749cac749ac97b);
        require(!0x01);
        (bool success, bytes memory ret0) = address(0x27942afe4ecb7f9945168094e0749cac749ac97b).latestRoundData(); // staticcall
        if (0xa0 > ret0.length) {
        }
        if (((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a)) {
            var_a = var_a + 0x40;
            if (((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a)) {
                var_a = var_a + 0x40;
                if (address(var_p)) {
                    if (!owner >> 0xa0) {
                        require(((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a), "ReentrancyGuard: reentrant call");
                    }
                }
                require(((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a), "ReentrancyGuard: reentrant call");
            }
        }
    }
    
    /// @custom:selector    0x56968f97
    /// @custom:signature   Unresolved_56968f97(uint256 arg0, uint256 arg1) public view returns (address)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_56968f97(uint256 arg0, uint256 arg1) public view returns (address) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg1 - arg1);
        require(((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a));
        uint256 var_a = var_a + 0x40;
        require(0 == (!address(var_a.length)));
        require(!(((arg0 * (address(var_f))) / arg0) == (address(var_f))) | !arg0);
        require(!address(var_a.length));
        require(arg1);
        require(arg1);
        require((arg0 * (address(var_f))) / (address(var_a.length)) > ((arg0 * (address(var_f))) / (address(var_a.length)) + 0x01));
        return ((arg0 * (address(var_f))) / (address(var_a.length))) + 0x01;
        return (arg0 * (address(var_f))) / (address(var_a.length));
        return arg0;
    }
    
    /// @custom:selector    0xb68d0a09
    /// @custom:signature   getUserSnapshot(address arg0) public view returns (bytes memory)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function getUserSnapshot(address arg0) public view returns (bytes memory) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x20);
        require(arg0 - (address(arg0)));
        address var_a = address(arg0);
        return abi.encodePacked(storage_map_a[var_a], storage_map_a[var_a], storage_map_a[var_a]);
    }
    
    /// @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    0x3d417d2d
    /// @custom:signature   repayAsset(uint256 arg0, address arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function repayAsset(uint256 arg0, address arg1) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg1 - (address(arg1)));
        require(!(!store_c == 0x02), "SafeCast: value doesn't fit in 128 bits");
        store_c = 0x02;
        require(((var_a + 0xa0) > 0xffffffffffffffff) | ((var_a + 0xa0) < var_a), "SafeCast: value doesn't fit in 128 bits");
        uint256 var_a = var_a + 0xa0;
        require(block.timestamp == (uint64(addInterest >> 0x40)), "SafeCast: value doesn't fit in 128 bits");
        require(((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a), "SafeCast: value doesn't fit in 128 bits");
        var_a = var_a + 0x40;
        require(0 == (!address(var_k)), "SafeCast: value doesn't fit in 128 bits");
        require(!(((arg0 * (address(var_a.length))) / arg0) == (address(var_a.length)) | !arg0), "SafeCast: value doesn't fit in 128 bits");
        require(!(address(var_k)), "SafeCast: value doesn't fit in 128 bits");
        require(arg0 > 0xffffffffffffffffffffffffffffffff, "SafeCast: value doesn't fit in 128 bits");
        if (((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a)) {
            var_a = var_a + 0x40;
            if (((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a)) {
                var_a = var_a + 0x40;
                if (address(var_k)) {
                    require(((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a), "ReentrancyGuard: reentrant call");
                    require(((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a), "ReentrancyGuard: reentrant call");
                }
                require(!(bytes1(owner >> 0xa0)), "ReentrancyGuard: reentrant call");
                require((block.timestamp - (uint64(var_r))) > block.timestamp, "ReentrancyGuard: reentrant call");
                require(address(var_a.length) - ((0x0186a0 * (address(var_a.length))) / 0x0186a0), "ReentrancyGuard: reentrant call");
            }
        }
    }
    
    /// @custom:selector    0x06fdde03
    /// @custom:signature   name() public view returns (string memory)
    function name() public view returns (string memory) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0);
        if (!store_m) {
            if (store_m == ((store_m >> 0x01) < 0x20)) {
                if (!store_m) {
                    if (0x01 == (store_m)) {
                        if (0 < (store_m >> 0x01)) {
                            if (((var_d + (uint248((((var_d + 0) + 0x20) - var_d) + 0x1f))) > 0xffffffffffffffff) | ((var_d + (uint248((((var_d + 0) + 0x20) - var_d) + 0x1f))) < var_d)) {
                                uint248 var_d = var_d + (uint248((((var_d + 0) + 0x20) - var_d) + 0x1f));
                                return abi.encodePacked(0x20, var_d.length);
                                if (((var_d + (uint248((0 - var_d) + 0x1f))) > 0xffffffffffffffff) | ((var_d + (uint248((0 - var_d) + 0x1f))) < var_d)) {
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0xcd3b691c
    /// @custom:signature   setMaxOracleDelay(uint256 arg0) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function setMaxOracleDelay(uint256 arg0) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x20, CustomError_3b6b86b1());
        require(msg.sender - (address(TIME_LOCK_ADDRESS)), CustomError_3b6b86b1());
        emit SetMaxOracleDelay(maxOracleDelay, arg0);
        maxOracleDelay = arg0;
    }
    
    /// @custom:selector    0x39509351
    /// @custom:signature   increaseAllowance(address arg0, uint256 arg1) public payable returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function increaseAllowance(address arg0, uint256 arg1) public payable returns (uint256) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg0 - (address(arg0)));
        var_a = address(arg0);
        require(storage_map_a[var_a] > (storage_map_a[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_a[var_a] = storage_map_a[var_a] + arg1;
        emit Approval(address(msg.sender), address(arg0), storage_map_a[var_a] + arg1);
        return 0x01;
    }
    
    /// @custom:selector    0x95d89b41
    /// @custom:signature   symbol() public view returns (string memory)
    function symbol() public view returns (string memory) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0);
        if (!store_n) {
            if (store_n == ((store_n >> 0x01) < 0x20)) {
                if (!store_n) {
                    if (0x01 == (store_n)) {
                        if (0 < (store_n >> 0x01)) {
                            if (((var_d + (uint248((((var_d + 0) + 0x20) - var_d) + 0x1f))) > 0xffffffffffffffff) | ((var_d + (uint248((((var_d + 0) + 0x20) - var_d) + 0x1f))) < var_d)) {
                                uint248 var_d = var_d + (uint248((((var_d + 0) + 0x20) - var_d) + 0x1f));
                                return abi.encodePacked(0x20, var_d.length);
                                if (((var_d + (uint248((0 - var_d) + 0x1f))) > 0xffffffffffffffff) | ((var_d + (uint248((0 - var_d) + 0x1f))) < var_d)) {
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0x94e301e0
    /// @custom:signature   Unresolved_94e301e0(uint256 arg0, uint256 arg1) public view returns (address)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_94e301e0(uint256 arg0, uint256 arg1) public view returns (address) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg1 - arg1);
        require(((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a));
        uint256 var_a = var_a + 0x40;
        require(0 == (!address(var_f)));
        require(!(((arg0 * (address(var_a.length))) / arg0) == (address(var_a.length))) | !arg0);
        require(!address(var_f));
        require(arg1);
        require(arg1);
        require((arg0 * (address(var_a.length))) / (address(var_g)) > ((arg0 * (address(var_a.length))) / (address(var_g)) + 0x01));
        return ((arg0 * (address(var_a.length))) / (address(var_g))) + 0x01;
        return (arg0 * (address(var_a.length))) / (address(var_g));
        return arg0;
    }
    
    /// @custom:selector    0xa053db68
    /// @custom:signature   Unresolved_a053db68(address arg0, address arg1, uint256 arg2, uint256 arg3) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    function Unresolved_a053db68(address arg0, address arg1, uint256 arg2, uint256 arg3) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0xa0);
        require(arg0 - (address(arg0)));
        require(arg4 > 0xffffffffffffffff);
        require(!(arg4 + 0x23) < msg.data.length);
        require(arg4 > 0xffffffffffffffff);
        require(((var_c + (uint248((0x20 + (arg4 << 0x05)) + 0x1f))) > 0xffffffffffffffff) | ((var_c + (uint248((0x20 + (arg4 << 0x05)) + 0x1f))) < var_c));
        uint256 var_c = var_c + (uint248((0x20 + (arg4 << 0x05)) + 0x1f));
        require(((arg4 + (arg4 << 0x05)) + 0x24) > msg.data.length);
        require((0x24 + arg4) < ((arg4 + (arg4 << 0x05)) + 0x24));
        require(msg.data[0x24 + arg4] - (address(msg.data[0x24 + arg4])));
        require(0, "Pausable: paused");
        require(block.timestamp > 0, "Pausable: paused");
        require(!(!store_c == 0x02), "Pausable: paused");
        store_c = 0x02;
        require(bytes1(owner >> 0xa0), "Pausable: paused");
        require(0, "SafeCast: value doesn't fit in 128 bits");
        address var_a = msg.sender;
        require(!(bytes1(storage_map_a[var_a])), "SafeCast: value doesn't fit in 128 bits");
        require(((var_c + 0xa0) > 0xffffffffffffffff) | ((var_c + 0xa0) < var_c), "SafeCast: value doesn't fit in 128 bits");
        var_c = var_c + 0xa0;
        require(block.timestamp == (uint64(addInterest >> 0x40)), "SafeCast: value doesn't fit in 128 bits");
        require(((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c), "SafeCast: value doesn't fit in 128 bits");
        var_c = var_c + 0x40;
        require(block.timestamp == (uint32(exchangeRateInfo)), "SafeCast: value doesn't fit in 128 bits");
        var_a = address(arg0);
        require(!(bytes1(storage_map_a[var_a])), "SafeCast: value doesn't fit in 128 bits");
        require(!var_c.length, "SafeCast: value doesn't fit in 128 bits");
        require(address(var_p) - 0x853d955acef822db058eb8505911ed77f175b99e, "SafeCast: value doesn't fit in 128 bits");
        require((var_c.length + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) > var_c.length, "SafeCast: value doesn't fit in 128 bits");
        require(!((var_c.length + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < var_c.length), "SafeCast: value doesn't fit in 128 bits");
        require(0xac3e018457b222d93114458476f3e3416abbe38f - (address(var_q)), "SafeCast: value doesn't fit in 128 bits");
        require(arg2, "SafeCast: value doesn't fit in 128 bits");
        var_a = address(msg.sender);
        require(storage_map_a[var_a] > (storage_map_a[var_a] + arg2), "SafeCast: value doesn't fit in 128 bits");
        require(arg1 > 0xffffffffffffffffffffffffffffffff, "SafeCast: value doesn't fit in 128 bits");
        require(((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c), CustomError_c5bb6dae());
        var_c = var_c + 0x40;
        require(((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c), CustomError_c5bb6dae());
        var_c = var_c + 0x40;
        require(address(var_c.length) - (address(var_c.length)) > 0xffffffffffffffffffffffffffffffff, CustomError_c5bb6dae());
        require(address(var_c.length - (var_c.length)) < (address(arg1)), CustomError_c5bb6dae());
        require(address(var_c.length), CustomError_b0b3262d());
        require(!(address(arg1) * (address(var_ac)) / (address(arg1)) == (address(var_ac)) | (!address(arg1))), CustomError_b0b3262d());
        require(!(address(var_c.length)), CustomError_b0b3262d());
        require(!(address(arg1) * (address(var_ac)) / (address(var_c.length)) * (address(var_c.length)) / (address(arg1) * (address(var_ac)) / (address(var_c.length))) == (address(var_c.length)) | (!(address(arg1) * (address(var_ac))) / (address(var_c.length)))), CustomError_b0b3262d());
        require(address(var_c.length) + (address(arg1)) > 0xffffffffffffffffffffffffffffffff, CustomError_b0b3262d());
        require(address(var_ac) + (address(arg1)) > 0xffffffffffffffffffffffffffffffff, CustomError_b0b3262d());
        require((var_c.length + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) > var_c.length, CustomError_b0b3262d());
        require(!var_c.length, CustomError_b0b3262d());
        require(0);
        (bool success, bytes memory ret0) = address(0).latestRoundData(); // staticcall
        require(!0 > 0);
        require((block.timestamp - 0) > block.timestamp);
        require((block.timestamp - 0) > maxOracleDelay);
        require(0);
        require(0x27942afe4ecb7f9945168094e0749cac749ac97b);
        (bool success, bytes memory ret0) = address(0x27942afe4ecb7f9945168094e0749cac749ac97b).latestRoundData(); // staticcall
        require(!(0 > 0), CustomError_8ab6676c());
        require(0xa0 > ret0.length);
        require(((var_c + 0xa0) > 0xffffffffffffffff) | ((var_c + 0xa0) < var_c));
        var_c = var_c + 0xa0;
        require(((var_c + 0xa0) - var_c) < 0xa0);
        require(var_c.length - (uint80(var_c.length)));
        require(var_ad - (uint80(var_ad)));
        require(0xa0 > ret0.length);
        require(((var_c + 0xa0) > 0xffffffffffffffff) | ((var_c + 0xa0) < var_c));
        var_c = var_c + 0xa0;
        require(((var_c + 0xa0) - var_c) < 0xa0);
        require(0x27942afe4ecb7f9945168094e0749cac749ac97b);
        (bool success, bytes memory ret0) = address(0x27942afe4ecb7f9945168094e0749cac749ac97b).latestRoundData(); // staticcall
        if (0xa0 > ret0.length) {
        }
        require(0, CustomError_85e83bba());
        require(0, CustomError_b063a8a5());
    }
    
    /// @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((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x60);
        require(arg0 - (address(arg0)));
        require(arg1 - (address(arg1)));
        var_a = msg.sender;
        require(storage_map_a[var_a] - 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, "ERC20: transfer amount exceeds balance");
        require(!(address(arg0)), "ERC20: transfer amount exceeds balance");
        require(!(address(arg1)), "ERC20: transfer amount exceeds balance");
        var_a = address(arg0);
        require(storage_map_a[var_a] < arg2, "ERC20: transfer amount exceeds balance");
        var_a = address(arg0);
        storage_map_a[var_a] = storage_map_a[var_a] - arg2;
        var_a = address(arg1);
        require(storage_map_a[var_a] > (storage_map_a[var_a] + arg2), "ERC20: transfer to the zero address");
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        storage_map_a[var_a] = storage_map_a[var_a] + arg2;
        emit Transfer(address(arg0), address(arg1), arg2);
        return 0x01;
        require(storage_map_a[var_a] < arg2, "ERC20: insufficient allowance");
        require(!(address(arg0)), "ERC20: approve to the zero address");
        require(!(address(msg.sender)), "ERC20: approve to the zero address");
    }
    
    /// @custom:selector    0xdaf33f2a
    /// @custom:signature   withdrawFees(uint128 arg0, address arg1) public view
    /// @param              arg0 ["address", "uint128", "bytes16", "int128"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function withdrawFees(uint128 arg0, address arg1) public view {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg0 - (address(arg0)));
        require(arg1 - (address(arg1)));
        require(msg.sender - (address(owner)), "Ownable: caller is not the owner");
        require(((var_e + 0x40) > 0xffffffffffffffff) | ((var_e + 0x40) < var_e), CustomError_c5bb6dae());
        uint256 var_e = var_e + 0x40;
        require(((var_e + 0x40) > 0xffffffffffffffff) | ((var_e + 0x40) < var_e), CustomError_c5bb6dae());
        var_e = var_e + 0x40;
        require(!(address(arg0)), CustomError_c5bb6dae());
        require(0 == (!address(var_k)), CustomError_c5bb6dae());
        require(!(address(arg0) * (address(var_e.length)) / (address(arg0)) == (address(var_e.length)) | (!address(arg0))), CustomError_c5bb6dae());
        require(!(address(var_k)), CustomError_c5bb6dae());
        require(address(var_e.length) - (address(var_e.length)) > 0xffffffffffffffffffffffffffffffff, CustomError_c5bb6dae());
        require(address(var_e.length - (var_e.length)) < (address(arg0)), CustomError_c5bb6dae());
        if (address(var_e.length) - (address(arg0)) > 0xffffffffffffffffffffffffffffffff) {
            require(address(var_e.length) - (address(arg0)) > 0xffffffffffffffffffffffffffffffff);
        }
    }
    
    /// @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((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x20);
        require(arg0 - (address(arg0)));
        address var_a = address(arg0);
        return storage_map_a[var_a];
    }
    
    /// @custom:selector    0x404ffa7a
    /// @custom:signature   Unresolved_404ffa7a(uint256 arg0, uint256 arg1) public view returns (address)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_404ffa7a(uint256 arg0, uint256 arg1) public view returns (address) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg1 - arg1);
        require(((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a));
        uint256 var_a = var_a + 0x40;
        require(0 == (!address(var_f)));
        require(!(((arg0 * (address(var_a.length))) / arg0) == (address(var_a.length))) | !arg0);
        require(!address(var_f));
        require(arg1);
        require(arg1);
        require((arg0 * (address(var_a.length))) / (address(var_g)) > ((arg0 * (address(var_a.length))) / (address(var_g)) + 0x01));
        return ((arg0 * (address(var_a.length))) / (address(var_g))) + 0x01;
        return (arg0 * (address(var_a.length))) / (address(var_g));
        return arg0;
    }
    
    /// @custom:selector    0x8cad7fbe
    /// @custom:signature   swappers(address arg0) public view returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function swappers(address arg0) public view returns (bool) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x20);
        require(arg0 - (address(arg0)));
        address var_a = address(arg0);
        return !(!bytes1(storage_map_a[var_a]));
    }
    
    /// @custom:selector    0xafa85de6
    /// @custom:signature   approvedLenders(address arg0) public view returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function approvedLenders(address arg0) public view returns (bool) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x20);
        require(arg0 - (address(arg0)));
        address var_a = address(arg0);
        return !(!bytes1(storage_map_a[var_a]));
    }
    
    /// @custom:selector    0xba087652
    /// @custom:signature   redeem(uint256 arg0, address arg1, address arg2) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["address", "uint160", "bytes20", "int160"]
    function redeem(uint256 arg0, address arg1, address arg2) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x60);
        require(arg1 - (address(arg1)));
        require(arg2 - (address(arg2)));
        require(!(!store_c == 0x02), "SafeCast: value doesn't fit in 128 bits");
        store_c = 0x02;
        require(((var_a + 0xa0) > 0xffffffffffffffff) | ((var_a + 0xa0) < var_a), "SafeCast: value doesn't fit in 128 bits");
        uint256 var_a = var_a + 0xa0;
        require(block.timestamp == (uint64(addInterest >> 0x40)), "SafeCast: value doesn't fit in 128 bits");
        require(((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a), "SafeCast: value doesn't fit in 128 bits");
        var_a = var_a + 0x40;
        require(0 == (!address(var_k)), "SafeCast: value doesn't fit in 128 bits");
        require(!(((arg0 * (address(var_a.length))) / arg0) == (address(var_a.length)) | !arg0), "SafeCast: value doesn't fit in 128 bits");
        require(!(address(var_k)), "SafeCast: value doesn't fit in 128 bits");
        require((arg0 * (address(var_a.length))) / (address(var_l)) > 0xffffffffffffffffffffffffffffffff, "SafeCast: value doesn't fit in 128 bits");
        if (((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a)) {
            var_a = var_a + 0x40;
            require(((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a));
            var_a = var_a + 0x40;
            require(((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a));
            require(address(var_k));
            require(!bytes1(owner >> 0xa0));
        }
        require((block.timestamp - (uint64(var_s))) > block.timestamp);
        require(address(var_a.length) - ((0x0186a0 * (address(var_a.length))) / 0x0186a0));
        require(!address(var_a.length));
        require(0);
        require(!block.timestamp > 0);
        uint256 var_p = block.timestamp - (uint64(var_s));
        (bool success, bytes memory ret0) = address(0x18500cb1f2fe7a40ebda393383a0b8548a31f261).Unresolved_cd3181d5(var_p); // staticcall
        emit UpdateRate(uint64(var_w), block.timestamp - (uint64(var_s)), (0x0186a0 * (address(var_a.length))) / (address(var_a.length)), 0);
        require(!((block.timestamp - (uint64(var_s))) * (address(var_a.length)) / (block.timestamp - (uint64(var_s))) == (address(var_a.length))) | (!block.timestamp - (uint64(var_s))));
        require(0x40 > ret0.length);
        require(((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a));
        var_a = var_a + 0x40;
        require(((var_a + 0x40) - var_a) < 0x40);
        require(var_a.length - (uint64(var_a.length)));
        if (!0) {
        }
        if (address(var_k)) {
        }
    }
    
    /// @custom:selector    0x891682d2
    /// @custom:signature   setTimeLock(address arg0) public payable returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function setTimeLock(address arg0) public payable returns (uint256) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x20);
        require(arg0 - (address(arg0)));
        require(msg.sender - (address(TIME_LOCK_ADDRESS)), CustomError_3b6b86b1());
        emit SetTimeLock(address(TIME_LOCK_ADDRESS), address(arg0));
        TIME_LOCK_ADDRESS = (uint96(TIME_LOCK_ADDRESS)) | (address(arg0));
        return ;
    }
    
    /// @custom:selector    0x715018a6
    /// @custom:signature   renounceOwnership() public payable
    function renounceOwnership() public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0);
        require(msg.sender - (address(owner)), "Ownable: caller is not the owner");
        owner = uint96(owner);
        emit OwnershipTransferred(address(owner), 0);
    }
    
    /// @custom:selector    0x3cc32aba
    /// @custom:signature   Unresolved_3cc32aba(uint256 arg0, uint256 arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_3cc32aba(uint256 arg0, uint256 arg1) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg0 > 0xffffffffffffffff);
        require(arg0 > 0xffffffffffffffff);
        require(arg1 - arg1);
        require(0);
        address var_a = msg.sender;
        require(!bytes1(storage_map_a[var_a]));
        require(!bytes1(storage_map_a[var_a]));
        require(0 < (arg0));
        require(!arg1);
        require(arg1);
        require(!0 < (arg0));
        require((0 + (arg0 + 0x20)) - (address(0 + (arg0 + 0x20))));
        var_a = address(0 + (arg0 + 0x20));
        storage_map_a[var_a] = (bytes1(arg1)) | (uint248(storage_map_a[var_a]));
        require(!(0 < (arg0)), CustomError_95a584f7());
        require(0 == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, CustomError_95a584f7());
        require(0, CustomError_95a584f7());
    }
    
    /// @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)), "ERC20: transfer amount exceeds balance");
        require(!(address(arg0)), "ERC20: transfer amount exceeds balance");
        address var_a = address(msg.sender);
        require(storage_map_a[var_a] < arg1, "ERC20: transfer amount exceeds balance");
        var_a = address(msg.sender);
        storage_map_a[var_a] = storage_map_a[var_a] - arg1;
        var_a = address(arg0);
        require(storage_map_a[var_a] > (storage_map_a[var_a] + arg1), "ERC20: transfer to the zero address");
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        storage_map_a[var_a] = storage_map_a[var_a] + arg1;
        emit Transfer(address(msg.sender), address(arg0), arg1);
        return 0x01;
    }
    
    /// @custom:selector    0xb054898b
    /// @custom:signature   Unresolved_b054898b(uint256 arg0, uint256 arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_b054898b(uint256 arg0, uint256 arg1) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg0 > 0xffffffffffffffff);
        require(arg0 > 0xffffffffffffffff);
        require(arg1 - arg1);
        require(0);
        address var_a = msg.sender;
        require(!bytes1(storage_map_a[var_a]));
        require(0 < (arg0));
        require(!arg1);
        require(arg1);
        require(!0 < (arg0));
        require((0 + (arg0 + 0x20)) - (address(0 + (arg0 + 0x20))));
        var_a = address(0 + (arg0 + 0x20));
        storage_map_a[var_a] = (bytes1(arg1)) | (uint248(storage_map_a[var_a]));
        require(!(0 < (arg0)), CustomError_85e83bba());
        require(0 == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff, CustomError_85e83bba());
        require(0, CustomError_85e83bba());
    }
    
    /// @custom:selector    0x3f4ba83a
    /// @custom:signature   unpause() public payable
    function unpause() public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0);
        require(!(msg.sender == 0x168200cf227d4543302686124ac28ae0eaf2ca0b), "Pausable: not paused");
        require(!(msg.sender == 0x168200cf227d4543302686124ac28ae0eaf2ca0b), "Pausable: not paused");
        require(((var_a + 0xa0) > 0xffffffffffffffff) | ((var_a + 0xa0) < var_a), "Pausable: not paused");
        uint256 var_a = var_a + 0xa0;
        require(block.timestamp == (uint64(addInterest >> 0x40)), "Pausable: not paused");
        require(!(bytes1(owner >> 0xa0)), "Pausable: not paused");
        owner = uint248(owner);
        emit Unpaused(msg.sender);
        if (((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a)) {
            var_a = var_a + 0x40;
            require(((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a));
            var_a = var_a + 0x40;
            require(((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a));
            require(address(var_p));
            require(!bytes1(owner >> 0xa0));
        }
        require((block.timestamp - (uint64(var_q))) > block.timestamp);
        require(address(var_a.length) - ((0x0186a0 * (address(var_a.length))) / 0x0186a0));
        require(!address(var_a.length));
        require(0);
        require(!block.timestamp > 0);
        uint256 var_s = block.timestamp - (uint64(var_q));
        (bool success, bytes memory ret0) = address(0x18500cb1f2fe7a40ebda393383a0b8548a31f261).Unresolved_cd3181d5(var_s); // staticcall
        emit UpdateRate(uint64(var_w), block.timestamp - (uint64(var_q)), (0x0186a0 * (address(var_a.length))) / (address(var_a.length)), 0);
        require(!((block.timestamp - (uint64(var_q))) * (address(var_a.length)) / (block.timestamp - (uint64(var_q))) == (address(var_a.length))) | (!block.timestamp - (uint64(var_q))));
        require(0x40 > ret0.length);
        require(((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a));
        var_a = var_a + 0x40;
        require(((var_a + 0x40) - var_a) < 0x40);
        require(var_a.length - (uint64(var_a.length)));
        if (!0) {
        }
        if (address(var_p)) {
        }
        require(!(msg.sender == (address(owner))), CustomError_8f5b12a7());
    }
    
    /// @custom:selector    0x8142dd53
    /// @custom:signature   changeFee(uint32 arg0) public payable
    /// @param              arg0 ["uint32", "bytes4", "int32"]
    function changeFee(uint32 arg0) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x20);
        require(arg0 - (uint32(arg0)));
        require(bytes1(owner >> 0xa0), "Pausable: paused");
        require(msg.sender - (address(TIME_LOCK_ADDRESS)), CustomError_3b6b86b1());
        require(uint32(arg0) > 0xc350, CustomError_da0afa57());
        require(((var_e + 0xa0) > 0xffffffffffffffff) | ((var_e + 0xa0) < var_e));
        uint256 var_e = var_e + 0xa0;
        require(block.timestamp == (uint64(addInterest >> 0x40)));
        addInterest = (uint224(addInterest)) | (uint32(arg0 << 0x20));
        emit ChangeFee(uint32(arg0));
        require(((var_e + 0x40) > 0xffffffffffffffff) | ((var_e + 0x40) < var_e));
        var_e = var_e + 0x40;
        require(((var_e + 0x40) > 0xffffffffffffffff) | ((var_e + 0x40) < var_e));
        var_e = var_e + 0x40;
        require(address(var_p));
        require(!bytes1(owner >> 0xa0));
        require(!bytes1(owner >> 0xa0));
        addInterest = (uint224(addInterest)) | (uint32(block.number));
        addInterest = (uint224(addInterest)) | (uint32(var_p << 0x20));
        addInterest = (uint64(addInterest) | (uint64(block.timestamp << 0x40)) | (uint64(var_q << 0x80))) | (uint64(var_r << 0xc0));
        addInterest = (uint224(addInterest)) | (uint32(arg0 << 0x20));
        emit ChangeFee(uint32(arg0));
        addInterest = (uint224(addInterest)) | (uint32(block.number));
        addInterest = (uint224(addInterest)) | (uint32(var_p << 0x20));
        addInterest = (uint64(addInterest) | (uint64(block.timestamp << 0x40)) | (uint64(var_q << 0x80))) | (uint64(var_r << 0xc0));
        addInterest = (uint224(addInterest)) | (uint32(arg0 << 0x20));
        emit ChangeFee(uint32(arg0));
        require((block.timestamp - (uint64(var_t))) > block.timestamp);
        require(address(var_e.length) - ((0x0186a0 * (address(var_e.length))) / 0x0186a0));
        require(!address(var_e.length));
        require(0);
        require(!block.timestamp > 0);
        uint256 var_u = block.timestamp - (uint64(var_t));
        (bool success, bytes memory ret0) = address(0x18500cb1f2fe7a40ebda393383a0b8548a31f261).Unresolved_cd3181d5(var_u); // staticcall
        emit UpdateRate(uint64(var_q), block.timestamp - (uint64(var_t)), (0x0186a0 * (address(var_e.length))) / (address(var_e.length)), 0);
        require(!((block.timestamp - (uint64(var_t))) * (address(var_e.length)) / (block.timestamp - (uint64(var_t))) == (address(var_e.length))) | (!block.timestamp - (uint64(var_t))));
        require(0x40 > ret0.length);
        require(((var_e + 0x40) > 0xffffffffffffffff) | ((var_e + 0x40) < var_e));
        var_e = var_e + 0x40;
        require(((var_e + 0x40) - var_e) < 0x40);
        require(var_e.length - (uint64(var_e.length)));
        if (!0) {
        }
        if (address(var_p)) {
        }
    }
    
    /// @custom:selector    0x721b0a47
    /// @custom:signature   liquidate(uint128 arg0, uint256 arg1, address arg2) public payable
    /// @param              arg0 ["address", "uint128", "bytes16", "int128"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["address", "uint160", "bytes20", "int160"]
    function liquidate(uint128 arg0, uint256 arg1, address arg2) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x60);
        require(arg0 - (address(arg0)));
        require(arg2 - (address(arg2)));
        require(bytes1(owner >> 0xa0), "Pausable: paused");
        require(!(!store_c == 0x02), CustomError_75e595fa());
        store_c = 0x02;
        require(0, CustomError_75e595fa());
        address var_e = msg.sender;
        require(!(bytes1(storage_map_g[var_e])), CustomError_75e595fa());
        require(!(bytes1(storage_map_g[var_e])), CustomError_75e595fa());
        require(block.timestamp > arg1, CustomError_75e595fa());
        require(((var_g + 0xa0) > 0xffffffffffffffff) | ((var_g + 0xa0) < var_g), CustomError_75e595fa());
        uint256 var_g = var_g + 0xa0;
        require(block.timestamp == (uint64(addInterest >> 0x40)), CustomError_75e595fa());
        require(((var_g + 0x40) > 0xffffffffffffffff) | ((var_g + 0x40) < var_g), CustomError_75e595fa());
        var_g = var_g + 0x40;
        require(block.timestamp == (uint32(exchangeRateInfo)), CustomError_75e595fa());
        require(!0x0124f8, CustomError_75e595fa());
        require(0x01, CustomError_75e595fa());
        require(((var_g + 0x40) > 0xffffffffffffffff) | ((var_g + 0x40) < var_g), CustomError_75e595fa());
        var_g = var_g + 0x40;
        var_e = address(arg2);
        require(0 == (!address(var_q)), CustomError_75e595fa());
        require(!(storage_map_g[var_e] * (address(var_g.length)) / storage_map_g[var_e] == (address(var_g.length)) | !storage_map_g[var_e]), CustomError_75e595fa());
        require(!(address(var_q)), CustomError_75e595fa());
        var_e = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(!storage_map_g[var_e], CustomError_75e595fa());
        var_e = address(arg2);
        require(!storage_map_g[var_e], CustomError_75e595fa());
        require(0, CustomError_75e595fa());
        require(0);
        (bool success, bytes memory ret0) = address(0).latestRoundData(); // staticcall
        require(!0 > 0);
        require((block.timestamp - 0) > block.timestamp);
        require((block.timestamp - 0) > maxOracleDelay);
        require(0);
        require(0x27942afe4ecb7f9945168094e0749cac749ac97b);
        (bool success, bytes memory ret0) = address(0x27942afe4ecb7f9945168094e0749cac749ac97b).latestRoundData(); // staticcall
        require(!(0 > 0), CustomError_8ab6676c());
        require(0xa0 > ret0.length);
        require(((var_g + 0xa0) > 0xffffffffffffffff) | ((var_g + 0xa0) < var_g));
        var_g = var_g + 0xa0;
        require(((var_g + 0xa0) - var_g) < 0xa0);
        require(var_g.length - (uint80(var_g.length)));
        require(var_t - (uint80(var_t)));
        require(0xa0 > ret0.length);
        require(((var_g + 0xa0) > 0xffffffffffffffff) | ((var_g + 0xa0) < var_g));
        var_g = var_g + 0xa0;
        require(((var_g + 0xa0) - var_g) < 0xa0);
        require(0x27942afe4ecb7f9945168094e0749cac749ac97b);
        (bool success, bytes memory ret0) = address(0x27942afe4ecb7f9945168094e0749cac749ac97b).latestRoundData(); // staticcall
        if (0xa0 > ret0.length) {
        }
        require(0, CustomError_95a584f7());
    }
    
    /// @custom:selector    0xa457c2d7
    /// @custom:signature   decreaseAllowance(address arg0, uint256 arg1) public payable returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function decreaseAllowance(address arg0, uint256 arg1) public payable returns (uint256) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg0 - (address(arg0)));
        var_a = address(arg0);
        require(storage_map_a[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_a[var_a] = storage_map_a[var_a] - arg1;
        emit Approval(address(msg.sender), address(arg0), storage_map_a[var_a] - arg1);
        return 0x01;
    }
    
    /// @custom:selector    0x6e553f65
    /// @custom:signature   Unresolved_6e553f65(address arg0, address arg1) public payable returns (address)
    /// @param              arg0 ["address", "uint128", "bytes16", "int128"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_6e553f65(address arg0, address arg1) public payable returns (address) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg1 - (address(arg1)));
        require(!(!store_c == 0x02), "Pausable: paused");
        store_c = 0x02;
        require(0, "Pausable: paused");
        require(block.timestamp > 0, "Pausable: paused");
        require(bytes1(owner >> 0xa0), "Pausable: paused");
        require(0, "SafeCast: value doesn't fit in 128 bits");
        address var_e = msg.sender;
        require(!(bytes1(storage_map_g[var_e])), "SafeCast: value doesn't fit in 128 bits");
        var_e = address(arg1);
        require(!(bytes1(storage_map_g[var_e])), "SafeCast: value doesn't fit in 128 bits");
        require(((var_g + 0xa0) > 0xffffffffffffffff) | ((var_g + 0xa0) < var_g), "SafeCast: value doesn't fit in 128 bits");
        uint256 var_g = var_g + 0xa0;
        uint32 var_a = uint32(addInterest);
        require(block.timestamp == (uint64(addInterest >> 0x40)), "SafeCast: value doesn't fit in 128 bits");
        require(((var_g + 0x40) > 0xffffffffffffffff) | ((var_g + 0x40) < var_g), "SafeCast: value doesn't fit in 128 bits");
        var_g = var_g + 0x40;
        require(0 == (!address(var_g.length)), "SafeCast: value doesn't fit in 128 bits");
        require(!(((arg0 * (address(var_o))) / arg0) == (address(var_o)) | !arg0), "SafeCast: value doesn't fit in 128 bits");
        require(!(address(var_g.length)), "SafeCast: value doesn't fit in 128 bits");
        require(arg0 > 0xffffffffffffffffffffffffffffffff, "SafeCast: value doesn't fit in 128 bits");
        require((arg0 * (address(var_o))) / (address(var_g.length)) > 0xffffffffffffffffffffffffffffffff, "SafeCast: value doesn't fit in 128 bits");
        require(address(var_g.length) + (address(arg0)) > 0xffffffffffffffffffffffffffffffff, "Address: call to non-contract");
        require(address(var_o) + (address((arg0 * (var_o)) / (var_g.length))) > 0xffffffffffffffffffffffffffffffff, "Address: call to non-contract");
        require(!(address(arg1)), "Address: call to non-contract");
        require(store_o > (store_o + (address((arg0 * (var_o)) / (var_g.length)))), "Address: call to non-contract");
        store_o = store_o + (address((arg0 * (var_o)) / (var_g.length)));
        var_e = address(arg1);
        uint256 var_f = 0;
        require(storage_map_g[var_e] > (storage_map_g[var_e] + (address((arg0 * (var_o)) / (var_g.length)))), "Address: call to non-contract");
        var_e = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        storage_map_g[var_e] = storage_map_g[var_e] + (address((arg0 * (var_o)) / (var_g.length)));
        emit Transfer(0, address(arg1), address((arg0 * (var_o)) / (var_g.length)));
        totalSupply = (address(totalSupply)) | (address(var_g.length));
        totalSupply = (address(totalSupply)) | (address(var_o << 0x80));
        address var_r = msg.sender;
        require(((var_g + 0xa0) > 0xffffffffffffffff) | ((var_g + 0xa0) < var_g), "Address: call to non-contract");
        var_g = var_g + 0xa0;
        require(((var_g + 0x40) > 0xffffffffffffffff) | ((var_g + 0x40) < var_g), "Address: call to non-contract");
        var_g = var_g + 0x40;
        require(!address(0x853d955acef822db058eb8505911ed77f175b99e).code.length, "Address: call to non-contract");
        (bool success, bytes memory ret0) = address(0x853d955acef822db058eb8505911ed77f175b99e).{ value: var_f ether }Unresolved_23b872dd(var_r); // call
        require(!ret0.length);
        require(!var_ab);
        require(var_ab);
        require((((0x60 + var_ab) + 0x20) - 0x80) < 0x20);
        require(var_a - var_a);
        require(!var_a, "SafeERC20: ERC20 operation did not succeed");
        emit Deposit(msg.sender, address(arg1), address(arg0), address((arg0 * (var_o)) / (var_g.length)));
        store_c = 0x01;
        return (arg0 * (address(var_o))) / (address(var_g.length));
        emit Deposit(msg.sender, address(arg1), address(arg0), address((arg0 * (var_o)) / (var_g.length)));
        store_c = 0x01;
        return (arg0 * (address(var_o))) / (address(var_g.length));
        require(ret0.length > 0xffffffffffffffff);
        require(((var_g + (uint248(((ret0.length + 0x1f) + 0x20) + 0x1f))) > 0xffffffffffffffff) | ((var_g + (uint248(((ret0.length + 0x1f) + 0x20) + 0x1f))) < var_g));
        var_g = var_g + (uint248(((ret0.length + 0x1f) + 0x20) + 0x1f));
        require(!var_g.length);
        require(var_g.length, "ERC20: mint to the zero address");
        emit Deposit(msg.sender, address(arg1), address(arg0), address((arg0 * (var_o)) / (var_g.length)));
        store_c = 0x01;
        return (arg0 * (address(var_o))) / (address(var_g.length));
        require(0, CustomError_95a584f7());
        require(0, CustomError_b063a8a5());
    }
    
    /// @custom:selector    0xc936c624
    /// @custom:signature   approvedBorrowers(address arg0) public view returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function approvedBorrowers(address arg0) public view returns (bool) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x20);
        require(arg0 - (address(arg0)));
        address var_a = address(arg0);
        return !(!bytes1(storage_map_a[var_a]));
    }
    
    /// @custom:selector    0xb5af3062
    /// @custom:signature   userCollateralBalance(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function userCollateralBalance(address arg0) public view returns (uint256) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x20);
        require(arg0 - (address(arg0)));
        address var_a = address(arg0);
        return storage_map_a[var_a];
    }
    
    /// @custom:selector    0xe5f13b16
    /// @custom:signature   borrowAsset(uint256 arg0, uint256 arg1, address arg2) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["address", "uint160", "bytes20", "int160"]
    function borrowAsset(uint256 arg0, uint256 arg1, address arg2) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x60);
        require(arg2 - (address(arg2)));
        require(0, "Pausable: paused");
        require(block.timestamp > 0, "Pausable: paused");
        require(bytes1(owner >> 0xa0), "Pausable: paused");
        require(!(!store_c == 0x02), "SafeCast: value doesn't fit in 128 bits");
        store_c = 0x02;
        require(0, "SafeCast: value doesn't fit in 128 bits");
        address var_e = msg.sender;
        require(!(bytes1(storage_map_g[var_e])), "SafeCast: value doesn't fit in 128 bits");
        require(((var_g + 0xa0) > 0xffffffffffffffff) | ((var_g + 0xa0) < var_g), "SafeCast: value doesn't fit in 128 bits");
        uint256 var_g = var_g + 0xa0;
        require(block.timestamp == (uint64(addInterest >> 0x40)), "SafeCast: value doesn't fit in 128 bits");
        require(((var_g + 0x40) > 0xffffffffffffffff) | ((var_g + 0x40) < var_g), "SafeCast: value doesn't fit in 128 bits");
        var_g = var_g + 0x40;
        require(block.timestamp == (uint32(exchangeRateInfo)), "SafeCast: value doesn't fit in 128 bits");
        require(arg1, "SafeCast: value doesn't fit in 128 bits");
        var_e = address(msg.sender);
        require(storage_map_g[var_e] > (storage_map_g[var_e] + arg1), "SafeCast: value doesn't fit in 128 bits");
        require(arg0 > 0xffffffffffffffffffffffffffffffff, "SafeCast: value doesn't fit in 128 bits");
        require(0);
        (bool success, bytes memory ret0) = address(0).latestRoundData(); // staticcall
        require(!(0 > 0), CustomError_57b0e210());
        require((block.timestamp - 0) > block.timestamp, CustomError_57b0e210());
        require((block.timestamp - 0) > maxOracleDelay, CustomError_57b0e210());
        require(0, CustomError_57b0e210());
        require(0x27942afe4ecb7f9945168094e0749cac749ac97b, CustomError_57b0e210());
        require(!0x01, CustomError_57b0e210());
        require(0 > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff, CustomError_57b0e210());
        (bool success, bytes memory ret0) = address(0x27942afe4ecb7f9945168094e0749cac749ac97b).latestRoundData(); // staticcall
        require(!(0 > 0), CustomError_8ab6676c());
        require(0xa0 > ret0.length);
        require(((var_g + 0xa0) > 0xffffffffffffffff) | ((var_g + 0xa0) < var_g));
        var_g = var_g + 0xa0;
        require(((var_g + 0xa0) - var_g) < 0xa0);
        require(var_g.length - (uint80(var_g.length)));
        require(var_t - (uint80(var_t)));
        require(0xa0 > ret0.length);
        require(((var_g + 0xa0) > 0xffffffffffffffff) | ((var_g + 0xa0) < var_g));
        var_g = var_g + 0xa0;
        require(((var_g + 0xa0) - var_g) < 0xa0);
        require(0x27942afe4ecb7f9945168094e0749cac749ac97b);
        require(!0x01);
        (bool success, bytes memory ret0) = address(0x27942afe4ecb7f9945168094e0749cac749ac97b).latestRoundData(); // staticcall
        if (0xa0 > ret0.length) {
        }
        if (((var_g + 0x40) > 0xffffffffffffffff) | ((var_g + 0x40) < var_g)) {
            var_g = var_g + 0x40;
            if (((var_g + 0x40) > 0xffffffffffffffff) | ((var_g + 0x40) < var_g)) {
                var_g = var_g + 0x40;
                if (address(var_v)) {
                    if (!owner >> 0xa0) {
                        require(((var_g + 0x40) > 0xffffffffffffffff) | ((var_g + 0x40) < var_g), CustomError_85e83bba());
                    }
                }
                require(((var_g + 0x40) > 0xffffffffffffffff) | ((var_g + 0x40) < var_g), CustomError_85e83bba());
            }
        }
        require(0, CustomError_85e83bba());
        require(0, CustomError_b063a8a5());
    }
    
    /// @custom:selector    0x4fd422df
    /// @custom:signature   userBorrowShares(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function userBorrowShares(address arg0) public view returns (uint256) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x20);
        require(arg0 - (address(arg0)));
        address var_a = address(arg0);
        return storage_map_a[var_a];
    }
    
    /// @custom:selector    0xf2fde38b
    /// @custom:signature   transferOwnership(address arg0) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function transferOwnership(address arg0) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x20);
        require(arg0 - (address(arg0)));
        require(msg.sender - (address(owner)), "Ownable: caller is not the owner");
        require(!(address(arg0)), "Ownable: new owner is the zero address");
        owner = (uint96(owner)) | (address(arg0));
        emit OwnershipTransferred(address(owner), address(arg0));
    }
    
    /// @custom:selector    0xcadac479
    /// @custom:signature   addCollateral(uint256 arg0, address arg1) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function addCollateral(uint256 arg0, address arg1) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg1 - (address(arg1)));
        if (store_c == 0x02) {
            store_c = 0x02;
            require(store_c == 0x02);
            require(0);
            require(block.timestamp > 0);
            uint256 var_c = var_c + 0xa0;
            require(((var_c + 0xa0) > 0xffffffffffffffff) | ((var_c + 0xa0) < var_c));
            require(block.timestamp == (uint64(addInterest >> 0x40)));
            var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
            require(storage_map_a[var_a] > (storage_map_a[var_a] + arg0));
            var_c = var_c + 0x40;
            require(((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c));
            var_c = var_c + 0x40;
            require(((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c));
            require(address(var_n));
            require(!bytes1(owner >> 0xa0));
        }
        require((block.timestamp - (uint64(var_o))) > block.timestamp);
        require(address(var_c.length) - ((0x0186a0 * (address(var_c.length))) / 0x0186a0));
        require(!address(var_c.length));
        require(0);
        require(!block.timestamp > 0);
        uint256 var_q = block.timestamp - (uint64(var_o));
        (bool success, bytes memory ret0) = address(0x18500cb1f2fe7a40ebda393383a0b8548a31f261).Unresolved_cd3181d5(var_q); // staticcall
        emit UpdateRate(uint64(var_u), block.timestamp - (uint64(var_o)), (0x0186a0 * (address(var_c.length))) / (address(var_c.length)), 0);
        require(!((block.timestamp - (uint64(var_o))) * (address(var_c.length)) / (block.timestamp - (uint64(var_o))) == (address(var_c.length))) | (!block.timestamp - (uint64(var_o))));
        require(0x40 > ret0.length);
        require(((var_c + 0x40) > 0xffffffffffffffff) | ((var_c + 0x40) < var_c));
        var_c = var_c + 0x40;
        require(((var_c + 0x40) - var_c) < 0x40);
        require(var_c.length - (uint64(var_c.length)));
        if (!0) {
        }
        if (address(var_n)) {
        }
        require(0, CustomError_b063a8a5());
    }
    
    /// @custom:selector    0xca2298fe
    /// @custom:signature   Unresolved_ca2298fe(address arg0, address arg1, uint256 arg2) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    function Unresolved_ca2298fe(address arg0, address arg1, uint256 arg2) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x80);
        require(arg0 - (address(arg0)));
        require(arg3 > 0xffffffffffffffff);
        require(arg3 > 0xffffffffffffffff);
        require(store_c == 0x02);
        store_c = 0x02;
        require(((var_a + 0xa0) > 0xffffffffffffffff) | ((var_a + 0xa0) < var_a));
        uint256 var_a = var_a + 0xa0;
        require(block.timestamp == (uint64(addInterest >> 0x40)));
        require(((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a));
        var_a = var_a + 0x40;
        require(block.timestamp == (uint32(exchangeRateInfo)));
        address var_b = address(arg0);
        require(!bytes1(storage_map_j[var_b]));
        require(!arg3);
        require((arg3 + 0x20) - (address(arg3 + 0x20)));
        require(address(arg3 + 0x20) - 0xac3e018457b222d93114458476f3e3416abbe38f);
        require((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) > (arg3));
        require(!(arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (arg3));
        require(((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) << 0x05) + (arg3 + 0x20) - (address(((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) << 0x05) + (arg3 + 0x20))));
        require(address(((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) << 0x05) + (arg3 + 0x20)) - 0x853d955acef822db058eb8505911ed77f175b99e);
        var_b = address(msg.sender);
        require((storage_map_j[var_b] - arg1) > storage_map_j[var_b]);
        require(!(arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (arg3));
        require(((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) << 0x05) + (arg3 + 0x20) - (address(((arg3 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) << 0x05) + (arg3 + 0x20))));
        require(0);
        (bool success, bytes memory ret0) = address(0).latestRoundData(); // staticcall
        require(!(0 > 0), CustomError_57b0e210());
        require((block.timestamp - 0) > block.timestamp, CustomError_57b0e210());
        require((block.timestamp - 0) > maxOracleDelay, CustomError_57b0e210());
        require(0, CustomError_57b0e210());
        require(0x27942afe4ecb7f9945168094e0749cac749ac97b, CustomError_57b0e210());
        require(!0x01, CustomError_57b0e210());
        require(0 > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff, CustomError_57b0e210());
        (bool success, bytes memory ret0) = address(0x27942afe4ecb7f9945168094e0749cac749ac97b).latestRoundData(); // staticcall
        require(!(0 > 0), CustomError_8ab6676c());
        require(0xa0 > ret0.length);
        require(((var_a + 0xa0) > 0xffffffffffffffff) | ((var_a + 0xa0) < var_a));
        var_a = var_a + 0xa0;
        require(((var_a + 0xa0) - var_a) < 0xa0);
        require(var_a.length - (uint80(var_a.length)));
        require(var_o - (uint80(var_o)));
        require(0xa0 > ret0.length);
        require(((var_a + 0xa0) > 0xffffffffffffffff) | ((var_a + 0xa0) < var_a));
        var_a = var_a + 0xa0;
        require(((var_a + 0xa0) - var_a) < 0xa0);
        require(0x27942afe4ecb7f9945168094e0749cac749ac97b);
        require(!0x01);
        (bool success, bytes memory ret0) = address(0x27942afe4ecb7f9945168094e0749cac749ac97b).latestRoundData(); // staticcall
        if (0xa0 > ret0.length) {
        }
        if (((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a)) {
            var_a = var_a + 0x40;
            if (((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a)) {
                var_a = var_a + 0x40;
                if (address(var_q)) {
                    if (!owner >> 0xa0) {
                        require(((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a), "ReentrancyGuard: reentrant call");
                    }
                }
                require(((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a), "ReentrancyGuard: reentrant call");
            }
        }
    }
    
    /// @custom:selector    0x8456cb59
    /// @custom:signature   pause() public payable
    function pause() public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0);
        require(!(msg.sender == 0xfd3065c629ee890fd74f43b802c2fea4b7279b8c), "Pausable: paused");
        require(!(msg.sender == 0xfd3065c629ee890fd74f43b802c2fea4b7279b8c), "Pausable: paused");
        require(!(msg.sender == 0xfd3065c629ee890fd74f43b802c2fea4b7279b8c), "Pausable: paused");
        require(!(msg.sender == 0xfd3065c629ee890fd74f43b802c2fea4b7279b8c), "Pausable: paused");
        require(((var_a + 0xa0) > 0xffffffffffffffff) | ((var_a + 0xa0) < var_a), "Pausable: paused");
        uint256 var_a = var_a + 0xa0;
        require(block.timestamp == (uint64(addInterest >> 0x40)), "Pausable: paused");
        require(bytes1(owner >> 0xa0), "Pausable: paused");
        owner = (uint248(owner)) | 0x010000000000000000000000000000000000000000;
        emit Paused(msg.sender);
        if (((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a)) {
            var_a = var_a + 0x40;
            require(((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a));
            var_a = var_a + 0x40;
            require(((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a));
            require(address(var_p));
            require(!bytes1(owner >> 0xa0));
        }
        require((block.timestamp - (uint64(var_q))) > block.timestamp);
        require(address(var_a.length) - ((0x0186a0 * (address(var_a.length))) / 0x0186a0));
        require(!address(var_a.length));
        require(0);
        require(!block.timestamp > 0);
        uint256 var_s = block.timestamp - (uint64(var_q));
        (bool success, bytes memory ret0) = address(0x18500cb1f2fe7a40ebda393383a0b8548a31f261).Unresolved_cd3181d5(var_s); // staticcall
        emit UpdateRate(uint64(var_w), block.timestamp - (uint64(var_q)), (0x0186a0 * (address(var_a.length))) / (address(var_a.length)), 0);
        require(!((block.timestamp - (uint64(var_q))) * (address(var_a.length)) / (block.timestamp - (uint64(var_q))) == (address(var_a.length))) | (!block.timestamp - (uint64(var_q))));
        require(0x40 > ret0.length);
        require(((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a));
        var_a = var_a + 0x40;
        require(((var_a + 0x40) - var_a) < 0x40);
        require(var_a.length - (uint64(var_a.length)));
        if (!0) {
        }
        if (address(var_p)) {
        }
        require(!(msg.sender == (address(owner))), CustomError_8f5b12a7());
        require(!(msg.sender == (address(owner))), CustomError_8f5b12a7());
    }
    
    /// @custom:selector    0xc270a544
    /// @custom:signature   Unresolved_c270a544(uint256 arg0, uint256 arg1) public view returns (address)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_c270a544(uint256 arg0, uint256 arg1) public view returns (address) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x40);
        require(arg1 - arg1);
        require(((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a));
        uint256 var_a = var_a + 0x40;
        require(0 == (!address(var_a.length)));
        require(!(((arg0 * (address(var_f))) / arg0) == (address(var_f))) | !arg0);
        require(!address(var_a.length));
        require(arg1);
        require(arg1);
        require((arg0 * (address(var_f))) / (address(var_a.length)) > ((arg0 * (address(var_f))) / (address(var_a.length)) + 0x01));
        return ((arg0 * (address(var_f))) / (address(var_a.length))) + 0x01;
        return (arg0 * (address(var_f))) / (address(var_a.length));
        return arg0;
    }
}