BNB Chain
0x63ad06a7ab30652aea278d52509fb1a1d23f6193
Decompiled Solidity recovered from this contract's runtime bytecode. Best-effort reconstruction — confirm behaviour against on-chain state.
Decompilation outputBNB Chain · 0x63ad06a7…d23f61936.4 KB8.3 s
This result is permanently available athttps://decompiler.exvul.com/bsc/0x63ad06a7ab30652aea278d52509fb1a1d23f6193
//decompiled by exvvul decompiler tool contact@exvul.com https://x.com/exvulsec
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;
contract DesolexContract {
uint256 public constant GOVERNANCE_ROLE = 51344670724517732003549907689393193919197804398902247150944709319656146718385;
uint256 public constant unresolved_cf744feb = 100000000000000000000000;
uint256 public constant MAX_STALENESS = 604800;
uint256 public constant MAX_TWAP_WINDOW = 86400;
uint256 public constant TOKEN_UNIT = 1000000000;
bool public constant unresolved_a4213afc = false;
uint256 public constant totalLiability = 0;
uint256 public constant hasOpenPositions = 0;
uint256 public constant DEFAULT_ADMIN_ROLE = 0;
uint256 public constant unresolved_9baaf593 = 10000000000000000000;
address public constant unresolved_908316ba = address(0xdaa4c92507c69b153b3d4556d79f04dc828945e4);
uint256 public constant wbnb = 1069295261705322660692659746119710186699350608220;
address public constant mainPair = address(0xbc4df56bb74a06a5a19965adea7833d6b4d9070);
uint256 public constant protocolRegistry = 1447451786632729987978363687652043719134903805331;
uint256 public constant moduleKey = 100025856811566313267149800545366947566468235534585981131010500246127659454936;
uint256 public constant unresolved_4862240e = 1000000;
uint256 public constant usdc = 489982930986835137684486657990555633941558688085;
uint256 public constant interfaceVersion = 1;
uint256 public constant unresolved_1af78208 = 1000000000000000000;
uint256 public constant MIN_TWAP_WINDOW = 60;
uint256 public constant protocolToken = 558970764211718742928263298617311505879053579059;
mapping(bytes32 => mapping(address => bool)) public hasRole; // STORAGE[0x0]
mapping(bytes32 => uint256) public getRoleMemberCount; // STORAGE[0x1]
uint32 stor_2; // STORAGE[0x2]
uint256 public observationCumulative; // STORAGE[0x3]
uint32 public observationTimestamp; // STORAGE[0x4]
uint256 public unresolved_047c0237; // STORAGE[0x5]
uint32 public pendingTimestamp; // STORAGE[0x6]
uint256 public unresolved_8d2c7252; // STORAGE[0x7]
uint64 public publishedAt; // STORAGE[0x8]
mapping(address => bool) mapping_316a51056d8b2401ab04c48d9973add294eadde229c785c6d19cde93785467ef; // STORAGE[0x316a51056d8b2401ab04c48d9973add294eadde229c785c6d19cde93785467ef]
mapping(address => uint256) mapping_expr_ac;
mapping(address => uint256) mapping_expr_am;
mapping(address => uint256) mapping_expr_d;
bytes32 stor_expr_a;
bytes32 stor_expr_aa;
bytes32 stor_expr_af;
uint256 stor_expr_ag;
bytes32 stor_expr_ah;
uint256 stor_expr_aj;
uint256 stor_expr_al;
address stor_expr_an;
uint256 stor_expr_e;
uint256 stor_expr_f;
uint256 stor_expr_g;
bytes32 stor_expr_i;
bytes32 stor_expr_j;
bytes32 stor_expr_k;
uint256 stor_expr_m;
bytes32 stor_expr_n;
event RoleRevoked(bytes32 indexed, address indexed, address indexed);
error CustomError_0bf8830c();
event RoleGranted(bytes32 indexed, address indexed, address indexed);
error CustomError_1fcbd196();
error ObservationWindowTooShort();
error AccessControlBadConfirmation();
error CustomError_b164617b();
error PriceIsZero();
event Event_8bdf940d(uint256, uint256, uint256, uint256, uint256);
error OracleNotReady();
error AccessControlUnauthorizedAccount(address, bytes32);
error CustomError_1546dbe2();
error PairHasNoLiquidity();
event Event_4f31a940(uint256, uint256, uint256, uint256, uint256);
error OracleStale();
function _desolexPanic(uint256 code) private pure {
assembly ("memory-safe") {
mstore(0x00, shl(224, 0x4e487b71))
mstore(0x04, code)
revert(0x00, 0x24)
}
}
fallback() external {
// Synthetic compatibility routes preserve original selectors for unresolved names.
if ((msg.data.length >= 4) && (msg.sig == 0x088c3b98)) {
// Route to Unknown_088c3b98(uint32,uint32) after replacing only msg.sig.
__desolexSelectorShim(uint32(0xa415dca2));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x1d761f68)) {
// Route to Unknown_1d761f68(uint256) after replacing only msg.sig.
__desolexSelectorShim(uint32(0xa6e00304));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x481565da)) {
// Route to Unknown_481565da(uint256) after replacing only msg.sig.
__desolexSelectorShim(uint32(0x821116b7));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x77d63446)) {
// Route to Unknown_77d63446() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x56c29fbf));
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 == 0xa06abd16)) {
// Route to Unknown_a06abd16(uint256) after replacing only msg.sig.
__desolexSelectorShim(uint32(0xd37826fa));
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 == 0xcc054af5)) {
// Route to Unknown_cc054af5() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x295d2929));
return;
}
revert();
}
function revokeRole(bytes32 role, address account) public {
require(bytes1(hasRole[stor_expr_a][msg.sender]), AccessControlUnauthorizedAccount());
uint256 value0 = 0;
if (bytes1(hasRole[role][account])) {
hasRole[role][account] = false;
emit RoleRevoked(role, account, msg.sender);
value0 = 0x01;
}
if (value0 != 0x0) {
uint256 value4 = 0;
if (!(0 == (!(!(mapping_expr_d[account]))))) {
uint256 value1 = 0;
uint256 value2 = 0;
uint256 value3 = 0;
if ((mapping_expr_d[account] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) != (stor_expr_e + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) {
if (!(((stor_expr_e + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < stor_expr_f))) _desolexPanic(50);
if (!(((mapping_expr_d[account] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < stor_expr_g))) _desolexPanic(50);
stor_expr_j = (0 & stor_expr_k) | ((stor_expr_i >> 0) << 0);
mapping_expr_d[stor_expr_i >> 0] = mapping_expr_d[account];
} else {
value1 = mapping_expr_d[account] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
value2 = stor_expr_e + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
value3 = mapping_expr_d[account];
}
if (!(stor_expr_e != 0x0)) _desolexPanic(49);
if (!(((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + stor_expr_e) < stor_expr_m))) _desolexPanic(50);
stor_expr_n = (0) & stor_expr_n;
stor_expr_e = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + stor_expr_e;
mapping_expr_d[account] = 0;
value4 = 0x01;
}
}
}
function Unknown_cc054af5() public returns (uint256) {
(bool success0, bytes memory returnData0) = address(0xdaa4c92507c69b153b3d4556d79f04dc828945e4).latestPrice(); // staticcall
require(success0);
uint256 value1 = 0;
uint256 value2 = var_b;
uint256 var_c;
uint256 value3 = var_c.length;
if (success0) {
uint256 value0 = returnData0.length;
if (0x40 <= returnData0.length) {
value0 = 0x40;
}
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) >= 0x40);
} else {
value1 = var_c;
value2 = 0;
value3 = 0;
}
uint256 value4 = 0;
if (value3 < 0x8ac7230489e80000) {
value4 = value3;
}
require(!(value3 >= 0x8ac7230489e80000 && value3 > 0x152d02c7e14af6800000 || value3 < 0x8ac7230489e80000), CustomError_1546dbe2());
require(!(value2 != 0x0 && value2 > block.timestamp || value2 == 0x0), CustomError_0bf8830c());
require(uint32(stor_2 >> 0x20) >= (block.timestamp - value2), CustomError_b164617b());
return value3;
}
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 update() public {
(bool success0, bytes memory returnData0) = address(0x0bc4df56bb74a06a5a19965adea7833d6b4d9070).getReserves(); // staticcall
require(success0);
if (!(success0)) {
uint256 value0 = msg.data[0] >> 0xe0;
value0 = 0;
require(0, PairHasNoLiquidity());
(bool success1, bytes memory returnData1) = address(0x0bc4df56bb74a06a5a19965adea7833d6b4d9070).price0CumulativeLast(); // staticcall
require(success1);
uint256 value2 = msg.data[0] >> 0xe0;
uint256 var_b;
uint256 value3 = var_b.length;
if (success1) {
uint256 value1 = returnData1.length;
if (0x20 <= returnData1.length) {
value1 = 0x20;
}
if (((var_b + ((value1 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value1 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65);
var_b = var_b + ((value1 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_b + value1) - var_b) >= 0x20);
} else {
value2 = var_b;
value3 = 0;
}
(bool success2, bytes memory returnData2) = address(0x0bc4df56bb74a06a5a19965adea7833d6b4d9070).price1CumulativeLast(); // staticcall
require(success2);
uint256 value5 = var_b.length;
uint256 value6 = 0x04;
if (success2) {
uint256 value4 = returnData2.length;
if (0x20 <= returnData2.length) {
value4 = 0x20;
}
if (((var_b + ((value4 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value4 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65);
var_b = var_b + ((value4 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_b + value4) - var_b) >= 0x20);
} else {
value5 = 0;
value6 = var_b;
}
(bool success3, bytes memory returnData3) = address(0x0bc4df56bb74a06a5a19965adea7833d6b4d9070).getReserves(); // staticcall
require(success3);
uint256 value8 = msg.data[0] >> 0xe0;
uint256 value9 = var_e;
uint256 value10 = var_b.length;
uint256 value11 = var_f;
if (success3) {
uint256 value7 = returnData3.length;
if (0x60 <= returnData3.length) {
value7 = 0x60;
}
if (((var_b + ((value7 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value7 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65);
var_b = var_b + ((value7 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_b + value7) - var_b) >= 0x60);
require(var_b.length == (uint112(var_b.length)));
require(var_f == (uint112(var_f)));
require(var_e == (uint32(var_e)));
} else {
value8 = var_b;
value9 = 0;
value10 = 0;
value11 = 0;
}
bool flag0 = (value10 & 0xffffffffffffffffffffffffffff) != 0x0;
if (uint32(value9) == (uint32(block.timestamp))) {
flag0 = !(uint32(value9) == (uint32(block.timestamp)));
}
uint256 value12 = msg.data[0] >> 0xe0;
uint256 value13 = msg.data[0] >> 0xe0;
uint256 value14 = msg.data[0] >> 0xe0;
uint256 value15 = msg.data[0] >> 0xe0;
uint256 value16 = msg.data[0] >> 0xe0;
uint256 value17 = (0xffffffffffffffffffffffffffff0000000000000000000000000000 & (value10 << 0x70) / (value11 & (0xffffffffffffffffffffffffffff)) * ((block.timestamp & (0xffffffff) - value9) & (0xffffffff))) + value5;
uint256 value18 = ((value11 << 0x70) & (0xffffffffffffffffffffffffffff0000000000000000000000000000) / (value10 & (0xffffffffffffffffffffffffffff)) * ((block.timestamp & (0xffffffff) - value9) & (0xffffffff))) + value3;
if ((flag0) && ((value11 & 0xffffffffffffffffffffffffffff) != 0x0)) {
} else {
value12 = value9;
value13 = value10;
value14 = value3;
value15 = value5;
value16 = value11;
value17 = value5;
value18 = value3;
}
require(uint32(block.timestamp - observationTimestamp) >= uint32(stor_2), ObservationWindowTooShort());
uint256 value19 = value17;
if (0 != 0) {
value19 = value18;
}
require((value19 - observationCumulative) / (uint32(block.timestamp - observationTimestamp)), PriceIsZero());
uint256 value20 = msg.data[0] >> 0xe0;
uint256 value21 = msg.data[0] >> 0xe0;
uint256 value22 = msg.data[0] >> 0xe0;
uint256 value23 = msg.data[0] >> 0xe0;
if (!(uint32(block.timestamp - pendingTimestamp) < (uint32(stor_2)))) {
observationCumulative = unresolved_047c0237;
observationTimestamp = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000 & observationTimestamp) | (pendingTimestamp & (0xffffffff));
unresolved_047c0237 = value19;
pendingTimestamp = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000 & pendingTimestamp) | (block.timestamp & (0xffffffff));
} else {
value20 = observationTimestamp;
value21 = uint32(pendingTimestamp);
value22 = pendingTimestamp;
value23 = uint32(block.timestamp);
}
unresolved_8d2c7252 = (value19 - observationCumulative) / (uint32(block.timestamp - observationTimestamp));
publishedAt = (publishedAt & (0xffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000)) | (block.timestamp & (0xffffffffffffffff));
emit Event_4f31a940(observationCumulative, value19, uint32(block.timestamp - observationTimestamp), (value19 - observationCumulative) / (uint32(block.timestamp - observationTimestamp)), block.timestamp);
}
if (0x60 > returnData0.length) {
if (((var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65);
var_b = var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_b + returnData0.length) - var_b) >= 0x60);
require(var_b.length == (uint112(var_b.length)));
require(var_f == (uint112(var_f)));
require(var_e == (uint32(var_e)));
uint256 value24 = msg.data[0] >> 0xe0;
bool flag2 = !(uint112(var_f));
if (!(uint112(var_b.length))) {
value24 = var_f;
flag2 = !(uint112(var_b.length));
}
require(!(flag2), PairHasNoLiquidity());
(bool success4, bytes memory returnData4) = address(0x0bc4df56bb74a06a5a19965adea7833d6b4d9070).price0CumulativeLast(); // staticcall
require(success4);
uint256 value26 = msg.data[0] >> 0xe0;
uint256 value27 = var_b.length;
if (success4) {
uint256 value25 = returnData4.length;
if (0x20 <= returnData4.length) {
value25 = 0x20;
}
if (((var_b + ((value25 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value25 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65);
var_b = var_b + ((value25 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_b + value25) - var_b) >= 0x20);
} else {
value26 = var_b;
value27 = 0;
}
(bool success5, bytes memory returnData5) = address(0x0bc4df56bb74a06a5a19965adea7833d6b4d9070).price1CumulativeLast(); // staticcall
require(success5);
uint256 value29 = var_b.length;
uint256 value30 = 0x04;
if (success5) {
uint256 value28 = returnData5.length;
if (0x20 <= returnData5.length) {
value28 = 0x20;
}
if (((var_b + ((value28 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value28 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65);
var_b = var_b + ((value28 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_b + value28) - var_b) >= 0x20);
} else {
value29 = 0;
value30 = var_b;
}
(bool success6, bytes memory returnData6) = address(0x0bc4df56bb74a06a5a19965adea7833d6b4d9070).getReserves(); // staticcall
require(success6);
uint256 value32 = msg.data[0] >> 0xe0;
uint256 value33 = var_e;
uint256 value34 = var_b.length;
uint256 value35 = var_f;
if (success6) {
uint256 value31 = returnData6.length;
if (0x60 <= returnData6.length) {
value31 = 0x60;
}
if (((var_b + ((value31 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value31 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65);
var_b = var_b + ((value31 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_b + value31) - var_b) >= 0x60);
require(var_b.length == (uint112(var_b.length)));
require(var_f == (uint112(var_f)));
require(var_e == (uint32(var_e)));
} else {
value32 = var_b;
value33 = 0;
value34 = 0;
value35 = 0;
}
bool flag3 = (value34 & 0xffffffffffffffffffffffffffff) != 0x0;
if (uint32(value33) == (uint32(block.timestamp))) {
flag3 = !(uint32(value33) == (uint32(block.timestamp)));
}
uint256 value36 = msg.data[0] >> 0xe0;
uint256 value37 = msg.data[0] >> 0xe0;
uint256 value38 = msg.data[0] >> 0xe0;
uint256 value39 = msg.data[0] >> 0xe0;
uint256 value40 = msg.data[0] >> 0xe0;
uint256 value41 = (0xffffffffffffffffffffffffffff0000000000000000000000000000 & (value34 << 0x70) / (value35 & (0xffffffffffffffffffffffffffff)) * ((block.timestamp & (0xffffffff) - value33) & (0xffffffff))) + value29;
uint256 value42 = ((value35 << 0x70) & (0xffffffffffffffffffffffffffff0000000000000000000000000000) / (value34 & (0xffffffffffffffffffffffffffff)) * ((block.timestamp & (0xffffffff) - value33) & (0xffffffff))) + value27;
if ((flag3) && ((value35 & 0xffffffffffffffffffffffffffff) != 0x0)) {
} else {
value36 = value33;
value37 = value34;
value38 = value27;
value39 = value29;
value40 = value35;
value41 = value29;
value42 = value27;
}
require(uint32(block.timestamp - observationTimestamp) >= uint32(stor_2), ObservationWindowTooShort());
uint256 value43 = value41;
if (0 != 0) {
value43 = value42;
}
require((value43 - observationCumulative) / (uint32(block.timestamp - observationTimestamp)), PriceIsZero());
uint256 value44 = msg.data[0] >> 0xe0;
uint256 value45 = msg.data[0] >> 0xe0;
uint256 value46 = msg.data[0] >> 0xe0;
uint256 value47 = msg.data[0] >> 0xe0;
if (!(uint32(block.timestamp - pendingTimestamp) < (uint32(stor_2)))) {
observationCumulative = unresolved_047c0237;
observationTimestamp = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000 & observationTimestamp) | (pendingTimestamp & (0xffffffff));
unresolved_047c0237 = value43;
pendingTimestamp = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000 & pendingTimestamp) | (block.timestamp & (0xffffffff));
} else {
value44 = observationTimestamp;
value45 = uint32(pendingTimestamp);
value46 = pendingTimestamp;
value47 = uint32(block.timestamp);
}
unresolved_8d2c7252 = (value43 - observationCumulative) / (uint32(block.timestamp - observationTimestamp));
publishedAt = (publishedAt & (0xffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000)) | (block.timestamp & (0xffffffffffffffff));
emit Event_4f31a940(observationCumulative, value43, uint32(block.timestamp - observationTimestamp), (value43 - observationCumulative) / (uint32(block.timestamp - observationTimestamp)), block.timestamp);
} else {
if (((var_b + 0x60) > 0xffffffffffffffff) | ((var_b + 0x60) < var_b)) _desolexPanic(65);
var_b = var_b + 0x60;
require(((var_b + 0x60) - var_b) >= 0x60);
require(var_b.length == (uint112(var_b.length)));
require(var_f == (uint112(var_f)));
require(var_e == (uint32(var_e)));
uint256 value48 = msg.data[0] >> 0xe0;
bool flag5 = !(uint112(var_f));
if (!(uint112(var_b.length))) {
value48 = var_f;
flag5 = !(uint112(var_b.length));
}
require(!(flag5), PairHasNoLiquidity());
(bool success7, bytes memory returnData7) = address(0x0bc4df56bb74a06a5a19965adea7833d6b4d9070).price0CumulativeLast(); // staticcall
require(success7);
uint256 value50 = msg.data[0] >> 0xe0;
uint256 value51 = var_b.length;
if (success7) {
uint256 value49 = returnData7.length;
if (0x20 <= returnData7.length) {
value49 = 0x20;
}
if (((var_b + ((value49 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value49 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65);
var_b = var_b + ((value49 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_b + value49) - var_b) >= 0x20);
} else {
value50 = var_b;
value51 = 0;
}
(bool success8, bytes memory returnData8) = address(0x0bc4df56bb74a06a5a19965adea7833d6b4d9070).price1CumulativeLast(); // staticcall
require(success8);
uint256 value53 = var_b.length;
uint256 value54 = 0x04;
if (success8) {
uint256 value52 = returnData8.length;
if (0x20 <= returnData8.length) {
value52 = 0x20;
}
if (((var_b + ((value52 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value52 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65);
var_b = var_b + ((value52 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_b + value52) - var_b) >= 0x20);
} else {
value53 = 0;
value54 = var_b;
}
(bool success9, bytes memory returnData9) = address(0x0bc4df56bb74a06a5a19965adea7833d6b4d9070).getReserves(); // staticcall
require(success9);
uint256 value56 = msg.data[0] >> 0xe0;
uint256 value57 = var_e;
uint256 value58 = var_b.length;
uint256 value59 = var_f;
if (success9) {
uint256 value55 = returnData9.length;
if (0x60 <= returnData9.length) {
value55 = 0x60;
}
if (((var_b + ((value55 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value55 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65);
var_b = var_b + ((value55 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_b + value55) - var_b) >= 0x60);
require(var_b.length == (uint112(var_b.length)));
require(var_f == (uint112(var_f)));
require(var_e == (uint32(var_e)));
} else {
value56 = var_b;
value57 = 0;
value58 = 0;
value59 = 0;
}
bool flag6 = (value58 & 0xffffffffffffffffffffffffffff) != 0x0;
if (uint32(value57) == (uint32(block.timestamp))) {
flag6 = !(uint32(value57) == (uint32(block.timestamp)));
}
uint256 value60 = msg.data[0] >> 0xe0;
uint256 value61 = msg.data[0] >> 0xe0;
uint256 value62 = msg.data[0] >> 0xe0;
uint256 value63 = msg.data[0] >> 0xe0;
uint256 value64 = msg.data[0] >> 0xe0;
uint256 value65 = (0xffffffffffffffffffffffffffff0000000000000000000000000000 & (value58 << 0x70) / (value59 & (0xffffffffffffffffffffffffffff)) * ((block.timestamp & (0xffffffff) - value57) & (0xffffffff))) + value53;
uint256 value66 = ((value59 << 0x70) & (0xffffffffffffffffffffffffffff0000000000000000000000000000) / (value58 & (0xffffffffffffffffffffffffffff)) * ((block.timestamp & (0xffffffff) - value57) & (0xffffffff))) + value51;
if ((flag6) && ((value59 & 0xffffffffffffffffffffffffffff) != 0x0)) {
} else {
value60 = value57;
value61 = value58;
value62 = value51;
value63 = value53;
value64 = value59;
value65 = value53;
value66 = value51;
}
require(uint32(block.timestamp - observationTimestamp) >= uint32(stor_2), ObservationWindowTooShort());
uint256 value67 = value65;
if (0 != 0) {
value67 = value66;
}
require((value67 - observationCumulative) / (uint32(block.timestamp - observationTimestamp)), PriceIsZero());
uint256 value68 = msg.data[0] >> 0xe0;
uint256 value69 = msg.data[0] >> 0xe0;
uint256 value70 = msg.data[0] >> 0xe0;
uint256 value71 = msg.data[0] >> 0xe0;
if (!(uint32(block.timestamp - pendingTimestamp) < (uint32(stor_2)))) {
observationCumulative = unresolved_047c0237;
observationTimestamp = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000 & observationTimestamp) | (pendingTimestamp & (0xffffffff));
unresolved_047c0237 = value67;
pendingTimestamp = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000 & pendingTimestamp) | (block.timestamp & (0xffffffff));
} else {
value68 = observationTimestamp;
value69 = uint32(pendingTimestamp);
value70 = pendingTimestamp;
value71 = uint32(block.timestamp);
}
unresolved_8d2c7252 = (value67 - observationCumulative) / (uint32(block.timestamp - observationTimestamp));
publishedAt = (publishedAt & (0xffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000)) | (block.timestamp & (0xffffffffffffffff));
emit Event_4f31a940(observationCumulative, value67, uint32(block.timestamp - observationTimestamp), (value67 - observationCumulative) / (uint32(block.timestamp - observationTimestamp)), block.timestamp);
}
}
function isReady() public returns (bool) {
bool flag0 = block.timestamp < (uint64(publishedAt));
if (unresolved_8d2c7252 == 0) {
flag0 = !unresolved_8d2c7252;
}
if (!flag0) {
}
if (((!flag0) && ((SHR(0x20, stor_2) & 0xffffffff) < block.timestamp - (publishedAt & 0xffffffffffffffff))) || (flag0)) {
return false;
} else {
(bool success0, bytes memory returnData0) = address(0x0bc4df56bb74a06a5a19965adea7833d6b4d9070).getReserves(); // staticcall
require(success0);
uint256 value0 = 0xffffffffffffffffffffffffffff;
uint256 value1;
uint256 value2;
if (success0) {
uint256 var_b;
uint256 value12 = var_b.length;
uint256 value13 = var_c;
if (0x60 > returnData0.length) {
if (((var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65);
var_b = var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_b + returnData0.length) - var_b) >= 0x60);
require(var_b.length == (uint112(var_b.length)));
require(var_c == (uint112(var_c)));
require(var_d == (uint32(var_d)));
} else {
if (((var_b + 0x60) > 0xffffffffffffffff) | ((var_b + 0x60) < var_b)) _desolexPanic(65);
var_b = var_b + 0x60;
require(((var_b + 0x60) - var_b) >= 0x60);
require(var_e == (uint112(var_e)));
require(var_f == (uint112(var_f)));
require(var_d == (uint32(var_d)));
value12 = var_h;
value13 = var_g;
}
value1 = value12;
value2 = value13;
} else {
value0 = var_b;
value1 = 0;
value2 = 0;
}
uint256 value3 = 0;
if (!(uint112(value1))) {
value3 = value2;
}
if ((((0xffffffffffffffffffffffffffff & value1) != 0x0) && ((value2 & 0xffffffffffffffffffffffffffff) == 0x0)) || ((0xffffffffffffffffffffffffffff & value1) == 0x0)) {
return false;
} else {
(bool success1, bytes memory returnData1) = address(0xdaa4c92507c69b153b3d4556d79f04dc828945e4).decimals(); // staticcall
uint256 value5 = 0;
uint256 value6 = var_b.length;
if (success1) {
uint256 value4 = returnData1.length;
if (0x20 <= returnData1.length) {
value4 = 0x20;
}
if (((var_b + ((value4 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value4 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65);
var_b = var_b + ((value4 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_b + value4) - var_b) >= 0x20);
require(var_b.length == (bytes1(var_b.length)));
} else {
value5 = var_b;
value6 = 0;
}
uint256 value11;
if (success1) {
uint256 value14 = 0;
if (!((value6 & 0xff) != 0x12)) {
(bool success2, bytes memory returnData2) = address(0xdaa4c92507c69b153b3d4556d79f04dc828945e4).latestPrice(); // staticcall
uint256 value7 = 0;
uint256 value8;
uint256 value9;
if (success2) {
uint256 value16 = var_c;
uint256 value17 = var_b.length;
if (0x40 > returnData2.length) {
if (((var_b + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65);
var_b = var_b + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_b + returnData2.length) - var_b) >= 0x40);
} else {
if (((var_b + ((0x40 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((0x40 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65);
var_b = var_b + ((0x40 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_b + 0x40) - var_b) < 0x40));
value16 = var_g;
value17 = var_h;
}
value8 = value16;
value9 = value17;
} else {
value7 = var_b;
value8 = 0;
value9 = 0;
}
uint256 value15;
if (success2) {
uint256 value10 = 0;
bool flag3 = 0x152d02c7e14af6800000 >= value9;
if (value9 < 0x8ac7230489e80000) {
value10 = value9;
flag3 = value9 >= 0x8ac7230489e80000;
}
bool flag4 = value8 != 0x0;
if (!(flag3)) {
flag4 = flag3;
}
bool flag5 = !(value8 > block.timestamp);
if (!(flag4)) {
flag5 = flag4;
}
bool flag6 = !(uint32(stor_2 >> 0x20) < (block.timestamp - value8));
if (flag5) {
} else {
flag6 = flag5;
}
value15 = (flag6) ? 1 : 0;
} else {
value15 = 0;
}
value14 = value15;
}
value11 = value14;
} else {
value11 = 0;
}
return value11;
}
}
}
function Unknown_a06abd16(uint256 arg0) public returns (uint256) {
if (arg0 == 0x0) {
return 0;
} else {
internal_11e1();
if (((arg0 * 0x010000000000000000000000000000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (arg0 << 0x70) == (((arg0 * 0x010000000000000000000000000000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (arg0 << 0x70))) {
require(((arg0 << 0x70) / unresolved_8d2c7252), PriceIsZero());
return (arg0 << 0x70) / unresolved_8d2c7252;
} else {
}
}
}
function Unknown_9010d07c(uint256 arg0, uint256 arg1) public view returns (address) {
if (!(arg1 < getRoleMemberCount[arg0])) _desolexPanic(50);
return address(stor_expr_aa >> 0);
}
function maxStaleness() public view returns (uint32) {
return uint32(stor_2 >> 0x20);
}
function twapWindow() public view returns (uint32) {
return uint32(stor_2);
}
function Unknown_77d63446() public returns (uint256) {
uint256 value6 = 0;
internal_11e1();
uint256 value5 = (0x3b9aca00 * unresolved_8d2c7252) >> 0x70;
if (!(((0x3b9aca00 * unresolved_8d2c7252) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x3b9aca00 * unresolved_8d2c7252) == (((0x3b9aca00 * unresolved_8d2c7252) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x3b9aca00 * unresolved_8d2c7252)))) {
value5 = ((0x3b9aca00 * unresolved_8d2c7252) - ((0x3b9aca00 * unresolved_8d2c7252) % 0x010000000000000000000000000000) >> 0x70) | (((0x3b9aca00 * unresolved_8d2c7252) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (0x3b9aca00 * unresolved_8d2c7252) - (((0x3b9aca00 * unresolved_8d2c7252) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (0x3b9aca00 * unresolved_8d2c7252)) - (((0x3b9aca00 * unresolved_8d2c7252) % 0x010000000000000000000000000000) > (0x3b9aca00 * unresolved_8d2c7252)) << 0x90);
}
require(value5 != 0x0, PriceIsZero());
value6 = value5;
return value6;
}
function Unknown_481565da(uint256 arg0) public returns (uint256) {
if (arg0 == 0x0) {
return 0;
} else {
uint256 value11 = 0;
if (!(arg0 == 0x0)) {
require(unresolved_8d2c7252 != 0x0, OracleNotReady());
uint256 value0 = 0;
if (!(block.timestamp < (uint64(publishedAt)))) {
} else {
value0 = uint64(publishedAt);
}
require(!(block.timestamp >= (publishedAt & 0xffffffffffffffff) && (SHR(0x20, stor_2) & 0xffffffff) < block.timestamp - (publishedAt & 0xffffffffffffffff) || block.timestamp < (publishedAt & 0xffffffffffffffff)), OracleStale());
(bool success0, bytes memory returnData0) = address(0x0bc4df56bb74a06a5a19965adea7833d6b4d9070).getReserves(); // staticcall
require(success0);
uint256 value1 = 0xffffffffffffffffffffffffffff;
uint256 var_b;
uint256 value2 = var_b.length;
uint256 value3 = var_c;
if (success0) {
if (0x60 > returnData0.length) {
if (((var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65);
var_b = var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_b + returnData0.length) - var_b) >= 0x60);
require(var_d == (uint112(var_d)));
require(var_e == (uint112(var_e)));
require(var_f == (uint32(var_f)));
} else {
if (((var_b + ((0x60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((0x60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65);
var_b = var_b + ((0x60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_b + 0x60) - var_b) < 0x60));
require(var_d == (uint112(var_d)));
require(var_e == (uint112(var_e)));
require(var_g == (uint32(var_g)));
}
} else {
value1 = var_b;
value2 = 0;
value3 = 0;
}
uint256 value4 = 0;
if (!(uint112(value2))) {
value4 = value3;
}
require(!((0xffffffffffffffffffffffffffff & value2) != 0x0 && (value3 & 0xffffffffffffffffffffffffffff) == 0x0 || (0xffffffffffffffffffffffffffff & value2) == 0x0), PairHasNoLiquidity());
uint256 value5 = (arg0 * unresolved_8d2c7252) >> 0x70;
if (!(((arg0 * unresolved_8d2c7252) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (arg0 * unresolved_8d2c7252) == (((arg0 * unresolved_8d2c7252) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (arg0 * unresolved_8d2c7252)))) {
value5 = ((arg0 * unresolved_8d2c7252) - ((arg0 * unresolved_8d2c7252) % 0x010000000000000000000000000000) >> 0x70) | (((arg0 * unresolved_8d2c7252) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (arg0 * unresolved_8d2c7252) - (((arg0 * unresolved_8d2c7252) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (arg0 * unresolved_8d2c7252)) - (((arg0 * unresolved_8d2c7252) % 0x010000000000000000000000000000) > (arg0 * unresolved_8d2c7252)) << 0x90);
}
require(value5 != 0x0, PriceIsZero());
value11 = value5;
}
(bool success1, bytes memory returnData1) = address(0xdaa4c92507c69b153b3d4556d79f04dc828945e4).latestPrice(); // staticcall
require(success1);
uint256 value7 = 0;
uint256 value8;
uint256 value9;
if (success1) {
uint256 value6 = returnData1.length;
if (0x40 <= returnData1.length) {
value6 = 0x40;
}
if (((var_b + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65);
var_b = var_b + ((value6 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_b + value6) - var_b) < 0x40));
value8 = var_l;
value9 = var_m;
} else {
value7 = var_b;
value8 = 0;
value9 = 0;
}
uint256 value10 = 0;
if (value9 < 0x8ac7230489e80000) {
value10 = value9;
}
require(!(value9 >= 0x8ac7230489e80000 && value9 > 0x152d02c7e14af6800000 || value9 < 0x8ac7230489e80000), CustomError_1546dbe2());
require(!(value8 != 0x0 && value8 > block.timestamp || value8 == 0x0), CustomError_0bf8830c());
require(!(uint32(stor_2 >> 0x20) < (block.timestamp - value8)), CustomError_b164617b());
if (((value11 * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (value11 * 0x0de0b6b3a7640000) == (((value11 * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (value11 * 0x0de0b6b3a7640000))) {
require(((value11 * 0x0de0b6b3a7640000) / value9), PriceIsZero());
return (value11 * 0x0de0b6b3a7640000) / value9;
} else {
}
}
}
function renounceRole(bytes32 role, address account) public {
require(account == msg.sender, AccessControlBadConfirmation());
internal_1479(role, account);
}
function grantRole(bytes32 role, address account) public {
require(bytes1(hasRole[stor_expr_a][msg.sender]), AccessControlUnauthorizedAccount());
if (!(bytes1(hasRole[role][account]) != 0x0)) {
hasRole[role][account] = true;
emit RoleGranted(role, account, msg.sender);
}
if (!(0 == (!(mapping_expr_am[account])))) {
if (!(stor_expr_al < 0x010000000000000000)) _desolexPanic(65);
stor_expr_al = stor_expr_al + 0x01;
if (!(stor_expr_al < stor_expr_al)) _desolexPanic(50);
stor_expr_an = (0 & stor_expr_an) | (account << 0);
mapping_expr_am[account] = stor_expr_al;
}
}
function getRoleAdmin(bytes32 role) public view returns (uint256) {
return stor_expr_a;
}
function Unknown_1d761f68(uint256 arg0) public returns (uint256) {
uint256 value6 = 0;
if (!(arg0 == 0x0)) {
internal_11e1();
uint256 value5 = (arg0 * unresolved_8d2c7252) >> 0x70;
if (!(((arg0 * unresolved_8d2c7252) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (arg0 * unresolved_8d2c7252) == (((arg0 * unresolved_8d2c7252) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (arg0 * unresolved_8d2c7252)))) {
value5 = ((arg0 * unresolved_8d2c7252) - ((arg0 * unresolved_8d2c7252) % 0x010000000000000000000000000000) >> 0x70) | (((arg0 * unresolved_8d2c7252) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (arg0 * unresolved_8d2c7252) - (((arg0 * unresolved_8d2c7252) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (arg0 * unresolved_8d2c7252)) - (((arg0 * unresolved_8d2c7252) % 0x010000000000000000000000000000) > (arg0 * unresolved_8d2c7252)) << 0x90);
}
require(value5 != 0x0, PriceIsZero());
value6 = value5;
}
return value6;
}
function Unknown_088c3b98(uint32 arg0, uint32 arg1) public {
require(arg0 == (arg0 & 0xffffffff));
require(arg1 == (arg1 & 0xffffffff));
require(mapping_316a51056d8b2401ab04c48d9973add294eadde229c785c6d19cde93785467ef[msg.sender], AccessControlUnauthorizedAccount());
bool flag0 = (arg0 & 0xffffffff) > 0x15180;
if (uint32(arg0) < 0x3c) {
flag0 = (arg0 & 0xffffffff) < 0x3c;
}
bool flag1 = (arg1 & 0xffffffff) < (arg0 & 0xffffffff);
if (flag0) {
flag1 = flag0;
}
require(!(!flag1 && (arg1 & 0xffffffff) > 0x93a80 || flag1), CustomError_1fcbd196());
stor_2 = (stor_2 & (0xffffffffffffffffffffffffffffffffffffffffffffffff0000000000000000) | (arg0 & (0xffffffff))) | ((arg1 << 0x20) & (0xffffffff00000000));
emit Event_8bdf940d(uint32(stor_2), uint32(arg0), uint32(stor_2 >> 0x20), uint32(arg1), block.timestamp);
}
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_11e1() private {
// Decompilation incomplete: helper effect provenance is conservative.
require(unresolved_8d2c7252 != 0x0, OracleNotReady());
uint256 value0 = 0;
bool flag0 = (uint32(stor_2 >> 0x20)) < ((block.timestamp - (uint64(publishedAt))));
if (block.timestamp < (uint64(publishedAt))) {
value0 = uint64(publishedAt);
flag0 = block.timestamp < (uint64(publishedAt));
}
require(!(flag0), OracleStale());
(bool success0, bytes memory returnData0) = address(0x0bc4df56bb74a06a5a19965adea7833d6b4d9070).getReserves(); // staticcall
require(success0);
uint256 value1 = 0xffffffffffffffffffffffffffff;
uint256 value2;
uint256 value3;
if (success0) {
uint256 value5 = var_c;
uint256 value6 = var_d;
uint256 var_b;
if (0x60 > returnData0.length) {
if (((var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65);
var_b = var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(((var_b + returnData0.length) - var_b) >= 0x60);
require(var_e == (uint112(var_e)));
require(var_f == (uint112(var_f)));
require(var_g == (uint32(var_g)));
} else {
if (((var_b + ((0x60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + ((0x60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65);
var_b = var_b + ((0x60 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_b + 0x60) - var_b) < 0x60));
require(var_e == (uint112(var_e)));
require(var_f == (uint112(var_f)));
require(var_h == (uint32(var_h)));
value5 = var_c;
value6 = (var_d);
}
value2 = value5;
value3 = value6;
} else {
value1 = var_b;
value2 = 0;
value3 = 0;
}
uint256 value4 = 0;
if (!(uint112(value2))) {
value4 = value3;
}
require(!((0xffffffffffffffffffffffffffff & value2) != 0x0 && (value3 & 0xffffffffffffffffffffffffffff) == 0x0 || (0xffffffffffffffffffffffffffff & value2) == 0x0), PairHasNoLiquidity());
}
function internal_1479(bytes32 arg0, address arg1) private {
// Decompilation incomplete: helper effect provenance is conservative.
uint256 value0 = 0;
if (bytes1(hasRole[arg0][arg1])) {
hasRole[arg0][arg1] = false;
emit RoleRevoked(arg0, arg1, msg.sender);
value0 = 0x01;
}
if (value0 != 0x0) {
uint256 value4 = 0;
if (!(0 == (!(!(mapping_expr_ac[arg1]))))) {
uint256 value1 = 0;
uint256 value2 = 0;
uint256 value3 = 0;
if ((mapping_expr_ac[arg1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) != (getRoleMemberCount[arg0] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) {
if (!(((getRoleMemberCount[arg0] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < stor_expr_f))) _desolexPanic(50);
if (!(((mapping_expr_ac[arg1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < stor_expr_g))) _desolexPanic(50);
stor_expr_ag = (0 & stor_expr_ah | (stor_expr_af >> (0 << 0x03) << 0));
mapping_expr_ac[stor_expr_af >> (0 << 0x03)] = mapping_expr_ac[arg1];
} else {
value1 = mapping_expr_ac[arg1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
value2 = getRoleMemberCount[arg0] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff;
value3 = mapping_expr_ac[arg1];
}
if (!(getRoleMemberCount[arg0])) _desolexPanic(49);
if (!(((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + getRoleMemberCount[arg0]) < stor_expr_m))) _desolexPanic(50);
stor_expr_aj = (~(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff << (0 << 0x03))) & stor_expr_aj;
getRoleMemberCount[arg0] = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + getRoleMemberCount[arg0];
mapping_expr_ac[arg1] = 0;
flag0 = true;
}
}
}
function __desolexSelectorShim(uint32 rewrittenSelector) private {
assembly {
let input := mload(0x40)
calldatacopy(input, 0, calldatasize())
mstore(input, or(and(mload(input), 0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff), shl(224, and(rewrittenSelector, 0xffffffff))))
let success := delegatecall(gas(), address(), input, calldatasize(), 0, 0)
let size := returndatasize()
returndatacopy(input, 0, size)
switch success
case 0 { revert(input, size) }
default { return(input, size) }
}
}
// Note: This selector table is synthetic and is not part of the original Solidity source.
// It records the recovered selector-to-signature mapping without executable behavior.
// 0x01ffc9a7 => supportsInterface(bytes4)
// 0x047c0237 => unresolved_047c0237()
// 0x088c3b98 => Unknown_088c3b98(uint32,uint32)
// 0x0fc29349 => totalLiability()
// 0x105e203c => pendingTimestamp()
// 0x1a465fe1 => protocolToken()
// 0x1a65893b => MIN_TWAP_WINDOW()
// 0x1af78208 => unresolved_1af78208()
// 0x1d761f68 => Unknown_1d761f68(uint256)
// 0x1d8ffa4d => interfaceVersion()
// 0x248a9ca3 => getRoleAdmin(bytes32)
// 0x2f2ff15d => grantRole(bytes32,address)
// 0x36568abe => renounceRole(bytes32,address)
// 0x3e413bee => usdc()
// 0x481565da => Unknown_481565da(uint256)
// 0x4862240e => unresolved_4862240e()
// 0x5524ee74 => observationCumulative()
// 0x55fd7fa0 => moduleKey()
// 0x756c8850 => observationTimestamp()
// 0x7656419f => protocolRegistry()
// 0x77d63446 => Unknown_77d63446()
// 0x8107e133 => twapWindow()
// 0x85af30c5 => mainPair()
// 0x87cf4696 => maxStaleness()
// 0x8d2c7252 => unresolved_8d2c7252()
// 0x8d72647e => wbnb()
// 0x9010d07c => Unknown_9010d07c(uint256,uint256)
// 0x908316ba => unresolved_908316ba()
// 0x91d14854 => hasRole(bytes32,address)
// 0x9baaf593 => unresolved_9baaf593()
// 0x9ce6dd9f => hasOpenPositions()
// 0xa06abd16 => Unknown_a06abd16(uint256)
// 0xa094a031 => isReady()
// 0xa217fddf => DEFAULT_ADMIN_ROLE()
// 0xa2e62045 => update()
// 0xa3246ad3 => Unknown_a3246ad3(uint256)
// 0xa4213afc => unresolved_a4213afc()
// 0xa5c9cd82 => TOKEN_UNIT()
// 0xb88a92b4 => MAX_TWAP_WINDOW()
// 0xbe5da0b4 => publishedAt()
// 0xca15c873 => getRoleMemberCount(bytes32)
// 0xcaca95a4 => MAX_STALENESS()
// 0xcc054af5 => Unknown_cc054af5()
// 0xcf744feb => unresolved_cf744feb()
// 0xd547741f => revokeRole(bytes32,address)
// 0xf36c8f5c => GOVERNANCE_ROLE()
}