0x4b32d0a88629ca98e817ccbbb0c6f485d897f681

deployer: unknown relevance score: 0 status: partially_identified bytecode: 14876 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 contractType = 35000263200677284442168254354289586231471933478394369033319683962860686278656;
    uint256 public constant contractVersion = 1;
    uint256 public constant pluginMap = 1025084213094066509426836593072480225662722517598;
    uint256 public constant DEFAULT_ADMIN_ROLE = 0;
    
    bytes32 store_b;
    address store_c;
    mapping(bytes32 => bytes32) storage_map_d;
    bytes32 store_f;
    bytes32 store_g;
    mapping(bytes32 => bytes32) storage_map_a;
    mapping(bytes32 => bytes32) storage_map_h;
    mapping(bytes32 => bytes32) storage_map_e;
    
    event CustomRoyalityDisabled(address);
    event RoleRevoked(bytes32, address, address);
    event CustomRoyalityEnabled(address, address, uint256);
    event RoleGranted(bytes32, address, address);
    event PlatformFeeInfoUpdated(address, uint256);
    
    /// @custom:selector    0x5c573f2e
    /// @custom:signature   getAllFunctionsOfPlugin(address arg0) public payable returns (bytes memory)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function getAllFunctionsOfPlugin(address arg0) public payable returns (bytes memory) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(address(arg0) - arg0);
        address var_a = address(arg0);
        var_b = 0x1a3e4131826bb378aa43abb34a33a366bc4a35b55ab18a884fa205b59285ec47;
        address var_d = address(arg0);
        (bool success, bytes memory ret0) = address(0xb38e5daa05e0e4d64419b3598ce0f5a2ff5a2a5e).Unresolved_5c573f2e(var_d); // staticcall
        require(storage_map_a[var_a] > (storage_map_a[var_a] + var_a));
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(0 < var_a);
        require(!0 < var_a);
        var_a = uint32(var_b);
        require(storage_map_a[var_a]);
        require(((storage_map_a[var_a] + var_a) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) > (storage_map_a[var_a] + var_a));
        require(0 > 0x01);
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require((storage_map_a[var_a] + var_a) > 0xffffffffffffffff);
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(((var_f + (uint248((0x20 + ((storage_map_a[var_a] + var_a) << 0x05)) + 0x1f))) > 0xffffffffffffffff) | ((var_f + (uint248((0x20 + ((storage_map_a[var_a] + var_a) << 0x05)) + 0x1f))) < var_f));
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        address var_f = var_f + (uint248((0x20 + ((storage_map_a[var_a] + var_a) << 0x05)) + 0x1f));
        require((storage_map_a[var_a] + var_a) > 0xffffffffffffffff);
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(0 < var_a);
        require(0 < storage_map_a[var_a]);
        var_a = address(arg0);
        require(!0 < storage_map_a[var_a]);
        require(0 == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff);
        return abi.encodePacked(0x20, var_f.length);
    }
    
    /// @custom:selector    0xbc197c81
    /// @custom:signature   Unresolved_bc197c81(address arg0, address arg1, uint256 arg2, uint256 arg3) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    function Unresolved_bc197c81(address arg0, address arg1, uint256 arg2, uint256 arg3) public pure {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0xa0);
        require(address(arg0) - arg0);
        require(address(arg1) - arg1);
        require(arg2 > 0xffffffffffffffff);
        require(arg2 > 0xffffffffffffffff);
        require(((var_c + (uint248((0x20 + (arg2 << 0x05)) + 0x1f))) > 0xffffffffffffffff) | ((var_c + (uint248((0x20 + (arg2 << 0x05)) + 0x1f))) < var_c));
        require((0x20 + (0x04 + arg2)) < ((0x04 + arg2) + (arg2 << 0x05) + 0x20));
        require(arg3 > 0xffffffffffffffff);
    }
    
    /// @custom:selector    0xca15c873
    /// @custom:signature   getRoleMemberCount(bytes32 arg0) public view returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function getRoleMemberCount(bytes32 arg0) public view returns (uint256) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x20);
        uint256 var_a = arg0;
        require(0 < storage_map_a[var_a]);
        var_a = 0;
        require(address(storage_map_a[var_a]));
        require(0 > 0x01);
        require(!0 > 0x01);
        var_a = 0;
        require(bytes1(storage_map_a[var_a]));
        require(0 > 0x01);
        return 0x01;
        return 0;
    }
    
    /// @custom:selector    0x248a9ca3
    /// @custom:signature   getRoleAdmin(bytes32 arg0) public view returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    function getRoleAdmin(bytes32 arg0) public view returns (uint256) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        uint256 var_a = arg0;
        return storage_map_a[var_a];
    }
    
    /// @custom:selector    0x91d14854
    /// @custom:signature   hasRole(bytes32 arg0, address arg1) public view returns (bool)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function hasRole(bytes32 arg0, address arg1) public view returns (bool) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x40);
        require(address(arg1) - arg1);
        var_a = address(arg1);
        return !(!bytes1(storage_map_a[var_a]));
    }
    
    /// @custom:selector    0xd547741f
    /// @custom:signature   Unresolved_d547741f(uint0 arg0, address arg1, uint256 arg2) public payable
    /// @param              arg0 ["uint0", "bytes0", "int0"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg18446744073709551615 ["uint256", "bytes32", "int256"]
    function Unresolved_d547741f(uint0 arg0, address arg1, uint256 arg2) public payable {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x40);
        require(address(arg1) - arg1);
        var_a = address(msg.sender);
        require(!(bytes1(storage_map_a[var_a])), "Strings: hex length insufficient");
        var_a = address(msg.data[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec + msg.data.length] >> 0x60);
        require(!(bytes1(storage_map_a[var_a])), "Strings: hex length insufficient");
        var_a = address(arg1);
        require(!(bytes1(storage_map_a[var_a])), "Strings: hex length insufficient");
        var_a = address(arg1);
        storage_map_a[var_a] = uint248(storage_map_a[var_a]);
        var_a = address(msg.sender);
        require(!(bytes1(storage_map_a[var_a])), "Strings: hex length insufficient");
        emit RoleRevoked(arg0, address(arg1), address(msg.data[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec + msg.data.length] >> 0x60));
        var_a = address(arg1);
        var_a = storage_map_a[var_a];
        storage_map_a[var_a] = uint96(storage_map_a[var_a]);
        var_a = address(arg1);
        storage_map_a[var_a] = 0;
        emit RoleRevoked(arg0, address(arg1), address(msg.sender));
        var_a = address(arg1);
        var_a = storage_map_a[var_a];
        storage_map_a[var_a] = uint96(storage_map_a[var_a]);
        var_a = address(arg1);
        storage_map_a[var_a] = 0;
        require(((var_c + 0x60) > 0xffffffffffffffff) | ((var_c + 0x60) < var_c), "Strings: hex length insufficient");
        uint256 var_c = var_c + 0x60;
        require(!var_c.length, "Strings: hex length insufficient");
        require(0x29 > 0x01, "Strings: hex length insufficient");
        require(!(!address(arg1)), "Strings: hex length insufficient");
        require(((var_c + 0x80) > 0xffffffffffffffff) | ((var_c + 0x80) < var_c), "Strings: hex length insufficient");
        var_c = var_c + 0x80;
        require(!var_c.length, "Strings: hex length insufficient");
        require(0x41 > 0x01, "Strings: hex length insufficient");
        require(arg0, "Strings: hex length insufficient");
        require(!(bytes1(arg0)) < 0x10);
        require(!0x41 < var_c.length);
        require(!0x41);
        require(!(bytes1(address(arg1))) < 0x10);
    }
    
    /// @custom:selector    0x938e3d7b
    /// @custom:signature   Unresolved_938e3d7b(uint256 arg0, uint256 arg1) public view
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg18446744073709551615 ["uint256", "bytes32", "int256"]
    function Unresolved_938e3d7b(uint256 arg0, uint256 arg1) public view {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(arg0 > 0xffffffffffffffff);
        if (arg0 > 0xffffffffffffffff) {
            require(arg0 > 0xffffffffffffffff, "Not authorized");
            uint256 var_c = var_c + (uint248((0x20 + (0x1f + (arg0))) + 0x1f));
            require(((var_c + (uint248((0x20 + (0x1f + (arg0))) + 0x1f))) > 0xffffffffffffffff) | ((var_c + (uint248((0x20 + (0x1f + (arg0))) + 0x1f))) < var_c), "Not authorized");
            var_a = address(msg.data[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec + msg.data.length] >> 0x60);
            require(!(bytes1(storage_map_a[var_a])), "Not authorized");
            require(!(bytes1(storage_map_a[var_a])), "Not authorized");
            require(!(bytes1(store_b)), "Not authorized");
            require(((store_b >> 0x01) < 0x20) == (bytes1(store_b)), "Not authorized");
            require(!(bytes1(store_b)), "Not authorized");
            require(0x01 == (bytes1(store_b)), "Not authorized");
        }
    }
    
    /// @custom:selector    0xe8a3d485
    /// @custom:signature   contractURI() public view returns (bytes memory)
    function contractURI() public view returns (bytes memory) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0);
        if (!store_b) {
            if (((store_b >> 0x01) < 0x20) == (store_b)) {
                if (!store_b) {
                    if (0x01 == (store_b)) {
                        if (0 < (store_b >> 0x01)) {
                            if (((var_d + (uint248(((0x20 + (var_d + 0)) - var_d) + 0x1f))) > 0xffffffffffffffff) | ((var_d + (uint248(((0x20 + (var_d + 0)) - var_d) + 0x1f))) < var_d)) {
                                uint248 var_d = var_d + (uint248(((0x20 + (var_d + 0)) - 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    0x2f2ff15d
    /// @custom:signature   Unresolved_2f2ff15d(uint256 arg0, address arg1, uint256 arg2) public payable returns (uint256)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg18446744073709551615 ["uint256", "bytes32", "int256"]
    function Unresolved_2f2ff15d(uint256 arg0, address arg1, uint256 arg2) public payable returns (uint256) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x40);
        require(address(arg1) - arg1);
        var_a = address(msg.sender);
        require(!(bytes1(storage_map_a[var_a])), "Can only grant to non holders");
        var_a = address(msg.data[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec + msg.data.length] >> 0x60);
        require(!(bytes1(storage_map_a[var_a])), "Can only grant to non holders");
        var_a = address(arg1);
        require(bytes1(storage_map_a[var_a]), "Can only grant to non holders");
        var_a = address(arg1);
        storage_map_a[var_a] = 0x01 | (uint248(storage_map_a[var_a]));
        var_a = address(msg.sender);
        require(!(bytes1(storage_map_a[var_a])), "Strings: hex length insufficient");
        emit RoleGranted(arg0, address(arg1), address(msg.data[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec + msg.data.length] >> 0x60));
        var_a = arg0;
        require(storage_map_a[var_a] > (storage_map_a[var_a] + 0x01), "Strings: hex length insufficient");
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        storage_map_a[var_a] = storage_map_a[var_a] + 0x01;
        var_a = storage_map_a[var_a];
        storage_map_a[var_a] = (uint96(storage_map_a[var_a])) | (address(arg1));
        var_a = address(arg1);
        storage_map_a[var_a] = storage_map_a[var_a];
        return ;
        require(((var_h + 0x60) > 0xffffffffffffffff) | ((var_h + 0x60) < var_h), "Strings: hex length insufficient");
        uint256 var_h = var_h + 0x60;
        require(!var_h.length, "Strings: hex length insufficient");
        require(0x29 > 0x01, "Strings: hex length insufficient");
        require(!(!address(msg.data[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec + msg.data.length] >> 0x60)), "Strings: hex length insufficient");
        require(((var_h + 0x80) > 0xffffffffffffffff) | ((var_h + 0x80) < var_h), "Strings: hex length insufficient");
        var_h = var_h + 0x80;
        require(!var_h.length, "Strings: hex length insufficient");
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        require(0x41 > 0x01, "Strings: hex length insufficient");
        require(storage_map_a[var_a], "Strings: hex length insufficient");
        require(!(bytes1(storage_map_a[var_a])) < 0x10);
        require(!0x41 < var_h.length);
        require(!0x41);
        require(!(bytes1(address(msg.data[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec + msg.data.length] >> 0x60))) < 0x10);
        var_a = address(msg.sender);
        require(!bytes1(storage_map_a[var_a]));
        require(((var_h + 0x60) > 0xffffffffffffffff) | ((var_h + 0x60) < var_h));
    }
    
    /// @custom:selector    0x01ffc9a7
    /// @custom:signature   Unresolved_01ffc9a7(uint32 arg0) public pure returns (bool)
    /// @param              arg0 ["uint32", "bytes4", "int32"]
    function Unresolved_01ffc9a7(uint32 arg0) public pure returns (bool) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(uint32(arg0) - arg0);
        require(!(uint32(arg0)) == 0x4e2312e000000000000000000000000000000000000000000000000000000000);
        require(!(uint32(arg0)) == 0x4e2312e000000000000000000000000000000000000000000000000000000000);
        return !(!(uint32(arg0)) == 0x4e2312e000000000000000000000000000000000000000000000000000000000);
        require(!(uint32(arg0)) == 0xf337402700000000000000000000000000000000000000000000000000000000);
        return !(!(uint32(arg0)) == 0xf337402700000000000000000000000000000000000000000000000000000000);
        return !(!(uint32(arg0)) == 0x01ffc9a700000000000000000000000000000000000000000000000000000000);
    }
    
    /// @custom:selector    0xd05e5696
    /// @custom:signature   getPlatformFeeInfo(address arg0) public view returns (bytes memory)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function getPlatformFeeInfo(address arg0) public view returns (bytes memory) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(address(arg0) - arg0);
        require(address(arg0) == 0xd22e78c22d7e77229d60cc9fc57b0e294f54488e);
        return abi.encodePacked(address(store_c), 0);
        return abi.encodePacked(address(store_c), uint16(store_c >> 0xa0));
    }
    
    /// @custom:selector    0x572b6c05
    /// @custom:signature   isTrustedForwarder(address arg0) public view returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function isTrustedForwarder(address arg0) public view returns (bool) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(address(arg0) - arg0);
        address var_a = address(arg0);
        return !(!bytes1(storage_map_a[var_a]));
    }
    
    /// @custom:selector    0xa520a38a
    /// @custom:signature   getPluginForFunction(bytes4 arg0) public payable returns (address)
    /// @param              arg0 ["uint32", "bytes4", "int32"]
    function getPluginForFunction(bytes4 arg0) public payable returns (address) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(uint32(arg0) - arg0);
        uint32 var_a = uint32(arg0);
        require(!address(storage_map_d[var_a]));
        return address(storage_map_d[var_a]);
        uint32 var_d = uint32(arg0);
        (bool success, bytes memory ret0) = address(0xb38e5daa05e0e4d64419b3598ce0f5a2ff5a2a5e).Unresolved_a520a38a(var_d); // staticcall
        return 0;
        require(0x20 > ret0.length);
        require(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e));
        uint256 var_e = var_e + 0x20;
        require(((var_e + 0x20) - var_e) < 0x20);
        require(address(var_e.length) - var_e.length);
        return address(var_e.length);
    }
    
    /// @custom:selector    0xaaae5633
    /// @custom:signature   Unresolved_aaae5633(address arg0, uint256 arg1, uint256 arg2) public pure
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["uint256", "bytes32", "int256"]
    function Unresolved_aaae5633(address arg0, uint256 arg1, uint256 arg2) public pure {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0xa0);
        require(address(arg0) - arg0);
        require(arg1 > 0xffffffffffffffff);
        require(arg1 > 0xffffffffffffffff);
        require(((var_c + (uint248((0x20 + (0x1f + (arg1))) + 0x1f))) > 0xffffffffffffffff) | ((var_c + (uint248((0x20 + (0x1f + (arg1))) + 0x1f))) < var_c));
        require(arg2 > 0xffffffffffffffff);
        require(!(arg2 + 0x23) < msg.data.length);
        require(arg2 > 0xffffffffffffffff);
    }
    
    /// @custom:selector    0xa5342fdf
    /// @custom:signature   removePlugin(bytes4 arg0) public pure
    /// @param              arg0 ["uint32", "bytes4", "int32"]
    function removePlugin(bytes4 arg0) public pure {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(uint32(arg0) - arg0);
    }
    
    /// @custom:selector    0xdc1add48
    /// @custom:signature   getCustomRoyaltyInfo(address arg0) public view returns (bool)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function getCustomRoyaltyInfo(address arg0) public view returns (bool) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(address(arg0) - arg0);
        require(((var_c + 0x60) > 0xffffffffffffffff) | ((var_c + 0x60) < var_c));
        var_a = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
        return abi.encodePacked(!(!bytes1(storage_map_a[var_a])), address(storage_map_a[var_a] >> 0x08), uint16(storage_map_a[var_a] >> 0xa8));
    }
    
    /// @custom:selector    0x150b7a02
    /// @custom:signature   Unresolved_150b7a02(address arg0, address arg1, uint256 arg2) public pure returns (uint256)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    function Unresolved_150b7a02(address arg0, address arg1, uint256 arg2) public pure returns (uint256) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x80);
        require(address(arg0) - arg0);
        require(address(arg1) - arg1);
        require(arg3 > 0xffffffffffffffff);
        require(!(arg3 + 0x23) < msg.data.length);
        require(arg3 > 0xffffffffffffffff);
        require((0x24 + (arg3 + (arg3))) > msg.data.length);
        return 0x150b7a0200000000000000000000000000000000000000000000000000000000;
    }
    
    /// @custom:selector    0x1e7ac488
    /// @custom:signature   Unresolved_1e7ac488(address arg0, uint16 arg1, uint256 arg2) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint16", "bytes2", "int16"]
    /// @param              arg18446744073709551615 ["uint256", "bytes32", "int256"]
    function Unresolved_1e7ac488(address arg0, uint16 arg1, uint256 arg2) public payable {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x40);
        require(address(arg0) - arg0);
        address var_a = address(msg.sender);
        require(!(bytes1(storage_map_a[var_a])), "Platform fee too high.");
        var_a = address(msg.data[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec + msg.data.length] >> 0x60);
        require(!(bytes1(storage_map_a[var_a])), "Platform fee too high.");
        require(arg1 > 0x2710, "Platform fee too high.");
        require(bytes1(store_c >> 0xb0), "Platform fee cannot be increased.");
        require(uint16(arg1) > (uint16(store_c >> 0xa0)), "Platform fee cannot be increased.");
        store_c = (uint248(store_c)) | 0x0100000000000000000000000000000000000000000000;
        store_c = (uint16(arg1 << 0xa0) | (uint80(store_c))) | (address(arg0));
        emit PlatformFeeInfoUpdated(address(arg0), arg1);
        store_c = (uint248(store_c)) | 0x0100000000000000000000000000000000000000000000;
        store_c = (uint16(arg1 << 0xa0) | (uint80(store_c))) | (address(arg0));
        emit PlatformFeeInfoUpdated(address(arg0), arg1);
    }
    
    /// @custom:selector    0x77d81c4f
    /// @custom:signature   Unresolved_77d81c4f(address arg0, address arg1, uint16 arg2) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg2 ["uint16", "bytes2", "int16"]
    function Unresolved_77d81c4f(address arg0, address arg1, uint16 arg2) public payable {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x60);
        require(address(arg0) - arg0);
        require(address(arg1) - arg1);
        require(arg2 > 0x2710, "Platform fee too high.");
        (bool success, bytes memory ret0) = address(arg0).owner(); // staticcall
        require(!(0 == msg.sender), "Only contract owner can update custom royalty.");
        require(((var_f + 0x60) > 0xffffffffffffffff) | ((var_f + 0x60) < var_f));
        uint256 var_f = var_f + 0x60;
        address var_g = address(arg0);
        storage_map_e[var_g] = (uint248(storage_map_e[var_g])) | (bytes1(var_f.length));
        storage_map_e[var_g] = (uint88(storage_map_e[var_g]) | (bytes1(var_f.length))) | (address(var_l << 0x08));
        storage_map_e[var_g] = (uint72(storage_map_e[var_g]) | (bytes1(var_f.length)) | (address(var_l << 0x08))) | (uint16(var_m << 0xa8));
        emit CustomRoyalityEnabled(address(arg0), address(arg1), arg2);
        require(0x20 > ret0.length);
        require(((var_f + 0x20) > 0xffffffffffffffff) | ((var_f + 0x20) < var_f));
        var_f = var_f + 0x20;
        require(((var_f + 0x20) - var_f) < 0x20);
        require(address(var_f.length) - var_f.length, "Unabled to determine contract owner.");
    }
    
    /// @custom:selector    0x1ab6b705
    /// @custom:signature   Unresolved_1ab6b705(uint256 arg0, uint256 arg1, address arg2) public pure
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_1ab6b705(uint256 arg0, uint256 arg1, address arg2) public pure {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(arg0 > 0xffffffffffffffff);
        require(((msg.data.length - arg0) + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x60);
        require(((var_a + 0x60) > 0xffffffffffffffff) | ((var_a + 0x60) < var_a));
        uint256 var_a = var_a + 0x60;
        require(uint32(arg0) - (arg0));
        require(msg.data[arg0 + 0x24] > 0xffffffffffffffff);
        require((arg0 + (msg.data[arg0 + 0x24]))  > 0xffffffffffffffff);
        require(((var_a + (uint248((0x20 + (0x1f + ((arg0 + (msg.data[arg0 + 0x24])) ))) + 0x1f))) > 0xffffffffffffffff) | ((var_a + (uint248((0x20 + (0x1f + ((arg0 + (msg.data[arg0 + 0x24])) ))) + 0x1f))) < var_a));
        var_a = var_a + (uint248((0x20 + (0x1f + ((arg0 + (msg.data[arg0 + 0x24])) ))) + 0x1f));
        require(address(msg.data[arg0 + 0x44]) - (msg.data[arg0 + 0x44]));
    }
    
    /// @custom:selector    0x36568abe
    /// @custom:signature   Unresolved_36568abe(uint0 arg0, address arg1, uint256 arg2) public payable
    /// @param              arg0 ["uint0", "bytes0", "int0"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg18446744073709551615 ["uint256", "bytes32", "int256"]
    function Unresolved_36568abe(uint0 arg0, address arg1, uint256 arg2) public payable {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x40);
        require(address(arg1) - arg1);
        address var_a = address(msg.sender);
        require(!(bytes1(storage_map_a[var_a])), "Can only renounce for self");
        require(address(msg.data[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec + msg.data.length] >> 0x60) - (address(arg1)), "Can only renounce for self");
        var_a = address(arg1);
        require(!(bytes1(storage_map_a[var_a])), "Strings: hex length insufficient");
        var_a = address(arg1);
        storage_map_a[var_a] = uint248(storage_map_a[var_a]);
        var_a = address(msg.sender);
        require(!(bytes1(storage_map_a[var_a])), "Strings: hex length insufficient");
        emit RoleRevoked(arg0, address(arg1), address(msg.data[0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffec + msg.data.length] >> 0x60));
        var_a = address(arg1);
        var_a = storage_map_a[var_a];
        storage_map_a[var_a] = uint96(storage_map_a[var_a]);
        var_a = address(arg1);
        storage_map_a[var_a] = 0;
        emit RoleRevoked(arg0, address(arg1), address(msg.sender));
        var_a = address(arg1);
        var_a = storage_map_a[var_a];
        storage_map_a[var_a] = uint96(storage_map_a[var_a]);
        var_a = address(arg1);
        storage_map_a[var_a] = 0;
        require(((var_g + 0x60) > 0xffffffffffffffff) | ((var_g + 0x60) < var_g), "Strings: hex length insufficient");
        uint256 var_g = var_g + 0x60;
        require(!var_g.length, "Strings: hex length insufficient");
        require(0x29 > 0x01, "Strings: hex length insufficient");
        require(!(!address(arg1)), "Strings: hex length insufficient");
        require(((var_g + 0x80) > 0xffffffffffffffff) | ((var_g + 0x80) < var_g), "Strings: hex length insufficient");
        var_g = var_g + 0x80;
        require(!var_g.length, "Strings: hex length insufficient");
        require(0x41 > 0x01, "Strings: hex length insufficient");
        require(arg0, "Strings: hex length insufficient");
        require(!(bytes1(arg0)) < 0x10);
        require(!0x41 < var_g.length);
        require(!0x41);
        require(!(bytes1(address(arg1))) < 0x10);
    }
    
    /// @custom:selector    0xbaf2696a
    /// @custom:signature   calculateFeeAndRoyalty(address arg0, uint256 arg1, address arg2, uint256 arg3) public payable returns (bytes memory)
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["address", "uint160", "bytes20", "int160"]
    /// @param              arg3 ["uint256", "bytes32", "int256"]
    function calculateFeeAndRoyalty(address arg0, uint256 arg1, address arg2, uint256 arg3) public payable returns (bytes memory) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x80);
        require(address(arg0) - arg0);
        require(address(arg2) - arg2);
        address var_b = address(arg2);
        (bool success, bytes memory ret0) = address(this).Unresolved_d05e5696(var_b); // staticcall
        require(!(((arg3 * 0) / arg3) == 0) | !arg3);
        var_b = address(arg0);
        (bool success, bytes memory ret0) = address(this).Unresolved_dc1add48(var_b); // staticcall
        require(!0, "Custom royalty fee exceeds the price.");
        require(0, "Custom royalty fee exceeds the price.");
        require(0, "Custom royalty fee exceeds the price.");
        require(!((((arg3 * 0) / arg3) == 0) | !arg3), "Custom royalty fee exceeds the price.");
        require(((arg3 * 0) / 0x2710) > (((arg3 * 0) / 0x2710) + ((arg3 * 0) / 0x2710)), "Custom royalty fee exceeds the price.");
        require(!(!(((arg3 * 0) / 0x2710) + ((arg3 * 0) / 0x2710)) > arg3), "Custom royalty fee exceeds the price.");
        return abi.encodePacked((arg3 * 0) / 0x2710, 0, (arg3 * 0) / 0x2710, 0);
        return abi.encodePacked((arg3 * 0) / 0x2710, 0, 0, 0);
        var_b = arg1;
        uint256 var_e = arg3;
        (bool success, bytes memory ret0) = address(arg0).royaltyInfo(var_b, var_e); // staticcall
        return abi.encodePacked((arg3 * 0) / 0x2710, 0, 0, 0);
        require(0);
        require(0);
        return abi.encodePacked((arg3 * 0) / 0x2710, 0, 0, 0);
        require(0x40 > ret0.length);
        require(((var_k + 0x40) > 0xffffffffffffffff) | ((var_k + 0x40) < var_k));
        uint256 var_k = var_k + 0x40;
        require(((var_k + 0x40) - var_k) < 0x40);
        require(address(var_k.length) - var_k.length);
        return abi.encodePacked((arg3 * 0) / 0x2710, 0, 0, 0);
        if (0x60 > ret0.length) {
        }
        if (0x40 > ret0.length) {
        }
    }
    
    /// @custom:selector    0x6b86400e
    /// @custom:signature   getAllPlugins() public payable returns (bytes memory)
    function getAllPlugins() public payable returns (bytes memory) {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0);
        (bool success, bytes memory ret0) = address(0xb38e5daa05e0e4d64419b3598ce0f5a2ff5a2a5e).getAllPlugins(); // staticcall
        if (store_f > (store_f + var_b)) {
            var_b = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
            if (0 < store_f) {
                if (0 < var_b) {
                    if (!0 < store_f) {
                        var_b = 0x1a3e4131826bb378aa43abb34a33a366bc4a35b55ab18a884fa205b59285ec45;
                        if (!0 < var_b) {
                            var_b = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
                            if (uint32(store_g) == (uint32(var_d.length))) {
                                if (((store_f + var_b) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) > (store_f + var_b)) {
                                    if (0 > 0x01) {
                                        var_b = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
                                        if ((store_f + var_b) > 0xffffffffffffffff) {
                                            var_b = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
                                            if (((var_e + (uint248((0x20 + ((store_f + var_b) << 0x05)) + 0x1f))) > 0xffffffffffffffff) | ((var_e + (uint248((0x20 + ((store_f + var_b) << 0x05)) + 0x1f))) < var_e)) {
                                                var_b = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
                                                uint248 var_e = var_e + (uint248((0x20 + ((store_f + var_b) << 0x05)) + 0x1f));
                                                if ((store_f + var_b) > 0xffffffffffffffff) {
                                                    var_b = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
                                                    if (0 < ((0x20 + ((store_f + var_b) << 0x05)) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) {
                                                        if (((var_e + 0x60) > 0xffffffffffffffff) | ((var_e + 0x60) < var_e)) {
                                                            var_b = 0x4e487b7100000000000000000000000000000000000000000000000000000000;
                                                            if (0 < var_b) {
                                                                if (0 < store_f) {
                                                                    if (!0 < store_f) {
                                                                        if (0 < (var_l)) {
                                                                            if (0x20 < (var_l)) {
                                                                            }
                                                                            return abi.encodePacked(0x20, var_e.length);
                                                                        }
                                                                    }
                                                                }
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
            }
        }
    }
    
    /// @custom:selector    0xbf4e168c
    /// @custom:signature   disableCustomRoyality(address arg0) public payable
    /// @param              arg0 ["address", "uint160", "bytes20", "int160"]
    function disableCustomRoyality(address arg0) public payable {
        require(msg.value);
        require((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x20);
        require(address(arg0) - arg0);
        (bool success, bytes memory ret0) = address(arg0).owner(); // staticcall
        require(!(msg.sender == 0), "Only asset contract owner can update custom royalty.");
        (bool success, bytes memory ret0) = address(arg0).owner(); // staticcall
        require(!(0 == msg.sender), "Only contract owner can update custom royalty.");
        address var_f = address(arg0);
        storage_map_h[var_f] = uint248(storage_map_h[var_f]);
        emit CustomRoyalityDisabled(address(arg0));
        require(ret0.length < 0x20);
        require(((var_h + 0x20) > 0xffffffffffffffff) | ((var_h + 0x20) < var_h));
        uint256 var_h = var_h + 0x20;
        require(((var_h + 0x20) - var_h) < 0x20);
        require(address(var_h.length) - var_h.length, "Unabled to determine contract owner.");
        require(0x20 > ret0.length);
        require(((var_h + 0x20) > 0xffffffffffffffff) | ((var_h + 0x20) < var_h));
        var_h = var_h + 0x20;
        require(((var_h + 0x20) - var_h) < 0x20);
        require(address(var_h.length) - var_h.length);
    }
    
    /// @custom:selector    0xa32fa5b3
    /// @custom:signature   hasRoleWithSwitch(bytes32 arg0, address arg1) public view returns (bool)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["address", "uint160", "bytes20", "int160"]
    function hasRoleWithSwitch(bytes32 arg0, address arg1) public view returns (bool) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x40);
        require(address(arg1) - arg1);
        var_a = 0;
        require(!bytes1(storage_map_a[var_a]));
        return 0x01;
        var_a = address(arg1);
        return !(!bytes1(storage_map_a[var_a]));
    }
    
    /// @custom:selector    0x4cb5d8fd
    /// @custom:signature   Unresolved_4cb5d8fd(uint256 arg0, uint256 arg1, address arg2) public pure
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    /// @param              arg2 ["address", "uint160", "bytes20", "int160"]
    function Unresolved_4cb5d8fd(uint256 arg0, uint256 arg1, address arg2) public pure {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(arg0 > 0xffffffffffffffff);
        require(((msg.data.length - arg0) + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0x60);
        require(((var_a + 0x60) > 0xffffffffffffffff) | ((var_a + 0x60) < var_a));
        uint256 var_a = var_a + 0x60;
        require(uint32(arg0) - (arg0));
        require(msg.data[arg0 + 0x24] > 0xffffffffffffffff);
        require((arg0 + (msg.data[arg0 + 0x24]))  > 0xffffffffffffffff);
        require(((var_a + (uint248((0x20 + (0x1f + ((arg0 + (msg.data[arg0 + 0x24])) ))) + 0x1f))) > 0xffffffffffffffff) | ((var_a + (uint248((0x20 + (0x1f + ((arg0 + (msg.data[arg0 + 0x24])) ))) + 0x1f))) < var_a));
        var_a = var_a + (uint248((0x20 + (0x1f + ((arg0 + (msg.data[arg0 + 0x24])) ))) + 0x1f));
        require(address(msg.data[arg0 + 0x44]) - (msg.data[arg0 + 0x44]));
    }
    
    /// @custom:selector    0x9010d07c
    /// @custom:signature   getRoleMember(bytes32 arg0, uint256 arg1) public view returns (address)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function getRoleMember(bytes32 arg0, uint256 arg1) public view returns (address) {
        require(msg.value);
        if ((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x40) {
            uint256 var_a = arg0;
            if (0 < storage_map_a[var_a]) {
                var_a = 0;
                require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x40);
                require(0 < storage_map_a[var_a]);
                require(!address(storage_map_a[var_a]));
                var_a = 0;
                return address(storage_map_a[var_a]);
                var_a = 0;
                require(0 == arg1);
                var_a = 0;
                require(0 > 0x01);
                require(0 == storage_map_a[var_a]);
                require(0 > 0x01);
            }
        }
        return 0;
    }
    
    /// @custom:selector    0xac9650d8
    /// @custom:signature   Unresolved_ac9650d8(uint256 arg0, uint256 arg1) public payable returns (bytes memory)
    /// @param              arg0 ["uint256", "bytes32", "int256"]
    /// @param              arg1 ["uint256", "bytes32", "int256"]
    function Unresolved_ac9650d8(uint256 arg0, uint256 arg1) public payable returns (bytes memory) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(arg0 > 0xffffffffffffffff);
        require(!(arg0 + 0x23) < msg.data.length);
        require(arg0 > 0xffffffffffffffff);
        require(((arg0 + (arg0 << 0x05)) + 0x24) > msg.data.length);
        require(arg0 > 0xffffffffffffffff);
        require(((var_c + (uint248((0x20 + (arg0 << 0x05)) + 0x1f))) > 0xffffffffffffffff) | ((var_c + (uint248((0x20 + (arg0 << 0x05)) + 0x1f))) < var_c));
        uint256 var_c = var_c + (uint248((0x20 + (arg0 << 0x05)) + 0x1f));
        require(arg0 > 0xffffffffffffffff);
        require(0 < ((0x20 + (arg0 << 0x05)) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
        require(0 < (arg0));
        require(!(msg.data[(arg0 + 0x24) + 0]) < ((msg.data.length - (arg0 + 0x24)) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1));
        require(msg.data[(arg0 + 0x24) + (msg.data[(arg0 + 0x24) + 0])] > 0xffffffffffffffff);
        require((0x20 + ((arg0 + 0x24) + (msg.data[(arg0 + 0x24) + 0]))) > (msg.data.length - (msg.data[(arg0 + 0x24) + (msg.data[(arg0 + 0x24) + 0])])), "Address: delegate call to non-contract");
        require(msg.data[(arg0 + 0x24) + (msg.data[(arg0 + 0x24) + 0])] > 0xffffffffffffffff, "Address: delegate call to non-contract");
        require(((var_c + (uint248((0x20 + (0x1f + (msg.data[(arg0 + 0x24) + (msg.data[(arg0 + 0x24) + 0])]))) + 0x1f))) > 0xffffffffffffffff) | ((var_c + (uint248((0x20 + (0x1f + (msg.data[(arg0 + 0x24) + (msg.data[(arg0 + 0x24) + 0])]))) + 0x1f))) < var_c), "Address: delegate call to non-contract");
        var_c = var_c + (uint248((0x20 + (0x1f + (msg.data[(arg0 + 0x24) + (msg.data[(arg0 + 0x24) + 0])]))) + 0x1f));
        require((0x20 + ((arg0 + 0x24) + (msg.data[(arg0 + 0x24) + 0]))) + (msg.data[(arg0 + 0x24) + (msg.data[(arg0 + 0x24) + 0])]) > msg.data.length, "Address: delegate call to non-contract");
        require(((var_c + 0x60) > 0xffffffffffffffff) | ((var_c + 0x60) < var_c), "Address: delegate call to non-contract");
        var_c = var_c + 0x60;
        require(!address(this).code.length, "Address: delegate call to non-contract");
        (bool success, bytes memory ret0) = address(this).Unresolved_(var_o); // delegatecall
        require(!ret0.length);
        require(!var_p);
        if (0 < (var_r)) {
        }
        return abi.encodePacked(0x20, var_c.length);
    }
    
    /// @custom:selector    0xc511f8fb
    /// @custom:signature   _getPluginForFunction(bytes4 arg0) public view returns (address)
    /// @param              arg0 ["uint32", "bytes4", "int32"]
    function _getPluginForFunction(bytes4 arg0) public view returns (address) {
        require(msg.value);
        require((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20);
        require(uint32(arg0) - arg0);
        uint32 var_a = uint32(arg0);
        return address(storage_map_d[var_a]);
    }
}

ABI

[
  {
    "type": "function",
    "name": "DEFAULT_ADMIN_ROLE",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_01ffc9a7",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint32"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_150b7a02",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_1ab6b705",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_1e7ac488",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint16"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_2f2ff15d",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "address"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_36568abe",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint0"
      },
      {
        "name": "arg1",
        "type": "address"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_4cb5d8fd",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_77d81c4f",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      },
      {
        "name": "arg2",
        "type": "uint16"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_938e3d7b",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "Unresolved_aaae5633",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_ac9650d8",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint256"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "Unresolved_bc197c81",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "address"
      },
      {
        "name": "arg2",
        "type": "uint256"
      },
      {
        "name": "arg3",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "Unresolved_d547741f",
    "inputs": [
      {
        "name": "arg0",
        "type": "uint0"
      },
      {
        "name": "arg1",
        "type": "address"
      },
      {
        "name": "arg2",
        "type": "uint256"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "_getPluginForFunction",
    "inputs": [
      {
        "name": "arg0",
        "type": "bytes4"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "calculateFeeAndRoyalty",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      },
      {
        "name": "arg1",
        "type": "uint256"
      },
      {
        "name": "arg2",
        "type": "address"
      },
      {
        "name": "arg3",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "contractType",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "contractURI",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "contractVersion",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "disableCustomRoyality",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "getAllFunctionsOfPlugin",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "getAllPlugins",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "getCustomRoyaltyInfo",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getPlatformFeeInfo",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bytes"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getPluginForFunction",
    "inputs": [
      {
        "name": "arg0",
        "type": "bytes4"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "payable"
  },
  {
    "type": "function",
    "name": "getRoleAdmin",
    "inputs": [
      {
        "name": "arg0",
        "type": "bytes32"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getRoleMember",
    "inputs": [
      {
        "name": "arg0",
        "type": "bytes32"
      },
      {
        "name": "arg1",
        "type": "uint256"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "address"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "getRoleMemberCount",
    "inputs": [
      {
        "name": "arg0",
        "type": "bytes32"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "hasRole",
    "inputs": [
      {
        "name": "arg0",
        "type": "bytes32"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "hasRoleWithSwitch",
    "inputs": [
      {
        "name": "arg0",
        "type": "bytes32"
      },
      {
        "name": "arg1",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "isTrustedForwarder",
    "inputs": [
      {
        "name": "arg0",
        "type": "address"
      }
    ],
    "outputs": [
      {
        "name": "",
        "type": "bool"
      }
    ],
    "stateMutability": "view"
  },
  {
    "type": "function",
    "name": "pluginMap",
    "inputs": [],
    "outputs": [
      {
        "name": "",
        "type": "uint256"
      }
    ],
    "stateMutability": "pure"
  },
  {
    "type": "function",
    "name": "removePlugin",
    "inputs": [
      {
        "name": "arg0",
        "type": "bytes4"
      }
    ],
    "outputs": [],
    "stateMutability": "pure"
  },
  {
    "type": "event",
    "name": "CustomRoyalityDisabled",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "CustomRoyalityEnabled",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg2",
        "type": "uint256",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "PlatformFeeInfoUpdated",
    "inputs": [
      {
        "name": "arg0",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "uint256",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "RoleGranted",
    "inputs": [
      {
        "name": "arg0",
        "type": "bytes32",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg2",
        "type": "address",
        "indexed": false
      }
    ],
    "anonymous": false
  },
  {
    "type": "event",
    "name": "RoleRevoked",
    "inputs": [
      {
        "name": "arg0",
        "type": "bytes32",
        "indexed": false
      },
      {
        "name": "arg1",
        "type": "address",
        "indexed": false
      },
      {
        "name": "arg2",
        "type": "address",
        "indexed": false
      }
    ],
    "anonymous": false
  }
]

UNKNOWN SELECTORS (6)

0x77d81c4funknown
0x0a85bd01unknown
0x529051c5unknown
0xbf4e168cunknown
0xbaf2696aunknown
0x3732b917unknown
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)