BNB Chain
0xe3a24afea37dc8547cedb480e291881bba335c31
Decompiled Solidity recovered from this contract's runtime bytecode. Best-effort reconstruction — confirm behaviour against on-chain state.
Decompilation outputBNB Chain · 0xe3a24afe…ba335c3114.3 KB21.7 s
This result is permanently available athttps://decompiler.exvul.com/bsc/0xe3a24afea37dc8547cedb480e291881bba335c31
//decompiled by exvvul decompiler tool [email protected] https://x.com/exvulsec
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;
contract DesolexContract {
uint256 public constant GOVERNANCE_ROLE = 51344670724517732003549907689393193919197804398902247150944709319656146718385;
address public constant stakedToken = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90);
uint256 public constant MAX_EPOCH_LENGTH = 2592000;
uint256 public constant DEFAULT_ADMIN_ROLE = 0;
address public constant protocolRegistry = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593);
uint256 public constant moduleKey = 25727345363390370839599297915092931842179525246167474880667594631952367445285;
uint256 public constant GUARDIAN_ROLE = 38565618417199902773051943526088628524471517387241857154768371431684916793409;
uint256 public constant interfaceVersion = 1;
address public constant protocolToken = address(0x61e91daf03a49ecec334bffbf5008860cfb33333);
uint256 public constant MIN_EPOCH_LENGTH = 60;
mapping(bytes32 => mapping(address => bool)) public hasRole; // STORAGE[0x0]
mapping(bytes32 => uint256) public getRoleMemberCount; // STORAGE[0x1]
bytes32 stor_2; // STORAGE[0x2]
uint64 stor_3; // STORAGE[0x3]
uint256 public totalPrincipal; // STORAGE[0x4]
uint256 public totalVaultPrincipal; // STORAGE[0x5]
uint256 public profit; // STORAGE[0x6]
bool public newStakingPaused; // STORAGE[0x7] bytes 0 to 0
mapping(address => uint256) public unresolved_092488f0; // STORAGE[0x8]
mapping(address => uint256) public vaultPrincipal; // STORAGE[0x9]
mapping(address => bool) mapping_316a51056d8b2401ab04c48d9973add294eadde229c785c6d19cde93785467ef; // STORAGE[0x316a51056d8b2401ab04c48d9973add294eadde229c785c6d19cde93785467ef]
mapping(address => uint256) mapping_expr_aq;
mapping(address => uint256) mapping_expr_f;
uint256 stor_expr_ap;
address stor_expr_ar;
bytes32 stor_expr_c;
uint256 stor_expr_h;
uint256 stor_expr_j;
bytes32 stor_expr_l;
uint256 stor_expr_m;
bytes32 stor_expr_n;
uint256 stor_expr_p;
uint256 stor_expr_q;
bytes32 stor_expr_y;
error InvalidEpochLength();
error CustomError_3e16baba();
error CustomError_5e08930c();
error CustomError_2c6f8587();
event RoleGranted(bytes32 indexed, address indexed, address indexed);
error SafeERC20FailedOperation(address);
error InsufficientReserve();
event Event_40409b77(uint256 indexed, uint256 indexed, uint256, uint256);
error CustomError_d1908c23();
error InsufficientReceiptBalance();
event Event_04b04d6c(uint256, uint256, uint256);
event Event_ba732029(uint256 indexed, uint256, uint256);
error AlreadyPaused();
event Event_b45d979c(uint256, uint256, uint256);
event RoleRevoked(bytes32 indexed, address indexed, address indexed);
error CustomError_61b33f00();
error EpochNotDue();
error CustomError_d0378693();
event Event_cf290932(uint256 indexed, uint256 indexed, uint256, uint256);
error ExceedsPrincipal();
error CustomError_6737a1e3();
error NotPaused();
event Event_1e750d55(uint256 indexed, address indexed);
error AccessControlBadConfirmation();
error EpochNotStarted();
event Event_2a0c0b7c(uint256 indexed, uint256, uint256, uint256);
error ReentrancyGuardReentrantCall();
error AccessControlUnauthorizedAccount(address, bytes32);
event PrincipalUnstaked(address indexed, uint256, uint256);
error CustomError_2104f790();
error ZeroAmount();
event Event_679f5082(uint256 indexed, uint256 indexed, uint256);
error CustomError_06ed793f();
error Insolvent();
error CustomError_1d3e9914();
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 == 0x06fbe47a)) {
// Route to Unknown_06fbe47a() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x15dd5788));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x0bb8102f)) {
// Route to Unknown_0bb8102f(address,uint256) after replacing only msg.sig.
__desolexSelectorShim(uint32(0x189fa5d2));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x0d60cf12)) {
// Route to Unknown_0d60cf12(address,uint256) after replacing only msg.sig.
__desolexSelectorShim(uint32(0x59660ef5));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x4757800c)) {
// Route to Unknown_4757800c() after replacing only msg.sig.
__desolexSelectorShim(uint32(0xf230e5f9));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x4973e066)) {
// Route to Unknown_4973e066(address,uint256) after replacing only msg.sig.
__desolexSelectorShim(uint32(0xe161833a));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x734f55c5)) {
// Route to Unknown_734f55c5(uint256,bool) after replacing only msg.sig.
__desolexSelectorShim(uint32(0x1a5e26e7));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x8b9dd40e)) {
// Route to Unknown_8b9dd40e(uint64) after replacing only msg.sig.
__desolexSelectorShim(uint32(0xe1ad13e7));
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 == 0xac060421)) {
// Route to Unknown_ac060421() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x59195d4e));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0xd547741f)) {
// Route to Unknown_d547741f(uint256,address) after replacing only msg.sig.
__desolexSelectorShim(uint32(0x36cc8c12));
return;
}
revert();
}
function accruedOf(address account) public returns (uint256) {
(bool success0, bytes memory returnData0) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).balanceOf(account); // staticcall
require(success0);
uint256 value1 = 0;
uint256 var_c;
uint256 value2 = var_c.length;
if (success0) {
uint256 value0 = returnData0.length;
if (0x20 <= returnData0.length) {
value0 = 0x20;
}
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);
} else {
value1 = var_c;
value2 = 0;
}
if (0 == (value2 > unresolved_092488f0[account])) {
return 0;
} else {
return value2 - unresolved_092488f0[account];
}
}
function Unknown_d547741f(uint256 arg0, address arg1) public {
require(bytes1(hasRole[stor_expr_c][msg.sender]), AccessControlUnauthorizedAccount());
internal_34b8(arg0, arg1);
}
function pauseNewStaking() public {
require(bytes1(hasRole[0x55435dd261a4b9b3364963f7738a7a662ad9c84396d64be3365284bb7f0a5041][msg.sender]), AccessControlUnauthorizedAccount());
require(!newStakingPaused, AlreadyPaused());
newStakingPaused = true;
emit Event_04b04d6c(0, 0x01, block.timestamp);
}
function startEpochs() public payable {
if (!(msg.value) && !((msg.data.length + 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc) < 0) && mapping_316a51056d8b2401ab04c48d9973add294eadde229c785c6d19cde93785467ef[msg.sender] && !(uint64(stor_3 >> 0x80))) {
var_a = var_a;
address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_a); // staticcall
}
}
function rebase() public {
require(stor_2 != 0x02, ReentrancyGuardReentrantCall());
stor_2 = 0x02;
require(uint64(stor_3 >> 0x80), EpochNotStarted());
require(block.timestamp >= uint64(stor_3 >> 0x80), EpochNotDue());
internal_2f30();
stor_2 = 0x01;
}
function Unknown_ac060421() public {
require(mapping_316a51056d8b2401ab04c48d9973add294eadde229c785c6d19cde93785467ef[msg.sender], AccessControlUnauthorizedAccount());
require(newStakingPaused, NotPaused());
newStakingPaused = false;
emit Event_04b04d6c(0x01, 0, block.timestamp);
}
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 reserveBalance() public returns (uint256) {
(bool success0, bytes memory returnData0) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success0);
if (success0) {
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;
} else {
return 0;
}
}
function hasOpenPositions() public returns (bool) {
(bool success0, bytes memory returnData0) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success0);
if (success0) {
uint256 value0 = returnData0.length;
if (0x20 <= returnData0.length) {
value0 = 0x20;
}
uint256 var_b;
if (((var_b + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65);
var_b = var_b + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_b + value0) - var_b) >= 0x20);
return var_b.length;
} else {
return false;
}
}
function Unknown_9010d07c(uint256 arg0, uint256 arg1) public view returns (address) {
if (!(arg1 < getRoleMemberCount[arg0])) _desolexPanic(50);
return address(stor_expr_y >> 0);
}
function Unknown_8b9dd40e(uint64 arg0) public {
require(arg0 == (arg0 & 0xffffffffffffffff));
var_b = var_b;
(bool success0, bytes memory returnData0) = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).isActive(var_b, msg.sender); // staticcall
require(success0);
if (!(success0)) {
require(0, CustomError_d1908c23());
require(!((arg0 & 0xffffffffffffffff) != 0x0 && (arg0 & 0xffffffffffffffff) != (SHR(0x40, stor_3) & 0xffffffffffffffff) || (arg0 & 0xffffffffffffffff) == 0x0), CustomError_2104f790());
require((stor_3 >> 0xc0) < (uint64(arg0)), CustomError_06ed793f());
stor_3 = (0xffffffffffffffff000000000000000000000000000000000000000000000000 & (arg0 << 0xc0)) | (stor_3 & (0xffffffffffffffffffffffffffffffffffffffffffffffff));
return;
}
if (0x20 > returnData0.length) {
uint256 var_e;
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 == var_e.length);
require(var_e.length != 0x0, CustomError_d1908c23());
require(!((arg0 & 0xffffffffffffffff) != 0x0 && (arg0 & 0xffffffffffffffff) != (SHR(0x40, stor_3) & 0xffffffffffffffff) || (arg0 & 0xffffffffffffffff) == 0x0), CustomError_2104f790());
} 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_d1908c23());
require(!((arg0 & 0xffffffffffffffff) != 0x0 && (arg0 & 0xffffffffffffffff) != (SHR(0x40, stor_3) & 0xffffffffffffffff) || (arg0 & 0xffffffffffffffff) == 0x0), CustomError_2104f790());
}
require((stor_3 >> 0xc0) < (uint64(arg0)), CustomError_06ed793f());
stor_3 = (0xffffffffffffffff000000000000000000000000000000000000000000000000 & (arg0 << 0xc0)) | (stor_3 & (0xffffffffffffffffffffffffffffffffffffffffffffffff));
}
function currentEpoch() public view returns (uint64) {
return uint64(stor_3 >> 0x40);
}
function Unknown_734f55c5(uint256 arg0, bool arg1) public payable {
if (!(msg.value)) {
if ((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) >= 0x60) {
if (arg1 == (arg1 & 0xff)) {
if (stor_2 != 0x02) {
stor_2 = 0x02;
if (uint64(stor_3 >> 0x80)) {
if (!(block.timestamp < (uint64(stor_3 >> 0x80)))) {
var_a = 0xde8ef1cd00000000000000000000000000000000000000000000000000000000;
(bool success0, bytes memory returnData0) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).Unknown_de8ef1cd(profit, uint64((stor_3 >> 0x40) + 0x01)); // call
require(success0);
uint256 value1 = 0;
uint256 var_d;
uint256 value5 = var_d.length;
if (success0) {
uint256 value0 = returnData0.length;
if (0x20 <= returnData0.length) {
value0 = 0x20;
}
if (((var_d + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value0) - var_d) >= 0x20);
} else {
value1 = var_d;
value5 = 0;
}
stor_3 = (0xffffffffffffffff00000000000000000000000000000000ffffffffffffffff & stor_3 | (0xffffffffffffffff0000000000000000 & (((stor_3 >> 0x40) & (0xffffffffffffffff) + 0x01) << 0x40))) | (((0xffffffffffffffff0000000000000000 & (((stor_3 >> 0x40) & (0xffffffffffffffff) + 0x01) << 0x40) | (stor_3 & (0xffffffffffffffffffffffffffffffff0000000000000000ffffffffffffffff)) >> 0x80) & (0xffffffffffffffff) & (0xffffffffffffffff) + (stor_3 & (0xffffffffffffffff) & (0xffffffffffffffff)) << 0x80) & (0xffffffffffffffff00000000000000000000000000000000));
var_f = var_f;
(bool success1, bytes memory returnData1) = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_f); // staticcall
require(success1);
uint256 value2 = 0;
uint256 value3 = var_d.length;
if (success1) {
if (0x20 > returnData1.length) {
if (((var_d + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + returnData1.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 {
value2 = var_d;
value3 = 0;
}
require(value3.code.length != 0x0, CustomError_6737a1e3());
require(value3.code.length != 0x0);
(bool success2, bytes memory returnData2) = address(value3).distribute(); // call
uint256 value4 = 0;
if (success2) {
if (((var_d + 0) > 0xffffffffffffffff) | ((var_d + 0) < var_d)) _desolexPanic(65);
var_d = var_d + 0;
} else {
value4 = var_d;
}
if (success2) {
(bool success3, bytes memory returnData3) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success3);
uint256 value9 = var_d.length;
if (success3) {
uint256 value6 = returnData3.length;
if (0x20 <= returnData3.length) {
value6 = 0x20;
}
if (((var_d + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value6) - var_d) >= 0x20);
} else {
value9 = 0;
}
(bool success4, bytes memory returnData4) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success4);
uint256 value8 = var_d.length;
if (success4) {
uint256 value7 = returnData4.length;
if (0x20 <= returnData4.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 = 0;
}
require(value9 >= value8, Insolvent());
profit = value9 - value8;
} else {
if (returnData2.length == 0) {
uint256 value10 = 0;
uint256 value11 = (var_a & (0xffffffff00000000000000000000000000000000000000000000000000000000 << ((0x04 - var_m) << 0x03))) & (0xffffffff00000000000000000000000000000000000000000000000000000000);
if (var_m >= 0x04) {
value10 = var_a;
value11 = var_a & (0xffffffff00000000000000000000000000000000000000000000000000000000);
}
require(!(0x87fd863100000000000000000000000000000000000000000000000000000000 + (0xffffffff00000000000000000000000000000000000000000000000000000000 & value11)));
emit Event_1e750d55(uint64((stor_3 >> 0x40) + 0x01), address(value3));
(bool success5, bytes memory returnData5) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success5);
uint256 value15 = var_d.length;
if (success5) {
uint256 value12 = returnData5.length;
if (0x20 <= returnData5.length) {
value12 = 0x20;
}
if (((var_d + ((value12 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value12 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value12 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value12) - var_d) >= 0x20);
} else {
value15 = 0;
}
(bool success6, bytes memory returnData6) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success6);
uint256 value14 = var_d.length;
if (success6) {
uint256 value13 = returnData6.length;
if (0x20 <= returnData6.length) {
value13 = 0x20;
}
if (((var_d + ((value13 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value13 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value13 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value13) - var_d) >= 0x20);
} else {
value14 = 0;
}
require(value15 >= value14, Insolvent());
profit = value15 - value14;
} else {
if (!(returnData2.length <= 0xffffffffffffffff)) _desolexPanic(65);
if (((var_d + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData2.length + 0x1f))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData2.length + 0x1f))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData2.length + 0x1f))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
uint256 value16 = 0;
uint256 value17 = (var_n & (0xffffffff00000000000000000000000000000000000000000000000000000000 << ((0x04 - var_d.length) << 0x03))) & (0xffffffff00000000000000000000000000000000000000000000000000000000);
if (var_d.length >= 0x04) {
value16 = var_n;
value17 = var_n & (0xffffffff00000000000000000000000000000000000000000000000000000000);
}
require(!(0x87fd863100000000000000000000000000000000000000000000000000000000 + (0xffffffff00000000000000000000000000000000000000000000000000000000 & value17)));
emit Event_1e750d55(uint64((stor_3 >> 0x40) + 0x01), address(value3));
(bool success7, bytes memory returnData7) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success7);
uint256 value21 = var_d.length;
if (success7) {
uint256 value18 = returnData7.length;
if (0x20 <= returnData7.length) {
value18 = 0x20;
}
if (((var_d + ((value18 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value18 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value18 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value18) - var_d) >= 0x20);
} else {
value21 = 0;
}
(bool success8, bytes memory returnData8) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success8);
uint256 value20 = var_d.length;
if (success8) {
uint256 value19 = returnData8.length;
if (0x20 <= returnData8.length) {
value19 = 0x20;
}
if (((var_d + ((value19 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value19 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value19 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value19) - var_d) >= 0x20);
} else {
value20 = 0;
}
require(value21 >= value20, Insolvent());
profit = value21 - value20;
}
}
emit Event_2a0c0b7c(uint64((stor_3 >> 0x40) + 0x01), value5, profit, uint64(stor_3 >> 0x80));
}
if (arg0 != 0x0) {
(bool success9, bytes memory returnData9) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).balanceOf(msg.sender); // staticcall
if (success9) {
uint256 value23 = 0;
uint256 value24 = var_d.length;
if (success9) {
uint256 value22 = returnData9.length;
if (0x20 <= returnData9.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);
} else {
value23 = var_d;
value24 = 0;
}
if ((0 != (value24 > unresolved_092488f0[msg.sender])) && (arg0 <= (value24 - unresolved_092488f0[msg.sender]))) {
address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(0xb6366bdf3e1f1a56d6b04f2715d3d26eda4eb524e2f1da91dc9063fdad2dd486); // staticcall
}
}
}
}
}
}
}
}
}
function epochLength() public view returns (uint64) {
return uint64(stor_3);
}
function epochEnd() public view returns (uint64) {
return uint64(stor_3 >> 0x80);
}
function Unknown_4973e066(address account, uint256 arg1) public payable {
if (!(msg.value)) {
if ((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) >= 0x40) {
if (account == account) {
if (stor_2 != 0x02) {
stor_2 = 0x02;
(bool success0, bytes memory returnData0) = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).statusOf(0x624f60ef0707af2659aff7fc3b84264f4a208e7d08a6af32641b2ccd028561d5, msg.sender); // staticcall
if (success0) {
uint256 value1 = 0;
uint256 var_d;
uint256 value2 = var_d.length;
if (success0) {
uint256 value0 = returnData0.length;
if (0x20 <= returnData0.length) {
value0 = 0x20;
}
if (((var_d + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value0) - var_d) >= 0x20);
require(var_d.length < 0x05);
} else {
value1 = var_d;
value2 = 0;
}
if (value2 < 0x05) {
uint256 value87 = 0;
bool flag1 = value2 == 0x2;
if (value2 == 0x01) {
flag0 = value2 >= 0x5;
flag1 = value2 == 0x1;
}
if (flag1) {
if (flag1) {
if (uint64(stor_3 >> 0x80)) {
if (block.timestamp < (uint64(stor_3 >> 0x80))) {
if (account != address(0)) {
if (arg1 != 0x0) {
if (arg1 <= vaultPrincipal[msg.sender]) {
(bool success1, bytes memory returnData1) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).balanceOf(msg.sender); // staticcall
if (success1) {
uint256 value4 = 0;
uint256 value5 = var_d.length;
if (success1) {
uint256 value3 = returnData1.length;
if (0x20 <= returnData1.length) {
value3 = 0x20;
}
if (((var_d + ((value3 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value3 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value3 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value3) - var_d) >= 0x20);
} else {
value4 = var_d;
value5 = 0;
}
if (arg1 <= value5) {
(bool success2, bytes memory returnData2) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
if (success2) {
if (!(success2)) {
(bool success3, bytes memory returnData3) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(account); // staticcall
if (success3) {
uint256 value7 = 0;
uint256 value8 = var_d.length;
if (success3) {
uint256 value6 = returnData3.length;
if (0x20 <= returnData3.length) {
value6 = 0x20;
}
if (((var_d + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value6) - var_d) >= 0x20);
} else {
value7 = var_d;
value8 = 0;
}
(bool success4, bytes memory returnData4) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).balanceOf(msg.sender); // staticcall
if (success4) {
uint256 value10 = 0;
uint256 value12 = var_d.length;
if (success4) {
uint256 value9 = returnData4.length;
if (0x20 <= returnData4.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);
} else {
value10 = var_d;
value12 = 0;
}
(bool success5, bytes memory returnData5) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
if (success5) {
if (success5) {
uint256 value11 = returnData5.length;
if (0x20 <= returnData5.length) {
value11 = 0x20;
}
if (((var_d + ((value11 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value11 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value11 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value11) - var_d) >= 0x20);
var_e = msg.sender;
vaultPrincipal[msg.sender] = vaultPrincipal[msg.sender] - arg1;
totalVaultPrincipal = totalVaultPrincipal - arg1;
require(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90.code.length != 0x0);
(bool success6, bytes memory returnData6) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).burn(msg.sender, arg1); // call
require(success6);
uint256 value13 = 0;
if (success6) {
if (((var_d + 0) > 0xffffffffffffffff) | ((var_d + 0) < var_d)) _desolexPanic(65);
var_d = var_d + 0;
require(!(0));
} else {
value13 = var_d;
}
(bool success7, bytes memory returnData7) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).balanceOf(msg.sender); // staticcall
require(success7);
uint256 value15 = 0;
uint256 value17 = var_d.length;
if (success7) {
uint256 value14 = returnData7.length;
if (0x20 <= returnData7.length) {
value14 = 0x20;
}
if (((var_d + ((value14 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value14 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value14 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value14) - var_d) >= 0x20);
} else {
value15 = var_d;
value17 = 0;
}
(bool success8, bytes memory returnData8) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success8);
if (success8) {
uint256 value16 = returnData8.length;
if (0x20 <= returnData8.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);
uint256 value18 = var_d.length - var_d.length;
if (!(var_d.length > var_d.length)) {
} else {
value18 = 0;
}
uint256 value19 = 0;
uint256 value20 = 0;
bool flag2 = value12 - value17 != arg1;
if (value17 <= value12) {
} else {
value19 = value12;
value20 = value17;
flag2 = value17 > value12;
}
bool flag3 = value18 < arg1;
if (flag2) {
flag3 = flag2;
}
uint256 value21 = 0;
if (!flag3) {
} else {
value21 = value18;
}
require(!(!flag3 && value18 - arg1 > 0x1 || flag3), CustomError_5e08930c());
if (((var_d + 0x80) > 0xffffffffffffffff) | ((var_d + 0x80) < var_d)) _desolexPanic(65);
var_d = var_d + 0x80;
(bool success9, bytes memory returnData9) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).transfer(account, arg1); // call
require(success9);
bool flag5 = !(0x01 == var_e);
if (returnData9.length == 0) {
flag5 = !(address(0x61e91daf03a49ecec334bffbf5008860cfb33333).code.length);
}
require(!(flag5), SafeERC20FailedOperation());
(bool success10, bytes memory returnData10) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success10);
if (success10) {
uint256 value22 = returnData10.length;
if (0x20 <= returnData10.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);
(bool success11, bytes memory returnData11) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(account); // staticcall
require(success11);
uint256 value24 = 0;
uint256 value25 = var_d.length;
if (success11) {
uint256 value23 = returnData11.length;
if (0x20 <= returnData11.length) {
value23 = 0x20;
}
if (((var_d + ((value23 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value23 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value23 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value23) - var_d) >= 0x20);
} else {
value24 = var_d;
value25 = 0;
}
uint256 value26 = 0;
bool flag6 = !((0 - var_d.length) == arg1);
if (!(var_d.length > 0)) {
} else {
value26 = var_d.length;
flag6 = var_d.length > 0;
}
bool flag7 = value25 < value8;
if (flag6) {
flag7 = flag6;
}
uint256 value27 = 0;
uint256 value28 = 0;
if (!flag7) {
} else {
value27 = value25;
value28 = value8;
}
require(!(!flag7 && value25 - value8 != arg1 || flag7), CustomError_61b33f00());
(bool success12, bytes memory returnData12) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success12);
uint256 value32 = var_d.length;
if (success12) {
uint256 value29 = returnData12.length;
if (0x20 <= returnData12.length) {
value29 = 0x20;
}
if (((var_d + ((value29 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value29 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value29 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value29) - var_d) >= 0x20);
} else {
value32 = 0;
}
(bool success13, bytes memory returnData13) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success13);
uint256 value31 = var_d.length;
if (success13) {
uint256 value30 = returnData13.length;
if (0x20 <= returnData13.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);
} else {
value31 = 0;
}
require(value32 >= value31, Insolvent());
profit = value32 - value31;
} else {
(bool success14, bytes memory returnData14) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(account); // staticcall
require(success14);
uint256 value34 = 0;
uint256 value35 = var_d.length;
if (success14) {
uint256 value33 = returnData14.length;
if (0x20 <= returnData14.length) {
value33 = 0x20;
}
if (((var_d + ((value33 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value33 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value33 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value33) - var_d) >= 0x20);
} else {
value34 = var_d;
value35 = 0;
}
bool flag9 = 0x0 != arg1;
bool flag10 = value35 < value8;
if (flag9) {
flag10 = flag9;
}
uint256 value36 = 0;
uint256 value37 = 0;
if (!flag10) {
} else {
value36 = value35;
value37 = value8;
}
require(!(!flag10 && value35 - value8 != arg1 || flag10), CustomError_61b33f00());
(bool success15, bytes memory returnData15) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success15);
uint256 value41 = var_d.length;
if (success15) {
uint256 value38 = returnData15.length;
if (0x20 <= returnData15.length) {
value38 = 0x20;
}
if (((var_d + ((value38 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value38 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value38 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value38) - var_d) >= 0x20);
} else {
value41 = 0;
}
(bool success16, bytes memory returnData16) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success16);
uint256 value40 = var_d.length;
if (success16) {
uint256 value39 = returnData16.length;
if (0x20 <= returnData16.length) {
value39 = 0x20;
}
if (((var_d + ((value39 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value39 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value39 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value39) - var_d) >= 0x20);
} else {
value40 = 0;
}
require(value41 >= value40, Insolvent());
profit = value41 - value40;
var_e = msg.sender;
}
} else {
uint256 value42 = var_d.length - 0;
if (!(0 > var_d.length)) {
} else {
value42 = 0;
}
uint256 value43 = 0;
uint256 value44 = 0;
bool flag12 = value12 - value17 != arg1;
if (value17 <= value12) {
} else {
value43 = value12;
value44 = value17;
flag12 = value17 > value12;
}
bool flag13 = value42 < arg1;
if (flag12) {
flag13 = flag12;
}
uint256 value45 = 0;
if (!flag13) {
} else {
value45 = value42;
}
require(!(!flag13 && value42 - arg1 > 0x1 || flag13), CustomError_5e08930c());
if (((var_d + 0x80) > 0xffffffffffffffff) | ((var_d + 0x80) < var_d)) _desolexPanic(65);
var_d = var_d + 0x80;
(bool success17, bytes memory returnData17) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).transfer(account, arg1); // call
require(success17);
bool flag15 = !(0x01 == var_e);
if (returnData17.length == 0) {
flag15 = !(address(0x61e91daf03a49ecec334bffbf5008860cfb33333).code.length);
}
require(!(flag15), SafeERC20FailedOperation());
(bool success18, bytes memory returnData18) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success18);
if (success18) {
uint256 value46 = returnData18.length;
if (0x20 <= returnData18.length) {
value46 = 0x20;
}
if (((var_d + ((value46 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value46 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value46 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value46) - var_d) >= 0x20);
(bool success19, bytes memory returnData19) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(account); // staticcall
require(success19);
uint256 value48 = 0;
uint256 value49 = var_d.length;
if (success19) {
uint256 value47 = returnData19.length;
if (0x20 <= returnData19.length) {
value47 = 0x20;
}
if (((var_d + ((value47 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value47 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value47 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value47) - var_d) >= 0x20);
} else {
value48 = var_d;
value49 = 0;
}
uint256 value50 = 0;
bool flag16 = !((0 - var_d.length) == arg1);
if (!(var_d.length > 0)) {
} else {
value50 = var_d.length;
flag16 = var_d.length > 0;
}
bool flag17 = value49 < value8;
if (flag16) {
flag17 = flag16;
}
uint256 value51 = 0;
uint256 value52 = 0;
if (!flag17) {
} else {
value51 = value49;
value52 = value8;
}
require(!(!flag17 && value49 - value8 != arg1 || flag17), CustomError_61b33f00());
(bool success20, bytes memory returnData20) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success20);
uint256 value56 = var_d.length;
if (success20) {
uint256 value53 = returnData20.length;
if (0x20 <= returnData20.length) {
value53 = 0x20;
}
if (((var_d + ((value53 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value53 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value53 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value53) - var_d) >= 0x20);
} else {
value56 = 0;
}
(bool success21, bytes memory returnData21) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success21);
uint256 value55 = var_d.length;
if (success21) {
uint256 value54 = returnData21.length;
if (0x20 <= returnData21.length) {
value54 = 0x20;
}
if (((var_d + ((value54 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value54 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value54 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value54) - var_d) >= 0x20);
} else {
value55 = 0;
}
require(value56 >= value55, Insolvent());
profit = value56 - value55;
} else {
(bool success22, bytes memory returnData22) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(account); // staticcall
require(success22);
uint256 value58 = 0;
uint256 value59 = var_d.length;
if (success22) {
uint256 value57 = returnData22.length;
if (0x20 <= returnData22.length) {
value57 = 0x20;
}
if (((var_d + ((value57 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value57 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value57 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value57) - var_d) >= 0x20);
} else {
value58 = var_d;
value59 = 0;
}
bool flag19 = 0x0 != arg1;
bool flag20 = value59 < value8;
if (flag19) {
flag20 = flag19;
}
uint256 value60 = 0;
uint256 value61 = 0;
if (!flag20) {
} else {
value60 = value59;
value61 = value8;
}
require(!(!flag20 && value59 - value8 != arg1 || flag20), CustomError_61b33f00());
(bool success23, bytes memory returnData23) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success23);
uint256 value65 = var_d.length;
if (success23) {
uint256 value62 = returnData23.length;
if (0x20 <= returnData23.length) {
value62 = 0x20;
}
if (((var_d + ((value62 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value62 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value62 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value62) - var_d) >= 0x20);
} else {
value65 = 0;
}
(bool success24, bytes memory returnData24) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success24);
uint256 value64 = var_d.length;
if (success24) {
uint256 value63 = returnData24.length;
if (0x20 <= returnData24.length) {
value63 = 0x20;
}
if (((var_d + ((value63 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value63 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value63 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value63) - var_d) >= 0x20);
} else {
value64 = 0;
}
require(value65 >= value64, Insolvent());
profit = value65 - value64;
}
}
emit Event_40409b77(msg.sender, account, arg1, vaultPrincipal[msg.sender]);
stor_2 = 0x01;
return;
} else {
var_e = msg.sender;
vaultPrincipal[msg.sender] = vaultPrincipal[msg.sender] - arg1;
totalVaultPrincipal = totalVaultPrincipal - arg1;
require(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90.code.length != 0x0);
(bool success25, bytes memory returnData25) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).burn(msg.sender, arg1); // call
if (success25) {
uint256 value66 = 0;
if (success25) {
if (((var_d + 0) > 0xffffffffffffffff) | ((var_d + 0) < var_d)) _desolexPanic(65);
var_d = var_d + 0;
require(!(0));
} else {
value66 = var_d;
}
(bool success26, bytes memory returnData26) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).balanceOf(msg.sender); // staticcall
if (success26) {
uint256 value68 = 0;
uint256 value70 = var_d.length;
if (success26) {
uint256 value67 = returnData26.length;
if (0x20 <= returnData26.length) {
value67 = 0x20;
}
if (((var_d + ((value67 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value67 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value67 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value67) - var_d) >= 0x20);
} else {
value68 = var_d;
value70 = 0;
}
(bool success27, bytes memory returnData27) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
if (success27) {
if (success27) {
uint256 value69 = returnData27.length;
if (0x20 <= returnData27.length) {
value69 = 0x20;
}
if (((var_d + ((value69 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value69 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value69 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value69) - var_d) >= 0x20);
uint256 value71 = 0 - var_d.length;
if (!(var_d.length > 0)) {
} else {
value71 = 0;
}
uint256 value72 = 0;
uint256 value73 = 0;
bool flag22 = value12 - value70 != arg1;
if (value70 <= value12) {
} else {
value72 = value12;
value73 = value70;
flag22 = value70 > value12;
}
bool flag23 = value71 < arg1;
if (flag22) {
flag23 = flag22;
}
uint256 value74 = 0;
if (!flag23) {
} else {
value74 = value71;
}
if (!(!flag23 && value71 - arg1 > 0x1 || flag23)) {
if (((var_d + 0x80) > 0xffffffffffffffff) | ((var_d + 0x80) < var_d)) _desolexPanic(65);
var_d = var_d + 0x80;
(bool success28, bytes memory returnData28) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).transfer(account, arg1); // call
require(success28);
bool flag25 = !(0x01 == var_e);
if (returnData28.length == 0) {
flag25 = !(address(0x61e91daf03a49ecec334bffbf5008860cfb33333).code.length);
}
require(!(flag25), SafeERC20FailedOperation());
(bool success29, bytes memory returnData29) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
if (success29) {
if (success29) {
uint256 value75 = returnData29.length;
if (0x20 <= returnData29.length) {
value75 = 0x20;
}
if (((var_d + ((value75 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value75 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value75 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
if (((var_d + value75) - var_d) >= 0x20) {
(bool success30, bytes memory returnData30) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(account); // staticcall
if (success30) {
uint256 value77 = 0;
uint256 value78 = var_d.length;
if (success30) {
uint256 value76 = returnData30.length;
if (0x20 <= returnData30.length) {
value76 = 0x20;
}
if (((var_d + ((value76 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value76 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value76 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value76) - var_d) >= 0x20);
} else {
value77 = var_d;
value78 = 0;
}
uint256 value79 = 0;
bool flag26 = !((0 - var_d.length) == arg1);
if (!(var_d.length > 0)) {
} else {
value79 = var_d.length;
flag26 = var_d.length > 0;
}
bool flag27 = value78 < value8;
if (flag26) {
flag27 = flag26;
}
uint256 value80 = 0;
uint256 value81 = 0;
if (!flag27) {
} else {
value80 = value78;
value81 = value8;
}
if (!(!flag27 && value78 - value8 != arg1 || flag27)) {
(bool success31, bytes memory returnData31) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
if (success31 && !(success31)) {
address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
}
}
}
}
} else {
(bool success33, bytes memory returnData33) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(account); // staticcall
require(success33);
uint256 value83 = 0;
uint256 value84 = var_d.length;
if (success33) {
uint256 value82 = returnData33.length;
if (0x20 <= returnData33.length) {
value82 = 0x20;
}
if (((var_d + ((value82 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value82 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value82 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value82) - var_d) >= 0x20);
} else {
value83 = var_d;
value84 = 0;
}
bool flag29 = 0x0 != arg1;
bool flag30 = value84 < value8;
if (flag29) {
flag30 = flag29;
}
uint256 value85 = 0;
uint256 value86 = 0;
if (!flag30) {
} else {
value85 = value84;
value86 = value8;
}
require(!(!flag30 && value84 - value8 != arg1 || flag30), CustomError_61b33f00());
internal_352e();
emit Event_40409b77(msg.sender, account, arg1, vaultPrincipal[msg.sender]);
stor_2 = 0x01;
return;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
function Unknown_4757800c() public view returns (uint256) {
return stor_3 >> 0xc0;
}
function setEpochLength(uint64 arg0) public {
require(arg0 == (arg0 & 0xffffffffffffffff));
require(mapping_316a51056d8b2401ab04c48d9973add294eadde229c785c6d19cde93785467ef[msg.sender], AccessControlUnauthorizedAccount());
require(!((arg0 & 0xffffffffffffffff) >= 0x3c && (arg0 & 0xffffffffffffffff) > 0x278d00 || (arg0 & 0xffffffffffffffff) < 0x3c), InvalidEpochLength());
stor_3 = (stor_3 & (0xffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000)) | (arg0 & (0xffffffffffffffff));
emit Event_b45d979c(uint64(stor_3), uint64(arg0), block.timestamp);
}
function availableSurplus() public returns (uint256) {
(bool success0, bytes memory returnData0) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success0);
if (success0) {
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);
(bool success1, bytes memory returnData1) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success1);
if (success1) {
uint256 value1 = returnData1.length;
if (0x20 <= returnData1.length) {
value1 = 0x20;
}
if (((var_c + ((value1 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((value1 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65);
var_c = var_c + ((value1 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_c + value1) - var_c) >= 0x20);
require(var_c.length >= var_c.length, Insolvent());
return var_c.length - var_c.length;
} else {
require(var_c.length >= 0, Insolvent());
return var_c.length - 0;
}
} else {
(bool success2, bytes memory returnData2) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success2);
if (success2) {
uint256 value2 = returnData2.length;
if (0x20 <= returnData2.length) {
value2 = 0x20;
}
if (((var_c + ((value2 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((value2 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65);
var_c = var_c + ((value2 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_c + value2) - var_c) >= 0x20);
require(0 >= var_c.length, Insolvent());
return 0 - var_c.length;
} else {
require(0 >= 0, Insolvent());
return 0;
}
}
}
function unstakeFor(address account, uint256 arg1) public {
(bool success0, bytes memory returnData0) = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).isActive(0x39485061e9df9de2e52725d3f549782722891330cb556e7e1c6c81b75a5d6f34, msg.sender); // staticcall
require(success0);
if (!(success0)) {
require(0, CustomError_d0378693());
require(stor_2 != 0x02, ReentrancyGuardReentrantCall());
stor_2 = 0x02;
require(arg1 != 0x0, ZeroAmount());
require(arg1 <= unresolved_092488f0[account], ExceedsPrincipal());
(bool success1, bytes memory returnData1) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).balanceOf(account); // staticcall
require(success1);
uint256 value1 = 0;
uint256 var_f;
uint256 value2 = var_f.length;
if (success1) {
uint256 value0 = returnData1.length;
if (0x20 <= returnData1.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);
} else {
value1 = var_f;
value2 = 0;
}
require(arg1 <= value2, InsufficientReceiptBalance());
var_d = account;
unresolved_092488f0[account] = unresolved_092488f0[account] - arg1;
totalPrincipal = totalPrincipal - arg1;
require(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90.code.length != 0x0);
(bool success2, bytes memory returnData2) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).burn(account, arg1); // call
require(success2);
uint256 value3 = (arg1) ? 1 : 0;
if (success2) {
if (((var_f + 0) > 0xffffffffffffffff) | ((var_f + 0) < var_f)) _desolexPanic(65);
var_f = var_f + 0;
} else {
value3 = var_f;
}
if (((var_f + 0x80) > 0xffffffffffffffff) | ((var_f + 0x80) < var_f)) _desolexPanic(65);
var_f = var_f + 0x80;
(bool success3, bytes memory returnData3) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).transfer(account, arg1); // call
require(success3);
bool flag0 = !(0x01 == var_d);
if (returnData3.length == 0) {
flag0 = !(address(0x61e91daf03a49ecec334bffbf5008860cfb33333).code.length);
}
require(!(flag0), SafeERC20FailedOperation());
(bool success4, bytes memory returnData4) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success4);
uint256 value7 = var_f.length;
if (success4) {
uint256 value4 = returnData4.length;
if (0x20 <= returnData4.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 {
value7 = 0;
}
(bool success5, bytes memory returnData5) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success5);
uint256 value6 = var_f.length;
if (success5) {
uint256 value5 = returnData5.length;
if (0x20 <= returnData5.length) {
value5 = 0x20;
}
if (((var_f + ((value5 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value5 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value5 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value5) - var_f) >= 0x20);
} else {
value6 = 0;
}
require(value7 >= value6, Insolvent());
profit = value7 - value6;
emit PrincipalUnstaked(account, arg1, unresolved_092488f0[account]);
stor_2 = 0x01;
return;
}
if (0x20 > returnData0.length) {
if (((var_f + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + returnData0.length) - var_f) >= 0x20);
require(var_f.length == var_f.length);
require(var_f.length != 0x0, CustomError_d0378693());
require(stor_2 != 0x02, ReentrancyGuardReentrantCall());
stor_2 = 0x02;
require(arg1 != 0x0, ZeroAmount());
require(arg1 <= unresolved_092488f0[account], ExceedsPrincipal());
(bool success6, bytes memory returnData6) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).balanceOf(account); // staticcall
require(success6);
uint256 value9 = 0;
uint256 value10 = var_f.length;
if (success6) {
uint256 value8 = returnData6.length;
if (0x20 <= returnData6.length) {
value8 = 0x20;
}
if (((var_f + ((value8 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value8 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value8 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value8) - var_f) >= 0x20);
} else {
value9 = var_f;
value10 = 0;
}
require(arg1 <= value10, InsufficientReceiptBalance());
var_d = account;
unresolved_092488f0[account] = unresolved_092488f0[account] - arg1;
totalPrincipal = totalPrincipal - arg1;
require(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90.code.length != 0x0);
(bool success7, bytes memory returnData7) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).burn(account, arg1); // call
require(success7);
uint256 value11 = (arg1) ? 1 : 0;
if (success7) {
if (((var_f + 0) > 0xffffffffffffffff) | ((var_f + 0) < var_f)) _desolexPanic(65);
var_f = var_f + 0;
} else {
value11 = var_f;
}
if (((var_f + 0x80) > 0xffffffffffffffff) | ((var_f + 0x80) < var_f)) _desolexPanic(65);
var_f = var_f + 0x80;
(bool success8, bytes memory returnData8) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).transfer(account, arg1); // call
require(success8);
bool flag1 = !(0x01 == var_d);
if (returnData8.length == 0) {
flag1 = !(address(0x61e91daf03a49ecec334bffbf5008860cfb33333).code.length);
}
require(!(flag1), SafeERC20FailedOperation());
(bool success9, bytes memory returnData9) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success9);
uint256 value15 = var_f.length;
if (success9) {
uint256 value12 = returnData9.length;
if (0x20 <= returnData9.length) {
value12 = 0x20;
}
if (((var_f + ((value12 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value12 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value12 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value12) - var_f) >= 0x20);
} else {
value15 = 0;
}
(bool success10, bytes memory returnData10) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success10);
uint256 value14 = var_f.length;
if (success10) {
uint256 value13 = returnData10.length;
if (0x20 <= returnData10.length) {
value13 = 0x20;
}
if (((var_f + ((value13 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_f + ((value13 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_f)) _desolexPanic(65);
var_f = var_f + ((value13 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_f + value13) - var_f) >= 0x20);
} else {
value14 = 0;
}
require(value15 >= value14, Insolvent());
profit = value15 - value14;
} 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 == var_f.length);
require(var_f.length != 0x0, CustomError_d0378693());
require(stor_2 != 0x02, ReentrancyGuardReentrantCall());
stor_2 = 0x02;
require(arg1 != 0x0, ZeroAmount());
require(arg1 <= unresolved_092488f0[account], ExceedsPrincipal());
(bool success11, bytes memory returnData11) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).balanceOf(account); // staticcall
require(success11);
uint256 value17 = 0;
uint256 value18 = var_f.length;
if (success11) {
uint256 value16 = returnData11.length;
if (0x20 <= returnData11.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;
}
require(arg1 <= value18, InsufficientReceiptBalance());
var_d = account;
unresolved_092488f0[account] = unresolved_092488f0[account] - arg1;
totalPrincipal = totalPrincipal - arg1;
require(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90.code.length != 0x0);
(bool success12, bytes memory returnData12) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).burn(account, arg1); // call
require(success12);
uint256 value19 = (arg1) ? 1 : 0;
if (success12) {
if (((var_f + 0) > 0xffffffffffffffff) | ((var_f + 0) < var_f)) _desolexPanic(65);
var_f = var_f + 0;
} else {
value19 = var_f;
}
if (((var_f + 0x80) > 0xffffffffffffffff) | ((var_f + 0x80) < var_f)) _desolexPanic(65);
var_f = var_f + 0x80;
(bool success13, bytes memory returnData13) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).transfer(account, arg1); // call
require(success13);
bool flag2 = !(0x01 == var_d);
if (returnData13.length == 0) {
flag2 = !(address(0x61e91daf03a49ecec334bffbf5008860cfb33333).code.length);
}
require(!(flag2), SafeERC20FailedOperation());
internal_352e();
}
emit PrincipalUnstaked(account, arg1, unresolved_092488f0[account]);
stor_2 = 0x01;
}
function renounceRole(bytes32 role, address account) public {
require(account == msg.sender, AccessControlBadConfirmation());
internal_34b8(role, account);
}
function grantRole(bytes32 role, address account) public {
require(bytes1(hasRole[stor_expr_c][msg.sender]), AccessControlUnauthorizedAccount());
if (!(bytes1(hasRole[role][account]) != 0x0)) {
hasRole[role][account] = true;
emit RoleGranted(role, account, msg.sender);
}
if (!(0 == (!(mapping_expr_aq[account])))) {
if (!(stor_expr_ap < 0x010000000000000000)) _desolexPanic(65);
stor_expr_ap = stor_expr_ap + 0x01;
if (!(stor_expr_ap < stor_expr_ap)) _desolexPanic(50);
stor_expr_ar = (0 & stor_expr_ar) | (account << 0);
mapping_expr_aq[account] = stor_expr_ap;
}
}
function stakeFor(address arg0, uint256 arg1) public {
(bool success0, bytes memory returnData0) = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).isActive(0x39485061e9df9de2e52725d3f549782722891330cb556e7e1c6c81b75a5d6f34, msg.sender); // staticcall
require(success0);
if (!(success0)) {
require(0, CustomError_d0378693());
require(stor_2 != 0x02, ReentrancyGuardReentrantCall());
stor_2 = 0x02;
require(uint64(stor_3 >> 0x80), EpochNotStarted());
require(block.timestamp < (uint64(stor_3 >> 0x80)), CustomError_2c6f8587());
require(!newStakingPaused, CustomError_1d3e9914());
require(arg1 != 0x0, ZeroAmount());
(bool success1, bytes memory returnData1) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success1);
uint256 var_d;
if (!(success1)) {
(bool success2, bytes memory returnData2) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success2);
uint256 value1 = msg.data[0] >> 0xe0;
uint256 value2 = var_d.length;
if (success2) {
uint256 value0 = returnData2.length;
if (0x20 <= returnData2.length) {
value0 = 0x20;
}
if (((var_d + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value0) - var_d) >= 0x20);
} else {
value1 = var_d;
value2 = 0;
}
require(value2 >= (0 + arg1), InsufficientReserve());
unresolved_092488f0[arg0] = unresolved_092488f0[arg0] + arg1;
totalPrincipal = totalPrincipal + arg1;
(bool success3, bytes memory returnData3) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).mint(arg0, arg1); // call
require(success3);
uint256 value4 = msg.data[0] >> 0xe0;
uint256 value5 = var_d.length;
if (success3) {
uint256 value3 = returnData3.length;
if (0x20 <= returnData3.length) {
value3 = 0x20;
}
if (((var_d + ((value3 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value3 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value3 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value3) - var_d) >= 0x20);
} else {
value4 = var_d;
value5 = 0;
}
require(value5 == arg1, CustomError_3e16baba());
emit Event_ba732029(arg0, arg1, unresolved_092488f0[arg0]);
stor_2 = 0x01;
}
uint256 value6 = returnData1.length;
if (0x20 <= returnData1.length) {
value6 = 0x20;
}
if (((var_d + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value6) - var_d) >= 0x20);
(bool success4, bytes memory returnData4) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success4);
uint256 value8 = msg.data[0] >> 0xe0;
uint256 value9 = var_d.length;
if (success4) {
uint256 value7 = returnData4.length;
if (0x20 <= returnData4.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;
value9 = 0;
}
require(value9 >= (var_d.length + arg1), InsufficientReserve());
unresolved_092488f0[arg0] = unresolved_092488f0[arg0] + arg1;
totalPrincipal = totalPrincipal + arg1;
(bool success5, bytes memory returnData5) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).mint(arg0, arg1); // call
require(success5);
uint256 value11 = msg.data[0] >> 0xe0;
uint256 value12 = var_d.length;
if (success5) {
uint256 value10 = returnData5.length;
if (0x20 <= returnData5.length) {
value10 = 0x20;
}
if (((var_d + ((value10 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value10 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value10 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value10) - var_d) >= 0x20);
} else {
value11 = var_d;
value12 = 0;
}
require(value12 == arg1, CustomError_3e16baba());
emit Event_ba732029(arg0, arg1, unresolved_092488f0[arg0]);
stor_2 = 0x01;
}
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);
require(var_d.length == var_d.length);
require(var_d.length != 0x0, CustomError_d0378693());
require(stor_2 != 0x02, ReentrancyGuardReentrantCall());
stor_2 = 0x02;
require(uint64(stor_3 >> 0x80), EpochNotStarted());
require(block.timestamp < (uint64(stor_3 >> 0x80)), CustomError_2c6f8587());
require(!newStakingPaused, CustomError_1d3e9914());
require(arg1 != 0x0, ZeroAmount());
(bool success6, bytes memory returnData6) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success6);
if (!(success6)) {
(bool success7, bytes memory returnData7) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success7);
uint256 value14 = msg.data[0] >> 0xe0;
uint256 value15 = var_d.length;
if (success7) {
uint256 value13 = returnData7.length;
if (0x20 <= returnData7.length) {
value13 = 0x20;
}
if (((var_d + ((value13 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value13 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value13 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value13) - var_d) >= 0x20);
} else {
value14 = var_d;
value15 = 0;
}
require(value15 >= (0 + arg1), InsufficientReserve());
unresolved_092488f0[arg0] = unresolved_092488f0[arg0] + arg1;
totalPrincipal = totalPrincipal + arg1;
(bool success8, bytes memory returnData8) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).mint(arg0, arg1); // call
require(success8);
uint256 value17 = msg.data[0] >> 0xe0;
uint256 value18 = var_d.length;
if (success8) {
uint256 value16 = returnData8.length;
if (0x20 <= returnData8.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);
} else {
value17 = var_d;
value18 = 0;
}
require(value18 == arg1, CustomError_3e16baba());
emit Event_ba732029(arg0, arg1, unresolved_092488f0[arg0]);
stor_2 = 0x01;
}
uint256 value19 = returnData6.length;
if (0x20 <= returnData6.length) {
value19 = 0x20;
}
if (((var_d + ((value19 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value19 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value19 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value19) - var_d) >= 0x20);
(bool success9, bytes memory returnData9) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success9);
uint256 value21 = msg.data[0] >> 0xe0;
uint256 value22 = var_d.length;
if (success9) {
uint256 value20 = returnData9.length;
if (0x20 <= returnData9.length) {
value20 = 0x20;
}
if (((var_d + ((value20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value20) - var_d) >= 0x20);
} else {
value21 = var_d;
value22 = 0;
}
require(value22 >= (var_d.length + arg1), InsufficientReserve());
unresolved_092488f0[arg0] = unresolved_092488f0[arg0] + arg1;
totalPrincipal = totalPrincipal + arg1;
(bool success10, bytes memory returnData10) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).mint(arg0, arg1); // call
require(success10);
uint256 value24 = msg.data[0] >> 0xe0;
uint256 value25 = var_d.length;
if (success10) {
uint256 value23 = returnData10.length;
if (0x20 <= returnData10.length) {
value23 = 0x20;
}
if (((var_d + ((value23 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value23 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value23 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value23) - var_d) >= 0x20);
} else {
value24 = var_d;
value25 = 0;
}
require(value25 == arg1, CustomError_3e16baba());
} 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 == var_d.length);
require(var_d.length != 0x0, CustomError_d0378693());
require(stor_2 != 0x02, ReentrancyGuardReentrantCall());
stor_2 = 0x02;
require(uint64(stor_3 >> 0x80), EpochNotStarted());
require(block.timestamp < (uint64(stor_3 >> 0x80)), CustomError_2c6f8587());
require(!newStakingPaused, CustomError_1d3e9914());
require(arg1 != 0x0, ZeroAmount());
(bool success11, bytes memory returnData11) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success11);
if (!(success11)) {
(bool success12, bytes memory returnData12) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success12);
uint256 value27 = msg.data[0] >> 0xe0;
uint256 value28 = var_d.length;
if (success12) {
uint256 value26 = returnData12.length;
if (0x20 <= returnData12.length) {
value26 = 0x20;
}
if (((var_d + ((value26 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value26 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value26 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value26) - var_d) >= 0x20);
} else {
value27 = var_d;
value28 = 0;
}
require(value28 >= (0 + arg1), InsufficientReserve());
unresolved_092488f0[arg0] = unresolved_092488f0[arg0] + arg1;
totalPrincipal = totalPrincipal + arg1;
(bool success13, bytes memory returnData13) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).mint(arg0, arg1); // call
require(success13);
uint256 value30 = msg.data[0] >> 0xe0;
uint256 value31 = var_d.length;
if (success13) {
uint256 value29 = returnData13.length;
if (0x20 <= returnData13.length) {
value29 = 0x20;
}
if (((var_d + ((value29 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value29 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value29 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value29) - var_d) >= 0x20);
} else {
value30 = var_d;
value31 = 0;
}
require(value31 == arg1, CustomError_3e16baba());
emit Event_ba732029(arg0, arg1, unresolved_092488f0[arg0]);
stor_2 = 0x01;
}
uint256 value32 = returnData11.length;
if (0x20 <= returnData11.length) {
value32 = 0x20;
}
if (((var_d + ((value32 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value32 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value32 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value32) - var_d) >= 0x20);
(bool success14, bytes memory returnData14) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success14);
uint256 value34 = msg.data[0] >> 0xe0;
uint256 value35 = var_d.length;
if (success14) {
uint256 value33 = returnData14.length;
if (0x20 <= returnData14.length) {
value33 = 0x20;
}
if (((var_d + ((value33 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value33 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value33 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value33) - var_d) >= 0x20);
} else {
value34 = var_d;
value35 = 0;
}
require(value35 >= (var_d.length + arg1), InsufficientReserve());
unresolved_092488f0[arg0] = unresolved_092488f0[arg0] + arg1;
totalPrincipal = totalPrincipal + arg1;
(bool success15, bytes memory returnData15) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).mint(arg0, arg1); // call
require(success15);
uint256 value37 = msg.data[0] >> 0xe0;
uint256 value38 = var_d.length;
if (success15) {
uint256 value36 = returnData15.length;
if (0x20 <= returnData15.length) {
value36 = 0x20;
}
if (((var_d + ((value36 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value36 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value36 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value36) - var_d) >= 0x20);
} else {
value37 = var_d;
value38 = 0;
}
require(value38 == arg1, CustomError_3e16baba());
}
emit Event_ba732029(arg0, arg1, unresolved_092488f0[arg0]);
stor_2 = 0x01;
}
function getRoleAdmin(bytes32 role) public view returns (uint256) {
return stor_expr_c;
}
function totalLiability() public returns (uint256) {
(bool success0, bytes memory returnData0) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success0);
if (!(success0)) {
return 0;
}
uint256 value0 = returnData0.length;
if (0x20 <= returnData0.length) {
value0 = 0x20;
}
uint256 var_b;
if (((var_b + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65);
var_b = var_b + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_b + value0) - var_b) >= 0x20);
return var_b.length;
}
function Unknown_0d60cf12(address account, uint256 arg1) public payable {
if (!(msg.value)) {
if ((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) >= 0x40) {
if (account == account) {
if (stor_2 != 0x02) {
stor_2 = 0x02;
(bool success0, bytes memory returnData0) = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).isActive(0xec3c2045da149c45c16ce5a6d86d63bb81d27c31c6383c580ec51f98d5c3ee4c, msg.sender); // staticcall
if (success0) {
if (!(success0)) {
if (0 != 0) {
(bool success1, bytes memory returnData1) = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).isActive(0x624f60ef0707af2659aff7fc3b84264f4a208e7d08a6af32641b2ccd028561d5, account); // staticcall
if (success1) {
if (!(success1)) {
if (0 != 0) {
if (uint64(stor_3 >> 0x80)) {
if (block.timestamp < (uint64(stor_3 >> 0x80))) {
if (block.timestamp < (uint64(stor_3 >> 0x80))) {
if (arg1 != 0x0) {
(bool success2, bytes memory returnData2) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
if (success2) {
if (!(success2)) {
uint256 var_g;
if (!(((var_g + 0xa0) > 0xffffffffffffffff) | ((var_g + 0xa0) < var_g))) {
var_g = var_g + 0xa0;
(bool success3, bytes memory returnData3) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).transferFrom(msg.sender, address(this), arg1); // call
if (success3) {
if (!(RETURNDATASIZE(0x361a, 0x197) != 0x0 && 0x1 != var_h || RETURNDATASIZE(0x361a, 0x197) == 0x0 && 0x61e91daf03a49ecec334bffbf5008860cfb33333.code.length == 0x0)) {
(bool success4, bytes memory returnData4) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
if (success4) {
if (success4) {
uint256 value0 = returnData4.length;
if (0x20 <= returnData4.length) {
value0 = 0x20;
}
if (((var_g + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value0) - var_g) >= 0x20);
uint256 value1 = msg.data[0] >> 0xe0;
bool flag1 = !((var_g.length - 0) == arg1);
if (!(var_g.length < 0)) {
} else {
value1 = 0;
flag1 = var_g.length < 0;
}
require(!(flag1), CustomError_61b33f00());
vaultPrincipal[account] = vaultPrincipal[account] + arg1;
totalVaultPrincipal = totalVaultPrincipal + arg1;
(bool success5, bytes memory returnData5) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).balanceOf(account); // staticcall
require(success5);
if (!(success5)) {
(bool success6, bytes memory returnData6) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success6);
if (success6) {
uint256 value2 = returnData6.length;
if (0x20 <= returnData6.length) {
value2 = 0x20;
}
if (((var_g + ((value2 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value2 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value2 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value2) - var_g) >= 0x20);
(bool success7, bytes memory returnData7) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).mint(account, arg1); // call
require(success7);
uint256 value4 = 0x20;
uint256 value5 = var_g.length;
if (success7) {
uint256 value3 = returnData7.length;
if (0x20 <= returnData7.length) {
value3 = 0x20;
}
if (((var_g + ((value3 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value3 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value3 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value3) - var_g) >= 0x20);
} else {
value4 = var_g;
value5 = 0;
}
(bool success8, bytes memory returnData8) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).balanceOf(account); // staticcall
require(success8);
uint256 value7 = msg.data[0] >> 0xe0;
uint256 value9 = var_g.length;
if (success8) {
uint256 value6 = returnData8.length;
if (0x20 <= returnData8.length) {
value6 = 0x20;
}
if (((var_g + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value6) - var_g) >= 0x20);
} else {
value7 = var_g;
value9 = 0;
}
(bool success9, bytes memory returnData9) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success9);
if (success9) {
uint256 value8 = returnData9.length;
if (0x20 <= returnData9.length) {
value8 = 0x20;
}
if (((var_g + ((value8 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value8 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value8 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value8) - var_g) >= 0x20);
bool flag2 = value9 < 0x0;
if (value5 != arg1) {
flag2 = value5 != arg1;
}
uint256 value10 = msg.data[0] >> 0xe0;
uint256 value11 = msg.data[0] >> 0xe0;
bool flag3 = value9 - 0x0 != arg1;
if (!flag2) {
} else {
value10 = value9;
value11 = 0;
flag3 = flag2;
}
bool flag4 = var_g.length < var_g.length;
if (flag3) {
flag4 = flag3;
}
uint256 value12 = msg.data[0] >> 0xe0;
uint256 value13 = msg.data[0] >> 0xe0;
bool flag5 = !((var_g.length - var_g.length) == arg1);
if (!flag4) {
} else {
value12 = var_g.length;
value13 = var_g.length;
flag5 = flag4;
}
require(!(flag5), CustomError_3e16baba());
(bool success10, bytes memory returnData10) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success10);
if (success10) {
uint256 value14 = returnData10.length;
if (0x20 <= returnData10.length) {
value14 = 0x20;
}
if (((var_g + ((value14 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value14 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value14 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value14) - var_g) >= 0x20);
require(var_g.length <= var_g.length, Insolvent());
} else {
require(0 <= var_g.length, Insolvent());
}
} else {
bool flag6 = value9 < 0x0;
if (value5 != arg1) {
flag6 = value5 != arg1;
}
uint256 value15 = msg.data[0] >> 0xe0;
uint256 value16 = msg.data[0] >> 0xe0;
bool flag7 = value9 - 0x0 != arg1;
if (!flag6) {
} else {
value15 = value9;
value16 = 0;
flag7 = flag6;
}
bool flag8 = 0 < var_g.length;
if (flag7) {
flag8 = flag7;
}
uint256 value17 = msg.data[0] >> 0xe0;
uint256 value18 = msg.data[0] >> 0xe0;
bool flag9 = !((0 - var_g.length) == arg1);
if (!flag8) {
} else {
value17 = 0;
value18 = var_g.length;
flag9 = flag8;
}
require(!(flag9), CustomError_3e16baba());
(bool success11, bytes memory returnData11) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success11);
if (success11) {
uint256 value19 = returnData11.length;
if (0x20 <= returnData11.length) {
value19 = 0x20;
}
if (((var_g + ((value19 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value19 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value19 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value19) - var_g) >= 0x20);
require(var_g.length <= var_g.length, Insolvent());
} else {
require(0 <= var_g.length, Insolvent());
}
}
} else {
(bool success12, bytes memory returnData12) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).mint(account, arg1); // call
require(success12);
uint256 value21 = 0x20;
uint256 value22 = var_g.length;
if (success12) {
uint256 value20 = returnData12.length;
if (0x20 <= returnData12.length) {
value20 = 0x20;
}
if (((var_g + ((value20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value20) - var_g) >= 0x20);
} else {
value21 = var_g;
value22 = 0;
}
(bool success13, bytes memory returnData13) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).balanceOf(account); // staticcall
require(success13);
uint256 value24 = msg.data[0] >> 0xe0;
uint256 value26 = var_g.length;
if (success13) {
uint256 value23 = returnData13.length;
if (0x20 <= returnData13.length) {
value23 = 0x20;
}
if (((var_g + ((value23 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value23 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value23 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value23) - var_g) >= 0x20);
} else {
value24 = var_g;
value26 = 0;
}
(bool success14, bytes memory returnData14) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success14);
if (success14) {
uint256 value25 = returnData14.length;
if (0x20 <= returnData14.length) {
value25 = 0x20;
}
if (((var_g + ((value25 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value25 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value25 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value25) - var_g) >= 0x20);
bool flag10 = value26 < 0x0;
if (value22 != arg1) {
flag10 = value22 != arg1;
}
uint256 value27 = msg.data[0] >> 0xe0;
uint256 value28 = msg.data[0] >> 0xe0;
bool flag11 = value26 - 0x0 != arg1;
if (!flag10) {
} else {
value27 = value26;
value28 = 0;
flag11 = flag10;
}
bool flag12 = var_g.length < 0;
if (flag11) {
flag12 = flag11;
}
uint256 value29 = msg.data[0] >> 0xe0;
uint256 value30 = msg.data[0] >> 0xe0;
bool flag13 = !((var_g.length - 0) == arg1);
if (!flag12) {
} else {
value29 = var_g.length;
value30 = 0;
flag13 = flag12;
}
require(!(flag13), CustomError_3e16baba());
(bool success15, bytes memory returnData15) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success15);
if (success15) {
uint256 value31 = returnData15.length;
if (0x20 <= returnData15.length) {
value31 = 0x20;
}
if (((var_g + ((value31 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value31 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value31 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value31) - var_g) >= 0x20);
require(var_g.length <= var_g.length, Insolvent());
} else {
require(0 <= var_g.length, Insolvent());
}
} else {
bool flag14 = value26 < 0x0;
if (value22 != arg1) {
flag14 = value22 != arg1;
}
uint256 value32 = msg.data[0] >> 0xe0;
uint256 value33 = msg.data[0] >> 0xe0;
bool flag15 = value26 - 0x0 != arg1;
if (!flag14) {
} else {
value32 = value26;
value33 = 0;
flag15 = flag14;
}
bool flag16 = 0x0 < 0x0;
if (flag15) {
flag16 = flag15;
}
uint256 value34 = msg.data[0] >> 0xe0;
uint256 value35 = msg.data[0] >> 0xe0;
if (!flag16) {
} else {
value34 = 0;
value35 = 0;
}
require(!(!flag16 && 0x0 != arg1 || flag16), CustomError_3e16baba());
(bool success16, bytes memory returnData16) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success16);
if (success16) {
uint256 value36 = returnData16.length;
if (0x20 <= returnData16.length) {
value36 = 0x20;
}
if (((var_g + ((value36 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value36 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value36 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value36) - var_g) >= 0x20);
require(var_g.length <= var_g.length, Insolvent());
} else {
require(0 <= var_g.length, Insolvent());
}
}
}
emit Event_cf290932(msg.sender, account, arg1, vaultPrincipal[account]);
stor_2 = 0x01;
}
uint256 value37 = returnData5.length;
if (0x20 <= returnData5.length) {
value37 = 0x20;
}
if (((var_g + ((value37 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value37 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value37 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value37) - var_g) >= 0x20);
(bool success17, bytes memory returnData17) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success17);
if (success17) {
uint256 value38 = returnData17.length;
if (0x20 <= returnData17.length) {
value38 = 0x20;
}
if (((var_g + ((value38 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value38 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value38 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value38) - var_g) >= 0x20);
address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).mint(account, arg1); // call
} else {
(bool success19, bytes memory returnData19) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).mint(account, arg1); // call
require(success19);
uint256 value40 = 0x20;
uint256 value41 = var_g.length;
if (success19) {
uint256 value39 = returnData19.length;
if (0x20 <= returnData19.length) {
value39 = 0x20;
}
if (((var_g + ((value39 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value39 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value39 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value39) - var_g) >= 0x20);
} else {
value40 = var_g;
value41 = 0;
}
(bool success20, bytes memory returnData20) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).balanceOf(account); // staticcall
require(success20);
uint256 value43 = msg.data[0] >> 0xe0;
uint256 value45 = var_g.length;
if (success20) {
uint256 value42 = returnData20.length;
if (0x20 <= returnData20.length) {
value42 = 0x20;
}
if (((var_g + ((value42 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value42 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value42 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value42) - var_g) >= 0x20);
} else {
value43 = var_g;
value45 = 0;
}
(bool success21, bytes memory returnData21) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success21);
if (success21) {
uint256 value44 = returnData21.length;
if (0x20 <= returnData21.length) {
value44 = 0x20;
}
if (((var_g + ((value44 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value44 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value44 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value44) - var_g) >= 0x20);
bool flag18 = value45 < var_g.length;
if (value41 != arg1) {
flag18 = value41 != arg1;
}
uint256 value46 = msg.data[0] >> 0xe0;
uint256 value47 = msg.data[0] >> 0xe0;
bool flag19 = !((value45 - var_g.length) == arg1);
if (!flag18) {
} else {
value46 = value45;
value47 = var_g.length;
flag19 = flag18;
}
bool flag20 = var_g.length < 0;
if (flag19) {
flag20 = flag19;
}
uint256 value48 = msg.data[0] >> 0xe0;
uint256 value49 = msg.data[0] >> 0xe0;
bool flag21 = !((var_g.length - 0) == arg1);
if (!flag20) {
} else {
value48 = var_g.length;
value49 = 0;
flag21 = flag20;
}
require(!(flag21), CustomError_3e16baba());
(bool success22, bytes memory returnData22) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success22);
if (success22) {
uint256 value50 = returnData22.length;
if (0x20 <= returnData22.length) {
value50 = 0x20;
}
if (((var_g + ((value50 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value50 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value50 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value50) - var_g) >= 0x20);
require(var_g.length <= var_g.length, Insolvent());
} else {
require(0 <= var_g.length, Insolvent());
}
} else {
bool flag22 = value45 < var_g.length;
if (value41 != arg1) {
flag22 = value41 != arg1;
}
uint256 value51 = msg.data[0] >> 0xe0;
uint256 value52 = msg.data[0] >> 0xe0;
bool flag23 = !((value45 - var_g.length) == arg1);
if (!flag22) {
} else {
value51 = value45;
value52 = var_g.length;
flag23 = flag22;
}
bool flag24 = 0x0 < 0x0;
if (flag23) {
flag24 = flag23;
}
uint256 value53 = msg.data[0] >> 0xe0;
uint256 value54 = msg.data[0] >> 0xe0;
if (!flag24) {
} else {
value53 = 0;
value54 = 0;
}
require(!(!flag24 && 0x0 != arg1 || flag24), CustomError_3e16baba());
(bool success23, bytes memory returnData23) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success23);
if (success23) {
uint256 value55 = returnData23.length;
if (0x20 <= returnData23.length) {
value55 = 0x20;
}
if (((var_g + ((value55 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value55 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value55 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value55) - var_g) >= 0x20);
require(var_g.length <= var_g.length, Insolvent());
} else {
require(0 <= var_g.length, Insolvent());
}
}
emit Event_cf290932(msg.sender, account, arg1, vaultPrincipal[account]);
stor_2 = 0x01;
}
} else {
uint256 value56 = msg.data[0] >> 0xe0;
if (!(0x0 >= 0x0 && 0x0 != arg1 || 0x0 < 0x0)) {
if (vaultPrincipal[account] <= (vaultPrincipal[account] + arg1)) {
vaultPrincipal[account] = vaultPrincipal[account] + arg1;
if (totalVaultPrincipal <= (totalVaultPrincipal + arg1)) {
totalVaultPrincipal = totalVaultPrincipal + arg1;
(bool success24, bytes memory returnData24) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).balanceOf(account); // staticcall
if (success24) {
if (!(success24)) {
(bool success25, bytes memory returnData25) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
if (success25) {
if (success25) {
uint256 value57 = returnData25.length;
if (0x20 <= returnData25.length) {
value57 = 0x20;
}
if (((var_g + ((value57 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value57 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value57 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
if (((var_g + value57) - var_g) >= 0x20) {
(bool success26, bytes memory returnData26) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).mint(account, arg1); // call
if (success26) {
uint256 value59 = 0x20;
uint256 value60 = var_g.length;
if (success26) {
uint256 value58 = returnData26.length;
if (0x20 <= returnData26.length) {
value58 = 0x20;
}
if (((var_g + ((value58 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value58 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value58 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value58) - var_g) >= 0x20);
} else {
value59 = var_g;
value60 = 0;
}
(bool success27, bytes memory returnData27) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).balanceOf(account); // staticcall
if (success27) {
uint256 value62 = msg.data[0] >> 0xe0;
uint256 value63 = var_g.length;
if (success27) {
uint256 value61 = returnData27.length;
if (0x20 <= returnData27.length) {
value61 = 0x20;
}
if (((var_g + ((value61 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value61 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value61 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value61) - var_g) >= 0x20);
} else {
value62 = var_g;
value63 = 0;
}
(bool success28, bytes memory returnData28) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
if (success28) {
if (!(success28)) {
bool flag27 = value63 < 0x0;
if (value60 != arg1) {
flag27 = value60 != arg1;
}
uint256 value64 = msg.data[0] >> 0xe0;
uint256 value65 = msg.data[0] >> 0xe0;
bool flag28 = value63 - 0x0 != arg1;
if (!flag27) {
} else {
value64 = value63;
value65 = 0;
flag28 = flag27;
}
bool flag29 = 0 < var_g.length;
if (flag28) {
flag29 = flag28;
}
uint256 value66 = msg.data[0] >> 0xe0;
uint256 value67 = msg.data[0] >> 0xe0;
bool flag30 = !((0 - var_g.length) == arg1);
if (!flag29) {
} else {
value66 = 0;
value67 = var_g.length;
flag30 = flag29;
}
require(!(flag30), CustomError_3e16baba());
(bool success29, bytes memory returnData29) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success29);
if (success29) {
uint256 value68 = returnData29.length;
if (0x20 <= returnData29.length) {
value68 = 0x20;
}
if (((var_g + ((value68 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value68 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value68 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value68) - var_g) >= 0x20);
require(var_g.length <= 0, Insolvent());
} else {
require(0 <= 0, Insolvent());
}
emit Event_cf290932(msg.sender, account, arg1, vaultPrincipal[account]);
stor_2 = 0x01;
}
}
}
}
}
} else {
(bool success30, bytes memory returnData30) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).mint(account, arg1); // call
require(success30);
uint256 value70 = 0x20;
uint256 value71 = var_g.length;
if (success30) {
uint256 value69 = returnData30.length;
if (0x20 <= returnData30.length) {
value69 = 0x20;
}
if (((var_g + ((value69 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value69 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value69 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value69) - var_g) >= 0x20);
} else {
value70 = var_g;
value71 = 0;
}
(bool success31, bytes memory returnData31) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).balanceOf(account); // staticcall
require(success31);
uint256 value73 = msg.data[0] >> 0xe0;
uint256 value75 = var_g.length;
if (success31) {
uint256 value72 = returnData31.length;
if (0x20 <= returnData31.length) {
value72 = 0x20;
}
if (((var_g + ((value72 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value72 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value72 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value72) - var_g) >= 0x20);
} else {
value73 = var_g;
value75 = 0;
}
(bool success32, bytes memory returnData32) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success32);
if (success32) {
uint256 value74 = returnData32.length;
if (0x20 <= returnData32.length) {
value74 = 0x20;
}
if (((var_g + ((value74 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value74 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value74 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value74) - var_g) >= 0x20);
bool flag31 = value75 < 0x0;
if (value71 != arg1) {
flag31 = value71 != arg1;
}
uint256 value76 = msg.data[0] >> 0xe0;
uint256 value77 = msg.data[0] >> 0xe0;
bool flag32 = value75 - 0x0 != arg1;
if (!flag31) {
} else {
value76 = value75;
value77 = 0;
flag32 = flag31;
}
bool flag33 = var_g.length < 0;
if (flag32) {
flag33 = flag32;
}
uint256 value78 = msg.data[0] >> 0xe0;
uint256 value79 = msg.data[0] >> 0xe0;
bool flag34 = !((var_g.length - 0) == arg1);
if (!flag33) {
} else {
value78 = var_g.length;
value79 = 0;
flag34 = flag33;
}
require(!(flag34), CustomError_3e16baba());
(bool success33, bytes memory returnData33) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success33);
if (success33) {
uint256 value80 = returnData33.length;
if (0x20 <= returnData33.length) {
value80 = 0x20;
}
if (((var_g + ((value80 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value80 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value80 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value80) - var_g) >= 0x20);
require(var_g.length <= 0, Insolvent());
} else {
require(0 <= 0, Insolvent());
}
} else {
bool flag35 = value75 < 0x0;
if (value71 != arg1) {
flag35 = value71 != arg1;
}
uint256 value81 = msg.data[0] >> 0xe0;
uint256 value82 = msg.data[0] >> 0xe0;
bool flag36 = value75 - 0x0 != arg1;
if (!flag35) {
} else {
value81 = value75;
value82 = 0;
flag36 = flag35;
}
bool flag37 = 0x0 < 0x0;
if (flag36) {
flag37 = flag36;
}
uint256 value83 = msg.data[0] >> 0xe0;
uint256 value84 = msg.data[0] >> 0xe0;
if (!flag37) {
} else {
value83 = 0;
value84 = 0;
}
require(!(!flag37 && 0x0 != arg1 || flag37), CustomError_3e16baba());
(bool success34, bytes memory returnData34) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success34);
if (success34) {
uint256 value85 = returnData34.length;
if (0x20 <= returnData34.length) {
value85 = 0x20;
}
if (((var_g + ((value85 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_g + ((value85 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_g)) _desolexPanic(65);
var_g = var_g + ((value85 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_g + value85) - var_g) >= 0x20);
require(var_g.length <= 0, Insolvent());
} else {
require(0 <= 0, Insolvent());
}
}
emit Event_cf290932(msg.sender, account, arg1, vaultPrincipal[account]);
stor_2 = 0x01;
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
function Unknown_0bb8102f(address account, uint256 arg1) public payable returns (bytes memory) {
if (!(msg.value)) {
if ((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) >= 0x40) {
if (account == account) {
if (stor_2 != 0x02) {
stor_2 = 0x02;
(bool success0, bytes memory returnData0) = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).statusOf(0x624f60ef0707af2659aff7fc3b84264f4a208e7d08a6af32641b2ccd028561d5, msg.sender); // staticcall
if (success0) {
uint256 value1 = 0;
uint256 var_d;
uint256 value2 = var_d.length;
if (success0) {
uint256 value0 = returnData0.length;
if (0x20 <= returnData0.length) {
value0 = 0x20;
}
if (((var_d + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value0) - var_d) >= 0x20);
require(var_d.length < 0x05);
} else {
value1 = var_d;
value2 = 0;
}
if (value2 < 0x05) {
uint256 value80 = 0;
bool flag1 = value2 == 0x2;
if (value2 == 0x01) {
flag0 = value2 >= 0x5;
flag1 = value2 == 0x1;
}
if (flag1) {
if (flag1) {
if (uint64(stor_3 >> 0x80)) {
if (block.timestamp < (uint64(stor_3 >> 0x80))) {
if (block.timestamp < (uint64(stor_3 >> 0x80))) {
if (account != address(0)) {
if (arg1 != 0x0) {
(bool success1, bytes memory returnData1) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
if (success1) {
if (!(success1)) {
if (!(((var_d + 0xa0) > 0xffffffffffffffff) | ((var_d + 0xa0) < var_d))) {
var_d = var_d + 0xa0;
(bool success2, bytes memory returnData2) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).transferFrom(msg.sender, address(this), arg1); // call
if (success2) {
if (!(RETURNDATASIZE(0x361a, 0xc) != 0x0 && 0x1 != var_j || RETURNDATASIZE(0x361a, 0xc) == 0x0 && 0x61e91daf03a49ecec334bffbf5008860cfb33333.code.length == 0x0)) {
(bool success3, bytes memory returnData3) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
if (success3) {
if (success3) {
uint256 value3 = returnData3.length;
if (0x20 <= returnData3.length) {
value3 = 0x20;
}
if (((var_d + ((value3 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value3 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value3 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
if (((var_d + value3) - var_d) >= 0x20) {
uint256 value4 = msg.data[0] >> 0xe0;
bool flag3 = !((var_d.length - 0) == arg1);
if (!(var_d.length < 0)) {
} else {
value4 = 0;
flag3 = var_d.length < 0;
}
if (!(flag3)) {
(bool success4, bytes memory returnData4) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).balanceOf(account); // staticcall
if (success4) {
if (!(success4)) {
(bool success5, bytes memory returnData5) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
if (success5) {
if (!(success5)) {
(bool success6, bytes memory returnData6) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).mint(account, arg1); // call
if (success6) {
uint256 value6 = 0x20;
uint256 value7 = var_d.length;
if (success6) {
uint256 value5 = returnData6.length;
if (0x20 <= returnData6.length) {
value5 = 0x20;
}
if (((var_d + ((value5 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value5 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value5 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value5) - var_d) >= 0x20);
} else {
value6 = var_d;
value7 = 0;
}
(bool success7, bytes memory returnData7) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).balanceOf(account); // staticcall
if (success7) {
uint256 value9 = msg.data[0] >> 0xe0;
uint256 value11 = var_d.length;
if (success7) {
uint256 value8 = returnData7.length;
if (0x20 <= returnData7.length) {
value8 = 0x20;
}
if (((var_d + ((value8 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value8 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value8 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value8) - var_d) >= 0x20);
} else {
value9 = var_d;
value11 = 0;
}
(bool success8, bytes memory returnData8) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
if (success8) {
if (success8) {
uint256 value10 = returnData8.length;
if (0x20 <= returnData8.length) {
value10 = 0x20;
}
if (((var_d + ((value10 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value10 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value10 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
} else {
bool flag4 = value11 < 0x0;
if (value7 != arg1) {
flag4 = value7 != arg1;
}
uint256 value12 = msg.data[0] >> 0xe0;
bool flag5 = value11 - 0x0 != arg1;
if (!flag4) {
} else {
value12 = 0;
flag5 = flag4;
}
bool flag6 = 0x0 < 0x0;
if (flag5) {
flag6 = flag5;
}
uint256 value13 = msg.data[0] >> 0xe0;
uint256 value14 = msg.data[0] >> 0xe0;
if (!flag6) {
} else {
value13 = 0;
value14 = 0;
}
require(!(!flag6 && 0x0 != arg1 || flag6), CustomError_3e16baba());
(bool success9, bytes memory returnData9) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success9);
if (success9) {
uint256 value15 = returnData9.length;
if (0x20 <= returnData9.length) {
value15 = 0x20;
}
if (((var_d + ((value15 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value15 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value15 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value15) - var_d) >= 0x20);
require(var_d.length <= var_d.length, Insolvent());
emit Event_679f5082(msg.sender, account, arg1);
stor_2 = 0x01;
} else {
require(0 <= var_d.length, Insolvent());
emit Event_679f5082(msg.sender, account, arg1);
stor_2 = 0x01;
}
return abi.encodePacked(value7, value11);
}
}
}
}
}
}
}
}
}
}
} else {
uint256 value16 = msg.data[0] >> 0xe0;
require(!(0x0 >= 0x0 && 0x0 != arg1 || 0x0 < 0x0), CustomError_61b33f00());
(bool success10, bytes memory returnData10) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).balanceOf(account); // staticcall
require(success10);
if (!(success10)) {
(bool success11, bytes memory returnData11) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success11);
if (success11) {
uint256 value17 = returnData11.length;
if (0x20 <= returnData11.length) {
value17 = 0x20;
}
if (((var_d + ((value17 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value17 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value17 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value17) - var_d) >= 0x20);
(bool success12, bytes memory returnData12) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).mint(account, arg1); // call
require(success12);
uint256 value19 = 0x20;
uint256 value20 = var_d.length;
if (success12) {
uint256 value18 = returnData12.length;
if (0x20 <= returnData12.length) {
value18 = 0x20;
}
if (((var_d + ((value18 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value18 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value18 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value18) - var_d) >= 0x20);
} else {
value19 = var_d;
value20 = 0;
}
(bool success13, bytes memory returnData13) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).balanceOf(account); // staticcall
require(success13);
uint256 value22 = msg.data[0] >> 0xe0;
uint256 value24 = var_d.length;
if (success13) {
uint256 value21 = returnData13.length;
if (0x20 <= returnData13.length) {
value21 = 0x20;
}
if (((var_d + ((value21 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value21 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value21 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value21) - var_d) >= 0x20);
} else {
value22 = var_d;
value24 = 0;
}
(bool success14, bytes memory returnData14) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success14);
if (success14) {
uint256 value23 = returnData14.length;
if (0x20 <= returnData14.length) {
value23 = 0x20;
}
if (((var_d + ((value23 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value23 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value23 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value23) - var_d) >= 0x20);
bool flag9 = value24 < 0x0;
if (value20 != arg1) {
flag9 = value20 != arg1;
}
uint256 value25 = msg.data[0] >> 0xe0;
bool flag10 = value24 - 0x0 != arg1;
if (!flag9) {
} else {
value25 = 0;
flag10 = flag9;
}
bool flag11 = var_d.length < var_d.length;
if (flag10) {
flag11 = flag10;
}
uint256 value26 = msg.data[0] >> 0xe0;
uint256 value27 = msg.data[0] >> 0xe0;
bool flag12 = !((var_d.length - var_d.length) == arg1);
if (!flag11) {
} else {
value26 = var_d.length;
value27 = var_d.length;
flag12 = flag11;
}
require(!(flag12), CustomError_3e16baba());
(bool success15, bytes memory returnData15) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success15);
if (success15) {
uint256 value28 = returnData15.length;
if (0x20 <= returnData15.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);
require(var_d.length <= 0, Insolvent());
emit Event_679f5082(msg.sender, account, arg1);
stor_2 = 0x01;
} else {
require(0 <= 0, Insolvent());
emit Event_679f5082(msg.sender, account, arg1);
stor_2 = 0x01;
}
} else {
bool flag13 = value24 < 0x0;
if (value20 != arg1) {
flag13 = value20 != arg1;
}
uint256 value29 = msg.data[0] >> 0xe0;
bool flag14 = value24 - 0x0 != arg1;
if (!flag13) {
} else {
value29 = 0;
flag14 = flag13;
}
bool flag15 = 0 < var_d.length;
if (flag14) {
flag15 = flag14;
}
uint256 value30 = msg.data[0] >> 0xe0;
uint256 value31 = msg.data[0] >> 0xe0;
bool flag16 = !((0 - var_d.length) == arg1);
if (!flag15) {
} else {
value30 = 0;
value31 = var_d.length;
flag16 = flag15;
}
require(!(flag16), CustomError_3e16baba());
(bool success16, bytes memory returnData16) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success16);
if (success16) {
uint256 value32 = returnData16.length;
if (0x20 <= returnData16.length) {
value32 = 0x20;
}
if (((var_d + ((value32 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value32 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value32 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value32) - var_d) >= 0x20);
require(var_d.length <= 0, Insolvent());
emit Event_679f5082(msg.sender, account, arg1);
stor_2 = 0x01;
} else {
require(0 <= 0, Insolvent());
emit Event_679f5082(msg.sender, account, arg1);
stor_2 = 0x01;
}
}
return abi.encodePacked(value20, value24);
} else {
(bool success17, bytes memory returnData17) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).mint(account, arg1); // call
require(success17);
uint256 value34 = 0x20;
uint256 value35 = var_d.length;
if (success17) {
uint256 value33 = returnData17.length;
if (0x20 <= returnData17.length) {
value33 = 0x20;
}
if (((var_d + ((value33 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value33 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value33 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value33) - var_d) >= 0x20);
} else {
value34 = var_d;
value35 = 0;
}
(bool success18, bytes memory returnData18) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).balanceOf(account); // staticcall
require(success18);
uint256 value37 = msg.data[0] >> 0xe0;
uint256 value39 = var_d.length;
if (success18) {
uint256 value36 = returnData18.length;
if (0x20 <= returnData18.length) {
value36 = 0x20;
}
if (((var_d + ((value36 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value36 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value36 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value36) - var_d) >= 0x20);
} else {
value37 = var_d;
value39 = 0;
}
(bool success19, bytes memory returnData19) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success19);
if (success19) {
uint256 value38 = returnData19.length;
if (0x20 <= returnData19.length) {
value38 = 0x20;
}
if (((var_d + ((value38 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value38 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value38 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value38) - var_d) >= 0x20);
bool flag17 = value39 < 0x0;
if (value35 != arg1) {
flag17 = value35 != arg1;
}
uint256 value40 = msg.data[0] >> 0xe0;
bool flag18 = value39 - 0x0 != arg1;
if (!flag17) {
} else {
value40 = 0;
flag18 = flag17;
}
bool flag19 = var_d.length < 0;
if (flag18) {
flag19 = flag18;
}
uint256 value41 = msg.data[0] >> 0xe0;
uint256 value42 = msg.data[0] >> 0xe0;
bool flag20 = !((var_d.length - 0) == arg1);
if (!flag19) {
} else {
value41 = var_d.length;
value42 = 0;
flag20 = flag19;
}
require(!(flag20), CustomError_3e16baba());
(bool success20, bytes memory returnData20) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success20);
if (success20) {
uint256 value43 = returnData20.length;
if (0x20 <= returnData20.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 <= 0, Insolvent());
emit Event_679f5082(msg.sender, account, arg1);
stor_2 = 0x01;
} else {
require(0 <= 0, Insolvent());
emit Event_679f5082(msg.sender, account, arg1);
stor_2 = 0x01;
}
} else {
bool flag21 = value39 < 0x0;
if (value35 != arg1) {
flag21 = value35 != arg1;
}
uint256 value44 = msg.data[0] >> 0xe0;
bool flag22 = value39 - 0x0 != arg1;
if (!flag21) {
} else {
value44 = 0;
flag22 = flag21;
}
bool flag23 = 0x0 < 0x0;
if (flag22) {
flag23 = flag22;
}
uint256 value45 = msg.data[0] >> 0xe0;
uint256 value46 = msg.data[0] >> 0xe0;
if (!flag23) {
} else {
value45 = 0;
value46 = 0;
}
require(!(!flag23 && 0x0 != arg1 || flag23), CustomError_3e16baba());
(bool success21, bytes memory returnData21) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success21);
if (success21) {
uint256 value47 = returnData21.length;
if (0x20 <= returnData21.length) {
value47 = 0x20;
}
if (((var_d + ((value47 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value47 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value47 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value47) - var_d) >= 0x20);
require(var_d.length <= 0, Insolvent());
emit Event_679f5082(msg.sender, account, arg1);
stor_2 = 0x01;
} else {
require(0 <= 0, Insolvent());
emit Event_679f5082(msg.sender, account, arg1);
stor_2 = 0x01;
}
}
return abi.encodePacked(value35, value39);
}
}
uint256 value48 = returnData10.length;
if (0x20 <= returnData10.length) {
value48 = 0x20;
}
if (((var_d + ((value48 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value48 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value48 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value48) - var_d) >= 0x20);
(bool success22, bytes memory returnData22) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success22);
if (success22) {
uint256 value49 = returnData22.length;
if (0x20 <= returnData22.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);
(bool success23, bytes memory returnData23) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).mint(account, arg1); // call
require(success23);
uint256 value51 = 0x20;
uint256 value52 = var_d.length;
if (success23) {
uint256 value50 = returnData23.length;
if (0x20 <= returnData23.length) {
value50 = 0x20;
}
if (((var_d + ((value50 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value50 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value50 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value50) - var_d) >= 0x20);
} else {
value51 = var_d;
value52 = 0;
}
(bool success24, bytes memory returnData24) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).balanceOf(account); // staticcall
require(success24);
uint256 value54 = msg.data[0] >> 0xe0;
uint256 value56 = var_d.length;
if (success24) {
uint256 value53 = returnData24.length;
if (0x20 <= returnData24.length) {
value53 = 0x20;
}
if (((var_d + ((value53 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value53 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value53 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value53) - var_d) >= 0x20);
} else {
value54 = var_d;
value56 = 0;
}
(bool success25, bytes memory returnData25) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success25);
if (success25) {
uint256 value55 = returnData25.length;
if (0x20 <= returnData25.length) {
value55 = 0x20;
}
if (((var_d + ((value55 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value55 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value55 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value55) - var_d) >= 0x20);
bool flag25 = value56 < var_d.length;
if (value52 != arg1) {
flag25 = value52 != arg1;
}
uint256 value57 = msg.data[0] >> 0xe0;
bool flag26 = !((value56 - var_d.length) == arg1);
if (!flag25) {
} else {
value57 = var_d.length;
flag26 = flag25;
}
bool flag27 = var_d.length < var_d.length;
if (flag26) {
flag27 = flag26;
}
uint256 value58 = msg.data[0] >> 0xe0;
uint256 value59 = msg.data[0] >> 0xe0;
bool flag28 = !((var_d.length - var_d.length) == arg1);
if (!flag27) {
} else {
value58 = var_d.length;
value59 = var_d.length;
flag28 = flag27;
}
require(!(flag28), CustomError_3e16baba());
(bool success26, bytes memory returnData26) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success26);
if (success26) {
uint256 value60 = returnData26.length;
if (0x20 <= returnData26.length) {
value60 = 0x20;
}
if (((var_d + ((value60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value60) - var_d) >= 0x20);
require(var_d.length <= 0, Insolvent());
emit Event_679f5082(msg.sender, account, arg1);
stor_2 = 0x01;
} else {
require(0 <= 0, Insolvent());
emit Event_679f5082(msg.sender, account, arg1);
stor_2 = 0x01;
}
} else {
bool flag29 = value56 < var_d.length;
if (value52 != arg1) {
flag29 = value52 != arg1;
}
uint256 value61 = msg.data[0] >> 0xe0;
bool flag30 = !((value56 - var_d.length) == arg1);
if (!flag29) {
} else {
value61 = var_d.length;
flag30 = flag29;
}
bool flag31 = 0 < var_d.length;
if (flag30) {
flag31 = flag30;
}
uint256 value62 = msg.data[0] >> 0xe0;
uint256 value63 = msg.data[0] >> 0xe0;
bool flag32 = !((0 - var_d.length) == arg1);
if (!flag31) {
} else {
value62 = 0;
value63 = var_d.length;
flag32 = flag31;
}
require(!(flag32), CustomError_3e16baba());
(bool success27, bytes memory returnData27) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success27);
if (success27) {
uint256 value64 = returnData27.length;
if (0x20 <= returnData27.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 <= 0, Insolvent());
emit Event_679f5082(msg.sender, account, arg1);
stor_2 = 0x01;
} else {
require(0 <= 0, Insolvent());
emit Event_679f5082(msg.sender, account, arg1);
stor_2 = 0x01;
}
}
return abi.encodePacked(value52, value56);
} else {
(bool success28, bytes memory returnData28) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).mint(account, arg1); // call
require(success28);
uint256 value66 = 0x20;
uint256 value67 = var_d.length;
if (success28) {
uint256 value65 = returnData28.length;
if (0x20 <= returnData28.length) {
value65 = 0x20;
}
if (((var_d + ((value65 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value65 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value65 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value65) - var_d) >= 0x20);
} else {
value66 = var_d;
value67 = 0;
}
(bool success29, bytes memory returnData29) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).balanceOf(account); // staticcall
require(success29);
uint256 value69 = msg.data[0] >> 0xe0;
uint256 value71 = var_d.length;
if (success29) {
uint256 value68 = returnData29.length;
if (0x20 <= returnData29.length) {
value68 = 0x20;
}
if (((var_d + ((value68 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value68 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value68 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value68) - var_d) >= 0x20);
} else {
value69 = var_d;
value71 = 0;
}
(bool success30, bytes memory returnData30) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success30);
if (success30) {
uint256 value70 = returnData30.length;
if (0x20 <= returnData30.length) {
value70 = 0x20;
}
if (((var_d + ((value70 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value70 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value70 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value70) - var_d) >= 0x20);
bool flag33 = value71 < var_d.length;
if (value67 != arg1) {
flag33 = value67 != arg1;
}
uint256 value72 = msg.data[0] >> 0xe0;
bool flag34 = !((value71 - var_d.length) == arg1);
if (!flag33) {
} else {
value72 = var_d.length;
flag34 = flag33;
}
bool flag35 = var_d.length < 0;
if (flag34) {
flag35 = flag34;
}
uint256 value73 = msg.data[0] >> 0xe0;
uint256 value74 = msg.data[0] >> 0xe0;
bool flag36 = !((var_d.length - 0) == arg1);
if (!flag35) {
} else {
value73 = var_d.length;
value74 = 0;
flag36 = flag35;
}
require(!(flag36), CustomError_3e16baba());
(bool success31, bytes memory returnData31) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success31);
if (success31) {
uint256 value75 = returnData31.length;
if (0x20 <= returnData31.length) {
value75 = 0x20;
}
if (((var_d + ((value75 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value75 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value75 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value75) - var_d) >= 0x20);
require(var_d.length <= 0, Insolvent());
emit Event_679f5082(msg.sender, account, arg1);
stor_2 = 0x01;
} else {
require(0 <= 0, Insolvent());
emit Event_679f5082(msg.sender, account, arg1);
stor_2 = 0x01;
}
} else {
bool flag37 = value71 < var_d.length;
if (value67 != arg1) {
flag37 = value67 != arg1;
}
uint256 value76 = msg.data[0] >> 0xe0;
bool flag38 = !((value71 - var_d.length) == arg1);
if (!flag37) {
} else {
value76 = var_d.length;
flag38 = flag37;
}
bool flag39 = 0x0 < 0x0;
if (flag38) {
flag39 = flag38;
}
uint256 value77 = msg.data[0] >> 0xe0;
uint256 value78 = msg.data[0] >> 0xe0;
if (!flag39) {
} else {
value77 = 0;
value78 = 0;
}
require(!(!flag39 && 0x0 != arg1 || flag39), CustomError_3e16baba());
(bool success32, bytes memory returnData32) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success32);
if (success32) {
uint256 value79 = returnData32.length;
if (0x20 <= returnData32.length) {
value79 = 0x20;
}
if (((var_d + ((value79 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value79 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value79 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value79) - var_d) >= 0x20);
require(var_d.length <= 0, Insolvent());
emit Event_679f5082(msg.sender, account, arg1);
stor_2 = 0x01;
} else {
require(0 <= 0, Insolvent());
emit Event_679f5082(msg.sender, account, arg1);
stor_2 = 0x01;
}
}
return abi.encodePacked(value67, value71);
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
}
function Unknown_06fbe47a() public returns (bool) {
require(stor_2 != 0x02, ReentrancyGuardReentrantCall());
stor_2 = 0x02;
require(uint64(stor_3 >> 0x80), EpochNotStarted());
if (block.timestamp < (uint64(stor_3 >> 0x80))) {
stor_2 = 0x01;
return false;
} else {
internal_2f30();
stor_2 = 0x01;
return true;
}
}
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_34b8(uint256 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_f[arg1]))))) {
uint256 value1 = 0;
uint256 value2 = 0;
uint256 value3 = 0;
if ((mapping_expr_f[arg1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) != (getRoleMemberCount[arg0] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) {
if (!(((getRoleMemberCount[arg0] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < stor_expr_h))) _desolexPanic(50);
if (!(((mapping_expr_f[arg1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < stor_expr_j))) _desolexPanic(50);
stor_expr_m = (0 & stor_expr_n | (stor_expr_l >> (0 << 0x03) << 0));
mapping_expr_f[stor_expr_l >> (0 << 0x03)] = mapping_expr_f[arg1];
} else {
value1 = mapping_expr_f[arg1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
value2 = getRoleMemberCount[arg0] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
value3 = mapping_expr_f[arg1];
}
if (!(getRoleMemberCount[arg0])) _desolexPanic(49);
if (!(((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + getRoleMemberCount[arg0]) < stor_expr_p))) _desolexPanic(50);
stor_expr_q = (~(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff << (0 << 0x03))) & stor_expr_q;
getRoleMemberCount[arg0] = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + getRoleMemberCount[arg0];
mapping_expr_f[arg1] = 0;
flag0 = true;
}
}
}
function internal_2f30() private {
// Decompilation incomplete: helper effect provenance is conservative.
var_a = 0xde8ef1cd00000000000000000000000000000000000000000000000000000000;
(bool success0, bytes memory returnData0) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).Unknown_de8ef1cd(profit, uint64((stor_3 >> 0x40) + 0x01)); // call
require(success0);
uint256 value1 = 0;
uint256 var_d;
uint256 value5 = var_d.length;
if (success0) {
uint256 value0 = returnData0.length;
if (0x20 <= returnData0.length) {
value0 = 0x20;
}
if (((var_d + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value0) - var_d) >= 0x20);
} else {
value1 = var_d;
value5 = 0;
}
stor_3 = (0xffffffffffffffff00000000000000000000000000000000ffffffffffffffff & stor_3 | (0xffffffffffffffff0000000000000000 & (((stor_3 >> 0x40) & (0xffffffffffffffff) + 0x01) << 0x40))) | ((((0xffffffffffffffff0000000000000000 & (((stor_3 >> 0x40) & (0xffffffffffffffff) + 0x01) << 0x40) | (stor_3 & (0xffffffffffffffffffffffffffffffff0000000000000000ffffffffffffffff)) >> 0x80) & (0xffffffffffffffff) & (0xffffffffffffffff) + (stor_3 & (0xffffffffffffffff) & (0xffffffffffffffff))) << 0x80) & (0xffffffffffffffff00000000000000000000000000000000));
var_f = var_f;
(bool success1, bytes memory returnData1) = address(0xfd89fb9faf9de258c2148b2d0ec14da16ee42593).activeAddress(var_f); // staticcall
require(success1);
uint256 value2 = 0;
uint256 value3;
if (success1) {
uint256 value22 = var_d.length;
if (0x20 > returnData1.length) {
if (((var_d + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + returnData1.length) - var_d) >= 0x20);
require(var_d.length == (address(var_d.length)));
} else {
if (((var_d + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((0x20 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_d + 0x20) - var_d) < 0x20));
require(var_g == (address(var_g)));
value22 = var_h;
}
value3 = value22;
} else {
value2 = var_d;
value3 = 0;
}
require(value3.code.length != 0x0, CustomError_6737a1e3());
require(value3.code.length != 0x0);
(bool success2, bytes memory returnData2) = address(value3).distribute(); // call
uint256 value4 = 0;
if (success2) {
if (((var_d + ((0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
} else {
value4 = var_d;
}
if (success2) {
(bool success3, bytes memory returnData3) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success3);
uint256 value9 = var_d.length;
if (success3) {
uint256 value6 = returnData3.length;
if (0x20 <= returnData3.length) {
value6 = 0x20;
}
if (((var_d + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value6) - var_d) >= 0x20);
} else {
value9 = 0;
}
(bool success4, bytes memory returnData4) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success4);
uint256 value8 = var_d.length;
if (success4) {
uint256 value7 = returnData4.length;
if (0x20 <= returnData4.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 = 0;
}
require(value9 >= value8, Insolvent());
profit = value9 - value8;
} else {
if (returnData2.length == 0) {
uint256 value10 = 0;
uint256 value11 = (var_a & (0xffffffff00000000000000000000000000000000000000000000000000000000 << ((0x04 - var_o) << 0x03))) & (0xffffffff00000000000000000000000000000000000000000000000000000000);
if (var_o >= 0x04) {
value10 = var_a;
value11 = var_a & (0xffffffff00000000000000000000000000000000000000000000000000000000);
}
require(!(0x87fd863100000000000000000000000000000000000000000000000000000000 + (0xffffffff00000000000000000000000000000000000000000000000000000000 & value11)));
emit Event_1e750d55(uint64((stor_3 >> 0x40) + 0x01), address(value3));
(bool success5, bytes memory returnData5) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success5);
uint256 value15 = var_d.length;
if (success5) {
uint256 value12 = returnData5.length;
if (0x20 <= returnData5.length) {
value12 = 0x20;
}
if (((var_d + ((value12 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value12 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value12 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value12) - var_d) >= 0x20);
} else {
value15 = 0;
}
(bool success6, bytes memory returnData6) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success6);
uint256 value14 = var_d.length;
if (success6) {
uint256 value13 = returnData6.length;
if (0x20 <= returnData6.length) {
value13 = 0x20;
}
if (((var_d + ((value13 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value13 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value13 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value13) - var_d) >= 0x20);
} else {
value14 = 0;
}
require(value15 >= value14, Insolvent());
profit = value15 - value14;
} else {
if (!(returnData2.length <= 0xffffffffffffffff)) _desolexPanic(65);
if (((var_d + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData2.length + 0x1f))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData2.length + 0x1f))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData2.length + 0x1f))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
uint256 value16 = 0;
uint256 value17 = (var_p & (0xffffffff00000000000000000000000000000000000000000000000000000000 << ((0x04 - var_d.length) << 0x03))) & (0xffffffff00000000000000000000000000000000000000000000000000000000);
if (var_d.length >= 0x04) {
value16 = var_p;
value17 = var_p & (0xffffffff00000000000000000000000000000000000000000000000000000000);
}
require(!(0x87fd863100000000000000000000000000000000000000000000000000000000 + (0xffffffff00000000000000000000000000000000000000000000000000000000 & value17)));
emit Event_1e750d55(uint64((stor_3 >> 0x40) + 0x01), address(value3));
(bool success7, bytes memory returnData7) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success7);
uint256 value21 = var_d.length;
if (success7) {
uint256 value18 = returnData7.length;
if (0x20 <= returnData7.length) {
value18 = 0x20;
}
if (((var_d + ((value18 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value18 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value18 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value18) - var_d) >= 0x20);
} else {
value21 = 0;
}
(bool success8, bytes memory returnData8) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success8);
uint256 value20 = var_d.length;
if (success8) {
uint256 value19 = returnData8.length;
if (0x20 <= returnData8.length) {
value19 = 0x20;
}
if (((var_d + ((value19 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value19 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value19 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value19) - var_d) >= 0x20);
} else {
value20 = 0;
}
require(value21 >= value20, Insolvent());
profit = value21 - value20;
}
}
emit Event_2a0c0b7c(uint64((stor_3 >> 0x40) + 0x01), value5, profit, uint64(stor_3 >> 0x80));
}
function internal_352e() private {
// Decompilation incomplete: helper effect provenance is conservative.
(bool success0, bytes memory returnData0) = address(0x61e91daf03a49ecec334bffbf5008860cfb33333).balanceOf(address(this)); // staticcall
require(success0);
uint256 value90 = var_d.length;
if (success0) {
uint256 value87 = returnData0.length;
if (0x20 <= returnData0.length) {
value87 = 0x20;
}
if (((var_d + ((value87 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value87 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value87 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value87) - var_d) >= 0x20);
} else {
value90 = 0;
}
(bool success1, bytes memory returnData1) = address(0xe8e4ddaa28612a98cd50805f53eff32f5ff94d90).circulatingSupply(); // staticcall
require(success1);
uint256 value89 = var_d.length;
if (success1) {
uint256 value88 = returnData1.length;
if (0x20 <= returnData1.length) {
value88 = 0x20;
}
if (((var_d + ((value88 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((value88 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65);
var_d = var_d + ((value88 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_d + value88) - var_d) >= 0x20);
} else {
value89 = 0;
}
require(value90 >= value89, Insolvent());
profit = value90 - value89;
}
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)
// 0x06fbe47a => Unknown_06fbe47a()
// 0x086ae8f1 => totalVaultPrincipal()
// 0x08a9376d => MIN_EPOCH_LENGTH()
// 0x092488f0 => unresolved_092488f0(address)
// 0x0a17926f => newStakingPaused()
// 0x0bb8102f => Unknown_0bb8102f(address,uint256)
// 0x0d60cf12 => Unknown_0d60cf12(address,uint256)
// 0x0fc29349 => totalLiability()
// 0x1a465fe1 => protocolToken()
// 0x1d8ffa4d => interfaceVersion()
// 0x248a9ca3 => getRoleAdmin(bytes32)
// 0x24ea54f4 => GUARDIAN_ROLE()
// 0x2ee40908 => stakeFor(address,uint256)
// 0x2f2ff15d => grantRole(bytes32,address)
// 0x36568abe => renounceRole(bytes32,address)
// 0x36ef088c => unstakeFor(address,uint256)
// 0x3759900f => availableSurplus()
// 0x38b2393d => setEpochLength(uint64)
// 0x4757800c => Unknown_4757800c()
// 0x4973e066 => Unknown_4973e066(address,uint256)
// 0x4b1533b2 => totalPrincipal()
// 0x4bb6b58f => epochEnd()
// 0x55fd7fa0 => moduleKey()
// 0x57d775f8 => epochLength()
// 0x66d16cc3 => profit()
// 0x734f55c5 => Unknown_734f55c5(uint256,bool)
// 0x7656419f => protocolRegistry()
// 0x76671808 => currentEpoch()
// 0x8b9dd40e => Unknown_8b9dd40e(uint64)
// 0x8db19a41 => vaultPrincipal(address)
// 0x9010d07c => Unknown_9010d07c(uint256,uint256)
// 0x91d14854 => hasRole(bytes32,address)
// 0x9ce6dd9f => hasOpenPositions()
// 0xa10954fe => reserveBalance()
// 0xa217fddf => DEFAULT_ADMIN_ROLE()
// 0xa3246ad3 => Unknown_a3246ad3(uint256)
// 0xac060421 => Unknown_ac060421()
// 0xaf14052c => rebase()
// 0xbb36e169 => MAX_EPOCH_LENGTH()
// 0xc1ee2e7c => startEpochs()
// 0xc7215c80 => pauseNewStaking()
// 0xca15c873 => getRoleMemberCount(bytes32)
// 0xcc7a262e => stakedToken()
// 0xd547741f => Unknown_d547741f(uint256,address)
// 0xea0c88b2 => accruedOf(address)
// 0xf36c8f5c => GOVERNANCE_ROLE()
}