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 0x021a 000C 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0004 memory[0x40:0x60] = 0x80 } // Block ends with conditional jump to 0x021a, 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 0x6c0360eb 0019 11 GT 001A 61 PUSH2 0x0123 001D 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0012 stack[0] = msg.data[0x00:0x20] >> 0xe0 } // Block ends with conditional jump to 0x0123, if 0x6c0360eb > msg.data[0x00:0x20] >> 0xe0 label_001E: // Incoming jump from 0x001D, if not 0x6c0360eb > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @001E stack[-1] } 001E 80 DUP1 001F 63 PUSH4 0xb0f67427 0024 11 GT 0025 61 PUSH2 0x00ab 0028 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00ab, if 0xb0f67427 > stack[-1] label_0029: // Incoming jump from 0x0028, if not 0xb0f67427 > stack[-1] // Inputs[1] { @0029 stack[-1] } 0029 80 DUP1 002A 63 PUSH4 0xe36d6498 002F 11 GT 0030 61 PUSH2 0x006f 0033 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x006f, if 0xe36d6498 > stack[-1] label_0034: // Incoming jump from 0x0033, if not 0xe36d6498 > stack[-1] // Inputs[1] { @0034 stack[-1] } 0034 80 DUP1 0035 63 PUSH4 0xe36d6498 003A 14 EQ 003B 61 PUSH2 0x0ddf 003E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ddf, if 0xe36d6498 == stack[-1] label_003F: // Incoming jump from 0x003E, if not 0xe36d6498 == stack[-1] // Inputs[1] { @003F stack[-1] } 003F 80 DUP1 0040 63 PUSH4 0xe985e9c5 0045 14 EQ 0046 61 PUSH2 0x0e0a 0049 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e0a, if 0xe985e9c5 == stack[-1] label_004A: // Incoming jump from 0x0049, if not 0xe985e9c5 == stack[-1] // Inputs[1] { @004A stack[-1] } 004A 80 DUP1 004B 63 PUSH4 0xe9866550 0050 14 EQ 0051 61 PUSH2 0x0e91 0054 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0e91, if 0xe9866550 == stack[-1] label_0055: // Incoming jump from 0x0054, if not 0xe9866550 == stack[-1] // Inputs[1] { @0055 stack[-1] } 0055 80 DUP1 0056 63 PUSH4 0xeb8d2444 005B 14 EQ 005C 61 PUSH2 0x0ea8 005F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ea8, if 0xeb8d2444 == stack[-1] label_0060: // Incoming jump from 0x005F, if not 0xeb8d2444 == stack[-1] // Inputs[1] { @0060 stack[-1] } 0060 80 DUP1 0061 63 PUSH4 0xf2fde38b 0066 14 EQ 0067 61 PUSH2 0x0ed5 006A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0ed5, if 0xf2fde38b == stack[-1] label_006B: // Incoming jump from 0x006A, if not 0xf2fde38b == stack[-1] 006B 61 PUSH2 0x021a 006E 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x021a label_006F: // Incoming jump from 0x0033, if 0xe36d6498 > stack[-1] // Inputs[1] { @0070 stack[-1] } 006F 5B JUMPDEST 0070 80 DUP1 0071 63 PUSH4 0xb0f67427 0076 14 EQ 0077 61 PUSH2 0x0bac 007A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bac, if 0xb0f67427 == stack[-1] label_007B: // Incoming jump from 0x007A, if not 0xb0f67427 == stack[-1] // Inputs[1] { @007B stack[-1] } 007B 80 DUP1 007C 63 PUSH4 0xb88d4fde 0081 14 EQ 0082 61 PUSH2 0x0bc3 0085 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0bc3, 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 0xbb8a16bd 008C 14 EQ 008D 61 PUSH2 0x0cd5 0090 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0cd5, if 0xbb8a16bd == stack[-1] label_0091: // Incoming jump from 0x0090, if not 0xbb8a16bd == stack[-1] // Inputs[1] { @0091 stack[-1] } 0091 80 DUP1 0092 63 PUSH4 0xc87b56dd 0097 14 EQ 0098 61 PUSH2 0x0d00 009B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0d00, if 0xc87b56dd == stack[-1] label_009C: // Incoming jump from 0x009B, if not 0xc87b56dd == stack[-1] // Inputs[1] { @009C stack[-1] } 009C 80 DUP1 009D 63 PUSH4 0xcb774d47 00A2 14 EQ 00A3 61 PUSH2 0x0db4 00A6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0db4, if 0xcb774d47 == stack[-1] label_00A7: // Incoming jump from 0x00A6, if not 0xcb774d47 == stack[-1] 00A7 61 PUSH2 0x021a 00AA 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x021a label_00AB: // Incoming jump from 0x0028, if 0xb0f67427 > stack[-1] // Inputs[1] { @00AC stack[-1] } 00AB 5B JUMPDEST 00AC 80 DUP1 00AD 63 PUSH4 0x7d17fcbe 00B2 11 GT 00B3 61 PUSH2 0x00f2 00B6 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x00f2, if 0x7d17fcbe > stack[-1] label_00B7: // Incoming jump from 0x00B6, if not 0x7d17fcbe > stack[-1] // Inputs[1] { @00B7 stack[-1] } 00B7 80 DUP1 00B8 63 PUSH4 0x7d17fcbe 00BD 14 EQ 00BE 61 PUSH2 0x0a39 00C1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a39, if 0x7d17fcbe == stack[-1] label_00C2: // Incoming jump from 0x00C1, if not 0x7d17fcbe == stack[-1] // Inputs[1] { @00C2 stack[-1] } 00C2 80 DUP1 00C3 63 PUSH4 0x8da5cb5b 00C8 14 EQ 00C9 61 PUSH2 0x0a50 00CC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a50, if 0x8da5cb5b == stack[-1] label_00CD: // Incoming jump from 0x00CC, if not 0x8da5cb5b == stack[-1] // Inputs[1] { @00CD stack[-1] } 00CD 80 DUP1 00CE 63 PUSH4 0x95d89b41 00D3 14 EQ 00D4 61 PUSH2 0x0a91 00D7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a91, if 0x95d89b41 == stack[-1] label_00D8: // Incoming jump from 0x00D7, if not 0x95d89b41 == stack[-1] // Inputs[1] { @00D8 stack[-1] } 00D8 80 DUP1 00D9 63 PUSH4 0xa22cb465 00DE 14 EQ 00DF 61 PUSH2 0x0b21 00E2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b21, if 0xa22cb465 == stack[-1] label_00E3: // Incoming jump from 0x00E2, if not 0xa22cb465 == stack[-1] // Inputs[1] { @00E3 stack[-1] } 00E3 80 DUP1 00E4 63 PUSH4 0xa723533e 00E9 14 EQ 00EA 61 PUSH2 0x0b7e 00ED 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0b7e, if 0xa723533e == stack[-1] label_00EE: // Incoming jump from 0x00ED, if not 0xa723533e == stack[-1] 00EE 61 PUSH2 0x021a 00F1 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x021a label_00F2: // Incoming jump from 0x00B6, if 0x7d17fcbe > stack[-1] // Inputs[1] { @00F3 stack[-1] } 00F2 5B JUMPDEST 00F3 80 DUP1 00F4 63 PUSH4 0x6c0360eb 00F9 14 EQ 00FA 61 PUSH2 0x0902 00FD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0902, if 0x6c0360eb == stack[-1] label_00FE: // Incoming jump from 0x00FD, if not 0x6c0360eb == stack[-1] // Inputs[1] { @00FE stack[-1] } 00FE 80 DUP1 00FF 63 PUSH4 0x70a08231 0104 14 EQ 0105 61 PUSH2 0x0992 0108 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0992, if 0x70a08231 == stack[-1] label_0109: // Incoming jump from 0x0108, if not 0x70a08231 == stack[-1] // Inputs[1] { @0109 stack[-1] } 0109 80 DUP1 010A 63 PUSH4 0x715018a6 010F 14 EQ 0110 61 PUSH2 0x09f7 0113 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x09f7, if 0x715018a6 == stack[-1] label_0114: // Incoming jump from 0x0113, if not 0x715018a6 == stack[-1] // Inputs[1] { @0114 stack[-1] } 0114 80 DUP1 0115 63 PUSH4 0x7a3f451e 011A 14 EQ 011B 61 PUSH2 0x0a0e 011E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0a0e, if 0x7a3f451e == stack[-1] label_011F: // Incoming jump from 0x011E, if not 0x7a3f451e == stack[-1] 011F 61 PUSH2 0x021a 0122 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x021a label_0123: // Incoming jump from 0x001D, if 0x6c0360eb > msg.data[0x00:0x20] >> 0xe0 // Inputs[1] { @0124 stack[-1] } 0123 5B JUMPDEST 0124 80 DUP1 0125 63 PUSH4 0x2f745c59 012A 11 GT 012B 61 PUSH2 0x01a6 012E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01a6, if 0x2f745c59 > stack[-1] label_012F: // Incoming jump from 0x012E, if not 0x2f745c59 > stack[-1] // Inputs[1] { @012F stack[-1] } 012F 80 DUP1 0130 63 PUSH4 0x4f6ccce7 0135 11 GT 0136 61 PUSH2 0x0175 0139 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0175, if 0x4f6ccce7 > stack[-1] label_013A: // Incoming jump from 0x0139, if not 0x4f6ccce7 > stack[-1] // Inputs[1] { @013A stack[-1] } 013A 80 DUP1 013B 63 PUSH4 0x4f6ccce7 0140 14 EQ 0141 61 PUSH2 0x06cb 0144 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x06cb, 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 0x55f804b3 014B 14 EQ 014C 61 PUSH2 0x071a 014F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x071a, if 0x55f804b3 == stack[-1] label_0150: // Incoming jump from 0x014F, if not 0x55f804b3 == stack[-1] // Inputs[1] { @0150 stack[-1] } 0150 80 DUP1 0151 63 PUSH4 0x571dff3b 0156 14 EQ 0157 61 PUSH2 0x07e2 015A 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x07e2, if 0x571dff3b == stack[-1] label_015B: // Incoming jump from 0x015A, if not 0x571dff3b == stack[-1] // Inputs[1] { @015B stack[-1] } 015B 80 DUP1 015C 63 PUSH4 0x607e20e3 0161 14 EQ 0162 61 PUSH2 0x080d 0165 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x080d, if 0x607e20e3 == stack[-1] label_0166: // Incoming jump from 0x0165, if not 0x607e20e3 == stack[-1] // Inputs[1] { @0166 stack[-1] } 0166 80 DUP1 0167 63 PUSH4 0x6352211e 016C 14 EQ 016D 61 PUSH2 0x089d 0170 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x089d, if 0x6352211e == stack[-1] label_0171: // Incoming jump from 0x0170, if not 0x6352211e == stack[-1] 0171 61 PUSH2 0x021a 0174 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x021a label_0175: // Incoming jump from 0x0139, if 0x4f6ccce7 > stack[-1] // Inputs[1] { @0176 stack[-1] } 0175 5B JUMPDEST 0176 80 DUP1 0177 63 PUSH4 0x2f745c59 017C 14 EQ 017D 61 PUSH2 0x05b3 0180 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x05b3, if 0x2f745c59 == stack[-1] label_0181: // Incoming jump from 0x0180, if not 0x2f745c59 == stack[-1] // Inputs[1] { @0181 stack[-1] } 0181 80 DUP1 0182 63 PUSH4 0x34918dfd 0187 14 EQ 0188 61 PUSH2 0x0622 018B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0622, if 0x34918dfd == stack[-1] label_018C: // Incoming jump from 0x018B, if not 0x34918dfd == stack[-1] // Inputs[1] { @018C stack[-1] } 018C 80 DUP1 018D 63 PUSH4 0x3ccfd60b 0192 14 EQ 0193 61 PUSH2 0x0639 0196 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0639, if 0x3ccfd60b == stack[-1] label_0197: // Incoming jump from 0x0196, if not 0x3ccfd60b == stack[-1] // Inputs[1] { @0197 stack[-1] } 0197 80 DUP1 0198 63 PUSH4 0x42842e0e 019D 14 EQ 019E 61 PUSH2 0x0650 01A1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0650, if 0x42842e0e == stack[-1] label_01A2: // Incoming jump from 0x01A1, if not 0x42842e0e == stack[-1] 01A2 61 PUSH2 0x021a 01A5 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x021a label_01A6: // Incoming jump from 0x012E, if 0x2f745c59 > stack[-1] // Inputs[1] { @01A7 stack[-1] } 01A6 5B JUMPDEST 01A7 80 DUP1 01A8 63 PUSH4 0x095ea7b3 01AD 11 GT 01AE 61 PUSH2 0x01ed 01B1 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x01ed, if 0x095ea7b3 > stack[-1] label_01B2: // Incoming jump from 0x01B1, if not 0x095ea7b3 > stack[-1] // Inputs[1] { @01B2 stack[-1] } 01B2 80 DUP1 01B3 63 PUSH4 0x095ea7b3 01B8 14 EQ 01B9 61 PUSH2 0x03bf 01BC 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x03bf, if 0x095ea7b3 == stack[-1] label_01BD: // Incoming jump from 0x01BC, if not 0x095ea7b3 == stack[-1] // Inputs[1] { @01BD stack[-1] } 01BD 80 DUP1 01BE 63 PUSH4 0x10969523 01C3 14 EQ 01C4 61 PUSH2 0x041a 01C7 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x041a, if 0x10969523 == stack[-1] label_01C8: // Incoming jump from 0x01C7, if not 0x10969523 == stack[-1] // Inputs[1] { @01C8 stack[-1] } 01C8 80 DUP1 01C9 63 PUSH4 0x18160ddd 01CE 14 EQ 01CF 61 PUSH2 0x04e2 01D2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x04e2, if 0x18160ddd == stack[-1] label_01D3: // Incoming jump from 0x01D2, if not 0x18160ddd == stack[-1] // Inputs[1] { @01D3 stack[-1] } 01D3 80 DUP1 01D4 63 PUSH4 0x18e20a38 01D9 14 EQ 01DA 61 PUSH2 0x050d 01DD 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x050d, if 0x18e20a38 == stack[-1] label_01DE: // Incoming jump from 0x01DD, if not 0x18e20a38 == stack[-1] // Inputs[1] { @01DE stack[-1] } 01DE 80 DUP1 01DF 63 PUSH4 0x23b872dd 01E4 14 EQ 01E5 61 PUSH2 0x0538 01E8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x0538, if 0x23b872dd == stack[-1] label_01E9: // Incoming jump from 0x01E8, if not 0x23b872dd == stack[-1] 01E9 61 PUSH2 0x021a 01EC 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x021a label_01ED: // Incoming jump from 0x01B1, if 0x095ea7b3 > stack[-1] // Inputs[1] { @01EE stack[-1] } 01ED 5B JUMPDEST 01EE 80 DUP1 01EF 63 PUSH4 0x018a2c37 01F4 14 EQ 01F5 61 PUSH2 0x021f 01F8 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x021f, if 0x018a2c37 == stack[-1] label_01F9: // Incoming jump from 0x01F8, if not 0x018a2c37 == stack[-1] // Inputs[1] { @01F9 stack[-1] } 01F9 80 DUP1 01FA 63 PUSH4 0x01ffc9a7 01FF 14 EQ 0200 61 PUSH2 0x025a 0203 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x025a, if 0x01ffc9a7 == stack[-1] label_0204: // Incoming jump from 0x0203, if not 0x01ffc9a7 == stack[-1] // Inputs[1] { @0204 stack[-1] } 0204 80 DUP1 0205 63 PUSH4 0x06fdde03 020A 14 EQ 020B 61 PUSH2 0x02ca 020E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x02ca, if 0x06fdde03 == stack[-1] label_020F: // Incoming jump from 0x020E, if not 0x06fdde03 == stack[-1] // Inputs[1] { @020F stack[-1] } 020F 80 DUP1 0210 63 PUSH4 0x081812fc 0215 14 EQ 0216 61 PUSH2 0x035a 0219 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x035a, if 0x081812fc == stack[-1] label_021A: // Incoming jump from 0x00AA // Incoming jump from 0x0122 // Incoming jump from 0x0219, if not 0x081812fc == stack[-1] // Incoming jump from 0x000C, if msg.data.length < 0x04 // Incoming jump from 0x0174 // Incoming jump from 0x00F1 // Incoming jump from 0x006E // Incoming jump from 0x01A5 // Incoming jump from 0x01EC // Inputs[1] { @021E memory[0x00:0x00] } 021A 5B JUMPDEST 021B 60 PUSH1 0x00 021D 80 DUP1 021E FD *REVERT // Stack delta = +0 // Outputs[1] { @021E revert(memory[0x00:0x00]); } // Block terminates label_021F: // Incoming jump from 0x01F8, if 0x018a2c37 == stack[-1] // Inputs[1] { @0220 msg.value } 021F 5B JUMPDEST 0220 34 CALLVALUE 0221 80 DUP1 0222 15 ISZERO 0223 61 PUSH2 0x022b 0226 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0220 stack[0] = msg.value } // Block ends with conditional jump to 0x022b, if !msg.value label_0227: // Incoming jump from 0x0226, if not !msg.value // Inputs[1] { @022A memory[0x00:0x00] } 0227 60 PUSH1 0x00 0229 80 DUP1 022A FD *REVERT // Stack delta = +0 // Outputs[1] { @022A revert(memory[0x00:0x00]); } // Block terminates label_022B: // Incoming jump from 0x0226, if !msg.value // Inputs[1] { @0233 msg.data.length } 022B 5B JUMPDEST 022C 50 POP 022D 61 PUSH2 0x0258 0230 60 PUSH1 0x04 0232 80 DUP1 0233 36 CALLDATASIZE 0234 03 SUB 0235 60 PUSH1 0x20 0237 81 DUP2 0238 10 LT 0239 15 ISZERO 023A 61 PUSH2 0x0242 023D 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @022D stack[-1] = 0x0258 // @0230 stack[0] = 0x04 // @0234 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0242, returns to 0x0258, if !(msg.data.length - 0x04 < 0x20) label_023E: // Incoming jump from 0x023D, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0241 memory[0x00:0x00] } 023E 60 PUSH1 0x00 0240 80 DUP1 0241 FD *REVERT // Stack delta = +0 // Outputs[1] { @0241 revert(memory[0x00:0x00]); } // Block terminates label_0242: // Incoming call from 0x023D, returns to 0x0258, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0243 stack[-2] // @0244 stack[-1] // @0248 msg.data[stack[-2]:stack[-2] + 0x20] // } 0242 5B JUMPDEST 0243 81 DUP2 0244 01 ADD 0245 90 SWAP1 0246 80 DUP1 0247 80 DUP1 0248 35 CALLDATALOAD 0249 90 SWAP1 024A 60 PUSH1 0x20 024C 01 ADD 024D 90 SWAP1 024E 92 SWAP3 024F 91 SWAP2 0250 90 SWAP1 0251 50 POP 0252 50 POP 0253 50 POP 0254 61 PUSH2 0x0f26 0257 56 *JUMP // Stack delta = -1 // Outputs[1] { @024E stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0f26 label_0258: // Incoming return from call to 0x0242 at 0x023D 0258 5B JUMPDEST 0259 00 *STOP // Stack delta = +0 // Outputs[1] { @0259 stop(); } // Block terminates label_025A: // Incoming jump from 0x0203, if 0x01ffc9a7 == stack[-1] // Inputs[1] { @025B msg.value } 025A 5B JUMPDEST 025B 34 CALLVALUE 025C 80 DUP1 025D 15 ISZERO 025E 61 PUSH2 0x0266 0261 57 *JUMPI // Stack delta = +1 // Outputs[1] { @025B stack[0] = msg.value } // Block ends with conditional jump to 0x0266, if !msg.value label_0262: // Incoming jump from 0x0261, if not !msg.value // Inputs[1] { @0265 memory[0x00:0x00] } 0262 60 PUSH1 0x00 0264 80 DUP1 0265 FD *REVERT // Stack delta = +0 // Outputs[1] { @0265 revert(memory[0x00:0x00]); } // Block terminates label_0266: // Incoming jump from 0x0261, if !msg.value // Inputs[1] { @026E msg.data.length } 0266 5B JUMPDEST 0267 50 POP 0268 61 PUSH2 0x02b2 026B 60 PUSH1 0x04 026D 80 DUP1 026E 36 CALLDATASIZE 026F 03 SUB 0270 60 PUSH1 0x20 0272 81 DUP2 0273 10 LT 0274 15 ISZERO 0275 61 PUSH2 0x027d 0278 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0268 stack[-1] = 0x02b2 // @026B stack[0] = 0x04 // @026F stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x027d, returns to 0x02B2, if !(msg.data.length - 0x04 < 0x20) label_0279: // Incoming jump from 0x0278, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @027C memory[0x00:0x00] } 0279 60 PUSH1 0x00 027B 80 DUP1 027C FD *REVERT // Stack delta = +0 // Outputs[1] { @027C revert(memory[0x00:0x00]); } // Block terminates label_027D: // Incoming call from 0x0278, returns to 0x02B2, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @027E stack[-2] // @027F stack[-1] // @0283 msg.data[stack[-2]:stack[-2] + 0x20] // } 027D 5B JUMPDEST 027E 81 DUP2 027F 01 ADD 0280 90 SWAP1 0281 80 DUP1 0282 80 DUP1 0283 35 CALLDATALOAD 0284 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 02A1 19 NOT 02A2 16 AND 02A3 90 SWAP1 02A4 60 PUSH1 0x20 02A6 01 ADD 02A7 90 SWAP1 02A8 92 SWAP3 02A9 91 SWAP2 02AA 90 SWAP1 02AB 50 POP 02AC 50 POP 02AD 50 POP 02AE 61 PUSH2 0x0fdf 02B1 56 *JUMP // Stack delta = -1 // Outputs[1] { @02A8 stack[-2] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x0fdf label_02B2: // Incoming return from call to 0x027D at 0x0278 // Inputs[4] // { // @02B5 memory[0x40:0x60] // @02B7 stack[-1] // @02C4 memory[0x40:0x60] // @02C9 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 02B2 5B JUMPDEST 02B3 60 PUSH1 0x40 02B5 51 MLOAD 02B6 80 DUP1 02B7 82 DUP3 02B8 15 ISZERO 02B9 15 ISZERO 02BA 81 DUP2 02BB 52 MSTORE 02BC 60 PUSH1 0x20 02BE 01 ADD 02BF 91 SWAP2 02C0 50 POP 02C1 50 POP 02C2 60 PUSH1 0x40 02C4 51 MLOAD 02C5 80 DUP1 02C6 91 SWAP2 02C7 03 SUB 02C8 90 SWAP1 02C9 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @02BB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @02C9 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_02CA: // Incoming jump from 0x020E, if 0x06fdde03 == stack[-1] // Inputs[1] { @02CB msg.value } 02CA 5B JUMPDEST 02CB 34 CALLVALUE 02CC 80 DUP1 02CD 15 ISZERO 02CE 61 PUSH2 0x02d6 02D1 57 *JUMPI // Stack delta = +1 // Outputs[1] { @02CB stack[0] = msg.value } // Block ends with conditional jump to 0x02d6, if !msg.value label_02D2: // Incoming jump from 0x02D1, if not !msg.value // Inputs[1] { @02D5 memory[0x00:0x00] } 02D2 60 PUSH1 0x00 02D4 80 DUP1 02D5 FD *REVERT // Stack delta = +0 // Outputs[1] { @02D5 revert(memory[0x00:0x00]); } // Block terminates label_02D6: // Incoming jump from 0x02D1, if !msg.value 02D6 5B JUMPDEST 02D7 50 POP 02D8 61 PUSH2 0x02df 02DB 61 PUSH2 0x1046 02DE 56 *JUMP // Stack delta = +0 // Outputs[1] { @02D8 stack[-1] = 0x02df } // Block ends with call to 0x1046, returns to 0x02DF label_02DF: // Incoming return from call to 0x1046 at 0x02DE // Inputs[4] // { // @02E2 memory[0x40:0x60] // @02ED stack[-1] // @02F0 memory[stack[-1]:stack[-1] + 0x20] // @02F9 memory[stack[-1]:stack[-1] + 0x20] // } 02DF 5B JUMPDEST 02E0 60 PUSH1 0x40 02E2 51 MLOAD 02E3 80 DUP1 02E4 80 DUP1 02E5 60 PUSH1 0x20 02E7 01 ADD 02E8 82 DUP3 02E9 81 DUP2 02EA 03 SUB 02EB 82 DUP3 02EC 52 MSTORE 02ED 83 DUP4 02EE 81 DUP2 02EF 81 DUP2 02F0 51 MLOAD 02F1 81 DUP2 02F2 52 MSTORE 02F3 60 PUSH1 0x20 02F5 01 ADD 02F6 91 SWAP2 02F7 50 POP 02F8 80 DUP1 02F9 51 MLOAD 02FA 90 SWAP1 02FB 60 PUSH1 0x20 02FD 01 ADD 02FE 90 SWAP1 02FF 80 DUP1 0300 83 DUP4 0301 83 DUP4 0302 60 PUSH1 0x00 0304 5B JUMPDEST 0305 83 DUP4 0306 81 DUP2 0307 10 LT 0308 15 ISZERO 0309 61 PUSH2 0x031f 030C 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @02E2 stack[0] = memory[0x40:0x60] // @02E3 stack[1] = memory[0x40:0x60] // @02EC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @02F2 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @02F6 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @02FE stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @02FE stack[3] = 0x20 + stack[-1] // @02FF stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @0300 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @0301 stack[7] = 0x20 + stack[-1] // @0302 stack[8] = 0x00 // } // Block ends with conditional jump to 0x031f, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_030D: // Incoming jump from 0x030C, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x030C, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @030D stack[-1] // @030E stack[-2] // @0310 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0312 stack[-3] // } 030D 80 DUP1 030E 82 DUP3 030F 01 ADD 0310 51 MLOAD 0311 81 DUP2 0312 84 DUP5 0313 01 ADD 0314 52 MSTORE 0315 60 PUSH1 0x20 0317 81 DUP2 0318 01 ADD 0319 90 SWAP1 031A 50 POP 031B 61 PUSH2 0x0304 031E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0314 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0319 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0304 label_031F: // Incoming jump from 0x030C, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x030C, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @0324 stack[-6] // @0324 stack[-5] // @0326 stack[-7] // } 031F 5B JUMPDEST 0320 50 POP 0321 50 POP 0322 50 POP 0323 50 POP 0324 90 SWAP1 0325 50 POP 0326 90 SWAP1 0327 81 DUP2 0328 01 ADD 0329 90 SWAP1 032A 60 PUSH1 0x1f 032C 16 AND 032D 80 DUP1 032E 15 ISZERO 032F 61 PUSH2 0x034c 0332 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0329 stack[-7] = stack[-5] + stack[-7] // @032C stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x034c, if !(0x1f & stack[-5]) label_0333: // Incoming jump from 0x0332, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0333 stack[-1] // @0334 stack[-2] // @0337 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @034E stack[-5] // @0354 memory[0x40:0x60] // @0359 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0333 80 DUP1 0334 82 DUP3 0335 03 SUB 0336 80 DUP1 0337 51 MLOAD 0338 60 PUSH1 0x01 033A 83 DUP4 033B 60 PUSH1 0x20 033D 03 SUB 033E 61 PUSH2 0x0100 0341 0A EXP 0342 03 SUB 0343 19 NOT 0344 16 AND 0345 81 DUP2 0346 52 MSTORE 0347 60 PUSH1 0x20 0349 01 ADD 034A 91 SWAP2 034B 50 POP 034C 5B JUMPDEST 034D 50 POP 034E 92 SWAP3 034F 50 POP 0350 50 POP 0351 50 POP 0352 60 PUSH1 0x40 0354 51 MLOAD 0355 80 DUP1 0356 91 SWAP2 0357 03 SUB 0358 90 SWAP1 0359 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0346 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0359 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_035A: // Incoming jump from 0x0219, if 0x081812fc == stack[-1] // Inputs[1] { @035B msg.value } 035A 5B JUMPDEST 035B 34 CALLVALUE 035C 80 DUP1 035D 15 ISZERO 035E 61 PUSH2 0x0366 0361 57 *JUMPI // Stack delta = +1 // Outputs[1] { @035B stack[0] = msg.value } // Block ends with conditional jump to 0x0366, if !msg.value label_0362: // Incoming jump from 0x0361, if not !msg.value // Inputs[1] { @0365 memory[0x00:0x00] } 0362 60 PUSH1 0x00 0364 80 DUP1 0365 FD *REVERT // Stack delta = +0 // Outputs[1] { @0365 revert(memory[0x00:0x00]); } // Block terminates label_0366: // Incoming jump from 0x0361, if !msg.value // Inputs[1] { @036E msg.data.length } 0366 5B JUMPDEST 0367 50 POP 0368 61 PUSH2 0x0393 036B 60 PUSH1 0x04 036D 80 DUP1 036E 36 CALLDATASIZE 036F 03 SUB 0370 60 PUSH1 0x20 0372 81 DUP2 0373 10 LT 0374 15 ISZERO 0375 61 PUSH2 0x037d 0378 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0368 stack[-1] = 0x0393 // @036B stack[0] = 0x04 // @036F stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x037d, returns to 0x0393, if !(msg.data.length - 0x04 < 0x20) label_0379: // Incoming jump from 0x0378, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @037C memory[0x00:0x00] } 0379 60 PUSH1 0x00 037B 80 DUP1 037C FD *REVERT // Stack delta = +0 // Outputs[1] { @037C revert(memory[0x00:0x00]); } // Block terminates label_037D: // Incoming call from 0x0378, returns to 0x0393, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @037E stack[-2] // @037F stack[-1] // @0383 msg.data[stack[-2]:stack[-2] + 0x20] // } 037D 5B JUMPDEST 037E 81 DUP2 037F 01 ADD 0380 90 SWAP1 0381 80 DUP1 0382 80 DUP1 0383 35 CALLDATALOAD 0384 90 SWAP1 0385 60 PUSH1 0x20 0387 01 ADD 0388 90 SWAP1 0389 92 SWAP3 038A 91 SWAP2 038B 90 SWAP1 038C 50 POP 038D 50 POP 038E 50 POP 038F 61 PUSH2 0x10e8 0392 56 *JUMP // Stack delta = -1 // Outputs[1] { @0389 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x10e8 label_0393: // Incoming return from call to 0x037D at 0x0378 // Inputs[4] // { // @0396 memory[0x40:0x60] // @0398 stack[-1] // @03B9 memory[0x40:0x60] // @03BE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0393 5B JUMPDEST 0394 60 PUSH1 0x40 0396 51 MLOAD 0397 80 DUP1 0398 82 DUP3 0399 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03AE 16 AND 03AF 81 DUP2 03B0 52 MSTORE 03B1 60 PUSH1 0x20 03B3 01 ADD 03B4 91 SWAP2 03B5 50 POP 03B6 50 POP 03B7 60 PUSH1 0x40 03B9 51 MLOAD 03BA 80 DUP1 03BB 91 SWAP2 03BC 03 SUB 03BD 90 SWAP1 03BE F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @03B0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @03BE return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_03BF: // Incoming jump from 0x01BC, if 0x095ea7b3 == stack[-1] // Inputs[1] { @03C0 msg.value } 03BF 5B JUMPDEST 03C0 34 CALLVALUE 03C1 80 DUP1 03C2 15 ISZERO 03C3 61 PUSH2 0x03cb 03C6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @03C0 stack[0] = msg.value } // Block ends with conditional jump to 0x03cb, if !msg.value label_03C7: // Incoming jump from 0x03C6, if not !msg.value // Inputs[1] { @03CA memory[0x00:0x00] } 03C7 60 PUSH1 0x00 03C9 80 DUP1 03CA FD *REVERT // Stack delta = +0 // Outputs[1] { @03CA revert(memory[0x00:0x00]); } // Block terminates label_03CB: // Incoming jump from 0x03C6, if !msg.value // Inputs[1] { @03D3 msg.data.length } 03CB 5B JUMPDEST 03CC 50 POP 03CD 61 PUSH2 0x0418 03D0 60 PUSH1 0x04 03D2 80 DUP1 03D3 36 CALLDATASIZE 03D4 03 SUB 03D5 60 PUSH1 0x40 03D7 81 DUP2 03D8 10 LT 03D9 15 ISZERO 03DA 61 PUSH2 0x03e2 03DD 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @03CD stack[-1] = 0x0418 // @03D0 stack[0] = 0x04 // @03D4 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x03e2, returns to 0x0418, if !(msg.data.length - 0x04 < 0x40) label_03DE: // Incoming jump from 0x03DD, if not !(msg.data.length - 0x04 < 0x40) // 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 call from 0x03DD, returns to 0x0418, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @03E3 stack[-2] // @03E4 stack[-1] // @03E8 msg.data[stack[-2]:stack[-2] + 0x20] // @0408 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 03E2 5B JUMPDEST 03E3 81 DUP2 03E4 01 ADD 03E5 90 SWAP1 03E6 80 DUP1 03E7 80 DUP1 03E8 35 CALLDATALOAD 03E9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 03FE 16 AND 03FF 90 SWAP1 0400 60 PUSH1 0x20 0402 01 ADD 0403 90 SWAP1 0404 92 SWAP3 0405 91 SWAP2 0406 90 SWAP1 0407 80 DUP1 0408 35 CALLDATALOAD 0409 90 SWAP1 040A 60 PUSH1 0x20 040C 01 ADD 040D 90 SWAP1 040E 92 SWAP3 040F 91 SWAP2 0410 90 SWAP1 0411 50 POP 0412 50 POP 0413 50 POP 0414 61 PUSH2 0x1183 0417 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0404 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @040E stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1183 label_0418: // Incoming return from call to 0x03E2 at 0x03DD 0418 5B JUMPDEST 0419 00 *STOP // Stack delta = +0 // Outputs[1] { @0419 stop(); } // Block terminates label_041A: // Incoming jump from 0x01C7, if 0x10969523 == stack[-1] // Inputs[1] { @041B msg.value } 041A 5B JUMPDEST 041B 34 CALLVALUE 041C 80 DUP1 041D 15 ISZERO 041E 61 PUSH2 0x0426 0421 57 *JUMPI // Stack delta = +1 // Outputs[1] { @041B stack[0] = msg.value } // Block ends with conditional jump to 0x0426, if !msg.value label_0422: // Incoming jump from 0x0421, if not !msg.value // Inputs[1] { @0425 memory[0x00:0x00] } 0422 60 PUSH1 0x00 0424 80 DUP1 0425 FD *REVERT // Stack delta = +0 // Outputs[1] { @0425 revert(memory[0x00:0x00]); } // Block terminates label_0426: // Incoming jump from 0x0421, if !msg.value // Inputs[1] { @042E msg.data.length } 0426 5B JUMPDEST 0427 50 POP 0428 61 PUSH2 0x04e0 042B 60 PUSH1 0x04 042D 80 DUP1 042E 36 CALLDATASIZE 042F 03 SUB 0430 60 PUSH1 0x20 0432 81 DUP2 0433 10 LT 0434 15 ISZERO 0435 61 PUSH2 0x043d 0438 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0428 stack[-1] = 0x04e0 // @042B stack[0] = 0x04 // @042F stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x043d, returns to 0x04E0, if !(msg.data.length - 0x04 < 0x20) label_0439: // Incoming jump from 0x0438, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @043C memory[0x00:0x00] } 0439 60 PUSH1 0x00 043B 80 DUP1 043C FD *REVERT // Stack delta = +0 // Outputs[1] { @043C revert(memory[0x00:0x00]); } // Block terminates label_043D: // Incoming call from 0x0438, returns to 0x04E0, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @043E stack[-2] // @043F stack[-1] // @0443 msg.data[stack[-2]:stack[-2] + 0x20] // } 043D 5B JUMPDEST 043E 81 DUP2 043F 01 ADD 0440 90 SWAP1 0441 80 DUP1 0442 80 DUP1 0443 35 CALLDATALOAD 0444 90 SWAP1 0445 60 PUSH1 0x20 0447 01 ADD 0448 90 SWAP1 0449 64 PUSH5 0x0100000000 044F 81 DUP2 0450 11 GT 0451 15 ISZERO 0452 61 PUSH2 0x045a 0455 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0440 stack[-1] = stack[-2] // @0440 stack[-2] = stack[-2] + stack[-1] // @0448 stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // @0448 stack[0] = 0x20 + stack[-2] // } // Block ends with conditional jump to 0x045a, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) label_0456: // Incoming jump from 0x0455, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @0459 memory[0x00:0x00] } 0456 60 PUSH1 0x00 0458 80 DUP1 0459 FD *REVERT // Stack delta = +0 // Outputs[1] { @0459 revert(memory[0x00:0x00]); } // Block terminates label_045A: // Incoming jump from 0x0455, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @045B stack[-3] // @045C stack[-1] // @045D stack[-4] // } 045A 5B JUMPDEST 045B 82 DUP3 045C 01 ADD 045D 83 DUP4 045E 60 PUSH1 0x20 0460 82 DUP3 0461 01 ADD 0462 11 GT 0463 15 ISZERO 0464 61 PUSH2 0x046c 0467 57 *JUMPI // Stack delta = +0 // Outputs[1] { @045C stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x046c, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0468: // Incoming jump from 0x0467, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @046B memory[0x00:0x00] } 0468 60 PUSH1 0x00 046A 80 DUP1 046B FD *REVERT // Stack delta = +0 // Outputs[1] { @046B revert(memory[0x00:0x00]); } // Block terminates label_046C: // Incoming jump from 0x0467, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @046D stack[-1] // @046E msg.data[stack[-1]:stack[-1] + 0x20] // @0473 stack[-2] // @0474 stack[-4] // } 046C 5B JUMPDEST 046D 80 DUP1 046E 35 CALLDATALOAD 046F 90 SWAP1 0470 60 PUSH1 0x20 0472 01 ADD 0473 91 SWAP2 0474 84 DUP5 0475 60 PUSH1 0x01 0477 83 DUP4 0478 02 MUL 0479 84 DUP5 047A 01 ADD 047B 11 GT 047C 64 PUSH5 0x0100000000 0482 83 DUP4 0483 11 GT 0484 17 OR 0485 15 ISZERO 0486 61 PUSH2 0x048e 0489 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @046F stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0473 stack[0] = stack[-2] // @0473 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x048e, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_048A: // Incoming jump from 0x0489, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @048D memory[0x00:0x00] } 048A 60 PUSH1 0x00 048C 80 DUP1 048D FD *REVERT // Stack delta = +0 // Outputs[1] { @048D revert(memory[0x00:0x00]); } // Block terminates label_048E: // Incoming jump from 0x0489, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @048F stack[-1] // @048F stack[-3] // @0490 stack[-2] // @04A1 memory[0x40:0x60] // @04B8 msg.data[stack[-3]:stack[-3] + stack[-2]] // @04D4 stack[-4] // @04D5 stack[-5] // } 048E 5B JUMPDEST 048F 91 SWAP2 0490 90 SWAP1 0491 80 DUP1 0492 80 DUP1 0493 60 PUSH1 0x1f 0495 01 ADD 0496 60 PUSH1 0x20 0498 80 DUP1 0499 91 SWAP2 049A 04 DIV 049B 02 MUL 049C 60 PUSH1 0x20 049E 01 ADD 049F 60 PUSH1 0x40 04A1 51 MLOAD 04A2 90 SWAP1 04A3 81 DUP2 04A4 01 ADD 04A5 60 PUSH1 0x40 04A7 52 MSTORE 04A8 80 DUP1 04A9 93 SWAP4 04AA 92 SWAP3 04AB 91 SWAP2 04AC 90 SWAP1 04AD 81 DUP2 04AE 81 DUP2 04AF 52 MSTORE 04B0 60 PUSH1 0x20 04B2 01 ADD 04B3 83 DUP4 04B4 83 DUP4 04B5 80 DUP1 04B6 82 DUP3 04B7 84 DUP5 04B8 37 CALLDATACOPY 04B9 60 PUSH1 0x00 04BB 81 DUP2 04BC 84 DUP5 04BD 01 ADD 04BE 52 MSTORE 04BF 60 PUSH1 0x1f 04C1 19 NOT 04C2 60 PUSH1 0x1f 04C4 82 DUP3 04C5 01 ADD 04C6 16 AND 04C7 90 SWAP1 04C8 50 POP 04C9 80 DUP1 04CA 83 DUP4 04CB 01 ADD 04CC 92 SWAP3 04CD 50 POP 04CE 50 POP 04CF 50 POP 04D0 50 POP 04D1 50 POP 04D2 50 POP 04D3 50 POP 04D4 91 SWAP2 04D5 92 SWAP3 04D6 91 SWAP2 04D7 92 SWAP3 04D8 90 SWAP1 04D9 50 POP 04DA 50 POP 04DB 50 POP 04DC 61 PUSH2 0x12c7 04DF 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @04A7 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @04AF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @04B8 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @04BE memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @04D7 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x12c7 label_04E0: // Incoming return from call to 0x043D at 0x0438 04E0 5B JUMPDEST 04E1 00 *STOP // Stack delta = +0 // Outputs[1] { @04E1 stop(); } // Block terminates label_04E2: // Incoming jump from 0x01D2, if 0x18160ddd == stack[-1] // Inputs[1] { @04E3 msg.value } 04E2 5B JUMPDEST 04E3 34 CALLVALUE 04E4 80 DUP1 04E5 15 ISZERO 04E6 61 PUSH2 0x04ee 04E9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @04E3 stack[0] = msg.value } // Block ends with conditional jump to 0x04ee, if !msg.value label_04EA: // Incoming jump from 0x04E9, if not !msg.value // Inputs[1] { @04ED memory[0x00:0x00] } 04EA 60 PUSH1 0x00 04EC 80 DUP1 04ED FD *REVERT // Stack delta = +0 // Outputs[1] { @04ED revert(memory[0x00:0x00]); } // Block terminates label_04EE: // Incoming jump from 0x04E9, if !msg.value 04EE 5B JUMPDEST 04EF 50 POP 04F0 61 PUSH2 0x04f7 04F3 61 PUSH2 0x1390 04F6 56 *JUMP // Stack delta = +0 // Outputs[1] { @04F0 stack[-1] = 0x04f7 } // Block ends with call to 0x1390, returns to 0x04F7 label_04F7: // Incoming return from call to 0x1390 at 0x04F6 // Inputs[4] // { // @04FA memory[0x40:0x60] // @04FC stack[-1] // @0507 memory[0x40:0x60] // @050C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 04F7 5B JUMPDEST 04F8 60 PUSH1 0x40 04FA 51 MLOAD 04FB 80 DUP1 04FC 82 DUP3 04FD 81 DUP2 04FE 52 MSTORE 04FF 60 PUSH1 0x20 0501 01 ADD 0502 91 SWAP2 0503 50 POP 0504 50 POP 0505 60 PUSH1 0x40 0507 51 MLOAD 0508 80 DUP1 0509 91 SWAP2 050A 03 SUB 050B 90 SWAP1 050C F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @04FE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @050C return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_050D: // Incoming jump from 0x01DD, if 0x18e20a38 == stack[-1] // Inputs[1] { @050E msg.value } 050D 5B JUMPDEST 050E 34 CALLVALUE 050F 80 DUP1 0510 15 ISZERO 0511 61 PUSH2 0x0519 0514 57 *JUMPI // Stack delta = +1 // Outputs[1] { @050E stack[0] = msg.value } // Block ends with conditional jump to 0x0519, if !msg.value label_0515: // Incoming jump from 0x0514, if not !msg.value // Inputs[1] { @0518 memory[0x00:0x00] } 0515 60 PUSH1 0x00 0517 80 DUP1 0518 FD *REVERT // Stack delta = +0 // Outputs[1] { @0518 revert(memory[0x00:0x00]); } // Block terminates label_0519: // Incoming jump from 0x0514, if !msg.value 0519 5B JUMPDEST 051A 50 POP 051B 61 PUSH2 0x0522 051E 61 PUSH2 0x13a1 0521 56 *JUMP // Stack delta = +0 // Outputs[1] { @051B stack[-1] = 0x0522 } // Block ends with call to 0x13a1, returns to 0x0522 label_0522: // Incoming return from call to 0x13A1 at 0x0521 // Inputs[4] // { // @0525 memory[0x40:0x60] // @0527 stack[-1] // @0532 memory[0x40:0x60] // @0537 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0522 5B JUMPDEST 0523 60 PUSH1 0x40 0525 51 MLOAD 0526 80 DUP1 0527 82 DUP3 0528 81 DUP2 0529 52 MSTORE 052A 60 PUSH1 0x20 052C 01 ADD 052D 91 SWAP2 052E 50 POP 052F 50 POP 0530 60 PUSH1 0x40 0532 51 MLOAD 0533 80 DUP1 0534 91 SWAP2 0535 03 SUB 0536 90 SWAP1 0537 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0529 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0537 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0538: // Incoming jump from 0x01E8, if 0x23b872dd == stack[-1] // Inputs[1] { @0539 msg.value } 0538 5B JUMPDEST 0539 34 CALLVALUE 053A 80 DUP1 053B 15 ISZERO 053C 61 PUSH2 0x0544 053F 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0539 stack[0] = msg.value } // Block ends with conditional jump to 0x0544, if !msg.value label_0540: // Incoming jump from 0x053F, if not !msg.value // Inputs[1] { @0543 memory[0x00:0x00] } 0540 60 PUSH1 0x00 0542 80 DUP1 0543 FD *REVERT // Stack delta = +0 // Outputs[1] { @0543 revert(memory[0x00:0x00]); } // Block terminates label_0544: // Incoming jump from 0x053F, if !msg.value // Inputs[1] { @054C msg.data.length } 0544 5B JUMPDEST 0545 50 POP 0546 61 PUSH2 0x05b1 0549 60 PUSH1 0x04 054B 80 DUP1 054C 36 CALLDATASIZE 054D 03 SUB 054E 60 PUSH1 0x60 0550 81 DUP2 0551 10 LT 0552 15 ISZERO 0553 61 PUSH2 0x055b 0556 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0546 stack[-1] = 0x05b1 // @0549 stack[0] = 0x04 // @054D stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x055b, returns to 0x05B1, if !(msg.data.length - 0x04 < 0x60) label_0557: // Incoming jump from 0x0556, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @055A memory[0x00:0x00] } 0557 60 PUSH1 0x00 0559 80 DUP1 055A FD *REVERT // Stack delta = +0 // Outputs[1] { @055A revert(memory[0x00:0x00]); } // Block terminates label_055B: // Incoming call from 0x0556, returns to 0x05B1, if !(msg.data.length - 0x04 < 0x60) // Inputs[5] // { // @055C stack[-2] // @055D stack[-1] // @0561 msg.data[stack[-2]:stack[-2] + 0x20] // @0581 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @05A1 msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } 055B 5B JUMPDEST 055C 81 DUP2 055D 01 ADD 055E 90 SWAP1 055F 80 DUP1 0560 80 DUP1 0561 35 CALLDATALOAD 0562 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0577 16 AND 0578 90 SWAP1 0579 60 PUSH1 0x20 057B 01 ADD 057C 90 SWAP1 057D 92 SWAP3 057E 91 SWAP2 057F 90 SWAP1 0580 80 DUP1 0581 35 CALLDATALOAD 0582 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0597 16 AND 0598 90 SWAP1 0599 60 PUSH1 0x20 059B 01 ADD 059C 90 SWAP1 059D 92 SWAP3 059E 91 SWAP2 059F 90 SWAP1 05A0 80 DUP1 05A1 35 CALLDATALOAD 05A2 90 SWAP1 05A3 60 PUSH1 0x20 05A5 01 ADD 05A6 90 SWAP1 05A7 92 SWAP3 05A8 91 SWAP2 05A9 90 SWAP1 05AA 50 POP 05AB 50 POP 05AC 50 POP 05AD 61 PUSH2 0x13a7 05B0 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @057D stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @059D stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @05A7 stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x13a7 label_05B1: // Incoming return from call to 0x055B at 0x0556 05B1 5B JUMPDEST 05B2 00 *STOP // Stack delta = +0 // Outputs[1] { @05B2 stop(); } // Block terminates label_05B3: // Incoming jump from 0x0180, if 0x2f745c59 == stack[-1] // Inputs[1] { @05B4 msg.value } 05B3 5B JUMPDEST 05B4 34 CALLVALUE 05B5 80 DUP1 05B6 15 ISZERO 05B7 61 PUSH2 0x05bf 05BA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @05B4 stack[0] = msg.value } // Block ends with conditional jump to 0x05bf, if !msg.value label_05BB: // Incoming jump from 0x05BA, if not !msg.value // Inputs[1] { @05BE memory[0x00:0x00] } 05BB 60 PUSH1 0x00 05BD 80 DUP1 05BE FD *REVERT // Stack delta = +0 // Outputs[1] { @05BE revert(memory[0x00:0x00]); } // Block terminates label_05BF: // Incoming jump from 0x05BA, if !msg.value // Inputs[1] { @05C7 msg.data.length } 05BF 5B JUMPDEST 05C0 50 POP 05C1 61 PUSH2 0x060c 05C4 60 PUSH1 0x04 05C6 80 DUP1 05C7 36 CALLDATASIZE 05C8 03 SUB 05C9 60 PUSH1 0x40 05CB 81 DUP2 05CC 10 LT 05CD 15 ISZERO 05CE 61 PUSH2 0x05d6 05D1 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @05C1 stack[-1] = 0x060c // @05C4 stack[0] = 0x04 // @05C8 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x05d6, returns to 0x060C, if !(msg.data.length - 0x04 < 0x40) label_05D2: // Incoming jump from 0x05D1, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @05D5 memory[0x00:0x00] } 05D2 60 PUSH1 0x00 05D4 80 DUP1 05D5 FD *REVERT // Stack delta = +0 // Outputs[1] { @05D5 revert(memory[0x00:0x00]); } // Block terminates label_05D6: // Incoming call from 0x05D1, returns to 0x060C, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @05D7 stack[-2] // @05D8 stack[-1] // @05DC msg.data[stack[-2]:stack[-2] + 0x20] // @05FC msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 05D6 5B JUMPDEST 05D7 81 DUP2 05D8 01 ADD 05D9 90 SWAP1 05DA 80 DUP1 05DB 80 DUP1 05DC 35 CALLDATALOAD 05DD 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 05F2 16 AND 05F3 90 SWAP1 05F4 60 PUSH1 0x20 05F6 01 ADD 05F7 90 SWAP1 05F8 92 SWAP3 05F9 91 SWAP2 05FA 90 SWAP1 05FB 80 DUP1 05FC 35 CALLDATALOAD 05FD 90 SWAP1 05FE 60 PUSH1 0x20 0600 01 ADD 0601 90 SWAP1 0602 92 SWAP3 0603 91 SWAP2 0604 90 SWAP1 0605 50 POP 0606 50 POP 0607 50 POP 0608 61 PUSH2 0x141d 060B 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @05F8 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0602 stack[-1] = msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x141d label_060C: // Incoming return from call to 0x05D6 at 0x05D1 // Inputs[4] // { // @060F memory[0x40:0x60] // @0611 stack[-1] // @061C memory[0x40:0x60] // @0621 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 060C 5B JUMPDEST 060D 60 PUSH1 0x40 060F 51 MLOAD 0610 80 DUP1 0611 82 DUP3 0612 81 DUP2 0613 52 MSTORE 0614 60 PUSH1 0x20 0616 01 ADD 0617 91 SWAP2 0618 50 POP 0619 50 POP 061A 60 PUSH1 0x40 061C 51 MLOAD 061D 80 DUP1 061E 91 SWAP2 061F 03 SUB 0620 90 SWAP1 0621 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0613 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0621 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0622: // Incoming jump from 0x018B, if 0x34918dfd == stack[-1] // Inputs[1] { @0623 msg.value } 0622 5B JUMPDEST 0623 34 CALLVALUE 0624 80 DUP1 0625 15 ISZERO 0626 61 PUSH2 0x062e 0629 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0623 stack[0] = msg.value } // Block ends with conditional jump to 0x062e, if !msg.value label_062A: // Incoming jump from 0x0629, if not !msg.value // Inputs[1] { @062D memory[0x00:0x00] } 062A 60 PUSH1 0x00 062C 80 DUP1 062D FD *REVERT // Stack delta = +0 // Outputs[1] { @062D revert(memory[0x00:0x00]); } // Block terminates label_062E: // Incoming jump from 0x0629, if !msg.value 062E 5B JUMPDEST 062F 50 POP 0630 61 PUSH2 0x0637 0633 61 PUSH2 0x1478 0636 56 *JUMP // Stack delta = +0 // Outputs[1] { @0630 stack[-1] = 0x0637 } // Block ends with call to 0x1478, returns to 0x0637 label_0637: // Incoming return from call to 0x1478 at 0x0636 0637 5B JUMPDEST 0638 00 *STOP // Stack delta = +0 // Outputs[1] { @0638 stop(); } // Block terminates label_0639: // Incoming jump from 0x0196, if 0x3ccfd60b == stack[-1] // Inputs[1] { @063A msg.value } 0639 5B JUMPDEST 063A 34 CALLVALUE 063B 80 DUP1 063C 15 ISZERO 063D 61 PUSH2 0x0645 0640 57 *JUMPI // Stack delta = +1 // Outputs[1] { @063A stack[0] = msg.value } // Block ends with conditional jump to 0x0645, if !msg.value label_0641: // Incoming jump from 0x0640, if not !msg.value // Inputs[1] { @0644 memory[0x00:0x00] } 0641 60 PUSH1 0x00 0643 80 DUP1 0644 FD *REVERT // Stack delta = +0 // Outputs[1] { @0644 revert(memory[0x00:0x00]); } // Block terminates label_0645: // Incoming jump from 0x0640, if !msg.value 0645 5B JUMPDEST 0646 50 POP 0647 61 PUSH2 0x064e 064A 61 PUSH2 0x1553 064D 56 *JUMP // Stack delta = +0 // Outputs[1] { @0647 stack[-1] = 0x064e } // Block ends with call to 0x1553, returns to 0x064E label_064E: // Incoming return from call to 0x1553 at 0x064D 064E 5B JUMPDEST 064F 00 *STOP // Stack delta = +0 // Outputs[1] { @064F stop(); } // Block terminates label_0650: // Incoming jump from 0x01A1, if 0x42842e0e == stack[-1] // Inputs[1] { @0651 msg.value } 0650 5B JUMPDEST 0651 34 CALLVALUE 0652 80 DUP1 0653 15 ISZERO 0654 61 PUSH2 0x065c 0657 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0651 stack[0] = msg.value } // Block ends with conditional jump to 0x065c, if !msg.value label_0658: // Incoming jump from 0x0657, if not !msg.value // Inputs[1] { @065B memory[0x00:0x00] } 0658 60 PUSH1 0x00 065A 80 DUP1 065B FD *REVERT // Stack delta = +0 // Outputs[1] { @065B revert(memory[0x00:0x00]); } // Block terminates label_065C: // Incoming jump from 0x0657, if !msg.value // Inputs[1] { @0664 msg.data.length } 065C 5B JUMPDEST 065D 50 POP 065E 61 PUSH2 0x06c9 0661 60 PUSH1 0x04 0663 80 DUP1 0664 36 CALLDATASIZE 0665 03 SUB 0666 60 PUSH1 0x60 0668 81 DUP2 0669 10 LT 066A 15 ISZERO 066B 61 PUSH2 0x0673 066E 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @065E stack[-1] = 0x06c9 // @0661 stack[0] = 0x04 // @0665 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0673, returns to 0x06C9, if !(msg.data.length - 0x04 < 0x60) label_066F: // Incoming jump from 0x066E, if not !(msg.data.length - 0x04 < 0x60) // Inputs[1] { @0672 memory[0x00:0x00] } 066F 60 PUSH1 0x00 0671 80 DUP1 0672 FD *REVERT // Stack delta = +0 // Outputs[1] { @0672 revert(memory[0x00:0x00]); } // Block terminates label_0673: // Incoming call from 0x066E, returns to 0x06C9, if !(msg.data.length - 0x04 < 0x60) // Inputs[5] // { // @0674 stack[-2] // @0675 stack[-1] // @0679 msg.data[stack[-2]:stack[-2] + 0x20] // @0699 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @06B9 msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } 0673 5B JUMPDEST 0674 81 DUP2 0675 01 ADD 0676 90 SWAP1 0677 80 DUP1 0678 80 DUP1 0679 35 CALLDATALOAD 067A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 068F 16 AND 0690 90 SWAP1 0691 60 PUSH1 0x20 0693 01 ADD 0694 90 SWAP1 0695 92 SWAP3 0696 91 SWAP2 0697 90 SWAP1 0698 80 DUP1 0699 35 CALLDATALOAD 069A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 06AF 16 AND 06B0 90 SWAP1 06B1 60 PUSH1 0x20 06B3 01 ADD 06B4 90 SWAP1 06B5 92 SWAP3 06B6 91 SWAP2 06B7 90 SWAP1 06B8 80 DUP1 06B9 35 CALLDATALOAD 06BA 90 SWAP1 06BB 60 PUSH1 0x20 06BD 01 ADD 06BE 90 SWAP1 06BF 92 SWAP3 06C0 91 SWAP2 06C1 90 SWAP1 06C2 50 POP 06C3 50 POP 06C4 50 POP 06C5 61 PUSH2 0x1651 06C8 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @0695 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @06B5 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @06BF stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1651 label_06C9: // Incoming return from call to 0x0673 at 0x066E 06C9 5B JUMPDEST 06CA 00 *STOP // Stack delta = +0 // Outputs[1] { @06CA stop(); } // Block terminates label_06CB: // Incoming jump from 0x0144, if 0x4f6ccce7 == stack[-1] // Inputs[1] { @06CC msg.value } 06CB 5B JUMPDEST 06CC 34 CALLVALUE 06CD 80 DUP1 06CE 15 ISZERO 06CF 61 PUSH2 0x06d7 06D2 57 *JUMPI // Stack delta = +1 // Outputs[1] { @06CC stack[0] = msg.value } // Block ends with conditional jump to 0x06d7, if !msg.value label_06D3: // Incoming jump from 0x06D2, if not !msg.value // Inputs[1] { @06D6 memory[0x00:0x00] } 06D3 60 PUSH1 0x00 06D5 80 DUP1 06D6 FD *REVERT // Stack delta = +0 // Outputs[1] { @06D6 revert(memory[0x00:0x00]); } // Block terminates label_06D7: // Incoming jump from 0x06D2, if !msg.value // Inputs[1] { @06DF msg.data.length } 06D7 5B JUMPDEST 06D8 50 POP 06D9 61 PUSH2 0x0704 06DC 60 PUSH1 0x04 06DE 80 DUP1 06DF 36 CALLDATASIZE 06E0 03 SUB 06E1 60 PUSH1 0x20 06E3 81 DUP2 06E4 10 LT 06E5 15 ISZERO 06E6 61 PUSH2 0x06ee 06E9 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @06D9 stack[-1] = 0x0704 // @06DC stack[0] = 0x04 // @06E0 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x06ee, returns to 0x0704, if !(msg.data.length - 0x04 < 0x20) label_06EA: // Incoming jump from 0x06E9, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @06ED memory[0x00:0x00] } 06EA 60 PUSH1 0x00 06EC 80 DUP1 06ED FD *REVERT // Stack delta = +0 // Outputs[1] { @06ED revert(memory[0x00:0x00]); } // Block terminates label_06EE: // Incoming call from 0x06E9, returns to 0x0704, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @06EF stack[-2] // @06F0 stack[-1] // @06F4 msg.data[stack[-2]:stack[-2] + 0x20] // } 06EE 5B JUMPDEST 06EF 81 DUP2 06F0 01 ADD 06F1 90 SWAP1 06F2 80 DUP1 06F3 80 DUP1 06F4 35 CALLDATALOAD 06F5 90 SWAP1 06F6 60 PUSH1 0x20 06F8 01 ADD 06F9 90 SWAP1 06FA 92 SWAP3 06FB 91 SWAP2 06FC 90 SWAP1 06FD 50 POP 06FE 50 POP 06FF 50 POP 0700 61 PUSH2 0x1671 0703 56 *JUMP // Stack delta = -1 // Outputs[1] { @06FA stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1671 label_0704: // Incoming return from call to 0x06EE at 0x06E9 // Inputs[4] // { // @0707 memory[0x40:0x60] // @0709 stack[-1] // @0714 memory[0x40:0x60] // @0719 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0704 5B JUMPDEST 0705 60 PUSH1 0x40 0707 51 MLOAD 0708 80 DUP1 0709 82 DUP3 070A 81 DUP2 070B 52 MSTORE 070C 60 PUSH1 0x20 070E 01 ADD 070F 91 SWAP2 0710 50 POP 0711 50 POP 0712 60 PUSH1 0x40 0714 51 MLOAD 0715 80 DUP1 0716 91 SWAP2 0717 03 SUB 0718 90 SWAP1 0719 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @070B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0719 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_071A: // Incoming jump from 0x014F, if 0x55f804b3 == stack[-1] // Inputs[1] { @071B msg.value } 071A 5B JUMPDEST 071B 34 CALLVALUE 071C 80 DUP1 071D 15 ISZERO 071E 61 PUSH2 0x0726 0721 57 *JUMPI // Stack delta = +1 // Outputs[1] { @071B stack[0] = msg.value } // Block ends with conditional jump to 0x0726, if !msg.value label_0722: // Incoming jump from 0x0721, if not !msg.value // Inputs[1] { @0725 memory[0x00:0x00] } 0722 60 PUSH1 0x00 0724 80 DUP1 0725 FD *REVERT // Stack delta = +0 // Outputs[1] { @0725 revert(memory[0x00:0x00]); } // Block terminates label_0726: // Incoming jump from 0x0721, if !msg.value // Inputs[1] { @072E msg.data.length } 0726 5B JUMPDEST 0727 50 POP 0728 61 PUSH2 0x07e0 072B 60 PUSH1 0x04 072D 80 DUP1 072E 36 CALLDATASIZE 072F 03 SUB 0730 60 PUSH1 0x20 0732 81 DUP2 0733 10 LT 0734 15 ISZERO 0735 61 PUSH2 0x073d 0738 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0728 stack[-1] = 0x07e0 // @072B stack[0] = 0x04 // @072F stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x073d, returns to 0x07E0, if !(msg.data.length - 0x04 < 0x20) label_0739: // Incoming jump from 0x0738, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @073C memory[0x00:0x00] } 0739 60 PUSH1 0x00 073B 80 DUP1 073C FD *REVERT // Stack delta = +0 // Outputs[1] { @073C revert(memory[0x00:0x00]); } // Block terminates label_073D: // Incoming call from 0x0738, returns to 0x07E0, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @073E stack[-2] // @073F stack[-1] // @0743 msg.data[stack[-2]:stack[-2] + 0x20] // } 073D 5B JUMPDEST 073E 81 DUP2 073F 01 ADD 0740 90 SWAP1 0741 80 DUP1 0742 80 DUP1 0743 35 CALLDATALOAD 0744 90 SWAP1 0745 60 PUSH1 0x20 0747 01 ADD 0748 90 SWAP1 0749 64 PUSH5 0x0100000000 074F 81 DUP2 0750 11 GT 0751 15 ISZERO 0752 61 PUSH2 0x075a 0755 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @0740 stack[-1] = stack[-2] // @0740 stack[-2] = stack[-2] + stack[-1] // @0748 stack[1] = msg.data[stack[-2]:stack[-2] + 0x20] // @0748 stack[0] = 0x20 + stack[-2] // } // Block ends with conditional jump to 0x075a, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) label_0756: // Incoming jump from 0x0755, if not !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @0759 memory[0x00:0x00] } 0756 60 PUSH1 0x00 0758 80 DUP1 0759 FD *REVERT // Stack delta = +0 // Outputs[1] { @0759 revert(memory[0x00:0x00]); } // Block terminates label_075A: // Incoming jump from 0x0755, if !(msg.data[stack[-2]:stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @075B stack[-3] // @075C stack[-1] // @075D stack[-4] // } 075A 5B JUMPDEST 075B 82 DUP3 075C 01 ADD 075D 83 DUP4 075E 60 PUSH1 0x20 0760 82 DUP3 0761 01 ADD 0762 11 GT 0763 15 ISZERO 0764 61 PUSH2 0x076c 0767 57 *JUMPI // Stack delta = +0 // Outputs[1] { @075C stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x076c, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0768: // Incoming jump from 0x0767, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @076B memory[0x00:0x00] } 0768 60 PUSH1 0x00 076A 80 DUP1 076B FD *REVERT // Stack delta = +0 // Outputs[1] { @076B revert(memory[0x00:0x00]); } // Block terminates label_076C: // Incoming jump from 0x0767, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @076D stack[-1] // @076E msg.data[stack[-1]:stack[-1] + 0x20] // @0773 stack[-2] // @0774 stack[-4] // } 076C 5B JUMPDEST 076D 80 DUP1 076E 35 CALLDATALOAD 076F 90 SWAP1 0770 60 PUSH1 0x20 0772 01 ADD 0773 91 SWAP2 0774 84 DUP5 0775 60 PUSH1 0x01 0777 83 DUP4 0778 02 MUL 0779 84 DUP5 077A 01 ADD 077B 11 GT 077C 64 PUSH5 0x0100000000 0782 83 DUP4 0783 11 GT 0784 17 OR 0785 15 ISZERO 0786 61 PUSH2 0x078e 0789 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @076F stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0773 stack[0] = stack[-2] // @0773 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x078e, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_078A: // Incoming jump from 0x0789, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @078D memory[0x00:0x00] } 078A 60 PUSH1 0x00 078C 80 DUP1 078D FD *REVERT // Stack delta = +0 // Outputs[1] { @078D revert(memory[0x00:0x00]); } // Block terminates label_078E: // Incoming jump from 0x0789, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @078F stack[-1] // @078F stack[-3] // @0790 stack[-2] // @07A1 memory[0x40:0x60] // @07B8 msg.data[stack[-3]:stack[-3] + stack[-2]] // @07D4 stack[-4] // @07D5 stack[-5] // } 078E 5B JUMPDEST 078F 91 SWAP2 0790 90 SWAP1 0791 80 DUP1 0792 80 DUP1 0793 60 PUSH1 0x1f 0795 01 ADD 0796 60 PUSH1 0x20 0798 80 DUP1 0799 91 SWAP2 079A 04 DIV 079B 02 MUL 079C 60 PUSH1 0x20 079E 01 ADD 079F 60 PUSH1 0x40 07A1 51 MLOAD 07A2 90 SWAP1 07A3 81 DUP2 07A4 01 ADD 07A5 60 PUSH1 0x40 07A7 52 MSTORE 07A8 80 DUP1 07A9 93 SWAP4 07AA 92 SWAP3 07AB 91 SWAP2 07AC 90 SWAP1 07AD 81 DUP2 07AE 81 DUP2 07AF 52 MSTORE 07B0 60 PUSH1 0x20 07B2 01 ADD 07B3 83 DUP4 07B4 83 DUP4 07B5 80 DUP1 07B6 82 DUP3 07B7 84 DUP5 07B8 37 CALLDATACOPY 07B9 60 PUSH1 0x00 07BB 81 DUP2 07BC 84 DUP5 07BD 01 ADD 07BE 52 MSTORE 07BF 60 PUSH1 0x1f 07C1 19 NOT 07C2 60 PUSH1 0x1f 07C4 82 DUP3 07C5 01 ADD 07C6 16 AND 07C7 90 SWAP1 07C8 50 POP 07C9 80 DUP1 07CA 83 DUP4 07CB 01 ADD 07CC 92 SWAP3 07CD 50 POP 07CE 50 POP 07CF 50 POP 07D0 50 POP 07D1 50 POP 07D2 50 POP 07D3 50 POP 07D4 91 SWAP2 07D5 92 SWAP3 07D6 91 SWAP2 07D7 92 SWAP3 07D8 90 SWAP1 07D9 50 POP 07DA 50 POP 07DB 50 POP 07DC 61 PUSH2 0x1694 07DF 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @07A7 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @07AF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @07B8 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @07BE memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @07D7 stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x1694 label_07E0: // Incoming return from call to 0x073D at 0x0738 07E0 5B JUMPDEST 07E1 00 *STOP // Stack delta = +0 // Outputs[1] { @07E1 stop(); } // Block terminates label_07E2: // Incoming jump from 0x015A, if 0x571dff3b == stack[-1] // Inputs[1] { @07E3 msg.value } 07E2 5B JUMPDEST 07E3 34 CALLVALUE 07E4 80 DUP1 07E5 15 ISZERO 07E6 61 PUSH2 0x07ee 07E9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @07E3 stack[0] = msg.value } // Block ends with conditional jump to 0x07ee, if !msg.value label_07EA: // Incoming jump from 0x07E9, if not !msg.value // Inputs[1] { @07ED memory[0x00:0x00] } 07EA 60 PUSH1 0x00 07EC 80 DUP1 07ED FD *REVERT // Stack delta = +0 // Outputs[1] { @07ED revert(memory[0x00:0x00]); } // Block terminates label_07EE: // Incoming jump from 0x07E9, if !msg.value 07EE 5B JUMPDEST 07EF 50 POP 07F0 61 PUSH2 0x07f7 07F3 61 PUSH2 0x174f 07F6 56 *JUMP // Stack delta = +0 // Outputs[1] { @07F0 stack[-1] = 0x07f7 } // Block ends with call to 0x174f, returns to 0x07F7 label_07F7: // Incoming return from call to 0x174F at 0x07F6 // Inputs[4] // { // @07FA memory[0x40:0x60] // @07FC stack[-1] // @0807 memory[0x40:0x60] // @080C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 07F7 5B JUMPDEST 07F8 60 PUSH1 0x40 07FA 51 MLOAD 07FB 80 DUP1 07FC 82 DUP3 07FD 81 DUP2 07FE 52 MSTORE 07FF 60 PUSH1 0x20 0801 01 ADD 0802 91 SWAP2 0803 50 POP 0804 50 POP 0805 60 PUSH1 0x40 0807 51 MLOAD 0808 80 DUP1 0809 91 SWAP2 080A 03 SUB 080B 90 SWAP1 080C F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @07FE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @080C return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_080D: // Incoming jump from 0x0165, if 0x607e20e3 == stack[-1] // Inputs[1] { @080E msg.value } 080D 5B JUMPDEST 080E 34 CALLVALUE 080F 80 DUP1 0810 15 ISZERO 0811 61 PUSH2 0x0819 0814 57 *JUMPI // Stack delta = +1 // Outputs[1] { @080E stack[0] = msg.value } // Block ends with conditional jump to 0x0819, if !msg.value label_0815: // Incoming jump from 0x0814, if not !msg.value // Inputs[1] { @0818 memory[0x00:0x00] } 0815 60 PUSH1 0x00 0817 80 DUP1 0818 FD *REVERT // Stack delta = +0 // Outputs[1] { @0818 revert(memory[0x00:0x00]); } // Block terminates label_0819: // Incoming jump from 0x0814, if !msg.value 0819 5B JUMPDEST 081A 50 POP 081B 61 PUSH2 0x0822 081E 61 PUSH2 0x1754 0821 56 *JUMP // Stack delta = +0 // Outputs[1] { @081B stack[-1] = 0x0822 } // Block ends with call to 0x1754, returns to 0x0822 label_0822: // Incoming return from call to 0x1754 at 0x0821 // Inputs[4] // { // @0825 memory[0x40:0x60] // @0830 stack[-1] // @0833 memory[stack[-1]:stack[-1] + 0x20] // @083C memory[stack[-1]:stack[-1] + 0x20] // } 0822 5B JUMPDEST 0823 60 PUSH1 0x40 0825 51 MLOAD 0826 80 DUP1 0827 80 DUP1 0828 60 PUSH1 0x20 082A 01 ADD 082B 82 DUP3 082C 81 DUP2 082D 03 SUB 082E 82 DUP3 082F 52 MSTORE 0830 83 DUP4 0831 81 DUP2 0832 81 DUP2 0833 51 MLOAD 0834 81 DUP2 0835 52 MSTORE 0836 60 PUSH1 0x20 0838 01 ADD 0839 91 SWAP2 083A 50 POP 083B 80 DUP1 083C 51 MLOAD 083D 90 SWAP1 083E 60 PUSH1 0x20 0840 01 ADD 0841 90 SWAP1 0842 80 DUP1 0843 83 DUP4 0844 83 DUP4 0845 60 PUSH1 0x00 0847 5B JUMPDEST 0848 83 DUP4 0849 81 DUP2 084A 10 LT 084B 15 ISZERO 084C 61 PUSH2 0x0862 084F 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @0825 stack[0] = memory[0x40:0x60] // @0826 stack[1] = memory[0x40:0x60] // @082F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0835 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0839 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @0841 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @0841 stack[3] = 0x20 + stack[-1] // @0842 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @0843 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @0844 stack[7] = 0x20 + stack[-1] // @0845 stack[8] = 0x00 // } // Block ends with conditional jump to 0x0862, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0850: // Incoming jump from 0x084F, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x084F, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @0850 stack[-1] // @0851 stack[-2] // @0853 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0855 stack[-3] // } 0850 80 DUP1 0851 82 DUP3 0852 01 ADD 0853 51 MLOAD 0854 81 DUP2 0855 84 DUP5 0856 01 ADD 0857 52 MSTORE 0858 60 PUSH1 0x20 085A 81 DUP2 085B 01 ADD 085C 90 SWAP1 085D 50 POP 085E 61 PUSH2 0x0847 0861 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0857 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @085C stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0847 label_0862: // Incoming jump from 0x084F, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x084F, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @0867 stack[-5] // @0867 stack[-6] // @0869 stack[-7] // } 0862 5B JUMPDEST 0863 50 POP 0864 50 POP 0865 50 POP 0866 50 POP 0867 90 SWAP1 0868 50 POP 0869 90 SWAP1 086A 81 DUP2 086B 01 ADD 086C 90 SWAP1 086D 60 PUSH1 0x1f 086F 16 AND 0870 80 DUP1 0871 15 ISZERO 0872 61 PUSH2 0x088f 0875 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @086C stack[-7] = stack[-5] + stack[-7] // @086F stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x088f, if !(0x1f & stack[-5]) label_0876: // Incoming jump from 0x0875, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0876 stack[-1] // @0877 stack[-2] // @087A memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0891 stack[-5] // @0897 memory[0x40:0x60] // @089C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0876 80 DUP1 0877 82 DUP3 0878 03 SUB 0879 80 DUP1 087A 51 MLOAD 087B 60 PUSH1 0x01 087D 83 DUP4 087E 60 PUSH1 0x20 0880 03 SUB 0881 61 PUSH2 0x0100 0884 0A EXP 0885 03 SUB 0886 19 NOT 0887 16 AND 0888 81 DUP2 0889 52 MSTORE 088A 60 PUSH1 0x20 088C 01 ADD 088D 91 SWAP2 088E 50 POP 088F 5B JUMPDEST 0890 50 POP 0891 92 SWAP3 0892 50 POP 0893 50 POP 0894 50 POP 0895 60 PUSH1 0x40 0897 51 MLOAD 0898 80 DUP1 0899 91 SWAP2 089A 03 SUB 089B 90 SWAP1 089C F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0889 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @089C return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_089D: // Incoming jump from 0x0170, if 0x6352211e == stack[-1] // Inputs[1] { @089E msg.value } 089D 5B JUMPDEST 089E 34 CALLVALUE 089F 80 DUP1 08A0 15 ISZERO 08A1 61 PUSH2 0x08a9 08A4 57 *JUMPI // Stack delta = +1 // Outputs[1] { @089E stack[0] = msg.value } // Block ends with conditional jump to 0x08a9, if !msg.value label_08A5: // Incoming jump from 0x08A4, if not !msg.value // Inputs[1] { @08A8 memory[0x00:0x00] } 08A5 60 PUSH1 0x00 08A7 80 DUP1 08A8 FD *REVERT // Stack delta = +0 // Outputs[1] { @08A8 revert(memory[0x00:0x00]); } // Block terminates label_08A9: // Incoming jump from 0x08A4, if !msg.value // Inputs[1] { @08B1 msg.data.length } 08A9 5B JUMPDEST 08AA 50 POP 08AB 61 PUSH2 0x08d6 08AE 60 PUSH1 0x04 08B0 80 DUP1 08B1 36 CALLDATASIZE 08B2 03 SUB 08B3 60 PUSH1 0x20 08B5 81 DUP2 08B6 10 LT 08B7 15 ISZERO 08B8 61 PUSH2 0x08c0 08BB 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @08AB stack[-1] = 0x08d6 // @08AE stack[0] = 0x04 // @08B2 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x08c0, returns to 0x08D6, if !(msg.data.length - 0x04 < 0x20) label_08BC: // Incoming jump from 0x08BB, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @08BF memory[0x00:0x00] } 08BC 60 PUSH1 0x00 08BE 80 DUP1 08BF FD *REVERT // Stack delta = +0 // Outputs[1] { @08BF revert(memory[0x00:0x00]); } // Block terminates label_08C0: // Incoming call from 0x08BB, returns to 0x08D6, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @08C1 stack[-2] // @08C2 stack[-1] // @08C6 msg.data[stack[-2]:stack[-2] + 0x20] // } 08C0 5B JUMPDEST 08C1 81 DUP2 08C2 01 ADD 08C3 90 SWAP1 08C4 80 DUP1 08C5 80 DUP1 08C6 35 CALLDATALOAD 08C7 90 SWAP1 08C8 60 PUSH1 0x20 08CA 01 ADD 08CB 90 SWAP1 08CC 92 SWAP3 08CD 91 SWAP2 08CE 90 SWAP1 08CF 50 POP 08D0 50 POP 08D1 50 POP 08D2 61 PUSH2 0x17f2 08D5 56 *JUMP // Stack delta = -1 // Outputs[1] { @08CC stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x17f2 label_08D6: // Incoming return from call to 0x08C0 at 0x08BB // Inputs[4] // { // @08D9 memory[0x40:0x60] // @08DB stack[-1] // @08FC memory[0x40:0x60] // @0901 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 08D6 5B JUMPDEST 08D7 60 PUSH1 0x40 08D9 51 MLOAD 08DA 80 DUP1 08DB 82 DUP3 08DC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 08F1 16 AND 08F2 81 DUP2 08F3 52 MSTORE 08F4 60 PUSH1 0x20 08F6 01 ADD 08F7 91 SWAP2 08F8 50 POP 08F9 50 POP 08FA 60 PUSH1 0x40 08FC 51 MLOAD 08FD 80 DUP1 08FE 91 SWAP2 08FF 03 SUB 0900 90 SWAP1 0901 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @08F3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0901 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0902: // Incoming jump from 0x00FD, if 0x6c0360eb == stack[-1] // Inputs[1] { @0903 msg.value } 0902 5B JUMPDEST 0903 34 CALLVALUE 0904 80 DUP1 0905 15 ISZERO 0906 61 PUSH2 0x090e 0909 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0903 stack[0] = msg.value } // Block ends with conditional jump to 0x090e, if !msg.value label_090A: // Incoming jump from 0x0909, if not !msg.value // Inputs[1] { @090D memory[0x00:0x00] } 090A 60 PUSH1 0x00 090C 80 DUP1 090D FD *REVERT // Stack delta = +0 // Outputs[1] { @090D revert(memory[0x00:0x00]); } // Block terminates label_090E: // Incoming jump from 0x0909, if !msg.value 090E 5B JUMPDEST 090F 50 POP 0910 61 PUSH2 0x0917 0913 61 PUSH2 0x1829 0916 56 *JUMP // Stack delta = +0 // Outputs[1] { @0910 stack[-1] = 0x0917 } // Block ends with call to 0x1829, returns to 0x0917 label_0917: // Incoming return from call to 0x1829 at 0x0916 // Inputs[4] // { // @091A memory[0x40:0x60] // @0925 stack[-1] // @0928 memory[stack[-1]:stack[-1] + 0x20] // @0931 memory[stack[-1]:stack[-1] + 0x20] // } 0917 5B JUMPDEST 0918 60 PUSH1 0x40 091A 51 MLOAD 091B 80 DUP1 091C 80 DUP1 091D 60 PUSH1 0x20 091F 01 ADD 0920 82 DUP3 0921 81 DUP2 0922 03 SUB 0923 82 DUP3 0924 52 MSTORE 0925 83 DUP4 0926 81 DUP2 0927 81 DUP2 0928 51 MLOAD 0929 81 DUP2 092A 52 MSTORE 092B 60 PUSH1 0x20 092D 01 ADD 092E 91 SWAP2 092F 50 POP 0930 80 DUP1 0931 51 MLOAD 0932 90 SWAP1 0933 60 PUSH1 0x20 0935 01 ADD 0936 90 SWAP1 0937 80 DUP1 0938 83 DUP4 0939 83 DUP4 093A 60 PUSH1 0x00 093C 5B JUMPDEST 093D 83 DUP4 093E 81 DUP2 093F 10 LT 0940 15 ISZERO 0941 61 PUSH2 0x0957 0944 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @091A stack[0] = memory[0x40:0x60] // @091B stack[1] = memory[0x40:0x60] // @0924 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @092A memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @092E stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @0936 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @0936 stack[3] = 0x20 + stack[-1] // @0937 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @0938 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @0939 stack[7] = 0x20 + stack[-1] // @093A stack[8] = 0x00 // } // Block ends with conditional jump to 0x0957, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0945: // Incoming jump from 0x0944, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0944, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @0945 stack[-1] // @0946 stack[-2] // @0948 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @094A stack[-3] // } 0945 80 DUP1 0946 82 DUP3 0947 01 ADD 0948 51 MLOAD 0949 81 DUP2 094A 84 DUP5 094B 01 ADD 094C 52 MSTORE 094D 60 PUSH1 0x20 094F 81 DUP2 0950 01 ADD 0951 90 SWAP1 0952 50 POP 0953 61 PUSH2 0x093c 0956 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @094C memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0951 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x093c label_0957: // Incoming jump from 0x0944, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x0944, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @095C stack[-6] // @095C stack[-5] // @095E stack[-7] // } 0957 5B JUMPDEST 0958 50 POP 0959 50 POP 095A 50 POP 095B 50 POP 095C 90 SWAP1 095D 50 POP 095E 90 SWAP1 095F 81 DUP2 0960 01 ADD 0961 90 SWAP1 0962 60 PUSH1 0x1f 0964 16 AND 0965 80 DUP1 0966 15 ISZERO 0967 61 PUSH2 0x0984 096A 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0961 stack[-7] = stack[-5] + stack[-7] // @0964 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0984, if !(0x1f & stack[-5]) label_096B: // Incoming jump from 0x096A, if not !(0x1f & stack[-5]) // Inputs[6] // { // @096B stack[-1] // @096C stack[-2] // @096F memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0986 stack[-5] // @098C memory[0x40:0x60] // @0991 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 096B 80 DUP1 096C 82 DUP3 096D 03 SUB 096E 80 DUP1 096F 51 MLOAD 0970 60 PUSH1 0x01 0972 83 DUP4 0973 60 PUSH1 0x20 0975 03 SUB 0976 61 PUSH2 0x0100 0979 0A EXP 097A 03 SUB 097B 19 NOT 097C 16 AND 097D 81 DUP2 097E 52 MSTORE 097F 60 PUSH1 0x20 0981 01 ADD 0982 91 SWAP2 0983 50 POP 0984 5B JUMPDEST 0985 50 POP 0986 92 SWAP3 0987 50 POP 0988 50 POP 0989 50 POP 098A 60 PUSH1 0x40 098C 51 MLOAD 098D 80 DUP1 098E 91 SWAP2 098F 03 SUB 0990 90 SWAP1 0991 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @097E memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0991 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0992: // Incoming jump from 0x0108, if 0x70a08231 == stack[-1] // Inputs[1] { @0993 msg.value } 0992 5B JUMPDEST 0993 34 CALLVALUE 0994 80 DUP1 0995 15 ISZERO 0996 61 PUSH2 0x099e 0999 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0993 stack[0] = msg.value } // Block ends with conditional jump to 0x099e, if !msg.value label_099A: // Incoming jump from 0x0999, if not !msg.value // Inputs[1] { @099D memory[0x00:0x00] } 099A 60 PUSH1 0x00 099C 80 DUP1 099D FD *REVERT // Stack delta = +0 // Outputs[1] { @099D revert(memory[0x00:0x00]); } // Block terminates label_099E: // Incoming jump from 0x0999, if !msg.value // Inputs[1] { @09A6 msg.data.length } 099E 5B JUMPDEST 099F 50 POP 09A0 61 PUSH2 0x09e1 09A3 60 PUSH1 0x04 09A5 80 DUP1 09A6 36 CALLDATASIZE 09A7 03 SUB 09A8 60 PUSH1 0x20 09AA 81 DUP2 09AB 10 LT 09AC 15 ISZERO 09AD 61 PUSH2 0x09b5 09B0 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @09A0 stack[-1] = 0x09e1 // @09A3 stack[0] = 0x04 // @09A7 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x09b5, returns to 0x09E1, if !(msg.data.length - 0x04 < 0x20) label_09B1: // Incoming jump from 0x09B0, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @09B4 memory[0x00:0x00] } 09B1 60 PUSH1 0x00 09B3 80 DUP1 09B4 FD *REVERT // Stack delta = +0 // Outputs[1] { @09B4 revert(memory[0x00:0x00]); } // Block terminates label_09B5: // Incoming call from 0x09B0, returns to 0x09E1, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @09B6 stack[-2] // @09B7 stack[-1] // @09BB msg.data[stack[-2]:stack[-2] + 0x20] // } 09B5 5B JUMPDEST 09B6 81 DUP2 09B7 01 ADD 09B8 90 SWAP1 09B9 80 DUP1 09BA 80 DUP1 09BB 35 CALLDATALOAD 09BC 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 09D1 16 AND 09D2 90 SWAP1 09D3 60 PUSH1 0x20 09D5 01 ADD 09D6 90 SWAP1 09D7 92 SWAP3 09D8 91 SWAP2 09D9 90 SWAP1 09DA 50 POP 09DB 50 POP 09DC 50 POP 09DD 61 PUSH2 0x18cb 09E0 56 *JUMP // Stack delta = -1 // Outputs[1] { @09D7 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x18cb label_09E1: // Incoming return from call to 0x09B5 at 0x09B0 // Inputs[4] // { // @09E4 memory[0x40:0x60] // @09E6 stack[-1] // @09F1 memory[0x40:0x60] // @09F6 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 09E1 5B JUMPDEST 09E2 60 PUSH1 0x40 09E4 51 MLOAD 09E5 80 DUP1 09E6 82 DUP3 09E7 81 DUP2 09E8 52 MSTORE 09E9 60 PUSH1 0x20 09EB 01 ADD 09EC 91 SWAP2 09ED 50 POP 09EE 50 POP 09EF 60 PUSH1 0x40 09F1 51 MLOAD 09F2 80 DUP1 09F3 91 SWAP2 09F4 03 SUB 09F5 90 SWAP1 09F6 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @09E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @09F6 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_09F7: // Incoming jump from 0x0113, if 0x715018a6 == stack[-1] // Inputs[1] { @09F8 msg.value } 09F7 5B JUMPDEST 09F8 34 CALLVALUE 09F9 80 DUP1 09FA 15 ISZERO 09FB 61 PUSH2 0x0a03 09FE 57 *JUMPI // Stack delta = +1 // Outputs[1] { @09F8 stack[0] = msg.value } // Block ends with conditional jump to 0x0a03, if !msg.value label_09FF: // Incoming jump from 0x09FE, if not !msg.value // Inputs[1] { @0A02 memory[0x00:0x00] } 09FF 60 PUSH1 0x00 0A01 80 DUP1 0A02 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A02 revert(memory[0x00:0x00]); } // Block terminates label_0A03: // Incoming jump from 0x09FE, if !msg.value 0A03 5B JUMPDEST 0A04 50 POP 0A05 61 PUSH2 0x0a0c 0A08 61 PUSH2 0x19a0 0A0B 56 *JUMP // Stack delta = +0 // Outputs[1] { @0A05 stack[-1] = 0x0a0c } // Block ends with call to 0x19a0, returns to 0x0A0C label_0A0C: // Incoming return from call to 0x19A0 at 0x0A0B 0A0C 5B JUMPDEST 0A0D 00 *STOP // Stack delta = +0 // Outputs[1] { @0A0D stop(); } // Block terminates label_0A0E: // Incoming jump from 0x011E, if 0x7a3f451e == stack[-1] // Inputs[1] { @0A0F msg.value } 0A0E 5B JUMPDEST 0A0F 34 CALLVALUE 0A10 80 DUP1 0A11 15 ISZERO 0A12 61 PUSH2 0x0a1a 0A15 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A0F stack[0] = msg.value } // Block ends with conditional jump to 0x0a1a, if !msg.value label_0A16: // Incoming jump from 0x0A15, if not !msg.value // Inputs[1] { @0A19 memory[0x00:0x00] } 0A16 60 PUSH1 0x00 0A18 80 DUP1 0A19 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A19 revert(memory[0x00:0x00]); } // Block terminates label_0A1A: // Incoming jump from 0x0A15, if !msg.value 0A1A 5B JUMPDEST 0A1B 50 POP 0A1C 61 PUSH2 0x0a23 0A1F 61 PUSH2 0x1b10 0A22 56 *JUMP // Stack delta = +0 // Outputs[1] { @0A1C stack[-1] = 0x0a23 } // Block ends with call to 0x1b10, returns to 0x0A23 label_0A23: // Incoming return from call to 0x1B10 at 0x0A22 // Inputs[4] // { // @0A26 memory[0x40:0x60] // @0A28 stack[-1] // @0A33 memory[0x40:0x60] // @0A38 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0A23 5B JUMPDEST 0A24 60 PUSH1 0x40 0A26 51 MLOAD 0A27 80 DUP1 0A28 82 DUP3 0A29 81 DUP2 0A2A 52 MSTORE 0A2B 60 PUSH1 0x20 0A2D 01 ADD 0A2E 91 SWAP2 0A2F 50 POP 0A30 50 POP 0A31 60 PUSH1 0x40 0A33 51 MLOAD 0A34 80 DUP1 0A35 91 SWAP2 0A36 03 SUB 0A37 90 SWAP1 0A38 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0A2A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0A38 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0A39: // Incoming jump from 0x00C1, if 0x7d17fcbe == stack[-1] // Inputs[1] { @0A3A msg.value } 0A39 5B JUMPDEST 0A3A 34 CALLVALUE 0A3B 80 DUP1 0A3C 15 ISZERO 0A3D 61 PUSH2 0x0a45 0A40 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A3A stack[0] = msg.value } // Block ends with conditional jump to 0x0a45, if !msg.value label_0A41: // Incoming jump from 0x0A40, if not !msg.value // Inputs[1] { @0A44 memory[0x00:0x00] } 0A41 60 PUSH1 0x00 0A43 80 DUP1 0A44 FD *REVERT // Stack delta = +0 // Outputs[1] { @0A44 revert(memory[0x00:0x00]); } // Block terminates label_0A45: // Incoming jump from 0x0A40, if !msg.value 0A45 5B JUMPDEST 0A46 50 POP 0A47 61 PUSH2 0x0a4e 0A4A 61 PUSH2 0x1b1c 0A4D 56 *JUMP // Stack delta = +0 // Outputs[1] { @0A47 stack[-1] = 0x0a4e } // Block ends with call to 0x1b1c, returns to 0x0A4E label_0A4E: // Incoming return from call to 0x1B1C at 0x0A4D 0A4E 5B JUMPDEST 0A4F 00 *STOP // Stack delta = +0 // Outputs[1] { @0A4F stop(); } // Block terminates label_0A50: // Incoming jump from 0x00CC, if 0x8da5cb5b == stack[-1] // Inputs[1] { @0A51 msg.value } 0A50 5B JUMPDEST 0A51 34 CALLVALUE 0A52 80 DUP1 0A53 15 ISZERO 0A54 61 PUSH2 0x0a5c 0A57 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A51 stack[0] = msg.value } // Block ends with conditional jump to 0x0a5c, if !msg.value label_0A58: // Incoming jump from 0x0A57, if not !msg.value // Inputs[1] { @0A5B memory[0x00:0x00] } 0A58 60 PUSH1 0x00 0A5A 80 DUP1 0A5B FD *REVERT // Stack delta = +0 // Outputs[1] { @0A5B revert(memory[0x00:0x00]); } // Block terminates label_0A5C: // Incoming jump from 0x0A57, if !msg.value 0A5C 5B JUMPDEST 0A5D 50 POP 0A5E 61 PUSH2 0x0a65 0A61 61 PUSH2 0x1c4c 0A64 56 *JUMP // Stack delta = +0 // Outputs[1] { @0A5E stack[-1] = 0x0a65 } // Block ends with call to 0x1c4c, returns to 0x0A65 label_0A65: // Incoming return from call to 0x1C4C at 0x0A64 // Inputs[4] // { // @0A68 memory[0x40:0x60] // @0A6A stack[-1] // @0A8B memory[0x40:0x60] // @0A90 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0A65 5B JUMPDEST 0A66 60 PUSH1 0x40 0A68 51 MLOAD 0A69 80 DUP1 0A6A 82 DUP3 0A6B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0A80 16 AND 0A81 81 DUP2 0A82 52 MSTORE 0A83 60 PUSH1 0x20 0A85 01 ADD 0A86 91 SWAP2 0A87 50 POP 0A88 50 POP 0A89 60 PUSH1 0x40 0A8B 51 MLOAD 0A8C 80 DUP1 0A8D 91 SWAP2 0A8E 03 SUB 0A8F 90 SWAP1 0A90 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0A82 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0A90 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0A91: // Incoming jump from 0x00D7, if 0x95d89b41 == stack[-1] // Inputs[1] { @0A92 msg.value } 0A91 5B JUMPDEST 0A92 34 CALLVALUE 0A93 80 DUP1 0A94 15 ISZERO 0A95 61 PUSH2 0x0a9d 0A98 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0A92 stack[0] = msg.value } // Block ends with conditional jump to 0x0a9d, if !msg.value label_0A99: // Incoming jump from 0x0A98, if not !msg.value // Inputs[1] { @0A9C memory[0x00:0x00] } 0A99 60 PUSH1 0x00 0A9B 80 DUP1 0A9C FD *REVERT // Stack delta = +0 // Outputs[1] { @0A9C revert(memory[0x00:0x00]); } // Block terminates label_0A9D: // Incoming jump from 0x0A98, if !msg.value 0A9D 5B JUMPDEST 0A9E 50 POP 0A9F 61 PUSH2 0x0aa6 0AA2 61 PUSH2 0x1c76 0AA5 56 *JUMP // Stack delta = +0 // Outputs[1] { @0A9F stack[-1] = 0x0aa6 } // Block ends with call to 0x1c76, returns to 0x0AA6 label_0AA6: // Incoming return from call to 0x1C76 at 0x0AA5 // Inputs[4] // { // @0AA9 memory[0x40:0x60] // @0AB4 stack[-1] // @0AB7 memory[stack[-1]:stack[-1] + 0x20] // @0AC0 memory[stack[-1]:stack[-1] + 0x20] // } 0AA6 5B JUMPDEST 0AA7 60 PUSH1 0x40 0AA9 51 MLOAD 0AAA 80 DUP1 0AAB 80 DUP1 0AAC 60 PUSH1 0x20 0AAE 01 ADD 0AAF 82 DUP3 0AB0 81 DUP2 0AB1 03 SUB 0AB2 82 DUP3 0AB3 52 MSTORE 0AB4 83 DUP4 0AB5 81 DUP2 0AB6 81 DUP2 0AB7 51 MLOAD 0AB8 81 DUP2 0AB9 52 MSTORE 0ABA 60 PUSH1 0x20 0ABC 01 ADD 0ABD 91 SWAP2 0ABE 50 POP 0ABF 80 DUP1 0AC0 51 MLOAD 0AC1 90 SWAP1 0AC2 60 PUSH1 0x20 0AC4 01 ADD 0AC5 90 SWAP1 0AC6 80 DUP1 0AC7 83 DUP4 0AC8 83 DUP4 0AC9 60 PUSH1 0x00 0ACB 5B JUMPDEST 0ACC 83 DUP4 0ACD 81 DUP2 0ACE 10 LT 0ACF 15 ISZERO 0AD0 61 PUSH2 0x0ae6 0AD3 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @0AA9 stack[0] = memory[0x40:0x60] // @0AAA stack[1] = memory[0x40:0x60] // @0AB3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0AB9 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0ABD stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @0AC5 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @0AC5 stack[3] = 0x20 + stack[-1] // @0AC6 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @0AC7 stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @0AC8 stack[7] = 0x20 + stack[-1] // @0AC9 stack[8] = 0x00 // } // Block ends with conditional jump to 0x0ae6, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0AD4: // Incoming jump from 0x0AD3, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x0AD3, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @0AD4 stack[-1] // @0AD5 stack[-2] // @0AD7 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0AD9 stack[-3] // } 0AD4 80 DUP1 0AD5 82 DUP3 0AD6 01 ADD 0AD7 51 MLOAD 0AD8 81 DUP2 0AD9 84 DUP5 0ADA 01 ADD 0ADB 52 MSTORE 0ADC 60 PUSH1 0x20 0ADE 81 DUP2 0ADF 01 ADD 0AE0 90 SWAP1 0AE1 50 POP 0AE2 61 PUSH2 0x0acb 0AE5 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0ADB memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0AE0 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0acb label_0AE6: // Incoming jump from 0x0AD3, if !(stack[-1] < stack[-4]) // Incoming jump from 0x0AD3, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @0AEB stack[-6] // @0AEB stack[-5] // @0AED stack[-7] // } 0AE6 5B JUMPDEST 0AE7 50 POP 0AE8 50 POP 0AE9 50 POP 0AEA 50 POP 0AEB 90 SWAP1 0AEC 50 POP 0AED 90 SWAP1 0AEE 81 DUP2 0AEF 01 ADD 0AF0 90 SWAP1 0AF1 60 PUSH1 0x1f 0AF3 16 AND 0AF4 80 DUP1 0AF5 15 ISZERO 0AF6 61 PUSH2 0x0b13 0AF9 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0AF0 stack[-7] = stack[-5] + stack[-7] // @0AF3 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0b13, if !(0x1f & stack[-5]) label_0AFA: // Incoming jump from 0x0AF9, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0AFA stack[-1] // @0AFB stack[-2] // @0AFE memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0B15 stack[-5] // @0B1B memory[0x40:0x60] // @0B20 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0AFA 80 DUP1 0AFB 82 DUP3 0AFC 03 SUB 0AFD 80 DUP1 0AFE 51 MLOAD 0AFF 60 PUSH1 0x01 0B01 83 DUP4 0B02 60 PUSH1 0x20 0B04 03 SUB 0B05 61 PUSH2 0x0100 0B08 0A EXP 0B09 03 SUB 0B0A 19 NOT 0B0B 16 AND 0B0C 81 DUP2 0B0D 52 MSTORE 0B0E 60 PUSH1 0x20 0B10 01 ADD 0B11 91 SWAP2 0B12 50 POP 0B13 5B JUMPDEST 0B14 50 POP 0B15 92 SWAP3 0B16 50 POP 0B17 50 POP 0B18 50 POP 0B19 60 PUSH1 0x40 0B1B 51 MLOAD 0B1C 80 DUP1 0B1D 91 SWAP2 0B1E 03 SUB 0B1F 90 SWAP1 0B20 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0B0D memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0B20 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0B21: // Incoming jump from 0x00E2, if 0xa22cb465 == stack[-1] // Inputs[1] { @0B22 msg.value } 0B21 5B JUMPDEST 0B22 34 CALLVALUE 0B23 80 DUP1 0B24 15 ISZERO 0B25 61 PUSH2 0x0b2d 0B28 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0B22 stack[0] = msg.value } // Block ends with conditional jump to 0x0b2d, if !msg.value label_0B29: // Incoming jump from 0x0B28, if not !msg.value // Inputs[1] { @0B2C memory[0x00:0x00] } 0B29 60 PUSH1 0x00 0B2B 80 DUP1 0B2C FD *REVERT // Stack delta = +0 // Outputs[1] { @0B2C revert(memory[0x00:0x00]); } // Block terminates label_0B2D: // Incoming jump from 0x0B28, if !msg.value // Inputs[1] { @0B35 msg.data.length } 0B2D 5B JUMPDEST 0B2E 50 POP 0B2F 61 PUSH2 0x0b7c 0B32 60 PUSH1 0x04 0B34 80 DUP1 0B35 36 CALLDATASIZE 0B36 03 SUB 0B37 60 PUSH1 0x40 0B39 81 DUP2 0B3A 10 LT 0B3B 15 ISZERO 0B3C 61 PUSH2 0x0b44 0B3F 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0B2F stack[-1] = 0x0b7c // @0B32 stack[0] = 0x04 // @0B36 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0b44, returns to 0x0B7C, if !(msg.data.length - 0x04 < 0x40) label_0B40: // Incoming jump from 0x0B3F, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0B43 memory[0x00:0x00] } 0B40 60 PUSH1 0x00 0B42 80 DUP1 0B43 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B43 revert(memory[0x00:0x00]); } // Block terminates label_0B44: // Incoming call from 0x0B3F, returns to 0x0B7C, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0B45 stack[-2] // @0B46 stack[-1] // @0B4A msg.data[stack[-2]:stack[-2] + 0x20] // @0B6A msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0B44 5B JUMPDEST 0B45 81 DUP2 0B46 01 ADD 0B47 90 SWAP1 0B48 80 DUP1 0B49 80 DUP1 0B4A 35 CALLDATALOAD 0B4B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0B60 16 AND 0B61 90 SWAP1 0B62 60 PUSH1 0x20 0B64 01 ADD 0B65 90 SWAP1 0B66 92 SWAP3 0B67 91 SWAP2 0B68 90 SWAP1 0B69 80 DUP1 0B6A 35 CALLDATALOAD 0B6B 15 ISZERO 0B6C 15 ISZERO 0B6D 90 SWAP1 0B6E 60 PUSH1 0x20 0B70 01 ADD 0B71 90 SWAP1 0B72 92 SWAP3 0B73 91 SWAP2 0B74 90 SWAP1 0B75 50 POP 0B76 50 POP 0B77 50 POP 0B78 61 PUSH2 0x1d18 0B7B 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0B66 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0B72 stack[-1] = !!msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x1d18 label_0B7C: // Incoming return from call to 0x0B44 at 0x0B3F 0B7C 5B JUMPDEST 0B7D 00 *STOP // Stack delta = +0 // Outputs[1] { @0B7D stop(); } // Block terminates label_0B7E: // Incoming jump from 0x00ED, if 0xa723533e == stack[-1] // Inputs[1] { @0B85 msg.data.length } 0B7E 5B JUMPDEST 0B7F 61 PUSH2 0x0baa 0B82 60 PUSH1 0x04 0B84 80 DUP1 0B85 36 CALLDATASIZE 0B86 03 SUB 0B87 60 PUSH1 0x20 0B89 81 DUP2 0B8A 10 LT 0B8B 15 ISZERO 0B8C 61 PUSH2 0x0b94 0B8F 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @0B7F stack[0] = 0x0baa // @0B82 stack[1] = 0x04 // @0B86 stack[2] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0b94, returns to 0x0BAA, if !(msg.data.length - 0x04 < 0x20) label_0B90: // Incoming jump from 0x0B8F, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0B93 memory[0x00:0x00] } 0B90 60 PUSH1 0x00 0B92 80 DUP1 0B93 FD *REVERT // Stack delta = +0 // Outputs[1] { @0B93 revert(memory[0x00:0x00]); } // Block terminates label_0B94: // Incoming call from 0x0B8F, returns to 0x0BAA, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0B95 stack[-2] // @0B96 stack[-1] // @0B9A msg.data[stack[-2]:stack[-2] + 0x20] // } 0B94 5B JUMPDEST 0B95 81 DUP2 0B96 01 ADD 0B97 90 SWAP1 0B98 80 DUP1 0B99 80 DUP1 0B9A 35 CALLDATALOAD 0B9B 90 SWAP1 0B9C 60 PUSH1 0x20 0B9E 01 ADD 0B9F 90 SWAP1 0BA0 92 SWAP3 0BA1 91 SWAP2 0BA2 90 SWAP1 0BA3 50 POP 0BA4 50 POP 0BA5 50 POP 0BA6 61 PUSH2 0x1ece 0BA9 56 *JUMP // Stack delta = -1 // Outputs[1] { @0BA0 stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x1ece label_0BAA: // Incoming return from call to 0x0B94 at 0x0B8F 0BAA 5B JUMPDEST 0BAB 00 *STOP // Stack delta = +0 // Outputs[1] { @0BAB stop(); } // Block terminates label_0BAC: // Incoming jump from 0x007A, if 0xb0f67427 == stack[-1] // Inputs[1] { @0BAD msg.value } 0BAC 5B JUMPDEST 0BAD 34 CALLVALUE 0BAE 80 DUP1 0BAF 15 ISZERO 0BB0 61 PUSH2 0x0bb8 0BB3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0BAD stack[0] = msg.value } // Block ends with conditional jump to 0x0bb8, if !msg.value label_0BB4: // Incoming jump from 0x0BB3, if not !msg.value // Inputs[1] { @0BB7 memory[0x00:0x00] } 0BB4 60 PUSH1 0x00 0BB6 80 DUP1 0BB7 FD *REVERT // Stack delta = +0 // Outputs[1] { @0BB7 revert(memory[0x00:0x00]); } // Block terminates label_0BB8: // Incoming jump from 0x0BB3, if !msg.value 0BB8 5B JUMPDEST 0BB9 50 POP 0BBA 61 PUSH2 0x0bc1 0BBD 61 PUSH2 0x2127 0BC0 56 *JUMP // Stack delta = +0 // Outputs[1] { @0BBA stack[-1] = 0x0bc1 } // Block ends with call to 0x2127, returns to 0x0BC1 label_0BC1: // Incoming return from call to 0x2127 at 0x0BC0 0BC1 5B JUMPDEST 0BC2 00 *STOP // Stack delta = +0 // Outputs[1] { @0BC2 stop(); } // Block terminates label_0BC3: // Incoming jump from 0x0085, if 0xb88d4fde == stack[-1] // Inputs[1] { @0BC4 msg.value } 0BC3 5B JUMPDEST 0BC4 34 CALLVALUE 0BC5 80 DUP1 0BC6 15 ISZERO 0BC7 61 PUSH2 0x0bcf 0BCA 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0BC4 stack[0] = msg.value } // Block ends with conditional jump to 0x0bcf, if !msg.value label_0BCB: // Incoming jump from 0x0BCA, if not !msg.value // Inputs[1] { @0BCE memory[0x00:0x00] } 0BCB 60 PUSH1 0x00 0BCD 80 DUP1 0BCE FD *REVERT // Stack delta = +0 // Outputs[1] { @0BCE revert(memory[0x00:0x00]); } // Block terminates label_0BCF: // Incoming jump from 0x0BCA, if !msg.value // Inputs[1] { @0BD7 msg.data.length } 0BCF 5B JUMPDEST 0BD0 50 POP 0BD1 61 PUSH2 0x0cd3 0BD4 60 PUSH1 0x04 0BD6 80 DUP1 0BD7 36 CALLDATASIZE 0BD8 03 SUB 0BD9 60 PUSH1 0x80 0BDB 81 DUP2 0BDC 10 LT 0BDD 15 ISZERO 0BDE 61 PUSH2 0x0be6 0BE1 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0BD1 stack[-1] = 0x0cd3 // @0BD4 stack[0] = 0x04 // @0BD8 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0be6, returns to 0x0CD3, if !(msg.data.length - 0x04 < 0x80) label_0BE2: // Incoming jump from 0x0BE1, if not !(msg.data.length - 0x04 < 0x80) // Inputs[1] { @0BE5 memory[0x00:0x00] } 0BE2 60 PUSH1 0x00 0BE4 80 DUP1 0BE5 FD *REVERT // Stack delta = +0 // Outputs[1] { @0BE5 revert(memory[0x00:0x00]); } // Block terminates label_0BE6: // Incoming call from 0x0BE1, returns to 0x0CD3, if !(msg.data.length - 0x04 < 0x80) // Inputs[6] // { // @0BE7 stack[-2] // @0BE8 stack[-1] // @0BEC msg.data[stack[-2]:stack[-2] + 0x20] // @0C0C msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @0C2C msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // @0C36 msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] // } 0BE6 5B JUMPDEST 0BE7 81 DUP2 0BE8 01 ADD 0BE9 90 SWAP1 0BEA 80 DUP1 0BEB 80 DUP1 0BEC 35 CALLDATALOAD 0BED 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C02 16 AND 0C03 90 SWAP1 0C04 60 PUSH1 0x20 0C06 01 ADD 0C07 90 SWAP1 0C08 92 SWAP3 0C09 91 SWAP2 0C0A 90 SWAP1 0C0B 80 DUP1 0C0C 35 CALLDATALOAD 0C0D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0C22 16 AND 0C23 90 SWAP1 0C24 60 PUSH1 0x20 0C26 01 ADD 0C27 90 SWAP1 0C28 92 SWAP3 0C29 91 SWAP2 0C2A 90 SWAP1 0C2B 80 DUP1 0C2C 35 CALLDATALOAD 0C2D 90 SWAP1 0C2E 60 PUSH1 0x20 0C30 01 ADD 0C31 90 SWAP1 0C32 92 SWAP3 0C33 91 SWAP2 0C34 90 SWAP1 0C35 80 DUP1 0C36 35 CALLDATALOAD 0C37 90 SWAP1 0C38 60 PUSH1 0x20 0C3A 01 ADD 0C3B 90 SWAP1 0C3C 64 PUSH5 0x0100000000 0C42 81 DUP2 0C43 11 GT 0C44 15 ISZERO 0C45 61 PUSH2 0x0c4d 0C48 57 *JUMPI // Stack delta = +5 // Outputs[7] // { // @0C08 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0C28 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // @0C32 stack[0] = msg.data[0x20 + 0x20 + stack[-2]:0x20 + 0x20 + stack[-2] + 0x20] // @0C33 stack[1] = stack[-2] + stack[-1] // @0C34 stack[2] = stack[-2] // @0C3B stack[4] = msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] // @0C3B stack[3] = 0x20 + 0x20 + 0x20 + 0x20 + stack[-2] // } // Block ends with conditional jump to 0x0c4d, if !(msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] > 0x0100000000) label_0C49: // Incoming jump from 0x0C48, if not !(msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] > 0x0100000000) // Inputs[1] { @0C4C memory[0x00:0x00] } 0C49 60 PUSH1 0x00 0C4B 80 DUP1 0C4C FD *REVERT // Stack delta = +0 // Outputs[1] { @0C4C revert(memory[0x00:0x00]); } // Block terminates label_0C4D: // Incoming jump from 0x0C48, if !(msg.data[0x20 + 0x20 + 0x20 + stack[-2]:0x20 + 0x20 + 0x20 + stack[-2] + 0x20] > 0x0100000000) // Inputs[3] // { // @0C4E stack[-3] // @0C4F stack[-1] // @0C50 stack[-4] // } 0C4D 5B JUMPDEST 0C4E 82 DUP3 0C4F 01 ADD 0C50 83 DUP4 0C51 60 PUSH1 0x20 0C53 82 DUP3 0C54 01 ADD 0C55 11 GT 0C56 15 ISZERO 0C57 61 PUSH2 0x0c5f 0C5A 57 *JUMPI // Stack delta = +0 // Outputs[1] { @0C4F stack[-1] = stack[-3] + stack[-1] } // Block ends with conditional jump to 0x0c5f, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) label_0C5B: // Incoming jump from 0x0C5A, if not !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[1] { @0C5E memory[0x00:0x00] } 0C5B 60 PUSH1 0x00 0C5D 80 DUP1 0C5E FD *REVERT // Stack delta = +0 // Outputs[1] { @0C5E revert(memory[0x00:0x00]); } // Block terminates label_0C5F: // Incoming jump from 0x0C5A, if !(stack[-3] + stack[-1] + 0x20 > stack[-4]) // Inputs[4] // { // @0C60 stack[-1] // @0C61 msg.data[stack[-1]:stack[-1] + 0x20] // @0C66 stack[-2] // @0C67 stack[-4] // } 0C5F 5B JUMPDEST 0C60 80 DUP1 0C61 35 CALLDATALOAD 0C62 90 SWAP1 0C63 60 PUSH1 0x20 0C65 01 ADD 0C66 91 SWAP2 0C67 84 DUP5 0C68 60 PUSH1 0x01 0C6A 83 DUP4 0C6B 02 MUL 0C6C 84 DUP5 0C6D 01 ADD 0C6E 11 GT 0C6F 64 PUSH5 0x0100000000 0C75 83 DUP4 0C76 11 GT 0C77 17 OR 0C78 15 ISZERO 0C79 61 PUSH2 0x0c81 0C7C 57 *JUMPI // Stack delta = +1 // Outputs[3] // { // @0C62 stack[-1] = msg.data[stack[-1]:stack[-1] + 0x20] // @0C66 stack[0] = stack[-2] // @0C66 stack[-2] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x0c81, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) label_0C7D: // Incoming jump from 0x0C7C, if not !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[1] { @0C80 memory[0x00:0x00] } 0C7D 60 PUSH1 0x00 0C7F 80 DUP1 0C80 FD *REVERT // Stack delta = +0 // Outputs[1] { @0C80 revert(memory[0x00:0x00]); } // Block terminates label_0C81: // Incoming jump from 0x0C7C, if !((msg.data[stack[-1]:stack[-1] + 0x20] > 0x0100000000) | (0x20 + stack[-1] + msg.data[stack[-1]:stack[-1] + 0x20] * 0x01 > stack[-4])) // Inputs[7] // { // @0C82 stack[-1] // @0C82 stack[-3] // @0C83 stack[-2] // @0C94 memory[0x40:0x60] // @0CAB msg.data[stack[-3]:stack[-3] + stack[-2]] // @0CC7 stack[-4] // @0CC8 stack[-5] // } 0C81 5B JUMPDEST 0C82 91 SWAP2 0C83 90 SWAP1 0C84 80 DUP1 0C85 80 DUP1 0C86 60 PUSH1 0x1f 0C88 01 ADD 0C89 60 PUSH1 0x20 0C8B 80 DUP1 0C8C 91 SWAP2 0C8D 04 DIV 0C8E 02 MUL 0C8F 60 PUSH1 0x20 0C91 01 ADD 0C92 60 PUSH1 0x40 0C94 51 MLOAD 0C95 90 SWAP1 0C96 81 DUP2 0C97 01 ADD 0C98 60 PUSH1 0x40 0C9A 52 MSTORE 0C9B 80 DUP1 0C9C 93 SWAP4 0C9D 92 SWAP3 0C9E 91 SWAP2 0C9F 90 SWAP1 0CA0 81 DUP2 0CA1 81 DUP2 0CA2 52 MSTORE 0CA3 60 PUSH1 0x20 0CA5 01 ADD 0CA6 83 DUP4 0CA7 83 DUP4 0CA8 80 DUP1 0CA9 82 DUP3 0CAA 84 DUP5 0CAB 37 CALLDATACOPY 0CAC 60 PUSH1 0x00 0CAE 81 DUP2 0CAF 84 DUP5 0CB0 01 ADD 0CB1 52 MSTORE 0CB2 60 PUSH1 0x1f 0CB4 19 NOT 0CB5 60 PUSH1 0x1f 0CB7 82 DUP3 0CB8 01 ADD 0CB9 16 AND 0CBA 90 SWAP1 0CBB 50 POP 0CBC 80 DUP1 0CBD 83 DUP4 0CBE 01 ADD 0CBF 92 SWAP3 0CC0 50 POP 0CC1 50 POP 0CC2 50 POP 0CC3 50 POP 0CC4 50 POP 0CC5 50 POP 0CC6 50 POP 0CC7 91 SWAP2 0CC8 92 SWAP3 0CC9 91 SWAP2 0CCA 92 SWAP3 0CCB 90 SWAP1 0CCC 50 POP 0CCD 50 POP 0CCE 50 POP 0CCF 61 PUSH2 0x220b 0CD2 56 *JUMP // Stack delta = -4 // Outputs[5] // { // @0C9A memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + stack[-2]) / 0x20 * 0x20 // @0CA2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @0CAB memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + stack[-2]] = msg.data[stack[-3]:stack[-3] + stack[-2]] // @0CB1 memory[0x20 + memory[0x40:0x60] + stack[-2]:0x20 + memory[0x40:0x60] + stack[-2] + 0x20] = 0x00 // @0CCA stack[-5] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x220b label_0CD3: // Incoming return from call to 0x0BE6 at 0x0BE1 0CD3 5B JUMPDEST 0CD4 00 *STOP // Stack delta = +0 // Outputs[1] { @0CD4 stop(); } // Block terminates label_0CD5: // Incoming jump from 0x0090, if 0xbb8a16bd == stack[-1] // Inputs[1] { @0CD6 msg.value } 0CD5 5B JUMPDEST 0CD6 34 CALLVALUE 0CD7 80 DUP1 0CD8 15 ISZERO 0CD9 61 PUSH2 0x0ce1 0CDC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0CD6 stack[0] = msg.value } // Block ends with conditional jump to 0x0ce1, if !msg.value label_0CDD: // Incoming jump from 0x0CDC, if not !msg.value // Inputs[1] { @0CE0 memory[0x00:0x00] } 0CDD 60 PUSH1 0x00 0CDF 80 DUP1 0CE0 FD *REVERT // Stack delta = +0 // Outputs[1] { @0CE0 revert(memory[0x00:0x00]); } // Block terminates label_0CE1: // Incoming jump from 0x0CDC, if !msg.value 0CE1 5B JUMPDEST 0CE2 50 POP 0CE3 61 PUSH2 0x0cea 0CE6 61 PUSH2 0x2283 0CE9 56 *JUMP // Stack delta = +0 // Outputs[1] { @0CE3 stack[-1] = 0x0cea } // Block ends with call to 0x2283, returns to 0x0CEA label_0CEA: // Incoming return from call to 0x2283 at 0x0CE9 // Inputs[4] // { // @0CED memory[0x40:0x60] // @0CEF stack[-1] // @0CFA memory[0x40:0x60] // @0CFF memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0CEA 5B JUMPDEST 0CEB 60 PUSH1 0x40 0CED 51 MLOAD 0CEE 80 DUP1 0CEF 82 DUP3 0CF0 81 DUP2 0CF1 52 MSTORE 0CF2 60 PUSH1 0x20 0CF4 01 ADD 0CF5 91 SWAP2 0CF6 50 POP 0CF7 50 POP 0CF8 60 PUSH1 0x40 0CFA 51 MLOAD 0CFB 80 DUP1 0CFC 91 SWAP2 0CFD 03 SUB 0CFE 90 SWAP1 0CFF F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0CF1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0CFF return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0D00: // Incoming jump from 0x009B, if 0xc87b56dd == stack[-1] // Inputs[1] { @0D01 msg.value } 0D00 5B JUMPDEST 0D01 34 CALLVALUE 0D02 80 DUP1 0D03 15 ISZERO 0D04 61 PUSH2 0x0d0c 0D07 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0D01 stack[0] = msg.value } // Block ends with conditional jump to 0x0d0c, if !msg.value label_0D08: // Incoming jump from 0x0D07, if not !msg.value // Inputs[1] { @0D0B memory[0x00:0x00] } 0D08 60 PUSH1 0x00 0D0A 80 DUP1 0D0B FD *REVERT // Stack delta = +0 // Outputs[1] { @0D0B revert(memory[0x00:0x00]); } // Block terminates label_0D0C: // Incoming jump from 0x0D07, if !msg.value // Inputs[1] { @0D14 msg.data.length } 0D0C 5B JUMPDEST 0D0D 50 POP 0D0E 61 PUSH2 0x0d39 0D11 60 PUSH1 0x04 0D13 80 DUP1 0D14 36 CALLDATASIZE 0D15 03 SUB 0D16 60 PUSH1 0x20 0D18 81 DUP2 0D19 10 LT 0D1A 15 ISZERO 0D1B 61 PUSH2 0x0d23 0D1E 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0D0E stack[-1] = 0x0d39 // @0D11 stack[0] = 0x04 // @0D15 stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0d23, returns to 0x0D39, if !(msg.data.length - 0x04 < 0x20) label_0D1F: // Incoming jump from 0x0D1E, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0D22 memory[0x00:0x00] } 0D1F 60 PUSH1 0x00 0D21 80 DUP1 0D22 FD *REVERT // Stack delta = +0 // Outputs[1] { @0D22 revert(memory[0x00:0x00]); } // Block terminates label_0D23: // Incoming call from 0x0D1E, returns to 0x0D39, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0D24 stack[-2] // @0D25 stack[-1] // @0D29 msg.data[stack[-2]:stack[-2] + 0x20] // } 0D23 5B JUMPDEST 0D24 81 DUP2 0D25 01 ADD 0D26 90 SWAP1 0D27 80 DUP1 0D28 80 DUP1 0D29 35 CALLDATALOAD 0D2A 90 SWAP1 0D2B 60 PUSH1 0x20 0D2D 01 ADD 0D2E 90 SWAP1 0D2F 92 SWAP3 0D30 91 SWAP2 0D31 90 SWAP1 0D32 50 POP 0D33 50 POP 0D34 50 POP 0D35 61 PUSH2 0x2289 0D38 56 *JUMP // Stack delta = -1 // Outputs[1] { @0D2F stack[-2] = msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x2289 label_0D39: // Incoming return from call to 0x0D23 at 0x0D1E // Inputs[4] // { // @0D3C memory[0x40:0x60] // @0D47 stack[-1] // @0D4A memory[stack[-1]:stack[-1] + 0x20] // @0D53 memory[stack[-1]:stack[-1] + 0x20] // } 0D39 5B JUMPDEST 0D3A 60 PUSH1 0x40 0D3C 51 MLOAD 0D3D 80 DUP1 0D3E 80 DUP1 0D3F 60 PUSH1 0x20 0D41 01 ADD 0D42 82 DUP3 0D43 81 DUP2 0D44 03 SUB 0D45 82 DUP3 0D46 52 MSTORE 0D47 83 DUP4 0D48 81 DUP2 0D49 81 DUP2 0D4A 51 MLOAD 0D4B 81 DUP2 0D4C 52 MSTORE 0D4D 60 PUSH1 0x20 0D4F 01 ADD 0D50 91 SWAP2 0D51 50 POP 0D52 80 DUP1 0D53 51 MLOAD 0D54 90 SWAP1 0D55 60 PUSH1 0x20 0D57 01 ADD 0D58 90 SWAP1 0D59 80 DUP1 0D5A 83 DUP4 0D5B 83 DUP4 0D5C 60 PUSH1 0x00 0D5E 5B JUMPDEST 0D5F 83 DUP4 0D60 81 DUP2 0D61 10 LT 0D62 15 ISZERO 0D63 61 PUSH2 0x0d79 0D66 57 *JUMPI // Stack delta = +9 // Outputs[11] // { // @0D3C stack[0] = memory[0x40:0x60] // @0D3D stack[1] = memory[0x40:0x60] // @0D46 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + memory[0x40:0x60]) - memory[0x40:0x60] // @0D4C memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @0D50 stack[2] = 0x20 + 0x20 + memory[0x40:0x60] // @0D58 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @0D58 stack[3] = 0x20 + stack[-1] // @0D59 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @0D5A stack[6] = 0x20 + 0x20 + memory[0x40:0x60] // @0D5B stack[7] = 0x20 + stack[-1] // @0D5C stack[8] = 0x00 // } // Block ends with conditional jump to 0x0d79, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_0D67: // Incoming jump from 0x0D66, if not !(stack[-1] < stack[-4]) // Incoming jump from 0x0D66, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[4] // { // @0D67 stack[-1] // @0D68 stack[-2] // @0D6A memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0D6C stack[-3] // } 0D67 80 DUP1 0D68 82 DUP3 0D69 01 ADD 0D6A 51 MLOAD 0D6B 81 DUP2 0D6C 84 DUP5 0D6D 01 ADD 0D6E 52 MSTORE 0D6F 60 PUSH1 0x20 0D71 81 DUP2 0D72 01 ADD 0D73 90 SWAP1 0D74 50 POP 0D75 61 PUSH2 0x0d5e 0D78 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0D6E memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @0D73 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x0d5e label_0D79: // Incoming jump from 0x0D66, if !(stack[-1] < stack[-4]) // Incoming jump from 0x0D66, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Inputs[3] // { // @0D7E stack[-6] // @0D7E stack[-5] // @0D80 stack[-7] // } 0D79 5B JUMPDEST 0D7A 50 POP 0D7B 50 POP 0D7C 50 POP 0D7D 50 POP 0D7E 90 SWAP1 0D7F 50 POP 0D80 90 SWAP1 0D81 81 DUP2 0D82 01 ADD 0D83 90 SWAP1 0D84 60 PUSH1 0x1f 0D86 16 AND 0D87 80 DUP1 0D88 15 ISZERO 0D89 61 PUSH2 0x0da6 0D8C 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @0D83 stack[-7] = stack[-5] + stack[-7] // @0D86 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x0da6, if !(0x1f & stack[-5]) label_0D8D: // Incoming jump from 0x0D8C, if not !(0x1f & stack[-5]) // Inputs[6] // { // @0D8D stack[-1] // @0D8E stack[-2] // @0D91 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0DA8 stack[-5] // @0DAE memory[0x40:0x60] // @0DB3 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 0D8D 80 DUP1 0D8E 82 DUP3 0D8F 03 SUB 0D90 80 DUP1 0D91 51 MLOAD 0D92 60 PUSH1 0x01 0D94 83 DUP4 0D95 60 PUSH1 0x20 0D97 03 SUB 0D98 61 PUSH2 0x0100 0D9B 0A EXP 0D9C 03 SUB 0D9D 19 NOT 0D9E 16 AND 0D9F 81 DUP2 0DA0 52 MSTORE 0DA1 60 PUSH1 0x20 0DA3 01 ADD 0DA4 91 SWAP2 0DA5 50 POP 0DA6 5B JUMPDEST 0DA7 50 POP 0DA8 92 SWAP3 0DA9 50 POP 0DAA 50 POP 0DAB 50 POP 0DAC 60 PUSH1 0x40 0DAE 51 MLOAD 0DAF 80 DUP1 0DB0 91 SWAP2 0DB1 03 SUB 0DB2 90 SWAP1 0DB3 F3 *RETURN // Stack delta = -5 // Outputs[2] // { // @0DA0 memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @0DB3 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]; // } // Block terminates label_0DB4: // Incoming jump from 0x00A6, if 0xcb774d47 == stack[-1] // Inputs[1] { @0DB5 msg.value } 0DB4 5B JUMPDEST 0DB5 34 CALLVALUE 0DB6 80 DUP1 0DB7 15 ISZERO 0DB8 61 PUSH2 0x0dc0 0DBB 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0DB5 stack[0] = msg.value } // Block ends with conditional jump to 0x0dc0, if !msg.value label_0DBC: // Incoming jump from 0x0DBB, if not !msg.value // Inputs[1] { @0DBF memory[0x00:0x00] } 0DBC 60 PUSH1 0x00 0DBE 80 DUP1 0DBF FD *REVERT // Stack delta = +0 // Outputs[1] { @0DBF revert(memory[0x00:0x00]); } // Block terminates label_0DC0: // Incoming jump from 0x0DBB, if !msg.value 0DC0 5B JUMPDEST 0DC1 50 POP 0DC2 61 PUSH2 0x0dc9 0DC5 61 PUSH2 0x255a 0DC8 56 *JUMP // Stack delta = +0 // Outputs[1] { @0DC2 stack[-1] = 0x0dc9 } // Block ends with call to 0x255a, returns to 0x0DC9 label_0DC9: // Incoming return from call to 0x255A at 0x0DC8 // Inputs[4] // { // @0DCC memory[0x40:0x60] // @0DCE stack[-1] // @0DD9 memory[0x40:0x60] // @0DDE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0DC9 5B JUMPDEST 0DCA 60 PUSH1 0x40 0DCC 51 MLOAD 0DCD 80 DUP1 0DCE 82 DUP3 0DCF 81 DUP2 0DD0 52 MSTORE 0DD1 60 PUSH1 0x20 0DD3 01 ADD 0DD4 91 SWAP2 0DD5 50 POP 0DD6 50 POP 0DD7 60 PUSH1 0x40 0DD9 51 MLOAD 0DDA 80 DUP1 0DDB 91 SWAP2 0DDC 03 SUB 0DDD 90 SWAP1 0DDE F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0DD0 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0DDE return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0DDF: // Incoming jump from 0x003E, if 0xe36d6498 == stack[-1] // Inputs[1] { @0DE0 msg.value } 0DDF 5B JUMPDEST 0DE0 34 CALLVALUE 0DE1 80 DUP1 0DE2 15 ISZERO 0DE3 61 PUSH2 0x0deb 0DE6 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0DE0 stack[0] = msg.value } // Block ends with conditional jump to 0x0deb, if !msg.value label_0DE7: // Incoming jump from 0x0DE6, if not !msg.value // Inputs[1] { @0DEA memory[0x00:0x00] } 0DE7 60 PUSH1 0x00 0DE9 80 DUP1 0DEA FD *REVERT // Stack delta = +0 // Outputs[1] { @0DEA revert(memory[0x00:0x00]); } // Block terminates label_0DEB: // Incoming jump from 0x0DE6, if !msg.value 0DEB 5B JUMPDEST 0DEC 50 POP 0DED 61 PUSH2 0x0df4 0DF0 61 PUSH2 0x2560 0DF3 56 *JUMP // Stack delta = +0 // Outputs[1] { @0DED stack[-1] = 0x0df4 } // Block ends with call to 0x2560, returns to 0x0DF4 label_0DF4: // Incoming return from call to 0x2560 at 0x0DF3 // Inputs[4] // { // @0DF7 memory[0x40:0x60] // @0DF9 stack[-1] // @0E04 memory[0x40:0x60] // @0E09 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0DF4 5B JUMPDEST 0DF5 60 PUSH1 0x40 0DF7 51 MLOAD 0DF8 80 DUP1 0DF9 82 DUP3 0DFA 81 DUP2 0DFB 52 MSTORE 0DFC 60 PUSH1 0x20 0DFE 01 ADD 0DFF 91 SWAP2 0E00 50 POP 0E01 50 POP 0E02 60 PUSH1 0x40 0E04 51 MLOAD 0E05 80 DUP1 0E06 91 SWAP2 0E07 03 SUB 0E08 90 SWAP1 0E09 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0DFB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-1] // @0E09 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0E0A: // Incoming jump from 0x0049, if 0xe985e9c5 == stack[-1] // Inputs[1] { @0E0B msg.value } 0E0A 5B JUMPDEST 0E0B 34 CALLVALUE 0E0C 80 DUP1 0E0D 15 ISZERO 0E0E 61 PUSH2 0x0e16 0E11 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E0B stack[0] = msg.value } // Block ends with conditional jump to 0x0e16, if !msg.value label_0E12: // Incoming jump from 0x0E11, if not !msg.value // Inputs[1] { @0E15 memory[0x00:0x00] } 0E12 60 PUSH1 0x00 0E14 80 DUP1 0E15 FD *REVERT // Stack delta = +0 // Outputs[1] { @0E15 revert(memory[0x00:0x00]); } // Block terminates label_0E16: // Incoming jump from 0x0E11, if !msg.value // Inputs[1] { @0E1E msg.data.length } 0E16 5B JUMPDEST 0E17 50 POP 0E18 61 PUSH2 0x0e79 0E1B 60 PUSH1 0x04 0E1D 80 DUP1 0E1E 36 CALLDATASIZE 0E1F 03 SUB 0E20 60 PUSH1 0x40 0E22 81 DUP2 0E23 10 LT 0E24 15 ISZERO 0E25 61 PUSH2 0x0e2d 0E28 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0E18 stack[-1] = 0x0e79 // @0E1B stack[0] = 0x04 // @0E1F stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0e2d, returns to 0x0E79, if !(msg.data.length - 0x04 < 0x40) label_0E29: // Incoming jump from 0x0E28, if not !(msg.data.length - 0x04 < 0x40) // Inputs[1] { @0E2C memory[0x00:0x00] } 0E29 60 PUSH1 0x00 0E2B 80 DUP1 0E2C FD *REVERT // Stack delta = +0 // Outputs[1] { @0E2C revert(memory[0x00:0x00]); } // Block terminates label_0E2D: // Incoming call from 0x0E28, returns to 0x0E79, if !(msg.data.length - 0x04 < 0x40) // Inputs[4] // { // @0E2E stack[-2] // @0E2F stack[-1] // @0E33 msg.data[stack[-2]:stack[-2] + 0x20] // @0E53 msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } 0E2D 5B JUMPDEST 0E2E 81 DUP2 0E2F 01 ADD 0E30 90 SWAP1 0E31 80 DUP1 0E32 80 DUP1 0E33 35 CALLDATALOAD 0E34 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E49 16 AND 0E4A 90 SWAP1 0E4B 60 PUSH1 0x20 0E4D 01 ADD 0E4E 90 SWAP1 0E4F 92 SWAP3 0E50 91 SWAP2 0E51 90 SWAP1 0E52 80 DUP1 0E53 35 CALLDATALOAD 0E54 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0E69 16 AND 0E6A 90 SWAP1 0E6B 60 PUSH1 0x20 0E6D 01 ADD 0E6E 90 SWAP1 0E6F 92 SWAP3 0E70 91 SWAP2 0E71 90 SWAP1 0E72 50 POP 0E73 50 POP 0E74 50 POP 0E75 61 PUSH2 0x2566 0E78 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @0E4F stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] // @0E6F stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] // } // Block ends with unconditional jump to 0x2566 label_0E79: // Incoming return from call to 0x0E2D at 0x0E28 // Inputs[4] // { // @0E7C memory[0x40:0x60] // @0E7E stack[-1] // @0E8B memory[0x40:0x60] // @0E90 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0E79 5B JUMPDEST 0E7A 60 PUSH1 0x40 0E7C 51 MLOAD 0E7D 80 DUP1 0E7E 82 DUP3 0E7F 15 ISZERO 0E80 15 ISZERO 0E81 81 DUP2 0E82 52 MSTORE 0E83 60 PUSH1 0x20 0E85 01 ADD 0E86 91 SWAP2 0E87 50 POP 0E88 50 POP 0E89 60 PUSH1 0x40 0E8B 51 MLOAD 0E8C 80 DUP1 0E8D 91 SWAP2 0E8E 03 SUB 0E8F 90 SWAP1 0E90 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0E82 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0E90 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0E91: // Incoming jump from 0x0054, if 0xe9866550 == stack[-1] // Inputs[1] { @0E92 msg.value } 0E91 5B JUMPDEST 0E92 34 CALLVALUE 0E93 80 DUP1 0E94 15 ISZERO 0E95 61 PUSH2 0x0e9d 0E98 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0E92 stack[0] = msg.value } // Block ends with conditional jump to 0x0e9d, if !msg.value label_0E99: // Incoming jump from 0x0E98, if not !msg.value // Inputs[1] { @0E9C memory[0x00:0x00] } 0E99 60 PUSH1 0x00 0E9B 80 DUP1 0E9C FD *REVERT // Stack delta = +0 // Outputs[1] { @0E9C revert(memory[0x00:0x00]); } // Block terminates label_0E9D: // Incoming jump from 0x0E98, if !msg.value 0E9D 5B JUMPDEST 0E9E 50 POP 0E9F 61 PUSH2 0x0ea6 0EA2 61 PUSH2 0x25fa 0EA5 56 *JUMP // Stack delta = +0 // Outputs[1] { @0E9F stack[-1] = 0x0ea6 } // Block ends with call to 0x25fa, returns to 0x0EA6 label_0EA6: // Incoming return from call to 0x25FA at 0x0EA5 0EA6 5B JUMPDEST 0EA7 00 *STOP // Stack delta = +0 // Outputs[1] { @0EA7 stop(); } // Block terminates label_0EA8: // Incoming jump from 0x005F, if 0xeb8d2444 == stack[-1] // Inputs[1] { @0EA9 msg.value } 0EA8 5B JUMPDEST 0EA9 34 CALLVALUE 0EAA 80 DUP1 0EAB 15 ISZERO 0EAC 61 PUSH2 0x0eb4 0EAF 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0EA9 stack[0] = msg.value } // Block ends with conditional jump to 0x0eb4, if !msg.value label_0EB0: // Incoming jump from 0x0EAF, if not !msg.value // Inputs[1] { @0EB3 memory[0x00:0x00] } 0EB0 60 PUSH1 0x00 0EB2 80 DUP1 0EB3 FD *REVERT // Stack delta = +0 // Outputs[1] { @0EB3 revert(memory[0x00:0x00]); } // Block terminates label_0EB4: // Incoming jump from 0x0EAF, if !msg.value 0EB4 5B JUMPDEST 0EB5 50 POP 0EB6 61 PUSH2 0x0ebd 0EB9 61 PUSH2 0x2764 0EBC 56 *JUMP // Stack delta = +0 // Outputs[1] { @0EB6 stack[-1] = 0x0ebd } // Block ends with call to 0x2764, returns to 0x0EBD label_0EBD: // Incoming return from call to 0x2764 at 0x0EBC // Inputs[4] // { // @0EC0 memory[0x40:0x60] // @0EC2 stack[-1] // @0ECF memory[0x40:0x60] // @0ED4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0EBD 5B JUMPDEST 0EBE 60 PUSH1 0x40 0EC0 51 MLOAD 0EC1 80 DUP1 0EC2 82 DUP3 0EC3 15 ISZERO 0EC4 15 ISZERO 0EC5 81 DUP2 0EC6 52 MSTORE 0EC7 60 PUSH1 0x20 0EC9 01 ADD 0ECA 91 SWAP2 0ECB 50 POP 0ECC 50 POP 0ECD 60 PUSH1 0x40 0ECF 51 MLOAD 0ED0 80 DUP1 0ED1 91 SWAP2 0ED2 03 SUB 0ED3 90 SWAP1 0ED4 F3 *RETURN // Stack delta = -1 // Outputs[2] // { // @0EC6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-1] // @0ED4 return memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]]; // } // Block terminates label_0ED5: // Incoming jump from 0x006A, if 0xf2fde38b == stack[-1] // Inputs[1] { @0ED6 msg.value } 0ED5 5B JUMPDEST 0ED6 34 CALLVALUE 0ED7 80 DUP1 0ED8 15 ISZERO 0ED9 61 PUSH2 0x0ee1 0EDC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @0ED6 stack[0] = msg.value } // Block ends with conditional jump to 0x0ee1, if !msg.value label_0EDD: // Incoming jump from 0x0EDC, if not !msg.value // Inputs[1] { @0EE0 memory[0x00:0x00] } 0EDD 60 PUSH1 0x00 0EDF 80 DUP1 0EE0 FD *REVERT // Stack delta = +0 // Outputs[1] { @0EE0 revert(memory[0x00:0x00]); } // Block terminates label_0EE1: // Incoming jump from 0x0EDC, if !msg.value // Inputs[1] { @0EE9 msg.data.length } 0EE1 5B JUMPDEST 0EE2 50 POP 0EE3 61 PUSH2 0x0f24 0EE6 60 PUSH1 0x04 0EE8 80 DUP1 0EE9 36 CALLDATASIZE 0EEA 03 SUB 0EEB 60 PUSH1 0x20 0EED 81 DUP2 0EEE 10 LT 0EEF 15 ISZERO 0EF0 61 PUSH2 0x0ef8 0EF3 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @0EE3 stack[-1] = 0x0f24 // @0EE6 stack[0] = 0x04 // @0EEA stack[1] = msg.data.length - 0x04 // } // Block ends with conditional call to 0x0ef8, returns to 0x0F24, if !(msg.data.length - 0x04 < 0x20) label_0EF4: // Incoming jump from 0x0EF3, if not !(msg.data.length - 0x04 < 0x20) // Inputs[1] { @0EF7 memory[0x00:0x00] } 0EF4 60 PUSH1 0x00 0EF6 80 DUP1 0EF7 FD *REVERT // Stack delta = +0 // Outputs[1] { @0EF7 revert(memory[0x00:0x00]); } // Block terminates label_0EF8: // Incoming call from 0x0EF3, returns to 0x0F24, if !(msg.data.length - 0x04 < 0x20) // Inputs[3] // { // @0EF9 stack[-2] // @0EFA stack[-1] // @0EFE msg.data[stack[-2]:stack[-2] + 0x20] // } 0EF8 5B JUMPDEST 0EF9 81 DUP2 0EFA 01 ADD 0EFB 90 SWAP1 0EFC 80 DUP1 0EFD 80 DUP1 0EFE 35 CALLDATALOAD 0EFF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F14 16 AND 0F15 90 SWAP1 0F16 60 PUSH1 0x20 0F18 01 ADD 0F19 90 SWAP1 0F1A 92 SWAP3 0F1B 91 SWAP2 0F1C 90 SWAP1 0F1D 50 POP 0F1E 50 POP 0F1F 50 POP 0F20 61 PUSH2 0x2777 0F23 56 *JUMP // Stack delta = -1 // Outputs[1] { @0F1A stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & msg.data[stack[-2]:stack[-2] + 0x20] } // Block ends with unconditional jump to 0x2777 label_0F24: // Incoming return from call to 0x0EF8 at 0x0EF3 0F24 5B JUMPDEST 0F25 00 *STOP // Stack delta = +0 // Outputs[1] { @0F25 stop(); } // Block terminates label_0F26: // Incoming jump from 0x0257 0F26 5B JUMPDEST 0F27 61 PUSH2 0x0f2e 0F2A 61 PUSH2 0x296c 0F2D 56 *JUMP // Stack delta = +1 // Outputs[1] { @0F27 stack[0] = 0x0f2e } // Block ends with call to 0x296c, returns to 0x0F2E label_0F2E: // Incoming return from call to 0x296C at 0x0F2D // Inputs[1] { @0F44 stack[-1] } 0F2E 5B JUMPDEST 0F2F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F44 16 AND 0F45 61 PUSH2 0x0f4c 0F48 61 PUSH2 0x1c4c 0F4B 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @0F44 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @0F45 stack[0] = 0x0f4c // } // Block ends with call to 0x1c4c, returns to 0x0F4C label_0F4C: // Incoming return from call to 0x1C4C at 0x0F4B // Inputs[2] // { // @0F62 stack[-1] // @0F63 stack[-2] // } 0F4C 5B JUMPDEST 0F4D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 0F62 16 AND 0F63 14 EQ 0F64 61 PUSH2 0x0fd5 0F67 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x0fd5, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_0F68: // Incoming jump from 0x0F67, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[3] // { // @0F6A memory[0x40:0x60] // @0FCF memory[0x40:0x60] // @0FD4 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 0F68 60 PUSH1 0x40 0F6A 51 MLOAD 0F6B 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 0F8C 81 DUP2 0F8D 52 MSTORE 0F8E 60 PUSH1 0x04 0F90 01 ADD 0F91 80 DUP1 0F92 80 DUP1 0F93 60 PUSH1 0x20 0F95 01 ADD 0F96 82 DUP3 0F97 81 DUP2 0F98 03 SUB 0F99 82 DUP3 0F9A 52 MSTORE 0F9B 60 PUSH1 0x20 0F9D 81 DUP2 0F9E 52 MSTORE 0F9F 60 PUSH1 0x20 0FA1 01 ADD 0FA2 80 DUP1 0FA3 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 0FC4 81 DUP2 0FC5 52 MSTORE 0FC6 50 POP 0FC7 60 PUSH1 0x20 0FC9 01 ADD 0FCA 91 SWAP2 0FCB 50 POP 0FCC 50 POP 0FCD 60 PUSH1 0x40 0FCF 51 MLOAD 0FD0 80 DUP1 0FD1 91 SWAP2 0FD2 03 SUB 0FD3 90 SWAP1 0FD4 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @0F8D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @0F9A memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @0F9E memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20 // @0FC5 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @0FD4 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_0FD5: // Incoming jump from 0x0F67, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[2] // { // @0FD6 stack[-1] // @0FDE stack[-2] // } 0FD5 5B JUMPDEST 0FD6 80 DUP1 0FD7 60 PUSH1 0x10 0FD9 81 DUP2 0FDA 90 SWAP1 0FDB 55 SSTORE 0FDC 50 POP 0FDD 50 POP 0FDE 56 *JUMP // Stack delta = -2 // Outputs[1] { @0FDB storage[0x10] = stack[-1] } // Block ends with unconditional jump to stack[-2] label_0FDF: // Incoming jump from 0x02B1 // Inputs[4] // { // @0FE5 stack[-1] // @1031 memory[0x00:0x40] // @1035 storage[keccak256(memory[0x00:0x40])] // @1042 stack[-2] // } 0FDF 5B JUMPDEST 0FE0 60 PUSH1 0x00 0FE2 80 DUP1 0FE3 60 PUSH1 0x00 0FE5 83 DUP4 0FE6 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1003 19 NOT 1004 16 AND 1005 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 1022 19 NOT 1023 16 AND 1024 81 DUP2 1025 52 MSTORE 1026 60 PUSH1 0x20 1028 01 ADD 1029 90 SWAP1 102A 81 DUP2 102B 52 MSTORE 102C 60 PUSH1 0x20 102E 01 ADD 102F 60 PUSH1 0x00 1031 20 SHA3 1032 60 PUSH1 0x00 1034 90 SWAP1 1035 54 SLOAD 1036 90 SWAP1 1037 61 PUSH2 0x0100 103A 0A EXP 103B 90 SWAP1 103C 04 DIV 103D 60 PUSH1 0xff 103F 16 AND 1040 90 SWAP1 1041 50 POP 1042 91 SWAP2 1043 90 SWAP1 1044 50 POP 1045 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @1025 memory[0x00:0x20] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-1] // @102B memory[0x20:0x40] = 0x00 // @1042 stack[-2] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-2] label_1046: // Incoming call from 0x02DE, returns to 0x02DF // Inputs[3] // { // @104C storage[0x06] // @106D memory[0x40:0x60] // @1080 storage[0x06] // } 1046 5B JUMPDEST 1047 60 PUSH1 0x60 1049 60 PUSH1 0x06 104B 80 DUP1 104C 54 SLOAD 104D 60 PUSH1 0x01 104F 81 DUP2 1050 60 PUSH1 0x01 1052 16 AND 1053 15 ISZERO 1054 61 PUSH2 0x0100 1057 02 MUL 1058 03 SUB 1059 16 AND 105A 60 PUSH1 0x02 105C 90 SWAP1 105D 04 DIV 105E 80 DUP1 105F 60 PUSH1 0x1f 1061 01 ADD 1062 60 PUSH1 0x20 1064 80 DUP1 1065 91 SWAP2 1066 04 DIV 1067 02 MUL 1068 60 PUSH1 0x20 106A 01 ADD 106B 60 PUSH1 0x40 106D 51 MLOAD 106E 90 SWAP1 106F 81 DUP2 1070 01 ADD 1071 60 PUSH1 0x40 1073 52 MSTORE 1074 80 DUP1 1075 92 SWAP3 1076 91 SWAP2 1077 90 SWAP1 1078 81 DUP2 1079 81 DUP2 107A 52 MSTORE 107B 60 PUSH1 0x20 107D 01 ADD 107E 82 DUP3 107F 80 DUP1 1080 54 SLOAD 1081 60 PUSH1 0x01 1083 81 DUP2 1084 60 PUSH1 0x01 1086 16 AND 1087 15 ISZERO 1088 61 PUSH2 0x0100 108B 02 MUL 108C 03 SUB 108D 16 AND 108E 60 PUSH1 0x02 1090 90 SWAP1 1091 04 DIV 1092 80 DUP1 1093 15 ISZERO 1094 61 PUSH2 0x10de 1097 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @1047 stack[0] = 0x60 // @1073 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02) / 0x20 * 0x20 // @1075 stack[1] = memory[0x40:0x60] // @1076 stack[2] = 0x06 // @1077 stack[3] = (0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02 // @107A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02 // @107D stack[4] = 0x20 + memory[0x40:0x60] // @107E stack[5] = 0x06 // @1091 stack[6] = (0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02 // } // Block ends with conditional jump to 0x10de, if !((0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02) label_1098: // Incoming jump from 0x1097, if not !((0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02) // Inputs[1] { @1098 stack[-1] } 1098 80 DUP1 1099 60 PUSH1 0x1f 109B 10 LT 109C 61 PUSH2 0x10b3 109F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x10b3, if 0x1f < stack[-1] label_10A0: // Incoming jump from 0x109F, if not 0x1f < stack[-1] // Inputs[4] // { // @10A4 stack[-2] // @10A5 storage[stack[-2]] // @10A8 stack[-3] // @10AA stack[-1] // } 10A0 61 PUSH2 0x0100 10A3 80 DUP1 10A4 83 DUP4 10A5 54 SLOAD 10A6 04 DIV 10A7 02 MUL 10A8 83 DUP4 10A9 52 MSTORE 10AA 91 SWAP2 10AB 60 PUSH1 0x20 10AD 01 ADD 10AE 91 SWAP2 10AF 61 PUSH2 0x10de 10B2 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @10A9 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @10AE stack[-1] = stack[-1] // @10AE stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x10de label_10B3: // Incoming jump from 0x109F, if 0x1f < stack[-1] // Inputs[5] // { // @10B4 stack[-3] // @10B5 stack[-1] // @10B7 stack[-2] // @10BF memory[0x00:0x20] // @10C3 storage[keccak256(memory[0x00:0x20])] // } 10B3 5B JUMPDEST 10B4 82 DUP3 10B5 01 ADD 10B6 91 SWAP2 10B7 90 SWAP1 10B8 60 PUSH1 0x00 10BA 52 MSTORE 10BB 60 PUSH1 0x20 10BD 60 PUSH1 0x00 10BF 20 SHA3 10C0 90 SWAP1 10C1 5B JUMPDEST 10C2 81 DUP2 10C3 54 SLOAD 10C4 81 DUP2 10C5 52 MSTORE 10C6 90 SWAP1 10C7 60 PUSH1 0x01 10C9 01 ADD 10CA 90 SWAP1 10CB 60 PUSH1 0x20 10CD 01 ADD 10CE 80 DUP1 10CF 83 DUP4 10D0 11 GT 10D1 61 PUSH2 0x10c1 10D4 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @10B6 stack[-3] = stack[-3] + stack[-1] // @10BA memory[0x00:0x20] = stack[-2] // @10C5 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @10CA stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @10CD stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x10c1, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_10D5: // Incoming jump from 0x10D4, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x10D4, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @10D5 stack[-3] // @10D6 stack[-1] // } 10D5 82 DUP3 10D6 90 SWAP1 10D7 03 SUB 10D8 60 PUSH1 0x1f 10DA 16 AND 10DB 82 DUP3 10DC 01 ADD 10DD 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @10DD stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @10DD stack[-1] = stack[-3] // } // Block continues label_10DE: // Incoming jump from 0x10B2 // Incoming jump from 0x10DD // Incoming jump from 0x1097, if !((0x0100 * !(0x01 & storage[0x06]) - 0x01 & storage[0x06]) / 0x02) // Inputs[3] // { // @10E4 stack[-6] // @10E4 stack[-7] // @10E6 stack[-8] // } 10DE 5B JUMPDEST 10DF 50 POP 10E0 50 POP 10E1 50 POP 10E2 50 POP 10E3 50 POP 10E4 90 SWAP1 10E5 50 POP 10E6 90 SWAP1 10E7 56 *JUMP // Stack delta = -7 // Outputs[1] { @10E6 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_10E8: // Incoming call from 0x2B20, returns to 0x2B21 // Incoming jump from 0x0392 // Inputs[1] { @10EE stack[-1] } 10E8 5B JUMPDEST 10E9 60 PUSH1 0x00 10EB 61 PUSH2 0x10f3 10EE 82 DUP3 10EF 61 PUSH2 0x2974 10F2 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @10E9 stack[0] = 0x00 // @10EB stack[1] = 0x10f3 // @10EE stack[2] = stack[-1] // } // Block ends with call to 0x2974, returns to 0x10F3 label_10F3: // Incoming return from call to 0x2974 at 0x10F2 // Inputs[1] { @10F7 stack[-1] } 10F3 5B JUMPDEST 10F4 61 PUSH2 0x1148 10F7 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1148, if stack[-1] label_10F8: // Incoming jump from 0x10F7, if not stack[-1] // Inputs[3] // { // @10FA memory[0x40:0x60] // @1142 memory[0x40:0x60] // @1147 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 10F8 60 PUSH1 0x40 10FA 51 MLOAD 10FB 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 111C 81 DUP2 111D 52 MSTORE 111E 60 PUSH1 0x04 1120 01 ADD 1121 80 DUP1 1122 80 DUP1 1123 60 PUSH1 0x20 1125 01 ADD 1126 82 DUP3 1127 81 DUP2 1128 03 SUB 1129 82 DUP3 112A 52 MSTORE 112B 60 PUSH1 0x2c 112D 81 DUP2 112E 52 MSTORE 112F 60 PUSH1 0x20 1131 01 ADD 1132 80 DUP1 1133 61 PUSH2 0x408b 1136 60 PUSH1 0x2c 1138 91 SWAP2 1139 39 CODECOPY 113A 60 PUSH1 0x40 113C 01 ADD 113D 91 SWAP2 113E 50 POP 113F 50 POP 1140 60 PUSH1 0x40 1142 51 MLOAD 1143 80 DUP1 1144 91 SWAP2 1145 03 SUB 1146 90 SWAP1 1147 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @111D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @112A memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @112E memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2c // @1139 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2c] = code[0x408b:0x40b7] // @1147 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1148: // Incoming jump from 0x10F7, if stack[-1] // Inputs[5] // { // @114D stack[-2] // @115B memory[0x00:0x40] // @115F storage[keccak256(memory[0x00:0x40])] // @117D stack[-1] // @117F stack[-3] // } 1148 5B JUMPDEST 1149 60 PUSH1 0x04 114B 60 PUSH1 0x00 114D 83 DUP4 114E 81 DUP2 114F 52 MSTORE 1150 60 PUSH1 0x20 1152 01 ADD 1153 90 SWAP1 1154 81 DUP2 1155 52 MSTORE 1156 60 PUSH1 0x20 1158 01 ADD 1159 60 PUSH1 0x00 115B 20 SHA3 115C 60 PUSH1 0x00 115E 90 SWAP1 115F 54 SLOAD 1160 90 SWAP1 1161 61 PUSH2 0x0100 1164 0A EXP 1165 90 SWAP1 1166 04 DIV 1167 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 117C 16 AND 117D 90 SWAP1 117E 50 POP 117F 91 SWAP2 1180 90 SWAP1 1181 50 POP 1182 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @114F memory[0x00:0x20] = stack[-2] // @1155 memory[0x20:0x40] = 0x04 // @117F stack[-3] = 0xffffffffffffffffffffffffffffffffffffffff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-3] label_1183: // Incoming jump from 0x0417 // Inputs[1] { @1189 stack[-1] } 1183 5B JUMPDEST 1184 60 PUSH1 0x00 1186 61 PUSH2 0x118e 1189 82 DUP3 118A 61 PUSH2 0x17f2 118D 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1184 stack[0] = 0x00 // @1186 stack[1] = 0x118e // @1189 stack[2] = stack[-1] // } // Block ends with call to 0x17f2, returns to 0x118E label_118E: // Incoming return from call to 0x17F2 at 0x118D // Inputs[3] // { // @118F stack[-1] // @118F stack[-2] // @11A8 stack[-4] // } 118E 5B JUMPDEST 118F 90 SWAP1 1190 50 POP 1191 80 DUP1 1192 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11A7 16 AND 11A8 83 DUP4 11A9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 11BE 16 AND 11BF 14 EQ 11C0 15 ISZERO 11C1 61 PUSH2 0x1215 11C4 57 *JUMPI // Stack delta = -1 // Outputs[1] { @118F stack[-2] = stack[-1] } // Block ends with conditional jump to 0x1215, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_11C5: // Incoming jump from 0x11C4, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[3] // { // @11C7 memory[0x40:0x60] // @120F memory[0x40:0x60] // @1214 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 11C5 60 PUSH1 0x40 11C7 51 MLOAD 11C8 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 11E9 81 DUP2 11EA 52 MSTORE 11EB 60 PUSH1 0x04 11ED 01 ADD 11EE 80 DUP1 11EF 80 DUP1 11F0 60 PUSH1 0x20 11F2 01 ADD 11F3 82 DUP3 11F4 81 DUP2 11F5 03 SUB 11F6 82 DUP3 11F7 52 MSTORE 11F8 60 PUSH1 0x21 11FA 81 DUP2 11FB 52 MSTORE 11FC 60 PUSH1 0x20 11FE 01 ADD 11FF 80 DUP1 1200 61 PUSH2 0x410f 1203 60 PUSH1 0x21 1205 91 SWAP2 1206 39 CODECOPY 1207 60 PUSH1 0x40 1209 01 ADD 120A 91 SWAP2 120B 50 POP 120C 50 POP 120D 60 PUSH1 0x40 120F 51 MLOAD 1210 80 DUP1 1211 91 SWAP2 1212 03 SUB 1213 90 SWAP1 1214 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @11EA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @11F7 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @11FB memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x21 // @1206 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x21] = code[0x410f:0x4130] // @1214 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1215: // Incoming jump from 0x11C4, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-4] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @1216 stack[-1] } 1215 5B JUMPDEST 1216 80 DUP1 1217 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 122C 16 AND 122D 61 PUSH2 0x1234 1230 61 PUSH2 0x296c 1233 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @122C stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @122D stack[1] = 0x1234 // } // Block ends with call to 0x296c, returns to 0x1234 label_1234: // Incoming return from call to 0x296C at 0x1233 // Inputs[2] // { // @124A stack[-1] // @124B stack[-2] // } 1234 5B JUMPDEST 1235 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 124A 16 AND 124B 14 EQ 124C 80 DUP1 124D 61 PUSH2 0x1263 1250 57 *JUMPI // Stack delta = -1 // Outputs[1] { @124B stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] } // Block ends with conditional jump to 0x1263, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_1251: // Incoming jump from 0x1250, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @1255 stack[-2] } 1251 50 POP 1252 61 PUSH2 0x1262 1255 81 DUP2 1256 61 PUSH2 0x125d 1259 61 PUSH2 0x296c 125C 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @1252 stack[-1] = 0x1262 // @1255 stack[0] = stack[-2] // @1256 stack[1] = 0x125d // } // Block ends with call to 0x296c, returns to 0x125D label_125D: // Incoming return from call to 0x296C at 0x125C 125D 5B JUMPDEST 125E 61 PUSH2 0x2566 1261 56 *JUMP // Stack delta = +0 // Block ends with unconditional jump to 0x2566 label_1262: // Incoming return from call to 0x125D at 0x125C 1262 5B JUMPDEST // Stack delta = +0 // Block continues label_1263: // Incoming jump from 0x1262 // Incoming jump from 0x1250, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @1267 stack[-1] } 1263 5B JUMPDEST 1264 61 PUSH2 0x12b8 1267 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x12b8, if stack[-1] label_1268: // Incoming jump from 0x1267, if not stack[-1] // Inputs[3] // { // @126A memory[0x40:0x60] // @12B2 memory[0x40:0x60] // @12B7 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1268 60 PUSH1 0x40 126A 51 MLOAD 126B 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 128C 81 DUP2 128D 52 MSTORE 128E 60 PUSH1 0x04 1290 01 ADD 1291 80 DUP1 1292 80 DUP1 1293 60 PUSH1 0x20 1295 01 ADD 1296 82 DUP3 1297 81 DUP2 1298 03 SUB 1299 82 DUP3 129A 52 MSTORE 129B 60 PUSH1 0x38 129D 81 DUP2 129E 52 MSTORE 129F 60 PUSH1 0x20 12A1 01 ADD 12A2 80 DUP1 12A3 61 PUSH2 0x3f95 12A6 60 PUSH1 0x38 12A8 91 SWAP2 12A9 39 CODECOPY 12AA 60 PUSH1 0x40 12AC 01 ADD 12AD 91 SWAP2 12AE 50 POP 12AF 50 POP 12B0 60 PUSH1 0x40 12B2 51 MLOAD 12B3 80 DUP1 12B4 91 SWAP2 12B5 03 SUB 12B6 90 SWAP1 12B7 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @128D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @129A memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @129E memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x38 // @12A9 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x38] = code[0x3f95:0x3fcd] // @12B7 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_12B8: // Incoming jump from 0x1267, if stack[-1] // Inputs[2] // { // @12BC stack[-3] // @12BD stack[-2] // } 12B8 5B JUMPDEST 12B9 61 PUSH2 0x12c2 12BC 83 DUP4 12BD 83 DUP4 12BE 61 PUSH2 0x2991 12C1 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @12B9 stack[0] = 0x12c2 // @12BC stack[1] = stack[-3] // @12BD stack[2] = stack[-2] // } // Block ends with call to 0x2991, returns to 0x12C2 label_12C2: // Incoming return from call to 0x2991 at 0x12C1 // Inputs[1] { @12C6 stack[-4] } 12C2 5B JUMPDEST 12C3 50 POP 12C4 50 POP 12C5 50 POP 12C6 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_12C7: // Incoming jump from 0x04DF 12C7 5B JUMPDEST 12C8 61 PUSH2 0x12cf 12CB 61 PUSH2 0x296c 12CE 56 *JUMP // Stack delta = +1 // Outputs[1] { @12C8 stack[0] = 0x12cf } // Block ends with call to 0x296c, returns to 0x12CF label_12CF: // Incoming return from call to 0x296C at 0x12CE // Inputs[1] { @12E5 stack[-1] } 12CF 5B JUMPDEST 12D0 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 12E5 16 AND 12E6 61 PUSH2 0x12ed 12E9 61 PUSH2 0x1c4c 12EC 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @12E5 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @12E6 stack[0] = 0x12ed // } // Block ends with call to 0x1c4c, returns to 0x12ED label_12ED: // Incoming return from call to 0x1C4C at 0x12EC // Inputs[2] // { // @1303 stack[-1] // @1304 stack[-2] // } 12ED 5B JUMPDEST 12EE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1303 16 AND 1304 14 EQ 1305 61 PUSH2 0x1376 1308 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1376, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_1309: // Incoming jump from 0x1308, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[3] // { // @130B memory[0x40:0x60] // @1370 memory[0x40:0x60] // @1375 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1309 60 PUSH1 0x40 130B 51 MLOAD 130C 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 132D 81 DUP2 132E 52 MSTORE 132F 60 PUSH1 0x04 1331 01 ADD 1332 80 DUP1 1333 80 DUP1 1334 60 PUSH1 0x20 1336 01 ADD 1337 82 DUP3 1338 81 DUP2 1339 03 SUB 133A 82 DUP3 133B 52 MSTORE 133C 60 PUSH1 0x20 133E 81 DUP2 133F 52 MSTORE 1340 60 PUSH1 0x20 1342 01 ADD 1343 80 DUP1 1344 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 1365 81 DUP2 1366 52 MSTORE 1367 50 POP 1368 60 PUSH1 0x20 136A 01 ADD 136B 91 SWAP2 136C 50 POP 136D 50 POP 136E 60 PUSH1 0x40 1370 51 MLOAD 1371 80 DUP1 1372 91 SWAP2 1373 03 SUB 1374 90 SWAP1 1375 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @132E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @133B memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @133F memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20 // @1366 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @1375 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1376: // Incoming jump from 0x1308, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[2] // { // @1377 stack[-1] // @137C memory[stack[-1]:stack[-1] + 0x20] // } 1376 5B JUMPDEST 1377 80 DUP1 1378 60 PUSH1 0x0b 137A 90 SWAP1 137B 80 DUP1 137C 51 MLOAD 137D 90 SWAP1 137E 60 PUSH1 0x20 1380 01 ADD 1381 90 SWAP1 1382 61 PUSH2 0x138c 1385 92 SWAP3 1386 91 SWAP2 1387 90 SWAP1 1388 61 PUSH2 0x3de6 138B 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1385 stack[0] = 0x138c // @1386 stack[1] = 0x0b // @1387 stack[2] = 0x20 + stack[-1] // @1387 stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x3de6, returns to 0x138C label_138C: // Incoming return from call to 0x3DE6 at 0x138B // Inputs[1] { @138F stack[-3] } 138C 5B JUMPDEST 138D 50 POP 138E 50 POP 138F 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_1390: // Incoming call from 0x21DF, returns to 0x21E0 // Incoming call from 0x04F6, returns to 0x04F7 // Incoming call from 0x20C2, returns to 0x20C3 // Incoming call from 0x20CF, returns to 0x20D0 // Incoming call from 0x1FB8, returns to 0x1FB9 // Incoming call from 0x2107, returns to 0x2108 1390 5B JUMPDEST 1391 60 PUSH1 0x00 1393 61 PUSH2 0x139c 1396 60 PUSH1 0x02 1398 61 PUSH2 0x2a4a 139B 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @1391 stack[0] = 0x00 // @1393 stack[1] = 0x139c // @1396 stack[2] = 0x02 // } // Block ends with call to 0x2a4a, returns to 0x139C label_139C: // Incoming return from call to 0x2A4A at 0x139B // Inputs[3] // { // @139D stack[-1] // @139D stack[-2] // @139F stack[-3] // } 139C 5B JUMPDEST 139D 90 SWAP1 139E 50 POP 139F 90 SWAP1 13A0 56 *JUMP // Stack delta = -2 // Outputs[1] { @139F stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_13A1: // Incoming call from 0x0521, returns to 0x0522 // Inputs[2] // { // @13A4 storage[0x10] // @13A5 stack[-1] // } 13A1 5B JUMPDEST 13A2 60 PUSH1 0x10 13A4 54 SLOAD 13A5 81 DUP2 13A6 56 *JUMP // Stack delta = +1 // Outputs[1] { @13A4 stack[0] = storage[0x10] } // Block ends with unconditional jump to stack[-1] label_13A7: // Incoming jump from 0x05B0 13A7 5B JUMPDEST 13A8 61 PUSH2 0x13b8 13AB 61 PUSH2 0x13b2 13AE 61 PUSH2 0x296c 13B1 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @13A8 stack[0] = 0x13b8 // @13AB stack[1] = 0x13b2 // } // Block ends with call to 0x296c, returns to 0x13B2 label_13B2: // Incoming return from call to 0x296C at 0x13B1 // Inputs[1] { @13B3 stack[-3] } 13B2 5B JUMPDEST 13B3 82 DUP3 13B4 61 PUSH2 0x2a5f 13B7 56 *JUMP // Stack delta = +1 // Outputs[1] { @13B3 stack[0] = stack[-3] } // Block ends with unconditional jump to 0x2a5f label_13B8: // Incoming return from call to 0x13B2 at 0x13B1 // Inputs[1] { @13BC stack[-1] } 13B8 5B JUMPDEST 13B9 61 PUSH2 0x140d 13BC 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x140d, if stack[-1] label_13BD: // Incoming jump from 0x13BC, if not stack[-1] // Inputs[3] // { // @13BF memory[0x40:0x60] // @1407 memory[0x40:0x60] // @140C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 13BD 60 PUSH1 0x40 13BF 51 MLOAD 13C0 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 13E1 81 DUP2 13E2 52 MSTORE 13E3 60 PUSH1 0x04 13E5 01 ADD 13E6 80 DUP1 13E7 80 DUP1 13E8 60 PUSH1 0x20 13EA 01 ADD 13EB 82 DUP3 13EC 81 DUP2 13ED 03 SUB 13EE 82 DUP3 13EF 52 MSTORE 13F0 60 PUSH1 0x31 13F2 81 DUP2 13F3 52 MSTORE 13F4 60 PUSH1 0x20 13F6 01 ADD 13F7 80 DUP1 13F8 61 PUSH2 0x4130 13FB 60 PUSH1 0x31 13FD 91 SWAP2 13FE 39 CODECOPY 13FF 60 PUSH1 0x40 1401 01 ADD 1402 91 SWAP2 1403 50 POP 1404 50 POP 1405 60 PUSH1 0x40 1407 51 MLOAD 1408 80 DUP1 1409 91 SWAP2 140A 03 SUB 140B 90 SWAP1 140C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @13E2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @13EF memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @13F3 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x31 // @13FE memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x31] = code[0x4130:0x4161] // @140C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_140D: // Incoming jump from 0x13BC, if stack[-1] // Inputs[3] // { // @1411 stack[-3] // @1412 stack[-2] // @1413 stack[-1] // } 140D 5B JUMPDEST 140E 61 PUSH2 0x1418 1411 83 DUP4 1412 83 DUP4 1413 83 DUP4 1414 61 PUSH2 0x2b53 1417 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @140E stack[0] = 0x1418 // @1411 stack[1] = stack[-3] // @1412 stack[2] = stack[-2] // @1413 stack[3] = stack[-1] // } // Block ends with call to 0x2b53, returns to 0x1418 label_1418: // Incoming return from call to 0x2B53 at 0x1417 // Inputs[1] { @141C stack[-4] } 1418 5B JUMPDEST 1419 50 POP 141A 50 POP 141B 50 POP 141C 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_141D: // Incoming jump from 0x060B // Inputs[3] // { // @1423 stack[-1] // @1428 stack[-2] // @1462 memory[0x00:0x40] // } 141D 5B JUMPDEST 141E 60 PUSH1 0x00 1420 61 PUSH2 0x1470 1423 82 DUP3 1424 60 PUSH1 0x01 1426 60 PUSH1 0x00 1428 86 DUP7 1429 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 143E 16 AND 143F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1454 16 AND 1455 81 DUP2 1456 52 MSTORE 1457 60 PUSH1 0x20 1459 01 ADD 145A 90 SWAP1 145B 81 DUP2 145C 52 MSTORE 145D 60 PUSH1 0x20 145F 01 ADD 1460 60 PUSH1 0x00 1462 20 SHA3 1463 61 PUSH2 0x2d96 1466 90 SWAP1 1467 91 SWAP2 1468 90 SWAP1 1469 63 PUSH4 0xffffffff 146E 16 AND 146F 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @141E stack[0] = 0x00 // @1420 stack[1] = 0x1470 // @1456 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @145C memory[0x20:0x40] = 0x01 // @1467 stack[2] = keccak256(memory[0x00:0x40]) // @1468 stack[3] = stack[-1] // } // Block ends with call to 0xffffffff & 0x2d96, returns to 0x1470 label_1470: // Incoming return from call to 0x2D96 at 0x146F // Inputs[4] // { // @1471 stack[-2] // @1471 stack[-1] // @1473 stack[-5] // @1474 stack[-4] // } 1470 5B JUMPDEST 1471 90 SWAP1 1472 50 POP 1473 92 SWAP3 1474 91 SWAP2 1475 50 POP 1476 50 POP 1477 56 *JUMP // Stack delta = -4 // Outputs[1] { @1473 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_1478: // Incoming call from 0x0636, returns to 0x0637 1478 5B JUMPDEST 1479 61 PUSH2 0x1480 147C 61 PUSH2 0x296c 147F 56 *JUMP // Stack delta = +1 // Outputs[1] { @1479 stack[0] = 0x1480 } // Block ends with call to 0x296c, returns to 0x1480 label_1480: // Incoming return from call to 0x296C at 0x147F // Inputs[1] { @1496 stack[-1] } 1480 5B JUMPDEST 1481 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1496 16 AND 1497 61 PUSH2 0x149e 149A 61 PUSH2 0x1c4c 149D 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1496 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1497 stack[0] = 0x149e // } // Block ends with call to 0x1c4c, returns to 0x149E label_149E: // Incoming return from call to 0x1C4C at 0x149D // Inputs[2] // { // @14B4 stack[-1] // @14B5 stack[-2] // } 149E 5B JUMPDEST 149F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 14B4 16 AND 14B5 14 EQ 14B6 61 PUSH2 0x1527 14B9 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1527, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_14BA: // Incoming jump from 0x14B9, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[3] // { // @14BC memory[0x40:0x60] // @1521 memory[0x40:0x60] // @1526 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 14BA 60 PUSH1 0x40 14BC 51 MLOAD 14BD 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 14DE 81 DUP2 14DF 52 MSTORE 14E0 60 PUSH1 0x04 14E2 01 ADD 14E3 80 DUP1 14E4 80 DUP1 14E5 60 PUSH1 0x20 14E7 01 ADD 14E8 82 DUP3 14E9 81 DUP2 14EA 03 SUB 14EB 82 DUP3 14EC 52 MSTORE 14ED 60 PUSH1 0x20 14EF 81 DUP2 14F0 52 MSTORE 14F1 60 PUSH1 0x20 14F3 01 ADD 14F4 80 DUP1 14F5 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 1516 81 DUP2 1517 52 MSTORE 1518 50 POP 1519 60 PUSH1 0x20 151B 01 ADD 151C 91 SWAP2 151D 50 POP 151E 50 POP 151F 60 PUSH1 0x40 1521 51 MLOAD 1522 80 DUP1 1523 91 SWAP2 1524 03 SUB 1525 90 SWAP1 1526 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @14DF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @14EC memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @14F0 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20 // @1517 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @1526 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1527: // Incoming jump from 0x14B9, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[3] // { // @152D storage[0x0f] // @1542 storage[0x0f] // @1552 stack[-1] // } 1527 5B JUMPDEST 1528 60 PUSH1 0x0f 152A 60 PUSH1 0x00 152C 90 SWAP1 152D 54 SLOAD 152E 90 SWAP1 152F 61 PUSH2 0x0100 1532 0A EXP 1533 90 SWAP1 1534 04 DIV 1535 60 PUSH1 0xff 1537 16 AND 1538 15 ISZERO 1539 60 PUSH1 0x0f 153B 60 PUSH1 0x00 153D 61 PUSH2 0x0100 1540 0A EXP 1541 81 DUP2 1542 54 SLOAD 1543 81 DUP2 1544 60 PUSH1 0xff 1546 02 MUL 1547 19 NOT 1548 16 AND 1549 90 SWAP1 154A 83 DUP4 154B 15 ISZERO 154C 15 ISZERO 154D 02 MUL 154E 17 OR 154F 90 SWAP1 1550 55 SSTORE 1551 50 POP 1552 56 *JUMP // Stack delta = -1 // Outputs[1] { @1550 storage[0x0f] = !!!(0xff & storage[0x0f] / 0x0100 ** 0x00) * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[0x0f]) } // Block ends with unconditional jump to stack[-1] label_1553: // Incoming call from 0x064D, returns to 0x064E 1553 5B JUMPDEST 1554 61 PUSH2 0x155b 1557 61 PUSH2 0x296c 155A 56 *JUMP // Stack delta = +1 // Outputs[1] { @1554 stack[0] = 0x155b } // Block ends with call to 0x296c, returns to 0x155B label_155B: // Incoming return from call to 0x296C at 0x155A // Inputs[1] { @1571 stack[-1] } 155B 5B JUMPDEST 155C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1571 16 AND 1572 61 PUSH2 0x1579 1575 61 PUSH2 0x1c4c 1578 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1571 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1572 stack[0] = 0x1579 // } // Block ends with call to 0x1c4c, returns to 0x1579 label_1579: // Incoming return from call to 0x1C4C at 0x1578 // Inputs[2] // { // @158F stack[-1] // @1590 stack[-2] // } 1579 5B JUMPDEST 157A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 158F 16 AND 1590 14 EQ 1591 61 PUSH2 0x1602 1594 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1602, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_1595: // Incoming jump from 0x1594, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[3] // { // @1597 memory[0x40:0x60] // @15FC memory[0x40:0x60] // @1601 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1595 60 PUSH1 0x40 1597 51 MLOAD 1598 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 15B9 81 DUP2 15BA 52 MSTORE 15BB 60 PUSH1 0x04 15BD 01 ADD 15BE 80 DUP1 15BF 80 DUP1 15C0 60 PUSH1 0x20 15C2 01 ADD 15C3 82 DUP3 15C4 81 DUP2 15C5 03 SUB 15C6 82 DUP3 15C7 52 MSTORE 15C8 60 PUSH1 0x20 15CA 81 DUP2 15CB 52 MSTORE 15CC 60 PUSH1 0x20 15CE 01 ADD 15CF 80 DUP1 15D0 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 15F1 81 DUP2 15F2 52 MSTORE 15F3 50 POP 15F4 60 PUSH1 0x20 15F6 01 ADD 15F7 91 SWAP2 15F8 50 POP 15F9 50 POP 15FA 60 PUSH1 0x40 15FC 51 MLOAD 15FD 80 DUP1 15FE 91 SWAP2 15FF 03 SUB 1600 90 SWAP1 1601 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @15BA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @15C7 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @15CB memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20 // @15F2 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @1601 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1602: // Incoming jump from 0x1594, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[7] // { // @1605 address(this) // @1605 address(this).balance // @1608 msg.sender // @162A memory[0x40:0x60] // @162F memory[0x40:0x60] // @1637 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1637 address(0xffffffffffffffffffffffffffffffffffffffff & msg.sender).call.gas(!address(this).balance * 0x08fc).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // } 1602 5B JUMPDEST 1603 60 PUSH1 0x00 1605 47 SELFBALANCE 1606 90 SWAP1 1607 50 POP 1608 33 CALLER 1609 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 161E 16 AND 161F 61 PUSH2 0x08fc 1622 82 DUP3 1623 90 SWAP1 1624 81 DUP2 1625 15 ISZERO 1626 02 MUL 1627 90 SWAP1 1628 60 PUSH1 0x40 162A 51 MLOAD 162B 60 PUSH1 0x00 162D 60 PUSH1 0x40 162F 51 MLOAD 1630 80 DUP1 1631 83 DUP4 1632 03 SUB 1633 81 DUP2 1634 85 DUP6 1635 88 DUP9 1636 88 DUP9 1637 F1 CALL 1638 93 SWAP4 1639 50 POP 163A 50 POP 163B 50 POP 163C 50 POP 163D 15 ISZERO 163E 80 DUP1 163F 15 ISZERO 1640 61 PUSH2 0x164d 1643 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @1606 stack[0] = address(this).balance // @1637 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(0xffffffffffffffffffffffffffffffffffffffff & msg.sender).call.gas(!address(this).balance * 0x08fc).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // @163D stack[1] = !address(0xffffffffffffffffffffffffffffffffffffffff & msg.sender).call.gas(!address(this).balance * 0x08fc).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // } // Block ends with conditional jump to 0x164d, if !!address(0xffffffffffffffffffffffffffffffffffffffff & msg.sender).call.gas(!address(this).balance * 0x08fc).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) label_1644: // Incoming jump from 0x1643, if not !!address(0xffffffffffffffffffffffffffffffffffffffff & msg.sender).call.gas(!address(this).balance * 0x08fc).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // Inputs[4] // { // @1644 returndata.length // @1648 returndata[0x00:0x00 + returndata.length] // @1649 returndata.length // @164C memory[0x00:0x00 + returndata.length] // } 1644 3D RETURNDATASIZE 1645 60 PUSH1 0x00 1647 80 DUP1 1648 3E RETURNDATACOPY 1649 3D RETURNDATASIZE 164A 60 PUSH1 0x00 164C FD *REVERT // Stack delta = +0 // Outputs[2] // { // @1648 memory[0x00:0x00 + returndata.length] = returndata[0x00:0x00 + returndata.length] // @164C revert(memory[0x00:0x00 + returndata.length]); // } // Block terminates label_164D: // Incoming jump from 0x1643, if !!address(0xffffffffffffffffffffffffffffffffffffffff & msg.sender).call.gas(!address(this).balance * 0x08fc).value(address(this).balance)(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]]) // Inputs[1] { @1650 stack[-3] } 164D 5B JUMPDEST 164E 50 POP 164F 50 POP 1650 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_1651: // Incoming jump from 0x06C8 // Inputs[4] // { // @1655 stack[-3] // @1656 stack[-2] // @1657 stack[-1] // @165A memory[0x40:0x60] // } 1651 5B JUMPDEST 1652 61 PUSH2 0x166c 1655 83 DUP4 1656 83 DUP4 1657 83 DUP4 1658 60 PUSH1 0x40 165A 51 MLOAD 165B 80 DUP1 165C 60 PUSH1 0x20 165E 01 ADD 165F 60 PUSH1 0x40 1661 52 MSTORE 1662 80 DUP1 1663 60 PUSH1 0x00 1665 81 DUP2 1666 52 MSTORE 1667 50 POP 1668 61 PUSH2 0x220b 166B 56 *JUMP // Stack delta = +5 // Outputs[7] // { // @1652 stack[0] = 0x166c // @1655 stack[1] = stack[-3] // @1656 stack[2] = stack[-2] // @1657 stack[3] = stack[-1] // @165A stack[4] = memory[0x40:0x60] // @1661 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @1666 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x220b, returns to 0x166C label_166C: // Incoming return from call to 0x220B at 0x166B // Inputs[1] { @1670 stack[-4] } 166C 5B JUMPDEST 166D 50 POP 166E 50 POP 166F 50 POP 1670 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_1671: // Incoming jump from 0x0703 // Inputs[1] { @1678 stack[-1] } 1671 5B JUMPDEST 1672 60 PUSH1 0x00 1674 80 DUP1 1675 61 PUSH2 0x1688 1678 83 DUP4 1679 60 PUSH1 0x02 167B 61 PUSH2 0x2db0 167E 90 SWAP1 167F 91 SWAP2 1680 90 SWAP1 1681 63 PUSH4 0xffffffff 1686 16 AND 1687 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @1672 stack[0] = 0x00 // @1674 stack[1] = 0x00 // @1675 stack[2] = 0x1688 // @167F stack[3] = 0x02 // @1680 stack[4] = stack[-1] // } // Block ends with call to 0xffffffff & 0x2db0, returns to 0x1688 label_1688: // Incoming return from call to 0x2DB0 at 0x1687 // Inputs[5] // { // @168A stack[-3] // @168A stack[-2] // @168D stack[-4] // @1690 stack[-6] // @1691 stack[-5] // } 1688 5B JUMPDEST 1689 50 POP 168A 90 SWAP1 168B 50 POP 168C 80 DUP1 168D 91 SWAP2 168E 50 POP 168F 50 POP 1690 91 SWAP2 1691 90 SWAP1 1692 50 POP 1693 56 *JUMP // Stack delta = -5 // Outputs[1] { @1690 stack[-6] = stack[-2] } // Block ends with unconditional jump to stack[-6] label_1694: // Incoming jump from 0x07DF 1694 5B JUMPDEST 1695 61 PUSH2 0x169c 1698 61 PUSH2 0x296c 169B 56 *JUMP // Stack delta = +1 // Outputs[1] { @1695 stack[0] = 0x169c } // Block ends with call to 0x296c, returns to 0x169C label_169C: // Incoming return from call to 0x296C at 0x169B // Inputs[1] { @16B2 stack[-1] } 169C 5B JUMPDEST 169D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16B2 16 AND 16B3 61 PUSH2 0x16ba 16B6 61 PUSH2 0x1c4c 16B9 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @16B2 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @16B3 stack[0] = 0x16ba // } // Block ends with call to 0x1c4c, returns to 0x16BA label_16BA: // Incoming return from call to 0x1C4C at 0x16B9 // Inputs[2] // { // @16D0 stack[-1] // @16D1 stack[-2] // } 16BA 5B JUMPDEST 16BB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 16D0 16 AND 16D1 14 EQ 16D2 61 PUSH2 0x1743 16D5 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1743, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_16D6: // Incoming jump from 0x16D5, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[3] // { // @16D8 memory[0x40:0x60] // @173D memory[0x40:0x60] // @1742 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 16D6 60 PUSH1 0x40 16D8 51 MLOAD 16D9 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 16FA 81 DUP2 16FB 52 MSTORE 16FC 60 PUSH1 0x04 16FE 01 ADD 16FF 80 DUP1 1700 80 DUP1 1701 60 PUSH1 0x20 1703 01 ADD 1704 82 DUP3 1705 81 DUP2 1706 03 SUB 1707 82 DUP3 1708 52 MSTORE 1709 60 PUSH1 0x20 170B 81 DUP2 170C 52 MSTORE 170D 60 PUSH1 0x20 170F 01 ADD 1710 80 DUP1 1711 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 1732 81 DUP2 1733 52 MSTORE 1734 50 POP 1735 60 PUSH1 0x20 1737 01 ADD 1738 91 SWAP2 1739 50 POP 173A 50 POP 173B 60 PUSH1 0x40 173D 51 MLOAD 173E 80 DUP1 173F 91 SWAP2 1740 03 SUB 1741 90 SWAP1 1742 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @16FB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1708 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @170C memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20 // @1733 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @1742 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1743: // Incoming jump from 0x16D5, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @1747 stack[-1] } 1743 5B JUMPDEST 1744 61 PUSH2 0x174c 1747 81 DUP2 1748 61 PUSH2 0x2ddc 174B 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @1744 stack[0] = 0x174c // @1747 stack[1] = stack[-1] // } // Block ends with call to 0x2ddc, returns to 0x174C label_174C: // Incoming return from call to 0x2DDC at 0x174B // Inputs[1] { @174E stack[-2] } 174C 5B JUMPDEST 174D 50 POP 174E 56 *JUMP // Stack delta = -2 // Block ends with unconditional jump to stack[-2] label_174F: // Incoming call from 0x07F6, returns to 0x07F7 // Inputs[1] { @1752 stack[-1] } 174F 5B JUMPDEST 1750 60 PUSH1 0x14 1752 81 DUP2 1753 56 *JUMP // Stack delta = +1 // Outputs[1] { @1750 stack[0] = 0x14 } // Block ends with unconditional jump to stack[-1] label_1754: // Incoming call from 0x0821, returns to 0x0822 // Inputs[3] // { // @1758 storage[0x0b] // @1779 memory[0x40:0x60] // @178C storage[0x0b] // } 1754 5B JUMPDEST 1755 60 PUSH1 0x0b 1757 80 DUP1 1758 54 SLOAD 1759 60 PUSH1 0x01 175B 81 DUP2 175C 60 PUSH1 0x01 175E 16 AND 175F 15 ISZERO 1760 61 PUSH2 0x0100 1763 02 MUL 1764 03 SUB 1765 16 AND 1766 60 PUSH1 0x02 1768 90 SWAP1 1769 04 DIV 176A 80 DUP1 176B 60 PUSH1 0x1f 176D 01 ADD 176E 60 PUSH1 0x20 1770 80 DUP1 1771 91 SWAP2 1772 04 DIV 1773 02 MUL 1774 60 PUSH1 0x20 1776 01 ADD 1777 60 PUSH1 0x40 1779 51 MLOAD 177A 90 SWAP1 177B 81 DUP2 177C 01 ADD 177D 60 PUSH1 0x40 177F 52 MSTORE 1780 80 DUP1 1781 92 SWAP3 1782 91 SWAP2 1783 90 SWAP1 1784 81 DUP2 1785 81 DUP2 1786 52 MSTORE 1787 60 PUSH1 0x20 1789 01 ADD 178A 82 DUP3 178B 80 DUP1 178C 54 SLOAD 178D 60 PUSH1 0x01 178F 81 DUP2 1790 60 PUSH1 0x01 1792 16 AND 1793 15 ISZERO 1794 61 PUSH2 0x0100 1797 02 MUL 1798 03 SUB 1799 16 AND 179A 60 PUSH1 0x02 179C 90 SWAP1 179D 04 DIV 179E 80 DUP1 179F 15 ISZERO 17A0 61 PUSH2 0x17ea 17A3 57 *JUMPI // Stack delta = +6 // Outputs[8] // { // @177F memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02) / 0x20 * 0x20 // @1781 stack[0] = memory[0x40:0x60] // @1782 stack[1] = 0x0b // @1783 stack[2] = (0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02 // @1786 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02 // @1789 stack[3] = 0x20 + memory[0x40:0x60] // @178A stack[4] = 0x0b // @179D stack[5] = (0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02 // } // Block ends with conditional jump to 0x17ea, if !((0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02) label_17A4: // Incoming jump from 0x17A3, if not !((0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02) // Inputs[1] { @17A4 stack[-1] } 17A4 80 DUP1 17A5 60 PUSH1 0x1f 17A7 10 LT 17A8 61 PUSH2 0x17bf 17AB 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x17bf, if 0x1f < stack[-1] label_17AC: // Incoming jump from 0x17AB, if not 0x1f < stack[-1] // Inputs[4] // { // @17B0 stack[-2] // @17B1 storage[stack[-2]] // @17B4 stack[-3] // @17B6 stack[-1] // } 17AC 61 PUSH2 0x0100 17AF 80 DUP1 17B0 83 DUP4 17B1 54 SLOAD 17B2 04 DIV 17B3 02 MUL 17B4 83 DUP4 17B5 52 MSTORE 17B6 91 SWAP2 17B7 60 PUSH1 0x20 17B9 01 ADD 17BA 91 SWAP2 17BB 61 PUSH2 0x17ea 17BE 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @17B5 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @17BA stack[-1] = stack[-1] // @17BA stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x17ea label_17BF: // Incoming jump from 0x17AB, if 0x1f < stack[-1] // Inputs[5] // { // @17C0 stack[-3] // @17C1 stack[-1] // @17C3 stack[-2] // @17CB memory[0x00:0x20] // @17CF storage[keccak256(memory[0x00:0x20])] // } 17BF 5B JUMPDEST 17C0 82 DUP3 17C1 01 ADD 17C2 91 SWAP2 17C3 90 SWAP1 17C4 60 PUSH1 0x00 17C6 52 MSTORE 17C7 60 PUSH1 0x20 17C9 60 PUSH1 0x00 17CB 20 SHA3 17CC 90 SWAP1 17CD 5B JUMPDEST 17CE 81 DUP2 17CF 54 SLOAD 17D0 81 DUP2 17D1 52 MSTORE 17D2 90 SWAP1 17D3 60 PUSH1 0x01 17D5 01 ADD 17D6 90 SWAP1 17D7 60 PUSH1 0x20 17D9 01 ADD 17DA 80 DUP1 17DB 83 DUP4 17DC 11 GT 17DD 61 PUSH2 0x17cd 17E0 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @17C2 stack[-3] = stack[-3] + stack[-1] // @17C6 memory[0x00:0x20] = stack[-2] // @17D1 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @17D6 stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @17D9 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x17cd, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_17E1: // Incoming jump from 0x17E0, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x17E0, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @17E1 stack[-3] // @17E2 stack[-1] // } 17E1 82 DUP3 17E2 90 SWAP1 17E3 03 SUB 17E4 60 PUSH1 0x1f 17E6 16 AND 17E7 82 DUP3 17E8 01 ADD 17E9 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @17E9 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @17E9 stack[-1] = stack[-3] // } // Block continues label_17EA: // Incoming jump from 0x17BE // Incoming jump from 0x17A3, if !((0x0100 * !(0x01 & storage[0x0b]) - 0x01 & storage[0x0b]) / 0x02) // Incoming jump from 0x17E9 // Inputs[1] { @17F0 stack[-7] } 17EA 5B JUMPDEST 17EB 50 POP 17EC 50 POP 17ED 50 POP 17EE 50 POP 17EF 50 POP 17F0 81 DUP2 17F1 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-7] label_17F2: // Incoming jump from 0x08D5 // Incoming call from 0x2B72, returns to 0x2B73 // Incoming call from 0x2AC9, returns to 0x2ACA // Incoming call from 0x2A03, returns to 0x2A04 // Incoming call from 0x118D, returns to 0x118E // Inputs[2] // { // @17F8 stack[-1] // @17FB memory[0x40:0x60] // } 17F2 5B JUMPDEST 17F3 60 PUSH1 0x00 17F5 61 PUSH2 0x1822 17F8 82 DUP3 17F9 60 PUSH1 0x40 17FB 51 MLOAD 17FC 80 DUP1 17FD 60 PUSH1 0x60 17FF 01 ADD 1800 60 PUSH1 0x40 1802 52 MSTORE 1803 80 DUP1 1804 60 PUSH1 0x29 1806 81 DUP2 1807 52 MSTORE 1808 60 PUSH1 0x20 180A 01 ADD 180B 61 PUSH2 0x3ff7 180E 60 PUSH1 0x29 1810 91 SWAP2 1811 39 CODECOPY 1812 60 PUSH1 0x02 1814 61 PUSH2 0x2df6 1817 90 SWAP1 1818 92 SWAP3 1819 91 SWAP2 181A 90 SWAP1 181B 63 PUSH4 0xffffffff 1820 16 AND 1821 56 *JUMP // Stack delta = +5 // Outputs[8] // { // @17F3 stack[0] = 0x00 // @17F5 stack[1] = 0x1822 // @1802 memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @1807 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x29 // @1811 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x29] = code[0x3ff7:0x4020] // @1818 stack[2] = 0x02 // @1819 stack[3] = stack[-1] // @181A stack[4] = memory[0x40:0x60] // } // Block ends with call to 0xffffffff & 0x2df6, returns to 0x1822 label_1822: // Incoming return from call to 0x2DF6 at 0x1821 // Inputs[4] // { // @1823 stack[-1] // @1823 stack[-2] // @1825 stack[-4] // @1826 stack[-3] // } 1822 5B JUMPDEST 1823 90 SWAP1 1824 50 POP 1825 91 SWAP2 1826 90 SWAP1 1827 50 POP 1828 56 *JUMP // Stack delta = -3 // Outputs[1] { @1825 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_1829: // Incoming call from 0x0916, returns to 0x0917 // Incoming call from 0x23A2, returns to 0x23A3 // Inputs[3] // { // @182F storage[0x09] // @1850 memory[0x40:0x60] // @1863 storage[0x09] // } 1829 5B JUMPDEST 182A 60 PUSH1 0x60 182C 60 PUSH1 0x09 182E 80 DUP1 182F 54 SLOAD 1830 60 PUSH1 0x01 1832 81 DUP2 1833 60 PUSH1 0x01 1835 16 AND 1836 15 ISZERO 1837 61 PUSH2 0x0100 183A 02 MUL 183B 03 SUB 183C 16 AND 183D 60 PUSH1 0x02 183F 90 SWAP1 1840 04 DIV 1841 80 DUP1 1842 60 PUSH1 0x1f 1844 01 ADD 1845 60 PUSH1 0x20 1847 80 DUP1 1848 91 SWAP2 1849 04 DIV 184A 02 MUL 184B 60 PUSH1 0x20 184D 01 ADD 184E 60 PUSH1 0x40 1850 51 MLOAD 1851 90 SWAP1 1852 81 DUP2 1853 01 ADD 1854 60 PUSH1 0x40 1856 52 MSTORE 1857 80 DUP1 1858 92 SWAP3 1859 91 SWAP2 185A 90 SWAP1 185B 81 DUP2 185C 81 DUP2 185D 52 MSTORE 185E 60 PUSH1 0x20 1860 01 ADD 1861 82 DUP3 1862 80 DUP1 1863 54 SLOAD 1864 60 PUSH1 0x01 1866 81 DUP2 1867 60 PUSH1 0x01 1869 16 AND 186A 15 ISZERO 186B 61 PUSH2 0x0100 186E 02 MUL 186F 03 SUB 1870 16 AND 1871 60 PUSH1 0x02 1873 90 SWAP1 1874 04 DIV 1875 80 DUP1 1876 15 ISZERO 1877 61 PUSH2 0x18c1 187A 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @182A stack[0] = 0x60 // @1856 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x09]) - 0x01 & storage[0x09]) / 0x02) / 0x20 * 0x20 // @1858 stack[1] = memory[0x40:0x60] // @1859 stack[2] = 0x09 // @185A stack[3] = (0x0100 * !(0x01 & storage[0x09]) - 0x01 & storage[0x09]) / 0x02 // @185D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x09]) - 0x01 & storage[0x09]) / 0x02 // @1860 stack[4] = 0x20 + memory[0x40:0x60] // @1861 stack[5] = 0x09 // @1874 stack[6] = (0x0100 * !(0x01 & storage[0x09]) - 0x01 & storage[0x09]) / 0x02 // } // Block ends with conditional jump to 0x18c1, if !((0x0100 * !(0x01 & storage[0x09]) - 0x01 & storage[0x09]) / 0x02) label_187B: // Incoming jump from 0x187A, if not !((0x0100 * !(0x01 & storage[0x09]) - 0x01 & storage[0x09]) / 0x02) // Inputs[1] { @187B stack[-1] } 187B 80 DUP1 187C 60 PUSH1 0x1f 187E 10 LT 187F 61 PUSH2 0x1896 1882 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1896, if 0x1f < stack[-1] label_1883: // Incoming jump from 0x1882, if not 0x1f < stack[-1] // Inputs[4] // { // @1887 stack[-2] // @1888 storage[stack[-2]] // @188B stack[-3] // @188D stack[-1] // } 1883 61 PUSH2 0x0100 1886 80 DUP1 1887 83 DUP4 1888 54 SLOAD 1889 04 DIV 188A 02 MUL 188B 83 DUP4 188C 52 MSTORE 188D 91 SWAP2 188E 60 PUSH1 0x20 1890 01 ADD 1891 91 SWAP2 1892 61 PUSH2 0x18c1 1895 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @188C memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1891 stack[-1] = stack[-1] // @1891 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x18c1 label_1896: // Incoming jump from 0x1882, if 0x1f < stack[-1] // Inputs[5] // { // @1897 stack[-3] // @1898 stack[-1] // @189A stack[-2] // @18A2 memory[0x00:0x20] // @18A6 storage[keccak256(memory[0x00:0x20])] // } 1896 5B JUMPDEST 1897 82 DUP3 1898 01 ADD 1899 91 SWAP2 189A 90 SWAP1 189B 60 PUSH1 0x00 189D 52 MSTORE 189E 60 PUSH1 0x20 18A0 60 PUSH1 0x00 18A2 20 SHA3 18A3 90 SWAP1 18A4 5B JUMPDEST 18A5 81 DUP2 18A6 54 SLOAD 18A7 81 DUP2 18A8 52 MSTORE 18A9 90 SWAP1 18AA 60 PUSH1 0x01 18AC 01 ADD 18AD 90 SWAP1 18AE 60 PUSH1 0x20 18B0 01 ADD 18B1 80 DUP1 18B2 83 DUP4 18B3 11 GT 18B4 61 PUSH2 0x18a4 18B7 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1899 stack[-3] = stack[-3] + stack[-1] // @189D memory[0x00:0x20] = stack[-2] // @18A8 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @18AD stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @18B0 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x18a4, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_18B8: // Incoming jump from 0x18B7, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x18B7, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @18B8 stack[-3] // @18B9 stack[-1] // } 18B8 82 DUP3 18B9 90 SWAP1 18BA 03 SUB 18BB 60 PUSH1 0x1f 18BD 16 AND 18BE 82 DUP3 18BF 01 ADD 18C0 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @18C0 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @18C0 stack[-1] = stack[-3] // } // Block continues label_18C1: // Incoming jump from 0x1895 // Incoming jump from 0x187A, if !((0x0100 * !(0x01 & storage[0x09]) - 0x01 & storage[0x09]) / 0x02) // Incoming jump from 0x18C0 // Inputs[3] // { // @18C7 stack[-7] // @18C7 stack[-6] // @18C9 stack[-8] // } 18C1 5B JUMPDEST 18C2 50 POP 18C3 50 POP 18C4 50 POP 18C5 50 POP 18C6 50 POP 18C7 90 SWAP1 18C8 50 POP 18C9 90 SWAP1 18CA 56 *JUMP // Stack delta = -7 // Outputs[1] { @18C9 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_18CB: // Incoming jump from 0x09E0 // Inputs[1] { @18E5 stack[-1] } 18CB 5B JUMPDEST 18CC 60 PUSH1 0x00 18CE 80 DUP1 18CF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18E4 16 AND 18E5 82 DUP3 18E6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 18FB 16 AND 18FC 14 EQ 18FD 15 ISZERO 18FE 61 PUSH2 0x1952 1901 57 *JUMPI // Stack delta = +1 // Outputs[1] { @18CC stack[0] = 0x00 } // Block ends with conditional jump to 0x1952, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_1902: // Incoming jump from 0x1901, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @1904 memory[0x40:0x60] // @194C memory[0x40:0x60] // @1951 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1902 60 PUSH1 0x40 1904 51 MLOAD 1905 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1926 81 DUP2 1927 52 MSTORE 1928 60 PUSH1 0x04 192A 01 ADD 192B 80 DUP1 192C 80 DUP1 192D 60 PUSH1 0x20 192F 01 ADD 1930 82 DUP3 1931 81 DUP2 1932 03 SUB 1933 82 DUP3 1934 52 MSTORE 1935 60 PUSH1 0x2a 1937 81 DUP2 1938 52 MSTORE 1939 60 PUSH1 0x20 193B 01 ADD 193C 80 DUP1 193D 61 PUSH2 0x3fcd 1940 60 PUSH1 0x2a 1942 91 SWAP2 1943 39 CODECOPY 1944 60 PUSH1 0x40 1946 01 ADD 1947 91 SWAP2 1948 50 POP 1949 50 POP 194A 60 PUSH1 0x40 194C 51 MLOAD 194D 80 DUP1 194E 91 SWAP2 194F 03 SUB 1950 90 SWAP1 1951 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1927 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1934 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1938 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2a // @1943 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2a] = code[0x3fcd:0x3ff7] // @1951 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1952: // Incoming jump from 0x1901, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[2] // { // @195A stack[-2] // @1994 memory[0x00:0x40] // } 1952 5B JUMPDEST 1953 61 PUSH2 0x1999 1956 60 PUSH1 0x01 1958 60 PUSH1 0x00 195A 84 DUP5 195B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1970 16 AND 1971 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1986 16 AND 1987 81 DUP2 1988 52 MSTORE 1989 60 PUSH1 0x20 198B 01 ADD 198C 90 SWAP1 198D 81 DUP2 198E 52 MSTORE 198F 60 PUSH1 0x20 1991 01 ADD 1992 60 PUSH1 0x00 1994 20 SHA3 1995 61 PUSH2 0x2e15 1998 56 *JUMP // Stack delta = +2 // Outputs[4] // { // @1953 stack[0] = 0x1999 // @1988 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @198E memory[0x20:0x40] = 0x01 // @1994 stack[1] = keccak256(memory[0x00:0x40]) // } // Block ends with call to 0x2e15, returns to 0x1999 label_1999: // Incoming return from call to 0x2E15 at 0x1998 // Inputs[4] // { // @199A stack[-1] // @199A stack[-2] // @199C stack[-4] // @199D stack[-3] // } 1999 5B JUMPDEST 199A 90 SWAP1 199B 50 POP 199C 91 SWAP2 199D 90 SWAP1 199E 50 POP 199F 56 *JUMP // Stack delta = -3 // Outputs[1] { @199C stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_19A0: // Incoming call from 0x0A0B, returns to 0x0A0C 19A0 5B JUMPDEST 19A1 61 PUSH2 0x19a8 19A4 61 PUSH2 0x296c 19A7 56 *JUMP // Stack delta = +1 // Outputs[1] { @19A1 stack[0] = 0x19a8 } // Block ends with call to 0x296c, returns to 0x19A8 label_19A8: // Incoming return from call to 0x296C at 0x19A7 // Inputs[1] { @19BE stack[-1] } 19A8 5B JUMPDEST 19A9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19BE 16 AND 19BF 61 PUSH2 0x19c6 19C2 61 PUSH2 0x1c4c 19C5 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @19BE stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @19BF stack[0] = 0x19c6 // } // Block ends with call to 0x1c4c, returns to 0x19C6 label_19C6: // Incoming return from call to 0x1C4C at 0x19C5 // Inputs[2] // { // @19DC stack[-1] // @19DD stack[-2] // } 19C6 5B JUMPDEST 19C7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 19DC 16 AND 19DD 14 EQ 19DE 61 PUSH2 0x1a4f 19E1 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1a4f, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_19E2: // Incoming jump from 0x19E1, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[3] // { // @19E4 memory[0x40:0x60] // @1A49 memory[0x40:0x60] // @1A4E memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 19E2 60 PUSH1 0x40 19E4 51 MLOAD 19E5 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1A06 81 DUP2 1A07 52 MSTORE 1A08 60 PUSH1 0x04 1A0A 01 ADD 1A0B 80 DUP1 1A0C 80 DUP1 1A0D 60 PUSH1 0x20 1A0F 01 ADD 1A10 82 DUP3 1A11 81 DUP2 1A12 03 SUB 1A13 82 DUP3 1A14 52 MSTORE 1A15 60 PUSH1 0x20 1A17 81 DUP2 1A18 52 MSTORE 1A19 60 PUSH1 0x20 1A1B 01 ADD 1A1C 80 DUP1 1A1D 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 1A3E 81 DUP2 1A3F 52 MSTORE 1A40 50 POP 1A41 60 PUSH1 0x20 1A43 01 ADD 1A44 91 SWAP2 1A45 50 POP 1A46 50 POP 1A47 60 PUSH1 0x40 1A49 51 MLOAD 1A4A 80 DUP1 1A4B 91 SWAP2 1A4C 03 SUB 1A4D 90 SWAP1 1A4E FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1A07 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1A14 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1A18 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20 // @1A3F memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @1A4E revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1A4F: // Incoming jump from 0x19E1, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[6] // { // @1A6D storage[0x0a] // @1AC4 memory[0x40:0x60] // @1AC7 memory[0x40:0x60] // @1ACC memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @1AD8 storage[0x0a] // @1B0F stack[-1] // } 1A4F 5B JUMPDEST 1A50 60 PUSH1 0x00 1A52 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A67 16 AND 1A68 60 PUSH1 0x0a 1A6A 60 PUSH1 0x00 1A6C 90 SWAP1 1A6D 54 SLOAD 1A6E 90 SWAP1 1A6F 61 PUSH2 0x0100 1A72 0A EXP 1A73 90 SWAP1 1A74 04 DIV 1A75 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1A8A 16 AND 1A8B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AA0 16 AND 1AA1 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 1AC2 60 PUSH1 0x40 1AC4 51 MLOAD 1AC5 60 PUSH1 0x40 1AC7 51 MLOAD 1AC8 80 DUP1 1AC9 91 SWAP2 1ACA 03 SUB 1ACB 90 SWAP1 1ACC A3 LOG3 1ACD 60 PUSH1 0x00 1ACF 60 PUSH1 0x0a 1AD1 60 PUSH1 0x00 1AD3 61 PUSH2 0x0100 1AD6 0A EXP 1AD7 81 DUP2 1AD8 54 SLOAD 1AD9 81 DUP2 1ADA 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1AEF 02 MUL 1AF0 19 NOT 1AF1 16 AND 1AF2 90 SWAP1 1AF3 83 DUP4 1AF4 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B09 16 AND 1B0A 02 MUL 1B0B 17 OR 1B0C 90 SWAP1 1B0D 55 SSTORE 1B0E 50 POP 1B0F 56 *JUMP // Stack delta = -1 // Outputs[2] // { // @1ACC log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x0a] & 0xffffffffffffffffffffffffffffffffffffffff, 0xffffffffffffffffffffffffffffffffffffffff & 0x00]); // @1B0D storage[0x0a] = (0xffffffffffffffffffffffffffffffffffffffff & 0x00) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x0a]) // } // Block ends with unconditional jump to stack[-1] label_1B10: // Incoming call from 0x0A22, returns to 0x0A23 // Inputs[1] { @1B1A stack[-1] } 1B10 5B JUMPDEST 1B11 67 PUSH8 0x011c37937e080000 1B1A 81 DUP2 1B1B 56 *JUMP // Stack delta = +1 // Outputs[1] { @1B11 stack[0] = 0x011c37937e080000 } // Block ends with unconditional jump to stack[-1] label_1B1C: // Incoming call from 0x0A4D, returns to 0x0A4E 1B1C 5B JUMPDEST 1B1D 61 PUSH2 0x1b24 1B20 61 PUSH2 0x296c 1B23 56 *JUMP // Stack delta = +1 // Outputs[1] { @1B1D stack[0] = 0x1b24 } // Block ends with call to 0x296c, returns to 0x1B24 label_1B24: // Incoming return from call to 0x296C at 0x1B23 // Inputs[1] { @1B3A stack[-1] } 1B24 5B JUMPDEST 1B25 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B3A 16 AND 1B3B 61 PUSH2 0x1b42 1B3E 61 PUSH2 0x1c4c 1B41 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @1B3A stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1B3B stack[0] = 0x1b42 // } // Block ends with call to 0x1c4c, returns to 0x1B42 label_1B42: // Incoming return from call to 0x1C4C at 0x1B41 // Inputs[2] // { // @1B58 stack[-1] // @1B59 stack[-2] // } 1B42 5B JUMPDEST 1B43 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1B58 16 AND 1B59 14 EQ 1B5A 61 PUSH2 0x1bcb 1B5D 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x1bcb, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_1B5E: // Incoming jump from 0x1B5D, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[3] // { // @1B60 memory[0x40:0x60] // @1BC5 memory[0x40:0x60] // @1BCA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1B5E 60 PUSH1 0x40 1B60 51 MLOAD 1B61 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1B82 81 DUP2 1B83 52 MSTORE 1B84 60 PUSH1 0x04 1B86 01 ADD 1B87 80 DUP1 1B88 80 DUP1 1B89 60 PUSH1 0x20 1B8B 01 ADD 1B8C 82 DUP3 1B8D 81 DUP2 1B8E 03 SUB 1B8F 82 DUP3 1B90 52 MSTORE 1B91 60 PUSH1 0x20 1B93 81 DUP2 1B94 52 MSTORE 1B95 60 PUSH1 0x20 1B97 01 ADD 1B98 80 DUP1 1B99 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 1BBA 81 DUP2 1BBB 52 MSTORE 1BBC 50 POP 1BBD 60 PUSH1 0x20 1BBF 01 ADD 1BC0 91 SWAP2 1BC1 50 POP 1BC2 50 POP 1BC3 60 PUSH1 0x40 1BC5 51 MLOAD 1BC6 80 DUP1 1BC7 91 SWAP2 1BC8 03 SUB 1BC9 90 SWAP1 1BCA FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1B83 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1B90 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1B94 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20 // @1BBB memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @1BCA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1BCB: // Incoming jump from 0x1B5D, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @1BD0 storage[0x0d] } 1BCB 5B JUMPDEST 1BCC 60 PUSH1 0x00 1BCE 60 PUSH1 0x0d 1BD0 54 SLOAD 1BD1 14 EQ 1BD2 61 PUSH2 0x1c43 1BD5 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1c43, if storage[0x0d] == 0x00 label_1BD6: // Incoming jump from 0x1BD5, if not storage[0x0d] == 0x00 // Inputs[3] // { // @1BD8 memory[0x40:0x60] // @1C3D memory[0x40:0x60] // @1C42 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1BD6 60 PUSH1 0x40 1BD8 51 MLOAD 1BD9 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1BFA 81 DUP2 1BFB 52 MSTORE 1BFC 60 PUSH1 0x04 1BFE 01 ADD 1BFF 80 DUP1 1C00 80 DUP1 1C01 60 PUSH1 0x20 1C03 01 ADD 1C04 82 DUP3 1C05 81 DUP2 1C06 03 SUB 1C07 82 DUP3 1C08 52 MSTORE 1C09 60 PUSH1 0x1d 1C0B 81 DUP2 1C0C 52 MSTORE 1C0D 60 PUSH1 0x20 1C0F 01 ADD 1C10 80 DUP1 1C11 7F PUSH32 0x5374617274696e6720696e64657820697320616c726561647920736574000000 1C32 81 DUP2 1C33 52 MSTORE 1C34 50 POP 1C35 60 PUSH1 0x20 1C37 01 ADD 1C38 91 SWAP2 1C39 50 POP 1C3A 50 POP 1C3B 60 PUSH1 0x40 1C3D 51 MLOAD 1C3E 80 DUP1 1C3F 91 SWAP2 1C40 03 SUB 1C41 90 SWAP1 1C42 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1BFB memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1C08 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1C0C memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x1d // @1C33 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x5374617274696e6720696e64657820697320616c726561647920736574000000 // @1C42 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1C43: // Incoming jump from 0x1BD5, if storage[0x0d] == 0x00 // Inputs[2] // { // @1C44 block.number // @1C4B stack[-1] // } 1C43 5B JUMPDEST 1C44 43 NUMBER 1C45 60 PUSH1 0x0c 1C47 81 DUP2 1C48 90 SWAP1 1C49 55 SSTORE 1C4A 50 POP 1C4B 56 *JUMP // Stack delta = -1 // Outputs[1] { @1C49 storage[0x0c] = block.number } // Block ends with unconditional jump to stack[-1] label_1C4C: // Incoming call from 0x0F4B, returns to 0x0F4C // Incoming call from 0x16B9, returns to 0x16BA // Incoming call from 0x149D, returns to 0x149E // Incoming call from 0x19C5, returns to 0x19C6 // Incoming call from 0x1578, returns to 0x1579 // Incoming call from 0x214C, returns to 0x214D // Incoming call from 0x1B41, returns to 0x1B42 // Incoming call from 0x279C, returns to 0x279D // Incoming call from 0x0A64, returns to 0x0A65 // Incoming call from 0x12EC, returns to 0x12ED // Inputs[2] // { // @1C54 storage[0x0a] // @1C74 stack[-1] // } 1C4C 5B JUMPDEST 1C4D 60 PUSH1 0x00 1C4F 60 PUSH1 0x0a 1C51 60 PUSH1 0x00 1C53 90 SWAP1 1C54 54 SLOAD 1C55 90 SWAP1 1C56 61 PUSH2 0x0100 1C59 0A EXP 1C5A 90 SWAP1 1C5B 04 DIV 1C5C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1C71 16 AND 1C72 90 SWAP1 1C73 50 POP 1C74 90 SWAP1 1C75 56 *JUMP // Stack delta = +0 // Outputs[1] { @1C74 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & storage[0x0a] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_1C76: // Incoming call from 0x0AA5, returns to 0x0AA6 // Inputs[3] // { // @1C7C storage[0x07] // @1C9D memory[0x40:0x60] // @1CB0 storage[0x07] // } 1C76 5B JUMPDEST 1C77 60 PUSH1 0x60 1C79 60 PUSH1 0x07 1C7B 80 DUP1 1C7C 54 SLOAD 1C7D 60 PUSH1 0x01 1C7F 81 DUP2 1C80 60 PUSH1 0x01 1C82 16 AND 1C83 15 ISZERO 1C84 61 PUSH2 0x0100 1C87 02 MUL 1C88 03 SUB 1C89 16 AND 1C8A 60 PUSH1 0x02 1C8C 90 SWAP1 1C8D 04 DIV 1C8E 80 DUP1 1C8F 60 PUSH1 0x1f 1C91 01 ADD 1C92 60 PUSH1 0x20 1C94 80 DUP1 1C95 91 SWAP2 1C96 04 DIV 1C97 02 MUL 1C98 60 PUSH1 0x20 1C9A 01 ADD 1C9B 60 PUSH1 0x40 1C9D 51 MLOAD 1C9E 90 SWAP1 1C9F 81 DUP2 1CA0 01 ADD 1CA1 60 PUSH1 0x40 1CA3 52 MSTORE 1CA4 80 DUP1 1CA5 92 SWAP3 1CA6 91 SWAP2 1CA7 90 SWAP1 1CA8 81 DUP2 1CA9 81 DUP2 1CAA 52 MSTORE 1CAB 60 PUSH1 0x20 1CAD 01 ADD 1CAE 82 DUP3 1CAF 80 DUP1 1CB0 54 SLOAD 1CB1 60 PUSH1 0x01 1CB3 81 DUP2 1CB4 60 PUSH1 0x01 1CB6 16 AND 1CB7 15 ISZERO 1CB8 61 PUSH2 0x0100 1CBB 02 MUL 1CBC 03 SUB 1CBD 16 AND 1CBE 60 PUSH1 0x02 1CC0 90 SWAP1 1CC1 04 DIV 1CC2 80 DUP1 1CC3 15 ISZERO 1CC4 61 PUSH2 0x1d0e 1CC7 57 *JUMPI // Stack delta = +7 // Outputs[9] // { // @1C77 stack[0] = 0x60 // @1CA3 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02) / 0x20 * 0x20 // @1CA5 stack[1] = memory[0x40:0x60] // @1CA6 stack[2] = 0x07 // @1CA7 stack[3] = (0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02 // @1CAA memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02 // @1CAD stack[4] = 0x20 + memory[0x40:0x60] // @1CAE stack[5] = 0x07 // @1CC1 stack[6] = (0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02 // } // Block ends with conditional jump to 0x1d0e, if !((0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02) label_1CC8: // Incoming jump from 0x1CC7, if not !((0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02) // Inputs[1] { @1CC8 stack[-1] } 1CC8 80 DUP1 1CC9 60 PUSH1 0x1f 1CCB 10 LT 1CCC 61 PUSH2 0x1ce3 1CCF 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1ce3, if 0x1f < stack[-1] label_1CD0: // Incoming jump from 0x1CCF, if not 0x1f < stack[-1] // Inputs[4] // { // @1CD4 stack[-2] // @1CD5 storage[stack[-2]] // @1CD8 stack[-3] // @1CDA stack[-1] // } 1CD0 61 PUSH2 0x0100 1CD3 80 DUP1 1CD4 83 DUP4 1CD5 54 SLOAD 1CD6 04 DIV 1CD7 02 MUL 1CD8 83 DUP4 1CD9 52 MSTORE 1CDA 91 SWAP2 1CDB 60 PUSH1 0x20 1CDD 01 ADD 1CDE 91 SWAP2 1CDF 61 PUSH2 0x1d0e 1CE2 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @1CD9 memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @1CDE stack[-1] = stack[-1] // @1CDE stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x1d0e label_1CE3: // Incoming jump from 0x1CCF, if 0x1f < stack[-1] // Inputs[5] // { // @1CE4 stack[-3] // @1CE5 stack[-1] // @1CE7 stack[-2] // @1CEF memory[0x00:0x20] // @1CF3 storage[keccak256(memory[0x00:0x20])] // } 1CE3 5B JUMPDEST 1CE4 82 DUP3 1CE5 01 ADD 1CE6 91 SWAP2 1CE7 90 SWAP1 1CE8 60 PUSH1 0x00 1CEA 52 MSTORE 1CEB 60 PUSH1 0x20 1CED 60 PUSH1 0x00 1CEF 20 SHA3 1CF0 90 SWAP1 1CF1 5B JUMPDEST 1CF2 81 DUP2 1CF3 54 SLOAD 1CF4 81 DUP2 1CF5 52 MSTORE 1CF6 90 SWAP1 1CF7 60 PUSH1 0x01 1CF9 01 ADD 1CFA 90 SWAP1 1CFB 60 PUSH1 0x20 1CFD 01 ADD 1CFE 80 DUP1 1CFF 83 DUP4 1D00 11 GT 1D01 61 PUSH2 0x1cf1 1D04 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @1CE6 stack[-3] = stack[-3] + stack[-1] // @1CEA memory[0x00:0x20] = stack[-2] // @1CF5 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @1CFA stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @1CFD stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x1cf1, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_1D05: // Incoming jump from 0x1D04, if not stack[-3] > 0x20 + stack[-1] // Incoming jump from 0x1D04, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Inputs[2] // { // @1D05 stack[-3] // @1D06 stack[-1] // } 1D05 82 DUP3 1D06 90 SWAP1 1D07 03 SUB 1D08 60 PUSH1 0x1f 1D0A 16 AND 1D0B 82 DUP3 1D0C 01 ADD 1D0D 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @1D0D stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @1D0D stack[-1] = stack[-3] // } // Block continues label_1D0E: // Incoming jump from 0x1CC7, if !((0x0100 * !(0x01 & storage[0x07]) - 0x01 & storage[0x07]) / 0x02) // Incoming jump from 0x1D0D // Incoming jump from 0x1CE2 // Inputs[3] // { // @1D14 stack[-7] // @1D14 stack[-6] // @1D16 stack[-8] // } 1D0E 5B JUMPDEST 1D0F 50 POP 1D10 50 POP 1D11 50 POP 1D12 50 POP 1D13 50 POP 1D14 90 SWAP1 1D15 50 POP 1D16 90 SWAP1 1D17 56 *JUMP // Stack delta = -7 // Outputs[1] { @1D16 stack[-8] = stack[-6] } // Block ends with unconditional jump to stack[-8] label_1D18: // Incoming jump from 0x0B7B 1D18 5B JUMPDEST 1D19 61 PUSH2 0x1d20 1D1C 61 PUSH2 0x296c 1D1F 56 *JUMP // Stack delta = +1 // Outputs[1] { @1D19 stack[0] = 0x1d20 } // Block ends with call to 0x296c, returns to 0x1D20 label_1D20: // Incoming return from call to 0x296C at 0x1D1F // Inputs[2] // { // @1D36 stack[-1] // @1D37 stack[-3] // } 1D20 5B JUMPDEST 1D21 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D36 16 AND 1D37 82 DUP3 1D38 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1D4D 16 AND 1D4E 14 EQ 1D4F 15 ISZERO 1D50 61 PUSH2 0x1dc1 1D53 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x1dc1, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) label_1D54: // Incoming jump from 0x1D53, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[3] // { // @1D56 memory[0x40:0x60] // @1DBB memory[0x40:0x60] // @1DC0 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1D54 60 PUSH1 0x40 1D56 51 MLOAD 1D57 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1D78 81 DUP2 1D79 52 MSTORE 1D7A 60 PUSH1 0x04 1D7C 01 ADD 1D7D 80 DUP1 1D7E 80 DUP1 1D7F 60 PUSH1 0x20 1D81 01 ADD 1D82 82 DUP3 1D83 81 DUP2 1D84 03 SUB 1D85 82 DUP3 1D86 52 MSTORE 1D87 60 PUSH1 0x19 1D89 81 DUP2 1D8A 52 MSTORE 1D8B 60 PUSH1 0x20 1D8D 01 ADD 1D8E 80 DUP1 1D8F 7F PUSH32 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 1DB0 81 DUP2 1DB1 52 MSTORE 1DB2 50 POP 1DB3 60 PUSH1 0x20 1DB5 01 ADD 1DB6 91 SWAP2 1DB7 50 POP 1DB8 50 POP 1DB9 60 PUSH1 0x40 1DBB 51 MLOAD 1DBC 80 DUP1 1DBD 91 SWAP2 1DBE 03 SUB 1DBF 90 SWAP1 1DC0 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1D79 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1D86 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1D8A memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x19 // @1DB1 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4552433732313a20617070726f766520746f2063616c6c657200000000000000 // @1DC0 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1DC1: // Incoming jump from 0x1D53, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-3] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) // Inputs[1] { @1DC2 stack[-1] } 1DC1 5B JUMPDEST 1DC2 80 DUP1 1DC3 60 PUSH1 0x05 1DC5 60 PUSH1 0x00 1DC7 61 PUSH2 0x1dce 1DCA 61 PUSH2 0x296c 1DCD 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1DC2 stack[0] = stack[-1] // @1DC3 stack[1] = 0x05 // @1DC5 stack[2] = 0x00 // @1DC7 stack[3] = 0x1dce // } // Block ends with call to 0x296c, returns to 0x1DCE label_1DCE: // Incoming return from call to 0x296C at 0x1DCD // Inputs[8] // { // @1DE4 stack[-1] // @1DFB stack[-2] // @1E00 stack[-3] // @1E08 memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]] // @1E0B stack[-6] // @1E45 memory[0x00:0x40] // @1E4D storage[keccak256(memory[0x00:0x40])] // @1E55 stack[-4] // } 1DCE 5B JUMPDEST 1DCF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1DE4 16 AND 1DE5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1DFA 16 AND 1DFB 81 DUP2 1DFC 52 MSTORE 1DFD 60 PUSH1 0x20 1DFF 01 ADD 1E00 90 SWAP1 1E01 81 DUP2 1E02 52 MSTORE 1E03 60 PUSH1 0x20 1E05 01 ADD 1E06 60 PUSH1 0x00 1E08 20 SHA3 1E09 60 PUSH1 0x00 1E0B 84 DUP5 1E0C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E21 16 AND 1E22 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E37 16 AND 1E38 81 DUP2 1E39 52 MSTORE 1E3A 60 PUSH1 0x20 1E3C 01 ADD 1E3D 90 SWAP1 1E3E 81 DUP2 1E3F 52 MSTORE 1E40 60 PUSH1 0x20 1E42 01 ADD 1E43 60 PUSH1 0x00 1E45 20 SHA3 1E46 60 PUSH1 0x00 1E48 61 PUSH2 0x0100 1E4B 0A EXP 1E4C 81 DUP2 1E4D 54 SLOAD 1E4E 81 DUP2 1E4F 60 PUSH1 0xff 1E51 02 MUL 1E52 19 NOT 1E53 16 AND 1E54 90 SWAP1 1E55 83 DUP4 1E56 15 ISZERO 1E57 15 ISZERO 1E58 02 MUL 1E59 17 OR 1E5A 90 SWAP1 1E5B 55 SSTORE 1E5C 50 POP 1E5D 81 DUP2 1E5E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E73 16 AND 1E74 61 PUSH2 0x1e7b 1E77 61 PUSH2 0x296c 1E7A 56 *JUMP // Stack delta = -2 // Outputs[7] // { // @1DFC memory[stack[-2]:stack[-2] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @1E02 memory[0x20 + stack[-2]:0x20 + stack[-2] + 0x20] = stack[-3] // @1E39 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @1E3F memory[0x20:0x40] = keccak256(memory[0x00:0x00 + 0x20 + 0x20 + stack[-2]]) // @1E5B storage[keccak256(memory[0x00:0x40])] = !!stack[-4] * 0x0100 ** 0x00 | (~(0xff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @1E73 stack[-4] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-6] // @1E74 stack[-3] = 0x1e7b // } // Block ends with call to 0x296c, returns to 0x1E7B label_1E7B: // Incoming return from call to 0x296C at 0x1E7A // Inputs[7] // { // @1E91 stack[-1] // @1EB3 stack[-3] // @1EB6 memory[0x40:0x60] // @1EC5 memory[0x40:0x60] // @1ECA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]] // @1ECA stack[-2] // @1ECD stack[-5] // } 1E7B 5B JUMPDEST 1E7C 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 1E91 16 AND 1E92 7F PUSH32 0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31 1EB3 83 DUP4 1EB4 60 PUSH1 0x40 1EB6 51 MLOAD 1EB7 80 DUP1 1EB8 82 DUP3 1EB9 15 ISZERO 1EBA 15 ISZERO 1EBB 81 DUP2 1EBC 52 MSTORE 1EBD 60 PUSH1 0x20 1EBF 01 ADD 1EC0 91 SWAP2 1EC1 50 POP 1EC2 50 POP 1EC3 60 PUSH1 0x40 1EC5 51 MLOAD 1EC6 80 DUP1 1EC7 91 SWAP2 1EC8 03 SUB 1EC9 90 SWAP1 1ECA A3 LOG3 1ECB 50 POP 1ECC 50 POP 1ECD 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @1EBC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = !!stack[-3] // @1ECA log(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + memory[0x40:0x60]) - memory[0x40:0x60]], [0x17307eab39ab6107e8899845ad3d59bd9653f200f220920489ca2b5937696c31, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2]]); // } // Block ends with unconditional jump to stack[-5] label_1ECE: // Incoming jump from 0x0BA9 // Inputs[1] { @1ED4 storage[0x0f] } 1ECE 5B JUMPDEST 1ECF 60 PUSH1 0x0f 1ED1 60 PUSH1 0x00 1ED3 90 SWAP1 1ED4 54 SLOAD 1ED5 90 SWAP1 1ED6 61 PUSH2 0x0100 1ED9 0A EXP 1EDA 90 SWAP1 1EDB 04 DIV 1EDC 60 PUSH1 0xff 1EDE 16 AND 1EDF 61 PUSH2 0x1f50 1EE2 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1f50, if 0xff & storage[0x0f] / 0x0100 ** 0x00 label_1EE3: // Incoming jump from 0x1EE2, if not 0xff & storage[0x0f] / 0x0100 ** 0x00 // Inputs[3] // { // @1EE5 memory[0x40:0x60] // @1F4A memory[0x40:0x60] // @1F4F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1EE3 60 PUSH1 0x40 1EE5 51 MLOAD 1EE6 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1F07 81 DUP2 1F08 52 MSTORE 1F09 60 PUSH1 0x04 1F0B 01 ADD 1F0C 80 DUP1 1F0D 80 DUP1 1F0E 60 PUSH1 0x20 1F10 01 ADD 1F11 82 DUP3 1F12 81 DUP2 1F13 03 SUB 1F14 82 DUP3 1F15 52 MSTORE 1F16 60 PUSH1 0x1f 1F18 81 DUP2 1F19 52 MSTORE 1F1A 60 PUSH1 0x20 1F1C 01 ADD 1F1D 80 DUP1 1F1E 7F PUSH32 0x53616c65206d7573742062652061637469766520746f206d696e742041706500 1F3F 81 DUP2 1F40 52 MSTORE 1F41 50 POP 1F42 60 PUSH1 0x20 1F44 01 ADD 1F45 91 SWAP2 1F46 50 POP 1F47 50 POP 1F48 60 PUSH1 0x40 1F4A 51 MLOAD 1F4B 80 DUP1 1F4C 91 SWAP2 1F4D 03 SUB 1F4E 90 SWAP1 1F4F FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1F08 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1F15 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1F19 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x1f // @1F40 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x53616c65206d7573742062652061637469766520746f206d696e742041706500 // @1F4F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1F50: // Incoming jump from 0x1EE2, if 0xff & storage[0x0f] / 0x0100 ** 0x00 // Inputs[1] { @1F53 stack[-1] } 1F50 5B JUMPDEST 1F51 60 PUSH1 0x14 1F53 81 DUP2 1F54 11 GT 1F55 15 ISZERO 1F56 61 PUSH2 0x1faa 1F59 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x1faa, if !(stack[-1] > 0x14) label_1F5A: // Incoming jump from 0x1F59, if not !(stack[-1] > 0x14) // Inputs[3] // { // @1F5C memory[0x40:0x60] // @1FA4 memory[0x40:0x60] // @1FA9 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1F5A 60 PUSH1 0x40 1F5C 51 MLOAD 1F5D 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1F7E 81 DUP2 1F7F 52 MSTORE 1F80 60 PUSH1 0x04 1F82 01 ADD 1F83 80 DUP1 1F84 80 DUP1 1F85 60 PUSH1 0x20 1F87 01 ADD 1F88 82 DUP3 1F89 81 DUP2 1F8A 03 SUB 1F8B 82 DUP3 1F8C 52 MSTORE 1F8D 60 PUSH1 0x21 1F8F 81 DUP2 1F90 52 MSTORE 1F91 60 PUSH1 0x20 1F93 01 ADD 1F94 80 DUP1 1F95 61 PUSH2 0x3f74 1F98 60 PUSH1 0x21 1F9A 91 SWAP2 1F9B 39 CODECOPY 1F9C 60 PUSH1 0x40 1F9E 01 ADD 1F9F 91 SWAP2 1FA0 50 POP 1FA1 50 POP 1FA2 60 PUSH1 0x40 1FA4 51 MLOAD 1FA5 80 DUP1 1FA6 91 SWAP2 1FA7 03 SUB 1FA8 90 SWAP1 1FA9 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1F7F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @1F8C memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @1F90 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x21 // @1F9B memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x21] = code[0x3f74:0x3f95] // @1FA9 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_1FAA: // Incoming jump from 0x1F59, if !(stack[-1] > 0x14) // Inputs[2] // { // @1FAD storage[0x0e] // @1FB1 stack[-1] // } 1FAA 5B JUMPDEST 1FAB 60 PUSH1 0x0e 1FAD 54 SLOAD 1FAE 61 PUSH2 0x1fc7 1FB1 82 DUP3 1FB2 61 PUSH2 0x1fb9 1FB5 61 PUSH2 0x1390 1FB8 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @1FAD stack[0] = storage[0x0e] // @1FAE stack[1] = 0x1fc7 // @1FB1 stack[2] = stack[-1] // @1FB2 stack[3] = 0x1fb9 // } // Block ends with call to 0x1390, returns to 0x1FB9 label_1FB9: // Incoming return from call to 0x1390 at 0x1FB8 // Inputs[2] // { // @1FBD stack[-1] // @1FBE stack[-2] // } 1FB9 5B JUMPDEST 1FBA 61 PUSH2 0x2e2a 1FBD 90 SWAP1 1FBE 91 SWAP2 1FBF 90 SWAP1 1FC0 63 PUSH4 0xffffffff 1FC5 16 AND 1FC6 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @1FBE stack[-2] = stack[-1] // @1FBF stack[-1] = stack[-2] // } // Block ends with unconditional jump to 0xffffffff & 0x2e2a label_1FC7: // Incoming return from call to 0x1FB9 at 0x1FB8 // Inputs[2] // { // @1FC8 stack[-1] // @1FC8 stack[-2] // } 1FC7 5B JUMPDEST 1FC8 11 GT 1FC9 15 ISZERO 1FCA 61 PUSH2 0x201e 1FCD 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x201e, if !(stack[-1] > stack[-2]) label_1FCE: // Incoming jump from 0x1FCD, if not !(stack[-1] > stack[-2]) // Inputs[3] // { // @1FD0 memory[0x40:0x60] // @2018 memory[0x40:0x60] // @201D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 1FCE 60 PUSH1 0x40 1FD0 51 MLOAD 1FD1 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 1FF2 81 DUP2 1FF3 52 MSTORE 1FF4 60 PUSH1 0x04 1FF6 01 ADD 1FF7 80 DUP1 1FF8 80 DUP1 1FF9 60 PUSH1 0x20 1FFB 01 ADD 1FFC 82 DUP3 1FFD 81 DUP2 1FFE 03 SUB 1FFF 82 DUP3 2000 52 MSTORE 2001 60 PUSH1 0x28 2003 81 DUP2 2004 52 MSTORE 2005 60 PUSH1 0x20 2007 01 ADD 2008 80 DUP1 2009 61 PUSH2 0x4042 200C 60 PUSH1 0x28 200E 91 SWAP2 200F 39 CODECOPY 2010 60 PUSH1 0x40 2012 01 ADD 2013 91 SWAP2 2014 50 POP 2015 50 POP 2016 60 PUSH1 0x40 2018 51 MLOAD 2019 80 DUP1 201A 91 SWAP2 201B 03 SUB 201C 90 SWAP1 201D FD *REVERT // Stack delta = +0 // Outputs[5] // { // @1FF3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2000 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2004 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x28 // @200F memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x28] = code[0x4042:0x406a] // @201D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_201E: // Incoming jump from 0x1FCD, if !(stack[-1] > stack[-2]) // Inputs[2] // { // @201F msg.value // @2023 stack[-1] // } 201E 5B JUMPDEST 201F 34 CALLVALUE 2020 61 PUSH2 0x203a 2023 82 DUP3 2024 67 PUSH8 0x011c37937e080000 202D 61 PUSH2 0x2eb2 2030 90 SWAP1 2031 91 SWAP2 2032 90 SWAP1 2033 63 PUSH4 0xffffffff 2038 16 AND 2039 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @201F stack[0] = msg.value // @2020 stack[1] = 0x203a // @2031 stack[2] = 0x011c37937e080000 // @2032 stack[3] = stack[-1] // } // Block ends with call to 0xffffffff & 0x2eb2, returns to 0x203A label_203A: // Incoming return from call to 0x2EB2 at 0x2039 // Inputs[2] // { // @203B stack[-1] // @203B stack[-2] // } 203A 5B JUMPDEST 203B 11 GT 203C 15 ISZERO 203D 61 PUSH2 0x20ae 2040 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x20ae, if !(stack[-1] > stack[-2]) label_2041: // Incoming jump from 0x2040, if not !(stack[-1] > stack[-2]) // Inputs[3] // { // @2043 memory[0x40:0x60] // @20A8 memory[0x40:0x60] // @20AD memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2041 60 PUSH1 0x40 2043 51 MLOAD 2044 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2065 81 DUP2 2066 52 MSTORE 2067 60 PUSH1 0x04 2069 01 ADD 206A 80 DUP1 206B 80 DUP1 206C 60 PUSH1 0x20 206E 01 ADD 206F 82 DUP3 2070 81 DUP2 2071 03 SUB 2072 82 DUP3 2073 52 MSTORE 2074 60 PUSH1 0x1f 2076 81 DUP2 2077 52 MSTORE 2078 60 PUSH1 0x20 207A 01 ADD 207B 80 DUP1 207C 7F PUSH32 0x45746865722076616c75652073656e74206973206e6f7420636f727265637400 209D 81 DUP2 209E 52 MSTORE 209F 50 POP 20A0 60 PUSH1 0x20 20A2 01 ADD 20A3 91 SWAP2 20A4 50 POP 20A5 50 POP 20A6 60 PUSH1 0x40 20A8 51 MLOAD 20A9 80 DUP1 20AA 91 SWAP2 20AB 03 SUB 20AC 90 SWAP1 20AD FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2066 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2073 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2077 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x1f // @209E memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x45746865722076616c75652073656e74206973206e6f7420636f727265637400 // @20AD revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_20AE: // Incoming jump from 0x2040, if !(stack[-1] > stack[-2]) // Inputs[1] { @20B2 stack[-1] } 20AE 5B JUMPDEST 20AF 60 PUSH1 0x00 20B1 5B JUMPDEST 20B2 81 DUP2 20B3 81 DUP2 20B4 10 LT 20B5 15 ISZERO 20B6 61 PUSH2 0x20ef 20B9 57 *JUMPI // Stack delta = +1 // Outputs[1] { @20AF stack[0] = 0x00 } // Block ends with conditional jump to 0x20ef, if !(0x00 < stack[-1]) label_20BA: // Incoming jump from 0x20B9, if not !(stack[-1] < stack[-2]) // Incoming jump from 0x20B9, if not !(0x00 < stack[-1]) 20BA 60 PUSH1 0x00 20BC 61 PUSH2 0x20c3 20BF 61 PUSH2 0x1390 20C2 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @20BA stack[0] = 0x00 // @20BC stack[1] = 0x20c3 // } // Block ends with call to 0x1390, returns to 0x20C3 label_20C3: // Incoming return from call to 0x1390 at 0x20C2 // Inputs[3] // { // @20C4 stack[-1] // @20C4 stack[-2] // @20C8 storage[0x0e] // } 20C3 5B JUMPDEST 20C4 90 SWAP1 20C5 50 POP 20C6 60 PUSH1 0x0e 20C8 54 SLOAD 20C9 61 PUSH2 0x20d0 20CC 61 PUSH2 0x1390 20CF 56 *JUMP // Stack delta = +1 // Outputs[3] // { // @20C4 stack[-2] = stack[-1] // @20C8 stack[-1] = storage[0x0e] // @20C9 stack[0] = 0x20d0 // } // Block ends with call to 0x1390, returns to 0x20D0 label_20D0: // Incoming return from call to 0x1390 at 0x20CF // Inputs[2] // { // @20D1 stack[-2] // @20D1 stack[-1] // } 20D0 5B JUMPDEST 20D1 10 LT 20D2 15 ISZERO 20D3 61 PUSH2 0x20e1 20D6 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x20e1, if !(stack[-1] < stack[-2]) label_20D7: // Incoming jump from 0x20D6, if not !(stack[-1] < stack[-2]) // Inputs[2] // { // @20DA msg.sender // @20DB stack[-1] // } 20D7 61 PUSH2 0x20e0 20DA 33 CALLER 20DB 82 DUP3 20DC 61 PUSH2 0x2f38 20DF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @20D7 stack[0] = 0x20e0 // @20DA stack[1] = msg.sender // @20DB stack[2] = stack[-1] // } // Block ends with call to 0x2f38, returns to 0x20E0 label_20E0: // Incoming return from call to 0x2F38 at 0x20DF 20E0 5B JUMPDEST // Stack delta = +0 // Block continues label_20E1: // Incoming jump from 0x20E0 // Incoming jump from 0x20D6, if !(stack[-1] < stack[-2]) // Inputs[1] { @20E3 stack[-2] } 20E1 5B JUMPDEST 20E2 50 POP 20E3 80 DUP1 20E4 80 DUP1 20E5 60 PUSH1 0x01 20E7 01 ADD 20E8 91 SWAP2 20E9 50 POP 20EA 50 POP 20EB 61 PUSH2 0x20b1 20EE 56 *JUMP // Stack delta = -1 // Outputs[1] { @20E8 stack[-2] = 0x01 + stack[-2] } // Block ends with unconditional jump to 0x20b1 label_20EF: // Incoming jump from 0x20B9, if !(stack[-1] < stack[-2]) // Incoming jump from 0x20B9, if !(0x00 < stack[-1]) // Inputs[1] { @20F5 storage[0x0c] } 20EF 5B JUMPDEST 20F0 50 POP 20F1 60 PUSH1 0x00 20F3 60 PUSH1 0x0c 20F5 54 SLOAD 20F6 14 EQ 20F7 80 DUP1 20F8 15 ISZERO 20F9 61 PUSH2 0x2117 20FC 57 *JUMPI // Stack delta = +0 // Outputs[1] { @20F6 stack[-1] = storage[0x0c] == 0x00 } // Block ends with conditional jump to 0x2117, if !(storage[0x0c] == 0x00) label_20FD: // Incoming jump from 0x20FC, if not !(storage[0x0c] == 0x00) // Inputs[1] { @2100 storage[0x0e] } 20FD 50 POP 20FE 60 PUSH1 0x0e 2100 54 SLOAD 2101 61 PUSH2 0x2108 2104 61 PUSH2 0x1390 2107 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @2100 stack[-1] = storage[0x0e] // @2101 stack[0] = 0x2108 // } // Block ends with call to 0x1390, returns to 0x2108 label_2108: // Incoming return from call to 0x1390 at 0x2107 // Inputs[2] // { // @2109 stack[-2] // @2109 stack[-1] // } 2108 5B JUMPDEST 2109 14 EQ 210A 80 DUP1 210B 61 PUSH2 0x2116 210E 57 *JUMPI // Stack delta = -1 // Outputs[1] { @2109 stack[-2] = stack[-1] == stack[-2] } // Block ends with conditional jump to 0x2116, if stack[-1] == stack[-2] label_210F: // Incoming jump from 0x210E, if not stack[-1] == stack[-2] // Inputs[2] // { // @2112 storage[0x10] // @2113 block.timestamp // } 210F 50 POP 2110 60 PUSH1 0x10 2112 54 SLOAD 2113 42 TIMESTAMP 2114 10 LT 2115 15 ISZERO 2116 5B JUMPDEST // Stack delta = +0 // Outputs[1] { @2115 stack[-1] = !(block.timestamp < storage[0x10]) } // Block continues label_2117: // Incoming jump from 0x20FC, if !(storage[0x0c] == 0x00) // Incoming jump from 0x2116 // Incoming jump from 0x2116 // Inputs[1] { @2118 stack[-1] } 2117 5B JUMPDEST 2118 15 ISZERO 2119 61 PUSH2 0x2124 211C 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2124, if !stack[-1] label_211D: // Incoming jump from 0x211C, if not !stack[-1] // Inputs[2] // { // @211D block.number // @2126 stack[-2] // } 211D 43 NUMBER 211E 60 PUSH1 0x0c 2120 81 DUP2 2121 90 SWAP1 2122 55 SSTORE 2123 50 POP 2124 5B JUMPDEST 2125 50 POP 2126 56 *JUMP // Stack delta = -2 // Outputs[1] { @2122 storage[0x0c] = block.number } // Block ends with unconditional jump to stack[-2] label_2127: // Incoming call from 0x0BC0, returns to 0x0BC1 2127 5B JUMPDEST 2128 61 PUSH2 0x212f 212B 61 PUSH2 0x296c 212E 56 *JUMP // Stack delta = +1 // Outputs[1] { @2128 stack[0] = 0x212f } // Block ends with call to 0x296c, returns to 0x212F label_212F: // Incoming return from call to 0x296C at 0x212E // Inputs[1] { @2145 stack[-1] } 212F 5B JUMPDEST 2130 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2145 16 AND 2146 61 PUSH2 0x214d 2149 61 PUSH2 0x1c4c 214C 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @2145 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @2146 stack[0] = 0x214d // } // Block ends with call to 0x1c4c, returns to 0x214D label_214D: // Incoming return from call to 0x1C4C at 0x214C // Inputs[2] // { // @2163 stack[-1] // @2164 stack[-2] // } 214D 5B JUMPDEST 214E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2163 16 AND 2164 14 EQ 2165 61 PUSH2 0x21d6 2168 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x21d6, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_2169: // Incoming jump from 0x2168, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[3] // { // @216B memory[0x40:0x60] // @21D0 memory[0x40:0x60] // @21D5 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2169 60 PUSH1 0x40 216B 51 MLOAD 216C 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 218D 81 DUP2 218E 52 MSTORE 218F 60 PUSH1 0x04 2191 01 ADD 2192 80 DUP1 2193 80 DUP1 2194 60 PUSH1 0x20 2196 01 ADD 2197 82 DUP3 2198 81 DUP2 2199 03 SUB 219A 82 DUP3 219B 52 MSTORE 219C 60 PUSH1 0x20 219E 81 DUP2 219F 52 MSTORE 21A0 60 PUSH1 0x20 21A2 01 ADD 21A3 80 DUP1 21A4 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 21C5 81 DUP2 21C6 52 MSTORE 21C7 50 POP 21C8 60 PUSH1 0x20 21CA 01 ADD 21CB 91 SWAP2 21CC 50 POP 21CD 50 POP 21CE 60 PUSH1 0x40 21D0 51 MLOAD 21D1 80 DUP1 21D2 91 SWAP2 21D3 03 SUB 21D4 90 SWAP1 21D5 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @218E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @219B memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @219F memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20 // @21C6 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @21D5 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_21D6: // Incoming jump from 0x2168, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] 21D6 5B JUMPDEST 21D7 60 PUSH1 0x00 21D9 61 PUSH2 0x21e0 21DC 61 PUSH2 0x1390 21DF 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @21D7 stack[0] = 0x00 // @21D9 stack[1] = 0x21e0 // } // Block ends with call to 0x1390, returns to 0x21E0 label_21E0: // Incoming return from call to 0x1390 at 0x21DF // Inputs[2] // { // @21E1 stack[-1] // @21E1 stack[-2] // } 21E0 5B JUMPDEST 21E1 90 SWAP1 21E2 50 POP 21E3 60 PUSH1 0x00 21E5 5B JUMPDEST 21E6 60 PUSH1 0x1e 21E8 81 DUP2 21E9 10 LT 21EA 15 ISZERO 21EB 61 PUSH2 0x2207 21EE 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @21E1 stack[-2] = stack[-1] // @21E3 stack[-1] = 0x00 // } // Block ends with conditional jump to 0x2207, if !(0x00 < 0x1e) label_21EF: // Incoming jump from 0x21EE, if not !(stack[-1] < 0x1e) // Incoming jump from 0x21EE, if not !(0x00 < 0x1e) // Inputs[3] // { // @21F2 msg.sender // @21F3 stack[-1] // @21F4 stack[-2] // } 21EF 61 PUSH2 0x21fa 21F2 33 CALLER 21F3 82 DUP3 21F4 84 DUP5 21F5 01 ADD 21F6 61 PUSH2 0x2f38 21F9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @21EF stack[0] = 0x21fa // @21F2 stack[1] = msg.sender // @21F5 stack[2] = stack[-2] + stack[-1] // } // Block ends with call to 0x2f38, returns to 0x21FA label_21FA: // Incoming return from call to 0x2F38 at 0x21F9 // Inputs[1] { @21FB stack[-1] } 21FA 5B JUMPDEST 21FB 80 DUP1 21FC 80 DUP1 21FD 60 PUSH1 0x01 21FF 01 ADD 2200 91 SWAP2 2201 50 POP 2202 50 POP 2203 61 PUSH2 0x21e5 2206 56 *JUMP // Stack delta = +0 // Outputs[1] { @2200 stack[-1] = 0x01 + stack[-1] } // Block ends with unconditional jump to 0x21e5 label_2207: // Incoming jump from 0x21EE, if !(stack[-1] < 0x1e) // Incoming jump from 0x21EE, if !(0x00 < 0x1e) // Inputs[1] { @220A stack[-3] } 2207 5B JUMPDEST 2208 50 POP 2209 50 POP 220A 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_220B: // Incoming jump from 0x0CD2 // Incoming call from 0x166B, returns to 0x166C 220B 5B JUMPDEST 220C 61 PUSH2 0x221c 220F 61 PUSH2 0x2216 2212 61 PUSH2 0x296c 2215 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @220C stack[0] = 0x221c // @220F stack[1] = 0x2216 // } // Block ends with call to 0x296c, returns to 0x2216 label_2216: // Incoming return from call to 0x296C at 0x2215 // Inputs[1] { @2217 stack[-4] } 2216 5B JUMPDEST 2217 83 DUP4 2218 61 PUSH2 0x2a5f 221B 56 *JUMP // Stack delta = +1 // Outputs[1] { @2217 stack[0] = stack[-4] } // Block ends with unconditional jump to 0x2a5f label_221C: // Incoming return from call to 0x2216 at 0x2215 // Inputs[1] { @2220 stack[-1] } 221C 5B JUMPDEST 221D 61 PUSH2 0x2271 2220 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2271, if stack[-1] label_2221: // Incoming jump from 0x2220, if not stack[-1] // Inputs[3] // { // @2223 memory[0x40:0x60] // @226B memory[0x40:0x60] // @2270 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2221 60 PUSH1 0x40 2223 51 MLOAD 2224 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2245 81 DUP2 2246 52 MSTORE 2247 60 PUSH1 0x04 2249 01 ADD 224A 80 DUP1 224B 80 DUP1 224C 60 PUSH1 0x20 224E 01 ADD 224F 82 DUP3 2250 81 DUP2 2251 03 SUB 2252 82 DUP3 2253 52 MSTORE 2254 60 PUSH1 0x31 2256 81 DUP2 2257 52 MSTORE 2258 60 PUSH1 0x20 225A 01 ADD 225B 80 DUP1 225C 61 PUSH2 0x4130 225F 60 PUSH1 0x31 2261 91 SWAP2 2262 39 CODECOPY 2263 60 PUSH1 0x40 2265 01 ADD 2266 91 SWAP2 2267 50 POP 2268 50 POP 2269 60 PUSH1 0x40 226B 51 MLOAD 226C 80 DUP1 226D 91 SWAP2 226E 03 SUB 226F 90 SWAP1 2270 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2246 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2253 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2257 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x31 // @2262 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x31] = code[0x4130:0x4161] // @2270 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2271: // Incoming jump from 0x2220, if stack[-1] // Inputs[4] // { // @2275 stack[-4] // @2276 stack[-3] // @2277 stack[-2] // @2278 stack[-1] // } 2271 5B JUMPDEST 2272 61 PUSH2 0x227d 2275 84 DUP5 2276 84 DUP5 2277 84 DUP5 2278 84 DUP5 2279 61 PUSH2 0x2f56 227C 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @2272 stack[0] = 0x227d // @2275 stack[1] = stack[-4] // @2276 stack[2] = stack[-3] // @2277 stack[3] = stack[-2] // @2278 stack[4] = stack[-1] // } // Block ends with call to 0x2f56, returns to 0x227D label_227D: // Incoming return from call to 0x2F56 at 0x227C // Inputs[1] { @2282 stack[-5] } 227D 5B JUMPDEST 227E 50 POP 227F 50 POP 2280 50 POP 2281 50 POP 2282 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_2283: // Incoming call from 0x0CE9, returns to 0x0CEA // Inputs[2] // { // @2286 storage[0x0e] // @2287 stack[-1] // } 2283 5B JUMPDEST 2284 60 PUSH1 0x0e 2286 54 SLOAD 2287 81 DUP2 2288 56 *JUMP // Stack delta = +1 // Outputs[1] { @2286 stack[0] = storage[0x0e] } // Block ends with unconditional jump to stack[-1] label_2289: // Incoming jump from 0x0D38 // Inputs[1] { @228F stack[-1] } 2289 5B JUMPDEST 228A 60 PUSH1 0x60 228C 61 PUSH2 0x2294 228F 82 DUP3 2290 61 PUSH2 0x2974 2293 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @228A stack[0] = 0x60 // @228C stack[1] = 0x2294 // @228F stack[2] = stack[-1] // } // Block ends with call to 0x2974, returns to 0x2294 label_2294: // Incoming return from call to 0x2974 at 0x2293 // Inputs[1] { @2298 stack[-1] } 2294 5B JUMPDEST 2295 61 PUSH2 0x22e9 2298 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x22e9, if stack[-1] label_2299: // Incoming jump from 0x2298, if not stack[-1] // Inputs[3] // { // @229B memory[0x40:0x60] // @22E3 memory[0x40:0x60] // @22E8 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2299 60 PUSH1 0x40 229B 51 MLOAD 229C 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 22BD 81 DUP2 22BE 52 MSTORE 22BF 60 PUSH1 0x04 22C1 01 ADD 22C2 80 DUP1 22C3 80 DUP1 22C4 60 PUSH1 0x20 22C6 01 ADD 22C7 82 DUP3 22C8 81 DUP2 22C9 03 SUB 22CA 82 DUP3 22CB 52 MSTORE 22CC 60 PUSH1 0x2f 22CE 81 DUP2 22CF 52 MSTORE 22D0 60 PUSH1 0x20 22D2 01 ADD 22D3 80 DUP1 22D4 61 PUSH2 0x40e0 22D7 60 PUSH1 0x2f 22D9 91 SWAP2 22DA 39 CODECOPY 22DB 60 PUSH1 0x40 22DD 01 ADD 22DE 91 SWAP2 22DF 50 POP 22E0 50 POP 22E1 60 PUSH1 0x40 22E3 51 MLOAD 22E4 80 DUP1 22E5 91 SWAP2 22E6 03 SUB 22E7 90 SWAP1 22E8 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @22BE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @22CB memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @22CF memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2f // @22DA memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2f] = code[0x40e0:0x410f] // @22E8 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_22E9: // Incoming jump from 0x2298, if stack[-1] // Inputs[5] // { // @22F0 stack[-2] // @22FE memory[0x00:0x40] // @2300 storage[keccak256(memory[0x00:0x40])] // @2321 memory[0x40:0x60] // @2334 storage[keccak256(memory[0x00:0x40])] // } 22E9 5B JUMPDEST 22EA 60 PUSH1 0x60 22EC 60 PUSH1 0x08 22EE 60 PUSH1 0x00 22F0 84 DUP5 22F1 81 DUP2 22F2 52 MSTORE 22F3 60 PUSH1 0x20 22F5 01 ADD 22F6 90 SWAP1 22F7 81 DUP2 22F8 52 MSTORE 22F9 60 PUSH1 0x20 22FB 01 ADD 22FC 60 PUSH1 0x00 22FE 20 SHA3 22FF 80 DUP1 2300 54 SLOAD 2301 60 PUSH1 0x01 2303 81 DUP2 2304 60 PUSH1 0x01 2306 16 AND 2307 15 ISZERO 2308 61 PUSH2 0x0100 230B 02 MUL 230C 03 SUB 230D 16 AND 230E 60 PUSH1 0x02 2310 90 SWAP1 2311 04 DIV 2312 80 DUP1 2313 60 PUSH1 0x1f 2315 01 ADD 2316 60 PUSH1 0x20 2318 80 DUP1 2319 91 SWAP2 231A 04 DIV 231B 02 MUL 231C 60 PUSH1 0x20 231E 01 ADD 231F 60 PUSH1 0x40 2321 51 MLOAD 2322 90 SWAP1 2323 81 DUP2 2324 01 ADD 2325 60 PUSH1 0x40 2327 52 MSTORE 2328 80 DUP1 2329 92 SWAP3 232A 91 SWAP2 232B 90 SWAP1 232C 81 DUP2 232D 81 DUP2 232E 52 MSTORE 232F 60 PUSH1 0x20 2331 01 ADD 2332 82 DUP3 2333 80 DUP1 2334 54 SLOAD 2335 60 PUSH1 0x01 2337 81 DUP2 2338 60 PUSH1 0x01 233A 16 AND 233B 15 ISZERO 233C 61 PUSH2 0x0100 233F 02 MUL 2340 03 SUB 2341 16 AND 2342 60 PUSH1 0x02 2344 90 SWAP1 2345 04 DIV 2346 80 DUP1 2347 15 ISZERO 2348 61 PUSH2 0x2392 234B 57 *JUMPI // Stack delta = +7 // Outputs[11] // { // @22EA stack[0] = 0x60 // @22F2 memory[0x00:0x20] = stack[-2] // @22F8 memory[0x20:0x40] = 0x08 // @2327 memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (0x1f + (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) / 0x20 * 0x20 // @2329 stack[1] = memory[0x40:0x60] // @232A stack[2] = keccak256(memory[0x00:0x40]) // @232B stack[3] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @232E memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // @2331 stack[4] = 0x20 + memory[0x40:0x60] // @2332 stack[5] = keccak256(memory[0x00:0x40]) // @2345 stack[6] = (0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02 // } // Block ends with conditional jump to 0x2392, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) label_234C: // Incoming jump from 0x234B, if not !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Inputs[1] { @234C stack[-1] } 234C 80 DUP1 234D 60 PUSH1 0x1f 234F 10 LT 2350 61 PUSH2 0x2367 2353 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2367, if 0x1f < stack[-1] label_2354: // Incoming jump from 0x2353, if not 0x1f < stack[-1] // Inputs[4] // { // @2358 stack[-2] // @2359 storage[stack[-2]] // @235C stack[-3] // @235E stack[-1] // } 2354 61 PUSH2 0x0100 2357 80 DUP1 2358 83 DUP4 2359 54 SLOAD 235A 04 DIV 235B 02 MUL 235C 83 DUP4 235D 52 MSTORE 235E 91 SWAP2 235F 60 PUSH1 0x20 2361 01 ADD 2362 91 SWAP2 2363 61 PUSH2 0x2392 2366 56 *JUMP // Stack delta = +0 // Outputs[3] // { // @235D memory[stack[-3]:stack[-3] + 0x20] = storage[stack[-2]] / 0x0100 * 0x0100 // @2362 stack[-1] = stack[-1] // @2362 stack[-3] = 0x20 + stack[-3] // } // Block ends with unconditional jump to 0x2392 label_2367: // Incoming jump from 0x2353, if 0x1f < stack[-1] // Inputs[5] // { // @2368 stack[-3] // @2369 stack[-1] // @236B stack[-2] // @2373 memory[0x00:0x20] // @2377 storage[keccak256(memory[0x00:0x20])] // } 2367 5B JUMPDEST 2368 82 DUP3 2369 01 ADD 236A 91 SWAP2 236B 90 SWAP1 236C 60 PUSH1 0x00 236E 52 MSTORE 236F 60 PUSH1 0x20 2371 60 PUSH1 0x00 2373 20 SHA3 2374 90 SWAP1 2375 5B JUMPDEST 2376 81 DUP2 2377 54 SLOAD 2378 81 DUP2 2379 52 MSTORE 237A 90 SWAP1 237B 60 PUSH1 0x01 237D 01 ADD 237E 90 SWAP1 237F 60 PUSH1 0x20 2381 01 ADD 2382 80 DUP1 2383 83 DUP4 2384 11 GT 2385 61 PUSH2 0x2375 2388 57 *JUMPI // Stack delta = +0 // Outputs[5] // { // @236A stack[-3] = stack[-3] + stack[-1] // @236E memory[0x00:0x20] = stack[-2] // @2379 memory[stack[-3]:stack[-3] + 0x20] = storage[keccak256(memory[0x00:0x20])] // @237E stack[-2] = 0x01 + keccak256(memory[0x00:0x20]) // @2381 stack[-1] = 0x20 + stack[-3] // } // Block ends with conditional jump to 0x2375, if stack[-3] + stack[-1] > 0x20 + stack[-3] label_2389: // Incoming jump from 0x2388, if not stack[-3] + stack[-1] > 0x20 + stack[-3] // Incoming jump from 0x2388, if not stack[-3] > 0x20 + stack[-1] // Inputs[2] // { // @2389 stack[-3] // @238A stack[-1] // } 2389 82 DUP3 238A 90 SWAP1 238B 03 SUB 238C 60 PUSH1 0x1f 238E 16 AND 238F 82 DUP3 2390 01 ADD 2391 91 SWAP2 // Stack delta = +0 // Outputs[2] // { // @2391 stack[-3] = stack[-3] + (0x1f & stack[-1] - stack[-3]) // @2391 stack[-1] = stack[-3] // } // Block continues label_2392: // Incoming jump from 0x2366 // Incoming jump from 0x2391 // Incoming jump from 0x234B, if !((0x0100 * !(0x01 & storage[keccak256(memory[0x00:0x40])]) - 0x01 & storage[keccak256(memory[0x00:0x40])]) / 0x02) // Inputs[2] // { // @2398 stack[-6] // @2398 stack[-7] // } 2392 5B JUMPDEST 2393 50 POP 2394 50 POP 2395 50 POP 2396 50 POP 2397 50 POP 2398 90 SWAP1 2399 50 POP 239A 60 PUSH1 0x60 239C 61 PUSH2 0x23a3 239F 61 PUSH2 0x1829 23A2 56 *JUMP // Stack delta = -4 // Outputs[3] // { // @2398 stack[-7] = stack[-6] // @239A stack[-6] = 0x60 // @239C stack[-5] = 0x23a3 // } // Block ends with call to 0x1829, returns to 0x23A3 label_23A3: // Incoming return from call to 0x1829 at 0x23A2 // Inputs[3] // { // @23A4 stack[-1] // @23A4 stack[-2] // @23A9 memory[stack[-1]:stack[-1] + 0x20] // } 23A3 5B JUMPDEST 23A4 90 SWAP1 23A5 50 POP 23A6 60 PUSH1 0x00 23A8 81 DUP2 23A9 51 MLOAD 23AA 14 EQ 23AB 15 ISZERO 23AC 61 PUSH2 0x23b9 23AF 57 *JUMPI // Stack delta = -1 // Outputs[1] { @23A4 stack[-2] = stack[-1] } // Block ends with conditional jump to 0x23b9, if !(memory[stack[-1]:stack[-1] + 0x20] == 0x00) label_23B0: // Incoming jump from 0x23AF, if not !(memory[stack[-1]:stack[-1] + 0x20] == 0x00) // Inputs[2] // { // @23B0 stack[-2] // @23B1 stack[-3] // } 23B0 81 DUP2 23B1 92 SWAP3 23B2 50 POP 23B3 50 POP 23B4 50 POP 23B5 61 PUSH2 0x2555 23B8 56 *JUMP // Stack delta = -2 // Outputs[1] { @23B1 stack[-3] = stack[-2] } // Block ends with unconditional jump to 0x2555 label_23B9: // Incoming jump from 0x23AF, if !(memory[stack[-1]:stack[-1] + 0x20] == 0x00) // Inputs[2] // { // @23BC stack[-2] // @23BD memory[stack[-2]:stack[-2] + 0x20] // } 23B9 5B JUMPDEST 23BA 60 PUSH1 0x00 23BC 82 DUP3 23BD 51 MLOAD 23BE 11 GT 23BF 15 ISZERO 23C0 61 PUSH2 0x248a 23C3 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x248a, if !(memory[stack[-2]:stack[-2] + 0x20] > 0x00) label_23C4: // Incoming jump from 0x23C3, if not !(memory[stack[-2]:stack[-2] + 0x20] > 0x00) // Inputs[4] // { // @23C4 stack[-1] // @23C5 stack[-2] // @23C8 memory[0x40:0x60] // @23CF memory[stack[-1]:stack[-1] + 0x20] // } 23C4 80 DUP1 23C5 82 DUP3 23C6 60 PUSH1 0x40 23C8 51 MLOAD 23C9 60 PUSH1 0x20 23CB 01 ADD 23CC 80 DUP1 23CD 83 DUP4 23CE 80 DUP1 23CF 51 MLOAD 23D0 90 SWAP1 23D1 60 PUSH1 0x20 23D3 01 ADD 23D4 90 SWAP1 23D5 80 DUP1 23D6 83 DUP4 23D7 83 DUP4 23D8 5B JUMPDEST 23D9 60 PUSH1 0x20 23DB 83 DUP4 23DC 10 LT 23DD 61 PUSH2 0x23fb 23E0 57 *JUMPI // Stack delta = +9 // Outputs[9] // { // @23C4 stack[0] = stack[-1] // @23C5 stack[1] = stack[-2] // @23CB stack[2] = 0x20 + memory[0x40:0x60] // @23CC stack[3] = 0x20 + memory[0x40:0x60] // @23D4 stack[4] = 0x20 + stack[-1] // @23D4 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @23D5 stack[6] = memory[stack[-1]:stack[-1] + 0x20] // @23D6 stack[7] = 0x20 + memory[0x40:0x60] // @23D7 stack[8] = 0x20 + stack[-1] // } // Block ends with conditional jump to 0x23fb, if memory[stack[-1]:stack[-1] + 0x20] < 0x20 label_23E1: // Incoming jump from 0x23E0, if not stack[-3] < 0x20 // Incoming jump from 0x23E0, if not memory[stack[-1]:stack[-1] + 0x20] < 0x20 // Inputs[4] // { // @23E1 stack[-1] // @23E2 memory[stack[-1]:stack[-1] + 0x20] // @23E3 stack[-2] // @23F3 stack[-3] // } 23E1 80 DUP1 23E2 51 MLOAD 23E3 82 DUP3 23E4 52 MSTORE 23E5 60 PUSH1 0x20 23E7 82 DUP3 23E8 01 ADD 23E9 91 SWAP2 23EA 50 POP 23EB 60 PUSH1 0x20 23ED 81 DUP2 23EE 01 ADD 23EF 90 SWAP1 23F0 50 POP 23F1 60 PUSH1 0x20 23F3 83 DUP4 23F4 03 SUB 23F5 92 SWAP3 23F6 50 POP 23F7 61 PUSH2 0x23d8 23FA 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @23E4 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @23E9 stack[-2] = stack[-2] + 0x20 // @23EF stack[-1] = stack[-1] + 0x20 // @23F5 stack[-3] = stack[-3] - 0x20 // } // Block ends with unconditional jump to 0x23d8 label_23FB: // Incoming jump from 0x23E0, if stack[-3] < 0x20 // Incoming jump from 0x23E0, if memory[stack[-1]:stack[-1] + 0x20] < 0x20 // Inputs[10] // { // @23FE stack[-3] // @2409 stack[-1] // @240A memory[stack[-1]:stack[-1] + 0x20] // @240D stack[-2] // @240E memory[stack[-2]:stack[-2] + 0x20] // @241B stack[-5] // @241B stack[-4] // @241D stack[-6] // @241E stack[-8] // @2420 memory[stack[-8]:stack[-8] + 0x20] // } 23FB 5B JUMPDEST 23FC 60 PUSH1 0x01 23FE 83 DUP4 23FF 60 PUSH1 0x20 2401 03 SUB 2402 61 PUSH2 0x0100 2405 0A EXP 2406 03 SUB 2407 80 DUP1 2408 19 NOT 2409 82 DUP3 240A 51 MLOAD 240B 16 AND 240C 81 DUP2 240D 84 DUP5 240E 51 MLOAD 240F 16 AND 2410 80 DUP1 2411 82 DUP3 2412 17 OR 2413 85 DUP6 2414 52 MSTORE 2415 50 POP 2416 50 POP 2417 50 POP 2418 50 POP 2419 50 POP 241A 50 POP 241B 90 SWAP1 241C 50 POP 241D 01 ADD 241E 82 DUP3 241F 80 DUP1 2420 51 MLOAD 2421 90 SWAP1 2422 60 PUSH1 0x20 2424 01 ADD 2425 90 SWAP1 2426 80 DUP1 2427 83 DUP4 2428 83 DUP4 2429 5B JUMPDEST 242A 60 PUSH1 0x20 242C 83 DUP4 242D 10 LT 242E 61 PUSH2 0x244c 2431 57 *JUMPI // Stack delta = +0 // Outputs[7] // { // @2414 memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @241D stack[-6] = stack[-4] + stack[-6] // @2425 stack[-5] = 0x20 + stack[-8] // @2425 stack[-4] = memory[stack[-8]:stack[-8] + 0x20] // @2426 stack[-3] = memory[stack[-8]:stack[-8] + 0x20] // @2427 stack[-2] = stack[-4] + stack[-6] // @2428 stack[-1] = 0x20 + stack[-8] // } // Block ends with conditional jump to 0x244c, if memory[stack[-8]:stack[-8] + 0x20] < 0x20 label_2432: // Incoming jump from 0x2431, if not memory[stack[-8]:stack[-8] + 0x20] < 0x20 // Incoming jump from 0x2431, if not stack[-3] < 0x20 // Inputs[4] // { // @2432 stack[-1] // @2433 memory[stack[-1]:stack[-1] + 0x20] // @2434 stack[-2] // @2444 stack[-3] // } 2432 80 DUP1 2433 51 MLOAD 2434 82 DUP3 2435 52 MSTORE 2436 60 PUSH1 0x20 2438 82 DUP3 2439 01 ADD 243A 91 SWAP2 243B 50 POP 243C 60 PUSH1 0x20 243E 81 DUP2 243F 01 ADD 2440 90 SWAP1 2441 50 POP 2442 60 PUSH1 0x20 2444 83 DUP4 2445 03 SUB 2446 92 SWAP3 2447 50 POP 2448 61 PUSH2 0x2429 244B 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2435 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @243A stack[-2] = stack[-2] + 0x20 // @2440 stack[-1] = stack[-1] + 0x20 // @2446 stack[-3] = stack[-3] - 0x20 // } // Block ends with unconditional jump to 0x2429 label_244C: // Incoming jump from 0x2431, if memory[stack[-8]:stack[-8] + 0x20] < 0x20 // Incoming jump from 0x2431, if stack[-3] < 0x20 // Inputs[11] // { // @244F stack[-3] // @245A stack[-1] // @245B memory[stack[-1]:stack[-1] + 0x20] // @245E stack[-2] // @245F memory[stack[-2]:stack[-2] + 0x20] // @246C stack[-5] // @246C stack[-4] // @246E stack[-6] // @246F stack[-9] // @2475 memory[0x40:0x60] // @2482 stack[-12] // } 244C 5B JUMPDEST 244D 60 PUSH1 0x01 244F 83 DUP4 2450 60 PUSH1 0x20 2452 03 SUB 2453 61 PUSH2 0x0100 2456 0A EXP 2457 03 SUB 2458 80 DUP1 2459 19 NOT 245A 82 DUP3 245B 51 MLOAD 245C 16 AND 245D 81 DUP2 245E 84 DUP5 245F 51 MLOAD 2460 16 AND 2461 80 DUP1 2462 82 DUP3 2463 17 OR 2464 85 DUP6 2465 52 MSTORE 2466 50 POP 2467 50 POP 2468 50 POP 2469 50 POP 246A 50 POP 246B 50 POP 246C 90 SWAP1 246D 50 POP 246E 01 ADD 246F 92 SWAP3 2470 50 POP 2471 50 POP 2472 50 POP 2473 60 PUSH1 0x40 2475 51 MLOAD 2476 60 PUSH1 0x20 2478 81 DUP2 2479 83 DUP4 247A 03 SUB 247B 03 SUB 247C 81 DUP2 247D 52 MSTORE 247E 90 SWAP1 247F 60 PUSH1 0x40 2481 52 MSTORE 2482 92 SWAP3 2483 50 POP 2484 50 POP 2485 50 POP 2486 61 PUSH2 0x2555 2489 56 *JUMP // Stack delta = -11 // Outputs[4] // { // @2465 memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @247D memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (stack[-4] + stack[-6]) - memory[0x40:0x60] - 0x20 // @2481 memory[0x40:0x60] = stack[-4] + stack[-6] // @2482 stack[-12] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x2555 label_248A: // Incoming jump from 0x23C3, if !(memory[stack[-2]:stack[-2] + 0x20] > 0x00) // Inputs[2] // { // @248B stack[-1] // @248F stack[-4] // } 248A 5B JUMPDEST 248B 80 DUP1 248C 61 PUSH2 0x2494 248F 85 DUP6 2490 61 PUSH2 0x2fc8 2493 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @248B stack[0] = stack[-1] // @248C stack[1] = 0x2494 // @248F stack[2] = stack[-4] // } // Block ends with call to 0x2fc8, returns to 0x2494 label_2494: // Incoming return from call to 0x2FC8 at 0x2493 // Inputs[3] // { // @2497 memory[0x40:0x60] // @249C stack[-2] // @249E memory[stack[-2]:stack[-2] + 0x20] // } 2494 5B JUMPDEST 2495 60 PUSH1 0x40 2497 51 MLOAD 2498 60 PUSH1 0x20 249A 01 ADD 249B 80 DUP1 249C 83 DUP4 249D 80 DUP1 249E 51 MLOAD 249F 90 SWAP1 24A0 60 PUSH1 0x20 24A2 01 ADD 24A3 90 SWAP1 24A4 80 DUP1 24A5 83 DUP4 24A6 83 DUP4 24A7 5B JUMPDEST 24A8 60 PUSH1 0x20 24AA 83 DUP4 24AB 10 LT 24AC 61 PUSH2 0x24ca 24AF 57 *JUMPI // Stack delta = +7 // Outputs[7] // { // @249A stack[0] = 0x20 + memory[0x40:0x60] // @249B stack[1] = 0x20 + memory[0x40:0x60] // @24A3 stack[2] = 0x20 + stack[-2] // @24A3 stack[3] = memory[stack[-2]:stack[-2] + 0x20] // @24A4 stack[4] = memory[stack[-2]:stack[-2] + 0x20] // @24A5 stack[5] = 0x20 + memory[0x40:0x60] // @24A6 stack[6] = 0x20 + stack[-2] // } // Block ends with conditional jump to 0x24ca, if memory[stack[-2]:stack[-2] + 0x20] < 0x20 label_24B0: // Incoming jump from 0x24AF, if not stack[-3] < 0x20 // Incoming jump from 0x24AF, if not memory[stack[-2]:stack[-2] + 0x20] < 0x20 // Inputs[4] // { // @24B0 stack[-1] // @24B1 memory[stack[-1]:stack[-1] + 0x20] // @24B2 stack[-2] // @24C2 stack[-3] // } 24B0 80 DUP1 24B1 51 MLOAD 24B2 82 DUP3 24B3 52 MSTORE 24B4 60 PUSH1 0x20 24B6 82 DUP3 24B7 01 ADD 24B8 91 SWAP2 24B9 50 POP 24BA 60 PUSH1 0x20 24BC 81 DUP2 24BD 01 ADD 24BE 90 SWAP1 24BF 50 POP 24C0 60 PUSH1 0x20 24C2 83 DUP4 24C3 03 SUB 24C4 92 SWAP3 24C5 50 POP 24C6 61 PUSH2 0x24a7 24C9 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @24B3 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @24B8 stack[-2] = stack[-2] + 0x20 // @24BE stack[-1] = stack[-1] + 0x20 // @24C4 stack[-3] = stack[-3] - 0x20 // } // Block ends with unconditional jump to 0x24a7 label_24CA: // Incoming jump from 0x24AF, if stack[-3] < 0x20 // Incoming jump from 0x24AF, if memory[stack[-2]:stack[-2] + 0x20] < 0x20 // Inputs[10] // { // @24CD stack[-3] // @24D8 stack[-1] // @24D9 memory[stack[-1]:stack[-1] + 0x20] // @24DC stack[-2] // @24DD memory[stack[-2]:stack[-2] + 0x20] // @24EA stack[-4] // @24EA stack[-5] // @24EC stack[-6] // @24ED stack[-8] // @24EF memory[stack[-8]:stack[-8] + 0x20] // } 24CA 5B JUMPDEST 24CB 60 PUSH1 0x01 24CD 83 DUP4 24CE 60 PUSH1 0x20 24D0 03 SUB 24D1 61 PUSH2 0x0100 24D4 0A EXP 24D5 03 SUB 24D6 80 DUP1 24D7 19 NOT 24D8 82 DUP3 24D9 51 MLOAD 24DA 16 AND 24DB 81 DUP2 24DC 84 DUP5 24DD 51 MLOAD 24DE 16 AND 24DF 80 DUP1 24E0 82 DUP3 24E1 17 OR 24E2 85 DUP6 24E3 52 MSTORE 24E4 50 POP 24E5 50 POP 24E6 50 POP 24E7 50 POP 24E8 50 POP 24E9 50 POP 24EA 90 SWAP1 24EB 50 POP 24EC 01 ADD 24ED 82 DUP3 24EE 80 DUP1 24EF 51 MLOAD 24F0 90 SWAP1 24F1 60 PUSH1 0x20 24F3 01 ADD 24F4 90 SWAP1 24F5 80 DUP1 24F6 83 DUP4 24F7 83 DUP4 24F8 5B JUMPDEST 24F9 60 PUSH1 0x20 24FB 83 DUP4 24FC 10 LT 24FD 61 PUSH2 0x251b 2500 57 *JUMPI // Stack delta = +0 // Outputs[7] // { // @24E3 memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @24EC stack[-6] = stack[-4] + stack[-6] // @24F4 stack[-5] = 0x20 + stack[-8] // @24F4 stack[-4] = memory[stack[-8]:stack[-8] + 0x20] // @24F5 stack[-3] = memory[stack[-8]:stack[-8] + 0x20] // @24F6 stack[-2] = stack[-4] + stack[-6] // @24F7 stack[-1] = 0x20 + stack[-8] // } // Block ends with conditional jump to 0x251b, if memory[stack[-8]:stack[-8] + 0x20] < 0x20 label_2501: // Incoming jump from 0x2500, if not stack[-3] < 0x20 // Incoming jump from 0x2500, if not memory[stack[-8]:stack[-8] + 0x20] < 0x20 // Inputs[4] // { // @2501 stack[-1] // @2502 memory[stack[-1]:stack[-1] + 0x20] // @2503 stack[-2] // @2513 stack[-3] // } 2501 80 DUP1 2502 51 MLOAD 2503 82 DUP3 2504 52 MSTORE 2505 60 PUSH1 0x20 2507 82 DUP3 2508 01 ADD 2509 91 SWAP2 250A 50 POP 250B 60 PUSH1 0x20 250D 81 DUP2 250E 01 ADD 250F 90 SWAP1 2510 50 POP 2511 60 PUSH1 0x20 2513 83 DUP4 2514 03 SUB 2515 92 SWAP3 2516 50 POP 2517 61 PUSH2 0x24f8 251A 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2504 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @2509 stack[-2] = stack[-2] + 0x20 // @250F stack[-1] = stack[-1] + 0x20 // @2515 stack[-3] = stack[-3] - 0x20 // } // Block ends with unconditional jump to 0x24f8 label_251B: // Incoming jump from 0x2500, if stack[-3] < 0x20 // Incoming jump from 0x2500, if memory[stack[-8]:stack[-8] + 0x20] < 0x20 // Inputs[11] // { // @251E stack[-3] // @2529 stack[-1] // @252A memory[stack[-1]:stack[-1] + 0x20] // @252D stack[-2] // @252E memory[stack[-2]:stack[-2] + 0x20] // @253B stack[-4] // @253B stack[-5] // @253D stack[-6] // @253E stack[-9] // @2544 memory[0x40:0x60] // @2551 stack[-12] // } 251B 5B JUMPDEST 251C 60 PUSH1 0x01 251E 83 DUP4 251F 60 PUSH1 0x20 2521 03 SUB 2522 61 PUSH2 0x0100 2525 0A EXP 2526 03 SUB 2527 80 DUP1 2528 19 NOT 2529 82 DUP3 252A 51 MLOAD 252B 16 AND 252C 81 DUP2 252D 84 DUP5 252E 51 MLOAD 252F 16 AND 2530 80 DUP1 2531 82 DUP3 2532 17 OR 2533 85 DUP6 2534 52 MSTORE 2535 50 POP 2536 50 POP 2537 50 POP 2538 50 POP 2539 50 POP 253A 50 POP 253B 90 SWAP1 253C 50 POP 253D 01 ADD 253E 92 SWAP3 253F 50 POP 2540 50 POP 2541 50 POP 2542 60 PUSH1 0x40 2544 51 MLOAD 2545 60 PUSH1 0x20 2547 81 DUP2 2548 83 DUP4 2549 03 SUB 254A 03 SUB 254B 81 DUP2 254C 52 MSTORE 254D 90 SWAP1 254E 60 PUSH1 0x40 2550 52 MSTORE 2551 92 SWAP3 2552 50 POP 2553 50 POP 2554 50 POP // Stack delta = -11 // Outputs[4] // { // @2534 memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @254C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (stack[-4] + stack[-6]) - memory[0x40:0x60] - 0x20 // @2550 memory[0x40:0x60] = stack[-4] + stack[-6] // @2551 stack[-12] = memory[0x40:0x60] // } // Block continues label_2555: // Incoming jump from 0x2489 // Incoming jump from 0x2554 // Incoming jump from 0x23B8 // Inputs[3] // { // @2556 stack[-3] // @2556 stack[-1] // @2557 stack[-2] // } 2555 5B JUMPDEST 2556 91 SWAP2 2557 90 SWAP1 2558 50 POP 2559 56 *JUMP // Stack delta = -2 // Outputs[1] { @2556 stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_255A: // Incoming call from 0x0DC8, returns to 0x0DC9 // Inputs[2] // { // @255D storage[0x0d] // @255E stack[-1] // } 255A 5B JUMPDEST 255B 60 PUSH1 0x0d 255D 54 SLOAD 255E 81 DUP2 255F 56 *JUMP // Stack delta = +1 // Outputs[1] { @255D stack[0] = storage[0x0d] } // Block ends with unconditional jump to stack[-1] label_2560: // Incoming call from 0x0DF3, returns to 0x0DF4 // Inputs[2] // { // @2563 storage[0x0c] // @2564 stack[-1] // } 2560 5B JUMPDEST 2561 60 PUSH1 0x0c 2563 54 SLOAD 2564 81 DUP2 2565 56 *JUMP // Stack delta = +1 // Outputs[1] { @2563 stack[0] = storage[0x0c] } // Block ends with unconditional jump to stack[-1] label_2566: // Incoming call from 0x2B48, returns to 0x2B49 // Incoming jump from 0x1261 // Incoming jump from 0x0E78 // Inputs[6] // { // @256D stack[-2] // @25A7 memory[0x00:0x40] // @25AA stack[-1] // @25E4 memory[0x00:0x40] // @25E8 storage[keccak256(memory[0x00:0x40])] // @25F5 stack[-3] // } 2566 5B JUMPDEST 2567 60 PUSH1 0x00 2569 60 PUSH1 0x05 256B 60 PUSH1 0x00 256D 84 DUP5 256E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2583 16 AND 2584 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2599 16 AND 259A 81 DUP2 259B 52 MSTORE 259C 60 PUSH1 0x20 259E 01 ADD 259F 90 SWAP1 25A0 81 DUP2 25A1 52 MSTORE 25A2 60 PUSH1 0x20 25A4 01 ADD 25A5 60 PUSH1 0x00 25A7 20 SHA3 25A8 60 PUSH1 0x00 25AA 83 DUP4 25AB 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 25C0 16 AND 25C1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 25D6 16 AND 25D7 81 DUP2 25D8 52 MSTORE 25D9 60 PUSH1 0x20 25DB 01 ADD 25DC 90 SWAP1 25DD 81 DUP2 25DE 52 MSTORE 25DF 60 PUSH1 0x20 25E1 01 ADD 25E2 60 PUSH1 0x00 25E4 20 SHA3 25E5 60 PUSH1 0x00 25E7 90 SWAP1 25E8 54 SLOAD 25E9 90 SWAP1 25EA 61 PUSH2 0x0100 25ED 0A EXP 25EE 90 SWAP1 25EF 04 DIV 25F0 60 PUSH1 0xff 25F2 16 AND 25F3 90 SWAP1 25F4 50 POP 25F5 92 SWAP3 25F6 91 SWAP2 25F7 50 POP 25F8 50 POP 25F9 56 *JUMP // Stack delta = -2 // Outputs[5] // { // @259B memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @25A1 memory[0x20:0x40] = 0x05 // @25D8 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @25DE memory[0x20:0x40] = keccak256(memory[0x00:0x40]) // @25F5 stack[-3] = 0xff & storage[keccak256(memory[0x00:0x40])] / 0x0100 ** 0x00 // } // Block ends with unconditional jump to stack[-3] label_25FA: // Incoming call from 0x0EA5, returns to 0x0EA6 // Inputs[1] { @25FF storage[0x0d] } 25FA 5B JUMPDEST 25FB 60 PUSH1 0x00 25FD 60 PUSH1 0x0d 25FF 54 SLOAD 2600 14 EQ 2601 61 PUSH2 0x2672 2604 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2672, if storage[0x0d] == 0x00 label_2605: // Incoming jump from 0x2604, if not storage[0x0d] == 0x00 // Inputs[3] // { // @2607 memory[0x40:0x60] // @266C memory[0x40:0x60] // @2671 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2605 60 PUSH1 0x40 2607 51 MLOAD 2608 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2629 81 DUP2 262A 52 MSTORE 262B 60 PUSH1 0x04 262D 01 ADD 262E 80 DUP1 262F 80 DUP1 2630 60 PUSH1 0x20 2632 01 ADD 2633 82 DUP3 2634 81 DUP2 2635 03 SUB 2636 82 DUP3 2637 52 MSTORE 2638 60 PUSH1 0x1d 263A 81 DUP2 263B 52 MSTORE 263C 60 PUSH1 0x20 263E 01 ADD 263F 80 DUP1 2640 7F PUSH32 0x5374617274696e6720696e64657820697320616c726561647920736574000000 2661 81 DUP2 2662 52 MSTORE 2663 50 POP 2664 60 PUSH1 0x20 2666 01 ADD 2667 91 SWAP2 2668 50 POP 2669 50 POP 266A 60 PUSH1 0x40 266C 51 MLOAD 266D 80 DUP1 266E 91 SWAP2 266F 03 SUB 2670 90 SWAP1 2671 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @262A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2637 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @263B memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x1d // @2662 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x5374617274696e6720696e64657820697320616c726561647920736574000000 // @2671 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2672: // Incoming jump from 0x2604, if storage[0x0d] == 0x00 // Inputs[1] { @2677 storage[0x0c] } 2672 5B JUMPDEST 2673 60 PUSH1 0x00 2675 60 PUSH1 0x0c 2677 54 SLOAD 2678 14 EQ 2679 15 ISZERO 267A 61 PUSH2 0x26eb 267D 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x26eb, if !(storage[0x0c] == 0x00) label_267E: // Incoming jump from 0x267D, if not !(storage[0x0c] == 0x00) // Inputs[3] // { // @2680 memory[0x40:0x60] // @26E5 memory[0x40:0x60] // @26EA memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 267E 60 PUSH1 0x40 2680 51 MLOAD 2681 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 26A2 81 DUP2 26A3 52 MSTORE 26A4 60 PUSH1 0x04 26A6 01 ADD 26A7 80 DUP1 26A8 80 DUP1 26A9 60 PUSH1 0x20 26AB 01 ADD 26AC 82 DUP3 26AD 81 DUP2 26AE 03 SUB 26AF 82 DUP3 26B0 52 MSTORE 26B1 60 PUSH1 0x20 26B3 81 DUP2 26B4 52 MSTORE 26B5 60 PUSH1 0x20 26B7 01 ADD 26B8 80 DUP1 26B9 7F PUSH32 0x5374617274696e6720696e64657820626c6f636b206d75737420626520736574 26DA 81 DUP2 26DB 52 MSTORE 26DC 50 POP 26DD 60 PUSH1 0x20 26DF 01 ADD 26E0 91 SWAP2 26E1 50 POP 26E2 50 POP 26E3 60 PUSH1 0x40 26E5 51 MLOAD 26E6 80 DUP1 26E7 91 SWAP2 26E8 03 SUB 26E9 90 SWAP1 26EA FD *REVERT // Stack delta = +0 // Outputs[5] // { // @26A3 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @26B0 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @26B4 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20 // @26DB memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x5374617274696e6720696e64657820626c6f636b206d75737420626520736574 // @26EA revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_26EB: // Incoming jump from 0x267D, if !(storage[0x0c] == 0x00) // Inputs[3] // { // @26EE storage[0x0e] // @26F1 storage[0x0c] // @26F2 block.blockHash(storage[0x0c]) // } 26EB 5B JUMPDEST 26EC 60 PUSH1 0x0e 26EE 54 SLOAD 26EF 60 PUSH1 0x0c 26F1 54 SLOAD 26F2 40 BLOCKHASH 26F3 60 PUSH1 0x00 26F5 1C SHR 26F6 81 DUP2 26F7 61 PUSH2 0x26fc 26FA 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @26EE stack[0] = storage[0x0e] // @26F5 stack[1] = block.blockHash(storage[0x0c]) >> 0x00 // } // Block ends with conditional jump to 0x26fc, if storage[0x0e] label_26FB: // Incoming jump from 0x26FA, if not storage[0x0e] 26FB FE *ASSERT // Stack delta = +0 // Outputs[1] { @26FB assert(); } // Block terminates label_26FC: // Incoming jump from 0x26FA, if storage[0x0e] // Inputs[4] // { // @26FD stack[-1] // @26FD stack[-2] // @270B storage[0x0c] // @270C block.number // } 26FC 5B JUMPDEST 26FD 06 MOD 26FE 60 PUSH1 0x0d 2700 81 DUP2 2701 90 SWAP1 2702 55 SSTORE 2703 50 POP 2704 60 PUSH1 0xff 2706 61 PUSH2 0x271a 2709 60 PUSH1 0x0c 270B 54 SLOAD 270C 43 NUMBER 270D 61 PUSH2 0x310f 2710 90 SWAP1 2711 91 SWAP2 2712 90 SWAP1 2713 63 PUSH4 0xffffffff 2718 16 AND 2719 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @2702 storage[0x0d] = stack[-1] % stack[-2] // @2704 stack[-2] = 0xff // @2706 stack[-1] = 0x271a // @2711 stack[0] = block.number // @2712 stack[1] = storage[0x0c] // } // Block ends with call to 0xffffffff & 0x310f, returns to 0x271A label_271A: // Incoming return from call to 0x310F at 0x2719 // Inputs[2] // { // @271B stack[-2] // @271B stack[-1] // } 271A 5B JUMPDEST 271B 11 GT 271C 15 ISZERO 271D 61 PUSH2 0x273a 2720 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x273a, if !(stack[-1] > stack[-2]) label_2721: // Incoming jump from 0x2720, if not !(stack[-1] > stack[-2]) // Inputs[3] // { // @2723 storage[0x0e] // @2726 block.number // @2728 block.blockHash(block.number - 0x01) // } 2721 60 PUSH1 0x0e 2723 54 SLOAD 2724 60 PUSH1 0x01 2726 43 NUMBER 2727 03 SUB 2728 40 BLOCKHASH 2729 60 PUSH1 0x00 272B 1C SHR 272C 81 DUP2 272D 61 PUSH2 0x2732 2730 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2723 stack[0] = storage[0x0e] // @272B stack[1] = block.blockHash(block.number - 0x01) >> 0x00 // } // Block ends with conditional jump to 0x2732, if storage[0x0e] label_2731: // Incoming jump from 0x2730, if not storage[0x0e] 2731 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2731 assert(); } // Block terminates label_2732: // Incoming jump from 0x2730, if storage[0x0e] // Inputs[2] // { // @2733 stack[-1] // @2733 stack[-2] // } 2732 5B JUMPDEST 2733 06 MOD 2734 60 PUSH1 0x0d 2736 81 DUP2 2737 90 SWAP1 2738 55 SSTORE 2739 50 POP // Stack delta = -2 // Outputs[1] { @2738 storage[0x0d] = stack[-1] % stack[-2] } // Block continues label_273A: // Incoming jump from 0x2739 // Incoming jump from 0x2720, if !(stack[-1] > stack[-2]) // Inputs[1] { @273F storage[0x0d] } 273A 5B JUMPDEST 273B 60 PUSH1 0x00 273D 60 PUSH1 0x0d 273F 54 SLOAD 2740 14 EQ 2741 15 ISZERO 2742 61 PUSH2 0x2762 2745 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2762, if !(storage[0x0d] == 0x00) label_2746: // Incoming jump from 0x2745, if not !(storage[0x0d] == 0x00) // Inputs[1] { @274D storage[0x0d] } 2746 61 PUSH2 0x275b 2749 60 PUSH1 0x01 274B 60 PUSH1 0x0d 274D 54 SLOAD 274E 61 PUSH2 0x2e2a 2751 90 SWAP1 2752 91 SWAP2 2753 90 SWAP1 2754 63 PUSH4 0xffffffff 2759 16 AND 275A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2746 stack[0] = 0x275b // @2752 stack[1] = storage[0x0d] // @2753 stack[2] = 0x01 // } // Block ends with call to 0xffffffff & 0x2e2a, returns to 0x275B label_275B: // Incoming return from call to 0x2E2A at 0x275A // Inputs[1] { @275E stack[-1] } 275B 5B JUMPDEST 275C 60 PUSH1 0x0d 275E 81 DUP2 275F 90 SWAP1 2760 55 SSTORE 2761 50 POP // Stack delta = -1 // Outputs[1] { @2760 storage[0x0d] = stack[-1] } // Block continues label_2762: // Incoming jump from 0x2761 // Incoming jump from 0x2745, if !(storage[0x0d] == 0x00) // Inputs[1] { @2763 stack[-1] } 2762 5B JUMPDEST 2763 56 *JUMP // Stack delta = -1 // Block ends with unconditional jump to stack[-1] label_2764: // Incoming call from 0x0EBC, returns to 0x0EBD // Inputs[2] // { // @276A storage[0x0f] // @2775 stack[-1] // } 2764 5B JUMPDEST 2765 60 PUSH1 0x0f 2767 60 PUSH1 0x00 2769 90 SWAP1 276A 54 SLOAD 276B 90 SWAP1 276C 61 PUSH2 0x0100 276F 0A EXP 2770 90 SWAP1 2771 04 DIV 2772 60 PUSH1 0xff 2774 16 AND 2775 81 DUP2 2776 56 *JUMP // Stack delta = +1 // Outputs[1] { @2774 stack[0] = 0xff & storage[0x0f] / 0x0100 ** 0x00 } // Block ends with unconditional jump to stack[-1] label_2777: // Incoming jump from 0x0F23 2777 5B JUMPDEST 2778 61 PUSH2 0x277f 277B 61 PUSH2 0x296c 277E 56 *JUMP // Stack delta = +1 // Outputs[1] { @2778 stack[0] = 0x277f } // Block ends with call to 0x296c, returns to 0x277F label_277F: // Incoming return from call to 0x296C at 0x277E // Inputs[1] { @2795 stack[-1] } 277F 5B JUMPDEST 2780 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2795 16 AND 2796 61 PUSH2 0x279d 2799 61 PUSH2 0x1c4c 279C 56 *JUMP // Stack delta = +1 // Outputs[2] // { // @2795 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @2796 stack[0] = 0x279d // } // Block ends with call to 0x1c4c, returns to 0x279D label_279D: // Incoming return from call to 0x1C4C at 0x279C // Inputs[2] // { // @27B3 stack[-1] // @27B4 stack[-2] // } 279D 5B JUMPDEST 279E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 27B3 16 AND 27B4 14 EQ 27B5 61 PUSH2 0x2826 27B8 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x2826, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_27B9: // Incoming jump from 0x27B8, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[3] // { // @27BB memory[0x40:0x60] // @2820 memory[0x40:0x60] // @2825 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 27B9 60 PUSH1 0x40 27BB 51 MLOAD 27BC 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 27DD 81 DUP2 27DE 52 MSTORE 27DF 60 PUSH1 0x04 27E1 01 ADD 27E2 80 DUP1 27E3 80 DUP1 27E4 60 PUSH1 0x20 27E6 01 ADD 27E7 82 DUP3 27E8 81 DUP2 27E9 03 SUB 27EA 82 DUP3 27EB 52 MSTORE 27EC 60 PUSH1 0x20 27EE 81 DUP2 27EF 52 MSTORE 27F0 60 PUSH1 0x20 27F2 01 ADD 27F3 80 DUP1 27F4 7F PUSH32 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 2815 81 DUP2 2816 52 MSTORE 2817 50 POP 2818 60 PUSH1 0x20 281A 01 ADD 281B 91 SWAP2 281C 50 POP 281D 50 POP 281E 60 PUSH1 0x40 2820 51 MLOAD 2821 80 DUP1 2822 91 SWAP2 2823 03 SUB 2824 90 SWAP1 2825 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @27DE memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @27EB memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @27EF memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20 // @2816 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4f776e61626c653a2063616c6c6572206973206e6f7420746865206f776e6572 // @2825 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2826: // Incoming jump from 0x27B8, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @283F stack[-1] } 2826 5B JUMPDEST 2827 60 PUSH1 0x00 2829 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 283E 16 AND 283F 81 DUP2 2840 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2855 16 AND 2856 14 EQ 2857 15 ISZERO 2858 61 PUSH2 0x28ac 285B 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x28ac, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_285C: // Incoming jump from 0x285B, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @285E memory[0x40:0x60] // @28A6 memory[0x40:0x60] // @28AB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 285C 60 PUSH1 0x40 285E 51 MLOAD 285F 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2880 81 DUP2 2881 52 MSTORE 2882 60 PUSH1 0x04 2884 01 ADD 2885 80 DUP1 2886 80 DUP1 2887 60 PUSH1 0x20 2889 01 ADD 288A 82 DUP3 288B 81 DUP2 288C 03 SUB 288D 82 DUP3 288E 52 MSTORE 288F 60 PUSH1 0x26 2891 81 DUP2 2892 52 MSTORE 2893 60 PUSH1 0x20 2895 01 ADD 2896 80 DUP1 2897 61 PUSH2 0x3ed8 289A 60 PUSH1 0x26 289C 91 SWAP2 289D 39 CODECOPY 289E 60 PUSH1 0x40 28A0 01 ADD 28A1 91 SWAP2 28A2 50 POP 28A3 50 POP 28A4 60 PUSH1 0x40 28A6 51 MLOAD 28A7 80 DUP1 28A8 91 SWAP2 28A9 03 SUB 28AA 90 SWAP1 28AB FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2881 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @288E memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2892 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x26 // @289D memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x26] = code[0x3ed8:0x3efe] // @28AB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_28AC: // Incoming jump from 0x285B, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[7] // { // @28AD stack[-1] // @28C9 storage[0x0a] // @2920 memory[0x40:0x60] // @2923 memory[0x40:0x60] // @2928 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @2933 storage[0x0a] // @296B stack[-2] // } 28AC 5B JUMPDEST 28AD 80 DUP1 28AE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 28C3 16 AND 28C4 60 PUSH1 0x0a 28C6 60 PUSH1 0x00 28C8 90 SWAP1 28C9 54 SLOAD 28CA 90 SWAP1 28CB 61 PUSH2 0x0100 28CE 0A EXP 28CF 90 SWAP1 28D0 04 DIV 28D1 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 28E6 16 AND 28E7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 28FC 16 AND 28FD 7F PUSH32 0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0 291E 60 PUSH1 0x40 2920 51 MLOAD 2921 60 PUSH1 0x40 2923 51 MLOAD 2924 80 DUP1 2925 91 SWAP2 2926 03 SUB 2927 90 SWAP1 2928 A3 LOG3 2929 80 DUP1 292A 60 PUSH1 0x0a 292C 60 PUSH1 0x00 292E 61 PUSH2 0x0100 2931 0A EXP 2932 81 DUP2 2933 54 SLOAD 2934 81 DUP2 2935 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 294A 02 MUL 294B 19 NOT 294C 16 AND 294D 90 SWAP1 294E 83 DUP4 294F 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2964 16 AND 2965 02 MUL 2966 17 OR 2967 90 SWAP1 2968 55 SSTORE 2969 50 POP 296A 50 POP 296B 56 *JUMP // Stack delta = -2 // Outputs[2] // { // @2928 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8be0079c531659141344cd1fd0a4f28419497f9722a3daafe3b4186f6b6457e0, storage[0x0a] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff]); // @2968 storage[0x0a] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[0x0a]) // } // Block ends with unconditional jump to stack[-2] label_296C: // Incoming call from 0x1DCD, returns to 0x1DCE // Incoming call from 0x169B, returns to 0x169C // Incoming call from 0x125C, returns to 0x125D // Incoming call from 0x13B1, returns to 0x13B2 // Incoming call from 0x3501, returns to 0x3502 // Incoming call from 0x155A, returns to 0x155B // Incoming call from 0x1233, returns to 0x1234 // Incoming call from 0x1B23, returns to 0x1B24 // Incoming call from 0x1D1F, returns to 0x1D20 // Incoming call from 0x0F2D, returns to 0x0F2E // Incoming call from 0x1E7A, returns to 0x1E7B // Incoming call from 0x212E, returns to 0x212F // Incoming call from 0x277E, returns to 0x277F // Incoming call from 0x19A7, returns to 0x19A8 // Incoming call from 0x12CE, returns to 0x12CF // Incoming call from 0x2215, returns to 0x2216 // Incoming call from 0x147F, returns to 0x1480 // Inputs[2] // { // @296F msg.sender // @2972 stack[-1] // } 296C 5B JUMPDEST 296D 60 PUSH1 0x00 296F 33 CALLER 2970 90 SWAP1 2971 50 POP 2972 90 SWAP1 2973 56 *JUMP // Stack delta = +0 // Outputs[1] { @2972 stack[-1] = msg.sender } // Block ends with unconditional jump to stack[-1] label_2974: // Incoming call from 0x39DA, returns to 0x39DB // Incoming call from 0x10F2, returns to 0x10F3 // Incoming call from 0x2293, returns to 0x2294 // Incoming call from 0x2A69, returns to 0x2A6A // Inputs[1] { @297A stack[-1] } 2974 5B JUMPDEST 2975 60 PUSH1 0x00 2977 61 PUSH2 0x298a 297A 82 DUP3 297B 60 PUSH1 0x02 297D 61 PUSH2 0x3192 2980 90 SWAP1 2981 91 SWAP2 2982 90 SWAP1 2983 63 PUSH4 0xffffffff 2988 16 AND 2989 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2975 stack[0] = 0x00 // @2977 stack[1] = 0x298a // @2981 stack[2] = 0x02 // @2982 stack[3] = stack[-1] // } // Block ends with call to 0xffffffff & 0x3192, returns to 0x298A label_298A: // Incoming return from call to 0x3192 at 0x2989 // Inputs[4] // { // @298B stack[-2] // @298B stack[-1] // @298D stack[-4] // @298E stack[-3] // } 298A 5B JUMPDEST 298B 90 SWAP1 298C 50 POP 298D 91 SWAP2 298E 90 SWAP1 298F 50 POP 2990 56 *JUMP // Stack delta = -3 // Outputs[1] { @298D stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2991: // Incoming call from 0x12C1, returns to 0x12C2 // Incoming call from 0x2C7A, returns to 0x2C7B // Inputs[4] // { // @2992 stack[-2] // @2997 stack[-1] // @29A5 memory[0x00:0x40] // @29AD storage[keccak256(memory[0x00:0x40])] // } 2991 5B JUMPDEST 2992 81 DUP2 2993 60 PUSH1 0x04 2995 60 PUSH1 0x00 2997 83 DUP4 2998 81 DUP2 2999 52 MSTORE 299A 60 PUSH1 0x20 299C 01 ADD 299D 90 SWAP1 299E 81 DUP2 299F 52 MSTORE 29A0 60 PUSH1 0x20 29A2 01 ADD 29A3 60 PUSH1 0x00 29A5 20 SHA3 29A6 60 PUSH1 0x00 29A8 61 PUSH2 0x0100 29AB 0A EXP 29AC 81 DUP2 29AD 54 SLOAD 29AE 81 DUP2 29AF 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 29C4 02 MUL 29C5 19 NOT 29C6 16 AND 29C7 90 SWAP1 29C8 83 DUP4 29C9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 29DE 16 AND 29DF 02 MUL 29E0 17 OR 29E1 90 SWAP1 29E2 55 SSTORE 29E3 50 POP 29E4 80 DUP1 29E5 82 DUP3 29E6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 29FB 16 AND 29FC 61 PUSH2 0x2a04 29FF 83 DUP4 2A00 61 PUSH2 0x17f2 2A03 56 *JUMP // Stack delta = +4 // Outputs[7] // { // @2999 memory[0x00:0x20] = stack[-1] // @299F memory[0x20:0x40] = 0x04 // @29E2 storage[keccak256(memory[0x00:0x40])] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-2]) * 0x0100 ** 0x00 | (~(0xffffffffffffffffffffffffffffffffffffffff * 0x0100 ** 0x00) & storage[keccak256(memory[0x00:0x40])]) // @29E4 stack[0] = stack[-1] // @29FB stack[1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @29FC stack[2] = 0x2a04 // @29FF stack[3] = stack[-1] // } // Block ends with call to 0x17f2, returns to 0x2A04 label_2A04: // Incoming return from call to 0x17F2 at 0x2A03 // Inputs[7] // { // @2A1A stack[-1] // @2A3E memory[0x40:0x60] // @2A41 memory[0x40:0x60] // @2A46 stack[-3] // @2A46 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @2A46 stack[-2] // @2A49 stack[-6] // } 2A04 5B JUMPDEST 2A05 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2A1A 16 AND 2A1B 7F PUSH32 0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925 2A3C 60 PUSH1 0x40 2A3E 51 MLOAD 2A3F 60 PUSH1 0x40 2A41 51 MLOAD 2A42 80 DUP1 2A43 91 SWAP2 2A44 03 SUB 2A45 90 SWAP1 2A46 A4 LOG4 2A47 50 POP 2A48 50 POP 2A49 56 *JUMP // Stack delta = -6 // Outputs[1] { @2A46 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0x8c5be1e5ebec7d5bd14f71427d1e84f3dd0314c0f7b2291e5b200ac8c7c3b925, stack[-1] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2], stack[-3]]); } // Block ends with unconditional jump to stack[-6] label_2A4A: // Incoming call from 0x139B, returns to 0x139C // Inputs[1] { @2A50 stack[-1] } 2A4A 5B JUMPDEST 2A4B 60 PUSH1 0x00 2A4D 61 PUSH2 0x2a58 2A50 82 DUP3 2A51 60 PUSH1 0x00 2A53 01 ADD 2A54 61 PUSH2 0x31ac 2A57 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2A4B stack[0] = 0x00 // @2A4D stack[1] = 0x2a58 // @2A53 stack[2] = 0x00 + stack[-1] // } // Block ends with call to 0x31ac, returns to 0x2A58 label_2A58: // Incoming return from call to 0x31AC at 0x2A57 // Inputs[4] // { // @2A59 stack[-1] // @2A59 stack[-2] // @2A5B stack[-4] // @2A5C stack[-3] // } 2A58 5B JUMPDEST 2A59 90 SWAP1 2A5A 50 POP 2A5B 91 SWAP2 2A5C 90 SWAP1 2A5D 50 POP 2A5E 56 *JUMP // Stack delta = -3 // Outputs[1] { @2A5B stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2A5F: // Incoming jump from 0x13B7 // Incoming jump from 0x221B // Inputs[1] { @2A65 stack[-1] } 2A5F 5B JUMPDEST 2A60 60 PUSH1 0x00 2A62 61 PUSH2 0x2a6a 2A65 82 DUP3 2A66 61 PUSH2 0x2974 2A69 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2A60 stack[0] = 0x00 // @2A62 stack[1] = 0x2a6a // @2A65 stack[2] = stack[-1] // } // Block ends with call to 0x2974, returns to 0x2A6A label_2A6A: // Incoming return from call to 0x2974 at 0x2A69 // Inputs[1] { @2A6E stack[-1] } 2A6A 5B JUMPDEST 2A6B 61 PUSH2 0x2abf 2A6E 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2abf, if stack[-1] label_2A6F: // Incoming jump from 0x2A6E, if not stack[-1] // Inputs[3] // { // @2A71 memory[0x40:0x60] // @2AB9 memory[0x40:0x60] // @2ABE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2A6F 60 PUSH1 0x40 2A71 51 MLOAD 2A72 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2A93 81 DUP2 2A94 52 MSTORE 2A95 60 PUSH1 0x04 2A97 01 ADD 2A98 80 DUP1 2A99 80 DUP1 2A9A 60 PUSH1 0x20 2A9C 01 ADD 2A9D 82 DUP3 2A9E 81 DUP2 2A9F 03 SUB 2AA0 82 DUP3 2AA1 52 MSTORE 2AA2 60 PUSH1 0x2c 2AA4 81 DUP2 2AA5 52 MSTORE 2AA6 60 PUSH1 0x20 2AA8 01 ADD 2AA9 80 DUP1 2AAA 61 PUSH2 0x3f48 2AAD 60 PUSH1 0x2c 2AAF 91 SWAP2 2AB0 39 CODECOPY 2AB1 60 PUSH1 0x40 2AB3 01 ADD 2AB4 91 SWAP2 2AB5 50 POP 2AB6 50 POP 2AB7 60 PUSH1 0x40 2AB9 51 MLOAD 2ABA 80 DUP1 2ABB 91 SWAP2 2ABC 03 SUB 2ABD 90 SWAP1 2ABE FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2A94 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2AA1 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2AA5 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x2c // @2AB0 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x2c] = code[0x3f48:0x3f74] // @2ABE revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2ABF: // Incoming jump from 0x2A6E, if stack[-1] // Inputs[1] { @2AC5 stack[-2] } 2ABF 5B JUMPDEST 2AC0 60 PUSH1 0x00 2AC2 61 PUSH2 0x2aca 2AC5 83 DUP4 2AC6 61 PUSH2 0x17f2 2AC9 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2AC0 stack[0] = 0x00 // @2AC2 stack[1] = 0x2aca // @2AC5 stack[2] = stack[-2] // } // Block ends with call to 0x17f2, returns to 0x2ACA label_2ACA: // Incoming return from call to 0x17F2 at 0x2AC9 // Inputs[3] // { // @2ACB stack[-2] // @2ACB stack[-1] // @2AE4 stack[-5] // } 2ACA 5B JUMPDEST 2ACB 90 SWAP1 2ACC 50 POP 2ACD 80 DUP1 2ACE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2AE3 16 AND 2AE4 84 DUP5 2AE5 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2AFA 16 AND 2AFB 14 EQ 2AFC 80 DUP1 2AFD 61 PUSH2 0x2b39 2B00 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @2ACB stack[-2] = stack[-1] // @2AFB stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // } // Block ends with conditional jump to 0x2b39, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] label_2B01: // Incoming jump from 0x2B00, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Inputs[2] // { // @2B02 stack[-5] // @2B1C stack[-4] // } 2B01 50 POP 2B02 83 DUP4 2B03 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2B18 16 AND 2B19 61 PUSH2 0x2b21 2B1C 84 DUP5 2B1D 61 PUSH2 0x10e8 2B20 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2B18 stack[-1] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @2B19 stack[0] = 0x2b21 // @2B1C stack[1] = stack[-4] // } // Block ends with call to 0x10e8, returns to 0x2B21 label_2B21: // Incoming return from call to 0x10E8 at 0x2B20 // Inputs[2] // { // @2B37 stack[-1] // @2B38 stack[-2] // } 2B21 5B JUMPDEST 2B22 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2B37 16 AND 2B38 14 EQ // Stack delta = -1 // Outputs[1] { @2B38 stack[-2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] } // Block continues label_2B39: // Incoming jump from 0x2B38 // Incoming jump from 0x2B00, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] == 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // Inputs[1] { @2B3A stack[-1] } 2B39 5B JUMPDEST 2B3A 80 DUP1 2B3B 61 PUSH2 0x2b4a 2B3E 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2b4a, if stack[-1] label_2B3F: // Incoming jump from 0x2B3E, if not stack[-1] // Inputs[2] // { // @2B43 stack[-2] // @2B44 stack[-5] // } 2B3F 50 POP 2B40 61 PUSH2 0x2b49 2B43 81 DUP2 2B44 85 DUP6 2B45 61 PUSH2 0x2566 2B48 56 *JUMP // Stack delta = +2 // Outputs[3] // { // @2B40 stack[-1] = 0x2b49 // @2B43 stack[0] = stack[-2] // @2B44 stack[1] = stack[-5] // } // Block ends with call to 0x2566, returns to 0x2B49 label_2B49: // Incoming return from call to 0x2566 at 0x2B48 2B49 5B JUMPDEST // Stack delta = +0 // Block continues label_2B4A: // Incoming jump from 0x2B3E, if stack[-1] // Incoming jump from 0x2B49 // Inputs[4] // { // @2B4B stack[-3] // @2B4B stack[-1] // @2B4E stack[-6] // @2B4F stack[-5] // } 2B4A 5B JUMPDEST 2B4B 91 SWAP2 2B4C 50 POP 2B4D 50 POP 2B4E 92 SWAP3 2B4F 91 SWAP2 2B50 50 POP 2B51 50 POP 2B52 56 *JUMP // Stack delta = -5 // Outputs[1] { @2B4E stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_2B53: // Incoming call from 0x1417, returns to 0x1418 // Incoming call from 0x2F60, returns to 0x2F61 // Inputs[2] // { // @2B54 stack[-3] // @2B6E stack[-1] // } 2B53 5B JUMPDEST 2B54 82 DUP3 2B55 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2B6A 16 AND 2B6B 61 PUSH2 0x2b73 2B6E 82 DUP3 2B6F 61 PUSH2 0x17f2 2B72 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2B6A stack[0] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @2B6B stack[1] = 0x2b73 // @2B6E stack[2] = stack[-1] // } // Block ends with call to 0x17f2, returns to 0x2B73 label_2B73: // Incoming return from call to 0x17F2 at 0x2B72 // Inputs[2] // { // @2B89 stack[-1] // @2B8A stack[-2] // } 2B73 5B JUMPDEST 2B74 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2B89 16 AND 2B8A 14 EQ 2B8B 61 PUSH2 0x2bdf 2B8E 57 *JUMPI // Stack delta = -2 // Block ends with conditional jump to 0x2bdf, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] label_2B8F: // Incoming jump from 0x2B8E, if not 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[3] // { // @2B91 memory[0x40:0x60] // @2BD9 memory[0x40:0x60] // @2BDE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2B8F 60 PUSH1 0x40 2B91 51 MLOAD 2B92 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2BB3 81 DUP2 2BB4 52 MSTORE 2BB5 60 PUSH1 0x04 2BB7 01 ADD 2BB8 80 DUP1 2BB9 80 DUP1 2BBA 60 PUSH1 0x20 2BBC 01 ADD 2BBD 82 DUP3 2BBE 81 DUP2 2BBF 03 SUB 2BC0 82 DUP3 2BC1 52 MSTORE 2BC2 60 PUSH1 0x29 2BC4 81 DUP2 2BC5 52 MSTORE 2BC6 60 PUSH1 0x20 2BC8 01 ADD 2BC9 80 DUP1 2BCA 61 PUSH2 0x40b7 2BCD 60 PUSH1 0x29 2BCF 91 SWAP2 2BD0 39 CODECOPY 2BD1 60 PUSH1 0x40 2BD3 01 ADD 2BD4 91 SWAP2 2BD5 50 POP 2BD6 50 POP 2BD7 60 PUSH1 0x40 2BD9 51 MLOAD 2BDA 80 DUP1 2BDB 91 SWAP2 2BDC 03 SUB 2BDD 90 SWAP1 2BDE FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2BB4 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2BC1 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2BC5 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x29 // @2BD0 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x29] = code[0x40b7:0x40e0] // @2BDE revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2BDF: // Incoming jump from 0x2B8E, if 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] == stack[-2] // Inputs[1] { @2BF8 stack[-2] } 2BDF 5B JUMPDEST 2BE0 60 PUSH1 0x00 2BE2 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2BF7 16 AND 2BF8 82 DUP3 2BF9 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2C0E 16 AND 2C0F 14 EQ 2C10 15 ISZERO 2C11 61 PUSH2 0x2c65 2C14 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x2c65, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_2C15: // Incoming jump from 0x2C14, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @2C17 memory[0x40:0x60] // @2C5F memory[0x40:0x60] // @2C64 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2C15 60 PUSH1 0x40 2C17 51 MLOAD 2C18 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2C39 81 DUP2 2C3A 52 MSTORE 2C3B 60 PUSH1 0x04 2C3D 01 ADD 2C3E 80 DUP1 2C3F 80 DUP1 2C40 60 PUSH1 0x20 2C42 01 ADD 2C43 82 DUP3 2C44 81 DUP2 2C45 03 SUB 2C46 82 DUP3 2C47 52 MSTORE 2C48 60 PUSH1 0x24 2C4A 81 DUP2 2C4B 52 MSTORE 2C4C 60 PUSH1 0x20 2C4E 01 ADD 2C4F 80 DUP1 2C50 61 PUSH2 0x3efe 2C53 60 PUSH1 0x24 2C55 91 SWAP2 2C56 39 CODECOPY 2C57 60 PUSH1 0x40 2C59 01 ADD 2C5A 91 SWAP2 2C5B 50 POP 2C5C 50 POP 2C5D 60 PUSH1 0x40 2C5F 51 MLOAD 2C60 80 DUP1 2C61 91 SWAP2 2C62 03 SUB 2C63 90 SWAP1 2C64 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2C3A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2C47 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2C4B memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x24 // @2C56 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x24] = code[0x3efe:0x3f22] // @2C64 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2C65: // Incoming jump from 0x2C14, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @2C69 stack[-3] // @2C6A stack[-2] // @2C6B stack[-1] // } 2C65 5B JUMPDEST 2C66 61 PUSH2 0x2c70 2C69 83 DUP4 2C6A 83 DUP4 2C6B 83 DUP4 2C6C 61 PUSH2 0x31bd 2C6F 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2C66 stack[0] = 0x2c70 // @2C69 stack[1] = stack[-3] // @2C6A stack[2] = stack[-2] // @2C6B stack[3] = stack[-1] // } // Block ends with call to 0x31bd, returns to 0x2C70 label_2C70: // Incoming return from call to 0x31BD at 0x2C6F // Inputs[1] { @2C76 stack[-1] } 2C70 5B JUMPDEST 2C71 61 PUSH2 0x2c7b 2C74 60 PUSH1 0x00 2C76 82 DUP3 2C77 61 PUSH2 0x2991 2C7A 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2C71 stack[0] = 0x2c7b // @2C74 stack[1] = 0x00 // @2C76 stack[2] = stack[-1] // } // Block ends with call to 0x2991, returns to 0x2C7B label_2C7B: // Incoming return from call to 0x2991 at 0x2C7A // Inputs[3] // { // @2C7F stack[-1] // @2C84 stack[-3] // @2CBE memory[0x00:0x40] // } 2C7B 5B JUMPDEST 2C7C 61 PUSH2 0x2ccc 2C7F 81 DUP2 2C80 60 PUSH1 0x01 2C82 60 PUSH1 0x00 2C84 86 DUP7 2C85 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2C9A 16 AND 2C9B 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2CB0 16 AND 2CB1 81 DUP2 2CB2 52 MSTORE 2CB3 60 PUSH1 0x20 2CB5 01 ADD 2CB6 90 SWAP1 2CB7 81 DUP2 2CB8 52 MSTORE 2CB9 60 PUSH1 0x20 2CBB 01 ADD 2CBC 60 PUSH1 0x00 2CBE 20 SHA3 2CBF 61 PUSH2 0x31c2 2CC2 90 SWAP1 2CC3 91 SWAP2 2CC4 90 SWAP1 2CC5 63 PUSH4 0xffffffff 2CCA 16 AND 2CCB 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @2C7C stack[0] = 0x2ccc // @2CB2 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @2CB8 memory[0x20:0x40] = 0x01 // @2CC3 stack[1] = keccak256(memory[0x00:0x40]) // @2CC4 stack[2] = stack[-1] // } // Block ends with call to 0xffffffff & 0x31c2, returns to 0x2CCC label_2CCC: // Incoming return from call to 0x31C2 at 0x2CCB // Inputs[3] // { // @2CD1 stack[-2] // @2CD6 stack[-3] // @2D10 memory[0x00:0x40] // } 2CCC 5B JUMPDEST 2CCD 50 POP 2CCE 61 PUSH2 0x2d1e 2CD1 81 DUP2 2CD2 60 PUSH1 0x01 2CD4 60 PUSH1 0x00 2CD6 85 DUP6 2CD7 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2CEC 16 AND 2CED 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2D02 16 AND 2D03 81 DUP2 2D04 52 MSTORE 2D05 60 PUSH1 0x20 2D07 01 ADD 2D08 90 SWAP1 2D09 81 DUP2 2D0A 52 MSTORE 2D0B 60 PUSH1 0x20 2D0D 01 ADD 2D0E 60 PUSH1 0x00 2D10 20 SHA3 2D11 61 PUSH2 0x31dc 2D14 90 SWAP1 2D15 91 SWAP2 2D16 90 SWAP1 2D17 63 PUSH4 0xffffffff 2D1C 16 AND 2D1D 56 *JUMP // Stack delta = +2 // Outputs[5] // { // @2CCE stack[-1] = 0x2d1e // @2D04 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // @2D0A memory[0x20:0x40] = 0x01 // @2D15 stack[0] = keccak256(memory[0x00:0x40]) // @2D16 stack[1] = stack[-2] // } // Block ends with call to 0xffffffff & 0x31dc, returns to 0x2D1E label_2D1E: // Incoming return from call to 0x31DC at 0x2D1D // Inputs[2] // { // @2D23 stack[-2] // @2D24 stack[-3] // } 2D1E 5B JUMPDEST 2D1F 50 POP 2D20 61 PUSH2 0x2d35 2D23 81 DUP2 2D24 83 DUP4 2D25 60 PUSH1 0x02 2D27 61 PUSH2 0x31f6 2D2A 90 SWAP1 2D2B 92 SWAP3 2D2C 91 SWAP2 2D2D 90 SWAP1 2D2E 63 PUSH4 0xffffffff 2D33 16 AND 2D34 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @2D20 stack[-1] = 0x2d35 // @2D2B stack[0] = 0x02 // @2D2C stack[1] = stack[-2] // @2D2D stack[2] = stack[-3] // } // Block ends with call to 0xffffffff & 0x31f6, returns to 0x2D35 label_2D35: // Incoming return from call to 0x31F6 at 0x2D34 // Inputs[7] // { // @2D37 stack[-2] // @2D38 stack[-3] // @2D4F stack[-4] // @2D89 memory[0x40:0x60] // @2D8C memory[0x40:0x60] // @2D91 memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @2D95 stack[-5] // } 2D35 5B JUMPDEST 2D36 50 POP 2D37 80 DUP1 2D38 82 DUP3 2D39 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2D4E 16 AND 2D4F 84 DUP5 2D50 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 2D65 16 AND 2D66 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 2D87 60 PUSH1 0x40 2D89 51 MLOAD 2D8A 60 PUSH1 0x40 2D8C 51 MLOAD 2D8D 80 DUP1 2D8E 91 SWAP2 2D8F 03 SUB 2D90 90 SWAP1 2D91 A4 LOG4 2D92 50 POP 2D93 50 POP 2D94 50 POP 2D95 56 *JUMP // Stack delta = -5 // Outputs[1] { @2D91 log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, stack[-4] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2]]); } // Block ends with unconditional jump to stack[-5] label_2D96: // Incoming call from 0x146F, returns to 0x1470 // Inputs[2] // { // @2D9C stack[-2] // @2DA0 stack[-1] // } 2D96 5B JUMPDEST 2D97 60 PUSH1 0x00 2D99 61 PUSH2 0x2da5 2D9C 83 DUP4 2D9D 60 PUSH1 0x00 2D9F 01 ADD 2DA0 83 DUP4 2DA1 61 PUSH2 0x322b 2DA4 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2D97 stack[0] = 0x00 // @2D99 stack[1] = 0x2da5 // @2D9F stack[2] = 0x00 + stack[-2] // @2DA0 stack[3] = stack[-1] // } // Block ends with call to 0x322b, returns to 0x2DA5 label_2DA5: // Incoming return from call to 0x322B at 0x2DA4 // Inputs[4] // { // @2DA8 stack[-1] // @2DA9 stack[-2] // @2DAB stack[-5] // @2DAC stack[-4] // } 2DA5 5B JUMPDEST 2DA6 60 PUSH1 0x00 2DA8 1C SHR 2DA9 90 SWAP1 2DAA 50 POP 2DAB 92 SWAP3 2DAC 91 SWAP2 2DAD 50 POP 2DAE 50 POP 2DAF 56 *JUMP // Stack delta = -4 // Outputs[1] { @2DAB stack[-5] = stack[-1] >> 0x00 } // Block ends with unconditional jump to stack[-5] label_2DB0: // Incoming call from 0x1687, returns to 0x1688 // Inputs[2] // { // @2DBA stack[-2] // @2DBE stack[-1] // } 2DB0 5B JUMPDEST 2DB1 60 PUSH1 0x00 2DB3 80 DUP1 2DB4 60 PUSH1 0x00 2DB6 80 DUP1 2DB7 61 PUSH2 0x2dc3 2DBA 86 DUP7 2DBB 60 PUSH1 0x00 2DBD 01 ADD 2DBE 86 DUP7 2DBF 61 PUSH2 0x32ae 2DC2 56 *JUMP // Stack delta = +7 // Outputs[7] // { // @2DB1 stack[0] = 0x00 // @2DB3 stack[1] = 0x00 // @2DB4 stack[2] = 0x00 // @2DB6 stack[3] = 0x00 // @2DB7 stack[4] = 0x2dc3 // @2DBD stack[5] = 0x00 + stack[-2] // @2DBE stack[6] = stack[-1] // } // Block ends with call to 0x32ae, returns to 0x2DC3 label_2DC3: // Incoming return from call to 0x32AE at 0x2DC2 // Inputs[9] // { // @2DC4 stack[-1] // @2DC4 stack[-3] // @2DC6 stack[-4] // @2DC6 stack[-2] // @2DD0 stack[-5] // @2DD2 stack[-6] // @2DD6 stack[-8] // @2DD8 stack[-9] // @2DD9 stack[-7] // } 2DC3 5B JUMPDEST 2DC4 91 SWAP2 2DC5 50 POP 2DC6 91 SWAP2 2DC7 50 POP 2DC8 81 DUP2 2DC9 60 PUSH1 0x00 2DCB 1C SHR 2DCC 81 DUP2 2DCD 60 PUSH1 0x00 2DCF 1C SHR 2DD0 93 SWAP4 2DD1 50 POP 2DD2 93 SWAP4 2DD3 50 POP 2DD4 50 POP 2DD5 50 POP 2DD6 92 SWAP3 2DD7 50 POP 2DD8 92 SWAP3 2DD9 90 SWAP1 2DDA 50 POP 2DDB 56 *JUMP // Stack delta = -7 // Outputs[2] // { // @2DD6 stack[-8] = stack[-1] >> 0x00 // @2DD8 stack[-9] = stack[-2] >> 0x00 // } // Block ends with unconditional jump to stack[-9] label_2DDC: // Incoming call from 0x174B, returns to 0x174C // Inputs[2] // { // @2DDD stack[-1] // @2DE2 memory[stack[-1]:stack[-1] + 0x20] // } 2DDC 5B JUMPDEST 2DDD 80 DUP1 2DDE 60 PUSH1 0x09 2DE0 90 SWAP1 2DE1 80 DUP1 2DE2 51 MLOAD 2DE3 90 SWAP1 2DE4 60 PUSH1 0x20 2DE6 01 ADD 2DE7 90 SWAP1 2DE8 61 PUSH2 0x2df2 2DEB 92 SWAP3 2DEC 91 SWAP2 2DED 90 SWAP1 2DEE 61 PUSH2 0x3de6 2DF1 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2DEB stack[0] = 0x2df2 // @2DEC stack[1] = 0x09 // @2DED stack[2] = 0x20 + stack[-1] // @2DED stack[3] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with call to 0x3de6, returns to 0x2DF2 label_2DF2: // Incoming return from call to 0x3DE6 at 0x2DF1 // Inputs[1] { @2DF5 stack[-3] } 2DF2 5B JUMPDEST 2DF3 50 POP 2DF4 50 POP 2DF5 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_2DF6: // Incoming call from 0x1821, returns to 0x1822 // Inputs[3] // { // @2DFC stack[-3] // @2E00 stack[-2] // @2E04 stack[-1] // } 2DF6 5B JUMPDEST 2DF7 60 PUSH1 0x00 2DF9 61 PUSH2 0x2e09 2DFC 84 DUP5 2DFD 60 PUSH1 0x00 2DFF 01 ADD 2E00 84 DUP5 2E01 60 PUSH1 0x00 2E03 1B SHL 2E04 84 DUP5 2E05 61 PUSH2 0x3347 2E08 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @2DF7 stack[0] = 0x00 // @2DF9 stack[1] = 0x2e09 // @2DFF stack[2] = 0x00 + stack[-3] // @2E03 stack[3] = stack[-2] << 0x00 // @2E04 stack[4] = stack[-1] // } // Block ends with call to 0x3347, returns to 0x2E09 label_2E09: // Incoming return from call to 0x3347 at 0x2E08 // Inputs[4] // { // @2E0C stack[-1] // @2E0D stack[-2] // @2E0F stack[-6] // @2E10 stack[-5] // } 2E09 5B JUMPDEST 2E0A 60 PUSH1 0x00 2E0C 1C SHR 2E0D 90 SWAP1 2E0E 50 POP 2E0F 93 SWAP4 2E10 92 SWAP3 2E11 50 POP 2E12 50 POP 2E13 50 POP 2E14 56 *JUMP // Stack delta = -5 // Outputs[1] { @2E0F stack[-6] = stack[-1] >> 0x00 } // Block ends with unconditional jump to stack[-6] label_2E15: // Incoming call from 0x1998, returns to 0x1999 // Inputs[1] { @2E1B stack[-1] } 2E15 5B JUMPDEST 2E16 60 PUSH1 0x00 2E18 61 PUSH2 0x2e23 2E1B 82 DUP3 2E1C 60 PUSH1 0x00 2E1E 01 ADD 2E1F 61 PUSH2 0x343d 2E22 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @2E16 stack[0] = 0x00 // @2E18 stack[1] = 0x2e23 // @2E1E stack[2] = 0x00 + stack[-1] // } // Block ends with call to 0x343d, returns to 0x2E23 label_2E23: // Incoming return from call to 0x343D at 0x2E22 // Inputs[4] // { // @2E24 stack[-2] // @2E24 stack[-1] // @2E26 stack[-4] // @2E27 stack[-3] // } 2E23 5B JUMPDEST 2E24 90 SWAP1 2E25 50 POP 2E26 91 SWAP2 2E27 90 SWAP1 2E28 50 POP 2E29 56 *JUMP // Stack delta = -3 // Outputs[1] { @2E26 stack[-4] = stack[-1] } // Block ends with unconditional jump to stack[-4] label_2E2A: // Incoming call from 0x275A, returns to 0x275B // Incoming jump from 0x1FC6 // Inputs[2] // { // @2E2E stack[-1] // @2E2F stack[-2] // } 2E2A 5B JUMPDEST 2E2B 60 PUSH1 0x00 2E2D 80 DUP1 2E2E 82 DUP3 2E2F 84 DUP5 2E30 01 ADD 2E31 90 SWAP1 2E32 50 POP 2E33 83 DUP4 2E34 81 DUP2 2E35 10 LT 2E36 15 ISZERO 2E37 61 PUSH2 0x2ea8 2E3A 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @2E2B stack[0] = 0x00 // @2E31 stack[1] = stack[-2] + stack[-1] // } // Block ends with conditional jump to 0x2ea8, if !(stack[-2] + stack[-1] < stack[-2]) label_2E3B: // Incoming jump from 0x2E3A, if not !(stack[-2] + stack[-1] < stack[-2]) // Inputs[3] // { // @2E3D memory[0x40:0x60] // @2EA2 memory[0x40:0x60] // @2EA7 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2E3B 60 PUSH1 0x40 2E3D 51 MLOAD 2E3E 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2E5F 81 DUP2 2E60 52 MSTORE 2E61 60 PUSH1 0x04 2E63 01 ADD 2E64 80 DUP1 2E65 80 DUP1 2E66 60 PUSH1 0x20 2E68 01 ADD 2E69 82 DUP3 2E6A 81 DUP2 2E6B 03 SUB 2E6C 82 DUP3 2E6D 52 MSTORE 2E6E 60 PUSH1 0x1b 2E70 81 DUP2 2E71 52 MSTORE 2E72 60 PUSH1 0x20 2E74 01 ADD 2E75 80 DUP1 2E76 7F PUSH32 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 2E97 81 DUP2 2E98 52 MSTORE 2E99 50 POP 2E9A 60 PUSH1 0x20 2E9C 01 ADD 2E9D 91 SWAP2 2E9E 50 POP 2E9F 50 POP 2EA0 60 PUSH1 0x40 2EA2 51 MLOAD 2EA3 80 DUP1 2EA4 91 SWAP2 2EA5 03 SUB 2EA6 90 SWAP1 2EA7 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2E60 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2E6D memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2E71 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x1b // @2E98 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x536166654d6174683a206164646974696f6e206f766572666c6f770000000000 // @2EA7 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2EA8: // Incoming jump from 0x2E3A, if !(stack[-2] + stack[-1] < stack[-2]) // Inputs[4] // { // @2EA9 stack[-1] // @2EAA stack[-2] // @2EAD stack[-5] // @2EAE stack[-4] // } 2EA8 5B JUMPDEST 2EA9 80 DUP1 2EAA 91 SWAP2 2EAB 50 POP 2EAC 50 POP 2EAD 92 SWAP3 2EAE 91 SWAP2 2EAF 50 POP 2EB0 50 POP 2EB1 56 *JUMP // Stack delta = -4 // Outputs[1] { @2EAD stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_2EB2: // Incoming call from 0x2039, returns to 0x203A // Inputs[1] { @2EB6 stack[-2] } 2EB2 5B JUMPDEST 2EB3 60 PUSH1 0x00 2EB5 80 DUP1 2EB6 83 DUP4 2EB7 14 EQ 2EB8 15 ISZERO 2EB9 61 PUSH2 0x2ec5 2EBC 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2EB3 stack[0] = 0x00 } // Block ends with conditional jump to 0x2ec5, if !(stack[-2] == 0x00) label_2EBD: // Incoming jump from 0x2EBC, if not !(stack[-2] == 0x00) // Inputs[1] { @2EBF stack[-1] } 2EBD 60 PUSH1 0x00 2EBF 90 SWAP1 2EC0 50 POP 2EC1 61 PUSH2 0x2f32 2EC4 56 *JUMP // Stack delta = +0 // Outputs[1] { @2EBF stack[-1] = 0x00 } // Block ends with unconditional jump to 0x2f32 label_2EC5: // Incoming jump from 0x2EBC, if !(stack[-2] == 0x00) // Inputs[2] // { // @2EC8 stack[-2] // @2EC9 stack[-3] // } 2EC5 5B JUMPDEST 2EC6 60 PUSH1 0x00 2EC8 82 DUP3 2EC9 84 DUP5 2ECA 02 MUL 2ECB 90 SWAP1 2ECC 50 POP 2ECD 82 DUP3 2ECE 84 DUP5 2ECF 82 DUP3 2ED0 81 DUP2 2ED1 61 PUSH2 0x2ed6 2ED4 57 *JUMPI // Stack delta = +4 // Outputs[4] // { // @2ECB stack[0] = stack[-3] * stack[-2] // @2ECD stack[1] = stack[-2] // @2ECE stack[2] = stack[-3] // @2ECF stack[3] = stack[-3] * stack[-2] // } // Block ends with conditional jump to 0x2ed6, if stack[-3] label_2ED5: // Incoming jump from 0x2ED4, if not stack[-3] 2ED5 FE *ASSERT // Stack delta = +0 // Outputs[1] { @2ED5 assert(); } // Block terminates label_2ED6: // Incoming jump from 0x2ED4, if stack[-3] // Inputs[3] // { // @2ED7 stack[-2] // @2ED7 stack[-1] // @2ED8 stack[-3] // } 2ED6 5B JUMPDEST 2ED7 04 DIV 2ED8 14 EQ 2ED9 61 PUSH2 0x2f2d 2EDC 57 *JUMPI // Stack delta = -3 // Block ends with conditional jump to 0x2f2d, if stack[-1] / stack[-2] == stack[-3] label_2EDD: // Incoming jump from 0x2EDC, if not stack[-1] / stack[-2] == stack[-3] // Inputs[3] // { // @2EDF memory[0x40:0x60] // @2F27 memory[0x40:0x60] // @2F2C memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2EDD 60 PUSH1 0x40 2EDF 51 MLOAD 2EE0 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2F01 81 DUP2 2F02 52 MSTORE 2F03 60 PUSH1 0x04 2F05 01 ADD 2F06 80 DUP1 2F07 80 DUP1 2F08 60 PUSH1 0x20 2F0A 01 ADD 2F0B 82 DUP3 2F0C 81 DUP2 2F0D 03 SUB 2F0E 82 DUP3 2F0F 52 MSTORE 2F10 60 PUSH1 0x21 2F12 81 DUP2 2F13 52 MSTORE 2F14 60 PUSH1 0x20 2F16 01 ADD 2F17 80 DUP1 2F18 61 PUSH2 0x406a 2F1B 60 PUSH1 0x21 2F1D 91 SWAP2 2F1E 39 CODECOPY 2F1F 60 PUSH1 0x40 2F21 01 ADD 2F22 91 SWAP2 2F23 50 POP 2F24 50 POP 2F25 60 PUSH1 0x40 2F27 51 MLOAD 2F28 80 DUP1 2F29 91 SWAP2 2F2A 03 SUB 2F2B 90 SWAP1 2F2C FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2F02 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2F0F memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2F13 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x21 // @2F1E memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x21] = code[0x406a:0x408b] // @2F2C revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2F2D: // Incoming jump from 0x2EDC, if stack[-1] / stack[-2] == stack[-3] // Inputs[4] // { // @2F2E stack[-1] // @2F2F stack[-2] // @2F33 stack[-5] // @2F34 stack[-4] // } 2F2D 5B JUMPDEST 2F2E 80 DUP1 2F2F 91 SWAP2 2F30 50 POP 2F31 50 POP 2F32 5B JUMPDEST 2F33 92 SWAP3 2F34 91 SWAP2 2F35 50 POP 2F36 50 POP 2F37 56 *JUMP // Stack delta = -4 // Outputs[1] { @2F33 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_2F38: // Incoming call from 0x20DF, returns to 0x20E0 // Incoming call from 0x21F9, returns to 0x21FA // Inputs[3] // { // @2F3C stack[-2] // @2F3D stack[-1] // @2F40 memory[0x40:0x60] // } 2F38 5B JUMPDEST 2F39 61 PUSH2 0x2f52 2F3C 82 DUP3 2F3D 82 DUP3 2F3E 60 PUSH1 0x40 2F40 51 MLOAD 2F41 80 DUP1 2F42 60 PUSH1 0x20 2F44 01 ADD 2F45 60 PUSH1 0x40 2F47 52 MSTORE 2F48 80 DUP1 2F49 60 PUSH1 0x00 2F4B 81 DUP2 2F4C 52 MSTORE 2F4D 50 POP 2F4E 61 PUSH2 0x344e 2F51 56 *JUMP // Stack delta = +4 // Outputs[6] // { // @2F39 stack[0] = 0x2f52 // @2F3C stack[1] = stack[-2] // @2F3D stack[2] = stack[-1] // @2F40 stack[3] = memory[0x40:0x60] // @2F47 memory[0x40:0x60] = 0x20 + memory[0x40:0x60] // @2F4C memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x00 // } // Block ends with call to 0x344e, returns to 0x2F52 label_2F52: // Incoming return from call to 0x344E at 0x2F51 // Inputs[1] { @2F55 stack[-3] } 2F52 5B JUMPDEST 2F53 50 POP 2F54 50 POP 2F55 56 *JUMP // Stack delta = -3 // Block ends with unconditional jump to stack[-3] label_2F56: // Incoming call from 0x227C, returns to 0x227D // Inputs[3] // { // @2F5A stack[-4] // @2F5B stack[-3] // @2F5C stack[-2] // } 2F56 5B JUMPDEST 2F57 61 PUSH2 0x2f61 2F5A 84 DUP5 2F5B 84 DUP5 2F5C 84 DUP5 2F5D 61 PUSH2 0x2b53 2F60 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @2F57 stack[0] = 0x2f61 // @2F5A stack[1] = stack[-4] // @2F5B stack[2] = stack[-3] // @2F5C stack[3] = stack[-2] // } // Block ends with call to 0x2b53, returns to 0x2F61 label_2F61: // Incoming return from call to 0x2B53 at 0x2F60 // Inputs[4] // { // @2F65 stack[-4] // @2F66 stack[-3] // @2F67 stack[-2] // @2F68 stack[-1] // } 2F61 5B JUMPDEST 2F62 61 PUSH2 0x2f6d 2F65 84 DUP5 2F66 84 DUP5 2F67 84 DUP5 2F68 84 DUP5 2F69 61 PUSH2 0x34bf 2F6C 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @2F62 stack[0] = 0x2f6d // @2F65 stack[1] = stack[-4] // @2F66 stack[2] = stack[-3] // @2F67 stack[3] = stack[-2] // @2F68 stack[4] = stack[-1] // } // Block ends with call to 0x34bf, returns to 0x2F6D label_2F6D: // Incoming return from call to 0x34BF at 0x2F6C // Inputs[1] { @2F71 stack[-1] } 2F6D 5B JUMPDEST 2F6E 61 PUSH2 0x2fc2 2F71 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x2fc2, if stack[-1] label_2F72: // Incoming jump from 0x2F71, if not stack[-1] // Inputs[3] // { // @2F74 memory[0x40:0x60] // @2FBC memory[0x40:0x60] // @2FC1 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 2F72 60 PUSH1 0x40 2F74 51 MLOAD 2F75 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 2F96 81 DUP2 2F97 52 MSTORE 2F98 60 PUSH1 0x04 2F9A 01 ADD 2F9B 80 DUP1 2F9C 80 DUP1 2F9D 60 PUSH1 0x20 2F9F 01 ADD 2FA0 82 DUP3 2FA1 81 DUP2 2FA2 03 SUB 2FA3 82 DUP3 2FA4 52 MSTORE 2FA5 60 PUSH1 0x32 2FA7 81 DUP2 2FA8 52 MSTORE 2FA9 60 PUSH1 0x20 2FAB 01 ADD 2FAC 80 DUP1 2FAD 61 PUSH2 0x3ea6 2FB0 60 PUSH1 0x32 2FB2 91 SWAP2 2FB3 39 CODECOPY 2FB4 60 PUSH1 0x40 2FB6 01 ADD 2FB7 91 SWAP2 2FB8 50 POP 2FB9 50 POP 2FBA 60 PUSH1 0x40 2FBC 51 MLOAD 2FBD 80 DUP1 2FBE 91 SWAP2 2FBF 03 SUB 2FC0 90 SWAP1 2FC1 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @2F97 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @2FA4 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @2FA8 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x32 // @2FB3 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x32] = code[0x3ea6:0x3ed8] // @2FC1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_2FC2: // Incoming jump from 0x2F71, if stack[-1] // Inputs[1] { @2FC7 stack[-5] } 2FC2 5B JUMPDEST 2FC3 50 POP 2FC4 50 POP 2FC5 50 POP 2FC6 50 POP 2FC7 56 *JUMP // Stack delta = -5 // Block ends with unconditional jump to stack[-5] label_2FC8: // Incoming call from 0x2493, returns to 0x2494 // Inputs[1] { @2FCD stack[-1] } 2FC8 5B JUMPDEST 2FC9 60 PUSH1 0x60 2FCB 60 PUSH1 0x00 2FCD 82 DUP3 2FCE 14 EQ 2FCF 15 ISZERO 2FD0 61 PUSH2 0x3010 2FD3 57 *JUMPI // Stack delta = +1 // Outputs[1] { @2FC9 stack[0] = 0x60 } // Block ends with conditional jump to 0x3010, if !(stack[-1] == 0x00) label_2FD4: // Incoming jump from 0x2FD3, if not !(stack[-1] == 0x00) // Inputs[2] // { // @2FD6 memory[0x40:0x60] // @300A stack[-1] // } 2FD4 60 PUSH1 0x40 2FD6 51 MLOAD 2FD7 80 DUP1 2FD8 60 PUSH1 0x40 2FDA 01 ADD 2FDB 60 PUSH1 0x40 2FDD 52 MSTORE 2FDE 80 DUP1 2FDF 60 PUSH1 0x01 2FE1 81 DUP2 2FE2 52 MSTORE 2FE3 60 PUSH1 0x20 2FE5 01 ADD 2FE6 7F PUSH32 0x3000000000000000000000000000000000000000000000000000000000000000 3007 81 DUP2 3008 52 MSTORE 3009 50 POP 300A 90 SWAP1 300B 50 POP 300C 61 PUSH2 0x310a 300F 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @2FDD memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @2FE2 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x01 // @3008 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = 0x3000000000000000000000000000000000000000000000000000000000000000 // @300A stack[-1] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0x310a label_3010: // Incoming jump from 0x2FD3, if !(stack[-1] == 0x00) // Inputs[1] { @3013 stack[-2] } 3010 5B JUMPDEST 3011 60 PUSH1 0x00 3013 82 DUP3 3014 90 SWAP1 3015 50 POP 3016 60 PUSH1 0x00 3018 5B JUMPDEST 3019 60 PUSH1 0x00 301B 82 DUP3 301C 14 EQ 301D 61 PUSH2 0x303a 3020 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3014 stack[0] = stack[-2] // @3016 stack[1] = 0x00 // } // Block ends with conditional jump to 0x303a, if stack[-2] == 0x00 label_3021: // Incoming jump from 0x3020, if not stack[-2] == 0x00 // Incoming jump from 0x3020, if not stack[-2] == 0x00 // Inputs[2] // { // @3021 stack[-1] // @302B stack[-2] // } 3021 80 DUP1 3022 80 DUP1 3023 60 PUSH1 0x01 3025 01 ADD 3026 91 SWAP2 3027 50 POP 3028 50 POP 3029 60 PUSH1 0x0a 302B 82 DUP3 302C 81 DUP2 302D 61 PUSH2 0x3032 3030 57 *JUMPI // Stack delta = +2 // Outputs[3] // { // @3026 stack[-1] = 0x01 + stack[-1] // @3029 stack[0] = 0x0a // @302B stack[1] = stack[-2] // } // Block ends with conditional jump to 0x3032, if 0x0a label_3031: // Incoming jump from 0x3030, if not 0x0a 3031 FE *ASSERT // Stack delta = +0 // Outputs[1] { @3031 assert(); } // Block terminates label_3032: // Incoming jump from 0x3030, if 0x0a // Inputs[3] // { // @3033 stack[-2] // @3033 stack[-1] // @3034 stack[-4] // } 3032 5B JUMPDEST 3033 04 DIV 3034 91 SWAP2 3035 50 POP 3036 61 PUSH2 0x3018 3039 56 *JUMP // Stack delta = -2 // Outputs[1] { @3034 stack[-4] = stack[-1] / stack[-2] } // Block ends with unconditional jump to 0x3018 label_303A: // Incoming jump from 0x3020, if stack[-2] == 0x00 // Incoming jump from 0x3020, if stack[-2] == 0x00 // Inputs[1] { @303D stack[-1] } 303A 5B JUMPDEST 303B 60 PUSH1 0x60 303D 81 DUP2 303E 67 PUSH8 0xffffffffffffffff 3047 81 DUP2 3048 11 GT 3049 80 DUP1 304A 15 ISZERO 304B 61 PUSH2 0x3053 304E 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @303B stack[0] = 0x60 // @303D stack[1] = stack[-1] // @3048 stack[2] = stack[-1] > 0xffffffffffffffff // } // Block ends with conditional jump to 0x3053, if !(stack[-1] > 0xffffffffffffffff) label_304F: // Incoming jump from 0x304E, if not !(stack[-1] > 0xffffffffffffffff) // Inputs[1] { @3052 memory[0x00:0x00] } 304F 60 PUSH1 0x00 3051 80 DUP1 3052 FD *REVERT // Stack delta = +0 // Outputs[1] { @3052 revert(memory[0x00:0x00]); } // Block terminates label_3053: // Incoming jump from 0x304E, if !(stack[-1] > 0xffffffffffffffff) // Inputs[2] // { // @3057 memory[0x40:0x60] // @3058 stack[-2] // } 3053 5B JUMPDEST 3054 50 POP 3055 60 PUSH1 0x40 3057 51 MLOAD 3058 90 SWAP1 3059 80 DUP1 305A 82 DUP3 305B 52 MSTORE 305C 80 DUP1 305D 60 PUSH1 0x1f 305F 01 ADD 3060 60 PUSH1 0x1f 3062 19 NOT 3063 16 AND 3064 60 PUSH1 0x20 3066 01 ADD 3067 82 DUP3 3068 01 ADD 3069 60 PUSH1 0x40 306B 52 MSTORE 306C 80 DUP1 306D 15 ISZERO 306E 61 PUSH2 0x3086 3071 57 *JUMPI // Stack delta = +0 // Outputs[4] // { // @3058 stack[-2] = memory[0x40:0x60] // @3058 stack[-1] = stack[-2] // @305B memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-2] // @306B memory[0x40:0x60] = memory[0x40:0x60] + 0x20 + (~0x1f & 0x1f + stack[-2]) // } // Block ends with conditional jump to 0x3086, if !stack[-2] label_3072: // Incoming jump from 0x3071, if not !stack[-2] // Inputs[8] // { // @3072 stack[-2] // @3078 stack[-1] // @307B msg.data.length // @307D msg.data[msg.data.length:msg.data.length + stack[-1] * 0x01] // @3088 stack[-3] // @308E stack[-4] // @3092 stack[-7] // @3093 stack[-5] // } 3072 81 DUP2 3073 60 PUSH1 0x20 3075 01 ADD 3076 60 PUSH1 0x01 3078 82 DUP3 3079 02 MUL 307A 80 DUP1 307B 36 CALLDATASIZE 307C 83 DUP4 307D 37 CALLDATACOPY 307E 80 DUP1 307F 82 DUP3 3080 01 ADD 3081 91 SWAP2 3082 50 POP 3083 50 POP 3084 90 SWAP1 3085 50 POP 3086 5B JUMPDEST 3087 50 POP 3088 90 SWAP1 3089 50 POP 308A 60 PUSH1 0x00 308C 60 PUSH1 0x01 308E 83 DUP4 308F 03 SUB 3090 90 SWAP1 3091 50 POP 3092 85 DUP6 3093 93 SWAP4 3094 50 POP 3095 5B JUMPDEST 3096 60 PUSH1 0x00 3098 84 DUP5 3099 14 EQ 309A 61 PUSH2 0x3102 309D 57 *JUMPI // Stack delta = -1 // Outputs[4] // { // @307D memory[0x20 + stack[-2]:0x20 + stack[-2] + stack[-1] * 0x01] = msg.data[msg.data.length:msg.data.length + stack[-1] * 0x01] // @3088 stack[-3] = stack[-2] // @3090 stack[-2] = stack[-4] - 0x01 // @3093 stack[-5] = stack[-7] // } // Block ends with conditional jump to 0x3102, if stack[-7] == 0x00 label_309E: // Incoming jump from 0x309D, if not stack[-4] == 0x00 // Incoming jump from 0x309D, if not stack[-7] == 0x00 // Incoming jump from 0x309D, if not stack[-7] == 0x00 // Inputs[1] { @30A0 stack[-4] } 309E 60 PUSH1 0x0a 30A0 84 DUP5 30A1 81 DUP2 30A2 61 PUSH2 0x30a7 30A5 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @309E stack[0] = 0x0a // @30A0 stack[1] = stack[-4] // } // Block ends with conditional jump to 0x30a7, if 0x0a label_30A6: // Incoming jump from 0x30A5, if not 0x0a 30A6 FE *ASSERT // Stack delta = +0 // Outputs[1] { @30A6 assert(); } // Block terminates label_30A7: // Incoming jump from 0x30A5, if 0x0a // Inputs[5] // { // @30A8 stack[-2] // @30A8 stack[-1] // @30AF stack[-4] // @30B0 stack[-3] // @30B9 memory[stack[-4]:stack[-4] + 0x20] // } 30A7 5B JUMPDEST 30A8 06 MOD 30A9 60 PUSH1 0x30 30AB 01 ADD 30AC 60 PUSH1 0xf8 30AE 1B SHL 30AF 82 DUP3 30B0 82 DUP3 30B1 80 DUP1 30B2 60 PUSH1 0x01 30B4 90 SWAP1 30B5 03 SUB 30B6 93 SWAP4 30B7 50 POP 30B8 81 DUP2 30B9 51 MLOAD 30BA 81 DUP2 30BB 10 LT 30BC 61 PUSH2 0x30c1 30BF 57 *JUMPI // Stack delta = +1 // Outputs[4] // { // @30AE stack[-2] = 0x30 + stack[-1] % stack[-2] << 0xf8 // @30AF stack[-1] = stack[-4] // @30B0 stack[0] = stack[-3] // @30B6 stack[-3] = stack[-3] - 0x01 // } // Block ends with conditional jump to 0x30c1, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] label_30C0: // Incoming jump from 0x30BF, if not stack[-3] < memory[stack[-4]:stack[-4] + 0x20] 30C0 FE *ASSERT // Stack delta = +0 // Outputs[1] { @30C0 assert(); } // Block terminates label_30C1: // Incoming jump from 0x30BF, if stack[-3] < memory[stack[-4]:stack[-4] + 0x20] // Inputs[4] // { // @30C4 stack[-1] // @30C5 stack[-2] // @30C6 stack[-3] // @30F3 stack[-7] // } 30C1 5B JUMPDEST 30C2 60 PUSH1 0x20 30C4 01 ADD 30C5 01 ADD 30C6 90 SWAP1 30C7 7E PUSH31 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff 30E7 19 NOT 30E8 16 AND 30E9 90 SWAP1 30EA 81 DUP2 30EB 60 PUSH1 0x00 30ED 1A BYTE 30EE 90 SWAP1 30EF 53 MSTORE8 30F0 50 POP 30F1 60 PUSH1 0x0a 30F3 84 DUP5 30F4 81 DUP2 30F5 61 PUSH2 0x30fa 30F8 57 *JUMPI // Stack delta = -1 // Outputs[3] // { // @30EF memory[0x20 + stack[-1] + stack[-2]:0x20 + stack[-1] + stack[-2] + 0x01] = byte(~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-3], 0x00) // @30F1 stack[-3] = 0x0a // @30F3 stack[-2] = stack[-7] // } // Block ends with conditional jump to 0x30fa, if 0x0a label_30F9: // Incoming jump from 0x30F8, if not 0x0a 30F9 FE *ASSERT // Stack delta = +0 // Outputs[1] { @30F9 assert(); } // Block terminates label_30FA: // Incoming jump from 0x30F8, if 0x0a // Inputs[3] // { // @30FB stack[-2] // @30FB stack[-1] // @30FC stack[-6] // } 30FA 5B JUMPDEST 30FB 04 DIV 30FC 93 SWAP4 30FD 50 POP 30FE 61 PUSH2 0x3095 3101 56 *JUMP // Stack delta = -2 // Outputs[1] { @30FC stack[-6] = stack[-1] / stack[-2] } // Block ends with unconditional jump to 0x3095 label_3102: // Incoming jump from 0x309D, if stack[-4] == 0x00 // Incoming jump from 0x309D, if stack[-7] == 0x00 // Incoming jump from 0x309D, if stack[-7] == 0x00 // Inputs[2] // { // @3103 stack[-2] // @3104 stack[-5] // } 3102 5B JUMPDEST 3103 81 DUP2 3104 94 SWAP5 3105 50 POP 3106 50 POP 3107 50 POP 3108 50 POP 3109 50 POP // Stack delta = -4 // Outputs[1] { @3104 stack[-5] = stack[-2] } // Block continues label_310A: // Incoming jump from 0x3109 // Incoming jump from 0x300F // Inputs[3] // { // @310B stack[-1] // @310B stack[-3] // @310C stack[-2] // } 310A 5B JUMPDEST 310B 91 SWAP2 310C 90 SWAP1 310D 50 POP 310E 56 *JUMP // Stack delta = -2 // Outputs[1] { @310B stack[-3] = stack[-1] } // Block ends with unconditional jump to stack[-3] label_310F: // Incoming call from 0x2719, returns to 0x271A // Inputs[2] // { // @3112 stack[-2] // @3113 stack[-1] // } 310F 5B JUMPDEST 3110 60 PUSH1 0x00 3112 82 DUP3 3113 82 DUP3 3114 11 GT 3115 15 ISZERO 3116 61 PUSH2 0x3187 3119 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3110 stack[0] = 0x00 } // Block ends with conditional jump to 0x3187, if !(stack[-1] > stack[-2]) label_311A: // Incoming jump from 0x3119, if not !(stack[-1] > stack[-2]) // Inputs[3] // { // @311C memory[0x40:0x60] // @3181 memory[0x40:0x60] // @3186 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 311A 60 PUSH1 0x40 311C 51 MLOAD 311D 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 313E 81 DUP2 313F 52 MSTORE 3140 60 PUSH1 0x04 3142 01 ADD 3143 80 DUP1 3144 80 DUP1 3145 60 PUSH1 0x20 3147 01 ADD 3148 82 DUP3 3149 81 DUP2 314A 03 SUB 314B 82 DUP3 314C 52 MSTORE 314D 60 PUSH1 0x1e 314F 81 DUP2 3150 52 MSTORE 3151 60 PUSH1 0x20 3153 01 ADD 3154 80 DUP1 3155 7F PUSH32 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000 3176 81 DUP2 3177 52 MSTORE 3178 50 POP 3179 60 PUSH1 0x20 317B 01 ADD 317C 91 SWAP2 317D 50 POP 317E 50 POP 317F 60 PUSH1 0x40 3181 51 MLOAD 3182 80 DUP1 3183 91 SWAP2 3184 03 SUB 3185 90 SWAP1 3186 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @313F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @314C memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @3150 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x1e // @3177 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x536166654d6174683a207375627472616374696f6e206f766572666c6f770000 // @3186 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_3187: // Incoming jump from 0x3119, if !(stack[-1] > stack[-2]) // Inputs[4] // { // @3188 stack[-2] // @3189 stack[-3] // @318B stack[-1] // @318D stack[-4] // } 3187 5B JUMPDEST 3188 81 DUP2 3189 83 DUP4 318A 03 SUB 318B 90 SWAP1 318C 50 POP 318D 92 SWAP3 318E 91 SWAP2 318F 50 POP 3190 50 POP 3191 56 *JUMP // Stack delta = -3 // Outputs[1] { @318D stack[-4] = stack[-3] - stack[-2] } // Block ends with unconditional jump to stack[-4] label_3192: // Incoming call from 0x2989, returns to 0x298A // Inputs[2] // { // @3198 stack[-2] // @319C stack[-1] // } 3192 5B JUMPDEST 3193 60 PUSH1 0x00 3195 61 PUSH2 0x31a4 3198 83 DUP4 3199 60 PUSH1 0x00 319B 01 ADD 319C 83 DUP4 319D 60 PUSH1 0x00 319F 1B SHL 31A0 61 PUSH2 0x36d8 31A3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3193 stack[0] = 0x00 // @3195 stack[1] = 0x31a4 // @319B stack[2] = 0x00 + stack[-2] // @319F stack[3] = stack[-1] << 0x00 // } // Block ends with call to 0x36d8, returns to 0x31A4 label_31A4: // Incoming return from call to 0x36D8 at 0x31A3 // Inputs[4] // { // @31A5 stack[-2] // @31A5 stack[-1] // @31A7 stack[-5] // @31A8 stack[-4] // } 31A4 5B JUMPDEST 31A5 90 SWAP1 31A6 50 POP 31A7 92 SWAP3 31A8 91 SWAP2 31A9 50 POP 31AA 50 POP 31AB 56 *JUMP // Stack delta = -4 // Outputs[1] { @31A7 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_31AC: // Incoming call from 0x2A57, returns to 0x2A58 // Inputs[3] // { // @31AF stack[-1] // @31B4 storage[0x00 + stack[-1]] // @31B9 stack[-2] // } 31AC 5B JUMPDEST 31AD 60 PUSH1 0x00 31AF 81 DUP2 31B0 60 PUSH1 0x00 31B2 01 ADD 31B3 80 DUP1 31B4 54 SLOAD 31B5 90 SWAP1 31B6 50 POP 31B7 90 SWAP1 31B8 50 POP 31B9 91 SWAP2 31BA 90 SWAP1 31BB 50 POP 31BC 56 *JUMP // Stack delta = -1 // Outputs[1] { @31B9 stack[-2] = storage[0x00 + stack[-1]] } // Block ends with unconditional jump to stack[-2] label_31BD: // Incoming call from 0x2C6F, returns to 0x2C70 // Incoming call from 0x3A59, returns to 0x3A5A // Inputs[1] { @31C1 stack[-4] } 31BD 5B JUMPDEST 31BE 50 POP 31BF 50 POP 31C0 50 POP 31C1 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_31C2: // Incoming call from 0x2CCB, returns to 0x2CCC // Inputs[2] // { // @31C8 stack[-2] // @31CC stack[-1] // } 31C2 5B JUMPDEST 31C3 60 PUSH1 0x00 31C5 61 PUSH2 0x31d4 31C8 83 DUP4 31C9 60 PUSH1 0x00 31CB 01 ADD 31CC 83 DUP4 31CD 60 PUSH1 0x00 31CF 1B SHL 31D0 61 PUSH2 0x36fb 31D3 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @31C3 stack[0] = 0x00 // @31C5 stack[1] = 0x31d4 // @31CB stack[2] = 0x00 + stack[-2] // @31CF stack[3] = stack[-1] << 0x00 // } // Block ends with call to 0x36fb, returns to 0x31D4 label_31D4: // Incoming return from call to 0x36FB at 0x31D3 // Inputs[4] // { // @31D5 stack[-1] // @31D5 stack[-2] // @31D7 stack[-5] // @31D8 stack[-4] // } 31D4 5B JUMPDEST 31D5 90 SWAP1 31D6 50 POP 31D7 92 SWAP3 31D8 91 SWAP2 31D9 50 POP 31DA 50 POP 31DB 56 *JUMP // Stack delta = -4 // Outputs[1] { @31D7 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_31DC: // Incoming call from 0x2D1D, returns to 0x2D1E // Incoming call from 0x3AAA, returns to 0x3AAB // Inputs[2] // { // @31E2 stack[-2] // @31E6 stack[-1] // } 31DC 5B JUMPDEST 31DD 60 PUSH1 0x00 31DF 61 PUSH2 0x31ee 31E2 83 DUP4 31E3 60 PUSH1 0x00 31E5 01 ADD 31E6 83 DUP4 31E7 60 PUSH1 0x00 31E9 1B SHL 31EA 61 PUSH2 0x37e3 31ED 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @31DD stack[0] = 0x00 // @31DF stack[1] = 0x31ee // @31E5 stack[2] = 0x00 + stack[-2] // @31E9 stack[3] = stack[-1] << 0x00 // } // Block ends with call to 0x37e3, returns to 0x31EE label_31EE: // Incoming return from call to 0x37E3 at 0x31ED // Inputs[4] // { // @31EF stack[-2] // @31EF stack[-1] // @31F1 stack[-5] // @31F2 stack[-4] // } 31EE 5B JUMPDEST 31EF 90 SWAP1 31F0 50 POP 31F1 92 SWAP3 31F2 91 SWAP2 31F3 50 POP 31F4 50 POP 31F5 56 *JUMP // Stack delta = -4 // Outputs[1] { @31F1 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_31F6: // Incoming call from 0x3AC1, returns to 0x3AC2 // Incoming call from 0x2D34, returns to 0x2D35 // Inputs[3] // { // @31FC stack[-3] // @3200 stack[-2] // @3204 stack[-1] // } 31F6 5B JUMPDEST 31F7 60 PUSH1 0x00 31F9 61 PUSH2 0x3222 31FC 84 DUP5 31FD 60 PUSH1 0x00 31FF 01 ADD 3200 84 DUP5 3201 60 PUSH1 0x00 3203 1B SHL 3204 84 DUP5 3205 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 321A 16 AND 321B 60 PUSH1 0x00 321D 1B SHL 321E 61 PUSH2 0x3853 3221 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @31F7 stack[0] = 0x00 // @31F9 stack[1] = 0x3222 // @31FF stack[2] = 0x00 + stack[-3] // @3203 stack[3] = stack[-2] << 0x00 // @321D stack[4] = (0xffffffffffffffffffffffffffffffffffffffff & stack[-1]) << 0x00 // } // Block ends with call to 0x3853, returns to 0x3222 label_3222: // Incoming return from call to 0x3853 at 0x3221 // Inputs[4] // { // @3223 stack[-1] // @3223 stack[-2] // @3225 stack[-6] // @3226 stack[-5] // } 3222 5B JUMPDEST 3223 90 SWAP1 3224 50 POP 3225 93 SWAP4 3226 92 SWAP3 3227 50 POP 3228 50 POP 3229 50 POP 322A 56 *JUMP // Stack delta = -5 // Outputs[1] { @3225 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_322B: // Incoming call from 0x2DA4, returns to 0x2DA5 // Inputs[3] // { // @322E stack[-1] // @322F stack[-2] // @3234 storage[0x00 + stack[-2]] // } 322B 5B JUMPDEST 322C 60 PUSH1 0x00 322E 81 DUP2 322F 83 DUP4 3230 60 PUSH1 0x00 3232 01 ADD 3233 80 DUP1 3234 54 SLOAD 3235 90 SWAP1 3236 50 POP 3237 11 GT 3238 61 PUSH2 0x328c 323B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @322C stack[0] = 0x00 } // Block ends with conditional jump to 0x328c, if storage[0x00 + stack[-2]] > stack[-1] label_323C: // Incoming jump from 0x323B, if not storage[0x00 + stack[-2]] > stack[-1] // Inputs[3] // { // @323E memory[0x40:0x60] // @3286 memory[0x40:0x60] // @328B memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 323C 60 PUSH1 0x40 323E 51 MLOAD 323F 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 3260 81 DUP2 3261 52 MSTORE 3262 60 PUSH1 0x04 3264 01 ADD 3265 80 DUP1 3266 80 DUP1 3267 60 PUSH1 0x20 3269 01 ADD 326A 82 DUP3 326B 81 DUP2 326C 03 SUB 326D 82 DUP3 326E 52 MSTORE 326F 60 PUSH1 0x22 3271 81 DUP2 3272 52 MSTORE 3273 60 PUSH1 0x20 3275 01 ADD 3276 80 DUP1 3277 61 PUSH2 0x3e84 327A 60 PUSH1 0x22 327C 91 SWAP2 327D 39 CODECOPY 327E 60 PUSH1 0x40 3280 01 ADD 3281 91 SWAP2 3282 50 POP 3283 50 POP 3284 60 PUSH1 0x40 3286 51 MLOAD 3287 80 DUP1 3288 91 SWAP2 3289 03 SUB 328A 90 SWAP1 328B FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3261 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @326E memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @3272 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x22 // @327D memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x22] = code[0x3e84:0x3ea6] // @328B revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_328C: // Incoming jump from 0x323B, if storage[0x00 + stack[-2]] > stack[-1] // Inputs[3] // { // @328D stack[-3] // @3291 stack[-2] // @3293 storage[0x00 + stack[-3]] // } 328C 5B JUMPDEST 328D 82 DUP3 328E 60 PUSH1 0x00 3290 01 ADD 3291 82 DUP3 3292 81 DUP2 3293 54 SLOAD 3294 81 DUP2 3295 10 LT 3296 61 PUSH2 0x329b 3299 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @3290 stack[0] = 0x00 + stack[-3] // @3291 stack[1] = stack[-2] // } // Block ends with conditional jump to 0x329b, if stack[-2] < storage[0x00 + stack[-3]] label_329A: // Incoming jump from 0x3299, if not stack[-2] < storage[0x00 + stack[-3]] 329A FE *ASSERT // Stack delta = +0 // Outputs[1] { @329A assert(); } // Block terminates label_329B: // Incoming jump from 0x3299, if stack[-2] < storage[0x00 + stack[-3]] // Inputs[7] // { // @329C stack[-2] // @329C stack[-1] // @32A4 memory[0x00:0x20] // @32A6 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @32A7 stack[-3] // @32A9 stack[-6] // @32AA stack[-5] // } 329B 5B JUMPDEST 329C 90 SWAP1 329D 60 PUSH1 0x00 329F 52 MSTORE 32A0 60 PUSH1 0x20 32A2 60 PUSH1 0x00 32A4 20 SHA3 32A5 01 ADD 32A6 54 SLOAD 32A7 90 SWAP1 32A8 50 POP 32A9 92 SWAP3 32AA 91 SWAP2 32AB 50 POP 32AC 50 POP 32AD 56 *JUMP // Stack delta = -5 // Outputs[2] // { // @329F memory[0x00:0x20] = stack[-2] // @32A9 stack[-6] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // } // Block ends with unconditional jump to stack[-6] label_32AE: // Incoming call from 0x2DC2, returns to 0x2DC3 // Inputs[3] // { // @32B2 stack[-1] // @32B3 stack[-2] // @32B8 storage[0x00 + stack[-2]] // } 32AE 5B JUMPDEST 32AF 60 PUSH1 0x00 32B1 80 DUP1 32B2 82 DUP3 32B3 84 DUP5 32B4 60 PUSH1 0x00 32B6 01 ADD 32B7 80 DUP1 32B8 54 SLOAD 32B9 90 SWAP1 32BA 50 POP 32BB 11 GT 32BC 61 PUSH2 0x3310 32BF 57 *JUMPI // Stack delta = +2 // Outputs[2] // { // @32AF stack[0] = 0x00 // @32B1 stack[1] = 0x00 // } // Block ends with conditional jump to 0x3310, if storage[0x00 + stack[-2]] > stack[-1] label_32C0: // Incoming jump from 0x32BF, if not storage[0x00 + stack[-2]] > stack[-1] // Inputs[3] // { // @32C2 memory[0x40:0x60] // @330A memory[0x40:0x60] // @330F memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 32C0 60 PUSH1 0x40 32C2 51 MLOAD 32C3 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 32E4 81 DUP2 32E5 52 MSTORE 32E6 60 PUSH1 0x04 32E8 01 ADD 32E9 80 DUP1 32EA 80 DUP1 32EB 60 PUSH1 0x20 32ED 01 ADD 32EE 82 DUP3 32EF 81 DUP2 32F0 03 SUB 32F1 82 DUP3 32F2 52 MSTORE 32F3 60 PUSH1 0x22 32F5 81 DUP2 32F6 52 MSTORE 32F7 60 PUSH1 0x20 32F9 01 ADD 32FA 80 DUP1 32FB 61 PUSH2 0x4020 32FE 60 PUSH1 0x22 3300 91 SWAP2 3301 39 CODECOPY 3302 60 PUSH1 0x40 3304 01 ADD 3305 91 SWAP2 3306 50 POP 3307 50 POP 3308 60 PUSH1 0x40 330A 51 MLOAD 330B 80 DUP1 330C 91 SWAP2 330D 03 SUB 330E 90 SWAP1 330F FD *REVERT // Stack delta = +0 // Outputs[5] // { // @32E5 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @32F2 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @32F6 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x22 // @3301 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x22] = code[0x4020:0x4042] // @330F revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_3310: // Incoming jump from 0x32BF, if storage[0x00 + stack[-2]] > stack[-1] // Inputs[3] // { // @3313 stack[-4] // @3317 stack[-3] // @3319 storage[0x00 + stack[-4]] // } 3310 5B JUMPDEST 3311 60 PUSH1 0x00 3313 84 DUP5 3314 60 PUSH1 0x00 3316 01 ADD 3317 84 DUP5 3318 81 DUP2 3319 54 SLOAD 331A 81 DUP2 331B 10 LT 331C 61 PUSH2 0x3321 331F 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @3311 stack[0] = 0x00 // @3316 stack[1] = 0x00 + stack[-4] // @3317 stack[2] = stack[-3] // } // Block ends with conditional jump to 0x3321, if stack[-3] < storage[0x00 + stack[-4]] label_3320: // Incoming jump from 0x331F, if not stack[-3] < storage[0x00 + stack[-4]] 3320 FE *ASSERT // Stack delta = +0 // Outputs[1] { @3320 assert(); } // Block terminates label_3321: // Incoming jump from 0x331F, if stack[-3] < storage[0x00 + stack[-4]] // Inputs[11] // { // @3322 stack[-2] // @3322 stack[-1] // @332A memory[0x00:0x20] // @3330 stack[-3] // @3336 storage[0x00 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // @333B storage[0x01 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // @333C stack[-4] // @333E stack[-5] // @3341 stack[-7] // @3343 stack[-8] // @3344 stack[-6] // } 3321 5B JUMPDEST 3322 90 SWAP1 3323 60 PUSH1 0x00 3325 52 MSTORE 3326 60 PUSH1 0x20 3328 60 PUSH1 0x00 332A 20 SHA3 332B 90 SWAP1 332C 60 PUSH1 0x02 332E 02 MUL 332F 01 ADD 3330 90 SWAP1 3331 50 POP 3332 80 DUP1 3333 60 PUSH1 0x00 3335 01 ADD 3336 54 SLOAD 3337 81 DUP2 3338 60 PUSH1 0x01 333A 01 ADD 333B 54 SLOAD 333C 92 SWAP3 333D 50 POP 333E 92 SWAP3 333F 50 POP 3340 50 POP 3341 92 SWAP3 3342 50 POP 3343 92 SWAP3 3344 90 SWAP1 3345 50 POP 3346 56 *JUMP // Stack delta = -6 // Outputs[3] // { // @3325 memory[0x00:0x20] = stack[-2] // @3341 stack[-7] = storage[0x01 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // @3343 stack[-8] = storage[0x00 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // } // Block ends with unconditional jump to stack[-8] label_3347: // Incoming call from 0x2E08, returns to 0x2E09 // Inputs[5] // { // @334B stack[-3] // @3351 stack[-2] // @335F memory[0x00:0x40] // @3360 storage[keccak256(memory[0x00:0x40])] // @3368 stack[-1] // } 3347 5B JUMPDEST 3348 60 PUSH1 0x00 334A 80 DUP1 334B 84 DUP5 334C 60 PUSH1 0x01 334E 01 ADD 334F 60 PUSH1 0x00 3351 85 DUP6 3352 81 DUP2 3353 52 MSTORE 3354 60 PUSH1 0x20 3356 01 ADD 3357 90 SWAP1 3358 81 DUP2 3359 52 MSTORE 335A 60 PUSH1 0x20 335C 01 ADD 335D 60 PUSH1 0x00 335F 20 SHA3 3360 54 SLOAD 3361 90 SWAP1 3362 50 POP 3363 60 PUSH1 0x00 3365 81 DUP2 3366 14 EQ 3367 15 ISZERO 3368 83 DUP4 3369 90 SWAP1 336A 61 PUSH2 0x340e 336D 57 *JUMPI // Stack delta = +3 // Outputs[5] // { // @3348 stack[0] = 0x00 // @3353 memory[0x00:0x20] = stack[-2] // @3359 memory[0x20:0x40] = 0x01 + stack[-3] // @3361 stack[1] = storage[keccak256(memory[0x00:0x40])] // @3369 stack[2] = stack[-1] // } // Block ends with conditional jump to 0x340e, if !(storage[keccak256(memory[0x00:0x40])] == 0x00) label_336E: // Incoming jump from 0x336D, if not !(storage[keccak256(memory[0x00:0x40])] == 0x00) // Inputs[4] // { // @3370 memory[0x40:0x60] // @33A1 stack[-1] // @33A4 memory[stack[-1]:stack[-1] + 0x20] // @33AD memory[stack[-1]:stack[-1] + 0x20] // } 336E 60 PUSH1 0x40 3370 51 MLOAD 3371 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 3392 81 DUP2 3393 52 MSTORE 3394 60 PUSH1 0x04 3396 01 ADD 3397 80 DUP1 3398 80 DUP1 3399 60 PUSH1 0x20 339B 01 ADD 339C 82 DUP3 339D 81 DUP2 339E 03 SUB 339F 82 DUP3 33A0 52 MSTORE 33A1 83 DUP4 33A2 81 DUP2 33A3 81 DUP2 33A4 51 MLOAD 33A5 81 DUP2 33A6 52 MSTORE 33A7 60 PUSH1 0x20 33A9 01 ADD 33AA 91 SWAP2 33AB 50 POP 33AC 80 DUP1 33AD 51 MLOAD 33AE 90 SWAP1 33AF 60 PUSH1 0x20 33B1 01 ADD 33B2 90 SWAP1 33B3 80 DUP1 33B4 83 DUP4 33B5 83 DUP4 33B6 60 PUSH1 0x00 33B8 5B JUMPDEST 33B9 83 DUP4 33BA 81 DUP2 33BB 10 LT 33BC 15 ISZERO 33BD 61 PUSH2 0x33d3 33C0 57 *JUMPI // Stack delta = +9 // Outputs[12] // { // @3393 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @3396 stack[0] = 0x04 + memory[0x40:0x60] // @3397 stack[1] = 0x04 + memory[0x40:0x60] // @33A0 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @33A6 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @33AA stack[2] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @33B2 stack[3] = 0x20 + stack[-1] // @33B2 stack[4] = memory[stack[-1]:stack[-1] + 0x20] // @33B3 stack[5] = memory[stack[-1]:stack[-1] + 0x20] // @33B4 stack[6] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @33B5 stack[7] = 0x20 + stack[-1] // @33B6 stack[8] = 0x00 // } // Block ends with conditional jump to 0x33d3, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) label_33C1: // Incoming jump from 0x33C0, if not !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x33C0, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @33C1 stack[-1] // @33C2 stack[-2] // @33C4 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @33C6 stack[-3] // } 33C1 80 DUP1 33C2 82 DUP3 33C3 01 ADD 33C4 51 MLOAD 33C5 81 DUP2 33C6 84 DUP5 33C7 01 ADD 33C8 52 MSTORE 33C9 60 PUSH1 0x20 33CB 81 DUP2 33CC 01 ADD 33CD 90 SWAP1 33CE 50 POP 33CF 61 PUSH2 0x33b8 33D2 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @33C8 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @33CD stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x33b8 label_33D3: // Incoming jump from 0x33C0, if !(0x00 < memory[stack[-1]:stack[-1] + 0x20]) // Incoming jump from 0x33C0, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @33D8 stack[-6] // @33D8 stack[-5] // @33DA stack[-7] // } 33D3 5B JUMPDEST 33D4 50 POP 33D5 50 POP 33D6 50 POP 33D7 50 POP 33D8 90 SWAP1 33D9 50 POP 33DA 90 SWAP1 33DB 81 DUP2 33DC 01 ADD 33DD 90 SWAP1 33DE 60 PUSH1 0x1f 33E0 16 AND 33E1 80 DUP1 33E2 15 ISZERO 33E3 61 PUSH2 0x3400 33E6 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @33DD stack[-7] = stack[-5] + stack[-7] // @33E0 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x3400, if !(0x1f & stack[-5]) label_33E7: // Incoming jump from 0x33E6, if not !(0x1f & stack[-5]) // Inputs[6] // { // @33E7 stack[-1] // @33E8 stack[-2] // @33EB memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @3402 stack[-5] // @3408 memory[0x40:0x60] // @340D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 33E7 80 DUP1 33E8 82 DUP3 33E9 03 SUB 33EA 80 DUP1 33EB 51 MLOAD 33EC 60 PUSH1 0x01 33EE 83 DUP4 33EF 60 PUSH1 0x20 33F1 03 SUB 33F2 61 PUSH2 0x0100 33F5 0A EXP 33F6 03 SUB 33F7 19 NOT 33F8 16 AND 33F9 81 DUP2 33FA 52 MSTORE 33FB 60 PUSH1 0x20 33FD 01 ADD 33FE 91 SWAP2 33FF 50 POP 3400 5B JUMPDEST 3401 50 POP 3402 92 SWAP3 3403 50 POP 3404 50 POP 3405 50 POP 3406 60 PUSH1 0x40 3408 51 MLOAD 3409 80 DUP1 340A 91 SWAP2 340B 03 SUB 340C 90 SWAP1 340D FD *REVERT // Stack delta = -5 // Outputs[2] // { // @33FA memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @340D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]); // } // Block terminates label_340E: // Incoming jump from 0x336D, if !(storage[keccak256(memory[0x00:0x40])] == 0x00) // Inputs[3] // { // @3410 stack[-6] // @3416 stack[-2] // @3419 storage[0x00 + stack[-6]] // } 340E 5B JUMPDEST 340F 50 POP 3410 84 DUP5 3411 60 PUSH1 0x00 3413 01 ADD 3414 60 PUSH1 0x01 3416 82 DUP3 3417 03 SUB 3418 81 DUP2 3419 54 SLOAD 341A 81 DUP2 341B 10 LT 341C 61 PUSH2 0x3421 341F 57 *JUMPI // Stack delta = +1 // Outputs[2] // { // @3413 stack[-1] = 0x00 + stack[-6] // @3417 stack[0] = stack[-2] - 0x01 // } // Block ends with conditional jump to 0x3421, if stack[-2] - 0x01 < storage[0x00 + stack[-6]] label_3420: // Incoming jump from 0x341F, if not stack[-2] - 0x01 < storage[0x00 + stack[-6]] 3420 FE *ASSERT // Stack delta = +0 // Outputs[1] { @3420 assert(); } // Block terminates label_3421: // Incoming jump from 0x341F, if stack[-2] - 0x01 < storage[0x00 + stack[-6]] // Inputs[7] // { // @3422 stack[-1] // @3422 stack[-2] // @342A memory[0x00:0x20] // @3433 storage[0x01 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // @3434 stack[-4] // @3437 stack[-8] // @3438 stack[-7] // } 3421 5B JUMPDEST 3422 90 SWAP1 3423 60 PUSH1 0x00 3425 52 MSTORE 3426 60 PUSH1 0x20 3428 60 PUSH1 0x00 342A 20 SHA3 342B 90 SWAP1 342C 60 PUSH1 0x02 342E 02 MUL 342F 01 ADD 3430 60 PUSH1 0x01 3432 01 ADD 3433 54 SLOAD 3434 91 SWAP2 3435 50 POP 3436 50 POP 3437 93 SWAP4 3438 92 SWAP3 3439 50 POP 343A 50 POP 343B 50 POP 343C 56 *JUMP // Stack delta = -7 // Outputs[2] // { // @3425 memory[0x00:0x20] = stack[-2] // @3437 stack[-8] = storage[0x01 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] // } // Block ends with unconditional jump to stack[-8] label_343D: // Incoming call from 0x2E22, returns to 0x2E23 // Inputs[3] // { // @3440 stack[-1] // @3445 storage[0x00 + stack[-1]] // @344A stack[-2] // } 343D 5B JUMPDEST 343E 60 PUSH1 0x00 3440 81 DUP2 3441 60 PUSH1 0x00 3443 01 ADD 3444 80 DUP1 3445 54 SLOAD 3446 90 SWAP1 3447 50 POP 3448 90 SWAP1 3449 50 POP 344A 91 SWAP2 344B 90 SWAP1 344C 50 POP 344D 56 *JUMP // Stack delta = -1 // Outputs[1] { @344A stack[-2] = storage[0x00 + stack[-1]] } // Block ends with unconditional jump to stack[-2] label_344E: // Incoming call from 0x2F51, returns to 0x2F52 // Inputs[2] // { // @3452 stack[-3] // @3453 stack[-2] // } 344E 5B JUMPDEST 344F 61 PUSH2 0x3458 3452 83 DUP4 3453 83 DUP4 3454 61 PUSH2 0x392f 3457 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @344F stack[0] = 0x3458 // @3452 stack[1] = stack[-3] // @3453 stack[2] = stack[-2] // } // Block ends with call to 0x392f, returns to 0x3458 label_3458: // Incoming return from call to 0x392F at 0x3457 // Inputs[3] // { // @345E stack[-3] // @345F stack[-2] // @3460 stack[-1] // } 3458 5B JUMPDEST 3459 61 PUSH2 0x3465 345C 60 PUSH1 0x00 345E 84 DUP5 345F 84 DUP5 3460 84 DUP5 3461 61 PUSH2 0x34bf 3464 56 *JUMP // Stack delta = +5 // Outputs[5] // { // @3459 stack[0] = 0x3465 // @345C stack[1] = 0x00 // @345E stack[2] = stack[-3] // @345F stack[3] = stack[-2] // @3460 stack[4] = stack[-1] // } // Block ends with call to 0x34bf, returns to 0x3465 label_3465: // Incoming return from call to 0x34BF at 0x3464 // Inputs[1] { @3469 stack[-1] } 3465 5B JUMPDEST 3466 61 PUSH2 0x34ba 3469 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x34ba, if stack[-1] label_346A: // Incoming jump from 0x3469, if not stack[-1] // Inputs[3] // { // @346C memory[0x40:0x60] // @34B4 memory[0x40:0x60] // @34B9 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 346A 60 PUSH1 0x40 346C 51 MLOAD 346D 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 348E 81 DUP2 348F 52 MSTORE 3490 60 PUSH1 0x04 3492 01 ADD 3493 80 DUP1 3494 80 DUP1 3495 60 PUSH1 0x20 3497 01 ADD 3498 82 DUP3 3499 81 DUP2 349A 03 SUB 349B 82 DUP3 349C 52 MSTORE 349D 60 PUSH1 0x32 349F 81 DUP2 34A0 52 MSTORE 34A1 60 PUSH1 0x20 34A3 01 ADD 34A4 80 DUP1 34A5 61 PUSH2 0x3ea6 34A8 60 PUSH1 0x32 34AA 91 SWAP2 34AB 39 CODECOPY 34AC 60 PUSH1 0x40 34AE 01 ADD 34AF 91 SWAP2 34B0 50 POP 34B1 50 POP 34B2 60 PUSH1 0x40 34B4 51 MLOAD 34B5 80 DUP1 34B6 91 SWAP2 34B7 03 SUB 34B8 90 SWAP1 34B9 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @348F memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @349C memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @34A0 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x32 // @34AB memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x32] = code[0x3ea6:0x3ed8] // @34B9 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_34BA: // Incoming jump from 0x3469, if stack[-1] // Inputs[1] { @34BE stack[-4] } 34BA 5B JUMPDEST 34BB 50 POP 34BC 50 POP 34BD 50 POP 34BE 56 *JUMP // Stack delta = -4 // Block ends with unconditional jump to stack[-4] label_34BF: // Incoming call from 0x2F6C, returns to 0x2F6D // Incoming call from 0x3464, returns to 0x3465 // Inputs[1] { @34C5 stack[-3] } 34BF 5B JUMPDEST 34C0 60 PUSH1 0x00 34C2 61 PUSH2 0x34e0 34C5 84 DUP5 34C6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 34DB 16 AND 34DC 61 PUSH2 0x3b23 34DF 56 *JUMP // Stack delta = +3 // Outputs[3] // { // @34C0 stack[0] = 0x00 // @34C2 stack[1] = 0x34e0 // @34DB stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-3] // } // Block ends with call to 0x3b23, returns to 0x34E0 label_34E0: // Incoming return from call to 0x3B23 at 0x34DF // Inputs[1] { @34E4 stack[-1] } 34E0 5B JUMPDEST 34E1 61 PUSH2 0x34ed 34E4 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x34ed, if stack[-1] label_34E5: // Incoming jump from 0x34E4, if not stack[-1] // Inputs[1] { @34E7 stack[-1] } 34E5 60 PUSH1 0x01 34E7 90 SWAP1 34E8 50 POP 34E9 61 PUSH2 0x36d0 34EC 56 *JUMP // Stack delta = +0 // Outputs[1] { @34E7 stack[-1] = 0x01 } // Block ends with unconditional jump to 0x36d0 label_34ED: // Incoming jump from 0x34E4, if stack[-1] 34ED 5B JUMPDEST 34EE 60 PUSH1 0x60 34F0 61 PUSH2 0x3657 34F3 63 PUSH4 0x150b7a02 34F8 60 PUSH1 0xe0 34FA 1B SHL 34FB 61 PUSH2 0x3502 34FE 61 PUSH2 0x296c 3501 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @34EE stack[0] = 0x60 // @34F0 stack[1] = 0x3657 // @34FA stack[2] = 0x150b7a02 << 0xe0 // @34FB stack[3] = 0x3502 // } // Block ends with call to 0x296c, returns to 0x3502 label_3502: // Incoming return from call to 0x296C at 0x3501 // Inputs[7] // { // @3503 stack[-9] // @3504 stack[-7] // @3505 stack[-6] // @3508 memory[0x40:0x60] // @350D stack[-1] // @3557 memory[stack[-6]:stack[-6] + 0x20] // @3560 memory[stack[-6]:stack[-6] + 0x20] // } 3502 5B JUMPDEST 3503 88 DUP9 3504 87 DUP8 3505 87 DUP8 3506 60 PUSH1 0x40 3508 51 MLOAD 3509 60 PUSH1 0x24 350B 01 ADD 350C 80 DUP1 350D 85 DUP6 350E 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3523 16 AND 3524 81 DUP2 3525 52 MSTORE 3526 60 PUSH1 0x20 3528 01 ADD 3529 84 DUP5 352A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 353F 16 AND 3540 81 DUP2 3541 52 MSTORE 3542 60 PUSH1 0x20 3544 01 ADD 3545 83 DUP4 3546 81 DUP2 3547 52 MSTORE 3548 60 PUSH1 0x20 354A 01 ADD 354B 80 DUP1 354C 60 PUSH1 0x20 354E 01 ADD 354F 82 DUP3 3550 81 DUP2 3551 03 SUB 3552 82 DUP3 3553 52 MSTORE 3554 83 DUP4 3555 81 DUP2 3556 81 DUP2 3557 51 MLOAD 3558 81 DUP2 3559 52 MSTORE 355A 60 PUSH1 0x20 355C 01 ADD 355D 91 SWAP2 355E 50 POP 355F 80 DUP1 3560 51 MLOAD 3561 90 SWAP1 3562 60 PUSH1 0x20 3564 01 ADD 3565 90 SWAP1 3566 80 DUP1 3567 83 DUP4 3568 83 DUP4 3569 60 PUSH1 0x00 356B 5B JUMPDEST 356C 83 DUP4 356D 81 DUP2 356E 10 LT 356F 15 ISZERO 3570 61 PUSH2 0x3586 3573 57 *JUMPI // Stack delta = +12 // Outputs[17] // { // @3503 stack[0] = stack[-9] // @3504 stack[1] = stack[-7] // @3505 stack[2] = stack[-6] // @350B stack[3] = 0x24 + memory[0x40:0x60] // @3525 memory[0x24 + memory[0x40:0x60]:0x24 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-1] // @3541 memory[0x20 + 0x24 + memory[0x40:0x60]:0x20 + 0x24 + memory[0x40:0x60] + 0x20] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-9] // @3547 memory[0x20 + 0x20 + 0x24 + memory[0x40:0x60]:0x20 + 0x20 + 0x24 + memory[0x40:0x60] + 0x20] = stack[-7] // @354A stack[4] = 0x20 + 0x20 + 0x20 + 0x24 + memory[0x40:0x60] // @3553 memory[0x20 + 0x20 + 0x20 + 0x24 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x24 + memory[0x40:0x60] + 0x20] = (0x20 + 0x20 + 0x20 + 0x20 + 0x24 + memory[0x40:0x60]) - (0x24 + memory[0x40:0x60]) // @3559 memory[0x20 + 0x20 + 0x20 + 0x20 + 0x24 + memory[0x40:0x60]:0x20 + 0x20 + 0x20 + 0x20 + 0x24 + memory[0x40:0x60] + 0x20] = memory[stack[-6]:stack[-6] + 0x20] // @355D stack[5] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x24 + memory[0x40:0x60] // @3565 stack[6] = 0x20 + stack[-6] // @3565 stack[7] = memory[stack[-6]:stack[-6] + 0x20] // @3566 stack[8] = memory[stack[-6]:stack[-6] + 0x20] // @3567 stack[9] = 0x20 + 0x20 + 0x20 + 0x20 + 0x20 + 0x24 + memory[0x40:0x60] // @3568 stack[10] = 0x20 + stack[-6] // @3569 stack[11] = 0x00 // } // Block ends with conditional jump to 0x3586, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) label_3574: // Incoming jump from 0x3573, if not !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x3573, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @3574 stack[-1] // @3575 stack[-2] // @3577 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @3579 stack[-3] // } 3574 80 DUP1 3575 82 DUP3 3576 01 ADD 3577 51 MLOAD 3578 81 DUP2 3579 84 DUP5 357A 01 ADD 357B 52 MSTORE 357C 60 PUSH1 0x20 357E 81 DUP2 357F 01 ADD 3580 90 SWAP1 3581 50 POP 3582 61 PUSH2 0x356b 3585 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @357B memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @3580 stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x356b label_3586: // Incoming jump from 0x3573, if !(0x00 < memory[stack[-6]:stack[-6] + 0x20]) // Incoming jump from 0x3573, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @358B stack[-6] // @358B stack[-5] // @358D stack[-7] // } 3586 5B JUMPDEST 3587 50 POP 3588 50 POP 3589 50 POP 358A 50 POP 358B 90 SWAP1 358C 50 POP 358D 90 SWAP1 358E 81 DUP2 358F 01 ADD 3590 90 SWAP1 3591 60 PUSH1 0x1f 3593 16 AND 3594 80 DUP1 3595 15 ISZERO 3596 61 PUSH2 0x35b3 3599 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @3590 stack[-7] = stack[-5] + stack[-7] // @3593 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x35b3, if !(0x1f & stack[-5]) label_359A: // Incoming jump from 0x3599, if not !(0x1f & stack[-5]) // Inputs[9] // { // @359A stack[-1] // @359B stack[-2] // @359E memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @35B5 stack[-8] // @35BE memory[0x40:0x60] // @35CB stack[-9] // @35F0 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @361B memory[0x40:0x60] // @3632 stack[-15] // } 359A 80 DUP1 359B 82 DUP3 359C 03 SUB 359D 80 DUP1 359E 51 MLOAD 359F 60 PUSH1 0x01 35A1 83 DUP4 35A2 60 PUSH1 0x20 35A4 03 SUB 35A5 61 PUSH2 0x0100 35A8 0A EXP 35A9 03 SUB 35AA 19 NOT 35AB 16 AND 35AC 81 DUP2 35AD 52 MSTORE 35AE 60 PUSH1 0x20 35B0 01 ADD 35B1 91 SWAP2 35B2 50 POP 35B3 5B JUMPDEST 35B4 50 POP 35B5 95 SWAP6 35B6 50 POP 35B7 50 POP 35B8 50 POP 35B9 50 POP 35BA 50 POP 35BB 50 POP 35BC 60 PUSH1 0x40 35BE 51 MLOAD 35BF 60 PUSH1 0x20 35C1 81 DUP2 35C2 83 DUP4 35C3 03 SUB 35C4 03 SUB 35C5 81 DUP2 35C6 52 MSTORE 35C7 90 SWAP1 35C8 60 PUSH1 0x40 35CA 52 MSTORE 35CB 90 SWAP1 35CC 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 35E9 19 NOT 35EA 16 AND 35EB 60 PUSH1 0x20 35ED 82 DUP3 35EE 01 ADD 35EF 80 DUP1 35F0 51 MLOAD 35F1 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 360E 83 DUP4 360F 81 DUP2 3610 83 DUP4 3611 16 AND 3612 17 OR 3613 83 DUP4 3614 52 MSTORE 3615 50 POP 3616 50 POP 3617 50 POP 3618 50 POP 3619 60 PUSH1 0x40 361B 51 MLOAD 361C 80 DUP1 361D 60 PUSH1 0x60 361F 01 ADD 3620 60 PUSH1 0x40 3622 52 MSTORE 3623 80 DUP1 3624 60 PUSH1 0x32 3626 81 DUP2 3627 52 MSTORE 3628 60 PUSH1 0x20 362A 01 ADD 362B 61 PUSH2 0x3ea6 362E 60 PUSH1 0x32 3630 91 SWAP2 3631 39 CODECOPY 3632 87 DUP8 3633 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3648 16 AND 3649 61 PUSH2 0x3b36 364C 90 SWAP1 364D 92 SWAP3 364E 91 SWAP2 364F 90 SWAP1 3650 63 PUSH4 0xffffffff 3655 16 AND 3656 56 *JUMP // Stack delta = -6 // Outputs[10] // { // @35AD memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @35C6 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60] - 0x20 // @35CA memory[0x40:0x60] = 0x20 + (stack[-2] - stack[-1]) // @3614 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] = (memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] & 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff) | (~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & stack[-9]) // @3622 memory[0x40:0x60] = 0x60 + memory[0x40:0x60] // @3627 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x32 // @3631 memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x32] = code[0x3ea6:0x3ed8] // @364D stack[-9] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-15] // @364E stack[-8] = memory[0x40:0x60] // @364F stack[-7] = memory[0x40:0x60] // } // Block ends with unconditional jump to 0xffffffff & 0x3b36 label_3657: // Incoming return from call to 0x3502 at 0x3501 // Inputs[3] // { // @3658 stack[-2] // @3658 stack[-1] // @3662 memory[stack[-1]:stack[-1] + 0x20] // } 3657 5B JUMPDEST 3658 90 SWAP1 3659 50 POP 365A 60 PUSH1 0x00 365C 81 DUP2 365D 80 DUP1 365E 60 PUSH1 0x20 3660 01 ADD 3661 90 SWAP1 3662 51 MLOAD 3663 60 PUSH1 0x20 3665 81 DUP2 3666 10 LT 3667 15 ISZERO 3668 61 PUSH2 0x3670 366B 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @3658 stack[-2] = stack[-1] // @365A stack[-1] = 0x00 // @3661 stack[0] = 0x20 + stack[-1] // @3662 stack[1] = memory[stack[-1]:stack[-1] + 0x20] // } // Block ends with conditional jump to 0x3670, if !(memory[stack[-1]:stack[-1] + 0x20] < 0x20) label_366C: // Incoming jump from 0x366B, if not !(memory[stack[-1]:stack[-1] + 0x20] < 0x20) // Inputs[1] { @366F memory[0x00:0x00] } 366C 60 PUSH1 0x00 366E 80 DUP1 366F FD *REVERT // Stack delta = +0 // Outputs[1] { @366F revert(memory[0x00:0x00]); } // Block terminates label_3670: // Incoming jump from 0x366B, if !(memory[stack[-1]:stack[-1] + 0x20] < 0x20) // Inputs[5] // { // @3671 stack[-2] // @3672 stack[-1] // @3676 memory[stack[-2]:stack[-2] + 0x20] // @3682 stack[-3] // @36CC stack[-5] // } 3670 5B JUMPDEST 3671 81 DUP2 3672 01 ADD 3673 90 SWAP1 3674 80 DUP1 3675 80 DUP1 3676 51 MLOAD 3677 90 SWAP1 3678 60 PUSH1 0x20 367A 01 ADD 367B 90 SWAP1 367C 92 SWAP3 367D 91 SWAP2 367E 90 SWAP1 367F 50 POP 3680 50 POP 3681 50 POP 3682 90 SWAP1 3683 50 POP 3684 63 PUSH4 0x150b7a02 3689 60 PUSH1 0xe0 368B 1B SHL 368C 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 36A9 19 NOT 36AA 16 AND 36AB 81 DUP2 36AC 7B PUSH28 0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff 36C9 19 NOT 36CA 16 AND 36CB 14 EQ 36CC 92 SWAP3 36CD 50 POP 36CE 50 POP 36CF 50 POP // Stack delta = -4 // Outputs[1] { @36CC stack[-5] = ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & memory[stack[-2]:stack[-2] + 0x20] == ~0xffffffffffffffffffffffffffffffffffffffffffffffffffffffff & (0x150b7a02 << 0xe0) } // Block continues label_36D0: // Incoming jump from 0x34EC // Incoming jump from 0x36CF // Inputs[3] // { // @36D1 stack[-6] // @36D1 stack[-1] // @36D2 stack[-5] // } 36D0 5B JUMPDEST 36D1 94 SWAP5 36D2 93 SWAP4 36D3 50 POP 36D4 50 POP 36D5 50 POP 36D6 50 POP 36D7 56 *JUMP // Stack delta = -5 // Outputs[1] { @36D1 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_36D8: // Incoming call from 0x31A3, returns to 0x31A4 // Inputs[5] // { // @36DC stack[-2] // @36E2 stack[-1] // @36F0 memory[0x00:0x40] // @36F1 storage[keccak256(memory[0x00:0x40])] // @36F6 stack[-3] // } 36D8 5B JUMPDEST 36D9 60 PUSH1 0x00 36DB 80 DUP1 36DC 83 DUP4 36DD 60 PUSH1 0x01 36DF 01 ADD 36E0 60 PUSH1 0x00 36E2 84 DUP5 36E3 81 DUP2 36E4 52 MSTORE 36E5 60 PUSH1 0x20 36E7 01 ADD 36E8 90 SWAP1 36E9 81 DUP2 36EA 52 MSTORE 36EB 60 PUSH1 0x20 36ED 01 ADD 36EE 60 PUSH1 0x00 36F0 20 SHA3 36F1 54 SLOAD 36F2 14 EQ 36F3 15 ISZERO 36F4 90 SWAP1 36F5 50 POP 36F6 92 SWAP3 36F7 91 SWAP2 36F8 50 POP 36F9 50 POP 36FA 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @36E4 memory[0x00:0x20] = stack[-1] // @36EA memory[0x20:0x40] = 0x01 + stack[-2] // @36F6 stack[-3] = !(storage[keccak256(memory[0x00:0x40])] == 0x00) // } // Block ends with unconditional jump to stack[-3] label_36FB: // Incoming call from 0x31D3, returns to 0x31D4 // Inputs[4] // { // @36FF stack[-2] // @3705 stack[-1] // @3713 memory[0x00:0x40] // @3714 storage[keccak256(memory[0x00:0x40])] // } 36FB 5B JUMPDEST 36FC 60 PUSH1 0x00 36FE 80 DUP1 36FF 83 DUP4 3700 60 PUSH1 0x01 3702 01 ADD 3703 60 PUSH1 0x00 3705 84 DUP5 3706 81 DUP2 3707 52 MSTORE 3708 60 PUSH1 0x20 370A 01 ADD 370B 90 SWAP1 370C 81 DUP2 370D 52 MSTORE 370E 60 PUSH1 0x20 3710 01 ADD 3711 60 PUSH1 0x00 3713 20 SHA3 3714 54 SLOAD 3715 90 SWAP1 3716 50 POP 3717 60 PUSH1 0x00 3719 81 DUP2 371A 14 EQ 371B 61 PUSH2 0x37d7 371E 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @36FC stack[0] = 0x00 // @3707 memory[0x00:0x20] = stack[-1] // @370D memory[0x20:0x40] = 0x01 + stack[-2] // @3715 stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x37d7, if storage[keccak256(memory[0x00:0x40])] == 0x00 label_371F: // Incoming jump from 0x371E, if not storage[keccak256(memory[0x00:0x40])] == 0x00 // Inputs[4] // { // @3723 stack[-1] // @372B stack[-4] // @3730 storage[0x00 + stack[-4]] // @373E storage[0x00 + stack[-4]] // } 371F 60 PUSH1 0x00 3721 60 PUSH1 0x01 3723 82 DUP3 3724 03 SUB 3725 90 SWAP1 3726 50 POP 3727 60 PUSH1 0x00 3729 60 PUSH1 0x01 372B 86 DUP7 372C 60 PUSH1 0x00 372E 01 ADD 372F 80 DUP1 3730 54 SLOAD 3731 90 SWAP1 3732 50 POP 3733 03 SUB 3734 90 SWAP1 3735 50 POP 3736 60 PUSH1 0x00 3738 86 DUP7 3739 60 PUSH1 0x00 373B 01 ADD 373C 82 DUP3 373D 81 DUP2 373E 54 SLOAD 373F 81 DUP2 3740 10 LT 3741 61 PUSH2 0x3746 3744 57 *JUMPI // Stack delta = +5 // Outputs[5] // { // @3725 stack[0] = stack[-1] - 0x01 // @3734 stack[1] = storage[0x00 + stack[-4]] - 0x01 // @3736 stack[2] = 0x00 // @373B stack[3] = 0x00 + stack[-4] // @373C stack[4] = storage[0x00 + stack[-4]] - 0x01 // } // Block ends with conditional jump to 0x3746, if storage[0x00 + stack[-4]] - 0x01 < storage[0x00 + stack[-4]] label_3745: // Incoming jump from 0x3744, if not storage[0x00 + stack[-4]] - 0x01 < storage[0x00 + stack[-4]] 3745 FE *ASSERT // Stack delta = +0 // Outputs[1] { @3745 assert(); } // Block terminates label_3746: // Incoming jump from 0x3744, if storage[0x00 + stack[-4]] - 0x01 < storage[0x00 + stack[-4]] // Inputs[8] // { // @3747 stack[-2] // @3747 stack[-1] // @374F memory[0x00:0x20] // @3751 storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @3752 stack[-3] // @3755 stack[-9] // @3759 stack[-5] // @375B storage[0x00 + stack[-9]] // } 3746 5B JUMPDEST 3747 90 SWAP1 3748 60 PUSH1 0x00 374A 52 MSTORE 374B 60 PUSH1 0x20 374D 60 PUSH1 0x00 374F 20 SHA3 3750 01 ADD 3751 54 SLOAD 3752 90 SWAP1 3753 50 POP 3754 80 DUP1 3755 87 DUP8 3756 60 PUSH1 0x00 3758 01 ADD 3759 84 DUP5 375A 81 DUP2 375B 54 SLOAD 375C 81 DUP2 375D 10 LT 375E 61 PUSH2 0x3763 3761 57 *JUMPI // Stack delta = +1 // Outputs[5] // { // @374A memory[0x00:0x20] = stack[-2] // @3752 stack[-3] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @3754 stack[-2] = storage[keccak256(memory[0x00:0x20]) + stack[-1]] // @3758 stack[-1] = 0x00 + stack[-9] // @3759 stack[0] = stack[-5] // } // Block ends with conditional jump to 0x3763, if stack[-5] < storage[0x00 + stack[-9]] label_3762: // Incoming jump from 0x3761, if not stack[-5] < storage[0x00 + stack[-9]] 3762 FE *ASSERT // Stack delta = +0 // Outputs[1] { @3762 assert(); } // Block terminates label_3763: // Incoming jump from 0x3761, if stack[-5] < storage[0x00 + stack[-9]] // Inputs[9] // { // @3764 stack[-1] // @3764 stack[-2] // @376C memory[0x00:0x20] // @376E stack[-3] // @3774 stack[-6] // @3776 stack[-10] // @377C stack[-4] // @378A memory[0x00:0x40] // @3794 storage[0x00 + stack[-10]] // } 3763 5B JUMPDEST 3764 90 SWAP1 3765 60 PUSH1 0x00 3767 52 MSTORE 3768 60 PUSH1 0x20 376A 60 PUSH1 0x00 376C 20 SHA3 376D 01 ADD 376E 81 DUP2 376F 90 SWAP1 3770 55 SSTORE 3771 50 POP 3772 60 PUSH1 0x01 3774 83 DUP4 3775 01 ADD 3776 87 DUP8 3777 60 PUSH1 0x01 3779 01 ADD 377A 60 PUSH1 0x00 377C 83 DUP4 377D 81 DUP2 377E 52 MSTORE 377F 60 PUSH1 0x20 3781 01 ADD 3782 90 SWAP1 3783 81 DUP2 3784 52 MSTORE 3785 60 PUSH1 0x20 3787 01 ADD 3788 60 PUSH1 0x00 378A 20 SHA3 378B 81 DUP2 378C 90 SWAP1 378D 55 SSTORE 378E 50 POP 378F 86 DUP7 3790 60 PUSH1 0x00 3792 01 ADD 3793 80 DUP1 3794 54 SLOAD 3795 80 DUP1 3796 61 PUSH2 0x379b 3799 57 *JUMPI // Stack delta = -1 // Outputs[7] // { // @3767 memory[0x00:0x20] = stack[-2] // @3770 storage[keccak256(memory[0x00:0x20]) + stack[-1]] = stack[-3] // @377E memory[0x00:0x20] = stack[-4] // @3784 memory[0x20:0x40] = 0x01 + stack[-10] // @378D storage[keccak256(memory[0x00:0x40])] = stack[-6] + 0x01 // @3792 stack[-3] = 0x00 + stack[-10] // @3794 stack[-2] = storage[0x00 + stack[-10]] // } // Block ends with conditional jump to 0x379b, if storage[0x00 + stack[-10]] label_379A: // Incoming jump from 0x3799, if not storage[0x00 + stack[-10]] 379A FE *ASSERT // Stack delta = +0 // Outputs[1] { @379A assert(); } // Block terminates label_379B: // Incoming jump from 0x3799, if storage[0x00 + stack[-10]] // Inputs[7] // { // @379E stack[-1] // @37A0 stack[-2] // @37AA memory[0x00:0x20] // @37B2 stack[-9] // @37B8 stack[-8] // @37C6 memory[0x00:0x40] // @37CD stack[-7] // } 379B 5B JUMPDEST 379C 60 PUSH1 0x01 379E 90 SWAP1 379F 03 SUB 37A0 81 DUP2 37A1 81 DUP2 37A2 90 SWAP1 37A3 60 PUSH1 0x00 37A5 52 MSTORE 37A6 60 PUSH1 0x20 37A8 60 PUSH1 0x00 37AA 20 SHA3 37AB 01 ADD 37AC 60 PUSH1 0x00 37AE 90 SWAP1 37AF 55 SSTORE 37B0 90 SWAP1 37B1 55 SSTORE 37B2 86 DUP7 37B3 60 PUSH1 0x01 37B5 01 ADD 37B6 60 PUSH1 0x00 37B8 87 DUP8 37B9 81 DUP2 37BA 52 MSTORE 37BB 60 PUSH1 0x20 37BD 01 ADD 37BE 90 SWAP1 37BF 81 DUP2 37C0 52 MSTORE 37C1 60 PUSH1 0x20 37C3 01 ADD 37C4 60 PUSH1 0x00 37C6 20 SHA3 37C7 60 PUSH1 0x00 37C9 90 SWAP1 37CA 55 SSTORE 37CB 60 PUSH1 0x01 37CD 94 SWAP5 37CE 50 POP 37CF 50 POP 37D0 50 POP 37D1 50 POP 37D2 50 POP 37D3 61 PUSH2 0x37dd 37D6 56 *JUMP // Stack delta = -6 // Outputs[7] // { // @37A5 memory[0x00:0x20] = stack[-2] // @37AF storage[keccak256(memory[0x00:0x20]) + (stack[-1] - 0x01)] = 0x00 // @37B1 storage[stack[-2]] = stack[-1] - 0x01 // @37BA memory[0x00:0x20] = stack[-8] // @37C0 memory[0x20:0x40] = 0x01 + stack[-9] // @37CA storage[keccak256(memory[0x00:0x40])] = 0x00 // @37CD stack[-7] = 0x01 // } // Block ends with unconditional jump to 0x37dd label_37D7: // Incoming jump from 0x371E, if storage[keccak256(memory[0x00:0x40])] == 0x00 // Inputs[3] // { // @37DA stack[-2] // @37DE stack[-5] // @37DF stack[-4] // } 37D7 5B JUMPDEST 37D8 60 PUSH1 0x00 37DA 91 SWAP2 37DB 50 POP 37DC 50 POP 37DD 5B JUMPDEST 37DE 92 SWAP3 37DF 91 SWAP2 37E0 50 POP 37E1 50 POP 37E2 56 *JUMP // Stack delta = -4 // Outputs[1] { @37DE stack[-5] = 0x00 } // Block ends with unconditional jump to stack[-5] label_37E3: // Incoming call from 0x31ED, returns to 0x31EE // Inputs[2] // { // @37E9 stack[-2] // @37EA stack[-1] // } 37E3 5B JUMPDEST 37E4 60 PUSH1 0x00 37E6 61 PUSH2 0x37ef 37E9 83 DUP4 37EA 83 DUP4 37EB 61 PUSH2 0x3b4e 37EE 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @37E4 stack[0] = 0x00 // @37E6 stack[1] = 0x37ef // @37E9 stack[2] = stack[-2] // @37EA stack[3] = stack[-1] // } // Block ends with call to 0x3b4e, returns to 0x37EF label_37EF: // Incoming return from call to 0x3B4E at 0x37EE // Inputs[1] { @37F3 stack[-1] } 37EF 5B JUMPDEST 37F0 61 PUSH2 0x3848 37F3 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x3848, if stack[-1] label_37F4: // Incoming jump from 0x37F3, if not stack[-1] // Inputs[7] // { // @37F4 stack[-3] // @37F8 stack[-2] // @37FE storage[0x00 + stack[-3]] // @3813 memory[0x00:0x20] // @3824 storage[0x00 + stack[-3]] // @383B memory[0x00:0x40] // @3842 stack[-1] // } 37F4 82 DUP3 37F5 60 PUSH1 0x00 37F7 01 ADD 37F8 82 DUP3 37F9 90 SWAP1 37FA 80 DUP1 37FB 60 PUSH1 0x01 37FD 81 DUP2 37FE 54 SLOAD 37FF 01 ADD 3800 80 DUP1 3801 82 DUP3 3802 55 SSTORE 3803 80 DUP1 3804 91 SWAP2 3805 50 POP 3806 50 POP 3807 60 PUSH1 0x01 3809 90 SWAP1 380A 03 SUB 380B 90 SWAP1 380C 60 PUSH1 0x00 380E 52 MSTORE 380F 60 PUSH1 0x20 3811 60 PUSH1 0x00 3813 20 SHA3 3814 01 ADD 3815 60 PUSH1 0x00 3817 90 SWAP1 3818 91 SWAP2 3819 90 SWAP1 381A 91 SWAP2 381B 90 SWAP1 381C 91 SWAP2 381D 50 POP 381E 55 SSTORE 381F 82 DUP3 3820 60 PUSH1 0x00 3822 01 ADD 3823 80 DUP1 3824 54 SLOAD 3825 90 SWAP1 3826 50 POP 3827 83 DUP4 3828 60 PUSH1 0x01 382A 01 ADD 382B 60 PUSH1 0x00 382D 84 DUP5 382E 81 DUP2 382F 52 MSTORE 3830 60 PUSH1 0x20 3832 01 ADD 3833 90 SWAP1 3834 81 DUP2 3835 52 MSTORE 3836 60 PUSH1 0x20 3838 01 ADD 3839 60 PUSH1 0x00 383B 20 SHA3 383C 81 DUP2 383D 90 SWAP1 383E 55 SSTORE 383F 50 POP 3840 60 PUSH1 0x01 3842 90 SWAP1 3843 50 POP 3844 61 PUSH2 0x384d 3847 56 *JUMP // Stack delta = +0 // Outputs[7] // { // @3802 storage[0x00 + stack[-3]] = storage[0x00 + stack[-3]] + 0x01 // @380E memory[0x00:0x20] = 0x00 + stack[-3] // @381E storage[keccak256(memory[0x00:0x20]) + ((storage[0x00 + stack[-3]] + 0x01) - 0x01)] = stack[-2] // @382F memory[0x00:0x20] = stack[-2] // @3835 memory[0x20:0x40] = 0x01 + stack[-3] // @383E storage[keccak256(memory[0x00:0x40])] = storage[0x00 + stack[-3]] // @3842 stack[-1] = 0x01 // } // Block ends with unconditional jump to 0x384d label_3848: // Incoming jump from 0x37F3, if stack[-1] // Inputs[3] // { // @384B stack[-1] // @384E stack[-4] // @384F stack[-3] // } 3848 5B JUMPDEST 3849 60 PUSH1 0x00 384B 90 SWAP1 384C 50 POP 384D 5B JUMPDEST 384E 92 SWAP3 384F 91 SWAP2 3850 50 POP 3851 50 POP 3852 56 *JUMP // Stack delta = -3 // Outputs[1] { @384E stack[-4] = 0x00 } // Block ends with unconditional jump to stack[-4] label_3853: // Incoming call from 0x3221, returns to 0x3222 // Inputs[4] // { // @3857 stack[-3] // @385D stack[-2] // @386B memory[0x00:0x40] // @386C storage[keccak256(memory[0x00:0x40])] // } 3853 5B JUMPDEST 3854 60 PUSH1 0x00 3856 80 DUP1 3857 84 DUP5 3858 60 PUSH1 0x01 385A 01 ADD 385B 60 PUSH1 0x00 385D 85 DUP6 385E 81 DUP2 385F 52 MSTORE 3860 60 PUSH1 0x20 3862 01 ADD 3863 90 SWAP1 3864 81 DUP2 3865 52 MSTORE 3866 60 PUSH1 0x20 3868 01 ADD 3869 60 PUSH1 0x00 386B 20 SHA3 386C 54 SLOAD 386D 90 SWAP1 386E 50 POP 386F 60 PUSH1 0x00 3871 81 DUP2 3872 14 EQ 3873 15 ISZERO 3874 61 PUSH2 0x38fa 3877 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @3854 stack[0] = 0x00 // @385F memory[0x00:0x20] = stack[-2] // @3865 memory[0x20:0x40] = 0x01 + stack[-3] // @386D stack[1] = storage[keccak256(memory[0x00:0x40])] // } // Block ends with conditional jump to 0x38fa, if !(storage[keccak256(memory[0x00:0x40])] == 0x00) label_3878: // Incoming jump from 0x3877, if not !(storage[keccak256(memory[0x00:0x40])] == 0x00) // Inputs[11] // { // @3878 stack[-5] // @387E memory[0x40:0x60] // @3887 stack[-4] // @388D stack[-3] // @3896 storage[0x00 + stack[-5]] // @38AB memory[0x00:0x20] // @38BE memory[memory[0x40:0x60] + 0x00:memory[0x40:0x60] + 0x00 + 0x20] // @38C8 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @38D5 storage[0x00 + stack[-5]] // @38EC memory[0x00:0x40] // @38F3 stack[-2] // } 3878 84 DUP5 3879 60 PUSH1 0x00 387B 01 ADD 387C 60 PUSH1 0x40 387E 51 MLOAD 387F 80 DUP1 3880 60 PUSH1 0x40 3882 01 ADD 3883 60 PUSH1 0x40 3885 52 MSTORE 3886 80 DUP1 3887 86 DUP7 3888 81 DUP2 3889 52 MSTORE 388A 60 PUSH1 0x20 388C 01 ADD 388D 85 DUP6 388E 81 DUP2 388F 52 MSTORE 3890 50 POP 3891 90 SWAP1 3892 80 DUP1 3893 60 PUSH1 0x01 3895 81 DUP2 3896 54 SLOAD 3897 01 ADD 3898 80 DUP1 3899 82 DUP3 389A 55 SSTORE 389B 80 DUP1 389C 91 SWAP2 389D 50 POP 389E 50 POP 389F 60 PUSH1 0x01 38A1 90 SWAP1 38A2 03 SUB 38A3 90 SWAP1 38A4 60 PUSH1 0x00 38A6 52 MSTORE 38A7 60 PUSH1 0x20 38A9 60 PUSH1 0x00 38AB 20 SHA3 38AC 90 SWAP1 38AD 60 PUSH1 0x02 38AF 02 MUL 38B0 01 ADD 38B1 60 PUSH1 0x00 38B3 90 SWAP1 38B4 91 SWAP2 38B5 90 SWAP1 38B6 91 SWAP2 38B7 90 SWAP1 38B8 91 SWAP2 38B9 50 POP 38BA 60 PUSH1 0x00 38BC 82 DUP3 38BD 01 ADD 38BE 51 MLOAD 38BF 81 DUP2 38C0 60 PUSH1 0x00 38C2 01 ADD 38C3 55 SSTORE 38C4 60 PUSH1 0x20 38C6 82 DUP3 38C7 01 ADD 38C8 51 MLOAD 38C9 81 DUP2 38CA 60 PUSH1 0x01 38CC 01 ADD 38CD 55 SSTORE 38CE 50 POP 38CF 50 POP 38D0 84 DUP5 38D1 60 PUSH1 0x00 38D3 01 ADD 38D4 80 DUP1 38D5 54 SLOAD 38D6 90 SWAP1 38D7 50 POP 38D8 85 DUP6 38D9 60 PUSH1 0x01 38DB 01 ADD 38DC 60 PUSH1 0x00 38DE 86 DUP7 38DF 81 DUP2 38E0 52 MSTORE 38E1 60 PUSH1 0x20 38E3 01 ADD 38E4 90 SWAP1 38E5 81 DUP2 38E6 52 MSTORE 38E7 60 PUSH1 0x20 38E9 01 ADD 38EA 60 PUSH1 0x00 38EC 20 SHA3 38ED 81 DUP2 38EE 90 SWAP1 38EF 55 SSTORE 38F0 50 POP 38F1 60 PUSH1 0x01 38F3 91 SWAP2 38F4 50 POP 38F5 50 POP 38F6 61 PUSH2 0x3928 38F9 56 *JUMP // Stack delta = -1 // Outputs[11] // { // @3885 memory[0x40:0x60] = 0x40 + memory[0x40:0x60] // @3889 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = stack[-4] // @388F memory[0x20 + memory[0x40:0x60]:0x20 + memory[0x40:0x60] + 0x20] = stack[-3] // @389A storage[0x00 + stack[-5]] = storage[0x00 + stack[-5]] + 0x01 // @38A6 memory[0x00:0x20] = 0x00 + stack[-5] // @38C3 storage[0x00 + 0x02 * ((storage[0x00 + stack[-5]] + 0x01) - 0x01) + keccak256(memory[0x00:0x20])] = memory[memory[0x40:0x60] + 0x00:memory[0x40:0x60] + 0x00 + 0x20] // @38CD storage[0x01 + 0x02 * ((storage[0x00 + stack[-5]] + 0x01) - 0x01) + keccak256(memory[0x00:0x20])] = memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + 0x20] // @38E0 memory[0x00:0x20] = stack[-4] // @38E6 memory[0x20:0x40] = 0x01 + stack[-5] // @38EF storage[keccak256(memory[0x00:0x40])] = storage[0x00 + stack[-5]] // @38F3 stack[-2] = 0x01 // } // Block ends with unconditional jump to 0x3928 label_38FA: // Incoming jump from 0x3877, if !(storage[keccak256(memory[0x00:0x40])] == 0x00) // Inputs[4] // { // @38FB stack[-3] // @38FC stack[-5] // @3902 stack[-1] // @3905 storage[0x00 + stack[-5]] // } 38FA 5B JUMPDEST 38FB 82 DUP3 38FC 85 DUP6 38FD 60 PUSH1 0x00 38FF 01 ADD 3900 60 PUSH1 0x01 3902 83 DUP4 3903 03 SUB 3904 81 DUP2 3905 54 SLOAD 3906 81 DUP2 3907 10 LT 3908 61 PUSH2 0x390d 390B 57 *JUMPI // Stack delta = +3 // Outputs[3] // { // @38FB stack[0] = stack[-3] // @38FF stack[1] = 0x00 + stack[-5] // @3903 stack[2] = stack[-1] - 0x01 // } // Block ends with conditional jump to 0x390d, if stack[-1] - 0x01 < storage[0x00 + stack[-5]] label_390C: // Incoming jump from 0x390B, if not stack[-1] - 0x01 < storage[0x00 + stack[-5]] 390C FE *ASSERT // Stack delta = +0 // Outputs[1] { @390C assert(); } // Block terminates label_390D: // Incoming jump from 0x390B, if stack[-1] - 0x01 < storage[0x00 + stack[-5]] // Inputs[7] // { // @390E stack[-2] // @390E stack[-1] // @3916 memory[0x00:0x20] // @391F stack[-3] // @3925 stack[-5] // @3929 stack[-9] // @392A stack[-8] // } 390D 5B JUMPDEST 390E 90 SWAP1 390F 60 PUSH1 0x00 3911 52 MSTORE 3912 60 PUSH1 0x20 3914 60 PUSH1 0x00 3916 20 SHA3 3917 90 SWAP1 3918 60 PUSH1 0x02 391A 02 MUL 391B 01 ADD 391C 60 PUSH1 0x01 391E 01 ADD 391F 81 DUP2 3920 90 SWAP1 3921 55 SSTORE 3922 50 POP 3923 60 PUSH1 0x00 3925 91 SWAP2 3926 50 POP 3927 50 POP 3928 5B JUMPDEST 3929 93 SWAP4 392A 92 SWAP3 392B 50 POP 392C 50 POP 392D 50 POP 392E 56 *JUMP // Stack delta = -8 // Outputs[3] // { // @3911 memory[0x00:0x20] = stack[-2] // @3921 storage[0x01 + 0x02 * stack[-1] + keccak256(memory[0x00:0x20])] = stack[-3] // @3929 stack[-9] = 0x00 // } // Block ends with unconditional jump to stack[-9] label_392F: // Incoming call from 0x3457, returns to 0x3458 // Inputs[1] { @3948 stack[-2] } 392F 5B JUMPDEST 3930 60 PUSH1 0x00 3932 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3947 16 AND 3948 82 DUP3 3949 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 395E 16 AND 395F 14 EQ 3960 15 ISZERO 3961 61 PUSH2 0x39d2 3964 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x39d2, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) label_3965: // Incoming jump from 0x3964, if not !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[3] // { // @3967 memory[0x40:0x60] // @39CC memory[0x40:0x60] // @39D1 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 3965 60 PUSH1 0x40 3967 51 MLOAD 3968 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 3989 81 DUP2 398A 52 MSTORE 398B 60 PUSH1 0x04 398D 01 ADD 398E 80 DUP1 398F 80 DUP1 3990 60 PUSH1 0x20 3992 01 ADD 3993 82 DUP3 3994 81 DUP2 3995 03 SUB 3996 82 DUP3 3997 52 MSTORE 3998 60 PUSH1 0x20 399A 81 DUP2 399B 52 MSTORE 399C 60 PUSH1 0x20 399E 01 ADD 399F 80 DUP1 39A0 7F PUSH32 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 39C1 81 DUP2 39C2 52 MSTORE 39C3 50 POP 39C4 60 PUSH1 0x20 39C6 01 ADD 39C7 91 SWAP2 39C8 50 POP 39C9 50 POP 39CA 60 PUSH1 0x40 39CC 51 MLOAD 39CD 80 DUP1 39CE 91 SWAP2 39CF 03 SUB 39D0 90 SWAP1 39D1 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @398A memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @3997 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @399B memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x20 // @39C2 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4552433732313a206d696e7420746f20746865207a65726f2061646472657373 // @39D1 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_39D2: // Incoming jump from 0x3964, if !(0xffffffffffffffffffffffffffffffffffffffff & stack[-2] == 0xffffffffffffffffffffffffffffffffffffffff & 0x00) // Inputs[1] { @39D6 stack[-1] } 39D2 5B JUMPDEST 39D3 61 PUSH2 0x39db 39D6 81 DUP2 39D7 61 PUSH2 0x2974 39DA 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @39D3 stack[0] = 0x39db // @39D6 stack[1] = stack[-1] // } // Block ends with call to 0x2974, returns to 0x39DB label_39DB: // Incoming return from call to 0x2974 at 0x39DA // Inputs[1] { @39DC stack[-1] } 39DB 5B JUMPDEST 39DC 15 ISZERO 39DD 61 PUSH2 0x3a4e 39E0 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x3a4e, if !stack[-1] label_39E1: // Incoming jump from 0x39E0, if not !stack[-1] // Inputs[3] // { // @39E3 memory[0x40:0x60] // @3A48 memory[0x40:0x60] // @3A4D memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 39E1 60 PUSH1 0x40 39E3 51 MLOAD 39E4 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 3A05 81 DUP2 3A06 52 MSTORE 3A07 60 PUSH1 0x04 3A09 01 ADD 3A0A 80 DUP1 3A0B 80 DUP1 3A0C 60 PUSH1 0x20 3A0E 01 ADD 3A0F 82 DUP3 3A10 81 DUP2 3A11 03 SUB 3A12 82 DUP3 3A13 52 MSTORE 3A14 60 PUSH1 0x1c 3A16 81 DUP2 3A17 52 MSTORE 3A18 60 PUSH1 0x20 3A1A 01 ADD 3A1B 80 DUP1 3A1C 7F PUSH32 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 3A3D 81 DUP2 3A3E 52 MSTORE 3A3F 50 POP 3A40 60 PUSH1 0x20 3A42 01 ADD 3A43 91 SWAP2 3A44 50 POP 3A45 50 POP 3A46 60 PUSH1 0x40 3A48 51 MLOAD 3A49 80 DUP1 3A4A 91 SWAP2 3A4B 03 SUB 3A4C 90 SWAP1 3A4D FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3A06 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @3A13 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @3A17 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x1c // @3A3E memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x4552433732313a20746f6b656e20616c7265616479206d696e74656400000000 // @3A4D revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_3A4E: // Incoming jump from 0x39E0, if !stack[-1] // Inputs[2] // { // @3A54 stack[-2] // @3A55 stack[-1] // } 3A4E 5B JUMPDEST 3A4F 61 PUSH2 0x3a5a 3A52 60 PUSH1 0x00 3A54 83 DUP4 3A55 83 DUP4 3A56 61 PUSH2 0x31bd 3A59 56 *JUMP // Stack delta = +4 // Outputs[4] // { // @3A4F stack[0] = 0x3a5a // @3A52 stack[1] = 0x00 // @3A54 stack[2] = stack[-2] // @3A55 stack[3] = stack[-1] // } // Block ends with call to 0x31bd, returns to 0x3A5A label_3A5A: // Incoming return from call to 0x31BD at 0x3A59 // Inputs[3] // { // @3A5E stack[-1] // @3A63 stack[-2] // @3A9D memory[0x00:0x40] // } 3A5A 5B JUMPDEST 3A5B 61 PUSH2 0x3aab 3A5E 81 DUP2 3A5F 60 PUSH1 0x01 3A61 60 PUSH1 0x00 3A63 85 DUP6 3A64 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3A79 16 AND 3A7A 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3A8F 16 AND 3A90 81 DUP2 3A91 52 MSTORE 3A92 60 PUSH1 0x20 3A94 01 ADD 3A95 90 SWAP1 3A96 81 DUP2 3A97 52 MSTORE 3A98 60 PUSH1 0x20 3A9A 01 ADD 3A9B 60 PUSH1 0x00 3A9D 20 SHA3 3A9E 61 PUSH2 0x31dc 3AA1 90 SWAP1 3AA2 91 SWAP2 3AA3 90 SWAP1 3AA4 63 PUSH4 0xffffffff 3AA9 16 AND 3AAA 56 *JUMP // Stack delta = +3 // Outputs[5] // { // @3A5B stack[0] = 0x3aab // @3A91 memory[0x00:0x20] = 0xffffffffffffffffffffffffffffffffffffffff & 0xffffffffffffffffffffffffffffffffffffffff & stack[-2] // @3A97 memory[0x20:0x40] = 0x01 // @3AA2 stack[1] = keccak256(memory[0x00:0x40]) // @3AA3 stack[2] = stack[-1] // } // Block ends with call to 0xffffffff & 0x31dc, returns to 0x3AAB label_3AAB: // Incoming return from call to 0x31DC at 0x3AAA // Inputs[2] // { // @3AB0 stack[-2] // @3AB1 stack[-3] // } 3AAB 5B JUMPDEST 3AAC 50 POP 3AAD 61 PUSH2 0x3ac2 3AB0 81 DUP2 3AB1 83 DUP4 3AB2 60 PUSH1 0x02 3AB4 61 PUSH2 0x31f6 3AB7 90 SWAP1 3AB8 92 SWAP3 3AB9 91 SWAP2 3ABA 90 SWAP1 3ABB 63 PUSH4 0xffffffff 3AC0 16 AND 3AC1 56 *JUMP // Stack delta = +3 // Outputs[4] // { // @3AAD stack[-1] = 0x3ac2 // @3AB8 stack[0] = 0x02 // @3AB9 stack[1] = stack[-2] // @3ABA stack[2] = stack[-3] // } // Block ends with call to 0xffffffff & 0x31f6, returns to 0x3AC2 label_3AC2: // Incoming return from call to 0x31F6 at 0x3AC1 // Inputs[6] // { // @3AC4 stack[-2] // @3AC5 stack[-3] // @3B17 memory[0x40:0x60] // @3B1A memory[0x40:0x60] // @3B1F memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]] // @3B22 stack[-4] // } 3AC2 5B JUMPDEST 3AC3 50 POP 3AC4 80 DUP1 3AC5 82 DUP3 3AC6 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3ADB 16 AND 3ADC 60 PUSH1 0x00 3ADE 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3AF3 16 AND 3AF4 7F PUSH32 0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef 3B15 60 PUSH1 0x40 3B17 51 MLOAD 3B18 60 PUSH1 0x40 3B1A 51 MLOAD 3B1B 80 DUP1 3B1C 91 SWAP2 3B1D 03 SUB 3B1E 90 SWAP1 3B1F A4 LOG4 3B20 50 POP 3B21 50 POP 3B22 56 *JUMP // Stack delta = -4 // Outputs[1] { @3B1F log(memory[memory[0x40:0x60]:memory[0x40:0x60] + memory[0x40:0x60] - memory[0x40:0x60]], [0xddf252ad1be2c89b69c2b068fc378daa952ba7f163c4a11628f55a4df523b3ef, 0xffffffffffffffffffffffffffffffffffffffff & 0x00, stack[-3] & 0xffffffffffffffffffffffffffffffffffffffff, stack[-2]]); } // Block ends with unconditional jump to stack[-4] label_3B23: // Incoming call from 0x34DF, returns to 0x34E0 // Incoming call from 0x3BD4, returns to 0x3BD5 // Inputs[3] // { // @3B27 stack[-1] // @3B28 address(stack[-1]).code.length // @3B32 stack[-2] // } 3B23 5B JUMPDEST 3B24 60 PUSH1 0x00 3B26 80 DUP1 3B27 82 DUP3 3B28 3B EXTCODESIZE 3B29 90 SWAP1 3B2A 50 POP 3B2B 60 PUSH1 0x00 3B2D 81 DUP2 3B2E 11 GT 3B2F 91 SWAP2 3B30 50 POP 3B31 50 POP 3B32 91 SWAP2 3B33 90 SWAP1 3B34 50 POP 3B35 56 *JUMP // Stack delta = -1 // Outputs[1] { @3B32 stack[-2] = address(stack[-1]).code.length > 0x00 } // Block ends with unconditional jump to stack[-2] label_3B36: // Incoming jump from 0x3656 // Incoming jump from 0x3656 // Inputs[3] // { // @3B3C stack[-3] // @3B3D stack[-2] // @3B40 stack[-1] // } 3B36 5B JUMPDEST 3B37 60 PUSH1 0x60 3B39 61 PUSH2 0x3b45 3B3C 84 DUP5 3B3D 84 DUP5 3B3E 60 PUSH1 0x00 3B40 85 DUP6 3B41 61 PUSH2 0x3b71 3B44 56 *JUMP // Stack delta = +6 // Outputs[6] // { // @3B37 stack[0] = 0x60 // @3B39 stack[1] = 0x3b45 // @3B3C stack[2] = stack[-3] // @3B3D stack[3] = stack[-2] // @3B3E stack[4] = 0x00 // @3B40 stack[5] = stack[-1] // } // Block ends with call to 0x3b71, returns to 0x3B45 label_3B45: // Incoming return from call to 0x3B71 at 0x3B44 // Inputs[4] // { // @3B46 stack[-1] // @3B46 stack[-2] // @3B48 stack[-6] // @3B49 stack[-5] // } 3B45 5B JUMPDEST 3B46 90 SWAP1 3B47 50 POP 3B48 93 SWAP4 3B49 92 SWAP3 3B4A 50 POP 3B4B 50 POP 3B4C 50 POP 3B4D 56 *JUMP // Stack delta = -5 // Outputs[1] { @3B48 stack[-6] = stack[-1] } // Block ends with unconditional jump to stack[-6] label_3B4E: // Incoming call from 0x37EE, returns to 0x37EF // Inputs[5] // { // @3B52 stack[-2] // @3B58 stack[-1] // @3B66 memory[0x00:0x40] // @3B67 storage[keccak256(memory[0x00:0x40])] // @3B6C stack[-3] // } 3B4E 5B JUMPDEST 3B4F 60 PUSH1 0x00 3B51 80 DUP1 3B52 83 DUP4 3B53 60 PUSH1 0x01 3B55 01 ADD 3B56 60 PUSH1 0x00 3B58 84 DUP5 3B59 81 DUP2 3B5A 52 MSTORE 3B5B 60 PUSH1 0x20 3B5D 01 ADD 3B5E 90 SWAP1 3B5F 81 DUP2 3B60 52 MSTORE 3B61 60 PUSH1 0x20 3B63 01 ADD 3B64 60 PUSH1 0x00 3B66 20 SHA3 3B67 54 SLOAD 3B68 14 EQ 3B69 15 ISZERO 3B6A 90 SWAP1 3B6B 50 POP 3B6C 92 SWAP3 3B6D 91 SWAP2 3B6E 50 POP 3B6F 50 POP 3B70 56 *JUMP // Stack delta = -2 // Outputs[3] // { // @3B5A memory[0x00:0x20] = stack[-1] // @3B60 memory[0x20:0x40] = 0x01 + stack[-2] // @3B6C stack[-3] = !(storage[keccak256(memory[0x00:0x40])] == 0x00) // } // Block ends with unconditional jump to stack[-3] label_3B71: // Incoming call from 0x3B44, returns to 0x3B45 // Inputs[3] // { // @3B74 stack[-2] // @3B75 address(this) // @3B75 address(this).balance // } 3B71 5B JUMPDEST 3B72 60 PUSH1 0x60 3B74 82 DUP3 3B75 47 SELFBALANCE 3B76 10 LT 3B77 15 ISZERO 3B78 61 PUSH2 0x3bcc 3B7B 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3B72 stack[0] = 0x60 } // Block ends with conditional jump to 0x3bcc, if !(address(this).balance < stack[-2]) label_3B7C: // Incoming jump from 0x3B7B, if not !(address(this).balance < stack[-2]) // Inputs[3] // { // @3B7E memory[0x40:0x60] // @3BC6 memory[0x40:0x60] // @3BCB memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 3B7C 60 PUSH1 0x40 3B7E 51 MLOAD 3B7F 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 3BA0 81 DUP2 3BA1 52 MSTORE 3BA2 60 PUSH1 0x04 3BA4 01 ADD 3BA5 80 DUP1 3BA6 80 DUP1 3BA7 60 PUSH1 0x20 3BA9 01 ADD 3BAA 82 DUP3 3BAB 81 DUP2 3BAC 03 SUB 3BAD 82 DUP3 3BAE 52 MSTORE 3BAF 60 PUSH1 0x26 3BB1 81 DUP2 3BB2 52 MSTORE 3BB3 60 PUSH1 0x20 3BB5 01 ADD 3BB6 80 DUP1 3BB7 61 PUSH2 0x3f22 3BBA 60 PUSH1 0x26 3BBC 91 SWAP2 3BBD 39 CODECOPY 3BBE 60 PUSH1 0x40 3BC0 01 ADD 3BC1 91 SWAP2 3BC2 50 POP 3BC3 50 POP 3BC4 60 PUSH1 0x40 3BC6 51 MLOAD 3BC7 80 DUP1 3BC8 91 SWAP2 3BC9 03 SUB 3BCA 90 SWAP1 3BCB FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3BA1 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @3BAE memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @3BB2 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x26 // @3BBD memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x26] = code[0x3f22:0x3f48] // @3BCB revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x40 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_3BCC: // Incoming jump from 0x3B7B, if !(address(this).balance < stack[-2]) // Inputs[1] { @3BD0 stack[-5] } 3BCC 5B JUMPDEST 3BCD 61 PUSH2 0x3bd5 3BD0 85 DUP6 3BD1 61 PUSH2 0x3b23 3BD4 56 *JUMP // Stack delta = +2 // Outputs[2] // { // @3BCD stack[0] = 0x3bd5 // @3BD0 stack[1] = stack[-5] // } // Block ends with call to 0x3b23, returns to 0x3BD5 label_3BD5: // Incoming return from call to 0x3B23 at 0x3BD4 // Inputs[1] { @3BD9 stack[-1] } 3BD5 5B JUMPDEST 3BD6 61 PUSH2 0x3c47 3BD9 57 *JUMPI // Stack delta = -1 // Block ends with conditional jump to 0x3c47, if stack[-1] label_3BDA: // Incoming jump from 0x3BD9, if not stack[-1] // Inputs[3] // { // @3BDC memory[0x40:0x60] // @3C41 memory[0x40:0x60] // @3C46 memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]] // } 3BDA 60 PUSH1 0x40 3BDC 51 MLOAD 3BDD 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 3BFE 81 DUP2 3BFF 52 MSTORE 3C00 60 PUSH1 0x04 3C02 01 ADD 3C03 80 DUP1 3C04 80 DUP1 3C05 60 PUSH1 0x20 3C07 01 ADD 3C08 82 DUP3 3C09 81 DUP2 3C0A 03 SUB 3C0B 82 DUP3 3C0C 52 MSTORE 3C0D 60 PUSH1 0x1d 3C0F 81 DUP2 3C10 52 MSTORE 3C11 60 PUSH1 0x20 3C13 01 ADD 3C14 80 DUP1 3C15 7F PUSH32 0x416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000 3C36 81 DUP2 3C37 52 MSTORE 3C38 50 POP 3C39 60 PUSH1 0x20 3C3B 01 ADD 3C3C 91 SWAP2 3C3D 50 POP 3C3E 50 POP 3C3F 60 PUSH1 0x40 3C41 51 MLOAD 3C42 80 DUP1 3C43 91 SWAP2 3C44 03 SUB 3C45 90 SWAP1 3C46 FD *REVERT // Stack delta = +0 // Outputs[5] // { // @3BFF memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @3C0C memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @3C10 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x1d // @3C37 memory[0x20 + 0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x20 + 0x04 + memory[0x40:0x60] + 0x20] = 0x416464726573733a2063616c6c20746f206e6f6e2d636f6e7472616374000000 // @3C46 revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + 0x20 + 0x20 + 0x04 + memory[0x40:0x60]) - memory[0x40:0x60]]); // } // Block terminates label_3C47: // Incoming jump from 0x3BD9, if stack[-1] // Inputs[5] // { // @3C4C stack[-5] // @3C63 stack[-3] // @3C64 stack[-4] // @3C67 memory[0x40:0x60] // @3C6B memory[stack[-4]:stack[-4] + 0x20] // } 3C47 5B JUMPDEST 3C48 60 PUSH1 0x00 3C4A 60 PUSH1 0x60 3C4C 86 DUP7 3C4D 73 PUSH20 0xffffffffffffffffffffffffffffffffffffffff 3C62 16 AND 3C63 85 DUP6 3C64 87 DUP8 3C65 60 PUSH1 0x40 3C67 51 MLOAD 3C68 80 DUP1 3C69 82 DUP3 3C6A 80 DUP1 3C6B 51 MLOAD 3C6C 90 SWAP1 3C6D 60 PUSH1 0x20 3C6F 01 ADD 3C70 90 SWAP1 3C71 80 DUP1 3C72 83 DUP4 3C73 83 DUP4 3C74 5B JUMPDEST 3C75 60 PUSH1 0x20 3C77 83 DUP4 3C78 10 LT 3C79 61 PUSH2 0x3c97 3C7C 57 *JUMPI // Stack delta = +12 // Outputs[12] // { // @3C48 stack[0] = 0x00 // @3C4A stack[1] = 0x60 // @3C62 stack[2] = 0xffffffffffffffffffffffffffffffffffffffff & stack[-5] // @3C63 stack[3] = stack[-3] // @3C64 stack[4] = stack[-4] // @3C67 stack[5] = memory[0x40:0x60] // @3C68 stack[6] = memory[0x40:0x60] // @3C70 stack[7] = 0x20 + stack[-4] // @3C70 stack[8] = memory[stack[-4]:stack[-4] + 0x20] // @3C71 stack[9] = memory[stack[-4]:stack[-4] + 0x20] // @3C72 stack[10] = memory[0x40:0x60] // @3C73 stack[11] = 0x20 + stack[-4] // } // Block ends with conditional jump to 0x3c97, if memory[stack[-4]:stack[-4] + 0x20] < 0x20 label_3C7D: // Incoming jump from 0x3C7C, if not stack[-3] < 0x20 // Incoming jump from 0x3C7C, if not memory[stack[-4]:stack[-4] + 0x20] < 0x20 // Inputs[4] // { // @3C7D stack[-1] // @3C7E memory[stack[-1]:stack[-1] + 0x20] // @3C7F stack[-2] // @3C8F stack[-3] // } 3C7D 80 DUP1 3C7E 51 MLOAD 3C7F 82 DUP3 3C80 52 MSTORE 3C81 60 PUSH1 0x20 3C83 82 DUP3 3C84 01 ADD 3C85 91 SWAP2 3C86 50 POP 3C87 60 PUSH1 0x20 3C89 81 DUP2 3C8A 01 ADD 3C8B 90 SWAP1 3C8C 50 POP 3C8D 60 PUSH1 0x20 3C8F 83 DUP4 3C90 03 SUB 3C91 92 SWAP3 3C92 50 POP 3C93 61 PUSH2 0x3c74 3C96 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @3C80 memory[stack[-2]:stack[-2] + 0x20] = memory[stack[-1]:stack[-1] + 0x20] // @3C85 stack[-2] = stack[-2] + 0x20 // @3C8B stack[-1] = stack[-1] + 0x20 // @3C91 stack[-3] = stack[-3] - 0x20 // } // Block ends with unconditional jump to 0x3c74 label_3C97: // Incoming jump from 0x3C7C, if stack[-3] < 0x20 // Incoming jump from 0x3C7C, if memory[stack[-4]:stack[-4] + 0x20] < 0x20 // Inputs[16] // { // @3C9A stack[-3] // @3CA5 stack[-1] // @3CA6 memory[stack[-1]:stack[-1] + 0x20] // @3CA9 stack[-2] // @3CAA memory[stack[-2]:stack[-2] + 0x20] // @3CB7 stack[-5] // @3CB7 stack[-4] // @3CB9 stack[-6] // @3CBA stack[-8] // @3CC1 memory[0x40:0x60] // @3CC6 stack[-9] // @3CC7 stack[-10] // @3CC8 msg.gas // @3CC9 address(stack[-10]).call.gas(msg.gas).value(stack[-9])(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @3CC9 memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]] // @3CCE returndata.length // } 3C97 5B JUMPDEST 3C98 60 PUSH1 0x01 3C9A 83 DUP4 3C9B 60 PUSH1 0x20 3C9D 03 SUB 3C9E 61 PUSH2 0x0100 3CA1 0A EXP 3CA2 03 SUB 3CA3 80 DUP1 3CA4 19 NOT 3CA5 82 DUP3 3CA6 51 MLOAD 3CA7 16 AND 3CA8 81 DUP2 3CA9 84 DUP5 3CAA 51 MLOAD 3CAB 16 AND 3CAC 80 DUP1 3CAD 82 DUP3 3CAE 17 OR 3CAF 85 DUP6 3CB0 52 MSTORE 3CB1 50 POP 3CB2 50 POP 3CB3 50 POP 3CB4 50 POP 3CB5 50 POP 3CB6 50 POP 3CB7 90 SWAP1 3CB8 50 POP 3CB9 01 ADD 3CBA 91 SWAP2 3CBB 50 POP 3CBC 50 POP 3CBD 60 PUSH1 0x00 3CBF 60 PUSH1 0x40 3CC1 51 MLOAD 3CC2 80 DUP1 3CC3 83 DUP4 3CC4 03 SUB 3CC5 81 DUP2 3CC6 85 DUP6 3CC7 87 DUP8 3CC8 5A GAS 3CC9 F1 CALL 3CCA 92 SWAP3 3CCB 50 POP 3CCC 50 POP 3CCD 50 POP 3CCE 3D RETURNDATASIZE 3CCF 80 DUP1 3CD0 60 PUSH1 0x00 3CD2 81 DUP2 3CD3 14 EQ 3CD4 61 PUSH2 0x3cf9 3CD7 57 *JUMPI // Stack delta = -7 // Outputs[5] // { // @3CB0 memory[stack[-2]:stack[-2] + 0x20] = (memory[stack[-1]:stack[-1] + 0x20] & ~(0x0100 ** (0x20 - stack[-3]) - 0x01)) | (memory[stack[-2]:stack[-2] + 0x20] & 0x0100 ** (0x20 - stack[-3]) - 0x01) // @3CC9 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x00] = address(stack[-10]).call.gas(msg.gas).value(stack[-9])(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @3CCA stack[-10] = address(stack[-10]).call.gas(msg.gas).value(stack[-9])(memory[memory[0x40:0x60]:memory[0x40:0x60] + (stack[-4] + stack[-6]) - memory[0x40:0x60]]) // @3CCE stack[-9] = returndata.length // @3CCF stack[-8] = returndata.length // } // Block ends with conditional jump to 0x3cf9, if returndata.length == 0x00 label_3CD8: // Incoming jump from 0x3CD7, if not returndata.length == 0x00 // Inputs[6] // { // @3CDA memory[0x40:0x60] // @3CDB stack[-2] // @3CE2 returndata.length // @3CEA returndata.length // @3CED returndata.length // @3CF4 returndata[0x00:0x00 + returndata.length] // } 3CD8 60 PUSH1 0x40 3CDA 51 MLOAD 3CDB 91 SWAP2 3CDC 50 POP 3CDD 60 PUSH1 0x1f 3CDF 19 NOT 3CE0 60 PUSH1 0x3f 3CE2 3D RETURNDATASIZE 3CE3 01 ADD 3CE4 16 AND 3CE5 82 DUP3 3CE6 01 ADD 3CE7 60 PUSH1 0x40 3CE9 52 MSTORE 3CEA 3D RETURNDATASIZE 3CEB 82 DUP3 3CEC 52 MSTORE 3CED 3D RETURNDATASIZE 3CEE 60 PUSH1 0x00 3CF0 60 PUSH1 0x20 3CF2 84 DUP5 3CF3 01 ADD 3CF4 3E RETURNDATACOPY 3CF5 61 PUSH2 0x3cfe 3CF8 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @3CDB stack[-2] = memory[0x40:0x60] // @3CE9 memory[0x40:0x60] = memory[0x40:0x60] + (returndata.length + 0x3f & ~0x1f) // @3CEC memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = returndata.length // @3CF4 memory[memory[0x40:0x60] + 0x20:memory[0x40:0x60] + 0x20 + returndata.length] = returndata[0x00:0x00 + returndata.length] // } // Block ends with unconditional jump to 0x3cfe label_3CF9: // Incoming jump from 0x3CD7, if returndata.length == 0x00 // Inputs[5] // { // @3CFC stack[-2] // @3D00 stack[-4] // @3D02 stack[-3] // @3D02 stack[-5] // @3D09 stack[-7] // } 3CF9 5B JUMPDEST 3CFA 60 PUSH1 0x60 3CFC 91 SWAP2 3CFD 50 POP 3CFE 5B JUMPDEST 3CFF 50 POP 3D00 91 SWAP2 3D01 50 POP 3D02 91 SWAP2 3D03 50 POP 3D04 61 PUSH2 0x3d0e 3D07 82 DUP3 3D08 82 DUP3 3D09 86 DUP7 3D0A 61 PUSH2 0x3d1a 3D0D 56 *JUMP // Stack delta = +1 // Outputs[6] // { // @3D00 stack[-4] = 0x60 // @3D02 stack[-5] = stack[-3] // @3D04 stack[-3] = 0x3d0e // @3D07 stack[-2] = stack[-3] // @3D08 stack[-1] = 0x60 // @3D09 stack[0] = stack[-7] // } // Block ends with call to 0x3d1a, returns to 0x3D0E label_3D0E: // Incoming return from call to 0x3D1A at 0x3D0D // Incoming return from call to 0x3D1A at 0x3D0D // Inputs[4] // { // @3D0F stack[-1] // @3D0F stack[-4] // @3D13 stack[-9] // @3D14 stack[-8] // } 3D0E 5B JUMPDEST 3D0F 92 SWAP3 3D10 50 POP 3D11 50 POP 3D12 50 POP 3D13 94 SWAP5 3D14 93 SWAP4 3D15 50 POP 3D16 50 POP 3D17 50 POP 3D18 50 POP 3D19 56 *JUMP // Stack delta = -8 // Outputs[1] { @3D13 stack[-9] = stack[-1] } // Block ends with unconditional jump to stack[-9] label_3D1A: // Incoming call from 0x3D0D, returns to 0x3D0E // Incoming call from 0x3D0D, returns to 0x3D0E // Inputs[1] { @3D1D stack[-3] } 3D1A 5B JUMPDEST 3D1B 60 PUSH1 0x60 3D1D 83 DUP4 3D1E 15 ISZERO 3D1F 61 PUSH2 0x3d2a 3D22 57 *JUMPI // Stack delta = +1 // Outputs[1] { @3D1B stack[0] = 0x60 } // Block ends with conditional jump to 0x3d2a, if !stack[-3] label_3D23: // Incoming jump from 0x3D22, if not !stack[-3] // Inputs[2] // { // @3D23 stack[-3] // @3D24 stack[-1] // } 3D23 82 DUP3 3D24 90 SWAP1 3D25 50 POP 3D26 61 PUSH2 0x3ddf 3D29 56 *JUMP // Stack delta = +0 // Outputs[1] { @3D24 stack[-1] = stack[-3] } // Block ends with unconditional jump to 0x3ddf label_3D2A: // Incoming jump from 0x3D22, if !stack[-3] // Inputs[2] // { // @3D2D stack[-3] // @3D2E memory[stack[-3]:stack[-3] + 0x20] // } 3D2A 5B JUMPDEST 3D2B 60 PUSH1 0x00 3D2D 83 DUP4 3D2E 51 MLOAD 3D2F 11 GT 3D30 15 ISZERO 3D31 61 PUSH2 0x3d3d 3D34 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3d3d, if !(memory[stack[-3]:stack[-3] + 0x20] > 0x00) label_3D35: // Incoming jump from 0x3D34, if not !(memory[stack[-3]:stack[-3] + 0x20] > 0x00) // Inputs[3] // { // @3D35 stack[-3] // @3D36 memory[stack[-3]:stack[-3] + 0x20] // @3D3C memory[0x20 + stack[-3]:0x20 + stack[-3] + memory[stack[-3]:stack[-3] + 0x20]] // } 3D35 82 DUP3 3D36 51 MLOAD 3D37 80 DUP1 3D38 84 DUP5 3D39 60 PUSH1 0x20 3D3B 01 ADD 3D3C FD *REVERT // Stack delta = +1 // Outputs[2] // { // @3D36 stack[0] = memory[stack[-3]:stack[-3] + 0x20] // @3D3C revert(memory[0x20 + stack[-3]:0x20 + stack[-3] + memory[stack[-3]:stack[-3] + 0x20]]); // } // Block terminates label_3D3D: // Incoming jump from 0x3D34, if !(memory[stack[-3]:stack[-3] + 0x20] > 0x00) // Inputs[4] // { // @3D3E stack[-2] // @3D41 memory[0x40:0x60] // @3D75 memory[stack[-2]:stack[-2] + 0x20] // @3D7E memory[stack[-2]:stack[-2] + 0x20] // } 3D3D 5B JUMPDEST 3D3E 81 DUP2 3D3F 60 PUSH1 0x40 3D41 51 MLOAD 3D42 7F PUSH32 0x08c379a000000000000000000000000000000000000000000000000000000000 3D63 81 DUP2 3D64 52 MSTORE 3D65 60 PUSH1 0x04 3D67 01 ADD 3D68 80 DUP1 3D69 80 DUP1 3D6A 60 PUSH1 0x20 3D6C 01 ADD 3D6D 82 DUP3 3D6E 81 DUP2 3D6F 03 SUB 3D70 82 DUP3 3D71 52 MSTORE 3D72 83 DUP4 3D73 81 DUP2 3D74 81 DUP2 3D75 51 MLOAD 3D76 81 DUP2 3D77 52 MSTORE 3D78 60 PUSH1 0x20 3D7A 01 ADD 3D7B 91 SWAP2 3D7C 50 POP 3D7D 80 DUP1 3D7E 51 MLOAD 3D7F 90 SWAP1 3D80 60 PUSH1 0x20 3D82 01 ADD 3D83 90 SWAP1 3D84 80 DUP1 3D85 83 DUP4 3D86 83 DUP4 3D87 60 PUSH1 0x00 3D89 5B JUMPDEST 3D8A 83 DUP4 3D8B 81 DUP2 3D8C 10 LT 3D8D 15 ISZERO 3D8E 61 PUSH2 0x3da4 3D91 57 *JUMPI // Stack delta = +10 // Outputs[13] // { // @3D3E stack[0] = stack[-2] // @3D64 memory[memory[0x40:0x60]:memory[0x40:0x60] + 0x20] = 0x08c379a000000000000000000000000000000000000000000000000000000000 // @3D67 stack[1] = 0x04 + memory[0x40:0x60] // @3D68 stack[2] = 0x04 + memory[0x40:0x60] // @3D71 memory[0x04 + memory[0x40:0x60]:0x04 + memory[0x40:0x60] + 0x20] = (0x20 + 0x04 + memory[0x40:0x60]) - (0x04 + memory[0x40:0x60]) // @3D77 memory[0x20 + 0x04 + memory[0x40:0x60]:0x20 + 0x04 + memory[0x40:0x60] + 0x20] = memory[stack[-2]:stack[-2] + 0x20] // @3D7B stack[3] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @3D83 stack[4] = 0x20 + stack[-2] // @3D83 stack[5] = memory[stack[-2]:stack[-2] + 0x20] // @3D84 stack[6] = memory[stack[-2]:stack[-2] + 0x20] // @3D85 stack[7] = 0x20 + 0x20 + 0x04 + memory[0x40:0x60] // @3D86 stack[8] = 0x20 + stack[-2] // @3D87 stack[9] = 0x00 // } // Block ends with conditional jump to 0x3da4, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) label_3D92: // Incoming jump from 0x3D91, if not !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x3D91, if not !(stack[-1] < stack[-4]) // Inputs[4] // { // @3D92 stack[-1] // @3D93 stack[-2] // @3D95 memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @3D97 stack[-3] // } 3D92 80 DUP1 3D93 82 DUP3 3D94 01 ADD 3D95 51 MLOAD 3D96 81 DUP2 3D97 84 DUP5 3D98 01 ADD 3D99 52 MSTORE 3D9A 60 PUSH1 0x20 3D9C 81 DUP2 3D9D 01 ADD 3D9E 90 SWAP1 3D9F 50 POP 3DA0 61 PUSH2 0x3d89 3DA3 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @3D99 memory[stack[-3] + stack[-1]:stack[-3] + stack[-1] + 0x20] = memory[stack[-2] + stack[-1]:stack[-2] + stack[-1] + 0x20] // @3D9E stack[-1] = stack[-1] + 0x20 // } // Block ends with unconditional jump to 0x3d89 label_3DA4: // Incoming jump from 0x3D91, if !(0x00 < memory[stack[-2]:stack[-2] + 0x20]) // Incoming jump from 0x3D91, if !(stack[-1] < stack[-4]) // Inputs[3] // { // @3DA9 stack[-5] // @3DA9 stack[-6] // @3DAB stack[-7] // } 3DA4 5B JUMPDEST 3DA5 50 POP 3DA6 50 POP 3DA7 50 POP 3DA8 50 POP 3DA9 90 SWAP1 3DAA 50 POP 3DAB 90 SWAP1 3DAC 81 DUP2 3DAD 01 ADD 3DAE 90 SWAP1 3DAF 60 PUSH1 0x1f 3DB1 16 AND 3DB2 80 DUP1 3DB3 15 ISZERO 3DB4 61 PUSH2 0x3dd1 3DB7 57 *JUMPI // Stack delta = -5 // Outputs[2] // { // @3DAE stack[-7] = stack[-5] + stack[-7] // @3DB1 stack[-6] = 0x1f & stack[-5] // } // Block ends with conditional jump to 0x3dd1, if !(0x1f & stack[-5]) label_3DB8: // Incoming jump from 0x3DB7, if not !(0x1f & stack[-5]) // Inputs[6] // { // @3DB8 stack[-1] // @3DB9 stack[-2] // @3DBC memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @3DD3 stack[-5] // @3DD9 memory[0x40:0x60] // @3DDE memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]] // } 3DB8 80 DUP1 3DB9 82 DUP3 3DBA 03 SUB 3DBB 80 DUP1 3DBC 51 MLOAD 3DBD 60 PUSH1 0x01 3DBF 83 DUP4 3DC0 60 PUSH1 0x20 3DC2 03 SUB 3DC3 61 PUSH2 0x0100 3DC6 0A EXP 3DC7 03 SUB 3DC8 19 NOT 3DC9 16 AND 3DCA 81 DUP2 3DCB 52 MSTORE 3DCC 60 PUSH1 0x20 3DCE 01 ADD 3DCF 91 SWAP2 3DD0 50 POP 3DD1 5B JUMPDEST 3DD2 50 POP 3DD3 92 SWAP3 3DD4 50 POP 3DD5 50 POP 3DD6 50 POP 3DD7 60 PUSH1 0x40 3DD9 51 MLOAD 3DDA 80 DUP1 3DDB 91 SWAP2 3DDC 03 SUB 3DDD 90 SWAP1 3DDE FD *REVERT // Stack delta = -5 // Outputs[2] // { // @3DCB memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] = ~(0x0100 ** (0x20 - stack[-1]) - 0x01) & memory[stack[-2] - stack[-1]:stack[-2] - stack[-1] + 0x20] // @3DDE revert(memory[memory[0x40:0x60]:memory[0x40:0x60] + (0x20 + (stack[-2] - stack[-1])) - memory[0x40:0x60]]); // } // Block terminates label_3DDF: // Incoming jump from 0x3D29 // Inputs[3] // { // @3DE0 stack[-1] // @3DE0 stack[-5] // @3DE1 stack[-4] // } 3DDF 5B JUMPDEST 3DE0 93 SWAP4 3DE1 92 SWAP3 3DE2 50 POP 3DE3 50 POP 3DE4 50 POP 3DE5 56 *JUMP // Stack delta = -4 // Outputs[1] { @3DE0 stack[-5] = stack[-1] } // Block ends with unconditional jump to stack[-5] label_3DE6: // Incoming call from 0x2DF1, returns to 0x2DF2 // Incoming call from 0x138B, returns to 0x138C // Inputs[5] // { // @3DE7 stack[-3] // @3DE9 storage[stack[-3]] // @3E03 memory[0x00:0x20] // @3E0E stack[-2] // @3E0F stack[-1] // } 3DE6 5B JUMPDEST 3DE7 82 DUP3 3DE8 80 DUP1 3DE9 54 SLOAD 3DEA 60 PUSH1 0x01 3DEC 81 DUP2 3DED 60 PUSH1 0x01 3DEF 16 AND 3DF0 15 ISZERO 3DF1 61 PUSH2 0x0100 3DF4 02 MUL 3DF5 03 SUB 3DF6 16 AND 3DF7 60 PUSH1 0x02 3DF9 90 SWAP1 3DFA 04 DIV 3DFB 90 SWAP1 3DFC 60 PUSH1 0x00 3DFE 52 MSTORE 3DFF 60 PUSH1 0x20 3E01 60 PUSH1 0x00 3E03 20 SHA3 3E04 90 SWAP1 3E05 60 PUSH1 0x1f 3E07 01 ADD 3E08 60 PUSH1 0x20 3E0A 90 SWAP1 3E0B 04 DIV 3E0C 81 DUP2 3E0D 01 ADD 3E0E 92 SWAP3 3E0F 82 DUP3 3E10 60 PUSH1 0x1f 3E12 10 LT 3E13 61 PUSH2 0x3e27 3E16 57 *JUMPI // Stack delta = +2 // Outputs[4] // { // @3DFE memory[0x00:0x20] = stack[-3] // @3E04 stack[0] = keccak256(memory[0x00:0x20]) // @3E0E stack[1] = stack[-2] // @3E0E stack[-2] = keccak256(memory[0x00:0x20]) + (0x1f + (0x0100 * !(0x01 & storage[stack[-3]]) - 0x01 & storage[stack[-3]]) / 0x02) / 0x20 // } // Block ends with conditional jump to 0x3e27, if 0x1f < stack[-1] label_3E17: // Incoming jump from 0x3E16, if not 0x1f < stack[-1] // Inputs[4] // { // @3E17 stack[-1] // @3E18 memory[stack[-1]:stack[-1] + 0x20] // @3E1D stack[-3] // @3E21 stack[-5] // } 3E17 80 DUP1 3E18 51 MLOAD 3E19 60 PUSH1 0xff 3E1B 19 NOT 3E1C 16 AND 3E1D 83 DUP4 3E1E 80 DUP1 3E1F 01 ADD 3E20 17 OR 3E21 85 DUP6 3E22 55 SSTORE 3E23 61 PUSH2 0x3e55 3E26 56 *JUMP // Stack delta = +0 // Outputs[1] { @3E22 storage[stack[-5]] = stack[-3] + stack[-3] | (~0xff & memory[stack[-1]:stack[-1] + 0x20]) } // Block ends with unconditional jump to 0x3e55 label_3E27: // Incoming jump from 0x3E16, if 0x1f < stack[-1] // Inputs[2] // { // @3E28 stack[-3] // @3E2E stack[-5] // } 3E27 5B JUMPDEST 3E28 82 DUP3 3E29 80 DUP1 3E2A 01 ADD 3E2B 60 PUSH1 0x01 3E2D 01 ADD 3E2E 85 DUP6 3E2F 55 SSTORE 3E30 82 DUP3 3E31 15 ISZERO 3E32 61 PUSH2 0x3e55 3E35 57 *JUMPI // Stack delta = +0 // Outputs[1] { @3E2F storage[stack[-5]] = 0x01 + stack[-3] + stack[-3] } // Block ends with conditional jump to 0x3e55, if !stack[-3] label_3E36: // Incoming jump from 0x3E35, if not !stack[-3] // Inputs[2] // { // @3E36 stack[-3] // @3E36 stack[-1] // } 3E36 91 SWAP2 3E37 82 DUP3 3E38 01 ADD 3E39 5B JUMPDEST 3E3A 82 DUP3 3E3B 81 DUP2 3E3C 11 GT 3E3D 15 ISZERO 3E3E 61 PUSH2 0x3e54 3E41 57 *JUMPI // Stack delta = +0 // Outputs[2] // { // @3E36 stack[-3] = stack[-1] // @3E38 stack[-1] = stack[-1] + stack[-3] // } // Block ends with conditional jump to 0x3e54, if !(stack[-1] + stack[-3] > stack[-1]) label_3E42: // Incoming jump from 0x3E41, if not !(stack[-1] > stack[-3]) // Incoming jump from 0x3E41, if not !(stack[-1] + stack[-3] > stack[-1]) // Inputs[4] // { // @3E42 stack[-3] // @3E43 memory[stack[-3]:stack[-3] + 0x20] // @3E44 stack[-2] // @3E46 stack[-1] // } 3E42 82 DUP3 3E43 51 MLOAD 3E44 82 DUP3 3E45 55 SSTORE 3E46 91 SWAP2 3E47 60 PUSH1 0x20 3E49 01 ADD 3E4A 91 SWAP2 3E4B 90 SWAP1 3E4C 60 PUSH1 0x01 3E4E 01 ADD 3E4F 90 SWAP1 3E50 61 PUSH2 0x3e39 3E53 56 *JUMP // Stack delta = +0 // Outputs[4] // { // @3E45 storage[stack[-2]] = memory[stack[-3]:stack[-3] + 0x20] // @3E4A stack[-3] = 0x20 + stack[-3] // @3E4F stack[-2] = 0x01 + stack[-2] // @3E4F stack[-1] = stack[-1] // } // Block ends with unconditional jump to 0x3e39 label_3E54: // Incoming jump from 0x3E41, if !(stack[-1] > stack[-3]) // Incoming jump from 0x3E41, if !(stack[-1] + stack[-3] > stack[-1]) 3E54 5B JUMPDEST // Stack delta = +0 // Block continues label_3E55: // Incoming jump from 0x3E26 // Incoming jump from 0x3E35, if !stack[-3] // Incoming jump from 0x3E54 // Inputs[3] // { // @3E57 stack[-2] // @3E57 stack[-3] // @3E5C stack[-4] // } 3E55 5B JUMPDEST 3E56 50 POP 3E57 90 SWAP1 3E58 50 POP 3E59 61 PUSH2 0x3e62 3E5C 91 SWAP2 3E5D 90 SWAP1 3E5E 61 PUSH2 0x3e66 3E61 56 *JUMP // Stack delta = -1 // Outputs[3] // { // @3E5C stack[-4] = 0x3e62 // @3E5D stack[-2] = stack[-2] // @3E5D stack[-3] = stack[-4] // } // Block ends with call to 0x3e66, returns to 0x3E62 label_3E62: // Incoming return from call to 0x3E66 at 0x3E61 // Inputs[2] // { // @3E64 stack[-2] // @3E64 stack[-3] // } 3E62 5B JUMPDEST 3E63 50 POP 3E64 90 SWAP1 3E65 56 *JUMP // Stack delta = -2 // Outputs[1] { @3E64 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] label_3E66: // Incoming call from 0x3E61, returns to 0x3E62 // Inputs[2] // { // @3E68 stack[-1] // @3E69 stack[-2] // } 3E66 5B JUMPDEST 3E67 5B JUMPDEST 3E68 80 DUP1 3E69 82 DUP3 3E6A 11 GT 3E6B 15 ISZERO 3E6C 61 PUSH2 0x3e7f 3E6F 57 *JUMPI // Stack delta = +0 // Block ends with conditional jump to 0x3e7f, if !(stack[-2] > stack[-1]) label_3E70: // Incoming jump from 0x3E6F, if not !(stack[-2] > stack[-1]) // Incoming jump from 0x3E6F, if not !(stack[-2] > stack[-1]) // Inputs[1] { @3E72 stack[-1] } 3E70 60 PUSH1 0x00 3E72 81 DUP2 3E73 60 PUSH1 0x00 3E75 90 SWAP1 3E76 55 SSTORE 3E77 50 POP 3E78 60 PUSH1 0x01 3E7A 01 ADD 3E7B 61 PUSH2 0x3e67 3E7E 56 *JUMP // Stack delta = +0 // Outputs[2] // { // @3E76 storage[stack[-1]] = 0x00 // @3E7A stack[-1] = 0x01 + stack[-1] // } // Block ends with unconditional jump to 0x3e67 label_3E7F: // Incoming jump from 0x3E6F, if !(stack[-2] > stack[-1]) // Incoming jump from 0x3E6F, if !(stack[-2] > stack[-1]) // Inputs[2] // { // @3E81 stack[-3] // @3E81 stack[-2] // } 3E7F 5B JUMPDEST 3E80 50 POP 3E81 90 SWAP1 3E82 56 *JUMP // Stack delta = -2 // Outputs[1] { @3E81 stack[-3] = stack[-2] } // Block ends with unconditional jump to stack[-3] 3E83 FE *ASSERT 3E84 45 GASLIMIT 3E85 6E PUSH15 0x756d657261626c655365743a20696e 3E95 64 PUSH5 0x6578206f75 3E9B 74 PUSH21 0x206f6620626f756e64734552433732313a20747261 3EB1 6E PUSH15 0x7366657220746f206e6f6e20455243 3EC1 37 CALLDATACOPY 3EC2 32 ORIGIN 3EC3 31 BALANCE 3EC4 52 MSTORE 3EC5 65 PUSH6 0x636569766572 3ECC 20 SHA3 3ECD 69 PUSH10 0x6d706c656d656e746572 3ED8 4F 4F 3ED9 77 PUSH24 0x6e61626c653a206e6577206f776e65722069732074686520 3EF2 7A PUSH27 0x65726f20616464726573734552433732313a207472616e73666572 3F0E 20 SHA3 3F0F 74 PUSH21 0x6f20746865207a65726f2061646472657373416464 3F25 72 PUSH19 0x6573733a20696e73756666696369656e742062 3F39 61 PUSH2 0x6c61 3F3C 6E PUSH15 0x636520666f722063616c6c45524337 3F4C 32 ORIGIN 3F4D 31 BALANCE 3F4E 3A GASPRICE 3F4F 20 SHA3 3F50 6F PUSH16 0x70657261746f7220717565727920666f 3F61 72 PUSH19 0x206e6f6e6578697374656e7420746f6b656e43 3F75 61 PUSH2 0x6e20 3F78 6F PUSH16 0x6e6c79206d696e7420323020746f6b65 3F89 6E PUSH15 0x7320617420612074696d6545524337 3F99 32 ORIGIN 3F9A 31 BALANCE 3F9B 3A GASPRICE 3F9C 20 SHA3 3F9D 61 PUSH2 0x7070 3FA0 72 PUSH19 0x6f76652063616c6c6572206973206e6f74206f 3FB4 77 PUSH24 0x6e6572206e6f7220617070726f76656420666f7220616c6c 3FCD 45 GASLIMIT 3FCE 52 MSTORE 3FCF 43 NUMBER 3FD0 37 CALLDATACOPY 3FD1 32 ORIGIN 3FD2 31 BALANCE 3FD3 3A GASPRICE 3FD4 20 SHA3 3FD5 62 PUSH3 0x616c61 3FD9 6E PUSH15 0x636520717565727920666f72207468 3FE9 65 PUSH6 0x207a65726f20 3FF0 61 PUSH2 0x6464 3FF3 72 PUSH19 0x6573734552433732313a206f776e6572207175 4007 65 PUSH6 0x727920666f72 400E 20 SHA3 400F 6E PUSH15 0x6f6e6578697374656e7420746f6b65 401F 6E PUSH15 0x456e756d657261626c654d61703a20 402F 69 PUSH10 0x6e646578206f7574206f 403A 66 PUSH7 0x20626f756e6473 4042 50 POP 4043 75 PUSH22 0x72636861736520776f756c6420657863656564206d61 405A 78 PUSH25 0x20737570706c79206f662041706573536166654d6174683a20 4074 6D PUSH14 0x756c7469706c69636174696f6e20 4083 6F PUSH16 0x766572666c6f774552433732313a2061 4094 70 PUSH17 0x70726f76656420717565727920666f7220 40A6 6E PUSH15 0x6f6e6578697374656e7420746f6b65 40B6 6E PUSH15 0x4552433732313a207472616e736665 40C6 72 PUSH19 0x206f6620746f6b656e2074686174206973206e 40DA 6F PUSH16 0x74206f776e4552433732314d65746164 40EB 61 PUSH2 0x7461 40EE 3A GASPRICE 40EF 20 SHA3 40F0 55 SSTORE 40F1 52 MSTORE 40F2 49 49 40F3 20 SHA3 40F4 71 PUSH18 0x7565727920666f72206e6f6e657869737465 4107 6E PUSH15 0x7420746f6b656e4552433732313a20 4117 61 PUSH2 0x7070 411A 72 PUSH19 0x6f76616c20746f2063757272656e74206f776e 412E 65 PUSH6 0x724552433732 4135 31 BALANCE 4136 3A GASPRICE 4137 20 SHA3 4138 74 PUSH21 0x72616e736665722063616c6c6572206973206e6f74 414E 20 SHA3 414F 6F PUSH16 0x776e6572206e6f7220617070726f7665 4160 64 PUSH5 0xa264697066 4166 73 PUSH20 0x58221220b0e64d1fa6c4dbeb9c6f54607d7e1996 417B 94 SWAP5 417C 3F EXTCODEHASH 417D E2 E2 417E 76 PUSH23 0x24a80652f57b53fda084621b64736f6c63430007000033