BNB Chain
0x7f3f9f4ed8987b78adc448a840169a0fd5affaab
Decompiled Solidity recovered from this contract's runtime bytecode. Best-effort reconstruction — confirm behaviour against on-chain state.
Decompilation outputBNB Chain · 0x7f3f9f4e…d5affaab17.6 KB69.6 s
This result is permanently available athttps://decompiler.exvul.com/bsc/0x7f3f9f4ed8987b78adc448a840169a0fd5affaab
4,761 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 calculator = address(0xb4123869ca90735bd2d9847b8a7dc60c36699dc3); string _name; // STORAGE[0x0] string _symbol; // STORAGE[0x1] bytes32[] array_2; // STORAGE[0x2] // DESOLEX_RAW_STORAGE: whole slot: array [Layout] vs mapping [Layout] (ambiguous) mapping(bytes32 => bytes32) mapping_2; // STORAGE[0x2] // DESOLEX_RAW_STORAGE: whole slot: array [Layout] vs mapping [Layout] (ambiguous) mapping(address => uint256) public balanceOf; // STORAGE[0x3] mapping(uint256 => address) public getApproved; // STORAGE[0x4] mapping(address => mapping(address => bool)) public isApprovedForAll; // STORAGE[0x5] address public owner; // STORAGE[0x6] address public pendingOwner; // STORAGE[0x7] bytes32 stor_8; // STORAGE[0x8] address public svgGenerator; // STORAGE[0x9] uint256 public nextVestingId; // STORAGE[0xa] mapping(address => uint256) mapping_b; // STORAGE[0xb] mapping(uint256 => uint256) mapping_c; // STORAGE[0xc] mapping(uint256 => address) mapping_d; // STORAGE[0xd] mapping(uint256 => bool) mapping_e; // STORAGE[0xe] mapping(address => uint256) mapping_f; // STORAGE[0xf] uint256 public feePercentage; // STORAGE[0x10] uint256 public flatFee; // STORAGE[0x11] address public feeCollector; // STORAGE[0x12] mapping(address => bool) public feeExemptCreators; // STORAGE[0x13] mapping(address => bool) public feeExemptTokens; // STORAGE[0x14] uint256 stor_expr_aa; uint256 stor_expr_ac; uint256 stor_expr_ad; bytes32 stor_expr_af; uint256 stor_expr_ag; address stor_expr_ai; bool stor_expr_aj_1_1; bytes32 stor_expr_ar; // DESOLEX_RAW_STORAGE: whole slot: address [LegacyInference] vs uint256 [LegacyInference] (ambiguous) bytes32 stor_expr_av; // DESOLEX_RAW_STORAGE: whole slot: address [LegacyInference] vs uint256 [LegacyInference] (ambiguous) uint256 stor_expr_ay; address stor_expr_b; address stor_expr_bj; address stor_expr_bt; bytes32 stor_expr_bu; // DESOLEX_RAW_STORAGE: whole slot: address [LegacyInference] vs uint256 [LegacyInference] (ambiguous) uint256 stor_expr_bv; bool stor_expr_bw; bytes32 stor_expr_bx; uint256 stor_expr_by; uint256 stor_expr_bz; uint256 stor_expr_c; uint256 stor_expr_ca; uint256 stor_expr_cb; uint256 stor_expr_cc; address stor_expr_co; uint256 stor_expr_cp; uint256 stor_expr_cq; uint256 stor_expr_cr; uint256 stor_expr_cs; bool stor_expr_d; uint256 stor_expr_df; address stor_expr_dn; address stor_expr_do; uint256 stor_expr_dp; bool stor_expr_dq; bytes32 stor_expr_dr; uint256 stor_expr_ds; uint256 stor_expr_dt; uint256 stor_expr_du; uint256 stor_expr_dv; uint256 stor_expr_e; address stor_expr_eg; uint256 stor_expr_f; uint256 stor_expr_q; uint256 stor_expr_r; uint256 stor_expr_s; uint256 stor_expr_w; error ERC721InvalidOwner(address); error ERC721InvalidApprover(address); event VestingCancelled(uint256 indexed); error InvalidFlatFee(); error FailedInnerCall(); error SafeERC20FailedOperation(address); event Approval(address indexed, address indexed, uint256 indexed); error ERC721InvalidOperator(address); error NoTokensToRelease(); event VestingToppedUp(uint256 indexed, address indexed, uint256, (uint256,uint256,uint8)[]); event FeesCollected(address, uint256, uint256); event CreatorFeeExemptionUpdated(address, bool); error ERC721InvalidReceiver(address); error ERC721IncorrectOwner(address, uint256, address); error AddressEmptyCode(address); event TokenFeeExemptionUpdated(address, bool); event SVGGeneratorUpdated(address indexed, address indexed); event TokensReleased(uint256 indexed, address indexed, uint256); event Transfer(address indexed, address indexed, uint256 indexed); event FeeCollectorUpdated(address indexed, address indexed); error InvalidSVGGenerator(); error NotAuthorized(); error FeeTransferFailed(); error TokenDoesNotExist(); error InvalidBeneficiary(); event FeePercentageUpdated(uint256); event VestingTransferred(uint256 indexed, address indexed, address indexed); error ERC721InsufficientApproval(address, uint256); error InvalidFeeCollector(); error InvalidToken(); error NonTransferableToken(); event FlatFeeUpdated(uint256); event ApprovalForAll(address indexed, address indexed, bool); error InvalidFeePercentage(); error ERC721InvalidSender(address); error ReentrancyGuardReentrantCall(); error NFTAlreadyMinted(); error InvalidArray(); error ERC721NonexistentToken(uint256); event VestingCreated(uint256 indexed, address indexed, address, (uint256,uint256,uint8)[], bool, bool, bool); error OwnableUnauthorizedAccount(address); event AirdropVestingCreated(uint256[], address[]); error VestingAlreadyCancelled(); event OwnershipTransferStarted(address indexed, address indexed); error NotCancellable(); error InvalidAmount(); 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()); _; } function topUpVesting(uint256 arg0, (uint256,uint256,uint8)[] memory arg1) public payable { if (!(msg.value)) { if ((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) >= 0x40) { if (!(arg1.length > 0xffffffffffffffff)) { if (((0x04 + arg1) + 0x1f) < msg.data.length) { if (!(arg1.length > 0xffffffffffffffff)) { if (!(((arg1.length * 0x60) + (0x04 + arg1) + 0x20) > msg.data.length)) { if (stor_8 != 0x02) { stor_8 = 0x02; if (msg.sender == (stor_expr_b)) { if (!(bytes1(stor_expr_c >> 0x10))) { if (bytes1(stor_expr_c >> 0x18)) { if ((stor_expr_d + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) <= stor_expr_d) { if ((stor_expr_d + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < stor_expr_d) { if (arg1 != 0x0) { if ((arg1 + 0x20) > stor_expr_e) { if (!(0 < arg1.length)) { (bool success0, bytes memory returnData0) = address(0xb4123869ca90735bd2d9847b8a7dc60c36699dc3).getTotalAmount(0x20); // staticcall if (success0) { uint256 value1 = this.code.length; uint256 var_e; uint256 value2 = var_e.length; if (success0) { uint256 value0 = returnData0.length; if (0x20 <= returnData0.length) { value0 = 0x20; } if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value0 + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value0 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value0 + 0x1f)); require(((var_e + value0) - var_e) >= 0x20); } else { value1 = var_e; value2 = 0; } if (value2 > stor_expr_f) { if (((arg1 + 0x20) + 0x20) >= stor_expr_f) { if (!(0 < arg1.length)) { (bool success1, bytes memory returnData1) = address(0xb4123869ca90735bd2d9847b8a7dc60c36699dc3).getTotalAmount(0x20); // staticcall if (success1) { if (success1) { uint256 value3 = returnData1.length; if (0x20 <= returnData1.length) { value3 = 0x20; } if (!(((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value3 + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value3 + 0x1f))) > 0xffffffffffffffff))) { var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value3 + 0x1f)); require(((var_e + value3) - var_e) >= 0x20); if (mapping_b[mapping_d[arg0]] != 0) { (bool success2, bytes memory returnData2) = mapping_d[arg0].balanceOf(address(this)); // staticcall if (success2) { uint256 value5 = this.code.length; uint256 value6 = var_e.length; if (success2) { uint256 value4 = returnData2.length; if (0x20 <= returnData2.length) { value4 = 0x20; } if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value4 + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value4 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value4 + 0x1f)); require(((var_e + value4) - var_e) >= 0x20); } else { value5 = var_e; value6 = 0; } if (value6 != 0x0) { if (value6 + 0x01 != 0) { mapping_f[mapping_d[arg0]] = ((mapping_b[mapping_d[arg0]] + 0x01) * 0x0de0b6b3a7640000) / (value6 + 0x01); bool flag0 = !(feeExemptCreators[msg.sender]); if (!feeExemptTokens[mapping_d[arg0]]) { } else { flag0 = !(feeExemptTokens[mapping_d[arg0]]); } uint256 value7 = ((var_e.length - stor_expr_f) * feePercentage) / 0x2710; if ((flag0) && (feePercentage != 0x0)) { } else { value7 = 0; } if ((var_e.length - stor_expr_f) <= ((var_e.length - stor_expr_f) + value7)) { (bool success3, bytes memory returnData3) = mapping_d[arg0].balanceOf(address(this)); // staticcall if (success3) { if (success3) { uint256 value8 = returnData3.length; if (0x20 <= returnData3.length) { value8 = 0x20; } if (!(((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value8 + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value8 + 0x1f))) > 0xffffffffffffffff))) { var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value8 + 0x1f)); require(((var_e + value8) - var_e) >= 0x20); if (((var_e + 0xa0) < var_e) | ((var_e + 0xa0) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + 0xa0; (bool success4, bytes memory returnData4) = mapping_d[arg0].transferFrom(msg.sender, address(this), (var_e.length - stor_expr_f) + value7); // call uint256 value9 = 0x60; if ((returnData4.length) != 0x0) { if (returnData4.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData4.length))) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData4.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData4.length))) + 0x1f)); value9 = var_e; } if (!(success4)) { require(!var_r); revert FailedInnerCall(); } require(!(var_r == 0x0 && mapping_d[arg0].code.length == 0x0), AddressEmptyCode()); uint256 value10 = this.code.length; uint256 value11 = this.code.length; bool flag3 = !(var_s); if (!(!(var_t))) { require(!(value9 + var_t - value9 < 0x20)); require((!(!(var_s))) == var_s); } else { value10 = var_t; value11 = value9; flag3 = !(!(var_t)); } require(!(flag3), SafeERC20FailedOperation()); (bool success5, bytes memory returnData5) = mapping_d[arg0].balanceOf(address(this)); // staticcall if (success5 && !success5 && !((0 - var_e.length) > 0) && !value7 && !(((0 - var_e.length) - value7) > (0 - var_e.length)) && !(0 < arg1.length)) { address(0xb4123869ca90735bd2d9847b8a7dc60c36699dc3).getTotalAmount(0x20); // staticcall } } } } } } else { mapping_f[mapping_d[arg0]] = 0x0de0b6b3a7640000; bool flag4 = !(feeExemptCreators[msg.sender]); if (!feeExemptTokens[mapping_d[arg0]]) { } else { flag4 = !(feeExemptTokens[mapping_d[arg0]]); } uint256 value12 = ((var_e.length - stor_expr_f) * feePercentage) / 0x2710; if ((flag4) && (feePercentage != 0x0)) { } else { value12 = 0; } (bool success7, bytes memory returnData7) = mapping_d[arg0].balanceOf(address(this)); // staticcall require(success7); if (success7) { uint256 value13 = returnData7.length; if (0x20 <= returnData7.length) { value13 = 0x20; } if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value13 + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value13 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value13 + 0x1f)); require(((var_e + value13) - var_e) >= 0x20); if (((var_e + 0xa0) < var_e) | ((var_e + 0xa0) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + 0xa0; (bool success8, bytes memory returnData8) = mapping_d[arg0].transferFrom(msg.sender, address(this), (var_e.length - stor_expr_f) + value12); // call uint256 value14 = 0x60; if ((returnData8.length) != 0x0) { if (returnData8.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData8.length))) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData8.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData8.length))) + 0x1f)); value14 = var_e; } if (!(success8)) { require(!var_r); revert FailedInnerCall(); } require(!(var_r == 0x0 && mapping_d[arg0].code.length == 0x0), AddressEmptyCode()); uint256 value15 = this.code.length; uint256 value16 = this.code.length; bool flag7 = !(var_w); if (!(!(var_x))) { require(!(value14 + var_x - value14 < 0x20)); require((!(!(var_w))) == var_w); } else { value15 = var_x; value16 = value14; flag7 = !(!(var_x)); } require(!(flag7), SafeERC20FailedOperation()); (bool success9, bytes memory returnData9) = mapping_d[arg0].balanceOf(address(this)); // staticcall require(success9); if (success9) { uint256 value17 = returnData9.length; if (0x20 <= returnData9.length) { value17 = 0x20; } if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value17 + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value17 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value17 + 0x1f)); require(((var_e + value17) - var_e) >= 0x20); uint256 value21 = this.code.length; if (value12 != 0x0) { if (((var_e + 0x80) < var_e) | ((var_e + 0x80) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + 0x80; (bool success10, bytes memory returnData10) = address(mapping_d[arg0]).transfer(address(feeCollector), value12); // call uint256 value18 = 0x60; if ((returnData10.length) != 0x0) { if (returnData10.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData10.length))) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData10.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData10.length))) + 0x1f)); value18 = var_e; } if (!(success10)) { require(!var_r); revert FailedInnerCall(); } require(!(var_r == 0x0 && address(mapping_d[arg0]).code.length == 0x0), AddressEmptyCode()); uint256 value19 = this.code.length; uint256 value20 = this.code.length; bool flag9 = !(var_ad); if (!(!(var_ae))) { require(!(value18 + var_ae - value18 < 0x20)); require((!(!(var_ad))) == var_ad); } else { value19 = var_ae; value20 = value18; flag9 = !(!(var_ae)); } require(!(flag9), SafeERC20FailedOperation()); emit FeesCollected(mapping_d[arg0], value12, 0); } else { value21 = mapping_d[arg0]; } if (0x0 < arg1.length) { require(msg.data[((0x04 + arg1) + 0x20) + 0x40] < 0x04); if (!((msg.data[((0x04 + arg1) + 0x20) + 0x40] < 0x04))) _desolexPanic(33); } else { (bool success11, bytes memory returnData11) = address(0xb4123869ca90735bd2d9847b8a7dc60c36699dc3).getTotalAmount(0x20); // staticcall require(success11); uint256 value23 = this.code.length; uint256 value24 = var_e.length; if (success11) { uint256 value22 = returnData11.length; if (0x20 <= returnData11.length) { value22 = 0x20; } if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value22 + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value22 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value22 + 0x1f)); require(((var_e + value22) - var_e) >= 0x20); } else { value23 = var_e; value24 = 0; } stor_expr_f = value24; mapping_c[arg0] = mapping_c[arg0] + (((var_e.length - var_e.length) - value12) * mapping_f[mapping_d[arg0]] / 0x0de0b6b3a7640000); mapping_b[mapping_d[arg0]] = mapping_b[mapping_d[arg0]] + (((var_e.length - var_e.length) - value12) * mapping_f[mapping_d[arg0]] / 0x0de0b6b3a7640000); if (0 < arg1.length) { if (!((0 < arg1.length))) _desolexPanic(50); if (!(stor_expr_d < 0x010000000000000000)) _desolexPanic(65); stor_expr_d = stor_expr_d + 0x01; if (!(stor_expr_d < stor_expr_d)) _desolexPanic(50); if (0) _desolexPanic(0); stor_expr_q = msg.data[(0x60 * 0) + ((0x04 + arg1) + 0x20)]; stor_expr_r = msg.data[((0x60 * 0) + ((0x04 + arg1) + 0x20)) + 0x20]; require(msg.data[0x40 + ((0x60 * 0) + ((0x04 + arg1) + 0x20))] < 0x04); stor_expr_s = (bytes1(msg.data[0x40 + ((0x60 * 0) + ((0x04 + arg1) + 0x20))])) | (stor_expr_s & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); } else { if (0x0 < arg1.length) { require(msg.data[((0x04 + arg1) + 0x20) + 0x40] < 0x04); if (!((msg.data[((0x04 + arg1) + 0x20) + 0x40] < 0x04))) _desolexPanic(33); } else { emit VestingToppedUp(arg0, msg.sender, (var_e.length - var_e.length) - value12, 0x40, (arg1)); stor_8 = 0x01; return; } } } } else { uint256 value28 = this.code.length; if (value12 != 0x0) { if (((var_e + 0x80) < var_e) | ((var_e + 0x80) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + 0x80; (bool success12, bytes memory returnData12) = address(mapping_d[arg0]).transfer(address(feeCollector), value12); // call uint256 value25 = 0x60; if ((returnData12.length) != 0x0) { if (returnData12.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData12.length))) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData12.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData12.length))) + 0x1f)); value25 = var_e; } if (!(success12)) { require(!var_r); revert FailedInnerCall(); } require(!(var_r == 0x0 && address(mapping_d[arg0]).code.length == 0x0), AddressEmptyCode()); uint256 value26 = this.code.length; uint256 value27 = this.code.length; bool flag11 = !(var_ar); if (!(!(var_as))) { require(!(value25 + var_as - value25 < 0x20)); require((!(!(var_ar))) == var_ar); } else { value26 = var_as; value27 = value25; flag11 = !(!(var_as)); } require(!(flag11), SafeERC20FailedOperation()); emit FeesCollected(mapping_d[arg0], value12, 0); } else { value28 = mapping_d[arg0]; } if (0x0 < arg1.length) { require(msg.data[((0x04 + arg1) + 0x20) + 0x40] < 0x04); if (!((msg.data[((0x04 + arg1) + 0x20) + 0x40] < 0x04))) _desolexPanic(33); } else { (bool success13, bytes memory returnData13) = address(0xb4123869ca90735bd2d9847b8a7dc60c36699dc3).getTotalAmount(0x20); // staticcall require(success13); uint256 value30 = this.code.length; uint256 value31 = var_e.length; if (success13) { uint256 value29 = returnData13.length; if (0x20 <= returnData13.length) { value29 = 0x20; } if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value29 + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value29 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value29 + 0x1f)); require(((var_e + value29) - var_e) >= 0x20); } else { value30 = var_e; value31 = 0; } stor_expr_f = value31; mapping_c[arg0] = mapping_c[arg0] + (((0 - var_e.length) - value12) * mapping_f[mapping_d[arg0]] / 0x0de0b6b3a7640000); mapping_b[mapping_d[arg0]] = mapping_b[mapping_d[arg0]] + (((0 - var_e.length) - value12) * mapping_f[mapping_d[arg0]] / 0x0de0b6b3a7640000); if (0 < arg1.length) { if (!((0 < arg1.length))) _desolexPanic(50); if (!(stor_expr_d < 0x010000000000000000)) _desolexPanic(65); stor_expr_d = stor_expr_d + 0x01; if (!(stor_expr_d < stor_expr_d)) _desolexPanic(50); if (0) _desolexPanic(0); stor_expr_q = msg.data[(0x60 * 0) + ((0x04 + arg1) + 0x20)]; stor_expr_r = msg.data[((0x60 * 0) + ((0x04 + arg1) + 0x20)) + 0x20]; require(msg.data[0x40 + ((0x60 * 0) + ((0x04 + arg1) + 0x20))] < 0x04); stor_expr_s = (bytes1(msg.data[0x40 + ((0x60 * 0) + ((0x04 + arg1) + 0x20))])) | (stor_expr_s & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); } else { if (0x0 < arg1.length) { require(msg.data[((0x04 + arg1) + 0x20) + 0x40] < 0x04); if (!((msg.data[((0x04 + arg1) + 0x20) + 0x40] < 0x04))) _desolexPanic(33); } else { emit VestingToppedUp(arg0, msg.sender, (0 - var_e.length) - value12, 0x40, (arg1)); stor_8 = 0x01; return; } } } } } else { if (((var_e + 0xa0) < var_e) | ((var_e + 0xa0) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + 0xa0; (bool success14, bytes memory returnData14) = mapping_d[arg0].transferFrom(msg.sender, address(this), (var_e.length - stor_expr_f) + value12); // call uint256 value32 = 0x60; if ((returnData14.length) != 0x0) { if (returnData14.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData14.length))) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData14.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData14.length))) + 0x1f)); value32 = var_e; } if (!(success14)) { require(!var_r); revert FailedInnerCall(); } require(!(var_r == 0x0 && mapping_d[arg0].code.length == 0x0), AddressEmptyCode()); uint256 value33 = this.code.length; uint256 value34 = this.code.length; bool flag13 = !(var_aw); if (!(!(var_ax))) { require(!(value32 + var_ax - value32 < 0x20)); require((!(!(var_aw))) == var_aw); } else { value33 = var_ax; value34 = value32; flag13 = !(!(var_ax)); } require(!(flag13), SafeERC20FailedOperation()); (bool success15, bytes memory returnData15) = mapping_d[arg0].balanceOf(address(this)); // staticcall require(success15); if (success15) { uint256 value35 = returnData15.length; if (0x20 <= returnData15.length) { value35 = 0x20; } if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value35 + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value35 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value35 + 0x1f)); require(((var_e + value35) - var_e) >= 0x20); uint256 value39 = this.code.length; if (value12 != 0x0) { if (((var_e + 0x80) < var_e) | ((var_e + 0x80) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + 0x80; (bool success16, bytes memory returnData16) = address(mapping_d[arg0]).transfer(address(feeCollector), value12); // call uint256 value36 = 0x60; if ((returnData16.length) != 0x0) { if (returnData16.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData16.length))) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData16.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData16.length))) + 0x1f)); value36 = var_e; } if (!(success16)) { require(!var_r); revert FailedInnerCall(); } require(!(var_r == 0x0 && address(mapping_d[arg0]).code.length == 0x0), AddressEmptyCode()); uint256 value37 = this.code.length; uint256 value38 = this.code.length; bool flag15 = !(var_az); if (!(!(var_ba))) { require(!(value36 + var_ba - value36 < 0x20)); require((!(!(var_az))) == var_az); } else { value37 = var_ba; value38 = value36; flag15 = !(!(var_ba)); } require(!(flag15), SafeERC20FailedOperation()); emit FeesCollected(mapping_d[arg0], value12, 0); } else { value39 = mapping_d[arg0]; } if (0x0 < arg1.length) { require(msg.data[((0x04 + arg1) + 0x20) + 0x40] < 0x04); if (!((msg.data[((0x04 + arg1) + 0x20) + 0x40] < 0x04))) _desolexPanic(33); } else { (bool success17, bytes memory returnData17) = address(0xb4123869ca90735bd2d9847b8a7dc60c36699dc3).getTotalAmount(0x20); // staticcall require(success17); uint256 value41 = this.code.length; uint256 value42 = var_e.length; if (success17) { uint256 value40 = returnData17.length; if (0x20 <= returnData17.length) { value40 = 0x20; } if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value40 + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value40 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value40 + 0x1f)); require(((var_e + value40) - var_e) >= 0x20); } else { value41 = var_e; value42 = 0; } stor_expr_f = value42; mapping_c[arg0] = mapping_c[arg0] + (((var_e.length - 0) - value12) * mapping_f[mapping_d[arg0]] / 0x0de0b6b3a7640000); mapping_b[mapping_d[arg0]] = mapping_b[mapping_d[arg0]] + (((var_e.length - 0) - value12) * mapping_f[mapping_d[arg0]] / 0x0de0b6b3a7640000); if (0 < arg1.length) { if (!((0 < arg1.length))) _desolexPanic(50); if (!(stor_expr_d < 0x010000000000000000)) _desolexPanic(65); stor_expr_d = stor_expr_d + 0x01; if (!(stor_expr_d < stor_expr_d)) _desolexPanic(50); if (0) _desolexPanic(0); stor_expr_q = msg.data[(0x60 * 0) + ((0x04 + arg1) + 0x20)]; stor_expr_r = msg.data[((0x60 * 0) + ((0x04 + arg1) + 0x20)) + 0x20]; require(msg.data[0x40 + ((0x60 * 0) + ((0x04 + arg1) + 0x20))] < 0x04); stor_expr_s = (bytes1(msg.data[0x40 + ((0x60 * 0) + ((0x04 + arg1) + 0x20))])) | (stor_expr_s & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); } else { if (0x0 < arg1.length) { require(msg.data[((0x04 + arg1) + 0x20) + 0x40] < 0x04); if (!((msg.data[((0x04 + arg1) + 0x20) + 0x40] < 0x04))) _desolexPanic(33); } else { emit VestingToppedUp(arg0, msg.sender, (var_e.length - 0) - value12, 0x40, (arg1)); stor_8 = 0x01; return; } } } } else { uint256 value46 = this.code.length; if (value12 != 0x0) { if (((var_e + 0x80) < var_e) | ((var_e + 0x80) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + 0x80; (bool success18, bytes memory returnData18) = address(mapping_d[arg0]).transfer(address(feeCollector), value12); // call uint256 value43 = 0x60; if ((returnData18.length) != 0x0) { if (returnData18.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData18.length))) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData18.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData18.length))) + 0x1f)); value43 = var_e; } if (!(success18)) { require(!var_r); revert FailedInnerCall(); } require(!(var_r == 0x0 && address(mapping_d[arg0]).code.length == 0x0), AddressEmptyCode()); uint256 value44 = this.code.length; uint256 value45 = this.code.length; bool flag17 = !(var_bc); if (!(!(var_bd))) { require(!(value43 + var_bd - value43 < 0x20)); require((!(!(var_bc))) == var_bc); } else { value44 = var_bd; value45 = value43; flag17 = !(!(var_bd)); } require(!(flag17), SafeERC20FailedOperation()); emit FeesCollected(mapping_d[arg0], value12, 0); } else { value46 = mapping_d[arg0]; } if (0x0 < arg1.length) { require(msg.data[((0x04 + arg1) + 0x20) + 0x40] < 0x04); if (!((msg.data[((0x04 + arg1) + 0x20) + 0x40] < 0x04))) _desolexPanic(33); } else { (bool success19, bytes memory returnData19) = address(0xb4123869ca90735bd2d9847b8a7dc60c36699dc3).getTotalAmount(0x20); // staticcall require(success19); uint256 value48 = this.code.length; uint256 value49 = var_e.length; if (success19) { uint256 value47 = returnData19.length; if (0x20 <= returnData19.length) { value47 = 0x20; } if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value47 + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value47 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value47 + 0x1f)); require(((var_e + value47) - var_e) >= 0x20); } else { value48 = var_e; value49 = 0; } stor_expr_f = value49; mapping_c[arg0] = mapping_c[arg0] + ((0 - value12) * mapping_f[mapping_d[arg0]] / 0x0de0b6b3a7640000); mapping_b[mapping_d[arg0]] = mapping_b[mapping_d[arg0]] + ((0 - value12) * mapping_f[mapping_d[arg0]] / 0x0de0b6b3a7640000); if (0 < arg1.length) { if (!((0 < arg1.length))) _desolexPanic(50); if (!(stor_expr_d < 0x010000000000000000)) _desolexPanic(65); stor_expr_d = stor_expr_d + 0x01; if (!(stor_expr_d < stor_expr_d)) _desolexPanic(50); if (0) _desolexPanic(0); stor_expr_q = msg.data[(0x60 * 0) + ((0x04 + arg1) + 0x20)]; stor_expr_r = msg.data[((0x60 * 0) + ((0x04 + arg1) + 0x20)) + 0x20]; require(msg.data[0x40 + ((0x60 * 0) + ((0x04 + arg1) + 0x20))] < 0x04); stor_expr_s = (bytes1(msg.data[0x40 + ((0x60 * 0) + ((0x04 + arg1) + 0x20))])) | (stor_expr_s & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); } else { if (0x0 < arg1.length) { require(msg.data[((0x04 + arg1) + 0x20) + 0x40] < 0x04); if (!((msg.data[((0x04 + arg1) + 0x20) + 0x40] < 0x04))) _desolexPanic(33); } else { emit VestingToppedUp(arg0, msg.sender, 0 - value12, 0x40, (arg1)); stor_8 = 0x01; return; } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } } function transferOwnership(address newOwner) public onlyOwner { pendingOwner = newOwner; emit OwnershipTransferStarted(owner, pendingOwner); } function _getReleasableShares(uint256 index) public returns (uint256) { if (bytes1(stor_expr_c >> 0x10) != 0x0) { return mapping_c[index] - stor_expr_w; } else { uint256 value0 = 0; uint256 var_d; uint256 value1 = (var_d + 0x04) + 0x60; uint256 value2 = keccak256(abi.encode(keccak256(abi.encode(index, 0x0d)) + 0x06)); while (true) { if (value0 >= stor_expr_d) { break; } if (!((bytes1(array_2[value2]) < 0x04))) _desolexPanic(33); value0 = value0 + 0x01; value1 = value1 + 0x60; value2 = value2 + 0x03; (bool success0, bytes memory returnData0) = address(0xb4123869ca90735bd2d9847b8a7dc60c36699dc3).calculateVestedAmount(0x40, block.timestamp); // staticcall require(success0); uint256 value4 = this.code.length; uint256 value5 = var_d.length; if (success0) { uint256 value3 = returnData0.length; if (0x20 <= returnData0.length) { value3 = 0x20; } if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value3 + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value3 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value3 + 0x1f)); require(((var_d + value3) - var_d) >= 0x20); } else { value4 = var_d; value5 = 0; } uint256 value6 = stor_expr_f; if (value5 <= stor_expr_f) { value6 = value5; } uint256 value7 = (mapping_c[index] * value6) / stor_expr_f; if (stor_expr_f != 0x0) { } else { value7 = 0; } uint256 value8 = 0x04; uint256 value9 = mapping_c[index]; if (value7 > mapping_c[index]) { } else { value8 = index; value9 = value7; } if (!(value9 > stor_expr_aa)) { return 0; } else { return value9 - stor_expr_aa; } } } } function getVestedAmount(uint256 arg0) public returns (uint256) { if (!(bytes1(stor_expr_c >> 0x10))) { uint256 value0 = 0; uint256 var_d; uint256 value1 = (var_d + 0x04) + 0x60; uint256 value2 = keccak256(abi.encode(keccak256(abi.encode(arg0, 0x0d)) + 0x06)); while (true) { if (value0 >= stor_expr_ac) { break; } if (!(bytes1(array_2[value2]) < 0x04)) _desolexPanic(33); value0 = value0 + 0x01; value1 = value1 + 0x60; value2 = value2 + 0x03; (bool success0, bytes memory returnData0) = address(0xb4123869ca90735bd2d9847b8a7dc60c36699dc3).calculateVestedAmount(0x40, block.timestamp); // staticcall require(success0); if (!(success0)) { return 0; } uint256 value3 = returnData0.length; if (0x20 <= returnData0.length) { value3 = 0x20; } if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value3 + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value3 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value3 + 0x1f)); require(((var_d + value3) - var_d) >= 0x20); return var_d.length; } } return stor_expr_ad; } function tokenURI(uint256 tokenId) public returns (bytes memory) { require(address(array_2[tokenId]), ERC721NonexistentToken()); require(address(array_2[tokenId]), TokenDoesNotExist()); (bool success0, bytes memory returnData0) = mapping_d[tokenId].symbol(); // staticcall uint256 value1 = msg.data[0] >> 0xe0; uint256 value2 = msg.data[0] >> 0xe0; uint256 var_d; uint256 value3 = var_d; if (success0) { if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData0.length + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData0.length + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData0.length + 0x1f)); require(((var_d + returnData0.length) - var_d) >= 0x20); require(var_d.length <= 0xffffffffffffffff); require(((var_d + var_d.length) + 0x1f) < (var_d + returnData0.length)); if (!(var_e <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f)); require(((var_d + var_d.length) + var_f + 0x20) <= (var_d + returnData0.length)); uint256 value0 = 0; while (true) { if (value0 >= var_e) { break; } value0 = 0x20 + value0; } } else { value1 = 0; value2 = var_d; value3 = 0; } if (!(success0)) { if (((var_d + 0x40) < var_d) | ((var_d + 0x40) > 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + 0x40; (bool success1, bytes memory returnData1) = mapping_d[tokenId].name(); // staticcall uint256 value4 = msg.data[0] >> 0xe0; uint256 value5 = var_d; if (success1) { if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData1.length + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData1.length + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData1.length + 0x1f)); require(((var_d + returnData1.length) - var_d) >= 0x20); require(var_d.length <= 0xffffffffffffffff); require(((var_d + var_d.length) + 0x1f) < (var_d + returnData1.length)); if (!(var_e <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f)); require(((var_d + var_d.length) + var_f + 0x20) <= (var_d + returnData1.length)); uint256 value0 = 0; while (true) { if (value0 >= var_e) { break; } value0 = 0x20 + value0; } } else { value4 = var_d; value5 = 0; } uint256 value7 = value5; if (!(success1)) { value7 = var_d; } (bool success2, bytes memory returnData2) = mapping_d[tokenId].decimals(); // staticcall uint256 value8 = msg.data[0] >> 0xe0; uint256 value9 = var_d.length; if (success2) { uint256 value6 = returnData2.length; if (0x20 <= returnData2.length) { value6 = 0x20; } if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value6 + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value6 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value6 + 0x1f)); require(((var_d + value6) - var_d) >= 0x20); require(var_d.length == (bytes1(var_d.length))); } else { value8 = var_d; value9 = 0; } uint256 value10 = value9; if (!(success2)) { value10 = 0x12; } uint256 value11 = block.timestamp; if (stor_expr_d) { value11 = stor_expr_af; } uint256 value12 = block.timestamp; if (!(!(stor_expr_d))) { if (!((stor_expr_d + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < stor_expr_d)) _desolexPanic(50); value12 = stor_expr_e; } if (bytes1(stor_expr_c >> 0x10) != 0x0) { uint256 value0 = 0; while (true) { if (value0 >= var_d.length) { break; } value0 = 0x20 + value0; uint256 value0 = 0; while (true) { if (value0 >= var_v) { break; } value0 = 0x20 + value0; (bool success3, bytes memory returnData3) = address(svgGenerator & (0xffffffffffffffffffffffffffffffffffffffff)).generateTokenURI(tokenId, 0x0160, 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_d.length) + (var_d + 0x0164) + 0x20) - var_d), stor_expr_f, stor_expr_ad, value11, value12, !(!(stor_expr_c & (0xff))), !(!(0xff & (stor_expr_c >> 0x18))), stor_expr_ag & (0xffffffffffffffffffffffffffffffffffffffff), (0xff) & value10); // staticcall require(success3); uint256 value13 = msg.data[0] >> 0xe0; uint256 value14 = var_d; if (success3) { if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData3.length + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData3.length + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData3.length + 0x1f)); require(((var_d + returnData3.length) - var_d) >= 0x20); require(var_d.length <= 0xffffffffffffffff); require(((var_d + var_d.length) + 0x1f) < (var_d + returnData3.length)); if (!(var_e <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f)); require(((var_d + var_d.length) + var_f + 0x20) <= (var_d + returnData3.length)); uint256 value0 = 0; while (true) { if (value0 >= var_e) { break; } value0 = 0x20 + value0; } } else { value13 = var_d; value14 = 0; } uint256 value0 = 0; while (true) { if (value0 >= var_aj) { break; } value0 = 0x20 + value0; return abi.encodePacked(0x20, var_aj); } } } } else { uint256 value15 = 0; uint256 value16 = (var_d + 0x04) + 0x60; uint256 value17 = keccak256(abi.encode(keccak256(abi.encode(tokenId, 0x0d)) + 0x06)); while (true) { if (value15 >= stor_expr_d) { break; } if (!((bytes1(array_2[value17]) < 0x04))) _desolexPanic(33); value15 = value15 + 0x01; value16 = value16 + 0x60; value17 = value17 + 0x03; (bool success4, bytes memory returnData4) = address(0xb4123869ca90735bd2d9847b8a7dc60c36699dc3).calculateVestedAmount(0x40, block.timestamp); // staticcall require(success4); if (success4) { uint256 value18 = returnData4.length; if (0x20 <= returnData4.length) { value18 = 0x20; } if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value18 + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value18 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value18 + 0x1f)); require(((var_d + value18) - var_d) >= 0x20); uint256 value0 = 0; while (true) { if (value0 >= var_d.length) { break; } value0 = 0x20 + value0; uint256 value0 = 0; while (true) { if (value0 >= var_v) { break; } value0 = 0x20 + value0; (bool success5, bytes memory returnData5) = address(svgGenerator & (0xffffffffffffffffffffffffffffffffffffffff)).generateTokenURI(tokenId, 0x0160, 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_d.length) + (var_d + 0x0164) + 0x20) - var_d), stor_expr_f, var_d.length, value11, value12, !(!(stor_expr_c & (0xff))), !(!(0xff & (stor_expr_c >> 0x18))), stor_expr_ag & (0xffffffffffffffffffffffffffffffffffffffff), (0xff) & value10); // staticcall require(success5); uint256 value19 = msg.data[0] >> 0xe0; uint256 value20 = var_d; if (success5) { if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData5.length + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData5.length + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData5.length + 0x1f)); require(((var_d + returnData5.length) - var_d) >= 0x20); require(var_d.length <= 0xffffffffffffffff); require(((var_d + var_d.length) + 0x1f) < (var_d + returnData5.length)); if (!(var_e <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f)); require(((var_d + var_d.length) + var_f + 0x20) <= (var_d + returnData5.length)); uint256 value0 = 0; while (true) { if (value0 >= var_e) { break; } value0 = 0x20 + value0; } } else { value19 = var_d; value20 = 0; } uint256 value0 = 0; while (true) { if (value0 >= var_aj) { break; } value0 = 0x20 + value0; return abi.encodePacked(0x20, var_ao); } } } } else { uint256 value0 = 0; while (true) { if (value0 >= var_d.length) { break; } value0 = 0x20 + value0; uint256 value0 = 0; while (true) { if (value0 >= var_v) { break; } value0 = 0x20 + value0; (bool success6, bytes memory returnData6) = address(svgGenerator & (0xffffffffffffffffffffffffffffffffffffffff)).generateTokenURI(tokenId, 0x0160, 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_d.length) + (var_d + 0x0164) + 0x20) - var_d), stor_expr_f, 0, value11, value12, !(!(stor_expr_c & (0xff))), !(!(0xff & (stor_expr_c >> 0x18))), stor_expr_ag & (0xffffffffffffffffffffffffffffffffffffffff), (0xff) & value10); // staticcall require(success6); uint256 value21 = msg.data[0] >> 0xe0; uint256 value22 = var_d; if (success6) { if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData6.length + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData6.length + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData6.length + 0x1f)); require(((var_d + returnData6.length) - var_d) >= 0x20); require(var_d.length <= 0xffffffffffffffff); require(((var_d + var_d.length) + 0x1f) < (var_d + returnData6.length)); if (!(var_e <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f)); require(((var_d + var_d.length) + var_f + 0x20) <= (var_d + returnData6.length)); uint256 value0 = 0; while (true) { if (value0 >= var_e) { break; } value0 = 0x20 + value0; } } else { value21 = var_d; value22 = 0; } uint256 value0 = 0; while (true) { if (value0 >= var_aj) { break; } value0 = 0x20 + value0; return abi.encodePacked(0x20, var_as); } } } } } } } (bool success7, bytes memory returnData7) = mapping_d[tokenId].name(); // staticcall uint256 value23 = msg.data[0] >> 0xe0; uint256 value24 = var_d; if (success7) { if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData7.length + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData7.length + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData7.length + 0x1f)); require(((var_d + returnData7.length) - var_d) >= 0x20); require(var_d.length <= 0xffffffffffffffff); require(((var_d + var_d.length) + 0x1f) < (var_d + returnData7.length)); if (!(var_e <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f)); require(((var_d + var_d.length) + var_f + 0x20) <= (var_d + returnData7.length)); uint256 value0 = 0; while (true) { if (value0 >= var_e) { break; } value0 = 0x20 + value0; } } else { value23 = var_d; value24 = 0; } uint256 value26 = value24; if (!(success7)) { value26 = value3; } (bool success8, bytes memory returnData8) = mapping_d[tokenId].decimals(); // staticcall uint256 value27 = msg.data[0] >> 0xe0; uint256 value28 = var_d.length; if (success8) { uint256 value25 = returnData8.length; if (0x20 <= returnData8.length) { value25 = 0x20; } if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value25 + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value25 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value25 + 0x1f)); require(((var_d + value25) - var_d) >= 0x20); require(var_d.length == (bytes1(var_d.length))); } else { value27 = var_d; value28 = 0; } uint256 value29 = value28; if (!(success8)) { value29 = 0x12; } uint256 value30 = block.timestamp; if (stor_expr_d) { value30 = stor_expr_af; } uint256 value31 = block.timestamp; if (!(!(stor_expr_d))) { if (!((stor_expr_d + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) < stor_expr_d)) _desolexPanic(50); value31 = stor_expr_e; } if (bytes1(stor_expr_c >> 0x10) != 0x0) { uint256 value0 = 0; while (true) { if (value0 >= var_d.length) { break; } value0 = 0x20 + value0; uint256 value0 = 0; while (true) { if (value0 >= var_v) { break; } value0 = 0x20 + value0; (bool success9, bytes memory returnData9) = address(svgGenerator & (0xffffffffffffffffffffffffffffffffffffffff)).generateTokenURI(tokenId, 0x0160, 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_aw) + (var_d + 0x0164) + 0x20) - var_d), stor_expr_f, stor_expr_ad, value30, value31, !(!(stor_expr_c & (0xff))), !(!(0xff & (stor_expr_c >> 0x18))), stor_expr_ag & (0xffffffffffffffffffffffffffffffffffffffff), (0xff) & value29); // staticcall require(success9); uint256 value32 = msg.data[0] >> 0xe0; uint256 value33 = var_d; if (success9) { if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData9.length + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData9.length + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData9.length + 0x1f)); require(((var_d + returnData9.length) - var_d) >= 0x20); require(var_d.length <= 0xffffffffffffffff); require(((var_d + var_d.length) + 0x1f) < (var_d + returnData9.length)); if (!(var_e <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f)); require(((var_d + var_d.length) + var_f + 0x20) <= (var_d + returnData9.length)); uint256 value0 = 0; while (true) { if (value0 >= var_e) { break; } value0 = 0x20 + value0; } } else { value32 = var_d; value33 = 0; } uint256 value0 = 0; while (true) { if (value0 >= var_aj) { break; } value0 = 0x20 + value0; return abi.encodePacked(0x20, var_ba); } } } } else { uint256 value15 = 0; uint256 value16 = (var_d + 0x04) + 0x60; uint256 value17 = keccak256(abi.encode(keccak256(abi.encode(tokenId, 0x0d)) + 0x06)); while (true) { if (value15 >= stor_expr_d) { break; } if (!((bytes1(array_2[value17]) < 0x04))) _desolexPanic(33); value15 = value15 + 0x01; value16 = value16 + 0x60; value17 = value17 + 0x03; (bool success10, bytes memory returnData10) = address(0xb4123869ca90735bd2d9847b8a7dc60c36699dc3).calculateVestedAmount(0x40, block.timestamp); // staticcall require(success10); if (success10) { uint256 value34 = returnData10.length; if (0x20 <= returnData10.length) { value34 = 0x20; } if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value34 + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value34 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value34 + 0x1f)); require(((var_d + value34) - var_d) >= 0x20); uint256 value0 = 0; while (true) { if (value0 >= var_d.length) { break; } value0 = 0x20 + value0; uint256 value0 = 0; while (true) { if (value0 >= var_v) { break; } value0 = 0x20 + value0; (bool success11, bytes memory returnData11) = address(svgGenerator & (0xffffffffffffffffffffffffffffffffffffffff)).generateTokenURI(tokenId, 0x0160, 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_aw) + (var_d + 0x0164) + 0x20) - var_d), stor_expr_f, var_d.length, value30, value31, !(!(stor_expr_c & (0xff))), !(!(0xff & (stor_expr_c >> 0x18))), stor_expr_ag & (0xffffffffffffffffffffffffffffffffffffffff), (0xff) & value29); // staticcall require(success11); uint256 value35 = msg.data[0] >> 0xe0; uint256 value36 = var_d; if (success11) { if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData11.length + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData11.length + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData11.length + 0x1f)); require(((var_d + returnData11.length) - var_d) >= 0x20); require(var_d.length <= 0xffffffffffffffff); require(((var_d + var_d.length) + 0x1f) < (var_d + returnData11.length)); if (!(var_e <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f)); require(((var_d + var_d.length) + var_f + 0x20) <= (var_d + returnData11.length)); uint256 value0 = 0; while (true) { if (value0 >= var_e) { break; } value0 = 0x20 + value0; } } else { value35 = var_d; value36 = 0; } uint256 value0 = 0; while (true) { if (value0 >= var_aj) { break; } value0 = 0x20 + value0; return abi.encodePacked(0x20, var_bc); } } } } else { uint256 value0 = 0; while (true) { if (value0 >= var_d.length) { break; } value0 = 0x20 + value0; uint256 value0 = 0; while (true) { if (value0 >= var_v) { break; } value0 = 0x20 + value0; (bool success12, bytes memory returnData12) = address(svgGenerator & (0xffffffffffffffffffffffffffffffffffffffff)).generateTokenURI(tokenId, 0x0160, 0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + ((0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_aw) + (var_d + 0x0164) + 0x20) - var_d), stor_expr_f, 0, value30, value31, !(!(stor_expr_c & (0xff))), !(!(0xff & (stor_expr_c >> 0x18))), stor_expr_ag & (0xffffffffffffffffffffffffffffffffffffffff), (0xff) & value29); // staticcall require(success12); uint256 value37 = msg.data[0] >> 0xe0; uint256 value38 = var_d; if (success12) { if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData12.length + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData12.length + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (returnData12.length + 0x1f)); require(((var_d + returnData12.length) - var_d) >= 0x20); require(var_d.length <= 0xffffffffffffffff); require(((var_d + var_d.length) + 0x1f) < (var_d + returnData12.length)); if (!(var_e <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + var_f))) + 0x1f)); require(((var_d + var_d.length) + var_f + 0x20) <= (var_d + returnData12.length)); uint256 value0 = 0; while (true) { if (value0 >= var_e) { break; } value0 = 0x20 + value0; } } else { value37 = var_d; value38 = 0; } uint256 value0 = 0; while (true) { if (value0 >= var_aj) { break; } value0 = 0x20 + value0; return abi.encodePacked(0x20, var_be); } } } } } } } function mintVestingNFT(uint256 arg0) public { require(msg.sender == stor_expr_ai, NotAuthorized()); require(!stor_expr_aj_1_1, NFTAlreadyMinted()); stor_expr_aj_1_1 = true; require(address(stor_expr_ai), ERC721InvalidReceiver()); uint256 value3 = 0; flag0 = 0x0 != 0x0; if (address(array_2[arg0]) != 0x0) { getApproved[arg0] = address(0); balanceOf[address(array_2[arg0])] = balanceOf[address(array_2[arg0])] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if ((0xffffffffffffffffffffffffffffffffffffffff & stor_expr_ai) != 0x0) { balanceOf[address(stor_expr_ai)] = balanceOf[address(stor_expr_ai)] + 0x01; } array_2[arg0] = (address(stor_expr_ai)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & array_2[arg0]); emit Transfer(address(array_2[arg0]), address(stor_expr_ai), arg0); if ((address(array_2[arg0]) & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { require(mapping_e[arg0], NonTransferableToken()); stor_expr_ar = (stor_expr_ai & (0xffffffffffffffffffffffffffffffffffffffff)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_ar); } require((!(address(array_2[arg0]))), ERC721InvalidSender()); } else { if ((0xffffffffffffffffffffffffffffffffffffffff & stor_expr_ai) != 0x0) { balanceOf[address(stor_expr_ai)] = balanceOf[address(stor_expr_ai)] + 0x01; array_2[arg0] = address(stor_expr_ai) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & array_2[arg0]); emit Transfer(address(array_2[arg0]), address(stor_expr_ai), arg0); if ((address(array_2[arg0]) & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { require(mapping_e[arg0], NonTransferableToken()); stor_expr_av = (stor_expr_ai & (0xffffffffffffffffffffffffffffffffffffffff)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_av); } require((!(address(array_2[arg0]))), ERC721InvalidSender()); } else { array_2[arg0] = (address(stor_expr_ai)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & array_2[arg0]); emit Transfer(address(array_2[arg0]), address(stor_expr_ai), arg0); } } if ((0xffffffffffffffffffffffffffffffffffffffff & mapping_2[arg0] & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { require(mapping_e[arg0], NonTransferableToken()); stor_expr_ay = (stor_expr_ai & (0xffffffffffffffffffffffffffffffffffffffff)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_ay); } require((!(address(array_2[arg0]))), ERC721InvalidSender()); } function getVestingSchedule(uint256 arg0) public view returns (bool) { uint256 var_a; if (((var_a + 0x0160) > 0xffffffffffffffff) | ((var_a + 0x0160) < var_a)) _desolexPanic(65); var_a = var_a + 0x0160; if (((var_a + 0x0160) > 0xffffffffffffffff) | ((var_a + 0x0160) < var_a)) _desolexPanic(65); var_a = var_a + 0x0160; if (!(bytes1(stor_expr_c >> 0x20) < 0x01)) _desolexPanic(33); if (!(stor_expr_d <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (stor_expr_d << 0x05)) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (stor_expr_d << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); uint256 value1 = var_a + 0x20; uint256 value0 = 0; uint256 value2 = keccak256(abi.encode(keccak256(abi.encode(arg0, 0x0d)) + 0x06)); while (true) { var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (stor_expr_d << 0x05)) + 0x1f)); if (value0 >= stor_expr_d) { break; } if (((var_a + 0x60) > 0xffffffffffffffff) | ((var_a + 0x60) < var_a)) { _desolexPanic(65); break; } var_a = var_a + 0x60; if (!(bytes1(array_2[value2]) < 0x04)) { _desolexPanic(33); break; } value1 = value1 + 0x20; value0 = value0 + 0x01; value2 = value2 + 0x03; } if (!(var_at < 0x01)) _desolexPanic(33); uint256 value3 = 0; uint256 value4 = var_au + 0x20; uint256 value5 = var_a + 0x01a0; while (true) { if (value3 >= var_ay) { return abi.encodePacked(0x20, address(var_a.length), address(var_az), address(var_ba), var_bb, var_bc, !(!(var_bd)), !(!(var_be)), !(!(var_bf)), !(!(var_bg)), var_bh, 0x0160, var_bi); } if (!(var_bn < 0x04)) { _desolexPanic(33); break; } value3 = value3 + 0x01; value4 = value4 + 0x20; value5 = value5 + 0x60; } } function safeTransferFrom(address _from, address to, uint256 tokenId, bytes memory _data) public { require((_data + 0x23) < msg.data.length); if (_data.length > 0xffffffffffffffff) _desolexPanic(65); uint256 var_a; if (((var_a + (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(((_data + _data) + 0x24) <= msg.data.length); require(to != address(0), ERC721InvalidReceiver()); bool value2 = msg.sender; if (msg.sender != address(0)) { uint256 value1; uint256 value0 = bytes1(isApprovedForAll[address(array_2[tokenId])][msg.sender]); if (!(address(array_2[tokenId]) == (msg.sender))) { } else { value0 = ((address(array_2[tokenId])) == (msg.sender)) ? 1 : 0; } uint256 value6 = value0; if (value0 == 0) { value6 = ((msg.sender) == getApproved[tokenId]) ? 1 : 0; } value1 = value6; if (value1 == 0x0) { require(address(array_2[tokenId]) != address(0), ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } } else { value2 = !(!(msg.sender)); } if (address(array_2[tokenId]) != address(0)) { getApproved[tokenId] = address(0); balanceOf[address(array_2[tokenId])] = balanceOf[address(array_2[tokenId])] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if (to != address(0)) { balanceOf[to] = balanceOf[to] + 0x01; } array_2[tokenId] = to | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & array_2[tokenId]); emit Transfer(address(array_2[tokenId]), to, tokenId); } else { if (to != address(0)) { balanceOf[to] = balanceOf[to] + 0x01; } array_2[tokenId] = to | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & array_2[tokenId]); emit Transfer(address(array_2[tokenId]), to, tokenId); } bool flag0 = true; if (!(address(array_2[tokenId]))) { flag0 = !(!(address(array_2[tokenId]))); } if (flag0) { require(mapping_e[tokenId], NonTransferableToken()); stor_expr_bj = to; } require(address(array_2[tokenId]) == _from, ERC721IncorrectOwner()); if (to.code.length != 0x0) { uint256 value3 = 0; while (true) { if (!(value3 < var_n)) { break; } value3 = 0x20 + value3; (bool success0, bytes memory returnData0) = to.onERC721Received(msg.sender, _from, tokenId, 0x80); // call if (success0) { uint256 value4 = returnData0.length; if (0x20 <= returnData0.length) { value4 = 0x20; } if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value4 + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value4 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value4 + 0x1f)); } else { if (!(success0)) { uint256 value5 = 0x60; if ((returnData0.length) != 0x0) { if (returnData0.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f)); value5 = var_a; } require(var_q != 0x0, ERC721InvalidReceiver()); revert(); } require(!(0xeaf485fe00000000000000000000000000000000000000000000000000000000), ERC721InvalidReceiver()); } } } } function setTokenFeeExempt(address account, bool enabled) public onlyOwner { feeExemptTokens[account] = enabled; emit TokenFeeExemptionUpdated(account, feeExemptTokens[account]); } function setSVGGenerator(address newAddress) public onlyOwner { require(newAddress != address(0), InvalidSVGGenerator()); emit SVGGeneratorUpdated(svgGenerator, newAddress); svgGenerator = newAddress; } function setFeePercentage(uint256 newFeePercentage) public onlyOwner { require(newFeePercentage <= 0x01f4, InvalidFeePercentage()); feePercentage = newFeePercentage; emit FeePercentageUpdated(feePercentage); } function setFeeCollector(address newAddress) public onlyOwner { require(newAddress != address(0), InvalidFeeCollector()); emit FeeCollectorUpdated(feeCollector, newAddress); feeCollector = newAddress; } 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 symbol() public view returns (string memory) { return _symbol; } function createDailySoftVesting(address token, (uint256,uint256,uint8)[] memory arg1, address arg2) public payable returns (uint256) { if ((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) >= 0x60) { if (token == token) { if (!(arg1.length > 0xffffffffffffffff)) { if (((0x04 + arg1) + 0x1f) < msg.data.length) { if (!(arg1.length > 0xffffffffffffffff)) { if (!(((arg1.length * 0x60) + (0x04 + arg1) + 0x20) > msg.data.length)) { if (arg2 == arg2) { if (stor_8 != 0x02) { stor_8 = 0x02; if (token != address(0)) { require(arg2 != address(0), InvalidBeneficiary()); if (mapping_b[token] != 0) { (bool success0, bytes memory returnData0) = token.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf if (success0) { uint256 value1 = this.code.length; uint256 var_e; uint256 value2 = var_e.length; if (success0) { uint256 value0 = returnData0.length; if (0x20 <= returnData0.length) { value0 = 0x20; } if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value0 + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value0 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value0 + 0x1f)); require(((var_e + value0) - var_e) >= 0x20); } else { value1 = var_e; value2 = 0; } if (value2 == 0x0) { uint256 value3 = 0; uint256 value4 = (0x04 + arg1) + 0x20; uint256 value5 = (var_e + 0x24) + 0x20; while (true) { mapping_f[token] = 0x0de0b6b3a7640000; if (!(value3 < arg1.length)) { break; } if (!(msg.data[value4 + 0x40] < 0x04)) { revert(); break; } if (!((msg.data[value4 + 0x40] < 0x04))) _desolexPanic(33); value3 = value3 + 0x01; value4 = value4 + 0x60; value5 = value5 + 0x60; } (bool success1, bytes memory returnData1) = address(0xb4123869ca90735bd2d9847b8a7dc60c36699dc3).getTotalAmount(0x20); // staticcall require(success1); uint256 value7 = msg.data[0] >> 0xe0; uint256 value8 = var_e.length; if (success1) { uint256 value6 = returnData1.length; if (0x20 <= returnData1.length) { value6 = 0x20; } if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value6 + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value6 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value6 + 0x1f)); require(((var_e + value6) - var_e) >= 0x20); } else { value7 = var_e; value8 = 0; } require(value8 != 0x0, InvalidAmount()); bool flag0 = !(feeExemptCreators[msg.sender]); if (!feeExemptTokens[token]) { } else { flag0 = !(feeExemptTokens[token]); } bool flag1 = !(feeExemptTokens[token]); if (flatFee != 0) { } else { flag1 = flatFee; } bool flag3 = !(feeExemptCreators[msg.sender]); if (flag1) { } else { flag3 = flag1; } uint256 value9 = (value8 * feePercentage) / 0x2710; if ((flag0) && (feePercentage != 0x0)) { } else { value9 = 0; } uint256 value10 = msg.data[0] >> 0xe0; uint256 value11 = flatFee; if (!(flag3)) { value10 = flatFee; value11 = 0; } if (((var_e + 0xa0) < var_e) | ((var_e + 0xa0) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + 0xa0; (bool success2, bytes memory returnData2) = token.call(abi.encodeWithSelector(bytes4(0x23b872dd), msg.sender, address(this), value8)); // call transferFrom uint256 value12 = 0x60; if ((returnData2.length) != 0x0) { if (!(returnData2.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData2.length))) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData2.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData2.length))) + 0x1f)); value12 = var_e; } if (!(success2)) { require(!var_o); revert FailedInnerCall(); } require(!(var_o == 0x0 && token.code.length == 0x0), AddressEmptyCode()); uint256 value13 = this.code.length; uint256 value14 = this.code.length; bool flag5 = !(var_p); if (!(!(var_q))) { require(!(value12 + var_q - value12 < 0x20)); require((!(!(var_p))) == var_p); } else { value13 = var_q; value14 = value12; flag5 = !(!(var_q)); } require(!(flag5), SafeERC20FailedOperation()); if (value9 != 0x0) { if (((var_e + 0x80) < var_e) | ((var_e + 0x80) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + 0x80; (bool success3, bytes memory returnData3) = token.call(abi.encodeWithSelector(bytes4(0xa9059cbb), address(feeCollector), value9)); // call transfer uint256 value15 = 0x60; if ((returnData3.length) != 0x0) { if (!(returnData3.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData3.length))) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData3.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData3.length))) + 0x1f)); value15 = var_e; } if (!(success3)) { require(!var_o); revert FailedInnerCall(); } require(!(var_o == 0x0 && address(token).code.length == 0x0), AddressEmptyCode()); uint256 value16 = this.code.length; uint256 value17 = this.code.length; bool flag7 = !(var_v); if (!(!(var_w))) { require(!(value15 + var_w - value15 < 0x20)); require((!(!(var_v))) == var_v); } else { value16 = var_w; value17 = value15; flag7 = !(!(var_w)); } require(!(flag7), SafeERC20FailedOperation()); emit FeesCollected(token, value9, 0); } if (value11 != 0x0) { require(msg.value >= value11, InvalidFlatFee()); (bool success4, bytes memory returnData4) = feeCollector.call{ value: value11 }(""); // call if (returnData4.length == 0) { require(success4, FeeTransferFailed()); emit FeesCollected(token, 0, value11); nextVestingId = 0x01 + nextVestingId; mapping_d[nextVestingId] = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & mapping_d[nextVestingId]) | token; stor_expr_bt = msg.sender; stor_expr_bu = (stor_expr_bu & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | arg2; stor_expr_bv = value8 - value9; stor_expr_bw = (bytes1(0x01)) | (stor_expr_bw & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); stor_expr_bw = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff & stor_expr_bw) | ((0 << 0x08) & (0xff00)); stor_expr_bx = 0; if (!(0 < 0x01)) _desolexPanic(33); stor_expr_bw = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff000000ffff & stor_expr_bw | ((0x01 << 0x18) & (0xff000000))) | 0; uint256 value18 = 0; while (true) { if (!(value18 < arg1.length)) { break; } if (!((value18 < arg1.length))) _desolexPanic(50); if (!(stor_expr_by < 0x010000000000000000)) _desolexPanic(65); stor_expr_by = stor_expr_by + 0x01; if (!((stor_expr_by < stor_expr_bz))) _desolexPanic(50); if (0) _desolexPanic(0); stor_expr_ca = msg.data[(0x60 * value18) + ((0x04 + arg1) + 0x20)]; stor_expr_cb = msg.data[((0x60 * value18) + ((0x04 + arg1) + 0x20)) + 0x20]; require(msg.data[0x40 + ((0x60 * value18) + ((0x04 + arg1) + 0x20))] < 0x04); stor_expr_cc = (bytes1(msg.data[0x40 + ((0x60 * value18) + ((0x04 + arg1) + 0x20))])) | (stor_expr_cc & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); value18 = value18 + 0x01; mapping_c[nextVestingId] = ((value8 - value9) * mapping_f[token]) / 0x0de0b6b3a7640000; mapping_b[token] = mapping_b[token] + ((value8 - value9) * mapping_f[token] / 0x0de0b6b3a7640000); uint256 value3 = 0; uint256 value4 = (0x04 + arg1) + 0x20; uint256 value5 = (var_e + 0xa0) + 0x20; while (true) { mapping_e[nextVestingId] = false; if (!(value3 < arg1.length)) { break; } if (!(msg.data[value4 + 0x40] < 0x04)) { revert(); break; } if (!(((msg.data[value4 + 0x40]) < 0x04))) _desolexPanic(33); value3 = value3 + 0x01; value4 = value4 + 0x60; value5 = value5 + 0x60; } emit VestingCreated(nextVestingId, arg2, token, 0xa0, 0x01, 0x01, 0, (arg1)); stor_8 = 0x01; return nextVestingId; } } else { if (!(returnData4.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData4.length))) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData4.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData4.length))) + 0x1f)); require(success4, FeeTransferFailed()); emit FeesCollected(token, 0, value11); nextVestingId = 0x01 + nextVestingId; mapping_d[nextVestingId] = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & mapping_d[nextVestingId]) | token; stor_expr_bt = msg.sender; stor_expr_bu = (stor_expr_bu & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | arg2; stor_expr_bv = value8 - value9; stor_expr_bw = (bytes1(0x01)) | (stor_expr_bw & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); stor_expr_bw = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff & stor_expr_bw) | ((0 << 0x08) & (0xff00)); stor_expr_bx = 0; if (!(0 < 0x01)) _desolexPanic(33); stor_expr_bw = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff000000ffff & stor_expr_bw | ((0x01 << 0x18) & (0xff000000))) | 0; uint256 value18 = 0; while (true) { if (!(value18 < arg1.length)) { break; } if (!((value18 < arg1.length))) _desolexPanic(50); if (!(stor_expr_by < 0x010000000000000000)) _desolexPanic(65); stor_expr_by = stor_expr_by + 0x01; if (!((stor_expr_by < stor_expr_bz))) _desolexPanic(50); if (0) _desolexPanic(0); stor_expr_ca = msg.data[(0x60 * value18) + ((0x04 + arg1) + 0x20)]; stor_expr_cb = msg.data[((0x60 * value18) + ((0x04 + arg1) + 0x20)) + 0x20]; require(msg.data[0x40 + ((0x60 * value18) + ((0x04 + arg1) + 0x20))] < 0x04); stor_expr_cc = (bytes1(msg.data[0x40 + ((0x60 * value18) + ((0x04 + arg1) + 0x20))])) | (stor_expr_cc & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); value18 = value18 + 0x01; mapping_c[nextVestingId] = ((value8 - value9) * mapping_f[token]) / 0x0de0b6b3a7640000; mapping_b[token] = mapping_b[token] + ((value8 - value9) * mapping_f[token] / 0x0de0b6b3a7640000); uint256 value3 = 0; uint256 value4 = (0x04 + arg1) + 0x20; uint256 value5 = (var_e + 0xa0) + 0x20; while (true) { mapping_e[nextVestingId] = false; if (!(value3 < arg1.length)) { break; } if (!(msg.data[value4 + 0x40] < 0x04)) { revert(); break; } if (!(((msg.data[value4 + 0x40]) < 0x04))) _desolexPanic(33); value3 = value3 + 0x01; value4 = value4 + 0x60; value5 = value5 + 0x60; } emit VestingCreated(nextVestingId, arg2, token, 0xa0, 0x01, 0x01, 0, (arg1)); stor_8 = 0x01; return nextVestingId; } } } else { nextVestingId = 0x01 + nextVestingId; mapping_d[nextVestingId] = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & mapping_d[nextVestingId]) | token; stor_expr_bt = msg.sender; stor_expr_bu = (stor_expr_bu & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | arg2; stor_expr_bv = value8 - value9; stor_expr_bw = (bytes1(0x01)) | (stor_expr_bw & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); stor_expr_bw = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff & stor_expr_bw) | ((0 << 0x08) & (0xff00)); stor_expr_bx = 0; if (!(0 < 0x01)) _desolexPanic(33); stor_expr_bw = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff000000ffff & stor_expr_bw | ((0x01 << 0x18) & (0xff000000))) | 0; uint256 value18 = 0; while (true) { if (!(value18 < arg1.length)) { break; } if (!((value18 < arg1.length))) _desolexPanic(50); if (!(stor_expr_by < 0x010000000000000000)) _desolexPanic(65); stor_expr_by = stor_expr_by + 0x01; if (!((stor_expr_by < stor_expr_bz))) _desolexPanic(50); if (0) _desolexPanic(0); stor_expr_ca = msg.data[(0x60 * value18) + ((0x04 + arg1) + 0x20)]; stor_expr_cb = msg.data[((0x60 * value18) + ((0x04 + arg1) + 0x20)) + 0x20]; require(msg.data[0x40 + ((0x60 * value18) + ((0x04 + arg1) + 0x20))] < 0x04); stor_expr_cc = (bytes1(msg.data[0x40 + ((0x60 * value18) + ((0x04 + arg1) + 0x20))])) | (stor_expr_cc & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); value18 = value18 + 0x01; mapping_c[nextVestingId] = ((value8 - value9) * mapping_f[token]) / 0x0de0b6b3a7640000; mapping_b[token] = mapping_b[token] + ((value8 - value9) * mapping_f[token] / 0x0de0b6b3a7640000); uint256 value3 = 0; uint256 value4 = (0x04 + arg1) + 0x20; uint256 value5 = (var_e + 0xa0) + 0x20; while (true) { mapping_e[nextVestingId] = false; if (!(value3 < arg1.length)) { break; } if (!(msg.data[value4 + 0x40] < 0x04)) { revert(); break; } if (!(((msg.data[value4 + 0x40]) < 0x04))) _desolexPanic(33); value3 = value3 + 0x01; value4 = value4 + 0x60; value5 = value5 + 0x60; } emit VestingCreated(nextVestingId, arg2, token, 0xa0, 0x01, 0x01, 0, (arg1)); stor_8 = 0x01; return nextVestingId; } } } else { if (value2 <= (value2 + 0x01)) { if (value2 + 0x01 != 0) { uint256 value3 = 0; uint256 value4 = (0x04 + arg1) + 0x20; uint256 value5 = (var_e + 0x24) + 0x20; while (true) { mapping_f[token] = ((mapping_b[token] + 0x01) * 0x0de0b6b3a7640000) / (value2 + 0x01); if (!(value3 < arg1.length)) { (bool success5, bytes memory returnData5) = address(0xb4123869ca90735bd2d9847b8a7dc60c36699dc3).getTotalAmount(0x20); // staticcall if (success5) { uint256 value20 = msg.data[0] >> 0xe0; uint256 value21 = var_e.length; if (success5) { uint256 value19 = returnData5.length; if (0x20 <= returnData5.length) { value19 = 0x20; } if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value19 + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value19 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value19 + 0x1f)); require(((var_e + value19) - var_e) >= 0x20); } else { value20 = var_e; value21 = 0; } require(value21 != 0x0, InvalidAmount()); bool flag8 = !(feeExemptCreators[msg.sender]); if (!feeExemptTokens[token]) { } else { flag8 = !(feeExemptTokens[token]); } bool flag9 = !(feeExemptTokens[token]); if (flatFee != 0) { } else { flag9 = flatFee; } bool flag11 = !(feeExemptCreators[msg.sender]); if (flag9) { } else { flag11 = flag9; } uint256 value22 = (value21 * feePercentage) / 0x2710; if ((flag8) && (feePercentage != 0x0)) { } else { value22 = 0; } uint256 value23 = msg.data[0] >> 0xe0; uint256 value24 = flatFee; if (!(flag11)) { value23 = flatFee; value24 = 0; } if (((var_e + 0xa0) < var_e) | ((var_e + 0xa0) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + 0xa0; (bool success6, bytes memory returnData6) = token.call(abi.encodeWithSelector(bytes4(0x23b872dd), msg.sender, address(this), value21)); // call transferFrom uint256 value25 = 0x60; if ((returnData6.length) != 0x0) { if (!(returnData6.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData6.length))) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData6.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData6.length))) + 0x1f)); value25 = var_e; } if (!(success6)) { require(!var_o); revert FailedInnerCall(); } require(!(var_o == 0x0 && token.code.length == 0x0), AddressEmptyCode()); uint256 value26 = this.code.length; uint256 value27 = this.code.length; bool flag13 = !(var_ah); if (!(!(var_ai))) { require(!(value25 + var_ai - value25 < 0x20)); require((!(!(var_ah))) == var_ah); } else { value26 = var_ai; value27 = value25; flag13 = !(!(var_ai)); } require(!(flag13), SafeERC20FailedOperation()); if (value22 != 0x0) { if (((var_e + 0x80) < var_e) | ((var_e + 0x80) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + 0x80; (bool success7, bytes memory returnData7) = token.call(abi.encodeWithSelector(bytes4(0xa9059cbb), address(feeCollector), value22)); // call transfer uint256 value28 = 0x60; if ((returnData7.length) != 0x0) { if (!(returnData7.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData7.length))) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData7.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData7.length))) + 0x1f)); value28 = var_e; } if (!(success7)) { require(!var_o); revert FailedInnerCall(); } require(!(var_o == 0x0 && address(token).code.length == 0x0), AddressEmptyCode()); uint256 value29 = this.code.length; uint256 value30 = this.code.length; bool flag15 = !(var_aj); if (!(!(var_ak))) { require(!(value28 + var_ak - value28 < 0x20)); require((!(!(var_aj))) == var_aj); } else { value29 = var_ak; value30 = value28; flag15 = !(!(var_ak)); } require(!(flag15), SafeERC20FailedOperation()); emit FeesCollected(token, value22, 0); } if (value24 == 0) { nextVestingId = 0x01 + nextVestingId; mapping_d[nextVestingId] = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & mapping_d[nextVestingId]) | token; stor_expr_bt = msg.sender; stor_expr_bu = (stor_expr_bu & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | arg2; stor_expr_bv = value21 - value22; stor_expr_bw = (bytes1(0x01)) | (stor_expr_bw & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); stor_expr_bw = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff & stor_expr_bw) | ((0 << 0x08) & (0xff00)); stor_expr_bx = 0; if (!(0 < 0x01)) _desolexPanic(33); stor_expr_bw = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff000000ffff & stor_expr_bw | ((0x01 << 0x18) & (0xff000000))) | 0; uint256 value18 = 0; while (true) { if (!(value18 < arg1.length)) { break; } if (!((value18 < arg1.length))) _desolexPanic(50); if (!(stor_expr_by < 0x010000000000000000)) _desolexPanic(65); stor_expr_by = stor_expr_by + 0x01; if (!((stor_expr_by < stor_expr_bz))) _desolexPanic(50); if (0) _desolexPanic(0); stor_expr_ca = msg.data[(0x60 * value18) + ((0x04 + arg1) + 0x20)]; stor_expr_cb = msg.data[((0x60 * value18) + ((0x04 + arg1) + 0x20)) + 0x20]; require(msg.data[0x40 + ((0x60 * value18) + ((0x04 + arg1) + 0x20))] < 0x04); stor_expr_cc = (bytes1(msg.data[0x40 + ((0x60 * value18) + ((0x04 + arg1) + 0x20))])) | (stor_expr_cc & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); value18 = value18 + 0x01; mapping_c[nextVestingId] = ((value21 - value22) * mapping_f[token]) / 0x0de0b6b3a7640000; mapping_b[token] = mapping_b[token] + ((value21 - value22) * mapping_f[token] / 0x0de0b6b3a7640000); uint256 value3 = 0; uint256 value4 = (0x04 + arg1) + 0x20; uint256 value5 = (var_e + 0xa0) + 0x20; while (true) { mapping_e[nextVestingId] = false; if (value3 < arg1.length) { } else { emit VestingCreated(nextVestingId, arg2, token, 0xa0, 0x01, 0x01, 0, (arg1)); stor_8 = 0x01; return nextVestingId; } } } } } } } } else { uint256 value3 = 0; uint256 value4 = (0x04 + arg1) + 0x20; uint256 value5 = (var_e + 0x24) + 0x20; while (true) { mapping_f[token] = 0x0de0b6b3a7640000; if (!(value3 < arg1.length)) { break; } if (!(msg.data[value4 + 0x40] < 0x04)) { revert(); break; } if (!((msg.data[value4 + 0x40] < 0x04))) _desolexPanic(33); value3 = value3 + 0x01; value4 = value4 + 0x60; value5 = value5 + 0x60; } (bool success8, bytes memory returnData8) = address(0xb4123869ca90735bd2d9847b8a7dc60c36699dc3).getTotalAmount(0x20); // staticcall require(success8); uint256 value32 = msg.data[0] >> 0xe0; uint256 value33 = var_e.length; if (success8) { uint256 value31 = returnData8.length; if (0x20 <= returnData8.length) { value31 = 0x20; } if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value31 + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value31 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value31 + 0x1f)); require(((var_e + value31) - var_e) >= 0x20); } else { value32 = var_e; value33 = 0; } require(value33 != 0x0, InvalidAmount()); bool flag16 = !(feeExemptCreators[msg.sender]); if (!feeExemptTokens[token]) { } else { flag16 = !(feeExemptTokens[token]); } bool flag17 = !(feeExemptTokens[token]); if (flatFee != 0) { } else { flag17 = flatFee; } bool flag19 = !(feeExemptCreators[msg.sender]); if (flag17) { } else { flag19 = flag17; } uint256 value34 = (value33 * feePercentage) / 0x2710; if ((flag16) && (feePercentage != 0x0)) { } else { value34 = 0; } uint256 value35 = msg.data[0] >> 0xe0; uint256 value36 = flatFee; if (!(flag19)) { value35 = flatFee; value36 = 0; } if (((var_e + 0xa0) < var_e) | ((var_e + 0xa0) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + 0xa0; (bool success9, bytes memory returnData9) = token.call(abi.encodeWithSelector(bytes4(0x23b872dd), msg.sender, address(this), value33)); // call transferFrom uint256 value37 = 0x60; if ((returnData9.length) != 0x0) { if (!(returnData9.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData9.length))) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData9.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData9.length))) + 0x1f)); value37 = var_e; } if (!(success9)) { require(!var_o); revert FailedInnerCall(); } require(!(var_o == 0x0 && token.code.length == 0x0), AddressEmptyCode()); uint256 value38 = this.code.length; uint256 value39 = this.code.length; bool flag21 = !(var_al); if (!(!(var_am))) { require(!(value37 + var_am - value37 < 0x20)); require((!(!(var_al))) == var_al); } else { value38 = var_am; value39 = value37; flag21 = !(!(var_am)); } require(!(flag21), SafeERC20FailedOperation()); if (value34 != 0x0) { if (((var_e + 0x80) < var_e) | ((var_e + 0x80) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + 0x80; (bool success10, bytes memory returnData10) = token.call(abi.encodeWithSelector(bytes4(0xa9059cbb), address(feeCollector), value34)); // call transfer uint256 value40 = 0x60; if ((returnData10.length) != 0x0) { if (!(returnData10.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData10.length))) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData10.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData10.length))) + 0x1f)); value40 = var_e; } if (!(success10)) { require(!var_o); revert FailedInnerCall(); } require(!(var_o == 0x0 && address(token).code.length == 0x0), AddressEmptyCode()); uint256 value41 = this.code.length; uint256 value42 = this.code.length; bool flag23 = !(var_an); if (!(!(var_ao))) { require(!(value40 + var_ao - value40 < 0x20)); require((!(!(var_an))) == var_an); } else { value41 = var_ao; value42 = value40; flag23 = !(!(var_ao)); } require(!(flag23), SafeERC20FailedOperation()); emit FeesCollected(token, value34, 0); } if (value36 != 0x0) { require(msg.value >= value36, InvalidFlatFee()); (bool success11, bytes memory returnData11) = feeCollector.call{ value: value36 }(""); // call if (returnData11.length == 0) { require(success11, FeeTransferFailed()); emit FeesCollected(token, 0, value36); nextVestingId = 0x01 + nextVestingId; mapping_d[nextVestingId] = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & mapping_d[nextVestingId]) | token; stor_expr_bt = msg.sender; stor_expr_bu = (stor_expr_bu & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | arg2; stor_expr_bv = value33 - value34; stor_expr_bw = (bytes1(0x01)) | (stor_expr_bw & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); stor_expr_bw = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff & stor_expr_bw) | ((0 << 0x08) & (0xff00)); stor_expr_bx = 0; if (!(0 < 0x01)) _desolexPanic(33); stor_expr_bw = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff000000ffff & stor_expr_bw | ((0x01 << 0x18) & (0xff000000))) | 0; uint256 value18 = 0; while (true) { if (!(value18 < arg1.length)) { break; } if (!((value18 < arg1.length))) _desolexPanic(50); if (!(stor_expr_by < 0x010000000000000000)) _desolexPanic(65); stor_expr_by = stor_expr_by + 0x01; if (!((stor_expr_by < stor_expr_bz))) _desolexPanic(50); if (0) _desolexPanic(0); stor_expr_ca = msg.data[(0x60 * value18) + ((0x04 + arg1) + 0x20)]; stor_expr_cb = msg.data[((0x60 * value18) + ((0x04 + arg1) + 0x20)) + 0x20]; require(msg.data[0x40 + ((0x60 * value18) + ((0x04 + arg1) + 0x20))] < 0x04); stor_expr_cc = (bytes1(msg.data[0x40 + ((0x60 * value18) + ((0x04 + arg1) + 0x20))])) | (stor_expr_cc & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); value18 = value18 + 0x01; mapping_c[nextVestingId] = ((value33 - value34) * mapping_f[token]) / 0x0de0b6b3a7640000; mapping_b[token] = mapping_b[token] + ((value33 - value34) * mapping_f[token] / 0x0de0b6b3a7640000); uint256 value3 = 0; uint256 value4 = (0x04 + arg1) + 0x20; uint256 value5 = (var_e + 0xa0) + 0x20; while (true) { mapping_e[nextVestingId] = false; if (!(value3 < arg1.length)) { break; } if (!(msg.data[value4 + 0x40] < 0x04)) { revert(); break; } if (!(((msg.data[value4 + 0x40]) < 0x04))) _desolexPanic(33); value3 = value3 + 0x01; value4 = value4 + 0x60; value5 = value5 + 0x60; } emit VestingCreated(nextVestingId, arg2, token, 0xa0, 0x01, 0x01, 0, (arg1)); stor_8 = 0x01; return nextVestingId; } } else { if (!(returnData11.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData11.length))) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData11.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData11.length))) + 0x1f)); require(success11, FeeTransferFailed()); emit FeesCollected(token, 0, value36); nextVestingId = 0x01 + nextVestingId; mapping_d[nextVestingId] = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & mapping_d[nextVestingId]) | token; stor_expr_bt = msg.sender; stor_expr_bu = (stor_expr_bu & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | arg2; stor_expr_bv = value33 - value34; stor_expr_bw = (bytes1(0x01)) | (stor_expr_bw & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); stor_expr_bw = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff & stor_expr_bw) | ((0 << 0x08) & (0xff00)); stor_expr_bx = 0; if (!(0 < 0x01)) _desolexPanic(33); stor_expr_bw = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff000000ffff & stor_expr_bw | ((0x01 << 0x18) & (0xff000000))) | 0; uint256 value18 = 0; while (true) { if (!(value18 < arg1.length)) { break; } if (!((value18 < arg1.length))) _desolexPanic(50); if (!(stor_expr_by < 0x010000000000000000)) _desolexPanic(65); stor_expr_by = stor_expr_by + 0x01; if (!((stor_expr_by < stor_expr_bz))) _desolexPanic(50); if (0) _desolexPanic(0); stor_expr_ca = msg.data[(0x60 * value18) + ((0x04 + arg1) + 0x20)]; stor_expr_cb = msg.data[((0x60 * value18) + ((0x04 + arg1) + 0x20)) + 0x20]; require(msg.data[0x40 + ((0x60 * value18) + ((0x04 + arg1) + 0x20))] < 0x04); stor_expr_cc = (bytes1(msg.data[0x40 + ((0x60 * value18) + ((0x04 + arg1) + 0x20))])) | (stor_expr_cc & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); value18 = value18 + 0x01; mapping_c[nextVestingId] = ((value33 - value34) * mapping_f[token]) / 0x0de0b6b3a7640000; mapping_b[token] = mapping_b[token] + ((value33 - value34) * mapping_f[token] / 0x0de0b6b3a7640000); uint256 value3 = 0; uint256 value4 = (0x04 + arg1) + 0x20; uint256 value5 = (var_e + 0xa0) + 0x20; while (true) { mapping_e[nextVestingId] = false; if (!(value3 < arg1.length)) { break; } if (!(msg.data[value4 + 0x40] < 0x04)) { revert(); break; } if (!(((msg.data[value4 + 0x40]) < 0x04))) _desolexPanic(33); value3 = value3 + 0x01; value4 = value4 + 0x60; value5 = value5 + 0x60; } emit VestingCreated(nextVestingId, arg2, token, 0xa0, 0x01, 0x01, 0, (arg1)); stor_8 = 0x01; return nextVestingId; } } } else { nextVestingId = 0x01 + nextVestingId; mapping_d[nextVestingId] = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & mapping_d[nextVestingId]) | token; stor_expr_bt = msg.sender; stor_expr_bu = (stor_expr_bu & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | arg2; stor_expr_bv = value33 - value34; stor_expr_bw = (bytes1(0x01)) | (stor_expr_bw & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); stor_expr_bw = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff & stor_expr_bw) | ((0 << 0x08) & (0xff00)); stor_expr_bx = 0; if (!(0 < 0x01)) _desolexPanic(33); stor_expr_bw = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff000000ffff & stor_expr_bw | ((0x01 << 0x18) & (0xff000000))) | 0; uint256 value18 = 0; while (true) { if (!(value18 < arg1.length)) { break; } if (!((value18 < arg1.length))) _desolexPanic(50); if (!(stor_expr_by < 0x010000000000000000)) _desolexPanic(65); stor_expr_by = stor_expr_by + 0x01; if (!((stor_expr_by < stor_expr_bz))) _desolexPanic(50); if (0) _desolexPanic(0); stor_expr_ca = msg.data[(0x60 * value18) + ((0x04 + arg1) + 0x20)]; stor_expr_cb = msg.data[((0x60 * value18) + ((0x04 + arg1) + 0x20)) + 0x20]; require(msg.data[0x40 + ((0x60 * value18) + ((0x04 + arg1) + 0x20))] < 0x04); stor_expr_cc = (bytes1(msg.data[0x40 + ((0x60 * value18) + ((0x04 + arg1) + 0x20))])) | (stor_expr_cc & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); value18 = value18 + 0x01; mapping_c[nextVestingId] = ((value33 - value34) * mapping_f[token]) / 0x0de0b6b3a7640000; mapping_b[token] = mapping_b[token] + ((value33 - value34) * mapping_f[token] / 0x0de0b6b3a7640000); uint256 value3 = 0; uint256 value4 = (0x04 + arg1) + 0x20; uint256 value5 = (var_e + 0xa0) + 0x20; while (true) { mapping_e[nextVestingId] = false; if (!(value3 < arg1.length)) { break; } if (!(msg.data[value4 + 0x40] < 0x04)) { revert(); break; } if (!(((msg.data[value4 + 0x40]) < 0x04))) _desolexPanic(33); value3 = value3 + 0x01; value4 = value4 + 0x60; value5 = value5 + 0x60; } emit VestingCreated(nextVestingId, arg2, token, 0xa0, 0x01, 0x01, 0, (arg1)); stor_8 = 0x01; return nextVestingId; } } } } } } } } } } } } } } } } } function acceptOwnership() public { require(pendingOwner == msg.sender, OwnableUnauthorizedAccount()); pendingOwner = address(0); emit OwnershipTransferred(owner, msg.sender); owner = msg.sender; } function renounceOwnership() public onlyOwner { pendingOwner = address(0); emit OwnershipTransferred(owner, address(0)); owner = address(0); } function vestingSchedules(uint256 index) public view returns (bool) { if (!(bytes1(stor_expr_c >> 0x20) < 0x01)) _desolexPanic(33); return abi.encodePacked(mapping_d[index], stor_expr_b, stor_expr_ai, stor_expr_f, stor_expr_w, !(!(bytes1(stor_expr_c))), !(!(bytes1(stor_expr_c >> 0x08))), !(!(bytes1(stor_expr_c >> 0x10))), !(!(bytes1(stor_expr_c >> 0x18))), bytes1(stor_expr_c >> 0x20)); } function ownerOf(uint256 tokenId) public view returns (address) { require(address(array_2[tokenId]), ERC721NonexistentToken()); return address(array_2[tokenId]); } function safeTransferFrom(address _from, address to, uint256 tokenId) public { uint256 var_a; if (((var_a + 0x20) < var_a) | ((var_a + 0x20) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + 0x20; require(to != address(0), ERC721InvalidReceiver()); bool value2 = msg.sender; if (msg.sender != address(0)) { uint256 value1; uint256 value0 = bytes1(isApprovedForAll[address(array_2[tokenId])][msg.sender]); if (!(address(array_2[tokenId]) == (msg.sender))) { } else { value0 = ((address(array_2[tokenId])) == (msg.sender)) ? 1 : 0; } uint256 value8 = value0; if (value0 == 0) { value8 = ((msg.sender) == getApproved[tokenId]) ? 1 : 0; } value1 = value8; if (value1 == 0x0) { require(address(array_2[tokenId]) != address(0), ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } } else { value2 = !(!(msg.sender)); } if (address(array_2[tokenId]) != address(0)) { getApproved[tokenId] = address(0); balanceOf[address(array_2[tokenId])] = balanceOf[address(array_2[tokenId])] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if (to != address(0)) { balanceOf[to] = balanceOf[to] + 0x01; } array_2[tokenId] = to | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & array_2[tokenId]); emit Transfer(address(array_2[tokenId]), to, tokenId); } else { if (to != address(0)) { balanceOf[to] = balanceOf[to] + 0x01; } array_2[tokenId] = to | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & array_2[tokenId]); emit Transfer(address(array_2[tokenId]), to, tokenId); } bool flag0 = true; if (!(address(array_2[tokenId]))) { flag0 = !(!(address(array_2[tokenId]))); } if (flag0) { require(mapping_e[tokenId], NonTransferableToken()); stor_expr_bj = to; } require(address(array_2[tokenId]) == _from, ERC721IncorrectOwner()); if (to.code.length != 0x0) { uint256 value3 = 0; while (true) { if (!(value3 < var_m)) { break; } value3 = 0x20 + value3; (bool success0, bytes memory returnData0) = to.onERC721Received(msg.sender, _from, tokenId, 0x80); // call uint256 value5 = this.code.length; uint256 value6 = var_a.length; if (success0) { uint256 value4 = returnData0.length; if (0x20 <= returnData0.length) { value4 = 0x20; } if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value4 + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value4 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value4 + 0x1f)); require(((var_a + value4) - var_a) >= 0x20); require(var_a.length == (var_a.length & (0xffffffff00000000000000000000000000000000000000000000000000000000))); } else { value5 = var_a; value6 = 0; } if (!(success0)) { uint256 value7 = 0x60; if ((returnData0.length) != 0x0) { if (returnData0.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f))) < var_a) | ((var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_a = var_a + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f)); value7 = var_a; } require(var_q != 0x0, ERC721InvalidReceiver()); revert(); } require(!(0xeaf485fe00000000000000000000000000000000000000000000000000000000 + (0xffffffff00000000000000000000000000000000000000000000000000000000 & value6)), ERC721InvalidReceiver()); } } } function createBulkVestingForBeneficiary(address[] memory arg0, (uint256,uint256,uint8)[] memory arg1, address arg2, bool arg3, bool arg4, bool arg5, bool arg6) public payable { require(((0x04 + arg0) + 0x1f) < msg.data.length); require(!(((arg0.length << 0x05) + (0x04 + arg0) + 0x20) > msg.data.length)); address[] var_a = arg0; address[] var_b = (0x04 + arg0) + 0x20; require(((0x04 + arg1) + 0x1f) < msg.data.length); require(!(((arg1.length << 0x05) + (0x04 + arg1) + 0x20) > msg.data.length)); address var_d = arg2; require(stor_8 != 0x02, ReentrancyGuardReentrantCall()); stor_8 = 0x02; require(address(var_d), InvalidBeneficiary()); bool flag0 = !(var_a == arg1.length); if (var_a == 0) { flag0 = !var_a; } require(!(flag0), InvalidArray()); bool flag1 = !(feeExemptCreators[msg.sender]); if (flatFee != 0) { } else { flag1 = flatFee; } uint256 value0 = msg.data[0] >> 0xe0; uint256 var_j; if (flag1) { require(msg.value >= flatFee, InvalidFlatFee()); (bool success0, bytes memory returnData0) = feeCollector.call{ value: flatFee }(""); // call if (returnData0.length == 0) { require(success0, FeeTransferFailed()); } else { if (!(returnData0.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_j + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f))) < var_j) | ((var_j + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_j = var_j + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f)); require(success0, FeeTransferFailed()); } emit FeesCollected(address(0), 0, flatFee); } else { value0 = flatFee; } if (!(var_a <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_j + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_a << 0x05)) + 0x1f))) < var_j) | ((var_j + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_a << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_j = var_j + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_a << 0x05)) + 0x1f)); if (!(var_a <= 0xffffffffffffffff)) _desolexPanic(65); if (!(var_a <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_j + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_a << 0x05)) + 0x1f))) < var_j) | ((var_j + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_a << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_j = var_j + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_a << 0x05)) + 0x1f)); if (!(var_a <= 0xffffffffffffffff)) _desolexPanic(65); if (!(var_a <= 0xffffffffffffffff)) _desolexPanic(65); } function cancel(uint256 arg0) public { require(stor_8 != 0x02, ReentrancyGuardReentrantCall()); stor_8 = 0x02; require(msg.sender == (stor_expr_b), NotAuthorized()); require(bytes1(stor_expr_c), NotCancellable()); require(!(bytes1(stor_expr_c >> 0x10)), VestingAlreadyCancelled()); if (bytes1(stor_expr_c >> 0x10) != 0x0) { uint256 value0; if (stor_expr_f != 0x0) { uint256 value28 = (stor_expr_ad * mapping_c[arg0]) / stor_expr_f; if (stor_expr_ad * mapping_c[arg0] / stor_expr_f > mapping_c[arg0]) { value28 = mapping_c[arg0]; } value0 = value28; } else { value0 = 0; } uint256 value1 = msg.data[0] >> 0xe0; if (mapping_c[arg0] != value0) { mapping_b[mapping_d[arg0]] = mapping_b[mapping_d[arg0]] - (mapping_c[arg0] - value0); } else { value1 = mapping_c[arg0] - value0; } mapping_c[arg0] = value0; stor_expr_c = (stor_expr_c & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ffff)) | 0x010000; stor_expr_f = stor_expr_ad; uint256 value5 = msg.data[0] >> 0xe0; uint256 value6 = msg.data[0] >> 0xe0; uint256 value7 = msg.data[0] >> 0xe0; uint256 var_g; if (stor_expr_f != stor_expr_ad) { if (((var_g + 0x80) < var_g) | ((var_g + 0x80) > 0xffffffffffffffff)) _desolexPanic(65); var_g = var_g + 0x80; (bool success0, bytes memory returnData0) = address(mapping_d[arg0]).transfer(stor_expr_b, (stor_expr_f - stor_expr_ad)); // call uint256 value2 = 0x60; if ((returnData0.length) != 0x0) { if (returnData0.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_g + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f))) < var_g) | ((var_g + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_g = var_g + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f)); value2 = var_g; } if (!(success0)) { require(!var_i); revert FailedInnerCall(); } require(!(var_i == 0x0 && address(mapping_d[arg0]).code.length == 0x0), AddressEmptyCode()); uint256 value3 = this.code.length; uint256 value4 = this.code.length; bool flag1 = !(var_j); if (!(!(var_k))) { require(!(value2 + var_k - value2 < 0x20)); require((!(!(var_j))) == var_j); } else { value3 = var_k; value4 = (value2) ? 1 : 0; flag1 = !(!(var_k)); } require(!(flag1), SafeERC20FailedOperation()); } else { value5 = (keccak256(abi.encode(arg0, 0x0d))) + 0x01; value6 = stor_expr_f - stor_expr_ad; value7 = keccak256(abi.encode(arg0, 0x0d)); } emit VestingCancelled(arg0); stor_8 = 0x01; } else { uint256 value8 = 0; uint256 value9 = (var_g + 0x04) + 0x60; uint256 value10 = keccak256(abi.encode(keccak256(abi.encode(arg0, 0x0d)) + 0x06)); while (true) { if (value8 >= stor_expr_d) { break; } if (!((bytes1(array_2[value10]) < 0x04))) _desolexPanic(33); value8 = value8 + 0x01; value9 = value9 + 0x60; value10 = value10 + 0x03; (bool success1, bytes memory returnData1) = address(0xb4123869ca90735bd2d9847b8a7dc60c36699dc3).calculateVestedAmount(0x40, block.timestamp); // staticcall require(success1); if (success1) { uint256 value11 = returnData1.length; if (0x20 <= returnData1.length) { value11 = 0x20; } if (((var_g + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value11 + 0x1f))) < var_g) | ((var_g + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value11 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_g = var_g + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value11 + 0x1f)); require(((var_g + value11) - var_g) >= 0x20); uint256 value12; if (stor_expr_f != 0x0) { uint256 value29 = (var_g.length * mapping_c[arg0]) / stor_expr_f; if ((var_g.length * mapping_c[arg0]) / stor_expr_f > mapping_c[arg0]) { value29 = mapping_c[arg0]; } value12 = value29; } else { value12 = 0; } uint256 value13 = msg.data[0] >> 0xe0; if (mapping_c[arg0] != value12) { mapping_b[mapping_d[arg0]] = mapping_b[mapping_d[arg0]] - (mapping_c[arg0] - value12); } else { value13 = mapping_c[arg0] - value12; } mapping_c[arg0] = value12; stor_expr_c = (stor_expr_c & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ffff)) | 0x010000; stor_expr_f = var_g.length; uint256 value17 = msg.data[0] >> 0xe0; uint256 value18 = msg.data[0] >> 0xe0; uint256 value19 = msg.data[0] >> 0xe0; if (stor_expr_f != var_g.length) { if (((var_g + 0x80) < var_g) | ((var_g + 0x80) > 0xffffffffffffffff)) _desolexPanic(65); var_g = var_g + 0x80; (bool success2, bytes memory returnData2) = address(mapping_d[arg0]).transfer(stor_expr_b, (stor_expr_f - var_g.length)); // call uint256 value14 = 0x60; if ((returnData2.length) != 0x0) { if (returnData2.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_g + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData2.length))) + 0x1f))) < var_g) | ((var_g + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData2.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_g = var_g + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData2.length))) + 0x1f)); value14 = var_g; } if (!(success2)) { require(!var_i); revert FailedInnerCall(); } require(!(var_i == 0x0 && address(mapping_d[arg0]).code.length == 0x0), AddressEmptyCode()); uint256 value15 = this.code.length; uint256 value16 = this.code.length; bool flag3 = !(var_r); if (!(!(var_s))) { require(!(value14 + var_s - value14 < 0x20)); require((!(!(var_r))) == var_r); } else { value15 = var_s; value16 = value14; flag3 = !(!(var_s)); } require(!(flag3), SafeERC20FailedOperation()); } else { value17 = (keccak256(abi.encode(arg0, 0x0d))) + 0x01; value18 = stor_expr_f - var_g.length; value19 = keccak256(abi.encode(arg0, 0x0d)); } } else { uint256 value20; if (stor_expr_f != 0x0) { uint256 value30 = (0 * mapping_c[arg0]) / stor_expr_f; if ((0 * mapping_c[arg0]) / stor_expr_f > mapping_c[arg0]) { value30 = mapping_c[arg0]; } value20 = value30; } else { value20 = 0; } uint256 value21 = msg.data[0] >> 0xe0; if (mapping_c[arg0] != value20) { mapping_b[mapping_d[arg0]] = mapping_b[mapping_d[arg0]] - (mapping_c[arg0] - value20); } else { value21 = mapping_c[arg0] - value20; } mapping_c[arg0] = value20; stor_expr_c = (stor_expr_c & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ffff)) | 0x010000; stor_expr_f = 0; uint256 value25 = msg.data[0] >> 0xe0; uint256 value26 = msg.data[0] >> 0xe0; uint256 value27 = msg.data[0] >> 0xe0; if (stor_expr_f != 0x0) { if (((var_g + 0x80) < var_g) | ((var_g + 0x80) > 0xffffffffffffffff)) _desolexPanic(65); var_g = var_g + 0x80; (bool success3, bytes memory returnData3) = address(mapping_d[arg0]).transfer(stor_expr_b, (stor_expr_f - 0)); // call uint256 value22 = 0x60; if ((returnData3.length) != 0x0) { if (returnData3.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_g + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData3.length))) + 0x1f))) < var_g) | ((var_g + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData3.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_g = var_g + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData3.length))) + 0x1f)); value22 = var_g; } if (!(success3)) { require(!var_i); revert FailedInnerCall(); } require(!(var_i == 0x0 && address(mapping_d[arg0]).code.length == 0x0), AddressEmptyCode()); uint256 value23 = this.code.length; uint256 value24 = this.code.length; bool flag5 = !(var_t); if (!(!(var_u))) { require(!(value22 + var_u - value22 < 0x20)); require((!(!(var_t))) == var_t); } else { value23 = var_u; value24 = value22; flag5 = !(!(var_u)); } require(!(flag5), SafeERC20FailedOperation()); } else { value25 = (keccak256(abi.encode(arg0, 0x0d))) + 0x01; value26 = stor_expr_f - 0; value27 = keccak256(abi.encode(arg0, 0x0d)); } } emit VestingCancelled(arg0); stor_8 = 0x01; } } } function release(uint256 arg0) public payable { if (!(msg.value)) { require(stor_8 != 0x02, ReentrancyGuardReentrantCall()); stor_8 = 0x02; if (0 != bytes1(stor_expr_c >> 0x08)) { require(address(array_2[arg0]), ERC721NonexistentToken()); require(msg.sender == (address(array_2[arg0])), NotAuthorized()); if (mapping_b[mapping_d[arg0]] != 0) { (bool success0, bytes memory returnData0) = mapping_d[arg0].balanceOf(address(this)); // staticcall if (success0) { uint256 value1 = this.code.length; uint256 var_e; uint256 value2 = var_e.length; if (success0) { uint256 value0 = returnData0.length; if (0x20 <= returnData0.length) { value0 = 0x20; } if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value0 + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value0 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value0 + 0x1f)); require(((var_e + value0) - var_e) >= 0x20); } else { value1 = var_e; value2 = 0; } if (value2 != 0x0) { if (value2 + 0x01 != 0) { mapping_f[mapping_d[arg0]] = ((mapping_b[mapping_d[arg0]] + 0x01) * 0x0de0b6b3a7640000) / (value2 + 0x01); if (bytes1(stor_expr_c >> 0x10) != 0x0) { if ((!(mapping_c[arg0] - stor_expr_w > mapping_c[arg0])) && (mapping_c[arg0] - stor_expr_w != 0)) { (bool success1, bytes memory returnData1) = mapping_d[arg0].balanceOf(address(this)); // staticcall if (success1 && !success1 && ((mapping_c[arg0] - stor_expr_w * 0) / (mapping_c[arg0] - stor_expr_w) == 0) | (!(mapping_c[arg0] - stor_expr_w))) { stor_expr_w = stor_expr_w + (mapping_c[arg0] - stor_expr_w); mapping_b[mapping_d[arg0]] = mapping_b[mapping_d[arg0]] - (mapping_c[arg0] - stor_expr_w); if (!(((var_e + 0x80) < var_e) | ((var_e + 0x80) > 0xffffffffffffffff))) { var_e = var_e + 0x80; (bool success2, bytes memory returnData2) = address(mapping_d[arg0]).transfer(msg.sender, ((mapping_c[arg0] - stor_expr_w * 0) / mapping_b[mapping_d[arg0]])); // call uint256 value3 = 0x60; if ((returnData2.length) != 0x0) { if (returnData2.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData2.length))) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData2.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData2.length))) + 0x1f)); value3 = var_e; } if (!(success2)) { require(!var_l); revert FailedInnerCall(); } require(!(var_l == 0x0 && address(mapping_d[arg0]).code.length == 0x0), AddressEmptyCode()); } } } } else { uint256 value4 = 0; uint256 value5 = (var_e + 0x04) + 0x60; uint256 value6 = keccak256(abi.encode(keccak256(abi.encode(arg0, 0x0d)) + 0x06)); while (true) { if (value4 >= stor_expr_d) { break; } if (!((bytes1(array_2[value6]) < 0x04))) _desolexPanic(33); value4 = value4 + 0x01; value5 = value5 + 0x60; value6 = value6 + 0x03; (bool success3, bytes memory returnData3) = address(0xb4123869ca90735bd2d9847b8a7dc60c36699dc3).calculateVestedAmount(0x40, block.timestamp); // staticcall require(success3); uint256 value8 = this.code.length; uint256 value9 = var_e.length; if (success3) { uint256 value7 = returnData3.length; if (0x20 <= returnData3.length) { value7 = 0x20; } if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value7 + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value7 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value7 + 0x1f)); require(((var_e + value7) - var_e) >= 0x20); } else { value8 = var_e; value9 = 0; } uint256 value10 = stor_expr_f; if (value9 <= stor_expr_f) { value10 = value9; } uint256 value11 = (mapping_c[arg0] * value10) / stor_expr_f; if (stor_expr_f != 0x0) { } else { value11 = 0; } uint256 value12 = 0x04; uint256 value13 = mapping_c[arg0]; if (value11 > mapping_c[arg0]) { } else { value12 = arg0; value13 = value11; } if (!(value13 > stor_expr_aa)) { require(0, NoTokensToRelease()); (bool success4, bytes memory returnData4) = mapping_d[arg0].balanceOf(address(this)); // staticcall require(success4); if (!(success4)) { stor_expr_w = stor_expr_w + 0; mapping_b[mapping_d[arg0]] = mapping_b[mapping_d[arg0]] - 0; if (((var_e + 0x80) < var_e) | ((var_e + 0x80) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + 0x80; (bool success5, bytes memory returnData5) = address(mapping_d[arg0]).transfer(msg.sender, (0 / mapping_b[mapping_d[arg0]])); // call uint256 value14 = 0x60; if ((returnData5.length) != 0x0) { if (returnData5.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData5.length))) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData5.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData5.length))) + 0x1f)); value14 = var_e; } if (!(success5)) { require(!var_l); revert FailedInnerCall(); } require(!(var_l == 0x0 && address(mapping_d[arg0]).code.length == 0x0), AddressEmptyCode()); uint256 value15 = this.code.length; uint256 value16 = this.code.length; bool flag2 = !(var_r); if (!(!(var_s))) { require(!(value14 + var_s - value14 < 0x20)); require((!(!(var_r))) == var_r); } else { value15 = var_s; value16 = value14; flag2 = !(!(var_s)); } require(!(flag2), SafeERC20FailedOperation()); emit TokensReleased(arg0, msg.sender, 0 / mapping_b[mapping_d[arg0]]); stor_8 = 0x01; } uint256 value17 = returnData4.length; if (0x20 <= returnData4.length) { value17 = 0x20; } if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value17 + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value17 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value17 + 0x1f)); require(((var_e + value17) - var_e) >= 0x20); stor_expr_w = stor_expr_w + 0; mapping_b[mapping_d[arg0]] = mapping_b[mapping_d[arg0]] - 0; if (((var_e + 0x80) < var_e) | ((var_e + 0x80) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + 0x80; (bool success6, bytes memory returnData6) = address(mapping_d[arg0]).transfer(msg.sender, ((0 * var_e.length) / mapping_b[mapping_d[arg0]])); // call uint256 value18 = 0x60; if ((returnData6.length) != 0x0) { if (returnData6.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData6.length))) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData6.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData6.length))) + 0x1f)); value18 = var_e; } if (!(success6)) { require(!var_l); revert FailedInnerCall(); } require(!(var_l == 0x0 && address(mapping_d[arg0]).code.length == 0x0), AddressEmptyCode()); uint256 value19 = this.code.length; uint256 value20 = this.code.length; bool flag4 = !(var_v); if (!(!(var_w))) { require(!(value18 + var_w - value18 < 0x20)); require((!(!(var_v))) == var_v); } else { value19 = var_w; value20 = value18; flag4 = !(!(var_w)); } require(!(flag4), SafeERC20FailedOperation()); emit TokensReleased(arg0, msg.sender, (0 * var_e.length) / mapping_b[mapping_d[arg0]]); } else { require(value13 - stor_expr_aa, NoTokensToRelease()); (bool success7, bytes memory returnData7) = mapping_d[arg0].balanceOf(address(this)); // staticcall require(success7); if (!(success7)) { stor_expr_w = stor_expr_w + (value13 - stor_expr_aa); mapping_b[mapping_d[arg0]] = mapping_b[mapping_d[arg0]] - (value13 - stor_expr_aa); if (((var_e + 0x80) < var_e) | ((var_e + 0x80) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + 0x80; (bool success8, bytes memory returnData8) = address(mapping_d[arg0]).transfer(msg.sender, (((value13 - stor_expr_aa) * 0) / mapping_b[mapping_d[arg0]])); // call uint256 value21 = 0x60; if ((returnData8.length) != 0x0) { if (returnData8.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData8.length))) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData8.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData8.length))) + 0x1f)); value21 = var_e; } if (!(success8)) { require(!var_l); revert FailedInnerCall(); } require(!(var_l == 0x0 && address(mapping_d[arg0]).code.length == 0x0), AddressEmptyCode()); uint256 value22 = this.code.length; uint256 value23 = this.code.length; bool flag6 = !(var_x); if (!(!(var_y))) { require(!(value21 + var_y - value21 < 0x20)); require((!(!(var_x))) == var_x); } else { value22 = var_y; value23 = value21; flag6 = !(!(var_y)); } require(!(flag6), SafeERC20FailedOperation()); emit TokensReleased(arg0, msg.sender, ((value13 - stor_expr_aa) * 0) / mapping_b[mapping_d[arg0]]); stor_8 = 0x01; } uint256 value24 = returnData7.length; if (0x20 <= returnData7.length) { value24 = 0x20; } if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value24 + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value24 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value24 + 0x1f)); require(((var_e + value24) - var_e) >= 0x20); stor_expr_w = stor_expr_w + (value13 - stor_expr_aa); mapping_b[mapping_d[arg0]] = mapping_b[mapping_d[arg0]] - (value13 - stor_expr_aa); if (((var_e + 0x80) < var_e) | ((var_e + 0x80) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + 0x80; (bool success9, bytes memory returnData9) = address(mapping_d[arg0]).transfer(msg.sender, (((value13 - stor_expr_aa) * var_e.length) / mapping_b[mapping_d[arg0]])); // call uint256 value25 = 0x60; if ((returnData9.length) != 0x0) { if (returnData9.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData9.length))) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData9.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData9.length))) + 0x1f)); value25 = var_e; } if (!(success9)) { require(!var_l); revert FailedInnerCall(); } require(!(var_l == 0x0 && address(mapping_d[arg0]).code.length == 0x0), AddressEmptyCode()); uint256 value26 = this.code.length; uint256 value27 = this.code.length; bool flag8 = !(var_z); if (!(!(var_aa))) { require(!(value25 + var_aa - value25 < 0x20)); require((!(!(var_z))) == var_z); } else { value26 = var_aa; value27 = value25; flag8 = !(!(var_aa)); } require(!(flag8), SafeERC20FailedOperation()); emit TokensReleased(arg0, msg.sender, ((value13 - stor_expr_aa) * var_e.length) / mapping_b[mapping_d[arg0]]); } stor_8 = 0x01; } } } else { mapping_f[mapping_d[arg0]] = 0x0de0b6b3a7640000; if (bytes1(stor_expr_c >> 0x10) != 0x0) { require(mapping_c[arg0] - stor_expr_w, NoTokensToRelease()); (bool success10, bytes memory returnData10) = mapping_d[arg0].balanceOf(address(this)); // staticcall require(success10); if (!(success10)) { stor_expr_w = stor_expr_w + (mapping_c[arg0] - stor_expr_w); mapping_b[mapping_d[arg0]] = mapping_b[mapping_d[arg0]] - (mapping_c[arg0] - stor_expr_w); if (((var_e + 0x80) < var_e) | ((var_e + 0x80) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + 0x80; (bool success11, bytes memory returnData11) = address(mapping_d[arg0]).transfer(msg.sender, ((mapping_c[arg0] - stor_expr_w * 0) / mapping_b[mapping_d[arg0]])); // call uint256 value28 = 0x60; if ((returnData11.length) != 0x0) { if (returnData11.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData11.length))) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData11.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData11.length))) + 0x1f)); value28 = var_e; } if (!(success11)) { require(!var_l); revert FailedInnerCall(); } require(!(var_l == 0x0 && address(mapping_d[arg0]).code.length == 0x0), AddressEmptyCode()); uint256 value29 = this.code.length; uint256 value30 = this.code.length; bool flag10 = !(var_ab); if (!(!(var_ac))) { require(!(value28 + var_ac - value28 < 0x20)); require((!(!(var_ab))) == var_ab); } else { value29 = var_ac; value30 = value28; flag10 = !(!(var_ac)); } require(!(flag10), SafeERC20FailedOperation()); emit TokensReleased(arg0, msg.sender, (mapping_c[arg0] - stor_expr_w * 0) / mapping_b[mapping_d[arg0]]); stor_8 = 0x01; } uint256 value31 = returnData10.length; if (0x20 <= returnData10.length) { value31 = 0x20; } if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value31 + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value31 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value31 + 0x1f)); require(((var_e + value31) - var_e) >= 0x20); stor_expr_w = stor_expr_w + (mapping_c[arg0] - stor_expr_w); mapping_b[mapping_d[arg0]] = mapping_b[mapping_d[arg0]] - (mapping_c[arg0] - stor_expr_w); if (((var_e + 0x80) < var_e) | ((var_e + 0x80) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + 0x80; (bool success12, bytes memory returnData12) = address(mapping_d[arg0]).transfer(msg.sender, ((mapping_c[arg0] - stor_expr_w * var_e.length) / mapping_b[mapping_d[arg0]])); // call uint256 value32 = 0x60; if ((returnData12.length) != 0x0) { if (returnData12.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData12.length))) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData12.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData12.length))) + 0x1f)); value32 = var_e; } if (!(success12)) { require(!var_l); revert FailedInnerCall(); } require(!(var_l == 0x0 && address(mapping_d[arg0]).code.length == 0x0), AddressEmptyCode()); uint256 value33 = this.code.length; uint256 value34 = this.code.length; bool flag12 = !(var_ad); if (!(!(var_ae))) { require(!(value32 + var_ae - value32 < 0x20)); require((!(!(var_ad))) == var_ad); } else { value33 = var_ae; value34 = value32; flag12 = !(!(var_ae)); } require(!(flag12), SafeERC20FailedOperation()); emit TokensReleased(arg0, msg.sender, (mapping_c[arg0] - stor_expr_w * var_e.length) / mapping_b[mapping_d[arg0]]); stor_8 = 0x01; } else { uint256 value4 = 0; uint256 value5 = (var_e + 0x04) + 0x60; uint256 value6 = keccak256(abi.encode(keccak256(abi.encode(arg0, 0x0d)) + 0x06)); while (true) { if (value4 >= stor_expr_d) { break; } if (!((bytes1(array_2[value6]) < 0x04))) _desolexPanic(33); value4 = value4 + 0x01; value5 = value5 + 0x60; value6 = value6 + 0x03; (bool success13, bytes memory returnData13) = address(0xb4123869ca90735bd2d9847b8a7dc60c36699dc3).calculateVestedAmount(0x40, block.timestamp); // staticcall require(success13); uint256 value36 = this.code.length; uint256 value37 = var_e.length; if (success13) { uint256 value35 = returnData13.length; if (0x20 <= returnData13.length) { value35 = 0x20; } if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value35 + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value35 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value35 + 0x1f)); require(((var_e + value35) - var_e) >= 0x20); } else { value36 = var_e; value37 = 0; } uint256 value38 = stor_expr_f; if (value37 <= stor_expr_f) { value38 = value37; } uint256 value39 = (mapping_c[arg0] * value38) / stor_expr_f; if (stor_expr_f != 0x0) { } else { value39 = 0; } uint256 value40 = 0x04; uint256 value41 = mapping_c[arg0]; if (value39 > mapping_c[arg0]) { } else { value40 = arg0; value41 = value39; } if (!(value41 > stor_expr_aa)) { require(0, NoTokensToRelease()); (bool success14, bytes memory returnData14) = mapping_d[arg0].balanceOf(address(this)); // staticcall require(success14); if (!(success14)) { stor_expr_w = stor_expr_w + 0; mapping_b[mapping_d[arg0]] = mapping_b[mapping_d[arg0]] - 0; if (((var_e + 0x80) < var_e) | ((var_e + 0x80) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + 0x80; (bool success15, bytes memory returnData15) = address(mapping_d[arg0]).transfer(msg.sender, (0 / mapping_b[mapping_d[arg0]])); // call uint256 value42 = 0x60; if ((returnData15.length) != 0x0) { if (returnData15.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData15.length))) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData15.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData15.length))) + 0x1f)); value42 = var_e; } if (!(success15)) { require(!var_l); revert FailedInnerCall(); } require(!(var_l == 0x0 && address(mapping_d[arg0]).code.length == 0x0), AddressEmptyCode()); uint256 value43 = this.code.length; uint256 value44 = this.code.length; bool flag14 = !(var_af); if (!(!(var_ag))) { require(!(value42 + var_ag - value42 < 0x20)); require((!(!(var_af))) == var_af); } else { value43 = var_ag; value44 = value42; flag14 = !(!(var_ag)); } require(!(flag14), SafeERC20FailedOperation()); emit TokensReleased(arg0, msg.sender, 0 / mapping_b[mapping_d[arg0]]); stor_8 = 0x01; } uint256 value45 = returnData14.length; if (0x20 <= returnData14.length) { value45 = 0x20; } if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value45 + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value45 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value45 + 0x1f)); require(((var_e + value45) - var_e) >= 0x20); stor_expr_w = stor_expr_w + 0; mapping_b[mapping_d[arg0]] = mapping_b[mapping_d[arg0]] - 0; if (((var_e + 0x80) < var_e) | ((var_e + 0x80) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + 0x80; (bool success16, bytes memory returnData16) = address(mapping_d[arg0]).transfer(msg.sender, ((0 * var_e.length) / mapping_b[mapping_d[arg0]])); // call uint256 value46 = 0x60; if ((returnData16.length) != 0x0) { if (returnData16.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData16.length))) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData16.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData16.length))) + 0x1f)); value46 = var_e; } if (!(success16)) { require(!var_l); revert FailedInnerCall(); } require(!(var_l == 0x0 && address(mapping_d[arg0]).code.length == 0x0), AddressEmptyCode()); uint256 value47 = this.code.length; uint256 value48 = this.code.length; bool flag16 = !(var_ah); if (!(!(var_ai))) { require(!(value46 + var_ai - value46 < 0x20)); require((!(!(var_ah))) == var_ah); } else { value47 = var_ai; value48 = value46; flag16 = !(!(var_ai)); } require(!(flag16), SafeERC20FailedOperation()); emit TokensReleased(arg0, msg.sender, (0 * var_e.length) / mapping_b[mapping_d[arg0]]); } else { require(value41 - stor_expr_aa, NoTokensToRelease()); (bool success17, bytes memory returnData17) = mapping_d[arg0].balanceOf(address(this)); // staticcall require(success17); if (!(success17)) { stor_expr_w = stor_expr_w + (value41 - stor_expr_aa); mapping_b[mapping_d[arg0]] = mapping_b[mapping_d[arg0]] - (value41 - stor_expr_aa); if (((var_e + 0x80) < var_e) | ((var_e + 0x80) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + 0x80; (bool success18, bytes memory returnData18) = address(mapping_d[arg0]).transfer(msg.sender, (((value41 - stor_expr_aa) * 0) / mapping_b[mapping_d[arg0]])); // call uint256 value49 = 0x60; if ((returnData18.length) != 0x0) { if (returnData18.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData18.length))) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData18.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData18.length))) + 0x1f)); value49 = var_e; } if (!(success18)) { require(!var_l); revert FailedInnerCall(); } require(!(var_l == 0x0 && address(mapping_d[arg0]).code.length == 0x0), AddressEmptyCode()); uint256 value50 = this.code.length; uint256 value51 = this.code.length; bool flag18 = !(var_aj); if (!(!(var_ak))) { require(!(value49 + var_ak - value49 < 0x20)); require((!(!(var_aj))) == var_aj); } else { value50 = var_ak; value51 = value49; flag18 = !(!(var_ak)); } require(!(flag18), SafeERC20FailedOperation()); emit TokensReleased(arg0, msg.sender, ((value41 - stor_expr_aa) * 0) / mapping_b[mapping_d[arg0]]); stor_8 = 0x01; } uint256 value52 = returnData17.length; if (0x20 <= returnData17.length) { value52 = 0x20; } if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value52 + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value52 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value52 + 0x1f)); require(((var_e + value52) - var_e) >= 0x20); stor_expr_w = stor_expr_w + (value41 - stor_expr_aa); mapping_b[mapping_d[arg0]] = mapping_b[mapping_d[arg0]] - (value41 - stor_expr_aa); if (((var_e + 0x80) < var_e) | ((var_e + 0x80) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + 0x80; (bool success19, bytes memory returnData19) = address(mapping_d[arg0]).transfer(msg.sender, (((value41 - stor_expr_aa) * var_e.length) / mapping_b[mapping_d[arg0]])); // call uint256 value53 = 0x60; if ((returnData19.length) != 0x0) { if (returnData19.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData19.length))) + 0x1f))) < var_e) | ((var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData19.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_e = var_e + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData19.length))) + 0x1f)); value53 = var_e; } if (!(success19)) { require(!var_l); revert FailedInnerCall(); } require(!(var_l == 0x0 && address(mapping_d[arg0]).code.length == 0x0), AddressEmptyCode()); uint256 value54 = this.code.length; uint256 value55 = this.code.length; bool flag20 = !(var_al); if (!(!(var_am))) { require(!(value53 + var_am - value53 < 0x20)); require((!(!(var_al))) == var_al); } else { value54 = var_am; value55 = value53; flag20 = !(!(var_am)); } require(!(flag20), SafeERC20FailedOperation()); emit TokensReleased(arg0, msg.sender, ((value41 - stor_expr_aa) * var_e.length) / mapping_b[mapping_d[arg0]]); } stor_8 = 0x01; } } } } } } } } } function setFlatFee(uint256 newFlatFee) public onlyOwner { flatFee = newFlatFee; emit FlatFeeUpdated(flatFee); } function transferFrom(address from, address to, uint256 amount) public { internal_3861(from, to, amount); } function createBulkVestingForBeneficiaries(address[] memory arg0, (uint256,uint256,uint8)[] memory arg1, address[] memory arg2, bool arg3, bool arg4, bool arg5, bool arg6) public payable { require(((0x04 + arg0) + 0x1f) < msg.data.length); require(!(((arg0.length << 0x05) + (0x04 + arg0) + 0x20) > msg.data.length)); address[] var_a = arg0; address[] var_b = (0x04 + arg0) + 0x20; require(((0x04 + arg1) + 0x1f) < msg.data.length); require(!(((arg1.length << 0x05) + (0x04 + arg1) + 0x20) > msg.data.length)); require(((0x04 + arg2) + 0x1f) < msg.data.length); require(!(((arg2.length << 0x05) + (0x04 + arg2) + 0x20) > msg.data.length)); address[] var_d = arg2; address[] var_e = (0x04 + arg2) + 0x20; require(stor_8 != 0x02, ReentrancyGuardReentrantCall()); stor_8 = 0x02; require(var_a != 0x0, InvalidArray()); require(var_a == arg1, InvalidArray()); require(var_a == var_d, InvalidArray()); bool flag0 = !(feeExemptCreators[msg.sender]); if (flatFee != 0) { } else { flag0 = flatFee; } uint256 value0 = msg.data[0] >> 0xe0; uint256 var_l; if (flag0) { require(msg.value >= flatFee, InvalidFlatFee()); (bool success0, bytes memory returnData0) = feeCollector.call{ value: flatFee }(""); // call if (returnData0.length == 0) { require(success0, FeeTransferFailed()); } else { if (!(returnData0.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_l + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f))) < var_l) | ((var_l + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_l = var_l + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData0.length))) + 0x1f)); require(success0, FeeTransferFailed()); } emit FeesCollected(address(0), 0, flatFee); } else { value0 = flatFee; } if (!(var_a <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_l + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_a << 0x05)) + 0x1f))) < var_l) | ((var_l + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_a << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_l = var_l + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_a << 0x05)) + 0x1f)); if (!(var_a <= 0xffffffffffffffff)) _desolexPanic(65); if (!(var_a <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_l + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_a << 0x05)) + 0x1f))) < var_l) | ((var_l + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_a << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_l = var_l + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (var_a << 0x05)) + 0x1f)); if (!(var_a <= 0xffffffffffffffff)) _desolexPanic(65); if (!(var_a <= 0xffffffffffffffff)) _desolexPanic(65); } function setCreatorFeeExempt(address account, bool enabled) public onlyOwner { feeExemptCreators[account] = enabled; emit CreatorFeeExemptionUpdated(account, feeExemptCreators[account]); } function createAirdropVesting(address token, (uint256,uint256,uint8)[] memory arg1, address[] memory arg2, bool arg3, bool arg4, bool arg5, bool arg6) public payable returns (bytes memory) { if ((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) >= 0xe0) { if (token == token) { if (!(arg1.length > 0xffffffffffffffff)) { if (((0x04 + arg1) + 0x1f) < msg.data.length) { if (!(arg1.length > 0xffffffffffffffff)) { if (!(((arg1.length * 0x60) + (0x04 + arg1) + 0x20) > msg.data.length)) { if (!(arg2.length > 0xffffffffffffffff)) { if (((0x04 + arg2) + 0x1f) < msg.data.length) { if (!(arg2.length > 0xffffffffffffffff)) { if (!(((arg2.length << 0x05) + (0x04 + arg2) + 0x20) > msg.data.length)) { if (arg3 == arg3) { if (arg4 == arg4) { if (arg5 == arg5) { if (arg6 == arg6) { if (stor_8 != 0x02) { stor_8 = 0x02; if (arg2 != 0x0) { if (!(0 < arg1.length)) { (bool success0, bytes memory returnData0) = address(0xb4123869ca90735bd2d9847b8a7dc60c36699dc3).getTotalAmount(0x20); // staticcall if (success0) { uint256 value1 = msg.data[0] >> 0xe0; uint256 var_c; uint256 value2 = var_c.length; if (success0) { uint256 value0 = returnData0.length; if (0x20 <= returnData0.length) { value0 = 0x20; } if (((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value0 + 0x1f))) < var_c) | ((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value0 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value0 + 0x1f)); require(((var_c + value0) - var_c) >= 0x20); } else { value1 = var_c; value2 = 0; } require(value2 != 0x0, InvalidAmount()); bool flag0 = !(feeExemptCreators[msg.sender]); if (!feeExemptTokens[token]) { } else { flag0 = !(feeExemptTokens[token]); } uint256 value3 = (value2 * feePercentage) / 0x2710; if ((flag0) && (feePercentage != 0x0)) { } else { value3 = 0; } bool flag2 = !(feeExemptTokens[token]); if (flatFee != 0) { } else { flag2 = flatFee; } bool flag3 = !(feeExemptCreators[msg.sender]); if (flag2) { } else { flag3 = flag2; } if (!(flag3)) { if (mapping_b[token] == 0) { mapping_f[token] = 0x0de0b6b3a7640000; if (((var_c + 0xa0) < var_c) | ((var_c + 0xa0) > 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + 0xa0; token.transferFrom(msg.sender, address(this), value2 * arg2.length); // call } else { (bool success2, bytes memory returnData2) = token.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf require(success2); uint256 value5 = this.code.length; uint256 value6 = var_c.length; if (success2) { uint256 value4 = returnData2.length; if (0x20 <= returnData2.length) { value4 = 0x20; } if (((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value4 + 0x1f))) < var_c) | ((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value4 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value4 + 0x1f)); require(((var_c + value4) - var_c) >= 0x20); } else { value5 = var_c; value6 = 0; } if (value6 == 0x0) { mapping_f[token] = 0x0de0b6b3a7640000; if (((var_c + 0xa0) < var_c) | ((var_c + 0xa0) > 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + 0xa0; (bool success3, bytes memory returnData3) = token.call(abi.encodeWithSelector(bytes4(0x23b872dd), msg.sender, address(this), value2 * arg2.length)); // call transferFrom uint256 value7 = 0x60; if ((returnData3.length) != 0x0) { if (returnData3.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData3.length))) + 0x1f))) < var_c) | ((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData3.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData3.length))) + 0x1f)); value7 = var_c; } if (!(success3)) { require(!var_o); revert FailedInnerCall(); } require(!(var_o == 0x0 && token.code.length == 0x0), AddressEmptyCode()); uint256 value8 = this.code.length; uint256 value9 = this.code.length; bool flag5 = !(var_p); if (!(!(var_q))) { require(!(value7 + var_q - value7 < 0x20)); require((!(!(var_p))) == var_p); } else { value8 = var_q; value9 = value7; flag5 = !(!(var_q)); } require(!(flag5), SafeERC20FailedOperation()); uint256 value13 = msg.data[0] >> 0xe0; uint256 value14 = msg.data[0] >> 0xe0; if (value3 != 0x0) { if (((var_c + 0x80) < var_c) | ((var_c + 0x80) > 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + 0x80; (bool success4, bytes memory returnData4) = token.call(abi.encodeWithSelector(bytes4(0xa9059cbb), address(feeCollector), (value3 * arg2.length))); // call transfer uint256 value10 = 0x60; if ((returnData4.length) != 0x0) { if (returnData4.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData4.length))) + 0x1f))) < var_c) | ((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData4.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData4.length))) + 0x1f)); value10 = var_c; } if (!(success4)) { require(!var_o); revert FailedInnerCall(); } require(!(var_o == 0x0 && address(token).code.length == 0x0), AddressEmptyCode()); uint256 value11 = this.code.length; uint256 value12 = this.code.length; bool flag7 = !(var_v); if (!(!(var_w))) { require(!(value10 + var_w - value10 < 0x20)); require((!(!(var_v))) == var_v); } else { value11 = var_w; value12 = value10; flag7 = !(!(var_w)); } require(!(flag7), SafeERC20FailedOperation()); emit FeesCollected(token, value3 * arg2.length, 0); } else { value13 = token; value14 = value3; } if (arg2.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f))) < var_c) | ((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f)); if (arg2.length > 0xffffffffffffffff) _desolexPanic(65); uint256 value15 = 0; while (true) { if (!(value15 < arg2.length)) { break; } if (!(value15 < arg2.length)) { _desolexPanic(50); break; } if ((value15 << 0x05) + (arg2 + 0x20) != (address((value15 << 0x05) + (arg2 + 0x20)))) { revert(); break; } if (token == address(0)) { revert InvalidToken(); break; } if (!(address((value15 << 0x05) + (arg2 + 0x20)))) { revert InvalidBeneficiary(); break; } if (value2 == value3) { revert InvalidAmount(); break; } if (nextVestingId == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) { _desolexPanic(17); break; } nextVestingId = 0x01 + nextVestingId; mapping_d[nextVestingId] = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & mapping_d[nextVestingId]) | token; stor_expr_bt = msg.sender; stor_expr_bu = (stor_expr_bu & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | (address((value15 << 0x05) + (arg2 + 0x20))); stor_expr_bv = value2 - value3; stor_expr_bw = (bytes1(arg3)) | (stor_expr_bw & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); stor_expr_bw = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff & stor_expr_bw) | ((arg4 << 0x08) & (0xff00)); stor_expr_bx = 0; stor_expr_bw = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff000000ffff & stor_expr_bw | ((arg6 << 0x18) & (0xff000000))) | 0; uint256 value16 = 0; while (true) { if (!(value16 < arg1.length)) { break; } if (!((value16 < arg1.length))) _desolexPanic(50); if (!(stor_expr_cp < 0x010000000000000000)) _desolexPanic(65); stor_expr_cp = stor_expr_cp + 0x01; if (!((stor_expr_cp < stor_expr_bz))) _desolexPanic(50); if (0) _desolexPanic(0); stor_expr_cq = msg.data[(0x60 * value16) + ((0x04 + arg1) + 0x20)]; stor_expr_cr = msg.data[((0x60 * value16) + ((0x04 + arg1) + 0x20)) + 0x20]; require(msg.data[0x40 + ((0x60 * value16) + ((0x04 + arg1) + 0x20))] < 0x04); stor_expr_cs = (bytes1(msg.data[0x40 + ((0x60 * value16) + ((0x04 + arg1) + 0x20))])) | (stor_expr_cs & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); value16 = value16 + 0x01; mapping_c[nextVestingId] = ((value2 - value3) * mapping_f[token]) / 0x0de0b6b3a7640000; mapping_b[token] = mapping_b[token] + ((value2 - value3) * mapping_f[token] / 0x0de0b6b3a7640000); uint256 value19 = this.code.length; if (arg4) { require(address((value15 << 0x05) + (arg2 + 0x20)), ERC721InvalidReceiver()); uint256 value54 = 0; flag8 = 0x0 != 0x0; if (address(array_2[nextVestingId]) != 0x0) { getApproved[nextVestingId] = address(0); balanceOf[address(array_2[nextVestingId])] = balanceOf[address(array_2[nextVestingId])] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if (address((value15 << 0x05) + (arg2 + 0x20)) != 0x0) { balanceOf[address((value15 << 0x05) + (arg2 + 0x20))] = balanceOf[address((value15 << 0x05) + (arg2 + 0x20))] + 0x01; } array_2[nextVestingId] = (address((value15 << 0x05) + (arg2 + 0x20))) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & array_2[nextVestingId]); emit Transfer(address(array_2[nextVestingId]), address((value15 << 0x05) + (arg2 + 0x20)), nextVestingId); } else { if (address((value15 << 0x05) + (arg2 + 0x20)) != 0x0) { balanceOf[address((value15 << 0x05) + (arg2 + 0x20))] = balanceOf[address((value15 << 0x05) + (arg2 + 0x20))] + 0x01; } array_2[nextVestingId] = (address((value15 << 0x05) + (arg2 + 0x20))) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & array_2[nextVestingId]); emit Transfer(address(array_2[nextVestingId]), address((value15 << 0x05) + (arg2 + 0x20)), nextVestingId); } if ((0xffffffffffffffffffffffffffffffffffffffff & mapping_2[nextVestingId] & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { require(mapping_e[nextVestingId], NonTransferableToken()); stor_expr_df = ((value15 << 0x05) + (arg2 + 0x20) & (0xffffffffffffffffffffffffffffffffffffffff)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_df); } require((!(address(array_2[nextVestingId]))), ERC721InvalidSender()); } else { value19 = (value15 << 0x05) + (arg2 + 0x20); } uint256 value20 = 0; uint256 value21 = (0x04 + arg1) + 0x20; uint256 value22 = (var_c + 0xa0) + 0x20; while (true) { mapping_e[nextVestingId] = arg5; if (!(value20 < arg1.length)) { break; } if (!(msg.data[value21 + 0x40] < 0x04)) { revert(); break; } if (!(((msg.data[value21 + 0x40]) < 0x04))) _desolexPanic(33); value20 = value20 + 0x01; value21 = value21 + 0x60; value22 = value22 + 0x60; } emit VestingCreated(nextVestingId, address((value15 << 0x05) + (arg2 + 0x20)), token, 0xa0, arg3, arg6, arg5, (arg1)); if (!(value15 < var_c.length)) { _desolexPanic(50); break; } value15 = value15 + 0x01; } } } else { if (value6 + 0x01 != 0) { mapping_f[token] = ((mapping_b[token] + 0x01) * 0x0de0b6b3a7640000) / (value6 + 0x01); if (((var_c + 0xa0) < var_c) | ((var_c + 0xa0) > 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + 0xa0; (bool success5, bytes memory returnData5) = token.call(abi.encodeWithSelector(bytes4(0x23b872dd), msg.sender, address(this), value2 * arg2.length)); // call transferFrom uint256 value29 = 0x60; if ((returnData5.length) != 0x0) { if (returnData5.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData5.length))) + 0x1f))) < var_c) | ((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData5.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData5.length))) + 0x1f)); value29 = var_c; } if (!(success5)) { require(!var_o); revert FailedInnerCall(); } require(!(var_o == 0x0 && token.code.length == 0x0), AddressEmptyCode()); uint256 value30 = this.code.length; uint256 value31 = this.code.length; bool flag11 = !(var_aj); if (!(!(var_ak))) { require(!(value29 + var_ak - value29 < 0x20)); require((!(!(var_aj))) == var_aj); } else { value30 = var_ak; value31 = value29; flag11 = !(!(var_ak)); } require(!(flag11), SafeERC20FailedOperation()); uint256 value35 = msg.data[0] >> 0xe0; uint256 value36 = msg.data[0] >> 0xe0; if (value3 != 0x0) { if (((var_c + 0x80) < var_c) | ((var_c + 0x80) > 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + 0x80; (bool success6, bytes memory returnData6) = token.call(abi.encodeWithSelector(bytes4(0xa9059cbb), address(feeCollector), (value3 * arg2.length))); // call transfer uint256 value32 = 0x60; if ((returnData6.length) != 0x0) { if (returnData6.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData6.length))) + 0x1f))) < var_c) | ((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData6.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData6.length))) + 0x1f)); value32 = var_c; } if (!(success6)) { require(!var_o); revert FailedInnerCall(); } require(!(var_o == 0x0 && address(token).code.length == 0x0), AddressEmptyCode()); uint256 value33 = this.code.length; uint256 value34 = this.code.length; bool flag13 = !(var_al); if (!(!(var_am))) { require(!(value32 + var_am - value32 < 0x20)); require((!(!(var_al))) == var_al); } else { value33 = var_am; value34 = value32; flag13 = !(!(var_am)); } require(!(flag13), SafeERC20FailedOperation()); emit FeesCollected(token, value3 * arg2.length, 0); } else { value35 = token; value36 = value3; } if (arg2.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f))) < var_c) | ((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f)); if (arg2.length > 0xffffffffffffffff) _desolexPanic(65); uint256 value15 = 0; while (true) { if (!(value15 < arg2.length)) { break; } if (!(value15 < arg2.length)) { _desolexPanic(50); break; } if ((value15 << 0x05) + (arg2 + 0x20) != (address((value15 << 0x05) + (arg2 + 0x20)))) { revert(); break; } if (token == address(0)) { revert InvalidToken(); break; } if (!(address((value15 << 0x05) + (arg2 + 0x20)))) { revert InvalidBeneficiary(); break; } if (value2 == value3) { revert InvalidAmount(); break; } if (nextVestingId == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) { _desolexPanic(17); break; } nextVestingId = 0x01 + nextVestingId; mapping_d[nextVestingId] = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & mapping_d[nextVestingId]) | token; stor_expr_bt = msg.sender; stor_expr_bu = (stor_expr_bu & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | (address((value15 << 0x05) + (arg2 + 0x20))); stor_expr_bv = value2 - value3; stor_expr_bw = (bytes1(arg3)) | (stor_expr_bw & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); stor_expr_bw = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff & stor_expr_bw) | ((arg4 << 0x08) & (0xff00)); stor_expr_bx = 0; stor_expr_bw = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff000000ffff & stor_expr_bw | ((arg6 << 0x18) & (0xff000000))) | 0; uint256 value16 = 0; while (true) { if (!(value16 < arg1.length)) { break; } if (!((value16 < arg1.length))) _desolexPanic(50); if (!(stor_expr_cp < 0x010000000000000000)) _desolexPanic(65); stor_expr_cp = stor_expr_cp + 0x01; if (!((stor_expr_cp < stor_expr_bz))) _desolexPanic(50); if (0) _desolexPanic(0); stor_expr_cq = msg.data[(0x60 * value16) + ((0x04 + arg1) + 0x20)]; stor_expr_cr = msg.data[((0x60 * value16) + ((0x04 + arg1) + 0x20)) + 0x20]; require(msg.data[0x40 + ((0x60 * value16) + ((0x04 + arg1) + 0x20))] < 0x04); stor_expr_cs = (bytes1(msg.data[0x40 + ((0x60 * value16) + ((0x04 + arg1) + 0x20))])) | (stor_expr_cs & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); value16 = value16 + 0x01; mapping_c[nextVestingId] = ((value2 - value3) * mapping_f[token]) / 0x0de0b6b3a7640000; mapping_b[token] = mapping_b[token] + ((value2 - value3) * mapping_f[token] / 0x0de0b6b3a7640000); uint256 value39 = this.code.length; if (arg4) { require(address((value15 << 0x05) + (arg2 + 0x20)), ERC721InvalidReceiver()); uint256 value55 = 0; flag14 = 0x0 != 0x0; if (address(array_2[nextVestingId]) != 0x0) { getApproved[nextVestingId] = address(0); balanceOf[address(array_2[nextVestingId])] = balanceOf[address(array_2[nextVestingId])] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if (address((value15 << 0x05) + (arg2 + 0x20)) != 0x0) { balanceOf[address((value15 << 0x05) + (arg2 + 0x20))] = balanceOf[address((value15 << 0x05) + (arg2 + 0x20))] + 0x01; } array_2[nextVestingId] = (address((value15 << 0x05) + (arg2 + 0x20))) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & array_2[nextVestingId]); emit Transfer(address(array_2[nextVestingId]), address((value15 << 0x05) + (arg2 + 0x20)), nextVestingId); } else { if (address((value15 << 0x05) + (arg2 + 0x20)) != 0x0) { balanceOf[address((value15 << 0x05) + (arg2 + 0x20))] = balanceOf[address((value15 << 0x05) + (arg2 + 0x20))] + 0x01; } array_2[nextVestingId] = (address((value15 << 0x05) + (arg2 + 0x20))) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & array_2[nextVestingId]); emit Transfer(address(array_2[nextVestingId]), address((value15 << 0x05) + (arg2 + 0x20)), nextVestingId); } if ((0xffffffffffffffffffffffffffffffffffffffff & mapping_2[nextVestingId] & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { require(mapping_e[nextVestingId], NonTransferableToken()); stor_expr_df = ((value15 << 0x05) + (arg2 + 0x20) & (0xffffffffffffffffffffffffffffffffffffffff)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_df); } require((!(address(array_2[nextVestingId]))), ERC721InvalidSender()); } else { value39 = (value15 << 0x05) + (arg2 + 0x20); } uint256 value20 = 0; uint256 value21 = (0x04 + arg1) + 0x20; uint256 value22 = (var_c + 0xa0) + 0x20; while (true) { mapping_e[nextVestingId] = arg5; if (!(value20 < arg1.length)) { break; } if (!(msg.data[value21 + 0x40] < 0x04)) { revert(); break; } if (!(((msg.data[value21 + 0x40]) < 0x04))) _desolexPanic(33); value20 = value20 + 0x01; value21 = value21 + 0x60; value22 = value22 + 0x60; } emit VestingCreated(nextVestingId, address((value15 << 0x05) + (arg2 + 0x20)), token, 0xa0, arg3, arg6, arg5, (arg1)); if (!(value15 < var_c.length)) { _desolexPanic(50); break; } value15 = value15 + 0x01; } } } else { mapping_f[token] = 0x0de0b6b3a7640000; if (((var_c + 0xa0) < var_c) | ((var_c + 0xa0) > 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + 0xa0; (bool success7, bytes memory returnData7) = token.call(abi.encodeWithSelector(bytes4(0x23b872dd), msg.sender, address(this), value2 * arg2.length)); // call transferFrom uint256 value40 = 0x60; if ((returnData7.length) != 0x0) { if (returnData7.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData7.length))) + 0x1f))) < var_c) | ((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData7.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData7.length))) + 0x1f)); value40 = var_c; } if (!(success7)) { require(!var_o); revert FailedInnerCall(); } require(!(var_o == 0x0 && token.code.length == 0x0), AddressEmptyCode()); uint256 value41 = this.code.length; uint256 value42 = this.code.length; bool flag17 = !(var_an); if (!(!(var_ao))) { require(!(value40 + var_ao - value40 < 0x20)); require((!(!(var_an))) == var_an); } else { value41 = var_ao; value42 = value40; flag17 = !(!(var_ao)); } require(!(flag17), SafeERC20FailedOperation()); uint256 value46 = msg.data[0] >> 0xe0; uint256 value47 = msg.data[0] >> 0xe0; if (value3 != 0x0) { if (((var_c + 0x80) < var_c) | ((var_c + 0x80) > 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + 0x80; (bool success8, bytes memory returnData8) = token.call(abi.encodeWithSelector(bytes4(0xa9059cbb), address(feeCollector), (value3 * arg2.length))); // call transfer uint256 value43 = 0x60; if ((returnData8.length) != 0x0) { if (returnData8.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData8.length))) + 0x1f))) < var_c) | ((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData8.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData8.length))) + 0x1f)); value43 = var_c; } if (!(success8)) { require(!var_o); revert FailedInnerCall(); } require(!(var_o == 0x0 && address(token).code.length == 0x0), AddressEmptyCode()); uint256 value44 = this.code.length; uint256 value45 = this.code.length; bool flag19 = !(var_ap); if (!(!(var_aq))) { require(!(value43 + var_aq - value43 < 0x20)); require((!(!(var_ap))) == var_ap); } else { value44 = var_aq; value45 = value43; flag19 = !(!(var_aq)); } require(!(flag19), SafeERC20FailedOperation()); emit FeesCollected(token, value3 * arg2.length, 0); } else { value46 = token; value47 = value3; } if (arg2.length > 0xffffffffffffffff) _desolexPanic(65); if (((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f))) < var_c) | ((var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_c = var_c + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (arg2.length << 0x05)) + 0x1f)); if (arg2.length > 0xffffffffffffffff) _desolexPanic(65); uint256 value15 = 0; while (true) { if (!(value15 < arg2.length)) { break; } if (!(value15 < arg2.length)) { _desolexPanic(50); break; } if ((value15 << 0x05) + (arg2 + 0x20) != (address((value15 << 0x05) + (arg2 + 0x20)))) { revert(); break; } if (token == address(0)) { revert InvalidToken(); break; } if (!(address((value15 << 0x05) + (arg2 + 0x20)))) { revert InvalidBeneficiary(); break; } if (value2 == value3) { revert InvalidAmount(); break; } if (nextVestingId == 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff) { _desolexPanic(17); break; } nextVestingId = 0x01 + nextVestingId; mapping_d[nextVestingId] = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & mapping_d[nextVestingId]) | token; stor_expr_bt = msg.sender; stor_expr_bu = (stor_expr_bu & (0xffffffffffffffffffffffff0000000000000000000000000000000000000000)) | (address((value15 << 0x05) + (arg2 + 0x20))); stor_expr_bv = value2 - value3; stor_expr_bw = (bytes1(arg3)) | (stor_expr_bw & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); stor_expr_bw = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff & stor_expr_bw) | ((arg4 << 0x08) & (0xff00)); stor_expr_bx = 0; stor_expr_bw = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff000000ffff & stor_expr_bw | ((arg6 << 0x18) & (0xff000000))) | 0; uint256 value16 = 0; while (true) { if (!(value16 < arg1.length)) { break; } if (!((value16 < arg1.length))) _desolexPanic(50); if (!(stor_expr_cp < 0x010000000000000000)) _desolexPanic(65); stor_expr_cp = stor_expr_cp + 0x01; if (!((stor_expr_cp < stor_expr_bz))) _desolexPanic(50); if (0) _desolexPanic(0); stor_expr_cq = msg.data[(0x60 * value16) + ((0x04 + arg1) + 0x20)]; stor_expr_cr = msg.data[((0x60 * value16) + ((0x04 + arg1) + 0x20)) + 0x20]; require(msg.data[0x40 + ((0x60 * value16) + ((0x04 + arg1) + 0x20))] < 0x04); stor_expr_cs = (bytes1(msg.data[0x40 + ((0x60 * value16) + ((0x04 + arg1) + 0x20))])) | (stor_expr_cs & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); value16 = value16 + 0x01; mapping_c[nextVestingId] = ((value2 - value3) * mapping_f[token]) / 0x0de0b6b3a7640000; mapping_b[token] = mapping_b[token] + ((value2 - value3) * mapping_f[token] / 0x0de0b6b3a7640000); uint256 value50 = this.code.length; if (arg4) { require(address((value15 << 0x05) + (arg2 + 0x20)), ERC721InvalidReceiver()); uint256 value56 = 0; flag20 = 0x0 != 0x0; if (address(array_2[nextVestingId]) != 0x0) { getApproved[nextVestingId] = address(0); balanceOf[address(array_2[nextVestingId])] = balanceOf[address(array_2[nextVestingId])] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if (address((value15 << 0x05) + (arg2 + 0x20)) != 0x0) { balanceOf[address((value15 << 0x05) + (arg2 + 0x20))] = balanceOf[address((value15 << 0x05) + (arg2 + 0x20))] + 0x01; } array_2[nextVestingId] = (address((value15 << 0x05) + (arg2 + 0x20))) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & array_2[nextVestingId]); emit Transfer(address(array_2[nextVestingId]), address((value15 << 0x05) + (arg2 + 0x20)), nextVestingId); } else { if (address((value15 << 0x05) + (arg2 + 0x20)) != 0x0) { balanceOf[address((value15 << 0x05) + (arg2 + 0x20))] = balanceOf[address((value15 << 0x05) + (arg2 + 0x20))] + 0x01; } array_2[nextVestingId] = (address((value15 << 0x05) + (arg2 + 0x20))) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & array_2[nextVestingId]); emit Transfer(address(array_2[nextVestingId]), address((value15 << 0x05) + (arg2 + 0x20)), nextVestingId); } if ((0xffffffffffffffffffffffffffffffffffffffff & mapping_2[nextVestingId] & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { require(mapping_e[nextVestingId], NonTransferableToken()); stor_expr_df = ((value15 << 0x05) + (arg2 + 0x20) & (0xffffffffffffffffffffffffffffffffffffffff)) | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_df); } require((!(address(array_2[nextVestingId]))), ERC721InvalidSender()); } else { value50 = (value15 << 0x05) + (arg2 + 0x20); } uint256 value20 = 0; uint256 value21 = (0x04 + arg1) + 0x20; uint256 value22 = (var_c + 0xa0) + 0x20; while (true) { mapping_e[nextVestingId] = arg5; if (!(value20 < arg1.length)) { break; } if (!(msg.data[value21 + 0x40] < 0x04)) { revert(); break; } if (!(((msg.data[value21 + 0x40]) < 0x04))) _desolexPanic(33); value20 = value20 + 0x01; value21 = value21 + 0x60; value22 = value22 + 0x60; } emit VestingCreated(nextVestingId, address((value15 << 0x05) + (arg2 + 0x20)), token, 0xa0, arg3, arg6, arg5, (arg1)); if (!(value15 < var_c.length)) { _desolexPanic(50); break; } value15 = value15 + 0x01; } } } } uint256 value23 = 0; uint256 value24 = var_c + 0x20; uint256 value25 = (var_c + 0x40) + 0x20; while (true) { if (value23 >= var_c.length) { break; } value23 = 0x01 + value23; value24 = value24 + 0x20; value25 = 0x20 + value25; } uint256 value26 = 0; uint256 value27 = (0x04 + arg2) + 0x20; uint256 value28 = ((var_c + 0x40) + 0x20) + 0x20; while (true) { if (!(value26 < arg2.length)) { break; } if (msg.data[value27] != (address(msg.data[value27]))) { revert(); break; } value26 = 0x01 + value26; value27 = value27 + 0x20; value28 = 0x20 + value28; } value23 = 0; value24 = var_c + 0x20; value25 = (var_c + 0x20) + 0x20; while (true) { emit AirdropVestingCreated(0x40, value25 - var_c, var_c.length, (arg2)); stor_8 = 0x01; if (value23 >= var_c.length) { return abi.encodePacked(0x20, var_c.length); } value23 = 0x01 + value23; value24 = value24 + 0x20; value25 = 0x20 + value25; } } } } } } } } } } } } } } } } } } } } } } function transferVesting(uint256 arg0, address arg1) public { require(arg1 != address(0), InvalidBeneficiary()); require(msg.sender == stor_expr_ai, NotAuthorized()); uint256 value0 = msg.data[0] >> 0xe0; if (bytes1(stor_expr_c >> 0x08) != 0x0) { if (address(array_2[arg0]) != 0x0) { getApproved[arg0] = address(0); balanceOf[address(array_2[arg0])] = balanceOf[address(array_2[arg0])] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; } if (arg1 != address(0)) { balanceOf[arg1] = balanceOf[arg1] + 0x01; } array_2[arg0] = arg1 | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & array_2[arg0]); emit Transfer(address(array_2[arg0]), arg1, arg0); } else { value0 = arg1; } stor_expr_ai = arg1; emit VestingTransferred(arg0, msg.sender, stor_expr_ai); } function createVesting(address arg0, (uint256,uint256,uint8)[] memory arg1, address arg2, bool arg3, bool arg4, bool arg5, bool arg6) public payable returns (uint256) { if ((0xfffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc + msg.data.length) >= 0xe0) { if (arg0 == arg0) { address var_a = arg0; if (!(arg1.length > 0xffffffffffffffff)) { if (((0x04 + arg1) + 0x1f) < msg.data.length) { if (!(arg1.length > 0xffffffffffffffff)) { if (!(((arg1.length * 0x60) + (0x04 + arg1) + 0x20) > msg.data.length)) { if (arg2 == arg2) { if (arg3 == arg3) { if (arg4 == arg4) { if (arg5 == arg5) { if (arg6 == arg6) { if (stor_8 != 0x02) { stor_8 = 0x02; if (address(var_a)) { require(arg2 != address(0), InvalidBeneficiary()); if (mapping_b[address(var_a)] != 0) { (bool success0, bytes memory returnData0) = var_a.staticcall(abi.encodeWithSelector(bytes4(0x70a08231), address(this))); // staticcall balanceOf if (success0) { uint256 value1 = this.code.length; uint256 var_f; uint256 value2 = var_f.length; if (success0) { uint256 value0 = returnData0.length; if (0x20 <= returnData0.length) { value0 = 0x20; } if (((var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value0 + 0x1f))) < var_f) | ((var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value0 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_f = var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value0 + 0x1f)); require(((var_f + value0) - var_f) >= 0x20); } else { value1 = var_f; value2 = 0; } if (value2 == 0x0) { uint256 value3 = 0; uint256 value4 = (0x04 + arg1) + 0x20; uint256 value5 = (var_f + 0x24) + 0x20; while (true) { mapping_f[address(var_a)] = 0x0de0b6b3a7640000; if (!(value3 < arg1.length)) { break; } if (!(msg.data[value4 + 0x40] < 0x04)) { revert(); break; } if (!(msg.data[value4 + 0x40] < 0x04)) _desolexPanic(33); value3 = value3 + 0x01; value4 = value4 + 0x60; value5 = value5 + 0x60; } (bool success1, bytes memory returnData1) = address(0xb4123869ca90735bd2d9847b8a7dc60c36699dc3).getTotalAmount(0x20); // staticcall require(success1); uint256 value7 = msg.data[0] >> 0xe0; uint256 value8 = var_f.length; if (success1) { uint256 value6 = returnData1.length; if (0x20 <= returnData1.length) { value6 = 0x20; } if (((var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value6 + 0x1f))) < var_f) | ((var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value6 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_f = var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value6 + 0x1f)); require(((var_f + value6) - var_f) >= 0x20); } else { value7 = var_f; value8 = 0; } require(value8 != 0x0, InvalidAmount()); bool flag0 = !(feeExemptCreators[msg.sender]); if (!feeExemptTokens[address(var_a)]) { } else { flag0 = !(feeExemptTokens[address(var_a)]); } bool flag1 = !(feeExemptTokens[address(var_a)]); if (flatFee != 0) { } else { flag1 = flatFee; } bool flag3 = !(feeExemptCreators[msg.sender]); if (flag1) { } else { flag3 = flag1; } uint256 value9 = (value8 * feePercentage) / 0x2710; if ((flag0) && (feePercentage != 0x0)) { } else { value9 = 0; } uint256 value10 = msg.data[0] >> 0xe0; uint256 value11 = flatFee; if (!(flag3)) { value10 = flatFee; value11 = 0; } if (((var_f + 0xa0) < var_f) | ((var_f + 0xa0) > 0xffffffffffffffff)) _desolexPanic(65); var_f = var_f + 0xa0; (bool success2, bytes memory returnData2) = var_a.call(abi.encodeWithSelector(bytes4(0x23b872dd), msg.sender, address(this), value8)); // call transferFrom uint256 value12 = 0x60; if ((returnData2.length) != 0x0) { if (!(returnData2.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData2.length))) + 0x1f))) < var_f) | ((var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData2.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_f = var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData2.length))) + 0x1f)); value12 = var_f; } if (!(success2)) { require(!var_p); revert FailedInnerCall(); } require(!(var_p == 0x0 && address(var_a).code.length == 0x0), AddressEmptyCode()); uint256 value13 = this.code.length; uint256 value14 = this.code.length; bool flag5 = !(var_q); if (!(!(var_r))) { require(!(value12 + var_s - value12 < 0x20)); require((!(!(var_q))) == var_q); } else { value13 = var_r; value14 = value12; flag5 = !(!(var_r)); } require(!(flag5), SafeERC20FailedOperation()); if (value9 != 0x0) { if (((var_f + 0x80) < var_f) | ((var_f + 0x80) > 0xffffffffffffffff)) _desolexPanic(65); var_f = var_f + 0x80; (bool success3, bytes memory returnData3) = var_a.call(abi.encodeWithSelector(bytes4(0xa9059cbb), address(feeCollector), value9)); // call transfer uint256 value15 = 0x60; if ((returnData3.length) != 0x0) { if (!(returnData3.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData3.length))) + 0x1f))) < var_f) | ((var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData3.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_f = var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData3.length))) + 0x1f)); value15 = var_f; } if (!(success3)) { require(!var_p); revert FailedInnerCall(); } require(!(var_p == 0x0 && address(var_a).code.length == 0x0), AddressEmptyCode()); uint256 value16 = this.code.length; uint256 value17 = this.code.length; bool flag7 = !(var_x); if (!(!(var_y))) { require(!(value15 + var_y - value15 < 0x20)); require((!(!(var_x))) == var_x); } else { value16 = var_y; value17 = value15; flag7 = !(!(var_y)); } require(!(flag7), SafeERC20FailedOperation()); emit FeesCollected(address(var_a), value9, 0); } if (value11 != 0x0) { require(msg.value >= value11, InvalidFlatFee()); (bool success4, bytes memory returnData4) = feeCollector.call{ value: value11 }(""); // call uint256 var_ab; if (returnData4.length == 0) { require(success4, FeeTransferFailed()); emit FeesCollected(address(var_a), 0, value11); var_ab = value8 - value9; var_ac = nextVestingId; nextVestingId = 0x01 + var_ac; mapping_d[var_ac] = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & mapping_d[var_ac]) | (0xffffffffffffffffffffffffffffffffffffffff & var_a); stor_expr_dn = msg.sender; stor_expr_do = arg2; stor_expr_dp = var_ab; stor_expr_dq = (bytes1(arg3)) | (stor_expr_dq & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); stor_expr_dq = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff & stor_expr_dq) | ((arg4 << 0x08) & (0xff00)); stor_expr_dr = 0; if (!((0 < 0x01))) _desolexPanic(33); stor_expr_dq = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff000000ffff & stor_expr_dq | ((arg6 << 0x18) & (0xff000000))) | 0; uint256 value18 = 0; while (true) { if (!(value18 < arg1.length)) { break; } if (!((value18 < arg1.length))) _desolexPanic(50); if (!(stor_expr_ds < 0x010000000000000000)) _desolexPanic(65); stor_expr_ds = stor_expr_ds + 0x01; if (!((stor_expr_ds < stor_expr_bz))) _desolexPanic(50); if (0) _desolexPanic(0); stor_expr_dt = msg.data[(0x60 * value18) + ((0x04 + arg1) + 0x20)]; stor_expr_du = msg.data[((0x60 * value18) + ((0x04 + arg1) + 0x20)) + 0x20]; require(msg.data[0x40 + ((0x60 * value18) + ((0x04 + arg1) + 0x20))] < 0x04); stor_expr_dv = (bytes1(msg.data[0x40 + ((0x60 * value18) + ((0x04 + arg1) + 0x20))])) | (stor_expr_dv & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); value18 = value18 + 0x01; mapping_c[var_ac] = (var_ab * mapping_f[address(var_a)]) / 0x0de0b6b3a7640000; mapping_b[address(var_a)] = mapping_b[address(var_a)] + ((var_ab * mapping_f[address(var_a)]) / 0x0de0b6b3a7640000); if (arg4) { require(arg2 != address(0), ERC721InvalidReceiver()); uint256 value43 = 0; flag8 = 0x0 != 0x0; if (address(array_2[var_ac]) != 0x0) { getApproved[var_ac] = address(0); balanceOf[address(array_2[var_ac])] = balanceOf[address(array_2[var_ac])] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if (arg2 != address(0)) { balanceOf[arg2] = balanceOf[arg2] + 0x01; } array_2[var_ac] = arg2 | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & array_2[var_ac]); emit Transfer(address(array_2[var_ac]), arg2, var_ac); } else { if (arg2 != address(0)) { balanceOf[arg2] = balanceOf[arg2] + 0x01; } array_2[var_ac] = arg2 | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & array_2[var_ac]); emit Transfer(address(array_2[var_ac]), arg2, var_ac); } if ((0xffffffffffffffffffffffffffffffffffffffff & mapping_2[var_af] & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { require(mapping_e[var_ac], NonTransferableToken()); stor_expr_eg = arg2; } require((!(address(array_2[var_ac]))), ERC721InvalidSender()); } uint256 value3 = 0; uint256 value4 = (0x04 + arg1) + 0x20; uint256 value5 = (var_f + 0xa0) + 0x20; while (true) { mapping_e[var_ac] = arg5; if (!(value3 < arg1.length)) { break; } if (!(msg.data[value4 + 0x40] < 0x04)) { revert(); break; } if (!(msg.data[value4 + 0x40] < 0x04)) _desolexPanic(33); value3 = value3 + 0x01; value4 = value4 + 0x60; value5 = value5 + 0x60; } emit VestingCreated(var_ac, arg2, address(var_a), 0xa0, arg3, arg6, arg5, (arg1)); stor_8 = 0x01; return var_ac; } } else { if (!(returnData4.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData4.length))) + 0x1f))) < var_f) | ((var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData4.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_f = var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData4.length))) + 0x1f)); require(success4, FeeTransferFailed()); emit FeesCollected(address(var_a), 0, value11); var_ab = value8 - value9; var_ac = nextVestingId; nextVestingId = 0x01 + var_ac; mapping_d[var_ac] = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & mapping_d[var_ac]) | (0xffffffffffffffffffffffffffffffffffffffff & var_a); stor_expr_dn = msg.sender; stor_expr_do = arg2; stor_expr_dp = var_ab; stor_expr_dq = (bytes1(arg3)) | (stor_expr_dq & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); stor_expr_dq = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff & stor_expr_dq) | ((arg4 << 0x08) & (0xff00)); stor_expr_dr = 0; if (!((0 < 0x01))) _desolexPanic(33); stor_expr_dq = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff000000ffff & stor_expr_dq | ((arg6 << 0x18) & (0xff000000))) | 0; uint256 value18 = 0; while (true) { if (!(value18 < arg1.length)) { break; } if (!((value18 < arg1.length))) _desolexPanic(50); if (!(stor_expr_ds < 0x010000000000000000)) _desolexPanic(65); stor_expr_ds = stor_expr_ds + 0x01; if (!((stor_expr_ds < stor_expr_bz))) _desolexPanic(50); if (0) _desolexPanic(0); stor_expr_dt = msg.data[(0x60 * value18) + ((0x04 + arg1) + 0x20)]; stor_expr_du = msg.data[((0x60 * value18) + ((0x04 + arg1) + 0x20)) + 0x20]; require(msg.data[0x40 + ((0x60 * value18) + ((0x04 + arg1) + 0x20))] < 0x04); stor_expr_dv = (bytes1(msg.data[0x40 + ((0x60 * value18) + ((0x04 + arg1) + 0x20))])) | (stor_expr_dv & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); value18 = value18 + 0x01; mapping_c[var_ac] = (var_ab * mapping_f[address(var_a)]) / 0x0de0b6b3a7640000; mapping_b[address(var_a)] = mapping_b[address(var_a)] + ((var_ab * mapping_f[address(var_a)]) / 0x0de0b6b3a7640000); if (arg4) { require(arg2 != address(0), ERC721InvalidReceiver()); uint256 value44 = 0; flag10 = 0x0 != 0x0; if (address(array_2[var_ac]) != 0x0) { getApproved[var_ac] = address(0); balanceOf[address(array_2[var_ac])] = balanceOf[address(array_2[var_ac])] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if (arg2 != address(0)) { balanceOf[arg2] = balanceOf[arg2] + 0x01; } array_2[var_ac] = arg2 | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & array_2[var_ac]); emit Transfer(address(array_2[var_ac]), arg2, var_ac); } else { if (arg2 != address(0)) { balanceOf[arg2] = balanceOf[arg2] + 0x01; } array_2[var_ac] = arg2 | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & array_2[var_ac]); emit Transfer(address(array_2[var_ac]), arg2, var_ac); } if ((0xffffffffffffffffffffffffffffffffffffffff & mapping_2[var_af] & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { require(mapping_e[var_ac], NonTransferableToken()); stor_expr_eg = arg2; } require((!(address(array_2[var_ac]))), ERC721InvalidSender()); } uint256 value3 = 0; uint256 value4 = (0x04 + arg1) + 0x20; uint256 value5 = (var_f + 0xa0) + 0x20; while (true) { mapping_e[var_ac] = arg5; if (!(value3 < arg1.length)) { break; } if (!(msg.data[value4 + 0x40] < 0x04)) { revert(); break; } if (!(msg.data[value4 + 0x40] < 0x04)) _desolexPanic(33); value3 = value3 + 0x01; value4 = value4 + 0x60; value5 = value5 + 0x60; } emit VestingCreated(var_ac, arg2, address(var_a), 0xa0, arg3, arg6, arg5, (arg1)); stor_8 = 0x01; return var_ac; } } } else { var_ab = value8 - value9; var_ac = nextVestingId; nextVestingId = 0x01 + var_ac; mapping_d[var_ac] = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & mapping_d[var_ac]) | (0xffffffffffffffffffffffffffffffffffffffff & var_a); stor_expr_dn = msg.sender; stor_expr_do = arg2; stor_expr_dp = var_ab; stor_expr_dq = (bytes1(arg3)) | (stor_expr_dq & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); stor_expr_dq = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff & stor_expr_dq) | ((arg4 << 0x08) & (0xff00)); stor_expr_dr = 0; if (!((0 < 0x01))) _desolexPanic(33); stor_expr_dq = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff000000ffff & stor_expr_dq | ((arg6 << 0x18) & (0xff000000))) | 0; uint256 value18 = 0; while (true) { if (!(value18 < arg1.length)) { break; } if (!((value18 < arg1.length))) _desolexPanic(50); if (!(stor_expr_ds < 0x010000000000000000)) _desolexPanic(65); stor_expr_ds = stor_expr_ds + 0x01; if (!((stor_expr_ds < stor_expr_bz))) _desolexPanic(50); if (0) _desolexPanic(0); stor_expr_dt = msg.data[(0x60 * value18) + ((0x04 + arg1) + 0x20)]; stor_expr_du = msg.data[((0x60 * value18) + ((0x04 + arg1) + 0x20)) + 0x20]; require(msg.data[0x40 + ((0x60 * value18) + ((0x04 + arg1) + 0x20))] < 0x04); stor_expr_dv = (bytes1(msg.data[0x40 + ((0x60 * value18) + ((0x04 + arg1) + 0x20))])) | (stor_expr_dv & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); value18 = value18 + 0x01; mapping_c[var_ac] = (var_ab * mapping_f[address(var_a)]) / 0x0de0b6b3a7640000; mapping_b[address(var_a)] = mapping_b[address(var_a)] + ((var_ab * mapping_f[address(var_a)]) / 0x0de0b6b3a7640000); if (arg4) { require(arg2 != address(0), ERC721InvalidReceiver()); uint256 value45 = 0; flag12 = 0x0 != 0x0; if (address(array_2[var_ac]) != 0x0) { getApproved[var_ac] = address(0); balanceOf[address(array_2[var_ac])] = balanceOf[address(array_2[var_ac])] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if (arg2 != address(0)) { balanceOf[arg2] = balanceOf[arg2] + 0x01; } array_2[var_ac] = arg2 | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & array_2[var_ac]); emit Transfer(address(array_2[var_ac]), arg2, var_ac); } else { if (arg2 != address(0)) { balanceOf[arg2] = balanceOf[arg2] + 0x01; } array_2[var_ac] = arg2 | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & array_2[var_ac]); emit Transfer(address(array_2[var_ac]), arg2, var_ac); } if ((0xffffffffffffffffffffffffffffffffffffffff & mapping_2[var_af] & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { require(mapping_e[var_ac], NonTransferableToken()); stor_expr_eg = arg2; } require((!(address(array_2[var_ac]))), ERC721InvalidSender()); } uint256 value3 = 0; uint256 value4 = (0x04 + arg1) + 0x20; uint256 value5 = (var_f + 0xa0) + 0x20; while (true) { mapping_e[var_ac] = arg5; if (!(value3 < arg1.length)) { break; } if (!(msg.data[value4 + 0x40] < 0x04)) { revert(); break; } if (!(msg.data[value4 + 0x40] < 0x04)) _desolexPanic(33); value3 = value3 + 0x01; value4 = value4 + 0x60; value5 = value5 + 0x60; } emit VestingCreated(var_ac, arg2, address(var_a), 0xa0, arg3, arg6, arg5, (arg1)); stor_8 = 0x01; return var_ac; } } } else { if (value2 <= (value2 + 0x01)) { if (value2 + 0x01 == 0) { uint256 value3 = 0; uint256 value4 = (0x04 + arg1) + 0x20; uint256 value5 = (var_f + 0x24) + 0x20; while (true) { mapping_f[address(var_a)] = 0x0de0b6b3a7640000; if (!(value3 < arg1.length)) { (bool success5, bytes memory returnData5) = address(0xb4123869ca90735bd2d9847b8a7dc60c36699dc3).getTotalAmount(0x20); // staticcall if (success5) { uint256 value26 = msg.data[0] >> 0xe0; uint256 value27 = var_f.length; if (success5) { uint256 value25 = returnData5.length; if (0x20 <= returnData5.length) { value25 = 0x20; } if (((var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value25 + 0x1f))) < var_f) | ((var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value25 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_f = var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value25 + 0x1f)); require(((var_f + value25) - var_f) >= 0x20); } else { value26 = var_f; value27 = 0; } require(value27 != 0x0, InvalidAmount()); bool flag14 = !(feeExemptCreators[msg.sender]); if (!feeExemptTokens[address(var_a)]) { } else { flag14 = !(feeExemptTokens[address(var_a)]); } bool flag15 = !(feeExemptTokens[address(var_a)]); if (flatFee != 0) { } else { flag15 = flatFee; } bool flag17 = !(feeExemptCreators[msg.sender]); if (flag15) { } else { flag17 = flag15; } uint256 value28 = (value27 * feePercentage) / 0x2710; if ((flag14) && (feePercentage != 0x0)) { } else { value28 = 0; } uint256 value29 = msg.data[0] >> 0xe0; uint256 value30 = flatFee; if (!(flag17)) { value29 = flatFee; value30 = 0; } if (((var_f + 0xa0) < var_f) | ((var_f + 0xa0) > 0xffffffffffffffff)) _desolexPanic(65); var_f = var_f + 0xa0; (bool success6, bytes memory returnData6) = var_a.call(abi.encodeWithSelector(bytes4(0x23b872dd), msg.sender, address(this), value27)); // call transferFrom uint256 value31 = 0x60; if ((returnData6.length) != 0x0) { if (!(returnData6.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData6.length))) + 0x1f))) < var_f) | ((var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData6.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_f = var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData6.length))) + 0x1f)); value31 = var_f; } if (!(success6)) { require(!var_p); revert FailedInnerCall(); } require(!(var_p == 0x0 && address(var_a).code.length == 0x0), AddressEmptyCode()); uint256 value32 = this.code.length; uint256 value33 = this.code.length; bool flag19 = !(var_ao); if (!(!(var_ap))) { require(!(value31 + var_aq - value31 < 0x20)); require((!(!(var_ao))) == var_ao); } else { value32 = var_ap; value33 = value31; flag19 = !(!(var_ap)); } require(!(flag19), SafeERC20FailedOperation()); if (value28 != 0x0) { if (((var_f + 0x80) < var_f) | ((var_f + 0x80) > 0xffffffffffffffff)) _desolexPanic(65); var_f = var_f + 0x80; (bool success7, bytes memory returnData7) = var_a.call(abi.encodeWithSelector(bytes4(0xa9059cbb), address(feeCollector), value28)); // call transfer uint256 value34 = 0x60; if ((returnData7.length) != 0x0) { if (!(returnData7.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData7.length))) + 0x1f))) < var_f) | ((var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData7.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_f = var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData7.length))) + 0x1f)); value34 = var_f; } if (!(success7)) { require(!var_p); revert FailedInnerCall(); } require(!(var_p == 0x0 && address(var_a).code.length == 0x0), AddressEmptyCode()); uint256 value35 = this.code.length; uint256 value36 = this.code.length; bool flag21 = !(var_ar); if (!(!(var_as))) { require(!(value34 + var_as - value34 < 0x20)); require((!(!(var_ar))) == var_ar); } else { value35 = var_as; value36 = value34; flag21 = !(!(var_as)); } require(!(flag21), SafeERC20FailedOperation()); emit FeesCollected(address(var_a), value28, 0); } if (value30 != 0x0) { require(msg.value >= value30, InvalidFlatFee()); (bool success8, bytes memory returnData8) = feeCollector.call{ value: value30 }(""); // call if (returnData8.length != 0x0) { if (!(returnData8.length <= 0xffffffffffffffff)) _desolexPanic(65); if (((var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData8.length))) + 0x1f))) < var_f) | ((var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData8.length))) + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_f = var_f + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & ((0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (0x1f + returnData8.length))) + 0x1f)); require(success8, FeeTransferFailed()); emit FeesCollected(address(var_a), 0, value30); var_ab = value27 - value28; var_ac = nextVestingId; nextVestingId = 0x01 + var_ac; mapping_d[var_ac] = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & mapping_d[var_ac]) | (0xffffffffffffffffffffffffffffffffffffffff & var_a); stor_expr_dn = msg.sender; stor_expr_do = arg2; stor_expr_dp = var_ab; stor_expr_dq = (bytes1(arg3)) | (stor_expr_dq & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); stor_expr_dq = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff & stor_expr_dq) | ((arg4 << 0x08) & (0xff00)); stor_expr_dr = 0; stor_expr_dq = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff000000ffff & stor_expr_dq | ((arg6 << 0x18) & (0xff000000))) | 0; uint256 value18 = 0; while (true) { if (!(value18 < arg1.length)) { break; } if (!((value18 < arg1.length))) _desolexPanic(50); if (!(stor_expr_ds < 0x010000000000000000)) _desolexPanic(65); stor_expr_ds = stor_expr_ds + 0x01; if (!((stor_expr_ds < stor_expr_bz))) _desolexPanic(50); if (0) _desolexPanic(0); stor_expr_dt = msg.data[(0x60 * value18) + ((0x04 + arg1) + 0x20)]; stor_expr_du = msg.data[((0x60 * value18) + ((0x04 + arg1) + 0x20)) + 0x20]; require(msg.data[0x40 + ((0x60 * value18) + ((0x04 + arg1) + 0x20))] < 0x04); stor_expr_dv = (bytes1(msg.data[0x40 + ((0x60 * value18) + ((0x04 + arg1) + 0x20))])) | (stor_expr_dv & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); value18 = value18 + 0x01; mapping_c[var_ac] = (var_ab * mapping_f[address(var_a)]) / 0x0de0b6b3a7640000; mapping_b[address(var_a)] = mapping_b[address(var_a)] + ((var_ab * mapping_f[address(var_a)]) / 0x0de0b6b3a7640000); if (arg4) { require(arg2 != address(0), ERC721InvalidReceiver()); } else { uint256 value3 = 0; uint256 value4 = (0x04 + arg1) + 0x20; uint256 value5 = (var_f + 0xa0) + 0x20; while (true) { mapping_e[var_ac] = arg5; if (!(value3 < arg1.length)) { break; } if (!(msg.data[value4 + 0x40] < 0x04)) { revert(); break; } if (!(msg.data[value4 + 0x40] < 0x04)) _desolexPanic(33); value3 = value3 + 0x01; value4 = value4 + 0x60; value5 = value5 + 0x60; } emit VestingCreated(var_ac, arg2, address(var_a), 0xa0, arg3, arg6, arg5, (arg1)); stor_8 = 0x01; return var_ac; } } } } else { var_ab = value27 - value28; var_ac = nextVestingId; nextVestingId = 0x01 + var_ac; mapping_d[var_ac] = (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & mapping_d[var_ac]) | (0xffffffffffffffffffffffffffffffffffffffff & var_a); stor_expr_dn = msg.sender; stor_expr_do = arg2; stor_expr_dp = var_ab; stor_expr_dq = (bytes1(arg3)) | (stor_expr_dq & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); stor_expr_dq = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00ff & stor_expr_dq) | ((arg4 << 0x08) & (0xff00)); stor_expr_dr = 0; if (!((0 < 0x01))) _desolexPanic(33); stor_expr_dq = (0xffffffffffffffffffffffffffffffffffffffffffffffffffffff000000ffff & stor_expr_dq | ((arg6 << 0x18) & (0xff000000))) | 0; uint256 value18 = 0; while (true) { if (!(value18 < arg1.length)) { break; } if (!((value18 < arg1.length))) _desolexPanic(50); if (!(stor_expr_ds < 0x010000000000000000)) _desolexPanic(65); stor_expr_ds = stor_expr_ds + 0x01; if (!((stor_expr_ds < stor_expr_bz))) _desolexPanic(50); if (0) _desolexPanic(0); stor_expr_dt = msg.data[(0x60 * value18) + ((0x04 + arg1) + 0x20)]; stor_expr_du = msg.data[((0x60 * value18) + ((0x04 + arg1) + 0x20)) + 0x20]; require(msg.data[0x40 + ((0x60 * value18) + ((0x04 + arg1) + 0x20))] < 0x04); stor_expr_dv = (bytes1(msg.data[0x40 + ((0x60 * value18) + ((0x04 + arg1) + 0x20))])) | (stor_expr_dv & (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff00)); value18 = value18 + 0x01; mapping_c[var_ac] = (var_ab * mapping_f[address(var_a)]) / 0x0de0b6b3a7640000; mapping_b[address(var_a)] = mapping_b[address(var_a)] + ((var_ab * mapping_f[address(var_a)]) / 0x0de0b6b3a7640000); if (arg4) { require(arg2 != address(0), ERC721InvalidReceiver()); uint256 value46 = 0; flag22 = 0x0 != 0x0; if (address(array_2[var_ac]) != 0x0) { getApproved[var_ac] = address(0); balanceOf[address(array_2[var_ac])] = balanceOf[address(array_2[var_ac])] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if (arg2 != address(0)) { balanceOf[arg2] = balanceOf[arg2] + 0x01; } array_2[var_ac] = arg2 | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & array_2[var_ac]); emit Transfer(address(array_2[var_ac]), arg2, var_ac); } else { if (arg2 != address(0)) { balanceOf[arg2] = balanceOf[arg2] + 0x01; } array_2[var_ac] = arg2 | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & array_2[var_ac]); emit Transfer(address(array_2[var_ac]), arg2, var_ac); } if ((0xffffffffffffffffffffffffffffffffffffffff & mapping_2[var_af] & 0xffffffffffffffffffffffffffffffffffffffff) != 0x0) { require(mapping_e[var_ac], NonTransferableToken()); stor_expr_eg = arg2; } require((!(address(array_2[var_ac]))), ERC721InvalidSender()); } uint256 value3 = 0; uint256 value4 = (0x04 + arg1) + 0x20; uint256 value5 = (var_f + 0xa0) + 0x20; while (true) { mapping_e[var_ac] = arg5; if (!(value3 < arg1.length)) { break; } if (!(msg.data[value4 + 0x40] < 0x04)) { revert(); break; } if (!(msg.data[value4 + 0x40] < 0x04)) _desolexPanic(33); value3 = value3 + 0x01; value4 = value4 + 0x60; value5 = value5 + 0x60; } emit VestingCreated(var_ac, arg2, address(var_a), 0xa0, arg3, arg6, arg5, (arg1)); stor_8 = 0x01; return var_ac; } } } } } } } } } } } } } } } } } } } } } } } } function approve(address spender, uint256 amount) public { require(address(array_2[amount]), ERC721NonexistentToken()); bool flag0 = !(msg.sender == (address(array_2[amount]))); if (!msg.sender) { flag0 = msg.sender != address(0); } bool flag1 = !(bytes1(isApprovedForAll[address(array_2[amount])][msg.sender])); if (flag0) { } else { flag1 = flag0; } require(!(flag1), ERC721InvalidApprover()); emit Approval(address(array_2[amount]), spender, amount); getApproved[amount] = spender | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & getApproved[amount]); } function name() public view returns (string memory) { return _name; } function getReleasableAmount(uint256 index) public returns (uint256) { if (bytes1(stor_expr_c >> 0x10) != 0x0) { return (mapping_c[index] - stor_expr_w * 0x0de0b6b3a7640000) / mapping_f[mapping_d[index]]; } else { uint256 value0 = 0; uint256 var_d; uint256 value1 = (var_d + 0x04) + 0x60; uint256 value2 = keccak256(abi.encode(keccak256(abi.encode(index, 0x0d)) + 0x06)); while (true) { if (value0 >= stor_expr_d) { break; } if (!((bytes1(array_2[value2]) < 0x04))) _desolexPanic(33); value0 = value0 + 0x01; value1 = value1 + 0x60; value2 = value2 + 0x03; (bool success0, bytes memory returnData0) = address(0xb4123869ca90735bd2d9847b8a7dc60c36699dc3).calculateVestedAmount(0x40, block.timestamp); // staticcall require(success0); uint256 value4 = this.code.length; uint256 value5 = var_d.length; if (success0) { uint256 value3 = returnData0.length; if (0x20 <= returnData0.length) { value3 = 0x20; } if (((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value3 + 0x1f))) < var_d) | ((var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value3 + 0x1f))) > 0xffffffffffffffff)) _desolexPanic(65); var_d = var_d + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & (value3 + 0x1f)); require(((var_d + value3) - var_d) >= 0x20); } else { value4 = var_d; value5 = 0; } uint256 value6 = stor_expr_f; if (value5 <= stor_expr_f) { value6 = value5; } uint256 value7 = (mapping_c[index] * value6) / stor_expr_f; if (stor_expr_f != 0x0) { } else { value7 = 0; } uint256 value8 = 0x04; uint256 value9 = mapping_c[index]; if (value7 > mapping_c[index]) { } else { value8 = index; value9 = value7; } if (!(value9 > stor_expr_aa)) { return 0 / mapping_f[mapping_d[index]]; } else { return ((value9 - stor_expr_aa) * 0x0de0b6b3a7640000) / mapping_f[mapping_d[index]]; } } } } function supportsInterface(bytes4 interfaceId) public pure returns (bool) { require(interfaceId == (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000)); bool flag0 = (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000) == 0x5b5e139f00000000000000000000000000000000000000000000000000000000; if (interfaceId & (0xffffffff00000000000000000000000000000000000000000000000000000000) == 0x80ac58cd00000000000000000000000000000000000000000000000000000000) { flag0 = (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000) == 0x80ac58cd00000000000000000000000000000000000000000000000000000000; } uint256 value0 = msg.data[0] >> 0xe0; bool flag1 = 0x1ffc9a700000000000000000000000000000000000000000000000000000000 == (interfaceId & 0xffffffff00000000000000000000000000000000000000000000000000000000); if (flag0) { value0 = interfaceId & (0xffffffff00000000000000000000000000000000000000000000000000000000); flag1 = flag0; } return flag1; } function internal_3861(address arg0, address arg1, uint256 arg2) private { // Decompilation incomplete: helper effect provenance is conservative. require(arg1 != address(0), ERC721InvalidReceiver()); internal_3ea7(arg1, arg2, msg.sender); if (mapping_2[__desolex_internal_3ea7_3881_arg1] != address(0)) { require(mapping_e[arg2], NonTransferableToken()); stor_expr_co = arg1; } require(address(array_2[__desolex_internal_3ea7_3881_arg1]) == arg0, ERC721IncorrectOwner()); } function internal_3ea7(address arg0, uint256 arg1, address arg2) private returns (uint256) { // Decompilation incomplete: helper effect provenance is conservative. bool value2 = arg2; if (arg2 != address(0)) { uint256 value1; uint256 value0 = bytes1(isApprovedForAll[address(array_2[arg1])][arg2]); if (address(array_2[arg1]) == arg2) { value0 = ((address(array_2[arg1])) == arg2) ? 1 : 0; } uint256 value3 = value0; if (value0 == 0) { value3 = (arg2 == getApproved[arg1]) ? 1 : 0; } value1 = value3; if (value1 == 0x0) { require(address(array_2[arg1]) != address(0), ERC721NonexistentToken()); revert ERC721InsufficientApproval(); } } else { value2 = !(!(arg2)); } if (address(array_2[arg1]) != address(0)) { getApproved[arg1] = address(0); balanceOf[address(array_2[arg1])] = balanceOf[address(array_2[arg1])] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff; if (arg0 != address(0)) { balanceOf[arg0] = balanceOf[arg0] + 0x01; } array_2[arg1] = arg0 | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & array_2[arg1]); emit Transfer(address(array_2[arg1]), arg0, arg1); if (address(array_2[arg1]) != address(0)) { require(mapping_e[arg2], NonTransferableToken()); stor_expr_ar = arg1 | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_ar); } require(address(array_2[arg1]) == arg0, ERC721IncorrectOwner()); } else { if (arg0 != address(0)) { balanceOf[arg0] = balanceOf[arg0] + 0x01; array_2[arg1] = arg0 | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & array_2[arg1]); emit Transfer(address(array_2[arg1]), arg0, arg1); if (address(array_2[arg1]) != address(0)) { require(mapping_e[arg2], NonTransferableToken()); stor_expr_av = arg1 | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & stor_expr_av); } require(address(array_2[arg1]) == arg0, ERC721IncorrectOwner()); } else { array_2[arg1] = arg0 | (0xffffffffffffffffffffffff0000000000000000000000000000000000000000 & array_2[arg1]); emit Transfer(address(array_2[arg1]), arg0, arg1); return address(array_2[arg1]); } } } // 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) // 0x025d3c83 => getReleasableAmount(uint256) // 0x06fdde03 => name() // 0x081812fc => getApproved(uint256) // 0x095ea7b3 => approve(address,uint256) // 0x0c558e44 => createVesting(address,(uint256,uint256,uint8)[],address,bool,bool,bool,bool) // 0x18785590 => transferVesting(uint256,address) // 0x1ce11349 => createAirdropVesting(address,(uint256,uint256,uint8)[],address[],bool,bool,bool,bool) // 0x1e6492b1 => setCreatorFeeExempt(address,bool) // 0x23241b13 => createBulkVestingForBeneficiaries(address[],(uint256,uint256,uint8)[][],address[],bool,bool,bool,bool) // 0x23b872dd => transferFrom(address,address,uint256) // 0x23fa495a => setFlatFee(uint256) // 0x37bdc99b => release(uint256) // 0x40e58ee5 => cancel(uint256) // 0x40ee6538 => createBulkVestingForBeneficiary(address[],(uint256,uint256,uint8)[][],address,bool,bool,bool,bool) // 0x42842e0e => safeTransferFrom(address,address,uint256) // 0x495f3d27 => nextVestingId() // 0x6352211e => ownerOf(uint256) // 0x6d3cbe21 => vestingSchedules(uint256) // 0x6d6060f5 => svgGenerator() // 0x6de18fbb => feeExemptTokens(address) // 0x70a08231 => balanceOf(address) // 0x715018a6 => renounceOwnership() // 0x79ba5097 => acceptOwnership() // 0x8799ce22 => createDailySoftVesting(address,(uint256,uint256,uint8)[],address) // 0x8da5cb5b => owner() // 0x95d89b41 => symbol() // 0x97b5bb3a => feeExemptCreators(address) // 0xa001ecdd => feePercentage() // 0xa22cb465 => setApprovalForAll(address,bool) // 0xa42dce80 => setFeeCollector(address) // 0xae06c1b7 => setFeePercentage(uint256) // 0xb3a0f37d => setSVGGenerator(address) // 0xb8677ebd => setTokenFeeExempt(address,bool) // 0xb88d4fde => safeTransferFrom(address,address,uint256,bytes) // 0xbeb8f883 => getVestingSchedule(uint256) // 0xc415b95c => feeCollector() // 0xc86055cb => mintVestingNFT(uint256) // 0xc87b56dd => tokenURI(uint256) // 0xcafeedf6 => getVestedAmount(uint256) // 0xce3e39c0 => calculator() // 0xd9eb5947 => flatFee() // 0xdda085cf => _getReleasableShares(uint256) // 0xe30c3978 => pendingOwner() // 0xe985e9c5 => isApprovedForAll(address,address) // 0xf2fde38b => transferOwnership(address) // 0xfc48422c => topUpVesting(uint256,(uint256,uint256,uint8)[])}