Online Solidity Decompiler

label_0000: // Inputs[1] { @0007 msg.data.length } 0000 60 PUSH1 0x80 0002 60 PUSH1 0x40 0004 52 MSTORE 0005 60 PUSH1 0x04 0007 36 CALLDATASIZE 0008 10 LT 0009 61 PUSH2 0x019a 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x019a, if msg.data.length < 0x04 label_000D: // Incoming jump from 0x000C, if not msg.data.length < 0x04 // Inputs[1] { @000F msg.data[0x00:0x20] } 000D 60 PUSH1 0x00 000F 35 CALLDATALOAD 0010 60 PUSH1 0xe0 0012 1C SHR 0013 80 DUP1 0014 63 PUSH4 0xa4a78f0c 0019 11 GT 001A 61 PUSH2 0x00e1 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x00e1, if 0xa4a78f0c > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0xa4a78f0c > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xdb3e2198 0024 11 GT 0025 61 PUSH2 0x008a 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x008a, if 0xdb3e2198 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xdb3e2198 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xe264172c 002F 11 GT 0030 61 PUSH2 0x0064 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0064, if 0xe264172c > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xe264172c > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xe264172c 003A 14 EQ 003B 61 PUSH2 0x046a 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x046a, if 0xe264172c == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xe264172c == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xf28c0498 0045 14 EQ 0046 61 PUSH2 0x047f 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x047f, if 0xf28c0498 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xf28c0498 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xf3995c67 0050 14 EQ 0051 61 PUSH2 0x0492 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0492, if 0xf3995c67 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xf3995c67 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xfa461e33 005B 14 EQ 005C 61 PUSH2 0x04a5 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04a5, if 0xfa461e33 == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xfa461e33 == stack[-1] 0060 61 PUSH2 0x0245 0063 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0245 label_0064: // Incoming jump from 0x0033, if 0xe264172c > stack[-1] // Inputs[1] { @0065 stack[-1] } 0064 5B JUMPDEST 0065 80 DUP1 0066 63 PUSH4 0xdb3e2198 006B 14 EQ 006C 61 PUSH2 0x0431 006F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0431, if 0xdb3e2198 == stack[-1] label_0070: // Incoming jump from 0x006F, if not 0xdb3e2198 == stack[-1] // Inputs[1] { @0070 stack[-1] } 0070 80 DUP1 0071 63 PUSH4 0xdf2ab5bb 0076 14 EQ 0077 61 PUSH2 0x0444 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0444, if 0xdf2ab5bb == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xdf2ab5bb == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0xe0e189a0 0081 14 EQ 0082 61 PUSH2 0x0457 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0457, if 0xe0e189a0 == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xe0e189a0 == stack[-1] 0086 61 PUSH2 0x0245 0089 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0245 label_008A: // Incoming jump from 0x0028, if 0xdb3e2198 > stack[-1] // Inputs[1] { @008B stack[-1] } 008A 5B JUMPDEST 008B 80 DUP1 008C 63 PUSH4 0xc2e3140a 0091 11 GT 0092 61 PUSH2 0x00bb 0095 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00bb, if 0xc2e3140a > stack[-1] label_0096: // Incoming jump from 0x0095, if not 0xc2e3140a > stack[-1] // Inputs[1] { @0096 stack[-1] } 0096 80 DUP1 0097 63 PUSH4 0xc2e3140a 009C 14 EQ 009D 61 PUSH2 0x03e9 00A0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03e9, if 0xc2e3140a == stack[-1] label_00A1: // Incoming jump from 0x00A0, if not 0xc2e3140a == stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A1 80 DUP1 00A2 63 PUSH4 0xc45a0155 00A7 14 EQ 00A8 61 PUSH2 0x03fc 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03fc, if 0xc45a0155 == stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0xc45a0155 == stack[-1] // Inputs[1] { @00AC stack[-1] } 00AC 80 DUP1 00AD 63 PUSH4 0xdaf9c210 00B2 14 EQ 00B3 61 PUSH2 0x0411 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0411, if 0xdaf9c210 == stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0xdaf9c210 == stack[-1] 00B7 61 PUSH2 0x0245 00BA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0245 label_00BB: // Incoming jump from 0x0095, if 0xc2e3140a > stack[-1] // Inputs[1] { @00BC stack[-1] } 00BB 5B JUMPDEST 00BC 80 DUP1 00BD 63 PUSH4 0xa4a78f0c 00C2 14 EQ 00C3 61 PUSH2 0x03a3 00C6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03a3, if 0xa4a78f0c == stack[-1] label_00C7: // Incoming jump from 0x00C6, if not 0xa4a78f0c == stack[-1] // Inputs[1] { @00C7 stack[-1] } 00C7 80 DUP1 00C8 63 PUSH4 0xac9650d8 00CD 14 EQ 00CE 61 PUSH2 0x03b6 00D1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b6, if 0xac9650d8 == stack[-1] label_00D2: // Incoming jump from 0x00D1, if not 0xac9650d8 == stack[-1] // Inputs[1] { @00D2 stack[-1] } 00D2 80 DUP1 00D3 63 PUSH4 0xc04b8d59 00D8 14 EQ 00D9 61 PUSH2 0x03d6 00DC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d6, if 0xc04b8d59 == stack[-1] label_00DD: // Incoming jump from 0x00DC, if not 0xc04b8d59 == stack[-1] 00DD 61 PUSH2 0x0245 00E0 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0245 label_00E1: // Incoming jump from 0x001D, if 0xa4a78f0c > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @00E2 stack[-1] } 00E1 5B JUMPDEST 00E2 80 DUP1 00E3 63 PUSH4 0x4659a494 00E8 11 GT 00E9 61 PUSH2 0x0143 00EC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0143, if 0x4659a494 > stack[-1] label_00ED: // Incoming jump from 0x00EC, if not 0x4659a494 > stack[-1] // Inputs[1] { @00ED stack[-1] } 00ED 80 DUP1 00EE 63 PUSH4 0x67bea493 00F3 11 GT 00F4 61 PUSH2 0x011d 00F7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x011d, if 0x67bea493 > stack[-1] label_00F8: // Incoming jump from 0x00F7, if not 0x67bea493 > stack[-1] // Inputs[1] { @00F8 stack[-1] } 00F8 80 DUP1 00F9 63 PUSH4 0x67bea493 00FE 14 EQ 00FF 61 PUSH2 0x0343 0102 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0343, if 0x67bea493 == stack[-1] label_0103: // Incoming jump from 0x0102, if not 0x67bea493 == stack[-1] // Inputs[1] { @0103 stack[-1] } 0103 80 DUP1 0104 63 PUSH4 0x839f7e66 0109 14 EQ 010A 61 PUSH2 0x0370 010D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0370, if 0x839f7e66 == stack[-1] label_010E: // Incoming jump from 0x010D, if not 0x839f7e66 == stack[-1] // Inputs[1] { @010E stack[-1] } 010E 80 DUP1 010F 63 PUSH4 0x9b2c0a37 0114 14 EQ 0115 61 PUSH2 0x0390 0118 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0390, if 0x9b2c0a37 == stack[-1] label_0119: // Incoming jump from 0x0118, if not 0x9b2c0a37 == stack[-1] 0119 61 PUSH2 0x0245 011C 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0245 label_011D: // Incoming jump from 0x00F7, if 0x67bea493 > stack[-1] // Inputs[1] { @011E stack[-1] } 011D 5B JUMPDEST 011E 80 DUP1 011F 63 PUSH4 0x4659a494 0124 14 EQ 0125 61 PUSH2 0x02fb 0128 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02fb, if 0x4659a494 == stack[-1] label_0129: // Incoming jump from 0x0128, if not 0x4659a494 == stack[-1] // Inputs[1] { @0129 stack[-1] } 0129 80 DUP1 012A 63 PUSH4 0x49404b7c 012F 14 EQ 0130 61 PUSH2 0x030e 0133 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x030e, if 0x49404b7c == stack[-1] label_0134: // Incoming jump from 0x0133, if not 0x49404b7c == stack[-1] // Inputs[1] { @0134 stack[-1] } 0134 80 DUP1 0135 63 PUSH4 0x4aa4a4fc 013A 14 EQ 013B 61 PUSH2 0x0321 013E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0321, if 0x4aa4a4fc == stack[-1] label_013F: // Incoming jump from 0x013E, if not 0x4aa4a4fc == stack[-1] 013F 61 PUSH2 0x0245 0142 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0245 label_0143: // Incoming jump from 0x00EC, if 0x4659a494 > stack[-1] // Inputs[1] { @0144 stack[-1] } 0143 5B JUMPDEST 0144 80 DUP1 0145 63 PUSH4 0x23879fc6 014A 11 GT 014B 61 PUSH2 0x0174 014E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0174, if 0x23879fc6 > stack[-1] label_014F: // Incoming jump from 0x014E, if not 0x23879fc6 > stack[-1] // Inputs[1] { @014F stack[-1] } 014F 80 DUP1 0150 63 PUSH4 0x23879fc6 0155 14 EQ 0156 61 PUSH2 0x02a8 0159 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a8, if 0x23879fc6 == stack[-1] label_015A: // Incoming jump from 0x0159, if not 0x23879fc6 == stack[-1] // Inputs[1] { @015A stack[-1] } 015A 80 DUP1 015B 63 PUSH4 0x40fe43c1 0160 14 EQ 0161 61 PUSH2 0x02c8 0164 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02c8, if 0x40fe43c1 == stack[-1] label_0165: // Incoming jump from 0x0164, if not 0x40fe43c1 == stack[-1] // Inputs[1] { @0165 stack[-1] } 0165 80 DUP1 0166 63 PUSH4 0x414bf389 016B 14 EQ 016C 61 PUSH2 0x02e8 016F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e8, if 0x414bf389 == stack[-1] label_0170: // Incoming jump from 0x016F, if not 0x414bf389 == stack[-1] 0170 61 PUSH2 0x0245 0173 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0245 label_0174: // Incoming jump from 0x014E, if 0x23879fc6 > stack[-1] // Inputs[1] { @0175 stack[-1] } 0174 5B JUMPDEST 0175 80 DUP1 0176 63 PUSH4 0x01fa4150 017B 14 EQ 017C 61 PUSH2 0x024a 017F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x024a, if 0x01fa4150 == stack[-1] label_0180: // Incoming jump from 0x017F, if not 0x01fa4150 == stack[-1] // Inputs[1] { @0180 stack[-1] } 0180 80 DUP1 0181 63 PUSH4 0x12210e8a 0186 14 EQ 0187 61 PUSH2 0x026a 018A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x026a, if 0x12210e8a == stack[-1] label_018B: // Incoming jump from 0x018A, if not 0x12210e8a == stack[-1] // Inputs[1] { @018B stack[-1] } 018B 80 DUP1 018C 63 PUSH4 0x1ede2a8d 0191 14 EQ 0192 61 PUSH2 0x0272 0195 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0272, if 0x1ede2a8d == stack[-1] label_0196: // Incoming jump from 0x0195, if not 0x1ede2a8d == stack[-1] 0196 61 PUSH2 0x0245 0199 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0245 label_019A: // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @019B msg.data.length } 019A 5B JUMPDEST 019B 36 CALLDATASIZE 019C 61 PUSH2 0x0245 019F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0245, if msg.data.length label_01A0: // Incoming jump from 0x019F, if not msg.data.length // Inputs[1] { @01A0 msg.sender } 01A0 33 CALLER 01A1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 01B6 7F PUSH32 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 01D7 16 AND 01D8 14 EQ 01D9 61 PUSH2 0x0243 01DC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0243, if 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 & 0xffffffffffffffffffffffffffffffffffffffff == msg.sender label_01DD: // Incoming jump from 0x01DC, if not 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 & 0xffffffffffffffffffffffffffffffffffffffff == msg.sender // Inputs[3] // { // @01E0 memory[0x40:0x60] // @0239 memory[0x40:0x60] // @0242 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 01DD 60 PUSH1 0x40 01DF 80 DUP1 01E0 51 MLOAD 01E1 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0202 81 DUP2 0203 52 MSTORE 0204 60 PUSH1 0x20 0206 60 PUSH1 0x04 0208 82 DUP3 0209 01 ADD 020A 52 MSTORE 020B 60 PUSH1 0x09 020D 60 PUSH1 0x24 020F 82 DUP3 0210 01 ADD 0211 52 MSTORE 0212 7F PUSH32 0x4e6f742057455448390000000000000000000000000000000000000000000000 0233 60 PUSH1 0x44 0235 82 DUP3 0236 01 ADD 0237 52 MSTORE 0238 90 SWAP1 0239 51 MLOAD 023A 90 SWAP1 023B 81 DUP2 023C 90 SWAP1 023D 03 SUB 023E 60 PUSH1 0x64 0240 01 ADD 0241 90 SWAP1 0242 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0203 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @020A memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0211 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x09 // @0237 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4e6f742057455448390000000000000000000000000000000000000000000000 // @0242 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0243: // Incoming return from call to 0x0452 at 0x0451 // Incoming return from call to 0x03B1 at 0x03B0 // Incoming return from call to 0x05A8 at 0x0271 // Incoming return from call to 0x031C at 0x031B // Incoming return from call to 0x0465 at 0x0464 // Incoming return from call to 0x0465 at 0x0464 // Incoming return from call to 0x039E at 0x039D // Incoming return from call to 0x03F7 at 0x03F6 // Incoming return from call to 0x0265 at 0x0264 // Incoming return from call to 0x04A0 at 0x049F // Incoming return from call to 0x18F8 at 0x047E // Incoming return from call to 0x0309 at 0x0308 // Incoming jump from 0x01DC, if 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 & 0xffffffffffffffffffffffffffffffffffffffff == msg.sender 0243 5B JUMPDEST 0244 00 *STOP // Stack delta = +0 // Outputs[1] { @0244 stop(); } // Block terminates label_0245: // Incoming jump from 0x011C // Incoming jump from 0x0063 // Incoming jump from 0x00BA // Incoming jump from 0x0142 // Incoming jump from 0x0173 // Incoming jump from 0x019F, if msg.data.length // Incoming jump from 0x00E0 // Incoming jump from 0x0199 // Incoming jump from 0x0089 // Inputs[1] { @0249 memory[0x00:0x00] } 0245 5B JUMPDEST 0246 60 PUSH1 0x00 0248 80 DUP1 0249 FD *REVERT // Stack delta = +0 // Outputs[1] { @0249 revert(memory[0x00:0x00]); } // Block terminates label_024A: // Incoming jump from 0x017F, if 0x01fa4150 == stack[-1] // Inputs[1] { @024B msg.value } 024A 5B JUMPDEST 024B 34 CALLVALUE 024C 80 DUP1 024D 15 ISZERO 024E 61 PUSH2 0x0256 0251 57 *JUMPI // Stack delta = +1 // Outputs[1] { @024B stack[0] = msg.value } // Block ends with conditional jump to 0x0256, if !msg.value label_0252: // Incoming jump from 0x0251, if not !msg.value // Inputs[1] { @0255 memory[0x00:0x00] } 0252 60 PUSH1 0x00 0254 80 DUP1 0255 FD *REVERT // Stack delta = +0 // Outputs[1] { @0255 revert(memory[0x00:0x00]); } // Block terminates label_0256: // Incoming jump from 0x0251, if !msg.value // Inputs[1] { @025E msg.data.length } 0256 5B JUMPDEST 0257 50 POP 0258 61 PUSH2 0x0243 025B 61 PUSH2 0x0265 025E 36 CALLDATASIZE 025F 60 PUSH1 0x04 0261 61 PUSH2 0x343c 0264 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0258 stack[-1] = 0x0243 // @025B stack[0] = 0x0265 // @025E stack[1] = msg.data.length // @025F stack[2] = 0x04 // } // Block ends with call to 0x343c, returns to 0x0265 label_0265: // Incoming return from call to 0x343C at 0x0264 0265 5B JUMPDEST 0266 61 PUSH2 0x04c5 0269 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x04c5 label_026A: // Incoming jump from 0x018A, if 0x12210e8a == stack[-1] 026A 5B JUMPDEST 026B 61 PUSH2 0x0243 026E 61 PUSH2 0x05a8 0271 56 *JUMP // Stack delta = +1 // Outputs[1] { @026B stack[0] = 0x0243 } // Block ends with call to 0x05a8, returns to 0x0243 label_0272: // Incoming jump from 0x0195, if 0x1ede2a8d == stack[-1] // Inputs[1] { @0273 msg.value } 0272 5B JUMPDEST 0273 34 CALLVALUE 0274 80 DUP1 0275 15 ISZERO 0276 61 PUSH2 0x027e 0279 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0273 stack[0] = msg.value } // Block ends with conditional jump to 0x027e, if !msg.value label_027A: // Incoming jump from 0x0279, if not !msg.value // Inputs[1] { @027D memory[0x00:0x00] } 027A 60 PUSH1 0x00 027C 80 DUP1 027D FD *REVERT // Stack delta = +0 // Outputs[1] { @027D revert(memory[0x00:0x00]); } // Block terminates label_027E: // Incoming jump from 0x0279, if !msg.value // Inputs[1] { @0286 msg.data.length } 027E 5B JUMPDEST 027F 50 POP 0280 61 PUSH2 0x0292 0283 61 PUSH2 0x028d 0286 36 CALLDATASIZE 0287 60 PUSH1 0x04 0289 61 PUSH2 0x343c 028C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0280 stack[-1] = 0x0292 // @0283 stack[0] = 0x028d // @0286 stack[1] = msg.data.length // @0287 stack[2] = 0x04 // } // Block ends with call to 0x343c, returns to 0x028D label_028D: // Incoming return from call to 0x343C at 0x028C 028D 5B JUMPDEST 028E 61 PUSH2 0x05ba 0291 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x05ba 0292 5B JUMPDEST 0293 60 PUSH1 0x40 0295 51 MLOAD 0296 61 PUSH2 0x029f 0299 91 SWAP2 029A 90 SWAP1 029B 61 PUSH2 0x3ad1 029E 56 *JUMP label_029F: // Incoming return from call to 0x3A48 at 0x03D5 // Incoming return from call to 0x39D5 at 0x0342 // Inputs[3] // { // @02A2 memory[0x40:0x60] // @02A4 stack[-1] // @02A7 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 029F 5B JUMPDEST 02A0 60 PUSH1 0x40 02A2 51 MLOAD 02A3 80 DUP1 02A4 91 SWAP2 02A5 03 SUB 02A6 90 SWAP1 02A7 F3 *RETURN // Stack delta = -1 // Outputs[1] { @02A7 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_02A8: // Incoming jump from 0x0159, if 0x23879fc6 == stack[-1] // Inputs[1] { @02A9 msg.value } 02A8 5B JUMPDEST 02A9 34 CALLVALUE 02AA 80 DUP1 02AB 15 ISZERO 02AC 61 PUSH2 0x02b4 02AF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02A9 stack[0] = msg.value } // Block ends with conditional jump to 0x02b4, if !msg.value label_02B0: // Incoming jump from 0x02AF, if not !msg.value // Inputs[1] { @02B3 memory[0x00:0x00] } 02B0 60 PUSH1 0x00 02B2 80 DUP1 02B3 FD *REVERT // Stack delta = +0 // Outputs[1] { @02B3 revert(memory[0x00:0x00]); } // Block terminates label_02B4: // Incoming jump from 0x02AF, if !msg.value // Inputs[1] { @02BC msg.data.length } 02B4 5B JUMPDEST 02B5 50 POP 02B6 61 PUSH2 0x0243 02B9 61 PUSH2 0x02c3 02BC 36 CALLDATASIZE 02BD 60 PUSH1 0x04 02BF 61 PUSH2 0x346f 02C2 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02B6 stack[-1] = 0x0243 // @02B9 stack[0] = 0x02c3 // @02BC stack[1] = msg.data.length // @02BD stack[2] = 0x04 // } // Block ends with call to 0x346f, returns to 0x02C3 label_02C3: // Incoming return from call to 0x346F at 0x02C2 02C3 5B JUMPDEST 02C4 61 PUSH2 0x061b 02C7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x061b label_02C8: // Incoming jump from 0x0164, if 0x40fe43c1 == stack[-1] // Inputs[1] { @02C9 msg.value } 02C8 5B JUMPDEST 02C9 34 CALLVALUE 02CA 80 DUP1 02CB 15 ISZERO 02CC 61 PUSH2 0x02d4 02CF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02C9 stack[0] = msg.value } // Block ends with conditional jump to 0x02d4, if !msg.value label_02D0: // Incoming jump from 0x02CF, if not !msg.value // Inputs[1] { @02D3 memory[0x00:0x00] } 02D0 60 PUSH1 0x00 02D2 80 DUP1 02D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @02D3 revert(memory[0x00:0x00]); } // Block terminates label_02D4: // Incoming jump from 0x02CF, if !msg.value // Inputs[1] { @02DC msg.data.length } 02D4 5B JUMPDEST 02D5 50 POP 02D6 61 PUSH2 0x0292 02D9 61 PUSH2 0x02e3 02DC 36 CALLDATASIZE 02DD 60 PUSH1 0x04 02DF 61 PUSH2 0x343c 02E2 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @02D6 stack[-1] = 0x0292 // @02D9 stack[0] = 0x02e3 // @02DC stack[1] = msg.data.length // @02DD stack[2] = 0x04 // } // Block ends with call to 0x343c, returns to 0x02E3 label_02E3: // Incoming return from call to 0x343C at 0x02E2 02E3 5B JUMPDEST 02E4 61 PUSH2 0x0776 02E7 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0776 label_02E8: // Incoming jump from 0x016F, if 0x414bf389 == stack[-1] // Inputs[1] { @02EF msg.data.length } 02E8 5B JUMPDEST 02E9 61 PUSH2 0x0292 02EC 61 PUSH2 0x02f6 02EF 36 CALLDATASIZE 02F0 60 PUSH1 0x04 02F2 61 PUSH2 0x3714 02F5 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02E9 stack[0] = 0x0292 // @02EC stack[1] = 0x02f6 // @02EF stack[2] = msg.data.length // @02F0 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x3714 02F6 5B JUMPDEST 02F7 61 PUSH2 0x0798 02FA 56 *JUMP label_02FB: // Incoming jump from 0x0128, if 0x4659a494 == stack[-1] // Inputs[1] { @0302 msg.data.length } 02FB 5B JUMPDEST 02FC 61 PUSH2 0x0243 02FF 61 PUSH2 0x0309 0302 36 CALLDATASIZE 0303 60 PUSH1 0x04 0305 61 PUSH2 0x33e3 0308 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02FC stack[0] = 0x0243 // @02FF stack[1] = 0x0309 // @0302 stack[2] = msg.data.length // @0303 stack[3] = 0x04 // } // Block ends with call to 0x33e3, returns to 0x0309 label_0309: // Incoming return from call to 0x33E3 at 0x0308 0309 5B JUMPDEST 030A 61 PUSH2 0x0970 030D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0970 label_030E: // Incoming jump from 0x0133, if 0x49404b7c == stack[-1] // Inputs[1] { @0315 msg.data.length } 030E 5B JUMPDEST 030F 61 PUSH2 0x0243 0312 61 PUSH2 0x031c 0315 36 CALLDATASIZE 0316 60 PUSH1 0x04 0318 61 PUSH2 0x3833 031B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @030F stack[0] = 0x0243 // @0312 stack[1] = 0x031c // @0315 stack[2] = msg.data.length // @0316 stack[3] = 0x04 // } // Block ends with call to 0x3833, returns to 0x031C label_031C: // Incoming return from call to 0x3833 at 0x031B 031C 5B JUMPDEST 031D 61 PUSH2 0x0a30 0320 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a30 label_0321: // Incoming jump from 0x013E, if 0x4aa4a4fc == stack[-1] // Inputs[1] { @0322 msg.value } 0321 5B JUMPDEST 0322 34 CALLVALUE 0323 80 DUP1 0324 15 ISZERO 0325 61 PUSH2 0x032d 0328 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0322 stack[0] = msg.value } // Block ends with conditional jump to 0x032d, if !msg.value label_0329: // Incoming jump from 0x0328, if not !msg.value // Inputs[1] { @032C memory[0x00:0x00] } 0329 60 PUSH1 0x00 032B 80 DUP1 032C FD *REVERT // Stack delta = +0 // Outputs[1] { @032C revert(memory[0x00:0x00]); } // Block terminates label_032D: // Incoming jump from 0x0328, if !msg.value 032D 5B JUMPDEST 032E 50 POP 032F 61 PUSH2 0x0336 0332 61 PUSH2 0x0bf6 0335 56 *JUMP // Stack delta = +0 // Outputs[1] { @032F stack[-1] = 0x0336 } // Block ends with call to 0x0bf6, returns to 0x0336 label_0336: // Incoming return from call to 0x0BF6 at 0x0335 // Incoming return from call to 0x1446 at 0x0410 // Inputs[2] // { // @0339 memory[0x40:0x60] // @033D stack[-1] // } 0336 5B JUMPDEST 0337 60 PUSH1 0x40 0339 51 MLOAD 033A 61 PUSH2 0x029f 033D 91 SWAP2 033E 90 SWAP1 033F 61 PUSH2 0x39d5 0342 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @033D stack[-1] = 0x029f // @033E stack[1] = memory[0x40:0x60] // @033E stack[0] = stack[-1] // } // Block ends with call to 0x39d5, returns to 0x029F label_0343: // Incoming jump from 0x0102, if 0x67bea493 == stack[-1] // Inputs[1] { @0344 msg.value } 0343 5B JUMPDEST 0344 34 CALLVALUE 0345 80 DUP1 0346 15 ISZERO 0347 61 PUSH2 0x034f 034A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0344 stack[0] = msg.value } // Block ends with conditional jump to 0x034f, if !msg.value label_034B: // Incoming jump from 0x034A, if not !msg.value // Inputs[1] { @034E memory[0x00:0x00] } 034B 60 PUSH1 0x00 034D 80 DUP1 034E FD *REVERT // Stack delta = +0 // Outputs[1] { @034E revert(memory[0x00:0x00]); } // Block terminates label_034F: // Incoming jump from 0x034A, if !msg.value // Inputs[1] { @0357 msg.data.length } 034F 5B JUMPDEST 0350 50 POP 0351 61 PUSH2 0x0363 0354 61 PUSH2 0x035e 0357 36 CALLDATASIZE 0358 60 PUSH1 0x04 035A 61 PUSH2 0x3321 035D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0351 stack[-1] = 0x0363 // @0354 stack[0] = 0x035e // @0357 stack[1] = msg.data.length // @0358 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x3321 035E 5B JUMPDEST 035F 61 PUSH2 0x0c1a 0362 56 *JUMP 0363 5B JUMPDEST 0364 60 PUSH1 0x40 0366 51 MLOAD 0367 61 PUSH2 0x029f 036A 91 SWAP2 036B 90 SWAP1 036C 61 PUSH2 0x3ac6 036F 56 *JUMP label_0370: // Incoming jump from 0x010D, if 0x839f7e66 == stack[-1] // Inputs[1] { @0371 msg.value } 0370 5B JUMPDEST 0371 34 CALLVALUE 0372 80 DUP1 0373 15 ISZERO 0374 61 PUSH2 0x037c 0377 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0371 stack[0] = msg.value } // Block ends with conditional jump to 0x037c, if !msg.value label_0378: // Incoming jump from 0x0377, if not !msg.value // Inputs[1] { @037B memory[0x00:0x00] } 0378 60 PUSH1 0x00 037A 80 DUP1 037B FD *REVERT // Stack delta = +0 // Outputs[1] { @037B revert(memory[0x00:0x00]); } // Block terminates label_037C: // Incoming jump from 0x0377, if !msg.value // Inputs[1] { @0384 msg.data.length } 037C 5B JUMPDEST 037D 50 POP 037E 61 PUSH2 0x0243 0381 61 PUSH2 0x038b 0384 36 CALLDATASIZE 0385 60 PUSH1 0x04 0387 61 PUSH2 0x346f 038A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @037E stack[-1] = 0x0243 // @0381 stack[0] = 0x038b // @0384 stack[1] = msg.data.length // @0385 stack[2] = 0x04 // } // Block ends with call to 0x346f, returns to 0x038B label_038B: // Incoming return from call to 0x346F at 0x038A 038B 5B JUMPDEST 038C 61 PUSH2 0x0c2f 038F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c2f label_0390: // Incoming jump from 0x0118, if 0x9b2c0a37 == stack[-1] // Inputs[1] { @0397 msg.data.length } 0390 5B JUMPDEST 0391 61 PUSH2 0x0243 0394 61 PUSH2 0x039e 0397 36 CALLDATASIZE 0398 60 PUSH1 0x04 039A 61 PUSH2 0x3862 039D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0391 stack[0] = 0x0243 // @0394 stack[1] = 0x039e // @0397 stack[2] = msg.data.length // @0398 stack[3] = 0x04 // } // Block ends with call to 0x3862, returns to 0x039E label_039E: // Incoming return from call to 0x3862 at 0x039D 039E 5B JUMPDEST 039F 61 PUSH2 0x0d80 03A2 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0d80 label_03A3: // Incoming jump from 0x00C6, if 0xa4a78f0c == stack[-1] // Inputs[1] { @03AA msg.data.length } 03A3 5B JUMPDEST 03A4 61 PUSH2 0x0243 03A7 61 PUSH2 0x03b1 03AA 36 CALLDATASIZE 03AB 60 PUSH1 0x04 03AD 61 PUSH2 0x33e3 03B0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03A4 stack[0] = 0x0243 // @03A7 stack[1] = 0x03b1 // @03AA stack[2] = msg.data.length // @03AB stack[3] = 0x04 // } // Block ends with call to 0x33e3, returns to 0x03B1 label_03B1: // Incoming return from call to 0x33E3 at 0x03B0 03B1 5B JUMPDEST 03B2 61 PUSH2 0x0f98 03B5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0f98 label_03B6: // Incoming jump from 0x00D1, if 0xac9650d8 == stack[-1] // Inputs[1] { @03BD msg.data.length } 03B6 5B JUMPDEST 03B7 61 PUSH2 0x03c9 03BA 61 PUSH2 0x03c4 03BD 36 CALLDATASIZE 03BE 60 PUSH1 0x04 03C0 61 PUSH2 0x34f2 03C3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03B7 stack[0] = 0x03c9 // @03BA stack[1] = 0x03c4 // @03BD stack[2] = msg.data.length // @03BE stack[3] = 0x04 // } // Block ends with call to 0x34f2, returns to 0x03C4 label_03C4: // Incoming return from call to 0x34F2 at 0x03C3 03C4 5B JUMPDEST 03C5 61 PUSH2 0x106d 03C8 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x106d label_03C9: // Incoming return from call to 0x03C4 at 0x03C3 // Inputs[2] // { // @03CC memory[0x40:0x60] // @03D0 stack[-1] // } 03C9 5B JUMPDEST 03CA 60 PUSH1 0x40 03CC 51 MLOAD 03CD 61 PUSH2 0x029f 03D0 91 SWAP2 03D1 90 SWAP1 03D2 61 PUSH2 0x3a48 03D5 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @03D0 stack[-1] = 0x029f // @03D1 stack[1] = memory[0x40:0x60] // @03D1 stack[0] = stack[-1] // } // Block ends with call to 0x3a48, returns to 0x029F label_03D6: // Incoming jump from 0x00DC, if 0xc04b8d59 == stack[-1] // Inputs[1] { @03DD msg.data.length } 03D6 5B JUMPDEST 03D7 61 PUSH2 0x0292 03DA 61 PUSH2 0x03e4 03DD 36 CALLDATASIZE 03DE 60 PUSH1 0x04 03E0 61 PUSH2 0x3669 03E3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03D7 stack[0] = 0x0292 // @03DA stack[1] = 0x03e4 // @03DD stack[2] = msg.data.length // @03DE stack[3] = 0x04 // } // Block ends with unconditional jump to 0x3669 03E4 5B JUMPDEST 03E5 61 PUSH2 0x11c7 03E8 56 *JUMP label_03E9: // Incoming jump from 0x00A0, if 0xc2e3140a == stack[-1] // Inputs[1] { @03F0 msg.data.length } 03E9 5B JUMPDEST 03EA 61 PUSH2 0x0243 03ED 61 PUSH2 0x03f7 03F0 36 CALLDATASIZE 03F1 60 PUSH1 0x04 03F3 61 PUSH2 0x33e3 03F6 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @03EA stack[0] = 0x0243 // @03ED stack[1] = 0x03f7 // @03F0 stack[2] = msg.data.length // @03F1 stack[3] = 0x04 // } // Block ends with call to 0x33e3, returns to 0x03F7 label_03F7: // Incoming return from call to 0x33E3 at 0x03F6 03F7 5B JUMPDEST 03F8 61 PUSH2 0x1391 03FB 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1391 label_03FC: // Incoming jump from 0x00AB, if 0xc45a0155 == stack[-1] // Inputs[1] { @03FD msg.value } 03FC 5B JUMPDEST 03FD 34 CALLVALUE 03FE 80 DUP1 03FF 15 ISZERO 0400 61 PUSH2 0x0408 0403 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03FD stack[0] = msg.value } // Block ends with conditional jump to 0x0408, if !msg.value label_0404: // Incoming jump from 0x0403, if not !msg.value // Inputs[1] { @0407 memory[0x00:0x00] } 0404 60 PUSH1 0x00 0406 80 DUP1 0407 FD *REVERT // Stack delta = +0 // Outputs[1] { @0407 revert(memory[0x00:0x00]); } // Block terminates label_0408: // Incoming jump from 0x0403, if !msg.value 0408 5B JUMPDEST 0409 50 POP 040A 61 PUSH2 0x0336 040D 61 PUSH2 0x1446 0410 56 *JUMP // Stack delta = +0 // Outputs[1] { @040A stack[-1] = 0x0336 } // Block ends with call to 0x1446, returns to 0x0336 label_0411: // Incoming jump from 0x00B6, if 0xdaf9c210 == stack[-1] // Inputs[1] { @0412 msg.value } 0411 5B JUMPDEST 0412 34 CALLVALUE 0413 80 DUP1 0414 15 ISZERO 0415 61 PUSH2 0x041d 0418 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0412 stack[0] = msg.value } // Block ends with conditional jump to 0x041d, if !msg.value label_0419: // Incoming jump from 0x0418, if not !msg.value // Inputs[1] { @041C memory[0x00:0x00] } 0419 60 PUSH1 0x00 041B 80 DUP1 041C FD *REVERT // Stack delta = +0 // Outputs[1] { @041C revert(memory[0x00:0x00]); } // Block terminates label_041D: // Incoming jump from 0x0418, if !msg.value // Inputs[1] { @0425 msg.data.length } 041D 5B JUMPDEST 041E 50 POP 041F 61 PUSH2 0x0363 0422 61 PUSH2 0x042c 0425 36 CALLDATASIZE 0426 60 PUSH1 0x04 0428 61 PUSH2 0x3321 042B 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @041F stack[-1] = 0x0363 // @0422 stack[0] = 0x042c // @0425 stack[1] = msg.data.length // @0426 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x3321 042C 5B JUMPDEST 042D 61 PUSH2 0x146a 0430 56 *JUMP label_0431: // Incoming jump from 0x006F, if 0xdb3e2198 == stack[-1] // Inputs[1] { @0438 msg.data.length } 0431 5B JUMPDEST 0432 61 PUSH2 0x0292 0435 61 PUSH2 0x043f 0438 36 CALLDATASIZE 0439 60 PUSH1 0x04 043B 61 PUSH2 0x3714 043E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0432 stack[0] = 0x0292 // @0435 stack[1] = 0x043f // @0438 stack[2] = msg.data.length // @0439 stack[3] = 0x04 // } // Block ends with unconditional jump to 0x3714 043F 5B JUMPDEST 0440 61 PUSH2 0x147f 0443 56 *JUMP label_0444: // Incoming jump from 0x007A, if 0xdf2ab5bb == stack[-1] // Inputs[1] { @044B msg.data.length } 0444 5B JUMPDEST 0445 61 PUSH2 0x0243 0448 61 PUSH2 0x0452 044B 36 CALLDATASIZE 044C 60 PUSH1 0x04 044E 61 PUSH2 0x3344 0451 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0445 stack[0] = 0x0243 // @0448 stack[1] = 0x0452 // @044B stack[2] = msg.data.length // @044C stack[3] = 0x04 // } // Block ends with call to 0x3344, returns to 0x0452 label_0452: // Incoming return from call to 0x3344 at 0x0451 0452 5B JUMPDEST 0453 61 PUSH2 0x1675 0456 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1675 label_0457: // Incoming jump from 0x0085, if 0xe0e189a0 == stack[-1] // Inputs[1] { @045E msg.data.length } 0457 5B JUMPDEST 0458 61 PUSH2 0x0243 045B 61 PUSH2 0x0465 045E 36 CALLDATASIZE 045F 60 PUSH1 0x04 0461 61 PUSH2 0x3385 0464 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0458 stack[0] = 0x0243 // @045B stack[1] = 0x0465 // @045E stack[2] = msg.data.length // @045F stack[3] = 0x04 // } // Block ends with call to 0x3385, returns to 0x0465 label_0465: // Incoming return from call to 0x3385 at 0x0464 0465 5B JUMPDEST 0466 61 PUSH2 0x1792 0469 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1792 label_046A: // Incoming jump from 0x003E, if 0xe264172c == stack[-1] // Inputs[1] { @046B msg.value } 046A 5B JUMPDEST 046B 34 CALLVALUE 046C 80 DUP1 046D 15 ISZERO 046E 61 PUSH2 0x0476 0471 57 *JUMPI // Stack delta = +1 // Outputs[1] { @046B stack[0] = msg.value } // Block ends with conditional jump to 0x0476, if !msg.value label_0472: // Incoming jump from 0x0471, if not !msg.value // Inputs[1] { @0475 memory[0x00:0x00] } 0472 60 PUSH1 0x00 0474 80 DUP1 0475 FD *REVERT // Stack delta = +0 // Outputs[1] { @0475 revert(memory[0x00:0x00]); } // Block terminates label_0476: // Incoming jump from 0x0471, if !msg.value 0476 5B JUMPDEST 0477 50 POP 0478 61 PUSH2 0x0243 047B 61 PUSH2 0x18f8 047E 56 *JUMP // Stack delta = +0 // Outputs[1] { @0478 stack[-1] = 0x0243 } // Block ends with call to 0x18f8, returns to 0x0243 label_047F: // Incoming jump from 0x0049, if 0xf28c0498 == stack[-1] // Inputs[1] { @0486 msg.data.length } 047F 5B JUMPDEST 0480 61 PUSH2 0x0292 0483 61 PUSH2 0x048d 0486 36 CALLDATASIZE 0487 60 PUSH1 0x04 0489 61 PUSH2 0x3730 048C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0480 stack[0] = 0x0292 // @0483 stack[1] = 0x048d // @0486 stack[2] = msg.data.length // @0487 stack[3] = 0x04 // } // Block ends with call to 0x3730, returns to 0x048D label_048D: // Incoming return from call to 0x3730 at 0x048C 048D 5B JUMPDEST 048E 61 PUSH2 0x196b 0491 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x196b label_0492: // Incoming jump from 0x0054, if 0xf3995c67 == stack[-1] // Inputs[1] { @0499 msg.data.length } 0492 5B JUMPDEST 0493 61 PUSH2 0x0243 0496 61 PUSH2 0x04a0 0499 36 CALLDATASIZE 049A 60 PUSH1 0x04 049C 61 PUSH2 0x33e3 049F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0493 stack[0] = 0x0243 // @0496 stack[1] = 0x04a0 // @0499 stack[2] = msg.data.length // @049A stack[3] = 0x04 // } // Block ends with call to 0x33e3, returns to 0x04A0 label_04A0: // Incoming return from call to 0x33E3 at 0x049F 04A0 5B JUMPDEST 04A1 61 PUSH2 0x1b45 04A4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1b45 label_04A5: // Incoming jump from 0x005F, if 0xfa461e33 == stack[-1] // Inputs[1] { @04A6 msg.value } 04A5 5B JUMPDEST 04A6 34 CALLVALUE 04A7 80 DUP1 04A8 15 ISZERO 04A9 61 PUSH2 0x04b1 04AC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04A6 stack[0] = msg.value } // Block ends with conditional jump to 0x04b1, if !msg.value label_04AD: // Incoming jump from 0x04AC, if not !msg.value // Inputs[1] { @04B0 memory[0x00:0x00] } 04AD 60 PUSH1 0x00 04AF 80 DUP1 04B0 FD *REVERT // Stack delta = +0 // Outputs[1] { @04B0 revert(memory[0x00:0x00]); } // Block terminates label_04B1: // Incoming jump from 0x04AC, if !msg.value // Inputs[1] { @04B9 msg.data.length } 04B1 5B JUMPDEST 04B2 50 POP 04B3 61 PUSH2 0x0243 04B6 61 PUSH2 0x04c0 04B9 36 CALLDATASIZE 04BA 60 PUSH1 0x04 04BC 61 PUSH2 0x3584 04BF 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04B3 stack[-1] = 0x0243 // @04B6 stack[0] = 0x04c0 // @04B9 stack[1] = msg.data.length // @04BA stack[2] = 0x04 // } // Block ends with call to 0x3584, returns to 0x04C0 label_04C0: // Incoming return from call to 0x3584 at 0x04BF 04C0 5B JUMPDEST 04C1 61 PUSH2 0x1bdd 04C4 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1bdd label_04C5: // Incoming jump from 0x0269 // Inputs[2] // { // @04C9 stack[-1] // @04CA memory[stack[-1]:stack[-1] + 0x20] // } 04C5 5B JUMPDEST 04C6 60 PUSH1 0x00 04C8 5B JUMPDEST 04C9 81 DUP2 04CA 51 MLOAD 04CB 81 DUP2 04CC 10 LT 04CD 15 ISZERO 04CE 61 PUSH2 0x05a4 04D1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04C6 stack[0] = 0x00 } // Block ends with conditional jump to 0x05a4, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_04D2: // Incoming jump from 0x04D1, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x04D1, if not !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[3] // { // @04D5 stack[-2] // @04D6 stack[-1] // @04D8 memory[stack[-2]:stack[-2] + 0x20] // } 04D2 61 PUSH2 0x059c 04D5 82 DUP3 04D6 82 DUP3 04D7 81 DUP2 04D8 51 MLOAD 04D9 81 DUP2 04DA 10 LT 04DB 61 PUSH2 0x04e0 04DE 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @04D2 stack[0] = 0x059c // @04D5 stack[1] = stack[-2] // @04D6 stack[2] = stack[-1] // } // Block ends with conditional call to 0x04e0, returns to 0x059C, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] label_04DF: // Incoming jump from 0x04DE, if not stack[-1] < memory[stack[-2]:stack[-2] + 0x20] 04DF FE *ASSERT // Stack delta = +0 // Outputs[1] { @04DF assert(); } // Block terminates label_04E0: // Incoming call from 0x04DE, returns to 0x059C, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[6] // { // @04E3 stack[-1] // @04E7 stack[-2] // @04E8 memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @04FC stack[-5] // @04FD stack[-4] // @04FF memory[stack[-5]:stack[-5] + 0x20] // } 04E0 5B JUMPDEST 04E1 60 PUSH1 0x20 04E3 02 MUL 04E4 60 PUSH1 0x20 04E6 01 ADD 04E7 01 ADD 04E8 51 MLOAD 04E9 71 PUSH18 0xf079e68bbcc79ab9600ace786b0a4db1c83c 04FC 84 DUP5 04FD 84 DUP5 04FE 81 DUP2 04FF 51 MLOAD 0500 81 DUP2 0501 10 LT 0502 61 PUSH2 0x0507 0505 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @04E8 stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @04E9 stack[-1] = 0xf079e68bbcc79ab9600ace786b0a4db1c83c // @04FC stack[0] = stack[-5] // @04FD stack[1] = stack[-4] // } // Block ends with conditional jump to 0x0507, if stack[-4] < memory[stack[-5]:stack[-5] + 0x20] label_0506: // Incoming jump from 0x0505, if not stack[-4] < memory[stack[-5]:stack[-5] + 0x20] 0506 FE *ASSERT // Stack delta = +0 // Outputs[1] { @0506 assert(); } // Block terminates label_0507: // Incoming jump from 0x0505, if stack[-4] < memory[stack[-5]:stack[-5] + 0x20] // Inputs[5] // { // @050A stack[-1] // @050E stack[-2] // @050F memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @052B address(this) // @052E memory[0x40:0x60] // } 0507 5B JUMPDEST 0508 60 PUSH1 0x20 050A 02 MUL 050B 60 PUSH1 0x20 050D 01 ADD 050E 01 ADD 050F 51 MLOAD 0510 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0525 16 AND 0526 63 PUSH4 0x70a08231 052B 30 ADDRESS 052C 60 PUSH1 0x40 052E 51 MLOAD 052F 82 DUP3 0530 63 PUSH4 0xffffffff 0535 16 AND 0536 60 PUSH1 0xe0 0538 1B SHL 0539 81 DUP2 053A 52 MSTORE 053B 60 PUSH1 0x04 053D 01 ADD 053E 61 PUSH2 0x0547 0541 91 SWAP2 0542 90 SWAP1 0543 61 PUSH2 0x39d5 0546 56 *JUMP // Stack delta = +3 // Outputs[6] // { // @0525 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // @0526 stack[-1] = 0x70a08231 // @053A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x70a08231) << 0xe0 // @0541 stack[0] = 0x0547 // @0542 stack[2] = 0x04 + memory[0x40:0x60] // @0542 stack[1] = address(this) // } // Block ends with call to 0x39d5, returns to 0x0547 label_0547: // Incoming return from call to 0x39D5 at 0x0546 // Inputs[4] // { // @054C memory[0x40:0x60] // @054E stack[-1] // @0551 stack[-3] // @0553 address(stack[-3]).code.length // } 0547 5B JUMPDEST 0548 60 PUSH1 0x20 054A 60 PUSH1 0x40 054C 51 MLOAD 054D 80 DUP1 054E 83 DUP4 054F 03 SUB 0550 81 DUP2 0551 86 DUP7 0552 80 DUP1 0553 3B EXTCODESIZE 0554 15 ISZERO 0555 80 DUP1 0556 15 ISZERO 0557 61 PUSH2 0x055f 055A 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @0548 stack[0] = 0x20 // @054C stack[1] = memory[0x40:0x60] // @054F stack[2] = stack[-1] - memory[0x40:0x60] // @0550 stack[3] = memory[0x40:0x60] // @0551 stack[4] = stack[-3] // @0554 stack[5] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x055f, if !!address(stack[-3]).code.length label_055B: // Incoming jump from 0x055A, if not !!address(stack[-3]).code.length // Inputs[1] { @055E memory[0x00:0x00] } 055B 60 PUSH1 0x00 055D 80 DUP1 055E FD *REVERT // Stack delta = +0 // Outputs[1] { @055E revert(memory[0x00:0x00]); } // Block terminates label_055F: // Incoming jump from 0x055A, if !!address(stack[-3]).code.length // Inputs[8] // { // @0561 msg.gas // @0562 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0562 stack[-5] // @0562 memory[stack[-3]:stack[-3] + stack[-4]] // @0562 stack[-3] // @0562 stack[-6] // @0562 stack[-4] // @0562 stack[-2] // } 055F 5B JUMPDEST 0560 50 POP 0561 5A GAS 0562 FA STATICCALL 0563 15 ISZERO 0564 80 DUP1 0565 15 ISZERO 0566 61 PUSH2 0x0573 0569 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0562 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0563 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0573, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_056A: // Incoming jump from 0x0569, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @056A returndata.length // @056E returndata[0x00:0x00 + returndata.length] // @056F returndata.length // @0572 memory[0x00:0x00 + returndata.length] // } 056A 3D RETURNDATASIZE 056B 60 PUSH1 0x00 056D 80 DUP1 056E 3E RETURNDATACOPY 056F 3D RETURNDATASIZE 0570 60 PUSH1 0x00 0572 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @056E memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0572 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0573: // Incoming jump from 0x0569, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @057A memory[0x40:0x60] // @057B returndata.length // } 0573 5B JUMPDEST 0574 50 POP 0575 50 POP 0576 50 POP 0577 50 POP 0578 60 PUSH1 0x40 057A 51 MLOAD 057B 3D RETURNDATASIZE 057C 60 PUSH1 0x1f 057E 19 NOT 057F 60 PUSH1 0x1f 0581 82 DUP3 0582 01 ADD 0583 16 AND 0584 82 DUP3 0585 01 ADD 0586 80 DUP1 0587 60 PUSH1 0x40 0589 52 MSTORE 058A 50 POP 058B 81 DUP2 058C 01 ADD 058D 90 SWAP1 058E 61 PUSH2 0x0597 0591 91 SWAP2 0592 90 SWAP1 0593 61 PUSH2 0x381b 0596 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @0589 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x1f & ~0x1f) // @0591 stack[-4] = 0x0597 // @0592 stack[-2] = memory[0x40:0x60] // @0592 stack[-3] = memory[0x40:0x60] + returndata.length // } // Block ends with call to 0x381b, returns to 0x0597 label_0597: // Incoming return from call to 0x381B at 0x0596 0597 5B JUMPDEST 0598 61 PUSH2 0x1d24 059B 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1d24 label_059C: // Incoming return from call to 0x04E0 at 0x04DE // Inputs[1] { @059F stack[-1] } 059C 5B JUMPDEST 059D 60 PUSH1 0x01 059F 01 ADD 05A0 61 PUSH2 0x04c8 05A3 56 *JUMP // Stack delta = +0 // Outputs[1] { @059F stack[-1] = 0x01 + stack[-1] } // Block ends with unconditional jump to 0x04c8 label_05A4: // Incoming jump from 0x04D1, if !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x2053, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x04D1, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x2053, if !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Inputs[1] { @05A7 stack[-3] } 05A4 5B JUMPDEST 05A5 50 POP 05A6 50 POP 05A7 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_05A8: // Incoming call from 0x0271, returns to 0x0243 // Inputs[2] // { // @05A9 address(this) // @05A9 address(this).balance // } 05A8 5B JUMPDEST 05A9 47 SELFBALANCE 05AA 15 ISZERO 05AB 61 PUSH2 0x05b8 05AE 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05b8, if !address(this).balance label_05AF: // Incoming jump from 0x05AE, if not !address(this).balance // Inputs[3] // { // @05B2 msg.sender // @05B3 address(this).balance // @05B3 address(this) // } 05AF 61 PUSH2 0x05b8 05B2 33 CALLER 05B3 47 SELFBALANCE 05B4 61 PUSH2 0x1ef9 05B7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @05AF stack[0] = 0x05b8 // @05B2 stack[1] = msg.sender // @05B3 stack[2] = address(this).balance // } // Block ends with call to 0x1ef9, returns to 0x05B8 label_05B8: // Incoming return from call to 0x1EF9 at 0x05B7 // Incoming jump from 0x05AE, if !address(this).balance // Inputs[1] { @05B9 stack[-1] } 05B8 5B JUMPDEST 05B9 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_05BA: // Incoming jump from 0x20B7 // Incoming jump from 0x0291 // Inputs[1] { @05C0 stack[-1] } 05BA 5B JUMPDEST 05BB 60 PUSH1 0x00 05BD 61 PUSH2 0x05c5 05C0 82 DUP3 05C1 61 PUSH2 0x2047 05C4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @05BB stack[0] = 0x00 // @05BD stack[1] = 0x05c5 // @05C0 stack[2] = stack[-1] // } // Block ends with call to 0x2047, returns to 0x05C5 label_05C5: // Incoming return from call to 0x2047 at 0x05C4 // Inputs[3] // { // @05CA storage[0x05] // @05CB stack[-2] // @05CE memory[0x40:0x60] // } 05C5 5B JUMPDEST 05C6 60 PUSH1 0x00 05C8 60 PUSH1 0x05 05CA 54 SLOAD 05CB 83 DUP4 05CC 60 PUSH1 0x40 05CE 51 MLOAD 05CF 60 PUSH1 0x20 05D1 01 ADD 05D2 61 PUSH2 0x05dc 05D5 92 SWAP3 05D6 91 SWAP2 05D7 90 SWAP1 05D8 61 PUSH2 0x3d0b 05DB 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @05C6 stack[0] = 0x00 // @05D5 stack[1] = 0x05dc // @05D6 stack[2] = storage[0x05] // @05D7 stack[3] = stack[-2] // @05D7 stack[4] = 0x20 + memory[0x40:0x60] // } // Block ends with call to 0x3d0b, returns to 0x05DC label_05DC: // Incoming return from call to 0x3D0B at 0x0797 // Incoming return from call to 0x3D0B at 0x05DB // Inputs[5] // { // @05E0 memory[0x40:0x60] // @0603 stack[-1] // @060C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @0612 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @0613 stack[-3] // } 05DC 5B JUMPDEST 05DD 60 PUSH1 0x40 05DF 80 DUP1 05E0 51 MLOAD 05E1 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 0602 81 DUP2 0603 84 DUP5 0604 03 SUB 0605 01 ADD 0606 81 DUP2 0607 52 MSTORE 0608 91 SWAP2 0609 90 SWAP1 060A 52 MSTORE 060B 80 DUP1 060C 51 MLOAD 060D 60 PUSH1 0x20 060F 90 SWAP1 0610 91 SWAP2 0611 01 ADD 0612 20 SHA3 0613 91 SWAP2 0614 50 POP 0615 50 POP // Stack delta = -2 // Outputs[3] // { // @0607 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 // @060A memory[0x40:0x60] = stack[-1] // @0613 stack[-3] = keccak256(memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // } // Block continues label_0616: // Incoming return from call to 0x3E68 at 0x3221 // Incoming jump from 0x331C, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & 0xff // Incoming jump from 0x0615 // Inputs[3] // { // @0617 stack[-1] // @0617 stack[-3] // @0618 stack[-2] // } 0616 5B JUMPDEST 0617 91 SWAP2 0618 90 SWAP1 0619 50 POP 061A 56 *JUMP // Stack delta = -2 // Outputs[1] { @0617 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_061B: // Incoming jump from 0x02C7 // Inputs[7] // { // @061F stack[-7] // @0620 stack[-6] // @0621 stack[-5] // @0622 stack[-4] // @0623 stack[-3] // @0624 stack[-2] // @0625 stack[-1] // } 061B 5B JUMPDEST 061C 61 PUSH2 0x062a 061F 87 DUP8 0620 87 DUP8 0621 87 DUP8 0622 87 DUP8 0623 87 DUP8 0624 87 DUP8 0625 87 DUP8 0626 61 PUSH2 0x20ad 0629 56 *JUMP // Stack delta = +8 // Outputs[8] // { // @061C stack[0] = 0x062a // @061F stack[1] = stack[-7] // @0620 stack[2] = stack[-6] // @0621 stack[3] = stack[-5] // @0622 stack[4] = stack[-4] // @0623 stack[5] = stack[-3] // @0624 stack[6] = stack[-2] // @0625 stack[7] = stack[-1] // } // Block ends with unconditional jump to 0x20ad 062A 5B JUMPDEST 062B 60 PUSH1 0x05 062D 80 DUP1 062E 54 SLOAD 062F 60 PUSH1 0x02 0631 01 ADD 0632 90 SWAP1 0633 55 SSTORE 0634 60 PUSH1 0x00 0636 5B JUMPDEST 0637 87 DUP8 0638 51 MLOAD 0639 81 DUP2 063A 10 LT 063B 15 ISZERO 063C 61 PUSH2 0x076c 063F 57 *JUMPI 0640 60 PUSH1 0x03 0642 60 PUSH1 0x00 0644 89 DUP10 0645 83 DUP4 0646 81 DUP2 0647 51 MLOAD 0648 81 DUP2 0649 10 LT 064A 61 PUSH2 0x064f 064D 57 *JUMPI 064E FE *ASSERT 064F 5B JUMPDEST 0650 60 PUSH1 0x20 0652 90 SWAP1 0653 81 DUP2 0654 02 MUL 0655 91 SWAP2 0656 90 SWAP1 0657 91 SWAP2 0658 01 ADD 0659 81 DUP2 065A 01 ADD 065B 51 MLOAD 065C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0671 16 AND 0672 82 DUP3 0673 52 MSTORE 0674 81 DUP2 0675 01 ADD 0676 91 SWAP2 0677 90 SWAP1 0678 91 SWAP2 0679 52 MSTORE 067A 60 PUSH1 0x40 067C 01 ADD 067D 60 PUSH1 0x00 067F 20 SHA3 0680 54 SLOAD 0681 60 PUSH1 0xff 0683 16 AND 0684 15 ISZERO 0685 61 PUSH2 0x06f8 0688 57 *JUMPI 0689 60 PUSH1 0x00 068B 60 PUSH1 0x03 068D 60 PUSH1 0x00 068F 8A DUP11 0690 84 DUP5 0691 81 DUP2 0692 51 MLOAD 0693 81 DUP2 0694 10 LT 0695 61 PUSH2 0x069a 0698 57 *JUMPI 0699 FE *ASSERT 069A 5B JUMPDEST 069B 60 PUSH1 0x20 069D 02 MUL 069E 60 PUSH1 0x20 06A0 01 ADD 06A1 01 ADD 06A2 51 MLOAD 06A3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06B8 16 AND 06B9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06CE 16 AND 06CF 81 DUP2 06D0 52 MSTORE 06D1 60 PUSH1 0x20 06D3 01 ADD 06D4 90 SWAP1 06D5 81 DUP2 06D6 52 MSTORE 06D7 60 PUSH1 0x20 06D9 01 ADD 06DA 60 PUSH1 0x00 06DC 20 SHA3 06DD 60 PUSH1 0x00 06DF 61 PUSH2 0x0100 06E2 0A EXP 06E3 81 DUP2 06E4 54 SLOAD 06E5 81 DUP2 06E6 60 PUSH1 0xff 06E8 02 MUL 06E9 19 NOT 06EA 16 AND 06EB 90 SWAP1 06EC 83 DUP4 06ED 15 ISZERO 06EE 15 ISZERO 06EF 02 MUL 06F0 17 OR 06F1 90 SWAP1 06F2 55 SSTORE 06F3 50 POP 06F4 61 PUSH2 0x0764 06F7 56 *JUMP 06F8 5B JUMPDEST 06F9 60 PUSH1 0x01 06FB 60 PUSH1 0x03 06FD 60 PUSH1 0x00 06FF 8A DUP11 0700 84 DUP5 0701 81 DUP2 0702 51 MLOAD 0703 81 DUP2 0704 10 LT 0705 61 PUSH2 0x070a 0708 57 *JUMPI 0709 FE *ASSERT 070A 5B JUMPDEST 070B 60 PUSH1 0x20 070D 02 MUL 070E 60 PUSH1 0x20 0710 01 ADD 0711 01 ADD 0712 51 MLOAD 0713 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0728 16 AND 0729 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 073E 16 AND 073F 81 DUP2 0740 52 MSTORE 0741 60 PUSH1 0x20 0743 01 ADD 0744 90 SWAP1 0745 81 DUP2 0746 52 MSTORE 0747 60 PUSH1 0x20 0749 01 ADD 074A 60 PUSH1 0x00 074C 20 SHA3 074D 60 PUSH1 0x00 074F 61 PUSH2 0x0100 0752 0A EXP 0753 81 DUP2 0754 54 SLOAD 0755 81 DUP2 0756 60 PUSH1 0xff 0758 02 MUL 0759 19 NOT 075A 16 AND 075B 90 SWAP1 075C 83 DUP4 075D 15 ISZERO 075E 15 ISZERO 075F 02 MUL 0760 17 OR 0761 90 SWAP1 0762 55 SSTORE 0763 50 POP 0764 5B JUMPDEST 0765 60 PUSH1 0x01 0767 01 ADD 0768 61 PUSH2 0x0636 076B 56 *JUMP 076C 5B JUMPDEST 076D 50 POP 076E 50 POP 076F 50 POP 0770 50 POP 0771 50 POP 0772 50 POP 0773 50 POP 0774 50 POP 0775 56 *JUMP label_0776: // Incoming jump from 0x02E7 // Incoming jump from 0x237E // Inputs[1] { @077C stack[-1] } 0776 5B JUMPDEST 0777 60 PUSH1 0x00 0779 61 PUSH2 0x0781 077C 82 DUP3 077D 61 PUSH2 0x2047 0780 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0777 stack[0] = 0x00 // @0779 stack[1] = 0x0781 // @077C stack[2] = stack[-1] // } // Block ends with call to 0x2047, returns to 0x0781 label_0781: // Incoming return from call to 0x2047 at 0x0780 // Inputs[3] // { // @0786 storage[0x04] // @0787 stack[-2] // @078A memory[0x40:0x60] // } 0781 5B JUMPDEST 0782 60 PUSH1 0x00 0784 60 PUSH1 0x04 0786 54 SLOAD 0787 83 DUP4 0788 60 PUSH1 0x40 078A 51 MLOAD 078B 60 PUSH1 0x20 078D 01 ADD 078E 61 PUSH2 0x05dc 0791 92 SWAP3 0792 91 SWAP2 0793 90 SWAP1 0794 61 PUSH2 0x3d0b 0797 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0782 stack[0] = 0x00 // @0791 stack[1] = 0x05dc // @0792 stack[2] = storage[0x04] // @0793 stack[3] = stack[-2] // @0793 stack[4] = 0x20 + memory[0x40:0x60] // } // Block ends with call to 0x3d0b, returns to 0x05DC 0798 5B JUMPDEST 0799 60 PUSH1 0x00 079B 81 DUP2 079C 60 PUSH1 0x80 079E 01 ADD 079F 35 CALLDATALOAD 07A0 80 DUP1 07A1 61 PUSH2 0x07a8 07A4 61 PUSH2 0x21ea 07A7 56 *JUMP 07A8 5B JUMPDEST 07A9 11 GT 07AA 15 ISZERO 07AB 61 PUSH2 0x0815 07AE 57 *JUMPI 07AF 60 PUSH1 0x40 07B1 80 DUP1 07B2 51 MLOAD 07B3 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 07D4 81 DUP2 07D5 52 MSTORE 07D6 60 PUSH1 0x20 07D8 60 PUSH1 0x04 07DA 82 DUP3 07DB 01 ADD 07DC 52 MSTORE 07DD 60 PUSH1 0x13 07DF 60 PUSH1 0x24 07E1 82 DUP3 07E2 01 ADD 07E3 52 MSTORE 07E4 7F PUSH32 0x5472616e73616374696f6e20746f6f206f6c6400000000000000000000000000 0805 60 PUSH1 0x44 0807 82 DUP3 0808 01 ADD 0809 52 MSTORE 080A 90 SWAP1 080B 51 MLOAD 080C 90 SWAP1 080D 81 DUP2 080E 90 SWAP1 080F 03 SUB 0810 60 PUSH1 0x64 0812 01 ADD 0813 90 SWAP1 0814 FD *REVERT 0815 5B JUMPDEST 0816 60 PUSH1 0x20 0818 83 DUP4 0819 81 DUP2 081A 01 ADD 081B 35 CALLDATALOAD 081C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0831 16 AND 0832 60 PUSH1 0x00 0834 81 DUP2 0835 81 DUP2 0836 52 MSTORE 0837 60 PUSH1 0x02 0839 90 SWAP1 083A 92 SWAP3 083B 52 MSTORE 083C 60 PUSH1 0x40 083E 90 SWAP1 083F 91 SWAP2 0840 20 SHA3 0841 54 SLOAD 0842 60 PUSH1 0xff 0844 16 AND 0845 61 PUSH2 0x0883 0848 57 *JUMPI 0849 60 PUSH1 0x40 084B 51 MLOAD 084C 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 086D 81 DUP2 086E 52 MSTORE 086F 60 PUSH1 0x04 0871 01 ADD 0872 61 PUSH2 0x087a 0875 90 SWAP1 0876 61 PUSH2 0x3bb0 0879 56 *JUMP label_087A: // Incoming return from call to 0x3B42 at 0x20A4 // Incoming return from call to 0x3BB0 at 0x1A8D // Inputs[3] // { // @087D memory[0x40:0x60] // @087F stack[-1] // @0882 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 087A 5B JUMPDEST 087B 60 PUSH1 0x40 087D 51 MLOAD 087E 80 DUP1 087F 91 SWAP2 0880 03 SUB 0881 90 SWAP1 0882 FD *REVERT // Stack delta = -1 // Outputs[1] { @0882 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates 0883 5B JUMPDEST 0884 61 PUSH2 0x0929 0887 60 PUSH1 0xa0 0889 85 DUP6 088A 01 ADD 088B 35 CALLDATALOAD 088C 61 PUSH2 0x089b 088F 60 PUSH1 0x80 0891 87 DUP8 0892 01 ADD 0893 60 PUSH1 0x60 0895 88 DUP9 0896 01 ADD 0897 61 PUSH2 0x3321 089A 56 *JUMP 089B 5B JUMPDEST 089C 61 PUSH2 0x08ac 089F 61 PUSH2 0x0100 08A2 88 DUP9 08A3 01 ADD 08A4 60 PUSH1 0xe0 08A6 89 DUP10 08A7 01 ADD 08A8 61 PUSH2 0x3321 08AB 56 *JUMP 08AC 5B JUMPDEST 08AD 60 PUSH1 0x40 08AF 80 DUP1 08B0 51 MLOAD 08B1 80 DUP1 08B2 82 DUP3 08B3 01 ADD 08B4 90 SWAP1 08B5 91 SWAP2 08B6 52 MSTORE 08B7 80 DUP1 08B8 61 PUSH2 0x08c4 08BB 60 PUSH1 0x20 08BD 8B DUP12 08BE 01 ADD 08BF 8B DUP12 08C0 61 PUSH2 0x3321 08C3 56 *JUMP 08C4 5B JUMPDEST 08C5 61 PUSH2 0x08d4 08C8 60 PUSH1 0x60 08CA 8C DUP13 08CB 01 ADD 08CC 60 PUSH1 0x40 08CE 8D DUP14 08CF 01 ADD 08D0 61 PUSH2 0x37f8 08D3 56 *JUMP 08D4 5B JUMPDEST 08D5 61 PUSH2 0x08e4 08D8 60 PUSH1 0x40 08DA 8D DUP14 08DB 01 ADD 08DC 60 PUSH1 0x20 08DE 8E DUP15 08DF 01 ADD 08E0 61 PUSH2 0x3321 08E3 56 *JUMP 08E4 5B JUMPDEST 08E5 60 PUSH1 0x40 08E7 51 MLOAD 08E8 60 PUSH1 0x20 08EA 01 ADD 08EB 61 PUSH2 0x08f6 08EE 93 SWAP4 08EF 92 SWAP3 08F0 91 SWAP2 08F1 90 SWAP1 08F2 61 PUSH2 0x38f5 08F5 56 *JUMP 08F6 5B JUMPDEST 08F7 60 PUSH1 0x40 08F9 51 MLOAD 08FA 60 PUSH1 0x20 08FC 81 DUP2 08FD 83 DUP4 08FE 03 SUB 08FF 03 SUB 0900 81 DUP2 0901 52 MSTORE 0902 90 SWAP1 0903 60 PUSH1 0x40 0905 52 MSTORE 0906 81 DUP2 0907 52 MSTORE 0908 60 PUSH1 0x20 090A 01 ADD 090B 33 CALLER 090C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0921 16 AND 0922 81 DUP2 0923 52 MSTORE 0924 50 POP 0925 61 PUSH2 0x21ee 0928 56 *JUMP 0929 5B JUMPDEST 092A 92 SWAP3 092B 50 POP 092C 83 DUP4 092D 60 PUSH1 0xc0 092F 01 ADD 0930 35 CALLDATALOAD 0931 83 DUP4 0932 10 LT 0933 15 ISZERO 0934 61 PUSH2 0x0969 0937 57 *JUMPI 0938 60 PUSH1 0x40 093A 51 MLOAD 093B 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 095C 81 DUP2 095D 52 MSTORE 095E 60 PUSH1 0x04 0960 01 ADD 0961 61 PUSH2 0x087a 0964 90 SWAP1 0965 61 PUSH2 0x3c8c 0968 56 *JUMP 0969 5B JUMPDEST 096A 50 POP 096B 50 POP 096C 91 SWAP2 096D 90 SWAP1 096E 50 POP 096F 56 *JUMP label_0970: // Incoming call from 0x106C, returns to 0x0F8F // Incoming jump from 0x030D // Inputs[11] // { // @0974 memory[0x40:0x60] // @0998 msg.sender // @099E address(this) // @09A8 stack[-5] // @09AF stack[-4] // @09BB stack[-3] // @09C6 stack[-2] // @09CD stack[-1] // @09D1 memory[0x40:0x60] // @09E7 stack[-6] // @0A04 address(stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } 0970 5B JUMPDEST 0971 60 PUSH1 0x40 0973 80 DUP1 0974 51 MLOAD 0975 7F PUSH32 0x8fcbaf0c00000000000000000000000000000000000000000000000000000000 0996 81 DUP2 0997 52 MSTORE 0998 33 CALLER 0999 60 PUSH1 0x04 099B 82 DUP3 099C 01 ADD 099D 52 MSTORE 099E 30 ADDRESS 099F 60 PUSH1 0x24 09A1 82 DUP3 09A2 01 ADD 09A3 52 MSTORE 09A4 60 PUSH1 0x44 09A6 81 DUP2 09A7 01 ADD 09A8 87 DUP8 09A9 90 SWAP1 09AA 52 MSTORE 09AB 60 PUSH1 0x64 09AD 81 DUP2 09AE 01 ADD 09AF 86 DUP7 09B0 90 SWAP1 09B1 52 MSTORE 09B2 60 PUSH1 0x01 09B4 60 PUSH1 0x84 09B6 82 DUP3 09B7 01 ADD 09B8 52 MSTORE 09B9 60 PUSH1 0xff 09BB 85 DUP6 09BC 16 AND 09BD 60 PUSH1 0xa4 09BF 82 DUP3 09C0 01 ADD 09C1 52 MSTORE 09C2 60 PUSH1 0xc4 09C4 81 DUP2 09C5 01 ADD 09C6 84 DUP5 09C7 90 SWAP1 09C8 52 MSTORE 09C9 60 PUSH1 0xe4 09CB 81 DUP2 09CC 01 ADD 09CD 83 DUP4 09CE 90 SWAP1 09CF 52 MSTORE 09D0 90 SWAP1 09D1 51 MLOAD 09D2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09E7 88 DUP9 09E8 16 AND 09E9 91 SWAP2 09EA 63 PUSH4 0x8fcbaf0c 09EF 91 SWAP2 09F0 61 PUSH2 0x0104 09F3 80 DUP1 09F4 83 DUP4 09F5 01 ADD 09F6 92 SWAP3 09F7 60 PUSH1 0x00 09F9 92 SWAP3 09FA 91 SWAP2 09FB 90 SWAP1 09FC 82 DUP3 09FD 90 SWAP1 09FE 03 SUB 09FF 01 ADD 0A00 81 DUP2 0A01 83 DUP4 0A02 87 DUP8 0A03 80 DUP1 0A04 3B EXTCODESIZE 0A05 15 ISZERO 0A06 80 DUP1 0A07 15 ISZERO 0A08 61 PUSH2 0x0a10 0A0B 57 *JUMPI // Stack delta = +10 // Outputs[19] // { // @0997 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x8fcbaf0c00000000000000000000000000000000000000000000000000000000 // @099D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = msg.sender // @09A3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = address(this) // @09AA memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-5] // @09B1 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = stack[-4] // @09B8 memory[memory[0x40:0x60] + 0x84:memory[0x40:0x60] + 0x84 + 0x20] = 0x01 // @09C1 memory[memory[0x40:0x60] + 0xa4:memory[0x40:0x60] + 0xa4 + 0x20] = stack[-3] & 0xff // @09C8 memory[memory[0x40:0x60] + 0xc4:memory[0x40:0x60] + 0xc4 + 0x20] = stack[-2] // @09CF memory[memory[0x40:0x60] + 0xe4:memory[0x40:0x60] + 0xe4 + 0x20] = stack[-1] // @09E9 stack[0] = stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff // @09EF stack[1] = 0x8fcbaf0c // @09F6 stack[2] = memory[0x40:0x60] + 0x0104 // @09F9 stack[3] = 0x00 // @09FA stack[4] = memory[0x40:0x60] // @09FF stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0x0104 // @0A00 stack[6] = memory[0x40:0x60] // @0A01 stack[7] = 0x00 // @0A02 stack[8] = stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff // @0A05 stack[9] = !address(stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } // Block ends with conditional jump to 0x0a10, if !!address(stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff).code.length label_0A0C: // Incoming jump from 0x0A0B, if not !!address(stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[1] { @0A0F memory[0x00:0x00] } 0A0C 60 PUSH1 0x00 0A0E 80 DUP1 0A0F FD *REVERT // Stack delta = +0 // Outputs[1] { @0A0F revert(memory[0x00:0x00]); } // Block terminates label_0A10: // Incoming jump from 0x1BD8, if !!address(stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Incoming jump from 0x0A0B, if !!address(stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[9] // { // @0A12 msg.gas // @0A13 stack[-2] // @0A13 stack[-7] // @0A13 stack[-4] // @0A13 stack[-6] // @0A13 memory[stack[-4]:stack[-4] + stack[-5]] // @0A13 stack[-3] // @0A13 stack[-5] // @0A13 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 0A10 5B JUMPDEST 0A11 50 POP 0A12 5A GAS 0A13 F1 CALL 0A14 15 ISZERO 0A15 80 DUP1 0A16 15 ISZERO 0A17 61 PUSH2 0x0a24 0A1A 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0A13 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0A14 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x0a24, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0A1B: // Incoming jump from 0x0A1A, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0A1B returndata.length // @0A1F returndata[0x00:0x00 + returndata.length] // @0A20 returndata.length // @0A23 memory[0x00:0x00 + returndata.length] // } 0A1B 3D RETURNDATASIZE 0A1C 60 PUSH1 0x00 0A1E 80 DUP1 0A1F 3E RETURNDATACOPY 0A20 3D RETURNDATASIZE 0A21 60 PUSH1 0x00 0A23 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0A1F memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0A23 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0A24: // Incoming jump from 0x0A1A, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @0A2F stack[-11] } 0A24 5B JUMPDEST 0A25 50 POP 0A26 50 POP 0A27 50 POP 0A28 50 POP 0A29 50 POP 0A2A 50 POP 0A2B 50 POP 0A2C 50 POP 0A2D 50 POP 0A2E 50 POP 0A2F 56 *JUMP // Stack delta = -11 // Block ends with unconditional jump to stack[-11] label_0A30: // Incoming jump from 0x0320 // Inputs[4] // { // @0A6F address(this) // @0A72 memory[0x40:0x60] // @0AA6 memory[0x40:0x60] // @0AAD address(0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // } 0A30 5B JUMPDEST 0A31 60 PUSH1 0x00 0A33 7F PUSH32 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 0A54 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A69 16 AND 0A6A 63 PUSH4 0x70a08231 0A6F 30 ADDRESS 0A70 60 PUSH1 0x40 0A72 51 MLOAD 0A73 82 DUP3 0A74 63 PUSH4 0xffffffff 0A79 16 AND 0A7A 60 PUSH1 0xe0 0A7C 1B SHL 0A7D 81 DUP2 0A7E 52 MSTORE 0A7F 60 PUSH1 0x04 0A81 01 ADD 0A82 80 DUP1 0A83 82 DUP3 0A84 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A99 16 AND 0A9A 81 DUP2 0A9B 52 MSTORE 0A9C 60 PUSH1 0x20 0A9E 01 ADD 0A9F 91 SWAP2 0AA0 50 POP 0AA1 50 POP 0AA2 60 PUSH1 0x20 0AA4 60 PUSH1 0x40 0AA6 51 MLOAD 0AA7 80 DUP1 0AA8 83 DUP4 0AA9 03 SUB 0AAA 81 DUP2 0AAB 86 DUP7 0AAC 80 DUP1 0AAD 3B EXTCODESIZE 0AAE 15 ISZERO 0AAF 80 DUP1 0AB0 15 ISZERO 0AB1 61 PUSH2 0x0ab9 0AB4 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @0A31 stack[0] = 0x00 // @0A69 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @0A6A stack[2] = 0x70a08231 // @0A7E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x70a08231) << 0xe0 // @0A9B memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & address(this) // @0A9F stack[3] = 0x20 + 0x04 + memory[0x40:0x60] // @0AA2 stack[4] = 0x20 // @0AA6 stack[5] = memory[0x40:0x60] // @0AA9 stack[6] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @0AAA stack[7] = memory[0x40:0x60] // @0AAB stack[8] = 0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @0AAE stack[9] = !address(0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // } // Block ends with conditional jump to 0x0ab9, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length label_0AB5: // Incoming jump from 0x0AB4, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Inputs[1] { @0AB8 memory[0x00:0x00] } 0AB5 60 PUSH1 0x00 0AB7 80 DUP1 0AB8 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AB8 revert(memory[0x00:0x00]); } // Block terminates label_0AB9: // Incoming jump from 0x0AB4, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Inputs[8] // { // @0ABB msg.gas // @0ABC stack[-2] // @0ABC stack[-4] // @0ABC address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0ABC memory[stack[-3]:stack[-3] + stack[-4]] // @0ABC stack[-3] // @0ABC stack[-6] // @0ABC stack[-5] // } 0AB9 5B JUMPDEST 0ABA 50 POP 0ABB 5A GAS 0ABC FA STATICCALL 0ABD 15 ISZERO 0ABE 80 DUP1 0ABF 15 ISZERO 0AC0 61 PUSH2 0x0acd 0AC3 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0ABC memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0ABD stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0acd, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0AC4: // Incoming jump from 0x0AC3, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0AC4 returndata.length // @0AC8 returndata[0x00:0x00 + returndata.length] // @0AC9 returndata.length // @0ACC memory[0x00:0x00 + returndata.length] // } 0AC4 3D RETURNDATASIZE 0AC5 60 PUSH1 0x00 0AC7 80 DUP1 0AC8 3E RETURNDATACOPY 0AC9 3D RETURNDATASIZE 0ACA 60 PUSH1 0x00 0ACC FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0AC8 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0ACC revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0ACD: // Incoming jump from 0x0AC3, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0AD4 memory[0x40:0x60] // @0AD5 returndata.length // } 0ACD 5B JUMPDEST 0ACE 50 POP 0ACF 50 POP 0AD0 50 POP 0AD1 50 POP 0AD2 60 PUSH1 0x40 0AD4 51 MLOAD 0AD5 3D RETURNDATASIZE 0AD6 60 PUSH1 0x20 0AD8 81 DUP2 0AD9 10 LT 0ADA 15 ISZERO 0ADB 61 PUSH2 0x0ae3 0ADE 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0AD4 stack[-4] = memory[0x40:0x60] // @0AD5 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0ae3, if !(returndata.length < 0x20) label_0ADF: // Incoming jump from 0x0ADE, if not !(returndata.length < 0x20) // Inputs[1] { @0AE2 memory[0x00:0x00] } 0ADF 60 PUSH1 0x00 0AE1 80 DUP1 0AE2 FD *REVERT // Stack delta = +0 // Outputs[1] { @0AE2 revert(memory[0x00:0x00]); } // Block terminates label_0AE3: // Incoming jump from 0x0ADE, if !(returndata.length < 0x20) // Inputs[4] // { // @0AE5 stack[-2] // @0AE5 memory[stack[-2]:stack[-2] + 0x20] // @0AE6 stack[-3] // @0AE8 stack[-5] // } 0AE3 5B JUMPDEST 0AE4 50 POP 0AE5 51 MLOAD 0AE6 90 SWAP1 0AE7 50 POP 0AE8 82 DUP3 0AE9 81 DUP2 0AEA 10 LT 0AEB 15 ISZERO 0AEC 61 PUSH2 0x0b56 0AEF 57 *JUMPI // Stack delta = -2 // Outputs[1] { @0AE6 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x0b56, if !(memory[stack[-2]:stack[-2] + 0x20] < stack[-5]) label_0AF0: // Incoming jump from 0x0AEF, if not !(memory[stack[-2]:stack[-2] + 0x20] < stack[-5]) // Inputs[3] // { // @0AF3 memory[0x40:0x60] // @0B4C memory[0x40:0x60] // @0B55 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0AF0 60 PUSH1 0x40 0AF2 80 DUP1 0AF3 51 MLOAD 0AF4 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0B15 81 DUP2 0B16 52 MSTORE 0B17 60 PUSH1 0x20 0B19 60 PUSH1 0x04 0B1B 82 DUP3 0B1C 01 ADD 0B1D 52 MSTORE 0B1E 60 PUSH1 0x12 0B20 60 PUSH1 0x24 0B22 82 DUP3 0B23 01 ADD 0B24 52 MSTORE 0B25 7F PUSH32 0x496e73756666696369656e742057455448390000000000000000000000000000 0B46 60 PUSH1 0x44 0B48 82 DUP3 0B49 01 ADD 0B4A 52 MSTORE 0B4B 90 SWAP1 0B4C 51 MLOAD 0B4D 90 SWAP1 0B4E 81 DUP2 0B4F 90 SWAP1 0B50 03 SUB 0B51 60 PUSH1 0x64 0B53 01 ADD 0B54 90 SWAP1 0B55 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0B16 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0B1D memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0B24 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x12 // @0B4A memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x496e73756666696369656e742057455448390000000000000000000000000000 // @0B55 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0B56: // Incoming jump from 0x0AEF, if !(memory[stack[-2]:stack[-2] + 0x20] < stack[-5]) // Inputs[1] { @0B57 stack[-1] } 0B56 5B JUMPDEST 0B57 80 DUP1 0B58 15 ISZERO 0B59 61 PUSH2 0x0bf1 0B5C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bf1, if !stack[-1] label_0B5D: // Incoming jump from 0x0B5C, if not !stack[-1] // Inputs[4] // { // @0B99 stack[-1] // @0B9C memory[0x40:0x60] // @0BBA memory[0x40:0x60] // @0BC3 address(0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // } 0B5D 7F PUSH32 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 0B7E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B93 16 AND 0B94 63 PUSH4 0x2e1a7d4d 0B99 82 DUP3 0B9A 60 PUSH1 0x40 0B9C 51 MLOAD 0B9D 82 DUP3 0B9E 63 PUSH4 0xffffffff 0BA3 16 AND 0BA4 60 PUSH1 0xe0 0BA6 1B SHL 0BA7 81 DUP2 0BA8 52 MSTORE 0BA9 60 PUSH1 0x04 0BAB 01 ADD 0BAC 80 DUP1 0BAD 82 DUP3 0BAE 81 DUP2 0BAF 52 MSTORE 0BB0 60 PUSH1 0x20 0BB2 01 ADD 0BB3 91 SWAP2 0BB4 50 POP 0BB5 50 POP 0BB6 60 PUSH1 0x00 0BB8 60 PUSH1 0x40 0BBA 51 MLOAD 0BBB 80 DUP1 0BBC 83 DUP4 0BBD 03 SUB 0BBE 81 DUP2 0BBF 60 PUSH1 0x00 0BC1 87 DUP8 0BC2 80 DUP1 0BC3 3B EXTCODESIZE 0BC4 15 ISZERO 0BC5 80 DUP1 0BC6 15 ISZERO 0BC7 61 PUSH2 0x0bcf 0BCA 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @0B93 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @0B94 stack[1] = 0x2e1a7d4d // @0BA8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x2e1a7d4d) << 0xe0 // @0BAF memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-1] // @0BB3 stack[2] = 0x20 + 0x04 + memory[0x40:0x60] // @0BB6 stack[3] = 0x00 // @0BBA stack[4] = memory[0x40:0x60] // @0BBD stack[5] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @0BBE stack[6] = memory[0x40:0x60] // @0BBF stack[7] = 0x00 // @0BC1 stack[8] = 0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @0BC4 stack[9] = !address(0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // } // Block ends with conditional jump to 0x0bcf, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length label_0BCB: // Incoming jump from 0x0BCA, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Inputs[1] { @0BCE memory[0x00:0x00] } 0BCB 60 PUSH1 0x00 0BCD 80 DUP1 0BCE FD *REVERT // Stack delta = +0 // Outputs[1] { @0BCE revert(memory[0x00:0x00]); } // Block terminates label_0BCF: // Incoming jump from 0x0BCA, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Inputs[9] // { // @0BD1 msg.gas // @0BD2 stack[-3] // @0BD2 stack[-6] // @0BD2 stack[-7] // @0BD2 memory[stack[-4]:stack[-4] + stack[-5]] // @0BD2 stack[-2] // @0BD2 stack[-5] // @0BD2 stack[-4] // @0BD2 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } 0BCF 5B JUMPDEST 0BD0 50 POP 0BD1 5A GAS 0BD2 F1 CALL 0BD3 15 ISZERO 0BD4 80 DUP1 0BD5 15 ISZERO 0BD6 61 PUSH2 0x0be3 0BD9 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0BD2 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0BD3 stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x0be3, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0BDA: // Incoming jump from 0x0BD9, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0BDA returndata.length // @0BDE returndata[0x00:0x00 + returndata.length] // @0BDF returndata.length // @0BE2 memory[0x00:0x00 + returndata.length] // } 0BDA 3D RETURNDATASIZE 0BDB 60 PUSH1 0x00 0BDD 80 DUP1 0BDE 3E RETURNDATACOPY 0BDF 3D RETURNDATASIZE 0BE0 60 PUSH1 0x00 0BE2 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0BDE memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0BE2 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0BE3: // Incoming jump from 0x0BD9, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @0BEB stack[-6] // @0BEC stack[-5] // } 0BE3 5B JUMPDEST 0BE4 50 POP 0BE5 50 POP 0BE6 50 POP 0BE7 50 POP 0BE8 61 PUSH2 0x0bf1 0BEB 82 DUP3 0BEC 82 DUP3 0BED 61 PUSH2 0x1ef9 0BF0 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0BE8 stack[-4] = 0x0bf1 // @0BEB stack[-3] = stack[-6] // @0BEC stack[-2] = stack[-5] // } // Block ends with call to 0x1ef9, returns to 0x0BF1 label_0BF1: // Incoming jump from 0x1FE0, if stack[-3] // Incoming jump from 0x1FE0, if stack[-3] // Incoming jump from 0x1949, if returndata.length == 0x00 // Incoming jump from 0x196A // Incoming return from call to 0x1EF9 at 0x0BF0 // Incoming jump from 0x0B5C, if !stack[-1] // Inputs[1] { @0BF5 stack[-4] } 0BF1 5B JUMPDEST 0BF2 50 POP 0BF3 50 POP 0BF4 50 POP 0BF5 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_0BF6: // Incoming call from 0x0335, returns to 0x0336 // Inputs[1] { @0C18 stack[-1] } 0BF6 5B JUMPDEST 0BF7 7F PUSH32 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 0C18 81 DUP2 0C19 56 *JUMP // Stack delta = +1 // Outputs[1] { @0BF7 stack[0] = 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 } // Block ends with unconditional jump to stack[-1] 0C1A 5B JUMPDEST 0C1B 60 PUSH1 0x03 0C1D 60 PUSH1 0x20 0C1F 52 MSTORE 0C20 60 PUSH1 0x00 0C22 90 SWAP1 0C23 81 DUP2 0C24 52 MSTORE 0C25 60 PUSH1 0x40 0C27 90 SWAP1 0C28 20 SHA3 0C29 54 SLOAD 0C2A 60 PUSH1 0xff 0C2C 16 AND 0C2D 81 DUP2 0C2E 56 *JUMP label_0C2F: // Incoming jump from 0x038F // Inputs[7] // { // @0C33 stack[-7] // @0C34 stack[-6] // @0C35 stack[-5] // @0C36 stack[-4] // @0C37 stack[-3] // @0C38 stack[-2] // @0C39 stack[-1] // } 0C2F 5B JUMPDEST 0C30 61 PUSH2 0x0c3e 0C33 87 DUP8 0C34 87 DUP8 0C35 87 DUP8 0C36 87 DUP8 0C37 87 DUP8 0C38 87 DUP8 0C39 87 DUP8 0C3A 61 PUSH2 0x2374 0C3D 56 *JUMP // Stack delta = +8 // Outputs[8] // { // @0C30 stack[0] = 0x0c3e // @0C33 stack[1] = stack[-7] // @0C34 stack[2] = stack[-6] // @0C35 stack[3] = stack[-5] // @0C36 stack[4] = stack[-4] // @0C37 stack[5] = stack[-3] // @0C38 stack[6] = stack[-2] // @0C39 stack[7] = stack[-1] // } // Block ends with unconditional jump to 0x2374 0C3E 5B JUMPDEST 0C3F 60 PUSH1 0x04 0C41 80 DUP1 0C42 54 SLOAD 0C43 60 PUSH1 0x02 0C45 01 ADD 0C46 90 SWAP1 0C47 55 SSTORE 0C48 60 PUSH1 0x00 0C4A 5B JUMPDEST 0C4B 87 DUP8 0C4C 51 MLOAD 0C4D 81 DUP2 0C4E 10 LT 0C4F 15 ISZERO 0C50 61 PUSH2 0x076c 0C53 57 *JUMPI 0C54 60 PUSH1 0x02 0C56 60 PUSH1 0x00 0C58 89 DUP10 0C59 83 DUP4 0C5A 81 DUP2 0C5B 51 MLOAD 0C5C 81 DUP2 0C5D 10 LT 0C5E 61 PUSH2 0x0c63 0C61 57 *JUMPI 0C62 FE *ASSERT 0C63 5B JUMPDEST 0C64 60 PUSH1 0x20 0C66 90 SWAP1 0C67 81 DUP2 0C68 02 MUL 0C69 91 SWAP2 0C6A 90 SWAP1 0C6B 91 SWAP2 0C6C 01 ADD 0C6D 81 DUP2 0C6E 01 ADD 0C6F 51 MLOAD 0C70 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C85 16 AND 0C86 82 DUP3 0C87 52 MSTORE 0C88 81 DUP2 0C89 01 ADD 0C8A 91 SWAP2 0C8B 90 SWAP1 0C8C 91 SWAP2 0C8D 52 MSTORE 0C8E 60 PUSH1 0x40 0C90 01 ADD 0C91 60 PUSH1 0x00 0C93 20 SHA3 0C94 54 SLOAD 0C95 60 PUSH1 0xff 0C97 16 AND 0C98 15 ISZERO 0C99 61 PUSH2 0x0d0c 0C9C 57 *JUMPI 0C9D 60 PUSH1 0x00 0C9F 60 PUSH1 0x02 0CA1 60 PUSH1 0x00 0CA3 8A DUP11 0CA4 84 DUP5 0CA5 81 DUP2 0CA6 51 MLOAD 0CA7 81 DUP2 0CA8 10 LT 0CA9 61 PUSH2 0x0cae 0CAC 57 *JUMPI 0CAD FE *ASSERT 0CAE 5B JUMPDEST 0CAF 60 PUSH1 0x20 0CB1 02 MUL 0CB2 60 PUSH1 0x20 0CB4 01 ADD 0CB5 01 ADD 0CB6 51 MLOAD 0CB7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CCC 16 AND 0CCD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0CE2 16 AND 0CE3 81 DUP2 0CE4 52 MSTORE 0CE5 60 PUSH1 0x20 0CE7 01 ADD 0CE8 90 SWAP1 0CE9 81 DUP2 0CEA 52 MSTORE 0CEB 60 PUSH1 0x20 0CED 01 ADD 0CEE 60 PUSH1 0x00 0CF0 20 SHA3 0CF1 60 PUSH1 0x00 0CF3 61 PUSH2 0x0100 0CF6 0A EXP 0CF7 81 DUP2 0CF8 54 SLOAD 0CF9 81 DUP2 0CFA 60 PUSH1 0xff 0CFC 02 MUL 0CFD 19 NOT 0CFE 16 AND 0CFF 90 SWAP1 0D00 83 DUP4 0D01 15 ISZERO 0D02 15 ISZERO 0D03 02 MUL 0D04 17 OR 0D05 90 SWAP1 0D06 55 SSTORE 0D07 50 POP 0D08 61 PUSH2 0x0d78 0D0B 56 *JUMP 0D0C 5B JUMPDEST 0D0D 60 PUSH1 0x01 0D0F 60 PUSH1 0x02 0D11 60 PUSH1 0x00 0D13 8A DUP11 0D14 84 DUP5 0D15 81 DUP2 0D16 51 MLOAD 0D17 81 DUP2 0D18 10 LT 0D19 61 PUSH2 0x0d1e 0D1C 57 *JUMPI 0D1D FE *ASSERT 0D1E 5B JUMPDEST 0D1F 60 PUSH1 0x20 0D21 02 MUL 0D22 60 PUSH1 0x20 0D24 01 ADD 0D25 01 ADD 0D26 51 MLOAD 0D27 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D3C 16 AND 0D3D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0D52 16 AND 0D53 81 DUP2 0D54 52 MSTORE 0D55 60 PUSH1 0x20 0D57 01 ADD 0D58 90 SWAP1 0D59 81 DUP2 0D5A 52 MSTORE 0D5B 60 PUSH1 0x20 0D5D 01 ADD 0D5E 60 PUSH1 0x00 0D60 20 SHA3 0D61 60 PUSH1 0x00 0D63 61 PUSH2 0x0100 0D66 0A EXP 0D67 81 DUP2 0D68 54 SLOAD 0D69 81 DUP2 0D6A 60 PUSH1 0xff 0D6C 02 MUL 0D6D 19 NOT 0D6E 16 AND 0D6F 90 SWAP1 0D70 83 DUP4 0D71 15 ISZERO 0D72 15 ISZERO 0D73 02 MUL 0D74 17 OR 0D75 90 SWAP1 0D76 55 SSTORE 0D77 50 POP 0D78 5B JUMPDEST 0D79 60 PUSH1 0x01 0D7B 01 ADD 0D7C 61 PUSH2 0x0c4a 0D7F 56 *JUMP label_0D80: // Incoming jump from 0x03A2 // Inputs[1] { @0D83 stack[-2] } 0D80 5B JUMPDEST 0D81 60 PUSH1 0x00 0D83 82 DUP3 0D84 11 GT 0D85 80 DUP1 0D86 15 ISZERO 0D87 61 PUSH2 0x0d91 0D8A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0D84 stack[0] = stack[-2] > 0x00 } // Block ends with conditional jump to 0x0d91, if !(stack[-2] > 0x00) label_0D8B: // Incoming jump from 0x0D8A, if not !(stack[-2] > 0x00) // Inputs[1] { @0D8E stack[-3] } 0D8B 50 POP 0D8C 60 PUSH1 0x64 0D8E 82 DUP3 0D8F 11 GT 0D90 15 ISZERO 0D91 5B JUMPDEST 0D92 61 PUSH2 0x0d9a 0D95 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0d9a, if !(stack[-3] > 0x64) label_0D96: // Incoming jump from 0x0D95, if not !(stack[-3] > 0x64) // Incoming jump from 0x0D95, if not stack[-1] // Inputs[1] { @0D99 memory[0x00:0x00] } 0D96 60 PUSH1 0x00 0D98 80 DUP1 0D99 FD *REVERT // Stack delta = +0 // Outputs[1] { @0D99 revert(memory[0x00:0x00]); } // Block terminates label_0D9A: // Incoming jump from 0x0D95, if !(stack[-3] > 0x64) // Incoming jump from 0x0D95, if stack[-1] // Inputs[4] // { // @0DD9 address(this) // @0DDC memory[0x40:0x60] // @0E10 memory[0x40:0x60] // @0E17 address(0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // } 0D9A 5B JUMPDEST 0D9B 60 PUSH1 0x00 0D9D 7F PUSH32 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 0DBE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0DD3 16 AND 0DD4 63 PUSH4 0x70a08231 0DD9 30 ADDRESS 0DDA 60 PUSH1 0x40 0DDC 51 MLOAD 0DDD 82 DUP3 0DDE 63 PUSH4 0xffffffff 0DE3 16 AND 0DE4 60 PUSH1 0xe0 0DE6 1B SHL 0DE7 81 DUP2 0DE8 52 MSTORE 0DE9 60 PUSH1 0x04 0DEB 01 ADD 0DEC 80 DUP1 0DED 82 DUP3 0DEE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E03 16 AND 0E04 81 DUP2 0E05 52 MSTORE 0E06 60 PUSH1 0x20 0E08 01 ADD 0E09 91 SWAP2 0E0A 50 POP 0E0B 50 POP 0E0C 60 PUSH1 0x20 0E0E 60 PUSH1 0x40 0E10 51 MLOAD 0E11 80 DUP1 0E12 83 DUP4 0E13 03 SUB 0E14 81 DUP2 0E15 86 DUP7 0E16 80 DUP1 0E17 3B EXTCODESIZE 0E18 15 ISZERO 0E19 80 DUP1 0E1A 15 ISZERO 0E1B 61 PUSH2 0x0e23 0E1E 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @0D9B stack[0] = 0x00 // @0DD3 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @0DD4 stack[2] = 0x70a08231 // @0DE8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x70a08231) << 0xe0 // @0E05 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & address(this) // @0E09 stack[3] = 0x20 + 0x04 + memory[0x40:0x60] // @0E0C stack[4] = 0x20 // @0E10 stack[5] = memory[0x40:0x60] // @0E13 stack[6] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @0E14 stack[7] = memory[0x40:0x60] // @0E15 stack[8] = 0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @0E18 stack[9] = !address(0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // } // Block ends with conditional jump to 0x0e23, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length label_0E1F: // Incoming jump from 0x0E1E, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Inputs[1] { @0E22 memory[0x00:0x00] } 0E1F 60 PUSH1 0x00 0E21 80 DUP1 0E22 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E22 revert(memory[0x00:0x00]); } // Block terminates label_0E23: // Incoming jump from 0x0E1E, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Inputs[8] // { // @0E25 msg.gas // @0E26 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0E26 stack[-3] // @0E26 stack[-6] // @0E26 memory[stack[-3]:stack[-3] + stack[-4]] // @0E26 stack[-2] // @0E26 stack[-5] // @0E26 stack[-4] // } 0E23 5B JUMPDEST 0E24 50 POP 0E25 5A GAS 0E26 FA STATICCALL 0E27 15 ISZERO 0E28 80 DUP1 0E29 15 ISZERO 0E2A 61 PUSH2 0x0e37 0E2D 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0E26 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @0E27 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x0e37, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_0E2E: // Incoming jump from 0x0E2D, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @0E2E returndata.length // @0E32 returndata[0x00:0x00 + returndata.length] // @0E33 returndata.length // @0E36 memory[0x00:0x00 + returndata.length] // } 0E2E 3D RETURNDATASIZE 0E2F 60 PUSH1 0x00 0E31 80 DUP1 0E32 3E RETURNDATACOPY 0E33 3D RETURNDATASIZE 0E34 60 PUSH1 0x00 0E36 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0E32 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0E36 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0E37: // Incoming jump from 0x0E2D, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @0E3E memory[0x40:0x60] // @0E3F returndata.length // } 0E37 5B JUMPDEST 0E38 50 POP 0E39 50 POP 0E3A 50 POP 0E3B 50 POP 0E3C 60 PUSH1 0x40 0E3E 51 MLOAD 0E3F 3D RETURNDATASIZE 0E40 60 PUSH1 0x20 0E42 81 DUP2 0E43 10 LT 0E44 15 ISZERO 0E45 61 PUSH2 0x0e4d 0E48 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @0E3E stack[-4] = memory[0x40:0x60] // @0E3F stack[-3] = returndata.length // } // Block ends with conditional jump to 0x0e4d, if !(returndata.length < 0x20) label_0E49: // Incoming jump from 0x0E48, if not !(returndata.length < 0x20) // Inputs[1] { @0E4C memory[0x00:0x00] } 0E49 60 PUSH1 0x00 0E4B 80 DUP1 0E4C FD *REVERT // Stack delta = +0 // Outputs[1] { @0E4C revert(memory[0x00:0x00]); } // Block terminates label_0E4D: // Incoming jump from 0x0E48, if !(returndata.length < 0x20) // Inputs[4] // { // @0E4F memory[stack[-2]:stack[-2] + 0x20] // @0E4F stack[-2] // @0E50 stack[-3] // @0E52 stack[-7] // } 0E4D 5B JUMPDEST 0E4E 50 POP 0E4F 51 MLOAD 0E50 90 SWAP1 0E51 50 POP 0E52 84 DUP5 0E53 81 DUP2 0E54 10 LT 0E55 15 ISZERO 0E56 61 PUSH2 0x0ec0 0E59 57 *JUMPI // Stack delta = -2 // Outputs[1] { @0E50 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x0ec0, if !(memory[stack[-2]:stack[-2] + 0x20] < stack[-7]) label_0E5A: // Incoming jump from 0x0E59, if not !(memory[stack[-2]:stack[-2] + 0x20] < stack[-7]) // Inputs[3] // { // @0E5D memory[0x40:0x60] // @0EB6 memory[0x40:0x60] // @0EBF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 0E5A 60 PUSH1 0x40 0E5C 80 DUP1 0E5D 51 MLOAD 0E5E 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0E7F 81 DUP2 0E80 52 MSTORE 0E81 60 PUSH1 0x20 0E83 60 PUSH1 0x04 0E85 82 DUP3 0E86 01 ADD 0E87 52 MSTORE 0E88 60 PUSH1 0x12 0E8A 60 PUSH1 0x24 0E8C 82 DUP3 0E8D 01 ADD 0E8E 52 MSTORE 0E8F 7F PUSH32 0x496e73756666696369656e742057455448390000000000000000000000000000 0EB0 60 PUSH1 0x44 0EB2 82 DUP3 0EB3 01 ADD 0EB4 52 MSTORE 0EB5 90 SWAP1 0EB6 51 MLOAD 0EB7 90 SWAP1 0EB8 81 DUP2 0EB9 90 SWAP1 0EBA 03 SUB 0EBB 60 PUSH1 0x64 0EBD 01 ADD 0EBE 90 SWAP1 0EBF FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0E80 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0E87 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0E8E memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x12 // @0EB4 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x496e73756666696369656e742057455448390000000000000000000000000000 // @0EBF revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_0EC0: // Incoming jump from 0x0E59, if !(memory[stack[-2]:stack[-2] + 0x20] < stack[-7]) // Inputs[1] { @0EC1 stack[-1] } 0EC0 5B JUMPDEST 0EC1 80 DUP1 0EC2 15 ISZERO 0EC3 61 PUSH2 0x0f91 0EC6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f91, if !stack[-1] label_0EC7: // Incoming jump from 0x0EC6, if not !stack[-1] // Inputs[4] // { // @0F03 stack[-1] // @0F06 memory[0x40:0x60] // @0F24 memory[0x40:0x60] // @0F2D address(0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // } 0EC7 7F PUSH32 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 0EE8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0EFD 16 AND 0EFE 63 PUSH4 0x2e1a7d4d 0F03 82 DUP3 0F04 60 PUSH1 0x40 0F06 51 MLOAD 0F07 82 DUP3 0F08 63 PUSH4 0xffffffff 0F0D 16 AND 0F0E 60 PUSH1 0xe0 0F10 1B SHL 0F11 81 DUP2 0F12 52 MSTORE 0F13 60 PUSH1 0x04 0F15 01 ADD 0F16 80 DUP1 0F17 82 DUP3 0F18 81 DUP2 0F19 52 MSTORE 0F1A 60 PUSH1 0x20 0F1C 01 ADD 0F1D 91 SWAP2 0F1E 50 POP 0F1F 50 POP 0F20 60 PUSH1 0x00 0F22 60 PUSH1 0x40 0F24 51 MLOAD 0F25 80 DUP1 0F26 83 DUP4 0F27 03 SUB 0F28 81 DUP2 0F29 60 PUSH1 0x00 0F2B 87 DUP8 0F2C 80 DUP1 0F2D 3B EXTCODESIZE 0F2E 15 ISZERO 0F2F 80 DUP1 0F30 15 ISZERO 0F31 61 PUSH2 0x0f39 0F34 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @0EFD stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @0EFE stack[1] = 0x2e1a7d4d // @0F12 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x2e1a7d4d) << 0xe0 // @0F19 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = stack[-1] // @0F1D stack[2] = 0x20 + 0x04 + memory[0x40:0x60] // @0F20 stack[3] = 0x00 // @0F24 stack[4] = memory[0x40:0x60] // @0F27 stack[5] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @0F28 stack[6] = memory[0x40:0x60] // @0F29 stack[7] = 0x00 // @0F2B stack[8] = 0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 // @0F2E stack[9] = !address(0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // } // Block ends with conditional jump to 0x0f39, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length label_0F35: // Incoming jump from 0x0F34, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Inputs[1] { @0F38 memory[0x00:0x00] } 0F35 60 PUSH1 0x00 0F37 80 DUP1 0F38 FD *REVERT // Stack delta = +0 // Outputs[1] { @0F38 revert(memory[0x00:0x00]); } // Block terminates label_0F39: // Incoming jump from 0x0F34, if !!address(0xffffffffffffffffffffffffffffffffffffffff & 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2).code.length // Inputs[9] // { // @0F3B msg.gas // @0F3C stack[-5] // @0F3C address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0F3C stack[-4] // @0F3C memory[stack[-4]:stack[-4] + stack[-5]] // @0F3C stack[-7] // @0F3C stack[-3] // @0F3C stack[-6] // @0F3C stack[-2] // } 0F39 5B JUMPDEST 0F3A 50 POP 0F3B 5A GAS 0F3C F1 CALL 0F3D 15 ISZERO 0F3E 80 DUP1 0F3F 15 ISZERO 0F40 61 PUSH2 0x0f4d 0F43 57 *JUMPI // Stack delta = -6 // Outputs[2] // { // @0F3C memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @0F3D stack[-7] = !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x0f4d, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_0F44: // Incoming jump from 0x0F43, if not !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[4] // { // @0F44 returndata.length // @0F48 returndata[0x00:0x00 + returndata.length] // @0F49 returndata.length // @0F4C memory[0x00:0x00 + returndata.length] // } 0F44 3D RETURNDATASIZE 0F45 60 PUSH1 0x00 0F47 80 DUP1 0F48 3E RETURNDATACOPY 0F49 3D RETURNDATASIZE 0F4A 60 PUSH1 0x00 0F4C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0F48 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0F4C revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0F4D: // Incoming jump from 0x0F43, if !!address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @0F5A stack[-7] // @0F5B stack[-5] // } 0F4D 5B JUMPDEST 0F4E 50 POP 0F4F 50 POP 0F50 50 POP 0F51 50 POP 0F52 60 PUSH1 0x00 0F54 61 PUSH2 0x2710 0F57 61 PUSH2 0x0f69 0F5A 85 DUP6 0F5B 84 DUP5 0F5C 61 PUSH2 0x23bc 0F5F 90 SWAP1 0F60 91 SWAP2 0F61 90 SWAP1 0F62 63 PUSH4 0xffffffff 0F67 16 AND 0F68 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0F52 stack[-4] = 0x00 // @0F54 stack[-3] = 0x2710 // @0F57 stack[-2] = 0x0f69 // @0F60 stack[-1] = stack[-5] // @0F61 stack[0] = stack[-7] // } // Block ends with call to 0xffffffff & 0x23bc, returns to 0x0F69 label_0F69: // Incoming return from call to 0x23BC at 0x0F68 // Inputs[1] { @0F6A stack[-2] } 0F69 5B JUMPDEST 0F6A 81 DUP2 0F6B 61 PUSH2 0x0f70 0F6E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f70, if stack[-2] label_0F6F: // Incoming jump from 0x0F6E, if not stack[-2] 0F6F FE *ASSERT // Stack delta = +0 // Outputs[1] { @0F6F assert(); } // Block terminates label_0F70: // Incoming jump from 0x0F6E, if stack[-2] // Inputs[3] // { // @0F71 stack[-2] // @0F71 stack[-1] // @0F72 stack[-3] // } 0F70 5B JUMPDEST 0F71 04 DIV 0F72 90 SWAP1 0F73 50 POP 0F74 80 DUP1 0F75 15 ISZERO 0F76 61 PUSH2 0x0f83 0F79 57 *JUMPI // Stack delta = -2 // Outputs[1] { @0F72 stack[-3] = stack[-1] / stack[-2] } // Block ends with conditional jump to 0x0f83, if !(stack[-1] / stack[-2]) label_0F7A: // Incoming jump from 0x0F79, if not !(stack[-1] / stack[-2]) // Inputs[2] // { // @0F7D stack[-3] // @0F7E stack[-1] // } 0F7A 61 PUSH2 0x0f83 0F7D 83 DUP4 0F7E 82 DUP3 0F7F 61 PUSH2 0x1ef9 0F82 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F7A stack[0] = 0x0f83 // @0F7D stack[1] = stack[-3] // @0F7E stack[2] = stack[-1] // } // Block ends with call to 0x1ef9, returns to 0x0F83 label_0F83: // Incoming jump from 0x0F79, if !(stack[-1] / stack[-2]) // Incoming return from call to 0x1EF9 at 0x0F82 // Inputs[3] // { // @0F87 stack[-5] // @0F88 stack[-1] // @0F89 stack[-2] // } 0F83 5B JUMPDEST 0F84 61 PUSH2 0x0f8f 0F87 85 DUP6 0F88 82 DUP3 0F89 84 DUP5 0F8A 03 SUB 0F8B 61 PUSH2 0x1ef9 0F8E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0F84 stack[0] = 0x0f8f // @0F87 stack[1] = stack[-5] // @0F8A stack[2] = stack[-2] - stack[-1] // } // Block ends with call to 0x1ef9, returns to 0x0F8F label_0F8F: // Incoming return from call to 0x0970 at 0x106C // Incoming return from call to 0x1EF9 at 0x0F8E // Incoming jump from 0x1438, if !(memory[stack[-2]:stack[-2] + 0x20] < stack[-3]) // Incoming return from call to 0x1B45 at 0x1445 // Incoming jump from 0x105F, if !(memory[stack[-2]:stack[-2] + 0x20] < stack[-3]) // Incoming jump from 0x18B8, if !stack[-1] 0F8F 5B JUMPDEST 0F90 50 POP // Stack delta = -1 // Block continues label_0F91: // Incoming jump from 0x1E92, if stack[-1] // Incoming jump from 0x0F90 // Incoming jump from 0x0EC6, if !stack[-1] // Inputs[1] { @0F97 stack[-6] } 0F91 5B JUMPDEST 0F92 50 POP 0F93 50 POP 0F94 50 POP 0F95 50 POP 0F96 50 POP 0F97 56 *JUMP // Stack delta = -6 // Block ends with unconditional jump to stack[-6] label_0F98: // Incoming jump from 0x03B5 // Inputs[6] // { // @0F9C memory[0x40:0x60] // @0FC0 msg.sender // @0FC6 address(this) // @0FCD memory[0x40:0x60] // @1005 stack[-6] // @1021 address(stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } 0F98 5B JUMPDEST 0F99 60 PUSH1 0x40 0F9B 80 DUP1 0F9C 51 MLOAD 0F9D 7F PUSH32 0xdd62ed3e00000000000000000000000000000000000000000000000000000000 0FBE 81 DUP2 0FBF 52 MSTORE 0FC0 33 CALLER 0FC1 60 PUSH1 0x04 0FC3 82 DUP3 0FC4 01 ADD 0FC5 52 MSTORE 0FC6 30 ADDRESS 0FC7 60 PUSH1 0x24 0FC9 82 DUP3 0FCA 01 ADD 0FCB 52 MSTORE 0FCC 90 SWAP1 0FCD 51 MLOAD 0FCE 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 0FEF 91 SWAP2 0FF0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1005 89 DUP10 1006 16 AND 1007 91 SWAP2 1008 63 PUSH4 0xdd62ed3e 100D 91 SWAP2 100E 60 PUSH1 0x44 1010 80 DUP1 1011 82 DUP3 1012 01 ADD 1013 92 SWAP3 1014 60 PUSH1 0x20 1016 92 SWAP3 1017 90 SWAP1 1018 91 SWAP2 1019 90 SWAP1 101A 82 DUP3 101B 90 SWAP1 101C 03 SUB 101D 01 ADD 101E 81 DUP2 101F 86 DUP7 1020 80 DUP1 1021 3B EXTCODESIZE 1022 15 ISZERO 1023 80 DUP1 1024 15 ISZERO 1025 61 PUSH2 0x102d 1028 57 *JUMPI // Stack delta = +10 // Outputs[13] // { // @0FBF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xdd62ed3e00000000000000000000000000000000000000000000000000000000 // @0FC5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = msg.sender // @0FCB memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = address(this) // @0FEF stack[0] = 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff // @1007 stack[1] = stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff // @100D stack[2] = 0xdd62ed3e // @1013 stack[3] = memory[0x40:0x60] + 0x44 // @1016 stack[4] = 0x20 // @1018 stack[5] = memory[0x40:0x60] // @101D stack[6] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @101E stack[7] = memory[0x40:0x60] // @101F stack[8] = stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff // @1022 stack[9] = !address(stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } // Block ends with conditional jump to 0x102d, if !!address(stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff).code.length label_1029: // Incoming jump from 0x1028, if not !!address(stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[1] { @102C memory[0x00:0x00] } 1029 60 PUSH1 0x00 102B 80 DUP1 102C FD *REVERT // Stack delta = +0 // Outputs[1] { @102C revert(memory[0x00:0x00]); } // Block terminates label_102D: // Incoming jump from 0x1028, if !!address(stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[8] // { // @102F msg.gas // @1030 stack[-2] // @1030 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1030 memory[stack[-3]:stack[-3] + stack[-4]] // @1030 stack[-6] // @1030 stack[-5] // @1030 stack[-3] // @1030 stack[-4] // } 102D 5B JUMPDEST 102E 50 POP 102F 5A GAS 1030 FA STATICCALL 1031 15 ISZERO 1032 80 DUP1 1033 15 ISZERO 1034 61 PUSH2 0x1041 1037 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1030 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1031 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1041, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1038: // Incoming jump from 0x1037, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1038 returndata.length // @103C returndata[0x00:0x00 + returndata.length] // @103D returndata.length // @1040 memory[0x00:0x00 + returndata.length] // } 1038 3D RETURNDATASIZE 1039 60 PUSH1 0x00 103B 80 DUP1 103C 3E RETURNDATACOPY 103D 3D RETURNDATASIZE 103E 60 PUSH1 0x00 1040 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @103C memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1040 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1041: // Incoming jump from 0x1037, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1048 memory[0x40:0x60] // @1049 returndata.length // } 1041 5B JUMPDEST 1042 50 POP 1043 50 POP 1044 50 POP 1045 50 POP 1046 60 PUSH1 0x40 1048 51 MLOAD 1049 3D RETURNDATASIZE 104A 60 PUSH1 0x20 104C 81 DUP2 104D 10 LT 104E 15 ISZERO 104F 61 PUSH2 0x1057 1052 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1048 stack[-4] = memory[0x40:0x60] // @1049 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1057, if !(returndata.length < 0x20) label_1053: // Incoming jump from 0x1052, if not !(returndata.length < 0x20) // Inputs[1] { @1056 memory[0x00:0x00] } 1053 60 PUSH1 0x00 1055 80 DUP1 1056 FD *REVERT // Stack delta = +0 // Outputs[1] { @1056 revert(memory[0x00:0x00]); } // Block terminates label_1057: // Incoming jump from 0x1052, if !(returndata.length < 0x20) // Inputs[3] // { // @1059 stack[-2] // @1059 memory[stack[-2]:stack[-2] + 0x20] // @105A stack[-3] // } 1057 5B JUMPDEST 1058 50 POP 1059 51 MLOAD 105A 10 LT 105B 15 ISZERO 105C 61 PUSH2 0x0f8f 105F 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x0f8f, if !(memory[stack[-2]:stack[-2] + 0x20] < stack[-3]) label_1060: // Incoming jump from 0x105F, if not !(memory[stack[-2]:stack[-2] + 0x20] < stack[-3]) // Inputs[6] // { // @1063 stack[-6] // @1064 stack[-5] // @1065 stack[-4] // @1066 stack[-3] // @1067 stack[-2] // @1068 stack[-1] // } 1060 61 PUSH2 0x0f8f 1063 86 DUP7 1064 86 DUP7 1065 86 DUP7 1066 86 DUP7 1067 86 DUP7 1068 86 DUP7 1069 61 PUSH2 0x0970 106C 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @1060 stack[0] = 0x0f8f // @1063 stack[1] = stack[-6] // @1064 stack[2] = stack[-5] // @1065 stack[3] = stack[-4] // @1066 stack[4] = stack[-3] // @1067 stack[5] = stack[-2] // @1068 stack[6] = stack[-1] // } // Block ends with call to 0x0970, returns to 0x0F8F label_106D: // Incoming jump from 0x03C8 // Inputs[1] { @1070 stack[-1] } 106D 5B JUMPDEST 106E 60 PUSH1 0x60 1070 81 DUP2 1071 67 PUSH8 0xffffffffffffffff 107A 81 DUP2 107B 11 GT 107C 80 DUP1 107D 15 ISZERO 107E 61 PUSH2 0x1086 1081 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @106E stack[0] = 0x60 // @1070 stack[1] = stack[-1] // @107B stack[2] = stack[-1] > 0xffffffffffffffff // } // Block ends with conditional jump to 0x1086, if !(stack[-1] > 0xffffffffffffffff) label_1082: // Incoming jump from 0x1081, if not !(stack[-1] > 0xffffffffffffffff) // Inputs[1] { @1085 memory[0x00:0x00] } 1082 60 PUSH1 0x00 1084 80 DUP1 1085 FD *REVERT // Stack delta = +0 // Outputs[1] { @1085 revert(memory[0x00:0x00]); } // Block terminates label_1086: // Incoming jump from 0x1081, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @108A memory[0x40:0x60] // @108B stack[-2] // } 1086 5B JUMPDEST 1087 50 POP 1088 60 PUSH1 0x40 108A 51 MLOAD 108B 90 SWAP1 108C 80 DUP1 108D 82 DUP3 108E 52 MSTORE 108F 80 DUP1 1090 60 PUSH1 0x20 1092 02 MUL 1093 60 PUSH1 0x20 1095 01 ADD 1096 82 DUP3 1097 01 ADD 1098 60 PUSH1 0x40 109A 52 MSTORE 109B 80 DUP1 109C 15 ISZERO 109D 61 PUSH2 0x10ba 10A0 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @108B stack[-2] = memory[0x40:0x60] // @108B stack[-1] = stack[-2] // @108E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @109A memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + 0x20 * stack[-2] // } // Block ends with conditional jump to 0x10ba, if !stack[-2] label_10A1: // Incoming jump from 0x10A0, if not !stack[-2] // Inputs[2] // { // @10A1 stack[-2] // @10AD stack[-1] // } 10A1 81 DUP2 10A2 60 PUSH1 0x20 10A4 01 ADD 10A5 5B JUMPDEST 10A6 60 PUSH1 0x60 10A8 81 DUP2 10A9 52 MSTORE 10AA 60 PUSH1 0x20 10AC 01 ADD 10AD 90 SWAP1 10AE 60 PUSH1 0x01 10B0 90 SWAP1 10B1 03 SUB 10B2 90 SWAP1 10B3 81 DUP2 10B4 61 PUSH2 0x10a5 10B7 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @10A9 memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = 0x60 // @10B2 stack[0] = 0x20 + 0x20 + stack[-2] // @10B2 stack[-1] = stack[-1] - 0x01 // } // Block ends with conditional jump to 0x10a5, if stack[-1] - 0x01 label_10B8: // Incoming jump from 0x10B7, if not stack[-2] - 0x01 // Incoming jump from 0x10B7, if not stack[-1] - 0x01 // Inputs[2] // { // @10B8 stack[-2] // @10B8 stack[-1] // } 10B8 90 SWAP1 10B9 50 POP // Stack delta = -1 // Outputs[1] { @10B8 stack[-2] = stack[-1] } // Block continues label_10BA: // Incoming jump from 0x10B9 // Incoming jump from 0x10A0, if !stack[-2] // Inputs[3] // { // @10BC stack[-3] // @10BC stack[-2] // @10C1 stack[-4] // } 10BA 5B JUMPDEST 10BB 50 POP 10BC 90 SWAP1 10BD 50 POP 10BE 60 PUSH1 0x00 10C0 5B JUMPDEST 10C1 82 DUP3 10C2 81 DUP2 10C3 10 LT 10C4 15 ISZERO 10C5 61 PUSH2 0x11c0 10C8 57 *JUMPI // Stack delta = -1 // Outputs[2] // { // @10BC stack[-3] = stack[-2] // @10BE stack[-2] = 0x00 // } // Block ends with conditional jump to 0x11c0, if !(0x00 < stack[-4]) label_10C9: // Incoming jump from 0x10C8, if not !(stack[-1] < stack[-3]) // Incoming jump from 0x10C8, if not !(0x00 < stack[-4]) // Inputs[4] // { // @10CC address(this) // @10CD stack[-4] // @10CE stack[-3] // @10CF stack[-1] // } 10C9 60 PUSH1 0x00 10CB 80 DUP1 10CC 30 ADDRESS 10CD 86 DUP7 10CE 86 DUP7 10CF 85 DUP6 10D0 81 DUP2 10D1 81 DUP2 10D2 10 LT 10D3 61 PUSH2 0x10d8 10D6 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @10C9 stack[0] = 0x00 // @10CB stack[1] = 0x00 // @10CC stack[2] = address(this) // @10CD stack[3] = stack[-4] // @10CE stack[4] = stack[-3] // @10CF stack[5] = stack[-1] // } // Block ends with conditional jump to 0x10d8, if stack[-1] < stack[-3] label_10D7: // Incoming jump from 0x10D6, if not stack[-1] < stack[-3] 10D7 FE *ASSERT // Stack delta = +0 // Outputs[1] { @10D7 assert(); } // Block terminates label_10D8: // Incoming jump from 0x10D6, if stack[-1] < stack[-3] // Inputs[3] // { // @10D9 stack[-1] // @10D9 stack[-2] // @10DE stack[-3] // } 10D8 5B JUMPDEST 10D9 90 SWAP1 10DA 50 POP 10DB 60 PUSH1 0x20 10DD 02 MUL 10DE 81 DUP2 10DF 01 ADD 10E0 90 SWAP1 10E1 61 PUSH2 0x10ea 10E4 91 SWAP2 10E5 90 SWAP1 10E6 61 PUSH2 0x3d6e 10E9 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @10E4 stack[-3] = 0x10ea // @10E5 stack[-1] = stack[-3] // @10E5 stack[-2] = stack[-3] + 0x20 * stack[-1] // } // Block ends with call to 0x3d6e, returns to 0x10EA label_10EA: // Incoming return from call to 0x3D6E at 0x10E9 // Inputs[3] // { // @10ED memory[0x40:0x60] // @10F1 stack[-2] // @10F2 stack[-1] // } 10EA 5B JUMPDEST 10EB 60 PUSH1 0x40 10ED 51 MLOAD 10EE 61 PUSH2 0x10f8 10F1 92 SWAP3 10F2 91 SWAP2 10F3 90 SWAP1 10F4 61 PUSH2 0x39c2 10F7 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @10F1 stack[-2] = 0x10f8 // @10F2 stack[-1] = stack[-2] // @10F3 stack[1] = memory[0x40:0x60] // @10F3 stack[0] = stack[-1] // } // Block ends with call to 0x39c2, returns to 0x10F8 label_10F8: // Incoming return from call to 0x39C2 at 0x10F7 // Inputs[7] // { // @10FD memory[0x40:0x60] // @10FF stack[-1] // @1102 stack[-2] // @1103 msg.gas // @1104 address(stack[-2]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @1104 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @1108 returndata.length // } 10F8 5B JUMPDEST 10F9 60 PUSH1 0x00 10FB 60 PUSH1 0x40 10FD 51 MLOAD 10FE 80 DUP1 10FF 83 DUP4 1100 03 SUB 1101 81 DUP2 1102 85 DUP6 1103 5A GAS 1104 F4 DELEGATECALL 1105 91 SWAP2 1106 50 POP 1107 50 POP 1108 3D RETURNDATASIZE 1109 80 DUP1 110A 60 PUSH1 0x00 110C 81 DUP2 110D 14 EQ 110E 61 PUSH2 0x1133 1111 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @1104 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-2]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @1105 stack[-2] = address(stack[-2]).delegatecall.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @1108 stack[-1] = returndata.length // @1109 stack[0] = returndata.length // } // Block ends with conditional jump to 0x1133, if returndata.length == 0x00 label_1112: // Incoming jump from 0x1111, if not returndata.length == 0x00 // Inputs[6] // { // @1114 memory[0x40:0x60] // @1115 stack[-2] // @111C returndata.length // @1124 returndata.length // @1127 returndata.length // @112E returndata[0x00:0x00 + returndata.length] // } 1112 60 PUSH1 0x40 1114 51 MLOAD 1115 91 SWAP2 1116 50 POP 1117 60 PUSH1 0x1f 1119 19 NOT 111A 60 PUSH1 0x3f 111C 3D RETURNDATASIZE 111D 01 ADD 111E 16 AND 111F 82 DUP3 1120 01 ADD 1121 60 PUSH1 0x40 1123 52 MSTORE 1124 3D RETURNDATASIZE 1125 82 DUP3 1126 52 MSTORE 1127 3D RETURNDATASIZE 1128 60 PUSH1 0x00 112A 60 PUSH1 0x20 112C 84 DUP5 112D 01 ADD 112E 3E RETURNDATACOPY 112F 61 PUSH2 0x1138 1132 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1115 stack[-2] = memory[0x40:0x60] // @1123 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1126 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @112E memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x1138 label_1133: // Incoming jump from 0x1111, if returndata.length == 0x00 // Inputs[4] // { // @1136 stack[-2] // @113A stack[-4] // @113C stack[-3] // @113C stack[-5] // } 1133 5B JUMPDEST 1134 60 PUSH1 0x60 1136 91 SWAP2 1137 50 POP 1138 5B JUMPDEST 1139 50 POP 113A 91 SWAP2 113B 50 POP 113C 91 SWAP2 113D 50 POP 113E 81 DUP2 113F 61 PUSH2 0x119e 1142 57 *JUMPI // Stack delta = -3 // Outputs[2] // { // @113A stack[-4] = 0x60 // @113C stack[-5] = stack[-3] // } // Block ends with conditional jump to 0x119e, if stack[-3] label_1143: // Incoming jump from 0x1142, if not stack[-3] // Incoming jump from 0x1142, if not stack[-3] // Inputs[2] // { // @1145 stack[-1] // @1146 memory[stack[-1]:stack[-1] + 0x20] // } 1143 60 PUSH1 0x44 1145 81 DUP2 1146 51 MLOAD 1147 10 LT 1148 15 ISZERO 1149 61 PUSH2 0x1151 114C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1151, if !(memory[stack[-1]:stack[-1] + 0x20] < 0x44) label_114D: // Incoming jump from 0x114C, if not !(memory[stack[-1]:stack[-1] + 0x20] < 0x44) // Inputs[1] { @1150 memory[0x00:0x00] } 114D 60 PUSH1 0x00 114F 80 DUP1 1150 FD *REVERT // Stack delta = +0 // Outputs[1] { @1150 revert(memory[0x00:0x00]); } // Block terminates label_1151: // Incoming jump from 0x114C, if !(memory[stack[-1]:stack[-1] + 0x20] < 0x44) // Inputs[2] // { // @1154 stack[-1] // @115E memory[stack[-1] + 0x04:stack[-1] + 0x04 + 0x20] // } 1151 5B JUMPDEST 1152 60 PUSH1 0x04 1154 81 DUP2 1155 01 ADD 1156 90 SWAP1 1157 50 POP 1158 80 DUP1 1159 80 DUP1 115A 60 PUSH1 0x20 115C 01 ADD 115D 90 SWAP1 115E 51 MLOAD 115F 81 DUP2 1160 01 ADD 1161 90 SWAP1 1162 61 PUSH2 0x116b 1165 91 SWAP2 1166 90 SWAP1 1167 61 PUSH2 0x35ff 116A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @1156 stack[-1] = stack[-1] + 0x04 // @1165 stack[0] = 0x116b // @1166 stack[2] = 0x20 + stack[-1] + 0x04 // @1166 stack[1] = 0x20 + stack[-1] + 0x04 + memory[stack[-1] + 0x04:stack[-1] + 0x04 + 0x20] // } // Block ends with call to 0x35ff, returns to 0x116B label_116B: // Incoming return from call to 0x35FF at 0x116A // Inputs[2] // { // @116E memory[0x40:0x60] // @1198 stack[-1] // } 116B 5B JUMPDEST 116C 60 PUSH1 0x40 116E 51 MLOAD 116F 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1190 81 DUP2 1191 52 MSTORE 1192 60 PUSH1 0x04 1194 01 ADD 1195 61 PUSH2 0x087a 1198 91 SWAP2 1199 90 SWAP1 119A 61 PUSH2 0x3af8 119D 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1191 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1198 stack[-1] = 0x087a // @1199 stack[1] = 0x04 + memory[0x40:0x60] // @1199 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x3af8 label_119E: // Incoming jump from 0x1142, if stack[-3] // Incoming jump from 0x1142, if stack[-3] // Inputs[4] // { // @119F stack[-1] // @11A0 stack[-4] // @11A1 stack[-3] // @11A3 memory[stack[-4]:stack[-4] + 0x20] // } 119E 5B JUMPDEST 119F 80 DUP1 11A0 84 DUP5 11A1 84 DUP5 11A2 81 DUP2 11A3 51 MLOAD 11A4 81 DUP2 11A5 10 LT 11A6 61 PUSH2 0x11ab 11A9 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @119F stack[0] = stack[-1] // @11A0 stack[1] = stack[-4] // @11A1 stack[2] = stack[-3] // } // Block ends with conditional jump to 0x11ab, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] label_11AA: // Incoming jump from 0x11A9, if not stack[-3] < memory[stack[-4]:stack[-4] + 0x20] 11AA FE *ASSERT // Stack delta = +0 // Outputs[1] { @11AA assert(); } // Block terminates label_11AB: // Incoming jump from 0x11A9, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[4] // { // @11AE stack[-1] // @11B1 stack[-2] // @11B6 stack[-3] // @11BB stack[-6] // } 11AB 5B JUMPDEST 11AC 60 PUSH1 0x20 11AE 90 SWAP1 11AF 81 DUP2 11B0 02 MUL 11B1 91 SWAP2 11B2 90 SWAP1 11B3 91 SWAP2 11B4 01 ADD 11B5 01 ADD 11B6 52 MSTORE 11B7 50 POP 11B8 50 POP 11B9 60 PUSH1 0x01 11BB 01 ADD 11BC 61 PUSH2 0x10c0 11BF 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @11B6 memory[0x20 * stack[-1] + stack[-2] + 0x20:0x20 * stack[-1] + stack[-2] + 0x20 + 0x20] = stack[-3] // @11BB stack[-6] = 0x01 + stack[-6] // } // Block ends with unconditional jump to 0x10c0 label_11C0: // Incoming jump from 0x10C8, if !(stack[-1] < stack[-3]) // Incoming jump from 0x10C8, if !(0x00 < stack[-4]) // Inputs[3] // { // @11C2 stack[-5] // @11C2 stack[-2] // @11C3 stack[-4] // } 11C0 5B JUMPDEST 11C1 50 POP 11C2 92 SWAP3 11C3 91 SWAP2 11C4 50 POP 11C5 50 POP 11C6 56 *JUMP // Stack delta = -4 // Outputs[1] { @11C2 stack[-5] = stack[-2] } // Block ends with unconditional jump to stack[-5] 11C7 5B JUMPDEST 11C8 60 PUSH1 0x00 11CA 81 DUP2 11CB 60 PUSH1 0x40 11CD 01 ADD 11CE 51 MLOAD 11CF 80 DUP1 11D0 61 PUSH2 0x11d7 11D3 61 PUSH2 0x21ea 11D6 56 *JUMP 11D7 5B JUMPDEST 11D8 11 GT 11D9 15 ISZERO 11DA 61 PUSH2 0x1244 11DD 57 *JUMPI 11DE 60 PUSH1 0x40 11E0 80 DUP1 11E1 51 MLOAD 11E2 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1203 81 DUP2 1204 52 MSTORE 1205 60 PUSH1 0x20 1207 60 PUSH1 0x04 1209 82 DUP3 120A 01 ADD 120B 52 MSTORE 120C 60 PUSH1 0x13 120E 60 PUSH1 0x24 1210 82 DUP3 1211 01 ADD 1212 52 MSTORE 1213 7F PUSH32 0x5472616e73616374696f6e20746f6f206f6c6400000000000000000000000000 1234 60 PUSH1 0x44 1236 82 DUP3 1237 01 ADD 1238 52 MSTORE 1239 90 SWAP1 123A 51 MLOAD 123B 90 SWAP1 123C 81 DUP2 123D 90 SWAP1 123E 03 SUB 123F 60 PUSH1 0x64 1241 01 ADD 1242 90 SWAP1 1243 FD *REVERT 1244 5B JUMPDEST 1245 82 DUP3 1246 51 MLOAD 1247 61 PUSH2 0x124f 124A 90 SWAP1 124B 61 PUSH2 0x23e6 124E 56 *JUMP 124F 5B JUMPDEST 1250 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1265 81 DUP2 1266 16 AND 1267 60 PUSH1 0x00 1269 90 SWAP1 126A 81 DUP2 126B 52 MSTORE 126C 60 PUSH1 0x02 126E 60 PUSH1 0x20 1270 52 MSTORE 1271 60 PUSH1 0x40 1273 90 SWAP1 1274 20 SHA3 1275 54 SLOAD 1276 60 PUSH1 0xff 1278 16 AND 1279 61 PUSH2 0x12ae 127C 57 *JUMPI 127D 60 PUSH1 0x40 127F 51 MLOAD 1280 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 12A1 81 DUP2 12A2 52 MSTORE 12A3 60 PUSH1 0x04 12A5 01 ADD 12A6 61 PUSH2 0x087a 12A9 90 SWAP1 12AA 61 PUSH2 0x3bb0 12AD 56 *JUMP 12AE 5B JUMPDEST 12AF 33 CALLER 12B0 5B JUMPDEST 12B1 60 PUSH1 0x00 12B3 61 PUSH2 0x12bf 12B6 86 DUP7 12B7 60 PUSH1 0x00 12B9 01 ADD 12BA 51 MLOAD 12BB 61 PUSH2 0x23ff 12BE 56 *JUMP 12BF 5B JUMPDEST 12C0 90 SWAP1 12C1 50 POP 12C2 61 PUSH2 0x1318 12C5 86 DUP7 12C6 60 PUSH1 0x60 12C8 01 ADD 12C9 51 MLOAD 12CA 82 DUP3 12CB 61 PUSH2 0x12d8 12CE 57 *JUMPI 12CF 87 DUP8 12D0 60 PUSH1 0x20 12D2 01 ADD 12D3 51 MLOAD 12D4 61 PUSH2 0x12da 12D7 56 *JUMP 12D8 5B JUMPDEST 12D9 30 ADDRESS 12DA 5B JUMPDEST 12DB 60 PUSH1 0x00 12DD 60 PUSH1 0x40 12DF 51 MLOAD 12E0 80 DUP1 12E1 60 PUSH1 0x40 12E3 01 ADD 12E4 60 PUSH1 0x40 12E6 52 MSTORE 12E7 80 DUP1 12E8 61 PUSH2 0x12f4 12EB 8C DUP13 12EC 60 PUSH1 0x00 12EE 01 ADD 12EF 51 MLOAD 12F0 61 PUSH2 0x2407 12F3 56 *JUMP 12F4 5B JUMPDEST 12F5 81 DUP2 12F6 52 MSTORE 12F7 60 PUSH1 0x20 12F9 01 ADD 12FA 87 DUP8 12FB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1310 16 AND 1311 81 DUP2 1312 52 MSTORE 1313 50 POP 1314 61 PUSH2 0x21ee 1317 56 *JUMP 1318 5B JUMPDEST 1319 60 PUSH1 0x60 131B 87 DUP8 131C 01 ADD 131D 52 MSTORE 131E 80 DUP1 131F 15 ISZERO 1320 61 PUSH2 0x1338 1323 57 *JUMPI 1324 85 DUP6 1325 51 MLOAD 1326 30 ADDRESS 1327 92 SWAP3 1328 50 POP 1329 61 PUSH2 0x1331 132C 90 SWAP1 132D 61 PUSH2 0x2416 1330 56 *JUMP 1331 5B JUMPDEST 1332 86 DUP7 1333 52 MSTORE 1334 61 PUSH2 0x1345 1337 56 *JUMP 1338 5B JUMPDEST 1339 85 DUP6 133A 60 PUSH1 0x60 133C 01 ADD 133D 51 MLOAD 133E 94 SWAP5 133F 50 POP 1340 50 POP 1341 61 PUSH2 0x134b 1344 56 *JUMP 1345 5B JUMPDEST 1346 50 POP 1347 61 PUSH2 0x12b0 134A 56 *JUMP 134B 5B JUMPDEST 134C 84 DUP5 134D 60 PUSH1 0x80 134F 01 ADD 1350 51 MLOAD 1351 84 DUP5 1352 10 LT 1353 15 ISZERO 1354 61 PUSH2 0x1389 1357 57 *JUMPI 1358 60 PUSH1 0x40 135A 51 MLOAD 135B 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 137C 81 DUP2 137D 52 MSTORE 137E 60 PUSH1 0x04 1380 01 ADD 1381 61 PUSH2 0x087a 1384 90 SWAP1 1385 61 PUSH2 0x3c8c 1388 56 *JUMP 1389 5B JUMPDEST 138A 50 POP 138B 50 POP 138C 50 POP 138D 91 SWAP2 138E 90 SWAP1 138F 50 POP 1390 56 *JUMP label_1391: // Incoming jump from 0x03FB // Inputs[7] // { // @1395 memory[0x40:0x60] // @13B9 msg.sender // @13BF address(this) // @13C6 memory[0x40:0x60] // @13C7 stack[-5] // @13DE stack[-6] // @13FA address(stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } 1391 5B JUMPDEST 1392 60 PUSH1 0x40 1394 80 DUP1 1395 51 MLOAD 1396 7F PUSH32 0xdd62ed3e00000000000000000000000000000000000000000000000000000000 13B7 81 DUP2 13B8 52 MSTORE 13B9 33 CALLER 13BA 60 PUSH1 0x04 13BC 82 DUP3 13BD 01 ADD 13BE 52 MSTORE 13BF 30 ADDRESS 13C0 60 PUSH1 0x24 13C2 82 DUP3 13C3 01 ADD 13C4 52 MSTORE 13C5 90 SWAP1 13C6 51 MLOAD 13C7 86 DUP7 13C8 91 SWAP2 13C9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 13DE 89 DUP10 13DF 16 AND 13E0 91 SWAP2 13E1 63 PUSH4 0xdd62ed3e 13E6 91 SWAP2 13E7 60 PUSH1 0x44 13E9 80 DUP1 13EA 82 DUP3 13EB 01 ADD 13EC 92 SWAP3 13ED 60 PUSH1 0x20 13EF 92 SWAP3 13F0 90 SWAP1 13F1 91 SWAP2 13F2 90 SWAP1 13F3 82 DUP3 13F4 90 SWAP1 13F5 03 SUB 13F6 01 ADD 13F7 81 DUP2 13F8 86 DUP7 13F9 80 DUP1 13FA 3B EXTCODESIZE 13FB 15 ISZERO 13FC 80 DUP1 13FD 15 ISZERO 13FE 61 PUSH2 0x1406 1401 57 *JUMPI // Stack delta = +10 // Outputs[13] // { // @13B8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xdd62ed3e00000000000000000000000000000000000000000000000000000000 // @13BE memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = msg.sender // @13C4 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = address(this) // @13C8 stack[0] = stack[-5] // @13E0 stack[1] = stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff // @13E6 stack[2] = 0xdd62ed3e // @13EC stack[3] = memory[0x40:0x60] + 0x44 // @13EF stack[4] = 0x20 // @13F1 stack[5] = memory[0x40:0x60] // @13F6 stack[6] = memory[0x40:0x60] - memory[0x40:0x60] + 0x44 // @13F7 stack[7] = memory[0x40:0x60] // @13F8 stack[8] = stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff // @13FB stack[9] = !address(stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } // Block ends with conditional jump to 0x1406, if !!address(stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff).code.length label_1402: // Incoming jump from 0x1401, if not !!address(stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[1] { @1405 memory[0x00:0x00] } 1402 60 PUSH1 0x00 1404 80 DUP1 1405 FD *REVERT // Stack delta = +0 // Outputs[1] { @1405 revert(memory[0x00:0x00]); } // Block terminates label_1406: // Incoming jump from 0x1401, if !!address(stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[8] // { // @1408 msg.gas // @1409 stack[-3] // @1409 stack[-4] // @1409 stack[-5] // @1409 stack[-6] // @1409 memory[stack[-3]:stack[-3] + stack[-4]] // @1409 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1409 stack[-2] // } 1406 5B JUMPDEST 1407 50 POP 1408 5A GAS 1409 FA STATICCALL 140A 15 ISZERO 140B 80 DUP1 140C 15 ISZERO 140D 61 PUSH2 0x141a 1410 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1409 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @140A stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x141a, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1411: // Incoming jump from 0x1410, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1411 returndata.length // @1415 returndata[0x00:0x00 + returndata.length] // @1416 returndata.length // @1419 memory[0x00:0x00 + returndata.length] // } 1411 3D RETURNDATASIZE 1412 60 PUSH1 0x00 1414 80 DUP1 1415 3E RETURNDATACOPY 1416 3D RETURNDATASIZE 1417 60 PUSH1 0x00 1419 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1415 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1419 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_141A: // Incoming jump from 0x1410, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1421 memory[0x40:0x60] // @1422 returndata.length // } 141A 5B JUMPDEST 141B 50 POP 141C 50 POP 141D 50 POP 141E 50 POP 141F 60 PUSH1 0x40 1421 51 MLOAD 1422 3D RETURNDATASIZE 1423 60 PUSH1 0x20 1425 81 DUP2 1426 10 LT 1427 15 ISZERO 1428 61 PUSH2 0x1430 142B 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1421 stack[-4] = memory[0x40:0x60] // @1422 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1430, if !(returndata.length < 0x20) label_142C: // Incoming jump from 0x142B, if not !(returndata.length < 0x20) // Inputs[1] { @142F memory[0x00:0x00] } 142C 60 PUSH1 0x00 142E 80 DUP1 142F FD *REVERT // Stack delta = +0 // Outputs[1] { @142F revert(memory[0x00:0x00]); } // Block terminates label_1430: // Incoming jump from 0x142B, if !(returndata.length < 0x20) // Inputs[3] // { // @1432 stack[-2] // @1432 memory[stack[-2]:stack[-2] + 0x20] // @1433 stack[-3] // } 1430 5B JUMPDEST 1431 50 POP 1432 51 MLOAD 1433 10 LT 1434 15 ISZERO 1435 61 PUSH2 0x0f8f 1438 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x0f8f, if !(memory[stack[-2]:stack[-2] + 0x20] < stack[-3]) label_1439: // Incoming jump from 0x1438, if not !(memory[stack[-2]:stack[-2] + 0x20] < stack[-3]) // Inputs[6] // { // @143C stack[-6] // @143D stack[-5] // @143E stack[-4] // @143F stack[-3] // @1440 stack[-2] // @1441 stack[-1] // } 1439 61 PUSH2 0x0f8f 143C 86 DUP7 143D 86 DUP7 143E 86 DUP7 143F 86 DUP7 1440 86 DUP7 1441 86 DUP7 1442 61 PUSH2 0x1b45 1445 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @1439 stack[0] = 0x0f8f // @143C stack[1] = stack[-6] // @143D stack[2] = stack[-5] // @143E stack[3] = stack[-4] // @143F stack[4] = stack[-3] // @1440 stack[5] = stack[-2] // @1441 stack[6] = stack[-1] // } // Block ends with call to 0x1b45, returns to 0x0F8F label_1446: // Incoming call from 0x0410, returns to 0x0336 // Inputs[1] { @1468 stack[-1] } 1446 5B JUMPDEST 1447 7F PUSH32 0x000000000000000000000000e592427a0aece92de3edee1f18e0157c05861564 1468 81 DUP2 1469 56 *JUMP // Stack delta = +1 // Outputs[1] { @1447 stack[0] = 0x000000000000000000000000e592427a0aece92de3edee1f18e0157c05861564 } // Block ends with unconditional jump to stack[-1] 146A 5B JUMPDEST 146B 60 PUSH1 0x02 146D 60 PUSH1 0x20 146F 52 MSTORE 1470 60 PUSH1 0x00 1472 90 SWAP1 1473 81 DUP2 1474 52 MSTORE 1475 60 PUSH1 0x40 1477 90 SWAP1 1478 20 SHA3 1479 54 SLOAD 147A 60 PUSH1 0xff 147C 16 AND 147D 81 DUP2 147E 56 *JUMP 147F 5B JUMPDEST 1480 60 PUSH1 0x00 1482 81 DUP2 1483 60 PUSH1 0x80 1485 01 ADD 1486 35 CALLDATALOAD 1487 80 DUP1 1488 61 PUSH2 0x148f 148B 61 PUSH2 0x21ea 148E 56 *JUMP 148F 5B JUMPDEST 1490 11 GT 1491 15 ISZERO 1492 61 PUSH2 0x14fc 1495 57 *JUMPI 1496 60 PUSH1 0x40 1498 80 DUP1 1499 51 MLOAD 149A 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 14BB 81 DUP2 14BC 52 MSTORE 14BD 60 PUSH1 0x20 14BF 60 PUSH1 0x04 14C1 82 DUP3 14C2 01 ADD 14C3 52 MSTORE 14C4 60 PUSH1 0x13 14C6 60 PUSH1 0x24 14C8 82 DUP3 14C9 01 ADD 14CA 52 MSTORE 14CB 7F PUSH32 0x5472616e73616374696f6e20746f6f206f6c6400000000000000000000000000 14EC 60 PUSH1 0x44 14EE 82 DUP3 14EF 01 ADD 14F0 52 MSTORE 14F1 90 SWAP1 14F2 51 MLOAD 14F3 90 SWAP1 14F4 81 DUP2 14F5 90 SWAP1 14F6 03 SUB 14F7 60 PUSH1 0x64 14F9 01 ADD 14FA 90 SWAP1 14FB FD *REVERT 14FC 5B JUMPDEST 14FD 60 PUSH1 0x20 14FF 83 DUP4 1500 81 DUP2 1501 01 ADD 1502 35 CALLDATALOAD 1503 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1518 16 AND 1519 60 PUSH1 0x00 151B 81 DUP2 151C 81 DUP2 151D 52 MSTORE 151E 60 PUSH1 0x02 1520 90 SWAP1 1521 92 SWAP3 1522 52 MSTORE 1523 60 PUSH1 0x40 1525 90 SWAP1 1526 91 SWAP2 1527 20 SHA3 1528 54 SLOAD 1529 60 PUSH1 0xff 152B 16 AND 152C 61 PUSH2 0x1561 152F 57 *JUMPI 1530 60 PUSH1 0x40 1532 51 MLOAD 1533 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1554 81 DUP2 1555 52 MSTORE 1556 60 PUSH1 0x04 1558 01 ADD 1559 61 PUSH2 0x087a 155C 90 SWAP1 155D 61 PUSH2 0x3bb0 1560 56 *JUMP 1561 5B JUMPDEST 1562 61 PUSH2 0x160a 1565 60 PUSH1 0xa0 1567 85 DUP6 1568 01 ADD 1569 35 CALLDATALOAD 156A 61 PUSH2 0x1579 156D 60 PUSH1 0x80 156F 87 DUP8 1570 01 ADD 1571 60 PUSH1 0x60 1573 88 DUP9 1574 01 ADD 1575 61 PUSH2 0x3321 1578 56 *JUMP 1579 5B JUMPDEST 157A 61 PUSH2 0x158a 157D 61 PUSH2 0x0100 1580 88 DUP9 1581 01 ADD 1582 60 PUSH1 0xe0 1584 89 DUP10 1585 01 ADD 1586 61 PUSH2 0x3321 1589 56 *JUMP 158A 5B JUMPDEST 158B 60 PUSH1 0x40 158D 51 MLOAD 158E 80 DUP1 158F 60 PUSH1 0x40 1591 01 ADD 1592 60 PUSH1 0x40 1594 52 MSTORE 1595 80 DUP1 1596 89 DUP10 1597 60 PUSH1 0x20 1599 01 ADD 159A 60 PUSH1 0x20 159C 81 DUP2 159D 01 ADD 159E 90 SWAP1 159F 61 PUSH2 0x15a8 15A2 91 SWAP2 15A3 90 SWAP1 15A4 61 PUSH2 0x3321 15A7 56 *JUMP 15A8 5B JUMPDEST 15A9 61 PUSH2 0x15b8 15AC 60 PUSH1 0x60 15AE 8C DUP13 15AF 01 ADD 15B0 60 PUSH1 0x40 15B2 8D DUP14 15B3 01 ADD 15B4 61 PUSH2 0x37f8 15B7 56 *JUMP 15B8 5B JUMPDEST 15B9 61 PUSH2 0x15c5 15BC 60 PUSH1 0x20 15BE 8D DUP14 15BF 01 ADD 15C0 8D DUP14 15C1 61 PUSH2 0x3321 15C4 56 *JUMP 15C5 5B JUMPDEST 15C6 60 PUSH1 0x40 15C8 51 MLOAD 15C9 60 PUSH1 0x20 15CB 01 ADD 15CC 61 PUSH2 0x15d7 15CF 93 SWAP4 15D0 92 SWAP3 15D1 91 SWAP2 15D2 90 SWAP1 15D3 61 PUSH2 0x38f5 15D6 56 *JUMP 15D7 5B JUMPDEST 15D8 60 PUSH1 0x40 15DA 51 MLOAD 15DB 60 PUSH1 0x20 15DD 81 DUP2 15DE 83 DUP4 15DF 03 SUB 15E0 03 SUB 15E1 81 DUP2 15E2 52 MSTORE 15E3 90 SWAP1 15E4 60 PUSH1 0x40 15E6 52 MSTORE 15E7 81 DUP2 15E8 52 MSTORE 15E9 60 PUSH1 0x20 15EB 01 ADD 15EC 33 CALLER 15ED 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1602 16 AND 1603 81 DUP2 1604 52 MSTORE 1605 50 POP 1606 61 PUSH2 0x244b 1609 56 *JUMP 160A 5B JUMPDEST 160B 92 SWAP3 160C 50 POP 160D 83 DUP4 160E 60 PUSH1 0xc0 1610 01 ADD 1611 35 CALLDATALOAD 1612 83 DUP4 1613 11 GT 1614 15 ISZERO 1615 61 PUSH2 0x164a 1618 57 *JUMPI 1619 60 PUSH1 0x40 161B 51 MLOAD 161C 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 163D 81 DUP2 163E 52 MSTORE 163F 60 PUSH1 0x04 1641 01 ADD 1642 61 PUSH2 0x087a 1645 90 SWAP1 1646 61 PUSH2 0x3be7 1649 56 *JUMP 164A 5B JUMPDEST 164B 50 POP 164C 50 POP 164D 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 166E 60 PUSH1 0x00 1670 55 SSTORE 1671 91 SWAP2 1672 90 SWAP1 1673 50 POP 1674 56 *JUMP label_1675: // Incoming jump from 0x0456 // Inputs[5] // { // @1678 stack[-3] // @1694 address(this) // @1697 memory[0x40:0x60] // @16CB memory[0x40:0x60] // @16D2 address(0xffffffffffffffffffffffffffffffffffffffff & stack[-3]).code.length // } 1675 5B JUMPDEST 1676 60 PUSH1 0x00 1678 83 DUP4 1679 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 168E 16 AND 168F 63 PUSH4 0x70a08231 1694 30 ADDRESS 1695 60 PUSH1 0x40 1697 51 MLOAD 1698 82 DUP3 1699 63 PUSH4 0xffffffff 169E 16 AND 169F 60 PUSH1 0xe0 16A1 1B SHL 16A2 81 DUP2 16A3 52 MSTORE 16A4 60 PUSH1 0x04 16A6 01 ADD 16A7 80 DUP1 16A8 82 DUP3 16A9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16BE 16 AND 16BF 81 DUP2 16C0 52 MSTORE 16C1 60 PUSH1 0x20 16C3 01 ADD 16C4 91 SWAP2 16C5 50 POP 16C6 50 POP 16C7 60 PUSH1 0x20 16C9 60 PUSH1 0x40 16CB 51 MLOAD 16CC 80 DUP1 16CD 83 DUP4 16CE 03 SUB 16CF 81 DUP2 16D0 86 DUP7 16D1 80 DUP1 16D2 3B EXTCODESIZE 16D3 15 ISZERO 16D4 80 DUP1 16D5 15 ISZERO 16D6 61 PUSH2 0x16de 16D9 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @1676 stack[0] = 0x00 // @168E stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @168F stack[2] = 0x70a08231 // @16A3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x70a08231) << 0xe0 // @16C0 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & address(this) // @16C4 stack[3] = 0x20 + 0x04 + memory[0x40:0x60] // @16C7 stack[4] = 0x20 // @16CB stack[5] = memory[0x40:0x60] // @16CE stack[6] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @16CF stack[7] = memory[0x40:0x60] // @16D0 stack[8] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @16D3 stack[9] = !address(0xffffffffffffffffffffffffffffffffffffffff & stack[-3]).code.length // } // Block ends with conditional jump to 0x16de, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-3]).code.length label_16DA: // Incoming jump from 0x16D9, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-3]).code.length // Inputs[1] { @16DD memory[0x00:0x00] } 16DA 60 PUSH1 0x00 16DC 80 DUP1 16DD FD *REVERT // Stack delta = +0 // Outputs[1] { @16DD revert(memory[0x00:0x00]); } // Block terminates label_16DE: // Incoming jump from 0x16D9, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-3]).code.length // Inputs[8] // { // @16E0 msg.gas // @16E1 stack[-6] // @16E1 memory[stack[-3]:stack[-3] + stack[-4]] // @16E1 stack[-5] // @16E1 stack[-4] // @16E1 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @16E1 stack[-3] // @16E1 stack[-2] // } 16DE 5B JUMPDEST 16DF 50 POP 16E0 5A GAS 16E1 FA STATICCALL 16E2 15 ISZERO 16E3 80 DUP1 16E4 15 ISZERO 16E5 61 PUSH2 0x16f2 16E8 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @16E1 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @16E2 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x16f2, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_16E9: // Incoming jump from 0x16E8, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @16E9 returndata.length // @16ED returndata[0x00:0x00 + returndata.length] // @16EE returndata.length // @16F1 memory[0x00:0x00 + returndata.length] // } 16E9 3D RETURNDATASIZE 16EA 60 PUSH1 0x00 16EC 80 DUP1 16ED 3E RETURNDATACOPY 16EE 3D RETURNDATASIZE 16EF 60 PUSH1 0x00 16F1 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @16ED memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @16F1 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_16F2: // Incoming jump from 0x16E8, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @16F9 memory[0x40:0x60] // @16FA returndata.length // } 16F2 5B JUMPDEST 16F3 50 POP 16F4 50 POP 16F5 50 POP 16F6 50 POP 16F7 60 PUSH1 0x40 16F9 51 MLOAD 16FA 3D RETURNDATASIZE 16FB 60 PUSH1 0x20 16FD 81 DUP2 16FE 10 LT 16FF 15 ISZERO 1700 61 PUSH2 0x1708 1703 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @16F9 stack[-4] = memory[0x40:0x60] // @16FA stack[-3] = returndata.length // } // Block ends with conditional jump to 0x1708, if !(returndata.length < 0x20) label_1704: // Incoming jump from 0x1703, if not !(returndata.length < 0x20) // Inputs[1] { @1707 memory[0x00:0x00] } 1704 60 PUSH1 0x00 1706 80 DUP1 1707 FD *REVERT // Stack delta = +0 // Outputs[1] { @1707 revert(memory[0x00:0x00]); } // Block terminates label_1708: // Incoming jump from 0x1703, if !(returndata.length < 0x20) // Inputs[4] // { // @170A stack[-2] // @170A memory[stack[-2]:stack[-2] + 0x20] // @170B stack[-3] // @170D stack[-5] // } 1708 5B JUMPDEST 1709 50 POP 170A 51 MLOAD 170B 90 SWAP1 170C 50 POP 170D 82 DUP3 170E 81 DUP2 170F 10 LT 1710 15 ISZERO 1711 61 PUSH2 0x177b 1714 57 *JUMPI // Stack delta = -2 // Outputs[1] { @170B stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x177b, if !(memory[stack[-2]:stack[-2] + 0x20] < stack[-5]) label_1715: // Incoming jump from 0x1714, if not !(memory[stack[-2]:stack[-2] + 0x20] < stack[-5]) // Inputs[3] // { // @1718 memory[0x40:0x60] // @1771 memory[0x40:0x60] // @177A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1715 60 PUSH1 0x40 1717 80 DUP1 1718 51 MLOAD 1719 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 173A 81 DUP2 173B 52 MSTORE 173C 60 PUSH1 0x20 173E 60 PUSH1 0x04 1740 82 DUP3 1741 01 ADD 1742 52 MSTORE 1743 60 PUSH1 0x12 1745 60 PUSH1 0x24 1747 82 DUP3 1748 01 ADD 1749 52 MSTORE 174A 7F PUSH32 0x496e73756666696369656e7420746f6b656e0000000000000000000000000000 176B 60 PUSH1 0x44 176D 82 DUP3 176E 01 ADD 176F 52 MSTORE 1770 90 SWAP1 1771 51 MLOAD 1772 90 SWAP1 1773 81 DUP2 1774 90 SWAP1 1775 03 SUB 1776 60 PUSH1 0x64 1778 01 ADD 1779 90 SWAP1 177A FD *REVERT // Stack delta = +0 // Outputs[5] // { // @173B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1742 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1749 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x12 // @176F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x496e73756666696369656e7420746f6b656e0000000000000000000000000000 // @177A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_177B: // Incoming jump from 0x1714, if !(memory[stack[-2]:stack[-2] + 0x20] < stack[-5]) // Inputs[1] { @177C stack[-1] } 177B 5B JUMPDEST 177C 80 DUP1 177D 15 ISZERO 177E 61 PUSH2 0x178c 1781 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x178c, if !stack[-1] label_1782: // Incoming jump from 0x1781, if not !stack[-1] // Inputs[3] // { // @1785 stack[-4] // @1786 stack[-2] // @1787 stack[-1] // } 1782 61 PUSH2 0x178c 1785 84 DUP5 1786 83 DUP4 1787 83 DUP4 1788 61 PUSH2 0x1d24 178B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1782 stack[0] = 0x178c // @1785 stack[1] = stack[-4] // @1786 stack[2] = stack[-2] // @1787 stack[3] = stack[-1] // } // Block ends with call to 0x1d24, returns to 0x178C label_178C: // Incoming return from call to 0x1D24 at 0x178B // Incoming jump from 0x3E5F, if !(stack[-1] > stack[-4]) // Incoming jump from 0x1781, if !stack[-1] // Inputs[1] { @1791 stack[-5] } 178C 5B JUMPDEST 178D 50 POP 178E 50 POP 178F 50 POP 1790 50 POP 1791 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_1792: // Incoming jump from 0x0469 // Inputs[1] { @1795 stack[-2] } 1792 5B JUMPDEST 1793 60 PUSH1 0x00 1795 82 DUP3 1796 11 GT 1797 80 DUP1 1798 15 ISZERO 1799 61 PUSH2 0x17a3 179C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1796 stack[0] = stack[-2] > 0x00 } // Block ends with conditional jump to 0x17a3, if !(stack[-2] > 0x00) label_179D: // Incoming jump from 0x179C, if not !(stack[-2] > 0x00) // Inputs[1] { @17A0 stack[-3] } 179D 50 POP 179E 60 PUSH1 0x64 17A0 82 DUP3 17A1 11 GT 17A2 15 ISZERO 17A3 5B JUMPDEST 17A4 61 PUSH2 0x17ac 17A7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x17ac, if !(stack[-3] > 0x64) label_17A8: // Incoming jump from 0x17A7, if not stack[-1] // Incoming jump from 0x17A7, if not !(stack[-3] > 0x64) // Inputs[1] { @17AB memory[0x00:0x00] } 17A8 60 PUSH1 0x00 17AA 80 DUP1 17AB FD *REVERT // Stack delta = +0 // Outputs[1] { @17AB revert(memory[0x00:0x00]); } // Block terminates label_17AC: // Incoming jump from 0x17A7, if stack[-1] // Incoming jump from 0x17A7, if !(stack[-3] > 0x64) // Inputs[5] // { // @17AF stack[-5] // @17CB address(this) // @17CE memory[0x40:0x60] // @1802 memory[0x40:0x60] // @1809 address(0xffffffffffffffffffffffffffffffffffffffff & stack[-5]).code.length // } 17AC 5B JUMPDEST 17AD 60 PUSH1 0x00 17AF 85 DUP6 17B0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17C5 16 AND 17C6 63 PUSH4 0x70a08231 17CB 30 ADDRESS 17CC 60 PUSH1 0x40 17CE 51 MLOAD 17CF 82 DUP3 17D0 63 PUSH4 0xffffffff 17D5 16 AND 17D6 60 PUSH1 0xe0 17D8 1B SHL 17D9 81 DUP2 17DA 52 MSTORE 17DB 60 PUSH1 0x04 17DD 01 ADD 17DE 80 DUP1 17DF 82 DUP3 17E0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 17F5 16 AND 17F6 81 DUP2 17F7 52 MSTORE 17F8 60 PUSH1 0x20 17FA 01 ADD 17FB 91 SWAP2 17FC 50 POP 17FD 50 POP 17FE 60 PUSH1 0x20 1800 60 PUSH1 0x40 1802 51 MLOAD 1803 80 DUP1 1804 83 DUP4 1805 03 SUB 1806 81 DUP2 1807 86 DUP7 1808 80 DUP1 1809 3B EXTCODESIZE 180A 15 ISZERO 180B 80 DUP1 180C 15 ISZERO 180D 61 PUSH2 0x1815 1810 57 *JUMPI // Stack delta = +10 // Outputs[12] // { // @17AD stack[0] = 0x00 // @17C5 stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @17C6 stack[2] = 0x70a08231 // @17DA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & 0x70a08231) << 0xe0 // @17F7 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & address(this) // @17FB stack[3] = 0x20 + 0x04 + memory[0x40:0x60] // @17FE stack[4] = 0x20 // @1802 stack[5] = memory[0x40:0x60] // @1805 stack[6] = (0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60] // @1806 stack[7] = memory[0x40:0x60] // @1807 stack[8] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @180A stack[9] = !address(0xffffffffffffffffffffffffffffffffffffffff & stack[-5]).code.length // } // Block ends with conditional jump to 0x1815, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-5]).code.length label_1811: // Incoming jump from 0x1810, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-5]).code.length // Inputs[1] { @1814 memory[0x00:0x00] } 1811 60 PUSH1 0x00 1813 80 DUP1 1814 FD *REVERT // Stack delta = +0 // Outputs[1] { @1814 revert(memory[0x00:0x00]); } // Block terminates label_1815: // Incoming jump from 0x1810, if !!address(0xffffffffffffffffffffffffffffffffffffffff & stack[-5]).code.length // Inputs[8] // { // @1817 msg.gas // @1818 stack[-5] // @1818 stack[-2] // @1818 stack[-3] // @1818 memory[stack[-3]:stack[-3] + stack[-4]] // @1818 address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1818 stack[-6] // @1818 stack[-4] // } 1815 5B JUMPDEST 1816 50 POP 1817 5A GAS 1818 FA STATICCALL 1819 15 ISZERO 181A 80 DUP1 181B 15 ISZERO 181C 61 PUSH2 0x1829 181F 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @1818 memory[stack[-5]:stack[-5] + stack[-6]] = address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // @1819 stack[-6] = !address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // } // Block ends with conditional jump to 0x1829, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) label_1820: // Incoming jump from 0x181F, if not !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[4] // { // @1820 returndata.length // @1824 returndata[0x00:0x00 + returndata.length] // @1825 returndata.length // @1828 memory[0x00:0x00 + returndata.length] // } 1820 3D RETURNDATASIZE 1821 60 PUSH1 0x00 1823 80 DUP1 1824 3E RETURNDATACOPY 1825 3D RETURNDATASIZE 1826 60 PUSH1 0x00 1828 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1824 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @1828 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_1829: // Incoming jump from 0x181F, if !!address(stack[-2]).staticcall.gas(msg.gas)(memory[stack[-3]:stack[-3] + stack[-4]]) // Inputs[2] // { // @1830 memory[0x40:0x60] // @1831 returndata.length // } 1829 5B JUMPDEST 182A 50 POP 182B 50 POP 182C 50 POP 182D 50 POP 182E 60 PUSH1 0x40 1830 51 MLOAD 1831 3D RETURNDATASIZE 1832 60 PUSH1 0x20 1834 81 DUP2 1835 10 LT 1836 15 ISZERO 1837 61 PUSH2 0x183f 183A 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1830 stack[-4] = memory[0x40:0x60] // @1831 stack[-3] = returndata.length // } // Block ends with conditional jump to 0x183f, if !(returndata.length < 0x20) label_183B: // Incoming jump from 0x183A, if not !(returndata.length < 0x20) // Inputs[1] { @183E memory[0x00:0x00] } 183B 60 PUSH1 0x00 183D 80 DUP1 183E FD *REVERT // Stack delta = +0 // Outputs[1] { @183E revert(memory[0x00:0x00]); } // Block terminates label_183F: // Incoming jump from 0x183A, if !(returndata.length < 0x20) // Inputs[4] // { // @1841 memory[stack[-2]:stack[-2] + 0x20] // @1841 stack[-2] // @1842 stack[-3] // @1844 stack[-7] // } 183F 5B JUMPDEST 1840 50 POP 1841 51 MLOAD 1842 90 SWAP1 1843 50 POP 1844 84 DUP5 1845 81 DUP2 1846 10 LT 1847 15 ISZERO 1848 61 PUSH2 0x18b2 184B 57 *JUMPI // Stack delta = -2 // Outputs[1] { @1842 stack[-3] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x18b2, if !(memory[stack[-2]:stack[-2] + 0x20] < stack[-7]) label_184C: // Incoming jump from 0x184B, if not !(memory[stack[-2]:stack[-2] + 0x20] < stack[-7]) // Inputs[3] // { // @184F memory[0x40:0x60] // @18A8 memory[0x40:0x60] // @18B1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 184C 60 PUSH1 0x40 184E 80 DUP1 184F 51 MLOAD 1850 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1871 81 DUP2 1872 52 MSTORE 1873 60 PUSH1 0x20 1875 60 PUSH1 0x04 1877 82 DUP3 1878 01 ADD 1879 52 MSTORE 187A 60 PUSH1 0x12 187C 60 PUSH1 0x24 187E 82 DUP3 187F 01 ADD 1880 52 MSTORE 1881 7F PUSH32 0x496e73756666696369656e7420746f6b656e0000000000000000000000000000 18A2 60 PUSH1 0x44 18A4 82 DUP3 18A5 01 ADD 18A6 52 MSTORE 18A7 90 SWAP1 18A8 51 MLOAD 18A9 90 SWAP1 18AA 81 DUP2 18AB 90 SWAP1 18AC 03 SUB 18AD 60 PUSH1 0x64 18AF 01 ADD 18B0 90 SWAP1 18B1 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1872 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1879 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1880 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x12 // @18A6 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x496e73756666696369656e7420746f6b656e0000000000000000000000000000 // @18B1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_18B2: // Incoming jump from 0x184B, if !(memory[stack[-2]:stack[-2] + 0x20] < stack[-7]) // Inputs[1] { @18B3 stack[-1] } 18B2 5B JUMPDEST 18B3 80 DUP1 18B4 15 ISZERO 18B5 61 PUSH2 0x0f8f 18B8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0f8f, if !stack[-1] label_18B9: // Incoming jump from 0x18B8, if not !stack[-1] // Inputs[2] // { // @18C1 stack[-1] // @18C2 stack[-3] // } 18B9 60 PUSH1 0x00 18BB 61 PUSH2 0x2710 18BE 61 PUSH2 0x18c7 18C1 83 DUP4 18C2 86 DUP7 18C3 61 PUSH2 0x23bc 18C6 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @18B9 stack[0] = 0x00 // @18BB stack[1] = 0x2710 // @18BE stack[2] = 0x18c7 // @18C1 stack[3] = stack[-1] // @18C2 stack[4] = stack[-3] // } // Block ends with call to 0x23bc, returns to 0x18C7 label_18C7: // Incoming return from call to 0x23BC at 0x18C6 // Inputs[1] { @18C8 stack[-2] } 18C7 5B JUMPDEST 18C8 81 DUP2 18C9 61 PUSH2 0x18ce 18CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x18ce, if stack[-2] label_18CD: // Incoming jump from 0x18CC, if not stack[-2] 18CD FE *ASSERT // Stack delta = +0 // Outputs[1] { @18CD assert(); } // Block terminates label_18CE: // Incoming jump from 0x18CC, if stack[-2] // Inputs[3] // { // @18CF stack[-2] // @18CF stack[-1] // @18D0 stack[-3] // } 18CE 5B JUMPDEST 18CF 04 DIV 18D0 90 SWAP1 18D1 50 POP 18D2 80 DUP1 18D3 15 ISZERO 18D4 61 PUSH2 0x18e2 18D7 57 *JUMPI // Stack delta = -2 // Outputs[1] { @18D0 stack[-3] = stack[-1] / stack[-2] } // Block ends with conditional jump to 0x18e2, if !(stack[-1] / stack[-2]) label_18D8: // Incoming jump from 0x18D7, if not !(stack[-1] / stack[-2]) // Inputs[3] // { // @18DB stack[-7] // @18DC stack[-3] // @18DD stack[-1] // } 18D8 61 PUSH2 0x18e2 18DB 87 DUP8 18DC 84 DUP5 18DD 83 DUP4 18DE 61 PUSH2 0x1d24 18E1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @18D8 stack[0] = 0x18e2 // @18DB stack[1] = stack[-7] // @18DC stack[2] = stack[-3] // @18DD stack[3] = stack[-1] // } // Block ends with call to 0x1d24, returns to 0x18E2 label_18E2: // Incoming return from call to 0x1D24 at 0x18E1 // Incoming jump from 0x18D7, if !(stack[-1] / stack[-2]) // Inputs[4] // { // @18E6 stack[-7] // @18E7 stack[-5] // @18E8 stack[-1] // @18E9 stack[-2] // } 18E2 5B JUMPDEST 18E3 61 PUSH2 0x18ef 18E6 87 DUP8 18E7 86 DUP7 18E8 83 DUP4 18E9 85 DUP6 18EA 03 SUB 18EB 61 PUSH2 0x1d24 18EE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @18E3 stack[0] = 0x18ef // @18E6 stack[1] = stack[-7] // @18E7 stack[2] = stack[-5] // @18EA stack[3] = stack[-2] - stack[-1] // } // Block ends with call to 0x1d24, returns to 0x18EF label_18EF: // Incoming return from call to 0x1D24 at 0x18EE // Inputs[1] { @18F7 stack[-8] } 18EF 5B JUMPDEST 18F0 50 POP 18F1 50 POP 18F2 50 POP 18F3 50 POP 18F4 50 POP 18F5 50 POP 18F6 50 POP 18F7 56 *JUMP // Stack delta = -8 // Block ends with unconditional jump to stack[-8] label_18F8: // Incoming call from 0x047E, returns to 0x0243 // Inputs[3] // { // @1922 address(this).balance // @1922 address(this) // @1925 memory[0x40:0x60] // } 18F8 5B JUMPDEST 18F9 71 PUSH18 0xf079e68bbcc79ab9600ace786b0a4db1c83c 190C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1921 16 AND 1922 47 SELFBALANCE 1923 60 PUSH1 0x40 1925 51 MLOAD 1926 61 PUSH2 0x192e 1929 90 SWAP1 192A 61 PUSH2 0x39d2 192D 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1921 stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & 0xf079e68bbcc79ab9600ace786b0a4db1c83c // @1922 stack[1] = address(this).balance // @1929 stack[2] = 0x192e // @1929 stack[3] = memory[0x40:0x60] // } // Block ends with call to 0x39d2, returns to 0x192E label_192E: // Incoming return from call to 0x39D2 at 0x192D // Inputs[8] // { // @1933 memory[0x40:0x60] // @1935 stack[-1] // @1938 stack[-2] // @1939 stack[-3] // @193A msg.gas // @193B memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @193B address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @1940 returndata.length // } 192E 5B JUMPDEST 192F 60 PUSH1 0x00 1931 60 PUSH1 0x40 1933 51 MLOAD 1934 80 DUP1 1935 83 DUP4 1936 03 SUB 1937 81 DUP2 1938 85 DUP6 1939 87 DUP8 193A 5A GAS 193B F1 CALL 193C 92 SWAP3 193D 50 POP 193E 50 POP 193F 50 POP 1940 3D RETURNDATASIZE 1941 80 DUP1 1942 60 PUSH1 0x00 1944 81 DUP2 1945 14 EQ 1946 61 PUSH2 0x0bf1 1949 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @193B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @193C stack[-3] = address(stack[-3]).call.gas(msg.gas).value(stack[-2])(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]) // @1940 stack[-2] = returndata.length // @1941 stack[-1] = returndata.length // } // Block ends with conditional jump to 0x0bf1, if returndata.length == 0x00 label_194A: // Incoming jump from 0x1949, if not returndata.length == 0x00 // Inputs[6] // { // @194C memory[0x40:0x60] // @194D stack[-2] // @1954 returndata.length // @195C returndata.length // @195F returndata.length // @1966 returndata[0x00:0x00 + returndata.length] // } 194A 60 PUSH1 0x40 194C 51 MLOAD 194D 91 SWAP2 194E 50 POP 194F 60 PUSH1 0x1f 1951 19 NOT 1952 60 PUSH1 0x3f 1954 3D RETURNDATASIZE 1955 01 ADD 1956 16 AND 1957 82 DUP3 1958 01 ADD 1959 60 PUSH1 0x40 195B 52 MSTORE 195C 3D RETURNDATASIZE 195D 82 DUP3 195E 52 MSTORE 195F 3D RETURNDATASIZE 1960 60 PUSH1 0x00 1962 60 PUSH1 0x20 1964 84 DUP5 1965 01 ADD 1966 3E RETURNDATACOPY 1967 61 PUSH2 0x0bf1 196A 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @194D stack[-2] = memory[0x40:0x60] // @195B memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @195E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @1966 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x0bf1 label_196B: // Incoming jump from 0x0491 // Inputs[2] // { // @196E stack[-1] // @1972 msg.data[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // } 196B 5B JUMPDEST 196C 60 PUSH1 0x00 196E 81 DUP2 196F 60 PUSH1 0x40 1971 01 ADD 1972 35 CALLDATALOAD 1973 80 DUP1 1974 61 PUSH2 0x197b 1977 61 PUSH2 0x21ea 197A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @196C stack[0] = 0x00 // @1972 stack[1] = msg.data[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // @1973 stack[2] = msg.data[0x40 + stack[-1]:0x40 + stack[-1] + 0x20] // @1974 stack[3] = 0x197b // } // Block ends with call to 0x21ea, returns to 0x197B label_197B: // Incoming return from call to 0x21EA at 0x197A // Inputs[2] // { // @197C stack[-2] // @197C stack[-1] // } 197B 5B JUMPDEST 197C 11 GT 197D 15 ISZERO 197E 61 PUSH2 0x19e8 1981 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x19e8, if !(stack[-1] > stack[-2]) label_1982: // Incoming jump from 0x1981, if not !(stack[-1] > stack[-2]) // Inputs[3] // { // @1985 memory[0x40:0x60] // @19DE memory[0x40:0x60] // @19E7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1982 60 PUSH1 0x40 1984 80 DUP1 1985 51 MLOAD 1986 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 19A7 81 DUP2 19A8 52 MSTORE 19A9 60 PUSH1 0x20 19AB 60 PUSH1 0x04 19AD 82 DUP3 19AE 01 ADD 19AF 52 MSTORE 19B0 60 PUSH1 0x13 19B2 60 PUSH1 0x24 19B4 82 DUP3 19B5 01 ADD 19B6 52 MSTORE 19B7 7F PUSH32 0x5472616e73616374696f6e20746f6f206f6c6400000000000000000000000000 19D8 60 PUSH1 0x44 19DA 82 DUP3 19DB 01 ADD 19DC 52 MSTORE 19DD 90 SWAP1 19DE 51 MLOAD 19DF 90 SWAP1 19E0 81 DUP2 19E1 90 SWAP1 19E2 03 SUB 19E3 60 PUSH1 0x64 19E5 01 ADD 19E6 90 SWAP1 19E7 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @19A8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @19AF memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @19B6 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x13 // @19DC memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5472616e73616374696f6e20746f6f206f6c6400000000000000000000000000 // @19E7 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_19E8: // Incoming jump from 0x1981, if !(stack[-1] > stack[-2]) // Inputs[1] { @19EF stack[-3] } 19E8 5B JUMPDEST 19E9 61 PUSH2 0x1a2f 19EC 61 PUSH2 0x19f5 19EF 84 DUP5 19F0 80 DUP1 19F1 61 PUSH2 0x3d6e 19F4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @19E9 stack[0] = 0x1a2f // @19EC stack[1] = 0x19f5 // @19EF stack[2] = stack[-3] // @19F0 stack[3] = stack[-3] // } // Block ends with call to 0x3d6e, returns to 0x19F5 label_19F5: // Incoming return from call to 0x3D6E at 0x19F4 // Inputs[4] // { // @19F6 stack[-1] // @1A06 memory[0x40:0x60] // @1A0E stack[-2] // @1A1D msg.data[stack[-2]:stack[-2] + stack[-1]] // } 19F5 5B JUMPDEST 19F6 80 DUP1 19F7 80 DUP1 19F8 60 PUSH1 0x1f 19FA 01 ADD 19FB 60 PUSH1 0x20 19FD 80 DUP1 19FE 91 SWAP2 19FF 04 DIV 1A00 02 MUL 1A01 60 PUSH1 0x20 1A03 01 ADD 1A04 60 PUSH1 0x40 1A06 51 MLOAD 1A07 90 SWAP1 1A08 81 DUP2 1A09 01 ADD 1A0A 60 PUSH1 0x40 1A0C 52 MSTORE 1A0D 80 DUP1 1A0E 93 SWAP4 1A0F 92 SWAP3 1A10 91 SWAP2 1A11 90 SWAP1 1A12 81 DUP2 1A13 81 DUP2 1A14 52 MSTORE 1A15 60 PUSH1 0x20 1A17 01 ADD 1A18 83 DUP4 1A19 83 DUP4 1A1A 80 DUP1 1A1B 82 DUP3 1A1C 84 DUP5 1A1D 37 CALLDATACOPY 1A1E 60 PUSH1 0x00 1A20 92 SWAP3 1A21 01 ADD 1A22 91 SWAP2 1A23 90 SWAP1 1A24 91 SWAP2 1A25 52 MSTORE 1A26 50 POP 1A27 61 PUSH2 0x23e6 1A2A 92 SWAP3 1A2B 50 POP 1A2C 50 POP 1A2D 50 POP 1A2E 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @1A0C memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @1A0E stack[-2] = memory[0x40:0x60] // @1A14 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1A1D memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-1]] = msg.data[stack[-2]:stack[-2] + stack[-1]] // @1A25 memory[0x20 + memory[0x40:0x60] + stack[-1]:0x20 + memory[0x40:0x60] + stack[-1] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x23e6 label_1A2F: // Incoming return from call to 0x19F5 at 0x19F4 // Inputs[3] // { // @1A45 stack[-1] // @1A54 memory[0x00:0x40] // @1A55 storage[keccak256(memory[0x00:0x40])] // } 1A2F 5B JUMPDEST 1A30 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A45 81 DUP2 1A46 16 AND 1A47 60 PUSH1 0x00 1A49 90 SWAP1 1A4A 81 DUP2 1A4B 52 MSTORE 1A4C 60 PUSH1 0x02 1A4E 60 PUSH1 0x20 1A50 52 MSTORE 1A51 60 PUSH1 0x40 1A53 90 SWAP1 1A54 20 SHA3 1A55 54 SLOAD 1A56 60 PUSH1 0xff 1A58 16 AND 1A59 61 PUSH2 0x1a8e 1A5C 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @1A4B memory[0x00:0x20] = stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // @1A50 memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x1a8e, if 0xff & storage[keccak256(memory[0x00:0x40])] label_1A5D: // Incoming jump from 0x1A5C, if not 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @1A5F memory[0x40:0x60] } 1A5D 60 PUSH1 0x40 1A5F 51 MLOAD 1A60 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1A81 81 DUP2 1A82 52 MSTORE 1A83 60 PUSH1 0x04 1A85 01 ADD 1A86 61 PUSH2 0x087a 1A89 90 SWAP1 1A8A 61 PUSH2 0x3bb0 1A8D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1A82 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1A89 stack[0] = 0x087a // @1A89 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3bb0, returns to 0x087A label_1A8E: // Incoming jump from 0x1A5C, if 0xff & storage[keccak256(memory[0x00:0x40])] // Inputs[2] // { // @1A94 stack[-4] // @1A96 msg.data[stack[-4] + 0x60:stack[-4] + 0x60 + 0x20] // } 1A8E 5B JUMPDEST 1A8F 61 PUSH2 0x1b01 1A92 60 PUSH1 0x60 1A94 85 DUP6 1A95 01 ADD 1A96 35 CALLDATALOAD 1A97 61 PUSH2 0x1aa6 1A9A 60 PUSH1 0x40 1A9C 87 DUP8 1A9D 01 ADD 1A9E 60 PUSH1 0x20 1AA0 88 DUP9 1AA1 01 ADD 1AA2 61 PUSH2 0x3321 1AA5 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1A8F stack[0] = 0x1b01 // @1A96 stack[1] = msg.data[stack[-4] + 0x60:stack[-4] + 0x60 + 0x20] // @1A97 stack[2] = 0x1aa6 // @1A9D stack[3] = stack[-4] + 0x40 // @1AA1 stack[4] = stack[-4] + 0x20 // } // Block ends with unconditional jump to 0x3321 1AA6 5B JUMPDEST 1AA7 60 PUSH1 0x40 1AA9 80 DUP1 1AAA 51 MLOAD 1AAB 80 DUP1 1AAC 82 DUP3 1AAD 01 ADD 1AAE 90 SWAP1 1AAF 91 SWAP2 1AB0 52 MSTORE 1AB1 60 PUSH1 0x00 1AB3 90 SWAP1 1AB4 80 DUP1 1AB5 61 PUSH2 0x1abe 1AB8 8A DUP11 1AB9 80 DUP1 1ABA 61 PUSH2 0x3d6e 1ABD 56 *JUMP 1ABE 5B JUMPDEST 1ABF 80 DUP1 1AC0 80 DUP1 1AC1 60 PUSH1 0x1f 1AC3 01 ADD 1AC4 60 PUSH1 0x20 1AC6 80 DUP1 1AC7 91 SWAP2 1AC8 04 DIV 1AC9 02 MUL 1ACA 60 PUSH1 0x20 1ACC 01 ADD 1ACD 60 PUSH1 0x40 1ACF 51 MLOAD 1AD0 90 SWAP1 1AD1 81 DUP2 1AD2 01 ADD 1AD3 60 PUSH1 0x40 1AD5 52 MSTORE 1AD6 80 DUP1 1AD7 93 SWAP4 1AD8 92 SWAP3 1AD9 91 SWAP2 1ADA 90 SWAP1 1ADB 81 DUP2 1ADC 81 DUP2 1ADD 52 MSTORE 1ADE 60 PUSH1 0x20 1AE0 01 ADD 1AE1 83 DUP4 1AE2 83 DUP4 1AE3 80 DUP1 1AE4 82 DUP3 1AE5 84 DUP5 1AE6 37 CALLDATACOPY 1AE7 60 PUSH1 0x00 1AE9 92 SWAP3 1AEA 01 ADD 1AEB 91 SWAP2 1AEC 90 SWAP1 1AED 91 SWAP2 1AEE 52 MSTORE 1AEF 50 POP 1AF0 50 POP 1AF1 50 POP 1AF2 90 SWAP1 1AF3 82 DUP3 1AF4 52 MSTORE 1AF5 50 POP 1AF6 33 CALLER 1AF7 60 PUSH1 0x20 1AF9 90 SWAP1 1AFA 91 SWAP2 1AFB 01 ADD 1AFC 52 MSTORE 1AFD 61 PUSH2 0x244b 1B00 56 *JUMP 1B01 5B JUMPDEST 1B02 50 POP 1B03 60 PUSH1 0x00 1B05 54 SLOAD 1B06 92 SWAP3 1B07 50 POP 1B08 83 DUP4 1B09 60 PUSH1 0x80 1B0B 01 ADD 1B0C 35 CALLDATALOAD 1B0D 83 DUP4 1B0E 11 GT 1B0F 15 ISZERO 1B10 61 PUSH2 0x164a 1B13 57 *JUMPI 1B14 60 PUSH1 0x40 1B16 51 MLOAD 1B17 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1B38 81 DUP2 1B39 52 MSTORE 1B3A 60 PUSH1 0x04 1B3C 01 ADD 1B3D 61 PUSH2 0x087a 1B40 90 SWAP1 1B41 61 PUSH2 0x3be7 1B44 56 *JUMP label_1B45: // Incoming jump from 0x04A4 // Incoming call from 0x1445, returns to 0x0F8F // Inputs[11] // { // @1B49 memory[0x40:0x60] // @1B6D msg.sender // @1B73 address(this) // @1B7D stack[-5] // @1B84 stack[-4] // @1B89 stack[-3] // @1B94 stack[-2] // @1B9B stack[-1] // @1B9F memory[0x40:0x60] // @1BB5 stack[-6] // @1BD1 address(stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } 1B45 5B JUMPDEST 1B46 60 PUSH1 0x40 1B48 80 DUP1 1B49 51 MLOAD 1B4A 7F PUSH32 0xd505accf00000000000000000000000000000000000000000000000000000000 1B6B 81 DUP2 1B6C 52 MSTORE 1B6D 33 CALLER 1B6E 60 PUSH1 0x04 1B70 82 DUP3 1B71 01 ADD 1B72 52 MSTORE 1B73 30 ADDRESS 1B74 60 PUSH1 0x24 1B76 82 DUP3 1B77 01 ADD 1B78 52 MSTORE 1B79 60 PUSH1 0x44 1B7B 81 DUP2 1B7C 01 ADD 1B7D 87 DUP8 1B7E 90 SWAP1 1B7F 52 MSTORE 1B80 60 PUSH1 0x64 1B82 81 DUP2 1B83 01 ADD 1B84 86 DUP7 1B85 90 SWAP1 1B86 52 MSTORE 1B87 60 PUSH1 0xff 1B89 85 DUP6 1B8A 16 AND 1B8B 60 PUSH1 0x84 1B8D 82 DUP3 1B8E 01 ADD 1B8F 52 MSTORE 1B90 60 PUSH1 0xa4 1B92 81 DUP2 1B93 01 ADD 1B94 84 DUP5 1B95 90 SWAP1 1B96 52 MSTORE 1B97 60 PUSH1 0xc4 1B99 81 DUP2 1B9A 01 ADD 1B9B 83 DUP4 1B9C 90 SWAP1 1B9D 52 MSTORE 1B9E 90 SWAP1 1B9F 51 MLOAD 1BA0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1BB5 88 DUP9 1BB6 16 AND 1BB7 91 SWAP2 1BB8 63 PUSH4 0xd505accf 1BBD 91 SWAP2 1BBE 60 PUSH1 0xe4 1BC0 80 DUP1 1BC1 83 DUP4 1BC2 01 ADD 1BC3 92 SWAP3 1BC4 60 PUSH1 0x00 1BC6 92 SWAP3 1BC7 91 SWAP2 1BC8 90 SWAP1 1BC9 82 DUP3 1BCA 90 SWAP1 1BCB 03 SUB 1BCC 01 ADD 1BCD 81 DUP2 1BCE 83 DUP4 1BCF 87 DUP8 1BD0 80 DUP1 1BD1 3B EXTCODESIZE 1BD2 15 ISZERO 1BD3 80 DUP1 1BD4 15 ISZERO 1BD5 61 PUSH2 0x0a10 1BD8 57 *JUMPI // Stack delta = +10 // Outputs[18] // { // @1B6C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xd505accf00000000000000000000000000000000000000000000000000000000 // @1B72 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = msg.sender // @1B78 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = address(this) // @1B7F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-5] // @1B86 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = stack[-4] // @1B8F memory[memory[0x40:0x60] + 0x84:memory[0x40:0x60] + 0x84 + 0x20] = stack[-3] & 0xff // @1B96 memory[memory[0x40:0x60] + 0xa4:memory[0x40:0x60] + 0xa4 + 0x20] = stack[-2] // @1B9D memory[memory[0x40:0x60] + 0xc4:memory[0x40:0x60] + 0xc4 + 0x20] = stack[-1] // @1BB7 stack[0] = stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff // @1BBD stack[1] = 0xd505accf // @1BC3 stack[2] = memory[0x40:0x60] + 0xe4 // @1BC6 stack[3] = 0x00 // @1BC7 stack[4] = memory[0x40:0x60] // @1BCC stack[5] = memory[0x40:0x60] - memory[0x40:0x60] + 0xe4 // @1BCD stack[6] = memory[0x40:0x60] // @1BCE stack[7] = 0x00 // @1BCF stack[8] = stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff // @1BD2 stack[9] = !address(stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // } // Block ends with conditional jump to 0x0a10, if !!address(stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff).code.length label_1BD9: // Incoming jump from 0x1BD8, if not !!address(stack[-6] & 0xffffffffffffffffffffffffffffffffffffffff).code.length // Inputs[1] { @1BDC memory[0x00:0x00] } 1BD9 60 PUSH1 0x00 1BDB 80 DUP1 1BDC FD *REVERT // Stack delta = +0 // Outputs[1] { @1BDC revert(memory[0x00:0x00]); } // Block terminates label_1BDD: // Incoming jump from 0x04C4 // Inputs[1] { @1BE0 stack[-4] } 1BDD 5B JUMPDEST 1BDE 60 PUSH1 0x00 1BE0 84 DUP5 1BE1 13 SGT 1BE2 80 DUP1 1BE3 61 PUSH2 0x1bec 1BE6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1BE1 stack[0] = stack[-4] i> 0x00 } // Block ends with conditional jump to 0x1bec, if stack[-4] i> 0x00 label_1BE7: // Incoming jump from 0x1BE6, if not stack[-4] i> 0x00 // Inputs[1] { @1BEA stack[-4] } 1BE7 50 POP 1BE8 60 PUSH1 0x00 1BEA 83 DUP4 1BEB 13 SGT 1BEC 5B JUMPDEST 1BED 61 PUSH2 0x1bf5 1BF0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1bf5, if stack[-4] i> 0x00 label_1BF1: // Incoming jump from 0x1BF0, if not stack[-1] // Incoming jump from 0x1BF0, if not stack[-4] i> 0x00 // Inputs[1] { @1BF4 memory[0x00:0x00] } 1BF1 60 PUSH1 0x00 1BF3 80 DUP1 1BF4 FD *REVERT // Stack delta = +0 // Outputs[1] { @1BF4 revert(memory[0x00:0x00]); } // Block terminates label_1BF5: // Incoming jump from 0x1BF0, if stack[-1] // Incoming jump from 0x1BF0, if stack[-4] i> 0x00 // Inputs[2] // { // @1BFB stack[-1] // @1BFC stack[-2] // } 1BF5 5B JUMPDEST 1BF6 60 PUSH1 0x00 1BF8 61 PUSH2 0x1c03 1BFB 82 DUP3 1BFC 84 DUP5 1BFD 01 ADD 1BFE 84 DUP5 1BFF 61 PUSH2 0x3768 1C02 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1BF6 stack[0] = 0x00 // @1BF8 stack[1] = 0x1c03 // @1BFD stack[2] = stack[-2] + stack[-1] // @1BFE stack[3] = stack[-2] // } // Block ends with call to 0x3768, returns to 0x1C03 label_1C03: // Incoming return from call to 0x3768 at 0x1C02 // Inputs[3] // { // @1C04 stack[-2] // @1C04 stack[-1] // @1C12 memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] // } 1C03 5B JUMPDEST 1C04 90 SWAP1 1C05 50 POP 1C06 60 PUSH1 0x00 1C08 80 DUP1 1C09 60 PUSH1 0x00 1C0B 61 PUSH2 0x1c17 1C0E 84 DUP5 1C0F 60 PUSH1 0x00 1C11 01 ADD 1C12 51 MLOAD 1C13 61 PUSH2 0x2607 1C16 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @1C04 stack[-2] = stack[-1] // @1C06 stack[-1] = 0x00 // @1C08 stack[0] = 0x00 // @1C09 stack[1] = 0x00 // @1C0B stack[2] = 0x1c17 // @1C12 stack[3] = memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] // } // Block ends with call to 0x2607, returns to 0x1C17 label_1C17: // Incoming return from call to 0x2607 at 0x1C16 // Inputs[6] // { // @1C18 stack[-1] // @1C18 stack[-4] // @1C1A stack[-2] // @1C1A stack[-5] // @1C1C stack[-6] // @1C1C stack[-3] // } 1C17 5B JUMPDEST 1C18 92 SWAP3 1C19 50 POP 1C1A 92 SWAP3 1C1B 50 POP 1C1C 92 SWAP3 1C1D 50 POP 1C1E 61 PUSH2 0x1c49 1C21 7F PUSH32 0x000000000000000000000000e592427a0aece92de3edee1f18e0157c05861564 1C42 84 DUP5 1C43 84 DUP5 1C44 84 DUP5 1C45 61 PUSH2 0x2638 1C48 56 *JUMP // Stack delta = +2 // Outputs[8] // { // @1C18 stack[-4] = stack[-1] // @1C1A stack[-5] = stack[-2] // @1C1C stack[-6] = stack[-3] // @1C1E stack[-3] = 0x1c49 // @1C21 stack[-2] = 0x000000000000000000000000e592427a0aece92de3edee1f18e0157c05861564 // @1C42 stack[-1] = stack[-3] // @1C43 stack[0] = stack[-2] // @1C44 stack[1] = stack[-1] // } // Block ends with unconditional jump to 0x2638 1C49 5B JUMPDEST 1C4A 50 POP 1C4B 60 PUSH1 0x00 1C4D 80 DUP1 1C4E 60 PUSH1 0x00 1C50 8A DUP11 1C51 13 SGT 1C52 61 PUSH2 0x1c8a 1C55 57 *JUMPI 1C56 84 DUP5 1C57 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C6C 16 AND 1C6D 84 DUP5 1C6E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C83 16 AND 1C84 10 LT 1C85 89 DUP10 1C86 61 PUSH2 0x1cbb 1C89 56 *JUMP 1C8A 5B JUMPDEST 1C8B 83 DUP4 1C8C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1CA1 16 AND 1CA2 85 DUP6 1CA3 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1CB8 16 AND 1CB9 10 LT 1CBA 8A DUP11 1CBB 5B JUMPDEST 1CBC 91 SWAP2 1CBD 50 POP 1CBE 91 SWAP2 1CBF 50 POP 1CC0 81 DUP2 1CC1 15 ISZERO 1CC2 61 PUSH2 0x1cda 1CC5 57 *JUMPI 1CC6 61 PUSH2 0x1cd5 1CC9 85 DUP6 1CCA 87 DUP8 1CCB 60 PUSH1 0x20 1CCD 01 ADD 1CCE 51 MLOAD 1CCF 33 CALLER 1CD0 84 DUP5 1CD1 61 PUSH2 0x2657 1CD4 56 *JUMP 1CD5 5B JUMPDEST 1CD6 61 PUSH2 0x0a24 1CD9 56 *JUMP 1CDA 5B JUMPDEST 1CDB 85 DUP6 1CDC 51 MLOAD 1CDD 61 PUSH2 0x1ce5 1CE0 90 SWAP1 1CE1 61 PUSH2 0x23ff 1CE4 56 *JUMP 1CE5 5B JUMPDEST 1CE6 15 ISZERO 1CE7 61 PUSH2 0x1d0a 1CEA 57 *JUMPI 1CEB 85 DUP6 1CEC 51 MLOAD 1CED 61 PUSH2 0x1cf5 1CF0 90 SWAP1 1CF1 61 PUSH2 0x2416 1CF4 56 *JUMP 1CF5 5B JUMPDEST 1CF6 86 DUP7 1CF7 52 MSTORE 1CF8 61 PUSH2 0x1d04 1CFB 81 DUP2 1CFC 33 CALLER 1CFD 60 PUSH1 0x00 1CFF 89 DUP10 1D00 61 PUSH2 0x244b 1D03 56 *JUMP 1D04 5B JUMPDEST 1D05 50 POP 1D06 61 PUSH2 0x0a24 1D09 56 *JUMP 1D0A 5B JUMPDEST 1D0B 80 DUP1 1D0C 60 PUSH1 0x00 1D0E 81 DUP2 1D0F 90 SWAP1 1D10 55 SSTORE 1D11 50 POP 1D12 83 DUP4 1D13 94 SWAP5 1D14 50 POP 1D15 61 PUSH2 0x0a24 1D18 85 DUP6 1D19 87 DUP8 1D1A 60 PUSH1 0x20 1D1C 01 ADD 1D1D 51 MLOAD 1D1E 33 CALLER 1D1F 84 DUP5 1D20 61 PUSH2 0x2657 1D23 56 *JUMP label_1D24: // Incoming call from 0x178B, returns to 0x178C // Incoming jump from 0x059B // Incoming call from 0x18E1, returns to 0x18E2 // Incoming call from 0x18EE, returns to 0x18EF // Inputs[8] // { // @1D28 memory[0x40:0x60] // @1D3E stack[-2] // @1D4B stack[-1] // @1D4F memory[0x40:0x60] // @1D64 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @1DA8 memory[0x40:0x60] // @1DAA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1DB1 stack[-3] // } 1D24 5B JUMPDEST 1D25 60 PUSH1 0x40 1D27 80 DUP1 1D28 51 MLOAD 1D29 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D3E 84 DUP5 1D3F 81 DUP2 1D40 16 AND 1D41 60 PUSH1 0x24 1D43 83 DUP4 1D44 01 ADD 1D45 52 MSTORE 1D46 60 PUSH1 0x44 1D48 80 DUP1 1D49 83 DUP4 1D4A 01 ADD 1D4B 85 DUP6 1D4C 90 SWAP1 1D4D 52 MSTORE 1D4E 83 DUP4 1D4F 51 MLOAD 1D50 80 DUP1 1D51 84 DUP5 1D52 03 SUB 1D53 90 SWAP1 1D54 91 SWAP2 1D55 01 ADD 1D56 81 DUP2 1D57 52 MSTORE 1D58 60 PUSH1 0x64 1D5A 90 SWAP1 1D5B 92 SWAP3 1D5C 01 ADD 1D5D 83 DUP4 1D5E 52 MSTORE 1D5F 60 PUSH1 0x20 1D61 82 DUP3 1D62 01 ADD 1D63 80 DUP1 1D64 51 MLOAD 1D65 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1D82 16 AND 1D83 7F PUSH32 0xa9059cbb00000000000000000000000000000000000000000000000000000000 1DA4 17 OR 1DA5 81 DUP2 1DA6 52 MSTORE 1DA7 92 SWAP3 1DA8 51 MLOAD 1DA9 82 DUP3 1DAA 51 MLOAD 1DAB 60 PUSH1 0x00 1DAD 94 SWAP5 1DAE 85 DUP6 1DAF 94 SWAP5 1DB0 93 SWAP4 1DB1 89 DUP10 1DB2 16 AND 1DB3 93 SWAP4 1DB4 92 SWAP3 1DB5 91 SWAP2 1DB6 82 DUP3 1DB7 91 SWAP2 1DB8 90 SWAP1 1DB9 80 DUP1 1DBA 83 DUP4 1DBB 83 DUP4 1DBC 5B JUMPDEST 1DBD 60 PUSH1 0x20 1DBF 83 DUP4 1DC0 10 LT 1DC1 61 PUSH2 0x1df9 1DC4 57 *JUMPI // Stack delta = +11 // Outputs[16] // { // @1D45 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @1D4D memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = stack[-1] // @1D57 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x44 + (memory[0x40:0x60] - memory[0x40:0x60]) // @1D5E memory[0x40:0x60] = memory[0x40:0x60] + 0x64 // @1DA6 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xa9059cbb00000000000000000000000000000000000000000000000000000000 | (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20]) // @1DAD stack[0] = 0x00 // @1DAF stack[1] = 0x00 // @1DB3 stack[2] = stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff // @1DB4 stack[3] = memory[0x40:0x60] // @1DB5 stack[4] = memory[0x40:0x60] // @1DB7 stack[5] = memory[0x40:0x60] // @1DB8 stack[6] = memory[0x40:0x60] + 0x20 // @1DB8 stack[7] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1DB9 stack[8] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1DBA stack[9] = memory[0x40:0x60] // @1DBB stack[10] = memory[0x40:0x60] + 0x20 // } // Block ends with conditional jump to 0x1df9, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 label_1DC5: // Incoming jump from 0x1DC4, if not memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 // Incoming jump from 0x1DC4, if not stack[-3] < 0x20 // Inputs[4] // { // @1DC5 stack[-1] // @1DC6 memory[stack[-1]:stack[-1] + 0x20] // @1DC7 stack[-2] // @1DEB stack[-3] // } 1DC5 80 DUP1 1DC6 51 MLOAD 1DC7 82 DUP3 1DC8 52 MSTORE 1DC9 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 1DEA 90 SWAP1 1DEB 92 SWAP3 1DEC 01 ADD 1DED 91 SWAP2 1DEE 60 PUSH1 0x20 1DF0 91 SWAP2 1DF1 82 DUP3 1DF2 01 ADD 1DF3 91 SWAP2 1DF4 01 ADD 1DF5 61 PUSH2 0x1dbc 1DF8 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1DC8 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1DED stack[-3] = stack[-3] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 // @1DF3 stack[-2] = 0x20 + stack[-2] // @1DF4 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1dbc label_1DF9: // Incoming jump from 0x1DC4, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 // Incoming jump from 0x1DC4, if stack[-3] < 0x20 // Inputs[15] // { // @1DFC stack[-3] // @1E07 stack[-1] // @1E08 memory[stack[-1]:stack[-1] + 0x20] // @1E0B stack[-2] // @1E0C memory[stack[-2]:stack[-2] + 0x20] // @1E19 stack[-4] // @1E19 stack[-5] // @1E1B stack[-6] // @1E1C stack[-8] // @1E23 memory[0x40:0x60] // @1E2A stack[-9] // @1E2B msg.gas // @1E2C address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @1E2C memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]] // @1E30 returndata.length // } 1DF9 5B JUMPDEST 1DFA 60 PUSH1 0x01 1DFC 83 DUP4 1DFD 60 PUSH1 0x20 1DFF 03 SUB 1E00 61 PUSH2 0x0100 1E03 0A EXP 1E04 03 SUB 1E05 80 DUP1 1E06 19 NOT 1E07 82 DUP3 1E08 51 MLOAD 1E09 16 AND 1E0A 81 DUP2 1E0B 84 DUP5 1E0C 51 MLOAD 1E0D 16 AND 1E0E 80 DUP1 1E0F 82 DUP3 1E10 17 OR 1E11 85 DUP6 1E12 52 MSTORE 1E13 50 POP 1E14 50 POP 1E15 50 POP 1E16 50 POP 1E17 50 POP 1E18 50 POP 1E19 90 SWAP1 1E1A 50 POP 1E1B 01 ADD 1E1C 91 SWAP2 1E1D 50 POP 1E1E 50 POP 1E1F 60 PUSH1 0x00 1E21 60 PUSH1 0x40 1E23 51 MLOAD 1E24 80 DUP1 1E25 83 DUP4 1E26 03 SUB 1E27 81 DUP2 1E28 60 PUSH1 0x00 1E2A 86 DUP7 1E2B 5A GAS 1E2C F1 CALL 1E2D 91 SWAP2 1E2E 50 POP 1E2F 50 POP 1E30 3D RETURNDATASIZE 1E31 80 DUP1 1E32 60 PUSH1 0x00 1E34 81 DUP2 1E35 14 EQ 1E36 61 PUSH2 0x1e5b 1E39 57 *JUMPI // Stack delta = -6 // Outputs[5] // { // @1E12 memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @1E2C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @1E2D stack[-9] = address(stack[-9]).call.gas(msg.gas)(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @1E30 stack[-8] = returndata.length // @1E31 stack[-7] = returndata.length // } // Block ends with conditional jump to 0x1e5b, if returndata.length == 0x00 label_1E3A: // Incoming jump from 0x1E39, if not returndata.length == 0x00 // Inputs[6] // { // @1E3C memory[0x40:0x60] // @1E3D stack[-2] // @1E44 returndata.length // @1E4C returndata.length // @1E4F returndata.length // @1E56 returndata[0x00:0x00 + returndata.length] // } 1E3A 60 PUSH1 0x40 1E3C 51 MLOAD 1E3D 91 SWAP2 1E3E 50 POP 1E3F 60 PUSH1 0x1f 1E41 19 NOT 1E42 60 PUSH1 0x3f 1E44 3D RETURNDATASIZE 1E45 01 ADD 1E46 16 AND 1E47 82 DUP3 1E48 01 ADD 1E49 60 PUSH1 0x40 1E4B 52 MSTORE 1E4C 3D RETURNDATASIZE 1E4D 82 DUP3 1E4E 52 MSTORE 1E4F 3D RETURNDATASIZE 1E50 60 PUSH1 0x00 1E52 60 PUSH1 0x20 1E54 84 DUP5 1E55 01 ADD 1E56 3E RETURNDATACOPY 1E57 61 PUSH2 0x1e60 1E5A 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1E3D stack[-2] = memory[0x40:0x60] // @1E4B memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1E4E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @1E56 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x1e60 label_1E5B: // Incoming jump from 0x1E39, if returndata.length == 0x00 // Inputs[4] // { // @1E5E stack[-2] // @1E62 stack[-4] // @1E64 stack[-5] // @1E64 stack[-3] // } 1E5B 5B JUMPDEST 1E5C 60 PUSH1 0x60 1E5E 91 SWAP2 1E5F 50 POP 1E60 5B JUMPDEST 1E61 50 POP 1E62 91 SWAP2 1E63 50 POP 1E64 91 SWAP2 1E65 50 POP 1E66 81 DUP2 1E67 80 DUP1 1E68 15 ISZERO 1E69 61 PUSH2 0x1e8e 1E6C 57 *JUMPI // Stack delta = -2 // Outputs[3] // { // @1E62 stack[-4] = 0x60 // @1E64 stack[-5] = stack[-3] // @1E66 stack[-3] = stack[-3] // } // Block ends with conditional jump to 0x1e8e, if !stack[-3] label_1E6D: // Incoming jump from 0x1E6C, if not !stack[-3] // Incoming jump from 0x1E6C, if not !stack[-3] // Inputs[2] // { // @1E6E stack[-2] // @1E6F memory[stack[-2]:stack[-2] + 0x20] // } 1E6D 50 POP 1E6E 80 DUP1 1E6F 51 MLOAD 1E70 15 ISZERO 1E71 80 DUP1 1E72 61 PUSH2 0x1e8e 1E75 57 *JUMPI // Stack delta = +0 // Outputs[1] { @1E70 stack[-1] = !memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x1e8e, if !memory[stack[-2]:stack[-2] + 0x20] label_1E76: // Incoming jump from 0x1E75, if not !memory[stack[-2]:stack[-2] + 0x20] // Inputs[2] // { // @1E77 stack[-2] // @1E7D memory[stack[-2]:stack[-2] + 0x20] // } 1E76 50 POP 1E77 80 DUP1 1E78 80 DUP1 1E79 60 PUSH1 0x20 1E7B 01 ADD 1E7C 90 SWAP1 1E7D 51 MLOAD 1E7E 60 PUSH1 0x20 1E80 81 DUP2 1E81 10 LT 1E82 15 ISZERO 1E83 61 PUSH2 0x1e8b 1E86 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @1E7C stack[-1] = 0x20 + stack[-2] // @1E7D stack[0] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x1e8b, if !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) label_1E87: // Incoming jump from 0x1E86, if not !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) // Inputs[1] { @1E8A memory[0x00:0x00] } 1E87 60 PUSH1 0x00 1E89 80 DUP1 1E8A FD *REVERT // Stack delta = +0 // Outputs[1] { @1E8A revert(memory[0x00:0x00]); } // Block terminates label_1E8B: // Incoming jump from 0x1E86, if !(memory[stack[-2]:stack[-2] + 0x20] < 0x20) // Inputs[2] // { // @1E8D memory[stack[-2]:stack[-2] + 0x20] // @1E8D stack[-2] // } 1E8B 5B JUMPDEST 1E8C 50 POP 1E8D 51 MLOAD // Stack delta = -1 // Outputs[1] { @1E8D stack[-2] = memory[stack[-2]:stack[-2] + 0x20] } // Block continues label_1E8E: // Incoming jump from 0x1E75, if !memory[stack[-2]:stack[-2] + 0x20] // Incoming jump from 0x1E6C, if !stack[-3] // Incoming jump from 0x1E6C, if !stack[-3] // Incoming jump from 0x1E8D // Inputs[1] { @1E92 stack[-1] } 1E8E 5B JUMPDEST 1E8F 61 PUSH2 0x0f91 1E92 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f91, if stack[-1] label_1E93: // Incoming jump from 0x1E92, if not stack[-1] // Inputs[3] // { // @1E96 memory[0x40:0x60] // @1EEF memory[0x40:0x60] // @1EF8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1E93 60 PUSH1 0x40 1E95 80 DUP1 1E96 51 MLOAD 1E97 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1EB8 81 DUP2 1EB9 52 MSTORE 1EBA 60 PUSH1 0x20 1EBC 60 PUSH1 0x04 1EBE 82 DUP3 1EBF 01 ADD 1EC0 52 MSTORE 1EC1 60 PUSH1 0x02 1EC3 60 PUSH1 0x24 1EC5 82 DUP3 1EC6 01 ADD 1EC7 52 MSTORE 1EC8 7F PUSH32 0x5354000000000000000000000000000000000000000000000000000000000000 1EE9 60 PUSH1 0x44 1EEB 82 DUP3 1EEC 01 ADD 1EED 52 MSTORE 1EEE 90 SWAP1 1EEF 51 MLOAD 1EF0 90 SWAP1 1EF1 81 DUP2 1EF2 90 SWAP1 1EF3 03 SUB 1EF4 60 PUSH1 0x64 1EF6 01 ADD 1EF7 90 SWAP1 1EF8 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1EB9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1EC0 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1EC7 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x02 // @1EED memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5354000000000000000000000000000000000000000000000000000000000000 // @1EF8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_1EF9: // Incoming call from 0x0F8E, returns to 0x0F8F // Incoming call from 0x05B7, returns to 0x05B8 // Incoming call from 0x0BF0, returns to 0x0BF1 // Incoming call from 0x0F82, returns to 0x0F83 // Inputs[5] // { // @1EFD memory[0x40:0x60] // @1F1F stack[-2] // @1F22 stack[-1] // @1F26 memory[0x40:0x60] // @1F2A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // } 1EF9 5B JUMPDEST 1EFA 60 PUSH1 0x40 1EFC 80 DUP1 1EFD 51 MLOAD 1EFE 60 PUSH1 0x00 1F00 80 DUP1 1F01 82 DUP3 1F02 52 MSTORE 1F03 60 PUSH1 0x20 1F05 82 DUP3 1F06 01 ADD 1F07 90 SWAP1 1F08 92 SWAP3 1F09 52 MSTORE 1F0A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1F1F 84 DUP5 1F20 16 AND 1F21 90 SWAP1 1F22 83 DUP4 1F23 90 SWAP1 1F24 60 PUSH1 0x40 1F26 51 MLOAD 1F27 80 DUP1 1F28 82 DUP3 1F29 80 DUP1 1F2A 51 MLOAD 1F2B 90 SWAP1 1F2C 60 PUSH1 0x20 1F2E 01 ADD 1F2F 90 SWAP1 1F30 80 DUP1 1F31 83 DUP4 1F32 83 DUP4 1F33 5B JUMPDEST 1F34 60 PUSH1 0x20 1F36 83 DUP4 1F37 10 LT 1F38 61 PUSH2 0x1f70 1F3B 57 *JUMPI // Stack delta = +11 // Outputs[13] // { // @1F02 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @1F08 stack[0] = 0x00 // @1F09 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 // @1F21 stack[1] = stack[-2] & 0xffffffffffffffffffffffffffffffffffffffff // @1F23 stack[2] = stack[-1] // @1F23 stack[3] = memory[0x40:0x60] // @1F26 stack[4] = memory[0x40:0x60] // @1F27 stack[5] = memory[0x40:0x60] // @1F2F stack[6] = 0x20 + memory[0x40:0x60] // @1F2F stack[7] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1F30 stack[8] = memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @1F31 stack[9] = memory[0x40:0x60] // @1F32 stack[10] = 0x20 + memory[0x40:0x60] // } // Block ends with conditional jump to 0x1f70, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 label_1F3C: // Incoming jump from 0x1F3B, if not stack[-3] < 0x20 // Incoming jump from 0x1F3B, if not memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 // Inputs[4] // { // @1F3C stack[-1] // @1F3D memory[stack[-1]:stack[-1] + 0x20] // @1F3E stack[-2] // @1F62 stack[-3] // } 1F3C 80 DUP1 1F3D 51 MLOAD 1F3E 82 DUP3 1F3F 52 MSTORE 1F40 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 1F61 90 SWAP1 1F62 92 SWAP3 1F63 01 ADD 1F64 91 SWAP2 1F65 60 PUSH1 0x20 1F67 91 SWAP2 1F68 82 DUP3 1F69 01 ADD 1F6A 91 SWAP2 1F6B 01 ADD 1F6C 61 PUSH2 0x1f33 1F6F 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1F3F memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @1F64 stack[-3] = stack[-3] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 // @1F6A stack[-2] = 0x20 + stack[-2] // @1F6B stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x1f33 label_1F70: // Incoming jump from 0x1F3B, if stack[-3] < 0x20 // Incoming jump from 0x1F3B, if memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] < 0x20 // Inputs[16] // { // @1F73 stack[-3] // @1F7E stack[-1] // @1F7F memory[stack[-1]:stack[-1] + 0x20] // @1F82 stack[-2] // @1F83 memory[stack[-2]:stack[-2] + 0x20] // @1F90 stack[-4] // @1F90 stack[-5] // @1F92 stack[-6] // @1F93 stack[-8] // @1F9A memory[0x40:0x60] // @1F9F stack[-9] // @1FA0 stack[-10] // @1FA1 msg.gas // @1FA2 address(stack[-10]).call.gas(msg.gas).value(stack[-9])(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @1FA2 memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]] // @1FA7 returndata.length // } 1F70 5B JUMPDEST 1F71 60 PUSH1 0x01 1F73 83 DUP4 1F74 60 PUSH1 0x20 1F76 03 SUB 1F77 61 PUSH2 0x0100 1F7A 0A EXP 1F7B 03 SUB 1F7C 80 DUP1 1F7D 19 NOT 1F7E 82 DUP3 1F7F 51 MLOAD 1F80 16 AND 1F81 81 DUP2 1F82 84 DUP5 1F83 51 MLOAD 1F84 16 AND 1F85 80 DUP1 1F86 82 DUP3 1F87 17 OR 1F88 85 DUP6 1F89 52 MSTORE 1F8A 50 POP 1F8B 50 POP 1F8C 50 POP 1F8D 50 POP 1F8E 50 POP 1F8F 50 POP 1F90 90 SWAP1 1F91 50 POP 1F92 01 ADD 1F93 91 SWAP2 1F94 50 POP 1F95 50 POP 1F96 60 PUSH1 0x00 1F98 60 PUSH1 0x40 1F9A 51 MLOAD 1F9B 80 DUP1 1F9C 83 DUP4 1F9D 03 SUB 1F9E 81 DUP2 1F9F 85 DUP6 1FA0 87 DUP8 1FA1 5A GAS 1FA2 F1 CALL 1FA3 92 SWAP3 1FA4 50 POP 1FA5 50 POP 1FA6 50 POP 1FA7 3D RETURNDATASIZE 1FA8 80 DUP1 1FA9 60 PUSH1 0x00 1FAB 81 DUP2 1FAC 14 EQ 1FAD 61 PUSH2 0x1fd2 1FB0 57 *JUMPI // Stack delta = -7 // Outputs[5] // { // @1F89 memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @1FA2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-10]).call.gas(msg.gas).value(stack[-9])(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @1FA3 stack[-10] = address(stack[-10]).call.gas(msg.gas).value(stack[-9])(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @1FA7 stack[-9] = returndata.length // @1FA8 stack[-8] = returndata.length // } // Block ends with conditional jump to 0x1fd2, if returndata.length == 0x00 label_1FB1: // Incoming jump from 0x1FB0, if not returndata.length == 0x00 // Inputs[6] // { // @1FB3 memory[0x40:0x60] // @1FB4 stack[-2] // @1FBB returndata.length // @1FC3 returndata.length // @1FC6 returndata.length // @1FCD returndata[0x00:0x00 + returndata.length] // } 1FB1 60 PUSH1 0x40 1FB3 51 MLOAD 1FB4 91 SWAP2 1FB5 50 POP 1FB6 60 PUSH1 0x1f 1FB8 19 NOT 1FB9 60 PUSH1 0x3f 1FBB 3D RETURNDATASIZE 1FBC 01 ADD 1FBD 16 AND 1FBE 82 DUP3 1FBF 01 ADD 1FC0 60 PUSH1 0x40 1FC2 52 MSTORE 1FC3 3D RETURNDATASIZE 1FC4 82 DUP3 1FC5 52 MSTORE 1FC6 3D RETURNDATASIZE 1FC7 60 PUSH1 0x00 1FC9 60 PUSH1 0x20 1FCB 84 DUP5 1FCC 01 ADD 1FCD 3E RETURNDATACOPY 1FCE 61 PUSH2 0x1fd7 1FD1 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1FB4 stack[-2] = memory[0x40:0x60] // @1FC2 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1FC5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @1FCD memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x1fd7 label_1FD2: // Incoming jump from 0x1FB0, if returndata.length == 0x00 // Inputs[3] // { // @1FD5 stack[-2] // @1FDA stack[-4] // @1FDA stack[-3] // } 1FD2 5B JUMPDEST 1FD3 60 PUSH1 0x60 1FD5 91 SWAP2 1FD6 50 POP 1FD7 5B JUMPDEST 1FD8 50 POP 1FD9 50 POP 1FDA 90 SWAP1 1FDB 50 POP 1FDC 80 DUP1 1FDD 61 PUSH2 0x0bf1 1FE0 57 *JUMPI // Stack delta = -3 // Outputs[1] { @1FDA stack[-4] = stack[-3] } // Block ends with conditional jump to 0x0bf1, if stack[-3] label_1FE1: // Incoming jump from 0x1FE0, if not stack[-3] // Incoming jump from 0x1FE0, if not stack[-3] // Inputs[3] // { // @1FE4 memory[0x40:0x60] // @203D memory[0x40:0x60] // @2046 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 1FE1 60 PUSH1 0x40 1FE3 80 DUP1 1FE4 51 MLOAD 1FE5 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2006 81 DUP2 2007 52 MSTORE 2008 60 PUSH1 0x20 200A 60 PUSH1 0x04 200C 82 DUP3 200D 01 ADD 200E 52 MSTORE 200F 60 PUSH1 0x03 2011 60 PUSH1 0x24 2013 82 DUP3 2014 01 ADD 2015 52 MSTORE 2016 7F PUSH32 0x5354450000000000000000000000000000000000000000000000000000000000 2037 60 PUSH1 0x44 2039 82 DUP3 203A 01 ADD 203B 52 MSTORE 203C 90 SWAP1 203D 51 MLOAD 203E 90 SWAP1 203F 81 DUP2 2040 90 SWAP1 2041 03 SUB 2042 60 PUSH1 0x64 2044 01 ADD 2045 90 SWAP1 2046 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2007 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @200E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2015 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x03 // @203B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x5354450000000000000000000000000000000000000000000000000000000000 // @2046 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2047: // Incoming call from 0x0780, returns to 0x0781 // Incoming call from 0x05C4, returns to 0x05C5 // Inputs[2] // { // @204B stack[-1] // @204C memory[stack[-1]:stack[-1] + 0x20] // } 2047 5B JUMPDEST 2048 60 PUSH1 0x00 204A 5B JUMPDEST 204B 81 DUP2 204C 51 MLOAD 204D 81 DUP2 204E 10 LT 204F 15 ISZERO 2050 61 PUSH2 0x05a4 2053 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2048 stack[0] = 0x00 } // Block ends with conditional jump to 0x05a4, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_2054: // Incoming jump from 0x2053, if not !(stack[-1] < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x2053, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @2057 stack[-2] // @2058 stack[-1] // @205A memory[stack[-2]:stack[-2] + 0x20] // } 2054 61 PUSH2 0x206f 2057 82 DUP3 2058 82 DUP3 2059 81 DUP2 205A 51 MLOAD 205B 81 DUP2 205C 10 LT 205D 61 PUSH2 0x2062 2060 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @2054 stack[0] = 0x206f // @2057 stack[1] = stack[-2] // @2058 stack[2] = stack[-1] // } // Block ends with conditional call to 0x2062, returns to 0x206F, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] label_2061: // Incoming jump from 0x2060, if not stack[-1] < memory[stack[-2]:stack[-2] + 0x20] 2061 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2061 assert(); } // Block terminates label_2062: // Incoming call from 0x2060, returns to 0x206F, if stack[-1] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @2065 stack[-1] // @2069 stack[-2] // @206A memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] // } 2062 5B JUMPDEST 2063 60 PUSH1 0x20 2065 02 MUL 2066 60 PUSH1 0x20 2068 01 ADD 2069 01 ADD 206A 51 MLOAD 206B 61 PUSH2 0x2835 206E 56 *JUMP // Stack delta = -1 // Outputs[1] { @206A stack[-2] = memory[0x20 + 0x20 * stack[-1] + stack[-2]:0x20 + 0x20 * stack[-1] + stack[-2] + 0x20] } // Block ends with unconditional jump to 0x2835 label_206F: // Incoming return from call to 0x2062 at 0x2060 // Inputs[1] { @2073 stack[-1] } 206F 5B JUMPDEST 2070 61 PUSH2 0x20a5 2073 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x20a5, if stack[-1] label_2074: // Incoming jump from 0x2073, if not stack[-1] // Inputs[1] { @2076 memory[0x40:0x60] } 2074 60 PUSH1 0x40 2076 51 MLOAD 2077 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2098 81 DUP2 2099 52 MSTORE 209A 60 PUSH1 0x04 209C 01 ADD 209D 61 PUSH2 0x087a 20A0 90 SWAP1 20A1 61 PUSH2 0x3b42 20A4 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2099 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @20A0 stack[0] = 0x087a // @20A0 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x3b42, returns to 0x087A label_20A5: // Incoming jump from 0x2073, if stack[-1] // Inputs[1] { @20A8 stack[-1] } 20A5 5B JUMPDEST 20A6 60 PUSH1 0x01 20A8 01 ADD 20A9 61 PUSH2 0x204a 20AC 56 *JUMP // Stack delta = +0 // Outputs[1] { @20A8 stack[-1] = 0x01 + stack[-1] } // Block ends with unconditional jump to 0x204a label_20AD: // Incoming jump from 0x0629 // Inputs[1] { @20B3 stack[-7] } 20AD 5B JUMPDEST 20AE 60 PUSH1 0x00 20B0 61 PUSH2 0x20b8 20B3 88 DUP9 20B4 61 PUSH2 0x05ba 20B7 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @20AE stack[0] = 0x00 // @20B0 stack[1] = 0x20b8 // @20B3 stack[2] = stack[-7] // } // Block ends with unconditional jump to 0x05ba 20B8 5B JUMPDEST 20B9 60 PUSH1 0x40 20BB 51 MLOAD 20BC 90 SWAP1 20BD 91 SWAP2 20BE 50 POP 20BF 60 PUSH1 0x00 20C1 90 SWAP1 20C2 61 PUSH2 0x2115 20C5 90 SWAP1 20C6 7F PUSH32 0x1900000000000000000000000000000000000000000000000000000000000000 20E7 90 SWAP1 20E8 7F PUSH32 0x0100000000000000000000000000000000000000000000000000000000000000 2109 90 SWAP1 210A 30 ADDRESS 210B 90 SWAP1 210C 86 DUP7 210D 90 SWAP1 210E 60 PUSH1 0x20 2110 01 ADD 2111 61 PUSH2 0x395b 2114 56 *JUMP 2115 5B JUMPDEST 2116 60 PUSH1 0x40 2118 51 MLOAD 2119 60 PUSH1 0x20 211B 81 DUP2 211C 83 DUP4 211D 03 SUB 211E 03 SUB 211F 81 DUP2 2120 52 MSTORE 2121 90 SWAP1 2122 60 PUSH1 0x40 2124 52 MSTORE 2125 80 DUP1 2126 51 MLOAD 2127 90 SWAP1 2128 60 PUSH1 0x20 212A 01 ADD 212B 20 SHA3 212C 90 SWAP1 212D 50 POP 212E 60 PUSH1 0x00 2130 60 PUSH1 0x01 2132 82 DUP3 2133 8A DUP11 2134 8A DUP11 2135 8A DUP11 2136 60 PUSH1 0x40 2138 51 MLOAD 2139 60 PUSH1 0x00 213B 81 DUP2 213C 52 MSTORE 213D 60 PUSH1 0x20 213F 01 ADD 2140 60 PUSH1 0x40 2142 52 MSTORE 2143 60 PUSH1 0x40 2145 51 MLOAD 2146 61 PUSH2 0x2152 2149 94 SWAP5 214A 93 SWAP4 214B 92 SWAP3 214C 91 SWAP2 214D 90 SWAP1 214E 61 PUSH2 0x3ada 2151 56 *JUMP 2152 5B JUMPDEST 2153 60 PUSH1 0x20 2155 60 PUSH1 0x40 2157 51 MLOAD 2158 60 PUSH1 0x20 215A 81 DUP2 215B 03 SUB 215C 90 SWAP1 215D 80 DUP1 215E 84 DUP5 215F 03 SUB 2160 90 SWAP1 2161 85 DUP6 2162 5A GAS 2163 FA STATICCALL 2164 15 ISZERO 2165 80 DUP1 2166 15 ISZERO 2167 61 PUSH2 0x2174 216A 57 *JUMPI 216B 3D RETURNDATASIZE 216C 60 PUSH1 0x00 216E 80 DUP1 216F 3E RETURNDATACOPY 2170 3D RETURNDATASIZE 2171 60 PUSH1 0x00 2173 FD *REVERT 2174 5B JUMPDEST 2175 50 POP 2176 50 POP 2177 50 POP 2178 60 PUSH1 0x20 217A 60 PUSH1 0x40 217C 51 MLOAD 217D 03 SUB 217E 51 MLOAD 217F 90 SWAP1 2180 50 POP 2181 60 PUSH1 0x00 2183 60 PUSH1 0x01 2185 83 DUP4 2186 88 DUP9 2187 88 DUP9 2188 88 DUP9 2189 60 PUSH1 0x40 218B 51 MLOAD 218C 60 PUSH1 0x00 218E 81 DUP2 218F 52 MSTORE 2190 60 PUSH1 0x20 2192 01 ADD 2193 60 PUSH1 0x40 2195 52 MSTORE 2196 60 PUSH1 0x40 2198 51 MLOAD 2199 61 PUSH2 0x21a5 219C 94 SWAP5 219D 93 SWAP4 219E 92 SWAP3 219F 91 SWAP2 21A0 90 SWAP1 21A1 61 PUSH2 0x3ada 21A4 56 *JUMP 21A5 5B JUMPDEST 21A6 60 PUSH1 0x20 21A8 60 PUSH1 0x40 21AA 51 MLOAD 21AB 60 PUSH1 0x20 21AD 81 DUP2 21AE 03 SUB 21AF 90 SWAP1 21B0 80 DUP1 21B1 84 DUP5 21B2 03 SUB 21B3 90 SWAP1 21B4 85 DUP6 21B5 5A GAS 21B6 FA STATICCALL 21B7 15 ISZERO 21B8 80 DUP1 21B9 15 ISZERO 21BA 61 PUSH2 0x21c7 21BD 57 *JUMPI 21BE 3D RETURNDATASIZE 21BF 60 PUSH1 0x00 21C1 80 DUP1 21C2 3E RETURNDATACOPY 21C3 3D RETURNDATASIZE 21C4 60 PUSH1 0x00 21C6 FD *REVERT 21C7 5B JUMPDEST 21C8 50 POP 21C9 50 POP 21CA 50 POP 21CB 60 PUSH1 0x20 21CD 60 PUSH1 0x40 21CF 51 MLOAD 21D0 03 SUB 21D1 51 MLOAD 21D2 90 SWAP1 21D3 50 POP 21D4 61 PUSH2 0x21dd 21D7 82 DUP3 21D8 82 DUP3 21D9 61 PUSH2 0x2871 21DC 56 *JUMP 21DD 5B JUMPDEST 21DE 50 POP 21DF 50 POP 21E0 50 POP 21E1 50 POP 21E2 50 POP 21E3 50 POP 21E4 50 POP 21E5 50 POP 21E6 50 POP 21E7 50 POP 21E8 50 POP 21E9 56 *JUMP label_21EA: // Incoming call from 0x197A, returns to 0x197B // Inputs[2] // { // @21EB block.timestamp // @21EC stack[-1] // } 21EA 5B JUMPDEST 21EB 42 TIMESTAMP 21EC 90 SWAP1 21ED 56 *JUMP // Stack delta = +0 // Outputs[1] { @21EC stack[-1] = block.timestamp } // Block ends with unconditional jump to stack[-1] 21EE 5B JUMPDEST 21EF 60 PUSH1 0x00 21F1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2206 84 DUP5 2207 16 AND 2208 61 PUSH2 0x220f 220B 57 *JUMPI 220C 30 ADDRESS 220D 93 SWAP4 220E 50 POP 220F 5B JUMPDEST 2210 60 PUSH1 0x00 2212 80 DUP1 2213 60 PUSH1 0x00 2215 61 PUSH2 0x2221 2218 85 DUP6 2219 60 PUSH1 0x00 221B 01 ADD 221C 51 MLOAD 221D 61 PUSH2 0x2607 2220 56 *JUMP 2221 5B JUMPDEST 2222 91 SWAP2 2223 94 SWAP5 2224 50 POP 2225 92 SWAP3 2226 50 POP 2227 90 SWAP1 2228 50 POP 2229 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 223E 80 DUP1 223F 83 DUP4 2240 16 AND 2241 90 SWAP1 2242 84 DUP5 2243 16 AND 2244 10 LT 2245 60 PUSH1 0x00 2247 80 DUP1 2248 61 PUSH2 0x2252 224B 86 DUP7 224C 86 DUP7 224D 86 DUP7 224E 61 PUSH2 0x2995 2251 56 *JUMP 2252 5B JUMPDEST 2253 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2268 16 AND 2269 63 PUSH4 0x128acb08 226E 8B DUP12 226F 85 DUP6 2270 61 PUSH2 0x2278 2273 8F DUP16 2274 61 PUSH2 0x2a2e 2277 56 *JUMP 2278 5B JUMPDEST 2279 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 228E 8E DUP15 228F 16 AND 2290 15 ISZERO 2291 61 PUSH2 0x229a 2294 57 *JUMPI 2295 8D DUP14 2296 61 PUSH2 0x22c0 2299 56 *JUMP 229A 5B JUMPDEST 229B 87 DUP8 229C 61 PUSH2 0x22b9 229F 57 *JUMPI 22A0 73 PUSH20 0xfffd8963efd1fc6a506488495d951d5263988d25 22B5 61 PUSH2 0x22c0 22B8 56 *JUMP 22B9 5B JUMPDEST 22BA 64 PUSH5 0x01000276a4 22C0 5B JUMPDEST 22C1 8D DUP14 22C2 60 PUSH1 0x40 22C4 51 MLOAD 22C5 60 PUSH1 0x20 22C7 01 ADD 22C8 61 PUSH2 0x22d1 22CB 91 SWAP2 22CC 90 SWAP1 22CD 61 PUSH2 0x3cc3 22D0 56 *JUMP 22D1 5B JUMPDEST 22D2 60 PUSH1 0x40 22D4 51 MLOAD 22D5 60 PUSH1 0x20 22D7 81 DUP2 22D8 83 DUP4 22D9 03 SUB 22DA 03 SUB 22DB 81 DUP2 22DC 52 MSTORE 22DD 90 SWAP1 22DE 60 PUSH1 0x40 22E0 52 MSTORE 22E1 60 PUSH1 0x40 22E3 51 MLOAD 22E4 86 DUP7 22E5 63 PUSH4 0xffffffff 22EA 16 AND 22EB 60 PUSH1 0xe0 22ED 1B SHL 22EE 81 DUP2 22EF 52 MSTORE 22F0 60 PUSH1 0x04 22F2 01 ADD 22F3 61 PUSH2 0x2300 22F6 95 SWAP6 22F7 94 SWAP5 22F8 93 SWAP4 22F9 92 SWAP3 22FA 91 SWAP2 22FB 90 SWAP1 22FC 61 PUSH2 0x39f6 22FF 56 *JUMP 2300 5B JUMPDEST 2301 60 PUSH1 0x40 2303 80 DUP1 2304 51 MLOAD 2305 80 DUP1 2306 83 DUP4 2307 03 SUB 2308 81 DUP2 2309 60 PUSH1 0x00 230B 87 DUP8 230C 80 DUP1 230D 3B EXTCODESIZE 230E 15 ISZERO 230F 80 DUP1 2310 15 ISZERO 2311 61 PUSH2 0x2319 2314 57 *JUMPI 2315 60 PUSH1 0x00 2317 80 DUP1 2318 FD *REVERT 2319 5B JUMPDEST 231A 50 POP 231B 5A GAS 231C F1 CALL 231D 15 ISZERO 231E 80 DUP1 231F 15 ISZERO 2320 61 PUSH2 0x232d 2323 57 *JUMPI 2324 3D RETURNDATASIZE 2325 60 PUSH1 0x00 2327 80 DUP1 2328 3E RETURNDATACOPY 2329 3D RETURNDATASIZE 232A 60 PUSH1 0x00 232C FD *REVERT 232D 5B JUMPDEST 232E 50 POP 232F 50 POP 2330 50 POP 2331 50 POP 2332 60 PUSH1 0x40 2334 51 MLOAD 2335 3D RETURNDATASIZE 2336 60 PUSH1 0x1f 2338 19 NOT 2339 60 PUSH1 0x1f 233B 82 DUP3 233C 01 ADD 233D 16 AND 233E 82 DUP3 233F 01 ADD 2340 80 DUP1 2341 60 PUSH1 0x40 2343 52 MSTORE 2344 50 POP 2345 81 DUP2 2346 01 ADD 2347 90 SWAP1 2348 61 PUSH2 0x2351 234B 91 SWAP2 234C 90 SWAP1 234D 61 PUSH2 0x3561 2350 56 *JUMP 2351 5B JUMPDEST 2352 91 SWAP2 2353 50 POP 2354 91 SWAP2 2355 50 POP 2356 82 DUP3 2357 61 PUSH2 0x2360 235A 57 *JUMPI 235B 81 DUP2 235C 61 PUSH2 0x2362 235F 56 *JUMP 2360 5B JUMPDEST 2361 80 DUP1 2362 5B JUMPDEST 2363 60 PUSH1 0x00 2365 03 SUB 2366 9B SWAP12 2367 9A SWAP11 2368 50 POP 2369 50 POP 236A 50 POP 236B 50 POP 236C 50 POP 236D 50 POP 236E 50 POP 236F 50 POP 2370 50 POP 2371 50 POP 2372 50 POP 2373 56 *JUMP label_2374: // Incoming jump from 0x0C3D // Inputs[1] { @237A stack[-7] } 2374 5B JUMPDEST 2375 60 PUSH1 0x00 2377 61 PUSH2 0x237f 237A 88 DUP9 237B 61 PUSH2 0x0776 237E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2375 stack[0] = 0x00 // @2377 stack[1] = 0x237f // @237A stack[2] = stack[-7] // } // Block ends with unconditional jump to 0x0776 237F 5B JUMPDEST 2380 60 PUSH1 0x40 2382 51 MLOAD 2383 90 SWAP1 2384 91 SWAP2 2385 50 POP 2386 60 PUSH1 0x00 2388 90 SWAP1 2389 61 PUSH2 0x2115 238C 90 SWAP1 238D 7F PUSH32 0x1900000000000000000000000000000000000000000000000000000000000000 23AE 90 SWAP1 23AF 83 DUP4 23B0 90 SWAP1 23B1 30 ADDRESS 23B2 90 SWAP1 23B3 86 DUP7 23B4 90 SWAP1 23B5 60 PUSH1 0x20 23B7 01 ADD 23B8 61 PUSH2 0x395b 23BB 56 *JUMP label_23BC: // Incoming call from 0x18C6, returns to 0x18C7 // Incoming call from 0x0F68, returns to 0x0F69 // Inputs[1] { @23BF stack[-2] } 23BC 5B JUMPDEST 23BD 60 PUSH1 0x00 23BF 82 DUP3 23C0 15 ISZERO 23C1 80 DUP1 23C2 61 PUSH2 0x23d7 23C5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @23BD stack[0] = 0x00 // @23C0 stack[1] = !stack[-2] // } // Block ends with conditional jump to 0x23d7, if !stack[-2] label_23C6: // Incoming jump from 0x23C5, if not !stack[-2] // Inputs[2] // { // @23C8 stack[-4] // @23C9 stack[-3] // } 23C6 50 POP 23C7 50 POP 23C8 81 DUP2 23C9 81 DUP2 23CA 02 MUL 23CB 81 DUP2 23CC 83 DUP4 23CD 82 DUP3 23CE 81 DUP2 23CF 61 PUSH2 0x23d4 23D2 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @23CA stack[-2] = stack[-3] * stack[-4] // @23CB stack[-1] = stack[-3] // @23CC stack[0] = stack[-4] // @23CD stack[1] = stack[-3] * stack[-4] // } // Block ends with conditional jump to 0x23d4, if stack[-4] label_23D3: // Incoming jump from 0x23D2, if not stack[-4] 23D3 FE *ASSERT // Stack delta = +0 // Outputs[1] { @23D3 assert(); } // Block terminates label_23D4: // Incoming jump from 0x23D2, if stack[-4] // Inputs[3] // { // @23D5 stack[-2] // @23D5 stack[-1] // @23D6 stack[-3] // } 23D4 5B JUMPDEST 23D5 04 DIV 23D6 14 EQ // Stack delta = -2 // Outputs[1] { @23D6 stack[-3] = stack[-1] / stack[-2] == stack[-3] } // Block continues label_23D7: // Incoming jump from 0x23C5, if !stack[-2] // Incoming jump from 0x23D6 // Inputs[1] { @23DB stack[-1] } 23D7 5B JUMPDEST 23D8 61 PUSH2 0x23e0 23DB 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x23e0, if stack[-1] label_23DC: // Incoming jump from 0x23DB, if not stack[-1] // Inputs[1] { @23DF memory[0x00:0x00] } 23DC 60 PUSH1 0x00 23DE 80 DUP1 23DF FD *REVERT // Stack delta = +0 // Outputs[1] { @23DF revert(memory[0x00:0x00]); } // Block terminates label_23E0: // Incoming return from call to 0x2A60 at 0x23FE // Incoming jump from 0x2EDF, if stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff == msg.sender // Incoming jump from 0x23DB, if stack[-1] // Inputs[3] // { // @23E1 stack[-4] // @23E1 stack[-1] // @23E2 stack[-3] // } 23E0 5B JUMPDEST 23E1 92 SWAP3 23E2 91 SWAP2 23E3 50 POP 23E4 50 POP 23E5 56 *JUMP // Stack delta = -3 // Outputs[1] { @23E1 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_23E6: // Incoming jump from 0x1A2E // Inputs[2] // { // @23EE stack[-1] // @23EF memory[stack[-1]:stack[-1] + 0x20] // } 23E6 5B JUMPDEST 23E7 60 PUSH1 0x00 23E9 61 PUSH2 0x23e0 23EC 60 PUSH1 0x14 23EE 83 DUP4 23EF 51 MLOAD 23F0 03 SUB 23F1 83 DUP4 23F2 61 PUSH2 0x2a60 23F5 90 SWAP1 23F6 91 SWAP2 23F7 90 SWAP1 23F8 63 PUSH4 0xffffffff 23FD 16 AND 23FE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @23E7 stack[0] = 0x00 // @23E9 stack[1] = 0x23e0 // @23F6 stack[2] = stack[-1] // @23F7 stack[3] = memory[stack[-1]:stack[-1] + 0x20] - 0x14 // } // Block ends with call to 0xffffffff & 0x2a60, returns to 0x23E0 23FF 5B JUMPDEST 2400 51 MLOAD 2401 60 PUSH1 0x42 2403 11 GT 2404 15 ISZERO 2405 90 SWAP1 2406 56 *JUMP 2407 5B JUMPDEST 2408 60 PUSH1 0x60 240A 61 PUSH2 0x23e0 240D 82 DUP3 240E 60 PUSH1 0x00 2410 60 PUSH1 0x2b 2412 61 PUSH2 0x2b60 2415 56 *JUMP 2416 5B JUMPDEST 2417 80 DUP1 2418 51 MLOAD 2419 60 PUSH1 0x60 241B 90 SWAP1 241C 61 PUSH2 0x23e0 241F 90 SWAP1 2420 83 DUP4 2421 90 SWAP1 2422 60 PUSH1 0x17 2424 90 SWAP1 2425 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe9 2446 01 ADD 2447 61 PUSH2 0x2b60 244A 56 *JUMP 244B 5B JUMPDEST 244C 60 PUSH1 0x00 244E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2463 84 DUP5 2464 16 AND 2465 61 PUSH2 0x246c 2468 57 *JUMPI 2469 30 ADDRESS 246A 93 SWAP4 246B 50 POP 246C 5B JUMPDEST 246D 60 PUSH1 0x00 246F 80 DUP1 2470 60 PUSH1 0x00 2472 61 PUSH2 0x247e 2475 85 DUP6 2476 60 PUSH1 0x00 2478 01 ADD 2479 51 MLOAD 247A 61 PUSH2 0x2607 247D 56 *JUMP 247E 5B JUMPDEST 247F 91 SWAP2 2480 94 SWAP5 2481 50 POP 2482 92 SWAP3 2483 50 POP 2484 90 SWAP1 2485 50 POP 2486 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 249B 80 DUP1 249C 84 DUP5 249D 16 AND 249E 90 SWAP1 249F 83 DUP4 24A0 16 AND 24A1 10 LT 24A2 60 PUSH1 0x00 24A4 80 DUP1 24A5 61 PUSH2 0x24af 24A8 85 DUP6 24A9 87 DUP8 24AA 86 DUP7 24AB 61 PUSH2 0x2995 24AE 56 *JUMP 24AF 5B JUMPDEST 24B0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 24C5 16 AND 24C6 63 PUSH4 0x128acb08 24CB 8B DUP12 24CC 85 DUP6 24CD 61 PUSH2 0x24d5 24D0 8F DUP16 24D1 61 PUSH2 0x2a2e 24D4 56 *JUMP 24D5 5B JUMPDEST 24D6 60 PUSH1 0x00 24D8 03 SUB 24D9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 24EE 8E DUP15 24EF 16 AND 24F0 15 ISZERO 24F1 61 PUSH2 0x24fa 24F4 57 *JUMPI 24F5 8D DUP14 24F6 61 PUSH2 0x2520 24F9 56 *JUMP 24FA 5B JUMPDEST 24FB 87 DUP8 24FC 61 PUSH2 0x2519 24FF 57 *JUMPI 2500 73 PUSH20 0xfffd8963efd1fc6a506488495d951d5263988d25 2515 61 PUSH2 0x2520 2518 56 *JUMP 2519 5B JUMPDEST 251A 64 PUSH5 0x01000276a4 2520 5B JUMPDEST 2521 8D DUP14 2522 60 PUSH1 0x40 2524 51 MLOAD 2525 60 PUSH1 0x20 2527 01 ADD 2528 61 PUSH2 0x2531 252B 91 SWAP2 252C 90 SWAP1 252D 61 PUSH2 0x3cc3 2530 56 *JUMP 2531 5B JUMPDEST 2532 60 PUSH1 0x40 2534 51 MLOAD 2535 60 PUSH1 0x20 2537 81 DUP2 2538 83 DUP4 2539 03 SUB 253A 03 SUB 253B 81 DUP2 253C 52 MSTORE 253D 90 SWAP1 253E 60 PUSH1 0x40 2540 52 MSTORE 2541 60 PUSH1 0x40 2543 51 MLOAD 2544 86 DUP7 2545 63 PUSH4 0xffffffff 254A 16 AND 254B 60 PUSH1 0xe0 254D 1B SHL 254E 81 DUP2 254F 52 MSTORE 2550 60 PUSH1 0x04 2552 01 ADD 2553 61 PUSH2 0x2560 2556 95 SWAP6 2557 94 SWAP5 2558 93 SWAP4 2559 92 SWAP3 255A 91 SWAP2 255B 90 SWAP1 255C 61 PUSH2 0x39f6 255F 56 *JUMP 2560 5B JUMPDEST 2561 60 PUSH1 0x40 2563 80 DUP1 2564 51 MLOAD 2565 80 DUP1 2566 83 DUP4 2567 03 SUB 2568 81 DUP2 2569 60 PUSH1 0x00 256B 87 DUP8 256C 80 DUP1 256D 3B EXTCODESIZE 256E 15 ISZERO 256F 80 DUP1 2570 15 ISZERO 2571 61 PUSH2 0x2579 2574 57 *JUMPI 2575 60 PUSH1 0x00 2577 80 DUP1 2578 FD *REVERT 2579 5B JUMPDEST 257A 50 POP 257B 5A GAS 257C F1 CALL 257D 15 ISZERO 257E 80 DUP1 257F 15 ISZERO 2580 61 PUSH2 0x258d 2583 57 *JUMPI 2584 3D RETURNDATASIZE 2585 60 PUSH1 0x00 2587 80 DUP1 2588 3E RETURNDATACOPY 2589 3D RETURNDATASIZE 258A 60 PUSH1 0x00 258C FD *REVERT 258D 5B JUMPDEST 258E 50 POP 258F 50 POP 2590 50 POP 2591 50 POP 2592 60 PUSH1 0x40 2594 51 MLOAD 2595 3D RETURNDATASIZE 2596 60 PUSH1 0x1f 2598 19 NOT 2599 60 PUSH1 0x1f 259B 82 DUP3 259C 01 ADD 259D 16 AND 259E 82 DUP3 259F 01 ADD 25A0 80 DUP1 25A1 60 PUSH1 0x40 25A3 52 MSTORE 25A4 50 POP 25A5 81 DUP2 25A6 01 ADD 25A7 90 SWAP1 25A8 61 PUSH2 0x25b1 25AB 91 SWAP2 25AC 90 SWAP1 25AD 61 PUSH2 0x3561 25B0 56 *JUMP 25B1 5B JUMPDEST 25B2 91 SWAP2 25B3 50 POP 25B4 91 SWAP2 25B5 50 POP 25B6 60 PUSH1 0x00 25B8 83 DUP4 25B9 61 PUSH2 0x25c6 25BC 57 *JUMPI 25BD 81 DUP2 25BE 83 DUP4 25BF 60 PUSH1 0x00 25C1 03 SUB 25C2 61 PUSH2 0x25cc 25C5 56 *JUMP 25C6 5B JUMPDEST 25C7 82 DUP3 25C8 82 DUP3 25C9 60 PUSH1 0x00 25CB 03 SUB 25CC 5B JUMPDEST 25CD 90 SWAP1 25CE 98 SWAP9 25CF 50 POP 25D0 90 SWAP1 25D1 50 POP 25D2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 25E7 8A DUP11 25E8 16 AND 25E9 61 PUSH2 0x25f8 25EC 57 *JUMPI 25ED 8B DUP12 25EE 81 DUP2 25EF 14 EQ 25F0 61 PUSH2 0x25f8 25F3 57 *JUMPI 25F4 60 PUSH1 0x00 25F6 80 DUP1 25F7 FD *REVERT 25F8 5B JUMPDEST 25F9 50 POP 25FA 50 POP 25FB 50 POP 25FC 50 POP 25FD 50 POP 25FE 50 POP 25FF 50 POP 2600 94 SWAP5 2601 93 SWAP4 2602 50 POP 2603 50 POP 2604 50 POP 2605 50 POP 2606 56 *JUMP label_2607: // Incoming call from 0x1C16, returns to 0x1C17 // Inputs[1] { @260F stack[-1] } 2607 5B JUMPDEST 2608 60 PUSH1 0x00 260A 80 DUP1 260B 80 DUP1 260C 61 PUSH2 0x2615 260F 84 DUP5 2610 82 DUP3 2611 61 PUSH2 0x2a60 2614 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @2608 stack[0] = 0x00 // @260A stack[1] = 0x00 // @260B stack[2] = 0x00 // @260C stack[3] = 0x2615 // @260F stack[4] = stack[-1] // @2610 stack[5] = 0x00 // } // Block ends with call to 0x2a60, returns to 0x2615 label_2615: // Incoming return from call to 0x2A60 at 0x2614 // Inputs[3] // { // @2616 stack[-4] // @2616 stack[-1] // @261B stack[-5] // } 2615 5B JUMPDEST 2616 92 SWAP3 2617 50 POP 2618 61 PUSH2 0x2622 261B 84 DUP5 261C 60 PUSH1 0x14 261E 61 PUSH2 0x2d47 2621 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2616 stack[-4] = stack[-1] // @2618 stack[-1] = 0x2622 // @261B stack[0] = stack[-5] // @261C stack[1] = 0x14 // } // Block ends with call to 0x2d47, returns to 0x2622 label_2622: // Incoming return from call to 0x2D47 at 0x2621 // Inputs[3] // { // @2623 stack[-2] // @2623 stack[-1] // @2628 stack[-5] // } 2622 5B JUMPDEST 2623 90 SWAP1 2624 50 POP 2625 61 PUSH2 0x262f 2628 84 DUP5 2629 60 PUSH1 0x17 262B 61 PUSH2 0x2a60 262E 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @2623 stack[-2] = stack[-1] // @2625 stack[-1] = 0x262f // @2628 stack[0] = stack[-5] // @2629 stack[1] = 0x17 // } // Block ends with call to 0x2a60, returns to 0x262F label_262F: // Incoming return from call to 0x2A60 at 0x262E // Inputs[6] // { // @2630 stack[-1] // @2630 stack[-3] // @2632 stack[-2] // @2632 stack[-4] // @2633 stack[-6] // @2635 stack[-5] // } 262F 5B JUMPDEST 2630 91 SWAP2 2631 50 POP 2632 91 SWAP2 2633 93 SWAP4 2634 90 SWAP1 2635 92 SWAP3 2636 50 POP 2637 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @2632 stack[-4] = stack[-2] // @2633 stack[-6] = stack[-4] // @2635 stack[-5] = stack[-1] // } // Block ends with unconditional jump to stack[-6] label_2638: // Incoming jump from 0x1C48 // Inputs[4] // { // @263E stack[-4] // @2642 stack[-3] // @2643 stack[-2] // @2644 stack[-1] // } 2638 5B JUMPDEST 2639 60 PUSH1 0x00 263B 61 PUSH2 0x264e 263E 85 DUP6 263F 61 PUSH2 0x2649 2642 86 DUP7 2643 86 DUP7 2644 86 DUP7 2645 61 PUSH2 0x2e37 2648 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @2639 stack[0] = 0x00 // @263B stack[1] = 0x264e // @263E stack[2] = stack[-4] // @263F stack[3] = 0x2649 // @2642 stack[4] = stack[-3] // @2643 stack[5] = stack[-2] // @2644 stack[6] = stack[-1] // } // Block ends with call to 0x2e37, returns to 0x2649 label_2649: // Incoming return from call to 0x2E37 at 0x2648 2649 5B JUMPDEST 264A 61 PUSH2 0x2eb4 264D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2eb4 label_264E: // Incoming return from call to 0x2649 at 0x2648 // Incoming return from call to 0x3E3C at 0x3668 // Inputs[3] // { // @264F stack[-7] // @264F stack[-1] // @2650 stack[-6] // } 264E 5B JUMPDEST 264F 95 SWAP6 2650 94 SWAP5 2651 50 POP 2652 50 POP 2653 50 POP 2654 50 POP 2655 50 POP 2656 56 *JUMP // Stack delta = -6 // Outputs[1] { @264F stack[-7] = stack[-1] } // Block ends with unconditional jump to stack[-7] 2657 5B JUMPDEST 2658 7F PUSH32 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 2679 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 268E 16 AND 268F 84 DUP5 2690 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 26A5 16 AND 26A6 14 EQ 26A7 80 DUP1 26A8 15 ISZERO 26A9 61 PUSH2 0x26b2 26AC 57 *JUMPI 26AD 50 POP 26AE 80 DUP1 26AF 47 SELFBALANCE 26B0 10 LT 26B1 15 ISZERO 26B2 5B JUMPDEST 26B3 15 ISZERO 26B4 61 PUSH2 0x27fb 26B7 57 *JUMPI 26B8 7F PUSH32 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 26D9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 26EE 16 AND 26EF 63 PUSH4 0xd0e30db0 26F4 82 DUP3 26F5 60 PUSH1 0x40 26F7 51 MLOAD 26F8 82 DUP3 26F9 63 PUSH4 0xffffffff 26FE 16 AND 26FF 60 PUSH1 0xe0 2701 1B SHL 2702 81 DUP2 2703 52 MSTORE 2704 60 PUSH1 0x04 2706 01 ADD 2707 60 PUSH1 0x00 2709 60 PUSH1 0x40 270B 51 MLOAD 270C 80 DUP1 270D 83 DUP4 270E 03 SUB 270F 81 DUP2 2710 85 DUP6 2711 88 DUP9 2712 80 DUP1 2713 3B EXTCODESIZE 2714 15 ISZERO 2715 80 DUP1 2716 15 ISZERO 2717 61 PUSH2 0x271f 271A 57 *JUMPI 271B 60 PUSH1 0x00 271D 80 DUP1 271E FD *REVERT 271F 5B JUMPDEST 2720 50 POP 2721 5A GAS 2722 F1 CALL 2723 15 ISZERO 2724 80 DUP1 2725 15 ISZERO 2726 61 PUSH2 0x2733 2729 57 *JUMPI 272A 3D RETURNDATASIZE 272B 60 PUSH1 0x00 272D 80 DUP1 272E 3E RETURNDATACOPY 272F 3D RETURNDATASIZE 2730 60 PUSH1 0x00 2732 FD *REVERT 2733 5B JUMPDEST 2734 50 POP 2735 50 POP 2736 50 POP 2737 50 POP 2738 50 POP 2739 7F PUSH32 0x000000000000000000000000c02aaa39b223fe8d0a0e5c4f27ead9083c756cc2 275A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 276F 16 AND 2770 63 PUSH4 0xa9059cbb 2775 83 DUP4 2776 83 DUP4 2777 60 PUSH1 0x40 2779 51 MLOAD 277A 83 DUP4 277B 63 PUSH4 0xffffffff 2780 16 AND 2781 60 PUSH1 0xe0 2783 1B SHL 2784 81 DUP2 2785 52 MSTORE 2786 60 PUSH1 0x04 2788 01 ADD 2789 80 DUP1 278A 83 DUP4 278B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 27A0 16 AND 27A1 81 DUP2 27A2 52 MSTORE 27A3 60 PUSH1 0x20 27A5 01 ADD 27A6 82 DUP3 27A7 81 DUP2 27A8 52 MSTORE 27A9 60 PUSH1 0x20 27AB 01 ADD 27AC 92 SWAP3 27AD 50 POP 27AE 50 POP 27AF 50 POP 27B0 60 PUSH1 0x20 27B2 60 PUSH1 0x40 27B4 51 MLOAD 27B5 80 DUP1 27B6 83 DUP4 27B7 03 SUB 27B8 81 DUP2 27B9 60 PUSH1 0x00 27BB 87 DUP8 27BC 80 DUP1 27BD 3B EXTCODESIZE 27BE 15 ISZERO 27BF 80 DUP1 27C0 15 ISZERO 27C1 61 PUSH2 0x27c9 27C4 57 *JUMPI 27C5 60 PUSH1 0x00 27C7 80 DUP1 27C8 FD *REVERT 27C9 5B JUMPDEST 27CA 50 POP 27CB 5A GAS 27CC F1 CALL 27CD 15 ISZERO 27CE 80 DUP1 27CF 15 ISZERO 27D0 61 PUSH2 0x27dd 27D3 57 *JUMPI 27D4 3D RETURNDATASIZE 27D5 60 PUSH1 0x00 27D7 80 DUP1 27D8 3E RETURNDATACOPY 27D9 3D RETURNDATASIZE 27DA 60 PUSH1 0x00 27DC FD *REVERT 27DD 5B JUMPDEST 27DE 50 POP 27DF 50 POP 27E0 50 POP 27E1 50 POP 27E2 60 PUSH1 0x40 27E4 51 MLOAD 27E5 3D RETURNDATASIZE 27E6 60 PUSH1 0x20 27E8 81 DUP2 27E9 10 LT 27EA 15 ISZERO 27EB 61 PUSH2 0x27f3 27EE 57 *JUMPI 27EF 60 PUSH1 0x00 27F1 80 DUP1 27F2 FD *REVERT 27F3 5B JUMPDEST 27F4 50 POP 27F5 61 PUSH2 0x178c 27F8 90 SWAP1 27F9 50 POP 27FA 56 *JUMP 27FB 5B JUMPDEST 27FC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2811 83 DUP4 2812 16 AND 2813 30 ADDRESS 2814 14 EQ 2815 15 ISZERO 2816 61 PUSH2 0x2829 2819 57 *JUMPI 281A 61 PUSH2 0x2824 281D 84 DUP5 281E 83 DUP4 281F 83 DUP4 2820 61 PUSH2 0x1d24 2823 56 *JUMP 2824 5B JUMPDEST 2825 61 PUSH2 0x178c 2828 56 *JUMP 2829 5B JUMPDEST 282A 61 PUSH2 0x178c 282D 84 DUP5 282E 84 DUP5 282F 84 DUP5 2830 84 DUP5 2831 61 PUSH2 0x2ee4 2834 56 *JUMP label_2835: // Incoming jump from 0x206E // Inputs[2] // { // @2838 stack[-1] // @2839 keccak256(address(stack[-1]).code) // } 2835 5B JUMPDEST 2836 60 PUSH1 0x00 2838 81 DUP2 2839 3F EXTCODEHASH 283A 7F PUSH32 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 285B 81 DUP2 285C 81 DUP2 285D 14 EQ 285E 80 DUP1 285F 15 ISZERO 2860 90 SWAP1 2861 61 PUSH2 0x2869 2864 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2836 stack[0] = 0x00 // @2839 stack[1] = keccak256(address(stack[-1]).code) // @283A stack[2] = 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 // @2860 stack[3] = !(0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 == keccak256(address(stack[-1]).code)) // } // Block ends with conditional jump to 0x2869, if 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 == keccak256(address(stack[-1]).code) label_2865: // Incoming jump from 0x2864, if not 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 == keccak256(address(stack[-1]).code) // Inputs[1] { @2866 stack[-3] } 2865 50 POP 2866 81 DUP2 2867 15 ISZERO 2868 15 ISZERO // Stack delta = +0 // Outputs[1] { @2868 stack[-1] = !!stack[-3] } // Block continues label_2869: // Incoming return from call to 0x3222 at 0x346E // Incoming jump from 0x2864, if 0xc5d2460186f7233c927e7db2dcc703c0e500b653ca82273b7bfad8045d85a470 == keccak256(address(stack[-1]).code) // Incoming jump from 0x2868 // Inputs[3] // { // @286A stack[-1] // @286A stack[-6] // @286B stack[-5] // } 2869 5B JUMPDEST 286A 94 SWAP5 286B 93 SWAP4 286C 50 POP 286D 50 POP 286E 50 POP 286F 50 POP 2870 56 *JUMP // Stack delta = -5 // Outputs[1] { @286A stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] 2871 5B JUMPDEST 2872 80 DUP1 2873 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2888 16 AND 2889 82 DUP3 288A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 289F 16 AND 28A0 14 EQ 28A1 15 ISZERO 28A2 61 PUSH2 0x28d7 28A5 57 *JUMPI 28A6 60 PUSH1 0x40 28A8 51 MLOAD 28A9 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 28CA 81 DUP2 28CB 52 MSTORE 28CC 60 PUSH1 0x04 28CE 01 ADD 28CF 61 PUSH2 0x087a 28D2 90 SWAP1 28D3 61 PUSH2 0x3b0b 28D6 56 *JUMP 28D7 5B JUMPDEST 28D8 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 28ED 82 DUP3 28EE 16 AND 28EF 60 PUSH1 0x00 28F1 90 SWAP1 28F2 81 DUP2 28F3 52 MSTORE 28F4 60 PUSH1 0x01 28F6 60 PUSH1 0x20 28F8 52 MSTORE 28F9 60 PUSH1 0x40 28FB 90 SWAP1 28FC 20 SHA3 28FD 54 SLOAD 28FE 60 PUSH1 0xff 2900 16 AND 2901 61 PUSH2 0x2936 2904 57 *JUMPI 2905 60 PUSH1 0x40 2907 51 MLOAD 2908 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2929 81 DUP2 292A 52 MSTORE 292B 60 PUSH1 0x04 292D 01 ADD 292E 61 PUSH2 0x087a 2931 90 SWAP1 2932 61 PUSH2 0x3c1e 2935 56 *JUMP 2936 5B JUMPDEST 2937 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 294C 81 DUP2 294D 16 AND 294E 60 PUSH1 0x00 2950 90 SWAP1 2951 81 DUP2 2952 52 MSTORE 2953 60 PUSH1 0x01 2955 60 PUSH1 0x20 2957 52 MSTORE 2958 60 PUSH1 0x40 295A 90 SWAP1 295B 20 SHA3 295C 54 SLOAD 295D 60 PUSH1 0xff 295F 16 AND 2960 61 PUSH2 0x05a4 2963 57 *JUMPI 2964 60 PUSH1 0x40 2966 51 MLOAD 2967 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2988 81 DUP2 2989 52 MSTORE 298A 60 PUSH1 0x04 298C 01 ADD 298D 61 PUSH2 0x087a 2990 90 SWAP1 2991 61 PUSH2 0x3c55 2994 56 *JUMP 2995 5B JUMPDEST 2996 60 PUSH1 0x00 2998 80 DUP1 2999 61 PUSH2 0x29cc 299C 7F PUSH32 0x000000000000000000000000e592427a0aece92de3edee1f18e0157c05861564 29BD 61 PUSH2 0x29c7 29C0 87 DUP8 29C1 87 DUP8 29C2 87 DUP8 29C3 61 PUSH2 0x2e37 29C6 56 *JUMP 29C7 5B JUMPDEST 29C8 61 PUSH2 0x30c1 29CB 56 *JUMP 29CC 5B JUMPDEST 29CD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 29E2 81 DUP2 29E3 16 AND 29E4 60 PUSH1 0x00 29E6 90 SWAP1 29E7 81 DUP2 29E8 52 MSTORE 29E9 60 PUSH1 0x03 29EB 60 PUSH1 0x20 29ED 52 MSTORE 29EE 60 PUSH1 0x40 29F0 90 SWAP1 29F1 20 SHA3 29F2 54 SLOAD 29F3 90 SWAP1 29F4 91 SWAP2 29F5 50 POP 29F6 60 PUSH1 0xff 29F8 16 AND 29F9 61 PUSH2 0x2869 29FC 57 *JUMPI 29FD 60 PUSH1 0x40 29FF 51 MLOAD 2A00 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2A21 81 DUP2 2A22 52 MSTORE 2A23 60 PUSH1 0x04 2A25 01 ADD 2A26 61 PUSH2 0x087a 2A29 90 SWAP1 2A2A 61 PUSH2 0x3b79 2A2D 56 *JUMP 2A2E 5B JUMPDEST 2A2F 60 PUSH1 0x00 2A31 7F PUSH32 0x8000000000000000000000000000000000000000000000000000000000000000 2A52 82 DUP3 2A53 10 LT 2A54 61 PUSH2 0x2a5c 2A57 57 *JUMPI 2A58 60 PUSH1 0x00 2A5A 80 DUP1 2A5B FD *REVERT 2A5C 5B JUMPDEST 2A5D 50 POP 2A5E 90 SWAP1 2A5F 56 *JUMP label_2A60: // Incoming call from 0x23FE, returns to 0x23E0 // Incoming call from 0x262E, returns to 0x262F // Incoming call from 0x2614, returns to 0x2615 // Inputs[1] { @2A63 stack[-1] } 2A60 5B JUMPDEST 2A61 60 PUSH1 0x00 2A63 81 DUP2 2A64 82 DUP3 2A65 60 PUSH1 0x14 2A67 01 ADD 2A68 10 LT 2A69 15 ISZERO 2A6A 61 PUSH2 0x2ad4 2A6D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2A61 stack[0] = 0x00 } // Block ends with conditional jump to 0x2ad4, if !(0x14 + stack[-1] < stack[-1]) label_2A6E: // Incoming jump from 0x2A6D, if not !(0x14 + stack[-1] < stack[-1]) // Inputs[3] // { // @2A71 memory[0x40:0x60] // @2ACA memory[0x40:0x60] // @2AD3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2A6E 60 PUSH1 0x40 2A70 80 DUP1 2A71 51 MLOAD 2A72 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2A93 81 DUP2 2A94 52 MSTORE 2A95 60 PUSH1 0x20 2A97 60 PUSH1 0x04 2A99 82 DUP3 2A9A 01 ADD 2A9B 52 MSTORE 2A9C 60 PUSH1 0x12 2A9E 60 PUSH1 0x24 2AA0 82 DUP3 2AA1 01 ADD 2AA2 52 MSTORE 2AA3 7F PUSH32 0x746f416464726573735f6f766572666c6f770000000000000000000000000000 2AC4 60 PUSH1 0x44 2AC6 82 DUP3 2AC7 01 ADD 2AC8 52 MSTORE 2AC9 90 SWAP1 2ACA 51 MLOAD 2ACB 90 SWAP1 2ACC 81 DUP2 2ACD 90 SWAP1 2ACE 03 SUB 2ACF 60 PUSH1 0x64 2AD1 01 ADD 2AD2 90 SWAP1 2AD3 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2A94 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2A9B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2AA2 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x12 // @2AC8 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x746f416464726573735f6f766572666c6f770000000000000000000000000000 // @2AD3 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2AD4: // Incoming jump from 0x2A6D, if !(0x14 + stack[-1] < stack[-1]) // Inputs[3] // { // @2AD5 stack[-2] // @2AD9 stack[-3] // @2ADA memory[stack[-3]:stack[-3] + 0x20] // } 2AD4 5B JUMPDEST 2AD5 81 DUP2 2AD6 60 PUSH1 0x14 2AD8 01 ADD 2AD9 83 DUP4 2ADA 51 MLOAD 2ADB 10 LT 2ADC 15 ISZERO 2ADD 61 PUSH2 0x2b47 2AE0 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2b47, if !(memory[stack[-3]:stack[-3] + 0x20] < 0x14 + stack[-2]) label_2AE1: // Incoming jump from 0x2AE0, if not !(memory[stack[-3]:stack[-3] + 0x20] < 0x14 + stack[-2]) // Inputs[3] // { // @2AE4 memory[0x40:0x60] // @2B3D memory[0x40:0x60] // @2B46 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2AE1 60 PUSH1 0x40 2AE3 80 DUP1 2AE4 51 MLOAD 2AE5 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2B06 81 DUP2 2B07 52 MSTORE 2B08 60 PUSH1 0x20 2B0A 60 PUSH1 0x04 2B0C 82 DUP3 2B0D 01 ADD 2B0E 52 MSTORE 2B0F 60 PUSH1 0x15 2B11 60 PUSH1 0x24 2B13 82 DUP3 2B14 01 ADD 2B15 52 MSTORE 2B16 7F PUSH32 0x746f416464726573735f6f75744f66426f756e64730000000000000000000000 2B37 60 PUSH1 0x44 2B39 82 DUP3 2B3A 01 ADD 2B3B 52 MSTORE 2B3C 90 SWAP1 2B3D 51 MLOAD 2B3E 90 SWAP1 2B3F 81 DUP2 2B40 90 SWAP1 2B41 03 SUB 2B42 60 PUSH1 0x64 2B44 01 ADD 2B45 90 SWAP1 2B46 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2B07 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2B0E memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2B15 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x15 // @2B3B memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x746f416464726573735f6f75744f66426f756e64730000000000000000000000 // @2B46 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2B47: // Incoming jump from 0x2AE0, if !(memory[stack[-3]:stack[-3] + 0x20] < 0x14 + stack[-2]) // Inputs[4] // { // @2B49 stack[-2] // @2B49 stack[-3] // @2B4D memory[0x20 + stack[-2] + stack[-3]:0x20 + stack[-2] + stack[-3] + 0x20] // @2B5E stack[-4] // } 2B47 5B JUMPDEST 2B48 50 POP 2B49 01 ADD 2B4A 60 PUSH1 0x20 2B4C 01 ADD 2B4D 51 MLOAD 2B4E 6C PUSH13 0x01000000000000000000000000 2B5C 90 SWAP1 2B5D 04 DIV 2B5E 90 SWAP1 2B5F 56 *JUMP // Stack delta = -3 // Outputs[1] { @2B5E stack[-4] = memory[0x20 + stack[-2] + stack[-3]:0x20 + stack[-2] + stack[-3] + 0x20] / 0x01000000000000000000000000 } // Block ends with unconditional jump to stack[-4] 2B60 5B JUMPDEST 2B61 60 PUSH1 0x60 2B63 81 DUP2 2B64 82 DUP3 2B65 60 PUSH1 0x1f 2B67 01 ADD 2B68 10 LT 2B69 15 ISZERO 2B6A 61 PUSH2 0x2bd4 2B6D 57 *JUMPI 2B6E 60 PUSH1 0x40 2B70 80 DUP1 2B71 51 MLOAD 2B72 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2B93 81 DUP2 2B94 52 MSTORE 2B95 60 PUSH1 0x20 2B97 60 PUSH1 0x04 2B99 82 DUP3 2B9A 01 ADD 2B9B 52 MSTORE 2B9C 60 PUSH1 0x0e 2B9E 60 PUSH1 0x24 2BA0 82 DUP3 2BA1 01 ADD 2BA2 52 MSTORE 2BA3 7F PUSH32 0x736c6963655f6f766572666c6f77000000000000000000000000000000000000 2BC4 60 PUSH1 0x44 2BC6 82 DUP3 2BC7 01 ADD 2BC8 52 MSTORE 2BC9 90 SWAP1 2BCA 51 MLOAD 2BCB 90 SWAP1 2BCC 81 DUP2 2BCD 90 SWAP1 2BCE 03 SUB 2BCF 60 PUSH1 0x64 2BD1 01 ADD 2BD2 90 SWAP1 2BD3 FD *REVERT 2BD4 5B JUMPDEST 2BD5 82 DUP3 2BD6 82 DUP3 2BD7 84 DUP5 2BD8 01 ADD 2BD9 10 LT 2BDA 15 ISZERO 2BDB 61 PUSH2 0x2c45 2BDE 57 *JUMPI 2BDF 60 PUSH1 0x40 2BE1 80 DUP1 2BE2 51 MLOAD 2BE3 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2C04 81 DUP2 2C05 52 MSTORE 2C06 60 PUSH1 0x20 2C08 60 PUSH1 0x04 2C0A 82 DUP3 2C0B 01 ADD 2C0C 52 MSTORE 2C0D 60 PUSH1 0x0e 2C0F 60 PUSH1 0x24 2C11 82 DUP3 2C12 01 ADD 2C13 52 MSTORE 2C14 7F PUSH32 0x736c6963655f6f766572666c6f77000000000000000000000000000000000000 2C35 60 PUSH1 0x44 2C37 82 DUP3 2C38 01 ADD 2C39 52 MSTORE 2C3A 90 SWAP1 2C3B 51 MLOAD 2C3C 90 SWAP1 2C3D 81 DUP2 2C3E 90 SWAP1 2C3F 03 SUB 2C40 60 PUSH1 0x64 2C42 01 ADD 2C43 90 SWAP1 2C44 FD *REVERT 2C45 5B JUMPDEST 2C46 81 DUP2 2C47 83 DUP4 2C48 01 ADD 2C49 84 DUP5 2C4A 51 MLOAD 2C4B 10 LT 2C4C 15 ISZERO 2C4D 61 PUSH2 0x2cb7 2C50 57 *JUMPI 2C51 60 PUSH1 0x40 2C53 80 DUP1 2C54 51 MLOAD 2C55 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2C76 81 DUP2 2C77 52 MSTORE 2C78 60 PUSH1 0x20 2C7A 60 PUSH1 0x04 2C7C 82 DUP3 2C7D 01 ADD 2C7E 52 MSTORE 2C7F 60 PUSH1 0x11 2C81 60 PUSH1 0x24 2C83 82 DUP3 2C84 01 ADD 2C85 52 MSTORE 2C86 7F PUSH32 0x736c6963655f6f75744f66426f756e6473000000000000000000000000000000 2CA7 60 PUSH1 0x44 2CA9 82 DUP3 2CAA 01 ADD 2CAB 52 MSTORE 2CAC 90 SWAP1 2CAD 51 MLOAD 2CAE 90 SWAP1 2CAF 81 DUP2 2CB0 90 SWAP1 2CB1 03 SUB 2CB2 60 PUSH1 0x64 2CB4 01 ADD 2CB5 90 SWAP1 2CB6 FD *REVERT 2CB7 5B JUMPDEST 2CB8 60 PUSH1 0x60 2CBA 82 DUP3 2CBB 15 ISZERO 2CBC 80 DUP1 2CBD 15 ISZERO 2CBE 61 PUSH2 0x2cd6 2CC1 57 *JUMPI 2CC2 60 PUSH1 0x40 2CC4 51 MLOAD 2CC5 91 SWAP2 2CC6 50 POP 2CC7 60 PUSH1 0x00 2CC9 82 DUP3 2CCA 52 MSTORE 2CCB 60 PUSH1 0x20 2CCD 82 DUP3 2CCE 01 ADD 2CCF 60 PUSH1 0x40 2CD1 52 MSTORE 2CD2 61 PUSH2 0x2d3e 2CD5 56 *JUMP 2CD6 5B JUMPDEST 2CD7 60 PUSH1 0x40 2CD9 51 MLOAD 2CDA 91 SWAP2 2CDB 50 POP 2CDC 60 PUSH1 0x1f 2CDE 84 DUP5 2CDF 16 AND 2CE0 80 DUP1 2CE1 15 ISZERO 2CE2 60 PUSH1 0x20 2CE4 02 MUL 2CE5 81 DUP2 2CE6 84 DUP5 2CE7 01 ADD 2CE8 01 ADD 2CE9 85 DUP6 2CEA 81 DUP2 2CEB 01 ADD 2CEC 87 DUP8 2CED 83 DUP4 2CEE 15 ISZERO 2CEF 60 PUSH1 0x20 2CF1 02 MUL 2CF2 84 DUP5 2CF3 8B DUP12 2CF4 01 ADD 2CF5 01 ADD 2CF6 01 ADD 2CF7 5B JUMPDEST 2CF8 81 DUP2 2CF9 83 DUP4 2CFA 10 LT 2CFB 15 ISZERO 2CFC 61 PUSH2 0x2d0f 2CFF 57 *JUMPI 2D00 80 DUP1 2D01 51 MLOAD 2D02 83 DUP4 2D03 52 MSTORE 2D04 60 PUSH1 0x20 2D06 92 SWAP3 2D07 83 DUP4 2D08 01 ADD 2D09 92 SWAP3 2D0A 01 ADD 2D0B 61 PUSH2 0x2cf7 2D0E 56 *JUMP 2D0F 5B JUMPDEST 2D10 50 POP 2D11 50 POP 2D12 85 DUP6 2D13 84 DUP5 2D14 52 MSTORE 2D15 60 PUSH1 0x1f 2D17 01 ADD 2D18 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 2D39 16 AND 2D3A 60 PUSH1 0x40 2D3C 52 MSTORE 2D3D 50 POP 2D3E 5B JUMPDEST 2D3F 50 POP 2D40 94 SWAP5 2D41 93 SWAP4 2D42 50 POP 2D43 50 POP 2D44 50 POP 2D45 50 POP 2D46 56 *JUMP label_2D47: // Incoming call from 0x2621, returns to 0x2622 // Inputs[1] { @2D4A stack[-1] } 2D47 5B JUMPDEST 2D48 60 PUSH1 0x00 2D4A 81 DUP2 2D4B 82 DUP3 2D4C 60 PUSH1 0x03 2D4E 01 ADD 2D4F 10 LT 2D50 15 ISZERO 2D51 61 PUSH2 0x2dbb 2D54 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2D48 stack[0] = 0x00 } // Block ends with conditional jump to 0x2dbb, if !(0x03 + stack[-1] < stack[-1]) label_2D55: // Incoming jump from 0x2D54, if not !(0x03 + stack[-1] < stack[-1]) // Inputs[3] // { // @2D58 memory[0x40:0x60] // @2DB1 memory[0x40:0x60] // @2DBA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2D55 60 PUSH1 0x40 2D57 80 DUP1 2D58 51 MLOAD 2D59 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2D7A 81 DUP2 2D7B 52 MSTORE 2D7C 60 PUSH1 0x20 2D7E 60 PUSH1 0x04 2D80 82 DUP3 2D81 01 ADD 2D82 52 MSTORE 2D83 60 PUSH1 0x11 2D85 60 PUSH1 0x24 2D87 82 DUP3 2D88 01 ADD 2D89 52 MSTORE 2D8A 7F PUSH32 0x746f55696e7432345f6f766572666c6f77000000000000000000000000000000 2DAB 60 PUSH1 0x44 2DAD 82 DUP3 2DAE 01 ADD 2DAF 52 MSTORE 2DB0 90 SWAP1 2DB1 51 MLOAD 2DB2 90 SWAP1 2DB3 81 DUP2 2DB4 90 SWAP1 2DB5 03 SUB 2DB6 60 PUSH1 0x64 2DB8 01 ADD 2DB9 90 SWAP1 2DBA FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2D7B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2D82 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2D89 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x11 // @2DAF memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x746f55696e7432345f6f766572666c6f77000000000000000000000000000000 // @2DBA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2DBB: // Incoming jump from 0x2D54, if !(0x03 + stack[-1] < stack[-1]) // Inputs[3] // { // @2DBC stack[-2] // @2DC0 stack[-3] // @2DC1 memory[stack[-3]:stack[-3] + 0x20] // } 2DBB 5B JUMPDEST 2DBC 81 DUP2 2DBD 60 PUSH1 0x03 2DBF 01 ADD 2DC0 83 DUP4 2DC1 51 MLOAD 2DC2 10 LT 2DC3 15 ISZERO 2DC4 61 PUSH2 0x2e2e 2DC7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2e2e, if !(memory[stack[-3]:stack[-3] + 0x20] < 0x03 + stack[-2]) label_2DC8: // Incoming jump from 0x2DC7, if not !(memory[stack[-3]:stack[-3] + 0x20] < 0x03 + stack[-2]) // Inputs[3] // { // @2DCB memory[0x40:0x60] // @2E24 memory[0x40:0x60] // @2E2D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])] // } 2DC8 60 PUSH1 0x40 2DCA 80 DUP1 2DCB 51 MLOAD 2DCC 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2DED 81 DUP2 2DEE 52 MSTORE 2DEF 60 PUSH1 0x20 2DF1 60 PUSH1 0x04 2DF3 82 DUP3 2DF4 01 ADD 2DF5 52 MSTORE 2DF6 60 PUSH1 0x14 2DF8 60 PUSH1 0x24 2DFA 82 DUP3 2DFB 01 ADD 2DFC 52 MSTORE 2DFD 7F PUSH32 0x746f55696e7432345f6f75744f66426f756e6473000000000000000000000000 2E1E 60 PUSH1 0x44 2E20 82 DUP3 2E21 01 ADD 2E22 52 MSTORE 2E23 90 SWAP1 2E24 51 MLOAD 2E25 90 SWAP1 2E26 81 DUP2 2E27 90 SWAP1 2E28 03 SUB 2E29 60 PUSH1 0x64 2E2B 01 ADD 2E2C 90 SWAP1 2E2D FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2DEE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2DF5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @2DFC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x14 // @2E22 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x746f55696e7432345f6f75744f66426f756e6473000000000000000000000000 // @2E2D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x64 + (memory[0x40:0x60] - memory[0x40:0x60])]); // } // Block terminates label_2E2E: // Incoming jump from 0x2DC7, if !(memory[stack[-3]:stack[-3] + 0x20] < 0x03 + stack[-2]) // Inputs[4] // { // @2E30 stack[-3] // @2E30 stack[-2] // @2E34 memory[0x03 + stack[-2] + stack[-3]:0x03 + stack[-2] + stack[-3] + 0x20] // @2E35 stack[-4] // } 2E2E 5B JUMPDEST 2E2F 50 POP 2E30 01 ADD 2E31 60 PUSH1 0x03 2E33 01 ADD 2E34 51 MLOAD 2E35 90 SWAP1 2E36 56 *JUMP // Stack delta = -3 // Outputs[1] { @2E35 stack[-4] = memory[0x03 + stack[-2] + stack[-3]:0x03 + stack[-2] + stack[-3] + 0x20] } // Block ends with unconditional jump to stack[-4] label_2E37: // Incoming call from 0x2648, returns to 0x2649 2E37 5B JUMPDEST 2E38 61 PUSH2 0x2e3f 2E3B 61 PUSH2 0x31f7 2E3E 56 *JUMP // Stack delta = +1 // Outputs[1] { @2E38 stack[0] = 0x2e3f } // Block ends with call to 0x31f7, returns to 0x2E3F label_2E3F: // Incoming return from call to 0x31F7 at 0x2E3E // Inputs[2] // { // @2E40 stack[-3] // @2E57 stack[-4] // } 2E3F 5B JUMPDEST 2E40 82 DUP3 2E41 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2E56 16 AND 2E57 84 DUP5 2E58 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2E6D 16 AND 2E6E 11 GT 2E6F 15 ISZERO 2E70 61 PUSH2 0x2e77 2E73 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2e77, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] > 0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) label_2E74: // Incoming jump from 0x2E73, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] > 0xffffffffffffffffffffffffffffffffffffffff & stack[-3]) // Inputs[6] // { // @2E74 stack[-1] // @2E74 stack[-3] // @2E75 stack[-4] // @2E7C memory[0x40:0x60] // @2EAA stack[-2] // @2EB2 stack[-5] // } 2E74 91 SWAP2 2E75 92 SWAP3 2E76 91 SWAP2 2E77 5B JUMPDEST 2E78 50 POP 2E79 60 PUSH1 0x40 2E7B 80 DUP1 2E7C 51 MLOAD 2E7D 60 PUSH1 0x60 2E7F 81 DUP2 2E80 01 ADD 2E81 82 DUP3 2E82 52 MSTORE 2E83 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2E98 94 SWAP5 2E99 85 DUP6 2E9A 16 AND 2E9B 81 DUP2 2E9C 52 MSTORE 2E9D 92 SWAP3 2E9E 90 SWAP1 2E9F 93 SWAP4 2EA0 16 AND 2EA1 60 PUSH1 0x20 2EA3 83 DUP4 2EA4 01 ADD 2EA5 52 MSTORE 2EA6 62 PUSH3 0xffffff 2EAA 16 AND 2EAB 91 SWAP2 2EAC 81 DUP2 2EAD 01 ADD 2EAE 91 SWAP2 2EAF 90 SWAP1 2EB0 91 SWAP2 2EB1 52 MSTORE 2EB2 90 SWAP1 2EB3 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @2E82 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @2E9C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @2EA5 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-4] // @2EB1 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0xffffff & stack[-2] // @2EB2 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-5] label_2EB4: // Incoming jump from 0x264D // Inputs[2] // { // @2EBA stack[-2] // @2EBB stack[-1] // } 2EB4 5B JUMPDEST 2EB5 60 PUSH1 0x00 2EB7 61 PUSH2 0x2ec0 2EBA 83 DUP4 2EBB 83 DUP4 2EBC 61 PUSH2 0x30c1 2EBF 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2EB5 stack[0] = 0x00 // @2EB7 stack[1] = 0x2ec0 // @2EBA stack[2] = stack[-2] // @2EBB stack[3] = stack[-1] // } // Block ends with call to 0x30c1, returns to 0x2EC0 label_2EC0: // Incoming return from call to 0x30C1 at 0x2EBF // Inputs[3] // { // @2EC1 stack[-1] // @2EC1 stack[-2] // @2EC3 msg.sender // } 2EC0 5B JUMPDEST 2EC1 90 SWAP1 2EC2 50 POP 2EC3 33 CALLER 2EC4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2ED9 82 DUP3 2EDA 16 AND 2EDB 14 EQ 2EDC 61 PUSH2 0x23e0 2EDF 57 *JUMPI // Stack delta = -1 // Outputs[1] { @2EC1 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x23e0, if stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff == msg.sender label_2EE0: // Incoming jump from 0x2EDF, if not stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff == msg.sender // Inputs[1] { @2EE3 memory[0x00:0x00] } 2EE0 60 PUSH1 0x00 2EE2 80 DUP1 2EE3 FD *REVERT // Stack delta = +0 // Outputs[1] { @2EE3 revert(memory[0x00:0x00]); } // Block terminates 2EE4 5B JUMPDEST 2EE5 60 PUSH1 0x40 2EE7 80 DUP1 2EE8 51 MLOAD 2EE9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2EFE 85 DUP6 2EFF 81 DUP2 2F00 16 AND 2F01 60 PUSH1 0x24 2F03 83 DUP4 2F04 01 ADD 2F05 52 MSTORE 2F06 84 DUP5 2F07 81 DUP2 2F08 16 AND 2F09 60 PUSH1 0x44 2F0B 83 DUP4 2F0C 01 ADD 2F0D 52 MSTORE 2F0E 60 PUSH1 0x64 2F10 80 DUP1 2F11 83 DUP4 2F12 01 ADD 2F13 85 DUP6 2F14 90 SWAP1 2F15 52 MSTORE 2F16 83 DUP4 2F17 51 MLOAD 2F18 80 DUP1 2F19 84 DUP5 2F1A 03 SUB 2F1B 90 SWAP1 2F1C 91 SWAP2 2F1D 01 ADD 2F1E 81 DUP2 2F1F 52 MSTORE 2F20 60 PUSH1 0x84 2F22 90 SWAP1 2F23 92 SWAP3 2F24 01 ADD 2F25 83 DUP4 2F26 52 MSTORE 2F27 60 PUSH1 0x20 2F29 82 DUP3 2F2A 01 ADD 2F2B 80 DUP1 2F2C 51 MLOAD 2F2D 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 2F4A 16 AND 2F4B 7F PUSH32 0x23b872dd00000000000000000000000000000000000000000000000000000000 2F6C 17 OR 2F6D 81 DUP2 2F6E 52 MSTORE 2F6F 92 SWAP3 2F70 51 MLOAD 2F71 82 DUP3 2F72 51 MLOAD 2F73 60 PUSH1 0x00 2F75 94 SWAP5 2F76 85 DUP6 2F77 94 SWAP5 2F78 93 SWAP4 2F79 8A DUP11 2F7A 16 AND 2F7B 93 SWAP4 2F7C 92 SWAP3 2F7D 91 SWAP2 2F7E 82 DUP3 2F7F 91 SWAP2 2F80 90 SWAP1 2F81 80 DUP1 2F82 83 DUP4 2F83 83 DUP4 2F84 5B JUMPDEST 2F85 60 PUSH1 0x20 2F87 83 DUP4 2F88 10 LT 2F89 61 PUSH2 0x2fc1 2F8C 57 *JUMPI 2F8D 80 DUP1 2F8E 51 MLOAD 2F8F 82 DUP3 2F90 52 MSTORE 2F91 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 2FB2 90 SWAP1 2FB3 92 SWAP3 2FB4 01 ADD 2FB5 91 SWAP2 2FB6 60 PUSH1 0x20 2FB8 91 SWAP2 2FB9 82 DUP3 2FBA 01 ADD 2FBB 91 SWAP2 2FBC 01 ADD 2FBD 61 PUSH2 0x2f84 2FC0 56 *JUMP 2FC1 5B JUMPDEST 2FC2 60 PUSH1 0x01 2FC4 83 DUP4 2FC5 60 PUSH1 0x20 2FC7 03 SUB 2FC8 61 PUSH2 0x0100 2FCB 0A EXP 2FCC 03 SUB 2FCD 80 DUP1 2FCE 19 NOT 2FCF 82 DUP3 2FD0 51 MLOAD 2FD1 16 AND 2FD2 81 DUP2 2FD3 84 DUP5 2FD4 51 MLOAD 2FD5 16 AND 2FD6 80 DUP1 2FD7 82 DUP3 2FD8 17 OR 2FD9 85 DUP6 2FDA 52 MSTORE 2FDB 50 POP 2FDC 50 POP 2FDD 50 POP 2FDE 50 POP 2FDF 50 POP 2FE0 50 POP 2FE1 90 SWAP1 2FE2 50 POP 2FE3 01 ADD 2FE4 91 SWAP2 2FE5 50 POP 2FE6 50 POP 2FE7 60 PUSH1 0x00 2FE9 60 PUSH1 0x40 2FEB 51 MLOAD 2FEC 80 DUP1 2FED 83 DUP4 2FEE 03 SUB 2FEF 81 DUP2 2FF0 60 PUSH1 0x00 2FF2 86 DUP7 2FF3 5A GAS 2FF4 F1 CALL 2FF5 91 SWAP2 2FF6 50 POP 2FF7 50 POP 2FF8 3D RETURNDATASIZE 2FF9 80 DUP1 2FFA 60 PUSH1 0x00 2FFC 81 DUP2 2FFD 14 EQ 2FFE 61 PUSH2 0x3023 3001 57 *JUMPI 3002 60 PUSH1 0x40 3004 51 MLOAD 3005 91 SWAP2 3006 50 POP 3007 60 PUSH1 0x1f 3009 19 NOT 300A 60 PUSH1 0x3f 300C 3D RETURNDATASIZE 300D 01 ADD 300E 16 AND 300F 82 DUP3 3010 01 ADD 3011 60 PUSH1 0x40 3013 52 MSTORE 3014 3D RETURNDATASIZE 3015 82 DUP3 3016 52 MSTORE 3017 3D RETURNDATASIZE 3018 60 PUSH1 0x00 301A 60 PUSH1 0x20 301C 84 DUP5 301D 01 ADD 301E 3E RETURNDATACOPY 301F 61 PUSH2 0x3028 3022 56 *JUMP 3023 5B JUMPDEST 3024 60 PUSH1 0x60 3026 91 SWAP2 3027 50 POP 3028 5B JUMPDEST 3029 50 POP 302A 91 SWAP2 302B 50 POP 302C 91 SWAP2 302D 50 POP 302E 81 DUP2 302F 80 DUP1 3030 15 ISZERO 3031 61 PUSH2 0x3056 3034 57 *JUMPI 3035 50 POP 3036 80 DUP1 3037 51 MLOAD 3038 15 ISZERO 3039 80 DUP1 303A 61 PUSH2 0x3056 303D 57 *JUMPI 303E 50 POP 303F 80 DUP1 3040 80 DUP1 3041 60 PUSH1 0x20 3043 01 ADD 3044 90 SWAP1 3045 51 MLOAD 3046 60 PUSH1 0x20 3048 81 DUP2 3049 10 LT 304A 15 ISZERO 304B 61 PUSH2 0x3053 304E 57 *JUMPI 304F 60 PUSH1 0x00 3051 80 DUP1 3052 FD *REVERT 3053 5B JUMPDEST 3054 50 POP 3055 51 MLOAD 3056 5B JUMPDEST 3057 61 PUSH2 0x0f8f 305A 57 *JUMPI 305B 60 PUSH1 0x40 305D 80 DUP1 305E 51 MLOAD 305F 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 3080 81 DUP2 3081 52 MSTORE 3082 60 PUSH1 0x20 3084 60 PUSH1 0x04 3086 82 DUP3 3087 01 ADD 3088 52 MSTORE 3089 60 PUSH1 0x03 308B 60 PUSH1 0x24 308D 82 DUP3 308E 01 ADD 308F 52 MSTORE 3090 7F PUSH32 0x5354460000000000000000000000000000000000000000000000000000000000 30B1 60 PUSH1 0x44 30B3 82 DUP3 30B4 01 ADD 30B5 52 MSTORE 30B6 90 SWAP1 30B7 51 MLOAD 30B8 90 SWAP1 30B9 81 DUP2 30BA 90 SWAP1 30BB 03 SUB 30BC 60 PUSH1 0x64 30BE 01 ADD 30BF 90 SWAP1 30C0 FD *REVERT label_30C1: // Incoming call from 0x2EBF, returns to 0x2EC0 // Inputs[3] // { // @30C4 stack[-1] // @30C8 memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // @30E3 memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] // } 30C1 5B JUMPDEST 30C2 60 PUSH1 0x00 30C4 81 DUP2 30C5 60 PUSH1 0x20 30C7 01 ADD 30C8 51 MLOAD 30C9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 30DE 16 AND 30DF 82 DUP3 30E0 60 PUSH1 0x00 30E2 01 ADD 30E3 51 MLOAD 30E4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 30F9 16 AND 30FA 10 LT 30FB 61 PUSH2 0x3103 30FE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @30C2 stack[0] = 0x00 } // Block ends with conditional jump to 0x3103, if 0xffffffffffffffffffffffffffffffffffffffff & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] < 0xffffffffffffffffffffffffffffffffffffffff & memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] label_30FF: // Incoming jump from 0x30FE, if not 0xffffffffffffffffffffffffffffffffffffffff & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] < 0xffffffffffffffffffffffffffffffffffffffff & memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // Inputs[1] { @3102 memory[0x00:0x00] } 30FF 60 PUSH1 0x00 3101 80 DUP1 3102 FD *REVERT // Stack delta = +0 // Outputs[1] { @3102 revert(memory[0x00:0x00]); } // Block terminates label_3103: // Incoming jump from 0x30FE, if 0xffffffffffffffffffffffffffffffffffffffff & memory[0x00 + stack[-1]:0x00 + stack[-1] + 0x20] < 0xffffffffffffffffffffffffffffffffffffffff & memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] // Inputs[13] // { // @3105 stack[-2] // @3106 memory[stack[-2]:stack[-2] + 0x20] // @310C memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] // @3112 memory[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // @3114 memory[0x40:0x60] // @3148 memory[0x40:0x60] // @3157 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @315B memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @3182 stack[-3] // @31DF memory[0x40:0x60] // @31F1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @31F4 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // @31F5 stack[-4] // } 3103 5B JUMPDEST 3104 50 POP 3105 80 DUP1 3106 51 MLOAD 3107 60 PUSH1 0x20 3109 80 DUP1 310A 83 DUP4 310B 01 ADD 310C 51 MLOAD 310D 60 PUSH1 0x40 310F 93 SWAP4 3110 84 DUP5 3111 01 ADD 3112 51 MLOAD 3113 84 DUP5 3114 51 MLOAD 3115 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 312A 94 SWAP5 312B 85 DUP6 312C 16 AND 312D 81 DUP2 312E 85 DUP6 312F 01 ADD 3130 52 MSTORE 3131 93 SWAP4 3132 90 SWAP1 3133 91 SWAP2 3134 16 AND 3135 83 DUP4 3136 85 DUP6 3137 01 ADD 3138 52 MSTORE 3139 62 PUSH3 0xffffff 313D 16 AND 313E 60 PUSH1 0x60 3140 80 DUP1 3141 84 DUP5 3142 01 ADD 3143 91 SWAP2 3144 90 SWAP1 3145 91 SWAP2 3146 52 MSTORE 3147 83 DUP4 3148 51 MLOAD 3149 80 DUP1 314A 84 DUP5 314B 03 SUB 314C 82 DUP3 314D 01 ADD 314E 81 DUP2 314F 52 MSTORE 3150 60 PUSH1 0x80 3152 84 DUP5 3153 01 ADD 3154 85 DUP6 3155 52 MSTORE 3156 80 DUP1 3157 51 MLOAD 3158 90 SWAP1 3159 83 DUP4 315A 01 ADD 315B 20 SHA3 315C 7F PUSH32 0xff00000000000000000000000000000000000000000000000000000000000000 317D 60 PUSH1 0xa0 317F 85 DUP6 3180 01 ADD 3181 52 MSTORE 3182 94 SWAP5 3183 90 SWAP1 3184 1B SHL 3185 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000 31A6 16 AND 31A7 60 PUSH1 0xa1 31A9 83 DUP4 31AA 01 ADD 31AB 52 MSTORE 31AC 60 PUSH1 0xb5 31AE 82 DUP3 31AF 01 ADD 31B0 93 SWAP4 31B1 90 SWAP1 31B2 93 SWAP4 31B3 52 MSTORE 31B4 7F PUSH32 0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54 31D5 60 PUSH1 0xd5 31D7 80 DUP1 31D8 83 DUP4 31D9 01 ADD 31DA 91 SWAP2 31DB 90 SWAP1 31DC 91 SWAP2 31DD 52 MSTORE 31DE 82 DUP3 31DF 51 MLOAD 31E0 80 DUP1 31E1 83 DUP4 31E2 03 SUB 31E3 90 SWAP1 31E4 91 SWAP2 31E5 01 ADD 31E6 81 DUP2 31E7 52 MSTORE 31E8 60 PUSH1 0xf5 31EA 90 SWAP1 31EB 91 SWAP2 31EC 01 ADD 31ED 90 SWAP1 31EE 91 SWAP2 31EF 52 MSTORE 31F0 80 DUP1 31F1 51 MLOAD 31F2 91 SWAP2 31F3 01 ADD 31F4 20 SHA3 31F5 90 SWAP1 31F6 56 *JUMP // Stack delta = -3 // Outputs[12] // { // @3130 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20] // @3138 memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffff // @3146 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = 0xffffff & memory[0x40 + stack[-2]:0x40 + stack[-2] + 0x20] // @314F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x60 + (memory[0x40:0x60] - memory[0x40:0x60]) // @3155 memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // @3181 memory[memory[0x40:0x60] + 0xa0:memory[0x40:0x60] + 0xa0 + 0x20] = 0xff00000000000000000000000000000000000000000000000000000000000000 // @31AB memory[memory[0x40:0x60] + 0xa1:memory[0x40:0x60] + 0xa1 + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000 & (stack[-3] << 0x60) // @31B3 memory[memory[0x40:0x60] + 0xb5:memory[0x40:0x60] + 0xb5 + 0x20] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // @31DD memory[memory[0x40:0x60] + 0xd5:memory[0x40:0x60] + 0xd5 + 0x20] = 0xe34f199b19b2b4f47f68442619d555527d244f78a3297ea89325f843f87b8b54 // @31E7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xd5 + (memory[0x40:0x60] - memory[0x40:0x60]) // @31EF memory[0x40:0x60] = memory[0x40:0x60] + 0xf5 // @31F5 stack[-4] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // } // Block ends with unconditional jump to stack[-4] label_31F7: // Incoming call from 0x2E3E, returns to 0x2E3F // Inputs[2] // { // @31FB memory[0x40:0x60] // @3215 stack[-1] // } 31F7 5B JUMPDEST 31F8 60 PUSH1 0x40 31FA 80 DUP1 31FB 51 MLOAD 31FC 60 PUSH1 0x60 31FE 81 DUP2 31FF 01 ADD 3200 82 DUP3 3201 52 MSTORE 3202 60 PUSH1 0x00 3204 80 DUP1 3205 82 DUP3 3206 52 MSTORE 3207 60 PUSH1 0x20 3209 82 DUP3 320A 01 ADD 320B 81 DUP2 320C 90 SWAP1 320D 52 MSTORE 320E 91 SWAP2 320F 81 DUP2 3210 01 ADD 3211 91 SWAP2 3212 90 SWAP1 3213 91 SWAP2 3214 52 MSTORE 3215 90 SWAP1 3216 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @3201 memory[0x40:0x60] = memory[0x40:0x60] + 0x60 // @3206 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // @320D memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x00 // @3214 memory[memory[0x40:0x60] + 0x40:memory[0x40:0x60] + 0x40 + 0x20] = 0x00 // @3215 stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-1] label_3217: // Incoming jump from 0x36E4 // Inputs[2] // { // @3218 stack[-1] // @3219 msg.data[stack[-1]:stack[-1] + 0x20] // } 3217 5B JUMPDEST 3218 80 DUP1 3219 35 CALLDATALOAD 321A 61 PUSH2 0x0616 321D 81 DUP2 321E 61 PUSH2 0x3e68 3221 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3219 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @321A stack[1] = 0x0616 // @321D stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x3e68, returns to 0x0616 label_3222: // Incoming call from 0x34AA, returns to 0x34AB // Incoming call from 0x346E, returns to 0x2869 // Inputs[2] // { // @3225 stack[-2] // @3228 stack[-1] // } 3222 5B JUMPDEST 3223 60 PUSH1 0x00 3225 82 DUP3 3226 60 PUSH1 0x1f 3228 83 DUP4 3229 01 ADD 322A 12 SLT 322B 61 PUSH2 0x3232 322E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3223 stack[0] = 0x00 } // Block ends with conditional jump to 0x3232, if stack[-1] + 0x1f i< stack[-2] label_322F: // Incoming jump from 0x322E, if not stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @322F stack[-1] // @3231 memory[stack[-1]:stack[-1] + stack[-1]] // } 322F 80 DUP1 3230 81 DUP2 3231 FD *REVERT // Stack delta = +0 // Outputs[1] { @3231 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_3232: // Incoming jump from 0x322E, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @3233 stack[-2] // @3234 msg.data[stack[-2]:stack[-2] + 0x20] // } 3232 5B JUMPDEST 3233 81 DUP2 3234 35 CALLDATALOAD 3235 60 PUSH1 0x20 3237 67 PUSH8 0xffffffffffffffff 3240 82 DUP3 3241 11 GT 3242 15 ISZERO 3243 61 PUSH2 0x3248 3246 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3234 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @3235 stack[1] = 0x20 // } // Block ends with conditional jump to 0x3248, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_3247: // Incoming jump from 0x3246, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) 3247 FE *ASSERT // Stack delta = +0 // Outputs[1] { @3247 assert(); } // Block terminates label_3248: // Incoming jump from 0x3246, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @3249 stack[-1] // @324A stack[-2] // } 3248 5B JUMPDEST 3249 80 DUP1 324A 82 DUP3 324B 02 MUL 324C 61 PUSH2 0x3256 324F 82 DUP3 3250 82 DUP3 3251 01 ADD 3252 61 PUSH2 0x3dd8 3255 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @324B stack[0] = stack[-2] * stack[-1] // @324C stack[1] = 0x3256 // @3251 stack[2] = stack[-2] * stack[-1] + stack[-1] // } // Block ends with call to 0x3dd8, returns to 0x3256 label_3256: // Incoming return from call to 0x3DD8 at 0x3255 // Inputs[6] // { // @3257 stack[-4] // @3258 stack[-1] // @325A stack[-3] // @325E stack[-6] // @3261 stack[-2] // @3266 stack[-7] // } 3256 5B JUMPDEST 3257 83 DUP4 3258 81 DUP2 3259 52 MSTORE 325A 82 DUP3 325B 81 DUP2 325C 01 ADD 325D 90 SWAP1 325E 86 DUP7 325F 84 DUP5 3260 01 ADD 3261 83 DUP4 3262 88 DUP9 3263 01 ADD 3264 85 DUP6 3265 01 ADD 3266 89 DUP10 3267 10 LT 3268 15 ISZERO 3269 61 PUSH2 0x3270 326C 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @3259 memory[stack[-1]:stack[-1] + 0x20] = stack[-4] // @325D stack[0] = stack[-1] // @325D stack[-1] = stack[-1] + stack[-3] // @3260 stack[1] = stack[-3] + stack[-6] // } // Block ends with conditional jump to 0x3270, if !(stack[-7] < stack[-3] + stack[-6] + stack[-2]) label_326D: // Incoming jump from 0x326C, if not !(stack[-7] < stack[-3] + stack[-6] + stack[-2]) // Inputs[2] // { // @326D stack[-7] // @326F memory[stack[-7]:stack[-7] + stack[-7]] // } 326D 86 DUP7 326E 87 DUP8 326F FD *REVERT // Stack delta = +0 // Outputs[1] { @326F revert(memory[stack[-7]:stack[-7] + stack[-7]]); } // Block terminates label_3270: // Incoming jump from 0x326C, if !(stack[-7] < stack[-3] + stack[-6] + stack[-2]) // Inputs[3] // { // @3271 stack[-7] // @3272 stack[-4] // @3275 stack[-6] // } 3270 5B JUMPDEST 3271 86 DUP7 3272 93 SWAP4 3273 50 POP 3274 5B JUMPDEST 3275 85 DUP6 3276 84 DUP5 3277 10 LT 3278 15 ISZERO 3279 61 PUSH2 0x329b 327C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @3272 stack[-4] = stack[-7] } // Block ends with conditional jump to 0x329b, if !(stack[-7] < stack[-6]) label_327D: // Incoming jump from 0x327C, if not !(stack[-4] < stack[-6]) // Incoming jump from 0x327C, if not !(stack[-7] < stack[-6]) // Inputs[2] // { // @327D stack[-1] // @327E msg.data[stack[-1]:stack[-1] + 0x20] // } 327D 80 DUP1 327E 35 CALLDATALOAD 327F 61 PUSH2 0x3287 3282 81 DUP2 3283 61 PUSH2 0x3e68 3286 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @327E stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] // @327F stack[1] = 0x3287 // @3282 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x3e68, returns to 0x3287 label_3287: // Incoming return from call to 0x3E68 at 0x3286 // Inputs[5] // { // @3288 stack[-4] // @3289 stack[-1] // @328C stack[-5] // @328D stack[-2] // @3292 stack[-6] // } 3287 5B JUMPDEST 3288 83 DUP4 3289 52 MSTORE 328A 60 PUSH1 0x01 328C 93 SWAP4 328D 90 SWAP1 328E 93 SWAP4 328F 01 ADD 3290 92 SWAP3 3291 91 SWAP2 3292 84 DUP5 3293 01 ADD 3294 91 SWAP2 3295 84 DUP5 3296 01 ADD 3297 61 PUSH2 0x3274 329A 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @3289 memory[stack[-4]:stack[-4] + 0x20] = stack[-1] // @3290 stack[-5] = 0x01 + stack[-5] // @3294 stack[-4] = stack[-6] + stack[-4] // @3296 stack[-2] = stack[-6] + stack[-2] // } // Block ends with unconditional jump to 0x3274 label_329B: // Incoming jump from 0x327C, if !(stack[-4] < stack[-6]) // Incoming jump from 0x327C, if !(stack[-7] < stack[-6]) // Inputs[3] // { // @329D stack[-10] // @329D stack[-2] // @329E stack[-9] // } 329B 5B JUMPDEST 329C 50 POP 329D 97 SWAP8 329E 96 SWAP7 329F 50 POP 32A0 50 POP 32A1 50 POP 32A2 50 POP 32A3 50 POP 32A4 50 POP 32A5 50 POP 32A6 56 *JUMP // Stack delta = -9 // Outputs[1] { @329D stack[-10] = stack[-2] } // Block ends with unconditional jump to stack[-10] label_32A7: // Incoming call from 0x36D5, returns to 0x36D6 // Incoming call from 0x37D4, returns to 0x37D5 // Inputs[2] // { // @32AA stack[-2] // @32AD stack[-1] // } 32A7 5B JUMPDEST 32A8 60 PUSH1 0x00 32AA 82 DUP3 32AB 60 PUSH1 0x1f 32AD 83 DUP4 32AE 01 ADD 32AF 12 SLT 32B0 61 PUSH2 0x32b7 32B3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @32A8 stack[0] = 0x00 } // Block ends with conditional jump to 0x32b7, if stack[-1] + 0x1f i< stack[-2] label_32B4: // Incoming jump from 0x32B3, if not stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @32B4 stack[-1] // @32B6 memory[stack[-1]:stack[-1] + stack[-1]] // } 32B4 80 DUP1 32B5 81 DUP2 32B6 FD *REVERT // Stack delta = +0 // Outputs[1] { @32B6 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_32B7: // Incoming jump from 0x32B3, if stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @32B8 stack[-2] // @32B9 msg.data[stack[-2]:stack[-2] + 0x20] // } 32B7 5B JUMPDEST 32B8 81 DUP2 32B9 35 CALLDATALOAD 32BA 61 PUSH2 0x32ca 32BD 61 PUSH2 0x32c5 32C0 82 DUP3 32C1 61 PUSH2 0x3dfc 32C4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @32B9 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @32BA stack[1] = 0x32ca // @32BD stack[2] = 0x32c5 // @32C0 stack[3] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x3dfc, returns to 0x32C5 label_32C5: // Incoming return from call to 0x3DFC at 0x3643 // Incoming return from call to 0x3DFC at 0x32C4 32C5 5B JUMPDEST 32C6 61 PUSH2 0x3dd8 32C9 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x3dd8 label_32CA: // Incoming return from call to 0x32C5 at 0x32C4 // Inputs[4] // { // @32CB stack[-2] // @32CC stack[-1] // @32CE stack[-5] // @32D2 stack[-4] // } 32CA 5B JUMPDEST 32CB 81 DUP2 32CC 81 DUP2 32CD 52 MSTORE 32CE 84 DUP5 32CF 60 PUSH1 0x20 32D1 83 DUP4 32D2 86 DUP7 32D3 01 ADD 32D4 01 ADD 32D5 11 GT 32D6 15 ISZERO 32D7 61 PUSH2 0x32de 32DA 57 *JUMPI // Stack delta = +0 // Outputs[1] { @32CD memory[stack[-1]:stack[-1] + 0x20] = stack[-2] } // Block ends with conditional jump to 0x32de, if !(stack[-4] + stack[-2] + 0x20 > stack[-5]) label_32DB: // Incoming jump from 0x32DA, if not !(stack[-4] + stack[-2] + 0x20 > stack[-5]) // Inputs[2] // { // @32DB stack[-3] // @32DD memory[stack[-3]:stack[-3] + stack[-3]] // } 32DB 82 DUP3 32DC 83 DUP4 32DD FD *REVERT // Stack delta = +0 // Outputs[1] { @32DD revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_32DE: // Incoming jump from 0x32DA, if !(stack[-4] + stack[-2] + 0x20 > stack[-5]) // Inputs[7] // { // @32DF stack[-2] // @32E2 stack[-4] // @32E6 stack[-1] // @32E8 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + stack[-2]] // @32EF stack[-3] // @32F3 stack[-6] // @32F4 stack[-5] // } 32DE 5B JUMPDEST 32DF 81 DUP2 32E0 60 PUSH1 0x20 32E2 85 DUP6 32E3 01 ADD 32E4 60 PUSH1 0x20 32E6 83 DUP4 32E7 01 ADD 32E8 37 CALLDATACOPY 32E9 90 SWAP1 32EA 81 DUP2 32EB 01 ADD 32EC 60 PUSH1 0x20 32EE 01 ADD 32EF 91 SWAP2 32F0 90 SWAP1 32F1 91 SWAP2 32F2 52 MSTORE 32F3 92 SWAP3 32F4 91 SWAP2 32F5 50 POP 32F6 50 POP 32F7 56 *JUMP // Stack delta = -5 // Outputs[3] // { // @32E8 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-2]] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + stack[-2]] // @32F2 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x20] = stack[-3] // @32F3 stack[-6] = stack[-1] // } // Block ends with unconditional jump to stack[-6] label_32F8: // Incoming call from 0x372F, returns to 0x333D // Inputs[2] // { // @32FE stack[-1] // @32FF stack[-2] // } 32F8 5B JUMPDEST 32F9 60 PUSH1 0x00 32FB 61 PUSH2 0x0100 32FE 82 DUP3 32FF 84 DUP5 3300 03 SUB 3301 12 SLT 3302 15 ISZERO 3303 61 PUSH2 0x330a 3306 57 *JUMPI // Stack delta = +1 // Outputs[1] { @32F9 stack[0] = 0x00 } // Block ends with conditional jump to 0x330a, if !(stack[-2] - stack[-1] i< 0x0100) label_3307: // Incoming jump from 0x3306, if not !(stack[-2] - stack[-1] i< 0x0100) // Inputs[2] // { // @3307 stack[-1] // @3309 memory[stack[-1]:stack[-1] + stack[-1]] // } 3307 80 DUP1 3308 81 DUP2 3309 FD *REVERT // Stack delta = +0 // Outputs[1] { @3309 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_330A: // Incoming jump from 0x3306, if !(stack[-2] - stack[-1] i< 0x0100) // Inputs[3] // { // @330C stack[-2] // @330C stack[-4] // @330D stack[-3] // } 330A 5B JUMPDEST 330B 50 POP 330C 91 SWAP2 330D 90 SWAP1 330E 50 POP 330F 56 *JUMP // Stack delta = -3 // Outputs[1] { @330C stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_3310: // Incoming call from 0x3421, returns to 0x3422 // Incoming call from 0x34D5, returns to 0x34D6 // Incoming call from 0x34B9, returns to 0x34BA // Inputs[2] // { // @3311 stack[-1] // @3312 msg.data[stack[-1]:stack[-1] + 0x20] // } 3310 5B JUMPDEST 3311 80 DUP1 3312 35 CALLDATALOAD 3313 60 PUSH1 0xff 3315 81 DUP2 3316 16 AND 3317 81 DUP2 3318 14 EQ 3319 61 PUSH2 0x0616 331C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3312 stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x0616, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & 0xff label_331D: // Incoming jump from 0x331C, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & 0xff // Inputs[1] { @3320 memory[0x00:0x00] } 331D 60 PUSH1 0x00 331F 80 DUP1 3320 FD *REVERT // Stack delta = +0 // Outputs[1] { @3320 revert(memory[0x00:0x00]); } // Block terminates label_3321: // Incoming jump from 0x035D // Incoming jump from 0x042B // Incoming jump from 0x1AA5 // Inputs[2] // { // @3326 stack[-1] // @3327 stack[-2] // } 3321 5B JUMPDEST 3322 60 PUSH1 0x00 3324 60 PUSH1 0x20 3326 82 DUP3 3327 84 DUP5 3328 03 SUB 3329 12 SLT 332A 15 ISZERO 332B 61 PUSH2 0x3332 332E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3322 stack[0] = 0x00 } // Block ends with conditional jump to 0x3332, if !(stack[-2] - stack[-1] i< 0x20) label_332F: // Incoming jump from 0x332E, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @332F stack[-1] // @3331 memory[stack[-1]:stack[-1] + stack[-1]] // } 332F 80 DUP1 3330 81 DUP2 3331 FD *REVERT // Stack delta = +0 // Outputs[1] { @3331 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_3332: // Incoming jump from 0x332E, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3333 stack[-2] // @3334 msg.data[stack[-2]:stack[-2] + 0x20] // } 3332 5B JUMPDEST 3333 81 DUP2 3334 35 CALLDATALOAD 3335 61 PUSH2 0x333d 3338 81 DUP2 3339 61 PUSH2 0x3e68 333C 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3334 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @3335 stack[1] = 0x333d // @3338 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x3e68, returns to 0x333D label_333D: // Incoming return from call to 0x3E68 at 0x333C // Incoming return from call to 0x38AB at 0x3B0A // Incoming return from call to 0x32F8 at 0x372F // Incoming jump from 0x3764, if !(stack[-4] - (stack[-3] + stack[-1]) i< 0xa0) // Inputs[3] // { // @333E stack[-5] // @333E stack[-1] // @333F stack[-4] // } 333D 5B JUMPDEST 333E 93 SWAP4 333F 92 SWAP3 3340 50 POP 3341 50 POP 3342 50 POP 3343 56 *JUMP // Stack delta = -4 // Outputs[1] { @333E stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_3344: // Incoming call from 0x0451, returns to 0x0452 // Inputs[2] // { // @334C stack[-1] // @334D stack[-2] // } 3344 5B JUMPDEST 3345 60 PUSH1 0x00 3347 80 DUP1 3348 60 PUSH1 0x00 334A 60 PUSH1 0x60 334C 84 DUP5 334D 86 DUP7 334E 03 SUB 334F 12 SLT 3350 15 ISZERO 3351 61 PUSH2 0x3358 3354 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @3345 stack[0] = 0x00 // @3347 stack[1] = 0x00 // @3348 stack[2] = 0x00 // } // Block ends with conditional jump to 0x3358, if !(stack[-2] - stack[-1] i< 0x60) label_3355: // Incoming jump from 0x3354, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @3355 stack[-2] // @3357 memory[stack[-2]:stack[-2] + stack[-2]] // } 3355 81 DUP2 3356 82 DUP3 3357 FD *REVERT // Stack delta = +0 // Outputs[1] { @3357 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_3358: // Incoming jump from 0x3354, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @3359 stack[-4] // @335A msg.data[stack[-4]:stack[-4] + 0x20] // } 3358 5B JUMPDEST 3359 83 DUP4 335A 35 CALLDATALOAD 335B 61 PUSH2 0x3363 335E 81 DUP2 335F 61 PUSH2 0x3e68 3362 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @335A stack[0] = msg.data[stack[-4]:stack[-4] + 0x20] // @335B stack[1] = 0x3363 // @335E stack[2] = msg.data[stack[-4]:stack[-4] + 0x20] // } // Block ends with call to 0x3e68, returns to 0x3363 label_3363: // Incoming return from call to 0x3E68 at 0x3362 // Inputs[6] // { // @3364 stack[-4] // @3364 stack[-1] // @3368 stack[-5] // @336A msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @336B stack[-3] // @3371 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // } 3363 5B JUMPDEST 3364 92 SWAP3 3365 50 POP 3366 60 PUSH1 0x20 3368 84 DUP5 3369 01 ADD 336A 35 CALLDATALOAD 336B 91 SWAP2 336C 50 POP 336D 60 PUSH1 0x40 336F 84 DUP5 3370 01 ADD 3371 35 CALLDATALOAD 3372 61 PUSH2 0x337a 3375 81 DUP2 3376 61 PUSH2 0x3e68 3379 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @3364 stack[-4] = stack[-1] // @336B stack[-3] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @3371 stack[-1] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @3372 stack[0] = 0x337a // @3375 stack[1] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // } // Block ends with call to 0x3e68, returns to 0x337A label_337A: // Incoming return from call to 0x3E68 at 0x3379 // Inputs[7] // { // @337B stack[-1] // @337C stack[-2] // @337F stack[-5] // @3381 stack[-6] // @3381 stack[-3] // @3383 stack[-4] // @3383 stack[-7] // } 337A 5B JUMPDEST 337B 80 DUP1 337C 91 SWAP2 337D 50 POP 337E 50 POP 337F 92 SWAP3 3380 50 POP 3381 92 SWAP3 3382 50 POP 3383 92 SWAP3 3384 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @337F stack[-5] = stack[-1] // @3381 stack[-6] = stack[-3] // @3383 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_3385: // Incoming call from 0x0464, returns to 0x0465 // Inputs[2] // { // @3390 stack[-1] // @3391 stack[-2] // } 3385 5B JUMPDEST 3386 60 PUSH1 0x00 3388 80 DUP1 3389 60 PUSH1 0x00 338B 80 DUP1 338C 60 PUSH1 0x00 338E 60 PUSH1 0xa0 3390 86 DUP7 3391 88 DUP9 3392 03 SUB 3393 12 SLT 3394 15 ISZERO 3395 61 PUSH2 0x339c 3398 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @3386 stack[0] = 0x00 // @3388 stack[1] = 0x00 // @3389 stack[2] = 0x00 // @338B stack[3] = 0x00 // @338C stack[4] = 0x00 // } // Block ends with conditional jump to 0x339c, if !(stack[-2] - stack[-1] i< 0xa0) label_3399: // Incoming jump from 0x3398, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @3399 stack[-1] // @339B memory[stack[-1]:stack[-1] + stack[-1]] // } 3399 80 DUP1 339A 81 DUP2 339B FD *REVERT // Stack delta = +0 // Outputs[1] { @339B revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_339C: // Incoming jump from 0x3398, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @339D stack[-6] // @339E msg.data[stack[-6]:stack[-6] + 0x20] // } 339C 5B JUMPDEST 339D 85 DUP6 339E 35 CALLDATALOAD 339F 61 PUSH2 0x33a7 33A2 81 DUP2 33A3 61 PUSH2 0x3e68 33A6 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @339E stack[0] = msg.data[stack[-6]:stack[-6] + 0x20] // @339F stack[1] = 0x33a7 // @33A2 stack[2] = msg.data[stack[-6]:stack[-6] + 0x20] // } // Block ends with call to 0x3e68, returns to 0x33A7 label_33A7: // Incoming return from call to 0x3E68 at 0x33A6 // Inputs[6] // { // @33A8 stack[-1] // @33A8 stack[-6] // @33AC stack[-7] // @33AE msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // @33AF stack[-5] // @33B5 msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // } 33A7 5B JUMPDEST 33A8 94 SWAP5 33A9 50 POP 33AA 60 PUSH1 0x20 33AC 86 DUP7 33AD 01 ADD 33AE 35 CALLDATALOAD 33AF 93 SWAP4 33B0 50 POP 33B1 60 PUSH1 0x40 33B3 86 DUP7 33B4 01 ADD 33B5 35 CALLDATALOAD 33B6 61 PUSH2 0x33be 33B9 81 DUP2 33BA 61 PUSH2 0x3e68 33BD 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @33A8 stack[-6] = stack[-1] // @33AF stack[-5] = msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // @33B5 stack[-1] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // @33B6 stack[0] = 0x33be // @33B9 stack[1] = msg.data[stack[-7] + 0x40:stack[-7] + 0x40 + 0x20] // } // Block ends with call to 0x3e68, returns to 0x33BE label_33BE: // Incoming return from call to 0x3E68 at 0x33BD // Inputs[6] // { // @33BF stack[-1] // @33BF stack[-4] // @33C3 stack[-7] // @33C5 msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @33C6 stack[-3] // @33CC msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] // } 33BE 5B JUMPDEST 33BF 92 SWAP3 33C0 50 POP 33C1 60 PUSH1 0x60 33C3 86 DUP7 33C4 01 ADD 33C5 35 CALLDATALOAD 33C6 91 SWAP2 33C7 50 POP 33C8 60 PUSH1 0x80 33CA 86 DUP7 33CB 01 ADD 33CC 35 CALLDATALOAD 33CD 61 PUSH2 0x33d5 33D0 81 DUP2 33D1 61 PUSH2 0x3e68 33D4 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @33BF stack[-4] = stack[-1] // @33C6 stack[-3] = msg.data[stack[-7] + 0x60:stack[-7] + 0x60 + 0x20] // @33CC stack[-1] = msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] // @33CD stack[0] = 0x33d5 // @33D0 stack[1] = msg.data[stack[-7] + 0x80:stack[-7] + 0x80 + 0x20] // } // Block ends with call to 0x3e68, returns to 0x33D5 label_33D5: // Incoming return from call to 0x3E68 at 0x33D4 // Inputs[9] // { // @33D6 stack[-1] // @33D7 stack[-2] // @33DA stack[-5] // @33DB stack[-8] // @33DD stack[-3] // @33DD stack[-6] // @33DE stack[-9] // @33DF stack[-4] // @33E0 stack[-7] // } 33D5 5B JUMPDEST 33D6 80 DUP1 33D7 91 SWAP2 33D8 50 POP 33D9 50 POP 33DA 92 SWAP3 33DB 95 SWAP6 33DC 50 POP 33DD 92 SWAP3 33DE 95 SWAP6 33DF 90 SWAP1 33E0 93 SWAP4 33E1 50 POP 33E2 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @33DA stack[-5] = stack[-1] // @33DB stack[-8] = stack[-5] // @33DD stack[-6] = stack[-3] // @33DE stack[-9] = stack[-6] // @33E0 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-9] label_33E3: // Incoming call from 0x0308, returns to 0x0309 // Incoming call from 0x03B0, returns to 0x03B1 // Incoming call from 0x049F, returns to 0x04A0 // Incoming call from 0x03F6, returns to 0x03F7 // Inputs[2] // { // @33EF stack[-1] // @33F0 stack[-2] // } 33E3 5B JUMPDEST 33E4 60 PUSH1 0x00 33E6 80 DUP1 33E7 60 PUSH1 0x00 33E9 80 DUP1 33EA 60 PUSH1 0x00 33EC 80 DUP1 33ED 60 PUSH1 0xc0 33EF 87 DUP8 33F0 89 DUP10 33F1 03 SUB 33F2 12 SLT 33F3 15 ISZERO 33F4 61 PUSH2 0x33fb 33F7 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @33E4 stack[0] = 0x00 // @33E6 stack[1] = 0x00 // @33E7 stack[2] = 0x00 // @33E9 stack[3] = 0x00 // @33EA stack[4] = 0x00 // @33EC stack[5] = 0x00 // } // Block ends with conditional jump to 0x33fb, if !(stack[-2] - stack[-1] i< 0xc0) label_33F8: // Incoming jump from 0x33F7, if not !(stack[-2] - stack[-1] i< 0xc0) // Inputs[2] // { // @33F8 stack[-1] // @33FA memory[stack[-1]:stack[-1] + stack[-1]] // } 33F8 80 DUP1 33F9 81 DUP2 33FA FD *REVERT // Stack delta = +0 // Outputs[1] { @33FA revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_33FB: // Incoming jump from 0x33F7, if !(stack[-2] - stack[-1] i< 0xc0) // Inputs[2] // { // @33FC stack[-7] // @33FD msg.data[stack[-7]:stack[-7] + 0x20] // } 33FB 5B JUMPDEST 33FC 86 DUP7 33FD 35 CALLDATALOAD 33FE 61 PUSH2 0x3406 3401 81 DUP2 3402 61 PUSH2 0x3e68 3405 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @33FD stack[0] = msg.data[stack[-7]:stack[-7] + 0x20] // @33FE stack[1] = 0x3406 // @3401 stack[2] = msg.data[stack[-7]:stack[-7] + 0x20] // } // Block ends with call to 0x3e68, returns to 0x3406 label_3406: // Incoming return from call to 0x3E68 at 0x3405 // Inputs[7] // { // @3407 stack[-7] // @3407 stack[-1] // @340B stack[-8] // @340D msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] // @340E stack[-6] // @3414 msg.data[stack[-8] + 0x40:stack[-8] + 0x40 + 0x20] // @3415 stack[-5] // } 3406 5B JUMPDEST 3407 95 SWAP6 3408 50 POP 3409 60 PUSH1 0x20 340B 87 DUP8 340C 01 ADD 340D 35 CALLDATALOAD 340E 94 SWAP5 340F 50 POP 3410 60 PUSH1 0x40 3412 87 DUP8 3413 01 ADD 3414 35 CALLDATALOAD 3415 93 SWAP4 3416 50 POP 3417 61 PUSH2 0x3422 341A 60 PUSH1 0x60 341C 88 DUP9 341D 01 ADD 341E 61 PUSH2 0x3310 3421 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @3407 stack[-7] = stack[-1] // @340E stack[-6] = msg.data[stack[-8] + 0x20:stack[-8] + 0x20 + 0x20] // @3415 stack[-5] = msg.data[stack[-8] + 0x40:stack[-8] + 0x40 + 0x20] // @3417 stack[-1] = 0x3422 // @341D stack[0] = stack[-8] + 0x60 // } // Block ends with call to 0x3310, returns to 0x3422 label_3422: // Incoming return from call to 0x3310 at 0x3421 // Inputs[12] // { // @3423 stack[-4] // @3423 stack[-1] // @3427 stack[-8] // @3429 msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] // @342A stack[-3] // @3430 msg.data[stack[-8] + 0xa0:stack[-8] + 0xa0 + 0x20] // @3431 stack[-2] // @3433 stack[-5] // @3436 stack[-6] // @3437 stack[-9] // @3439 stack[-7] // @343A stack[-10] // } 3422 5B JUMPDEST 3423 92 SWAP3 3424 50 POP 3425 60 PUSH1 0x80 3427 87 DUP8 3428 01 ADD 3429 35 CALLDATALOAD 342A 91 SWAP2 342B 50 POP 342C 60 PUSH1 0xa0 342E 87 DUP8 342F 01 ADD 3430 35 CALLDATALOAD 3431 90 SWAP1 3432 50 POP 3433 92 SWAP3 3434 95 SWAP6 3435 50 POP 3436 92 SWAP3 3437 95 SWAP6 3438 50 POP 3439 92 SWAP3 343A 95 SWAP6 343B 56 *JUMP // Stack delta = -4 // Outputs[6] // { // @3433 stack[-5] = msg.data[stack[-8] + 0xa0:stack[-8] + 0xa0 + 0x20] // @3434 stack[-8] = stack[-5] // @3436 stack[-6] = msg.data[stack[-8] + 0x80:stack[-8] + 0x80 + 0x20] // @3437 stack[-9] = stack[-6] // @3439 stack[-7] = stack[-1] // @343A stack[-10] = stack[-7] // } // Block ends with unconditional jump to stack[-10] label_343C: // Incoming call from 0x028C, returns to 0x028D // Incoming call from 0x02E2, returns to 0x02E3 // Incoming call from 0x0264, returns to 0x0265 // Inputs[2] // { // @3441 stack[-1] // @3442 stack[-2] // } 343C 5B JUMPDEST 343D 60 PUSH1 0x00 343F 60 PUSH1 0x20 3441 82 DUP3 3442 84 DUP5 3443 03 SUB 3444 12 SLT 3445 15 ISZERO 3446 61 PUSH2 0x344d 3449 57 *JUMPI // Stack delta = +1 // Outputs[1] { @343D stack[0] = 0x00 } // Block ends with conditional jump to 0x344d, if !(stack[-2] - stack[-1] i< 0x20) label_344A: // Incoming jump from 0x3449, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @344A stack[-1] // @344C memory[stack[-1]:stack[-1] + stack[-1]] // } 344A 80 DUP1 344B 81 DUP2 344C FD *REVERT // Stack delta = +0 // Outputs[1] { @344C revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_344D: // Incoming jump from 0x3449, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @344E stack[-2] // @344F msg.data[stack[-2]:stack[-2] + 0x20] // } 344D 5B JUMPDEST 344E 81 DUP2 344F 35 CALLDATALOAD 3450 67 PUSH8 0xffffffffffffffff 3459 81 DUP2 345A 11 GT 345B 15 ISZERO 345C 61 PUSH2 0x3463 345F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @344F stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x3463, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_3460: // Incoming jump from 0x345F, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @3460 stack[-2] // @3462 memory[stack[-2]:stack[-2] + stack[-2]] // } 3460 81 DUP2 3461 82 DUP3 3462 FD *REVERT // Stack delta = +0 // Outputs[1] { @3462 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_3463: // Incoming jump from 0x345F, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @3467 stack[-4] // @3468 stack[-1] // @3469 stack[-3] // } 3463 5B JUMPDEST 3464 61 PUSH2 0x2869 3467 84 DUP5 3468 82 DUP3 3469 85 DUP6 346A 01 ADD 346B 61 PUSH2 0x3222 346E 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3464 stack[0] = 0x2869 // @3467 stack[1] = stack[-4] // @346A stack[2] = stack[-3] + stack[-1] // } // Block ends with call to 0x3222, returns to 0x2869 label_346F: // Incoming call from 0x02C2, returns to 0x02C3 // Incoming call from 0x038A, returns to 0x038B // Inputs[2] // { // @347D stack[-1] // @347E stack[-2] // } 346F 5B JUMPDEST 3470 60 PUSH1 0x00 3472 80 DUP1 3473 60 PUSH1 0x00 3475 80 DUP1 3476 60 PUSH1 0x00 3478 80 DUP1 3479 60 PUSH1 0x00 347B 60 PUSH1 0xe0 347D 88 DUP9 347E 8A DUP11 347F 03 SUB 3480 12 SLT 3481 15 ISZERO 3482 61 PUSH2 0x3489 3485 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @3470 stack[0] = 0x00 // @3472 stack[1] = 0x00 // @3473 stack[2] = 0x00 // @3475 stack[3] = 0x00 // @3476 stack[4] = 0x00 // @3478 stack[5] = 0x00 // @3479 stack[6] = 0x00 // } // Block ends with conditional jump to 0x3489, if !(stack[-2] - stack[-1] i< 0xe0) label_3486: // Incoming jump from 0x3485, if not !(stack[-2] - stack[-1] i< 0xe0) // Inputs[2] // { // @3486 stack[-5] // @3488 memory[stack[-5]:stack[-5] + stack[-5]] // } 3486 84 DUP5 3487 85 DUP6 3488 FD *REVERT // Stack delta = +0 // Outputs[1] { @3488 revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_3489: // Incoming jump from 0x3485, if !(stack[-2] - stack[-1] i< 0xe0) // Inputs[2] // { // @348A stack[-8] // @348B msg.data[stack[-8]:stack[-8] + 0x20] // } 3489 5B JUMPDEST 348A 87 DUP8 348B 35 CALLDATALOAD 348C 67 PUSH8 0xffffffffffffffff 3495 81 DUP2 3496 11 GT 3497 15 ISZERO 3498 61 PUSH2 0x349f 349B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @348B stack[0] = msg.data[stack[-8]:stack[-8] + 0x20] } // Block ends with conditional jump to 0x349f, if !(msg.data[stack[-8]:stack[-8] + 0x20] > 0xffffffffffffffff) label_349C: // Incoming jump from 0x349B, if not !(msg.data[stack[-8]:stack[-8] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @349C stack[-6] // @349E memory[stack[-6]:stack[-6] + stack[-6]] // } 349C 85 DUP6 349D 86 DUP7 349E FD *REVERT // Stack delta = +0 // Outputs[1] { @349E revert(memory[stack[-6]:stack[-6] + stack[-6]]); } // Block terminates label_349F: // Incoming jump from 0x349B, if !(msg.data[stack[-8]:stack[-8] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @34A3 stack[-10] // @34A4 stack[-1] // @34A5 stack[-9] // } 349F 5B JUMPDEST 34A0 61 PUSH2 0x34ab 34A3 8A DUP11 34A4 82 DUP3 34A5 8B DUP12 34A6 01 ADD 34A7 61 PUSH2 0x3222 34AA 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @34A0 stack[0] = 0x34ab // @34A3 stack[1] = stack[-10] // @34A6 stack[2] = stack[-9] + stack[-1] // } // Block ends with call to 0x3222, returns to 0x34AB label_34AB: // Incoming return from call to 0x3222 at 0x34AA // Inputs[3] // { // @34AC stack[-9] // @34AC stack[-1] // @34B4 stack[-10] // } 34AB 5B JUMPDEST 34AC 97 SWAP8 34AD 50 POP 34AE 50 POP 34AF 61 PUSH2 0x34ba 34B2 60 PUSH1 0x20 34B4 89 DUP10 34B5 01 ADD 34B6 61 PUSH2 0x3310 34B9 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @34AC stack[-9] = stack[-1] // @34AF stack[-2] = 0x34ba // @34B5 stack[-1] = stack[-10] + 0x20 // } // Block ends with call to 0x3310, returns to 0x34BA label_34BA: // Incoming return from call to 0x3310 at 0x34B9 // Inputs[7] // { // @34BB stack[-1] // @34BB stack[-7] // @34BF stack[-9] // @34C1 msg.data[stack[-9] + 0x40:stack[-9] + 0x40 + 0x20] // @34C2 stack[-6] // @34C8 msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // @34C9 stack[-5] // } 34BA 5B JUMPDEST 34BB 95 SWAP6 34BC 50 POP 34BD 60 PUSH1 0x40 34BF 88 DUP9 34C0 01 ADD 34C1 35 CALLDATALOAD 34C2 94 SWAP5 34C3 50 POP 34C4 60 PUSH1 0x60 34C6 88 DUP9 34C7 01 ADD 34C8 35 CALLDATALOAD 34C9 93 SWAP4 34CA 50 POP 34CB 61 PUSH2 0x34d6 34CE 60 PUSH1 0x80 34D0 89 DUP10 34D1 01 ADD 34D2 61 PUSH2 0x3310 34D5 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @34BB stack[-7] = stack[-1] // @34C2 stack[-6] = msg.data[stack[-9] + 0x40:stack[-9] + 0x40 + 0x20] // @34C9 stack[-5] = msg.data[stack[-9] + 0x60:stack[-9] + 0x60 + 0x20] // @34CB stack[-1] = 0x34d6 // @34D1 stack[0] = stack[-9] + 0x80 // } // Block ends with call to 0x3310, returns to 0x34D6 label_34D6: // Incoming return from call to 0x3310 at 0x34D5 // Inputs[13] // { // @34D7 stack[-4] // @34D7 stack[-1] // @34DB stack[-9] // @34DD msg.data[stack[-9] + 0xa0:stack[-9] + 0xa0 + 0x20] // @34DE stack[-3] // @34E4 msg.data[stack[-9] + 0xc0:stack[-9] + 0xc0 + 0x20] // @34E5 stack[-2] // @34E7 stack[-5] // @34E8 stack[-8] // @34E9 stack[-11] // @34EB stack[-7] // @34EC stack[-10] // @34EE stack[-6] // } 34D6 5B JUMPDEST 34D7 92 SWAP3 34D8 50 POP 34D9 60 PUSH1 0xa0 34DB 88 DUP9 34DC 01 ADD 34DD 35 CALLDATALOAD 34DE 91 SWAP2 34DF 50 POP 34E0 60 PUSH1 0xc0 34E2 88 DUP9 34E3 01 ADD 34E4 35 CALLDATALOAD 34E5 90 SWAP1 34E6 50 POP 34E7 92 SWAP3 34E8 95 SWAP6 34E9 98 SWAP9 34EA 91 SWAP2 34EB 94 SWAP5 34EC 97 SWAP8 34ED 50 POP 34EE 92 SWAP3 34EF 95 SWAP6 34F0 50 POP 34F1 56 *JUMP // Stack delta = -4 // Outputs[7] // { // @34E7 stack[-5] = msg.data[stack[-9] + 0xc0:stack[-9] + 0xc0 + 0x20] // @34E8 stack[-8] = stack[-5] // @34E9 stack[-11] = stack[-8] // @34EB stack[-7] = stack[-1] // @34EC stack[-10] = stack[-7] // @34EE stack[-6] = msg.data[stack[-9] + 0xa0:stack[-9] + 0xa0 + 0x20] // @34EF stack[-9] = stack[-6] // } // Block ends with unconditional jump to stack[-11] label_34F2: // Incoming call from 0x03C3, returns to 0x03C4 // Inputs[2] // { // @34F8 stack[-1] // @34F9 stack[-2] // } 34F2 5B JUMPDEST 34F3 60 PUSH1 0x00 34F5 80 DUP1 34F6 60 PUSH1 0x20 34F8 83 DUP4 34F9 85 DUP6 34FA 03 SUB 34FB 12 SLT 34FC 15 ISZERO 34FD 61 PUSH2 0x3504 3500 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @34F3 stack[0] = 0x00 // @34F5 stack[1] = 0x00 // } // Block ends with conditional jump to 0x3504, if !(stack[-2] - stack[-1] i< 0x20) label_3501: // Incoming jump from 0x3500, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3501 stack[-2] // @3503 memory[stack[-2]:stack[-2] + stack[-2]] // } 3501 81 DUP2 3502 82 DUP3 3503 FD *REVERT // Stack delta = +0 // Outputs[1] { @3503 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_3504: // Incoming jump from 0x3500, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3505 stack[-3] // @3506 msg.data[stack[-3]:stack[-3] + 0x20] // } 3504 5B JUMPDEST 3505 82 DUP3 3506 35 CALLDATALOAD 3507 67 PUSH8 0xffffffffffffffff 3510 80 DUP1 3511 82 DUP3 3512 11 GT 3513 15 ISZERO 3514 61 PUSH2 0x351b 3517 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3506 stack[0] = msg.data[stack[-3]:stack[-3] + 0x20] // @3507 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x351b, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) label_3518: // Incoming jump from 0x3517, if not !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @3518 stack[-4] // @351A memory[stack[-4]:stack[-4] + stack[-4]] // } 3518 83 DUP4 3519 84 DUP5 351A FD *REVERT // Stack delta = +0 // Outputs[1] { @351A revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_351B: // Incoming jump from 0x3517, if !(msg.data[stack[-3]:stack[-3] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @351C stack[-2] // @351D stack[-5] // @3521 stack[-6] // } 351B 5B JUMPDEST 351C 81 DUP2 351D 85 DUP6 351E 01 ADD 351F 91 SWAP2 3520 50 POP 3521 85 DUP6 3522 60 PUSH1 0x1f 3524 83 DUP4 3525 01 ADD 3526 12 SLT 3527 61 PUSH2 0x352e 352A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @351F stack[-2] = stack[-5] + stack[-2] } // Block ends with conditional jump to 0x352e, if stack[-5] + stack[-2] + 0x1f i< stack[-6] label_352B: // Incoming jump from 0x352A, if not stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[2] // { // @352B stack[-4] // @352D memory[stack[-4]:stack[-4] + stack[-4]] // } 352B 83 DUP4 352C 84 DUP5 352D FD *REVERT // Stack delta = +0 // Outputs[1] { @352D revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_352E: // Incoming jump from 0x352A, if stack[-5] + stack[-2] + 0x1f i< stack[-6] // Inputs[3] // { // @352F stack[-2] // @3530 msg.data[stack[-2]:stack[-2] + 0x20] // @3531 stack[-1] // } 352E 5B JUMPDEST 352F 81 DUP2 3530 35 CALLDATALOAD 3531 81 DUP2 3532 81 DUP2 3533 11 GT 3534 15 ISZERO 3535 61 PUSH2 0x353c 3538 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3530 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x353c, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_3539: // Incoming jump from 0x3538, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[2] // { // @3539 stack[-5] // @353B memory[stack[-5]:stack[-5] + stack[-5]] // } 3539 84 DUP5 353A 85 DUP6 353B FD *REVERT // Stack delta = +0 // Outputs[1] { @353B revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_353C: // Incoming jump from 0x3538, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @353D stack[-7] // @3541 stack[-1] // @3543 stack[-3] // } 353C 5B JUMPDEST 353D 86 DUP7 353E 60 PUSH1 0x20 3540 80 DUP1 3541 83 DUP4 3542 02 MUL 3543 85 DUP6 3544 01 ADD 3545 01 ADD 3546 11 GT 3547 15 ISZERO 3548 61 PUSH2 0x354f 354B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x354f, if !(stack[-3] + stack[-1] * 0x20 + 0x20 > stack[-7]) label_354C: // Incoming jump from 0x354B, if not !(stack[-3] + stack[-1] * 0x20 + 0x20 > stack[-7]) // Inputs[2] // { // @354C stack[-5] // @354E memory[stack[-5]:stack[-5] + stack[-5]] // } 354C 84 DUP5 354D 85 DUP6 354E FD *REVERT // Stack delta = +0 // Outputs[1] { @354E revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_354F: // Incoming jump from 0x354B, if !(stack[-3] + stack[-1] * 0x20 + 0x20 > stack[-7]) // Inputs[6] // { // @3552 stack[-3] // @3553 stack[-1] // @3556 stack[-8] // @3558 stack[-7] // @355A stack[-2] // @355B stack[-6] // } 354F 5B JUMPDEST 3550 60 PUSH1 0x20 3552 92 SWAP3 3553 90 SWAP1 3554 92 SWAP3 3555 01 ADD 3556 96 SWAP7 3557 91 SWAP2 3558 95 SWAP6 3559 50 POP 355A 90 SWAP1 355B 93 SWAP4 355C 50 POP 355D 50 POP 355E 50 POP 355F 50 POP 3560 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @3556 stack[-8] = 0x20 + stack[-3] // @3558 stack[-7] = stack[-1] // } // Block ends with unconditional jump to stack[-8] 3561 5B JUMPDEST 3562 60 PUSH1 0x00 3564 80 DUP1 3565 60 PUSH1 0x40 3567 83 DUP4 3568 85 DUP6 3569 03 SUB 356A 12 SLT 356B 15 ISZERO 356C 61 PUSH2 0x3573 356F 57 *JUMPI 3570 81 DUP2 3571 82 DUP3 3572 FD *REVERT 3573 5B JUMPDEST 3574 50 POP 3575 50 POP 3576 80 DUP1 3577 51 MLOAD 3578 60 PUSH1 0x20 357A 90 SWAP1 357B 91 SWAP2 357C 01 ADD 357D 51 MLOAD 357E 90 SWAP1 357F 92 SWAP3 3580 90 SWAP1 3581 91 SWAP2 3582 50 POP 3583 56 *JUMP label_3584: // Incoming call from 0x04BF, returns to 0x04C0 // Inputs[2] // { // @358D stack[-1] // @358E stack[-2] // } 3584 5B JUMPDEST 3585 60 PUSH1 0x00 3587 80 DUP1 3588 60 PUSH1 0x00 358A 80 DUP1 358B 60 PUSH1 0x60 358D 85 DUP6 358E 87 DUP8 358F 03 SUB 3590 12 SLT 3591 15 ISZERO 3592 61 PUSH2 0x3599 3595 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @3585 stack[0] = 0x00 // @3587 stack[1] = 0x00 // @3588 stack[2] = 0x00 // @358A stack[3] = 0x00 // } // Block ends with conditional jump to 0x3599, if !(stack[-2] - stack[-1] i< 0x60) label_3596: // Incoming jump from 0x3595, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @3596 stack[-2] // @3598 memory[stack[-2]:stack[-2] + stack[-2]] // } 3596 81 DUP2 3597 82 DUP3 3598 FD *REVERT // Stack delta = +0 // Outputs[1] { @3598 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_3599: // Incoming jump from 0x3595, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[6] // { // @359A stack[-5] // @359B msg.data[stack[-5]:stack[-5] + 0x20] // @359C stack[-4] // @35A2 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @35A3 stack[-3] // @35A9 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // } 3599 5B JUMPDEST 359A 84 DUP5 359B 35 CALLDATALOAD 359C 93 SWAP4 359D 50 POP 359E 60 PUSH1 0x20 35A0 85 DUP6 35A1 01 ADD 35A2 35 CALLDATALOAD 35A3 92 SWAP3 35A4 50 POP 35A5 60 PUSH1 0x40 35A7 85 DUP6 35A8 01 ADD 35A9 35 CALLDATALOAD 35AA 67 PUSH8 0xffffffffffffffff 35B3 80 DUP1 35B4 82 DUP3 35B5 11 GT 35B6 15 ISZERO 35B7 61 PUSH2 0x35be 35BA 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @359C stack[-4] = msg.data[stack[-5]:stack[-5] + 0x20] // @35A3 stack[-3] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @35A9 stack[0] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @35AA stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x35be, if !(msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] > 0xffffffffffffffff) label_35BB: // Incoming jump from 0x35BA, if not !(msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @35BB stack[-4] // @35BD memory[stack[-4]:stack[-4] + stack[-4]] // } 35BB 83 DUP4 35BC 84 DUP5 35BD FD *REVERT // Stack delta = +0 // Outputs[1] { @35BD revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_35BE: // Incoming jump from 0x35BA, if !(msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @35BF stack[-2] // @35C0 stack[-7] // @35C4 stack[-8] // } 35BE 5B JUMPDEST 35BF 81 DUP2 35C0 87 DUP8 35C1 01 ADD 35C2 91 SWAP2 35C3 50 POP 35C4 87 DUP8 35C5 60 PUSH1 0x1f 35C7 83 DUP4 35C8 01 ADD 35C9 12 SLT 35CA 61 PUSH2 0x35d1 35CD 57 *JUMPI // Stack delta = +0 // Outputs[1] { @35C2 stack[-2] = stack[-7] + stack[-2] } // Block ends with conditional jump to 0x35d1, if stack[-7] + stack[-2] + 0x1f i< stack[-8] label_35CE: // Incoming jump from 0x35CD, if not stack[-7] + stack[-2] + 0x1f i< stack[-8] // Inputs[2] // { // @35CE stack[-4] // @35D0 memory[stack[-4]:stack[-4] + stack[-4]] // } 35CE 83 DUP4 35CF 84 DUP5 35D0 FD *REVERT // Stack delta = +0 // Outputs[1] { @35D0 revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_35D1: // Incoming jump from 0x35CD, if stack[-7] + stack[-2] + 0x1f i< stack[-8] // Inputs[3] // { // @35D2 stack[-2] // @35D3 msg.data[stack[-2]:stack[-2] + 0x20] // @35D4 stack[-1] // } 35D1 5B JUMPDEST 35D2 81 DUP2 35D3 35 CALLDATALOAD 35D4 81 DUP2 35D5 81 DUP2 35D6 11 GT 35D7 15 ISZERO 35D8 61 PUSH2 0x35df 35DB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @35D3 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x35df, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) label_35DC: // Incoming jump from 0x35DB, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[2] // { // @35DC stack[-5] // @35DE memory[stack[-5]:stack[-5] + stack[-5]] // } 35DC 84 DUP5 35DD 85 DUP6 35DE FD *REVERT // Stack delta = +0 // Outputs[1] { @35DE revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_35DF: // Incoming jump from 0x35DB, if !(msg.data[stack[-2]:stack[-2] + 0x20] > stack[-1]) // Inputs[3] // { // @35E0 stack[-9] // @35E3 stack[-1] // @35E4 stack[-3] // } 35DF 5B JUMPDEST 35E0 88 DUP9 35E1 60 PUSH1 0x20 35E3 82 DUP3 35E4 85 DUP6 35E5 01 ADD 35E6 01 ADD 35E7 11 GT 35E8 15 ISZERO 35E9 61 PUSH2 0x35f0 35EC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x35f0, if !(stack[-3] + stack[-1] + 0x20 > stack[-9]) label_35ED: // Incoming jump from 0x35EC, if not !(stack[-3] + stack[-1] + 0x20 > stack[-9]) // Inputs[2] // { // @35ED stack[-5] // @35EF memory[stack[-5]:stack[-5] + stack[-5]] // } 35ED 84 DUP5 35EE 85 DUP6 35EF FD *REVERT // Stack delta = +0 // Outputs[1] { @35EF revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_35F0: // Incoming jump from 0x35EC, if !(stack[-3] + stack[-1] + 0x20 > stack[-9]) // Inputs[7] // { // @35F1 stack[-7] // @35F1 stack[-1] // @35F2 stack[-10] // @35F3 stack[-6] // @35F4 stack[-9] // @35F9 stack[-3] // @35FA stack[-8] // } 35F0 5B JUMPDEST 35F1 95 SWAP6 35F2 98 SWAP9 35F3 94 SWAP5 35F4 97 SWAP8 35F5 50 POP 35F6 50 POP 35F7 60 PUSH1 0x20 35F9 01 ADD 35FA 94 SWAP5 35FB 50 POP 35FC 50 POP 35FD 50 POP 35FE 56 *JUMP // Stack delta = -6 // Outputs[4] // { // @35F1 stack[-7] = stack[-1] // @35F2 stack[-10] = stack[-7] // @35F4 stack[-9] = stack[-6] // @35FA stack[-8] = 0x20 + stack[-3] // } // Block ends with unconditional jump to stack[-10] label_35FF: // Incoming call from 0x116A, returns to 0x116B // Inputs[2] // { // @3604 stack[-1] // @3605 stack[-2] // } 35FF 5B JUMPDEST 3600 60 PUSH1 0x00 3602 60 PUSH1 0x20 3604 82 DUP3 3605 84 DUP5 3606 03 SUB 3607 12 SLT 3608 15 ISZERO 3609 61 PUSH2 0x3610 360C 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3600 stack[0] = 0x00 } // Block ends with conditional jump to 0x3610, if !(stack[-2] - stack[-1] i< 0x20) label_360D: // Incoming jump from 0x360C, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @360D stack[-1] // @360F memory[stack[-1]:stack[-1] + stack[-1]] // } 360D 80 DUP1 360E 81 DUP2 360F FD *REVERT // Stack delta = +0 // Outputs[1] { @360F revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_3610: // Incoming jump from 0x360C, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3611 stack[-2] // @3612 memory[stack[-2]:stack[-2] + 0x20] // } 3610 5B JUMPDEST 3611 81 DUP2 3612 51 MLOAD 3613 67 PUSH8 0xffffffffffffffff 361C 81 DUP2 361D 11 GT 361E 15 ISZERO 361F 61 PUSH2 0x3626 3622 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3612 stack[0] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x3626, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_3623: // Incoming jump from 0x3622, if not !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @3623 stack[-2] // @3625 memory[stack[-2]:stack[-2] + stack[-2]] // } 3623 81 DUP2 3624 82 DUP3 3625 FD *REVERT // Stack delta = +0 // Outputs[1] { @3625 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_3626: // Incoming jump from 0x3622, if !(memory[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @3627 stack[-3] // @3628 stack[-1] // @362D stack[-4] // } 3626 5B JUMPDEST 3627 82 DUP3 3628 01 ADD 3629 60 PUSH1 0x1f 362B 81 DUP2 362C 01 ADD 362D 84 DUP5 362E 13 SGT 362F 61 PUSH2 0x3636 3632 57 *JUMPI // Stack delta = +0 // Outputs[1] { @3628 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x3636, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_3633: // Incoming jump from 0x3632, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[2] // { // @3633 stack[-2] // @3635 memory[stack[-2]:stack[-2] + stack[-2]] // } 3633 81 DUP2 3634 82 DUP3 3635 FD *REVERT // Stack delta = +0 // Outputs[1] { @3635 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_3636: // Incoming jump from 0x3632, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[2] // { // @3637 stack[-1] // @3638 memory[stack[-1]:stack[-1] + 0x20] // } 3636 5B JUMPDEST 3637 80 DUP1 3638 51 MLOAD 3639 61 PUSH2 0x3644 363C 61 PUSH2 0x32c5 363F 82 DUP3 3640 61 PUSH2 0x3dfc 3643 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3638 stack[0] = memory[stack[-1]:stack[-1] + 0x20] // @3639 stack[1] = 0x3644 // @363C stack[2] = 0x32c5 // @363F stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x3dfc, returns to 0x32C5 label_3644: // Incoming return from call to 0x32C5 at 0x3643 // Inputs[4] // { // @3645 stack[-2] // @3646 stack[-1] // @3648 stack[-6] // @364C stack[-3] // } 3644 5B JUMPDEST 3645 81 DUP2 3646 81 DUP2 3647 52 MSTORE 3648 85 DUP6 3649 60 PUSH1 0x20 364B 83 DUP4 364C 85 DUP6 364D 01 ADD 364E 01 ADD 364F 11 GT 3650 15 ISZERO 3651 61 PUSH2 0x3658 3654 57 *JUMPI // Stack delta = +0 // Outputs[1] { @3647 memory[stack[-1]:stack[-1] + 0x20] = stack[-2] } // Block ends with conditional jump to 0x3658, if !(stack[-3] + stack[-2] + 0x20 > stack[-6]) label_3655: // Incoming jump from 0x3654, if not !(stack[-3] + stack[-2] + 0x20 > stack[-6]) // Inputs[2] // { // @3655 stack[-4] // @3657 memory[stack[-4]:stack[-4] + stack[-4]] // } 3655 83 DUP4 3656 84 DUP5 3657 FD *REVERT // Stack delta = +0 // Outputs[1] { @3657 revert(memory[stack[-4]:stack[-4] + stack[-4]]); } // Block terminates label_3658: // Incoming jump from 0x3654, if !(stack[-3] + stack[-2] + 0x20 > stack[-6]) // Inputs[3] // { // @365C stack[-2] // @365F stack[-1] // @3663 stack[-3] // } 3658 5B JUMPDEST 3659 61 PUSH2 0x264e 365C 82 DUP3 365D 60 PUSH1 0x20 365F 83 DUP4 3660 01 ADD 3661 60 PUSH1 0x20 3663 86 DUP7 3664 01 ADD 3665 61 PUSH2 0x3e3c 3668 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3659 stack[0] = 0x264e // @365C stack[1] = stack[-2] // @3660 stack[2] = stack[-1] + 0x20 // @3664 stack[3] = stack[-3] + 0x20 // } // Block ends with call to 0x3e3c, returns to 0x264E label_3669: // Incoming jump from 0x03E3 // Inputs[2] // { // @366E stack[-1] // @366F stack[-2] // } 3669 5B JUMPDEST 366A 60 PUSH1 0x00 366C 60 PUSH1 0x20 366E 82 DUP3 366F 84 DUP5 3670 03 SUB 3671 12 SLT 3672 15 ISZERO 3673 61 PUSH2 0x367a 3676 57 *JUMPI // Stack delta = +1 // Outputs[1] { @366A stack[0] = 0x00 } // Block ends with conditional jump to 0x367a, if !(stack[-2] - stack[-1] i< 0x20) label_3677: // Incoming jump from 0x3676, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3677 stack[-1] // @3679 memory[stack[-1]:stack[-1] + stack[-1]] // } 3677 80 DUP1 3678 81 DUP2 3679 FD *REVERT // Stack delta = +0 // Outputs[1] { @3679 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_367A: // Incoming jump from 0x3676, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @367B stack[-2] // @367C msg.data[stack[-2]:stack[-2] + 0x20] // } 367A 5B JUMPDEST 367B 81 DUP2 367C 35 CALLDATALOAD 367D 67 PUSH8 0xffffffffffffffff 3686 80 DUP1 3687 82 DUP3 3688 11 GT 3689 15 ISZERO 368A 61 PUSH2 0x3691 368D 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @367C stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @367D stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x3691, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_368E: // Incoming jump from 0x368D, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @368E stack[-3] // @3690 memory[stack[-3]:stack[-3] + stack[-3]] // } 368E 82 DUP3 368F 83 DUP4 3690 FD *REVERT // Stack delta = +0 // Outputs[1] { @3690 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_3691: // Incoming jump from 0x368D, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[4] // { // @3692 stack[-2] // @3692 stack[-1] // @3693 stack[-4] // @3699 stack[-5] // } 3691 5B JUMPDEST 3692 90 SWAP1 3693 83 DUP4 3694 01 ADD 3695 90 SWAP1 3696 60 PUSH1 0xa0 3698 82 DUP3 3699 86 DUP7 369A 03 SUB 369B 12 SLT 369C 15 ISZERO 369D 61 PUSH2 0x36a4 36A0 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @3695 stack[-1] = stack[-1] // @3695 stack[-2] = stack[-4] + stack[-2] // } // Block ends with conditional jump to 0x36a4, if !(stack[-5] - (stack[-4] + stack[-2]) i< 0xa0) label_36A1: // Incoming jump from 0x36A0, if not !(stack[-5] - (stack[-4] + stack[-2]) i< 0xa0) // Inputs[2] // { // @36A1 stack[-3] // @36A3 memory[stack[-3]:stack[-3] + stack[-3]] // } 36A1 82 DUP3 36A2 83 DUP4 36A3 FD *REVERT // Stack delta = +0 // Outputs[1] { @36A3 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_36A4: // Incoming jump from 0x36A0, if !(stack[-5] - (stack[-4] + stack[-2]) i< 0xa0) // Inputs[2] // { // @36A7 memory[0x40:0x60] // @36AF stack[-1] // } 36A4 5B JUMPDEST 36A5 60 PUSH1 0x40 36A7 51 MLOAD 36A8 60 PUSH1 0xa0 36AA 81 DUP2 36AB 01 ADD 36AC 81 DUP2 36AD 81 DUP2 36AE 10 LT 36AF 83 DUP4 36B0 82 DUP3 36B1 11 GT 36B2 17 OR 36B3 15 ISZERO 36B4 61 PUSH2 0x36b9 36B7 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @36A7 stack[0] = memory[0x40:0x60] // @36AB stack[1] = memory[0x40:0x60] + 0xa0 // } // Block ends with conditional jump to 0x36b9, if !((memory[0x40:0x60] + 0xa0 > stack[-1]) | (memory[0x40:0x60] + 0xa0 < memory[0x40:0x60])) label_36B8: // Incoming jump from 0x36B7, if not !((memory[0x40:0x60] + 0xa0 > stack[-1]) | (memory[0x40:0x60] + 0xa0 < memory[0x40:0x60])) 36B8 FE *ASSERT // Stack delta = +0 // Outputs[1] { @36B8 assert(); } // Block terminates label_36B9: // Incoming jump from 0x36B7, if !((memory[0x40:0x60] + 0xa0 > stack[-1]) | (memory[0x40:0x60] + 0xa0 < memory[0x40:0x60])) // Inputs[4] // { // @36BC stack[-1] // @36BD stack[-4] // @36BE msg.data[stack[-4]:stack[-4] + 0x20] // @36BF stack[-3] // } 36B9 5B JUMPDEST 36BA 60 PUSH1 0x40 36BC 52 MSTORE 36BD 82 DUP3 36BE 35 CALLDATALOAD 36BF 82 DUP3 36C0 81 DUP2 36C1 11 GT 36C2 15 ISZERO 36C3 61 PUSH2 0x36ca 36C6 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @36BC memory[0x40:0x60] = stack[-1] // @36BE stack[-1] = msg.data[stack[-4]:stack[-4] + 0x20] // } // Block ends with conditional jump to 0x36ca, if !(msg.data[stack[-4]:stack[-4] + 0x20] > stack[-3]) label_36C7: // Incoming jump from 0x36C6, if not !(msg.data[stack[-4]:stack[-4] + 0x20] > stack[-3]) // Inputs[2] // { // @36C7 stack[-5] // @36C9 memory[stack[-5]:stack[-5] + stack[-5]] // } 36C7 84 DUP5 36C8 85 DUP6 36C9 FD *REVERT // Stack delta = +0 // Outputs[1] { @36C9 revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_36CA: // Incoming jump from 0x36C6, if !(msg.data[stack[-4]:stack[-4] + 0x20] > stack[-3]) // Inputs[3] // { // @36CE stack[-7] // @36CF stack[-1] // @36D0 stack[-4] // } 36CA 5B JUMPDEST 36CB 61 PUSH2 0x36d6 36CE 87 DUP8 36CF 82 DUP3 36D0 86 DUP7 36D1 01 ADD 36D2 61 PUSH2 0x32a7 36D5 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @36CB stack[0] = 0x36d6 // @36CE stack[1] = stack[-7] // @36D1 stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x32a7, returns to 0x36D6 label_36D6: // Incoming return from call to 0x32A7 at 0x36D5 // Inputs[3] // { // @36D7 stack[-3] // @36D8 stack[-1] // @36DF stack[-5] // } 36D6 5B JUMPDEST 36D7 82 DUP3 36D8 52 MSTORE 36D9 50 POP 36DA 61 PUSH2 0x36e5 36DD 60 PUSH1 0x20 36DF 84 DUP5 36E0 01 ADD 36E1 61 PUSH2 0x3217 36E4 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @36D8 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] // @36DA stack[-2] = 0x36e5 // @36E0 stack[-1] = stack[-5] + 0x20 // } // Block ends with unconditional jump to 0x3217 36E5 5B JUMPDEST 36E6 60 PUSH1 0x20 36E8 82 DUP3 36E9 01 ADD 36EA 52 MSTORE 36EB 60 PUSH1 0x40 36ED 83 DUP4 36EE 01 ADD 36EF 35 CALLDATALOAD 36F0 60 PUSH1 0x40 36F2 82 DUP3 36F3 01 ADD 36F4 52 MSTORE 36F5 60 PUSH1 0x60 36F7 83 DUP4 36F8 01 ADD 36F9 35 CALLDATALOAD 36FA 60 PUSH1 0x60 36FC 82 DUP3 36FD 01 ADD 36FE 52 MSTORE 36FF 60 PUSH1 0x80 3701 83 DUP4 3702 01 ADD 3703 35 CALLDATALOAD 3704 60 PUSH1 0x80 3706 82 DUP3 3707 01 ADD 3708 52 MSTORE 3709 80 DUP1 370A 93 SWAP4 370B 50 POP 370C 50 POP 370D 50 POP 370E 50 POP 370F 92 SWAP3 3710 91 SWAP2 3711 50 POP 3712 50 POP 3713 56 *JUMP label_3714: // Incoming jump from 0x043E // Incoming jump from 0x02F5 // Inputs[2] // { // @371A stack[-1] // @371B stack[-2] // } 3714 5B JUMPDEST 3715 60 PUSH1 0x00 3717 61 PUSH2 0x0100 371A 82 DUP3 371B 84 DUP5 371C 03 SUB 371D 12 SLT 371E 15 ISZERO 371F 61 PUSH2 0x3726 3722 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3715 stack[0] = 0x00 } // Block ends with conditional jump to 0x3726, if !(stack[-2] - stack[-1] i< 0x0100) label_3723: // Incoming jump from 0x3722, if not !(stack[-2] - stack[-1] i< 0x0100) // Inputs[2] // { // @3723 stack[-1] // @3725 memory[stack[-1]:stack[-1] + stack[-1]] // } 3723 80 DUP1 3724 81 DUP2 3725 FD *REVERT // Stack delta = +0 // Outputs[1] { @3725 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_3726: // Incoming jump from 0x3722, if !(stack[-2] - stack[-1] i< 0x0100) // Inputs[2] // { // @372A stack[-3] // @372B stack[-2] // } 3726 5B JUMPDEST 3727 61 PUSH2 0x333d 372A 83 DUP4 372B 83 DUP4 372C 61 PUSH2 0x32f8 372F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @3727 stack[0] = 0x333d // @372A stack[1] = stack[-3] // @372B stack[2] = stack[-2] // } // Block ends with call to 0x32f8, returns to 0x333D label_3730: // Incoming call from 0x048C, returns to 0x048D // Inputs[2] // { // @3735 stack[-1] // @3736 stack[-2] // } 3730 5B JUMPDEST 3731 60 PUSH1 0x00 3733 60 PUSH1 0x20 3735 82 DUP3 3736 84 DUP5 3737 03 SUB 3738 12 SLT 3739 15 ISZERO 373A 61 PUSH2 0x3741 373D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3731 stack[0] = 0x00 } // Block ends with conditional jump to 0x3741, if !(stack[-2] - stack[-1] i< 0x20) label_373E: // Incoming jump from 0x373D, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @373E stack[-1] // @3740 memory[stack[-1]:stack[-1] + stack[-1]] // } 373E 80 DUP1 373F 81 DUP2 3740 FD *REVERT // Stack delta = +0 // Outputs[1] { @3740 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_3741: // Incoming jump from 0x373D, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3742 stack[-2] // @3743 msg.data[stack[-2]:stack[-2] + 0x20] // } 3741 5B JUMPDEST 3742 81 DUP2 3743 35 CALLDATALOAD 3744 67 PUSH8 0xffffffffffffffff 374D 81 DUP2 374E 11 GT 374F 15 ISZERO 3750 61 PUSH2 0x3757 3753 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3743 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x3757, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_3754: // Incoming jump from 0x3753, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @3754 stack[-2] // @3756 memory[stack[-2]:stack[-2] + stack[-2]] // } 3754 81 DUP2 3755 82 DUP3 3756 FD *REVERT // Stack delta = +0 // Outputs[1] { @3756 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_3757: // Incoming jump from 0x3753, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @3758 stack[-3] // @3759 stack[-1] // @375D stack[-4] // } 3757 5B JUMPDEST 3758 82 DUP3 3759 01 ADD 375A 60 PUSH1 0xa0 375C 81 DUP2 375D 85 DUP6 375E 03 SUB 375F 12 SLT 3760 15 ISZERO 3761 61 PUSH2 0x333d 3764 57 *JUMPI // Stack delta = +0 // Outputs[1] { @3759 stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x333d, if !(stack[-4] - (stack[-3] + stack[-1]) i< 0xa0) label_3765: // Incoming jump from 0x3764, if not !(stack[-4] - (stack[-3] + stack[-1]) i< 0xa0) // Inputs[2] // { // @3765 stack[-2] // @3767 memory[stack[-2]:stack[-2] + stack[-2]] // } 3765 81 DUP2 3766 82 DUP3 3767 FD *REVERT // Stack delta = +0 // Outputs[1] { @3767 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_3768: // Incoming call from 0x1C02, returns to 0x1C03 // Inputs[2] // { // @376D stack[-1] // @376E stack[-2] // } 3768 5B JUMPDEST 3769 60 PUSH1 0x00 376B 60 PUSH1 0x20 376D 82 DUP3 376E 84 DUP5 376F 03 SUB 3770 12 SLT 3771 15 ISZERO 3772 61 PUSH2 0x3779 3775 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3769 stack[0] = 0x00 } // Block ends with conditional jump to 0x3779, if !(stack[-2] - stack[-1] i< 0x20) label_3776: // Incoming jump from 0x3775, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3776 stack[-1] // @3778 memory[stack[-1]:stack[-1] + stack[-1]] // } 3776 80 DUP1 3777 81 DUP2 3778 FD *REVERT // Stack delta = +0 // Outputs[1] { @3778 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_3779: // Incoming jump from 0x3775, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @377A stack[-2] // @377B msg.data[stack[-2]:stack[-2] + 0x20] // } 3779 5B JUMPDEST 377A 81 DUP2 377B 35 CALLDATALOAD 377C 67 PUSH8 0xffffffffffffffff 3785 80 DUP1 3786 82 DUP3 3787 11 GT 3788 15 ISZERO 3789 61 PUSH2 0x3790 378C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @377B stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @377C stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x3790, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_378D: // Incoming jump from 0x378C, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @378D stack[-3] // @378F memory[stack[-3]:stack[-3] + stack[-3]] // } 378D 82 DUP3 378E 83 DUP4 378F FD *REVERT // Stack delta = +0 // Outputs[1] { @378F revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_3790: // Incoming jump from 0x378C, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[4] // { // @3791 stack[-1] // @3791 stack[-2] // @3792 stack[-4] // @3798 stack[-5] // } 3790 5B JUMPDEST 3791 90 SWAP1 3792 83 DUP4 3793 01 ADD 3794 90 SWAP1 3795 60 PUSH1 0x40 3797 82 DUP3 3798 86 DUP7 3799 03 SUB 379A 12 SLT 379B 15 ISZERO 379C 61 PUSH2 0x37a3 379F 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @3794 stack[-1] = stack[-1] // @3794 stack[-2] = stack[-4] + stack[-2] // } // Block ends with conditional jump to 0x37a3, if !(stack[-5] - (stack[-4] + stack[-2]) i< 0x40) label_37A0: // Incoming jump from 0x379F, if not !(stack[-5] - (stack[-4] + stack[-2]) i< 0x40) // Inputs[2] // { // @37A0 stack[-3] // @37A2 memory[stack[-3]:stack[-3] + stack[-3]] // } 37A0 82 DUP3 37A1 83 DUP4 37A2 FD *REVERT // Stack delta = +0 // Outputs[1] { @37A2 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_37A3: // Incoming jump from 0x379F, if !(stack[-5] - (stack[-4] + stack[-2]) i< 0x40) // Inputs[2] // { // @37A6 memory[0x40:0x60] // @37AE stack[-1] // } 37A3 5B JUMPDEST 37A4 60 PUSH1 0x40 37A6 51 MLOAD 37A7 60 PUSH1 0x40 37A9 81 DUP2 37AA 01 ADD 37AB 81 DUP2 37AC 81 DUP2 37AD 10 LT 37AE 83 DUP4 37AF 82 DUP3 37B0 11 GT 37B1 17 OR 37B2 15 ISZERO 37B3 61 PUSH2 0x37b8 37B6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @37A6 stack[0] = memory[0x40:0x60] // @37AA stack[1] = memory[0x40:0x60] + 0x40 // } // Block ends with conditional jump to 0x37b8, if !((memory[0x40:0x60] + 0x40 > stack[-1]) | (memory[0x40:0x60] + 0x40 < memory[0x40:0x60])) label_37B7: // Incoming jump from 0x37B6, if not !((memory[0x40:0x60] + 0x40 > stack[-1]) | (memory[0x40:0x60] + 0x40 < memory[0x40:0x60])) 37B7 FE *ASSERT // Stack delta = +0 // Outputs[1] { @37B7 assert(); } // Block terminates label_37B8: // Incoming jump from 0x37B6, if !((memory[0x40:0x60] + 0x40 > stack[-1]) | (memory[0x40:0x60] + 0x40 < memory[0x40:0x60])) // Inputs[4] // { // @37BB stack[-1] // @37BC stack[-4] // @37BD msg.data[stack[-4]:stack[-4] + 0x20] // @37BE stack[-3] // } 37B8 5B JUMPDEST 37B9 60 PUSH1 0x40 37BB 52 MSTORE 37BC 82 DUP3 37BD 35 CALLDATALOAD 37BE 82 DUP3 37BF 81 DUP2 37C0 11 GT 37C1 15 ISZERO 37C2 61 PUSH2 0x37c9 37C5 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @37BB memory[0x40:0x60] = stack[-1] // @37BD stack[-1] = msg.data[stack[-4]:stack[-4] + 0x20] // } // Block ends with conditional jump to 0x37c9, if !(msg.data[stack[-4]:stack[-4] + 0x20] > stack[-3]) label_37C6: // Incoming jump from 0x37C5, if not !(msg.data[stack[-4]:stack[-4] + 0x20] > stack[-3]) // Inputs[2] // { // @37C6 stack[-5] // @37C8 memory[stack[-5]:stack[-5] + stack[-5]] // } 37C6 84 DUP5 37C7 85 DUP6 37C8 FD *REVERT // Stack delta = +0 // Outputs[1] { @37C8 revert(memory[stack[-5]:stack[-5] + stack[-5]]); } // Block terminates label_37C9: // Incoming jump from 0x37C5, if !(msg.data[stack[-4]:stack[-4] + 0x20] > stack[-3]) // Inputs[3] // { // @37CD stack[-7] // @37CE stack[-1] // @37CF stack[-4] // } 37C9 5B JUMPDEST 37CA 61 PUSH2 0x37d5 37CD 87 DUP8 37CE 82 DUP3 37CF 86 DUP7 37D0 01 ADD 37D1 61 PUSH2 0x32a7 37D4 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @37CA stack[0] = 0x37d5 // @37CD stack[1] = stack[-7] // @37D0 stack[2] = stack[-4] + stack[-1] // } // Block ends with call to 0x32a7, returns to 0x37D5 label_37D5: // Incoming return from call to 0x32A7 at 0x37D4 // Inputs[4] // { // @37D6 stack[-3] // @37D7 stack[-1] // @37DB stack[-5] // @37DD msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 37D5 5B JUMPDEST 37D6 82 DUP3 37D7 52 MSTORE 37D8 50 POP 37D9 60 PUSH1 0x20 37DB 83 DUP4 37DC 01 ADD 37DD 35 CALLDATALOAD 37DE 92 SWAP3 37DF 50 POP 37E0 61 PUSH2 0x37e8 37E3 83 DUP4 37E4 61 PUSH2 0x3e68 37E7 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @37D7 memory[stack[-3]:stack[-3] + 0x20] = stack[-1] // @37DE stack[-5] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @37E0 stack[-2] = 0x37e8 // @37E3 stack[-1] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with call to 0x3e68, returns to 0x37E8 label_37E8: // Incoming return from call to 0x3E68 at 0x37E7 // Inputs[4] // { // @37EB stack[-1] // @37ED stack[-3] // @37F2 stack[-7] // @37F3 stack[-6] // } 37E8 5B JUMPDEST 37E9 60 PUSH1 0x20 37EB 81 DUP2 37EC 01 ADD 37ED 92 SWAP3 37EE 90 SWAP1 37EF 92 SWAP3 37F0 52 MSTORE 37F1 50 POP 37F2 93 SWAP4 37F3 92 SWAP3 37F4 50 POP 37F5 50 POP 37F6 50 POP 37F7 56 *JUMP // Stack delta = -6 // Outputs[2] // { // @37F0 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-3] // @37F2 stack[-7] = stack[-1] // } // Block ends with unconditional jump to stack[-7] 37F8 5B JUMPDEST 37F9 60 PUSH1 0x00 37FB 60 PUSH1 0x20 37FD 82 DUP3 37FE 84 DUP5 37FF 03 SUB 3800 12 SLT 3801 15 ISZERO 3802 61 PUSH2 0x3809 3805 57 *JUMPI 3806 80 DUP1 3807 81 DUP2 3808 FD *REVERT 3809 5B JUMPDEST 380A 81 DUP2 380B 35 CALLDATALOAD 380C 62 PUSH3 0xffffff 3810 81 DUP2 3811 16 AND 3812 81 DUP2 3813 14 EQ 3814 61 PUSH2 0x333d 3817 57 *JUMPI 3818 81 DUP2 3819 82 DUP3 381A FD *REVERT label_381B: // Incoming call from 0x0596, returns to 0x0597 // Inputs[2] // { // @3820 stack[-1] // @3821 stack[-2] // } 381B 5B JUMPDEST 381C 60 PUSH1 0x00 381E 60 PUSH1 0x20 3820 82 DUP3 3821 84 DUP5 3822 03 SUB 3823 12 SLT 3824 15 ISZERO 3825 61 PUSH2 0x382c 3828 57 *JUMPI // Stack delta = +1 // Outputs[1] { @381C stack[0] = 0x00 } // Block ends with conditional jump to 0x382c, if !(stack[-2] - stack[-1] i< 0x20) label_3829: // Incoming jump from 0x3828, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @3829 stack[-1] // @382B memory[stack[-1]:stack[-1] + stack[-1]] // } 3829 80 DUP1 382A 81 DUP2 382B FD *REVERT // Stack delta = +0 // Outputs[1] { @382B revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_382C: // Incoming jump from 0x3828, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @382E stack[-2] // @382E memory[stack[-2]:stack[-2] + 0x20] // @382F stack[-4] // @3830 stack[-3] // } 382C 5B JUMPDEST 382D 50 POP 382E 51 MLOAD 382F 91 SWAP2 3830 90 SWAP1 3831 50 POP 3832 56 *JUMP // Stack delta = -3 // Outputs[1] { @382F stack[-4] = memory[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_3833: // Incoming call from 0x031B, returns to 0x031C // Inputs[2] // { // @3839 stack[-1] // @383A stack[-2] // } 3833 5B JUMPDEST 3834 60 PUSH1 0x00 3836 80 DUP1 3837 60 PUSH1 0x40 3839 83 DUP4 383A 85 DUP6 383B 03 SUB 383C 12 SLT 383D 15 ISZERO 383E 61 PUSH2 0x3845 3841 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3834 stack[0] = 0x00 // @3836 stack[1] = 0x00 // } // Block ends with conditional jump to 0x3845, if !(stack[-2] - stack[-1] i< 0x40) label_3842: // Incoming jump from 0x3841, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @3842 stack[-2] // @3844 memory[stack[-2]:stack[-2] + stack[-2]] // } 3842 81 DUP2 3843 82 DUP3 3844 FD *REVERT // Stack delta = +0 // Outputs[1] { @3844 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_3845: // Incoming jump from 0x3841, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[4] // { // @3846 stack[-3] // @3847 msg.data[stack[-3]:stack[-3] + 0x20] // @3848 stack[-2] // @384E msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } 3845 5B JUMPDEST 3846 82 DUP3 3847 35 CALLDATALOAD 3848 91 SWAP2 3849 50 POP 384A 60 PUSH1 0x20 384C 83 DUP4 384D 01 ADD 384E 35 CALLDATALOAD 384F 61 PUSH2 0x3857 3852 81 DUP2 3853 61 PUSH2 0x3e68 3856 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @3848 stack[-2] = msg.data[stack[-3]:stack[-3] + 0x20] // @384E stack[0] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // @384F stack[1] = 0x3857 // @3852 stack[2] = msg.data[stack[-3] + 0x20:stack[-3] + 0x20 + 0x20] // } // Block ends with call to 0x3e68, returns to 0x3857 label_3857: // Incoming return from call to 0x3E68 at 0x3856 // Inputs[6] // { // @3858 stack[-1] // @3859 stack[-2] // @385C stack[-5] // @385E stack[-3] // @385E stack[-6] // @385F stack[-4] // } 3857 5B JUMPDEST 3858 80 DUP1 3859 91 SWAP2 385A 50 POP 385B 50 POP 385C 92 SWAP3 385D 50 POP 385E 92 SWAP3 385F 90 SWAP1 3860 50 POP 3861 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @385C stack[-5] = stack[-1] // @385E stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_3862: // Incoming call from 0x039D, returns to 0x039E // Inputs[2] // { // @386B stack[-1] // @386C stack[-2] // } 3862 5B JUMPDEST 3863 60 PUSH1 0x00 3865 80 DUP1 3866 60 PUSH1 0x00 3868 80 DUP1 3869 60 PUSH1 0x80 386B 85 DUP6 386C 87 DUP8 386D 03 SUB 386E 12 SLT 386F 15 ISZERO 3870 61 PUSH2 0x3877 3873 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @3863 stack[0] = 0x00 // @3865 stack[1] = 0x00 // @3866 stack[2] = 0x00 // @3868 stack[3] = 0x00 // } // Block ends with conditional jump to 0x3877, if !(stack[-2] - stack[-1] i< 0x80) label_3874: // Incoming jump from 0x3873, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @3874 stack[-2] // @3876 memory[stack[-2]:stack[-2] + stack[-2]] // } 3874 81 DUP2 3875 82 DUP3 3876 FD *REVERT // Stack delta = +0 // Outputs[1] { @3876 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_3877: // Incoming jump from 0x3873, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[4] // { // @3878 stack[-5] // @3879 msg.data[stack[-5]:stack[-5] + 0x20] // @387A stack[-4] // @3880 msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } 3877 5B JUMPDEST 3878 84 DUP5 3879 35 CALLDATALOAD 387A 93 SWAP4 387B 50 POP 387C 60 PUSH1 0x20 387E 85 DUP6 387F 01 ADD 3880 35 CALLDATALOAD 3881 61 PUSH2 0x3889 3884 81 DUP2 3885 61 PUSH2 0x3e68 3888 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @387A stack[-4] = msg.data[stack[-5]:stack[-5] + 0x20] // @3880 stack[0] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // @3881 stack[1] = 0x3889 // @3884 stack[2] = msg.data[stack[-5] + 0x20:stack[-5] + 0x20 + 0x20] // } // Block ends with call to 0x3e68, returns to 0x3889 label_3889: // Incoming return from call to 0x3E68 at 0x3888 // Inputs[6] // { // @388A stack[-4] // @388A stack[-1] // @388E stack[-6] // @3890 msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @3891 stack[-3] // @3897 msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 3889 5B JUMPDEST 388A 92 SWAP3 388B 50 POP 388C 60 PUSH1 0x40 388E 85 DUP6 388F 01 ADD 3890 35 CALLDATALOAD 3891 91 SWAP2 3892 50 POP 3893 60 PUSH1 0x60 3895 85 DUP6 3896 01 ADD 3897 35 CALLDATALOAD 3898 61 PUSH2 0x38a0 389B 81 DUP2 389C 61 PUSH2 0x3e68 389F 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @388A stack[-4] = stack[-1] // @3891 stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @3897 stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // @3898 stack[0] = 0x38a0 // @389B stack[1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with call to 0x3e68, returns to 0x38A0 label_38A0: // Incoming return from call to 0x3E68 at 0x389F // Inputs[8] // { // @38A1 stack[-1] // @38A1 stack[-5] // @38A2 stack[-8] // @38A3 stack[-4] // @38A4 stack[-7] // @38A6 stack[-2] // @38A6 stack[-3] // @38A7 stack[-6] // } 38A0 5B JUMPDEST 38A1 93 SWAP4 38A2 96 SWAP7 38A3 92 SWAP3 38A4 95 SWAP6 38A5 50 POP 38A6 90 SWAP1 38A7 93 SWAP4 38A8 50 POP 38A9 50 POP 38AA 56 *JUMP // Stack delta = -4 // Outputs[4] // { // @38A1 stack[-5] = stack[-1] // @38A2 stack[-8] = stack[-5] // @38A4 stack[-7] = stack[-4] // @38A7 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-8] label_38AB: // Incoming call from 0x3AA6, returns to 0x3AA7 // Incoming call from 0x3B0A, returns to 0x333D // Inputs[3] // { // @38AE stack[-1] // @38AF memory[stack[-1]:stack[-1] + 0x20] // @38B1 stack[-2] // } 38AB 5B JUMPDEST 38AC 60 PUSH1 0x00 38AE 81 DUP2 38AF 51 MLOAD 38B0 80 DUP1 38B1 84 DUP5 38B2 52 MSTORE 38B3 61 PUSH2 0x38c3 38B6 81 DUP2 38B7 60 PUSH1 0x20 38B9 86 DUP7 38BA 01 ADD 38BB 60 PUSH1 0x20 38BD 86 DUP7 38BE 01 ADD 38BF 61 PUSH2 0x3e3c 38C2 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @38AC stack[0] = 0x00 // @38AF stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @38B2 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @38B3 stack[2] = 0x38c3 // @38B6 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @38BA stack[4] = stack[-2] + 0x20 // @38BE stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x3e3c, returns to 0x38C3 label_38C3: // Incoming return from call to 0x3E3C at 0x38C2 // Inputs[4] // { // @38C6 stack[-1] // @38E9 stack[-4] // @38EA stack[-2] // @38F0 stack[-5] // } 38C3 5B JUMPDEST 38C4 60 PUSH1 0x1f 38C6 01 ADD 38C7 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 38E8 16 AND 38E9 92 SWAP3 38EA 90 SWAP1 38EB 92 SWAP3 38EC 01 ADD 38ED 60 PUSH1 0x20 38EF 01 ADD 38F0 92 SWAP3 38F1 91 SWAP2 38F2 50 POP 38F3 50 POP 38F4 56 *JUMP // Stack delta = -4 // Outputs[1] { @38F0 stack[-5] = 0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] 38F5 5B JUMPDEST 38F6 60 PUSH1 0x60 38F8 93 SWAP4 38F9 84 DUP5 38FA 1B SHL 38FB 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000 391C 90 SWAP1 391D 81 DUP2 391E 16 AND 391F 82 DUP3 3920 52 MSTORE 3921 60 PUSH1 0xe8 3923 93 SWAP4 3924 90 SWAP1 3925 93 SWAP4 3926 1B SHL 3927 7F PUSH32 0xffffff0000000000000000000000000000000000000000000000000000000000 3948 16 AND 3949 60 PUSH1 0x14 394B 82 DUP3 394C 01 ADD 394D 52 MSTORE 394E 92 SWAP3 394F 1B SHL 3950 16 AND 3951 60 PUSH1 0x17 3953 82 DUP3 3954 01 ADD 3955 52 MSTORE 3956 60 PUSH1 0x2b 3958 01 ADD 3959 90 SWAP1 395A 56 *JUMP 395B 5B JUMPDEST 395C 7F PUSH32 0xff00000000000000000000000000000000000000000000000000000000000000 397D 94 SWAP5 397E 85 DUP6 397F 16 AND 3980 81 DUP2 3981 52 MSTORE 3982 92 SWAP3 3983 90 SWAP1 3984 93 SWAP4 3985 16 AND 3986 60 PUSH1 0x01 3988 83 DUP4 3989 01 ADD 398A 52 MSTORE 398B 60 PUSH1 0x60 398D 1B SHL 398E 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffff000000000000000000000000 39AF 16 AND 39B0 60 PUSH1 0x02 39B2 82 DUP3 39B3 01 ADD 39B4 52 MSTORE 39B5 60 PUSH1 0x16 39B7 81 DUP2 39B8 01 ADD 39B9 91 SWAP2 39BA 90 SWAP1 39BB 91 SWAP2 39BC 52 MSTORE 39BD 60 PUSH1 0x36 39BF 01 ADD 39C0 90 SWAP1 39C1 56 *JUMP label_39C2: // Incoming call from 0x10F7, returns to 0x10F8 // Inputs[5] // { // @39C5 stack[-2] // @39C6 stack[-3] // @39C7 stack[-1] // @39C8 msg.data[stack[-3]:stack[-3] + stack[-2]] // @39CE stack[-4] // } 39C2 5B JUMPDEST 39C3 60 PUSH1 0x00 39C5 82 DUP3 39C6 84 DUP5 39C7 83 DUP4 39C8 37 CALLDATACOPY 39C9 91 SWAP2 39CA 01 ADD 39CB 90 SWAP1 39CC 81 DUP2 39CD 52 MSTORE 39CE 91 SWAP2 39CF 90 SWAP1 39D0 50 POP 39D1 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @39C8 memory[stack[-1]:stack[-1] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @39CD memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] = 0x00 // @39CE stack[-4] = stack[-2] + stack[-1] // } // Block ends with unconditional jump to stack[-4] label_39D2: // Incoming call from 0x192D, returns to 0x192E // Inputs[2] // { // @39D3 stack[-1] // @39D3 stack[-2] // } 39D2 5B JUMPDEST 39D3 90 SWAP1 39D4 56 *JUMP // Stack delta = -1 // Outputs[1] { @39D3 stack[-2] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_39D5: // Incoming call from 0x0546, returns to 0x0547 // Incoming call from 0x0342, returns to 0x029F // Inputs[3] // { // @39EB stack[-2] // @39EC stack[-1] // @39F4 stack[-3] // } 39D5 5B JUMPDEST 39D6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 39EB 91 SWAP2 39EC 90 SWAP1 39ED 91 SWAP2 39EE 16 AND 39EF 81 DUP2 39F0 52 MSTORE 39F1 60 PUSH1 0x20 39F3 01 ADD 39F4 90 SWAP1 39F5 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @39F0 memory[stack[-1]:stack[-1] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @39F4 stack[-3] = 0x20 + stack[-1] // } // Block ends with unconditional jump to stack[-3] 39F6 5B JUMPDEST 39F7 60 PUSH1 0x00 39F9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3A0E 80 DUP1 3A0F 88 DUP9 3A10 16 AND 3A11 83 DUP4 3A12 52 MSTORE 3A13 86 DUP7 3A14 15 ISZERO 3A15 15 ISZERO 3A16 60 PUSH1 0x20 3A18 84 DUP5 3A19 01 ADD 3A1A 52 MSTORE 3A1B 85 DUP6 3A1C 60 PUSH1 0x40 3A1E 84 DUP5 3A1F 01 ADD 3A20 52 MSTORE 3A21 80 DUP1 3A22 85 DUP6 3A23 16 AND 3A24 60 PUSH1 0x60 3A26 84 DUP5 3A27 01 ADD 3A28 52 MSTORE 3A29 50 POP 3A2A 60 PUSH1 0xa0 3A2C 60 PUSH1 0x80 3A2E 83 DUP4 3A2F 01 ADD 3A30 52 MSTORE 3A31 61 PUSH2 0x3a3d 3A34 60 PUSH1 0xa0 3A36 83 DUP4 3A37 01 ADD 3A38 84 DUP5 3A39 61 PUSH2 0x38ab 3A3C 56 *JUMP 3A3D 5B JUMPDEST 3A3E 97 SWAP8 3A3F 96 SWAP7 3A40 50 POP 3A41 50 POP 3A42 50 POP 3A43 50 POP 3A44 50 POP 3A45 50 POP 3A46 50 POP 3A47 56 *JUMP label_3A48: // Incoming call from 0x03D5, returns to 0x029F // Inputs[3] // { // @3A4E stack[-1] // @3A54 stack[-2] // @3A55 memory[stack[-2]:stack[-2] + 0x20] // } 3A48 5B JUMPDEST 3A49 60 PUSH1 0x00 3A4B 60 PUSH1 0x20 3A4D 80 DUP1 3A4E 83 DUP4 3A4F 01 ADD 3A50 81 DUP2 3A51 84 DUP5 3A52 52 MSTORE 3A53 80 DUP1 3A54 85 DUP6 3A55 51 MLOAD 3A56 80 DUP1 3A57 83 DUP4 3A58 52 MSTORE 3A59 60 PUSH1 0x40 3A5B 86 DUP7 3A5C 01 ADD 3A5D 91 SWAP2 3A5E 50 POP 3A5F 60 PUSH1 0x40 3A61 84 DUP5 3A62 82 DUP3 3A63 02 MUL 3A64 87 DUP8 3A65 01 ADD 3A66 01 ADD 3A67 92 SWAP3 3A68 50 POP 3A69 83 DUP4 3A6A 87 DUP8 3A6B 01 ADD 3A6C 85 DUP6 3A6D 5B JUMPDEST 3A6E 82 DUP3 3A6F 81 DUP2 3A70 10 LT 3A71 15 ISZERO 3A72 61 PUSH2 0x3ab9 3A75 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @3A49 stack[0] = 0x00 // @3A4B stack[1] = 0x20 // @3A52 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3A55 stack[4] = memory[stack[-2]:stack[-2] + 0x20] // @3A58 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @3A5D stack[3] = stack[-1] + 0x40 // @3A67 stack[2] = stack[-1] + memory[stack[-2]:stack[-2] + 0x20] * 0x20 + 0x40 // @3A6B stack[5] = stack[-2] + 0x20 // @3A6C stack[6] = 0x00 // } // Block ends with conditional jump to 0x3ab9, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_3A76: // Incoming jump from 0x3A75, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x3A75, if not !(stack[-1] < stack[-3]) // Inputs[5] // { // @3A97 stack[-8] // @3A98 stack[-5] // @3A9B stack[-4] // @3AA1 stack[-2] // @3AA2 memory[stack[-2]:stack[-2] + 0x20] // } 3A76 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc0 3A97 88 DUP9 3A98 86 DUP7 3A99 03 SUB 3A9A 01 ADD 3A9B 84 DUP5 3A9C 52 MSTORE 3A9D 61 PUSH2 0x3aa7 3AA0 85 DUP6 3AA1 83 DUP4 3AA2 51 MLOAD 3AA3 61 PUSH2 0x38ab 3AA6 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @3A9C memory[stack[-4]:stack[-4] + 0x20] = stack[-5] - stack[-8] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffc0 // @3A9D stack[0] = 0x3aa7 // @3AA0 stack[1] = stack[-5] // @3AA2 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x38ab, returns to 0x3AA7 label_3AA7: // Incoming return from call to 0x38AB at 0x3AA6 // Inputs[6] // { // @3AA8 stack[-1] // @3AA8 stack[-6] // @3AAA stack[-2] // @3AAA stack[-5] // @3AAB stack[-7] // @3AAE stack[-3] // } 3AA7 5B JUMPDEST 3AA8 94 SWAP5 3AA9 50 POP 3AAA 92 SWAP3 3AAB 85 DUP6 3AAC 01 ADD 3AAD 92 SWAP3 3AAE 90 SWAP1 3AAF 85 DUP6 3AB0 01 ADD 3AB1 90 SWAP1 3AB2 60 PUSH1 0x01 3AB4 01 ADD 3AB5 61 PUSH2 0x3a6d 3AB8 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @3AA8 stack[-6] = stack[-1] // @3AAD stack[-5] = stack[-7] + stack[-5] // @3AB1 stack[-3] = stack[-7] + stack[-3] // @3AB4 stack[-2] = 0x01 + stack[-2] // } // Block ends with unconditional jump to 0x3a6d label_3AB9: // Incoming jump from 0x3A75, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x3A75, if !(stack[-1] < stack[-3]) // Inputs[4] // { // @3ABB stack[-5] // @3ABB stack[-2] // @3ABC stack[-10] // @3ABD stack[-9] // } 3AB9 5B JUMPDEST 3ABA 50 POP 3ABB 92 SWAP3 3ABC 97 SWAP8 3ABD 96 SWAP7 3ABE 50 POP 3ABF 50 POP 3AC0 50 POP 3AC1 50 POP 3AC2 50 POP 3AC3 50 POP 3AC4 50 POP 3AC5 56 *JUMP // Stack delta = -9 // Outputs[1] { @3ABC stack[-10] = stack[-5] } // Block ends with unconditional jump to stack[-10] 3AC6 5B JUMPDEST 3AC7 90 SWAP1 3AC8 15 ISZERO 3AC9 15 ISZERO 3ACA 81 DUP2 3ACB 52 MSTORE 3ACC 60 PUSH1 0x20 3ACE 01 ADD 3ACF 90 SWAP1 3AD0 56 *JUMP 3AD1 5B JUMPDEST 3AD2 90 SWAP1 3AD3 81 DUP2 3AD4 52 MSTORE 3AD5 60 PUSH1 0x20 3AD7 01 ADD 3AD8 90 SWAP1 3AD9 56 *JUMP 3ADA 5B JUMPDEST 3ADB 93 SWAP4 3ADC 84 DUP5 3ADD 52 MSTORE 3ADE 60 PUSH1 0xff 3AE0 92 SWAP3 3AE1 90 SWAP1 3AE2 92 SWAP3 3AE3 16 AND 3AE4 60 PUSH1 0x20 3AE6 84 DUP5 3AE7 01 ADD 3AE8 52 MSTORE 3AE9 60 PUSH1 0x40 3AEB 83 DUP4 3AEC 01 ADD 3AED 52 MSTORE 3AEE 60 PUSH1 0x60 3AF0 82 DUP3 3AF1 01 ADD 3AF2 52 MSTORE 3AF3 60 PUSH1 0x80 3AF5 01 ADD 3AF6 90 SWAP1 3AF7 56 *JUMP label_3AF8: // Incoming jump from 0x119D // Inputs[2] // { // @3AFD stack[-1] // @3B06 stack[-2] // } 3AF8 5B JUMPDEST 3AF9 60 PUSH1 0x00 3AFB 60 PUSH1 0x20 3AFD 82 DUP3 3AFE 52 MSTORE 3AFF 61 PUSH2 0x333d 3B02 60 PUSH1 0x20 3B04 83 DUP4 3B05 01 ADD 3B06 84 DUP5 3B07 61 PUSH2 0x38ab 3B0A 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @3AF9 stack[0] = 0x00 // @3AFE memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3AFF stack[1] = 0x333d // @3B05 stack[2] = stack[-1] + 0x20 // @3B06 stack[3] = stack[-2] // } // Block ends with call to 0x38ab, returns to 0x333D 3B0B 5B JUMPDEST 3B0C 60 PUSH1 0x20 3B0E 80 DUP1 3B0F 82 DUP3 3B10 52 MSTORE 3B11 60 PUSH1 0x01 3B13 90 SWAP1 3B14 82 DUP3 3B15 01 ADD 3B16 52 MSTORE 3B17 7F PUSH32 0x3400000000000000000000000000000000000000000000000000000000000000 3B38 60 PUSH1 0x40 3B3A 82 DUP3 3B3B 01 ADD 3B3C 52 MSTORE 3B3D 60 PUSH1 0x60 3B3F 01 ADD 3B40 90 SWAP1 3B41 56 *JUMP label_3B42: // Incoming call from 0x20A4, returns to 0x087A // Inputs[2] // { // @3B46 stack[-1] // @3B77 stack[-2] // } 3B42 5B JUMPDEST 3B43 60 PUSH1 0x20 3B45 80 DUP1 3B46 82 DUP3 3B47 52 MSTORE 3B48 60 PUSH1 0x01 3B4A 90 SWAP1 3B4B 82 DUP3 3B4C 01 ADD 3B4D 52 MSTORE 3B4E 7F PUSH32 0x3700000000000000000000000000000000000000000000000000000000000000 3B6F 60 PUSH1 0x40 3B71 82 DUP3 3B72 01 ADD 3B73 52 MSTORE 3B74 60 PUSH1 0x60 3B76 01 ADD 3B77 90 SWAP1 3B78 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @3B47 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3B4D memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x01 // @3B73 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x3700000000000000000000000000000000000000000000000000000000000000 // @3B77 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 3B79 5B JUMPDEST 3B7A 60 PUSH1 0x20 3B7C 80 DUP1 3B7D 82 DUP3 3B7E 52 MSTORE 3B7F 60 PUSH1 0x14 3B81 90 SWAP1 3B82 82 DUP3 3B83 01 ADD 3B84 52 MSTORE 3B85 7F PUSH32 0x504f4f4c5f4e4f545f57484954454c4953544544000000000000000000000000 3BA6 60 PUSH1 0x40 3BA8 82 DUP3 3BA9 01 ADD 3BAA 52 MSTORE 3BAB 60 PUSH1 0x60 3BAD 01 ADD 3BAE 90 SWAP1 3BAF 56 *JUMP label_3BB0: // Incoming call from 0x1A8D, returns to 0x087A // Inputs[2] // { // @3BB4 stack[-1] // @3BE5 stack[-2] // } 3BB0 5B JUMPDEST 3BB1 60 PUSH1 0x20 3BB3 80 DUP1 3BB4 82 DUP3 3BB5 52 MSTORE 3BB6 60 PUSH1 0x1c 3BB8 90 SWAP1 3BB9 82 DUP3 3BBA 01 ADD 3BBB 52 MSTORE 3BBC 7F PUSH32 0x4f55545055545f544f4b454e5f4e4f545f57484954454c495354454400000000 3BDD 60 PUSH1 0x40 3BDF 82 DUP3 3BE0 01 ADD 3BE1 52 MSTORE 3BE2 60 PUSH1 0x60 3BE4 01 ADD 3BE5 90 SWAP1 3BE6 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @3BB5 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @3BBB memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x1c // @3BE1 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4f55545055545f544f4b454e5f4e4f545f57484954454c495354454400000000 // @3BE5 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] 3BE7 5B JUMPDEST 3BE8 60 PUSH1 0x20 3BEA 80 DUP1 3BEB 82 DUP3 3BEC 52 MSTORE 3BED 60 PUSH1 0x12 3BEF 90 SWAP1 3BF0 82 DUP3 3BF1 01 ADD 3BF2 52 MSTORE 3BF3 7F PUSH32 0x546f6f206d756368207265717565737465640000000000000000000000000000 3C14 60 PUSH1 0x40 3C16 82 DUP3 3C17 01 ADD 3C18 52 MSTORE 3C19 60 PUSH1 0x60 3C1B 01 ADD 3C1C 90 SWAP1 3C1D 56 *JUMP 3C1E 5B JUMPDEST 3C1F 60 PUSH1 0x20 3C21 80 DUP1 3C22 82 DUP3 3C23 52 MSTORE 3C24 60 PUSH1 0x01 3C26 90 SWAP1 3C27 82 DUP3 3C28 01 ADD 3C29 52 MSTORE 3C2A 7F PUSH32 0x3500000000000000000000000000000000000000000000000000000000000000 3C4B 60 PUSH1 0x40 3C4D 82 DUP3 3C4E 01 ADD 3C4F 52 MSTORE 3C50 60 PUSH1 0x60 3C52 01 ADD 3C53 90 SWAP1 3C54 56 *JUMP 3C55 5B JUMPDEST 3C56 60 PUSH1 0x20 3C58 80 DUP1 3C59 82 DUP3 3C5A 52 MSTORE 3C5B 60 PUSH1 0x01 3C5D 90 SWAP1 3C5E 82 DUP3 3C5F 01 ADD 3C60 52 MSTORE 3C61 7F PUSH32 0x3600000000000000000000000000000000000000000000000000000000000000 3C82 60 PUSH1 0x40 3C84 82 DUP3 3C85 01 ADD 3C86 52 MSTORE 3C87 60 PUSH1 0x60 3C89 01 ADD 3C8A 90 SWAP1 3C8B 56 *JUMP 3C8C 5B JUMPDEST 3C8D 60 PUSH1 0x20 3C8F 80 DUP1 3C90 82 DUP3 3C91 52 MSTORE 3C92 60 PUSH1 0x13 3C94 90 SWAP1 3C95 82 DUP3 3C96 01 ADD 3C97 52 MSTORE 3C98 7F PUSH32 0x546f6f206c6974746c6520726563656976656400000000000000000000000000 3CB9 60 PUSH1 0x40 3CBB 82 DUP3 3CBC 01 ADD 3CBD 52 MSTORE 3CBE 60 PUSH1 0x60 3CC0 01 ADD 3CC1 90 SWAP1 3CC2 56 *JUMP 3CC3 5B JUMPDEST 3CC4 60 PUSH1 0x00 3CC6 60 PUSH1 0x20 3CC8 82 DUP3 3CC9 52 MSTORE 3CCA 82 DUP3 3CCB 51 MLOAD 3CCC 60 PUSH1 0x40 3CCE 60 PUSH1 0x20 3CD0 84 DUP5 3CD1 01 ADD 3CD2 52 MSTORE 3CD3 61 PUSH2 0x3cdf 3CD6 60 PUSH1 0x60 3CD8 84 DUP5 3CD9 01 ADD 3CDA 82 DUP3 3CDB 61 PUSH2 0x38ab 3CDE 56 *JUMP 3CDF 5B JUMPDEST 3CE0 90 SWAP1 3CE1 50 POP 3CE2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3CF7 60 PUSH1 0x20 3CF9 85 DUP6 3CFA 01 ADD 3CFB 51 MLOAD 3CFC 16 AND 3CFD 60 PUSH1 0x40 3CFF 84 DUP5 3D00 01 ADD 3D01 52 MSTORE 3D02 80 DUP1 3D03 91 SWAP2 3D04 50 POP 3D05 50 POP 3D06 92 SWAP3 3D07 91 SWAP2 3D08 50 POP 3D09 50 POP 3D0A 56 *JUMP label_3D0B: // Incoming call from 0x0797, returns to 0x05DC // Incoming call from 0x05DB, returns to 0x05DC // Inputs[4] // { // @3D10 stack[-1] // @3D12 stack[-3] // @3D1E stack[-2] // @3D1F memory[stack[-2]:stack[-2] + 0x20] // } 3D0B 5B JUMPDEST 3D0C 60 PUSH1 0x00 3D0E 60 PUSH1 0x40 3D10 82 DUP3 3D11 01 ADD 3D12 84 DUP5 3D13 83 DUP4 3D14 52 MSTORE 3D15 60 PUSH1 0x20 3D17 60 PUSH1 0x40 3D19 81 DUP2 3D1A 85 DUP6 3D1B 01 ADD 3D1C 52 MSTORE 3D1D 81 DUP2 3D1E 85 DUP6 3D1F 51 MLOAD 3D20 80 DUP1 3D21 84 DUP5 3D22 52 MSTORE 3D23 60 PUSH1 0x60 3D25 86 DUP7 3D26 01 ADD 3D27 91 SWAP2 3D28 50 POP 3D29 82 DUP3 3D2A 87 DUP8 3D2B 01 ADD 3D2C 93 SWAP4 3D2D 50 POP 3D2E 84 DUP5 3D2F 5B JUMPDEST 3D30 81 DUP2 3D31 81 DUP2 3D32 10 LT 3D33 15 ISZERO 3D34 61 PUSH2 0x3d61 3D37 57 *JUMPI // Stack delta = +6 // Outputs[9] // { // @3D0C stack[0] = 0x00 // @3D14 memory[stack[-1]:stack[-1] + 0x20] = stack[-3] // @3D15 stack[2] = 0x20 // @3D1C memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x40 // @3D1F stack[4] = memory[stack[-2]:stack[-2] + 0x20] // @3D22 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @3D27 stack[3] = stack[-1] + 0x60 // @3D2C stack[1] = stack[-2] + 0x20 // @3D2E stack[5] = 0x00 // } // Block ends with conditional jump to 0x3d61, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_3D38: // Incoming jump from 0x3D37, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x3D37, if not !(stack[-1] < stack[-2]) // Inputs[5] // { // @3D38 stack[-5] // @3D39 memory[stack[-5]:stack[-5] + 0x20] // @3D50 stack[-3] // @3D52 stack[-1] // @3D53 stack[-4] // } 3D38 84 DUP5 3D39 51 MLOAD 3D3A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3D4F 16 AND 3D50 83 DUP4 3D51 52 MSTORE 3D52 93 SWAP4 3D53 83 DUP4 3D54 01 ADD 3D55 93 SWAP4 3D56 91 SWAP2 3D57 83 DUP4 3D58 01 ADD 3D59 91 SWAP2 3D5A 60 PUSH1 0x01 3D5C 01 ADD 3D5D 61 PUSH2 0x3d2f 3D60 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @3D51 memory[stack[-3]:stack[-3] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & memory[stack[-5]:stack[-5] + 0x20] // @3D55 stack[-5] = stack[-4] + stack[-5] // @3D59 stack[-3] = stack[-4] + stack[-3] // @3D5C stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x3d2f label_3D61: // Incoming jump from 0x3D37, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x3D37, if !(stack[-1] < stack[-2]) // Inputs[4] // { // @3D63 stack[-2] // @3D63 stack[-3] // @3D64 stack[-10] // @3D65 stack[-9] // } 3D61 5B JUMPDEST 3D62 50 POP 3D63 90 SWAP1 3D64 97 SWAP8 3D65 96 SWAP7 3D66 50 POP 3D67 50 POP 3D68 50 POP 3D69 50 POP 3D6A 50 POP 3D6B 50 POP 3D6C 50 POP 3D6D 56 *JUMP // Stack delta = -9 // Outputs[1] { @3D64 stack[-10] = stack[-3] } // Block ends with unconditional jump to stack[-10] label_3D6E: // Incoming call from 0x19F4, returns to 0x19F5 // Incoming call from 0x10E9, returns to 0x10EA // Inputs[4] // { // @3D72 stack[-2] // @3D73 msg.data[stack[-2]:stack[-2] + 0x20] // @3D95 stack[-1] // @3D96 msg.data.length // } 3D6E 5B JUMPDEST 3D6F 60 PUSH1 0x00 3D71 80 DUP1 3D72 83 DUP4 3D73 35 CALLDATALOAD 3D74 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1 3D95 84 DUP5 3D96 36 CALLDATASIZE 3D97 03 SUB 3D98 01 ADD 3D99 81 DUP2 3D9A 12 SLT 3D9B 61 PUSH2 0x3da2 3D9E 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @3D6F stack[0] = 0x00 // @3D71 stack[1] = 0x00 // @3D73 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with conditional jump to 0x3da2, if msg.data[stack[-2]:stack[-2] + 0x20] i< msg.data.length - stack[-1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1 label_3D9F: // Incoming jump from 0x3D9E, if not msg.data[stack[-2]:stack[-2] + 0x20] i< msg.data.length - stack[-1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1 // Inputs[2] // { // @3D9F stack[-3] // @3DA1 memory[stack[-3]:stack[-3] + stack[-3]] // } 3D9F 82 DUP3 3DA0 83 DUP4 3DA1 FD *REVERT // Stack delta = +0 // Outputs[1] { @3DA1 revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_3DA2: // Incoming jump from 0x3D9E, if msg.data[stack[-2]:stack[-2] + 0x20] i< msg.data.length - stack[-1] + 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe1 // Inputs[4] // { // @3DA3 stack[-4] // @3DA4 stack[-1] // @3DA6 msg.data[stack[-4] + stack[-1]:stack[-4] + stack[-1] + 0x20] // @3DA7 stack[-2] // } 3DA2 5B JUMPDEST 3DA3 83 DUP4 3DA4 01 ADD 3DA5 80 DUP1 3DA6 35 CALLDATALOAD 3DA7 91 SWAP2 3DA8 50 POP 3DA9 67 PUSH8 0xffffffffffffffff 3DB2 82 DUP3 3DB3 11 GT 3DB4 15 ISZERO 3DB5 61 PUSH2 0x3dbc 3DB8 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @3DA4 stack[-1] = stack[-4] + stack[-1] // @3DA7 stack[-2] = msg.data[stack[-4] + stack[-1]:stack[-4] + stack[-1] + 0x20] // } // Block ends with conditional jump to 0x3dbc, if !(msg.data[stack[-4] + stack[-1]:stack[-4] + stack[-1] + 0x20] > 0xffffffffffffffff) label_3DB9: // Incoming jump from 0x3DB8, if not !(msg.data[stack[-4] + stack[-1]:stack[-4] + stack[-1] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @3DB9 stack[-3] // @3DBB memory[stack[-3]:stack[-3] + stack[-3]] // } 3DB9 82 DUP3 3DBA 83 DUP4 3DBB FD *REVERT // Stack delta = +0 // Outputs[1] { @3DBB revert(memory[stack[-3]:stack[-3] + stack[-3]]); } // Block terminates label_3DBC: // Incoming jump from 0x3DB8, if !(msg.data[stack[-4] + stack[-1]:stack[-4] + stack[-1] + 0x20] > 0xffffffffffffffff) // Inputs[4] // { // @3DBF stack[-1] // @3DC0 stack[-3] // @3DC2 msg.data.length // @3DC3 stack[-2] // } 3DBC 5B JUMPDEST 3DBD 60 PUSH1 0x20 3DBF 01 ADD 3DC0 91 SWAP2 3DC1 50 POP 3DC2 36 CALLDATASIZE 3DC3 81 DUP2 3DC4 90 SWAP1 3DC5 03 SUB 3DC6 82 DUP3 3DC7 13 SGT 3DC8 15 ISZERO 3DC9 61 PUSH2 0x3dd1 3DCC 57 *JUMPI // Stack delta = -1 // Outputs[1] { @3DC0 stack[-3] = 0x20 + stack[-1] } // Block ends with conditional jump to 0x3dd1, if !(0x20 + stack[-1] i> msg.data.length - stack[-2]) label_3DCD: // Incoming jump from 0x3DCC, if not !(0x20 + stack[-1] i> msg.data.length - stack[-2]) // Inputs[1] { @3DD0 memory[0x00:0x00] } 3DCD 60 PUSH1 0x00 3DCF 80 DUP1 3DD0 FD *REVERT // Stack delta = +0 // Outputs[1] { @3DD0 revert(memory[0x00:0x00]); } // Block terminates label_3DD1: // Incoming jump from 0x3DCC, if !(0x20 + stack[-1] i> msg.data.length - stack[-2]) // Inputs[5] // { // @3DD2 stack[-4] // @3DD2 stack[-1] // @3DD4 stack[-5] // @3DD4 stack[-2] // @3DD5 stack[-3] // } 3DD1 5B JUMPDEST 3DD2 92 SWAP3 3DD3 50 POP 3DD4 92 SWAP3 3DD5 90 SWAP1 3DD6 50 POP 3DD7 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @3DD2 stack[-4] = stack[-1] // @3DD4 stack[-5] = stack[-2] // } // Block ends with unconditional jump to stack[-5] label_3DD8: // Incoming call from 0x3255, returns to 0x3256 // Incoming jump from 0x32C9 // Inputs[2] // { // @3DDB memory[0x40:0x60] // @3DDC stack[-1] // } 3DD8 5B JUMPDEST 3DD9 60 PUSH1 0x40 3DDB 51 MLOAD 3DDC 81 DUP2 3DDD 81 DUP2 3DDE 01 ADD 3DDF 67 PUSH8 0xffffffffffffffff 3DE8 81 DUP2 3DE9 11 GT 3DEA 82 DUP3 3DEB 82 DUP3 3DEC 10 LT 3DED 17 OR 3DEE 15 ISZERO 3DEF 61 PUSH2 0x3df4 3DF2 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3DDB stack[0] = memory[0x40:0x60] // @3DDE stack[1] = memory[0x40:0x60] + stack[-1] // } // Block ends with conditional jump to 0x3df4, if !((memory[0x40:0x60] + stack[-1] < memory[0x40:0x60]) | (memory[0x40:0x60] + stack[-1] > 0xffffffffffffffff)) label_3DF3: // Incoming jump from 0x3DF2, if not !((memory[0x40:0x60] + stack[-1] < memory[0x40:0x60]) | (memory[0x40:0x60] + stack[-1] > 0xffffffffffffffff)) 3DF3 FE *ASSERT // Stack delta = +0 // Outputs[1] { @3DF3 assert(); } // Block terminates label_3DF4: // Incoming jump from 0x3DF2, if !((memory[0x40:0x60] + stack[-1] < memory[0x40:0x60]) | (memory[0x40:0x60] + stack[-1] > 0xffffffffffffffff)) // Inputs[4] // { // @3DF7 stack[-1] // @3DF8 stack[-2] // @3DF8 stack[-4] // @3DF9 stack[-3] // } 3DF4 5B JUMPDEST 3DF5 60 PUSH1 0x40 3DF7 52 MSTORE 3DF8 91 SWAP2 3DF9 90 SWAP1 3DFA 50 POP 3DFB 56 *JUMP // Stack delta = -3 // Outputs[2] // { // @3DF7 memory[0x40:0x60] = stack[-1] // @3DF8 stack[-4] = stack[-2] // } // Block ends with unconditional jump to stack[-4] label_3DFC: // Incoming call from 0x3643, returns to 0x32C5 // Incoming call from 0x32C4, returns to 0x32C5 // Inputs[1] { @3E08 stack[-1] } 3DFC 5B JUMPDEST 3DFD 60 PUSH1 0x00 3DFF 67 PUSH8 0xffffffffffffffff 3E08 82 DUP3 3E09 11 GT 3E0A 15 ISZERO 3E0B 61 PUSH2 0x3e10 3E0E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3DFD stack[0] = 0x00 } // Block ends with conditional jump to 0x3e10, if !(stack[-1] > 0xffffffffffffffff) label_3E0F: // Incoming jump from 0x3E0E, if not !(stack[-1] > 0xffffffffffffffff) 3E0F FE *ASSERT // Stack delta = +0 // Outputs[1] { @3E0F assert(); } // Block terminates label_3E10: // Incoming jump from 0x3E0E, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @3E14 stack[-2] // @3E3A stack[-3] // } 3E10 5B JUMPDEST 3E11 50 POP 3E12 60 PUSH1 0x1f 3E14 01 ADD 3E15 7F PUSH32 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 3E36 16 AND 3E37 60 PUSH1 0x20 3E39 01 ADD 3E3A 90 SWAP1 3E3B 56 *JUMP // Stack delta = -2 // Outputs[1] { @3E3A stack[-3] = 0x20 + (0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffe0 & 0x1f + stack[-2]) } // Block ends with unconditional jump to stack[-3] label_3E3C: // Incoming call from 0x3668, returns to 0x264E // Incoming call from 0x38C2, returns to 0x38C3 // Inputs[1] { @3E40 stack[-3] } 3E3C 5B JUMPDEST 3E3D 60 PUSH1 0x00 3E3F 5B JUMPDEST 3E40 83 DUP4 3E41 81 DUP2 3E42 10 LT 3E43 15 ISZERO 3E44 61 PUSH2 0x3e57 3E47 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3E3D stack[0] = 0x00 } // Block ends with conditional jump to 0x3e57, if !(0x00 < stack[-3]) label_3E48: // Incoming jump from 0x3E47, if not !(0x00 < stack[-3]) // Incoming jump from 0x3E47, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @3E48 stack[-2] // @3E49 stack[-1] // @3E4B memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @3E4C stack[-3] // } 3E48 81 DUP2 3E49 81 DUP2 3E4A 01 ADD 3E4B 51 MLOAD 3E4C 83 DUP4 3E4D 82 DUP3 3E4E 01 ADD 3E4F 52 MSTORE 3E50 60 PUSH1 0x20 3E52 01 ADD 3E53 61 PUSH2 0x3e3f 3E56 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @3E4F memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @3E52 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x3e3f label_3E57: // Incoming jump from 0x3E47, if !(0x00 < stack[-3]) // Incoming jump from 0x3E47, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @3E58 stack[-4] // @3E59 stack[-1] // } 3E57 5B JUMPDEST 3E58 83 DUP4 3E59 81 DUP2 3E5A 11 GT 3E5B 15 ISZERO 3E5C 61 PUSH2 0x178c 3E5F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x178c, if !(stack[-1] > stack[-4]) label_3E60: // Incoming jump from 0x3E5F, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @3E64 stack[-4] // @3E65 stack[-3] // @3E67 stack[-5] // } 3E60 50 POP 3E61 50 POP 3E62 60 PUSH1 0x00 3E64 91 SWAP2 3E65 01 ADD 3E66 52 MSTORE 3E67 56 *JUMP // Stack delta = -5 // Outputs[1] { @3E66 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_3E68: // Incoming call from 0x3362, returns to 0x3363 // Incoming call from 0x33D4, returns to 0x33D5 // Incoming call from 0x3856, returns to 0x3857 // Incoming call from 0x389F, returns to 0x38A0 // Incoming call from 0x333C, returns to 0x333D // Incoming call from 0x33BD, returns to 0x33BE // Incoming call from 0x37E7, returns to 0x37E8 // Incoming call from 0x3286, returns to 0x3287 // Incoming call from 0x3888, returns to 0x3889 // Incoming call from 0x3379, returns to 0x337A // Incoming call from 0x3405, returns to 0x3406 // Incoming call from 0x3221, returns to 0x0616 // Incoming call from 0x33A6, returns to 0x33A7 // Inputs[1] { @3E7E stack[-1] } 3E68 5B JUMPDEST 3E69 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3E7E 81 DUP2 3E7F 16 AND 3E80 81 DUP2 3E81 14 EQ 3E82 61 PUSH2 0x3e8a 3E85 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3e8a, if stack[-1] == stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff label_3E86: // Incoming jump from 0x3E85, if not stack[-1] == stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @3E89 memory[0x00:0x00] } 3E86 60 PUSH1 0x00 3E88 80 DUP1 3E89 FD *REVERT // Stack delta = +0 // Outputs[1] { @3E89 revert(memory[0x00:0x00]); } // Block terminates label_3E8A: // Incoming jump from 0x3E85, if stack[-1] == stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff // Inputs[1] { @3E8C stack[-2] } 3E8A 5B JUMPDEST 3E8B 50 POP 3E8C 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] 3E8D FE *ASSERT 3E8E A2 LOG2 3E8F 64 PUSH5 0x6970667358 3E95 22 22 3E96 12 SLT 3E97 20 SHA3 3E98 3A GASPRICE 3E99 0F 0F 3E9A 89 DUP10 3E9B 3A GASPRICE 3E9C 14 EQ 3E9D 24 24 3E9E 28 28 3E9F EF EF 3EA0 78 PUSH25 0xbfaac11d71ae17aa4cc51ae141a75b6b3cfb55297e5d606473 3EBA 6F PUSH16 0x6c63430007060033