0x6243d8cea23066d098a15582d81a598b4e8391f4

deployer: unknown relevance score: 10 status: identified bytecode: 15011 bytes

DECOMPILED SOLIDITY (Heimdall) 

// 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 DOMAIN_TYPEHASH = 63630494520926674092677056046569304749177344945028501797992170511073678501990;
    uint256 public constant DELEGATION_TYPEHASH = 103359069561928152843793640083012950350530901667116492021891118459870908603103;
    
    bytes32 store_d;
    mapping(bytes32 => bytes32) storage_map_f;
    mapping(bytes32 => bytes32) storage_map_o;
    uint256 public decimals;
    mapping(bytes32 => bytes32) storage_map_h;
    mapping(bytes32 => bytes32) storage_map_g;
    bytes32 store_q;
    address public authority;
    bool public stopped;
    uint256 public unresolved_18160ddd;
    mapping(bytes32 => bytes32) storage_map_k;
    mapping(bytes32 => bytes32) storage_map_i;
    mapping(bytes32 => bytes32) storage_map_p;
    mapping(bytes32 => bytes32) storage_map_m;
    mapping(bytes32 => bytes32) storage_map_e;
    mapping(bytes32 => bytes32) storage_map_l;
    mapping(bytes32 => bytes32) storage_map_n;
    mapping(bytes32 => bytes32) storage_map_c;
    
    event Transfer(address, address, uint256);
    event LogSetAuthority(address);
    event Event_8c5be1e5();
    event DelegateVotesChanged(address, uint256, uint256);
    event DelegateChanged(address, address, address);
    event LogSetOwner(address);
    event Event_07da68f5();
    event Event_be9a6555();
    
    /// @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(!(bytes1(stopped / 0x010000000000000000000000000000000000000000)), "ds-stop-is-stopped");
        var_f = address(arg0);
        storage_map_c[var_f] = arg1;
        emit Event_8c5be1e5(address(msg.sender), address(arg0), arg1);
        return 0x01;
    }
    
    /// @custom:selector    0xc3cda520
    /// @custom:signature   delegateBySig(address arg0, uint256 arg1, uint256 arg2, uint8 arg3, bytes32 arg4, bytes32 arg5) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["bool", "uint8", "bytes1", "int8"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    function delegateBySig(address arg0, uint256 arg1, uint256 arg2, uint8 arg3, bytes32 arg4, bytes32 arg5) public payable {
        var_a = this.code[14724:14791];
        require(!(((0x0100 * (!bytes1(store_d))) - 0x01) & (store_d)) / 0x02);
        require(0x1f < (((0x0100 * (!bytes1(store_d))) - 0x01) & (store_d) / 0x02));
        var_b = 0x06;
        require((0x20 + var_d) + (((0x0100 * (!bytes1(store_d))) - 0x01) & (store_d) / 0x02) > (0x20 + (0x20 + var_d)));
        bytes1 var_d = (0x20 + var_d) + (((0x0100 * (!bytes1(store_d))) - 0x01) & (store_d) / 0x02);
        var_d = 0x20 + (0x20 + (0x20 + (0x20 + (0x20 + var_d))));
        var_a = this.code[14864:14922];
        var_d = 0x20 + (0x20 + (0x20 + (0x20 + (0x20 + var_d))));
        var_d = 0x20 + var_d;
        address var_y = ecrecover(keccak256(var_h), bytes1(arg3), arg4, arg5);
        require(var_z);
        require(!(address(var_y) == 0), "ds-delegate-token-invalid-nonce");
        address var_b = address(var_y);
        storage_map_e[var_b] = 0x01 + storage_map_e[var_b];
        require(arg1 == storage_map_e[var_b], "ds-delegate-token-invalid-nonce");
        require(!(block.timestamp > arg2), "ds-math-sub-underflow");
        var_b = address(var_y);
        storage_map_e[var_b] = (address(arg0) * 0x01) | (uint96(storage_map_e[var_b]));
        emit DelegateChanged(address(var_y), address(storage_map_e[var_b] / 0x01), address(arg0));
        var_b = address(var_y);
        require(!(!(address(storage_map_e[var_b] / 0x01)) == (address(arg0))), "ds-math-sub-underflow");
        require(!(storage_map_e[var_b] > 0), "ds-math-sub-underflow");
        require(address(storage_map_e[var_b] / 0x01) == 0, "ds-math-sub-underflow");
        var_b = address(storage_map_e[var_b] / 0x01);
        require(uint32(storage_map_e[var_b] / 0x01) > 0, "ds-math-sub-underflow");
        var_b = uint32((storage_map_e[var_b] / 0x01) - 0x01);
        require(!(storage_map_f[var_b] - storage_map_e[var_b] > (storage_map_f[var_b])), "ds-math-sub-underflow");
        require(!(uint32(storage_map_e[var_b] / 0x01) > 0), "ds-math-add-overflow");
        var_b = uint32((storage_map_e[var_b] / 0x01) - 0x01);
        require(!(storage_map_g[var_b] == block.number), "ds-math-add-overflow");
        var_b = uint32((storage_map_e[var_b] / 0x01) - 0x01);
        storage_map_f[var_b] = (storage_map_f[var_b]) - storage_map_e[var_b];
        emit DelegateVotesChanged(address(storage_map_e[var_b] / 0x01), storage_map_f[var_b], (storage_map_f[var_b]) - storage_map_e[var_b]);
        require(address(arg0) == 0, "ds-math-add-overflow");
        var_b = address(arg0);
        require(uint32(storage_map_e[var_b] / 0x01) > 0, "ds-math-add-overflow");
        var_b = uint32((storage_map_e[var_b] / 0x01) - 0x01);
        require(!(storage_map_f[var_b] + storage_map_e[var_b] < (storage_map_f[var_b])), "ds-math-add-overflow");
    }
    
    /// @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(!(bytes1(stopped / 0x010000000000000000000000000000000000000000)), "ds-stop-is-stopped");
        require(!(!(address(msg.sender)) == (address(msg.sender))), "ds-delegate-token-insufficient-balance");
        var_f = address(msg.sender);
        require(!(!storage_map_c[var_f] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), "ds-delegate-token-insufficient-balance");
        var_f = address(msg.sender);
        require(!(storage_map_c[var_f] < arg1), "ds-delegate-token-insufficient-balance");
        var_f = address(msg.sender);
        require(!((storage_map_c[var_f] - arg1) > storage_map_c[var_f]), "ds-math-sub-underflow");
        var_f = address(msg.sender);
        storage_map_c[var_f] = storage_map_c[var_f] - arg1;
        var_f = address(arg0);
        require(!((storage_map_c[var_f] + arg1) < storage_map_c[var_f]), "ds-math-add-overflow");
        var_f = address(arg0);
        storage_map_c[var_f] = storage_map_c[var_f] + arg1;
        emit Transfer(address(msg.sender), address(arg0), arg1);
        var_f = address(arg0);
        require(!(!(address(storage_map_c[var_f] / 0x01)) == (address(storage_map_c[var_f] / 0x01))), "ds-math-sub-underflow");
        require(!(arg1 > 0), "ds-math-sub-underflow");
        require(address(storage_map_c[var_f] / 0x01) == 0, "ds-math-sub-underflow");
        var_f = address(storage_map_c[var_f] / 0x01);
        require(uint32(storage_map_c[var_f] / 0x01) > 0, "ds-math-sub-underflow");
        var_f = uint32((storage_map_c[var_f] / 0x01) - 0x01);
        require(!((storage_map_h[var_f] - arg1) > (storage_map_h[var_f])), "ds-math-sub-underflow");
        require(!(uint32(storage_map_c[var_f] / 0x01) > 0), "ds-math-add-overflow");
        var_f = uint32((storage_map_c[var_f] / 0x01) - 0x01);
        require(!(storage_map_i[var_f] == block.number), "ds-math-add-overflow");
        var_f = uint32((storage_map_c[var_f] / 0x01) - 0x01);
        storage_map_h[var_f] = (storage_map_h[var_f]) - arg1;
        emit DelegateVotesChanged(address(storage_map_c[var_f] / 0x01), storage_map_h[var_f], (storage_map_h[var_f]) - arg1);
        require(address(storage_map_c[var_f] / 0x01) == 0, "ds-math-add-overflow");
        var_f = address(storage_map_c[var_f] / 0x01);
        require(uint32(storage_map_c[var_f] / 0x01) > 0, "ds-math-add-overflow");
        var_f = uint32((storage_map_c[var_f] / 0x01) - 0x01);
        require(!((storage_map_h[var_f] + arg1) < (storage_map_h[var_f])), "ds-math-add-overflow");
        return 0x01;
        return 0x01;
        var_f = address(msg.sender);
        require(!(storage_map_c[var_f] < arg1), "ds-delegate-token-insufficient-approval");
        if (address(msg.sender) == (address(msg.sender))) {
        }
    }
    
    /// @custom:selector    0xbe9a6555
    /// @custom:signature   Unresolved_be9a6555(uint32 arg0, uint256 arg1) public payable
    /// @param              arg0 ["uint32", "bytes4", "int32"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_be9a6555(uint32 arg0, uint256 arg1) public payable {
        require(!(address(msg.sender)) == (address(this)));
        require(!(address(msg.sender)) == (address(stopped / 0x01)));
        require(!(address(authority / 0x01)) == 0);
        address var_b = address(msg.sender);
        require(address(authority / 0x01).code.length);
        (bool success, bytes memory ret0) = address(authority / 0x01).Unresolved_b7009613(var_b); // staticcall
        require(!(ret0.length < 0x20), "ds-auth-unauthorized");
        require(var_e.length, "ds-auth-unauthorized");
        stopped = (0 * 0x010000000000000000000000000000000000000000) | (uint248(stopped));
        emit Event_be9a6555(address(msg.sender), arg0, arg1, msg.value, (0x20 + (0x20 + var_e)) - var_e, msg.data.length);
        require(0, "ds-auth-unauthorized");
        stopped = (0 * 0x010000000000000000000000000000000000000000) | (uint248(stopped));
        emit Event_be9a6555(address(msg.sender), arg0, arg1, msg.value, (0x20 + (0x20 + var_e)) - var_e, msg.data.length);
    }
    
    /// @custom:selector    0xbb35783b
    /// @custom:signature   move(address arg0, address arg1, uint256 arg2) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function move(address arg0, address arg1, uint256 arg2) public payable {
        require(!(bytes1(stopped / 0x010000000000000000000000000000000000000000)), "ds-stop-is-stopped");
        require(!(!(address(arg0)) == (address(msg.sender))), "ds-delegate-token-insufficient-balance");
        var_f = address(msg.sender);
        require(!(!storage_map_c[var_f] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), "ds-delegate-token-insufficient-balance");
        var_f = address(arg0);
        require(!(storage_map_c[var_f] < arg2), "ds-delegate-token-insufficient-balance");
        var_f = address(arg0);
        require(!((storage_map_c[var_f] - arg2) > storage_map_c[var_f]), "ds-math-sub-underflow");
        var_f = address(arg0);
        storage_map_c[var_f] = storage_map_c[var_f] - arg2;
        var_f = address(arg1);
        require(!((storage_map_c[var_f] + arg2) < storage_map_c[var_f]), "ds-math-add-overflow");
        var_f = address(arg1);
        storage_map_c[var_f] = storage_map_c[var_f] + arg2;
        emit Transfer(address(arg0), address(arg1), arg2);
        var_f = address(arg1);
        require(!(!(address(storage_map_c[var_f] / 0x01)) == (address(storage_map_c[var_f] / 0x01))), "ds-math-sub-underflow");
        require(!(arg2 > 0), "ds-math-sub-underflow");
        require(address(storage_map_c[var_f] / 0x01) == 0, "ds-math-sub-underflow");
        var_f = address(storage_map_c[var_f] / 0x01);
        require(uint32(storage_map_c[var_f] / 0x01) > 0, "ds-math-sub-underflow");
        var_f = uint32((storage_map_c[var_f] / 0x01) - 0x01);
        require(!((storage_map_h[var_f] - arg2) > (storage_map_h[var_f])), "ds-math-sub-underflow");
        require(!(uint32(storage_map_c[var_f] / 0x01) > 0), "ds-math-add-overflow");
        var_f = uint32((storage_map_c[var_f] / 0x01) - 0x01);
        require(!(storage_map_i[var_f] == block.number), "ds-math-add-overflow");
        var_f = uint32((storage_map_c[var_f] / 0x01) - 0x01);
        storage_map_h[var_f] = (storage_map_h[var_f]) - arg2;
        emit DelegateVotesChanged(address(storage_map_c[var_f] / 0x01), storage_map_h[var_f], (storage_map_h[var_f]) - arg2);
        require(address(storage_map_c[var_f] / 0x01) == 0, "ds-math-add-overflow");
        var_f = address(storage_map_c[var_f] / 0x01);
        require(uint32(storage_map_c[var_f] / 0x01) > 0, "ds-math-add-overflow");
        var_f = uint32((storage_map_c[var_f] / 0x01) - 0x01);
        require(!((storage_map_h[var_f] + arg2) < (storage_map_h[var_f])), "ds-math-add-overflow");
        var_f = address(msg.sender);
        require(!(storage_map_c[var_f] < arg2), "ds-delegate-token-insufficient-approval");
        if (address(arg0) == (address(msg.sender))) {
        }
    }
    
    /// @custom:selector    0x7ecebe00
    /// @custom:signature   nonces(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function nonces(address arg0) public view returns (uint256) {
        address var_b = address(arg0);
        return storage_map_e[var_b];
    }
    
    /// @custom:selector    0x13af4035
    /// @custom:signature   setOwner(address arg0) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function setOwner(address arg0) public payable {
        require(!(address(msg.sender)) == (address(this)));
        require(!(address(msg.sender)) == (address(stopped / 0x01)));
        require(!(address(authority / 0x01)) == 0);
        address var_b = address(msg.sender);
        require(address(authority / 0x01).code.length);
        (bool success, bytes memory ret0) = address(authority / 0x01).Unresolved_b7009613(var_b); // staticcall
        require(!(ret0.length < 0x20), "ds-auth-unauthorized");
        require(var_e.length, "ds-auth-unauthorized");
        stopped = (address(arg0) * 0x01) | (uint96(stopped));
        emit LogSetOwner(address(stopped / 0x01));
        require(0, "ds-auth-unauthorized");
        stopped = (address(arg0) * 0x01) | (uint96(stopped));
        emit LogSetOwner(address(stopped / 0x01));
    }
    
    /// @custom:selector    0x5c19a95c
    /// @custom:signature   delegate(address arg0) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function delegate(address arg0) public payable {
        var_a = address(msg.sender);
        storage_map_k[var_a] = (address(arg0) * 0x01) | (uint96(storage_map_k[var_a]));
        emit DelegateChanged(address(msg.sender), address(storage_map_k[var_a] / 0x01), address(arg0));
        var_a = address(msg.sender);
        require(!(!(address(storage_map_k[var_a] / 0x01)) == (address(arg0))), "ds-math-sub-underflow");
        require(!(storage_map_k[var_a] > 0), "ds-math-sub-underflow");
        require(address(storage_map_k[var_a] / 0x01) == 0, "ds-math-sub-underflow");
        var_a = address(storage_map_k[var_a] / 0x01);
        require(uint32(storage_map_k[var_a] / 0x01) > 0, "ds-math-sub-underflow");
        var_a = uint32((storage_map_k[var_a] / 0x01) - 0x01);
        require(!(storage_map_l[var_a] - storage_map_k[var_a] > (storage_map_l[var_a])), "ds-math-sub-underflow");
        require(!(uint32(storage_map_k[var_a] / 0x01) > 0), "ds-math-add-overflow");
        var_a = uint32((storage_map_k[var_a] / 0x01) - 0x01);
        require(!(storage_map_m[var_a] == block.number), "ds-math-add-overflow");
        var_a = uint32((storage_map_k[var_a] / 0x01) - 0x01);
        storage_map_l[var_a] = (storage_map_l[var_a]) - storage_map_k[var_a];
        emit DelegateVotesChanged(address(storage_map_k[var_a] / 0x01), storage_map_l[var_a], (storage_map_l[var_a]) - storage_map_k[var_a]);
        require(address(arg0) == 0, "ds-math-add-overflow");
        var_a = address(arg0);
        require(uint32(storage_map_k[var_a] / 0x01) > 0, "ds-math-add-overflow");
        var_a = uint32((storage_map_k[var_a] / 0x01) - 0x01);
        require(!(storage_map_l[var_a] + storage_map_k[var_a] < (storage_map_l[var_a])), "ds-math-add-overflow");
    }
    
    /// @custom:selector    0xf1127ed8
    /// @custom:signature   checkpoints(address arg0, uint32 arg1) public view returns (bytes memory)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint32", "bytes4", "int32"]
    function checkpoints(address arg0, uint32 arg1) public view returns (bytes memory) {
        address var_b = address(arg0);
        var_b = uint32(arg1);
        return abi.encodePacked(storage_map_g[var_b], storage_map_f[var_b]);
    }
    
    /// @custom:selector    0xb4b5ea57
    /// @custom:signature   getCurrentVotes(address arg0) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function getCurrentVotes(address arg0) public view returns (uint256) {
        address var_a = address(arg0);
        require(uint32(storage_map_k[var_a] / 0x01) > 0);
        var_a = uint32((storage_map_k[var_a] / 0x01) - 0x01);
        return storage_map_l[var_a];
        return 0;
    }
    
    /// @custom:selector    0xdd62ed3e
    /// @custom:signature   Unresolved_dd62ed3e(address arg0, address arg1) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_dd62ed3e(address arg0, address arg1) public view returns (uint256) {
        var_a = address(arg1);
        return storage_map_k[var_a];
    }
    
    /// @custom:selector    0x7a9e5e4b
    /// @custom:signature   setAuthority(address arg0) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function setAuthority(address arg0) public payable {
        require(!(address(msg.sender)) == (address(this)));
        require(!(address(msg.sender)) == (address(stopped / 0x01)));
        require(!(address(authority / 0x01)) == 0);
        address var_b = address(msg.sender);
        require(address(authority / 0x01).code.length);
        (bool success, bytes memory ret0) = address(authority / 0x01).Unresolved_b7009613(var_b); // staticcall
        require(!(ret0.length < 0x20), "ds-auth-unauthorized");
        require(var_e.length, "ds-auth-unauthorized");
        authority = (address(arg0) * 0x01) | (uint96(authority));
        emit LogSetAuthority(address(authority / 0x01));
        require(0, "ds-auth-unauthorized");
        authority = (address(arg0) * 0x01) | (uint96(authority));
        emit LogSetAuthority(address(authority / 0x01));
    }
    
    /// @custom:selector    0xa0712d68
    /// @custom:signature   mint(uint256 arg0) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function mint(uint256 arg0) public payable {
        require(!(address(msg.sender)) == (address(this)));
        require(!(address(msg.sender)) == (address(stopped / 0x01)));
        require(!(address(authority / 0x01)) == 0);
        address var_b = address(msg.sender);
        require(address(authority / 0x01).code.length);
        (bool success, bytes memory ret0) = address(authority / 0x01).Unresolved_b7009613(var_b); // staticcall
        require(!(ret0.length < 0x20), "ds-auth-unauthorized");
        require(var_e.length, "ds-auth-unauthorized");
        require(!(bytes1(stopped / 0x010000000000000000000000000000000000000000)), "ds-stop-is-stopped");
        address var_f = address(msg.sender);
        require(!((storage_map_c[var_f] + arg0) < storage_map_c[var_f]), "ds-math-add-overflow");
        require(0, "ds-auth-unauthorized");
    }
    
    /// @custom:selector    0x782d6fe1
    /// @custom:signature   getPriorVotes(address arg0, uint256 arg1) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function getPriorVotes(address arg0, uint256 arg1) public view returns (uint256) {
        require(arg1 < block.number, "ds-delegate-token-not-yet-determined");
        address var_f = address(arg0);
        if (!(uint32(storage_map_c[var_f] / 0x01)) == 0) {
            var_f = uint32((storage_map_c[var_f] / 0x01) - 0x01);
            require(!(uint32(storage_map_c[var_f] / 0x01)) == 0);
            var_f = 0;
            require(storage_map_i[var_f] > arg1);
            return 0;
            require(!(storage_map_i[var_f]) > arg1);
            var_f = 0;
            return storage_map_h[var_f];
            require(!(uint32((storage_map_c[var_f] / 0x01) - 0x01)) > 0);
            var_f = uint32(((storage_map_c[var_f] / 0x01) - 0x01) - ((((storage_map_c[var_f] / 0x01) - 0x01) - 0) / 0x02));
            require(0x02);
            require(!(var_k) == arg1);
        }
        return var_m;
        var_f = uint32((storage_map_c[var_f] / 0x01) - 0x01);
        return storage_map_h[var_f];
        return 0;
    }
    
    /// @custom:selector    0x06fdde03
    /// @custom:signature   Unresolved_06fdde03() public view returns (string memory)
    function Unresolved_06fdde03() public view returns (string memory) {
        bytes1 var_a = var_a + (0x20 + (((0x1f + (((0x0100 * (!bytes1(store_d))) - 0x01) & (store_d) / 0x02)) / 0x20) * 0x20));
        if (!(((0x0100 * (!store_d)) - 0x01) & (store_d)) / 0x02) {
            if (0x1f < (((0x0100 * (!store_d)) - 0x01) & (store_d) / 0x02)) {
                var_c = 0x06;
                if ((0x20 + var_a) + (((0x0100 * (!store_d)) - 0x01) & (store_d) / 0x02) > (0x20 + (0x20 + var_a))) {
                    if (!var_a.length) {
                        return abi.encodePacked((0x20 + var_a) - var_a, var_a.length, (~((0x0100 ** (0x20 - (bytes1(var_a.length)))) - 0x01)) & (var_g));
                        return abi.encodePacked((0x20 + var_a) - var_a, var_a.length);
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0xf2d5d56b
    /// @custom:signature   pull(address arg0, uint256 arg1) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function pull(address arg0, uint256 arg1) public payable {
        require(!(bytes1(stopped / 0x010000000000000000000000000000000000000000)), "ds-stop-is-stopped");
        require(!(!(address(arg0)) == (address(msg.sender))), "ds-delegate-token-insufficient-balance");
        var_f = address(msg.sender);
        require(!(!storage_map_c[var_f] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), "ds-delegate-token-insufficient-balance");
        var_f = address(arg0);
        require(!(storage_map_c[var_f] < arg1), "ds-delegate-token-insufficient-balance");
        var_f = address(arg0);
        require(!((storage_map_c[var_f] - arg1) > storage_map_c[var_f]), "ds-math-sub-underflow");
        var_f = address(arg0);
        storage_map_c[var_f] = storage_map_c[var_f] - arg1;
        var_f = address(msg.sender);
        require(!((storage_map_c[var_f] + arg1) < storage_map_c[var_f]), "ds-math-add-overflow");
        var_f = address(msg.sender);
        storage_map_c[var_f] = storage_map_c[var_f] + arg1;
        emit Transfer(address(arg0), address(msg.sender), arg1);
        var_f = address(msg.sender);
        require(!(!(address(storage_map_c[var_f] / 0x01)) == (address(storage_map_c[var_f] / 0x01))), "ds-math-sub-underflow");
        require(!(arg1 > 0), "ds-math-sub-underflow");
        require(address(storage_map_c[var_f] / 0x01) == 0, "ds-math-sub-underflow");
        var_f = address(storage_map_c[var_f] / 0x01);
        require(uint32(storage_map_c[var_f] / 0x01) > 0, "ds-math-sub-underflow");
        var_f = uint32((storage_map_c[var_f] / 0x01) - 0x01);
        require(!((storage_map_h[var_f] - arg1) > (storage_map_h[var_f])), "ds-math-sub-underflow");
        require(!(uint32(storage_map_c[var_f] / 0x01) > 0), "ds-math-add-overflow");
        var_f = uint32((storage_map_c[var_f] / 0x01) - 0x01);
        require(!(storage_map_i[var_f] == block.number), "ds-math-add-overflow");
        var_f = uint32((storage_map_c[var_f] / 0x01) - 0x01);
        storage_map_h[var_f] = (storage_map_h[var_f]) - arg1;
        emit DelegateVotesChanged(address(storage_map_c[var_f] / 0x01), storage_map_h[var_f], (storage_map_h[var_f]) - arg1);
        require(address(storage_map_c[var_f] / 0x01) == 0, "ds-math-add-overflow");
        var_f = address(storage_map_c[var_f] / 0x01);
        require(uint32(storage_map_c[var_f] / 0x01) > 0, "ds-math-add-overflow");
        var_f = uint32((storage_map_c[var_f] / 0x01) - 0x01);
        require(!((storage_map_h[var_f] + arg1) < (storage_map_h[var_f])), "ds-math-add-overflow");
        var_f = address(msg.sender);
        require(!(storage_map_c[var_f] < arg1), "ds-delegate-token-insufficient-approval");
        if (address(arg0) == (address(msg.sender))) {
        }
    }
    
    /// @custom:selector    0x95d89b41
    /// @custom:signature   Unresolved_95d89b41() public view returns (string memory)
    function Unresolved_95d89b41() public view returns (string memory) {
        bytes1 var_a = var_a + (0x20 + (((0x1f + (((0x0100 * (!bytes1(store_q))) - 0x01) & (store_q) / 0x02)) / 0x20) * 0x20));
        if (!(((0x0100 * (!store_q)) - 0x01) & (store_q)) / 0x02) {
            if (0x1f < (((0x0100 * (!store_q)) - 0x01) & (store_q) / 0x02)) {
                var_c = 0x05;
                if ((0x20 + var_a) + (((0x0100 * (!store_q)) - 0x01) & (store_q) / 0x02) > (0x20 + (0x20 + var_a))) {
                    if (!var_a.length) {
                        return abi.encodePacked((0x20 + var_a) - var_a, var_a.length, (~((0x0100 ** (0x20 - (bytes1(var_a.length)))) - 0x01)) & (var_g));
                        return abi.encodePacked((0x20 + var_a) - var_a, var_a.length);
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0xb753a98c
    /// @custom:signature   push(address arg0, uint256 arg1) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function push(address arg0, uint256 arg1) public payable {
        require(!(bytes1(stopped / 0x010000000000000000000000000000000000000000)), "ds-stop-is-stopped");
        require(!(!(address(msg.sender)) == (address(msg.sender))), "ds-delegate-token-insufficient-balance");
        var_f = address(msg.sender);
        require(!(!storage_map_c[var_f] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), "ds-delegate-token-insufficient-balance");
        var_f = address(msg.sender);
        require(!(storage_map_c[var_f] < arg1), "ds-delegate-token-insufficient-balance");
        var_f = address(msg.sender);
        require(!((storage_map_c[var_f] - arg1) > storage_map_c[var_f]), "ds-math-sub-underflow");
        var_f = address(msg.sender);
        storage_map_c[var_f] = storage_map_c[var_f] - arg1;
        var_f = address(arg0);
        require(!((storage_map_c[var_f] + arg1) < storage_map_c[var_f]), "ds-math-add-overflow");
        var_f = address(arg0);
        storage_map_c[var_f] = storage_map_c[var_f] + arg1;
        emit Transfer(address(msg.sender), address(arg0), arg1);
        var_f = address(arg0);
        require(!(!(address(storage_map_c[var_f] / 0x01)) == (address(storage_map_c[var_f] / 0x01))), "ds-math-sub-underflow");
        require(!(arg1 > 0), "ds-math-sub-underflow");
        require(address(storage_map_c[var_f] / 0x01) == 0, "ds-math-sub-underflow");
        var_f = address(storage_map_c[var_f] / 0x01);
        require(uint32(storage_map_c[var_f] / 0x01) > 0, "ds-math-sub-underflow");
        var_f = uint32((storage_map_c[var_f] / 0x01) - 0x01);
        require(!((storage_map_h[var_f] - arg1) > (storage_map_h[var_f])), "ds-math-sub-underflow");
        require(!(uint32(storage_map_c[var_f] / 0x01) > 0), "ds-math-add-overflow");
        var_f = uint32((storage_map_c[var_f] / 0x01) - 0x01);
        require(!(storage_map_i[var_f] == block.number), "ds-math-add-overflow");
        var_f = uint32((storage_map_c[var_f] / 0x01) - 0x01);
        storage_map_h[var_f] = (storage_map_h[var_f]) - arg1;
        emit DelegateVotesChanged(address(storage_map_c[var_f] / 0x01), storage_map_h[var_f], (storage_map_h[var_f]) - arg1);
        require(address(storage_map_c[var_f] / 0x01) == 0, "ds-math-add-overflow");
        var_f = address(storage_map_c[var_f] / 0x01);
        require(uint32(storage_map_c[var_f] / 0x01) > 0, "ds-math-add-overflow");
        var_f = uint32((storage_map_c[var_f] / 0x01) - 0x01);
        require(!((storage_map_h[var_f] + arg1) < (storage_map_h[var_f])), "ds-math-add-overflow");
        var_f = address(msg.sender);
        require(!(storage_map_c[var_f] < arg1), "ds-delegate-token-insufficient-approval");
        if (address(msg.sender) == (address(msg.sender))) {
        }
    }
    
    /// @custom:selector    0x23b872dd
    /// @custom:signature   Unresolved_23b872dd(address arg0, address arg1, uint256 arg2) public payable returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function Unresolved_23b872dd(address arg0, address arg1, uint256 arg2) public payable returns (bool) {
        require(!(bytes1(stopped / 0x010000000000000000000000000000000000000000)), "ds-stop-is-stopped");
        require(!(!(address(arg0)) == (address(msg.sender))), "ds-delegate-token-insufficient-balance");
        var_f = address(msg.sender);
        require(!(!storage_map_c[var_f] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), "ds-delegate-token-insufficient-balance");
        var_f = address(arg0);
        require(!(storage_map_c[var_f] < arg2), "ds-delegate-token-insufficient-balance");
        var_f = address(arg0);
        require(!((storage_map_c[var_f] - arg2) > storage_map_c[var_f]), "ds-math-sub-underflow");
        var_f = address(arg0);
        storage_map_c[var_f] = storage_map_c[var_f] - arg2;
        var_f = address(arg1);
        require(!((storage_map_c[var_f] + arg2) < storage_map_c[var_f]), "ds-math-add-overflow");
        var_f = address(arg1);
        storage_map_c[var_f] = storage_map_c[var_f] + arg2;
        emit Transfer(address(arg0), address(arg1), arg2);
        var_f = address(arg1);
        require(!(!(address(storage_map_c[var_f] / 0x01)) == (address(storage_map_c[var_f] / 0x01))), "ds-math-sub-underflow");
        require(!(arg2 > 0), "ds-math-sub-underflow");
        require(address(storage_map_c[var_f] / 0x01) == 0, "ds-math-sub-underflow");
        var_f = address(storage_map_c[var_f] / 0x01);
        require(uint32(storage_map_c[var_f] / 0x01) > 0, "ds-math-sub-underflow");
        var_f = uint32((storage_map_c[var_f] / 0x01) - 0x01);
        require(!((storage_map_h[var_f] - arg2) > (storage_map_h[var_f])), "ds-math-sub-underflow");
        require(!(uint32(storage_map_c[var_f] / 0x01) > 0), "ds-math-add-overflow");
        var_f = uint32((storage_map_c[var_f] / 0x01) - 0x01);
        require(!(storage_map_i[var_f] == block.number), "ds-math-add-overflow");
        var_f = uint32((storage_map_c[var_f] / 0x01) - 0x01);
        storage_map_h[var_f] = (storage_map_h[var_f]) - arg2;
        emit DelegateVotesChanged(address(storage_map_c[var_f] / 0x01), storage_map_h[var_f], (storage_map_h[var_f]) - arg2);
        require(address(storage_map_c[var_f] / 0x01) == 0, "ds-math-add-overflow");
        var_f = address(storage_map_c[var_f] / 0x01);
        require(uint32(storage_map_c[var_f] / 0x01) > 0, "ds-math-add-overflow");
        var_f = uint32((storage_map_c[var_f] / 0x01) - 0x01);
        require(!((storage_map_h[var_f] + arg2) < (storage_map_h[var_f])), "ds-math-add-overflow");
        return 0x01;
        return 0x01;
        var_f = address(msg.sender);
        require(!(storage_map_c[var_f] < arg2), "ds-delegate-token-insufficient-approval");
        if (address(arg0) == (address(msg.sender))) {
        }
    }
    
    /// @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) {
        address var_a = address(arg0);
        return storage_map_k[var_a];
    }
    
    /// @custom:selector    0x40c10f19
    /// @custom:signature   mint(address arg0, uint256 arg1) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function mint(address arg0, uint256 arg1) public payable {
        require(!(address(msg.sender)) == (address(this)));
        require(!(address(msg.sender)) == (address(stopped / 0x01)));
        require(!(address(authority / 0x01)) == 0);
        address var_b = address(msg.sender);
        require(address(authority / 0x01).code.length);
        (bool success, bytes memory ret0) = address(authority / 0x01).Unresolved_b7009613(var_b); // staticcall
        require(!(ret0.length < 0x20), "ds-auth-unauthorized");
        require(var_e.length, "ds-auth-unauthorized");
        require(!(bytes1(stopped / 0x010000000000000000000000000000000000000000)), "ds-stop-is-stopped");
        address var_f = address(arg0);
        require(!((storage_map_c[var_f] + arg1) < storage_map_c[var_f]), "ds-math-add-overflow");
        require(0, "ds-auth-unauthorized");
    }
    
    /// @custom:selector    0x9dc29fac
    /// @custom:signature   burn(address arg0, uint256 arg1) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function burn(address arg0, uint256 arg1) public payable {
        require(!(address(msg.sender)) == (address(this)));
        require(!(address(msg.sender)) == (address(stopped / 0x01)));
        require(!(address(authority / 0x01)) == 0);
        address var_b = address(msg.sender);
        require(address(authority / 0x01).code.length);
        (bool success, bytes memory ret0) = address(authority / 0x01).Unresolved_b7009613(var_b); // staticcall
        require(!(ret0.length < 0x20), "ds-auth-unauthorized");
        require(var_e.length, "ds-auth-unauthorized");
        require(!(bytes1(stopped / 0x010000000000000000000000000000000000000000)), "ds-stop-is-stopped");
        require(!(!(address(arg0)) == (address(msg.sender))), "ds-delegate-token-insufficient-balance");
        var_f = address(msg.sender);
        require(!(!storage_map_c[var_f] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), "ds-delegate-token-insufficient-balance");
        var_f = address(arg0);
        require(!(storage_map_c[var_f] < arg1), "ds-delegate-token-insufficient-balance");
        var_f = address(arg0);
        require(!((storage_map_c[var_f] - arg1) > storage_map_c[var_f]), "ds-math-sub-underflow");
        var_f = address(msg.sender);
        require(!(storage_map_c[var_f] < arg1), "ds-delegate-token-insufficient-approval");
        if (address(arg0) == (address(msg.sender))) {
        }
        require(0, "ds-auth-unauthorized");
    }
    
    /// @custom:selector    0x6fcfff45
    /// @custom:signature   numCheckpoints(address arg0) public view returns (uint32)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function numCheckpoints(address arg0) public view returns (uint32) {
        address var_b = address(arg0);
        return uint32(storage_map_e[var_b] / 0x01);
    }
    
    /// @custom:selector    0x587cde1e
    /// @custom:signature   delegates(address arg0) public view returns (address)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function delegates(address arg0) public view returns (address) {
        address var_b = address(arg0);
        return address(storage_map_e[var_b] / 0x01);
    }
    
    /// @custom:selector    0x07da68f5
    /// @custom:signature   Unresolved_07da68f5(uint32 arg0, uint256 arg1) public payable
    /// @param              arg0 ["uint32", "bytes4", "int32"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_07da68f5(uint32 arg0, uint256 arg1) public payable {
        require(!(address(msg.sender)) == (address(this)));
        require(!(address(msg.sender)) == (address(stopped / 0x01)));
        require(!(address(authority / 0x01)) == 0);
        address var_b = address(msg.sender);
        require(address(authority / 0x01).code.length);
        (bool success, bytes memory ret0) = address(authority / 0x01).Unresolved_b7009613(var_b); // staticcall
        require(!(ret0.length < 0x20), "ds-auth-unauthorized");
        require(var_e.length, "ds-auth-unauthorized");
        stopped = (0x01 * 0x010000000000000000000000000000000000000000) | (uint248(stopped));
        emit Event_07da68f5(address(msg.sender), arg0, arg1, msg.value, (0x20 + (0x20 + var_e)) - var_e, msg.data.length);
        require(0, "ds-auth-unauthorized");
        stopped = (0x01 * 0x010000000000000000000000000000000000000000) | (uint248(stopped));
        emit Event_07da68f5(address(msg.sender), arg0, arg1, msg.value, (0x20 + (0x20 + var_e)) - var_e, msg.data.length);
    }
    
    /// @custom:selector    0x42966c68
    /// @custom:signature   Unresolved_42966c68(uint256 arg0) public payable
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function Unresolved_42966c68(uint256 arg0) public payable {
        require(!(address(msg.sender)) == (address(this)));
        require(!(address(msg.sender)) == (address(stopped / 0x01)));
        require(!(address(authority / 0x01)) == 0);
        address var_b = address(msg.sender);
        require(address(authority / 0x01).code.length);
        (bool success, bytes memory ret0) = address(authority / 0x01).Unresolved_b7009613(var_b); // staticcall
        require(!(ret0.length < 0x20), "ds-auth-unauthorized");
        require(var_e.length, "ds-auth-unauthorized");
        require(!(bytes1(stopped / 0x010000000000000000000000000000000000000000)), "ds-stop-is-stopped");
        require(!(!(address(msg.sender)) == (address(msg.sender))), "ds-delegate-token-insufficient-balance");
        var_f = address(msg.sender);
        require(!(!storage_map_c[var_f] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), "ds-delegate-token-insufficient-balance");
        var_f = address(msg.sender);
        require(!(storage_map_c[var_f] < arg0), "ds-delegate-token-insufficient-balance");
        var_f = address(msg.sender);
        require(!((storage_map_c[var_f] - arg0) > storage_map_c[var_f]), "ds-math-sub-underflow");
        var_f = address(msg.sender);
        require(!(storage_map_c[var_f] < arg0), "ds-delegate-token-insufficient-approval");
        if (address(msg.sender) == (address(msg.sender))) {
        }
        require(0, "ds-auth-unauthorized");
    }
    
    /// @custom:selector    0xdaea85c5
    /// @custom:signature   approve(address arg0) public payable returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function approve(address arg0) public payable returns (bool) {
        require(!(bytes1(stopped / 0x010000000000000000000000000000000000000000)), "ds-stop-is-stopped");
        var_f = address(arg0);
        storage_map_c[var_f] = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
        emit Event_8c5be1e5(address(msg.sender), address(arg0), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        return 0x01;
    }
}

