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 0x01ee 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x01ee, 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 0x66328738 0019 11 GT 001A 61 PUSH2 0x010d 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x010d, if 0x66328738 > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x66328738 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xa22cb465 0024 11 GT 0025 61 PUSH2 0x00a0 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00a0, if 0xa22cb465 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xa22cb465 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xd547cfb7 002F 11 GT 0030 61 PUSH2 0x006f 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x006f, if 0xd547cfb7 > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xd547cfb7 > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xd547cfb7 003A 14 EQ 003B 61 PUSH2 0x0569 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0569, if 0xd547cfb7 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xd547cfb7 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xd94b7243 0045 14 EQ 0046 61 PUSH2 0x057e 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x057e, if 0xd94b7243 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xd94b7243 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xd96a094a 0050 14 EQ 0051 61 PUSH2 0x0594 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0594, if 0xd96a094a == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xd96a094a == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xe985e9c5 005B 14 EQ 005C 61 PUSH2 0x05a7 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05a7, if 0xe985e9c5 == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @0060 stack[-1] } 0060 80 DUP1 0061 63 PUSH4 0xf2fde38b 0066 14 EQ 0067 61 PUSH2 0x05f0 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05f0, if 0xf2fde38b == stack[-1] label_006B: // Incoming jump from 0x006A, if not 0xf2fde38b == stack[-1] // Inputs[1] { @006E memory[0x00:0x00] } 006B 60 PUSH1 0x00 006D 80 DUP1 006E FD *REVERT // Stack delta = +0 // Outputs[1] { @006E revert(memory[0x00:0x00]); } // Block terminates label_006F: // Incoming jump from 0x0033, if 0xd547cfb7 > stack[-1] // Inputs[1] { @0070 stack[-1] } 006F 5B JUMPDEST 0070 80 DUP1 0071 63 PUSH4 0xa22cb465 0076 14 EQ 0077 61 PUSH2 0x04f4 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04f4, if 0xa22cb465 == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xa22cb465 == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0xb88d4fde 0081 14 EQ 0082 61 PUSH2 0x0514 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0514, if 0xb88d4fde == stack[-1] label_0086: // Incoming jump from 0x0085, if not 0xb88d4fde == stack[-1] // Inputs[1] { @0086 stack[-1] } 0086 80 DUP1 0087 63 PUSH4 0xc87b56dd 008C 14 EQ 008D 61 PUSH2 0x0534 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0534, if 0xc87b56dd == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xc87b56dd == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0xca5d0880 0097 14 EQ 0098 61 PUSH2 0x0554 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0554, if 0xca5d0880 == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0xca5d0880 == stack[-1] // Inputs[1] { @009F memory[0x00:0x00] } 009C 60 PUSH1 0x00 009E 80 DUP1 009F FD *REVERT // Stack delta = +0 // Outputs[1] { @009F revert(memory[0x00:0x00]); } // Block terminates label_00A0: // Incoming jump from 0x0028, if 0xa22cb465 > stack[-1] // Inputs[1] { @00A1 stack[-1] } 00A0 5B JUMPDEST 00A1 80 DUP1 00A2 63 PUSH4 0x78e97925 00A7 11 GT 00A8 61 PUSH2 0x00dc 00AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00dc, if 0x78e97925 > stack[-1] label_00AC: // Incoming jump from 0x00AB, if not 0x78e97925 > stack[-1] // Inputs[1] { @00AC stack[-1] } 00AC 80 DUP1 00AD 63 PUSH4 0x78e97925 00B2 14 EQ 00B3 61 PUSH2 0x048b 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x048b, if 0x78e97925 == stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0x78e97925 == stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0x8da5cb5b 00BD 14 EQ 00BE 61 PUSH2 0x04a1 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04a1, if 0x8da5cb5b == stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0x95d89b41 00C8 14 EQ 00C9 61 PUSH2 0x04bf 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04bf, if 0x95d89b41 == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00CD stack[-1] } 00CD 80 DUP1 00CE 63 PUSH4 0xa0bcfc7f 00D3 14 EQ 00D4 61 PUSH2 0x04d4 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04d4, if 0xa0bcfc7f == stack[-1] label_00D8: // Incoming jump from 0x00D7, if not 0xa0bcfc7f == stack[-1] // Inputs[1] { @00DB memory[0x00:0x00] } 00D8 60 PUSH1 0x00 00DA 80 DUP1 00DB FD *REVERT // Stack delta = +0 // Outputs[1] { @00DB revert(memory[0x00:0x00]); } // Block terminates label_00DC: // Incoming jump from 0x00AB, if 0x78e97925 > stack[-1] // Inputs[1] { @00DD stack[-1] } 00DC 5B JUMPDEST 00DD 80 DUP1 00DE 63 PUSH4 0x66328738 00E3 14 EQ 00E4 61 PUSH2 0x0416 00E7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0416, if 0x66328738 == stack[-1] label_00E8: // Incoming jump from 0x00E7, if not 0x66328738 == stack[-1] // Inputs[1] { @00E8 stack[-1] } 00E8 80 DUP1 00E9 63 PUSH4 0x70a08231 00EE 14 EQ 00EF 61 PUSH2 0x0436 00F2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0436, if 0x70a08231 == stack[-1] label_00F3: // Incoming jump from 0x00F2, if not 0x70a08231 == stack[-1] // Inputs[1] { @00F3 stack[-1] } 00F3 80 DUP1 00F4 63 PUSH4 0x715018a6 00F9 14 EQ 00FA 61 PUSH2 0x0456 00FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0456, if 0x715018a6 == stack[-1] label_00FE: // Incoming jump from 0x00FD, if not 0x715018a6 == stack[-1] // Inputs[1] { @00FE stack[-1] } 00FE 80 DUP1 00FF 63 PUSH4 0x755edd17 0104 14 EQ 0105 61 PUSH2 0x046b 0108 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x046b, if 0x755edd17 == stack[-1] label_0109: // Incoming jump from 0x0108, if not 0x755edd17 == stack[-1] // Inputs[1] { @010C memory[0x00:0x00] } 0109 60 PUSH1 0x00 010B 80 DUP1 010C FD *REVERT // Stack delta = +0 // Outputs[1] { @010C revert(memory[0x00:0x00]); } // Block terminates label_010D: // Incoming jump from 0x001D, if 0x66328738 > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @010E stack[-1] } 010D 5B JUMPDEST 010E 80 DUP1 010F 63 PUSH4 0x23b872dd 0114 11 GT 0115 61 PUSH2 0x0185 0118 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0185, if 0x23b872dd > stack[-1] label_0119: // Incoming jump from 0x0118, if not 0x23b872dd > stack[-1] // Inputs[1] { @0119 stack[-1] } 0119 80 DUP1 011A 63 PUSH4 0x3ccfd60b 011F 11 GT 0120 61 PUSH2 0x0154 0123 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0154, if 0x3ccfd60b > stack[-1] label_0124: // Incoming jump from 0x0123, if not 0x3ccfd60b > stack[-1] // Inputs[1] { @0124 stack[-1] } 0124 80 DUP1 0125 63 PUSH4 0x3ccfd60b 012A 14 EQ 012B 61 PUSH2 0x03a1 012E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03a1, if 0x3ccfd60b == stack[-1] label_012F: // Incoming jump from 0x012E, if not 0x3ccfd60b == stack[-1] // Inputs[1] { @012F stack[-1] } 012F 80 DUP1 0130 63 PUSH4 0x42842e0e 0135 14 EQ 0136 61 PUSH2 0x03b6 0139 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03b6, if 0x42842e0e == stack[-1] label_013A: // Incoming jump from 0x0139, if not 0x42842e0e == stack[-1] // Inputs[1] { @013A stack[-1] } 013A 80 DUP1 013B 63 PUSH4 0x4f6ccce7 0140 14 EQ 0141 61 PUSH2 0x03d6 0144 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03d6, if 0x4f6ccce7 == stack[-1] label_0145: // Incoming jump from 0x0144, if not 0x4f6ccce7 == stack[-1] // Inputs[1] { @0145 stack[-1] } 0145 80 DUP1 0146 63 PUSH4 0x6352211e 014B 14 EQ 014C 61 PUSH2 0x03f6 014F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03f6, if 0x6352211e == stack[-1] label_0150: // Incoming jump from 0x014F, if not 0x6352211e == stack[-1] // Inputs[1] { @0153 memory[0x00:0x00] } 0150 60 PUSH1 0x00 0152 80 DUP1 0153 FD *REVERT // Stack delta = +0 // Outputs[1] { @0153 revert(memory[0x00:0x00]); } // Block terminates label_0154: // Incoming jump from 0x0123, if 0x3ccfd60b > stack[-1] // Inputs[1] { @0155 stack[-1] } 0154 5B JUMPDEST 0155 80 DUP1 0156 63 PUSH4 0x23b872dd 015B 14 EQ 015C 61 PUSH2 0x0318 015F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0318, if 0x23b872dd == stack[-1] label_0160: // Incoming jump from 0x015F, if not 0x23b872dd == stack[-1] // Inputs[1] { @0160 stack[-1] } 0160 80 DUP1 0161 63 PUSH4 0x2d0335ab 0166 14 EQ 0167 61 PUSH2 0x0338 016A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0338, if 0x2d0335ab == stack[-1] label_016B: // Incoming jump from 0x016A, if not 0x2d0335ab == stack[-1] // Inputs[1] { @016B stack[-1] } 016B 80 DUP1 016C 63 PUSH4 0x2f745c59 0171 14 EQ 0172 61 PUSH2 0x036e 0175 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x036e, if 0x2f745c59 == stack[-1] label_0176: // Incoming jump from 0x0175, if not 0x2f745c59 == stack[-1] // Inputs[1] { @0176 stack[-1] } 0176 80 DUP1 0177 63 PUSH4 0x3408e470 017C 14 EQ 017D 61 PUSH2 0x038e 0180 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x038e, if 0x3408e470 == stack[-1] label_0181: // Incoming jump from 0x0180, if not 0x3408e470 == stack[-1] // Inputs[1] { @0184 memory[0x00:0x00] } 0181 60 PUSH1 0x00 0183 80 DUP1 0184 FD *REVERT // Stack delta = +0 // Outputs[1] { @0184 revert(memory[0x00:0x00]); } // Block terminates label_0185: // Incoming jump from 0x0118, if 0x23b872dd > stack[-1] // Inputs[1] { @0186 stack[-1] } 0185 5B JUMPDEST 0186 80 DUP1 0187 63 PUSH4 0x0c53c51c 018C 11 GT 018D 61 PUSH2 0x01c1 0190 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01c1, if 0x0c53c51c > stack[-1] label_0191: // Incoming jump from 0x0190, if not 0x0c53c51c > stack[-1] // Inputs[1] { @0191 stack[-1] } 0191 80 DUP1 0192 63 PUSH4 0x0c53c51c 0197 14 EQ 0198 61 PUSH2 0x02a4 019B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02a4, if 0x0c53c51c == stack[-1] label_019C: // Incoming jump from 0x019B, if not 0x0c53c51c == stack[-1] // Inputs[1] { @019C stack[-1] } 019C 80 DUP1 019D 63 PUSH4 0x0f7e5970 01A2 14 EQ 01A3 61 PUSH2 0x02b7 01A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02b7, if 0x0f7e5970 == stack[-1] label_01A7: // Incoming jump from 0x01A6, if not 0x0f7e5970 == stack[-1] // Inputs[1] { @01A7 stack[-1] } 01A7 80 DUP1 01A8 63 PUSH4 0x18160ddd 01AD 14 EQ 01AE 61 PUSH2 0x02e4 01B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02e4, if 0x18160ddd == stack[-1] label_01B2: // Incoming jump from 0x01B1, if not 0x18160ddd == stack[-1] // Inputs[1] { @01B2 stack[-1] } 01B2 80 DUP1 01B3 63 PUSH4 0x20379ee5 01B8 14 EQ 01B9 61 PUSH2 0x0303 01BC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0303, if 0x20379ee5 == stack[-1] label_01BD: // Incoming jump from 0x01BC, if not 0x20379ee5 == stack[-1] // Inputs[1] { @01C0 memory[0x00:0x00] } 01BD 60 PUSH1 0x00 01BF 80 DUP1 01C0 FD *REVERT // Stack delta = +0 // Outputs[1] { @01C0 revert(memory[0x00:0x00]); } // Block terminates label_01C1: // Incoming jump from 0x0190, if 0x0c53c51c > stack[-1] // Inputs[1] { @01C2 stack[-1] } 01C1 5B JUMPDEST 01C2 80 DUP1 01C3 63 PUSH4 0x01ffc9a7 01C8 14 EQ 01C9 61 PUSH2 0x01f3 01CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01f3, if 0x01ffc9a7 == stack[-1] label_01CD: // Incoming jump from 0x01CC, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @01CD stack[-1] } 01CD 80 DUP1 01CE 63 PUSH4 0x06fdde03 01D3 14 EQ 01D4 61 PUSH2 0x0228 01D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0228, if 0x06fdde03 == stack[-1] label_01D8: // Incoming jump from 0x01D7, if not 0x06fdde03 == stack[-1] // Inputs[1] { @01D8 stack[-1] } 01D8 80 DUP1 01D9 63 PUSH4 0x081812fc 01DE 14 EQ 01DF 61 PUSH2 0x024a 01E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x024a, if 0x081812fc == stack[-1] label_01E3: // Incoming jump from 0x01E2, if not 0x081812fc == stack[-1] // Inputs[1] { @01E3 stack[-1] } 01E3 80 DUP1 01E4 63 PUSH4 0x095ea7b3 01E9 14 EQ 01EA 61 PUSH2 0x0282 01ED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0282, if 0x095ea7b3 == stack[-1] label_01EE: // Incoming jump from 0x01ED, if not 0x095ea7b3 == stack[-1] // Incoming jump from 0x000C, if msg.data.length < 0x04 // Inputs[1] { @01F2 memory[0x00:0x00] } 01EE 5B JUMPDEST 01EF 60 PUSH1 0x00 01F1 80 DUP1 01F2 FD *REVERT // Stack delta = +0 // Outputs[1] { @01F2 revert(memory[0x00:0x00]); } // Block terminates label_01F3: // Incoming jump from 0x01CC, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @01F4 msg.value } 01F3 5B JUMPDEST 01F4 34 CALLVALUE 01F5 80 DUP1 01F6 15 ISZERO 01F7 61 PUSH2 0x01ff 01FA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @01F4 stack[0] = msg.value } // Block ends with conditional jump to 0x01ff, if !msg.value label_01FB: // Incoming jump from 0x01FA, if not !msg.value // Inputs[1] { @01FE memory[0x00:0x00] } 01FB 60 PUSH1 0x00 01FD 80 DUP1 01FE FD *REVERT // Stack delta = +0 // Outputs[1] { @01FE revert(memory[0x00:0x00]); } // Block terminates label_01FF: // Incoming jump from 0x01FA, if !msg.value // Inputs[1] { @0207 msg.data.length } 01FF 5B JUMPDEST 0200 50 POP 0201 61 PUSH2 0x0213 0204 61 PUSH2 0x020e 0207 36 CALLDATASIZE 0208 60 PUSH1 0x04 020A 61 PUSH2 0x243d 020D 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0201 stack[-1] = 0x0213 // @0204 stack[0] = 0x020e // @0207 stack[1] = msg.data.length // @0208 stack[2] = 0x04 // } // Block ends with call to 0x243d, returns to 0x020E label_020E: // Incoming return from call to 0x243D at 0x020D 020E 5B JUMPDEST 020F 61 PUSH2 0x0610 0212 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0610 label_0213: // Incoming return from call to 0x020E at 0x020D // Incoming return from call to 0x05C2 at 0x05C1 // Inputs[2] // { // @0216 memory[0x40:0x60] // @0217 stack[-1] // } 0213 5B JUMPDEST 0214 60 PUSH1 0x40 0216 51 MLOAD 0217 90 SWAP1 0218 15 ISZERO 0219 15 ISZERO 021A 81 DUP2 021B 52 MSTORE 021C 60 PUSH1 0x20 021E 01 ADD // Stack delta = +0 // Outputs[2] // { // @021B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @021E stack[-1] = 0x20 + memory[0x40:0x60] // } // Block continues label_021F: // Incoming jump from 0x0302 // Incoming jump from 0x0281 // Incoming jump from 0x021E // Inputs[3] // { // @0222 memory[0x40:0x60] // @0224 stack[-1] // @0227 memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 021F 5B JUMPDEST 0220 60 PUSH1 0x40 0222 51 MLOAD 0223 80 DUP1 0224 91 SWAP2 0225 03 SUB 0226 90 SWAP1 0227 F3 *RETURN // Stack delta = -1 // Outputs[1] { @0227 return memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]; } // Block terminates label_0228: // Incoming jump from 0x01D7, if 0x06fdde03 == stack[-1] // Inputs[1] { @0229 msg.value } 0228 5B JUMPDEST 0229 34 CALLVALUE 022A 80 DUP1 022B 15 ISZERO 022C 61 PUSH2 0x0234 022F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0229 stack[0] = msg.value } // Block ends with conditional jump to 0x0234, if !msg.value label_0230: // Incoming jump from 0x022F, if not !msg.value // Inputs[1] { @0233 memory[0x00:0x00] } 0230 60 PUSH1 0x00 0232 80 DUP1 0233 FD *REVERT // Stack delta = +0 // Outputs[1] { @0233 revert(memory[0x00:0x00]); } // Block terminates label_0234: // Incoming jump from 0x022F, if !msg.value 0234 5B JUMPDEST 0235 50 POP 0236 61 PUSH2 0x023d 0239 61 PUSH2 0x063b 023C 56 *JUMP // Stack delta = +0 // Outputs[1] { @0236 stack[-1] = 0x023d } // Block ends with call to 0x063b, returns to 0x023D label_023D: // Incoming jump from 0x02E3 // Incoming return from call to 0x054F at 0x054E // Incoming return from call to 0x063B at 0x023C // Incoming return from call to 0x113C at 0x057D // Incoming return from call to 0x0E46 at 0x04D3 // Inputs[2] // { // @0240 memory[0x40:0x60] // @0244 stack[-1] // } 023D 5B JUMPDEST 023E 60 PUSH1 0x40 0240 51 MLOAD 0241 61 PUSH2 0x021f 0244 91 SWAP2 0245 90 SWAP1 0246 61 PUSH2 0x267d 0249 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0244 stack[-1] = 0x021f // @0245 stack[1] = memory[0x40:0x60] // @0245 stack[0] = stack[-1] // } // Block ends with unconditional jump to 0x267d label_024A: // Incoming jump from 0x01E2, if 0x081812fc == 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 0x026a 025B 61 PUSH2 0x0265 025E 36 CALLDATASIZE 025F 60 PUSH1 0x04 0261 61 PUSH2 0x24bb 0264 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0258 stack[-1] = 0x026a // @025B stack[0] = 0x0265 // @025E stack[1] = msg.data.length // @025F stack[2] = 0x04 // } // Block ends with call to 0x24bb, returns to 0x0265 label_0265: // Incoming return from call to 0x24BB at 0x0264 0265 5B JUMPDEST 0266 61 PUSH2 0x06cd 0269 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x06cd label_026A: // Incoming jump from 0x04BE // Incoming return from call to 0x0411 at 0x0410 // Incoming return from call to 0x0265 at 0x0264 // Incoming jump from 0x0435 // Inputs[2] // { // @026D memory[0x40:0x60] // @0277 stack[-1] // } 026A 5B JUMPDEST 026B 60 PUSH1 0x40 026D 51 MLOAD 026E 60 PUSH1 0x01 0270 60 PUSH1 0x01 0272 60 PUSH1 0xa0 0274 1B SHL 0275 03 SUB 0276 90 SWAP1 0277 91 SWAP2 0278 16 AND 0279 81 DUP2 027A 52 MSTORE 027B 60 PUSH1 0x20 027D 01 ADD 027E 61 PUSH2 0x021f 0281 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @027A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] & (0x01 << 0xa0) - 0x01 // @027D stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x021f label_0282: // Incoming jump from 0x01ED, if 0x095ea7b3 == stack[-1] // Inputs[1] { @0283 msg.value } 0282 5B JUMPDEST 0283 34 CALLVALUE 0284 80 DUP1 0285 15 ISZERO 0286 61 PUSH2 0x028e 0289 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0283 stack[0] = msg.value } // Block ends with conditional jump to 0x028e, if !msg.value label_028A: // Incoming jump from 0x0289, if not !msg.value // Inputs[1] { @028D memory[0x00:0x00] } 028A 60 PUSH1 0x00 028C 80 DUP1 028D FD *REVERT // Stack delta = +0 // Outputs[1] { @028D revert(memory[0x00:0x00]); } // Block terminates label_028E: // Incoming jump from 0x0289, if !msg.value // Inputs[1] { @0296 msg.data.length } 028E 5B JUMPDEST 028F 50 POP 0290 61 PUSH2 0x02a2 0293 61 PUSH2 0x029d 0296 36 CALLDATASIZE 0297 60 PUSH1 0x04 0299 61 PUSH2 0x2414 029C 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0290 stack[-1] = 0x02a2 // @0293 stack[0] = 0x029d // @0296 stack[1] = msg.data.length // @0297 stack[2] = 0x04 // } // Block ends with call to 0x2414, returns to 0x029D label_029D: // Incoming return from call to 0x2414 at 0x029C 029D 5B JUMPDEST 029E 61 PUSH2 0x0767 02A1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0767 label_02A2: // Incoming return from call to 0x029D at 0x029C // Incoming return from call to 0x1026 at 0x0568 // Incoming return from call to 0x05A2 at 0x05A1 // Incoming return from call to 0x050F at 0x050E // Incoming return from call to 0x0B47 at 0x03B5 // Incoming return from call to 0x0D86 at 0x046A 02A2 5B JUMPDEST 02A3 00 *STOP // Stack delta = +0 // Outputs[1] { @02A3 stop(); } // Block terminates label_02A4: // Incoming jump from 0x019B, if 0x0c53c51c == stack[-1] // Inputs[1] { @02AB msg.data.length } 02A4 5B JUMPDEST 02A5 61 PUSH2 0x023d 02A8 61 PUSH2 0x02b2 02AB 36 CALLDATASIZE 02AC 60 PUSH1 0x04 02AE 61 PUSH2 0x239b 02B1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @02A5 stack[0] = 0x023d // @02A8 stack[1] = 0x02b2 // @02AB stack[2] = msg.data.length // @02AC stack[3] = 0x04 // } // Block ends with unconditional jump to 0x239b 02B2 5B JUMPDEST 02B3 61 PUSH2 0x088f 02B6 56 *JUMP label_02B7: // Incoming jump from 0x01A6, if 0x0f7e5970 == stack[-1] // Inputs[1] { @02B8 msg.value } 02B7 5B JUMPDEST 02B8 34 CALLVALUE 02B9 80 DUP1 02BA 15 ISZERO 02BB 61 PUSH2 0x02c3 02BE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02B8 stack[0] = msg.value } // Block ends with conditional jump to 0x02c3, if !msg.value label_02BF: // Incoming jump from 0x02BE, if not !msg.value // Inputs[1] { @02C2 memory[0x00:0x00] } 02BF 60 PUSH1 0x00 02C1 80 DUP1 02C2 FD *REVERT // Stack delta = +0 // Outputs[1] { @02C2 revert(memory[0x00:0x00]); } // Block terminates label_02C3: // Incoming jump from 0x02BE, if !msg.value // Inputs[1] { @02CA memory[0x40:0x60] } 02C3 5B JUMPDEST 02C4 50 POP 02C5 61 PUSH2 0x023d 02C8 60 PUSH1 0x40 02CA 51 MLOAD 02CB 80 DUP1 02CC 60 PUSH1 0x40 02CE 01 ADD 02CF 60 PUSH1 0x40 02D1 52 MSTORE 02D2 80 DUP1 02D3 60 PUSH1 0x01 02D5 81 DUP2 02D6 52 MSTORE 02D7 60 PUSH1 0x20 02D9 01 ADD 02DA 60 PUSH1 0x31 02DC 60 PUSH1 0xf8 02DE 1B SHL 02DF 81 DUP2 02E0 52 MSTORE 02E1 50 POP 02E2 81 DUP2 02E3 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @02C5 stack[-1] = 0x023d // @02CA stack[0] = memory[0x40:0x60] // @02D1 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @02D6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @02E0 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x31 << 0xf8 // } // Block ends with unconditional jump to 0x023d label_02E4: // Incoming jump from 0x01B1, if 0x18160ddd == stack[-1] // Inputs[1] { @02E5 msg.value } 02E4 5B JUMPDEST 02E5 34 CALLVALUE 02E6 80 DUP1 02E7 15 ISZERO 02E8 61 PUSH2 0x02f0 02EB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02E5 stack[0] = msg.value } // Block ends with conditional jump to 0x02f0, if !msg.value label_02EC: // Incoming jump from 0x02EB, if not !msg.value // Inputs[1] { @02EF memory[0x00:0x00] } 02EC 60 PUSH1 0x00 02EE 80 DUP1 02EF FD *REVERT // Stack delta = +0 // Outputs[1] { @02EF revert(memory[0x00:0x00]); } // Block terminates label_02F0: // Incoming jump from 0x02EB, if !msg.value // Inputs[1] { @02F4 storage[0x08] } 02F0 5B JUMPDEST 02F1 50 POP 02F2 60 PUSH1 0x08 02F4 54 SLOAD // Stack delta = +0 // Outputs[1] { @02F4 stack[-1] = storage[0x08] } // Block continues label_02F5: // Incoming jump from 0x0317 // Incoming jump from 0x03A0 // Incoming jump from 0x04A0 // Incoming jump from 0x0593 // Incoming return from call to 0x0353 at 0x0352 // Incoming return from call to 0x03F1 at 0x03F0 // Incoming return from call to 0x0451 at 0x0450 // Incoming return from call to 0x0389 at 0x0388 // Incoming jump from 0x02F4 // Inputs[2] // { // @02F8 memory[0x40:0x60] // @02F9 stack[-1] // } 02F5 5B JUMPDEST 02F6 60 PUSH1 0x40 02F8 51 MLOAD 02F9 90 SWAP1 02FA 81 DUP2 02FB 52 MSTORE 02FC 60 PUSH1 0x20 02FE 01 ADD 02FF 61 PUSH2 0x021f 0302 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @02FB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @02FE stack[-1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x021f label_0303: // Incoming jump from 0x01BC, if 0x20379ee5 == stack[-1] // Inputs[1] { @0304 msg.value } 0303 5B JUMPDEST 0304 34 CALLVALUE 0305 80 DUP1 0306 15 ISZERO 0307 61 PUSH2 0x030f 030A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0304 stack[0] = msg.value } // Block ends with conditional jump to 0x030f, if !msg.value label_030B: // Incoming jump from 0x030A, if not !msg.value // Inputs[1] { @030E memory[0x00:0x00] } 030B 60 PUSH1 0x00 030D 80 DUP1 030E FD *REVERT // Stack delta = +0 // Outputs[1] { @030E revert(memory[0x00:0x00]); } // Block terminates label_030F: // Incoming jump from 0x030A, if !msg.value // Inputs[1] { @0313 storage[0x0b] } 030F 5B JUMPDEST 0310 50 POP 0311 60 PUSH1 0x0b 0313 54 SLOAD 0314 61 PUSH2 0x02f5 0317 56 *JUMP // Stack delta = +0 // Outputs[1] { @0313 stack[-1] = storage[0x0b] } // Block ends with unconditional jump to 0x02f5 label_0318: // Incoming jump from 0x015F, if 0x23b872dd == stack[-1] // Inputs[1] { @0319 msg.value } 0318 5B JUMPDEST 0319 34 CALLVALUE 031A 80 DUP1 031B 15 ISZERO 031C 61 PUSH2 0x0324 031F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0319 stack[0] = msg.value } // Block ends with conditional jump to 0x0324, if !msg.value label_0320: // Incoming jump from 0x031F, if not !msg.value // Inputs[1] { @0323 memory[0x00:0x00] } 0320 60 PUSH1 0x00 0322 80 DUP1 0323 FD *REVERT // Stack delta = +0 // Outputs[1] { @0323 revert(memory[0x00:0x00]); } // Block terminates label_0324: // Incoming jump from 0x031F, if !msg.value // Inputs[1] { @032C msg.data.length } 0324 5B JUMPDEST 0325 50 POP 0326 61 PUSH2 0x02a2 0329 61 PUSH2 0x0333 032C 36 CALLDATASIZE 032D 60 PUSH1 0x04 032F 61 PUSH2 0x22c0 0332 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0326 stack[-1] = 0x02a2 // @0329 stack[0] = 0x0333 // @032C stack[1] = msg.data.length // @032D stack[2] = 0x04 // } // Block ends with call to 0x22c0, returns to 0x0333 label_0333: // Incoming return from call to 0x22C0 at 0x0332 0333 5B JUMPDEST 0334 61 PUSH2 0x0a79 0337 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0a79 label_0338: // Incoming jump from 0x016A, if 0x2d0335ab == stack[-1] // Inputs[1] { @0339 msg.value } 0338 5B JUMPDEST 0339 34 CALLVALUE 033A 80 DUP1 033B 15 ISZERO 033C 61 PUSH2 0x0344 033F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0339 stack[0] = msg.value } // Block ends with conditional jump to 0x0344, if !msg.value label_0340: // Incoming jump from 0x033F, if not !msg.value // Inputs[1] { @0343 memory[0x00:0x00] } 0340 60 PUSH1 0x00 0342 80 DUP1 0343 FD *REVERT // Stack delta = +0 // Outputs[1] { @0343 revert(memory[0x00:0x00]); } // Block terminates label_0344: // Incoming jump from 0x033F, if !msg.value // Inputs[1] { @034C msg.data.length } 0344 5B JUMPDEST 0345 50 POP 0346 61 PUSH2 0x02f5 0349 61 PUSH2 0x0353 034C 36 CALLDATASIZE 034D 60 PUSH1 0x04 034F 61 PUSH2 0x2274 0352 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0346 stack[-1] = 0x02f5 // @0349 stack[0] = 0x0353 // @034C stack[1] = msg.data.length // @034D stack[2] = 0x04 // } // Block ends with call to 0x2274, returns to 0x0353 label_0353: // Incoming return from call to 0x2274 at 0x0352 // Inputs[4] // { // @035C stack[-1] // @036A memory[0x00:0x40] // @036B storage[keccak256(memory[0x00:0x40])] // @036C stack[-2] // } 0353 5B JUMPDEST 0354 60 PUSH1 0x01 0356 60 PUSH1 0x01 0358 60 PUSH1 0xa0 035A 1B SHL 035B 03 SUB 035C 16 AND 035D 60 PUSH1 0x00 035F 90 SWAP1 0360 81 DUP2 0361 52 MSTORE 0362 60 PUSH1 0x0c 0364 60 PUSH1 0x20 0366 52 MSTORE 0367 60 PUSH1 0x40 0369 90 SWAP1 036A 20 SHA3 036B 54 SLOAD 036C 90 SWAP1 036D 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @0361 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0366 memory[0x20:0x40] = 0x0c // @036C stack[-2] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-2] label_036E: // Incoming jump from 0x0175, if 0x2f745c59 == stack[-1] // Inputs[1] { @036F msg.value } 036E 5B JUMPDEST 036F 34 CALLVALUE 0370 80 DUP1 0371 15 ISZERO 0372 61 PUSH2 0x037a 0375 57 *JUMPI // Stack delta = +1 // Outputs[1] { @036F stack[0] = msg.value } // Block ends with conditional jump to 0x037a, if !msg.value label_0376: // Incoming jump from 0x0375, if not !msg.value // Inputs[1] { @0379 memory[0x00:0x00] } 0376 60 PUSH1 0x00 0378 80 DUP1 0379 FD *REVERT // Stack delta = +0 // Outputs[1] { @0379 revert(memory[0x00:0x00]); } // Block terminates label_037A: // Incoming jump from 0x0375, if !msg.value // Inputs[1] { @0382 msg.data.length } 037A 5B JUMPDEST 037B 50 POP 037C 61 PUSH2 0x02f5 037F 61 PUSH2 0x0389 0382 36 CALLDATASIZE 0383 60 PUSH1 0x04 0385 61 PUSH2 0x2414 0388 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @037C stack[-1] = 0x02f5 // @037F stack[0] = 0x0389 // @0382 stack[1] = msg.data.length // @0383 stack[2] = 0x04 // } // Block ends with call to 0x2414, returns to 0x0389 label_0389: // Incoming return from call to 0x2414 at 0x0388 0389 5B JUMPDEST 038A 61 PUSH2 0x0ab1 038D 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ab1 label_038E: // Incoming jump from 0x0180, if 0x3408e470 == stack[-1] // Inputs[1] { @038F msg.value } 038E 5B JUMPDEST 038F 34 CALLVALUE 0390 80 DUP1 0391 15 ISZERO 0392 61 PUSH2 0x039a 0395 57 *JUMPI // Stack delta = +1 // Outputs[1] { @038F stack[0] = msg.value } // Block ends with conditional jump to 0x039a, if !msg.value label_0396: // Incoming jump from 0x0395, if not !msg.value // Inputs[1] { @0399 memory[0x00:0x00] } 0396 60 PUSH1 0x00 0398 80 DUP1 0399 FD *REVERT // Stack delta = +0 // Outputs[1] { @0399 revert(memory[0x00:0x00]); } // Block terminates label_039A: // Incoming jump from 0x0395, if !msg.value // Inputs[1] { @039C CHAINID() } 039A 5B JUMPDEST 039B 50 POP 039C 46 CHAINID 039D 61 PUSH2 0x02f5 03A0 56 *JUMP // Stack delta = +0 // Outputs[1] { @039C stack[-1] = CHAINID() } // Block ends with unconditional jump to 0x02f5 label_03A1: // Incoming jump from 0x012E, if 0x3ccfd60b == stack[-1] // Inputs[1] { @03A2 msg.value } 03A1 5B JUMPDEST 03A2 34 CALLVALUE 03A3 80 DUP1 03A4 15 ISZERO 03A5 61 PUSH2 0x03ad 03A8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03A2 stack[0] = msg.value } // Block ends with conditional jump to 0x03ad, if !msg.value label_03A9: // Incoming jump from 0x03A8, if not !msg.value // Inputs[1] { @03AC memory[0x00:0x00] } 03A9 60 PUSH1 0x00 03AB 80 DUP1 03AC FD *REVERT // Stack delta = +0 // Outputs[1] { @03AC revert(memory[0x00:0x00]); } // Block terminates label_03AD: // Incoming jump from 0x03A8, if !msg.value 03AD 5B JUMPDEST 03AE 50 POP 03AF 61 PUSH2 0x02a2 03B2 61 PUSH2 0x0b47 03B5 56 *JUMP // Stack delta = +0 // Outputs[1] { @03AF stack[-1] = 0x02a2 } // Block ends with call to 0x0b47, returns to 0x02A2 label_03B6: // Incoming jump from 0x0139, if 0x42842e0e == stack[-1] // Inputs[1] { @03B7 msg.value } 03B6 5B JUMPDEST 03B7 34 CALLVALUE 03B8 80 DUP1 03B9 15 ISZERO 03BA 61 PUSH2 0x03c2 03BD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03B7 stack[0] = msg.value } // Block ends with conditional jump to 0x03c2, if !msg.value label_03BE: // Incoming jump from 0x03BD, if not !msg.value // Inputs[1] { @03C1 memory[0x00:0x00] } 03BE 60 PUSH1 0x00 03C0 80 DUP1 03C1 FD *REVERT // Stack delta = +0 // Outputs[1] { @03C1 revert(memory[0x00:0x00]); } // Block terminates label_03C2: // Incoming jump from 0x03BD, if !msg.value // Inputs[1] { @03CA msg.data.length } 03C2 5B JUMPDEST 03C3 50 POP 03C4 61 PUSH2 0x02a2 03C7 61 PUSH2 0x03d1 03CA 36 CALLDATASIZE 03CB 60 PUSH1 0x04 03CD 61 PUSH2 0x22c0 03D0 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03C4 stack[-1] = 0x02a2 // @03C7 stack[0] = 0x03d1 // @03CA stack[1] = msg.data.length // @03CB stack[2] = 0x04 // } // Block ends with call to 0x22c0, returns to 0x03D1 label_03D1: // Incoming return from call to 0x22C0 at 0x03D0 03D1 5B JUMPDEST 03D2 61 PUSH2 0x0bcc 03D5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0bcc label_03D6: // Incoming jump from 0x0144, if 0x4f6ccce7 == stack[-1] // Inputs[1] { @03D7 msg.value } 03D6 5B JUMPDEST 03D7 34 CALLVALUE 03D8 80 DUP1 03D9 15 ISZERO 03DA 61 PUSH2 0x03e2 03DD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03D7 stack[0] = msg.value } // Block ends with conditional jump to 0x03e2, if !msg.value label_03DE: // Incoming jump from 0x03DD, if not !msg.value // Inputs[1] { @03E1 memory[0x00:0x00] } 03DE 60 PUSH1 0x00 03E0 80 DUP1 03E1 FD *REVERT // Stack delta = +0 // Outputs[1] { @03E1 revert(memory[0x00:0x00]); } // Block terminates label_03E2: // Incoming jump from 0x03DD, if !msg.value // Inputs[1] { @03EA msg.data.length } 03E2 5B JUMPDEST 03E3 50 POP 03E4 61 PUSH2 0x02f5 03E7 61 PUSH2 0x03f1 03EA 36 CALLDATASIZE 03EB 60 PUSH1 0x04 03ED 61 PUSH2 0x24bb 03F0 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @03E4 stack[-1] = 0x02f5 // @03E7 stack[0] = 0x03f1 // @03EA stack[1] = msg.data.length // @03EB stack[2] = 0x04 // } // Block ends with call to 0x24bb, returns to 0x03F1 label_03F1: // Incoming return from call to 0x24BB at 0x03F0 03F1 5B JUMPDEST 03F2 61 PUSH2 0x0be7 03F5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0be7 label_03F6: // Incoming jump from 0x014F, if 0x6352211e == stack[-1] // Inputs[1] { @03F7 msg.value } 03F6 5B JUMPDEST 03F7 34 CALLVALUE 03F8 80 DUP1 03F9 15 ISZERO 03FA 61 PUSH2 0x0402 03FD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03F7 stack[0] = msg.value } // Block ends with conditional jump to 0x0402, if !msg.value label_03FE: // Incoming jump from 0x03FD, if not !msg.value // Inputs[1] { @0401 memory[0x00:0x00] } 03FE 60 PUSH1 0x00 0400 80 DUP1 0401 FD *REVERT // Stack delta = +0 // Outputs[1] { @0401 revert(memory[0x00:0x00]); } // Block terminates label_0402: // Incoming jump from 0x03FD, if !msg.value // Inputs[1] { @040A msg.data.length } 0402 5B JUMPDEST 0403 50 POP 0404 61 PUSH2 0x026a 0407 61 PUSH2 0x0411 040A 36 CALLDATASIZE 040B 60 PUSH1 0x04 040D 61 PUSH2 0x24bb 0410 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0404 stack[-1] = 0x026a // @0407 stack[0] = 0x0411 // @040A stack[1] = msg.data.length // @040B stack[2] = 0x04 // } // Block ends with call to 0x24bb, returns to 0x0411 label_0411: // Incoming return from call to 0x24BB at 0x0410 0411 5B JUMPDEST 0412 61 PUSH2 0x0c88 0415 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0c88 label_0416: // Incoming jump from 0x00E7, if 0x66328738 == stack[-1] // Inputs[1] { @0417 msg.value } 0416 5B JUMPDEST 0417 34 CALLVALUE 0418 80 DUP1 0419 15 ISZERO 041A 61 PUSH2 0x0422 041D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0417 stack[0] = msg.value } // Block ends with conditional jump to 0x0422, if !msg.value label_041E: // Incoming jump from 0x041D, if not !msg.value // Inputs[1] { @0421 memory[0x00:0x00] } 041E 60 PUSH1 0x00 0420 80 DUP1 0421 FD *REVERT // Stack delta = +0 // Outputs[1] { @0421 revert(memory[0x00:0x00]); } // Block terminates label_0422: // Incoming jump from 0x041D, if !msg.value // Inputs[1] { @0426 storage[0x13] } 0422 5B JUMPDEST 0423 50 POP 0424 60 PUSH1 0x13 0426 54 SLOAD 0427 61 PUSH2 0x026a 042A 90 SWAP1 042B 60 PUSH1 0x01 042D 60 PUSH1 0x01 042F 60 PUSH1 0xa0 0431 1B SHL 0432 03 SUB 0433 16 AND 0434 81 DUP2 0435 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @042A stack[-1] = 0x026a // @0433 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x13] // } // Block ends with unconditional jump to 0x026a label_0436: // Incoming jump from 0x00F2, if 0x70a08231 == stack[-1] // Inputs[1] { @0437 msg.value } 0436 5B JUMPDEST 0437 34 CALLVALUE 0438 80 DUP1 0439 15 ISZERO 043A 61 PUSH2 0x0442 043D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0437 stack[0] = msg.value } // Block ends with conditional jump to 0x0442, if !msg.value label_043E: // Incoming jump from 0x043D, if not !msg.value // Inputs[1] { @0441 memory[0x00:0x00] } 043E 60 PUSH1 0x00 0440 80 DUP1 0441 FD *REVERT // Stack delta = +0 // Outputs[1] { @0441 revert(memory[0x00:0x00]); } // Block terminates label_0442: // Incoming jump from 0x043D, if !msg.value // Inputs[1] { @044A msg.data.length } 0442 5B JUMPDEST 0443 50 POP 0444 61 PUSH2 0x02f5 0447 61 PUSH2 0x0451 044A 36 CALLDATASIZE 044B 60 PUSH1 0x04 044D 61 PUSH2 0x2274 0450 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0444 stack[-1] = 0x02f5 // @0447 stack[0] = 0x0451 // @044A stack[1] = msg.data.length // @044B stack[2] = 0x04 // } // Block ends with call to 0x2274, returns to 0x0451 label_0451: // Incoming return from call to 0x2274 at 0x0450 0451 5B JUMPDEST 0452 61 PUSH2 0x0cff 0455 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0cff label_0456: // Incoming jump from 0x00FD, if 0x715018a6 == stack[-1] // Inputs[1] { @0457 msg.value } 0456 5B JUMPDEST 0457 34 CALLVALUE 0458 80 DUP1 0459 15 ISZERO 045A 61 PUSH2 0x0462 045D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0457 stack[0] = msg.value } // Block ends with conditional jump to 0x0462, if !msg.value label_045E: // Incoming jump from 0x045D, if not !msg.value // Inputs[1] { @0461 memory[0x00:0x00] } 045E 60 PUSH1 0x00 0460 80 DUP1 0461 FD *REVERT // Stack delta = +0 // Outputs[1] { @0461 revert(memory[0x00:0x00]); } // Block terminates label_0462: // Incoming jump from 0x045D, if !msg.value 0462 5B JUMPDEST 0463 50 POP 0464 61 PUSH2 0x02a2 0467 61 PUSH2 0x0d86 046A 56 *JUMP // Stack delta = +0 // Outputs[1] { @0464 stack[-1] = 0x02a2 } // Block ends with call to 0x0d86, returns to 0x02A2 label_046B: // Incoming jump from 0x0108, if 0x755edd17 == stack[-1] // Inputs[1] { @046C msg.value } 046B 5B JUMPDEST 046C 34 CALLVALUE 046D 80 DUP1 046E 15 ISZERO 046F 61 PUSH2 0x0477 0472 57 *JUMPI // Stack delta = +1 // Outputs[1] { @046C stack[0] = msg.value } // Block ends with conditional jump to 0x0477, if !msg.value label_0473: // Incoming jump from 0x0472, if not !msg.value // Inputs[1] { @0476 memory[0x00:0x00] } 0473 60 PUSH1 0x00 0475 80 DUP1 0476 FD *REVERT // Stack delta = +0 // Outputs[1] { @0476 revert(memory[0x00:0x00]); } // Block terminates label_0477: // Incoming jump from 0x0472, if !msg.value // Inputs[1] { @047F msg.data.length } 0477 5B JUMPDEST 0478 50 POP 0479 61 PUSH2 0x02a2 047C 61 PUSH2 0x0486 047F 36 CALLDATASIZE 0480 60 PUSH1 0x04 0482 61 PUSH2 0x2274 0485 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0479 stack[-1] = 0x02a2 // @047C stack[0] = 0x0486 // @047F stack[1] = msg.data.length // @0480 stack[2] = 0x04 // } // Block ends with call to 0x2274, returns to 0x0486 label_0486: // Incoming return from call to 0x2274 at 0x0485 0486 5B JUMPDEST 0487 61 PUSH2 0x0ddb 048A 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ddb label_048B: // Incoming jump from 0x00B6, if 0x78e97925 == stack[-1] // Inputs[1] { @048C msg.value } 048B 5B JUMPDEST 048C 34 CALLVALUE 048D 80 DUP1 048E 15 ISZERO 048F 61 PUSH2 0x0497 0492 57 *JUMPI // Stack delta = +1 // Outputs[1] { @048C stack[0] = msg.value } // Block ends with conditional jump to 0x0497, if !msg.value label_0493: // Incoming jump from 0x0492, if not !msg.value // Inputs[1] { @0496 memory[0x00:0x00] } 0493 60 PUSH1 0x00 0495 80 DUP1 0496 FD *REVERT // Stack delta = +0 // Outputs[1] { @0496 revert(memory[0x00:0x00]); } // Block terminates label_0497: // Incoming jump from 0x0492, if !msg.value // Inputs[1] { @049E storage[0x12] } 0497 5B JUMPDEST 0498 50 POP 0499 61 PUSH2 0x02f5 049C 60 PUSH1 0x12 049E 54 SLOAD 049F 81 DUP2 04A0 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0499 stack[-1] = 0x02f5 // @049E stack[0] = storage[0x12] // } // Block ends with unconditional jump to 0x02f5 label_04A1: // Incoming jump from 0x00C1, if 0x8da5cb5b == stack[-1] // Inputs[1] { @04A2 msg.value } 04A1 5B JUMPDEST 04A2 34 CALLVALUE 04A3 80 DUP1 04A4 15 ISZERO 04A5 61 PUSH2 0x04ad 04A8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04A2 stack[0] = msg.value } // Block ends with conditional jump to 0x04ad, if !msg.value label_04A9: // Incoming jump from 0x04A8, if not !msg.value // Inputs[1] { @04AC memory[0x00:0x00] } 04A9 60 PUSH1 0x00 04AB 80 DUP1 04AC FD *REVERT // Stack delta = +0 // Outputs[1] { @04AC revert(memory[0x00:0x00]); } // Block terminates label_04AD: // Incoming jump from 0x04A8, if !msg.value // Inputs[1] { @04B1 storage[0x0d] } 04AD 5B JUMPDEST 04AE 50 POP 04AF 60 PUSH1 0x0d 04B1 54 SLOAD 04B2 60 PUSH1 0x01 04B4 60 PUSH1 0x01 04B6 60 PUSH1 0xa0 04B8 1B SHL 04B9 03 SUB 04BA 16 AND 04BB 61 PUSH2 0x026a 04BE 56 *JUMP // Stack delta = +0 // Outputs[1] { @04BA stack[-1] = (0x01 << 0xa0) - 0x01 & storage[0x0d] } // Block ends with unconditional jump to 0x026a label_04BF: // Incoming jump from 0x00CC, if 0x95d89b41 == stack[-1] // Inputs[1] { @04C0 msg.value } 04BF 5B JUMPDEST 04C0 34 CALLVALUE 04C1 80 DUP1 04C2 15 ISZERO 04C3 61 PUSH2 0x04cb 04C6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04C0 stack[0] = msg.value } // Block ends with conditional jump to 0x04cb, if !msg.value label_04C7: // Incoming jump from 0x04C6, if not !msg.value // Inputs[1] { @04CA memory[0x00:0x00] } 04C7 60 PUSH1 0x00 04C9 80 DUP1 04CA FD *REVERT // Stack delta = +0 // Outputs[1] { @04CA revert(memory[0x00:0x00]); } // Block terminates label_04CB: // Incoming jump from 0x04C6, if !msg.value 04CB 5B JUMPDEST 04CC 50 POP 04CD 61 PUSH2 0x023d 04D0 61 PUSH2 0x0e46 04D3 56 *JUMP // Stack delta = +0 // Outputs[1] { @04CD stack[-1] = 0x023d } // Block ends with call to 0x0e46, returns to 0x023D label_04D4: // Incoming jump from 0x00D7, if 0xa0bcfc7f == stack[-1] // Inputs[1] { @04D5 msg.value } 04D4 5B JUMPDEST 04D5 34 CALLVALUE 04D6 80 DUP1 04D7 15 ISZERO 04D8 61 PUSH2 0x04e0 04DB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04D5 stack[0] = msg.value } // Block ends with conditional jump to 0x04e0, if !msg.value label_04DC: // Incoming jump from 0x04DB, if not !msg.value // Inputs[1] { @04DF memory[0x00:0x00] } 04DC 60 PUSH1 0x00 04DE 80 DUP1 04DF FD *REVERT // Stack delta = +0 // Outputs[1] { @04DF revert(memory[0x00:0x00]); } // Block terminates label_04E0: // Incoming jump from 0x04DB, if !msg.value // Inputs[1] { @04E8 msg.data.length } 04E0 5B JUMPDEST 04E1 50 POP 04E2 61 PUSH2 0x02a2 04E5 61 PUSH2 0x04ef 04E8 36 CALLDATASIZE 04E9 60 PUSH1 0x04 04EB 61 PUSH2 0x2475 04EE 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @04E2 stack[-1] = 0x02a2 // @04E5 stack[0] = 0x04ef // @04E8 stack[1] = msg.data.length // @04E9 stack[2] = 0x04 // } // Block ends with call to 0x2475, returns to 0x04EF label_04EF: // Incoming return from call to 0x2475 at 0x04EE 04EF 5B JUMPDEST 04F0 61 PUSH2 0x0e55 04F3 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0e55 label_04F4: // Incoming jump from 0x007A, if 0xa22cb465 == stack[-1] // Inputs[1] { @04F5 msg.value } 04F4 5B JUMPDEST 04F5 34 CALLVALUE 04F6 80 DUP1 04F7 15 ISZERO 04F8 61 PUSH2 0x0500 04FB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04F5 stack[0] = msg.value } // Block ends with conditional jump to 0x0500, if !msg.value label_04FC: // Incoming jump from 0x04FB, if not !msg.value // Inputs[1] { @04FF memory[0x00:0x00] } 04FC 60 PUSH1 0x00 04FE 80 DUP1 04FF FD *REVERT // Stack delta = +0 // Outputs[1] { @04FF revert(memory[0x00:0x00]); } // Block terminates label_0500: // Incoming jump from 0x04FB, if !msg.value // Inputs[1] { @0508 msg.data.length } 0500 5B JUMPDEST 0501 50 POP 0502 61 PUSH2 0x02a2 0505 61 PUSH2 0x050f 0508 36 CALLDATASIZE 0509 60 PUSH1 0x04 050B 61 PUSH2 0x2361 050E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0502 stack[-1] = 0x02a2 // @0505 stack[0] = 0x050f // @0508 stack[1] = msg.data.length // @0509 stack[2] = 0x04 // } // Block ends with call to 0x2361, returns to 0x050F label_050F: // Incoming return from call to 0x2361 at 0x050E 050F 5B JUMPDEST 0510 61 PUSH2 0x0eb1 0513 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0eb1 label_0514: // Incoming jump from 0x0085, if 0xb88d4fde == stack[-1] // Inputs[1] { @0515 msg.value } 0514 5B JUMPDEST 0515 34 CALLVALUE 0516 80 DUP1 0517 15 ISZERO 0518 61 PUSH2 0x0520 051B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0515 stack[0] = msg.value } // Block ends with conditional jump to 0x0520, if !msg.value label_051C: // Incoming jump from 0x051B, if not !msg.value // Inputs[1] { @051F memory[0x00:0x00] } 051C 60 PUSH1 0x00 051E 80 DUP1 051F FD *REVERT // Stack delta = +0 // Outputs[1] { @051F revert(memory[0x00:0x00]); } // Block terminates label_0520: // Incoming jump from 0x051B, if !msg.value // Inputs[1] { @0528 msg.data.length } 0520 5B JUMPDEST 0521 50 POP 0522 61 PUSH2 0x02a2 0525 61 PUSH2 0x052f 0528 36 CALLDATASIZE 0529 60 PUSH1 0x04 052B 61 PUSH2 0x22fb 052E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0522 stack[-1] = 0x02a2 // @0525 stack[0] = 0x052f // @0528 stack[1] = msg.data.length // @0529 stack[2] = 0x04 // } // Block ends with unconditional jump to 0x22fb 052F 5B JUMPDEST 0530 61 PUSH2 0x0fb3 0533 56 *JUMP label_0534: // Incoming jump from 0x0090, if 0xc87b56dd == stack[-1] // Inputs[1] { @0535 msg.value } 0534 5B JUMPDEST 0535 34 CALLVALUE 0536 80 DUP1 0537 15 ISZERO 0538 61 PUSH2 0x0540 053B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0535 stack[0] = msg.value } // Block ends with conditional jump to 0x0540, if !msg.value label_053C: // Incoming jump from 0x053B, if not !msg.value // Inputs[1] { @053F memory[0x00:0x00] } 053C 60 PUSH1 0x00 053E 80 DUP1 053F FD *REVERT // Stack delta = +0 // Outputs[1] { @053F revert(memory[0x00:0x00]); } // Block terminates label_0540: // Incoming jump from 0x053B, if !msg.value // Inputs[1] { @0548 msg.data.length } 0540 5B JUMPDEST 0541 50 POP 0542 61 PUSH2 0x023d 0545 61 PUSH2 0x054f 0548 36 CALLDATASIZE 0549 60 PUSH1 0x04 054B 61 PUSH2 0x24bb 054E 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @0542 stack[-1] = 0x023d // @0545 stack[0] = 0x054f // @0548 stack[1] = msg.data.length // @0549 stack[2] = 0x04 // } // Block ends with call to 0x24bb, returns to 0x054F label_054F: // Incoming return from call to 0x24BB at 0x054E 054F 5B JUMPDEST 0550 61 PUSH2 0x0ff2 0553 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x0ff2 label_0554: // Incoming jump from 0x009B, if 0xca5d0880 == stack[-1] // Inputs[1] { @0555 msg.value } 0554 5B JUMPDEST 0555 34 CALLVALUE 0556 80 DUP1 0557 15 ISZERO 0558 61 PUSH2 0x0560 055B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0555 stack[0] = msg.value } // Block ends with conditional jump to 0x0560, if !msg.value label_055C: // Incoming jump from 0x055B, if not !msg.value // Inputs[1] { @055F memory[0x00:0x00] } 055C 60 PUSH1 0x00 055E 80 DUP1 055F FD *REVERT // Stack delta = +0 // Outputs[1] { @055F revert(memory[0x00:0x00]); } // Block terminates label_0560: // Incoming jump from 0x055B, if !msg.value 0560 5B JUMPDEST 0561 50 POP 0562 61 PUSH2 0x02a2 0565 61 PUSH2 0x1026 0568 56 *JUMP // Stack delta = +0 // Outputs[1] { @0562 stack[-1] = 0x02a2 } // Block ends with call to 0x1026, returns to 0x02A2 label_0569: // Incoming jump from 0x003E, if 0xd547cfb7 == stack[-1] // Inputs[1] { @056A msg.value } 0569 5B JUMPDEST 056A 34 CALLVALUE 056B 80 DUP1 056C 15 ISZERO 056D 61 PUSH2 0x0575 0570 57 *JUMPI // Stack delta = +1 // Outputs[1] { @056A stack[0] = msg.value } // Block ends with conditional jump to 0x0575, if !msg.value label_0571: // Incoming jump from 0x0570, if not !msg.value // Inputs[1] { @0574 memory[0x00:0x00] } 0571 60 PUSH1 0x00 0573 80 DUP1 0574 FD *REVERT // Stack delta = +0 // Outputs[1] { @0574 revert(memory[0x00:0x00]); } // Block terminates label_0575: // Incoming jump from 0x0570, if !msg.value 0575 5B JUMPDEST 0576 50 POP 0577 61 PUSH2 0x023d 057A 61 PUSH2 0x113c 057D 56 *JUMP // Stack delta = +0 // Outputs[1] { @0577 stack[-1] = 0x023d } // Block ends with call to 0x113c, returns to 0x023D label_057E: // Incoming jump from 0x0049, if 0xd94b7243 == stack[-1] // Inputs[1] { @057F msg.value } 057E 5B JUMPDEST 057F 34 CALLVALUE 0580 80 DUP1 0581 15 ISZERO 0582 61 PUSH2 0x058a 0585 57 *JUMPI // Stack delta = +1 // Outputs[1] { @057F stack[0] = msg.value } // Block ends with conditional jump to 0x058a, if !msg.value label_0586: // Incoming jump from 0x0585, if not !msg.value // Inputs[1] { @0589 memory[0x00:0x00] } 0586 60 PUSH1 0x00 0588 80 DUP1 0589 FD *REVERT // Stack delta = +0 // Outputs[1] { @0589 revert(memory[0x00:0x00]); } // Block terminates label_058A: // Incoming jump from 0x0585, if !msg.value // Inputs[1] { @0591 storage[0x11] } 058A 5B JUMPDEST 058B 50 POP 058C 61 PUSH2 0x02f5 058F 60 PUSH1 0x11 0591 54 SLOAD 0592 81 DUP2 0593 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @058C stack[-1] = 0x02f5 // @0591 stack[0] = storage[0x11] // } // Block ends with unconditional jump to 0x02f5 label_0594: // Incoming jump from 0x0054, if 0xd96a094a == stack[-1] // Inputs[1] { @059B msg.data.length } 0594 5B JUMPDEST 0595 61 PUSH2 0x02a2 0598 61 PUSH2 0x05a2 059B 36 CALLDATASIZE 059C 60 PUSH1 0x04 059E 61 PUSH2 0x24bb 05A1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0595 stack[0] = 0x02a2 // @0598 stack[1] = 0x05a2 // @059B stack[2] = msg.data.length // @059C stack[3] = 0x04 // } // Block ends with call to 0x24bb, returns to 0x05A2 label_05A2: // Incoming return from call to 0x24BB at 0x05A1 05A2 5B JUMPDEST 05A3 61 PUSH2 0x11ca 05A6 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x11ca label_05A7: // Incoming jump from 0x005F, if 0xe985e9c5 == stack[-1] // Inputs[1] { @05A8 msg.value } 05A7 5B JUMPDEST 05A8 34 CALLVALUE 05A9 80 DUP1 05AA 15 ISZERO 05AB 61 PUSH2 0x05b3 05AE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05A8 stack[0] = msg.value } // Block ends with conditional jump to 0x05b3, if !msg.value label_05AF: // Incoming jump from 0x05AE, if not !msg.value // Inputs[1] { @05B2 memory[0x00:0x00] } 05AF 60 PUSH1 0x00 05B1 80 DUP1 05B2 FD *REVERT // Stack delta = +0 // Outputs[1] { @05B2 revert(memory[0x00:0x00]); } // Block terminates label_05B3: // Incoming jump from 0x05AE, if !msg.value // Inputs[1] { @05BB msg.data.length } 05B3 5B JUMPDEST 05B4 50 POP 05B5 61 PUSH2 0x0213 05B8 61 PUSH2 0x05c2 05BB 36 CALLDATASIZE 05BC 60 PUSH1 0x04 05BE 61 PUSH2 0x228e 05C1 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05B5 stack[-1] = 0x0213 // @05B8 stack[0] = 0x05c2 // @05BB stack[1] = msg.data.length // @05BC stack[2] = 0x04 // } // Block ends with call to 0x228e, returns to 0x05C2 label_05C2: // Incoming return from call to 0x13E6 at 0x080D // Incoming return from call to 0x228E at 0x05C1 // Inputs[6] // { // @05CB stack[-2] // @05DE memory[0x00:0x40] // @05DF stack[-1] // @05E9 memory[0x00:0x40] // @05EA storage[keccak256(memory[0x00:0x40])] // @05EE stack[-3] // } 05C2 5B JUMPDEST 05C3 60 PUSH1 0x01 05C5 60 PUSH1 0x01 05C7 60 PUSH1 0xa0 05C9 1B SHL 05CA 03 SUB 05CB 91 SWAP2 05CC 82 DUP3 05CD 16 AND 05CE 60 PUSH1 0x00 05D0 90 SWAP1 05D1 81 DUP2 05D2 52 MSTORE 05D3 60 PUSH1 0x05 05D5 60 PUSH1 0x20 05D7 90 SWAP1 05D8 81 DUP2 05D9 52 MSTORE 05DA 60 PUSH1 0x40 05DC 80 DUP1 05DD 83 DUP4 05DE 20 SHA3 05DF 93 SWAP4 05E0 90 SWAP1 05E1 94 SWAP5 05E2 16 AND 05E3 82 DUP3 05E4 52 MSTORE 05E5 91 SWAP2 05E6 90 SWAP1 05E7 91 SWAP2 05E8 52 MSTORE 05E9 20 SHA3 05EA 54 SLOAD 05EB 60 PUSH1 0xff 05ED 16 AND 05EE 90 SWAP1 05EF 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @05D2 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @05D9 memory[0x20:0x40] = 0x05 // @05E4 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @05E8 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @05EE stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_05F0: // Incoming jump from 0x006A, if 0xf2fde38b == stack[-1] // Inputs[1] { @05F1 msg.value } 05F0 5B JUMPDEST 05F1 34 CALLVALUE 05F2 80 DUP1 05F3 15 ISZERO 05F4 61 PUSH2 0x05fc 05F7 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05F1 stack[0] = msg.value } // Block ends with conditional jump to 0x05fc, if !msg.value label_05F8: // Incoming jump from 0x05F7, if not !msg.value // Inputs[1] { @05FB memory[0x00:0x00] } 05F8 60 PUSH1 0x00 05FA 80 DUP1 05FB FD *REVERT // Stack delta = +0 // Outputs[1] { @05FB revert(memory[0x00:0x00]); } // Block terminates label_05FC: // Incoming jump from 0x05F7, if !msg.value // Inputs[1] { @0604 msg.data.length } 05FC 5B JUMPDEST 05FD 50 POP 05FE 61 PUSH2 0x02a2 0601 61 PUSH2 0x060b 0604 36 CALLDATASIZE 0605 60 PUSH1 0x04 0607 61 PUSH2 0x2274 060A 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @05FE stack[-1] = 0x02a2 // @0601 stack[0] = 0x060b // @0604 stack[1] = msg.data.length // @0605 stack[2] = 0x04 // } // Block ends with call to 0x2274, returns to 0x060B label_060B: // Incoming return from call to 0x2274 at 0x060A 060B 5B JUMPDEST 060C 61 PUSH2 0x1282 060F 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1282 label_0610: // Incoming jump from 0x0212 // Inputs[1] { @061C stack[-1] } 0610 5B JUMPDEST 0611 60 PUSH1 0x00 0613 60 PUSH1 0x01 0615 60 PUSH1 0x01 0617 60 PUSH1 0xe0 0619 1B SHL 061A 03 SUB 061B 19 NOT 061C 82 DUP3 061D 16 AND 061E 63 PUSH4 0x780e9d63 0623 60 PUSH1 0xe0 0625 1B SHL 0626 14 EQ 0627 80 DUP1 0628 61 PUSH2 0x0635 062B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0611 stack[0] = 0x00 // @0626 stack[1] = 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x0635, if 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_062C: // Incoming jump from 0x062B, if not 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @0630 stack[-3] } 062C 50 POP 062D 61 PUSH2 0x0635 0630 82 DUP3 0631 61 PUSH2 0x1396 0634 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @062D stack[-1] = 0x0635 // @0630 stack[0] = stack[-3] // } // Block ends with call to 0x1396, returns to 0x0635 label_0635: // Incoming return from call to 0x1396 at 0x0634 // Incoming jump from 0x13CC, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x13CC, if stack[-1] // Incoming jump from 0x13E5 // Incoming jump from 0x0CA5, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Incoming jump from 0x062B, if 0x780e9d63 << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[3] // { // @0636 stack[-4] // @0636 stack[-1] // @0637 stack[-3] // } 0635 5B JUMPDEST 0636 92 SWAP3 0637 91 SWAP2 0638 50 POP 0639 50 POP 063A 56 *JUMP // Stack delta = -3 // Outputs[1] { @0636 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_063B: // Incoming call from 0x023C, returns to 0x023D // Inputs[1] { @0641 storage[0x00] } 063B 5B JUMPDEST 063C 60 PUSH1 0x60 063E 60 PUSH1 0x00 0640 80 DUP1 0641 54 SLOAD 0642 61 PUSH2 0x064a 0645 90 SWAP1 0646 61 PUSH2 0x27f6 0649 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @063C stack[0] = 0x60 // @063E stack[1] = 0x00 // @0645 stack[2] = 0x064a // @0645 stack[3] = storage[0x00] // } // Block ends with call to 0x27f6, returns to 0x064A label_064A: // Incoming return from call to 0x27F6 at 0x0E54 // Incoming return from call to 0x27F6 at 0x0649 // Inputs[4] // { // @064B stack[-1] // @065A memory[0x40:0x60] // @0662 stack[-2] // @066D storage[stack[-2]] // } 064A 5B JUMPDEST 064B 80 DUP1 064C 60 PUSH1 0x1f 064E 01 ADD 064F 60 PUSH1 0x20 0651 80 DUP1 0652 91 SWAP2 0653 04 DIV 0654 02 MUL 0655 60 PUSH1 0x20 0657 01 ADD 0658 60 PUSH1 0x40 065A 51 MLOAD 065B 90 SWAP1 065C 81 DUP2 065D 01 ADD 065E 60 PUSH1 0x40 0660 52 MSTORE 0661 80 DUP1 0662 92 SWAP3 0663 91 SWAP2 0664 90 SWAP1 0665 81 DUP2 0666 81 DUP2 0667 52 MSTORE 0668 60 PUSH1 0x20 066A 01 ADD 066B 82 DUP3 066C 80 DUP1 066D 54 SLOAD 066E 61 PUSH2 0x0676 0671 90 SWAP1 0672 61 PUSH2 0x27f6 0675 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @0660 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @0662 stack[-2] = memory[0x40:0x60] // @0663 stack[-1] = stack[-2] // @0664 stack[0] = stack[-1] // @0667 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @066A stack[1] = 0x20 + memory[0x40:0x60] // @066B stack[2] = stack[-2] // @0671 stack[4] = storage[stack[-2]] // @0671 stack[3] = 0x0676 // } // Block ends with call to 0x27f6, returns to 0x0676 label_0676: // Incoming return from call to 0x27F6 at 0x0675 // Inputs[1] { @0677 stack[-1] } 0676 5B JUMPDEST 0677 80 DUP1 0678 15 ISZERO 0679 61 PUSH2 0x06c3 067C 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06c3, if !stack[-1] label_067D: // Incoming jump from 0x067C, if not !stack[-1] // Inputs[1] { @067D stack[-1] } 067D 80 DUP1 067E 60 PUSH1 0x1f 0680 10 LT 0681 61 PUSH2 0x0698 0684 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0698, if 0x1f < stack[-1] label_0685: // Incoming jump from 0x0684, if not 0x1f < stack[-1] // Inputs[4] // { // @0689 stack[-2] // @068A storage[stack[-2]] // @068D stack[-3] // @068F stack[-1] // } 0685 61 PUSH2 0x0100 0688 80 DUP1 0689 83 DUP4 068A 54 SLOAD 068B 04 DIV 068C 02 MUL 068D 83 DUP4 068E 52 MSTORE 068F 91 SWAP2 0690 60 PUSH1 0x20 0692 01 ADD 0693 91 SWAP2 0694 61 PUSH2 0x06c3 0697 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @068E memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @0693 stack[-1] = stack[-1] // @0693 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x06c3 label_0698: // Incoming jump from 0x0684, if 0x1f < stack[-1] // Inputs[5] // { // @0699 stack[-3] // @069A stack[-1] // @069C stack[-2] // @06A4 memory[0x00:0x20] // @06A8 storage[keccak256(memory[0x00:0x20])] // } 0698 5B JUMPDEST 0699 82 DUP3 069A 01 ADD 069B 91 SWAP2 069C 90 SWAP1 069D 60 PUSH1 0x00 069F 52 MSTORE 06A0 60 PUSH1 0x20 06A2 60 PUSH1 0x00 06A4 20 SHA3 06A5 90 SWAP1 06A6 5B JUMPDEST 06A7 81 DUP2 06A8 54 SLOAD 06A9 81 DUP2 06AA 52 MSTORE 06AB 90 SWAP1 06AC 60 PUSH1 0x01 06AE 01 ADD 06AF 90 SWAP1 06B0 60 PUSH1 0x20 06B2 01 ADD 06B3 80 DUP1 06B4 83 DUP4 06B5 11 GT 06B6 61 PUSH2 0x06a6 06B9 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @069B stack[-3] = stack[-3] + stack[-1] // @069F memory[0x00:0x20] = stack[-2] // @06AA memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @06AF stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @06B2 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x06a6, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_06BA: // Incoming jump from 0x06B9, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x06B9, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @06BA stack[-3] // @06BB stack[-1] // } 06BA 82 DUP3 06BB 90 SWAP1 06BC 03 SUB 06BD 60 PUSH1 0x1f 06BF 16 AND 06C0 82 DUP3 06C1 01 ADD 06C2 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @06C2 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @06C2 stack[-1] = stack[-3] // } // Block continues label_06C3: // Incoming jump from 0x0697 // Incoming jump from 0x06C2 // Incoming jump from 0x067C, if !stack[-1] // Inputs[3] // { // @06C9 stack[-6] // @06C9 stack[-7] // @06CB stack[-8] // } 06C3 5B JUMPDEST 06C4 50 POP 06C5 50 POP 06C6 50 POP 06C7 50 POP 06C8 50 POP 06C9 90 SWAP1 06CA 50 POP 06CB 90 SWAP1 06CC 56 *JUMP // Stack delta = -7 // Outputs[1] { @06CB stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_06CD: // Incoming jump from 0x0269 // Incoming call from 0x1619, returns to 0x161A // Inputs[3] // { // @06D0 stack[-1] // @06DB memory[0x00:0x40] // @06DC storage[keccak256(memory[0x00:0x40])] // } 06CD 5B JUMPDEST 06CE 60 PUSH1 0x00 06D0 81 DUP2 06D1 81 DUP2 06D2 52 MSTORE 06D3 60 PUSH1 0x02 06D5 60 PUSH1 0x20 06D7 52 MSTORE 06D8 60 PUSH1 0x40 06DA 81 DUP2 06DB 20 SHA3 06DC 54 SLOAD 06DD 60 PUSH1 0x01 06DF 60 PUSH1 0x01 06E1 60 PUSH1 0xa0 06E3 1B SHL 06E4 03 SUB 06E5 16 AND 06E6 61 PUSH2 0x074b 06E9 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @06CE stack[0] = 0x00 // @06D2 memory[0x00:0x20] = stack[-1] // @06D7 memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x074b, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_06EA: // Incoming jump from 0x06E9, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @06EC memory[0x40:0x60] } 06EA 60 PUSH1 0x40 06EC 51 MLOAD 06ED 62 PUSH3 0x461bcd 06F1 60 PUSH1 0xe5 06F3 1B SHL 06F4 81 DUP2 06F5 52 MSTORE 06F6 60 PUSH1 0x20 06F8 60 PUSH1 0x04 06FA 82 DUP3 06FB 01 ADD 06FC 52 MSTORE 06FD 60 PUSH1 0x2c 06FF 60 PUSH1 0x24 0701 82 DUP3 0702 01 ADD 0703 52 MSTORE 0704 7F PUSH32 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 0725 60 PUSH1 0x44 0727 82 DUP3 0728 01 ADD 0729 52 MSTORE 072A 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 0737 60 PUSH1 0xa1 0739 1B SHL 073A 60 PUSH1 0x64 073C 82 DUP3 073D 01 ADD 073E 52 MSTORE 073F 60 PUSH1 0x84 0741 01 ADD // Stack delta = +1 // Outputs[6] // { // @06F5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @06FC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0703 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2c // @0729 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f76656420717565727920666f72206e6f6e6578 // @073E memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x34b9ba32b73a103a37b5b2b7 << 0xa1 // @0741 stack[0] = 0x84 + memory[0x40:0x60] // } // Block continues label_0742: // Incoming jump from 0x07DF // Incoming return from call to 0x26E2 at 0x0DCE // Incoming return from call to 0x26E2 at 0x0E23 // Incoming return from call to 0x2690 at 0x1F42 // Incoming jump from 0x1739 // Incoming jump from 0x0C54 // Incoming jump from 0x0F19 // Incoming jump from 0x16D7 // Incoming jump from 0x15DE // Incoming jump from 0x132F // Incoming return from call to 0x26E2 at 0x0E9D // Incoming return from call to 0x26E2 at 0x0B8F // Incoming return from call to 0x2717 at 0x0FDF // Incoming jump from 0x0CFE // Incoming jump from 0x0741 // Incoming return from call to 0x2717 at 0x0AA5 // Incoming jump from 0x087F // Incoming return from call to 0x26E2 at 0x106E // Incoming jump from 0x120F // Incoming return from call to 0x2690 at 0x1BDC // Incoming jump from 0x0D69 // Incoming jump from 0x0B1D // Incoming return from call to 0x26E2 at 0x12CA // Inputs[3] // { // @0745 memory[0x40:0x60] // @0747 stack[-1] // @074A memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // } 0742 5B JUMPDEST 0743 60 PUSH1 0x40 0745 51 MLOAD 0746 80 DUP1 0747 91 SWAP2 0748 03 SUB 0749 90 SWAP1 074A FD *REVERT // Stack delta = -1 // Outputs[1] { @074A revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]]); } // Block terminates label_074B: // Incoming jump from 0x06E9, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[4] // { // @074F stack[-2] // @075A memory[0x00:0x40] // @075B storage[keccak256(memory[0x00:0x40])] // @0765 stack[-3] // } 074B 5B JUMPDEST 074C 50 POP 074D 60 PUSH1 0x00 074F 90 SWAP1 0750 81 DUP2 0751 52 MSTORE 0752 60 PUSH1 0x04 0754 60 PUSH1 0x20 0756 52 MSTORE 0757 60 PUSH1 0x40 0759 90 SWAP1 075A 20 SHA3 075B 54 SLOAD 075C 60 PUSH1 0x01 075E 60 PUSH1 0x01 0760 60 PUSH1 0xa0 0762 1B SHL 0763 03 SUB 0764 16 AND 0765 90 SWAP1 0766 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0751 memory[0x00:0x20] = stack[-2] // @0756 memory[0x20:0x40] = 0x04 // @0765 stack[-3] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0767: // Incoming jump from 0x02A1 // Inputs[1] { @076D stack[-1] } 0767 5B JUMPDEST 0768 60 PUSH1 0x00 076A 61 PUSH2 0x0772 076D 82 DUP3 076E 61 PUSH2 0x0c88 0771 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0768 stack[0] = 0x00 // @076A stack[1] = 0x0772 // @076D stack[2] = stack[-1] // } // Block ends with call to 0x0c88, returns to 0x0772 label_0772: // Incoming return from call to 0x0C88 at 0x0771 // Inputs[3] // { // @0773 stack[-1] // @0773 stack[-2] // @077F stack[-4] // } 0772 5B JUMPDEST 0773 90 SWAP1 0774 50 POP 0775 80 DUP1 0776 60 PUSH1 0x01 0778 60 PUSH1 0x01 077A 60 PUSH1 0xa0 077C 1B SHL 077D 03 SUB 077E 16 AND 077F 83 DUP4 0780 60 PUSH1 0x01 0782 60 PUSH1 0x01 0784 60 PUSH1 0xa0 0786 1B SHL 0787 03 SUB 0788 16 AND 0789 14 EQ 078A 15 ISZERO 078B 61 PUSH2 0x07e0 078E 57 *JUMPI // Stack delta = -1 // Outputs[1] { @0773 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x07e0, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_078F: // Incoming jump from 0x078E, if not !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @0791 memory[0x40:0x60] } 078F 60 PUSH1 0x40 0791 51 MLOAD 0792 62 PUSH3 0x461bcd 0796 60 PUSH1 0xe5 0798 1B SHL 0799 81 DUP2 079A 52 MSTORE 079B 60 PUSH1 0x20 079D 60 PUSH1 0x04 079F 82 DUP3 07A0 01 ADD 07A1 52 MSTORE 07A2 60 PUSH1 0x21 07A4 60 PUSH1 0x24 07A6 82 DUP3 07A7 01 ADD 07A8 52 MSTORE 07A9 7F PUSH32 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 07CA 60 PUSH1 0x44 07CC 82 DUP3 07CD 01 ADD 07CE 52 MSTORE 07CF 60 PUSH1 0x39 07D1 60 PUSH1 0xf9 07D3 1B SHL 07D4 60 PUSH1 0x64 07D6 82 DUP3 07D7 01 ADD 07D8 52 MSTORE 07D9 60 PUSH1 0x84 07DB 01 ADD 07DC 61 PUSH2 0x0742 07DF 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @079A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @07A1 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @07A8 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x21 // @07CE memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f76616c20746f2063757272656e74206f776e65 // @07D8 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x39 << 0xf9 // @07DB stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0742 label_07E0: // Incoming jump from 0x078E, if !((0x01 << 0xa0) - 0x01 & stack[-4] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @07E1 stack[-1] } 07E0 5B JUMPDEST 07E1 80 DUP1 07E2 60 PUSH1 0x01 07E4 60 PUSH1 0x01 07E6 60 PUSH1 0xa0 07E8 1B SHL 07E9 03 SUB 07EA 16 AND 07EB 61 PUSH2 0x07f2 07EE 61 PUSH2 0x13e6 07F1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @07EA stack[0] = (0x01 << 0xa0) - 0x01 & stack[-1] // @07EB stack[1] = 0x07f2 // } // Block ends with call to 0x13e6, returns to 0x07F2 label_07F2: // Incoming return from call to 0x13E6 at 0x07F1 // Inputs[2] // { // @07FB stack[-1] // @07FC stack[-2] // } 07F2 5B JUMPDEST 07F3 60 PUSH1 0x01 07F5 60 PUSH1 0x01 07F7 60 PUSH1 0xa0 07F9 1B SHL 07FA 03 SUB 07FB 16 AND 07FC 14 EQ 07FD 80 DUP1 07FE 61 PUSH2 0x080e 0801 57 *JUMPI // Stack delta = -1 // Outputs[1] { @07FC stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block ends with conditional jump to 0x080e, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_0802: // Incoming jump from 0x0801, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @0806 stack[-2] } 0802 50 POP 0803 61 PUSH2 0x080e 0806 81 DUP2 0807 61 PUSH2 0x05c2 080A 61 PUSH2 0x13e6 080D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0803 stack[-1] = 0x080e // @0806 stack[0] = stack[-2] // @0807 stack[1] = 0x05c2 // } // Block ends with call to 0x13e6, returns to 0x05C2 label_080E: // Incoming jump from 0x0801, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Incoming return from call to 0x05C2 at 0x080D // Inputs[1] { @0812 stack[-1] } 080E 5B JUMPDEST 080F 61 PUSH2 0x0880 0812 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0880, if stack[-1] label_0813: // Incoming jump from 0x0812, if not stack[-1] // Inputs[1] { @0815 memory[0x40:0x60] } 0813 60 PUSH1 0x40 0815 51 MLOAD 0816 62 PUSH3 0x461bcd 081A 60 PUSH1 0xe5 081C 1B SHL 081D 81 DUP2 081E 52 MSTORE 081F 60 PUSH1 0x20 0821 60 PUSH1 0x04 0823 82 DUP3 0824 01 ADD 0825 52 MSTORE 0826 60 PUSH1 0x38 0828 60 PUSH1 0x24 082A 82 DUP3 082B 01 ADD 082C 52 MSTORE 082D 7F PUSH32 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 084E 60 PUSH1 0x44 0850 82 DUP3 0851 01 ADD 0852 52 MSTORE 0853 7F PUSH32 0x6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000 0874 60 PUSH1 0x64 0876 82 DUP3 0877 01 ADD 0878 52 MSTORE 0879 60 PUSH1 0x84 087B 01 ADD 087C 61 PUSH2 0x0742 087F 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @081E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0825 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @082C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x38 // @0852 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f76652063616c6c6572206973206e6f74206f77 // @0878 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x6e6572206e6f7220617070726f76656420666f7220616c6c0000000000000000 // @087B stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0742 label_0880: // Incoming jump from 0x0812, if stack[-1] // Inputs[2] // { // @0884 stack[-3] // @0885 stack[-2] // } 0880 5B JUMPDEST 0881 61 PUSH2 0x088a 0884 83 DUP4 0885 83 DUP4 0886 61 PUSH2 0x13f5 0889 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0881 stack[0] = 0x088a // @0884 stack[1] = stack[-3] // @0885 stack[2] = stack[-2] // } // Block ends with call to 0x13f5, returns to 0x088A label_088A: // Incoming return from call to 0x13F5 at 0x0889 // Incoming return from call to 0x165D at 0x0AB0 // Incoming jump from 0x1E52, if (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-3] // Incoming return from call to 0x200D at 0x1E38 // Incoming return from call to 0x20E6 at 0x1E5B // Inputs[1] { @088E stack[-4] } 088A 5B JUMPDEST 088B 50 POP 088C 50 POP 088D 50 POP 088E 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] 088F 5B JUMPDEST 0890 60 PUSH1 0x40 0892 80 DUP1 0893 51 MLOAD 0894 60 PUSH1 0x60 0896 81 DUP2 0897 81 DUP2 0898 01 ADD 0899 83 DUP4 089A 52 MSTORE 089B 60 PUSH1 0x01 089D 60 PUSH1 0x01 089F 60 PUSH1 0xa0 08A1 1B SHL 08A2 03 SUB 08A3 88 DUP9 08A4 16 AND 08A5 60 PUSH1 0x00 08A7 81 DUP2 08A8 81 DUP2 08A9 52 MSTORE 08AA 60 PUSH1 0x0c 08AC 60 PUSH1 0x20 08AE 90 SWAP1 08AF 81 DUP2 08B0 52 MSTORE 08B1 90 SWAP1 08B2 85 DUP6 08B3 90 SWAP1 08B4 20 SHA3 08B5 54 SLOAD 08B6 84 DUP5 08B7 52 MSTORE 08B8 83 DUP4 08B9 01 ADD 08BA 52 MSTORE 08BB 91 SWAP2 08BC 81 DUP2 08BD 01 ADD 08BE 86 DUP7 08BF 90 SWAP1 08C0 52 MSTORE 08C1 61 PUSH2 0x08cd 08C4 87 DUP8 08C5 82 DUP3 08C6 87 DUP8 08C7 87 DUP8 08C8 87 DUP8 08C9 61 PUSH2 0x1463 08CC 56 *JUMP 08CD 5B JUMPDEST 08CE 61 PUSH2 0x0923 08D1 57 *JUMPI 08D2 60 PUSH1 0x40 08D4 51 MLOAD 08D5 62 PUSH3 0x461bcd 08D9 60 PUSH1 0xe5 08DB 1B SHL 08DC 81 DUP2 08DD 52 MSTORE 08DE 60 PUSH1 0x20 08E0 60 PUSH1 0x04 08E2 82 DUP3 08E3 01 ADD 08E4 52 MSTORE 08E5 60 PUSH1 0x21 08E7 60 PUSH1 0x24 08E9 82 DUP3 08EA 01 ADD 08EB 52 MSTORE 08EC 7F PUSH32 0x5369676e657220616e64207369676e617475726520646f206e6f74206d617463 090D 60 PUSH1 0x44 090F 82 DUP3 0910 01 ADD 0911 52 MSTORE 0912 60 PUSH1 0x0d 0914 60 PUSH1 0xfb 0916 1B SHL 0917 60 PUSH1 0x64 0919 82 DUP3 091A 01 ADD 091B 52 MSTORE 091C 60 PUSH1 0x84 091E 01 ADD 091F 61 PUSH2 0x0742 0922 56 *JUMP 0923 5B JUMPDEST 0924 60 PUSH1 0x01 0926 60 PUSH1 0x01 0928 60 PUSH1 0xa0 092A 1B SHL 092B 03 SUB 092C 87 DUP8 092D 16 AND 092E 60 PUSH1 0x00 0930 90 SWAP1 0931 81 DUP2 0932 52 MSTORE 0933 60 PUSH1 0x0c 0935 60 PUSH1 0x20 0937 52 MSTORE 0938 60 PUSH1 0x40 093A 90 SWAP1 093B 20 SHA3 093C 54 SLOAD 093D 61 PUSH2 0x0947 0940 90 SWAP1 0941 60 PUSH1 0x01 0943 61 PUSH2 0x1553 0946 56 *JUMP 0947 5B JUMPDEST 0948 60 PUSH1 0x01 094A 60 PUSH1 0x01 094C 60 PUSH1 0xa0 094E 1B SHL 094F 03 SUB 0950 88 DUP9 0951 16 AND 0952 60 PUSH1 0x00 0954 90 SWAP1 0955 81 DUP2 0956 52 MSTORE 0957 60 PUSH1 0x0c 0959 60 PUSH1 0x20 095B 52 MSTORE 095C 60 PUSH1 0x40 095E 90 SWAP1 095F 81 DUP2 0960 90 SWAP1 0961 20 SHA3 0962 91 SWAP2 0963 90 SWAP1 0964 91 SWAP2 0965 55 SSTORE 0966 51 MLOAD 0967 7F PUSH32 0x5845892132946850460bff5a0083f71031bc5bf9aadcd40f1de79423eac9b10b 0988 90 SWAP1 0989 61 PUSH2 0x0997 098C 90 SWAP1 098D 89 DUP10 098E 90 SWAP1 098F 33 CALLER 0990 90 SWAP1 0991 8A DUP11 0992 90 SWAP1 0993 61 PUSH2 0x2614 0996 56 *JUMP 0997 5B JUMPDEST 0998 60 PUSH1 0x40 099A 51 MLOAD 099B 80 DUP1 099C 91 SWAP2 099D 03 SUB 099E 90 SWAP1 099F A1 LOG1 09A0 60 PUSH1 0x00 09A2 80 DUP1 09A3 30 ADDRESS 09A4 60 PUSH1 0x01 09A6 60 PUSH1 0x01 09A8 60 PUSH1 0xa0 09AA 1B SHL 09AB 03 SUB 09AC 16 AND 09AD 88 DUP9 09AE 8A DUP11 09AF 60 PUSH1 0x40 09B1 51 MLOAD 09B2 60 PUSH1 0x20 09B4 01 ADD 09B5 61 PUSH2 0x09bf 09B8 92 SWAP3 09B9 91 SWAP2 09BA 90 SWAP1 09BB 61 PUSH2 0x2537 09BE 56 *JUMP 09BF 5B JUMPDEST 09C0 60 PUSH1 0x40 09C2 80 DUP1 09C3 51 MLOAD 09C4 60 PUSH1 0x1f 09C6 19 NOT 09C7 81 DUP2 09C8 84 DUP5 09C9 03 SUB 09CA 01 ADD 09CB 81 DUP2 09CC 52 MSTORE 09CD 90 SWAP1 09CE 82 DUP3 09CF 90 SWAP1 09D0 52 MSTORE 09D1 61 PUSH2 0x09d9 09D4 91 SWAP2 09D5 61 PUSH2 0x251b 09D8 56 *JUMP 09D9 5B JUMPDEST 09DA 60 PUSH1 0x00 09DC 60 PUSH1 0x40 09DE 51 MLOAD 09DF 80 DUP1 09E0 83 DUP4 09E1 03 SUB 09E2 81 DUP2 09E3 60 PUSH1 0x00 09E5 86 DUP7 09E6 5A GAS 09E7 F1 CALL 09E8 91 SWAP2 09E9 50 POP 09EA 50 POP 09EB 3D RETURNDATASIZE 09EC 80 DUP1 09ED 60 PUSH1 0x00 09EF 81 DUP2 09F0 14 EQ 09F1 61 PUSH2 0x0a16 09F4 57 *JUMPI 09F5 60 PUSH1 0x40 09F7 51 MLOAD 09F8 91 SWAP2 09F9 50 POP 09FA 60 PUSH1 0x1f 09FC 19 NOT 09FD 60 PUSH1 0x3f 09FF 3D RETURNDATASIZE 0A00 01 ADD 0A01 16 AND 0A02 82 DUP3 0A03 01 ADD 0A04 60 PUSH1 0x40 0A06 52 MSTORE 0A07 3D RETURNDATASIZE 0A08 82 DUP3 0A09 52 MSTORE 0A0A 3D RETURNDATASIZE 0A0B 60 PUSH1 0x00 0A0D 60 PUSH1 0x20 0A0F 84 DUP5 0A10 01 ADD 0A11 3E RETURNDATACOPY 0A12 61 PUSH2 0x0a1b 0A15 56 *JUMP 0A16 5B JUMPDEST 0A17 60 PUSH1 0x60 0A19 91 SWAP2 0A1A 50 POP 0A1B 5B JUMPDEST 0A1C 50 POP 0A1D 91 SWAP2 0A1E 50 POP 0A1F 91 SWAP2 0A20 50 POP 0A21 81 DUP2 0A22 61 PUSH2 0x0a6d 0A25 57 *JUMPI 0A26 60 PUSH1 0x40 0A28 51 MLOAD 0A29 62 PUSH3 0x461bcd 0A2D 60 PUSH1 0xe5 0A2F 1B SHL 0A30 81 DUP2 0A31 52 MSTORE 0A32 60 PUSH1 0x20 0A34 60 PUSH1 0x04 0A36 82 DUP3 0A37 01 ADD 0A38 52 MSTORE 0A39 60 PUSH1 0x1c 0A3B 60 PUSH1 0x24 0A3D 82 DUP3 0A3E 01 ADD 0A3F 52 MSTORE 0A40 7F PUSH32 0x46756e6374696f6e2063616c6c206e6f74207375636365737366756c00000000 0A61 60 PUSH1 0x44 0A63 82 DUP3 0A64 01 ADD 0A65 52 MSTORE 0A66 60 PUSH1 0x64 0A68 01 ADD 0A69 61 PUSH2 0x0742 0A6C 56 *JUMP 0A6D 5B JUMPDEST 0A6E 98 SWAP9 0A6F 97 SWAP8 0A70 50 POP 0A71 50 POP 0A72 50 POP 0A73 50 POP 0A74 50 POP 0A75 50 POP 0A76 50 POP 0A77 50 POP 0A78 56 *JUMP label_0A79: // Incoming jump from 0x0337 0A79 5B JUMPDEST 0A7A 61 PUSH2 0x0a8a 0A7D 61 PUSH2 0x0a84 0A80 61 PUSH2 0x13e6 0A83 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0A7A stack[0] = 0x0a8a // @0A7D stack[1] = 0x0a84 // } // Block ends with call to 0x13e6, returns to 0x0A84 label_0A84: // Incoming return from call to 0x13E6 at 0x0A83 // Inputs[1] { @0A85 stack[-3] } 0A84 5B JUMPDEST 0A85 82 DUP3 0A86 61 PUSH2 0x1566 0A89 56 *JUMP // Stack delta = +1 // Outputs[1] { @0A85 stack[0] = stack[-3] } // Block ends with unconditional jump to 0x1566 label_0A8A: // Incoming return from call to 0x0A84 at 0x0A83 // Inputs[1] { @0A8E stack[-1] } 0A8A 5B JUMPDEST 0A8B 61 PUSH2 0x0aa6 0A8E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0aa6, if stack[-1] label_0A8F: // Incoming jump from 0x0A8E, if not stack[-1] // Inputs[1] { @0A91 memory[0x40:0x60] } 0A8F 60 PUSH1 0x40 0A91 51 MLOAD 0A92 62 PUSH3 0x461bcd 0A96 60 PUSH1 0xe5 0A98 1B SHL 0A99 81 DUP2 0A9A 52 MSTORE 0A9B 60 PUSH1 0x04 0A9D 01 ADD 0A9E 61 PUSH2 0x0742 0AA1 90 SWAP1 0AA2 61 PUSH2 0x2717 0AA5 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0A9A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0AA1 stack[0] = 0x0742 // @0AA1 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2717, returns to 0x0742 label_0AA6: // Incoming jump from 0x0A8E, if stack[-1] // Inputs[3] // { // @0AAA stack[-3] // @0AAB stack[-2] // @0AAC stack[-1] // } 0AA6 5B JUMPDEST 0AA7 61 PUSH2 0x088a 0AAA 83 DUP4 0AAB 83 DUP4 0AAC 83 DUP4 0AAD 61 PUSH2 0x165d 0AB0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0AA7 stack[0] = 0x088a // @0AAA stack[1] = stack[-3] // @0AAB stack[2] = stack[-2] // @0AAC stack[3] = stack[-1] // } // Block ends with call to 0x165d, returns to 0x088A label_0AB1: // Incoming jump from 0x038D // Inputs[1] { @0AB7 stack[-2] } 0AB1 5B JUMPDEST 0AB2 60 PUSH1 0x00 0AB4 61 PUSH2 0x0abc 0AB7 83 DUP4 0AB8 61 PUSH2 0x0cff 0ABB 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @0AB2 stack[0] = 0x00 // @0AB4 stack[1] = 0x0abc // @0AB7 stack[2] = stack[-2] // } // Block ends with call to 0x0cff, returns to 0x0ABC label_0ABC: // Incoming return from call to 0x0CFF at 0x0ABB // Inputs[2] // { // @0ABD stack[-3] // @0ABE stack[-1] // } 0ABC 5B JUMPDEST 0ABD 82 DUP3 0ABE 10 LT 0ABF 61 PUSH2 0x0b1e 0AC2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0b1e, if stack[-3] < stack[-1] label_0AC3: // Incoming jump from 0x0AC2, if not stack[-3] < stack[-1] // Inputs[1] { @0AC5 memory[0x40:0x60] } 0AC3 60 PUSH1 0x40 0AC5 51 MLOAD 0AC6 62 PUSH3 0x461bcd 0ACA 60 PUSH1 0xe5 0ACC 1B SHL 0ACD 81 DUP2 0ACE 52 MSTORE 0ACF 60 PUSH1 0x20 0AD1 60 PUSH1 0x04 0AD3 82 DUP3 0AD4 01 ADD 0AD5 52 MSTORE 0AD6 60 PUSH1 0x2b 0AD8 60 PUSH1 0x24 0ADA 82 DUP3 0ADB 01 ADD 0ADC 52 MSTORE 0ADD 7F PUSH32 0x455243373231456e756d657261626c653a206f776e657220696e646578206f75 0AFE 60 PUSH1 0x44 0B00 82 DUP3 0B01 01 ADD 0B02 52 MSTORE 0B03 6A PUSH11 0x74206f6620626f756e6473 0B0F 60 PUSH1 0xa8 0B11 1B SHL 0B12 60 PUSH1 0x64 0B14 82 DUP3 0B15 01 ADD 0B16 52 MSTORE 0B17 60 PUSH1 0x84 0B19 01 ADD 0B1A 61 PUSH2 0x0742 0B1D 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0ACE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0AD5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0ADC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2b // @0B02 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231456e756d657261626c653a206f776e657220696e646578206f75 // @0B16 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x74206f6620626f756e6473 << 0xa8 // @0B19 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0742 label_0B1E: // Incoming jump from 0x0AC2, if stack[-3] < stack[-1] // Inputs[6] // { // @0B28 stack[-3] // @0B29 stack[-2] // @0B3C memory[0x00:0x40] // @0B43 memory[0x00:0x40] // @0B44 storage[keccak256(memory[0x00:0x40])] // @0B45 stack[-4] // } 0B1E 5B JUMPDEST 0B1F 50 POP 0B20 60 PUSH1 0x01 0B22 60 PUSH1 0x01 0B24 60 PUSH1 0xa0 0B26 1B SHL 0B27 03 SUB 0B28 91 SWAP2 0B29 90 SWAP1 0B2A 91 SWAP2 0B2B 16 AND 0B2C 60 PUSH1 0x00 0B2E 90 SWAP1 0B2F 81 DUP2 0B30 52 MSTORE 0B31 60 PUSH1 0x06 0B33 60 PUSH1 0x20 0B35 90 SWAP1 0B36 81 DUP2 0B37 52 MSTORE 0B38 60 PUSH1 0x40 0B3A 80 DUP1 0B3B 83 DUP4 0B3C 20 SHA3 0B3D 93 SWAP4 0B3E 83 DUP4 0B3F 52 MSTORE 0B40 92 SWAP3 0B41 90 SWAP1 0B42 52 MSTORE 0B43 20 SHA3 0B44 54 SLOAD 0B45 90 SWAP1 0B46 56 *JUMP // Stack delta = -3 // Outputs[5] // { // @0B30 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-3] // @0B37 memory[0x20:0x40] = 0x06 // @0B3F memory[0x00:0x20] = stack[-2] // @0B42 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @0B45 stack[-4] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-4] label_0B47: // Incoming call from 0x03B5, returns to 0x02A2 0B47 5B JUMPDEST 0B48 61 PUSH2 0x0b4f 0B4B 61 PUSH2 0x13e6 0B4E 56 *JUMP // Stack delta = +1 // Outputs[1] { @0B48 stack[0] = 0x0b4f } // Block ends with call to 0x13e6, returns to 0x0B4F label_0B4F: // Incoming return from call to 0x13E6 at 0x0B4E // Inputs[2] // { // @0B58 stack[-1] // @0B5E storage[0x0d] // } 0B4F 5B JUMPDEST 0B50 60 PUSH1 0x01 0B52 60 PUSH1 0x01 0B54 60 PUSH1 0xa0 0B56 1B SHL 0B57 03 SUB 0B58 16 AND 0B59 61 PUSH2 0x0b6a 0B5C 60 PUSH1 0x0d 0B5E 54 SLOAD 0B5F 60 PUSH1 0x01 0B61 60 PUSH1 0x01 0B63 60 PUSH1 0xa0 0B65 1B SHL 0B66 03 SUB 0B67 16 AND 0B68 90 SWAP1 0B69 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0B58 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0B68 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x0d] // } // Block ends with unconditional jump to 0x0b6a label_0B6A: // Incoming jump from 0x0B69 // Inputs[2] // { // @0B73 stack[-1] // @0B74 stack[-2] // } 0B6A 5B JUMPDEST 0B6B 60 PUSH1 0x01 0B6D 60 PUSH1 0x01 0B6F 60 PUSH1 0xa0 0B71 1B SHL 0B72 03 SUB 0B73 16 AND 0B74 14 EQ 0B75 61 PUSH2 0x0b90 0B78 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0b90, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_0B79: // Incoming jump from 0x0B78, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @0B7B memory[0x40:0x60] } 0B79 60 PUSH1 0x40 0B7B 51 MLOAD 0B7C 62 PUSH3 0x461bcd 0B80 60 PUSH1 0xe5 0B82 1B SHL 0B83 81 DUP2 0B84 52 MSTORE 0B85 60 PUSH1 0x04 0B87 01 ADD 0B88 61 PUSH2 0x0742 0B8B 90 SWAP1 0B8C 61 PUSH2 0x26e2 0B8F 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0B84 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0B8B stack[0] = 0x0742 // @0B8B stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x26e2, returns to 0x0742 label_0B90: // Incoming jump from 0x0B78, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[6] // { // @0B93 storage[0x0d] // @0B96 memory[0x40:0x60] // @0BA3 address(this) // @0BA3 address(this).balance // @0BB3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @0BB3 address(storage[0x0d] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } 0B90 5B JUMPDEST 0B91 60 PUSH1 0x0d 0B93 54 SLOAD 0B94 60 PUSH1 0x40 0B96 51 MLOAD 0B97 60 PUSH1 0x01 0B99 60 PUSH1 0x01 0B9B 60 PUSH1 0xa0 0B9D 1B SHL 0B9E 03 SUB 0B9F 90 SWAP1 0BA0 91 SWAP2 0BA1 16 AND 0BA2 90 SWAP1 0BA3 47 SELFBALANCE 0BA4 80 DUP1 0BA5 15 ISZERO 0BA6 61 PUSH2 0x08fc 0BA9 02 MUL 0BAA 91 SWAP2 0BAB 60 PUSH1 0x00 0BAD 81 DUP2 0BAE 81 DUP2 0BAF 81 DUP2 0BB0 85 DUP6 0BB1 88 DUP9 0BB2 88 DUP9 0BB3 F1 CALL 0BB4 93 SWAP4 0BB5 50 POP 0BB6 50 POP 0BB7 50 POP 0BB8 50 POP 0BB9 15 ISZERO 0BBA 80 DUP1 0BBB 15 ISZERO 0BBC 61 PUSH2 0x0bc9 0BBF 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @0BB3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(storage[0x0d] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // @0BB9 stack[0] = !address(storage[0x0d] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // } // Block ends with conditional jump to 0x0bc9, if !!address(storage[0x0d] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) label_0BC0: // Incoming jump from 0x0BBF, if not !!address(storage[0x0d] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Inputs[4] // { // @0BC0 returndata.length // @0BC4 returndata[0x00:0x00 + returndata.length] // @0BC5 returndata.length // @0BC8 memory[0x00:0x00 + returndata.length] // } 0BC0 3D RETURNDATASIZE 0BC1 60 PUSH1 0x00 0BC3 80 DUP1 0BC4 3E RETURNDATACOPY 0BC5 3D RETURNDATASIZE 0BC6 60 PUSH1 0x00 0BC8 FD *REVERT // Stack delta = +0 // Outputs[2] // { // @0BC4 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @0BC8 revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_0BC9: // Incoming jump from 0x28B3, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Incoming jump from 0x0BBF, if !!address(storage[0x0d] & (0x01 << 0xa0) - 0x01).call.gas(0x08fc * !address(this).balance).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00]) // Incoming return from call to 0x1808 at 0x1338 // Inputs[1] { @0BCB stack[-2] } 0BC9 5B JUMPDEST 0BCA 50 POP 0BCB 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_0BCC: // Incoming jump from 0x03D5 // Inputs[4] // { // @0BD0 stack[-3] // @0BD1 stack[-2] // @0BD2 stack[-1] // @0BD5 memory[0x40:0x60] // } 0BCC 5B JUMPDEST 0BCD 61 PUSH2 0x088a 0BD0 83 DUP4 0BD1 83 DUP4 0BD2 83 DUP4 0BD3 60 PUSH1 0x40 0BD5 51 MLOAD 0BD6 80 DUP1 0BD7 60 PUSH1 0x20 0BD9 01 ADD 0BDA 60 PUSH1 0x40 0BDC 52 MSTORE 0BDD 80 DUP1 0BDE 60 PUSH1 0x00 0BE0 81 DUP2 0BE1 52 MSTORE 0BE2 50 POP 0BE3 61 PUSH2 0x0fb3 0BE6 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @0BCD stack[0] = 0x088a // @0BD0 stack[1] = stack[-3] // @0BD1 stack[2] = stack[-2] // @0BD2 stack[3] = stack[-1] // @0BD5 stack[4] = memory[0x40:0x60] // @0BDC memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @0BE1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with unconditional jump to 0x0fb3 label_0BE7: // Incoming jump from 0x03F5 // Inputs[1] { @0BEF storage[0x08] } 0BE7 5B JUMPDEST 0BE8 60 PUSH1 0x00 0BEA 61 PUSH2 0x0bf2 0BED 60 PUSH1 0x08 0BEF 54 SLOAD 0BF0 90 SWAP1 0BF1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0BE8 stack[0] = 0x00 // @0BF0 stack[1] = storage[0x08] // } // Block ends with unconditional jump to 0x0bf2 label_0BF2: // Incoming jump from 0x0BF1 // Inputs[2] // { // @0BF3 stack[-3] // @0BF4 stack[-1] // } 0BF2 5B JUMPDEST 0BF3 82 DUP3 0BF4 10 LT 0BF5 61 PUSH2 0x0c55 0BF8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0c55, if stack[-3] < stack[-1] label_0BF9: // Incoming jump from 0x0BF8, if not stack[-3] < stack[-1] // Inputs[1] { @0BFB memory[0x40:0x60] } 0BF9 60 PUSH1 0x40 0BFB 51 MLOAD 0BFC 62 PUSH3 0x461bcd 0C00 60 PUSH1 0xe5 0C02 1B SHL 0C03 81 DUP2 0C04 52 MSTORE 0C05 60 PUSH1 0x20 0C07 60 PUSH1 0x04 0C09 82 DUP3 0C0A 01 ADD 0C0B 52 MSTORE 0C0C 60 PUSH1 0x2c 0C0E 60 PUSH1 0x24 0C10 82 DUP3 0C11 01 ADD 0C12 52 MSTORE 0C13 7F PUSH32 0x455243373231456e756d657261626c653a20676c6f62616c20696e646578206f 0C34 60 PUSH1 0x44 0C36 82 DUP3 0C37 01 ADD 0C38 52 MSTORE 0C39 6B PUSH12 0x7574206f6620626f756e6473 0C46 60 PUSH1 0xa0 0C48 1B SHL 0C49 60 PUSH1 0x64 0C4B 82 DUP3 0C4C 01 ADD 0C4D 52 MSTORE 0C4E 60 PUSH1 0x84 0C50 01 ADD 0C51 61 PUSH2 0x0742 0C54 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0C04 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0C0B memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0C12 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2c // @0C38 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x455243373231456e756d657261626c653a20676c6f62616c20696e646578206f // @0C4D memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x7574206f6620626f756e6473 << 0xa0 // @0C50 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0742 label_0C55: // Incoming jump from 0x0BF8, if stack[-3] < stack[-1] // Inputs[2] // { // @0C58 stack[-2] // @0C5A storage[0x08] // } 0C55 5B JUMPDEST 0C56 60 PUSH1 0x08 0C58 82 DUP3 0C59 81 DUP2 0C5A 54 SLOAD 0C5B 81 DUP2 0C5C 10 LT 0C5D 61 PUSH2 0x0c76 0C60 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @0C56 stack[0] = 0x08 // @0C58 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x0c76, if stack[-2] < storage[0x08] label_0C61: // Incoming jump from 0x0C60, if not stack[-2] < storage[0x08] // Inputs[1] { @0C75 memory[0x00:0x24] } 0C61 63 PUSH4 0x4e487b71 0C66 60 PUSH1 0xe0 0C68 1B SHL 0C69 60 PUSH1 0x00 0C6B 52 MSTORE 0C6C 60 PUSH1 0x32 0C6E 60 PUSH1 0x04 0C70 52 MSTORE 0C71 60 PUSH1 0x24 0C73 60 PUSH1 0x00 0C75 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @0C6B memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @0C70 memory[0x04:0x24] = 0x32 // @0C75 revert(memory[0x00:0x24]); // } // Block terminates label_0C76: // Incoming jump from 0x0C60, if stack[-2] < storage[0x08] // Inputs[7] // { // @0C77 stack[-2] // @0C77 stack[-1] // @0C7F memory[0x00:0x20] // @0C81 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @0C82 stack[-3] // @0C84 stack[-5] // @0C85 stack[-4] // } 0C76 5B JUMPDEST 0C77 90 SWAP1 0C78 60 PUSH1 0x00 0C7A 52 MSTORE 0C7B 60 PUSH1 0x20 0C7D 60 PUSH1 0x00 0C7F 20 SHA3 0C80 01 ADD 0C81 54 SLOAD 0C82 90 SWAP1 0C83 50 POP 0C84 91 SWAP2 0C85 90 SWAP1 0C86 50 POP 0C87 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @0C7A memory[0x00:0x20] = stack[-2] // @0C84 stack[-5] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-5] label_0C88: // Incoming call from 0x15E9, returns to 0x15EA // Incoming jump from 0x0415 // Incoming call from 0x1429, returns to 0x142A // Incoming call from 0x0771, returns to 0x0772 // Incoming call from 0x166F, returns to 0x1670 // Inputs[3] // { // @0C8B stack[-1] // @0C96 memory[0x00:0x40] // @0C97 storage[keccak256(memory[0x00:0x40])] // } 0C88 5B JUMPDEST 0C89 60 PUSH1 0x00 0C8B 81 DUP2 0C8C 81 DUP2 0C8D 52 MSTORE 0C8E 60 PUSH1 0x02 0C90 60 PUSH1 0x20 0C92 52 MSTORE 0C93 60 PUSH1 0x40 0C95 81 DUP2 0C96 20 SHA3 0C97 54 SLOAD 0C98 60 PUSH1 0x01 0C9A 60 PUSH1 0x01 0C9C 60 PUSH1 0xa0 0C9E 1B SHL 0C9F 03 SUB 0CA0 16 AND 0CA1 80 DUP1 0CA2 61 PUSH2 0x0635 0CA5 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0C89 stack[0] = 0x00 // @0C8D memory[0x00:0x20] = stack[-1] // @0C92 memory[0x20:0x40] = 0x02 // @0CA0 stack[1] = (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x0635, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_0CA6: // Incoming jump from 0x0CA5, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @0CA8 memory[0x40:0x60] } 0CA6 60 PUSH1 0x40 0CA8 51 MLOAD 0CA9 62 PUSH3 0x461bcd 0CAD 60 PUSH1 0xe5 0CAF 1B SHL 0CB0 81 DUP2 0CB1 52 MSTORE 0CB2 60 PUSH1 0x20 0CB4 60 PUSH1 0x04 0CB6 82 DUP3 0CB7 01 ADD 0CB8 52 MSTORE 0CB9 60 PUSH1 0x29 0CBB 60 PUSH1 0x24 0CBD 82 DUP3 0CBE 01 ADD 0CBF 52 MSTORE 0CC0 7F PUSH32 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 0CE1 60 PUSH1 0x44 0CE3 82 DUP3 0CE4 01 ADD 0CE5 52 MSTORE 0CE6 68 PUSH9 0x32b73a103a37b5b2b7 0CF0 60 PUSH1 0xb9 0CF2 1B SHL 0CF3 60 PUSH1 0x64 0CF5 82 DUP3 0CF6 01 ADD 0CF7 52 MSTORE 0CF8 60 PUSH1 0x84 0CFA 01 ADD 0CFB 61 PUSH2 0x0742 0CFE 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0CB1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0CB8 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0CBF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @0CE5 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a206f776e657220717565727920666f72206e6f6e6578697374 // @0CF7 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x32b73a103a37b5b2b7 << 0xb9 // @0CFA stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0742 label_0CFF: // Incoming call from 0x1F7C, returns to 0x1F7D // Incoming call from 0x0ABB, returns to 0x0ABC // Incoming jump from 0x0455 // Incoming call from 0x20F0, returns to 0x20F1 // Inputs[1] { @0D0A stack[-1] } 0CFF 5B JUMPDEST 0D00 60 PUSH1 0x00 0D02 60 PUSH1 0x01 0D04 60 PUSH1 0x01 0D06 60 PUSH1 0xa0 0D08 1B SHL 0D09 03 SUB 0D0A 82 DUP3 0D0B 16 AND 0D0C 61 PUSH2 0x0d6a 0D0F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0D00 stack[0] = 0x00 } // Block ends with conditional jump to 0x0d6a, if stack[-1] & (0x01 << 0xa0) - 0x01 label_0D10: // Incoming jump from 0x0D0F, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @0D12 memory[0x40:0x60] } 0D10 60 PUSH1 0x40 0D12 51 MLOAD 0D13 62 PUSH3 0x461bcd 0D17 60 PUSH1 0xe5 0D19 1B SHL 0D1A 81 DUP2 0D1B 52 MSTORE 0D1C 60 PUSH1 0x20 0D1E 60 PUSH1 0x04 0D20 82 DUP3 0D21 01 ADD 0D22 52 MSTORE 0D23 60 PUSH1 0x2a 0D25 60 PUSH1 0x24 0D27 82 DUP3 0D28 01 ADD 0D29 52 MSTORE 0D2A 7F PUSH32 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 0D4B 60 PUSH1 0x44 0D4D 82 DUP3 0D4E 01 ADD 0D4F 52 MSTORE 0D50 69 PUSH10 0x726f2061646472657373 0D5B 60 PUSH1 0xb0 0D5D 1B SHL 0D5E 60 PUSH1 0x64 0D60 82 DUP3 0D61 01 ADD 0D62 52 MSTORE 0D63 60 PUSH1 0x84 0D65 01 ADD 0D66 61 PUSH2 0x0742 0D69 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @0D1B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0D22 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0D29 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2a // @0D4F memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a2062616c616e636520717565727920666f7220746865207a65 // @0D62 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x726f2061646472657373 << 0xb0 // @0D65 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0742 label_0D6A: // Incoming jump from 0x0D0F, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[4] // { // @0D74 stack[-2] // @0D82 memory[0x00:0x40] // @0D83 storage[keccak256(memory[0x00:0x40])] // @0D84 stack[-3] // } 0D6A 5B JUMPDEST 0D6B 50 POP 0D6C 60 PUSH1 0x01 0D6E 60 PUSH1 0x01 0D70 60 PUSH1 0xa0 0D72 1B SHL 0D73 03 SUB 0D74 16 AND 0D75 60 PUSH1 0x00 0D77 90 SWAP1 0D78 81 DUP2 0D79 52 MSTORE 0D7A 60 PUSH1 0x03 0D7C 60 PUSH1 0x20 0D7E 52 MSTORE 0D7F 60 PUSH1 0x40 0D81 90 SWAP1 0D82 20 SHA3 0D83 54 SLOAD 0D84 90 SWAP1 0D85 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @0D79 memory[0x00:0x20] = (0x01 << 0xa0) - 0x01 & stack[-2] // @0D7E memory[0x20:0x40] = 0x03 // @0D84 stack[-3] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with unconditional jump to stack[-3] label_0D86: // Incoming call from 0x046A, returns to 0x02A2 0D86 5B JUMPDEST 0D87 61 PUSH2 0x0d8e 0D8A 61 PUSH2 0x13e6 0D8D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0D87 stack[0] = 0x0d8e } // Block ends with call to 0x13e6, returns to 0x0D8E label_0D8E: // Incoming return from call to 0x13E6 at 0x0D8D // Inputs[2] // { // @0D97 stack[-1] // @0D9D storage[0x0d] // } 0D8E 5B JUMPDEST 0D8F 60 PUSH1 0x01 0D91 60 PUSH1 0x01 0D93 60 PUSH1 0xa0 0D95 1B SHL 0D96 03 SUB 0D97 16 AND 0D98 61 PUSH2 0x0da9 0D9B 60 PUSH1 0x0d 0D9D 54 SLOAD 0D9E 60 PUSH1 0x01 0DA0 60 PUSH1 0x01 0DA2 60 PUSH1 0xa0 0DA4 1B SHL 0DA5 03 SUB 0DA6 16 AND 0DA7 90 SWAP1 0DA8 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0D97 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0DA7 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x0d] // } // Block ends with unconditional jump to 0x0da9 label_0DA9: // Incoming jump from 0x0DA8 // Inputs[2] // { // @0DB2 stack[-1] // @0DB3 stack[-2] // } 0DA9 5B JUMPDEST 0DAA 60 PUSH1 0x01 0DAC 60 PUSH1 0x01 0DAE 60 PUSH1 0xa0 0DB0 1B SHL 0DB1 03 SUB 0DB2 16 AND 0DB3 14 EQ 0DB4 61 PUSH2 0x0dcf 0DB7 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0dcf, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_0DB8: // Incoming jump from 0x0DB7, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @0DBA memory[0x40:0x60] } 0DB8 60 PUSH1 0x40 0DBA 51 MLOAD 0DBB 62 PUSH3 0x461bcd 0DBF 60 PUSH1 0xe5 0DC1 1B SHL 0DC2 81 DUP2 0DC3 52 MSTORE 0DC4 60 PUSH1 0x04 0DC6 01 ADD 0DC7 61 PUSH2 0x0742 0DCA 90 SWAP1 0DCB 61 PUSH2 0x26e2 0DCE 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0DC3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0DCA stack[0] = 0x0742 // @0DCA stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x26e2, returns to 0x0742 label_0DCF: // Incoming jump from 0x0DB7, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] 0DCF 5B JUMPDEST 0DD0 61 PUSH2 0x0dd9 0DD3 60 PUSH1 0x00 0DD5 61 PUSH2 0x1808 0DD8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0DD0 stack[0] = 0x0dd9 // @0DD3 stack[1] = 0x00 // } // Block ends with call to 0x1808, returns to 0x0DD9 label_0DD9: // Incoming return from call to 0x1808 at 0x0DD8 // Inputs[1] { @0DDA stack[-1] } 0DD9 5B JUMPDEST 0DDA 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_0DDB: // Incoming jump from 0x048A 0DDB 5B JUMPDEST 0DDC 61 PUSH2 0x0de3 0DDF 61 PUSH2 0x13e6 0DE2 56 *JUMP // Stack delta = +1 // Outputs[1] { @0DDC stack[0] = 0x0de3 } // Block ends with call to 0x13e6, returns to 0x0DE3 label_0DE3: // Incoming return from call to 0x13E6 at 0x0DE2 // Inputs[2] // { // @0DEC stack[-1] // @0DF2 storage[0x0d] // } 0DE3 5B JUMPDEST 0DE4 60 PUSH1 0x01 0DE6 60 PUSH1 0x01 0DE8 60 PUSH1 0xa0 0DEA 1B SHL 0DEB 03 SUB 0DEC 16 AND 0DED 61 PUSH2 0x0dfe 0DF0 60 PUSH1 0x0d 0DF2 54 SLOAD 0DF3 60 PUSH1 0x01 0DF5 60 PUSH1 0x01 0DF7 60 PUSH1 0xa0 0DF9 1B SHL 0DFA 03 SUB 0DFB 16 AND 0DFC 90 SWAP1 0DFD 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0DEC stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0DFC stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x0d] // } // Block ends with unconditional jump to 0x0dfe label_0DFE: // Incoming jump from 0x0DFD // Inputs[2] // { // @0E07 stack[-1] // @0E08 stack[-2] // } 0DFE 5B JUMPDEST 0DFF 60 PUSH1 0x01 0E01 60 PUSH1 0x01 0E03 60 PUSH1 0xa0 0E05 1B SHL 0E06 03 SUB 0E07 16 AND 0E08 14 EQ 0E09 61 PUSH2 0x0e24 0E0C 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0e24, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_0E0D: // Incoming jump from 0x0E0C, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @0E0F memory[0x40:0x60] } 0E0D 60 PUSH1 0x40 0E0F 51 MLOAD 0E10 62 PUSH3 0x461bcd 0E14 60 PUSH1 0xe5 0E16 1B SHL 0E17 81 DUP2 0E18 52 MSTORE 0E19 60 PUSH1 0x04 0E1B 01 ADD 0E1C 61 PUSH2 0x0742 0E1F 90 SWAP1 0E20 61 PUSH2 0x26e2 0E23 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E18 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E1F stack[0] = 0x0742 // @0E1F stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x26e2, returns to 0x0742 label_0E24: // Incoming jump from 0x0E0C, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] 0E24 5B JUMPDEST 0E25 60 PUSH1 0x00 0E27 61 PUSH2 0x0e2e 0E2A 61 PUSH2 0x185a 0E2D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0E25 stack[0] = 0x00 // @0E27 stack[1] = 0x0e2e // } // Block ends with unconditional jump to 0x185a 0E2E 5B JUMPDEST 0E2F 90 SWAP1 0E30 50 POP 0E31 61 PUSH2 0x0e3a 0E34 82 DUP3 0E35 82 DUP3 0E36 61 PUSH2 0x186b 0E39 56 *JUMP 0E3A 5B JUMPDEST 0E3B 61 PUSH2 0x0e42 0E3E 61 PUSH2 0x19b9 0E41 56 *JUMP label_0E42: // Incoming jump from 0x1251, if !(0x00 < stack[-1]) // Inputs[1] { @0E45 stack[-3] } 0E42 5B JUMPDEST 0E43 50 POP 0E44 50 POP 0E45 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_0E46: // Incoming call from 0x04D3, returns to 0x023D // Inputs[1] { @0E4C storage[0x01] } 0E46 5B JUMPDEST 0E47 60 PUSH1 0x60 0E49 60 PUSH1 0x01 0E4B 80 DUP1 0E4C 54 SLOAD 0E4D 61 PUSH2 0x064a 0E50 90 SWAP1 0E51 61 PUSH2 0x27f6 0E54 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0E47 stack[0] = 0x60 // @0E49 stack[1] = 0x01 // @0E50 stack[2] = 0x064a // @0E50 stack[3] = storage[0x01] // } // Block ends with call to 0x27f6, returns to 0x064A label_0E55: // Incoming jump from 0x04F3 0E55 5B JUMPDEST 0E56 61 PUSH2 0x0e5d 0E59 61 PUSH2 0x13e6 0E5C 56 *JUMP // Stack delta = +1 // Outputs[1] { @0E56 stack[0] = 0x0e5d } // Block ends with call to 0x13e6, returns to 0x0E5D label_0E5D: // Incoming return from call to 0x13E6 at 0x0E5C // Inputs[2] // { // @0E66 stack[-1] // @0E6C storage[0x0d] // } 0E5D 5B JUMPDEST 0E5E 60 PUSH1 0x01 0E60 60 PUSH1 0x01 0E62 60 PUSH1 0xa0 0E64 1B SHL 0E65 03 SUB 0E66 16 AND 0E67 61 PUSH2 0x0e78 0E6A 60 PUSH1 0x0d 0E6C 54 SLOAD 0E6D 60 PUSH1 0x01 0E6F 60 PUSH1 0x01 0E71 60 PUSH1 0xa0 0E73 1B SHL 0E74 03 SUB 0E75 16 AND 0E76 90 SWAP1 0E77 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0E66 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0E76 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x0d] // } // Block ends with unconditional jump to 0x0e78 label_0E78: // Incoming jump from 0x0E77 // Inputs[2] // { // @0E81 stack[-1] // @0E82 stack[-2] // } 0E78 5B JUMPDEST 0E79 60 PUSH1 0x01 0E7B 60 PUSH1 0x01 0E7D 60 PUSH1 0xa0 0E7F 1B SHL 0E80 03 SUB 0E81 16 AND 0E82 14 EQ 0E83 61 PUSH2 0x0e9e 0E86 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0e9e, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_0E87: // Incoming jump from 0x0E86, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @0E89 memory[0x40:0x60] } 0E87 60 PUSH1 0x40 0E89 51 MLOAD 0E8A 62 PUSH3 0x461bcd 0E8E 60 PUSH1 0xe5 0E90 1B SHL 0E91 81 DUP2 0E92 52 MSTORE 0E93 60 PUSH1 0x04 0E95 01 ADD 0E96 61 PUSH2 0x0742 0E99 90 SWAP1 0E9A 61 PUSH2 0x26e2 0E9D 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0E92 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0E99 stack[0] = 0x0742 // @0E99 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x26e2, returns to 0x0742 label_0E9E: // Incoming jump from 0x0E86, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[2] // { // @0E9F stack[-1] // @0EA0 memory[stack[-1]:stack[-1] + 0x20] // } 0E9E 5B JUMPDEST 0E9F 80 DUP1 0EA0 51 MLOAD 0EA1 61 PUSH2 0x0e42 0EA4 90 SWAP1 0EA5 60 PUSH1 0x10 0EA7 90 SWAP1 0EA8 60 PUSH1 0x20 0EAA 84 DUP5 0EAB 01 ADD 0EAC 90 SWAP1 0EAD 61 PUSH2 0x212a 0EB0 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0EA4 stack[0] = 0x0e42 // @0EA7 stack[1] = 0x10 // @0EAC stack[2] = stack[-1] + 0x20 // @0EAC stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with unconditional jump to 0x212a label_0EB1: // Incoming jump from 0x0513 0EB1 5B JUMPDEST 0EB2 61 PUSH2 0x0eb9 0EB5 61 PUSH2 0x13e6 0EB8 56 *JUMP // Stack delta = +1 // Outputs[1] { @0EB2 stack[0] = 0x0eb9 } // Block ends with call to 0x13e6, returns to 0x0EB9 label_0EB9: // Incoming return from call to 0x13E6 at 0x0EB8 // Inputs[2] // { // @0EC2 stack[-1] // @0EC3 stack[-3] // } 0EB9 5B JUMPDEST 0EBA 60 PUSH1 0x01 0EBC 60 PUSH1 0x01 0EBE 60 PUSH1 0xa0 0EC0 1B SHL 0EC1 03 SUB 0EC2 16 AND 0EC3 82 DUP3 0EC4 60 PUSH1 0x01 0EC6 60 PUSH1 0x01 0EC8 60 PUSH1 0xa0 0ECA 1B SHL 0ECB 03 SUB 0ECC 16 AND 0ECD 14 EQ 0ECE 15 ISZERO 0ECF 61 PUSH2 0x0f1a 0ED2 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0f1a, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) label_0ED3: // Incoming jump from 0x0ED2, if not !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @0ED5 memory[0x40:0x60] } 0ED3 60 PUSH1 0x40 0ED5 51 MLOAD 0ED6 62 PUSH3 0x461bcd 0EDA 60 PUSH1 0xe5 0EDC 1B SHL 0EDD 81 DUP2 0EDE 52 MSTORE 0EDF 60 PUSH1 0x20 0EE1 60 PUSH1 0x04 0EE3 82 DUP3 0EE4 01 ADD 0EE5 52 MSTORE 0EE6 60 PUSH1 0x19 0EE8 60 PUSH1 0x24 0EEA 82 DUP3 0EEB 01 ADD 0EEC 52 MSTORE 0EED 7F PUSH32 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 0F0E 60 PUSH1 0x44 0F10 82 DUP3 0F11 01 ADD 0F12 52 MSTORE 0F13 60 PUSH1 0x64 0F15 01 ADD 0F16 61 PUSH2 0x0742 0F19 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @0EDE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0EE5 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @0EEC memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x19 // @0F12 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 // @0F15 stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0742 label_0F1A: // Incoming jump from 0x0ED2, if !((0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-1]) // Inputs[1] { @0F1B stack[-1] } 0F1A 5B JUMPDEST 0F1B 80 DUP1 0F1C 60 PUSH1 0x05 0F1E 60 PUSH1 0x00 0F20 61 PUSH2 0x0f27 0F23 61 PUSH2 0x13e6 0F26 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0F1B stack[0] = stack[-1] // @0F1C stack[1] = 0x05 // @0F1E stack[2] = 0x00 // @0F20 stack[3] = 0x0f27 // } // Block ends with call to 0x13e6, returns to 0x0F27 label_0F27: // Incoming return from call to 0x13E6 at 0x0F26 // Inputs[8] // { // @0F30 stack[-1] // @0F33 stack[-2] // @0F3A stack[-3] // @0F47 memory[0x00:0x00 + 0x40 + stack[-2]] // @0F49 stack[-6] // @0F53 memory[0x00:0x40] // @0F55 storage[keccak256(memory[0x00:0x40])] // @0F5A stack[-4] // } 0F27 5B JUMPDEST 0F28 60 PUSH1 0x01 0F2A 60 PUSH1 0x01 0F2C 60 PUSH1 0xa0 0F2E 1B SHL 0F2F 03 SUB 0F30 90 SWAP1 0F31 81 DUP2 0F32 16 AND 0F33 82 DUP3 0F34 52 MSTORE 0F35 60 PUSH1 0x20 0F37 80 DUP1 0F38 83 DUP4 0F39 01 ADD 0F3A 93 SWAP4 0F3B 90 SWAP1 0F3C 93 SWAP4 0F3D 52 MSTORE 0F3E 60 PUSH1 0x40 0F40 91 SWAP2 0F41 82 DUP3 0F42 01 ADD 0F43 60 PUSH1 0x00 0F45 90 SWAP1 0F46 81 DUP2 0F47 20 SHA3 0F48 91 SWAP2 0F49 87 DUP8 0F4A 16 AND 0F4B 80 DUP1 0F4C 82 DUP3 0F4D 52 MSTORE 0F4E 91 SWAP2 0F4F 90 SWAP1 0F50 93 SWAP4 0F51 52 MSTORE 0F52 91 SWAP2 0F53 20 SHA3 0F54 80 DUP1 0F55 54 SLOAD 0F56 60 PUSH1 0xff 0F58 19 NOT 0F59 16 AND 0F5A 92 SWAP3 0F5B 15 ISZERO 0F5C 15 ISZERO 0F5D 92 SWAP3 0F5E 90 SWAP1 0F5F 92 SWAP3 0F60 17 OR 0F61 90 SWAP1 0F62 91 SWAP2 0F63 55 SSTORE 0F64 61 PUSH2 0x0f6b 0F67 61 PUSH2 0x13e6 0F6A 56 *JUMP // Stack delta = -2 // Outputs[7] // { // @0F34 memory[stack[-2]:stack[-2] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0F3D memory[stack[-2] + 0x20:stack[-2] + 0x20 + 0x20] = stack[-3] // @0F4D memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @0F51 memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x40 + stack[-2]]) // @0F62 stack[-4] = stack[-6] & (0x01 << 0xa0) - 0x01 // @0F63 storage[keccak256(memory[0x00:0x40])] = !!stack[-4] | (~0xff & storage[keccak256(memory[0x00:0x40])]) // @0F64 stack[-3] = 0x0f6b // } // Block ends with call to 0x13e6, returns to 0x0F6B label_0F6B: // Incoming return from call to 0x13E6 at 0x0F6A // Inputs[3] // { // @0F74 stack[-1] // @0F96 stack[-3] // @0F99 memory[0x40:0x60] // } 0F6B 5B JUMPDEST 0F6C 60 PUSH1 0x01 0F6E 60 PUSH1 0x01 0F70 60 PUSH1 0xa0 0F72 1B SHL 0F73 03 SUB 0F74 16 AND 0F75 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 0F96 83 DUP4 0F97 60 PUSH1 0x40 0F99 51 MLOAD 0F9A 61 PUSH2 0x0fa7 0F9D 91 SWAP2 0F9E 15 ISZERO 0F9F 15 ISZERO 0FA0 81 DUP2 0FA1 52 MSTORE 0FA2 60 PUSH1 0x20 0FA4 01 ADD 0FA5 90 SWAP1 0FA6 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @0F74 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @0F75 stack[0] = 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 // @0FA1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-3] // @0FA5 stack[1] = 0x20 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0fa7 label_0FA7: // Incoming jump from 0x0FA6 // Inputs[7] // { // @0FAA memory[0x40:0x60] // @0FAC stack[-1] // @0FAF memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]] // @0FAF stack[-3] // @0FAF stack[-4] // @0FAF stack[-2] // @0FB2 stack[-7] // } 0FA7 5B JUMPDEST 0FA8 60 PUSH1 0x40 0FAA 51 MLOAD 0FAB 80 DUP1 0FAC 91 SWAP2 0FAD 03 SUB 0FAE 90 SWAP1 0FAF A3 LOG3 0FB0 50 POP 0FB1 50 POP 0FB2 56 *JUMP // Stack delta = -7 // Outputs[1] { @0FAF log(memory[memory[0x40:0x60]:memory[0x40:0x60] + stack[-1] - memory[0x40:0x60]], [stack[-2], stack[-3], stack[-4]]); } // Block ends with unconditional jump to stack[-7] label_0FB3: // Incoming jump from 0x0BE6 0FB3 5B JUMPDEST 0FB4 61 PUSH2 0x0fc4 0FB7 61 PUSH2 0x0fbe 0FBA 61 PUSH2 0x13e6 0FBD 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @0FB4 stack[0] = 0x0fc4 // @0FB7 stack[1] = 0x0fbe // } // Block ends with call to 0x13e6, returns to 0x0FBE label_0FBE: // Incoming return from call to 0x13E6 at 0x0FBD // Inputs[1] { @0FBF stack[-4] } 0FBE 5B JUMPDEST 0FBF 83 DUP4 0FC0 61 PUSH2 0x1566 0FC3 56 *JUMP // Stack delta = +1 // Outputs[1] { @0FBF stack[0] = stack[-4] } // Block ends with unconditional jump to 0x1566 label_0FC4: // Incoming return from call to 0x0FBE at 0x0FBD // Inputs[1] { @0FC8 stack[-1] } 0FC4 5B JUMPDEST 0FC5 61 PUSH2 0x0fe0 0FC8 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0fe0, if stack[-1] label_0FC9: // Incoming jump from 0x0FC8, if not stack[-1] // Inputs[1] { @0FCB memory[0x40:0x60] } 0FC9 60 PUSH1 0x40 0FCB 51 MLOAD 0FCC 62 PUSH3 0x461bcd 0FD0 60 PUSH1 0xe5 0FD2 1B SHL 0FD3 81 DUP2 0FD4 52 MSTORE 0FD5 60 PUSH1 0x04 0FD7 01 ADD 0FD8 61 PUSH2 0x0742 0FDB 90 SWAP1 0FDC 61 PUSH2 0x2717 0FDF 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @0FD4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @0FDB stack[0] = 0x0742 // @0FDB stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2717, returns to 0x0742 label_0FE0: // Incoming jump from 0x0FC8, if stack[-1] // Inputs[4] // { // @0FE4 stack[-4] // @0FE5 stack[-3] // @0FE6 stack[-2] // @0FE7 stack[-1] // } 0FE0 5B JUMPDEST 0FE1 61 PUSH2 0x0fec 0FE4 84 DUP5 0FE5 84 DUP5 0FE6 84 DUP5 0FE7 84 DUP5 0FE8 61 PUSH2 0x1baa 0FEB 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @0FE1 stack[0] = 0x0fec // @0FE4 stack[1] = stack[-4] // @0FE5 stack[2] = stack[-3] // @0FE6 stack[3] = stack[-2] // @0FE7 stack[4] = stack[-1] // } // Block ends with call to 0x1baa, returns to 0x0FEC label_0FEC: // Incoming jump from 0x1BC5, if stack[-1] // Incoming jump from 0x27ED, if !(stack[-1] > stack[-4]) // Incoming return from call to 0x1BAA at 0x0FEB // Inputs[1] { @0FF1 stack[-5] } 0FEC 5B JUMPDEST 0FED 50 POP 0FEE 50 POP 0FEF 50 POP 0FF0 50 POP 0FF1 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_0FF2: // Incoming jump from 0x0553 // Inputs[1] { @0FFA stack[-1] } 0FF2 5B JUMPDEST 0FF3 60 PUSH1 0x60 0FF5 60 PUSH1 0x10 0FF7 61 PUSH2 0x0fff 0FFA 83 DUP4 0FFB 61 PUSH2 0x1bdd 0FFE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @0FF3 stack[0] = 0x60 // @0FF5 stack[1] = 0x10 // @0FF7 stack[2] = 0x0fff // @0FFA stack[3] = stack[-1] // } // Block ends with call to 0x1bdd, returns to 0x0FFF label_0FFF: // Incoming return from call to 0x1BDD at 0x0FFE // Inputs[3] // { // @1002 memory[0x40:0x60] // @1009 stack[-2] // @100A stack[-1] // } 0FFF 5B JUMPDEST 1000 60 PUSH1 0x40 1002 51 MLOAD 1003 60 PUSH1 0x20 1005 01 ADD 1006 61 PUSH2 0x1010 1009 92 SWAP3 100A 91 SWAP2 100B 90 SWAP1 100C 61 PUSH2 0x256e 100F 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1009 stack[-2] = 0x1010 // @100A stack[-1] = stack[-2] // @100B stack[1] = 0x20 + memory[0x40:0x60] // @100B stack[0] = stack[-1] // } // Block ends with call to 0x256e, returns to 0x1010 label_1010: // Incoming return from call to 0x256E at 0x100F // Inputs[5] // { // @1013 memory[0x40:0x60] // @1017 stack[-1] // @1020 stack[-2] // @1022 stack[-4] // @1023 stack[-3] // } 1010 5B JUMPDEST 1011 60 PUSH1 0x40 1013 51 MLOAD 1014 60 PUSH1 0x20 1016 81 DUP2 1017 83 DUP4 1018 03 SUB 1019 03 SUB 101A 81 DUP2 101B 52 MSTORE 101C 90 SWAP1 101D 60 PUSH1 0x40 101F 52 MSTORE 1020 90 SWAP1 1021 50 POP 1022 91 SWAP2 1023 90 SWAP1 1024 50 POP 1025 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @101B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] - memory[0x40:0x60] - 0x20 // @101F memory[0x40:0x60] = stack[-1] // @1022 stack[-4] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-4] label_1026: // Incoming call from 0x0568, returns to 0x02A2 1026 5B JUMPDEST 1027 61 PUSH2 0x102e 102A 61 PUSH2 0x13e6 102D 56 *JUMP // Stack delta = +1 // Outputs[1] { @1027 stack[0] = 0x102e } // Block ends with call to 0x13e6, returns to 0x102E label_102E: // Incoming return from call to 0x13E6 at 0x102D // Inputs[2] // { // @1037 stack[-1] // @103D storage[0x0d] // } 102E 5B JUMPDEST 102F 60 PUSH1 0x01 1031 60 PUSH1 0x01 1033 60 PUSH1 0xa0 1035 1B SHL 1036 03 SUB 1037 16 AND 1038 61 PUSH2 0x1049 103B 60 PUSH1 0x0d 103D 54 SLOAD 103E 60 PUSH1 0x01 1040 60 PUSH1 0x01 1042 60 PUSH1 0xa0 1044 1B SHL 1045 03 SUB 1046 16 AND 1047 90 SWAP1 1048 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1037 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @1047 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x0d] // } // Block ends with unconditional jump to 0x1049 label_1049: // Incoming jump from 0x1048 // Inputs[2] // { // @1052 stack[-1] // @1053 stack[-2] // } 1049 5B JUMPDEST 104A 60 PUSH1 0x01 104C 60 PUSH1 0x01 104E 60 PUSH1 0xa0 1050 1B SHL 1051 03 SUB 1052 16 AND 1053 14 EQ 1054 61 PUSH2 0x106f 1057 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x106f, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_1058: // Incoming jump from 0x1057, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @105A memory[0x40:0x60] } 1058 60 PUSH1 0x40 105A 51 MLOAD 105B 62 PUSH3 0x461bcd 105F 60 PUSH1 0xe5 1061 1B SHL 1062 81 DUP2 1063 52 MSTORE 1064 60 PUSH1 0x04 1066 01 ADD 1067 61 PUSH2 0x0742 106A 90 SWAP1 106B 61 PUSH2 0x26e2 106E 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1063 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @106A stack[0] = 0x0742 // @106A stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x26e2, returns to 0x0742 label_106F: // Incoming jump from 0x1057, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[7] // { // @107A memory[0x40:0x60] // @107B block.coinbase // @1085 block.timestamp // @108A block.difficulty // @1095 memory[0x40:0x60] // @10A7 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] // @10AA memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]] // } 106F 5B JUMPDEST 1070 60 PUSH1 0x00 1072 60 PUSH1 0x64 1074 61 PUSH2 0x10ad 1077 60 PUSH1 0x40 1079 80 DUP1 107A 51 MLOAD 107B 41 COINBASE 107C 60 PUSH1 0x20 107E 80 DUP1 107F 83 DUP4 1080 01 ADD 1081 91 SWAP2 1082 90 SWAP1 1083 91 SWAP2 1084 52 MSTORE 1085 42 TIMESTAMP 1086 82 DUP3 1087 84 DUP5 1088 01 ADD 1089 52 MSTORE 108A 44 DIFFICULTY 108B 60 PUSH1 0x60 108D 80 DUP1 108E 84 DUP5 108F 01 ADD 1090 91 SWAP2 1091 90 SWAP1 1092 91 SWAP2 1093 52 MSTORE 1094 83 DUP4 1095 51 MLOAD 1096 80 DUP1 1097 84 DUP5 1098 03 SUB 1099 90 SWAP1 109A 91 SWAP2 109B 01 ADD 109C 81 DUP2 109D 52 MSTORE 109E 60 PUSH1 0x80 10A0 90 SWAP1 10A1 92 SWAP3 10A2 01 ADD 10A3 90 SWAP1 10A4 92 SWAP3 10A5 52 MSTORE 10A6 80 DUP1 10A7 51 MLOAD 10A8 91 SWAP2 10A9 01 ADD 10AA 20 SHA3 10AB 90 SWAP1 10AC 56 *JUMP // Stack delta = +3 // Outputs[8] // { // @1070 stack[0] = 0x00 // @1072 stack[1] = 0x64 // @1084 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = block.coinbase // @1089 memory[0x40 + memory[0x40:0x60]:0x40 + memory[0x40:0x60] + 0x20] = block.timestamp // @1093 memory[memory[0x40:0x60] + 0x60:memory[0x40:0x60] + 0x60 + 0x20] = block.difficulty // @109D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x60 + (memory[0x40:0x60] - memory[0x40:0x60]) // @10A5 memory[0x40:0x60] = memory[0x40:0x60] + 0x80 // @10AB stack[2] = keccak256(memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20]]) // } // Block ends with unconditional jump to 0x10ad label_10AD: // Incoming jump from 0x10AC // Inputs[2] // { // @10B1 stack[-2] // @10B2 stack[-1] // } 10AD 5B JUMPDEST 10AE 61 PUSH2 0x10b7 10B1 91 SWAP2 10B2 90 SWAP1 10B3 61 PUSH2 0x284c 10B6 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @10B1 stack[-2] = 0x10b7 // @10B2 stack[-1] = stack[-2] // @10B2 stack[0] = stack[-1] // } // Block ends with call to 0x284c, returns to 0x10B7 label_10B7: // Incoming return from call to 0x284C at 0x10B6 // Inputs[2] // { // @10B8 stack[-1] // @10B8 stack[-2] // } 10B7 5B JUMPDEST 10B8 90 SWAP1 10B9 50 POP 10BA 60 PUSH1 0x00 10BC 5B JUMPDEST 10BD 60 PUSH1 0x0a 10BF 81 DUP2 10C0 10 LT 10C1 15 ISZERO 10C2 61 PUSH2 0x1127 10C5 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @10B8 stack[-2] = stack[-1] // @10BA stack[-1] = 0x00 // } // Block ends with conditional jump to 0x1127, if !(0x00 < 0x0a) label_10C6: // Incoming jump from 0x10C5, if not !(0x00 < 0x0a) 10C6 60 PUSH1 0x00 10C8 61 PUSH2 0x10cf 10CB 61 PUSH2 0x185a 10CE 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @10C6 stack[0] = 0x00 // @10C8 stack[1] = 0x10cf // } // Block ends with unconditional jump to 0x185a 10CF 5B JUMPDEST 10D0 90 SWAP1 10D1 50 POP 10D2 61 PUSH2 0x110c 10D5 61 PUSH2 0x1106 10D8 84 DUP5 10D9 61 PUSH2 0x10e3 10DC 85 DUP6 10DD 60 PUSH1 0x64 10DF 61 PUSH2 0x2794 10E2 56 *JUMP 10E3 5B JUMPDEST 10E4 60 PUSH1 0x11 10E6 54 SLOAD 10E7 61 PUSH2 0x10f2 10EA 90 SWAP1 10EB 61 PUSH2 0x03e8 10EE 61 PUSH2 0x2794 10F1 56 *JUMP 10F2 5B JUMPDEST 10F3 61 PUSH2 0x10fc 10F6 91 SWAP2 10F7 90 SWAP1 10F8 61 PUSH2 0x2768 10FB 56 *JUMP 10FC 5B JUMPDEST 10FD 61 PUSH2 0x0411 1100 91 SWAP2 1101 90 SWAP1 1102 61 PUSH2 0x2768 1105 56 *JUMP 1106 5B JUMPDEST 1107 82 DUP3 1108 61 PUSH2 0x186b 110B 56 *JUMP 110C 5B JUMPDEST 110D 61 PUSH2 0x1114 1110 61 PUSH2 0x19b9 1113 56 *JUMP 1114 5B JUMPDEST 1115 50 POP 1116 80 DUP1 1117 61 PUSH2 0x111f 111A 81 DUP2 111B 61 PUSH2 0x2831 111E 56 *JUMP 111F 5B JUMPDEST 1120 91 SWAP2 1121 50 POP 1122 50 POP 1123 61 PUSH2 0x10bc 1126 56 *JUMP label_1127: // Incoming jump from 0x10C5, if !(0x00 < 0x0a) // Inputs[1] { @112B storage[0x11] } 1127 5B JUMPDEST 1128 50 POP 1129 60 PUSH1 0x11 112B 54 SLOAD 112C 61 PUSH2 0x1136 112F 90 SWAP1 1130 60 PUSH1 0x01 1132 61 PUSH2 0x2768 1135 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @112F stack[0] = storage[0x11] // @112F stack[-1] = 0x1136 // @1130 stack[1] = 0x01 // } // Block ends with call to 0x2768, returns to 0x1136 label_1136: // Incoming return from call to 0x2768 at 0x1135 // Inputs[2] // { // @1139 stack[-1] // @113B stack[-3] // } 1136 5B JUMPDEST 1137 60 PUSH1 0x11 1139 55 SSTORE 113A 50 POP 113B 56 *JUMP // Stack delta = -3 // Outputs[1] { @1139 storage[0x11] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_113C: // Incoming call from 0x057D, returns to 0x023D // Inputs[1] { @1140 storage[0x10] } 113C 5B JUMPDEST 113D 60 PUSH1 0x10 113F 80 DUP1 1140 54 SLOAD 1141 61 PUSH2 0x1149 1144 90 SWAP1 1145 61 PUSH2 0x27f6 1148 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @113D stack[0] = 0x10 // @1144 stack[1] = 0x1149 // @1144 stack[2] = storage[0x10] // } // Block ends with call to 0x27f6, returns to 0x1149 label_1149: // Incoming return from call to 0x27F6 at 0x1148 // Inputs[4] // { // @114A stack[-1] // @1159 memory[0x40:0x60] // @1161 stack[-2] // @116C storage[stack[-2]] // } 1149 5B JUMPDEST 114A 80 DUP1 114B 60 PUSH1 0x1f 114D 01 ADD 114E 60 PUSH1 0x20 1150 80 DUP1 1151 91 SWAP2 1152 04 DIV 1153 02 MUL 1154 60 PUSH1 0x20 1156 01 ADD 1157 60 PUSH1 0x40 1159 51 MLOAD 115A 90 SWAP1 115B 81 DUP2 115C 01 ADD 115D 60 PUSH1 0x40 115F 52 MSTORE 1160 80 DUP1 1161 92 SWAP3 1162 91 SWAP2 1163 90 SWAP1 1164 81 DUP2 1165 81 DUP2 1166 52 MSTORE 1167 60 PUSH1 0x20 1169 01 ADD 116A 82 DUP3 116B 80 DUP1 116C 54 SLOAD 116D 61 PUSH2 0x1175 1170 90 SWAP1 1171 61 PUSH2 0x27f6 1174 56 *JUMP // Stack delta = +5 // Outputs[9] // { // @115F memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-1]) / 0x20 * 0x20 // @1161 stack[-2] = memory[0x40:0x60] // @1162 stack[-1] = stack[-2] // @1163 stack[0] = stack[-1] // @1166 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1169 stack[1] = 0x20 + memory[0x40:0x60] // @116A stack[2] = stack[-2] // @1170 stack[4] = storage[stack[-2]] // @1170 stack[3] = 0x1175 // } // Block ends with call to 0x27f6, returns to 0x1175 label_1175: // Incoming return from call to 0x27F6 at 0x1174 // Inputs[1] { @1176 stack[-1] } 1175 5B JUMPDEST 1176 80 DUP1 1177 15 ISZERO 1178 61 PUSH2 0x11c2 117B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x11c2, if !stack[-1] label_117C: // Incoming jump from 0x117B, if not !stack[-1] // Inputs[1] { @117C stack[-1] } 117C 80 DUP1 117D 60 PUSH1 0x1f 117F 10 LT 1180 61 PUSH2 0x1197 1183 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1197, if 0x1f < stack[-1] label_1184: // Incoming jump from 0x1183, if not 0x1f < stack[-1] // Inputs[4] // { // @1188 stack[-2] // @1189 storage[stack[-2]] // @118C stack[-3] // @118E stack[-1] // } 1184 61 PUSH2 0x0100 1187 80 DUP1 1188 83 DUP4 1189 54 SLOAD 118A 04 DIV 118B 02 MUL 118C 83 DUP4 118D 52 MSTORE 118E 91 SWAP2 118F 60 PUSH1 0x20 1191 01 ADD 1192 91 SWAP2 1193 61 PUSH2 0x11c2 1196 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @118D memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1192 stack[-1] = stack[-1] // @1192 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x11c2 label_1197: // Incoming jump from 0x1183, if 0x1f < stack[-1] // Inputs[5] // { // @1198 stack[-3] // @1199 stack[-1] // @119B stack[-2] // @11A3 memory[0x00:0x20] // @11A7 storage[keccak256(memory[0x00:0x20])] // } 1197 5B JUMPDEST 1198 82 DUP3 1199 01 ADD 119A 91 SWAP2 119B 90 SWAP1 119C 60 PUSH1 0x00 119E 52 MSTORE 119F 60 PUSH1 0x20 11A1 60 PUSH1 0x00 11A3 20 SHA3 11A4 90 SWAP1 11A5 5B JUMPDEST 11A6 81 DUP2 11A7 54 SLOAD 11A8 81 DUP2 11A9 52 MSTORE 11AA 90 SWAP1 11AB 60 PUSH1 0x01 11AD 01 ADD 11AE 90 SWAP1 11AF 60 PUSH1 0x20 11B1 01 ADD 11B2 80 DUP1 11B3 83 DUP4 11B4 11 GT 11B5 61 PUSH2 0x11a5 11B8 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @119A stack[-3] = stack[-3] + stack[-1] // @119E memory[0x00:0x20] = stack[-2] // @11A9 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @11AE stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @11B1 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x11a5, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_11B9: // Incoming jump from 0x11B8, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x11B8, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @11B9 stack[-3] // @11BA stack[-1] // } 11B9 82 DUP3 11BA 90 SWAP1 11BB 03 SUB 11BC 60 PUSH1 0x1f 11BE 16 AND 11BF 82 DUP3 11C0 01 ADD 11C1 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @11C1 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @11C1 stack[-1] = stack[-3] // } // Block continues label_11C2: // Incoming jump from 0x1196 // Incoming jump from 0x117B, if !stack[-1] // Incoming jump from 0x11C1 // Inputs[1] { @11C8 stack[-7] } 11C2 5B JUMPDEST 11C3 50 POP 11C4 50 POP 11C5 50 POP 11C6 50 POP 11C7 50 POP 11C8 81 DUP2 11C9 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_11CA: // Incoming jump from 0x05A6 // Inputs[2] // { // @11CD storage[0x12] // @11CE block.timestamp // } 11CA 5B JUMPDEST 11CB 60 PUSH1 0x12 11CD 54 SLOAD 11CE 42 TIMESTAMP 11CF 10 LT 11D0 15 ISZERO 11D1 61 PUSH2 0x1210 11D4 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1210, if !(block.timestamp < storage[0x12]) label_11D5: // Incoming jump from 0x11D4, if not !(block.timestamp < storage[0x12]) // Inputs[1] { @11D7 memory[0x40:0x60] } 11D5 60 PUSH1 0x40 11D7 51 MLOAD 11D8 62 PUSH3 0x461bcd 11DC 60 PUSH1 0xe5 11DE 1B SHL 11DF 81 DUP2 11E0 52 MSTORE 11E1 60 PUSH1 0x20 11E3 60 PUSH1 0x04 11E5 82 DUP3 11E6 01 ADD 11E7 52 MSTORE 11E8 60 PUSH1 0x11 11EA 60 PUSH1 0x24 11EC 82 DUP3 11ED 01 ADD 11EE 52 MSTORE 11EF 70 PUSH17 0x125d09dcc81b9bdd081d1a5b59481e595d 1201 60 PUSH1 0x7a 1203 1B SHL 1204 60 PUSH1 0x44 1206 82 DUP3 1207 01 ADD 1208 52 MSTORE 1209 60 PUSH1 0x64 120B 01 ADD 120C 61 PUSH2 0x0742 120F 56 *JUMP // Stack delta = +1 // Outputs[5] // { // @11E0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @11E7 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @11EE memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x11 // @1208 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x125d09dcc81b9bdd081d1a5b59481e595d << 0x7a // @120B stack[0] = 0x64 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0742 label_1210: // Incoming jump from 0x11D4, if !(block.timestamp < storage[0x12]) // Inputs[1] { @1213 stack[-1] } 1210 5B JUMPDEST 1211 60 PUSH1 0x00 1213 81 DUP2 1214 11 GT 1215 80 DUP1 1216 15 ISZERO 1217 61 PUSH2 0x1221 121A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1214 stack[0] = stack[-1] > 0x00 } // Block ends with conditional jump to 0x1221, if !(stack[-1] > 0x00) label_121B: // Incoming jump from 0x121A, if not !(stack[-1] > 0x00) // Inputs[1] { @121E stack[-2] } 121B 50 POP 121C 60 PUSH1 0x14 121E 81 DUP2 121F 11 GT 1220 15 ISZERO 1221 5B JUMPDEST 1222 61 PUSH2 0x122a 1225 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x122a, if !(stack[-2] > 0x14) label_1226: // Incoming jump from 0x1225, if not !(stack[-2] > 0x14) // Incoming jump from 0x1225, if not stack[-1] // Inputs[1] { @1229 memory[0x00:0x00] } 1226 60 PUSH1 0x00 1228 80 DUP1 1229 FD *REVERT // Stack delta = +0 // Outputs[1] { @1229 revert(memory[0x00:0x00]); } // Block terminates label_122A: // Incoming jump from 0x1225, if !(stack[-2] > 0x14) // Incoming jump from 0x1225, if stack[-1] // Inputs[1] { @122E stack[-1] } 122A 5B JUMPDEST 122B 61 PUSH2 0x123b 122E 81 DUP2 122F 66 PUSH7 0x6a94d74f430000 1237 61 PUSH2 0x2794 123A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @122B stack[0] = 0x123b // @122E stack[1] = stack[-1] // @122F stack[2] = 0x6a94d74f430000 // } // Block ends with call to 0x2794, returns to 0x123B label_123B: // Incoming return from call to 0x2794 at 0x123A // Inputs[2] // { // @123C msg.value // @123D stack[-1] // } 123B 5B JUMPDEST 123C 34 CALLVALUE 123D 14 EQ 123E 61 PUSH2 0x1246 1241 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1246, if msg.value == stack[-1] label_1242: // Incoming jump from 0x1241, if not msg.value == stack[-1] // Inputs[1] { @1245 memory[0x00:0x00] } 1242 60 PUSH1 0x00 1244 80 DUP1 1245 FD *REVERT // Stack delta = +0 // Outputs[1] { @1245 revert(memory[0x00:0x00]); } // Block terminates label_1246: // Incoming jump from 0x1241, if msg.value == stack[-1] // Inputs[1] { @124A stack[-1] } 1246 5B JUMPDEST 1247 60 PUSH1 0x00 1249 5B JUMPDEST 124A 81 DUP2 124B 81 DUP2 124C 10 LT 124D 15 ISZERO 124E 61 PUSH2 0x0e42 1251 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1247 stack[0] = 0x00 } // Block ends with conditional jump to 0x0e42, if !(0x00 < stack[-1]) label_1252: // Incoming jump from 0x1251, if not !(0x00 < stack[-1]) 1252 60 PUSH1 0x00 1254 61 PUSH2 0x125b 1257 61 PUSH2 0x185a 125A 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1252 stack[0] = 0x00 // @1254 stack[1] = 0x125b // } // Block ends with unconditional jump to 0x185a 125B 5B JUMPDEST 125C 90 SWAP1 125D 50 POP 125E 61 PUSH2 0x1267 1261 33 CALLER 1262 82 DUP3 1263 61 PUSH2 0x186b 1266 56 *JUMP 1267 5B JUMPDEST 1268 61 PUSH2 0x126f 126B 61 PUSH2 0x19b9 126E 56 *JUMP 126F 5B JUMPDEST 1270 50 POP 1271 80 DUP1 1272 61 PUSH2 0x127a 1275 81 DUP2 1276 61 PUSH2 0x2831 1279 56 *JUMP 127A 5B JUMPDEST 127B 91 SWAP2 127C 50 POP 127D 50 POP 127E 61 PUSH2 0x1249 1281 56 *JUMP label_1282: // Incoming jump from 0x060F 1282 5B JUMPDEST 1283 61 PUSH2 0x128a 1286 61 PUSH2 0x13e6 1289 56 *JUMP // Stack delta = +1 // Outputs[1] { @1283 stack[0] = 0x128a } // Block ends with call to 0x13e6, returns to 0x128A label_128A: // Incoming return from call to 0x13E6 at 0x1289 // Inputs[2] // { // @1293 stack[-1] // @1299 storage[0x0d] // } 128A 5B JUMPDEST 128B 60 PUSH1 0x01 128D 60 PUSH1 0x01 128F 60 PUSH1 0xa0 1291 1B SHL 1292 03 SUB 1293 16 AND 1294 61 PUSH2 0x12a5 1297 60 PUSH1 0x0d 1299 54 SLOAD 129A 60 PUSH1 0x01 129C 60 PUSH1 0x01 129E 60 PUSH1 0xa0 12A0 1B SHL 12A1 03 SUB 12A2 16 AND 12A3 90 SWAP1 12A4 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1293 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-1] // @12A3 stack[0] = (0x01 << 0xa0) - 0x01 & storage[0x0d] // } // Block ends with unconditional jump to 0x12a5 label_12A5: // Incoming jump from 0x12A4 // Inputs[2] // { // @12AE stack[-1] // @12AF stack[-2] // } 12A5 5B JUMPDEST 12A6 60 PUSH1 0x01 12A8 60 PUSH1 0x01 12AA 60 PUSH1 0xa0 12AC 1B SHL 12AD 03 SUB 12AE 16 AND 12AF 14 EQ 12B0 61 PUSH2 0x12cb 12B3 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x12cb, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_12B4: // Incoming jump from 0x12B3, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @12B6 memory[0x40:0x60] } 12B4 60 PUSH1 0x40 12B6 51 MLOAD 12B7 62 PUSH3 0x461bcd 12BB 60 PUSH1 0xe5 12BD 1B SHL 12BE 81 DUP2 12BF 52 MSTORE 12C0 60 PUSH1 0x04 12C2 01 ADD 12C3 61 PUSH2 0x0742 12C6 90 SWAP1 12C7 61 PUSH2 0x26e2 12CA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @12BF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @12C6 stack[0] = 0x0742 // @12C6 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x26e2, returns to 0x0742 label_12CB: // Incoming jump from 0x12B3, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @12D4 stack[-1] } 12CB 5B JUMPDEST 12CC 60 PUSH1 0x01 12CE 60 PUSH1 0x01 12D0 60 PUSH1 0xa0 12D2 1B SHL 12D3 03 SUB 12D4 81 DUP2 12D5 16 AND 12D6 61 PUSH2 0x1330 12D9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1330, if stack[-1] & (0x01 << 0xa0) - 0x01 label_12DA: // Incoming jump from 0x12D9, if not stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @12DC memory[0x40:0x60] } 12DA 60 PUSH1 0x40 12DC 51 MLOAD 12DD 62 PUSH3 0x461bcd 12E1 60 PUSH1 0xe5 12E3 1B SHL 12E4 81 DUP2 12E5 52 MSTORE 12E6 60 PUSH1 0x20 12E8 60 PUSH1 0x04 12EA 82 DUP3 12EB 01 ADD 12EC 52 MSTORE 12ED 60 PUSH1 0x26 12EF 60 PUSH1 0x24 12F1 82 DUP3 12F2 01 ADD 12F3 52 MSTORE 12F4 7F PUSH32 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 1315 60 PUSH1 0x44 1317 82 DUP3 1318 01 ADD 1319 52 MSTORE 131A 65 PUSH6 0x646472657373 1321 60 PUSH1 0xd0 1323 1B SHL 1324 60 PUSH1 0x64 1326 82 DUP3 1327 01 ADD 1328 52 MSTORE 1329 60 PUSH1 0x84 132B 01 ADD 132C 61 PUSH2 0x0742 132F 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @12E5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @12EC memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @12F3 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x26 // @1319 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4f776e61626c653a206e6577206f776e657220697320746865207a65726f2061 // @1328 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x646472657373 << 0xd0 // @132B stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0742 label_1330: // Incoming jump from 0x12D9, if stack[-1] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1334 stack[-1] } 1330 5B JUMPDEST 1331 61 PUSH2 0x0bc9 1334 81 DUP2 1335 61 PUSH2 0x1808 1338 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1331 stack[0] = 0x0bc9 // @1334 stack[1] = stack[-1] // } // Block ends with call to 0x1808, returns to 0x0BC9 label_1339: // Incoming call from 0x13EF, returns to 0x13F0 // Inputs[2] // { // @133C msg.sender // @133D address(this) // } 1339 5B JUMPDEST 133A 60 PUSH1 0x00 133C 33 CALLER 133D 30 ADDRESS 133E 14 EQ 133F 15 ISZERO 1340 61 PUSH2 0x1390 1343 57 *JUMPI // Stack delta = +1 // Outputs[1] { @133A stack[0] = 0x00 } // Block ends with conditional jump to 0x1390, if !(address(this) == msg.sender) label_1344: // Incoming jump from 0x1343, if not !(address(this) == msg.sender) // Inputs[6] // { // @1347 msg.data.length // @1358 memory[0x40:0x60] // @136F msg.data[0x00:0x00 + msg.data.length] // @137C msg.data.length // @137E memory[msg.data.length + memory[0x40:0x60]:msg.data.length + memory[0x40:0x60] + 0x20] // @1388 stack[-1] // } 1344 60 PUSH1 0x00 1346 80 DUP1 1347 36 CALLDATASIZE 1348 80 DUP1 1349 80 DUP1 134A 60 PUSH1 0x1f 134C 01 ADD 134D 60 PUSH1 0x20 134F 80 DUP1 1350 91 SWAP2 1351 04 DIV 1352 02 MUL 1353 60 PUSH1 0x20 1355 01 ADD 1356 60 PUSH1 0x40 1358 51 MLOAD 1359 90 SWAP1 135A 81 DUP2 135B 01 ADD 135C 60 PUSH1 0x40 135E 52 MSTORE 135F 80 DUP1 1360 93 SWAP4 1361 92 SWAP3 1362 91 SWAP2 1363 90 SWAP1 1364 81 DUP2 1365 81 DUP2 1366 52 MSTORE 1367 60 PUSH1 0x20 1369 01 ADD 136A 83 DUP4 136B 83 DUP4 136C 80 DUP1 136D 82 DUP3 136E 84 DUP5 136F 37 CALLDATACOPY 1370 60 PUSH1 0x00 1372 92 SWAP3 1373 01 ADD 1374 91 SWAP2 1375 90 SWAP1 1376 91 SWAP2 1377 52 MSTORE 1378 50 POP 1379 50 POP 137A 50 POP 137B 50 POP 137C 36 CALLDATASIZE 137D 01 ADD 137E 51 MLOAD 137F 60 PUSH1 0x01 1381 60 PUSH1 0x01 1383 60 PUSH1 0xa0 1385 1B SHL 1386 03 SUB 1387 16 AND 1388 91 SWAP2 1389 50 POP 138A 61 PUSH2 0x1393 138D 90 SWAP1 138E 50 POP 138F 56 *JUMP // Stack delta = +0 // Outputs[5] // { // @135E memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + msg.data.length) / 0x20 * 0x20 // @1366 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = msg.data.length // @136F memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + msg.data.length] = msg.data[0x00:0x00 + msg.data.length] // @1377 memory[0x20 + memory[0x40:0x60] + msg.data.length:0x20 + memory[0x40:0x60] + msg.data.length + 0x20] = 0x00 // @1388 stack[-1] = (0x01 << 0xa0) - 0x01 & memory[msg.data.length + memory[0x40:0x60]:msg.data.length + memory[0x40:0x60] + 0x20] // } // Block ends with unconditional jump to 0x1393 label_1390: // Incoming jump from 0x1343, if !(address(this) == msg.sender) // Inputs[2] // { // @1392 msg.sender // @1394 stack[-2] // } 1390 5B JUMPDEST 1391 50 POP 1392 33 CALLER 1393 5B JUMPDEST 1394 90 SWAP1 1395 56 *JUMP // Stack delta = -1 // Outputs[1] { @1394 stack[-2] = msg.sender } // Block ends with unconditional jump to stack[-2] label_1396: // Incoming call from 0x0634, returns to 0x0635 // Inputs[1] { @13A2 stack[-1] } 1396 5B JUMPDEST 1397 60 PUSH1 0x00 1399 60 PUSH1 0x01 139B 60 PUSH1 0x01 139D 60 PUSH1 0xe0 139F 1B SHL 13A0 03 SUB 13A1 19 NOT 13A2 82 DUP3 13A3 16 AND 13A4 63 PUSH4 0x80ac58cd 13A9 60 PUSH1 0xe0 13AB 1B SHL 13AC 14 EQ 13AD 80 DUP1 13AE 61 PUSH2 0x13c7 13B1 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1397 stack[0] = 0x00 // @13AC stack[1] = 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // } // Block ends with conditional jump to 0x13c7, if 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_13B2: // Incoming jump from 0x13B1, if not 0x80ac58cd << 0xe0 == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @13BC stack[-3] } 13B2 50 POP 13B3 60 PUSH1 0x01 13B5 60 PUSH1 0x01 13B7 60 PUSH1 0xe0 13B9 1B SHL 13BA 03 SUB 13BB 19 NOT 13BC 82 DUP3 13BD 16 AND 13BE 63 PUSH4 0x5b5e139f 13C3 60 PUSH1 0xe0 13C5 1B SHL 13C6 14 EQ 13C7 5B JUMPDEST 13C8 80 DUP1 13C9 61 PUSH2 0x0635 13CC 57 *JUMPI // Stack delta = +0 // Outputs[1] { @13C6 stack[-1] = 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) } // Block ends with conditional jump to 0x0635, if 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) label_13CD: // Incoming jump from 0x13CC, if not stack[-1] // Incoming jump from 0x13CC, if not 0x5b5e139f << 0xe0 == stack[-3] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @13DF stack[-3] } 13CD 50 POP 13CE 63 PUSH4 0x01ffc9a7 13D3 60 PUSH1 0xe0 13D5 1B SHL 13D6 60 PUSH1 0x01 13D8 60 PUSH1 0x01 13DA 60 PUSH1 0xe0 13DC 1B SHL 13DD 03 SUB 13DE 19 NOT 13DF 83 DUP4 13E0 16 AND 13E1 14 EQ 13E2 61 PUSH2 0x0635 13E5 56 *JUMP // Stack delta = +0 // Outputs[1] { @13E1 stack[-1] = stack[-3] & ~((0x01 << 0xe0) - 0x01) == 0x01ffc9a7 << 0xe0 } // Block ends with unconditional jump to 0x0635 label_13E6: // Incoming call from 0x0E5C, returns to 0x0E5D // Incoming call from 0x0FBD, returns to 0x0FBE // Incoming call from 0x1289, returns to 0x128A // Incoming call from 0x102D, returns to 0x102E // Incoming call from 0x0EB8, returns to 0x0EB9 // Incoming call from 0x0DE2, returns to 0x0DE3 // Incoming call from 0x0F6A, returns to 0x0F6B // Incoming call from 0x0D8D, returns to 0x0D8E // Incoming call from 0x07F1, returns to 0x07F2 // Incoming call from 0x0A83, returns to 0x0A84 // Incoming call from 0x0B4E, returns to 0x0B4F // Incoming call from 0x1E84, returns to 0x1E85 // Incoming call from 0x080D, returns to 0x05C2 // Incoming call from 0x0F26, returns to 0x0F27 13E6 5B JUMPDEST 13E7 60 PUSH1 0x00 13E9 61 PUSH2 0x13f0 13EC 61 PUSH2 0x1339 13EF 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @13E7 stack[0] = 0x00 // @13E9 stack[1] = 0x13f0 // } // Block ends with call to 0x1339, returns to 0x13F0 label_13F0: // Incoming return from call to 0x1339 at 0x13EF // Inputs[3] // { // @13F1 stack[-2] // @13F1 stack[-1] // @13F3 stack[-3] // } 13F0 5B JUMPDEST 13F1 90 SWAP1 13F2 50 POP 13F3 90 SWAP1 13F4 56 *JUMP // Stack delta = -2 // Outputs[1] { @13F3 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_13F5: // Incoming call from 0x0889, returns to 0x088A // Incoming call from 0x174F, returns to 0x1750 // Inputs[4] // { // @13F8 stack[-1] // @1403 memory[0x00:0x40] // @1405 storage[keccak256(memory[0x00:0x40])] // @1418 stack[-2] // } 13F5 5B JUMPDEST 13F6 60 PUSH1 0x00 13F8 81 DUP2 13F9 81 DUP2 13FA 52 MSTORE 13FB 60 PUSH1 0x04 13FD 60 PUSH1 0x20 13FF 52 MSTORE 1400 60 PUSH1 0x40 1402 90 SWAP1 1403 20 SHA3 1404 80 DUP1 1405 54 SLOAD 1406 60 PUSH1 0x01 1408 60 PUSH1 0x01 140A 60 PUSH1 0xa0 140C 1B SHL 140D 03 SUB 140E 19 NOT 140F 16 AND 1410 60 PUSH1 0x01 1412 60 PUSH1 0x01 1414 60 PUSH1 0xa0 1416 1B SHL 1417 03 SUB 1418 84 DUP5 1419 16 AND 141A 90 SWAP1 141B 81 DUP2 141C 17 OR 141D 90 SWAP1 141E 91 SWAP2 141F 55 SSTORE 1420 81 DUP2 1421 90 SWAP1 1422 61 PUSH2 0x142a 1425 82 DUP3 1426 61 PUSH2 0x0c88 1429 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @13FA memory[0x00:0x20] = stack[-1] // @13FF memory[0x20:0x40] = 0x04 // @141F storage[keccak256(memory[0x00:0x40])] = (stack[-2] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1421 stack[0] = stack[-1] // @1421 stack[1] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1422 stack[2] = 0x142a // @1425 stack[3] = stack[-1] // } // Block ends with call to 0x0c88, returns to 0x142A label_142A: // Incoming return from call to 0x0C88 at 0x1429 // Inputs[7] // { // @1433 stack[-1] // @1457 memory[0x40:0x60] // @145A memory[0x40:0x60] // @145F stack[-2] // @145F memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @145F stack[-3] // @1462 stack[-6] // } 142A 5B JUMPDEST 142B 60 PUSH1 0x01 142D 60 PUSH1 0x01 142F 60 PUSH1 0xa0 1431 1B SHL 1432 03 SUB 1433 16 AND 1434 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 1455 60 PUSH1 0x40 1457 51 MLOAD 1458 60 PUSH1 0x40 145A 51 MLOAD 145B 80 DUP1 145C 91 SWAP2 145D 03 SUB 145E 90 SWAP1 145F A4 LOG4 1460 50 POP 1461 50 POP 1462 56 *JUMP // Stack delta = -6 // Outputs[1] { @145F log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & (0x01 << 0xa0) - 0x01, stack[-2], stack[-3]]); } // Block ends with unconditional jump to stack[-6] 1463 5B JUMPDEST 1464 60 PUSH1 0x00 1466 60 PUSH1 0x01 1468 60 PUSH1 0x01 146A 60 PUSH1 0xa0 146C 1B SHL 146D 03 SUB 146E 86 DUP7 146F 16 AND 1470 61 PUSH2 0x14c9 1473 57 *JUMPI 1474 60 PUSH1 0x40 1476 51 MLOAD 1477 62 PUSH3 0x461bcd 147B 60 PUSH1 0xe5 147D 1B SHL 147E 81 DUP2 147F 52 MSTORE 1480 60 PUSH1 0x20 1482 60 PUSH1 0x04 1484 82 DUP3 1485 01 ADD 1486 52 MSTORE 1487 60 PUSH1 0x25 1489 60 PUSH1 0x24 148B 82 DUP3 148C 01 ADD 148D 52 MSTORE 148E 7F PUSH32 0x4e61746976654d6574615472616e73616374696f6e3a20494e56414c49445f53 14AF 60 PUSH1 0x44 14B1 82 DUP3 14B2 01 ADD 14B3 52 MSTORE 14B4 64 PUSH5 0x24a3a722a9 14BA 60 PUSH1 0xd9 14BC 1B SHL 14BD 60 PUSH1 0x64 14BF 82 DUP3 14C0 01 ADD 14C1 52 MSTORE 14C2 60 PUSH1 0x84 14C4 01 ADD 14C5 61 PUSH2 0x0742 14C8 56 *JUMP 14C9 5B JUMPDEST 14CA 60 PUSH1 0x01 14CC 61 PUSH2 0x14dc 14CF 61 PUSH2 0x14d7 14D2 87 DUP8 14D3 61 PUSH2 0x1cf7 14D6 56 *JUMP 14D7 5B JUMPDEST 14D8 61 PUSH2 0x1d74 14DB 56 *JUMP 14DC 5B JUMPDEST 14DD 60 PUSH1 0x40 14DF 80 DUP1 14E0 51 MLOAD 14E1 60 PUSH1 0x00 14E3 81 DUP2 14E4 52 MSTORE 14E5 60 PUSH1 0x20 14E7 81 DUP2 14E8 01 ADD 14E9 80 DUP1 14EA 83 DUP4 14EB 52 MSTORE 14EC 92 SWAP3 14ED 90 SWAP1 14EE 92 SWAP3 14EF 52 MSTORE 14F0 60 PUSH1 0xff 14F2 85 DUP6 14F3 16 AND 14F4 90 SWAP1 14F5 82 DUP3 14F6 01 ADD 14F7 52 MSTORE 14F8 60 PUSH1 0x60 14FA 81 DUP2 14FB 01 ADD 14FC 86 DUP7 14FD 90 SWAP1 14FE 52 MSTORE 14FF 60 PUSH1 0x80 1501 81 DUP2 1502 01 ADD 1503 85 DUP6 1504 90 SWAP1 1505 52 MSTORE 1506 60 PUSH1 0xa0 1508 01 ADD 1509 60 PUSH1 0x20 150B 60 PUSH1 0x40 150D 51 MLOAD 150E 60 PUSH1 0x20 1510 81 DUP2 1511 03 SUB 1512 90 SWAP1 1513 80 DUP1 1514 84 DUP5 1515 03 SUB 1516 90 SWAP1 1517 85 DUP6 1518 5A GAS 1519 FA STATICCALL 151A 15 ISZERO 151B 80 DUP1 151C 15 ISZERO 151D 61 PUSH2 0x152a 1520 57 *JUMPI 1521 3D RETURNDATASIZE 1522 60 PUSH1 0x00 1524 80 DUP1 1525 3E RETURNDATACOPY 1526 3D RETURNDATASIZE 1527 60 PUSH1 0x00 1529 FD *REVERT 152A 5B JUMPDEST 152B 50 POP 152C 50 POP 152D 50 POP 152E 60 PUSH1 0x20 1530 60 PUSH1 0x40 1532 51 MLOAD 1533 03 SUB 1534 51 MLOAD 1535 60 PUSH1 0x01 1537 60 PUSH1 0x01 1539 60 PUSH1 0xa0 153B 1B SHL 153C 03 SUB 153D 16 AND 153E 86 DUP7 153F 60 PUSH1 0x01 1541 60 PUSH1 0x01 1543 60 PUSH1 0xa0 1545 1B SHL 1546 03 SUB 1547 16 AND 1548 14 EQ 1549 90 SWAP1 154A 50 POP 154B 95 SWAP6 154C 94 SWAP5 154D 50 POP 154E 50 POP 154F 50 POP 1550 50 POP 1551 50 POP 1552 56 *JUMP label_1553: // Incoming jump from 0x186A // Inputs[2] // { // @1559 stack[-1] // @155A stack[-2] // } 1553 5B JUMPDEST 1554 60 PUSH1 0x00 1556 61 PUSH2 0x155f 1559 82 DUP3 155A 84 DUP5 155B 61 PUSH2 0x2768 155E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1554 stack[0] = 0x00 // @1556 stack[1] = 0x155f // @1559 stack[2] = stack[-1] // @155A stack[3] = stack[-2] // } // Block ends with call to 0x2768, returns to 0x155F label_155F: // Incoming return from call to 0x21C3 at 0x2273 // Incoming return from call to 0x24D3 at 0x268F // Incoming return from call to 0x28A2 at 0x2474 // Incoming return from call to 0x28A2 at 0x2458 // Incoming return from call to 0x2239 at 0x228D // Incoming return from call to 0x2768 at 0x155E // Inputs[3] // { // @1560 stack[-5] // @1560 stack[-1] // @1561 stack[-4] // } 155F 5B JUMPDEST 1560 93 SWAP4 1561 92 SWAP3 1562 50 POP 1563 50 POP 1564 50 POP 1565 56 *JUMP // Stack delta = -4 // Outputs[1] { @1560 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1566: // Incoming jump from 0x0A89 // Incoming jump from 0x0FC3 // Inputs[3] // { // @1569 stack[-1] // @1574 memory[0x00:0x40] // @1575 storage[keccak256(memory[0x00:0x40])] // } 1566 5B JUMPDEST 1567 60 PUSH1 0x00 1569 81 DUP2 156A 81 DUP2 156B 52 MSTORE 156C 60 PUSH1 0x02 156E 60 PUSH1 0x20 1570 52 MSTORE 1571 60 PUSH1 0x40 1573 81 DUP2 1574 20 SHA3 1575 54 SLOAD 1576 60 PUSH1 0x01 1578 60 PUSH1 0x01 157A 60 PUSH1 0xa0 157C 1B SHL 157D 03 SUB 157E 16 AND 157F 61 PUSH2 0x15df 1582 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @1567 stack[0] = 0x00 // @156B memory[0x00:0x20] = stack[-1] // @1570 memory[0x20:0x40] = 0x02 // } // Block ends with conditional jump to 0x15df, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] label_1583: // Incoming jump from 0x1582, if not (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @1585 memory[0x40:0x60] } 1583 60 PUSH1 0x40 1585 51 MLOAD 1586 62 PUSH3 0x461bcd 158A 60 PUSH1 0xe5 158C 1B SHL 158D 81 DUP2 158E 52 MSTORE 158F 60 PUSH1 0x20 1591 60 PUSH1 0x04 1593 82 DUP3 1594 01 ADD 1595 52 MSTORE 1596 60 PUSH1 0x2c 1598 60 PUSH1 0x24 159A 82 DUP3 159B 01 ADD 159C 52 MSTORE 159D 7F PUSH32 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 15BE 60 PUSH1 0x44 15C0 82 DUP3 15C1 01 ADD 15C2 52 MSTORE 15C3 6B PUSH12 0x34b9ba32b73a103a37b5b2b7 15D0 60 PUSH1 0xa1 15D2 1B SHL 15D3 60 PUSH1 0x64 15D5 82 DUP3 15D6 01 ADD 15D7 52 MSTORE 15D8 60 PUSH1 0x84 15DA 01 ADD 15DB 61 PUSH2 0x0742 15DE 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @158E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1595 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @159C memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x2c // @15C2 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a206f70657261746f7220717565727920666f72206e6f6e6578 // @15D7 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x34b9ba32b73a103a37b5b2b7 << 0xa1 // @15DA stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0742 label_15DF: // Incoming jump from 0x1582, if (0x01 << 0xa0) - 0x01 & storage[keccak256(memory[0x00:0x40])] // Inputs[1] { @15E5 stack[-2] } 15DF 5B JUMPDEST 15E0 60 PUSH1 0x00 15E2 61 PUSH2 0x15ea 15E5 83 DUP4 15E6 61 PUSH2 0x0c88 15E9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @15E0 stack[0] = 0x00 // @15E2 stack[1] = 0x15ea // @15E5 stack[2] = stack[-2] // } // Block ends with call to 0x0c88, returns to 0x15EA label_15EA: // Incoming return from call to 0x0C88 at 0x15E9 // Inputs[3] // { // @15EB stack[-1] // @15EB stack[-2] // @15F7 stack[-5] // } 15EA 5B JUMPDEST 15EB 90 SWAP1 15EC 50 POP 15ED 80 DUP1 15EE 60 PUSH1 0x01 15F0 60 PUSH1 0x01 15F2 60 PUSH1 0xa0 15F4 1B SHL 15F5 03 SUB 15F6 16 AND 15F7 84 DUP5 15F8 60 PUSH1 0x01 15FA 60 PUSH1 0x01 15FC 60 PUSH1 0xa0 15FE 1B SHL 15FF 03 SUB 1600 16 AND 1601 14 EQ 1602 80 DUP1 1603 61 PUSH2 0x1625 1606 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @15EB stack[-2] = stack[-1] // @1601 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // } // Block ends with conditional jump to 0x1625, if (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] label_1607: // Incoming jump from 0x1606, if not (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // Inputs[2] // { // @1608 stack[-5] // @1615 stack[-4] // } 1607 50 POP 1608 83 DUP4 1609 60 PUSH1 0x01 160B 60 PUSH1 0x01 160D 60 PUSH1 0xa0 160F 1B SHL 1610 03 SUB 1611 16 AND 1612 61 PUSH2 0x161a 1615 84 DUP5 1616 61 PUSH2 0x06cd 1619 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1611 stack[-1] = (0x01 << 0xa0) - 0x01 & stack[-5] // @1612 stack[0] = 0x161a // @1615 stack[1] = stack[-4] // } // Block ends with call to 0x06cd, returns to 0x161A label_161A: // Incoming return from call to 0x06CD at 0x1619 // Inputs[2] // { // @1623 stack[-1] // @1624 stack[-2] // } 161A 5B JUMPDEST 161B 60 PUSH1 0x01 161D 60 PUSH1 0x01 161F 60 PUSH1 0xa0 1621 1B SHL 1622 03 SUB 1623 16 AND 1624 14 EQ // Stack delta = -1 // Outputs[1] { @1624 stack[-2] = (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] } // Block continues label_1625: // Incoming jump from 0x1606, if (0x01 << 0xa0) - 0x01 & stack[-5] == (0x01 << 0xa0) - 0x01 & stack[-1] // Incoming jump from 0x1624 // Inputs[1] { @1626 stack[-1] } 1625 5B JUMPDEST 1626 80 DUP1 1627 61 PUSH2 0x1655 162A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1655, if stack[-1] label_162B: // Incoming jump from 0x162A, if not stack[-1] // Inputs[5] // { // @1635 stack[-2] // @1647 memory[0x00:0x40] // @1649 stack[-5] // @1650 memory[0x00:0x40] // @1651 storage[keccak256(memory[0x00:0x40])] // } 162B 50 POP 162C 60 PUSH1 0x01 162E 60 PUSH1 0x01 1630 60 PUSH1 0xa0 1632 1B SHL 1633 03 SUB 1634 80 DUP1 1635 82 DUP3 1636 16 AND 1637 60 PUSH1 0x00 1639 90 SWAP1 163A 81 DUP2 163B 52 MSTORE 163C 60 PUSH1 0x05 163E 60 PUSH1 0x20 1640 90 SWAP1 1641 81 DUP2 1642 52 MSTORE 1643 60 PUSH1 0x40 1645 80 DUP1 1646 83 DUP4 1647 20 SHA3 1648 93 SWAP4 1649 88 DUP9 164A 16 AND 164B 83 DUP4 164C 52 MSTORE 164D 92 SWAP3 164E 90 SWAP1 164F 52 MSTORE 1650 20 SHA3 1651 54 SLOAD 1652 60 PUSH1 0xff 1654 16 AND // Stack delta = +0 // Outputs[5] // { // @163B memory[0x00:0x20] = stack[-2] & (0x01 << 0xa0) - 0x01 // @1642 memory[0x20:0x40] = 0x05 // @164C memory[0x00:0x20] = stack[-5] & (0x01 << 0xa0) - 0x01 // @164F memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1654 stack[-1] = 0xff & storage[keccak256(memory[0x00:0x40])] // } // Block continues label_1655: // Incoming jump from 0x162A, if stack[-1] // Incoming jump from 0x1F64 // Incoming return from call to 0x21C3 at 0x24BA // Incoming jump from 0x1C88, if !stack[-7] // Incoming jump from 0x1C88, if !stack[-5] // Incoming jump from 0x1654 // Incoming jump from 0x1C88, if !stack[-7] // Inputs[3] // { // @1656 stack[-6] // @1656 stack[-1] // @1657 stack[-5] // } 1655 5B JUMPDEST 1656 94 SWAP5 1657 93 SWAP4 1658 50 POP 1659 50 POP 165A 50 POP 165B 50 POP 165C 56 *JUMP // Stack delta = -5 // Outputs[1] { @1656 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_165D: // Incoming call from 0x0AB0, returns to 0x088A // Incoming call from 0x1BB4, returns to 0x1BB5 // Inputs[2] // { // @165E stack[-3] // @166B stack[-1] // } 165D 5B JUMPDEST 165E 82 DUP3 165F 60 PUSH1 0x01 1661 60 PUSH1 0x01 1663 60 PUSH1 0xa0 1665 1B SHL 1666 03 SUB 1667 16 AND 1668 61 PUSH2 0x1670 166B 82 DUP3 166C 61 PUSH2 0x0c88 166F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1667 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-3] // @1668 stack[1] = 0x1670 // @166B stack[2] = stack[-1] // } // Block ends with call to 0x0c88, returns to 0x1670 label_1670: // Incoming return from call to 0x0C88 at 0x166F // Inputs[2] // { // @1679 stack[-1] // @167A stack[-2] // } 1670 5B JUMPDEST 1671 60 PUSH1 0x01 1673 60 PUSH1 0x01 1675 60 PUSH1 0xa0 1677 1B SHL 1678 03 SUB 1679 16 AND 167A 14 EQ 167B 61 PUSH2 0x16d8 167E 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x16d8, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] label_167F: // Incoming jump from 0x167E, if not (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @1681 memory[0x40:0x60] } 167F 60 PUSH1 0x40 1681 51 MLOAD 1682 62 PUSH3 0x461bcd 1686 60 PUSH1 0xe5 1688 1B SHL 1689 81 DUP2 168A 52 MSTORE 168B 60 PUSH1 0x20 168D 60 PUSH1 0x04 168F 82 DUP3 1690 01 ADD 1691 52 MSTORE 1692 60 PUSH1 0x29 1694 60 PUSH1 0x24 1696 82 DUP3 1697 01 ADD 1698 52 MSTORE 1699 7F PUSH32 0x4552433732313a207472616e73666572206f6620746f6b656e20746861742069 16BA 60 PUSH1 0x44 16BC 82 DUP3 16BD 01 ADD 16BE 52 MSTORE 16BF 68 PUSH9 0x39903737ba1037bbb7 16C9 60 PUSH1 0xb9 16CB 1B SHL 16CC 60 PUSH1 0x64 16CE 82 DUP3 16CF 01 ADD 16D0 52 MSTORE 16D1 60 PUSH1 0x84 16D3 01 ADD 16D4 61 PUSH2 0x0742 16D7 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @168A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1691 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @1698 memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x29 // @16BE memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a207472616e73666572206f6620746f6b656e20746861742069 // @16D0 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x39903737ba1037bbb7 << 0xb9 // @16D3 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0742 label_16D8: // Incoming jump from 0x167E, if (0x01 << 0xa0) - 0x01 & stack[-1] == stack[-2] // Inputs[1] { @16E1 stack[-2] } 16D8 5B JUMPDEST 16D9 60 PUSH1 0x01 16DB 60 PUSH1 0x01 16DD 60 PUSH1 0xa0 16DF 1B SHL 16E0 03 SUB 16E1 82 DUP3 16E2 16 AND 16E3 61 PUSH2 0x173a 16E6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x173a, if stack[-2] & (0x01 << 0xa0) - 0x01 label_16E7: // Incoming jump from 0x16E6, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @16E9 memory[0x40:0x60] } 16E7 60 PUSH1 0x40 16E9 51 MLOAD 16EA 62 PUSH3 0x461bcd 16EE 60 PUSH1 0xe5 16F0 1B SHL 16F1 81 DUP2 16F2 52 MSTORE 16F3 60 PUSH1 0x20 16F5 60 PUSH1 0x04 16F7 82 DUP3 16F8 01 ADD 16F9 52 MSTORE 16FA 60 PUSH1 0x24 16FC 80 DUP1 16FD 82 DUP3 16FE 01 ADD 16FF 52 MSTORE 1700 7F PUSH32 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 1721 60 PUSH1 0x44 1723 82 DUP3 1724 01 ADD 1725 52 MSTORE 1726 63 PUSH4 0x72657373 172B 60 PUSH1 0xe0 172D 1B SHL 172E 60 PUSH1 0x64 1730 82 DUP3 1731 01 ADD 1732 52 MSTORE 1733 60 PUSH1 0x84 1735 01 ADD 1736 61 PUSH2 0x0742 1739 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @16F2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @16F9 memory[memory[0x40:0x60] + 0x04:memory[0x40:0x60] + 0x04 + 0x20] = 0x20 // @16FF memory[memory[0x40:0x60] + 0x24:memory[0x40:0x60] + 0x24 + 0x20] = 0x24 // @1725 memory[memory[0x40:0x60] + 0x44:memory[0x40:0x60] + 0x44 + 0x20] = 0x4552433732313a207472616e7366657220746f20746865207a65726f20616464 // @1732 memory[memory[0x40:0x60] + 0x64:memory[0x40:0x60] + 0x64 + 0x20] = 0x72657373 << 0xe0 // @1735 stack[0] = 0x84 + memory[0x40:0x60] // } // Block ends with unconditional jump to 0x0742 label_173A: // Incoming jump from 0x16E6, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @173E stack[-3] // @173F stack[-2] // @1740 stack[-1] // } 173A 5B JUMPDEST 173B 61 PUSH2 0x1745 173E 83 DUP4 173F 83 DUP4 1740 83 DUP4 1741 61 PUSH2 0x1da4 1744 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @173B stack[0] = 0x1745 // @173E stack[1] = stack[-3] // @173F stack[2] = stack[-2] // @1740 stack[3] = stack[-1] // } // Block ends with call to 0x1da4, returns to 0x1745 label_1745: // Incoming return from call to 0x1DA4 at 0x1744 // Inputs[1] { @174B stack[-1] } 1745 5B JUMPDEST 1746 61 PUSH2 0x1750 1749 60 PUSH1 0x00 174B 82 DUP3 174C 61 PUSH2 0x13f5 174F 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1746 stack[0] = 0x1750 // @1749 stack[1] = 0x00 // @174B stack[2] = stack[-1] // } // Block ends with call to 0x13f5, returns to 0x1750 label_1750: // Incoming return from call to 0x13F5 at 0x174F // Inputs[3] // { // @1759 stack[-3] // @1768 memory[0x00:0x40] // @176A storage[keccak256(memory[0x00:0x40])] // } 1750 5B JUMPDEST 1751 60 PUSH1 0x01 1753 60 PUSH1 0x01 1755 60 PUSH1 0xa0 1757 1B SHL 1758 03 SUB 1759 83 DUP4 175A 16 AND 175B 60 PUSH1 0x00 175D 90 SWAP1 175E 81 DUP2 175F 52 MSTORE 1760 60 PUSH1 0x03 1762 60 PUSH1 0x20 1764 52 MSTORE 1765 60 PUSH1 0x40 1767 81 DUP2 1768 20 SHA3 1769 80 DUP1 176A 54 SLOAD 176B 60 PUSH1 0x01 176D 92 SWAP3 176E 90 SWAP1 176F 61 PUSH2 0x1779 1772 90 SWAP1 1773 84 DUP5 1774 90 SWAP1 1775 61 PUSH2 0x27b3 1778 56 *JUMP // Stack delta = +6 // Outputs[8] // { // @175F memory[0x00:0x20] = stack[-3] & (0x01 << 0xa0) - 0x01 // @1764 memory[0x20:0x40] = 0x03 // @1768 stack[1] = keccak256(memory[0x00:0x40]) // @176D stack[0] = 0x01 // @176E stack[2] = 0x00 // @1772 stack[3] = 0x1779 // @1774 stack[4] = 0x01 // @1774 stack[5] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x27b3, returns to 0x1779 label_1779: // Incoming return from call to 0x27B3 at 0x1778 // Inputs[6] // { // @177A stack[-2] // @177A stack[-1] // @177B stack[-3] // @1787 stack[-6] // @1796 memory[0x00:0x40] // @1798 storage[keccak256(memory[0x00:0x40])] // } 1779 5B JUMPDEST 177A 90 SWAP1 177B 91 SWAP2 177C 55 SSTORE 177D 50 POP 177E 50 POP 177F 60 PUSH1 0x01 1781 60 PUSH1 0x01 1783 60 PUSH1 0xa0 1785 1B SHL 1786 03 SUB 1787 82 DUP3 1788 16 AND 1789 60 PUSH1 0x00 178B 90 SWAP1 178C 81 DUP2 178D 52 MSTORE 178E 60 PUSH1 0x03 1790 60 PUSH1 0x20 1792 52 MSTORE 1793 60 PUSH1 0x40 1795 81 DUP2 1796 20 SHA3 1797 80 DUP1 1798 54 SLOAD 1799 60 PUSH1 0x01 179B 92 SWAP3 179C 90 SWAP1 179D 61 PUSH2 0x17a7 17A0 90 SWAP1 17A1 84 DUP5 17A2 90 SWAP1 17A3 61 PUSH2 0x2768 17A6 56 *JUMP // Stack delta = +2 // Outputs[9] // { // @177C storage[stack[-3]] = stack[-1] // @178D memory[0x00:0x20] = stack[-6] & (0x01 << 0xa0) - 0x01 // @1792 memory[0x20:0x40] = 0x03 // @1796 stack[-3] = keccak256(memory[0x00:0x40]) // @179B stack[-4] = 0x01 // @179C stack[-2] = 0x00 // @17A0 stack[-1] = 0x17a7 // @17A2 stack[0] = 0x01 // @17A2 stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with call to 0x2768, returns to 0x17A7 label_17A7: // Incoming return from call to 0x2768 at 0x17A6 // Inputs[11] // { // @17A8 stack[-2] // @17A8 stack[-1] // @17A9 stack[-3] // @17AF stack[-5] // @17BB memory[0x00:0x40] // @17BD storage[keccak256(memory[0x00:0x40])] // @17D0 stack[-6] // @17DA memory[0x40:0x60] // @17DE stack[-7] // @1803 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1807 stack[-8] // } 17A7 5B JUMPDEST 17A8 90 SWAP1 17A9 91 SWAP2 17AA 55 SSTORE 17AB 50 POP 17AC 50 POP 17AD 60 PUSH1 0x00 17AF 81 DUP2 17B0 81 DUP2 17B1 52 MSTORE 17B2 60 PUSH1 0x02 17B4 60 PUSH1 0x20 17B6 52 MSTORE 17B7 60 PUSH1 0x40 17B9 80 DUP1 17BA 82 DUP3 17BB 20 SHA3 17BC 80 DUP1 17BD 54 SLOAD 17BE 60 PUSH1 0x01 17C0 60 PUSH1 0x01 17C2 60 PUSH1 0xa0 17C4 1B SHL 17C5 03 SUB 17C6 19 NOT 17C7 16 AND 17C8 60 PUSH1 0x01 17CA 60 PUSH1 0x01 17CC 60 PUSH1 0xa0 17CE 1B SHL 17CF 03 SUB 17D0 86 DUP7 17D1 81 DUP2 17D2 16 AND 17D3 91 SWAP2 17D4 82 DUP3 17D5 17 OR 17D6 90 SWAP1 17D7 92 SWAP3 17D8 55 SSTORE 17D9 91 SWAP2 17DA 51 MLOAD 17DB 84 DUP5 17DC 93 SWAP4 17DD 91 SWAP2 17DE 87 DUP8 17DF 16 AND 17E0 91 SWAP2 17E1 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 1802 91 SWAP2 1803 A4 LOG4 1804 50 POP 1805 50 POP 1806 50 POP 1807 56 *JUMP // Stack delta = -8 // Outputs[5] // { // @17AA storage[stack[-3]] = stack[-1] // @17B1 memory[0x00:0x20] = stack[-5] // @17B6 memory[0x20:0x40] = 0x02 // @17D8 storage[keccak256(memory[0x00:0x40])] = (stack[-6] & (0x01 << 0xa0) - 0x01) | (~((0x01 << 0xa0) - 0x01) & storage[keccak256(memory[0x00:0x40])]) // @1803 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-7] & (0x01 << 0xa0) - 0x01, stack[-6] & (0x01 << 0xa0) - 0x01, stack[-5]]); // } // Block ends with unconditional jump to stack[-8] label_1808: // Incoming call from 0x0DD8, returns to 0x0DD9 // Incoming call from 0x1338, returns to 0x0BC9 // Inputs[5] // { // @180C storage[0x0d] // @1815 stack[-1] // @182A memory[0x40:0x60] // @1856 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] // @1859 stack[-2] // } 1808 5B JUMPDEST 1809 60 PUSH1 0x0d 180B 80 DUP1 180C 54 SLOAD 180D 60 PUSH1 0x01 180F 60 PUSH1 0x01 1811 60 PUSH1 0xa0 1813 1B SHL 1814 03 SUB 1815 83 DUP4 1816 81 DUP2 1817 16 AND 1818 60 PUSH1 0x01 181A 60 PUSH1 0x01 181C 60 PUSH1 0xa0 181E 1B SHL 181F 03 SUB 1820 19 NOT 1821 83 DUP4 1822 16 AND 1823 81 DUP2 1824 17 OR 1825 90 SWAP1 1826 93 SWAP4 1827 55 SSTORE 1828 60 PUSH1 0x40 182A 51 MLOAD 182B 91 SWAP2 182C 16 AND 182D 91 SWAP2 182E 90 SWAP1 182F 82 DUP3 1830 90 SWAP1 1831 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1852 90 SWAP1 1853 60 PUSH1 0x00 1855 90 SWAP1 1856 A3 LOG3 1857 50 POP 1858 50 POP 1859 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @1827 storage[0x0d] = (stack[-1] & (0x01 << 0xa0) - 0x01) | (storage[0x0d] & ~((0x01 << 0xa0) - 0x01)) // @1856 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x0d] & (0x01 << 0xa0) - 0x01, stack[-1] & (0x01 << 0xa0) - 0x01]); // } // Block ends with unconditional jump to stack[-2] label_185A: // Incoming jump from 0x0E2D // Incoming jump from 0x125A // Incoming jump from 0x10CE // Inputs[1] { @185D storage[0x0e] } 185A 5B JUMPDEST 185B 60 PUSH1 0x0e 185D 54 SLOAD 185E 60 PUSH1 0x00 1860 90 SWAP1 1861 61 PUSH2 0x13f0 1864 90 SWAP1 1865 60 PUSH1 0x01 1867 61 PUSH2 0x1553 186A 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1860 stack[0] = 0x00 // @1864 stack[1] = 0x13f0 // @1864 stack[2] = storage[0x0e] // @1865 stack[3] = 0x01 // } // Block ends with unconditional jump to 0x1553 186B 5B JUMPDEST 186C 60 PUSH1 0x01 186E 60 PUSH1 0x01 1870 60 PUSH1 0xa0 1872 1B SHL 1873 03 SUB 1874 82 DUP3 1875 16 AND 1876 61 PUSH2 0x18c1 1879 57 *JUMPI 187A 60 PUSH1 0x40 187C 51 MLOAD 187D 62 PUSH3 0x461bcd 1881 60 PUSH1 0xe5 1883 1B SHL 1884 81 DUP2 1885 52 MSTORE 1886 60 PUSH1 0x20 1888 60 PUSH1 0x04 188A 82 DUP3 188B 01 ADD 188C 81 DUP2 188D 90 SWAP1 188E 52 MSTORE 188F 60 PUSH1 0x24 1891 82 DUP3 1892 01 ADD 1893 52 MSTORE 1894 7F PUSH32 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 18B5 60 PUSH1 0x44 18B7 82 DUP3 18B8 01 ADD 18B9 52 MSTORE 18BA 60 PUSH1 0x64 18BC 01 ADD 18BD 61 PUSH2 0x0742 18C0 56 *JUMP 18C1 5B JUMPDEST 18C2 60 PUSH1 0x00 18C4 81 DUP2 18C5 81 DUP2 18C6 52 MSTORE 18C7 60 PUSH1 0x02 18C9 60 PUSH1 0x20 18CB 52 MSTORE 18CC 60 PUSH1 0x40 18CE 90 SWAP1 18CF 20 SHA3 18D0 54 SLOAD 18D1 60 PUSH1 0x01 18D3 60 PUSH1 0x01 18D5 60 PUSH1 0xa0 18D7 1B SHL 18D8 03 SUB 18D9 16 AND 18DA 15 ISZERO 18DB 61 PUSH2 0x1926 18DE 57 *JUMPI 18DF 60 PUSH1 0x40 18E1 51 MLOAD 18E2 62 PUSH3 0x461bcd 18E6 60 PUSH1 0xe5 18E8 1B SHL 18E9 81 DUP2 18EA 52 MSTORE 18EB 60 PUSH1 0x20 18ED 60 PUSH1 0x04 18EF 82 DUP3 18F0 01 ADD 18F1 52 MSTORE 18F2 60 PUSH1 0x1c 18F4 60 PUSH1 0x24 18F6 82 DUP3 18F7 01 ADD 18F8 52 MSTORE 18F9 7F PUSH32 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 191A 60 PUSH1 0x44 191C 82 DUP3 191D 01 ADD 191E 52 MSTORE 191F 60 PUSH1 0x64 1921 01 ADD 1922 61 PUSH2 0x0742 1925 56 *JUMP 1926 5B JUMPDEST 1927 61 PUSH2 0x1932 192A 60 PUSH1 0x00 192C 83 DUP4 192D 83 DUP4 192E 61 PUSH2 0x1da4 1931 56 *JUMP 1932 5B JUMPDEST 1933 60 PUSH1 0x01 1935 60 PUSH1 0x01 1937 60 PUSH1 0xa0 1939 1B SHL 193A 03 SUB 193B 82 DUP3 193C 16 AND 193D 60 PUSH1 0x00 193F 90 SWAP1 1940 81 DUP2 1941 52 MSTORE 1942 60 PUSH1 0x03 1944 60 PUSH1 0x20 1946 52 MSTORE 1947 60 PUSH1 0x40 1949 81 DUP2 194A 20 SHA3 194B 80 DUP1 194C 54 SLOAD 194D 60 PUSH1 0x01 194F 92 SWAP3 1950 90 SWAP1 1951 61 PUSH2 0x195b 1954 90 SWAP1 1955 84 DUP5 1956 90 SWAP1 1957 61 PUSH2 0x2768 195A 56 *JUMP 195B 5B JUMPDEST 195C 90 SWAP1 195D 91 SWAP2 195E 55 SSTORE 195F 50 POP 1960 50 POP 1961 60 PUSH1 0x00 1963 81 DUP2 1964 81 DUP2 1965 52 MSTORE 1966 60 PUSH1 0x02 1968 60 PUSH1 0x20 196A 52 MSTORE 196B 60 PUSH1 0x40 196D 80 DUP1 196E 82 DUP3 196F 20 SHA3 1970 80 DUP1 1971 54 SLOAD 1972 60 PUSH1 0x01 1974 60 PUSH1 0x01 1976 60 PUSH1 0xa0 1978 1B SHL 1979 03 SUB 197A 19 NOT 197B 16 AND 197C 60 PUSH1 0x01 197E 60 PUSH1 0x01 1980 60 PUSH1 0xa0 1982 1B SHL 1983 03 SUB 1984 86 DUP7 1985 16 AND 1986 90 SWAP1 1987 81 DUP2 1988 17 OR 1989 90 SWAP1 198A 91 SWAP2 198B 55 SSTORE 198C 90 SWAP1 198D 51 MLOAD 198E 83 DUP4 198F 92 SWAP3 1990 90 SWAP1 1991 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 19B2 90 SWAP1 19B3 82 DUP3 19B4 90 SWAP1 19B5 A4 LOG4 19B6 50 POP 19B7 50 POP 19B8 56 *JUMP 19B9 5B JUMPDEST 19BA 61 PUSH2 0x19c1 19BD 61 PUSH2 0x13e6 19C0 56 *JUMP 19C1 5B JUMPDEST 19C2 60 PUSH1 0x01 19C4 60 PUSH1 0x01 19C6 60 PUSH1 0xa0 19C8 1B SHL 19C9 03 SUB 19CA 16 AND 19CB 61 PUSH2 0x19dc 19CE 60 PUSH1 0x0d 19D0 54 SLOAD 19D1 60 PUSH1 0x01 19D3 60 PUSH1 0x01 19D5 60 PUSH1 0xa0 19D7 1B SHL 19D8 03 SUB 19D9 16 AND 19DA 90 SWAP1 19DB 56 *JUMP 19DC 5B JUMPDEST 19DD 60 PUSH1 0x01 19DF 60 PUSH1 0x01 19E1 60 PUSH1 0xa0 19E3 1B SHL 19E4 03 SUB 19E5 16 AND 19E6 14 EQ 19E7 15 ISZERO 19E8 61 PUSH2 0x1a00 19EB 57 *JUMPI 19EC 60 PUSH1 0x0f 19EE 54 SLOAD 19EF 60 PUSH1 0x0e 19F1 54 SLOAD 19F2 10 LT 19F3 61 PUSH2 0x19fb 19F6 57 *JUMPI 19F7 60 PUSH1 0x00 19F9 80 DUP1 19FA FD *REVERT 19FB 5B JUMPDEST 19FC 61 PUSH2 0x1a1c 19FF 56 *JUMP 1A00 5B JUMPDEST 1A01 60 PUSH1 0xd4 1A03 60 PUSH1 0x0f 1A05 54 SLOAD 1A06 61 PUSH2 0x1a0f 1A09 91 SWAP2 1A0A 90 SWAP1 1A0B 61 PUSH2 0x27b3 1A0E 56 *JUMP 1A0F 5B JUMPDEST 1A10 60 PUSH1 0x0e 1A12 54 SLOAD 1A13 10 LT 1A14 61 PUSH2 0x1a1c 1A17 57 *JUMPI 1A18 60 PUSH1 0x00 1A1A 80 DUP1 1A1B FD *REVERT 1A1C 5B JUMPDEST 1A1D 60 PUSH1 0x0e 1A1F 80 DUP1 1A20 54 SLOAD 1A21 90 SWAP1 1A22 60 PUSH1 0x00 1A24 61 PUSH2 0x1a2c 1A27 83 DUP4 1A28 61 PUSH2 0x2831 1A2B 56 *JUMP 1A2C 5B JUMPDEST 1A2D 91 SWAP2 1A2E 90 SWAP1 1A2F 50 POP 1A30 55 SSTORE 1A31 50 POP 1A32 60 PUSH1 0xd4 1A34 60 PUSH1 0x0f 1A36 54 SLOAD 1A37 61 PUSH2 0x1a40 1A3A 91 SWAP2 1A3B 90 SWAP1 1A3C 61 PUSH2 0x27b3 1A3F 56 *JUMP 1A40 5B JUMPDEST 1A41 60 PUSH1 0x0e 1A43 54 SLOAD 1A44 14 EQ 1A45 15 ISZERO 1A46 61 PUSH2 0x0dd9 1A49 57 *JUMPI 1A4A 60 PUSH1 0x00 1A4C 61 PUSH2 0x03e8 1A4F 61 PUSH2 0x1a88 1A52 60 PUSH1 0x40 1A54 80 DUP1 1A55 51 MLOAD 1A56 41 COINBASE 1A57 60 PUSH1 0x20 1A59 80 DUP1 1A5A 83 DUP4 1A5B 01 ADD 1A5C 91 SWAP2 1A5D 90 SWAP1 1A5E 91 SWAP2 1A5F 52 MSTORE 1A60 42 TIMESTAMP 1A61 82 DUP3 1A62 84 DUP5 1A63 01 ADD 1A64 52 MSTORE 1A65 44 DIFFICULTY 1A66 60 PUSH1 0x60 1A68 80 DUP1 1A69 84 DUP5 1A6A 01 ADD 1A6B 91 SWAP2 1A6C 90 SWAP1 1A6D 91 SWAP2 1A6E 52 MSTORE 1A6F 83 DUP4 1A70 51 MLOAD 1A71 80 DUP1 1A72 84 DUP5 1A73 03 SUB 1A74 90 SWAP1 1A75 91 SWAP2 1A76 01 ADD 1A77 81 DUP2 1A78 52 MSTORE 1A79 60 PUSH1 0x80 1A7B 90 SWAP1 1A7C 92 SWAP3 1A7D 01 ADD 1A7E 90 SWAP1 1A7F 92 SWAP3 1A80 52 MSTORE 1A81 80 DUP1 1A82 51 MLOAD 1A83 91 SWAP2 1A84 01 ADD 1A85 20 SHA3 1A86 90 SWAP1 1A87 56 *JUMP 1A88 5B JUMPDEST 1A89 61 PUSH2 0x1a92 1A8C 91 SWAP2 1A8D 90 SWAP1 1A8E 61 PUSH2 0x284c 1A91 56 *JUMP 1A92 5B JUMPDEST 1A93 90 SWAP1 1A94 50 POP 1A95 60 PUSH1 0x00 1A97 61 PUSH2 0x1aaa 1A9A 82 DUP3 1A9B 61 PUSH2 0x03e8 1A9E 60 PUSH1 0x0e 1AA0 54 SLOAD 1AA1 61 PUSH2 0x10fc 1AA4 91 SWAP2 1AA5 90 SWAP1 1AA6 61 PUSH2 0x27b3 1AA9 56 *JUMP 1AAA 5B JUMPDEST 1AAB 61 PUSH2 0x1abe 1AAE 83 DUP4 1AAF 61 PUSH2 0x07d0 1AB2 60 PUSH1 0x0e 1AB4 54 SLOAD 1AB5 61 PUSH2 0x10fc 1AB8 91 SWAP2 1AB9 90 SWAP1 1ABA 61 PUSH2 0x27b3 1ABD 56 *JUMP 1ABE 5B JUMPDEST 1ABF 61 PUSH2 0x1ad2 1AC2 84 DUP5 1AC3 61 PUSH2 0x0bb8 1AC6 60 PUSH1 0x0e 1AC8 54 SLOAD 1AC9 61 PUSH2 0x10fc 1ACC 91 SWAP2 1ACD 90 SWAP1 1ACE 61 PUSH2 0x27b3 1AD1 56 *JUMP 1AD2 5B JUMPDEST 1AD3 61 PUSH2 0x1ae6 1AD6 85 DUP6 1AD7 61 PUSH2 0x0fa0 1ADA 60 PUSH1 0x0e 1ADC 54 SLOAD 1ADD 61 PUSH2 0x10fc 1AE0 91 SWAP2 1AE1 90 SWAP1 1AE2 61 PUSH2 0x27b3 1AE5 56 *JUMP 1AE6 5B JUMPDEST 1AE7 61 PUSH2 0x1afa 1AEA 86 DUP7 1AEB 61 PUSH2 0x1388 1AEE 60 PUSH1 0x0e 1AF0 54 SLOAD 1AF1 61 PUSH2 0x10fc 1AF4 91 SWAP2 1AF5 90 SWAP1 1AF6 61 PUSH2 0x27b3 1AF9 56 *JUMP 1AFA 5B JUMPDEST 1AFB 61 PUSH2 0x1b0e 1AFE 87 DUP8 1AFF 61 PUSH2 0x1770 1B02 60 PUSH1 0x0e 1B04 54 SLOAD 1B05 61 PUSH2 0x10fc 1B08 91 SWAP2 1B09 90 SWAP1 1B0A 61 PUSH2 0x27b3 1B0D 56 *JUMP 1B0E 5B JUMPDEST 1B0F 60 PUSH1 0x40 1B11 80 DUP1 1B12 51 MLOAD 1B13 60 PUSH1 0x01 1B15 60 PUSH1 0x01 1B17 60 PUSH1 0xa0 1B19 1B SHL 1B1A 03 SUB 1B1B 97 SWAP8 1B1C 88 DUP9 1B1D 16 AND 1B1E 60 PUSH1 0x20 1B20 82 DUP3 1B21 01 ADD 1B22 52 MSTORE 1B23 95 SWAP6 1B24 87 DUP8 1B25 16 AND 1B26 90 SWAP1 1B27 86 DUP7 1B28 01 ADD 1B29 52 MSTORE 1B2A 92 SWAP3 1B2B 85 DUP6 1B2C 16 AND 1B2D 60 PUSH1 0x60 1B2F 85 DUP6 1B30 01 ADD 1B31 52 MSTORE 1B32 90 SWAP1 1B33 84 DUP5 1B34 16 AND 1B35 60 PUSH1 0x80 1B37 84 DUP5 1B38 01 ADD 1B39 52 MSTORE 1B3A 83 DUP4 1B3B 16 AND 1B3C 60 PUSH1 0xa0 1B3E 83 DUP4 1B3F 01 ADD 1B40 52 MSTORE 1B41 90 SWAP1 1B42 91 SWAP2 1B43 16 AND 1B44 60 PUSH1 0xc0 1B46 82 DUP3 1B47 01 ADD 1B48 52 MSTORE 1B49 33 CALLER 1B4A 60 PUSH1 0xe0 1B4C 82 DUP3 1B4D 01 ADD 1B4E 52 MSTORE 1B4F 61 PUSH2 0x0100 1B52 01 ADD 1B53 60 PUSH1 0x40 1B55 80 DUP1 1B56 51 MLOAD 1B57 60 PUSH1 0x1f 1B59 19 NOT 1B5A 81 DUP2 1B5B 84 DUP5 1B5C 03 SUB 1B5D 01 ADD 1B5E 81 DUP2 1B5F 52 MSTORE 1B60 91 SWAP2 1B61 90 SWAP1 1B62 52 MSTORE 1B63 80 DUP1 1B64 51 MLOAD 1B65 60 PUSH1 0x20 1B67 90 SWAP1 1B68 91 SWAP2 1B69 01 ADD 1B6A 20 SHA3 1B6B 90 SWAP1 1B6C 50 POP 1B6D 61 PUSH2 0x1b86 1B70 61 PUSH2 0x1b7b 1B73 61 PUSH2 0x263c 1B76 83 DUP4 1B77 61 PUSH2 0x284c 1B7A 56 *JUMP 1B7B 5B JUMPDEST 1B7C 61 PUSH2 0x0411 1B7F 90 SWAP1 1B80 60 PUSH1 0x01 1B82 61 PUSH2 0x2768 1B85 56 *JUMP 1B86 5B JUMPDEST 1B87 60 PUSH1 0x13 1B89 80 DUP1 1B8A 54 SLOAD 1B8B 60 PUSH1 0x01 1B8D 60 PUSH1 0x01 1B8F 60 PUSH1 0xa0 1B91 1B SHL 1B92 03 SUB 1B93 19 NOT 1B94 16 AND 1B95 60 PUSH1 0x01 1B97 60 PUSH1 0x01 1B99 60 PUSH1 0xa0 1B9B 1B SHL 1B9C 03 SUB 1B9D 92 SWAP3 1B9E 90 SWAP1 1B9F 92 SWAP3 1BA0 16 AND 1BA1 91 SWAP2 1BA2 90 SWAP1 1BA3 91 SWAP2 1BA4 17 OR 1BA5 90 SWAP1 1BA6 55 SSTORE 1BA7 50 POP 1BA8 50 POP 1BA9 56 *JUMP label_1BAA: // Incoming call from 0x0FEB, returns to 0x0FEC // Inputs[3] // { // @1BAE stack[-4] // @1BAF stack[-3] // @1BB0 stack[-2] // } 1BAA 5B JUMPDEST 1BAB 61 PUSH2 0x1bb5 1BAE 84 DUP5 1BAF 84 DUP5 1BB0 84 DUP5 1BB1 61 PUSH2 0x165d 1BB4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1BAB stack[0] = 0x1bb5 // @1BAE stack[1] = stack[-4] // @1BAF stack[2] = stack[-3] // @1BB0 stack[3] = stack[-2] // } // Block ends with call to 0x165d, returns to 0x1BB5 label_1BB5: // Incoming return from call to 0x165D at 0x1BB4 // Inputs[4] // { // @1BB9 stack[-4] // @1BBA stack[-3] // @1BBB stack[-2] // @1BBC stack[-1] // } 1BB5 5B JUMPDEST 1BB6 61 PUSH2 0x1bc1 1BB9 84 DUP5 1BBA 84 DUP5 1BBB 84 DUP5 1BBC 84 DUP5 1BBD 61 PUSH2 0x1e5c 1BC0 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1BB6 stack[0] = 0x1bc1 // @1BB9 stack[1] = stack[-4] // @1BBA stack[2] = stack[-3] // @1BBB stack[3] = stack[-2] // @1BBC stack[4] = stack[-1] // } // Block ends with call to 0x1e5c, returns to 0x1BC1 label_1BC1: // Incoming return from call to 0x1E5C at 0x1BC0 // Inputs[1] { @1BC5 stack[-1] } 1BC1 5B JUMPDEST 1BC2 61 PUSH2 0x0fec 1BC5 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x0fec, if stack[-1] label_1BC6: // Incoming jump from 0x1BC5, if not stack[-1] // Inputs[1] { @1BC8 memory[0x40:0x60] } 1BC6 60 PUSH1 0x40 1BC8 51 MLOAD 1BC9 62 PUSH3 0x461bcd 1BCD 60 PUSH1 0xe5 1BCF 1B SHL 1BD0 81 DUP2 1BD1 52 MSTORE 1BD2 60 PUSH1 0x04 1BD4 01 ADD 1BD5 61 PUSH2 0x0742 1BD8 90 SWAP1 1BD9 61 PUSH2 0x2690 1BDC 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1BD1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1BD8 stack[0] = 0x0742 // @1BD8 stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2690, returns to 0x0742 label_1BDD: // Incoming call from 0x0FFE, returns to 0x0FFF // Inputs[1] { @1BE0 stack[-1] } 1BDD 5B JUMPDEST 1BDE 60 PUSH1 0x60 1BE0 81 DUP2 1BE1 61 PUSH2 0x1c01 1BE4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1BDE stack[0] = 0x60 } // Block ends with conditional jump to 0x1c01, if stack[-1] label_1BE5: // Incoming jump from 0x1BE4, if not stack[-1] // Inputs[2] // { // @1BEA memory[0x40:0x60] // @1BFF stack[-3] // } 1BE5 50 POP 1BE6 50 POP 1BE7 60 PUSH1 0x40 1BE9 80 DUP1 1BEA 51 MLOAD 1BEB 80 DUP1 1BEC 82 DUP3 1BED 01 ADD 1BEE 90 SWAP1 1BEF 91 SWAP2 1BF0 52 MSTORE 1BF1 60 PUSH1 0x01 1BF3 81 DUP2 1BF4 52 MSTORE 1BF5 60 PUSH1 0x03 1BF7 60 PUSH1 0xfc 1BF9 1B SHL 1BFA 60 PUSH1 0x20 1BFC 82 DUP3 1BFD 01 ADD 1BFE 52 MSTORE 1BFF 90 SWAP1 1C00 56 *JUMP // Stack delta = -2 // Outputs[4] // { // @1BF0 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @1BF4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @1BFE memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = 0x03 << 0xfc // @1BFF stack[-3] = memory[0x40:0x60] // } // Block ends with unconditional jump to stack[-3] label_1C01: // Incoming jump from 0x1BE4, if stack[-1] // Inputs[1] { @1C02 stack[-2] } 1C01 5B JUMPDEST 1C02 81 DUP2 1C03 60 PUSH1 0x00 1C05 5B JUMPDEST 1C06 81 DUP2 1C07 15 ISZERO 1C08 61 PUSH2 0x1c2b 1C0B 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1C02 stack[0] = stack[-2] // @1C03 stack[1] = 0x00 // } // Block ends with conditional jump to 0x1c2b, if !stack[-2] label_1C0C: // Incoming jump from 0x1C0B, if not !stack[-2] // Incoming jump from 0x1C0B, if not !stack[-2] // Inputs[1] { @1C0C stack[-1] } 1C0C 80 DUP1 1C0D 61 PUSH2 0x1c15 1C10 81 DUP2 1C11 61 PUSH2 0x2831 1C14 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C0C stack[0] = stack[-1] // @1C0D stack[1] = 0x1c15 // @1C10 stack[2] = stack[-1] // } // Block ends with call to 0x2831, returns to 0x1C15 label_1C15: // Incoming return from call to 0x2831 at 0x1C14 // Inputs[4] // { // @1C16 stack[-3] // @1C16 stack[-1] // @1C1B stack[-2] // @1C1F stack[-4] // } 1C15 5B JUMPDEST 1C16 91 SWAP2 1C17 50 POP 1C18 61 PUSH2 0x1c24 1C1B 90 SWAP1 1C1C 50 POP 1C1D 60 PUSH1 0x0a 1C1F 83 DUP4 1C20 61 PUSH2 0x2780 1C23 56 *JUMP // Stack delta = +1 // Outputs[4] // { // @1C16 stack[-3] = stack[-1] // @1C1B stack[-2] = 0x1c24 // @1C1D stack[-1] = 0x0a // @1C1F stack[0] = stack[-4] // } // Block ends with call to 0x2780, returns to 0x1C24 label_1C24: // Incoming return from call to 0x2780 at 0x1C23 // Inputs[2] // { // @1C25 stack[-1] // @1C25 stack[-3] // } 1C24 5B JUMPDEST 1C25 91 SWAP2 1C26 50 POP 1C27 61 PUSH2 0x1c05 1C2A 56 *JUMP // Stack delta = -1 // Outputs[1] { @1C25 stack[-3] = stack[-1] } // Block ends with unconditional jump to 0x1c05 label_1C2B: // Incoming jump from 0x1C0B, if !stack[-2] // Incoming jump from 0x1C0B, if !stack[-2] // Inputs[1] { @1C2E stack[-1] } 1C2B 5B JUMPDEST 1C2C 60 PUSH1 0x00 1C2E 81 DUP2 1C2F 67 PUSH8 0xffffffffffffffff 1C38 81 DUP2 1C39 11 GT 1C3A 15 ISZERO 1C3B 61 PUSH2 0x1c54 1C3E 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1C2C stack[0] = 0x00 // @1C2E stack[1] = stack[-1] // } // Block ends with conditional jump to 0x1c54, if !(stack[-1] > 0xffffffffffffffff) label_1C3F: // Incoming jump from 0x1C3E, if not !(stack[-1] > 0xffffffffffffffff) // Inputs[1] { @1C53 memory[0x00:0x24] } 1C3F 63 PUSH4 0x4e487b71 1C44 60 PUSH1 0xe0 1C46 1B SHL 1C47 60 PUSH1 0x00 1C49 52 MSTORE 1C4A 60 PUSH1 0x41 1C4C 60 PUSH1 0x04 1C4E 52 MSTORE 1C4F 60 PUSH1 0x24 1C51 60 PUSH1 0x00 1C53 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1C49 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1C4E memory[0x04:0x24] = 0x41 // @1C53 revert(memory[0x00:0x24]); // } // Block terminates label_1C54: // Incoming jump from 0x1C3E, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @1C57 memory[0x40:0x60] // @1C58 stack[-1] // } 1C54 5B JUMPDEST 1C55 60 PUSH1 0x40 1C57 51 MLOAD 1C58 90 SWAP1 1C59 80 DUP1 1C5A 82 DUP3 1C5B 52 MSTORE 1C5C 80 DUP1 1C5D 60 PUSH1 0x1f 1C5F 01 ADD 1C60 60 PUSH1 0x1f 1C62 19 NOT 1C63 16 AND 1C64 60 PUSH1 0x20 1C66 01 ADD 1C67 82 DUP3 1C68 01 ADD 1C69 60 PUSH1 0x40 1C6B 52 MSTORE 1C6C 80 DUP1 1C6D 15 ISZERO 1C6E 61 PUSH2 0x1c7e 1C71 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @1C58 stack[-1] = memory[0x40:0x60] // @1C58 stack[0] = stack[-1] // @1C5B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @1C6B memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-1]) // } // Block ends with conditional jump to 0x1c7e, if !stack[-1] label_1C72: // Incoming jump from 0x1C71, if not !stack[-1] // Inputs[6] // { // @1C74 stack[-2] // @1C76 stack[-1] // @1C78 msg.data.length // @1C7A msg.data[msg.data.length:msg.data.length + stack[-1]] // @1C80 stack[-3] // @1C83 stack[-7] // } 1C72 60 PUSH1 0x20 1C74 82 DUP3 1C75 01 ADD 1C76 81 DUP2 1C77 80 DUP1 1C78 36 CALLDATASIZE 1C79 83 DUP4 1C7A 37 CALLDATACOPY 1C7B 01 ADD 1C7C 90 SWAP1 1C7D 50 POP 1C7E 5B JUMPDEST 1C7F 50 POP 1C80 90 SWAP1 1C81 50 POP 1C82 5B JUMPDEST 1C83 84 DUP5 1C84 15 ISZERO 1C85 61 PUSH2 0x1655 1C88 57 *JUMPI // Stack delta = -2 // Outputs[2] // { // @1C7A memory[stack[-2] + 0x20:stack[-2] + 0x20 + stack[-1]] = msg.data[msg.data.length:msg.data.length + stack[-1]] // @1C80 stack[-3] = stack[-2] // } // Block ends with conditional jump to 0x1655, if !stack[-7] label_1C89: // Incoming jump from 0x1C88, if not !stack[-5] // Incoming jump from 0x1C88, if not !stack[-7] // Incoming jump from 0x1C88, if not !stack[-7] // Inputs[1] { @1C8E stack[-2] } 1C89 61 PUSH2 0x1c93 1C8C 60 PUSH1 0x01 1C8E 83 DUP4 1C8F 61 PUSH2 0x27b3 1C92 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1C89 stack[0] = 0x1c93 // @1C8C stack[1] = 0x01 // @1C8E stack[2] = stack[-2] // } // Block ends with call to 0x27b3, returns to 0x1C93 label_1C93: // Incoming return from call to 0x27B3 at 0x1C92 // Inputs[3] // { // @1C94 stack[-3] // @1C94 stack[-1] // @1C9B stack[-6] // } 1C93 5B JUMPDEST 1C94 91 SWAP2 1C95 50 POP 1C96 61 PUSH2 0x1ca0 1C99 60 PUSH1 0x0a 1C9B 86 DUP7 1C9C 61 PUSH2 0x284c 1C9F 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1C94 stack[-3] = stack[-1] // @1C96 stack[-1] = 0x1ca0 // @1C99 stack[0] = 0x0a // @1C9B stack[1] = stack[-6] // } // Block ends with call to 0x284c, returns to 0x1CA0 label_1CA0: // Incoming return from call to 0x284C at 0x1C9F // Inputs[1] { @1CA4 stack[-1] } 1CA0 5B JUMPDEST 1CA1 61 PUSH2 0x1cab 1CA4 90 SWAP1 1CA5 60 PUSH1 0x30 1CA7 61 PUSH2 0x2768 1CAA 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1CA4 stack[0] = stack[-1] // @1CA4 stack[-1] = 0x1cab // @1CA5 stack[1] = 0x30 // } // Block ends with call to 0x2768, returns to 0x1CAB label_1CAB: // Incoming return from call to 0x2768 at 0x1CAA // Inputs[4] // { // @1CAE stack[-1] // @1CAF stack[-2] // @1CB0 stack[-3] // @1CB2 memory[stack[-2]:stack[-2] + 0x20] // } 1CAB 5B JUMPDEST 1CAC 60 PUSH1 0xf8 1CAE 1B SHL 1CAF 81 DUP2 1CB0 83 DUP4 1CB1 81 DUP2 1CB2 51 MLOAD 1CB3 81 DUP2 1CB4 10 LT 1CB5 61 PUSH2 0x1cce 1CB8 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @1CAE stack[-1] = stack[-1] << 0xf8 // @1CAF stack[0] = stack[-2] // @1CB0 stack[1] = stack[-3] // } // Block ends with conditional jump to 0x1cce, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] label_1CB9: // Incoming jump from 0x1CB8, if not stack[-3] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @1CCD memory[0x00:0x24] } 1CB9 63 PUSH4 0x4e487b71 1CBE 60 PUSH1 0xe0 1CC0 1B SHL 1CC1 60 PUSH1 0x00 1CC3 52 MSTORE 1CC4 60 PUSH1 0x32 1CC6 60 PUSH1 0x04 1CC8 52 MSTORE 1CC9 60 PUSH1 0x24 1CCB 60 PUSH1 0x00 1CCD FD *REVERT // Stack delta = +0 // Outputs[3] // { // @1CC3 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @1CC8 memory[0x04:0x24] = 0x32 // @1CCD revert(memory[0x00:0x24]); // } // Block terminates label_1CCE: // Incoming jump from 0x1CB8, if stack[-3] < memory[stack[-2]:stack[-2] + 0x20] // Inputs[4] // { // @1CD1 stack[-1] // @1CD2 stack[-2] // @1CD3 stack[-3] // @1CEB stack[-8] // } 1CCE 5B JUMPDEST 1CCF 60 PUSH1 0x20 1CD1 01 ADD 1CD2 01 ADD 1CD3 90 SWAP1 1CD4 60 PUSH1 0x01 1CD6 60 PUSH1 0x01 1CD8 60 PUSH1 0xf8 1CDA 1B SHL 1CDB 03 SUB 1CDC 19 NOT 1CDD 16 AND 1CDE 90 SWAP1 1CDF 81 DUP2 1CE0 60 PUSH1 0x00 1CE2 1A BYTE 1CE3 90 SWAP1 1CE4 53 MSTORE8 1CE5 50 POP 1CE6 61 PUSH2 0x1cf0 1CE9 60 PUSH1 0x0a 1CEB 86 DUP7 1CEC 61 PUSH2 0x2780 1CEF 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1CE4 memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~((0x01 << 0xf8) - 0x01) & stack[-3], 0x00) // @1CE6 stack[-3] = 0x1cf0 // @1CE9 stack[-2] = 0x0a // @1CEB stack[-1] = stack[-8] // } // Block ends with call to 0x2780, returns to 0x1CF0 label_1CF0: // Incoming return from call to 0x2780 at 0x1CEF // Inputs[2] // { // @1CF1 stack[-1] // @1CF1 stack[-6] // } 1CF0 5B JUMPDEST 1CF1 94 SWAP5 1CF2 50 POP 1CF3 61 PUSH2 0x1c82 1CF6 56 *JUMP // Stack delta = -1 // Outputs[1] { @1CF1 stack[-6] = stack[-1] } // Block ends with unconditional jump to 0x1c82 1CF7 5B JUMPDEST 1CF8 60 PUSH1 0x00 1CFA 60 PUSH1 0x40 1CFC 51 MLOAD 1CFD 80 DUP1 1CFE 60 PUSH1 0x80 1D00 01 ADD 1D01 60 PUSH1 0x40 1D03 52 MSTORE 1D04 80 DUP1 1D05 60 PUSH1 0x43 1D07 81 DUP2 1D08 52 MSTORE 1D09 60 PUSH1 0x20 1D0B 01 ADD 1D0C 61 PUSH2 0x28b9 1D0F 60 PUSH1 0x43 1D11 91 SWAP2 1D12 39 CODECOPY 1D13 80 DUP1 1D14 51 MLOAD 1D15 60 PUSH1 0x20 1D17 91 SWAP2 1D18 82 DUP3 1D19 01 ADD 1D1A 20 SHA3 1D1B 83 DUP4 1D1C 51 MLOAD 1D1D 84 DUP5 1D1E 83 DUP4 1D1F 01 ADD 1D20 51 MLOAD 1D21 60 PUSH1 0x40 1D23 80 DUP1 1D24 87 DUP8 1D25 01 ADD 1D26 51 MLOAD 1D27 80 DUP1 1D28 51 MLOAD 1D29 90 SWAP1 1D2A 86 DUP7 1D2B 01 ADD 1D2C 20 SHA3 1D2D 90 SWAP1 1D2E 51 MLOAD 1D2F 61 PUSH2 0x1d57 1D32 95 SWAP6 1D33 01 ADD 1D34 93 SWAP4 1D35 84 DUP5 1D36 52 MSTORE 1D37 60 PUSH1 0x20 1D39 84 DUP5 1D3A 01 ADD 1D3B 92 SWAP3 1D3C 90 SWAP1 1D3D 92 SWAP3 1D3E 52 MSTORE 1D3F 60 PUSH1 0x01 1D41 60 PUSH1 0x01 1D43 60 PUSH1 0xa0 1D45 1B SHL 1D46 03 SUB 1D47 16 AND 1D48 60 PUSH1 0x40 1D4A 83 DUP4 1D4B 01 ADD 1D4C 52 MSTORE 1D4D 60 PUSH1 0x60 1D4F 82 DUP3 1D50 01 ADD 1D51 52 MSTORE 1D52 60 PUSH1 0x80 1D54 01 ADD 1D55 90 SWAP1 1D56 56 *JUMP 1D57 5B JUMPDEST 1D58 60 PUSH1 0x40 1D5A 51 MLOAD 1D5B 60 PUSH1 0x20 1D5D 81 DUP2 1D5E 83 DUP4 1D5F 03 SUB 1D60 03 SUB 1D61 81 DUP2 1D62 52 MSTORE 1D63 90 SWAP1 1D64 60 PUSH1 0x40 1D66 52 MSTORE 1D67 80 DUP1 1D68 51 MLOAD 1D69 90 SWAP1 1D6A 60 PUSH1 0x20 1D6C 01 ADD 1D6D 20 SHA3 1D6E 90 SWAP1 1D6F 50 POP 1D70 91 SWAP2 1D71 90 SWAP1 1D72 50 POP 1D73 56 *JUMP 1D74 5B JUMPDEST 1D75 60 PUSH1 0x00 1D77 61 PUSH2 0x1d7f 1D7A 60 PUSH1 0x0b 1D7C 54 SLOAD 1D7D 90 SWAP1 1D7E 56 *JUMP 1D7F 5B JUMPDEST 1D80 60 PUSH1 0x40 1D82 51 MLOAD 1D83 61 PUSH2 0x1901 1D86 60 PUSH1 0xf0 1D88 1B SHL 1D89 60 PUSH1 0x20 1D8B 82 DUP3 1D8C 01 ADD 1D8D 52 MSTORE 1D8E 60 PUSH1 0x22 1D90 81 DUP2 1D91 01 ADD 1D92 91 SWAP2 1D93 90 SWAP1 1D94 91 SWAP2 1D95 52 MSTORE 1D96 60 PUSH1 0x42 1D98 81 DUP2 1D99 01 ADD 1D9A 83 DUP4 1D9B 90 SWAP1 1D9C 52 MSTORE 1D9D 60 PUSH1 0x62 1D9F 01 ADD 1DA0 61 PUSH2 0x1d57 1DA3 56 *JUMP label_1DA4: // Incoming call from 0x1744, returns to 0x1745 // Inputs[1] { @1DAD stack[-3] } 1DA4 5B JUMPDEST 1DA5 60 PUSH1 0x01 1DA7 60 PUSH1 0x01 1DA9 60 PUSH1 0xa0 1DAB 1B SHL 1DAC 03 SUB 1DAD 83 DUP4 1DAE 16 AND 1DAF 61 PUSH2 0x1dff 1DB2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1dff, if stack[-3] & (0x01 << 0xa0) - 0x01 label_1DB3: // Incoming jump from 0x1DB2, if not stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @1DB6 stack[-1] // @1DBA storage[0x08] // @1DC8 memory[0x00:0x40] // } 1DB3 61 PUSH2 0x1dfa 1DB6 81 DUP2 1DB7 60 PUSH1 0x08 1DB9 80 DUP1 1DBA 54 SLOAD 1DBB 60 PUSH1 0x00 1DBD 83 DUP4 1DBE 81 DUP2 1DBF 52 MSTORE 1DC0 60 PUSH1 0x09 1DC2 60 PUSH1 0x20 1DC4 52 MSTORE 1DC5 60 PUSH1 0x40 1DC7 81 DUP2 1DC8 20 SHA3 1DC9 82 DUP3 1DCA 90 SWAP1 1DCB 55 SSTORE 1DCC 60 PUSH1 0x01 1DCE 82 DUP3 1DCF 01 ADD 1DD0 83 DUP4 1DD1 55 SSTORE 1DD2 91 SWAP2 1DD3 90 SWAP1 1DD4 91 SWAP2 1DD5 52 MSTORE 1DD6 7F PUSH32 0xf3f7a9fe364faab93b216da50a3214154f22a0a2b415b23a84c8169e8b636ee3 1DF7 01 ADD 1DF8 55 SSTORE 1DF9 56 *JUMP // Stack delta = +0 // Outputs[6] // { // @1DBF memory[0x00:0x20] = stack[-1] // @1DC4 memory[0x20:0x40] = 0x09 // @1DCB storage[keccak256(memory[0x00:0x40])] = storage[0x08] // @1DD1 storage[0x08] = storage[0x08] + 0x01 // @1DD5 memory[0x00:0x20] = 0x08 // @1DF8 storage[0xf3f7a9fe364faab93b216da50a3214154f22a0a2b415b23a84c8169e8b636ee3 + storage[0x08]] = stack[-1] // } // Block ends with unconditional jump to 0x1dfa label_1DFA: // Incoming jump from 0x1DF9 1DFA 5B JUMPDEST 1DFB 61 PUSH2 0x1e22 1DFE 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x1e22 label_1DFF: // Incoming jump from 0x1DB2, if stack[-3] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @1E00 stack[-2] // @1E0A stack[-3] // } 1DFF 5B JUMPDEST 1E00 81 DUP2 1E01 60 PUSH1 0x01 1E03 60 PUSH1 0x01 1E05 60 PUSH1 0xa0 1E07 1B SHL 1E08 03 SUB 1E09 16 AND 1E0A 83 DUP4 1E0B 60 PUSH1 0x01 1E0D 60 PUSH1 0x01 1E0F 60 PUSH1 0xa0 1E11 1B SHL 1E12 03 SUB 1E13 16 AND 1E14 14 EQ 1E15 61 PUSH2 0x1e22 1E18 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1e22, if (0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2] label_1E19: // Incoming jump from 0x1E18, if not (0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2] // Inputs[2] // { // @1E1C stack[-3] // @1E1D stack[-1] // } 1E19 61 PUSH2 0x1e22 1E1C 83 DUP4 1E1D 82 DUP3 1E1E 61 PUSH2 0x1f70 1E21 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1E19 stack[0] = 0x1e22 // @1E1C stack[1] = stack[-3] // @1E1D stack[2] = stack[-1] // } // Block ends with call to 0x1f70, returns to 0x1E22 label_1E22: // Incoming return from call to 0x1F70 at 0x1E21 // Incoming jump from 0x1DFE // Incoming jump from 0x1E18, if (0x01 << 0xa0) - 0x01 & stack[-3] == (0x01 << 0xa0) - 0x01 & stack[-2] // Inputs[1] { @1E2B stack[-2] } 1E22 5B JUMPDEST 1E23 60 PUSH1 0x01 1E25 60 PUSH1 0x01 1E27 60 PUSH1 0xa0 1E29 1B SHL 1E2A 03 SUB 1E2B 82 DUP3 1E2C 16 AND 1E2D 61 PUSH2 0x1e39 1E30 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1e39, if stack[-2] & (0x01 << 0xa0) - 0x01 label_1E31: // Incoming jump from 0x1E30, if not stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @1E34 stack[-1] } 1E31 61 PUSH2 0x088a 1E34 81 DUP2 1E35 61 PUSH2 0x200d 1E38 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1E31 stack[0] = 0x088a // @1E34 stack[1] = stack[-1] // } // Block ends with call to 0x200d, returns to 0x088A label_1E39: // Incoming jump from 0x1E30, if stack[-2] & (0x01 << 0xa0) - 0x01 // Inputs[2] // { // @1E3A stack[-3] // @1E44 stack[-2] // } 1E39 5B JUMPDEST 1E3A 82 DUP3 1E3B 60 PUSH1 0x01 1E3D 60 PUSH1 0x01 1E3F 60 PUSH1 0xa0 1E41 1B SHL 1E42 03 SUB 1E43 16 AND 1E44 82 DUP3 1E45 60 PUSH1 0x01 1E47 60 PUSH1 0x01 1E49 60 PUSH1 0xa0 1E4B 1B SHL 1E4C 03 SUB 1E4D 16 AND 1E4E 14 EQ 1E4F 61 PUSH2 0x088a 1E52 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x088a, if (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-3] label_1E53: // Incoming jump from 0x1E52, if not (0x01 << 0xa0) - 0x01 & stack[-2] == (0x01 << 0xa0) - 0x01 & stack[-3] // Inputs[2] // { // @1E56 stack[-2] // @1E57 stack[-1] // } 1E53 61 PUSH2 0x088a 1E56 82 DUP3 1E57 82 DUP3 1E58 61 PUSH2 0x20e6 1E5B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1E53 stack[0] = 0x088a // @1E56 stack[1] = stack[-2] // @1E57 stack[2] = stack[-1] // } // Block ends with call to 0x20e6, returns to 0x088A label_1E5C: // Incoming call from 0x1BC0, returns to 0x1BC1 // Inputs[2] // { // @1E67 stack[-3] // @1E69 address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // } 1E5C 5B JUMPDEST 1E5D 60 PUSH1 0x00 1E5F 60 PUSH1 0x01 1E61 60 PUSH1 0x01 1E63 60 PUSH1 0xa0 1E65 1B SHL 1E66 03 SUB 1E67 84 DUP5 1E68 16 AND 1E69 3B EXTCODESIZE 1E6A 15 ISZERO 1E6B 61 PUSH2 0x1f65 1E6E 57 *JUMPI // Stack delta = +1 // Outputs[1] { @1E5D stack[0] = 0x00 } // Block ends with conditional jump to 0x1f65, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length label_1E6F: // Incoming jump from 0x1E6E, if not !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[1] { @1E6F stack[-4] } 1E6F 83 DUP4 1E70 60 PUSH1 0x01 1E72 60 PUSH1 0x01 1E74 60 PUSH1 0xa0 1E76 1B SHL 1E77 03 SUB 1E78 16 AND 1E79 63 PUSH4 0x150b7a02 1E7E 61 PUSH2 0x1e85 1E81 61 PUSH2 0x13e6 1E84 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1E78 stack[0] = (0x01 << 0xa0) - 0x01 & stack[-4] // @1E79 stack[1] = 0x150b7a02 // @1E7E stack[2] = 0x1e85 // } // Block ends with call to 0x13e6, returns to 0x1E85 label_1E85: // Incoming return from call to 0x13E6 at 0x1E84 // Inputs[6] // { // @1E86 stack[-8] // @1E87 stack[-6] // @1E88 stack[-5] // @1E8B memory[0x40:0x60] // @1E8C stack[-2] // @1E9E stack[-1] // } 1E85 5B JUMPDEST 1E86 87 DUP8 1E87 86 DUP7 1E88 86 DUP7 1E89 60 PUSH1 0x40 1E8B 51 MLOAD 1E8C 85 DUP6 1E8D 63 PUSH4 0xffffffff 1E92 16 AND 1E93 60 PUSH1 0xe0 1E95 1B SHL 1E96 81 DUP2 1E97 52 MSTORE 1E98 60 PUSH1 0x04 1E9A 01 ADD 1E9B 61 PUSH2 0x1ea7 1E9E 94 SWAP5 1E9F 93 SWAP4 1EA0 92 SWAP3 1EA1 91 SWAP2 1EA2 90 SWAP1 1EA3 61 PUSH2 0x2640 1EA6 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @1E97 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0xffffffff & stack[-2]) << 0xe0 // @1E9E stack[-1] = 0x1ea7 // @1E9F stack[0] = stack[-1] // @1EA0 stack[1] = stack[-8] // @1EA1 stack[2] = stack[-6] // @1EA2 stack[4] = 0x04 + memory[0x40:0x60] // @1EA2 stack[3] = stack[-5] // } // Block ends with call to 0x2640, returns to 0x1EA7 label_1EA7: // Incoming return from call to 0x2640 at 0x1EA6 // Inputs[4] // { // @1EAC memory[0x40:0x60] // @1EAE stack[-1] // @1EB3 stack[-3] // @1EB5 address(stack[-3]).code.length // } 1EA7 5B JUMPDEST 1EA8 60 PUSH1 0x20 1EAA 60 PUSH1 0x40 1EAC 51 MLOAD 1EAD 80 DUP1 1EAE 83 DUP4 1EAF 03 SUB 1EB0 81 DUP2 1EB1 60 PUSH1 0x00 1EB3 87 DUP8 1EB4 80 DUP1 1EB5 3B EXTCODESIZE 1EB6 15 ISZERO 1EB7 80 DUP1 1EB8 15 ISZERO 1EB9 61 PUSH2 0x1ec1 1EBC 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @1EA8 stack[0] = 0x20 // @1EAC stack[1] = memory[0x40:0x60] // @1EAF stack[2] = stack[-1] - memory[0x40:0x60] // @1EB0 stack[3] = memory[0x40:0x60] // @1EB1 stack[4] = 0x00 // @1EB3 stack[5] = stack[-3] // @1EB6 stack[6] = !address(stack[-3]).code.length // } // Block ends with conditional jump to 0x1ec1, if !!address(stack[-3]).code.length label_1EBD: // Incoming jump from 0x1EBC, if not !!address(stack[-3]).code.length // Inputs[1] { @1EC0 memory[0x00:0x00] } 1EBD 60 PUSH1 0x00 1EBF 80 DUP1 1EC0 FD *REVERT // Stack delta = +0 // Outputs[1] { @1EC0 revert(memory[0x00:0x00]); } // Block terminates label_1EC1: // Incoming jump from 0x1EBC, if !!address(stack[-3]).code.length // Inputs[10] // { // @1EC3 msg.gas // @1EC4 memory[stack[-4]:stack[-4] + stack[-5]] // @1EC4 stack[-2] // @1EC4 stack[-6] // @1EC4 stack[-5] // @1EC4 stack[-3] // @1EC4 address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1EC4 stack[-4] // @1EC4 stack[-7] // @1EC5 stack[-10] // } 1EC1 5B JUMPDEST 1EC2 50 POP 1EC3 5A GAS 1EC4 F1 CALL 1EC5 92 SWAP3 1EC6 50 POP 1EC7 50 POP 1EC8 50 POP 1EC9 80 DUP1 1ECA 15 ISZERO 1ECB 61 PUSH2 0x1ef1 1ECE 57 *JUMPI // Stack delta = -9 // Outputs[2] // { // @1EC4 memory[stack[-6]:stack[-6] + stack[-7]] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // @1EC5 stack[-10] = address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // } // Block ends with conditional jump to 0x1ef1, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) label_1ECF: // Incoming jump from 0x1ECE, if not !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[2] // { // @1ED3 memory[0x40:0x60] // @1ED6 returndata.length // } 1ECF 50 POP 1ED0 60 PUSH1 0x40 1ED2 80 DUP1 1ED3 51 MLOAD 1ED4 60 PUSH1 0x1f 1ED6 3D RETURNDATASIZE 1ED7 90 SWAP1 1ED8 81 DUP2 1ED9 01 ADD 1EDA 60 PUSH1 0x1f 1EDC 19 NOT 1EDD 16 AND 1EDE 82 DUP3 1EDF 01 ADD 1EE0 90 SWAP1 1EE1 92 SWAP3 1EE2 52 MSTORE 1EE3 61 PUSH2 0x1eee 1EE6 91 SWAP2 1EE7 81 DUP2 1EE8 01 ADD 1EE9 90 SWAP1 1EEA 61 PUSH2 0x2459 1EED 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1EE2 memory[0x40:0x60] = memory[0x40:0x60] + (~0x1f & returndata.length + 0x1f) // @1EE6 stack[-1] = 0x1eee // @1EE9 stack[1] = memory[0x40:0x60] // @1EE9 stack[0] = memory[0x40:0x60] + returndata.length // } // Block ends with unconditional jump to 0x2459 1EEE 5B JUMPDEST 1EEF 60 PUSH1 0x01 label_1EF1: // Incoming jump from 0x1ECE, if !address(stack[-2]).call.gas(msg.gas).value(stack[-3])(memory[stack[-4]:stack[-4] + stack[-5]]) // Inputs[1] { @1EF5 stack[-1] } 1EF1 5B JUMPDEST 1EF2 61 PUSH2 0x1f4b 1EF5 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1f4b, if stack[-1] label_1EF6: // Incoming jump from 0x1EF5, if not stack[-1] // Inputs[1] { @1EF6 returndata.length } 1EF6 3D RETURNDATASIZE 1EF7 80 DUP1 1EF8 80 DUP1 1EF9 15 ISZERO 1EFA 61 PUSH2 0x1f1f 1EFD 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @1EF6 stack[0] = returndata.length // @1EF7 stack[1] = returndata.length // } // Block ends with conditional jump to 0x1f1f, if !returndata.length label_1EFE: // Incoming jump from 0x1EFD, if not !returndata.length // Inputs[6] // { // @1F00 memory[0x40:0x60] // @1F01 stack[-2] // @1F08 returndata.length // @1F10 returndata.length // @1F13 returndata.length // @1F1A returndata[0x00:0x00 + returndata.length] // } 1EFE 60 PUSH1 0x40 1F00 51 MLOAD 1F01 91 SWAP2 1F02 50 POP 1F03 60 PUSH1 0x1f 1F05 19 NOT 1F06 60 PUSH1 0x3f 1F08 3D RETURNDATASIZE 1F09 01 ADD 1F0A 16 AND 1F0B 82 DUP3 1F0C 01 ADD 1F0D 60 PUSH1 0x40 1F0F 52 MSTORE 1F10 3D RETURNDATASIZE 1F11 82 DUP3 1F12 52 MSTORE 1F13 3D RETURNDATASIZE 1F14 60 PUSH1 0x00 1F16 60 PUSH1 0x20 1F18 84 DUP5 1F19 01 ADD 1F1A 3E RETURNDATACOPY 1F1B 61 PUSH2 0x1f24 1F1E 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @1F01 stack[-2] = memory[0x40:0x60] // @1F0F memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @1F12 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @1F1A memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x1f24 label_1F1F: // Incoming jump from 0x1EFD, if !returndata.length // Inputs[2] // { // @1F22 stack[-2] // @1F27 memory[0x60:0x80] // } 1F1F 5B JUMPDEST 1F20 60 PUSH1 0x60 1F22 91 SWAP2 1F23 50 POP 1F24 5B JUMPDEST 1F25 50 POP 1F26 80 DUP1 1F27 51 MLOAD 1F28 61 PUSH2 0x1f43 1F2B 57 *JUMPI // Stack delta = -1 // Outputs[1] { @1F22 stack[-2] = 0x60 } // Block ends with conditional jump to 0x1f43, if memory[0x60:0x80] label_1F2C: // Incoming jump from 0x1F2B, if not memory[0x60:0x80] // Incoming jump from 0x1F2B, if not memory[stack[-2]:stack[-2] + 0x20] // Inputs[1] { @1F2E memory[0x40:0x60] } 1F2C 60 PUSH1 0x40 1F2E 51 MLOAD 1F2F 62 PUSH3 0x461bcd 1F33 60 PUSH1 0xe5 1F35 1B SHL 1F36 81 DUP2 1F37 52 MSTORE 1F38 60 PUSH1 0x04 1F3A 01 ADD 1F3B 61 PUSH2 0x0742 1F3E 90 SWAP1 1F3F 61 PUSH2 0x2690 1F42 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1F37 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x461bcd << 0xe5 // @1F3E stack[0] = 0x0742 // @1F3E stack[1] = 0x04 + memory[0x40:0x60] // } // Block ends with call to 0x2690, returns to 0x0742 label_1F43: // Incoming jump from 0x1F2B, if memory[0x60:0x80] // Incoming jump from 0x1F2B, if memory[stack[-2]:stack[-2] + 0x20] // Inputs[3] // { // @1F44 stack[-1] // @1F45 memory[stack[-1]:stack[-1] + 0x20] // @1F4A memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]] // } 1F43 5B JUMPDEST 1F44 80 DUP1 1F45 51 MLOAD 1F46 81 DUP2 1F47 60 PUSH1 0x20 1F49 01 ADD 1F4A FD *REVERT // Stack delta = +0 // Outputs[1] { @1F4A revert(memory[0x20 + stack[-1]:0x20 + stack[-1] + memory[stack[-1]:stack[-1] + 0x20]]); } // Block terminates label_1F4B: // Incoming jump from 0x1EF5, if stack[-1] // Inputs[2] // { // @1F55 stack[-1] // @1F5F stack[-2] // } 1F4B 5B JUMPDEST 1F4C 60 PUSH1 0x01 1F4E 60 PUSH1 0x01 1F50 60 PUSH1 0xe0 1F52 1B SHL 1F53 03 SUB 1F54 19 NOT 1F55 16 AND 1F56 63 PUSH4 0x0a85bd01 1F5B 60 PUSH1 0xe1 1F5D 1B SHL 1F5E 14 EQ 1F5F 90 SWAP1 1F60 50 POP 1F61 61 PUSH2 0x1655 1F64 56 *JUMP // Stack delta = -1 // Outputs[1] { @1F5F stack[-2] = 0x0a85bd01 << 0xe1 == ~((0x01 << 0xe0) - 0x01) & stack[-1] } // Block ends with unconditional jump to 0x1655 label_1F65: // Incoming jump from 0x1E6E, if !address(stack[-3] & (0x01 << 0xa0) - 0x01).code.length // Inputs[2] // { // @1F69 stack[-6] // @1F6A stack[-5] // } 1F65 5B JUMPDEST 1F66 50 POP 1F67 60 PUSH1 0x01 1F69 94 SWAP5 1F6A 93 SWAP4 1F6B 50 POP 1F6C 50 POP 1F6D 50 POP 1F6E 50 POP 1F6F 56 *JUMP // Stack delta = -5 // Outputs[1] { @1F69 stack[-6] = 0x01 } // Block ends with unconditional jump to stack[-6] label_1F70: // Incoming call from 0x1E21, returns to 0x1E22 // Inputs[1] { @1F78 stack[-2] } 1F70 5B JUMPDEST 1F71 60 PUSH1 0x00 1F73 60 PUSH1 0x01 1F75 61 PUSH2 0x1f7d 1F78 84 DUP5 1F79 61 PUSH2 0x0cff 1F7C 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1F71 stack[0] = 0x00 // @1F73 stack[1] = 0x01 // @1F75 stack[2] = 0x1f7d // @1F78 stack[3] = stack[-2] // } // Block ends with call to 0x0cff, returns to 0x1F7D label_1F7D: // Incoming return from call to 0x0CFF at 0x1F7C // Inputs[2] // { // @1F81 stack[-2] // @1F82 stack[-1] // } 1F7D 5B JUMPDEST 1F7E 61 PUSH2 0x1f87 1F81 91 SWAP2 1F82 90 SWAP1 1F83 61 PUSH2 0x27b3 1F86 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @1F81 stack[-2] = 0x1f87 // @1F82 stack[-1] = stack[-2] // @1F82 stack[0] = stack[-1] // } // Block ends with call to 0x27b3, returns to 0x1F87 label_1F87: // Incoming return from call to 0x27B3 at 0x1F86 // Inputs[5] // { // @1F8A stack[-3] // @1F95 memory[0x00:0x40] // @1F96 storage[keccak256(memory[0x00:0x40])] // @1F97 stack[-1] // @1F98 stack[-2] // } 1F87 5B JUMPDEST 1F88 60 PUSH1 0x00 1F8A 83 DUP4 1F8B 81 DUP2 1F8C 52 MSTORE 1F8D 60 PUSH1 0x07 1F8F 60 PUSH1 0x20 1F91 52 MSTORE 1F92 60 PUSH1 0x40 1F94 90 SWAP1 1F95 20 SHA3 1F96 54 SLOAD 1F97 90 SWAP1 1F98 91 SWAP2 1F99 50 POP 1F9A 80 DUP1 1F9B 82 DUP3 1F9C 14 EQ 1F9D 61 PUSH2 0x1fda 1FA0 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @1F8C memory[0x00:0x20] = stack[-3] // @1F91 memory[0x20:0x40] = 0x07 // @1F97 stack[-1] = storage[keccak256(memory[0x00:0x40])] // @1F98 stack[-2] = stack[-1] // } // Block ends with conditional jump to 0x1fda, if stack[-1] == storage[keccak256(memory[0x00:0x40])] label_1FA1: // Incoming jump from 0x1FA0, if not stack[-1] == storage[keccak256(memory[0x00:0x40])] // Inputs[13] // { // @1FA9 stack[-4] // @1FBB memory[0x00:0x40] // @1FBC stack[-2] // @1FC3 memory[0x00:0x40] // @1FC4 storage[keccak256(memory[0x00:0x40])] // @1FC5 stack[-1] // @1FCA memory[0x00:0x40] // @1FD6 memory[0x00:0x40] // @1FDE stack[-3] // @1FEC memory[0x00:0x40] // @2003 memory[0x00:0x40] // @200A memory[0x00:0x40] // @200C stack[-5] // } 1FA1 60 PUSH1 0x01 1FA3 60 PUSH1 0x01 1FA5 60 PUSH1 0xa0 1FA7 1B SHL 1FA8 03 SUB 1FA9 84 DUP5 1FAA 16 AND 1FAB 60 PUSH1 0x00 1FAD 90 SWAP1 1FAE 81 DUP2 1FAF 52 MSTORE 1FB0 60 PUSH1 0x06 1FB2 60 PUSH1 0x20 1FB4 90 SWAP1 1FB5 81 DUP2 1FB6 52 MSTORE 1FB7 60 PUSH1 0x40 1FB9 80 DUP1 1FBA 83 DUP4 1FBB 20 SHA3 1FBC 85 DUP6 1FBD 84 DUP5 1FBE 52 MSTORE 1FBF 82 DUP3 1FC0 52 MSTORE 1FC1 80 DUP1 1FC2 83 DUP4 1FC3 20 SHA3 1FC4 54 SLOAD 1FC5 84 DUP5 1FC6 84 DUP5 1FC7 52 MSTORE 1FC8 81 DUP2 1FC9 84 DUP5 1FCA 20 SHA3 1FCB 81 DUP2 1FCC 90 SWAP1 1FCD 55 SSTORE 1FCE 83 DUP4 1FCF 52 MSTORE 1FD0 60 PUSH1 0x07 1FD2 90 SWAP1 1FD3 91 SWAP2 1FD4 52 MSTORE 1FD5 90 SWAP1 1FD6 20 SHA3 1FD7 81 DUP2 1FD8 90 SWAP1 1FD9 55 SSTORE 1FDA 5B JUMPDEST 1FDB 50 POP 1FDC 60 PUSH1 0x00 1FDE 91 SWAP2 1FDF 82 DUP3 1FE0 52 MSTORE 1FE1 60 PUSH1 0x07 1FE3 60 PUSH1 0x20 1FE5 90 SWAP1 1FE6 81 DUP2 1FE7 52 MSTORE 1FE8 60 PUSH1 0x40 1FEA 80 DUP1 1FEB 84 DUP5 1FEC 20 SHA3 1FED 84 DUP5 1FEE 90 SWAP1 1FEF 55 SSTORE 1FF0 60 PUSH1 0x01 1FF2 60 PUSH1 0x01 1FF4 60 PUSH1 0xa0 1FF6 1B SHL 1FF7 03 SUB 1FF8 90 SWAP1 1FF9 94 SWAP5 1FFA 16 AND 1FFB 83 DUP4 1FFC 52 MSTORE 1FFD 60 PUSH1 0x06 1FFF 81 DUP2 2000 52 MSTORE 2001 83 DUP4 2002 83 DUP4 2003 20 SHA3 2004 91 SWAP2 2005 83 DUP4 2006 52 MSTORE 2007 52 MSTORE 2008 90 SWAP1 2009 81 DUP2 200A 20 SHA3 200B 55 SSTORE 200C 56 *JUMP // Stack delta = -5 // Outputs[17] // { // @1FAF memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @1FB6 memory[0x20:0x40] = 0x06 // @1FBE memory[0x00:0x20] = stack[-2] // @1FC0 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @1FC7 memory[0x00:0x20] = stack[-1] // @1FCD storage[keccak256(memory[0x00:0x40])] = storage[keccak256(memory[0x00:0x40])] // @1FCF memory[0x00:0x20] = storage[keccak256(memory[0x00:0x40])] // @1FD4 memory[0x20:0x40] = 0x07 // @1FD9 storage[keccak256(memory[0x00:0x40])] = stack[-1] // @1FE0 memory[0x00:0x20] = stack[-3] // @1FE7 memory[0x20:0x40] = 0x07 // @1FEF storage[keccak256(memory[0x00:0x40])] = 0x00 // @1FFC memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @2000 memory[0x20:0x40] = 0x06 // @2006 memory[0x00:0x20] = stack[-2] // @2007 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @200B storage[keccak256(memory[0x00:0x40])] = 0x00 // } // Block ends with unconditional jump to stack[-5] label_200D: // Incoming call from 0x1E38, returns to 0x088A // Inputs[1] { @2010 storage[0x08] } 200D 5B JUMPDEST 200E 60 PUSH1 0x08 2010 54 SLOAD 2011 60 PUSH1 0x00 2013 90 SWAP1 2014 61 PUSH2 0x201f 2017 90 SWAP1 2018 60 PUSH1 0x01 201A 90 SWAP1 201B 61 PUSH2 0x27b3 201E 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2013 stack[0] = 0x00 // @2017 stack[1] = 0x201f // @201A stack[2] = 0x01 // @201A stack[3] = storage[0x08] // } // Block ends with call to 0x27b3, returns to 0x201F label_201F: // Incoming return from call to 0x27B3 at 0x201E // Inputs[6] // { // @2022 stack[-3] // @202D memory[0x00:0x40] // @202E storage[keccak256(memory[0x00:0x40])] // @2032 storage[0x08] // @2033 stack[-1] // @2034 stack[-2] // } 201F 5B JUMPDEST 2020 60 PUSH1 0x00 2022 83 DUP4 2023 81 DUP2 2024 52 MSTORE 2025 60 PUSH1 0x09 2027 60 PUSH1 0x20 2029 52 MSTORE 202A 60 PUSH1 0x40 202C 81 DUP2 202D 20 SHA3 202E 54 SLOAD 202F 60 PUSH1 0x08 2031 80 DUP1 2032 54 SLOAD 2033 93 SWAP4 2034 94 SWAP5 2035 50 POP 2036 90 SWAP1 2037 92 SWAP3 2038 84 DUP5 2039 90 SWAP1 203A 81 DUP2 203B 10 LT 203C 61 PUSH2 0x2055 203F 57 *JUMPI // Stack delta = +3 // Outputs[7] // { // @2020 stack[0] = 0x00 // @2024 memory[0x00:0x20] = stack[-3] // @2029 memory[0x20:0x40] = 0x09 // @2034 stack[-2] = stack[-1] // @2036 stack[1] = 0x08 // @2037 stack[-1] = storage[keccak256(memory[0x00:0x40])] // @2039 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x2055, if stack[-1] < storage[0x08] label_2040: // Incoming jump from 0x203F, if not stack[-1] < storage[0x08] // Inputs[1] { @2054 memory[0x00:0x24] } 2040 63 PUSH4 0x4e487b71 2045 60 PUSH1 0xe0 2047 1B SHL 2048 60 PUSH1 0x00 204A 52 MSTORE 204B 60 PUSH1 0x32 204D 60 PUSH1 0x04 204F 52 MSTORE 2050 60 PUSH1 0x24 2052 60 PUSH1 0x00 2054 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @204A memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @204F memory[0x04:0x24] = 0x32 // @2054 revert(memory[0x00:0x24]); // } // Block terminates label_2055: // Incoming jump from 0x203F, if stack[-1] < storage[0x08] // Inputs[7] // { // @2056 stack[-2] // @2056 stack[-1] // @205E memory[0x00:0x20] // @2060 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @2061 stack[-3] // @2066 stack[-4] // @2068 storage[0x08] // } 2055 5B JUMPDEST 2056 90 SWAP1 2057 60 PUSH1 0x00 2059 52 MSTORE 205A 60 PUSH1 0x20 205C 60 PUSH1 0x00 205E 20 SHA3 205F 01 ADD 2060 54 SLOAD 2061 90 SWAP1 2062 50 POP 2063 80 DUP1 2064 60 PUSH1 0x08 2066 83 DUP4 2067 81 DUP2 2068 54 SLOAD 2069 81 DUP2 206A 10 LT 206B 61 PUSH2 0x2084 206E 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @2059 memory[0x00:0x20] = stack[-2] // @2061 stack[-3] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @2063 stack[-2] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @2064 stack[-1] = 0x08 // @2066 stack[0] = stack[-4] // } // Block ends with conditional jump to 0x2084, if stack[-4] < storage[0x08] label_206F: // Incoming jump from 0x206E, if not stack[-4] < storage[0x08] // Inputs[1] { @2083 memory[0x00:0x24] } 206F 63 PUSH4 0x4e487b71 2074 60 PUSH1 0xe0 2076 1B SHL 2077 60 PUSH1 0x00 2079 52 MSTORE 207A 60 PUSH1 0x32 207C 60 PUSH1 0x04 207E 52 MSTORE 207F 60 PUSH1 0x24 2081 60 PUSH1 0x00 2083 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2079 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @207E memory[0x04:0x24] = 0x32 // @2083 revert(memory[0x00:0x24]); // } // Block terminates label_2084: // Incoming jump from 0x206E, if stack[-4] < storage[0x08] // Inputs[10] // { // @2087 stack[-2] // @208E memory[0x00:0x20] // @2090 stack[-1] // @2092 stack[-3] // @2096 stack[-4] // @20A2 memory[0x00:0x40] // @20A3 stack[-5] // @20A6 stack[-7] // @20AA memory[0x00:0x40] // @20AF storage[0x08] // } 2084 5B JUMPDEST 2085 60 PUSH1 0x00 2087 91 SWAP2 2088 82 DUP3 2089 52 MSTORE 208A 60 PUSH1 0x20 208C 80 DUP1 208D 83 DUP4 208E 20 SHA3 208F 90 SWAP1 2090 91 SWAP2 2091 01 ADD 2092 92 SWAP3 2093 90 SWAP1 2094 92 SWAP3 2095 55 SSTORE 2096 82 DUP3 2097 81 DUP2 2098 52 MSTORE 2099 60 PUSH1 0x09 209B 90 SWAP1 209C 91 SWAP2 209D 52 MSTORE 209E 60 PUSH1 0x40 20A0 80 DUP1 20A1 82 DUP3 20A2 20 SHA3 20A3 84 DUP5 20A4 90 SWAP1 20A5 55 SSTORE 20A6 85 DUP6 20A7 82 DUP3 20A8 52 MSTORE 20A9 81 DUP2 20AA 20 SHA3 20AB 55 SSTORE 20AC 60 PUSH1 0x08 20AE 80 DUP1 20AF 54 SLOAD 20B0 80 DUP1 20B1 61 PUSH2 0x20ca 20B4 57 *JUMPI // Stack delta = -1 // Outputs[9] // { // @2089 memory[0x00:0x20] = stack[-2] // @2095 storage[stack[-1] + keccak256(memory[0x00:0x20])] = stack[-3] // @2098 memory[0x00:0x20] = stack[-4] // @209D memory[0x20:0x40] = 0x09 // @20A5 storage[keccak256(memory[0x00:0x40])] = stack[-5] // @20A8 memory[0x00:0x20] = stack[-7] // @20AB storage[keccak256(memory[0x00:0x40])] = 0x00 // @20AC stack[-3] = 0x08 // @20AF stack[-2] = storage[0x08] // } // Block ends with conditional jump to 0x20ca, if storage[0x08] label_20B5: // Incoming jump from 0x20B4, if not storage[0x08] // Inputs[1] { @20C9 memory[0x00:0x24] } 20B5 63 PUSH4 0x4e487b71 20BA 60 PUSH1 0xe0 20BC 1B SHL 20BD 60 PUSH1 0x00 20BF 52 MSTORE 20C0 60 PUSH1 0x31 20C2 60 PUSH1 0x04 20C4 52 MSTORE 20C5 60 PUSH1 0x24 20C7 60 PUSH1 0x00 20C9 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @20BF memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @20C4 memory[0x04:0x24] = 0x31 // @20C9 revert(memory[0x00:0x24]); // } // Block terminates label_20CA: // Incoming jump from 0x20B4, if storage[0x08] // Inputs[4] // { // @20CD stack[-1] // @20CF stack[-2] // @20D9 memory[0x00:0x20] // @20E5 stack[-7] // } 20CA 5B JUMPDEST 20CB 60 PUSH1 0x01 20CD 90 SWAP1 20CE 03 SUB 20CF 81 DUP2 20D0 81 DUP2 20D1 90 SWAP1 20D2 60 PUSH1 0x00 20D4 52 MSTORE 20D5 60 PUSH1 0x20 20D7 60 PUSH1 0x00 20D9 20 SHA3 20DA 01 ADD 20DB 60 PUSH1 0x00 20DD 90 SWAP1 20DE 55 SSTORE 20DF 90 SWAP1 20E0 55 SSTORE 20E1 50 POP 20E2 50 POP 20E3 50 POP 20E4 50 POP 20E5 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @20D4 memory[0x00:0x20] = stack[-2] // @20DE storage[keccak256(memory[0x00:0x20]) + (stack[-1] - 0x01)] = 0x00 // @20E0 storage[stack[-2]] = stack[-1] - 0x01 // } // Block ends with unconditional jump to stack[-7] label_20E6: // Incoming call from 0x1E5B, returns to 0x088A // Inputs[1] { @20EC stack[-2] } 20E6 5B JUMPDEST 20E7 60 PUSH1 0x00 20E9 61 PUSH2 0x20f1 20EC 83 DUP4 20ED 61 PUSH2 0x0cff 20F0 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @20E7 stack[0] = 0x00 // @20E9 stack[1] = 0x20f1 // @20EC stack[2] = stack[-2] // } // Block ends with call to 0x0cff, returns to 0x20F1 label_20F1: // Incoming return from call to 0x0CFF at 0x20F0 // Inputs[8] // { // @20FA stack[-1] // @20FB stack[-4] // @210D memory[0x00:0x40] // @2115 memory[0x00:0x40] // @2116 stack[-3] // @2121 stack[-2] // @2123 memory[0x00:0x40] // @2129 stack[-5] // } 20F1 5B JUMPDEST 20F2 60 PUSH1 0x01 20F4 60 PUSH1 0x01 20F6 60 PUSH1 0xa0 20F8 1B SHL 20F9 03 SUB 20FA 90 SWAP1 20FB 93 SWAP4 20FC 16 AND 20FD 60 PUSH1 0x00 20FF 90 SWAP1 2100 81 DUP2 2101 52 MSTORE 2102 60 PUSH1 0x06 2104 60 PUSH1 0x20 2106 90 SWAP1 2107 81 DUP2 2108 52 MSTORE 2109 60 PUSH1 0x40 210B 80 DUP1 210C 83 DUP4 210D 20 SHA3 210E 86 DUP7 210F 84 DUP5 2110 52 MSTORE 2111 82 DUP3 2112 52 MSTORE 2113 80 DUP1 2114 83 DUP4 2115 20 SHA3 2116 85 DUP6 2117 90 SWAP1 2118 55 SSTORE 2119 93 SWAP4 211A 82 DUP3 211B 52 MSTORE 211C 60 PUSH1 0x07 211E 90 SWAP1 211F 52 MSTORE 2120 91 SWAP2 2121 90 SWAP1 2122 91 SWAP2 2123 20 SHA3 2124 91 SWAP2 2125 90 SWAP1 2126 91 SWAP2 2127 55 SSTORE 2128 50 POP 2129 56 *JUMP // Stack delta = -5 // Outputs[8] // { // @2101 memory[0x00:0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @2108 memory[0x20:0x40] = 0x06 // @2110 memory[0x00:0x20] = stack[-1] // @2112 memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @2118 storage[keccak256(memory[0x00:0x40])] = stack[-3] // @211B memory[0x00:0x20] = stack[-3] // @211F memory[0x20:0x40] = 0x07 // @2127 storage[keccak256(memory[0x00:0x40])] = stack[-1] // } // Block ends with unconditional jump to stack[-5] label_212A: // Incoming jump from 0x0EB0 // Inputs[2] // { // @212B stack[-3] // @212D storage[stack[-3]] // } 212A 5B JUMPDEST 212B 82 DUP3 212C 80 DUP1 212D 54 SLOAD 212E 61 PUSH2 0x2136 2131 90 SWAP1 2132 61 PUSH2 0x27f6 2135 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @212B stack[0] = stack[-3] // @2131 stack[1] = 0x2136 // @2131 stack[2] = storage[stack[-3]] // } // Block ends with call to 0x27f6, returns to 0x2136 label_2136: // Incoming return from call to 0x27F6 at 0x2135 // Inputs[5] // { // @2137 stack[-2] // @2137 stack[-1] // @213F memory[0x00:0x20] // @214A stack[-4] // @214B stack[-3] // } 2136 5B JUMPDEST 2137 90 SWAP1 2138 60 PUSH1 0x00 213A 52 MSTORE 213B 60 PUSH1 0x20 213D 60 PUSH1 0x00 213F 20 SHA3 2140 90 SWAP1 2141 60 PUSH1 0x1f 2143 01 ADD 2144 60 PUSH1 0x20 2146 90 SWAP1 2147 04 DIV 2148 81 DUP2 2149 01 ADD 214A 92 SWAP3 214B 82 DUP3 214C 61 PUSH2 0x2158 214F 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @213A memory[0x00:0x20] = stack[-2] // @2140 stack[-2] = keccak256(memory[0x00:0x20]) // @214A stack[-1] = stack[-4] // @214A stack[-4] = keccak256(memory[0x00:0x20]) + (0x1f + stack[-1]) / 0x20 // } // Block ends with conditional jump to 0x2158, if stack[-3] label_2150: // Incoming jump from 0x214F, if not stack[-3] // Inputs[1] { @2152 stack[-5] } 2150 60 PUSH1 0x00 2152 85 DUP6 2153 55 SSTORE 2154 61 PUSH2 0x219e 2157 56 *JUMP // Stack delta = +0 // Outputs[1] { @2153 storage[stack[-5]] = 0x00 } // Block ends with unconditional jump to 0x219e label_2158: // Incoming jump from 0x214F, if stack[-3] // Inputs[1] { @2159 stack[-3] } 2158 5B JUMPDEST 2159 82 DUP3 215A 60 PUSH1 0x1f 215C 10 LT 215D 61 PUSH2 0x2171 2160 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2171, if 0x1f < stack[-3] label_2161: // Incoming jump from 0x2160, if not 0x1f < stack[-3] // Inputs[4] // { // @2161 stack[-1] // @2162 memory[stack[-1]:stack[-1] + 0x20] // @2167 stack[-3] // @216B stack[-5] // } 2161 80 DUP1 2162 51 MLOAD 2163 60 PUSH1 0xff 2165 19 NOT 2166 16 AND 2167 83 DUP4 2168 80 DUP1 2169 01 ADD 216A 17 OR 216B 85 DUP6 216C 55 SSTORE 216D 61 PUSH2 0x219e 2170 56 *JUMP // Stack delta = +0 // Outputs[1] { @216C storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x219e label_2171: // Incoming jump from 0x2160, if 0x1f < stack[-3] // Inputs[2] // { // @2172 stack[-3] // @2178 stack[-5] // } 2171 5B JUMPDEST 2172 82 DUP3 2173 80 DUP1 2174 01 ADD 2175 60 PUSH1 0x01 2177 01 ADD 2178 85 DUP6 2179 55 SSTORE 217A 82 DUP3 217B 15 ISZERO 217C 61 PUSH2 0x219e 217F 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2179 storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x219e, if !stack[-3] label_2180: // Incoming jump from 0x217F, if not !stack[-3] // Inputs[2] // { // @2180 stack[-3] // @2180 stack[-1] // } 2180 91 SWAP2 2181 82 DUP3 2182 01 ADD 2183 5B JUMPDEST 2184 82 DUP3 2185 81 DUP2 2186 11 GT 2187 15 ISZERO 2188 61 PUSH2 0x219e 218B 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2180 stack[-3] = stack[-1] // @2182 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x219e, if !(stack[-1] + stack[-3] > stack[-1]) label_218C: // Incoming jump from 0x218B, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x218B, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @218C stack[-3] // @218D memory[stack[-3]:stack[-3] + 0x20] // @218E stack[-2] // @2190 stack[-1] // } 218C 82 DUP3 218D 51 MLOAD 218E 82 DUP3 218F 55 SSTORE 2190 91 SWAP2 2191 60 PUSH1 0x20 2193 01 ADD 2194 91 SWAP2 2195 90 SWAP1 2196 60 PUSH1 0x01 2198 01 ADD 2199 90 SWAP1 219A 61 PUSH2 0x2183 219D 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @218F storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @2194 stack[-3] = 0x20 + stack[-3] // @2199 stack[-2] = 0x01 + stack[-2] // @2199 stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x2183 label_219E: // Incoming jump from 0x2157 // Incoming jump from 0x2170 // Incoming jump from 0x218B, if !(stack[-1] > stack[-3]) // Incoming jump from 0x217F, if !stack[-3] // Incoming jump from 0x218B, if !(stack[-1] + stack[-3] > stack[-1]) // Inputs[2] // { // @21A3 stack[-4] // @21A4 stack[-3] // } 219E 5B JUMPDEST 219F 50 POP 21A0 61 PUSH2 0x21aa 21A3 92 SWAP3 21A4 91 SWAP2 21A5 50 POP 21A6 61 PUSH2 0x21ae 21A9 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @21A3 stack[-4] = 0x21aa // @21A4 stack[-3] = stack[-4] // } // Block ends with call to 0x21ae, returns to 0x21AA label_21AA: // Incoming return from call to 0x21AE at 0x21A9 // Incoming jump from 0x21B7, if !(stack[-2] > stack[-1]) // Incoming jump from 0x21B7, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @21AC stack[-3] // @21AC stack[-2] // } 21AA 5B JUMPDEST 21AB 50 POP 21AC 90 SWAP1 21AD 56 *JUMP // Stack delta = -2 // Outputs[1] { @21AC stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_21AE: // Incoming call from 0x21A9, returns to 0x21AA // Inputs[2] // { // @21B0 stack[-1] // @21B1 stack[-2] // } 21AE 5B JUMPDEST 21AF 5B JUMPDEST 21B0 80 DUP1 21B1 82 DUP3 21B2 11 GT 21B3 15 ISZERO 21B4 61 PUSH2 0x21aa 21B7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x21aa, if !(stack[-2] > stack[-1]) label_21B8: // Incoming jump from 0x21B7, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x21B7, if not !(stack[-2] > stack[-1]) // Inputs[1] { @21BA stack[-1] } 21B8 60 PUSH1 0x00 21BA 81 DUP2 21BB 55 SSTORE 21BC 60 PUSH1 0x01 21BE 01 ADD 21BF 61 PUSH2 0x21af 21C2 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @21BB storage[stack[-1]] = 0x00 // @21BE stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x21af label_21C3: // Incoming call from 0x2273, returns to 0x155F // Incoming call from 0x24BA, returns to 0x1655 // Inputs[1] { @21D0 stack[-2] } 21C3 5B JUMPDEST 21C4 60 PUSH1 0x00 21C6 67 PUSH8 0xffffffffffffffff 21CF 80 DUP1 21D0 84 DUP5 21D1 11 GT 21D2 15 ISZERO 21D3 61 PUSH2 0x21de 21D6 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @21C4 stack[0] = 0x00 // @21C6 stack[1] = 0xffffffffffffffff // } // Block ends with conditional jump to 0x21de, if !(stack[-2] > 0xffffffffffffffff) label_21D7: // Incoming jump from 0x21D6, if not !(stack[-2] > 0xffffffffffffffff) 21D7 61 PUSH2 0x21de 21DA 61 PUSH2 0x288c 21DD 56 *JUMP // Stack delta = +1 // Outputs[1] { @21D7 stack[0] = 0x21de } // Block ends with unconditional jump to 0x288c label_21DE: // Incoming jump from 0x21D6, if !(stack[-2] > 0xffffffffffffffff) // Inputs[3] // { // @21E1 memory[0x40:0x60] // @21E4 stack[-4] // @21F3 stack[-1] // } 21DE 5B JUMPDEST 21DF 60 PUSH1 0x40 21E1 51 MLOAD 21E2 60 PUSH1 0x1f 21E4 85 DUP6 21E5 01 ADD 21E6 60 PUSH1 0x1f 21E8 19 NOT 21E9 90 SWAP1 21EA 81 DUP2 21EB 16 AND 21EC 60 PUSH1 0x3f 21EE 01 ADD 21EF 16 AND 21F0 81 DUP2 21F1 01 ADD 21F2 90 SWAP1 21F3 82 DUP3 21F4 82 DUP3 21F5 11 GT 21F6 81 DUP2 21F7 83 DUP4 21F8 10 LT 21F9 17 OR 21FA 15 ISZERO 21FB 61 PUSH2 0x2206 21FE 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @21F2 stack[0] = memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) // @21F2 stack[1] = memory[0x40:0x60] // } // Block ends with conditional jump to 0x2206, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) label_21FF: // Incoming jump from 0x21FE, if not !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) 21FF 61 PUSH2 0x2206 2202 61 PUSH2 0x288c 2205 56 *JUMP // Stack delta = +1 // Outputs[1] { @21FF stack[0] = 0x2206 } // Block ends with unconditional jump to 0x288c label_2206: // Incoming jump from 0x21FE, if !((memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) < memory[0x40:0x60]) | (memory[0x40:0x60] + (0x3f + (~0x1f & stack[-4] + 0x1f) & ~0x1f) > stack[-1])) // Inputs[6] // { // @2207 stack[-2] // @220B stack[-1] // @220C stack[-4] // @220E stack[-6] // @2211 stack[-7] // @2213 stack[-5] // } 2206 5B JUMPDEST 2207 81 DUP2 2208 60 PUSH1 0x40 220A 52 MSTORE 220B 80 DUP1 220C 93 SWAP4 220D 50 POP 220E 85 DUP6 220F 81 DUP2 2210 52 MSTORE 2211 86 DUP7 2212 86 DUP7 2213 86 DUP7 2214 01 ADD 2215 11 GT 2216 15 ISZERO 2217 61 PUSH2 0x221f 221A 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @220A memory[0x40:0x60] = stack[-2] // @220C stack[-4] = stack[-1] // @2210 memory[stack[-1]:stack[-1] + 0x20] = stack[-6] // } // Block ends with conditional jump to 0x221f, if !(stack[-5] + stack[-6] > stack[-7]) label_221B: // Incoming jump from 0x221A, if not !(stack[-5] + stack[-6] > stack[-7]) // Inputs[1] { @221E memory[0x00:0x00] } 221B 60 PUSH1 0x00 221D 80 DUP1 221E FD *REVERT // Stack delta = +0 // Outputs[1] { @221E revert(memory[0x00:0x00]); } // Block terminates label_221F: // Incoming jump from 0x221A, if !(stack[-5] + stack[-6] > stack[-7]) // Inputs[7] // { // @2220 stack[-6] // @2221 stack[-5] // @2224 stack[-1] // @2226 msg.data[stack[-5]:stack[-5] + stack[-6]] // @2233 stack[-4] // @2233 stack[-8] // @2234 stack[-7] // } 221F 5B JUMPDEST 2220 85 DUP6 2221 85 DUP6 2222 60 PUSH1 0x20 2224 83 DUP4 2225 01 ADD 2226 37 CALLDATACOPY 2227 60 PUSH1 0x00 2229 60 PUSH1 0x20 222B 87 DUP8 222C 83 DUP4 222D 01 ADD 222E 01 ADD 222F 52 MSTORE 2230 50 POP 2231 50 POP 2232 50 POP 2233 93 SWAP4 2234 92 SWAP3 2235 50 POP 2236 50 POP 2237 50 POP 2238 56 *JUMP // Stack delta = -7 // Outputs[3] // { // @2226 memory[stack[-1] + 0x20:stack[-1] + 0x20 + stack[-6]] = msg.data[stack[-5]:stack[-5] + stack[-6]] // @222F memory[stack[-1] + stack[-6] + 0x20:stack[-1] + stack[-6] + 0x20 + 0x20] = 0x00 // @2233 stack[-8] = stack[-4] // } // Block ends with unconditional jump to stack[-8] label_2239: // Incoming call from 0x22A8, returns to 0x22A9 // Incoming call from 0x237B, returns to 0x237C // Incoming call from 0x2326, returns to 0x2327 // Incoming call from 0x22B6, returns to 0x22B7 // Incoming call from 0x23BA, returns to 0x23BB // Incoming call from 0x242E, returns to 0x242F // Incoming call from 0x22DC, returns to 0x22DD // Incoming call from 0x228D, returns to 0x155F // Incoming call from 0x22EA, returns to 0x22EB // Incoming call from 0x2318, returns to 0x2319 // Inputs[2] // { // @223A stack[-1] // @223B msg.data[stack[-1]:stack[-1] + 0x20] // } 2239 5B JUMPDEST 223A 80 DUP1 223B 35 CALLDATALOAD 223C 60 PUSH1 0x01 223E 60 PUSH1 0x01 2240 60 PUSH1 0xa0 2242 1B SHL 2243 03 SUB 2244 81 DUP2 2245 16 AND 2246 81 DUP2 2247 14 EQ 2248 61 PUSH2 0x2250 224B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @223B stack[0] = msg.data[stack[-1]:stack[-1] + 0x20] } // Block ends with conditional jump to 0x2250, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 label_224C: // Incoming jump from 0x224B, if not msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[1] { @224F memory[0x00:0x00] } 224C 60 PUSH1 0x00 224E 80 DUP1 224F FD *REVERT // Stack delta = +0 // Outputs[1] { @224F revert(memory[0x00:0x00]); } // Block terminates label_2250: // Incoming jump from 0x224B, if msg.data[stack[-1]:stack[-1] + 0x20] == msg.data[stack[-1]:stack[-1] + 0x20] & (0x01 << 0xa0) - 0x01 // Inputs[3] // { // @2251 stack[-1] // @2251 stack[-3] // @2252 stack[-2] // } 2250 5B JUMPDEST 2251 91 SWAP2 2252 90 SWAP1 2253 50 POP 2254 56 *JUMP // Stack delta = -2 // Outputs[1] { @2251 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_2255: // Incoming jump from 0x23E1 // Incoming jump from 0x2354 // Inputs[2] // { // @2258 stack[-2] // @225B stack[-1] // } 2255 5B JUMPDEST 2256 60 PUSH1 0x00 2258 82 DUP3 2259 60 PUSH1 0x1f 225B 83 DUP4 225C 01 ADD 225D 12 SLT 225E 61 PUSH2 0x2265 2261 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2256 stack[0] = 0x00 } // Block ends with conditional jump to 0x2265, if stack[-1] + 0x1f i< stack[-2] label_2262: // Incoming jump from 0x2261, if not stack[-1] + 0x1f i< stack[-2] // Inputs[2] // { // @2262 stack[-1] // @2264 memory[stack[-1]:stack[-1] + stack[-1]] // } 2262 80 DUP1 2263 81 DUP2 2264 FD *REVERT // Stack delta = +0 // Outputs[1] { @2264 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2265: // Incoming jump from 0x2261, if stack[-1] + 0x1f i< stack[-2] // Inputs[3] // { // @2269 stack[-3] // @226A stack[-2] // @226B msg.data[stack[-2]:stack[-2] + 0x20] // } 2265 5B JUMPDEST 2266 61 PUSH2 0x155f 2269 83 DUP4 226A 83 DUP4 226B 35 CALLDATALOAD 226C 60 PUSH1 0x20 226E 85 DUP6 226F 01 ADD 2270 61 PUSH2 0x21c3 2273 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2266 stack[0] = 0x155f // @2269 stack[1] = stack[-3] // @226B stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // @226F stack[3] = stack[-2] + 0x20 // } // Block ends with call to 0x21c3, returns to 0x155F label_2274: // Incoming call from 0x0485, returns to 0x0486 // Incoming call from 0x0450, returns to 0x0451 // Incoming call from 0x060A, returns to 0x060B // Incoming call from 0x0352, returns to 0x0353 // Inputs[2] // { // @2279 stack[-1] // @227A stack[-2] // } 2274 5B JUMPDEST 2275 60 PUSH1 0x00 2277 60 PUSH1 0x20 2279 82 DUP3 227A 84 DUP5 227B 03 SUB 227C 12 SLT 227D 15 ISZERO 227E 61 PUSH2 0x2285 2281 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2275 stack[0] = 0x00 } // Block ends with conditional jump to 0x2285, if !(stack[-2] - stack[-1] i< 0x20) label_2282: // Incoming jump from 0x2281, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2282 stack[-1] // @2284 memory[stack[-1]:stack[-1] + stack[-1]] // } 2282 80 DUP1 2283 81 DUP2 2284 FD *REVERT // Stack delta = +0 // Outputs[1] { @2284 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2285: // Incoming jump from 0x2281, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[1] { @2289 stack[-2] } 2285 5B JUMPDEST 2286 61 PUSH2 0x155f 2289 82 DUP3 228A 61 PUSH2 0x2239 228D 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2286 stack[0] = 0x155f // @2289 stack[1] = stack[-2] // } // Block ends with call to 0x2239, returns to 0x155F label_228E: // Incoming call from 0x05C1, returns to 0x05C2 // Inputs[2] // { // @2294 stack[-1] // @2295 stack[-2] // } 228E 5B JUMPDEST 228F 60 PUSH1 0x00 2291 80 DUP1 2292 60 PUSH1 0x40 2294 83 DUP4 2295 85 DUP6 2296 03 SUB 2297 12 SLT 2298 15 ISZERO 2299 61 PUSH2 0x22a0 229C 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @228F stack[0] = 0x00 // @2291 stack[1] = 0x00 // } // Block ends with conditional jump to 0x22a0, if !(stack[-2] - stack[-1] i< 0x40) label_229D: // Incoming jump from 0x229C, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @229D stack[-1] // @229F memory[stack[-1]:stack[-1] + stack[-1]] // } 229D 80 DUP1 229E 81 DUP2 229F FD *REVERT // Stack delta = +0 // Outputs[1] { @229F revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_22A0: // Incoming jump from 0x229C, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @22A4 stack[-3] } 22A0 5B JUMPDEST 22A1 61 PUSH2 0x22a9 22A4 83 DUP4 22A5 61 PUSH2 0x2239 22A8 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @22A1 stack[0] = 0x22a9 // @22A4 stack[1] = stack[-3] // } // Block ends with call to 0x2239, returns to 0x22A9 label_22A9: // Incoming return from call to 0x2239 at 0x22A8 // Inputs[3] // { // @22AA stack[-3] // @22AA stack[-1] // @22B1 stack[-4] // } 22A9 5B JUMPDEST 22AA 91 SWAP2 22AB 50 POP 22AC 61 PUSH2 0x22b7 22AF 60 PUSH1 0x20 22B1 84 DUP5 22B2 01 ADD 22B3 61 PUSH2 0x2239 22B6 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @22AA stack[-3] = stack[-1] // @22AC stack[-1] = 0x22b7 // @22B2 stack[0] = stack[-4] + 0x20 // } // Block ends with call to 0x2239, returns to 0x22B7 label_22B7: // Incoming return from call to 0x2239 at 0x22B6 // Inputs[6] // { // @22B8 stack[-2] // @22B8 stack[-1] // @22BA stack[-5] // @22BC stack[-6] // @22BC stack[-3] // @22BD stack[-4] // } 22B7 5B JUMPDEST 22B8 90 SWAP1 22B9 50 POP 22BA 92 SWAP3 22BB 50 POP 22BC 92 SWAP3 22BD 90 SWAP1 22BE 50 POP 22BF 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @22BA stack[-5] = stack[-1] // @22BC stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_22C0: // Incoming call from 0x03D0, returns to 0x03D1 // Incoming call from 0x0332, returns to 0x0333 // Inputs[2] // { // @22C8 stack[-1] // @22C9 stack[-2] // } 22C0 5B JUMPDEST 22C1 60 PUSH1 0x00 22C3 80 DUP1 22C4 60 PUSH1 0x00 22C6 60 PUSH1 0x60 22C8 84 DUP5 22C9 86 DUP7 22CA 03 SUB 22CB 12 SLT 22CC 15 ISZERO 22CD 61 PUSH2 0x22d4 22D0 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @22C1 stack[0] = 0x00 // @22C3 stack[1] = 0x00 // @22C4 stack[2] = 0x00 // } // Block ends with conditional jump to 0x22d4, if !(stack[-2] - stack[-1] i< 0x60) label_22D1: // Incoming jump from 0x22D0, if not !(stack[-2] - stack[-1] i< 0x60) // Inputs[2] // { // @22D1 stack[-1] // @22D3 memory[stack[-1]:stack[-1] + stack[-1]] // } 22D1 80 DUP1 22D2 81 DUP2 22D3 FD *REVERT // Stack delta = +0 // Outputs[1] { @22D3 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_22D4: // Incoming jump from 0x22D0, if !(stack[-2] - stack[-1] i< 0x60) // Inputs[1] { @22D8 stack[-4] } 22D4 5B JUMPDEST 22D5 61 PUSH2 0x22dd 22D8 84 DUP5 22D9 61 PUSH2 0x2239 22DC 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @22D5 stack[0] = 0x22dd // @22D8 stack[1] = stack[-4] // } // Block ends with call to 0x2239, returns to 0x22DD label_22DD: // Incoming return from call to 0x2239 at 0x22DC // Inputs[3] // { // @22DE stack[-4] // @22DE stack[-1] // @22E5 stack[-5] // } 22DD 5B JUMPDEST 22DE 92 SWAP3 22DF 50 POP 22E0 61 PUSH2 0x22eb 22E3 60 PUSH1 0x20 22E5 85 DUP6 22E6 01 ADD 22E7 61 PUSH2 0x2239 22EA 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @22DE stack[-4] = stack[-1] // @22E0 stack[-1] = 0x22eb // @22E6 stack[0] = stack[-5] + 0x20 // } // Block ends with call to 0x2239, returns to 0x22EB label_22EB: // Incoming return from call to 0x2239 at 0x22EA // Inputs[8] // { // @22EC stack[-3] // @22EC stack[-1] // @22F0 stack[-5] // @22F2 msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @22F3 stack[-2] // @22F7 stack[-6] // @22F9 stack[-4] // @22F9 stack[-7] // } 22EB 5B JUMPDEST 22EC 91 SWAP2 22ED 50 POP 22EE 60 PUSH1 0x40 22F0 84 DUP5 22F1 01 ADD 22F2 35 CALLDATALOAD 22F3 90 SWAP1 22F4 50 POP 22F5 92 SWAP3 22F6 50 POP 22F7 92 SWAP3 22F8 50 POP 22F9 92 SWAP3 22FA 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @22F5 stack[-5] = msg.data[stack[-5] + 0x40:stack[-5] + 0x40 + 0x20] // @22F7 stack[-6] = stack[-1] // @22F9 stack[-7] = stack[-4] // } // Block ends with unconditional jump to stack[-7] label_22FB: // Incoming jump from 0x052E // Inputs[2] // { // @2304 stack[-1] // @2305 stack[-2] // } 22FB 5B JUMPDEST 22FC 60 PUSH1 0x00 22FE 80 DUP1 22FF 60 PUSH1 0x00 2301 80 DUP1 2302 60 PUSH1 0x80 2304 85 DUP6 2305 87 DUP8 2306 03 SUB 2307 12 SLT 2308 15 ISZERO 2309 61 PUSH2 0x2310 230C 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @22FC stack[0] = 0x00 // @22FE stack[1] = 0x00 // @22FF stack[2] = 0x00 // @2301 stack[3] = 0x00 // } // Block ends with conditional jump to 0x2310, if !(stack[-2] - stack[-1] i< 0x80) label_230D: // Incoming jump from 0x230C, if not !(stack[-2] - stack[-1] i< 0x80) // Inputs[2] // { // @230D stack[-1] // @230F memory[stack[-1]:stack[-1] + stack[-1]] // } 230D 80 DUP1 230E 81 DUP2 230F FD *REVERT // Stack delta = +0 // Outputs[1] { @230F revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2310: // Incoming jump from 0x230C, if !(stack[-2] - stack[-1] i< 0x80) // Inputs[1] { @2314 stack[-5] } 2310 5B JUMPDEST 2311 61 PUSH2 0x2319 2314 85 DUP6 2315 61 PUSH2 0x2239 2318 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2311 stack[0] = 0x2319 // @2314 stack[1] = stack[-5] // } // Block ends with call to 0x2239, returns to 0x2319 label_2319: // Incoming return from call to 0x2239 at 0x2318 // Inputs[3] // { // @231A stack[-1] // @231A stack[-5] // @2321 stack[-6] // } 2319 5B JUMPDEST 231A 93 SWAP4 231B 50 POP 231C 61 PUSH2 0x2327 231F 60 PUSH1 0x20 2321 86 DUP7 2322 01 ADD 2323 61 PUSH2 0x2239 2326 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @231A stack[-5] = stack[-1] // @231C stack[-1] = 0x2327 // @2322 stack[0] = stack[-6] + 0x20 // } // Block ends with call to 0x2239, returns to 0x2327 label_2327: // Incoming return from call to 0x2239 at 0x2326 // Inputs[6] // { // @2328 stack[-1] // @2328 stack[-4] // @232C stack[-6] // @232E msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @232F stack[-3] // @2335 msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } 2327 5B JUMPDEST 2328 92 SWAP3 2329 50 POP 232A 60 PUSH1 0x40 232C 85 DUP6 232D 01 ADD 232E 35 CALLDATALOAD 232F 91 SWAP2 2330 50 POP 2331 60 PUSH1 0x60 2333 85 DUP6 2334 01 ADD 2335 35 CALLDATALOAD 2336 67 PUSH8 0xffffffffffffffff 233F 81 DUP2 2340 11 GT 2341 15 ISZERO 2342 61 PUSH2 0x2349 2345 57 *JUMPI // Stack delta = +0 // Outputs[3] // { // @2328 stack[-4] = stack[-1] // @232F stack[-3] = msg.data[stack[-6] + 0x40:stack[-6] + 0x40 + 0x20] // @2335 stack[-1] = msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] // } // Block ends with conditional jump to 0x2349, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) label_2346: // Incoming jump from 0x2345, if not !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @2346 stack[-2] // @2348 memory[stack[-2]:stack[-2] + stack[-2]] // } 2346 81 DUP2 2347 82 DUP3 2348 FD *REVERT // Stack delta = +0 // Outputs[1] { @2348 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2349: // Incoming jump from 0x2345, if !(msg.data[stack[-6] + 0x60:stack[-6] + 0x60 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @234D stack[-7] // @234E stack[-1] // @234F stack[-6] // } 2349 5B JUMPDEST 234A 61 PUSH2 0x2355 234D 87 DUP8 234E 82 DUP3 234F 88 DUP9 2350 01 ADD 2351 61 PUSH2 0x2255 2354 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @234A stack[0] = 0x2355 // @234D stack[1] = stack[-7] // @2350 stack[2] = stack[-6] + stack[-1] // } // Block ends with unconditional jump to 0x2255 2355 5B JUMPDEST 2356 91 SWAP2 2357 50 POP 2358 50 POP 2359 92 SWAP3 235A 95 SWAP6 235B 91 SWAP2 235C 94 SWAP5 235D 50 POP 235E 92 SWAP3 235F 50 POP 2360 56 *JUMP label_2361: // Incoming call from 0x050E, returns to 0x050F // Inputs[2] // { // @2367 stack[-1] // @2368 stack[-2] // } 2361 5B JUMPDEST 2362 60 PUSH1 0x00 2364 80 DUP1 2365 60 PUSH1 0x40 2367 83 DUP4 2368 85 DUP6 2369 03 SUB 236A 12 SLT 236B 15 ISZERO 236C 61 PUSH2 0x2373 236F 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2362 stack[0] = 0x00 // @2364 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2373, if !(stack[-2] - stack[-1] i< 0x40) label_2370: // Incoming jump from 0x236F, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2370 stack[-2] // @2372 memory[stack[-2]:stack[-2] + stack[-2]] // } 2370 81 DUP2 2371 82 DUP3 2372 FD *REVERT // Stack delta = +0 // Outputs[1] { @2372 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2373: // Incoming jump from 0x236F, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @2377 stack[-3] } 2373 5B JUMPDEST 2374 61 PUSH2 0x237c 2377 83 DUP4 2378 61 PUSH2 0x2239 237B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2374 stack[0] = 0x237c // @2377 stack[1] = stack[-3] // } // Block ends with call to 0x2239, returns to 0x237C label_237C: // Incoming return from call to 0x2239 at 0x237B // Inputs[4] // { // @237D stack[-1] // @237D stack[-3] // @2381 stack[-4] // @2383 msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } 237C 5B JUMPDEST 237D 91 SWAP2 237E 50 POP 237F 60 PUSH1 0x20 2381 83 DUP4 2382 01 ADD 2383 35 CALLDATALOAD 2384 80 DUP1 2385 15 ISZERO 2386 15 ISZERO 2387 81 DUP2 2388 14 EQ 2389 61 PUSH2 0x2390 238C 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @237D stack[-3] = stack[-1] // @2383 stack[-1] = msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x2390, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] label_238D: // Incoming jump from 0x238C, if not msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[2] // { // @238D stack[-2] // @238F memory[stack[-2]:stack[-2] + stack[-2]] // } 238D 81 DUP2 238E 82 DUP3 238F FD *REVERT // Stack delta = +0 // Outputs[1] { @238F revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2390: // Incoming jump from 0x238C, if msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] == !!msg.data[stack[-4] + 0x20:stack[-4] + 0x20 + 0x20] // Inputs[6] // { // @2391 stack[-1] // @2392 stack[-2] // @2395 stack[-5] // @2397 stack[-6] // @2397 stack[-3] // @2398 stack[-4] // } 2390 5B JUMPDEST 2391 80 DUP1 2392 91 SWAP2 2393 50 POP 2394 50 POP 2395 92 SWAP3 2396 50 POP 2397 92 SWAP3 2398 90 SWAP1 2399 50 POP 239A 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2395 stack[-5] = stack[-1] // @2397 stack[-6] = stack[-3] // } // Block ends with unconditional jump to stack[-6] label_239B: // Incoming jump from 0x02B1 // Inputs[2] // { // @23A6 stack[-1] // @23A7 stack[-2] // } 239B 5B JUMPDEST 239C 60 PUSH1 0x00 239E 80 DUP1 239F 60 PUSH1 0x00 23A1 80 DUP1 23A2 60 PUSH1 0x00 23A4 60 PUSH1 0xa0 23A6 86 DUP7 23A7 88 DUP9 23A8 03 SUB 23A9 12 SLT 23AA 15 ISZERO 23AB 61 PUSH2 0x23b2 23AE 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @239C stack[0] = 0x00 // @239E stack[1] = 0x00 // @239F stack[2] = 0x00 // @23A1 stack[3] = 0x00 // @23A2 stack[4] = 0x00 // } // Block ends with conditional jump to 0x23b2, if !(stack[-2] - stack[-1] i< 0xa0) label_23AF: // Incoming jump from 0x23AE, if not !(stack[-2] - stack[-1] i< 0xa0) // Inputs[2] // { // @23AF stack[-1] // @23B1 memory[stack[-1]:stack[-1] + stack[-1]] // } 23AF 80 DUP1 23B0 81 DUP2 23B1 FD *REVERT // Stack delta = +0 // Outputs[1] { @23B1 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_23B2: // Incoming jump from 0x23AE, if !(stack[-2] - stack[-1] i< 0xa0) // Inputs[1] { @23B6 stack[-6] } 23B2 5B JUMPDEST 23B3 61 PUSH2 0x23bb 23B6 86 DUP7 23B7 61 PUSH2 0x2239 23BA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @23B3 stack[0] = 0x23bb // @23B6 stack[1] = stack[-6] // } // Block ends with call to 0x2239, returns to 0x23BB label_23BB: // Incoming return from call to 0x2239 at 0x23BA // Inputs[4] // { // @23BC stack[-1] // @23BC stack[-6] // @23C0 stack[-7] // @23C2 msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // } 23BB 5B JUMPDEST 23BC 94 SWAP5 23BD 50 POP 23BE 60 PUSH1 0x20 23C0 86 DUP7 23C1 01 ADD 23C2 35 CALLDATALOAD 23C3 67 PUSH8 0xffffffffffffffff 23CC 81 DUP2 23CD 11 GT 23CE 15 ISZERO 23CF 61 PUSH2 0x23d6 23D2 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @23BC stack[-6] = stack[-1] // @23C2 stack[-1] = msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] // } // Block ends with conditional jump to 0x23d6, if !(msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] > 0xffffffffffffffff) label_23D3: // Incoming jump from 0x23D2, if not !(msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @23D3 stack[-2] // @23D5 memory[stack[-2]:stack[-2] + stack[-2]] // } 23D3 81 DUP2 23D4 82 DUP3 23D5 FD *REVERT // Stack delta = +0 // Outputs[1] { @23D5 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_23D6: // Incoming jump from 0x23D2, if !(msg.data[stack[-7] + 0x20:stack[-7] + 0x20 + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @23DA stack[-8] // @23DB stack[-1] // @23DC stack[-7] // } 23D6 5B JUMPDEST 23D7 61 PUSH2 0x23e2 23DA 88 DUP9 23DB 82 DUP3 23DC 89 DUP10 23DD 01 ADD 23DE 61 PUSH2 0x2255 23E1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @23D7 stack[0] = 0x23e2 // @23DA stack[1] = stack[-8] // @23DD stack[2] = stack[-7] + stack[-1] // } // Block ends with unconditional jump to 0x2255 23E2 5B JUMPDEST 23E3 94 SWAP5 23E4 50 POP 23E5 50 POP 23E6 60 PUSH1 0x40 23E8 86 DUP7 23E9 01 ADD 23EA 35 CALLDATALOAD 23EB 92 SWAP3 23EC 50 POP 23ED 60 PUSH1 0x60 23EF 86 DUP7 23F0 01 ADD 23F1 35 CALLDATALOAD 23F2 91 SWAP2 23F3 50 POP 23F4 60 PUSH1 0x80 23F6 86 DUP7 23F7 01 ADD 23F8 35 CALLDATALOAD 23F9 60 PUSH1 0xff 23FB 81 DUP2 23FC 16 AND 23FD 81 DUP2 23FE 14 EQ 23FF 61 PUSH2 0x2406 2402 57 *JUMPI 2403 81 DUP2 2404 82 DUP3 2405 FD *REVERT 2406 5B JUMPDEST 2407 80 DUP1 2408 91 SWAP2 2409 50 POP 240A 50 POP 240B 92 SWAP3 240C 95 SWAP6 240D 50 POP 240E 92 SWAP3 240F 95 SWAP6 2410 90 SWAP1 2411 93 SWAP4 2412 50 POP 2413 56 *JUMP label_2414: // Incoming call from 0x0388, returns to 0x0389 // Incoming call from 0x029C, returns to 0x029D // Inputs[2] // { // @241A stack[-1] // @241B stack[-2] // } 2414 5B JUMPDEST 2415 60 PUSH1 0x00 2417 80 DUP1 2418 60 PUSH1 0x40 241A 83 DUP4 241B 85 DUP6 241C 03 SUB 241D 12 SLT 241E 15 ISZERO 241F 61 PUSH2 0x2426 2422 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2415 stack[0] = 0x00 // @2417 stack[1] = 0x00 // } // Block ends with conditional jump to 0x2426, if !(stack[-2] - stack[-1] i< 0x40) label_2423: // Incoming jump from 0x2422, if not !(stack[-2] - stack[-1] i< 0x40) // Inputs[2] // { // @2423 stack[-2] // @2425 memory[stack[-2]:stack[-2] + stack[-2]] // } 2423 81 DUP2 2424 82 DUP3 2425 FD *REVERT // Stack delta = +0 // Outputs[1] { @2425 revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_2426: // Incoming jump from 0x2422, if !(stack[-2] - stack[-1] i< 0x40) // Inputs[1] { @242A stack[-3] } 2426 5B JUMPDEST 2427 61 PUSH2 0x242f 242A 83 DUP4 242B 61 PUSH2 0x2239 242E 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @2427 stack[0] = 0x242f // @242A stack[1] = stack[-3] // } // Block ends with call to 0x2239, returns to 0x242F label_242F: // Incoming return from call to 0x2239 at 0x242E // Inputs[5] // { // @2430 stack[-6] // @2430 stack[-1] // @2433 stack[-4] // @2437 msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // @2438 stack[-5] // } 242F 5B JUMPDEST 2430 94 SWAP5 2431 60 PUSH1 0x20 2433 93 SWAP4 2434 90 SWAP1 2435 93 SWAP4 2436 01 ADD 2437 35 CALLDATALOAD 2438 93 SWAP4 2439 50 POP 243A 50 POP 243B 50 POP 243C 56 *JUMP // Stack delta = -4 // Outputs[2] // { // @2430 stack[-6] = stack[-1] // @2438 stack[-5] = msg.data[0x20 + stack[-4]:0x20 + stack[-4] + 0x20] // } // Block ends with unconditional jump to stack[-6] label_243D: // Incoming call from 0x020D, returns to 0x020E // Inputs[2] // { // @2442 stack[-1] // @2443 stack[-2] // } 243D 5B JUMPDEST 243E 60 PUSH1 0x00 2440 60 PUSH1 0x20 2442 82 DUP3 2443 84 DUP5 2444 03 SUB 2445 12 SLT 2446 15 ISZERO 2447 61 PUSH2 0x244e 244A 57 *JUMPI // Stack delta = +1 // Outputs[1] { @243E stack[0] = 0x00 } // Block ends with conditional jump to 0x244e, if !(stack[-2] - stack[-1] i< 0x20) label_244B: // Incoming jump from 0x244A, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @244B stack[-1] // @244D memory[stack[-1]:stack[-1] + stack[-1]] // } 244B 80 DUP1 244C 81 DUP2 244D FD *REVERT // Stack delta = +0 // Outputs[1] { @244D revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_244E: // Incoming jump from 0x244A, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @244F stack[-2] // @2450 msg.data[stack[-2]:stack[-2] + 0x20] // } 244E 5B JUMPDEST 244F 81 DUP2 2450 35 CALLDATALOAD 2451 61 PUSH2 0x155f 2454 81 DUP2 2455 61 PUSH2 0x28a2 2458 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2450 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] // @2451 stack[1] = 0x155f // @2454 stack[2] = msg.data[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x28a2, returns to 0x155F label_2459: // Incoming jump from 0x1EED // Inputs[2] // { // @245E stack[-1] // @245F stack[-2] // } 2459 5B JUMPDEST 245A 60 PUSH1 0x00 245C 60 PUSH1 0x20 245E 82 DUP3 245F 84 DUP5 2460 03 SUB 2461 12 SLT 2462 15 ISZERO 2463 61 PUSH2 0x246a 2466 57 *JUMPI // Stack delta = +1 // Outputs[1] { @245A stack[0] = 0x00 } // Block ends with conditional jump to 0x246a, if !(stack[-2] - stack[-1] i< 0x20) label_2467: // Incoming jump from 0x2466, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2467 stack[-1] // @2469 memory[stack[-1]:stack[-1] + stack[-1]] // } 2467 80 DUP1 2468 81 DUP2 2469 FD *REVERT // Stack delta = +0 // Outputs[1] { @2469 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_246A: // Incoming jump from 0x2466, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @246B stack[-2] // @246C memory[stack[-2]:stack[-2] + 0x20] // } 246A 5B JUMPDEST 246B 81 DUP2 246C 51 MLOAD 246D 61 PUSH2 0x155f 2470 81 DUP2 2471 61 PUSH2 0x28a2 2474 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @246C stack[0] = memory[stack[-2]:stack[-2] + 0x20] // @246D stack[1] = 0x155f // @2470 stack[2] = memory[stack[-2]:stack[-2] + 0x20] // } // Block ends with call to 0x28a2, returns to 0x155F label_2475: // Incoming call from 0x04EE, returns to 0x04EF // Inputs[2] // { // @247A stack[-1] // @247B stack[-2] // } 2475 5B JUMPDEST 2476 60 PUSH1 0x00 2478 60 PUSH1 0x20 247A 82 DUP3 247B 84 DUP5 247C 03 SUB 247D 12 SLT 247E 15 ISZERO 247F 61 PUSH2 0x2486 2482 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2476 stack[0] = 0x00 } // Block ends with conditional jump to 0x2486, if !(stack[-2] - stack[-1] i< 0x20) label_2483: // Incoming jump from 0x2482, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2483 stack[-1] // @2485 memory[stack[-1]:stack[-1] + stack[-1]] // } 2483 80 DUP1 2484 81 DUP2 2485 FD *REVERT // Stack delta = +0 // Outputs[1] { @2485 revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_2486: // Incoming jump from 0x2482, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @2487 stack[-2] // @2488 msg.data[stack[-2]:stack[-2] + 0x20] // } 2486 5B JUMPDEST 2487 81 DUP2 2488 35 CALLDATALOAD 2489 67 PUSH8 0xffffffffffffffff 2492 81 DUP2 2493 11 GT 2494 15 ISZERO 2495 61 PUSH2 0x249c 2498 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2488 stack[0] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with conditional jump to 0x249c, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) label_2499: // Incoming jump from 0x2498, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[2] // { // @2499 stack[-2] // @249B memory[stack[-2]:stack[-2] + stack[-2]] // } 2499 81 DUP2 249A 82 DUP3 249B FD *REVERT // Stack delta = +0 // Outputs[1] { @249B revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_249C: // Incoming jump from 0x2498, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0xffffffffffffffff) // Inputs[3] // { // @249D stack[-3] // @249E stack[-1] // @24A3 stack[-4] // } 249C 5B JUMPDEST 249D 82 DUP3 249E 01 ADD 249F 60 PUSH1 0x1f 24A1 81 DUP2 24A2 01 ADD 24A3 84 DUP5 24A4 13 SGT 24A5 61 PUSH2 0x24ac 24A8 57 *JUMPI // Stack delta = +0 // Outputs[1] { @249E stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x24ac, if stack[-4] i> stack[-3] + stack[-1] + 0x1f label_24A9: // Incoming jump from 0x24A8, if not stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[2] // { // @24A9 stack[-2] // @24AB memory[stack[-2]:stack[-2] + stack[-2]] // } 24A9 81 DUP2 24AA 82 DUP3 24AB FD *REVERT // Stack delta = +0 // Outputs[1] { @24AB revert(memory[stack[-2]:stack[-2] + stack[-2]]); } // Block terminates label_24AC: // Incoming jump from 0x24A8, if stack[-4] i> stack[-3] + stack[-1] + 0x1f // Inputs[3] // { // @24B0 stack[-4] // @24B1 stack[-1] // @24B2 msg.data[stack[-1]:stack[-1] + 0x20] // } 24AC 5B JUMPDEST 24AD 61 PUSH2 0x1655 24B0 84 DUP5 24B1 82 DUP3 24B2 35 CALLDATALOAD 24B3 60 PUSH1 0x20 24B5 84 DUP5 24B6 01 ADD 24B7 61 PUSH2 0x21c3 24BA 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @24AD stack[0] = 0x1655 // @24B0 stack[1] = stack[-4] // @24B2 stack[2] = msg.data[stack[-1]:stack[-1] + 0x20] // @24B6 stack[3] = stack[-1] + 0x20 // } // Block ends with call to 0x21c3, returns to 0x1655 label_24BB: // Incoming call from 0x054E, returns to 0x054F // Incoming call from 0x0264, returns to 0x0265 // Incoming call from 0x0410, returns to 0x0411 // Incoming call from 0x05A1, returns to 0x05A2 // Incoming call from 0x03F0, returns to 0x03F1 // Inputs[2] // { // @24C0 stack[-1] // @24C1 stack[-2] // } 24BB 5B JUMPDEST 24BC 60 PUSH1 0x00 24BE 60 PUSH1 0x20 24C0 82 DUP3 24C1 84 DUP5 24C2 03 SUB 24C3 12 SLT 24C4 15 ISZERO 24C5 61 PUSH2 0x24cc 24C8 57 *JUMPI // Stack delta = +1 // Outputs[1] { @24BC stack[0] = 0x00 } // Block ends with conditional jump to 0x24cc, if !(stack[-2] - stack[-1] i< 0x20) label_24C9: // Incoming jump from 0x24C8, if not !(stack[-2] - stack[-1] i< 0x20) // Inputs[2] // { // @24C9 stack[-1] // @24CB memory[stack[-1]:stack[-1] + stack[-1]] // } 24C9 80 DUP1 24CA 81 DUP2 24CB FD *REVERT // Stack delta = +0 // Outputs[1] { @24CB revert(memory[stack[-1]:stack[-1] + stack[-1]]); } // Block terminates label_24CC: // Incoming jump from 0x24C8, if !(stack[-2] - stack[-1] i< 0x20) // Inputs[4] // { // @24CE stack[-2] // @24CE msg.data[stack[-2]:stack[-2] + 0x20] // @24CF stack[-4] // @24D0 stack[-3] // } 24CC 5B JUMPDEST 24CD 50 POP 24CE 35 CALLDATALOAD 24CF 91 SWAP2 24D0 90 SWAP1 24D1 50 POP 24D2 56 *JUMP // Stack delta = -3 // Outputs[1] { @24CF stack[-4] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to stack[-4] label_24D3: // Incoming call from 0x2672, returns to 0x2673 // Incoming call from 0x268F, returns to 0x155F // Inputs[3] // { // @24D6 stack[-1] // @24D7 memory[stack[-1]:stack[-1] + 0x20] // @24D9 stack[-2] // } 24D3 5B JUMPDEST 24D4 60 PUSH1 0x00 24D6 81 DUP2 24D7 51 MLOAD 24D8 80 DUP1 24D9 84 DUP5 24DA 52 MSTORE 24DB 61 PUSH2 0x24eb 24DE 81 DUP2 24DF 60 PUSH1 0x20 24E1 86 DUP7 24E2 01 ADD 24E3 60 PUSH1 0x20 24E5 86 DUP7 24E6 01 ADD 24E7 61 PUSH2 0x27ca 24EA 56 *JUMP // Stack delta = +6 // Outputs[7] // { // @24D4 stack[0] = 0x00 // @24D7 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @24DA memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @24DB stack[2] = 0x24eb // @24DE stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @24E2 stack[4] = stack[-2] + 0x20 // @24E6 stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x27ca, returns to 0x24EB label_24EB: // Incoming return from call to 0x27CA at 0x24EA // Inputs[4] // { // @24EE stack[-1] // @24F3 stack[-4] // @24F4 stack[-2] // @24FA stack[-5] // } 24EB 5B JUMPDEST 24EC 60 PUSH1 0x1f 24EE 01 ADD 24EF 60 PUSH1 0x1f 24F1 19 NOT 24F2 16 AND 24F3 92 SWAP3 24F4 90 SWAP1 24F5 92 SWAP3 24F6 01 ADD 24F7 60 PUSH1 0x20 24F9 01 ADD 24FA 92 SWAP3 24FB 91 SWAP2 24FC 50 POP 24FD 50 POP 24FE 56 *JUMP // Stack delta = -4 // Outputs[1] { @24FA stack[-5] = 0x20 + (~0x1f & 0x1f + stack[-1]) + stack[-4] } // Block ends with unconditional jump to stack[-5] label_24FF: // Incoming call from 0x260A, returns to 0x260B // Inputs[3] // { // @2502 stack[-1] // @2503 memory[stack[-1]:stack[-1] + 0x20] // @2508 stack[-2] // } 24FF 5B JUMPDEST 2500 60 PUSH1 0x00 2502 81 DUP2 2503 51 MLOAD 2504 61 PUSH2 0x2511 2507 81 DUP2 2508 85 DUP6 2509 60 PUSH1 0x20 250B 86 DUP7 250C 01 ADD 250D 61 PUSH2 0x27ca 2510 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @2500 stack[0] = 0x00 // @2503 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // @2504 stack[2] = 0x2511 // @2507 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // @2508 stack[4] = stack[-2] // @250C stack[5] = stack[-1] + 0x20 // } // Block ends with call to 0x27ca, returns to 0x2511 label_2511: // Incoming return from call to 0x27CA at 0x2510 // Inputs[4] // { // @2512 stack[-1] // @2512 stack[-4] // @2513 stack[-2] // @2516 stack[-5] // } 2511 5B JUMPDEST 2512 92 SWAP3 2513 90 SWAP1 2514 92 SWAP3 2515 01 ADD 2516 92 SWAP3 2517 91 SWAP2 2518 50 POP 2519 50 POP 251A 56 *JUMP // Stack delta = -4 // Outputs[1] { @2516 stack[-5] = stack[-1] + stack[-4] } // Block ends with unconditional jump to stack[-5] 251B 5B JUMPDEST 251C 60 PUSH1 0x00 251E 82 DUP3 251F 51 MLOAD 2520 61 PUSH2 0x252d 2523 81 DUP2 2524 84 DUP5 2525 60 PUSH1 0x20 2527 87 DUP8 2528 01 ADD 2529 61 PUSH2 0x27ca 252C 56 *JUMP 252D 5B JUMPDEST 252E 91 SWAP2 252F 90 SWAP1 2530 91 SWAP2 2531 01 ADD 2532 92 SWAP3 2533 91 SWAP2 2534 50 POP 2535 50 POP 2536 56 *JUMP 2537 5B JUMPDEST 2538 60 PUSH1 0x00 253A 83 DUP4 253B 51 MLOAD 253C 61 PUSH2 0x2549 253F 81 DUP2 2540 84 DUP5 2541 60 PUSH1 0x20 2543 88 DUP9 2544 01 ADD 2545 61 PUSH2 0x27ca 2548 56 *JUMP 2549 5B JUMPDEST 254A 60 PUSH1 0x60 254C 93 SWAP4 254D 90 SWAP1 254E 93 SWAP4 254F 1B SHL 2550 6B PUSH12 0xffffffffffffffffffffffff 255D 19 NOT 255E 16 AND 255F 91 SWAP2 2560 90 SWAP1 2561 92 SWAP3 2562 01 ADD 2563 90 SWAP1 2564 81 DUP2 2565 52 MSTORE 2566 60 PUSH1 0x14 2568 01 ADD 2569 92 SWAP3 256A 91 SWAP2 256B 50 POP 256C 50 POP 256D 56 *JUMP label_256E: // Incoming call from 0x100F, returns to 0x1010 // Inputs[2] // { // @2572 stack[-3] // @2573 storage[stack[-3]] // } 256E 5B JUMPDEST 256F 60 PUSH1 0x00 2571 80 DUP1 2572 84 DUP5 2573 54 SLOAD 2574 82 DUP3 2575 60 PUSH1 0x01 2577 82 DUP3 2578 81 DUP2 2579 1C SHR 257A 91 SWAP2 257B 50 POP 257C 80 DUP1 257D 83 DUP4 257E 16 AND 257F 80 DUP1 2580 61 PUSH2 0x258a 2583 57 *JUMPI // Stack delta = +6 // Outputs[6] // { // @256F stack[0] = 0x00 // @2571 stack[1] = 0x00 // @2573 stack[2] = storage[stack[-3]] // @2575 stack[4] = 0x01 // @257A stack[3] = storage[stack[-3]] >> 0x01 // @257E stack[5] = storage[stack[-3]] & 0x01 // } // Block ends with conditional jump to 0x258a, if storage[stack[-3]] & 0x01 label_2584: // Incoming jump from 0x2583, if not storage[stack[-3]] & 0x01 // Inputs[2] // { // @2586 stack[-3] // @2590 stack[-1] // } 2584 60 PUSH1 0x7f 2586 83 DUP4 2587 16 AND 2588 92 SWAP3 2589 50 POP 258A 5B JUMPDEST 258B 60 PUSH1 0x20 258D 80 DUP1 258E 84 DUP5 258F 10 LT 2590 82 DUP3 2591 14 EQ 2592 15 ISZERO 2593 61 PUSH2 0x25aa 2596 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @2588 stack[-3] = stack[-3] & 0x7f // @258B stack[0] = 0x20 // } // Block ends with conditional jump to 0x25aa, if !(stack[-1] == (stack[-3] & 0x7f < 0x20)) label_2597: // Incoming jump from 0x2596, if not !(stack[-1] == (stack[-3] & 0x7f < 0x20)) // Incoming jump from 0x2596, if not !(stack[-1] == (stack[-3] < 0x20)) // Inputs[2] // { // @259F stack[-7] // @25A9 memory[stack[-7]:stack[-7] + 0x24] // } 2597 63 PUSH4 0x4e487b71 259C 60 PUSH1 0xe0 259E 1B SHL 259F 87 DUP8 25A0 52 MSTORE 25A1 60 PUSH1 0x22 25A3 60 PUSH1 0x04 25A5 52 MSTORE 25A6 60 PUSH1 0x24 25A8 87 DUP8 25A9 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @25A0 memory[stack[-7]:stack[-7] + 0x20] = 0x4e487b71 << 0xe0 // @25A5 memory[0x04:0x24] = 0x22 // @25A9 revert(memory[stack[-7]:stack[-7] + 0x24]); // } // Block terminates label_25AA: // Incoming jump from 0x2596, if !(stack[-1] == (stack[-3] & 0x7f < 0x20)) // Incoming jump from 0x2596, if !(stack[-1] == (stack[-3] < 0x20)) // Inputs[1] { @25AB stack[-2] } 25AA 5B JUMPDEST 25AB 81 DUP2 25AC 80 DUP1 25AD 15 ISZERO 25AE 61 PUSH2 0x25be 25B1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @25AB stack[0] = stack[-2] } // Block ends with conditional jump to 0x25be, if !stack[-2] label_25B2: // Incoming jump from 0x25B1, if not !stack[-2] // Inputs[1] { @25B4 stack[-1] } 25B2 60 PUSH1 0x01 25B4 81 DUP2 25B5 14 EQ 25B6 61 PUSH2 0x25cf 25B9 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x25cf, if stack[-1] == 0x01 label_25BA: // Incoming jump from 0x25B9, if not stack[-1] == 0x01 25BA 61 PUSH2 0x25fb 25BD 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x25fb label_25BE: // Incoming jump from 0x25B1, if !stack[-2] // Inputs[4] // { // @25C2 stack[-6] // @25C4 stack[-9] // @25C6 stack[-5] // @25C9 stack[-7] // } 25BE 5B JUMPDEST 25BF 60 PUSH1 0xff 25C1 19 NOT 25C2 86 DUP7 25C3 16 AND 25C4 89 DUP10 25C5 52 MSTORE 25C6 84 DUP5 25C7 89 DUP10 25C8 01 ADD 25C9 96 SWAP7 25CA 50 POP 25CB 61 PUSH2 0x25fb 25CE 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @25C5 memory[stack[-9]:stack[-9] + 0x20] = stack[-6] & ~0xff // @25C9 stack[-7] = stack[-9] + stack[-5] // } // Block ends with unconditional jump to 0x25fb label_25CF: // Incoming jump from 0x25B9, if stack[-1] == 0x01 // Inputs[4] // { // @25D2 stack[-11] // @25D8 memory[0x00:0x20] // @25D9 stack[-8] // @25DB stack[-5] // } 25CF 5B JUMPDEST 25D0 60 PUSH1 0x00 25D2 8B DUP12 25D3 81 DUP2 25D4 52 MSTORE 25D5 60 PUSH1 0x20 25D7 90 SWAP1 25D8 20 SHA3 25D9 88 DUP9 25DA 5B JUMPDEST 25DB 86 DUP7 25DC 81 DUP2 25DD 10 LT 25DE 15 ISZERO 25DF 61 PUSH2 0x25f3 25E2 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @25D4 memory[0x00:0x20] = stack[-11] // @25D8 stack[0] = keccak256(memory[0x00:0x20]) // @25D9 stack[1] = stack[-8] // } // Block ends with conditional jump to 0x25f3, if !(stack[-8] < stack[-5]) label_25E3: // Incoming jump from 0x25E2, if not !(stack[-8] < stack[-5]) // Incoming jump from 0x25E2, if not !(stack[-1] < stack[-7]) // Inputs[6] // { // @25E3 stack[-2] // @25E4 storage[stack[-2]] // @25E5 stack[-11] // @25E6 stack[-1] // @25EA stack[-6] // @25ED stack[-4] // } 25E3 81 DUP2 25E4 54 SLOAD 25E5 8B DUP12 25E6 82 DUP3 25E7 01 ADD 25E8 52 MSTORE 25E9 90 SWAP1 25EA 85 DUP6 25EB 01 ADD 25EC 90 SWAP1 25ED 83 DUP4 25EE 01 ADD 25EF 61 PUSH2 0x25da 25F2 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @25E8 memory[stack[-1] + stack[-11]:stack[-1] + stack[-11] + 0x20] = storage[stack[-2]] // @25EC stack[-2] = stack[-6] + stack[-2] // @25EE stack[-1] = stack[-4] + stack[-1] // } // Block ends with unconditional jump to 0x25da label_25F3: // Incoming jump from 0x25E2, if !(stack[-8] < stack[-5]) // Incoming jump from 0x25E2, if !(stack[-1] < stack[-7]) // Inputs[3] // { // @25F6 stack[-7] // @25F7 stack[-11] // @25F9 stack[-9] // } 25F3 5B JUMPDEST 25F4 50 POP 25F5 50 POP 25F6 84 DUP5 25F7 89 DUP10 25F8 01 ADD 25F9 96 SWAP7 25FA 50 POP // Stack delta = -2 // Outputs[1] { @25F9 stack[-9] = stack[-11] + stack[-7] } // Block continues label_25FB: // Incoming jump from 0x25BD // Incoming jump from 0x25CE // Incoming jump from 0x25FA // Inputs[2] // { // @2605 stack[-7] // @2606 stack[-10] // } 25FB 5B JUMPDEST 25FC 50 POP 25FD 50 POP 25FE 50 POP 25FF 50 POP 2600 50 POP 2601 50 POP 2602 61 PUSH2 0x260b 2605 81 DUP2 2606 85 DUP6 2607 61 PUSH2 0x24ff 260A 56 *JUMP // Stack delta = -3 // Outputs[3] // { // @2602 stack[-6] = 0x260b // @2605 stack[-5] = stack[-7] // @2606 stack[-4] = stack[-10] // } // Block ends with call to 0x24ff, returns to 0x260B label_260B: // Incoming return from call to 0x24FF at 0x260A // Inputs[3] // { // @260C stack[-7] // @260C stack[-1] // @260D stack[-6] // } 260B 5B JUMPDEST 260C 95 SWAP6 260D 94 SWAP5 260E 50 POP 260F 50 POP 2610 50 POP 2611 50 POP 2612 50 POP 2613 56 *JUMP // Stack delta = -6 // Outputs[1] { @260C stack[-7] = stack[-1] } // Block ends with unconditional jump to stack[-7] 2614 5B JUMPDEST 2615 60 PUSH1 0x01 2617 60 PUSH1 0x01 2619 60 PUSH1 0xa0 261B 1B SHL 261C 03 SUB 261D 84 DUP5 261E 81 DUP2 261F 16 AND 2620 82 DUP3 2621 52 MSTORE 2622 83 DUP4 2623 16 AND 2624 60 PUSH1 0x20 2626 82 DUP3 2627 01 ADD 2628 52 MSTORE 2629 60 PUSH1 0x60 262B 60 PUSH1 0x40 262D 82 DUP3 262E 01 ADD 262F 81 DUP2 2630 90 SWAP1 2631 52 MSTORE 2632 60 PUSH1 0x00 2634 90 SWAP1 2635 61 PUSH2 0x260b 2638 90 SWAP1 2639 83 DUP4 263A 01 ADD 263B 84 DUP5 263C 61 PUSH2 0x24d3 263F 56 *JUMP label_2640: // Incoming call from 0x1EA6, returns to 0x1EA7 // Inputs[5] // { // @2649 stack[-5] // @264C stack[-1] // @264E stack[-4] // @2659 stack[-3] // @266E stack[-2] // } 2640 5B JUMPDEST 2641 60 PUSH1 0x01 2643 60 PUSH1 0x01 2645 60 PUSH1 0xa0 2647 1B SHL 2648 03 SUB 2649 85 DUP6 264A 81 DUP2 264B 16 AND 264C 82 DUP3 264D 52 MSTORE 264E 84 DUP5 264F 16 AND 2650 60 PUSH1 0x20 2652 82 DUP3 2653 01 ADD 2654 52 MSTORE 2655 60 PUSH1 0x40 2657 81 DUP2 2658 01 ADD 2659 83 DUP4 265A 90 SWAP1 265B 52 MSTORE 265C 60 PUSH1 0x80 265E 60 PUSH1 0x60 2660 82 DUP3 2661 01 ADD 2662 81 DUP2 2663 90 SWAP1 2664 52 MSTORE 2665 60 PUSH1 0x00 2667 90 SWAP1 2668 61 PUSH2 0x2673 266B 90 SWAP1 266C 83 DUP4 266D 01 ADD 266E 84 DUP5 266F 61 PUSH2 0x24d3 2672 56 *JUMP // Stack delta = +4 // Outputs[8] // { // @264D memory[stack[-1]:stack[-1] + 0x20] = (0x01 << 0xa0) - 0x01 & stack[-5] // @2654 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = stack[-4] & (0x01 << 0xa0) - 0x01 // @265B memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = stack[-3] // @2664 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x80 // @2667 stack[0] = 0x00 // @266B stack[1] = 0x2673 // @266D stack[2] = stack[-1] + 0x80 // @266E stack[3] = stack[-2] // } // Block ends with call to 0x24d3, returns to 0x2673 label_2673: // Incoming return from call to 0x24D3 at 0x2672 // Inputs[3] // { // @2674 stack[-1] // @2674 stack[-8] // @2675 stack[-7] // } 2673 5B JUMPDEST 2674 96 SWAP7 2675 95 SWAP6 2676 50 POP 2677 50 POP 2678 50 POP 2679 50 POP 267A 50 POP 267B 50 POP 267C 56 *JUMP // Stack delta = -7 // Outputs[1] { @2674 stack[-8] = stack[-1] } // Block ends with unconditional jump to stack[-8] label_267D: // Incoming jump from 0x0249 // Inputs[2] // { // @2680 stack[-1] // @268B stack[-2] // } 267D 5B JUMPDEST 267E 60 PUSH1 0x20 2680 81 DUP2 2681 52 MSTORE 2682 60 PUSH1 0x00 2684 61 PUSH2 0x155f 2687 60 PUSH1 0x20 2689 83 DUP4 268A 01 ADD 268B 84 DUP5 268C 61 PUSH2 0x24d3 268F 56 *JUMP // Stack delta = +4 // Outputs[5] // { // @2681 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2682 stack[0] = 0x00 // @2684 stack[1] = 0x155f // @268A stack[2] = stack[-1] + 0x20 // @268B stack[3] = stack[-2] // } // Block ends with call to 0x24d3, returns to 0x155F label_2690: // Incoming call from 0x1BDC, returns to 0x0742 // Incoming call from 0x1F42, returns to 0x0742 // Inputs[2] // { // @2694 stack[-1] // @26E0 stack[-2] // } 2690 5B JUMPDEST 2691 60 PUSH1 0x20 2693 80 DUP1 2694 82 DUP3 2695 52 MSTORE 2696 60 PUSH1 0x32 2698 90 SWAP1 2699 82 DUP3 269A 01 ADD 269B 52 MSTORE 269C 7F PUSH32 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 26BD 60 PUSH1 0x40 26BF 82 DUP3 26C0 01 ADD 26C1 52 MSTORE 26C2 71 PUSH18 0x31b2b4bb32b91034b6b83632b6b2b73a32b9 26D5 60 PUSH1 0x71 26D7 1B SHL 26D8 60 PUSH1 0x60 26DA 82 DUP3 26DB 01 ADD 26DC 52 MSTORE 26DD 60 PUSH1 0x80 26DF 01 ADD 26E0 90 SWAP1 26E1 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @2695 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @269B memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x32 // @26C1 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732313a207472616e7366657220746f206e6f6e204552433732315265 // @26DC memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x31b2b4bb32b91034b6b83632b6b2b73a32b9 << 0x71 // @26E0 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_26E2: // Incoming call from 0x12CA, returns to 0x0742 // Incoming call from 0x0E23, returns to 0x0742 // Incoming call from 0x0B8F, returns to 0x0742 // Incoming call from 0x0E9D, returns to 0x0742 // Incoming call from 0x106E, returns to 0x0742 // Incoming call from 0x0DCE, returns to 0x0742 // Inputs[2] // { // @26E6 stack[-1] // @2715 stack[-2] // } 26E2 5B JUMPDEST 26E3 60 PUSH1 0x20 26E5 80 DUP1 26E6 82 DUP3 26E7 52 MSTORE 26E8 81 DUP2 26E9 81 DUP2 26EA 01 ADD 26EB 52 MSTORE 26EC 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 270D 60 PUSH1 0x40 270F 82 DUP3 2710 01 ADD 2711 52 MSTORE 2712 60 PUSH1 0x60 2714 01 ADD 2715 90 SWAP1 2716 56 *JUMP // Stack delta = -1 // Outputs[4] // { // @26E7 memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @26EB memory[0x20 + stack[-1]:0x20 + stack[-1] + 0x20] = 0x20 // @2711 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @2715 stack[-2] = 0x60 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2717: // Incoming call from 0x0AA5, returns to 0x0742 // Incoming call from 0x0FDF, returns to 0x0742 // Inputs[2] // { // @271B stack[-1] // @2766 stack[-2] // } 2717 5B JUMPDEST 2718 60 PUSH1 0x20 271A 80 DUP1 271B 82 DUP3 271C 52 MSTORE 271D 60 PUSH1 0x31 271F 90 SWAP1 2720 82 DUP3 2721 01 ADD 2722 52 MSTORE 2723 7F PUSH32 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f 2744 60 PUSH1 0x40 2746 82 DUP3 2747 01 ADD 2748 52 MSTORE 2749 70 PUSH17 0x1ddb995c881b9bdc88185c1c1c9bdd9959 275B 60 PUSH1 0x7a 275D 1B SHL 275E 60 PUSH1 0x60 2760 82 DUP3 2761 01 ADD 2762 52 MSTORE 2763 60 PUSH1 0x80 2765 01 ADD 2766 90 SWAP1 2767 56 *JUMP // Stack delta = -1 // Outputs[5] // { // @271C memory[stack[-1]:stack[-1] + 0x20] = 0x20 // @2722 memory[stack[-1] + 0x20:stack[-1] + 0x20 + 0x20] = 0x31 // @2748 memory[stack[-1] + 0x40:stack[-1] + 0x40 + 0x20] = 0x4552433732313a207472616e736665722063616c6c6572206973206e6f74206f // @2762 memory[stack[-1] + 0x60:stack[-1] + 0x60 + 0x20] = 0x1ddb995c881b9bdc88185c1c1c9bdd9959 << 0x7a // @2766 stack[-2] = 0x80 + stack[-1] // } // Block ends with unconditional jump to stack[-2] label_2768: // Incoming call from 0x1CAA, returns to 0x1CAB // Incoming call from 0x155E, returns to 0x155F // Incoming call from 0x17A6, returns to 0x17A7 // Incoming call from 0x1135, returns to 0x1136 // Inputs[2] // { // @276B stack[-2] // @276D stack[-1] // } 2768 5B JUMPDEST 2769 60 PUSH1 0x00 276B 82 DUP3 276C 19 NOT 276D 82 DUP3 276E 11 GT 276F 15 ISZERO 2770 61 PUSH2 0x277b 2773 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2769 stack[0] = 0x00 } // Block ends with conditional jump to 0x277b, if !(stack[-1] > ~stack[-2]) label_2774: // Incoming jump from 0x2773, if not !(stack[-1] > ~stack[-2]) 2774 61 PUSH2 0x277b 2777 61 PUSH2 0x2860 277A 56 *JUMP // Stack delta = +1 // Outputs[1] { @2774 stack[0] = 0x277b } // Block ends with unconditional jump to 0x2860 label_277B: // Incoming jump from 0x2773, if !(stack[-1] > ~stack[-2]) // Inputs[3] // { // @277D stack[-3] // @277D stack[-2] // @277E stack[-4] // } 277B 5B JUMPDEST 277C 50 POP 277D 01 ADD 277E 90 SWAP1 277F 56 *JUMP // Stack delta = -3 // Outputs[1] { @277E stack[-4] = stack[-2] + stack[-3] } // Block ends with unconditional jump to stack[-4] label_2780: // Incoming call from 0x1C23, returns to 0x1C24 // Incoming call from 0x1CEF, returns to 0x1CF0 // Inputs[1] { @2783 stack[-2] } 2780 5B JUMPDEST 2781 60 PUSH1 0x00 2783 82 DUP3 2784 61 PUSH2 0x278f 2787 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2781 stack[0] = 0x00 } // Block ends with conditional jump to 0x278f, if stack[-2] label_2788: // Incoming jump from 0x2787, if not stack[-2] 2788 61 PUSH2 0x278f 278B 61 PUSH2 0x2876 278E 56 *JUMP // Stack delta = +1 // Outputs[1] { @2788 stack[0] = 0x278f } // Block ends with unconditional jump to 0x2876 label_278F: // Incoming jump from 0x2787, if stack[-2] // Inputs[3] // { // @2791 stack[-2] // @2791 stack[-3] // @2792 stack[-4] // } 278F 5B JUMPDEST 2790 50 POP 2791 04 DIV 2792 90 SWAP1 2793 56 *JUMP // Stack delta = -3 // Outputs[1] { @2792 stack[-4] = stack[-2] / stack[-3] } // Block ends with unconditional jump to stack[-4] label_2794: // Incoming call from 0x123A, returns to 0x123B // Inputs[2] // { // @2797 stack[-1] // @279C stack[-2] // } 2794 5B JUMPDEST 2795 60 PUSH1 0x00 2797 81 DUP2 2798 60 PUSH1 0x00 279A 19 NOT 279B 04 DIV 279C 83 DUP4 279D 11 GT 279E 82 DUP3 279F 15 ISZERO 27A0 15 ISZERO 27A1 16 AND 27A2 15 ISZERO 27A3 61 PUSH2 0x27ae 27A6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2795 stack[0] = 0x00 } // Block ends with conditional jump to 0x27ae, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) label_27A7: // Incoming jump from 0x27A6, if not !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) 27A7 61 PUSH2 0x27ae 27AA 61 PUSH2 0x2860 27AD 56 *JUMP // Stack delta = +1 // Outputs[1] { @27A7 stack[0] = 0x27ae } // Block ends with unconditional jump to 0x2860 label_27AE: // Incoming jump from 0x27A6, if !(!!stack[-1] & (stack[-2] > ~0x00 / stack[-1])) // Inputs[3] // { // @27B0 stack[-2] // @27B0 stack[-3] // @27B1 stack[-4] // } 27AE 5B JUMPDEST 27AF 50 POP 27B0 02 MUL 27B1 90 SWAP1 27B2 56 *JUMP // Stack delta = -3 // Outputs[1] { @27B1 stack[-4] = stack[-2] * stack[-3] } // Block ends with unconditional jump to stack[-4] label_27B3: // Incoming call from 0x201E, returns to 0x201F // Incoming call from 0x1778, returns to 0x1779 // Incoming call from 0x1F86, returns to 0x1F87 // Incoming call from 0x1C92, returns to 0x1C93 // Inputs[2] // { // @27B6 stack[-2] // @27B7 stack[-1] // } 27B3 5B JUMPDEST 27B4 60 PUSH1 0x00 27B6 82 DUP3 27B7 82 DUP3 27B8 10 LT 27B9 15 ISZERO 27BA 61 PUSH2 0x27c5 27BD 57 *JUMPI // Stack delta = +1 // Outputs[1] { @27B4 stack[0] = 0x00 } // Block ends with conditional jump to 0x27c5, if !(stack[-1] < stack[-2]) label_27BE: // Incoming jump from 0x27BD, if not !(stack[-1] < stack[-2]) 27BE 61 PUSH2 0x27c5 27C1 61 PUSH2 0x2860 27C4 56 *JUMP // Stack delta = +1 // Outputs[1] { @27BE stack[0] = 0x27c5 } // Block ends with unconditional jump to 0x2860 label_27C5: // Incoming jump from 0x27BD, if !(stack[-1] < stack[-2]) // Inputs[3] // { // @27C7 stack[-3] // @27C7 stack[-2] // @27C8 stack[-4] // } 27C5 5B JUMPDEST 27C6 50 POP 27C7 03 SUB 27C8 90 SWAP1 27C9 56 *JUMP // Stack delta = -3 // Outputs[1] { @27C8 stack[-4] = stack[-2] - stack[-3] } // Block ends with unconditional jump to stack[-4] label_27CA: // Incoming call from 0x2510, returns to 0x2511 // Incoming call from 0x24EA, returns to 0x24EB // Inputs[1] { @27CE stack[-3] } 27CA 5B JUMPDEST 27CB 60 PUSH1 0x00 27CD 5B JUMPDEST 27CE 83 DUP4 27CF 81 DUP2 27D0 10 LT 27D1 15 ISZERO 27D2 61 PUSH2 0x27e5 27D5 57 *JUMPI // Stack delta = +1 // Outputs[1] { @27CB stack[0] = 0x00 } // Block ends with conditional jump to 0x27e5, if !(0x00 < stack[-3]) label_27D6: // Incoming jump from 0x27D5, if not !(0x00 < stack[-3]) // Incoming jump from 0x27D5, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @27D6 stack[-2] // @27D7 stack[-1] // @27D9 memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @27DA stack[-3] // } 27D6 81 DUP2 27D7 81 DUP2 27D8 01 ADD 27D9 51 MLOAD 27DA 83 DUP4 27DB 82 DUP3 27DC 01 ADD 27DD 52 MSTORE 27DE 60 PUSH1 0x20 27E0 01 ADD 27E1 61 PUSH2 0x27cd 27E4 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @27DD memory[stack[-1] + stack[-3]:stack[-1] + stack[-3] + 0x20] = memory[stack[-1] + stack[-2]:stack[-1] + stack[-2] + 0x20] // @27E0 stack[-1] = 0x20 + stack[-1] // } // Block ends with unconditional jump to 0x27cd label_27E5: // Incoming jump from 0x27D5, if !(0x00 < stack[-3]) // Incoming jump from 0x27D5, if !(stack[-1] < stack[-4]) // Inputs[2] // { // @27E6 stack[-4] // @27E7 stack[-1] // } 27E5 5B JUMPDEST 27E6 83 DUP4 27E7 81 DUP2 27E8 11 GT 27E9 15 ISZERO 27EA 61 PUSH2 0x0fec 27ED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0fec, if !(stack[-1] > stack[-4]) label_27EE: // Incoming jump from 0x27ED, if not !(stack[-1] > stack[-4]) // Inputs[3] // { // @27F2 stack[-4] // @27F3 stack[-3] // @27F5 stack[-5] // } 27EE 50 POP 27EF 50 POP 27F0 60 PUSH1 0x00 27F2 91 SWAP2 27F3 01 ADD 27F4 52 MSTORE 27F5 56 *JUMP // Stack delta = -5 // Outputs[1] { @27F4 memory[stack[-4] + stack[-3]:stack[-4] + stack[-3] + 0x20] = 0x00 } // Block ends with unconditional jump to stack[-5] label_27F6: // Incoming call from 0x0675, returns to 0x0676 // Incoming call from 0x1174, returns to 0x1175 // Incoming call from 0x0E54, returns to 0x064A // Incoming call from 0x0649, returns to 0x064A // Incoming call from 0x1148, returns to 0x1149 // Incoming call from 0x2135, returns to 0x2136 // Inputs[1] { @27F9 stack[-1] } 27F6 5B JUMPDEST 27F7 60 PUSH1 0x01 27F9 81 DUP2 27FA 81 DUP2 27FB 1C SHR 27FC 90 SWAP1 27FD 82 DUP3 27FE 16 AND 27FF 80 DUP1 2800 61 PUSH2 0x280a 2803 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @27FC stack[0] = stack[-1] >> 0x01 // @27FE stack[1] = stack[-1] & 0x01 // } // Block ends with conditional jump to 0x280a, if stack[-1] & 0x01 label_2804: // Incoming jump from 0x2803, if not stack[-1] & 0x01 // Inputs[2] // { // @2806 stack[-2] // @280F stack[-1] // } 2804 60 PUSH1 0x7f 2806 82 DUP3 2807 16 AND 2808 91 SWAP2 2809 50 POP 280A 5B JUMPDEST 280B 60 PUSH1 0x20 280D 82 DUP3 280E 10 LT 280F 81 DUP2 2810 14 EQ 2811 15 ISZERO 2812 61 PUSH2 0x282b 2815 57 *JUMPI // Stack delta = +0 // Outputs[1] { @2808 stack[-2] = stack[-2] & 0x7f } // Block ends with conditional jump to 0x282b, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) label_2816: // Incoming jump from 0x2815, if not !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x2815, if not !(stack[-1] == (stack[-2] < 0x20)) // Inputs[1] { @282A memory[0x00:0x24] } 2816 63 PUSH4 0x4e487b71 281B 60 PUSH1 0xe0 281D 1B SHL 281E 60 PUSH1 0x00 2820 52 MSTORE 2821 60 PUSH1 0x22 2823 60 PUSH1 0x04 2825 52 MSTORE 2826 60 PUSH1 0x24 2828 60 PUSH1 0x00 282A FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2820 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2825 memory[0x04:0x24] = 0x22 // @282A revert(memory[0x00:0x24]); // } // Block terminates label_282B: // Incoming jump from 0x2815, if !(stack[-1] == (stack[-2] & 0x7f < 0x20)) // Incoming jump from 0x2815, if !(stack[-1] == (stack[-2] < 0x20)) // Inputs[3] // { // @282D stack[-4] // @282D stack[-2] // @282E stack[-3] // } 282B 5B JUMPDEST 282C 50 POP 282D 91 SWAP2 282E 90 SWAP1 282F 50 POP 2830 56 *JUMP // Stack delta = -3 // Outputs[1] { @282D stack[-4] = stack[-2] } // Block ends with unconditional jump to stack[-4] label_2831: // Incoming call from 0x1C14, returns to 0x1C15 // Inputs[1] { @2837 stack[-1] } 2831 5B JUMPDEST 2832 60 PUSH1 0x00 2834 60 PUSH1 0x00 2836 19 NOT 2837 82 DUP3 2838 14 EQ 2839 15 ISZERO 283A 61 PUSH2 0x2845 283D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2832 stack[0] = 0x00 } // Block ends with conditional jump to 0x2845, if !(stack[-1] == ~0x00) label_283E: // Incoming jump from 0x283D, if not !(stack[-1] == ~0x00) 283E 61 PUSH2 0x2845 2841 61 PUSH2 0x2860 2844 56 *JUMP // Stack delta = +1 // Outputs[1] { @283E stack[0] = 0x2845 } // Block ends with unconditional jump to 0x2860 label_2845: // Incoming jump from 0x283D, if !(stack[-1] == ~0x00) // Inputs[2] // { // @2849 stack[-2] // @284A stack[-3] // } 2845 5B JUMPDEST 2846 50 POP 2847 60 PUSH1 0x01 2849 01 ADD 284A 90 SWAP1 284B 56 *JUMP // Stack delta = -2 // Outputs[1] { @284A stack[-3] = 0x01 + stack[-2] } // Block ends with unconditional jump to stack[-3] label_284C: // Incoming call from 0x1C9F, returns to 0x1CA0 // Incoming call from 0x10B6, returns to 0x10B7 // Inputs[1] { @284F stack[-2] } 284C 5B JUMPDEST 284D 60 PUSH1 0x00 284F 82 DUP3 2850 61 PUSH2 0x285b 2853 57 *JUMPI // Stack delta = +1 // Outputs[1] { @284D stack[0] = 0x00 } // Block ends with conditional jump to 0x285b, if stack[-2] label_2854: // Incoming jump from 0x2853, if not stack[-2] 2854 61 PUSH2 0x285b 2857 61 PUSH2 0x2876 285A 56 *JUMP // Stack delta = +1 // Outputs[1] { @2854 stack[0] = 0x285b } // Block ends with unconditional jump to 0x2876 label_285B: // Incoming jump from 0x2853, if stack[-2] // Inputs[3] // { // @285D stack[-3] // @285D stack[-2] // @285E stack[-4] // } 285B 5B JUMPDEST 285C 50 POP 285D 06 MOD 285E 90 SWAP1 285F 56 *JUMP // Stack delta = -3 // Outputs[1] { @285E stack[-4] = stack[-2] % stack[-3] } // Block ends with unconditional jump to stack[-4] label_2860: // Incoming jump from 0x27AD // Incoming jump from 0x277A // Incoming jump from 0x27C4 // Incoming jump from 0x2844 // Inputs[1] { @2875 memory[0x00:0x24] } 2860 5B JUMPDEST 2861 63 PUSH4 0x4e487b71 2866 60 PUSH1 0xe0 2868 1B SHL 2869 60 PUSH1 0x00 286B 52 MSTORE 286C 60 PUSH1 0x11 286E 60 PUSH1 0x04 2870 52 MSTORE 2871 60 PUSH1 0x24 2873 60 PUSH1 0x00 2875 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @286B memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2870 memory[0x04:0x24] = 0x11 // @2875 revert(memory[0x00:0x24]); // } // Block terminates label_2876: // Incoming jump from 0x285A // Incoming jump from 0x278E // Inputs[1] { @288B memory[0x00:0x24] } 2876 5B JUMPDEST 2877 63 PUSH4 0x4e487b71 287C 60 PUSH1 0xe0 287E 1B SHL 287F 60 PUSH1 0x00 2881 52 MSTORE 2882 60 PUSH1 0x12 2884 60 PUSH1 0x04 2886 52 MSTORE 2887 60 PUSH1 0x24 2889 60 PUSH1 0x00 288B FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2881 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @2886 memory[0x04:0x24] = 0x12 // @288B revert(memory[0x00:0x24]); // } // Block terminates label_288C: // Incoming jump from 0x2205 // Incoming jump from 0x21DD // Inputs[1] { @28A1 memory[0x00:0x24] } 288C 5B JUMPDEST 288D 63 PUSH4 0x4e487b71 2892 60 PUSH1 0xe0 2894 1B SHL 2895 60 PUSH1 0x00 2897 52 MSTORE 2898 60 PUSH1 0x41 289A 60 PUSH1 0x04 289C 52 MSTORE 289D 60 PUSH1 0x24 289F 60 PUSH1 0x00 28A1 FD *REVERT // Stack delta = +0 // Outputs[3] // { // @2897 memory[0x00:0x20] = 0x4e487b71 << 0xe0 // @289C memory[0x04:0x24] = 0x41 // @28A1 revert(memory[0x00:0x24]); // } // Block terminates label_28A2: // Incoming call from 0x2458, returns to 0x155F // Incoming call from 0x2474, returns to 0x155F // Inputs[1] { @28AC stack[-1] } 28A2 5B JUMPDEST 28A3 60 PUSH1 0x01 28A5 60 PUSH1 0x01 28A7 60 PUSH1 0xe0 28A9 1B SHL 28AA 03 SUB 28AB 19 NOT 28AC 81 DUP2 28AD 16 AND 28AE 81 DUP2 28AF 14 EQ 28B0 61 PUSH2 0x0bc9 28B3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bc9, if stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) label_28B4: // Incoming jump from 0x28B3, if not stack[-1] == stack[-1] & ~((0x01 << 0xe0) - 0x01) // Inputs[1] { @28B7 memory[0x00:0x00] } 28B4 60 PUSH1 0x00 28B6 80 DUP1 28B7 FD *REVERT // Stack delta = +0 // Outputs[1] { @28B7 revert(memory[0x00:0x00]); } // Block terminates 28B8 FE *ASSERT 28B9 4D 4D 28BA 65 PUSH6 0x74615472616e 28C1 73 PUSH20 0x616374696f6e2875696e74323536206e6f6e6365 28D6 2C 2C 28D7 61 PUSH2 0x6464 28DA 72 PUSH19 0x6573732066726f6d2c62797465732066756e63 28EE 74 PUSH21 0x696f6e5369676e617475726529a264697066735822 2904 12 SLT 2905 20 SHA3 2906 20 SHA3 2907 B5 B5 2908 E2 E2 2909 2C 2C 290A C0 C0 290B BC BC 290C 67 PUSH8 0xeffa7285031e7cb3 2915 A0 LOG0 2916 5A GAS 2917 5F PUSH0 2918 8B DUP12 2919 4E 4E 291A 47 SELFBALANCE 291B 4B 4B 291C 4B 4B 291D 18 XOR 291E 82 DUP3 291F 00 *STOP 2920 E7 E7 2921 C1 C1 2922 63 PUSH4 0xff328a64 2927 73 PUSH20 0x6f6c63430008040033