BNB Chain
0xd889db9d05666b91145275ba9a89fbef90b5e127
Decompiled Solidity recovered from this contract's runtime bytecode. Best-effort reconstruction — confirm behaviour against on-chain state.
Decompilation outputBNB Chain · 0xd889db9d…90b5e12720.0 KB88.6 s
This result is permanently available athttps://decompiler.exvul.com/bsc/0xd889db9d05666b91145275ba9a89fbef90b5e127
2,483 lines · Click a variable or keyword to highlight its references · Click a line number to copy its link; Shift-click to copy a block link
//decompiled by exvvul decompiler tool [email protected] https://x.com/exvulsec// Decompilation incomplete: symbolic execution reached a configured deadline for 2 of 57 entry points (170000 ms contract budget): 160cbed7, 2656227d// SPDX-License-Identifier: MITpragma solidity >=0.8.0;contract DesolexContract { uint256 public constant ADMIN_ROLE = 74447917106227587185069542233768419360415527974423666340979253117352358844277; uint256 public constant PROPOSER_ROLE = 79880299296705742699333642239210630756328524875623738728757137919097174072513; uint256 public constant quorumDenominator = 100; uint256 public constant DEFAULT_ADMIN_ROLE = 0; uint256 public constant BALLOT_TYPEHASH = 9502247353839574495332276951844984684583132597607571786073323397282563895951; address public owner; // STORAGE[0x0] mapping(bytes32 => mapping(address => bool)) public isProposer; // STORAGE[0x1] // DESOLEX_STORAGE_CONFLICT_RESOLVED: mapping key 0: address [ResolvedAbi] vs bytes32 [VerifiedAbi] (selected bytes32) string _name; // STORAGE[0x2] mapping(uint256 => uint64) public proposalSnapshot; // STORAGE[0x3] mapping(uint256 => address) mapping_4; // STORAGE[0x4] mapping(uint256 => uint256) mapping_5; // STORAGE[0x5] uint256 public quorumNumerator; // STORAGE[0x6] address public timelock; // STORAGE[0x7] mapping(uint256 => bytes32) mapping_8; // STORAGE[0x8] uint256 public votingDelay; // STORAGE[0x9] uint256 public votingPeriod; // STORAGE[0xa] uint256 public proposalThreshold; // STORAGE[0xb] address public provider; // STORAGE[0xc] mapping(address => uint256) mapping_expr_aq; mapping(bytes32 => bytes32) mapping_expr_bv; // DESOLEX_RAW_STORAGE: mapping key 0: address [ResolvedAbi] vs uint256 [ResolvedAbi] (ambiguous) mapping(address => uint256) mapping_expr_cf; uint256 stor_expr_aa; uint256 stor_expr_ad; uint256 stor_expr_ag; bytes32 stor_expr_ai; uint256 stor_expr_an; uint256 stor_expr_ao; bytes32 stor_expr_at; // DESOLEX_RAW_STORAGE: whole slot: address [LegacyInference] vs uint256 [LegacyInference] (ambiguous) bytes32 stor_expr_au; bytes32 stor_expr_av; uint256 stor_expr_aw; uint256 stor_expr_ax; uint256 stor_expr_ay; uint256 stor_expr_az; uint256 stor_expr_ba; uint256 stor_expr_bb; uint256 stor_expr_bc; uint256 stor_expr_bd; uint256 stor_expr_be; uint256 stor_expr_bf; bytes32 stor_expr_bh; uint256 stor_expr_bk; uint256 stor_expr_bn; uint256 stor_expr_bq; uint256 stor_expr_br; uint256 stor_expr_bt; uint256 stor_expr_bu; uint256 stor_expr_bx; uint256 stor_expr_by; uint256 stor_expr_bz; uint256 stor_expr_ca; uint256 stor_expr_cb; uint256 stor_expr_cc; uint256 stor_expr_cd; uint256 stor_expr_ce; address stor_expr_ch; bytes32 stor_expr_ci; bytes32 stor_expr_cj; uint256 stor_expr_ck; uint256 stor_expr_cl; uint256 stor_expr_co; uint256 stor_expr_cp; uint256 stor_expr_cq; uint256 stor_expr_cr; uint256 stor_expr_cs; uint256 stor_expr_ct; uint256 stor_expr_cu; uint256 stor_expr_cv; uint256 stor_expr_cw; uint256 stor_expr_cx; uint256 stor_expr_cy; uint64 stor_expr_d; bytes32 stor_expr_dc; uint256 stor_expr_dk; uint256 stor_expr_dn; uint256 stor_expr_dq; uint256 stor_expr_dr; uint256 stor_expr_dt; uint256 stor_expr_du; uint256 stor_expr_dw; uint256 stor_expr_dz; uint256 stor_expr_ec; uint256 stor_expr_ed; uint256 stor_expr_ef; uint256 stor_expr_eg; bytes32 stor_expr_g; bytes32 stor_expr_l; uint256 stor_expr_m; uint256 stor_expr_n; bytes32 stor_expr_t; bytes32 stor_expr_u; event RoleRevoked(bytes32 indexed, address indexed, address indexed); event VotingDelayChanged(uint256, uint256); event VoteCast(address indexed, uint256, uint8, uint256, string); event ProposalThresholdChanged(uint256, uint256); event QuorumNumeratorUpdated(uint256, uint256); event VotingPeriodChanged(uint256, uint256); event TimelockChange(address, address); event RoleGranted(bytes32 indexed, address indexed, address indexed); event OwnershipTransferred(address indexed, address indexed); function _desolexPanic(uint256 code) private pure { assembly ("memory-safe") { mstore(0x00, shl(224, 0x4e487b71)) mstore(0x04, code) revert(0x00, 0x24) } } modifier onlyOwner() { require(msg.sender == owner, "Ownable: caller is not the owner"); _; } receive() external payable { require(timelock == address(this)); } fallback() external { // Synthetic compatibility routes preserve original selectors for unresolved names. if ((msg.data.length >= 4) && (msg.sig == 0x3bccf4fd)) { // Route to Unknown_3bccf4fd(bytes32,bool,bool,uint256,uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0x9ad1d257)); return; } revert(); } function proposals(uint256 index) public returns (bool) { require(timelock.code.length != 0x0); (bool success0, bytes memory returnData0) = timelock.getTimestamp(mapping_8[index]); // staticcall require(success0); uint256 var_e; var_e = var_e + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_e + returnData0.length) - var_e >= 0x20); uint256 value1 = 0; if (!(0x01 == var_g)) { value1 = var_g; } var_e = var_e + 0xa0; var_e = 0x20 + var_e; if (bytes1(stor_expr_g)) { if (!(0x7 <= 0x7)) _desolexPanic(33); if (!(0x7 <= 0x7)) _desolexPanic(33); if (!(0x7 <= 0x7)) _desolexPanic(33); return abi.encodePacked(index, mapping_4[index], value1, uint64(proposalSnapshot[index]), uint64(stor_expr_d), stor_expr_n, stor_expr_m, stor_expr_l, !(!(0x07 == 0x02)), !(!(0x07 == 0x07))); } else if (var_p) { if (0x02 > 0x07) _desolexPanic(33); if (0x02 > 0x07) _desolexPanic(33); if (0x02 > 0x07) _desolexPanic(33); return abi.encodePacked(index, mapping_4[index], value1, uint64(proposalSnapshot[index]), uint64(stor_expr_d), stor_expr_n, stor_expr_m, stor_expr_l, !(!(0x02 == 0x02)), !(!(0x02 == 0x07))); } else { if (uint64(var_q) < block.number) { if (uint64(var_r) < block.number) { bool flag0 = !(!(uint64(var_t))); if (!(!(uint64(var_t)))) { flag0 = !(uint64(var_t) > block.number); } require(flag0, "Governor: unknown proposal id"); require(provider.code.length != 0x0); (bool success1, bytes memory returnData1) = provider.getPastTotalSupply(__desolex_internal_141f_28fa_arg0); // staticcall require(success1); var_e = var_e + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_e + returnData1.length) - var_e) < 0x20)); } else { if (0x01 > 0x07) _desolexPanic(33); if (0x01 > 0x07) _desolexPanic(33); if (0x01 > 0x07) _desolexPanic(33); return abi.encodePacked(index, mapping_4[index], value1, uint64(proposalSnapshot[index]), uint64(stor_expr_d), stor_expr_n, stor_expr_m, stor_expr_l, !(!(0x01 == 0x02)), !(!(0x01 == 0x07))); } } else { if (0 > 0x07) _desolexPanic(33); if (0 > 0x07) _desolexPanic(33); if (0 > 0x07) _desolexPanic(33); return abi.encodePacked(index, mapping_4[index], value1, uint64(proposalSnapshot[index]), uint64(stor_expr_d), stor_expr_n, stor_expr_m, stor_expr_l, !(!(0 == 0x02)), !(!(0 == 0x07))); } } } function supportsInterface(bytes4 interfaceId) public pure returns (bool) { require(interfaceId == (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000)); if (0x6e665ced00000000000000000000000000000000000000000000000000000000 == (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000)) { return !(!(0x6e665ced00000000000000000000000000000000000000000000000000000000 == (interfaceId & (0xffffffff00000000000000000000000000000000000000000000000000000000)))); } else { if (0xbf26d89700000000000000000000000000000000000000000000000000000000 == (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000)) { return !(!(0xbf26d89700000000000000000000000000000000000000000000000000000000 == (interfaceId & (0xffffffff00000000000000000000000000000000000000000000000000000000)))); } else { if (0x7965db0b00000000000000000000000000000000000000000000000000000000 == (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000)) { return !(!(0x7965db0b00000000000000000000000000000000000000000000000000000000 == (interfaceId & (0xffffffff00000000000000000000000000000000000000000000000000000000)))); } else { return !(!(interfaceId & (0xffffffff00000000000000000000000000000000000000000000000000000000) == 0x01ffc9a700000000000000000000000000000000000000000000000000000000)); } } } } function updateQuorumNumerator(uint256 arg0) public { require(msg.sender == (0xffffffffffffffffffffffffffffffffffffffff & timelock), "Governor: onlyGovernance"); require(arg0 <= 0x64, "GovernorVotesQuorumFraction: quorumNumerator over quorumDenominator"); emit QuorumNumeratorUpdated(quorumNumerator, arg0); quorumNumerator = arg0; } function name() public view returns (string memory) { return _name; } function queue(address[] memory arg0, uint256[] memory arg1, bytes[] memory arg2, bytes32 arg3) public pure { if (!(arg0.length <= 0xffffffffffffffff)) _desolexPanic(65); uint256 var_a; if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f)); address[] var_b = arg0; require(!(((0x04 + arg0) + (arg0.length << 0x05) + 0x20) > msg.data.length)); if (0 < arg0.length) { require((arg0 + 0x20) == ((arg0 + 0x20) & 0xffffffffffffffffffffffffffffffffffffffff)); address[] var_c = arg0 + 0x20; } if (!(arg1.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg1.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg1.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg1.length << 0x05)) + 0x1f)); require(!(((0x04 + arg1) + (arg1.length << 0x05) + 0x20) > msg.data.length)); if (0 < arg1.length) { uint256[] var_d = arg1[0]; } if (!(arg2.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f)); require(!(((0x04 + arg2) + (arg2.length << 0x05) + 0x20) > msg.data.length)); if (0 < arg2.length) { require(!((arg2 + 0x20) > 0xffffffffffffffff)); require(msg.data.length > ((0x04 + arg2) + (arg2 + 0x20) + 0x3f)); if (!((arg2 + (arg2 + 0x20) + 0x20) <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((arg2 + (arg2 + 0x20) + 0x20) + 0x1f))) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((arg2 + (arg2 + 0x20) + 0x20) + 0x1f))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((arg2 + (arg2 + 0x20) + 0x20) + 0x1f))) + 0x1f)); require(((0x04 + arg2) + (arg2 + 0x20) + 0x40) + (arg2 + (arg2 + 0x20) + 0x20) <= msg.data.length); } } function getRoleAdmin(bytes32 role) public view returns (uint256) { return stor_expr_t; } function quorumVotes() public returns (uint256) { require(provider.code.length != 0x0); (bool success0, bytes memory returnData0) = provider.getPastTotalSupply(block.number - 0x01); // staticcall require(success0); uint256 var_c; var_c = var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData0.length) - var_c) < 0x20)); return (var_c.length * quorumNumerator) / 0x64; } function execute(address[] memory arg0, uint256[] memory arg1, bytes[] memory arg2, bytes32 arg3) public pure { if (!(arg0.length <= 0xffffffffffffffff)) _desolexPanic(65); uint256 var_a; if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f)); address[] var_b = arg0; require(!(((0x04 + arg0) + (arg0.length << 0x05) + 0x20) > msg.data.length)); if (0 < arg0.length) { require((arg0 + 0x20) == ((arg0 + 0x20) & 0xffffffffffffffffffffffffffffffffffffffff)); address[] var_c = arg0 + 0x20; } if (!(arg1.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg1.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg1.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg1.length << 0x05)) + 0x1f)); require(!(((0x04 + arg1) + (arg1.length << 0x05) + 0x20) > msg.data.length)); if (0 < arg1.length) { uint256[] var_d = arg1[0]; } if (!(arg2.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f)); require(!(((0x04 + arg2) + (arg2.length << 0x05) + 0x20) > msg.data.length)); if (0 < arg2.length) { require(!((arg2 + 0x20) > 0xffffffffffffffff)); require(msg.data.length > ((0x04 + arg2) + (arg2 + 0x20) + 0x3f)); if (!((arg2 + (arg2 + 0x20) + 0x20) <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((arg2 + (arg2 + 0x20) + 0x20) + 0x1f))) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((arg2 + (arg2 + 0x20) + 0x20) + 0x1f))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((arg2 + (arg2 + 0x20) + 0x20) + 0x1f))) + 0x1f)); require(((0x04 + arg2) + (arg2 + 0x20) + 0x40) + (arg2 + (arg2 + 0x20) + 0x20) <= msg.data.length); } } function grantRole(bytes32 role, address account) public { internal_e36(account, role); } function getActions(uint256 arg0) public view { uint256 var_c; var_c = var_c + (0x20 + (0x20 * stor_expr_aa)); uint256 value2 = stor_expr_aa; uint256 value3 = 0x01 + (keccak256(abi.encode(arg0, 0x04))); uint256 value4 = 0x20 + var_c; if (stor_expr_aa != 0) { uint256 value0 = 0x20 + (0x20 + var_c); uint256 value1 = (keccak256(abi.encode(0x01 + (keccak256(abi.encode(arg0, 0x04)))))) + 0x01; while (true) { if ((0x20 + var_c) + (0x20 * stor_expr_aa) <= value0) { break; } value0 = 0x20 + value0; value1 = value1 + 0x01; } value2 = value0; value3 = value1; value4 = (0x20 + var_c) + (0x20 * stor_expr_aa); } var_c = var_c + (0x20 + (0x20 * stor_expr_ad)); uint256 value7 = stor_expr_ad; uint256 value8 = 0x02 + (keccak256(abi.encode(arg0, 0x04))); uint256 value9 = 0x20 + var_c; if (stor_expr_ad != 0) { uint256 value5 = 0x20 + (0x20 + var_c); uint256 value6 = 0x01 + (keccak256(abi.encode(0x02 + (keccak256(abi.encode(arg0, 0x04)))))); while (true) { if ((0x20 + var_c) + (0x20 * stor_expr_ad) <= value5) { break; } value5 = 0x20 + value5; value6 = 0x01 + value6; } value7 = value5; value8 = value6; value9 = (0x20 + var_c) + (0x20 * stor_expr_ad); } if (!(0 < stor_expr_ag)) { } else { uint256 value10 = stor_expr_ai >> 0x01; if (!(stor_expr_ai & (0x01))) { value10 = (stor_expr_ai >> 0x01) & (0x7f); } if (stor_expr_ai & (0x01) == (value10 < 0x20)) _desolexPanic(34); uint256 value11 = stor_expr_ai >> 0x01; if (!(stor_expr_ai & (0x01))) { value11 = (stor_expr_ai >> 0x01) & (0x7f); } if (stor_expr_ai & (0x01) == (value11 < 0x20)) _desolexPanic(34); } } function renounceRole(bytes32 role, address account) public { require(msg.sender == account, "AccessControl: can only renounce roles for self"); if (bytes1(isProposer[role][account])) { isProposer[role][account] = false; emit RoleRevoked(role, account, msg.sender); } } function getPastVotes(address arg0, uint256 arg1) public returns (uint256) { require(provider.code.length != 0x0); (bool success0, bytes memory returnData0) = provider.getPastVotes(arg0, arg1); // staticcall require(success0); uint256 var_d; var_d = var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_d + returnData0.length) - var_d) < 0x20)); return var_d.length; } function Unknown_3bccf4fd(bytes32 arg0, bool arg1, bool arg2, uint256 arg3, uint256 arg4) public returns (uint256) { require(arg1 == (arg1 & 0xff)); require(arg2 == (arg2 & 0xff)); internal_1ed5(arg4, arg3, arg2, arg1, arg0); return var_e.length; if (value8 > __desolex_internal_4e8f_4986_arg2) { } } function state(uint256 arg0) public returns (uint256) { uint256 var_c; var_c = var_c + 0xa0; var_c = 0x20 + var_c; uint256 value3; if (!(bytes1(stor_expr_bh))) { uint256 value5; if (!(var_j)) { uint256 value6 = 0x01; if (uint64(var_k) < block.number) { if (uint64(var_l) < block.number) { bool flag0 = !(!(uint64(var_n))); if (!(!(uint64(var_n)))) { flag0 = !(uint64(var_n) > block.number); } require(flag0, "Governor: unknown proposal id"); require(provider.code.length != 0x0); (bool success0, bytes memory returnData0) = provider.getPastTotalSupply(__desolex_internal_141f_28fa_arg0); // staticcall require(success0); var_c = var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData0.length) - var_c) < 0x20)); if ((((var_c.length * quorumNumerator) / 0x64) <= stor_expr_n) && (stor_expr_n > stor_expr_m)) { if (!(0x4 <= 0x7)) _desolexPanic(33); if (mapping_8[arg0] != 0x0) { require(timelock.code.length != 0x0); (bool success1, bytes memory returnData1) = timelock.isOperationDone(mapping_8[arg0]); // staticcall require(success1); var_c = var_c + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_c + returnData1.length) - var_c >= 0x20); require(var_u == var_u); if (var_c.length == 0) { if (!(0x5 < 0x8)) _desolexPanic(33); return 0x05; } else { if (!(0x7 < 0x8)) _desolexPanic(33); return 0x07; } } else { if (!(0x4 < 0x8)) _desolexPanic(33); return 0x04; } } else { if (!(0x3 <= 0x7)) _desolexPanic(33); if (!(0x3 < 0x8)) _desolexPanic(33); return 0x03; } } } else { value6 = 0; } value5 = value6; } else { value5 = 0x02; } value3 = value5; } else { value3 = 0x07; } if (!(value3 <= 0x7)) _desolexPanic(33); if (value3 != 0x4) { if (!(value3 < 0x8)) _desolexPanic(33); uint256 value3; } else if (mapping_8[arg0] == 0x0) { if (!(value3 < 0x8)) _desolexPanic(33); uint256 value3; } else { require(timelock.code.length != 0x0); (bool success3, bytes memory returnData3) = timelock.isOperationDone(mapping_8[arg0]); // staticcall require(success3); var_c = var_c + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData3.length) - var_c) < 0x20)); require(value4 == (value4 != 0x0)); if (var_c.length == 0) { if (!(0x5 < 0x8)) _desolexPanic(33); return 0x05; } else { if (!(0x7 < 0x8)) _desolexPanic(33); return 0x07; } } } function cancel(uint256 arg0) public { bool flag0 = (msg.sender) == mapping_4[arg0]; uint256 var_f; if (!(msg.sender == mapping_4[arg0])) { require(provider.code.length != 0x0); (bool success0, bytes memory returnData0) = provider.getPastVotes(address(mapping_4[arg0]), block.number - 0x01); // staticcall require(success0); var_f = var_f + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_f + returnData0.length) - var_f >= 0x20); flag0 = (var_f.length) < proposalThreshold; } require(flag0, "GovernorBravo: proposer above threshold"); var_f = var_f + (0x20 + (0x20 * stor_expr_bk)); uint256 value2 = stor_expr_bk; uint256 value3 = 0x01 + (keccak256(abi.encode(arg0, 0x04))); uint256 value4 = 0x20 + var_f; if (stor_expr_bk != 0) { uint256 value0 = 0x20 + (0x20 + var_f); uint256 value1 = (keccak256(abi.encode(0x01 + (keccak256(abi.encode(arg0, 0x04)))))) + 0x01; while (true) { if ((0x20 + var_f) + (0x20 * stor_expr_bk) <= value0) { break; } value0 = 0x20 + value0; value1 = value1 + 0x01; } value2 = value0; value3 = value1; value4 = (0x20 + var_f) + (0x20 * stor_expr_bk); } var_f = var_f + (0x20 + (0x20 * stor_expr_bn)); uint256 value7 = stor_expr_bn; uint256 value8 = 0x02 + (keccak256(abi.encode(arg0, 0x04))); uint256 value9 = 0x20 + var_f; if (stor_expr_bn != 0) { uint256 value5 = 0x20 + (0x20 + var_f); uint256 value6 = 0x01 + (keccak256(abi.encode(0x02 + (keccak256(abi.encode(arg0, 0x04)))))); while (true) { if ((0x20 + var_f) + (0x20 * stor_expr_bn) <= value5) { break; } value5 = 0x20 + value5; value6 = 0x01 + value6; } value7 = value5; value8 = value6; value9 = (0x20 + var_f) + (0x20 * stor_expr_bn); } uint256 value11 = 0x20 + var_f; uint256 value10 = 0; while (true) { if (!(value10 < stor_expr_bq)) { break; } uint256 value14 = stor_expr_br >> 0x01; if (!(stor_expr_br & (0x01))) { value14 = (stor_expr_br >> 0x01) & (0x7f); } if (!((stor_expr_br & 0x1) != value14 < 0x20)) _desolexPanic(34); var_f = var_f + (0x20 + (((0x1f + value14) / 0x20) * 0x20)); uint256 value15 = stor_expr_br >> 0x01; if (!(stor_expr_br & (0x01))) { value15 = (stor_expr_br >> 0x01) & (0x7f); } if (!((stor_expr_br & 0x1) != value15 < 0x20)) _desolexPanic(34); uint256 value16 = 0x20 + var_f; if (value15 != 0) { if (0x1f < value15) { } else { } value16 = 0x20 + (0x20 + var_f); } value11 = 0x20 + value11; value10 = 0x01 + value10; } var_f = 0x20 + (var_f + (stor_expr_bt * 0x20)); if (!(0 < stor_expr_bt)) { if (var_l > 0xffffffffffffffff) _desolexPanic(65); } else { uint256 value12 = stor_expr_bu >> 0x01; if (!(stor_expr_bu & (0x01))) { value12 = (stor_expr_bu >> 0x01) & (0x7f); } if (!((stor_expr_bu & 0x1) != value12 < 0x20)) _desolexPanic(34); uint256 value13 = stor_expr_bu >> 0x01; if (!(stor_expr_bu & (0x01))) { value13 = (stor_expr_bu >> 0x01) & (0x7f); } if (!((stor_expr_bu & 0x1) != value13 < 0x20)) _desolexPanic(34); } } function hasVoted(uint256 arg0, address arg1) public view returns (bool) { return !(!(bytes1(mapping_expr_bv[arg1]))); } function version() public pure returns (bytes memory) { uint256 var_a; var_a = 0x40 + var_a; uint256 value0 = 0; while (true) { if (value0 >= var_a.length) { break; } value0 = 0x20 + value0; return abi.encodePacked(0x20, var_a.length, var_g); } if (value0 > var_a.length) { } } function castVote(uint256 arg0, uint8 arg1) public returns (uint256) { require(arg1 == (arg1 & 0xff)); uint256 var_a; var_a = 0x20 + var_a; var_a = var_a + 0xa0; var_a = 0x20 + var_a; uint256 value36; if (!(bytes1(stor_expr_g))) { uint256 value42; if (!(var_k)) { uint256 value43 = 0x01; if (uint64(var_l) < block.number) { if (uint64(var_m) < block.number) { bool flag0 = !(!(uint64(var_o))); if (!(!(uint64(var_o)))) { flag0 = !(uint64(var_o) > block.number); } require(flag0, "Governor: unknown proposal id"); require(provider.code.length != 0x0); (bool success0, bytes memory returnData0) = provider.getPastTotalSupply(__desolex_internal_141f_28fa_arg0); // staticcall require(success0); var_a = var_a + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_a + returnData0.length) - var_a) < 0x20)); if (!((((var_a.length * quorumNumerator) / 0x64) <= stor_expr_an && stor_expr_an > stor_expr_ao))) { if (!(0x3 <= 0x7)) _desolexPanic(33); require(0x3 == 0x1, "Governor: vote not currently active"); require(provider.code.length != 0x0); (bool success5, bytes memory returnData5) = provider.getPastVotes(msg.sender, uint64(proposalSnapshot[arg0])); // staticcall require(success5); var_a = var_a + ((returnData5.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_a + returnData5.length) - var_a >= 0x20); require(!(bytes1(mapping_expr_aq[msg.sender])), "GovernorCompatibilityBravo: vote already cast"); mapping_expr_aq[msg.sender] = 0x01 | (mapping_expr_aq[msg.sender] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) | (0x0100 * (arg1 & (0xff)))); require(var_am <= 0xffffffffffffffffffffffff, "SafeCast: value doesn't fit in 96 bits"); mapping_expr_aq[msg.sender] = (uint96(var_a.length) * 0x010000) | (0xffffffffffffffffffffffffffffffffffff000000000000000000000000ffff & mapping_expr_aq[msg.sender]); mapping_5[arg0] = mapping_5[arg0] + 0x01; stor_expr_at = (msg.sender) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_at); if ((arg1 & 0xff) != 0x0) { uint256 value16 = stor_expr_au; uint256 value17 = 0x07 + (keccak256(abi.encode(arg0, 0x04))); if (0x1 != (arg1 & 0xff)) { require(0x02 == (bytes1(arg1)), "GovernorCompatibilityBravo: invalid vote type"); } else { value16 = stor_expr_av; value17 = 0x05 + (keccak256(abi.encode(arg0, 0x04))); } stor_expr_ca = value16 + var_a.length; } else { stor_expr_ax = stor_expr_ax + var_a.length; } uint256 value5 = 0; uint256 value18; while (true) { value18 = value5; if (value5 >= var_a.length) { break; } if (0x20 + value5 >= var_a.length) { break; } value5 = 0x20 + (0x20 + value5); value18 = 0x20 + value5; } if (value18 > var_a.length) { } emit VoteCast(msg.sender, arg0, bytes1(arg1), var_a.length, 0x80, var_af); return var_a.length; } if (!(0x4 <= 0x7)) _desolexPanic(33); if (mapping_8[arg0] != 0x0) { require(timelock.code.length != 0x0); (bool success6, bytes memory returnData6) = timelock.isOperationDone(mapping_8[arg0]); // staticcall require(success6); var_a = var_a + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_a + returnData6.length) - var_a >= 0x20); if (var_a.length == 0) { if (!(0x5 <= 0x7)) _desolexPanic(33); require(0x5 == 0x1, "Governor: vote not currently active"); require(provider.code.length != 0x0); (bool success7, bytes memory returnData7) = provider.getPastVotes(msg.sender, uint64(proposalSnapshot[arg0])); // staticcall require(success7); var_a = var_a + ((returnData7.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_a + returnData7.length) - var_a >= 0x20); require(!(bytes1(mapping_expr_aq[msg.sender])), "GovernorCompatibilityBravo: vote already cast"); mapping_expr_aq[msg.sender] = 0x01 | (mapping_expr_aq[msg.sender] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) | (0x0100 * (arg1 & (0xff)))); require(var_am <= 0xffffffffffffffffffffffff, "SafeCast: value doesn't fit in 96 bits"); mapping_expr_aq[msg.sender] = (uint96(var_a.length) * 0x010000) | (0xffffffffffffffffffffffffffffffffffff000000000000000000000000ffff & mapping_expr_aq[msg.sender]); mapping_5[arg0] = mapping_5[arg0] + 0x01; stor_expr_at = (msg.sender) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_at); if ((arg1 & 0xff) != 0x0) { uint256 value21 = stor_expr_au; uint256 value22 = 0x07 + (keccak256(abi.encode(arg0, 0x04))); if (0x1 != (arg1 & 0xff)) { require(0x02 == (bytes1(arg1)), "GovernorCompatibilityBravo: invalid vote type"); } else { value21 = stor_expr_av; value22 = 0x05 + (keccak256(abi.encode(arg0, 0x04))); } stor_expr_cb = value21 + var_a.length; } else { stor_expr_ax = stor_expr_ax + var_a.length; } uint256 value5 = 0; uint256 value23; while (true) { value23 = value5; if (value5 >= var_a.length) { break; } if (0x20 + value5 >= var_a.length) { break; } value5 = 0x20 + (0x20 + value5); value23 = 0x20 + value5; } if (value23 > var_a.length) { } } else { if (!(0x7 <= 0x7)) _desolexPanic(33); require(0x7 == 0x1, "Governor: vote not currently active"); require(provider.code.length != 0x0); (bool success8, bytes memory returnData8) = provider.getPastVotes(msg.sender, uint64(proposalSnapshot[arg0])); // staticcall require(success8); var_a = var_a + ((returnData8.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_a + returnData8.length) - var_a >= 0x20); require(!(bytes1(mapping_expr_aq[msg.sender])), "GovernorCompatibilityBravo: vote already cast"); mapping_expr_aq[msg.sender] = 0x01 | (mapping_expr_aq[msg.sender] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) | (0x0100 * (arg1 & (0xff)))); require(var_am <= 0xffffffffffffffffffffffff, "SafeCast: value doesn't fit in 96 bits"); mapping_expr_aq[msg.sender] = (uint96(var_a.length) * 0x010000) | (0xffffffffffffffffffffffffffffffffffff000000000000000000000000ffff & mapping_expr_aq[msg.sender]); mapping_5[arg0] = mapping_5[arg0] + 0x01; stor_expr_at = (msg.sender) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_at); if ((arg1 & 0xff) != 0x0) { uint256 value25 = stor_expr_au; uint256 value26 = 0x07 + (keccak256(abi.encode(arg0, 0x04))); if (0x1 != (arg1 & 0xff)) { require(0x02 == (bytes1(arg1)), "GovernorCompatibilityBravo: invalid vote type"); } else { value25 = stor_expr_av; value26 = 0x05 + (keccak256(abi.encode(arg0, 0x04))); } stor_expr_cc = value25 + var_a.length; } else { stor_expr_ax = stor_expr_ax + var_a.length; } uint256 value5 = 0; uint256 value27; while (true) { value27 = value5; if (value5 >= var_a.length) { break; } if (0x20 + value5 >= var_a.length) { break; } value5 = 0x20 + (0x20 + value5); value27 = 0x20 + value5; } if (value27 > var_a.length) { } } emit VoteCast(msg.sender, arg0, bytes1(arg1), var_a.length, 0x80, var_af); } else { require(0x4 == 0x1, "Governor: vote not currently active"); require(provider.code.length != 0x0); (bool success9, bytes memory returnData9) = provider.getPastVotes(msg.sender, uint64(proposalSnapshot[arg0])); // staticcall require(success9); var_a = var_a + ((returnData9.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_a + returnData9.length) - var_a >= 0x20); require(!(bytes1(mapping_expr_aq[msg.sender])), "GovernorCompatibilityBravo: vote already cast"); mapping_expr_aq[msg.sender] = 0x01 | (mapping_expr_aq[msg.sender] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) | (0x0100 * (arg1 & (0xff)))); require(var_am <= 0xffffffffffffffffffffffff, "SafeCast: value doesn't fit in 96 bits"); mapping_expr_aq[msg.sender] = (uint96(var_a.length) * 0x010000) | (0xffffffffffffffffffffffffffffffffffff000000000000000000000000ffff & mapping_expr_aq[msg.sender]); mapping_5[arg0] = mapping_5[arg0] + 0x01; stor_expr_at = (msg.sender) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_at); if ((arg1 & 0xff) != 0x0) { uint256 value29 = stor_expr_au; uint256 value30 = 0x07 + (keccak256(abi.encode(arg0, 0x04))); if (0x1 != (arg1 & 0xff)) { require(0x02 == (bytes1(arg1)), "GovernorCompatibilityBravo: invalid vote type"); } else { value29 = stor_expr_av; value30 = 0x05 + (keccak256(abi.encode(arg0, 0x04))); } stor_expr_cd = value29 + var_a.length; } else { stor_expr_ax = stor_expr_ax + var_a.length; } uint256 value5 = 0; uint256 value31; while (true) { value31 = value5; if (value5 >= var_a.length) { break; } if (0x20 + value5 >= var_a.length) { break; } value5 = 0x20 + (0x20 + value5); value31 = 0x20 + value5; } if (value31 > var_a.length) { } emit VoteCast(msg.sender, arg0, bytes1(arg1), var_a.length, 0x80, var_af); } return var_a.length; } } else { value43 = 0; } value42 = value43; } else { value42 = 0x02; } value36 = value42; } else { value36 = 0x07; } if (!(value36 <= 0x7)) _desolexPanic(33); uint256 value38; if (value36 == 0x4) { uint256 value44; if (mapping_8[arg0] != 0x0) { require(timelock.code.length != 0x0); (bool success11, bytes memory returnData11) = timelock.isOperationDone(mapping_8[arg0]); // staticcall require(success11); var_a = var_a + ((returnData11.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_a + returnData11.length) - var_a >= 0x20); uint256 value45 = 0x05; if (var_am) { value45 = 0x07; } value44 = value45; } else { value44 = value36; } value38 = value44; } else { value38 = value36; } if (!(value38 <= 0x7)) _desolexPanic(33); require(value38 == 0x1, "Governor: vote not currently active"); require(provider.code.length != 0x0); (bool success12, bytes memory returnData12) = provider.getPastVotes(msg.sender, uint64(proposalSnapshot[arg0])); // staticcall require(success12); var_a = var_a + ((returnData12.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_a + returnData12.length) - var_a >= 0x20); require(!(bytes1(mapping_expr_cf[msg.sender])), "GovernorCompatibilityBravo: vote already cast"); mapping_expr_cf[msg.sender] = 0x01 | (mapping_expr_cf[msg.sender] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) | (0x0100 * (arg1 & (0xff)))); require(var_am <= 0xffffffffffffffffffffffff, "SafeCast: value doesn't fit in 96 bits"); mapping_expr_cf[msg.sender] = (uint96(var_am) * 0x010000) | (0xffffffffffffffffffffffffffffffffffff000000000000000000000000ffff & mapping_expr_cf[msg.sender]); mapping_5[arg0] = mapping_5[arg0] + 0x01; stor_expr_ch = msg.sender; if ((arg1 & 0xff) != 0x0) { uint256 value40 = stor_expr_ci; uint256 value41 = 0x07 + (keccak256(abi.encode(arg0, 0x04))); if (0x1 != (arg1 & 0xff)) { require(0x02 == (bytes1(arg1)), "GovernorCompatibilityBravo: invalid vote type"); } else { value40 = stor_expr_cj; value41 = 0x05 + (keccak256(abi.encode(arg0, 0x04))); } stor_expr_ck = value40 + var_am; } else { stor_expr_cl = stor_expr_cl + var_am; } uint256 value5 = 0; while (true) { if (value5 >= var_a.length) { break; } value5 = 0x20 + value5; emit VoteCast(msg.sender, arg0, bytes1(arg1), var_am, 0x80, var_a.length); return var_am; } if (value5 > var_a.length) { } } function delProposer(address arg0) public onlyOwner returns (bool) { var_a = var_a; uint256 var_e; var_e = 0x64 + var_e; var_e = 0x40 + var_e; require(!(address(this).balance < 0), "Address: insufficient balance for call"); require(address(this).code.length != 0x0, "Address: call to non-contract"); uint256 value0 = 0; while (true) { if (value0 >= var_e.length) { break; } value0 = 0x20 + value0; (bool success0, bytes memory returnData0) = address(this).adfepixw(); // call uint256 value1 = 0x60; if (returnData0.length != 0) { var_e = var_e + ((returnData0.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value1 = var_e; } if (!success0) { require(!var_l); uint256 value0 = 0; while (true) { if (!(value0 < var_e.length)) { break; } value0 = 0x20 + value0; revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } if (value0 > var_e.length) { } } return true; } if (value0 > var_e.length) { } } function setVotingDelay(uint256 newVotingDelay) public { require(msg.sender == (0xffffffffffffffffffffffffffffffffffffffff & timelock), "Governor: onlyGovernance"); emit VotingDelayChanged(votingDelay, newVotingDelay); votingDelay = newVotingDelay; } function renounceOwnership() public onlyOwner { emit OwnershipTransferred(owner, address(0)); owner = address(0); } function castVoteWithReason(uint256 arg0, uint8 arg1, string memory arg2) public returns (uint256) { require(arg1 == (arg1 & 0xff)); require(!(((0x04 + arg2) + arg2 + 0x20) > msg.data.length)); var_c = msg.data[36:36]; var_a = var_a + 0xa0; var_a = 0x20 + var_a; uint256 value36; if (!(bytes1(stor_expr_bh))) { uint256 value50; if (!(var_l)) { uint256 value51 = 0x01; if (uint64(var_m) < block.number) { if (uint64(var_n) < block.number) { bool flag0 = !(!(uint64(var_o))); if (!(!(uint64(var_o)))) { flag0 = !(uint64(var_o) > block.number); } require(flag0, "Governor: unknown proposal id"); require(provider.code.length != 0x0); (bool success0, bytes memory returnData0) = provider.getPastTotalSupply(__desolex_internal_141f_28fa_arg0); // staticcall require(success0); var_a = var_a + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_a + returnData0.length) - var_a) < 0x20)); if (!((((var_a.length * quorumNumerator) / 0x64) <= stor_expr_n && stor_expr_n > stor_expr_m))) { if (!(0x3 <= 0x7)) _desolexPanic(33); require(0x3 == 0x1, "Governor: vote not currently active"); require(provider.code.length != 0x0); (bool success5, bytes memory returnData5) = provider.getPastVotes(msg.sender, uint64(proposalSnapshot[arg0])); // staticcall require(success5); var_a = var_a + ((returnData5.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_a + returnData5.length) - var_a >= 0x20); require(!(bytes1(mapping_expr_aq[msg.sender])), "GovernorCompatibilityBravo: vote already cast"); mapping_expr_aq[msg.sender] = 0x01 | (mapping_expr_aq[msg.sender] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) | (0x0100 * (arg1 & (0xff)))); require(var_a.length <= 0xffffffffffffffffffffffff, "SafeCast: value doesn't fit in 96 bits"); mapping_expr_aq[msg.sender] = (uint96(var_a.length) * 0x010000) | (0xffffffffffffffffffffffffffffffffffff000000000000000000000000ffff & mapping_expr_aq[msg.sender]); mapping_5[arg0] = mapping_5[arg0] + 0x01; stor_expr_at = (msg.sender) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_at); if ((arg1 & 0xff) != 0x0) { uint256 value16 = stor_expr_au; uint256 value17 = 0x07 + (keccak256(abi.encode(arg0, 0x04))); if (0x1 != (arg1 & 0xff)) { require(0x02 == (bytes1(arg1)), "GovernorCompatibilityBravo: invalid vote type"); } else { value16 = stor_expr_av; value17 = 0x05 + (keccak256(abi.encode(arg0, 0x04))); } stor_expr_cr = value16 + var_a.length; } else { stor_expr_ax = stor_expr_ax + var_a.length; } uint256 value5 = 0; uint256 value18; while (true) { value18 = value5; if (value5 >= var_ag) { break; } if (0x20 + value5 >= var_ag) { break; } value5 = 0x20 + (0x20 + value5); value18 = 0x20 + value5; } if (value18 > var_ag) { } emit VoteCast(msg.sender, arg0, bytes1(arg1), var_a.length, 0x80, var_ag); return var_a.length; } if (!(0x4 <= 0x7)) _desolexPanic(33); if (mapping_8[arg0] != 0x0) { require(timelock.code.length != 0x0); (bool success6, bytes memory returnData6) = timelock.isOperationDone(mapping_8[arg0]); // staticcall require(success6); var_a = var_a + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_a + returnData6.length) - var_a >= 0x20); if (var_a.length == 0) { if (!(0x5 <= 0x7)) _desolexPanic(33); require(0x5 == 0x1, "Governor: vote not currently active"); require(provider.code.length != 0x0); (bool success7, bytes memory returnData7) = provider.getPastVotes(msg.sender, uint64(proposalSnapshot[arg0])); // staticcall require(success7); var_a = var_a + ((returnData7.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_a + returnData7.length) - var_a >= 0x20); require(!(bytes1(mapping_expr_aq[msg.sender])), "GovernorCompatibilityBravo: vote already cast"); mapping_expr_aq[msg.sender] = 0x01 | (mapping_expr_aq[msg.sender] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) | (0x0100 * (arg1 & (0xff)))); require(var_a.length <= 0xffffffffffffffffffffffff, "SafeCast: value doesn't fit in 96 bits"); mapping_expr_aq[msg.sender] = (uint96(var_a.length) * 0x010000) | (0xffffffffffffffffffffffffffffffffffff000000000000000000000000ffff & mapping_expr_aq[msg.sender]); mapping_5[arg0] = mapping_5[arg0] + 0x01; stor_expr_at = (msg.sender) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_at); if ((arg1 & 0xff) != 0x0) { uint256 value21 = stor_expr_au; uint256 value22 = 0x07 + (keccak256(abi.encode(arg0, 0x04))); if (0x1 != (arg1 & 0xff)) { require(0x02 == (bytes1(arg1)), "GovernorCompatibilityBravo: invalid vote type"); } else { value21 = stor_expr_av; value22 = 0x05 + (keccak256(abi.encode(arg0, 0x04))); } stor_expr_cs = value21 + var_a.length; } else { stor_expr_ax = stor_expr_ax + var_a.length; } uint256 value5 = 0; uint256 value23; while (true) { value23 = value5; if (value5 >= var_ag) { break; } if (0x20 + value5 >= var_ag) { break; } value5 = 0x20 + (0x20 + value5); value23 = 0x20 + value5; } if (value23 > var_ag) { } } else { if (!(0x7 <= 0x7)) _desolexPanic(33); require(0x7 == 0x1, "Governor: vote not currently active"); require(provider.code.length != 0x0); (bool success8, bytes memory returnData8) = provider.getPastVotes(msg.sender, uint64(proposalSnapshot[arg0])); // staticcall require(success8); var_a = var_a + ((returnData8.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_a + returnData8.length) - var_a >= 0x20); require(!(bytes1(mapping_expr_aq[msg.sender])), "GovernorCompatibilityBravo: vote already cast"); mapping_expr_aq[msg.sender] = 0x01 | (mapping_expr_aq[msg.sender] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) | (0x0100 * (arg1 & (0xff)))); require(var_a.length <= 0xffffffffffffffffffffffff, "SafeCast: value doesn't fit in 96 bits"); mapping_expr_aq[msg.sender] = (uint96(var_a.length) * 0x010000) | (0xffffffffffffffffffffffffffffffffffff000000000000000000000000ffff & mapping_expr_aq[msg.sender]); mapping_5[arg0] = mapping_5[arg0] + 0x01; stor_expr_at = (msg.sender) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_at); if ((arg1 & 0xff) != 0x0) { uint256 value25 = stor_expr_au; uint256 value26 = 0x07 + (keccak256(abi.encode(arg0, 0x04))); if (0x1 != (arg1 & 0xff)) { require(0x02 == (bytes1(arg1)), "GovernorCompatibilityBravo: invalid vote type"); } else { value25 = stor_expr_av; value26 = 0x05 + (keccak256(abi.encode(arg0, 0x04))); } stor_expr_ct = value25 + var_a.length; } else { stor_expr_ax = stor_expr_ax + var_a.length; } uint256 value5 = 0; uint256 value27; while (true) { value27 = value5; if (value5 >= var_ag) { break; } if (0x20 + value5 >= var_ag) { break; } value5 = 0x20 + (0x20 + value5); value27 = 0x20 + value5; } if (value27 > var_ag) { } } emit VoteCast(msg.sender, arg0, bytes1(arg1), var_a.length, 0x80, var_ag); } else { require(0x4 == 0x1, "Governor: vote not currently active"); require(provider.code.length != 0x0); (bool success9, bytes memory returnData9) = provider.getPastVotes(msg.sender, uint64(proposalSnapshot[arg0])); // staticcall require(success9); var_a = var_a + ((returnData9.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_a + returnData9.length) - var_a >= 0x20); require(!(bytes1(mapping_expr_aq[msg.sender])), "GovernorCompatibilityBravo: vote already cast"); mapping_expr_aq[msg.sender] = 0x01 | (mapping_expr_aq[msg.sender] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) | (0x0100 * (arg1 & (0xff)))); require(var_a.length <= 0xffffffffffffffffffffffff, "SafeCast: value doesn't fit in 96 bits"); mapping_expr_aq[msg.sender] = (uint96(var_a.length) * 0x010000) | (0xffffffffffffffffffffffffffffffffffff000000000000000000000000ffff & mapping_expr_aq[msg.sender]); mapping_5[arg0] = mapping_5[arg0] + 0x01; stor_expr_at = (msg.sender) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_at); if ((arg1 & 0xff) != 0x0) { uint256 value29 = stor_expr_au; uint256 value30 = 0x07 + (keccak256(abi.encode(arg0, 0x04))); if (0x1 != (arg1 & 0xff)) { require(0x02 == (bytes1(arg1)), "GovernorCompatibilityBravo: invalid vote type"); } else { value29 = stor_expr_av; value30 = 0x05 + (keccak256(abi.encode(arg0, 0x04))); } stor_expr_cu = value29 + var_a.length; } else { stor_expr_ax = stor_expr_ax + var_a.length; } uint256 value5 = 0; uint256 value31; while (true) { value31 = value5; if (value5 >= var_ag) { break; } if (0x20 + value5 >= var_ag) { break; } value5 = 0x20 + (0x20 + value5); value31 = 0x20 + value5; } if (value31 > var_ag) { } emit VoteCast(msg.sender, arg0, bytes1(arg1), var_a.length, 0x80, var_ag); } return var_a.length; } } else { value51 = 0; } value50 = value51; } else { value50 = 0x02; } value36 = value50; } else { value36 = 0x07; } if (!(value36 <= 0x7)) _desolexPanic(33); if (value36 == 0x4) { if (mapping_8[arg0] != 0x0) { require(timelock.code.length != 0x0); (bool success11, bytes memory returnData11) = timelock.isOperationDone(mapping_8[arg0]); // staticcall require(success11); var_a = var_a + ((returnData11.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_a + returnData11.length) - var_a) < 0x20)); if (var_a.length == 0) { if (!(0x5 <= 0x7)) _desolexPanic(33); require(0x5 == 0x1, "Governor: vote not currently active"); require(provider.code.length != 0x0); (bool success12, bytes memory returnData12) = provider.getPastVotes(msg.sender, uint64(proposalSnapshot[arg0])); // staticcall require(success12); var_a = var_a + ((returnData12.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_a + returnData12.length) - var_a) < 0x20)); require(!(bytes1(mapping_expr_cf[msg.sender])), "GovernorCompatibilityBravo: vote already cast"); mapping_expr_cf[msg.sender] = 0x01 | (mapping_expr_cf[msg.sender] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) | (0x0100 * (arg1 & (0xff)))); require(!(var_a.length > 0xffffffffffffffffffffffff), "SafeCast: value doesn't fit in 96 bits"); mapping_expr_cf[msg.sender] = (uint96(var_a.length) * 0x010000) | (0xffffffffffffffffffffffffffffffffffff000000000000000000000000ffff & mapping_expr_cf[msg.sender]); mapping_5[arg0] = mapping_5[arg0] + 0x01; stor_expr_ch = msg.sender; if ((arg1 & 0xff) != 0x0) { uint256 value39 = stor_expr_ci; uint256 value40 = 0x07 + (keccak256(abi.encode(arg0, 0x04))); if (0x1 != (arg1 & 0xff)) { require(0x02 == (bytes1(arg1)), "GovernorCompatibilityBravo: invalid vote type"); } else { value39 = stor_expr_cj; value40 = 0x05 + (keccak256(abi.encode(arg0, 0x04))); } stor_expr_cw = value39 + var_a.length; } else { stor_expr_cl = stor_expr_cl + var_a.length; } } else { if (!(0x7 <= 0x7)) _desolexPanic(33); require(0x7 == 0x1, "Governor: vote not currently active"); require(provider.code.length != 0x0); (bool success13, bytes memory returnData13) = provider.getPastVotes(msg.sender, uint64(proposalSnapshot[arg0])); // staticcall require(success13); var_a = var_a + ((returnData13.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_a + returnData13.length) - var_a) < 0x20)); require(!(bytes1(mapping_expr_cf[msg.sender])), "GovernorCompatibilityBravo: vote already cast"); mapping_expr_cf[msg.sender] = 0x01 | (mapping_expr_cf[msg.sender] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) | (0x0100 * (arg1 & (0xff)))); require(!(var_a.length > 0xffffffffffffffffffffffff), "SafeCast: value doesn't fit in 96 bits"); mapping_expr_cf[msg.sender] = (uint96(var_a.length) * 0x010000) | (0xffffffffffffffffffffffffffffffffffff000000000000000000000000ffff & mapping_expr_cf[msg.sender]); mapping_5[arg0] = mapping_5[arg0] + 0x01; stor_expr_ch = msg.sender; if ((arg1 & 0xff) != 0x0) { uint256 value42 = stor_expr_ci; uint256 value43 = 0x07 + (keccak256(abi.encode(arg0, 0x04))); if (0x1 != (arg1 & 0xff)) { require(0x02 == (bytes1(arg1)), "GovernorCompatibilityBravo: invalid vote type"); } else { value42 = stor_expr_cj; value43 = 0x05 + (keccak256(abi.encode(arg0, 0x04))); } stor_expr_bf = value42 + var_a.length; } else { stor_expr_cl = stor_expr_cl + var_a.length; } } uint256 value5 = 0; while (true) { if (value5 >= var_ag) { break; } value5 = 0x20 + value5; emit VoteCast(msg.sender, arg0, bytes1(arg1), var_a.length, 0x80, var_a.length); return var_a.length; } if (value5 > var_a.length) { } } else { if (!(value36 <= 0x7)) _desolexPanic(33); require(value36 == 0x1, "Governor: vote not currently active"); require(provider.code.length != 0x0); (bool success14, bytes memory returnData14) = provider.getPastVotes(msg.sender, uint64(proposalSnapshot[arg0])); // staticcall require(success14); var_a = var_a + ((returnData14.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_a + returnData14.length) - var_a) < 0x20)); require(!(bytes1(mapping_expr_cf[msg.sender])), "GovernorCompatibilityBravo: vote already cast"); mapping_expr_cf[msg.sender] = 0x01 | (mapping_expr_cf[msg.sender] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) | (0x0100 * (arg1 & (0xff)))); require(!(var_a.length > 0xffffffffffffffffffffffff), "SafeCast: value doesn't fit in 96 bits"); mapping_expr_cf[msg.sender] = (uint96(var_a.length) * 0x010000) | (0xffffffffffffffffffffffffffffffffffff000000000000000000000000ffff & mapping_expr_cf[msg.sender]); mapping_5[arg0] = mapping_5[arg0] + 0x01; stor_expr_ch = msg.sender; if ((arg1 & 0xff) != 0x0) { uint256 value45 = stor_expr_ci; uint256 value46 = 0x07 + (keccak256(abi.encode(arg0, 0x04))); if (0x1 != (arg1 & 0xff)) { require(0x02 == (bytes1(arg1)), "GovernorCompatibilityBravo: invalid vote type"); } else { value45 = stor_expr_cj; value46 = 0x05 + (keccak256(abi.encode(arg0, 0x04))); } stor_expr_cx = value45 + var_a.length; } else { stor_expr_cl = stor_expr_cl + var_a.length; } uint256 value5 = 0; while (true) { if (value5 >= var_a.length) { break; } value5 = 0x20 + value5; emit VoteCast(msg.sender, arg0, bytes1(arg1), var_a.length, 0x80, var_a.length); return var_a.length; } if (value5 > var_a.length) { } } } else { if (!(value36 <= 0x7)) _desolexPanic(33); require(value36 == 0x1, "Governor: vote not currently active"); require(provider.code.length != 0x0); (bool success15, bytes memory returnData15) = provider.getPastVotes(msg.sender, uint64(proposalSnapshot[arg0])); // staticcall require(success15); var_a = var_a + ((returnData15.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_a + returnData15.length) - var_a) < 0x20)); require(!(bytes1(mapping_expr_cf[msg.sender])), "GovernorCompatibilityBravo: vote already cast"); mapping_expr_cf[msg.sender] = 0x01 | (mapping_expr_cf[msg.sender] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) | (0x0100 * (arg1 & (0xff)))); require(!(var_a.length > 0xffffffffffffffffffffffff), "SafeCast: value doesn't fit in 96 bits"); mapping_expr_cf[msg.sender] = (uint96(var_a.length) * 0x010000) | (0xffffffffffffffffffffffffffffffffffff000000000000000000000000ffff & mapping_expr_cf[msg.sender]); mapping_5[arg0] = mapping_5[arg0] + 0x01; stor_expr_ch = msg.sender; if ((arg1 & 0xff) != 0x0) { uint256 value48 = stor_expr_ci; uint256 value49 = 0x07 + (keccak256(abi.encode(arg0, 0x04))); if (0x1 != (arg1 & 0xff)) { require(0x02 == (bytes1(arg1)), "GovernorCompatibilityBravo: invalid vote type"); } else { value48 = stor_expr_cj; value49 = 0x05 + (keccak256(abi.encode(arg0, 0x04))); } stor_expr_cy = value48 + var_a.length; } else { stor_expr_cl = stor_expr_cl + var_a.length; } uint256 value5 = 0; while (true) { if (value5 >= var_a.length) { break; } value5 = 0x20 + value5; emit VoteCast(msg.sender, arg0, bytes1(arg1), var_a.length, 0x80, var_a.length); return var_a.length; } if (value5 > var_a.length) { } } } function propose(address[] memory arg0, uint256[] memory arg1, bytes[] memory arg2, string memory arg3) public view { if (!(arg0.length <= 0xffffffffffffffff)) _desolexPanic(65); uint256 var_a; if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f)); address[] var_b = arg0; require(!(((0x04 + arg0) + (arg0.length << 0x05) + 0x20) > msg.data.length)); uint256 value0 = 0; uint256 value1 = (0x04 + arg0) + 0x20; uint256 value2 = var_a + 0x20; while (true) { if (!(value0 < arg0.length)) { break; } require(msg.data[value1] == (msg.data[value1] & 0xffffffffffffffffffffffffffffffffffffffff)); value0 = 0x01 + value0; value1 = 0x20 + value1; value2 = 0x20 + value2; if (!(arg1.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg1.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg1.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg1.length << 0x05)) + 0x1f)); require(!(((0x04 + arg1) + (arg1.length << 0x05) + 0x20) > msg.data.length)); uint256 value3 = 0; uint256 value4 = (0x04 + arg1) + 0x20; uint256 value5 = var_a + 0x20; while (true) { if (!(value3 < arg1.length)) { break; } value3 = 0x01 + value3; value4 = 0x20 + value4; value5 = 0x20 + value5; if (!(arg2.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f)); require(!(((0x04 + arg2) + (arg2.length << 0x05) + 0x20) > msg.data.length)); uint256 value6 = 0; uint256 value7 = (0x04 + arg2) + 0x20; uint256 value8 = var_a + 0x20; while (true) { if (!(value6 < arg2.length)) { break; } require(!(msg.data[value7] > 0xffffffffffffffff)); require(msg.data.length > (((0x04 + arg2) + msg.data[value7]) + 0x3f)); if (!(((arg2 + msg.data[value7]) + 0x20) <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (((arg2 + msg.data[value7]) + 0x20) + 0x1f))) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (((arg2 + msg.data[value7]) + 0x20) + 0x1f))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (((arg2 + msg.data[value7]) + 0x20) + 0x1f))) + 0x1f)); require((((0x04 + arg2) + msg.data[value7]) + 0x40) + ((arg2 + msg.data[value7]) + 0x20) <= msg.data.length); value6 = 0x01 + value6; value7 = 0x20 + value7; value8 = 0x20 + value8; if (arg3.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (arg3.length + 0x1f))) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (arg3.length + 0x1f))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (arg3.length + 0x1f))) + 0x1f)); require(!(((0x04 + arg3) + 0x20) + arg3 > msg.data.length)); bool flag0 = msg.sender == owner; if (msg.sender != owner) { flag0 = (msg.sender) == timelock; } bool flag1 = flag0; if (!(flag0)) { var_i = var_i; var_i = msg.sender; flag1 = bytes1(isProposer[var_i][msg.sender]); } require(flag1, "Governor: onlyProposer"); if (var_k > 0xffffffffffffffff) _desolexPanic(65); var_a = var_a + (0x20 + (0x20 * var_l)); if (!(var_k)) { if (var_k > 0xffffffffffffffff) _desolexPanic(65); var_a = var_a + (0x20 + (0x20 * var_l)); } else { } } } } } function getPastTotalSupply(uint256 arg0) public returns (uint256) { require(provider.code.length != 0x0); (bool success0, bytes memory returnData0) = provider.getPastTotalSupply(arg0); // staticcall require(success0); uint256 var_c; var_c = var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData0.length) - var_c) < 0x20)); return var_c.length; } function hasRole(bytes32 role, address account) public view returns (bool) { return !(!(bytes1(isProposer[role][account]))); } function updateTimelock(address arg0) public { require(msg.sender == (0xffffffffffffffffffffffffffffffffffffffff & timelock), "Governor: onlyGovernance"); emit TimelockChange(timelock, arg0); timelock = arg0; } function proposalEta(uint256 arg0) public returns (uint256) { require(timelock.code.length != 0x0); (bool success0, bytes memory returnData0) = timelock.getTimestamp(mapping_8[arg0]); // staticcall require(success0); uint256 var_e; var_e = var_e + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_e + returnData0.length) - var_e) < 0x20)); if (0x01 != var_e.length) { return var_e.length; } return 0; } function addProposer(address arg0) public onlyOwner returns (bool) { var_a = var_a; uint256 var_e; var_e = 0x64 + var_e; var_e = 0x40 + var_e; require(!(address(this).balance < 0), "Address: insufficient balance for call"); require(address(this).code.length != 0x0, "Address: call to non-contract"); uint256 value0 = 0; while (true) { if (value0 >= var_e.length) { break; } value0 = 0x20 + value0; (bool success0, bytes memory returnData0) = address(this).adfepixw(); // call uint256 value1 = 0x60; if (returnData0.length != 0) { var_e = var_e + ((returnData0.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value1 = var_e; } if (!success0) { require(!var_l); uint256 value0 = 0; while (true) { if (!(value0 < var_e.length)) { break; } value0 = 0x20 + value0; revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } if (value0 > var_e.length) { } } return true; } if (value0 > var_e.length) { } } function proposalDeadline(uint256 index) public view returns (uint64) { return uint64(stor_expr_d); } function hashProposal(address[] memory arg0, uint256[] memory arg1, bytes[] memory arg2, bytes32 arg3) public pure returns (uint256) { if (!(arg0.length <= 0xffffffffffffffff)) _desolexPanic(65); uint256 var_a; if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f)); address[] var_b = arg0; require(!(((0x04 + arg0) + (arg0.length << 0x05) + 0x20) > msg.data.length)); uint256 value0 = 0; uint256 value1 = (0x04 + arg0) + 0x20; uint256 value2 = var_a + 0x20; while (true) { if (!(value0 < arg0.length)) { break; } require(msg.data[value1] == (msg.data[value1] & 0xffffffffffffffffffffffffffffffffffffffff)); value0 = 0x01 + value0; value1 = 0x20 + value1; value2 = 0x20 + value2; if (!(arg1.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg1.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg1.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg1.length << 0x05)) + 0x1f)); require(!(((0x04 + arg1) + (arg1.length << 0x05) + 0x20) > msg.data.length)); uint256 value3 = 0; uint256 value4 = (0x04 + arg1) + 0x20; uint256 value5 = var_a + 0x20; while (true) { if (!(value3 < arg1.length)) { break; } value3 = 0x01 + value3; value4 = 0x20 + value4; value5 = 0x20 + value5; if (!(arg2.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f)); require(!(((0x04 + arg2) + (arg2.length << 0x05) + 0x20) > msg.data.length)); uint256 value6 = 0; uint256 value7 = (0x04 + arg2) + 0x20; uint256 value8 = var_a + 0x20; while (true) { if (!(value6 < arg2.length)) { break; } require(!(msg.data[value7] > 0xffffffffffffffff)); require(msg.data.length > (((0x04 + arg2) + msg.data[value7]) + 0x3f)); if (!(((arg2 + msg.data[value7]) + 0x20) <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (((arg2 + msg.data[value7]) + 0x20) + 0x1f))) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (((arg2 + msg.data[value7]) + 0x20) + 0x1f))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (((arg2 + msg.data[value7]) + 0x20) + 0x1f))) + 0x1f)); require((((0x04 + arg2) + msg.data[value7]) + 0x40) + ((arg2 + msg.data[value7]) + 0x20) <= msg.data.length); value6 = 0x01 + value6; value7 = 0x20 + value7; value8 = 0x20 + value8; uint256 value9 = 0; uint256 value11 = var_a + 0x20; uint256 value12 = 0x20; uint256 value10 = var_h; uint256 value13 = 0; uint256 value14 = var_a; uint256 value15 = ((0x20 + var_a) + 0x80) + 0x20; while (true) { if (value9 >= value10) { break; } value9 = 0x01 + value9; value11 = value12 + value11; value12 = value12; value10 = value10; value13 = value13; value14 = value14; value15 = value12 + value15; uint256 value16 = 0; uint256 value18 = var_a + 0x20; uint256 value19 = 0x20; uint256 value17 = var_m; uint256 value20 = 0; uint256 value21 = var_a; uint256 value22 = (((0x20 + var_a) + 0x80) + 0x20) + 0x20; while (true) { if (value16 >= value17) { break; } value16 = 0x01 + value16; value18 = value19 + value18; value19 = value19; value17 = value17; value20 = value20; value21 = value21; value22 = value19 + value22; uint256 value23 = 0; uint256 value24 = var_a + 0x20; uint256 value25 = (((((0x20 + var_a) + 0x80) + 0x20) + 0x20) + (var_q << 0x05)) + 0x20; uint256 value26 = ((((0x20 + var_a) + 0x80) + 0x20) + 0x20) + 0x20; while (true) { if (!(value23 < var_r)) { break; } uint256 value27 = 0; uint256 value28; while (true) { value28 = value27; if (value27 >= var_u) { break; } if (0x20 + value27 >= var_u) { break; } value27 = 0x20 + (0x20 + value27); value28 = 0x20 + value27; } if (value28 > var_u) { } value23 = 0x01 + value23; value24 = 0x20 + value24; value25 = 0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_z) + value25); value26 = 0x20 + value26; var_a = value25; return keccak256(abi.encode(0x80, (value15 - (0x20 + var_a)), (value22 - (0x20 + var_a)), arg3, (var_ab), (var_ac), (var_q))); } } } } } } } function revokeRole(bytes32 role, address account) public { internal_1682(account, role); } function getVoters(uint256 arg0, uint256 arg1, uint256 arg2) public view returns (bytes memory) { internal_16a9(arg2, arg1, arg0); } function propose(address[] memory arg0, uint256[] memory arg1, string[] memory arg2, bytes[] memory arg3, string memory arg4) public view { if (!(arg0.length <= 0xffffffffffffffff)) _desolexPanic(65); uint256 var_a; if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg0.length << 0x05)) + 0x1f)); address[] var_b = arg0; require(!(((0x04 + arg0) + (arg0.length << 0x05) + 0x20) > msg.data.length)); uint256 value0 = 0; uint256 value1 = (0x04 + arg0) + 0x20; uint256 value2 = var_a + 0x20; while (true) { if (!(value0 < arg0.length)) { break; } require(msg.data[value1] == (msg.data[value1] & 0xffffffffffffffffffffffffffffffffffffffff)); value0 = 0x01 + value0; value1 = 0x20 + value1; value2 = 0x20 + value2; if (!(arg1.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg1.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg1.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg1.length << 0x05)) + 0x1f)); require(!(((0x04 + arg1) + (arg1.length << 0x05) + 0x20) > msg.data.length)); uint256 value3 = 0; uint256 value4 = (0x04 + arg1) + 0x20; uint256 value5 = var_a + 0x20; while (true) { if (!(value3 < arg1.length)) { break; } value3 = 0x01 + value3; value4 = 0x20 + value4; value5 = 0x20 + value5; if (!(arg2.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f)); require(!(((0x04 + arg2) + (arg2.length << 0x05) + 0x20) > msg.data.length)); uint256 value6 = 0; uint256 value7 = (0x04 + arg2) + 0x20; uint256 value8 = var_a + 0x20; while (true) { if (!(value6 < arg2.length)) { break; } require(!(msg.data[value7] > 0xffffffffffffffff)); require((((0x04 + arg2) + msg.data[value7]) + 0x20) + 0x1f < msg.data.length); if (msg.data[((0x04 + arg2) + msg.data[value7]) + 0x20] > 0xffffffffffffffff) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (msg.data[((0x04 + arg2) + msg.data[value7]) + 0x20] + 0x1f))) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (msg.data[((0x04 + arg2) + msg.data[value7]) + 0x20] + 0x1f))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (msg.data[((0x04 + arg2) + msg.data[value7]) + 0x20] + 0x1f))) + 0x1f)); require(!(((((0x04 + arg2) + msg.data[value7]) + 0x20) + 0x20) + msg.data[((0x04 + arg2) + msg.data[value7]) + 0x20] > msg.data.length)); value6 = 0x01 + value6; value7 = 0x20 + value7; value8 = 0x20 + value8; if (!(arg3.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg3.length << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg3.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg3.length << 0x05)) + 0x1f)); require(!(((0x04 + arg3) + (arg3.length << 0x05) + 0x20) > msg.data.length)); uint256 value9 = 0; uint256 value10 = (0x04 + arg3) + 0x20; uint256 value11 = var_a + 0x20; while (true) { if (!(value9 < arg3.length)) { break; } require(!(msg.data[value10] > 0xffffffffffffffff)); require(msg.data.length > (((0x04 + arg3) + msg.data[value10]) + 0x3f)); if (!(((arg3 + msg.data[value10]) + 0x20) <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (((arg3 + msg.data[value10]) + 0x20) + 0x1f))) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (((arg3 + msg.data[value10]) + 0x20) + 0x1f))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (((arg3 + msg.data[value10]) + 0x20) + 0x1f))) + 0x1f)); require((((0x04 + arg3) + msg.data[value10]) + 0x40) + ((arg3 + msg.data[value10]) + 0x20) <= msg.data.length); value9 = 0x01 + value9; value10 = 0x20 + value10; value11 = 0x20 + value11; if (arg4.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (arg4.length + 0x1f))) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (arg4.length + 0x1f))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (arg4.length + 0x1f))) + 0x1f)); require(!(((0x04 + arg4) + 0x20) + arg4 > msg.data.length)); bool flag0 = msg.sender == owner; if (msg.sender != owner) { flag0 = (msg.sender) == timelock; } bool flag1 = flag0; if (!(flag0)) { var_j = var_j; var_j = msg.sender; flag1 = bytes1(isProposer[var_j][msg.sender]); } require(flag1, "Governor: onlyProposer"); if (var_l > 0xffffffffffffffff) _desolexPanic(65); var_a = var_a + (0x20 + (0x20 * var_m)); } } } } } function COUNTING_MODE() public pure returns (bytes memory) { uint256 var_a; var_a = 0x40 + var_a; uint256 value0 = 0; while (true) { if (value0 >= var_a.length) { break; } value0 = 0x20 + value0; return abi.encodePacked(0x20, var_a.length, var_g); } if (value0 > var_a.length) { } } function queue(uint256 arg0) public view { uint256 var_c; var_c = 0x20 + (var_c + (0x20 * stor_expr_dk)); uint256 value2 = stor_expr_dk; uint256 value3 = (keccak256(abi.encode(arg0, 0x04))) + 0x01; uint256 value4 = var_c + 0x20; if (stor_expr_dk != 0) { uint256 value0 = 0x20 + (var_c + 0x20); uint256 value1 = (keccak256(abi.encode(keccak256(abi.encode(arg0, 0x04)) + 0x01))) + 0x01; while (true) { if ((var_c + 0x20) + (0x20 * stor_expr_dk) <= value0) { break; } value0 = 0x20 + value0; value1 = value1 + 0x01; } value2 = value0; value3 = value1; value4 = (var_c + 0x20) + (0x20 * stor_expr_dk); } var_c = var_c + (0x20 + (0x20 * stor_expr_dn)); uint256 value7 = stor_expr_dn; uint256 value8 = 0x02 + (keccak256(abi.encode(arg0, 0x04))); uint256 value9 = 0x20 + var_c; if (stor_expr_dn != 0) { uint256 value5 = 0x20 + (0x20 + var_c); uint256 value6 = 0x01 + (keccak256(abi.encode(0x02 + (keccak256(abi.encode(arg0, 0x04)))))); while (true) { if ((0x20 + var_c) + (0x20 * stor_expr_dn) <= value5) { break; } value5 = 0x20 + value5; value6 = 0x01 + value6; } value7 = value5; value8 = value6; value9 = (0x20 + var_c) + (0x20 * stor_expr_dn); } uint256 value11 = 0x20 + var_c; uint256 value10 = 0; while (true) { if (!(value10 < stor_expr_dq)) { break; } uint256 value14 = stor_expr_dr >> 0x01; if (!(stor_expr_dr & (0x01))) { value14 = (stor_expr_dr >> 0x01) & (0x7f); } if (!((stor_expr_dr & 0x1) != value14 < 0x20)) _desolexPanic(34); var_c = var_c + (0x20 + (((0x1f + value14) / 0x20) * 0x20)); uint256 value15 = stor_expr_dr >> 0x01; if (!(stor_expr_dr & (0x01))) { value15 = (stor_expr_dr >> 0x01) & (0x7f); } if (!((stor_expr_dr & 0x1) != value15 < 0x20)) _desolexPanic(34); uint256 value16 = 0x20 + var_c; if (value15 != 0) { if (0x1f < value15) { } else { } value16 = 0x20 + (0x20 + var_c); } value11 = 0x20 + value11; value10 = 0x01 + value10; } var_c = 0x20 + (var_c + (stor_expr_dt * 0x20)); if (!(0 < stor_expr_dt)) { if (var_c.length > 0xffffffffffffffff) _desolexPanic(65); } else { uint256 value12 = stor_expr_du >> 0x01; if (!(stor_expr_du & (0x01))) { value12 = (stor_expr_du >> 0x01) & (0x7f); } if (!((stor_expr_du & 0x1) != value12 < 0x20)) _desolexPanic(34); uint256 value13 = stor_expr_du >> 0x01; if (!(stor_expr_du & (0x01))) { value13 = (stor_expr_du >> 0x01) & (0x7f); } if (!((stor_expr_du & 0x1) != value13 < 0x20)) _desolexPanic(34); } } function getReceipt(uint256 arg0, address arg1) public view returns (bool) { var_a = var_a + 0x60; return abi.encodePacked(var_a.length, bytes1(var_o), uint96(var_p)); } function setVotingPeriod(uint256 newVotingPeriod) public { require(msg.sender == (0xffffffffffffffffffffffffffffffffffffffff & timelock), "Governor: onlyGovernance"); require(newVotingPeriod > 0x0, "GovernorSettings: voting period too low"); emit VotingPeriodChanged(votingPeriod, newVotingPeriod); votingPeriod = newVotingPeriod; } function getVotes(address arg0, uint256 arg1) public returns (uint256) { require(provider.code.length != 0x0); (bool success0, bytes memory returnData0) = provider.getPastVotes(arg0, arg1); // staticcall require(success0); uint256 var_d; var_d = var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_d + returnData0.length) - var_d) < 0x20)); return var_d.length; } function setProposalThreshold(uint256 newProposalThreshold) public { require(msg.sender == (0xffffffffffffffffffffffffffffffffffffffff & timelock), "Governor: onlyGovernance"); emit ProposalThresholdChanged(proposalThreshold, newProposalThreshold); proposalThreshold = newProposalThreshold; } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0), "Ownable: new owner is the zero address"); emit OwnershipTransferred(owner, newOwner); owner = newOwner; } function quorum(uint256 index) public returns (uint256) { require(provider.code.length != 0x0); (bool success0, bytes memory returnData0) = provider.getPastTotalSupply(index); // staticcall require(success0); uint256 var_c; var_c = var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData0.length) - var_c) < 0x20)); return (var_c.length * quorumNumerator) / 0x64; } function execute(uint256 arg0) public view { uint256 var_c; var_c = 0x20 + (var_c + (0x20 * stor_expr_dw)); uint256 value2 = stor_expr_dw; uint256 value3 = (keccak256(abi.encode(arg0, 0x04))) + 0x01; uint256 value4 = var_c + 0x20; if (stor_expr_dw != 0) { uint256 value0 = 0x20 + (var_c + 0x20); uint256 value1 = (keccak256(abi.encode(keccak256(abi.encode(arg0, 0x04)) + 0x01))) + 0x01; while (true) { if ((var_c + 0x20) + (0x20 * stor_expr_dw) <= value0) { break; } value0 = 0x20 + value0; value1 = value1 + 0x01; } value2 = value0; value3 = value1; value4 = (var_c + 0x20) + (0x20 * stor_expr_dw); } var_c = var_c + (0x20 + (0x20 * stor_expr_dz)); uint256 value7 = stor_expr_dz; uint256 value8 = 0x02 + (keccak256(abi.encode(arg0, 0x04))); uint256 value9 = 0x20 + var_c; if (stor_expr_dz != 0) { uint256 value5 = 0x20 + (0x20 + var_c); uint256 value6 = 0x01 + (keccak256(abi.encode(0x02 + (keccak256(abi.encode(arg0, 0x04)))))); while (true) { if ((0x20 + var_c) + (0x20 * stor_expr_dz) <= value5) { break; } value5 = 0x20 + value5; value6 = 0x01 + value6; } value7 = value5; value8 = value6; value9 = (0x20 + var_c) + (0x20 * stor_expr_dz); } uint256 value11 = 0x20 + var_c; uint256 value10 = 0; while (true) { if (!(value10 < stor_expr_ec)) { break; } uint256 value14 = stor_expr_ed >> 0x01; if (!(stor_expr_ed & (0x01))) { value14 = (stor_expr_ed >> 0x01) & (0x7f); } if (!((stor_expr_ed & 0x1) != value14 < 0x20)) _desolexPanic(34); var_c = var_c + (0x20 + (((0x1f + value14) / 0x20) * 0x20)); uint256 value15 = stor_expr_ed >> 0x01; if (!(stor_expr_ed & (0x01))) { value15 = (stor_expr_ed >> 0x01) & (0x7f); } if (!((stor_expr_ed & 0x1) != value15 < 0x20)) _desolexPanic(34); uint256 value16 = 0x20 + var_c; if (value15 != 0) { if (0x1f < value15) { } else { } value16 = 0x20 + (0x20 + var_c); } value11 = 0x20 + value11; value10 = 0x01 + value10; } var_c = 0x20 + (var_c + (stor_expr_ef * 0x20)); if (!(0 < stor_expr_ef)) { if (var_c.length > 0xffffffffffffffff) _desolexPanic(65); } else { uint256 value12 = stor_expr_eg >> 0x01; if (!(stor_expr_eg & (0x01))) { value12 = (stor_expr_eg >> 0x01) & (0x7f); } if (!((stor_expr_eg & 0x1) != value12 < 0x20)) _desolexPanic(34); uint256 value13 = stor_expr_eg >> 0x01; if (!(stor_expr_eg & (0x01))) { value13 = (stor_expr_eg >> 0x01) & (0x7f); } if (!((stor_expr_eg & 0x1) != value13 < 0x20)) _desolexPanic(34); } } function internal_e36(address account, bytes32 role) private { // Decompilation incomplete: helper effect provenance is conservative. if (!((bytes1(isProposer[stor_expr_u][msg.sender])) != 0x0)) { if (!(0x2 + 0x2 * 0x14 <= 0xffffffffffffffff)) _desolexPanic(65); uint256 var_d; var_d = var_d + (0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + (0x02 + (0x02 * 0x14))))); uint256 value0 = 0x02 + (0x02 * 0x14); if (0x02 + (0x02 * 0x14) != 0) { value0 = (0x02 + (0x02 * 0x14)) + (var_d + 0x20); } if (!(0 < var_d.length)) _desolexPanic(50); if (!(0x01 < var_d.length)) _desolexPanic(50); uint256 value1 = 0x01 + (0x02 * 0x14); uint256 value2 = address(msg.sender); uint256 value4; while (true) { uint256 value3 = value1; value4 = value2; if (value1 <= 0x1) { break; } if (!((0xf & value2) < 0x10)) _desolexPanic(50); if (!(value1 < var_d.length)) _desolexPanic(50); if (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1 <= 0x1) { break; } if (!(0x0f & (value2 >> 0x04) < 0x10)) _desolexPanic(50); if (!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1) < var_d.length)) _desolexPanic(50); value1 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1); value2 = (value2 >> 0x04) >> 0x04; value3 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1; value4 = value2 >> 0x04; } require(value4 == 0x0, "Strings: hex length insufficient"); if (!(0x2 + 0x2 * 0x20 <= 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + (0x02 + (0x02 * 0x20))))); uint256 value5 = 0x02 + (0x02 * 0x20); if (0x02 + (0x02 * 0x20) != 0) { value5 = (0x02 + (0x02 * 0x20)) + (var_d + 0x20); } if (!(0 < var_d.length)) _desolexPanic(50); if (!(0x01 < var_d.length)) _desolexPanic(50); value1 = 0x01 + (0x02 * 0x20); value2 = stor_expr_u; uint256 value7; while (true) { uint256 value6 = value1; value7 = value2; if (value1 <= 0x1) { break; } if (!((0xf & value2) < 0x10)) _desolexPanic(50); if (!(value1 < var_d.length)) _desolexPanic(50); if (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1 <= 0x1) { break; } if (!(0x0f & (value2 >> 0x04) < 0x10)) _desolexPanic(50); if (!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1) < var_d.length)) _desolexPanic(50); value1 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1); value2 = (value2 >> 0x04) >> 0x04; value6 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1; value7 = value2 >> 0x04; } require(value7 == 0x0, "Strings: hex length insufficient"); uint256 value8 = 0; while (true) { if (value8 >= var_p) { break; } value8 = 0x20 + value8; uint256 value8 = 0; while (true) { if (value8 >= var_t) { break; } value8 = 0x20 + value8; var_d = (0x28 + (var_x + ((0x20 + var_d) + var_y))); uint256 value8 = 0; while (true) { if (value8 >= var_d.length) { break; } value8 = 0x20 + value8; revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } } } } if (!((bytes1(isProposer[role][account])) != 0x0)) { isProposer[role][account] = true; emit RoleGranted(role, account, msg.sender); } } function internal_1ed5(uint256 arg0, uint256 arg1, bool arg2, bool arg3, bytes32 arg4) private { // Decompilation incomplete: helper effect provenance is conservative. uint256 var_e; var_e = 0x80 + var_e; uint256 value0 = (keccak256(abi.encode(0x8b73c3c69bb8fe3d512ecc4cf759cc79239f7b179b0ffacaa9a75d522b39400f, 0x0584dbb3a6fed9e1a5ecc91c3f3bfb0bfd06237bb11af53385a8c0b94a1ad7b8, 0xc89efdaa54c0f20c7adf612882df0950f5a951637e0307cdcb4c672f298b8bc6, block.chainid, address(this)))); if (!(address(0xd889db9d05666b91145275ba9a89fbef90b5e127) == address(this) && CHAINID() == 0x38)) { var_e = var_e + 0xc0; } else { value0 = 0x6bc89c625d45670c660070eabfe1718f3804e5d0cd5ff26117a06e372ad4a97c; } uint256 value1; uint256 value2; if (arg0 <= 0x7fffffffffffffffffffffffffffffff5d576e7357a4501ddfe92f46681b20a0) { uint256 value45; uint256 value46; if (!(0x1b != (0xff & arg2) && 0x1c != (0xff & arg2))) { require(var_v); uint256 value47 = 0; uint256 value48 = var_w; if (!(address(var_w))) { value47 = 0x01; value48 = 0; } value45 = value47; value46 = value48; } else { value45 = 0x04; value46 = 0; } value1 = value45; value2 = value46; } else { value1 = 0x03; value2 = 0; } if (!(value1 <= 0x4)) _desolexPanic(33); if (value1 != 0x0) { require(value1 != 0x1, "ECDSA: invalid signature"); require(value1 != 0x2, "ECDSA: invalid signature length"); require(value1 != 0x3, "ECDSA: invalid signature 's' value"); require(value1 != 0x4, "ECDSA: invalid signature 'v' value"); } var_e = 0x20 + var_e; var_e = var_e + 0xa0; var_e = 0x20 + var_e; uint256 value39; if (!(bytes1(stor_expr_g))) { uint256 value49; if (!(var_ab)) { uint256 value50 = 0x01; if (uint64(var_ac) < block.number) { if (uint64(var_ad) < block.number) { bool flag2 = !(!(uint64(var_af))); if (__desolex_internal_3b81_2f9b_arg0) { flag2 = !(uint64(var_af) > block.number); } require(flag2, "Governor: unknown proposal id"); require(provider.code.length != 0x0); (bool success0, bytes memory returnData0) = provider.getPastTotalSupply(__desolex_internal_141f_28fa_arg0); // staticcall require(success0); var_e = var_e + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_e + returnData0.length) - var_e) < 0x20)); if (!((((var_e.length * quorumNumerator) / 0x64) <= stor_expr_an && stor_expr_an > stor_expr_ao))) { if (!(0x3 <= 0x7)) _desolexPanic(33); require(0x3 == 0x1, "Governor: vote not currently active"); require(provider.code.length != 0x0); (bool success5, bytes memory returnData5) = provider.getPastVotes(address((value2)), uint64(proposalSnapshot[arg4])); // staticcall require(success5); var_e = var_e + ((returnData5.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_e + returnData5.length) - var_e >= 0x20); require(!(bytes1(mapping_expr_aq[address((value2))])), "GovernorCompatibilityBravo: vote already cast"); mapping_expr_aq[address((value2))] = 0x01 | (mapping_expr_aq[address((value2))] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) | (0x0100 * (arg3 & (0xff)))); require((var_e.length) <= 0xffffffffffffffffffffffff, "SafeCast: value doesn't fit in 96 bits"); mapping_expr_aq[value2 & (0xffffffffffffffffffffffffffffffffffffffff)] = (uint96((var_e.length)) * 0x010000) | (0xffffffffffffffffffffffffffffffffffff000000000000000000000000ffff & mapping_expr_aq[(value2) & (0xffffffffffffffffffffffffffffffffffffffff)]); mapping_5[arg4] = mapping_5[arg4] + 0x01; stor_expr_at = (value2 & (0xffffffffffffffffffffffffffffffffffffffff)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_at); if ((arg3 & 0xff) != 0x0) { uint256 value19 = stor_expr_au; uint256 value20 = 0x07 + (keccak256(abi.encode(arg4, 0x04))); if (0x1 != (arg3 & 0xff)) { require((0x02 == (bytes1(arg3))), "GovernorCompatibilityBravo: invalid vote type"); } else { value19 = stor_expr_av; value20 = 0x05 + (keccak256(abi.encode(arg4, 0x04))); } stor_expr_ba = value19 + (var_e.length); } else { stor_expr_ax = stor_expr_ax + (var_e.length); } uint256 value8 = 0; while (true) { uint256 value21 = value8; if (value8 >= var_av) { break; } if (0x20 + value8 >= var_av) { break; } value8 = 0x20 + (0x20 + value8); value21 = 0x20 + value8; } emit VoteCast(address(value2), arg4, bytes1(arg3), (var_e.length), 0x80, var_av); return var_e.length; } if (!(0x4 <= 0x7)) _desolexPanic(33); if (mapping_8[arg4] != 0x0) { require(timelock.code.length != 0x0); (bool success6, bytes memory returnData6) = timelock.isOperationDone(mapping_8[arg4]); // staticcall require(success6); var_e = var_e + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_e + returnData6.length) - var_e >= 0x20); require(var_al == var_al); if (var_e.length == 0) { if (!(0x5 <= 0x7)) _desolexPanic(33); require(0x5 == 0x1, "Governor: vote not currently active"); require(provider.code.length != 0x0); (bool success7, bytes memory returnData7) = provider.getPastVotes(address((value2)), uint64(proposalSnapshot[arg4])); // staticcall require(success7); require((var_e + returnData7.length) - var_e >= 0x20); require(!(bytes1(mapping_expr_aq[address((value2))])), "GovernorCompatibilityBravo: vote already cast"); mapping_expr_aq[address((value2))] = 0x01 | (mapping_expr_aq[address((value2))] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) | (0x0100 * (arg3 & (0xff)))); require((var_e.length) <= 0xffffffffffffffffffffffff, "SafeCast: value doesn't fit in 96 bits"); mapping_expr_aq[value2 & (0xffffffffffffffffffffffffffffffffffffffff)] = (uint96((var_e.length)) * 0x010000) | (0xffffffffffffffffffffffffffffffffffff000000000000000000000000ffff & mapping_expr_aq[(value2) & (0xffffffffffffffffffffffffffffffffffffffff)]); mapping_5[arg4] = mapping_5[arg4] + 0x01; stor_expr_at = (value2 & (0xffffffffffffffffffffffffffffffffffffffff)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_at); if ((arg3 & 0xff) != 0x0) { uint256 value24 = stor_expr_au; uint256 value25 = 0x07 + (keccak256(abi.encode(arg4, 0x04))); if (0x1 != (arg3 & 0xff)) { require((0x02 == (bytes1(arg3))), "GovernorCompatibilityBravo: invalid vote type"); } else { value24 = stor_expr_av; value25 = 0x05 + (keccak256(abi.encode(arg4, 0x04))); } stor_expr_bb = value24 + (var_e.length); } else { stor_expr_ax = stor_expr_ax + (var_e.length); } uint256 value8 = 0; while (true) { uint256 value26 = value8; if (value8 >= var_av) { break; } if (0x20 + value8 >= var_av) { break; } value8 = 0x20 + (0x20 + value8); value26 = 0x20 + value8; } } else { if (!(0x7 <= 0x7)) _desolexPanic(33); require(0x7 == 0x1, "Governor: vote not currently active"); require(provider.code.length != 0x0); (bool success8, bytes memory returnData8) = provider.getPastVotes(address((value2)), uint64(proposalSnapshot[arg4])); // staticcall require(success8); var_e = var_e + ((returnData8.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_e + returnData8.length) - var_e >= 0x20); require(!(bytes1(mapping_expr_aq[address((value2))])), "GovernorCompatibilityBravo: vote already cast"); mapping_expr_aq[address((value2))] = 0x01 | (mapping_expr_aq[address((value2))] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) | (0x0100 * (arg3 & (0xff)))); require((var_e.length) <= 0xffffffffffffffffffffffff, "SafeCast: value doesn't fit in 96 bits"); mapping_expr_aq[value2 & (0xffffffffffffffffffffffffffffffffffffffff)] = (uint96((var_e.length)) * 0x010000) | (0xffffffffffffffffffffffffffffffffffff000000000000000000000000ffff & mapping_expr_aq[(value2) & (0xffffffffffffffffffffffffffffffffffffffff)]); mapping_5[arg4] = mapping_5[arg4] + 0x01; stor_expr_at = (value2 & (0xffffffffffffffffffffffffffffffffffffffff)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_at); if ((arg3 & 0xff) != 0x0) { uint256 value28 = stor_expr_au; uint256 value29 = 0x07 + (keccak256(abi.encode(arg4, 0x04))); if (0x1 != (arg3 & 0xff)) { require((0x02 == (bytes1(arg3))), "GovernorCompatibilityBravo: invalid vote type"); } else { value28 = stor_expr_av; value29 = 0x05 + (keccak256(abi.encode(arg4, 0x04))); } stor_expr_bc = value28 + (var_e.length); } else { stor_expr_ax = stor_expr_ax + (var_e.length); } uint256 value8 = 0; while (true) { uint256 value30 = value8; if (value8 >= var_av) { break; } if (0x20 + value8 >= var_av) { break; } value8 = 0x20 + (0x20 + value8); value30 = 0x20 + value8; } } emit VoteCast(address(value2), arg4, bytes1(arg3), (var_e.length), 0x80, var_av); } else { require(0x4 == 0x1, "Governor: vote not currently active"); require(provider.code.length != 0x0); (bool success9, bytes memory returnData9) = provider.getPastVotes(address((value2)), uint64(proposalSnapshot[arg4])); // staticcall require(success9); var_e = var_e + ((returnData9.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_e + returnData9.length) - var_e >= 0x20); require(!(bytes1(mapping_expr_aq[address((value2))])), "GovernorCompatibilityBravo: vote already cast"); mapping_expr_aq[address((value2))] = 0x01 | (mapping_expr_aq[address((value2))] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) | (0x0100 * (arg3 & (0xff)))); require((var_e.length) <= 0xffffffffffffffffffffffff, "SafeCast: value doesn't fit in 96 bits"); mapping_expr_aq[value2 & (0xffffffffffffffffffffffffffffffffffffffff)] = (uint96((var_e.length)) * 0x010000) | (0xffffffffffffffffffffffffffffffffffff000000000000000000000000ffff & mapping_expr_aq[(value2) & (0xffffffffffffffffffffffffffffffffffffffff)]); mapping_5[arg4] = mapping_5[arg4] + 0x01; stor_expr_at = (value2 & (0xffffffffffffffffffffffffffffffffffffffff)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_at); if ((arg3 & 0xff) != 0x0) { uint256 value32 = stor_expr_au; uint256 value33 = 0x07 + (keccak256(abi.encode(arg4, 0x04))); if (0x1 != (arg3 & 0xff)) { require((0x02 == (bytes1(arg3))), "GovernorCompatibilityBravo: invalid vote type"); } else { value32 = stor_expr_av; value33 = 0x05 + (keccak256(abi.encode(arg4, 0x04))); } stor_expr_bd = value32 + (var_e.length); } else { stor_expr_ax = stor_expr_ax + (var_e.length); } uint256 value8 = 0; while (true) { uint256 value34 = value8; if (value8 >= var_av) { break; } if (0x20 + value8 >= var_av) { break; } value8 = 0x20 + (0x20 + value8); value34 = 0x20 + value8; } emit VoteCast(address(value2), arg4, bytes1(arg3), (var_e.length), 0x80, var_av); } return var_e.length; } } else { value50 = 0; } value49 = value50; } else { value49 = 0x02; } value39 = value49; } else { value39 = 0x07; } if (!(value39 <= 0x7)) _desolexPanic(33); uint256 value41; if (value39 == 0x4) { uint256 value51; if (mapping_8[arg4] != 0x0) { require(timelock.code.length != 0x0); (bool success11, bytes memory returnData11) = timelock.isOperationDone(mapping_8[arg4]); // staticcall require(success11); var_e = var_e + ((returnData11.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_e + returnData11.length) - var_e >= 0x20); require(var_al == var_al); uint256 value52 = 0x05; if (var_e.length != 0) { value52 = 0x07; } value51 = value52; } else { value51 = value39; } value41 = value51; } else { value41 = value39; } if (!(value41 <= 0x7)) _desolexPanic(33); require(value41 == 0x1, "Governor: vote not currently active"); require(provider.code.length != 0x0); (bool success12, bytes memory returnData12) = provider.getPastVotes(address((value2)), uint64(proposalSnapshot[arg4])); // staticcall require(success12); var_e = var_e + ((returnData12.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_e + returnData12.length) - var_e >= 0x20); require(!(bytes1(mapping_expr_aq[address((value2))])), "GovernorCompatibilityBravo: vote already cast"); mapping_expr_aq[address((value2))] = 0x01 | (mapping_expr_aq[address((value2))] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff0000) | (0x0100 * (arg3 & (0xff)))); require((var_e.length) <= 0xffffffffffffffffffffffff, "SafeCast: value doesn't fit in 96 bits"); mapping_expr_aq[value2 & (0xffffffffffffffffffffffffffffffffffffffff)] = (uint96((var_e.length)) * 0x010000) | (0xffffffffffffffffffffffffffffffffffff000000000000000000000000ffff & mapping_expr_aq[(value2) & (0xffffffffffffffffffffffffffffffffffffffff)]); mapping_5[arg4] = mapping_5[arg4] + 0x01; stor_expr_at = (value2 & (0xffffffffffffffffffffffffffffffffffffffff)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_at); if ((arg3 & 0xff) != 0x0) { uint256 value43 = stor_expr_au; uint256 value44 = 0x07 + (keccak256(abi.encode(arg4, 0x04))); if (0x1 != (arg3 & 0xff)) { require((0x02 == (bytes1(arg3))), "GovernorCompatibilityBravo: invalid vote type"); } else { value43 = stor_expr_av; value44 = 0x05 + (keccak256(abi.encode(arg4, 0x04))); } stor_expr_bf = value43 + (var_e.length); } else { stor_expr_ax = stor_expr_ax + (var_e.length); } uint256 value8 = 0; while (true) { if (value8 >= var_av) { break; } value8 = 0x20 + value8; emit VoteCast(address(value2), arg4, bytes1(arg3), (var_e.length), 0x80, var_av); } } function internal_1682(address account, bytes32 role) private { // Decompilation incomplete: helper effect provenance is conservative. if (!((bytes1(isProposer[stor_expr_dc][msg.sender])) != 0x0)) { if (!(0x2 + 0x2 * 0x14 <= 0xffffffffffffffff)) _desolexPanic(65); uint256 var_d; var_d = var_d + (0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + (0x02 + (0x02 * 0x14))))); uint256 value0 = 0x02 + (0x02 * 0x14); if (0x02 + (0x02 * 0x14) != 0) { value0 = (0x02 + (0x02 * 0x14)) + (var_d + 0x20); } if (!(0 < var_d.length)) _desolexPanic(50); if (!(0x01 < var_d.length)) _desolexPanic(50); uint256 value1 = 0x01 + (0x02 * 0x14); uint256 value2 = address(msg.sender); uint256 value4; while (true) { uint256 value3 = value1; value4 = value2; if (value1 <= 0x1) { break; } if (!((0xf & value2) < 0x10)) _desolexPanic(50); if (!(value1 < var_d.length)) _desolexPanic(50); if (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1 <= 0x1) { break; } if (!(0x0f & (value2 >> 0x04) < 0x10)) _desolexPanic(50); if (!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1) < var_d.length)) _desolexPanic(50); value1 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1); value2 = (value2 >> 0x04) >> 0x04; value3 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1; value4 = value2 >> 0x04; } require(value4 == 0x0, "Strings: hex length insufficient"); if (!(0x2 + 0x2 * 0x20 <= 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + (0x02 + (0x02 * 0x20))))); uint256 value5 = 0x02 + (0x02 * 0x20); if (0x02 + (0x02 * 0x20) != 0) { value5 = (0x02 + (0x02 * 0x20)) + (var_d + 0x20); } if (!(0 < var_d.length)) _desolexPanic(50); if (!(0x01 < var_d.length)) _desolexPanic(50); value1 = 0x01 + (0x02 * 0x20); value2 = stor_expr_dc; uint256 value7; while (true) { uint256 value6 = value1; value7 = value2; if (value1 <= 0x1) { break; } if (!((0xf & value2) < 0x10)) _desolexPanic(50); if (!(value1 < var_d.length)) _desolexPanic(50); if (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1 <= 0x1) { break; } if (!(0x0f & (value2 >> 0x04) < 0x10)) _desolexPanic(50); if (!((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1) < var_d.length)) _desolexPanic(50); value1 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1); value2 = (value2 >> 0x04) >> 0x04; value6 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value1; value7 = value2 >> 0x04; } require(value7 == 0x0, "Strings: hex length insufficient"); uint256 value8 = 0; while (true) { if (value8 >= var_p) { break; } value8 = 0x20 + value8; uint256 value8 = 0; while (true) { if (value8 >= var_t) { break; } value8 = 0x20 + value8; var_d = (0x28 + (var_x + ((0x20 + var_d) + var_y))); uint256 value8 = 0; while (true) { if (value8 >= var_d.length) { break; } value8 = 0x20 + value8; revert("\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00"); } } } } if ((bytes1(isProposer[role][account]))) { isProposer[role][account] = false; emit RoleRevoked(role, account, msg.sender); } } function internal_16a9(uint256 arg0, uint256 arg1, uint256 arg2) private { // Decompilation incomplete: helper effect provenance is conservative. uint256 value0 = mapping_5[arg2] + arg0; uint256 value1 = mapping_5[arg2]; if (arg1 < mapping_5[arg2]) { value0 = arg1 + arg0; value1 = (arg1) ? 1 : 0; } uint256 value2 = mapping_5[arg2] - value1; uint256 value4 = mapping_5[arg2]; if (value0 < mapping_5[arg2]) { value2 = (value1 + arg0) - value1; value4 = value1 + arg0; } if (!(value2 <= 0xffffffffffffffff)) _desolexPanic(65); uint256 var_d; var_d = var_d + (0x20 + (0x20 * value2)); uint256 value3 = value2; if (value2 != 0x0) { value3 = (value2 * 0x20) + (0x20 + var_d); } uint256 value5 = value1; uint256 value6 = 0; while (true) { if (value5 >= value4) { break; } if (!(value5 < mapping_5[arg2])) _desolexPanic(50); if (!((value5 - value1) < var_d.length)) _desolexPanic(50); value5 = 0x01 + value5; value6 = value5 - value1; uint256 value7 = 0; uint256 value8 = var_d + 0x20; uint256 value9 = (var_d + 0x20) + 0x20; while (true) { if (!(value7 < var_d.length)) { break; } value7 = 0x01 + value7; value8 = 0x20 + value8; value9 = 0x20 + value9; } return abi.encodePacked(0x20, var_d.length); } } 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. // 0x013cf08b => proposals(uint256) // 0x01ffc9a7 => supportsInterface(bytes4) // 0x02a251a3 => votingPeriod() // 0x06f3f9e6 => updateQuorumNumerator(uint256) // 0x06fdde03 => name() // 0x085d4883 => provider() // 0x160cbed7 => queue(address[],uint256[],bytes[],bytes32) // 0x248a9ca3 => getRoleAdmin(bytes32) // 0x24bc1a64 => quorumVotes() // 0x2656227d => execute(address[],uint256[],bytes[],bytes32) // 0x2d63f693 => proposalSnapshot(uint256) // 0x2f2ff15d => grantRole(bytes32,address) // 0x328dd982 => getActions(uint256) // 0x36568abe => renounceRole(bytes32,address) // 0x3932abb1 => votingDelay() // 0x3a46b1a8 => getPastVotes(address,uint256) // 0x3bccf4fd => Unknown_3bccf4fd(bytes32,bool,bool,uint256,uint256) // 0x3e4f49e6 => state(uint256) // 0x40e58ee5 => cancel(uint256) // 0x43859632 => hasVoted(uint256,address) // 0x54fd4d50 => version() // 0x56781388 => castVote(uint256,uint8) // 0x5ed876da => delProposer(address) // 0x70b0f660 => setVotingDelay(uint256) // 0x715018a6 => renounceOwnership() // 0x74ec29a0 => isProposer(address) // 0x75b238fc => ADMIN_ROLE() // 0x7b3c71d3 => castVoteWithReason(uint256,uint8,string) // 0x7d5e81e2 => propose(address[],uint256[],bytes[],string) // 0x8da5cb5b => owner() // 0x8e539e8c => getPastTotalSupply(uint256) // 0x8f61f4f5 => PROPOSER_ROLE() // 0x91d14854 => hasRole(bytes32,address) // 0x97c3d334 => quorumDenominator() // 0xa217fddf => DEFAULT_ADMIN_ROLE() // 0xa7713a70 => quorumNumerator() // 0xa890c910 => updateTimelock(address) // 0xab58fb8e => proposalEta(uint256) // 0xb03cd418 => addProposer(address) // 0xb58131b0 => proposalThreshold() // 0xc01f9e37 => proposalDeadline(uint256) // 0xc59057e4 => hashProposal(address[],uint256[],bytes[],bytes32) // 0xd33219b4 => timelock() // 0xd547741f => revokeRole(bytes32,address) // 0xd9e2b4d3 => getVoters(uint256,uint256,uint256) // 0xda95691a => propose(address[],uint256[],string[],bytes[],string) // 0xdd4e2ba5 => COUNTING_MODE() // 0xddf0b009 => queue(uint256) // 0xdeaaa7cc => BALLOT_TYPEHASH() // 0xe23a9a52 => getReceipt(uint256,address) // 0xea0217cf => setVotingPeriod(uint256) // 0xeb9019d4 => getVotes(address,uint256) // 0xece40cc1 => setProposalThreshold(uint256) // 0xf2fde38b => transferOwnership(address) // 0xf8ce560a => quorum(uint256) // 0xfe0d94c1 => execute(uint256)}