ABI

[
  {
    "type": "function",
    "name": "DELEGATION_TYPEHASH",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "DOMAIN_TYPEHASH",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_06fdde03",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_07da68f5",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint32"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_095ea7b3",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_18160ddd",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_23b872dd",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_42966c68",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_70a08231",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_95d89b41",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_be9a6555",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint32"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_dd62ed3e",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "approve",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "authority",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "burn",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "checkpoints",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint32"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "decimals",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "delegate",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "delegateBySig",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "uint8"
      },
      {
        "name": "arg4",
        "type": "bytes32"
      },
      {
        "name": "arg5",
        "type": "bytes32"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "delegates",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getCurrentVotes",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getPriorVotes",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "mint",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "move",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "nonces",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "numCheckpoints",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint32"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "owner",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "pull",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "push",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "setAuthority",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "setOwner",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "stopped",
    "inputs": [],
    "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": "DelegateChanged",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg2",
        "type": "address",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "DelegateVotesChanged",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "uint256",
        "indexed": false
      },
      {
        "name": "arg2",
        "type": "uint256",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Event_07da68f500000000000000000000000000000000000000000000000000000000",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Event_8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "Event_be9a655500000000000000000000000000000000000000000000000000000000",
    "inputs": [],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "LogSetAuthority",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "LogSetOwner",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      }
    ],
    "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 (0)

(none -- all recognized)
These selectors are not yet in the research database — they are being investigated and will be added as known functions once identified. They are also marked in red in the decompiled Solidity above.

KNOWN CLUSTER ADDRESSES IN THIS BYTECODE (0)

(none)