0x518076cce3729ef1a3877ea3647a26e278e764fe

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 {
    bytes public constant version = 0xBytes([49]);
    bytes public constant getTokenInterfacesVersion = 000000000000000000000000000000000000000000000000000000000000000200000000000000000000000000000000000000000000000000000000000000050000000000000000000000000000000000000000000000000000000000000000;
    uint256 public constant PERMIT_TYPEHASH_LEGACY = 105916522785188513640362517802612480037966763957092682311465172263008277174987;
    uint256 public constant PERMIT_TYPEHASH = 49955707469362902507454157297736832118868343942642399513960811609542965143241;
    bytes public constant finishMinting = ;
    
    uint256 public totalSupply;
    address public bridgeContract;
    mapping(bytes32 => bytes32) storage_map_d;
    uint256 public fopwCDKKK;
    bytes32 store_f;
    mapping(bytes32 => bytes32) storage_map_i;
    mapping(bytes32 => bytes32) storage_map_a;
    mapping(bytes32 => bytes32) storage_map_g;
    string public symbol;
    bool public mintingFinished;
    bool public decimals;
    
    event Approval(address, address, uint256);
    event Transfer(address, address, uint256);
    event Transfer(address, address, uint256, bytes);
    event OwnershipTransferred(address, address);
    
    /// @custom:selector    0x095ea7b3
    /// @custom:signature   approve(address arg0, uint256 arg1) public returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function approve(address arg0, uint256 arg1) public returns (bool) {
        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);
        require(!(arg1 == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), "ERC20: approve to the zero address");
        var_a = address(arg0);
        storage_map_a[var_a] = 0;
        return 0x01;
        return 0x01;
    }
    
    /// @custom:selector    0x66188463
    /// @custom:signature   decreaseApproval(address arg0, uint256 arg1) public returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function decreaseApproval(address arg0, uint256 arg1) public returns (bool) {
        var_a = address(arg0);
        if (arg1 < storage_map_a[var_a]) {
            if (!arg1 > storage_map_a[var_a]) {
                var_a = address(arg0);
                storage_map_a[var_a] = storage_map_a[var_a] - arg1;
                var_a = address(arg0);
                var_a = var_a;
                emit Approval(msg.sender, address(arg0), storage_map_a[var_a]);
                return 0x01;
                var_a = address(arg0);
                storage_map_a[var_a] = 0;
                var_a = address(arg0);
                var_a = var_a;
                emit Approval(msg.sender, address(arg0), storage_map_a[var_a]);
                return 0x01;
            }
        }
    }
    
    /// @custom:selector    0xa9059cbb
    /// @custom:signature   transfer(address arg0, uint256 arg1) public returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function transfer(address arg0, uint256 arg1) public returns (bool) {
        address var_a = msg.sender;
        require(!arg1 > storage_map_a[var_a]);
        require(address(arg0));
        var_a = msg.sender;
        require(!arg1 > storage_map_a[var_a]);
        var_a = msg.sender;
        storage_map_a[var_a] = storage_map_a[var_a] - arg1;
        var_a = address(arg0);
        require(!(arg1 + storage_map_a[var_a]) < storage_map_a[var_a]);
        var_a = address(arg0);
        storage_map_a[var_a] = arg1 + storage_map_a[var_a];
        emit Transfer(msg.sender, address(arg0), arg1);
        require(0x01);
        require(!(address(arg0)) == (address(bridgeContract)));
        return 0x01;
        uint256 var_d = var_d + 0x20;
        require(!bytes1(var_d.length));
        var_d = 0x20 + ((var_d.length + (0x20 + (0x20 + (0x20 + (0x20 + (0x24 + var_d)))))) - (bytes1(var_d.length)));
        require(!bytes1(var_d.length));
        (bool success, bytes memory ret0) = address(arg0).transfer(0);
        return 0x01;
    }
    
    /// @custom:selector    0xbb35783b
    /// @custom:signature   move(address arg0, address arg1, uint256 arg2) public
    /// @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 {
        require(address(arg0));
        require(address(arg1));
        address var_a = address(arg0);
        require(!arg2 > storage_map_a[var_a]);
        var_a = address(arg0);
        storage_map_a[var_a] = storage_map_a[var_a] - arg2;
        var_a = address(arg1);
        require(!(arg2 + storage_map_a[var_a]) < storage_map_a[var_a]);
        var_a = address(arg1);
        storage_map_a[var_a] = arg2 + storage_map_a[var_a];
        emit Transfer(address(arg0), address(arg1), arg2);
        require(msg.sender == (address(arg0)));
        var_a = address(msg.sender);
        require(storage_map_a[var_a] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        var_a = msg.sender;
        require(!storage_map_a[var_a]);
        var_a = msg.sender;
        require(!block.timestamp > storage_map_a[var_a]);
        require(!(address(arg1)) == (address(bridgeContract)));
        uint256 var_d = var_d + 0x20;
        require(!bytes1(var_d.length));
        var_d = 0x20 + ((var_d.length + (0x20 + (0x20 + (0x20 + (0x20 + (0x24 + var_d)))))) - (bytes1(var_d.length)));
        require(!bytes1(var_d.length));
        (bool success, bytes memory ret0) = address(arg1).transfer(0);
        require(!storage_map_a[var_a]);
    }
    
    /// @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_d[var_b];
    }
    
    /// @custom:selector    0xa457c2d7
    /// @custom:signature   decreaseAllowance(address arg0, uint256 arg1) public returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function decreaseAllowance(address arg0, uint256 arg1) public returns (bool) {
        var_a = address(arg0);
        if (arg1 < storage_map_a[var_a]) {
            if (!arg1 > storage_map_a[var_a]) {
                var_a = address(arg0);
                storage_map_a[var_a] = storage_map_a[var_a] - arg1;
                var_a = address(arg0);
                var_a = var_a;
                emit Approval(msg.sender, address(arg0), storage_map_a[var_a]);
                return 0x01;
                var_a = address(arg0);
                storage_map_a[var_a] = 0;
                var_a = address(arg0);
                var_a = var_a;
                emit Approval(msg.sender, address(arg0), storage_map_a[var_a]);
                return 0x01;
            }
        }
    }
    
    /// @custom:selector    0xd505accf
    /// @custom:signature   permit(address arg0, address arg1, uint256 arg2, uint256 arg3, uint8 arg4, bytes32 arg5, bytes32 arg6) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["bool", "uint8", "bytes1", "int8"]
    /// @param              arg5 ["uint256", "bytes32", "int256"]
    /// @param              arg6 ["uint256", "bytes32", "int256"]
    function permit(address arg0, address arg1, uint256 arg2, uint256 arg3, uint8 arg4, bytes32 arg5, bytes32 arg6) public {
        require(!(arg3 < block.timestamp), "ECDSA: invalid signature 's' value");
        address var_a = address(arg0);
        storage_map_a[var_a] = storage_map_a[var_a] + 0x01;
        uint256 var_j = var_j + 0xe0;
        require(var_j.length < 0x20, "ECDSA: invalid signature 's' value");
        var_j = var_j + 0x62;
        require(var_j.length < 0x20, "ECDSA: invalid signature 's' value");
        require(0x1b == (bytes1(arg4)), "ECDSA: invalid signature 's' value");
        require(!(!0x1b == (bytes1(arg4))), "ECDSA: invalid signature 's' value");
        require(!(arg6 > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0), "ECDSA: invalid signature 's' value");
        address var_ab = ecrecover(keccak256(var_p), bytes1(arg4), arg5, arg6);
        require(var_ab);
        require(address(var_ac));
        require(address(var_ac) == (address(arg0)));
        require(!(!address(arg0)), "ERC20: approve to the zero address");
        require(!(!address(arg1)), "ERC20: approve to the zero address");
        var_a = address(arg1);
        storage_map_a[var_a] = arg2;
        emit Approval(address(arg0), address(arg1), arg2);
        require(!(arg2 == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), "ERC20: approve to the zero address");
        var_a = address(arg1);
        storage_map_a[var_a] = 0;
    }
    
    /// @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) {
        var_a = address(arg1);
        return storage_map_a[var_a];
    }
    
    /// @custom:selector    0x06fdde03
    /// @custom:signature   name() public view returns (string memory)
    function name() public view returns (string memory) {
        bytes1 var_a = 0x20 + (var_a + (0x20 * (((store_f & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0x0100 * (!bytes1(store_f)))) / 0x02) + 0x1f) / 0x20)));
        if (!(store_f & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0x0100 * (!store_f)))) / 0x02) {
            if (0x1f < (store_f & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0x0100 * (!store_f))) / 0x02)) {
                uint256 var_c = 0;
                if ((var_a + 0x20) + (store_f & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0x0100 * (!store_f))) / 0x02) > (0x20 + (var_a + 0x20))) {
                    if (!var_a.length) {
                        return abi.encodePacked(0x20, var_a.length, (~((0x0100 ** (0x20 - (bytes1(var_a.length)))) - 0x01)) & (var_g));
                        return abi.encodePacked(0x20, var_a.length);
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0xf2d5d56b
    /// @custom:signature   pull(address arg0, uint256 arg1) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function pull(address arg0, uint256 arg1) public {
        require(address(arg0));
        require(address(msg.sender));
        address var_a = address(arg0);
        require(!arg1 > storage_map_a[var_a]);
        var_a = address(arg0);
        storage_map_a[var_a] = storage_map_a[var_a] - arg1;
        var_a = address(msg.sender);
        require(!(arg1 + storage_map_a[var_a]) < storage_map_a[var_a]);
        var_a = address(msg.sender);
        storage_map_a[var_a] = arg1 + storage_map_a[var_a];
        emit Transfer(address(arg0), address(msg.sender), arg1);
        require(msg.sender == (address(arg0)));
        var_a = address(msg.sender);
        require(storage_map_a[var_a] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        var_a = msg.sender;
        require(!storage_map_a[var_a]);
        var_a = msg.sender;
        require(!block.timestamp > storage_map_a[var_a]);
        require(!(address(msg.sender)) == (address(bridgeContract)));
        uint256 var_d = var_d + 0x20;
        require(!bytes1(var_d.length));
        var_d = 0x20 + ((var_d.length + (0x20 + (0x20 + (0x20 + (0x20 + (0x24 + var_d)))))) - (bytes1(var_d.length)));
        require(!bytes1(var_d.length));
        (bool success, bytes memory ret0) = address(msg.sender).transfer(0);
        require(!storage_map_a[var_a]);
    }
    
    /// @custom:selector    0x726600ce
    /// @custom:signature   isBridge(address arg0) public view returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function isBridge(address arg0) public view returns (bool) {
        return !(!(address(arg0)) == (address(bridgeContract)));
    }
    
    /// @custom:selector    0x39509351
    /// @custom:signature   increaseAllowance(address arg0, uint256 arg1) public returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function increaseAllowance(address arg0, uint256 arg1) public returns (bool) {
        var_a = address(arg0);
        require(!((arg1 + storage_map_a[var_a]) < storage_map_a[var_a]), "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] = arg1 + storage_map_a[var_a];
        var_a = var_a;
        emit Approval(address(msg.sender), address(arg0), arg1 + storage_map_a[var_a]);
        require(!((arg1 + storage_map_a[var_a]) == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), "ERC20: approve to the zero address");
        var_a = address(arg0);
        storage_map_a[var_a] = 0;
        return 0x01;
        return 0x01;
    }
    
    /// @custom:selector    0xb753a98c
    /// @custom:signature   push(address arg0, uint256 arg1) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function push(address arg0, uint256 arg1) public {
        require(address(msg.sender));
        require(address(arg0));
        address var_a = address(msg.sender);
        require(!arg1 > storage_map_a[var_a]);
        var_a = address(msg.sender);
        storage_map_a[var_a] = storage_map_a[var_a] - arg1;
        var_a = address(arg0);
        require(!(arg1 + storage_map_a[var_a]) < storage_map_a[var_a]);
        var_a = address(arg0);
        storage_map_a[var_a] = arg1 + storage_map_a[var_a];
        emit Transfer(address(msg.sender), address(arg0), arg1);
        require(msg.sender == (address(msg.sender)));
        var_a = address(msg.sender);
        require(storage_map_a[var_a] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        var_a = msg.sender;
        require(!storage_map_a[var_a]);
        var_a = msg.sender;
        require(!block.timestamp > storage_map_a[var_a]);
        require(!(address(arg0)) == (address(bridgeContract)));
        uint256 var_d = var_d + 0x20;
        require(!bytes1(var_d.length));
        var_d = 0x20 + ((var_d.length + (0x20 + (0x20 + (0x20 + (0x20 + (0x24 + var_d)))))) - (bytes1(var_d.length)));
        require(!bytes1(var_d.length));
        (bool success, bytes memory ret0) = address(arg0).transfer(0);
        require(!storage_map_a[var_a]);
    }
    
    /// @custom:selector    0x8fcbaf0c
    /// @custom:signature   Unresolved_8fcbaf0c(address arg0, address arg1, uint256 arg2, uint256 arg3, uint256 arg4, bool arg5, uint256 arg6, uint256 arg7) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    /// @param              arg4 ["uint256", "bytes32", "int256"]
    /// @param              arg5 ["bool", "uint8", "bytes1", "int8"]
    /// @param              arg6 ["uint256", "bytes32", "int256"]
    /// @param              arg7 ["uint256", "bytes32", "int256"]
    function Unresolved_8fcbaf0c(address arg0, address arg1, uint256 arg2, uint256 arg3, uint256 arg4, bool arg5, uint256 arg6, uint256 arg7) public {
        require(!arg3, "ECDSA: invalid signature 's' value");
        require(!(block.timestamp > arg3), "ECDSA: invalid signature 's' value");
        uint256 var_h = var_h + 0xe0;
        require(var_h.length < 0x20, "ECDSA: invalid signature 's' value");
        var_h = var_h + 0x62;
        require(var_h.length < 0x20, "ECDSA: invalid signature 's' value");
        require(0x1b == (bytes1(arg5)), "ECDSA: invalid signature 's' value");
        require(!(!0x1b == (bytes1(arg5))), "ECDSA: invalid signature 's' value");
        require(!(arg7 > 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0), "ECDSA: invalid signature 's' value");
        address var_z = ecrecover(keccak256(var_n), bytes1(arg5), arg6, arg7);
        require(var_z);
        require(address(var_aa));
        require(address(var_aa) == (address(arg0)));
        address var_ab = address(arg0);
        storage_map_i[var_ab] = storage_map_i[var_ab] + 0x01;
        require(arg2 == storage_map_i[var_ab]);
        require(arg4, "ERC20: approve to the zero address");
        require(arg4, "ERC20: approve to the zero address");
        var_ab = address(arg1);
        storage_map_i[var_ab] = arg3;
        require(!(!address(arg0)), "ERC20: approve to the zero address");
        require(!(!address(arg1)), "ERC20: approve to the zero address");
        var_ab = address(arg1);
        storage_map_i[var_ab] = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
        emit Approval(address(arg0), address(arg1), 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        if (arg4) {
        }
        require(!arg3);
    }
    
    /// @custom:selector    0x23b872dd
    /// @custom:signature   transferFrom(address arg0, address arg1, uint256 arg2) public returns (bool)
    /// @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 returns (bool) {
        require(address(arg0));
        require(address(arg1));
        address var_a = address(arg0);
        require(!arg2 > storage_map_a[var_a]);
        var_a = address(arg0);
        storage_map_a[var_a] = storage_map_a[var_a] - arg2;
        var_a = address(arg1);
        require(!(arg2 + storage_map_a[var_a]) < storage_map_a[var_a]);
        var_a = address(arg1);
        storage_map_a[var_a] = arg2 + storage_map_a[var_a];
        emit Transfer(address(arg0), address(arg1), arg2);
        require(msg.sender == (address(arg0)));
        var_a = address(msg.sender);
        require(storage_map_a[var_a] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        var_a = msg.sender;
        require(!storage_map_a[var_a]);
        var_a = msg.sender;
        require(!block.timestamp > storage_map_a[var_a]);
        require(!(address(arg1)) == (address(bridgeContract)));
        return 0x01;
        uint256 var_d = var_d + 0x20;
        require(!bytes1(var_d.length));
        var_d = 0x20 + ((var_d.length + (0x20 + (0x20 + (0x20 + (0x20 + (0x24 + var_d)))))) - (bytes1(var_d.length)));
        require(!bytes1(var_d.length));
        (bool success, bytes memory ret0) = address(arg1).transfer(0);
        return 0x01;
        require(!storage_map_a[var_a]);
    }
    
    /// @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) {
        address var_a = address(arg0);
        return storage_map_a[var_a];
    }
    
    /// @custom:selector    0xf2fde38b
    /// @custom:signature   transferOwnership(address arg0) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function transferOwnership(address arg0) public {
        require(msg.sender == (address(mintingFinished)));
        require(address(arg0));
        emit OwnershipTransferred(address(mintingFinished), address(arg0));
        mintingFinished = (address(arg0)) | (uint96(mintingFinished));
    }
    
    /// @custom:selector    0x40c10f19
    /// @custom:signature   mint(address arg0, uint256 arg1) public view
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function mint(address arg0, uint256 arg1) public view {
        require(msg.sender == (address(mintingFinished)));
        require(!bytes1(mintingFinished / 0x010000000000000000000000000000000000000000));
        if (!(arg1 + totalSupply) < totalSupply) {
        }
    }
    
    /// @custom:selector    0x69ffa08a
    /// @custom:signature   claimTokens(address arg0, address arg1) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function claimTokens(address arg0, address arg1) public {
        require(msg.sender == (address(mintingFinished)));
        require(address(arg1));
        require(address(arg0));
        address var_b = address(this);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).{ value: 0 ether }Unresolved_70a08231(var_b); // call
        require(!ret0.length < 0x20);
        var_b = address(arg1);
        require(address(arg0).code.length);
        (bool success, bytes memory ret0) = address(arg0).{ value: 0 ether }Unresolved_a9059cbb(var_b); // call
        require(!ret0.length);
        require(var_e);
        (bool success, bytes memory ret0) = address(arg1).transfer(address(this).balance);
        assembly { addr := create(address(this).balance, var_d, 0x20 + ((0x21 + var_d) - var_d)) }
        require(240);
    }
    
    /// @custom:selector    0x42966c68
    /// @custom:signature   burn(uint256 arg0) public view
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function burn(uint256 arg0) public view {
        address var_a = address(msg.sender);
        require(!arg0 > storage_map_a[var_a]);
        var_a = address(msg.sender);
        if (!arg0 > storage_map_a[var_a]) {
        }
    }
    
    /// @custom:selector    0x0b26cf66
    /// @custom:signature   setBridgeContract(address arg0) public
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function setBridgeContract(address arg0) public {
        require(msg.sender == (address(mintingFinished)));
        require(address(arg0).code.length > 0);
        bridgeContract = (address(arg0)) | (uint96(bridgeContract));
    }
    
    /// @custom:selector    0xd73dd623
    /// @custom:signature   increaseApproval(address arg0, uint256 arg1) public returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function increaseApproval(address arg0, uint256 arg1) public returns (bool) {
        var_a = address(arg0);
        if (!(arg1 + storage_map_a[var_a]) < storage_map_a[var_a]) {
            var_a = address(arg0);
            storage_map_a[var_a] = arg1 + storage_map_a[var_a];
            var_a = var_a;
            emit Approval(msg.sender, address(arg0), arg1 + storage_map_a[var_a]);
            return 0x01;
        }
    }
    
    /// @custom:selector    0xc9ac7f8e
    /// @custom:signature   Unresolved_c9ac7f8e(address arg0, uint256 arg1, uint256 arg2, address arg3) public returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_c9ac7f8e(address arg0, uint256 arg1, uint256 arg2, address arg3) public returns (bool) {
        require(!address(arg0));
        require(!address(this) == (address(arg0)));
        address var_a = msg.sender;
        require(!arg1 > storage_map_a[var_a]);
        require(address(arg0));
        var_a = msg.sender;
        require(!arg1 > storage_map_a[var_a]);
        var_a = msg.sender;
        storage_map_a[var_a] = storage_map_a[var_a] - arg1;
        var_a = address(arg0);
        require(!(arg1 + storage_map_a[var_a]) < storage_map_a[var_a]);
        var_a = address(arg0);
        storage_map_a[var_a] = arg1 + storage_map_a[var_a];
        emit Transfer(msg.sender, address(arg0), arg1);
        require(0x01);
        emit Transfer(address(msg.sender), address(arg0), arg1, (0x20 + (0x20 + var_e)) - var_e, (arg2 ));
        require(!(address(arg0).code.length) > 0);
        return 0x01;
        uint256 var_e = var_e + (0x20 + (((0x1f + (arg2 )) / 0x20) * 0x20));
        require(!bytes1(var_e.length));
        var_e = 0x20 + ((var_e.length + (0x20 + (0x20 + (0x20 + (0x20 + (0x24 + var_e)))))) - (bytes1(var_e.length)));
        require(!bytes1(var_e.length));
        (bool success, bytes memory ret0) = address(arg0).transfer(0);
        return 0x01;
    }
    
    /// @custom:selector    0xff9e884d
    /// @custom:signature   expirations(address arg0, address arg1) public view returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function expirations(address arg0, address arg1) public view returns (uint256) {
        address var_b = address(arg0);
        var_b = address(arg1);
        return storage_map_d[var_b];
    }
    
    /// @custom:selector    0x715018a6
    /// @custom:signature   renounceOwnership() public view
    function renounceOwnership() public view {
        require(msg.sender == (address(mintingFinished)));
    }
}

