BNB Chain
0x461def77d51082572cfb1c4f28aaf2a03227667e
Decompiled Solidity recovered from this contract's runtime bytecode. Best-effort reconstruction — confirm behaviour against on-chain state.
Decompilation outputBNB Chain · 0x461def77…3227667e8.8 KB57.1 s
This result is permanently available athttps://decompiler.exvul.com/bsc/0x461def77d51082572cfb1c4f28aaf2a03227667e
//decompiled by exvvul decompiler tool [email protected] https://x.com/exvulsec
// Decompilation incomplete: symbolic execution reached a configured deadline for 1 of 27 entry points (170000 ms contract budget): e9c4a3ac
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;
contract DesolexContract {
uint256 public constant GOVERNANCE_ROLE = 51344670724517732003549907689393193919197804398902247150944709319656146718385;
uint256 public constant RATIO_PRECISION = 100000;
uint256 public constant totalLiability = 0;
uint256 public constant DEFAULT_ADMIN_ROLE = 0;
address public constant stakingMain = address(0xe3a24afea37dc8547cedb480e291881bba335c31);
address public constant protocolRegistry = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593);
uint256 public constant moduleKey = 5315582784776574345583678605422711614505338069440959309533380248438413347275;
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]
uint256 stor_2; // STORAGE[0x2]
uint256 stor_3; // STORAGE[0x3]
uint256[] array_4; // STORAGE[0x4]
uint256 stor_5; // STORAGE[0x5]
mapping(address => bool) mapping_316a51056d8b2401ab04c48d9973add294eadde229c785c6d19cde93785467ef; // STORAGE[0x316a51056d8b2401ab04c48d9973add294eadde229c785c6d19cde93785467ef]
mapping(address => uint256) mapping_expr_aj;
mapping(address => uint256) mapping_expr_g;
mapping(address => uint256) mapping_expr_z;
bytes32 stor_expr_ac;
uint256 stor_expr_ad;
bytes32 stor_expr_ae;
uint256 stor_expr_ag;
uint256 stor_expr_ai;
address stor_expr_ak;
bytes32 stor_expr_al;
bytes32 stor_expr_d;
uint256 stor_expr_h;
uint256 stor_expr_i;
uint256 stor_expr_j;
bytes32 stor_expr_l;
bytes32 stor_expr_m;
bytes32 stor_expr_n;
uint256 stor_expr_p;
bytes32 stor_expr_q;
bytes32 stor_expr_u;
event RoleRevoked(bytes32 indexed, address indexed, address indexed);
error CustomError_82669d4e();
error CustomError_0a817548();
error CustomError_62c0d9df();
error CustomError_4b1fbffa();
error SafeERC20FailedOperation(address);
event Event_d6ac4603(uint256, uint256, uint256);
event RoleGranted(bytes32 indexed, address indexed, address indexed);
error CustomError_9faaa407();
event Event_ffe82287();
error AccessControlBadConfirmation();
error CustomError_d5fbac7a();
error ReentrancyGuardReentrantCall();
error AccessControlUnauthorizedAccount(address, bytes32);
error CustomError_43aee0a5();
event Event_fbf559fe();
function _desolexPanic(uint256 code) private pure {
assembly ("memory-safe") {
mstore(0x00, shl(224, 0x4e487b71))
mstore(0x04, code)
revert(0x00, 0x24)
}
}
fallback() external payable {
// Synthetic compatibility routes preserve original selectors for unresolved names.
if ((msg.data.length >= 4) && (msg.sig == 0x232879cf)) {
// Route to Unknown_232879cf(uint256) after replacing only msg.sig.
__desolexSelectorShim(uint32(0xd6da7838));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x261341cc)) {
// Route to Unknown_261341cc() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x682fdacf));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x45992f43)) {
// Route to Unknown_45992f43() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x45114b33));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x45d94c51)) {
// Route to Unknown_45d94c51() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x7fabb0a3));
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 == 0x949f062d)) {
// Route to Unknown_949f062d() after replacing only msg.sig.
__desolexSelectorShim(uint32(0xed5f89c2));
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 == 0xf08e7e8c)) {
// Route to Unknown_f08e7e8c(bool) after replacing only msg.sig.
__desolexSelectorShim(uint32(0x8e8266bf));
return;
}
revert();
}
function Unknown_f08e7e8c(bool arg0) public {
require(arg0 < 0x02);
require(mapping_316a51056d8b2401ab04c48d9973add294eadde229c785c6d19cde93785467ef[msg.sender], AccessControlUnauthorizedAccount());
stor_3 = (stor_3 & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)) | (arg0 & (0xff));
if (!(bytes1(stor_3) < 0x02)) _desolexPanic(33);
if (!((arg0 < 0x02))) _desolexPanic(33);
emit Event_d6ac4603(bytes1(stor_3), arg0, block.timestamp);
}
function dispatch() public payable {
if (!(msg.value) && !((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0) && !(stor_2 == 0x02)) {
stor_2 = 0x02;
var_b = var_b;
address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).isActive(var_b, address(this)); // staticcall
}
}
function revokeRole(bytes32 role, address account) public {
require(bytes1(hasRole[stor_expr_d][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_g[account]))))) {
uint256 value1 = 0;
uint256 value2 = 0;
uint256 value3 = 0;
if ((mapping_expr_g[account] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) != (stor_expr_h + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) {
if (!(((stor_expr_h + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < stor_expr_i))) _desolexPanic(50);
if (!(((mapping_expr_g[account] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < stor_expr_j))) _desolexPanic(50);
stor_expr_m = (0 & stor_expr_n) | ((stor_expr_l >> 0) << 0);
mapping_expr_g[stor_expr_l >> 0] = mapping_expr_g[account];
} else {
value1 = mapping_expr_g[account] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
value2 = stor_expr_h + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
value3 = mapping_expr_g[account];
}
if (!(stor_expr_h != 0x0)) _desolexPanic(49);
if (!(((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + stor_expr_h) < stor_expr_p))) _desolexPanic(50);
stor_expr_q = (0) & stor_expr_q;
stor_expr_h = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + stor_expr_h;
mapping_expr_g[account] = 0;
value4 = 0x01;
}
}
}
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 hasOpenPositions() public returns (bool) {
(bool success0, bytes memory returnData0) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success0);
if (!(success0)) {
return false;
}
uint256 value0 = returnData0.length;
if (0x20 <= returnData0.length) {
value0 = 0x20;
}
uint256 var_c;
if (((var_c + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65);
var_c = var_c + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_c + value0) - var_c) >= 0x20);
return var_c.length;
}
function Unknown_949f062d() public view returns (bool) {
if (!(bytes1(stor_3) < 0x02)) _desolexPanic(33);
return bytes1(stor_3);
}
function Unknown_9010d07c(uint256 arg0, uint256 arg1) public view returns (address) {
if (!(arg1 < getRoleMemberCount[arg0])) _desolexPanic(50);
return address(stor_expr_u >> 0);
}
function lastDistributedEpoch() public returns (uint64) {
(bool success0, bytes memory returnData0) = address(0xe3a24afea37dc8547cedb480e291881bba335c31).Unknown_4757800c(); // 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_45d94c51() public {
require(mapping_316a51056d8b2401ab04c48d9973add294eadde229c785c6d19cde93785467ef[msg.sender], AccessControlUnauthorizedAccount());
require(stor_2 != 0x02, ReentrancyGuardReentrantCall());
stor_2 = 0x02;
var_a = var_a;
(bool success0, bytes memory returnData0) = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).statusOf(var_a, address(this)); // staticcall
require(success0);
uint256 value1 = msg.data[0] >> 0xe0;
uint256 var_f;
uint256 value2 = var_f.length;
if (success0) {
uint256 value0 = returnData0.length;
if (0x20 <= returnData0.length) {
value0 = 0x20;
}
if (((var_f + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value0) - var_f) >= 0x20);
require(var_f.length < 0x05);
} else {
value1 = var_f;
value2 = 0;
}
if (!(value2 < 0x05)) _desolexPanic(33);
uint256 value3 = msg.data[0] >> 0xe0;
if (value2 == 0x02) {
value3 = value2;
}
require(!(value2 != 0x2 && value2 != 0x3), CustomError_0a817548());
(bool success1, bytes memory returnData1) = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(0x06aa03964db1f7257357ef09714a5f0ca3633723df419e97015e0c7a3e83edb7); // staticcall
require(success1);
if (!(success1)) {
require(!(0x0 != 0x0 && address(0) == address(this) || 0x0 == 0x0), CustomError_9faaa407());
(bool success2, bytes memory returnData2) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success2);
uint256 value5 = msg.data[0] >> 0xe0;
uint256 value6 = var_f.length;
if (success2) {
uint256 value4 = returnData2.length;
if (0x20 <= returnData2.length) {
value4 = 0x20;
}
if (((var_f + ((value4 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value4 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value4 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value4) - var_f) >= 0x20);
} else {
value5 = var_f;
value6 = 0;
}
require(value6 != 0x0, CustomError_d5fbac7a());
(bool success3, bytes memory returnData3) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(0); // staticcall
require(success3);
if (!(success3)) {
if (((var_f + 0x80) > 0xffffffffffffffff) | ((var_f + 0x80) < var_f)) _desolexPanic(65);
var_f = var_f + 0x80;
(bool success4, bytes memory returnData4) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).transfer(address(0), value6); // call
require(success4);
bool flag2 = !(0x01 == var_a);
if (returnData4.length == 0) {
flag2 = !(address(0x61e91daf03a49ecec334bffbf5008860cfb33333).code.length);
}
require(!(flag2), SafeERC20FailedOperation());
(bool success5, bytes memory returnData5) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success5);
uint256 value8 = 0x20;
uint256 value9 = var_f.length;
if (success5) {
uint256 value7 = returnData5.length;
if (0x20 <= returnData5.length) {
value7 = 0x20;
}
if (((var_f + ((value7 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value7 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value7 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value7) - var_f) >= 0x20);
} else {
value8 = var_f;
value9 = 0;
}
(bool success6, bytes memory returnData6) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(0); // staticcall
require(success6);
uint256 value11 = msg.data[0] >> 0xe0;
uint256 value12 = var_f.length;
if (success6) {
uint256 value10 = returnData6.length;
if (0x20 <= returnData6.length) {
value10 = 0x20;
}
if (((var_f + ((value10 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value10 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value10 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value10) - var_f) >= 0x20);
} else {
value11 = var_f;
value12 = 0;
}
bool flag3 = value12 < 0x0;
if (value9 != 0x0) {
flag3 = value9 != 0x0;
}
uint256 value13 = msg.data[0] >> 0xe0;
uint256 value14 = msg.data[0] >> 0xe0;
if (!flag3) {
} else {
value13 = value12;
value14 = 0;
}
require(!(!flag3 && value12 - 0x0 != value6 || flag3), CustomError_62c0d9df());
emit Event_fbf559fe(0, 0x06aa03964db1f7257357ef09714a5f0ca3633723df419e97015e0c7a3e83edb7, value6);
stor_2 = 0x01;
}
uint256 value15 = returnData3.length;
if (0x20 <= returnData3.length) {
value15 = 0x20;
}
if (((var_f + ((value15 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value15 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value15 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value15) - var_f) >= 0x20);
if (((var_f + 0x80) > 0xffffffffffffffff) | ((var_f + 0x80) < var_f)) _desolexPanic(65);
var_f = var_f + 0x80;
(bool success7, bytes memory returnData7) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).transfer(address(0), value6); // call
require(success7);
bool flag5 = !(0x01 == var_a);
if (returnData7.length == 0) {
flag5 = !(address(0x61e91daf03a49ecec334bffbf5008860cfb33333).code.length);
}
require(!(flag5), SafeERC20FailedOperation());
(bool success8, bytes memory returnData8) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success8);
uint256 value17 = 0x20;
uint256 value18 = var_f.length;
if (success8) {
uint256 value16 = returnData8.length;
if (0x20 <= returnData8.length) {
value16 = 0x20;
}
if (((var_f + ((value16 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value16 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value16 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value16) - var_f) >= 0x20);
} else {
value17 = var_f;
value18 = 0;
}
(bool success9, bytes memory returnData9) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(0); // staticcall
require(success9);
uint256 value20 = msg.data[0] >> 0xe0;
uint256 value21 = var_f.length;
if (success9) {
uint256 value19 = returnData9.length;
if (0x20 <= returnData9.length) {
value19 = 0x20;
}
if (((var_f + ((value19 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value19 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value19 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value19) - var_f) >= 0x20);
} else {
value20 = var_f;
value21 = 0;
}
bool flag6 = value21 < var_f.length;
if (value18 != 0x0) {
flag6 = value18 != 0x0;
}
uint256 value22 = msg.data[0] >> 0xe0;
uint256 value23 = msg.data[0] >> 0xe0;
bool flag7 = !((value21 - var_f.length) == value6);
if (!flag6) {
} else {
value22 = value21;
value23 = var_f.length;
flag7 = flag6;
}
require(!(flag7), CustomError_62c0d9df());
emit Event_fbf559fe(0, 0x06aa03964db1f7257357ef09714a5f0ca3633723df419e97015e0c7a3e83edb7, value6);
stor_2 = 0x01;
}
if (0x20 > returnData1.length) {
if (((var_f + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + returnData1.length) - var_f) >= 0x20);
require(var_f.length == (address(var_f.length)));
bool flag8 = (address(var_f.length)) == address(this);
if (!(address(var_f.length))) {
flag8 = !(address(var_f.length));
}
require(!(flag8), CustomError_9faaa407());
(bool success10, bytes memory returnData10) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success10);
uint256 value25 = msg.data[0] >> 0xe0;
uint256 value26 = var_f.length;
if (success10) {
uint256 value24 = returnData10.length;
if (0x20 <= returnData10.length) {
value24 = 0x20;
}
if (((var_f + ((value24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value24) - var_f) >= 0x20);
} else {
value25 = var_f;
value26 = 0;
}
require(value26 != 0x0, CustomError_d5fbac7a());
(bool success11, bytes memory returnData11) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(var_f.length)); // staticcall
require(success11);
if (!(success11)) {
if (((var_f + 0x80) > 0xffffffffffffffff) | ((var_f + 0x80) < var_f)) _desolexPanic(65);
var_f = var_f + 0x80;
(bool success12, bytes memory returnData12) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).transfer(address(var_f.length), value26); // call
require(success12);
bool flag9 = !(0x01 == var_a);
if (returnData12.length == 0) {
flag9 = !(address(0x61e91daf03a49ecec334bffbf5008860cfb33333).code.length);
}
require(!(flag9), SafeERC20FailedOperation());
(bool success13, bytes memory returnData13) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success13);
uint256 value28 = 0x20;
uint256 value29 = var_f.length;
if (success13) {
uint256 value27 = returnData13.length;
if (0x20 <= returnData13.length) {
value27 = 0x20;
}
if (((var_f + ((value27 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value27 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value27 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value27) - var_f) >= 0x20);
} else {
value28 = var_f;
value29 = 0;
}
(bool success14, bytes memory returnData14) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(var_f.length)); // staticcall
require(success14);
uint256 value31 = msg.data[0] >> 0xe0;
uint256 value32 = var_f.length;
if (success14) {
uint256 value30 = returnData14.length;
if (0x20 <= returnData14.length) {
value30 = 0x20;
}
if (((var_f + ((value30 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value30 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value30 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value30) - var_f) >= 0x20);
} else {
value31 = var_f;
value32 = 0;
}
bool flag10 = value32 < 0x0;
if (value29 != 0x0) {
flag10 = value29 != 0x0;
}
uint256 value33 = msg.data[0] >> 0xe0;
uint256 value34 = msg.data[0] >> 0xe0;
if (!flag10) {
} else {
value33 = value32;
value34 = 0;
}
require(!(!flag10 && value32 - 0x0 != value26 || flag10), CustomError_62c0d9df());
emit Event_fbf559fe(address(var_f.length), 0x06aa03964db1f7257357ef09714a5f0ca3633723df419e97015e0c7a3e83edb7, value26);
stor_2 = 0x01;
}
uint256 value35 = returnData11.length;
if (0x20 <= returnData11.length) {
value35 = 0x20;
}
if (((var_f + ((value35 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value35 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value35 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value35) - var_f) >= 0x20);
if (((var_f + 0x80) > 0xffffffffffffffff) | ((var_f + 0x80) < var_f)) _desolexPanic(65);
var_f = var_f + 0x80;
(bool success15, bytes memory returnData15) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).transfer(address(var_f.length), value26); // call
require(success15);
bool flag12 = !(0x01 == var_a);
if (returnData15.length == 0) {
flag12 = !(address(0x61e91daf03a49ecec334bffbf5008860cfb33333).code.length);
}
require(!(flag12), SafeERC20FailedOperation());
(bool success16, bytes memory returnData16) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success16);
uint256 value37 = 0x20;
uint256 value38 = var_f.length;
if (success16) {
uint256 value36 = returnData16.length;
if (0x20 <= returnData16.length) {
value36 = 0x20;
}
if (((var_f + ((value36 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value36 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value36 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value36) - var_f) >= 0x20);
} else {
value37 = var_f;
value38 = 0;
}
(bool success17, bytes memory returnData17) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(var_f.length)); // staticcall
require(success17);
uint256 value40 = msg.data[0] >> 0xe0;
uint256 value41 = var_f.length;
if (success17) {
uint256 value39 = returnData17.length;
if (0x20 <= returnData17.length) {
value39 = 0x20;
}
if (((var_f + ((value39 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value39 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value39 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value39) - var_f) >= 0x20);
} else {
value40 = var_f;
value41 = 0;
}
bool flag13 = value41 < var_f.length;
if (value38 != 0x0) {
flag13 = value38 != 0x0;
}
uint256 value42 = msg.data[0] >> 0xe0;
uint256 value43 = msg.data[0] >> 0xe0;
bool flag14 = !((value41 - var_f.length) == value26);
if (!flag13) {
} else {
value42 = value41;
value43 = var_f.length;
flag14 = flag13;
}
require(!(flag14), CustomError_62c0d9df());
emit Event_fbf559fe(address(var_f.length), 0x06aa03964db1f7257357ef09714a5f0ca3633723df419e97015e0c7a3e83edb7, value26);
} else {
if (((var_f + 0x20) > 0xffffffffffffffff) | ((var_f + 0x20) < var_f)) _desolexPanic(65);
var_f = var_f + 0x20;
require(((var_f + 0x20) - var_f) >= 0x20);
require(var_f.length == (address(var_f.length)));
bool flag15 = (address(var_f.length)) == address(this);
if (!(address(var_f.length))) {
flag15 = !(address(var_f.length));
}
require(!(flag15), CustomError_9faaa407());
(bool success18, bytes memory returnData18) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success18);
uint256 value45 = msg.data[0] >> 0xe0;
uint256 value46 = var_f.length;
if (success18) {
uint256 value44 = returnData18.length;
if (0x20 <= returnData18.length) {
value44 = 0x20;
}
if (((var_f + ((value44 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value44 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value44 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value44) - var_f) >= 0x20);
} else {
value45 = var_f;
value46 = 0;
}
require(value46 != 0x0, CustomError_d5fbac7a());
(bool success19, bytes memory returnData19) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(var_f.length)); // staticcall
require(success19);
if (!(success19)) {
if (((var_f + 0x80) > 0xffffffffffffffff) | ((var_f + 0x80) < var_f)) _desolexPanic(65);
var_f = var_f + 0x80;
(bool success20, bytes memory returnData20) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).transfer(address(var_f.length), value46); // call
require(success20);
bool flag16 = !(0x01 == var_a);
if (returnData20.length == 0) {
flag16 = !(address(0x61e91daf03a49ecec334bffbf5008860cfb33333).code.length);
}
require(!(flag16), SafeERC20FailedOperation());
(bool success21, bytes memory returnData21) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success21);
uint256 value48 = 0x20;
uint256 value49 = var_f.length;
if (success21) {
uint256 value47 = returnData21.length;
if (0x20 <= returnData21.length) {
value47 = 0x20;
}
if (((var_f + ((value47 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value47 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value47 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value47) - var_f) >= 0x20);
} else {
value48 = var_f;
value49 = 0;
}
(bool success22, bytes memory returnData22) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(var_f.length)); // staticcall
require(success22);
uint256 value51 = msg.data[0] >> 0xe0;
uint256 value52 = var_f.length;
if (success22) {
uint256 value50 = returnData22.length;
if (0x20 <= returnData22.length) {
value50 = 0x20;
}
if (((var_f + ((value50 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value50 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value50 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value50) - var_f) >= 0x20);
} else {
value51 = var_f;
value52 = 0;
}
bool flag17 = value52 < 0x0;
if (value49 != 0x0) {
flag17 = value49 != 0x0;
}
uint256 value53 = msg.data[0] >> 0xe0;
uint256 value54 = msg.data[0] >> 0xe0;
if (!flag17) {
} else {
value53 = value52;
value54 = 0;
}
require(!(!flag17 && value52 - 0x0 != value46 || flag17), CustomError_62c0d9df());
emit Event_fbf559fe(address(var_f.length), 0x06aa03964db1f7257357ef09714a5f0ca3633723df419e97015e0c7a3e83edb7, value46);
stor_2 = 0x01;
}
uint256 value55 = returnData19.length;
if (0x20 <= returnData19.length) {
value55 = 0x20;
}
if (((var_f + ((value55 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value55 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value55 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value55) - var_f) >= 0x20);
if (((var_f + 0x80) > 0xffffffffffffffff) | ((var_f + 0x80) < var_f)) _desolexPanic(65);
var_f = var_f + 0x80;
(bool success23, bytes memory returnData23) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).transfer(address(var_f.length), value46); // call
require(success23);
bool flag19 = !(0x01 == var_a);
if (returnData23.length == 0) {
flag19 = !(address(0x61e91daf03a49ecec334bffbf5008860cfb33333).code.length);
}
require(!(flag19), SafeERC20FailedOperation());
(bool success24, bytes memory returnData24) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success24);
uint256 value57 = 0x20;
uint256 value58 = var_f.length;
if (success24) {
uint256 value56 = returnData24.length;
if (0x20 <= returnData24.length) {
value56 = 0x20;
}
if (((var_f + ((value56 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value56 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value56 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value56) - var_f) >= 0x20);
} else {
value57 = var_f;
value58 = 0;
}
(bool success25, bytes memory returnData25) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(var_f.length)); // staticcall
require(success25);
uint256 value60 = msg.data[0] >> 0xe0;
uint256 value61 = var_f.length;
if (success25) {
uint256 value59 = returnData25.length;
if (0x20 <= returnData25.length) {
value59 = 0x20;
}
if (((var_f + ((value59 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value59 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value59 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value59) - var_f) >= 0x20);
} else {
value60 = var_f;
value61 = 0;
}
bool flag20 = value61 < var_f.length;
if (value58 != 0x0) {
flag20 = value58 != 0x0;
}
uint256 value62 = msg.data[0] >> 0xe0;
uint256 value63 = msg.data[0] >> 0xe0;
bool flag21 = !((value61 - var_f.length) == value46);
if (!flag20) {
} else {
value62 = value61;
value63 = var_f.length;
flag21 = flag20;
}
require(!(flag21), CustomError_62c0d9df());
emit Event_fbf559fe(address(var_f.length), 0x06aa03964db1f7257357ef09714a5f0ca3633723df419e97015e0c7a3e83edb7, value46);
}
stor_2 = 0x01;
}
function Unknown_45992f43() public payable {
if (!(msg.value)) {
if ((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) >= 0x0140) {
if (0x0144 <= msg.data.length) {
if (mapping_316a51056d8b2401ab04c48d9973add294eadde229c785c6d19cde93785467ef[msg.sender]) {
var_a = var_a;
(bool success0, bytes memory returnData0) = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_a); // staticcall
if (success0) {
if (success0) {
if (0x20 <= returnData0.length) {
uint256 var_e;
if (!(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e))) {
var_e = var_e + 0x20;
if (((var_e + 0x20) - var_e) >= 0x20) {
if (var_e.length == (address(var_e.length))) {
if (address(var_e.length).code.length != 0x0) {
var_a = var_a;
(bool success1, bytes memory returnData1) = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).isActive(var_a, address(var_e.length)); // staticcall
if (success1) {
if (success1) {
if (0x20 > returnData1.length) {
if (!(((var_e + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_e + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_e))) {
var_e = var_e + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
if (((var_e + returnData1.length) - var_e) >= 0x20) {
require(var_e.length == var_e.length);
require(var_e.length != 0x0, CustomError_4b1fbffa());
uint256 value1 = 0;
uint256 value0 = 0;
while (true) {
if (value0 >= 0xa) {
break;
}
if (value0 >= 0xa) {
_desolexPanic(50);
break;
}
if ((value0 << 0x05) != (uint32(value0 << 0x05))) {
revert();
break;
}
if (value1 > (value1 + (uint32(value0 << 0x05)))) {
_desolexPanic(17);
break;
}
if (value0 >= 0xa) {
_desolexPanic(50);
break;
}
if ((value0 << 0x05) != (uint32(value0 << 0x05))) {
revert();
break;
}
if (!(uint32(value0 << 0x05))) {
break;
}
if (value0 >= 0xa) {
break;
}
(bool success2, bytes memory returnData2) = address(var_e.length).isTierActive(value0); // staticcall
if (!success2) {
break;
}
if (success2) {
if (!(0x20 > returnData2.length) && !(((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e))) {
var_e = var_e + 0x20;
if (((var_e + 0x20) - var_e) >= 0x20) {
require(var_e.length == var_e.length);
}
}
break;
}
revert CustomError_82669d4e();
break;
value1 = value1 + (uint32(value0 << 0x05));
value0 = 0x01 + value0;
}
require(0x186a0 == value1, CustomError_43aee0a5());
uint256 value2 = 0;
uint256 value3 = 0x04;
uint256 value4 = var_e;
while (true) {
value2 = value2 + 0x08;
value3 = value3 + 0x01;
value4 = value4 + 0x0100;
}
if (((var_e + 0x0140) > 0xffffffffffffffff) | ((var_e + 0x0140) < var_e)) _desolexPanic(65);
uint256 value5 = 0;
while (true) {
var_e = var_e + 0x0140;
if (value5 >= 0x01) {
break;
}
uint256 value6 = 0;
uint256 value7 = 0x04;
uint256 value8 = 0;
while (true) {
if (value6 >= 0x08) {
break;
}
if (msg.data[value7] != (uint32(msg.data[value7]))) {
revert();
break;
}
value6 = value6 + 0x01;
value7 = value7 + 0x20;
value8 = (~(0xffffffff << ((value6 << 0x02) << 0x03)) & value8) | (uint32(msg.data[value7]) << ((value6 << 0x02) << 0x03));
}
array_4[value5] = value8;
value5 = value5 + 0x01;
}
uint256 value9 = 0;
uint256 value10 = 0x04;
uint256 value11 = 0;
while (true) {
if (value9 >= 0x02) {
break;
}
if (msg.data[value10] != (uint32(msg.data[value10]))) {
revert();
break;
}
value9 = value9 + 0x01;
value10 = value10 + 0x20;
value11 = (~(0xffffffff << ((value9 << 0x02) << 0x03)) & value11) | (uint32(msg.data[value10]) << ((value9 << 0x02) << 0x03));
}
uint256 value13 = var_e;
uint256 value12 = 0;
uint256 value14 = var_e;
while (true) {
stor_5 = value11;
if (value12 >= 0x0a) {
break;
}
value13 = value13 + 0x20;
value12 = value12 + 0x01;
value14 = value14 + 0x20;
}
uint256 value16 = var_e + 0x0140;
uint256 value17 = 0x04;
uint256 value15 = 0;
while (true) {
if (value15 >= 0x0a) {
emit Event_ffe82287(uint32(var_s), block.timestamp);
}
if (msg.data[value17] != (uint32(msg.data[value17]))) {
revert();
break;
}
value16 = value16 + 0x20;
value17 = value17 + 0x20;
value15 = value15 + 0x01;
}
}
}
} 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 == var_e.length);
require(var_e.length != 0x0, CustomError_4b1fbffa());
uint256 value1 = 0;
uint256 value0 = 0;
while (true) {
if (value0 >= 0xa) {
break;
}
if (value0 >= 0xa) {
_desolexPanic(50);
break;
}
if ((value0 << 0x05) != (uint32(value0 << 0x05))) {
revert();
break;
}
if (value1 > (value1 + (uint32(value0 << 0x05)))) {
_desolexPanic(17);
break;
}
if (value0 >= 0xa) {
_desolexPanic(50);
break;
}
if ((value0 << 0x05) != (uint32(value0 << 0x05))) {
revert();
break;
}
if (!(!(uint32(value0 << 0x05)))) {
if (value0 >= 0xa) {
_desolexPanic(33);
break;
}
(bool success3, bytes memory returnData3) = address(var_e.length).isTierActive(value0); // staticcall
if (!success3) {
revert();
break;
}
if (success3) {
if (0x20 > returnData3.length) {
if (((var_e + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_e + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_e)) {
_desolexPanic(65);
break;
}
var_e = var_e + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
if (((var_e + returnData3.length) - var_e) < 0x20) {
revert();
break;
}
} else {
if (((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e)) {
_desolexPanic(65);
break;
}
var_e = var_e + 0x20;
if (((var_e + 0x20) - var_e) < 0x20) {
revert();
break;
}
}
if (var_e.length != var_e.length) {
revert();
break;
}
if (var_e.length == 0) {
revert CustomError_82669d4e();
break;
}
} else {
revert CustomError_82669d4e();
break;
}
} else {
if (!(!(uint32(value0 << 0x05)))) {
revert CustomError_82669d4e();
break;
}
}
value1 = value1 + (uint32(value0 << 0x05));
value0 = 0x01 + value0;
}
require(0x186a0 == value1, CustomError_43aee0a5());
uint256 value2 = 0;
uint256 value3 = 0x04;
uint256 value4 = var_e;
while (true) {
value2 = value2 + 0x08;
value3 = value3 + 0x01;
value4 = value4 + 0x0100;
}
if (((var_e + 0x0140) > 0xffffffffffffffff) | ((var_e + 0x0140) < var_e)) _desolexPanic(65);
uint256 value5 = 0;
while (true) {
var_e = var_e + 0x0140;
if (value5 >= 0x01) {
break;
}
uint256 value6 = 0;
uint256 value7 = 0x04;
uint256 value8 = 0;
while (true) {
if (value6 >= 0x08) {
break;
}
if (msg.data[value7] != (uint32(msg.data[value7]))) {
revert();
break;
}
value6 = value6 + 0x01;
value7 = value7 + 0x20;
value8 = (~(0xffffffff << ((value6 << 0x02) << 0x03)) & value8) | (uint32(msg.data[value7]) << ((value6 << 0x02) << 0x03));
}
array_4[value5] = value8;
value5 = value5 + 0x01;
}
uint256 value9 = 0;
uint256 value10 = 0x04;
uint256 value11 = 0;
while (true) {
if (value9 >= 0x02) {
break;
}
if (msg.data[value10] != (uint32(msg.data[value10]))) {
revert();
break;
}
value9 = value9 + 0x01;
value10 = value10 + 0x20;
value11 = (~(0xffffffff << ((value9 << 0x02) << 0x03)) & value11) | (uint32(msg.data[value10]) << ((value9 << 0x02) << 0x03));
}
uint256 value13 = var_e;
uint256 value12 = 0;
uint256 value14 = var_e;
while (true) {
stor_5 = value11;
if (value12 >= 0x0a) {
break;
}
value13 = value13 + 0x20;
value12 = value12 + 0x01;
value14 = value14 + 0x20;
}
uint256 value16 = var_e + 0x0140;
uint256 value17 = 0x04;
uint256 value15 = 0;
while (true) {
if (value15 >= 0x0a) {
emit Event_ffe82287(uint32(var_s), uint32(msg.data[value17]), block.timestamp);
}
if (msg.data[value17] != (uint32(msg.data[value17]))) {
revert();
break;
}
value16 = value16 + 0x20;
value17 = value17 + 0x20;
value15 = value15 + 0x01;
}
}
} else {
require(0, CustomError_4b1fbffa());
uint256 value1 = 0;
uint256 value0 = 0;
while (true) {
if (value0 >= 0xa) {
break;
}
if (value0 >= 0xa) {
_desolexPanic(50);
break;
}
if ((value0 << 0x05) != (uint32(value0 << 0x05))) {
revert();
break;
}
if (value1 > (value1 + (uint32(value0 << 0x05)))) {
_desolexPanic(17);
break;
}
if (value0 >= 0xa) {
_desolexPanic(50);
break;
}
if ((value0 << 0x05) != (uint32(value0 << 0x05))) {
revert();
break;
}
if (!(!(uint32(value0 << 0x05)))) {
if (value0 >= 0xa) {
_desolexPanic(33);
break;
}
(bool success4, bytes memory returnData4) = address(var_e.length).isTierActive(value0); // staticcall
if (!success4) {
revert();
break;
}
if (success4) {
if (0x20 > returnData4.length) {
if (((var_e + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_e + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_e)) {
_desolexPanic(65);
break;
}
var_e = var_e + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
if (((var_e + returnData4.length) - var_e) < 0x20) {
revert();
break;
}
} else {
if (((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e)) {
_desolexPanic(65);
break;
}
var_e = var_e + 0x20;
if (((var_e + 0x20) - var_e) < 0x20) {
revert();
break;
}
}
if (var_e.length != var_e.length) {
revert();
break;
}
if (var_e.length == 0) {
revert CustomError_82669d4e();
break;
}
} else {
revert CustomError_82669d4e();
break;
}
} else {
if (!(!(uint32(value0 << 0x05)))) {
revert CustomError_82669d4e();
break;
}
}
value1 = value1 + (uint32(value0 << 0x05));
value0 = 0x01 + value0;
}
require(0x186a0 == value1, CustomError_43aee0a5());
uint256 value2 = 0;
uint256 value3 = 0x04;
uint256 value4 = var_e;
while (true) {
value2 = value2 + 0x08;
value3 = value3 + 0x01;
value4 = value4 + 0x0100;
}
if (((var_e + 0x0140) > 0xffffffffffffffff) | ((var_e + 0x0140) < var_e)) _desolexPanic(65);
uint256 value5 = 0;
while (true) {
var_e = var_e + 0x0140;
if (value5 >= 0x01) {
break;
}
uint256 value6 = 0;
uint256 value7 = 0x04;
uint256 value8 = 0;
while (true) {
if (value6 >= 0x08) {
break;
}
if (msg.data[value7] != (uint32(msg.data[value7]))) {
revert();
break;
}
value6 = value6 + 0x01;
value7 = value7 + 0x20;
value8 = (~(0xffffffff << ((value6 << 0x02) << 0x03)) & value8) | (uint32(msg.data[value7]) << ((value6 << 0x02) << 0x03));
}
array_4[value5] = value8;
value5 = value5 + 0x01;
}
uint256 value9 = 0;
uint256 value10 = 0x04;
uint256 value11 = 0;
while (true) {
if (value9 >= 0x02) {
break;
}
if (msg.data[value10] != (uint32(msg.data[value10]))) {
revert();
break;
}
value9 = value9 + 0x01;
value10 = value10 + 0x20;
value11 = (~(0xffffffff << ((value9 << 0x02) << 0x03)) & value11) | (uint32(msg.data[value10]) << ((value9 << 0x02) << 0x03));
}
uint256 value13 = var_e;
uint256 value12 = 0;
uint256 value14 = var_e;
while (true) {
stor_5 = value11;
if (value12 >= 0x0a) {
break;
}
value13 = value13 + 0x20;
value12 = value12 + 0x01;
value14 = value14 + 0x20;
}
uint256 value16 = var_e + 0x0140;
uint256 value17 = 0x04;
uint256 value15 = 0;
while (true) {
if (value15 >= 0x0a) {
emit Event_ffe82287(uint32(var_s), uint32(var_s), uint32(msg.data[value17]), block.timestamp);
}
if (msg.data[value17] != (uint32(msg.data[value17]))) {
revert();
break;
}
value16 = value16 + 0x20;
value17 = value17 + 0x20;
value15 = value15 + 0x01;
}
}
}
}
}
}
}
}
} else {
if (address(0).code.length != 0x0) {
var_a = var_a;
(bool success5, bytes memory returnData5) = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).isActive(var_a, 0); // staticcall
require(success5);
if (success5) {
if (0x20 > returnData5.length) {
if (((var_e + ((returnData5.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_e + ((returnData5.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_e)) _desolexPanic(65);
var_e = var_e + ((returnData5.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_e + returnData5.length) - var_e) >= 0x20);
require(var_e.length == var_e.length);
require(var_e.length != 0x0, CustomError_4b1fbffa());
uint256 value1 = 0;
uint256 value0 = 0;
while (true) {
if (value0 >= 0xa) {
break;
}
if (value0 >= 0xa) {
_desolexPanic(50);
break;
}
if ((value0 << 0x05) != (uint32(value0 << 0x05))) {
revert();
break;
}
if (value1 > (value1 + (uint32(value0 << 0x05)))) {
_desolexPanic(17);
break;
}
if (value0 >= 0xa) {
_desolexPanic(50);
break;
}
if ((value0 << 0x05) != (uint32(value0 << 0x05))) {
revert();
break;
}
if (!(!(uint32(value0 << 0x05)))) {
if (value0 >= 0xa) {
_desolexPanic(33);
break;
}
(bool success6, bytes memory returnData6) = address(0).isTierActive(value0); // staticcall
if (!success6) {
revert();
break;
}
if (success6) {
if (0x20 > returnData6.length) {
if (((var_e + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_e + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_e)) {
_desolexPanic(65);
break;
}
var_e = var_e + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
if (((var_e + returnData6.length) - var_e) < 0x20) {
revert();
break;
}
} else {
if (((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e)) {
_desolexPanic(65);
break;
}
var_e = var_e + 0x20;
if (((var_e + 0x20) - var_e) < 0x20) {
revert();
break;
}
}
if (var_e.length != var_e.length) {
revert();
break;
}
if (var_e.length == 0) {
revert CustomError_82669d4e();
break;
}
} else {
revert CustomError_82669d4e();
break;
}
} else {
if (!(!(uint32(value0 << 0x05)))) {
revert CustomError_82669d4e();
break;
}
}
value1 = value1 + (uint32(value0 << 0x05));
value0 = 0x01 + value0;
}
} 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 == var_e.length);
require(var_e.length != 0x0, CustomError_4b1fbffa());
uint256 value1 = 0;
uint256 value0 = 0;
while (true) {
if (value0 >= 0xa) {
break;
}
if (value0 >= 0xa) {
_desolexPanic(50);
break;
}
if ((value0 << 0x05) != (uint32(value0 << 0x05))) {
revert();
break;
}
if (value1 > (value1 + (uint32(value0 << 0x05)))) {
_desolexPanic(17);
break;
}
if (value0 >= 0xa) {
_desolexPanic(50);
break;
}
if ((value0 << 0x05) != (uint32(value0 << 0x05))) {
revert();
break;
}
if (!(!(uint32(value0 << 0x05)))) {
if (value0 >= 0xa) {
_desolexPanic(33);
break;
}
(bool success7, bytes memory returnData7) = address(0).isTierActive(value0); // staticcall
if (!success7) {
revert();
break;
}
if (success7) {
if (0x20 > returnData7.length) {
if (((var_e + ((returnData7.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_e + ((returnData7.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_e)) {
_desolexPanic(65);
break;
}
var_e = var_e + ((returnData7.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
if (((var_e + returnData7.length) - var_e) < 0x20) {
revert();
break;
}
} else {
if (((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e)) {
_desolexPanic(65);
break;
}
var_e = var_e + 0x20;
if (((var_e + 0x20) - var_e) < 0x20) {
revert();
break;
}
}
if (var_e.length != var_e.length) {
revert();
break;
}
if (var_e.length == 0) {
revert CustomError_82669d4e();
break;
}
} else {
revert CustomError_82669d4e();
break;
}
} else {
if (!(!(uint32(value0 << 0x05)))) {
revert CustomError_82669d4e();
break;
}
}
value1 = value1 + (uint32(value0 << 0x05));
value0 = 0x01 + value0;
}
}
require(0x186a0 == value1, CustomError_43aee0a5());
uint256 value2 = 0;
uint256 value3 = 0x04;
uint256 value4 = var_e;
while (true) {
value2 = value2 + 0x08;
value3 = value3 + 0x01;
value4 = value4 + 0x0100;
}
if (((var_e + 0x0140) > 0xffffffffffffffff) | ((var_e + 0x0140) < var_e)) _desolexPanic(65);
uint256 value5 = 0;
while (true) {
var_e = var_e + 0x0140;
if (value5 >= 0x01) {
break;
}
uint256 value6 = 0;
uint256 value7 = 0x04;
uint256 value8 = 0;
while (true) {
if (value6 >= 0x08) {
break;
}
if (msg.data[value7] != (uint32(msg.data[value7]))) {
revert();
break;
}
value6 = value6 + 0x01;
value7 = value7 + 0x20;
value8 = (~(0xffffffff << ((value6 << 0x02) << 0x03)) & value8) | (uint32(msg.data[value7]) << ((value6 << 0x02) << 0x03));
}
array_4[value5] = value8;
value5 = value5 + 0x01;
}
uint256 value9 = 0;
uint256 value10 = 0x04;
uint256 value11 = 0;
while (true) {
if (value9 >= 0x02) {
break;
}
if (msg.data[value10] != (uint32(msg.data[value10]))) {
revert();
break;
}
value9 = value9 + 0x01;
value10 = value10 + 0x20;
value11 = (~(0xffffffff << ((value9 << 0x02) << 0x03)) & value11) | (uint32(msg.data[value10]) << ((value9 << 0x02) << 0x03));
}
uint256 value13 = var_e;
uint256 value12 = 0;
uint256 value14 = var_e;
while (true) {
stor_5 = value11;
if (value12 >= 0x0a) {
break;
}
value13 = value13 + 0x20;
value12 = value12 + 0x01;
value14 = value14 + 0x20;
}
uint256 value16 = var_e + 0x0140;
uint256 value17 = 0x04;
uint256 value15 = 0;
while (true) {
if (value15 >= 0x0a) {
emit Event_ffe82287(uint32(var_s), uint32(var_s), uint32(msg.data[value17]), uint32(msg.data[value17]), block.timestamp);
}
if (msg.data[value17] != (uint32(msg.data[value17]))) {
revert();
break;
}
value16 = value16 + 0x20;
value17 = value17 + 0x20;
value15 = value15 + 0x01;
}
} else {
require(0, CustomError_4b1fbffa());
uint256 value1 = 0;
uint256 value0 = 0;
while (true) {
if (value0 >= 0xa) {
break;
}
if (value0 >= 0xa) {
_desolexPanic(50);
break;
}
if ((value0 << 0x05) != (uint32(value0 << 0x05))) {
revert();
break;
}
if (value1 > (value1 + (uint32(value0 << 0x05)))) {
_desolexPanic(17);
break;
}
if (value0 >= 0xa) {
_desolexPanic(50);
break;
}
if ((value0 << 0x05) != (uint32(value0 << 0x05))) {
revert();
break;
}
if (!(!(uint32(value0 << 0x05)))) {
if (value0 >= 0xa) {
_desolexPanic(33);
break;
}
(bool success8, bytes memory returnData8) = address(0).isTierActive(value0); // staticcall
if (!success8) {
revert();
break;
}
if (success8) {
if (0x20 > returnData8.length) {
if (((var_e + ((returnData8.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_e + ((returnData8.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_e)) {
_desolexPanic(65);
break;
}
var_e = var_e + ((returnData8.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
if (((var_e + returnData8.length) - var_e) < 0x20) {
revert();
break;
}
} else {
if (((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e)) {
_desolexPanic(65);
break;
}
var_e = var_e + 0x20;
if (((var_e + 0x20) - var_e) < 0x20) {
revert();
break;
}
}
if (var_e.length != var_e.length) {
revert();
break;
}
if (var_e.length == 0) {
revert CustomError_82669d4e();
break;
}
} else {
revert CustomError_82669d4e();
break;
}
} else {
if (!(!(uint32(value0 << 0x05)))) {
revert CustomError_82669d4e();
break;
}
}
value1 = value1 + (uint32(value0 << 0x05));
value0 = 0x01 + value0;
}
require(0x186a0 == value1, CustomError_43aee0a5());
uint256 value2 = 0;
uint256 value3 = 0x04;
uint256 value4 = var_e;
while (true) {
value2 = value2 + 0x08;
value3 = value3 + 0x01;
value4 = value4 + 0x0100;
}
if (((var_e + 0x0140) > 0xffffffffffffffff) | ((var_e + 0x0140) < var_e)) _desolexPanic(65);
uint256 value5 = 0;
while (true) {
var_e = var_e + 0x0140;
if (value5 >= 0x01) {
break;
}
uint256 value6 = 0;
uint256 value7 = 0x04;
uint256 value8 = 0;
while (true) {
if (value6 >= 0x08) {
break;
}
if (msg.data[value7] != (uint32(msg.data[value7]))) {
revert();
break;
}
value6 = value6 + 0x01;
value7 = value7 + 0x20;
value8 = (~(0xffffffff << ((value6 << 0x02) << 0x03)) & value8) | (uint32(msg.data[value7]) << ((value6 << 0x02) << 0x03));
}
array_4[value5] = value8;
value5 = value5 + 0x01;
}
uint256 value9 = 0;
uint256 value10 = 0x04;
uint256 value11 = 0;
while (true) {
if (value9 >= 0x02) {
break;
}
if (msg.data[value10] != (uint32(msg.data[value10]))) {
revert();
break;
}
value9 = value9 + 0x01;
value10 = value10 + 0x20;
value11 = (~(0xffffffff << ((value9 << 0x02) << 0x03)) & value11) | (uint32(msg.data[value10]) << ((value9 << 0x02) << 0x03));
}
uint256 value13 = var_e;
uint256 value12 = 0;
uint256 value14 = var_e;
while (true) {
stor_5 = value11;
if (value12 >= 0x0a) {
break;
}
value13 = value13 + 0x20;
value12 = value12 + 0x01;
value14 = value14 + 0x20;
}
uint256 value16 = var_e + 0x0140;
uint256 value17 = 0x04;
uint256 value15 = 0;
while (true) {
if (value15 >= 0x0a) {
emit Event_ffe82287(uint32(var_s), uint32(var_s), uint32(var_s), uint32(msg.data[value17]), uint32(msg.data[value17]), block.timestamp);
}
if (msg.data[value17] != (uint32(msg.data[value17]))) {
revert();
break;
}
value16 = value16 + 0x20;
value17 = value17 + 0x20;
value15 = value15 + 0x01;
}
}
} else {
require(0x0.code.length != 0x0, CustomError_4b1fbffa());
uint256 value1 = 0;
uint256 value0 = 0;
while (true) {
if (value0 >= 0xa) {
break;
}
if (value0 >= 0xa) {
_desolexPanic(50);
break;
}
if ((value0 << 0x05) != (uint32(value0 << 0x05))) {
revert();
break;
}
if (value1 > (value1 + (uint32(value0 << 0x05)))) {
_desolexPanic(17);
break;
}
if (value0 >= 0xa) {
_desolexPanic(50);
break;
}
if ((value0 << 0x05) != (uint32(value0 << 0x05))) {
revert();
break;
}
if (!(!(uint32(value0 << 0x05)))) {
if (value0 >= 0xa) {
_desolexPanic(33);
break;
}
(bool success9, bytes memory returnData9) = address(0).isTierActive(value0); // staticcall
if (!success9) {
revert();
break;
}
if (success9) {
if (0x20 > returnData9.length) {
if (((var_e + ((returnData9.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_e + ((returnData9.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_e)) {
_desolexPanic(65);
break;
}
var_e = var_e + ((returnData9.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
if (((var_e + returnData9.length) - var_e) < 0x20) {
revert();
break;
}
} else {
if (((var_e + 0x20) > 0xffffffffffffffff) | ((var_e + 0x20) < var_e)) {
_desolexPanic(65);
break;
}
var_e = var_e + 0x20;
if (((var_e + 0x20) - var_e) < 0x20) {
revert();
break;
}
}
if (var_e.length != var_e.length) {
revert();
break;
}
if (var_e.length == 0) {
revert CustomError_82669d4e();
break;
}
} else {
revert CustomError_82669d4e();
break;
}
} else {
if (!(!(uint32(value0 << 0x05)))) {
revert CustomError_82669d4e();
break;
}
}
value1 = value1 + (uint32(value0 << 0x05));
value0 = 0x01 + value0;
}
require(0x186a0 == value1, CustomError_43aee0a5());
uint256 value2 = 0;
uint256 value3 = 0x04;
uint256 value4 = var_e;
while (true) {
value2 = value2 + 0x08;
value3 = value3 + 0x01;
value4 = value4 + 0x0100;
}
if (((var_e + 0x0140) > 0xffffffffffffffff) | ((var_e + 0x0140) < var_e)) _desolexPanic(65);
uint256 value5 = 0;
while (true) {
var_e = var_e + 0x0140;
if (value5 >= 0x01) {
break;
}
uint256 value6 = 0;
uint256 value7 = 0x04;
uint256 value8 = 0;
while (true) {
if (value6 >= 0x08) {
break;
}
if (msg.data[value7] != (uint32(msg.data[value7]))) {
revert();
break;
}
value6 = value6 + 0x01;
value7 = value7 + 0x20;
value8 = (~(0xffffffff << ((value6 << 0x02) << 0x03)) & value8) | (uint32(msg.data[value7]) << ((value6 << 0x02) << 0x03));
}
array_4[value5] = value8;
value5 = value5 + 0x01;
}
uint256 value9 = 0;
uint256 value10 = 0x04;
uint256 value11 = 0;
while (true) {
if (value9 >= 0x02) {
break;
}
if (msg.data[value10] != (uint32(msg.data[value10]))) {
revert();
break;
}
value9 = value9 + 0x01;
value10 = value10 + 0x20;
value11 = (~(0xffffffff << ((value9 << 0x02) << 0x03)) & value11) | (uint32(msg.data[value10]) << ((value9 << 0x02) << 0x03));
}
uint256 value13 = var_e;
uint256 value12 = 0;
uint256 value14 = var_e;
while (true) {
stor_5 = value11;
if (value12 >= 0x0a) {
break;
}
value13 = value13 + 0x20;
value12 = value12 + 0x01;
value14 = value14 + 0x20;
}
uint256 value16 = var_e + 0x0140;
uint256 value17 = 0x04;
uint256 value15 = 0;
while (true) {
if (value15 >= 0x0a) {
emit Event_ffe82287(uint32(var_s), uint32(var_s), uint32(var_s), uint32(msg.data[value17]), uint32(msg.data[value17]), uint32(msg.data[value17]), block.timestamp);
}
if (msg.data[value17] != (uint32(msg.data[value17]))) {
revert();
break;
}
value16 = value16 + 0x20;
value17 = value17 + 0x20;
value15 = value15 + 0x01;
}
}
}
}
}
}
}
}
}
function renounceRole(bytes32 role, address account) public {
require(account == msg.sender, AccessControlBadConfirmation());
internal_1e7b(role, account);
}
function grantRole(bytes32 role, address account) public {
require(bytes1(hasRole[stor_expr_d][msg.sender]), AccessControlUnauthorizedAccount());
if (!(bytes1(hasRole[role][account]) != 0x0)) {
hasRole[role][account] = true;
emit RoleGranted(role, account, msg.sender);
}
if (!(0 == (!(mapping_expr_aj[account])))) {
if (!(stor_expr_ai < 0x010000000000000000)) _desolexPanic(65);
stor_expr_ai = stor_expr_ai + 0x01;
if (!(stor_expr_ai < stor_expr_ai)) _desolexPanic(50);
stor_expr_ak = (0 & stor_expr_ak) | (account << 0);
mapping_expr_aj[account] = stor_expr_ai;
}
}
function Unknown_261341cc() public {
require(mapping_316a51056d8b2401ab04c48d9973add294eadde229c785c6d19cde93785467ef[msg.sender], AccessControlUnauthorizedAccount());
require(stor_2 != 0x02, ReentrancyGuardReentrantCall());
stor_2 = 0x02;
var_a = var_a;
(bool success0, bytes memory returnData0) = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).statusOf(var_a, address(this)); // staticcall
require(success0);
uint256 value1 = msg.data[0] >> 0xe0;
uint256 var_f;
uint256 value2 = var_f.length;
if (success0) {
uint256 value0 = returnData0.length;
if (0x20 <= returnData0.length) {
value0 = 0x20;
}
if (((var_f + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value0) - var_f) >= 0x20);
require(var_f.length < 0x05);
} else {
value1 = var_f;
value2 = 0;
}
if (!(value2 < 0x05)) _desolexPanic(33);
uint256 value3 = msg.data[0] >> 0xe0;
if (value2 == 0x02) {
value3 = value2;
}
require(!(value2 != 0x2 && value2 != 0x3), CustomError_0a817548());
var_a = var_a;
(bool success1, bytes memory returnData1) = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_a); // staticcall
require(success1);
if (!(success1)) {
require(!(0x0 != 0x0 && address(0) == address(this) || 0x0 == 0x0), CustomError_9faaa407());
(bool success2, bytes memory returnData2) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success2);
uint256 value5 = msg.data[0] >> 0xe0;
uint256 value6 = var_f.length;
if (success2) {
uint256 value4 = returnData2.length;
if (0x20 <= returnData2.length) {
value4 = 0x20;
}
if (((var_f + ((value4 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value4 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value4 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value4) - var_f) >= 0x20);
} else {
value5 = var_f;
value6 = 0;
}
require(value6 != 0x0, CustomError_d5fbac7a());
(bool success3, bytes memory returnData3) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(0); // staticcall
require(success3);
if (!(success3)) {
if (((var_f + 0x80) > 0xffffffffffffffff) | ((var_f + 0x80) < var_f)) _desolexPanic(65);
var_f = var_f + 0x80;
(bool success4, bytes memory returnData4) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).transfer(address(0), value6); // call
require(success4);
bool flag2 = !(0x01 == var_a);
if (returnData4.length == 0) {
flag2 = !(address(0x61e91daf03a49ecec334bffbf5008860cfb33333).code.length);
}
require(!(flag2), SafeERC20FailedOperation());
(bool success5, bytes memory returnData5) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success5);
uint256 value8 = 0x20;
uint256 value9 = var_f.length;
if (success5) {
uint256 value7 = returnData5.length;
if (0x20 <= returnData5.length) {
value7 = 0x20;
}
if (((var_f + ((value7 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value7 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value7 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value7) - var_f) >= 0x20);
} else {
value8 = var_f;
value9 = 0;
}
(bool success6, bytes memory returnData6) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(0); // staticcall
require(success6);
uint256 value11 = msg.data[0] >> 0xe0;
uint256 value12 = var_f.length;
if (success6) {
uint256 value10 = returnData6.length;
if (0x20 <= returnData6.length) {
value10 = 0x20;
}
if (((var_f + ((value10 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value10 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value10 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value10) - var_f) >= 0x20);
} else {
value11 = var_f;
value12 = 0;
}
bool flag3 = value12 < 0x0;
if (value9 != 0x0) {
flag3 = value9 != 0x0;
}
uint256 value13 = msg.data[0] >> 0xe0;
uint256 value14 = msg.data[0] >> 0xe0;
if (!flag3) {
} else {
value13 = value12;
value14 = 0;
}
require(!(!flag3 && value12 - 0x0 != value6 || flag3), CustomError_62c0d9df());
var_a = var_a;
emit Event_fbf559fe(0, var_a, value6);
stor_2 = 0x01;
}
uint256 value15 = returnData3.length;
if (0x20 <= returnData3.length) {
value15 = 0x20;
}
if (((var_f + ((value15 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value15 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value15 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value15) - var_f) >= 0x20);
if (((var_f + 0x80) > 0xffffffffffffffff) | ((var_f + 0x80) < var_f)) _desolexPanic(65);
var_f = var_f + 0x80;
(bool success7, bytes memory returnData7) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).transfer(address(0), value6); // call
require(success7);
bool flag5 = !(0x01 == var_a);
if (returnData7.length == 0) {
flag5 = !(address(0x61e91daf03a49ecec334bffbf5008860cfb33333).code.length);
}
require(!(flag5), SafeERC20FailedOperation());
(bool success8, bytes memory returnData8) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success8);
uint256 value17 = 0x20;
uint256 value18 = var_f.length;
if (success8) {
uint256 value16 = returnData8.length;
if (0x20 <= returnData8.length) {
value16 = 0x20;
}
if (((var_f + ((value16 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value16 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value16 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value16) - var_f) >= 0x20);
} else {
value17 = var_f;
value18 = 0;
}
(bool success9, bytes memory returnData9) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(0); // staticcall
require(success9);
uint256 value20 = msg.data[0] >> 0xe0;
uint256 value21 = var_f.length;
if (success9) {
uint256 value19 = returnData9.length;
if (0x20 <= returnData9.length) {
value19 = 0x20;
}
if (((var_f + ((value19 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value19 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value19 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value19) - var_f) >= 0x20);
} else {
value20 = var_f;
value21 = 0;
}
bool flag6 = value21 < var_f.length;
if (value18 != 0x0) {
flag6 = value18 != 0x0;
}
uint256 value22 = msg.data[0] >> 0xe0;
uint256 value23 = msg.data[0] >> 0xe0;
bool flag7 = !((value21 - var_f.length) == value6);
if (!flag6) {
} else {
value22 = value21;
value23 = var_f.length;
flag7 = flag6;
}
require(!(flag7), CustomError_62c0d9df());
var_a = var_a;
emit Event_fbf559fe(0, var_a, value6);
stor_2 = 0x01;
}
if (0x20 > returnData1.length) {
if (((var_f + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + returnData1.length) - var_f) >= 0x20);
require(var_f.length == (address(var_f.length)));
bool flag8 = (address(var_f.length)) == address(this);
if (!(address(var_f.length))) {
flag8 = !(address(var_f.length));
}
require(!(flag8), CustomError_9faaa407());
(bool success10, bytes memory returnData10) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success10);
uint256 value25 = msg.data[0] >> 0xe0;
uint256 value26 = var_f.length;
if (success10) {
uint256 value24 = returnData10.length;
if (0x20 <= returnData10.length) {
value24 = 0x20;
}
if (((var_f + ((value24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value24) - var_f) >= 0x20);
} else {
value25 = var_f;
value26 = 0;
}
require(value26 != 0x0, CustomError_d5fbac7a());
(bool success11, bytes memory returnData11) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(var_f.length)); // staticcall
require(success11);
if (!(success11)) {
if (((var_f + 0x80) > 0xffffffffffffffff) | ((var_f + 0x80) < var_f)) _desolexPanic(65);
var_f = var_f + 0x80;
(bool success12, bytes memory returnData12) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).transfer(address(var_f.length), value26); // call
require(success12);
bool flag9 = !(0x01 == var_a);
if (returnData12.length == 0) {
flag9 = !(address(0x61e91daf03a49ecec334bffbf5008860cfb33333).code.length);
}
require(!(flag9), SafeERC20FailedOperation());
(bool success13, bytes memory returnData13) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success13);
uint256 value28 = 0x20;
uint256 value29 = var_f.length;
if (success13) {
uint256 value27 = returnData13.length;
if (0x20 <= returnData13.length) {
value27 = 0x20;
}
if (((var_f + ((value27 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value27 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value27 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value27) - var_f) >= 0x20);
} else {
value28 = var_f;
value29 = 0;
}
(bool success14, bytes memory returnData14) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(var_f.length)); // staticcall
require(success14);
uint256 value31 = msg.data[0] >> 0xe0;
uint256 value32 = var_f.length;
if (success14) {
uint256 value30 = returnData14.length;
if (0x20 <= returnData14.length) {
value30 = 0x20;
}
if (((var_f + ((value30 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value30 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value30 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value30) - var_f) >= 0x20);
} else {
value31 = var_f;
value32 = 0;
}
bool flag10 = value32 < 0x0;
if (value29 != 0x0) {
flag10 = value29 != 0x0;
}
uint256 value33 = msg.data[0] >> 0xe0;
uint256 value34 = msg.data[0] >> 0xe0;
if (!flag10) {
} else {
value33 = value32;
value34 = 0;
}
require(!(!flag10 && value32 - 0x0 != value26 || flag10), CustomError_62c0d9df());
var_a = var_a;
emit Event_fbf559fe(address(var_f.length), var_a, value26);
stor_2 = 0x01;
}
uint256 value35 = returnData11.length;
if (0x20 <= returnData11.length) {
value35 = 0x20;
}
if (((var_f + ((value35 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value35 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value35 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value35) - var_f) >= 0x20);
if (((var_f + 0x80) > 0xffffffffffffffff) | ((var_f + 0x80) < var_f)) _desolexPanic(65);
var_f = var_f + 0x80;
(bool success15, bytes memory returnData15) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).transfer(address(var_f.length), value26); // call
require(success15);
bool flag12 = !(0x01 == var_a);
if (returnData15.length == 0) {
flag12 = !(address(0x61e91daf03a49ecec334bffbf5008860cfb33333).code.length);
}
require(!(flag12), SafeERC20FailedOperation());
(bool success16, bytes memory returnData16) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success16);
uint256 value37 = 0x20;
uint256 value38 = var_f.length;
if (success16) {
uint256 value36 = returnData16.length;
if (0x20 <= returnData16.length) {
value36 = 0x20;
}
if (((var_f + ((value36 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value36 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value36 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value36) - var_f) >= 0x20);
} else {
value37 = var_f;
value38 = 0;
}
(bool success17, bytes memory returnData17) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(var_f.length)); // staticcall
require(success17);
uint256 value40 = msg.data[0] >> 0xe0;
uint256 value41 = var_f.length;
if (success17) {
uint256 value39 = returnData17.length;
if (0x20 <= returnData17.length) {
value39 = 0x20;
}
if (((var_f + ((value39 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value39 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value39 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value39) - var_f) >= 0x20);
} else {
value40 = var_f;
value41 = 0;
}
bool flag13 = value41 < var_f.length;
if (value38 != 0x0) {
flag13 = value38 != 0x0;
}
uint256 value42 = msg.data[0] >> 0xe0;
uint256 value43 = msg.data[0] >> 0xe0;
bool flag14 = !((value41 - var_f.length) == value26);
if (!flag13) {
} else {
value42 = value41;
value43 = var_f.length;
flag14 = flag13;
}
require(!(flag14), CustomError_62c0d9df());
var_a = var_a;
emit Event_fbf559fe(address(var_f.length), var_a, value26);
} else {
if (((var_f + 0x20) > 0xffffffffffffffff) | ((var_f + 0x20) < var_f)) _desolexPanic(65);
var_f = var_f + 0x20;
require(((var_f + 0x20) - var_f) >= 0x20);
require(var_f.length == (address(var_f.length)));
bool flag15 = (address(var_f.length)) == address(this);
if (!(address(var_f.length))) {
flag15 = !(address(var_f.length));
}
require(!(flag15), CustomError_9faaa407());
(bool success18, bytes memory returnData18) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success18);
uint256 value45 = msg.data[0] >> 0xe0;
uint256 value46 = var_f.length;
if (success18) {
uint256 value44 = returnData18.length;
if (0x20 <= returnData18.length) {
value44 = 0x20;
}
if (((var_f + ((value44 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value44 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value44 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value44) - var_f) >= 0x20);
} else {
value45 = var_f;
value46 = 0;
}
require(value46 != 0x0, CustomError_d5fbac7a());
(bool success19, bytes memory returnData19) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(var_f.length)); // staticcall
require(success19);
if (!(success19)) {
if (((var_f + 0x80) > 0xffffffffffffffff) | ((var_f + 0x80) < var_f)) _desolexPanic(65);
var_f = var_f + 0x80;
(bool success20, bytes memory returnData20) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).transfer(address(var_f.length), value46); // call
require(success20);
bool flag16 = !(0x01 == var_a);
if (returnData20.length == 0) {
flag16 = !(address(0x61e91daf03a49ecec334bffbf5008860cfb33333).code.length);
}
require(!(flag16), SafeERC20FailedOperation());
(bool success21, bytes memory returnData21) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success21);
uint256 value48 = 0x20;
uint256 value49 = var_f.length;
if (success21) {
uint256 value47 = returnData21.length;
if (0x20 <= returnData21.length) {
value47 = 0x20;
}
if (((var_f + ((value47 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value47 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value47 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value47) - var_f) >= 0x20);
} else {
value48 = var_f;
value49 = 0;
}
(bool success22, bytes memory returnData22) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(var_f.length)); // staticcall
require(success22);
uint256 value51 = msg.data[0] >> 0xe0;
uint256 value52 = var_f.length;
if (success22) {
uint256 value50 = returnData22.length;
if (0x20 <= returnData22.length) {
value50 = 0x20;
}
if (((var_f + ((value50 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value50 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value50 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value50) - var_f) >= 0x20);
} else {
value51 = var_f;
value52 = 0;
}
bool flag17 = value52 < 0x0;
if (value49 != 0x0) {
flag17 = value49 != 0x0;
}
uint256 value53 = msg.data[0] >> 0xe0;
uint256 value54 = msg.data[0] >> 0xe0;
if (!flag17) {
} else {
value53 = value52;
value54 = 0;
}
require(!(!flag17 && value52 - 0x0 != value46 || flag17), CustomError_62c0d9df());
var_a = var_a;
emit Event_fbf559fe(address(var_f.length), var_a, value46);
stor_2 = 0x01;
}
uint256 value55 = returnData19.length;
if (0x20 <= returnData19.length) {
value55 = 0x20;
}
if (((var_f + ((value55 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value55 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value55 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value55) - var_f) >= 0x20);
if (((var_f + 0x80) > 0xffffffffffffffff) | ((var_f + 0x80) < var_f)) _desolexPanic(65);
var_f = var_f + 0x80;
(bool success23, bytes memory returnData23) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).transfer(address(var_f.length), value46); // call
require(success23);
bool flag19 = !(0x01 == var_a);
if (returnData23.length == 0) {
flag19 = !(address(0x61e91daf03a49ecec334bffbf5008860cfb33333).code.length);
}
require(!(flag19), SafeERC20FailedOperation());
(bool success24, bytes memory returnData24) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success24);
uint256 value57 = 0x20;
uint256 value58 = var_f.length;
if (success24) {
uint256 value56 = returnData24.length;
if (0x20 <= returnData24.length) {
value56 = 0x20;
}
if (((var_f + ((value56 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value56 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value56 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value56) - var_f) >= 0x20);
} else {
value57 = var_f;
value58 = 0;
}
(bool success25, bytes memory returnData25) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(var_f.length)); // staticcall
require(success25);
uint256 value60 = msg.data[0] >> 0xe0;
uint256 value61 = var_f.length;
if (success25) {
uint256 value59 = returnData25.length;
if (0x20 <= returnData25.length) {
value59 = 0x20;
}
if (((var_f + ((value59 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value59 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value59 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value59) - var_f) >= 0x20);
} else {
value60 = var_f;
value61 = 0;
}
bool flag20 = value61 < var_f.length;
if (value58 != 0x0) {
flag20 = value58 != 0x0;
}
uint256 value62 = msg.data[0] >> 0xe0;
uint256 value63 = msg.data[0] >> 0xe0;
bool flag21 = !((value61 - var_f.length) == value46);
if (!flag20) {
} else {
value62 = value61;
value63 = var_f.length;
flag21 = flag20;
}
require(!(flag21), CustomError_62c0d9df());
var_a = var_a;
emit Event_fbf559fe(address(var_f.length), var_a, value46);
}
stor_2 = 0x01;
}
function getRoleAdmin(bytes32 role) public view returns (uint256) {
return stor_expr_d;
}
function Unknown_232879cf(uint256 arg0) public view returns (uint32) {
require(arg0 < 0x0a);
if (!((arg0 < 0x0a))) _desolexPanic(50);
return (stor_expr_al >> ((arg0 << 0x02) & (0x1c) << 0x03)) & (0xffffffff);
}
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_1e7b(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_z[arg1]))))) {
uint256 value1 = 0;
uint256 value2 = 0;
uint256 value3 = 0;
if ((mapping_expr_z[arg1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) != (getRoleMemberCount[arg0] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) {
if (!(((getRoleMemberCount[arg0] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < stor_expr_i))) _desolexPanic(50);
if (!(((mapping_expr_z[arg1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < stor_expr_j))) _desolexPanic(50);
stor_expr_ad = (0 & stor_expr_ae | (stor_expr_ac >> (0 << 0x03) << 0));
mapping_expr_z[stor_expr_ac >> (0 << 0x03)] = mapping_expr_z[arg1];
} else {
value1 = mapping_expr_z[arg1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
value2 = getRoleMemberCount[arg0] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
value3 = mapping_expr_z[arg1];
}
if (!(getRoleMemberCount[arg0])) _desolexPanic(49);
if (!(((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + getRoleMemberCount[arg0]) < stor_expr_p))) _desolexPanic(50);
stor_expr_ag = (~(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff << (0 << 0x03))) & stor_expr_ag;
getRoleMemberCount[arg0] = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + getRoleMemberCount[arg0];
mapping_expr_z[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()
// 0x232879cf => Unknown_232879cf(uint256)
// 0x248a9ca3 => getRoleAdmin(bytes32)
// 0x261341cc => Unknown_261341cc()
// 0x2f2ff15d => grantRole(bytes32,address)
// 0x36568abe => renounceRole(bytes32,address)
// 0x45992f43 => Unknown_45992f43()
// 0x45d94c51 => Unknown_45d94c51()
// 0x55fd7fa0 => moduleKey()
// 0x7656419f => protocolRegistry()
// 0x79bd9e41 => lastDistributedEpoch()
// 0x8ba1dbf7 => stakingMain()
// 0x9010d07c => Unknown_9010d07c(uint256,uint256)
// 0x91d14854 => hasRole(bytes32,address)
// 0x949f062d => Unknown_949f062d()
// 0x9ce6dd9f => hasOpenPositions()
// 0xa217fddf => DEFAULT_ADMIN_ROLE()
// 0xa3246ad3 => Unknown_a3246ad3(uint256)
// 0xca15c873 => getRoleMemberCount(bytes32)
// 0xd32867d0 => RATIO_PRECISION()
// 0xd547741f => revokeRole(bytes32,address)
// 0xe9c4a3ac => dispatch()
// 0xf08e7e8c => Unknown_f08e7e8c(bool)
// 0xf36c8f5c => GOVERNANCE_ROLE()
}