0x4d118b4bfc697aee7762e2e7f2be4ffbd14732ba

//decompiled by exvvul decompiler tool contact@exvul.com https://x.com/exvulsec
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;

contract DesolexContract {
    uint256 public constant GOVERNANCE_ROLE = 51344670724517732003549907689393193919197804398902247150944709319656146718385;
    uint256 public constant totalLiability = 0;
    uint256 public constant hasOpenPositions = 0;
    uint256 public constant DEFAULT_ADMIN_ROLE = 0;
    uint256 public constant protocolRegistry = 1447451786632729987978363687652043719134903805331;
    uint256 public constant moduleKey = 97766633952224135370598129365303251181784756373664917277965587451721885316337;
    uint256 public constant interfaceVersion = 1;
    
    mapping(bytes32 => mapping(address => bool)) public hasRole; // STORAGE[0x0]
    mapping(bytes32 => uint256) public getRoleMemberCount; // STORAGE[0x1]
    mapping(address => uint256) public isExempt; // STORAGE[0x2] // DESOLEX_STORAGE_CONFLICT_RESOLVED: mapping value 0: bool [ResolvedAbi] vs uint256 [VerifiedAbi] (selected uint256)
    address[] public memberAt; // STORAGE[0x3]
    uint256 public memberCount; // STORAGE[0x3]
    mapping(address => uint256) mapping_4; // STORAGE[0x4]
    mapping(address => bool) mapping_316a51056d8b2401ab04c48d9973add294eadde229c785c6d19cde93785467ef; // STORAGE[0x316a51056d8b2401ab04c48d9973add294eadde229c785c6d19cde93785467ef]
    mapping(address => uint256) mapping_expr_al;
    mapping(address => uint256) mapping_expr_av;
    mapping(address => uint256) mapping_expr_d;
    bytes32 stor_expr_a;
    bytes32 stor_expr_ab;
    bytes32 stor_expr_af;
    bytes32 stor_expr_ai;
    bytes32 stor_expr_ao;
    uint256 stor_expr_ap;
    bytes32 stor_expr_aq;
    uint256 stor_expr_as;
    uint256 stor_expr_au;
    address stor_expr_aw;
    uint256 stor_expr_e;
    uint256 stor_expr_f;
    uint256 stor_expr_g;
    bytes32 stor_expr_i;
    bytes32 stor_expr_j;
    bytes32 stor_expr_k;
    uint256 stor_expr_m;
    bytes32 stor_expr_n;
    bytes32 stor_expr_y;
    uint256 stor_expr_z;
    
    error AccessControlBadConfirmation();
    event RoleRevoked(bytes32 indexed, address indexed, address indexed);
    event RoleGranted(bytes32 indexed, address indexed, address indexed);
    event Event_a257d589();
    error ZeroAddress();
    error AccessControlUnauthorizedAccount(address, bytes32);
    function _desolexPanic(uint256 code) private pure {
        assembly ("memory-safe") {
            mstore(0x00, shl(224, 0x4e487b71))
            mstore(0x04, code)
            revert(0x00, 0x24)
        }
    }
    fallback() external {
        // Synthetic compatibility routes preserve original selectors for unresolved names.
        if ((msg.data.length >= 4) && (msg.sig == 0x9010d07c)) {
            // Route to Unknown_9010d07c(uint256,uint256) after replacing only msg.sig.
            __desolexSelectorShim(uint32(0xb656a175));
            return;
        }
        if ((msg.data.length >= 4) && (msg.sig == 0xa3246ad3)) {
            // Route to Unknown_a3246ad3(uint256) after replacing only msg.sig.
            __desolexSelectorShim(uint32(0x1cf458ec));
            return;
        }
        revert();
    }
    
    
    function revokeRole(bytes32 role, address account) public {
        require(bytes1(hasRole[stor_expr_a][msg.sender]), AccessControlUnauthorizedAccount());
        uint256 value0 = 0;
        if (bytes1(hasRole[role][account])) {
            hasRole[role][account] = false;
            emit RoleRevoked(role, account, msg.sender);
            value0 = 0x01;
        }
        if (value0 != 0x0) {
            uint256 value4 = 0;
            if (!(0 == (!(!(mapping_expr_d[account]))))) {
                uint256 value1 = 0;
                uint256 value2 = 0;
                uint256 value3 = 0;
                if ((mapping_expr_d[account] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) != (stor_expr_e + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) {
                    if (!(((stor_expr_e + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < stor_expr_f))) _desolexPanic(50);
                    if (!(((mapping_expr_d[account] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < stor_expr_g))) _desolexPanic(50);
                    stor_expr_j = (0 & stor_expr_k) | ((stor_expr_i >> 0) << 0);
                    mapping_expr_d[stor_expr_i >> 0] = mapping_expr_d[account];
                } else {
                    value1 = mapping_expr_d[account] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
                    value2 = stor_expr_e + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
                    value3 = mapping_expr_d[account];
                }
                if (!(stor_expr_e != 0x0)) _desolexPanic(49);
                if (!(((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + stor_expr_e) < stor_expr_m))) _desolexPanic(50);
                stor_expr_n = (0) & stor_expr_n;
                stor_expr_e = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + stor_expr_e;
                mapping_expr_d[account] = 0;
                value4 = 0x01;
            }
        }
    }
    
    function members() public view returns (bytes memory) {
        uint256 value0 = 0;
        uint256 value1 = 0xc2575a0e9e593c00f959f8c92f12db2869c3395a3b0502d05e2516446f71f85b;
        uint256 var_a;
        uint256 value2 = var_a + 0x20;
        while (true) {
            if (value0 >= memberCount) {
                break;
            }
            value0 = 0x01 + value0;
            value1 = 0x01 + value1;
            value2 = value2 + 0x20;
        }
        if (((var_a + (((value2 - var_a) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + (((value2 - var_a) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65);
        uint256 value3 = 0;
        uint256 value4 = var_a + 0x20;
        uint256 value5 = var_a + 0x40;
        while (true) {
            var_a = var_a + (((value2 - var_a) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
            if (value3 >= var_a.length) {
                break;
            }
            value3 = 0x01 + value3;
            value4 = value4 + 0x20;
            value5 = 0x20 + value5;
        }
        return abi.encodePacked(0x20, var_a.length);
    }
    
    function Unknown_a3246ad3(uint256 arg0) public view returns (bytes memory) {
        uint256 value0 = 0;
        uint256 value1 = keccak256(abi.encode(keccak256(abi.encode(arg0, 0x01))));
        uint256 var_a;
        uint256 value2 = var_a + 0x20;
        while (true) {
            if (value0 >= getRoleMemberCount[arg0]) {
                break;
            }
            value0 = 0x01 + value0;
            value1 = 0x01 + value1;
            value2 = value2 + 0x20;
        }
        if (((var_a + (((value2 - var_a) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + (((value2 - var_a) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65);
        uint256 value3 = 0;
        uint256 value4 = var_a + 0x20;
        uint256 value5 = var_a + 0x40;
        while (true) {
            var_a = var_a + (((value2 - var_a) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
            if (value3 >= var_a.length) {
                break;
            }
            value3 = 0x01 + value3;
            value4 = value4 + 0x20;
            value5 = 0x20 + value5;
        }
        return abi.encodePacked(0x20, var_a.length);
    }
    
    function setExempt(address account, bool enabled) public {
        require(mapping_316a51056d8b2401ab04c48d9973add294eadde229c785c6d19cde93785467ef[msg.sender], AccessControlUnauthorizedAccount());
        internal_875(account, enabled);
    }
    
    function Unknown_9010d07c(uint256 arg0, uint256 arg1) public view returns (address) {
        if (!(arg1 < getRoleMemberCount[arg0])) _desolexPanic(50);
        return address(stor_expr_af >> 0);
    }
    
    function setExemptBatch(address[] memory accounts, bool enabled) public {
        require((accounts + 0x23) < msg.data.length);
        require(!(((accounts + (accounts.length << 0x05)) + 0x24) > msg.data.length));
        require(mapping_316a51056d8b2401ab04c48d9973add294eadde229c785c6d19cde93785467ef[msg.sender], AccessControlUnauthorizedAccount());
        uint256 value0 = 0;
        while (true) {
            if (!(value0 < accounts.length)) {
                break;
            }
            if (msg.data[0x24 + (accounts + (value0 << 0x05))] != (address(msg.data[0x24 + (accounts + (value0 << 0x05))]))) {
                revert();
                break;
            }
            if (!(address(msg.data[0x24 + (accounts + (value0 << 0x05))]))) {
                revert ZeroAddress();
                break;
            }
            if (!(!(bytes1(isExempt[address(msg.data[0x24 + (accounts + (value0 << 0x05))])]))) != enabled) {
                isExempt[address(msg.data[0x24 + (accounts + (value0 << 0x05))])] = (bytes1(enabled)) | (isExempt[address(msg.data[0x24 + (accounts + (value0 << 0x05))])] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00));
                if (!enabled) {
                    if ((mapping_4[address(msg.data[0x24 + (accounts + (value0 << 0x05))])] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) > mapping_4[address(msg.data[0x24 + (accounts + (value0 << 0x05))])]) {
                        _desolexPanic(17);
                        break;
                    }
                    if ((memberCount + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) > memberCount) {
                        _desolexPanic(17);
                        break;
                    }
                    uint256 value1 = 0;
                    uint256 value2 = 0;
                    uint256 value3 = 0;
                    if ((mapping_4[address(msg.data[0x24 + (accounts + (value0 << 0x05))])] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) != (memberCount + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) {
                        if (!((memberCount + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < memberCount)) _desolexPanic(50);
                        if (!((mapping_4[address(msg.data[0x24 + (accounts + (value0 << 0x05))])] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < memberCount)) _desolexPanic(50);
                        stor_expr_ai = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_ai) | (0xffffffffffffffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffffffffffffffff & (stor_expr_y >> 0)) << 0);
                        mapping_4[address(stor_expr_y >> 0)] = mapping_4[address(msg.data[0x24 + (accounts + (value0 << 0x05))])];
                    } else {
                        value1 = memberCount + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
                        value2 = mapping_4[address(msg.data[0x24 + (accounts + (value0 << 0x05))])] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
                        value3 = mapping_4[address(msg.data[0x24 + (accounts + (value0 << 0x05))])];
                    }
                    if (memberCount == 0) {
                        _desolexPanic(49);
                        break;
                    }
                    if (!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + memberCount) < memberCount)) _desolexPanic(50);
                    stor_expr_ab = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000) & stor_expr_ab;
                    memberCount = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + memberCount;
                    mapping_4[address(msg.data[0x24 + (accounts + (value0 << 0x05))])] = 0;
                } else {
                    if (!(memberCount < 0x010000000000000000)) {
                        _desolexPanic(65);
                        break;
                    }
                    memberCount = memberCount + 0x01;
                    if (!(memberCount < memberCount)) _desolexPanic(50);
                    memberAt[memberCount] = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & memberAt[memberCount]) | (0xffffffffffffffffffffffffffffffffffffffff & (msg.data[0x24 + (accounts + (value0 << 0x05))]) << 0);
                    mapping_4[address(msg.data[0x24 + (accounts + (value0 << 0x05))])] = memberCount;
                }
                emit Event_a257d589(address(msg.data[0x24 + (accounts + (value0 << 0x05))]), enabled, block.timestamp);
            }
            value0 = value0 + 0x01;
        }
    }
    
    function renounceRole(bytes32 role, address account) public {
        require(account == msg.sender, AccessControlBadConfirmation());
        internal_83b(role, account);
    }
    
    function grantRole(bytes32 role, address account) public {
        require(bytes1(hasRole[stor_expr_a][msg.sender]), AccessControlUnauthorizedAccount());
        if (!(bytes1(hasRole[role][account]) != 0x0)) {
            hasRole[role][account] = true;
            emit RoleGranted(role, account, msg.sender);
        }
        if (!(0 == (!(mapping_expr_av[account])))) {
            if (!(stor_expr_au < 0x010000000000000000)) _desolexPanic(65);
            stor_expr_au = stor_expr_au + 0x01;
            if (!(stor_expr_au < stor_expr_au)) _desolexPanic(50);
            stor_expr_aw = (0 & stor_expr_aw) | (account << 0);
            mapping_expr_av[account] = stor_expr_au;
        }
    }
    
    function getRoleAdmin(bytes32 role) public view returns (uint256) {
        return stor_expr_a;
    }
    
    function supportsInterface(bytes4 interfaceId) public pure returns (bool) {
        require(interfaceId == (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000));
        uint256 value1 = msg.data[0] >> 0xe0;
        bool flag1;
        if ((interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000) != 0x5a05180f00000000000000000000000000000000000000000000000000000000) {
            uint256 value0 = msg.data[0] >> 0xe0;
            bool flag0 = 0x1ffc9a700000000000000000000000000000000000000000000000000000000 == (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000);
            if (interfaceId & (0xffffffff00000000000000000000000000000000000000000000000000000000) == 0x7965db0b00000000000000000000000000000000000000000000000000000000) {
                value0 = interfaceId & (0xffffffff00000000000000000000000000000000000000000000000000000000);
                flag0 = (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000) == 0x7965db0b00000000000000000000000000000000000000000000000000000000;
            }
            flag1 = flag0;
        } else {
            value1 = interfaceId & (0xffffffff00000000000000000000000000000000000000000000000000000000);
            flag1 = (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000) == 0x5a05180f00000000000000000000000000000000000000000000000000000000;
        }
        return flag1;
    }
    
    function internal_875(uint256 arg0, bool arg1) private {
        // Decompilation incomplete: helper effect provenance is conservative.
        require(arg0 != address(0), ZeroAddress());
        if ((!(!(bytes1(isExempt[arg0])))) == arg1) {
            return;
        } else {
            isExempt[arg0] = (bytes1(arg1)) | (isExempt[arg0] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00));
            if (arg1) {
                if (!(memberCount < 0x010000000000000000)) _desolexPanic(65);
                memberCount = memberCount + 0x01;
                if (!(memberCount < memberCount)) _desolexPanic(50);
                memberAt[memberCount] = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & memberAt[memberCount]) | (arg0 << 0);
                mapping_4[arg0] = memberCount;
                emit Event_a257d589(arg0, arg1, block.timestamp);
                return;
            } else if ((mapping_4[arg0] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) == (memberCount + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) {
                if (!(memberCount != 0x0)) _desolexPanic(49);
                if (!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + memberCount) < memberCount)) _desolexPanic(50);
                stor_expr_ab = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000) & stor_expr_ab;
                memberCount = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + memberCount;
                mapping_4[arg0] = 0;
                emit Event_a257d589(arg0, arg1, block.timestamp);
                return;
            } else {
                if (!((memberCount + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < memberCount)) _desolexPanic(50);
                if (!((mapping_4[arg0] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < memberCount)) _desolexPanic(50);
                stor_expr_z = (~(0xffffffffffffffffffffffffffffffffffffffff << (0 << 0x03)) & stor_expr_z) | (address((address(stor_expr_y >> 0))) << (0 << 0x03));
                mapping_4[(address(stor_expr_y >> 0))] = mapping_4[arg0];
                if (!(memberCount != 0x0)) _desolexPanic(49);
                if (!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + memberCount) < memberCount)) _desolexPanic(50);
                stor_expr_ab = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000) & stor_expr_ab;
                memberCount = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + memberCount;
                mapping_4[arg0] = 0;
                emit Event_a257d589(arg0, arg1, block.timestamp);
            }
        }
    }
    
    function internal_83b(bytes32 arg0, address arg1) private {
        // Decompilation incomplete: helper effect provenance is conservative.
        uint256 value0 = 0;
        if (bytes1(hasRole[arg0][arg1])) {
            hasRole[arg0][arg1] = false;
            emit RoleRevoked(arg0, arg1, msg.sender);
            value0 = 0x01;
        }
        if (value0 != 0x0) {
            uint256 value4 = 0;
            if (!(0 == (!(!(mapping_expr_al[arg1]))))) {
                uint256 value1 = 0;
                uint256 value2 = 0;
                uint256 value3 = 0;
                if ((mapping_expr_al[arg1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) != (getRoleMemberCount[arg0] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) {
                    if (!(((getRoleMemberCount[arg0] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < stor_expr_f))) _desolexPanic(50);
                    if (!(((mapping_expr_al[arg1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < stor_expr_g))) _desolexPanic(50);
                    stor_expr_ap = (0 & stor_expr_aq | (stor_expr_ao >> (0 << 0x03) << 0));
                    mapping_expr_al[stor_expr_ao >> (0 << 0x03)] = mapping_expr_al[arg1];
                } else {
                    value1 = mapping_expr_al[arg1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
                    value2 = getRoleMemberCount[arg0] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
                    value3 = mapping_expr_al[arg1];
                }
                if (!(getRoleMemberCount[arg0])) _desolexPanic(49);
                if (!(((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + getRoleMemberCount[arg0]) < stor_expr_m))) _desolexPanic(50);
                stor_expr_as = (~(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff << (0 << 0x03))) & stor_expr_as;
                getRoleMemberCount[arg0] = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + getRoleMemberCount[arg0];
                mapping_expr_al[arg1] = 0;
                flag0 = true;
            }
        }
    }
    
    function __desolexSelectorShim(uint32 rewrittenSelector) private {
        assembly {
            let input := mload(0x40)
            calldatacopy(input, 0, calldatasize())
            mstore(input, or(and(mload(input), 0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff), shl(224, and(rewrittenSelector, 0xffffffff))))
            let success := delegatecall(gas(), address(), input, calldatasize(), 0, 0)
            let size := returndatasize()
            returndatacopy(input, 0, size)
            switch success
            case 0 { revert(input, size) }
            default { return(input, size) }
        }
    }
    
    // Note: This selector table is synthetic and is not part of the original Solidity source.
    // It records the recovered selector-to-signature mapping without executable behavior.
    
    // 0x01ffc9a7 => supportsInterface(bytes4)
    // 0x0fc29349 => totalLiability()
    // 0x11aee380 => memberCount()
    // 0x1d8ffa4d => interfaceVersion()
    // 0x248a9ca3 => getRoleAdmin(bytes32)
    // 0x2f2ff15d => grantRole(bytes32,address)
    // 0x36568abe => renounceRole(bytes32,address)
    // 0x37e371ee => setExemptBatch(address[],bool)
    // 0x55fd7fa0 => moduleKey()
    // 0x7656419f => protocolRegistry()
    // 0x9010d07c => Unknown_9010d07c(uint256,uint256)
    // 0x91d14854 => hasRole(bytes32,address)
    // 0x9ce6dd9f => hasOpenPositions()
    // 0x9fde54f5 => setExempt(address,bool)
    // 0xa217fddf => DEFAULT_ADMIN_ROLE()
    // 0xa3246ad3 => Unknown_a3246ad3(uint256)
    // 0xac0250f7 => memberAt(uint256)
    // 0xad5dff73 => isExempt(address)
    // 0xbdd4d18d => members()
    // 0xca15c873 => getRoleMemberCount(bytes32)
    // 0xd547741f => revokeRole(bytes32,address)
    // 0xf36c8f5c => GOVERNANCE_ROLE()
}