BNB Chain
0x0bc4df56bb74a06a5a19965adea7833d6b4d9070
Decompiled Solidity recovered from this contract's runtime bytecode. Best-effort reconstruction — confirm behaviour against on-chain state.
Decompilation outputBNB Chain · 0x0bc4df56…6b4d907014.6 KB37.8 s
This result is permanently available athttps://decompiler.exvul.com/bsc/0x0bc4df56bb74a06a5a19965adea7833d6b4d9070
//decompiled by exvvul decompiler tool [email protected] https://x.com/exvulsec
// SPDX-License-Identifier: MIT
pragma solidity >=0.8.0;
contract DesolexContract {
string public constant name = "Pancake LPs";
uint256 public constant PERMIT_TYPEHASH = 49955707469362902507454157297736832118868343942642399513960811609542965143241;
uint8 public constant decimals = 18;
string public constant symbol = "Cake-LP";
uint256 public constant MINIMUM_LIQUIDITY = 1000;
uint256 public totalSupply; // STORAGE[0x0]
mapping(address => uint256) public balanceOf; // STORAGE[0x1]
mapping(address => mapping(address => uint256)) public allowance; // STORAGE[0x2]
uint256 public DOMAIN_SEPARATOR; // STORAGE[0x3]
mapping(address => uint256) public nonces; // STORAGE[0x4]
address public factory; // STORAGE[0x5] bytes 0 to 19
uint256 stor_6; // STORAGE[0x6]
uint256 stor_7; // STORAGE[0x7]
bytes32 stor_8; // STORAGE[0x8] // DESOLEX_RAW_STORAGE: whole slot: uint224 [ArithmeticUse] vs uint256 [ArithmeticUse] (ambiguous)
uint256 public price0CumulativeLast; // STORAGE[0x9]
uint256 public price1CumulativeLast; // STORAGE[0xa]
uint256 public kLast; // STORAGE[0xb]
bytes32 stor_c; // STORAGE[0xc]
event Burn(address indexed, uint256 indexed, uint256, address);
event Approval(address indexed, address indexed, uint256);
event Swap(address indexed, uint256 indexed, uint256, uint256, uint256, address);
event Mint(address indexed, uint256, uint256);
event Sync(uint112, uint112);
event Transfer(address indexed, address indexed, uint256);
fallback() external payable {
// Synthetic compatibility routes preserve original selectors for unresolved names.
if ((msg.data.length >= 4) && (msg.sig == 0xd505accf)) {
// Route to Unknown_d505accf(address,address,uint256,uint256,bool,uint256,uint256) after replacing only msg.sig.
__desolexSelectorShim(uint32(0xcd2d430f));
return;
}
revert();
}
function swap(uint256 arg0, uint256 arg1, address arg2, bytes memory arg3) public payable {
require(arg3 <= 0x100000000);
require(!(((0x04 + arg3) + 0x20) > (0x04 + (msg.data.length - 0x04))));
require(!((arg3.length > 0x0100000000) | ((0x20 + (0x04 + arg3)) + (arg3.length * 0x01) > (0x04 + (msg.data.length - 0x04)))));
require(stor_c == 0x01, "Pancake: LOCKED");
stor_c = 0;
require((arg0 > 0x0 || arg1 > 0x0), "Pancake: INSUFFICIENT_OUTPUT_AMOUNT");
require((arg0 < (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)) && arg1 < (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000))), "Pancake: INSUFFICIENT_LIQUIDITY");
require((arg2 != stor_6 / 0x1 && arg2 != stor_7 / 0x1), "Pancake: INVALID_TO");
uint256 var_a;
if (arg0 > 0) {
uint256 value1 = 0x20 + var_a;
uint256 value2 = var_a;
uint256 value0 = var_a.length;
while (true) {
var_a = 0x40 + var_a;
var_a = 0x20 + (0x20 + (0x24 + var_a));
if (value0 < 0x20) {
break;
}
value1 = value1 + 0x20;
value2 = value2 + 0x20;
value0 = value0 - 0x20;
}
(bool success0, bytes memory returnData0) = stor_6.call(abi.encodeWithSelector(bytes4(0xa9059cbb), var_n, var_o)); // call transfer
uint256 value3 = 0x60;
if (returnData0.length != 0) {
var_a = var_a + ((returnData0.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
value3 = var_a;
}
uint256 value4 = success0;
if (success0) {
uint256 value16 = (var_p == 0) ? 1 : 0;
if (var_p != 0) {
require(!(var_p < 0x20));
value16 = var_q;
}
value4 = value16;
}
require(value4 != 0x0, "Pancake: TRANSFER_FAILED");
}
if (arg1 > 0) {
uint256 value1 = 0x20 + var_a;
uint256 value2 = var_a;
uint256 value0 = var_a.length;
while (true) {
var_a = 0x40 + var_a;
if (value0 < 0x20) {
break;
}
value1 = value1 + 0x20;
value2 = value2 + 0x20;
value0 = value0 - 0x20;
}
(bool success1, bytes memory returnData1) = address(stor_7 / 0x01).adfepixw(); // call
uint256 value5 = 0x60;
if (returnData1.length != 0) {
var_a = var_a + ((returnData1.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
value5 = var_a;
}
uint256 value6 = success1;
if (success1) {
uint256 value17 = (var_s == 0) ? 1 : 0;
if (var_s != 0) {
require(!(var_s < 0x20));
value17 = var_t;
}
value6 = value17;
}
require(value6 != 0x0, "Pancake: TRANSFER_FAILED");
}
if (arg3.length > 0) {
require(address(arg2).code.length != 0x0);
(bool success2, bytes memory returnData2) = address(arg2).pancakeCall(msg.sender, arg0, arg1, (0x20 + (0x20 + (0x20 + (0x20 + (0x04 + var_a))))) - (0x04 + var_a)); // call
require(success2);
}
require(address(stor_6 / 0x01).code.length != 0x0);
(bool success3, bytes memory returnData3) = stor_6.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf
require(success3);
require(!(returnData3.length < 0x20));
require(address(stor_7 / 0x01).code.length != 0x0);
(bool success4, bytes memory returnData4) = stor_7.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf
require(success4);
require(!(returnData4.length < 0x20));
uint256 value7 = var_a.length - (uint112(stor_8 / 0x01) - arg0);
if (!(var_a.length > (uint112(stor_8 / 0x01) - arg0))) {
value7 = 0;
}
uint256 value8 = var_a.length - (uint112(stor_8 / 0x010000000000000000000000000000) - arg1);
if (!(var_a.length > (uint112(stor_8 / 0x010000000000000000000000000000) - arg1))) {
value8 = 0;
}
require((value7 > 0x0 || value8 > 0x0), "Pancake: INSUFFICIENT_INPUT_AMOUNT");
uint256 value9 = 0;
value9 = value7 * 0x19;
require((0x19 == 0x0 || value7 * 0x19 / 0x19 == value7), "ds-math-mul-overflow");
uint256 value10 = 0;
value10 = var_a.length * 0x2710;
require((0x2710 == 0x0 || var_y * 0x2710 / 0x2710 == var_y), "ds-math-mul-overflow");
require(value10 - value9 <= value10, "ds-math-sub-underflow");
uint256 value11 = 0;
value11 = value8 * 0x19;
require((0x19 == 0x0 || value8 * 0x19 / 0x19 == value8), "ds-math-mul-overflow");
uint256 value12 = 0;
value12 = var_a.length * 0x2710;
require((0x2710 == 0x0 || var_y * 0x2710 / 0x2710 == var_y), "ds-math-mul-overflow");
require(value12 - value11 <= value12, "ds-math-sub-underflow");
uint256 value13 = 0;
if (uint112(stor_8 / 0x010000000000000000000000000000) != 0) {
value13 = (uint112(stor_8 / 0x01)) * (uint112(stor_8 / 0x010000000000000000000000000000));
}
require((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) == 0x0 || (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)) * (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) / (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) == (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)), "ds-math-mul-overflow");
uint256 value14 = 0;
value14 = value13 * 0x05f5e100;
require((0x5f5e100 == 0x0 || value13 * 0x5f5e100 / 0x5f5e100 == value13), "ds-math-mul-overflow");
uint256 value15 = 0;
if ((value12 - value11) != 0) {
value15 = (value10 - value9) * (value12 - value11);
}
require((value12 - value11 == 0x0 || (value10 - value9) * (value12 - value11) / (value12 - value11) == value10 - value9), "ds-math-mul-overflow");
require(value15 >= value14, "Pancake: K");
require((var_y <= 0xffffffffffffffffffffffffffff && var_y <= 0xffffffffffffffffffffffffffff), "Pancake: OVERFLOW");
if (((0xffffffff & block.timestamp % 0x100000000 - (0xffffffff & stor_8 / 0x100000000000000000000000000000000000000000000000000000000)) > 0x0) && (((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)) != 0x0) && ((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) != 0x0))) {
price0CumulativeLast = price0CumulativeLast + (uint224((uint112(uint112(stor_8 / 0x010000000000000000000000000000)) * 0x010000000000000000000000000000) / (uint112(uint112(stor_8 / 0x01)))) * (uint32((block.timestamp % 0x0100000000) - (stor_8 / 0x0100000000000000000000000000000000000000000000000000000000))));
price1CumulativeLast = price1CumulativeLast + (uint224((uint112(uint112(stor_8 / 0x01)) * 0x010000000000000000000000000000) / (uint112(uint112(stor_8 / 0x010000000000000000000000000000)))) * (uint32((block.timestamp % 0x0100000000) - (stor_8 / 0x0100000000000000000000000000000000000000000000000000000000))));
}
stor_8 = (uint112(var_a.length) * 0x01) | (0xffffffffffffffffffffffffffffffffffff0000000000000000000000000000 & stor_8);
stor_8 = (uint112(var_a.length) * 0x010000000000000000000000000000) | (0xffffffff0000000000000000000000000000ffffffffffffffffffffffffffff & stor_8);
stor_8 = (uint32(block.timestamp % 0x0100000000) * 0x0100000000000000000000000000000000000000000000000000000000) | (uint224(stor_8));
emit Sync(uint112(stor_8 / 0x01), uint112(stor_8 / 0x010000000000000000000000000000));
emit Swap(msg.sender, arg2, value7, value8, arg0, arg1);
stor_c = 0x01;
}
function getReserves() public view returns (bytes memory) {
return abi.encodePacked(uint112(stor_8 / 0x01), uint112(stor_8 / 0x010000000000000000000000000000), uint32(stor_8 / 0x0100000000000000000000000000000000000000000000000000000000));
}
function approve(address spender, uint256 amount) public payable returns (bool) {
allowance[msg.sender][spender] = amount;
emit Approval(msg.sender, spender, allowance[msg.sender][spender]);
return true;
}
function token0() public view returns (address) {
return address(stor_6 / 0x01);
}
function transferFrom(address from, address to, uint256 amount) public payable returns (bool) {
if (!(allowance[from][msg.sender] == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)) {
require(!((allowance[from][msg.sender] - amount) > allowance[from][msg.sender]), "ds-math-sub-underflow");
allowance[from][msg.sender] = allowance[from][msg.sender] - amount;
}
require(balanceOf[address(from)] - amount <= balanceOf[address(from)], "ds-math-sub-underflow");
balanceOf[from] = balanceOf[from] - amount;
require(balanceOf[address(to)] + amount >= balanceOf[address(to)], "ds-math-add-overflow");
balanceOf[to] = balanceOf[to] + amount;
emit Transfer(from, to, amount);
return true;
}
function initialize(address arg0, address arg1) public payable {
require(msg.sender == factory, "Pancake: FORBIDDEN");
stor_6 = (arg0 * 0x01) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_6);
stor_7 = (arg1 * 0x01) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_7);
}
function mint(address arg0) public payable returns (uint256) {
require(stor_c == 0x01, "Pancake: LOCKED");
stor_c = 0;
require(address(stor_6 / 0x01).code.length != 0x0);
(bool success0, bytes memory returnData0) = stor_6.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf
require(success0);
require(!(returnData0.length < 0x20));
uint256 accountBalance = abi.decode(returnData0, (uint256));
require(address(stor_7 / 0x01).code.length != 0x0);
(bool success1, bytes memory returnData1) = stor_7.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf
require(success1);
require(!(returnData1.length < 0x20));
uint256 accountBalance1 = abi.decode(returnData1, (uint256));
require(!((accountBalance - (uint112(stor_8 / 0x01))) > accountBalance), "ds-math-sub-underflow");
require(!((accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000))) > accountBalance1), "ds-math-sub-underflow");
require(factory.code.length != 0x0);
(bool success2, bytes memory returnData2) = factory.feeTo(); // staticcall
require(success2);
require(!(returnData2.length < 0x20));
if (!(address(var_c.length) == 0)) {
if (kLast != 0) {
uint256 value9 = 0;
if (uint112(stor_8 / 0x010000000000000000000000000000) != 0) {
value9 = (uint112(stor_8 / 0x01)) * (uint112(stor_8 / 0x010000000000000000000000000000));
}
require(uint112(stor_8 / 0x010000000000000000000000000000) == 0x0 || (uint112(stor_8 / 0x01)) * (uint112(stor_8 / 0x010000000000000000000000000000)) / (uint112(stor_8 / 0x010000000000000000000000000000)) == (uint112(stor_8 / 0x01)), "ds-math-mul-overflow");
if (value9 <= 0x3) {
uint256 value10 = 0;
if (!(value9 == 0)) {
value10 = 0x01;
}
if (kLast > 0x03) {
if (kLast / 0x2 + 0x1 >= kLast) {
if (value10 > kLast) {
require(value10 - kLast <= value10, "ds-math-sub-underflow");
uint256 value11 = 0;
if (!((value10 - kLast) == 0)) {
value11 = totalSupply * (value10 - kLast);
}
require(((value10 - kLast) == 0x0 || totalSupply * (value10 - kLast) / (value10 - kLast) == totalSupply), "ds-math-mul-overflow");
uint256 value12 = 0;
value12 = value11 * 0x08;
require((0x08 == 0x0 || value11 * 0x08 / 0x08 == value11), "ds-math-mul-overflow");
uint256 value13 = 0;
value13 = kLast * 0x08;
require((0x08 == 0x0 || kLast * 0x08 / 0x08 == kLast), "ds-math-mul-overflow");
uint256 value14 = 0;
value14 = value10 * 0x11;
require((0x11 == 0x0 || value10 * 0x11 / 0x11 == value10), "ds-math-mul-overflow");
require(value14 + value13 >= value14, "ds-math-add-overflow");
if (((value14 + value13) != 0x0) && (value12 / (value14 + value13) > 0)) {
require(totalSupply + (value12 / (value14 + value13)) >= totalSupply, "ds-math-add-overflow");
totalSupply = totalSupply + (value12 / (value14 + value13));
require(balanceOf[address(var_c.length)] + (value12 / (value14 + value13)) >= balanceOf[address(var_c.length)], "ds-math-add-overflow");
balanceOf[address(var_c.length)] = balanceOf[address(var_c.length)] + (value12 / (value14 + value13));
emit Transfer(address(0), address(var_c.length), (value12 / (value14 + value13)));
}
}
if (totalSupply != 0) {
bool flag20 = totalSupply == 0;
uint256 value15 = 0;
if (totalSupply != 0) {
flag20 = (((accountBalance - (uint112(stor_8 / 0x01))) * totalSupply) / totalSupply) == (accountBalance - (uint112(stor_8 / 0x01)));
value15 = (accountBalance - (uint112(stor_8 / 0x01))) * totalSupply;
}
require(flag20, "ds-math-mul-overflow");
if (uint112(stor_8 / 0x01) != 0x0) {
bool flag21 = totalSupply == 0;
uint256 value16 = 0;
if (totalSupply != 0) {
flag21 = (((accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000))) * totalSupply) / totalSupply) == (accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000)));
value16 = (accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000))) * totalSupply;
}
require(flag21, "ds-math-mul-overflow");
if (uint112(stor_8 / 0x010000000000000000000000000000) != 0x0) {
uint256 value17 = value15 / (uint112(stor_8 / 0x01));
if ((value15 / uint112(stor_8 / 0x01)) >= (value16 / uint112(stor_8 / 0x010000000000000000000000000000))) {
value17 = value16 / (uint112(stor_8 / 0x010000000000000000000000000000));
}
require(value17 > 0x0, "Pancake: INSUFFICIENT_LIQUIDITY_MINTED");
require(totalSupply + value17 >= totalSupply, "ds-math-add-overflow");
totalSupply = totalSupply + value17;
require(balanceOf[arg0] + value17 >= balanceOf[arg0], "ds-math-add-overflow");
balanceOf[arg0] = balanceOf[arg0] + value17;
emit Transfer(address(0), arg0, value17);
bool flag22 = !(accountBalance > 0xffffffffffffffffffffffffffff);
if (!(accountBalance > 0xffffffffffffffffffffffffffff)) {
flag22 = !(accountBalance1 > 0xffffffffffffffffffffffffffff);
}
require(flag22, "Pancake: OVERFLOW");
if (((0xffffffff & block.timestamp % 0x100000000 - (0xffffffff & stor_8 / 0x100000000000000000000000000000000000000000000000000000000)) > 0x0) && (((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)) != 0x0) && ((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) != 0x0))) {
price0CumulativeLast = price0CumulativeLast + (uint224((uint112(uint112(stor_8 / 0x010000000000000000000000000000)) * 0x010000000000000000000000000000) / (uint112(uint112(stor_8 / 0x01)))) * (uint32((block.timestamp % 0x0100000000) - (stor_8 / 0x0100000000000000000000000000000000000000000000000000000000))));
price1CumulativeLast = price1CumulativeLast + (uint224((uint112(uint112(stor_8 / 0x01)) * 0x010000000000000000000000000000) / (uint112(uint112(stor_8 / 0x010000000000000000000000000000)))) * (uint32((block.timestamp % 0x0100000000) - (stor_8 / 0x0100000000000000000000000000000000000000000000000000000000))));
}
stor_8 = (uint112(accountBalance) * 0x01) | (0xffffffffffffffffffffffffffffffffffff0000000000000000000000000000 & stor_8);
stor_8 = (uint112(accountBalance1) * 0x010000000000000000000000000000) | (0xffffffff0000000000000000000000000000ffffffffffffffffffffffffffff & stor_8);
stor_8 = (uint32(block.timestamp % 0x0100000000) * 0x0100000000000000000000000000000000000000000000000000000000) | (uint224(stor_8));
emit Sync(uint112(stor_8 / 0x01), uint112(stor_8 / 0x010000000000000000000000000000));
if (!(address(var_c.length) == 0)) {
uint256 value18 = 0;
if (uint112(stor_8 / 0x010000000000000000000000000000) != 0) {
value18 = (uint112(stor_8 / 0x01)) * (uint112(stor_8 / 0x010000000000000000000000000000));
}
require((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) == 0x0 || (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)) * (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) / (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) == (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)), "ds-math-mul-overflow");
kLast = value18;
}
emit Mint(msg.sender, accountBalance - (uint112(stor_8 / 0x01)), accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000)));
stor_c = 0x01;
// duplicate declaration of value17 omitted
}
}
} else {
bool flag26 = (accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000))) == 0;
uint256 value19 = 0;
if (!((accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000))) == 0)) {
flag26 = ((accountBalance - (uint112(stor_8 / 0x01))) * (accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000))) / (accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000)))) == (accountBalance - (uint112(stor_8 / 0x01)));
value19 = (accountBalance - (uint112(stor_8 / 0x01))) * (accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000)));
}
require(flag26, "ds-math-mul-overflow");
if (value19 <= 0x3) {
uint256 value20 = 0;
if (value19 != 0) {
value20 = 0x01;
}
require(value20 - 0x3e8 <= value20, "ds-math-sub-underflow");
require(totalSupply + 0x03e8 >= totalSupply, "ds-math-add-overflow");
totalSupply = totalSupply + 0x03e8;
require(balanceOf[0] + 0x03e8 >= balanceOf[0], "ds-math-add-overflow");
balanceOf[0] = balanceOf[0] + 0x03e8;
emit Transfer(address(0), address(0), 0x03e8);
require(value20 - 0x3e8 > 0x0, "Pancake: INSUFFICIENT_LIQUIDITY_MINTED");
require(totalSupply + (value20 - 0x03e8) >= totalSupply, "ds-math-add-overflow");
totalSupply = totalSupply + (value20 - 0x03e8);
require(balanceOf[arg0] + (value20 - 0x03e8) >= balanceOf[arg0], "ds-math-add-overflow");
balanceOf[arg0] = balanceOf[arg0] + (value20 - 0x03e8);
emit Transfer(address(0), arg0, value20 - 0x03e8);
bool flag27 = !(accountBalance > 0xffffffffffffffffffffffffffff);
if (!(accountBalance > 0xffffffffffffffffffffffffffff)) {
flag27 = !(accountBalance1 > 0xffffffffffffffffffffffffffff);
}
require(flag27, "Pancake: OVERFLOW");
if (((0xffffffff & block.timestamp % 0x100000000 - (0xffffffff & stor_8 / 0x100000000000000000000000000000000000000000000000000000000)) > 0x0) && (((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)) != 0x0) && ((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) != 0x0))) {
price0CumulativeLast = price0CumulativeLast + (uint224((uint112(uint112(stor_8 / 0x010000000000000000000000000000)) * 0x010000000000000000000000000000) / (uint112(uint112(stor_8 / 0x01)))) * (uint32((block.timestamp % 0x0100000000) - (stor_8 / 0x0100000000000000000000000000000000000000000000000000000000))));
price1CumulativeLast = price1CumulativeLast + (uint224((uint112(uint112(stor_8 / 0x01)) * 0x010000000000000000000000000000) / (uint112(uint112(stor_8 / 0x010000000000000000000000000000)))) * (uint32((block.timestamp % 0x0100000000) - (stor_8 / 0x0100000000000000000000000000000000000000000000000000000000))));
}
stor_8 = (uint112(accountBalance) * 0x01) | (0xffffffffffffffffffffffffffffffffffff0000000000000000000000000000 & stor_8);
stor_8 = (uint112(accountBalance1) * 0x010000000000000000000000000000) | (0xffffffff0000000000000000000000000000ffffffffffffffffffffffffffff & stor_8);
stor_8 = (uint32(block.timestamp % 0x0100000000) * 0x0100000000000000000000000000000000000000000000000000000000) | (uint224(stor_8));
emit Sync(uint112(stor_8 / 0x01), uint112(stor_8 / 0x010000000000000000000000000000));
if (!(address(var_c.length) == 0)) {
uint256 value21 = 0;
if (uint112(stor_8 / 0x010000000000000000000000000000) != 0) {
value21 = (uint112(stor_8 / 0x01)) * (uint112(stor_8 / 0x010000000000000000000000000000));
}
require((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) == 0x0 || (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)) * (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) / (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) == (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)), "ds-math-mul-overflow");
kLast = value21;
}
emit Mint(msg.sender, accountBalance - (uint112(stor_8 / 0x01)), accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000)));
stor_c = 0x01;
return value20 - 0x03e8;
} else {
if ((0x02 != 0x0) && (value19 / 0x2 + 0x1 >= value19)) {
require(value19 - 0x3e8 <= value19, "ds-math-sub-underflow");
require(totalSupply + 0x03e8 >= totalSupply, "ds-math-add-overflow");
totalSupply = totalSupply + 0x03e8;
require(balanceOf[0] + 0x03e8 >= balanceOf[0], "ds-math-add-overflow");
balanceOf[0] = balanceOf[0] + 0x03e8;
emit Transfer(address(0), address(0), 0x03e8);
require(value19 - 0x3e8 > 0x0, "Pancake: INSUFFICIENT_LIQUIDITY_MINTED");
require(totalSupply + (value19 - 0x03e8) >= totalSupply, "ds-math-add-overflow");
totalSupply = totalSupply + (value19 - 0x03e8);
require(balanceOf[arg0] + (value19 - 0x03e8) >= balanceOf[arg0], "ds-math-add-overflow");
balanceOf[arg0] = balanceOf[arg0] + (value19 - 0x03e8);
emit Transfer(address(0), arg0, value19 - 0x03e8);
bool flag31 = !(accountBalance > 0xffffffffffffffffffffffffffff);
if (!(accountBalance > 0xffffffffffffffffffffffffffff)) {
flag31 = !(accountBalance1 > 0xffffffffffffffffffffffffffff);
}
require(flag31, "Pancake: OVERFLOW");
if (((0xffffffff & block.timestamp % 0x100000000 - (0xffffffff & stor_8 / 0x100000000000000000000000000000000000000000000000000000000)) > 0x0) && (((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)) != 0x0) && ((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) != 0x0))) {
price0CumulativeLast = price0CumulativeLast + (uint224((uint112(uint112(stor_8 / 0x010000000000000000000000000000)) * 0x010000000000000000000000000000) / (uint112(uint112(stor_8 / 0x01)))) * (uint32((block.timestamp % 0x0100000000) - (stor_8 / 0x0100000000000000000000000000000000000000000000000000000000))));
price1CumulativeLast = price1CumulativeLast + (uint224((uint112(uint112(stor_8 / 0x01)) * 0x010000000000000000000000000000) / (uint112(uint112(stor_8 / 0x010000000000000000000000000000)))) * (uint32((block.timestamp % 0x0100000000) - (stor_8 / 0x0100000000000000000000000000000000000000000000000000000000))));
}
stor_8 = (uint112(accountBalance) * 0x01) | (0xffffffffffffffffffffffffffffffffffff0000000000000000000000000000 & stor_8);
stor_8 = (uint112(accountBalance1) * 0x010000000000000000000000000000) | (0xffffffff0000000000000000000000000000ffffffffffffffffffffffffffff & stor_8);
stor_8 = (uint32(block.timestamp % 0x0100000000) * 0x0100000000000000000000000000000000000000000000000000000000) | (uint224(stor_8));
emit Sync(uint112(stor_8 / 0x01), uint112(stor_8 / 0x010000000000000000000000000000));
if (!(address(var_c.length) == 0)) {
uint256 value22 = 0;
if (uint112(stor_8 / 0x010000000000000000000000000000) != 0) {
value22 = (uint112(stor_8 / 0x01)) * (uint112(stor_8 / 0x010000000000000000000000000000));
}
require((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) == 0x0 || (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)) * (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) / (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) == (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)), "ds-math-mul-overflow");
kLast = value22;
}
emit Mint(msg.sender, accountBalance - (uint112(stor_8 / 0x01)), accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000)));
stor_c = 0x01;
return value19 - 0x03e8;
}
}
}
} else {
if (kLast / 0x2 != type(uint256).max) {
if ((kLast / (kLast / 0x2 + 0x1) + (kLast / 0x2 + 0x1)) / 0x2 >= kLast / 0x2 + 0x1) {
if (value10 > ((kLast / 0x02) + 0x01)) {
require(value10 - ((kLast / 0x02) + 0x01) <= value10, "ds-math-sub-underflow");
uint256 value23 = 0;
if (!((value10 - ((kLast / 0x02) + 0x01)) == 0)) {
value23 = totalSupply * (value10 - ((kLast / 0x02) + 0x01));
}
require(((value10 - ((kLast / 0x02) + 0x01)) == 0x0 || totalSupply * (value10 - ((kLast / 0x02) + 0x01)) / (value10 - ((kLast / 0x02) + 0x01)) == totalSupply), "ds-math-mul-overflow");
uint256 value24 = 0;
value24 = value23 * 0x08;
require((0x08 == 0x0 || value23 * 0x08 / 0x08 == value23), "ds-math-mul-overflow");
uint256 value25 = 0;
value25 = ((kLast / 0x02) + 0x01) * 0x08;
require((0x08 == 0x0 || ((kLast / 0x02) + 0x01) * 0x08 / 0x08 == ((kLast / 0x02) + 0x01)), "ds-math-mul-overflow");
uint256 value26 = 0;
value26 = value10 * 0x11;
require((0x11 == 0x0 || value10 * 0x11 / 0x11 == value10), "ds-math-mul-overflow");
require(value26 + value25 >= value26, "ds-math-add-overflow");
if (((value26 + value25) != 0x0) && (value24 / (value26 + value25) > 0)) {
require(totalSupply + (value24 / (value26 + value25)) >= totalSupply, "ds-math-add-overflow");
totalSupply = totalSupply + (value24 / (value26 + value25));
require(balanceOf[address(var_c.length)] + (value24 / (value26 + value25)) >= balanceOf[address(var_c.length)], "ds-math-add-overflow");
balanceOf[address(var_c.length)] = balanceOf[address(var_c.length)] + (value24 / (value26 + value25));
emit Transfer(address(0), address(var_c.length), (value24 / (value26 + value25)));
}
}
if (totalSupply != 0) {
bool flag39 = totalSupply == 0;
uint256 value27 = 0;
if (totalSupply != 0) {
flag39 = (((accountBalance - (uint112(stor_8 / 0x01))) * totalSupply) / totalSupply) == (accountBalance - (uint112(stor_8 / 0x01)));
value27 = (accountBalance - (uint112(stor_8 / 0x01))) * totalSupply;
}
require(flag39, "ds-math-mul-overflow");
} else {
bool flag40 = (accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000))) == 0;
uint256 value28 = 0;
if (!((accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000))) == 0)) {
flag40 = ((accountBalance - (uint112(stor_8 / 0x01))) * (accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000))) / (accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000)))) == (accountBalance - (uint112(stor_8 / 0x01)));
value28 = (accountBalance - (uint112(stor_8 / 0x01))) * (accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000)));
}
require(flag40, "ds-math-mul-overflow");
if (value28 <= 0x3) {
uint256 value29 = 0;
if (value28 != 0) {
value29 = 0x01;
}
require(value29 - 0x3e8 <= value29, "ds-math-sub-underflow");
require(totalSupply + 0x03e8 >= totalSupply, "ds-math-add-overflow");
totalSupply = totalSupply + 0x03e8;
require(balanceOf[0] + 0x03e8 >= balanceOf[0], "ds-math-add-overflow");
balanceOf[0] = balanceOf[0] + 0x03e8;
emit Transfer(address(0), address(0), 0x03e8);
require(value29 - 0x3e8 > 0x0, "Pancake: INSUFFICIENT_LIQUIDITY_MINTED");
require(totalSupply + (value29 - 0x03e8) >= totalSupply, "ds-math-add-overflow");
totalSupply = totalSupply + (value29 - 0x03e8);
require(balanceOf[arg0] + (value29 - 0x03e8) >= balanceOf[arg0], "ds-math-add-overflow");
balanceOf[arg0] = balanceOf[arg0] + (value29 - 0x03e8);
emit Transfer(address(0), arg0, value29 - 0x03e8);
bool flag41 = !(accountBalance > 0xffffffffffffffffffffffffffff);
if (!(accountBalance > 0xffffffffffffffffffffffffffff)) {
flag41 = !(accountBalance1 > 0xffffffffffffffffffffffffffff);
}
require(flag41, "Pancake: OVERFLOW");
if (((0xffffffff & block.timestamp % 0x100000000 - (0xffffffff & stor_8 / 0x100000000000000000000000000000000000000000000000000000000)) > 0x0) && (((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)) != 0x0) && ((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) != 0x0))) {
price0CumulativeLast = price0CumulativeLast + (uint224((uint112(uint112(stor_8 / 0x010000000000000000000000000000)) * 0x010000000000000000000000000000) / (uint112(uint112(stor_8 / 0x01)))) * (uint32((block.timestamp % 0x0100000000) - (stor_8 / 0x0100000000000000000000000000000000000000000000000000000000))));
price1CumulativeLast = price1CumulativeLast + (uint224((uint112(uint112(stor_8 / 0x01)) * 0x010000000000000000000000000000) / (uint112(uint112(stor_8 / 0x010000000000000000000000000000)))) * (uint32((block.timestamp % 0x0100000000) - (stor_8 / 0x0100000000000000000000000000000000000000000000000000000000))));
}
stor_8 = (uint112(accountBalance) * 0x01) | (0xffffffffffffffffffffffffffffffffffff0000000000000000000000000000 & stor_8);
stor_8 = (uint112(accountBalance1) * 0x010000000000000000000000000000) | (0xffffffff0000000000000000000000000000ffffffffffffffffffffffffffff & stor_8);
stor_8 = (uint32(block.timestamp % 0x0100000000) * 0x0100000000000000000000000000000000000000000000000000000000) | (uint224(stor_8));
emit Sync(uint112(stor_8 / 0x01), uint112(stor_8 / 0x010000000000000000000000000000));
if (!(address(var_c.length) == 0)) {
uint256 value30 = 0;
if (uint112(stor_8 / 0x010000000000000000000000000000) != 0) {
value30 = (uint112(stor_8 / 0x01)) * (uint112(stor_8 / 0x010000000000000000000000000000));
}
require((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) == 0x0 || (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)) * (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) / (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) == (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)), "ds-math-mul-overflow");
kLast = value30;
}
emit Mint(msg.sender, accountBalance - (uint112(stor_8 / 0x01)), accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000)));
stor_c = 0x01;
return value29 - 0x03e8;
} else {
if ((0x02 != 0x0) && (value28 / 0x2 + 0x1 >= value28)) {
require(value28 - 0x3e8 <= value28, "ds-math-sub-underflow");
require(totalSupply + 0x03e8 >= totalSupply, "ds-math-add-overflow");
totalSupply = totalSupply + 0x03e8;
require(balanceOf[0] + 0x03e8 >= balanceOf[0], "ds-math-add-overflow");
balanceOf[0] = balanceOf[0] + 0x03e8;
emit Transfer(address(0), address(0), 0x03e8);
require(value28 - 0x3e8 > 0x0, "Pancake: INSUFFICIENT_LIQUIDITY_MINTED");
require(totalSupply + (value28 - 0x03e8) >= totalSupply, "ds-math-add-overflow");
totalSupply = totalSupply + (value28 - 0x03e8);
require(balanceOf[arg0] + (value28 - 0x03e8) >= balanceOf[arg0], "ds-math-add-overflow");
balanceOf[arg0] = balanceOf[arg0] + (value28 - 0x03e8);
emit Transfer(address(0), arg0, value28 - 0x03e8);
bool flag45 = !(accountBalance > 0xffffffffffffffffffffffffffff);
if (!(accountBalance > 0xffffffffffffffffffffffffffff)) {
flag45 = !(accountBalance1 > 0xffffffffffffffffffffffffffff);
}
require(flag45, "Pancake: OVERFLOW");
if (((0xffffffff & block.timestamp % 0x100000000 - (0xffffffff & stor_8 / 0x100000000000000000000000000000000000000000000000000000000)) > 0x0) && (((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)) != 0x0) && ((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) != 0x0))) {
price0CumulativeLast = price0CumulativeLast + (uint224((uint112(uint112(stor_8 / 0x010000000000000000000000000000)) * 0x010000000000000000000000000000) / (uint112(uint112(stor_8 / 0x01)))) * (uint32((block.timestamp % 0x0100000000) - (stor_8 / 0x0100000000000000000000000000000000000000000000000000000000))));
price1CumulativeLast = price1CumulativeLast + (uint224((uint112(uint112(stor_8 / 0x01)) * 0x010000000000000000000000000000) / (uint112(uint112(stor_8 / 0x010000000000000000000000000000)))) * (uint32((block.timestamp % 0x0100000000) - (stor_8 / 0x0100000000000000000000000000000000000000000000000000000000))));
}
stor_8 = (uint112(accountBalance) * 0x01) | (0xffffffffffffffffffffffffffffffffffff0000000000000000000000000000 & stor_8);
stor_8 = (uint112(accountBalance1) * 0x010000000000000000000000000000) | (0xffffffff0000000000000000000000000000ffffffffffffffffffffffffffff & stor_8);
stor_8 = (uint32(block.timestamp % 0x0100000000) * 0x0100000000000000000000000000000000000000000000000000000000) | (uint224(stor_8));
emit Sync(uint112(stor_8 / 0x01), uint112(stor_8 / 0x010000000000000000000000000000));
if (!(address(var_c.length) == 0)) {
uint256 value31 = 0;
if (uint112(stor_8 / 0x010000000000000000000000000000) != 0) {
value31 = (uint112(stor_8 / 0x01)) * (uint112(stor_8 / 0x010000000000000000000000000000));
}
require((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) == 0x0 || (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)) * (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) / (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) == (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)), "ds-math-mul-overflow");
kLast = value31;
}
emit Mint(msg.sender, accountBalance - (uint112(stor_8 / 0x01)), accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000)));
stor_c = 0x01;
return value28 - 0x03e8;
}
}
}
}
}
}
}
}
} else if (totalSupply == 0) {
bool flag6 = (accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000))) == 0;
uint256 value5 = 0;
if (!((accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000))) == 0)) {
flag6 = ((accountBalance - (uint112(stor_8 / 0x01))) * (accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000))) / (accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000)))) == (accountBalance - (uint112(stor_8 / 0x01)));
value5 = (accountBalance - (uint112(stor_8 / 0x01))) * (accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000)));
}
require(flag6, "ds-math-mul-overflow");
if (value5 <= 0x3) {
uint256 value6 = 0;
if (value5 != 0) {
value6 = 0x01;
}
require(value6 - 0x3e8 <= value6, "ds-math-sub-underflow");
require(totalSupply + 0x03e8 >= totalSupply, "ds-math-add-overflow");
totalSupply = totalSupply + 0x03e8;
require(balanceOf[0] + 0x03e8 >= balanceOf[0], "ds-math-add-overflow");
balanceOf[0] = balanceOf[0] + 0x03e8;
emit Transfer(address(0), address(0), 0x03e8);
require(value6 - 0x3e8 > 0x0, "Pancake: INSUFFICIENT_LIQUIDITY_MINTED");
require(totalSupply + (value6 - 0x03e8) >= totalSupply, "ds-math-add-overflow");
totalSupply = totalSupply + (value6 - 0x03e8);
require(balanceOf[arg0] + (value6 - 0x03e8) >= balanceOf[arg0], "ds-math-add-overflow");
balanceOf[arg0] = balanceOf[arg0] + (value6 - 0x03e8);
emit Transfer(address(0), arg0, value6 - 0x03e8);
bool flag7 = !(accountBalance > 0xffffffffffffffffffffffffffff);
if (!(accountBalance > 0xffffffffffffffffffffffffffff)) {
flag7 = !(accountBalance1 > 0xffffffffffffffffffffffffffff);
}
require(flag7, "Pancake: OVERFLOW");
if (((0xffffffff & block.timestamp % 0x100000000 - (0xffffffff & stor_8 / 0x100000000000000000000000000000000000000000000000000000000)) > 0x0) && (((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)) != 0x0) && ((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) != 0x0))) {
price0CumulativeLast = price0CumulativeLast + (uint224((uint112(uint112(stor_8 / 0x010000000000000000000000000000)) * 0x010000000000000000000000000000) / (uint112(uint112(stor_8 / 0x01)))) * (uint32((block.timestamp % 0x0100000000) - (stor_8 / 0x0100000000000000000000000000000000000000000000000000000000))));
price1CumulativeLast = price1CumulativeLast + (uint224((uint112(uint112(stor_8 / 0x01)) * 0x010000000000000000000000000000) / (uint112(uint112(stor_8 / 0x010000000000000000000000000000)))) * (uint32((block.timestamp % 0x0100000000) - (stor_8 / 0x0100000000000000000000000000000000000000000000000000000000))));
}
stor_8 = (uint112(accountBalance) * 0x01) | (0xffffffffffffffffffffffffffffffffffff0000000000000000000000000000 & stor_8);
stor_8 = (uint112(accountBalance1) * 0x010000000000000000000000000000) | (0xffffffff0000000000000000000000000000ffffffffffffffffffffffffffff & stor_8);
stor_8 = (uint32(block.timestamp % 0x0100000000) * 0x0100000000000000000000000000000000000000000000000000000000) | (uint224(stor_8));
emit Sync(uint112(stor_8 / 0x01), uint112(stor_8 / 0x010000000000000000000000000000));
if (!(address(var_c.length) == 0)) {
uint256 value7 = 0;
if (uint112(stor_8 / 0x010000000000000000000000000000) != 0) {
value7 = (uint112(stor_8 / 0x01)) * (uint112(stor_8 / 0x010000000000000000000000000000));
}
require((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) == 0x0 || (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)) * (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) / (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) == (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)), "ds-math-mul-overflow");
kLast = value7;
}
emit Mint(msg.sender, accountBalance - (uint112(stor_8 / 0x01)), accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000)));
stor_c = 0x01;
return value6 - 0x03e8;
} else {
if ((0x02 != 0x0) && (value5 / 0x2 + 0x1 >= value5)) {
require(value5 - 0x3e8 <= value5, "ds-math-sub-underflow");
require(totalSupply + 0x03e8 >= totalSupply, "ds-math-add-overflow");
totalSupply = totalSupply + 0x03e8;
require(balanceOf[0] + 0x03e8 >= balanceOf[0], "ds-math-add-overflow");
balanceOf[0] = balanceOf[0] + 0x03e8;
emit Transfer(address(0), address(0), 0x03e8);
require(value5 - 0x3e8 > 0x0, "Pancake: INSUFFICIENT_LIQUIDITY_MINTED");
require(totalSupply + (value5 - 0x03e8) >= totalSupply, "ds-math-add-overflow");
totalSupply = totalSupply + (value5 - 0x03e8);
require(balanceOf[arg0] + (value5 - 0x03e8) >= balanceOf[arg0], "ds-math-add-overflow");
balanceOf[arg0] = balanceOf[arg0] + (value5 - 0x03e8);
emit Transfer(address(0), arg0, value5 - 0x03e8);
bool flag11 = !(accountBalance > 0xffffffffffffffffffffffffffff);
if (!(accountBalance > 0xffffffffffffffffffffffffffff)) {
flag11 = !(accountBalance1 > 0xffffffffffffffffffffffffffff);
}
require(flag11, "Pancake: OVERFLOW");
if (((0xffffffff & block.timestamp % 0x100000000 - (0xffffffff & stor_8 / 0x100000000000000000000000000000000000000000000000000000000)) > 0x0) && (((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)) != 0x0) && ((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) != 0x0))) {
price0CumulativeLast = price0CumulativeLast + (uint224((uint112(uint112(stor_8 / 0x010000000000000000000000000000)) * 0x010000000000000000000000000000) / (uint112(uint112(stor_8 / 0x01)))) * (uint32((block.timestamp % 0x0100000000) - (stor_8 / 0x0100000000000000000000000000000000000000000000000000000000))));
price1CumulativeLast = price1CumulativeLast + (uint224((uint112(uint112(stor_8 / 0x01)) * 0x010000000000000000000000000000) / (uint112(uint112(stor_8 / 0x010000000000000000000000000000)))) * (uint32((block.timestamp % 0x0100000000) - (stor_8 / 0x0100000000000000000000000000000000000000000000000000000000))));
}
stor_8 = (uint112(accountBalance) * 0x01) | (0xffffffffffffffffffffffffffffffffffff0000000000000000000000000000 & stor_8);
stor_8 = (uint112(accountBalance1) * 0x010000000000000000000000000000) | (0xffffffff0000000000000000000000000000ffffffffffffffffffffffffffff & stor_8);
stor_8 = (uint32(block.timestamp % 0x0100000000) * 0x0100000000000000000000000000000000000000000000000000000000) | (uint224(stor_8));
emit Sync(uint112(stor_8 / 0x01), uint112(stor_8 / 0x010000000000000000000000000000));
if (!(address(var_c.length) == 0)) {
uint256 value8 = 0;
if (uint112(stor_8 / 0x010000000000000000000000000000) != 0) {
value8 = (uint112(stor_8 / 0x01)) * (uint112(stor_8 / 0x010000000000000000000000000000));
}
require((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) == 0x0 || (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)) * (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) / (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) == (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)), "ds-math-mul-overflow");
kLast = value8;
}
emit Mint(msg.sender, accountBalance - (uint112(stor_8 / 0x01)), accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000)));
stor_c = 0x01;
return value5 - 0x03e8;
}
}
} else {
bool flag0 = totalSupply == 0;
uint256 value1 = 0;
if (totalSupply != 0) {
flag0 = (((accountBalance - (uint112(stor_8 / 0x01))) * totalSupply) / totalSupply) == (accountBalance - (uint112(stor_8 / 0x01)));
value1 = (accountBalance - (uint112(stor_8 / 0x01))) * totalSupply;
}
require(flag0, "ds-math-mul-overflow");
if (uint112(stor_8 / 0x01) != 0x0) {
bool flag1 = totalSupply == 0;
uint256 value2 = 0;
if (totalSupply != 0) {
flag1 = (((accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000))) * totalSupply) / totalSupply) == (accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000)));
value2 = (accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000))) * totalSupply;
}
require(flag1, "ds-math-mul-overflow");
if (uint112(stor_8 / 0x010000000000000000000000000000) != 0x0) {
uint256 value3 = value1 / (uint112(stor_8 / 0x01));
if ((value1 / uint112(stor_8 / 0x01)) >= (value2 / uint112(stor_8 / 0x010000000000000000000000000000))) {
value3 = value2 / (uint112(stor_8 / 0x010000000000000000000000000000));
}
require(value3 > 0x0, "Pancake: INSUFFICIENT_LIQUIDITY_MINTED");
require(totalSupply + value3 >= totalSupply, "ds-math-add-overflow");
totalSupply = totalSupply + value3;
require(balanceOf[arg0] + value3 >= balanceOf[arg0], "ds-math-add-overflow");
balanceOf[arg0] = balanceOf[arg0] + value3;
emit Transfer(address(0), arg0, value3);
bool flag2 = !(accountBalance > 0xffffffffffffffffffffffffffff);
if (!(accountBalance > 0xffffffffffffffffffffffffffff)) {
flag2 = !(accountBalance1 > 0xffffffffffffffffffffffffffff);
}
require(flag2, "Pancake: OVERFLOW");
if (((0xffffffff & block.timestamp % 0x100000000 - (0xffffffff & stor_8 / 0x100000000000000000000000000000000000000000000000000000000)) > 0x0) && (((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)) != 0x0) && ((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) != 0x0))) {
price0CumulativeLast = price0CumulativeLast + (uint224((uint112(uint112(stor_8 / 0x010000000000000000000000000000)) * 0x010000000000000000000000000000) / (uint112(uint112(stor_8 / 0x01)))) * (uint32((block.timestamp % 0x0100000000) - (stor_8 / 0x0100000000000000000000000000000000000000000000000000000000))));
price1CumulativeLast = price1CumulativeLast + (uint224((uint112(uint112(stor_8 / 0x01)) * 0x010000000000000000000000000000) / (uint112(uint112(stor_8 / 0x010000000000000000000000000000)))) * (uint32((block.timestamp % 0x0100000000) - (stor_8 / 0x0100000000000000000000000000000000000000000000000000000000))));
}
stor_8 = (uint112(accountBalance) * 0x01) | (0xffffffffffffffffffffffffffffffffffff0000000000000000000000000000 & stor_8);
stor_8 = (uint112(accountBalance1) * 0x010000000000000000000000000000) | (0xffffffff0000000000000000000000000000ffffffffffffffffffffffffffff & stor_8);
stor_8 = (uint32(block.timestamp % 0x0100000000) * 0x0100000000000000000000000000000000000000000000000000000000) | (uint224(stor_8));
emit Sync(uint112(stor_8 / 0x01), uint112(stor_8 / 0x010000000000000000000000000000));
if (!(address(var_c.length) == 0)) {
uint256 value4 = 0;
if (uint112(stor_8 / 0x010000000000000000000000000000) != 0) {
value4 = (uint112(stor_8 / 0x01)) * (uint112(stor_8 / 0x010000000000000000000000000000));
}
require((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) == 0x0 || (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)) * (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) / (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) == (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)), "ds-math-mul-overflow");
kLast = value4;
}
emit Mint(msg.sender, accountBalance - (uint112(stor_8 / 0x01)), accountBalance1 - (uint112(stor_8 / 0x010000000000000000000000000000)));
stor_c = 0x01;
// duplicate declaration of value3 omitted
}
}
}
}
}
function burn(address account) public payable returns (bytes memory) {
require(stor_c == 0x01, "Pancake: LOCKED");
stor_c = 0;
require(address(stor_6 / 0x01).code.length != 0x0);
(bool success0, bytes memory returnData0) = stor_6.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf
require(success0);
require(!(returnData0.length < 0x20));
uint256 accountBalance = abi.decode(returnData0, (uint256));
require(address(stor_7 / 0x01).code.length != 0x0);
(bool success1, bytes memory returnData1) = stor_7.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf
require(success1);
require(!(returnData1.length < 0x20));
uint256 accountBalance1 = abi.decode(returnData1, (uint256));
require(factory.code.length != 0x0);
(bool success2, bytes memory returnData2) = factory.feeTo(); // staticcall
require(success2);
require(!(returnData2.length < 0x20));
uint256 var_e;
if (!(address(var_e.length) == 0)) {
if (kLast != 0) {
uint256 value1 = 0;
if (uint112(stor_8 / 0x010000000000000000000000000000) != 0) {
value1 = (uint112(stor_8 / 0x01)) * (uint112(stor_8 / 0x010000000000000000000000000000));
}
require(uint112(stor_8 / 0x010000000000000000000000000000) == 0x0 || (uint112(stor_8 / 0x01)) * (uint112(stor_8 / 0x010000000000000000000000000000)) / (uint112(stor_8 / 0x010000000000000000000000000000)) == (uint112(stor_8 / 0x01)), "ds-math-mul-overflow");
if (value1 > 0x03) {
uint256 value2 = (value1 / 0x02) + 0x01;
uint256 value3 = value1;
while (true) {
if (value2 >= value3) {
break;
}
if (value2 == 0) {
break;
}
if (0x02 == 0) {
break;
}
if ((value1 / value2 + value2) / 0x2 >= value2) {
if (kLast <= 0x3) {
uint256 value11 = 0;
if (kLast != 0) {
value11 = 0x01;
}
if (value2 > value11) {
require(value2 - value11 <= value2, "ds-math-sub-underflow");
uint256 value12 = 0;
if (!((value2 - value11) == 0)) {
value12 = totalSupply * (value2 - value11);
}
require(((value2 - value11) == 0x0 || totalSupply * (value2 - value11) / (value2 - value11) == totalSupply), "ds-math-mul-overflow");
uint256 value13 = 0;
value13 = value12 * 0x08;
require((0x08 == 0x0 || value12 * 0x08 / 0x08 == value12), "ds-math-mul-overflow");
uint256 value14 = 0;
value14 = value11 * 0x08;
require((0x08 == 0x0 || value11 * 0x08 / 0x08 == value11), "ds-math-mul-overflow");
uint256 value15 = 0;
value15 = value2 * 0x11;
require((0x11 == 0x0 || value2 * 0x11 / 0x11 == value2), "ds-math-mul-overflow");
require(value15 + value14 >= value15, "ds-math-add-overflow");
if (((value15 + value14) != 0x0) && (value13 / (value15 + value14) > 0)) {
require(totalSupply + (value13 / (value15 + value14)) >= totalSupply, "ds-math-add-overflow");
totalSupply = totalSupply + (value13 / (value15 + value14));
require(balanceOf[address(var_e.length)] + (value13 / (value15 + value14)) >= balanceOf[address(var_e.length)], "ds-math-add-overflow");
balanceOf[address(var_e.length)] = balanceOf[address(var_e.length)] + (value13 / (value15 + value14));
emit Transfer(address(0), address(var_e.length), (value13 / (value15 + value14)));
}
}
bool flag12 = accountBalance == 0;
uint256 value16 = 0;
if (!(accountBalance == 0)) {
flag12 = ((balanceOf[address(this)] * accountBalance) / accountBalance) == balanceOf[address(this)];
value16 = balanceOf[address(this)] * accountBalance;
}
require(flag12, "ds-math-mul-overflow");
if (totalSupply != 0x0) {
bool flag13 = accountBalance1 == 0;
uint256 value17 = 0;
if (!(accountBalance1 == 0)) {
flag13 = ((balanceOf[address(this)] * accountBalance1) / accountBalance1) == balanceOf[address(this)];
value17 = balanceOf[address(this)] * accountBalance1;
}
require(flag13, "ds-math-mul-overflow");
if (totalSupply != 0x0) {
require((value16 / totalSupply > 0x0 && value17 / totalSupply > 0x0), "Pancake: INSUFFICIENT_LIQUIDITY_BURNED");
require(balanceOf[address(this)] - balanceOf[address(this)] <= balanceOf[address(this)], "ds-math-sub-underflow");
balanceOf[address(this)] = balanceOf[address(this)] - balanceOf[address(this)];
require(totalSupply - balanceOf[address(this)] <= totalSupply, "ds-math-sub-underflow");
totalSupply = totalSupply - balanceOf[address(this)];
emit Transfer(address(this), address(0), balanceOf[address(this)]);
uint256 value18 = 0x20 + var_e;
uint256 value19 = var_e;
uint256 value10 = var_e.length;
while (true) {
var_e = 0x40 + var_e;
var_e = 0x20 + (0x20 + (0x24 + var_e));
if (value10 < 0x20) {
break;
}
value18 = value18 + 0x20;
value19 = value19 + 0x20;
value10 = value10 - 0x20;
}
(bool success3, bytes memory returnData3) = stor_6.call(abi.encodeWithSelector(bytes4(0xa9059cbb), var_q, var_r)); // call transfer
uint256 value20 = 0x60;
if (returnData3.length != 0) {
var_e = var_e + ((returnData3.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
value20 = var_e;
}
uint256 value21 = success3;
if (success3) {
uint256 value47 = (var_s == 0) ? 1 : 0;
if (var_s != 0) {
require(!(var_s < 0x20));
value47 = var_t;
}
value21 = value47;
}
require(value21 != 0x0, "Pancake: TRANSFER_FAILED");
value18 = 0x20 + var_e;
value19 = var_e;
value10 = var_e.length;
while (true) {
var_e = 0x40 + var_e;
var_e = 0x20 + (0x20 + (0x24 + var_e));
if (value10 < 0x20) {
break;
}
value18 = value18 + 0x20;
value19 = value19 + 0x20;
value10 = value10 - 0x20;
require(address(stor_6 / 0x01).code.length != 0x0);
(bool success4, bytes memory returnData4) = stor_6.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf
require(success4);
require(!(returnData4.length < 0x20));
require(address(stor_7 / 0x01).code.length != 0x0);
(bool success5, bytes memory returnData5) = stor_7.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf
require(success5);
require(!(returnData5.length < 0x20));
require((var_aa <= 0xffffffffffffffffffffffffffff && var_aa <= 0xffffffffffffffffffffffffffff), "Pancake: OVERFLOW");
if (((0xffffffff & block.timestamp % 0x100000000 - (0xffffffff & stor_8 / 0x100000000000000000000000000000000000000000000000000000000)) > 0x0) && (((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)) != 0x0) && ((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) != 0x0))) {
price0CumulativeLast = price0CumulativeLast + (uint224((uint112(uint112(stor_8 / 0x010000000000000000000000000000)) * 0x010000000000000000000000000000) / (uint112(uint112(stor_8 / 0x01)))) * (uint32((block.timestamp % 0x0100000000) - (stor_8 / 0x0100000000000000000000000000000000000000000000000000000000))));
price1CumulativeLast = price1CumulativeLast + (uint224((uint112(uint112(stor_8 / 0x01)) * 0x010000000000000000000000000000) / (uint112(uint112(stor_8 / 0x010000000000000000000000000000)))) * (uint32((block.timestamp % 0x0100000000) - (stor_8 / 0x0100000000000000000000000000000000000000000000000000000000))));
}
stor_8 = (uint112(var_e.length) * 0x01) | (0xffffffffffffffffffffffffffffffffffff0000000000000000000000000000 & stor_8);
stor_8 = (uint112(var_e.length) * 0x010000000000000000000000000000) | (0xffffffff0000000000000000000000000000ffffffffffffffffffffffffffff & stor_8);
stor_8 = (uint32(block.timestamp % 0x0100000000) * 0x0100000000000000000000000000000000000000000000000000000000) | (uint224(stor_8));
emit Sync(uint112(stor_8 / 0x01), uint112(stor_8 / 0x010000000000000000000000000000));
if (!(address(var_e.length) == 0)) {
uint256 value24 = 0;
if (uint112(stor_8 / 0x010000000000000000000000000000) != 0) {
value24 = (uint112(stor_8 / 0x01)) * (uint112(stor_8 / 0x010000000000000000000000000000));
}
require((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) == 0x0 || (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)) * (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) / (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) == (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)), "ds-math-mul-overflow");
kLast = value24;
}
emit Burn(msg.sender, account, value16 / totalSupply, value17 / totalSupply);
stor_c = 0x01;
return abi.encodePacked(value16 / totalSupply, value17 / totalSupply);
}
(bool success6, bytes memory returnData6) = address(stor_7 / 0x01).adfepixw(); // call
uint256 value22 = 0x60;
if (returnData6.length != 0) {
var_e = var_e + ((returnData6.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
value22 = var_e;
}
uint256 value23 = success6;
if (success6) {
uint256 value48 = (var_ad == 0) ? 1 : 0;
if (var_ad != 0) {
require(!(var_ad < 0x20));
value48 = var_ae;
}
value23 = value48;
}
require(value23 != 0x0, "Pancake: TRANSFER_FAILED");
}
}
} else {
uint256 value2 = (kLast / 0x02) + 0x01;
uint256 value3 = kLast;
while (true) {
if (value2 >= value3) {
break;
}
if (value2 == 0) {
break;
}
if (0x02 == 0) {
break;
}
if ((kLast / value2 + value2) / 0x2 >= value2) {
if (value2 > value2) {
require(value2 - value2 <= value2, "ds-math-sub-underflow");
uint256 value36 = 0;
if (!((value2 - value2) == 0)) {
value36 = totalSupply * (value2 - value2);
}
require(((value2 - value2) == 0x0 || totalSupply * (value2 - value2) / (value2 - value2) == totalSupply), "ds-math-mul-overflow");
uint256 value37 = 0;
value37 = value36 * 0x08;
require((0x08 == 0x0 || value36 * 0x08 / 0x08 == value36), "ds-math-mul-overflow");
uint256 value38 = 0;
value38 = value2 * 0x08;
require((0x08 == 0x0 || value2 * 0x08 / 0x08 == value2), "ds-math-mul-overflow");
uint256 value39 = 0;
value39 = value2 * 0x11;
require((0x11 == 0x0 || value2 * 0x11 / 0x11 == value2), "ds-math-mul-overflow");
require(value39 + value38 >= value39, "ds-math-add-overflow");
if (((value39 + value38) != 0x0) && (value37 / (value39 + value38) > 0)) {
require(totalSupply + (value37 / (value39 + value38)) >= totalSupply, "ds-math-add-overflow");
totalSupply = totalSupply + (value37 / (value39 + value38));
require(balanceOf[address(var_e.length)] + (value37 / (value39 + value38)) >= balanceOf[address(var_e.length)], "ds-math-add-overflow");
balanceOf[address(var_e.length)] = balanceOf[address(var_e.length)] + (value37 / (value39 + value38));
emit Transfer(address(0), address(var_e.length), (value37 / (value39 + value38)));
}
}
bool flag34 = accountBalance == 0;
uint256 value40 = 0;
if (!(accountBalance == 0)) {
flag34 = ((balanceOf[address(this)] * accountBalance) / accountBalance) == balanceOf[address(this)];
value40 = balanceOf[address(this)] * accountBalance;
}
require(flag34, "ds-math-mul-overflow");
if (totalSupply != 0x0) {
bool flag35 = accountBalance1 == 0;
uint256 value41 = 0;
if (!(accountBalance1 == 0)) {
flag35 = ((balanceOf[address(this)] * accountBalance1) / accountBalance1) == balanceOf[address(this)];
value41 = balanceOf[address(this)] * accountBalance1;
}
require(flag35, "ds-math-mul-overflow");
if (totalSupply != 0x0) {
require((value40 / totalSupply > 0x0 && value41 / totalSupply > 0x0), "Pancake: INSUFFICIENT_LIQUIDITY_BURNED");
require(balanceOf[address(this)] - balanceOf[address(this)] <= balanceOf[address(this)], "ds-math-sub-underflow");
balanceOf[address(this)] = balanceOf[address(this)] - balanceOf[address(this)];
require(totalSupply - balanceOf[address(this)] <= totalSupply, "ds-math-sub-underflow");
totalSupply = totalSupply - balanceOf[address(this)];
emit Transfer(address(this), address(0), balanceOf[address(this)]);
uint256 value18 = 0x20 + var_e;
uint256 value19 = var_e;
uint256 value10 = var_e.length;
while (true) {
var_e = 0x40 + var_e;
var_e = 0x20 + (0x20 + (0x24 + var_e));
if (value10 < 0x20) {
break;
}
value18 = value18 + 0x20;
value19 = value19 + 0x20;
value10 = value10 - 0x20;
}
(bool success7, bytes memory returnData7) = stor_6.call(abi.encodeWithSelector(bytes4(0xa9059cbb), var_q, var_r)); // call transfer
uint256 value42 = 0x60;
if (returnData7.length != 0) {
var_e = var_e + ((returnData7.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
value42 = var_e;
}
uint256 value43 = success7;
if (success7) {
uint256 value49 = (var_af == 0) ? 1 : 0;
if (var_af != 0) {
require(!(var_af < 0x20));
value49 = var_ag;
}
value43 = value49;
}
require(value43 != 0x0, "Pancake: TRANSFER_FAILED");
value18 = 0x20 + var_e;
value19 = var_e;
value10 = var_e.length;
while (true) {
var_e = 0x40 + var_e;
var_e = 0x20 + (0x20 + (0x24 + var_e));
if (value10 < 0x20) {
break;
}
value18 = value18 + 0x20;
value19 = value19 + 0x20;
value10 = value10 - 0x20;
require(address(stor_6 / 0x01).code.length != 0x0);
(bool success8, bytes memory returnData8) = stor_6.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf
require(success8);
require(!(returnData8.length < 0x20));
require(address(stor_7 / 0x01).code.length != 0x0);
(bool success9, bytes memory returnData9) = stor_7.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf
require(success9);
require(!(returnData9.length < 0x20));
require((var_aa <= 0xffffffffffffffffffffffffffff && var_aa <= 0xffffffffffffffffffffffffffff), "Pancake: OVERFLOW");
if (((0xffffffff & block.timestamp % 0x100000000 - (0xffffffff & stor_8 / 0x100000000000000000000000000000000000000000000000000000000)) > 0x0) && (((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)) != 0x0) && ((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) != 0x0))) {
price0CumulativeLast = price0CumulativeLast + (uint224((uint112(uint112(stor_8 / 0x010000000000000000000000000000)) * 0x010000000000000000000000000000) / (uint112(uint112(stor_8 / 0x01)))) * (uint32((block.timestamp % 0x0100000000) - (stor_8 / 0x0100000000000000000000000000000000000000000000000000000000))));
price1CumulativeLast = price1CumulativeLast + (uint224((uint112(uint112(stor_8 / 0x01)) * 0x010000000000000000000000000000) / (uint112(uint112(stor_8 / 0x010000000000000000000000000000)))) * (uint32((block.timestamp % 0x0100000000) - (stor_8 / 0x0100000000000000000000000000000000000000000000000000000000))));
}
stor_8 = (uint112(var_e.length) * 0x01) | (0xffffffffffffffffffffffffffffffffffff0000000000000000000000000000 & stor_8);
stor_8 = (uint112(var_e.length) * 0x010000000000000000000000000000) | (0xffffffff0000000000000000000000000000ffffffffffffffffffffffffffff & stor_8);
stor_8 = (uint32(block.timestamp % 0x0100000000) * 0x0100000000000000000000000000000000000000000000000000000000) | (uint224(stor_8));
emit Sync(uint112(stor_8 / 0x01), uint112(stor_8 / 0x010000000000000000000000000000));
if (!(address(var_e.length) == 0)) {
uint256 value46 = 0;
if (uint112(stor_8 / 0x010000000000000000000000000000) != 0) {
value46 = (uint112(stor_8 / 0x01)) * (uint112(stor_8 / 0x010000000000000000000000000000));
}
require((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) == 0x0 || (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)) * (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) / (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) == (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)), "ds-math-mul-overflow");
kLast = value46;
}
emit Burn(msg.sender, account, value40 / totalSupply, value41 / totalSupply);
stor_c = 0x01;
return abi.encodePacked(value40 / totalSupply, value41 / totalSupply);
}
(bool success10, bytes memory returnData10) = address(stor_7 / 0x01).adfepixw(); // call
uint256 value44 = 0x60;
if (returnData10.length != 0) {
var_e = var_e + ((returnData10.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
value44 = var_e;
}
uint256 value45 = success10;
if (success10) {
uint256 value50 = (var_ah == 0) ? 1 : 0;
if (var_ah != 0) {
require(!(var_ah < 0x20));
value50 = var_ai;
}
value45 = value50;
}
require(value45 != 0x0, "Pancake: TRANSFER_FAILED");
}
}
break;
}
if (((kLast / value2) + value2) / 0x02 == 0) {
break;
}
if (0x02 == 0) {
break;
}
value2 = ((kLast / (((kLast / value2) + value2) / 0x02)) + (((kLast / value2) + value2) / 0x02)) / 0x02;
value3 = ((kLast / value2) + value2) / 0x02;
}
if (value2 > value3) {
require(value2 - value3 <= value2, "ds-math-sub-underflow");
uint256 value25 = 0;
if (!((value2 - value3) == 0)) {
value25 = totalSupply * (value2 - value3);
}
require(((value2 - value3) == 0x0 || totalSupply * (value2 - value3) / (value2 - value3) == totalSupply), "ds-math-mul-overflow");
uint256 value26 = 0;
value26 = value25 * 0x08;
require((0x08 == 0x0 || value25 * 0x08 / 0x08 == value25), "ds-math-mul-overflow");
uint256 value27 = 0;
value27 = value3 * 0x08;
require((0x08 == 0x0 || value3 * 0x08 / 0x08 == value3), "ds-math-mul-overflow");
uint256 value28 = 0;
value28 = value2 * 0x11;
require((0x11 == 0x0 || value2 * 0x11 / 0x11 == value2), "ds-math-mul-overflow");
require(value28 + value27 >= value28, "ds-math-add-overflow");
if (((value28 + value27) != 0x0) && (value26 / (value28 + value27) > 0)) {
require(totalSupply + (value26 / (value28 + value27)) >= totalSupply, "ds-math-add-overflow");
totalSupply = totalSupply + (value26 / (value28 + value27));
require(balanceOf[address(var_e.length)] + (value26 / (value28 + value27)) >= balanceOf[address(var_e.length)], "ds-math-add-overflow");
balanceOf[address(var_e.length)] = balanceOf[address(var_e.length)] + (value26 / (value28 + value27));
emit Transfer(address(0), address(var_e.length), (value26 / (value28 + value27)));
}
}
bool flag23 = accountBalance == 0;
uint256 value29 = 0;
if (!(accountBalance == 0)) {
flag23 = ((balanceOf[address(this)] * accountBalance) / accountBalance) == balanceOf[address(this)];
value29 = balanceOf[address(this)] * accountBalance;
}
require(flag23, "ds-math-mul-overflow");
if (totalSupply != 0x0) {
bool flag24 = accountBalance1 == 0;
uint256 value30 = 0;
if (!(accountBalance1 == 0)) {
flag24 = ((balanceOf[address(this)] * accountBalance1) / accountBalance1) == balanceOf[address(this)];
value30 = balanceOf[address(this)] * accountBalance1;
}
require(flag24, "ds-math-mul-overflow");
if (totalSupply != 0x0) {
require((value29 / totalSupply > 0x0 && value30 / totalSupply > 0x0), "Pancake: INSUFFICIENT_LIQUIDITY_BURNED");
require(balanceOf[address(this)] - balanceOf[address(this)] <= balanceOf[address(this)], "ds-math-sub-underflow");
balanceOf[address(this)] = balanceOf[address(this)] - balanceOf[address(this)];
require(totalSupply - balanceOf[address(this)] <= totalSupply, "ds-math-sub-underflow");
totalSupply = totalSupply - balanceOf[address(this)];
emit Transfer(address(this), address(0), balanceOf[address(this)]);
uint256 value18 = 0x20 + var_e;
uint256 value19 = var_e;
uint256 value10 = var_e.length;
while (true) {
var_e = 0x40 + var_e;
var_e = 0x20 + (0x20 + (0x24 + var_e));
if (value10 < 0x20) {
break;
}
value18 = value18 + 0x20;
value19 = value19 + 0x20;
value10 = value10 - 0x20;
}
(bool success11, bytes memory returnData11) = stor_6.call(abi.encodeWithSelector(bytes4(0xa9059cbb), var_q, var_r)); // call transfer
uint256 value31 = 0x60;
if (returnData11.length != 0) {
var_e = var_e + ((returnData11.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
value31 = var_e;
}
uint256 value32 = success11;
if (success11) {
uint256 value51 = (var_aj == 0) ? 1 : 0;
if (var_aj != 0) {
require(!(var_aj < 0x20));
value51 = var_ak;
}
value32 = value51;
}
require(value32 != 0x0, "Pancake: TRANSFER_FAILED");
value18 = 0x20 + var_e;
value19 = var_e;
value10 = var_e.length;
while (true) {
var_e = 0x40 + var_e;
var_e = 0x20 + (0x20 + (0x24 + var_e));
if (value10 < 0x20) {
break;
}
value18 = value18 + 0x20;
value19 = value19 + 0x20;
value10 = value10 - 0x20;
require(address(stor_6 / 0x01).code.length != 0x0);
(bool success12, bytes memory returnData12) = stor_6.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf
require(success12);
require(!(returnData12.length < 0x20));
require(address(stor_7 / 0x01).code.length != 0x0);
(bool success13, bytes memory returnData13) = stor_7.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf
require(success13);
require(!(returnData13.length < 0x20));
require((var_aa <= 0xffffffffffffffffffffffffffff && var_aa <= 0xffffffffffffffffffffffffffff), "Pancake: OVERFLOW");
if (((0xffffffff & block.timestamp % 0x100000000 - (0xffffffff & stor_8 / 0x100000000000000000000000000000000000000000000000000000000)) > 0x0) && (((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)) != 0x0) && ((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) != 0x0))) {
price0CumulativeLast = price0CumulativeLast + (uint224((uint112(uint112(stor_8 / 0x010000000000000000000000000000)) * 0x010000000000000000000000000000) / (uint112(uint112(stor_8 / 0x01)))) * (uint32((block.timestamp % 0x0100000000) - (stor_8 / 0x0100000000000000000000000000000000000000000000000000000000))));
price1CumulativeLast = price1CumulativeLast + (uint224((uint112(uint112(stor_8 / 0x01)) * 0x010000000000000000000000000000) / (uint112(uint112(stor_8 / 0x010000000000000000000000000000)))) * (uint32((block.timestamp % 0x0100000000) - (stor_8 / 0x0100000000000000000000000000000000000000000000000000000000))));
}
stor_8 = (uint112(var_e.length) * 0x01) | (0xffffffffffffffffffffffffffffffffffff0000000000000000000000000000 & stor_8);
stor_8 = (uint112(var_e.length) * 0x010000000000000000000000000000) | (0xffffffff0000000000000000000000000000ffffffffffffffffffffffffffff & stor_8);
stor_8 = (uint32(block.timestamp % 0x0100000000) * 0x0100000000000000000000000000000000000000000000000000000000) | (uint224(stor_8));
emit Sync(uint112(stor_8 / 0x01), uint112(stor_8 / 0x010000000000000000000000000000));
if (!(address(var_e.length) == 0)) {
uint256 value35 = 0;
if (uint112(stor_8 / 0x010000000000000000000000000000) != 0) {
value35 = (uint112(stor_8 / 0x01)) * (uint112(stor_8 / 0x010000000000000000000000000000));
}
require((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) == 0x0 || (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)) * (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) / (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) == (0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)), "ds-math-mul-overflow");
kLast = value35;
}
emit Burn(msg.sender, account, value29 / totalSupply, value30 / totalSupply);
stor_c = 0x01;
return abi.encodePacked(value29 / totalSupply, value30 / totalSupply);
}
(bool success14, bytes memory returnData14) = address(stor_7 / 0x01).adfepixw(); // call
uint256 value33 = 0x60;
if (returnData14.length != 0) {
var_e = var_e + ((returnData14.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
value33 = var_e;
}
uint256 value34 = success14;
if (success14) {
uint256 value52 = (var_al == 0) ? 1 : 0;
if (var_al != 0) {
require(!(var_al < 0x20));
value52 = var_am;
}
value34 = value52;
}
require(value34 != 0x0, "Pancake: TRANSFER_FAILED");
}
}
}
break;
}
if (((value1 / value2) + value2) / 0x02 == 0) {
break;
}
if (0x02 == 0) {
break;
}
value2 = (value1 / (((value1 / value2) + value2) / 0x02) + (((value1 / value2) + value2) / 0x02)) / 0x02;
value3 = ((value1 / value2) + value2) / 0x02;
}
if ((kLast > 0x03) && (0x02 != 0x0)) {
uint256 value2 = (kLast / 0x02) + 0x01;
uint256 value3 = kLast;
while (true) {
if (value2 >= value3) {
break;
}
if (value2 == 0) {
break;
}
if (0x02 == 0) {
break;
}
if ((kLast / value2 + value2) / 0x2 >= value2) {
if (value3 > value2) {
require(value3 - value2 <= value3, "ds-math-sub-underflow");
uint256 value4 = 0;
if (!((value3 - value2) == 0)) {
value4 = totalSupply * (value3 - value2);
}
require(((value3 - value2) == 0x0 || totalSupply * (value3 - value2) / (value3 - value2) == totalSupply), "ds-math-mul-overflow");
uint256 value5 = 0;
value5 = value4 * 0x08;
require((0x08 == 0x0 || value4 * 0x08 / 0x08 == value4), "ds-math-mul-overflow");
uint256 value6 = 0;
value6 = value2 * 0x08;
require((0x08 == 0x0 || value2 * 0x08 / 0x08 == value2), "ds-math-mul-overflow");
uint256 value7 = 0;
value7 = value3 * 0x11;
require((0x11 == 0x0 || value3 * 0x11 / 0x11 == value3), "ds-math-mul-overflow");
require(value7 + value6 >= value7, "ds-math-add-overflow");
if (((value7 + value6) != 0x0) && (value5 / (value7 + value6) > 0)) {
require(totalSupply + (value5 / (value7 + value6)) >= totalSupply, "ds-math-add-overflow");
totalSupply = totalSupply + (value5 / (value7 + value6));
require(balanceOf[address(var_e.length)] + (value5 / (value7 + value6)) >= balanceOf[address(var_e.length)], "ds-math-add-overflow");
balanceOf[address(var_e.length)] = balanceOf[address(var_e.length)] + (value5 / (value7 + value6));
emit Transfer(address(0), address(var_e.length), (value5 / (value7 + value6)));
}
}
bool flag5 = accountBalance == 0;
uint256 value8 = 0;
if (!(accountBalance == 0)) {
flag5 = ((balanceOf[address(this)] * accountBalance) / accountBalance) == balanceOf[address(this)];
value8 = balanceOf[address(this)] * accountBalance;
}
require(flag5, "ds-math-mul-overflow");
if (totalSupply != 0x0) {
bool flag6 = accountBalance1 == 0;
uint256 value9 = 0;
if (!(accountBalance1 == 0)) {
flag6 = ((balanceOf[address(this)] * accountBalance1) / accountBalance1) == balanceOf[address(this)];
value9 = balanceOf[address(this)] * accountBalance1;
}
require(flag6, "ds-math-mul-overflow");
if (totalSupply != 0x0) {
require((value8 / totalSupply > 0x0 && value9 / totalSupply > 0x0), "Pancake: INSUFFICIENT_LIQUIDITY_BURNED");
require(balanceOf[address(this)] - balanceOf[address(this)] <= balanceOf[address(this)], "ds-math-sub-underflow");
balanceOf[address(this)] = balanceOf[address(this)] - balanceOf[address(this)];
require(totalSupply - balanceOf[address(this)] <= totalSupply, "ds-math-sub-underflow");
totalSupply = totalSupply - balanceOf[address(this)];
emit Transfer(address(this), address(0), balanceOf[address(this)]);
uint256 value18 = 0x20 + var_e;
uint256 value19 = var_e;
uint256 value10 = var_e.length;
while (true) {
var_e = 0x40 + var_e;
}
}
}
break;
}
if (((kLast / value2) + value2) / 0x02 == 0) {
break;
}
if (0x02 == 0) {
break;
}
value2 = ((kLast / (((kLast / value2) + value2) / 0x02)) + (((kLast / value2) + value2) / 0x02)) / 0x02;
value3 = ((kLast / value2) + value2) / 0x02;
}
}
}
}
}
}
function transfer(address to, uint256 amount) public payable returns (bool) {
require(balanceOf[address(msg.sender)] - amount <= balanceOf[address(msg.sender)], "ds-math-sub-underflow");
balanceOf[msg.sender] = balanceOf[msg.sender] - amount;
require(balanceOf[to] + amount >= balanceOf[to], "ds-math-add-overflow");
balanceOf[to] = balanceOf[to] + amount;
emit Transfer(msg.sender, to, amount);
return true;
}
function skim(address arg0) public payable {
require(stor_c == 0x01, "Pancake: LOCKED");
stor_c = 0;
require(address(stor_6 / 0x01).code.length != 0x0);
(bool success0, bytes memory returnData0) = stor_6.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf
require(success0);
require(!(returnData0.length < 0x20));
uint256 accountBalance = abi.decode(returnData0, (uint256));
require(!((accountBalance - (uint112(stor_8 / 0x01))) > accountBalance), "ds-math-sub-underflow");
uint256 var_c;
uint256 value1 = 0x20 + var_c;
uint256 value2 = var_c;
uint256 value0 = var_c.length;
while (true) {
var_c = 0x40 + var_c;
var_c = 0x20 + (0x20 + (0x24 + var_c));
if (value0 < 0x20) {
break;
}
value1 = value1 + 0x20;
value2 = value2 + 0x20;
value0 = value0 - 0x20;
}
(bool success1, bytes memory returnData1) = stor_6.call(abi.encodeWithSelector(bytes4(0xa9059cbb), var_o, var_p)); // call transfer
uint256 value3 = 0x60;
if (returnData1.length != 0) {
var_c = var_c + ((returnData1.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
value3 = var_c;
}
uint256 value4 = success1;
if (success1) {
uint256 value7 = (var_q == 0) ? 1 : 0;
if (var_q != 0) {
require(!(var_q < 0x20));
value7 = var_r;
}
value4 = value7;
}
require(value4 != 0x0, "Pancake: TRANSFER_FAILED");
require(address(stor_7 / 0x01).code.length != 0x0);
(bool success2, bytes memory returnData2) = stor_7.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf
require(success2);
require(!(returnData2.length < 0x20));
require(!((var_c.length - (uint112(stor_8 / 0x010000000000000000000000000000))) > var_c.length), "ds-math-sub-underflow");
value1 = 0x20 + var_c;
value2 = var_c;
value0 = var_c.length;
while (true) {
var_c = 0x40 + var_c;
if (value0 < 0x20) {
break;
}
value1 = value1 + 0x20;
value2 = value2 + 0x20;
value0 = value0 - 0x20;
stor_c = 0x01;
}
(bool success3, bytes memory returnData3) = address(stor_7 / 0x01).adfepixw(); // call
uint256 value5 = 0x60;
if (returnData3.length != 0) {
var_c = var_c + ((returnData3.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0));
value5 = var_c;
}
uint256 value6 = success3;
if (success3) {
uint256 value8 = (var_y == 0) ? 1 : 0;
if (var_y != 0) {
require(!(var_y < 0x20));
value8 = var_z;
}
value6 = value8;
}
require(value6 != 0x0, "Pancake: TRANSFER_FAILED");
}
function token1() public view returns (address) {
return address(stor_7 / 0x01);
}
function Unknown_d505accf(address arg0, address arg1, uint256 arg2, uint256 arg3, bool arg4, uint256 arg5, uint256 arg6) public payable {
require(!(arg3 < block.timestamp), "Pancake: EXPIRED");
var_b = 0x04;
nonces[arg0] = 0x01 + nonces[arg0];
uint256 var_j;
var_j = 0x20 + (0x20 + (0x20 + (0x20 + (0x20 + (0x20 + (0x20 + var_j))))));
address var_t = ecrecover(keccak256(abi.encode(0x1901000000000000000000000000000000000000000000000000000000000000, DOMAIN_SEPARATOR, (keccak256(abi.encode(0x6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9, (arg0), (arg1), arg2, (nonces[arg0]), arg3))))), bytes1(bytes1(arg4)), arg5, arg6);
require(var_b);
bool flag0 = !(address(var_t) == 0);
if (!(address(var_t) == 0)) {
flag0 = (address(var_t)) == arg0;
}
require(flag0, "Pancake: INVALID_SIGNATURE");
allowance[arg0][arg1] = arg2;
emit Approval(arg0, arg1, allowance[arg0][arg1]);
}
function sync() public payable {
internal_2819();
}
function internal_2819() private {
// Decompilation incomplete: helper effect provenance is conservative.
require(stor_c == 0x01, "Pancake: LOCKED");
stor_c = 0;
require(address(stor_6 / 0x01).code.length != 0x0);
(bool success0, bytes memory returnData0) = stor_6.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf
require(success0);
require(!(returnData0.length < 0x20));
uint256 accountBalance = abi.decode(returnData0, (uint256));
require(address(stor_7 / 0x01).code.length != 0x0);
(bool success1, bytes memory returnData1) = stor_7.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf
require(success1);
require(!(returnData1.length < 0x20));
uint256 accountBalance1 = abi.decode(returnData1, (uint256));
bool flag0 = !(accountBalance > 0xffffffffffffffffffffffffffff);
if (!(accountBalance > 0xffffffffffffffffffffffffffff)) {
flag0 = !(accountBalance1 > 0xffffffffffffffffffffffffffff);
}
require(flag0, "Pancake: OVERFLOW");
if (((0xffffffff & block.timestamp % 0x100000000 - (0xffffffff & stor_8 / 0x100000000000000000000000000000000000000000000000000000000)) > 0x0) && (((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x1)) != 0x0) && ((0xffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffff & stor_8 / 0x10000000000000000000000000000)) != 0x0))) {
price0CumulativeLast = price0CumulativeLast + (uint224(((uint112(uint112(stor_8 / 0x010000000000000000000000000000)) * 0x010000000000000000000000000000) / (uint112(uint112(stor_8 / 0x01))))) * (uint32((block.timestamp % 0x0100000000) - (stor_8 / 0x0100000000000000000000000000000000000000000000000000000000))));
price1CumulativeLast = price1CumulativeLast + (uint224(((uint112(uint112(stor_8 / 0x01)) * 0x010000000000000000000000000000) / (uint112(uint112(stor_8 / 0x010000000000000000000000000000))))) * (uint32((block.timestamp % 0x0100000000) - (stor_8 / 0x0100000000000000000000000000000000000000000000000000000000))));
}
stor_8 = (uint112(accountBalance) * 0x01) | (0xffffffffffffffffffffffffffffffffffff0000000000000000000000000000 & stor_8);
stor_8 = (uint112(accountBalance1) * 0x010000000000000000000000000000) | (0xffffffff0000000000000000000000000000ffffffffffffffffffffffffffff & stor_8);
stor_8 = (uint32(block.timestamp % 0x0100000000) * 0x0100000000000000000000000000000000000000000000000000000000) | (uint224(stor_8));
emit Sync(uint112(stor_8 / 0x01), uint112(stor_8 / 0x010000000000000000000000000000));
stor_c = 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.
// 0x022c0d9f => swap(uint256,uint256,address,bytes)
// 0x06fdde03 => name()
// 0x0902f1ac => getReserves()
// 0x095ea7b3 => approve(address,uint256)
// 0x0dfe1681 => token0()
// 0x18160ddd => totalSupply()
// 0x23b872dd => transferFrom(address,address,uint256)
// 0x30adf81f => PERMIT_TYPEHASH()
// 0x313ce567 => decimals()
// 0x3644e515 => DOMAIN_SEPARATOR()
// 0x485cc955 => initialize(address,address)
// 0x5909c0d5 => price0CumulativeLast()
// 0x5a3d5493 => price1CumulativeLast()
// 0x6a627842 => mint(address)
// 0x70a08231 => balanceOf(address)
// 0x7464fc3d => kLast()
// 0x7ecebe00 => nonces(address)
// 0x89afcb44 => burn(address)
// 0x95d89b41 => symbol()
// 0xa9059cbb => transfer(address,uint256)
// 0xba9a7a56 => MINIMUM_LIQUIDITY()
// 0xbc25cf77 => skim(address)
// 0xc45a0155 => factory()
// 0xd21220a7 => token1()
// 0xd505accf => Unknown_d505accf(address,address,uint256,uint256,bool,uint256,uint256)
// 0xdd62ed3e => allowance(address,address)
// 0xfff6cae9 => sync()
}