BNB Chain
0x7ec07e99001403480d7396fecbbe530c93a0a575
Decompiled Solidity recovered from this contract's runtime bytecode. Best-effort reconstruction — confirm behaviour against on-chain state.
Decompilation outputBNB Chain · 0x7ec07e99…93a0a57520.9 KB44.4 s
This result is permanently available athttps://decompiler.exvul.com/bsc/0x7ec07e99001403480d7396fecbbe530c93a0a575
//decompiled by exvvul decompiler tool contact@exvul.com https://x.com/exvulsec
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;
contract DesolexContract {
address public constant usdt = address(0x55d398326f99059ff775485246999027b3197955);
address public constant pair = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7);
address public constant router = address(0x10ed43c718714eb63d5aa57b78b54704e256024e);
address public constant token = address(0xd684e229204acd336e1ff1dd64c1045d88888888);
uint256 stor_0; // STORAGE[0x0]
mapping(address => bool) public keepers; // STORAGE[0x1]
uint256 stor_2; // STORAGE[0x2]
uint256 public referencePriceE18; // STORAGE[0x3]
uint256 public unresolved_87d450f7; // STORAGE[0x4]
uint256 public unresolved_ead3e008; // STORAGE[0x5]
uint256 public maxMintPerCall; // STORAGE[0x6]
uint256 public maxMintPerWindow; // STORAGE[0x7]
uint256 public totalMintCap; // STORAGE[0x8]
uint256 public totalMinted; // STORAGE[0x9]
uint256 public cooldown; // STORAGE[0xa]
uint256 public lastInjectionTime; // STORAGE[0xb]
uint256 public windowStart; // STORAGE[0xc]
uint256 public mintedInWindow; // STORAGE[0xd]
uint256 public unresolved_83a47f7e; // STORAGE[0xe]
uint256 public twapPriceE18; // STORAGE[0xf]
uint256 stor_10; // STORAGE[0x10]
uint256 public twapPeriod; // STORAGE[0x11]
uint256 public maxTwapAge; // STORAGE[0x12]
uint256 stor_13; // STORAGE[0x13]
uint256 stor_14; // STORAGE[0x14]
uint256 public unresolved_5f6d8fa0; // STORAGE[0x15]
uint256 public unresolved_b6a6289d; // STORAGE[0x16]
uint256 public unresolved_a2511a59; // STORAGE[0x17]
uint256 public currentTradingDay; // STORAGE[0x18]
uint256 public dailyReferencePriceE18; // STORAGE[0x19]
uint256 public unresolved_2cd259e7; // STORAGE[0x1a]
uint256 public unresolved_b03af0d4; // STORAGE[0x1b]
uint256 public unresolved_068eb3e8; // STORAGE[0x1c]
uint256 public unresolved_7b5df679; // STORAGE[0x1d]
bytes32 stor_1e; // STORAGE[0x1e] // DESOLEX_RAW_STORAGE: whole slot: uint256 [ArithmeticUse] vs uint32 [ArithmeticUse] (ambiguous)
uint256 public unresolved_374a45b3; // STORAGE[0x1f]
event OwnershipTransferred(address indexed, address indexed);
event Event_6915205a(uint256, uint256);
event Event_0e1d7554(uint256 indexed, uint256, uint256, uint256, uint256);
event ReferencePriceUpdated(uint256, uint256);
event Event_a8aa2232(uint256 indexed, uint256, uint256, uint256, uint256);
event Event_1c2c7db9(uint256 indexed, uint256 indexed);
event Event_362df859(uint256 indexed, uint256, uint256);
event TwapConfigUpdated(bool, uint256, uint256);
event LiquidityRemoved(address indexed, uint256, uint256, uint256);
event Event_4c32c791(uint256 indexed, uint256, uint256);
event Event_fedad824(uint256, uint256, uint256, uint256);
event Event_f2569c17(uint256);
event KeeperUpdated(address indexed, bool);
event LiquidityAdded(address indexed, uint256, uint256, uint256);
event Event_c303ed1c(uint256 indexed, uint256 indexed, uint256);
event TwapUpdated(uint256, uint256, uint256);
event Event_8ea31a49(uint256, uint256, uint256, uint256, uint256, uint256);
event Event_a777ff1b(uint256 indexed, uint256);
fallback() external payable {
// Synthetic compatibility routes preserve original selectors for unresolved names.
if ((msg.data.length >= 4) && (msg.sig == 0x0361afad)) {
// Route to Unknown_0361afad(uint256,uint256,uint256,uint256,uint256,uint256) after replacing only msg.sig.
__desolexSelectorShim(uint32(0x5ec4f4ca));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x08bb9a29)) {
// Route to Unknown_08bb9a29(bool,uint256) after replacing only msg.sig.
__desolexSelectorShim(uint32(0x86e35e2e));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x08cffa64)) {
// Route to Unknown_08cffa64() after replacing only msg.sig.
__desolexSelectorShim(uint32(0xf50310a5));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x1a07ba74)) {
// Route to Unknown_1a07ba74() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x5d3db70c));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x2aecdb8a)) {
// Route to Unknown_2aecdb8a() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x5725854c));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x34167a4e)) {
// Route to Unknown_34167a4e(uint256) after replacing only msg.sig.
__desolexSelectorShim(uint32(0x8a1476b6));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x4bff9362)) {
// Route to Unknown_4bff9362() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x0402c016));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x5385098a)) {
// Route to Unknown_5385098a(bool) after replacing only msg.sig.
__desolexSelectorShim(uint32(0x82bd442d));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x656099ef)) {
// Route to Unknown_656099ef(uint256,uint256,uint256) after replacing only msg.sig.
__desolexSelectorShim(uint32(0x596df828));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x77ada1d9)) {
// Route to Unknown_77ada1d9() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x5f0d38b6));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x87c6ffe1)) {
// Route to Unknown_87c6ffe1() after replacing only msg.sig.
__desolexSelectorShim(uint32(0xa9a3754f));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x89e79be2)) {
// Route to Unknown_89e79be2() after replacing only msg.sig.
__desolexSelectorShim(uint32(0xadf3bf4c));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0x95fba192)) {
// Route to Unknown_95fba192() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x0de82fa7));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0xa360501c)) {
// Route to Unknown_a360501c(bool,uint256,uint256,uint256,uint256) after replacing only msg.sig.
__desolexSelectorShim(uint32(0x6814fc4e));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0xb944447f)) {
// Route to Unknown_b944447f() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x3bb16612));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0xccd2de64)) {
// Route to Unknown_ccd2de64() after replacing only msg.sig.
__desolexSelectorShim(uint32(0xcd3f1d4b));
return;
}
if ((msg.data.length >= 4) && (msg.sig == 0xfee169f7)) {
// Route to Unknown_fee169f7() after replacing only msg.sig.
__desolexSelectorShim(uint32(0x506d9840));
return;
}
revert();
}
function Unknown_0361afad(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5) public payable {
internal_7c1(arg5, arg4, arg3, arg2, arg1, arg0);
}
function Unknown_08bb9a29(bool arg0, uint256 arg1) public payable {
require(msg.sender == (address(stor_0 / 0x0100)), "!owner");
require(arg1 <= 0x2710, "offset too high");
if (arg0) {
require(!(arg1 > unresolved_ead3e008), "offset exceeds target");
}
stor_2 = (arg0 * 0x010000) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ffff & stor_2);
unresolved_83a47f7e = arg1;
emit Event_6915205a(arg0, unresolved_83a47f7e);
}
function Unknown_08cffa64() public payable {
bool flag0 = msg.sender == (address(stor_0 / 0x0100));
if (msg.sender != address(stor_0 / 0x0100)) {
flag0 = keepers[msg.sender];
}
require(flag0, "!keeper");
require(!(bytes1(stor_0)), "manager busy");
stor_0 = 0x01 | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & stor_0);
require(!(bytes1(stor_2)), "injection paused");
require(referencePriceE18 > 0, "reference price not set");
(bool success0, bytes memory returnData0) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).dailyResetOffset(); // staticcall
require(success0);
uint256 var_d;
var_d = var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData0.length) - var_d >= 0x20);
uint256 value1 = (block.timestamp - (var_d.length)) / 0x015180;
if (!(block.timestamp < (var_d.length))) {
} else {
value1 = 0;
}
require(unresolved_b03af0d4 == value1, "daily reference not ready");
require(!(block.timestamp < (cooldown + lastInjectionTime)), "cooldown");
(bool success1, bytes memory returnData1) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).dailyResetOffset(); // staticcall
require(success1);
var_d = var_d + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData1.length) - var_d >= 0x20);
uint256 value4 = (block.timestamp - var_d.length) / 0x015180;
if (block.timestamp >= value2) {
} else {
value4 = 0;
}
(bool success2, bytes memory returnData2) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).dailyResetOffset(); // staticcall
require(success2);
var_d = var_d + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData2.length) - var_d >= 0x20);
if (!(windowStart == (var_d.length + (value4 * 0x015180)))) {
windowStart = var_d.length + (value4 * 0x015180);
mintedInWindow = 0;
}
require(mintedInWindow < maxMintPerWindow, "window cap reached");
require(totalMinted < totalMintCap, "total cap reached");
(bool success3, bytes memory returnData3) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).totalSupply(); // staticcall
require(success3);
uint256 tokenSupply = abi.decode(returnData3, (uint256));
(bool success4, bytes memory returnData4) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).maxSupply(); // staticcall
require(success4);
var_d = var_d + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_d + returnData4.length) - var_d) < 0x20));
require((var_d.length - tokenSupply) > 0, "max supply reached");
(bool success5, bytes memory returnData5) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).getReserves(); // staticcall
require(success5);
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = abi.decode(returnData5, (uint112, uint112, uint32));
(bool success6, bytes memory returnData6) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).token0(); // staticcall
require(success6);
var_d = var_d + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData6.length) - var_d >= 0x20);
require(var_q == (var_q & 0xffffffffffffffffffffffffffffffffffffffff));
}
function twapUpdatedAt() public view returns (uint256) {
return stor_10;
}
function Unknown_1a07ba74() public payable returns (uint256) {
bool flag0 = msg.sender == (address(stor_0 / 0x0100));
if (msg.sender != address(stor_0 / 0x0100)) {
flag0 = keepers[msg.sender];
}
require(flag0, "!keeper");
(bool success0, bytes memory returnData0) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).dailyResetOffset(); // staticcall
require(success0);
uint256 var_d;
var_d = var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData0.length) - var_d >= 0x20);
if (!(block.timestamp < var_f)) {
(bool success1, bytes memory returnData1) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).dailyResetOffset(); // staticcall
require(success1);
var_d = var_d + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData1.length) - var_d >= 0x20);
require(!(block.timestamp < (var_f + ((((block.timestamp - var_f) / 0x015180) + 0x01) * 0x015180) - unresolved_b6a6289d)), "reference window not open");
require(block.timestamp < (var_f + ((((block.timestamp - var_f) / 0x015180) + 0x01) * 0x015180)), "reference window ended");
if (bytes1(stor_1e / 0x0100000000)) {
if (bytes1(stor_1e / 0x0100000000) != 0x0) {
(bool success2, bytes memory returnData2) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).dailyResetOffset(); // staticcall
require(success2);
var_d = var_d + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData2.length) - var_d >= 0x20);
require(block.timestamp > (unresolved_5f6d8fa0 + (var_d.length + ((unresolved_068eb3e8 + 0x01) * 0x015180))), "reference window pending");
stor_1e = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff00ffffffff) & stor_1e;
} else {
require(0 != 0x0, "reference window pending");
stor_1e = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff00ffffffff) & stor_1e;
}
emit Event_c303ed1c(unresolved_068eb3e8, unresolved_068eb3e8 + 0x01, block.timestamp);
}
(bool success3, bytes memory returnData3) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).token0(); // staticcall
require(success3);
var_d = var_d + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_d + returnData3.length) - var_d) < 0x20));
require(var_d.length == (var_d.length & 0xffffffffffffffffffffffffffffffffffffffff));
(bool success4, bytes memory returnData4) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).getReserves(); // staticcall
require(success4);
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = abi.decode(returnData4, (uint112, uint112, uint32));
uint256 value5;
if (address(var_d.length) != 0xd684e229204acd336e1ff1dd64c1045d88888888) {
(bool success5, bytes memory returnData5) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).price1CumulativeLast(); // staticcall
require(success5);
var_d = var_d + ((returnData5.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_d + returnData5.length) - var_d) < 0x20));
bool flag1 = (uint32(block.timestamp - var_l)) > 0;
if (uint32(block.timestamp - var_l) > 0) {
flag1 = (uint112(var_m)) > 0;
}
uint256 value11 = var_d.length;
if (flag1) {
value11 = var_d.length + ((uint112(var_f) << 0x70) / (uint112(var_m)) * (uint32(block.timestamp - var_o)));
}
value5 = value11;
} else {
(bool success6, bytes memory returnData6) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).price0CumulativeLast(); // staticcall
require(success6);
var_d = var_d + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_d + returnData6.length) - var_d) < 0x20));
bool flag2 = (uint32(block.timestamp - var_l)) > 0;
if (uint32(block.timestamp - var_l) > 0) {
flag2 = (uint112(var_f)) > 0;
}
uint256 value12 = var_d.length;
if (flag2) {
value12 = var_d.length + ((uint112(var_m) << 0x70) / (uint112(var_f)) * (uint32(block.timestamp - var_o)));
}
value5 = value12;
}
unresolved_068eb3e8 = (block.timestamp - var_f) / 0x015180;
unresolved_7b5df679 = value5;
stor_1e = 0x0100000000 | (block.timestamp & (0xffffffff) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000 & stor_1e));
emit Event_a777ff1b((block.timestamp - var_f) / 0x015180, uint32(block.timestamp));
if (block.timestamp > (unresolved_a2511a59 + (var_f + ((((block.timestamp - var_f) / 0x015180) + 0x01) * 0x015180) - unresolved_b6a6289d))) {
emit Event_362df859((block.timestamp - var_f) / 0x015180, uint32(block.timestamp), block.timestamp - (var_f + ((((block.timestamp - var_f) / 0x015180) + 0x01) * 0x015180) - unresolved_b6a6289d));
}
return (block.timestamp - var_f) / 0x015180;
} else {
(bool success7, bytes memory returnData7) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).dailyResetOffset(); // staticcall
require(success7);
var_d = var_d + ((returnData7.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData7.length) - var_d >= 0x20);
require(!(block.timestamp < ((var_f + 0x015180) - unresolved_b6a6289d)), "reference window not open");
require(block.timestamp < (var_f + 0x015180), "reference window ended");
if (bytes1(stor_1e / 0x0100000000)) {
if (bytes1(stor_1e / 0x0100000000) != 0x0) {
(bool success8, bytes memory returnData8) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).dailyResetOffset(); // staticcall
require(success8);
var_d = var_d + ((returnData8.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData8.length) - var_d >= 0x20);
require(block.timestamp > (unresolved_5f6d8fa0 + (var_d.length + ((unresolved_068eb3e8 + 0x01) * 0x015180))), "reference window pending");
stor_1e = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff00ffffffff) & stor_1e;
} else {
require(0 != 0x0, "reference window pending");
stor_1e = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff00ffffffff) & stor_1e;
}
emit Event_c303ed1c(unresolved_068eb3e8, unresolved_068eb3e8 + 0x01, block.timestamp);
}
(bool success9, bytes memory returnData9) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).token0(); // staticcall
require(success9);
var_d = var_d + ((returnData9.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_d + returnData9.length) - var_d) < 0x20));
require(var_d.length == (var_d.length & 0xffffffffffffffffffffffffffffffffffffffff));
(bool success10, bytes memory returnData10) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).getReserves(); // staticcall
require(success10);
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = abi.decode(returnData10, (uint112, uint112, uint32));
uint256 value10;
if (address(var_d.length) != 0xd684e229204acd336e1ff1dd64c1045d88888888) {
(bool success11, bytes memory returnData11) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).price1CumulativeLast(); // staticcall
require(success11);
var_d = var_d + ((returnData11.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_d + returnData11.length) - var_d) < 0x20));
bool flag3 = (uint32(block.timestamp - var_l)) > 0;
if (uint32(block.timestamp - var_l) > 0) {
flag3 = (uint112(var_m)) > 0;
}
uint256 value13 = var_d.length;
if (flag3) {
value13 = var_d.length + ((uint112(var_f) << 0x70) / (uint112(var_m)) * (uint32(block.timestamp - var_o)));
}
value10 = value13;
} else {
(bool success12, bytes memory returnData12) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).price0CumulativeLast(); // staticcall
require(success12);
var_d = var_d + ((returnData12.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_d + returnData12.length) - var_d) < 0x20));
bool flag4 = (uint32(block.timestamp - var_l)) > 0;
if (uint32(block.timestamp - var_l) > 0) {
flag4 = (uint112(var_f)) > 0;
}
uint256 value14 = var_d.length;
if (flag4) {
value14 = var_d.length + ((uint112(var_m) << 0x70) / (uint112(var_f)) * (uint32(block.timestamp - var_o)));
}
value10 = value14;
}
unresolved_068eb3e8 = 0;
unresolved_7b5df679 = value10;
stor_1e = 0x0100000000 | (block.timestamp & (0xffffffff) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000 & stor_1e));
emit Event_a777ff1b(0, uint32(block.timestamp));
if (block.timestamp > (unresolved_a2511a59 + ((var_f + 0x015180) - unresolved_b6a6289d))) {
emit Event_362df859(0, uint32(block.timestamp), block.timestamp - ((var_f + 0x015180) - unresolved_b6a6289d));
}
return 0;
}
}
function setTwapConfig(bool arg0, uint256 arg1, uint256 arg2) public payable {
require(msg.sender == (address(stor_0 / 0x0100)), "!owner");
require((arg1 >= 0x12c && arg1 <= 0x93a80), "invalid twap period");
require((arg2 >= arg1 && arg2 <= 0x278d00), "invalid twap age");
stor_2 = (arg0 * 0x0100) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff & stor_2);
twapPeriod = arg1;
maxTwapAge = arg2;
emit TwapConfigUpdated(arg0, arg1, maxTwapAge);
}
function Unknown_2aecdb8a() public payable {
internal_116b();
}
function Unknown_34167a4e(uint256 arg0) public payable {
require(msg.sender == (address(stor_0 / 0x0100)), "!owner");
require((arg0 >= unresolved_a2511a59 && arg0 <= 0x93a80), "invalid late roll grace");
emit Event_1c2c7db9(unresolved_5f6d8fa0, arg0);
unresolved_5f6d8fa0 = (arg0) ? 1 : 0;
}
function Unknown_4bff9362() public view returns (bool) {
return !(!(bytes1(stor_1e / 0x010000000000)));
}
function Unknown_5385098a(bool arg0) public payable {
require(msg.sender == (address(stor_0 / 0x0100)), "!owner");
stor_2 = arg0 | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & stor_2);
emit Event_f2569c17(arg0);
}
function useTwap() public view returns (bool) {
return !(!(bytes1(stor_2 / 0x0100)));
}
function Unknown_656099ef(uint256 arg0, uint256 arg1, uint256 arg2) public payable {
internal_1423(arg2, arg1, arg0);
}
function renounceOwnership() public payable {
require(msg.sender == (address(stor_0 / 0x0100)), "!owner");
emit OwnershipTransferred(address(stor_0 / 0x0100), address(0));
stor_0 = (0xffffffffffffffffffffff0000000000000000000000000000000000000000ff) & stor_0;
}
function Unknown_77ada1d9() public view returns (bool) {
return !(!(bytes1(stor_1e / 0x0100000000)));
}
function updateTwap() public payable returns (uint256) {
bool flag0 = msg.sender == (address(stor_0 / 0x0100));
if (msg.sender != address(stor_0 / 0x0100)) {
flag0 = keepers[msg.sender];
}
require(flag0, "!keeper");
(bool success0, bytes memory returnData0) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).token0(); // staticcall
require(success0);
uint256 var_d;
var_d = var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_d + returnData0.length) - var_d) < 0x20));
require(var_d.length == (var_d.length & 0xffffffffffffffffffffffffffffffffffffffff));
(bool success1, bytes memory returnData1) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).getReserves(); // staticcall
require(success1);
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = abi.decode(returnData1, (uint112, uint112, uint32));
uint256 value3;
if ((value0 & 0xffffffffffffffffffffffffffffffffffffffff) != 0xd684e229204acd336e1ff1dd64c1045d88888888) {
(bool success2, bytes memory returnData2) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).price1CumulativeLast(); // staticcall
require(success2);
var_d = var_d + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_d + returnData2.length) - var_d) < 0x20));
bool flag1 = (uint32(block.timestamp - var_h)) > 0;
if (uint32(block.timestamp - var_h) > 0) {
flag1 = (uint112(var_i)) > 0;
}
uint256 value4 = var_d.length;
if (flag1) {
value4 = var_d.length + ((uint112(var_j) << 0x70) / (uint112(var_i)) * (uint32(block.timestamp - var_l)));
}
value3 = value4;
} else {
(bool success3, bytes memory returnData3) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).price0CumulativeLast(); // staticcall
require(success3);
var_d = var_d + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_d + returnData3.length) - var_d) < 0x20));
bool flag2 = (uint32(block.timestamp - var_h)) > 0;
if (uint32(block.timestamp - var_h) > 0) {
flag2 = (uint112(var_j)) > 0;
}
uint256 value5 = var_d.length;
if (flag2) {
value5 = var_d.length + ((uint112(var_i) << 0x70) / (uint112(var_j)) * (uint32(block.timestamp - var_l)));
}
value3 = value5;
}
if (!(bytes1(stor_14 / 0x0100000000))) {
stor_13 = value3;
stor_14 = 0x0100000000 | (block.timestamp & (0xffffffff) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000 & stor_14));
emit TwapUpdated(0, 0, block.timestamp);
return 0;
}
if (uint32(block.timestamp - stor_14) < twapPeriod) {
return 0;
}
require(((0x0de0b6b3a7640000 * ((value3 - stor_13) / (uint32(block.timestamp - stor_14)))) >> 0x70) > 0, "twap price zero");
stor_13 = value3;
stor_14 = (uint32(block.timestamp)) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000 & stor_14);
twapPriceE18 = (0x0de0b6b3a7640000 * ((value3 - stor_13) / (uint32(block.timestamp - stor_14)))) >> 0x70;
stor_10 = block.timestamp;
emit TwapUpdated((0x0de0b6b3a7640000 * ((value3 - stor_13) / (uint32(block.timestamp - stor_14)))) >> 0x70, uint32(block.timestamp - stor_14), stor_10);
return (0x0de0b6b3a7640000 * ((value3 - stor_13) / (uint32(block.timestamp - stor_14)))) >> 0x70;
}
function Unknown_87c6ffe1() public view returns (uint32) {
return uint32(stor_1e);
}
function Unknown_89e79be2() public view returns (bool) {
return !(!(bytes1(stor_2 / 0x010000)));
}
function owner() public view returns (address) {
return address(stor_0 / 0x0100);
}
function dailyResetOffset() public payable returns (uint256) {
(bool success0, bytes memory returnData0) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).dailyResetOffset(); // staticcall
require(success0);
uint256 var_b;
var_b = var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_b + returnData0.length) - var_b) < 0x20));
return var_b.length;
}
function setReferencePrice(uint256 arg0) public payable {
internal_1a91(arg0);
}
function Unknown_95fba192() public payable {
(bool success0, bytes memory returnData0) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).getReserves(); // staticcall
require(success0);
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = abi.decode(returnData0, (uint112, uint112, uint32));
(bool success1, bytes memory returnData1) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).token0(); // staticcall
require(success1);
uint256 var_b;
var_b = var_b + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_b + returnData1.length) - var_b >= 0x20);
require(var_i == (var_i & 0xffffffffffffffffffffffffffffffffffffffff));
uint112 value1 = var_j;
if (!(address(var_j) == 0xd684e229204acd336e1ff1dd64c1045d88888888)) {
value1 = var_k;
}
uint112 value2 = var_k;
if (!(address(var_j) == 0xd684e229204acd336e1ff1dd64c1045d88888888)) {
value2 = var_j;
}
uint256 value3 = (0x0de0b6b3a7640000 * (uint112(value2))) / (uint112(value1));
if (0x0 != (0xffffffffffffffffffffffffffff & value1)) {
} else {
value3 = 0;
}
uint256 value6 = twapPriceE18;
if (!(0xff & stor_2 / 0x100 && twapPriceE18 > 0x0)) {
value6 = value3;
}
uint256 value4 = 0;
if (0 != referencePriceE18) {
value4 = ((unresolved_ead3e008 + 0x2710) * referencePriceE18) / 0x2710;
}
uint256 value5 = 0;
if (0 != referencePriceE18) {
value5 = ((unresolved_87d450f7 + 0x2710) * referencePriceE18) / 0x2710;
}
uint256 value17 = 0;
if ((value4 > 0x0) && ((value5 > 0x0) && ((value6 >= value5) && (value3 > value4)))) {
uint256 value10;
if (!(value4 == 0x0 || value3 == 0x0)) {
(bool success2, bytes memory returnData2) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).getReserves(); // staticcall
require(success2);
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = abi.decode(returnData2, (uint112, uint112, uint32));
(bool success3, bytes memory returnData3) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).token0(); // staticcall
require(success3);
var_b = var_b + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_b + returnData3.length) - var_b >= 0x20);
require(var_q == (var_q & 0xffffffffffffffffffffffffffffffffffffffff));
uint112 value8 = var_j;
if (!(address(var_j) == 0xd684e229204acd336e1ff1dd64c1045d88888888)) {
value8 = var_k;
}
uint112 value9 = var_k;
if (!(address(var_j) == 0xd684e229204acd336e1ff1dd64c1045d88888888)) {
value9 = var_j;
}
uint256 value18 = (((value4 + (0x0de0b6b3a7640000 * (uint112(value9)))) - 0x01) / value4) - (uint112(value8));
if ((((value4 + (0x0de0b6b3a7640000 * (uint112(value9)))) - 0x01) / value4) > (uint112(value8))) {
} else {
value18 = 0;
}
value10 = value18;
} else {
value10 = 0;
}
value17 = value10;
}
(bool success4, bytes memory returnData4) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).dailyResetOffset(); // staticcall
require(success4);
var_b = var_b + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_b + returnData4.length) - var_b >= 0x20);
uint256 value12 = (block.timestamp - var_b.length) / 0x015180;
if (!(block.timestamp < var_b.length)) {
} else {
value12 = 0;
}
(bool success5, bytes memory returnData5) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).dailyResetOffset(); // staticcall
require(success5);
var_b = var_b + ((returnData5.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_b + returnData5.length) - var_b >= 0x20);
uint256 value13 = mintedInWindow;
if (!(windowStart == (var_b.length + (value12 * 0x015180)))) {
value13 = 0;
}
uint256 value14 = maxMintPerWindow - value13;
if (maxMintPerWindow > value13) {
} else {
value14 = 0;
}
uint256 value15 = totalMintCap - totalMinted;
if (totalMintCap > totalMinted) {
} else {
value15 = 0;
}
(bool success6, bytes memory returnData6) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).totalSupply(); // staticcall
require(success6);
uint256 tokenSupply = abi.decode(returnData6, (uint256));
(bool success7, bytes memory returnData7) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).maxSupply(); // staticcall
require(success7);
var_b = var_b + ((returnData7.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_b + returnData7.length) - var_b) < 0x20));
}
function Unknown_a360501c(bool arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 deadline) public payable returns (bytes memory) {
internal_1f6c(deadline, arg3, arg2, arg1, arg0);
return abi.encodePacked(var_c.length, (var_aj), (var_ak));
}
function Unknown_b944447f() public payable returns (uint256) {
bool flag0 = msg.sender == (address(stor_0 / 0x0100));
if (msg.sender != address(stor_0 / 0x0100)) {
flag0 = keepers[msg.sender];
}
require(flag0, "!keeper");
(bool success0, bytes memory returnData0) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).dailyResetOffset(); // staticcall
require(success0);
uint256 var_d;
var_d = var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData0.length) - var_d >= 0x20);
if (!(block.timestamp < var_f)) {
require(bytes1(stor_1e / 0x0100000000) != 0x0, "reference window unavailable");
(bool success1, bytes memory returnData1) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).dailyResetOffset(); // staticcall
require(success1);
var_d = var_d + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData1.length) - var_d >= 0x20);
require(!(((block.timestamp - var_f) / 0x015180) < (unresolved_068eb3e8 + 0x01)), "daily boundary not reached");
require(!(block.timestamp < (var_f + ((unresolved_068eb3e8 + 0x01) * 0x015180))), "daily boundary not reached");
require(!(block.timestamp > (unresolved_5f6d8fa0 + (var_f + ((unresolved_068eb3e8 + 0x01) * 0x015180)))), "daily rollover expired");
(bool success2, bytes memory returnData2) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).token0(); // staticcall
require(success2);
var_d = var_d + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_d + returnData2.length) - var_d) < 0x20));
require(var_d.length == (var_d.length & 0xffffffffffffffffffffffffffffffffffffffff));
(bool success3, bytes memory returnData3) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).getReserves(); // staticcall
require(success3);
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = abi.decode(returnData3, (uint112, uint112, uint32));
uint256 value5;
if (address(var_d.length) - 0xd684e229204acd336e1ff1dd64c1045d88888888 != 0) {
(bool success4, bytes memory returnData4) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).price1CumulativeLast(); // staticcall
require(success4);
var_d = var_d + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_d + returnData4.length) - var_d) < 0x20));
bool flag1 = (uint32(block.timestamp - var_l)) > 0;
if (uint32(block.timestamp - var_l) > 0) {
flag1 = (uint112(var_m)) > 0;
}
uint256 value11 = var_d.length;
if (flag1) {
value11 = var_d.length + ((uint112(var_f) << 0x70) / (uint112(var_m)) * (uint32(block.timestamp - var_o)));
}
value5 = value11;
} else {
(bool success5, bytes memory returnData5) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).price0CumulativeLast(); // staticcall
require(success5);
var_d = var_d + ((returnData5.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_d + returnData5.length) - var_d) < 0x20));
bool flag2 = (uint32(block.timestamp - var_l)) > 0;
if (uint32(block.timestamp - var_l) > 0) {
flag2 = (uint112(var_f)) > 0;
}
uint256 value12 = var_d.length;
if (flag2) {
value12 = var_d.length + ((uint112(var_m) << 0x70) / (uint112(var_f)) * (uint32(block.timestamp - var_o)));
}
value5 = value12;
}
require(!(uint32(block.timestamp - stor_1e) < unresolved_b6a6289d), "reference period incomplete");
require(((0x0de0b6b3a7640000 * ((value5 - unresolved_7b5df679) / (uint32(block.timestamp - stor_1e)))) >> 0x70) > 0, "reference price zero");
currentTradingDay = (block.timestamp - var_f) / 0x015180;
stor_1e = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff00ffffffff) & stor_1e;
windowStart = var_f + ((unresolved_068eb3e8 + 0x01) * 0x015180);
mintedInWindow = 0;
stor_14 = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff00ffffffff) & stor_14;
twapPriceE18 = 0;
stor_10 = 0;
dailyReferencePriceE18 = (0x0de0b6b3a7640000 * ((value5 - unresolved_7b5df679) / (uint32(block.timestamp - stor_1e)))) >> 0x70;
unresolved_2cd259e7 = block.timestamp;
bool flag3 = bytes1(0xffffffffffffffffffffffffffffffffffffffffffffffffffffff00ffffffff & stor_1e / 0x010000000000);
if (bytes1(0xffffffffffffffffffffffffffffffffffffffffffffffffffffff00ffffffff & stor_1e / 0x010000000000)) {
flag3 = unresolved_374a45b3 == ((block.timestamp - var_f) / 0x015180);
}
if (flag3) {
unresolved_b03af0d4 = (block.timestamp - var_f) / 0x015180;
} else {
referencePriceE18 = (0x0de0b6b3a7640000 * ((value5 - unresolved_7b5df679) / (uint32(block.timestamp - stor_1e)))) >> 0x70;
unresolved_b03af0d4 = (block.timestamp - var_f) / 0x015180;
stor_1e = (0xffffffffffffffffffffffffffffffffffffffffffffffffffff00ffffffffff) & stor_1e;
emit ReferencePriceUpdated(referencePriceE18, (0x0de0b6b3a7640000 * ((value5 - unresolved_7b5df679) / (uint32(block.timestamp - stor_1e)))) >> 0x70);
}
require(address(0xd684e229204acd336e1ff1dd64c1045d88888888).code.length != 0x0);
(bool success6, bytes memory returnData6) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).Unknown_5ed4e85e((block.timestamp - var_f) / 0x015180, referencePriceE18); // call
require(success6);
emit Event_a8aa2232((block.timestamp - var_f) / 0x015180, (0x0de0b6b3a7640000 * ((value5 - unresolved_7b5df679) / (uint32(block.timestamp - stor_1e)))) >> 0x70, uint32(stor_1e), uint32(block.timestamp), uint32(block.timestamp - stor_1e));
return (0x0de0b6b3a7640000 * ((value5 - unresolved_7b5df679) / (uint32(block.timestamp - stor_1e)))) >> 0x70;
} else {
require(bytes1(stor_1e / 0x0100000000) != 0x0, "reference window unavailable");
(bool success7, bytes memory returnData7) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).dailyResetOffset(); // staticcall
require(success7);
var_d = var_d + ((returnData7.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData7.length) - var_d >= 0x20);
require(!(0 < (unresolved_068eb3e8 + 0x01)), "daily boundary not reached");
require(!(block.timestamp < (var_f + ((unresolved_068eb3e8 + 0x01) * 0x015180))), "daily boundary not reached");
require(!(block.timestamp > (unresolved_5f6d8fa0 + (var_f + ((unresolved_068eb3e8 + 0x01) * 0x015180)))), "daily rollover expired");
(bool success8, bytes memory returnData8) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).token0(); // staticcall
require(success8);
var_d = var_d + ((returnData8.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_d + returnData8.length) - var_d) < 0x20));
require(var_d.length == (var_d.length & 0xffffffffffffffffffffffffffffffffffffffff));
(bool success9, bytes memory returnData9) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).getReserves(); // staticcall
require(success9);
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = abi.decode(returnData9, (uint112, uint112, uint32));
uint256 value10;
if (address(var_d.length) - 0xd684e229204acd336e1ff1dd64c1045d88888888 != 0) {
(bool success10, bytes memory returnData10) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).price1CumulativeLast(); // staticcall
require(success10);
var_d = var_d + ((returnData10.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_d + returnData10.length) - var_d) < 0x20));
bool flag4 = (uint32(block.timestamp - var_l)) > 0;
if (uint32(block.timestamp - var_l) > 0) {
flag4 = (uint112(var_m)) > 0;
}
uint256 value13 = var_d.length;
if (flag4) {
value13 = var_d.length + ((uint112(var_f) << 0x70) / (uint112(var_m)) * (uint32(block.timestamp - var_o)));
}
value10 = value13;
} else {
(bool success11, bytes memory returnData11) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).price0CumulativeLast(); // staticcall
require(success11);
var_d = var_d + ((returnData11.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_d + returnData11.length) - var_d) < 0x20));
bool flag5 = (uint32(block.timestamp - var_l)) > 0;
if (uint32(block.timestamp - var_l) > 0) {
flag5 = (uint112(var_f)) > 0;
}
uint256 value14 = var_d.length;
if (flag5) {
value14 = var_d.length + ((uint112(var_m) << 0x70) / (uint112(var_f)) * (uint32(block.timestamp - var_o)));
}
value10 = value14;
}
require(!(uint32(block.timestamp - stor_1e) < unresolved_b6a6289d), "reference period incomplete");
require(((0x0de0b6b3a7640000 * ((value10 - unresolved_7b5df679) / (uint32(block.timestamp - stor_1e)))) >> 0x70) > 0, "reference price zero");
currentTradingDay = 0;
stor_1e = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff00ffffffff) & stor_1e;
windowStart = var_f + ((unresolved_068eb3e8 + 0x01) * 0x015180);
mintedInWindow = 0;
stor_14 = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff00ffffffff) & stor_14;
twapPriceE18 = 0;
stor_10 = 0;
dailyReferencePriceE18 = (0x0de0b6b3a7640000 * ((value10 - unresolved_7b5df679) / (uint32(block.timestamp - stor_1e)))) >> 0x70;
unresolved_2cd259e7 = block.timestamp;
if ((0xff & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff00ffffffff & stor_1e) / 0x10000000000 != 0) && (unresolved_374a45b3 == 0x0)) {
unresolved_b03af0d4 = 0;
} else {
referencePriceE18 = (0x0de0b6b3a7640000 * ((value10 - unresolved_7b5df679) / (uint32(block.timestamp - stor_1e)))) >> 0x70;
unresolved_b03af0d4 = 0;
stor_1e = (0xffffffffffffffffffffffffffffffffffffffffffffffffffff00ffffffffff) & stor_1e;
emit ReferencePriceUpdated(referencePriceE18, (0x0de0b6b3a7640000 * ((value10 - unresolved_7b5df679) / (uint32(block.timestamp - stor_1e)))) >> 0x70);
}
require(address(0xd684e229204acd336e1ff1dd64c1045d88888888).code.length != 0x0);
(bool success12, bytes memory returnData12) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).Unknown_5ed4e85e(0, referencePriceE18); // call
require(success12);
emit Event_a8aa2232(0, (0x0de0b6b3a7640000 * ((value10 - unresolved_7b5df679) / (uint32(block.timestamp - stor_1e)))) >> 0x70, uint32(stor_1e), uint32(block.timestamp), uint32(block.timestamp - stor_1e));
return (0x0de0b6b3a7640000 * ((value10 - unresolved_7b5df679) / (uint32(block.timestamp - stor_1e)))) >> 0x70;
}
}
function Unknown_ccd2de64() public view returns (bool) {
return !(!(bytes1(stor_2)));
}
function setKeeper(address account, bool enabled) public payable {
require(msg.sender == (address(stor_0 / 0x0100)), "!owner");
require(account != address(0), "keeper zero");
keepers[account] = enabled;
emit KeeperUpdated(account, keepers[account]);
}
function twapInitialized() public view returns (bool) {
return !(!(bytes1(stor_14 / 0x0100000000)));
}
function transferOwnership(address newOwner) public payable {
require(msg.sender == (address(stor_0 / 0x0100)), "!owner");
require(newOwner != address(0), "owner zero");
emit OwnershipTransferred(address(stor_0 / 0x0100), newOwner);
stor_0 = (stor_0 & (0xffffffffffffffffffffff0000000000000000000000000000000000000000ff)) | (0x0100 * newOwner);
}
function removeLiquidity(uint256 amount, uint256 arg1, uint256 arg2, uint256 arg3) public payable returns (bytes memory) {
internal_2c4c(arg3, arg2, arg1, amount);
return abi.encodePacked(var_c.length, (var_ae));
}
function Unknown_fee169f7() public payable returns (bool) {
internal_326b();
return abi.encodePacked(value18, value7, !(!(stor_10 > stor_10)), 0);
}
function internal_7c1(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, uint256 arg4, uint256 arg5) private {
// Decompilation incomplete: helper effect provenance is conservative.
require(msg.sender == (address(stor_0 / 0x0100)), "!owner");
require(arg5 <= 0x2710, "trigger too high");
require(arg4 < arg5, "target must be lower");
if (bytes1(stor_2 / 0x010000)) {
require(!(unresolved_83a47f7e > arg4), "offset exceeds target");
}
require((arg3 > 0x0 && arg2 >= arg3), "invalid mint limits");
require(arg1 >= arg3, "total cap too low");
require(!(arg1 < totalMinted), "cap below minted");
(bool success0, bytes memory returnData0) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).totalSupply(); // staticcall
require(success0);
uint256 tokenSupply = abi.decode(returnData0, (uint256));
(bool success1, bytes memory returnData1) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).maxSupply(); // staticcall
require(success1);
uint256 var_b;
var_b = var_b + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_b + returnData1.length) - var_b) < 0x20));
require(!(arg1 > (totalMinted + (var_b.length - tokenSupply))), "cap exceeds token supply");
require(arg0 >= 0x3c, "cooldown too short");
require(arg0 <= 0x278d00, "cooldown too long");
unresolved_87d450f7 = arg5;
unresolved_ead3e008 = (arg4) ? 1 : 0;
maxMintPerCall = arg3;
maxMintPerWindow = arg2;
totalMintCap = arg1;
cooldown = (arg0) ? 1 : 0;
emit Event_8ea31a49(arg5, arg4, arg3, arg2, arg1, cooldown);
}
function internal_116b() private {
// Decompilation incomplete: helper effect provenance is conservative.
require(msg.sender == (address(stor_0 / 0x0100)), "!owner");
(bool success0, bytes memory returnData0) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).dailyResetOffset(); // staticcall
require(success0);
uint256 var_b;
var_b = var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_b + returnData0.length) - var_b >= 0x20);
uint256 value1 = ((block.timestamp - (var_b.length)) / 0x015180);
if (block.timestamp < (var_b.length)) {
value1 = 0;
}
stor_1e = (0xffffffffffffffffffffffffffffffffffffffffffffffffffff00ffffffffff) & stor_1e;
unresolved_374a45b3 = value1;
uint256 value3;
if (dailyReferencePriceE18 != 0x0) {
(bool success1, bytes memory returnData1) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).dailyResetOffset(); // staticcall
require(success1);
var_b = var_b + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_b + returnData1.length) - var_b >= 0x20);
value3 = ((unresolved_2cd259e7 - (var_b.length)) / 0x015180);
if (unresolved_2cd259e7 < (var_b.length)) {
value3 = 0;
}
}
if (!(dailyReferencePriceE18 != 0x0 && value3 == value1)) {
unresolved_b03af0d4 = 0;
} else {
referencePriceE18 = dailyReferencePriceE18;
unresolved_b03af0d4 = value1;
require(address(0xd684e229204acd336e1ff1dd64c1045d88888888).code.length != 0x0);
(bool success2, bytes memory returnData2) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).Unknown_5ed4e85e(value1, dailyReferencePriceE18); // call
require(success2);
emit ReferencePriceUpdated(referencePriceE18, dailyReferencePriceE18);
}
emit Event_4c32c791(value1, referencePriceE18, 0);
}
function internal_1423(uint256 arg0, uint256 arg1, uint256 arg2) private {
// Decompilation incomplete: helper effect provenance is conservative.
require(msg.sender == (address(stor_0 / 0x0100)), "!owner");
require(arg2 < 0x15180, "reset offset too high");
(bool success0, bytes memory returnData0) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).dailyResetOffset(); // staticcall
require(success0);
uint256 var_b;
var_b = var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_b + returnData0.length) - var_b) < 0x20));
require(arg2 == value0, "token time mismatch");
require((arg1 >= 0x384 && arg1 <= 0x15180), "invalid reference period");
require((arg0 >= 0x3c && arg0 <= 0xe10), "invalid reference grace");
require(arg0 + arg1 <= 0x15f90, "schedule overlap");
require(!(unresolved_5f6d8fa0 < arg0), "late grace too short");
(bool success1, bytes memory returnData1) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).dailyResetOffset(); // staticcall
require(success1);
var_b = var_b + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_b + returnData1.length) - var_b) < 0x20));
unresolved_b6a6289d = arg1;
unresolved_a2511a59 = (arg0) ? 1 : 0;
(bool success2, bytes memory returnData2) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).dailyResetOffset(); // staticcall
require(success2);
var_b = var_b + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_b + returnData2.length) - var_b >= 0x20);
uint256 value3 = ((block.timestamp - (var_b.length)) / 0x015180);
if (block.timestamp < (var_b.length)) {
value3 = 0;
}
currentTradingDay = value3;
unresolved_b03af0d4 = 0;
stor_1e = (0xffffffffffffffffffffffffffffffffffffffffffffffffffff0000ffffffff) & stor_1e;
emit Event_fedad824(var_b.length, arg2, arg1, arg0);
}
function internal_1a91(uint256 arg0) private {
// Decompilation incomplete: helper effect provenance is conservative.
require(msg.sender == (address(stor_0 / 0x0100)), "!owner");
require(arg0 > 0x0, "reference price zero");
referencePriceE18 = (arg0) ? 1 : 0;
(bool success0, bytes memory returnData0) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).dailyResetOffset(); // staticcall
require(success0);
uint256 var_b;
var_b = var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_b + returnData0.length) - var_b >= 0x20);
uint256 value1 = ((block.timestamp - (var_b.length)) / 0x015180);
if (block.timestamp < (var_b.length)) {
value1 = 0;
}
unresolved_b03af0d4 = value1;
stor_1e = 0x010000000000 | (0xffffffffffffffffffffffffffffffffffffffffffffffffffff00ffffffffff & stor_1e);
unresolved_374a45b3 = value1;
require(address(0xd684e229204acd336e1ff1dd64c1045d88888888).code.length != 0x0);
(bool success1, bytes memory returnData1) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).Unknown_5ed4e85e(value1, arg0); // call
require(success1);
emit ReferencePriceUpdated(referencePriceE18, arg0);
emit Event_4c32c791(value1, arg0, 0x01);
}
function internal_1f6c(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3, bool arg4) private {
// Decompilation incomplete: helper effect provenance is conservative.
require(!(bytes1(stor_0)), "manager busy");
stor_0 = 0x01 | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & stor_0);
require((arg4 && arg3 > 0x0), "amount zero");
require(!(arg0 < block.timestamp), "deadline expired");
(bool success0, bytes memory returnData0) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).balanceOf(address(this)); // staticcall
require(success0);
uint256 beforeBalance = abi.decode(returnData0, (uint256));
(bool success1, bytes memory returnData1) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall
require(success1);
uint256 accountBalance = abi.decode(returnData1, (uint256));
(bool success2, bytes memory returnData2) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).transferFrom(msg.sender, address(this), arg4); // call
require(success2);
bool transferSucceeded = abi.decode(returnData2, (bool));
require(transferSucceeded, "token pull");
(bool success3, bytes memory returnData3) = address(0x55d398326f99059ff775485246999027b3197955).transferFrom(msg.sender, address(this), arg3); // call
require(success3);
bool transferSucceeded1 = abi.decode(returnData3, (bool));
require(transferSucceeded1, "usdt pull");
(bool success4, bytes memory returnData4) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).approve(0x10ed43c718714eb63d5aa57b78b54704e256024e, 0); // call
require(success4);
bool approvalSucceeded = abi.decode(returnData4, (bool));
require(approvalSucceeded, "approve reset");
(bool success5, bytes memory returnData5) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).approve(0x10ed43c718714eb63d5aa57b78b54704e256024e, arg4); // call
require(success5);
bool approvalSucceeded1 = abi.decode(returnData5, (bool));
require(approvalSucceeded1, "approve");
(bool success6, bytes memory returnData6) = address(0x55d398326f99059ff775485246999027b3197955).approve(0x10ed43c718714eb63d5aa57b78b54704e256024e, 0); // call
require(success6);
bool approvalSucceeded2 = abi.decode(returnData6, (bool));
require(approvalSucceeded2, "approve reset");
(bool success7, bytes memory returnData7) = address(0x55d398326f99059ff775485246999027b3197955).approve(0x10ed43c718714eb63d5aa57b78b54704e256024e, arg3); // call
require(success7);
bool approvalSucceeded3 = abi.decode(returnData7, (bool));
require(approvalSucceeded3, "approve");
require(address(0xd684e229204acd336e1ff1dd64c1045d88888888).code.length != 0x0);
(bool success8, bytes memory returnData8) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).Unknown_b80e11a3(msg.sender); // call
require(success8);
(bool success9, bytes memory returnData9) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).addLiquidity(0xd684e229204acd336e1ff1dd64c1045d88888888, 0x55d398326f99059ff775485246999027b3197955, arg4, arg3, arg2, arg1, msg.sender, arg0); // call
require(success9);
abi.decode(returnData9, (uint256, uint256, uint256));
require(address(0xd684e229204acd336e1ff1dd64c1045d88888888).code.length != 0x0);
(bool success10, bytes memory returnData10) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).Unknown_6ec5226c(msg.sender, (var_aa)); // call
require(success10);
require(address(0xd684e229204acd336e1ff1dd64c1045d88888888).code.length != 0x0);
(bool success11, bytes memory returnData11) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).Unknown_45981682(); // call
require(success11);
(bool success12, bytes memory returnData12) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).balanceOf(address(this)); // staticcall
require(success12);
uint256 afterBalance = abi.decode(returnData12, (uint256));
if (afterBalance > beforeBalance) {
(bool success13, bytes memory returnData13) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).transfer(msg.sender, (afterBalance - beforeBalance)); // call
require(success13);
bool transferSucceeded2 = abi.decode(returnData13, (bool));
require(transferSucceeded2, "refund");
}
(bool success14, bytes memory returnData14) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall
require(success14);
uint256 var_c;
var_c = var_c + ((returnData14.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_c + returnData14.length) - var_c >= 0x20);
if (var_af > accountBalance) {
(bool success15, bytes memory returnData15) = address(0x55d398326f99059ff775485246999027b3197955).transfer(msg.sender, (var_af - accountBalance)); // call
require(success15);
bool transferSucceeded3 = abi.decode(returnData15, (bool));
require(transferSucceeded3, "refund");
}
emit LiquidityAdded(msg.sender, var_c.length, (var_aj), (var_ak));
stor_0 = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00) & stor_0;
}
function internal_2c4c(uint256 arg0, uint256 arg1, uint256 arg2, uint256 arg3) private {
// Decompilation incomplete: helper effect provenance is conservative.
require(!(bytes1(stor_0)), "manager busy");
stor_0 = 0x01 | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & stor_0);
require(arg3 != 0x0, "lp zero");
require(!(arg0 < block.timestamp), "deadline expired");
(bool success0, bytes memory returnData0) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).balanceOf(address(this)); // staticcall
require(success0);
uint256 beforeBalance = abi.decode(returnData0, (uint256));
(bool success1, bytes memory returnData1) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).balanceOf(address(this)); // staticcall
require(success1);
uint256 accountBalance = abi.decode(returnData1, (uint256));
(bool success2, bytes memory returnData2) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall
require(success2);
uint256 accountBalance1 = abi.decode(returnData2, (uint256));
(bool success3, bytes memory returnData3) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).transferFrom(msg.sender, address(this), arg3); // call
require(success3);
bool transferSucceeded = abi.decode(returnData3, (bool));
require(transferSucceeded, "lp pull");
(bool success4, bytes memory returnData4) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).approve(0x10ed43c718714eb63d5aa57b78b54704e256024e, 0); // call
require(success4);
bool approvalSucceeded = abi.decode(returnData4, (bool));
require(approvalSucceeded, "approve reset");
(bool success5, bytes memory returnData5) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).approve(0x10ed43c718714eb63d5aa57b78b54704e256024e, arg3); // call
require(success5);
bool approvalSucceeded1 = abi.decode(returnData5, (bool));
require(approvalSucceeded1, "approve");
require(address(0xd684e229204acd336e1ff1dd64c1045d88888888).code.length != 0x0);
(bool success6, bytes memory returnData6) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).Unknown_d4970e3f(msg.sender, arg3); // call
require(success6);
(bool success7, bytes memory returnData7) = address(0x10ed43c718714eb63d5aa57b78b54704e256024e).removeLiquidity(0xd684e229204acd336e1ff1dd64c1045d88888888, 0x55d398326f99059ff775485246999027b3197955, arg3, arg2, arg1, msg.sender, arg0); // call
require(success7);
uint256 var_c;
var_c = var_c + ((returnData7.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require(!(((var_c + returnData7.length) - var_c) < 0x40));
require(address(0xd684e229204acd336e1ff1dd64c1045d88888888).code.length != 0x0);
(bool success8, bytes memory returnData8) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).Unknown_45981682(); // call
require(success8);
(bool success9, bytes memory returnData9) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).balanceOf(address(this)); // staticcall
require(success9);
uint256 afterBalance = abi.decode(returnData9, (uint256));
if (afterBalance > beforeBalance) {
(bool success10, bytes memory returnData10) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).transfer(msg.sender, (afterBalance - beforeBalance)); // call
require(success10);
bool transferSucceeded1 = abi.decode(returnData10, (bool));
require(transferSucceeded1, "refund");
}
(bool success11, bytes memory returnData11) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).balanceOf(address(this)); // staticcall
require(success11);
var_c = var_c + ((returnData11.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_c + returnData11.length) - var_c >= 0x20);
if (var_z > accountBalance) {
(bool success12, bytes memory returnData12) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).transfer(msg.sender, (var_z - accountBalance)); // call
require(success12);
bool transferSucceeded2 = abi.decode(returnData12, (bool));
require(transferSucceeded2, "refund");
}
(bool success13, bytes memory returnData13) = address(0x55d398326f99059ff775485246999027b3197955).balanceOf(address(this)); // staticcall
require(success13);
var_c = var_c + ((returnData13.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_c + returnData13.length) - var_c >= 0x20);
if (var_z > accountBalance1) {
(bool success14, bytes memory returnData14) = address(0x55d398326f99059ff775485246999027b3197955).transfer(msg.sender, (var_z - accountBalance1)); // call
require(success14);
bool transferSucceeded3 = abi.decode(returnData14, (bool));
require(transferSucceeded3, "refund");
}
emit LiquidityRemoved(msg.sender, var_c.length, (var_ae), arg3);
stor_0 = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00) & stor_0;
}
function internal_326b() private {
// Decompilation incomplete: helper effect provenance is conservative.
bool flag0 = msg.sender == (address(stor_0 / 0x0100));
if (msg.sender != address(stor_0 / 0x0100)) {
flag0 = keepers[msg.sender];
}
require(flag0, "!keeper");
require(!(bytes1(stor_0)), "manager busy");
stor_0 = 0x01 | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & stor_0);
uint256 value47 = internal_459c();
uint256 value48 = internal_4825();
uint256 value56 = internal_182c();
uint256 value23 = bytes1(stor_2);
if (!(bytes1(stor_2))) {
value23 = !referencePriceE18;
}
uint256 value24;
if (value23 == 0) {
(bool success0, bytes memory returnData0) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).dailyResetOffset(); // staticcall
require(success0);
var_d = var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData0.length) - var_d >= 0x20);
value24 = ((block.timestamp - var_d.length) / 0x015180);
if (block.timestamp < var_d.length) {
value24 = 0;
}
}
if (value23 != 0x0 || unresolved_b03af0d4 != value24) {
emit Event_0e1d7554(msg.sender, value18, value7, !(!(stor_10 > stor_10)), 0);
stor_0 = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00) & stor_0;
return;
} else if (block.timestamp < ((cooldown + lastInjectionTime))) {
emit Event_0e1d7554(msg.sender, value18, value7, !(!(stor_10 > stor_10)), 0);
stor_0 = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00) & stor_0;
return;
} else if (bytes1(stor_2 / 0x0100)) {
bool flag13 = !twapPriceE18;
if (twapPriceE18 != 0x0) {
flag13 = !stor_10;
}
bool flag14 = flag13;
if (!(flag13)) {
flag14 = ((block.timestamp - stor_10)) > maxTwapAge;
}
if (flag14) {
emit Event_0e1d7554(msg.sender, value18, value7, !(!(stor_10 > stor_10)), 0);
stor_0 = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00) & stor_0;
return;
}
}
}
function internal_182c() private returns (uint256) {
// Decompilation incomplete: helper effect provenance is conservative.
bool flag9 = msg.sender == (address(stor_0 / 0x0100));
if (msg.sender != address(stor_0 / 0x0100)) {
flag9 = keepers[msg.sender];
}
require(flag9, "!keeper");
(bool success0, bytes memory returnData0) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).token0(); // staticcall
require(success0);
var_d = var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData0.length) - var_d >= 0x20);
require(var_h == (var_h & 0xffffffffffffffffffffffffffffffffffffffff));
(bool success1, bytes memory returnData1) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).getReserves(); // staticcall
require(success1);
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = abi.decode(returnData1, (uint112, uint112, uint32));
uint256 value21;
if (address(reserve0) - 0xd684e229204acd336e1ff1dd64c1045d88888888 != 0) {
(bool success2, bytes memory returnData2) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).price1CumulativeLast(); // staticcall
require(success2);
var_d = var_d + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData2.length) - var_d >= 0x20);
bool flag10 = (uint32(block.timestamp - var_q)) > 0;
if (uint32(block.timestamp - var_q) > 0) {
flag10 = (0xffffffffffffffffffffffffffff & reserve13) > 0x0;
}
uint256 value54 = var_d.length;
if (flag10) {
value54 = var_d.length + ((uint112(var_d.length) << 0x70) / (uint112(var_s)) * (uint32(block.timestamp - var_t)));
}
value21 = value54;
} else {
(bool success3, bytes memory returnData3) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).price0CumulativeLast(); // staticcall
require(success3);
var_d = var_d + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData3.length) - var_d >= 0x20);
bool flag11 = (uint32(block.timestamp - var_q)) > 0;
if (uint32(block.timestamp - var_q) > 0) {
flag11 = (0xffffffffffffffffffffffffffff & reserve03) > 0x0;
}
uint256 value55 = var_d.length;
if (flag11) {
value55 = var_d.length + ((uint112(var_s) << 0x70) / (uint112(var_d.length)) * (uint32(block.timestamp - var_t)));
}
value21 = value55;
}
uint256 value22;
if (bytes1(stor_14 / 0x0100000000) == 0x0) {
stor_13 = value21;
stor_14 = 0x0100000000 | (block.timestamp & (0xffffffff) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000 & stor_14));
emit TwapUpdated(0, 0, block.timestamp);
return 0;
} else if (uint32(block.timestamp - stor_14) < twapPeriod) {
return 0;
} else {
require(((0x0de0b6b3a7640000 * (((value21 - stor_13) / (uint32(block.timestamp - stor_14))))) >> 0x70) > 0, "twap price zero");
stor_13 = value21;
stor_14 = (uint32(block.timestamp)) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff00000000 & stor_14);
twapPriceE18 = ((0x0de0b6b3a7640000 * (((value21 - stor_13) / (uint32(block.timestamp - stor_14)))))) >> 0x70;
stor_10 = block.timestamp;
emit TwapUpdated((0x0de0b6b3a7640000 * (((value21 - stor_13) / (uint32(block.timestamp - stor_14))))) >> 0x70, uint32(block.timestamp - stor_14), stor_10);
return (0x0de0b6b3a7640000 * (((value21 - stor_13) / (uint32(block.timestamp - stor_14))))) >> 0x70;
}
}
function internal_459c() private returns (uint256) {
// Decompilation incomplete: helper effect provenance is conservative.
(bool success0, bytes memory returnData0) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).dailyResetOffset(); // staticcall
require(success0);
uint256 var_d;
var_d = var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData0.length) - var_d >= 0x20);
uint256 value1 = ((block.timestamp - var_d.length) / 0x015180);
if (!(block.timestamp >= value0)) {
value1 = 0;
}
uint256 value7;
if (bytes1(stor_1e / 0x0100000000) != 0x0) {
(bool success1, bytes memory returnData1) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).dailyResetOffset(); // staticcall
require(success1);
var_d = var_d + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData1.length) - var_d >= 0x20);
uint256 value41;
if (!(value1 < ((unresolved_068eb3e8 + 0x01)))) {
uint256 value42;
if (!(block.timestamp < ((var_d.length + ((unresolved_068eb3e8 + 0x01) * 0x015180))))) {
uint256 value43;
if (!(block.timestamp > ((unresolved_5f6d8fa0 + ((var_d.length + ((unresolved_068eb3e8 + 0x01) * 0x015180))))))) {
(bool success2, bytes memory returnData2) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).token0(); // staticcall
require(success2);
var_d = var_d + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData2.length) - var_d >= 0x20);
require(var_h == (var_h & 0xffffffffffffffffffffffffffffffffffffffff));
(bool success3, bytes memory returnData3) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).getReserves(); // staticcall
require(success3);
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = abi.decode(returnData3, (uint112, uint112, uint32));
uint256 value6;
if (address(reserve0) - 0xd684e229204acd336e1ff1dd64c1045d88888888 != 0) {
(bool success4, bytes memory returnData4) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).price1CumulativeLast(); // staticcall
require(success4);
var_d = var_d + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData4.length) - var_d >= 0x20);
bool flag1 = (uint32(block.timestamp - var_q)) > 0;
if (uint32(block.timestamp - var_q) > 0) {
flag1 = (0xffffffffffffffffffffffffffff & reserve1) > 0x0;
}
uint256 value45 = var_d.length;
if (flag1) {
value45 = var_d.length + ((uint112(var_d.length) << 0x70) / (uint112(var_s)) * (uint32(block.timestamp - var_t)));
}
value6 = value45;
} else {
(bool success5, bytes memory returnData5) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).price0CumulativeLast(); // staticcall
require(success5);
var_d = var_d + ((returnData5.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData5.length) - var_d >= 0x20);
bool flag2 = (uint32(block.timestamp - var_q)) > 0;
if (uint32(block.timestamp - var_q) > 0) {
flag2 = (0xffffffffffffffffffffffffffff & reserve0) > 0x0;
}
uint256 value46 = var_d.length;
if (flag2) {
value46 = var_d.length + ((uint112(var_s) << 0x70) / (uint112(var_d.length)) * (uint32(block.timestamp - var_t)));
}
value6 = value46;
}
uint256 value44;
if (uint32(block.timestamp - stor_1e) < unresolved_b6a6289d) {
return 0;
} else if (0 == ((0x0de0b6b3a7640000 * ((value6 - unresolved_7b5df679) / uint32(block.timestamp - stor_1e))) >> 0x70)) {
return 0;
} else {
currentTradingDay = value1;
stor_1e = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff00ffffffff) & stor_1e;
windowStart = (var_d.length + ((unresolved_068eb3e8 + 0x01) * 0x015180));
mintedInWindow = 0;
stor_14 = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff00ffffffff) & stor_14;
twapPriceE18 = 0;
stor_10 = 0;
dailyReferencePriceE18 = ((0x0de0b6b3a7640000 * (((value6 - unresolved_7b5df679) / (uint32(block.timestamp - stor_1e)))))) >> 0x70;
unresolved_2cd259e7 = block.timestamp;
if ((0xff & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff00ffffffff & stor_1e) / 0x10000000000 != 0) && (unresolved_374a45b3 == value1)) {
unresolved_b03af0d4 = value1;
} else {
referencePriceE18 = ((0x0de0b6b3a7640000 * (((value6 - unresolved_7b5df679) / (uint32(block.timestamp - stor_1e)))))) >> 0x70;
unresolved_b03af0d4 = value1;
stor_1e = (0xffffffffffffffffffffffffffffffffffffffffffffffffffff00ffffffffff) & stor_1e;
emit ReferencePriceUpdated(referencePriceE18, ((0x0de0b6b3a7640000 * (((value6 - unresolved_7b5df679) / (uint32(block.timestamp - stor_1e)))))) >> 0x70);
}
require(address(0xd684e229204acd336e1ff1dd64c1045d88888888).code.length != 0x0);
(bool success6, bytes memory returnData6) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).Unknown_5ed4e85e(value1, referencePriceE18); // call
require(success6);
emit Event_a8aa2232(value1, ((0x0de0b6b3a7640000 * (((value6 - unresolved_7b5df679) / (uint32(block.timestamp - stor_1e)))))) >> 0x70, uint32(stor_1e), uint32(block.timestamp), uint32(block.timestamp - stor_1e));
return 0x01;
}
} else {
return 0;
}
} else {
return 0;
}
} else {
return 0;
}
} else {
return 0;
}
}
function internal_4825() private returns (uint256) {
// Decompilation incomplete: helper effect provenance is conservative.
(bool success0, bytes memory returnData0) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).dailyResetOffset(); // staticcall
require(success0);
var_d = var_d + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData0.length) - var_d >= 0x20);
uint256 value8 = ((block.timestamp - var_d.length) / 0x015180);
if (block.timestamp < var_d.length) {
value8 = 0;
}
(bool success1, bytes memory returnData1) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).dailyResetOffset(); // staticcall
require(success1);
var_d = var_d + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData1.length) - var_d >= 0x20);
bool flag4 = block.timestamp < (((var_d.length + ((value8 + 0x01) * 0x015180)) - unresolved_b6a6289d));
if (!(block.timestamp < (((var_d.length + ((value8 + 0x01) * 0x015180)) - unresolved_b6a6289d)))) {
flag4 = !(block.timestamp < ((var_d.length + ((value8 + 0x01) * 0x015180))));
}
uint256 value18;
if (flag4) {
return 0;
} else if (bytes1(stor_1e / 0x0100000000)) {
uint256 value14 = ((block.timestamp > (unresolved_5f6d8fa0 + (var_d.length + ((unresolved_068eb3e8 + 0x01) * 0x015180))))) ? 1 : 0;
if (bytes1(stor_1e / 0x0100000000) != 0x0) {
(bool success6, bytes memory returnData6) = address(0xd684e229204acd336e1ff1dd64c1045d88888888).dailyResetOffset(); // staticcall
require(success6);
var_d = var_d + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData6.length) - var_d >= 0x20);
} else {
value14 = 0;
}
if (value14 != 0x0) {
stor_1e = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff00ffffffff) & stor_1e;
emit Event_c303ed1c(unresolved_068eb3e8, unresolved_068eb3e8 + 0x01, block.timestamp);
(bool success7, bytes memory returnData7) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).token0(); // staticcall
require(success7);
var_d = var_d + ((returnData7.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData7.length) - var_d >= 0x20);
require(var_h == (var_h & 0xffffffffffffffffffffffffffffffffffffffff));
(bool success8, bytes memory returnData8) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).getReserves(); // staticcall
require(success8);
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = abi.decode(returnData8, (uint112, uint112, uint32));
uint256 value17;
if (address(reserve0) - 0xd684e229204acd336e1ff1dd64c1045d88888888 != 0) {
(bool success9, bytes memory returnData9) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).price1CumulativeLast(); // staticcall
require(success9);
var_d = var_d + ((returnData9.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData9.length) - var_d >= 0x20);
bool flag7 = (uint32(block.timestamp - var_q)) > 0;
if (uint32(block.timestamp - var_q) > 0) {
flag7 = (0xffffffffffffffffffffffffffff & reserve12) > 0x0;
}
uint256 value52 = var_d.length;
if (flag7) {
value52 = var_d.length + ((uint112(var_d.length) << 0x70) / (uint112(var_s)) * (uint32(block.timestamp - var_t)));
}
value17 = value52;
} else {
(bool success10, bytes memory returnData10) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).price0CumulativeLast(); // staticcall
require(success10);
var_d = var_d + ((returnData10.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData10.length) - var_d >= 0x20);
bool flag8 = (uint32(block.timestamp - var_q)) > 0;
if (uint32(block.timestamp - var_q) > 0) {
flag8 = (0xffffffffffffffffffffffffffff & reserve02) > 0x0;
}
uint256 value53 = var_d.length;
if (flag8) {
value53 = var_d.length + ((uint112(var_s) << 0x70) / (uint112(var_d.length)) * (uint32(block.timestamp - var_t)));
}
value17 = value53;
}
unresolved_068eb3e8 = value8;
unresolved_7b5df679 = value17;
stor_1e = 0x0100000000 | (block.timestamp & (0xffffffff) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000 & stor_1e));
emit Event_a777ff1b(value8, uint32(block.timestamp));
if (block.timestamp > ((unresolved_a2511a59 + (((var_d.length + ((value8 + 0x01) * 0x015180)) - unresolved_b6a6289d))))) {
emit Event_362df859(value8, uint32(block.timestamp), (block.timestamp - (((var_d.length + ((value8 + 0x01) * 0x015180)) - unresolved_b6a6289d))));
}
return 0x01;
} else {
return 0;
}
} else {
(bool success2, bytes memory returnData2) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).token0(); // staticcall
require(success2);
var_d = var_d + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData2.length) - var_d >= 0x20);
require(var_h == (var_h & 0xffffffffffffffffffffffffffffffffffffffff));
(bool success3, bytes memory returnData3) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).getReserves(); // staticcall
require(success3);
(uint112 reserve0, uint112 reserve1, uint32 blockTimestampLast) = abi.decode(returnData3, (uint112, uint112, uint32));
uint256 value13;
if (address(reserve0) - 0xd684e229204acd336e1ff1dd64c1045d88888888 != 0) {
(bool success4, bytes memory returnData4) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).price1CumulativeLast(); // staticcall
require(success4);
var_d = var_d + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData4.length) - var_d >= 0x20);
bool flag5 = (uint32(block.timestamp - var_q)) > 0;
if (uint32(block.timestamp - var_q) > 0) {
flag5 = (0xffffffffffffffffffffffffffff & reserve11) > 0x0;
}
uint256 value50 = var_d.length;
if (flag5) {
value50 = var_d.length + ((uint112(var_d.length) << 0x70) / (uint112(var_s)) * (uint32(block.timestamp - var_t)));
}
value13 = value50;
} else {
(bool success5, bytes memory returnData5) = address(0x443017a871aae227d3b39ab41bd4a83e3168d3f7).price0CumulativeLast(); // staticcall
require(success5);
var_d = var_d + ((returnData5.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
require((var_d + returnData5.length) - var_d >= 0x20);
bool flag6 = (uint32(block.timestamp - var_q)) > 0;
if (uint32(block.timestamp - var_q) > 0) {
flag6 = (0xffffffffffffffffffffffffffff & reserve01) > 0x0;
}
uint256 value51 = var_d.length;
if (flag6) {
value51 = var_d.length + ((uint112(var_s) << 0x70) / (uint112(var_d.length)) * (uint32(block.timestamp - var_t)));
}
value13 = value51;
}
unresolved_068eb3e8 = value8;
unresolved_7b5df679 = value13;
stor_1e = 0x0100000000 | (block.timestamp & (0xffffffff) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff0000000000 & stor_1e));
emit Event_a777ff1b(value8, uint32(block.timestamp));
if (block.timestamp > ((unresolved_a2511a59 + (((var_d.length + ((value8 + 0x01) * 0x015180)) - unresolved_b6a6289d))))) {
emit Event_362df859(value8, uint32(block.timestamp), (block.timestamp - (((var_d.length + ((value8 + 0x01) * 0x015180)) - unresolved_b6a6289d))));
}
return 0x01;
}
}
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.
// 0x0361afad => Unknown_0361afad(uint256,uint256,uint256,uint256,uint256,uint256)
// 0x03ca49f1 => totalMintCap()
// 0x068eb3e8 => unresolved_068eb3e8()
// 0x08bb9a29 => Unknown_08bb9a29(bool,uint256)
// 0x08cffa64 => Unknown_08cffa64()
// 0x17de4ba6 => twapUpdatedAt()
// 0x1a07ba74 => Unknown_1a07ba74()
// 0x1fd9189a => setTwapConfig(bool,uint256,uint256)
// 0x23a6d88d => mintedInWindow()
// 0x25027cc0 => maxTwapAge()
// 0x2aecdb8a => Unknown_2aecdb8a()
// 0x2cd259e7 => unresolved_2cd259e7()
// 0x2f48ab7d => usdt()
// 0x34167a4e => Unknown_34167a4e(uint256)
// 0x374a45b3 => unresolved_374a45b3()
// 0x3bbd64bc => keepers(address)
// 0x3fcf989f => maxMintPerCall()
// 0x4020699a => dailyReferencePriceE18()
// 0x435aef5a => referencePriceE18()
// 0x4bff9362 => Unknown_4bff9362()
// 0x5385098a => Unknown_5385098a(bool)
// 0x54691034 => currentTradingDay()
// 0x5f6d8fa0 => unresolved_5f6d8fa0()
// 0x625b3672 => useTwap()
// 0x656099ef => Unknown_656099ef(uint256,uint256,uint256)
// 0x715018a6 => renounceOwnership()
// 0x77ada1d9 => Unknown_77ada1d9()
// 0x787a08a6 => cooldown()
// 0x7b5df679 => unresolved_7b5df679()
// 0x83a47f7e => unresolved_83a47f7e()
// 0x8516e6dc => updateTwap()
// 0x87c6ffe1 => Unknown_87c6ffe1()
// 0x87d450f7 => unresolved_87d450f7()
// 0x89e79be2 => Unknown_89e79be2()
// 0x8da5cb5b => owner()
// 0x95b7c5e2 => dailyResetOffset()
// 0x95e6c401 => setReferencePrice(uint256)
// 0x95fba192 => Unknown_95fba192()
// 0xa2309ff8 => totalMinted()
// 0xa2511a59 => unresolved_a2511a59()
// 0xa360501c => Unknown_a360501c(bool,uint256,uint256,uint256,uint256)
// 0xa8aa1b31 => pair()
// 0xa9a4fccd => twapPriceE18()
// 0xb03af0d4 => unresolved_b03af0d4()
// 0xb0c2783a => windowStart()
// 0xb6a6289d => unresolved_b6a6289d()
// 0xb944447f => Unknown_b944447f()
// 0xbfe9f2a9 => lastInjectionTime()
// 0xccd2de64 => Unknown_ccd2de64()
// 0xd1b9e853 => setKeeper(address,bool)
// 0xe09bd19f => twapInitialized()
// 0xead3e008 => unresolved_ead3e008()
// 0xed65408c => maxMintPerWindow()
// 0xf2fde38b => transferOwnership(address)
// 0xf6207326 => twapPeriod()
// 0xf887ea40 => router()
// 0xf88bf15a => removeLiquidity(uint256,uint256,uint256,uint256)
// 0xfc0c546a => token()
// 0xfee169f7 => Unknown_fee169f7()
}