BNB Chain
0x21bfc273b2d4bc4b29ec86157660088d4af7dd37
Decompiled Solidity recovered from this contract's runtime bytecode. Best-effort reconstruction — confirm behaviour against on-chain state.
Decompilation outputBNB Chain · 0x21bfc273…4af7dd375.7 KB26.7 s
This result is permanently available athttps://decompiler.exvul.com/bsc/0x21bfc273b2d4bc4b29ec86157660088d4af7dd37
//decompiled by exvvul decompiler tool contact@exvul.com https://x.com/exvulsec
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;
contract DesolexContract {
uint256 public constant GOVERNANCE_ROLE = 51344670724517732003549907689393193919197804398902247150944709319656146718385;
uint256 public constant MAX_RATE_PER_SECOND = 1000000000000000000000;
uint256 public constant totalLiability = 0;
uint256 public constant hasOpenPositions = 0;
uint256 public constant DEFAULT_ADMIN_ROLE = 0;
address public constant rewardMinter = address(0x7d32e67c6f4972fb288e034f465444daf000d9d3);
address public constant protocolRegistry = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593);
uint256 public constant moduleKey = 60600748203901680582727323601164208577868609738685759654755141493035622499885;
uint256 public constant RATE_PRECISION = 1000000000000000000000000000;
uint256 public constant interfaceVersion = 1;
address public constant protocolToken = address(0x61e91daf03a49ecec334bffbf5008860cfb33333);
mapping(bytes32 => mapping(address => bool)) public hasRole; // STORAGE[0x0]
mapping(bytes32 => uint256) public getRoleMemberCount; // STORAGE[0x1]
mapping(bytes32 => bytes32) mapping_2; // STORAGE[0x2] // DESOLEX_RAW_STORAGE: mapping value 0: uint192 [ArithmeticUse] vs uint256 [ArithmeticUse] (ambiguous) | mapping value 0: uint192 [ArithmeticUse] vs uint96 [ArithmeticUse] (ambiguous) | mapping value 0: uint256 [ArithmeticUse] vs uint96 [ArithmeticUse] (ambiguous)
mapping(address => bool) mapping_316a51056d8b2401ab04c48d9973add294eadde229c785c6d19cde93785467ef; // STORAGE[0x316a51056d8b2401ab04c48d9973add294eadde229c785c6d19cde93785467ef]
mapping(address => uint256) mapping_expr_aa;
mapping(address => uint256) mapping_expr_ak;
mapping(address => uint256) mapping_expr_h;
bytes32 stor_expr_ad;
uint256 stor_expr_ae;
bytes32 stor_expr_af;
uint256 stor_expr_ah;
uint256 stor_expr_aj;
address stor_expr_al;
bool stor_expr_b;
bytes32 stor_expr_e;
uint256 stor_expr_i;
uint256 stor_expr_j;
uint256 stor_expr_k;
bytes32 stor_expr_m;
bytes32 stor_expr_n;
bytes32 stor_expr_o;
uint256 stor_expr_q;
bytes32 stor_expr_r;
bool stor_expr_t;
uint256 stor_expr_u;
bytes32 stor_expr_x;
error InvalidEpoch();
event RoleRevoked(bytes32 indexed, address indexed, address indexed);
error AccessControlBadConfirmation();
error EpochAlreadyDistributed();
error AccessControlUnauthorizedAccount(address, bytes32);
error RateTooHigh();
event Event_5eac0795(uint256 indexed, uint256, uint256, uint256, uint256);
error InvalidChannel();
event RoleGranted(bytes32 indexed, address indexed, address indexed);
event Event_e6620a82(uint256 indexed, uint256, uint256, uint256, uint256);
function _desolexPanic(uint256 code) private pure {
assembly ("memory-safe") {
mstore(0x00, shl(224, 0x4e487b71))
mstore(0x04, code)
revert(0x00, 0x24)
}
}
fallback() external {
// Synthetic compatibility routes preserve original selectors for unresolved names.
if ((msg.data.length >= 4) && (msg.sig == 0x5ff37c18)) {
// Route to Unknown_5ff37c18(uint256,uint96) after replacing only msg.sig.
__desolexSelectorShim(uint32(0x21c8f06d));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x6f3e4849)) {
// Route to Unknown_6f3e4849(uint256,bool) after replacing only msg.sig.
__desolexSelectorShim(uint32(0x2d867be4));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x9010d07c)) {
// Route to Unknown_9010d07c(uint256,uint256) after replacing only msg.sig.
__desolexSelectorShim(uint32(0xb656a175));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0xa3246ad3)) {
// Route to Unknown_a3246ad3(uint256) after replacing only msg.sig.
__desolexSelectorShim(uint32(0x1cf458ec));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0xbd0ecdcb)) {
// Route to Unknown_bd0ecdcb(uint256) after replacing only msg.sig.
__desolexSelectorShim(uint32(0x22b3eea1));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0xe3e866ee)) {
// Route to Unknown_e3e866ee(uint256) after replacing only msg.sig.
__desolexSelectorShim(uint32(0x15523ec3));
return;
}
revert();
}
function distribute() public payable {
if (!(msg.value)) {
if ((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) >= 0) {
var_b = var_b;
(bool success0, bytes memory returnData0) = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_b); // staticcall
if (success0) {
uint256 value0 = 0;
uint256 var_d;
uint256 value1 = var_d.length;
if (success0) {
if (0x20 > returnData0.length) {
if (((var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + returnData0.length) - var_d) >= 0x20);
} else {
if (((var_d + 0x20) > 0xffffffffffffffff) | ((var_d + 0x20) < var_d)) _desolexPanic(65);
var_d = var_d + 0x20;
require(((var_d + 0x20) - var_d) >= 0x20);
}
require(var_d.length == (address(var_d.length)));
} else {
value0 = var_d;
value1 = 0;
}
(bool success1, bytes memory returnData1) = address(value1).currentEpoch(); // staticcall
if (success1) {
if (success1) {
if (0x20 <= returnData1.length) {
if (((var_d + 0x20) > 0xffffffffffffffff) | ((var_d + 0x20) < var_d)) _desolexPanic(65);
var_d = var_d + 0x20;
require(((var_d + 0x20) - var_d) >= 0x20);
require(var_d.length == (uint64(var_d.length)));
if (uint64(var_d.length)) {
(bool success2, bytes memory returnData2) = address(0x7d32e67c6f4972fb288e034f465444daf000d9d3).lastDistributedEpoch(); // staticcall
if (success2) {
if (!(success2)) {
if (uint64(var_d.length) > 0) {
(bool success3, bytes memory returnData3) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).totalSupply(); // staticcall
if (success3) {
uint256 value3 = 0;
uint256 value70 = var_d.length;
if (success3) {
uint256 value2 = returnData3.length;
if (0x20 <= returnData3.length) {
value2 = 0x20;
}
if (((var_d + ((value2 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value2 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value2 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value2) - var_d) >= 0x20);
} else {
value3 = var_d;
value70 = 0;
}
var_b = var_b;
(bool success4, bytes memory returnData4) = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_b); // staticcall
if (success4) {
if (!(success4)) {
(bool success5, bytes memory returnData5) = address(0).epochLength(); // staticcall
if (success5) {
uint256 value5 = 0;
uint256 value6 = var_d.length;
if (success5) {
uint256 value4 = returnData5.length;
if (0x20 <= returnData5.length) {
value4 = 0x20;
}
if (((var_d + ((value4 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value4 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value4 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value4) - var_d) >= 0x20);
require(var_d.length == (uint64(var_d.length)));
} else {
value5 = var_d;
value6 = 0;
}
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
var_b = var_b;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
}
}
}
}
}
}
}
}
}
} else {
require(0, InvalidEpoch());
(bool success6, bytes memory returnData6) = address(0x7d32e67c6f4972fb288e034f465444daf000d9d3).lastDistributedEpoch(); // staticcall
require(success6);
if (success6) {
if (0x20 > returnData6.length) {
if (((var_d + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + returnData6.length) - var_d) >= 0x20);
require(var_d.length == (uint64(var_d.length)));
require(0 > (uint64(var_d.length)), EpochAlreadyDistributed());
(bool success7, bytes memory returnData7) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).totalSupply(); // staticcall
require(success7);
uint256 value8 = 0;
uint256 value15 = var_d.length;
if (success7) {
uint256 value7 = returnData7.length;
if (0x20 <= returnData7.length) {
value7 = 0x20;
}
if (((var_d + ((value7 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value7 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value7 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value7) - var_d) >= 0x20);
} else {
value8 = var_d;
value15 = 0;
}
var_b = var_b;
(bool success8, bytes memory returnData8) = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_b); // staticcall
require(success8);
if (success8) {
if (0x20 > returnData8.length) {
if (((var_d + ((returnData8.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((returnData8.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((returnData8.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + returnData8.length) - var_d) >= 0x20);
require(var_d.length == (address(var_d.length)));
(bool success9, bytes memory returnData9) = address(var_d.length).epochLength(); // staticcall
require(success9);
uint256 value10 = 0;
uint256 value11 = var_d.length;
if (success9) {
uint256 value9 = returnData9.length;
if (0x20 <= returnData9.length) {
value9 = 0x20;
}
if (((var_d + ((value9 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value9 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value9 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value9) - var_d) >= 0x20);
require(var_d.length == (uint64(var_d.length)));
} else {
value10 = var_d;
value11 = 0;
}
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
var_b = var_b;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (!(0x0 < 0x3)) _desolexPanic(50);
uint256 value12 = 0;
bool flag0 = !(0 < (mapping_2[var_n] >> 0xc0));
if (!(mapping_2[var_n] >> 0xc0)) {
value12 = mapping_2[var_n] >> 0xc0;
flag0 = !(!(mapping_2[var_n] >> 0xc0));
}
uint256 value13 = 0;
if (flag0) {
mapping_2[var_n] = (0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000 & mapping_2[var_n]) | ((mapping_2[var_n] >> 0x60) & (0xffffffffffffffffffffffff));
mapping_2[var_n] = uint192(mapping_2[var_n]);
} else {
value13 = mapping_2[var_n];
}
uint256 value14 = 0;
bool flag1 = !(0 < (uint64(stor_expr_b)));
if (!(uint64(stor_expr_b))) {
value14 = uint64(stor_expr_b);
flag1 = !(!(uint64(stor_expr_b)));
}
if (flag1) {
stor_expr_b = (0xff0000000000000000 & ((!(!(0xff & (stor_expr_b >> 0x48)))) << 0x40)) | (stor_expr_b & (0xffffffffffffffffffffffffffffffffffffffffffffff000000000000000000));
address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_n); // staticcall
} else {
address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_n); // staticcall
}
} else {
if (((var_d + 0x20) > 0xffffffffffffffff) | ((var_d + 0x20) < var_d)) _desolexPanic(65);
var_d = var_d + 0x20;
require(((var_d + 0x20) - var_d) >= 0x20);
require(var_d.length == (address(var_d.length)));
(bool success12, bytes memory returnData12) = address(var_d.length).epochLength(); // staticcall
require(success12);
uint256 value17 = 0;
uint256 value18 = var_d.length;
if (success12) {
uint256 value16 = returnData12.length;
if (0x20 <= returnData12.length) {
value16 = 0x20;
}
if (((var_d + ((value16 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value16 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value16 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value16) - var_d) >= 0x20);
require(var_d.length == (uint64(var_d.length)));
} else {
value17 = var_d;
value18 = 0;
}
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
var_b = var_b;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (!(0x0 < 0x3)) _desolexPanic(50);
uint256 value19 = 0;
bool flag2 = !(0 < (mapping_2[var_n] >> 0xc0));
if (!(mapping_2[var_n] >> 0xc0)) {
value19 = mapping_2[var_n] >> 0xc0;
flag2 = !(!(mapping_2[var_n] >> 0xc0));
}
uint256 value20 = 0;
if (flag2) {
mapping_2[var_n] = (0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000 & mapping_2[var_n]) | ((mapping_2[var_n] >> 0x60) & (0xffffffffffffffffffffffff));
mapping_2[var_n] = uint192(mapping_2[var_n]);
} else {
value20 = mapping_2[var_n];
}
uint256 value21 = 0;
bool flag3 = !(0 < (uint64(stor_expr_b)));
if (!(uint64(stor_expr_b))) {
value21 = uint64(stor_expr_b);
flag3 = !(!(uint64(stor_expr_b)));
}
if (flag3) {
stor_expr_b = (0xff0000000000000000 & ((!(!(0xff & (stor_expr_b >> 0x48)))) << 0x40)) | (stor_expr_b & (0xffffffffffffffffffffffffffffffffffffffffffffff000000000000000000));
address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_n); // staticcall
} else {
address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_n); // staticcall
}
}
} else {
(bool success15, bytes memory returnData15) = address(0).epochLength(); // staticcall
require(success15);
uint256 value23 = 0;
uint256 value24 = var_d.length;
if (success15) {
uint256 value22 = returnData15.length;
if (0x20 <= returnData15.length) {
value22 = 0x20;
}
if (((var_d + ((value22 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value22 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value22 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value22) - var_d) >= 0x20);
require(var_d.length == (uint64(var_d.length)));
} else {
value23 = var_d;
value24 = 0;
}
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
var_b = var_b;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (!(0x0 < 0x3)) _desolexPanic(50);
uint256 value25 = 0;
bool flag4 = !(0 < (mapping_2[var_n] >> 0xc0));
if (!(mapping_2[var_n] >> 0xc0)) {
value25 = mapping_2[var_n] >> 0xc0;
flag4 = !(!(mapping_2[var_n] >> 0xc0));
}
uint256 value26 = 0;
if (flag4) {
mapping_2[var_n] = (0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000 & mapping_2[var_n]) | ((mapping_2[var_n] >> 0x60) & (0xffffffffffffffffffffffff));
mapping_2[var_n] = uint192(mapping_2[var_n]);
} else {
value26 = mapping_2[var_n];
}
uint256 value27 = 0;
bool flag5 = !(0 < (uint64(stor_expr_b)));
if (!(uint64(stor_expr_b))) {
value27 = uint64(stor_expr_b);
flag5 = !(!(uint64(stor_expr_b)));
}
if (flag5) {
stor_expr_b = (0xff0000000000000000 & ((!(!(0xff & (stor_expr_b >> 0x48)))) << 0x40)) | (stor_expr_b & (0xffffffffffffffffffffffffffffffffffffffffffffff000000000000000000));
address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_n); // staticcall
} else {
address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_n); // staticcall
}
}
} else {
if (((var_d + 0x20) > 0xffffffffffffffff) | ((var_d + 0x20) < var_d)) _desolexPanic(65);
var_d = var_d + 0x20;
require(((var_d + 0x20) - var_d) >= 0x20);
require(var_d.length == (uint64(var_d.length)));
require(0 > (uint64(var_d.length)), EpochAlreadyDistributed());
(bool success18, bytes memory returnData18) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).totalSupply(); // staticcall
require(success18);
uint256 value29 = 0;
uint256 value36 = var_d.length;
if (success18) {
uint256 value28 = returnData18.length;
if (0x20 <= returnData18.length) {
value28 = 0x20;
}
if (((var_d + ((value28 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value28 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value28 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value28) - var_d) >= 0x20);
} else {
value29 = var_d;
value36 = 0;
}
var_b = var_b;
(bool success19, bytes memory returnData19) = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_b); // staticcall
require(success19);
if (success19) {
if (0x20 > returnData19.length) {
if (((var_d + ((returnData19.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((returnData19.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((returnData19.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + returnData19.length) - var_d) >= 0x20);
require(var_d.length == (address(var_d.length)));
(bool success20, bytes memory returnData20) = address(var_d.length).epochLength(); // staticcall
require(success20);
uint256 value31 = 0;
uint256 value32 = var_d.length;
if (success20) {
uint256 value30 = returnData20.length;
if (0x20 <= returnData20.length) {
value30 = 0x20;
}
if (((var_d + ((value30 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value30 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value30 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value30) - var_d) >= 0x20);
require(var_d.length == (uint64(var_d.length)));
} else {
value31 = var_d;
value32 = 0;
}
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
var_b = var_b;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (!(0x0 < 0x3)) _desolexPanic(50);
uint256 value33 = 0;
bool flag6 = !(0 < (mapping_2[var_n] >> 0xc0));
if (!(mapping_2[var_n] >> 0xc0)) {
value33 = mapping_2[var_n] >> 0xc0;
flag6 = !(!(mapping_2[var_n] >> 0xc0));
}
uint256 value34 = 0;
if (flag6) {
mapping_2[var_n] = (0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000 & mapping_2[var_n]) | ((mapping_2[var_n] >> 0x60) & (0xffffffffffffffffffffffff));
mapping_2[var_n] = uint192(mapping_2[var_n]);
} else {
value34 = mapping_2[var_n];
}
uint256 value35 = 0;
bool flag7 = !(0 < (uint64(stor_expr_b)));
if (!(uint64(stor_expr_b))) {
value35 = uint64(stor_expr_b);
flag7 = !(!(uint64(stor_expr_b)));
}
if (flag7) {
stor_expr_b = (0xff0000000000000000 & ((!(!(0xff & (stor_expr_b >> 0x48)))) << 0x40)) | (stor_expr_b & (0xffffffffffffffffffffffffffffffffffffffffffffff000000000000000000));
address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_n); // staticcall
} else {
address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_n); // staticcall
}
} else {
if (((var_d + 0x20) > 0xffffffffffffffff) | ((var_d + 0x20) < var_d)) _desolexPanic(65);
var_d = var_d + 0x20;
require(((var_d + 0x20) - var_d) >= 0x20);
require(var_d.length == (address(var_d.length)));
(bool success23, bytes memory returnData23) = address(var_d.length).epochLength(); // staticcall
require(success23);
uint256 value38 = 0;
uint256 value39 = var_d.length;
if (success23) {
uint256 value37 = returnData23.length;
if (0x20 <= returnData23.length) {
value37 = 0x20;
}
if (((var_d + ((value37 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value37 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value37 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value37) - var_d) >= 0x20);
require(var_d.length == (uint64(var_d.length)));
} else {
value38 = var_d;
value39 = 0;
}
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
var_b = var_b;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (!(0x0 < 0x3)) _desolexPanic(50);
uint256 value40 = 0;
bool flag8 = !(0 < (mapping_2[var_n] >> 0xc0));
if (!(mapping_2[var_n] >> 0xc0)) {
value40 = mapping_2[var_n] >> 0xc0;
flag8 = !(!(mapping_2[var_n] >> 0xc0));
}
uint256 value41 = 0;
if (flag8) {
mapping_2[var_n] = (0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000 & mapping_2[var_n]) | ((mapping_2[var_n] >> 0x60) & (0xffffffffffffffffffffffff));
mapping_2[var_n] = uint192(mapping_2[var_n]);
} else {
value41 = mapping_2[var_n];
}
uint256 value42 = 0;
bool flag9 = !(0 < (uint64(stor_expr_b)));
if (!(uint64(stor_expr_b))) {
value42 = uint64(stor_expr_b);
flag9 = !(!(uint64(stor_expr_b)));
}
if (flag9) {
stor_expr_b = (0xff0000000000000000 & ((!(!(0xff & (stor_expr_b >> 0x48)))) << 0x40)) | (stor_expr_b & (0xffffffffffffffffffffffffffffffffffffffffffffff000000000000000000));
address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_n); // staticcall
} else {
address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_n); // staticcall
}
}
} else {
(bool success26, bytes memory returnData26) = address(0).epochLength(); // staticcall
require(success26);
uint256 value44 = 0;
uint256 value45 = var_d.length;
if (success26) {
uint256 value43 = returnData26.length;
if (0x20 <= returnData26.length) {
value43 = 0x20;
}
if (((var_d + ((value43 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value43 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value43 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value43) - var_d) >= 0x20);
require(var_d.length == (uint64(var_d.length)));
} else {
value44 = var_d;
value45 = 0;
}
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
var_b = var_b;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (!(0x0 < 0x3)) _desolexPanic(50);
uint256 value46 = 0;
bool flag10 = !(0 < (mapping_2[var_n] >> 0xc0));
if (!(mapping_2[var_n] >> 0xc0)) {
value46 = mapping_2[var_n] >> 0xc0;
flag10 = !(!(mapping_2[var_n] >> 0xc0));
}
uint256 value47 = 0;
if (flag10) {
mapping_2[var_n] = (0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000 & mapping_2[var_n]) | ((mapping_2[var_n] >> 0x60) & (0xffffffffffffffffffffffff));
mapping_2[var_n] = uint192(mapping_2[var_n]);
} else {
value47 = mapping_2[var_n];
}
uint256 value48 = 0;
bool flag11 = !(0 < (uint64(stor_expr_b)));
if (!(uint64(stor_expr_b))) {
value48 = uint64(stor_expr_b);
flag11 = !(!(uint64(stor_expr_b)));
}
if (flag11) {
stor_expr_b = (0xff0000000000000000 & ((!(!(0xff & (stor_expr_b >> 0x48)))) << 0x40)) | (stor_expr_b & (0xffffffffffffffffffffffffffffffffffffffffffffff000000000000000000));
address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_n); // staticcall
} else {
address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_n); // staticcall
}
}
}
} else {
require(0 > 0, EpochAlreadyDistributed());
(bool success29, bytes memory returnData29) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).totalSupply(); // staticcall
require(success29);
uint256 value50 = 0;
uint256 value57 = var_d.length;
if (success29) {
uint256 value49 = returnData29.length;
if (0x20 <= returnData29.length) {
value49 = 0x20;
}
if (((var_d + ((value49 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value49 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value49 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value49) - var_d) >= 0x20);
} else {
value50 = var_d;
value57 = 0;
}
var_b = var_b;
(bool success30, bytes memory returnData30) = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_b); // staticcall
require(success30);
if (success30) {
if (0x20 > returnData30.length) {
if (((var_d + ((returnData30.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((returnData30.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((returnData30.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + returnData30.length) - var_d) >= 0x20);
require(var_d.length == (address(var_d.length)));
(bool success31, bytes memory returnData31) = address(var_d.length).epochLength(); // staticcall
require(success31);
uint256 value52 = 0;
uint256 value53 = var_d.length;
if (success31) {
uint256 value51 = returnData31.length;
if (0x20 <= returnData31.length) {
value51 = 0x20;
}
if (((var_d + ((value51 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value51 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value51 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value51) - var_d) >= 0x20);
require(var_d.length == (uint64(var_d.length)));
} else {
value52 = var_d;
value53 = 0;
}
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
var_b = var_b;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (!(0x0 < 0x3)) _desolexPanic(50);
uint256 value54 = 0;
bool flag12 = !(0 < (mapping_2[var_n] >> 0xc0));
if (!(mapping_2[var_n] >> 0xc0)) {
value54 = mapping_2[var_n] >> 0xc0;
flag12 = !(!(mapping_2[var_n] >> 0xc0));
}
uint256 value55 = 0;
if (flag12) {
mapping_2[var_n] = (0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000 & mapping_2[var_n]) | ((mapping_2[var_n] >> 0x60) & (0xffffffffffffffffffffffff));
mapping_2[var_n] = uint192(mapping_2[var_n]);
} else {
value55 = mapping_2[var_n];
}
uint256 value56 = 0;
bool flag13 = !(0 < (uint64(stor_expr_b)));
if (!(uint64(stor_expr_b))) {
value56 = uint64(stor_expr_b);
flag13 = !(!(uint64(stor_expr_b)));
}
if (flag13) {
stor_expr_b = (0xff0000000000000000 & ((!(!(0xff & (stor_expr_b >> 0x48)))) << 0x40)) | (stor_expr_b & (0xffffffffffffffffffffffffffffffffffffffffffffff000000000000000000));
address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_n); // staticcall
} else {
address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_n); // staticcall
}
} else {
if (((var_d + 0x20) > 0xffffffffffffffff) | ((var_d + 0x20) < var_d)) _desolexPanic(65);
var_d = var_d + 0x20;
require(((var_d + 0x20) - var_d) >= 0x20);
require(var_d.length == (address(var_d.length)));
(bool success34, bytes memory returnData34) = address(var_d.length).epochLength(); // staticcall
require(success34);
uint256 value59 = 0;
uint256 value60 = var_d.length;
if (success34) {
uint256 value58 = returnData34.length;
if (0x20 <= returnData34.length) {
value58 = 0x20;
}
if (((var_d + ((value58 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value58 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value58 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value58) - var_d) >= 0x20);
require(var_d.length == (uint64(var_d.length)));
} else {
value59 = var_d;
value60 = 0;
}
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
var_b = var_b;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (!(0x0 < 0x3)) _desolexPanic(50);
uint256 value61 = 0;
bool flag14 = !(0 < (mapping_2[var_n] >> 0xc0));
if (!(mapping_2[var_n] >> 0xc0)) {
value61 = mapping_2[var_n] >> 0xc0;
flag14 = !(!(mapping_2[var_n] >> 0xc0));
}
uint256 value62 = 0;
if (flag14) {
mapping_2[var_n] = (0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000 & mapping_2[var_n]) | ((mapping_2[var_n] >> 0x60) & (0xffffffffffffffffffffffff));
mapping_2[var_n] = uint192(mapping_2[var_n]);
} else {
value62 = mapping_2[var_n];
}
uint256 value63 = 0;
bool flag15 = !(0 < (uint64(stor_expr_b)));
if (!(uint64(stor_expr_b))) {
value63 = uint64(stor_expr_b);
flag15 = !(!(uint64(stor_expr_b)));
}
if (flag15) {
stor_expr_b = (0xff0000000000000000 & ((!(!(0xff & (stor_expr_b >> 0x48)))) << 0x40)) | (stor_expr_b & (0xffffffffffffffffffffffffffffffffffffffffffffff000000000000000000));
address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_n); // staticcall
} else {
address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_n); // staticcall
}
}
} else {
(bool success37, bytes memory returnData37) = address(0).epochLength(); // staticcall
require(success37);
uint256 value65 = 0;
uint256 value66 = var_d.length;
if (success37) {
uint256 value64 = returnData37.length;
if (0x20 <= returnData37.length) {
value64 = 0x20;
}
if (((var_d + ((value64 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value64 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value64 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value64) - var_d) >= 0x20);
require(var_d.length == (uint64(var_d.length)));
} else {
value65 = var_d;
value66 = 0;
}
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
var_b = var_b;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (((var_d + 0x60) > 0xffffffffffffffff) | ((var_d + 0x60) < var_d)) _desolexPanic(65);
var_d = var_d + 0x60;
if (!(0x0 < 0x3)) _desolexPanic(50);
uint256 value67 = 0;
bool flag16 = !(0 < (mapping_2[var_n] >> 0xc0));
if (!(mapping_2[var_n] >> 0xc0)) {
value67 = mapping_2[var_n] >> 0xc0;
flag16 = !(!(mapping_2[var_n] >> 0xc0));
}
uint256 value68 = 0;
if (flag16) {
mapping_2[var_n] = (0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000 & mapping_2[var_n]) | ((mapping_2[var_n] >> 0x60) & (0xffffffffffffffffffffffff));
mapping_2[var_n] = uint192(mapping_2[var_n]);
} else {
value68 = mapping_2[var_n];
}
uint256 value69 = 0;
bool flag17 = !(0 < (uint64(stor_expr_b)));
if (!(uint64(stor_expr_b))) {
value69 = uint64(stor_expr_b);
flag17 = !(!(uint64(stor_expr_b)));
}
if (flag17) {
stor_expr_b = (0xff0000000000000000 & ((!(!(0xff & (stor_expr_b >> 0x48)))) << 0x40)) | (stor_expr_b & (0xffffffffffffffffffffffffffffffffffffffffffffff000000000000000000));
address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_n); // staticcall
} else {
address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_n); // staticcall
}
}
}
}
}
}
}
}
}
function Unknown_e3e866ee(uint256 arg0) public returns (uint96) {
bool flag0 = arg0 != 0xbc08363990a5d8594f51cfdcedc3f7359d3bba2162c25c1f2b1b196035a49cb;
if (arg0 == 0x03dc1425fc74b1b336a6bbd0b133ff09f16fa42d94b14f524a0892734913070c) {
flag0 = arg0 != 0x3dc1425fc74b1b336a6bbd0b133ff09f16fa42d94b14f524a0892734913070c;
}
uint256 value0 = 0;
bool flag1 = !(arg0 == var_a);
if (flag0) {
} else {
value0 = arg0;
flag1 = flag0;
}
require(!(flag1), InvalidChannel());
uint256 value4 = 0;
if (!(!(mapping_2[arg0] >> 0xc0))) {
var_a = var_a;
(bool success0, bytes memory returnData0) = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_a); // staticcall
require(success0);
uint256 value1 = 0;
uint256 value2;
if (success0) {
uint256 var_e;
uint256 value5 = var_e.length;
if (0x20 > returnData0.length) {
if (((var_e + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_e + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_e)) _desolexPanic(65);
var_e = var_e + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_e + returnData0.length) - var_e) >= 0x20);
require(var_e.length == (address(var_e.length)));
} else {
if (((var_e + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_e + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_e)) _desolexPanic(65);
var_e = var_e + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_e + 0x20) - var_e) < 0x20));
require(var_f == (address(var_f)));
value5 = var_g;
}
value2 = value5;
} else {
value1 = var_e;
value2 = 0;
}
(bool success1, bytes memory returnData1) = address(value2).currentEpoch(); // staticcall
require(success1);
uint256 value3;
if (success1) {
uint256 value6 = var_e.length;
if (0x20 > returnData1.length) {
if (((var_e + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_e + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_e)) _desolexPanic(65);
var_e = var_e + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_e + returnData1.length) - var_e) >= 0x20);
require(var_e.length == (uint64(var_e.length)));
} else {
if (((var_e + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_e + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_e)) _desolexPanic(65);
var_e = var_e + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_e + 0x20) - var_e) < 0x20));
require(var_i == (uint64(var_i)));
value6 = var_g;
}
value3 = value6;
} else {
value3 = 0;
}
} else {
value4 = mapping_2[arg0] >> 0xc0;
}
if ((SHR(0xc0, mapping_2[arg0]) != 0x0) && ((value3 & 0xffffffffffffffff) >= SHR(0xc0, mapping_2[arg0]))) {
return uint96(mapping_2[arg0] >> 0x60);
} else {
return uint96(mapping_2[arg0]);
}
}
function revokeRole(bytes32 role, address account) public {
require(bytes1(hasRole[stor_expr_e][msg.sender]), AccessControlUnauthorizedAccount());
uint256 value0 = 0;
if (bytes1(hasRole[role][account])) {
hasRole[role][account] = false;
emit RoleRevoked(role, account, msg.sender);
value0 = 0x01;
}
if (value0 != 0x0) {
uint256 value4 = 0;
if (!(0 == (!(!(mapping_expr_h[account]))))) {
uint256 value1 = 0;
uint256 value2 = 0;
uint256 value3 = 0;
if ((mapping_expr_h[account] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) != (stor_expr_i + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) {
if (!(((stor_expr_i + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < stor_expr_j))) _desolexPanic(50);
if (!(((mapping_expr_h[account] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < stor_expr_k))) _desolexPanic(50);
stor_expr_n = (0 & stor_expr_o) | ((stor_expr_m >> 0) << 0);
mapping_expr_h[stor_expr_m >> 0] = mapping_expr_h[account];
} else {
value1 = mapping_expr_h[account] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
value2 = stor_expr_i + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
value3 = mapping_expr_h[account];
}
if (!(stor_expr_i != 0x0)) _desolexPanic(49);
if (!(((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + stor_expr_i) < stor_expr_q))) _desolexPanic(50);
stor_expr_r = (0) & stor_expr_r;
stor_expr_i = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + stor_expr_i;
mapping_expr_h[account] = 0;
value4 = 0x01;
}
}
}
function Unknown_bd0ecdcb(uint256 arg0) public returns (bool) {
bool flag0 = arg0 != 0xbc08363990a5d8594f51cfdcedc3f7359d3bba2162c25c1f2b1b196035a49cb;
if (arg0 == 0x03dc1425fc74b1b336a6bbd0b133ff09f16fa42d94b14f524a0892734913070c) {
flag0 = arg0 != 0x3dc1425fc74b1b336a6bbd0b133ff09f16fa42d94b14f524a0892734913070c;
}
uint256 value0 = 0;
bool flag1 = !(arg0 == var_a);
if (flag0) {
} else {
value0 = arg0;
flag1 = flag0;
}
require(!(flag1), InvalidChannel());
uint256 value4 = 0;
if (!(!(uint64(stor_expr_t)))) {
var_a = var_a;
(bool success0, bytes memory returnData0) = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_a); // staticcall
require(success0);
uint256 value1 = 0;
uint256 value2;
if (success0) {
uint256 var_e;
uint256 value5 = var_e.length;
if (0x20 > returnData0.length) {
if (((var_e + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_e + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_e)) _desolexPanic(65);
var_e = var_e + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_e + returnData0.length) - var_e) >= 0x20);
require(var_e.length == (address(var_e.length)));
} else {
if (((var_e + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_e + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_e)) _desolexPanic(65);
var_e = var_e + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_e + 0x20) - var_e) < 0x20));
require(var_f == (address(var_f)));
value5 = var_g;
}
value2 = value5;
} else {
value1 = var_e;
value2 = 0;
}
(bool success1, bytes memory returnData1) = address(value2).currentEpoch(); // staticcall
require(success1);
uint256 value3;
if (success1) {
uint256 value6 = var_e.length;
if (0x20 > returnData1.length) {
if (((var_e + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_e + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_e)) _desolexPanic(65);
var_e = var_e + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_e + returnData1.length) - var_e) >= 0x20);
require(var_e.length == (uint64(var_e.length)));
} else {
if (((var_e + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_e + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_e)) _desolexPanic(65);
var_e = var_e + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_e + 0x20) - var_e) < 0x20));
require(var_i == (uint64(var_i)));
value6 = var_g;
}
value3 = value6;
} else {
value3 = 0;
}
} else {
value4 = uint64(stor_expr_t);
}
if (((stor_expr_u & 0xffffffffffffffff) != 0x0) && ((value3 & 0xffffffffffffffff) >= (stor_expr_u & 0xffffffffffffffff))) {
return !(!(bytes1(stor_expr_t >> 0x48)));
} else {
return !(!(bytes1(stor_expr_t >> 0x40)));
}
}
function Unknown_a3246ad3(uint256 arg0) public view returns (bytes memory) {
uint256 value0 = 0;
uint256 value1 = keccak256(abi.encode(keccak256(abi.encode(arg0, 0x01))));
uint256 var_a;
uint256 value2 = var_a + 0x20;
while (true) {
if (value0 >= getRoleMemberCount[arg0]) {
break;
}
value0 = 0x01 + value0;
value1 = 0x01 + value1;
value2 = value2 + 0x20;
}
if (((var_a + (((value2 - var_a) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + (((value2 - var_a) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65);
uint256 value3 = 0;
uint256 value4 = var_a + 0x20;
uint256 value5 = var_a + 0x40;
while (true) {
var_a = var_a + (((value2 - var_a) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
if (value3 >= var_a.length) {
return abi.encodePacked(0x20, var_a.length);
}
value3 = 0x01 + value3;
value4 = value4 + 0x20;
value5 = 0x20 + value5;
}
}
function Unknown_9010d07c(uint256 arg0, uint256 arg1) public view returns (address) {
if (!(arg1 < getRoleMemberCount[arg0])) _desolexPanic(50);
return address(stor_expr_x >> 0);
}
function lastDistributedEpoch() public returns (uint64) {
(bool success0, bytes memory returnData0) = address(0x7d32e67c6f4972fb288e034f465444daf000d9d3).lastDistributedEpoch(); // staticcall
require(success0);
if (success0) {
uint256 var_b;
if (0x20 > returnData0.length) {
if (((var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65);
var_b = var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_b + returnData0.length) - var_b) >= 0x20);
} else {
if (((var_b + 0x20) > 0xffffffffffffffff) | ((var_b + 0x20) < var_b)) _desolexPanic(65);
var_b = var_b + 0x20;
require(((var_b + 0x20) - var_b) >= 0x20);
}
require(var_b.length == (uint64(var_b.length)));
return uint64(var_b.length);
} else {
return 0;
}
}
function Unknown_6f3e4849(uint256 arg0, bool arg1) public {
address var_a = msg.sender;
require(mapping_316a51056d8b2401ab04c48d9973add294eadde229c785c6d19cde93785467ef[msg.sender], AccessControlUnauthorizedAccount());
bool flag0 = arg0 != 0xbc08363990a5d8594f51cfdcedc3f7359d3bba2162c25c1f2b1b196035a49cb;
if (arg0 == 0x03dc1425fc74b1b336a6bbd0b133ff09f16fa42d94b14f524a0892734913070c) {
flag0 = arg0 != 0x3dc1425fc74b1b336a6bbd0b133ff09f16fa42d94b14f524a0892734913070c;
}
uint256 value0 = 0;
bool flag1 = !(arg0 == var_a);
if (flag0) {
} else {
value0 = arg0;
flag1 = flag0;
}
require(!(flag1), InvalidChannel());
var_a = var_a;
(bool success0, bytes memory returnData0) = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_a); // staticcall
require(success0);
uint256 value1 = 0;
uint256 var_e;
uint256 value2 = var_e.length;
if (success0) {
if (0x20 > returnData0.length) {
if (((var_e + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_e + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_e)) _desolexPanic(65);
var_e = var_e + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_e + returnData0.length) - var_e) >= 0x20);
} else {
if (((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e)) _desolexPanic(65);
var_e = var_e + 0x20;
require(((var_e + 0x20) - var_e) >= 0x20);
}
require(var_e.length == (address(var_e.length)));
} else {
value1 = var_e;
value2 = 0;
}
(bool success1, bytes memory returnData1) = address(value2).currentEpoch(); // staticcall
require(success1);
if (success1) {
if (0x20 > returnData1.length) {
if (((var_e + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_e + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_e)) _desolexPanic(65);
var_e = var_e + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_e + returnData1.length) - var_e) >= 0x20);
require(var_e.length == (uint64(var_e.length)));
uint256 value3 = 0;
bool flag2 = !(uint64(var_e.length) < (mapping_2[arg0] >> 0xc0));
if (!(mapping_2[arg0] >> 0xc0)) {
value3 = mapping_2[arg0] >> 0xc0;
flag2 = !(!(mapping_2[arg0] >> 0xc0));
}
uint256 value4 = 0;
if (flag2) {
mapping_2[arg0] = (0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000 & mapping_2[arg0]) | ((mapping_2[arg0] >> 0x60) & (0xffffffffffffffffffffffff));
mapping_2[arg0] = uint192(mapping_2[arg0]);
} else {
value4 = mapping_2[arg0];
}
uint256 value5 = 0;
uint256 value6 = 0;
bool flag3 = !(uint64(var_e.length) < (uint64(stor_expr_t)));
if (!(uint64(stor_expr_t))) {
value5 = var_e.length;
value6 = uint64(stor_expr_t);
flag3 = !(!(uint64(stor_expr_t)));
}
if (flag3) {
stor_expr_t = (0xff0000000000000000 & ((!(!(0xff & (stor_expr_t >> 0x48)))) << 0x40)) | (stor_expr_t & (0xffffffffffffffffffffffffffffffffffffffffffffff000000000000000000));
uint256 value7 = bytes1(stor_expr_t >> 0x40);
if (0 != (uint64(stor_expr_t) == uint64(var_e.length + 0x01))) {
value7 = bytes1(stor_expr_t >> 0x48);
}
stor_expr_t = ((var_e.length & (0xffffffffffffffff) + 0x01) & (0xffffffffffffffff)) | (0xff000000000000000000 & (arg1 << 0x48) | (0xffffffffffffffffffffffffffffffffffffffffffff00ff0000000000000000 & stor_expr_t));
emit Event_5eac0795(arg0, value7, arg1, uint64(var_e.length + 0x01), block.timestamp);
} else {
uint256 value8 = bytes1(stor_expr_t >> 0x40);
if (0 != (uint64(stor_expr_t) == uint64(var_e.length + 0x01))) {
value8 = bytes1(stor_expr_t >> 0x48);
}
stor_expr_t = ((var_e.length & (0xffffffffffffffff) + 0x01) & (0xffffffffffffffff)) | (0xff000000000000000000 & (arg1 << 0x48) | (0xffffffffffffffffffffffffffffffffffffffffffff00ff0000000000000000 & stor_expr_t));
emit Event_5eac0795(arg0, value8, arg1, uint64(var_e.length + 0x01), block.timestamp);
}
} else {
if (((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e)) _desolexPanic(65);
var_e = var_e + 0x20;
require(((var_e + 0x20) - var_e) >= 0x20);
require(var_e.length == (uint64(var_e.length)));
uint256 value9 = 0;
bool flag4 = !(uint64(var_e.length) < (mapping_2[arg0] >> 0xc0));
if (!(mapping_2[arg0] >> 0xc0)) {
value9 = mapping_2[arg0] >> 0xc0;
flag4 = !(!(mapping_2[arg0] >> 0xc0));
}
uint256 value10 = 0;
if (flag4) {
mapping_2[arg0] = (0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000 & mapping_2[arg0]) | ((mapping_2[arg0] >> 0x60) & (0xffffffffffffffffffffffff));
mapping_2[arg0] = uint192(mapping_2[arg0]);
} else {
value10 = mapping_2[arg0];
}
uint256 value11 = 0;
uint256 value12 = 0;
bool flag5 = !(uint64(var_e.length) < (uint64(stor_expr_t)));
if (!(uint64(stor_expr_t))) {
value11 = var_e.length;
value12 = uint64(stor_expr_t);
flag5 = !(!(uint64(stor_expr_t)));
}
if (flag5) {
stor_expr_t = (0xff0000000000000000 & ((!(!(0xff & (stor_expr_t >> 0x48)))) << 0x40)) | (stor_expr_t & (0xffffffffffffffffffffffffffffffffffffffffffffff000000000000000000));
uint256 value13 = bytes1(stor_expr_t >> 0x40);
if (0 != (uint64(stor_expr_t) == uint64(var_e.length + 0x01))) {
value13 = bytes1(stor_expr_t >> 0x48);
}
stor_expr_t = ((var_e.length & (0xffffffffffffffff) + 0x01) & (0xffffffffffffffff)) | (0xff000000000000000000 & (arg1 << 0x48) | (0xffffffffffffffffffffffffffffffffffffffffffff00ff0000000000000000 & stor_expr_t));
emit Event_5eac0795(arg0, value13, arg1, uint64(var_e.length + 0x01), block.timestamp);
} else {
uint256 value14 = bytes1(stor_expr_t >> 0x40);
if (0 != (uint64(stor_expr_t) == uint64(var_e.length + 0x01))) {
value14 = bytes1(stor_expr_t >> 0x48);
}
stor_expr_t = ((var_e.length & (0xffffffffffffffff) + 0x01) & (0xffffffffffffffff)) | (0xff000000000000000000 & (arg1 << 0x48) | (0xffffffffffffffffffffffffffffffffffffffffffff00ff0000000000000000 & stor_expr_t));
emit Event_5eac0795(arg0, value14, arg1, uint64(var_e.length + 0x01), block.timestamp);
}
}
} else {
uint256 value15 = 0;
if (!(mapping_2[arg0] >> 0xc0)) {
value15 = mapping_2[arg0] >> 0xc0;
}
uint256 value16 = 0;
if ((SHR(0xc0, mapping_2[arg0]) != 0x0) && (0x0 >= SHR(0xc0, mapping_2[arg0]))) {
mapping_2[arg0] = (0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000 & mapping_2[arg0]) | ((mapping_2[arg0] >> 0x60) & (0xffffffffffffffffffffffff));
mapping_2[arg0] = uint192(mapping_2[arg0]);
} else {
value16 = mapping_2[arg0];
}
uint256 value17 = 0;
if (!(uint64(stor_expr_t))) {
value17 = uint64(stor_expr_t);
}
if (((stor_expr_u & 0xffffffffffffffff) != 0x0) && (0x0 >= (stor_expr_u & 0xffffffffffffffff))) {
stor_expr_t = (0xff0000000000000000 & ((!(!(0xff & (stor_expr_t >> 0x48)))) << 0x40)) | (stor_expr_t & (0xffffffffffffffffffffffffffffffffffffffffffffff000000000000000000));
uint256 value18 = bytes1(stor_expr_t >> 0x40);
if (0 != (uint64(stor_expr_t) == 0x01)) {
value18 = bytes1(stor_expr_t >> 0x48);
}
stor_expr_t = 0x01 | (0xff000000000000000000 & (arg1 << 0x48) | (0xffffffffffffffffffffffffffffffffffffffffffff00ff0000000000000000 & stor_expr_t));
emit Event_5eac0795(arg0, value18, arg1, 0x01, block.timestamp);
} else {
uint256 value19 = bytes1(stor_expr_t >> 0x40);
if (0 != (uint64(stor_expr_t) == 0x01)) {
value19 = bytes1(stor_expr_t >> 0x48);
}
stor_expr_t = 0x01 | (0xff000000000000000000 & (arg1 << 0x48) | (0xffffffffffffffffffffffffffffffffffffffffffff00ff0000000000000000 & stor_expr_t));
emit Event_5eac0795(arg0, value19, arg1, 0x01, block.timestamp);
}
}
}
function Unknown_5ff37c18(uint256 arg0, uint96 arg1) public {
require(arg1 == (arg1 & 0xffffffffffffffffffffffff));
address var_a = msg.sender;
require(mapping_316a51056d8b2401ab04c48d9973add294eadde229c785c6d19cde93785467ef[msg.sender], AccessControlUnauthorizedAccount());
bool flag0 = arg0 != 0xbc08363990a5d8594f51cfdcedc3f7359d3bba2162c25c1f2b1b196035a49cb;
if (arg0 == 0x03dc1425fc74b1b336a6bbd0b133ff09f16fa42d94b14f524a0892734913070c) {
flag0 = arg0 != 0x3dc1425fc74b1b336a6bbd0b133ff09f16fa42d94b14f524a0892734913070c;
}
uint256 value0 = 0;
bool flag1 = !(arg0 == var_a);
if (flag0) {
} else {
value0 = arg0;
flag1 = flag0;
}
require(!(flag1), InvalidChannel());
require(uint96(arg1) <= 0x3635c9adc5dea00000, RateTooHigh());
var_a = var_a;
(bool success0, bytes memory returnData0) = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_a); // staticcall
require(success0);
uint256 value1 = 0;
uint256 var_e;
uint256 value2 = var_e.length;
if (success0) {
if (0x20 > returnData0.length) {
if (((var_e + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_e + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_e)) _desolexPanic(65);
var_e = var_e + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_e + returnData0.length) - var_e) >= 0x20);
} else {
if (((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e)) _desolexPanic(65);
var_e = var_e + 0x20;
require(((var_e + 0x20) - var_e) >= 0x20);
}
require(var_e.length == (address(var_e.length)));
} else {
value1 = var_e;
value2 = 0;
}
(bool success1, bytes memory returnData1) = address(value2).currentEpoch(); // staticcall
require(success1);
if (success1) {
if (0x20 > returnData1.length) {
if (((var_e + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_e + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_e)) _desolexPanic(65);
var_e = var_e + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_e + returnData1.length) - var_e) >= 0x20);
require(var_e.length == (uint64(var_e.length)));
uint256 value3 = 0;
bool flag2 = !(uint64(var_e.length) < (mapping_2[arg0] >> 0xc0));
if (!(mapping_2[arg0] >> 0xc0)) {
value3 = mapping_2[arg0] >> 0xc0;
flag2 = !(!(mapping_2[arg0] >> 0xc0));
}
uint256 value4 = 0;
if (flag2) {
mapping_2[arg0] = (0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000 & mapping_2[arg0]) | ((mapping_2[arg0] >> 0x60) & (0xffffffffffffffffffffffff));
mapping_2[arg0] = uint192(mapping_2[arg0]);
} else {
value4 = mapping_2[arg0];
}
uint256 value5 = 0;
uint256 value6 = 0;
bool flag3 = !(uint64(var_e.length) < (uint64(stor_expr_t)));
if (!(uint64(stor_expr_t))) {
value5 = var_e.length;
value6 = uint64(stor_expr_t);
flag3 = !(!(uint64(stor_expr_t)));
}
if (flag3) {
stor_expr_t = (0xff0000000000000000 & ((!(!(0xff & (stor_expr_t >> 0x48)))) << 0x40)) | (stor_expr_t & (0xffffffffffffffffffffffffffffffffffffffffffffff000000000000000000));
uint256 value7 = uint96(mapping_2[arg0]);
if (0 != ((mapping_2[arg0] >> 0xc0) == uint64(var_e.length + 0x01))) {
value7 = uint96(mapping_2[arg0] >> 0x60);
}
mapping_2[arg0] = (0xffffffffffffffff000000000000000000000000000000000000000000000000 & ((var_e.length & (0xffffffffffffffff) + 0x01) << 0xc0)) | (0xffffffffffffffffffffffff000000000000000000000000 & (arg1 << 0x60) | (0xffffffffffffffffffffffff & mapping_2[arg0]));
emit Event_e6620a82(arg0, uint96(value7), uint96(arg1), uint64(var_e.length + 0x01), block.timestamp);
} else {
uint256 value8 = uint96(mapping_2[arg0]);
if (0 != ((mapping_2[arg0] >> 0xc0) == uint64(var_e.length + 0x01))) {
value8 = uint96(mapping_2[arg0] >> 0x60);
}
mapping_2[arg0] = (0xffffffffffffffff000000000000000000000000000000000000000000000000 & ((var_e.length & (0xffffffffffffffff) + 0x01) << 0xc0)) | (0xffffffffffffffffffffffff000000000000000000000000 & (arg1 << 0x60) | (0xffffffffffffffffffffffff & mapping_2[arg0]));
emit Event_e6620a82(arg0, uint96(value8), uint96(arg1), uint64(var_e.length + 0x01), block.timestamp);
}
} else {
if (((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e)) _desolexPanic(65);
var_e = var_e + 0x20;
require(((var_e + 0x20) - var_e) >= 0x20);
require(var_e.length == (uint64(var_e.length)));
uint256 value9 = 0;
bool flag4 = !(uint64(var_e.length) < (mapping_2[arg0] >> 0xc0));
if (!(mapping_2[arg0] >> 0xc0)) {
value9 = mapping_2[arg0] >> 0xc0;
flag4 = !(!(mapping_2[arg0] >> 0xc0));
}
uint256 value10 = 0;
if (flag4) {
mapping_2[arg0] = (0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000 & mapping_2[arg0]) | ((mapping_2[arg0] >> 0x60) & (0xffffffffffffffffffffffff));
mapping_2[arg0] = uint192(mapping_2[arg0]);
} else {
value10 = mapping_2[arg0];
}
uint256 value11 = 0;
uint256 value12 = 0;
bool flag5 = !(uint64(var_e.length) < (uint64(stor_expr_t)));
if (!(uint64(stor_expr_t))) {
value11 = var_e.length;
value12 = uint64(stor_expr_t);
flag5 = !(!(uint64(stor_expr_t)));
}
if (flag5) {
stor_expr_t = (0xff0000000000000000 & ((!(!(0xff & (stor_expr_t >> 0x48)))) << 0x40)) | (stor_expr_t & (0xffffffffffffffffffffffffffffffffffffffffffffff000000000000000000));
uint256 value13 = uint96(mapping_2[arg0]);
if (0 != ((mapping_2[arg0] >> 0xc0) == uint64(var_e.length + 0x01))) {
value13 = uint96(mapping_2[arg0] >> 0x60);
}
mapping_2[arg0] = (0xffffffffffffffff000000000000000000000000000000000000000000000000 & ((var_e.length & (0xffffffffffffffff) + 0x01) << 0xc0)) | (0xffffffffffffffffffffffff000000000000000000000000 & (arg1 << 0x60) | (0xffffffffffffffffffffffff & mapping_2[arg0]));
emit Event_e6620a82(arg0, uint96(value13), uint96(arg1), uint64(var_e.length + 0x01), block.timestamp);
} else {
uint256 value14 = uint96(mapping_2[arg0]);
if (0 != ((mapping_2[arg0] >> 0xc0) == uint64(var_e.length + 0x01))) {
value14 = uint96(mapping_2[arg0] >> 0x60);
}
mapping_2[arg0] = (0xffffffffffffffff000000000000000000000000000000000000000000000000 & ((var_e.length & (0xffffffffffffffff) + 0x01) << 0xc0)) | (0xffffffffffffffffffffffff000000000000000000000000 & (arg1 << 0x60) | (0xffffffffffffffffffffffff & mapping_2[arg0]));
emit Event_e6620a82(arg0, uint96(value14), uint96(arg1), uint64(var_e.length + 0x01), block.timestamp);
}
}
} else {
uint256 value15 = 0;
if (!(mapping_2[arg0] >> 0xc0)) {
value15 = mapping_2[arg0] >> 0xc0;
}
uint256 value16 = 0;
if ((SHR(0xc0, mapping_2[arg0]) != 0x0) && (0x0 >= SHR(0xc0, mapping_2[arg0]))) {
mapping_2[arg0] = (0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000 & mapping_2[arg0]) | ((mapping_2[arg0] >> 0x60) & (0xffffffffffffffffffffffff));
mapping_2[arg0] = uint192(mapping_2[arg0]);
} else {
value16 = mapping_2[arg0];
}
uint256 value17 = 0;
if (!(uint64(stor_expr_t))) {
value17 = uint64(stor_expr_t);
}
if (((stor_expr_u & 0xffffffffffffffff) != 0x0) && (0x0 >= (stor_expr_u & 0xffffffffffffffff))) {
stor_expr_t = (0xff0000000000000000 & ((!(!(0xff & (stor_expr_t >> 0x48)))) << 0x40)) | (stor_expr_t & (0xffffffffffffffffffffffffffffffffffffffffffffff000000000000000000));
uint256 value18 = uint96(mapping_2[arg0]);
if (0 != ((mapping_2[arg0] >> 0xc0) == 0x01)) {
value18 = uint96(mapping_2[arg0] >> 0x60);
}
mapping_2[arg0] = 0x01000000000000000000000000000000000000000000000000 | (0xffffffffffffffffffffffff000000000000000000000000 & (arg1 << 0x60) | (0xffffffffffffffffffffffff & mapping_2[arg0]));
emit Event_e6620a82(arg0, uint96(value18), uint96(arg1), 0x01, block.timestamp);
} else {
uint256 value19 = uint96(mapping_2[arg0]);
if (0 != ((mapping_2[arg0] >> 0xc0) == 0x01)) {
value19 = uint96(mapping_2[arg0] >> 0x60);
}
mapping_2[arg0] = 0x01000000000000000000000000000000000000000000000000 | (0xffffffffffffffffffffffff000000000000000000000000 & (arg1 << 0x60) | (0xffffffffffffffffffffffff & mapping_2[arg0]));
emit Event_e6620a82(arg0, uint96(value19), uint96(arg1), 0x01, block.timestamp);
}
}
}
function renounceRole(bytes32 role, address account) public {
require(account == msg.sender, AccessControlBadConfirmation());
internal_117b(role, account);
}
function grantRole(bytes32 role, address account) public {
require(bytes1(hasRole[stor_expr_e][msg.sender]), AccessControlUnauthorizedAccount());
if (!(bytes1(hasRole[role][account]) != 0x0)) {
hasRole[role][account] = true;
emit RoleGranted(role, account, msg.sender);
}
if (!(0 == (!(mapping_expr_ak[account])))) {
if (!(stor_expr_aj < 0x010000000000000000)) _desolexPanic(65);
stor_expr_aj = stor_expr_aj + 0x01;
if (!(stor_expr_aj < stor_expr_aj)) _desolexPanic(50);
stor_expr_al = (0 & stor_expr_al) | (account << 0);
mapping_expr_ak[account] = stor_expr_aj;
}
}
function getRoleAdmin(bytes32 role) public view returns (uint256) {
return stor_expr_e;
}
function supportsInterface(bytes4 interfaceId) public pure returns (bool) {
require(interfaceId == (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000));
uint256 value1 = msg.data[0] >> 0xe0;
bool flag1;
if ((interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000) != 0x5a05180f00000000000000000000000000000000000000000000000000000000) {
uint256 value0 = msg.data[0] >> 0xe0;
bool flag0 = 0x1ffc9a700000000000000000000000000000000000000000000000000000000 == (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000);
if (interfaceId & (0xffffffff00000000000000000000000000000000000000000000000000000000) == 0x7965db0b00000000000000000000000000000000000000000000000000000000) {
value0 = interfaceId & (0xffffffff00000000000000000000000000000000000000000000000000000000);
flag0 = (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000) == 0x7965db0b00000000000000000000000000000000000000000000000000000000;
}
flag1 = flag0;
} else {
value1 = interfaceId & (0xffffffff00000000000000000000000000000000000000000000000000000000);
flag1 = (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000) == 0x5a05180f00000000000000000000000000000000000000000000000000000000;
}
return flag1;
}
function internal_117b(bytes32 arg0, address arg1) private {
// Decompilation incomplete: helper effect provenance is conservative.
uint256 value0 = 0;
if (bytes1(hasRole[arg0][arg1])) {
hasRole[arg0][arg1] = false;
emit RoleRevoked(arg0, arg1, msg.sender);
value0 = 0x01;
}
if (value0 != 0x0) {
uint256 value4 = 0;
if (!(0 == (!(!(mapping_expr_aa[arg1]))))) {
uint256 value1 = 0;
uint256 value2 = 0;
uint256 value3 = 0;
if ((mapping_expr_aa[arg1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) != (getRoleMemberCount[arg0] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) {
if (!(((getRoleMemberCount[arg0] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < stor_expr_j))) _desolexPanic(50);
if (!(((mapping_expr_aa[arg1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < stor_expr_k))) _desolexPanic(50);
stor_expr_ae = (0 & stor_expr_af | (stor_expr_ad >> (0 << 0x03) << 0));
mapping_expr_aa[stor_expr_ad >> (0 << 0x03)] = mapping_expr_aa[arg1];
} else {
value1 = mapping_expr_aa[arg1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
value2 = getRoleMemberCount[arg0] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
value3 = mapping_expr_aa[arg1];
}
if (!(getRoleMemberCount[arg0])) _desolexPanic(49);
if (!(((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + getRoleMemberCount[arg0]) < stor_expr_q))) _desolexPanic(50);
stor_expr_ah = (~(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff << (0 << 0x03))) & stor_expr_ah;
getRoleMemberCount[arg0] = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + getRoleMemberCount[arg0];
mapping_expr_aa[arg1] = 0;
flag0 = true;
}
}
}
function __desolexSelectorShim(uint32 rewrittenSelector) private {
assembly {
let input := mload(0x40)
calldatacopy(input, 0, calldatasize())
mstore(input, or(and(mload(input), 0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff), shl(224, and(rewrittenSelector, 0xffffffff))))
let success := delegatecall(gas(), address(), input, calldatasize(), 0, 0)
let size := returndatasize()
returndatacopy(input, 0, size)
switch success
case 0 { revert(input, size) }
default { return(input, size) }
}
}
// Note: This selector table is synthetic and is not part of the original Solidity source.
// It records the recovered selector-to-signature mapping without executable behavior.
// 0x01ffc9a7 => supportsInterface(bytes4)
// 0x0fc29349 => totalLiability()
// 0x1a465fe1 => protocolToken()
// 0x1d8ffa4d => interfaceVersion()
// 0x248a9ca3 => getRoleAdmin(bytes32)
// 0x2b3ba681 => RATE_PRECISION()
// 0x2f2ff15d => grantRole(bytes32,address)
// 0x36568abe => renounceRole(bytes32,address)
// 0x55fd7fa0 => moduleKey()
// 0x5ff37c18 => Unknown_5ff37c18(uint256,uint96)
// 0x6f3e4849 => Unknown_6f3e4849(uint256,bool)
// 0x7656419f => protocolRegistry()
// 0x79bd9e41 => lastDistributedEpoch()
// 0x9010d07c => Unknown_9010d07c(uint256,uint256)
// 0x91d14854 => hasRole(bytes32,address)
// 0x9b8e5563 => rewardMinter()
// 0x9ce6dd9f => hasOpenPositions()
// 0xa217fddf => DEFAULT_ADMIN_ROLE()
// 0xa3246ad3 => Unknown_a3246ad3(uint256)
// 0xbd0ecdcb => Unknown_bd0ecdcb(uint256)
// 0xca15c873 => getRoleMemberCount(bytes32)
// 0xd26cf1a6 => MAX_RATE_PER_SECOND()
// 0xd547741f => revokeRole(bytes32,address)
// 0xe3e866ee => Unknown_e3e866ee(uint256)
// 0xe4fc6b6d => distribute()
// 0xf36c8f5c => GOVERNANCE_ROLE()
}