ABI

[
  {
    "type": "function",
    "name": "PERMIT_TYPEHASH",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "PERMIT_TYPEHASH_LEGACY",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_8fcbaf0c",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "uint256"
      },
      {
        "name": "arg4",
        "type": "uint256"
      },
      {
        "name": "arg5",
        "type": "bool"
      },
      {
        "name": "arg6",
        "type": "uint256"
      },
      {
        "name": "arg7",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "Unresolved_c9ac7f8e",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "allowance",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "approve",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "balanceOf",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "bridgeContract",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "burn",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "claimTokens",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "decimals",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "decreaseAllowance",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "decreaseApproval",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "expirations",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "finishMinting",
    "inputs": [],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "fopwCDKKK",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getTokenInterfacesVersion",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "increaseAllowance",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "increaseApproval",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "isBridge",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "mint",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "mintingFinished",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "move",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "name",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "nonces",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "owner",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "permit",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "uint256"
      },
      {
        "name": "arg4",
        "type": "uint8"
      },
      {
        "name": "arg5",
        "type": "bytes32"
      },
      {
        "name": "arg6",
        "type": "bytes32"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "pull",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "push",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "renounceOwnership",
    "inputs": [],
    "outputs": [],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "setBridgeContract",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "symbol",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "string"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "totalSupply",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "transfer",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "transferFrom",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "transferOwnership",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "nonpayable"
  },
  {
    "type": "function",
    "name": "version",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "event",
    "name": "Approval",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg2",
        "type": "uint256",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "OwnershipTransferred",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "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
      },
      {
        "name": "arg3",
        "type": "bytes",
        "indexed": false
      }
    ],
    "anonymous": false
  }
]

UNKNOWN SELECTORS (2)

KNOWN CLUSTER ADDRESSES IN THIS BYTECODE (0)