BNB Chain
0xc4059d2f9f6f86695896e68f3e73e1e6cc3791c8
Decompiled Solidity recovered from this contract's runtime bytecode. Best-effort reconstruction — confirm behaviour against on-chain state.
Decompilation outputBNB Chain · 0xc4059d2f…cc3791c821.8 KB58.6 s
This result is permanently available athttps://decompiler.exvul.com/bsc/0xc4059d2f9f6f86695896e68f3e73e1e6cc3791c8
2,573 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// SPDX-License-Identifier: MITpragma solidity >=0.8.0;contract DesolexContract { address public constant agentRegistry = address(0x60b9262456de011f7d15a54cdd8c48baaa8b022f); uint256 public constant paymentToken = 489982930986835137684486657990555633941558688085; uint256 public constant MAX_SUPPLY = 9999; uint256 public constant CALLBACK_GAS_LIMIT = 100000; address public constant unresolved_595e12b1 = address(0xcee1bd3235c7119a96de107138600b4d0d19ecbf); address public constant treasury = address(0xbde905a3424f41d3a400a84e10a118e7df0f9bc7); uint256 public constant REQUEST_CONFIRMATIONS = 10; uint256 public constant marsToken = 1450632688972200390477830669319375980704760100727; uint256 public constant unresolved_9129b502 = 100000000000000000; address public constant i_vrfV2PlusWrapper = address(0x471506e6aded0b9811d05b8cac8db25ee839ac94); address public constant bnbOracle = address(0x3c5673ff9b15bf1ecd47af17050cebdcd5bd18e6); address public constant legacy = address(0x163a94c3523c404f3f58d400a3ad605f71fa09ec); uint256 public constant THIRD_PRICE = 4440000000000000000; uint256 public constant MAX_MINTS = 5; uint256 public constant POWER_SCALE = 100; uint256 public constant SECOND_PRICE = 2990000000000000000; uint256 public constant getLinkToken = 366900290382141705897032873237019319720464989045; 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)) public isApprovedForAll; // STORAGE[0x5] mapping(address => uint256) public tokenOfOwnerByIndex; // STORAGE[0x6] mapping(uint256 => uint256) mapping_7; // STORAGE[0x7] uint256[] public tokenByIndex; // STORAGE[0x8] uint256 public totalSupply; // STORAGE[0x8] mapping(uint256 => uint256) mapping_9; // STORAGE[0x9] address public owner; // STORAGE[0xa] address public pendingOwner; // STORAGE[0xb] bytes 0 to 19 bool public paused; // STORAGE[0xb] bytes 20 to 20 bytes32 stor_c; // STORAGE[0xc] mapping(uint256 => uint256) public tier; // STORAGE[0xd] // DESOLEX_STORAGE_CONFLICT_RESOLVED: mapping value 0: bool [ResolvedAbi] vs uint256 [VerifiedAbi] (selected uint256) mapping(uint256 => uint256) public requestToken; // STORAGE[0xe] mapping(bytes32 => uint256) public unresolved_1fb3ac7c; // STORAGE[0xf] address public gameController; // STORAGE[0x10] uint256 public unresolved_9c9dea71; // STORAGE[0x11] uint256 public newMinted; // STORAGE[0x12] bool public activated; // STORAGE[0x13] bytes 0 to 0 mapping(bytes32 => uint256) public unresolved_fd597f11; // STORAGE[0x14] bool stor_15; // STORAGE[0x15] mapping(bytes32 => uint256) public referrerOf; // STORAGE[0x16] mapping(bytes32 => bool) public unresolved_f8e040bd; // STORAGE[0x17] mapping(bytes32 => bool) public unresolved_2cb62beb; // STORAGE[0x18] mapping(uint256 => bool) public unresolved_89644c77; // STORAGE[0x19] uint256 public maxRandomnessFee; // STORAGE[0x1a] mapping(uint256 => uint256) public originAgent; // STORAGE[0x1b] mapping(uint256 => bool) public life; // STORAGE[0x1c] mapping(bytes32 => uint256) public unresolved_09d50bd1; // STORAGE[0x1d] bytes32 stor_expr_ay; bytes32 stor_expr_az; event Event_0258145b(uint256 indexed, uint256); event MigrationActivated(uint256); event Event_1580c4eb(uint256 indexed, uint256 indexed, uint256); error AgentRequired(); error EnforcedPause(); error ReferralUnavailable(); error MintLimit(); error ERC721InvalidApprover(address); event Event_a51c6e3c(uint256 indexed); event Event_ce627dbc(uint256 indexed, uint256 indexed, uint256); event Approval(address indexed, address indexed, uint256 indexed); event Event_fa4b5121(uint256); event Event_0624a0eb(uint256 indexed); error ERC721InvalidOperator(address); error InvalidConfiguration(); error CustomError_a0550940(); event MetadataUpdate(uint256); error ERC721InvalidOwner(address); error CustomError_811ff142(); error ERC721InvalidReceiver(address); event Paused(address); event Transfer(address indexed, address indexed, uint256 indexed); error ERC721IncorrectOwner(address, uint256, address); error RandomnessPending(); event Event_1d18c174(uint256 indexed, uint256, uint256); error CustomError_ad9303b3(); error CustomError_b04a5f91(); error GameUnavailable(); error OnlyVRFWrapperCanFulfill(address, address); error ControllerOnly(); event Event_d6d5d80b(uint256); error ERC721InsufficientApproval(address, uint256); error SoldOut(); error NotTokenOwner(); error RandomnessUnavailable(); error ERC721OutOfBoundsIndex(address, uint256); event Event_d01b55c4(uint256 indexed, uint256 indexed, uint256 indexed); event ApprovalForAll(address indexed, address indexed, bool); event Event_77e40c72(address indexed, uint256 indexed); event Event_e9859c82(uint256); error ReentrancyGuardReentrantCall(); error WrongState(); error ERC721InvalidSender(address); error ERC721NonexistentToken(uint256); error PaymentMismatch(); error ExpectedPause(); error ExpiredQuote(); event OwnershipTransferStarted(address indexed, address indexed); error OwnableUnauthorizedAccount(address); event Unpaused(address); event OwnershipTransferred(address indexed, address indexed); 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()); _; } receive() external payable { emit Event_0258145b(msg.sender, msg.value); } fallback() external payable { // Synthetic compatibility routes preserve original selectors for unresolved names. if ((msg.data.length >= 4) && (msg.sig == 0x1075abb2)) { // Route to Unknown_1075abb2() after replacing only msg.sig. __desolexSelectorShim(uint32(0x65236c2e)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x2c885fab)) { // Route to Unknown_2c885fab(uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0xc9db0e20)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x302ec51d)) { // Route to Unknown_302ec51d(uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0x2ff91c07)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x313b2a1a)) { // Route to Unknown_313b2a1a(uint256,uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0xd4a8ff53)); return; } if ((msg.data.length >= 4) && (msg.sig == 0x5eb68e9c)) { // Route to Unknown_5eb68e9c(bool) after replacing only msg.sig. __desolexSelectorShim(uint32(0xfb694da1)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xaceb65d2)) { // Route to Unknown_aceb65d2(uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0x5a247898)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xe987e14b)) { // Route to Unknown_e987e14b(uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0x90c2535c)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xeb302a44)) { // Route to Unknown_eb302a44(uint256,uint256,bool) after replacing only msg.sig. __desolexSelectorShim(uint32(0x5dd323c7)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xf230b4ac)) { // Route to Unknown_f230b4ac(uint256) after replacing only msg.sig. __desolexSelectorShim(uint32(0xb01c1165)); return; } if ((msg.data.length >= 4) && (msg.sig == 0xf44168b3)) { // Route to Unknown_f44168b3(bool) after replacing only msg.sig. __desolexSelectorShim(uint32(0xd2612e9a)); return; } revert(); } function supportsInterface(bytes4 interfaceId) public pure returns (bool) { require(interfaceId == (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000)); if (0x780e9d6300000000000000000000000000000000000000000000000000000000 == (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000)) { return !(!(0x780e9d6300000000000000000000000000000000000000000000000000000000 == (interfaceId & (0xffffffff00000000000000000000000000000000000000000000000000000000)))); } else { bool flag0 = 0x80ac58cd00000000000000000000000000000000000000000000000000000000 == (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000); if (0x80ac58cd00000000000000000000000000000000000000000000000000000000 != (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000)) { flag0 = 0x5b5e139f00000000000000000000000000000000000000000000000000000000 == (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000); } if (flag0) { return flag0; } else { return !(!(interfaceId & (0xffffffff00000000000000000000000000000000000000000000000000000000) == 0x01ffc9a700000000000000000000000000000000000000000000000000000000)); } } } function name() public view returns (string memory) { return _name; } function approve(address spender, uint256 amount) public { bool flag0 = !(!(spender)); if (spender != address(0)) { flag0 = unresolved_89644c77[amount]; } require(!flag0, CustomError_ad9303b3()); if ((0x01 != 0x0) || (msg.sender != address(0))) { require(ownerOf[amount] != 0x0, ERC721NonexistentToken()); bool flag2 = !(!(msg.sender)); if (msg.sender != 0x0) { flag2 = !(ownerOf[amount] == (msg.sender)); } if (flag2) { } require(!(flag2 && isApprovedForAll[ownerOf[amount]][msg.sender] == 0x0), ERC721InvalidApprover()); emit Approval(ownerOf[amount], spender, amount); } getApproved[amount] = spender | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & getApproved[amount]); } function quote(address arg0) public { internal_179a(arg0); (bool success0, bytes memory returnData0) = address(0x163a94c3523c404f3f58d400a3ad605f71fa09ec).mintedByAgent(keccak256(var_n)); // staticcall require(success0); var_c = var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_c + returnData0.length) - var_c >= 0x20); require(var_t == (var_t & 0xff)); } function activate() public { internal_10bf(); } function Unknown_1075abb2() public payable { require(!((msg.data.length - 0x04) < 0xc0)); require(!paused, EnforcedPause()); require(stor_c != 0x2, ReentrancyGuardReentrantCall()); stor_c = 0x02; bool flag0 = !(activated); uint256 var_b; if (activated) { (bool success0, bytes memory returnData0) = address(0x163a94c3523c404f3f58d400a3ad605f71fa09ec).paused(); // staticcall require(success0); var_b = var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_b + returnData0.length) - var_b) < 0x20)); require(var_b.length == (var_b.length != 0x0)); flag0 = !var_b.length; } bool flag1 = flag0; if (!(flag0)) { (bool success1, bytes memory returnData1) = address(0x163a94c3523c404f3f58d400a3ad605f71fa09ec).totalMinted(); // staticcall require(success1); var_b = var_b + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_b + returnData1.length) - var_b) < 0x20)); flag1 = !(var_b.length == unresolved_9c9dea71); } require(!flag1, CustomError_a0550940()); internal_179a(msg.sender); (bool success2, bytes memory returnData2) = address(0x163a94c3523c404f3f58d400a3ad605f71fa09ec).mintedByAgent(keccak256(var_k)); // staticcall require(success2); var_b = var_b + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_b + returnData2.length) - var_b) < 0x20)); require(var_b.length == (var_b.length & 0xff)); } function getBalance() public view returns (uint256) { return address(this).balance; } function agentKeyOf(address arg0) public returns (uint256) { (bool success0, bytes memory returnData0) = address(0x60b9262456de011f7d15a54cdd8c48baaa8b022f).handleOf(arg0); // staticcall require(success0); uint256 var_c; var_c = var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData0.length + 0x1f)); require(!(((var_c + returnData0.length) - var_c) < 0x20)); require(!(var_c.length > 0xffffffffffffffff)); require((var_c + returnData0.length) > ((var_c + var_c.length) + 0x1f)); if (var_d > 0xffffffffffffffff) _desolexPanic(65); if (((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_e))) + 0x1f))) < var_c) | ((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_e))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_e))) + 0x1f)); require(!(((var_c + var_c.length) + var_e + 0x20) > (var_c + returnData0.length))); uint256 value0 = 0; while (true) { if (!(value0 < var_d)) { break; } value0 = 0x20 + value0; require(0x0 != var_c.length, AgentRequired()); (bool success1, bytes memory returnData1) = address(0x60b9262456de011f7d15a54cdd8c48baaa8b022f).ownerOf(keccak256(var_j)); // staticcall require(success1); var_c = var_c + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData1.length) - var_c) < 0x20)); require(value1 == (value1 & 0xffffffffffffffffffffffffffffffffffffffff)); require((0xffffffffffffffffffffffffffffffffffffffff & value1) == arg0, AgentRequired()); return keccak256(var_j); } } function rawFulfillRandomWords(uint256 arg0, uint256[] memory arg1) public { if (arg1.length > 0xffffffffffffffff) _desolexPanic(65); uint256 var_a; if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (((arg1.length << 0x05) + 0x20) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (((arg1.length << 0x05) + 0x20) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (((arg1.length << 0x05) + 0x20) + 0x1f)); uint256[] var_b = arg1; require(!((0x20 + ((0x04 + arg1) + (arg1.length << 0x05))) > msg.data.length)); uint256 value1 = var_a + 0x20; uint256 value2 = arg1.length << 0x05; uint256 value0 = (0x04 + arg1) + 0x20; while (true) { if (!(value0 < (0x20 + ((0x04 + arg1) + (arg1.length << 0x05))))) { break; } value1 = value1 + 0x20; value2 = msg.data[value0]; value0 = 0x20 + value0; } require(address(0x471506e6aded0b9811d05b8cac8db25ee839ac94) == msg.sender, OnlyVRFWrapperCanFulfill()); bool flag0 = !(requestToken[arg0]); if (requestToken[arg0] != 0) { if (bytes1(tier[requestToken[arg0]]) > 0x03) _desolexPanic(33); flag0 = !(bytes1(tier[requestToken[arg0]]) == 0); } if (!(flag0 || var_f == 0x0)) { if (!(0 < var_f)) _desolexPanic(50); uint256 value4; if ((var_g % 0x64) < 0x3c) { if (!(0x1 <= 0x3)) _desolexPanic(33); tier[requestToken[arg0]] = 0x01 | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & tier[requestToken[arg0]]); if (bytes1(tier[requestToken[arg0]]) > 0x03) _desolexPanic(33); value4 = 0x64; if (!(bytes1(tier[requestToken[arg0]]) == 0x01)) { uint256 value8 = 0x96; if (!(bytes1(tier[requestToken[arg0]]) == 0x02)) { uint256 value3 = 0xc8; if (!(bytes1(tier[requestToken[arg0]]) == 0x03)) { value3 = 0; } value8 = bytes1(value3); } value4 = value8; } } else { uint256 value5 = 0x02; if (!((var_g % 0x64) < 0x5a)) { value5 = 0x03; } if (!(value5 <= 0x3)) _desolexPanic(33); tier[requestToken[arg0]] = (value5 * 0x01) | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & tier[requestToken[arg0]]); if (bytes1(tier[requestToken[arg0]]) > 0x03) _desolexPanic(33); uint256 value7 = 0x64; if (!(bytes1(tier[requestToken[arg0]]) == 0x01)) { uint256 value9 = 0x96; if (!(bytes1(tier[requestToken[arg0]]) == 0x02)) { uint256 value6 = 0xc8; if (!(bytes1(tier[requestToken[arg0]]) == 0x03)) { value6 = 0; } value9 = bytes1(value6); } value7 = value9; } } if (!(bytes1(tier[requestToken[arg0]]) < 0x4)) _desolexPanic(33); emit Event_1d18c174(requestToken[arg0], bytes1(tier[requestToken[arg0]]), value4); emit MetadataUpdate(requestToken[arg0]); } } function transferFrom(address from, address to, uint256 amount) public { internal_1984(amount, to, from); } function setReferralsEnabled(bool arg0) public onlyOwner { stor_15 = arg0 | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00 & stor_15); emit Event_fa4b5121(arg0); } function Unknown_2c885fab(uint256 arg0) public { require(ownerOf[arg0] != 0x0, ERC721NonexistentToken()); require((0xffffffffffffffffffffffffffffffffffffffff & ownerOf[arg0]) == msg.sender, NotTokenOwner()); if (bytes1(tier[arg0]) > 0x03) _desolexPanic(33); require(bytes1(tier[arg0]) != 0, RandomnessPending()); require(gameController != 0x0, GameUnavailable()); if (life[arg0] > 0x03) _desolexPanic(33); require(!life[arg0], WrongState()); life[arg0] = true; unresolved_09d50bd1[arg0] = 0x01 + unresolved_09d50bd1[arg0]; emit Event_d01b55c4(arg0, unresolved_09d50bd1[arg0], msg.sender); } function Unknown_302ec51d(uint256 arg0) public onlyOwner { maxRandomnessFee = (arg0) ? 1 : 0; emit Event_d6d5d80b(maxRandomnessFee); } function Unknown_313b2a1a(uint256 arg0, uint256 arg1) public payable { require(!paused, EnforcedPause()); require(stor_c != 0x2, ReentrancyGuardReentrantCall()); stor_c = 0x02; bool flag0 = !(activated); uint256 var_b; if (activated) { (bool success0, bytes memory returnData0) = address(0x163a94c3523c404f3f58d400a3ad605f71fa09ec).paused(); // staticcall require(success0); var_b = var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_b + returnData0.length) - var_b) < 0x20)); require(var_b.length == (var_b.length != 0x0)); flag0 = !var_b.length; } bool flag1 = flag0; if (!(flag0)) { (bool success1, bytes memory returnData1) = address(0x163a94c3523c404f3f58d400a3ad605f71fa09ec).totalMinted(); // staticcall require(success1); var_b = var_b + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_b + returnData1.length) - var_b) < 0x20)); flag1 = !(var_b.length == unresolved_9c9dea71); } require(!flag1, CustomError_a0550940()); (bool success2, bytes memory returnData2) = address(0x60b9262456de011f7d15a54cdd8c48baaa8b022f).handleOf(msg.sender); // staticcall require(success2); var_b = var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData2.length + 0x1f)); require(!(((var_b + returnData2.length) - var_b) < 0x20)); require(!(var_b.length > 0xffffffffffffffff)); require((var_b + returnData2.length) > ((var_b + var_b.length) + 0x1f)); if (!(var_d <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_d))) + 0x1f))) < var_b) | ((var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_d))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_b = var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_d))) + 0x1f)); require(!(((var_b + var_b.length) + var_f + 0x20) > (var_b + returnData2.length))); uint256 value0 = 0; while (true) { if (value0 >= var_f) { break; } value0 = 0x20 + value0; require(0x0 != var_i, AgentRequired()); (bool success3, bytes memory returnData3) = address(0x60b9262456de011f7d15a54cdd8c48baaa8b022f).ownerOf(keccak256(var_k)); // staticcall require(success3); var_b = var_b + ((returnData3.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_b + returnData3.length) - var_b) < 0x20)); require(var_b.length == (var_b.length & 0xffffffffffffffffffffffffffffffffffffffff)); require((0xffffffffffffffffffffffffffffffffffffffff & value1) == msg.sender, AgentRequired()); bool flag2 = !(bytes1(stor_15)); if (bytes1(stor_15)) { flag2 = !(unresolved_f8e040bd[keccak256(var_k)]); } bool flag3 = flag2; if (!(flag2)) { flag3 = unresolved_2cb62beb[keccak256(var_k)]; } require(!flag3, ReferralUnavailable()); require(msg.value == arg0, PaymentMismatch()); unresolved_2cb62beb[keccak256(var_k)] = true; if (block.timestamp <= arg1) { } require(!(block.timestamp > arg1 || arg1 > block.timestamp + 0x12c), ExpiredQuote()); (bool success4, bytes memory returnData4) = address(0x471506e6aded0b9811d05b8cac8db25ee839ac94).calculateRequestPriceNative(0x0186a0, 0x01); // staticcall require(success4); var_b = var_b + ((returnData4.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_b + returnData4.length) - var_b) < 0x20)); bool flag5 = arg0 == 0x0; if (arg0 != 0x0) { flag5 = arg0 < value2; } bool flag17; if (!(flag5)) { flag17 = value2 == 0x0; if (var_b.length == 0) { flag17 = tx.gasprice; } } require(!(flag5 || flag17), RandomnessUnavailable()); (bool success5, bytes memory returnData5) = address(0x163a94c3523c404f3f58d400a3ad605f71fa09ec).totalMinted(); // staticcall require(success5); var_b = var_b + ((returnData5.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_b + returnData5.length) - var_b >= 0x20); require((newMinted + var_t) < 0x270f, SoldOut()); newMinted = 0x01 + newMinted; originAgent[(0x01 + newMinted) + unresolved_9c9dea71] = keccak256(var_q); unresolved_89644c77[(0x01 + newMinted) + unresolved_9c9dea71] = true; emit Event_a51c6e3c((0x01 + newMinted) + unresolved_9c9dea71); var_b = 0x20 + var_b; var_b = 0x20 + (0x24 + var_b); (bool success6, bytes memory returnData6) = address(0x471506e6aded0b9811d05b8cac8db25ee839ac94).calculateRequestPriceNative(uint32(0x0186a0), uint32(0x01)); // staticcall require(success6); var_b = var_b + ((returnData6.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_b + returnData6.length) - var_b >= 0x20); uint256 value0 = 0; while (true) { if (value0 >= var_ai) { break; } value0 = 0x20 + value0; (bool success7, bytes memory returnData7) = address(0x471506e6aded0b9811d05b8cac8db25ee839ac94).requestRandomWordsInNative{ value: var_t }(uint32(0x0186a0), uint16(0x0a), uint32(0x01), 0x80); // call require(success7); var_b = var_b + ((returnData7.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_b + returnData7.length) - var_b >= 0x20); require(var_t == var_b.length, RandomnessUnavailable()); requestToken[var_t] = (0x01 + newMinted) + unresolved_9c9dea71; unresolved_1fb3ac7c[(0x01 + newMinted) + unresolved_9c9dea71] = var_t; var_b = 0x20 + var_b; require(msg.sender != address(0), ERC721InvalidReceiver()); bool flag7 = !(!(ownerOf[(0x01 + newMinted) + unresolved_9c9dea71])); if (ownerOf[(0x01 + newMinted) + unresolved_9c9dea71]) { flag7 = unresolved_89644c77[(0x01 + newMinted) + unresolved_9c9dea71]; } require(!flag7, CustomError_ad9303b3()); bool flag8 = !(!(ownerOf[(0x01 + newMinted) + unresolved_9c9dea71])); if (ownerOf[(0x01 + newMinted) + unresolved_9c9dea71]) { if (life[(0x01 + newMinted) + unresolved_9c9dea71] > 0x03) _desolexPanic(33); bool flag18 = !(life[(0x01 + newMinted) + unresolved_9c9dea71] == 0); if (!life[(0x01 + newMinted) + unresolved_9c9dea71]) { if (bytes1(tier[(0x01 + newMinted) + unresolved_9c9dea71]) > 0x03) _desolexPanic(33); flag18 = (bytes1(tier[(0x01 + newMinted) + unresolved_9c9dea71])) == 0; } flag8 = flag18; } require(!flag8, CustomError_b04a5f91()); if ((__desolex_internal_4111_3d73_arg0 & 0xffffffffffffffffffffffffffffffffffffffff) == 0x0) { if (ownerOf[__desolex_internal_4111_3d73_arg1]) { bool flag9 = (__desolex_internal_3af2_415b_arg3 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0; if (address(__desolex_internal_3af2_415b_arg3)) { flag9 = unresolved_89644c77[__desolex_internal_3af2_415b_arg2]; } require(!flag9, CustomError_ad9303b3()); if ((__desolex_internal_3f82_1a09_arg0 != 0x0) || ((__desolex_internal_3f82_1a09_arg1 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0)) { require(ownerOf[__desolex_internal_3f82_1a09_arg2] != 0x0, ERC721NonexistentToken()); bool flag11 = (__desolex_internal_3f82_1a09_arg1 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0; if (address(__desolex_internal_3f82_1a09_arg1)) { flag11 = !(ownerOf[__desolex_internal_3f82_1a09_arg2] == (address(__desolex_internal_3f82_1a09_arg1))); } bool flag12 = flag11; if (flag11) { flag12 = !(bytes1(isApprovedForAll[address(ownerOf[__desolex_internal_3f82_1a09_arg2])][address(__desolex_internal_3f82_1a09_arg1)])); } require(!flag12, ERC721InvalidApprover()); if (__desolex_internal_3f82_1a09_arg0 != 0x0) { emit Approval(ownerOf[__desolex_internal_3f82_1a09_arg2], address(__desolex_internal_3f82_1a09_arg3), __desolex_internal_3f82_1a09_arg2); } } getApproved[__desolex_internal_3f82_1a09_arg2] = (address(__desolex_internal_3f82_1a09_arg3)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & getApproved[__desolex_internal_3f82_1a09_arg2]); balanceOf[ownerOf[__desolex_internal_4111_3d73_arg1]] = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + balanceOf[ownerOf[__desolex_internal_4111_3d73_arg1]]; } if (__desolex_internal_4111_3d73_arg2 != 0x0) { balanceOf[__desolex_internal_4111_3d73_arg2] = 0x01 + balanceOf[__desolex_internal_4111_3d73_arg2]; } ownerOf[__desolex_internal_4111_3d73_arg1] = __desolex_internal_4111_3d73_arg2 | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & ownerOf[__desolex_internal_4111_3d73_arg1]); emit Transfer(ownerOf[__desolex_internal_4111_3d73_arg1], __desolex_internal_4111_3d73_arg2, __desolex_internal_4111_3d73_arg1); } else { uint256 value7 = !(!(address(__desolex_internal_456f_413e_arg1))); if (address(__desolex_internal_45d3_457a_arg1)) { uint256 value6 = ((address(__desolex_internal_45d3_457a_arg2)) == (address(__desolex_internal_45d3_457a_arg1))) ? 1 : 0; if (address(__desolex_internal_45d3_457a_arg2) != address(__desolex_internal_45d3_457a_arg1)) { value6 = bytes1(isApprovedForAll[address(__desolex_internal_45d3_457a_arg2)][address(__desolex_internal_45d3_457a_arg1)]); } uint256 value11 = value6; if (value6 == 0) { value11 = ((address(__desolex_internal_456f_413e_arg1)) == getApproved[__desolex_internal_456f_413e_arg0]) ? 1 : 0; } value7 = value11; } if (value7 == 0) { require((__desolex_internal_456f_413e_arg2 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0, ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } if (ownerOf[__desolex_internal_4111_3d73_arg1]) { bool flag13 = (__desolex_internal_3af2_415b_arg3 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0; if (address(__desolex_internal_3af2_415b_arg3)) { flag13 = unresolved_89644c77[__desolex_internal_3af2_415b_arg2]; } require(!flag13, CustomError_ad9303b3()); if ((__desolex_internal_3f82_1a09_arg0 != 0x0) || ((__desolex_internal_3f82_1a09_arg1 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0)) { require(ownerOf[__desolex_internal_3f82_1a09_arg2] != 0x0, ERC721NonexistentToken()); bool flag15 = (__desolex_internal_3f82_1a09_arg1 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0; if (address(__desolex_internal_3f82_1a09_arg1)) { flag15 = !(ownerOf[__desolex_internal_3f82_1a09_arg2] == (address(__desolex_internal_3f82_1a09_arg1))); } bool flag16 = flag15; if (flag15) { flag16 = !(bytes1(isApprovedForAll[address(ownerOf[__desolex_internal_3f82_1a09_arg2])][address(__desolex_internal_3f82_1a09_arg1)])); } require(!flag16, ERC721InvalidApprover()); if (__desolex_internal_3f82_1a09_arg0 != 0x0) { emit Approval(ownerOf[__desolex_internal_3f82_1a09_arg2], address(__desolex_internal_3f82_1a09_arg3), __desolex_internal_3f82_1a09_arg2); } } getApproved[__desolex_internal_3f82_1a09_arg2] = (address(__desolex_internal_3f82_1a09_arg3)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & getApproved[__desolex_internal_3f82_1a09_arg2]); balanceOf[ownerOf[__desolex_internal_4111_3d73_arg1]] = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + balanceOf[ownerOf[__desolex_internal_4111_3d73_arg1]]; } if (__desolex_internal_4111_3d73_arg2 != 0x0) { balanceOf[__desolex_internal_4111_3d73_arg2] = 0x01 + balanceOf[__desolex_internal_4111_3d73_arg2]; } ownerOf[__desolex_internal_4111_3d73_arg1] = __desolex_internal_4111_3d73_arg2 | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & ownerOf[__desolex_internal_4111_3d73_arg1]); emit Transfer(ownerOf[__desolex_internal_4111_3d73_arg1], __desolex_internal_4111_3d73_arg2, __desolex_internal_4111_3d73_arg1); } if (ownerOf[__desolex_internal_3d65_36d3_arg1] != address(0)) { if (ownerOf[__desolex_internal_3d65_36d3_arg1] != __desolex_internal_3d65_36d3_arg2) { require(__desolex_internal_2015_4215_arg0 != address(0), ERC721InvalidOwner()); if (balanceOf[__desolex_internal_420a_3df3_arg1] != mapping_7[__desolex_internal_420a_3df3_arg0]) { tokenOfOwnerByIndex[__desolex_internal_420a_3df3_arg1][mapping_7[__desolex_internal_420a_3df3_arg0]] = tokenOfOwnerByIndex[__desolex_internal_420a_3df3_arg1][balanceOf[__desolex_internal_420a_3df3_arg1]]; mapping_7[tokenOfOwnerByIndex[__desolex_internal_420a_3df3_arg1][balanceOf[__desolex_internal_420a_3df3_arg1]]] = mapping_7[__desolex_internal_420a_3df3_arg0]; } mapping_7[__desolex_internal_420a_3df3_arg0] = 0; tokenOfOwnerByIndex[__desolex_internal_420a_3df3_arg1][balanceOf[__desolex_internal_420a_3df3_arg1]] = 0; } } else { mapping_9[__desolex_internal_3d65_36d3_arg1] = totalSupply; totalSupply = totalSupply + 0x01; tokenByIndex[totalSupply] = __desolex_internal_3d65_36d3_arg1; } if (__desolex_internal_3d65_36d3_arg2 != address(0)) { if (ownerOf[__desolex_internal_3d65_36d3_arg1] != __desolex_internal_3d65_36d3_arg2) { require(__desolex_internal_2015_4347_arg0 != address(0), ERC721InvalidOwner()); tokenOfOwnerByIndex[__desolex_internal_433a_36d3_arg1][balanceOf[__desolex_internal_433a_36d3_arg1] - 0x01] = __desolex_internal_433a_36d3_arg0; mapping_7[__desolex_internal_433a_36d3_arg0] = balanceOf[__desolex_internal_433a_36d3_arg1] - 0x01; } } else { if (!((totalSupply - 0x01) < totalSupply)) _desolexPanic(50); if (!(mapping_9[__desolex_internal_428b_3e0a_arg0] < totalSupply)) _desolexPanic(50); stor_expr_ay = stor_expr_az; mapping_9[stor_expr_az] = mapping_9[__desolex_internal_428b_3e0a_arg0]; mapping_9[__desolex_internal_428b_3e0a_arg0] = 0; if (!(totalSupply != 0x0)) _desolexPanic(49); stor_expr_az = 0; totalSupply = totalSupply - 0x01; } require(!(ownerOf[(0x01 + newMinted) + unresolved_9c9dea71]), ERC721InvalidSender()); if (!(msg.sender.code.length == 0x0)) { uint256 value0 = 0; while (true) { if (value0 >= var_ai) { break; } value0 = 0x20 + value0; (bool success8, bytes memory returnData8) = address(msg.sender).onERC721Received(msg.sender, address(0), ((0x01 + newMinted) + unresolved_9c9dea71), 0x80); // call if (!success8) { if (!(success8)) { uint256 value8 = 0x60; if (returnData8.length != 0x0) { var_b = var_b + ((returnData8.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value8 = var_b; } require(0x0 != var_ar, ERC721InvalidReceiver()); revert(); } require(0x150b7a0200000000000000000000000000000000000000000000000000000000 == (var_b & 0xffffffff00000000000000000000000000000000000000000000000000000000), ERC721InvalidReceiver()); } else { var_b = var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData8.length + 0x1f)); require((var_b + returnData8.length) - var_b >= 0x20); require(__desolex_internal_4636_190e_arg0 == (__desolex_internal_4636_190e_arg0 & 0xffffffff00000000000000000000000000000000000000000000000000000000)); if (0x01 == 0) { uint256 value10 = 0x60; if (returnData8.length != 0x0) { var_b = var_b + ((returnData8.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value10 = var_b; } require(0x0 != var_au, ERC721InvalidReceiver()); revert(); } require(0x150b7a0200000000000000000000000000000000000000000000000000000000 == (value9 & 0xffffffff00000000000000000000000000000000000000000000000000000000), ERC721InvalidReceiver()); } } } emit Event_1580c4eb((0x01 + newMinted) + unresolved_9c9dea71, var_t, var_t); } } } function miningPower(uint256 arg0) public view returns (uint256) { bool flag0 = !(!(ownerOf[arg0])); if (ownerOf[arg0]) { if (life[arg0] > 0x03) _desolexPanic(33); flag0 = life[arg0] == 0x02; } if (!(flag0)) { return 0; } if (bytes1(tier[arg0]) > 0x03) _desolexPanic(33); uint256 value1 = 0x64; if (bytes1(tier[arg0]) != 0x01) { if (bytes1(tier[arg0]) != 0x02) { uint256 value0 = 0xc8; if (bytes1(tier[arg0]) != 0x03) { value0 = 0; } return bytes1(value0); } value1 = 0x96; } return bytes1(value1); } function quoteBNB(uint8 arg0) public returns (uint256) { require(arg0 == (arg0 & 0xff)); require(!((arg0 & 0xff) == 0x0 || (arg0 & 0xff) > 0x5), MintLimit()); if (0x1 == (0xff & arg0)) { if (0 != 0) { (bool success0, bytes memory returnData0) = address(0x3c5673ff9b15bf1ecd47af17050cebdcd5bd18e6).quote(0); // staticcall require(success0); uint256 var_c; var_c = var_c + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData0.length) - var_c) < 0x20)); return var_c.length; } } else { if (0x2 == (0xff & arg0)) { if (0x297e9d28866b0000 != 0) { (bool success1, bytes memory returnData1) = address(0x3c5673ff9b15bf1ecd47af17050cebdcd5bd18e6).quote(address(uint160(0x297e9d28866b0000))); // staticcall require(success1); var_c = var_c + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData1.length) - var_c) < 0x20)); return var_c.length; } } else { if (0x3d9e0c79d2bc0000 != 0) { (bool success2, bytes memory returnData2) = address(0x3c5673ff9b15bf1ecd47af17050cebdcd5bd18e6).quote(address(uint160(0x3d9e0c79d2bc0000))); // staticcall require(success2); var_c = var_c + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData2.length) - var_c) < 0x20)); return var_c.length; } } } return 0; } function safeTransferFrom(address _from, address to, uint256 tokenId) public { internal_1eaa(tokenId, to, _from); } function Unknown_5eb68e9c(bool arg0) public pure returns (uint256) { require(arg0 == (arg0 & 0xff)); require(!((arg0 & 0xff) == 0x0 || (arg0 & 0xff) > 0x5), MintLimit()); if (0x01 != bytes1(arg0)) { if (0x02 != bytes1(arg0)) { return 0x3d9e0c79d2bc0000; } return 0x297e9d28866b0000; } return 0; } function basePower(uint256 arg0) public view returns (bool) { if (bytes1(tier[arg0]) > 0x03) _desolexPanic(33); uint256 value1 = 0x64; if (bytes1(tier[arg0]) != 0x01) { if (bytes1(tier[arg0]) != 0x02) { uint256 value0 = 0xc8; if (bytes1(tier[arg0]) != 0x03) { value0 = 0; } return bytes1(value0); } value1 = 0x96; } return bytes1(value1); } function renounceOwnership() public onlyOwner { pendingOwner = address(0); emit OwnershipTransferred(owner, address(0)); owner = address(0); } function acceptOwnership() public { require(msg.sender == pendingOwner, OwnableUnauthorizedAccount()); pendingOwner = address(0); emit OwnershipTransferred(owner, msg.sender); owner = msg.sender; } function symbol() public view returns (string memory) { return _symbol; } function setApprovalForAll(address operator, bool approved) public { require(operator != address(0), ERC721InvalidOperator()); isApprovedForAll[msg.sender][operator] = approved; emit ApprovalForAll(msg.sender, operator, isApprovedForAll[msg.sender][operator]); } function totalMinted() public returns (uint256) { (bool success0, bytes memory returnData0) = address(0x163a94c3523c404f3f58d400a3ad605f71fa09ec).totalMinted(); // staticcall require(success0); uint256 var_b; var_b = var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_b + returnData0.length) - var_b) < 0x20)); return newMinted + var_b.length; } function setGameController(address newAddress) public onlyOwner { emit Event_77e40c72(gameController, newAddress); gameController = newAddress; } function Unknown_aceb65d2(uint256 arg0) public { require(ownerOf[arg0] != 0x0, ERC721NonexistentToken()); require((0xffffffffffffffffffffffffffffffffffffffff & ownerOf[arg0]) == msg.sender, NotTokenOwner()); if (life[arg0] > 0x03) _desolexPanic(33); require(life[arg0] == 0x02, WrongState()); life[arg0] = false; emit Event_0624a0eb(arg0); } function setMintPaused(bool arg0) public { internal_227b(arg0); } function safeTransferFrom(address _from, address to, uint256 tokenId, bytes memory _data) public { if (_data.length > 0xffffffffffffffff) _desolexPanic(65); uint256 var_a; if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + _data.length))) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + _data.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + _data.length))) + 0x1f)); require(!(((0x04 + _data) + _data + 0x20) > msg.data.length)); require(to != address(0), ERC721InvalidReceiver()); bool flag0 = !(!(ownerOf[tokenId])); if (ownerOf[tokenId]) { flag0 = unresolved_89644c77[tokenId]; } require(!flag0, CustomError_ad9303b3()); bool flag1 = !(!(ownerOf[tokenId])); if (ownerOf[tokenId]) { if (life[tokenId] > 0x03) _desolexPanic(33); bool flag6 = !(life[tokenId] == 0); if (!life[tokenId]) { if (bytes1(tier[tokenId]) > 0x03) _desolexPanic(33); flag6 = (bytes1(tier[tokenId])) == 0; } flag1 = flag6; } require(!flag1, CustomError_b04a5f91()); if (msg.sender != 0x0) { uint256 value1 = !(!(__desolex_internal_456f_413e_arg1)); if (__desolex_internal_45d3_457a_arg1 != 0x0) { uint256 value0 = ((address(__desolex_internal_45d3_457a_arg2)) == __desolex_internal_45d3_457a_arg1) ? 1 : 0; if (address(__desolex_internal_45d3_457a_arg2) != __desolex_internal_45d3_457a_arg1) { value0 = bytes1(isApprovedForAll[address(__desolex_internal_45d3_457a_arg2)][__desolex_internal_45d3_457a_arg1]); } uint256 value6 = value0; if (value0 == 0) { value6 = (__desolex_internal_456f_413e_arg1 == getApproved[__desolex_internal_456f_413e_arg0]) ? 1 : 0; } value1 = value6; } if (value1 == 0) { require((__desolex_internal_456f_413e_arg2 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0, ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } } if (ownerOf[tokenId]) { bool flag2 = (__desolex_internal_3af2_415b_arg3 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0; if (address(__desolex_internal_3af2_415b_arg3)) { flag2 = unresolved_89644c77[__desolex_internal_3af2_415b_arg2]; } require(!flag2, CustomError_ad9303b3()); if ((__desolex_internal_3f82_1a09_arg0 != 0x0) || ((__desolex_internal_3f82_1a09_arg1 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0)) { require(ownerOf[__desolex_internal_2b00_3fa6_arg0] != 0x0, ERC721NonexistentToken()); bool flag4 = (__desolex_internal_3f82_1a09_arg1 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0; if (address(__desolex_internal_3f82_1a09_arg1)) { flag4 = !(ownerOf[__desolex_internal_3f82_1a09_arg2] == (address(__desolex_internal_3f82_1a09_arg1))); } if (flag4) { } require(!(flag4 && isApprovedForAll[0xffffffffffffffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffffffffffffffff & ownerOf[__desolex_internal_3f82_1a09_arg2])][0xffffffffffffffffffffffffffffffffffffffff & __desolex_internal_3f82_1a09_arg1] == 0x0), ERC721InvalidApprover()); if (__desolex_internal_3f82_1a09_arg0 != 0x0) { emit Approval(ownerOf[__desolex_internal_3f82_1a09_arg2], address(__desolex_internal_3f82_1a09_arg3), __desolex_internal_3f82_1a09_arg2); } } getApproved[__desolex_internal_3f82_1a09_arg2] = (address(__desolex_internal_3f82_1a09_arg3)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & getApproved[__desolex_internal_3f82_1a09_arg2]); balanceOf[ownerOf[tokenId]] = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + balanceOf[ownerOf[tokenId]]; } if (to != address(0)) { balanceOf[to] = 0x01 + balanceOf[to]; } ownerOf[tokenId] = to | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & ownerOf[tokenId]); emit Transfer(ownerOf[tokenId], to, tokenId); if (ownerOf[tokenId] != address(0)) { if (!(ownerOf[tokenId] == to)) { require(__desolex_internal_2015_4215_arg0 != address(0), ERC721InvalidOwner()); if (!(balanceOf[ownerOf[tokenId]] == mapping_7[tokenId])) { tokenOfOwnerByIndex[ownerOf[tokenId]][mapping_7[tokenId]] = tokenOfOwnerByIndex[ownerOf[tokenId]][balanceOf[ownerOf[tokenId]]]; mapping_7[tokenOfOwnerByIndex[ownerOf[tokenId]][balanceOf[ownerOf[tokenId]]]] = mapping_7[tokenId]; } mapping_7[tokenId] = 0; tokenOfOwnerByIndex[ownerOf[tokenId]][balanceOf[ownerOf[tokenId]]] = 0; } } else { mapping_9[tokenId] = totalSupply; totalSupply = totalSupply + 0x01; tokenByIndex[totalSupply] = tokenId; } if (to != address(0)) { if (!(ownerOf[tokenId] == to)) { require(__desolex_internal_2015_4347_arg0 != address(0), ERC721InvalidOwner()); tokenOfOwnerByIndex[to][balanceOf[to] - 0x01] = tokenId; mapping_7[tokenId] = balanceOf[to] - 0x01; } } else { if (!((totalSupply - 0x01) < totalSupply)) _desolexPanic(50); if (!(mapping_9[tokenId] < totalSupply)) _desolexPanic(50); stor_expr_ay = stor_expr_az; mapping_9[stor_expr_az] = mapping_9[tokenId]; mapping_9[tokenId] = 0; if (!(totalSupply != 0x0)) _desolexPanic(49); stor_expr_az = 0; totalSupply = totalSupply - 0x01; } require(ownerOf[tokenId] == _from, ERC721IncorrectOwner()); if (!(to.code.length == 0x0)) { uint256 value2 = 0; while (true) { if (value2 >= var_l) { break; } value2 = 0x20 + value2; (bool success0, bytes memory returnData0) = to.onERC721Received(msg.sender, _from, tokenId, 0x80); // call if (!success0) { if (!(success0)) { uint256 value3 = 0x60; if (returnData0.length != 0x0) { var_a = var_a + ((returnData0.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value3 = var_a; } require(0x0 != var_o, ERC721InvalidReceiver()); revert(); } require(0x150b7a0200000000000000000000000000000000000000000000000000000000 == (var_a & 0xffffffff00000000000000000000000000000000000000000000000000000000), ERC721InvalidReceiver()); } else { var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData0.length + 0x1f)); require((var_a + returnData0.length) - var_a >= 0x20); require(var_p == (var_p & 0xffffffff00000000000000000000000000000000000000000000000000000000)); if (0x01 == 0) { uint256 value5 = 0x60; if (returnData0.length != 0x0) { var_a = var_a + ((returnData0.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value5 = var_a; } require(0x0 != var_r, ERC721InvalidReceiver()); revert(); } require(0x150b7a0200000000000000000000000000000000000000000000000000000000 == (var_s & (0xffffffff00000000000000000000000000000000000000000000000000000000)), ERC721InvalidReceiver()); } } } } function tokenURI(uint256 tokenId) public view { require(ownerOf[tokenId] != 0x0, ERC721NonexistentToken()); if (life[tokenId] > 0x03) _desolexPanic(33); if (life[tokenId] != 0x03) { if (life[tokenId] == 0x02) { if (bytes1(tier[tokenId]) > 0x03) _desolexPanic(33); if (bytes1(tier[tokenId]) != 0x01) { if (bytes1(tier[tokenId]) == 0x02) { var_c = 0x40 + var_c; if (bytes1(tier[tokenId]) != 0x03) { } } else { uint256 value18 = var_c; if (bytes1(tier[tokenId]) == 0x03) { } else { var_c = 0x40 + var_c; value18 = var_c; } if (bytes1(tier[tokenId]) > 0x03) _desolexPanic(33); uint256 value31; if (bytes1(tier[tokenId]) == 0x03) { uint256 value19 = 0; uint256 value20 = tokenId; if (tokenId >= 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000) { value19 = 0x40; value20 = tokenId / 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000; } uint256 value21 = value19; uint256 value22 = value20; if (value20 >= 0x04ee2d6d415b85acef8100000000) { value21 = 0x20 + value19; value22 = value20 / 0x04ee2d6d415b85acef8100000000; } uint256 value23 = value21; uint256 value24 = value22; if (value22 >= 0x2386f26fc10000) { value23 = 0x10 + value21; value24 = value22 / 0x2386f26fc10000; } uint256 value25 = value23; uint256 value26 = value24; if (value24 >= 0x05f5e100) { value25 = 0x08 + value23; value26 = value24 / 0x05f5e100; } uint256 value27 = value25; uint256 value28 = value26; if (value26 >= 0x2710) { value27 = 0x04 + value25; value28 = value26 / 0x2710; } uint256 value29 = value27; uint256 value30 = value28; if (value28 >= 0x64) { value29 = 0x02 + value27; value30 = value28 / 0x64; } value31 = value29; if (!(value30 < 0xa)) { value31 = 0x01 + value29; } if (!(0x1 + value31 <= 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + (0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + (0x01 + value31)))); uint256 value32 = 0x01 + value31; if (value31 != type(uint256).max) { value32 = (0x01 + value31) + (var_c + 0x20); } uint256 value16 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0x20 + (var_c + (0x01 + value31))); uint256 value15 = tokenId / 0x0a; while (true) { if (value15 == 0) { break; } value16 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value16; value15 = value15 / 0x0a; } uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_aq) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; var_c = 0x11 + (var_c.length + (0x3f + (var_c.length + (0x36 + (var_aq + (0x3f + (var_c.length + ((0x20 + var_c) + 0x0308)))))))); uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_aq) { break; } value17 = 0x20 + value17; } } } } } } } else { if (bytes1(tier[tokenId]) == 0x02) { uint256 value33 = 0; uint256 value34 = tokenId; if (tokenId >= 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000) { value33 = 0x40; value34 = tokenId / 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000; } uint256 value35 = value33; uint256 value36 = value34; if (value34 >= 0x04ee2d6d415b85acef8100000000) { value35 = 0x20 + value33; value36 = value34 / 0x04ee2d6d415b85acef8100000000; } uint256 value37 = value35; uint256 value38 = value36; if (value36 >= 0x2386f26fc10000) { value37 = 0x10 + value35; value38 = value36 / 0x2386f26fc10000; } uint256 value39 = value37; uint256 value40 = value38; if (value38 >= 0x05f5e100) { value39 = 0x08 + value37; value40 = value38 / 0x05f5e100; } uint256 value41 = value39; uint256 value42 = value40; if (value40 >= 0x2710) { value41 = 0x04 + value39; value42 = value40 / 0x2710; } uint256 value43 = value41; uint256 value44 = value42; if (value42 >= 0x64) { value43 = 0x02 + value41; value44 = value42 / 0x64; } uint256 value45 = value43; if (!(value44 < 0xa)) { value45 = 0x01 + value43; } if (!(0x1 + value45 <= 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + (0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + (0x01 + value45)))); uint256 value46 = 0x01 + value45; if (value45 != type(uint256).max) { value46 = (0x01 + value45) + (var_c + 0x20); } uint256 value16 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0x20 + (var_c + (0x01 + value31))); uint256 value15 = tokenId / 0x0a; while (true) { if (value15 == 0) { break; } value16 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value16; value15 = value15 / 0x0a; } uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_aq) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; var_c = 0x11 + (var_c.length + (0x3f + (var_c.length + (0x36 + (var_aq + (0x3f + (var_c.length + ((0x20 + var_c) + 0x0308)))))))); uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_aq) { break; } value17 = 0x20 + value17; var_c = 0x43 + (var_aq + ((0x20 + var_c) + var_c.length)); } } } } } } } else { uint256 value47 = var_c; if (bytes1(tier[tokenId]) == 0x01) { } else { var_c = 0x40 + var_c; value47 = var_c; } uint256 value48 = 0; uint256 value49 = tokenId; if (tokenId >= 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000) { value48 = 0x40; value49 = tokenId / 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000; } uint256 value50 = value48; uint256 value51 = value49; if (value49 >= 0x04ee2d6d415b85acef8100000000) { value50 = 0x20 + value48; value51 = value49 / 0x04ee2d6d415b85acef8100000000; } uint256 value52 = value50; uint256 value53 = value51; if (value51 >= 0x2386f26fc10000) { value52 = 0x10 + value50; value53 = value51 / 0x2386f26fc10000; } uint256 value54 = value52; uint256 value55 = value53; if (value53 >= 0x05f5e100) { value54 = 0x08 + value52; value55 = value53 / 0x05f5e100; } uint256 value56 = value54; uint256 value57 = value55; if (value55 >= 0x2710) { value56 = 0x04 + value54; value57 = value55 / 0x2710; } uint256 value58 = value56; uint256 value59 = value57; if (value57 >= 0x64) { value58 = 0x02 + value56; value59 = value57 / 0x64; } uint256 value60 = value58; if (!(value59 < 0xa)) { value60 = 0x01 + value58; } if (!(0x1 + value60 <= 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + (0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + (0x01 + value60)))); uint256 value61 = 0x01 + value60; if (value60 != type(uint256).max) { value61 = (0x01 + value60) + (var_c + 0x20); } uint256 value16 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0x20 + (var_c + (0x01 + value31))); uint256 value15 = tokenId / 0x0a; while (true) { if (value15 == 0) { break; } value16 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value16; value15 = value15 / 0x0a; } uint256 value17 = 0; while (true) { if (value17 >= var_by) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_aq) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; var_c = 0x11 + (var_c.length + (0x3f + (var_c.length + (0x36 + (var_aq + (0x3f + (var_by + ((0x20 + var_c) + 0x0308)))))))); uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_aq) { break; } value17 = 0x20 + value17; var_c = 0x43 + (var_aq + ((0x20 + var_c) + var_c.length)); } } } } } } } } } } } else { uint256 value62 = var_c; if (life[tokenId] == 0x01) { } else { var_c = 0x40 + var_c; value62 = var_c; } if (bytes1(tier[tokenId]) > 0x03) _desolexPanic(33); if (bytes1(tier[tokenId]) == 0x01) { if (bytes1(tier[tokenId]) == 0x03) { uint256 value63 = 0; uint256 value64 = tokenId; if (tokenId >= 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000) { value63 = 0x40; value64 = tokenId / 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000; } uint256 value65 = value63; uint256 value66 = value64; if (value64 >= 0x04ee2d6d415b85acef8100000000) { value65 = 0x20 + value63; value66 = value64 / 0x04ee2d6d415b85acef8100000000; } uint256 value67 = value65; uint256 value68 = value66; if (value66 >= 0x2386f26fc10000) { value67 = 0x10 + value65; value68 = value66 / 0x2386f26fc10000; } uint256 value69 = value67; uint256 value70 = value68; if (value68 >= 0x05f5e100) { value69 = 0x08 + value67; value70 = value68 / 0x05f5e100; } uint256 value71 = value69; uint256 value72 = value70; if (value70 >= 0x2710) { value71 = 0x04 + value69; value72 = value70 / 0x2710; } uint256 value73 = value71; uint256 value74 = value72; if (value72 >= 0x64) { value73 = 0x02 + value71; value74 = value72 / 0x64; } uint256 value75 = value73; if (!(value74 < 0xa)) { value75 = 0x01 + value73; } if (!(0x1 + value75 <= 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + (0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + (0x01 + value75)))); uint256 value76 = 0x01 + value75; if (value75 != type(uint256).max) { value76 = (0x01 + value75) + (var_c + 0x20); } uint256 value16 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0x20 + (var_c + (0x01 + value31))); uint256 value15 = tokenId / 0x0a; while (true) { if (value15 == 0) { break; } value16 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value16; value15 = value15 / 0x0a; } uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_ct) { break; } value17 = 0x20 + value17; var_c = 0x11 + (var_ct + (0x3f + (var_c.length + (0x36 + (var_c.length + (0x3f + (var_c.length + ((0x20 + var_c) + 0x0308)))))))); uint256 value17 = 0; while (true) { if (value17 >= var_ct) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; } } } } } } } else { if (bytes1(tier[tokenId]) == 0x02) { uint256 value77 = 0; uint256 value78 = tokenId; if (tokenId >= 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000) { value77 = 0x40; value78 = tokenId / 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000; } uint256 value79 = value77; uint256 value80 = value78; if (value78 >= 0x04ee2d6d415b85acef8100000000) { value79 = 0x20 + value77; value80 = value78 / 0x04ee2d6d415b85acef8100000000; } uint256 value81 = value79; uint256 value82 = value80; if (value80 >= 0x2386f26fc10000) { value81 = 0x10 + value79; value82 = value80 / 0x2386f26fc10000; } uint256 value83 = value81; uint256 value84 = value82; if (value82 >= 0x05f5e100) { value83 = 0x08 + value81; value84 = value82 / 0x05f5e100; } uint256 value85 = value83; uint256 value86 = value84; if (value84 >= 0x2710) { value85 = 0x04 + value83; value86 = value84 / 0x2710; } uint256 value87 = value85; uint256 value88 = value86; if (value86 >= 0x64) { value87 = 0x02 + value85; value88 = value86 / 0x64; } uint256 value89 = value87; if (!(value88 < 0xa)) { value89 = 0x01 + value87; } if (!(0x1 + value89 <= 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + (0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + (0x01 + value89)))); uint256 value90 = 0x01 + value89; if (value89 != type(uint256).max) { value90 = (0x01 + value89) + (var_c + 0x20); } uint256 value16 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0x20 + (var_c + (0x01 + value31))); uint256 value15 = tokenId / 0x0a; while (true) { if (value15 == 0) { break; } value16 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value16; value15 = value15 / 0x0a; } uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_ct) { break; } value17 = 0x20 + value17; var_c = 0x11 + (var_ct + (0x3f + (var_c.length + (0x36 + (var_c.length + (0x3f + (var_c.length + ((0x20 + var_c) + 0x0308)))))))); uint256 value17 = 0; while (true) { if (value17 >= var_ct) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; var_c = 0x43 + (var_c.length + ((0x20 + var_c) + var_ct)); } } } } } } } else { uint256 value91 = var_c; uint256 value92 = 0; uint256 value93 = tokenId; if (tokenId >= 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000) { value92 = 0x40; value93 = tokenId / 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000; } uint256 value94 = value92; uint256 value95 = value93; if (value93 >= 0x04ee2d6d415b85acef8100000000) { value94 = 0x20 + value92; value95 = value93 / 0x04ee2d6d415b85acef8100000000; } uint256 value96 = value94; uint256 value97 = value95; if (value95 >= 0x2386f26fc10000) { value96 = 0x10 + value94; value97 = value95 / 0x2386f26fc10000; } uint256 value98 = value96; uint256 value99 = value97; if (value97 >= 0x05f5e100) { value98 = 0x08 + value96; value99 = value97 / 0x05f5e100; } uint256 value100 = value98; uint256 value101 = value99; if (value99 >= 0x2710) { value100 = 0x04 + value98; value101 = value99 / 0x2710; } uint256 value102 = value100; uint256 value103 = value101; if (value101 >= 0x64) { value102 = 0x02 + value100; value103 = value101 / 0x64; } uint256 value104 = value102; if (!(value103 < 0xa)) { value104 = 0x01 + value102; } if (!(0x1 + value104 <= 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + (0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + (0x01 + value104)))); uint256 value105 = 0x01 + value104; if (value104 != type(uint256).max) { value105 = (0x01 + value104) + (var_c + 0x20); } uint256 value16 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0x20 + (var_c + (0x01 + value31))); uint256 value15 = tokenId / 0x0a; while (true) { if (value15 == 0) { break; } value16 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value16; value15 = value15 / 0x0a; } uint256 value17 = 0; while (true) { if (value17 >= var_df) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_ct) { break; } value17 = 0x20 + value17; var_c = 0x11 + (var_ct + (0x3f + (var_c.length + (0x36 + (var_c.length + (0x3f + (var_df + ((0x20 + var_c) + 0x0308)))))))); uint256 value17 = 0; while (true) { if (value17 >= var_ct) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; } } } } } } } } } else { if (bytes1(tier[tokenId]) == 0x02) { if (bytes1(tier[tokenId]) == 0x03) { uint256 value106 = 0; uint256 value107 = tokenId; if (tokenId >= 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000) { value106 = 0x40; value107 = tokenId / 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000; } uint256 value108 = value106; uint256 value109 = value107; if (value107 >= 0x04ee2d6d415b85acef8100000000) { value108 = 0x20 + value106; value109 = value107 / 0x04ee2d6d415b85acef8100000000; } uint256 value110 = value108; uint256 value111 = value109; if (value109 >= 0x2386f26fc10000) { value110 = 0x10 + value108; value111 = value109 / 0x2386f26fc10000; } uint256 value112 = value110; uint256 value113 = value111; if (value111 >= 0x05f5e100) { value112 = 0x08 + value110; value113 = value111 / 0x05f5e100; } uint256 value114 = value112; uint256 value115 = value113; if (value113 >= 0x2710) { value114 = 0x04 + value112; value115 = value113 / 0x2710; } uint256 value116 = value114; uint256 value117 = value115; if (value115 >= 0x64) { value116 = 0x02 + value114; value117 = value115 / 0x64; } uint256 value118 = value116; if (!(value117 < 0xa)) { value118 = 0x01 + value116; } if (!(0x1 + value118 <= 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + (0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + (0x01 + value118)))); uint256 value119 = 0x01 + value118; if (value118 != type(uint256).max) { value119 = (0x01 + value118) + (var_c + 0x20); } uint256 value16 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0x20 + (var_c + (0x01 + value31))); uint256 value15 = tokenId / 0x0a; while (true) { if (value15 == 0) { break; } value16 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value16; value15 = value15 / 0x0a; } uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_ct) { break; } value17 = 0x20 + value17; var_c = 0x11 + (var_ct + (0x3f + (var_c.length + (0x36 + (var_c.length + (0x3f + (var_c.length + ((0x20 + var_c) + 0x0308)))))))); uint256 value17 = 0; while (true) { if (value17 >= var_ct) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; } } } } } } } else { uint256 value120 = 0; uint256 value121 = tokenId; if (tokenId >= 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000) { value120 = 0x40; value121 = tokenId / 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000; } uint256 value122 = value120; uint256 value123 = value121; if (value121 >= 0x04ee2d6d415b85acef8100000000) { value122 = 0x20 + value120; value123 = value121 / 0x04ee2d6d415b85acef8100000000; } uint256 value124 = value122; uint256 value125 = value123; if (value123 >= 0x2386f26fc10000) { value124 = 0x10 + value122; value125 = value123 / 0x2386f26fc10000; } uint256 value126 = value124; uint256 value127 = value125; if (value125 >= 0x05f5e100) { value126 = 0x08 + value124; value127 = value125 / 0x05f5e100; } uint256 value128 = value126; uint256 value129 = value127; if (value127 >= 0x2710) { value128 = 0x04 + value126; value129 = value127 / 0x2710; } uint256 value130 = value128; uint256 value131 = value129; if (value129 >= 0x64) { value130 = 0x02 + value128; value131 = value129 / 0x64; } uint256 value132 = value130; if (!(value131 < 0xa)) { value132 = 0x01 + value130; } if (!(0x1 + value132 <= 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + (0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + (0x01 + value132)))); uint256 value133 = 0x01 + value132; if (value132 != type(uint256).max) { value133 = (0x01 + value132) + (var_c + 0x20); } uint256 value16 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0x20 + (var_c + (0x01 + value31))); uint256 value15 = tokenId / 0x0a; while (true) { if (value15 == 0) { break; } value16 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value16; value15 = value15 / 0x0a; } uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_ct) { break; } value17 = 0x20 + value17; var_c = 0x11 + (var_ct + (0x3f + (var_c.length + (0x36 + (var_c.length + (0x3f + (var_c.length + ((0x20 + var_c) + 0x0308)))))))); uint256 value17 = 0; while (true) { if (value17 >= var_ct) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; var_c = 0x43 + (var_c.length + ((0x20 + var_c) + var_ct)); } } } } } } } } else { uint256 value149 = var_c; if (bytes1(tier[tokenId]) == 0x03) { } else { var_c = 0x40 + var_c; value149 = var_c; } if (bytes1(tier[tokenId]) > 0x03) _desolexPanic(33); if (bytes1(tier[tokenId]) == 0x03) { uint256 value150 = 0; uint256 value151 = tokenId; if (tokenId >= 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000) { value150 = 0x40; value151 = tokenId / 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000; } uint256 value152 = value150; uint256 value153 = value151; if (value151 >= 0x04ee2d6d415b85acef8100000000) { value152 = 0x20 + value150; value153 = value151 / 0x04ee2d6d415b85acef8100000000; } uint256 value154 = value152; uint256 value155 = value153; if (value153 >= 0x2386f26fc10000) { value154 = 0x10 + value152; value155 = value153 / 0x2386f26fc10000; } uint256 value156 = value154; uint256 value157 = value155; if (value155 >= 0x05f5e100) { value156 = 0x08 + value154; value157 = value155 / 0x05f5e100; } uint256 value158 = value156; uint256 value159 = value157; if (value157 >= 0x2710) { value158 = 0x04 + value156; value159 = value157 / 0x2710; } uint256 value160 = value158; uint256 value161 = value159; if (value159 >= 0x64) { value160 = 0x02 + value158; value161 = value159 / 0x64; } uint256 value162 = value160; if (!(value161 < 0xa)) { value162 = 0x01 + value160; } if (!(0x1 + value162 <= 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + (0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + (0x01 + value162)))); uint256 value163 = 0x01 + value162; if (value162 != type(uint256).max) { value163 = (0x01 + value162) + (var_c + 0x20); } uint256 value16 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0x20 + (var_c + (0x01 + value31))); uint256 value15 = tokenId / 0x0a; while (true) { if (value15 == 0) { break; } value16 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value16; value15 = value15 / 0x0a; } uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_ef) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_ct) { break; } value17 = 0x20 + value17; var_c = 0x11 + (var_ct + (0x3f + (var_c.length + (0x36 + (var_ef + (0x3f + (var_c.length + ((0x20 + var_c) + 0x0308)))))))); uint256 value17 = 0; while (true) { if (value17 >= var_ct) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_ef) { break; } value17 = 0x20 + value17; } } } } } } } else { if (bytes1(tier[tokenId]) == 0x02) { uint256 value164 = 0; uint256 value165 = tokenId; if (tokenId >= 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000) { value164 = 0x40; value165 = tokenId / 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000; } uint256 value166 = value164; uint256 value167 = value165; if (value165 >= 0x04ee2d6d415b85acef8100000000) { value166 = 0x20 + value164; value167 = value165 / 0x04ee2d6d415b85acef8100000000; } uint256 value168 = value166; uint256 value169 = value167; if (value167 >= 0x2386f26fc10000) { value168 = 0x10 + value166; value169 = value167 / 0x2386f26fc10000; } uint256 value170 = value168; uint256 value171 = value169; if (value169 >= 0x05f5e100) { value170 = 0x08 + value168; value171 = value169 / 0x05f5e100; } uint256 value172 = value170; uint256 value173 = value171; if (value171 >= 0x2710) { value172 = 0x04 + value170; value173 = value171 / 0x2710; } uint256 value174 = value172; uint256 value175 = value173; if (value173 >= 0x64) { value174 = 0x02 + value172; value175 = value173 / 0x64; } uint256 value176 = value174; if (!(value175 < 0xa)) { value176 = 0x01 + value174; } if (!(0x1 + value176 <= 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + (0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + (0x01 + value176)))); uint256 value177 = 0x01 + value176; if (value176 != type(uint256).max) { value177 = (0x01 + value176) + (var_c + 0x20); } uint256 value16 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0x20 + (var_c + (0x01 + value31))); uint256 value15 = tokenId / 0x0a; while (true) { if (value15 == 0) { break; } value16 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value16; value15 = value15 / 0x0a; } uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_ef) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_ct) { break; } value17 = 0x20 + value17; var_c = 0x11 + (var_ct + (0x3f + (var_c.length + (0x36 + (var_ef + (0x3f + (var_c.length + ((0x20 + var_c) + 0x0308)))))))); uint256 value17 = 0; while (true) { if (value17 >= var_ct) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_ef) { break; } value17 = 0x20 + value17; var_c = 0x43 + (var_ef + ((0x20 + var_c) + var_ct)); } } } } } } } else { uint256 value178 = var_c; if (bytes1(tier[tokenId]) == 0x01) { } else { var_c = 0x40 + var_c; value178 = var_c; } uint256 value179 = 0; uint256 value180 = tokenId; if (tokenId >= 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000) { value179 = 0x40; value180 = tokenId / 0x184f03e93ff9f4daa797ed6e38ed64bf6a1f010000000000000000; } uint256 value181 = value179; uint256 value182 = value180; if (value180 >= 0x04ee2d6d415b85acef8100000000) { value181 = 0x20 + value179; value182 = value180 / 0x04ee2d6d415b85acef8100000000; } uint256 value183 = value181; uint256 value184 = value182; if (value182 >= 0x2386f26fc10000) { value183 = 0x10 + value181; value184 = value182 / 0x2386f26fc10000; } uint256 value185 = value183; uint256 value186 = value184; if (value184 >= 0x05f5e100) { value185 = 0x08 + value183; value186 = value184 / 0x05f5e100; } uint256 value187 = value185; uint256 value188 = value186; if (value186 >= 0x2710) { value187 = 0x04 + value185; value188 = value186 / 0x2710; } uint256 value189 = value187; uint256 value190 = value188; if (value188 >= 0x64) { value189 = 0x02 + value187; value190 = value188 / 0x64; } uint256 value191 = value189; if (!(value190 < 0xa)) { value191 = 0x01 + value189; } if (!(0x1 + value191 <= 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + (0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + (0x01 + value191)))); uint256 value192 = 0x01 + value191; if (value191 != type(uint256).max) { value192 = (0x01 + value191) + (var_c + 0x20); } uint256 value16 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + (0x20 + (var_c + (0x01 + value31))); uint256 value15 = tokenId / 0x0a; while (true) { if (value15 == 0) { break; } value16 = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + value16; value15 = value15 / 0x0a; } uint256 value17 = 0; while (true) { if (value17 >= var_er) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_ef) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_c.length) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_ct) { break; } value17 = 0x20 + value17; var_c = 0x11 + (var_ct + (0x3f + (var_c.length + (0x36 + (var_ef + (0x3f + (var_er + ((0x20 + var_c) + 0x0308)))))))); uint256 value17 = 0; while (true) { if (value17 >= var_ct) { break; } value17 = 0x20 + value17; uint256 value17 = 0; while (true) { if (value17 >= var_ef) { break; } value17 = 0x20 + value17; } } } } } } } } } } } } } function referralsEnabled() public view returns (bool) { return !(!(bytes1(stor_15))); } function Unknown_e987e14b(uint256 arg0) public returns (uint256) { require(0x0 != arg0, InvalidConfiguration()); (bool success0, bytes memory returnData0) = address(0x471506e6aded0b9811d05b8cac8db25ee839ac94).estimateRequestPriceNative(0x0186a0, 0x01, arg0); // staticcall require(success0); uint256 var_e; var_e = var_e + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_e + returnData0.length) - var_e) < 0x20)); return var_e.length; } function Unknown_eb302a44(uint256 arg0, uint256 arg1, bool arg2) public { require(msg.sender == gameController, ControllerOnly()); if (life[arg0] > 0x03) _desolexPanic(33); require(life[arg0] == 0x01, WrongState()); require(arg1 == unresolved_09d50bd1[arg0], CustomError_811ff142()); uint256 value0 = 0x02; if (!(arg2)) { value0 = 0x03; } if (!(value0 <= 0x3)) _desolexPanic(33); life[arg0] = value0; emit Event_ce627dbc(arg0, arg1, arg2); } function Unknown_f230b4ac(uint256 arg0) public onlyOwner { require(paused, ExpectedPause()); require(stor_c != 0x2, ReentrancyGuardReentrantCall()); stor_c = 0x02; (bool success0, bytes memory returnData0) = address(0xbde905a3424f41d3a400a84e10a118e7df0f9bc7).call{ value: arg0 }(""); // call uint256 value0 = 0x60; if (returnData0.length != 0) { uint256 var_a; var_a = var_a + ((returnData0.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value0 = var_a; } require(success0, PaymentMismatch()); emit Event_e9859c82(arg0); stor_c = 0x01; } function transferOwnership(address newOwner) public onlyOwner { pendingOwner = newOwner; emit OwnershipTransferStarted(owner, pendingOwner); } function Unknown_f44168b3(bool arg0) public returns (uint256) { require(arg0 == (arg0 & 0xff)); require(!((arg0 & 0xff) == 0x0 || (arg0 & 0xff) > 0x5), MintLimit()); if (0x1 == (0xff & arg0)) { return 0; } else { if (0x2 == (0xff & arg0)) { (bool success1, bytes memory returnData1) = address(0xcee1bd3235c7119a96de107138600b4d0d19ecbf).quote(address(uint160(0x281b57b028e10000))); // staticcall require(success1); var_c = var_c + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData1.length) - var_c) < 0x20)); return var_c.length; } else { (bool success2, bytes memory returnData2) = address(0xcee1bd3235c7119a96de107138600b4d0d19ecbf).quote(address(uint160(0x3c3ac70175320000))); // staticcall require(success2); var_c = var_c + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_c + returnData2.length) - var_c) < 0x20)); return var_c.length; } } } function internal_179a(address arg0) private { // Decompilation incomplete: helper effect provenance is conservative. (bool success0, bytes memory returnData0) = address(0x60b9262456de011f7d15a54cdd8c48baaa8b022f).handleOf(arg0); // staticcall require(success0); var_b = var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData0.length + 0x1f)); require(!(((var_b + returnData0.length) - var_b) < 0x20)); require(!(var_b.length > 0xffffffffffffffff)); require((var_b + returnData0.length) > ((var_b + var_b.length) + 0x1f)); if (!(var_d <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_d))) + 0x1f))) < var_b) | ((var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_d))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_b = var_b + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_d))) + 0x1f)); require(!(((var_b + var_b.length) + var_f + 0x20) > (var_b + returnData0.length))); uint256 value0 = 0; while (true) { if (value0 >= var_f) { break; } value0 = 0x20 + value0; require(0x0 != var_i, AgentRequired()); (bool success1, bytes memory returnData1) = address(0x60b9262456de011f7d15a54cdd8c48baaa8b022f).ownerOf(keccak256(var_k)); // staticcall require(success1); var_b = var_b + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_b + returnData1.length) - var_b) < 0x20)); require(var_b.length == (var_b.length & 0xffffffffffffffffffffffffffffffffffffffff)); require((0xffffffffffffffffffffffffffffffffffffffff & value1) == arg0, AgentRequired()); } } function internal_4c11(uint256 arg0, uint256 arg1) private returns (uint256) { // Decompilation incomplete: helper effect provenance is conservative. require(arg1 - arg0 >= 0x20); require(!(var_d > 0xffffffffffffffff)); require(arg1 > ((arg0 + var_d) + 0x1f)); if (!(var_e <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_e))) + 0x1f))) < var_c) | ((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_e))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_e))) + 0x1f)); require(!(((arg0 + var_d) + var_g + 0x20) > arg1)); uint256 value0 = 0; while (true) { uint256 value1 = value0; if (value0 >= var_g) { break; } if (0x20 + value0 >= var_g) { break; } value0 = 0x20 + (0x20 + value0); value1 = 0x20 + value0; } return var_c; } function internal_10bf() private { // Decompilation incomplete: helper effect provenance is conservative. require(msg.sender == owner, OwnableUnauthorizedAccount()); uint256 value0 = (activated) ? 1 : 0; uint256 var_b; if (!activated) { (bool success0, bytes memory returnData0) = address(0x163a94c3523c404f3f58d400a3ad605f71fa09ec).paused(); // staticcall require(success0); var_b = var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_b + returnData0.length) - var_b) < 0x20)); require(var_b.length == (var_b.length != 0x0)); value0 = !var_b.length; } bool flag0 = value0 != 0x0; if (value0 == 0) { (bool success1, bytes memory returnData1) = address(0x163a94c3523c404f3f58d400a3ad605f71fa09ec).totalMinted(); // staticcall require(success1); var_b = var_b + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_b + returnData1.length) - var_b) < 0x20)); flag0 = !(var_b.length < 0x270f); } require(!flag0, CustomError_a0550940()); (bool success2, bytes memory returnData2) = address(0x163a94c3523c404f3f58d400a3ad605f71fa09ec).totalMinted(); // staticcall require(success2); var_b = var_b + ((returnData2.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require(!(((var_b + returnData2.length) - var_b) < 0x20)); unresolved_9c9dea71 = var_b.length; activated = true; emit MigrationActivated(var_b.length); require(paused, ExpectedPause()); paused = false; emit Unpaused(msg.sender); } function internal_1984(uint256 arg0, address arg1, address arg2) private { // Decompilation incomplete: helper effect provenance is conservative. require(arg1 != address(0), ERC721InvalidReceiver()); internal_35e7(msg.sender, arg0, arg1); require(address((ownerOf[__desolex_internal_35e7_19bb_arg1])) == arg2, ERC721IncorrectOwner()); } function internal_35e7(address arg0, uint256 arg1, address arg2) private returns (uint256) { // Decompilation incomplete: helper effect provenance is conservative. bool flag0 = !(!(ownerOf[arg1])); if (ownerOf[arg1]) { flag0 = unresolved_89644c77[arg1]; } require(!flag0, CustomError_ad9303b3()); bool flag1 = !(!(ownerOf[arg1])); if (ownerOf[arg1]) { if (life[arg1] > 0x03) _desolexPanic(33); bool flag10 = !(life[arg1] == 0); if (!life[arg1]) { if (bytes1(tier[arg1]) > 0x03) _desolexPanic(33); flag10 = (bytes1(tier[arg1])) == 0; } flag1 = flag10; } require(!flag1, CustomError_b04a5f91()); if (arg0 == address(0)) { if (ownerOf[arg1]) { bool flag2 = (0 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0; if (address(0)) { flag2 = unresolved_89644c77[arg1]; } require(!flag2, CustomError_ad9303b3()); if ((__desolex_internal_3f82_1a09_arg0 != 0x0) || ((__desolex_internal_3f82_1a09_arg1 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0)) { require(ownerOf[__desolex_internal_2b00_3fa6_arg0] != 0x0, ERC721NonexistentToken()); bool flag4 = (__desolex_internal_3f82_1a09_arg1 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0; if (address(__desolex_internal_3f82_1a09_arg1)) { flag4 = !(ownerOf[__desolex_internal_3f82_1a09_arg2] == (address(__desolex_internal_3f82_1a09_arg1))); } require(!(flag4 && isApprovedForAll[0xffffffffffffffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffffffffffffffff & ownerOf[__desolex_internal_3f82_1a09_arg2])][0xffffffffffffffffffffffffffffffffffffffff & __desolex_internal_3f82_1a09_arg1] == 0x0), ERC721InvalidApprover()); if (__desolex_internal_3f82_1a09_arg0 != 0x0) { emit Approval(ownerOf[__desolex_internal_3f82_1a09_arg2], address(__desolex_internal_3f82_1a09_arg3), __desolex_internal_3f82_1a09_arg2); } } getApproved[__desolex_internal_3f82_1a09_arg2] = (address(__desolex_internal_3f82_1a09_arg3)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & getApproved[__desolex_internal_3f82_1a09_arg2]); balanceOf[ownerOf[arg1]] = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + balanceOf[ownerOf[arg1]]; } if (arg2 != address(0)) { balanceOf[arg2] = 0x01 + balanceOf[arg2]; } ownerOf[arg1] = arg2 | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & ownerOf[arg1]); emit Transfer(ownerOf[arg1], arg2, arg1); } else { uint256 value1 = (!(!(arg0))) ? 1 : 0; if (__desolex_internal_45d3_457a_arg1 != 0x0) { uint256 value0 = ((address(__desolex_internal_45d3_457a_arg2)) == __desolex_internal_45d3_457a_arg1) ? 1 : 0; if (address(__desolex_internal_45d3_457a_arg2) != __desolex_internal_45d3_457a_arg1) { value0 = bytes1(isApprovedForAll[address(__desolex_internal_45d3_457a_arg2)][__desolex_internal_45d3_457a_arg1]); } uint256 value2 = value0; if (value0 == 0) { value2 = (arg0 == getApproved[arg1]) ? 1 : 0; } value1 = value2; } if (!(value1 != 0x0)) { require((ownerOf[arg1] & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0, ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } if (ownerOf[arg1]) { bool flag6 = (0 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0; if (address(0)) { flag6 = unresolved_89644c77[arg1]; } require(!flag6, CustomError_ad9303b3()); if ((__desolex_internal_3f82_1a09_arg0 != 0x0) || ((__desolex_internal_3f82_1a09_arg1 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0)) { require(ownerOf[__desolex_internal_2b00_3fa6_arg0] != 0x0, ERC721NonexistentToken()); bool flag8 = (__desolex_internal_3f82_1a09_arg1 & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0; if (address(__desolex_internal_3f82_1a09_arg1)) { flag8 = !(ownerOf[__desolex_internal_3f82_1a09_arg2] == (address(__desolex_internal_3f82_1a09_arg1))); } require(!(flag8 && isApprovedForAll[0xffffffffffffffffffffffffffffffffffffffff & (0xffffffffffffffffffffffffffffffffffffffff & ownerOf[__desolex_internal_3f82_1a09_arg2])][0xffffffffffffffffffffffffffffffffffffffff & __desolex_internal_3f82_1a09_arg1] == 0x0), ERC721InvalidApprover()); if (__desolex_internal_3f82_1a09_arg0 != 0x0) { emit Approval(ownerOf[__desolex_internal_3f82_1a09_arg2], address(__desolex_internal_3f82_1a09_arg3), __desolex_internal_3f82_1a09_arg2); } } getApproved[__desolex_internal_3f82_1a09_arg2] = (address(__desolex_internal_3f82_1a09_arg3)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & getApproved[__desolex_internal_3f82_1a09_arg2]); balanceOf[ownerOf[arg1]] = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff + balanceOf[ownerOf[arg1]]; } if (arg2 != address(0)) { balanceOf[arg2] = 0x01 + balanceOf[arg2]; } ownerOf[arg1] = arg2 | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & ownerOf[arg1]); emit Transfer(ownerOf[arg1], arg2, arg1); } if (ownerOf[arg1] != address(0)) { if (!(ownerOf[arg1] == arg2)) { require(ownerOf[arg1] != address(0), ERC721InvalidOwner()); if (!(balanceOf[ownerOf[arg1]] == mapping_7[arg1])) { tokenOfOwnerByIndex[ownerOf[arg1]][mapping_7[arg1]] = tokenOfOwnerByIndex[ownerOf[arg1]][balanceOf[ownerOf[arg1]]]; mapping_7[tokenOfOwnerByIndex[ownerOf[arg1]][balanceOf[ownerOf[arg1]]]] = mapping_7[arg1]; } mapping_7[arg1] = 0; tokenOfOwnerByIndex[ownerOf[arg1]][balanceOf[ownerOf[arg1]]] = 0; } } else { mapping_9[arg1] = totalSupply; totalSupply = totalSupply + 0x01; tokenByIndex[totalSupply] = arg1; } if (arg2 != address(0)) { if (!(ownerOf[arg1] == arg2)) { require(arg2 != address(0), ERC721InvalidOwner()); tokenOfOwnerByIndex[arg2][(balanceOf[arg2] - 0x01)] = arg1; mapping_7[arg1] = balanceOf[arg2] - 0x01; } return (ownerOf[arg1]); } else { if (!((totalSupply - 0x01) < totalSupply)) _desolexPanic(50); if (!(mapping_9[arg1] < totalSupply)) _desolexPanic(50); stor_expr_ay = stor_expr_az; mapping_9[stor_expr_az] = mapping_9[arg1]; mapping_9[arg1] = 0; if (!(totalSupply != 0x0)) _desolexPanic(49); stor_expr_az = 0; totalSupply = totalSupply - 0x01; return (ownerOf[arg1]); } } function internal_1eaa(uint256 tokenId, address to, address _from) private { // Decompilation incomplete: helper effect provenance is conservative. uint256 var_a; var_a = 0x20 + var_a; internal_22a1(var_a, tokenId, to, _from); } function internal_22a1(uint256 arg0, uint256 arg1, address arg2, address arg3) private { // Decompilation incomplete: helper effect provenance is conservative. internal_1984(arg1, arg2, arg3); if (!(arg2.code.length == 0x0)) { uint256 value2 = 0; while (true) { if (value2 >= var_k) { break; } value2 = 0x20 + value2; (bool success0, bytes memory returnData0) = arg2.onERC721Received(msg.sender, arg3, arg1, 0x80); // call if (!success0) { if (!(success0)) { uint256 value3 = 0x60; if (returnData0.length != 0x0) { var_a = var_a + ((returnData0.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value3 = var_a; } require(0x0 != var_n, ERC721InvalidReceiver()); revert(); } require(0x150b7a0200000000000000000000000000000000000000000000000000000000 == (arg0 & 0xffffffff00000000000000000000000000000000000000000000000000000000), ERC721InvalidReceiver()); } else { var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData0.length + 0x1f)); require((var_a + returnData0.length) - var_a >= 0x20); require(var_o == (var_o & 0xffffffff00000000000000000000000000000000000000000000000000000000)); if (0x01 == 0) { uint256 value5 = 0x60; if (returnData0.length != 0x0) { var_a = var_a + ((returnData0.length + 0x3f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); value5 = var_a; } require(0x0 != var_q, ERC721InvalidReceiver()); revert(); } require(0x150b7a0200000000000000000000000000000000000000000000000000000000 == (value4 & 0xffffffff00000000000000000000000000000000000000000000000000000000), ERC721InvalidReceiver()); } } } } function internal_227b(bool arg0) private { // Decompilation incomplete: helper effect provenance is conservative. require(msg.sender == owner, OwnableUnauthorizedAccount()); if (!arg0) { bool flag0 = !(activated); if (activated) { (bool success0, bytes memory returnData0) = address(0x163a94c3523c404f3f58d400a3ad605f71fa09ec).paused(); // staticcall require(success0); uint256 var_b; var_b = var_b + ((returnData0.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_b + returnData0.length) - var_b >= 0x20); flag0 = !(var_d); } bool flag1 = flag0; if (!(flag0)) { (bool success1, bytes memory returnData1) = address(0x163a94c3523c404f3f58d400a3ad605f71fa09ec).totalMinted(); // staticcall require(success1); var_b = var_b + ((returnData1.length + 0x1f) & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0)); require((var_b + returnData1.length) - var_b >= 0x20); flag1 = !(var_d == unresolved_9c9dea71); } require(!flag1, CustomError_a0550940()); require(paused, ExpectedPause()); paused = false; emit Unpaused(msg.sender); } else { require(!paused, EnforcedPause()); paused = true; emit Paused(msg.sender); } } function __desolexSelectorShim(uint32 rewrittenSelector) private { assembly { let input := mload(0x40) calldatacopy(input, 0, calldatasize()) mstore(input, or(and(mload(input), 0x00000000ffffffffffffffffffffffffffffffffffffffffffffffffffffffff), shl(224, and(rewrittenSelector, 0xffffffff)))) let success := delegatecall(gas(), address(), input, calldatasize(), 0, 0) let size := returndatasize() returndatacopy(input, 0, size) switch success case 0 { revert(input, size) } default { return(input, size) } } } // Note: This selector table is synthetic and is not part of the original Solidity source. // It records the recovered selector-to-signature mapping without executable behavior. // 0x01ffc9a7 => supportsInterface(bytes4) // 0x06fdde03 => name() // 0x081812fc => getApproved(uint256) // 0x095ea7b3 => approve(address,uint256) // 0x09d50bd1 => unresolved_09d50bd1(bytes32) // 0x0b39ed47 => quote(address) // 0x0d1cfcae => agentRegistry() // 0x0f15f4c0 => activate() // 0x1075abb2 => Unknown_1075abb2() // 0x12065fe0 => getBalance() // 0x18160ddd => totalSupply() // 0x186601ca => activated() // 0x1f1b9756 => agentKeyOf(address) // 0x1fb3ac7c => unresolved_1fb3ac7c(bytes32) // 0x1fe543e3 => rawFulfillRandomWords(uint256,uint256[]) // 0x22272024 => life(uint256) // 0x23b872dd => transferFrom(address,address,uint256) // 0x2b4df9d3 => requestToken(uint256) // 0x2c2bbeba => setReferralsEnabled(bool) // 0x2c885fab => Unknown_2c885fab(uint256) // 0x2cb62beb => unresolved_2cb62beb(bytes32) // 0x2f745c59 => tokenOfOwnerByIndex(address,uint256) // 0x3013ce29 => paymentToken() // 0x302ec51d => Unknown_302ec51d(uint256) // 0x313b2a1a => Unknown_313b2a1a(uint256,uint256) // 0x32cb6b0c => MAX_SUPPLY() // 0x33d608f1 => CALLBACK_GAS_LIMIT() // 0x40f2035e => miningPower(uint256) // 0x41aa70ca => quoteBNB(uint8) // 0x42842e0e => safeTransferFrom(address,address,uint256) // 0x4f6ccce7 => tokenByIndex(uint256) // 0x595e12b1 => unresolved_595e12b1() // 0x5c975abb => paused() // 0x5eb68e9c => Unknown_5eb68e9c(bool) // 0x60c899d5 => basePower(uint256) // 0x61d027b3 => treasury() // 0x6352211e => ownerOf(uint256) // 0x67f082b0 => REQUEST_CONFIRMATIONS() // 0x6dda34db => tier(uint256) // 0x70a08231 => balanceOf(address) // 0x715018a6 => renounceOwnership() // 0x7419f946 => marsToken() // 0x798c5d20 => originAgent(uint256) // 0x79ba5097 => acceptOwnership() // 0x7dfac4d7 => maxRandomnessFee() // 0x83481739 => newMinted() // 0x89644c77 => unresolved_89644c77(bytes32) // 0x8da5cb5b => owner() // 0x9129b502 => unresolved_9129b502() // 0x95d89b41 => symbol() // 0x9c9dea71 => unresolved_9c9dea71() // 0x9ed0868d => i_vrfV2PlusWrapper() // 0xa22cb465 => setApprovalForAll(address,bool) // 0xa2309ff8 => totalMinted() // 0xa271f65a => bnbOracle() // 0xa56d6340 => setGameController(address) // 0xa7f3f0d2 => legacy() // 0xaceb65d2 => Unknown_aceb65d2(uint256) // 0xb6935501 => setMintPaused(bool) // 0xb88d4fde => safeTransferFrom(address,address,uint256,bytes) // 0xc87b56dd => tokenURI(uint256) // 0xc951c9f9 => THIRD_PRICE() // 0xcce132d1 => MAX_MINTS() // 0xd379a5b4 => referralsEnabled() // 0xe30c3978 => pendingOwner() // 0xe5f4e506 => POWER_SCALE() // 0xe6a83757 => SECOND_PRICE() // 0xe76d5168 => getLinkToken() // 0xe985e9c5 => isApprovedForAll(address,address) // 0xe987e14b => Unknown_e987e14b(uint256) // 0xeb302a44 => Unknown_eb302a44(uint256,uint256,bool) // 0xf230b4ac => Unknown_f230b4ac(uint256) // 0xf2fde38b => transferOwnership(address) // 0xf44168b3 => Unknown_f44168b3(bool) // 0xf68256a8 => gameController() // 0xf8e040bd => unresolved_f8e040bd(bytes32) // 0xf99c1447 => referrerOf(bytes32) // 0xfd597f11 => unresolved_fd597f11(uint256)}