BNB Chain
0xab21d6291f4635917945b0cf3b50c1c2dc3266ab
Decompiled Solidity recovered from this contract's runtime bytecode. Best-effort reconstruction — confirm behaviour against on-chain state.
Decompilation outputBNB Chain · 0xab21d629…dc3266ab23.4 KB201.1 s
This result is permanently available athttps://decompiler.exvul.com/bsc/0xab21d6291f4635917945b0cf3b50c1c2dc3266ab
4,866 lines · Click a variable or keyword to highlight its references · Click a line number to copy its link; Shift-click to copy a block link
//decompiled by exvvul decompiler tool [email protected] https://x.com/exvulsec// Decompilation incomplete: symbolic execution reached a configured deadline for 4 of 136 entry points (170000 ms contract budget): 26c7f77c, 3b304147, 4d474898, 79e186cd// SPDX-License-Identifier: MITpragma solidity >=0.8.0;contract DesolexContract { uint256 public constant PHASE_COUNT = 11; uint256 public constant unresolved_fdaf00e5 = 20; uint256 public constant MAX_BITS = 56; uint256 public constant unresolved_e6d23cf1 = 10000000; uint256 public constant OK = 0; uint256 public constant PAID_LIMIT = 4; uint256 public constant unresolved_d3ce95d8 = 4; uint256 public constant HISTORY = 21693734551179282564423033930679318143314229; uint256 public constant REVEAL_DELAY = 4; uint256 public constant SRC_CHAINLINK = 1; uint256 public constant NOT_OPEN = 1; uint256 public constant MAX_PRICE_AGE = 3600; uint256 public constant FREE_SUPPLY = 4000; uint256 public constant unresolved_97da4529 = 18; uint256 public constant unresolved_54ce9898 = 3; uint256 public constant FREE_LIMIT = 3; address public constant unresolved_8416e03b = address(0x16b9a82891338f9ba80e2d6970fdda79d1eb0dae); uint256 public constant TARGET_GRACE = 90; uint256 public constant USD_DECIMALS = 8; uint256 public constant unresolved_74d30167 = 8; uint256 public constant SOLD_OUT = 2; uint256 public constant unresolved_73efd92c = 2; uint256 public constant unresolved_6fb0e8ed = 5; uint256 public constant FEED_DECIMALS = 8; uint256 public constant PROVENANCE = 7958815924252034840349971078297197811235559079633405020787420119684343173244; uint256 public constant REWARD_DURATION = 86400; uint256 public constant AUTO_REVEAL = 5; uint256 public constant PHASE1_END = 500; uint256 public constant HISTORY_WINDOW = 8191; uint256 public constant REWARD_BPS = 1000; uint256 public constant MAX_PAID_PER_TX = 20; uint256 public constant MAX_ROYALTY_BPS = 1000; uint256 public constant PRICE_TIER_SIZE = 1000; uint256 public constant MAX_SUPPLY = 10000; address public constant PRICE_FEED = address(0x567f2323251f0aab15c8dfb1967e4e8a7d42aee); bool public constant unresolved_14ff92fb = false; uint256 public constant MAX_PER_BLOCK = 10; uint256 public constant unresolved_0cb7528a = 10; uint256 public constant unresolved_09d16642 = 3; uint256 public constant unresolved_06dae220 = 18; string _name; // STORAGE[0x0] string _symbol; // STORAGE[0x1] mapping(uint256 => address) public ownerOf; // STORAGE[0x2] mapping(address => uint256) public balanceOf; // STORAGE[0x3] mapping(uint256 => address) public getApproved; // STORAGE[0x4] mapping(address => mapping(address => bool)) mapping_5; // STORAGE[0x5] address stor_6; // STORAGE[0x6] mapping(uint256 => address) mapping_7; // STORAGE[0x7] address public owner; // STORAGE[0x8] bytes 0 to 19 bool public miningOpen; // STORAGE[0x8] bytes 20 to 20 bool public metadataFrozen; // STORAGE[0x8] bytes 21 to 21 uint256 public launchSeed; // STORAGE[0x9] uint256 stor_a; // STORAGE[0xa] uint256 stor_b; // STORAGE[0xb] uint256 public freeUsed; // STORAGE[0xc] uint256 public lastGoodPrice; // STORAGE[0xd] uint256 stor_e; // STORAGE[0xe] uint256 stor_f; // STORAGE[0xf] uint256 public mintBlock; // STORAGE[0x10] uint256 public unresolved_4ec5df4f; // STORAGE[0x11] uint256 stor_12; // STORAGE[0x12] uint256 public unresolved_7c3f33d6; // STORAGE[0x13] uint256 public unresolved_e4441769; // STORAGE[0x14] bool stor_15_0_0; // STORAGE[0x15] bytes 0 to 0 address public agentRegistry; // STORAGE[0x15] bytes 1 to 20 bool stor_15_21_21; // STORAGE[0x15] bytes 21 to 21 address public marketplace; // STORAGE[0x16] mapping(address => bool) public unresolved_50cd382e; // STORAGE[0x17] bool stor_18; // STORAGE[0x18] mapping(uint256 => bool) public unresolved_64c37584; // STORAGE[0x19] uint256 stor_1a; // STORAGE[0x1a] uint256 public unresolved_31698b91; // STORAGE[0x1b] bool stor_1c; // STORAGE[0x1c] uint256 public rewardAccrued; // STORAGE[0x1d] uint256 public rewardClaimedTotal; // STORAGE[0x1e] address public unresolved_7baa1165; // STORAGE[0x1f] address public unresolved_b79b1d35; // STORAGE[0x20] uint256 public devReleased; // STORAGE[0x21] uint256 public unresolved_b1e8557c; // STORAGE[0x22] mapping(uint256 => uint256) public rewardClaimed; // STORAGE[0x23] mapping(uint256 => address) mapping_24; // STORAGE[0x24] mapping(uint256 => bool) mapping_25; // STORAGE[0x25] mapping(uint256 => address) mapping_26; // STORAGE[0x26] mapping(address => uint256) public minedBy; // STORAGE[0x27] mapping(address => bytes) public walletStats; // STORAGE[0x28] mapping(address => uint256) public unresolved_337900e0; // STORAGE[0x29] mapping(uint256 => uint256) public seedOf; // STORAGE[0x30] mapping(uint256 => uint256) public workOf; // STORAGE[0x31] mapping(bytes32 => uint256) public unresolved_666abc16; // STORAGE[0x32] bytes32 stor_expr_bo; uint256 stor_expr_bp; bytes32 stor_expr_bv; bytes32 stor_expr_t; event MetadataFrozen(); error ERC721InvalidApprover(address); error ERC721InvalidOwner(address); event OwnershipTransferred(address indexed, address indexed); error BlockFull(); event MarketplaceSet(address); event Approval(address indexed, address indexed, uint256 indexed); error ERC721InvalidReceiver(address); error ERC721InvalidOperator(address); event Event_2086182e(uint256, uint256); error BadQuantity(); error NotAgentHolder(); error AlreadyOpen(); error RoyaltyTooHigh(); error ERC721IncorrectOwner(address, uint256, address); event Transfer(address indexed, address indexed, uint256 indexed); error MiningClosed(); error OwnableInvalidOwner(address); error CustomError_e150381c(); event AgentRegistrySet(address); error FrozenMetadata(); event Event_d94d502d(uint256 indexed, address indexed); error ERC721InsufficientApproval(address, uint256); error BadConfig(string); event Event_6a574931(); event Event_8e6a36ee(uint256, uint256); error NothingToClaim(); error CustomError_317cfc38(); event BaseURIChanged(string); error CustomError_472890de(); event ApprovalForAll(address indexed, address indexed, bool); error SoldOut(); error NotPayee(); event Event_e4f09f69(uint256, uint256, uint256); error OwnableUnauthorizedAccount(address); error ReentrancyGuardReentrantCall(); event RevenueReleased(address indexed, uint256); error ERC721NonexistentToken(uint256); error MarketplaceAlreadySet(); error ERC2981InvalidDefaultRoyalty(uint256, uint256); error ERC2981InvalidDefaultRoyaltyReceiver(address); event Event_7642a0bd(); function _desolexPanic(uint256 code) private pure { assembly ("memory-safe") { mstore(0x00, shl(224, 0x4e487b71)) mstore(0x04, code) revert(0x00, 0x24) } } modifier onlyOwner() { require(msg.sender == owner, OwnableUnauthorizedAccount()); _; } fallback() external payable { // Synthetic compatibility routes preserve original selectors for unresolved names. if ((msg.data.length >= 4) && (msg.sig == 0x01595fa6)) { // Route to Unknown_01595fa6() after replacing only msg.sig. __desolexSelectorShim(uint32(0x2f27ccd0)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x05c14577)) { // Route to Unknown_05c14577(uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0xd43d0067)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x0d84ed30)) { // Route to Unknown_0d84ed30(address) after replacing only msg.sig. __desolexSelectorShim(uint32(0x7bc4036a)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x26c7f77c)) { // Route to Unknown_26c7f77c(bool) after replacing only msg.sig. __desolexSelectorShim(uint32(0x8e7e4f23)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x329e4f4a)) { // Route to Unknown_329e4f4a() after replacing only msg.sig. __desolexSelectorShim(uint32(0x6c0976f8)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x458fb554)) { // Route to Unknown_458fb554(address,uint256,uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0xabf11ed0)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x7272ce26)) { // Route to Unknown_7272ce26() after replacing only msg.sig. __desolexSelectorShim(uint32(0x4b3e066a)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x82451915)) { // Route to Unknown_82451915(bytes32) after replacing only msg.sig. __desolexSelectorShim(uint32(0x9e546f1c)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x825c47f2)) { // Route to Unknown_825c47f2(uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0x04843e7e)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xa5c88017)) { // Route to Unknown_a5c88017(address) after replacing only msg.sig. __desolexSelectorShim(uint32(0x34642116)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xc941f055)) { // Route to Unknown_c941f055() after replacing only msg.sig. __desolexSelectorShim(uint32(0xefc1c2f8)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xcab4c53d)) { // Route to Unknown_cab4c53d() after replacing only msg.sig. __desolexSelectorShim(uint32(0x13b445d9)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xd59ac577)) { // Route to Unknown_d59ac577() after replacing only msg.sig. __desolexSelectorShim(uint32(0x48ffbdbb)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xd7c6a43a)) { // Route to Unknown_d7c6a43a() after replacing only msg.sig. __desolexSelectorShim(uint32(0x9b3ba571)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xeaa33ca7)) { // Route to Unknown_eaa33ca7(address) after replacing only msg.sig. __desolexSelectorShim(uint32(0x803e5ffa)); return; } revert(); } function releasable() public view returns (bytes memory) { uint256 value0 = 0; if ((((address(this).balance + devReleased) + unresolved_b1e8557c) + rewardClaimedTotal) > rewardAccrued) { value0 = (((address(this).balance + devReleased) + unresolved_b1e8557c) + rewardClaimedTotal) - rewardAccrued; } if (!(unresolved_b79b1d35)) { return abi.encodePacked((value0 - devReleased) - unresolved_b1e8557c, 0); } else { uint256 value1 = 0; if (0 != ((value0 >> 0x01) > unresolved_b1e8557c)) { value1 = (value0 >> 0x01) - unresolved_b1e8557c; } if (!((value0 - (value0 >> 0x01)) > devReleased)) { return abi.encodePacked(0, value1); } else { return abi.encodePacked((value0 - (value0 >> 0x01)) - devReleased, value1); } } } function transferOwnership(address newOwner) public onlyOwner { require(newOwner != address(0), OwnableInvalidOwner()); emit OwnershipTransferred(owner, newOwner); owner = newOwner; } function Unknown_eaa33ca7(address arg0) public view returns (uint256) { uint256 value0 = 0x01; if (!((stor_a + 0x01) <= 0x01f4)) { value0 = (0x02 + (((stor_a + 0x01) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } uint256 var_c; if (((var_c + 0x80) > 0xffffffffffffffff) | ((var_c + 0x80) < var_c)) _desolexPanic(65); var_c = var_c + 0x80; bool flag0 = !(!(uint16(var_c.length))); if (bytes1(value0) == 0x01) { flag0 = (value0 & 0xff) == 0x1; } if (((!flag0) && (0x3 <= (var_h & 0xffff))) || (flag0)) { return 0; } else { uint256 value1 = 0; uint256 value2 = 0; bool flag2 = !(bytes1(var_j) == (bytes1(value0))); if (!(bytes1(var_j))) { value1 = bytes1(var_j); value2 = bytes1(value0); flag2 = !(!(bytes1(var_j))); } if (flag2) { return 0; } else { return ((0x03 - (uint16(var_h))) ^ (0x0fa0 - freeUsed) * ((0x03 - (uint16(var_h))) < (0x0fa0 - freeUsed))) ^ (0x0fa0 - freeUsed); } } } function isApprovedForAll(address owner, address operator) public view returns (bool) { bool flag0 = !(!(operator)); if (operator != marketplace) { flag0 = operator == marketplace; } bool flag1 = !(unresolved_50cd382e[owner]); if (flag0) { } else { flag1 = flag0; } if (flag1) { return true; } else { return !(!(bytes1(mapping_5[owner][operator]))); } } function leadingZeroBits(uint256 arg0) public pure returns (uint256) { if (!(arg0)) { return 0x0100; } } function Unknown_d7c6a43a() public onlyOwner { stor_15_21_21 = true; emit Event_6a574931(); } function totalSupply() public view returns (uint256) { return stor_b; } function Unknown_d59ac577() public view returns (uint256) { return stor_b; } function freezeMetadata() public onlyOwner { metadataFrozen = true; emit MetadataFrozen(); } function rewardPerToken() public view returns (uint256) { if (!(stor_18)) { return 0; } return rewardAccrued / stor_18; } function Unknown_cab4c53d() public view returns (uint256) { uint256 value0 = 0x2710; if (stor_a < 0x2710) { value0 = stor_a + 0x01; } uint256 value1 = 0x01; if (!(value0 <= 0x01f4)) { value1 = (0x02 + ((value0 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } uint256 value2 = (bytes1(value1)) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if ((value1 & 0xff) != 0x0) { } else { value2 = 0; } if ((unresolved_7c3f33d6 + (value2 * unresolved_e4441769)) > 0x38) { return 0x38; } return unresolved_7c3f33d6 + (value2 * unresolved_e4441769); } function claimReward(uint256[] memory arg0) public payable { if (!(msg.value) && !((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20) && !(arg0.length > 0xffffffffffffffff) && (arg0 + 0x23) < msg.data.length && !(arg0.length > 0xffffffffffffffff) && !(((arg0 + (arg0.length << 0x05)) + 0x24) > msg.data.length) && stor_expr_t != 0x02) { stor_expr_t = 0x02; } } function Unknown_c941f055() public view returns (uint256) { return stor_1c; } function tokenURI(uint256 tokenId) public view returns (bytes memory) { uint256 var_a = tokenId; require(ownerOf[tokenId], ERC721NonexistentToken()); uint256 value0 = (0x7f) & (stor_12 >> 0x01); if (stor_12 & (0x01)) { value0 = stor_12 >> 0x01; } if (!((value0 < 0x20) != (stor_12 & 0x01))) _desolexPanic(34); uint256 var_c; if (value0 == 0) { if (((var_c + 0x20) > 0xffffffffffffffff) | ((var_c + 0x20) < var_c)) _desolexPanic(65); var_c = var_c + 0x20; return abi.encodePacked(0x20, var_c.length); } uint256 value1 = 0x0a; uint256 value2 = tokenId / 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000; uint256 value3 = 0x40; if (tokenId < 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000) { value1 = tokenId; value2 = tokenId; value3 = 0; } uint256 value4 = value2 / 0x04ee2d6d415b85acef8100000000; uint256 value5 = value3 + 0x20; if (value2 < 0x04ee2d6d415b85acef8100000000) { value4 = value2; value5 = value3; } uint256 value6 = value4 / 0x2386f26fc10000; uint256 value7 = value5 + 0x10; if (value4 < 0x2386f26fc10000) { value6 = value4; value7 = (value5) ? 1 : 0; } uint256 value8 = value6 / 0x05f5e100; uint256 value9 = value7 + 0x08; if (value6 < 0x05f5e100) { value8 = value6; value9 = value7; } uint256 value10 = value8 / 0x2710; uint256 value11 = value9 + 0x04; if (value8 < 0x2710) { value10 = value8; value11 = value9; } uint256 value12 = value10 / 0x64; uint256 value13 = value11 + 0x02; if (value10 < 0x64) { value12 = value10; value13 = value11; } uint256 value14 = 0x01 + value13; if (value12 < 0x0a) { value14 = value13; } if (!((value14 + 0x01) <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_c + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + (value14 + 0x01)))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + (value14 + 0x01)))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + (value14 + 0x01)))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); if (!((value14 + 0x01) <= 0xffffffffffffffff)) _desolexPanic(65); uint256 value15 = tokenId / 0x0a; uint256 value16 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + ((var_c + value14) + 0x21); while (true) { if (value15 == 0x0) { break; } value15 = value15 / 0x0a; value16 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value16; } uint256 value17 = (0x7f) & (stor_12 >> 0x01); if (stor_12 & (0x01)) { value17 = stor_12 >> 0x01; } if (!((value17 < 0x20) != (stor_12 & 0x01))) _desolexPanic(34); uint256 value20 = var_c; uint256 value21 = 0x20 + (var_c + (value17 * value17)); if (!(stor_12 & (0x01))) { } else { uint256 value22 = var_c; uint256 value23 = 0x20 + (var_c + value17); if (0x01 == (stor_12 & (0x01))) { uint256 value19 = var_a; uint256 value18 = 0; while (true) { if (value18 >= value17) { break; } value19 = value19 + 0x01; value18 = value18 + 0x20; } } else { value22 = value17; value23 = 0; } value20 = value22; value21 = value23; } if (((var_c + (((((value21 + var_c.length) - var_c) + 0x05) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + (((((value21 + var_c.length) - var_c) + 0x05) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + (((((value21 + var_c.length) - var_c) + 0x05) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); return abi.encodePacked(0x20, var_c.length); } function rewardEnd() public view returns (uint256) { if (stor_1a == 0) { return 0; } else { if (stor_1c != 0x0) { if (!(stor_1c > stor_1a)) { return stor_1a; } else { if (0x015180 != 0) { return stor_1a + ((!(!(stor_1c - stor_1a))) * ((((stor_1c - stor_1a) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x015180) + 0x01) * 0x015180); } return stor_1c; } } uint256 value0 = stor_1a; if (block.timestamp > stor_1a) { uint256 value1 = block.timestamp; value1 = stor_1a + ((!(!(block.timestamp - stor_1a))) * ((((block.timestamp - stor_1a) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x015180) + 0x01) * 0x015180); value0 = value1; } return value0; } } function rewardTokenIds() public view returns (bytes memory) { uint256 value0 = 0; uint256 value1 = 0xb13d2d76d1f4b7be834882e410b3e3a8afaf69f83600ae24db354391d2378d2e; uint256 var_a; uint256 value2 = var_a + 0x20; while (true) { if (value0 >= stor_18) { break; } value0 = 0x01 + value0; value1 = 0x01 + value1; value2 = value2 + 0x20; } if (((var_a + (((value2 - var_a) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + (((value2 - var_a) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); uint256 value3 = 0; uint256 value4 = var_a + 0x20; uint256 value5 = var_a + 0x40; while (true) { var_a = var_a + (((value2 - var_a) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); if (value3 >= var_a.length) { return abi.encodePacked(0x20, var_a.length); } value3 = 0x01 + value3; value4 = value4 + 0x20; value5 = 0x20 + value5; } } function safeTransferFrom(address _from, address to, uint256 tokenId, bytes memory _data) public { require((_data + 0x23) < msg.data.length); if (_data.length > 0xffffffffffffffff) _desolexPanic(65); uint256 var_a; if (((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + _data.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + _data.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + _data.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((_data + _data) + 0x24) <= msg.data.length); require(to != address(0), ERC721InvalidReceiver()); if (unresolved_64c37584[tokenId]) { if (ownerOf[tokenId] == address(0)) { unresolved_31698b91 = 0x01 + unresolved_31698b91; if (stor_18 != (0x01 + unresolved_31698b91)) { uint256 value69 = 0; if (msg.sender != address(0)) { uint256 value30; uint256 value29; if (!(ownerOf[tokenId] == msg.sender)) { bool flag21 = !(!(msg.sender)); if (!(msg.sender == marketplace)) { flag21 = (msg.sender) == marketplace; } bool flag22 = !(unresolved_50cd382e[ownerOf[tokenId]]); if (flag21) { } else { flag22 = flag21; } uint256 value57 = 0x01; if (!(flag22)) { value57 = bytes1(mapping_5[address(ownerOf[tokenId])][msg.sender]); } value29 = value57; } else { value29 = (ownerOf[tokenId] == msg.sender) ? 1 : 0; } uint256 value56 = value29; if (value29 == 0) { value56 = (msg.sender == getApproved[tokenId]) ? 1 : 0; } value30 = value56; if (value30 == 0x0) { require(ownerOf[tokenId] != address(0), ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } } else { flag23 = msg.sender != address(0); } if (ownerOf[tokenId] != address(0)) { getApproved[tokenId] = address(0); balanceOf[ownerOf[tokenId]] = balanceOf[ownerOf[tokenId]] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[to] = balanceOf[to] + 0x01; ownerOf[tokenId] = (ownerOf[tokenId] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | to; emit Transfer(ownerOf[tokenId], to, tokenId); require(ownerOf[tokenId] == _from, ERC721IncorrectOwner()); if (to.code.length != 0x0) { (bool success7, bytes memory returnData7) = to.onERC721Received(msg.sender, _from, tokenId, 0x80); // call if (success7) { uint256 value31 = returnData7.length; if (0x20 <= returnData7.length) { value31 = 0x20; } if (((var_a + ((value31 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value31 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value31 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); } else { if (!(success7)) { uint256 value32 = 0x60; if ((returnData7.length) != 0x0) { if (returnData7.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData7.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData7.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData7.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value32 = var_a; } require(var_x != 0x0, ERC721InvalidReceiver()); revert(); } require(!(0xeaf485fe00000000000000000000000000000000000000000000000000000000), ERC721InvalidReceiver()); } } } else { stor_1c = block.timestamp; uint256 value70 = 0; if (msg.sender != address(0)) { uint256 value34; uint256 value33; if (!(ownerOf[tokenId] == msg.sender)) { bool flag24 = !(!(msg.sender)); if (!(msg.sender == marketplace)) { flag24 = (msg.sender) == marketplace; } bool flag25 = !(unresolved_50cd382e[ownerOf[tokenId]]); if (flag24) { } else { flag25 = flag24; } uint256 value59 = 0x01; if (!(flag25)) { value59 = bytes1(mapping_5[address(ownerOf[tokenId])][msg.sender]); } value33 = value59; } else { value33 = (ownerOf[tokenId] == msg.sender) ? 1 : 0; } uint256 value58 = value33; if (value33 == 0) { value58 = (msg.sender == getApproved[tokenId]) ? 1 : 0; } value34 = value58; if (value34 == 0x0) { require(ownerOf[tokenId] != address(0), ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } } else { flag26 = msg.sender != address(0); } if (ownerOf[tokenId] != address(0)) { getApproved[tokenId] = address(0); balanceOf[ownerOf[tokenId]] = balanceOf[ownerOf[tokenId]] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[to] = balanceOf[to] + 0x01; ownerOf[tokenId] = (ownerOf[tokenId] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | to; emit Transfer(ownerOf[tokenId], to, tokenId); require(ownerOf[tokenId] == _from, ERC721IncorrectOwner()); if (to.code.length != 0x0) { (bool success8, bytes memory returnData8) = to.onERC721Received(msg.sender, _from, tokenId, 0x80); // call if (success8) { uint256 value35 = returnData8.length; if (0x20 <= returnData8.length) { value35 = 0x20; } if (((var_a + ((value35 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value35 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value35 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); } else { if (!(success8)) { uint256 value36 = 0x60; if ((returnData8.length) != 0x0) { if (returnData8.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData8.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData8.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData8.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value36 = var_a; } require(var_y != 0x0, ERC721InvalidReceiver()); revert(); } require(!(0xeaf485fe00000000000000000000000000000000000000000000000000000000), ERC721InvalidReceiver()); } } } } else if (mapping_25[tokenId]) { address account5 = address(0); account5 = ownerOf[tokenId]; uint256 value68 = 0; if (msg.sender != address(0)) { uint256 value26; uint256 value25; if (!(ownerOf[tokenId] == msg.sender)) { bool flag18 = !(!(msg.sender)); if (!(msg.sender == marketplace)) { flag18 = (msg.sender) == marketplace; } bool flag19 = !(unresolved_50cd382e[ownerOf[tokenId]]); if (flag18) { } else { flag19 = flag18; } uint256 value55 = 0x01; if (!(flag19)) { value55 = bytes1(mapping_5[address(ownerOf[tokenId])][msg.sender]); } value25 = value55; } else { value25 = (ownerOf[tokenId] == msg.sender) ? 1 : 0; } uint256 value54 = value25; if (value25 == 0) { value54 = (msg.sender == getApproved[tokenId]) ? 1 : 0; } value26 = value54; if (value26 == 0x0) { require(ownerOf[tokenId] != address(0), ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } } else { flag20 = msg.sender != address(0); } if (ownerOf[tokenId] != address(0)) { getApproved[tokenId] = address(0); balanceOf[ownerOf[tokenId]] = balanceOf[ownerOf[tokenId]] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[to] = balanceOf[to] + 0x01; ownerOf[tokenId] = (ownerOf[tokenId] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | to; emit Transfer(ownerOf[tokenId], to, tokenId); require(ownerOf[tokenId] == _from, ERC721IncorrectOwner()); if (to.code.length != 0x0) { (bool success6, bytes memory returnData6) = to.onERC721Received(msg.sender, _from, tokenId, 0x80); // call if (success6) { uint256 value27 = returnData6.length; if (0x20 <= returnData6.length) { value27 = 0x20; } if (((var_a + ((value27 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value27 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value27 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); } else { if (!(success6)) { uint256 value28 = 0x60; if ((returnData6.length) != 0x0) { if (returnData6.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData6.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData6.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData6.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value28 = var_a; } require(var_v != 0x0, ERC721InvalidReceiver()); revert(); } require(!(0xeaf485fe00000000000000000000000000000000000000000000000000000000), ERC721InvalidReceiver()); } } } else { if (stor_1c) { if (stor_1a == 0) { address account0 = address(0); if (!(block.timestamp < 0)) { mapping_25[tokenId] = true; mapping_24[tokenId] = (ownerOf[tokenId] & (0xffffffffffffffffffffffffffffffffffffffff)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & mapping_24[tokenId]); emit Event_d94d502d(tokenId, ownerOf[tokenId]); } else { account0 = ownerOf[tokenId]; } uint256 value62 = 0; if (msg.sender != address(0)) { uint256 value1; uint256 value0; if (!(ownerOf[tokenId] == msg.sender)) { bool flag0 = !(!(msg.sender)); if (!(msg.sender == marketplace)) { flag0 = (msg.sender) == marketplace; } bool flag1 = !(unresolved_50cd382e[ownerOf[tokenId]]); if (flag0) { } else { flag1 = flag0; } uint256 value42 = 0x01; if (!(flag1)) { value42 = bytes1(mapping_5[address(ownerOf[tokenId])][msg.sender]); } value0 = value42; } else { value0 = (ownerOf[tokenId] == msg.sender) ? 1 : 0; } uint256 value41 = value0; if (value0 == 0) { value41 = (msg.sender == getApproved[tokenId]) ? 1 : 0; } value1 = value41; if (value1 == 0x0) { require(ownerOf[tokenId] != address(0), ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } } else { flag2 = msg.sender != address(0); } if (ownerOf[tokenId] != address(0)) { getApproved[tokenId] = address(0); balanceOf[ownerOf[tokenId]] = balanceOf[ownerOf[tokenId]] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[to] = balanceOf[to] + 0x01; ownerOf[tokenId] = (ownerOf[tokenId] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | to; emit Transfer(ownerOf[tokenId], to, tokenId); require(ownerOf[tokenId] == _from, ERC721IncorrectOwner()); if (to.code.length != 0x0) { (bool success0, bytes memory returnData0) = to.onERC721Received(msg.sender, _from, tokenId, 0x80); // call if (success0) { uint256 value2 = returnData0.length; if (0x20 <= returnData0.length) { value2 = 0x20; } if (((var_a + ((value2 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value2 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value2 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); } else { if (!(success0)) { uint256 value3 = 0x60; if ((returnData0.length) != 0x0) { if (returnData0.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value3 = var_a; } require(var_p != 0x0, ERC721InvalidReceiver()); revert(); } require(!(0xeaf485fe00000000000000000000000000000000000000000000000000000000), ERC721InvalidReceiver()); } } } else { if (!stor_1c) { uint256 value4 = stor_1a; if (!(block.timestamp <= stor_1a)) { uint256 value43 = block.timestamp; value43 = stor_1a + ((!(!(block.timestamp - stor_1a))) * ((((block.timestamp - stor_1a) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x015180) + 0x01) * 0x015180); value4 = value43; } if (!(block.timestamp < value4)) { mapping_25[tokenId] = true; mapping_24[tokenId] = (ownerOf[tokenId] & (0xffffffffffffffffffffffffffffffffffffffff)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & mapping_24[tokenId]); emit Event_d94d502d(tokenId, ownerOf[tokenId]); } uint256 value63 = 0; if (msg.sender != address(0)) { uint256 value6; uint256 value5; if (!(ownerOf[tokenId] == msg.sender)) { bool flag3 = !(!(msg.sender)); if (!(msg.sender == marketplace)) { flag3 = (msg.sender) == marketplace; } bool flag4 = !(unresolved_50cd382e[ownerOf[tokenId]]); if (flag3) { } else { flag4 = flag3; } uint256 value45 = 0x01; if (!(flag4)) { value45 = bytes1(mapping_5[address(ownerOf[tokenId])][msg.sender]); } value5 = value45; } else { value5 = (ownerOf[tokenId] == msg.sender) ? 1 : 0; } uint256 value44 = (value5) ? 1 : 0; if (!(value5)) { value44 = (msg.sender == getApproved[tokenId]) ? 1 : 0; } value6 = value44; if (value6 == 0x0) { require(ownerOf[tokenId] != address(0), ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } } else { flag5 = msg.sender != address(0); } if (ownerOf[tokenId] != address(0)) { getApproved[tokenId] = address(0); balanceOf[ownerOf[tokenId]] = balanceOf[ownerOf[tokenId]] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[to] = balanceOf[to] + 0x01; ownerOf[tokenId] = (ownerOf[tokenId] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | to; emit Transfer(ownerOf[tokenId], to, tokenId); require(ownerOf[tokenId] == _from, ERC721IncorrectOwner()); if (to.code.length != 0x0) { (bool success1, bytes memory returnData1) = to.onERC721Received(msg.sender, _from, tokenId, 0x80); // call if (success1) { uint256 value7 = returnData1.length; if (0x20 <= returnData1.length) { value7 = 0x20; } if (((var_a + ((value2 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value2 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); } else { if (!(success1)) { uint256 value8 = 0x60; if (returnData1.length != 0x0) { if (returnData1.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData1.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData1.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData1.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value8 = var_a; } require(var_q != 0x0, ERC721InvalidReceiver()); revert(); } require(!(0xeaf485fe00000000000000000000000000000000000000000000000000000000), ERC721InvalidReceiver()); } } } else { if (!(stor_1c > stor_1a)) { address account1 = address(0); if (!(block.timestamp < stor_1a)) { mapping_25[tokenId] = true; mapping_24[tokenId] = (ownerOf[tokenId] & (0xffffffffffffffffffffffffffffffffffffffff)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & mapping_24[tokenId]); emit Event_d94d502d(tokenId, ownerOf[tokenId]); } else { account1 = ownerOf[tokenId]; } uint256 value64 = 0; if (msg.sender != address(0)) { uint256 value10; uint256 value9; if (!(ownerOf[tokenId] == msg.sender)) { bool flag6 = !(!(msg.sender)); if (!(msg.sender == marketplace)) { flag6 = (msg.sender) == marketplace; } bool flag7 = !(unresolved_50cd382e[ownerOf[tokenId]]); if (flag6) { } else { flag7 = flag6; } uint256 value47 = 0x01; if (!(flag7)) { value47 = bytes1(mapping_5[address(ownerOf[tokenId])][msg.sender]); } value9 = value47; } else { value9 = (ownerOf[tokenId] == msg.sender) ? 1 : 0; } uint256 value46 = value9; if (value9 == 0) { value46 = (msg.sender == getApproved[tokenId]) ? 1 : 0; } value10 = value46; if (value10 == 0x0) { require(ownerOf[tokenId] != address(0), ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } } else { flag8 = msg.sender != address(0); } if (ownerOf[tokenId] != address(0)) { getApproved[tokenId] = address(0); balanceOf[ownerOf[tokenId]] = balanceOf[ownerOf[tokenId]] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[to] = balanceOf[to] + 0x01; ownerOf[tokenId] = (ownerOf[tokenId] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | to; emit Transfer(ownerOf[tokenId], to, tokenId); require(ownerOf[tokenId] == _from, ERC721IncorrectOwner()); if (to.code.length != 0x0) { (bool success2, bytes memory returnData2) = to.onERC721Received(msg.sender, _from, tokenId, 0x80); // call if (success2) { uint256 value11 = returnData2.length; if (0x20 <= returnData2.length) { value11 = 0x20; } if (((var_a + ((value11 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value11 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value11 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); } else { if (!(success2)) { uint256 value12 = 0x60; if ((returnData2.length) != 0x0) { if (returnData2.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData2.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData2.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData2.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value12 = var_a; } require(var_r != 0x0, ERC721InvalidReceiver()); revert(); } require(!(0xeaf485fe00000000000000000000000000000000000000000000000000000000), ERC721InvalidReceiver()); } } } else { address account3 = address(0); if (!(block.timestamp < (stor_1a + ((!(!(stor_1c - stor_1a))) * ((((stor_1c - stor_1a) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x015180) + 0x01) * 0x015180)))) { mapping_25[tokenId] = true; mapping_24[tokenId] = (ownerOf[tokenId] & (0xffffffffffffffffffffffffffffffffffffffff)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & mapping_24[tokenId]); emit Event_d94d502d(tokenId, ownerOf[tokenId]); } else { account3 = ownerOf[tokenId]; } uint256 value66 = 0; if (msg.sender != address(0)) { uint256 value18; uint256 value17; if (!(ownerOf[tokenId] == msg.sender)) { bool flag12 = !(!(msg.sender)); if (!(msg.sender == marketplace)) { flag12 = (msg.sender) == marketplace; } bool flag13 = !(unresolved_50cd382e[ownerOf[tokenId]]); if (flag12) { } else { flag13 = flag12; } uint256 value51 = 0x01; if (!(flag13)) { value51 = bytes1(mapping_5[address(ownerOf[tokenId])][msg.sender]); } value17 = value51; } else { value17 = (ownerOf[tokenId] == msg.sender) ? 1 : 0; } uint256 value50 = value17; if (value17 == 0) { value50 = (msg.sender == getApproved[tokenId]) ? 1 : 0; } value18 = value50; if (value18 == 0x0) { require(ownerOf[tokenId] != address(0), ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } } else { flag14 = msg.sender != address(0); } if (ownerOf[tokenId] != address(0)) { getApproved[tokenId] = address(0); balanceOf[ownerOf[tokenId]] = balanceOf[ownerOf[tokenId]] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[to] = balanceOf[to] + 0x01; ownerOf[tokenId] = (ownerOf[tokenId] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | to; emit Transfer(ownerOf[tokenId], to, tokenId); require(ownerOf[tokenId] == _from, ERC721IncorrectOwner()); if (to.code.length != 0x0) { (bool success4, bytes memory returnData4) = to.onERC721Received(msg.sender, _from, tokenId, 0x80); // call if (success4) { uint256 value19 = returnData4.length; if (0x20 <= returnData4.length) { value19 = 0x20; } if (((var_a + ((value19 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value19 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value19 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); } else { if (!(success4)) { uint256 value20 = 0x60; if ((returnData4.length) != 0x0) { if (returnData4.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData4.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData4.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData4.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value20 = var_a; } require(var_t != 0x0, ERC721InvalidReceiver()); revert(); } require(!(0xeaf485fe00000000000000000000000000000000000000000000000000000000), ERC721InvalidReceiver()); } } } } } } else { address account4 = address(0); if (stor_1c) { mapping_25[tokenId] = true; mapping_24[tokenId] = (ownerOf[tokenId] & (0xffffffffffffffffffffffffffffffffffffffff)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & mapping_24[tokenId]); emit Event_d94d502d(tokenId, ownerOf[tokenId]); } else { account4 = ownerOf[tokenId]; } uint256 value67 = 0; if (msg.sender != address(0)) { uint256 value22; uint256 value21; if (!(ownerOf[tokenId] == msg.sender)) { bool flag15 = !(!(msg.sender)); if (!(msg.sender == marketplace)) { flag15 = (msg.sender) == marketplace; } bool flag16 = !(unresolved_50cd382e[ownerOf[tokenId]]); if (flag15) { } else { flag16 = flag15; } uint256 value53 = 0x01; if (!(flag16)) { value53 = bytes1(mapping_5[address(ownerOf[tokenId])][msg.sender]); } value21 = value53; } else { value21 = (ownerOf[tokenId] == msg.sender) ? 1 : 0; } uint256 value52 = value21; if (value21 == 0) { value52 = (msg.sender == getApproved[tokenId]) ? 1 : 0; } value22 = value52; if (value22 == 0x0) { require(ownerOf[tokenId] != address(0), ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } } else { flag17 = msg.sender != address(0); } if (ownerOf[tokenId] != address(0)) { getApproved[tokenId] = address(0); balanceOf[ownerOf[tokenId]] = balanceOf[ownerOf[tokenId]] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[to] = balanceOf[to] + 0x01; ownerOf[tokenId] = (ownerOf[tokenId] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | to; emit Transfer(ownerOf[tokenId], to, tokenId); require(ownerOf[tokenId] == _from, ERC721IncorrectOwner()); if (to.code.length != 0x0) { (bool success5, bytes memory returnData5) = to.onERC721Received(msg.sender, _from, tokenId, 0x80); // call if (success5) { uint256 value23 = returnData5.length; if (0x20 <= returnData5.length) { value23 = 0x20; } if (((var_a + ((value23 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value23 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value23 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); } else { if (!(success5)) { uint256 value24 = 0x60; if ((returnData5.length) != 0x0) { if (returnData5.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData5.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData5.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData5.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value24 = var_a; } require(var_u != 0x0, ERC721InvalidReceiver()); revert(); } require(!(0xeaf485fe00000000000000000000000000000000000000000000000000000000), ERC721InvalidReceiver()); } } } } } else { uint256 value71 = 0; if (msg.sender != address(0)) { uint256 value38; uint256 value37; if (!(ownerOf[tokenId] == msg.sender)) { bool flag27 = !(!(msg.sender)); if (!(msg.sender == marketplace)) { flag27 = (msg.sender) == marketplace; } bool flag28 = !(unresolved_50cd382e[ownerOf[tokenId]]); if (flag27) { } else { flag28 = flag27; } uint256 value61 = 0x01; if (!(flag28)) { value61 = bytes1(mapping_5[address(ownerOf[tokenId])][msg.sender]); } value37 = value61; } else { value37 = (ownerOf[tokenId] == msg.sender) ? 1 : 0; } uint256 value60 = value37; if (value37 == 0) { value60 = (msg.sender == getApproved[tokenId]) ? 1 : 0; } value38 = value60; if (value38 == 0x0) { require(ownerOf[tokenId] != address(0), ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } } else { flag29 = msg.sender != address(0); } if (ownerOf[tokenId] != address(0)) { getApproved[tokenId] = address(0); balanceOf[ownerOf[tokenId]] = balanceOf[ownerOf[tokenId]] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[to] = balanceOf[to] + 0x01; ownerOf[tokenId] = (ownerOf[tokenId] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | to; emit Transfer(ownerOf[tokenId], to, tokenId); require(ownerOf[tokenId] == _from, ERC721IncorrectOwner()); if (to.code.length != 0x0) { (bool success9, bytes memory returnData9) = to.onERC721Received(msg.sender, _from, tokenId, 0x80); // call if (success9) { uint256 value39 = returnData9.length; if (0x20 <= returnData9.length) { value39 = 0x20; } if (((var_a + ((value39 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value39 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value39 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); } else { if (!(success9)) { uint256 value40 = 0x60; if ((returnData9.length) != 0x0) { if (returnData9.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData9.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData9.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData9.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value40 = var_a; } require(var_z != 0x0, ERC721InvalidReceiver()); revert(); } require(!(0xeaf485fe00000000000000000000000000000000000000000000000000000000), ERC721InvalidReceiver()); } } } } function rewardEnded() public view returns (bool) { if (!stor_1c) { return stor_1c; } if (stor_1a == 0) { return !(block.timestamp < 0); } else { if (!stor_1c) { uint256 value0 = stor_1a; if (block.timestamp > stor_1a) { uint256 value1 = block.timestamp; value1 = stor_1a + ((!(!(block.timestamp - stor_1a))) * ((((block.timestamp - stor_1a) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x015180) + 0x01) * 0x015180); value0 = value1; } return !(block.timestamp < value0); } else { if (!(stor_1c > stor_1a)) { return !(block.timestamp < stor_1a); } else { return !(block.timestamp < (stor_1a + ((!(!(stor_1c - stor_1a))) * ((((stor_1c - stor_1a) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x015180) + 0x01) * 0x015180))); } } } } function usdToWei(uint256 arg0) public returns (uint256) { uint256 var_c; if (((var_c + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); (bool success0, bytes memory returnData0) = address(0x0567f2323251f0aab15c8dfb1967e4e8a7d42aee).latestRoundData{ gas: 0x030d40 }(); // staticcall uint256 value0 = 0x60; if ((returnData0.length) != 0x0) { if (returnData0.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_c + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value0 = var_c; } bool flag0 = var_e < 0xa0; if (!success0) { flag0 = !success0; } uint256 value2 = 0; uint256 value3 = 0; uint256 value4 = 0; if (!(flag0)) { require(((value0 + var_e) - value0) >= 0xa0); uint256 value15 = 0; uint256 value16 = 0; uint256 value17 = 0; if (var_f > 0) { uint256 value1 = (var_f * 0x05f5e100) / (0x0a ** 0x08); if (((var_f * 0x05f5e100) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (var_f * 0x05f5e100) == (((var_f * 0x05f5e100) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (var_f * 0x05f5e100))) { } else { uint256 sharedExpr15 = (0x0a ** 0x08) & (0 - (0x0a ** 0x08)); uint256 sharedExpr16 = 0x03 * ((0x0a ** 0x08) / sharedExpr15); uint256 sharedExpr17 = 0x02 - (((0x0a ** 0x08) / sharedExpr15) * (sharedExpr16 ^ 0x02)); uint256 sharedExpr18 = sharedExpr16 ^ 0x02; uint256 sharedExpr19 = 0x02 - (((0x0a ** 0x08) / sharedExpr15) * (sharedExpr17 * sharedExpr18)); uint256 sharedExpr20 = sharedExpr17 * sharedExpr18; uint256 sharedExpr21 = 0x02 - (((0x0a ** 0x08) / sharedExpr15) * (sharedExpr19 * sharedExpr20)); uint256 sharedExpr22 = sharedExpr19 * sharedExpr20; uint256 sharedExpr23 = 0x02 - (((0x0a ** 0x08) / sharedExpr15) * (sharedExpr21 * sharedExpr22)); uint256 sharedExpr24 = sharedExpr21 * sharedExpr22; uint256 sharedExpr25 = 0x02 - (((0x0a ** 0x08) / sharedExpr15) * (sharedExpr23 * sharedExpr24)); uint256 sharedExpr26 = sharedExpr23 * sharedExpr24; uint256 sharedExpr27 = var_f; uint256 sharedExpr28 = 0x0a ** 0x08; uint256 sharedExpr29 = (0x0a ** 0x08) & (0 - (0x0a ** 0x08)); uint256 sharedExpr30 = 0x03 * ((0x0a ** 0x08) / sharedExpr29); uint256 sharedExpr31 = 0x02 - (((0x0a ** 0x08) / sharedExpr29) * (sharedExpr30 ^ 0x02)); uint256 sharedExpr32 = sharedExpr30 ^ 0x02; uint256 sharedExpr33 = 0x02 - (((0x0a ** 0x08) / sharedExpr29) * (sharedExpr31 * sharedExpr32)); uint256 sharedExpr34 = sharedExpr31 * sharedExpr32; uint256 sharedExpr35 = 0x02 - (((0x0a ** 0x08) / sharedExpr29) * (sharedExpr33 * sharedExpr34)); uint256 sharedExpr36 = sharedExpr33 * sharedExpr34; uint256 sharedExpr37 = 0x02 - (((0x0a ** 0x08) / sharedExpr29) * (sharedExpr35 * sharedExpr36)); uint256 sharedExpr38 = sharedExpr35 * sharedExpr36; uint256 sharedExpr39 = 0x02 - (((0x0a ** 0x08) / sharedExpr29) * (sharedExpr37 * sharedExpr38)); uint256 sharedExpr40 = sharedExpr37 * sharedExpr38; uint256 sharedExpr41 = ((var_f * 0x05f5e100) - ((var_f * 0x05f5e100) % (0x0a ** 0x08)) / ((0x0a ** 0x08) & (0 - (0x0a ** 0x08))) | (((var_f * 0x05f5e100) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (var_f * 0x05f5e100) - (((var_f * 0x05f5e100) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (var_f * 0x05f5e100)) - ((var_f * 0x05f5e100) % (0x0a ** 0x08) > (var_f * 0x05f5e100)) * ((0 - ((0x0a ** 0x08) & (0 - (0x0a ** 0x08)))) / ((0x0a ** 0x08) & (0 - (0x0a ** 0x08))) + 0x01))) * ((0x02 - (((0x0a ** 0x08) / sharedExpr29) * (sharedExpr39 * sharedExpr40))) * (sharedExpr39 * sharedExpr40)); value1 = sharedExpr41; } value15 = var_g; value16 = value1; value17 = 0x01; } value2 = value15; value3 = value16; value4 = value17; } bool value5 = !(value2 > block.timestamp); if (value4 == 0) { value5 = (value4 != 0x0) ? 1 : 0; } uint256 value6 = 0; if (value5 != 0x0) { } else { value6 = value2; } if ((value5 != 0x0) && (0xe10 >= block.timestamp - value2)) { uint256 value7 = (arg0 * 0x0de0b6b3a7640000) / value3; if (((arg0 * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (arg0 * 0x0de0b6b3a7640000) == (((arg0 * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (arg0 * 0x0de0b6b3a7640000))) { } else { uint256 sharedExpr54 = value3 & (0 - value3); uint256 sharedExpr55 = 0x03 * (value3 / sharedExpr54); uint256 sharedExpr56 = 0x02 - ((value3 / sharedExpr54) * (sharedExpr55 ^ 0x02)); uint256 sharedExpr57 = sharedExpr55 ^ 0x02; uint256 sharedExpr58 = 0x02 - ((value3 / sharedExpr54) * (sharedExpr56 * sharedExpr57)); uint256 sharedExpr59 = sharedExpr56 * sharedExpr57; uint256 sharedExpr60 = 0x02 - ((value3 / sharedExpr54) * (sharedExpr58 * sharedExpr59)); uint256 sharedExpr61 = sharedExpr58 * sharedExpr59; uint256 sharedExpr62 = 0x02 - ((value3 / sharedExpr54) * (sharedExpr60 * sharedExpr61)); uint256 sharedExpr63 = sharedExpr60 * sharedExpr61; uint256 sharedExpr64 = 0x02 - ((value3 / sharedExpr54) * (sharedExpr62 * sharedExpr63)); uint256 sharedExpr65 = sharedExpr62 * sharedExpr63; uint256 sharedExpr66 = value3 & (0 - value3); uint256 sharedExpr67 = 0x03 * (value3 / sharedExpr66); uint256 sharedExpr68 = 0x02 - ((value3 / sharedExpr66) * (sharedExpr67 ^ 0x02)); uint256 sharedExpr69 = sharedExpr67 ^ 0x02; uint256 sharedExpr70 = 0x02 - ((value3 / sharedExpr66) * (sharedExpr68 * sharedExpr69)); uint256 sharedExpr71 = sharedExpr68 * sharedExpr69; uint256 sharedExpr72 = 0x02 - ((value3 / sharedExpr66) * (sharedExpr70 * sharedExpr71)); uint256 sharedExpr73 = sharedExpr70 * sharedExpr71; uint256 sharedExpr74 = 0x02 - ((value3 / sharedExpr66) * (sharedExpr72 * sharedExpr73)); uint256 sharedExpr75 = sharedExpr72 * sharedExpr73; uint256 sharedExpr76 = 0x02 - ((value3 / sharedExpr66) * (sharedExpr74 * sharedExpr75)); uint256 sharedExpr77 = sharedExpr74 * sharedExpr75; value7 = ((arg0 * 0x0de0b6b3a7640000) - ((arg0 * 0x0de0b6b3a7640000) % value3) / (value3 & (0 - value3)) | (((arg0 * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (arg0 * 0x0de0b6b3a7640000) - (((arg0 * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (arg0 * 0x0de0b6b3a7640000)) - (((arg0 * 0x0de0b6b3a7640000) % value3) > (arg0 * 0x0de0b6b3a7640000)) * ((0 - (value3 & (0 - value3))) / (value3 & (0 - value3)) + 0x01))) * ((0x02 - ((value3 / sharedExpr66) * (sharedExpr76 * sharedExpr77))) * (sharedExpr76 * sharedExpr77)); } return value7 + (!(!((arg0 * 0x0de0b6b3a7640000) % value3))); } else { uint256 value11 = 0; if (((var_c + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); (bool success1, bytes memory returnData1) = address(0x16b9a82891338f9ba80e2d6970fdda79d1eb0dae).getReserves{ gas: 0x030d40 }(); // staticcall uint256 value8 = 0x60; if ((returnData1.length) != 0x0) { if (returnData1.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_c + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData1.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData1.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData1.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value8 = var_c; } bool flag2 = var_j < 0x60; if (!success1) { flag2 = !success1; } uint256 value18 = 0; if (!(flag2)) { require(((value8 + var_j) - value8) >= 0x60); uint256 value9 = var_k; uint256 value10 = var_l; bool flag3 = value9 == 0x0; if (value10 == 0) { flag3 = value10 == 0x0; } bool flag4 = value10 > 0xffffffffffffffffffffffffffff; if (flag3) { flag4 = flag3; } uint256 value19 = 0; if (((flag4) && (value9 > 0xffffffffffffffffffffffffffff)) || (flag4)) { uint256 value20 = (value9 * (0x0a ** 0x1a)) / (value10 * (0x0a ** 0x12)); if (((value9 * (0x0a ** 0x1a)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (value9 * (0x0a ** 0x1a)) == (((value9 * (0x0a ** 0x1a)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (value9 * (0x0a ** 0x1a)))) { } else { uint256 sharedExpr99 = 0x0a ** 0x1a; uint256 sharedExpr100 = 0x0a ** 0x1a; uint256 sharedExpr101 = 0x0a ** 0x12; uint256 sharedExpr102 = value10 * (0x0a ** 0x12); uint256 sharedExpr103 = sharedExpr102; uint256 sharedExpr104 = sharedExpr102; uint256 sharedExpr105 = 0 - sharedExpr102; uint256 sharedExpr106 = 0x0a ** 0x1a; uint256 sharedExpr107 = sharedExpr102; uint256 sharedExpr108 = sharedExpr104 & sharedExpr105; uint256 sharedExpr109 = 0x03 * (sharedExpr107 / sharedExpr108); uint256 sharedExpr110 = 0x02 - ((sharedExpr107 / sharedExpr108) * (sharedExpr109 ^ 0x02)); uint256 sharedExpr111 = sharedExpr109 ^ 0x02; uint256 sharedExpr112 = 0x02 - ((sharedExpr107 / sharedExpr108) * (sharedExpr110 * sharedExpr111)); uint256 sharedExpr113 = sharedExpr110 * sharedExpr111; uint256 sharedExpr114 = 0x02 - ((sharedExpr107 / sharedExpr108) * (sharedExpr112 * sharedExpr113)); uint256 sharedExpr115 = sharedExpr112 * sharedExpr113; uint256 sharedExpr116 = 0x02 - ((sharedExpr107 / sharedExpr108) * (sharedExpr114 * sharedExpr115)); uint256 sharedExpr117 = sharedExpr114 * sharedExpr115; uint256 sharedExpr118 = 0x02 - ((sharedExpr107 / sharedExpr108) * (sharedExpr116 * sharedExpr117)); uint256 sharedExpr119 = sharedExpr116 * sharedExpr117; uint256 sharedExpr120 = 0x0a ** 0x1a; uint256 sharedExpr121 = 0x0a ** 0x1a; uint256 sharedExpr122 = 0x0a ** 0x12; uint256 sharedExpr123 = value10 * (0x0a ** 0x12); uint256 sharedExpr124 = sharedExpr123; uint256 sharedExpr125 = sharedExpr123; uint256 sharedExpr126 = 0 - sharedExpr123; uint256 sharedExpr127 = 0x0a ** 0x1a; uint256 sharedExpr128 = sharedExpr123; uint256 sharedExpr129 = sharedExpr125 & sharedExpr126; uint256 sharedExpr130 = 0x03 * (sharedExpr128 / sharedExpr129); uint256 sharedExpr131 = 0x02 - ((sharedExpr128 / sharedExpr129) * (sharedExpr130 ^ 0x02)); uint256 sharedExpr132 = sharedExpr130 ^ 0x02; uint256 sharedExpr133 = 0x02 - ((sharedExpr128 / sharedExpr129) * (sharedExpr131 * sharedExpr132)); uint256 sharedExpr134 = sharedExpr131 * sharedExpr132; uint256 sharedExpr135 = 0x02 - ((sharedExpr128 / sharedExpr129) * (sharedExpr133 * sharedExpr134)); uint256 sharedExpr136 = sharedExpr133 * sharedExpr134; uint256 sharedExpr137 = 0x02 - ((sharedExpr128 / sharedExpr129) * (sharedExpr135 * sharedExpr136)); uint256 sharedExpr138 = sharedExpr135 * sharedExpr136; uint256 sharedExpr139 = 0x02 - ((sharedExpr128 / sharedExpr129) * (sharedExpr137 * sharedExpr138)); uint256 sharedExpr140 = sharedExpr137 * sharedExpr138; value20 = ((value9 * sharedExpr120) - ((value9 * sharedExpr121) % sharedExpr124) / (sharedExpr125 & sharedExpr126) | (((value9 * sharedExpr127) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (value9 * sharedExpr120) - (((value9 * sharedExpr127) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (value9 * sharedExpr120)) - (((value9 * sharedExpr121) % sharedExpr124) > (value9 * sharedExpr120)) * ((0 - (sharedExpr125 & sharedExpr126)) / (sharedExpr125 & sharedExpr126) + 0x01))) * ((0x02 - ((sharedExpr128 / sharedExpr129) * (sharedExpr139 * sharedExpr140))) * (sharedExpr139 * sharedExpr140)); } value19 = value20; } value18 = value19; } value11 = value18; if (value11 != 0x0) { uint256 value12 = (arg0 * 0x0de0b6b3a7640000) / value11; if (((arg0 * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (arg0 * 0x0de0b6b3a7640000) == (((arg0 * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (arg0 * 0x0de0b6b3a7640000))) { } else { uint256 sharedExpr153 = value3 & (0 - value3); uint256 sharedExpr154 = 0x03 * (value3 / sharedExpr153); uint256 sharedExpr155 = 0x02 - ((value3 / sharedExpr153) * (sharedExpr154 ^ 0x02)); uint256 sharedExpr156 = sharedExpr154 ^ 0x02; uint256 sharedExpr157 = 0x02 - ((value3 / sharedExpr153) * (sharedExpr155 * sharedExpr156)); uint256 sharedExpr158 = sharedExpr155 * sharedExpr156; uint256 sharedExpr159 = 0x02 - ((value3 / sharedExpr153) * (sharedExpr157 * sharedExpr158)); uint256 sharedExpr160 = sharedExpr157 * sharedExpr158; uint256 sharedExpr161 = 0x02 - ((value3 / sharedExpr153) * (sharedExpr159 * sharedExpr160)); uint256 sharedExpr162 = sharedExpr159 * sharedExpr160; uint256 sharedExpr163 = 0x02 - ((value3 / sharedExpr153) * (sharedExpr161 * sharedExpr162)); uint256 sharedExpr164 = sharedExpr161 * sharedExpr162; uint256 sharedExpr165 = value3 & (0 - value3); uint256 sharedExpr166 = 0x03 * (value3 / sharedExpr165); uint256 sharedExpr167 = 0x02 - ((value3 / sharedExpr165) * (sharedExpr166 ^ 0x02)); uint256 sharedExpr168 = sharedExpr166 ^ 0x02; uint256 sharedExpr169 = 0x02 - ((value3 / sharedExpr165) * (sharedExpr167 * sharedExpr168)); uint256 sharedExpr170 = sharedExpr167 * sharedExpr168; uint256 sharedExpr171 = 0x02 - ((value3 / sharedExpr165) * (sharedExpr169 * sharedExpr170)); uint256 sharedExpr172 = sharedExpr169 * sharedExpr170; uint256 sharedExpr173 = 0x02 - ((value3 / sharedExpr165) * (sharedExpr171 * sharedExpr172)); uint256 sharedExpr174 = sharedExpr171 * sharedExpr172; uint256 sharedExpr175 = 0x02 - ((value3 / sharedExpr165) * (sharedExpr173 * sharedExpr174)); uint256 sharedExpr176 = sharedExpr173 * sharedExpr174; value12 = ((arg0 * 0x0de0b6b3a7640000) - ((arg0 * 0x0de0b6b3a7640000) % value3) / (value3 & (0 - value3)) | (((arg0 * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (arg0 * 0x0de0b6b3a7640000) - (((arg0 * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (arg0 * 0x0de0b6b3a7640000)) - (((arg0 * 0x0de0b6b3a7640000) % value3) > (arg0 * 0x0de0b6b3a7640000)) * ((0 - (value3 & (0 - value3))) / (value3 & (0 - value3)) + 0x01))) * ((0x02 - ((value3 / sharedExpr165) * (sharedExpr175 * sharedExpr176))) * (sharedExpr175 * sharedExpr176)); } return value12 + (!(!((arg0 * 0x0de0b6b3a7640000) % value11))); } else { if (value4 != 0x0) { uint256 value13 = (arg0 * 0x0de0b6b3a7640000) / value3; if (((arg0 * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (arg0 * 0x0de0b6b3a7640000) == (((arg0 * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (arg0 * 0x0de0b6b3a7640000))) { } else { uint256 sharedExpr189 = value3 & (0 - value3); uint256 sharedExpr190 = 0x03 * (value3 / sharedExpr189); uint256 sharedExpr191 = 0x02 - ((value3 / sharedExpr189) * (sharedExpr190 ^ 0x02)); uint256 sharedExpr192 = sharedExpr190 ^ 0x02; uint256 sharedExpr193 = 0x02 - ((value3 / sharedExpr189) * (sharedExpr191 * sharedExpr192)); uint256 sharedExpr194 = sharedExpr191 * sharedExpr192; uint256 sharedExpr195 = 0x02 - ((value3 / sharedExpr189) * (sharedExpr193 * sharedExpr194)); uint256 sharedExpr196 = sharedExpr193 * sharedExpr194; uint256 sharedExpr197 = 0x02 - ((value3 / sharedExpr189) * (sharedExpr195 * sharedExpr196)); uint256 sharedExpr198 = sharedExpr195 * sharedExpr196; uint256 sharedExpr199 = 0x02 - ((value3 / sharedExpr189) * (sharedExpr197 * sharedExpr198)); uint256 sharedExpr200 = sharedExpr197 * sharedExpr198; uint256 sharedExpr201 = value3 & (0 - value3); uint256 sharedExpr202 = 0x03 * (value3 / sharedExpr201); uint256 sharedExpr203 = 0x02 - ((value3 / sharedExpr201) * (sharedExpr202 ^ 0x02)); uint256 sharedExpr204 = sharedExpr202 ^ 0x02; uint256 sharedExpr205 = 0x02 - ((value3 / sharedExpr201) * (sharedExpr203 * sharedExpr204)); uint256 sharedExpr206 = sharedExpr203 * sharedExpr204; uint256 sharedExpr207 = 0x02 - ((value3 / sharedExpr201) * (sharedExpr205 * sharedExpr206)); uint256 sharedExpr208 = sharedExpr205 * sharedExpr206; uint256 sharedExpr209 = 0x02 - ((value3 / sharedExpr201) * (sharedExpr207 * sharedExpr208)); uint256 sharedExpr210 = sharedExpr207 * sharedExpr208; uint256 sharedExpr211 = 0x02 - ((value3 / sharedExpr201) * (sharedExpr209 * sharedExpr210)); uint256 sharedExpr212 = sharedExpr209 * sharedExpr210; value13 = ((arg0 * 0x0de0b6b3a7640000) - ((arg0 * 0x0de0b6b3a7640000) % value3) / (value3 & (0 - value3)) | (((arg0 * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (arg0 * 0x0de0b6b3a7640000) - (((arg0 * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (arg0 * 0x0de0b6b3a7640000)) - (((arg0 * 0x0de0b6b3a7640000) % value3) > (arg0 * 0x0de0b6b3a7640000)) * ((0 - (value3 & (0 - value3))) / (value3 & (0 - value3)) + 0x01))) * ((0x02 - ((value3 / sharedExpr201) * (sharedExpr211 * sharedExpr212))) * (sharedExpr211 * sharedExpr212)); } return value13 + (!(!((arg0 * 0x0de0b6b3a7640000) % value3))); } else { uint256 value14 = (arg0 * 0x0de0b6b3a7640000) / lastGoodPrice; if (((arg0 * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (arg0 * 0x0de0b6b3a7640000) == (((arg0 * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (arg0 * 0x0de0b6b3a7640000))) { } else { uint256 sharedExpr225 = value3 & (0 - value3); uint256 sharedExpr226 = 0x03 * (value3 / sharedExpr225); uint256 sharedExpr227 = 0x02 - ((value3 / sharedExpr225) * (sharedExpr226 ^ 0x02)); uint256 sharedExpr228 = sharedExpr226 ^ 0x02; uint256 sharedExpr229 = 0x02 - ((value3 / sharedExpr225) * (sharedExpr227 * sharedExpr228)); uint256 sharedExpr230 = sharedExpr227 * sharedExpr228; uint256 sharedExpr231 = 0x02 - ((value3 / sharedExpr225) * (sharedExpr229 * sharedExpr230)); uint256 sharedExpr232 = sharedExpr229 * sharedExpr230; uint256 sharedExpr233 = 0x02 - ((value3 / sharedExpr225) * (sharedExpr231 * sharedExpr232)); uint256 sharedExpr234 = sharedExpr231 * sharedExpr232; uint256 sharedExpr235 = 0x02 - ((value3 / sharedExpr225) * (sharedExpr233 * sharedExpr234)); uint256 sharedExpr236 = sharedExpr233 * sharedExpr234; uint256 sharedExpr237 = value3 & (0 - value3); uint256 sharedExpr238 = 0x03 * (value3 / sharedExpr237); uint256 sharedExpr239 = 0x02 - ((value3 / sharedExpr237) * (sharedExpr238 ^ 0x02)); uint256 sharedExpr240 = sharedExpr238 ^ 0x02; uint256 sharedExpr241 = 0x02 - ((value3 / sharedExpr237) * (sharedExpr239 * sharedExpr240)); uint256 sharedExpr242 = sharedExpr239 * sharedExpr240; uint256 sharedExpr243 = 0x02 - ((value3 / sharedExpr237) * (sharedExpr241 * sharedExpr242)); uint256 sharedExpr244 = sharedExpr241 * sharedExpr242; uint256 sharedExpr245 = 0x02 - ((value3 / sharedExpr237) * (sharedExpr243 * sharedExpr244)); uint256 sharedExpr246 = sharedExpr243 * sharedExpr244; uint256 sharedExpr247 = 0x02 - ((value3 / sharedExpr237) * (sharedExpr245 * sharedExpr246)); uint256 sharedExpr248 = sharedExpr245 * sharedExpr246; value14 = ((arg0 * 0x0de0b6b3a7640000) - ((arg0 * 0x0de0b6b3a7640000) % value3) / (value3 & (0 - value3)) | (((arg0 * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (arg0 * 0x0de0b6b3a7640000) - (((arg0 * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (arg0 * 0x0de0b6b3a7640000)) - (((arg0 * 0x0de0b6b3a7640000) % value3) > (arg0 * 0x0de0b6b3a7640000)) * ((0 - (value3 & (0 - value3))) / (value3 & (0 - value3)) + 0x01))) * ((0x02 - ((value3 / sharedExpr237) * (sharedExpr247 * sharedExpr248))) * (sharedExpr247 * sharedExpr248)); } return value14 + (!(!((arg0 * 0x0de0b6b3a7640000) % lastGoodPrice))); } } } } function Unknown_a5c88017(address arg0) public { uint256 value0 = msg.data[0] >> 0xe0; if (unresolved_b79b1d35 != msg.sender) { value0 = unresolved_b79b1d35; } require(!(unresolved_b79b1d35 != msg.sender || unresolved_b79b1d35 == 0x0), NotPayee()); require(arg0 != address(0), BadConfig()); unresolved_b79b1d35 = arg0; emit Event_8e6a36ee(0x01, unresolved_b79b1d35); } function setApprovalForAll(address operator, bool approved) public { if ((operator == marketplace) && (operator != address(0))) { unresolved_50cd382e[msg.sender] = (bytes1(!approved)) | (unresolved_50cd382e[msg.sender] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); } else { require(msg.sender != address(0), ERC721InvalidApprover()); require(operator != address(0), ERC721InvalidOperator()); mapping_5[msg.sender][operator] = (bytes1(approved)) | (mapping_5[msg.sender][operator] & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); } emit ApprovalForAll(msg.sender, operator, approved); } function ticketsIssued() public view returns (uint256) { return stor_a; } function phaseOf(uint256 arg0) public pure returns (bool) { uint256 value0 = 0x01; if (!(arg0 <= 0x01f4)) { value0 = (0x02 + ((arg0 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } return bytes1(value0); } function symbol() public view returns (string memory) { return _symbol; } function claimableReward(uint256 arg0) public view returns (uint256) { uint256 value2; if (unresolved_64c37584[arg0]) { if (stor_1c) { value2 = 0; if (stor_1a != 0) { uint256 value3; if (!stor_1c) { uint256 value0 = stor_1a; if (!(block.timestamp <= stor_1a)) { uint256 value4 = block.timestamp; value4 = stor_1a + ((!(!(block.timestamp - stor_1a))) * ((((block.timestamp - stor_1a) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x015180) + 0x01) * 0x015180); value0 = value4; } if (!(!(block.timestamp < value0))) { return 0; } else { uint256 value1 = rewardAccrued / stor_18; if (!(stor_18 != 0x0)) { value1 = 0; } return value1 - rewardClaimed[arg0]; } } else { value3 = stor_1a; if (stor_1c > stor_1a) { uint256 value5 = (stor_1c) ? 1 : 0; value5 = stor_1a + ((!(!(stor_1c - stor_1a))) * ((((stor_1c - stor_1a) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x015180) + 0x01) * 0x015180); value3 = (value5) ? 1 : 0; } } value2 = value3; } } } if (((unresolved_64c37584[arg0]) && (((stor_1c != 0x0) && (block.timestamp < value2)) || ((stor_1c == 0x0) && (stor_1c == 0x0)))) || (!unresolved_64c37584[arg0])) { return 0; } else { if (stor_18 != 0x0) { return (rewardAccrued / stor_18) - rewardClaimed[arg0]; } else { return 0 - rewardClaimed[arg0]; } } } function setRoyalty(address arg0, uint96 arg1) public { require(arg1 == (arg1 & 0xffffffffffffffffffffffff)); require(msg.sender == owner, OwnableUnauthorizedAccount()); require(uint96(arg1) <= 0x03e8, RoyaltyTooHigh()); require(uint96(arg1) <= 0x2710, ERC2981InvalidDefaultRoyalty()); require(arg0 != address(0), ERC2981InvalidDefaultRoyaltyReceiver()); if (((var_a + 0x40) > 0xffffffffffffffff) | ((var_a + 0x40) < var_a)) _desolexPanic(65); stor_6 = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & (arg1 << 0xa0)) | arg0; } function Unknown_825c47f2(uint256 arg0) public view returns (uint256) { uint256 value0 = arg0 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if (arg0 != 0x0) { } else { value0 = 0; } if ((unresolved_7c3f33d6 + (value0 * unresolved_e4441769)) > 0x38) { return 0x38; } return unresolved_7c3f33d6 + (value0 * unresolved_e4441769); } function Unknown_82451915(bytes32 arg0) public view returns (uint256) { if (!unresolved_64c37584[arg0]) { return 0; } else { if (mapping_25[arg0]) { return mapping_24[arg0]; } else { return ownerOf[arg0]; } } } function setDifficulty(uint256 arg0, uint256 arg1) public onlyOwner { require(!stor_15_0_0, CustomError_e150381c()); bool flag0 = arg0 > 0x38; if (arg0 < 0x08) { flag0 = arg0 < 0x8; } require(!(!flag0 && arg1 > 0x8 || flag0), BadConfig()); uint256 value0 = 0x2710; if (stor_a < 0x2710) { value0 = stor_a + 0x01; } uint256 value1 = 0x01; if (!(value0 <= 0x01f4)) { value1 = (0x02 + ((value0 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } uint256 value2 = (bytes1(value1)) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if ((value1 & 0xff) != 0x0) { } else { value2 = 0; } uint256 value3 = unresolved_7c3f33d6 + (value2 * unresolved_e4441769); if ((unresolved_7c3f33d6 + (value2 * unresolved_e4441769)) > 0x38) { value3 = 0x38; } uint256 value4 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> value3; if (!(value3 < 0x100)) { value4 = 0; } if ((block.timestamp <= stor_f) && (stor_e > value4)) { unresolved_7c3f33d6 = (arg0) ? 1 : 0; unresolved_e4441769 = arg1; uint256 value10; if (!(stor_a < 0x2710)) { uint256 value17; uint256 value6 = ((0x02 + ((0x2710 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8) & (0xff)) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if ((0x02 + ((0x2710 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8) & (0xff) != 0x0) { } else { value6 = 0; } uint256 value20; if (!((unresolved_7c3f33d6 + (value6 * unresolved_e4441769)) > 0x38)) { uint256 value23 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> (unresolved_7c3f33d6 + (value6 * unresolved_e4441769)); if (!((unresolved_7c3f33d6 + (value6 * unresolved_e4441769)) < 0x0100)) { value23 = 0; } value20 = value23; } else { uint256 value24 = 0xffffffffffffffffffffffffffffffffffffffffffffffffff; value20 = value24; } value17 = value20; value10 = value17; } else { uint256 value7 = 0x01; if (!((stor_a + 0x01) <= 0x01f4)) { value7 = (0x02 + (((stor_a + 0x01) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } uint256 value8 = bytes1(value7) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if (bytes1(value7) != 0x0) { } else { value8 = 0; } uint256 value9 = unresolved_7c3f33d6 + (value8 * unresolved_e4441769); if ((unresolved_7c3f33d6 + (value8 * unresolved_e4441769)) > 0x38) { value9 = 0x38; } uint256 value18 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> value9; if (!(value9 < 0x100)) { value18 = 0; } value10 = value18; } if (value10 < stor_e) { stor_e = stor_e; stor_f = block.timestamp + 0x5a; } } else { unresolved_7c3f33d6 = (arg0) ? 1 : 0; unresolved_e4441769 = arg1; uint256 value16; if (!(stor_a < 0x2710)) { uint256 value25; uint256 value12 = ((0x02 + ((0x2710 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8) & (0xff)) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if ((0x02 + ((0x2710 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8) & (0xff) != 0x0) { } else { value12 = 0; } uint256 value28; if (!((unresolved_7c3f33d6 + (value12 * unresolved_e4441769)) > 0x38)) { uint256 value31 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> (unresolved_7c3f33d6 + (value12 * unresolved_e4441769)); if (!((unresolved_7c3f33d6 + (value12 * unresolved_e4441769)) < 0x0100)) { value31 = 0; } value28 = value31; } else { uint256 value32 = 0xffffffffffffffffffffffffffffffffffffffffffffffffff; value28 = value32; } value25 = value28; value16 = value25; } else { uint256 value13 = 0x01; if (!((stor_a + 0x01) <= 0x01f4)) { value13 = (0x02 + (((stor_a + 0x01) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } uint256 value14 = bytes1(value13) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if (bytes1(value13) != 0x0) { } else { value14 = 0; } uint256 value15 = unresolved_7c3f33d6 + (value14 * unresolved_e4441769); if ((unresolved_7c3f33d6 + (value14 * unresolved_e4441769)) > 0x38) { value15 = 0x38; } uint256 value26 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> value15; if (!(value15 < 0x100)) { value26 = 0; } value16 = value26; } if (value16 < value4) { stor_e = value4; stor_f = block.timestamp + 0x5a; } } emit Event_2086182e(arg0, arg1); } function rewardStatus() public view { } function pendingDraws() public view returns (bool) { if (stor_a - stor_b == 0) { return abi.encodePacked(0, 0, 0); } else { return abi.encodePacked(stor_a - stor_b, !(!(block.number > (uint64(mapping_26[stor_b + 0x01] >> 0xa0)))), uint64(mapping_26[stor_b + 0x01] >> 0xa0)); } } function setMarketplace(address newAddress) public onlyOwner { require(!(marketplace), MarketplaceAlreadySet()); require(newAddress != address(0), BadConfig()); marketplace = newAddress; emit MarketplaceSet(marketplace); } function Unknown_7272ce26() public view returns (bool) { return stor_15_0_0; } function renounceOwnership() public onlyOwner { emit OwnershipTransferred(owner, address(0)); owner = address(0); } function challengeOf(address account) public view returns (uint256) { if (((var_i + 0xc0) > 0xffffffffffffffff) | ((var_i + 0xc0) < var_i)) _desolexPanic(65); return keccak256(abi.encode(block.chainid, address(this), launchSeed, (account), (minedBy[account]))); } function verify(address arg0, uint256 arg1) public returns (bool) { var_b = 0x27; uint256 var_i; if (((var_i + 0xc0) > 0xffffffffffffffff) | ((var_i + 0xc0) < var_i)) _desolexPanic(65); var_i = var_i + 0xc0; if (((var_i + 0x80) > 0xffffffffffffffff) | ((var_i + 0x80) < var_i)) _desolexPanic(65); bytes var_a = sha256(); require(var_b); uint256 value0 = 0x2710; if (stor_a < 0x2710) { value0 = stor_a + 0x01; } uint256 value1 = 0x01; if (!(value0 <= 0x01f4)) { value1 = (0x02 + ((value0 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } uint256 value2 = (bytes1(value1)) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if ((value1 & 0xff) != 0x0) { } else { value2 = 0; } uint256 value3 = unresolved_7c3f33d6 + (value2 * unresolved_e4441769); if ((unresolved_7c3f33d6 + (value2 * unresolved_e4441769)) > 0x38) { value3 = 0x38; } uint256 value4 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> value3; if (!(value3 < 0x100)) { value4 = 0; } if ((block.timestamp <= stor_f) && (stor_e > value4)) { return abi.encodePacked(!(var_a > stor_e), var_a, stor_e); } else { return abi.encodePacked(!(var_a > value4), var_a, value4); } } function status(address arg0) public view { if (!(msg.value)) { uint256 var_a; if (((var_a + 0x02e0) > 0xffffffffffffffff) | ((var_a + 0x02e0) < var_a)) _desolexPanic(65); var_a = var_a + 0x02e0; if (((var_a + 0xc0) > 0xffffffffffffffff) | ((var_a + 0xc0) < var_a)) _desolexPanic(65); var_a = var_a + 0xc0; if (((var_a + 0x80) > 0xffffffffffffffff) | ((var_a + 0x80) < var_a)) _desolexPanic(65); var_a = var_a + 0x80; uint256 value0 = 0x2710; if (stor_a < 0x2710) { value0 = stor_a + 0x01; } uint256 value1 = 0x01; if (!(value0 <= 0x01f4)) { value1 = (0x02 + ((value0 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } uint256 value2 = (bytes1(value1)) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if ((value1 & 0xff) != 0x0) { } else { value2 = 0; } uint256 value3 = unresolved_7c3f33d6 + (value2 * unresolved_e4441769); if ((unresolved_7c3f33d6 + (value2 * unresolved_e4441769)) > 0x38) { value3 = 0x38; } uint256 value4 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> value3; if (!(value3 < 0x100)) { value4 = 0; } if ((block.timestamp <= stor_f) && (stor_e > value4)) { uint256 value5 = 0x2710; if (stor_a < 0x2710) { value5 = stor_a + 0x01; } uint256 value6 = 0x01; if (!(value5 <= 0x01f4)) { value6 = (0x02 + ((value5 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } uint256 value7 = (bytes1(value6)) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if ((value6 & 0xff) != 0x0) { } else { value7 = 0; } uint256 value8 = unresolved_7c3f33d6 + (value7 * unresolved_e4441769); if ((unresolved_7c3f33d6 + (value7 * unresolved_e4441769)) > 0x38) { value8 = 0x38; } uint256 value9 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> value8; if (!(value8 < 0x100)) { value9 = 0; } if ((block.timestamp <= stor_f) && (stor_e > value9)) { if (((var_a + 0xc0) > 0xffffffffffffffff) | ((var_a + 0xc0) < var_a)) _desolexPanic(65); var_a = var_a + 0xc0; uint256 value10 = 0x2710; if (stor_a < 0x2710) { value10 = stor_a + 0x01; } uint256 value11 = 0x01; if (!(value10 <= 0x1f4)) { value11 = (0x02 + ((value10 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } } else { if (((var_a + 0xc0) > 0xffffffffffffffff) | ((var_a + 0xc0) < var_a)) _desolexPanic(65); var_a = var_a + 0xc0; uint256 value12 = 0x2710; if (stor_a < 0x2710) { value12 = stor_a + 0x01; } uint256 value13 = 0x01; if (!(value12 <= 0x1f4)) { value13 = (0x02 + ((value12 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } uint256 value14 = (bytes1(value13)) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if ((value13 & 0xff) != 0x0) { } else { value14 = 0; } if ((unresolved_7c3f33d6 + (value14 * unresolved_e4441769)) > 0x38) { if (stor_a - stor_b == 0) { if (((var_a + 0xc0) > 0xffffffffffffffff) | ((var_a + 0xc0) < var_a)) _desolexPanic(65); var_a = var_a + 0xc0; uint256 value17 = 0x01; if ((stor_a + 0x01) > 0x01f4) { value17 = (0x02 + (((stor_a + 0x01) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } } else { if (((var_a + 0xc0) > 0xffffffffffffffff) | ((var_a + 0xc0) < var_a)) _desolexPanic(65); var_a = var_a + 0xc0; uint256 value18 = 0x01; if ((stor_a + 0x01) > 0x01f4) { value18 = (0x02 + (((stor_a + 0x01) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } } } else if (stor_a - stor_b != 0) { if (((var_a + 0xc0) > 0xffffffffffffffff) | ((var_a + 0xc0) < var_a)) _desolexPanic(65); var_a = var_a + 0xc0; uint256 value16 = 0x01; if ((stor_a + 0x01) > 0x01f4) { value16 = (0x02 + (((stor_a + 0x01) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } } else { if (((var_a + 0xc0) > 0xffffffffffffffff) | ((var_a + 0xc0) < var_a)) _desolexPanic(65); var_a = var_a + 0xc0; uint256 value15 = 0x01; if ((stor_a + 0x01) > 0x01f4) { value15 = (0x02 + (((stor_a + 0x01) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } } if (miningOpen) { if (0x2710 <= stor_a) { } } else { } if (((var_a + 0x80) > 0xffffffffffffffff) | ((var_a + 0x80) < var_a)) _desolexPanic(65); var_a = var_a + 0x80; } } else { uint256 value19 = 0x2710; if (stor_a < 0x2710) { value19 = stor_a + 0x01; } uint256 value20 = 0x01; if (!(value19 <= 0x01f4)) { value20 = (0x02 + ((value19 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } uint256 value21 = (bytes1(value20)) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if ((value20 & 0xff) != 0x0) { } else { value21 = 0; } uint256 value22 = unresolved_7c3f33d6 + (value21 * unresolved_e4441769); if ((unresolved_7c3f33d6 + (value21 * unresolved_e4441769)) > 0x38) { value22 = 0x38; } uint256 value23 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> value22; if (!(value22 < 0x100)) { value23 = 0; } if ((block.timestamp <= stor_f) && (stor_e > value23)) { if (((var_a + 0xc0) > 0xffffffffffffffff) | ((var_a + 0xc0) < var_a)) _desolexPanic(65); var_a = var_a + 0xc0; uint256 value24 = 0x2710; if (stor_a < 0x2710) { value24 = stor_a + 0x01; } uint256 value25 = 0x01; if (!(value24 <= 0x1f4)) { value25 = (0x02 + ((value24 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } uint256 value26 = (bytes1(value25)) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if ((value25 & 0xff) != 0x0) { } else { value26 = 0; } if ((unresolved_7c3f33d6 + (value26 * unresolved_e4441769)) > 0x38) { if (stor_a - stor_b == 0) { if (((var_a + 0xc0) > 0xffffffffffffffff) | ((var_a + 0xc0) < var_a)) _desolexPanic(65); var_a = var_a + 0xc0; uint256 value29 = 0x01; if ((stor_a + 0x01) > 0x01f4) { value29 = (0x02 + (((stor_a + 0x01) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } } else { if (((var_a + 0xc0) > 0xffffffffffffffff) | ((var_a + 0xc0) < var_a)) _desolexPanic(65); var_a = var_a + 0xc0; uint256 value30 = 0x01; if ((stor_a + 0x01) > 0x01f4) { value30 = (0x02 + (((stor_a + 0x01) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } } } else if (stor_a - stor_b != 0) { if (((var_a + 0xc0) > 0xffffffffffffffff) | ((var_a + 0xc0) < var_a)) _desolexPanic(65); var_a = var_a + 0xc0; uint256 value28 = 0x01; if ((stor_a + 0x01) > 0x01f4) { value28 = (0x02 + (((stor_a + 0x01) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } } else { if (((var_a + 0xc0) > 0xffffffffffffffff) | ((var_a + 0xc0) < var_a)) _desolexPanic(65); var_a = var_a + 0xc0; uint256 value27 = 0x01; if ((stor_a + 0x01) > 0x01f4) { value27 = (0x02 + (((stor_a + 0x01) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } } } else { if (((var_a + 0xc0) > 0xffffffffffffffff) | ((var_a + 0xc0) < var_a)) _desolexPanic(65); var_a = var_a + 0xc0; uint256 value31 = 0x2710; if (stor_a < 0x2710) { value31 = stor_a + 0x01; } uint256 value32 = 0x01; if (!(value31 <= 0x1f4)) { value32 = (0x02 + ((value31 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } uint256 value33 = (bytes1(value32)) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if ((value32 & 0xff) != 0x0) { } else { value33 = 0; } if ((unresolved_7c3f33d6 + (value33 * unresolved_e4441769)) > 0x38) { if (stor_a - stor_b == 0) { if (((var_a + 0xc0) > 0xffffffffffffffff) | ((var_a + 0xc0) < var_a)) _desolexPanic(65); var_a = var_a + 0xc0; uint256 value36 = 0x01; if ((stor_a + 0x01) > 0x01f4) { value36 = (0x02 + (((stor_a + 0x01) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } } else { if (((var_a + 0xc0) > 0xffffffffffffffff) | ((var_a + 0xc0) < var_a)) _desolexPanic(65); var_a = var_a + 0xc0; uint256 value37 = 0x01; if ((stor_a + 0x01) > 0x01f4) { value37 = (0x02 + (((stor_a + 0x01) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } } } else if (stor_a - stor_b != 0) { if (((var_a + 0xc0) > 0xffffffffffffffff) | ((var_a + 0xc0) < var_a)) _desolexPanic(65); var_a = var_a + 0xc0; uint256 value35 = 0x01; if ((stor_a + 0x01) > 0x01f4) { value35 = (0x02 + (((stor_a + 0x01) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } } else { if (((var_a + 0xc0) > 0xffffffffffffffff) | ((var_a + 0xc0) < var_a)) _desolexPanic(65); var_a = var_a + 0xc0; uint256 value34 = 0x01; if ((stor_a + 0x01) > 0x01f4) { value34 = (0x02 + (((stor_a + 0x01) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } } } if (miningOpen) { if (0x2710 <= stor_a) { } } else { } if (((var_a + 0x80) > 0xffffffffffffffff) | ((var_a + 0x80) < var_a)) _desolexPanic(65); } } } function bnbUsd() public returns (bytes memory) { uint256 var_c; if (((var_c + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); (bool success0, bytes memory returnData0) = address(0x0567f2323251f0aab15c8dfb1967e4e8a7d42aee).latestRoundData{ gas: 0x030d40 }(); // staticcall uint256 value0 = 0x60; if ((returnData0.length) != 0x0) { if (returnData0.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_c + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value0 = var_c; } bool flag0 = var_e < 0xa0; if (!success0) { flag0 = !success0; } uint256 value2 = 0; uint256 value3 = 0; uint256 value4 = 0; if (!(flag0)) { require(((value0 + var_e) - value0) >= 0xa0); uint256 value11 = 0; uint256 value12 = 0; uint256 value13 = 0; if (var_f > 0) { uint256 value1 = (var_f * 0x05f5e100) / (0x0a ** 0x08); if (((var_f * 0x05f5e100) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (var_f * 0x05f5e100) == (((var_f * 0x05f5e100) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (var_f * 0x05f5e100))) { } else { uint256 sharedExpr15 = (0x0a ** 0x08) & (0 - (0x0a ** 0x08)); uint256 sharedExpr16 = 0x03 * ((0x0a ** 0x08) / sharedExpr15); uint256 sharedExpr17 = 0x02 - (((0x0a ** 0x08) / sharedExpr15) * (sharedExpr16 ^ 0x02)); uint256 sharedExpr18 = sharedExpr16 ^ 0x02; uint256 sharedExpr19 = 0x02 - (((0x0a ** 0x08) / sharedExpr15) * (sharedExpr17 * sharedExpr18)); uint256 sharedExpr20 = sharedExpr17 * sharedExpr18; uint256 sharedExpr21 = 0x02 - (((0x0a ** 0x08) / sharedExpr15) * (sharedExpr19 * sharedExpr20)); uint256 sharedExpr22 = sharedExpr19 * sharedExpr20; uint256 sharedExpr23 = 0x02 - (((0x0a ** 0x08) / sharedExpr15) * (sharedExpr21 * sharedExpr22)); uint256 sharedExpr24 = sharedExpr21 * sharedExpr22; uint256 sharedExpr25 = 0x02 - (((0x0a ** 0x08) / sharedExpr15) * (sharedExpr23 * sharedExpr24)); uint256 sharedExpr26 = sharedExpr23 * sharedExpr24; uint256 sharedExpr27 = var_f; uint256 sharedExpr28 = 0x0a ** 0x08; uint256 sharedExpr29 = (0x0a ** 0x08) & (0 - (0x0a ** 0x08)); uint256 sharedExpr30 = 0x03 * ((0x0a ** 0x08) / sharedExpr29); uint256 sharedExpr31 = 0x02 - (((0x0a ** 0x08) / sharedExpr29) * (sharedExpr30 ^ 0x02)); uint256 sharedExpr32 = sharedExpr30 ^ 0x02; uint256 sharedExpr33 = 0x02 - (((0x0a ** 0x08) / sharedExpr29) * (sharedExpr31 * sharedExpr32)); uint256 sharedExpr34 = sharedExpr31 * sharedExpr32; uint256 sharedExpr35 = 0x02 - (((0x0a ** 0x08) / sharedExpr29) * (sharedExpr33 * sharedExpr34)); uint256 sharedExpr36 = sharedExpr33 * sharedExpr34; uint256 sharedExpr37 = 0x02 - (((0x0a ** 0x08) / sharedExpr29) * (sharedExpr35 * sharedExpr36)); uint256 sharedExpr38 = sharedExpr35 * sharedExpr36; uint256 sharedExpr39 = 0x02 - (((0x0a ** 0x08) / sharedExpr29) * (sharedExpr37 * sharedExpr38)); uint256 sharedExpr40 = sharedExpr37 * sharedExpr38; uint256 sharedExpr41 = ((var_f * 0x05f5e100) - ((var_f * 0x05f5e100) % (0x0a ** 0x08)) / ((0x0a ** 0x08) & (0 - (0x0a ** 0x08))) | (((var_f * 0x05f5e100) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (var_f * 0x05f5e100) - (((var_f * 0x05f5e100) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (var_f * 0x05f5e100)) - ((var_f * 0x05f5e100) % (0x0a ** 0x08) > (var_f * 0x05f5e100)) * ((0 - ((0x0a ** 0x08) & (0 - (0x0a ** 0x08)))) / ((0x0a ** 0x08) & (0 - (0x0a ** 0x08))) + 0x01))) * ((0x02 - (((0x0a ** 0x08) / sharedExpr29) * (sharedExpr39 * sharedExpr40))) * (sharedExpr39 * sharedExpr40)); value1 = sharedExpr41; } value11 = var_g; value12 = value1; value13 = 0x01; } value2 = value11; value3 = value12; value4 = value13; } bool value5 = !(value2 > block.timestamp); if (value4 == 0) { value5 = (value4 != 0x0) ? 1 : 0; } uint256 value6 = 0; if (value5 != 0x0) { } else { value6 = value2; } if ((value5 != 0x0) && (0xe10 >= block.timestamp - value2)) { return abi.encodePacked(value3, 0x01); } else { uint256 value10 = 0; if (((var_c + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); (bool success1, bytes memory returnData1) = address(0x16b9a82891338f9ba80e2d6970fdda79d1eb0dae).getReserves{ gas: 0x030d40 }(); // staticcall uint256 value7 = 0x60; if ((returnData1.length) != 0x0) { if (returnData1.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_c + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData1.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData1.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData1.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value7 = var_c; } bool flag2 = var_j < 0x60; if (!success1) { flag2 = !success1; } uint256 value14 = 0; if (!(flag2)) { require(((value7 + var_j) - value7) >= 0x60); uint256 value8 = var_k; uint256 value9 = var_l; bool flag3 = value8 == 0x0; if (value9 == 0) { flag3 = value9 == 0x0; } bool flag4 = value9 > 0xffffffffffffffffffffffffffff; if (flag3) { flag4 = flag3; } uint256 value15 = 0; if (((flag4) && (value8 > 0xffffffffffffffffffffffffffff)) || (flag4)) { uint256 value16 = (value8 * (0x0a ** 0x1a)) / (value9 * (0x0a ** 0x12)); if (((value8 * (0x0a ** 0x1a)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (value8 * (0x0a ** 0x1a)) == (((value8 * (0x0a ** 0x1a)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (value8 * (0x0a ** 0x1a)))) { } else { uint256 sharedExpr63 = 0x0a ** 0x1a; uint256 sharedExpr64 = 0x0a ** 0x1a; uint256 sharedExpr65 = 0x0a ** 0x12; uint256 sharedExpr66 = value9 * (0x0a ** 0x12); uint256 sharedExpr67 = sharedExpr66; uint256 sharedExpr68 = sharedExpr66; uint256 sharedExpr69 = 0 - sharedExpr66; uint256 sharedExpr70 = 0x0a ** 0x1a; uint256 sharedExpr71 = sharedExpr66; uint256 sharedExpr72 = sharedExpr68 & sharedExpr69; uint256 sharedExpr73 = 0x03 * (sharedExpr71 / sharedExpr72); uint256 sharedExpr74 = 0x02 - ((sharedExpr71 / sharedExpr72) * (sharedExpr73 ^ 0x02)); uint256 sharedExpr75 = sharedExpr73 ^ 0x02; uint256 sharedExpr76 = 0x02 - ((sharedExpr71 / sharedExpr72) * (sharedExpr74 * sharedExpr75)); uint256 sharedExpr77 = sharedExpr74 * sharedExpr75; uint256 sharedExpr78 = 0x02 - ((sharedExpr71 / sharedExpr72) * (sharedExpr76 * sharedExpr77)); uint256 sharedExpr79 = sharedExpr76 * sharedExpr77; uint256 sharedExpr80 = 0x02 - ((sharedExpr71 / sharedExpr72) * (sharedExpr78 * sharedExpr79)); uint256 sharedExpr81 = sharedExpr78 * sharedExpr79; uint256 sharedExpr82 = 0x02 - ((sharedExpr71 / sharedExpr72) * (sharedExpr80 * sharedExpr81)); uint256 sharedExpr83 = sharedExpr80 * sharedExpr81; uint256 sharedExpr84 = 0x0a ** 0x1a; uint256 sharedExpr85 = 0x0a ** 0x1a; uint256 sharedExpr86 = 0x0a ** 0x12; uint256 sharedExpr87 = value9 * (0x0a ** 0x12); uint256 sharedExpr88 = sharedExpr87; uint256 sharedExpr89 = sharedExpr87; uint256 sharedExpr90 = 0 - sharedExpr87; uint256 sharedExpr91 = 0x0a ** 0x1a; uint256 sharedExpr92 = sharedExpr87; uint256 sharedExpr93 = sharedExpr89 & sharedExpr90; uint256 sharedExpr94 = 0x03 * (sharedExpr92 / sharedExpr93); uint256 sharedExpr95 = 0x02 - ((sharedExpr92 / sharedExpr93) * (sharedExpr94 ^ 0x02)); uint256 sharedExpr96 = sharedExpr94 ^ 0x02; uint256 sharedExpr97 = 0x02 - ((sharedExpr92 / sharedExpr93) * (sharedExpr95 * sharedExpr96)); uint256 sharedExpr98 = sharedExpr95 * sharedExpr96; uint256 sharedExpr99 = 0x02 - ((sharedExpr92 / sharedExpr93) * (sharedExpr97 * sharedExpr98)); uint256 sharedExpr100 = sharedExpr97 * sharedExpr98; uint256 sharedExpr101 = 0x02 - ((sharedExpr92 / sharedExpr93) * (sharedExpr99 * sharedExpr100)); uint256 sharedExpr102 = sharedExpr99 * sharedExpr100; uint256 sharedExpr103 = 0x02 - ((sharedExpr92 / sharedExpr93) * (sharedExpr101 * sharedExpr102)); uint256 sharedExpr104 = sharedExpr101 * sharedExpr102; value16 = ((value8 * sharedExpr84) - ((value8 * sharedExpr85) % sharedExpr88) / (sharedExpr89 & sharedExpr90) | (((value8 * sharedExpr91) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (value8 * sharedExpr84) - (((value8 * sharedExpr91) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (value8 * sharedExpr84)) - (((value8 * sharedExpr85) % sharedExpr88) > (value8 * sharedExpr84)) * ((0 - (sharedExpr89 & sharedExpr90)) / (sharedExpr89 & sharedExpr90) + 0x01))) * ((0x02 - ((sharedExpr92 / sharedExpr93) * (sharedExpr103 * sharedExpr104))) * (sharedExpr103 * sharedExpr104)); } value15 = value16; } value14 = value15; } value10 = value14; if (value10 != 0x0) { return abi.encodePacked(value10, 0x02); } else { if (value4 != 0x0) { return abi.encodePacked(value3, 0x03); } else { return abi.encodePacked(lastGoodPrice, 0x04); } } } } function isAgentHolder(address account) public returns (bool) { if (agentRegistry) { (bool success0, bytes memory returnData0) = agentRegistry.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), account)); // staticcall balanceOf if (!(success0)) { if (!(success0)) { return false; } return false; } uint256 value0 = returnData0.length; if (0x20 <= returnData0.length) { value0 = 0x20; } uint256 var_c; if (((var_c + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((value0 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_c + value0) - var_c) >= 0x20); if (!(success0)) { return false; } return var_c.length; } return true; } function setBaseURI(string memory arg0) public { require((arg0 + 0x23) < msg.data.length); require(((arg0 + arg0) + 0x24) <= msg.data.length); require(msg.sender == owner, OwnableUnauthorizedAccount()); require(!metadataFrozen, FrozenMetadata()); uint256 value0 = (0x7f) & (stor_12 >> 0x01); if (stor_12 & (0x01)) { value0 = stor_12 >> 0x01; } if (!((value0 < 0x20) != (stor_12 & 0x01))) _desolexPanic(34); uint256 value3 = var_a + ((0x1f + value0) >> 0x05); if (value0 > 0x1f) { var_a = var_a; uint256 value1 = var_a; if (arg0.length < 0x20) { var_a = var_a; } else { value1 = var_a + ((arg0.length + 0x1f) >> 0x05); } uint256 value2 = value1; while (true) { var_a = var_a; if (value2 >= (var_a + ((0x1f + value0) >> 0x05))) { break; } stor_expr_bo = 0; value2 = 0x01 + value2; } } else { value3 = value0; } if (!(0x01 == (arg0.length > 0x1f))) { uint256 value4 = msg.data[0] >> 0xe0; uint256 value5 = msg.data[(arg0 + 0) + 0x24]; if (!(arg0)) { value4 = 0; value5 = 0; } stor_12 = (~(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> (arg0.length << 0x03)) & value5) | (arg0.length << 0x01); emit BaseURIChanged(0x20, (arg0)); } uint256 value6 = 0; uint256 value7 = 0; uint256 value8 = var_a; while (true) { if (!(value6 < (arg0.length & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)))) { uint256 value9 = msg.data[0] >> 0xe0; uint256 value10 = msg.data[0] >> 0xe0; if ((arg0.length & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)) < arg0) { stor_expr_bp = (~(0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> (0xf8 & (arg0.length << 0x03)))) & (msg.data[0x24 + (arg0 + value7)]); } else { value9 = value7; value10 = value8; } stor_12 = (arg0.length << 0x01) + 0x01; emit BaseURIChanged(0x20, (arg0)); } stor_expr_bp = msg.data[(arg0 + value7) + 0x24]; value6 = value6 + 0x20; value7 = value7 + 0x20; value8 = value8 + 0x01; } } function paidQuote(address arg0, uint256 arg1) public returns (bytes memory) { uint256 var_c; if (((var_c + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); (bool success0, bytes memory returnData0) = address(0x0567f2323251f0aab15c8dfb1967e4e8a7d42aee).latestRoundData{ gas: 0x030d40 }(); // staticcall uint256 value0 = 0x60; if ((returnData0.length) != 0x0) { if (returnData0.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_c + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value0 = var_c; } bool flag0 = var_e < 0xa0; if (!success0) { flag0 = !success0; } uint256 value2 = 0; uint256 value3 = 0; uint256 value4 = 0; if (!(flag0)) { require(((value0 + var_e) - value0) >= 0xa0); uint256 value46 = 0; uint256 value47 = 0; uint256 value48 = 0; if (var_f > 0) { uint256 value1 = (var_f * 0x05f5e100) / (0x0a ** 0x08); if (((var_f * 0x05f5e100) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (var_f * 0x05f5e100) == (((var_f * 0x05f5e100) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (var_f * 0x05f5e100))) { } else { uint256 sharedExpr15 = (0x0a ** 0x08) & (0 - (0x0a ** 0x08)); uint256 sharedExpr16 = 0x03 * ((0x0a ** 0x08) / sharedExpr15); uint256 sharedExpr17 = 0x02 - (((0x0a ** 0x08) / sharedExpr15) * (sharedExpr16 ^ 0x02)); uint256 sharedExpr18 = sharedExpr16 ^ 0x02; uint256 sharedExpr19 = 0x02 - (((0x0a ** 0x08) / sharedExpr15) * (sharedExpr17 * sharedExpr18)); uint256 sharedExpr20 = sharedExpr17 * sharedExpr18; uint256 sharedExpr21 = 0x02 - (((0x0a ** 0x08) / sharedExpr15) * (sharedExpr19 * sharedExpr20)); uint256 sharedExpr22 = sharedExpr19 * sharedExpr20; uint256 sharedExpr23 = 0x02 - (((0x0a ** 0x08) / sharedExpr15) * (sharedExpr21 * sharedExpr22)); uint256 sharedExpr24 = sharedExpr21 * sharedExpr22; uint256 sharedExpr25 = 0x02 - (((0x0a ** 0x08) / sharedExpr15) * (sharedExpr23 * sharedExpr24)); uint256 sharedExpr26 = sharedExpr23 * sharedExpr24; uint256 sharedExpr27 = var_f; uint256 sharedExpr28 = 0x0a ** 0x08; uint256 sharedExpr29 = (0x0a ** 0x08) & (0 - (0x0a ** 0x08)); uint256 sharedExpr30 = 0x03 * ((0x0a ** 0x08) / sharedExpr29); uint256 sharedExpr31 = 0x02 - (((0x0a ** 0x08) / sharedExpr29) * (sharedExpr30 ^ 0x02)); uint256 sharedExpr32 = sharedExpr30 ^ 0x02; uint256 sharedExpr33 = 0x02 - (((0x0a ** 0x08) / sharedExpr29) * (sharedExpr31 * sharedExpr32)); uint256 sharedExpr34 = sharedExpr31 * sharedExpr32; uint256 sharedExpr35 = 0x02 - (((0x0a ** 0x08) / sharedExpr29) * (sharedExpr33 * sharedExpr34)); uint256 sharedExpr36 = sharedExpr33 * sharedExpr34; uint256 sharedExpr37 = 0x02 - (((0x0a ** 0x08) / sharedExpr29) * (sharedExpr35 * sharedExpr36)); uint256 sharedExpr38 = sharedExpr35 * sharedExpr36; uint256 sharedExpr39 = 0x02 - (((0x0a ** 0x08) / sharedExpr29) * (sharedExpr37 * sharedExpr38)); uint256 sharedExpr40 = sharedExpr37 * sharedExpr38; uint256 sharedExpr41 = ((var_f * 0x05f5e100) - ((var_f * 0x05f5e100) % (0x0a ** 0x08)) / ((0x0a ** 0x08) & (0 - (0x0a ** 0x08))) | (((var_f * 0x05f5e100) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (var_f * 0x05f5e100) - (((var_f * 0x05f5e100) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (var_f * 0x05f5e100)) - ((var_f * 0x05f5e100) % (0x0a ** 0x08) > (var_f * 0x05f5e100)) * ((0 - ((0x0a ** 0x08) & (0 - (0x0a ** 0x08)))) / ((0x0a ** 0x08) & (0 - (0x0a ** 0x08))) + 0x01))) * ((0x02 - (((0x0a ** 0x08) / sharedExpr29) * (sharedExpr39 * sharedExpr40))) * (sharedExpr39 * sharedExpr40)); value1 = sharedExpr41; } value46 = var_g; value47 = value1; value48 = 0x01; } value2 = value46; value3 = value47; value4 = value48; } bool value5 = !(value2 > block.timestamp); if (value4 == 0) { value5 = (value4 != 0x0) ? 1 : 0; } uint256 value6 = 0; if (value5 != 0x0) { } else { value6 = value2; } if ((value5 != 0x0) && (0xe10 >= block.timestamp - value2)) { uint256 value7 = 0; bool flag2 = 0x0 < arg1; uint256 value8 = 0; uint256 value9 = 0; uint256 value10 = 0; uint256 value11 = 0; uint256 value12 = 0; uint256 value14 = 0; while (true) { uint256 value13 = value12; if (!(flag2)) { value13 = value7; } if (!(flag2 && value7 < 0x14)) { return abi.encodePacked(value10, value14, value8, value3); break; } if (stor_a > (stor_a + 0x01)) { _desolexPanic(17); break; } if ((stor_a + 0x01) > ((stor_a + 0x01) + value12)) { _desolexPanic(17); break; } if (((stor_a + 0x01) + value12) > 0x2710) { return abi.encodePacked(value10, value14, value8, value3); break; } uint256 value15 = 0x01; if (!(((stor_a + 0x01) + value12) <= 0x01f4)) { value15 = (0x02 + ((((stor_a + 0x01) + value12) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } if ((value15 & 0xff) == 0x1) { return abi.encodePacked(value10, value14, value8, value3); break; } uint256 value16 = 0; uint256 value17 = unresolved_337900e0[arg0][bytes1(value15)]; uint256 value18 = bytes1(value15); if ((value15 & 0xff) != value9) { } else { value16 = bytes1(value15); value17 = value11; value18 = value9; } if (value17 >= 0x14) { return abi.encodePacked(value10, value14, value8, value3); break; } if (value17 == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) { _desolexPanic(17); break; } if (value10 == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) { _desolexPanic(17); break; } uint256 value19 = 0x01; if (((stor_a + 0x01) + value12) > 0x01f4) { value19 = (0x02 + ((((stor_a + 0x01) + value12) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } if ((value19 & 0xff) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff > 0xff) { _desolexPanic(17); break; } if (!(0x989680 * ((value19 & 0xff) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0xff) / 0x989680 == ((value19 & 0xff) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0xff) || 0x989680 == 0x0)) { _desolexPanic(17); break; } if (value14 > value14 + 0x989680 * ((value19 & 0xff) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0xff)) { _desolexPanic(17); break; } uint256 value20 = ((0x989680 * (bytes1(value19 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) / value3; if ((((0x989680 * (bytes1(value19 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - ((0x989680 * (bytes1(value19 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) == ((((0x989680 * (bytes1(value19 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < ((0x989680 * (bytes1(value19 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000))) { } else { uint256 sharedExpr58 = bytes1(value19 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); uint256 sharedExpr59 = 0x989680 * sharedExpr58; uint256 sharedExpr60 = 0x989680 * sharedExpr58; uint256 sharedExpr61 = 0x989680 * sharedExpr58; uint256 sharedExpr62 = value3 & (0 - value3); uint256 sharedExpr63 = 0x03 * (value3 / sharedExpr62); uint256 sharedExpr64 = 0x02 - ((value3 / sharedExpr62) * (sharedExpr63 ^ 0x02)); uint256 sharedExpr65 = sharedExpr63 ^ 0x02; uint256 sharedExpr66 = 0x02 - ((value3 / sharedExpr62) * (sharedExpr64 * sharedExpr65)); uint256 sharedExpr67 = sharedExpr64 * sharedExpr65; uint256 sharedExpr68 = 0x02 - ((value3 / sharedExpr62) * (sharedExpr66 * sharedExpr67)); uint256 sharedExpr69 = sharedExpr66 * sharedExpr67; uint256 sharedExpr70 = 0x02 - ((value3 / sharedExpr62) * (sharedExpr68 * sharedExpr69)); uint256 sharedExpr71 = sharedExpr68 * sharedExpr69; uint256 sharedExpr72 = 0x02 - ((value3 / sharedExpr62) * (sharedExpr70 * sharedExpr71)); uint256 sharedExpr73 = sharedExpr70 * sharedExpr71; uint256 sharedExpr74 = bytes1(value19 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); uint256 sharedExpr75 = 0x989680 * sharedExpr74; uint256 sharedExpr76 = 0x989680 * sharedExpr74; uint256 sharedExpr77 = 0x989680 * sharedExpr74; uint256 sharedExpr78 = value3 & (0 - value3); uint256 sharedExpr79 = 0x03 * (value3 / sharedExpr78); uint256 sharedExpr80 = 0x02 - ((value3 / sharedExpr78) * (sharedExpr79 ^ 0x02)); uint256 sharedExpr81 = sharedExpr79 ^ 0x02; uint256 sharedExpr82 = 0x02 - ((value3 / sharedExpr78) * (sharedExpr80 * sharedExpr81)); uint256 sharedExpr83 = sharedExpr80 * sharedExpr81; uint256 sharedExpr84 = 0x02 - ((value3 / sharedExpr78) * (sharedExpr82 * sharedExpr83)); uint256 sharedExpr85 = sharedExpr82 * sharedExpr83; uint256 sharedExpr86 = 0x02 - ((value3 / sharedExpr78) * (sharedExpr84 * sharedExpr85)); uint256 sharedExpr87 = sharedExpr84 * sharedExpr85; uint256 sharedExpr88 = 0x02 - ((value3 / sharedExpr78) * (sharedExpr86 * sharedExpr87)); uint256 sharedExpr89 = sharedExpr86 * sharedExpr87; value20 = ((sharedExpr75 * 0x0de0b6b3a7640000) - ((sharedExpr76 * 0x0de0b6b3a7640000) % value3) / (value3 & (0 - value3)) | (((sharedExpr77 * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (sharedExpr75 * 0x0de0b6b3a7640000) - (((sharedExpr77 * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (sharedExpr75 * 0x0de0b6b3a7640000)) - (((sharedExpr76 * 0x0de0b6b3a7640000) % value3) > (sharedExpr75 * 0x0de0b6b3a7640000)) * ((0 - (value3 & (0 - value3))) / (value3 & (0 - value3)) + 0x01))) * ((0x02 - ((value3 / sharedExpr78) * (sharedExpr88 * sharedExpr89))) * (sharedExpr88 * sharedExpr89)); } if (value3 == 0x0) { _desolexPanic(18); break; } if (value20 > (value20 + (!(!(((0x989680 * (bytes1(value19 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) % value3))))) { _desolexPanic(17); break; } if (value8 > (value8 + (value20 + (!(!(((0x989680 * (bytes1(value19 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) % value3)))))) { _desolexPanic(17); break; } if (value12 == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) { _desolexPanic(17); break; } value7 = 0x01 + value12; flag2 = (0x01 + value12) < arg1; value8 = value8 + (value20 + (!(!(((0x989680 * (bytes1(value19 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) % value3)))); value9 = value18; value10 = 0x01 + value10; value11 = 0x01 + value17; value12 = 0x01 + value12; value14 = value14 + (0x989680 * (bytes1(value19 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))); } } else { uint256 value24 = 0; if (((var_c + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); (bool success1, bytes memory returnData1) = address(0x16b9a82891338f9ba80e2d6970fdda79d1eb0dae).getReserves{ gas: 0x030d40 }(); // staticcall uint256 value21 = 0x60; if ((returnData1.length) != 0x0) { if (returnData1.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_c + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData1.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_c + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData1.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_c)) _desolexPanic(65); var_c = var_c + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData1.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value21 = var_c; } bool flag4 = var_n < 0x60; if (!success1) { flag4 = !success1; } uint256 value49 = 0; if (!(flag4)) { require(((value21 + var_n) - value21) >= 0x60); uint256 value22 = var_o; uint256 value23 = var_p; bool flag5 = value22 == 0x0; if (value23 == 0) { flag5 = value23 == 0x0; } bool flag6 = value23 > 0xffffffffffffffffffffffffffff; if (flag5) { flag6 = flag5; } uint256 value50 = 0; if (((flag6) && (value22 > 0xffffffffffffffffffffffffffff)) || (flag6)) { uint256 value51 = (value22 * (0x0a ** 0x1a)) / (value23 * (0x0a ** 0x12)); if (((value22 * (0x0a ** 0x1a)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (value22 * (0x0a ** 0x1a)) == (((value22 * (0x0a ** 0x1a)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (value22 * (0x0a ** 0x1a)))) { } else { uint256 sharedExpr111 = 0x0a ** 0x1a; uint256 sharedExpr112 = 0x0a ** 0x1a; uint256 sharedExpr113 = 0x0a ** 0x12; uint256 sharedExpr114 = value23 * (0x0a ** 0x12); uint256 sharedExpr115 = sharedExpr114; uint256 sharedExpr116 = sharedExpr114; uint256 sharedExpr117 = 0 - sharedExpr114; uint256 sharedExpr118 = 0x0a ** 0x1a; uint256 sharedExpr119 = sharedExpr114; uint256 sharedExpr120 = sharedExpr116 & sharedExpr117; uint256 sharedExpr121 = 0x03 * (sharedExpr119 / sharedExpr120); uint256 sharedExpr122 = 0x02 - ((sharedExpr119 / sharedExpr120) * (sharedExpr121 ^ 0x02)); uint256 sharedExpr123 = sharedExpr121 ^ 0x02; uint256 sharedExpr124 = 0x02 - ((sharedExpr119 / sharedExpr120) * (sharedExpr122 * sharedExpr123)); uint256 sharedExpr125 = sharedExpr122 * sharedExpr123; uint256 sharedExpr126 = 0x02 - ((sharedExpr119 / sharedExpr120) * (sharedExpr124 * sharedExpr125)); uint256 sharedExpr127 = sharedExpr124 * sharedExpr125; uint256 sharedExpr128 = 0x02 - ((sharedExpr119 / sharedExpr120) * (sharedExpr126 * sharedExpr127)); uint256 sharedExpr129 = sharedExpr126 * sharedExpr127; uint256 sharedExpr130 = 0x02 - ((sharedExpr119 / sharedExpr120) * (sharedExpr128 * sharedExpr129)); uint256 sharedExpr131 = sharedExpr128 * sharedExpr129; uint256 sharedExpr132 = 0x0a ** 0x1a; uint256 sharedExpr133 = 0x0a ** 0x1a; uint256 sharedExpr134 = 0x0a ** 0x12; uint256 sharedExpr135 = value23 * (0x0a ** 0x12); uint256 sharedExpr136 = sharedExpr135; uint256 sharedExpr137 = sharedExpr135; uint256 sharedExpr138 = 0 - sharedExpr135; uint256 sharedExpr139 = 0x0a ** 0x1a; uint256 sharedExpr140 = sharedExpr135; uint256 sharedExpr141 = sharedExpr137 & sharedExpr138; uint256 sharedExpr142 = 0x03 * (sharedExpr140 / sharedExpr141); uint256 sharedExpr143 = 0x02 - ((sharedExpr140 / sharedExpr141) * (sharedExpr142 ^ 0x02)); uint256 sharedExpr144 = sharedExpr142 ^ 0x02; uint256 sharedExpr145 = 0x02 - ((sharedExpr140 / sharedExpr141) * (sharedExpr143 * sharedExpr144)); uint256 sharedExpr146 = sharedExpr143 * sharedExpr144; uint256 sharedExpr147 = 0x02 - ((sharedExpr140 / sharedExpr141) * (sharedExpr145 * sharedExpr146)); uint256 sharedExpr148 = sharedExpr145 * sharedExpr146; uint256 sharedExpr149 = 0x02 - ((sharedExpr140 / sharedExpr141) * (sharedExpr147 * sharedExpr148)); uint256 sharedExpr150 = sharedExpr147 * sharedExpr148; uint256 sharedExpr151 = 0x02 - ((sharedExpr140 / sharedExpr141) * (sharedExpr149 * sharedExpr150)); uint256 sharedExpr152 = sharedExpr149 * sharedExpr150; value51 = ((value22 * sharedExpr132) - ((value22 * sharedExpr133) % sharedExpr136) / (sharedExpr137 & sharedExpr138) | (((value22 * sharedExpr139) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (value22 * sharedExpr132) - (((value22 * sharedExpr139) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (value22 * sharedExpr132)) - (((value22 * sharedExpr133) % sharedExpr136) > (value22 * sharedExpr132)) * ((0 - (sharedExpr137 & sharedExpr138)) / (sharedExpr137 & sharedExpr138) + 0x01))) * ((0x02 - ((sharedExpr140 / sharedExpr141) * (sharedExpr151 * sharedExpr152))) * (sharedExpr151 * sharedExpr152)); } value50 = value51; } value49 = value50; } value24 = value49; if (value24 != 0x0) { uint256 value7 = 0; bool flag2 = 0x0 < arg1; uint256 value8 = 0; uint256 value9 = 0; uint256 value10 = 0; uint256 value11 = 0; uint256 value12 = 0; uint256 value14 = 0; while (true) { uint256 value25 = value12; if (!(flag2)) { value25 = value7; } if (!(flag2 && value7 < 0x14)) { return abi.encodePacked(value10, value14, value8, value24); break; } if (stor_a > (stor_a + 0x01)) { _desolexPanic(17); break; } if ((stor_a + 0x01) > ((stor_a + 0x01) + value12)) { _desolexPanic(17); break; } if (((stor_a + 0x01) + value12) > 0x2710) { return abi.encodePacked(value10, value14, value8, value24); break; } uint256 value26 = 0x01; if (!(((stor_a + 0x01) + value12) <= 0x01f4)) { value26 = (0x02 + ((((stor_a + 0x01) + value12) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } if ((value26 & 0xff) == 0x1) { return abi.encodePacked(value10, value14, value8, value24); break; } uint256 value27 = 0; uint256 value28 = unresolved_337900e0[arg0][bytes1(value26)]; uint256 value29 = bytes1(value26); if ((value26 & 0xff) != value9) { } else { value27 = bytes1(value26); value28 = value11; value29 = value9; } if (value28 >= 0x14) { return abi.encodePacked(value10, value14, value8, value24); break; } if (value28 == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) { _desolexPanic(17); break; } if (value10 == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) { _desolexPanic(17); break; } uint256 value30 = 0x01; if (((stor_a + 0x01) + value12) > 0x01f4) { value30 = (0x02 + ((((stor_a + 0x01) + value12) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } if ((value30 & 0xff) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff > 0xff) { _desolexPanic(17); break; } if (!(0x989680 * ((value30 & 0xff) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0xff) / 0x989680 == ((value30 & 0xff) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0xff) || 0x989680 == 0x0)) { _desolexPanic(17); break; } if (value14 > value14 + 0x989680 * ((value30 & 0xff) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0xff)) { _desolexPanic(17); break; } uint256 value31 = ((0x989680 * (bytes1(value30 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) / value24; if ((((0x989680 * (bytes1(value30 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - ((0x989680 * (bytes1(value30 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) == ((((0x989680 * (bytes1(value30 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < ((0x989680 * (bytes1(value30 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000))) { } else { uint256 sharedExpr169 = bytes1(value30 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); uint256 sharedExpr170 = 0x989680 * sharedExpr169; uint256 sharedExpr171 = 0x989680 * sharedExpr169; uint256 sharedExpr172 = 0x989680 * sharedExpr169; uint256 sharedExpr173 = value24 & (0 - value24); uint256 sharedExpr174 = 0x03 * (value24 / sharedExpr173); uint256 sharedExpr175 = 0x02 - ((value24 / sharedExpr173) * (sharedExpr174 ^ 0x02)); uint256 sharedExpr176 = sharedExpr174 ^ 0x02; uint256 sharedExpr177 = 0x02 - ((value24 / sharedExpr173) * (sharedExpr175 * sharedExpr176)); uint256 sharedExpr178 = sharedExpr175 * sharedExpr176; uint256 sharedExpr179 = 0x02 - ((value24 / sharedExpr173) * (sharedExpr177 * sharedExpr178)); uint256 sharedExpr180 = sharedExpr177 * sharedExpr178; uint256 sharedExpr181 = 0x02 - ((value24 / sharedExpr173) * (sharedExpr179 * sharedExpr180)); uint256 sharedExpr182 = sharedExpr179 * sharedExpr180; uint256 sharedExpr183 = 0x02 - ((value24 / sharedExpr173) * (sharedExpr181 * sharedExpr182)); uint256 sharedExpr184 = sharedExpr181 * sharedExpr182; uint256 sharedExpr185 = bytes1(value30 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); uint256 sharedExpr186 = 0x989680 * sharedExpr185; uint256 sharedExpr187 = 0x989680 * sharedExpr185; uint256 sharedExpr188 = 0x989680 * sharedExpr185; uint256 sharedExpr189 = value24 & (0 - value24); uint256 sharedExpr190 = 0x03 * (value24 / sharedExpr189); uint256 sharedExpr191 = 0x02 - ((value24 / sharedExpr189) * (sharedExpr190 ^ 0x02)); uint256 sharedExpr192 = sharedExpr190 ^ 0x02; uint256 sharedExpr193 = 0x02 - ((value24 / sharedExpr189) * (sharedExpr191 * sharedExpr192)); uint256 sharedExpr194 = sharedExpr191 * sharedExpr192; uint256 sharedExpr195 = 0x02 - ((value24 / sharedExpr189) * (sharedExpr193 * sharedExpr194)); uint256 sharedExpr196 = sharedExpr193 * sharedExpr194; uint256 sharedExpr197 = 0x02 - ((value24 / sharedExpr189) * (sharedExpr195 * sharedExpr196)); uint256 sharedExpr198 = sharedExpr195 * sharedExpr196; uint256 sharedExpr199 = 0x02 - ((value24 / sharedExpr189) * (sharedExpr197 * sharedExpr198)); uint256 sharedExpr200 = sharedExpr197 * sharedExpr198; value31 = ((sharedExpr186 * 0x0de0b6b3a7640000) - ((sharedExpr187 * 0x0de0b6b3a7640000) % value24) / (value24 & (0 - value24)) | (((sharedExpr188 * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (sharedExpr186 * 0x0de0b6b3a7640000) - (((sharedExpr188 * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (sharedExpr186 * 0x0de0b6b3a7640000)) - (((sharedExpr187 * 0x0de0b6b3a7640000) % value24) > (sharedExpr186 * 0x0de0b6b3a7640000)) * ((0 - (value24 & (0 - value24))) / (value24 & (0 - value24)) + 0x01))) * ((0x02 - ((value24 / sharedExpr189) * (sharedExpr199 * sharedExpr200))) * (sharedExpr199 * sharedExpr200)); } if (value24 == 0x0) { _desolexPanic(18); break; } if (value31 > (value31 + (!(!(((0x989680 * (bytes1(value30 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) % value24))))) { _desolexPanic(17); break; } if (value8 > (value8 + (value31 + (!(!(((0x989680 * (bytes1(value30 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) % value24)))))) { _desolexPanic(17); break; } if (value12 == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) { _desolexPanic(17); break; } value7 = 0x01 + value12; flag2 = (0x01 + value12) < arg1; value8 = value8 + (value31 + (!(!(((0x989680 * (bytes1(value30 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) % value24)))); value9 = value29; value10 = 0x01 + value10; value11 = 0x01 + value28; value12 = 0x01 + value12; value14 = value14 + (0x989680 * (bytes1(value30 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))); } } else { if (value4 != 0x0) { uint256 value7 = 0; bool flag2 = 0x0 < arg1; uint256 value8 = 0; uint256 value9 = 0; uint256 value10 = 0; uint256 value11 = 0; uint256 value12 = 0; uint256 value14 = 0; while (true) { uint256 value32 = value12; if (!(flag2)) { value32 = value7; } if (!(flag2 && value7 < 0x14)) { return abi.encodePacked(value10, value14, value8, value3); break; } if (stor_a > (stor_a + 0x01)) { _desolexPanic(17); break; } if ((stor_a + 0x01) > ((stor_a + 0x01) + value12)) { _desolexPanic(17); break; } if (((stor_a + 0x01) + value12) > 0x2710) { return abi.encodePacked(value10, value14, value8, value3); break; } uint256 value33 = 0x01; if (!(((stor_a + 0x01) + value12) <= 0x01f4)) { value33 = (0x02 + ((((stor_a + 0x01) + value12) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } if ((value33 & 0xff) == 0x1) { return abi.encodePacked(value10, value14, value8, value3); break; } uint256 value34 = 0; uint256 value35 = unresolved_337900e0[arg0][bytes1(value33)]; uint256 value36 = bytes1(value33); if ((value33 & 0xff) != value9) { } else { value34 = bytes1(value33); value35 = value11; value36 = value9; } if (value35 >= 0x14) { return abi.encodePacked(value10, value14, value8, value3); break; } if (value35 == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) { _desolexPanic(17); break; } if (value10 == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) { _desolexPanic(17); break; } uint256 value37 = 0x01; if (((stor_a + 0x01) + value12) > 0x01f4) { value37 = (0x02 + ((((stor_a + 0x01) + value12) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } if ((value37 & 0xff) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff > 0xff) { _desolexPanic(17); break; } if (!(0x989680 * ((value37 & 0xff) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0xff) / 0x989680 == ((value37 & 0xff) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0xff) || 0x989680 == 0x0)) { _desolexPanic(17); break; } if (value14 > value14 + 0x989680 * ((value37 & 0xff) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0xff)) { _desolexPanic(17); break; } uint256 value38 = ((0x989680 * (bytes1(value37 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) / value3; if ((((0x989680 * (bytes1(value37 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - ((0x989680 * (bytes1(value37 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) == ((((0x989680 * (bytes1(value37 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < ((0x989680 * (bytes1(value37 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000))) { } else { uint256 sharedExpr217 = bytes1(value37 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); uint256 sharedExpr218 = 0x989680 * sharedExpr217; uint256 sharedExpr219 = 0x989680 * sharedExpr217; uint256 sharedExpr220 = 0x989680 * sharedExpr217; uint256 sharedExpr221 = value3 & (0 - value3); uint256 sharedExpr222 = 0x03 * (value3 / sharedExpr221); uint256 sharedExpr223 = 0x02 - ((value3 / sharedExpr221) * (sharedExpr222 ^ 0x02)); uint256 sharedExpr224 = sharedExpr222 ^ 0x02; uint256 sharedExpr225 = 0x02 - ((value3 / sharedExpr221) * (sharedExpr223 * sharedExpr224)); uint256 sharedExpr226 = sharedExpr223 * sharedExpr224; uint256 sharedExpr227 = 0x02 - ((value3 / sharedExpr221) * (sharedExpr225 * sharedExpr226)); uint256 sharedExpr228 = sharedExpr225 * sharedExpr226; uint256 sharedExpr229 = 0x02 - ((value3 / sharedExpr221) * (sharedExpr227 * sharedExpr228)); uint256 sharedExpr230 = sharedExpr227 * sharedExpr228; uint256 sharedExpr231 = 0x02 - ((value3 / sharedExpr221) * (sharedExpr229 * sharedExpr230)); uint256 sharedExpr232 = sharedExpr229 * sharedExpr230; uint256 sharedExpr233 = bytes1(value37 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); uint256 sharedExpr234 = 0x989680 * sharedExpr233; uint256 sharedExpr235 = 0x989680 * sharedExpr233; uint256 sharedExpr236 = 0x989680 * sharedExpr233; uint256 sharedExpr237 = value3 & (0 - value3); uint256 sharedExpr238 = 0x03 * (value3 / sharedExpr237); uint256 sharedExpr239 = 0x02 - ((value3 / sharedExpr237) * (sharedExpr238 ^ 0x02)); uint256 sharedExpr240 = sharedExpr238 ^ 0x02; uint256 sharedExpr241 = 0x02 - ((value3 / sharedExpr237) * (sharedExpr239 * sharedExpr240)); uint256 sharedExpr242 = sharedExpr239 * sharedExpr240; uint256 sharedExpr243 = 0x02 - ((value3 / sharedExpr237) * (sharedExpr241 * sharedExpr242)); uint256 sharedExpr244 = sharedExpr241 * sharedExpr242; uint256 sharedExpr245 = 0x02 - ((value3 / sharedExpr237) * (sharedExpr243 * sharedExpr244)); uint256 sharedExpr246 = sharedExpr243 * sharedExpr244; uint256 sharedExpr247 = 0x02 - ((value3 / sharedExpr237) * (sharedExpr245 * sharedExpr246)); uint256 sharedExpr248 = sharedExpr245 * sharedExpr246; value38 = ((sharedExpr234 * 0x0de0b6b3a7640000) - ((sharedExpr235 * 0x0de0b6b3a7640000) % value3) / (value3 & (0 - value3)) | (((sharedExpr236 * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (sharedExpr234 * 0x0de0b6b3a7640000) - (((sharedExpr236 * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (sharedExpr234 * 0x0de0b6b3a7640000)) - (((sharedExpr235 * 0x0de0b6b3a7640000) % value3) > (sharedExpr234 * 0x0de0b6b3a7640000)) * ((0 - (value3 & (0 - value3))) / (value3 & (0 - value3)) + 0x01))) * ((0x02 - ((value3 / sharedExpr237) * (sharedExpr247 * sharedExpr248))) * (sharedExpr247 * sharedExpr248)); } if (value3 == 0x0) { _desolexPanic(18); break; } if (value38 > (value38 + (!(!(((0x989680 * (bytes1(value37 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) % value3))))) { _desolexPanic(17); break; } if (value8 > (value8 + (value38 + (!(!(((0x989680 * (bytes1(value37 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) % value3)))))) { _desolexPanic(17); break; } if (value12 == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) { _desolexPanic(17); break; } value7 = 0x01 + value12; flag2 = (0x01 + value12) < arg1; value8 = value8 + (value38 + (!(!(((0x989680 * (bytes1(value37 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) % value3)))); value9 = value36; value10 = 0x01 + value10; value11 = 0x01 + value35; value12 = 0x01 + value12; value14 = value14 + (0x989680 * (bytes1(value37 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))); } } else { uint256 value7 = 0; bool flag2 = 0x0 < arg1; uint256 value8 = 0; uint256 value9 = 0; uint256 value10 = 0; uint256 value11 = 0; uint256 value12 = 0; uint256 value14 = 0; while (true) { uint256 value39 = value12; if (!(flag2)) { value39 = value7; } if (!(flag2 && value7 < 0x14)) { return abi.encodePacked(value10, value14, value8, lastGoodPrice); break; } if (stor_a > (stor_a + 0x01)) { _desolexPanic(17); break; } if ((stor_a + 0x01) > ((stor_a + 0x01) + value12)) { _desolexPanic(17); break; } if (((stor_a + 0x01) + value12) > 0x2710) { return abi.encodePacked(value10, value14, value8, lastGoodPrice); break; } uint256 value40 = 0x01; if (!(((stor_a + 0x01) + value12) <= 0x01f4)) { value40 = (0x02 + ((((stor_a + 0x01) + value12) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } if ((value40 & 0xff) == 0x1) { return abi.encodePacked(value10, value14, value8, lastGoodPrice); break; } uint256 value41 = 0; uint256 value42 = unresolved_337900e0[arg0][bytes1(value40)]; uint256 value43 = bytes1(value40); if ((value40 & 0xff) != value9) { } else { value41 = bytes1(value40); value42 = value11; value43 = value9; } if (value42 >= 0x14) { return abi.encodePacked(value10, value14, value8, lastGoodPrice); break; } if (value42 == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) { _desolexPanic(17); break; } if (value10 == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) { _desolexPanic(17); break; } uint256 value44 = 0x01; if (((stor_a + 0x01) + value12) > 0x01f4) { value44 = (0x02 + ((((stor_a + 0x01) + value12) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } if ((value44 & 0xff) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff > 0xff) { _desolexPanic(17); break; } if (!(0x989680 * ((value44 & 0xff) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0xff) / 0x989680 == ((value44 & 0xff) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0xff) || 0x989680 == 0x0)) { _desolexPanic(17); break; } if (value14 > value14 + 0x989680 * ((value44 & 0xff) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & 0xff)) { _desolexPanic(17); break; } uint256 value45 = ((0x989680 * (bytes1(value44 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) / lastGoodPrice; if ((((0x989680 * (bytes1(value44 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - ((0x989680 * (bytes1(value44 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) == ((((0x989680 * (bytes1(value44 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < ((0x989680 * (bytes1(value44 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000))) { } else { uint256 sharedExpr265 = bytes1(value44 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); uint256 sharedExpr266 = 0x989680 * sharedExpr265; uint256 sharedExpr267 = 0x989680 * sharedExpr265; uint256 sharedExpr268 = 0x989680 * sharedExpr265; uint256 sharedExpr269 = lastGoodPrice & (0 - lastGoodPrice); uint256 sharedExpr270 = 0x03 * (lastGoodPrice / sharedExpr269); uint256 sharedExpr271 = 0x02 - ((lastGoodPrice / sharedExpr269) * (sharedExpr270 ^ 0x02)); uint256 sharedExpr272 = sharedExpr270 ^ 0x02; uint256 sharedExpr273 = 0x02 - ((lastGoodPrice / sharedExpr269) * (sharedExpr271 * sharedExpr272)); uint256 sharedExpr274 = sharedExpr271 * sharedExpr272; uint256 sharedExpr275 = 0x02 - ((lastGoodPrice / sharedExpr269) * (sharedExpr273 * sharedExpr274)); uint256 sharedExpr276 = sharedExpr273 * sharedExpr274; uint256 sharedExpr277 = 0x02 - ((lastGoodPrice / sharedExpr269) * (sharedExpr275 * sharedExpr276)); uint256 sharedExpr278 = sharedExpr275 * sharedExpr276; uint256 sharedExpr279 = 0x02 - ((lastGoodPrice / sharedExpr269) * (sharedExpr277 * sharedExpr278)); uint256 sharedExpr280 = sharedExpr277 * sharedExpr278; uint256 sharedExpr281 = bytes1(value44 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff); uint256 sharedExpr282 = 0x989680 * sharedExpr281; uint256 sharedExpr283 = 0x989680 * sharedExpr281; uint256 sharedExpr284 = 0x989680 * sharedExpr281; uint256 sharedExpr285 = lastGoodPrice & (0 - lastGoodPrice); uint256 sharedExpr286 = 0x03 * (lastGoodPrice / sharedExpr285); uint256 sharedExpr287 = 0x02 - ((lastGoodPrice / sharedExpr285) * (sharedExpr286 ^ 0x02)); uint256 sharedExpr288 = sharedExpr286 ^ 0x02; uint256 sharedExpr289 = 0x02 - ((lastGoodPrice / sharedExpr285) * (sharedExpr287 * sharedExpr288)); uint256 sharedExpr290 = sharedExpr287 * sharedExpr288; uint256 sharedExpr291 = 0x02 - ((lastGoodPrice / sharedExpr285) * (sharedExpr289 * sharedExpr290)); uint256 sharedExpr292 = sharedExpr289 * sharedExpr290; uint256 sharedExpr293 = 0x02 - ((lastGoodPrice / sharedExpr285) * (sharedExpr291 * sharedExpr292)); uint256 sharedExpr294 = sharedExpr291 * sharedExpr292; uint256 sharedExpr295 = 0x02 - ((lastGoodPrice / sharedExpr285) * (sharedExpr293 * sharedExpr294)); uint256 sharedExpr296 = sharedExpr293 * sharedExpr294; value45 = ((sharedExpr282 * 0x0de0b6b3a7640000) - ((sharedExpr283 * 0x0de0b6b3a7640000) % lastGoodPrice) / (lastGoodPrice & (0 - lastGoodPrice)) | (((sharedExpr284 * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (sharedExpr282 * 0x0de0b6b3a7640000) - (((sharedExpr284 * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (sharedExpr282 * 0x0de0b6b3a7640000)) - (((sharedExpr283 * 0x0de0b6b3a7640000) % lastGoodPrice) > (sharedExpr282 * 0x0de0b6b3a7640000)) * ((0 - (lastGoodPrice & (0 - lastGoodPrice))) / (lastGoodPrice & (0 - lastGoodPrice)) + 0x01))) * ((0x02 - ((lastGoodPrice / sharedExpr285) * (sharedExpr295 * sharedExpr296))) * (sharedExpr295 * sharedExpr296)); } if (lastGoodPrice == 0) { _desolexPanic(18); break; } if (value45 > (value45 + (!(!(((0x989680 * (bytes1(value44 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) % lastGoodPrice))))) { _desolexPanic(17); break; } if (value8 > (value8 + (value45 + (!(!(((0x989680 * (bytes1(value44 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) % lastGoodPrice)))))) { _desolexPanic(17); break; } if (value12 == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) { _desolexPanic(17); break; } value7 = 0x01 + value12; flag2 = (0x01 + value12) < arg1; value8 = value8 + (value45 + (!(!(((0x989680 * (bytes1(value44 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) * 0x0de0b6b3a7640000) % lastGoodPrice)))); value9 = value43; value10 = 0x01 + value10; value11 = 0x01 + value42; value12 = 0x01 + value12; value14 = value14 + (0x989680 * (bytes1(value44 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))); } } } } } function remaining() public view returns (uint256) { return 0x2710 - stor_b; } function openMining() public onlyOwner { require(!miningOpen, AlreadyOpen()); miningOpen = true; if (((var_e + 0x80) > 0xffffffffffffffff) | ((var_e + 0x80) < var_e)) _desolexPanic(65); launchSeed = keccak256(abi.encode(blockhash(block.number + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), block.prevrandao, address(this))); if (stor_18 != 0x0) { stor_1a = block.timestamp + 0x015180; } uint256 value0 = 0x2710; if (stor_a < 0x2710) { value0 = stor_a + 0x01; } uint256 value1 = 0x01; if (!(value0 <= 0x01f4)) { value1 = (0x02 + ((value0 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } uint256 value2 = (bytes1(value1)) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if ((value1 & 0xff) != 0x0) { } else { value2 = 0; } uint256 value3 = unresolved_7c3f33d6 + (value2 * unresolved_e4441769); if ((unresolved_7c3f33d6 + (value2 * unresolved_e4441769)) > 0x38) { value3 = 0x38; } uint256 value4 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> value3; if (!(value3 < 0x100)) { value4 = 0; } if ((block.timestamp <= stor_f) && (stor_e > value4)) { emit Event_e4f09f69(block.timestamp, keccak256(abi.encode(blockhash(block.number + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), block.prevrandao, address(this))), stor_e); } else { emit Event_e4f09f69(block.timestamp, keccak256(abi.encode(blockhash(block.number + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff), block.prevrandao, address(this))), value4); } } function tickets(uint256 index) public view returns (bytes memory) { return abi.encodePacked(mapping_26[index], uint64(mapping_26[index] >> 0xa0), mapping_26[index] >> 0xe0, stor_expr_bv); } function mine(uint256 arg0) public payable { if ((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) >= 0x20) { if (stor_expr_t != 0x02) { stor_expr_t = 0x02; require(miningOpen, MiningClosed()); require((stor_a < 0x2710), SoldOut()); if (block.number != mintBlock) { mintBlock = block.number; unresolved_4ec5df4f = 0; } require(0x0a > unresolved_4ec5df4f, BlockFull()); if (agentRegistry) { (bool success0, bytes memory returnData0) = agentRegistry.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), msg.sender)); // staticcall balanceOf if (!(success0)) { if (!(success0)) { require(0, NotAgentHolder()); var_d = 0x27; uint256 var_j; if (((var_j + 0xc0) > 0xffffffffffffffff) | ((var_j + 0xc0) < var_j)) _desolexPanic(65); var_j = var_j + 0xc0; if (((var_j + 0x80) > 0xffffffffffffffff) | ((var_j + 0x80) < var_j)) _desolexPanic(65); bytes var_a = sha256(); require(var_d); uint256 value0 = 0x2710; if (stor_a < 0x2710) { value0 = stor_a + 0x01; } uint256 value1 = 0x01; if (!(value0 <= 0x01f4)) { value1 = (0x02 + ((value0 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } uint256 value2 = (bytes1(value1)) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if ((value1 & 0xff) != 0x0) { } else { value2 = 0; } uint256 value3 = unresolved_7c3f33d6 + (value2 * unresolved_e4441769); if ((unresolved_7c3f33d6 + (value2 * unresolved_e4441769)) > 0x38) { value3 = 0x38; } uint256 value4 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> value3; if (!(value3 < 0x100)) { value4 = 0; } if (!(block.timestamp <= stor_f && stor_e > value4)) { require(var_a <= value4, CustomError_317cfc38()); uint256 value5 = 0x01; if (!((stor_a + 0x01) <= 0x01f4)) { value5 = (0x02 + (((stor_a + 0x01) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } } } } } } } } function Unknown_458fb554(address arg0, uint256 arg1, uint256 arg2) public returns (uint256) { if (((var_e + 0x80) > 0xffffffffffffffff) | ((var_e + 0x80) < var_e)) _desolexPanic(65); bytes var_g = sha256(); require(var_h); return var_g; } function safeTransferFrom(address _from, address to, uint256 tokenId) public { uint256 var_a; if (((var_a + 0x20) > 0xffffffffffffffff) | ((var_a + 0x20) < var_a)) _desolexPanic(65); var_a = var_a + 0x20; require(to != address(0), ERC721InvalidReceiver()); if (unresolved_64c37584[tokenId]) { if (ownerOf[tokenId] != address(0)) { if (!mapping_25[tokenId]) { bool flag13; if (stor_1c) { uint256 value7 = 0; uint256 value10; if (stor_1a != 0) { uint256 value26; if (!stor_1c) { uint256 value0 = stor_1a; if (!(block.timestamp <= stor_1a)) { uint256 value27 = block.timestamp; value27 = stor_1a + ((!(!(block.timestamp - stor_1a))) * ((((block.timestamp - stor_1a) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x015180) + 0x01) * 0x015180); value0 = value27; } if (!(block.timestamp < value0)) { mapping_25[tokenId] = true; mapping_24[tokenId] = (ownerOf[tokenId] & (0xffffffffffffffffffffffffffffffffffffffff)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & mapping_24[tokenId]); emit Event_d94d502d(tokenId, ownerOf[tokenId]); } uint256 value37 = 0; if (msg.sender != address(0)) { uint256 value2; uint256 value1; if (!(ownerOf[tokenId] == msg.sender)) { bool flag0 = !(!(msg.sender)); if (!(msg.sender == marketplace)) { flag0 = (msg.sender) == marketplace; } bool flag1 = !(unresolved_50cd382e[ownerOf[tokenId]]); if (flag0) { } else { flag1 = flag0; } uint256 value29 = 0x01; if (!(flag1)) { value29 = bytes1(mapping_5[address(ownerOf[tokenId])][msg.sender]); } value1 = value29; } else { value1 = (ownerOf[tokenId] == msg.sender) ? 1 : 0; } uint256 value28 = value1; if (value1 == 0) { value28 = (msg.sender == getApproved[tokenId]) ? 1 : 0; } value2 = value28; if (value2 == 0x0) { require(ownerOf[tokenId] != address(0), ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } } else { flag2 = msg.sender != address(0); } if (ownerOf[tokenId] != address(0)) { getApproved[tokenId] = address(0); balanceOf[ownerOf[tokenId]] = balanceOf[ownerOf[tokenId]] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[to] = balanceOf[to] + 0x01; ownerOf[tokenId] = (ownerOf[tokenId] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | to; emit Transfer(ownerOf[tokenId], to, tokenId); require(ownerOf[tokenId] == _from, ERC721IncorrectOwner()); if (to.code.length != 0x0) { (bool success0, bytes memory returnData0) = to.onERC721Received(msg.sender, _from, tokenId, 0x80); // call uint256 value4 = 0; uint256 value5 = var_a.length; if (success0) { uint256 value3 = returnData0.length; if (0x20 <= returnData0.length) { value3 = 0x20; } if (((var_a + ((value10 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value10 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value10 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_a + value3) - var_a) >= 0x20); require(var_a.length == (var_a.length & (0xffffffff00000000000000000000000000000000000000000000000000000000))); } else { value4 = var_a; value5 = 0; } if (!(success0)) { uint256 value6 = 0x60; if (returnData0.length != 0x0) { if (returnData0.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value6 = var_a; } require(var_p != 0x0, ERC721InvalidReceiver()); revert(); } require(!(0xeaf485fe00000000000000000000000000000000000000000000000000000000 + (0xffffffff00000000000000000000000000000000000000000000000000000000 & value5)), ERC721InvalidReceiver()); } } else { value26 = stor_1a; if (stor_1c > stor_1a) { uint256 value30 = (stor_1c) ? 1 : 0; value30 = stor_1a + ((!(!(stor_1c - stor_1a))) * ((((stor_1c - stor_1a) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x015180) + 0x01) * 0x015180); value26 = value30; } } value7 = value26; } flag13 = !(block.timestamp < value7); } else { flag13 = stor_1c; } } address account0 = address(0); if (!mapping_25[tokenId] && flag13) { mapping_25[tokenId] = true; mapping_24[tokenId] = (ownerOf[tokenId] & (0xffffffffffffffffffffffffffffffffffffffff)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & mapping_24[tokenId]); emit Event_d94d502d(tokenId, ownerOf[tokenId]); } else { account0 = ownerOf[tokenId]; } uint256 value38 = 0; if (msg.sender != address(0)) { uint256 value9; uint256 value8; if (!(ownerOf[tokenId] == msg.sender)) { bool flag4 = !(!(msg.sender)); if (!(msg.sender == marketplace)) { flag4 = (msg.sender) == marketplace; } bool flag5 = !(unresolved_50cd382e[ownerOf[tokenId]]); if (flag4) { } else { flag5 = flag4; } uint256 value32 = 0x01; if (!(flag5)) { value32 = bytes1(mapping_5[address(ownerOf[tokenId])][msg.sender]); } value8 = value32; } else { value8 = (ownerOf[tokenId] == msg.sender) ? 1 : 0; } uint256 value31 = value8; if (value8 == 0) { value31 = (msg.sender == getApproved[tokenId]) ? 1 : 0; } value9 = value31; if (value9 == 0x0) { require(ownerOf[tokenId] != address(0), ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } } else { flag6 = msg.sender != address(0); } if (ownerOf[tokenId] != address(0)) { getApproved[tokenId] = address(0); balanceOf[ownerOf[tokenId]] = balanceOf[ownerOf[tokenId]] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[to] = balanceOf[to] + 0x01; ownerOf[tokenId] = (ownerOf[tokenId] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | to; emit Transfer(ownerOf[tokenId], to, tokenId); require(ownerOf[tokenId] == _from, ERC721IncorrectOwner()); if (to.code.length != 0x0) { (bool success1, bytes memory returnData1) = to.onERC721Received(msg.sender, _from, tokenId, 0x80); // call uint256 value11 = 0; uint256 value12 = var_a.length; if (success1) { value10 = returnData1.length; if (0x20 <= returnData1.length) { value10 = 0x20; } if (((var_a + ((value10 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value10 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value10 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_a + value10) - var_a) >= 0x20); require(var_a.length == (var_a.length & (0xffffffff00000000000000000000000000000000000000000000000000000000))); } else { value11 = var_a; value12 = 0; } if (!(success1)) { uint256 value13 = 0x60; if ((returnData1.length) != 0x0) { if (returnData1.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData1.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData1.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData1.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value13 = var_a; } require(var_q != 0x0, ERC721InvalidReceiver()); revert(); } require(!(0xeaf485fe00000000000000000000000000000000000000000000000000000000 + (0xffffffff00000000000000000000000000000000000000000000000000000000 & value12)), ERC721InvalidReceiver()); } } else { unresolved_31698b91 = 0x01 + unresolved_31698b91; if (stor_18 == (0x01 + unresolved_31698b91)) { stor_1c = block.timestamp; uint256 value39 = 0; if (msg.sender != address(0)) { uint256 value15; uint256 value14; if (!(ownerOf[tokenId] == msg.sender)) { bool flag7 = !(!(msg.sender)); if (!(msg.sender == marketplace)) { flag7 = (msg.sender) == marketplace; } bool flag8 = !(unresolved_50cd382e[ownerOf[tokenId]]); if (flag7) { } else { flag8 = flag7; } uint256 value34 = 0x01; if (!(flag8)) { value34 = bytes1(mapping_5[address(ownerOf[tokenId])][msg.sender]); } value14 = value34; } else { value14 = (ownerOf[tokenId] == msg.sender) ? 1 : 0; } uint256 value33 = value14; if (value14 == 0) { value33 = (msg.sender == getApproved[tokenId]) ? 1 : 0; } value15 = value33; if (value15 == 0x0) { require(ownerOf[tokenId] != address(0), ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } } else { flag9 = msg.sender != address(0); } if (ownerOf[tokenId] != address(0)) { getApproved[tokenId] = address(0); balanceOf[ownerOf[tokenId]] = balanceOf[ownerOf[tokenId]] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[to] = balanceOf[to] + 0x01; ownerOf[tokenId] = (ownerOf[tokenId] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | to; emit Transfer(ownerOf[tokenId], to, tokenId); require(ownerOf[tokenId] == _from, ERC721IncorrectOwner()); if (to.code.length != 0x0) { (bool success2, bytes memory returnData2) = to.onERC721Received(msg.sender, _from, tokenId, 0x80); // call uint256 value17 = 0; uint256 value18 = var_a.length; if (success2) { uint256 value16 = returnData2.length; if (0x20 <= returnData2.length) { value16 = 0x20; } if (((var_a + ((value16 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value16 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value16 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_a + value16) - var_a) >= 0x20); require(var_a.length == (var_a.length & (0xffffffff00000000000000000000000000000000000000000000000000000000))); } else { value17 = var_a; value18 = 0; } if (!(success2)) { uint256 value19 = 0x60; if ((returnData2.length) != 0x0) { if (returnData2.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData2.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData2.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData2.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value19 = var_a; } require(var_r != 0x0, ERC721InvalidReceiver()); revert(); } require(!(0xeaf485fe00000000000000000000000000000000000000000000000000000000 + (0xffffffff00000000000000000000000000000000000000000000000000000000 & value18)), ERC721InvalidReceiver()); } } } } uint256 value40 = 0; if (msg.sender != address(0)) { uint256 value21; uint256 value20; if (!(ownerOf[tokenId] == msg.sender)) { bool flag10 = !(!(msg.sender)); if (!(msg.sender == marketplace)) { flag10 = (msg.sender) == marketplace; } bool flag11 = !(unresolved_50cd382e[ownerOf[tokenId]]); if (flag10) { } else { flag11 = flag10; } uint256 value36 = 0x01; if (!(flag11)) { value36 = bytes1(mapping_5[address(ownerOf[tokenId])][msg.sender]); } value20 = value36; } else { value20 = (ownerOf[tokenId] == msg.sender) ? 1 : 0; } uint256 value35 = value20; if (value20 == 0) { value35 = (msg.sender == getApproved[tokenId]) ? 1 : 0; } value21 = value35; if (value21 == 0x0) { require(ownerOf[tokenId] != address(0), ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } } else { flag12 = msg.sender != address(0); } if (ownerOf[tokenId] != address(0)) { getApproved[tokenId] = address(0); balanceOf[ownerOf[tokenId]] = balanceOf[ownerOf[tokenId]] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[to] = balanceOf[to] + 0x01; ownerOf[tokenId] = (ownerOf[tokenId] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | to; emit Transfer(ownerOf[tokenId], to, tokenId); require(ownerOf[tokenId] == _from, ERC721IncorrectOwner()); if (to.code.length != 0x0) { (bool success3, bytes memory returnData3) = to.onERC721Received(msg.sender, _from, tokenId, 0x80); // call uint256 value23 = 0; uint256 value24 = var_a.length; if (success3) { uint256 value22 = returnData3.length; if (0x20 <= returnData3.length) { value22 = 0x20; } if (((var_a + ((value22 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((value22 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((value22 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(((var_a + value22) - var_a) >= 0x20); require(var_a.length == (var_a.length & (0xffffffff00000000000000000000000000000000000000000000000000000000))); } else { value23 = var_a; value24 = 0; } if (!(success3)) { uint256 value25 = 0x60; if ((returnData3.length) != 0x0) { if (returnData3.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData3.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData3.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData3.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value25 = var_a; } require(var_t != 0x0, ERC721InvalidReceiver()); revert(); } require(!(0xeaf485fe00000000000000000000000000000000000000000000000000000000 + (0xffffffff00000000000000000000000000000000000000000000000000000000 & value24)), ERC721InvalidReceiver()); } } function withdraw() public returns (bytes memory) { require(stor_expr_t != 0x02, ReentrancyGuardReentrantCall()); stor_expr_t = 0x02; bool flag0 = !(msg.sender == unresolved_7baa1165); if (msg.sender == owner) { flag0 = !(msg.sender == owner); } require(!(flag0 && msg.sender != unresolved_b79b1d35), NotPayee()); uint256 value0 = 0; if ((((address(this).balance + devReleased) + unresolved_b1e8557c) + rewardClaimedTotal) > rewardAccrued) { value0 = (((address(this).balance + devReleased) + unresolved_b1e8557c) + rewardClaimedTotal) - rewardAccrued; } if (!(unresolved_b79b1d35)) { uint256 value4 = msg.data[0] >> 0xe0; uint256 value5; if ((value0 - devReleased) != unresolved_b1e8557c) { devReleased = devReleased + ((value0 - devReleased) - unresolved_b1e8557c); (bool success0, bytes memory returnData0) = unresolved_7baa1165.call{ value: (value0 - devReleased) - unresolved_b1e8557c }(""); // call uint256 value1 = 0x60; if ((returnData0.length) != 0x0) { if (returnData0.length > 0xffffffffffffffff) _desolexPanic(65); uint256 var_b; if (((var_b + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value1 = var_b; } uint256 value26; if (success0) { emit RevenueReleased(unresolved_7baa1165, (value0 - devReleased) - unresolved_b1e8557c); uint256 value2 = 0; if (!success0) { devReleased = devReleased - ((value0 - devReleased) - unresolved_b1e8557c); } else { value2 = (value0 - devReleased) - unresolved_b1e8557c; } value26 = value2; } else { uint256 value3 = 0; if (!success0) { devReleased = devReleased - ((value0 - devReleased) - unresolved_b1e8557c); } else { value3 = (value0 - devReleased) - unresolved_b1e8557c; } value26 = value3; } value5 = value26; } else { value4 = (value0 - devReleased) - unresolved_b1e8557c; value5 = 0; } uint256 value7 = msg.data[0] >> 0xe0; value7 = 0; require(!(value5 == 0x0 && 0x0 == 0x0), NothingToClaim()); stor_expr_t = 0x01; return abi.encodePacked(value5, 0); } else { uint256 value8 = 0; if (0 != ((value0 >> 0x01) > unresolved_b1e8557c)) { value8 = (value0 >> 0x01) - unresolved_b1e8557c; } if (!((value0 - (value0 >> 0x01)) > devReleased)) { uint256 value10 = msg.data[0] >> 0xe0; value10 = 0; uint256 value14 = msg.data[0] >> 0xe0; uint256 value15; if (value8 != 0x0) { unresolved_b1e8557c = unresolved_b1e8557c + value8; (bool success3, bytes memory returnData3) = unresolved_b79b1d35.call{ value: value8 }(""); // call uint256 value11 = 0x60; if ((returnData3.length) != 0x0) { if (returnData3.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_b + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData3.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData3.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData3.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value11 = var_b; } uint256 value27; if (success3) { emit RevenueReleased(unresolved_b79b1d35, value8); uint256 value12 = 0; if (!success3) { unresolved_b1e8557c = unresolved_b1e8557c - value8; } else { value12 = value8; } value27 = value12; } else { uint256 value13 = 0; if (!success3) { unresolved_b1e8557c = unresolved_b1e8557c - value8; } else { value13 = value8; } value27 = value13; } value15 = value27; } else { value14 = value8; value15 = 0; } require(!(0x0 == 0x0 && value15 == 0x0), NothingToClaim()); stor_expr_t = 0x01; return abi.encodePacked(0, value15); } else { uint256 value19 = msg.data[0] >> 0xe0; uint256 value20; if ((value0 - (value0 >> 0x01)) != devReleased) { devReleased = devReleased + ((value0 - (value0 >> 0x01)) - devReleased); (bool success4, bytes memory returnData4) = unresolved_7baa1165.call{ value: (value0 - (value0 >> 0x01)) - devReleased }(""); // call uint256 value16 = 0x60; if ((returnData4.length) != 0x0) { if (returnData4.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_b + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData4.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData4.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData4.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value16 = var_b; } uint256 value28; if (success4) { emit RevenueReleased(unresolved_7baa1165, (value0 - (value0 >> 0x01)) - devReleased); uint256 value17 = 0; if (!success4) { devReleased = devReleased - ((value0 - (value0 >> 0x01)) - devReleased); } else { value17 = (value0 - (value0 >> 0x01)) - devReleased; } value28 = value17; } else { uint256 value18 = 0; if (!success4) { devReleased = devReleased - ((value0 - (value0 >> 0x01)) - devReleased); } else { value18 = (value0 - (value0 >> 0x01)) - devReleased; } value28 = value18; } value20 = value28; } else { value19 = (value0 - (value0 >> 0x01)) - devReleased; value20 = 0; } uint256 value24 = msg.data[0] >> 0xe0; uint256 value25; if (value8 != 0x0) { unresolved_b1e8557c = unresolved_b1e8557c + value8; (bool success5, bytes memory returnData5) = unresolved_b79b1d35.call{ value: value8 }(""); // call uint256 value21 = 0x60; if ((returnData5.length) != 0x0) { if (returnData5.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_b + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData5.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_b + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData5.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_b)) _desolexPanic(65); var_b = var_b + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData5.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value21 = var_b; } uint256 value29; if (success5) { emit RevenueReleased(unresolved_b79b1d35, value8); uint256 value22 = 0; if (!success5) { unresolved_b1e8557c = unresolved_b1e8557c - value8; } else { value22 = value8; } value29 = value22; } else { uint256 value23 = 0; if (!success5) { unresolved_b1e8557c = unresolved_b1e8557c - value8; } else { value23 = value8; } value29 = value23; } value25 = value29; } else { value24 = value8; value25 = 0; } require(!(value20 == 0x0 && value25 == 0x0), NothingToClaim()); stor_expr_t = 0x01; return abi.encodePacked(value20, value25); } } } function draw(uint256 arg0) public payable { if (!(msg.value) && !((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) < 0x20) && stor_expr_t != 0x02) { stor_expr_t = 0x02; bool flag0 = stor_a > stor_b; if (0 >= arg0) { flag0 = 0x0 < arg0; } bool flag1 = !(gasleft() < 0x030d40); if (!(flag0)) { flag1 = flag0; } } } function currentTarget() public view returns (uint256) { uint256 value0 = 0x2710; if (stor_a < 0x2710) { value0 = stor_a + 0x01; } uint256 value1 = 0x01; if (!(value0 <= 0x1f4)) { value1 = (0x02 + ((value0 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } uint256 value2 = (bytes1(value1)) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if ((value1 & 0xff) != 0x0) { } else { value2 = 0; } if ((unresolved_7c3f33d6 + (value2 * unresolved_e4441769)) > 0x38) { if (!(block.timestamp <= stor_f && stor_e > 0xffffffffffffffffffffffffffffffffffffffffffffffffff)) { return 0xffffffffffffffffffffffffffffffffffffffffffffffffff; } } else if ((unresolved_7c3f33d6 + (value2 * unresolved_e4441769)) >= 0x0100) { if (!(block.timestamp <= stor_f && stor_e > 0x0)) { return 0; } } else if (!(block.timestamp <= stor_f && stor_e > SHR(unresolved_7c3f33d6 + value2 * unresolved_e4441769, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) { return 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> (unresolved_7c3f33d6 + (value2 * unresolved_e4441769)); } return stor_e; } function Unknown_329e4f4a() public view returns (bool) { return stor_15_21_21; } function bitsToTarget(uint256 arg0) public pure returns (uint256) { if (arg0 >= 0x0100) { return 0; } return 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> arg0; } function royaltyInfo(uint256 _tokenId, uint256 arg1) public view returns (bytes memory) { uint256 value0 = stor_6 >> 0xa0; address account0 = stor_6; if (mapping_7[_tokenId]) { value0 = mapping_7[_tokenId] >> 0xa0; account0 = mapping_7[_tokenId]; } return abi.encodePacked(account0, (arg1 * (uint96(value0))) / 0x2710); } function setAgentRegistry(address newAddress) public onlyOwner { require(!stor_15_21_21, CustomError_472890de()); require(!(newAddress != address(0) && newAddress.code.length == 0x0), BadConfig()); agentRegistry = newAddress; emit AgentRegistrySet(agentRegistry); } function Unknown_26c7f77c(bool arg0) public payable { if ((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) >= 0x20) { if (stor_expr_t != 0x02) { stor_expr_t = 0x02; if (miningOpen) { require(!(arg0 && arg0 > 0x14 || !arg0), BadQuantity()); require(0x2710 >= (stor_a + arg0), SoldOut()); uint256 var_d; if (((var_d + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); (bool success0, bytes memory returnData0) = address(0x0567f2323251f0aab15c8dfb1967e4e8a7d42aee).latestRoundData{ gas: 0x030d40 }(); // staticcall uint256 value0 = 0x60; if ((returnData0.length) != 0x0) { if (returnData0.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_d + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value0 = var_d; } bool flag1 = var_f < 0xa0; if (!success0) { flag1 = !success0; } uint256 value2 = 0; uint256 value3 = 0; uint256 value4 = 0; if (!(flag1)) { require(((value0 + var_f) - value0) >= 0xa0); uint256 value16 = 0; uint256 value17 = 0; uint256 value18 = 0; if (var_g > 0) { uint256 value1 = (var_g * 0x05f5e100) / (0x0a ** 0x08); if (((var_g * 0x05f5e100) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (var_g * 0x05f5e100) == (((var_g * 0x05f5e100) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (var_g * 0x05f5e100))) { } else { uint256 sharedExpr15 = (0x0a ** 0x08) & (0 - (0x0a ** 0x08)); uint256 sharedExpr16 = 0x03 * ((0x0a ** 0x08) / sharedExpr15); uint256 sharedExpr17 = 0x02 - (((0x0a ** 0x08) / sharedExpr15) * (sharedExpr16 ^ 0x02)); uint256 sharedExpr18 = sharedExpr16 ^ 0x02; uint256 sharedExpr19 = 0x02 - (((0x0a ** 0x08) / sharedExpr15) * (sharedExpr17 * sharedExpr18)); uint256 sharedExpr20 = sharedExpr17 * sharedExpr18; uint256 sharedExpr21 = 0x02 - (((0x0a ** 0x08) / sharedExpr15) * (sharedExpr19 * sharedExpr20)); uint256 sharedExpr22 = sharedExpr19 * sharedExpr20; uint256 sharedExpr23 = 0x02 - (((0x0a ** 0x08) / sharedExpr15) * (sharedExpr21 * sharedExpr22)); uint256 sharedExpr24 = sharedExpr21 * sharedExpr22; uint256 sharedExpr25 = 0x02 - (((0x0a ** 0x08) / sharedExpr15) * (sharedExpr23 * sharedExpr24)); uint256 sharedExpr26 = sharedExpr23 * sharedExpr24; uint256 sharedExpr27 = var_g; uint256 sharedExpr28 = 0x0a ** 0x08; uint256 sharedExpr29 = (0x0a ** 0x08) & (0 - (0x0a ** 0x08)); uint256 sharedExpr30 = 0x03 * ((0x0a ** 0x08) / sharedExpr29); uint256 sharedExpr31 = 0x02 - (((0x0a ** 0x08) / sharedExpr29) * (sharedExpr30 ^ 0x02)); uint256 sharedExpr32 = sharedExpr30 ^ 0x02; uint256 sharedExpr33 = 0x02 - (((0x0a ** 0x08) / sharedExpr29) * (sharedExpr31 * sharedExpr32)); uint256 sharedExpr34 = sharedExpr31 * sharedExpr32; uint256 sharedExpr35 = 0x02 - (((0x0a ** 0x08) / sharedExpr29) * (sharedExpr33 * sharedExpr34)); uint256 sharedExpr36 = sharedExpr33 * sharedExpr34; uint256 sharedExpr37 = 0x02 - (((0x0a ** 0x08) / sharedExpr29) * (sharedExpr35 * sharedExpr36)); uint256 sharedExpr38 = sharedExpr35 * sharedExpr36; uint256 sharedExpr39 = 0x02 - (((0x0a ** 0x08) / sharedExpr29) * (sharedExpr37 * sharedExpr38)); uint256 sharedExpr40 = sharedExpr37 * sharedExpr38; uint256 sharedExpr41 = ((var_g * 0x05f5e100) - ((var_g * 0x05f5e100) % (0x0a ** 0x08)) / ((0x0a ** 0x08) & (0 - (0x0a ** 0x08))) | (((var_g * 0x05f5e100) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (var_g * 0x05f5e100) - (((var_g * 0x05f5e100) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (var_g * 0x05f5e100)) - ((var_g * 0x05f5e100) % (0x0a ** 0x08) > (var_g * 0x05f5e100)) * ((0 - ((0x0a ** 0x08) & (0 - (0x0a ** 0x08)))) / ((0x0a ** 0x08) & (0 - (0x0a ** 0x08))) + 0x01))) * ((0x02 - (((0x0a ** 0x08) / sharedExpr29) * (sharedExpr39 * sharedExpr40))) * (sharedExpr39 * sharedExpr40)); value1 = sharedExpr41; } value16 = var_h; value17 = value1; value18 = 0x01; } value2 = value16; value3 = value17; value4 = value18; } uint256 value5 = (!(value2 > block.timestamp)) ? 1 : 0; if (value4 == 0) { value5 = value4; } uint256 value6 = 0; if (value5 != 0x0) { } else { value6 = value2; } if (!(value5 != 0x0 && 0xe10 >= block.timestamp - value2)) { uint256 value10 = 0; if (((var_d + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); (bool success1, bytes memory returnData1) = address(0x16b9a82891338f9ba80e2d6970fdda79d1eb0dae).getReserves{ gas: 0x030d40 }(); // staticcall uint256 value7 = 0x60; if ((returnData1.length) != 0x0) { if (returnData1.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_d + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData1.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_d + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData1.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_d)) _desolexPanic(65); var_d = var_d + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData1.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value7 = var_d; } bool flag3 = var_k < 0x60; if (!success1) { flag3 = !success1; } uint256 value19 = 0; if (!(flag3)) { require(((value7 + var_k) - value7) >= 0x60); uint256 value8 = var_l; uint256 value9 = var_m; bool flag4 = value8 == 0x0; if (value9 == 0) { flag4 = value9 == 0x0; } bool flag5 = value9 > 0xffffffffffffffffffffffffffff; if (flag4) { flag5 = flag4; } uint256 value20 = 0; if (((flag5) && (value8 > 0xffffffffffffffffffffffffffff)) || (flag5)) { uint256 value21 = (value8 * (0x0a ** 0x1a)) / (value9 * (0x0a ** 0x12)); if (((value8 * (0x0a ** 0x1a)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (value8 * (0x0a ** 0x1a)) == (((value8 * (0x0a ** 0x1a)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (value8 * (0x0a ** 0x1a)))) { } else { uint256 sharedExpr63 = 0x0a ** 0x1a; uint256 sharedExpr64 = 0x0a ** 0x1a; uint256 sharedExpr65 = 0x0a ** 0x12; uint256 sharedExpr66 = value9 * (0x0a ** 0x12); uint256 sharedExpr67 = sharedExpr66; uint256 sharedExpr68 = sharedExpr66; uint256 sharedExpr69 = 0 - sharedExpr66; uint256 sharedExpr70 = 0x0a ** 0x1a; uint256 sharedExpr71 = sharedExpr66; uint256 sharedExpr72 = sharedExpr68 & sharedExpr69; uint256 sharedExpr73 = 0x03 * (sharedExpr71 / sharedExpr72); uint256 sharedExpr74 = 0x02 - ((sharedExpr71 / sharedExpr72) * (sharedExpr73 ^ 0x02)); uint256 sharedExpr75 = sharedExpr73 ^ 0x02; uint256 sharedExpr76 = 0x02 - ((sharedExpr71 / sharedExpr72) * (sharedExpr74 * sharedExpr75)); uint256 sharedExpr77 = sharedExpr74 * sharedExpr75; uint256 sharedExpr78 = 0x02 - ((sharedExpr71 / sharedExpr72) * (sharedExpr76 * sharedExpr77)); uint256 sharedExpr79 = sharedExpr76 * sharedExpr77; uint256 sharedExpr80 = 0x02 - ((sharedExpr71 / sharedExpr72) * (sharedExpr78 * sharedExpr79)); uint256 sharedExpr81 = sharedExpr78 * sharedExpr79; uint256 sharedExpr82 = 0x02 - ((sharedExpr71 / sharedExpr72) * (sharedExpr80 * sharedExpr81)); uint256 sharedExpr83 = sharedExpr80 * sharedExpr81; uint256 sharedExpr84 = 0x0a ** 0x1a; uint256 sharedExpr85 = 0x0a ** 0x1a; uint256 sharedExpr86 = 0x0a ** 0x12; uint256 sharedExpr87 = value9 * (0x0a ** 0x12); uint256 sharedExpr88 = sharedExpr87; uint256 sharedExpr89 = sharedExpr87; uint256 sharedExpr90 = 0 - sharedExpr87; uint256 sharedExpr91 = 0x0a ** 0x1a; uint256 sharedExpr92 = sharedExpr87; uint256 sharedExpr93 = sharedExpr89 & sharedExpr90; uint256 sharedExpr94 = 0x03 * (sharedExpr92 / sharedExpr93); uint256 sharedExpr95 = 0x02 - ((sharedExpr92 / sharedExpr93) * (sharedExpr94 ^ 0x02)); uint256 sharedExpr96 = sharedExpr94 ^ 0x02; uint256 sharedExpr97 = 0x02 - ((sharedExpr92 / sharedExpr93) * (sharedExpr95 * sharedExpr96)); uint256 sharedExpr98 = sharedExpr95 * sharedExpr96; uint256 sharedExpr99 = 0x02 - ((sharedExpr92 / sharedExpr93) * (sharedExpr97 * sharedExpr98)); uint256 sharedExpr100 = sharedExpr97 * sharedExpr98; uint256 sharedExpr101 = 0x02 - ((sharedExpr92 / sharedExpr93) * (sharedExpr99 * sharedExpr100)); uint256 sharedExpr102 = sharedExpr99 * sharedExpr100; uint256 sharedExpr103 = 0x02 - ((sharedExpr92 / sharedExpr93) * (sharedExpr101 * sharedExpr102)); uint256 sharedExpr104 = sharedExpr101 * sharedExpr102; value21 = ((value8 * sharedExpr84) - ((value8 * sharedExpr85) % sharedExpr88) / (sharedExpr89 & sharedExpr90) | (((value8 * sharedExpr91) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (value8 * sharedExpr84) - (((value8 * sharedExpr91) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (value8 * sharedExpr84)) - (((value8 * sharedExpr85) % sharedExpr88) > (value8 * sharedExpr84)) * ((0 - (sharedExpr89 & sharedExpr90)) / (sharedExpr89 & sharedExpr90) + 0x01))) * ((0x02 - ((sharedExpr92 / sharedExpr93) * (sharedExpr103 * sharedExpr104))) * (sharedExpr103 * sharedExpr104)); } value20 = value21; } value19 = value20; } value10 = value19; if (value10 == 0) { if (value4 == 0) { if ((0x4 != 0x4) && (lastGoodPrice != lastGoodPrice)) { lastGoodPrice = lastGoodPrice; } uint256 value11 = 0x2710; if (stor_a < 0x2710) { value11 = stor_a + 0x01; } uint256 value12 = 0x01; if (!(value11 <= 0x01f4)) { value12 = (0x02 + ((value11 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } uint256 value13 = (bytes1(value12)) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if ((value12 & 0xff) != 0x0) { } else { value13 = 0; } uint256 value14 = unresolved_7c3f33d6 + (value13 * unresolved_e4441769); if ((unresolved_7c3f33d6 + (value13 * unresolved_e4441769)) > 0x38) { value14 = 0x38; } uint256 value15 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> value14; if (!(value14 < 0x100)) { value15 = 0; } if (!(block.timestamp <= stor_f && stor_e > value15)) { bool flag9 = stor_18; if (0x03e8 == 0) { flag9 = 0x3e8 != 0x0; } } } } } } } } } function transferFrom(address from, address to, uint256 amount) public { internal_4346(from, to, amount); } function targetFor(address account) public view returns (uint256) { uint256 value0 = 0x2710; if (stor_a < 0x2710) { value0 = stor_a + 0x01; } uint256 value1 = 0x01; if (!(value0 <= 0x1f4)) { value1 = (0x02 + ((value0 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } uint256 value2 = (bytes1(value1)) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if ((value1 & 0xff) != 0x0) { } else { value2 = 0; } if ((unresolved_7c3f33d6 + (value2 * unresolved_e4441769)) > 0x38) { if (!(block.timestamp <= stor_f && stor_e > 0xffffffffffffffffffffffffffffffffffffffffffffffffff)) { return 0xffffffffffffffffffffffffffffffffffffffffffffffffff; } } else if ((unresolved_7c3f33d6 + (value2 * unresolved_e4441769)) >= 0x0100) { if (!(block.timestamp <= stor_f && stor_e > 0x0)) { return 0; } } else if (!(block.timestamp <= stor_f && stor_e > SHR(unresolved_7c3f33d6 + value2 * unresolved_e4441769, 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff))) { return 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff >> (unresolved_7c3f33d6 + (value2 * unresolved_e4441769)); } return stor_e; } function Unknown_0d84ed30(address arg0) public onlyOwner { require(arg0 != address(0), BadConfig()); unresolved_7baa1165 = arg0; emit Event_8e6a36ee(0, unresolved_7baa1165); } function quote(address arg0) public returns (bool) { uint256 var_a; if (((var_a + 0xc0) > 0xffffffffffffffff) | ((var_a + 0xc0) < var_a)) _desolexPanic(65); var_a = var_a + 0xc0; uint256 value0 = 0x01; if ((stor_a + 0x01) > 0x01f4) { value0 = (0x02 + (((stor_a + 0x01) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } if (miningOpen) { if (0x2710 <= stor_a) { } } else { } if (((var_a + 0x80) > 0xffffffffffffffff) | ((var_a + 0x80) < var_a)) _desolexPanic(65); var_a = var_a + 0x80; if (bytes1(var_a.length) == 0x01) { uint256 value1 = 0; bool flag0 = !(0x0a > (uint16(var_a.length))); if (bytes1(var_n)) { value1 = var_a; flag0 = !(bytes1(var_n)); } if (flag0) { } } else { if (((var_a + 0x80) > 0xffffffffffffffff) | ((var_a + 0x80) < var_a)) _desolexPanic(65); var_a = var_a + 0x80; bool flag1 = !(!(uint16(var_y))); if (bytes1(var_a.length) == 0x01) { flag1 = (bytes1(var_a.length)) == 0x01; } bool flag2 = !(0x03 > (uint16(var_z))); if (flag1) { flag2 = flag1; } uint256 value4 = 0; if (!(flag2)) { uint256 value2 = 0; uint256 value3 = 0; bool flag3 = !(bytes1(var_aa) == (bytes1(var_a.length))); if (!(bytes1(var_aa))) { value2 = bytes1(var_aa); value3 = bytes1(var_a.length); flag3 = !(!(bytes1(var_aa))); } uint256 value22 = 0; if (!(flag3)) { value22 = ((0x03 - (uint16(var_z))) ^ (0x0fa0 - freeUsed) * ((0x03 - (uint16(var_z))) < (0x0fa0 - freeUsed))) ^ (0x0fa0 - freeUsed); } value4 = value22; } if (value4 != 0x0) { } else { address account0 = address(0); uint256 value6 = 0; if (!(bytes1(var_n))) { uint256 value5 = 0x05; if (0 != !(0x14 > unresolved_337900e0[arg0][bytes1(var_a.length)])) { value5 = 0x04; } } else { account0 = arg0; value6 = var_a + 0x20; } uint256 value7 = 0x01; if (!((stor_a + 0x01) <= 0x01f4)) { value7 = (0x02 + (((stor_a + 0x01) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } if (((var_a + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); (bool success0, bytes memory returnData0) = address(0x0567f2323251f0aab15c8dfb1967e4e8a7d42aee).latestRoundData{ gas: 0x030d40 }(); // staticcall uint256 value8 = 0x60; if ((returnData0.length) != 0x0) { if (returnData0.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value8 = var_a; } bool flag4 = var_ag < 0xa0; if (!success0) { flag4 = !success0; } uint256 value10 = 0; uint256 value11 = 0; uint256 value12 = 0; if (!(flag4)) { require(((value8 + var_ag) - value8) >= 0xa0); uint256 value23 = 0; uint256 value24 = 0; uint256 value25 = 0; if (var_ah > 0) { uint256 value9 = (var_ah * 0x05f5e100) / (0x0a ** 0x08); if (((var_ah * 0x05f5e100) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (var_ah * 0x05f5e100) == (((var_ah * 0x05f5e100) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (var_ah * 0x05f5e100))) { } else { uint256 sharedExpr15 = (0x0a ** 0x08) & (0 - (0x0a ** 0x08)); uint256 sharedExpr16 = 0x03 * ((0x0a ** 0x08) / sharedExpr15); uint256 sharedExpr17 = 0x02 - (((0x0a ** 0x08) / sharedExpr15) * (sharedExpr16 ^ 0x02)); uint256 sharedExpr18 = sharedExpr16 ^ 0x02; uint256 sharedExpr19 = 0x02 - (((0x0a ** 0x08) / sharedExpr15) * (sharedExpr17 * sharedExpr18)); uint256 sharedExpr20 = sharedExpr17 * sharedExpr18; uint256 sharedExpr21 = 0x02 - (((0x0a ** 0x08) / sharedExpr15) * (sharedExpr19 * sharedExpr20)); uint256 sharedExpr22 = sharedExpr19 * sharedExpr20; uint256 sharedExpr23 = 0x02 - (((0x0a ** 0x08) / sharedExpr15) * (sharedExpr21 * sharedExpr22)); uint256 sharedExpr24 = sharedExpr21 * sharedExpr22; uint256 sharedExpr25 = 0x02 - (((0x0a ** 0x08) / sharedExpr15) * (sharedExpr23 * sharedExpr24)); uint256 sharedExpr26 = sharedExpr23 * sharedExpr24; uint256 sharedExpr27 = var_ah; uint256 sharedExpr28 = var_ah; uint256 sharedExpr29 = var_ah; uint256 sharedExpr30 = (0x0a ** 0x08) & (0 - (0x0a ** 0x08)); uint256 sharedExpr31 = 0x03 * ((0x0a ** 0x08) / sharedExpr30); uint256 sharedExpr32 = 0x02 - (((0x0a ** 0x08) / sharedExpr30) * (sharedExpr31 ^ 0x02)); uint256 sharedExpr33 = sharedExpr31 ^ 0x02; uint256 sharedExpr34 = 0x02 - (((0x0a ** 0x08) / sharedExpr30) * (sharedExpr32 * sharedExpr33)); uint256 sharedExpr35 = sharedExpr32 * sharedExpr33; uint256 sharedExpr36 = 0x02 - (((0x0a ** 0x08) / sharedExpr30) * (sharedExpr34 * sharedExpr35)); uint256 sharedExpr37 = sharedExpr34 * sharedExpr35; uint256 sharedExpr38 = 0x02 - (((0x0a ** 0x08) / sharedExpr30) * (sharedExpr36 * sharedExpr37)); uint256 sharedExpr39 = sharedExpr36 * sharedExpr37; uint256 sharedExpr40 = 0x02 - (((0x0a ** 0x08) / sharedExpr30) * (sharedExpr38 * sharedExpr39)); uint256 sharedExpr41 = sharedExpr38 * sharedExpr39; value9 = ((sharedExpr27 * 0x05f5e100) - ((sharedExpr28 * 0x05f5e100) % (0x0a ** 0x08)) / ((0x0a ** 0x08) & (0 - (0x0a ** 0x08))) | (((sharedExpr29 * 0x05f5e100) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (sharedExpr27 * 0x05f5e100) - (((sharedExpr29 * 0x05f5e100) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (sharedExpr27 * 0x05f5e100)) - ((sharedExpr28 * 0x05f5e100) % (0x0a ** 0x08) > (sharedExpr27 * 0x05f5e100)) * ((0 - ((0x0a ** 0x08) & (0 - (0x0a ** 0x08)))) / ((0x0a ** 0x08) & (0 - (0x0a ** 0x08))) + 0x01))) * ((0x02 - (((0x0a ** 0x08) / sharedExpr30) * (sharedExpr40 * sharedExpr41))) * (sharedExpr40 * sharedExpr41)); } value23 = var_ai; value24 = value9; value25 = 0x01; } value10 = value23; value11 = value24; value12 = value25; } uint256 value13 = (!(value10 > block.timestamp)) ? 1 : 0; if (value12 == 0) { value13 = value12; } uint256 value14 = 0; bool flag5 = !(0x0e10 < (block.timestamp - value10)); if (value13 != 0x0) { } else { value14 = value10; flag5 = value13 != 0x0; } uint256 value19 = 0x01; uint256 value20 = value11; if (!(flag5)) { uint256 value18 = 0; if (((var_a + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + ((0x24 + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); (bool success1, bytes memory returnData1) = address(0x16b9a82891338f9ba80e2d6970fdda79d1eb0dae).getReserves{ gas: 0x030d40 }(); // staticcall uint256 value15 = 0x60; if ((returnData1.length) != 0x0) { if (returnData1.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData1.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) > 0xffffffffffffffff) | ((var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData1.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0))) < var_a)) _desolexPanic(65); var_a = var_a + (((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData1.length))) + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value15 = var_a; } bool flag6 = var_aj < 0x60; if (!success1) { flag6 = !success1; } uint256 value28 = 0; if (!(flag6)) { require(((value15 + var_aj) - value15) >= 0x60); uint256 value16 = var_ak; uint256 value17 = var_al; bool flag7 = value16 == 0x0; if (value17 == 0) { flag7 = value17 == 0x0; } bool flag8 = value17 > 0xffffffffffffffffffffffffffff; if (flag7) { flag8 = flag7; } uint256 value29 = 0; if (((flag8) && (value16 > 0xffffffffffffffffffffffffffff)) || (flag8)) { uint256 value30 = (value16 * (0x0a ** 0x1a)) / (value17 * (0x0a ** 0x12)); if (((value16 * (0x0a ** 0x1a)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (value16 * (0x0a ** 0x1a)) == (((value16 * (0x0a ** 0x1a)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (value16 * (0x0a ** 0x1a)))) { } else { uint256 sharedExpr59 = value17 * (0x0a ** 0x12); uint256 sharedExpr60 = value17 * (0x0a ** 0x12); uint256 sharedExpr61 = 0 - (value17 * (0x0a ** 0x12)); uint256 sharedExpr62 = value17 * (0x0a ** 0x12); uint256 sharedExpr63 = sharedExpr60 & sharedExpr61; uint256 sharedExpr64 = 0x03 * (sharedExpr62 / sharedExpr63); uint256 sharedExpr65 = 0x02 - ((sharedExpr62 / sharedExpr63) * (sharedExpr64 ^ 0x02)); uint256 sharedExpr66 = sharedExpr64 ^ 0x02; uint256 sharedExpr67 = 0x02 - ((sharedExpr62 / sharedExpr63) * (sharedExpr65 * sharedExpr66)); uint256 sharedExpr68 = sharedExpr65 * sharedExpr66; uint256 sharedExpr69 = 0x02 - ((sharedExpr62 / sharedExpr63) * (sharedExpr67 * sharedExpr68)); uint256 sharedExpr70 = sharedExpr67 * sharedExpr68; uint256 sharedExpr71 = 0x02 - ((sharedExpr62 / sharedExpr63) * (sharedExpr69 * sharedExpr70)); uint256 sharedExpr72 = sharedExpr69 * sharedExpr70; uint256 sharedExpr73 = 0x02 - ((sharedExpr62 / sharedExpr63) * (sharedExpr71 * sharedExpr72)); uint256 sharedExpr74 = sharedExpr71 * sharedExpr72; uint256 sharedExpr75 = value17 * (0x0a ** 0x12); uint256 sharedExpr76 = value17 * (0x0a ** 0x12); uint256 sharedExpr77 = 0 - (value17 * (0x0a ** 0x12)); uint256 sharedExpr78 = value17 * (0x0a ** 0x12); uint256 sharedExpr79 = sharedExpr76 & sharedExpr77; uint256 sharedExpr80 = 0x03 * (sharedExpr78 / sharedExpr79); uint256 sharedExpr81 = 0x02 - ((sharedExpr78 / sharedExpr79) * (sharedExpr80 ^ 0x02)); uint256 sharedExpr82 = sharedExpr80 ^ 0x02; uint256 sharedExpr83 = 0x02 - ((sharedExpr78 / sharedExpr79) * (sharedExpr81 * sharedExpr82)); uint256 sharedExpr84 = sharedExpr81 * sharedExpr82; uint256 sharedExpr85 = 0x02 - ((sharedExpr78 / sharedExpr79) * (sharedExpr83 * sharedExpr84)); uint256 sharedExpr86 = sharedExpr83 * sharedExpr84; uint256 sharedExpr87 = 0x02 - ((sharedExpr78 / sharedExpr79) * (sharedExpr85 * sharedExpr86)); uint256 sharedExpr88 = sharedExpr85 * sharedExpr86; uint256 sharedExpr89 = 0x02 - ((sharedExpr78 / sharedExpr79) * (sharedExpr87 * sharedExpr88)); uint256 sharedExpr90 = sharedExpr87 * sharedExpr88; uint256 sharedExpr91 = ((value16 * (0x0a ** 0x1a)) - ((value16 * (0x0a ** 0x1a)) % sharedExpr75) / (sharedExpr76 & sharedExpr77) | (((value16 * (0x0a ** 0x1a)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (value16 * (0x0a ** 0x1a)) - (((value16 * (0x0a ** 0x1a)) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (value16 * (0x0a ** 0x1a))) - (((value16 * (0x0a ** 0x1a)) % sharedExpr75) > (value16 * (0x0a ** 0x1a))) * ((0 - (sharedExpr76 & sharedExpr77)) / (sharedExpr76 & sharedExpr77) + 0x01))) * ((0x02 - ((sharedExpr78 / sharedExpr79) * (sharedExpr89 * sharedExpr90))) * (sharedExpr89 * sharedExpr90)); value30 = sharedExpr91; } value29 = value30; } value28 = value29; } value18 = value28; uint256 value26 = 0x02; uint256 value27 = value18; if (!(value18 != 0x0)) { uint256 value31 = 0x03; uint256 value32 = value11; if (!(value12 != 0x0)) { value31 = 0x04; value32 = lastGoodPrice; } value26 = value31; value27 = value32; } value19 = value26; value20 = value27; } uint256 value21 = (var_t * 0x0de0b6b3a7640000) / value20; if (((var_t * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (var_t * 0x0de0b6b3a7640000) == (((var_t * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (var_t * 0x0de0b6b3a7640000))) { } else { uint256 sharedExpr107 = value20 & (0 - value20); uint256 sharedExpr108 = 0x03 * (value20 / sharedExpr107); uint256 sharedExpr109 = 0x02 - ((value20 / sharedExpr107) * (sharedExpr108 ^ 0x02)); uint256 sharedExpr110 = sharedExpr108 ^ 0x02; uint256 sharedExpr111 = 0x02 - ((value20 / sharedExpr107) * (sharedExpr109 * sharedExpr110)); uint256 sharedExpr112 = sharedExpr109 * sharedExpr110; uint256 sharedExpr113 = 0x02 - ((value20 / sharedExpr107) * (sharedExpr111 * sharedExpr112)); uint256 sharedExpr114 = sharedExpr111 * sharedExpr112; uint256 sharedExpr115 = 0x02 - ((value20 / sharedExpr107) * (sharedExpr113 * sharedExpr114)); uint256 sharedExpr116 = sharedExpr113 * sharedExpr114; uint256 sharedExpr117 = 0x02 - ((value20 / sharedExpr107) * (sharedExpr115 * sharedExpr116)); uint256 sharedExpr118 = sharedExpr115 * sharedExpr116; uint256 sharedExpr119 = var_a; uint256 sharedExpr120 = var_am; uint256 sharedExpr121 = value20 & (0 - value20); uint256 sharedExpr122 = 0x03 * (value20 / sharedExpr121); uint256 sharedExpr123 = 0x02 - ((value20 / sharedExpr121) * (sharedExpr122 ^ 0x02)); uint256 sharedExpr124 = sharedExpr122 ^ 0x02; uint256 sharedExpr125 = 0x02 - ((value20 / sharedExpr121) * (sharedExpr123 * sharedExpr124)); uint256 sharedExpr126 = sharedExpr123 * sharedExpr124; uint256 sharedExpr127 = 0x02 - ((value20 / sharedExpr121) * (sharedExpr125 * sharedExpr126)); uint256 sharedExpr128 = sharedExpr125 * sharedExpr126; uint256 sharedExpr129 = 0x02 - ((value20 / sharedExpr121) * (sharedExpr127 * sharedExpr128)); uint256 sharedExpr130 = sharedExpr127 * sharedExpr128; uint256 sharedExpr131 = 0x02 - ((value20 / sharedExpr121) * (sharedExpr129 * sharedExpr130)); uint256 sharedExpr132 = sharedExpr129 * sharedExpr130; uint256 sharedExpr133 = ((var_t * 0x0de0b6b3a7640000) - ((var_t * 0x0de0b6b3a7640000) % value20) / (value20 & (0 - value20)) | (((var_t * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) - (var_t * 0x0de0b6b3a7640000) - (((var_t * 0x0de0b6b3a7640000) % 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < (var_t * 0x0de0b6b3a7640000)) - (((var_t * 0x0de0b6b3a7640000) % value20) > (var_t * 0x0de0b6b3a7640000)) * ((0 - (value20 & (0 - value20))) / (value20 & (0 - value20)) + 0x01))) * ((0x02 - ((value20 / sharedExpr121) * (sharedExpr131 * sharedExpr132))) * (sharedExpr131 * sharedExpr132)); value21 = sharedExpr133; } } } return abi.encodePacked(bytes1(var_a.length), bytes1(var_ap), !(!(var_aq)), var_ar, var_as, bytes1(var_at)); } function approve(address spender, uint256 amount) public { require(ownerOf[amount], ERC721NonexistentToken()); bool flag0 = !(msg.sender == ownerOf[amount]); if (!msg.sender) { flag0 = msg.sender != address(0); } bool flag4; if (flag0) { bool flag1 = !(!(msg.sender)); if (msg.sender != marketplace) { flag1 = (msg.sender) == marketplace; } bool flag2 = !(unresolved_50cd382e[address(ownerOf[amount])]); if (flag1) { } else { flag2 = flag1; } flag4 = 0x1 == 0x0; if (!(flag2)) { flag4 = !(bytes1(mapping_5[address(ownerOf[amount])][msg.sender])); } } require(!(flag0 && flag4), ERC721InvalidApprover()); emit Approval(ownerOf[amount], spender, amount); getApproved[amount] = spender | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & getApproved[amount]); } function name() public view returns (string memory) { return _name; } function Unknown_05c14577(uint256 arg0) public pure returns (uint256) { uint256 value0 = 0x01; if (!(arg0 <= 0x01f4)) { value0 = (0x02 + ((arg0 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x03e8)) - (0x01f4 / 0x03e8); } return 0x989680 * (bytes1(value0 + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff)); } function revenueTotal() public view returns (uint256) { if ((((address(this).balance + devReleased) + unresolved_b1e8557c) + rewardClaimedTotal) > rewardAccrued) { return (((address(this).balance + devReleased) + unresolved_b1e8557c) + rewardClaimedTotal) - rewardAccrued; } return 0; } function supportsInterface(bytes4 interfaceId) public pure returns (bool) { require(interfaceId == (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000)); uint256 value1 = msg.data[0] >> 0xe0; bool flag2; if ((interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000) != 0x2a55205a00000000000000000000000000000000000000000000000000000000) { bool flag0 = (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000) == 0x5b5e139f00000000000000000000000000000000000000000000000000000000; if (interfaceId & (0xffffffff00000000000000000000000000000000000000000000000000000000) == 0x80ac58cd00000000000000000000000000000000000000000000000000000000) { flag0 = (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000) == 0x80ac58cd00000000000000000000000000000000000000000000000000000000; } uint256 value0 = msg.data[0] >> 0xe0; bool flag1 = 0x1ffc9a700000000000000000000000000000000000000000000000000000000 == (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000); if (flag0) { value0 = interfaceId & (0xffffffff00000000000000000000000000000000000000000000000000000000); flag1 = flag0; } flag2 = flag1; } else { value1 = interfaceId & (0xffffffff00000000000000000000000000000000000000000000000000000000); flag2 = (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000) == 0x2a55205a00000000000000000000000000000000000000000000000000000000; } return flag2; } function Unknown_01595fa6() public onlyOwner { stor_15_0_0 = true; emit Event_7642a0bd(); } function internal_4346(address arg0, address arg1, uint256 arg2) private { require(arg1 != address(0), ERC721InvalidReceiver()); if (unresolved_64c37584[arg2]) { if (ownerOf[arg2] != address(0)) { if (!mapping_25[arg2]) { internal_4ba7(); } address account3 = address(0); if ((!mapping_25[arg2]) && ((stor_1c != 0x0) && (block.timestamp >= value7))) { mapping_25[arg2] = true; mapping_24[arg2] = (ownerOf[arg2] & (0xffffffffffffffffffffffffffffffffffffffff)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & mapping_24[arg2]); emit Event_d94d502d(arg2, ownerOf[arg2]); } else { account3 = ownerOf[arg2]; } } else { unresolved_31698b91 = 0x01 + unresolved_31698b91; if (stor_18 == (0x01 + unresolved_31698b91)) { stor_1c = block.timestamp; } } } uint256 value0 = 0; if (msg.sender != address(0)) { uint256 value9; uint256 value8; if (!(ownerOf[arg2] == msg.sender)) { uint256 value18; if (msg.sender == marketplace) { bool flag7 = !(unresolved_50cd382e[ownerOf[arg2]]); if (!((!(!(address(msg.sender)))))) { flag7 = (!(!(address(msg.sender)))); } if (flag7) { if (ownerOf[arg2] != 0x0) { getApproved[arg2] = address(0); balanceOf[ownerOf[arg2]] = balanceOf[ownerOf[arg2]] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[arg1] = balanceOf[arg1] + 0x01; ownerOf[arg2] = (ownerOf[arg2] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | arg1; emit Transfer(ownerOf[arg2], arg1, arg2); require(ownerOf[arg2] == arg0, ERC721IncorrectOwner()); } else { if (bytes1(mapping_5[ownerOf[arg2]][address(msg.sender)]) != 0x0) { if (ownerOf[arg2] != 0x0) { getApproved[arg2] = address(0); balanceOf[ownerOf[arg2]] = balanceOf[ownerOf[arg2]] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[arg1] = balanceOf[arg1] + 0x01; ownerOf[arg2] = (ownerOf[arg2] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | arg1; emit Transfer(ownerOf[arg2], arg1, arg2); require(ownerOf[arg2] == arg0, ERC721IncorrectOwner()); } else { if (!(msg.sender == getApproved[arg2])) { require(ownerOf[arg2] != 0x0, ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } else { if (ownerOf[arg2] != 0x0) { getApproved[arg2] = address(0); balanceOf[ownerOf[arg2]] = balanceOf[ownerOf[arg2]] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[arg1] = balanceOf[arg1] + 0x01; ownerOf[arg2] = (ownerOf[arg2] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | arg1; emit Transfer(ownerOf[arg2], arg1, arg2); require(ownerOf[arg2] == arg0, ERC721IncorrectOwner()); } } } } else { value18 = 0x01; value18 = bytes1(mapping_5[address(ownerOf[arg2])][msg.sender]); } value8 = value18; } else { value8 = (ownerOf[arg2] == msg.sender) ? 1 : 0; } uint256 value17 = value8; if (value8 == 0) { value17 = (msg.sender == getApproved[arg2]) ? 1 : 0; } value9 = value17; if (value9 == 0x0) { require(ownerOf[arg2] != address(0), ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } } else { flag8 = msg.sender != address(0); } if (ownerOf[arg2] != address(0)) { getApproved[arg2] = address(0); balanceOf[ownerOf[arg2]] = balanceOf[ownerOf[arg2]] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[arg1] = balanceOf[arg1] + 0x01; ownerOf[arg2] = (ownerOf[arg2] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | arg1; emit Transfer(ownerOf[arg2], arg1, arg2); require(ownerOf[arg2] == arg0, ERC721IncorrectOwner()); } function internal_4ba7() private returns (uint256) { if (stor_1c) { uint256 value7 = internal_4cdc(); return !(block.timestamp < value7); } else { return stor_1c; } } function internal_4cdc() private returns (uint256) { if (stor_1a == 0) { return 0; } else { if (!stor_1c) { internal_4cf0(stor_1a, block.timestamp); address account1 = address(0); if ((!(block.timestamp < value2))) { mapping_25[arg2] = true; mapping_24[arg2] = ownerOf[arg0] | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & mapping_24[arg2]); emit Event_d94d502d(arg2, ownerOf[arg0]); } else { account1 = ownerOf[arg0]; } uint256 value0 = 0; if (msg.sender != address(0)) { uint256 value4; uint256 value3; if (!(ownerOf[arg2] == msg.sender)) { uint256 value14; if (msg.sender == marketplace) { bool flag2 = !(unresolved_50cd382e[__desolex_internal_4e28_1028_arg1]); if (!(__desolex_internal_4e28_1028_arg0)) { flag2 = __desolex_internal_4e28_1028_arg0; } if (flag2) { if (__desolex_internal_4e28_1028_arg7 != 0x0) { getApproved[__desolex_internal_4e28_1028_arg6] = address(0); balanceOf[__desolex_internal_4e28_1028_arg7] = balanceOf[__desolex_internal_4e28_1028_arg7] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[__desolex_internal_4e28_1028_arg4] = balanceOf[__desolex_internal_4e28_1028_arg4] + 0x01; ownerOf[__desolex_internal_4e28_1028_arg6] = (ownerOf[__desolex_internal_4e28_1028_arg6] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | __desolex_internal_4e28_1028_arg4; emit Transfer(__desolex_internal_4e28_1028_arg7, __desolex_internal_4e28_1028_arg4, __desolex_internal_4e28_1028_arg6); require(__desolex_internal_4e28_1028_arg7 == __desolex_internal_4e28_1028_arg5, ERC721IncorrectOwner()); } else { if (bytes1(mapping_5[__desolex_internal_4e28_1028_arg1][__desolex_internal_4e28_1028_arg2]) != 0x0) { if (__desolex_internal_4e28_1028_arg7 != 0x0) { getApproved[__desolex_internal_4e28_1028_arg6] = address(0); balanceOf[__desolex_internal_4e28_1028_arg7] = balanceOf[__desolex_internal_4e28_1028_arg7] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[__desolex_internal_4e28_1028_arg4] = balanceOf[__desolex_internal_4e28_1028_arg4] + 0x01; ownerOf[__desolex_internal_4e28_1028_arg6] = (ownerOf[__desolex_internal_4e28_1028_arg6] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | __desolex_internal_4e28_1028_arg4; emit Transfer(__desolex_internal_4e28_1028_arg7, __desolex_internal_4e28_1028_arg4, __desolex_internal_4e28_1028_arg6); require(__desolex_internal_4e28_1028_arg7 == __desolex_internal_4e28_1028_arg5, ERC721IncorrectOwner()); } else { if (!(msg.sender == getApproved[__desolex_internal_4e28_1028_arg6])) { require(__desolex_internal_4e28_1028_arg7 != 0x0, ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } else { if (__desolex_internal_4e28_1028_arg7 != 0x0) { getApproved[__desolex_internal_4e28_1028_arg6] = address(0); balanceOf[__desolex_internal_4e28_1028_arg7] = balanceOf[__desolex_internal_4e28_1028_arg7] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[__desolex_internal_4e28_1028_arg4] = balanceOf[__desolex_internal_4e28_1028_arg4] + 0x01; ownerOf[__desolex_internal_4e28_1028_arg6] = (ownerOf[__desolex_internal_4e28_1028_arg6] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | __desolex_internal_4e28_1028_arg4; emit Transfer(__desolex_internal_4e28_1028_arg7, __desolex_internal_4e28_1028_arg4, __desolex_internal_4e28_1028_arg6); require(__desolex_internal_4e28_1028_arg7 == __desolex_internal_4e28_1028_arg5, ERC721IncorrectOwner()); } } } } else { value14 = 0x01; value14 = bytes1(mapping_5[address(ownerOf[arg2])][msg.sender]); } value3 = value14; } else { value3 = (ownerOf[arg2] == msg.sender) ? 1 : 0; } uint256 value13 = value3; if (value3 == 0) { value13 = (msg.sender == getApproved[arg2]) ? 1 : 0; } value4 = value13; if (value4 == 0x0) { require(ownerOf[arg2] != address(0), ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } } else { flag3 = msg.sender != address(0); } if (ownerOf[arg2] != address(0)) { getApproved[arg2] = address(0); balanceOf[ownerOf[arg2]] = balanceOf[ownerOf[arg2]] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[address(arg1)] = balanceOf[address(arg1)] + 0x01; ownerOf[arg2] = (ownerOf[arg2] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | address(arg1); emit Transfer(ownerOf[arg2], address(arg1), arg2); require(ownerOf[arg2] == arg0, ERC721IncorrectOwner()); } else { if (!(stor_1c > stor_1a)) { return stor_1a; } else { if (0x015180 != 0) { address account2 = address(0); if (!(block.timestamp < (stor_1a + ((!(!(stor_1c - stor_1a))) * ((((stor_1c - stor_1a) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x015180) + 0x01) * 0x015180)))) { mapping_25[arg2] = true; mapping_24[arg2] = ownerOf[arg2] | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & mapping_24[arg2]); emit Event_d94d502d(arg2, ownerOf[arg2]); } else { account2 = ownerOf[arg2]; } uint256 value1 = 0; if (msg.sender != address(0)) { uint256 value6; uint256 value5; if (!(ownerOf[arg2] == msg.sender)) { uint256 value16; if (msg.sender == marketplace) { bool flag4 = !(unresolved_50cd382e[__desolex_internal_4e28_1028_arg1]); if (!(__desolex_internal_4e28_1028_arg0)) { flag4 = __desolex_internal_4e28_1028_arg0; } if (flag4) { if (__desolex_internal_4e28_1028_arg7 != 0x0) { getApproved[__desolex_internal_4e28_1028_arg6] = address(0); balanceOf[__desolex_internal_4e28_1028_arg7] = balanceOf[__desolex_internal_4e28_1028_arg7] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[__desolex_internal_4e28_1028_arg4] = balanceOf[__desolex_internal_4e28_1028_arg4] + 0x01; ownerOf[__desolex_internal_4e28_1028_arg6] = (ownerOf[__desolex_internal_4e28_1028_arg6] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | __desolex_internal_4e28_1028_arg4; emit Transfer(__desolex_internal_4e28_1028_arg7, __desolex_internal_4e28_1028_arg4, __desolex_internal_4e28_1028_arg6); require(__desolex_internal_4e28_1028_arg7 == __desolex_internal_4e28_1028_arg5, ERC721IncorrectOwner()); } else { if (bytes1(mapping_5[__desolex_internal_4e28_1028_arg1][__desolex_internal_4e28_1028_arg2]) != 0x0) { if (__desolex_internal_4e28_1028_arg7 != 0x0) { getApproved[__desolex_internal_4e28_1028_arg6] = address(0); balanceOf[__desolex_internal_4e28_1028_arg7] = balanceOf[__desolex_internal_4e28_1028_arg7] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[__desolex_internal_4e28_1028_arg4] = balanceOf[__desolex_internal_4e28_1028_arg4] + 0x01; ownerOf[__desolex_internal_4e28_1028_arg6] = (ownerOf[__desolex_internal_4e28_1028_arg6] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | __desolex_internal_4e28_1028_arg4; emit Transfer(__desolex_internal_4e28_1028_arg7, __desolex_internal_4e28_1028_arg4, __desolex_internal_4e28_1028_arg6); require(__desolex_internal_4e28_1028_arg7 == __desolex_internal_4e28_1028_arg5, ERC721IncorrectOwner()); } else { if (!(msg.sender == getApproved[__desolex_internal_4e28_1028_arg6])) { require(__desolex_internal_4e28_1028_arg7 != 0x0, ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } else { if (__desolex_internal_4e28_1028_arg7 != 0x0) { getApproved[__desolex_internal_4e28_1028_arg6] = address(0); balanceOf[__desolex_internal_4e28_1028_arg7] = balanceOf[__desolex_internal_4e28_1028_arg7] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[__desolex_internal_4e28_1028_arg4] = balanceOf[__desolex_internal_4e28_1028_arg4] + 0x01; ownerOf[__desolex_internal_4e28_1028_arg6] = (ownerOf[__desolex_internal_4e28_1028_arg6] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | __desolex_internal_4e28_1028_arg4; emit Transfer(__desolex_internal_4e28_1028_arg7, __desolex_internal_4e28_1028_arg4, __desolex_internal_4e28_1028_arg6); require(__desolex_internal_4e28_1028_arg7 == __desolex_internal_4e28_1028_arg5, ERC721IncorrectOwner()); } } } } else { value16 = 0x01; value16 = bytes1(mapping_5[address(ownerOf[arg2])][msg.sender]); } value5 = value16; } else { value5 = (ownerOf[arg2] == msg.sender) ? 1 : 0; } uint256 value15 = (value5) ? 1 : 0; if (!(value5)) { value15 = (msg.sender == getApproved[arg2]) ? 1 : 0; } value6 = value15; if (value6 == 0x0) { require(ownerOf[arg2] != address(0), ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } } else { flag5 = msg.sender != address(0); } if (ownerOf[arg2] != address(0)) { getApproved[arg2] = address(0); balanceOf[ownerOf[arg2]] = balanceOf[ownerOf[arg2]] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[address(arg1)] = balanceOf[address(arg1)] + 0x01; ownerOf[arg2] = (ownerOf[arg2] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | address(arg1); emit Transfer(ownerOf[arg2], address(arg1), arg2); require(ownerOf[arg2] == arg0, ERC721IncorrectOwner()); } return stor_1c; } } } } function internal_4cf0(uint256 arg0, uint256 arg1) private returns (uint256) { if (arg1 <= arg0) { return arg0; } else { if (0x015180 != 0) { address account0 = address(0); if (!(block.timestamp < (arg0 + ((!(!(arg1 - arg0))) * ((((arg1 - arg0) + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) / 0x015180) + 0x01) * 0x015180)))) { mapping_25[arg2] = true; mapping_24[arg2] = ownerOf[arg2] | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & mapping_24[arg2]); emit Event_d94d502d(arg2, ownerOf[arg2]); } else { account0 = ownerOf[arg2]; } uint256 value2 = 0; if (msg.sender != address(0)) { uint256 value1; uint256 value0; if (!(ownerOf[arg2] == msg.sender)) { uint256 value12; if (__desolex_internal_4e10_44cc_arg1 == marketplace) { bool flag0 = !(unresolved_50cd382e[__desolex_internal_4e28_1028_arg1]); if (!(__desolex_internal_4e28_1028_arg0)) { flag0 = __desolex_internal_4e28_1028_arg0; } if (flag0) { if (__desolex_internal_4e28_1028_arg7 != 0x0) { getApproved[__desolex_internal_4e28_1028_arg6] = address(0); balanceOf[__desolex_internal_4e28_1028_arg7] = balanceOf[__desolex_internal_4e28_1028_arg7] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[__desolex_internal_4e28_1028_arg4] = balanceOf[__desolex_internal_4e28_1028_arg4] + 0x01; ownerOf[__desolex_internal_4e28_1028_arg6] = (ownerOf[__desolex_internal_4e28_1028_arg6] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | __desolex_internal_4e28_1028_arg4; emit Transfer(__desolex_internal_4e28_1028_arg7, __desolex_internal_4e28_1028_arg4, __desolex_internal_4e28_1028_arg6); require(__desolex_internal_4e28_1028_arg7 == __desolex_internal_4e28_1028_arg5, ERC721IncorrectOwner()); } else { if (bytes1(mapping_5[__desolex_internal_4e28_1028_arg1][__desolex_internal_4e28_1028_arg2]) != 0x0) { if (__desolex_internal_4e28_1028_arg7 != 0x0) { getApproved[__desolex_internal_4e28_1028_arg6] = address(0); balanceOf[__desolex_internal_4e28_1028_arg7] = balanceOf[__desolex_internal_4e28_1028_arg7] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[__desolex_internal_4e28_1028_arg4] = balanceOf[__desolex_internal_4e28_1028_arg4] + 0x01; ownerOf[__desolex_internal_4e28_1028_arg6] = (ownerOf[__desolex_internal_4e28_1028_arg6] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | __desolex_internal_4e28_1028_arg4; emit Transfer(__desolex_internal_4e28_1028_arg7, __desolex_internal_4e28_1028_arg4, __desolex_internal_4e28_1028_arg6); require(__desolex_internal_4e28_1028_arg7 == __desolex_internal_4e28_1028_arg5, ERC721IncorrectOwner()); } else { if (!(msg.sender == getApproved[__desolex_internal_4e28_1028_arg6])) { require(__desolex_internal_4e28_1028_arg7 != 0x0, ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } else { if (__desolex_internal_4e28_1028_arg7 != 0x0) { getApproved[__desolex_internal_4e28_1028_arg6] = address(0); balanceOf[__desolex_internal_4e28_1028_arg7] = balanceOf[__desolex_internal_4e28_1028_arg7] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[__desolex_internal_4e28_1028_arg4] = balanceOf[__desolex_internal_4e28_1028_arg4] + 0x01; ownerOf[__desolex_internal_4e28_1028_arg6] = (ownerOf[__desolex_internal_4e28_1028_arg6] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | __desolex_internal_4e28_1028_arg4; emit Transfer(__desolex_internal_4e28_1028_arg7, __desolex_internal_4e28_1028_arg4, __desolex_internal_4e28_1028_arg6); require(__desolex_internal_4e28_1028_arg7 == __desolex_internal_4e28_1028_arg5, ERC721IncorrectOwner()); } } } } else { value12 = 0x01; value12 = bytes1(mapping_5[address(ownerOf[arg2])][msg.sender]); } value0 = value12; } else { value0 = (ownerOf[arg2] == msg.sender) ? 1 : 0; } uint256 value11 = value0; if (value0 == 0) { value11 = (msg.sender == getApproved[arg2]) ? 1 : 0; } value1 = value11; if (value1 == 0x0) { require(ownerOf[arg2] != address(0), ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } } else { flag1 = msg.sender != address(0); } if (ownerOf[arg2] != address(0)) { getApproved[arg2] = address(0); balanceOf[ownerOf[arg2]] = balanceOf[ownerOf[arg2]] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } balanceOf[address(arg1)] = balanceOf[address(arg1)] + 0x01; ownerOf[arg2] = (ownerOf[arg2] & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | address(arg1); emit Transfer(ownerOf[arg2], address(arg1), arg2); require(ownerOf[arg2] == arg0, ERC721IncorrectOwner()); } return arg1; } } 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. // 0x01595fa6 => Unknown_01595fa6() // 0x01ffc9a7 => supportsInterface(bytes4) // 0x03183e0e => revenueTotal() // 0x0490be83 => lastGoodPrice() // 0x05c14577 => Unknown_05c14577(uint256) // 0x06dae220 => unresolved_06dae220() // 0x06fdde03 => name() // 0x07312654 => minedBy(address) // 0x081812fc => getApproved(uint256) // 0x095ea7b3 => approve(address,uint256) // 0x09d16642 => unresolved_09d16642() // 0x0b39ed47 => quote(address) // 0x0cb7528a => unresolved_0cb7528a() // 0x0d1cfcae => agentRegistry() // 0x0d2a95ef => MAX_PER_BLOCK() // 0x0d84ed30 => Unknown_0d84ed30(address) // 0x14ff92fb => unresolved_14ff92fb() // 0x16ccc8c0 => targetFor(address) // 0x18160ddd => totalSupply() // 0x23b872dd => transferFrom(address,address,uint256) // 0x26c7f77c => Unknown_26c7f77c(bool) // 0x28342ecf => setAgentRegistry(address) // 0x2a55205a => royaltyInfo(uint256,uint256) // 0x2bddec58 => bitsToTarget(uint256) // 0x2f6ee695 => USD_DECIMALS() // 0x31698b91 => unresolved_31698b91() // 0x31eb318a => PRICE_FEED() // 0x329e4f4a => Unknown_329e4f4a() // 0x32cb6b0c => MAX_SUPPLY() // 0x337900e0 => unresolved_337900e0(address,bytes32) // 0x3563beda => PAID_LIMIT() // 0x39148c53 => currentTarget() // 0x3b304147 => draw(uint256) // 0x3b3b502c => PRICE_TIER_SIZE() // 0x3ccfd60b => withdraw() // 0x3dca40e6 => MAX_ROYALTY_BPS() // 0x3e5a3da4 => SOLD_OUT() // 0x42842e0e => safeTransferFrom(address,address,uint256) // 0x4434ba5f => MAX_PAID_PER_TX() // 0x458fb554 => Unknown_458fb554(address,uint256,uint256) // 0x47b12bfc => REWARD_BPS() // 0x49e96ae7 => miningOpen() // 0x4b2d292b => launchSeed() // 0x4d474898 => mine(uint256) // 0x4ec5df4f => unresolved_4ec5df4f() // 0x50b44712 => tickets(uint256) // 0x50cd382e => unresolved_50cd382e(address) // 0x51736a13 => openMining() // 0x54ce9898 => unresolved_54ce9898() // 0x55234ec0 => remaining() // 0x552512d0 => paidQuote(address,uint256) // 0x55f804b3 => setBaseURI(string) // 0x579a3d6c => isAgentHolder(address) // 0x58614dbf => bnbUsd() // 0x5892f9be => HISTORY_WINDOW() // 0x5a2718ae => PHASE1_END() // 0x5aa1edc5 => AUTO_REVEAL() // 0x5ade228a => REWARD_DURATION() // 0x6101b37f => freeUsed() // 0x6352211e => ownerOf(uint256) // 0x6373a6b1 => PROVENANCE() // 0x645b8b1b => status(address) // 0x64c37584 => unresolved_64c37584(bytes32) // 0x666abc16 => unresolved_666abc16(bytes32) // 0x6704fe9f => verify(address,uint256) // 0x679c1eda => FEED_DECIMALS() // 0x68825a39 => rewardClaimed(uint256) // 0x6cc23c5d => challengeOf(address) // 0x6fb0e8ed => unresolved_6fb0e8ed() // 0x70a08231 => balanceOf(address) // 0x714a35fb => mintBlock() // 0x715018a6 => renounceOwnership() // 0x7272ce26 => Unknown_7272ce26() // 0x73ad6c2d => setMarketplace(address) // 0x73efd92c => unresolved_73efd92c() // 0x74d30167 => unresolved_74d30167() // 0x7788338e => pendingDraws() // 0x79e186cd => rewardStatus() // 0x7a14a4e5 => TARGET_GRACE() // 0x7baa1165 => unresolved_7baa1165() // 0x7c3f33d6 => unresolved_7c3f33d6() // 0x7f8c4376 => setDifficulty(uint256,uint256) // 0x7fb202c7 => devReleased() // 0x80926dea => walletStats(address) // 0x82451915 => Unknown_82451915(bytes32) // 0x825c47f2 => Unknown_825c47f2(uint256) // 0x82829f74 => seedOf(uint256) // 0x8416e03b => unresolved_8416e03b() // 0x8da5cb5b => owner() // 0x8f2fc60b => setRoyalty(address,uint96) // 0x90061a0a => FREE_LIMIT() // 0x90399b88 => claimableReward(uint256) // 0x95d89b41 => symbol() // 0x97da4529 => unresolved_97da4529() // 0x9858cf19 => FREE_SUPPLY() // 0x9a243ebf => phaseOf(uint256) // 0x9d7f7e86 => MAX_PRICE_AGE() // 0x9dbb616f => ticketsIssued() // 0x9e8f2cb6 => SRC_CHAINLINK() // 0xa22cb465 => setApprovalForAll(address,bool) // 0xa27d30f2 => NOT_OPEN() // 0xa5c88017 => Unknown_a5c88017(address) // 0xa6a86130 => usdToWei(uint256) // 0xa7bc4e30 => REVEAL_DELAY() // 0xabc8c7af => marketplace() // 0xadf54cce => HISTORY() // 0xb1e8557c => unresolved_b1e8557c() // 0xb2d4d6a3 => rewardClaimedTotal() // 0xb6c9bc56 => rewardEnded() // 0xb79b1d35 => unresolved_b79b1d35() // 0xb88d4fde => safeTransferFrom(address,address,uint256,bytes) // 0xba296b9f => rewardTokenIds() // 0xba7e3be4 => rewardAccrued() // 0xc1e534aa => rewardEnd() // 0xc87b56dd => tokenURI(uint256) // 0xc941f055 => Unknown_c941f055() // 0xc94c7ff4 => claimReward(uint256[]) // 0xcab4c53d => Unknown_cab4c53d() // 0xcd3daf9d => rewardPerToken() // 0xd111515d => freezeMetadata() // 0xd3ce95d8 => unresolved_d3ce95d8() // 0xd48fe280 => OK() // 0xd59ac577 => Unknown_d59ac577() // 0xd7c6a43a => Unknown_d7c6a43a() // 0xdc9dbc98 => leadingZeroBits(uint256) // 0xe36c528b => workOf(uint256) // 0xe4441769 => unresolved_e4441769() // 0xe6d23cf1 => unresolved_e6d23cf1() // 0xe985e9c5 => isApprovedForAll(address,address) // 0xeaa33ca7 => Unknown_eaa33ca7(address) // 0xf2fde38b => transferOwnership(address) // 0xf30ab0d7 => MAX_BITS() // 0xfb3cc6c2 => metadataFrozen() // 0xfbccedae => releasable() // 0xfdaf00e5 => unresolved_fdaf00e5() // 0xfe66485c => PHASE_COUNT()}